Line data Source code
1 : // MACHINE GENERATED SOURCE FILE WITH ROSE (Grammar.h)--- DO NOT MODIFY!
2 :
3 : #include "sage3basic.h"
4 :
5 : #ifndef ROSE_USE_INTERNAL_FRONTEND_DEVELOPMENT
6 : #include "AST_FILE_IO.h"
7 : #endif
8 : // The header file ("rose_config.h") should only be included by source files that require it.
9 : #include "rose_config.h"
10 :
11 : #if _MSC_VER
12 : #define USE_CPP_NEW_DELETE_OPERATORS 0
13 : #endif
14 :
15 : #define ROSE_ALLOC_TRACE 0
16 : #undef mprintf
17 : #define mprintf Rose::Diagnostics::mfprintf(Rose::ir_node_mlog[Rose::Diagnostics::DEBUG])
18 :
19 :
20 : using namespace std;
21 :
22 : TerminalNamesType Cxx_GrammarTerminalNames[691] = {
23 : {(VariantT)0, "<ERROR: unknown VariantT>"},
24 : {(VariantT)1, "SgAccessModifier"},
25 : {(VariantT)2, "SgActualArgumentExpression"},
26 : {(VariantT)3, "SgAddOp"},
27 : {(VariantT)4, "SgAddressOfOp"},
28 : {(VariantT)5, "SgAggregateInitializer"},
29 : {(VariantT)6, "SgAliasSymbol"},
30 : {(VariantT)7, "SgAllocateStatement"},
31 : {(VariantT)8, "SgAndAssignOp"},
32 : {(VariantT)9, "SgAndOp"},
33 : {(VariantT)10, "SgArithmeticIfStatement"},
34 : {(VariantT)11, "SgArrayType"},
35 : {(VariantT)12, "SgArrowExp"},
36 : {(VariantT)13, "SgArrowStarOp"},
37 : {(VariantT)14, "SgAsmOp"},
38 : {(VariantT)15, "SgAsmStmt"},
39 : {(VariantT)16, "SgAssertStmt"},
40 : {(VariantT)17, "SgAssignInitializer"},
41 : {(VariantT)18, "SgAssignOp"},
42 : {(VariantT)19, "SgAssignStatement"},
43 : {(VariantT)20, "SgAssignedGotoStatement"},
44 : {(VariantT)21, "SgAssociateStatement"},
45 : {(VariantT)22, "SgAsteriskShapeExp"},
46 : {(VariantT)23, "SgAttribute"},
47 : {(VariantT)24, "SgAttributeSpecificationStatement"},
48 : {(VariantT)25, "SgAutoType"},
49 : {(VariantT)26, "SgAwaitExpression"},
50 : {(VariantT)27, "SgBackspaceStatement"},
51 : {(VariantT)28, "SgBaseClass"},
52 : {(VariantT)29, "SgExpBaseClass"},
53 : {(VariantT)30, "SgBaseClassModifier"},
54 : {(VariantT)31, "SgBasicBlock"},
55 : {(VariantT)32, "SgBidirectionalGraph"},
56 : {(VariantT)33, "SgBinaryComposite"},
57 : {(VariantT)34, "SgBinaryOp"},
58 : {(VariantT)35, "SgBitAndOp"},
59 : {(VariantT)36, "SgBitAttribute"},
60 : {(VariantT)37, "SgBitComplementOp"},
61 : {(VariantT)38, "SgBitEqvOp"},
62 : {(VariantT)39, "SgBitOrOp"},
63 : {(VariantT)40, "SgBitXorOp"},
64 : {(VariantT)41, "SgBlockDataStatement"},
65 : {(VariantT)42, "SgBoolValExp"},
66 : {(VariantT)43, "SgBreakStmt"},
67 : {(VariantT)44, "SgBracedInitializer"},
68 : {(VariantT)45, "SgC_PreprocessorDirectiveStatement"},
69 : {(VariantT)46, "SgCaseOptionStmt"},
70 : {(VariantT)47, "SgCastExp"},
71 : {(VariantT)48, "SgCatchOptionStmt"},
72 : {(VariantT)49, "SgCatchStatementSeq"},
73 : {(VariantT)50, "SgCharVal"},
74 : {(VariantT)51, "SgChar16Val"},
75 : {(VariantT)52, "SgChar32Val"},
76 : {(VariantT)53, "SgChooseExpression"},
77 : {(VariantT)54, "SgClassDecl_attr"},
78 : {(VariantT)55, "SgClassDeclaration"},
79 : {(VariantT)56, "SgClassDefinition"},
80 : {(VariantT)57, "SgClassNameRefExp"},
81 : {(VariantT)58, "SgClassSymbol"},
82 : {(VariantT)59, "SgClassType"},
83 : {(VariantT)60, "SgClinkageDeclarationStatement"},
84 : {(VariantT)61, "SgClinkageEndStatement"},
85 : {(VariantT)62, "SgClinkageStartStatement"},
86 : {(VariantT)63, "SgCloseStatement"},
87 : {(VariantT)64, "SgColonShapeExp"},
88 : {(VariantT)65, "SgCommaOpExp"},
89 : {(VariantT)66, "SgCommonBlock"},
90 : {(VariantT)67, "SgCommonBlockObject"},
91 : {(VariantT)68, "SgCommonSymbol"},
92 : {(VariantT)69, "SgComplexVal"},
93 : {(VariantT)70, "SgComprehension"},
94 : {(VariantT)71, "SgComprehensionList"},
95 : {(VariantT)72, "SgCompoundAssignOp"},
96 : {(VariantT)73, "SgCompoundInitializer"},
97 : {(VariantT)74, "SgCompoundLiteralExp"},
98 : {(VariantT)75, "SgComputedGotoStatement"},
99 : {(VariantT)76, "SgConcatenationOp"},
100 : {(VariantT)77, "SgConditionalExp"},
101 : {(VariantT)78, "SgConjugateOp"},
102 : {(VariantT)79, "SgConstVolatileModifier"},
103 : {(VariantT)80, "SgConstructorInitializer"},
104 : {(VariantT)81, "SgContainsStatement"},
105 : {(VariantT)82, "SgContinueStmt"},
106 : {(VariantT)83, "SgCtorInitializerList"},
107 : {(VariantT)84, "SgDataStatementGroup"},
108 : {(VariantT)85, "SgDataStatementObject"},
109 : {(VariantT)86, "SgDataStatementValue"},
110 : {(VariantT)87, "SgDeadIfDirectiveStatement"},
111 : {(VariantT)88, "SgDeallocateStatement"},
112 : {(VariantT)89, "SgDeclarationModifier"},
113 : {(VariantT)90, "SgDeclarationScope"},
114 : {(VariantT)91, "SgDeclarationStatement"},
115 : {(VariantT)92, "SgDeclType"},
116 : {(VariantT)93, "SgDefaultOptionStmt"},
117 : {(VariantT)94, "SgDefaultSymbol"},
118 : {(VariantT)95, "SgDefineDirectiveStatement"},
119 : {(VariantT)96, "SgDeleteExp"},
120 : {(VariantT)97, "SgDerivedTypeStatement"},
121 : {(VariantT)98, "SgDesignatedInitializer"},
122 : {(VariantT)99, "SgDictionaryComprehension"},
123 : {(VariantT)100, "SgDictionaryExp"},
124 : {(VariantT)101, "SgDimensionObject"},
125 : {(VariantT)102, "SgDirectedGraph"},
126 : {(VariantT)103, "SgDirectedGraphEdge"},
127 : {(VariantT)104, "SgDirectedGraphNode"},
128 : {(VariantT)105, "SgDirectory"},
129 : {(VariantT)106, "SgDirectoryList"},
130 : {(VariantT)107, "SgDivAssignOp"},
131 : {(VariantT)108, "SgDivideOp"},
132 : {(VariantT)109, "SgDoWhileStmt"},
133 : {(VariantT)110, "SgDotExp"},
134 : {(VariantT)111, "SgDotStarOp"},
135 : {(VariantT)112, "SgDoubleVal"},
136 : {(VariantT)113, "SgElaboratedTypeModifier"},
137 : {(VariantT)114, "SgElementwiseOp"},
138 : {(VariantT)115, "SgElementwiseAddOp"},
139 : {(VariantT)116, "SgElementwiseDivideOp"},
140 : {(VariantT)117, "SgElementwiseLeftDivideOp"},
141 : {(VariantT)118, "SgElementwiseMultiplyOp"},
142 : {(VariantT)119, "SgElementwisePowerOp"},
143 : {(VariantT)120, "SgElementwiseSubtractOp"},
144 : {(VariantT)121, "SgElseDirectiveStatement"},
145 : {(VariantT)122, "SgElseWhereStatement"},
146 : {(VariantT)123, "SgElseifDirectiveStatement"},
147 : {(VariantT)124, "SgEmptyDeclaration"},
148 : {(VariantT)125, "SgEmptyDirectiveStatement"},
149 : {(VariantT)126, "SgEndfileStatement"},
150 : {(VariantT)127, "SgEndifDirectiveStatement"},
151 : {(VariantT)128, "SgEntryStatement"},
152 : {(VariantT)129, "SgEnumDeclaration"},
153 : {(VariantT)130, "SgEnumFieldSymbol"},
154 : {(VariantT)131, "SgEnumSymbol"},
155 : {(VariantT)132, "SgEnumType"},
156 : {(VariantT)133, "SgEnumVal"},
157 : {(VariantT)134, "SgEqualityOp"},
158 : {(VariantT)135, "SgEquivalenceStatement"},
159 : {(VariantT)136, "SgErrorDirectiveStatement"},
160 : {(VariantT)137, "SgExecStatement"},
161 : {(VariantT)138, "SgExponentiationOp"},
162 : {(VariantT)139, "SgExponentiationAssignOp"},
163 : {(VariantT)140, "SgExprListExp"},
164 : {(VariantT)141, "SgExprStatement"},
165 : {(VariantT)142, "SgExpression"},
166 : {(VariantT)143, "SgExpressionRoot"},
167 : {(VariantT)144, "SgFile"},
168 : {(VariantT)145, "SgFileList"},
169 : {(VariantT)146, "SgFloatVal"},
170 : {(VariantT)147, "SgFloat128Val"},
171 : {(VariantT)148, "SgFloat80Val"},
172 : {(VariantT)149, "SgFoldExpression"},
173 : {(VariantT)150, "SgFlushStatement"},
174 : {(VariantT)151, "SgForAllStatement"},
175 : {(VariantT)152, "SgForInitStatement"},
176 : {(VariantT)153, "SgForStatement"},
177 : {(VariantT)154, "SgFormatItem"},
178 : {(VariantT)155, "SgFormatItemList"},
179 : {(VariantT)156, "SgFormatStatement"},
180 : {(VariantT)157, "SgFortranDo"},
181 : {(VariantT)158, "SgFortranIncludeLine"},
182 : {(VariantT)159, "SgFortranNonblockedDo"},
183 : {(VariantT)160, "SgFuncDecl_attr"},
184 : {(VariantT)161, "SgFunctionCallExp"},
185 : {(VariantT)162, "SgFunctionDeclaration"},
186 : {(VariantT)163, "SgFunctionDefinition"},
187 : {(VariantT)164, "SgFunctionParameterScope"},
188 : {(VariantT)165, "SgFunctionModifier"},
189 : {(VariantT)166, "SgFunctionParameterList"},
190 : {(VariantT)167, "SgFunctionParameterRefExp"},
191 : {(VariantT)168, "SgFunctionParameterTypeList"},
192 : {(VariantT)169, "SgFunctionRefExp"},
193 : {(VariantT)170, "SgFunctionSymbol"},
194 : {(VariantT)171, "SgFunctionType"},
195 : {(VariantT)172, "SgFunctionTypeSymbol"},
196 : {(VariantT)173, "SgFunctionTypeTable"},
197 : {(VariantT)174, "SgTypeTable"},
198 : {(VariantT)175, "SgGlobal"},
199 : {(VariantT)176, "SgGotoStatement"},
200 : {(VariantT)177, "SgGraph"},
201 : {(VariantT)178, "SgGraphEdge"},
202 : {(VariantT)179, "SgGraphEdgeList"},
203 : {(VariantT)180, "SgGraphNode"},
204 : {(VariantT)181, "SgGraphNodeList"},
205 : {(VariantT)182, "SgGreaterOrEqualOp"},
206 : {(VariantT)183, "SgGreaterThanOp"},
207 : {(VariantT)184, "SgIOItemExpression"},
208 : {(VariantT)185, "SgIOStatement"},
209 : {(VariantT)186, "SgIdentDirectiveStatement"},
210 : {(VariantT)187, "SgIfDirectiveStatement"},
211 : {(VariantT)188, "SgIfStmt"},
212 : {(VariantT)189, "SgIfdefDirectiveStatement"},
213 : {(VariantT)190, "SgIfndefDirectiveStatement"},
214 : {(VariantT)191, "SgImageControlStatement"},
215 : {(VariantT)192, "SgImagPartOp"},
216 : {(VariantT)193, "SgImplicitStatement"},
217 : {(VariantT)194, "SgImpliedDo"},
218 : {(VariantT)195, "SgImportStatement"},
219 : {(VariantT)196, "SgIncidenceDirectedGraph"},
220 : {(VariantT)197, "SgIncidenceUndirectedGraph"},
221 : {(VariantT)198, "SgIncludeDirectiveStatement"},
222 : {(VariantT)199, "SgIncludeFile"},
223 : {(VariantT)200, "SgIncludeNextDirectiveStatement"},
224 : {(VariantT)201, "SgInitializedName"},
225 : {(VariantT)202, "SgInitializer"},
226 : {(VariantT)203, "SgInquireStatement"},
227 : {(VariantT)204, "SgIntKeyedBidirectionalGraph"},
228 : {(VariantT)205, "SgIntVal"},
229 : {(VariantT)206, "SgIntegerDivideOp"},
230 : {(VariantT)207, "SgIntegerDivideAssignOp"},
231 : {(VariantT)208, "SgInterfaceBody"},
232 : {(VariantT)209, "SgHeaderFileBody"},
233 : {(VariantT)210, "SgHeaderFileReport"},
234 : {(VariantT)211, "SgInterfaceStatement"},
235 : {(VariantT)212, "SgInterfaceSymbol"},
236 : {(VariantT)213, "SgIntrinsicSymbol"},
237 : {(VariantT)214, "SgIsOp"},
238 : {(VariantT)215, "SgIsNotOp"},
239 : {(VariantT)216, "SgIorAssignOp"},
240 : {(VariantT)217, "SgKeyDatumPair"},
241 : {(VariantT)218, "SgCudaKernelExecConfig"},
242 : {(VariantT)219, "SgCudaKernelCallExp"},
243 : {(VariantT)220, "SgLabelRefExp"},
244 : {(VariantT)221, "SgLabelStatement"},
245 : {(VariantT)222, "SgLabelSymbol"},
246 : {(VariantT)223, "SgLambdaCapture"},
247 : {(VariantT)224, "SgLambdaCaptureList"},
248 : {(VariantT)225, "SgLambdaExp"},
249 : {(VariantT)226, "SgLambdaRefExp"},
250 : {(VariantT)227, "SgLeftDivideOp"},
251 : {(VariantT)228, "SgLessOrEqualOp"},
252 : {(VariantT)229, "SgLessThanOp"},
253 : {(VariantT)230, "SgLineDirectiveStatement"},
254 : {(VariantT)231, "SgLinemarkerDirectiveStatement"},
255 : {(VariantT)232, "SgLinkageModifier"},
256 : {(VariantT)233, "SgListComprehension"},
257 : {(VariantT)234, "SgListExp"},
258 : {(VariantT)235, "SgLocatedNode"},
259 : {(VariantT)236, "SgLocatedNodeSupport"},
260 : {(VariantT)237, "SgLongDoubleVal"},
261 : {(VariantT)238, "SgLongIntVal"},
262 : {(VariantT)239, "SgLongLongIntVal"},
263 : {(VariantT)240, "SgLshiftAssignOp"},
264 : {(VariantT)241, "SgLshiftOp"},
265 : {(VariantT)242, "SgMagicColonExp"},
266 : {(VariantT)243, "SgMatrixExp"},
267 : {(VariantT)244, "SgMatrixTransposeOp"},
268 : {(VariantT)245, "SgMemberFunctionDeclaration"},
269 : {(VariantT)246, "SgMemberFunctionRefExp"},
270 : {(VariantT)247, "SgMemberFunctionSymbol"},
271 : {(VariantT)248, "SgMemberFunctionType"},
272 : {(VariantT)249, "SgMembershipOp"},
273 : {(VariantT)250, "SgMicrosoftAttributeDeclaration"},
274 : {(VariantT)251, "SgMinusAssignOp"},
275 : {(VariantT)252, "SgMinusMinusOp"},
276 : {(VariantT)253, "SgMinusOp"},
277 : {(VariantT)254, "SgModAssignOp"},
278 : {(VariantT)255, "SgModOp"},
279 : {(VariantT)256, "SgModifier"},
280 : {(VariantT)257, "SgModifierNodes"},
281 : {(VariantT)258, "SgModifierType"},
282 : {(VariantT)259, "SgModuleStatement"},
283 : {(VariantT)260, "SgModuleSymbol"},
284 : {(VariantT)261, "SgMultAssignOp"},
285 : {(VariantT)262, "SgMultiplyOp"},
286 : {(VariantT)263, "SgName"},
287 : {(VariantT)264, "SgNameGroup"},
288 : {(VariantT)265, "SgNamedType"},
289 : {(VariantT)266, "SgNamelistStatement"},
290 : {(VariantT)267, "SgNamespaceAliasDeclarationStatement"},
291 : {(VariantT)268, "SgNamespaceDeclarationStatement"},
292 : {(VariantT)269, "SgNamespaceDefinitionStatement"},
293 : {(VariantT)270, "SgNamespaceSymbol"},
294 : {(VariantT)271, "SgNaryOp"},
295 : {(VariantT)272, "SgNaryBooleanOp"},
296 : {(VariantT)273, "SgNaryComparisonOp"},
297 : {(VariantT)274, "SgNewExp"},
298 : {(VariantT)275, "SgNode"},
299 : {(VariantT)276, "SgNoexceptOp"},
300 : {(VariantT)277, "SgNotEqualOp"},
301 : {(VariantT)278, "SgNotOp"},
302 : {(VariantT)279, "SgNonMembershipOp"},
303 : {(VariantT)280, "SgNonrealDecl"},
304 : {(VariantT)281, "SgNonrealRefExp"},
305 : {(VariantT)282, "SgNonrealSymbol"},
306 : {(VariantT)283, "SgNonrealType"},
307 : {(VariantT)284, "SgNonrealBaseClass"},
308 : {(VariantT)285, "SgNullExpression"},
309 : {(VariantT)286, "SgNullptrValExp"},
310 : {(VariantT)287, "SgNullStatement"},
311 : {(VariantT)288, "SgNullifyStatement"},
312 : {(VariantT)289, "SgOmpAtomicStatement"},
313 : {(VariantT)290, "SgOmpBarrierStatement"},
314 : {(VariantT)291, "SgOmpCriticalStatement"},
315 : {(VariantT)292, "SgUpirFieldBodyStatement"},
316 : {(VariantT)293, "SgUpirBodyStatement"},
317 : {(VariantT)294, "SgUpirFieldStatement"},
318 : {(VariantT)295, "SgOmpDoStatement"},
319 : {(VariantT)296, "SgOmpFlushStatement"},
320 : {(VariantT)297, "SgOmpAllocateStatement"},
321 : {(VariantT)298, "SgOmpDeclareSimdStatement"},
322 : {(VariantT)299, "SgUpirWorksharingStatement"},
323 : {(VariantT)300, "SgOmpForSimdStatement"},
324 : {(VariantT)301, "SgOmpMasterStatement"},
325 : {(VariantT)302, "SgOmpTaskyieldStatement"},
326 : {(VariantT)303, "SgOmpMetadirectiveStatement"},
327 : {(VariantT)304, "SgOmpOrderedStatement"},
328 : {(VariantT)305, "SgOmpOrderedDependStatement"},
329 : {(VariantT)306, "SgUpirSpmdStatement"},
330 : {(VariantT)307, "SgOmpTeamsStatement"},
331 : {(VariantT)308, "SgOmpCancellationPointStatement"},
332 : {(VariantT)309, "SgOmpDeclareMapperStatement"},
333 : {(VariantT)310, "SgOmpCancelStatement"},
334 : {(VariantT)311, "SgOmpTaskgroupStatement"},
335 : {(VariantT)312, "SgOmpDepobjStatement"},
336 : {(VariantT)313, "SgOmpDistributeStatement"},
337 : {(VariantT)314, "SgOmpLoopStatement"},
338 : {(VariantT)315, "SgOmpScanStatement"},
339 : {(VariantT)316, "SgOmpTaskloopStatement"},
340 : {(VariantT)317, "SgOmpTargetEnterDataStatement"},
341 : {(VariantT)318, "SgOmpTargetExitDataStatement"},
342 : {(VariantT)319, "SgOmpSectionStatement"},
343 : {(VariantT)320, "SgOmpSectionsStatement"},
344 : {(VariantT)321, "SgOmpSingleStatement"},
345 : {(VariantT)322, "SgOmpTaskStatement"},
346 : {(VariantT)323, "SgOmpTaskwaitStatement"},
347 : {(VariantT)324, "SgOmpThreadprivateStatement"},
348 : {(VariantT)325, "SgOmpWorkshareStatement"},
349 : {(VariantT)326, "SgUpirTaskStatement"},
350 : {(VariantT)327, "SgOmpTargetDataStatement"},
351 : {(VariantT)328, "SgOmpTargetParallelForStatement"},
352 : {(VariantT)329, "SgOmpTargetUpdateStatement"},
353 : {(VariantT)330, "SgOmpRequiresStatement"},
354 : {(VariantT)331, "SgOmpTargetParallelStatement"},
355 : {(VariantT)332, "SgOmpTargetParallelForSimdStatement"},
356 : {(VariantT)333, "SgOmpTargetParallelLoopStatement"},
357 : {(VariantT)334, "SgOmpTargetSimdStatement"},
358 : {(VariantT)335, "SgOmpTargetTeamsStatement"},
359 : {(VariantT)336, "SgOmpTargetTeamsDistributeStatement"},
360 : {(VariantT)337, "SgOmpTargetTeamsDistributeSimdStatement"},
361 : {(VariantT)338, "SgOmpTargetTeamsLoopStatement"},
362 : {(VariantT)339, "SgOmpTargetTeamsDistributeParallelForStatement"},
363 : {(VariantT)340, "SgOmpTargetTeamsDistributeParallelForSimdStatement"},
364 : {(VariantT)341, "SgOmpDistributeSimdStatement"},
365 : {(VariantT)342, "SgOmpDistributeParallelForStatement"},
366 : {(VariantT)343, "SgOmpDistributeParallelForSimdStatement"},
367 : {(VariantT)344, "SgOmpTaskloopSimdStatement"},
368 : {(VariantT)345, "SgOmpMasterTaskloopSimdStatement"},
369 : {(VariantT)346, "SgOmpParallelMasterTaskloopStatement"},
370 : {(VariantT)347, "SgOmpParallelMasterTaskloopSimdStatement"},
371 : {(VariantT)348, "SgOmpTeamsDistributeStatement"},
372 : {(VariantT)349, "SgOmpTeamsDistributeSimdStatement"},
373 : {(VariantT)350, "SgOmpTeamsDistributeParallelForStatement"},
374 : {(VariantT)351, "SgOmpTeamsDistributeParallelForSimdStatement"},
375 : {(VariantT)352, "SgOmpTeamsLoopStatement"},
376 : {(VariantT)353, "SgOmpParallelLoopStatement"},
377 : {(VariantT)354, "SgOmpParallelMasterStatement"},
378 : {(VariantT)355, "SgOmpMasterTaskloopStatement"},
379 : {(VariantT)356, "SgOmpUnrollStatement"},
380 : {(VariantT)357, "SgOmpTileStatement"},
381 : {(VariantT)358, "SgUpirSimdStatement"},
382 : {(VariantT)359, "SgUpirBaseStatement"},
383 : {(VariantT)360, "SgUpirLoopStatement"},
384 : {(VariantT)361, "SgUpirLoopParallelStatement"},
385 : {(VariantT)362, "SgUpirSyncStatement"},
386 : {(VariantT)363, "SgOmpClause"},
387 : {(VariantT)364, "SgOmpAllocateClause"},
388 : {(VariantT)365, "SgOmpAllocatorClause"},
389 : {(VariantT)366, "SgOmpUsesAllocatorsClause"},
390 : {(VariantT)367, "SgOmpUsesAllocatorsDefination"},
391 : {(VariantT)368, "SgOmpToClause"},
392 : {(VariantT)369, "SgOmpFromClause"},
393 : {(VariantT)370, "SgOmpThreadsClause"},
394 : {(VariantT)371, "SgOmpSimdClause"},
395 : {(VariantT)372, "SgOmpBeginClause"},
396 : {(VariantT)373, "SgOmpCollapseClause"},
397 : {(VariantT)374, "SgOmpCopyinClause"},
398 : {(VariantT)375, "SgOmpCopyprivateClause"},
399 : {(VariantT)376, "SgOmpDefaultClause"},
400 : {(VariantT)377, "SgOmpEndClause"},
401 : {(VariantT)378, "SgOmpExpressionClause"},
402 : {(VariantT)379, "SgOmpFirstprivateClause"},
403 : {(VariantT)380, "SgOmpIfClause"},
404 : {(VariantT)381, "SgOmpFinalClause"},
405 : {(VariantT)382, "SgOmpPriorityClause"},
406 : {(VariantT)383, "SgOmpDeviceClause"},
407 : {(VariantT)384, "SgOmpLastprivateClause"},
408 : {(VariantT)385, "SgOmpNowaitClause"},
409 : {(VariantT)386, "SgOmpReadClause"},
410 : {(VariantT)387, "SgOmpWriteClause"},
411 : {(VariantT)388, "SgOmpUpdateClause"},
412 : {(VariantT)389, "SgOmpDepobjUpdateClause"},
413 : {(VariantT)390, "SgOmpDestroyClause"},
414 : {(VariantT)391, "SgOmpCaptureClause"},
415 : {(VariantT)392, "SgOmpSeqCstClause"},
416 : {(VariantT)393, "SgOmpAcqRelClause"},
417 : {(VariantT)394, "SgOmpReleaseClause"},
418 : {(VariantT)395, "SgOmpAcquireClause"},
419 : {(VariantT)396, "SgOmpReverseOffloadClause"},
420 : {(VariantT)397, "SgOmpUnifiedAddressClause"},
421 : {(VariantT)398, "SgOmpUnifiedSharedMemoryClause"},
422 : {(VariantT)399, "SgOmpDynamicAllocatorsClause"},
423 : {(VariantT)400, "SgOmpAtomicDefaultMemOrderClause"},
424 : {(VariantT)401, "SgOmpExtImplementationDefinedRequirementClause"},
425 : {(VariantT)402, "SgOmpRelaxedClause"},
426 : {(VariantT)403, "SgOmpParallelClause"},
427 : {(VariantT)404, "SgOmpSectionsClause"},
428 : {(VariantT)405, "SgOmpForClause"},
429 : {(VariantT)406, "SgOmpTaskgroupClause"},
430 : {(VariantT)407, "SgUpirNumUnitsField"},
431 : {(VariantT)408, "SgOmpNumTeamsClause"},
432 : {(VariantT)409, "SgOmpGrainsizeClause"},
433 : {(VariantT)410, "SgOmpDetachClause"},
434 : {(VariantT)411, "SgOmpNumTasksClause"},
435 : {(VariantT)412, "SgOmpNogroupClause"},
436 : {(VariantT)413, "SgOmpHintClause"},
437 : {(VariantT)414, "SgOmpOrderClause"},
438 : {(VariantT)415, "SgOmpDistScheduleClause"},
439 : {(VariantT)416, "SgOmpBindClause"},
440 : {(VariantT)417, "SgOmpNontemporalClause"},
441 : {(VariantT)418, "SgOmpInclusiveClause"},
442 : {(VariantT)419, "SgOmpExclusiveClause"},
443 : {(VariantT)420, "SgOmpIsDevicePtrClause"},
444 : {(VariantT)421, "SgOmpUseDevicePtrClause"},
445 : {(VariantT)422, "SgOmpUseDeviceAddrClause"},
446 : {(VariantT)423, "SgOmpThreadLimitClause"},
447 : {(VariantT)424, "SgOmpOrderedClause"},
448 : {(VariantT)425, "SgOmpPrivateClause"},
449 : {(VariantT)426, "SgOmpReductionClause"},
450 : {(VariantT)427, "SgOmpInReductionClause"},
451 : {(VariantT)428, "SgOmpTaskReductionClause"},
452 : {(VariantT)429, "SgOmpDefaultmapClause"},
453 : {(VariantT)430, "SgOmpScheduleClause"},
454 : {(VariantT)431, "SgOmpSharedClause"},
455 : {(VariantT)432, "SgOmpUntiedClause"},
456 : {(VariantT)433, "SgOmpMergeableClause"},
457 : {(VariantT)434, "SgOmpVariablesClause"},
458 : {(VariantT)435, "SgOmpMapClause"},
459 : {(VariantT)436, "SgOmpSafelenClause"},
460 : {(VariantT)437, "SgOmpSimdlenClause"},
461 : {(VariantT)438, "SgOmpLinearClause"},
462 : {(VariantT)439, "SgOmpUniformClause"},
463 : {(VariantT)440, "SgOmpAlignedClause"},
464 : {(VariantT)441, "SgOmpProcBindClause"},
465 : {(VariantT)442, "SgOmpAtomicClause"},
466 : {(VariantT)443, "SgOmpInbranchClause"},
467 : {(VariantT)444, "SgOmpNotinbranchClause"},
468 : {(VariantT)445, "SgOmpDependClause"},
469 : {(VariantT)446, "SgOmpAffinityClause"},
470 : {(VariantT)447, "SgOmpWhenClause"},
471 : {(VariantT)448, "SgOmpFullClause"},
472 : {(VariantT)449, "SgOmpPartialClause"},
473 : {(VariantT)450, "SgOmpSizesClause"},
474 : {(VariantT)451, "SgUpirBranchField"},
475 : {(VariantT)452, "SgUpirNestedLevelField"},
476 : {(VariantT)453, "SgUpirNestedParentField"},
477 : {(VariantT)454, "SgUpirNestedChildField"},
478 : {(VariantT)455, "SgUpirSyncField"},
479 : {(VariantT)456, "SgUpirDataField"},
480 : {(VariantT)457, "SgUpirDataItemField"},
481 : {(VariantT)458, "SgUpirTargetField"},
482 : {(VariantT)459, "SgOpenclAccessModeModifier"},
483 : {(VariantT)460, "SgOpenStatement"},
484 : {(VariantT)461, "SgOptions"},
485 : {(VariantT)462, "SgOrOp"},
486 : {(VariantT)463, "SgParameterStatement"},
487 : {(VariantT)464, "SgPartialFunctionModifierType"},
488 : {(VariantT)465, "SgPartialFunctionType"},
489 : {(VariantT)466, "SgPassStatement"},
490 : {(VariantT)467, "SgPlusAssignOp"},
491 : {(VariantT)468, "SgPlusPlusOp"},
492 : {(VariantT)469, "SgPntrArrRefExp"},
493 : {(VariantT)470, "SgPointerAssignOp"},
494 : {(VariantT)471, "SgPointerDerefExp"},
495 : {(VariantT)472, "SgPointerMemberType"},
496 : {(VariantT)473, "SgPointerType"},
497 : {(VariantT)474, "SgPowerOp"},
498 : {(VariantT)475, "SgPragma"},
499 : {(VariantT)476, "SgPragmaDeclaration"},
500 : {(VariantT)477, "SgPrintStatement"},
501 : {(VariantT)478, "SgProcedureHeaderStatement"},
502 : {(VariantT)479, "SgProgramHeaderStatement"},
503 : {(VariantT)480, "SgProject"},
504 : {(VariantT)481, "SgPseudoDestructorRefExp"},
505 : {(VariantT)482, "SgPythonGlobalStmt"},
506 : {(VariantT)483, "SgPythonPrintStmt"},
507 : {(VariantT)484, "SgQualifiedName"},
508 : {(VariantT)485, "SgQualifiedNameType"},
509 : {(VariantT)486, "SgRangeExp"},
510 : {(VariantT)487, "SgRangeBasedForStatement"},
511 : {(VariantT)488, "SgReadStatement"},
512 : {(VariantT)489, "SgRealPartOp"},
513 : {(VariantT)490, "SgRefExp"},
514 : {(VariantT)491, "SgReferenceType"},
515 : {(VariantT)492, "SgRenamePair"},
516 : {(VariantT)493, "SgRenameSymbol"},
517 : {(VariantT)494, "SgReturnStmt"},
518 : {(VariantT)495, "SgRewindStatement"},
519 : {(VariantT)496, "SgRshiftAssignOp"},
520 : {(VariantT)497, "SgRshiftOp"},
521 : {(VariantT)498, "SgRvalueReferenceType"},
522 : {(VariantT)499, "SgScopeOp"},
523 : {(VariantT)500, "SgScopeStatement"},
524 : {(VariantT)501, "SgSequenceStatement"},
525 : {(VariantT)502, "SgSetComprehension"},
526 : {(VariantT)503, "SgShortVal"},
527 : {(VariantT)504, "SgSIMDBinaryOp"},
528 : {(VariantT)505, "SgSIMDAddOp"},
529 : {(VariantT)506, "SgSIMDSubOp"},
530 : {(VariantT)507, "SgSIMDMulOp"},
531 : {(VariantT)508, "SgSIMDDivOp"},
532 : {(VariantT)509, "SgSIMDFmaOp"},
533 : {(VariantT)510, "SgSIMDLoad"},
534 : {(VariantT)511, "SgSIMDBroadcast"},
535 : {(VariantT)512, "SgSIMDStore"},
536 : {(VariantT)513, "SgSIMDPartialStore"},
537 : {(VariantT)514, "SgSIMDScalarStore"},
538 : {(VariantT)515, "SgSIMDGather"},
539 : {(VariantT)516, "SgSIMDExplicitGather"},
540 : {(VariantT)517, "SgSIMDScatter"},
541 : {(VariantT)518, "SgSizeOfOp"},
542 : {(VariantT)519, "SgAlignOfOp"},
543 : {(VariantT)520, "SgSourceFile"},
544 : {(VariantT)521, "SgSpaceshipOp"},
545 : {(VariantT)522, "SgSpawnStmt"},
546 : {(VariantT)523, "SgSyncAllStatement"},
547 : {(VariantT)524, "SgSyncImagesStatement"},
548 : {(VariantT)525, "SgSyncMemoryStatement"},
549 : {(VariantT)526, "SgSyncTeamStatement"},
550 : {(VariantT)527, "SgLockStatement"},
551 : {(VariantT)528, "SgUnlockStatement"},
552 : {(VariantT)529, "SgProcessControlStatement"},
553 : {(VariantT)530, "SgSpecialFunctionModifier"},
554 : {(VariantT)531, "SgStatement"},
555 : {(VariantT)532, "SgStaticAssertionDeclaration"},
556 : {(VariantT)533, "SgStmtDeclarationStatement"},
557 : {(VariantT)534, "SgStatementExpression"},
558 : {(VariantT)535, "SgStatementFunctionStatement"},
559 : {(VariantT)536, "SgStopOrPauseStatement"},
560 : {(VariantT)537, "SgStorageModifier"},
561 : {(VariantT)538, "SgStringConversion"},
562 : {(VariantT)539, "SgStringKeyedBidirectionalGraph"},
563 : {(VariantT)540, "SgStringVal"},
564 : {(VariantT)541, "SgStructureModifier"},
565 : {(VariantT)542, "SgSubscriptExpression"},
566 : {(VariantT)543, "SgSubtractOp"},
567 : {(VariantT)544, "SgSupport"},
568 : {(VariantT)545, "SgSwitchStatement"},
569 : {(VariantT)546, "SgSymbol"},
570 : {(VariantT)547, "SgSymbolTable"},
571 : {(VariantT)548, "SgTemplateArgument"},
572 : {(VariantT)549, "SgTemplateArgumentList"},
573 : {(VariantT)550, "SgTemplateDeclaration"},
574 : {(VariantT)551, "SgTemplateClassDeclaration"},
575 : {(VariantT)552, "SgTemplateClassSymbol"},
576 : {(VariantT)553, "SgTemplateFunctionDeclaration"},
577 : {(VariantT)554, "SgTemplateFunctionRefExp"},
578 : {(VariantT)555, "SgTemplateFunctionSymbol"},
579 : {(VariantT)556, "SgTemplateMemberFunctionDeclaration"},
580 : {(VariantT)557, "SgTemplateMemberFunctionRefExp"},
581 : {(VariantT)558, "SgTemplateMemberFunctionSymbol"},
582 : {(VariantT)559, "SgTemplateTypedefDeclaration"},
583 : {(VariantT)560, "SgTemplateTypedefSymbol"},
584 : {(VariantT)561, "SgTemplateVariableDeclaration"},
585 : {(VariantT)562, "SgTemplateVariableSymbol"},
586 : {(VariantT)563, "SgTemplateClassDefinition"},
587 : {(VariantT)564, "SgTemplateFunctionDefinition"},
588 : {(VariantT)565, "SgTemplateInstantiationDecl"},
589 : {(VariantT)566, "SgTemplateInstantiationDefn"},
590 : {(VariantT)567, "SgTemplateInstantiationDirectiveStatement"},
591 : {(VariantT)568, "SgTemplateInstantiationFunctionDecl"},
592 : {(VariantT)569, "SgTemplateInstantiationMemberFunctionDecl"},
593 : {(VariantT)570, "SgTemplateInstantiationTypedefDeclaration"},
594 : {(VariantT)571, "SgTemplateParameter"},
595 : {(VariantT)572, "SgTemplateParameterVal"},
596 : {(VariantT)573, "SgTemplateParameterList"},
597 : {(VariantT)574, "SgTemplateSymbol"},
598 : {(VariantT)575, "SgTemplateType"},
599 : {(VariantT)576, "SgThisExp"},
600 : {(VariantT)577, "SgTypeTraitBuiltinOperator"},
601 : {(VariantT)578, "SgSuperExp"},
602 : {(VariantT)579, "SgThrowOp"},
603 : {(VariantT)580, "SgToken"},
604 : {(VariantT)581, "SgTryStmt"},
605 : {(VariantT)582, "SgTupleExp"},
606 : {(VariantT)583, "SgType"},
607 : {(VariantT)584, "SgTypeBool"},
608 : {(VariantT)585, "SgTypeChar"},
609 : {(VariantT)586, "SgTypeChar16"},
610 : {(VariantT)587, "SgTypeChar32"},
611 : {(VariantT)588, "SgTypeComplex"},
612 : {(VariantT)589, "SgTypeDefault"},
613 : {(VariantT)590, "SgTypeExpression"},
614 : {(VariantT)591, "SgTypeLabel"},
615 : {(VariantT)592, "SgTypeDouble"},
616 : {(VariantT)593, "SgTypeEllipse"},
617 : {(VariantT)594, "SgTypeFixed"},
618 : {(VariantT)595, "SgTypeFloat"},
619 : {(VariantT)596, "SgTypeFloat128"},
620 : {(VariantT)597, "SgTypeFloat80"},
621 : {(VariantT)598, "SgTypeGlobalVoid"},
622 : {(VariantT)599, "SgTypeIdOp"},
623 : {(VariantT)600, "SgTypeImaginary"},
624 : {(VariantT)601, "SgTypeInt"},
625 : {(VariantT)602, "SgTypeLong"},
626 : {(VariantT)603, "SgTypeLongDouble"},
627 : {(VariantT)604, "SgTypeLongLong"},
628 : {(VariantT)605, "SgTypeModifier"},
629 : {(VariantT)606, "SgTypeMatrix"},
630 : {(VariantT)607, "SgTypeTuple"},
631 : {(VariantT)608, "SgTypeNullptr"},
632 : {(VariantT)609, "SgTypeOfType"},
633 : {(VariantT)610, "SgTypeShort"},
634 : {(VariantT)611, "SgTypeSigned128bitInteger"},
635 : {(VariantT)612, "SgTypeSignedChar"},
636 : {(VariantT)613, "SgTypeSignedInt"},
637 : {(VariantT)614, "SgTypeSignedLong"},
638 : {(VariantT)615, "SgTypeSignedLongLong"},
639 : {(VariantT)616, "SgTypeSignedShort"},
640 : {(VariantT)617, "SgTypeString"},
641 : {(VariantT)618, "SgTypeUnknown"},
642 : {(VariantT)619, "SgTypeUnsigned128bitInteger"},
643 : {(VariantT)620, "SgTypeUnsignedChar"},
644 : {(VariantT)621, "SgTypeUnsignedInt"},
645 : {(VariantT)622, "SgTypeUnsignedLong"},
646 : {(VariantT)623, "SgTypeUnsignedLongLong"},
647 : {(VariantT)624, "SgTypeUnsignedShort"},
648 : {(VariantT)625, "SgTypeVoid"},
649 : {(VariantT)626, "SgTypeWchar"},
650 : {(VariantT)627, "SgTypedefDeclaration"},
651 : {(VariantT)628, "SgTypedefSeq"},
652 : {(VariantT)629, "SgTypedefSymbol"},
653 : {(VariantT)630, "SgTypedefType"},
654 : {(VariantT)631, "SgUPC_AccessModifier"},
655 : {(VariantT)632, "SgUnaryAddOp"},
656 : {(VariantT)633, "SgUnaryOp"},
657 : {(VariantT)634, "SgUndefDirectiveStatement"},
658 : {(VariantT)635, "SgUndirectedGraphEdge"},
659 : {(VariantT)636, "SgUnknownArrayOrFunctionReference"},
660 : {(VariantT)637, "SgUnknownFile"},
661 : {(VariantT)638, "SgUnknownMemberFunctionType"},
662 : {(VariantT)639, "SgUnparse_Info"},
663 : {(VariantT)640, "SgUnsignedCharVal"},
664 : {(VariantT)641, "SgUnsignedIntVal"},
665 : {(VariantT)642, "SgUnsignedLongLongIntVal"},
666 : {(VariantT)643, "SgUnsignedLongVal"},
667 : {(VariantT)644, "SgUnsignedShortVal"},
668 : {(VariantT)645, "SgUpcBarrierStatement"},
669 : {(VariantT)646, "SgUpcBlocksizeofExpression"},
670 : {(VariantT)647, "SgUpcElemsizeofExpression"},
671 : {(VariantT)648, "SgUpcFenceStatement"},
672 : {(VariantT)649, "SgUpcForAllStatement"},
673 : {(VariantT)650, "SgUpcLocalsizeofExpression"},
674 : {(VariantT)651, "SgUpcMythread"},
675 : {(VariantT)652, "SgUpcNotifyStatement"},
676 : {(VariantT)653, "SgUpcThreads"},
677 : {(VariantT)654, "SgUpcWaitStatement"},
678 : {(VariantT)655, "SgUseStatement"},
679 : {(VariantT)656, "SgUserDefinedBinaryOp"},
680 : {(VariantT)657, "SgUserDefinedUnaryOp"},
681 : {(VariantT)658, "SgUsingDeclarationStatement"},
682 : {(VariantT)659, "SgUsingDirectiveStatement"},
683 : {(VariantT)660, "SgValueExp"},
684 : {(VariantT)661, "SgVarArgCopyOp"},
685 : {(VariantT)662, "SgVarArgEndOp"},
686 : {(VariantT)663, "SgVarArgOp"},
687 : {(VariantT)664, "SgVarArgStartOneOperandOp"},
688 : {(VariantT)665, "SgVarArgStartOp"},
689 : {(VariantT)666, "SgVarRefExp"},
690 : {(VariantT)667, "SgVariableDeclaration"},
691 : {(VariantT)668, "SgVariableDefinition"},
692 : {(VariantT)669, "SgVariableSymbol"},
693 : {(VariantT)670, "SgVariantExpression"},
694 : {(VariantT)671, "SgVariantStatement"},
695 : {(VariantT)672, "SgVoidVal"},
696 : {(VariantT)673, "SgWaitStatement"},
697 : {(VariantT)674, "SgWarningDirectiveStatement"},
698 : {(VariantT)675, "SgWithStatement"},
699 : {(VariantT)676, "SgWcharVal"},
700 : {(VariantT)677, "SgWhereStatement"},
701 : {(VariantT)678, "SgWhileStmt"},
702 : {(VariantT)679, "SgWriteStatement"},
703 : {(VariantT)680, "SgXorAssignOp"},
704 : {(VariantT)681, "SgYieldExpression"},
705 : {(VariantT)682, "Sg_File_Info"},
706 : {(VariantT)683, "SgTypeCAFTeam"},
707 : {(VariantT)684, "SgCAFWithTeamStatement"},
708 : {(VariantT)685, "SgCAFCoExpression"},
709 : {(VariantT)686, "SgCallExpression"},
710 : {(VariantT)687, "SgTypeCrayPointer"},
711 : {(VariantT)688, "SgClassExp"},
712 : {(VariantT)689, "hello"},
713 : {V_SgNumVariants, "last tag" }
714 : };
715 :
716 :
717 :
718 :
719 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
720 :
721 : // ********************************************************
722 : // member functions specific to each node in the grammar
723 : // ********************************************************
724 :
725 :
726 : /* #line 727 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
727 :
728 : // Start of memberFunctionString
729 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
730 :
731 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
732 :
733 : SgNode*
734 82767500 : SgNode::get_freepointer () const
735 : {
736 82767500 : ROSE_ASSERT (this != NULL);
737 :
738 : #if 0
739 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
740 : // used to trigger marking transformations for the token-based unparsing.
741 : printf ("SgNode::get_freepointer = %p = %s \n",this,this->class_name().c_str());
742 : #endif
743 :
744 82767500 : return p_freepointer;
745 : }
746 :
747 : void
748 4550460 : SgNode::set_freepointer ( SgNode* freepointer )
749 : {
750 4550460 : ROSE_ASSERT (this != NULL);
751 :
752 : #if 0
753 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
754 : // used to trigger marking transformations for the token-based unparsing.
755 : printf ("SgNode::set_freepointer = %p = %s \n",this,this->class_name().c_str());
756 : #endif
757 :
758 4550460 : set_isModified(true);
759 :
760 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
761 : if (p_freepointer != NULL && freepointer != NULL && p_freepointer != freepointer)
762 : {
763 : printf ("Warning: freepointer = %p overwriting valid pointer p_freepointer = %p \n",freepointer,p_freepointer);
764 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
765 : printf ("Error fails assertion (p_freepointer != NULL && freepointer != NULL && p_freepointer != freepointer) is false\n");
766 : ROSE_ASSERT(false);
767 : #endif
768 : }
769 : #endif
770 4550460 : p_freepointer = freepointer;
771 4550460 : }
772 :
773 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
774 :
775 :
776 : // End of memberFunctionString
777 : // Start of memberFunctionString
778 :
779 :
780 : // End of memberFunctionString
781 : // Start of memberFunctionString
782 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
783 :
784 : // *** COMMON CODE SECTION BEGINS HERE ***
785 :
786 : #if 0
787 : int
788 : SgNode::getVariant() const
789 : {
790 : // This function is used in ROSE while "variant()" is used in SAGE
791 : assert(this != NULL);
792 : return variant();
793 : }
794 : #endif
795 :
796 : // This function is used in ROSE in treeTraversal code
797 : // eventually replaces getVariant() and variant()
798 : // though after variant() has been removed for a while we will
799 : // want to change the name of variantT() back to variant()
800 : // (since the "T" was ment to stand for temporary).
801 : // When this happens the variantT() will be depricated.
802 : VariantT
803 1691490000 : SgNode::variantT() const
804 : {
805 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
806 1691490000 : ROSE_ASSERT(this != NULL);
807 1691490000 : return V_SgNode;
808 : }
809 :
810 : #if 0
811 : int
812 : SgNode::variant() const
813 : {
814 : // This function is used in SAGE
815 : ROSE_ASSERT(this != NULL);
816 : return NodeTag;
817 : }
818 : #endif
819 :
820 : ROSE_DLL_API const char*
821 0 : SgNode::sage_class_name() const
822 : {
823 0 : ROSE_ASSERT(this != NULL);
824 0 : return "SgNode";
825 : }
826 :
827 : std::string
828 0 : SgNode::class_name() const
829 : {
830 0 : ROSE_ASSERT(this != NULL);
831 0 : return "SgNode";
832 : }
833 :
834 : // DQ (11/26/2005): Support for visitor pattern mechanims
835 : // (inferior to ROSE traversal mechanism, experimental).
836 : void
837 0 : SgNode::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
838 : {
839 0 : ROSE_ASSERT(this != NULL);
840 0 : visitor.visit(this);
841 0 : }
842 :
843 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
844 0 : void SgNode::accept (ROSE_VisitorPattern & visitor) {
845 0 : ROSE_ASSERT(this != NULL);
846 0 : visitor.visit(this);
847 0 : }
848 :
849 : SgNode*
850 0 : SgNode::addRegExpAttribute(std::string s, AstRegExAttribute* a)
851 : {
852 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
853 : // This function is currently only supported for the AST used the represent Binary executables.
854 : if (0 /* isSgAsmNode(this) != NULL */)
855 : {
856 : // Support for regex specification.
857 : std::string prefixCode = "REGEX:";
858 : addNewAttribute(prefixCode + s,a);
859 : }
860 : #endif
861 :
862 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
863 0 : return this;
864 : }
865 :
866 : // *** COMMON CODE SECTION ENDS HERE ***
867 :
868 :
869 : // End of memberFunctionString
870 : // Start of memberFunctionString
871 : /* #line 1669 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
872 :
873 :
874 :
875 : // ########################################
876 : // Some global variables used within SAGE 3
877 : // ########################################
878 :
879 : // declaration of variable to control internal output of debuging information
880 : int SAGE_DEBUG = 0; // default value is zero
881 :
882 : // ###############################
883 : // Start of source code for SgNode
884 : // ###############################
885 :
886 : // Specialize printing for ROSE addresses. A better place for this would be ExtentMap.C along
887 : // with all the other Extent-related methods. Unfortunately, that file is compiled only if
888 : // ROSE is configured with binary support.
889 : template<>
890 0 : void Range<rose_addr_t>::print(std::ostream &o) const
891 : {
892 0 : if (empty()) {
893 0 : o <<"<empty>";
894 0 : } else if (1==size()) {
895 0 : char buf[64];
896 : // DQ (10/20/2015): Note that whitespace is required before PRIx64 (to avoid compiler warning).
897 0 : sprintf(buf, "0x%08" PRIx64, first());
898 0 : o << buf;
899 : } else {
900 0 : char buf[64];
901 : // DQ (10/20/2015): Note that whitespace is required before PRIx64 (to avoid compiler warning).
902 0 : sprintf(buf, "0x%08" PRIx64 "+0x%08" PRIx64 "=0x%08" PRIx64, first(), size(), first()+size());
903 0 : o <<buf;
904 : }
905 0 : }
906 :
907 : // This resolves a linker error when building ROSE with Visual Studio.
908 : // If the above function is not called within the same file, the compiler
909 : // fails to generate the symbol, so we use explicit instantiation.
910 : #ifdef _MSC_VER
911 : template class Range<rose_addr_t>;
912 : #endif
913 :
914 : // Support for global function type symbol table (moved to be static data pointer)
915 : // DQ (1/31/2006): Modified to build all types in the memory pools
916 : // SgFunctionTypeTable* SgNode::Sgfunc_type_table = new SgFunctionTypeTable();
917 : // SgFunctionTypeTable* SgNode::p_globalFunctionTypeTable = new SgFunctionTypeTable();
918 : SgFunctionTypeTable* SgNode::p_globalFunctionTypeTable = NULL;
919 :
920 : // DQ (7/22/2010): Added type table for non-function types (supports construction of unique types).
921 : SgTypeTable* SgNode::p_globalTypeTable = NULL;
922 :
923 : // Static variable used to hold language specific information for each IR node
924 : // long SgNode::language_classification_bit_vector;
925 :
926 : // DQ (3/12/2007): Added mangled name map to improve performance of generating mangled names
927 : std::map<SgNode*,std::string> SgNode::p_globalMangledNameMap;
928 : std::map<std::string,int> SgNode::p_shortMangledNameCache;
929 :
930 : // DQ (5/28/2011): Added central location for qualified name maps (for names and types).
931 : // these maps store the required qualified name for where an IR node is referenced (not
932 : // at the IR node which has the qlocal qualifier). Thus we can support multiple references
933 : // to an IR node which might have different qualified names. This is critical to the
934 : // qualified name support.
935 : std::map<SgNode*,std::string> SgNode::p_globalQualifiedNameMapForNames;
936 : std::map<SgNode*,std::string> SgNode::p_globalQualifiedNameMapForTypes;
937 : std::map<SgNode*,std::string> SgNode::p_globalQualifiedNameMapForTemplateHeaders;
938 : std::map<SgNode*,std::string> SgNode::p_globalTypeNameMap;
939 :
940 : // DQ (3/13/2019): The fix for referencing types than contain many parts is to have a map of maps
941 : // to the generated name qualification substrings for each type, all associted with a single reference
942 : // node to the statement refering to the type.
943 : std::map<SgNode*,std::map<SgNode*,std::string> > SgNode::p_globalQualifiedNameMapForMapsOfTypes;
944 :
945 : // DQ (7/22/2011): array dimensions may include expressions that require name qualification.
946 : // std::map<SgNode*,std::string> SgNode::p_globalQualifiedNameMapForArrayTypeDimensions;
947 :
948 :
949 : #if ALT_FIXUP_COPY
950 : void
951 34146 : SgNode::fixupCopy_scopes(SgNode* copy, SgCopyHelp & help) const
952 : {
953 : // This is the empty default inplementation, not a problem if it is called!
954 34146 : }
955 :
956 : void
957 34146 : SgNode::fixupCopy_symbols(SgNode* copy, SgCopyHelp & help) const
958 : {
959 : // This is the empty default inplementation, not a problem if it is called!
960 34146 : }
961 :
962 : void
963 34146 : SgNode::fixupCopy_references(SgNode* copy, SgCopyHelp & help) const
964 : {
965 : // This is the empty default inplementation, not a problem if it is called!
966 34146 : }
967 : #else
968 : // DQ (10/5/2007): Added IR node specific function to permit copies, via AST copy(), to be fixedup
969 : // Usually this will correct scopes and in a few cases build child IR nodes that are not traversed
970 : // (and thus shared in the result from the automatically generated copy function).
971 : void
972 : SgNode::fixupCopy(SgNode* copy, SgCopyHelp & help) const
973 : {
974 : // This is the empty default inplementation, not a problem if it is called!
975 : }
976 : #endif
977 :
978 : // DQ (1/31/2006): We might want this function to be automaticaly generated
979 : // except that then we could not support the assertion. Also we
980 : // don't have to set this function, though perhaps the interface function
981 : // should be implemented to set it just on general principles.
982 : SgFunctionTypeTable*
983 3748840 : SgNode::get_globalFunctionTypeTable()
984 : {
985 : // DQ (1/31/2006): If there is no global function type symbol table then build one
986 3748840 : if (p_globalFunctionTypeTable == NULL)
987 : {
988 : // printf ("In SgNode::get_globalFunctionTypeTable(): p_globalFunctionTypeTable == NULL (allocating the global function type symbol table) \n");
989 354 : p_globalFunctionTypeTable = new SgFunctionTypeTable();
990 354 : ROSE_ASSERT(p_globalFunctionTypeTable != NULL);
991 : // p_globalFunctionTypeTable->set_parent(???);
992 : }
993 :
994 3748840 : ROSE_ASSERT(p_globalFunctionTypeTable != NULL);
995 3748840 : return p_globalFunctionTypeTable;
996 : }
997 :
998 : void
999 11 : SgNode::set_globalFunctionTypeTable ( SgFunctionTypeTable* globalFunctionTypeTable )
1000 : {
1001 11 : p_globalFunctionTypeTable = globalFunctionTypeTable;
1002 11 : }
1003 :
1004 : SgTypeTable*
1005 372917 : SgNode::get_globalTypeTable()
1006 : {
1007 : // DQ (1/31/2006): If there is no global function type symbol table then build one
1008 372917 : if (p_globalTypeTable == NULL)
1009 : {
1010 : // printf ("In SgNode::get_globalTypeTable(): p_globalTypeTable == NULL (allocating the global non-function type symbol table) \n");
1011 354 : p_globalTypeTable = new SgTypeTable();
1012 354 : ROSE_ASSERT(p_globalTypeTable != NULL);
1013 : // p_globalTypeTable->set_parent(this);
1014 : // p_globalFunctionTypeTable->set_parent(???);
1015 : }
1016 :
1017 372917 : ROSE_ASSERT(p_globalTypeTable != NULL);
1018 372917 : return p_globalTypeTable;
1019 : }
1020 :
1021 : void
1022 11 : SgNode::set_globalTypeTable ( SgTypeTable* globalTypeTable )
1023 : {
1024 11 : p_globalTypeTable = globalTypeTable;
1025 11 : }
1026 :
1027 : // DQ (3/17/2007): return reference to the global mangled name map (the use
1028 : // of this map is a performance optimization).
1029 : std::map<SgNode*,std::string> &
1030 40299500 : SgNode::get_globalMangledNameMap()
1031 : {
1032 40299500 : return p_globalMangledNameMap;
1033 : }
1034 : #if 0
1035 : std::map<SgNode*,std::string> &
1036 : SgNode:: get_mangledNameCache()
1037 : {
1038 : return p_mangledNameCache;
1039 : }
1040 : #endif
1041 : std::map<std::string, int> &
1042 3490450 : SgNode:: get_shortMangledNameCache()
1043 : {
1044 3490450 : return p_shortMangledNameCache;
1045 : }
1046 :
1047 : // DQ (3/17/2007): return reference to the global mangled name map (the use
1048 : // of this map is a performance optimization).
1049 : void
1050 677 : SgNode::clearGlobalMangledNameMap()
1051 : {
1052 : // Remove all elements from the globalMangledNameMap
1053 : // p_globalMangledNameMap.erase(p_globalMangledNameMap.begin(),p_globalMangledNameMap.end());
1054 677 : p_globalMangledNameMap.clear();
1055 :
1056 : // DQ (6/26/2007): The function types require the same mangled names be generated across
1057 : // clears of the p_globalMangledNameMap cache. Clearing the short name map breaks this.
1058 : // It might be that we don't want to clear the short name map to permit the same mangled
1059 : // names to be regenerated. However, for the purposes of AST merge this is not a problem.
1060 : // p_shortMangledNameCache.clear();
1061 677 : }
1062 :
1063 : #if 0
1064 : // DQ (3/12/2007): Not clear how to do this!
1065 : SgName
1066 : SgNode::lookupMangledName(const SgNode* node) const
1067 : {
1068 : string returnString;
1069 :
1070 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
1071 : const SgName name = "__global__";
1072 : SgGlobal* global = const_cast<SgGlobal*>(this);
1073 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(global);
1074 : if (i != p_globalMangledNameMap.end())
1075 : {
1076 : return i->second.c_str();
1077 : }
1078 : else
1079 : {
1080 : p_globalMangledNameMap[global] = name;
1081 : return name;
1082 : }
1083 :
1084 : return SgName(returnString);
1085 : }
1086 : #endif
1087 :
1088 : // DQ (5/28/2011): Added support for holding the name qualification map.
1089 : std::map<SgNode*,std::string> &
1090 47084 : SgNode::get_globalQualifiedNameMapForNames()
1091 : {
1092 47084 : return p_globalQualifiedNameMapForNames;
1093 : }
1094 :
1095 : // DQ (5/28/2011): Added support for holding the name qualification map.
1096 : void
1097 0 : SgNode::set_globalQualifiedNameMapForNames(const std::map<SgNode*,std::string> & X)
1098 : {
1099 0 : p_globalQualifiedNameMapForNames = X;
1100 0 : }
1101 :
1102 : // DQ (5/28/2011): Added support for holding the name qualification map.
1103 : std::map<SgNode*,std::string> &
1104 2969240 : SgNode::get_globalQualifiedNameMapForTypes()
1105 : {
1106 2969240 : return p_globalQualifiedNameMapForTypes;
1107 : }
1108 :
1109 : // DQ (5/28/2011): Added support for holding the name qualification map.
1110 : void
1111 0 : SgNode::set_globalQualifiedNameMapForTypes(const std::map<SgNode*,std::string> & X)
1112 : {
1113 0 : p_globalQualifiedNameMapForTypes = X;
1114 0 : }
1115 :
1116 : // DQ (3/13/2019): Added support for holding the name qualification map.
1117 : std::map<SgNode*,std::map<SgNode*,std::string> > &
1118 66 : SgNode::get_globalQualifiedNameMapForMapsOfTypes()
1119 : {
1120 66 : return p_globalQualifiedNameMapForMapsOfTypes;
1121 : }
1122 :
1123 : // DQ (3/13/2019): Added support for holding the name qualification map.
1124 : void
1125 0 : SgNode::set_globalQualifiedNameMapForMapsOfTypes(const std::map<SgNode*,std::map<SgNode*,std::string> > & X)
1126 : {
1127 0 : p_globalQualifiedNameMapForMapsOfTypes = X;
1128 0 : }
1129 :
1130 : // DQ (5/28/2011): Added support for holding the name qualification map.
1131 : std::map<SgNode*,std::string> &
1132 66 : SgNode::get_globalQualifiedNameMapForTemplateHeaders()
1133 : {
1134 66 : return p_globalQualifiedNameMapForTemplateHeaders;
1135 : }
1136 :
1137 : // DQ (5/28/2011): Added support for holding the name qualification map.
1138 : void
1139 0 : SgNode::set_globalQualifiedNameMapForTemplateHeaders(const std::map<SgNode*,std::string> & X)
1140 : {
1141 0 : p_globalQualifiedNameMapForTemplateHeaders = X;
1142 0 : }
1143 :
1144 : // DQ (6/3/2011): Added support for holding the map of type names that require qualification and at this position dependent.
1145 : std::map<SgNode*,std::string> &
1146 3615450 : SgNode::get_globalTypeNameMap()
1147 : {
1148 3615450 : return p_globalTypeNameMap;
1149 : }
1150 :
1151 : // DQ (6/3/2011): Added support for holding the map of type names that require qualification and at this position dependent.
1152 : void
1153 0 : SgNode::set_globalTypeNameMap(const std::map<SgNode*,std::string> & X)
1154 : {
1155 0 : p_globalTypeNameMap = X;
1156 0 : }
1157 :
1158 :
1159 : #if 0
1160 : // DQ (6/21/2011): Since this type "std::set<SgNode*>" is not supported by our AST file I/O I will
1161 : // implement this in a way that does not require such support.
1162 : // DQ (6/21/2011): Added support for holding the set of seen declarations which is referenced as we travers and compute qualified names.
1163 : std::set<SgNode*> &
1164 : SgNode::get_globalReferencedNameSet()
1165 : {
1166 : return p_globalReferencedNameSet;
1167 : }
1168 :
1169 : // DQ (6/21/2011): Added support for holding the set of seen declarations which is referenced as we travers and compute qualified names.
1170 : void
1171 : SgNode::set_globalReferencedNameSet(const std::set<SgNode*> & X)
1172 : {
1173 : p_globalReferencedNameSet = X;
1174 : }
1175 : #endif
1176 :
1177 : // DQ (4/10/2006): These are the default virtual function definitions (each returns an error)
1178 : void
1179 0 : SgNode::addNewAttribute( std::string s, AstAttribute* a )
1180 : {
1181 0 : printf ("Error: calling SgNode::addNewAttribute(%s) \n",s.c_str());
1182 0 : ROSE_ASSERT(false);
1183 : }
1184 :
1185 : void
1186 0 : SgNode::setAttribute( std::string s, AstAttribute* a )
1187 : {
1188 0 : printf ("Error: calling SgNode::setAttribute(%s) \n",s.c_str());
1189 0 : ROSE_ASSERT(false);
1190 : }
1191 :
1192 : AstAttribute*
1193 0 : SgNode::getAttribute(std::string s) const
1194 : {
1195 0 : printf ("Error: calling SgNode::getAttribute(%s) \n",s.c_str());
1196 0 : ROSE_ASSERT(false);
1197 :
1198 : return NULL;
1199 : }
1200 :
1201 : void
1202 0 : SgNode::updateAttribute( std::string s, AstAttribute* a )
1203 : {
1204 : // formerly called: replace
1205 0 : printf ("Error: calling SgNode::updateAttribute(%s) \n",s.c_str());
1206 0 : ROSE_ASSERT(false);
1207 : }
1208 :
1209 : void
1210 0 : SgNode::removeAttribute(std::string s)
1211 : {
1212 0 : printf ("Error: calling SgNode::removeAttribute(%s) \n",s.c_str());
1213 0 : ROSE_ASSERT(false);
1214 : }
1215 :
1216 : bool
1217 0 : SgNode::attributeExists(std::string s) const
1218 : {
1219 0 : printf ("Error: calling SgNode::attributeExists(%s) on node = %s \n",s.c_str(),class_name().c_str());
1220 0 : ROSE_ASSERT(false);
1221 :
1222 : // tps (12/9/2009) : MSC requires a return value
1223 : return false;
1224 : }
1225 :
1226 : int
1227 0 : SgNode::numberOfAttributes() const
1228 : {
1229 0 : int returnValue = 0;
1230 0 : return returnValue;
1231 : }
1232 :
1233 : AstAttributeMechanism*
1234 0 : SgNode::get_attributeMechanism() const
1235 : {
1236 : // DQ (4/10/2006): virtual function defined at the SgNode and redefined whereever there is
1237 : // an AstAttributeMechanism defined! Note that there is no set function defined.
1238 0 : return NULL;
1239 : }
1240 :
1241 : void
1242 0 : SgNode::set_attributeMechanism(AstAttributeMechanism* a)
1243 : {
1244 : // Nothing to do here, but we need this virtual function so that the correct access
1245 : // function will be call on IR nodes where the AstAttributeMechanism is defined as
1246 : // a data member.
1247 :
1248 0 : printf ("Error: SgNode::set_attributeMechanism(AstAttributeMechanism* a) has been called \n");
1249 0 : ROSE_ASSERT(false);
1250 : }
1251 :
1252 : #if 0
1253 : void
1254 : SgNode::print( std::ostream* os, /* 0 uses the default */
1255 : int maxdepth) /* controlling function*/
1256 : {
1257 : Sg_print_info().reset(os, maxdepth);
1258 : this->_print(0);
1259 : }
1260 :
1261 : bool
1262 : SgNode::_print(int depth) const
1263 : {
1264 : return Sg_print_info().output_class(this,sage_class_name(), depth + 1);
1265 : }
1266 : #endif
1267 :
1268 : #if 0
1269 : //! implementation in base class - overridden by SgLocatedNode::directives(ostream&)
1270 : void
1271 : SgNode::directives(std::ostream& os)
1272 : {
1273 : // to be overridden by SgLocatedNode::directives(ostream&)
1274 : }
1275 : #endif
1276 :
1277 : #if 0
1278 : void
1279 : SgNode::unparse(SgUnparse_Info& info, std::ostream& os)
1280 : {
1281 : /* nothing to be done in general: only comments for statements*/
1282 : directives(os);
1283 : logical_unparse(info,os);
1284 : }
1285 :
1286 : void
1287 : SgNode::unparse_helper(SgUnparse_Info& info, std::ostream& os)
1288 : {
1289 : }
1290 :
1291 : void
1292 : SgNode::logical_unparse(SgUnparse_Info& info, std::ostream& os)
1293 : {
1294 : }
1295 : #endif
1296 :
1297 : void
1298 1167190000 : SgNode::post_construction_initialization()
1299 : {
1300 : // default implementation does nothing!
1301 :
1302 : #if 0
1303 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
1304 : printf ("In SgNode::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
1305 : #endif
1306 1167190000 : }
1307 :
1308 : // DQ (7/23/2005): Let these be automatically generated by ROSETTA!
1309 : // See note above where these are proptotyped, they have to be defined
1310 : // explicitly to avoid endless recursion!
1311 :
1312 : void
1313 181462000 : SgNode::set_isModified ( bool isModified)
1314 : {
1315 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
1316 181462000 : ROSE_ASSERT(this != NULL);
1317 :
1318 : #if 0
1319 : // DQ (6/4/2019): Use this to debug the outlining to seperate file mechanism (remove some spew by ignoring some IR nodes).
1320 : if (variantT() != V_Sg_File_Info && variantT() != V_SgUnparse_Info)
1321 : {
1322 : printf ("SgNode::set_isModified(%s) called for node = %p = %s \n",isModified ? "true" : "false",this,this->class_name().c_str());
1323 : }
1324 : #endif
1325 :
1326 : #if 0
1327 : // DQ (6/6/2019): Testing where isModified is being reset.
1328 : SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(this);
1329 : if (functionDeclaration != NULL && functionDeclaration == functionDeclaration->get_firstNondefiningDeclaration())
1330 : {
1331 : if (functionDeclaration->get_name() == "OUT_1_transformation_0")
1332 : {
1333 : printf ("%%%%%%%%%%%%%%%%%% Setting SgFunctionDeclaration: OUT_1_transformation_0: isModified = %s \n",isModified ? "true" : "false");
1334 : #if 0
1335 : printf ("Exiting as a test! \n");
1336 : ROSE_ASSERT(false);
1337 : #endif
1338 : }
1339 : }
1340 : #endif
1341 :
1342 : #if 0
1343 : // DQ (4/14/2015): Adding testing to identify side-effects in the AST.
1344 : if (SgProject::get_verbose() >= 3)
1345 : {
1346 : // DQ (10/6/2015): Skip the output of this debug info for SgUnparse_Info IR nodes.
1347 : // printf ("SgNode::set_isModified(%s) called for node = %p = %s \n",isModified ? "true" : "false",this,this->class_name().c_str());
1348 : // if (!(isSgUnparse_Info(this) != NULL || isSgToken(this) != NULL))
1349 : if (isSgUnparse_Info(this) == NULL && isSgToken(this) == NULL)
1350 : {
1351 : printf ("SgNode::set_isModified(%s) called for node = %p = %s \n",isModified ? "true" : "false",this,this->class_name().c_str());
1352 : #if 0
1353 : if (SgProject::get_verbose() >= 4)
1354 : {
1355 : printf ("Exiting as a test (when verbose >= 3) in SgNode::set_isModified \n");
1356 : ROSE_ASSERT(false);
1357 : }
1358 : #endif
1359 : }
1360 : #if 0
1361 : // DQ (10/13/2015): Chasing a issue in the move tool.
1362 : if (isSgForStatement(this) != NULL)
1363 : {
1364 : printf ("Exiting as a test in SgNode::set_isModified (found SgForStatemen) \n");
1365 : ROSE_ASSERT(false);
1366 : }
1367 : #endif
1368 : #if 0
1369 : printf ("Exiting as a test in SgNode::set_isModified \n");
1370 : ROSE_ASSERT(false);
1371 : #endif
1372 : }
1373 : #endif
1374 :
1375 181462000 : p_isModified = isModified;
1376 181462000 : }
1377 :
1378 : bool
1379 21671600 : SgNode::get_isModified () const
1380 : {
1381 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
1382 21671600 : ROSE_ASSERT(this != NULL);
1383 :
1384 21671600 : return p_isModified;
1385 : }
1386 :
1387 : // DQ (12/3/2014): Added support to recode when an AST subtree holds an AST node (or subtree) that has been modified.
1388 : void
1389 0 : SgNode::set_containsTransformation ( bool containsTransformation)
1390 : {
1391 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
1392 0 : ROSE_ASSERT(this != NULL);
1393 :
1394 0 : p_containsTransformation = containsTransformation;
1395 0 : }
1396 :
1397 : // DQ (12/3/2014): Added support to recode when an AST subtree holds an AST node (or subtree) that has been modified.
1398 : bool
1399 34109 : SgNode::get_containsTransformation () const
1400 : {
1401 34109 : ROSE_ASSERT(this != NULL);
1402 :
1403 34109 : return p_containsTransformation;
1404 : }
1405 :
1406 :
1407 : bool
1408 0 : SgNode::get_isVisited () const
1409 : {
1410 : // The p_isVisited flag has been removed, it is an error to call this function.
1411 :
1412 0 : ROSE_ASSERT(this != NULL);
1413 :
1414 0 : printf ("Error: The p_isVisited flag has been removed, it is an error to call this function (get_isVisited). \n");
1415 0 : ROSE_ASSERT(false);
1416 :
1417 : return true;
1418 : }
1419 :
1420 : void
1421 0 : SgNode::set_isVisited ( bool isVisited )
1422 : {
1423 : // The p_isVisited flag has been removed, it is an error to call this function.
1424 :
1425 0 : ROSE_ASSERT(this != NULL);
1426 :
1427 0 : printf ("Error: The p_isVisited flag has been removed, it is an error to call this function (set_isVisited). \n");
1428 0 : ROSE_ASSERT(false);
1429 :
1430 : set_isModified(true);
1431 : // p_isVisited = isVisited;
1432 : /* */
1433 : }
1434 :
1435 :
1436 : // ! Permits specification of parent node (connects the AST tree)
1437 : /* ! This function is called internally to connect the elements of the grammar to form the AST.
1438 : */
1439 : void
1440 71743000 : SgNode::set_parent ( SgNode* parent )
1441 : {
1442 : // ROSE_ASSERT (parent != NULL); // QY: should allow setting parent to NULL when detaching SgNodes
1443 : // DQ (9/24/2004): Enforce this simple rule!
1444 71743000 : ROSE_ASSERT(this != NULL);
1445 71743000 : ROSE_ASSERT(this != parent);
1446 :
1447 : #if 0
1448 : printf ("In SgNode::set_parent():\n");
1449 : printf (" - this = %p (%s)\n", this, class_name().c_str());
1450 : printf (" - parent = %p (%s)\n", parent, parent ? parent->class_name().c_str() : "" );
1451 : printf (" - p_parent = %p (%s)\n", p_parent, p_parent ? p_parent->class_name().c_str() : "" );
1452 : #endif
1453 :
1454 71743000 : p_parent = parent;
1455 :
1456 : // ROSE_ASSERT( ( this != (SgNode*)(0xb484411c) ) || ( parent != (SgNode*)(0xb46fe008) ) );
1457 :
1458 : // I think this should be always be true, so let's inforce it (this happends for test2005_64.C)
1459 71743000 : if ( ( variantT() == V_SgClassDeclaration ) && ( parent != NULL && parent->variantT() == V_SgFunctionParameterList ) )
1460 : {
1461 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
1462 : printf ("Warning: Found case in set_parent() where this is a SgClassDeclaration and parent is a SgFunctionParameterList \n");
1463 : #endif
1464 : // get_file_info()->display("Warning: Found case in set_parent() where this is a SgClassDeclaration and parent is a SgFunctionParameterList");
1465 : }
1466 : // ROSE_ASSERT( ( variantT() != V_SgClassDeclaration ) || ( parent->variantT() != V_SgFunctionParameterList ) );
1467 :
1468 71743000 : if ( ( variantT() == V_SgTemplateDeclaration ) && ( parent != NULL && parent->variantT() == V_SgTemplateInstantiationFunctionDecl ) )
1469 : {
1470 0 : printf ("Warning: Found case in set_parent() where this is a SgTemplateDeclaration and parent is a SgTemplateInstantiationFunctionDecl \n");
1471 : // get_file_info()->display("Warning: Found case in set_parent() where this is a SgTemplateDeclaration and parent is a SgTemplateInstantiationFunctionDecl");
1472 0 : ROSE_ASSERT(false);
1473 : }
1474 :
1475 71743000 : if ( ( variantT() == V_SgClassDeclaration ) && ( parent != NULL && parent->variantT() == V_SgGlobal ) )
1476 : {
1477 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
1478 : printf ("Warning: Found case in set_parent() where this is a SgClassDeclaration and parent is a SgGlobal \n");
1479 : #endif
1480 : // get_file_info()->display("Warning: Found case in set_parent() where this is a SgClassDeclaration and parent is a SgFunctionParameterList");
1481 : }
1482 : // ROSE_ASSERT( ( variantT() != V_SgClassDeclaration ) || ( parent->variantT() != V_SgGlobal ) );
1483 :
1484 71743000 : if ( ( variantT() == V_SgTemplateInstantiationDecl ) && ( parent != NULL && parent->variantT() == V_SgClassType ) )
1485 : {
1486 0 : printf ("Warning: Found case in set_parent() where this is a SgTemplateInstantiationDecl and parent is a SgClassType \n");
1487 : // get_file_info()->display("Warning: Found case in set_parent() where this is aSgTemplateInstantiationDecl and parent is a SgClassType");
1488 :
1489 0 : printf ("Exiting in this case! \n");
1490 0 : ROSE_ASSERT(false);
1491 : }
1492 :
1493 : // DQ (7/26/2010): Make the pointer a valid pointer by defining that it
1494 : // should point to its associated SgSymbol as used in the type table.
1495 : // OLD COMMENT: We should not be setting the parent on SgType IR nodes
1496 : // ROSE_ASSERT( isSgType(this) == NULL );
1497 71743000 : }
1498 :
1499 : /*! \brief Set the parent node.
1500 : This function is called internally to connect the elements of the grammar to form the
1501 : AST. This is the backward reference up the tree.
1502 :
1503 : \internal We can't have ROSETTA build these access functions since we want specific
1504 : checking of values for NULL pointers (parent point is NULL only for SgProject)
1505 : */
1506 : SgNode*
1507 586664000 : SgNode::get_parent () const
1508 : {
1509 586664000 : ROSE_ASSERT(this != NULL);
1510 :
1511 586664000 : SgNode* returnNode = p_parent;
1512 :
1513 : // DQ (5/24/2006): I would like to allow SgSymbols to have a valid parent pointer since it can be used to reference
1514 : // the symbol table as a way to support better debugging within the AST merge mechanims.
1515 : // Sage II semantics: Types and Symbols always have a NULL parent (This is the way it is implemented (from Sage II))
1516 : // if ( (isSgType( const_cast<SgNode*>(this) ) != NULL) || (isSgSymbol( const_cast<SgNode*>(this) ) != NULL) )
1517 : // if ( isSgType( const_cast<SgNode*>(this) ) != NULL )
1518 : // returnNode = NULL;
1519 :
1520 586664000 : return returnNode;
1521 : }
1522 :
1523 : // DQ (3/8/2007): Added more efficent implementation to support AST consitency tests and other work.
1524 : //! Query function for if the input IR nodes is a child of the current IR node.
1525 : bool
1526 147833 : SgNode::isChild ( SgNode* node ) const
1527 : {
1528 147833 : return (getChildIndex(node) != -1);
1529 : }
1530 :
1531 :
1532 : vector<string>
1533 0 : SgNode::buildCommandLineToSubstituteTransformationFile( const vector<string>& argv, std::string newFileName )
1534 : {
1535 0 : int fileNameCounter = 0;
1536 0 : int fileNameLocation = 0;
1537 :
1538 : // return a copy of the commandline input to this function
1539 0 : vector<string> transformation_argv(argv.size());
1540 :
1541 : // printf ("In buildCommandLineToSubstituteTransformationFile(): argc = %d \n",argc);
1542 :
1543 : // copy all the entries in the command line.
1544 0 : for (unsigned int i=0; i < argv.size(); i++)
1545 : {
1546 : // Count up the number of filenames (if it is ZERO then this is likely a link line called
1547 : // using the compiler (required for template processing in C++ with most compilers) if there
1548 : // is ONE then this is the source file. Currently their can only be ONE source file specified.
1549 :
1550 : // most options appear as -<option>
1551 : // have to process +w2 (warnings option) on some compilers so include +<option>
1552 0 : if ( argv[i].size() < 1 || (argv[i][0] != '-') || (argv[i][0] != '+') )
1553 : {
1554 0 : unsigned int length = argv[i].size();
1555 : // printf ("Look for file names: argv[%d] = %s length = %d \n",i,argv[i],length);
1556 :
1557 : // look only for .c and .C files (source code files)
1558 : // The length has to be greater then 2 or else we will generate a purify error!
1559 0 : if ( (length > 2) && (argv[i][length-2] == '.') && ( (argv[i][length-1] == 'c') || (argv[i][length-1] == 'C') ) )
1560 : {
1561 : // printf ("Found a filename = %s \n",argv[i]);
1562 : // Rose::sourceFileNamesWithPath [fileNameCounter] = strdup(argv[i]);
1563 : // Rose::sourceFileNamesWithoutPath [fileNameCounter] = strdup(argv[i]);
1564 : // argv[i] = "rose_transformation.C";
1565 : // transformation_argv[i] = "rose_transformation.C";
1566 0 : transformation_argv[i] = strdup(newFileName.c_str());
1567 :
1568 : // record the location of the filename in the command line and the number of filenames
1569 0 : fileNameLocation = i;
1570 0 : fileNameCounter++;
1571 : }
1572 : else
1573 : {
1574 0 : transformation_argv [i] = argv[i];
1575 : }
1576 : }
1577 : else
1578 : {
1579 0 : transformation_argv [i] = argv[i];
1580 : }
1581 :
1582 : // printf ("In loop: i = %d \n",i);
1583 : }
1584 :
1585 : // For now ets only debug the case of a single file specified on the command line
1586 0 : ROSE_ASSERT (fileNameCounter == 1);
1587 0 : ROSE_ASSERT (fileNameLocation > 0);
1588 :
1589 : // We have found the location of the filename in the command line (now modify it)
1590 :
1591 : // now delete the original file name
1592 : // delete argv[fileNameLocation];
1593 : // argv[fileNameLocation] = "rose_transformation.C";
1594 : // argv[fileNameLocation] = "/home/dquinlan/ROSE/NEW_ROSE/TransformationSpecification/rose_transformation.C";
1595 : // argv[fileNameLocation] = "/home/dquinlan2/ROSE/SUN_CC_NOPURIFY/TransformationSpecification/rose_transformation.C";
1596 : // argv[fileNameLocation] = "rose_transformation.C";
1597 :
1598 : #if 0
1599 : // This is not longer required (EDG sets its
1600 : // primary_source_file_name internally from the
1601 : // command line directly).
1602 :
1603 : // Since it is a problem to call EDG more than once with
1604 : // (EDG comand line processing can only be called once)
1605 : // the easiest thing to do is change the name of the primary
1606 : // source file. See notes in the TODO document.
1607 : EDG_secondarySourceFile = argv[fileNameLocation];
1608 : #endif
1609 :
1610 : // printf ("Command line modified to include \"rose_transformation.C\"! \n");
1611 :
1612 0 : return transformation_argv;
1613 : }
1614 :
1615 : std::string
1616 125050 : SgNode::unparseToString(SgUnparse_Info* info) const
1617 : {
1618 : // DQ (4/4/2006): Added optional parameter to customize unparsing
1619 : // Generate the string (don't pass a SgUnparse_Info object so that we can use the
1620 : // default settings).
1621 125050 : std::string outputString = globalUnparseToString(this,info);
1622 125050 : return outputString;
1623 : }
1624 :
1625 : std::string
1626 48082 : SgNode::unparseToString() const
1627 : {
1628 : // DQ (9/6/2010): Move this to the source file (we want to eliminate function definitions in header files).
1629 48082 : return this->unparseToString(NULL);
1630 : }
1631 :
1632 : std::string
1633 0 : SgNode::unparseToCompleteString()
1634 : {
1635 : // Generate the string (pass a SgUnparse_Info object)
1636 0 : SgUnparse_Info* inputUnparseInfoPointer = new SgUnparse_Info();
1637 0 : inputUnparseInfoPointer->unset_SkipComments(); // generate comments
1638 0 : inputUnparseInfoPointer->unset_SkipWhitespaces(); // generate all whitespaces to format the code
1639 0 : std::string outputString = globalUnparseToString(this,inputUnparseInfoPointer);
1640 :
1641 : // DQ (2/18/2013): Added fix to delete SgUnparse_Info built to support unparseToCompleteString().
1642 0 : delete inputUnparseInfoPointer;
1643 0 : inputUnparseInfoPointer = NULL;
1644 :
1645 0 : return outputString;
1646 : }
1647 :
1648 : #if 0
1649 : // JJW 10-25-2007 Removed this because using it makes code very prone to bugs
1650 : // DQ (10/8/2007): I would like to get rid of this mechanism in the future.
1651 : SgShallowCopy *SgShallowCopy::p_static_instance = NULL;
1652 : SgTreeCopy *SgTreeCopy ::p_static_instance = NULL;
1653 : #endif
1654 :
1655 :
1656 :
1657 : void
1658 44373 : SgCopyHelp::insertCopiedNodePair( const SgNode* key, SgNode* value )
1659 : {
1660 : // DQ (10/8/2007): This function support the saving of state used to associated original IR nodes with the copies made of them so that symbols can be updated.
1661 :
1662 88746 : if (copiedNodeMap.find(key) == copiedNodeMap.end())
1663 : {
1664 : // Add the node to the map...
1665 44373 : copiedNodeMap[key] = value;
1666 : }
1667 44373 : }
1668 :
1669 :
1670 : SgNode*
1671 8474 : SgTreeCopy::copyAst( const SgNode *n )
1672 : {
1673 : #if 0
1674 : if (isSgType( const_cast<SgNode*>(n) ) != NULL)
1675 : {
1676 : return const_cast<SgNode *>(n);
1677 : }
1678 :
1679 : SgNode *nCopy = n->copy(*this);
1680 : nCopy->set_parent(NULL);
1681 : return nCopy;
1682 : #else
1683 : // DQ (10/8/2007): I have modified this function to have a single return.
1684 : // This function is called by the copy mechanism to copy AST child trees.
1685 :
1686 8474 : SgNode *nCopy = NULL;
1687 :
1688 : // If this is a SgType, then force it to be shared, since all SgTypes are shared.
1689 : // if (isSgType( const_cast<SgNode*>(n) ) != NULL)
1690 8474 : if (isSgType(n) != NULL)
1691 : {
1692 : // Share the reference to the IR node.
1693 : nCopy = const_cast<SgNode *>(n);
1694 : }
1695 : else
1696 : {
1697 : // If this is a class definition then only do a deep copy if it is from a defining class declaration.
1698 8474 : const SgClassDefinition* classDefinition = isSgClassDefinition(n);
1699 8474 : if (classDefinition != NULL)
1700 : {
1701 0 : ROSE_ASSERT(classDefinition->get_parent() != NULL);
1702 0 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(classDefinition->get_parent());
1703 0 : if (classDeclaration == classDeclaration->get_definingDeclaration())
1704 : {
1705 : // Do a deep copy on this IR node.
1706 0 : nCopy = n->copy(*this);
1707 : }
1708 : else
1709 : {
1710 : // Share the reference to the IR node.
1711 : nCopy = const_cast<SgNode *>(n);
1712 : }
1713 : }
1714 : else
1715 : {
1716 : // Do a deep copy on this IR node.
1717 8474 : nCopy = n->copy(*this);
1718 : }
1719 :
1720 : // Set the parent to NULL, the copy mechanism we set it correctly ...
1721 8474 : nCopy->set_parent(NULL);
1722 : }
1723 :
1724 8474 : return nCopy;
1725 : #endif
1726 : }
1727 :
1728 : #if 0
1729 : bool SgTreeCopy :: clone_node( const SgNode *n ) const
1730 : {
1731 : if (isSgType( const_cast<SgNode*>(n) ) != 0)
1732 : return false;
1733 : return true;
1734 : }
1735 : #endif
1736 :
1737 :
1738 : // DQ (8/10/2008): Added to support binary file format.
1739 : std::ostream &
1740 0 : operator<< ( std::ostream & os, const std::multimap<rose_addr_t, rose_addr_t> & m )
1741 : {
1742 0 : return os;
1743 : }
1744 :
1745 : #if 0
1746 : // DQ (8/10/2008): This is not used!
1747 : std::ostream &
1748 : operator<< ( std::ostream & os, const std::vector<std::pair<rose_addr_t, rose_addr_t> > & l )
1749 : {
1750 : return os;
1751 : }
1752 : #endif
1753 :
1754 : // DQ (8/10/2008): Added to support binary file format.
1755 : std::ostream &
1756 0 : operator<< ( std::ostream & os, const struct stat & sb )
1757 : {
1758 0 : return os;
1759 : }
1760 :
1761 : // DQ (4/5/2017): Moved these function definition out of the header file to avoid warnings from
1762 : // assertion from the header file (OK if it appears once from compiling the source file).
1763 : VirtualCFG::CFGNode
1764 609 : SgNode::cfgForBeginning()
1765 : {
1766 609 : ROSE_ASSERT (this != NULL);
1767 609 : return VirtualCFG::CFGNode(this, 0);
1768 : }
1769 :
1770 : VirtualCFG::CFGNode
1771 976 : SgNode::cfgForEnd()
1772 : {
1773 976 : ROSE_ASSERT (this != NULL);
1774 976 : return VirtualCFG::CFGNode(this, this->cfgIndexForEnd());
1775 : }
1776 :
1777 0 : VariantT SgNode::variantFromPool(SgNode const * n) {
1778 0 : for (std::tuple<unsigned char*, unsigned, VariantT> const & pool: all_pools) {
1779 0 : auto & base = std::get<0>(pool);
1780 0 : auto & size = std::get<1>(pool);
1781 0 : auto offset = ((unsigned char*)n - base);
1782 0 : if ( offset >= 0 && offset < size ) return std::get<2>(pool);
1783 : }
1784 : return (VariantT)0;
1785 : }
1786 :
1787 :
1788 :
1789 : // End of memberFunctionString
1790 : // Start of memberFunctionString
1791 : /* #line 2586 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
1792 :
1793 :
1794 : #if 0
1795 : bool SgNode::error()
1796 : {
1797 : // Put error checking here
1798 :
1799 : ROSE_ASSERT (this != NULL);
1800 : if (getVariant() != NodeTag)
1801 : {
1802 : printf ("Error in SgNode::error(): SgNode object has a %s variant \n",
1803 : Cxx_GrammarTerminalNames[getVariant()].name);
1804 : // printf ("Error in SgNode::error() \n");
1805 : ROSE_ABORT();
1806 : }
1807 :
1808 : // ROSE_ASSERT (getVariant() == SgNodeTag);
1809 : ROSE_ASSERT (getVariant() == NodeTag);
1810 : return false; // //::error();
1811 : }
1812 : #endif
1813 :
1814 :
1815 :
1816 : // End of memberFunctionString
1817 :
1818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
1819 :
1820 563831000 : SgNode* isSgNode ( SgNode* inputDerivedClassPointer )
1821 : {
1822 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
1823 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
1824 : // So to fix this we return NULL directly when the input is NULL and avoid the
1825 : // dynamic_cast in this case. This is likely a performance improvement as well.
1826 : // return dynamic_cast<SgNode*>(inputDerivedClassPointer);
1827 : // Milind Chabbi (8/28/2013): isSgNode uses table-driven castability instead of c++ default dynamic_cast
1828 : // this improves the running time performance by 10-20%.
1829 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNode*>(inputDerivedClassPointer);
1830 563831000 : return IS_SgNode_FAST_MACRO(inputDerivedClassPointer);
1831 : }
1832 :
1833 : // DQ (11/8/2003): Added version of functions taking const pointer
1834 0 : const SgNode* isSgNode ( const SgNode* inputDerivedClassPointer )
1835 : {
1836 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
1837 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
1838 : // So to fix this we return NULL directly when the input is NULL and avoid the
1839 : // dynamic_cast in this case. This is likely a performance improvement as well.
1840 : // return dynamic_cast<const SgNode*>(inputDerivedClassPointer);
1841 : // Milind Chabbi (8/28/2013): isSgNode uses table-driven castability instead of c++ default dynamic_cast
1842 : // this improves the running time performance by 10-20%.
1843 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNode*>(inputDerivedClassPointer);
1844 0 : return IS_SgNode_FAST_MACRO(inputDerivedClassPointer);
1845 : }
1846 :
1847 :
1848 :
1849 : /* #line 1850 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
1850 :
1851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
1852 :
1853 : /**
1854 : \brief Generated destructor
1855 :
1856 : This destructor is automatically generated (by ROSETTA). This destructor
1857 : only frees memory of data members associated with the parts of the current IR node which
1858 : are NOT traversed. Those data members that are part of a traversal can be freed using
1859 : a traversal (calling this destructor on all children in a post-order traversal). Such
1860 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
1861 :
1862 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
1863 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
1864 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
1865 :
1866 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
1867 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
1868 : pointers are not yet implemented to call delete on eash pointer in the container.
1869 : (This could be done by derivation from the STL containers to define containers that
1870 : automatically deleted their members.)
1871 :
1872 : */
1873 922746000 : SgNode::~SgNode () {
1874 461373000 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
1875 :
1876 :
1877 : // case: not a listType for parent
1878 : p_parent = NULL; // non list case
1879 : // case: not a listType for isModified
1880 : p_isModified = false; // non list case
1881 : // case: not a listType for containsTransformation
1882 : p_containsTransformation = false; // non list case
1883 :
1884 : }
1885 :
1886 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
1887 461373000 : }
1888 :
1889 :
1890 : /* #line 1891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
1891 :
1892 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
1893 :
1894 : // Generated constructor
1895 563831000 : SgNode::SgNode ( )
1896 :
1897 : {
1898 : #ifdef DEBUG
1899 : // printf ("In SgNode::SgNode () sage_class_name() = %s \n",sage_class_name());
1900 : #endif
1901 : #if 0
1902 : // debugging information!
1903 : printf ("In SgNode::SgNode (): this = %p = %s \n",this,this->class_name().c_str());
1904 : #endif
1905 :
1906 563831000 : p_parent = NULL;
1907 563831000 : p_isModified = false;
1908 563831000 : p_containsTransformation = false;
1909 563831000 : p_freepointer = AST_FileIO::IS_VALID_POINTER();
1910 :
1911 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
1912 :
1913 : #if 0
1914 : // DQ (7/30/2014): Call a virtual function.
1915 : std::string s = this->class_name();
1916 : #endif
1917 :
1918 : // Test the variant virtual function
1919 : // assert(NodeTag == variant());
1920 563831000 : assert(NodeTag == this->variant());
1921 563831000 : ROSE_ASSERT(NodeTag == (int)(this->variantT()));
1922 563831000 : post_construction_initialization();
1923 :
1924 : // Test the isSgNode() function since it has been problematic
1925 563831000 : assert(isSgNode(this) != NULL);
1926 563831000 : }
1927 :
1928 : // Generated constructor (all data members)
1929 :
1930 : /* #line 1931 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
1931 :
1932 :
1933 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
1934 :
1935 :
1936 : // ********************************************************
1937 : // member functions common across all array grammar objects
1938 : // ********************************************************
1939 :
1940 :
1941 :
1942 : /* #line 1943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
1943 :
1944 :
1945 :
1946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
1947 :
1948 : // ********************************************************
1949 : // member functions specific to each node in the grammar
1950 : // ********************************************************
1951 :
1952 :
1953 : /* #line 1954 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
1954 :
1955 : // Start of memberFunctionString
1956 : /* #line 7807 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
1957 :
1958 : // No functions defined for the GrammarSource
1959 :
1960 :
1961 : // End of memberFunctionString
1962 : // Start of memberFunctionString
1963 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
1964 :
1965 : // *** COMMON CODE SECTION BEGINS HERE ***
1966 :
1967 : #if 0
1968 : int
1969 : SgSupport::getVariant() const
1970 : {
1971 : // This function is used in ROSE while "variant()" is used in SAGE
1972 : assert(this != NULL);
1973 : return variant();
1974 : }
1975 : #endif
1976 :
1977 : // This function is used in ROSE in treeTraversal code
1978 : // eventually replaces getVariant() and variant()
1979 : // though after variant() has been removed for a while we will
1980 : // want to change the name of variantT() back to variant()
1981 : // (since the "T" was ment to stand for temporary).
1982 : // When this happens the variantT() will be depricated.
1983 : VariantT
1984 1646900000 : SgSupport::variantT() const
1985 : {
1986 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
1987 1646900000 : ROSE_ASSERT(this != NULL);
1988 1646900000 : return V_SgSupport;
1989 : }
1990 :
1991 : #if 0
1992 : int
1993 : SgSupport::variant() const
1994 : {
1995 : // This function is used in SAGE
1996 : ROSE_ASSERT(this != NULL);
1997 : return SupportTag;
1998 : }
1999 : #endif
2000 :
2001 : ROSE_DLL_API const char*
2002 0 : SgSupport::sage_class_name() const
2003 : {
2004 0 : ROSE_ASSERT(this != NULL);
2005 0 : return "SgSupport";
2006 : }
2007 :
2008 : std::string
2009 0 : SgSupport::class_name() const
2010 : {
2011 0 : ROSE_ASSERT(this != NULL);
2012 0 : return "SgSupport";
2013 : }
2014 :
2015 : // DQ (11/26/2005): Support for visitor pattern mechanims
2016 : // (inferior to ROSE traversal mechanism, experimental).
2017 : void
2018 0 : SgSupport::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
2019 : {
2020 0 : ROSE_ASSERT(this != NULL);
2021 0 : visitor.visit(this);
2022 0 : }
2023 :
2024 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
2025 0 : void SgSupport::accept (ROSE_VisitorPattern & visitor) {
2026 0 : ROSE_ASSERT(this != NULL);
2027 0 : visitor.visit(this);
2028 0 : }
2029 :
2030 : SgSupport*
2031 0 : SgSupport::addRegExpAttribute(std::string s, AstRegExAttribute* a)
2032 : {
2033 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
2034 : // This function is currently only supported for the AST used the represent Binary executables.
2035 : if (0 /* isSgAsmNode(this) != NULL */)
2036 : {
2037 : // Support for regex specification.
2038 : std::string prefixCode = "REGEX:";
2039 : addNewAttribute(prefixCode + s,a);
2040 : }
2041 : #endif
2042 :
2043 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
2044 0 : return this;
2045 : }
2046 :
2047 : // *** COMMON CODE SECTION ENDS HERE ***
2048 :
2049 :
2050 : // End of memberFunctionString
2051 : // Start of memberFunctionString
2052 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
2053 :
2054 :
2055 : #if 0
2056 : //! Error checking support
2057 : /*! Verifies the following:
2058 : - working getVariant() member function
2059 : - calls base class's error() member function
2060 : Every class has one of these functions.
2061 : */
2062 : bool
2063 : SgSupport::error()
2064 : {
2065 : // Put error checking here
2066 :
2067 : ROSE_ASSERT (this != NULL);
2068 : if (getVariant() != SupportTag)
2069 : {
2070 : printf ("Error in SgSupport::error(): SgSupport object has a %s variant \n",
2071 : Cxx_GrammarTerminalNames[getVariant()].name);
2072 : // printf ("Error in SgSupport::error() \n");
2073 : ROSE_ABORT();
2074 : }
2075 :
2076 : ROSE_ASSERT (getVariant() == SupportTag);
2077 : return SgNode::error();
2078 : }
2079 : #endif
2080 :
2081 :
2082 :
2083 : // End of memberFunctionString
2084 :
2085 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
2086 :
2087 694173000 : SgSupport* isSgSupport ( SgNode* inputDerivedClassPointer )
2088 : {
2089 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
2090 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
2091 : // So to fix this we return NULL directly when the input is NULL and avoid the
2092 : // dynamic_cast in this case. This is likely a performance improvement as well.
2093 : // return dynamic_cast<SgSupport*>(inputDerivedClassPointer);
2094 : // Milind Chabbi (8/28/2013): isSgSupport uses table-driven castability instead of c++ default dynamic_cast
2095 : // this improves the running time performance by 10-20%.
2096 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSupport*>(inputDerivedClassPointer);
2097 694173000 : return IS_SgSupport_FAST_MACRO(inputDerivedClassPointer);
2098 : }
2099 :
2100 : // DQ (11/8/2003): Added version of functions taking const pointer
2101 1852430 : const SgSupport* isSgSupport ( const SgNode* inputDerivedClassPointer )
2102 : {
2103 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
2104 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
2105 : // So to fix this we return NULL directly when the input is NULL and avoid the
2106 : // dynamic_cast in this case. This is likely a performance improvement as well.
2107 : // return dynamic_cast<const SgSupport*>(inputDerivedClassPointer);
2108 : // Milind Chabbi (8/28/2013): isSgSupport uses table-driven castability instead of c++ default dynamic_cast
2109 : // this improves the running time performance by 10-20%.
2110 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSupport*>(inputDerivedClassPointer);
2111 1852430 : return IS_SgSupport_FAST_MACRO(inputDerivedClassPointer);
2112 : }
2113 :
2114 :
2115 :
2116 : /* #line 2117 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2117 :
2118 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
2119 :
2120 : /**
2121 : \brief Generated destructor
2122 :
2123 : This destructor is automatically generated (by ROSETTA). This destructor
2124 : only frees memory of data members associated with the parts of the current IR node which
2125 : are NOT traversed. Those data members that are part of a traversal can be freed using
2126 : a traversal (calling this destructor on all children in a post-order traversal). Such
2127 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
2128 :
2129 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
2130 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
2131 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
2132 :
2133 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
2134 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
2135 : pointers are not yet implemented to call delete on eash pointer in the container.
2136 : (This could be done by derivation from the STL containers to define containers that
2137 : automatically deleted their members.)
2138 :
2139 : */
2140 459540000 : SgSupport::~SgSupport () {
2141 459540000 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
2142 :
2143 :
2144 :
2145 : }
2146 :
2147 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
2148 459540000 : }
2149 :
2150 :
2151 : /* #line 2152 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2152 :
2153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
2154 :
2155 : // Generated constructor
2156 548965000 : SgSupport::SgSupport ( )
2157 548965000 : : SgNode()
2158 : {
2159 : #ifdef DEBUG
2160 : // printf ("In SgSupport::SgSupport () sage_class_name() = %s \n",sage_class_name());
2161 : #endif
2162 : #if 0
2163 : // debugging information!
2164 : printf ("In SgSupport::SgSupport (): this = %p = %s \n",this,this->class_name().c_str());
2165 : #endif
2166 :
2167 :
2168 :
2169 : #if 0
2170 : // DQ (7/30/2014): Call a virtual function.
2171 : std::string s = this->class_name();
2172 : #endif
2173 :
2174 : // Test the variant virtual function
2175 : // assert(SupportTag == variant());
2176 548965000 : assert(SupportTag == this->variant());
2177 548965000 : ROSE_ASSERT(SupportTag == (int)(this->variantT()));
2178 548965000 : post_construction_initialization();
2179 :
2180 : // Test the isSgSupport() function since it has been problematic
2181 548965000 : assert(isSgSupport(this) != NULL);
2182 548965000 : }
2183 :
2184 : // Generated constructor (all data members)
2185 :
2186 : /* #line 2187 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2187 :
2188 :
2189 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
2190 :
2191 :
2192 : // ********************************************************
2193 : // member functions common across all array grammar objects
2194 : // ********************************************************
2195 :
2196 :
2197 :
2198 : /* #line 2199 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2199 :
2200 :
2201 :
2202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
2203 :
2204 : // ********************************************************
2205 : // member functions specific to each node in the grammar
2206 : // ********************************************************
2207 :
2208 :
2209 : /* #line 2210 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2210 :
2211 : // Start of memberFunctionString
2212 : /* #line 2543 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
2213 :
2214 :
2215 0 : SgModifier::SgModifier ( const SgModifier & X )
2216 : {
2217 : // DQ (4/13/2004): Nothing to do here, but this function prevents the SgSupport copy
2218 : // constructor from being called and we would like to keep that copy constructor
2219 : // private so that we can enforce error checking via the type system.
2220 0 : }
2221 :
2222 : SgModifier &
2223 0 : SgModifier::operator= ( const SgModifier & X )
2224 : {
2225 0 : return *this;
2226 : }
2227 :
2228 : bool
2229 5003390 : SgModifier::checkBit ( unsigned int bit, const SgBitVector & bitVector ) const
2230 : {
2231 5003390 : ROSE_ASSERT (bit < bitVector.size());
2232 5003390 : return bitVector[bit];
2233 : }
2234 :
2235 : void
2236 20340500 : SgModifier::setBit ( unsigned int bit, SgBitVector & bitVector ) const
2237 : {
2238 20340500 : ROSE_ASSERT (bit < bitVector.size());
2239 20340500 : bitVector[bit] = true;
2240 20340500 : }
2241 :
2242 : void
2243 14002300 : SgModifier::unsetBit ( unsigned int bit, SgBitVector & bitVector ) const
2244 : {
2245 14002300 : ROSE_ASSERT (bit < bitVector.size());
2246 14002300 : bitVector[bit] = false;
2247 14002300 : }
2248 :
2249 :
2250 :
2251 : // End of memberFunctionString
2252 : // Start of memberFunctionString
2253 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
2254 :
2255 : // *** COMMON CODE SECTION BEGINS HERE ***
2256 :
2257 : #if 0
2258 : int
2259 : SgModifier::getVariant() const
2260 : {
2261 : // This function is used in ROSE while "variant()" is used in SAGE
2262 : assert(this != NULL);
2263 : return variant();
2264 : }
2265 : #endif
2266 :
2267 : // This function is used in ROSE in treeTraversal code
2268 : // eventually replaces getVariant() and variant()
2269 : // though after variant() has been removed for a while we will
2270 : // want to change the name of variantT() back to variant()
2271 : // (since the "T" was ment to stand for temporary).
2272 : // When this happens the variantT() will be depricated.
2273 : VariantT
2274 148449000 : SgModifier::variantT() const
2275 : {
2276 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
2277 148449000 : ROSE_ASSERT(this != NULL);
2278 148449000 : return V_SgModifier;
2279 : }
2280 :
2281 : #if 0
2282 : int
2283 : SgModifier::variant() const
2284 : {
2285 : // This function is used in SAGE
2286 : ROSE_ASSERT(this != NULL);
2287 : return ModifierTag;
2288 : }
2289 : #endif
2290 :
2291 : ROSE_DLL_API const char*
2292 0 : SgModifier::sage_class_name() const
2293 : {
2294 0 : ROSE_ASSERT(this != NULL);
2295 0 : return "SgModifier";
2296 : }
2297 :
2298 : std::string
2299 0 : SgModifier::class_name() const
2300 : {
2301 0 : ROSE_ASSERT(this != NULL);
2302 0 : return "SgModifier";
2303 : }
2304 :
2305 : // DQ (11/26/2005): Support for visitor pattern mechanims
2306 : // (inferior to ROSE traversal mechanism, experimental).
2307 : void
2308 0 : SgModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
2309 : {
2310 0 : ROSE_ASSERT(this != NULL);
2311 0 : visitor.visit(this);
2312 0 : }
2313 :
2314 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
2315 0 : void SgModifier::accept (ROSE_VisitorPattern & visitor) {
2316 0 : ROSE_ASSERT(this != NULL);
2317 0 : visitor.visit(this);
2318 0 : }
2319 :
2320 : SgModifier*
2321 0 : SgModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
2322 : {
2323 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
2324 : // This function is currently only supported for the AST used the represent Binary executables.
2325 : if (0 /* isSgAsmNode(this) != NULL */)
2326 : {
2327 : // Support for regex specification.
2328 : std::string prefixCode = "REGEX:";
2329 : addNewAttribute(prefixCode + s,a);
2330 : }
2331 : #endif
2332 :
2333 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
2334 0 : return this;
2335 : }
2336 :
2337 : // *** COMMON CODE SECTION ENDS HERE ***
2338 :
2339 :
2340 : // End of memberFunctionString
2341 : // Start of memberFunctionString
2342 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
2343 :
2344 :
2345 : #if 0
2346 : //! Error checking support
2347 : /*! Verifies the following:
2348 : - working getVariant() member function
2349 : - calls base class's error() member function
2350 : Every class has one of these functions.
2351 : */
2352 : bool
2353 : SgModifier::error()
2354 : {
2355 : // Put error checking here
2356 :
2357 : ROSE_ASSERT (this != NULL);
2358 : if (getVariant() != ModifierTag)
2359 : {
2360 : printf ("Error in SgModifier::error(): SgModifier object has a %s variant \n",
2361 : Cxx_GrammarTerminalNames[getVariant()].name);
2362 : // printf ("Error in SgModifier::error() \n");
2363 : ROSE_ABORT();
2364 : }
2365 :
2366 : ROSE_ASSERT (getVariant() == ModifierTag);
2367 : return SgSupport::error();
2368 : }
2369 : #endif
2370 :
2371 :
2372 :
2373 : // End of memberFunctionString
2374 :
2375 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
2376 :
2377 49482900 : SgModifier* isSgModifier ( SgNode* inputDerivedClassPointer )
2378 : {
2379 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
2380 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
2381 : // So to fix this we return NULL directly when the input is NULL and avoid the
2382 : // dynamic_cast in this case. This is likely a performance improvement as well.
2383 : // return dynamic_cast<SgModifier*>(inputDerivedClassPointer);
2384 : // Milind Chabbi (8/28/2013): isSgModifier uses table-driven castability instead of c++ default dynamic_cast
2385 : // this improves the running time performance by 10-20%.
2386 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModifier*>(inputDerivedClassPointer);
2387 49482900 : return IS_SgModifier_FAST_MACRO(inputDerivedClassPointer);
2388 : }
2389 :
2390 : // DQ (11/8/2003): Added version of functions taking const pointer
2391 0 : const SgModifier* isSgModifier ( const SgNode* inputDerivedClassPointer )
2392 : {
2393 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
2394 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
2395 : // So to fix this we return NULL directly when the input is NULL and avoid the
2396 : // dynamic_cast in this case. This is likely a performance improvement as well.
2397 : // return dynamic_cast<const SgModifier*>(inputDerivedClassPointer);
2398 : // Milind Chabbi (8/28/2013): isSgModifier uses table-driven castability instead of c++ default dynamic_cast
2399 : // this improves the running time performance by 10-20%.
2400 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModifier*>(inputDerivedClassPointer);
2401 0 : return IS_SgModifier_FAST_MACRO(inputDerivedClassPointer);
2402 : }
2403 :
2404 :
2405 :
2406 : /* #line 2407 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2407 :
2408 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
2409 :
2410 : /**
2411 : \brief Generated destructor
2412 :
2413 : This destructor is automatically generated (by ROSETTA). This destructor
2414 : only frees memory of data members associated with the parts of the current IR node which
2415 : are NOT traversed. Those data members that are part of a traversal can be freed using
2416 : a traversal (calling this destructor on all children in a post-order traversal). Such
2417 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
2418 :
2419 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
2420 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
2421 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
2422 :
2423 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
2424 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
2425 : pointers are not yet implemented to call delete on eash pointer in the container.
2426 : (This could be done by derivation from the STL containers to define containers that
2427 : automatically deleted their members.)
2428 :
2429 : */
2430 11544800 : SgModifier::~SgModifier () {
2431 11544800 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
2432 :
2433 :
2434 :
2435 : }
2436 :
2437 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
2438 11544800 : }
2439 :
2440 :
2441 : /* #line 2442 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2442 :
2443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
2444 :
2445 : // Generated constructor
2446 49482900 : SgModifier::SgModifier ( )
2447 49482900 : : SgSupport()
2448 : {
2449 : #ifdef DEBUG
2450 : // printf ("In SgModifier::SgModifier () sage_class_name() = %s \n",sage_class_name());
2451 : #endif
2452 : #if 0
2453 : // debugging information!
2454 : printf ("In SgModifier::SgModifier (): this = %p = %s \n",this,this->class_name().c_str());
2455 : #endif
2456 :
2457 :
2458 :
2459 : #if 0
2460 : // DQ (7/30/2014): Call a virtual function.
2461 : std::string s = this->class_name();
2462 : #endif
2463 :
2464 : // Test the variant virtual function
2465 : // assert(ModifierTag == variant());
2466 49482900 : assert(ModifierTag == this->variant());
2467 49482900 : ROSE_ASSERT(ModifierTag == (int)(this->variantT()));
2468 49482900 : post_construction_initialization();
2469 :
2470 : // Test the isSgModifier() function since it has been problematic
2471 49482900 : assert(isSgModifier(this) != NULL);
2472 49482900 : }
2473 :
2474 : // Generated constructor (all data members)
2475 :
2476 : /* #line 2477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2477 :
2478 :
2479 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
2480 :
2481 :
2482 : // ********************************************************
2483 : // member functions common across all array grammar objects
2484 : // ********************************************************
2485 :
2486 :
2487 :
2488 : /* #line 2489 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2489 :
2490 :
2491 :
2492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
2493 :
2494 : // ********************************************************
2495 : // member functions specific to each node in the grammar
2496 : // ********************************************************
2497 :
2498 :
2499 : /* #line 2500 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2500 :
2501 : // Start of memberFunctionString
2502 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
2503 :
2504 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
2505 :
2506 : SgModifierTypePtrVector
2507 0 : SgModifierNodes::get_nodes () const
2508 : {
2509 0 : ROSE_ASSERT (this != NULL);
2510 :
2511 : #if 0
2512 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
2513 : // used to trigger marking transformations for the token-based unparsing.
2514 : printf ("SgModifierNodes::get_nodes = %p = %s \n",this,this->class_name().c_str());
2515 : #endif
2516 :
2517 0 : return p_nodes;
2518 : }
2519 :
2520 : void
2521 0 : SgModifierNodes::set_nodes ( SgModifierTypePtrVector nodes )
2522 : {
2523 0 : ROSE_ASSERT (this != NULL);
2524 :
2525 : #if 0
2526 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
2527 : // used to trigger marking transformations for the token-based unparsing.
2528 : printf ("SgModifierNodes::set_nodes = %p = %s \n",this,this->class_name().c_str());
2529 : #endif
2530 :
2531 0 : set_isModified(true);
2532 :
2533 0 : p_nodes = nodes;
2534 0 : }
2535 :
2536 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
2537 :
2538 :
2539 : // End of memberFunctionString
2540 : // Start of memberFunctionString
2541 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
2542 :
2543 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
2544 :
2545 : SgModifierNodes*
2546 0 : SgModifierNodes::get_next () const
2547 : {
2548 0 : ROSE_ASSERT (this != NULL);
2549 :
2550 : #if 0
2551 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
2552 : // used to trigger marking transformations for the token-based unparsing.
2553 : printf ("SgModifierNodes::get_next = %p = %s \n",this,this->class_name().c_str());
2554 : #endif
2555 :
2556 0 : return p_next;
2557 : }
2558 :
2559 : void
2560 0 : SgModifierNodes::set_next ( SgModifierNodes* next )
2561 : {
2562 0 : ROSE_ASSERT (this != NULL);
2563 :
2564 : #if 0
2565 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
2566 : // used to trigger marking transformations for the token-based unparsing.
2567 : printf ("SgModifierNodes::set_next = %p = %s \n",this,this->class_name().c_str());
2568 : #endif
2569 :
2570 0 : set_isModified(true);
2571 :
2572 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
2573 : if (p_next != NULL && next != NULL && p_next != next)
2574 : {
2575 : printf ("Warning: next = %p overwriting valid pointer p_next = %p \n",next,p_next);
2576 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
2577 : printf ("Error fails assertion (p_next != NULL && next != NULL && p_next != next) is false\n");
2578 : ROSE_ASSERT(false);
2579 : #endif
2580 : }
2581 : #endif
2582 0 : p_next = next;
2583 0 : }
2584 :
2585 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
2586 :
2587 :
2588 : // End of memberFunctionString
2589 : // Start of memberFunctionString
2590 : /* #line 2582 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
2591 :
2592 :
2593 : #if 1
2594 : // These are generated
2595 0 : SgModifierNodes::SgModifierNodes()
2596 : {
2597 : // p_nodes[0] = p_nodes[1] = p_nodes[2] = p_nodes[3] = (SgModifierType*)0L;
2598 : // p_next = (SgModifierNodes*)0L;
2599 : // MK: Call the following function instead
2600 0 : post_construction_initialization();
2601 0 : }
2602 :
2603 : #if 0
2604 : SgModifierNodes::~SgModifierNodes()
2605 : {
2606 : // delete nodes[];
2607 : delete p_next;
2608 : }
2609 : #endif
2610 : #endif
2611 :
2612 : void
2613 0 : SgModifierNodes::post_construction_initialization()
2614 : {
2615 : // nodes = new (SgModifierType*)[4];
2616 : // p_nodes[0] = p_nodes[1] = p_nodes[2] = p_nodes[3] = (SgModifierType*)0L;
2617 : // MK: p_nodes is an STL vector now, it needs to be initilized differently
2618 0 : for (int i= 0; i<4; i++)
2619 0 : p_nodes.push_back((SgModifierType*) NULL);
2620 0 : p_next = (SgModifierNodes*) NULL;
2621 0 : }
2622 :
2623 : #if 0
2624 : // DQ (4/13/2004): Commented out as a test to see if we need this function
2625 : SgModifierType*
2626 : SgModifierNodes::match(SgType* base, unsigned int f)
2627 : {
2628 : for (int j = 0; j < 4; j++)
2629 : {
2630 : if (!p_nodes[j])
2631 : {
2632 : SgModifierType* newType = new SgModifierType(base, f);
2633 : assert(newType != NULL);
2634 :
2635 : p_nodes[j] = newType;
2636 : assert(p_nodes[j] != NULL);
2637 :
2638 : return p_nodes[j];
2639 : // return nodes[j] = new SgModifierType(base, f);
2640 : }
2641 : assert(p_nodes[j] != NULL);
2642 : if (p_nodes[j]->bitfield() == f)
2643 : {
2644 : return p_nodes[j];
2645 : }
2646 : }
2647 :
2648 : if (!p_next)
2649 : {
2650 : p_next = new SgModifierNodes();
2651 : assert(p_next != NULL);
2652 : }
2653 :
2654 : return p_next->match(base, f);
2655 : }
2656 : #endif
2657 :
2658 :
2659 :
2660 : // End of memberFunctionString
2661 : // Start of memberFunctionString
2662 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
2663 :
2664 : // *** COMMON CODE SECTION BEGINS HERE ***
2665 :
2666 : #if 0
2667 : int
2668 : SgModifierNodes::getVariant() const
2669 : {
2670 : // This function is used in ROSE while "variant()" is used in SAGE
2671 : assert(this != NULL);
2672 : return variant();
2673 : }
2674 : #endif
2675 :
2676 : // This function is used in ROSE in treeTraversal code
2677 : // eventually replaces getVariant() and variant()
2678 : // though after variant() has been removed for a while we will
2679 : // want to change the name of variantT() back to variant()
2680 : // (since the "T" was ment to stand for temporary).
2681 : // When this happens the variantT() will be depricated.
2682 : VariantT
2683 0 : SgModifierNodes::variantT() const
2684 : {
2685 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
2686 0 : ROSE_ASSERT(this != NULL);
2687 0 : return V_SgModifierNodes;
2688 : }
2689 :
2690 : #if 0
2691 : int
2692 : SgModifierNodes::variant() const
2693 : {
2694 : // This function is used in SAGE
2695 : ROSE_ASSERT(this != NULL);
2696 : return ModifierNodesTag;
2697 : }
2698 : #endif
2699 :
2700 : ROSE_DLL_API const char*
2701 0 : SgModifierNodes::sage_class_name() const
2702 : {
2703 0 : ROSE_ASSERT(this != NULL);
2704 0 : return "SgModifierNodes";
2705 : }
2706 :
2707 : std::string
2708 0 : SgModifierNodes::class_name() const
2709 : {
2710 0 : ROSE_ASSERT(this != NULL);
2711 0 : return "SgModifierNodes";
2712 : }
2713 :
2714 : // DQ (11/26/2005): Support for visitor pattern mechanims
2715 : // (inferior to ROSE traversal mechanism, experimental).
2716 : void
2717 0 : SgModifierNodes::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
2718 : {
2719 0 : ROSE_ASSERT(this != NULL);
2720 0 : visitor.visit(this);
2721 0 : }
2722 :
2723 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
2724 0 : void SgModifierNodes::accept (ROSE_VisitorPattern & visitor) {
2725 0 : ROSE_ASSERT(this != NULL);
2726 0 : visitor.visit(this);
2727 0 : }
2728 :
2729 : SgModifierNodes*
2730 0 : SgModifierNodes::addRegExpAttribute(std::string s, AstRegExAttribute* a)
2731 : {
2732 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
2733 : // This function is currently only supported for the AST used the represent Binary executables.
2734 : if (0 /* isSgAsmNode(this) != NULL */)
2735 : {
2736 : // Support for regex specification.
2737 : std::string prefixCode = "REGEX:";
2738 : addNewAttribute(prefixCode + s,a);
2739 : }
2740 : #endif
2741 :
2742 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
2743 0 : return this;
2744 : }
2745 :
2746 : // *** COMMON CODE SECTION ENDS HERE ***
2747 :
2748 :
2749 : // End of memberFunctionString
2750 : // Start of memberFunctionString
2751 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
2752 :
2753 :
2754 : #if 0
2755 : //! Error checking support
2756 : /*! Verifies the following:
2757 : - working getVariant() member function
2758 : - calls base class's error() member function
2759 : Every class has one of these functions.
2760 : */
2761 : bool
2762 : SgModifierNodes::error()
2763 : {
2764 : // Put error checking here
2765 :
2766 : ROSE_ASSERT (this != NULL);
2767 : if (getVariant() != ModifierNodesTag)
2768 : {
2769 : printf ("Error in SgModifierNodes::error(): SgModifierNodes object has a %s variant \n",
2770 : Cxx_GrammarTerminalNames[getVariant()].name);
2771 : // printf ("Error in SgModifierNodes::error() \n");
2772 : ROSE_ABORT();
2773 : }
2774 :
2775 : ROSE_ASSERT (getVariant() == ModifierNodesTag);
2776 : return SgModifier::error();
2777 : }
2778 : #endif
2779 :
2780 :
2781 :
2782 : // End of memberFunctionString
2783 :
2784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
2785 :
2786 0 : SgModifierNodes* isSgModifierNodes ( SgNode* inputDerivedClassPointer )
2787 : {
2788 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
2789 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
2790 : // So to fix this we return NULL directly when the input is NULL and avoid the
2791 : // dynamic_cast in this case. This is likely a performance improvement as well.
2792 : // return dynamic_cast<SgModifierNodes*>(inputDerivedClassPointer);
2793 : // Milind Chabbi (8/28/2013): isSgModifierNodes uses table-driven castability instead of c++ default dynamic_cast
2794 : // this improves the running time performance by 10-20%.
2795 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModifierNodes*>(inputDerivedClassPointer);
2796 0 : return IS_SgModifierNodes_FAST_MACRO(inputDerivedClassPointer);
2797 : }
2798 :
2799 : // DQ (11/8/2003): Added version of functions taking const pointer
2800 0 : const SgModifierNodes* isSgModifierNodes ( const SgNode* inputDerivedClassPointer )
2801 : {
2802 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
2803 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
2804 : // So to fix this we return NULL directly when the input is NULL and avoid the
2805 : // dynamic_cast in this case. This is likely a performance improvement as well.
2806 : // return dynamic_cast<const SgModifierNodes*>(inputDerivedClassPointer);
2807 : // Milind Chabbi (8/28/2013): isSgModifierNodes uses table-driven castability instead of c++ default dynamic_cast
2808 : // this improves the running time performance by 10-20%.
2809 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModifierNodes*>(inputDerivedClassPointer);
2810 0 : return IS_SgModifierNodes_FAST_MACRO(inputDerivedClassPointer);
2811 : }
2812 :
2813 :
2814 :
2815 : /* #line 2816 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2816 :
2817 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
2818 :
2819 : /**
2820 : \brief Generated destructor
2821 :
2822 : This destructor is automatically generated (by ROSETTA). This destructor
2823 : only frees memory of data members associated with the parts of the current IR node which
2824 : are NOT traversed. Those data members that are part of a traversal can be freed using
2825 : a traversal (calling this destructor on all children in a post-order traversal). Such
2826 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
2827 :
2828 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
2829 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
2830 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
2831 :
2832 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
2833 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
2834 : pointers are not yet implemented to call delete on eash pointer in the container.
2835 : (This could be done by derivation from the STL containers to define containers that
2836 : automatically deleted their members.)
2837 :
2838 : */
2839 0 : SgModifierNodes::~SgModifierNodes () {
2840 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
2841 :
2842 :
2843 : // case: not a listType for next
2844 0 : p_next = NULL; // non list case
2845 :
2846 : }
2847 :
2848 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
2849 0 : }
2850 :
2851 :
2852 : /* #line 2853 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2853 :
2854 :
2855 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
2856 :
2857 :
2858 : // ********************************************************
2859 : // member functions common across all array grammar objects
2860 : // ********************************************************
2861 :
2862 :
2863 :
2864 : /* #line 2865 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2865 :
2866 :
2867 :
2868 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
2869 :
2870 : // ********************************************************
2871 : // member functions specific to each node in the grammar
2872 : // ********************************************************
2873 :
2874 :
2875 : /* #line 2876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
2876 :
2877 : // Start of memberFunctionString
2878 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
2879 :
2880 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
2881 :
2882 : SgConstVolatileModifier::cv_modifier_enum
2883 0 : SgConstVolatileModifier::get_modifier () const
2884 : {
2885 0 : ROSE_ASSERT (this != NULL);
2886 :
2887 : #if 0
2888 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
2889 : // used to trigger marking transformations for the token-based unparsing.
2890 : printf ("SgConstVolatileModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
2891 : #endif
2892 :
2893 0 : return p_modifier;
2894 : }
2895 :
2896 : void
2897 0 : SgConstVolatileModifier::set_modifier ( SgConstVolatileModifier::cv_modifier_enum modifier )
2898 : {
2899 0 : ROSE_ASSERT (this != NULL);
2900 :
2901 : #if 0
2902 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
2903 : // used to trigger marking transformations for the token-based unparsing.
2904 : printf ("SgConstVolatileModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
2905 : #endif
2906 :
2907 0 : set_isModified(true);
2908 :
2909 0 : p_modifier = modifier;
2910 0 : }
2911 :
2912 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
2913 :
2914 :
2915 : // End of memberFunctionString
2916 : // Start of memberFunctionString
2917 : /* #line 2652 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
2918 :
2919 :
2920 0 : SgConstVolatileModifier::SgConstVolatileModifier ( const SgConstVolatileModifier & X )
2921 : {
2922 0 : p_modifier = X.p_modifier;
2923 0 : }
2924 :
2925 : SgConstVolatileModifier &
2926 163337 : SgConstVolatileModifier::operator= ( const SgConstVolatileModifier & X )
2927 : {
2928 163337 : p_modifier = X.p_modifier;
2929 163337 : return *this;
2930 : }
2931 :
2932 : void
2933 5130600 : SgConstVolatileModifier::post_construction_initialization()
2934 : {
2935 5130600 : p_modifier = e_default;
2936 5130600 : }
2937 :
2938 18273 : bool SgConstVolatileModifier::isUnknown() const { return p_modifier == e_unknown; }
2939 0 : void SgConstVolatileModifier::setUnknown() { p_modifier = e_unknown; }
2940 :
2941 18273 : bool SgConstVolatileModifier::isDefault() const { return p_modifier == e_default; }
2942 12815700 : void SgConstVolatileModifier::setDefault() { p_modifier = e_default; }
2943 :
2944 614439 : bool SgConstVolatileModifier::isConst() const { return p_modifier == e_const || p_modifier == e_const_volatile; }
2945 13519 : void SgConstVolatileModifier::setConst() { p_modifier = (p_modifier == e_volatile) ? e_const_volatile : e_const; }
2946 0 : void SgConstVolatileModifier::unsetConst() { p_modifier = (p_modifier == e_const_volatile) ? e_volatile : e_default; }
2947 :
2948 612298 : bool SgConstVolatileModifier::isVolatile() const { return p_modifier == e_volatile || p_modifier == e_const_volatile; }
2949 1519 : void SgConstVolatileModifier::setVolatile() { p_modifier = (p_modifier == e_const) ? e_const_volatile : e_volatile; }
2950 0 : void SgConstVolatileModifier::unsetVolatile() { p_modifier = (p_modifier == e_const_volatile) ? e_const : e_default; }
2951 :
2952 : string
2953 6893 : SgConstVolatileModifier::displayString() const
2954 : {
2955 6893 : std::string s = "SgConstVolatileModifier(";
2956 27572 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
2957 24854 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
2958 23399 : s += std::string("isConst() = ") + std::string(isConst() ? "true " : "false ");
2959 27562 : s += std::string("isVolatile() = ") + std::string(isVolatile() ? "true " : "false ");
2960 :
2961 6893 : s += ")";
2962 6893 : return s;
2963 : }
2964 :
2965 : void
2966 0 : SgConstVolatileModifier::display ( std::string label ) const
2967 : {
2968 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
2969 0 : printf ("In SgConstVolatileModifier::display(%s) \n",label.c_str());
2970 : #if 0
2971 : mprintf (" isUnknown() = %s \n",isUnknown() ? "true" : "false");
2972 : mprintf (" isDefault() = %s \n",isDefault() ? "true" : "false");
2973 : mprintf (" isConst() = %s \n",isConst() ? "true" : "false");
2974 : mprintf (" isVolatile() = %s \n",isVolatile() ? "true" : "false");
2975 : #else
2976 0 : printf ("%s \n",displayString().c_str());
2977 : #endif
2978 0 : }
2979 :
2980 0 : std::ostream & operator<< ( std::ostream & os, const SgConstVolatileModifier & m)
2981 : {
2982 0 : os << m.get_modifier();
2983 0 : return os;
2984 : }
2985 :
2986 5690 : bool operator== (const SgConstVolatileModifier& lhs, const SgConstVolatileModifier& rhs)
2987 : {
2988 5690 : return
2989 11380 : (lhs.isUnknown() == rhs.isUnknown() ) &&
2990 10768 : (lhs.isDefault() == rhs.isDefault() ) &&
2991 15846 : (lhs.isConst() == rhs.isConst() ) &&
2992 5078 : (lhs.isVolatile() == rhs.isVolatile()) ;
2993 : }
2994 :
2995 :
2996 : // DQ (2/4/2006): Added mechamism to clear all bits
2997 12815700 : void SgConstVolatileModifier::reset()
2998 : {
2999 12815700 : setDefault();
3000 12815700 : }
3001 :
3002 :
3003 :
3004 : // End of memberFunctionString
3005 : // Start of memberFunctionString
3006 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
3007 :
3008 : // *** COMMON CODE SECTION BEGINS HERE ***
3009 :
3010 : #if 0
3011 : int
3012 : SgConstVolatileModifier::getVariant() const
3013 : {
3014 : // This function is used in ROSE while "variant()" is used in SAGE
3015 : assert(this != NULL);
3016 : return variant();
3017 : }
3018 : #endif
3019 :
3020 : // This function is used in ROSE in treeTraversal code
3021 : // eventually replaces getVariant() and variant()
3022 : // though after variant() has been removed for a while we will
3023 : // want to change the name of variantT() back to variant()
3024 : // (since the "T" was ment to stand for temporary).
3025 : // When this happens the variantT() will be depricated.
3026 : VariantT
3027 15391800 : SgConstVolatileModifier::variantT() const
3028 : {
3029 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
3030 15391800 : ROSE_ASSERT(this != NULL);
3031 15391800 : return V_SgConstVolatileModifier;
3032 : }
3033 :
3034 : #if 0
3035 : int
3036 : SgConstVolatileModifier::variant() const
3037 : {
3038 : // This function is used in SAGE
3039 : ROSE_ASSERT(this != NULL);
3040 : return ConstVolatileModifierTag;
3041 : }
3042 : #endif
3043 :
3044 : ROSE_DLL_API const char*
3045 0 : SgConstVolatileModifier::sage_class_name() const
3046 : {
3047 0 : ROSE_ASSERT(this != NULL);
3048 0 : return "SgConstVolatileModifier";
3049 : }
3050 :
3051 : std::string
3052 0 : SgConstVolatileModifier::class_name() const
3053 : {
3054 0 : ROSE_ASSERT(this != NULL);
3055 0 : return "SgConstVolatileModifier";
3056 : }
3057 :
3058 : // DQ (11/26/2005): Support for visitor pattern mechanims
3059 : // (inferior to ROSE traversal mechanism, experimental).
3060 : void
3061 0 : SgConstVolatileModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
3062 : {
3063 0 : ROSE_ASSERT(this != NULL);
3064 0 : visitor.visit(this);
3065 0 : }
3066 :
3067 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
3068 0 : void SgConstVolatileModifier::accept (ROSE_VisitorPattern & visitor) {
3069 0 : ROSE_ASSERT(this != NULL);
3070 0 : visitor.visit(this);
3071 0 : }
3072 :
3073 : SgConstVolatileModifier*
3074 0 : SgConstVolatileModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
3075 : {
3076 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
3077 : // This function is currently only supported for the AST used the represent Binary executables.
3078 : if (0 /* isSgAsmNode(this) != NULL */)
3079 : {
3080 : // Support for regex specification.
3081 : std::string prefixCode = "REGEX:";
3082 : addNewAttribute(prefixCode + s,a);
3083 : }
3084 : #endif
3085 :
3086 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
3087 0 : return this;
3088 : }
3089 :
3090 : // *** COMMON CODE SECTION ENDS HERE ***
3091 :
3092 :
3093 : // End of memberFunctionString
3094 : // Start of memberFunctionString
3095 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
3096 :
3097 :
3098 : #if 0
3099 : //! Error checking support
3100 : /*! Verifies the following:
3101 : - working getVariant() member function
3102 : - calls base class's error() member function
3103 : Every class has one of these functions.
3104 : */
3105 : bool
3106 : SgConstVolatileModifier::error()
3107 : {
3108 : // Put error checking here
3109 :
3110 : ROSE_ASSERT (this != NULL);
3111 : if (getVariant() != ConstVolatileModifierTag)
3112 : {
3113 : printf ("Error in SgConstVolatileModifier::error(): SgConstVolatileModifier object has a %s variant \n",
3114 : Cxx_GrammarTerminalNames[getVariant()].name);
3115 : // printf ("Error in SgConstVolatileModifier::error() \n");
3116 : ROSE_ABORT();
3117 : }
3118 :
3119 : ROSE_ASSERT (getVariant() == ConstVolatileModifierTag);
3120 : return SgModifier::error();
3121 : }
3122 : #endif
3123 :
3124 :
3125 :
3126 : // End of memberFunctionString
3127 :
3128 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
3129 :
3130 5130600 : SgConstVolatileModifier* isSgConstVolatileModifier ( SgNode* inputDerivedClassPointer )
3131 : {
3132 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
3133 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
3134 : // So to fix this we return NULL directly when the input is NULL and avoid the
3135 : // dynamic_cast in this case. This is likely a performance improvement as well.
3136 : // return dynamic_cast<SgConstVolatileModifier*>(inputDerivedClassPointer);
3137 : // Milind Chabbi (8/28/2013): isSgConstVolatileModifier uses table-driven castability instead of c++ default dynamic_cast
3138 : // this improves the running time performance by 10-20%.
3139 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgConstVolatileModifier*>(inputDerivedClassPointer);
3140 5130600 : return IS_SgConstVolatileModifier_FAST_MACRO(inputDerivedClassPointer);
3141 : }
3142 :
3143 : // DQ (11/8/2003): Added version of functions taking const pointer
3144 0 : const SgConstVolatileModifier* isSgConstVolatileModifier ( const SgNode* inputDerivedClassPointer )
3145 : {
3146 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
3147 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
3148 : // So to fix this we return NULL directly when the input is NULL and avoid the
3149 : // dynamic_cast in this case. This is likely a performance improvement as well.
3150 : // return dynamic_cast<const SgConstVolatileModifier*>(inputDerivedClassPointer);
3151 : // Milind Chabbi (8/28/2013): isSgConstVolatileModifier uses table-driven castability instead of c++ default dynamic_cast
3152 : // this improves the running time performance by 10-20%.
3153 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgConstVolatileModifier*>(inputDerivedClassPointer);
3154 0 : return IS_SgConstVolatileModifier_FAST_MACRO(inputDerivedClassPointer);
3155 : }
3156 :
3157 :
3158 :
3159 : /* #line 3160 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3160 :
3161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
3162 :
3163 : /**
3164 : \brief Generated destructor
3165 :
3166 : This destructor is automatically generated (by ROSETTA). This destructor
3167 : only frees memory of data members associated with the parts of the current IR node which
3168 : are NOT traversed. Those data members that are part of a traversal can be freed using
3169 : a traversal (calling this destructor on all children in a post-order traversal). Such
3170 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
3171 :
3172 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
3173 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
3174 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
3175 :
3176 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
3177 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
3178 : pointers are not yet implemented to call delete on eash pointer in the container.
3179 : (This could be done by derivation from the STL containers to define containers that
3180 : automatically deleted their members.)
3181 :
3182 : */
3183 1453340 : SgConstVolatileModifier::~SgConstVolatileModifier () {
3184 1453340 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
3185 :
3186 :
3187 : // case: not a listType for modifier
3188 1453340 : p_modifier = SgConstVolatileModifier::e_unknown; // non list case
3189 :
3190 : }
3191 :
3192 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
3193 1453340 : }
3194 :
3195 :
3196 : /* #line 3197 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3197 :
3198 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
3199 :
3200 : // Generated constructor
3201 5130600 : SgConstVolatileModifier::SgConstVolatileModifier ( )
3202 5130600 : : SgModifier()
3203 : {
3204 : #ifdef DEBUG
3205 : // printf ("In SgConstVolatileModifier::SgConstVolatileModifier () sage_class_name() = %s \n",sage_class_name());
3206 : #endif
3207 : #if 0
3208 : // debugging information!
3209 : printf ("In SgConstVolatileModifier::SgConstVolatileModifier (): this = %p = %s \n",this,this->class_name().c_str());
3210 : #endif
3211 :
3212 5130600 : p_modifier = SgConstVolatileModifier::e_unknown;
3213 :
3214 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
3215 :
3216 : #if 0
3217 : // DQ (7/30/2014): Call a virtual function.
3218 : std::string s = this->class_name();
3219 : #endif
3220 :
3221 : // Test the variant virtual function
3222 : // assert(ConstVolatileModifierTag == variant());
3223 5130600 : assert(ConstVolatileModifierTag == this->variant());
3224 5130600 : ROSE_ASSERT(ConstVolatileModifierTag == (int)(this->variantT()));
3225 5130600 : post_construction_initialization();
3226 :
3227 : // Test the isSgConstVolatileModifier() function since it has been problematic
3228 5130600 : assert(isSgConstVolatileModifier(this) != NULL);
3229 5130600 : }
3230 :
3231 : // Generated constructor (all data members)
3232 :
3233 : /* #line 3234 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3234 :
3235 :
3236 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
3237 :
3238 :
3239 : // ********************************************************
3240 : // member functions common across all array grammar objects
3241 : // ********************************************************
3242 :
3243 :
3244 :
3245 : /* #line 3246 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3246 :
3247 :
3248 :
3249 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
3250 :
3251 : // ********************************************************
3252 : // member functions specific to each node in the grammar
3253 : // ********************************************************
3254 :
3255 :
3256 : /* #line 3257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3257 :
3258 : // Start of memberFunctionString
3259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
3260 :
3261 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
3262 :
3263 : SgStorageModifier::storage_modifier_enum
3264 11716 : SgStorageModifier::get_modifier () const
3265 : {
3266 11716 : ROSE_ASSERT (this != NULL);
3267 :
3268 : #if 0
3269 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
3270 : // used to trigger marking transformations for the token-based unparsing.
3271 : printf ("SgStorageModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
3272 : #endif
3273 :
3274 11716 : return p_modifier;
3275 : }
3276 :
3277 : void
3278 2044500 : SgStorageModifier::set_modifier ( SgStorageModifier::storage_modifier_enum modifier )
3279 : {
3280 2044500 : ROSE_ASSERT (this != NULL);
3281 :
3282 : #if 0
3283 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
3284 : // used to trigger marking transformations for the token-based unparsing.
3285 : printf ("SgStorageModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
3286 : #endif
3287 :
3288 2044500 : set_isModified(true);
3289 :
3290 2044500 : p_modifier = modifier;
3291 2044500 : }
3292 :
3293 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
3294 :
3295 :
3296 : // End of memberFunctionString
3297 : // Start of memberFunctionString
3298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
3299 :
3300 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
3301 :
3302 : bool
3303 10749 : SgStorageModifier::get_thread_local_storage () const
3304 : {
3305 10749 : ROSE_ASSERT (this != NULL);
3306 :
3307 : #if 0
3308 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
3309 : // used to trigger marking transformations for the token-based unparsing.
3310 : printf ("SgStorageModifier::get_thread_local_storage = %p = %s \n",this,this->class_name().c_str());
3311 : #endif
3312 :
3313 10749 : return p_thread_local_storage;
3314 : }
3315 :
3316 : void
3317 0 : SgStorageModifier::set_thread_local_storage ( bool thread_local_storage )
3318 : {
3319 0 : ROSE_ASSERT (this != NULL);
3320 :
3321 : #if 0
3322 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
3323 : // used to trigger marking transformations for the token-based unparsing.
3324 : printf ("SgStorageModifier::set_thread_local_storage = %p = %s \n",this,this->class_name().c_str());
3325 : #endif
3326 :
3327 0 : set_isModified(true);
3328 :
3329 0 : p_thread_local_storage = thread_local_storage;
3330 0 : }
3331 :
3332 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
3333 :
3334 :
3335 : // End of memberFunctionString
3336 : // Start of memberFunctionString
3337 : /* #line 2739 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
3338 :
3339 :
3340 : // Copy constructor
3341 0 : SgStorageModifier::SgStorageModifier ( const SgStorageModifier & X )
3342 : {
3343 0 : p_modifier = X.p_modifier;
3344 0 : }
3345 :
3346 : SgStorageModifier &
3347 107748 : SgStorageModifier::operator= ( const SgStorageModifier & X )
3348 : {
3349 107748 : p_modifier = X.p_modifier;
3350 107748 : return *this;
3351 : }
3352 :
3353 : void
3354 11426200 : SgStorageModifier::post_construction_initialization()
3355 : {
3356 11426200 : p_modifier = e_default;
3357 11426200 : }
3358 :
3359 2704 : bool SgStorageModifier::isUnknown() const { return p_modifier == e_unknown; }
3360 0 : void SgStorageModifier::setUnknown() { p_modifier = e_unknown; }
3361 :
3362 2735 : bool SgStorageModifier::isDefault() const { return p_modifier == e_default; }
3363 13787800 : void SgStorageModifier::setDefault() { p_modifier = e_default; }
3364 :
3365 1166850 : bool SgStorageModifier::isExtern() const { return p_modifier == e_extern; }
3366 9120 : void SgStorageModifier::setExtern() { p_modifier = e_extern; }
3367 :
3368 2209230 : bool SgStorageModifier::isStatic() const { return p_modifier == e_static; }
3369 969 : void SgStorageModifier::setStatic() { p_modifier = e_static; }
3370 :
3371 3671 : bool SgStorageModifier::isAuto() const { return p_modifier == e_auto; }
3372 0 : void SgStorageModifier::setAuto() { p_modifier = e_auto; }
3373 :
3374 2704 : bool SgStorageModifier::isUnspecified() const { return p_modifier == e_unspecified; }
3375 0 : void SgStorageModifier::setUnspecified() { p_modifier = e_unspecified; }
3376 :
3377 : // This is not used (but is present in the EDG AST)
3378 3671 : bool SgStorageModifier::isTypedef() const { return p_modifier == e_typedef; }
3379 0 : void SgStorageModifier::setTypedef() { p_modifier = e_typedef; }
3380 :
3381 14420 : bool SgStorageModifier::isRegister() const { return p_modifier == e_register; }
3382 0 : void SgStorageModifier::setRegister() { p_modifier = e_register; }
3383 :
3384 14420 : bool SgStorageModifier::isMutable() const { return p_modifier == e_mutable; }
3385 208 : void SgStorageModifier::setMutable() { p_modifier = e_mutable; }
3386 :
3387 4324 : bool SgStorageModifier::isAsm() const { return p_modifier == e_asm; }
3388 0 : void SgStorageModifier::setAsm() { p_modifier = e_asm; }
3389 :
3390 : #ifdef FORTRAN_SUPPORTED
3391 : // These remaining access functions are specific to FORTRAN
3392 : bool SgStorageModifier::isLocal() const { return p_modifier == e_local; }
3393 : void SgStorageModifier::setLocal() { p_modifier = e_local; }
3394 :
3395 : bool SgStorageModifier::isCommon() const { return p_modifier == e_common; }
3396 : void SgStorageModifier::setCommon() { p_modifier = e_common; }
3397 :
3398 : bool SgStorageModifier::isAssociated() const { return p_modifier == e_associated; }
3399 : void SgStorageModifier::setAssociated() { p_modifier = e_associated; }
3400 :
3401 : bool SgStorageModifier::isIntrinsic() const { return p_modifier == e_intrinsic; }
3402 : void SgStorageModifier::setIntrinsic() { p_modifier = e_intrinsic; }
3403 :
3404 : bool SgStorageModifier::isPointerBased() const { return p_modifier == e_pointer_based; }
3405 : void SgStorageModifier::setPointerBased() { p_modifier = e_pointer_based; }
3406 : #endif
3407 :
3408 : // Rasmussen (02/04/2018): Fortran contiguous array storage attribute
3409 49 : bool SgStorageModifier::isContiguous() const { return p_modifier == e_contiguous; }
3410 0 : void SgStorageModifier::setContiguous() { p_modifier = e_contiguous; }
3411 :
3412 : // TV (08/04/2010): Support for CUDA storage modifiers
3413 :
3414 11716 : bool SgStorageModifier::isCudaGlobal() const { return p_modifier == e_cuda_global; }
3415 0 : void SgStorageModifier::setCudaGlobal() { p_modifier = e_cuda_global; }
3416 :
3417 11765 : bool SgStorageModifier::isCudaConstant() const { return p_modifier == e_cuda_constant; }
3418 0 : void SgStorageModifier::setCudaConstant() { p_modifier = e_cuda_constant; }
3419 :
3420 11765 : bool SgStorageModifier::isCudaShared() const { return p_modifier == e_cuda_shared; }
3421 0 : void SgStorageModifier::setCudaShared() { p_modifier = e_cuda_shared; }
3422 :
3423 11716 : bool SgStorageModifier::isCudaDynamicShared() const { return p_modifier == e_cuda_dynamic_shared; }
3424 0 : void SgStorageModifier::setCudaDynamicShared() { p_modifier = e_cuda_dynamic_shared; }
3425 :
3426 : // Rasmussen (03/13/2018): New CUDA storage modifiers
3427 :
3428 49 : bool SgStorageModifier::isCudaDeviceMemory() const { return p_modifier == e_cuda_device_memory; }
3429 0 : void SgStorageModifier::setCudaDeviceMemory() { p_modifier = e_cuda_device_memory; }
3430 :
3431 49 : bool SgStorageModifier::isCudaManaged() const { return p_modifier == e_cuda_managed; }
3432 0 : void SgStorageModifier::setCudaManaged() { p_modifier = e_cuda_managed; }
3433 :
3434 49 : bool SgStorageModifier::isCudaPinned() const { return p_modifier == e_cuda_pinned; }
3435 0 : void SgStorageModifier::setCudaPinned() { p_modifier = e_cuda_pinned; }
3436 :
3437 49 : bool SgStorageModifier::isCudaTexture() const { return p_modifier == e_cuda_texture; }
3438 0 : void SgStorageModifier::setCudaTexture() { p_modifier = e_cuda_texture; }
3439 :
3440 : string
3441 2704 : SgStorageModifier::displayString() const
3442 : {
3443 2704 : std::string s = "SgStorageModifier(";
3444 10816 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
3445 8338 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
3446 10816 : s += std::string("isExtern() = ") + std::string(isExtern() ? "true " : "false ");
3447 10753 : s += std::string("isStatic() = ") + std::string(isStatic() ? "true " : "false ");
3448 10816 : s += std::string("isAuto() = ") + std::string(isAuto() ? "true " : "false ");
3449 10653 : s += std::string("isUnspecified() = ") + std::string(isUnspecified() ? "true " : "false ");
3450 10816 : s += std::string("isTypedef() = ") + std::string(isTypedef() ? "true " : "false ");
3451 10816 : s += std::string("isRegister() = ") + std::string(isRegister() ? "true " : "false ");
3452 10816 : s += std::string("isMutable() = ") + std::string(isMutable() ? "true " : "false ");
3453 10816 : s += std::string("isAsm() = ") + std::string(isAsm() ? "true " : "false ");
3454 : #ifdef FORTRAN_SUPPORTED
3455 : s += std::string("isLocal() = ") + std::string(isLocal() ? "true " : "false ");
3456 : s += std::string("isCommon() = ") + std::string(isCommon() ? "true " : "false ");
3457 : s += std::string("isAssociated() = ") + std::string(isAssociated() ? "true " : "false ");
3458 : s += std::string("isIntrinsic() = ") + std::string(isIntrinsic() ? "true " : "false ");
3459 : s += std::string("isPointerBased() = ") + std::string(isPointerBased() ? "true " : "false ");
3460 : #endif
3461 2704 : s += ")";
3462 2704 : return s;
3463 : }
3464 :
3465 : void
3466 0 : SgStorageModifier::display ( std::string label ) const
3467 : {
3468 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
3469 0 : printf ("In SgStorageModifier::display(%s) \n",label.c_str());
3470 0 : printf ("%s \n",displayString().c_str());
3471 0 : }
3472 :
3473 0 : std::ostream & operator<< ( std::ostream & os, const SgStorageModifier & m)
3474 : {
3475 0 : os << m.get_modifier();
3476 0 : return os;
3477 : }
3478 :
3479 0 : bool operator== (const SgStorageModifier& lhs, const SgStorageModifier& rhs)
3480 : {
3481 0 : return
3482 0 : (lhs.isUnknown() == rhs.isUnknown() ) &&
3483 0 : (lhs.isDefault() == rhs.isDefault() ) &&
3484 0 : (lhs.isExtern() == rhs.isExtern() ) &&
3485 0 : (lhs.isStatic() == rhs.isStatic() ) &&
3486 0 : (lhs.isAuto() == rhs.isAuto() ) &&
3487 0 : (lhs.isUnspecified() == rhs.isUnspecified() ) &&
3488 0 : (lhs.isRegister() == rhs.isRegister() ) &&
3489 0 : (lhs.isMutable() == rhs.isMutable() ) &&
3490 0 : (lhs.isTypedef() == rhs.isTypedef() ) &&
3491 0 : (lhs.isAsm() == rhs.isAsm() ) &&
3492 0 : (lhs.isContiguous() == rhs.isContiguous() ) &&
3493 0 : (lhs.isCudaGlobal() == rhs.isCudaGlobal() ) &&
3494 0 : (lhs.isCudaConstant() == rhs.isCudaConstant()) &&
3495 0 : (lhs.isCudaShared() == rhs.isCudaShared() ) &&
3496 0 : (lhs.isCudaManaged() == rhs.isCudaManaged() ) &&
3497 0 : (lhs.isCudaPinned() == rhs.isCudaPinned() ) &&
3498 0 : (lhs.isCudaTexture() == rhs.isCudaTexture() ) &&
3499 0 : (lhs.isCudaDynamicShared() == rhs.isCudaDynamicShared() ) &&
3500 0 : (lhs.isCudaDeviceMemory() == rhs.isCudaDeviceMemory() ) &&
3501 0 : true;
3502 : }
3503 :
3504 : // DQ (2/4/2006): Added mechamism to clear all bits
3505 6341180 : void SgStorageModifier::reset()
3506 : {
3507 6341180 : setDefault();
3508 6341180 : }
3509 :
3510 :
3511 :
3512 : // End of memberFunctionString
3513 : // Start of memberFunctionString
3514 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
3515 :
3516 : // *** COMMON CODE SECTION BEGINS HERE ***
3517 :
3518 : #if 0
3519 : int
3520 : SgStorageModifier::getVariant() const
3521 : {
3522 : // This function is used in ROSE while "variant()" is used in SAGE
3523 : assert(this != NULL);
3524 : return variant();
3525 : }
3526 : #endif
3527 :
3528 : // This function is used in ROSE in treeTraversal code
3529 : // eventually replaces getVariant() and variant()
3530 : // though after variant() has been removed for a while we will
3531 : // want to change the name of variantT() back to variant()
3532 : // (since the "T" was ment to stand for temporary).
3533 : // When this happens the variantT() will be depricated.
3534 : VariantT
3535 258530000 : SgStorageModifier::variantT() const
3536 : {
3537 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
3538 258530000 : ROSE_ASSERT(this != NULL);
3539 258530000 : return V_SgStorageModifier;
3540 : }
3541 :
3542 : #if 0
3543 : int
3544 : SgStorageModifier::variant() const
3545 : {
3546 : // This function is used in SAGE
3547 : ROSE_ASSERT(this != NULL);
3548 : return StorageModifierTag;
3549 : }
3550 : #endif
3551 :
3552 : ROSE_DLL_API const char*
3553 0 : SgStorageModifier::sage_class_name() const
3554 : {
3555 0 : ROSE_ASSERT(this != NULL);
3556 0 : return "SgStorageModifier";
3557 : }
3558 :
3559 : std::string
3560 5957280 : SgStorageModifier::class_name() const
3561 : {
3562 5957280 : ROSE_ASSERT(this != NULL);
3563 5957280 : return "SgStorageModifier";
3564 : }
3565 :
3566 : // DQ (11/26/2005): Support for visitor pattern mechanims
3567 : // (inferior to ROSE traversal mechanism, experimental).
3568 : void
3569 6131590 : SgStorageModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
3570 : {
3571 6131590 : ROSE_ASSERT(this != NULL);
3572 6131590 : visitor.visit(this);
3573 6131590 : }
3574 :
3575 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
3576 0 : void SgStorageModifier::accept (ROSE_VisitorPattern & visitor) {
3577 0 : ROSE_ASSERT(this != NULL);
3578 0 : visitor.visit(this);
3579 0 : }
3580 :
3581 : SgStorageModifier*
3582 0 : SgStorageModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
3583 : {
3584 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
3585 : // This function is currently only supported for the AST used the represent Binary executables.
3586 : if (0 /* isSgAsmNode(this) != NULL */)
3587 : {
3588 : // Support for regex specification.
3589 : std::string prefixCode = "REGEX:";
3590 : addNewAttribute(prefixCode + s,a);
3591 : }
3592 : #endif
3593 :
3594 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
3595 0 : return this;
3596 : }
3597 :
3598 : // *** COMMON CODE SECTION ENDS HERE ***
3599 :
3600 :
3601 : // End of memberFunctionString
3602 : // Start of memberFunctionString
3603 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
3604 :
3605 :
3606 : #if 0
3607 : //! Error checking support
3608 : /*! Verifies the following:
3609 : - working getVariant() member function
3610 : - calls base class's error() member function
3611 : Every class has one of these functions.
3612 : */
3613 : bool
3614 : SgStorageModifier::error()
3615 : {
3616 : // Put error checking here
3617 :
3618 : ROSE_ASSERT (this != NULL);
3619 : if (getVariant() != StorageModifierTag)
3620 : {
3621 : printf ("Error in SgStorageModifier::error(): SgStorageModifier object has a %s variant \n",
3622 : Cxx_GrammarTerminalNames[getVariant()].name);
3623 : // printf ("Error in SgStorageModifier::error() \n");
3624 : ROSE_ABORT();
3625 : }
3626 :
3627 : ROSE_ASSERT (getVariant() == StorageModifierTag);
3628 : return SgModifier::error();
3629 : }
3630 : #endif
3631 :
3632 :
3633 :
3634 : // End of memberFunctionString
3635 :
3636 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
3637 :
3638 11426200 : SgStorageModifier* isSgStorageModifier ( SgNode* inputDerivedClassPointer )
3639 : {
3640 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
3641 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
3642 : // So to fix this we return NULL directly when the input is NULL and avoid the
3643 : // dynamic_cast in this case. This is likely a performance improvement as well.
3644 : // return dynamic_cast<SgStorageModifier*>(inputDerivedClassPointer);
3645 : // Milind Chabbi (8/28/2013): isSgStorageModifier uses table-driven castability instead of c++ default dynamic_cast
3646 : // this improves the running time performance by 10-20%.
3647 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStorageModifier*>(inputDerivedClassPointer);
3648 11426200 : return IS_SgStorageModifier_FAST_MACRO(inputDerivedClassPointer);
3649 : }
3650 :
3651 : // DQ (11/8/2003): Added version of functions taking const pointer
3652 19816 : const SgStorageModifier* isSgStorageModifier ( const SgNode* inputDerivedClassPointer )
3653 : {
3654 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
3655 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
3656 : // So to fix this we return NULL directly when the input is NULL and avoid the
3657 : // dynamic_cast in this case. This is likely a performance improvement as well.
3658 : // return dynamic_cast<const SgStorageModifier*>(inputDerivedClassPointer);
3659 : // Milind Chabbi (8/28/2013): isSgStorageModifier uses table-driven castability instead of c++ default dynamic_cast
3660 : // this improves the running time performance by 10-20%.
3661 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStorageModifier*>(inputDerivedClassPointer);
3662 19816 : return IS_SgStorageModifier_FAST_MACRO(inputDerivedClassPointer);
3663 : }
3664 :
3665 :
3666 :
3667 : /* #line 3668 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3668 :
3669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
3670 :
3671 : /**
3672 : \brief Generated destructor
3673 :
3674 : This destructor is automatically generated (by ROSETTA). This destructor
3675 : only frees memory of data members associated with the parts of the current IR node which
3676 : are NOT traversed. Those data members that are part of a traversal can be freed using
3677 : a traversal (calling this destructor on all children in a post-order traversal). Such
3678 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
3679 :
3680 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
3681 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
3682 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
3683 :
3684 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
3685 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
3686 : pointers are not yet implemented to call delete on eash pointer in the container.
3687 : (This could be done by derivation from the STL containers to define containers that
3688 : automatically deleted their members.)
3689 :
3690 : */
3691 1616759 : SgStorageModifier::~SgStorageModifier () {
3692 1506300 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
3693 :
3694 :
3695 : // case: not a listType for modifier
3696 1506300 : p_modifier = SgStorageModifier::e_unknown; // non list case
3697 : // case: not a listType for thread_local_storage
3698 1506300 : p_thread_local_storage = false; // non list case
3699 :
3700 : }
3701 :
3702 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
3703 1616759 : }
3704 :
3705 :
3706 : /* #line 3707 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3707 :
3708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
3709 :
3710 : // Generated constructor
3711 11426200 : SgStorageModifier::SgStorageModifier ( )
3712 11426200 : : SgModifier()
3713 : {
3714 : #ifdef DEBUG
3715 : // printf ("In SgStorageModifier::SgStorageModifier () sage_class_name() = %s \n",sage_class_name());
3716 : #endif
3717 : #if 0
3718 : // debugging information!
3719 : printf ("In SgStorageModifier::SgStorageModifier (): this = %p = %s \n",this,this->class_name().c_str());
3720 : #endif
3721 :
3722 11426200 : p_modifier = SgStorageModifier::e_unknown;
3723 11426200 : p_thread_local_storage = false;
3724 :
3725 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
3726 :
3727 : #if 0
3728 : // DQ (7/30/2014): Call a virtual function.
3729 : std::string s = this->class_name();
3730 : #endif
3731 :
3732 : // Test the variant virtual function
3733 : // assert(StorageModifierTag == variant());
3734 11426200 : assert(StorageModifierTag == this->variant());
3735 11426200 : ROSE_ASSERT(StorageModifierTag == (int)(this->variantT()));
3736 11426200 : post_construction_initialization();
3737 :
3738 : // Test the isSgStorageModifier() function since it has been problematic
3739 11426200 : assert(isSgStorageModifier(this) != NULL);
3740 11426200 : }
3741 :
3742 : // Generated constructor (all data members)
3743 :
3744 : /* #line 3745 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3745 :
3746 :
3747 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
3748 :
3749 :
3750 : // ********************************************************
3751 : // member functions common across all array grammar objects
3752 : // ********************************************************
3753 :
3754 :
3755 :
3756 : /* #line 3757 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3757 :
3758 :
3759 :
3760 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
3761 :
3762 : // ********************************************************
3763 : // member functions specific to each node in the grammar
3764 : // ********************************************************
3765 :
3766 :
3767 : /* #line 3768 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
3768 :
3769 : // Start of memberFunctionString
3770 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
3771 :
3772 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
3773 :
3774 : SgAccessModifier::access_modifier_enum
3775 298630 : SgAccessModifier::get_modifier () const
3776 : {
3777 298630 : ROSE_ASSERT (this != NULL);
3778 :
3779 : #if 0
3780 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
3781 : // used to trigger marking transformations for the token-based unparsing.
3782 : printf ("SgAccessModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
3783 : #endif
3784 :
3785 298630 : return p_modifier;
3786 : }
3787 :
3788 : void
3789 0 : SgAccessModifier::set_modifier ( SgAccessModifier::access_modifier_enum modifier )
3790 : {
3791 0 : ROSE_ASSERT (this != NULL);
3792 :
3793 : #if 0
3794 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
3795 : // used to trigger marking transformations for the token-based unparsing.
3796 : printf ("SgAccessModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
3797 : #endif
3798 :
3799 0 : set_isModified(true);
3800 :
3801 0 : p_modifier = modifier;
3802 0 : }
3803 :
3804 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
3805 :
3806 :
3807 : // End of memberFunctionString
3808 : // Start of memberFunctionString
3809 : /* #line 2913 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
3810 :
3811 :
3812 : // Copy constructor
3813 0 : SgAccessModifier::SgAccessModifier ( const SgAccessModifier & X )
3814 : {
3815 0 : p_modifier = X.p_modifier;
3816 0 : }
3817 :
3818 : SgAccessModifier &
3819 114093 : SgAccessModifier::operator= ( const SgAccessModifier & X )
3820 : {
3821 114093 : p_modifier = X.p_modifier;
3822 114093 : return *this;
3823 : }
3824 :
3825 : void
3826 5065120 : SgAccessModifier::post_construction_initialization()
3827 : {
3828 5065120 : p_modifier = e_default;
3829 5065120 : }
3830 :
3831 2704 : bool SgAccessModifier::isUnknown() const { return p_modifier == e_unknown; }
3832 0 : void SgAccessModifier::setUnknown() { p_modifier = e_unknown; }
3833 :
3834 12217300 : bool SgAccessModifier::isDefault() const { return p_modifier == e_default; }
3835 6341180 : void SgAccessModifier::setDefault() { p_modifier = e_default; }
3836 :
3837 34095 : bool SgAccessModifier::isPrivate() const { return p_modifier == e_private; }
3838 8149 : void SgAccessModifier::setPrivate() { p_modifier = e_private; }
3839 :
3840 18600 : bool SgAccessModifier::isProtected() const { return p_modifier == e_protected; }
3841 8267 : void SgAccessModifier::setProtected() { p_modifier = e_protected; }
3842 :
3843 3756610 : bool SgAccessModifier::isPublic() const { return p_modifier == e_public; }
3844 1309140 : void SgAccessModifier::setPublic() { p_modifier = e_public; }
3845 :
3846 2704 : bool SgAccessModifier::isUndefined() const { return p_modifier == e_undefined; }
3847 408 : void SgAccessModifier::setUndefined() { p_modifier = e_undefined; }
3848 :
3849 : string
3850 2704 : SgAccessModifier::displayString() const
3851 : {
3852 2704 : std::string s = "SgAccessModifier(";
3853 10816 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
3854 9527 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
3855 10710 : s += std::string("isPrivate() = ") + std::string(isPrivate() ? "true " : "false ");
3856 10765 : s += std::string("isProtected() = ") + std::string(isProtected() ? "true " : "false ");
3857 9558 : s += std::string("isPublic() = ") + std::string(isPublic() ? "true " : "false ");
3858 10816 : s += std::string("isUndefined() = ") + std::string(isUndefined() ? "true " : "false ");
3859 2704 : s += ")";
3860 2704 : return s;
3861 : }
3862 :
3863 : void
3864 0 : SgAccessModifier::display ( std::string label ) const
3865 : {
3866 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
3867 0 : printf ("In SgAccessModifier::display(%s) \n",label.c_str());
3868 0 : printf ("%s \n",displayString().c_str());
3869 0 : }
3870 :
3871 0 : std::ostream & operator<< ( std::ostream & os, const SgAccessModifier & m)
3872 : {
3873 0 : os << m.get_modifier();
3874 0 : return os;
3875 : }
3876 :
3877 0 : bool operator== (const SgAccessModifier& lhs, const SgAccessModifier& rhs)
3878 : {
3879 0 : return
3880 0 : (lhs.isUnknown() == rhs.isUnknown() ) &&
3881 0 : (lhs.isDefault() == rhs.isDefault() ) &&
3882 0 : (lhs.isPrivate() == rhs.isPrivate() ) &&
3883 0 : (lhs.isProtected()== rhs.isProtected()) &&
3884 0 : (lhs.isPublic() == rhs.isPublic() ) &&
3885 0 : true;
3886 : }
3887 :
3888 : // DQ (2/4/2006): Added mechamism to clear all bits
3889 6341180 : void SgAccessModifier::reset()
3890 : {
3891 6341180 : setDefault();
3892 6341180 : }
3893 :
3894 :
3895 :
3896 : // End of memberFunctionString
3897 : // Start of memberFunctionString
3898 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
3899 :
3900 : // *** COMMON CODE SECTION BEGINS HERE ***
3901 :
3902 : #if 0
3903 : int
3904 : SgAccessModifier::getVariant() const
3905 : {
3906 : // This function is used in ROSE while "variant()" is used in SAGE
3907 : assert(this != NULL);
3908 : return variant();
3909 : }
3910 : #endif
3911 :
3912 : // This function is used in ROSE in treeTraversal code
3913 : // eventually replaces getVariant() and variant()
3914 : // though after variant() has been removed for a while we will
3915 : // want to change the name of variantT() back to variant()
3916 : // (since the "T" was ment to stand for temporary).
3917 : // When this happens the variantT() will be depricated.
3918 : VariantT
3919 15195300 : SgAccessModifier::variantT() const
3920 : {
3921 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
3922 15195300 : ROSE_ASSERT(this != NULL);
3923 15195300 : return V_SgAccessModifier;
3924 : }
3925 :
3926 : #if 0
3927 : int
3928 : SgAccessModifier::variant() const
3929 : {
3930 : // This function is used in SAGE
3931 : ROSE_ASSERT(this != NULL);
3932 : return AccessModifierTag;
3933 : }
3934 : #endif
3935 :
3936 : ROSE_DLL_API const char*
3937 0 : SgAccessModifier::sage_class_name() const
3938 : {
3939 0 : ROSE_ASSERT(this != NULL);
3940 0 : return "SgAccessModifier";
3941 : }
3942 :
3943 : std::string
3944 0 : SgAccessModifier::class_name() const
3945 : {
3946 0 : ROSE_ASSERT(this != NULL);
3947 0 : return "SgAccessModifier";
3948 : }
3949 :
3950 : // DQ (11/26/2005): Support for visitor pattern mechanims
3951 : // (inferior to ROSE traversal mechanism, experimental).
3952 : void
3953 0 : SgAccessModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
3954 : {
3955 0 : ROSE_ASSERT(this != NULL);
3956 0 : visitor.visit(this);
3957 0 : }
3958 :
3959 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
3960 0 : void SgAccessModifier::accept (ROSE_VisitorPattern & visitor) {
3961 0 : ROSE_ASSERT(this != NULL);
3962 0 : visitor.visit(this);
3963 0 : }
3964 :
3965 : SgAccessModifier*
3966 0 : SgAccessModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
3967 : {
3968 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
3969 : // This function is currently only supported for the AST used the represent Binary executables.
3970 : if (0 /* isSgAsmNode(this) != NULL */)
3971 : {
3972 : // Support for regex specification.
3973 : std::string prefixCode = "REGEX:";
3974 : addNewAttribute(prefixCode + s,a);
3975 : }
3976 : #endif
3977 :
3978 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
3979 0 : return this;
3980 : }
3981 :
3982 : // *** COMMON CODE SECTION ENDS HERE ***
3983 :
3984 :
3985 : // End of memberFunctionString
3986 : // Start of memberFunctionString
3987 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
3988 :
3989 :
3990 : #if 0
3991 : //! Error checking support
3992 : /*! Verifies the following:
3993 : - working getVariant() member function
3994 : - calls base class's error() member function
3995 : Every class has one of these functions.
3996 : */
3997 : bool
3998 : SgAccessModifier::error()
3999 : {
4000 : // Put error checking here
4001 :
4002 : ROSE_ASSERT (this != NULL);
4003 : if (getVariant() != AccessModifierTag)
4004 : {
4005 : printf ("Error in SgAccessModifier::error(): SgAccessModifier object has a %s variant \n",
4006 : Cxx_GrammarTerminalNames[getVariant()].name);
4007 : // printf ("Error in SgAccessModifier::error() \n");
4008 : ROSE_ABORT();
4009 : }
4010 :
4011 : ROSE_ASSERT (getVariant() == AccessModifierTag);
4012 : return SgModifier::error();
4013 : }
4014 : #endif
4015 :
4016 :
4017 :
4018 : // End of memberFunctionString
4019 :
4020 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
4021 :
4022 5065120 : SgAccessModifier* isSgAccessModifier ( SgNode* inputDerivedClassPointer )
4023 : {
4024 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
4025 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
4026 : // So to fix this we return NULL directly when the input is NULL and avoid the
4027 : // dynamic_cast in this case. This is likely a performance improvement as well.
4028 : // return dynamic_cast<SgAccessModifier*>(inputDerivedClassPointer);
4029 : // Milind Chabbi (8/28/2013): isSgAccessModifier uses table-driven castability instead of c++ default dynamic_cast
4030 : // this improves the running time performance by 10-20%.
4031 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAccessModifier*>(inputDerivedClassPointer);
4032 5065120 : return IS_SgAccessModifier_FAST_MACRO(inputDerivedClassPointer);
4033 : }
4034 :
4035 : // DQ (11/8/2003): Added version of functions taking const pointer
4036 0 : const SgAccessModifier* isSgAccessModifier ( const SgNode* inputDerivedClassPointer )
4037 : {
4038 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
4039 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
4040 : // So to fix this we return NULL directly when the input is NULL and avoid the
4041 : // dynamic_cast in this case. This is likely a performance improvement as well.
4042 : // return dynamic_cast<const SgAccessModifier*>(inputDerivedClassPointer);
4043 : // Milind Chabbi (8/28/2013): isSgAccessModifier uses table-driven castability instead of c++ default dynamic_cast
4044 : // this improves the running time performance by 10-20%.
4045 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAccessModifier*>(inputDerivedClassPointer);
4046 0 : return IS_SgAccessModifier_FAST_MACRO(inputDerivedClassPointer);
4047 : }
4048 :
4049 :
4050 :
4051 : /* #line 4052 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4052 :
4053 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
4054 :
4055 : /**
4056 : \brief Generated destructor
4057 :
4058 : This destructor is automatically generated (by ROSETTA). This destructor
4059 : only frees memory of data members associated with the parts of the current IR node which
4060 : are NOT traversed. Those data members that are part of a traversal can be freed using
4061 : a traversal (calling this destructor on all children in a post-order traversal). Such
4062 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
4063 :
4064 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
4065 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
4066 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
4067 :
4068 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
4069 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
4070 : pointers are not yet implemented to call delete on eash pointer in the container.
4071 : (This could be done by derivation from the STL containers to define containers that
4072 : automatically deleted their members.)
4073 :
4074 : */
4075 1403430 : SgAccessModifier::~SgAccessModifier () {
4076 1403430 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
4077 :
4078 :
4079 : // case: not a listType for modifier
4080 1403430 : p_modifier = SgAccessModifier::e_unknown; // non list case
4081 :
4082 : }
4083 :
4084 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
4085 1403430 : }
4086 :
4087 :
4088 : /* #line 4089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4089 :
4090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
4091 :
4092 : // Generated constructor
4093 5065120 : SgAccessModifier::SgAccessModifier ( )
4094 5065120 : : SgModifier()
4095 : {
4096 : #ifdef DEBUG
4097 : // printf ("In SgAccessModifier::SgAccessModifier () sage_class_name() = %s \n",sage_class_name());
4098 : #endif
4099 : #if 0
4100 : // debugging information!
4101 : printf ("In SgAccessModifier::SgAccessModifier (): this = %p = %s \n",this,this->class_name().c_str());
4102 : #endif
4103 :
4104 5065120 : p_modifier = SgAccessModifier::e_unknown;
4105 :
4106 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
4107 :
4108 : #if 0
4109 : // DQ (7/30/2014): Call a virtual function.
4110 : std::string s = this->class_name();
4111 : #endif
4112 :
4113 : // Test the variant virtual function
4114 : // assert(AccessModifierTag == variant());
4115 5065120 : assert(AccessModifierTag == this->variant());
4116 5065120 : ROSE_ASSERT(AccessModifierTag == (int)(this->variantT()));
4117 5065120 : post_construction_initialization();
4118 :
4119 : // Test the isSgAccessModifier() function since it has been problematic
4120 5065120 : assert(isSgAccessModifier(this) != NULL);
4121 5065120 : }
4122 :
4123 : // Generated constructor (all data members)
4124 :
4125 : /* #line 4126 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4126 :
4127 :
4128 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
4129 :
4130 :
4131 : // ********************************************************
4132 : // member functions common across all array grammar objects
4133 : // ********************************************************
4134 :
4135 :
4136 :
4137 : /* #line 4138 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4138 :
4139 :
4140 :
4141 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
4142 :
4143 : // ********************************************************
4144 : // member functions specific to each node in the grammar
4145 : // ********************************************************
4146 :
4147 :
4148 : /* #line 4149 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4149 :
4150 : // Start of memberFunctionString
4151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4152 :
4153 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4154 :
4155 : SgBitVector
4156 0 : SgFunctionModifier::get_modifierVector () const
4157 : {
4158 0 : ROSE_ASSERT (this != NULL);
4159 :
4160 : #if 0
4161 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4162 : // used to trigger marking transformations for the token-based unparsing.
4163 : printf ("SgFunctionModifier::get_modifierVector = %p = %s \n",this,this->class_name().c_str());
4164 : #endif
4165 :
4166 0 : return p_modifierVector;
4167 : }
4168 :
4169 : void
4170 0 : SgFunctionModifier::set_modifierVector ( SgBitVector modifierVector )
4171 : {
4172 0 : ROSE_ASSERT (this != NULL);
4173 :
4174 : #if 0
4175 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4176 : // used to trigger marking transformations for the token-based unparsing.
4177 : printf ("SgFunctionModifier::set_modifierVector = %p = %s \n",this,this->class_name().c_str());
4178 : #endif
4179 :
4180 0 : set_isModified(true);
4181 :
4182 0 : p_modifierVector = modifierVector;
4183 0 : }
4184 :
4185 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
4186 :
4187 :
4188 : // End of memberFunctionString
4189 : // Start of memberFunctionString
4190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4191 :
4192 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4193 :
4194 : unsigned long int
4195 0 : SgFunctionModifier::get_gnu_attribute_constructor_destructor_priority () const
4196 : {
4197 0 : ROSE_ASSERT (this != NULL);
4198 :
4199 : #if 0
4200 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4201 : // used to trigger marking transformations for the token-based unparsing.
4202 : printf ("SgFunctionModifier::get_gnu_attribute_constructor_destructor_priority = %p = %s \n",this,this->class_name().c_str());
4203 : #endif
4204 :
4205 0 : return p_gnu_attribute_constructor_destructor_priority;
4206 : }
4207 :
4208 : void
4209 0 : SgFunctionModifier::set_gnu_attribute_constructor_destructor_priority ( unsigned long int gnu_attribute_constructor_destructor_priority )
4210 : {
4211 0 : ROSE_ASSERT (this != NULL);
4212 :
4213 : #if 0
4214 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4215 : // used to trigger marking transformations for the token-based unparsing.
4216 : printf ("SgFunctionModifier::set_gnu_attribute_constructor_destructor_priority = %p = %s \n",this,this->class_name().c_str());
4217 : #endif
4218 :
4219 0 : set_isModified(true);
4220 :
4221 0 : p_gnu_attribute_constructor_destructor_priority = gnu_attribute_constructor_destructor_priority;
4222 0 : }
4223 :
4224 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
4225 :
4226 :
4227 : // End of memberFunctionString
4228 : // Start of memberFunctionString
4229 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4230 :
4231 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4232 :
4233 : std::string
4234 0 : SgFunctionModifier::get_gnu_attribute_named_weak_reference () const
4235 : {
4236 0 : ROSE_ASSERT (this != NULL);
4237 :
4238 : #if 0
4239 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4240 : // used to trigger marking transformations for the token-based unparsing.
4241 : printf ("SgFunctionModifier::get_gnu_attribute_named_weak_reference = %p = %s \n",this,this->class_name().c_str());
4242 : #endif
4243 :
4244 0 : return p_gnu_attribute_named_weak_reference;
4245 : }
4246 :
4247 : void
4248 0 : SgFunctionModifier::set_gnu_attribute_named_weak_reference ( std::string gnu_attribute_named_weak_reference )
4249 : {
4250 0 : ROSE_ASSERT (this != NULL);
4251 :
4252 : #if 0
4253 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4254 : // used to trigger marking transformations for the token-based unparsing.
4255 : printf ("SgFunctionModifier::set_gnu_attribute_named_weak_reference = %p = %s \n",this,this->class_name().c_str());
4256 : #endif
4257 :
4258 0 : set_isModified(true);
4259 :
4260 0 : p_gnu_attribute_named_weak_reference = gnu_attribute_named_weak_reference;
4261 0 : }
4262 :
4263 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
4264 :
4265 :
4266 : // End of memberFunctionString
4267 : // Start of memberFunctionString
4268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4269 :
4270 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4271 :
4272 : std::string
4273 138 : SgFunctionModifier::get_gnu_attribute_named_alias () const
4274 : {
4275 138 : ROSE_ASSERT (this != NULL);
4276 :
4277 : #if 0
4278 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4279 : // used to trigger marking transformations for the token-based unparsing.
4280 : printf ("SgFunctionModifier::get_gnu_attribute_named_alias = %p = %s \n",this,this->class_name().c_str());
4281 : #endif
4282 :
4283 138 : return p_gnu_attribute_named_alias;
4284 : }
4285 :
4286 : void
4287 0 : SgFunctionModifier::set_gnu_attribute_named_alias ( std::string gnu_attribute_named_alias )
4288 : {
4289 0 : ROSE_ASSERT (this != NULL);
4290 :
4291 : #if 0
4292 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4293 : // used to trigger marking transformations for the token-based unparsing.
4294 : printf ("SgFunctionModifier::set_gnu_attribute_named_alias = %p = %s \n",this,this->class_name().c_str());
4295 : #endif
4296 :
4297 0 : set_isModified(true);
4298 :
4299 0 : p_gnu_attribute_named_alias = gnu_attribute_named_alias;
4300 0 : }
4301 :
4302 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
4303 :
4304 :
4305 : // End of memberFunctionString
4306 : // Start of memberFunctionString
4307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4308 :
4309 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4310 :
4311 : SgType *
4312 0 : SgFunctionModifier::get_opencl_vec_type () const
4313 : {
4314 0 : ROSE_ASSERT (this != NULL);
4315 :
4316 : #if 0
4317 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4318 : // used to trigger marking transformations for the token-based unparsing.
4319 : printf ("SgFunctionModifier::get_opencl_vec_type = %p = %s \n",this,this->class_name().c_str());
4320 : #endif
4321 :
4322 0 : return p_opencl_vec_type;
4323 : }
4324 :
4325 : void
4326 0 : SgFunctionModifier::set_opencl_vec_type ( SgType * opencl_vec_type )
4327 : {
4328 0 : ROSE_ASSERT (this != NULL);
4329 :
4330 : #if 0
4331 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4332 : // used to trigger marking transformations for the token-based unparsing.
4333 : printf ("SgFunctionModifier::set_opencl_vec_type = %p = %s \n",this,this->class_name().c_str());
4334 : #endif
4335 :
4336 0 : set_isModified(true);
4337 :
4338 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
4339 : if (p_opencl_vec_type != NULL && opencl_vec_type != NULL && p_opencl_vec_type != opencl_vec_type)
4340 : {
4341 : printf ("Warning: opencl_vec_type = %p overwriting valid pointer p_opencl_vec_type = %p \n",opencl_vec_type,p_opencl_vec_type);
4342 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
4343 : printf ("Error fails assertion (p_opencl_vec_type != NULL && opencl_vec_type != NULL && p_opencl_vec_type != opencl_vec_type) is false\n");
4344 : ROSE_ASSERT(false);
4345 : #endif
4346 : }
4347 : #endif
4348 0 : p_opencl_vec_type = opencl_vec_type;
4349 0 : }
4350 :
4351 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
4352 :
4353 :
4354 : // End of memberFunctionString
4355 : // Start of memberFunctionString
4356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4357 :
4358 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4359 :
4360 : SgFunctionModifier::opencl_work_group_size_t
4361 0 : SgFunctionModifier::get_opencl_work_group_size () const
4362 : {
4363 0 : ROSE_ASSERT (this != NULL);
4364 :
4365 : #if 0
4366 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4367 : // used to trigger marking transformations for the token-based unparsing.
4368 : printf ("SgFunctionModifier::get_opencl_work_group_size = %p = %s \n",this,this->class_name().c_str());
4369 : #endif
4370 :
4371 0 : return p_opencl_work_group_size;
4372 : }
4373 :
4374 : void
4375 0 : SgFunctionModifier::set_opencl_work_group_size ( SgFunctionModifier::opencl_work_group_size_t opencl_work_group_size )
4376 : {
4377 0 : ROSE_ASSERT (this != NULL);
4378 :
4379 : #if 0
4380 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4381 : // used to trigger marking transformations for the token-based unparsing.
4382 : printf ("SgFunctionModifier::set_opencl_work_group_size = %p = %s \n",this,this->class_name().c_str());
4383 : #endif
4384 :
4385 0 : set_isModified(true);
4386 :
4387 0 : p_opencl_work_group_size = opencl_work_group_size;
4388 0 : }
4389 :
4390 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
4391 :
4392 :
4393 : // End of memberFunctionString
4394 : // Start of memberFunctionString
4395 : /* #line 3000 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
4396 :
4397 : // Copy constructor
4398 5 : SgFunctionModifier::SgFunctionModifier ( const SgFunctionModifier & X )
4399 : {
4400 5 : p_modifierVector = X.p_modifierVector;
4401 5 : }
4402 :
4403 : SgFunctionModifier &
4404 13308 : SgFunctionModifier::operator= ( const SgFunctionModifier & X )
4405 : {
4406 13308 : p_modifierVector = X.p_modifierVector;
4407 13308 : return *this;
4408 : }
4409 :
4410 : void
4411 1194170 : SgFunctionModifier::post_construction_initialization()
4412 : {
4413 1194170 : p_modifierVector = SgBitVector(e_last_modifier,false);
4414 1194170 : setDefault();
4415 1194170 : }
4416 :
4417 697 : bool SgFunctionModifier::isUnknown() const { return checkBit(e_unknown,p_modifierVector); }
4418 0 : void SgFunctionModifier::setUnknown() { setBit(e_unknown,p_modifierVector); }
4419 0 : void SgFunctionModifier::unsetUnknown() { unsetBit(e_unknown,p_modifierVector); }
4420 :
4421 697 : bool SgFunctionModifier::isDefault() const { return checkBit(e_default,p_modifierVector); }
4422 1194170 : void SgFunctionModifier::setDefault() { setBit(e_default,p_modifierVector); }
4423 0 : void SgFunctionModifier::unsetDefault() { unsetBit(e_default,p_modifierVector); }
4424 :
4425 1074330 : bool SgFunctionModifier::isInline() const { return checkBit(e_inline,p_modifierVector); }
4426 51067 : void SgFunctionModifier::setInline() { setBit(e_inline,p_modifierVector); }
4427 200 : void SgFunctionModifier::unsetInline() { unsetBit(e_inline,p_modifierVector); }
4428 :
4429 22402 : bool SgFunctionModifier::isVirtual() const { return checkBit(e_virtual,p_modifierVector); }
4430 2927 : void SgFunctionModifier::setVirtual() { setBit(e_virtual,p_modifierVector); }
4431 0 : void SgFunctionModifier::unsetVirtual() { unsetBit(e_virtual,p_modifierVector); }
4432 :
4433 13539 : bool SgFunctionModifier::isPureVirtual() const { return checkBit(e_pure_virtual,p_modifierVector); }
4434 232 : void SgFunctionModifier::setPureVirtual() { setBit(e_pure_virtual,p_modifierVector); }
4435 0 : void SgFunctionModifier::unsetPureVirtual() { unsetBit(e_pure_virtual,p_modifierVector); }
4436 :
4437 1744 : bool SgFunctionModifier::isExplicit() const { return checkBit(e_explicit,p_modifierVector); }
4438 3920 : void SgFunctionModifier::setExplicit() { setBit(e_explicit,p_modifierVector); }
4439 0 : void SgFunctionModifier::unsetExplicit() { unsetBit(e_explicit,p_modifierVector); }
4440 :
4441 : #if 0
4442 : bool SgFunctionModifier::isBind() const { return checkBit(e_bind,p_modifierVector); }
4443 : void SgFunctionModifier::setBind() { setBit(e_bind,p_modifierVector); }
4444 : void SgFunctionModifier::unsetBind() { unsetBit(e_bind,p_modifierVector); }
4445 : #endif
4446 :
4447 715 : bool SgFunctionModifier::isPure() const { return checkBit(e_pure,p_modifierVector); }
4448 0 : void SgFunctionModifier::setPure() { setBit(e_pure,p_modifierVector); }
4449 0 : void SgFunctionModifier::unsetPure() { unsetBit(e_pure,p_modifierVector); }
4450 :
4451 715 : bool SgFunctionModifier::isElemental() const { return checkBit(e_elemental,p_modifierVector); }
4452 0 : void SgFunctionModifier::setElemental() { setBit(e_elemental,p_modifierVector); }
4453 0 : void SgFunctionModifier::unsetElemental() { unsetBit(e_elemental,p_modifierVector); }
4454 :
4455 715 : bool SgFunctionModifier::isRecursive() const { return checkBit(e_recursive,p_modifierVector); }
4456 0 : void SgFunctionModifier::setRecursive() { setBit(e_recursive,p_modifierVector); }
4457 0 : void SgFunctionModifier::unsetRecursive() { unsetBit(e_recursive,p_modifierVector); }
4458 :
4459 : // Rasmussen (10/26/2019): Added Jovial specific attribute
4460 697 : bool SgFunctionModifier::isReentrant() const { return checkBit(e_reentrant,p_modifierVector); }
4461 0 : void SgFunctionModifier::setReentrant() { setBit(e_reentrant,p_modifierVector); }
4462 0 : void SgFunctionModifier::unsetReentrant() { unsetBit(e_reentrant,p_modifierVector); }
4463 :
4464 : // DQ (1/3/2009): Added GNU specific attributes
4465 1350 : bool SgFunctionModifier::isGnuAttributeConstructor() const { return checkBit(e_gnu_attribute__constructor__,p_modifierVector); }
4466 0 : void SgFunctionModifier::setGnuAttributeConstructor() { setBit(e_gnu_attribute__constructor__,p_modifierVector); }
4467 0 : void SgFunctionModifier::unsetGnuAttributeConstructor() { unsetBit(e_gnu_attribute__constructor__,p_modifierVector); }
4468 :
4469 : // DQ (1/3/2009): Added GNU specific attributes
4470 1350 : bool SgFunctionModifier::isGnuAttributeDestructor() const { return checkBit(e_gnu_attribute__destructor__,p_modifierVector); }
4471 0 : void SgFunctionModifier::setGnuAttributeDestructor() { setBit(e_gnu_attribute__destructor__,p_modifierVector); }
4472 0 : void SgFunctionModifier::unsetGnuAttributeDestructor() { unsetBit(e_gnu_attribute__destructor__,p_modifierVector); }
4473 :
4474 : // DQ (1/3/2009): Added GNU specific attributes
4475 1350 : bool SgFunctionModifier::isGnuAttributePure() const { return checkBit(e_gnu_attribute__pure__,p_modifierVector); }
4476 1249 : void SgFunctionModifier::setGnuAttributePure() { setBit(e_gnu_attribute__pure__,p_modifierVector); }
4477 0 : void SgFunctionModifier::unsetGnuAttributePure() { unsetBit(e_gnu_attribute__pure__,p_modifierVector); }
4478 :
4479 : // DQ (1/3/2009): Added GNU specific attributes
4480 1350 : bool SgFunctionModifier::isGnuAttributeWeak() const { return checkBit(e_gnu_attribute__weak__,p_modifierVector); }
4481 2 : void SgFunctionModifier::setGnuAttributeWeak() { setBit(e_gnu_attribute__weak__,p_modifierVector); }
4482 0 : void SgFunctionModifier::unsetGnuAttributeWeak() { unsetBit(e_gnu_attribute__weak__,p_modifierVector); }
4483 :
4484 : // DQ (1/3/2009): Added GNU specific attributes
4485 1350 : bool SgFunctionModifier::isGnuAttributeUnused() const { return checkBit(e_gnu_attribute__unused__,p_modifierVector); }
4486 0 : void SgFunctionModifier::setGnuAttributeUnused() { setBit(e_gnu_attribute__unused__,p_modifierVector); }
4487 0 : void SgFunctionModifier::unsetGnuAttributeUnused() { unsetBit(e_gnu_attribute__unused__,p_modifierVector); }
4488 :
4489 : // DQ (1/3/2009): Added GNU specific attributes
4490 1350 : bool SgFunctionModifier::isGnuAttributeUsed() const { return checkBit(e_gnu_attribute__used__,p_modifierVector); }
4491 0 : void SgFunctionModifier::setGnuAttributeUsed() { setBit(e_gnu_attribute__used__,p_modifierVector); }
4492 0 : void SgFunctionModifier::unsetGnuAttributeUsed() { unsetBit(e_gnu_attribute__used__,p_modifierVector); }
4493 :
4494 : // DQ (1/3/2009): Added GNU specific attributes
4495 1350 : bool SgFunctionModifier::isGnuAttributeDeprecated() const { return checkBit(e_gnu_attribute__deprecated__,p_modifierVector); }
4496 58 : void SgFunctionModifier::setGnuAttributeDeprecated() { setBit(e_gnu_attribute__deprecated__,p_modifierVector); }
4497 0 : void SgFunctionModifier::unsetGnuAttributeDeprecated() { unsetBit(e_gnu_attribute__deprecated__,p_modifierVector); }
4498 :
4499 : // DQ (1/3/2009): Added GNU specific attributes
4500 1350 : bool SgFunctionModifier::isGnuAttributeMalloc() const { return checkBit(e_gnu_attribute__malloc__,p_modifierVector); }
4501 866 : void SgFunctionModifier::setGnuAttributeMalloc() { setBit(e_gnu_attribute__malloc__,p_modifierVector); }
4502 0 : void SgFunctionModifier::unsetGnuAttributeMalloc() { unsetBit(e_gnu_attribute__malloc__,p_modifierVector); }
4503 :
4504 : // DQ (1/3/2009): Added GNU specific attributes
4505 1350 : bool SgFunctionModifier::isGnuAttributeNaked() const { return checkBit(e_gnu_attribute__naked__,p_modifierVector); }
4506 0 : void SgFunctionModifier::setGnuAttributeNaked() { setBit(e_gnu_attribute__naked__,p_modifierVector); }
4507 0 : void SgFunctionModifier::unsetGnuAttributeNaked() { unsetBit(e_gnu_attribute__naked__,p_modifierVector); }
4508 :
4509 : // DQ (1/3/2009): Added GNU specific attributes
4510 1350 : bool SgFunctionModifier::isGnuAttributeNoInstrumentFunction() const { return checkBit(e_gnu_attribute__no_instrument_function__,p_modifierVector); }
4511 0 : void SgFunctionModifier::setGnuAttributeNoInstrumentFunction() { setBit(e_gnu_attribute__no_instrument_function__,p_modifierVector); }
4512 0 : void SgFunctionModifier::unsetGnuAttributeNoInstrumentFunction() { unsetBit(e_gnu_attribute__no_instrument_function__,p_modifierVector); }
4513 :
4514 : // DQ (1/3/2009): Added GNU specific attributes
4515 1350 : bool SgFunctionModifier::isGnuAttributeNoCheckMemoryUsage() const { return checkBit(e_gnu_attribute__no_check_memory_usage__,p_modifierVector); }
4516 0 : void SgFunctionModifier::setGnuAttributeNoCheckMemoryUsage() { setBit(e_gnu_attribute__no_check_memory_usage__,p_modifierVector); }
4517 0 : void SgFunctionModifier::unsetGnuAttributeNoCheckMemoryUsage() { unsetBit(e_gnu_attribute__no_check_memory_usage__,p_modifierVector); }
4518 :
4519 : // DQ (1/3/2009): Added GNU specific attributes
4520 1350 : bool SgFunctionModifier::isGnuAttributeNoInline() const { return checkBit(e_gnu_attribute__noinline__,p_modifierVector); }
4521 0 : void SgFunctionModifier::setGnuAttributeNoInline() { setBit(e_gnu_attribute__noinline__,p_modifierVector); }
4522 0 : void SgFunctionModifier::unsetGnuAttributeNoInline() { unsetBit(e_gnu_attribute__noinline__,p_modifierVector); }
4523 :
4524 : // DQ (1/3/2009): Added GNU specific attributes
4525 1350 : bool SgFunctionModifier::isGnuAttributeAlwaysInline() const { return checkBit(e_gnu_attribute__always_inline__,p_modifierVector); }
4526 0 : void SgFunctionModifier::setGnuAttributeAlwaysInline() { setBit(e_gnu_attribute__always_inline__,p_modifierVector); }
4527 0 : void SgFunctionModifier::unsetGnuAttributeAlwaysInline() { unsetBit(e_gnu_attribute__always_inline__,p_modifierVector); }
4528 :
4529 : // DQ (1/3/2009): Added GNU specific attributes
4530 1350 : bool SgFunctionModifier::isGnuAttributeNoThrow() const { return checkBit(e_gnu_attribute__nothrow__,p_modifierVector); }
4531 164503 : void SgFunctionModifier::setGnuAttributeNoThrow() { setBit(e_gnu_attribute__nothrow__,p_modifierVector); }
4532 0 : void SgFunctionModifier::unsetGnuAttributeNoThrow() { unsetBit(e_gnu_attribute__nothrow__,p_modifierVector); }
4533 :
4534 : // DQ (1/3/2009): Added GNU specific attributes
4535 1350 : bool SgFunctionModifier::isGnuAttributeWeakReference() const { return checkBit(e_gnu_attribute__weakref__,p_modifierVector); }
4536 0 : void SgFunctionModifier::setGnuAttributeWeakReference() { setBit(e_gnu_attribute__weakref__,p_modifierVector); }
4537 0 : void SgFunctionModifier::unsetGnuAttributeWeakReference() { unsetBit(e_gnu_attribute__weakref__,p_modifierVector); }
4538 :
4539 : // TV (04/08/2010): Support for CUDA functions modifiers
4540 1025 : bool SgFunctionModifier::isCudaDevice() const { return checkBit(e_cuda_device,p_modifierVector); }
4541 0 : void SgFunctionModifier::setCudaDevice() { setBit(e_cuda_device,p_modifierVector); }
4542 0 : void SgFunctionModifier::unsetCudaDevice() { unsetBit(e_cuda_device,p_modifierVector); }
4543 :
4544 1007 : bool SgFunctionModifier::isCudaKernel() const { return checkBit(e_cuda_kernel,p_modifierVector); }
4545 0 : void SgFunctionModifier::setCudaKernel() { setBit(e_cuda_kernel,p_modifierVector); }
4546 0 : void SgFunctionModifier::unsetCudaKernel() { unsetBit(e_cuda_kernel,p_modifierVector); }
4547 :
4548 1025 : bool SgFunctionModifier::isCudaHost() const { return checkBit(e_cuda_host,p_modifierVector); }
4549 0 : void SgFunctionModifier::setCudaHost() { setBit(e_cuda_host,p_modifierVector); }
4550 0 : void SgFunctionModifier::unsetCudaHost() { unsetBit(e_cuda_host,p_modifierVector); }
4551 :
4552 : // Rasmussen (03/13/2018): New CUDA function modifiers
4553 18 : bool SgFunctionModifier::isCudaGlobalFunction() const { return checkBit(e_cuda_global_function,p_modifierVector); }
4554 0 : void SgFunctionModifier::setCudaGlobalFunction() { setBit(e_cuda_global_function,p_modifierVector); }
4555 0 : void SgFunctionModifier::unsetCudaGlobalFunction() { unsetBit(e_cuda_global_function,p_modifierVector); }
4556 :
4557 18 : bool SgFunctionModifier::isCudaGridGlobal() const { return checkBit(e_cuda_grid_global,p_modifierVector); }
4558 0 : void SgFunctionModifier::setCudaGridGlobal() { setBit(e_cuda_grid_global,p_modifierVector); }
4559 0 : void SgFunctionModifier::unsetCudaGridGlobal() { unsetBit(e_cuda_grid_global,p_modifierVector); }
4560 :
4561 : // TV (05/03/2010): Support for OpenCL functions modifiers
4562 1007 : bool SgFunctionModifier::isOpenclKernel() const { return checkBit(e_opencl_kernel, p_modifierVector); }
4563 0 : void SgFunctionModifier::setOpenclKernel() { setBit(e_opencl_kernel, p_modifierVector); }
4564 0 : void SgFunctionModifier::unsetOpenclKernel() { unsetBit(e_opencl_kernel, p_modifierVector); }
4565 :
4566 1007 : bool SgFunctionModifier::hasOpenclVecTypeHint() const { return checkBit(e_opencl_vec_type_hint, p_modifierVector); }
4567 0 : void SgFunctionModifier::setOpenclVecTypeHint() { setBit(e_opencl_vec_type_hint,p_modifierVector); }
4568 0 : void SgFunctionModifier::unsetOpenclVecTypeHint() { unsetBit(e_opencl_vec_type_hint, p_modifierVector); }
4569 :
4570 1007 : bool SgFunctionModifier::hasOpenclWorkGroupSizeHint() const { return checkBit(e_opencl_work_group_size_hint, p_modifierVector); }
4571 0 : void SgFunctionModifier::setOpenclWorkGroupSizeHint() { setBit(e_opencl_work_group_size_hint,p_modifierVector); }
4572 0 : void SgFunctionModifier::unsetOpenclWorkGroupSizeHint() { unsetBit(e_opencl_work_group_size_hint, p_modifierVector); }
4573 :
4574 1007 : bool SgFunctionModifier::hasOpenclWorkGroupSizeReq() const { return checkBit(e_opencl_work_group_size_req, p_modifierVector); }
4575 0 : void SgFunctionModifier::setOpenclWorkGroupSizeReq() { setBit(e_opencl_work_group_size_req,p_modifierVector);}
4576 0 : void SgFunctionModifier::unsetOpenclWorkGroupSizeReq() { unsetBit(e_opencl_work_group_size_req, p_modifierVector); }
4577 :
4578 : // DQ (4/13/2019): Added C++11 options for function modifiers.
4579 997 : bool SgFunctionModifier::isMarkedDefault() const { return checkBit(e_marked_default, p_modifierVector); }
4580 660 : void SgFunctionModifier::setMarkedDefault() { setBit(e_marked_default, p_modifierVector); }
4581 0 : void SgFunctionModifier::unsetMarkedDefault() { unsetBit(e_marked_default, p_modifierVector); }
4582 :
4583 : // DQ (4/13/2019): Added C++11 options for function modifiers.
4584 993 : bool SgFunctionModifier::isMarkedDelete() const { return checkBit(e_marked_delete, p_modifierVector); }
4585 300 : void SgFunctionModifier::setMarkedDelete() { setBit(e_marked_delete, p_modifierVector); }
4586 0 : void SgFunctionModifier::unsetMarkedDelete() { unsetBit(e_marked_delete, p_modifierVector); }
4587 :
4588 :
4589 :
4590 :
4591 : string
4592 697 : SgFunctionModifier::displayString() const
4593 : {
4594 697 : std::string s = "SgFunctionModifier(";
4595 2788 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
4596 2091 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
4597 2368 : s += std::string("isInline() = ") + std::string(isInline() ? "true " : "false ");
4598 2786 : s += std::string("isVirtual() = ") + std::string(isVirtual() ? "true " : "false ");
4599 2788 : s += std::string("isPureVirtual() = ") + std::string(isPureVirtual() ? "true " : "false ");
4600 2778 : s += std::string("isExplicit() = ") + std::string(isExplicit() ? "true " : "false ");
4601 : // s += std::string("isBind() = ") + std::string(isBind() ? "true " : "false ");
4602 2788 : s += std::string("isPure() = ") + std::string(isPure() ? "true " : "false ");
4603 :
4604 : // DQ (2/26/2013): Bug report noticed that a set of these attributes were not properly support.
4605 2788 : s += std::string("isElemental() = ") + std::string(isElemental() ? "true " : "false ");
4606 2788 : s += std::string("isRecursive() = ") + std::string(isRecursive() ? "true " : "false ");
4607 2788 : s += std::string("isReentrant() = ") + std::string(isReentrant() ? "true " : "false ");
4608 2788 : s += std::string("isGnuAttributeConstructor() = ") + std::string(isGnuAttributeConstructor() ? "true " : "false ");
4609 2788 : s += std::string("isGnuAttributeDestructor() = ") + std::string(isGnuAttributeDestructor() ? "true " : "false ");
4610 2788 : s += std::string("isGnuAttributePure() = ") + std::string(isGnuAttributePure() ? "true " : "false ");
4611 2788 : s += std::string("isGnuAttributeWeak() = ") + std::string(isGnuAttributeWeak() ? "true " : "false ");
4612 2788 : s += std::string("isGnuAttributeUnused() = ") + std::string(isGnuAttributeUnused() ? "true " : "false ");
4613 2788 : s += std::string("isGnuAttributeUsed() = ") + std::string(isGnuAttributeUsed() ? "true " : "false ");
4614 2788 : s += std::string("isGnuAttributeDeprecated() = ") + std::string(isGnuAttributeDeprecated() ? "true " : "false ");
4615 2788 : s += std::string("isGnuAttributeMalloc() = ") + std::string(isGnuAttributeMalloc() ? "true " : "false ");
4616 2788 : s += std::string("isGnuAttributeNaked() = ") + std::string(isGnuAttributeNaked() ? "true " : "false ");
4617 2788 : s += std::string("isGnuAttributeNoInstrumentFunction() = ") + std::string(isGnuAttributeNoInstrumentFunction() ? "true " : "false ");
4618 2788 : s += std::string("isGnuAttributeNoCheckMemoryUsage() = ") + std::string(isGnuAttributeNoCheckMemoryUsage() ? "true " : "false ");
4619 2788 : s += std::string("isGnuAttributeNoInline() = ") + std::string(isGnuAttributeNoInline() ? "true " : "false ");
4620 2788 : s += std::string("isGnuAttributeAlwaysInline() = ") + std::string(isGnuAttributeAlwaysInline() ? "true " : "false ");
4621 2492 : s += std::string("isGnuAttributeNoThrow() = ") + std::string(isGnuAttributeNoThrow() ? "true " : "false ");
4622 2788 : s += std::string("isGnuAttributeWeakReference() = ") + std::string(isGnuAttributeWeakReference() ? "true " : "false ");
4623 :
4624 697 : s += ")";
4625 697 : return s;
4626 : }
4627 :
4628 : void
4629 0 : SgFunctionModifier::display ( std::string label ) const
4630 : {
4631 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
4632 0 : printf ("In SgFunctionModifier::display(%s) \n",label.c_str());
4633 0 : printf ("%s \n",displayString().c_str());
4634 0 : }
4635 :
4636 0 : std::ostream & operator<< ( std::ostream & os, const SgFunctionModifier & m)
4637 : {
4638 0 : os << m.get_modifierVector();
4639 0 : return os;
4640 : }
4641 :
4642 0 : std::ostream & operator<< ( std::ostream & os, const std::vector<bool> & bv )
4643 : {
4644 : // DQ (1/26/2006): Modified to handle 64 bit machines
4645 : // for (unsigned int i=0; i < bv.size(); i++)
4646 : // for (vector<bool>::size_type i=0; i < bv.size(); i++)
4647 0 : for (unsigned int i=0; i < bv.size(); i++)
4648 0 : os << ((bv[i] == true) ? "T" : "F");
4649 0 : return os;
4650 : }
4651 :
4652 0 : bool operator== (const SgFunctionModifier& lhs, const SgFunctionModifier& rhs)
4653 : {
4654 0 : return
4655 0 : (lhs.isUnknown() == rhs.isUnknown() ) &&
4656 0 : (lhs.isDefault() == rhs.isDefault() ) &&
4657 0 : (lhs.isInline() == rhs.isInline() ) &&
4658 : // C++ specific
4659 0 : (lhs.isVirtual() == rhs.isVirtual() ) &&
4660 0 : (lhs.isPureVirtual() == rhs.isPureVirtual()) &&
4661 : // Fortran specific
4662 0 : (lhs.isExplicit() == rhs.isExplicit() ) &&
4663 0 : (lhs.isPure() == rhs.isPure() ) &&
4664 0 : (lhs.isElemental() == rhs.isElemental()) &&
4665 0 : (lhs.isRecursive() == rhs.isRecursive()) &&
4666 0 : (lhs.isReentrant() == rhs.isReentrant()) &&
4667 : // GNU specific
4668 0 : (lhs.isGnuAttributeConstructor() == rhs.isGnuAttributeConstructor()) &&
4669 0 : (lhs.isGnuAttributeDestructor() == rhs.isGnuAttributeDestructor() ) &&
4670 0 : (lhs.isGnuAttributePure() == rhs.isGnuAttributePure() ) &&
4671 0 : (lhs.isGnuAttributeWeak() == rhs.isGnuAttributeWeak() ) &&
4672 0 : (lhs.isGnuAttributeUnused() == rhs.isGnuAttributeUnused() ) &&
4673 0 : (lhs.isGnuAttributeUsed() == rhs.isGnuAttributeUsed() ) &&
4674 0 : (lhs.isGnuAttributeDeprecated() == rhs.isGnuAttributeDeprecated() ) &&
4675 0 : (lhs.isGnuAttributeMalloc() == rhs.isGnuAttributeMalloc() ) &&
4676 0 : (lhs.isGnuAttributeNaked() == rhs.isGnuAttributeNaked() ) &&
4677 0 : (lhs.isGnuAttributeNoInstrumentFunction() == rhs.isGnuAttributeNoInstrumentFunction()) &&
4678 0 : (lhs.isGnuAttributeNoCheckMemoryUsage() == rhs.isGnuAttributeNoCheckMemoryUsage()) &&
4679 0 : (lhs.isGnuAttributeNoInline() == rhs.isGnuAttributeNoInline() ) &&
4680 0 : (lhs.isGnuAttributeAlwaysInline() == rhs.isGnuAttributeAlwaysInline() ) &&
4681 0 : (lhs.isGnuAttributeNoThrow() == rhs.isGnuAttributeNoThrow() ) &&
4682 0 : (lhs.isGnuAttributeWeakReference() == rhs.isGnuAttributeWeakReference() ) &&
4683 : // Cuda specific
4684 0 : (lhs.isCudaDevice() == rhs.isCudaDevice()) &&
4685 0 : (lhs.isCudaKernel() == rhs.isCudaKernel()) &&
4686 0 : (lhs.isCudaHost() == rhs.isCudaHost() ) &&
4687 0 : (lhs.isCudaGlobalFunction() == rhs.isCudaGlobalFunction()) &&
4688 0 : (lhs.isCudaGridGlobal() == rhs.isCudaGridGlobal()) &&
4689 : // OpenCL specific
4690 0 : (lhs.isOpenclKernel() == rhs.isOpenclKernel() ) &&
4691 0 : (lhs.hasOpenclVecTypeHint() == rhs.hasOpenclVecTypeHint() ) &&
4692 0 : (lhs.hasOpenclWorkGroupSizeHint() == rhs.hasOpenclWorkGroupSizeHint()) &&
4693 0 : (lhs.hasOpenclWorkGroupSizeReq() == rhs.hasOpenclWorkGroupSizeReq() ) &&
4694 0 : true;
4695 : }
4696 :
4697 : // DQ (2/4/2006): Added mechamism to clear all bits
4698 0 : void SgFunctionModifier::reset()
4699 : {
4700 : // Unset each bit separately
4701 0 : unsetUnknown();
4702 0 : unsetInline();
4703 0 : unsetVirtual();
4704 0 : unsetPureVirtual();
4705 0 : unsetExplicit();
4706 : // unsetBind();
4707 0 : unsetPure();
4708 :
4709 : // Set this bit to indicate the default value (we want a value of all zero bits to be an error)
4710 0 : setDefault();
4711 0 : }
4712 :
4713 :
4714 :
4715 : // End of memberFunctionString
4716 : // Start of memberFunctionString
4717 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
4718 :
4719 : // *** COMMON CODE SECTION BEGINS HERE ***
4720 :
4721 : #if 0
4722 : int
4723 : SgFunctionModifier::getVariant() const
4724 : {
4725 : // This function is used in ROSE while "variant()" is used in SAGE
4726 : assert(this != NULL);
4727 : return variant();
4728 : }
4729 : #endif
4730 :
4731 : // This function is used in ROSE in treeTraversal code
4732 : // eventually replaces getVariant() and variant()
4733 : // though after variant() has been removed for a while we will
4734 : // want to change the name of variantT() back to variant()
4735 : // (since the "T" was ment to stand for temporary).
4736 : // When this happens the variantT() will be depricated.
4737 : VariantT
4738 3582520 : SgFunctionModifier::variantT() const
4739 : {
4740 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
4741 3582520 : ROSE_ASSERT(this != NULL);
4742 3582520 : return V_SgFunctionModifier;
4743 : }
4744 :
4745 : #if 0
4746 : int
4747 : SgFunctionModifier::variant() const
4748 : {
4749 : // This function is used in SAGE
4750 : ROSE_ASSERT(this != NULL);
4751 : return FunctionModifierTag;
4752 : }
4753 : #endif
4754 :
4755 : ROSE_DLL_API const char*
4756 0 : SgFunctionModifier::sage_class_name() const
4757 : {
4758 0 : ROSE_ASSERT(this != NULL);
4759 0 : return "SgFunctionModifier";
4760 : }
4761 :
4762 : std::string
4763 0 : SgFunctionModifier::class_name() const
4764 : {
4765 0 : ROSE_ASSERT(this != NULL);
4766 0 : return "SgFunctionModifier";
4767 : }
4768 :
4769 : // DQ (11/26/2005): Support for visitor pattern mechanims
4770 : // (inferior to ROSE traversal mechanism, experimental).
4771 : void
4772 0 : SgFunctionModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
4773 : {
4774 0 : ROSE_ASSERT(this != NULL);
4775 0 : visitor.visit(this);
4776 0 : }
4777 :
4778 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
4779 0 : void SgFunctionModifier::accept (ROSE_VisitorPattern & visitor) {
4780 0 : ROSE_ASSERT(this != NULL);
4781 0 : visitor.visit(this);
4782 0 : }
4783 :
4784 : SgFunctionModifier*
4785 0 : SgFunctionModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
4786 : {
4787 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
4788 : // This function is currently only supported for the AST used the represent Binary executables.
4789 : if (0 /* isSgAsmNode(this) != NULL */)
4790 : {
4791 : // Support for regex specification.
4792 : std::string prefixCode = "REGEX:";
4793 : addNewAttribute(prefixCode + s,a);
4794 : }
4795 : #endif
4796 :
4797 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
4798 0 : return this;
4799 : }
4800 :
4801 : // *** COMMON CODE SECTION ENDS HERE ***
4802 :
4803 :
4804 : // End of memberFunctionString
4805 : // Start of memberFunctionString
4806 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
4807 :
4808 :
4809 : #if 0
4810 : //! Error checking support
4811 : /*! Verifies the following:
4812 : - working getVariant() member function
4813 : - calls base class's error() member function
4814 : Every class has one of these functions.
4815 : */
4816 : bool
4817 : SgFunctionModifier::error()
4818 : {
4819 : // Put error checking here
4820 :
4821 : ROSE_ASSERT (this != NULL);
4822 : if (getVariant() != FunctionModifierTag)
4823 : {
4824 : printf ("Error in SgFunctionModifier::error(): SgFunctionModifier object has a %s variant \n",
4825 : Cxx_GrammarTerminalNames[getVariant()].name);
4826 : // printf ("Error in SgFunctionModifier::error() \n");
4827 : ROSE_ABORT();
4828 : }
4829 :
4830 : ROSE_ASSERT (getVariant() == FunctionModifierTag);
4831 : return SgModifier::error();
4832 : }
4833 : #endif
4834 :
4835 :
4836 :
4837 : // End of memberFunctionString
4838 :
4839 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
4840 :
4841 1194170 : SgFunctionModifier* isSgFunctionModifier ( SgNode* inputDerivedClassPointer )
4842 : {
4843 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
4844 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
4845 : // So to fix this we return NULL directly when the input is NULL and avoid the
4846 : // dynamic_cast in this case. This is likely a performance improvement as well.
4847 : // return dynamic_cast<SgFunctionModifier*>(inputDerivedClassPointer);
4848 : // Milind Chabbi (8/28/2013): isSgFunctionModifier uses table-driven castability instead of c++ default dynamic_cast
4849 : // this improves the running time performance by 10-20%.
4850 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionModifier*>(inputDerivedClassPointer);
4851 1194170 : return IS_SgFunctionModifier_FAST_MACRO(inputDerivedClassPointer);
4852 : }
4853 :
4854 : // DQ (11/8/2003): Added version of functions taking const pointer
4855 0 : const SgFunctionModifier* isSgFunctionModifier ( const SgNode* inputDerivedClassPointer )
4856 : {
4857 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
4858 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
4859 : // So to fix this we return NULL directly when the input is NULL and avoid the
4860 : // dynamic_cast in this case. This is likely a performance improvement as well.
4861 : // return dynamic_cast<const SgFunctionModifier*>(inputDerivedClassPointer);
4862 : // Milind Chabbi (8/28/2013): isSgFunctionModifier uses table-driven castability instead of c++ default dynamic_cast
4863 : // this improves the running time performance by 10-20%.
4864 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionModifier*>(inputDerivedClassPointer);
4865 0 : return IS_SgFunctionModifier_FAST_MACRO(inputDerivedClassPointer);
4866 : }
4867 :
4868 :
4869 :
4870 : /* #line 4871 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4871 :
4872 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
4873 :
4874 : /**
4875 : \brief Generated destructor
4876 :
4877 : This destructor is automatically generated (by ROSETTA). This destructor
4878 : only frees memory of data members associated with the parts of the current IR node which
4879 : are NOT traversed. Those data members that are part of a traversal can be freed using
4880 : a traversal (calling this destructor on all children in a post-order traversal). Such
4881 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
4882 :
4883 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
4884 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
4885 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
4886 :
4887 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
4888 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
4889 : pointers are not yet implemented to call delete on eash pointer in the container.
4890 : (This could be done by derivation from the STL containers to define containers that
4891 : automatically deleted their members.)
4892 :
4893 : */
4894 39915 : SgFunctionModifier::~SgFunctionModifier () {
4895 39915 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
4896 :
4897 :
4898 : // case: not a listType for gnu_attribute_constructor_destructor_priority
4899 39915 : p_gnu_attribute_constructor_destructor_priority = 0; // non list case
4900 : // case: not a listType for gnu_attribute_named_weak_reference
4901 39915 : p_gnu_attribute_named_weak_reference =""; // non list case
4902 : // case: not a listType for gnu_attribute_named_alias
4903 39915 : p_gnu_attribute_named_alias =""; // non list case
4904 : // case: not a listType for opencl_vec_type
4905 39915 : p_opencl_vec_type = NULL; // non list case
4906 :
4907 : }
4908 :
4909 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
4910 39915 : }
4911 :
4912 :
4913 : /* #line 4914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4914 :
4915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
4916 :
4917 : // Generated constructor
4918 1194170 : SgFunctionModifier::SgFunctionModifier ( )
4919 1194170 : : SgModifier()
4920 : {
4921 : #ifdef DEBUG
4922 : // printf ("In SgFunctionModifier::SgFunctionModifier () sage_class_name() = %s \n",sage_class_name());
4923 : #endif
4924 : #if 0
4925 : // debugging information!
4926 : printf ("In SgFunctionModifier::SgFunctionModifier (): this = %p = %s \n",this,this->class_name().c_str());
4927 : #endif
4928 :
4929 1194170 : p_gnu_attribute_constructor_destructor_priority = 0;
4930 1194170 : p_gnu_attribute_named_weak_reference ="";
4931 1194170 : p_gnu_attribute_named_alias ="";
4932 1194170 : p_opencl_vec_type = NULL;
4933 :
4934 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
4935 :
4936 : #if 0
4937 : // DQ (7/30/2014): Call a virtual function.
4938 : std::string s = this->class_name();
4939 : #endif
4940 :
4941 : // Test the variant virtual function
4942 : // assert(FunctionModifierTag == variant());
4943 1194170 : assert(FunctionModifierTag == this->variant());
4944 1194170 : ROSE_ASSERT(FunctionModifierTag == (int)(this->variantT()));
4945 1194170 : post_construction_initialization();
4946 :
4947 : // Test the isSgFunctionModifier() function since it has been problematic
4948 1194170 : assert(isSgFunctionModifier(this) != NULL);
4949 1194170 : }
4950 :
4951 : // Generated constructor (all data members)
4952 :
4953 : /* #line 4954 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4954 :
4955 :
4956 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
4957 :
4958 :
4959 : // ********************************************************
4960 : // member functions common across all array grammar objects
4961 : // ********************************************************
4962 :
4963 :
4964 :
4965 : /* #line 4966 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4966 :
4967 :
4968 :
4969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
4970 :
4971 : // ********************************************************
4972 : // member functions specific to each node in the grammar
4973 : // ********************************************************
4974 :
4975 :
4976 : /* #line 4977 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
4977 :
4978 : // Start of memberFunctionString
4979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
4980 :
4981 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
4982 :
4983 : SgUPC_AccessModifier::upc_access_modifier_enum
4984 0 : SgUPC_AccessModifier::get_modifier () const
4985 : {
4986 0 : ROSE_ASSERT (this != NULL);
4987 :
4988 : #if 0
4989 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
4990 : // used to trigger marking transformations for the token-based unparsing.
4991 : printf ("SgUPC_AccessModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
4992 : #endif
4993 :
4994 0 : return p_modifier;
4995 : }
4996 :
4997 : void
4998 0 : SgUPC_AccessModifier::set_modifier ( SgUPC_AccessModifier::upc_access_modifier_enum modifier )
4999 : {
5000 0 : ROSE_ASSERT (this != NULL);
5001 :
5002 : #if 0
5003 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5004 : // used to trigger marking transformations for the token-based unparsing.
5005 : printf ("SgUPC_AccessModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
5006 : #endif
5007 :
5008 0 : set_isModified(true);
5009 :
5010 0 : p_modifier = modifier;
5011 0 : }
5012 :
5013 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
5014 :
5015 :
5016 : // End of memberFunctionString
5017 : // Start of memberFunctionString
5018 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
5019 :
5020 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
5021 :
5022 : bool
5023 603026 : SgUPC_AccessModifier::get_isShared () const
5024 : {
5025 603026 : ROSE_ASSERT (this != NULL);
5026 :
5027 : #if 0
5028 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5029 : // used to trigger marking transformations for the token-based unparsing.
5030 : printf ("SgUPC_AccessModifier::get_isShared = %p = %s \n",this,this->class_name().c_str());
5031 : #endif
5032 :
5033 603026 : return p_isShared;
5034 : }
5035 :
5036 : void
5037 20 : SgUPC_AccessModifier::set_isShared ( bool isShared )
5038 : {
5039 20 : ROSE_ASSERT (this != NULL);
5040 :
5041 : #if 0
5042 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5043 : // used to trigger marking transformations for the token-based unparsing.
5044 : printf ("SgUPC_AccessModifier::set_isShared = %p = %s \n",this,this->class_name().c_str());
5045 : #endif
5046 :
5047 20 : set_isModified(true);
5048 :
5049 20 : p_isShared = isShared;
5050 20 : }
5051 :
5052 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
5053 :
5054 :
5055 : // End of memberFunctionString
5056 : // Start of memberFunctionString
5057 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
5058 :
5059 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
5060 :
5061 : long
5062 6990 : SgUPC_AccessModifier::get_layout () const
5063 : {
5064 6990 : ROSE_ASSERT (this != NULL);
5065 :
5066 : #if 0
5067 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5068 : // used to trigger marking transformations for the token-based unparsing.
5069 : printf ("SgUPC_AccessModifier::get_layout = %p = %s \n",this,this->class_name().c_str());
5070 : #endif
5071 :
5072 6990 : return p_layout;
5073 : }
5074 :
5075 : void
5076 20 : SgUPC_AccessModifier::set_layout ( long layout )
5077 : {
5078 20 : ROSE_ASSERT (this != NULL);
5079 :
5080 : #if 0
5081 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5082 : // used to trigger marking transformations for the token-based unparsing.
5083 : printf ("SgUPC_AccessModifier::set_layout = %p = %s \n",this,this->class_name().c_str());
5084 : #endif
5085 :
5086 20 : set_isModified(true);
5087 :
5088 20 : p_layout = layout;
5089 20 : }
5090 :
5091 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
5092 :
5093 :
5094 : // End of memberFunctionString
5095 : // Start of memberFunctionString
5096 : /* #line 3319 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
5097 :
5098 : // Copy constructor
5099 0 : SgUPC_AccessModifier::SgUPC_AccessModifier ( const SgUPC_AccessModifier & X )
5100 : {
5101 0 : p_modifier = X.p_modifier;
5102 0 : }
5103 :
5104 : SgUPC_AccessModifier &
5105 163337 : SgUPC_AccessModifier::operator= ( const SgUPC_AccessModifier & X )
5106 : {
5107 163337 : p_modifier = X.p_modifier;
5108 163337 : return *this;
5109 : }
5110 :
5111 : void
5112 5130600 : SgUPC_AccessModifier::post_construction_initialization()
5113 : {
5114 5130600 : p_modifier = e_default;
5115 5130600 : }
5116 :
5117 18273 : bool SgUPC_AccessModifier::isUnknown() const { return p_modifier == e_unknown; }
5118 0 : void SgUPC_AccessModifier::setUnknown() { p_modifier = e_unknown; }
5119 :
5120 18273 : bool SgUPC_AccessModifier::isDefault() const { return p_modifier == e_default; }
5121 12815700 : void SgUPC_AccessModifier::setDefault() { p_modifier = e_default; }
5122 :
5123 : // bool SgUPC_AccessModifier::isUPC_Shared() const { return p_modifier == e_upc_shared; }
5124 : // void SgUPC_AccessModifier::setUPC_Shared() { p_modifier = e_upc_shared; }
5125 :
5126 611947 : bool SgUPC_AccessModifier::isUPC_Strict() const { return p_modifier == e_upc_strict; }
5127 0 : void SgUPC_AccessModifier::setUPC_Strict() { p_modifier = e_upc_strict; }
5128 :
5129 611947 : bool SgUPC_AccessModifier::isUPC_Relaxed() const { return p_modifier == e_upc_relaxed; }
5130 0 : void SgUPC_AccessModifier::setUPC_Relaxed() { p_modifier = e_upc_relaxed; }
5131 :
5132 : string
5133 6893 : SgUPC_AccessModifier::displayString() const
5134 : {
5135 6893 : std::string s = "SgUPC_AccessModifier(";
5136 27572 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
5137 20679 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
5138 : // s += std::string("isUPC_Shared() = ") + std::string(isUPC_Shared() ? "true " : "false ");
5139 27572 : s += std::string("isUPC_Strict() = ") + std::string(isUPC_Strict() ? "true " : "false ");
5140 27572 : s += std::string("isUPC_Relaxed() = ") + std::string(isUPC_Relaxed() ? "true " : "false ");
5141 :
5142 : // DQ (6/13/2008): Added support for layout and shared use with "strict" or "relaxed"
5143 27572 : s += std::string("get_isShared() = ") + std::string(get_isShared() ? "true " : "false ");
5144 20679 : s += std::string("get_layout() = ") + Rose::StringUtility::numberToString(get_layout());
5145 :
5146 6893 : s += ")";
5147 6893 : return s;
5148 : }
5149 :
5150 : void
5151 0 : SgUPC_AccessModifier::display ( std::string label ) const
5152 : {
5153 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
5154 0 : printf ("In SgUPC_AccessModifier::display(%s) \n",label.c_str());
5155 0 : printf ("%s \n",displayString().c_str());
5156 0 : }
5157 :
5158 0 : std::ostream & operator<< ( std::ostream & os, const SgUPC_AccessModifier & m)
5159 : {
5160 0 : os << m.get_modifier();
5161 0 : return os;
5162 : }
5163 :
5164 5690 : bool operator== (const SgUPC_AccessModifier& lhs, const SgUPC_AccessModifier& rhs)
5165 : {
5166 5690 : return
5167 11380 : (lhs.isUnknown() == rhs.isUnknown() ) &&
5168 11380 : (lhs.isDefault() == rhs.isDefault() ) &&
5169 11380 : (lhs.isUPC_Strict() == rhs.isUPC_Strict() ) &&
5170 11380 : (lhs.isUPC_Relaxed() == rhs.isUPC_Relaxed()) &&
5171 5690 : true;
5172 : }
5173 :
5174 : // DQ (2/4/2006): Added mechamism to clear all bits
5175 12815700 : void SgUPC_AccessModifier::reset()
5176 : {
5177 12815700 : setDefault();
5178 12815700 : }
5179 :
5180 :
5181 :
5182 : // End of memberFunctionString
5183 : // Start of memberFunctionString
5184 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
5185 :
5186 : // *** COMMON CODE SECTION BEGINS HERE ***
5187 :
5188 : #if 0
5189 : int
5190 : SgUPC_AccessModifier::getVariant() const
5191 : {
5192 : // This function is used in ROSE while "variant()" is used in SAGE
5193 : assert(this != NULL);
5194 : return variant();
5195 : }
5196 : #endif
5197 :
5198 : // This function is used in ROSE in treeTraversal code
5199 : // eventually replaces getVariant() and variant()
5200 : // though after variant() has been removed for a while we will
5201 : // want to change the name of variantT() back to variant()
5202 : // (since the "T" was ment to stand for temporary).
5203 : // When this happens the variantT() will be depricated.
5204 : VariantT
5205 15391800 : SgUPC_AccessModifier::variantT() const
5206 : {
5207 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
5208 15391800 : ROSE_ASSERT(this != NULL);
5209 15391800 : return V_SgUPC_AccessModifier;
5210 : }
5211 :
5212 : #if 0
5213 : int
5214 : SgUPC_AccessModifier::variant() const
5215 : {
5216 : // This function is used in SAGE
5217 : ROSE_ASSERT(this != NULL);
5218 : return UPC_AccessModifierTag;
5219 : }
5220 : #endif
5221 :
5222 : ROSE_DLL_API const char*
5223 0 : SgUPC_AccessModifier::sage_class_name() const
5224 : {
5225 0 : ROSE_ASSERT(this != NULL);
5226 0 : return "SgUPC_AccessModifier";
5227 : }
5228 :
5229 : std::string
5230 0 : SgUPC_AccessModifier::class_name() const
5231 : {
5232 0 : ROSE_ASSERT(this != NULL);
5233 0 : return "SgUPC_AccessModifier";
5234 : }
5235 :
5236 : // DQ (11/26/2005): Support for visitor pattern mechanims
5237 : // (inferior to ROSE traversal mechanism, experimental).
5238 : void
5239 0 : SgUPC_AccessModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
5240 : {
5241 0 : ROSE_ASSERT(this != NULL);
5242 0 : visitor.visit(this);
5243 0 : }
5244 :
5245 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
5246 0 : void SgUPC_AccessModifier::accept (ROSE_VisitorPattern & visitor) {
5247 0 : ROSE_ASSERT(this != NULL);
5248 0 : visitor.visit(this);
5249 0 : }
5250 :
5251 : SgUPC_AccessModifier*
5252 0 : SgUPC_AccessModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
5253 : {
5254 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
5255 : // This function is currently only supported for the AST used the represent Binary executables.
5256 : if (0 /* isSgAsmNode(this) != NULL */)
5257 : {
5258 : // Support for regex specification.
5259 : std::string prefixCode = "REGEX:";
5260 : addNewAttribute(prefixCode + s,a);
5261 : }
5262 : #endif
5263 :
5264 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
5265 0 : return this;
5266 : }
5267 :
5268 : // *** COMMON CODE SECTION ENDS HERE ***
5269 :
5270 :
5271 : // End of memberFunctionString
5272 : // Start of memberFunctionString
5273 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
5274 :
5275 :
5276 : #if 0
5277 : //! Error checking support
5278 : /*! Verifies the following:
5279 : - working getVariant() member function
5280 : - calls base class's error() member function
5281 : Every class has one of these functions.
5282 : */
5283 : bool
5284 : SgUPC_AccessModifier::error()
5285 : {
5286 : // Put error checking here
5287 :
5288 : ROSE_ASSERT (this != NULL);
5289 : if (getVariant() != UPC_AccessModifierTag)
5290 : {
5291 : printf ("Error in SgUPC_AccessModifier::error(): SgUPC_AccessModifier object has a %s variant \n",
5292 : Cxx_GrammarTerminalNames[getVariant()].name);
5293 : // printf ("Error in SgUPC_AccessModifier::error() \n");
5294 : ROSE_ABORT();
5295 : }
5296 :
5297 : ROSE_ASSERT (getVariant() == UPC_AccessModifierTag);
5298 : return SgModifier::error();
5299 : }
5300 : #endif
5301 :
5302 :
5303 :
5304 : // End of memberFunctionString
5305 :
5306 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
5307 :
5308 5130600 : SgUPC_AccessModifier* isSgUPC_AccessModifier ( SgNode* inputDerivedClassPointer )
5309 : {
5310 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
5311 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
5312 : // So to fix this we return NULL directly when the input is NULL and avoid the
5313 : // dynamic_cast in this case. This is likely a performance improvement as well.
5314 : // return dynamic_cast<SgUPC_AccessModifier*>(inputDerivedClassPointer);
5315 : // Milind Chabbi (8/28/2013): isSgUPC_AccessModifier uses table-driven castability instead of c++ default dynamic_cast
5316 : // this improves the running time performance by 10-20%.
5317 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUPC_AccessModifier*>(inputDerivedClassPointer);
5318 5130600 : return IS_SgUPC_AccessModifier_FAST_MACRO(inputDerivedClassPointer);
5319 : }
5320 :
5321 : // DQ (11/8/2003): Added version of functions taking const pointer
5322 0 : const SgUPC_AccessModifier* isSgUPC_AccessModifier ( const SgNode* inputDerivedClassPointer )
5323 : {
5324 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
5325 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
5326 : // So to fix this we return NULL directly when the input is NULL and avoid the
5327 : // dynamic_cast in this case. This is likely a performance improvement as well.
5328 : // return dynamic_cast<const SgUPC_AccessModifier*>(inputDerivedClassPointer);
5329 : // Milind Chabbi (8/28/2013): isSgUPC_AccessModifier uses table-driven castability instead of c++ default dynamic_cast
5330 : // this improves the running time performance by 10-20%.
5331 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUPC_AccessModifier*>(inputDerivedClassPointer);
5332 0 : return IS_SgUPC_AccessModifier_FAST_MACRO(inputDerivedClassPointer);
5333 : }
5334 :
5335 :
5336 :
5337 : /* #line 5338 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5338 :
5339 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
5340 :
5341 : /**
5342 : \brief Generated destructor
5343 :
5344 : This destructor is automatically generated (by ROSETTA). This destructor
5345 : only frees memory of data members associated with the parts of the current IR node which
5346 : are NOT traversed. Those data members that are part of a traversal can be freed using
5347 : a traversal (calling this destructor on all children in a post-order traversal). Such
5348 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
5349 :
5350 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
5351 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
5352 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
5353 :
5354 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
5355 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
5356 : pointers are not yet implemented to call delete on eash pointer in the container.
5357 : (This could be done by derivation from the STL containers to define containers that
5358 : automatically deleted their members.)
5359 :
5360 : */
5361 1453340 : SgUPC_AccessModifier::~SgUPC_AccessModifier () {
5362 1453340 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
5363 :
5364 :
5365 : // case: not a listType for modifier
5366 1453340 : p_modifier = SgUPC_AccessModifier::e_unknown; // non list case
5367 : // case: not a listType for isShared
5368 1453340 : p_isShared = false; // non list case
5369 : // case: not a listType for layout
5370 1453340 : p_layout = -1; // non list case
5371 :
5372 : }
5373 :
5374 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
5375 1453340 : }
5376 :
5377 :
5378 : /* #line 5379 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5379 :
5380 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
5381 :
5382 : // Generated constructor
5383 5130600 : SgUPC_AccessModifier::SgUPC_AccessModifier ( )
5384 5130600 : : SgModifier()
5385 : {
5386 : #ifdef DEBUG
5387 : // printf ("In SgUPC_AccessModifier::SgUPC_AccessModifier () sage_class_name() = %s \n",sage_class_name());
5388 : #endif
5389 : #if 0
5390 : // debugging information!
5391 : printf ("In SgUPC_AccessModifier::SgUPC_AccessModifier (): this = %p = %s \n",this,this->class_name().c_str());
5392 : #endif
5393 :
5394 5130600 : p_modifier = SgUPC_AccessModifier::e_unknown;
5395 5130600 : p_isShared = false;
5396 5130600 : p_layout = -1;
5397 :
5398 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
5399 :
5400 : #if 0
5401 : // DQ (7/30/2014): Call a virtual function.
5402 : std::string s = this->class_name();
5403 : #endif
5404 :
5405 : // Test the variant virtual function
5406 : // assert(UPC_AccessModifierTag == variant());
5407 5130600 : assert(UPC_AccessModifierTag == this->variant());
5408 5130600 : ROSE_ASSERT(UPC_AccessModifierTag == (int)(this->variantT()));
5409 5130600 : post_construction_initialization();
5410 :
5411 : // Test the isSgUPC_AccessModifier() function since it has been problematic
5412 5130600 : assert(isSgUPC_AccessModifier(this) != NULL);
5413 5130600 : }
5414 :
5415 : // Generated constructor (all data members)
5416 :
5417 : /* #line 5418 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5418 :
5419 :
5420 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
5421 :
5422 :
5423 : // ********************************************************
5424 : // member functions common across all array grammar objects
5425 : // ********************************************************
5426 :
5427 :
5428 :
5429 : /* #line 5430 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5430 :
5431 :
5432 :
5433 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
5434 :
5435 : // ********************************************************
5436 : // member functions specific to each node in the grammar
5437 : // ********************************************************
5438 :
5439 :
5440 : /* #line 5441 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5441 :
5442 : // Start of memberFunctionString
5443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
5444 :
5445 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
5446 :
5447 : SgBitVector
5448 0 : SgSpecialFunctionModifier::get_modifierVector () const
5449 : {
5450 0 : ROSE_ASSERT (this != NULL);
5451 :
5452 : #if 0
5453 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5454 : // used to trigger marking transformations for the token-based unparsing.
5455 : printf ("SgSpecialFunctionModifier::get_modifierVector = %p = %s \n",this,this->class_name().c_str());
5456 : #endif
5457 :
5458 0 : return p_modifierVector;
5459 : }
5460 :
5461 : void
5462 0 : SgSpecialFunctionModifier::set_modifierVector ( SgBitVector modifierVector )
5463 : {
5464 0 : ROSE_ASSERT (this != NULL);
5465 :
5466 : #if 0
5467 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5468 : // used to trigger marking transformations for the token-based unparsing.
5469 : printf ("SgSpecialFunctionModifier::set_modifierVector = %p = %s \n",this,this->class_name().c_str());
5470 : #endif
5471 :
5472 0 : set_isModified(true);
5473 :
5474 0 : p_modifierVector = modifierVector;
5475 0 : }
5476 :
5477 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
5478 :
5479 :
5480 : // End of memberFunctionString
5481 : // Start of memberFunctionString
5482 : /* #line 3482 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
5483 :
5484 :
5485 : // Copy constructor
5486 5 : SgSpecialFunctionModifier::SgSpecialFunctionModifier ( const SgSpecialFunctionModifier & X )
5487 : {
5488 5 : p_modifierVector = X.p_modifierVector;
5489 5 : }
5490 :
5491 : SgSpecialFunctionModifier &
5492 13308 : SgSpecialFunctionModifier::operator= ( const SgSpecialFunctionModifier & X )
5493 : {
5494 13308 : p_modifierVector = X.p_modifierVector;
5495 13308 : return *this;
5496 : }
5497 :
5498 : void
5499 1194170 : SgSpecialFunctionModifier::post_construction_initialization()
5500 : {
5501 1194170 : p_modifierVector = SgBitVector(e_last_modifier,false);
5502 1194170 : setDefault();
5503 1194170 : }
5504 :
5505 697 : bool SgSpecialFunctionModifier::isUnknown() const { return checkBit(e_unknown,p_modifierVector); }
5506 0 : void SgSpecialFunctionModifier::setUnknown() { setBit(e_unknown,p_modifierVector); }
5507 0 : void SgSpecialFunctionModifier::unsetUnknown() { unsetBit(e_unknown,p_modifierVector); }
5508 :
5509 697 : bool SgSpecialFunctionModifier::isDefault() const { return checkBit(e_default,p_modifierVector); }
5510 2358400 : void SgSpecialFunctionModifier::setDefault() { setBit(e_default,p_modifierVector); }
5511 0 : void SgSpecialFunctionModifier::unsetDefault() { unsetBit(e_default,p_modifierVector); }
5512 :
5513 697 : bool SgSpecialFunctionModifier::isNotSpecial() const { return checkBit(e_none,p_modifierVector); }
5514 0 : void SgSpecialFunctionModifier::setNotSpecial() { setBit(e_none,p_modifierVector); }
5515 0 : void SgSpecialFunctionModifier::unsetNotSpecial() { unsetBit(e_none,p_modifierVector); }
5516 :
5517 20610 : bool SgSpecialFunctionModifier::isConstructor() const { return checkBit(e_constructor,p_modifierVector); }
5518 6855 : void SgSpecialFunctionModifier::setConstructor() { setBit(e_constructor,p_modifierVector); }
5519 0 : void SgSpecialFunctionModifier::unsetConstructor() { unsetBit(e_constructor,p_modifierVector); }
5520 :
5521 18851 : bool SgSpecialFunctionModifier::isDestructor() const { return checkBit(e_destructor,p_modifierVector); }
5522 1545 : void SgSpecialFunctionModifier::setDestructor() { setBit(e_destructor,p_modifierVector); }
5523 0 : void SgSpecialFunctionModifier::unsetDestructor() { unsetBit(e_destructor,p_modifierVector); }
5524 :
5525 16333 : bool SgSpecialFunctionModifier::isConversion() const { return checkBit(e_conversion,p_modifierVector); }
5526 220 : void SgSpecialFunctionModifier::setConversion() { setBit(e_conversion,p_modifierVector); }
5527 0 : void SgSpecialFunctionModifier::unsetConversion() { unsetBit(e_conversion,p_modifierVector); }
5528 :
5529 302190 : bool SgSpecialFunctionModifier::isOperator() const { return checkBit(e_operator,p_modifierVector); }
5530 10887 : void SgSpecialFunctionModifier::setOperator() { setBit(e_operator,p_modifierVector); }
5531 0 : void SgSpecialFunctionModifier::unsetOperator() { unsetBit(e_operator,p_modifierVector); }
5532 :
5533 2340 : bool SgSpecialFunctionModifier::isUldOperator() const { return checkBit(e_uld_operator,p_modifierVector); }
5534 64 : void SgSpecialFunctionModifier::setUldOperator() { setBit(e_uld_operator,p_modifierVector); }
5535 0 : void SgSpecialFunctionModifier::unsetUldOperator() { unsetBit(e_uld_operator,p_modifierVector); }
5536 :
5537 0 : bool SgSpecialFunctionModifier::isLambdaEntryPoint() const { return checkBit(e_lambda_entry_point,p_modifierVector); }
5538 0 : void SgSpecialFunctionModifier::setLambdaEntryPoint() { setBit(e_lambda_entry_point,p_modifierVector); }
5539 0 : void SgSpecialFunctionModifier::unsetLambdaEntryPoint() { unsetBit(e_lambda_entry_point,p_modifierVector); }
5540 :
5541 : string
5542 697 : SgSpecialFunctionModifier::displayString() const
5543 : {
5544 697 : std::string s = "SgSpecialFunctionModifier(";
5545 2788 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
5546 2091 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
5547 2091 : s += std::string("isNotSpecial() = ") + std::string(isNotSpecial() ? "true " : "false ");
5548 2664 : s += std::string("isConstructor() = ") + std::string(isConstructor() ? "true " : "false ");
5549 2752 : s += std::string("isDestructor() = ") + std::string(isDestructor() ? "true " : "false ");
5550 2788 : s += std::string("isConversion() = ") + std::string(isConversion() ? "true " : "false ");
5551 2678 : s += std::string("isOperator() = ") + std::string(isOperator() ? "true " : "false ");
5552 697 : s += ")";
5553 697 : return s;
5554 : }
5555 :
5556 : void
5557 0 : SgSpecialFunctionModifier::display ( std::string label ) const
5558 : {
5559 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
5560 0 : printf ("In SgSpecialFunctionModifier::display(%s) \n",label.c_str());
5561 0 : printf ("%s \n",displayString().c_str());
5562 0 : }
5563 :
5564 0 : std::ostream & operator<< ( std::ostream & os, const SgSpecialFunctionModifier & m)
5565 : {
5566 0 : os << m.get_modifierVector();
5567 0 : return os;
5568 : }
5569 :
5570 0 : bool operator== (const SgSpecialFunctionModifier& lhs, const SgSpecialFunctionModifier& rhs)
5571 : {
5572 0 : return
5573 0 : (lhs.isUnknown() == rhs.isUnknown() ) &&
5574 0 : (lhs.isDefault() == rhs.isDefault() ) &&
5575 0 : (lhs.isNotSpecial() == rhs.isNotSpecial() ) &&
5576 0 : (lhs.isConstructor() == rhs.isConstructor()) &&
5577 0 : (lhs.isDestructor() == rhs.isDestructor() ) &&
5578 0 : (lhs.isConversion() == rhs.isConversion() ) &&
5579 0 : (lhs.isOperator() == rhs.isOperator() ) &&
5580 0 : true;
5581 : }
5582 :
5583 : // DQ (2/4/2006): Added mechamism to clear all bits
5584 0 : void SgSpecialFunctionModifier::reset()
5585 : {
5586 0 : unsetUnknown();
5587 0 : unsetNotSpecial();
5588 0 : unsetConstructor();
5589 0 : unsetDestructor();
5590 0 : unsetConversion();
5591 0 : unsetOperator();
5592 :
5593 : // Set this bit to indicate the default value (we want a value of all zero bits to be an error)
5594 0 : setDefault();
5595 0 : }
5596 :
5597 :
5598 :
5599 : // End of memberFunctionString
5600 : // Start of memberFunctionString
5601 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
5602 :
5603 : // *** COMMON CODE SECTION BEGINS HERE ***
5604 :
5605 : #if 0
5606 : int
5607 : SgSpecialFunctionModifier::getVariant() const
5608 : {
5609 : // This function is used in ROSE while "variant()" is used in SAGE
5610 : assert(this != NULL);
5611 : return variant();
5612 : }
5613 : #endif
5614 :
5615 : // This function is used in ROSE in treeTraversal code
5616 : // eventually replaces getVariant() and variant()
5617 : // though after variant() has been removed for a while we will
5618 : // want to change the name of variantT() back to variant()
5619 : // (since the "T" was ment to stand for temporary).
5620 : // When this happens the variantT() will be depricated.
5621 : VariantT
5622 3582520 : SgSpecialFunctionModifier::variantT() const
5623 : {
5624 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
5625 3582520 : ROSE_ASSERT(this != NULL);
5626 3582520 : return V_SgSpecialFunctionModifier;
5627 : }
5628 :
5629 : #if 0
5630 : int
5631 : SgSpecialFunctionModifier::variant() const
5632 : {
5633 : // This function is used in SAGE
5634 : ROSE_ASSERT(this != NULL);
5635 : return SpecialFunctionModifierTag;
5636 : }
5637 : #endif
5638 :
5639 : ROSE_DLL_API const char*
5640 0 : SgSpecialFunctionModifier::sage_class_name() const
5641 : {
5642 0 : ROSE_ASSERT(this != NULL);
5643 0 : return "SgSpecialFunctionModifier";
5644 : }
5645 :
5646 : std::string
5647 0 : SgSpecialFunctionModifier::class_name() const
5648 : {
5649 0 : ROSE_ASSERT(this != NULL);
5650 0 : return "SgSpecialFunctionModifier";
5651 : }
5652 :
5653 : // DQ (11/26/2005): Support for visitor pattern mechanims
5654 : // (inferior to ROSE traversal mechanism, experimental).
5655 : void
5656 0 : SgSpecialFunctionModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
5657 : {
5658 0 : ROSE_ASSERT(this != NULL);
5659 0 : visitor.visit(this);
5660 0 : }
5661 :
5662 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
5663 0 : void SgSpecialFunctionModifier::accept (ROSE_VisitorPattern & visitor) {
5664 0 : ROSE_ASSERT(this != NULL);
5665 0 : visitor.visit(this);
5666 0 : }
5667 :
5668 : SgSpecialFunctionModifier*
5669 0 : SgSpecialFunctionModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
5670 : {
5671 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
5672 : // This function is currently only supported for the AST used the represent Binary executables.
5673 : if (0 /* isSgAsmNode(this) != NULL */)
5674 : {
5675 : // Support for regex specification.
5676 : std::string prefixCode = "REGEX:";
5677 : addNewAttribute(prefixCode + s,a);
5678 : }
5679 : #endif
5680 :
5681 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
5682 0 : return this;
5683 : }
5684 :
5685 : // *** COMMON CODE SECTION ENDS HERE ***
5686 :
5687 :
5688 : // End of memberFunctionString
5689 : // Start of memberFunctionString
5690 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
5691 :
5692 :
5693 : #if 0
5694 : //! Error checking support
5695 : /*! Verifies the following:
5696 : - working getVariant() member function
5697 : - calls base class's error() member function
5698 : Every class has one of these functions.
5699 : */
5700 : bool
5701 : SgSpecialFunctionModifier::error()
5702 : {
5703 : // Put error checking here
5704 :
5705 : ROSE_ASSERT (this != NULL);
5706 : if (getVariant() != SpecialFunctionModifierTag)
5707 : {
5708 : printf ("Error in SgSpecialFunctionModifier::error(): SgSpecialFunctionModifier object has a %s variant \n",
5709 : Cxx_GrammarTerminalNames[getVariant()].name);
5710 : // printf ("Error in SgSpecialFunctionModifier::error() \n");
5711 : ROSE_ABORT();
5712 : }
5713 :
5714 : ROSE_ASSERT (getVariant() == SpecialFunctionModifierTag);
5715 : return SgModifier::error();
5716 : }
5717 : #endif
5718 :
5719 :
5720 :
5721 : // End of memberFunctionString
5722 :
5723 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
5724 :
5725 1194170 : SgSpecialFunctionModifier* isSgSpecialFunctionModifier ( SgNode* inputDerivedClassPointer )
5726 : {
5727 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
5728 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
5729 : // So to fix this we return NULL directly when the input is NULL and avoid the
5730 : // dynamic_cast in this case. This is likely a performance improvement as well.
5731 : // return dynamic_cast<SgSpecialFunctionModifier*>(inputDerivedClassPointer);
5732 : // Milind Chabbi (8/28/2013): isSgSpecialFunctionModifier uses table-driven castability instead of c++ default dynamic_cast
5733 : // this improves the running time performance by 10-20%.
5734 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSpecialFunctionModifier*>(inputDerivedClassPointer);
5735 1194170 : return IS_SgSpecialFunctionModifier_FAST_MACRO(inputDerivedClassPointer);
5736 : }
5737 :
5738 : // DQ (11/8/2003): Added version of functions taking const pointer
5739 0 : const SgSpecialFunctionModifier* isSgSpecialFunctionModifier ( const SgNode* inputDerivedClassPointer )
5740 : {
5741 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
5742 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
5743 : // So to fix this we return NULL directly when the input is NULL and avoid the
5744 : // dynamic_cast in this case. This is likely a performance improvement as well.
5745 : // return dynamic_cast<const SgSpecialFunctionModifier*>(inputDerivedClassPointer);
5746 : // Milind Chabbi (8/28/2013): isSgSpecialFunctionModifier uses table-driven castability instead of c++ default dynamic_cast
5747 : // this improves the running time performance by 10-20%.
5748 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSpecialFunctionModifier*>(inputDerivedClassPointer);
5749 0 : return IS_SgSpecialFunctionModifier_FAST_MACRO(inputDerivedClassPointer);
5750 : }
5751 :
5752 :
5753 :
5754 : /* #line 5755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5755 :
5756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
5757 :
5758 : /**
5759 : \brief Generated destructor
5760 :
5761 : This destructor is automatically generated (by ROSETTA). This destructor
5762 : only frees memory of data members associated with the parts of the current IR node which
5763 : are NOT traversed. Those data members that are part of a traversal can be freed using
5764 : a traversal (calling this destructor on all children in a post-order traversal). Such
5765 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
5766 :
5767 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
5768 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
5769 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
5770 :
5771 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
5772 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
5773 : pointers are not yet implemented to call delete on eash pointer in the container.
5774 : (This could be done by derivation from the STL containers to define containers that
5775 : automatically deleted their members.)
5776 :
5777 : */
5778 39915 : SgSpecialFunctionModifier::~SgSpecialFunctionModifier () {
5779 39915 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
5780 :
5781 :
5782 :
5783 : }
5784 :
5785 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
5786 39915 : }
5787 :
5788 :
5789 : /* #line 5790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5790 :
5791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
5792 :
5793 : // Generated constructor
5794 1194170 : SgSpecialFunctionModifier::SgSpecialFunctionModifier ( )
5795 1194170 : : SgModifier()
5796 : {
5797 : #ifdef DEBUG
5798 : // printf ("In SgSpecialFunctionModifier::SgSpecialFunctionModifier () sage_class_name() = %s \n",sage_class_name());
5799 : #endif
5800 : #if 0
5801 : // debugging information!
5802 : printf ("In SgSpecialFunctionModifier::SgSpecialFunctionModifier (): this = %p = %s \n",this,this->class_name().c_str());
5803 : #endif
5804 :
5805 :
5806 :
5807 : #if 0
5808 : // DQ (7/30/2014): Call a virtual function.
5809 : std::string s = this->class_name();
5810 : #endif
5811 :
5812 : // Test the variant virtual function
5813 : // assert(SpecialFunctionModifierTag == variant());
5814 1194170 : assert(SpecialFunctionModifierTag == this->variant());
5815 1194170 : ROSE_ASSERT(SpecialFunctionModifierTag == (int)(this->variantT()));
5816 1194170 : post_construction_initialization();
5817 :
5818 : // Test the isSgSpecialFunctionModifier() function since it has been problematic
5819 1194170 : assert(isSgSpecialFunctionModifier(this) != NULL);
5820 1194170 : }
5821 :
5822 : // Generated constructor (all data members)
5823 :
5824 : /* #line 5825 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5825 :
5826 :
5827 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
5828 :
5829 :
5830 : // ********************************************************
5831 : // member functions common across all array grammar objects
5832 : // ********************************************************
5833 :
5834 :
5835 :
5836 : /* #line 5837 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5837 :
5838 :
5839 :
5840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
5841 :
5842 : // ********************************************************
5843 : // member functions specific to each node in the grammar
5844 : // ********************************************************
5845 :
5846 :
5847 : /* #line 5848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
5848 :
5849 : // Start of memberFunctionString
5850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
5851 :
5852 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
5853 :
5854 : SgElaboratedTypeModifier::elaborated_type_modifier_enum
5855 0 : SgElaboratedTypeModifier::get_modifier () const
5856 : {
5857 0 : ROSE_ASSERT (this != NULL);
5858 :
5859 : #if 0
5860 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5861 : // used to trigger marking transformations for the token-based unparsing.
5862 : printf ("SgElaboratedTypeModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
5863 : #endif
5864 :
5865 0 : return p_modifier;
5866 : }
5867 :
5868 : void
5869 0 : SgElaboratedTypeModifier::set_modifier ( SgElaboratedTypeModifier::elaborated_type_modifier_enum modifier )
5870 : {
5871 0 : ROSE_ASSERT (this != NULL);
5872 :
5873 : #if 0
5874 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
5875 : // used to trigger marking transformations for the token-based unparsing.
5876 : printf ("SgElaboratedTypeModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
5877 : #endif
5878 :
5879 0 : set_isModified(true);
5880 :
5881 0 : p_modifier = modifier;
5882 0 : }
5883 :
5884 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
5885 :
5886 :
5887 : // End of memberFunctionString
5888 : // Start of memberFunctionString
5889 : /* #line 4306 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
5890 :
5891 :
5892 : // Copy constructor
5893 0 : SgElaboratedTypeModifier::SgElaboratedTypeModifier ( const SgElaboratedTypeModifier & X )
5894 : {
5895 0 : p_modifier = X.p_modifier;
5896 0 : }
5897 :
5898 : SgElaboratedTypeModifier &
5899 163337 : SgElaboratedTypeModifier::operator= ( const SgElaboratedTypeModifier & X )
5900 : {
5901 163337 : p_modifier = X.p_modifier;
5902 163337 : return *this;
5903 : }
5904 :
5905 : void
5906 5130600 : SgElaboratedTypeModifier::post_construction_initialization()
5907 : {
5908 5130600 : p_modifier = e_default;
5909 5130600 : }
5910 :
5911 17049 : bool SgElaboratedTypeModifier::isUnknown() const { return p_modifier == e_unknown; }
5912 0 : void SgElaboratedTypeModifier::setUnknown() { p_modifier = e_unknown; }
5913 :
5914 17049 : bool SgElaboratedTypeModifier::isDefault() const { return p_modifier == e_default; }
5915 12815700 : void SgElaboratedTypeModifier::setDefault() { p_modifier = e_default; }
5916 :
5917 17049 : bool SgElaboratedTypeModifier::isClass() const { return p_modifier == e_class; }
5918 0 : void SgElaboratedTypeModifier::setClass() { p_modifier = e_class; }
5919 :
5920 17049 : bool SgElaboratedTypeModifier::isStruct() const { return p_modifier == e_struct; }
5921 0 : void SgElaboratedTypeModifier::setStruct() { p_modifier = e_struct; }
5922 :
5923 17049 : bool SgElaboratedTypeModifier::isUnion() const { return p_modifier == e_union; }
5924 0 : void SgElaboratedTypeModifier::setUnion() { p_modifier = e_union; }
5925 :
5926 17049 : bool SgElaboratedTypeModifier::isEnum() const { return p_modifier == e_enum; }
5927 0 : void SgElaboratedTypeModifier::setEnum() { p_modifier = e_enum; }
5928 :
5929 17049 : bool SgElaboratedTypeModifier::isTypename() const { return p_modifier == e_typename; }
5930 0 : void SgElaboratedTypeModifier::setTypename() { p_modifier = e_typename; }
5931 :
5932 : string
5933 6893 : SgElaboratedTypeModifier::displayString() const
5934 : {
5935 6893 : std::string s = "SgElaboratedTypeModifier(";
5936 27572 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
5937 20679 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
5938 27572 : s += std::string("isClass() = ") + std::string(isClass() ? "true " : "false ");
5939 27572 : s += std::string("isStruct() = ") + std::string(isStruct() ? "true " : "false ");
5940 27572 : s += std::string("isUnion() = ") + std::string(isUnion() ? "true " : "false ");
5941 27572 : s += std::string("isEnum() = ") + std::string(isEnum() ? "true " : "false ");
5942 27572 : s += std::string("isTypename() = ") + std::string(isTypename() ? "true " : "false ");
5943 6893 : s += ")";
5944 6893 : return s;
5945 : }
5946 :
5947 : void
5948 0 : SgElaboratedTypeModifier::display ( std::string label ) const
5949 : {
5950 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
5951 0 : printf ("In SgElaboratedTypeModifier::display(%s) \n",label.c_str());
5952 0 : printf ("%s \n",displayString().c_str());
5953 0 : }
5954 :
5955 0 : std::ostream & operator<< ( std::ostream & os, const SgElaboratedTypeModifier & m)
5956 : {
5957 0 : os << m.get_modifier();
5958 0 : return os;
5959 : }
5960 :
5961 5078 : bool operator== (const SgElaboratedTypeModifier& lhs, const SgElaboratedTypeModifier& rhs)
5962 : {
5963 5078 : return
5964 10156 : (lhs.isUnknown() == rhs.isUnknown() ) &&
5965 10156 : (lhs.isDefault() == rhs.isDefault() ) &&
5966 10156 : (lhs.isClass() == rhs.isClass() ) &&
5967 10156 : (lhs.isStruct() == rhs.isStruct() ) &&
5968 10156 : (lhs.isUnion() == rhs.isUnion() ) &&
5969 10156 : (lhs.isEnum() == rhs.isEnum() ) &&
5970 10156 : (lhs.isTypename() == rhs.isTypename()) &&
5971 5078 : true;
5972 : }
5973 :
5974 : // DQ (2/4/2006): Added mechamism to clear all bits
5975 12815700 : void SgElaboratedTypeModifier::reset()
5976 : {
5977 12815700 : setDefault();
5978 12815700 : }
5979 :
5980 :
5981 :
5982 : // End of memberFunctionString
5983 : // Start of memberFunctionString
5984 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
5985 :
5986 : // *** COMMON CODE SECTION BEGINS HERE ***
5987 :
5988 : #if 0
5989 : int
5990 : SgElaboratedTypeModifier::getVariant() const
5991 : {
5992 : // This function is used in ROSE while "variant()" is used in SAGE
5993 : assert(this != NULL);
5994 : return variant();
5995 : }
5996 : #endif
5997 :
5998 : // This function is used in ROSE in treeTraversal code
5999 : // eventually replaces getVariant() and variant()
6000 : // though after variant() has been removed for a while we will
6001 : // want to change the name of variantT() back to variant()
6002 : // (since the "T" was ment to stand for temporary).
6003 : // When this happens the variantT() will be depricated.
6004 : VariantT
6005 15391800 : SgElaboratedTypeModifier::variantT() const
6006 : {
6007 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
6008 15391800 : ROSE_ASSERT(this != NULL);
6009 15391800 : return V_SgElaboratedTypeModifier;
6010 : }
6011 :
6012 : #if 0
6013 : int
6014 : SgElaboratedTypeModifier::variant() const
6015 : {
6016 : // This function is used in SAGE
6017 : ROSE_ASSERT(this != NULL);
6018 : return ElaboratedTypeModifierTag;
6019 : }
6020 : #endif
6021 :
6022 : ROSE_DLL_API const char*
6023 0 : SgElaboratedTypeModifier::sage_class_name() const
6024 : {
6025 0 : ROSE_ASSERT(this != NULL);
6026 0 : return "SgElaboratedTypeModifier";
6027 : }
6028 :
6029 : std::string
6030 0 : SgElaboratedTypeModifier::class_name() const
6031 : {
6032 0 : ROSE_ASSERT(this != NULL);
6033 0 : return "SgElaboratedTypeModifier";
6034 : }
6035 :
6036 : // DQ (11/26/2005): Support for visitor pattern mechanims
6037 : // (inferior to ROSE traversal mechanism, experimental).
6038 : void
6039 0 : SgElaboratedTypeModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
6040 : {
6041 0 : ROSE_ASSERT(this != NULL);
6042 0 : visitor.visit(this);
6043 0 : }
6044 :
6045 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
6046 0 : void SgElaboratedTypeModifier::accept (ROSE_VisitorPattern & visitor) {
6047 0 : ROSE_ASSERT(this != NULL);
6048 0 : visitor.visit(this);
6049 0 : }
6050 :
6051 : SgElaboratedTypeModifier*
6052 0 : SgElaboratedTypeModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
6053 : {
6054 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
6055 : // This function is currently only supported for the AST used the represent Binary executables.
6056 : if (0 /* isSgAsmNode(this) != NULL */)
6057 : {
6058 : // Support for regex specification.
6059 : std::string prefixCode = "REGEX:";
6060 : addNewAttribute(prefixCode + s,a);
6061 : }
6062 : #endif
6063 :
6064 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
6065 0 : return this;
6066 : }
6067 :
6068 : // *** COMMON CODE SECTION ENDS HERE ***
6069 :
6070 :
6071 : // End of memberFunctionString
6072 : // Start of memberFunctionString
6073 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
6074 :
6075 :
6076 : #if 0
6077 : //! Error checking support
6078 : /*! Verifies the following:
6079 : - working getVariant() member function
6080 : - calls base class's error() member function
6081 : Every class has one of these functions.
6082 : */
6083 : bool
6084 : SgElaboratedTypeModifier::error()
6085 : {
6086 : // Put error checking here
6087 :
6088 : ROSE_ASSERT (this != NULL);
6089 : if (getVariant() != ElaboratedTypeModifierTag)
6090 : {
6091 : printf ("Error in SgElaboratedTypeModifier::error(): SgElaboratedTypeModifier object has a %s variant \n",
6092 : Cxx_GrammarTerminalNames[getVariant()].name);
6093 : // printf ("Error in SgElaboratedTypeModifier::error() \n");
6094 : ROSE_ABORT();
6095 : }
6096 :
6097 : ROSE_ASSERT (getVariant() == ElaboratedTypeModifierTag);
6098 : return SgModifier::error();
6099 : }
6100 : #endif
6101 :
6102 :
6103 :
6104 : // End of memberFunctionString
6105 :
6106 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
6107 :
6108 5130600 : SgElaboratedTypeModifier* isSgElaboratedTypeModifier ( SgNode* inputDerivedClassPointer )
6109 : {
6110 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
6111 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
6112 : // So to fix this we return NULL directly when the input is NULL and avoid the
6113 : // dynamic_cast in this case. This is likely a performance improvement as well.
6114 : // return dynamic_cast<SgElaboratedTypeModifier*>(inputDerivedClassPointer);
6115 : // Milind Chabbi (8/28/2013): isSgElaboratedTypeModifier uses table-driven castability instead of c++ default dynamic_cast
6116 : // this improves the running time performance by 10-20%.
6117 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElaboratedTypeModifier*>(inputDerivedClassPointer);
6118 5130600 : return IS_SgElaboratedTypeModifier_FAST_MACRO(inputDerivedClassPointer);
6119 : }
6120 :
6121 : // DQ (11/8/2003): Added version of functions taking const pointer
6122 0 : const SgElaboratedTypeModifier* isSgElaboratedTypeModifier ( const SgNode* inputDerivedClassPointer )
6123 : {
6124 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
6125 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
6126 : // So to fix this we return NULL directly when the input is NULL and avoid the
6127 : // dynamic_cast in this case. This is likely a performance improvement as well.
6128 : // return dynamic_cast<const SgElaboratedTypeModifier*>(inputDerivedClassPointer);
6129 : // Milind Chabbi (8/28/2013): isSgElaboratedTypeModifier uses table-driven castability instead of c++ default dynamic_cast
6130 : // this improves the running time performance by 10-20%.
6131 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElaboratedTypeModifier*>(inputDerivedClassPointer);
6132 0 : return IS_SgElaboratedTypeModifier_FAST_MACRO(inputDerivedClassPointer);
6133 : }
6134 :
6135 :
6136 :
6137 : /* #line 6138 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6138 :
6139 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
6140 :
6141 : /**
6142 : \brief Generated destructor
6143 :
6144 : This destructor is automatically generated (by ROSETTA). This destructor
6145 : only frees memory of data members associated with the parts of the current IR node which
6146 : are NOT traversed. Those data members that are part of a traversal can be freed using
6147 : a traversal (calling this destructor on all children in a post-order traversal). Such
6148 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
6149 :
6150 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
6151 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
6152 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
6153 :
6154 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
6155 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
6156 : pointers are not yet implemented to call delete on eash pointer in the container.
6157 : (This could be done by derivation from the STL containers to define containers that
6158 : automatically deleted their members.)
6159 :
6160 : */
6161 1453340 : SgElaboratedTypeModifier::~SgElaboratedTypeModifier () {
6162 1453340 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
6163 :
6164 :
6165 : // case: not a listType for modifier
6166 1453340 : p_modifier = SgElaboratedTypeModifier::e_unknown; // non list case
6167 :
6168 : }
6169 :
6170 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
6171 1453340 : }
6172 :
6173 :
6174 : /* #line 6175 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6175 :
6176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
6177 :
6178 : // Generated constructor
6179 5130600 : SgElaboratedTypeModifier::SgElaboratedTypeModifier ( )
6180 5130600 : : SgModifier()
6181 : {
6182 : #ifdef DEBUG
6183 : // printf ("In SgElaboratedTypeModifier::SgElaboratedTypeModifier () sage_class_name() = %s \n",sage_class_name());
6184 : #endif
6185 : #if 0
6186 : // debugging information!
6187 : printf ("In SgElaboratedTypeModifier::SgElaboratedTypeModifier (): this = %p = %s \n",this,this->class_name().c_str());
6188 : #endif
6189 :
6190 5130600 : p_modifier = SgElaboratedTypeModifier::e_unknown;
6191 :
6192 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
6193 :
6194 : #if 0
6195 : // DQ (7/30/2014): Call a virtual function.
6196 : std::string s = this->class_name();
6197 : #endif
6198 :
6199 : // Test the variant virtual function
6200 : // assert(ElaboratedTypeModifierTag == variant());
6201 5130600 : assert(ElaboratedTypeModifierTag == this->variant());
6202 5130600 : ROSE_ASSERT(ElaboratedTypeModifierTag == (int)(this->variantT()));
6203 5130600 : post_construction_initialization();
6204 :
6205 : // Test the isSgElaboratedTypeModifier() function since it has been problematic
6206 5130600 : assert(isSgElaboratedTypeModifier(this) != NULL);
6207 5130600 : }
6208 :
6209 : // Generated constructor (all data members)
6210 :
6211 : /* #line 6212 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6212 :
6213 :
6214 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
6215 :
6216 :
6217 : // ********************************************************
6218 : // member functions common across all array grammar objects
6219 : // ********************************************************
6220 :
6221 :
6222 :
6223 : /* #line 6224 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6224 :
6225 :
6226 :
6227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
6228 :
6229 : // ********************************************************
6230 : // member functions specific to each node in the grammar
6231 : // ********************************************************
6232 :
6233 :
6234 : /* #line 6235 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6235 :
6236 : // Start of memberFunctionString
6237 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
6238 :
6239 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
6240 :
6241 : SgLinkageModifier::linkage_modifier_enum
6242 0 : SgLinkageModifier::get_modifier () const
6243 : {
6244 0 : ROSE_ASSERT (this != NULL);
6245 :
6246 : #if 0
6247 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
6248 : // used to trigger marking transformations for the token-based unparsing.
6249 : printf ("SgLinkageModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
6250 : #endif
6251 :
6252 0 : return p_modifier;
6253 : }
6254 :
6255 : void
6256 0 : SgLinkageModifier::set_modifier ( SgLinkageModifier::linkage_modifier_enum modifier )
6257 : {
6258 0 : ROSE_ASSERT (this != NULL);
6259 :
6260 : #if 0
6261 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
6262 : // used to trigger marking transformations for the token-based unparsing.
6263 : printf ("SgLinkageModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
6264 : #endif
6265 :
6266 0 : set_isModified(true);
6267 :
6268 0 : p_modifier = modifier;
6269 0 : }
6270 :
6271 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
6272 :
6273 :
6274 : // End of memberFunctionString
6275 : // Start of memberFunctionString
6276 : /* #line 4398 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
6277 :
6278 :
6279 : // Copy constructor
6280 0 : SgLinkageModifier::SgLinkageModifier ( const SgLinkageModifier & X )
6281 : {
6282 0 : p_modifier = X.p_modifier;
6283 0 : }
6284 :
6285 : SgLinkageModifier &
6286 0 : SgLinkageModifier::operator= ( const SgLinkageModifier & X )
6287 : {
6288 0 : p_modifier = X.p_modifier;
6289 0 : return *this;
6290 : }
6291 :
6292 : void
6293 0 : SgLinkageModifier::post_construction_initialization()
6294 : {
6295 0 : p_modifier = e_default;
6296 0 : }
6297 :
6298 0 : bool SgLinkageModifier::isUnknown() const { return p_modifier == e_unknown; }
6299 0 : void SgLinkageModifier::setUnknown() { p_modifier = e_unknown; }
6300 :
6301 0 : bool SgLinkageModifier::isDefault() const { return p_modifier == e_default; }
6302 0 : void SgLinkageModifier::setDefault() { p_modifier = e_default; }
6303 :
6304 0 : bool SgLinkageModifier::isC_Linkage() const { return p_modifier == e_C_linkage; }
6305 0 : void SgLinkageModifier::setC_Linkage() { p_modifier = e_C_linkage; }
6306 :
6307 0 : bool SgLinkageModifier::isCppLinkage() const { return p_modifier == e_Cpp_linkage; }
6308 0 : void SgLinkageModifier::setCppLinkage() { p_modifier = e_Cpp_linkage; }
6309 :
6310 0 : bool SgLinkageModifier::isFortranLinkage() const { return p_modifier == e_fortran_linkage; }
6311 0 : void SgLinkageModifier::setFortranLinkage() { p_modifier = e_fortran_linkage; }
6312 :
6313 : string
6314 0 : SgLinkageModifier::displayString() const
6315 : {
6316 0 : std::string s = "SgLinkageModifier(";
6317 0 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
6318 0 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
6319 0 : s += std::string("isC_Linkage() = ") + std::string(isC_Linkage() ? "true " : "false ");
6320 0 : s += std::string("isCppLinkage() = ") + std::string(isCppLinkage() ? "true " : "false ");
6321 0 : s += std::string("isFortranLinkage() = ") + std::string(isFortranLinkage() ? "true " : "false ");
6322 0 : s += ")";
6323 0 : return s;
6324 : }
6325 :
6326 : void
6327 0 : SgLinkageModifier::display ( std::string label ) const
6328 : {
6329 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
6330 0 : printf ("In SgLinkageModifier::display(%s) \n",label.c_str());
6331 0 : printf ("%s \n",displayString().c_str());
6332 0 : }
6333 :
6334 0 : std::ostream & operator<< ( std::ostream & os, const SgLinkageModifier & m)
6335 : {
6336 0 : os << m.get_modifier();
6337 0 : return os;
6338 : }
6339 :
6340 0 : bool operator== (const SgLinkageModifier& lhs, const SgLinkageModifier& rhs)
6341 : {
6342 0 : return
6343 0 : (lhs.isUnknown() == rhs.isUnknown() ) &&
6344 0 : (lhs.isDefault() == rhs.isDefault() ) &&
6345 0 : (lhs.isC_Linkage() == rhs.isC_Linkage() ) &&
6346 0 : (lhs.isCppLinkage() == rhs.isCppLinkage() ) &&
6347 0 : (lhs.isFortranLinkage() == rhs.isFortranLinkage()) &&
6348 0 : true;
6349 : }
6350 :
6351 : // DQ (2/4/2006): Added mechamism to clear all bits
6352 0 : void SgLinkageModifier::reset()
6353 : {
6354 0 : setDefault();
6355 0 : }
6356 :
6357 :
6358 :
6359 : // End of memberFunctionString
6360 : // Start of memberFunctionString
6361 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
6362 :
6363 : // *** COMMON CODE SECTION BEGINS HERE ***
6364 :
6365 : #if 0
6366 : int
6367 : SgLinkageModifier::getVariant() const
6368 : {
6369 : // This function is used in ROSE while "variant()" is used in SAGE
6370 : assert(this != NULL);
6371 : return variant();
6372 : }
6373 : #endif
6374 :
6375 : // This function is used in ROSE in treeTraversal code
6376 : // eventually replaces getVariant() and variant()
6377 : // though after variant() has been removed for a while we will
6378 : // want to change the name of variantT() back to variant()
6379 : // (since the "T" was ment to stand for temporary).
6380 : // When this happens the variantT() will be depricated.
6381 : VariantT
6382 0 : SgLinkageModifier::variantT() const
6383 : {
6384 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
6385 0 : ROSE_ASSERT(this != NULL);
6386 0 : return V_SgLinkageModifier;
6387 : }
6388 :
6389 : #if 0
6390 : int
6391 : SgLinkageModifier::variant() const
6392 : {
6393 : // This function is used in SAGE
6394 : ROSE_ASSERT(this != NULL);
6395 : return LinkageModifierTag;
6396 : }
6397 : #endif
6398 :
6399 : ROSE_DLL_API const char*
6400 0 : SgLinkageModifier::sage_class_name() const
6401 : {
6402 0 : ROSE_ASSERT(this != NULL);
6403 0 : return "SgLinkageModifier";
6404 : }
6405 :
6406 : std::string
6407 0 : SgLinkageModifier::class_name() const
6408 : {
6409 0 : ROSE_ASSERT(this != NULL);
6410 0 : return "SgLinkageModifier";
6411 : }
6412 :
6413 : // DQ (11/26/2005): Support for visitor pattern mechanims
6414 : // (inferior to ROSE traversal mechanism, experimental).
6415 : void
6416 0 : SgLinkageModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
6417 : {
6418 0 : ROSE_ASSERT(this != NULL);
6419 0 : visitor.visit(this);
6420 0 : }
6421 :
6422 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
6423 0 : void SgLinkageModifier::accept (ROSE_VisitorPattern & visitor) {
6424 0 : ROSE_ASSERT(this != NULL);
6425 0 : visitor.visit(this);
6426 0 : }
6427 :
6428 : SgLinkageModifier*
6429 0 : SgLinkageModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
6430 : {
6431 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
6432 : // This function is currently only supported for the AST used the represent Binary executables.
6433 : if (0 /* isSgAsmNode(this) != NULL */)
6434 : {
6435 : // Support for regex specification.
6436 : std::string prefixCode = "REGEX:";
6437 : addNewAttribute(prefixCode + s,a);
6438 : }
6439 : #endif
6440 :
6441 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
6442 0 : return this;
6443 : }
6444 :
6445 : // *** COMMON CODE SECTION ENDS HERE ***
6446 :
6447 :
6448 : // End of memberFunctionString
6449 : // Start of memberFunctionString
6450 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
6451 :
6452 :
6453 : #if 0
6454 : //! Error checking support
6455 : /*! Verifies the following:
6456 : - working getVariant() member function
6457 : - calls base class's error() member function
6458 : Every class has one of these functions.
6459 : */
6460 : bool
6461 : SgLinkageModifier::error()
6462 : {
6463 : // Put error checking here
6464 :
6465 : ROSE_ASSERT (this != NULL);
6466 : if (getVariant() != LinkageModifierTag)
6467 : {
6468 : printf ("Error in SgLinkageModifier::error(): SgLinkageModifier object has a %s variant \n",
6469 : Cxx_GrammarTerminalNames[getVariant()].name);
6470 : // printf ("Error in SgLinkageModifier::error() \n");
6471 : ROSE_ABORT();
6472 : }
6473 :
6474 : ROSE_ASSERT (getVariant() == LinkageModifierTag);
6475 : return SgModifier::error();
6476 : }
6477 : #endif
6478 :
6479 :
6480 :
6481 : // End of memberFunctionString
6482 :
6483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
6484 :
6485 0 : SgLinkageModifier* isSgLinkageModifier ( SgNode* inputDerivedClassPointer )
6486 : {
6487 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
6488 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
6489 : // So to fix this we return NULL directly when the input is NULL and avoid the
6490 : // dynamic_cast in this case. This is likely a performance improvement as well.
6491 : // return dynamic_cast<SgLinkageModifier*>(inputDerivedClassPointer);
6492 : // Milind Chabbi (8/28/2013): isSgLinkageModifier uses table-driven castability instead of c++ default dynamic_cast
6493 : // this improves the running time performance by 10-20%.
6494 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLinkageModifier*>(inputDerivedClassPointer);
6495 0 : return IS_SgLinkageModifier_FAST_MACRO(inputDerivedClassPointer);
6496 : }
6497 :
6498 : // DQ (11/8/2003): Added version of functions taking const pointer
6499 0 : const SgLinkageModifier* isSgLinkageModifier ( const SgNode* inputDerivedClassPointer )
6500 : {
6501 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
6502 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
6503 : // So to fix this we return NULL directly when the input is NULL and avoid the
6504 : // dynamic_cast in this case. This is likely a performance improvement as well.
6505 : // return dynamic_cast<const SgLinkageModifier*>(inputDerivedClassPointer);
6506 : // Milind Chabbi (8/28/2013): isSgLinkageModifier uses table-driven castability instead of c++ default dynamic_cast
6507 : // this improves the running time performance by 10-20%.
6508 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLinkageModifier*>(inputDerivedClassPointer);
6509 0 : return IS_SgLinkageModifier_FAST_MACRO(inputDerivedClassPointer);
6510 : }
6511 :
6512 :
6513 :
6514 : /* #line 6515 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6515 :
6516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
6517 :
6518 : /**
6519 : \brief Generated destructor
6520 :
6521 : This destructor is automatically generated (by ROSETTA). This destructor
6522 : only frees memory of data members associated with the parts of the current IR node which
6523 : are NOT traversed. Those data members that are part of a traversal can be freed using
6524 : a traversal (calling this destructor on all children in a post-order traversal). Such
6525 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
6526 :
6527 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
6528 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
6529 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
6530 :
6531 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
6532 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
6533 : pointers are not yet implemented to call delete on eash pointer in the container.
6534 : (This could be done by derivation from the STL containers to define containers that
6535 : automatically deleted their members.)
6536 :
6537 : */
6538 0 : SgLinkageModifier::~SgLinkageModifier () {
6539 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
6540 :
6541 :
6542 : // case: not a listType for modifier
6543 0 : p_modifier = SgLinkageModifier::e_unknown; // non list case
6544 :
6545 : }
6546 :
6547 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
6548 0 : }
6549 :
6550 :
6551 : /* #line 6552 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6552 :
6553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
6554 :
6555 : // Generated constructor
6556 0 : SgLinkageModifier::SgLinkageModifier ( )
6557 0 : : SgModifier()
6558 : {
6559 : #ifdef DEBUG
6560 : // printf ("In SgLinkageModifier::SgLinkageModifier () sage_class_name() = %s \n",sage_class_name());
6561 : #endif
6562 : #if 0
6563 : // debugging information!
6564 : printf ("In SgLinkageModifier::SgLinkageModifier (): this = %p = %s \n",this,this->class_name().c_str());
6565 : #endif
6566 :
6567 0 : p_modifier = SgLinkageModifier::e_unknown;
6568 :
6569 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
6570 :
6571 : #if 0
6572 : // DQ (7/30/2014): Call a virtual function.
6573 : std::string s = this->class_name();
6574 : #endif
6575 :
6576 : // Test the variant virtual function
6577 : // assert(LinkageModifierTag == variant());
6578 0 : assert(LinkageModifierTag == this->variant());
6579 0 : ROSE_ASSERT(LinkageModifierTag == (int)(this->variantT()));
6580 0 : post_construction_initialization();
6581 :
6582 : // Test the isSgLinkageModifier() function since it has been problematic
6583 0 : assert(isSgLinkageModifier(this) != NULL);
6584 0 : }
6585 :
6586 : // Generated constructor (all data members)
6587 :
6588 : /* #line 6589 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6589 :
6590 :
6591 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
6592 :
6593 :
6594 : // ********************************************************
6595 : // member functions common across all array grammar objects
6596 : // ********************************************************
6597 :
6598 :
6599 :
6600 : /* #line 6601 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6601 :
6602 :
6603 :
6604 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
6605 :
6606 : // ********************************************************
6607 : // member functions specific to each node in the grammar
6608 : // ********************************************************
6609 :
6610 :
6611 : /* #line 6612 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6612 :
6613 : // Start of memberFunctionString
6614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
6615 :
6616 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
6617 :
6618 : SgBaseClassModifier::baseclass_modifier_enum
6619 0 : SgBaseClassModifier::get_modifier () const
6620 : {
6621 0 : ROSE_ASSERT (this != NULL);
6622 :
6623 : #if 0
6624 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
6625 : // used to trigger marking transformations for the token-based unparsing.
6626 : printf ("SgBaseClassModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
6627 : #endif
6628 :
6629 0 : return p_modifier;
6630 : }
6631 :
6632 : void
6633 0 : SgBaseClassModifier::set_modifier ( SgBaseClassModifier::baseclass_modifier_enum modifier )
6634 : {
6635 0 : ROSE_ASSERT (this != NULL);
6636 :
6637 : #if 0
6638 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
6639 : // used to trigger marking transformations for the token-based unparsing.
6640 : printf ("SgBaseClassModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
6641 : #endif
6642 :
6643 0 : set_isModified(true);
6644 :
6645 0 : p_modifier = modifier;
6646 0 : }
6647 :
6648 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
6649 :
6650 :
6651 : // End of memberFunctionString
6652 : // Start of memberFunctionString
6653 :
6654 :
6655 : // End of memberFunctionString
6656 : // Start of memberFunctionString
6657 : /* #line 4480 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
6658 :
6659 :
6660 : // Copy constructor
6661 0 : SgBaseClassModifier::SgBaseClassModifier ( const SgBaseClassModifier & X )
6662 : {
6663 0 : p_modifier = X.p_modifier;
6664 0 : p_accessModifier = X.p_accessModifier;
6665 0 : }
6666 :
6667 : SgBaseClassModifier &
6668 0 : SgBaseClassModifier::operator= ( const SgBaseClassModifier & X )
6669 : {
6670 0 : p_modifier = X.p_modifier;
6671 0 : p_accessModifier = X.p_accessModifier;
6672 0 : return *this;
6673 : }
6674 :
6675 : void
6676 5725 : SgBaseClassModifier::post_construction_initialization()
6677 : {
6678 5725 : p_modifier = e_default;
6679 5725 : }
6680 :
6681 0 : bool SgBaseClassModifier::isUnknown() const { return p_modifier == e_unknown; }
6682 0 : void SgBaseClassModifier::setUnknown() { p_modifier = e_unknown; }
6683 :
6684 0 : bool SgBaseClassModifier::isDefault() const { return p_modifier == e_default; }
6685 0 : void SgBaseClassModifier::setDefault() { p_modifier = e_default; }
6686 :
6687 359 : bool SgBaseClassModifier::isVirtual() const { return p_modifier == e_virtual; }
6688 48 : void SgBaseClassModifier::setVirtual() { p_modifier = e_virtual; }
6689 :
6690 : string
6691 0 : SgBaseClassModifier::displayString() const
6692 : {
6693 0 : std::string s = "SgBaseClassModifier(";
6694 0 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
6695 0 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
6696 0 : s += std::string("isVirtual() = ") + std::string(isVirtual() ? "true " : "false ");
6697 0 : s += std::string("\n ") + get_accessModifier().displayString();
6698 0 : s += ")";
6699 0 : return s;
6700 : }
6701 :
6702 : void
6703 0 : SgBaseClassModifier::display ( std::string label ) const
6704 : {
6705 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
6706 0 : printf ("In SgBaseClassModifier::display(%s) \n",label.c_str());
6707 0 : printf ("%s \n",displayString().c_str());
6708 0 : }
6709 :
6710 0 : std::ostream & operator<< ( std::ostream & os, const SgBaseClassModifier & m)
6711 : {
6712 0 : os << m.get_modifier();
6713 0 : return os;
6714 : }
6715 :
6716 0 : bool operator== (const SgBaseClassModifier& lhs, const SgBaseClassModifier& rhs)
6717 : {
6718 0 : return
6719 0 : (lhs.get_accessModifier() == rhs.get_accessModifier()) &&
6720 0 : (lhs.isUnknown() == rhs.isUnknown()) &&
6721 0 : (lhs.isDefault() == rhs.isDefault()) &&
6722 0 : (lhs.isVirtual() == rhs.isVirtual()) &&
6723 0 : true;
6724 : }
6725 :
6726 : SgAccessModifier &
6727 20196 : SgBaseClassModifier::get_accessModifier ()
6728 : {
6729 20196 : ROSE_ASSERT (this != NULL);
6730 20196 : return p_accessModifier;
6731 : }
6732 :
6733 : const SgAccessModifier &
6734 0 : SgBaseClassModifier::get_accessModifier () const
6735 : {
6736 0 : ROSE_ASSERT (this != NULL);
6737 0 : return p_accessModifier;
6738 : }
6739 :
6740 : // DQ (2/4/2006): Added mechamism to clear all bits
6741 0 : void SgBaseClassModifier::reset()
6742 : {
6743 0 : setDefault();
6744 0 : get_accessModifier().reset();
6745 0 : }
6746 :
6747 :
6748 :
6749 : // End of memberFunctionString
6750 : // Start of memberFunctionString
6751 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
6752 :
6753 : // *** COMMON CODE SECTION BEGINS HERE ***
6754 :
6755 : #if 0
6756 : int
6757 : SgBaseClassModifier::getVariant() const
6758 : {
6759 : // This function is used in ROSE while "variant()" is used in SAGE
6760 : assert(this != NULL);
6761 : return variant();
6762 : }
6763 : #endif
6764 :
6765 : // This function is used in ROSE in treeTraversal code
6766 : // eventually replaces getVariant() and variant()
6767 : // though after variant() has been removed for a while we will
6768 : // want to change the name of variantT() back to variant()
6769 : // (since the "T" was ment to stand for temporary).
6770 : // When this happens the variantT() will be depricated.
6771 : VariantT
6772 173621 : SgBaseClassModifier::variantT() const
6773 : {
6774 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
6775 173621 : ROSE_ASSERT(this != NULL);
6776 173621 : return V_SgBaseClassModifier;
6777 : }
6778 :
6779 : #if 0
6780 : int
6781 : SgBaseClassModifier::variant() const
6782 : {
6783 : // This function is used in SAGE
6784 : ROSE_ASSERT(this != NULL);
6785 : return BaseClassModifierTag;
6786 : }
6787 : #endif
6788 :
6789 : ROSE_DLL_API const char*
6790 0 : SgBaseClassModifier::sage_class_name() const
6791 : {
6792 0 : ROSE_ASSERT(this != NULL);
6793 0 : return "SgBaseClassModifier";
6794 : }
6795 :
6796 : std::string
6797 4084 : SgBaseClassModifier::class_name() const
6798 : {
6799 4084 : ROSE_ASSERT(this != NULL);
6800 4084 : return "SgBaseClassModifier";
6801 : }
6802 :
6803 : // DQ (11/26/2005): Support for visitor pattern mechanims
6804 : // (inferior to ROSE traversal mechanism, experimental).
6805 : void
6806 85560 : SgBaseClassModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
6807 : {
6808 85560 : ROSE_ASSERT(this != NULL);
6809 85560 : visitor.visit(this);
6810 85560 : }
6811 :
6812 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
6813 0 : void SgBaseClassModifier::accept (ROSE_VisitorPattern & visitor) {
6814 0 : ROSE_ASSERT(this != NULL);
6815 0 : visitor.visit(this);
6816 0 : }
6817 :
6818 : SgBaseClassModifier*
6819 0 : SgBaseClassModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
6820 : {
6821 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
6822 : // This function is currently only supported for the AST used the represent Binary executables.
6823 : if (0 /* isSgAsmNode(this) != NULL */)
6824 : {
6825 : // Support for regex specification.
6826 : std::string prefixCode = "REGEX:";
6827 : addNewAttribute(prefixCode + s,a);
6828 : }
6829 : #endif
6830 :
6831 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
6832 0 : return this;
6833 : }
6834 :
6835 : // *** COMMON CODE SECTION ENDS HERE ***
6836 :
6837 :
6838 : // End of memberFunctionString
6839 : // Start of memberFunctionString
6840 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
6841 :
6842 :
6843 : #if 0
6844 : //! Error checking support
6845 : /*! Verifies the following:
6846 : - working getVariant() member function
6847 : - calls base class's error() member function
6848 : Every class has one of these functions.
6849 : */
6850 : bool
6851 : SgBaseClassModifier::error()
6852 : {
6853 : // Put error checking here
6854 :
6855 : ROSE_ASSERT (this != NULL);
6856 : if (getVariant() != BaseClassModifierTag)
6857 : {
6858 : printf ("Error in SgBaseClassModifier::error(): SgBaseClassModifier object has a %s variant \n",
6859 : Cxx_GrammarTerminalNames[getVariant()].name);
6860 : // printf ("Error in SgBaseClassModifier::error() \n");
6861 : ROSE_ABORT();
6862 : }
6863 :
6864 : ROSE_ASSERT (getVariant() == BaseClassModifierTag);
6865 : return SgModifier::error();
6866 : }
6867 : #endif
6868 :
6869 :
6870 :
6871 : // End of memberFunctionString
6872 :
6873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
6874 :
6875 5725 : SgBaseClassModifier* isSgBaseClassModifier ( SgNode* inputDerivedClassPointer )
6876 : {
6877 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
6878 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
6879 : // So to fix this we return NULL directly when the input is NULL and avoid the
6880 : // dynamic_cast in this case. This is likely a performance improvement as well.
6881 : // return dynamic_cast<SgBaseClassModifier*>(inputDerivedClassPointer);
6882 : // Milind Chabbi (8/28/2013): isSgBaseClassModifier uses table-driven castability instead of c++ default dynamic_cast
6883 : // this improves the running time performance by 10-20%.
6884 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBaseClassModifier*>(inputDerivedClassPointer);
6885 5725 : return IS_SgBaseClassModifier_FAST_MACRO(inputDerivedClassPointer);
6886 : }
6887 :
6888 : // DQ (11/8/2003): Added version of functions taking const pointer
6889 0 : const SgBaseClassModifier* isSgBaseClassModifier ( const SgNode* inputDerivedClassPointer )
6890 : {
6891 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
6892 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
6893 : // So to fix this we return NULL directly when the input is NULL and avoid the
6894 : // dynamic_cast in this case. This is likely a performance improvement as well.
6895 : // return dynamic_cast<const SgBaseClassModifier*>(inputDerivedClassPointer);
6896 : // Milind Chabbi (8/28/2013): isSgBaseClassModifier uses table-driven castability instead of c++ default dynamic_cast
6897 : // this improves the running time performance by 10-20%.
6898 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBaseClassModifier*>(inputDerivedClassPointer);
6899 0 : return IS_SgBaseClassModifier_FAST_MACRO(inputDerivedClassPointer);
6900 : }
6901 :
6902 :
6903 :
6904 : /* #line 6905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6905 :
6906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
6907 :
6908 : /**
6909 : \brief Generated destructor
6910 :
6911 : This destructor is automatically generated (by ROSETTA). This destructor
6912 : only frees memory of data members associated with the parts of the current IR node which
6913 : are NOT traversed. Those data members that are part of a traversal can be freed using
6914 : a traversal (calling this destructor on all children in a post-order traversal). Such
6915 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
6916 :
6917 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
6918 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
6919 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
6920 :
6921 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
6922 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
6923 : pointers are not yet implemented to call delete on eash pointer in the container.
6924 : (This could be done by derivation from the STL containers to define containers that
6925 : automatically deleted their members.)
6926 :
6927 : */
6928 2480 : SgBaseClassModifier::~SgBaseClassModifier () {
6929 1240 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
6930 :
6931 :
6932 : // case: not a listType for modifier
6933 1240 : p_modifier = SgBaseClassModifier::e_unknown; // non list case
6934 :
6935 : }
6936 :
6937 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
6938 2480 : }
6939 :
6940 :
6941 : /* #line 6942 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6942 :
6943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
6944 :
6945 : // Generated constructor
6946 5725 : SgBaseClassModifier::SgBaseClassModifier ( )
6947 5725 : : SgModifier()
6948 : {
6949 : #ifdef DEBUG
6950 : // printf ("In SgBaseClassModifier::SgBaseClassModifier () sage_class_name() = %s \n",sage_class_name());
6951 : #endif
6952 : #if 0
6953 : // debugging information!
6954 : printf ("In SgBaseClassModifier::SgBaseClassModifier (): this = %p = %s \n",this,this->class_name().c_str());
6955 : #endif
6956 :
6957 5725 : p_modifier = SgBaseClassModifier::e_unknown;
6958 :
6959 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
6960 :
6961 : #if 0
6962 : // DQ (7/30/2014): Call a virtual function.
6963 : std::string s = this->class_name();
6964 : #endif
6965 :
6966 : // Test the variant virtual function
6967 : // assert(BaseClassModifierTag == variant());
6968 5725 : assert(BaseClassModifierTag == this->variant());
6969 5725 : ROSE_ASSERT(BaseClassModifierTag == (int)(this->variantT()));
6970 5725 : post_construction_initialization();
6971 :
6972 : // Test the isSgBaseClassModifier() function since it has been problematic
6973 5725 : assert(isSgBaseClassModifier(this) != NULL);
6974 5725 : }
6975 :
6976 : // Generated constructor (all data members)
6977 :
6978 : /* #line 6979 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6979 :
6980 :
6981 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
6982 :
6983 :
6984 : // ********************************************************
6985 : // member functions common across all array grammar objects
6986 : // ********************************************************
6987 :
6988 :
6989 :
6990 : /* #line 6991 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
6991 :
6992 :
6993 :
6994 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
6995 :
6996 : // ********************************************************
6997 : // member functions specific to each node in the grammar
6998 : // ********************************************************
6999 :
7000 :
7001 : /* #line 7002 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
7002 :
7003 : // Start of memberFunctionString
7004 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7005 :
7006 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7007 :
7008 : SgStructureModifier::jovial_structure_modifier_enum
7009 0 : SgStructureModifier::get_modifier () const
7010 : {
7011 0 : ROSE_ASSERT (this != NULL);
7012 :
7013 : #if 0
7014 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7015 : // used to trigger marking transformations for the token-based unparsing.
7016 : printf ("SgStructureModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
7017 : #endif
7018 :
7019 0 : return p_modifier;
7020 : }
7021 :
7022 : void
7023 0 : SgStructureModifier::set_modifier ( SgStructureModifier::jovial_structure_modifier_enum modifier )
7024 : {
7025 0 : ROSE_ASSERT (this != NULL);
7026 :
7027 : #if 0
7028 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7029 : // used to trigger marking transformations for the token-based unparsing.
7030 : printf ("SgStructureModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
7031 : #endif
7032 :
7033 0 : set_isModified(true);
7034 :
7035 0 : p_modifier = modifier;
7036 0 : }
7037 :
7038 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7039 :
7040 :
7041 : // End of memberFunctionString
7042 : // Start of memberFunctionString
7043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7044 :
7045 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7046 :
7047 : int
7048 0 : SgStructureModifier::get_bits_per_entry () const
7049 : {
7050 0 : ROSE_ASSERT (this != NULL);
7051 :
7052 : #if 0
7053 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7054 : // used to trigger marking transformations for the token-based unparsing.
7055 : printf ("SgStructureModifier::get_bits_per_entry = %p = %s \n",this,this->class_name().c_str());
7056 : #endif
7057 :
7058 0 : return p_bits_per_entry;
7059 : }
7060 :
7061 : void
7062 0 : SgStructureModifier::set_bits_per_entry ( int bits_per_entry )
7063 : {
7064 0 : ROSE_ASSERT (this != NULL);
7065 :
7066 : #if 0
7067 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7068 : // used to trigger marking transformations for the token-based unparsing.
7069 : printf ("SgStructureModifier::set_bits_per_entry = %p = %s \n",this,this->class_name().c_str());
7070 : #endif
7071 :
7072 0 : set_isModified(true);
7073 :
7074 0 : p_bits_per_entry = bits_per_entry;
7075 0 : }
7076 :
7077 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7078 :
7079 :
7080 : // End of memberFunctionString
7081 : // Start of memberFunctionString
7082 : /* #line 3405 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
7083 :
7084 :
7085 : // Copy constructor
7086 0 : SgStructureModifier::SgStructureModifier ( const SgStructureModifier & X )
7087 : {
7088 0 : p_modifier = X.p_modifier;
7089 0 : }
7090 :
7091 : SgStructureModifier &
7092 54713 : SgStructureModifier::operator= ( const SgStructureModifier & X )
7093 : {
7094 54713 : p_modifier = X.p_modifier;
7095 54713 : return *this;
7096 : }
7097 :
7098 : void
7099 5130600 : SgStructureModifier::post_construction_initialization()
7100 : {
7101 5130600 : p_modifier = e_default;
7102 5130600 : }
7103 :
7104 18273 : bool SgStructureModifier::isUnknown() const { return p_modifier == e_unknown; }
7105 0 : void SgStructureModifier::setUnknown() { p_modifier = e_unknown; }
7106 :
7107 18273 : bool SgStructureModifier::isDefault() const { return p_modifier == e_default; }
7108 12815700 : void SgStructureModifier::setDefault() { p_modifier = e_default; }
7109 :
7110 18273 : bool SgStructureModifier::isParallel() const { return p_modifier == e_table_structure_parallel; }
7111 0 : void SgStructureModifier::setParallel() { p_modifier = e_table_structure_parallel; }
7112 :
7113 18273 : bool SgStructureModifier::isTight() const { return p_modifier == e_table_structure_tight; }
7114 0 : void SgStructureModifier::setTight() { p_modifier = e_table_structure_tight; }
7115 :
7116 : string
7117 6893 : SgStructureModifier::displayString() const
7118 : {
7119 6893 : std::string s = "SgStructureModifier(";
7120 27572 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
7121 20679 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
7122 27572 : s += std::string("isParallel() = ") + std::string(isParallel() ? "true " : "false ");
7123 27572 : s += std::string("isTight() = ") + std::string(isTight() ? "true " : "false ");
7124 :
7125 6893 : s += ")";
7126 6893 : return s;
7127 : }
7128 :
7129 : void
7130 0 : SgStructureModifier::display ( std::string label ) const
7131 : {
7132 0 : mprintf ("In SgStructureModifier::display(%s) \n",label.c_str());
7133 0 : mprintf ("%s \n",displayString().c_str());
7134 0 : }
7135 :
7136 0 : std::ostream & operator<< ( std::ostream & os, const SgStructureModifier & m)
7137 : {
7138 0 : os << m.get_modifier();
7139 0 : return os;
7140 : }
7141 :
7142 5690 : bool operator== (const SgStructureModifier& lhs, const SgStructureModifier& rhs)
7143 : {
7144 5690 : return
7145 11380 : (lhs.isUnknown() == rhs.isUnknown() ) &&
7146 11380 : (lhs.isDefault() == rhs.isDefault() ) &&
7147 11380 : (lhs.isParallel() == rhs.isParallel() ) &&
7148 11380 : (lhs.isTight() == rhs.isTight() ) &&
7149 5690 : true;
7150 : }
7151 :
7152 12815700 : void SgStructureModifier::reset()
7153 : {
7154 12815700 : setDefault();
7155 12815700 : }
7156 :
7157 :
7158 :
7159 : // End of memberFunctionString
7160 : // Start of memberFunctionString
7161 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
7162 :
7163 : // *** COMMON CODE SECTION BEGINS HERE ***
7164 :
7165 : #if 0
7166 : int
7167 : SgStructureModifier::getVariant() const
7168 : {
7169 : // This function is used in ROSE while "variant()" is used in SAGE
7170 : assert(this != NULL);
7171 : return variant();
7172 : }
7173 : #endif
7174 :
7175 : // This function is used in ROSE in treeTraversal code
7176 : // eventually replaces getVariant() and variant()
7177 : // though after variant() has been removed for a while we will
7178 : // want to change the name of variantT() back to variant()
7179 : // (since the "T" was ment to stand for temporary).
7180 : // When this happens the variantT() will be depricated.
7181 : VariantT
7182 15391800 : SgStructureModifier::variantT() const
7183 : {
7184 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
7185 15391800 : ROSE_ASSERT(this != NULL);
7186 15391800 : return V_SgStructureModifier;
7187 : }
7188 :
7189 : #if 0
7190 : int
7191 : SgStructureModifier::variant() const
7192 : {
7193 : // This function is used in SAGE
7194 : ROSE_ASSERT(this != NULL);
7195 : return StructureModifierTag;
7196 : }
7197 : #endif
7198 :
7199 : ROSE_DLL_API const char*
7200 0 : SgStructureModifier::sage_class_name() const
7201 : {
7202 0 : ROSE_ASSERT(this != NULL);
7203 0 : return "SgStructureModifier";
7204 : }
7205 :
7206 : std::string
7207 0 : SgStructureModifier::class_name() const
7208 : {
7209 0 : ROSE_ASSERT(this != NULL);
7210 0 : return "SgStructureModifier";
7211 : }
7212 :
7213 : // DQ (11/26/2005): Support for visitor pattern mechanims
7214 : // (inferior to ROSE traversal mechanism, experimental).
7215 : void
7216 0 : SgStructureModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
7217 : {
7218 0 : ROSE_ASSERT(this != NULL);
7219 0 : visitor.visit(this);
7220 0 : }
7221 :
7222 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
7223 0 : void SgStructureModifier::accept (ROSE_VisitorPattern & visitor) {
7224 0 : ROSE_ASSERT(this != NULL);
7225 0 : visitor.visit(this);
7226 0 : }
7227 :
7228 : SgStructureModifier*
7229 0 : SgStructureModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
7230 : {
7231 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
7232 : // This function is currently only supported for the AST used the represent Binary executables.
7233 : if (0 /* isSgAsmNode(this) != NULL */)
7234 : {
7235 : // Support for regex specification.
7236 : std::string prefixCode = "REGEX:";
7237 : addNewAttribute(prefixCode + s,a);
7238 : }
7239 : #endif
7240 :
7241 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
7242 0 : return this;
7243 : }
7244 :
7245 : // *** COMMON CODE SECTION ENDS HERE ***
7246 :
7247 :
7248 : // End of memberFunctionString
7249 : // Start of memberFunctionString
7250 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
7251 :
7252 :
7253 : #if 0
7254 : //! Error checking support
7255 : /*! Verifies the following:
7256 : - working getVariant() member function
7257 : - calls base class's error() member function
7258 : Every class has one of these functions.
7259 : */
7260 : bool
7261 : SgStructureModifier::error()
7262 : {
7263 : // Put error checking here
7264 :
7265 : ROSE_ASSERT (this != NULL);
7266 : if (getVariant() != StructureModifierTag)
7267 : {
7268 : printf ("Error in SgStructureModifier::error(): SgStructureModifier object has a %s variant \n",
7269 : Cxx_GrammarTerminalNames[getVariant()].name);
7270 : // printf ("Error in SgStructureModifier::error() \n");
7271 : ROSE_ABORT();
7272 : }
7273 :
7274 : ROSE_ASSERT (getVariant() == StructureModifierTag);
7275 : return SgModifier::error();
7276 : }
7277 : #endif
7278 :
7279 :
7280 :
7281 : // End of memberFunctionString
7282 :
7283 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
7284 :
7285 5130600 : SgStructureModifier* isSgStructureModifier ( SgNode* inputDerivedClassPointer )
7286 : {
7287 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
7288 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
7289 : // So to fix this we return NULL directly when the input is NULL and avoid the
7290 : // dynamic_cast in this case. This is likely a performance improvement as well.
7291 : // return dynamic_cast<SgStructureModifier*>(inputDerivedClassPointer);
7292 : // Milind Chabbi (8/28/2013): isSgStructureModifier uses table-driven castability instead of c++ default dynamic_cast
7293 : // this improves the running time performance by 10-20%.
7294 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStructureModifier*>(inputDerivedClassPointer);
7295 5130600 : return IS_SgStructureModifier_FAST_MACRO(inputDerivedClassPointer);
7296 : }
7297 :
7298 : // DQ (11/8/2003): Added version of functions taking const pointer
7299 0 : const SgStructureModifier* isSgStructureModifier ( const SgNode* inputDerivedClassPointer )
7300 : {
7301 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
7302 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
7303 : // So to fix this we return NULL directly when the input is NULL and avoid the
7304 : // dynamic_cast in this case. This is likely a performance improvement as well.
7305 : // return dynamic_cast<const SgStructureModifier*>(inputDerivedClassPointer);
7306 : // Milind Chabbi (8/28/2013): isSgStructureModifier uses table-driven castability instead of c++ default dynamic_cast
7307 : // this improves the running time performance by 10-20%.
7308 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStructureModifier*>(inputDerivedClassPointer);
7309 0 : return IS_SgStructureModifier_FAST_MACRO(inputDerivedClassPointer);
7310 : }
7311 :
7312 :
7313 :
7314 : /* #line 7315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
7315 :
7316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
7317 :
7318 : /**
7319 : \brief Generated destructor
7320 :
7321 : This destructor is automatically generated (by ROSETTA). This destructor
7322 : only frees memory of data members associated with the parts of the current IR node which
7323 : are NOT traversed. Those data members that are part of a traversal can be freed using
7324 : a traversal (calling this destructor on all children in a post-order traversal). Such
7325 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
7326 :
7327 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
7328 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
7329 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
7330 :
7331 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
7332 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
7333 : pointers are not yet implemented to call delete on eash pointer in the container.
7334 : (This could be done by derivation from the STL containers to define containers that
7335 : automatically deleted their members.)
7336 :
7337 : */
7338 1453340 : SgStructureModifier::~SgStructureModifier () {
7339 1453340 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
7340 :
7341 :
7342 : // case: not a listType for modifier
7343 1453340 : p_modifier = SgStructureModifier::e_default; // non list case
7344 : // case: not a listType for bits_per_entry
7345 1453340 : p_bits_per_entry = 0; // non list case
7346 :
7347 : }
7348 :
7349 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
7350 1453340 : }
7351 :
7352 :
7353 : /* #line 7354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
7354 :
7355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
7356 :
7357 : // Generated constructor
7358 5130600 : SgStructureModifier::SgStructureModifier ( )
7359 5130600 : : SgModifier()
7360 : {
7361 : #ifdef DEBUG
7362 : // printf ("In SgStructureModifier::SgStructureModifier () sage_class_name() = %s \n",sage_class_name());
7363 : #endif
7364 : #if 0
7365 : // debugging information!
7366 : printf ("In SgStructureModifier::SgStructureModifier (): this = %p = %s \n",this,this->class_name().c_str());
7367 : #endif
7368 :
7369 5130600 : p_modifier = SgStructureModifier::e_default;
7370 5130600 : p_bits_per_entry = 0;
7371 :
7372 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
7373 :
7374 : #if 0
7375 : // DQ (7/30/2014): Call a virtual function.
7376 : std::string s = this->class_name();
7377 : #endif
7378 :
7379 : // Test the variant virtual function
7380 : // assert(StructureModifierTag == variant());
7381 5130600 : assert(StructureModifierTag == this->variant());
7382 5130600 : ROSE_ASSERT(StructureModifierTag == (int)(this->variantT()));
7383 5130600 : post_construction_initialization();
7384 :
7385 : // Test the isSgStructureModifier() function since it has been problematic
7386 5130600 : assert(isSgStructureModifier(this) != NULL);
7387 5130600 : }
7388 :
7389 : // Generated constructor (all data members)
7390 :
7391 : /* #line 7392 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
7392 :
7393 :
7394 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
7395 :
7396 :
7397 : // ********************************************************
7398 : // member functions common across all array grammar objects
7399 : // ********************************************************
7400 :
7401 :
7402 :
7403 : /* #line 7404 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
7404 :
7405 :
7406 :
7407 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
7408 :
7409 : // ********************************************************
7410 : // member functions specific to each node in the grammar
7411 : // ********************************************************
7412 :
7413 :
7414 : /* #line 7415 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
7415 :
7416 : // Start of memberFunctionString
7417 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7418 :
7419 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7420 :
7421 : SgBitVector
7422 0 : SgTypeModifier::get_modifierVector () const
7423 : {
7424 0 : ROSE_ASSERT (this != NULL);
7425 :
7426 : #if 0
7427 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7428 : // used to trigger marking transformations for the token-based unparsing.
7429 : printf ("SgTypeModifier::get_modifierVector = %p = %s \n",this,this->class_name().c_str());
7430 : #endif
7431 :
7432 0 : return p_modifierVector;
7433 : }
7434 :
7435 : void
7436 0 : SgTypeModifier::set_modifierVector ( SgBitVector modifierVector )
7437 : {
7438 0 : ROSE_ASSERT (this != NULL);
7439 :
7440 : #if 0
7441 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7442 : // used to trigger marking transformations for the token-based unparsing.
7443 : printf ("SgTypeModifier::set_modifierVector = %p = %s \n",this,this->class_name().c_str());
7444 : #endif
7445 :
7446 0 : set_isModified(true);
7447 :
7448 0 : p_modifierVector = modifierVector;
7449 0 : }
7450 :
7451 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7452 :
7453 :
7454 : // End of memberFunctionString
7455 : // Start of memberFunctionString
7456 :
7457 :
7458 : // End of memberFunctionString
7459 : // Start of memberFunctionString
7460 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7461 :
7462 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7463 :
7464 : int
7465 10000 : SgTypeModifier::get_gnu_attribute_alignment () const
7466 : {
7467 10000 : ROSE_ASSERT (this != NULL);
7468 :
7469 : #if 0
7470 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7471 : // used to trigger marking transformations for the token-based unparsing.
7472 : printf ("SgTypeModifier::get_gnu_attribute_alignment = %p = %s \n",this,this->class_name().c_str());
7473 : #endif
7474 :
7475 10000 : return p_gnu_attribute_alignment;
7476 : }
7477 :
7478 : void
7479 57 : SgTypeModifier::set_gnu_attribute_alignment ( int gnu_attribute_alignment )
7480 : {
7481 57 : ROSE_ASSERT (this != NULL);
7482 :
7483 : #if 0
7484 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7485 : // used to trigger marking transformations for the token-based unparsing.
7486 : printf ("SgTypeModifier::set_gnu_attribute_alignment = %p = %s \n",this,this->class_name().c_str());
7487 : #endif
7488 :
7489 57 : set_isModified(true);
7490 :
7491 57 : p_gnu_attribute_alignment = gnu_attribute_alignment;
7492 57 : }
7493 :
7494 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7495 :
7496 :
7497 : // End of memberFunctionString
7498 : // Start of memberFunctionString
7499 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7500 :
7501 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7502 :
7503 : long
7504 0 : SgTypeModifier::get_gnu_attribute_sentinel () const
7505 : {
7506 0 : ROSE_ASSERT (this != NULL);
7507 :
7508 : #if 0
7509 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7510 : // used to trigger marking transformations for the token-based unparsing.
7511 : printf ("SgTypeModifier::get_gnu_attribute_sentinel = %p = %s \n",this,this->class_name().c_str());
7512 : #endif
7513 :
7514 0 : return p_gnu_attribute_sentinel;
7515 : }
7516 :
7517 : void
7518 0 : SgTypeModifier::set_gnu_attribute_sentinel ( long gnu_attribute_sentinel )
7519 : {
7520 0 : ROSE_ASSERT (this != NULL);
7521 :
7522 : #if 0
7523 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7524 : // used to trigger marking transformations for the token-based unparsing.
7525 : printf ("SgTypeModifier::set_gnu_attribute_sentinel = %p = %s \n",this,this->class_name().c_str());
7526 : #endif
7527 :
7528 0 : set_isModified(true);
7529 :
7530 0 : p_gnu_attribute_sentinel = gnu_attribute_sentinel;
7531 0 : }
7532 :
7533 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7534 :
7535 :
7536 : // End of memberFunctionString
7537 : // Start of memberFunctionString
7538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7539 :
7540 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7541 :
7542 : unsigned
7543 10156 : SgTypeModifier::get_address_space_value () const
7544 : {
7545 10156 : ROSE_ASSERT (this != NULL);
7546 :
7547 : #if 0
7548 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7549 : // used to trigger marking transformations for the token-based unparsing.
7550 : printf ("SgTypeModifier::get_address_space_value = %p = %s \n",this,this->class_name().c_str());
7551 : #endif
7552 :
7553 10156 : return p_address_space_value;
7554 : }
7555 :
7556 : void
7557 0 : SgTypeModifier::set_address_space_value ( unsigned address_space_value )
7558 : {
7559 0 : ROSE_ASSERT (this != NULL);
7560 :
7561 : #if 0
7562 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7563 : // used to trigger marking transformations for the token-based unparsing.
7564 : printf ("SgTypeModifier::set_address_space_value = %p = %s \n",this,this->class_name().c_str());
7565 : #endif
7566 :
7567 0 : set_isModified(true);
7568 :
7569 0 : p_address_space_value = address_space_value;
7570 0 : }
7571 :
7572 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7573 :
7574 :
7575 : // End of memberFunctionString
7576 : // Start of memberFunctionString
7577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
7578 :
7579 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
7580 :
7581 : unsigned
7582 10156 : SgTypeModifier::get_vector_size () const
7583 : {
7584 10156 : ROSE_ASSERT (this != NULL);
7585 :
7586 : #if 0
7587 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7588 : // used to trigger marking transformations for the token-based unparsing.
7589 : printf ("SgTypeModifier::get_vector_size = %p = %s \n",this,this->class_name().c_str());
7590 : #endif
7591 :
7592 10156 : return p_vector_size;
7593 : }
7594 :
7595 : void
7596 0 : SgTypeModifier::set_vector_size ( unsigned vector_size )
7597 : {
7598 0 : ROSE_ASSERT (this != NULL);
7599 :
7600 : #if 0
7601 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
7602 : // used to trigger marking transformations for the token-based unparsing.
7603 : printf ("SgTypeModifier::set_vector_size = %p = %s \n",this,this->class_name().c_str());
7604 : #endif
7605 :
7606 0 : set_isModified(true);
7607 :
7608 0 : p_vector_size = vector_size;
7609 0 : }
7610 :
7611 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
7612 :
7613 :
7614 : // End of memberFunctionString
7615 : // Start of memberFunctionString
7616 : /* #line 3886 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
7617 :
7618 :
7619 : // Copy constructor
7620 0 : SgTypeModifier::SgTypeModifier ( const SgTypeModifier & X )
7621 : {
7622 0 : p_modifierVector = X.p_modifierVector;
7623 0 : p_constVolatileModifier = X.p_constVolatileModifier;
7624 0 : p_upcModifier = X.p_upcModifier;
7625 0 : p_elaboratedTypeModifier = X.p_elaboratedTypeModifier;
7626 0 : }
7627 :
7628 : SgTypeModifier &
7629 108624 : SgTypeModifier::operator= ( const SgTypeModifier & X )
7630 : {
7631 108624 : p_modifierVector = X.p_modifierVector;
7632 108624 : p_constVolatileModifier = X.p_constVolatileModifier;
7633 108624 : p_upcModifier = X.p_upcModifier;
7634 108624 : p_elaboratedTypeModifier = X.p_elaboratedTypeModifier;
7635 108624 : return *this;
7636 : }
7637 :
7638 : void
7639 5075890 : SgTypeModifier::post_construction_initialization()
7640 : {
7641 5075890 : p_modifierVector = SgBitVector(e_last_modifier,false);
7642 5075890 : setDefault();
7643 5075890 : }
7644 :
7645 17049 : bool SgTypeModifier::isUnknown() const { return checkBit(e_unknown,p_modifierVector); }
7646 0 : void SgTypeModifier::setUnknown() { setBit(e_unknown,p_modifierVector); }
7647 6341180 : void SgTypeModifier::unsetUnknown() { unsetBit(e_unknown,p_modifierVector); }
7648 :
7649 17049 : bool SgTypeModifier::isDefault() const { return checkBit(e_default,p_modifierVector); }
7650 11417100 : void SgTypeModifier::setDefault() { setBit(e_default,p_modifierVector); }
7651 0 : void SgTypeModifier::unsetDefault() { unsetBit(e_default,p_modifierVector); }
7652 :
7653 637039 : bool SgTypeModifier::isRestrict() const { return checkBit(e_restrict,p_modifierVector); }
7654 1 : void SgTypeModifier::setRestrict() { setBit(e_restrict,p_modifierVector); }
7655 6341180 : void SgTypeModifier::unsetRestrict() { unsetBit(e_restrict,p_modifierVector); }
7656 :
7657 : #if 0
7658 : e_allocatable = 3, /*!< allocatable attribute specifier (for Fortran 90) */
7659 : e_asynchronous = 4, /*!< asynchronous attribute specifier (for Fortran 2003) */
7660 : e_bind = 5, /*!< bind attribute specifier (for Fortran 2003, this is closely related to the SgLinkageModifier) */
7661 : e_data = 6, /*!< data attribute specifier (for Fortran 77) */
7662 : e_dimension = 7, /*!< dimension attribute specifier (for Fortran 77) */
7663 : // This should map to the C/C++ extern modifier in SgStorageModifier
7664 : // e_external = x, /*!< external attribute specifier (for Fortran 77, this is less related to the SgLinkageModifier than the SgStorageModifier) */
7665 : e_intent_in = 8, /*!< intent(in) attribute specifier (for Fortran 90) */
7666 : e_intent_out = 9, /*!< intent(out) attribute specifier (for Fortran 90) */
7667 : e_intent_inout = 10,/*!< intent(inout) attribute specifier (for Fortran 90) */
7668 : e_intrinsic = 11,/*!< intrinsic attribute specifier (for Fortran 90) */
7669 : e_optional = 12,/*!< optional attribute specifier (for Fortran 90) */
7670 : // This should map to const in the SgConstVolatileModifier
7671 : // e_parameter = xx,/*!< parameter attribute specifier (for Fortran 77) */
7672 :
7673 : // This should be mapped to the SgPointerType in C/C++
7674 : // e_pointer = xx,/*!< pointer attribute specifier (for Fortran 90) */
7675 : // Note that protected access attribute is mapped to the C/C++ protected access modifiers in SgDeclarationModifier
7676 : // e_protected = xx,/*!< protected attribute specifier (for Fortran 2003) */
7677 : e_save = 13,/*!< save attribute specifier (for Fortran 77) */
7678 : e_target = 14,/*!< target attribute specifier (for Fortran 90) */
7679 : e_value = 15,/*!< value attribute specifier (for Fortran 2003) */
7680 : #endif
7681 :
7682 : // Fortran specific attribute
7683 10205 : bool SgTypeModifier::isAllocatable() const { return checkBit(e_allocatable,p_modifierVector); }
7684 0 : void SgTypeModifier::setAllocatable() { setBit(e_allocatable,p_modifierVector); }
7685 0 : void SgTypeModifier::unsetAllocatable() { unsetBit(e_allocatable,p_modifierVector); }
7686 :
7687 : // Fortran specific attribute
7688 10205 : bool SgTypeModifier::isAsynchronous() const { return checkBit(e_asynchronous,p_modifierVector); }
7689 0 : void SgTypeModifier::setAsynchronous() { setBit(e_asynchronous,p_modifierVector); }
7690 0 : void SgTypeModifier::unsetAsynchronous() { unsetBit(e_asynchronous,p_modifierVector); }
7691 :
7692 : // Fortran specific attribute
7693 10156 : bool SgTypeModifier::isBind() const { return checkBit(e_bind,p_modifierVector); }
7694 0 : void SgTypeModifier::setBind() { setBit(e_bind,p_modifierVector); }
7695 0 : void SgTypeModifier::unsetBind() { unsetBit(e_bind,p_modifierVector); }
7696 :
7697 : // Fortran specific attribute
7698 10156 : bool SgTypeModifier::isData() const { return checkBit(e_data,p_modifierVector); }
7699 0 : void SgTypeModifier::setData() { setBit(e_data,p_modifierVector); }
7700 0 : void SgTypeModifier::unsetData() { unsetBit(e_data,p_modifierVector); }
7701 :
7702 : // Fortran specific attribute
7703 10156 : bool SgTypeModifier::isDimension() const { return checkBit(e_dimension,p_modifierVector); }
7704 0 : void SgTypeModifier::setDimension() { setBit(e_dimension,p_modifierVector); }
7705 0 : void SgTypeModifier::unsetDimension() { unsetBit(e_dimension,p_modifierVector); }
7706 :
7707 : // Fortran specific attribute
7708 10205 : bool SgTypeModifier::isIntent_in() const { return checkBit(e_intent_in,p_modifierVector); }
7709 0 : void SgTypeModifier::setIntent_in() { setBit(e_intent_in,p_modifierVector); }
7710 0 : void SgTypeModifier::unsetIntent_in() { unsetBit(e_intent_in,p_modifierVector); }
7711 :
7712 : // Fortran specific attribute
7713 10205 : bool SgTypeModifier::isIntent_out() const { return checkBit(e_intent_out,p_modifierVector); }
7714 0 : void SgTypeModifier::setIntent_out() { setBit(e_intent_out,p_modifierVector); }
7715 0 : void SgTypeModifier::unsetIntent_out() { unsetBit(e_intent_out,p_modifierVector); }
7716 :
7717 : // Fortran specific attribute
7718 10205 : bool SgTypeModifier::isIntent_inout() const { return checkBit(e_intent_inout,p_modifierVector); }
7719 0 : void SgTypeModifier::setIntent_inout() { setBit(e_intent_inout,p_modifierVector); }
7720 0 : void SgTypeModifier::unsetIntent_inout() { unsetBit(e_intent_inout,p_modifierVector); }
7721 :
7722 : // Fortran specific attribute
7723 10205 : bool SgTypeModifier::isIntrinsic() const { return checkBit(e_intrinsic,p_modifierVector); }
7724 0 : void SgTypeModifier::setIntrinsic() { setBit(e_intrinsic,p_modifierVector); }
7725 0 : void SgTypeModifier::unsetIntrinsic() { unsetBit(e_intrinsic,p_modifierVector); }
7726 :
7727 : // Fortran specific attribute
7728 10205 : bool SgTypeModifier::isOptional() const { return checkBit(e_optional,p_modifierVector); }
7729 0 : void SgTypeModifier::setOptional() { setBit(e_optional,p_modifierVector); }
7730 0 : void SgTypeModifier::unsetOptional() { unsetBit(e_optional,p_modifierVector); }
7731 :
7732 : // Fortran specific attribute
7733 10205 : bool SgTypeModifier::isSave() const { return checkBit(e_save,p_modifierVector); }
7734 0 : void SgTypeModifier::setSave() { setBit(e_save,p_modifierVector); }
7735 0 : void SgTypeModifier::unsetSave() { unsetBit(e_save,p_modifierVector); }
7736 :
7737 : // Fortran specific attribute
7738 10205 : bool SgTypeModifier::isTarget() const { return checkBit(e_target,p_modifierVector); }
7739 4 : void SgTypeModifier::setTarget() { setBit(e_target,p_modifierVector); }
7740 0 : void SgTypeModifier::unsetTarget() { unsetBit(e_target,p_modifierVector); }
7741 :
7742 : // Fortran specific attribute
7743 10205 : bool SgTypeModifier::isValue() const { return checkBit(e_value,p_modifierVector); }
7744 0 : void SgTypeModifier::setValue() { setBit(e_value,p_modifierVector); }
7745 0 : void SgTypeModifier::unsetValue() { unsetBit(e_value,p_modifierVector); }
7746 :
7747 : // Fortran specific attribute
7748 0 : bool SgTypeModifier::isExtends() const { return checkBit(e_extends,p_modifierVector); }
7749 0 : void SgTypeModifier::setExtends() { setBit(e_extends,p_modifierVector); }
7750 0 : void SgTypeModifier::unsetExtends() { unsetBit(e_extends,p_modifierVector); }
7751 :
7752 : // Fortran specific attribute
7753 0 : bool SgTypeModifier::isAbstract() const { return checkBit(e_abstract,p_modifierVector); }
7754 0 : void SgTypeModifier::setAbstract() { setBit(e_abstract,p_modifierVector); }
7755 0 : void SgTypeModifier::unsetAbstract() { unsetBit(e_abstract,p_modifierVector); }
7756 :
7757 : // DQ (1/3/2009): Added GNU specific attributes
7758 10156 : bool SgTypeModifier::isGnuAttributeUnused() const { return checkBit(e_gnu_attribute__unused__,p_modifierVector); }
7759 0 : void SgTypeModifier::setGnuAttributeUnused() { setBit(e_gnu_attribute__unused__,p_modifierVector); }
7760 0 : void SgTypeModifier::unsetGnuAttributeUnused() { unsetBit(e_gnu_attribute__unused__,p_modifierVector); }
7761 :
7762 : // DQ (1/3/2009): Added GNU specific attributes
7763 14307 : bool SgTypeModifier::isGnuAttributePacked() const { return checkBit(e_gnu_attribute__packed__,p_modifierVector); }
7764 0 : void SgTypeModifier::setGnuAttributePacked() { setBit(e_gnu_attribute__packed__,p_modifierVector); }
7765 0 : void SgTypeModifier::unsetGnuAttributePacked() { unsetBit(e_gnu_attribute__packed__,p_modifierVector); }
7766 :
7767 : // DQ (1/3/2009): Added GNU specific attributes
7768 10156 : bool SgTypeModifier::isGnuAttributeDeprecated() const { return checkBit(e_gnu_attribute__deprecated__,p_modifierVector); }
7769 40 : void SgTypeModifier::setGnuAttributeDeprecated() { setBit(e_gnu_attribute__deprecated__,p_modifierVector); }
7770 0 : void SgTypeModifier::unsetGnuAttributeDeprecated() { unsetBit(e_gnu_attribute__deprecated__,p_modifierVector); }
7771 :
7772 : // DQ (1/3/2009): Added GNU specific attributes
7773 11415 : bool SgTypeModifier::isGnuAttributeTransparentUnion() const { return checkBit(e_gnu_attribute__transparent_union__,p_modifierVector); }
7774 0 : void SgTypeModifier::setGnuAttributeTransparentUnion() { setBit(e_gnu_attribute__transparent_union__,p_modifierVector); }
7775 0 : void SgTypeModifier::unsetGnuAttributeTransparentUnion() { unsetBit(e_gnu_attribute__transparent_union__,p_modifierVector); }
7776 :
7777 : // DQ (1/3/2009): Added GNU specific attributes
7778 10294 : bool SgTypeModifier::isGnuAttributeNoReturn() const { return checkBit(e_gnu_attribute__noreturn__,p_modifierVector); }
7779 5438 : void SgTypeModifier::setGnuAttributeNoReturn() { setBit(e_gnu_attribute__noreturn__,p_modifierVector); }
7780 0 : void SgTypeModifier::unsetGnuAttributeNoReturn() { unsetBit(e_gnu_attribute__noreturn__,p_modifierVector); }
7781 :
7782 : // DQ (1/3/2009): Added GNU specific attributes
7783 10156 : bool SgTypeModifier::isGnuAttributeConst() const { return checkBit(e_gnu_attribute__const__,p_modifierVector); }
7784 92684 : void SgTypeModifier::setGnuAttributeConst() { setBit(e_gnu_attribute__const__,p_modifierVector); }
7785 0 : void SgTypeModifier::unsetGnuAttributeConst() { unsetBit(e_gnu_attribute__const__,p_modifierVector); }
7786 :
7787 : // DQ (1/3/2009): Added GNU specific attributes
7788 11163 : bool SgTypeModifier::isGnuAttributeCdecl() const { return checkBit(e_gnu_attribute__cdecl__,p_modifierVector); }
7789 0 : void SgTypeModifier::setGnuAttributeCdecl() { setBit(e_gnu_attribute__cdecl__,p_modifierVector); }
7790 0 : void SgTypeModifier::unsetGnuAttributeCdecl() { unsetBit(e_gnu_attribute__cdecl__,p_modifierVector); }
7791 :
7792 : // DQ (1/3/2009): Added GNU specific attributes
7793 10156 : bool SgTypeModifier::isGnuAttributeStdcall() const { return checkBit(e_gnu_attribute__stdcall__,p_modifierVector); }
7794 0 : void SgTypeModifier::setGnuAttributeStdcall() { setBit(e_gnu_attribute__stdcall__,p_modifierVector); }
7795 0 : void SgTypeModifier::unsetGnuAttributeStdcall() { unsetBit(e_gnu_attribute__stdcall__,p_modifierVector); }
7796 :
7797 : // DQ (1/3/2009): Added GNU specific attributes
7798 10156 : bool SgTypeModifier::isGnuAttributeWarnUnusedResult() const { return checkBit(e_gnu_attribute__warn_unused_result__,p_modifierVector); }
7799 334 : void SgTypeModifier::setGnuAttributeWarnUnusedResult() { setBit(e_gnu_attribute__warn_unused_result__,p_modifierVector); }
7800 0 : void SgTypeModifier::unsetGnuAttributeWarnUnusedResult() { unsetBit(e_gnu_attribute__warn_unused_result__,p_modifierVector); }
7801 :
7802 : // DQ (1/3/2009): Added GNU specific attributes
7803 10156 : bool SgTypeModifier::isGnuAttributeNonnull() const { return checkBit(e_gnu_attribute__nonnull__,p_modifierVector); }
7804 17876 : void SgTypeModifier::setGnuAttributeNonnull() { setBit(e_gnu_attribute__nonnull__,p_modifierVector); }
7805 0 : void SgTypeModifier::unsetGnuAttributeNonnull() { unsetBit(e_gnu_attribute__nonnull__,p_modifierVector); }
7806 :
7807 : // DQ (1/3/2009): Added GNU specific attributes
7808 10156 : bool SgTypeModifier::isGnuAttributeSentinel() const { return checkBit(e_gnu_attribute__sentinel__,p_modifierVector); }
7809 0 : void SgTypeModifier::setGnuAttributeSentinel() { setBit(e_gnu_attribute__sentinel__,p_modifierVector); }
7810 0 : void SgTypeModifier::unsetGnuAttributeSentinel() { unsetBit(e_gnu_attribute__sentinel__,p_modifierVector); }
7811 :
7812 59517 : bool SgTypeModifier::haveAddressSpace() const { return checkBit(e_address_space__,p_modifierVector); }
7813 0 : void SgTypeModifier::setAddressSpace() { setBit(e_address_space__,p_modifierVector); }
7814 0 : void SgTypeModifier::unsetAddressSpace() { unsetBit(e_address_space__,p_modifierVector); }
7815 :
7816 59517 : bool SgTypeModifier::isOpenclGlobal() const { return checkBit(e_ocl_global__,p_modifierVector); }
7817 0 : void SgTypeModifier::setOpenclGlobal() { setBit(e_ocl_global__,p_modifierVector); }
7818 0 : void SgTypeModifier::unsetOpenclGlobal() { unsetBit(e_ocl_global__,p_modifierVector); }
7819 :
7820 59517 : bool SgTypeModifier::isOpenclLocal() const { return checkBit(e_ocl_local__,p_modifierVector); }
7821 0 : void SgTypeModifier::setOpenclLocal() { setBit(e_ocl_local__,p_modifierVector); }
7822 0 : void SgTypeModifier::unsetOpenclLocal() { unsetBit(e_ocl_local__,p_modifierVector); }
7823 :
7824 59517 : bool SgTypeModifier::isOpenclConstant() const { return checkBit(e_ocl_constant__,p_modifierVector); }
7825 0 : void SgTypeModifier::setOpenclConstant() { setBit(e_ocl_constant__,p_modifierVector); }
7826 0 : void SgTypeModifier::unsetOpenclConstant() { unsetBit(e_ocl_constant__,p_modifierVector); }
7827 :
7828 10156 : bool SgTypeModifier::isVectorType() const { return checkBit(e_vector_type__,p_modifierVector); }
7829 0 : void SgTypeModifier::setVectorType() { setBit(e_vector_type__,p_modifierVector); }
7830 0 : void SgTypeModifier::unsetVectorType() { unsetBit(e_vector_type__,p_modifierVector); }
7831 :
7832 : // DQ (1/24/2016): Added GNU specific attributes for custom specification of CUDA device in function parameter types.
7833 0 : bool SgTypeModifier::isGnuAttributeDevice() const { return checkBit(e_gnu_attribute__device__,p_modifierVector); }
7834 0 : void SgTypeModifier::setGnuAttributeDevice() { setBit(e_gnu_attribute__device__,p_modifierVector); }
7835 0 : void SgTypeModifier::unsetGnuAttributeDevice() { unsetBit(e_gnu_attribute__device__,p_modifierVector); }
7836 :
7837 : // Rasmussen (3/1/2020): numeric type specifiers for Jovial
7838 0 : bool SgTypeModifier::isRound() const { return checkBit(e_round,p_modifierVector); }
7839 0 : void SgTypeModifier::setRound() { setBit(e_round,p_modifierVector); }
7840 0 : void SgTypeModifier::unsetRound() { unsetBit(e_round,p_modifierVector); }
7841 :
7842 0 : bool SgTypeModifier::isTruncate() const { return checkBit(e_truncate,p_modifierVector); }
7843 0 : void SgTypeModifier::setTruncate() { setBit(e_truncate,p_modifierVector); }
7844 0 : void SgTypeModifier::unsetTruncate() { unsetBit(e_truncate,p_modifierVector); }
7845 :
7846 0 : bool SgTypeModifier::isTruncateTowardsZero() const { return checkBit(e_truncate_towards_zero,p_modifierVector); }
7847 0 : void SgTypeModifier::setTruncateTowardsZero() { setBit(e_truncate_towards_zero,p_modifierVector); }
7848 0 : void SgTypeModifier::unsetTruncateTowardsZero() { unsetBit(e_truncate_towards_zero,p_modifierVector); }
7849 :
7850 551206 : bool SgTypeModifier::isAliased() const { return checkBit(e_aliased,p_modifierVector); }
7851 0 : void SgTypeModifier::setAliased() { setBit(e_aliased,p_modifierVector); }
7852 0 : void SgTypeModifier::unsetAliased() { unsetBit(e_aliased,p_modifierVector); }
7853 :
7854 : string
7855 6893 : SgTypeModifier::displayString() const
7856 : {
7857 6893 : std::string s = "SgTypeModifier(";
7858 27572 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
7859 20679 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
7860 27572 : s += std::string("isRestrict() = ") + std::string(isRestrict() ? "true " : "false ");
7861 27572 : s += std::string("isAliased() = ") + std::string(isAliased() ? "true " : "false ");
7862 20679 : s += std::string("gnu_extension_machine_mode = ") + Rose::StringUtility::numberToString((int)p_gnu_extension_machine_mode) + " ";
7863 20679 : s += std::string("gnu_attribute_alignment = ") + Rose::StringUtility::numberToString((int)p_gnu_attribute_alignment) + " ";
7864 20679 : s += std::string("gnu_attribute_sentinel = ") + Rose::StringUtility::numberToString((int)p_gnu_attribute_sentinel) + " ";
7865 20679 : s += std::string("address_space_value = ") + Rose::StringUtility::numberToString((int)p_address_space_value) + " ";
7866 20679 : s += std::string("vector_size = ") + Rose::StringUtility::numberToString((int)p_vector_size) + " ";
7867 20679 : s += std::string(" ") + get_constVolatileModifier().displayString() + " ";
7868 20679 : s += std::string(" ") + get_upcModifier().displayString() + " ";
7869 20679 : s += std::string(" ") + get_structureModifier().displayString() + " ";
7870 20679 : s += std::string(" ") + get_elaboratedTypeModifier().displayString();
7871 6893 : s += ")";
7872 6893 : return s;
7873 : }
7874 :
7875 : void
7876 0 : SgTypeModifier::display ( std::string label ) const
7877 : {
7878 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
7879 0 : printf ("In SgTypeModifier::display(%s) \n",label.c_str());
7880 0 : printf ("%s \n",displayString().c_str());
7881 0 : }
7882 :
7883 0 : std::ostream& operator<< (std::ostream& os, const SgTypeModifier& tm)
7884 : {
7885 0 : os << tm.get_modifierVector();
7886 0 : return os;
7887 : }
7888 :
7889 : // DQ (11/28/2015): We need a better way to support wrappers of types that are significant and not significant.
7890 3667 : bool SgTypeModifier::isIdentity() const
7891 : {
7892 : // When this is true, the SgTypeModifier acts as a simple wrapper to a base type that is equivalent.
7893 3667 : bool identity = false;
7894 :
7895 : #if 0
7896 : mprintf ("In SgTypeModifier::isIdentity(): this = %p get_constVolatileModifier().isConst() = %s \n",this,get_constVolatileModifier().isConst() ? "true" : "false");
7897 : #endif
7898 :
7899 : // This needs to be an expanded set of fields later.
7900 3667 : identity = (get_constVolatileModifier().isConst() == false) && (get_constVolatileModifier().isVolatile() == false) && (isRestrict() == false);
7901 :
7902 : #if 0
7903 : mprintf ("In SgTypeModifier::isIdentity(): return identity = %s \n",identity ? "true" : "false");
7904 : #endif
7905 :
7906 3667 : return identity;
7907 : }
7908 :
7909 :
7910 5690 : bool operator== (const SgTypeModifier& lhs, const SgTypeModifier& rhs)
7911 : {
7912 5690 : return
7913 11380 : (lhs.get_upcModifier() == rhs.get_upcModifier() ) &&
7914 11380 : (lhs.get_structureModifier() == rhs.get_structureModifier() ) &&
7915 10768 : (lhs.get_constVolatileModifier() == rhs.get_constVolatileModifier() ) &&
7916 10156 : (lhs.get_elaboratedTypeModifier() == rhs.get_elaboratedTypeModifier()) &&
7917 10156 : (lhs.isUnknown() == rhs.isUnknown()) &&
7918 10156 : (lhs.isDefault() == rhs.isDefault()) &&
7919 : // C specific
7920 10156 : (lhs.isRestrict() == rhs.isRestrict()) &&
7921 : // Fortran specific
7922 10156 : (lhs.isAllocatable() == rhs.isAllocatable() ) &&
7923 10156 : (lhs.isBind() == rhs.isBind() ) &&
7924 10156 : (lhs.isAsynchronous() == rhs.isAsynchronous()) &&
7925 10156 : (lhs.isData() == rhs.isData() ) &&
7926 10156 : (lhs.isDimension() == rhs.isDimension() ) &&
7927 10156 : (lhs.isIntent_in() == rhs.isIntent_in() ) &&
7928 10156 : (lhs.isIntent_out() == rhs.isIntent_out() ) &&
7929 10156 : (lhs.isIntent_inout() == rhs.isIntent_inout()) &&
7930 10156 : (lhs.isIntrinsic() == rhs.isIntrinsic() ) &&
7931 10156 : (lhs.isOptional() == rhs.isOptional() ) &&
7932 10156 : (lhs.isSave() == rhs.isSave() ) &&
7933 10156 : (lhs.isTarget() == rhs.isTarget() ) &&
7934 10156 : (lhs.isValue() == rhs.isValue() ) &&
7935 : // GNU specific
7936 10156 : (lhs.isGnuAttributeUnused() == rhs.isGnuAttributeUnused() ) &&
7937 10156 : (lhs.isGnuAttributePacked() == rhs.isGnuAttributePacked() ) &&
7938 10156 : (lhs.isGnuAttributeDeprecated() == rhs.isGnuAttributeDeprecated() ) &&
7939 10156 : (lhs.isGnuAttributeTransparentUnion() == rhs.isGnuAttributeTransparentUnion()) &&
7940 10156 : (lhs.isGnuAttributeNoReturn() == rhs.isGnuAttributeNoReturn() ) &&
7941 10156 : (lhs.isGnuAttributeConst() == rhs.isGnuAttributeConst() ) &&
7942 10156 : (lhs.isGnuAttributeCdecl() == rhs.isGnuAttributeCdecl() ) &&
7943 10156 : (lhs.isGnuAttributeStdcall() == rhs.isGnuAttributeStdcall() ) &&
7944 10156 : (lhs.isGnuAttributeWarnUnusedResult() == rhs.isGnuAttributeWarnUnusedResult()) &&
7945 10156 : (lhs.isGnuAttributeNonnull() == rhs.isGnuAttributeNonnull() ) &&
7946 10156 : (lhs.isGnuAttributeSentinel() == rhs.isGnuAttributeSentinel() ) &&
7947 : // Address Space
7948 10156 : (lhs.haveAddressSpace() == rhs.haveAddressSpace() ) &&
7949 10156 : (lhs.get_address_space_value() == rhs.get_address_space_value() ) &&
7950 : // OpenCL specific
7951 10156 : (lhs.isOpenclGlobal() == rhs.isOpenclGlobal() ) &&
7952 10156 : (lhs.isOpenclLocal() == rhs.isOpenclLocal() ) &&
7953 10156 : (lhs.isOpenclConstant() == rhs.isOpenclConstant() ) &&
7954 : // Vector Type
7955 10156 : (lhs.isVectorType() == rhs.isVectorType() ) &&
7956 10768 : (lhs.get_vector_size() == rhs.get_vector_size() ) &&
7957 5690 : true;
7958 : }
7959 :
7960 : SgConstVolatileModifier &
7961 6455030 : SgTypeModifier::get_constVolatileModifier ()
7962 : {
7963 6455030 : ROSE_ASSERT (this != NULL);
7964 6455030 : return p_constVolatileModifier;
7965 : }
7966 :
7967 : SgUPC_AccessModifier &
7968 6491820 : SgTypeModifier::get_upcModifier ()
7969 : {
7970 6491820 : ROSE_ASSERT (this != NULL);
7971 6491820 : return p_upcModifier;
7972 : }
7973 :
7974 : SgStructureModifier &
7975 6341180 : SgTypeModifier::get_structureModifier ()
7976 : {
7977 6341180 : ROSE_ASSERT (this != NULL);
7978 6341180 : return p_structureModifier;
7979 : }
7980 :
7981 : SgElaboratedTypeModifier &
7982 6341180 : SgTypeModifier::get_elaboratedTypeModifier ()
7983 : {
7984 6341180 : ROSE_ASSERT (this != NULL);
7985 6341180 : return p_elaboratedTypeModifier;
7986 : }
7987 :
7988 : // DQ (2/4/2006): Added mechamism to clear all bits
7989 6341180 : void SgTypeModifier::reset()
7990 : {
7991 6341180 : unsetUnknown();
7992 6341180 : unsetRestrict();
7993 :
7994 : // Set this bit to indicate the default value (we want a value of all zero bits to be an error)
7995 6341180 : setDefault();
7996 :
7997 6341180 : get_constVolatileModifier().reset();
7998 6341180 : get_upcModifier().reset();
7999 6341180 : get_structureModifier().reset();
8000 6341180 : get_elaboratedTypeModifier().reset();
8001 6341180 : }
8002 :
8003 : // RV (2/2/2006): Created this 'const' version of the member function.
8004 : const SgConstVolatileModifier &
8005 567779 : SgTypeModifier::get_constVolatileModifier (void) const
8006 : {
8007 567779 : ROSE_ASSERT (this != NULL);
8008 567779 : return p_constVolatileModifier;
8009 : }
8010 :
8011 : // RV (2/2/2006): Created this 'const' version of the member function.
8012 : const SgUPC_AccessModifier &
8013 562586 : SgTypeModifier::get_upcModifier (void) const
8014 : {
8015 562586 : ROSE_ASSERT (this != NULL);
8016 562586 : return p_upcModifier;
8017 : }
8018 :
8019 : const SgStructureModifier &
8020 18273 : SgTypeModifier::get_structureModifier (void) const
8021 : {
8022 18273 : ROSE_ASSERT (this != NULL);
8023 18273 : return p_structureModifier;
8024 : }
8025 :
8026 : // RV (2/2/2006): Created this 'const' version of the member function.
8027 : const SgElaboratedTypeModifier &
8028 17049 : SgTypeModifier::get_elaboratedTypeModifier (void) const
8029 : {
8030 17049 : ROSE_ASSERT (this != NULL);
8031 17049 : return p_elaboratedTypeModifier;
8032 : }
8033 :
8034 :
8035 :
8036 : // End of memberFunctionString
8037 : // Start of memberFunctionString
8038 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
8039 :
8040 : // *** COMMON CODE SECTION BEGINS HERE ***
8041 :
8042 : #if 0
8043 : int
8044 : SgTypeModifier::getVariant() const
8045 : {
8046 : // This function is used in ROSE while "variant()" is used in SAGE
8047 : assert(this != NULL);
8048 : return variant();
8049 : }
8050 : #endif
8051 :
8052 : // This function is used in ROSE in treeTraversal code
8053 : // eventually replaces getVariant() and variant()
8054 : // though after variant() has been removed for a while we will
8055 : // want to change the name of variantT() back to variant()
8056 : // (since the "T" was ment to stand for temporary).
8057 : // When this happens the variantT() will be depricated.
8058 : VariantT
8059 15236000 : SgTypeModifier::variantT() const
8060 : {
8061 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
8062 15236000 : ROSE_ASSERT(this != NULL);
8063 15236000 : return V_SgTypeModifier;
8064 : }
8065 :
8066 : #if 0
8067 : int
8068 : SgTypeModifier::variant() const
8069 : {
8070 : // This function is used in SAGE
8071 : ROSE_ASSERT(this != NULL);
8072 : return TypeModifierTag;
8073 : }
8074 : #endif
8075 :
8076 : ROSE_DLL_API const char*
8077 0 : SgTypeModifier::sage_class_name() const
8078 : {
8079 0 : ROSE_ASSERT(this != NULL);
8080 0 : return "SgTypeModifier";
8081 : }
8082 :
8083 : std::string
8084 0 : SgTypeModifier::class_name() const
8085 : {
8086 0 : ROSE_ASSERT(this != NULL);
8087 0 : return "SgTypeModifier";
8088 : }
8089 :
8090 : // DQ (11/26/2005): Support for visitor pattern mechanims
8091 : // (inferior to ROSE traversal mechanism, experimental).
8092 : void
8093 0 : SgTypeModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
8094 : {
8095 0 : ROSE_ASSERT(this != NULL);
8096 0 : visitor.visit(this);
8097 0 : }
8098 :
8099 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
8100 0 : void SgTypeModifier::accept (ROSE_VisitorPattern & visitor) {
8101 0 : ROSE_ASSERT(this != NULL);
8102 0 : visitor.visit(this);
8103 0 : }
8104 :
8105 : SgTypeModifier*
8106 0 : SgTypeModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
8107 : {
8108 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
8109 : // This function is currently only supported for the AST used the represent Binary executables.
8110 : if (0 /* isSgAsmNode(this) != NULL */)
8111 : {
8112 : // Support for regex specification.
8113 : std::string prefixCode = "REGEX:";
8114 : addNewAttribute(prefixCode + s,a);
8115 : }
8116 : #endif
8117 :
8118 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
8119 0 : return this;
8120 : }
8121 :
8122 : // *** COMMON CODE SECTION ENDS HERE ***
8123 :
8124 :
8125 : // End of memberFunctionString
8126 : // Start of memberFunctionString
8127 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
8128 :
8129 :
8130 : #if 0
8131 : //! Error checking support
8132 : /*! Verifies the following:
8133 : - working getVariant() member function
8134 : - calls base class's error() member function
8135 : Every class has one of these functions.
8136 : */
8137 : bool
8138 : SgTypeModifier::error()
8139 : {
8140 : // Put error checking here
8141 :
8142 : ROSE_ASSERT (this != NULL);
8143 : if (getVariant() != TypeModifierTag)
8144 : {
8145 : printf ("Error in SgTypeModifier::error(): SgTypeModifier object has a %s variant \n",
8146 : Cxx_GrammarTerminalNames[getVariant()].name);
8147 : // printf ("Error in SgTypeModifier::error() \n");
8148 : ROSE_ABORT();
8149 : }
8150 :
8151 : ROSE_ASSERT (getVariant() == TypeModifierTag);
8152 : return SgModifier::error();
8153 : }
8154 : #endif
8155 :
8156 :
8157 :
8158 : // End of memberFunctionString
8159 :
8160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
8161 :
8162 5075890 : SgTypeModifier* isSgTypeModifier ( SgNode* inputDerivedClassPointer )
8163 : {
8164 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
8165 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
8166 : // So to fix this we return NULL directly when the input is NULL and avoid the
8167 : // dynamic_cast in this case. This is likely a performance improvement as well.
8168 : // return dynamic_cast<SgTypeModifier*>(inputDerivedClassPointer);
8169 : // Milind Chabbi (8/28/2013): isSgTypeModifier uses table-driven castability instead of c++ default dynamic_cast
8170 : // this improves the running time performance by 10-20%.
8171 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeModifier*>(inputDerivedClassPointer);
8172 5075890 : return IS_SgTypeModifier_FAST_MACRO(inputDerivedClassPointer);
8173 : }
8174 :
8175 : // DQ (11/8/2003): Added version of functions taking const pointer
8176 4189 : const SgTypeModifier* isSgTypeModifier ( const SgNode* inputDerivedClassPointer )
8177 : {
8178 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
8179 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
8180 : // So to fix this we return NULL directly when the input is NULL and avoid the
8181 : // dynamic_cast in this case. This is likely a performance improvement as well.
8182 : // return dynamic_cast<const SgTypeModifier*>(inputDerivedClassPointer);
8183 : // Milind Chabbi (8/28/2013): isSgTypeModifier uses table-driven castability instead of c++ default dynamic_cast
8184 : // this improves the running time performance by 10-20%.
8185 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeModifier*>(inputDerivedClassPointer);
8186 4189 : return IS_SgTypeModifier_FAST_MACRO(inputDerivedClassPointer);
8187 : }
8188 :
8189 :
8190 :
8191 : /* #line 8192 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
8192 :
8193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
8194 :
8195 : /**
8196 : \brief Generated destructor
8197 :
8198 : This destructor is automatically generated (by ROSETTA). This destructor
8199 : only frees memory of data members associated with the parts of the current IR node which
8200 : are NOT traversed. Those data members that are part of a traversal can be freed using
8201 : a traversal (calling this destructor on all children in a post-order traversal). Such
8202 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
8203 :
8204 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
8205 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
8206 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
8207 :
8208 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
8209 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
8210 : pointers are not yet implemented to call delete on eash pointer in the container.
8211 : (This could be done by derivation from the STL containers to define containers that
8212 : automatically deleted their members.)
8213 :
8214 : */
8215 1398620 : SgTypeModifier::~SgTypeModifier () {
8216 1398620 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
8217 :
8218 :
8219 : // case: not a listType for upcModifier
8220 1398620 : p_upcModifier .reset(); // non list case
8221 : // case: not a listType for structureModifier
8222 1398620 : p_structureModifier .reset(); // non list case
8223 : // case: not a listType for constVolatileModifier
8224 1398620 : p_constVolatileModifier .reset(); // non list case
8225 : // case: not a listType for elaboratedTypeModifier
8226 1398620 : p_elaboratedTypeModifier .reset(); // non list case
8227 : // case: not a listType for gnu_extension_machine_mode
8228 1398620 : p_gnu_extension_machine_mode = SgTypeModifier::e_gnu_extension_machine_mode_unspecified; // non list case
8229 : // case: not a listType for gnu_attribute_alignment
8230 1398620 : p_gnu_attribute_alignment = -1; // non list case
8231 : // case: not a listType for gnu_attribute_sentinel
8232 1398620 : p_gnu_attribute_sentinel = -1; // non list case
8233 : // case: not a listType for address_space_value
8234 1398620 : p_address_space_value = 0; // non list case
8235 : // case: not a listType for vector_size
8236 1398620 : p_vector_size = 1; // non list case
8237 :
8238 : }
8239 :
8240 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
8241 1398620 : }
8242 :
8243 :
8244 : /* #line 8245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
8245 :
8246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
8247 :
8248 : // Generated constructor
8249 5075890 : SgTypeModifier::SgTypeModifier ( )
8250 5075890 : : SgModifier()
8251 : {
8252 : #ifdef DEBUG
8253 : // printf ("In SgTypeModifier::SgTypeModifier () sage_class_name() = %s \n",sage_class_name());
8254 : #endif
8255 : #if 0
8256 : // debugging information!
8257 : printf ("In SgTypeModifier::SgTypeModifier (): this = %p = %s \n",this,this->class_name().c_str());
8258 : #endif
8259 :
8260 5075890 : p_upcModifier .reset();
8261 5075890 : p_structureModifier .reset();
8262 5075890 : p_constVolatileModifier .reset();
8263 5075890 : p_elaboratedTypeModifier .reset();
8264 5075890 : p_gnu_extension_machine_mode = SgTypeModifier::e_gnu_extension_machine_mode_unspecified;
8265 5075890 : p_gnu_attribute_alignment = -1;
8266 5075890 : p_gnu_attribute_sentinel = -1;
8267 5075890 : p_address_space_value = 0;
8268 5075890 : p_vector_size = 1;
8269 :
8270 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
8271 :
8272 : #if 0
8273 : // DQ (7/30/2014): Call a virtual function.
8274 : std::string s = this->class_name();
8275 : #endif
8276 :
8277 : // Test the variant virtual function
8278 : // assert(TypeModifierTag == variant());
8279 5075890 : assert(TypeModifierTag == this->variant());
8280 5075890 : ROSE_ASSERT(TypeModifierTag == (int)(this->variantT()));
8281 5075890 : post_construction_initialization();
8282 :
8283 : // Test the isSgTypeModifier() function since it has been problematic
8284 5075890 : assert(isSgTypeModifier(this) != NULL);
8285 5075890 : }
8286 :
8287 : // Generated constructor (all data members)
8288 :
8289 : /* #line 8290 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
8290 :
8291 :
8292 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
8293 :
8294 :
8295 : // ********************************************************
8296 : // member functions common across all array grammar objects
8297 : // ********************************************************
8298 :
8299 :
8300 :
8301 : /* #line 8302 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
8302 :
8303 :
8304 :
8305 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
8306 :
8307 : // ********************************************************
8308 : // member functions specific to each node in the grammar
8309 : // ********************************************************
8310 :
8311 :
8312 : /* #line 8313 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
8313 :
8314 : // Start of memberFunctionString
8315 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
8316 :
8317 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
8318 :
8319 : SgBitVector
8320 0 : SgDeclarationModifier::get_modifierVector () const
8321 : {
8322 0 : ROSE_ASSERT (this != NULL);
8323 :
8324 : #if 0
8325 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8326 : // used to trigger marking transformations for the token-based unparsing.
8327 : printf ("SgDeclarationModifier::get_modifierVector = %p = %s \n",this,this->class_name().c_str());
8328 : #endif
8329 :
8330 0 : return p_modifierVector;
8331 : }
8332 :
8333 : void
8334 0 : SgDeclarationModifier::set_modifierVector ( SgBitVector modifierVector )
8335 : {
8336 0 : ROSE_ASSERT (this != NULL);
8337 :
8338 : #if 0
8339 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8340 : // used to trigger marking transformations for the token-based unparsing.
8341 : printf ("SgDeclarationModifier::set_modifierVector = %p = %s \n",this,this->class_name().c_str());
8342 : #endif
8343 :
8344 0 : set_isModified(true);
8345 :
8346 0 : p_modifierVector = modifierVector;
8347 0 : }
8348 :
8349 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
8350 :
8351 :
8352 : // End of memberFunctionString
8353 : // Start of memberFunctionString
8354 :
8355 :
8356 : // End of memberFunctionString
8357 : // Start of memberFunctionString
8358 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
8359 :
8360 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
8361 :
8362 : std::string
8363 0 : SgDeclarationModifier::get_gnu_attribute_section_name () const
8364 : {
8365 0 : ROSE_ASSERT (this != NULL);
8366 :
8367 : #if 0
8368 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8369 : // used to trigger marking transformations for the token-based unparsing.
8370 : printf ("SgDeclarationModifier::get_gnu_attribute_section_name = %p = %s \n",this,this->class_name().c_str());
8371 : #endif
8372 :
8373 0 : return p_gnu_attribute_section_name;
8374 : }
8375 :
8376 : void
8377 0 : SgDeclarationModifier::set_gnu_attribute_section_name ( std::string gnu_attribute_section_name )
8378 : {
8379 0 : ROSE_ASSERT (this != NULL);
8380 :
8381 : #if 0
8382 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8383 : // used to trigger marking transformations for the token-based unparsing.
8384 : printf ("SgDeclarationModifier::set_gnu_attribute_section_name = %p = %s \n",this,this->class_name().c_str());
8385 : #endif
8386 :
8387 0 : set_isModified(true);
8388 :
8389 0 : p_gnu_attribute_section_name = gnu_attribute_section_name;
8390 0 : }
8391 :
8392 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
8393 :
8394 :
8395 : // End of memberFunctionString
8396 : // Start of memberFunctionString
8397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
8398 :
8399 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
8400 :
8401 : SgDeclarationModifier::gnu_declaration_visability_enum
8402 653 : SgDeclarationModifier::get_gnu_attribute_visability () const
8403 : {
8404 653 : ROSE_ASSERT (this != NULL);
8405 :
8406 : #if 0
8407 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8408 : // used to trigger marking transformations for the token-based unparsing.
8409 : printf ("SgDeclarationModifier::get_gnu_attribute_visability = %p = %s \n",this,this->class_name().c_str());
8410 : #endif
8411 :
8412 653 : return p_gnu_attribute_visability;
8413 : }
8414 :
8415 : void
8416 1196070 : SgDeclarationModifier::set_gnu_attribute_visability ( SgDeclarationModifier::gnu_declaration_visability_enum gnu_attribute_visability )
8417 : {
8418 1196070 : ROSE_ASSERT (this != NULL);
8419 :
8420 : #if 0
8421 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8422 : // used to trigger marking transformations for the token-based unparsing.
8423 : printf ("SgDeclarationModifier::set_gnu_attribute_visability = %p = %s \n",this,this->class_name().c_str());
8424 : #endif
8425 :
8426 1196070 : set_isModified(true);
8427 :
8428 1196070 : p_gnu_attribute_visability = gnu_attribute_visability;
8429 1196070 : }
8430 :
8431 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
8432 :
8433 :
8434 : // End of memberFunctionString
8435 : // Start of memberFunctionString
8436 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
8437 :
8438 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
8439 :
8440 : std::string
8441 0 : SgDeclarationModifier::get_microsoft_uuid_string () const
8442 : {
8443 0 : ROSE_ASSERT (this != NULL);
8444 :
8445 : #if 0
8446 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8447 : // used to trigger marking transformations for the token-based unparsing.
8448 : printf ("SgDeclarationModifier::get_microsoft_uuid_string = %p = %s \n",this,this->class_name().c_str());
8449 : #endif
8450 :
8451 0 : return p_microsoft_uuid_string;
8452 : }
8453 :
8454 : void
8455 0 : SgDeclarationModifier::set_microsoft_uuid_string ( std::string microsoft_uuid_string )
8456 : {
8457 0 : ROSE_ASSERT (this != NULL);
8458 :
8459 : #if 0
8460 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8461 : // used to trigger marking transformations for the token-based unparsing.
8462 : printf ("SgDeclarationModifier::set_microsoft_uuid_string = %p = %s \n",this,this->class_name().c_str());
8463 : #endif
8464 :
8465 0 : set_isModified(true);
8466 :
8467 0 : p_microsoft_uuid_string = microsoft_uuid_string;
8468 0 : }
8469 :
8470 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
8471 :
8472 :
8473 : // End of memberFunctionString
8474 : // Start of memberFunctionString
8475 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
8476 :
8477 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
8478 :
8479 : std::string
8480 0 : SgDeclarationModifier::get_microsoft_property_get_function_name () const
8481 : {
8482 0 : ROSE_ASSERT (this != NULL);
8483 :
8484 : #if 0
8485 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8486 : // used to trigger marking transformations for the token-based unparsing.
8487 : printf ("SgDeclarationModifier::get_microsoft_property_get_function_name = %p = %s \n",this,this->class_name().c_str());
8488 : #endif
8489 :
8490 0 : return p_microsoft_property_get_function_name;
8491 : }
8492 :
8493 : void
8494 0 : SgDeclarationModifier::set_microsoft_property_get_function_name ( std::string microsoft_property_get_function_name )
8495 : {
8496 0 : ROSE_ASSERT (this != NULL);
8497 :
8498 : #if 0
8499 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8500 : // used to trigger marking transformations for the token-based unparsing.
8501 : printf ("SgDeclarationModifier::set_microsoft_property_get_function_name = %p = %s \n",this,this->class_name().c_str());
8502 : #endif
8503 :
8504 0 : set_isModified(true);
8505 :
8506 0 : p_microsoft_property_get_function_name = microsoft_property_get_function_name;
8507 0 : }
8508 :
8509 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
8510 :
8511 :
8512 : // End of memberFunctionString
8513 : // Start of memberFunctionString
8514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
8515 :
8516 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
8517 :
8518 : std::string
8519 0 : SgDeclarationModifier::get_microsoft_property_put_function_name () const
8520 : {
8521 0 : ROSE_ASSERT (this != NULL);
8522 :
8523 : #if 0
8524 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8525 : // used to trigger marking transformations for the token-based unparsing.
8526 : printf ("SgDeclarationModifier::get_microsoft_property_put_function_name = %p = %s \n",this,this->class_name().c_str());
8527 : #endif
8528 :
8529 0 : return p_microsoft_property_put_function_name;
8530 : }
8531 :
8532 : void
8533 0 : SgDeclarationModifier::set_microsoft_property_put_function_name ( std::string microsoft_property_put_function_name )
8534 : {
8535 0 : ROSE_ASSERT (this != NULL);
8536 :
8537 : #if 0
8538 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
8539 : // used to trigger marking transformations for the token-based unparsing.
8540 : printf ("SgDeclarationModifier::set_microsoft_property_put_function_name = %p = %s \n",this,this->class_name().c_str());
8541 : #endif
8542 :
8543 0 : set_isModified(true);
8544 :
8545 0 : p_microsoft_property_put_function_name = microsoft_property_put_function_name;
8546 0 : }
8547 :
8548 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
8549 :
8550 :
8551 : // End of memberFunctionString
8552 : // Start of memberFunctionString
8553 : /* #line 3598 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
8554 :
8555 :
8556 : // Copy constructor
8557 37 : SgDeclarationModifier::SgDeclarationModifier ( const SgDeclarationModifier & X )
8558 : {
8559 37 : p_modifierVector = X.p_modifierVector;
8560 37 : p_typeModifier = X.p_typeModifier;
8561 37 : p_accessModifier = X.p_accessModifier;
8562 37 : p_storageModifier = X.p_storageModifier;
8563 37 : }
8564 :
8565 : SgDeclarationModifier &
8566 53874 : SgDeclarationModifier::operator= ( const SgDeclarationModifier & X )
8567 : {
8568 53874 : p_modifierVector = X.p_modifierVector;
8569 53874 : p_typeModifier = X.p_typeModifier;
8570 53874 : p_accessModifier = X.p_accessModifier;
8571 53874 : p_storageModifier = X.p_storageModifier;
8572 53874 : return *this;
8573 : }
8574 :
8575 : void
8576 4999170 : SgDeclarationModifier::post_construction_initialization()
8577 : {
8578 4999170 : p_modifierVector = SgBitVector(e_last_modifier,false);
8579 4999170 : setDefault();
8580 4999170 : }
8581 :
8582 2704 : bool SgDeclarationModifier::isUnknown() const { return checkBit(e_unknown,p_modifierVector); }
8583 0 : void SgDeclarationModifier::setUnknown() { setBit(e_unknown,p_modifierVector); }
8584 0 : void SgDeclarationModifier::unsetUnknown() { unsetBit(e_unknown,p_modifierVector); }
8585 :
8586 2778 : bool SgDeclarationModifier::isDefault() const { return checkBit(e_default,p_modifierVector); }
8587 4999170 : void SgDeclarationModifier::setDefault() { setBit(e_default,p_modifierVector); }
8588 1319780 : void SgDeclarationModifier::unsetDefault() { unsetBit(e_default,p_modifierVector); }
8589 :
8590 1512910 : bool SgDeclarationModifier::isFriend() const { return checkBit(e_friend,p_modifierVector); }
8591 1145 : void SgDeclarationModifier::setFriend() { setBit(e_friend,p_modifierVector); }
8592 0 : void SgDeclarationModifier::unsetFriend() { unsetBit(e_friend,p_modifierVector); }
8593 :
8594 2704 : bool SgDeclarationModifier::isTypedef() const { return checkBit(e_typedef,p_modifierVector); }
8595 0 : void SgDeclarationModifier::setTypedef() { setBit(e_typedef,p_modifierVector); }
8596 0 : void SgDeclarationModifier::unsetTypedef() { unsetBit(e_typedef,p_modifierVector); }
8597 :
8598 7278 : bool SgDeclarationModifier::isExport() const { return checkBit(e_export,p_modifierVector); }
8599 0 : void SgDeclarationModifier::setExport() { setBit(e_export,p_modifierVector); }
8600 0 : void SgDeclarationModifier::unsetExport() { unsetBit(e_export,p_modifierVector); }
8601 :
8602 13083 : bool SgDeclarationModifier::isThrow() const { return checkBit(e_throw,p_modifierVector); }
8603 8797 : void SgDeclarationModifier::setThrow() { setBit(e_throw,p_modifierVector); }
8604 0 : void SgDeclarationModifier::unsetThrow() { unsetBit(e_throw,p_modifierVector); }
8605 :
8606 2771 : bool SgDeclarationModifier::isBind() const { return checkBit(e_bind,p_modifierVector); }
8607 0 : void SgDeclarationModifier::setBind() { setBit(e_bind,p_modifierVector); }
8608 0 : void SgDeclarationModifier::unsetBind() { unsetBit(e_bind,p_modifierVector); }
8609 :
8610 3689 : bool SgDeclarationModifier::isFinal() const { return checkBit(e_final,p_modifierVector); }
8611 0 : void SgDeclarationModifier::setFinal() { setBit(e_final,p_modifierVector); }
8612 0 : void SgDeclarationModifier::unsetFinal() { unsetBit(e_final,p_modifierVector); }
8613 :
8614 : // DQ (8/11/2014): C++11 specific attribute
8615 357 : bool SgDeclarationModifier::isOverride() const { return checkBit(e_override,p_modifierVector); }
8616 0 : void SgDeclarationModifier::setOverride() { setBit(e_override,p_modifierVector); }
8617 0 : void SgDeclarationModifier::unsetOverride() { unsetBit(e_override,p_modifierVector); }
8618 :
8619 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8620 10749 : bool SgDeclarationModifier::is_ms_declspec_align() const { return checkBit(e_ms_declspec_align,p_modifierVector); }
8621 0 : void SgDeclarationModifier::set_ms_declspec_align() { setBit(e_ms_declspec_align,p_modifierVector); }
8622 0 : void SgDeclarationModifier::unset_ms_declspec_align() { unsetBit(e_ms_declspec_align,p_modifierVector); }
8623 :
8624 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8625 10749 : bool SgDeclarationModifier::is_ms_declspec_allocate() const { return checkBit(e_ms_declspec_allocate,p_modifierVector); }
8626 0 : void SgDeclarationModifier::set_ms_declspec_allocate() { setBit(e_ms_declspec_allocate,p_modifierVector); }
8627 0 : void SgDeclarationModifier::unset_ms_declspec_allocate() { unsetBit(e_ms_declspec_allocate,p_modifierVector); }
8628 :
8629 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8630 10749 : bool SgDeclarationModifier::is_ms_declspec_appdomain() const { return checkBit(e_ms_declspec_appdomain,p_modifierVector); }
8631 0 : void SgDeclarationModifier::set_ms_declspec_appdomain() { setBit(e_ms_declspec_appdomain,p_modifierVector); }
8632 0 : void SgDeclarationModifier::unset_ms_declspec_appdomain() { unsetBit(e_ms_declspec_appdomain,p_modifierVector); }
8633 :
8634 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8635 10749 : bool SgDeclarationModifier::is_ms_declspec_code_seg() const { return checkBit(e_ms_declspec_code_seg,p_modifierVector); }
8636 0 : void SgDeclarationModifier::set_ms_declspec_code_seg() { setBit(e_ms_declspec_code_seg,p_modifierVector); }
8637 0 : void SgDeclarationModifier::unset_ms_declspec_code_seg() { unsetBit(e_ms_declspec_code_seg,p_modifierVector); }
8638 :
8639 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8640 10749 : bool SgDeclarationModifier::is_ms_declspec_deprecated() const { return checkBit(e_ms_declspec_deprecated,p_modifierVector); }
8641 0 : void SgDeclarationModifier::set_ms_declspec_deprecated() { setBit(e_ms_declspec_deprecated,p_modifierVector); }
8642 0 : void SgDeclarationModifier::unset_ms_declspec_deprecated() { unsetBit(e_ms_declspec_deprecated,p_modifierVector); }
8643 :
8644 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8645 10749 : bool SgDeclarationModifier::is_ms_declspec_dllimport() const { return checkBit(e_ms_declspec_dllimport,p_modifierVector); }
8646 0 : void SgDeclarationModifier::set_ms_declspec_dllimport() { setBit(e_ms_declspec_dllimport,p_modifierVector); }
8647 0 : void SgDeclarationModifier::unset_ms_declspec_dllimport() { unsetBit(e_ms_declspec_dllimport,p_modifierVector); }
8648 :
8649 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8650 10749 : bool SgDeclarationModifier::is_ms_declspec_dllexport() const { return checkBit(e_ms_declspec_dllexport,p_modifierVector); }
8651 0 : void SgDeclarationModifier::set_ms_declspec_dllexport() { setBit(e_ms_declspec_dllexport,p_modifierVector); }
8652 0 : void SgDeclarationModifier::unset_ms_declspec_dllexport() { unsetBit(e_ms_declspec_dllexport,p_modifierVector); }
8653 :
8654 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8655 10749 : bool SgDeclarationModifier::is_ms_declspec_jitintrinsic() const { return checkBit(e_ms_declspec_jitintrinsic,p_modifierVector); }
8656 0 : void SgDeclarationModifier::set_ms_declspec_jitintrinsic() { setBit(e_ms_declspec_jitintrinsic,p_modifierVector); }
8657 0 : void SgDeclarationModifier::unset_ms_declspec_jitintrinsic() { unsetBit(e_ms_declspec_jitintrinsic,p_modifierVector); }
8658 :
8659 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8660 10749 : bool SgDeclarationModifier::is_ms_declspec_naked() const { return checkBit(e_ms_declspec_naked,p_modifierVector); }
8661 0 : void SgDeclarationModifier::set_ms_declspec_naked() { setBit(e_ms_declspec_naked,p_modifierVector); }
8662 0 : void SgDeclarationModifier::unset_ms_declspec_naked() { unsetBit(e_ms_declspec_naked,p_modifierVector); }
8663 :
8664 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8665 10749 : bool SgDeclarationModifier::is_ms_declspec_noalias() const { return checkBit(e_ms_declspec_noalias,p_modifierVector); }
8666 0 : void SgDeclarationModifier::set_ms_declspec_noalias() { setBit(e_ms_declspec_noalias,p_modifierVector); }
8667 0 : void SgDeclarationModifier::unset_ms_declspec_noalias() { unsetBit(e_ms_declspec_noalias,p_modifierVector); }
8668 :
8669 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8670 10749 : bool SgDeclarationModifier::is_ms_declspec_noinline() const { return checkBit(e_ms_declspec_noinline,p_modifierVector); }
8671 0 : void SgDeclarationModifier::set_ms_declspec_noinline() { setBit(e_ms_declspec_noinline,p_modifierVector); }
8672 0 : void SgDeclarationModifier::unset_ms_declspec_noinline() { unsetBit(e_ms_declspec_noinline,p_modifierVector); }
8673 :
8674 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8675 10749 : bool SgDeclarationModifier::is_ms_declspec_noreturn() const { return checkBit(e_ms_declspec_noreturn,p_modifierVector); }
8676 0 : void SgDeclarationModifier::set_ms_declspec_noreturn() { setBit(e_ms_declspec_noreturn,p_modifierVector); }
8677 0 : void SgDeclarationModifier::unset_ms_declspec_noreturn() { unsetBit(e_ms_declspec_noreturn,p_modifierVector); }
8678 :
8679 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8680 10749 : bool SgDeclarationModifier::is_ms_declspec_nothrow() const { return checkBit(e_ms_declspec_nothrow,p_modifierVector); }
8681 0 : void SgDeclarationModifier::set_ms_declspec_nothrow() { setBit(e_ms_declspec_nothrow,p_modifierVector); }
8682 0 : void SgDeclarationModifier::unset_ms_declspec_nothrow() { unsetBit(e_ms_declspec_nothrow,p_modifierVector); }
8683 :
8684 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8685 10749 : bool SgDeclarationModifier::is_ms_declspec_novtable() const { return checkBit(e_ms_declspec_novtable,p_modifierVector); }
8686 0 : void SgDeclarationModifier::set_ms_declspec_novtable() { setBit(e_ms_declspec_novtable,p_modifierVector); }
8687 0 : void SgDeclarationModifier::unset_ms_declspec_novtable() { unsetBit(e_ms_declspec_novtable,p_modifierVector); }
8688 :
8689 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8690 10749 : bool SgDeclarationModifier::is_ms_declspec_process() const { return checkBit(e_ms_declspec_process,p_modifierVector); }
8691 0 : void SgDeclarationModifier::set_ms_declspec_process() { setBit(e_ms_declspec_process,p_modifierVector); }
8692 0 : void SgDeclarationModifier::unset_ms_declspec_process() { unsetBit(e_ms_declspec_process,p_modifierVector); }
8693 :
8694 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8695 10749 : bool SgDeclarationModifier::is_ms_declspec_property() const { return checkBit(e_ms_declspec_property,p_modifierVector); }
8696 0 : void SgDeclarationModifier::set_ms_declspec_property() { setBit(e_ms_declspec_property,p_modifierVector); }
8697 0 : void SgDeclarationModifier::unset_ms_declspec_property() { unsetBit(e_ms_declspec_property,p_modifierVector); }
8698 :
8699 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8700 10749 : bool SgDeclarationModifier::is_ms_declspec_restrict() const { return checkBit(e_ms_declspec_restrict,p_modifierVector); }
8701 0 : void SgDeclarationModifier::set_ms_declspec_restrict() { setBit(e_ms_declspec_restrict,p_modifierVector); }
8702 0 : void SgDeclarationModifier::unset_ms_declspec_restrict() { unsetBit(e_ms_declspec_restrict,p_modifierVector); }
8703 :
8704 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8705 10749 : bool SgDeclarationModifier::is_ms_declspec_safebuffers() const { return checkBit(e_ms_declspec_safebuffers,p_modifierVector); }
8706 0 : void SgDeclarationModifier::set_ms_declspec_safebuffers() { setBit(e_ms_declspec_safebuffers,p_modifierVector); }
8707 0 : void SgDeclarationModifier::unset_ms_declspec_safebuffers() { unsetBit(e_ms_declspec_safebuffers,p_modifierVector); }
8708 :
8709 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8710 10749 : bool SgDeclarationModifier::is_ms_declspec_selectany() const { return checkBit(e_ms_declspec_selectany,p_modifierVector); }
8711 0 : void SgDeclarationModifier::set_ms_declspec_selectany() { setBit(e_ms_declspec_selectany,p_modifierVector); }
8712 0 : void SgDeclarationModifier::unset_ms_declspec_selectany() { unsetBit(e_ms_declspec_selectany,p_modifierVector); }
8713 :
8714 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8715 10749 : bool SgDeclarationModifier::is_ms_declspec_thread() const { return checkBit(e_ms_declspec_thread,p_modifierVector); }
8716 0 : void SgDeclarationModifier::set_ms_declspec_thread() { setBit(e_ms_declspec_thread,p_modifierVector); }
8717 0 : void SgDeclarationModifier::unset_ms_declspec_thread() { unsetBit(e_ms_declspec_thread,p_modifierVector); }
8718 :
8719 : // DQ (8/16/2014): Adding non-C++ standard Microsoft specific attributes.
8720 10749 : bool SgDeclarationModifier::is_ms_declspec_uuid() const { return checkBit(e_ms_declspec_uuid,p_modifierVector); }
8721 0 : void SgDeclarationModifier::set_ms_declspec_uuid() { setBit(e_ms_declspec_uuid,p_modifierVector); }
8722 0 : void SgDeclarationModifier::unset_ms_declspec_uuid() { unsetBit(e_ms_declspec_uuid,p_modifierVector); }
8723 :
8724 :
8725 :
8726 :
8727 :
8728 :
8729 : string
8730 2704 : SgDeclarationModifier::displayString() const
8731 : {
8732 2704 : std::string s = "SgDeclarationModifier(";
8733 10816 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
8734 9527 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
8735 10812 : s += std::string("isFriend() = ") + std::string(isFriend() ? "true " : "false ");
8736 10816 : s += std::string("isTypedef() = ") + std::string(isTypedef() ? "true " : "false ");
8737 10816 : s += std::string("isExport() = ") + std::string(isExport() ? "true " : "false ");
8738 10812 : s += std::string("isThrow() = ") + std::string(isThrow() ? "true " : "false ");
8739 10816 : s += std::string("isBind() = ") + std::string(isBind() ? "true " : "false ");
8740 10816 : s += std::string("isFinal() = ") + std::string(isFinal() ? "true " : "false ");
8741 8112 : s += std::string("\n ") + get_typeModifier().displayString() + " ";
8742 8112 : s += std::string("\n ") + get_accessModifier().displayString() + " ";
8743 8112 : s += std::string("\n ") + get_storageModifier().displayString();
8744 2704 : s += ")";
8745 2704 : return s;
8746 : }
8747 :
8748 : void
8749 0 : SgDeclarationModifier::display ( std::string label ) const
8750 : {
8751 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
8752 0 : printf ("In SgDeclarationModifier::display(%s) \n",label.c_str());
8753 0 : printf ("%s \n",displayString().c_str());
8754 0 : }
8755 :
8756 0 : std::ostream & operator<< ( std::ostream & os, const SgDeclarationModifier & m)
8757 : {
8758 0 : os << m.get_modifierVector();
8759 0 : return os;
8760 : }
8761 :
8762 0 : bool operator== (const SgDeclarationModifier& lhs, const SgDeclarationModifier& rhs)
8763 : {
8764 0 : return
8765 0 : (lhs.get_typeModifier() == rhs.get_typeModifier() ) &&
8766 0 : (lhs.get_accessModifier() == rhs.get_accessModifier() ) &&
8767 0 : (lhs.get_storageModifier() == rhs.get_storageModifier()) &&
8768 0 : (lhs.isUnknown() == rhs.isUnknown()) &&
8769 0 : (lhs.isDefault() == rhs.isDefault()) &&
8770 0 : (lhs.isFriend() == rhs.isFriend() ) &&
8771 0 : (lhs.isTypedef() == rhs.isTypedef()) &&
8772 0 : (lhs.isExport() == rhs.isExport() ) &&
8773 0 : (lhs.isThrow() == rhs.isThrow() ) &&
8774 0 : (lhs.isBind() == rhs.isBind() ) &&
8775 0 : (lhs.isFinal() == rhs.isFinal() ) &&
8776 0 : true;
8777 : }
8778 :
8779 : SgTypeModifier &
8780 2382320 : SgDeclarationModifier::get_typeModifier ()
8781 : {
8782 2382320 : ROSE_ASSERT (this != NULL);
8783 2382320 : return p_typeModifier;
8784 : }
8785 :
8786 : SgAccessModifier &
8787 17589800 : SgDeclarationModifier::get_accessModifier ()
8788 : {
8789 17589800 : ROSE_ASSERT (this != NULL);
8790 17589800 : return p_accessModifier;
8791 : }
8792 :
8793 : SgStorageModifier &
8794 4380360 : SgDeclarationModifier::get_storageModifier ()
8795 : {
8796 4380360 : ROSE_ASSERT (this != NULL);
8797 4380360 : return p_storageModifier;
8798 : }
8799 :
8800 : const SgTypeModifier &
8801 2704 : SgDeclarationModifier::get_typeModifier () const
8802 : {
8803 2704 : ROSE_ASSERT (this != NULL);
8804 2704 : return p_typeModifier;
8805 : }
8806 :
8807 : const SgAccessModifier &
8808 15941 : SgDeclarationModifier::get_accessModifier () const
8809 : {
8810 15941 : ROSE_ASSERT (this != NULL);
8811 15941 : return p_accessModifier;
8812 : }
8813 :
8814 : const SgStorageModifier &
8815 2165720 : SgDeclarationModifier::get_storageModifier () const
8816 : {
8817 2165720 : ROSE_ASSERT (this != NULL);
8818 2165720 : return p_storageModifier;
8819 : }
8820 :
8821 : // DQ (2/4/2006): Added mechamism to clear all bits
8822 : void
8823 0 : SgDeclarationModifier::reset()
8824 : {
8825 0 : unsetUnknown();
8826 0 : unsetFriend();
8827 0 : unsetTypedef();
8828 0 : unsetExport();
8829 0 : unsetThrow();
8830 0 : unsetBind();
8831 :
8832 : // Set this bit to indicate the default value (we want a value of all zero bits to be an error)
8833 0 : setDefault();
8834 :
8835 0 : get_typeModifier().reset();
8836 0 : get_accessModifier().reset();
8837 0 : get_storageModifier().reset();
8838 0 : }
8839 :
8840 :
8841 :
8842 : // End of memberFunctionString
8843 : // Start of memberFunctionString
8844 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
8845 :
8846 : // *** COMMON CODE SECTION BEGINS HERE ***
8847 :
8848 : #if 0
8849 : int
8850 : SgDeclarationModifier::getVariant() const
8851 : {
8852 : // This function is used in ROSE while "variant()" is used in SAGE
8853 : assert(this != NULL);
8854 : return variant();
8855 : }
8856 : #endif
8857 :
8858 : // This function is used in ROSE in treeTraversal code
8859 : // eventually replaces getVariant() and variant()
8860 : // though after variant() has been removed for a while we will
8861 : // want to change the name of variantT() back to variant()
8862 : // (since the "T" was ment to stand for temporary).
8863 : // When this happens the variantT() will be depricated.
8864 : VariantT
8865 14997500 : SgDeclarationModifier::variantT() const
8866 : {
8867 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
8868 14997500 : ROSE_ASSERT(this != NULL);
8869 14997500 : return V_SgDeclarationModifier;
8870 : }
8871 :
8872 : #if 0
8873 : int
8874 : SgDeclarationModifier::variant() const
8875 : {
8876 : // This function is used in SAGE
8877 : ROSE_ASSERT(this != NULL);
8878 : return DeclarationModifierTag;
8879 : }
8880 : #endif
8881 :
8882 : ROSE_DLL_API const char*
8883 0 : SgDeclarationModifier::sage_class_name() const
8884 : {
8885 0 : ROSE_ASSERT(this != NULL);
8886 0 : return "SgDeclarationModifier";
8887 : }
8888 :
8889 : std::string
8890 0 : SgDeclarationModifier::class_name() const
8891 : {
8892 0 : ROSE_ASSERT(this != NULL);
8893 0 : return "SgDeclarationModifier";
8894 : }
8895 :
8896 : // DQ (11/26/2005): Support for visitor pattern mechanims
8897 : // (inferior to ROSE traversal mechanism, experimental).
8898 : void
8899 0 : SgDeclarationModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
8900 : {
8901 0 : ROSE_ASSERT(this != NULL);
8902 0 : visitor.visit(this);
8903 0 : }
8904 :
8905 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
8906 0 : void SgDeclarationModifier::accept (ROSE_VisitorPattern & visitor) {
8907 0 : ROSE_ASSERT(this != NULL);
8908 0 : visitor.visit(this);
8909 0 : }
8910 :
8911 : SgDeclarationModifier*
8912 0 : SgDeclarationModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
8913 : {
8914 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
8915 : // This function is currently only supported for the AST used the represent Binary executables.
8916 : if (0 /* isSgAsmNode(this) != NULL */)
8917 : {
8918 : // Support for regex specification.
8919 : std::string prefixCode = "REGEX:";
8920 : addNewAttribute(prefixCode + s,a);
8921 : }
8922 : #endif
8923 :
8924 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
8925 0 : return this;
8926 : }
8927 :
8928 : // *** COMMON CODE SECTION ENDS HERE ***
8929 :
8930 :
8931 : // End of memberFunctionString
8932 : // Start of memberFunctionString
8933 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
8934 :
8935 :
8936 : #if 0
8937 : //! Error checking support
8938 : /*! Verifies the following:
8939 : - working getVariant() member function
8940 : - calls base class's error() member function
8941 : Every class has one of these functions.
8942 : */
8943 : bool
8944 : SgDeclarationModifier::error()
8945 : {
8946 : // Put error checking here
8947 :
8948 : ROSE_ASSERT (this != NULL);
8949 : if (getVariant() != DeclarationModifierTag)
8950 : {
8951 : printf ("Error in SgDeclarationModifier::error(): SgDeclarationModifier object has a %s variant \n",
8952 : Cxx_GrammarTerminalNames[getVariant()].name);
8953 : // printf ("Error in SgDeclarationModifier::error() \n");
8954 : ROSE_ABORT();
8955 : }
8956 :
8957 : ROSE_ASSERT (getVariant() == DeclarationModifierTag);
8958 : return SgModifier::error();
8959 : }
8960 : #endif
8961 :
8962 :
8963 :
8964 : // End of memberFunctionString
8965 :
8966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
8967 :
8968 4999170 : SgDeclarationModifier* isSgDeclarationModifier ( SgNode* inputDerivedClassPointer )
8969 : {
8970 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
8971 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
8972 : // So to fix this we return NULL directly when the input is NULL and avoid the
8973 : // dynamic_cast in this case. This is likely a performance improvement as well.
8974 : // return dynamic_cast<SgDeclarationModifier*>(inputDerivedClassPointer);
8975 : // Milind Chabbi (8/28/2013): isSgDeclarationModifier uses table-driven castability instead of c++ default dynamic_cast
8976 : // this improves the running time performance by 10-20%.
8977 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeclarationModifier*>(inputDerivedClassPointer);
8978 4999170 : return IS_SgDeclarationModifier_FAST_MACRO(inputDerivedClassPointer);
8979 : }
8980 :
8981 : // DQ (11/8/2003): Added version of functions taking const pointer
8982 0 : const SgDeclarationModifier* isSgDeclarationModifier ( const SgNode* inputDerivedClassPointer )
8983 : {
8984 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
8985 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
8986 : // So to fix this we return NULL directly when the input is NULL and avoid the
8987 : // dynamic_cast in this case. This is likely a performance improvement as well.
8988 : // return dynamic_cast<const SgDeclarationModifier*>(inputDerivedClassPointer);
8989 : // Milind Chabbi (8/28/2013): isSgDeclarationModifier uses table-driven castability instead of c++ default dynamic_cast
8990 : // this improves the running time performance by 10-20%.
8991 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeclarationModifier*>(inputDerivedClassPointer);
8992 0 : return IS_SgDeclarationModifier_FAST_MACRO(inputDerivedClassPointer);
8993 : }
8994 :
8995 :
8996 :
8997 : /* #line 8998 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
8998 :
8999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
9000 :
9001 : /**
9002 : \brief Generated destructor
9003 :
9004 : This destructor is automatically generated (by ROSETTA). This destructor
9005 : only frees memory of data members associated with the parts of the current IR node which
9006 : are NOT traversed. Those data members that are part of a traversal can be freed using
9007 : a traversal (calling this destructor on all children in a post-order traversal). Such
9008 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
9009 :
9010 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
9011 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
9012 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
9013 :
9014 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
9015 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
9016 : pointers are not yet implemented to call delete on eash pointer in the container.
9017 : (This could be done by derivation from the STL containers to define containers that
9018 : automatically deleted their members.)
9019 :
9020 : */
9021 1342000 : SgDeclarationModifier::~SgDeclarationModifier () {
9022 1342000 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
9023 :
9024 :
9025 : // case: not a listType for typeModifier
9026 1342000 : p_typeModifier .reset(); // non list case
9027 : // case: not a listType for accessModifier
9028 1342000 : p_accessModifier .reset(); // non list case
9029 : // case: not a listType for storageModifier
9030 1342000 : p_storageModifier .reset(); // non list case
9031 : // case: not a listType for gnu_attribute_section_name
9032 1342000 : p_gnu_attribute_section_name =""; // non list case
9033 : // case: not a listType for gnu_attribute_visability
9034 1342000 : p_gnu_attribute_visability = SgDeclarationModifier::e_unknown_visibility; // non list case
9035 : // case: not a listType for microsoft_uuid_string
9036 1342000 : p_microsoft_uuid_string =""; // non list case
9037 : // case: not a listType for microsoft_property_get_function_name
9038 1342000 : p_microsoft_property_get_function_name =""; // non list case
9039 : // case: not a listType for microsoft_property_put_function_name
9040 1342000 : p_microsoft_property_put_function_name =""; // non list case
9041 :
9042 : }
9043 :
9044 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
9045 1342000 : }
9046 :
9047 :
9048 : /* #line 9049 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9049 :
9050 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
9051 :
9052 : // Generated constructor
9053 4999170 : SgDeclarationModifier::SgDeclarationModifier ( )
9054 4999170 : : SgModifier()
9055 : {
9056 : #ifdef DEBUG
9057 : // printf ("In SgDeclarationModifier::SgDeclarationModifier () sage_class_name() = %s \n",sage_class_name());
9058 : #endif
9059 : #if 0
9060 : // debugging information!
9061 : printf ("In SgDeclarationModifier::SgDeclarationModifier (): this = %p = %s \n",this,this->class_name().c_str());
9062 : #endif
9063 :
9064 4999170 : p_typeModifier .reset();
9065 4999170 : p_accessModifier .reset();
9066 4999170 : p_storageModifier .reset();
9067 4999170 : p_gnu_attribute_section_name ="";
9068 4999170 : p_gnu_attribute_visability = SgDeclarationModifier::e_unknown_visibility;
9069 4999170 : p_microsoft_uuid_string ="";
9070 4999170 : p_microsoft_property_get_function_name ="";
9071 4999170 : p_microsoft_property_put_function_name ="";
9072 :
9073 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
9074 :
9075 : #if 0
9076 : // DQ (7/30/2014): Call a virtual function.
9077 : std::string s = this->class_name();
9078 : #endif
9079 :
9080 : // Test the variant virtual function
9081 : // assert(DeclarationModifierTag == variant());
9082 4999170 : assert(DeclarationModifierTag == this->variant());
9083 4999170 : ROSE_ASSERT(DeclarationModifierTag == (int)(this->variantT()));
9084 4999170 : post_construction_initialization();
9085 :
9086 : // Test the isSgDeclarationModifier() function since it has been problematic
9087 4999170 : assert(isSgDeclarationModifier(this) != NULL);
9088 4999170 : }
9089 :
9090 : // Generated constructor (all data members)
9091 :
9092 : /* #line 9093 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9093 :
9094 :
9095 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
9096 :
9097 :
9098 : // ********************************************************
9099 : // member functions common across all array grammar objects
9100 : // ********************************************************
9101 :
9102 :
9103 :
9104 : /* #line 9105 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9105 :
9106 :
9107 :
9108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
9109 :
9110 : // ********************************************************
9111 : // member functions specific to each node in the grammar
9112 : // ********************************************************
9113 :
9114 :
9115 : /* #line 9116 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9116 :
9117 : // Start of memberFunctionString
9118 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
9119 :
9120 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
9121 :
9122 : SgOpenclAccessModeModifier::access_mode_modifier_enum
9123 0 : SgOpenclAccessModeModifier::get_modifier () const
9124 : {
9125 0 : ROSE_ASSERT (this != NULL);
9126 :
9127 : #if 0
9128 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
9129 : // used to trigger marking transformations for the token-based unparsing.
9130 : printf ("SgOpenclAccessModeModifier::get_modifier = %p = %s \n",this,this->class_name().c_str());
9131 : #endif
9132 :
9133 0 : return p_modifier;
9134 : }
9135 :
9136 : void
9137 0 : SgOpenclAccessModeModifier::set_modifier ( SgOpenclAccessModeModifier::access_mode_modifier_enum modifier )
9138 : {
9139 0 : ROSE_ASSERT (this != NULL);
9140 :
9141 : #if 0
9142 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
9143 : // used to trigger marking transformations for the token-based unparsing.
9144 : printf ("SgOpenclAccessModeModifier::set_modifier = %p = %s \n",this,this->class_name().c_str());
9145 : #endif
9146 :
9147 0 : set_isModified(true);
9148 :
9149 0 : p_modifier = modifier;
9150 0 : }
9151 :
9152 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
9153 :
9154 :
9155 : // End of memberFunctionString
9156 : // Start of memberFunctionString
9157 : /* #line 22679 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
9158 :
9159 :
9160 : // Copy constructor
9161 0 : SgOpenclAccessModeModifier::SgOpenclAccessModeModifier ( const SgOpenclAccessModeModifier & X )
9162 : {
9163 0 : p_modifier = X.p_modifier;
9164 0 : }
9165 :
9166 : SgOpenclAccessModeModifier &
9167 0 : SgOpenclAccessModeModifier::operator= ( const SgOpenclAccessModeModifier & X )
9168 : {
9169 0 : p_modifier = X.p_modifier;
9170 0 : return *this;
9171 : }
9172 :
9173 : void
9174 0 : SgOpenclAccessModeModifier::post_construction_initialization()
9175 : {
9176 0 : p_modifier = e_default;
9177 0 : }
9178 :
9179 0 : bool SgOpenclAccessModeModifier::isUnknown() const { return p_modifier == e_unknown; }
9180 0 : void SgOpenclAccessModeModifier::setUnknown() { p_modifier = e_unknown; }
9181 :
9182 0 : bool SgOpenclAccessModeModifier::isDefault() const { return p_modifier == e_default; }
9183 0 : void SgOpenclAccessModeModifier::setDefault() { p_modifier = e_default; }
9184 :
9185 0 : bool SgOpenclAccessModeModifier::isReadOnly() const { return p_modifier == e_read_only; }
9186 0 : void SgOpenclAccessModeModifier::setReadOnly() { p_modifier = e_read_only; }
9187 :
9188 0 : bool SgOpenclAccessModeModifier::isWriteOnly() const { return p_modifier == e_write_only; }
9189 0 : void SgOpenclAccessModeModifier::setWriteOnly() { p_modifier = e_write_only; }
9190 :
9191 0 : bool SgOpenclAccessModeModifier::isReadWrite() const { return p_modifier == e_read_write; }
9192 0 : void SgOpenclAccessModeModifier::setReadWrite() { p_modifier = e_read_write; }
9193 :
9194 0 : std::ostream & operator<< ( std::ostream & os, const SgOpenclAccessModeModifier & m)
9195 : {
9196 0 : os << m.get_modifier();
9197 0 : return os;
9198 : }
9199 :
9200 : string
9201 0 : SgOpenclAccessModeModifier::displayString() const
9202 : {
9203 0 : std::string s = "SgOpenclAccessModeModifier(";
9204 0 : s += std::string("isUnknown() = ") + std::string(isUnknown() ? "true " : "false ");
9205 0 : s += std::string("isDefault() = ") + std::string(isDefault() ? "true " : "false ");
9206 0 : s += std::string("isReadOnly() = ") + std::string(isReadOnly() ? "true " : "false ");
9207 0 : s += std::string("isWriteOnly() = ") + std::string(isWriteOnly() ? "true " : "false ");
9208 0 : s += std::string("isReadWrite() = ") + std::string(isReadWrite() ? "true " : "false ");
9209 0 : s += ")";
9210 0 : return s;
9211 : }
9212 :
9213 : void
9214 0 : SgOpenclAccessModeModifier::display ( std::string label ) const
9215 : {
9216 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
9217 0 : printf ("In SgOpenclAccessModeModifier::display(%s) \n",label.c_str());
9218 0 : printf ("%s \n",displayString().c_str());
9219 0 : }
9220 :
9221 :
9222 :
9223 :
9224 : // End of memberFunctionString
9225 : // Start of memberFunctionString
9226 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
9227 :
9228 : // *** COMMON CODE SECTION BEGINS HERE ***
9229 :
9230 : #if 0
9231 : int
9232 : SgOpenclAccessModeModifier::getVariant() const
9233 : {
9234 : // This function is used in ROSE while "variant()" is used in SAGE
9235 : assert(this != NULL);
9236 : return variant();
9237 : }
9238 : #endif
9239 :
9240 : // This function is used in ROSE in treeTraversal code
9241 : // eventually replaces getVariant() and variant()
9242 : // though after variant() has been removed for a while we will
9243 : // want to change the name of variantT() back to variant()
9244 : // (since the "T" was ment to stand for temporary).
9245 : // When this happens the variantT() will be depricated.
9246 : VariantT
9247 0 : SgOpenclAccessModeModifier::variantT() const
9248 : {
9249 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
9250 0 : ROSE_ASSERT(this != NULL);
9251 0 : return V_SgOpenclAccessModeModifier;
9252 : }
9253 :
9254 : #if 0
9255 : int
9256 : SgOpenclAccessModeModifier::variant() const
9257 : {
9258 : // This function is used in SAGE
9259 : ROSE_ASSERT(this != NULL);
9260 : return OPENCL_ACCESS_MODE;
9261 : }
9262 : #endif
9263 :
9264 : ROSE_DLL_API const char*
9265 0 : SgOpenclAccessModeModifier::sage_class_name() const
9266 : {
9267 0 : ROSE_ASSERT(this != NULL);
9268 0 : return "SgOpenclAccessModeModifier";
9269 : }
9270 :
9271 : std::string
9272 0 : SgOpenclAccessModeModifier::class_name() const
9273 : {
9274 0 : ROSE_ASSERT(this != NULL);
9275 0 : return "SgOpenclAccessModeModifier";
9276 : }
9277 :
9278 : // DQ (11/26/2005): Support for visitor pattern mechanims
9279 : // (inferior to ROSE traversal mechanism, experimental).
9280 : void
9281 0 : SgOpenclAccessModeModifier::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
9282 : {
9283 0 : ROSE_ASSERT(this != NULL);
9284 0 : visitor.visit(this);
9285 0 : }
9286 :
9287 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
9288 0 : void SgOpenclAccessModeModifier::accept (ROSE_VisitorPattern & visitor) {
9289 0 : ROSE_ASSERT(this != NULL);
9290 0 : visitor.visit(this);
9291 0 : }
9292 :
9293 : SgOpenclAccessModeModifier*
9294 0 : SgOpenclAccessModeModifier::addRegExpAttribute(std::string s, AstRegExAttribute* a)
9295 : {
9296 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
9297 : // This function is currently only supported for the AST used the represent Binary executables.
9298 : if (0 /* isSgAsmNode(this) != NULL */)
9299 : {
9300 : // Support for regex specification.
9301 : std::string prefixCode = "REGEX:";
9302 : addNewAttribute(prefixCode + s,a);
9303 : }
9304 : #endif
9305 :
9306 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
9307 0 : return this;
9308 : }
9309 :
9310 : // *** COMMON CODE SECTION ENDS HERE ***
9311 :
9312 :
9313 : // End of memberFunctionString
9314 : // Start of memberFunctionString
9315 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
9316 :
9317 :
9318 : #if 0
9319 : //! Error checking support
9320 : /*! Verifies the following:
9321 : - working getVariant() member function
9322 : - calls base class's error() member function
9323 : Every class has one of these functions.
9324 : */
9325 : bool
9326 : SgOpenclAccessModeModifier::error()
9327 : {
9328 : // Put error checking here
9329 :
9330 : ROSE_ASSERT (this != NULL);
9331 : if (getVariant() != OPENCL_ACCESS_MODE)
9332 : {
9333 : printf ("Error in SgOpenclAccessModeModifier::error(): SgOpenclAccessModeModifier object has a %s variant \n",
9334 : Cxx_GrammarTerminalNames[getVariant()].name);
9335 : // printf ("Error in SgOpenclAccessModeModifier::error() \n");
9336 : ROSE_ABORT();
9337 : }
9338 :
9339 : ROSE_ASSERT (getVariant() == OPENCL_ACCESS_MODE);
9340 : return SgModifier::error();
9341 : }
9342 : #endif
9343 :
9344 :
9345 :
9346 : // End of memberFunctionString
9347 :
9348 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
9349 :
9350 0 : SgOpenclAccessModeModifier* isSgOpenclAccessModeModifier ( SgNode* inputDerivedClassPointer )
9351 : {
9352 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
9353 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
9354 : // So to fix this we return NULL directly when the input is NULL and avoid the
9355 : // dynamic_cast in this case. This is likely a performance improvement as well.
9356 : // return dynamic_cast<SgOpenclAccessModeModifier*>(inputDerivedClassPointer);
9357 : // Milind Chabbi (8/28/2013): isSgOpenclAccessModeModifier uses table-driven castability instead of c++ default dynamic_cast
9358 : // this improves the running time performance by 10-20%.
9359 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOpenclAccessModeModifier*>(inputDerivedClassPointer);
9360 0 : return IS_SgOpenclAccessModeModifier_FAST_MACRO(inputDerivedClassPointer);
9361 : }
9362 :
9363 : // DQ (11/8/2003): Added version of functions taking const pointer
9364 0 : const SgOpenclAccessModeModifier* isSgOpenclAccessModeModifier ( const SgNode* inputDerivedClassPointer )
9365 : {
9366 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
9367 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
9368 : // So to fix this we return NULL directly when the input is NULL and avoid the
9369 : // dynamic_cast in this case. This is likely a performance improvement as well.
9370 : // return dynamic_cast<const SgOpenclAccessModeModifier*>(inputDerivedClassPointer);
9371 : // Milind Chabbi (8/28/2013): isSgOpenclAccessModeModifier uses table-driven castability instead of c++ default dynamic_cast
9372 : // this improves the running time performance by 10-20%.
9373 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOpenclAccessModeModifier*>(inputDerivedClassPointer);
9374 0 : return IS_SgOpenclAccessModeModifier_FAST_MACRO(inputDerivedClassPointer);
9375 : }
9376 :
9377 :
9378 :
9379 : /* #line 9380 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9380 :
9381 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
9382 :
9383 : /**
9384 : \brief Generated destructor
9385 :
9386 : This destructor is automatically generated (by ROSETTA). This destructor
9387 : only frees memory of data members associated with the parts of the current IR node which
9388 : are NOT traversed. Those data members that are part of a traversal can be freed using
9389 : a traversal (calling this destructor on all children in a post-order traversal). Such
9390 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
9391 :
9392 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
9393 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
9394 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
9395 :
9396 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
9397 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
9398 : pointers are not yet implemented to call delete on eash pointer in the container.
9399 : (This could be done by derivation from the STL containers to define containers that
9400 : automatically deleted their members.)
9401 :
9402 : */
9403 0 : SgOpenclAccessModeModifier::~SgOpenclAccessModeModifier () {
9404 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
9405 :
9406 :
9407 : // case: not a listType for modifier
9408 0 : p_modifier = SgOpenclAccessModeModifier::e_unknown; // non list case
9409 :
9410 : }
9411 :
9412 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
9413 0 : }
9414 :
9415 :
9416 : /* #line 9417 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9417 :
9418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
9419 :
9420 : // Generated constructor
9421 0 : SgOpenclAccessModeModifier::SgOpenclAccessModeModifier ( )
9422 0 : : SgModifier()
9423 : {
9424 : #ifdef DEBUG
9425 : // printf ("In SgOpenclAccessModeModifier::SgOpenclAccessModeModifier () sage_class_name() = %s \n",sage_class_name());
9426 : #endif
9427 : #if 0
9428 : // debugging information!
9429 : printf ("In SgOpenclAccessModeModifier::SgOpenclAccessModeModifier (): this = %p = %s \n",this,this->class_name().c_str());
9430 : #endif
9431 :
9432 0 : p_modifier = SgOpenclAccessModeModifier::e_unknown;
9433 :
9434 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
9435 :
9436 : #if 0
9437 : // DQ (7/30/2014): Call a virtual function.
9438 : std::string s = this->class_name();
9439 : #endif
9440 :
9441 : // Test the variant virtual function
9442 : // assert(OPENCL_ACCESS_MODE == variant());
9443 0 : assert(OPENCL_ACCESS_MODE == this->variant());
9444 0 : ROSE_ASSERT(OPENCL_ACCESS_MODE == (int)(this->variantT()));
9445 0 : post_construction_initialization();
9446 :
9447 : // Test the isSgOpenclAccessModeModifier() function since it has been problematic
9448 0 : assert(isSgOpenclAccessModeModifier(this) != NULL);
9449 0 : }
9450 :
9451 : // Generated constructor (all data members)
9452 :
9453 : /* #line 9454 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9454 :
9455 :
9456 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
9457 :
9458 :
9459 : // ********************************************************
9460 : // member functions common across all array grammar objects
9461 : // ********************************************************
9462 :
9463 :
9464 :
9465 : /* #line 9466 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9466 :
9467 :
9468 :
9469 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
9470 :
9471 : // ********************************************************
9472 : // member functions specific to each node in the grammar
9473 : // ********************************************************
9474 :
9475 :
9476 : /* #line 9477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9477 :
9478 : // Start of memberFunctionString
9479 :
9480 :
9481 : // End of memberFunctionString
9482 : // Start of memberFunctionString
9483 : /* #line 13317 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
9484 :
9485 :
9486 : #if 0
9487 : // DQ (4/21/2020): operator related functions that we declare in the
9488 : // header file and need to support with function definitions.
9489 :
9490 : X SgName();
9491 : X SgName(const char* str);
9492 : X SgName(const std::string& str);
9493 : X SgName(const SgName& n);
9494 :
9495 : X int operator!=(const SgName& n1) const;
9496 : X int operator==(const SgName& n1) const;
9497 : X int operator< (const SgName& n1) const;
9498 :
9499 : // DQ (4/21/2020): I think this might be used but not defined.
9500 : // Added to support assignments to string variables.
9501 : operator std::string () const;
9502 :
9503 : X SgName& operator<<(const std::string& str);
9504 :
9505 : X SgName& operator<<(int val);
9506 : SgName& operator=(const SgName& n1);
9507 :
9508 : X bool operator== (const int) const { return false; }
9509 :
9510 : // DQ (9/9/2004): friend function (string concatination)
9511 : X ROSE_DLL_API friend SgName operator+(const SgName & n1, const SgName & n2);
9512 :
9513 : // DQ (11/15/2004): Added to support general string operations (first used in the unparser)
9514 : X SgName & operator+= (const SgName & n1);
9515 : #endif
9516 :
9517 :
9518 : // Added to support assignments to string variables.
9519 8223330 : SgName::operator std::string () const
9520 : {
9521 8223330 : return p_char;
9522 : }
9523 :
9524 : // DQ (10/5/2007): We no longer need this!
9525 : // Definition of defaultName (use a default parameter)
9526 : // const SgName SgdefaultName("defaultName");
9527 :
9528 54816900 : SgName::SgName()
9529 54816900 : : p_char("")
9530 54816900 : { }
9531 :
9532 : unsigned int
9533 12438400 : SgName::get_length() const
9534 : {
9535 12438400 : assert(this != NULL);
9536 12438400 : return p_char.size();
9537 : }
9538 :
9539 238125000 : SgName::SgName(const char * str): p_char(str ? str : "")
9540 : {
9541 : // Nothing to do here!
9542 234298000 : }
9543 :
9544 : // DQ (9/9/2004): Added support for conversion of strings to SgName
9545 : // I always wanted this and it was a pain that it didn't exist previously!
9546 167121000 : SgName::SgName(const std::string & str): p_char(str) {}
9547 :
9548 : #if 0
9549 : SgName::SgName(const std::string & str)
9550 : {
9551 : // DQ (2/22/2019): Old version of code ": p_char(str) {}"
9552 : p_char = "";
9553 : if (str.empty() == false)
9554 : {
9555 : p_char = str;
9556 : }
9557 : }
9558 : #endif
9559 :
9560 55147500 : SgName::SgName(const SgName& n): p_char(n.p_char)
9561 : {
9562 : #if 0
9563 : // DQ (1/25/2011): Added check...plus message...
9564 : if (p_char.empty() == true)
9565 : {
9566 : mprintf ("WARNING: SgName copy constructor called for empty string \n");
9567 : }
9568 : else
9569 : {
9570 : mprintf ("In SgName copy constructor name = %s \n",p_char.c_str());
9571 : }
9572 : #endif
9573 55147500 : }
9574 :
9575 : // SgName::SgName(const char *str, int n): p_char(str, n) {} // get first n chars in the string
9576 :
9577 : int
9578 303548 : SgName::operator!=(const SgName& n1) const
9579 : {
9580 303548 : assert(this != NULL);
9581 303548 : return p_char != n1.p_char;
9582 : }
9583 :
9584 : int
9585 61202300 : SgName::operator==(const SgName& n1) const
9586 : {
9587 61202300 : assert(this != NULL);
9588 :
9589 61202300 : return p_char == n1.p_char;
9590 : }
9591 :
9592 : #ifdef _MSC_VER
9593 : #define strncasecmp _strnicmp
9594 : #endif
9595 : // DQ (11/27/2010): Added support for case insensitive name matching.
9596 : bool
9597 11059 : SgName::caseInsensitiveEquality ( const SgName & x, const SgName & y )
9598 : {
9599 : // This function checks a case insensitive match of x against y.
9600 : // This is required because Fortran is case insensitive.
9601 :
9602 11059 : size_t x_length = x.p_char.length();
9603 11059 : size_t y_length = y.p_char.length();
9604 :
9605 11059 : return (x_length == y_length) ? strncasecmp(x.p_char.c_str(),y.p_char.c_str(),x_length) == 0 : false;
9606 : }
9607 :
9608 :
9609 : int
9610 0 : SgName::operator<(const SgName& n1) const
9611 : {
9612 0 : assert(this != NULL);
9613 :
9614 0 : return p_char < n1.p_char;
9615 : }
9616 :
9617 : bool
9618 9880800 : SgName::is_null(void) const
9619 : {
9620 9880800 : assert(this != NULL);
9621 9880800 : return p_char.empty();
9622 : }
9623 :
9624 : void
9625 0 : SgName::replace_space(char t)
9626 : {
9627 0 : assert(this != NULL);
9628 :
9629 0 : int len = p_char.size();
9630 0 : for(int i=0; i < len; i++)
9631 : {
9632 : // if last one
9633 0 : if(p_char[i]==' ')
9634 : {
9635 0 : if(i==len-1)
9636 0 : p_char.resize(p_char.size() - 1);
9637 : else
9638 0 : p_char[i]=t;
9639 : }
9640 : }
9641 0 : }
9642 :
9643 : SgName&
9644 30822000 : SgName::operator<<(const std::string& str)
9645 : {
9646 30822000 : assert (this != NULL);
9647 :
9648 30822000 : p_char += str;
9649 30822000 : return *this;
9650 : }
9651 :
9652 : SgName
9653 2 : SgName::itoname(int val)
9654 : {
9655 2 : std::ostringstream os;
9656 2 : os << val;
9657 4 : return SgName(os.str());
9658 : }
9659 :
9660 : SgName&
9661 2 : SgName::operator<<(int val)
9662 : {
9663 2 : assert(this != NULL);
9664 :
9665 2 : SgName str = itoname(val);
9666 2 : p_char += str.p_char;
9667 2 : return *this;
9668 : }
9669 :
9670 : SgName&
9671 66447800 : SgName::operator=(const SgName& n1)
9672 : {
9673 66447800 : assert(this != NULL);
9674 66447800 : this->p_char = n1.p_char;
9675 66447800 : return *this;
9676 : }
9677 :
9678 : SgName&
9679 0 : SgName::tail(int n) // keep string after n
9680 : {
9681 0 : assert(this != NULL);
9682 0 : p_char = (unsigned int)n >= p_char.size() ? "" : p_char.substr(n);
9683 0 : return *this;
9684 : }
9685 :
9686 : SgName&
9687 107 : SgName::head(int n) // keep first n chars
9688 : {
9689 107 : assert(this != NULL);
9690 165 : p_char = (unsigned int)n >= p_char.size() ? p_char : p_char.substr(0, n);
9691 107 : return *this;
9692 : }
9693 :
9694 81082800 : const char* SgName::str() const {
9695 81082800 : assert(this != NULL);
9696 81082800 : return p_char.c_str();
9697 : }
9698 :
9699 : std::string&
9700 13414000 : SgName::getString()
9701 : {
9702 13414000 : assert(this != NULL);
9703 13414000 : return p_char;
9704 : }
9705 :
9706 : const std::string&
9707 9036930 : SgName::getString() const
9708 : {
9709 9036930 : assert(this != NULL);
9710 9036930 : return p_char;
9711 : }
9712 :
9713 :
9714 0 : void SgName::display( const std::string& label ) const
9715 : {
9716 0 : assert(this != NULL);
9717 :
9718 0 : std::cout << label << ": " << p_char << "\n";
9719 0 : }
9720 :
9721 : // DQ (9/9/2004): friend function
9722 : SgName
9723 27389400 : operator+(const SgName & n1, const SgName & n2)
9724 : {
9725 54778800 : return SgName(n1.p_char + n2.p_char);
9726 : }
9727 :
9728 : // DQ (11/15/2004): Added to support general string operations (first used in the unparser)
9729 : SgName &
9730 7583460 : SgName::operator+= (const SgName & n1)
9731 : {
9732 7583460 : assert(this != NULL);
9733 7583460 : p_char += n1.p_char;
9734 7583460 : return *this;
9735 : }
9736 :
9737 : SgName
9738 239870 : SgName::assembleQualifiedName(const SgName & scopeQualifiedName, const SgName & localName)
9739 : {
9740 : // DQ (22/2005): Neede to add global scope specifier to handle some pathological cases (see test2005_144.C).
9741 : // DQ (9/9/2004): Supporting function for building qualified names (specialied string concatination)
9742 : // Previous code caused "::" to be inserted too often (e.g. where scope->get_qualified_name() was empty, as in global scope)
9743 : // returnName = scope->get_qualified_name() << "::" << get_name().str();
9744 :
9745 : // DQ (9/9/2004): We can't assert this since "" evaluates to is_null() being true!
9746 : // assert(scopeQualifiedName.is_null() == false);
9747 :
9748 239870 : SgName returnName;
9749 : // DQ (9/9/2004): So these are redundent tests! (which was pleasant news to me!)
9750 : // if ( (scopeQualifiedName.is_null() == true) || (scopeQualifiedName == "") )
9751 239870 : if ( (scopeQualifiedName.is_null() == true) || (scopeQualifiedName.getString() == "") )
9752 : {
9753 826 : returnName = localName;
9754 : #if 0
9755 : // DQ (11/29/2004): It seems that any assignment of "" to a SgName forces it to be evaluated so that is_null() == true
9756 : // DQ (11/29/2004): Added checking for is_null() so that returnName would always be a valid name
9757 : if (localName.is_null() == true)
9758 : returnName = "";
9759 : else
9760 : returnName = localName;
9761 : #endif
9762 : }
9763 : else
9764 : {
9765 478088 : std::string scopeDelimiter;
9766 239044 : scopeDelimiter = "::";
9767 :
9768 : // Trap out the case of global scope to avoid building "::::"
9769 239044 : if ( scopeQualifiedName == scopeDelimiter )
9770 : {
9771 : // Avoid building "::::"
9772 215983 : returnName = scopeQualifiedName.getString() + localName.getString();
9773 : }
9774 : else
9775 : {
9776 141608 : returnName = scopeQualifiedName.getString() + scopeDelimiter + localName.getString();
9777 : }
9778 : }
9779 :
9780 : // returnName = scopeQualifiedName << "::" << localName.str();
9781 : // assert(returnName.is_null() == false);
9782 :
9783 239870 : return returnName;
9784 : }
9785 :
9786 : SgName
9787 401 : SgName::invertCase() const
9788 : {
9789 401 : string s = p_char;
9790 :
9791 401 : char* str = &(s[0]);
9792 6356 : while(*str)
9793 : {
9794 5955 : if(isupper(*str))
9795 16 : *str = tolower(*str);
9796 : else
9797 5939 : if(islower(*str))
9798 5070 : *str = toupper(*str);
9799 5955 : str++;
9800 : }
9801 :
9802 : // mprintf ("In SgName::invertCase() s = %s return_name = %s \n",this->str(),s.c_str());
9803 :
9804 802 : return s;
9805 : }
9806 :
9807 :
9808 :
9809 :
9810 :
9811 : // End of memberFunctionString
9812 : // Start of memberFunctionString
9813 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
9814 :
9815 : // *** COMMON CODE SECTION BEGINS HERE ***
9816 :
9817 : #if 0
9818 : int
9819 : SgName::getVariant() const
9820 : {
9821 : // This function is used in ROSE while "variant()" is used in SAGE
9822 : assert(this != NULL);
9823 : return variant();
9824 : }
9825 : #endif
9826 :
9827 : // This function is used in ROSE in treeTraversal code
9828 : // eventually replaces getVariant() and variant()
9829 : // though after variant() has been removed for a while we will
9830 : // want to change the name of variantT() back to variant()
9831 : // (since the "T" was ment to stand for temporary).
9832 : // When this happens the variantT() will be depricated.
9833 : VariantT
9834 431 : SgName::variantT() const
9835 : {
9836 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
9837 431 : ROSE_ASSERT(this != NULL);
9838 431 : return V_SgName;
9839 : }
9840 :
9841 : #if 0
9842 : int
9843 : SgName::variant() const
9844 : {
9845 : // This function is used in SAGE
9846 : ROSE_ASSERT(this != NULL);
9847 : return NameTag;
9848 : }
9849 : #endif
9850 :
9851 : ROSE_DLL_API const char*
9852 0 : SgName::sage_class_name() const
9853 : {
9854 0 : ROSE_ASSERT(this != NULL);
9855 0 : return "SgName";
9856 : }
9857 :
9858 : std::string
9859 28 : SgName::class_name() const
9860 : {
9861 28 : ROSE_ASSERT(this != NULL);
9862 28 : return "SgName";
9863 : }
9864 :
9865 : // DQ (11/26/2005): Support for visitor pattern mechanims
9866 : // (inferior to ROSE traversal mechanism, experimental).
9867 : void
9868 0 : SgName::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
9869 : {
9870 0 : ROSE_ASSERT(this != NULL);
9871 0 : visitor.visit(this);
9872 0 : }
9873 :
9874 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
9875 0 : void SgName::accept (ROSE_VisitorPattern & visitor) {
9876 0 : ROSE_ASSERT(this != NULL);
9877 0 : visitor.visit(this);
9878 0 : }
9879 :
9880 : SgName*
9881 0 : SgName::addRegExpAttribute(std::string s, AstRegExAttribute* a)
9882 : {
9883 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
9884 : // This function is currently only supported for the AST used the represent Binary executables.
9885 : if (0 /* isSgAsmNode(this) != NULL */)
9886 : {
9887 : // Support for regex specification.
9888 : std::string prefixCode = "REGEX:";
9889 : addNewAttribute(prefixCode + s,a);
9890 : }
9891 : #endif
9892 :
9893 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
9894 0 : return this;
9895 : }
9896 :
9897 : // *** COMMON CODE SECTION ENDS HERE ***
9898 :
9899 :
9900 : // End of memberFunctionString
9901 : // Start of memberFunctionString
9902 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
9903 :
9904 :
9905 : #if 0
9906 : //! Error checking support
9907 : /*! Verifies the following:
9908 : - working getVariant() member function
9909 : - calls base class's error() member function
9910 : Every class has one of these functions.
9911 : */
9912 : bool
9913 : SgName::error()
9914 : {
9915 : // Put error checking here
9916 :
9917 : ROSE_ASSERT (this != NULL);
9918 : if (getVariant() != NameTag)
9919 : {
9920 : printf ("Error in SgName::error(): SgName object has a %s variant \n",
9921 : Cxx_GrammarTerminalNames[getVariant()].name);
9922 : // printf ("Error in SgName::error() \n");
9923 : ROSE_ABORT();
9924 : }
9925 :
9926 : ROSE_ASSERT (getVariant() == NameTag);
9927 : return SgSupport::error();
9928 : }
9929 : #endif
9930 :
9931 :
9932 :
9933 : // End of memberFunctionString
9934 :
9935 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
9936 :
9937 21 : SgName* isSgName ( SgNode* inputDerivedClassPointer )
9938 : {
9939 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
9940 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
9941 : // So to fix this we return NULL directly when the input is NULL and avoid the
9942 : // dynamic_cast in this case. This is likely a performance improvement as well.
9943 : // return dynamic_cast<SgName*>(inputDerivedClassPointer);
9944 : // Milind Chabbi (8/28/2013): isSgName uses table-driven castability instead of c++ default dynamic_cast
9945 : // this improves the running time performance by 10-20%.
9946 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgName*>(inputDerivedClassPointer);
9947 21 : return IS_SgName_FAST_MACRO(inputDerivedClassPointer);
9948 : }
9949 :
9950 : // DQ (11/8/2003): Added version of functions taking const pointer
9951 0 : const SgName* isSgName ( const SgNode* inputDerivedClassPointer )
9952 : {
9953 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
9954 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
9955 : // So to fix this we return NULL directly when the input is NULL and avoid the
9956 : // dynamic_cast in this case. This is likely a performance improvement as well.
9957 : // return dynamic_cast<const SgName*>(inputDerivedClassPointer);
9958 : // Milind Chabbi (8/28/2013): isSgName uses table-driven castability instead of c++ default dynamic_cast
9959 : // this improves the running time performance by 10-20%.
9960 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgName*>(inputDerivedClassPointer);
9961 0 : return IS_SgName_FAST_MACRO(inputDerivedClassPointer);
9962 : }
9963 :
9964 :
9965 :
9966 : /* #line 9967 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
9967 :
9968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
9969 :
9970 : /**
9971 : \brief Generated destructor
9972 :
9973 : This destructor is automatically generated (by ROSETTA). This destructor
9974 : only frees memory of data members associated with the parts of the current IR node which
9975 : are NOT traversed. Those data members that are part of a traversal can be freed using
9976 : a traversal (calling this destructor on all children in a post-order traversal). Such
9977 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
9978 :
9979 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
9980 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
9981 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
9982 :
9983 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
9984 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
9985 : pointers are not yet implemented to call delete on eash pointer in the container.
9986 : (This could be done by derivation from the STL containers to define containers that
9987 : automatically deleted their members.)
9988 :
9989 : */
9990 416292000 : SgName::~SgName () {
9991 416292000 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
9992 :
9993 :
9994 : // case: not a listType for char
9995 416292000 : p_char = ""; // non list case
9996 :
9997 : }
9998 :
9999 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
10000 416292000 : }
10001 :
10002 :
10003 : /* #line 10004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
10004 :
10005 :
10006 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
10007 :
10008 :
10009 : // ********************************************************
10010 : // member functions common across all array grammar objects
10011 : // ********************************************************
10012 :
10013 :
10014 :
10015 : /* #line 10016 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
10016 :
10017 :
10018 :
10019 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
10020 :
10021 : // ********************************************************
10022 : // member functions specific to each node in the grammar
10023 : // ********************************************************
10024 :
10025 :
10026 : /* #line 10027 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
10027 :
10028 : // Start of memberFunctionString
10029 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
10030 :
10031 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
10032 :
10033 : SgName
10034 20 : SgSymbolTable::get_name () const
10035 : {
10036 20 : ROSE_ASSERT (this != NULL);
10037 :
10038 : #if 0
10039 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10040 : // used to trigger marking transformations for the token-based unparsing.
10041 : printf ("SgSymbolTable::get_name = %p = %s \n",this,this->class_name().c_str());
10042 : #endif
10043 :
10044 20 : return p_name;
10045 : }
10046 :
10047 : void
10048 0 : SgSymbolTable::set_name ( SgName name )
10049 : {
10050 0 : ROSE_ASSERT (this != NULL);
10051 :
10052 : #if 0
10053 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10054 : // used to trigger marking transformations for the token-based unparsing.
10055 : printf ("SgSymbolTable::set_name = %p = %s \n",this,this->class_name().c_str());
10056 : #endif
10057 :
10058 0 : set_isModified(true);
10059 :
10060 0 : p_name = name;
10061 0 : }
10062 :
10063 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
10064 :
10065 :
10066 : // End of memberFunctionString
10067 : // Start of memberFunctionString
10068 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
10069 :
10070 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
10071 :
10072 : bool
10073 28 : SgSymbolTable::get_no_name () const
10074 : {
10075 28 : ROSE_ASSERT (this != NULL);
10076 :
10077 : #if 0
10078 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10079 : // used to trigger marking transformations for the token-based unparsing.
10080 : printf ("SgSymbolTable::get_no_name = %p = %s \n",this,this->class_name().c_str());
10081 : #endif
10082 :
10083 28 : return p_no_name;
10084 : }
10085 :
10086 : void
10087 0 : SgSymbolTable::set_no_name ( bool no_name )
10088 : {
10089 0 : ROSE_ASSERT (this != NULL);
10090 :
10091 : #if 0
10092 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10093 : // used to trigger marking transformations for the token-based unparsing.
10094 : printf ("SgSymbolTable::set_no_name = %p = %s \n",this,this->class_name().c_str());
10095 : #endif
10096 :
10097 0 : set_isModified(true);
10098 :
10099 0 : p_no_name = no_name;
10100 0 : }
10101 :
10102 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
10103 :
10104 :
10105 : // End of memberFunctionString
10106 : // Start of memberFunctionString
10107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
10108 :
10109 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
10110 :
10111 : rose_hash_multimap*
10112 19332900 : SgSymbolTable::get_table () const
10113 : {
10114 19332900 : ROSE_ASSERT (this != NULL);
10115 :
10116 : #if 0
10117 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10118 : // used to trigger marking transformations for the token-based unparsing.
10119 : printf ("SgSymbolTable::get_table = %p = %s \n",this,this->class_name().c_str());
10120 : #endif
10121 :
10122 19332900 : return p_table;
10123 : }
10124 :
10125 : void
10126 0 : SgSymbolTable::set_table ( rose_hash_multimap* table )
10127 : {
10128 0 : ROSE_ASSERT (this != NULL);
10129 :
10130 : #if 0
10131 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10132 : // used to trigger marking transformations for the token-based unparsing.
10133 : printf ("SgSymbolTable::set_table = %p = %s \n",this,this->class_name().c_str());
10134 : #endif
10135 :
10136 0 : set_isModified(true);
10137 :
10138 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
10139 : if (p_table != NULL && table != NULL && p_table != table)
10140 : {
10141 : printf ("Warning: table = %p overwriting valid pointer p_table = %p \n",table,p_table);
10142 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
10143 : printf ("Error fails assertion (p_table != NULL && table != NULL && p_table != table) is false\n");
10144 : ROSE_ASSERT(false);
10145 : #endif
10146 : }
10147 : #endif
10148 0 : p_table = table;
10149 0 : }
10150 :
10151 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
10152 :
10153 :
10154 : // End of memberFunctionString
10155 : // Start of memberFunctionString
10156 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
10157 :
10158 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
10159 :
10160 : SgNodeSet
10161 0 : SgSymbolTable::get_symbolSet () const
10162 : {
10163 0 : ROSE_ASSERT (this != NULL);
10164 :
10165 : #if 0
10166 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10167 : // used to trigger marking transformations for the token-based unparsing.
10168 : printf ("SgSymbolTable::get_symbolSet = %p = %s \n",this,this->class_name().c_str());
10169 : #endif
10170 :
10171 0 : return p_symbolSet;
10172 : }
10173 :
10174 : void
10175 0 : SgSymbolTable::set_symbolSet ( SgNodeSet symbolSet )
10176 : {
10177 0 : ROSE_ASSERT (this != NULL);
10178 :
10179 : #if 0
10180 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
10181 : // used to trigger marking transformations for the token-based unparsing.
10182 : printf ("SgSymbolTable::set_symbolSet = %p = %s \n",this,this->class_name().c_str());
10183 : #endif
10184 :
10185 0 : set_isModified(true);
10186 :
10187 0 : p_symbolSet = symbolSet;
10188 0 : }
10189 :
10190 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
10191 :
10192 :
10193 : // End of memberFunctionString
10194 : // Start of memberFunctionString
10195 :
10196 :
10197 : // End of memberFunctionString
10198 : // Start of memberFunctionString
10199 : /* #line 7812 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
10200 :
10201 :
10202 : // This function was moved to be defined outside of eqstr so that we could
10203 : // reference the data member rose_hash_multimap::case_insensitive_semantics.
10204 : bool
10205 58746500 : eqstr::operator()(const SgName & s1, const SgName & s2) const
10206 : {
10207 : // DQ (11/27/2010): This is where we can implement the case insensitive support in ROSE.
10208 : // return s1.getString() == s2.getString();
10209 : // return s1 == s2;
10210 :
10211 58746500 : ROSE_ASSERT(hash_multimap != NULL);
10212 : // mprintf ("@@@@@ hash_multimap->get_case_insensitive_semantics() = %s s1 = %s s2 = %s \n",(hash_multimap->get_case_insensitive_semantics() == true) ? "true" : "false",s1.str(),s2.str());
10213 : // ROSE_ASSERT(hash_multimap->get_case_insensitive_semantics() == true);
10214 :
10215 58746500 : if (hash_multimap->get_case_insensitive_semantics() == true)
10216 : {
10217 11059 : return SgName::caseInsensitiveEquality(s1,s2);
10218 : }
10219 : else
10220 : {
10221 : // This is the SgName::operator==(const SgName & s1, const SgName & s2) member function
10222 58735400 : return s1 == s2;
10223 : }
10224 : }
10225 :
10226 :
10227 : // DQ (11/5/2020): Moved this out of the generated header file and into the generated source
10228 : // file so that it could be more easily changed without recompiling all of ROSE.
10229 : void
10230 54458 : rose_hash_multimap::delete_elements()
10231 : {
10232 : #if 0
10233 : printf ("Inside of rose_hash_multimap::delete_elements(): this = %p derived from public rose_hash::unordered_multimap<SgName, SgSymbol*, hash_Name, eqstr>: \n",this);
10234 : #endif
10235 : #if 0
10236 : // DQ (11/5/2020): Uncommenting this code out.
10237 : // DQ (2/19/2007): I am not sure why this is commented out (has been since it was introduced summer of 2005)
10238 : // hash_multimap<SgName, SgSymbol*, hash_Name, eqstr>::iterator it;
10239 : rose_hash::unordered_multimap<SgName, SgSymbol*, hash_Name, eqstr>::iterator it;
10240 : for (it = begin(); it != end(); ++it)
10241 : {
10242 : #if 0
10243 : printf ("Removing symbol (commented out delete): (*it).first = %s \n",(*it).first.str());
10244 : #endif
10245 : // delete (*it).second;
10246 : // (*it).second = NULL;
10247 : }
10248 : #endif
10249 : #if 0
10250 : printf ("Inside of rose_hash_multimap::delete_elements(): this = %p calling clear(): size() = %zu \n",this,size());
10251 : #endif
10252 :
10253 : // DQ (11/5/2020): Call the clear function so that we can remove all elements.
10254 54458 : clear();
10255 :
10256 : #if 0
10257 : printf ("DONE: Inside of rose_hash_multimap::delete_elements(): this = %p calling clear(): size() = %zu \n",this,size());
10258 : #endif
10259 54458 : }
10260 :
10261 :
10262 : size_t
10263 40859000 : hash_Name::operator()(const SgName & name) const
10264 : {
10265 : // CH (4/8/2010): Use boost::unordered instead
10266 : // return hasher(name.str());
10267 :
10268 40859000 : ROSE_ASSERT(hash_multimap != NULL);
10269 : // mprintf ("In hash_Name::operator(): hash_multimap->get_case_insensitive_semantics() = %s name = %s \n",hash_multimap->get_case_insensitive_semantics() ? "true" : "false",name.str());
10270 :
10271 : // ROSE_ASSERT(hash_multimap->get_case_insensitive_semantics() == true);
10272 :
10273 40859000 : if (hash_multimap->get_case_insensitive_semantics() == true)
10274 : {
10275 : // We need to compute the hash on the normalized form of the name (pick lower case).
10276 25896 : std::string s = name;
10277 :
10278 : // Convert string to lower case.
10279 12948 : std::transform(s.begin(), s.end(),s.begin(),::tolower);
10280 : // mprintf ("In hash_Name::operator(): transformed name = %s to lower case s = %s \n",name.str(),s.c_str());
10281 :
10282 : // Return hashed value on the normalized (lower case) string.
10283 31359 : return hasher(s.c_str());
10284 : }
10285 : else
10286 : {
10287 107212000 : return hasher(name.str());
10288 : }
10289 : }
10290 :
10291 : // DQ (2/19/2007): Added mechanism to turn off expensive error checking!
10292 : #define SYMBOL_TABLE_ERROR_CHECKING 0
10293 :
10294 : // DQ (7/24/2005): Make this a constant in the function if it is not used elsewhere!
10295 : // #define SYMTBL_INIT_SZ 16
10296 :
10297 : // DQ (11/27/2010): Added support for case sensitive and case insensitive symbol table (internal name matching).
10298 : // SgSymbolTable::SgSymbolTable(bool case_insensitive)
10299 138601 : SgSymbolTable::SgSymbolTable()
10300 138601 : : p_no_name(true)
10301 : {
10302 : // This should always be a non-null pointer (and never shared)!
10303 138601 : int symbolTableSize = 17;
10304 :
10305 : // CH (4/8/2010): Use boost::unordered instead
10306 : #if 0
10307 : mprintf ("WARNING: Symbol table built using default constructor in SgSymbolTable(). \n");
10308 : p_table = new BaseHashType();
10309 : #else
10310 138601 : p_table = new BaseHashType(symbolTableSize);
10311 : #endif
10312 138601 : ROSE_ASSERT (p_table != NULL);
10313 138601 : }
10314 :
10315 : // DQ (2/19/2007): I have put it back into use as a way of
10316 : // customizing the size of the underlying hash tables to be
10317 : // larger for certain scopes (e.g global scope usually has a
10318 : // lot more symbols.
10319 :
10320 : // DQ (11/27/2010): Added support for case sensitive and case insensitive symbol table (internal name matching).
10321 : // DQ (1/31/2007): This function is not used!
10322 : // SgSymbolTable::SgSymbolTable(int symbolTableSize)
10323 : // SgSymbolTable::SgSymbolTable(int symbolTableSize, bool case_insensitive)
10324 138601 : SgSymbolTable::SgSymbolTable(int symbolTableSize)
10325 138601 : : p_no_name(true)
10326 : {
10327 : // This should always be a non-null pointer (and never shared)!
10328 :
10329 : // AJ (10/21/2004): Adjusted implementation to use new STL hash map interface
10330 : // p_table = new SgSymbolHashMultiMap(sz);
10331 :
10332 : // CH (4/8/2010): Use boost::unordered instead
10333 : //#ifdef _MSCx_VER
10334 : #if 0
10335 : mprintf ("WARNING: Symbol table built using default constructor in SgSymbolTable(int symbolTableSize). \n");
10336 : p_table = new BaseHashType();
10337 : #else
10338 138601 : p_table = new BaseHashType(symbolTableSize);
10339 : #endif
10340 138601 : ROSE_ASSERT (p_table != NULL);
10341 138601 : }
10342 :
10343 : bool
10344 154140 : SgSymbolTable::isCaseInsensitive() const
10345 : {
10346 : // Case sensitive symbol tables are used for C/C++ and case insensitive scopes are for Fortran.
10347 : // Note that a case insensitive symbol table can only be built that way from the constructor
10348 : // and not be toggled back and forth at will.
10349 :
10350 154140 : ROSE_ASSERT(p_table != NULL);
10351 154140 : return p_table->get_case_insensitive_semantics();
10352 : }
10353 :
10354 : void
10355 229 : SgSymbolTable::setCaseInsensitive(bool b)
10356 : {
10357 : // Case sensitive symbol tables are used for C/C++ and case insensitive scopes are for Fortran.
10358 : // Note that a case insensitive symbol table can only be built that way from the constructor
10359 : // and not be toggled back and forth at will.
10360 :
10361 229 : ROSE_ASSERT(p_table != NULL);
10362 :
10363 : // Make it NOT an error to redundantly set the case sensitivity/insensitivity.
10364 229 : bool changingCaseSensitivity = b != p_table->get_case_insensitive_semantics();
10365 229 : if (changingCaseSensitivity == true)
10366 : {
10367 192 : if (p_table->empty() == false)
10368 : {
10369 0 : mprintf ("Error: Can't change case sensitivity of non-empty symbol table.\n");
10370 0 : mprintf (" Solution: set the case sensitivity/insensitivity earlier in processing (immediately after the call to build the scope) \n");
10371 : }
10372 192 : ROSE_ASSERT(p_table->empty() == true);
10373 :
10374 192 : p_table->set_case_insensitive_semantics(b);
10375 : }
10376 229 : }
10377 :
10378 0 : std::ostream & operator<< ( std::ostream & os, const rose_hash_multimap::iterator & rhm_it )
10379 : {
10380 : // DQ (1/19/2006): Error reported by Michelle Strout when compiled with g++ 4.0.2 on 64 bit machines
10381 : // os << " pair (" << (*rhm_it).first.str() << "," << (int)((*rhm_it).second) << ")";
10382 : // os << " pair (" << (*rhm_it).first.str() << "," << ((*rhm_it).second) << ")";
10383 : // JJW (7/10/2008): The iterator may not be valid, so don't try to print what it points to
10384 0 : os << "<iterator>";
10385 0 : return os;
10386 : }
10387 :
10388 : SgName
10389 14898900 : SgSymbolTable::get_name( const SgNode* node) const
10390 : {
10391 : // DQ (2/20/2007): This function is used to get the name for the different types of declarations used to build symbols.
10392 :
10393 14898900 : SgName name;
10394 :
10395 14898900 : switch (node->variantT())
10396 : {
10397 : // We could implement a function on the selective nodes that generated the symbol
10398 : // name (the name used for the input of associated symbols in the symbol table).
10399 7 : case V_SgLabelStatement:
10400 7 : {
10401 7 : const SgLabelStatement* labelStatement = isSgLabelStatement(node);
10402 7 : if (labelStatement->get_label() != NULL)
10403 : {
10404 4 : name = labelStatement->get_label();
10405 : }
10406 : else
10407 : {
10408 : // name = Rose::StringUtility::numberToString(labelStatement->get_numeric_label()->get_name());
10409 3 : ROSE_ASSERT(labelStatement->get_numeric_label() != NULL);
10410 3 : name = labelStatement->get_numeric_label()->get_name();
10411 : }
10412 : break;
10413 : }
10414 :
10415 27386 : case V_SgClassDeclaration:
10416 27386 : case V_SgDerivedTypeStatement:
10417 27386 : case V_SgModuleStatement:
10418 27386 : {
10419 27386 : const SgClassDeclaration* classDeclaration = isSgClassDeclaration(node);
10420 27386 : name = classDeclaration->get_name();
10421 27386 : break;
10422 : }
10423 :
10424 74664 : case V_SgTemplateInstantiationDecl:
10425 74664 : {
10426 74664 : const SgTemplateInstantiationDecl* templateInstantiationDeclaration = isSgTemplateInstantiationDecl(node);
10427 : // Note that get_name() returns a name with arguments such as "class_template<int>" while get_templateName() returns the template name withouth arguments.
10428 : // name = templateInstantiationDeclaration->get_templateName();
10429 : // mprintf ("In SgSymbolTable::find(const SgStatement*): case V_SgTemplateInstantiationDecl, using get_name() = %s instead of get_templateName() = %s \n",
10430 : // templateInstantiationDeclaration->get_name().str(),templateInstantiationDeclaration->get_templateName().str());
10431 : // mprintf ("Base class get_name() = %s \n",templateInstantiationDeclaration->SgClassDeclaration::get_name().str());
10432 74664 : name = templateInstantiationDeclaration->get_name();
10433 74664 : break;
10434 : }
10435 :
10436 1434 : case V_SgEnumDeclaration:
10437 1434 : {
10438 1434 : const SgEnumDeclaration* enumDeclaration = isSgEnumDeclaration(node);
10439 1434 : name = enumDeclaration->get_name();
10440 1434 : break;
10441 : }
10442 :
10443 14285500 : case V_SgFunctionDeclaration:
10444 14285500 : case V_SgProgramHeaderStatement:
10445 14285500 : case V_SgProcedureHeaderStatement:
10446 14285500 : case V_SgMemberFunctionDeclaration:
10447 14285500 : {
10448 14285500 : const SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(node);
10449 : // mprintf ("functionDeclaration = %p \n",functionDeclaration);
10450 : // mprintf ("functionDeclaration->get_definingDeclaration() = %p \n",functionDeclaration->get_definingDeclaration());
10451 : // mprintf ("functionDeclaration->get_firstNondefiningDeclaration() = %p \n",functionDeclaration->get_firstNondefiningDeclaration());
10452 14285500 : name = functionDeclaration->get_name();
10453 14285500 : break;
10454 : }
10455 :
10456 : // DQ (2/14/2007): Note that for template-based declarations there is a process where within the post-processing of
10457 : // the AST the names are updated from the EDG form (e.g. "template_name___Lnnn"), to the template specialization
10458 : // form (e.g. "template_name<int>"). Since the symbol references only one of the declarations, if there are defining
10459 : // declarations and non-defining declarations, the name can be changed in the declaration but not in the associated symbol.
10460 : // Details of this situation require more clarification.
10461 29478 : case V_SgTemplateInstantiationFunctionDecl:
10462 29478 : {
10463 29478 : const SgTemplateInstantiationFunctionDecl* functionDeclaration = isSgTemplateInstantiationFunctionDecl(node);
10464 : // mprintf ("functionDeclaration = %p \n",functionDeclaration);
10465 : // mprintf ("functionDeclaration->get_definingDeclaration() = %p \n",functionDeclaration->get_definingDeclaration());
10466 : // mprintf ("functionDeclaration->get_firstNondefiningDeclaration() = %p \n",functionDeclaration->get_firstNondefiningDeclaration());
10467 :
10468 : // DQ (2/14/2007): The name used to insert symbols into the symbol table is the one returned by get_name(),
10469 : // get_templateName returns the name of the template which is required for code generation (where for
10470 : // functions the specialization is not required or not allowed).
10471 : // name = functionDeclaration->get_templateName();
10472 29478 : name = functionDeclaration->get_name();
10473 29478 : break;
10474 : }
10475 :
10476 179292 : case V_SgTemplateInstantiationMemberFunctionDecl:
10477 179292 : {
10478 179292 : const SgTemplateInstantiationMemberFunctionDecl* functionDeclaration = isSgTemplateInstantiationMemberFunctionDecl(node);
10479 : // mprintf ("functionDeclaration = %p \n",functionDeclaration);
10480 : // mprintf ("functionDeclaration->get_definingDeclaration() = %p \n",functionDeclaration->get_definingDeclaration());
10481 : // mprintf ("functionDeclaration->get_firstNondefiningDeclaration() = %p \n",functionDeclaration->get_firstNondefiningDeclaration());
10482 :
10483 : // DQ (2/14/2007): The name used to insert symbols into the symbol table is the one returned by get_name(),
10484 : // get_templateName returns the name of the template which is required for code generation (where for
10485 : // functions the specialization is not required or not allowed).
10486 : // name = functionDeclaration->get_templateName();
10487 179292 : name = functionDeclaration->get_name();
10488 179292 : break;
10489 : }
10490 :
10491 9609 : case V_SgNamespaceDeclarationStatement:
10492 9609 : {
10493 9609 : const SgNamespaceDeclarationStatement* namespaceDeclarationStatement = isSgNamespaceDeclarationStatement(node);
10494 9609 : name = namespaceDeclarationStatement->get_name();
10495 9609 : break;
10496 : }
10497 :
10498 : // DQ (8/30/2009): Added namespace alias support.
10499 0 : case V_SgNamespaceAliasDeclarationStatement:
10500 0 : {
10501 0 : const SgNamespaceAliasDeclarationStatement* namespaceAliasDeclarationStatement = isSgNamespaceAliasDeclarationStatement(node);
10502 0 : name = namespaceAliasDeclarationStatement->get_name();
10503 0 : break;
10504 : }
10505 :
10506 : // DQ (12/26/2011): Template declarations have to have their own cases now.
10507 : // DQ (11/23/2011): Added more support for template declaration IR nodes.
10508 51886 : case V_SgTemplateFunctionDeclaration:
10509 51886 : {
10510 51886 : const SgTemplateFunctionDeclaration* templateDeclaration = isSgTemplateFunctionDeclaration(node);
10511 51886 : name = templateDeclaration->get_name();
10512 51886 : break;
10513 : }
10514 :
10515 : // DQ (12/26/2011): Template declarations have to have their own cases now.
10516 132667 : case V_SgTemplateMemberFunctionDeclaration:
10517 132667 : {
10518 132667 : const SgTemplateMemberFunctionDeclaration* templateDeclaration = isSgTemplateMemberFunctionDeclaration(node);
10519 132667 : name = templateDeclaration->get_name();
10520 132667 : break;
10521 : }
10522 :
10523 : // DQ (12/26/2011): Template declarations have to have their own cases now.
10524 : // DQ (6/11/2011): Added support for new template declaration IR nodes.
10525 36840 : case V_SgTemplateClassDeclaration:
10526 36840 : {
10527 36840 : const SgTemplateClassDeclaration* templateDeclaration = isSgTemplateClassDeclaration(node);
10528 36840 : name = templateDeclaration->get_name();
10529 36840 : break;
10530 : }
10531 : #if 0
10532 : // DQ (12/26/2011): This is not a required case to handle since a variable declaration dos not have a name.
10533 : case V_SgTemplateVariableDeclaration:
10534 : {
10535 : const SgTemplateVariableDeclaration* templateDeclaration = isSgTemplateVariableDeclaration(node);
10536 : name = templateDeclaration->get_name();
10537 : break;
10538 : }
10539 : #endif
10540 : // DQ (12/26/2011): This is no longer a base class for SgTemplateClassDeclaration and other templae declaration IR nodes.
10541 : // It is used only for the EDG 3.3 compatable support for template declarations.
10542 0 : case V_SgTemplateDeclaration:
10543 0 : {
10544 0 : const SgTemplateDeclaration* templateDeclaration = isSgTemplateDeclaration(node);
10545 0 : name = templateDeclaration->get_name();
10546 0 : break;
10547 : }
10548 :
10549 55919 : case V_SgTypedefDeclaration:
10550 55919 : {
10551 55919 : const SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(node);
10552 55919 : name = typedefDeclaration->get_name();
10553 55919 : break;
10554 : }
10555 :
10556 : // DQ (11/5/2014): Adding support for templated typedef.
10557 454 : case V_SgTemplateInstantiationTypedefDeclaration:
10558 454 : {
10559 454 : const SgTemplateInstantiationTypedefDeclaration* templateInstantiationDeclaration = isSgTemplateInstantiationTypedefDeclaration(node);
10560 454 : name = templateInstantiationDeclaration->get_name();
10561 454 : break;
10562 : }
10563 :
10564 : // DQ (11/4/2014): Adding support for templated typedef.
10565 742 : case V_SgTemplateTypedefDeclaration:
10566 742 : {
10567 742 : const SgTemplateTypedefDeclaration* templateDeclaration = isSgTemplateTypedefDeclaration(node);
10568 742 : name = templateDeclaration->get_name();
10569 742 : break;
10570 : }
10571 :
10572 0 : case V_SgFunctionType:
10573 0 : {
10574 0 : const SgFunctionType* functionType = isSgFunctionType(node);
10575 :
10576 : // DQ (3/19/2016): Klocworks reports this as an issue, since functionType could be NULL.
10577 : // So I am adding an assertion to see if this is a reasonalbe solution. I am not clear
10578 : // why all of the other cases in this function are not flagged as issues by Klocworks.
10579 0 : ROSE_ASSERT(functionType != NULL);
10580 :
10581 0 : name = functionType->get_mangled();
10582 0 : break;
10583 : }
10584 :
10585 0 : case V_SgInitializedName:
10586 0 : {
10587 0 : const SgInitializedName* initializedName = isSgInitializedName(node);
10588 0 : name = initializedName->get_name();
10589 0 : break;
10590 : }
10591 :
10592 13091 : case V_SgNonrealDecl:
10593 13091 : {
10594 13091 : const SgNonrealDecl* nrdecl = isSgNonrealDecl(node);
10595 13091 : name = nrdecl->get_name();
10596 13091 : break;
10597 : }
10598 :
10599 0 : default:
10600 0 : {
10601 0 : mprintf ("SgSymbolTable::get_name(SgNode*) undefined for %s \n",node->class_name().c_str());
10602 0 : ROSE_ASSERT(false);
10603 : }
10604 : }
10605 :
10606 : #if 0
10607 : mprintf ("SgSymbolTable::get_name(SgNode*) node = %p = %s name = %s \n",node,node->class_name().c_str(),name.str());
10608 : #endif
10609 :
10610 14898900 : return name;
10611 : }
10612 :
10613 :
10614 : /* ************************************************************************
10615 : INSERT FUNCTIONS
10616 : ************************************************************************/
10617 :
10618 : void
10619 2404200 : SgSymbolTable::insert ( const SgName & nm , SgSymbol *sp )
10620 : {
10621 : // For simplicity, there is only a single insert member function to put a symbol into the symbol table.
10622 :
10623 : #if 0
10624 : mprintf ("********** In SgSymbolTable::insert(%s,%p) into SgSymbolTable = %p = %s of scope = %p = %s sp = %p = %s \n",
10625 : nm.str(),sp,this,this->class_name().c_str(),this->get_parent(),this->get_parent()->class_name().c_str(),sp,sp->class_name().c_str());
10626 : #endif
10627 :
10628 : // DQ (2/14/2007): Added assertion!
10629 2404200 : ROSE_ASSERT(this != NULL);
10630 :
10631 : // DQ (2/19/2007): Added additional assertion!
10632 2404200 : ROSE_ASSERT (p_table != NULL);
10633 :
10634 : // DQ (2/14/2007): Added assertion!
10635 2404200 : ROSE_ASSERT (sp != NULL);
10636 :
10637 : #if 0
10638 : // This outputs a message for every use of the insert function (for non function type symbols) useful for tracing through bugs
10639 : SgNode* symbolBasis = sp->get_symbol_basis();
10640 : #if 0
10641 : // DQ (12/3/3011): This does not work since the sp->get_mangled_name() can't always be called...
10642 : mprintf ("+++++++++++ In SgSymbolTable::insert(%s,%p) into SgSymbolTable = %p = %s of scope = %p = %s sp = %p = %s sp->get_symbol_basis() = %p = %s mangled_name = %s \n",
10643 : nm.str(),sp,this,this->class_name().c_str(),this->get_parent(),this->get_parent()->class_name().c_str(),
10644 : sp,sp->class_name().c_str(),symbolBasis,symbolBasis != NULL ? symbolBasis->class_name().c_str() : "NULL",
10645 : sp->get_mangled_name().str());
10646 : #else
10647 : mprintf ("+++++++++++ In SgSymbolTable::insert(%s,%p) into SgSymbolTable = %p = %s of scope = %p = %s sp = %p = %s sp->get_symbol_basis() = %p = %s \n",
10648 : nm.str(),sp,this,this->class_name().c_str(),this->get_parent(),this->get_parent()->class_name().c_str(),
10649 : sp,sp->class_name().c_str(),symbolBasis,symbolBasis != NULL ? symbolBasis->class_name().c_str() : "NULL");
10650 : #endif
10651 :
10652 : #if 0
10653 : // DQ (7/24/2012): Note that this can fail (e.g. test2004_77.C) since SgAliassymbols are not considered in this test, I think.
10654 : // DQ (12/3/2011): If this is a symbol for a member function declaration, then it should be a SgMemberFunctionSymbol, and not a SgFunctionSymbol.
10655 : if (symbolBasis != NULL && isSgMemberFunctionDeclaration(symbolBasis) != NULL)
10656 : {
10657 : if (isSgMemberFunctionSymbol(sp) == NULL)
10658 : {
10659 : mprintf ("Error: symbol for SgMemberFunctionDeclaration is not a SgMemberFunctionSymbol (sp = %p = %s) \n",sp,sp->class_name().c_str());
10660 : }
10661 : ROSE_ASSERT(isSgMemberFunctionSymbol(sp) != NULL);
10662 : }
10663 : #endif
10664 : #endif
10665 :
10666 : #if 0
10667 : // DQ (12/3/2011): Disable symbols with the same name (temporary testing/debugging).
10668 : if (exists(nm) == true)
10669 : {
10670 : // We what to check on what kind of symbol this is.
10671 : SgSymbol* s = find_function(nm);
10672 : mprintf ("In SgSymbolTable::insert(%s,%p = %s) found an overloaded function (symbol = %p = %s) \n",nm.str(),sp,sp->class_name().c_str(),s,(s != NULL) ? s->class_name().c_str() : "empty string");
10673 : // ROSE_ASSERT(s == NULL);
10674 : }
10675 : // ROSE_ASSERT(exists(nm) == false);
10676 : #endif
10677 :
10678 : // DQ (11/20/2012): Make error checking dependent upon SYMBOL_TABLE_ERROR_CHECKING macro.
10679 : #if SYMBOL_TABLE_ERROR_CHECKING
10680 : // SgFunctionTypeSymbol does not have a valid get_symbol_basis(), so skip this case!
10681 : if (isSgFunctionTypeSymbol(sp) == NULL)
10682 : {
10683 : if (sp->get_symbol_basis() == NULL)
10684 : {
10685 : mprintf ("Error (sp->get_symbol_basis() == NULL): name = %s sp = %p = %s \n",nm.str(),sp,sp->class_name().c_str());
10686 : }
10687 : ROSE_ASSERT(sp->get_symbol_basis() != NULL);
10688 : #if 0
10689 : // This outputs a message for every use of the insert function (for non function type symbols) useful for tracing through bugs
10690 : mprintf ("In SgSymbolTable::insert(%s,%p) into SgSymbolTable = %p = %s of scope = %p = %s sp = %p = %s sp->get_symbol_basis() = %p = %s \n",
10691 : nm.str(),sp,this,this->class_name().c_str(),this->get_parent(),this->get_parent()->class_name().c_str(),
10692 : sp,sp->class_name().c_str(),sp->get_symbol_basis(),sp->get_symbol_basis()->class_name().c_str());
10693 : #endif
10694 : }
10695 :
10696 : // DQ (3/10/2007): This is a simpler assertion equivalent to the one above but without generating any error output
10697 : ROSE_ASSERT(isSgFunctionTypeSymbol(sp) != NULL || sp->get_symbol_basis() != NULL);
10698 : #endif
10699 :
10700 : #if 0
10701 : // DQ (12/3/2011): Adding debugging support to output p_symbolSet.
10702 : mprintf ("Output the internal symbol set used for fast existence testing (p_symbolSet size = %" PRIuPTR "): \n",p_symbolSet.size());
10703 : int counter = 0;
10704 : SgNodeSet::iterator i = p_symbolSet.begin();
10705 : while (i != p_symbolSet.end())
10706 : {
10707 : SgSymbol* temp_symbol = isSgSymbol(*i);
10708 : ROSE_ASSERT(temp_symbol != NULL);
10709 :
10710 : SgNode* symbolBasis = temp_symbol->get_symbol_basis();
10711 : // mprintf ("--- p_symbolSet[counter=%d] = %p = %s : name = %s symbolBasis = %p mangled_name = %s \n",counter,temp_symbol,temp_symbol->class_name().c_str(),temp_symbol->get_name().str(),symbolBasis,temp_symbol->get_mangled_name().str());
10712 : mprintf ("--- p_symbolSet[counter=%d] = %p = %s : name = %s symbolBasis = %p \n",counter,temp_symbol,temp_symbol->class_name().c_str(),temp_symbol->get_name().str(),symbolBasis);
10713 : i++;
10714 : counter++;
10715 : }
10716 : mprintf ("DONE: Output the internal symbol set used for fast existence testing (p_symbolSet size = %" PRIuPTR ") \n",p_symbolSet.size());
10717 :
10718 : #if 0
10719 : // DQ (12/3/2011): Debugging code...
10720 : if (p_symbolSet.size() > 1)
10721 : {
10722 : mprintf ("Exiting when there is a single symbol in p_symbolSet \n");
10723 : ROSE_ASSERT(false);
10724 : }
10725 : #endif
10726 : #endif
10727 :
10728 : // DQ (3/10/2007): Test for if the symbol exists
10729 4808400 : if (p_symbolSet.find(sp) != p_symbolSet.end())
10730 : {
10731 0 : SgType* t = sp->get_type();
10732 0 : ROSE_ASSERT(t != NULL);
10733 0 : mprintf ("ERROR: p_symbolSet.find(sp) != p_symbolSet.end(): base type = %p = %s \n",t,t->class_name().c_str());
10734 : }
10735 4808400 : ROSE_ASSERT(p_symbolSet.find(sp) == p_symbolSet.end());
10736 :
10737 : // DQ (11/20/2012): Make error checking dependent upon SYMBOL_TABLE_ERROR_CHECKING macro.
10738 : // #if 1
10739 : // DQ (12/3/2011): Turning on symbol table checking.
10740 : #if SYMBOL_TABLE_ERROR_CHECKING
10741 : // DQ (2/19/2007): These is no need to do both of these since exists(sp) is more complete test!
10742 : // DQ (2/25/2007): except that it is helpful to know which one fails.
10743 : ROSE_ASSERT(exists(nm,sp) == false);
10744 : ROSE_ASSERT(exists(sp) == false);
10745 :
10746 : // DQ (2/14/2007): error checking (make sure that no two symbols are represented by the same basis declaration).
10747 : // But skip such tests on the SgFunctionTypeSymbol (only used for the function type table)
10748 : if (isSgFunctionTypeSymbol(sp) == NULL)
10749 : {
10750 : // set<SgNode*> existingSymbolBasisDeclarations;
10751 : map<SgNode*, rose_hash_multimap::iterator > existingSymbolBasisDeclarations;
10752 :
10753 : SgNode* sp_associatedDeclaration = sp->get_symbol_basis();
10754 : ROSE_ASSERT(sp_associatedDeclaration != NULL);
10755 :
10756 : rose_hash_multimap::iterator i = get_table()->begin();
10757 : while (i != get_table()->end())
10758 : {
10759 : // test if symbol is in set
10760 : SgNode* associatedDeclaration = i->second->get_symbol_basis();
10761 : ROSE_ASSERT(associatedDeclaration != NULL);
10762 :
10763 : // Check if this declaration has previously been used with another symbol!
10764 : if (existingSymbolBasisDeclarations.find( sp_associatedDeclaration ) == existingSymbolBasisDeclarations.end())
10765 : {
10766 : // Add this declaration to the list associated with symbols in the table
10767 : // existingSymbolBasisDeclarations.insert( associatedDeclaration );
10768 : existingSymbolBasisDeclarations[associatedDeclaration] = i;
10769 : }
10770 : else
10771 : {
10772 : mprintf ("Error in symbol table located in parent = %p = %s \n",get_parent(),get_parent()->class_name().c_str());
10773 : ROSE_ASSERT(get_parent() != NULL);
10774 : get_parent()->get_file_info()->display("Error in symbol table");
10775 :
10776 : string associatedDeclarationName = SageInterface::get_name(sp_associatedDeclaration);
10777 :
10778 : // DQ (2/15/2007): Output the name of the symbol being inserted, the declaration associated with it,
10779 : // and the name of the symbol previously inserted with the same associated declaration.
10780 : mprintf ("Symbol sp = %p = %s already associated with declaration = %p = %s (name = %s) in symbol table i = %p = %s \n",
10781 : sp,sp->class_name().c_str(),sp_associatedDeclaration,sp_associatedDeclaration->class_name().c_str(),
10782 : associatedDeclarationName.c_str(),existingSymbolBasisDeclarations[sp_associatedDeclaration]->second,existingSymbolBasisDeclarations[sp_associatedDeclaration]->second->class_name().c_str());
10783 : associatedDeclaration->get_file_info()->display("Dual use of associatedDeclaration in source: debug");
10784 :
10785 : mprintf ("existingSymbolBasisDeclarations[sp_associatedDeclaration]->first = %s second = %p \n",
10786 : existingSymbolBasisDeclarations[sp_associatedDeclaration]->first.str(),
10787 : existingSymbolBasisDeclarations[sp_associatedDeclaration]->second);
10788 : ROSE_ASSERT(false);
10789 : }
10790 :
10791 : i++;
10792 : }
10793 : }
10794 : #endif
10795 :
10796 : // Now, finally insert it into the symbol table
10797 : // std::pair<const SgName,SgSymbol*> npair(nm,sp);
10798 : // p_table->insert(npair);
10799 2404200 : p_table->insert(std::pair<const SgName,SgSymbol*>(nm,sp));
10800 :
10801 : // DQ (5/11/2006): set the parent to avoid NULL pointers
10802 2404200 : sp->set_parent(this);
10803 :
10804 : // DQ (3/10/2007): Insert this symbol into p_symbolSet which we use for fast tests of existance in the
10805 : // symbol table when we don't use the name. This helps detect where symbols have been entered using one
10806 : // name and either reentered using an second name or the name changed and the symbol had not been properly
10807 : // unloaded and reloaded into the symbol table. Since the names are not stored in the symbol, but computed
10808 : // from associated declaration this is an easy error to make and we detect this by backing up the test for
10809 : // if a symbol exists using a name with a test for if the symbol exists using ANY possible name (a search
10810 : // for the symbol independent of the name). To avoid this being a linear search of the symbol table (too
10811 : // slow) we implement a set of symbols to permit fast tests for existence.
10812 2404200 : p_symbolSet.insert(sp);
10813 :
10814 : // DQ (11/20/2012): Make error checking dependent upon SYMBOL_TABLE_ERROR_CHECKING macro.
10815 : // #if 1
10816 : // DQ (12/3/2011): Turning on symbol table checking.
10817 : #if SYMBOL_TABLE_ERROR_CHECKING
10818 : // Error checking
10819 : ROSE_ASSERT(exists(nm) == true);
10820 : ROSE_ASSERT(exists(nm,sp) == true);
10821 : ROSE_ASSERT(exists(sp) == true);
10822 : #endif
10823 :
10824 : // DQ (11/20/2012): Make error checking dependent upon SYMBOL_TABLE_ERROR_CHECKING macro.
10825 : // #if 1
10826 : #if SYMBOL_TABLE_ERROR_CHECKING
10827 : // Liao 11/12/2012: Fortran numeric label symbol is different: a label "05" is stored as a numeric value of 5 so naive comparison will fail.
10828 : // we have to handle this case specially.
10829 : SgLabelSymbol * ls = isSgLabelSymbol(sp);
10830 : bool special_handled = false;
10831 : if (ls != NULL)
10832 : {
10833 : SgStatement* fortran_stmt = ls->get_fortran_statement();
10834 : if (fortran_stmt != NULL)
10835 : {
10836 : int label_value = atoi (nm.getString().c_str());
10837 : ROSE_ASSERT (label_value == ls->get_numeric_label_value());
10838 : special_handled = true;
10839 : }
10840 : }
10841 :
10842 : // DQ (12/3/2011): Turning on symbol table checking.
10843 : // #if SYMBOL_TABLE_ERROR_CHECKING
10844 : // DQ (2/14/2007): Added error checking!
10845 : if (!special_handled && (nm != sp->get_name()))
10846 : {
10847 : mprintf ("Warning: symbol name does not match name used to input associated symbol into symbol table! sp = %p = %s nm = \"%s\" sp->get_name() = \"%s\" \n",sp,sp->class_name().c_str(),nm.str(),sp->get_name().str());
10848 :
10849 : ROSE_ASSERT(sp->get_symbol_basis() != NULL);
10850 : ROSE_ASSERT(sp->get_symbol_basis()->get_file_info() != NULL);
10851 :
10852 : sp->get_symbol_basis()->get_file_info()->display("Error in source: debug");
10853 : ROSE_ASSERT(false);
10854 : }
10855 : #endif
10856 :
10857 :
10858 : #if 0
10859 : // We can't test this because where symbols are inserted (EDG/SageIII translation) the scopes are not set yet (done in AST post-processing).
10860 : // DQ (2/14/2007): Added error checking!
10861 : SgStatement* statement = isSgStatement(sp->get_symbol_basis());
10862 : if (statement != NULL)
10863 : {
10864 : // mprintf ("In loop: p_iterator->second = %p = %s statement = %p = %s \n",p_iterator->second,p_iterator->second->class_name().c_str(),statement,statement->class_name().c_str());
10865 : // SgNode* symbolBasis = p_iterator->second->get_symbol_basis();
10866 : SgSymbol* symbolFromTable = statement->get_symbol_from_symbol_table();
10867 : ROSE_ASSERT(symbolFromTable != NULL);
10868 : ROSE_ASSERT(symbolFromTable == sp);
10869 : }
10870 : else
10871 : {
10872 : SgInitializedName* initializedName = isSgInitializedName(sp->get_symbol_basis());
10873 : if (initializedName != NULL)
10874 : {
10875 : // mprintf ("In loop: p_iterator->second = %p = %s statement = %p = %s \n",p_iterator->second,p_iterator->second->class_name().c_str(),statement,statement->class_name().c_str());
10876 : // SgNode* symbolBasis = p_iterator->second->get_symbol_basis();
10877 : SgSymbol* symbolFromTable = initializedName->get_symbol_from_symbol_table();
10878 : ROSE_ASSERT(symbolFromTable != NULL);
10879 : ROSE_ASSERT(symbolFromTable == sp);
10880 : }
10881 : else
10882 : {
10883 : mprintf ("Unknown symbol_base for input symbol sp = %p = %s sp->get_symbol_basis() = %p = %s \n",sp,sp->class_name().c_str(),sp->get_symbol_basis(),sp->get_symbol_basis()->class_name().c_str());
10884 : ROSE_ASSERT(false);
10885 : }
10886 : }
10887 : #endif
10888 :
10889 : #if 0
10890 : // DQ (1/27/2019): Adding test to check the symbol basis (failing for Cxx11_tests/test2019_31.C).
10891 : SgNode* symbolBasis = sp->get_symbol_basis();
10892 : if (isSgClassSymbol(sp) != NULL || isSgAliasSymbol(sp) != NULL)
10893 : {
10894 : ROSE_ASSERT(symbolBasis != NULL);
10895 : }
10896 :
10897 : // DQ (1/27/2019): Adding test to check the symbol basis (failing for Cxx11_tests/test2019_31.C).
10898 : // Get a quick pointer into the symbol table using the name (log n complexity)
10899 : p_iterator = p_table->find(nm);
10900 :
10901 : // Once we have p_iterator set via the name we don't typically have more than one iteration
10902 : while (p_iterator != p_table->end() && get_table()->key_eq()((*p_iterator).first,nm))
10903 : {
10904 : ROSE_ASSERT(p_iterator->second != NULL);
10905 : #if 0
10906 : mprintf ("In loop: p_iterator->second = %p statement = %p \n",p_iterator->second,statement);
10907 : mprintf ("In loop: p_iterator->second = %p = %s statement = %p = %s \n",p_iterator->second,p_iterator->second->class_name().c_str(),statement,statement->class_name().c_str());
10908 : #endif
10909 :
10910 : // This is a virtual function call (not defined for function type symbols)
10911 : SgNode* symbolBasis = p_iterator->second->get_symbol_basis();
10912 :
10913 : if (isSgAliasSymbol(p_iterator->second) != NULL)
10914 : {
10915 : ROSE_ASSERT(symbolBasis != NULL);
10916 : }
10917 :
10918 : p_iterator++;
10919 : }
10920 : #endif
10921 :
10922 : #if 0
10923 : mprintf ("********** Leaving SgSymbolTable::insert(%s,%p) into SgSymbolTable = %p = %s of scope = %p = %s sp = %p = %s \n",
10924 : nm.str(),sp,this,this->class_name().c_str(),this->get_parent(),this->get_parent()->class_name().c_str(),sp,sp->class_name().c_str());
10925 : #endif
10926 2404200 : }
10927 :
10928 :
10929 : /* ************************************************************************
10930 : REMOVE FUNCTIONS
10931 : ************************************************************************/
10932 :
10933 : // DQ (2/6/2007): This is too dangerous for use in ROSE (deletes all
10934 : // possible SgSymbols that match the input name independent of type).
10935 : // It is however currently used in the global function type symbol table
10936 : // so we have named this function to make its purpose more clear.
10937 : // This function is not likely called except where complex function type
10938 : // symbol table editing is required. Since SgFunctionTypeSymbols are
10939 : // shared removing such symbols is a rather dangerous actvity!
10940 : void
10941 0 : SgSymbolTable::remove_function_type( const SgName & name )
10942 : {
10943 : // This is non-destructive (does not delete the symbol, only removes it from the symbol table).
10944 :
10945 0 : ROSE_ASSERT (p_table != NULL);
10946 :
10947 : // CH (4/8/2010): Use boost::unordered instead
10948 0 : list<rose_hash_multimap::iterator> deleteList;
10949 0 : rose_hash_multimap::iterator it = get_table()->find(name);
10950 :
10951 : // DQ (11/27/2010): Adding support for case insensitive name lookup (using the rose_hash_multimap's key equality function).
10952 : // while (it != get_table()->end() && (*it).first == name)
10953 0 : while (it != get_table()->end() && get_table()->key_eq()((*it).first,name))
10954 : {
10955 0 : ROSE_ASSERT(it->second->variantT() == V_SgFunctionTypeSymbol);
10956 :
10957 0 : deleteList.push_back(it);
10958 0 : it++;
10959 : }
10960 : #if 0
10961 : mprintf ("In SgSymbolTable::remove_function_type( const SgName & name ): name = %s deleteList.size() = %" PRIuPTR " \n",name.str(),deleteList.size());
10962 : #endif
10963 :
10964 : // Now remove the copy of the symbol from the symbol table and insert the shared symbol
10965 : // CH (4/8/2010): Use boost::unordered instead
10966 0 : list<rose_hash_multimap::iterator>::iterator i = deleteList.begin();
10967 :
10968 0 : while (i != deleteList.end())
10969 : {
10970 : // DQ (5/9/2007): Moved to after the call to "p_symbolSet.erase((*i)->second);"
10971 : // Remove the existing symbol (associated with the function declaration we will be deleting from the AST.
10972 : // mprintf ("Erasing symbol %p from symbol table %p in scope = %p \n",(*i)->second,this,this->get_parent());
10973 : // get_table()->erase(*i);
10974 :
10975 : // DQ (3/10/2007): Remove the symbol from the symbol set used to test for if the symbol exists
10976 0 : p_symbolSet.erase((*i)->second);
10977 :
10978 : // Remove the existing symbol (associated with the function declaration we will be deleting from the AST.
10979 : // mprintf ("Erasing symbol %p from symbol table %p in scope = %p \n",(*i)->second,this,this->get_parent());
10980 0 : get_table()->erase(*i);
10981 :
10982 0 : i++;
10983 : }
10984 :
10985 0 : }
10986 :
10987 :
10988 : SgSymbol*
10989 8651950 : SgSymbolTable::find( const SgInitializedName* initializedName)
10990 : {
10991 8651950 : ROSE_ASSERT(p_table != NULL);
10992 8651950 : ROSE_ASSERT(initializedName != NULL);
10993 :
10994 : #define DEBUG_FIND_INITIALIZED_NAME_SYMBOL 0
10995 :
10996 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
10997 : mprintf ("Inside of SgSymbolTable::find( const SgInitializedName* ): initializedName = %p = %s \n",initializedName,SageInterface::get_name(initializedName).c_str());
10998 : #endif
10999 :
11000 8651950 : SgSymbol* returnSymbol = NULL;
11001 :
11002 17303900 : SgName name = initializedName->get_name();
11003 :
11004 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11005 : mprintf ("Inside of SgSymbolTable::find( const SgInitializedName* ): name = %s \n",name.str());
11006 : #endif
11007 :
11008 : // Find the first symbol in the multimap
11009 8651950 : p_iterator = p_table->find(name);
11010 :
11011 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11012 : mprintf ("Inside of SgSymbolTable::find( const SgInitializedName* ): name = %s this->count(name) = %d \n",name.str(),this->count(name));
11013 : #endif
11014 :
11015 : // Iterate through the matching symbols in the multimap
11016 : // while (p_iterator != p_table->end() && (*p_iterator).first == name)
11017 8708040 : while (p_iterator != p_table->end() && get_table()->key_eq()((*p_iterator).first,name))
11018 : {
11019 610129 : ROSE_ASSERT(p_iterator->second != NULL);
11020 610129 : SgNode* symbolBasis = p_iterator->second->get_symbol_basis();
11021 :
11022 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11023 : mprintf ("In loop: p_iterator->second = %p symbolBasis = %p initializedName = %p \n",p_iterator->second,symbolBasis,initializedName);
11024 : mprintf ("In loop: symbolBasis->variantT() = %d statement->variantT() = %d \n",symbolBasis->variantT(),initializedName->variantT());
11025 : #endif
11026 610129 : ROSE_ASSERT(symbolBasis != NULL);
11027 610129 : if (isSgInitializedName(symbolBasis) != NULL)
11028 : {
11029 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11030 : mprintf ("found a SgInitializedName \n");
11031 : #endif
11032 589123 : returnSymbol = p_iterator->second;
11033 589123 : if (returnSymbol->get_symbol_basis() == initializedName)
11034 : {
11035 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11036 : mprintf ("returnSymbol->get_symbol_basis() == initializedName returnSymbol = %p = %s \n",returnSymbol,returnSymbol->class_name().c_str());
11037 : #endif
11038 554046 : return returnSymbol;
11039 : }
11040 : else
11041 : {
11042 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11043 : mprintf ("returnSymbol->get_symbol_basis() != initializedName \n");
11044 : #endif
11045 : }
11046 : }
11047 : else
11048 : {
11049 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11050 : mprintf ("Some other symbol was found (no matching variants) \n");
11051 : #endif
11052 : }
11053 :
11054 56083 : p_iterator++;
11055 : }
11056 :
11057 : #if DEBUG_FIND_INITIALIZED_NAME_SYMBOL
11058 : mprintf ("Leaving SgSymbolTable::find( const SgInitializedName* ): return NULL \n");
11059 : #endif
11060 :
11061 : // DQ (2/13/2007): Fixed bug that returns a valid pointer even when there was no match to the input statement!
11062 : // return returnSymbol;
11063 : return NULL;
11064 : }
11065 :
11066 : SgSymbol*
11067 0 : SgSymbolTable::find( const SgFunctionType* functionType)
11068 : {
11069 0 : ROSE_ASSERT(p_table != NULL);
11070 0 : ROSE_ASSERT(functionType != NULL);
11071 :
11072 : #if 0
11073 : mprintf ("Inside of SgSymbolTable::find( const SgFunctionType* ): functionType = %p = %s \n",functionType,SageInterface::get_name(functionType).c_str());
11074 : #endif
11075 :
11076 0 : SgSymbol* returnSymbol = NULL;
11077 :
11078 0 : SgName name = functionType->get_mangled();
11079 :
11080 0 : p_iterator = p_table->find(name);
11081 : // while (p_iterator != p_table->end() && (*p_iterator).first == name)
11082 0 : while (p_iterator != p_table->end() && get_table()->key_eq()((*p_iterator).first,name))
11083 : {
11084 : // DQ (3/19/2016): This is an issue for Klocworks.
11085 : // if (isSgSymbol((*p_iterator).second)->variantT() == functionType->variantT())
11086 0 : SgSymbol* symbol = isSgSymbol((*p_iterator).second);
11087 0 : ROSE_ASSERT(symbol != NULL);
11088 0 : if (symbol->variantT() == functionType->variantT())
11089 : {
11090 0 : returnSymbol = p_iterator->second;
11091 0 : if (returnSymbol->get_symbol_basis() == functionType)
11092 0 : return returnSymbol;
11093 : }
11094 :
11095 0 : p_iterator++;
11096 : }
11097 :
11098 : // DQ (2/13/2007): Fixed bug that returns a valid pointer even when there was no match to the input statement!
11099 : // return returnSymbol;
11100 : return NULL;
11101 : }
11102 :
11103 : SgSymbol*
11104 14898900 : SgSymbolTable::find( const SgStatement* statement)
11105 : {
11106 14898900 : ROSE_ASSERT(p_table != NULL);
11107 14898900 : ROSE_ASSERT(statement != NULL);
11108 :
11109 : #define DEBUG_FIND_SYMBOL_FROM_STATEMENT 0
11110 :
11111 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11112 : mprintf ("Inside of SgSymbolTable::find( const SgStatement* ): statement = %p = %s = %s \n",statement,statement->class_name().c_str(),SageInterface::get_name(statement).c_str());
11113 : #endif
11114 :
11115 14898900 : SgSymbol* returnSymbol = NULL;
11116 :
11117 29797900 : SgName name = get_name(statement);
11118 : // Liao 11/28/2012: a declaration can have empty name "". But it will have a symbol with a mangled name starting with "__unnamed_".
11119 : // A ResetEmptyNames process to handle this should be used before this find is called.
11120 : // I cannot assert this since this function can be called before the empty name is reset.
11121 : // ROSE_ASSERT (name.getString().length() !=0);
11122 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11123 : mprintf ("Inside of SgSymbolTable::find( const SgStatement* ): name = %s \n",name.str());
11124 : #endif
11125 :
11126 : // Get a quick pointer into the symbol table using the name (log n complexity)
11127 14898900 : p_iterator = p_table->find(name);
11128 :
11129 : // Once we have p_iterator set via the name we don't typically have more than one iteration
11130 : // while (p_iterator != p_table->end() && (*p_iterator).first == name)
11131 17921900 : while (p_iterator != p_table->end() && get_table()->key_eq()((*p_iterator).first,name))
11132 : {
11133 15348000 : ROSE_ASSERT(p_iterator->second != NULL);
11134 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11135 : mprintf ("In loop: p_iterator->second = %p statement = %p \n",p_iterator->second,statement);
11136 : mprintf ("In loop: p_iterator->second = %p = %s statement = %p = %s \n",p_iterator->second,p_iterator->second->class_name().c_str(),statement,statement->class_name().c_str());
11137 : #endif
11138 :
11139 : // This is a virtual function call (not defined for function type symbols)
11140 15348000 : SgNode* symbolBasis = p_iterator->second->get_symbol_basis();
11141 :
11142 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11143 : mprintf ("In loop: statement->variantT() = %d = %s \n",
11144 : statement->variantT(),Cxx_GrammarTerminalNames[statement->variantT()].name.c_str());
11145 : #endif
11146 : // DQ (1/27/2019): Test this to see if we can generate a dot graph to debug the problem.
11147 15348000 : ROSE_ASSERT(symbolBasis != NULL);
11148 :
11149 : // if (symbolBasis != NULL)
11150 : // {
11151 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11152 : mprintf ("In loop: symbolBasis->variantT() = %d = %s statement->variantT() = %d = %s \n",
11153 : symbolBasis->variantT(),Cxx_GrammarTerminalNames[symbolBasis->variantT()].name.c_str(),
11154 : statement->variantT(),Cxx_GrammarTerminalNames[statement->variantT()].name.c_str());
11155 : #endif
11156 15348000 : ROSE_ASSERT(symbolBasis != NULL);
11157 :
11158 15348000 : if (symbolBasis->variantT() == statement->variantT())
11159 : {
11160 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11161 : mprintf ("matching variants \n");
11162 : #endif
11163 15295500 : returnSymbol = p_iterator->second;
11164 :
11165 : // This is a very precise test which might be a problem because of defining and non-defining versions
11166 : // of declarations (we might be able to always use the non-defining declaration in these cases. The
11167 : // switch which computes the names could normalize this aspect.
11168 15295500 : if (returnSymbol->get_symbol_basis() == statement)
11169 : {
11170 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11171 : mprintf ("returnSymbol->get_symbol_basis() == statement returnSymbol = %p = %s \n",returnSymbol,returnSymbol->class_name().c_str());
11172 : #endif
11173 12325100 : return returnSymbol;
11174 : }
11175 : else
11176 : {
11177 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11178 : mprintf ("returnSymbol->get_symbol_basis() != statement (returnSymbol->get_symbol_basis() = %p statement = %p) \n",returnSymbol->get_symbol_basis(),statement);
11179 : #endif
11180 : }
11181 : }
11182 : else
11183 : {
11184 : #if DEBUG_FIND_SYMBOL_FROM_STATEMENT
11185 : mprintf ("Some other symbol was found (no matching variants) \n");
11186 : #endif
11187 : }
11188 :
11189 : #if 0
11190 : }
11191 : else
11192 : {
11193 : mprintf ("################## In SgSymbolTable::find( const SgStatement* statement): symbolBasis == NULL \n");
11194 : mprintf (" --- statement = %p = %s = %s \n",statement,statement->class_name().c_str(),SageInterface::get_name(statement).c_str());
11195 : }
11196 : #endif
11197 3022920 : p_iterator++;
11198 : }
11199 : return NULL;
11200 : }
11201 :
11202 :
11203 : void
11204 26493 : SgSymbolTable::remove( const SgSymbol* symbol )
11205 : {
11206 : // This is used for the handled of non function type symbol tables, and is more useful when the
11207 : // symbols don't have unique names.
11208 :
11209 : // This is non-destructive (does not delete the symbol, only removes it from the symbol table).
11210 :
11211 26493 : ROSE_ASSERT (p_table != NULL);
11212 :
11213 : // DQ (11/20/2012): Make error checking dependent upon SYMBOL_TABLE_ERROR_CHECKING macro.
11214 : // #if 1
11215 : #if SYMBOL_TABLE_ERROR_CHECKING
11216 : // This is an expensive linear time search of the symbol table!
11217 : ROSE_ASSERT(exists(symbol) == true);
11218 : #endif
11219 :
11220 : // This is a virtual function call
11221 52986 : SgName name = symbol->get_name();
11222 : #if 0
11223 : // mprintf ("In SgSymbolTable::remove(SgSymbol* symbol = %p = %s = %s) from SgSymbolTable = %p \n",symbol,symbol->class_name().c_str(),SageInterface::get_name(symbol).c_str(),this);
11224 : SgNode* symbolBasis = symbol->get_symbol_basis();
11225 : ROSE_ASSERT(symbolBasis != NULL);
11226 : mprintf ("In SgSymbolTable::remove(SgSymbol* symbol = %p = %s = %s) symbol_basis = %p = %s = %s from SgSymbolTable = %p \n",
11227 : symbol,symbol->class_name().c_str(),SageInterface::get_name(symbol).c_str(),
11228 : symbolBasis,symbolBasis->class_name().c_str(),SageInterface::get_name(symbolBasis).c_str(),this);
11229 : #endif
11230 : // CH (4/8/2010): Use boost::unordered instead
11231 : //#ifdef _MSCx_VER
11232 : // rose_hash::unordered_multimap<SgName, SgSymbol*>::iterator elementToDelete = get_table()->end();
11233 : // rose_hash::unordered_multimap<SgName, SgSymbol*>::iterator it = get_table()->find(name);
11234 : //#else
11235 26493 : rose_hash_multimap::iterator elementToDelete = get_table()->end();
11236 26493 : rose_hash_multimap::iterator it = get_table()->find(name);
11237 : //#endif
11238 : // while ( (it != get_table()->end()) && (elementToDelete == get_table()->end()) && ((*it).first == name) )
11239 83485 : while ( (it != get_table()->end()) && (elementToDelete == get_table()->end()) && get_table()->key_eq()((*it).first,name) )
11240 : {
11241 : // mprintf ("Looking for symbol to remove (Make sure that we find the correct element) \n");
11242 : // Make sure that we find the correct element
11243 56992 : if (it->second == symbol)
11244 : {
11245 : // mprintf ("Found iterator for symbol = %p \n",symbol);
11246 26493 : elementToDelete = it;
11247 : }
11248 56992 : it++;
11249 : }
11250 : #if 0
11251 : // #if SYMBOL_TABLE_ERROR_CHECKING
11252 : // DQ (2/11/2007): This is part of making the symbol table use more precise.
11253 : if (elementToDelete == get_table()->end())
11254 : {
11255 : mprintf ("Error: could not find symbol name = %s in symbol table (restart search using symbol pointer) \n",name.str());
11256 :
11257 : // DQ (2/19/2007): Added assertion to exit on error! Enforcing this allows us to
11258 : // make sure that the complexity is not linear in the size of the symbol table!
11259 : ROSE_ASSERT(false);
11260 :
11261 : rose_hash_multimap::iterator i = get_table()->begin();
11262 : while ( (i != get_table()->end()) && (elementToDelete == get_table()->end()) )
11263 : {
11264 : // mprintf ("Looking for symbol to remove (Make sure that we find the correct element) \n");
11265 : // Make sure that we find the correct element
11266 : if (i->second == symbol)
11267 : {
11268 : // mprintf ("Found iterator for symbol = %p \n",symbol);
11269 : elementToDelete = i;
11270 : }
11271 : i++;
11272 : }
11273 :
11274 : if (elementToDelete != get_table()->end())
11275 : {
11276 : mprintf ("Warning: found symbol = %p = %s stored under a different name = %s \n",symbol,symbol->class_name().c_str(),elementToDelete->first.str());
11277 : mprintf ("Location of problem in source code: \n");
11278 : SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(symbol->get_symbol_basis());
11279 : if (declarationStatement != NULL)
11280 : {
11281 : mprintf ("declarationStatement = %p = %s \n",declarationStatement,declarationStatement->class_name().c_str());
11282 : declarationStatement->get_startOfConstruct()->display("location of problem: debug");
11283 : }
11284 : ROSE_ASSERT(false);
11285 : }
11286 : }
11287 : #endif
11288 :
11289 : #if 0
11290 : // DQ (2/13/2007): Now we really have an error to report
11291 : // Make sure we found the input element to be removed!
11292 : if (elementToDelete == get_table()->end())
11293 : {
11294 : mprintf ("Error: could not find symbol = %p name = %s in symbol table (failed to find symbol pointer under any name) \n",symbol,name.str());
11295 : ROSE_ASSERT(false);
11296 : }
11297 : #endif
11298 :
11299 : #if 1
11300 : // DQ (8/15/2020): Original code before the chagne below.
11301 26493 : ROSE_ASSERT(elementToDelete != get_table()->end());
11302 :
11303 : // DQ (5/9/2007): Moved to after the call to "p_symbolSet.erase(elementToDelete->second);"
11304 : // get_table()->erase(elementToDelete);
11305 :
11306 : // DQ (3/10/2007): Remove the symbol from the symbol set used to test for if the symbol exists
11307 : // p_symbolSet.erase(symbol);
11308 26493 : p_symbolSet.erase(elementToDelete->second);
11309 :
11310 26493 : get_table()->erase(elementToDelete);
11311 : #else
11312 : // DQ (8/15/2020): The internal support for using directives in C++ has been modified to correctly filter
11313 : // the addition of symbols which could lead to ambiguity. Craig and I think that the rules no implemented
11314 : // may be inconsistant with the use of the lower level infrastructire for Fortran. And we are sorting
11315 : // this out. For now it is not an error to remove a symbol that is not present in the symbol table.
11316 : // assert(elementToDelete != get_table()->end());
11317 : if (elementToDelete != get_table()->end())
11318 : {
11319 : // DQ (5/9/2007): Moved to after the call to "p_symbolSet.erase(elementToDelete->second);"
11320 : // get_table()->erase(elementToDelete);
11321 :
11322 : // DQ (3/10/2007): Remove the symbol from the symbol set used to test for if the symbol exists
11323 : // p_symbolSet.erase(symbol);
11324 : p_symbolSet.erase(elementToDelete->second);
11325 :
11326 : get_table()->erase(elementToDelete);
11327 : }
11328 : else
11329 : {
11330 : // assert(exists(symbol) == true);
11331 : if (exists(symbol) == true)
11332 : {
11333 : // Nothing to do, this should have been found above.
11334 : }
11335 : else
11336 : {
11337 : printf ("The symbol to remove was not in the symbol table for this scope: symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11338 : }
11339 : }
11340 :
11341 : #endif
11342 26493 : }
11343 :
11344 :
11345 : /* ************************************************************************
11346 : FIND FUNCTIONS
11347 : ************************************************************************/
11348 :
11349 : // DQ (11/27/2010): Change return type to "bool".
11350 : // DQ (2/10/2007): This is a depricated function
11351 : // int (changed the return type)
11352 : bool
11353 0 : SgSymbolTable::find(const SgName & nm, SgSymbol *sp)
11354 : {
11355 0 : ROSE_ASSERT(p_table != NULL);
11356 :
11357 : // if(!p_table)
11358 : // return NULL;
11359 :
11360 : // DQ (5/22/2006): Made this a local variable
11361 : // hash_iterator p_iterator = p_table->find(nm);
11362 0 : p_iterator = p_table->find(nm);
11363 : // while (p_iterator != p_table->end() && (*p_iterator).first == nm)
11364 : // while (p_iterator != p_table->end() && p_iterator->first == nm)
11365 0 : while (p_iterator != p_table->end() && get_table()->key_eq()(p_iterator->first,nm))
11366 : {
11367 0 : p_name = nm;
11368 0 : p_no_name = false;
11369 : // if( ((SgSymbol *)(*p_iterator).second) == sp )
11370 0 : if( p_iterator->second == sp )
11371 : return true;
11372 0 : p_iterator++;
11373 : }
11374 :
11375 : return false;
11376 : }
11377 :
11378 : SgAliasSymbol*
11379 914755 : SgSymbolTable::find_aliased_symbol(const SgName & nm, SgSymbol *sp)
11380 : {
11381 : // DQ (5/19/2013): This function finds the symbol for which the alias is sp, not the symbol to be returned being sp.
11382 914755 : ROSE_ASSERT(p_table != NULL);
11383 :
11384 914755 : ROSE_ASSERT(sp != NULL);
11385 :
11386 : #if 0
11387 : mprintf ("In SgSymbolTable::find_aliased_symbol(): We are only using the name = %s sp = %p = %s (not any template arguments or template parameters) \n",nm.str(),sp,sp->class_name().c_str());
11388 : #endif
11389 :
11390 914755 : p_iterator = p_table->find(nm);
11391 :
11392 943271 : while (p_iterator != p_table->end() && get_table()->key_eq()(p_iterator->first,nm))
11393 : {
11394 49050 : p_name = nm;
11395 49050 : p_no_name = false;
11396 :
11397 49050 : ROSE_ASSERT(p_iterator->second != NULL);
11398 : #if 0
11399 : mprintf ("In SgSymbolTable::find_aliased_symbol(): in loop: nm = %s p_iterator->second = %p = %s \n",nm.str(),p_iterator->second,p_iterator->second->class_name().c_str());
11400 : #endif
11401 :
11402 : // if( p_iterator->second == sp )
11403 49050 : SgAliasSymbol* aliasSymbol = isSgAliasSymbol(p_iterator->second);
11404 49050 : if ( (aliasSymbol != NULL) && (aliasSymbol->get_alias() == sp) )
11405 : {
11406 20534 : return aliasSymbol;
11407 : }
11408 :
11409 28516 : p_iterator++;
11410 : }
11411 :
11412 : return NULL;
11413 : }
11414 :
11415 :
11416 : // DQ (1/31/2007): New functions that will replace the depricated find() member function
11417 : bool
11418 61103 : SgSymbolTable::exists ( const SgName & nm ) const
11419 : {
11420 61103 : ROSE_ASSERT(p_table != NULL);
11421 61103 : return p_table->find(nm) != p_table->end();
11422 : }
11423 :
11424 : // DQ (1/31/2007): New functions that will replace the depricated find() member function
11425 : bool
11426 45071 : SgSymbolTable::exists ( const SgSymbol *sp ) const
11427 : {
11428 : // DQ (3/10/2007): We can now use the stored p_symbolSet (STL set of SgNode*) to do this test more efficiently.
11429 : // return p_symbolSet.find(sp) != p_symbolSet.end();
11430 45071 : return p_symbolSet.find(const_cast<SgSymbol*>(sp)) != p_symbolSet.end();
11431 : }
11432 :
11433 : // DQ (1/31/2007): New functions that will replace the depricated find() member function
11434 : bool
11435 1137190 : SgSymbolTable::exists ( const SgName & nm, SgSymbol *sp ) const
11436 : {
11437 : // DQ (3/10/2007): We can now use the stored p_symbolSet (STL set of SgNode*) to do this test more efficiently.
11438 : // Since we if we find the symbol it exists, we can test the name separately
11439 : // bool returnValue = false;
11440 :
11441 : // Test if the symbol is in the set, else the name is not relavant to the existence
11442 2274380 : if (p_symbolSet.find(sp) != p_symbolSet.end())
11443 : {
11444 : // Now look to make sure that we have an entry with the correct name (and pointer value)
11445 2894 : hash_iterator p_iterator = p_table->find(nm);
11446 : // while (p_iterator != p_table->end() && p_iterator->first == nm)
11447 2932 : while (p_iterator != p_table->end() && get_table()->key_eq()(p_iterator->first,nm))
11448 : {
11449 2932 : if ( p_iterator->second == sp )
11450 : {
11451 : // This allows us to short-circuit the rest of the iterations
11452 1137190 : return true;
11453 : }
11454 :
11455 38 : p_iterator++;
11456 : }
11457 : }
11458 :
11459 : return false;
11460 : }
11461 :
11462 : /* ************************************************************************
11463 : DQ (1/30/2007): Added remove functions for each sort of SgSymbol IR node
11464 : ************************************************************************
11465 : SgSymbol* find_any(const SgName &);
11466 : SgVariableSymbol* find_variable(const SgName &);
11467 : SgClassSymbol* find_class(const SgName &);
11468 : SgFunctionSymbol* find_function(const SgName&);
11469 : SgFunctionSymbol* find_function_type(const SgName&, const SgType*);
11470 : SgTypedefSymbol* find_typedef(const SgName &);
11471 : SgEnumSymbol* find_enum(const SgName &);
11472 : SgEnumFieldSymbol* find_enum_field(const SgName &);
11473 : SgLabelSymbol* find_label(const SgName &) const;
11474 : SgNamespaceSymbol* find_namespace(const SgName &);
11475 : */
11476 :
11477 : #if 0
11478 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
11479 : SgSymbol*
11480 : SgSymbolTable::findany(const SgName &nm)
11481 : {
11482 : return find_any(nm);
11483 : }
11484 : #endif
11485 :
11486 : // SgSymbol* SgSymbolTable::find_any(const SgName & nm)
11487 : SgSymbol*
11488 2631300 : SgSymbolTable::find_any(const SgName & nm, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList)
11489 : {
11490 : // DQ (8/21/2013): Modified to use single supporting templated lower level function.
11491 : // DQ (6/24/2013): This special case requires some special support in find_symbol_support.
11492 : // return find_symbol_support<SgSymbol>(nm,templateParameterList,templateArgumentList);
11493 2631300 : bool filterTemplateSymbols = false;
11494 2631300 : return find_symbol_with_type_support<SgSymbol>(nm,NULL,templateParameterList,templateArgumentList,filterTemplateSymbols);
11495 : }
11496 :
11497 : // DQ (1/30/2007): Added these back into ROSE.
11498 : SgTypedefSymbol*
11499 22308 : SgSymbolTable::find_typedef(const SgName & nm)
11500 : {
11501 : // DQ (8/21/2013): Modified to use single supporting templated lower level function.
11502 : // return find_symbol_support<SgTypedefSymbol>(nm,NULL,NULL);
11503 22308 : bool filterTemplateSymbols = false;
11504 22308 : return find_symbol_with_type_support<SgTypedefSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
11505 : }
11506 :
11507 : // DQ (1/30/2007): Added these back into ROSE.
11508 : SgEnumSymbol*
11509 12492 : SgSymbolTable::find_enum(const SgName & nm)
11510 : {
11511 : // DQ (8/21/2013): Modified to use single supporting templated lower level function.
11512 : // return find_symbol_support<SgEnumSymbol>(nm,NULL,NULL);
11513 12492 : bool filterTemplateSymbols = false;
11514 12492 : return find_symbol_with_type_support<SgEnumSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
11515 : }
11516 :
11517 : // DQ (1/30/2007): Added these back into ROSE.
11518 : SgEnumFieldSymbol*
11519 20666 : SgSymbolTable::find_enum_field(const SgName & nm)
11520 : {
11521 : // DQ (8/21/2013): Modified to use single supporting templated lower level function.
11522 : // return find_symbol_support<SgEnumFieldSymbol>(nm,NULL,NULL);
11523 20666 : bool filterTemplateSymbols = false;
11524 20666 : return find_symbol_with_type_support<SgEnumFieldSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
11525 : }
11526 :
11527 : #if 0
11528 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
11529 : SgVariableSymbol*
11530 : SgSymbolTable::findvar(const SgName & nm)
11531 : {
11532 : return find_variable(nm);
11533 : }
11534 : #endif
11535 :
11536 : SgVariableSymbol*
11537 193119 : SgSymbolTable::find_variable(const SgName & nm)
11538 : {
11539 : // DQ (8/21/2013): Modified to use single supporting templated lower level function.
11540 : #if 0
11541 : SgVariableSymbol* s = find_symbol_support<SgVariableSymbol>(nm,NULL,NULL);
11542 :
11543 : // DQ (5/23/2013): Report when we are not being strict in the symbol that we return.
11544 : if (isSgTemplateVariableSymbol(s) != NULL)
11545 : {
11546 : mprintf ("WARNING: returing a SgTemplateVariableSymbol from find_symbol_support<SgVariableSymbol>(nm = %s); \n",nm.str());
11547 : }
11548 :
11549 : return s;
11550 : #endif
11551 193119 : bool filterTemplateSymbols = false;
11552 193119 : return find_symbol_with_type_support<SgVariableSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
11553 : }
11554 :
11555 : #if 0
11556 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
11557 : SgClassSymbol*
11558 : SgSymbolTable::findclass(const SgName &nm)
11559 : {
11560 : return find_class(nm);
11561 : }
11562 : #endif
11563 :
11564 : SgClassSymbol*
11565 0 : SgSymbolTable::find_class(const SgName & nm)
11566 : {
11567 : // DQ (8/21/2013): Modified to use single supporting templated lower level function.
11568 : // SgClassSymbol* s = find_symbol_support<SgClassSymbol>(nm,NULL,NULL);
11569 0 : bool filterTemplateSymbols = false;
11570 0 : SgClassSymbol* s = find_symbol_with_type_support<SgClassSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
11571 :
11572 : // DQ (5/23/2013): Report when we are not being strict in the symbol that we return.
11573 0 : if (isSgTemplateClassSymbol(s) != NULL)
11574 : {
11575 0 : mprintf ("WARNING: returing a SgTemplateClassSymbol from find_symbol_support<SgClassSymbol>(nm = %s); \n",nm.str());
11576 : }
11577 :
11578 0 : return s;
11579 : }
11580 :
11581 : #if 0
11582 : // DQ (1/23/2019): This function adds the support to find the SgAlias symbols of a given name.
11583 : // This is important in handling the viability of symbols through base classes when private base
11584 : // class derivation is used.
11585 : SgAliasSymbol*
11586 : SgSymbolTable::find_alias(const SgName & nm)
11587 : {
11588 : #if 0
11589 : mprintf ("In SgSymbolTable::find_alias(): nm = %s \n",nm.str());
11590 : #endif
11591 : bool filterTemplateSymbols = false;
11592 : return find_symbol_with_type_support<SgAliasSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
11593 : }
11594 : #endif
11595 :
11596 :
11597 : #define DEBUG_MATCHING_TEMPLATE_ARGUMENTS 0
11598 :
11599 : bool
11600 7115310 : SgSymbolTable::hasMatchingTemplateParametersArgumentsOrNoTemplateParametersArguments(SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentsList, SgSymbol* symbol)
11601 : {
11602 : // DQ (8/8/2013): I don't think that we need to handle the case of where there is both a valid SgTemplateParameterPtrList and SgTemplateArgumentPtrList.
11603 7115310 : bool returnValue = false;
11604 :
11605 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
11606 : mprintf ("In TOP SgSymbolTable::hasMatchingTemplateParametersArgumentsOrNoTemplateParametersArguments(): templateParameterList = %p templateArgumentsList = %p \n",templateParameterList,templateArgumentsList);
11607 : #endif
11608 :
11609 7115310 : if (templateParameterList != NULL)
11610 : {
11611 : // Note that this should be a template case if template parameters were specified.
11612 :
11613 : // DQ (8/19/2013): template classes need to use both the template parameter list and the template argument list.
11614 175162 : returnValue = hasMatchingTemplateParametersOrNoTemplateParameters(templateParameterList,symbol);
11615 :
11616 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
11617 : mprintf ("In SgSymbolTable::hasMatchingTemplateParametersArgumentsOrNoTemplateParametersArguments(): after evaluation of templateParameterList: templateParameterList = %p templateArgumentsList = %p returnValue = %s \n",templateParameterList,templateArgumentsList,returnValue ? "true" : "false");
11618 : #endif
11619 :
11620 175162 : if (returnValue == true && templateArgumentsList != NULL)
11621 : {
11622 : // Since this function can be called when searching on the most general case of SgSymbol, we have to
11623 : // permit this case to be evaluated. However, since it only make sense for SgTemplateClassSymbol we
11624 : // can return "true" for all other cases.
11625 : // This case should only be for template class symbols (case of partial specialization).
11626 : // SgTemplateClassSymbol* templateClassSymbol = isSgTemplateClassSymbol(symbol);
11627 46913 : if (isSgTemplateClassSymbol(symbol) != NULL)
11628 : {
11629 27868 : returnValue = hasMatchingTemplateArgumentsOrNoTemplateArguments(templateArgumentsList,symbol);
11630 : }
11631 : else
11632 : {
11633 : // DQ (5/22/2016): Isn't this an error to not also test the template arguments for non-class templates.
11634 : #if 0
11635 : mprintf ("WARNING: Isn't this an error to not also test the template arguments for non-class templates. \n");
11636 : #endif
11637 : // return "returnValue == true" for all other cases.
11638 : }
11639 : }
11640 : }
11641 : else
11642 : {
11643 : // This is not a template and is either an instantiation of a template or non-instantiation (normal class, function, etc.).
11644 6940150 : returnValue = hasMatchingTemplateArgumentsOrNoTemplateArguments(templateArgumentsList,symbol);
11645 : }
11646 :
11647 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
11648 : mprintf ("In SgSymbolTable::hasMatchingTemplateParametersArgumentsOrNoTemplateParametersArguments() templateParameterList = %p templateArgumentsList = %p returnValue = %s \n",templateParameterList,templateArgumentsList,returnValue ? "true" : "false");
11649 : #endif
11650 :
11651 7115310 : return returnValue;
11652 : }
11653 :
11654 : bool
11655 175162 : SgSymbolTable::hasMatchingTemplateParametersOrNoTemplateParameters(SgTemplateParameterPtrList* templateParameterList, SgSymbol* symbol)
11656 : {
11657 : // This is an overloaded function.
11658 :
11659 : // This function hides the details of calling the template version of the function.
11660 : // return hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments<SgTemplateParameterPtrList>(templateParameterList,symbol);
11661 175162 : return hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments<SgTemplateParameter>(templateParameterList,symbol);
11662 : }
11663 :
11664 : bool
11665 6968020 : SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(SgTemplateArgumentPtrList* templateArgumentsList, SgSymbol* symbol)
11666 : {
11667 : // This is an overloaded function.
11668 :
11669 : // This is the refactored version of the previous function API.
11670 : // This function hides the details of calling the template version of the function.
11671 : // return hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments<SgTemplateArgumentPtrList>(templateArgumentsList,symbol);
11672 6968020 : return hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments<SgTemplateArgument>(templateArgumentsList,symbol);
11673 : }
11674 :
11675 : // DQ (8/10/2013): Base template for specializations specific to template arguments and template parameters.
11676 : template <class T> std::vector<T*> getTemplateParametersOrArgumentsList(SgSymbol* symbol)
11677 : {
11678 : return std::vector<T*>();
11679 : }
11680 :
11681 : template <>
11682 209054 : std::vector<SgTemplateArgument*> getTemplateParametersOrArgumentsList<SgTemplateArgument>(SgSymbol* symbol)
11683 : {
11684 : // Template specialization for handling template arguments.
11685 :
11686 : // DQ (8/11/2013): This function uses the STL copy operation and might have a more efficient implementation.
11687 209054 : std::vector<SgTemplateArgument*> returnList;
11688 :
11689 209054 : ROSE_ASSERT(symbol != NULL);
11690 : #if 0
11691 : mprintf ("In getTemplateParametersOrArgumentsList<SgTemplateArgument>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11692 : #endif
11693 209054 : switch(symbol->variantT())
11694 : {
11695 145928 : case V_SgClassSymbol:
11696 145928 : {
11697 145928 : SgClassSymbol* classSymbol = isSgClassSymbol(symbol);
11698 145928 : ROSE_ASSERT(classSymbol != NULL);
11699 :
11700 145928 : SgClassDeclaration* classDeclaration = classSymbol->get_declaration();
11701 145928 : ROSE_ASSERT(classDeclaration != NULL);
11702 145928 : SgTemplateInstantiationDecl* templateClassInstantiation = isSgTemplateInstantiationDecl(classDeclaration);
11703 145928 : if (templateClassInstantiation != NULL)
11704 : {
11705 117618 : returnList = templateClassInstantiation->get_templateArguments();
11706 : }
11707 : break;
11708 : }
11709 :
11710 4362 : case V_SgFunctionSymbol:
11711 4362 : {
11712 4362 : SgFunctionSymbol* functionSymbol = isSgFunctionSymbol(symbol);
11713 4362 : ROSE_ASSERT(functionSymbol != NULL);
11714 :
11715 4362 : SgFunctionDeclaration* functionDeclaration = functionSymbol->get_declaration();
11716 4362 : ROSE_ASSERT(functionDeclaration != NULL);
11717 4362 : SgTemplateInstantiationFunctionDecl* templateFunctionInstantiation = isSgTemplateInstantiationFunctionDecl(functionDeclaration);
11718 4362 : if (templateFunctionInstantiation != NULL)
11719 : {
11720 4330 : returnList = templateFunctionInstantiation->get_templateArguments();
11721 : }
11722 : break;
11723 : }
11724 :
11725 : // DQ (8/12/2013): Added case for SgMemberFunctionSymbol
11726 27062 : case V_SgMemberFunctionSymbol:
11727 27062 : {
11728 27062 : SgMemberFunctionSymbol* memberFunctionSymbol = isSgMemberFunctionSymbol(symbol);
11729 27062 : ROSE_ASSERT(memberFunctionSymbol != NULL);
11730 :
11731 27062 : SgMemberFunctionDeclaration* memberFunctionDeclaration = memberFunctionSymbol->get_declaration();
11732 27062 : ROSE_ASSERT(memberFunctionDeclaration != NULL);
11733 27062 : SgTemplateInstantiationMemberFunctionDecl* templateMemberFunctionInstantiation = isSgTemplateInstantiationMemberFunctionDecl(memberFunctionDeclaration);
11734 27062 : if (templateMemberFunctionInstantiation != NULL)
11735 : {
11736 24392 : returnList = templateMemberFunctionInstantiation->get_templateArguments();
11737 : }
11738 : break;
11739 : }
11740 :
11741 : // DQ (8/19/2013): Added case for SgTemplateClassSymbol
11742 27868 : case V_SgTemplateClassSymbol:
11743 27868 : {
11744 27868 : SgTemplateClassSymbol* templateClassSymbol = isSgTemplateClassSymbol(symbol);
11745 27868 : ROSE_ASSERT(templateClassSymbol != NULL);
11746 :
11747 27868 : ROSE_ASSERT(templateClassSymbol->get_declaration() != NULL);
11748 :
11749 : // SgTemplateClassDeclaration* templateClassDeclaration = templateClassSymbol->get_declaration();
11750 27868 : SgTemplateClassDeclaration* templateClassDeclaration = isSgTemplateClassDeclaration(templateClassSymbol->get_declaration());
11751 : // ROSE_ASSERT(templateClassDeclaration != NULL);
11752 :
11753 27868 : if (templateClassDeclaration != NULL)
11754 : {
11755 27868 : returnList = templateClassDeclaration->get_templateSpecializationArguments();
11756 : }
11757 : break;
11758 : }
11759 :
11760 0 : case V_SgTemplateVariableSymbol:
11761 0 : {
11762 0 : SgTemplateVariableSymbol* vsym = isSgTemplateVariableSymbol(symbol);
11763 0 : ROSE_ASSERT(vsym != NULL);
11764 :
11765 0 : SgInitializedName* iname = vsym->get_declaration();
11766 0 : ROSE_ASSERT(iname != NULL);
11767 :
11768 0 : SgTemplateVariableDeclaration * tplvdecl = isSgTemplateVariableDeclaration(iname->get_parent());
11769 0 : ROSE_ASSERT(tplvdecl != NULL);
11770 :
11771 0 : returnList = tplvdecl->get_templateSpecializationArguments();
11772 : break;
11773 : }
11774 :
11775 : // DQ (9/12/2016): Providing better implementation for template typedef symbol support.
11776 : // DQ (11/10/2014): Providing an initial implementation for template typedef symbol support.
11777 1476 : case V_SgTemplateTypedefSymbol:
11778 1476 : {
11779 : #if 0
11780 : mprintf ("WARNING: returning NULL in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateArgument>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11781 : #endif
11782 1476 : SgTemplateTypedefSymbol* templateTypedefSymbol = isSgTemplateTypedefSymbol(symbol);
11783 1476 : ROSE_ASSERT(templateTypedefSymbol != NULL);
11784 :
11785 1476 : ROSE_ASSERT(templateTypedefSymbol->get_declaration() != NULL);
11786 :
11787 1476 : SgTemplateTypedefDeclaration* templateTypedefDeclaration = isSgTemplateTypedefDeclaration(templateTypedefSymbol->get_declaration());
11788 : // ROSE_ASSERT(templateTypedefDeclaration != NULL);
11789 :
11790 1476 : if (templateTypedefDeclaration != NULL)
11791 : {
11792 : // returnList = templateTypedefDeclaration->get_templateArguments();
11793 0 : returnList = templateTypedefDeclaration->get_templateSpecializationArguments();
11794 : }
11795 : break;
11796 : }
11797 :
11798 : #if 0
11799 : // We have to support these sorts of declarations in the name qualifiaction.
11800 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(declaration);
11801 : SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(declaration);
11802 : SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(declaration);
11803 : SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(declaration);
11804 : SgTemplateDeclaration* templateDeclaration = isSgTemplateDeclaration(declaration);
11805 : SgEnumDeclaration* enumDeclaration = isSgEnumDeclaration(declaration);
11806 : SgNamespaceDeclarationStatement* namespaceDeclaration = isSgNamespaceDeclarationStatement(declaration);
11807 : #endif
11808 :
11809 : // DQ (4/10/2017): Added case for other symbols (but we only return the empty list for this case).
11810 : case V_SgLabelSymbol:
11811 :
11812 : // DQ (8/19/2013): Added case for other symbols (but we only return the empty list for this case).
11813 : case V_SgVariableSymbol:
11814 : case V_SgTypedefSymbol:
11815 : case V_SgEnumSymbol:
11816 : case V_SgEnumFieldSymbol:
11817 : case V_SgNamespaceSymbol:
11818 : {
11819 : // This function requires this case so that it can be called within very general contexts.
11820 : // However, for this case we only return the empty template parameter list.
11821 :
11822 : break;
11823 : }
11824 :
11825 2358 : case V_SgNonrealSymbol:
11826 2358 : {
11827 : #if 0
11828 : mprintf ("In SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateArgument>(): Case of SgNonrealSymbol\n");
11829 : #endif
11830 2358 : SgNonrealSymbol * nrsym = isSgNonrealSymbol(symbol);
11831 2358 : ROSE_ASSERT(nrsym != NULL);
11832 2358 : SgNonrealDecl * nrdecl = isSgNonrealDecl(nrsym->get_declaration());
11833 2358 : ROSE_ASSERT(nrdecl != NULL);
11834 2358 : returnList = nrdecl->get_tpl_args();
11835 : break;
11836 : }
11837 :
11838 0 : case V_SgTemplateSymbol:
11839 0 : {
11840 0 : mprintf ("Case of SgTemplateSymbol not handled yet in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateArgument>() \n");
11841 0 : ROSE_ASSERT(false);
11842 : break;
11843 : }
11844 :
11845 0 : default:
11846 0 : {
11847 0 : mprintf ("Error: Default reached in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateArgument>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11848 0 : ROSE_ASSERT(false);
11849 : }
11850 : }
11851 :
11852 209054 : return returnList;
11853 : }
11854 :
11855 : template <>
11856 175162 : std::vector<SgTemplateParameter*> getTemplateParametersOrArgumentsList<SgTemplateParameter>(SgSymbol* symbol)
11857 : {
11858 : // Template specialization for handling template parameters.
11859 :
11860 : // DQ (8/11/2013): This function uses the STL copy operation and might have a more efficient implementation.
11861 175162 : std::vector<SgTemplateParameter*> returnList;
11862 :
11863 175162 : ROSE_ASSERT(symbol != NULL);
11864 :
11865 : #if 0
11866 : mprintf ("In getTemplateParametersOrArgumentsList<SgTemplateParameter>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11867 : #endif
11868 :
11869 175162 : switch(symbol->variantT())
11870 : {
11871 49562 : case V_SgTemplateClassSymbol:
11872 49562 : {
11873 49562 : SgTemplateClassSymbol* templateClassSymbol = isSgTemplateClassSymbol(symbol);
11874 49562 : ROSE_ASSERT(templateClassSymbol != NULL);
11875 :
11876 49562 : SgClassDeclaration* classDeclaration = templateClassSymbol->get_declaration();
11877 49562 : ROSE_ASSERT(classDeclaration != NULL);
11878 49562 : SgTemplateClassDeclaration* templateClassDeclaration = isSgTemplateClassDeclaration(classDeclaration);
11879 49562 : if (templateClassDeclaration != NULL)
11880 : {
11881 49562 : returnList = templateClassDeclaration->get_templateParameters();
11882 : }
11883 : break;
11884 : }
11885 :
11886 33338 : case V_SgTemplateFunctionSymbol:
11887 33338 : {
11888 33338 : SgTemplateFunctionSymbol* templateFunctionSymbol = isSgTemplateFunctionSymbol(symbol);
11889 33338 : ROSE_ASSERT(templateFunctionSymbol != NULL);
11890 :
11891 33338 : SgFunctionDeclaration* functionDeclaration = templateFunctionSymbol->get_declaration();
11892 33338 : ROSE_ASSERT(functionDeclaration != NULL);
11893 33338 : SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(functionDeclaration);
11894 33338 : if (templateFunctionDeclaration != NULL)
11895 : {
11896 : #if 0
11897 : mprintf ("In getTemplateParametersOrArgumentsList<SgTemplateParameter>(): Get the template parameter lise from templateFunctionDeclaration = %p = %s name = %s \n",
11898 : templateFunctionDeclaration,templateFunctionDeclaration->class_name().c_str(),templateFunctionDeclaration->get_name().str());
11899 : #endif
11900 33338 : returnList = templateFunctionDeclaration->get_templateParameters();
11901 : }
11902 : else
11903 : {
11904 0 : mprintf ("Error: Default reached in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateParameter>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11905 0 : ROSE_ASSERT(false);
11906 : }
11907 : break;
11908 : }
11909 :
11910 : // DQ (8/12/2013): Added case for SgTemplateMemberFunctionSymbol
11911 81421 : case V_SgTemplateMemberFunctionSymbol:
11912 81421 : {
11913 81421 : SgTemplateMemberFunctionSymbol* templateMemberFunctionSymbol = isSgTemplateMemberFunctionSymbol(symbol);
11914 81421 : ROSE_ASSERT(templateMemberFunctionSymbol != NULL);
11915 :
11916 81421 : SgMemberFunctionDeclaration* memberFunctionDeclaration = templateMemberFunctionSymbol->get_declaration();
11917 81421 : ROSE_ASSERT(memberFunctionDeclaration != NULL);
11918 81421 : SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = isSgTemplateMemberFunctionDeclaration(memberFunctionDeclaration);
11919 81421 : if (templateMemberFunctionDeclaration != NULL)
11920 : {
11921 : #if 0
11922 : mprintf ("In getTemplateParametersOrArgumentsList<SgTemplateParameter>(): Get the template parameter lise from templateFunctionDeclaration = %p = %s name = %s \n",
11923 : templateMemberFunctionDeclaration,templateMemberFunctionDeclaration->class_name().c_str(),templateMemberFunctionDeclaration->get_name().str());
11924 : #endif
11925 81421 : returnList = templateMemberFunctionDeclaration->get_templateParameters();
11926 : }
11927 : else
11928 : {
11929 0 : mprintf ("Error: Default reached in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateParameter>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11930 0 : ROSE_ASSERT(false);
11931 : }
11932 : break;
11933 : }
11934 :
11935 485 : case V_SgTemplateVariableSymbol:
11936 485 : {
11937 485 : SgTemplateVariableSymbol* vsym = isSgTemplateVariableSymbol(symbol);
11938 485 : ROSE_ASSERT(vsym != NULL);
11939 :
11940 485 : SgInitializedName* iname = vsym->get_declaration();
11941 485 : ROSE_ASSERT(iname != NULL);
11942 :
11943 485 : SgTemplateVariableDeclaration * tplvdecl = isSgTemplateVariableDeclaration(iname->get_parent());
11944 485 : ROSE_ASSERT(tplvdecl != NULL);
11945 :
11946 485 : returnList = tplvdecl->get_templateParameters();
11947 : break;
11948 : }
11949 :
11950 : // DQ (11/10/2014): Providing an initial implementation for template typedef symbol support.
11951 165 : case V_SgTemplateTypedefSymbol:
11952 165 : {
11953 : #if 1
11954 : // DQ (3/5/2017): Converted to use message logging, but the mechanism is not supported here yet.
11955 165 : mprintf ("WARNING: returning NULL in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateParameter>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
11956 : #endif
11957 165 : break;
11958 : }
11959 : #if 0
11960 : // We have to support these sorts of declarations in the name qualifiaction.
11961 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(declaration);
11962 : SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(declaration);
11963 : SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(declaration);
11964 : SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(declaration);
11965 : SgTemplateDeclaration* templateDeclaration = isSgTemplateDeclaration(declaration);
11966 : SgEnumDeclaration* enumDeclaration = isSgEnumDeclaration(declaration);
11967 : SgNamespaceDeclarationStatement* namespaceDeclaration = isSgNamespaceDeclarationStatement(declaration);
11968 : #endif
11969 : // DQ (8/19/2013): Added case for other symbols (but we only return the empty list for this case).
11970 : case V_SgClassSymbol:
11971 : case V_SgVariableSymbol:
11972 : case V_SgFunctionSymbol:
11973 : case V_SgMemberFunctionSymbol:
11974 : case V_SgTypedefSymbol:
11975 : case V_SgEnumSymbol:
11976 : case V_SgEnumFieldSymbol:
11977 : case V_SgNamespaceSymbol:
11978 : {
11979 : // This function requires this case so that it can be called within very general contexts.
11980 : // However, for this case we only return the empty template parameter list.
11981 :
11982 : break;
11983 : }
11984 :
11985 6950 : case V_SgNonrealSymbol:
11986 6950 : {
11987 : #if 0
11988 : mprintf ("In SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateParameter>(): Case of SgTemplateSymbol\n");
11989 : #endif
11990 6950 : SgNonrealSymbol * nrsym = isSgNonrealSymbol(symbol);
11991 6950 : ROSE_ASSERT(nrsym != NULL);
11992 6950 : SgNonrealDecl * nrdecl = isSgNonrealDecl(nrsym->get_declaration());
11993 6950 : ROSE_ASSERT(nrdecl != NULL);
11994 6950 : returnList = nrdecl->get_tpl_params();
11995 : break;
11996 : }
11997 :
11998 0 : case V_SgTemplateSymbol:
11999 0 : {
12000 0 : mprintf ("Case of SgTemplateSymbol not handled yet in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateParameter>() \n");
12001 0 : ROSE_ASSERT(false);
12002 : break;
12003 : }
12004 :
12005 0 : default:
12006 0 : {
12007 0 : mprintf ("Exiting in SgSymbolTable::getTemplateParametersOrArgumentsList<SgTemplateParameter>(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
12008 0 : ROSE_ASSERT(false);
12009 : }
12010 : }
12011 :
12012 175162 : return returnList;
12013 : }
12014 :
12015 :
12016 : // bool SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(SgTemplateArgumentPtrList* templateArgumentsList, SgClassSymbol* classSymbol)
12017 : // bool SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(SgTemplateArgumentPtrList* templateArgumentsList, SgSymbol* symbol)
12018 : // bool SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(SgTemplateArgumentPtrList* templateArgumentsList, SgSymbol* symbol)
12019 : template <class T>
12020 : bool
12021 7143182 : SgSymbolTable::hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments(std::vector<T*>* templateParametersOrArgumentsList, SgSymbol* symbol)
12022 : {
12023 : // DQ (8/8/2013): I needed to change the API to be more generic to support template for functions (and not just classes).
12024 :
12025 : // DQ (1/30/2013): Note that this function only supports the evaluation of template arguments for classes (and structs, and unions),
12026 : // but not for any types of functions. Not clear if this is a problem for the future or not, but usually there is more symmetry required.
12027 :
12028 : // DQ (8/22/2012): We need more information to disambiguate where template argument name qualification would be important. See test2012_195.C.
12029 7143182 : bool returnValue = false;
12030 :
12031 7143182 : ROSE_ASSERT(symbol != NULL);
12032 :
12033 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12034 : mprintf ("\nIn SgSymbolTable::hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments(): templateParametersOrArgumentsList = %p symbol = %p = %s \n",templateParametersOrArgumentsList,symbol,symbol->class_name().c_str());
12035 : #endif
12036 :
12037 : // DQ (8/8/2013): Added requirement that this be a SgClassSymbol, this will detect where we are using this more generally.
12038 : // ROSE_ASSERT(isSgClassSymbol(symbol) != NULL);
12039 :
12040 7143182 : if (templateParametersOrArgumentsList != NULL)
12041 : {
12042 768432 : std::vector<T*> templateParametersOrArgumentsListFromSymbol = getTemplateParametersOrArgumentsList<T>(symbol);
12043 :
12044 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12045 : mprintf ("In SgSymbolTable::hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments(): templateParametersOrArgumentsList->size() = %" PRIuPTR " templateParametersOrArgumentsListFromSymbol.size() = %" PRIuPTR " \n",
12046 : templateParametersOrArgumentsList->size(),templateParametersOrArgumentsListFromSymbol.size());
12047 : #endif
12048 : // Output a message for this case, but don't make it an error.
12049 384216 : if (templateParametersOrArgumentsListFromSymbol.empty() == false)
12050 : {
12051 : // ROSE_ASSERT(templateArgumentsList->size() == templateClassInstantiation->get_templateArguments().size());
12052 : // ROSE_ASSERT(templateArgumentsList->size() == templateArgumentsListFromSymbol.size());
12053 : #if 0
12054 : if (templateParametersOrArgumentsList->size() != templateParametersOrArgumentsListFromSymbol.size())
12055 : {
12056 : mprintf ("NOTE: In SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): symbol = %p = %s = %s templateParametersOrArgumentsList->size() = %" PRIuPTR " templateParametersOrArgumentsListFromSymbol.size() = %" PRIuPTR " \n",
12057 : symbol,symbol->class_name().c_str(),symbol->get_name().str(),templateParametersOrArgumentsList->size(),templateParametersOrArgumentsListFromSymbol.size());
12058 : }
12059 : #endif
12060 : // DQ (9/19/2013): I now think this should not be an error, since it would not permit the general case where this function is used.
12061 : // ROSE_ASSERT(templateParametersOrArgumentsList->size() == templateParametersOrArgumentsListFromSymbol.size());
12062 : }
12063 :
12064 : // if (templateParametersOrArgumentsListFromSymbol.empty() == false)
12065 384216 : if ( (templateParametersOrArgumentsListFromSymbol.empty() == false) && (templateParametersOrArgumentsList->size() == templateParametersOrArgumentsListFromSymbol.size()) )
12066 : {
12067 : // Check if they are the same size...
12068 :
12069 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12070 : mprintf ("In SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): symbol = %p = %s templateParametersOrArgumentsList->size() = %" PRIuPTR " templateClassInstantiation->get_templateArguments().size() = %" PRIuPTR " \n",
12071 : symbol,symbol->class_name().c_str(),templateParametersOrArgumentsList->size(),templateParametersOrArgumentsListFromSymbol.size());
12072 : for (size_t i = 0; i < templateParametersOrArgumentsList->size(); i++)
12073 : {
12074 : mprintf ("----- (*templateParametersOrArgumentsList)[%" PRIuPTR "] = %p templateClassInstantiation->get_templateArguments()[%" PRIuPTR "] = %p \n",i,(*templateParametersOrArgumentsList)[i],i,templateParametersOrArgumentsListFromSymbol[i]);
12075 : }
12076 : #endif
12077 196277 : if (templateParametersOrArgumentsList->size() == templateParametersOrArgumentsListFromSymbol.size())
12078 : {
12079 : // Check if they are the same STL vector values...
12080 : #if 0
12081 : // DQ (8/10/2013): We need to get the associated template parameters or template arguments to test the STL vectors.
12082 : mprintf ("Exiting in SgSymbolTable::hasMatchingTemplateParametersOrArgumentsOrNoTemplateParametersOrArguments() \n");
12083 : ROSE_ASSERT(false);
12084 : #endif
12085 : // if (*templateParametersOrArgumentsList == templateClassInstantiation->get_templateArguments())
12086 196277 : if (*templateParametersOrArgumentsList == templateParametersOrArgumentsListFromSymbol)
12087 : {
12088 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12089 : mprintf ("In SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): The template argument vectors are equal \n");
12090 : #endif
12091 : returnValue = true;
12092 : }
12093 :
12094 : // DQ (8/23/2012): If these are SgTemplateType arguments then consider them the same for now.
12095 : // It is less clear how to handle template arguments because the names can change in different parts of the
12096 : // template declaration, so for now we will rely on the instantiated templates name and the number of arguments
12097 : // if they are all SgTemplateType template arguments.
12098 : if (returnValue == false)
12099 : {
12100 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12101 : mprintf ("SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): Double check if we had set returnValue to false based on SgTemplateType template arguments (if so, then return true) \n");
12102 : #endif
12103 :
12104 : // DQ (12/30/2018): I think a better name for this variable would be "is_matching_template_type_boolean".
12105 : bool isTemplateType = true;
12106 : #if 0
12107 : // DQ (12/30/2018): This is the original code.
12108 : for (size_t i = 0; i < templateParametersOrArgumentsList->size(); i++)
12109 : #else
12110 : // DQ 12/30/2018): We only want to test up to the first template parameter or argument that is not matching.
12111 : // Alternatively a "while" loop might be more clear.
12112 101557 : for (size_t i = 0; ((isTemplateType == true) && (i < templateParametersOrArgumentsList->size())); i++)
12113 : #endif
12114 : {
12115 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12116 : printf("----- (*templateParametersOrArgumentsList)[%zd] = %p = %s\n", i, (*templateParametersOrArgumentsList)[i], (*templateParametersOrArgumentsList)[i]->unparseToString().c_str() );
12117 : printf("----- templateParametersOrArgumentsListFromSymbol[%zd] = %p = %s\n", i, templateParametersOrArgumentsListFromSymbol[i], templateParametersOrArgumentsListFromSymbol[i]->unparseToString().c_str() );
12118 : #endif
12119 :
12120 : // SgTemplateArgument* templateArgumentLocal = isSgTemplateArgument((*templateParametersOrArgumentsList)[i]);
12121 : // SgTemplateArgument* templateArgumentFromSymbol = isSgTemplateArgument(templateParametersOrArgumentsListFromSymbol[i]);
12122 59199 : T* templateParameterOrArgumentLocal = (*templateParametersOrArgumentsList)[i];
12123 59199 : T* templateParameterOrArgumentFromSymbol = templateParametersOrArgumentsListFromSymbol[i];
12124 59199 : ROSE_ASSERT(templateParameterOrArgumentLocal != NULL);
12125 59199 : ROSE_ASSERT(templateParameterOrArgumentFromSymbol != NULL);
12126 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12127 : // mprintf ("----- templateArgumentLocal->get_argumentType() = %d templateArgumentFromSymbol->get_argumentType() = %d \n",templateParameterOrArgumentLocal->get_argumentType(),templateParameterOrArgumentFromSymbol->get_argumentType());
12128 : #endif
12129 : // DQ (6/17/2013): The get_argumentType() can be either of these.
12130 : // type_argument = 1, /*!< type parameter */
12131 : // nontype_argument = 2, /*!< nontype parameter */
12132 : // template_template_argument = 3 /*!< template template parameter */
12133 :
12134 : // DQ (8/10/2013): Test for if the template parameter or arguments type matches (type, nontype, template_template).
12135 : // Note that this predicate function does not test if the types are equivalent.
12136 : // if (templateArgumentLocal->get_argumentType() == SgTemplateArgument::type_argument && templateArgumentFromSymbol->get_argumentType() == SgTemplateArgument::type_argument)
12137 59199 : if (T::is_matching_type(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == true)
12138 : {
12139 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12140 : mprintf ("----- Template parameters or arguments match in parameter or argument type: \n");
12141 : mprintf ("----- --- templateParameterOrArgumentLocal->get_type() = %p = %s \n",templateParameterOrArgumentLocal->get_type(), templateParameterOrArgumentLocal->get_type()->class_name().c_str());
12142 : mprintf ("----- --- templateParameterOrArgumentFromSymbol->get_type() = %p = %s \n",templateParameterOrArgumentFromSymbol->get_type(),templateParameterOrArgumentFromSymbol->get_type()->class_name().c_str());
12143 : #endif
12144 57387 : isTemplateType = SageInterface::isEquivalentType(templateParameterOrArgumentLocal->get_type(),templateParameterOrArgumentFromSymbol->get_type());
12145 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12146 : mprintf ("----- --- SageInterface::isEquivalentType() returns: isTemplateType = %s \n",(isTemplateType == true) ? "true" : "false");
12147 : #endif
12148 : }
12149 : else
12150 : {
12151 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12152 : mprintf ("----- --- T::is_matching_type() == false \n");
12153 : #endif
12154 : // DQ (8/10/2013): Test for if the template parameter or arguments type matches (type, nontype, template_template).
12155 : // DQ (6/17/2013): This newer code does a better job of resolving if template arguments are equivalent (more can be done still).
12156 : // if (templateArgumentLocal->get_argumentType() == SgTemplateArgument::nontype_argument && templateArgumentFromSymbol->get_argumentType() == SgTemplateArgument::nontype_argument)
12157 1812 : if (T::is_matching_nontype(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == true)
12158 : {
12159 : // Test for equivalence of nontype arguments (e.g. values).
12160 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12161 : mprintf ("WARNING: These are both nontype template arguments (which we are considering to be the same withouth enough testing \n");
12162 : #endif
12163 : // ROSE_ASSERT(templateParameterOrArgumentLocal->get_expression() != NULL);
12164 : // ROSE_ASSERT(templateParameterOrArgumentFromSymbol->get_expression() != NULL);
12165 798 : ROSE_ASSERT(templateParameterOrArgumentLocal->get_expression() != NULL || templateParameterOrArgumentLocal->get_initializedName() != NULL);
12166 798 : ROSE_ASSERT(templateParameterOrArgumentFromSymbol->get_expression() != NULL || templateParameterOrArgumentFromSymbol->get_initializedName() != NULL);
12167 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12168 : mprintf ("----- --- templateParameterOrArgumentLocal->get_expression() = %p \n",templateParameterOrArgumentLocal->get_expression());
12169 : mprintf ("----- --- templateParameterOrArgumentFromSymbol->get_expression() = %p \n",templateParameterOrArgumentFromSymbol->get_expression());
12170 : #endif
12171 : // DQ (8/11/2013): We have added a SgInitializedName pointer to SgTemplateArgument (so it now matches the SgTemplateParameter,
12172 : // and because it was needed for more complex template arguments, analigous to test2013_303.C)
12173 798 : if (templateParameterOrArgumentLocal->get_expression() == templateParameterOrArgumentFromSymbol->get_expression())
12174 : {
12175 : // DQ (8/11/2013): Note that these might have been equal because they were both NULL.
12176 : // isTemplateType = true;
12177 778 : if (templateParameterOrArgumentLocal->get_expression() != NULL)
12178 : {
12179 : isTemplateType = true;
12180 : }
12181 : else
12182 : {
12183 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12184 : mprintf ("----- --- templateParameterOrArgumentLocal->get_initializedName() = %p type = %p \n",
12185 : templateParameterOrArgumentLocal->get_initializedName(),templateParameterOrArgumentLocal->get_initializedName()->get_type());
12186 : mprintf ("----- --- templateParameterOrArgumentFromSymbol->get_initializedName() = %p type = %p \n",
12187 : templateParameterOrArgumentFromSymbol->get_initializedName(),templateParameterOrArgumentFromSymbol->get_initializedName()->get_type());
12188 : #endif
12189 291 : ROSE_ASSERT(templateParameterOrArgumentLocal->get_initializedName() != NULL);
12190 291 : ROSE_ASSERT(templateParameterOrArgumentFromSymbol->get_initializedName() != NULL);
12191 :
12192 : // DQ (12/8/2015): FIXME: This is not a good enough test, this can be improved.
12193 291 : if (templateParameterOrArgumentLocal->get_initializedName() == templateParameterOrArgumentFromSymbol->get_initializedName())
12194 : {
12195 : isTemplateType = true;
12196 : }
12197 : else
12198 : {
12199 : // DQ (8/19/2013): The possible problem here is that two SgInitializedName objects might be the same and yet be different pointers.
12200 : // So this might still not be a good enough test. An alternative might be to double check the name and the scope as what might be
12201 : // a better test.
12202 : #if 0
12203 :
12204 : printf("----- --- initializedName objects where not the same (checking the names saved as strings in each SgInitializedName object) \n");
12205 : #endif
12206 : // DQ (12/8/2015): Check if the names are the same (independent of the SgIntializedName object pointers).
12207 873 : std::string str1 = templateParameterOrArgumentLocal->get_initializedName()->get_name().str();
12208 873 : std::string str2 = templateParameterOrArgumentFromSymbol->get_initializedName()->get_name().str();
12209 : // if (templateParameterOrArgumentLocal->get_initializedName()->get_name().str() != templateParameterOrArgumentFromSymbol->get_initializedName()->get_name().str())
12210 291 : if (str1 != str2)
12211 : {
12212 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS || 0
12213 : mprintf ("----- --- --- These are NOT the same initializedName values and should have resolved to be the same pointer value if there were the same initializedName! (really?) \n");
12214 : mprintf ("WARNING: initializedName associated with same different initializedName was not checked... (might be different initializedName with the same name and type) \n");
12215 : mprintf ("templateParameterOrArgumentLocal->get_initializedName() = %s templateParameterOrArgumentFromSymbol->get_initializedName() = %s \n",str1.c_str(),str2.c_str());
12216 : #endif
12217 : }
12218 :
12219 :
12220 : // DQ (2/16/2014): test2014_17.C demonstrates that the SgInitializedName pointers need not match for this to be the same template parameter.
12221 : // I think it is enough that they are the same type, but it migh also be required that the names match as well (but I don't think this is
12222 : // required for C++).
12223 : // isTemplateType = false;
12224 :
12225 : // DQ (12/8/2015): Using newly implemented function for type equivalence.
12226 : // DQ (12/8/2015): FIXME: This is not a good enough test, this can be improved.
12227 : // DQ (12/15/2015): This causes a problem for SgTemplateType and SgMemberFunctionType and demonstrates the problem for debugging.
12228 291 : if (templateParameterOrArgumentLocal->get_initializedName()->get_type()->isEquivalentType(templateParameterOrArgumentFromSymbol->get_initializedName()->get_type()) == true)
12229 : {
12230 : isTemplateType = true;
12231 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12232 : mprintf ("----- --- --- These are NOT the same initializedName pointers, but they match in type! \n");
12233 : #endif
12234 : // DQ (7/7/2014): If these are not the same name then there is no match (see test2014_78.C).
12235 : // TV (06/21/2018): TODO look into this more...
12236 : if (false && templateParameterOrArgumentLocal->get_initializedName()->get_name() != templateParameterOrArgumentFromSymbol->get_initializedName()->get_name())
12237 : {
12238 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12239 : // DQ (7/7/2014): For now output debugging informationfor this case.
12240 : mprintf ("These names failed to match: \n");
12241 : mprintf (" --- templateParameterOrArgumentLocal->get_initializedName()->get_name() = %s \n",templateParameterOrArgumentLocal->get_initializedName()->get_name().str());
12242 : mprintf (" --- templateParameterOrArgumentFromSymbol->get_initializedName()->get_name() = %s \n",templateParameterOrArgumentFromSymbol->get_initializedName()->get_name().str());
12243 : #endif
12244 : #if 0
12245 : // Extra information to track down the example code.
12246 : templateParameterOrArgumentLocal->get_initializedName()->get_file_info()->display("templateParameterOrArgumentLocal: debug");
12247 : templateParameterOrArgumentFromSymbol->get_initializedName()->get_file_info()->display("templateParameterOrArgumentLocal: debug");
12248 : #endif
12249 :
12250 : isTemplateType = false;
12251 : }
12252 : // DQ (2/16/2014): I am not certain that the names have to match, but assert this for now as part of testing!
12253 : // ROSE_ASSERT (templateParameterOrArgumentLocal->get_initializedName()->get_name() == templateParameterOrArgumentFromSymbol->get_initializedName()->get_name());
12254 : }
12255 : else
12256 : {
12257 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12258 : mprintf ("----- --- --- These are NOT the same initializedName pointers OR the same type! \n");
12259 : #endif
12260 0 : isTemplateType = false;
12261 : }
12262 : }
12263 : }
12264 : }
12265 : else
12266 : {
12267 : // DQ (12/8/2015): FIXME: These pointers to different expressions are nearly always the same expression after evaluation.
12268 : // Different pointer values mean different expressions (I hope this is always true).
12269 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS || 0
12270 : mprintf ("----- --- --- These are NOT the same expresion values and should have resolved to be the same pointer value if there were the same expression! (really?) \n");
12271 : mprintf ("WARNING: value associated with same different expressions was not checked... (might be different constants with the same value) \n");
12272 : std::string str1 = templateParameterOrArgumentLocal->get_expression()->unparseToString();
12273 : std::string str2 = templateParameterOrArgumentFromSymbol->get_expression()->unparseToString();
12274 : mprintf ("unparsed expressions: %s and %s \n",str1.c_str(),str2.c_str());
12275 : #endif
12276 : }
12277 : }
12278 : else
12279 : {
12280 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12281 : mprintf ("----- --- T::is_matching_nontype() == false \n");
12282 : #endif
12283 : // DQ (8/10/2013): Test for if the template parameter or arguments type matches (type, nontype, template_template).
12284 : // if (templateArgumentLocal->get_argumentType() == SgTemplateArgument::template_template_argument && templateArgumentFromSymbol->get_argumentType() == SgTemplateArgument::template_template_argument)
12285 1014 : if (T::is_matching_template(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == true)
12286 : {
12287 : // Test for equivalence of template_template arguments.
12288 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12289 : mprintf ("WARNING: These are both template template template arguments (which we are considering to be the same without enough testing \n");
12290 : #endif
12291 0 : ROSE_ASSERT(templateParameterOrArgumentLocal->get_templateDeclaration() != NULL);
12292 0 : ROSE_ASSERT(templateParameterOrArgumentFromSymbol->get_templateDeclaration() != NULL);
12293 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12294 : mprintf ("----- --- templateParameterOrArgumentLocal->get_templateDeclaration() = %p \n",templateParameterOrArgumentLocal->get_templateDeclaration());
12295 : mprintf ("----- --- templateParameterOrArgumentFromSymbol->get_templateDeclaration() = %p \n",templateParameterOrArgumentFromSymbol->get_templateDeclaration());
12296 : #endif
12297 0 : if (templateParameterOrArgumentLocal->get_templateDeclaration() == templateParameterOrArgumentFromSymbol->get_templateDeclaration())
12298 : {
12299 : isTemplateType = true;
12300 : }
12301 : else
12302 : {
12303 : // Different pointer values mean different expressions (I hope this is always true).
12304 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12305 : mprintf ("----- --- --- These are NOT the same template declaration values and should have resolved to be the same pointer value if there were the same template template declaration argument value \n");
12306 : #endif
12307 : }
12308 : }
12309 : else
12310 : {
12311 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12312 : mprintf ("----- --- T::is_matching_template() == false \n");
12313 : #endif
12314 : // ROSE_ASSERT(templateArgumentLocal->get_argumentType() != templateArgumentFromSymbol->get_argumentType());
12315 : // DQ (5/19/2014): Output more debugging information.
12316 1014 : if (T::is_matching_kind(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == true)
12317 : {
12318 : #if 0
12319 : mprintf ("Error: templateParameterOrArgumentLocal = %p = %s \n",templateParameterOrArgumentLocal,templateParameterOrArgumentLocal->class_name().c_str());
12320 : mprintf ("Error: templateParameterOrArgumentFromSymbol = %p = %s \n",templateParameterOrArgumentFromSymbol,templateParameterOrArgumentFromSymbol->class_name().c_str());
12321 : #endif
12322 1014 : SgTemplateArgument* templateArgumentLocal = isSgTemplateArgument(templateParameterOrArgumentLocal);
12323 1014 : SgTemplateArgument* templateArgumentFromSymbol = isSgTemplateArgument(templateParameterOrArgumentFromSymbol);
12324 1014 : SgTemplateParameter* templateParameterLocal = isSgTemplateParameter(templateParameterOrArgumentLocal);
12325 1014 : SgTemplateParameter* templateParameterFromSymbol = isSgTemplateParameter(templateParameterOrArgumentFromSymbol);
12326 1014 : if (templateArgumentLocal != NULL)
12327 : {
12328 1014 : ROSE_ASSERT(templateArgumentFromSymbol != NULL);
12329 : #if 0
12330 : mprintf ("templateArgumentLocal->get_argumentType() = %d \n",templateArgumentLocal->get_argumentType());
12331 : mprintf ("templateArgumentFromSymbol->get_argumentType() = %d \n",templateArgumentFromSymbol->get_argumentType());
12332 : #endif
12333 : }
12334 : else
12335 : {
12336 0 : ROSE_ASSERT(templateParameterLocal != NULL);
12337 0 : ROSE_ASSERT(templateParameterFromSymbol != NULL);
12338 : #if 0
12339 : mprintf ("templateParameterLocal->get_parameterType() = %d \n",templateParameterLocal->get_parameterType());
12340 : mprintf ("templateParameterFromSymbol->get_parameterType() = %d \n",templateParameterFromSymbol->get_parameterType());
12341 : #endif
12342 : }
12343 : }
12344 : else
12345 : {
12346 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12347 : mprintf ("----- T::is_matching_kind() == false: \n");
12348 : #endif
12349 : }
12350 :
12351 : // DQ (5/19/2014): /include/boost/chrono/duration.hpp contains a new kind of template argument that maps to what EDG calls tak_start_of_pack_expansion.
12352 : // This support is not yet implemented in ROSE (version 1.50 of Boost and version 4.9 of EDG are required to detect this).
12353 : // returning "isTemplateType = false;" for now.
12354 : // ROSE_ASSERT(T::is_matching_kind(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == false);
12355 1014 : if (T::is_matching_template_pack_expansion(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == true)
12356 : {
12357 : #if 0
12358 : mprintf ("----- SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): This is the case of a template_pack_expansion: not yet supported (edg calls this tak_start_of_pack_expansion) \n");
12359 : #endif
12360 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12361 : mprintf ("----- SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): This is the case of a template_pack_expansion: not yet supported (edg calls this tak_start_of_pack_expansion) \n");
12362 : #endif
12363 : // DQ (12/28/2018): Return true if both a marked as template pack.
12364 : isTemplateType = true;
12365 : }
12366 : else
12367 : {
12368 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12369 : mprintf ("----- --- T::is_matching_template_pack_expansion() == false \n");
12370 : #endif
12371 0 : ROSE_ASSERT(T::is_matching_kind(*templateParameterOrArgumentLocal,*templateParameterOrArgumentFromSymbol) == false);
12372 :
12373 : // DQ (12/28/2018): Return false.
12374 0 : isTemplateType = false;
12375 : }
12376 :
12377 : // DQ (12/28/2018): We want to set this differently in the two branches above.
12378 : // These are not the same type: so return false.
12379 : // isTemplateType = false;
12380 : }
12381 : }
12382 : }
12383 : }
12384 :
12385 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12386 : mprintf ("WARNING: SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): we are relying on only the existence of all SgTemplateType template arguments to decide that this is a match isTemplateType = %s \n",
12387 : isTemplateType ? "true" : "false");
12388 : #endif
12389 : returnValue = isTemplateType;
12390 : }
12391 : }
12392 : }
12393 : else
12394 : {
12395 : // DQ (8/22/2012): Consider if this make sense...yes, if it is not a template instantiation then matching is based on name in a specific scope only.
12396 : // DQ (5/8/2016): Actually it is based on the name and the template parameters (I think the number of template parameters only, but I am not certain).
12397 : #if 1
12398 : // DQ (5/8/2016): If the list is not empty then it had a different number of arguments and so it can't be the same (return false)
12399 187939 : if (templateParametersOrArgumentsListFromSymbol.empty() == false)
12400 : {
12401 : // && (templateParametersOrArgumentsList->size() == templateParametersOrArgumentsListFromSymbol.size())
12402 : // Check if they are the same size...
12403 : // DQ (5/8/2016): If the list is not empty then it had a different number of arguments and so it can't be the same (return false)
12404 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12405 : mprintf ("WARNING: SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): templateParametersOrArgumentsListFromSymbol.empty() == false: different size list: (return false) \n");
12406 : #endif
12407 : returnValue = false;
12408 : }
12409 : else
12410 : {
12411 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12412 : mprintf ("WARNING: SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): templateParametersOrArgumentsListFromSymbol.empty() == true (return true) \n");
12413 : #endif
12414 153314 : returnValue = true;
12415 : }
12416 : #else
12417 :
12418 : #error "DEAD CODE!"
12419 :
12420 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12421 : mprintf ("WARNING: SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): templateClassInstantiation == NULL (return true) \n");
12422 : #endif
12423 : returnValue = true;
12424 : #endif
12425 : }
12426 : }
12427 : else
12428 : {
12429 : #if DEBUG_MATCHING_TEMPLATE_ARGUMENTS
12430 : mprintf ("WARNING: SgSymbolTable::hasMatchingTemplateArgumentsOrNoTemplateArguments(): templateParametersOrArgumentsList == NULL (return true) \n");
12431 : #endif
12432 : returnValue = true;
12433 : }
12434 :
12435 7143182 : return returnValue;
12436 : }
12437 :
12438 :
12439 : SgClassSymbol*
12440 65448 : SgSymbolTable::find_class(const SgName & nm, SgTemplateArgumentPtrList* templateArgumentsList)
12441 : {
12442 : // DQ (8/22/2012): We need more information to disambiguate where template argument name qualification would be important. See test2012_195.C.
12443 :
12444 : // DQ (5/20/2013): Using the find_template_symbol_support() function with templateParameterList == NULL;
12445 : // s = find_symbol_support<SgTemplateClassSymbol>(nm);
12446 : // SgTemplateParameterPtrList* templateParameterList = NULL;
12447 : // return find_template_symbol_support<SgClassSymbol,SgClassDeclaration>(nm,templateParameterList,templateArgumentsList);
12448 :
12449 : // return find_symbol_with_template_args_support<SgClassSymbol>(nm,templateArgumentsList);
12450 : // return find_symbol_support<SgClassSymbol>(nm,NULL,templateArgumentsList);
12451 65448 : bool filterTemplateSymbols = false;
12452 65448 : return find_symbol_with_type_support<SgClassSymbol>(nm,NULL,NULL,templateArgumentsList,filterTemplateSymbols);
12453 : }
12454 :
12455 : #if 0
12456 : SgAliasSymbol*
12457 : SgSymbolTable::find_alias(const SgName & nm, SgTemplateArgumentPtrList* templateArgumentsList)
12458 : {
12459 : #if 0
12460 : mprintf ("In SgSymbolTable::find_alias(): nm = %s \n",nm.str());
12461 : #endif
12462 :
12463 : bool filterTemplateSymbols = false;
12464 : return find_symbol_with_type_support<SgAliasSymbol>(nm,NULL,NULL,templateArgumentsList,filterTemplateSymbols);
12465 : }
12466 : #endif
12467 :
12468 : SgNonrealSymbol*
12469 27902 : SgSymbolTable::find_nonreal(const SgName & nm, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentsList)
12470 : {
12471 27902 : bool filterTemplateSymbols = false;
12472 27902 : return find_symbol_with_type_support<SgNonrealSymbol>(nm,NULL,templateParameterList,templateArgumentsList,filterTemplateSymbols);
12473 : }
12474 :
12475 :
12476 :
12477 : #if 0
12478 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
12479 : SgFunctionTypeSymbol*
12480 : SgSymbolTable::findfunctype(const SgName &nm)
12481 : {
12482 : return find_function_type(nm);
12483 : }
12484 : #endif
12485 :
12486 : SgFunctionTypeSymbol*
12487 2860270 : SgSymbolTable::find_function_type(const SgName & nm)
12488 : {
12489 : // return find_symbol_support<SgFunctionTypeSymbol>(nm);
12490 2860270 : bool filterTemplateSymbols = false;
12491 2860270 : return find_symbol_with_type_support<SgFunctionTypeSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
12492 : }
12493 :
12494 : SgLabelSymbol*
12495 20 : SgSymbolTable::find_label(const SgName & nm)
12496 : {
12497 : // return find_symbol_support<SgLabelSymbol>(nm);
12498 20 : bool filterTemplateSymbols = false;
12499 20 : return find_symbol_with_type_support<SgLabelSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
12500 : }
12501 :
12502 : // DQ (1/30/2007): Added these back into ROSE.
12503 : SgNamespaceSymbol*
12504 2531 : SgSymbolTable::find_namespace ( const SgName & nm )
12505 : {
12506 : // return find_symbol_support<SgNamespaceSymbol>(nm);
12507 2531 : bool filterTemplateSymbols = false;
12508 2531 : return find_symbol_with_type_support<SgNamespaceSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
12509 : }
12510 :
12511 : #if 0
12512 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
12513 : SgFunctionSymbol*
12514 : SgSymbolTable::findfunc(const SgName & nm, const SgType* t)
12515 : {
12516 : return find_function(nm,t);
12517 : }
12518 : #endif
12519 :
12520 :
12521 : // SgFunctionSymbol* SgSymbolTable::find_function (const SgName & nm, const SgType* t)
12522 : SgFunctionSymbol*
12523 1165210 : SgSymbolTable::find_function (const SgName & nm, const SgType* type, SgTemplateArgumentPtrList* templateArgumentList)
12524 : {
12525 : // DQ (8/22/2013): We need to allow for functions to be searched for by name if the type is unavailable.
12526 : // ROSE_ASSERT(type != NULL);
12527 :
12528 1165210 : bool filterTemplateSymbols = false;
12529 1165210 : SgFunctionSymbol *s = find_symbol_with_type_support<SgFunctionSymbol>(nm,type,NULL,templateArgumentList,filterTemplateSymbols);
12530 :
12531 : // DQ (8/22/2013): We have to allow this function to return either SgTemplateFunctionSymbol or
12532 : // SgTemplateMemberFunctionSymbol when not enough information (type == NULL or templateArgumentList == NULL).
12533 : // DQ (8/13/2013): We should not be returning a template symbol from this function (verify this).
12534 : // ROSE_ASSERT(isSgTemplateFunctionSymbol(s) == NULL && isSgTemplateMemberFunctionSymbol(s) == NULL);
12535 :
12536 1165210 : return s;
12537 : }
12538 :
12539 : // DQ (12/27/2011): Added more support for template declarations in the AST.
12540 : // DQ (12/12/2011): New functions to support template declarations in the AST.
12541 : // SgTemplateSymbol* SgFunctionSymbol* SgSymbolTable::find_nontemplate_function(const SgName& nm, const SgType* t)
12542 : SgFunctionSymbol*
12543 2265100 : SgSymbolTable::find_nontemplate_function(const SgName& nm, const SgType* t, SgTemplateArgumentPtrList* templateArgumentList)
12544 : {
12545 : // DQ (8/22/2013): We need to allow for functions to be searched for by name if the type is unavailable.
12546 : // ROSE_ASSERT(t != NULL);
12547 :
12548 2265100 : bool filterTemplateSymbols = true;
12549 2265100 : SgFunctionSymbol *s = find_symbol_with_type_support<SgFunctionSymbol>(nm,t,NULL,templateArgumentList,filterTemplateSymbols);
12550 :
12551 : // DQ (8/22/2013): We have to allow this function to return either SgTemplateFunctionSymbol or
12552 : // SgTemplateMemberFunctionSymbol when not enough information (type == NULL or templateArgumentList == NULL).
12553 : // DQ (5/23/2013): Added assertion on retuned symbol.
12554 : // ROSE_ASSERT(isSgTemplateFunctionSymbol(s) == NULL && isSgTemplateMemberFunctionSymbol(s) == NULL);
12555 :
12556 2265100 : return s;
12557 : }
12558 :
12559 : // DQ (7/31/2013): Adding support for template parameters and template specialization.
12560 : // SgTemplateFunctionSymbol* SgSymbolTable::find_template_function(const SgName& nm, const SgType* t)
12561 : // SgTemplateFunctionSymbol* SgSymbolTable::find_template_function(const SgName& nm, const SgType* t, SgTemplateParameterPtrList* templateList, SgTemplateArgumentPtrList* templateSpecializationArgumentList)
12562 : SgTemplateFunctionSymbol*
12563 17665 : SgSymbolTable::find_template_function(const SgName& nm, const SgType* t, SgTemplateParameterPtrList* templateParameterList)
12564 : {
12565 : // DQ (8/22/2013): We need to allow for functions to be searched for by name if the type is unavailable.
12566 : // ROSE_ASSERT(t != NULL);
12567 :
12568 : #if 0
12569 : mprintf ("In SgSymbolTable::find_template_function(): nm = %s t = %p templateParameterList = %p size = %zu \n",nm.str(),t,templateParameterList,templateParameterList->size());
12570 : #endif
12571 :
12572 17665 : bool filterTemplateSymbols = false;
12573 17665 : SgTemplateFunctionSymbol *s = find_symbol_with_type_support<SgTemplateFunctionSymbol>(nm,t,templateParameterList,NULL,filterTemplateSymbols);
12574 :
12575 17665 : return s;
12576 : }
12577 :
12578 : SgTemplateVariableSymbol*
12579 0 : SgSymbolTable::find_template_variable(const SgName& nm, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentsList)
12580 : {
12581 : #if 0
12582 : mprintf ("In SgSymbolTable::find_template_variable(): nm = %s templateParameterList = %p size = %zu \n",nm.str(),templateParameterList,templateParameterList->size());
12583 : #endif
12584 :
12585 0 : bool filterTemplateSymbols = false;
12586 0 : SgTemplateVariableSymbol *s = find_symbol_with_type_support<SgTemplateVariableSymbol>(nm,NULL,templateParameterList,templateArgumentsList,filterTemplateSymbols);
12587 :
12588 0 : return s;
12589 : }
12590 :
12591 :
12592 : // DQ (12/27/2011): Added more support for template declarations in the AST.
12593 : // SgMemberFunctionSymbol* SgSymbolTable::find_nontemplate_member_function(const SgName& nm, const SgType* t)
12594 : SgMemberFunctionSymbol*
12595 51331 : SgSymbolTable::find_nontemplate_member_function(const SgName& nm, const SgType* t, SgTemplateArgumentPtrList* templateArgumentList)
12596 : {
12597 51331 : SgMemberFunctionSymbol *s = NULL;
12598 :
12599 : // DQ (8/22/2013): We need to allow for functions to be searched for by name if the type is unavailable.
12600 : // ROSE_ASSERT(t != NULL);
12601 :
12602 51331 : bool filterTemplateSymbols = true;
12603 51331 : s = find_symbol_with_type_support<SgMemberFunctionSymbol>(nm,t,NULL,templateArgumentList,filterTemplateSymbols);
12604 :
12605 : // DQ (8/22/2013): We have to allow this function to return either SgTemplateFunctionSymbol or
12606 : // SgTemplateMemberFunctionSymbol when not enough information (type == NULL or templateArgumentList == NULL).
12607 : // DQ (8/13/2013): We should not be returning a template symbol from this function (verify this).
12608 : // ROSE_ASSERT(isSgTemplateFunctionSymbol(s) == NULL && isSgTemplateMemberFunctionSymbol(s) == NULL);
12609 :
12610 51331 : return s;
12611 : }
12612 :
12613 :
12614 : // SgTemplateMemberFunctionSymbol* SgSymbolTable::find_template_member_function(const SgName& nm, const SgType* t)
12615 : // SgTemplateMemberFunctionSymbol* SgSymbolTable::find_template_member_function(const SgName& nm, const SgType* t, SgTemplateParameterPtrList* templateList, SgTemplateArgumentPtrList* templateSpecializationArgumentList)
12616 : SgTemplateMemberFunctionSymbol*
12617 82842 : SgSymbolTable::find_template_member_function(const SgName& nm, const SgType* t, SgTemplateParameterPtrList* templateParameterList)
12618 : {
12619 : // DQ (8/22/2013): We need to allow for functions to be searched for by name if the type is unavailable.
12620 : // ROSE_ASSERT(t != NULL);
12621 :
12622 82842 : bool filterTemplateSymbols = false;
12623 82842 : SgTemplateMemberFunctionSymbol *s = find_symbol_with_type_support<SgTemplateMemberFunctionSymbol>(nm,t,templateParameterList,NULL,filterTemplateSymbols);
12624 :
12625 82842 : return s;
12626 : }
12627 :
12628 :
12629 : // DQ (12/26/2011): Adding revised support for template declarations in the AST.
12630 : // SgClassSymbol* SgSymbolTable::find_nontemplate_class (const SgName & nm)
12631 : SgClassSymbol*
12632 98151 : SgSymbolTable::find_nontemplate_class (const SgName & nm, SgTemplateArgumentPtrList* templateArgumentsList)
12633 : {
12634 98151 : bool filterTemplateSymbols = true;
12635 98151 : SgClassSymbol* s = find_symbol_with_type_support<SgClassSymbol>(nm,NULL,NULL,templateArgumentsList,filterTemplateSymbols);
12636 :
12637 : // DQ (8/12/2013): The semantics of find_symbol_with_template_args_support() was to never
12638 : // return a SgTemplateClassSymbol where as the semantics of find_symbol_support() is to
12639 : // return anything that is a derived class from SgClassSymbol, which can be a SgTemplateClassSymbol.
12640 : // So this is an error in EDG/ROSE function: retrieveAssociatedClassSymbol().
12641 : // Need to fix this tomorrow morning (make the function optionally strict so that we can
12642 : // reuse the same minimal templated support.
12643 98151 : ROSE_ASSERT(isSgTemplateClassSymbol(s) == NULL);
12644 :
12645 98151 : return s;
12646 : }
12647 :
12648 :
12649 : // SgTemplateClassSymbol* SgSymbolTable::find_template_class (const SgName & nm)
12650 : SgTemplateClassSymbol*
12651 20296 : SgSymbolTable::find_template_class (const SgName & nm, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList )
12652 : {
12653 : // ROSE_ASSERT(templateParameterList != NULL); // TV: when we are looking for the original declaration of a template from potential specialization (we only have the name)
12654 :
12655 20296 : bool filterTemplateSymbols = false;
12656 20296 : SgTemplateClassSymbol *s = find_symbol_with_type_support<SgTemplateClassSymbol>(nm,NULL,templateParameterList,templateSpecializationArgumentList,filterTemplateSymbols);
12657 :
12658 20296 : return s;
12659 : }
12660 :
12661 : // DQ (3/8/2017): Adding support for SgTemplateTypedefSymbol handling.
12662 : // SgTemplateClassSymbol* SgSymbolTable::find_template_class (const SgName & nm)
12663 : // SgTemplateTypedefSymbol* SgSymbolTable::find_template_typedef (const SgName & nm, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList )
12664 : SgTemplateTypedefSymbol*
12665 8640 : SgSymbolTable::find_template_typedef (const SgName & nm)
12666 : {
12667 : // ROSE_ASSERT(templateParameterList != NULL);
12668 :
12669 8640 : SgTemplateParameterPtrList* templateParameterList = NULL;
12670 8640 : SgTemplateArgumentPtrList* templateSpecializationArgumentList = NULL;
12671 :
12672 8640 : bool filterTemplateSymbols = false;
12673 : // SgTemplateTypedefSymbol *s = find_symbol_with_type_support<SgTemplateTypedefSymbol>(nm,NULL,templateParameterList,templateSpecializationArgumentList);
12674 8640 : SgTemplateTypedefSymbol *s = find_symbol_with_type_support<SgTemplateTypedefSymbol>(nm,NULL,templateParameterList,templateSpecializationArgumentList,filterTemplateSymbols);
12675 :
12676 8640 : return s;
12677 : }
12678 :
12679 :
12680 : #if 0
12681 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
12682 : SgFunctionSymbol*
12683 : SgSymbolTable::findfunc(const SgName & nm)
12684 : {
12685 : return find_function(nm);
12686 : }
12687 : #endif
12688 :
12689 :
12690 : SgFunctionSymbol*
12691 902017 : SgSymbolTable::find_function(const SgName & nm)
12692 : {
12693 902017 : bool filterTemplateSymbols = false;
12694 902017 : SgFunctionSymbol* s = find_symbol_with_type_support<SgFunctionSymbol>(nm,NULL,NULL,NULL,filterTemplateSymbols);
12695 :
12696 : // DQ (8/22/2013): We have to allow this function to return either SgTemplateFunctionSymbol or
12697 : // SgTemplateMemberFunctionSymbol when not enough information (type == NULL or templateArgumentList == NULL).
12698 : // DQ (8/13/2013): We should not be returning a template symbol from this function (verify this).
12699 : // ROSE_ASSERT(isSgTemplateFunctionSymbol(s) == NULL && isSgTemplateMemberFunctionSymbol(s) == NULL);
12700 :
12701 902017 : return s;
12702 : }
12703 :
12704 : #if 0
12705 : // DQ (8/21/2013): It might be a mistake to remove this symbol lookup function since there may still be
12706 : // some SgTemplateSymbol IR nodes to handle unusual template cases. This neds to be checked.
12707 :
12708 : // SgTemplateSymbol* SgSymbolTable::find_template(const SgName & nm)
12709 : SgTemplateSymbol*
12710 : SgSymbolTable::find_template(const SgName & nm, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList)
12711 : {
12712 : // DQ (8/13/2013): Since function templates, member function templates, and class templates are symbols not derived from SgTemplateSymbol,
12713 : // this function is not very useful since it returns a SgTemplateSymbol. This was a part of the older pre-EDG4x API.
12714 :
12715 : // DQ (8/12/2013): I think this is the wrong function to call.
12716 : mprintf ("ERROR: This function is not specific enough, please select find_template_class(), or find_template_function(), or find_template_member_function() \n");
12717 : ROSE_ASSERT(false);
12718 :
12719 : // DQ (5/20/2013): New use of template function to abstract the specific type and refactor support for symbol table handling.
12720 : // return find_symbol_support<SgTemplateSymbol>(nm);
12721 : SgTemplateSymbol* s = find_symbol_support<SgTemplateSymbol>(nm,templateParameterList,templateSpecializationArgumentList);
12722 :
12723 : return s;
12724 : }
12725 : #endif
12726 :
12727 : #define DEBUG_TEMPLATE_PARAMETERS_AND_ARGUMENTS_ERROR_CHECKING 0
12728 :
12729 : template<class ReturnType>
12730 : bool
12731 10447300 : templateParameterAndArgumentErrorChecking(SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList)
12732 : {
12733 : // DQ (8/11/2013): This function implements error checking on when template arguments and template parameters can be used relative to specific IR nodes
12734 : // (template declarations, template instantiations, and non-template instantiations (normal functions and classes).
12735 :
12736 : // This function implements error checking for the functions: SgSymbolTable::find_symbol_support() and SgSymbolTable::find_symbol_with_type_support().
12737 : // It is used within an assertion at the top of these template functions.
12738 :
12739 7788100 : bool returnValue = true;
12740 :
12741 10447300 : VariantT returnTypeVariant = (VariantT)ReturnType::static_variant;
12742 :
12743 : // DQ (8/17/2013): We need to permit ReturnType to be a SgSymbol so that we can support more general queries in the symbol table.
12744 : // if (templateParameterList != NULL || templateArgumentList != NULL)
12745 7788100 : if ((returnTypeVariant != V_SgSymbol) && (templateParameterList != NULL || templateArgumentList != NULL))
12746 : {
12747 184140 : if (templateParameterList != NULL)
12748 : {
12749 : // ROSE_ASSERT((VariantT)ReturnType::static_variant == V_SgTemplateClassDeclaration || (VariantT)ReturnType::static_variant == V_SgTemplateFunctionDeclaration || (VariantT)ReturnType::static_variant == V_SgTemplateMemberFunctionDeclaration);
12750 0 : returnValue = (returnTypeVariant == V_SgTemplateClassSymbol || returnTypeVariant == V_SgTemplateFunctionSymbol || returnTypeVariant == V_SgTemplateMemberFunctionSymbol || returnTypeVariant == V_SgNonrealSymbol);
12751 : #if DEBUG_TEMPLATE_PARAMETERS_AND_ARGUMENTS_ERROR_CHECKING
12752 : mprintf ("In templateParameterAndArgumentErrorChecking(): templateParameterList != NULL && templateArgumentList == NULL: returnValue = %s \n",returnValue ? "true" : "false");
12753 : #endif
12754 : }
12755 :
12756 304943 : if (templateParameterList != NULL && templateArgumentList != NULL)
12757 : {
12758 : // This is the only allowed case (since functions template can be partially specialized.
12759 : // ROSE_ASSERT((VariantT)ReturnType::static_variant == V_SgTemplateClassDeclaration);
12760 : returnValue = (returnTypeVariant == V_SgTemplateClassSymbol || returnTypeVariant == V_SgTemplateVariableSymbol || returnTypeVariant == V_SgNonrealSymbol);
12761 : #if DEBUG_TEMPLATE_PARAMETERS_AND_ARGUMENTS_ERROR_CHECKING
12762 : mprintf ("In templateParameterAndArgumentErrorChecking(): templateParameterList != NULL && templateArgumentList != NULL: returnValue = %s \n",returnValue ? "true" : "false");
12763 : #endif
12764 : }
12765 : else
12766 : {
12767 284647 : if (templateArgumentList != NULL)
12768 : {
12769 : // ROSE_ASSERT((VariantT)ReturnType::static_variant == V_SgTemplateInstantiationDecl || (VariantT)ReturnType::static_variant == V_SgTemplateInstantiationFunctionDecl || (VariantT)ReturnType::static_variant == V_SgTemplateInstantiationMemberFunctionDecl);
12770 : returnValue = (returnTypeVariant == V_SgClassSymbol || returnTypeVariant == V_SgFunctionSymbol || returnTypeVariant == V_SgMemberFunctionSymbol || returnTypeVariant == V_SgNonrealSymbol);
12771 : #if DEBUG_TEMPLATE_PARAMETERS_AND_ARGUMENTS_ERROR_CHECKING
12772 : mprintf ("In templateParameterAndArgumentErrorChecking(): templateParameterList == NULL && templateArgumentList != NULL: returnValue = %s \n",returnValue ? "true" : "false");
12773 : #endif
12774 : }
12775 : }
12776 : }
12777 :
12778 : return returnValue;
12779 : }
12780 :
12781 :
12782 : #define DEBUG_SYMBOL_FILTER 0
12783 :
12784 : // DQ (4/14/2017): Test test2017_30.C demonstrates that we need to be able to force the filtering of symbols from templates
12785 : // and that they only way to do this is with an extra paramter to force this to happen. Since the lack of information triggers
12786 : // the more general semantics to return any symbol (which is fine as a simple API, but inconsistant with when this is called
12787 : // indirectly from the lookup_nontemplate_function_symbol() function (for example).
12788 : // template<class ReturnSymbolType> ReturnSymbolType* symbolFilter(ReturnSymbolType* symbol, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList)
12789 : template<class ReturnSymbolType>
12790 : ReturnSymbolType*
12791 7550006 : symbolFilter(ReturnSymbolType* symbol, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, bool filterTemplateSymbols)
12792 : {
12793 : // DQ (8/13/2013): This function filters types of IR nodes that could not be considered given the rules
12794 : // for what IR nodes apply when template parameters lists and template argument lists are provided.
12795 :
12796 7550006 : if (symbol != NULL)
12797 : {
12798 7414468 : VariantT symbolVariant = symbol->variantT();
12799 :
12800 : #if DEBUG_SYMBOL_FILTER
12801 : mprintf ("In symbolFilter(): symbolVariant = %d ReturnSymbolType variant = %d templateParameterList = %p templateArgumentList = %p \n",(int)symbolVariant,(int)ReturnSymbolType::static_variant,templateParameterList,templateArgumentList);
12802 : mprintf (" --- symbol = %p = %s \n",symbol,symbol->class_name().c_str());
12803 : mprintf (" --- symbol->get_name() = %s \n",symbol->get_name().str());
12804 : mprintf (" --- V_SgClassSymbol = %d \n",(int)V_SgClassSymbol);
12805 : mprintf (" --- V_SgFunctionSymbol = %d V_SgMemberFunctionSymbol = %d \n",(int)V_SgFunctionSymbol,(int)V_SgMemberFunctionSymbol);
12806 : mprintf (" --- V_SgTemplateFunctionSymbol = %d V_SgTemplateMemberFunctionSymbol = %d V_SgTemplateClassSymbol = %d \n",
12807 : (int)V_SgTemplateFunctionSymbol,(int)V_SgTemplateMemberFunctionSymbol,(int)V_SgTemplateClassSymbol);
12808 : mprintf (" --- filterTemplateSymbols = %s \n",filterTemplateSymbols ? "true" : "false");
12809 : #if 0
12810 : // Not all language constructs associated with a symbol are a SgDeclarationStatement.
12811 : // SgDeclarationStatement* declaration = symbol->get_declaration();
12812 : SgLocatedNode* declaration = symbol->get_declaration();
12813 :
12814 : mprintf (" --- declaration = %p \n",declaration);
12815 :
12816 : if (declaration != NULL)
12817 : {
12818 : mprintf (" --- declaration = %p = %s \n",declaration,declaration->class_name().c_str());
12819 :
12820 : // The source positions is not always set (e.g. during AST construction).
12821 : if (declaration->get_file_info() != NULL)
12822 : {
12823 : SgStatement* statement = isSgStatement(declaration);
12824 : if (statement != NULL)
12825 : {
12826 : ROSE_ASSERT(statement->get_file_info() != NULL);
12827 : statement->get_file_info()->display("symbol declaration location (statement)");
12828 : }
12829 : else
12830 : {
12831 : if (declaration->get_file_info() != NULL)
12832 : {
12833 : declaration->get_file_info()->display("symbol declaration location (non-statement)");
12834 : }
12835 : else
12836 : {
12837 : mprintf ("WARNING: In symbolFilter(): statement == NULL: declaration->get_file_info() == NULL \n");
12838 : }
12839 : }
12840 : }
12841 : else
12842 : {
12843 : mprintf ("WARNING: In symbolFilter(): declaration->get_file_info() == NULL \n");
12844 : }
12845 : }
12846 : else
12847 : {
12848 : mprintf ("WARNING: In symbolFilter(): declaration == NULL \n");
12849 : }
12850 : #endif
12851 : #endif
12852 :
12853 7414468 : if (templateParameterList != NULL)
12854 : {
12855 : // DQ (8/13/2013): If a template parameter list AND template argument list WERE provided then we only want to find class templates,
12856 : // so if this is NOT a template reset it to NULL. Note that the previous cast will have eliminated function symbols
12857 293321 : if ( (templateArgumentList != NULL) && (symbolVariant == V_SgClassSymbol) )
12858 : {
12859 : #if DEBUG_SYMBOL_FILTER
12860 : mprintf ("Reset symbol to NULL: (templateParameterList != NULL && templateArgumentList != NULL): V_SgClassSymbol = %d \n",(int)V_SgClassSymbol);
12861 : #endif
12862 306 : symbol = NULL;
12863 : }
12864 :
12865 : // DQ (8/13/2013): If a template parameter list WAS provided and a template argument list was NOT provided then we only want to find function templates,
12866 : // so if this is NOT a template reset it to NULL. Note that the previous cast will have eliminated class symbols.
12867 293321 : if ( (templateArgumentList == NULL) && (symbolVariant == V_SgFunctionSymbol || symbolVariant == V_SgMemberFunctionSymbol) )
12868 : {
12869 : #if DEBUG_SYMBOL_FILTER
12870 : mprintf ("Reset symbol to NULL: (templateParameterList != NULL && templateArgumentList == NULL): V_SgFunctionSymbol = %d V_SgMemberFunctionSymbol = %d \n",(int)V_SgFunctionSymbol,(int)V_SgMemberFunctionSymbol);
12871 : #endif
12872 0 : symbol = NULL;
12873 : }
12874 : }
12875 : else
12876 : {
12877 7121147 : if (templateArgumentList != NULL)
12878 : {
12879 : // DQ (8/13/2013): If a template parameter list was NOT provided then we only want to find non-templates,
12880 : // so if this IS a template reset it to NULL.
12881 284989 : if ( symbolVariant == V_SgTemplateFunctionSymbol || symbolVariant == V_SgTemplateMemberFunctionSymbol || symbolVariant == V_SgTemplateClassSymbol )
12882 : {
12883 : // This can't be a template since there is no templateParameterList
12884 : #if DEBUG_SYMBOL_FILTER
12885 : mprintf ("Reset symbol to NULL: (templateParameterList == NULL): V_SgTemplateFunctionSymbol = %d V_SgTemplateMemberFunctionSymbol = %d V_SgTemplateClassSymbol = %d \n",
12886 : (int)V_SgTemplateFunctionSymbol,(int)V_SgTemplateMemberFunctionSymbol,(int)V_SgTemplateClassSymbol);
12887 : #endif
12888 11200 : symbol = NULL;
12889 : }
12890 : }
12891 : else
12892 : {
12893 : // DQ (4/14/2017): Added support to disallow template symbolds explicitly.
12894 6836152 : if (filterTemplateSymbols == true)
12895 : {
12896 : // DQ (4/14/2017): This can't be a template symbol since we explicitly disallow it using a function parameter to control this.
12897 : #if DEBUG_SYMBOL_FILTER
12898 : mprintf ("Reset symbol to NULL: (filterTemplateSymbols == true && templateParameterList == NULL && templateArgumentList == NULL): V_SgTemplateFunctionSymbol = %d V_SgTemplateMemberFunctionSymbol = %d V_SgTemplateClassSymbol = %d \n",
12899 : (int)V_SgTemplateFunctionSymbol,(int)V_SgTemplateMemberFunctionSymbol,(int)V_SgTemplateClassSymbol);
12900 : #endif
12901 : // DQ (4/14/2017): Check if this is a template symbol (if so then set symbol to NULL to avoid returning a template symbol).
12902 650192 : if ( symbolVariant == V_SgTemplateFunctionSymbol || symbolVariant == V_SgTemplateMemberFunctionSymbol ||
12903 646565 : symbolVariant == V_SgTemplateClassSymbol || symbolVariant == V_SgTemplateTypedefSymbol ||
12904 : symbolVariant == V_SgTemplateVariableSymbol )
12905 : {
12906 3627 : symbol = NULL;
12907 : }
12908 : }
12909 : else
12910 : {
12911 : // DQ (4/14/2017): Original case before adding explicit control to avoid symbols associated with template declarations.
12912 :
12913 : // If both templateParameterList == NULL and templateArgumentList == NULL, then we have not provided enough
12914 : // information and are looking up symbols based only on name (and maybe type) and need to find the first match
12915 : // based on only this limited information. Basically, we want to provide the best possible match when less
12916 : // than enough information is available to make a precise match.
12917 : #if DEBUG_SYMBOL_FILTER
12918 : mprintf ("DO NOT Reset symbol to NULL: (templateParameterList == NULL && templateArgumentList == NULL): not enough information provided for a precise match \n");
12919 : #endif
12920 : }
12921 : }
12922 : }
12923 : }
12924 :
12925 : #if DEBUG_SYMBOL_FILTER
12926 : mprintf ("Leaving symbolFilter(): symbol = %p templateParameterList = %p templateArgumentList = %p filterTemplateSymbols = %s \n",
12927 : symbol,templateParameterList,templateArgumentList,filterTemplateSymbols ? "true" : "false");
12928 : #endif
12929 :
12930 7550006 : return symbol;
12931 : }
12932 :
12933 : bool
12934 116062 : isSubset(const std::vector<SgNode*>& a_vector, const std::set<SgNode*>& b_set)
12935 : {
12936 : // DQ (7/12/2014): I am not aware of a faster algorithm for this. Using the shorter
12937 : // vector (from the SgAliasSymbol) first will generally reduce the complexity for
12938 : // order Na * log Nb instead of log Nb. The value of Na would be the number of
12939 : // causal nodes for any SgAliasSymbol (typically one) and Nb would be the number
12940 : // of causal SgNode objects (e.g. SgUsingDirectiveStatement, SgUsingDeclarationStatement,
12941 : // SgBaseClass, etc.).
12942 :
12943 : #define DEBUG_IS_SUBSET 0
12944 :
12945 : #if DEBUG_IS_SUBSET
12946 : mprintf ("In isSubset(): a_vector.size() = %zu b_set.size() = %zu \n",a_vector.size(),b_set.size());
12947 : #endif
12948 :
12949 118630 : for (std::vector<SgNode*>::const_iterator i = a_vector.begin(); i != a_vector.end(); i++)
12950 : {
12951 24108 : bool found = false;
12952 : #if 0
12953 : for (std::set<SgNode*>::const_iterator j = b_set.begin(); j != b_set.end(); j++)
12954 : {
12955 : if (*i == *j)
12956 : {
12957 : found = true;
12958 : break;
12959 : }
12960 : }
12961 : #else
12962 24108 : std::set<SgNode*>::const_iterator j = find(b_set.begin(),b_set.end(),*i);
12963 24108 : found = (j != b_set.end());
12964 : #endif
12965 : #if DEBUG_IS_SUBSET
12966 : mprintf ("In isSubset(): loop: found = %s *i = %p = %s \n",found ? "true" : "false",*i,(*i)->class_name().c_str());
12967 : #endif
12968 24108 : if (!found)
12969 : {
12970 : #if DEBUG_IS_SUBSET
12971 : mprintf ("Leaving isSubset(): returning false \n");
12972 : #endif
12973 116062 : return false;
12974 : }
12975 : }
12976 :
12977 : #if DEBUG_IS_SUBSET
12978 : mprintf ("Leaving isSubset(): returning true \n");
12979 : #endif
12980 :
12981 : return true;
12982 : }
12983 :
12984 :
12985 : #define DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS 0
12986 :
12987 : namespace
12988 : {
12989 : // PP (4/29/22): replace SgSymbol::get_declaration
12990 : // with functions that check whether get_declaration exists
12991 : template <class SageSymbol>
12992 2006446 : auto getTypeOfDeclaration(const SageSymbol* sym) -> decltype(sym->get_declaration()->get_type())
12993 : {
12994 2006446 : auto ptr = sym->get_declaration();
12995 2006446 : ASSERT_not_null(ptr);
12996 :
12997 2006446 : return ptr->get_type();
12998 : }
12999 :
13000 : [[noreturn]]
13001 : auto getTypeOfDeclaration(const SgSymbol*) -> SgType*
13002 : {
13003 : ROSE_ABORT();
13004 : }
13005 : }
13006 :
13007 : // DQ (4/14/2017): Added explicit control to filer symbols associated with templates (see test2017_30.C for where this is required).
13008 : // DQ (7/31/2013): Added support for template parameters and template specialization.
13009 : // template<class ReturnType> ReturnType* SgSymbolTable::find_symbol_with_type_support (const SgName & nm, const SgType* type)
13010 : // template<class ReturnType> ReturnType* SgSymbolTable::find_symbol_with_type_support (const SgName & nm, const SgType* type, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList)
13011 : template<class ReturnType>
13012 10447301 : ReturnType* SgSymbolTable::find_symbol_with_type_support (const SgName & nm, const SgType* type, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList, bool filterTemplateSymbols)
13013 : {
13014 : // Templated function to support retrival of different types of symbols from the symbol table.
13015 : // This refactors a lot of code (some now and more later).
13016 :
13017 : // This low level templated function only makes sense for where the ReturnType is either of:
13018 : // SgFunctionSymbol, SgMemberFunctionSymbol, SgTemplateFunctionSymbol, SgTemplateMemberFunctionSymbol.
13019 :
13020 : // DQ (5/20/2013): Newer implementation of the symbol table handling to account for the template type, SgRenameSymbol, and SgAliasSymbols (in that order).
13021 :
13022 10447301 : ROSE_ASSERT(p_table != NULL);
13023 :
13024 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13025 : mprintf ("---------------------------------------------------------------------------------- \n");
13026 : mprintf ("In find_symbol_with_type_support(nm = %s, type = %p = %s, templateParameterList = %p, templateArgumentList = %p, filterTemplateSymbols = %s) \n",
13027 : nm.str(),type,(type != NULL) ? type->class_name().c_str() : "null",templateParameterList,templateArgumentList,filterTemplateSymbols ? "true" : "false");
13028 : #endif
13029 :
13030 10447301 : ROSE_ASSERT(templateParameterAndArgumentErrorChecking<ReturnType>(templateParameterList,templateArgumentList) == true);
13031 :
13032 : // bool restrictToSpecificType = true;
13033 :
13034 : // p_iterator = p_table->find(nm);
13035 : // hash_iterator save_original_iterator = p_iterator;
13036 :
13037 : // Find the sublist that match the name.
13038 10447301 : std::pair<hash_iterator, hash_iterator> range = p_table->equal_range(nm);
13039 10447301 : std::pair<hash_iterator, hash_iterator> save_original_range = range;
13040 :
13041 : // First look through only the local (non-aliased) symbols.
13042 :
13043 : // while(p_iterator != p_table->end())
13044 10860712 : for (hash_iterator i = range.first; i != range.second; ++i)
13045 : {
13046 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13047 : mprintf ("Check for SgAliasSymbol in SgSymbolTable::find_symbol_with_type_support(const SgName & nm = %s) \n",nm.str());
13048 : #endif
13049 7360747 : p_iterator = i;
13050 :
13051 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13052 : mprintf ("In loop over target symbols associated with nm = %s: p_iterator->second = %p = %s \n",nm.str(),p_iterator->second,p_iterator->second->class_name().c_str());
13053 : #endif
13054 :
13055 : // DQ (8/13/2013): Note that the effect of this is that if ReturnType == SgFunctionSymbol then symbol will be
13056 : // valid for both SgFunctionSymbol and SgMemberFunctionSymbol. However, since SgTemplateFunctionSymbol is derived
13057 : // from SgFunctionSymbol and SgTemplateMemberFunctionSymbol is derived from SgMemberFunctionSymbol, the same is
13058 : // not true for template function and template member function relationship. A SgTemplateMemberFunctionSymbol
13059 : // is NOT derived from a SgTemplateFunctionSymbol and thus a SgTemplateMemberFunctionSymbol dynamic_cast to a
13060 : // SgTemplateFunctionSymbol will be a NULL pointer (where for non-templates is will be a valid pointer.
13061 : // The solution is to always know if you want to find the class, function, or member functions symbol for
13062 : // either a template or non-template. Note that template instanitations are handled using SgFunctionSymbol
13063 : // and SgMemberFunctionSymbols (since they are functions), however, they require template arguments to be
13064 : // properly resolved. Template declarations similarly require template parameters. Since partial specialization
13065 : // of functions and member functions is not allowed in C++, template functions and template member functions
13066 : // don't use template arguments to there resolution. Since template classes can be partially specialized, both
13067 : // template parameters and template arguments are required for their resolution.
13068 7360747 : ReturnType* symbol = dynamic_cast<ReturnType*>(p_iterator->second);
13069 :
13070 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13071 : mprintf ("In loop over target symbols associated with nm = %s: (BEFORE symbolFilter) symbol = %p = %s \n",nm.str(),symbol,(symbol != NULL) ? symbol->class_name().c_str() : "null");
13072 : #endif
13073 : // DQ (8/13/2013): Added function to filter out types of symbols that would be found from
13074 : // a dynamic cast but which we are not interested in given the rules where template parameter
13075 : // lists and template argument lists apply.
13076 : // DQ (4/14/2017): Added explicit control to filter template symbols.
13077 7360747 : symbol = symbolFilter<ReturnType>(symbol,templateParameterList,templateArgumentList,filterTemplateSymbols);
13078 :
13079 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13080 : mprintf ("In loop over target symbols associated with nm = %s: (AFTER symbolFilter) symbol = %p = %s \n",nm.str(),symbol,(symbol != NULL) ? symbol->class_name().c_str() : "null");
13081 : #endif
13082 :
13083 : // DQ (8/21/2013): This is an additional filter that was not previously used (and copied from the
13084 : // find_symbol_support() function).
13085 : // DQ (6/24/2013): We catch the case of SgAliasSymbol in the tailing test of the symbol table,
13086 : // there we properly resolve it to its base symbol. When this template is instatiated using
13087 : // SgSymbol we have to worry about this detail, else the initialization of symbol above can never
13088 : // result in a SgAliasSymbol. So this is a result of writting very general code. Not sure how to
13089 : // make this a compile-time test so that we could avoid the overhead of using this dynamic cast.
13090 : // One performance alternative would be to have a specialization of this template for the general
13091 : // case of SgSymbol, but that should be considered later when we are sure that this is the final
13092 : // working implementation (so we will leave the code it is most re-factored state for now).
13093 : // if (isSgAliasSymbol(symbol) != NULL)
13094 7360747 : if ( (symbol != NULL) && (symbol->variantT() == (VariantT)SgAliasSymbol::static_variant) )
13095 : {
13096 : symbol = NULL;
13097 : }
13098 :
13099 : #if 0
13100 : // DQ (5/20/2013): Note that this is somewhat expensive and redundant, just checking.
13101 : if (symbol != NULL && get_table()->key_eq()(symbol->get_name(),nm) == false)
13102 : {
13103 : // I think that the function name is provided in mangled from and the name from the symbol would be in non-mangled form.
13104 : mprintf ("Note: In find_symbol_with_type_support(): symbol->get_name() != nm: symbol->get_name() = %s nm = %s \n",symbol->get_name().str(),nm.str());
13105 : }
13106 : #endif
13107 : #if 0
13108 : // DQ (8/21/2013): This fails for the case of Fortran labels that are numeric and converted to a numeric
13109 : // value and thus loose leading 0's. This function was not previously used for labels so this was not
13110 : // noticed. An example is in:
13111 : // --- tests/nonsmoke/functional/CompileTests/Fortran_tests/gfortranTestSuite/gfortran.dg/endfile_2.f90
13112 : // where the numeric label "0023" is used but stored in the SgLabelDeclaration as a numeric value "23"
13113 : // and thus the string "0023" fails to match with the string "23" in this assertion. The fundamental
13114 : // problem is that we ask the symbol for the name and this causes the name to be computed from the
13115 : // numeric label. Basically this is a problem that might best be solved by not tryig to compare
13116 : // the string generated from the numeric label to the name generated in the fortran frontend using
13117 : // the text string for the label.
13118 :
13119 : // This may be an expensive assert.
13120 : ROSE_ASSERT(symbol == NULL || get_table()->key_eq()(symbol->get_name(),nm) == true);
13121 : #endif
13122 :
13123 : // if (isSgFunctionSymbol(p_iterator->second) && (*p_iterator).first==nm)
13124 : // if (isSgFunctionSymbol(p_iterator->second) && get_table()->key_eq()((*p_iterator).first,nm))
13125 : // if (symbol != NULL && get_table()->key_eq()((*p_iterator).first,nm))
13126 : // if ( (symbol != NULL) && (symbol->get_declaration()->get_type() == type) && get_table()->key_eq()(sym->get_name(),nm))
13127 : // if ( (symbol != NULL) && (symbol->get_declaration()->get_type() == type) )
13128 7211677 : if ( (symbol != NULL) && ( (type == NULL) || ( (type != NULL) && (getTypeOfDeclaration(symbol) == type) ) ) )
13129 : {
13130 6962356 : p_name = nm;
13131 6962356 : p_no_name = false;
13132 : // return (SgFunctionSymbol *) p_iterator->second;
13133 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13134 : mprintf ("In SgSymbolTable::find_symbol_with_type_support(): name = %s type = %p = %s symbol = %p = %s \n",nm.str(),type,(type != NULL) ? type->class_name().c_str() : "null",symbol,symbol->class_name().c_str());
13135 : #endif
13136 :
13137 : // DQ (8/7/2013): Added support for template function overloading using template parameters.
13138 : // Note: We are handling the template arguments into the hasMatchingTemplateArgumentsOrNoTemplateArguments()
13139 : // as template specialization arguments which may be incorrect.
13140 :
13141 : // mprintf ("We are handling the template arguments into the hasMatchingTemplateArgumentsOrNoTemplateArguments() as template specialization arguments which may be incorrect \n");
13142 :
13143 : // return symbol;
13144 : // DQ (8/22/2012): If we have template arguments then we have a chance to disambiguate SgTemplateInstantiationDecl IR nodes based
13145 : // on the arguments which would otherwise require qulified names (which are difficult to robustly support using as the AST is
13146 : // being constructed).
13147 : // break;
13148 6962356 : if (hasMatchingTemplateParametersArgumentsOrNoTemplateParametersArguments(templateParameterList,templateArgumentList,symbol) == true)
13149 : {
13150 : // return classSymbol;
13151 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13152 : mprintf ("In SgSymbolTable::find_symbol_with_type_support(): Found a match: return symbol = %p = %s nm = %s \n",symbol,symbol->class_name().c_str(),nm.str());
13153 : #endif
13154 : // DQ (8/8/2013): I think we should return the symbol rather than break.
13155 : // DQ (9/9/2012): We could either call "break" to get out of the loop, or directly "return s".
13156 : // break;
13157 10447301 : return symbol;
13158 : }
13159 : else
13160 : {
13161 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13162 : mprintf ("In SgSymbolTable::find_symbol_with_type_support(): The template arguments are NOT the same for symbol = %p = %s (keep searching) nm = %s \n",symbol,symbol->class_name().c_str(),nm.str());
13163 : #endif
13164 : // DQ (9/9/2012): If this is not a match, then we have to set s == NULL so that we will not accidentally returning the WRONG sysmbol at the end of the loop.
13165 413408 : symbol = NULL;
13166 : }
13167 : }
13168 : else
13169 : {
13170 : // DQ (10/11/2008): Added support to find renamed functions (common in Fortran 90)
13171 : // F90 permits interface statements to effectively rename functions is scope,
13172 : // SgRenameSymbol IR nodes are used to represent the renamed functions. This
13173 : // renaming using an interface is different from the aliasing and combined renaming
13174 : // that is possible within the "use" statement.
13175 398395 : if ( p_iterator->second->variantT() == V_SgRenameSymbol)
13176 : {
13177 : // mprintf ("Found a SgRenameSymbol: p_iterator->second->class_name() = %s p_iterator->second->get_name() = %s \n",p_iterator->second->class_name().c_str(),p_iterator->second->get_name().str());
13178 :
13179 0 : p_name = nm;
13180 0 : p_no_name = false;
13181 0 : SgRenameSymbol* renameSymbol = isSgRenameSymbol(p_iterator->second);
13182 0 : ROSE_ASSERT(renameSymbol != NULL);
13183 :
13184 : // DQ (10/11/2008): Moved SgRenameSymbol to be derived from SgFunctionSymbol.
13185 : // SgFunctionSymbol* functionSymbol = isSgFunctionSymbol(renameSymbol->get_original_symbol());
13186 : // SgFunctionSymbol* functionSymbol = isSgFunctionSymbol(renameSymbol);
13187 :
13188 : // DQ (5/24/2013): This should have been expressed in terms of renameSymbol->get_original_symbol().
13189 : // ReturnType* original_renamed_symbol = dynamic_cast<ReturnType*>(p_iterator->second);
13190 0 : ReturnType* original_renamed_symbol = dynamic_cast<ReturnType*>(renameSymbol->get_original_symbol());
13191 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13192 : mprintf ("In SgSymbolTable::find_symbol_with_type_support(): Need filtering for SgRenameSymbol cases \n");
13193 : #endif
13194 : // assert(functionSymbol != NULL);
13195 : // return functionSymbol;
13196 0 : ROSE_ASSERT(original_renamed_symbol != NULL);
13197 0 : return original_renamed_symbol;
13198 : }
13199 : }
13200 :
13201 : // p_iterator++;
13202 : }
13203 :
13204 : // DQ (9/30/2008): If we have not found a symbol from the current scope, search for symbols
13205 : // injected from other scopes using the Fortran "use" statment (or in a future implementation
13206 : // the C++ "using" directive or "using" declaration).
13207 : // p_iterator = save_original_iterator;
13208 : // while(p_iterator != p_table->end() && (*p_iterator).first==nm)
13209 : // while(p_iterator != p_table->end() && get_table()->key_eq()((*p_iterator).first,nm))
13210 :
13211 : // Reset the range so we can look for SgAliasSymbols.
13212 3499956 : range = save_original_range;
13213 :
13214 : // Iterate through the list that match the name to find the one that is a SgTemplateSymbol and has a matching SgType pointer.
13215 3733800 : for (hash_iterator i = range.first; i != range.second; ++i)
13216 : {
13217 328371 : p_iterator = i;
13218 :
13219 : // mprintf ("Looking for aliased symbols: p_iterator->second->class_name() = %s p_iterator->second->get_name() = %s \n",p_iterator->second->class_name().c_str(),p_iterator->second->get_name().str());
13220 328371 : SgAliasSymbol* aliasedSymbol = isSgAliasSymbol(p_iterator->second);
13221 328371 : if (aliasedSymbol != NULL)
13222 : {
13223 : // DQ (10/9/2008): Resolve the last link in any chain of alias symbols
13224 : // SgFunctionSymbol* functionSymbol = isSgFunctionSymbol(aliasedSymbol->get_alias());
13225 : // SgFunctionSymbol* functionSymbol = isSgFunctionSymbol(aliasedSymbol->get_base());
13226 189251 : ReturnType* original_aliased_symbol = dynamic_cast<ReturnType*>(aliasedSymbol->get_base());
13227 : // mprintf ("Looking for functionSymbol = %p \n",functionSymbol);
13228 :
13229 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13230 : mprintf ("In loop over target ALIASED symbols associated with nm = %s (BEFORE symbolFilter) original_aliased_symbol = %p = %s \n",nm.str(),original_aliased_symbol,(original_aliased_symbol != NULL) ? original_aliased_symbol->class_name().c_str() : "null");
13231 : #endif
13232 : // DQ (8/13/2013): Added function to filter out types of symbols that would be found from
13233 : // a dynamic cast but which we are not interested in given the rules where template parameter
13234 : // lists and template argument lists apply.
13235 : // DQ (4/14/2017): Added explicit control to filter template symbols.
13236 189251 : original_aliased_symbol = symbolFilter<ReturnType>(original_aliased_symbol,templateParameterList,templateArgumentList,filterTemplateSymbols);
13237 :
13238 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13239 : mprintf ("In loop over target ALIASED symbols associated with nm = %s (AFTER symbolFilter) original_aliased_symbol = %p = %s \n",nm.str(),original_aliased_symbol,(original_aliased_symbol != NULL) ? original_aliased_symbol->class_name().c_str() : "null");
13240 : #endif
13241 :
13242 : // DQ (10/10/2008): The current problem is that this is NULL when the base of an aliased symbol is a SgRenameSymbol.
13243 : // assert(functionSymbol != NULL);
13244 :
13245 : // Liao 9/15/2016
13246 : // Allow template function type match. They may have arguments of template types
13247 189251 : SgFunctionType* f1 = NULL;
13248 189251 : if (original_aliased_symbol != NULL && isSgFunctionSymbol(original_aliased_symbol))
13249 60962 : f1= isSgFunctionType(isSgFunctionSymbol(original_aliased_symbol)->get_declaration()->get_type());
13250 189251 : SgFunctionType* f2 = NULL;
13251 189251 : if (type != NULL)
13252 37875 : f2 = isSgFunctionType (const_cast <SgType*> (type));
13253 :
13254 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13255 : mprintf ("In loop over target ALIASED symbols associated with nm = %s compare types = %p and %p \n",nm.str(),f1, f2);
13256 : #endif
13257 :
13258 189251 : bool equavilentFunctionType= ( (f1!= NULL && f2!= NULL) && (SageInterface::isEquivalentFunctionType(f1, f2)) );
13259 :
13260 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13261 : mprintf (" -- equavilentFunctionType = %s\n", equavilentFunctionType ? "true" : "false");
13262 : #endif
13263 :
13264 : // if ( functionSymbol != NULL )
13265 : // if ( original_aliased_symbol != NULL )
13266 : // if ( (original_aliased_symbol != NULL) && (original_aliased_symbol->get_declaration()->get_type() == type))
13267 : // if ( (original_aliased_symbol != NULL) && ( (type == NULL) || (type != NULL) && (original_aliased_symbol->get_declaration()->get_type() == type) ) )
13268 189251 : if ( (original_aliased_symbol != NULL) && ( (type == NULL) || ((type != NULL) && (getTypeOfDeclaration(original_aliased_symbol) == type || equavilentFunctionType)) ) )
13269 : {
13270 : // mprintf ("Found a valid functionSymbol = %p = %s \n",functionSymbol,functionSymbol->get_name().str());
13271 152954 : p_name = nm;
13272 152954 : p_no_name = false;
13273 : // return functionSymbol;
13274 :
13275 :
13276 : // return original_aliased_symbol;
13277 :
13278 : // DQ (8/7/2013): Added support for template function overloading using template parameters.
13279 : // DQ (8/22/2012): If we have template arguments then we have a chance to disambiguate SgTemplateInstantiationDecl IR nodes based
13280 : // on the arguments which would otherwise require qulified names (which are difficult to robustly support using as the AST is
13281 : // being constructed).
13282 : // break;
13283 152954 : if (hasMatchingTemplateParametersArgumentsOrNoTemplateParametersArguments(templateParameterList,templateArgumentList,original_aliased_symbol) == true)
13284 : {
13285 : // return classSymbol;
13286 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13287 : mprintf ("In SgSymbolTable::find_symbol_with_type_support(): Found a match: return original_aliased_symbol = %p = %s nm = %s \n",original_aliased_symbol,original_aliased_symbol->class_name().c_str(),nm.str());
13288 : #endif
13289 : // DQ (8/8/2013): I think we should return the symbol rather than break.
13290 : // DQ (9/9/2012): We could either call "break" to get out of the loop, or directly "return s".
13291 : // break;
13292 : #if 1
13293 : // DQ (7/12/2014): To support better symbol handling for name qualification. At this point were
13294 : // we have identified the target aliased symbol, we need to check if the associated reason for
13295 : // it being an alias symbol has been seen in the AST yet. The cause for the alias symbol is a
13296 : // causal node that is stored in the SgAliasSymbol (new modification to SgAliasSymbol). The list
13297 : // of possible causal nodes for alias symbols to be inserted is held in a static member of the
13298 : // SgSymbolTable (new modification to SgSymbolTable).
13299 : // if (aliasSymbolCausalNodeSet.find(original_aliased_symbol->get_causal_nodes().begin(),original_aliased_symbol->get_causal_nodes().end()) != aliasSymbolCausalNodeSet.end())
13300 116062 : bool foundCausalNode = isSubset(aliasedSymbol->get_causal_nodes(),get_aliasSymbolCausalNodeSet());
13301 116062 : if (foundCausalNode == true)
13302 : {
13303 : // DQ (1/23/2019): I think that this support is specific to the references to a symbol before
13304 : // a using directive that would make is visible vs after the using directive. Unfortunately it
13305 : // is not sufficent to support when a class is derivied from another class and private derivation
13306 : // would cause alis symbols to be seen or not seen in the subsequent coass derivations (see
13307 : // Cxx_tests/test2019_21.C).
13308 : // NOTE: the set defined by get_aliasSymbolCausalNodeSet() is only maintained in the name qualification
13309 : // support and so it is useless within the
13310 : // FixupAstSymbolTablesToSupportAliasedSymbols::injectSymbolsFromReferencedScopeIntoCurrentScope()
13311 : // function. So to fix this we have added to code in this function to insert the causal nodes into
13312 : // the required set. It might be that this set should be cleared before starting the namequalification
13313 : // phase.
13314 :
13315 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13316 : mprintf ("Found causal node for SgAliasSymbol: aliasedSymbol = %p = %s original_aliased_symbol = %p = %s \n",
13317 : aliasedSymbol,aliasedSymbol->class_name().c_str(),original_aliased_symbol,original_aliased_symbol->class_name().c_str());
13318 : ROSE_ASSERT(aliasedSymbol->get_alias() != NULL);
13319 : mprintf (" --- aliasedSymbol = %p aliasedSymbol->get_alias() = %p = %s \n",aliasedSymbol,aliasedSymbol->get_alias(),aliasedSymbol->get_alias()->class_name().c_str());
13320 : mprintf (" --- aliasedSymbol->get_causal_nodes().size() = %" PRIuPTR " \n",aliasedSymbol->get_causal_nodes().size());
13321 : mprintf (" --- get_aliasSymbolCausalNodeSet().size() = %" PRIuPTR " \n",get_aliasSymbolCausalNodeSet().size());
13322 : #endif
13323 94522 : return original_aliased_symbol;
13324 : }
13325 : else
13326 : {
13327 : // DQ (7/12/2014): If we didn't find the causal node then we can't consider the alias to exist
13328 : // yet in the traversal of the AST represented by the symbol table query at this point.
13329 233849 : original_aliased_symbol = NULL;
13330 :
13331 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13332 : mprintf ("associated causal nodes not seen yet in traversal of AST: \n");
13333 : ROSE_ASSERT(aliasedSymbol->get_alias() != NULL);
13334 : mprintf (" --- aliasedSymbol = %p aliasedSymbol->get_alias() = %p = %s \n",aliasedSymbol,aliasedSymbol->get_alias(),aliasedSymbol->get_alias()->class_name().c_str());
13335 : mprintf (" --- aliasedSymbol->get_causal_nodes().size() = %zu \n",aliasedSymbol->get_causal_nodes().size());
13336 : mprintf (" --- get_aliasSymbolCausalNodeSet().size() = %zu \n",get_aliasSymbolCausalNodeSet().size());
13337 : for (std::vector<SgNode*>::iterator i = aliasedSymbol->get_causal_nodes().begin(); i != aliasedSymbol->get_causal_nodes().end(); i++)
13338 : {
13339 : mprintf (" --- causal node = %p = %s \n",*i,(*i)->class_name().c_str());
13340 : }
13341 : #endif
13342 : }
13343 : #else
13344 : // DQ (7/12/2014): Older original version of code.
13345 : return original_aliased_symbol;
13346 : #endif
13347 : }
13348 : else
13349 : {
13350 : #if DEBUG_FIND_SYMBOL_WITH_TEMPLATE_ARGUMENTS
13351 : mprintf ("In SgSymbolTable::find_symbol_with_type_support(): The template arguments are NOT the same for original_aliased_symbol = %p = %s (keep searching) nm = %s \n",original_aliased_symbol,original_aliased_symbol->class_name().c_str(),nm.str());
13352 : #endif
13353 : // DQ (9/9/2012): If this is not a match, then we have to set s == NULL so that we will not accidentally returning the WRONG sysmbol at the end of the loop.
13354 : original_aliased_symbol = NULL;
13355 : }
13356 : }
13357 : }
13358 : }
13359 :
13360 : #if 1
13361 3405439 : if (this->get_force_search_of_base_classes() == true)
13362 : {
13363 : // DQ (3/28/2014): If we reach this point, then in the case of Java, we have to search the
13364 : // base class definitions (since the representation of Java base class does not presently
13365 : // inject the base class symbols into the derived class symbol table. There are pros and
13366 : // const to this design. But this function will at least make the API semantics that same.
13367 0 : SgNode* parentNode = this->get_parent();
13368 0 : ROSE_ASSERT(parentNode != NULL);
13369 0 : SgClassDefinition* classDefinition = isSgClassDefinition(parentNode);
13370 0 : if (classDefinition != NULL)
13371 : {
13372 : #if 0
13373 : mprintf ("Found SgClassDefinition as parent of SgSymbolTable \n");
13374 : #endif
13375 0 : SgBaseClassPtrList & base_classes = classDefinition->get_inheritances();
13376 :
13377 0 : SgBaseClassPtrList::iterator i = base_classes.begin();
13378 0 : while (i != base_classes.end())
13379 : {
13380 0 : SgBaseClass* baseClass = *i;
13381 0 : ROSE_ASSERT(baseClass != NULL);
13382 0 : SgClassDeclaration* baseClassDeclaration = baseClass->get_base_class();
13383 0 : ROSE_ASSERT(baseClassDeclaration != NULL);
13384 : #if 0
13385 : mprintf (" --- baseClassDeclaration = %p = %s = %s \n",baseClassDeclaration,baseClassDeclaration->class_name().c_str(),baseClassDeclaration->get_name().str());
13386 : #endif
13387 0 : SgClassDeclaration* baseClassDeclaration_defining = isSgClassDeclaration(baseClassDeclaration->get_definingDeclaration());
13388 :
13389 : // DQ: Note that we have to implement conditional lookup based on base class permissions, plus the access permissions of base class members.
13390 0 : if (baseClassDeclaration_defining != NULL)
13391 : {
13392 0 : SgClassDefinition* baseClassDefinition = baseClassDeclaration_defining->get_definition();
13393 0 : ROSE_ASSERT(baseClassDefinition != NULL);
13394 :
13395 0 : ROSE_ASSERT(baseClassDefinition->get_symbol_table() != NULL);
13396 :
13397 : // DQ (4/14/2017): Added explicit support to filter symbols associated with templates.
13398 : // Make a recursive call on the symbol table associated with the base class.
13399 0 : ReturnType* symbol = baseClassDefinition->get_symbol_table()->find_symbol_with_type_support<ReturnType>(nm,type,templateParameterList,templateArgumentList,filterTemplateSymbols);
13400 : #if 0
13401 : mprintf (" --- baseClassDefinition = %p symbol = %p \n",baseClassDefinition,symbol);
13402 : #endif
13403 : #if 0
13404 : mprintf ("Exiting as a test! \n");
13405 : ROSE_ASSERT(false);
13406 : #endif
13407 0 : if (symbol != NULL)
13408 : {
13409 0 : return symbol;
13410 : }
13411 : }
13412 :
13413 0 : i++;
13414 : #if 0
13415 : mprintf ("Exiting as a test! \n");
13416 : ROSE_ASSERT(false);
13417 : #endif
13418 : }
13419 : #if 0
13420 : mprintf ("Exiting as a test! \n");
13421 : ROSE_ASSERT(false);
13422 : #endif
13423 : }
13424 : }
13425 : #endif
13426 :
13427 : return NULL;
13428 : }
13429 :
13430 :
13431 : /* ************************************************************************
13432 : DQ (1/30/2007): Added remove functions for each sort of SgSymbol IR node
13433 : ************************************************************************
13434 : SgSymbol* find_any();
13435 : SgVariableSymbol* find_variable();
13436 : SgClassSymbol* find_class();
13437 : SgFunctionSymbol* find_function();
13438 : SgFunctionSymbol* find_function_type();
13439 : SgTypedefSymbol* find_typedef();
13440 : SgEnumSymbol* find_enum();
13441 : SgEnumFieldSymbol* find_enum_field();
13442 : SgLabelSymbol* find_label();
13443 : SgNamespaceSymbol* find_namespace();
13444 : */
13445 :
13446 : #if 0
13447 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13448 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
13449 : SgSymbol*
13450 : SgSymbolTable::findfirstany()
13451 : {
13452 : return find_any();
13453 : }
13454 : #endif
13455 :
13456 : SgSymbol*
13457 0 : SgSymbolTable::find_any()
13458 : {
13459 0 : ROSE_ASSERT(p_table != NULL);
13460 0 : p_iterator = p_table->begin();
13461 0 : p_no_name = true;
13462 0 : if(p_iterator != p_table->end())
13463 0 : return (SgSymbol *) p_iterator->second;
13464 :
13465 : return NULL;
13466 : }
13467 :
13468 : #if 0
13469 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13470 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
13471 : SgVariableSymbol*
13472 : SgSymbolTable::findfirstvar()
13473 : {
13474 : return find_variable();
13475 : }
13476 : #endif
13477 :
13478 : SgVariableSymbol*
13479 0 : SgSymbolTable::find_variable()
13480 : {
13481 0 : ROSE_ASSERT(p_table != NULL);
13482 :
13483 0 : p_iterator = p_table->begin();
13484 0 : p_no_name = true;
13485 0 : while(p_iterator != p_table->end())
13486 : {
13487 : // if(isSgVariableSymbol((*p_iterator).second))
13488 : // return ((SgVariableSymbol *)(*p_iterator).second);
13489 0 : if (p_iterator->second->variantT() == V_SgVariableSymbol)
13490 0 : return (SgVariableSymbol *) p_iterator->second;
13491 0 : p_iterator++;
13492 : }
13493 :
13494 : return NULL;
13495 : }
13496 :
13497 : #if 0
13498 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13499 : // DQ (1/30/2007): Added these back into ROSE.
13500 : SgClassSymbol*
13501 : SgSymbolTable::findfirstclass()
13502 : {
13503 : return find_class();
13504 : }
13505 : #endif
13506 :
13507 : SgClassSymbol*
13508 0 : SgSymbolTable::find_class()
13509 : {
13510 0 : ROSE_ASSERT(p_table != NULL);
13511 0 : if (p_table)
13512 : {
13513 0 : p_iterator = p_table->begin();
13514 0 : p_no_name = true;
13515 0 : while (p_iterator != p_table->end())
13516 : {
13517 : // if (isSgClassSymbol((*p_iterator).second))
13518 : // return ((SgClassSymbol *)(*p_iterator).second);
13519 0 : if (p_iterator->second->variantT() == V_SgClassSymbol)
13520 0 : return (SgClassSymbol *) p_iterator->second;
13521 0 : p_iterator++;
13522 : }
13523 : }
13524 :
13525 : return NULL;
13526 : }
13527 :
13528 : #if 0
13529 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13530 : // DQ (1/30/2007): Added these back into ROSE.
13531 : SgFunctionSymbol*
13532 : SgSymbolTable::findfirstfunction()
13533 : {
13534 : return find_function();
13535 : }
13536 : #endif
13537 :
13538 : SgFunctionSymbol*
13539 0 : SgSymbolTable::find_function()
13540 : {
13541 0 : ROSE_ASSERT(p_table != NULL);
13542 0 : if(p_table)
13543 : {
13544 0 : p_iterator = p_table->begin();
13545 0 : p_no_name = true;
13546 0 : while(p_iterator != p_table->end())
13547 : {
13548 : // if(isSgFunctionSymbol((*p_iterator).second))
13549 : // return ((SgFunctionSymbol *)(*p_iterator).second);
13550 0 : if (p_iterator->second->variantT() == V_SgFunctionSymbol)
13551 0 : return (SgFunctionSymbol *) p_iterator->second;
13552 0 : p_iterator++;
13553 : }
13554 : }
13555 :
13556 : return NULL;
13557 : }
13558 :
13559 : #if 0
13560 : // DQ (1/30/2007): Added to make the interface consistant
13561 : // This function is not required since SgFunctionTypeSymbols
13562 : // are stored into their own function table. So this is
13563 : // equivalent to STL function "begin()".
13564 : SgFunctionSymbol*
13565 : SgSymbolTable::find_function_type()
13566 : {
13567 : ROSE_ASSERT(p_table != NULL);
13568 : if(p_table)
13569 : {
13570 : p_iterator = p_table->begin();
13571 : p_no_name = true;
13572 : while(p_iterator != p_table->end())
13573 : {
13574 : // if(isSgFunctionSymbol((*p_iterator).second))
13575 : // return ((SgFunctionSymbol *)(*p_iterator).second);
13576 : if (p_iterator->second->variantT() == V_SgFunctionTypeSymbol)
13577 : return (SgFunctionTypeSymbol *) p_iterator->second;
13578 : p_iterator++;
13579 : }
13580 : }
13581 :
13582 : return NULL;
13583 : }
13584 : #endif
13585 :
13586 : SgTypedefSymbol*
13587 0 : SgSymbolTable::find_typedef()
13588 : {
13589 0 : ROSE_ASSERT(p_table != NULL);
13590 0 : if (p_table)
13591 : {
13592 0 : p_iterator = p_table->begin();
13593 0 : p_no_name = true;
13594 0 : while (p_iterator != p_table->end())
13595 : {
13596 : // if (isSgTypedefSymbol((*p_iterator).second))
13597 : // return ((SgTypedefSymbol *)(*p_iterator).second);
13598 0 : if (p_iterator->second->variantT() == V_SgTypedefSymbol)
13599 0 : return (SgTypedefSymbol *) p_iterator->second;
13600 0 : p_iterator++;
13601 : }
13602 : }
13603 :
13604 : return NULL;
13605 : }
13606 :
13607 : SgEnumSymbol*
13608 0 : SgSymbolTable::find_enum()
13609 : {
13610 0 : ROSE_ASSERT(p_table != NULL);
13611 0 : if (p_table)
13612 : {
13613 0 : p_iterator = p_table->begin();
13614 0 : p_no_name = true;
13615 0 : while (p_iterator != p_table->end())
13616 : {
13617 : // if (isSgEnumSymbol((*p_iterator).second))
13618 : // return ((SgEnumSymbol *)(*p_iterator).second);
13619 0 : if (p_iterator->second->variantT() == V_SgEnumSymbol)
13620 0 : return (SgEnumSymbol *) p_iterator->second;
13621 0 : p_iterator++;
13622 : }
13623 : }
13624 :
13625 : return NULL;
13626 : }
13627 :
13628 : SgEnumFieldSymbol*
13629 0 : SgSymbolTable::find_enum_field()
13630 : {
13631 0 : ROSE_ASSERT(p_table != NULL);
13632 0 : if (p_table)
13633 : {
13634 0 : p_iterator = p_table->begin();
13635 0 : p_no_name = true;
13636 0 : while (p_iterator != p_table->end())
13637 : {
13638 : // if (isSgEnumFieldSymbol((*p_iterator).second))
13639 : // return ((SgEnumFieldSymbol *)(*p_iterator).second);
13640 0 : if (p_iterator->second->variantT() == V_SgEnumFieldSymbol)
13641 0 : return (SgEnumFieldSymbol *) p_iterator->second;
13642 0 : p_iterator++;
13643 : }
13644 : }
13645 :
13646 : return NULL;
13647 : }
13648 :
13649 : SgLabelSymbol*
13650 0 : SgSymbolTable::find_label()
13651 : {
13652 0 : ROSE_ASSERT(p_table != NULL);
13653 0 : if (p_table)
13654 : {
13655 0 : p_iterator = p_table->begin();
13656 0 : p_no_name = true;
13657 0 : while (p_iterator != p_table->end())
13658 : {
13659 : // if (isSgLabelSymbol((*p_iterator).second))
13660 : // return ((SgLabelSymbol *)(*p_iterator).second);
13661 0 : if (p_iterator->second->variantT() == V_SgLabelSymbol)
13662 0 : return (SgLabelSymbol *) p_iterator->second;
13663 0 : p_iterator++;
13664 : }
13665 : }
13666 :
13667 : return NULL;
13668 : }
13669 :
13670 : SgNamespaceSymbol*
13671 0 : SgSymbolTable::find_namespace()
13672 : {
13673 0 : ROSE_ASSERT(p_table != NULL);
13674 0 : if (p_table)
13675 : {
13676 0 : p_iterator = p_table->begin();
13677 0 : p_no_name = true;
13678 0 : while (p_iterator != p_table->end())
13679 : {
13680 : // if (isSgNamespaceSymbol((*p_iterator).second))
13681 : // return ((SgNamespaceSymbol *)(*p_iterator).second);
13682 0 : if (p_iterator->second->variantT() == V_SgNamespaceSymbol)
13683 0 : return (SgNamespaceSymbol *) p_iterator->second;
13684 0 : p_iterator++;
13685 : }
13686 : }
13687 :
13688 : return NULL;
13689 : }
13690 :
13691 : SgTemplateSymbol*
13692 0 : SgSymbolTable::find_template()
13693 : {
13694 0 : ROSE_ASSERT(p_table != NULL);
13695 0 : if (p_table)
13696 : {
13697 0 : p_iterator = p_table->begin();
13698 0 : p_no_name = true;
13699 0 : while (p_iterator != p_table->end())
13700 : {
13701 : // if (isSgTemplateSymbol((*p_iterator).second))
13702 : // return ((SgTemplateSymbol *)(*p_iterator).second);
13703 0 : if (p_iterator->second->variantT() == V_SgTemplateSymbol)
13704 0 : return (SgTemplateSymbol *) p_iterator->second;
13705 0 : p_iterator++;
13706 : }
13707 : }
13708 :
13709 : return NULL;
13710 : }
13711 :
13712 :
13713 : /* ************************************************************************
13714 : DQ (1/30/2007): Added remove functions for each sort of SgSymbol IR node
13715 : ************************************************************************
13716 : SgSymbol* next_any();
13717 : SgVariableSymbol* next_variable();
13718 : SgClassSymbol* next_class();
13719 : SgFunctionSymbol* next_function();
13720 : SgTypedefSymbol* next_typedef();
13721 : SgEnumSymbol* next_enum();
13722 : SgEnumFieldSymbol* next_enum_field();
13723 : SgLabelSymbol* next_label();
13724 : SgNamespaceSymbol* next_namespace();
13725 : */
13726 :
13727 : #if 0
13728 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13729 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
13730 : SgSymbol*
13731 : SgSymbolTable::nextany()
13732 : {
13733 : return next_any();
13734 : }
13735 : #endif
13736 :
13737 : SgSymbol*
13738 0 : SgSymbolTable::next_any()
13739 : {
13740 0 : ROSE_ASSERT(p_table != NULL);
13741 0 : if(p_table)
13742 : {
13743 0 : p_iterator++;
13744 :
13745 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13746 0 : while( p_iterator != p_table->end() )
13747 : {
13748 : // if( p_no_name || (*p_iterator).first == p_name )
13749 0 : if( p_no_name || get_table()->key_eq()((*p_iterator).first,p_name) )
13750 0 : return (SgSymbol *) p_iterator->second;
13751 0 : p_iterator++;
13752 : }
13753 : }
13754 :
13755 : return NULL;
13756 : }
13757 :
13758 : #if 0
13759 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13760 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
13761 : SgVariableSymbol*
13762 : SgSymbolTable::nextvar()
13763 : {
13764 : return next_variable();
13765 : }
13766 : #endif
13767 :
13768 : SgVariableSymbol*
13769 0 : SgSymbolTable::next_variable()
13770 : {
13771 0 : ROSE_ASSERT(p_table != NULL);
13772 0 : if (p_table != NULL)
13773 : {
13774 0 : p_iterator++;
13775 :
13776 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13777 : // while (p_iterator != p_table->end() && (p_no_name || (*p_iterator).first==p_name))
13778 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13779 : {
13780 0 : if (isSgVariableSymbol((*p_iterator).second))
13781 0 : return ((SgVariableSymbol *) (*p_iterator).second);
13782 0 : p_iterator++;
13783 : }
13784 : }
13785 :
13786 0 : return NULL;
13787 : }
13788 :
13789 : #if 0
13790 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13791 : // DQ (1/30/2007): Added these back into ROSE.
13792 : SgClassSymbol*
13793 : SgSymbolTable::nextclass()
13794 : {
13795 : return next_class();
13796 : }
13797 : #endif
13798 :
13799 : SgClassSymbol*
13800 0 : SgSymbolTable::next_class()
13801 : {
13802 0 : ROSE_ASSERT(p_table != NULL);
13803 0 : if(p_table)
13804 : {
13805 0 : p_iterator++; // go to next one
13806 :
13807 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13808 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13809 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13810 : {
13811 0 : if (isSgClassSymbol((*p_iterator).second))
13812 0 : return ((SgClassSymbol *)(*p_iterator).second);
13813 0 : p_iterator++;
13814 : }
13815 : }
13816 :
13817 0 : return NULL;
13818 : }
13819 :
13820 : #if 0
13821 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13822 : // DQ (1/30/2007): Added these back into ROSE.
13823 : SgFunctionSymbol*
13824 : SgSymbolTable::nextfunc()
13825 : {
13826 : return next_function();
13827 : }
13828 : #endif
13829 :
13830 : SgFunctionSymbol*
13831 0 : SgSymbolTable::next_function()
13832 : {
13833 0 : ROSE_ASSERT(p_table != NULL);
13834 0 : if(p_table)
13835 : {
13836 0 : p_iterator++;
13837 :
13838 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13839 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13840 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13841 : {
13842 0 : if (isSgFunctionSymbol((*p_iterator).second))
13843 0 : return ((SgFunctionSymbol *)(*p_iterator).second);
13844 0 : p_iterator++;
13845 : }
13846 : }
13847 :
13848 0 : return NULL;
13849 : }
13850 :
13851 : SgTypedefSymbol*
13852 0 : SgSymbolTable::next_typedef()
13853 : {
13854 0 : ROSE_ASSERT(p_table != NULL);
13855 0 : if (p_table != NULL)
13856 : {
13857 0 : p_iterator++;
13858 :
13859 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13860 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13861 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13862 : {
13863 0 : if (isSgTypedefSymbol((*p_iterator).second))
13864 0 : return ((SgTypedefSymbol *) (*p_iterator).second);
13865 0 : p_iterator++;
13866 : }
13867 : }
13868 :
13869 0 : return NULL;
13870 : }
13871 :
13872 :
13873 : // DQ (1/30/2007): Added this as a new member function.
13874 : SgEnumSymbol*
13875 0 : SgSymbolTable::next_enum()
13876 : {
13877 0 : ROSE_ASSERT(p_table != NULL);
13878 0 : if(p_table)
13879 : {
13880 0 : p_iterator++;
13881 :
13882 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13883 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13884 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13885 : {
13886 0 : if (isSgEnumSymbol((*p_iterator).second))
13887 0 : return ((SgEnumSymbol *)(*p_iterator).second);
13888 0 : p_iterator++;
13889 : }
13890 : }
13891 :
13892 0 : return NULL;
13893 : }
13894 :
13895 : // DQ (1/30/2007): Added this as a new member function.
13896 : SgEnumFieldSymbol*
13897 0 : SgSymbolTable::next_enum_field()
13898 : {
13899 0 : ROSE_ASSERT(p_table != NULL);
13900 0 : if(p_table)
13901 : {
13902 0 : p_iterator++;
13903 :
13904 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13905 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13906 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13907 : {
13908 0 : if(isSgEnumFieldSymbol((*p_iterator).second))
13909 0 : return ((SgEnumFieldSymbol *)(*p_iterator).second);
13910 0 : p_iterator++;
13911 : }
13912 : }
13913 :
13914 0 : return NULL;
13915 : }
13916 :
13917 : SgLabelSymbol*
13918 0 : SgSymbolTable::next_label()
13919 : {
13920 0 : ROSE_ASSERT(p_table != NULL);
13921 0 : if (p_table != NULL)
13922 : {
13923 0 : p_iterator++;
13924 :
13925 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13926 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13927 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13928 : {
13929 0 : if (isSgLabelSymbol((*p_iterator).second))
13930 0 : return ((SgLabelSymbol *) (*p_iterator).second);
13931 0 : p_iterator++;
13932 : }
13933 : }
13934 :
13935 0 : return NULL;
13936 : }
13937 :
13938 : SgNamespaceSymbol*
13939 0 : SgSymbolTable::next_namespace()
13940 : {
13941 0 : ROSE_ASSERT(p_table != NULL);
13942 0 : if (p_table != NULL)
13943 : {
13944 0 : p_iterator++;
13945 :
13946 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13947 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13948 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13949 : {
13950 0 : if (isSgNamespaceSymbol((*p_iterator).second))
13951 0 : return ((SgNamespaceSymbol *) (*p_iterator).second);
13952 0 : p_iterator++;
13953 : }
13954 : }
13955 :
13956 0 : return NULL;
13957 : }
13958 :
13959 : SgTemplateSymbol*
13960 0 : SgSymbolTable::next_template()
13961 : {
13962 0 : ROSE_ASSERT(p_table != NULL);
13963 0 : if (p_table != NULL)
13964 : {
13965 0 : p_iterator++;
13966 :
13967 : // DQ (10/8/2007): Is there a use of find that would be O(log n) and be a faster way to return the next matching entry?
13968 : // while( p_iterator != p_table->end() && (p_no_name || (*p_iterator).first == p_name))
13969 0 : while (p_iterator != p_table->end() && (p_no_name || get_table()->key_eq()((*p_iterator).first,p_name)))
13970 : {
13971 0 : if (isSgTemplateSymbol((*p_iterator).second))
13972 0 : return ((SgTemplateSymbol *) (*p_iterator).second);
13973 0 : p_iterator++;
13974 : }
13975 : }
13976 :
13977 0 : return NULL;
13978 : }
13979 :
13980 :
13981 : #if 0
13982 : // DQ (11/27/2010): Removed deprecated function (depricated three years ago).
13983 : // DQ (1/30/2007): Added these back into ROSE.
13984 : SgSymbol*
13985 : SgSymbolTable::operator[](const SgName & nm)
13986 : {
13987 : ROSE_ASSERT(p_table != NULL);
13988 : if (p_table != NULL)
13989 : {
13990 : // AJ (10/21/2004): Adjusted implementation to use new STL hash map interface
13991 : // SgSymbolHashBase::iterator i=p_table->find(nm);
13992 : hash_iterator i=p_table->find(nm);
13993 : if (i != p_table->end())
13994 : return (*i).second;
13995 : }
13996 :
13997 : return NULL;
13998 : }
13999 : #endif
14000 :
14001 : // AJ (10/21/2004): Adjusted implementation to use new STL hash map interface
14002 : int
14003 2429090 : SgSymbolTable::size() const
14004 : {
14005 2429090 : ROSE_ASSERT(p_table != NULL);
14006 2429090 : return p_table->size();
14007 : }
14008 :
14009 : // AJ (10/21/2004): Adjusted implementation to use new STL hash map interface
14010 : int
14011 91948 : SgSymbolTable::count(const SgName & nm) const
14012 : {
14013 : // DQ (1/30/2007): assertion added
14014 91948 : ROSE_ASSERT(p_table != NULL);
14015 91948 : return p_table->count(nm);
14016 : }
14017 :
14018 : int
14019 157097 : SgSymbolTable::count_aliases(const SgName & nm) const
14020 : {
14021 157097 : ROSE_ASSERT(p_table != NULL);
14022 :
14023 : // This is the fastest way (that I know of) to iterate over just those entries that match the key.
14024 157097 : std::pair<hash_iterator,hash_iterator> range = p_table->equal_range(nm);
14025 :
14026 157097 : hash_iterator start = range.first;
14027 157097 : hash_iterator last = range.second;
14028 :
14029 157097 : int count = 0;
14030 157097 : hash_iterator i = start;
14031 246239 : while (i != last)
14032 : {
14033 : // Count only the alias symbols.
14034 89142 : if (isSgAliasSymbol((*i).second) != NULL)
14035 4140 : count++;
14036 :
14037 89142 : i++;
14038 : }
14039 :
14040 157097 : return count;
14041 : }
14042 :
14043 : void
14044 0 : SgSymbolTable::print() // Liao 5/5/2011. Added this to support calling this from gdb
14045 : {
14046 0 : print ("default settings", V_SgSymbol);
14047 0 : }
14048 :
14049 : void
14050 3 : SgSymbolTable::print( std::string label, VariantT nodeType )
14051 : {
14052 3 : printf ("Printing out the data within the symbol table (p_table = %p,label = %s size = %d): \n",p_table,label.c_str(),size());
14053 :
14054 3 : printf ("Internal static data: p_no_name: %s p_name = %s \n",(p_no_name == true) ? "true" : "false",p_name.str());
14055 :
14056 : // These are just static data used internally for some of the symbol lookup functions (symbol tables are not given names).
14057 : // printf ("SymbolTable has a name: %s \n",(p_no_name == true) ? "NO: it has no name" : "YES: it does have a name");
14058 : // if (p_no_name == false)
14059 : // printf ("SymbolTable name = %s \n",p_name.str());
14060 :
14061 : // DQ (2/16/2006): This is a SgScopeStatement except for the SgSymbolTable used in the global function type symbol table
14062 : // SgScopeStatement* parentNode = isSgScopeStatement(get_parent());
14063 3 : SgNode* parentNode = get_parent();
14064 3 : ROSE_ASSERT(parentNode != NULL);
14065 3 : printf ("Symbol table has parent = %p = %s \n",parentNode,parentNode->class_name().c_str());
14066 :
14067 : // DQ (6/23/2005): It is not a problem for the global function table to not have a name!
14068 : // else
14069 : // assert (p_name.str() == NULL);
14070 :
14071 3 : ROSE_ASSERT(p_table != NULL);
14072 3 : if (p_table != NULL)
14073 : {
14074 : // AJ (10/21/2004): Adjusted implementation to use new STL hash map interface
14075 : // SgSymbolHashBase::iterator i = p_table->begin();
14076 3 : hash_iterator i = p_table->begin();
14077 :
14078 3 : int idx = 0;
14079 5025 : while (i != p_table->end())
14080 : {
14081 : // DQ: removed SgName casting operator to char*
14082 : // cout << "[" << idx << "] " << (*i).first;
14083 : // cout << "[" << idx << "] " << (*i).first.str();
14084 5022 : ROSE_ASSERT ( isSgSymbol( (*i).second ) != NULL );
14085 :
14086 : // printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) sage_class_name() = %s \n",
14087 : // idx,(*i).first.str(),(*i).second->sage_class_name());
14088 :
14089 5022 : SgSymbol* symbol = isSgSymbol((*i).second);
14090 5022 : ROSE_ASSERT ( symbol != NULL );
14091 5022 : SgType* type = symbol->get_type();
14092 :
14093 : // DQ (5/7/2004): modified to allow for get_type() to return NULL
14094 : // ROSE_ASSERT ( type != NULL );
14095 :
14096 5022 : SgNamedType* namedType = isSgNamedType(type);
14097 10044 : SgName nameOfType;
14098 5022 : if (namedType != NULL)
14099 : {
14100 0 : nameOfType = namedType->get_name();
14101 : // char* nameString = namedType->get_name().str();
14102 : // printf ("Type is: (named type) = %s \n",nameString);
14103 : }
14104 : else
14105 : {
14106 : // DQ (5/7/2004): modified to allow for get_type() to return NULL
14107 5022 : if (type != NULL)
14108 : {
14109 : // printf ("Type is: type->sage_class_name() = %s \n",type->sage_class_name());
14110 5022 : nameOfType = type->sage_class_name();
14111 : }
14112 : else
14113 : {
14114 : // printf ("Type is: No type found in symbol (likely a possible error!) \n");
14115 0 : switch(symbol->variantT())
14116 : {
14117 0 : case V_SgNamespaceSymbol:
14118 0 : {
14119 : // This is a normal case where the type will be a null pointer!
14120 0 : nameOfType = "symbol's type is NULL (normal for SgNamespaceSymbol)";
14121 0 : break;
14122 : }
14123 :
14124 0 : case V_SgTemplateSymbol:
14125 0 : {
14126 : // This is a normal case where the type will be a null pointer!
14127 0 : nameOfType = "symbol's type is NULL (normal for SgTemplateSymbol)";
14128 0 : break;
14129 : }
14130 :
14131 0 : default:
14132 0 : {
14133 : // This is likely an error, I think
14134 0 : nameOfType = "unknown type name (likely a possible error!)";
14135 0 : break;
14136 : }
14137 : }
14138 : }
14139 : }
14140 :
14141 5022 : bool outputSymbolInfo = (nodeType == V_SgSymbol) || (symbol->variantT() == nodeType);
14142 :
14143 : // Output of symbol information
14144 5022 : SgNode* symbolBasis = i->second->get_symbol_basis();
14145 5022 : if (symbolBasis != NULL)
14146 : {
14147 0 : ROSE_ASSERT(symbolBasis != NULL);
14148 :
14149 0 : if (outputSymbolInfo == true)
14150 : {
14151 0 : SgAliasSymbol* aliasSymbol = isSgAliasSymbol((*i).second);
14152 0 : if (aliasSymbol != NULL)
14153 : {
14154 0 : ROSE_ASSERT(aliasSymbol->get_alias() != NULL);
14155 :
14156 0 : printf ("Symbol %4d: name = %s SgSymbol = %p = %s (alias to %s) type = %p = %s = %s get_symbol_basis() = %p = %s = %s \n",
14157 0 : idx,(*i).first.str(),(*i).second,(*i).second->class_name().c_str(),aliasSymbol->get_alias()->class_name().c_str(),type,(type != NULL) ? type->class_name().c_str() : "NULL" ,
14158 0 : nameOfType.str(),symbolBasis,symbolBasis->class_name().c_str(),SageInterface::get_name(symbolBasis).c_str());
14159 :
14160 : // DQ (12/24/2020): I want to add the details of the causal nodes.
14161 0 : printf (" --- alias node details: causal_nodes.size() = %zu \n",aliasSymbol->get_causal_nodes().size());
14162 0 : SgNodePtrList & causal_nodes_list = aliasSymbol->get_causal_nodes();
14163 0 : SgNodePtrList::iterator j = causal_nodes_list.begin();
14164 0 : while (j != causal_nodes_list.end())
14165 : {
14166 0 : SgNode* causal_node = *j;
14167 0 : ROSE_ASSERT(causal_node != NULL);
14168 0 : printf (" --- causal node = %p = %s \n",causal_node,causal_node->class_name().c_str());
14169 0 : SgBaseClass* baseClass = isSgBaseClass(causal_node);
14170 0 : if (baseClass != NULL)
14171 : {
14172 0 : SgClassDeclaration* baseClassDeclaration = baseClass->get_base_class();
14173 0 : ROSE_ASSERT(baseClassDeclaration != NULL);
14174 0 : printf (" --- --- baseClass = %p baseClassDeclaration = %p name = %s \n",baseClass,baseClassDeclaration,baseClassDeclaration->get_name().str());
14175 : }
14176 0 : j++;
14177 : }
14178 : }
14179 : else
14180 : {
14181 0 : printf ("Symbol %4d: name = %s SgSymbol = %p = %s type = %p = %s = %s get_symbol_basis() = %p = %s = %s \n",
14182 0 : idx,(*i).first.str(),(*i).second,(*i).second->class_name().c_str(),type,(type != NULL) ? type->class_name().c_str() : "NULL" ,
14183 0 : nameOfType.str(),symbolBasis,symbolBasis->class_name().c_str(),SageInterface::get_name(symbolBasis).c_str());
14184 : }
14185 : }
14186 : }
14187 : else
14188 : {
14189 5022 : if (outputSymbolInfo == true)
14190 : {
14191 15066 : printf ("Warning Symbol %4d: name = %s SgSymbol = %p = %s type = %p = %s = %s get_symbol_basis() = NULL \n",
14192 15066 : idx,(*i).first.str(),(*i).second,(*i).second->class_name().c_str(),type,(type != NULL) ? type->class_name().c_str() : "NULL" ,
14193 : nameOfType.str());
14194 : }
14195 : }
14196 :
14197 : // DQ (12/3/2011): Refactored code.
14198 5022 : SgSymbol* symbolFromTable = (*i).second;
14199 5022 : SgName mangledName = symbolFromTable->get_mangled_name();
14200 :
14201 5022 : if (outputSymbolInfo == true)
14202 : {
14203 5022 : printf (" Symbol's associated mangled name = %s \n",mangledName.str());
14204 :
14205 : // This is useful for the output of the function types when the global function type symbol table is output.
14206 : // handle case of function symbol (unparse the funtion type)
14207 5022 : SgFunctionTypeSymbol *f = isSgFunctionTypeSymbol((*i).second);
14208 5022 : if (f != NULL)
14209 : {
14210 : #if 1
14211 : // f->get_type()->unparse(); cout << endl;
14212 14735 : std::cout << " function: " << f->get_type()->unparseToString() << endl;
14213 : #else
14214 : // printf ("ERROR: unparse function for symbol type not implemented in SAGE3! \n");
14215 : // ROSE_ABORT();
14216 : #endif
14217 : }
14218 : }
14219 :
14220 : // Increment the symbol table's symbol iterator
14221 5022 : i++;
14222 :
14223 : // Increment the symbol counter (used for output)
14224 5022 : idx++;
14225 : }
14226 : }
14227 : else
14228 : {
14229 : // DQ (6/27/2005): I think this is an error (we should always have a valid symbol table)
14230 : printf ("Pointer to symbol table is NULL \n");
14231 : ROSE_ASSERT(false);
14232 : }
14233 3 : }
14234 :
14235 :
14236 : set<SgNode*>
14237 2 : SgSymbolTable::get_symbols() const
14238 : {
14239 : // DQ (2/15/2007): generate a set of SgNode* so that we can use them for set difference against the delete list in AST merge.
14240 2 : set<SgNode*> returnSet;
14241 :
14242 2 : ROSE_ASSERT(p_table != NULL);
14243 : // CH (4/8/2010): Use boost::unordered instead
14244 : //#ifdef _MSCx_VER
14245 : // rose_hash::unordered_multimap<SgName, SgSymbol*>::iterator i = get_table()->begin();
14246 : //#else
14247 2 : rose_hash_multimap::iterator i = get_table()->begin();
14248 : //#endif
14249 5 : while (i != p_table->end())
14250 : {
14251 3 : ROSE_ASSERT(i->second != NULL);
14252 3 : returnSet.insert(i->second);
14253 :
14254 3 : i++;
14255 : }
14256 :
14257 2 : return returnSet;
14258 : }
14259 :
14260 :
14261 : size_t
14262 0 : SgSymbolTable::maxCollisions()
14263 : {
14264 0 : ROSE_ASSERT(p_table != NULL);
14265 :
14266 0 : unsigned nbuckets = p_table->bucket_count();
14267 0 : size_t maxColl = 0;
14268 0 : for (unsigned i = 0; i < nbuckets; ++i)
14269 : {
14270 0 : if(p_table->bucket_size(i)>maxColl)
14271 : maxColl = p_table->bucket_size(i);
14272 : }
14273 :
14274 0 : return maxColl;
14275 : }
14276 :
14277 : // DQ (3/30/2014): Declaration of space for static data member.
14278 : bool SgSymbolTable::p_force_search_of_base_classes = false;
14279 :
14280 : // DQ (7/12/2014): Declaration of space for static data member.
14281 : SgNodeSet SgSymbolTable::p_aliasSymbolCausalNodeSet;
14282 :
14283 : bool
14284 3405440 : SgSymbolTable::get_force_search_of_base_classes()
14285 : {
14286 3405440 : return p_force_search_of_base_classes;
14287 : }
14288 :
14289 : void
14290 0 : SgSymbolTable::set_force_search_of_base_classes( bool value )
14291 : {
14292 0 : p_force_search_of_base_classes = value;
14293 0 : }
14294 :
14295 : // DQ (7/12/2014): Access function for static data member.
14296 : SgNodeSet &
14297 687538 : SgSymbolTable::get_aliasSymbolCausalNodeSet()
14298 : {
14299 687538 : return p_aliasSymbolCausalNodeSet;
14300 : }
14301 :
14302 :
14303 : // DQ (8/3/2019): Display function for static data member.
14304 : void
14305 0 : SgSymbolTable::display_aliasSymbolCausalNodeSet()
14306 : {
14307 0 : SgNodeSet::iterator i = p_aliasSymbolCausalNodeSet.begin();
14308 0 : while (i != p_aliasSymbolCausalNodeSet.end())
14309 : {
14310 0 : printf ("SgSymbolTable::p_aliasSymbolCausalNodeSet: *i = %p = %s \n",*i,(*i)->class_name().c_str());
14311 :
14312 0 : i++;
14313 : }
14314 0 : }
14315 :
14316 :
14317 :
14318 :
14319 :
14320 :
14321 : // End of memberFunctionString
14322 : // Start of memberFunctionString
14323 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
14324 :
14325 : // *** COMMON CODE SECTION BEGINS HERE ***
14326 :
14327 : #if 0
14328 : int
14329 : SgSymbolTable::getVariant() const
14330 : {
14331 : // This function is used in ROSE while "variant()" is used in SAGE
14332 : assert(this != NULL);
14333 : return variant();
14334 : }
14335 : #endif
14336 :
14337 : // This function is used in ROSE in treeTraversal code
14338 : // eventually replaces getVariant() and variant()
14339 : // though after variant() has been removed for a while we will
14340 : // want to change the name of variantT() back to variant()
14341 : // (since the "T" was ment to stand for temporary).
14342 : // When this happens the variantT() will be depricated.
14343 : VariantT
14344 12304200 : SgSymbolTable::variantT() const
14345 : {
14346 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
14347 12304200 : ROSE_ASSERT(this != NULL);
14348 12304200 : return V_SgSymbolTable;
14349 : }
14350 :
14351 : #if 0
14352 : int
14353 : SgSymbolTable::variant() const
14354 : {
14355 : // This function is used in SAGE
14356 : ROSE_ASSERT(this != NULL);
14357 : return SymbolTableTag;
14358 : }
14359 : #endif
14360 :
14361 : ROSE_DLL_API const char*
14362 0 : SgSymbolTable::sage_class_name() const
14363 : {
14364 0 : ROSE_ASSERT(this != NULL);
14365 0 : return "SgSymbolTable";
14366 : }
14367 :
14368 : std::string
14369 200976 : SgSymbolTable::class_name() const
14370 : {
14371 200976 : ROSE_ASSERT(this != NULL);
14372 200976 : return "SgSymbolTable";
14373 : }
14374 :
14375 : // DQ (11/26/2005): Support for visitor pattern mechanims
14376 : // (inferior to ROSE traversal mechanism, experimental).
14377 : void
14378 3750340 : SgSymbolTable::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
14379 : {
14380 3750340 : ROSE_ASSERT(this != NULL);
14381 3750340 : visitor.visit(this);
14382 3750340 : }
14383 :
14384 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
14385 0 : void SgSymbolTable::accept (ROSE_VisitorPattern & visitor) {
14386 0 : ROSE_ASSERT(this != NULL);
14387 0 : visitor.visit(this);
14388 0 : }
14389 :
14390 : SgSymbolTable*
14391 0 : SgSymbolTable::addRegExpAttribute(std::string s, AstRegExAttribute* a)
14392 : {
14393 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
14394 : // This function is currently only supported for the AST used the represent Binary executables.
14395 : if (0 /* isSgAsmNode(this) != NULL */)
14396 : {
14397 : // Support for regex specification.
14398 : std::string prefixCode = "REGEX:";
14399 : addNewAttribute(prefixCode + s,a);
14400 : }
14401 : #endif
14402 :
14403 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
14404 0 : return this;
14405 : }
14406 :
14407 : // *** COMMON CODE SECTION ENDS HERE ***
14408 :
14409 :
14410 : // End of memberFunctionString
14411 : // Start of memberFunctionString
14412 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
14413 :
14414 :
14415 : #if 0
14416 : //! Error checking support
14417 : /*! Verifies the following:
14418 : - working getVariant() member function
14419 : - calls base class's error() member function
14420 : Every class has one of these functions.
14421 : */
14422 : bool
14423 : SgSymbolTable::error()
14424 : {
14425 : // Put error checking here
14426 :
14427 : ROSE_ASSERT (this != NULL);
14428 : if (getVariant() != SymbolTableTag)
14429 : {
14430 : printf ("Error in SgSymbolTable::error(): SgSymbolTable object has a %s variant \n",
14431 : Cxx_GrammarTerminalNames[getVariant()].name);
14432 : // printf ("Error in SgSymbolTable::error() \n");
14433 : ROSE_ABORT();
14434 : }
14435 :
14436 : ROSE_ASSERT (getVariant() == SymbolTableTag);
14437 : return SgSupport::error();
14438 : }
14439 : #endif
14440 :
14441 :
14442 :
14443 : // End of memberFunctionString
14444 :
14445 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
14446 :
14447 219 : SgSymbolTable* isSgSymbolTable ( SgNode* inputDerivedClassPointer )
14448 : {
14449 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
14450 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
14451 : // So to fix this we return NULL directly when the input is NULL and avoid the
14452 : // dynamic_cast in this case. This is likely a performance improvement as well.
14453 : // return dynamic_cast<SgSymbolTable*>(inputDerivedClassPointer);
14454 : // Milind Chabbi (8/28/2013): isSgSymbolTable uses table-driven castability instead of c++ default dynamic_cast
14455 : // this improves the running time performance by 10-20%.
14456 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSymbolTable*>(inputDerivedClassPointer);
14457 219 : return IS_SgSymbolTable_FAST_MACRO(inputDerivedClassPointer);
14458 : }
14459 :
14460 : // DQ (11/8/2003): Added version of functions taking const pointer
14461 18 : const SgSymbolTable* isSgSymbolTable ( const SgNode* inputDerivedClassPointer )
14462 : {
14463 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
14464 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
14465 : // So to fix this we return NULL directly when the input is NULL and avoid the
14466 : // dynamic_cast in this case. This is likely a performance improvement as well.
14467 : // return dynamic_cast<const SgSymbolTable*>(inputDerivedClassPointer);
14468 : // Milind Chabbi (8/28/2013): isSgSymbolTable uses table-driven castability instead of c++ default dynamic_cast
14469 : // this improves the running time performance by 10-20%.
14470 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSymbolTable*>(inputDerivedClassPointer);
14471 18 : return IS_SgSymbolTable_FAST_MACRO(inputDerivedClassPointer);
14472 : }
14473 :
14474 :
14475 :
14476 : /* #line 14477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14477 :
14478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
14479 :
14480 : /**
14481 : \brief Generated destructor
14482 :
14483 : This destructor is automatically generated (by ROSETTA). This destructor
14484 : only frees memory of data members associated with the parts of the current IR node which
14485 : are NOT traversed. Those data members that are part of a traversal can be freed using
14486 : a traversal (calling this destructor on all children in a post-order traversal). Such
14487 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
14488 :
14489 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
14490 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
14491 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
14492 :
14493 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
14494 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
14495 : pointers are not yet implemented to call delete on eash pointer in the container.
14496 : (This could be done by derivation from the STL containers to define containers that
14497 : automatically deleted their members.)
14498 :
14499 : */
14500 108916 : SgSymbolTable::~SgSymbolTable () {
14501 54458 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
14502 :
14503 108916 : if (p_table) { delete p_table; }
14504 :
14505 : // case: not a listType for name
14506 54458 : p_name = ""; // non list case
14507 : // case: not a listType for no_name
14508 54458 : p_no_name = false; // non list case
14509 : // case: not a listType for table
14510 54458 : p_table = NULL; // non list case
14511 : // case: not a listType for case_insensitive
14512 54458 : p_case_insensitive = false; // non list case
14513 :
14514 : }
14515 :
14516 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
14517 108916 : }
14518 :
14519 :
14520 : /* #line 14521 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14521 :
14522 :
14523 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
14524 :
14525 :
14526 : // ********************************************************
14527 : // member functions common across all array grammar objects
14528 : // ********************************************************
14529 :
14530 :
14531 :
14532 : /* #line 14533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14533 :
14534 :
14535 :
14536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
14537 :
14538 : // ********************************************************
14539 : // member functions specific to each node in the grammar
14540 : // ********************************************************
14541 :
14542 :
14543 : /* #line 14544 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14544 :
14545 : // Start of memberFunctionString
14546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
14547 :
14548 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
14549 :
14550 : std::string
14551 3014 : SgAttribute::get_name () const
14552 : {
14553 3014 : ROSE_ASSERT (this != NULL);
14554 :
14555 : #if 0
14556 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14557 : // used to trigger marking transformations for the token-based unparsing.
14558 : printf ("SgAttribute::get_name = %p = %s \n",this,this->class_name().c_str());
14559 : #endif
14560 :
14561 3014 : return p_name;
14562 : }
14563 :
14564 : void
14565 0 : SgAttribute::set_name ( std::string name )
14566 : {
14567 0 : ROSE_ASSERT (this != NULL);
14568 :
14569 : #if 0
14570 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14571 : // used to trigger marking transformations for the token-based unparsing.
14572 : printf ("SgAttribute::set_name = %p = %s \n",this,this->class_name().c_str());
14573 : #endif
14574 :
14575 0 : set_isModified(true);
14576 :
14577 0 : p_name = name;
14578 0 : }
14579 :
14580 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
14581 :
14582 :
14583 : // End of memberFunctionString
14584 : // Start of memberFunctionString
14585 : /* #line 13649 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
14586 :
14587 :
14588 : int
14589 0 : SgAttribute::isSame(const std::string& str)
14590 : {
14591 0 : return p_name == str;
14592 : }
14593 :
14594 :
14595 :
14596 : // End of memberFunctionString
14597 : // Start of memberFunctionString
14598 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
14599 :
14600 : // *** COMMON CODE SECTION BEGINS HERE ***
14601 :
14602 : #if 0
14603 : int
14604 : SgAttribute::getVariant() const
14605 : {
14606 : // This function is used in ROSE while "variant()" is used in SAGE
14607 : assert(this != NULL);
14608 : return variant();
14609 : }
14610 : #endif
14611 :
14612 : // This function is used in ROSE in treeTraversal code
14613 : // eventually replaces getVariant() and variant()
14614 : // though after variant() has been removed for a while we will
14615 : // want to change the name of variantT() back to variant()
14616 : // (since the "T" was ment to stand for temporary).
14617 : // When this happens the variantT() will be depricated.
14618 : VariantT
14619 5487 : SgAttribute::variantT() const
14620 : {
14621 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
14622 5487 : ROSE_ASSERT(this != NULL);
14623 5487 : return V_SgAttribute;
14624 : }
14625 :
14626 : #if 0
14627 : int
14628 : SgAttribute::variant() const
14629 : {
14630 : // This function is used in SAGE
14631 : ROSE_ASSERT(this != NULL);
14632 : return AttributeTag;
14633 : }
14634 : #endif
14635 :
14636 : ROSE_DLL_API const char*
14637 0 : SgAttribute::sage_class_name() const
14638 : {
14639 0 : ROSE_ASSERT(this != NULL);
14640 0 : return "SgAttribute";
14641 : }
14642 :
14643 : std::string
14644 0 : SgAttribute::class_name() const
14645 : {
14646 0 : ROSE_ASSERT(this != NULL);
14647 0 : return "SgAttribute";
14648 : }
14649 :
14650 : // DQ (11/26/2005): Support for visitor pattern mechanims
14651 : // (inferior to ROSE traversal mechanism, experimental).
14652 : void
14653 0 : SgAttribute::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
14654 : {
14655 0 : ROSE_ASSERT(this != NULL);
14656 0 : visitor.visit(this);
14657 0 : }
14658 :
14659 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
14660 0 : void SgAttribute::accept (ROSE_VisitorPattern & visitor) {
14661 0 : ROSE_ASSERT(this != NULL);
14662 0 : visitor.visit(this);
14663 0 : }
14664 :
14665 : SgAttribute*
14666 0 : SgAttribute::addRegExpAttribute(std::string s, AstRegExAttribute* a)
14667 : {
14668 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
14669 : // This function is currently only supported for the AST used the represent Binary executables.
14670 : if (0 /* isSgAsmNode(this) != NULL */)
14671 : {
14672 : // Support for regex specification.
14673 : std::string prefixCode = "REGEX:";
14674 : addNewAttribute(prefixCode + s,a);
14675 : }
14676 : #endif
14677 :
14678 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
14679 0 : return this;
14680 : }
14681 :
14682 : // *** COMMON CODE SECTION ENDS HERE ***
14683 :
14684 :
14685 : // End of memberFunctionString
14686 : // Start of memberFunctionString
14687 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
14688 :
14689 :
14690 : #if 0
14691 : //! Error checking support
14692 : /*! Verifies the following:
14693 : - working getVariant() member function
14694 : - calls base class's error() member function
14695 : Every class has one of these functions.
14696 : */
14697 : bool
14698 : SgAttribute::error()
14699 : {
14700 : // Put error checking here
14701 :
14702 : ROSE_ASSERT (this != NULL);
14703 : if (getVariant() != AttributeTag)
14704 : {
14705 : printf ("Error in SgAttribute::error(): SgAttribute object has a %s variant \n",
14706 : Cxx_GrammarTerminalNames[getVariant()].name);
14707 : // printf ("Error in SgAttribute::error() \n");
14708 : ROSE_ABORT();
14709 : }
14710 :
14711 : ROSE_ASSERT (getVariant() == AttributeTag);
14712 : return SgSupport::error();
14713 : }
14714 : #endif
14715 :
14716 :
14717 :
14718 : // End of memberFunctionString
14719 :
14720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
14721 :
14722 1829 : SgAttribute* isSgAttribute ( SgNode* inputDerivedClassPointer )
14723 : {
14724 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
14725 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
14726 : // So to fix this we return NULL directly when the input is NULL and avoid the
14727 : // dynamic_cast in this case. This is likely a performance improvement as well.
14728 : // return dynamic_cast<SgAttribute*>(inputDerivedClassPointer);
14729 : // Milind Chabbi (8/28/2013): isSgAttribute uses table-driven castability instead of c++ default dynamic_cast
14730 : // this improves the running time performance by 10-20%.
14731 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAttribute*>(inputDerivedClassPointer);
14732 1829 : return IS_SgAttribute_FAST_MACRO(inputDerivedClassPointer);
14733 : }
14734 :
14735 : // DQ (11/8/2003): Added version of functions taking const pointer
14736 0 : const SgAttribute* isSgAttribute ( const SgNode* inputDerivedClassPointer )
14737 : {
14738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
14739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
14740 : // So to fix this we return NULL directly when the input is NULL and avoid the
14741 : // dynamic_cast in this case. This is likely a performance improvement as well.
14742 : // return dynamic_cast<const SgAttribute*>(inputDerivedClassPointer);
14743 : // Milind Chabbi (8/28/2013): isSgAttribute uses table-driven castability instead of c++ default dynamic_cast
14744 : // this improves the running time performance by 10-20%.
14745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAttribute*>(inputDerivedClassPointer);
14746 0 : return IS_SgAttribute_FAST_MACRO(inputDerivedClassPointer);
14747 : }
14748 :
14749 :
14750 :
14751 : /* #line 14752 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14752 :
14753 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
14754 :
14755 : /**
14756 : \brief Generated destructor
14757 :
14758 : This destructor is automatically generated (by ROSETTA). This destructor
14759 : only frees memory of data members associated with the parts of the current IR node which
14760 : are NOT traversed. Those data members that are part of a traversal can be freed using
14761 : a traversal (calling this destructor on all children in a post-order traversal). Such
14762 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
14763 :
14764 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
14765 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
14766 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
14767 :
14768 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
14769 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
14770 : pointers are not yet implemented to call delete on eash pointer in the container.
14771 : (This could be done by derivation from the STL containers to define containers that
14772 : automatically deleted their members.)
14773 :
14774 : */
14775 194 : SgAttribute::~SgAttribute () {
14776 194 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
14777 :
14778 :
14779 : // case: not a listType for name
14780 194 : p_name = ""; // non list case
14781 :
14782 : }
14783 :
14784 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
14785 194 : }
14786 :
14787 :
14788 : /* #line 14789 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14789 :
14790 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
14791 :
14792 : // Generated constructor
14793 1829 : SgAttribute::SgAttribute ( std::string name )
14794 1829 : : SgSupport()
14795 : {
14796 : #ifdef DEBUG
14797 : // printf ("In SgAttribute::SgAttribute (std::string name) sage_class_name() = %s \n",sage_class_name());
14798 : #endif
14799 : #if 0
14800 : // debugging information!
14801 : printf ("In SgAttribute::SgAttribute (std::string name): this = %p = %s \n",this,this->class_name().c_str());
14802 : #endif
14803 :
14804 1829 : p_name = name;
14805 :
14806 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
14807 :
14808 : #if 0
14809 : // DQ (7/30/2014): Call a virtual function.
14810 : std::string s = this->class_name();
14811 : #endif
14812 :
14813 : // Test the variant virtual function
14814 : // assert(AttributeTag == variant());
14815 1829 : assert(AttributeTag == this->variant());
14816 1829 : ROSE_ASSERT(AttributeTag == (int)(this->variantT()));
14817 1829 : post_construction_initialization();
14818 :
14819 : // Test the isSgAttribute() function since it has been problematic
14820 1829 : assert(isSgAttribute(this) != NULL);
14821 1829 : }
14822 :
14823 : // Generated constructor (all data members)
14824 :
14825 : /* #line 14826 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14826 :
14827 :
14828 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
14829 :
14830 :
14831 : // ********************************************************
14832 : // member functions common across all array grammar objects
14833 : // ********************************************************
14834 :
14835 :
14836 :
14837 : /* #line 14838 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14838 :
14839 :
14840 :
14841 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
14842 :
14843 : // ********************************************************
14844 : // member functions specific to each node in the grammar
14845 : // ********************************************************
14846 :
14847 :
14848 : /* #line 14849 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
14849 :
14850 : // Start of memberFunctionString
14851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
14852 :
14853 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
14854 :
14855 : Sg_File_Info*
14856 12342 : SgPragma::get_startOfConstruct () const
14857 : {
14858 12342 : ROSE_ASSERT (this != NULL);
14859 :
14860 : #if 0
14861 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14862 : // used to trigger marking transformations for the token-based unparsing.
14863 : printf ("SgPragma::get_startOfConstruct = %p = %s \n",this,this->class_name().c_str());
14864 : #endif
14865 :
14866 12342 : return p_startOfConstruct;
14867 : }
14868 :
14869 : void
14870 1829 : SgPragma::set_startOfConstruct ( Sg_File_Info* startOfConstruct )
14871 : {
14872 1829 : ROSE_ASSERT (this != NULL);
14873 :
14874 : #if 0
14875 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14876 : // used to trigger marking transformations for the token-based unparsing.
14877 : printf ("SgPragma::set_startOfConstruct = %p = %s \n",this,this->class_name().c_str());
14878 : #endif
14879 :
14880 1829 : set_isModified(true);
14881 :
14882 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
14883 : if (p_startOfConstruct != NULL && startOfConstruct != NULL && p_startOfConstruct != startOfConstruct)
14884 : {
14885 : printf ("Warning: startOfConstruct = %p overwriting valid pointer p_startOfConstruct = %p \n",startOfConstruct,p_startOfConstruct);
14886 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
14887 : printf ("Error fails assertion (p_startOfConstruct != NULL && startOfConstruct != NULL && p_startOfConstruct != startOfConstruct) is false\n");
14888 : ROSE_ASSERT(false);
14889 : #endif
14890 : }
14891 : #endif
14892 1829 : p_startOfConstruct = startOfConstruct;
14893 1829 : }
14894 :
14895 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
14896 :
14897 :
14898 : // End of memberFunctionString
14899 : // Start of memberFunctionString
14900 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
14901 :
14902 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
14903 :
14904 : Sg_File_Info*
14905 14054 : SgPragma::get_endOfConstruct () const
14906 : {
14907 14054 : ROSE_ASSERT (this != NULL);
14908 :
14909 : #if 0
14910 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14911 : // used to trigger marking transformations for the token-based unparsing.
14912 : printf ("SgPragma::get_endOfConstruct = %p = %s \n",this,this->class_name().c_str());
14913 : #endif
14914 :
14915 14054 : return p_endOfConstruct;
14916 : }
14917 :
14918 : void
14919 1828 : SgPragma::set_endOfConstruct ( Sg_File_Info* endOfConstruct )
14920 : {
14921 1828 : ROSE_ASSERT (this != NULL);
14922 :
14923 : #if 0
14924 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14925 : // used to trigger marking transformations for the token-based unparsing.
14926 : printf ("SgPragma::set_endOfConstruct = %p = %s \n",this,this->class_name().c_str());
14927 : #endif
14928 :
14929 1828 : set_isModified(true);
14930 :
14931 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
14932 : if (p_endOfConstruct != NULL && endOfConstruct != NULL && p_endOfConstruct != endOfConstruct)
14933 : {
14934 : printf ("Warning: endOfConstruct = %p overwriting valid pointer p_endOfConstruct = %p \n",endOfConstruct,p_endOfConstruct);
14935 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
14936 : printf ("Error fails assertion (p_endOfConstruct != NULL && endOfConstruct != NULL && p_endOfConstruct != endOfConstruct) is false\n");
14937 : ROSE_ASSERT(false);
14938 : #endif
14939 : }
14940 : #endif
14941 1828 : p_endOfConstruct = endOfConstruct;
14942 1828 : }
14943 :
14944 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
14945 :
14946 :
14947 : // End of memberFunctionString
14948 : // Start of memberFunctionString
14949 :
14950 :
14951 : // End of memberFunctionString
14952 : // Start of memberFunctionString
14953 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
14954 :
14955 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
14956 :
14957 : SgExprListExp*
14958 0 : SgPragma::get_args () const
14959 : {
14960 0 : ROSE_ASSERT (this != NULL);
14961 :
14962 : #if 0
14963 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14964 : // used to trigger marking transformations for the token-based unparsing.
14965 : printf ("SgPragma::get_args = %p = %s \n",this,this->class_name().c_str());
14966 : #endif
14967 :
14968 0 : return p_args;
14969 : }
14970 :
14971 : void
14972 0 : SgPragma::set_args ( SgExprListExp* args )
14973 : {
14974 0 : ROSE_ASSERT (this != NULL);
14975 :
14976 : #if 0
14977 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
14978 : // used to trigger marking transformations for the token-based unparsing.
14979 : printf ("SgPragma::set_args = %p = %s \n",this,this->class_name().c_str());
14980 : #endif
14981 :
14982 0 : set_isModified(true);
14983 :
14984 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
14985 : if (p_args != NULL && args != NULL && p_args != args)
14986 : {
14987 : printf ("Warning: args = %p overwriting valid pointer p_args = %p \n",args,p_args);
14988 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
14989 : printf ("Error fails assertion (p_args != NULL && args != NULL && p_args != args) is false\n");
14990 : ROSE_ASSERT(false);
14991 : #endif
14992 : }
14993 : #endif
14994 0 : p_args = args;
14995 0 : }
14996 :
14997 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
14998 :
14999 :
15000 : // End of memberFunctionString
15001 : // Start of memberFunctionString
15002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
15003 :
15004 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
15005 :
15006 : AstAttributeMechanism*
15007 5 : SgPragma::get_attributeMechanism () const
15008 : {
15009 5 : ROSE_ASSERT (this != NULL);
15010 5 : return p_attributeMechanism;
15011 : }
15012 :
15013 : void
15014 0 : SgPragma::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
15015 : {
15016 0 : ROSE_ASSERT (this != NULL);
15017 :
15018 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
15019 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
15020 : {
15021 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
15022 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
15023 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
15024 : ROSE_ASSERT(false);
15025 : #endif
15026 : }
15027 : #endif
15028 0 : p_attributeMechanism = attributeMechanism;
15029 0 : }
15030 :
15031 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
15032 :
15033 :
15034 : // End of memberFunctionString
15035 : // Start of memberFunctionString
15036 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
15037 :
15038 :
15039 : #if 0
15040 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
15041 : // a pointer and the interface represented directly at the SgNode
15042 : AstAttributeMechanism &
15043 : SgPragma::attribute()
15044 : {
15045 : // DQ (1/2/2006): This function preserves as much of
15046 : // the syntax of attribute being a public data member.
15047 : if (p_attribute == NULL)
15048 : {
15049 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
15050 : assert(false);
15051 : }
15052 :
15053 : return *p_attribute;
15054 : }
15055 : #endif
15056 :
15057 : void
15058 0 : SgPragma::addNewAttribute( std::string s, AstAttribute* a )
15059 : {
15060 0 : if (get_attributeMechanism() == NULL)
15061 : {
15062 0 : set_attributeMechanism( new AstAttributeMechanism() );
15063 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
15064 : }
15065 0 : get_attributeMechanism()->add(s,a);
15066 0 : }
15067 :
15068 : void
15069 0 : SgPragma::setAttribute( std::string s, AstAttribute* a )
15070 : {
15071 0 : if (get_attributeMechanism() == NULL)
15072 : {
15073 0 : set_attributeMechanism( new AstAttributeMechanism() );
15074 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
15075 : }
15076 0 : get_attributeMechanism()->set(s,a);
15077 0 : }
15078 :
15079 : AstAttribute*
15080 0 : SgPragma::getAttribute(std::string s) const
15081 : {
15082 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
15083 0 : if (attributeExists(s)==false) return NULL;
15084 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
15085 0 : ROSE_ASSERT(returnValue != NULL);
15086 0 : return returnValue;
15087 : }
15088 :
15089 : void
15090 0 : SgPragma::updateAttribute( std::string s, AstAttribute* a )
15091 : {
15092 : // formerly called: replace
15093 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
15094 0 : get_attributeMechanism()->replace(s,a);
15095 0 : }
15096 :
15097 : void
15098 0 : SgPragma::removeAttribute(std::string s)
15099 : {
15100 0 : if (get_attributeMechanism())
15101 0 : get_attributeMechanism()->remove(s);
15102 :
15103 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
15104 0 : int remainingCount = numberOfAttributes();
15105 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
15106 0 : if (remainingCount == 0)
15107 : {
15108 0 : delete get_attributeMechanism();
15109 0 : set_attributeMechanism(NULL);
15110 : }
15111 0 : }
15112 :
15113 : bool
15114 0 : SgPragma::attributeExists(std::string s) const
15115 : {
15116 0 : bool returnValue = false;
15117 0 : if (get_attributeMechanism() != NULL)
15118 0 : returnValue = get_attributeMechanism()->exists(s);
15119 0 : return returnValue;
15120 : }
15121 :
15122 : int
15123 0 : SgPragma::numberOfAttributes() const
15124 : {
15125 0 : int returnValue = 0;
15126 0 : if (get_attributeMechanism() != NULL)
15127 0 : returnValue = get_attributeMechanism()->size();
15128 0 : return returnValue;
15129 : }
15130 :
15131 :
15132 :
15133 : // End of memberFunctionString
15134 : // Start of memberFunctionString
15135 : /* #line 13675 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
15136 :
15137 :
15138 : std::string
15139 3014 : SgPragma::get_pragma() const
15140 3014 : { return get_name(); }
15141 :
15142 : bool
15143 0 : SgPragma::samePragma(const std::string& str)
15144 0 : { return get_name() == str; }
15145 :
15146 : bool
15147 0 : SgPragma::isPragma() const
15148 0 : { return 1; }
15149 :
15150 : bool
15151 0 : SgPragma::gotPrinted() const
15152 0 : { return p_printed; }
15153 :
15154 : void
15155 0 : SgPragma::setPrinted(bool s)
15156 0 : { p_printed=s; }
15157 :
15158 : void
15159 1829 : SgPragma::post_construction_initialization()
15160 : {
15161 : // JJW 10-26-2007 ensure that this object is not on the stack
15162 1829 : preventConstructionOnStack(this);
15163 :
15164 1829 : p_printed = false;
15165 1829 : }
15166 :
15167 : // DQ (11/6/2006): This is not generated due to the name change of "file_info" to "startOfConstruct" (uncommented)
15168 : // DQ (1/18/2006): This is not generated due to the name change of "fileInfo" to "file_info"
15169 : Sg_File_Info*
15170 19090 : SgPragma::get_file_info() const
15171 : {
15172 : // return p_fileInfo;
15173 19090 : return p_startOfConstruct;
15174 : }
15175 :
15176 :
15177 :
15178 : // End of memberFunctionString
15179 : // Start of memberFunctionString
15180 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
15181 :
15182 : // *** COMMON CODE SECTION BEGINS HERE ***
15183 :
15184 : #if 0
15185 : int
15186 : SgPragma::getVariant() const
15187 : {
15188 : // This function is used in ROSE while "variant()" is used in SAGE
15189 : assert(this != NULL);
15190 : return variant();
15191 : }
15192 : #endif
15193 :
15194 : // This function is used in ROSE in treeTraversal code
15195 : // eventually replaces getVariant() and variant()
15196 : // though after variant() has been removed for a while we will
15197 : // want to change the name of variantT() back to variant()
15198 : // (since the "T" was ment to stand for temporary).
15199 : // When this happens the variantT() will be depricated.
15200 : VariantT
15201 278743 : SgPragma::variantT() const
15202 : {
15203 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
15204 278743 : ROSE_ASSERT(this != NULL);
15205 278743 : return V_SgPragma;
15206 : }
15207 :
15208 : #if 0
15209 : int
15210 : SgPragma::variant() const
15211 : {
15212 : // This function is used in SAGE
15213 : ROSE_ASSERT(this != NULL);
15214 : return PragmaTag;
15215 : }
15216 : #endif
15217 :
15218 : ROSE_DLL_API const char*
15219 10 : SgPragma::sage_class_name() const
15220 : {
15221 10 : ROSE_ASSERT(this != NULL);
15222 10 : return "SgPragma";
15223 : }
15224 :
15225 : std::string
15226 1588 : SgPragma::class_name() const
15227 : {
15228 1588 : ROSE_ASSERT(this != NULL);
15229 1588 : return "SgPragma";
15230 : }
15231 :
15232 : // DQ (11/26/2005): Support for visitor pattern mechanims
15233 : // (inferior to ROSE traversal mechanism, experimental).
15234 : void
15235 13512 : SgPragma::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
15236 : {
15237 13512 : ROSE_ASSERT(this != NULL);
15238 13512 : visitor.visit(this);
15239 13512 : }
15240 :
15241 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
15242 0 : void SgPragma::accept (ROSE_VisitorPattern & visitor) {
15243 0 : ROSE_ASSERT(this != NULL);
15244 0 : visitor.visit(this);
15245 0 : }
15246 :
15247 : SgPragma*
15248 0 : SgPragma::addRegExpAttribute(std::string s, AstRegExAttribute* a)
15249 : {
15250 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
15251 : // This function is currently only supported for the AST used the represent Binary executables.
15252 : if (0 /* isSgAsmNode(this) != NULL */)
15253 : {
15254 : // Support for regex specification.
15255 : std::string prefixCode = "REGEX:";
15256 : addNewAttribute(prefixCode + s,a);
15257 : }
15258 : #endif
15259 :
15260 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
15261 0 : return this;
15262 : }
15263 :
15264 : // *** COMMON CODE SECTION ENDS HERE ***
15265 :
15266 :
15267 : // End of memberFunctionString
15268 : // Start of memberFunctionString
15269 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
15270 :
15271 :
15272 : #if 0
15273 : //! Error checking support
15274 : /*! Verifies the following:
15275 : - working getVariant() member function
15276 : - calls base class's error() member function
15277 : Every class has one of these functions.
15278 : */
15279 : bool
15280 : SgPragma::error()
15281 : {
15282 : // Put error checking here
15283 :
15284 : ROSE_ASSERT (this != NULL);
15285 : if (getVariant() != PragmaTag)
15286 : {
15287 : printf ("Error in SgPragma::error(): SgPragma object has a %s variant \n",
15288 : Cxx_GrammarTerminalNames[getVariant()].name);
15289 : // printf ("Error in SgPragma::error() \n");
15290 : ROSE_ABORT();
15291 : }
15292 :
15293 : ROSE_ASSERT (getVariant() == PragmaTag);
15294 : return SgAttribute::error();
15295 : }
15296 : #endif
15297 :
15298 :
15299 :
15300 : // End of memberFunctionString
15301 :
15302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
15303 :
15304 21588900 : SgPragma* isSgPragma ( SgNode* inputDerivedClassPointer )
15305 : {
15306 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
15307 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
15308 : // So to fix this we return NULL directly when the input is NULL and avoid the
15309 : // dynamic_cast in this case. This is likely a performance improvement as well.
15310 : // return dynamic_cast<SgPragma*>(inputDerivedClassPointer);
15311 : // Milind Chabbi (8/28/2013): isSgPragma uses table-driven castability instead of c++ default dynamic_cast
15312 : // this improves the running time performance by 10-20%.
15313 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPragma*>(inputDerivedClassPointer);
15314 21588900 : return IS_SgPragma_FAST_MACRO(inputDerivedClassPointer);
15315 : }
15316 :
15317 : // DQ (11/8/2003): Added version of functions taking const pointer
15318 0 : const SgPragma* isSgPragma ( const SgNode* inputDerivedClassPointer )
15319 : {
15320 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
15321 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
15322 : // So to fix this we return NULL directly when the input is NULL and avoid the
15323 : // dynamic_cast in this case. This is likely a performance improvement as well.
15324 : // return dynamic_cast<const SgPragma*>(inputDerivedClassPointer);
15325 : // Milind Chabbi (8/28/2013): isSgPragma uses table-driven castability instead of c++ default dynamic_cast
15326 : // this improves the running time performance by 10-20%.
15327 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPragma*>(inputDerivedClassPointer);
15328 0 : return IS_SgPragma_FAST_MACRO(inputDerivedClassPointer);
15329 : }
15330 :
15331 :
15332 :
15333 : /* #line 15334 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15334 :
15335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
15336 :
15337 : /**
15338 : \brief Generated destructor
15339 :
15340 : This destructor is automatically generated (by ROSETTA). This destructor
15341 : only frees memory of data members associated with the parts of the current IR node which
15342 : are NOT traversed. Those data members that are part of a traversal can be freed using
15343 : a traversal (calling this destructor on all children in a post-order traversal). Such
15344 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
15345 :
15346 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
15347 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
15348 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
15349 :
15350 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
15351 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
15352 : pointers are not yet implemented to call delete on eash pointer in the container.
15353 : (This could be done by derivation from the STL containers to define containers that
15354 : automatically deleted their members.)
15355 :
15356 : */
15357 388 : SgPragma::~SgPragma () {
15358 194 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
15359 :
15360 194 : if (p_startOfConstruct && p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_startOfConstruct; }
15361 194 : if (p_endOfConstruct && p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_endOfConstruct; }
15362 :
15363 : // case: not a listType for startOfConstruct
15364 194 : p_startOfConstruct = NULL; // non list case
15365 : // case: not a listType for endOfConstruct
15366 194 : p_endOfConstruct = NULL; // non list case
15367 : // case: not a listType for printed
15368 194 : p_printed = 0; // non list case
15369 : // case: not a listType for args
15370 194 : p_args = NULL; // non list case
15371 : // case: not a listType for attributeMechanism
15372 194 : p_attributeMechanism = NULL; // non list case
15373 :
15374 : }
15375 :
15376 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
15377 388 : }
15378 :
15379 :
15380 : /* #line 15381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15381 :
15382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
15383 :
15384 : // Generated constructor
15385 1829 : SgPragma::SgPragma ( std::string name, Sg_File_Info* startOfConstruct, Sg_File_Info* endOfConstruct )
15386 1829 : : SgAttribute(name)
15387 : {
15388 : #ifdef DEBUG
15389 : // printf ("In SgPragma::SgPragma (std::string name, Sg_File_Info* startOfConstruct, Sg_File_Info* endOfConstruct) sage_class_name() = %s \n",sage_class_name());
15390 : #endif
15391 : #if 0
15392 : // debugging information!
15393 : printf ("In SgPragma::SgPragma (std::string name, Sg_File_Info* startOfConstruct, Sg_File_Info* endOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
15394 : #endif
15395 :
15396 1829 : p_startOfConstruct = startOfConstruct;
15397 1829 : p_endOfConstruct = endOfConstruct;
15398 1829 : p_printed = 0;
15399 1829 : p_args = NULL;
15400 1829 : p_attributeMechanism = NULL;
15401 :
15402 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
15403 :
15404 : #if 0
15405 : // DQ (7/30/2014): Call a virtual function.
15406 : std::string s = this->class_name();
15407 : #endif
15408 :
15409 : // Test the variant virtual function
15410 : // assert(PragmaTag == variant());
15411 1829 : assert(PragmaTag == this->variant());
15412 1829 : ROSE_ASSERT(PragmaTag == (int)(this->variantT()));
15413 1829 : post_construction_initialization();
15414 :
15415 : // Test the isSgPragma() function since it has been problematic
15416 1829 : assert(isSgPragma(this) != NULL);
15417 1829 : }
15418 :
15419 : // Generated constructor (all data members)
15420 :
15421 : /* #line 15422 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15422 :
15423 :
15424 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
15425 :
15426 :
15427 : // ********************************************************
15428 : // member functions common across all array grammar objects
15429 : // ********************************************************
15430 :
15431 :
15432 :
15433 : /* #line 15434 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15434 :
15435 :
15436 :
15437 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
15438 :
15439 : // ********************************************************
15440 : // member functions specific to each node in the grammar
15441 : // ********************************************************
15442 :
15443 :
15444 : /* #line 15445 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15445 :
15446 : // Start of memberFunctionString
15447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
15448 :
15449 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
15450 :
15451 : unsigned long int
15452 0 : SgBitAttribute::get_bitflag () const
15453 : {
15454 0 : ROSE_ASSERT (this != NULL);
15455 :
15456 : #if 0
15457 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
15458 : // used to trigger marking transformations for the token-based unparsing.
15459 : printf ("SgBitAttribute::get_bitflag = %p = %s \n",this,this->class_name().c_str());
15460 : #endif
15461 :
15462 0 : return p_bitflag;
15463 : }
15464 :
15465 : void
15466 0 : SgBitAttribute::set_bitflag ( unsigned long int bitflag )
15467 : {
15468 0 : ROSE_ASSERT (this != NULL);
15469 :
15470 : #if 0
15471 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
15472 : // used to trigger marking transformations for the token-based unparsing.
15473 : printf ("SgBitAttribute::set_bitflag = %p = %s \n",this,this->class_name().c_str());
15474 : #endif
15475 :
15476 0 : set_isModified(true);
15477 :
15478 0 : p_bitflag = bitflag;
15479 0 : }
15480 :
15481 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
15482 :
15483 :
15484 : // End of memberFunctionString
15485 : // Start of memberFunctionString
15486 : /* #line 13660 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
15487 :
15488 :
15489 :
15490 : // End of memberFunctionString
15491 : // Start of memberFunctionString
15492 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
15493 :
15494 : // *** COMMON CODE SECTION BEGINS HERE ***
15495 :
15496 : #if 0
15497 : int
15498 : SgBitAttribute::getVariant() const
15499 : {
15500 : // This function is used in ROSE while "variant()" is used in SAGE
15501 : assert(this != NULL);
15502 : return variant();
15503 : }
15504 : #endif
15505 :
15506 : // This function is used in ROSE in treeTraversal code
15507 : // eventually replaces getVariant() and variant()
15508 : // though after variant() has been removed for a while we will
15509 : // want to change the name of variantT() back to variant()
15510 : // (since the "T" was ment to stand for temporary).
15511 : // When this happens the variantT() will be depricated.
15512 : VariantT
15513 0 : SgBitAttribute::variantT() const
15514 : {
15515 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
15516 0 : ROSE_ASSERT(this != NULL);
15517 0 : return V_SgBitAttribute;
15518 : }
15519 :
15520 : #if 0
15521 : int
15522 : SgBitAttribute::variant() const
15523 : {
15524 : // This function is used in SAGE
15525 : ROSE_ASSERT(this != NULL);
15526 : return BitAttributeTag;
15527 : }
15528 : #endif
15529 :
15530 : ROSE_DLL_API const char*
15531 0 : SgBitAttribute::sage_class_name() const
15532 : {
15533 0 : ROSE_ASSERT(this != NULL);
15534 0 : return "SgBitAttribute";
15535 : }
15536 :
15537 : std::string
15538 0 : SgBitAttribute::class_name() const
15539 : {
15540 0 : ROSE_ASSERT(this != NULL);
15541 0 : return "SgBitAttribute";
15542 : }
15543 :
15544 : // DQ (11/26/2005): Support for visitor pattern mechanims
15545 : // (inferior to ROSE traversal mechanism, experimental).
15546 : void
15547 0 : SgBitAttribute::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
15548 : {
15549 0 : ROSE_ASSERT(this != NULL);
15550 0 : visitor.visit(this);
15551 0 : }
15552 :
15553 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
15554 0 : void SgBitAttribute::accept (ROSE_VisitorPattern & visitor) {
15555 0 : ROSE_ASSERT(this != NULL);
15556 0 : visitor.visit(this);
15557 0 : }
15558 :
15559 : SgBitAttribute*
15560 0 : SgBitAttribute::addRegExpAttribute(std::string s, AstRegExAttribute* a)
15561 : {
15562 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
15563 : // This function is currently only supported for the AST used the represent Binary executables.
15564 : if (0 /* isSgAsmNode(this) != NULL */)
15565 : {
15566 : // Support for regex specification.
15567 : std::string prefixCode = "REGEX:";
15568 : addNewAttribute(prefixCode + s,a);
15569 : }
15570 : #endif
15571 :
15572 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
15573 0 : return this;
15574 : }
15575 :
15576 : // *** COMMON CODE SECTION ENDS HERE ***
15577 :
15578 :
15579 : // End of memberFunctionString
15580 : // Start of memberFunctionString
15581 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
15582 :
15583 :
15584 : #if 0
15585 : //! Error checking support
15586 : /*! Verifies the following:
15587 : - working getVariant() member function
15588 : - calls base class's error() member function
15589 : Every class has one of these functions.
15590 : */
15591 : bool
15592 : SgBitAttribute::error()
15593 : {
15594 : // Put error checking here
15595 :
15596 : ROSE_ASSERT (this != NULL);
15597 : if (getVariant() != BitAttributeTag)
15598 : {
15599 : printf ("Error in SgBitAttribute::error(): SgBitAttribute object has a %s variant \n",
15600 : Cxx_GrammarTerminalNames[getVariant()].name);
15601 : // printf ("Error in SgBitAttribute::error() \n");
15602 : ROSE_ABORT();
15603 : }
15604 :
15605 : ROSE_ASSERT (getVariant() == BitAttributeTag);
15606 : return SgAttribute::error();
15607 : }
15608 : #endif
15609 :
15610 :
15611 :
15612 : // End of memberFunctionString
15613 :
15614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
15615 :
15616 0 : SgBitAttribute* isSgBitAttribute ( SgNode* inputDerivedClassPointer )
15617 : {
15618 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
15619 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
15620 : // So to fix this we return NULL directly when the input is NULL and avoid the
15621 : // dynamic_cast in this case. This is likely a performance improvement as well.
15622 : // return dynamic_cast<SgBitAttribute*>(inputDerivedClassPointer);
15623 : // Milind Chabbi (8/28/2013): isSgBitAttribute uses table-driven castability instead of c++ default dynamic_cast
15624 : // this improves the running time performance by 10-20%.
15625 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBitAttribute*>(inputDerivedClassPointer);
15626 0 : return IS_SgBitAttribute_FAST_MACRO(inputDerivedClassPointer);
15627 : }
15628 :
15629 : // DQ (11/8/2003): Added version of functions taking const pointer
15630 0 : const SgBitAttribute* isSgBitAttribute ( const SgNode* inputDerivedClassPointer )
15631 : {
15632 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
15633 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
15634 : // So to fix this we return NULL directly when the input is NULL and avoid the
15635 : // dynamic_cast in this case. This is likely a performance improvement as well.
15636 : // return dynamic_cast<const SgBitAttribute*>(inputDerivedClassPointer);
15637 : // Milind Chabbi (8/28/2013): isSgBitAttribute uses table-driven castability instead of c++ default dynamic_cast
15638 : // this improves the running time performance by 10-20%.
15639 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBitAttribute*>(inputDerivedClassPointer);
15640 0 : return IS_SgBitAttribute_FAST_MACRO(inputDerivedClassPointer);
15641 : }
15642 :
15643 :
15644 :
15645 : /* #line 15646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15646 :
15647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
15648 :
15649 : /**
15650 : \brief Generated destructor
15651 :
15652 : This destructor is automatically generated (by ROSETTA). This destructor
15653 : only frees memory of data members associated with the parts of the current IR node which
15654 : are NOT traversed. Those data members that are part of a traversal can be freed using
15655 : a traversal (calling this destructor on all children in a post-order traversal). Such
15656 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
15657 :
15658 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
15659 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
15660 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
15661 :
15662 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
15663 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
15664 : pointers are not yet implemented to call delete on eash pointer in the container.
15665 : (This could be done by derivation from the STL containers to define containers that
15666 : automatically deleted their members.)
15667 :
15668 : */
15669 0 : SgBitAttribute::~SgBitAttribute () {
15670 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
15671 :
15672 :
15673 : // case: not a listType for bitflag
15674 0 : p_bitflag = 0; // non list case
15675 :
15676 : }
15677 :
15678 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
15679 0 : }
15680 :
15681 :
15682 : /* #line 15683 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15683 :
15684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
15685 :
15686 : // Generated constructor
15687 0 : SgBitAttribute::SgBitAttribute ( std::string name, unsigned long int bitflag )
15688 0 : : SgAttribute(name)
15689 : {
15690 : #ifdef DEBUG
15691 : // printf ("In SgBitAttribute::SgBitAttribute (std::string name, unsigned long int bitflag) sage_class_name() = %s \n",sage_class_name());
15692 : #endif
15693 : #if 0
15694 : // debugging information!
15695 : printf ("In SgBitAttribute::SgBitAttribute (std::string name, unsigned long int bitflag): this = %p = %s \n",this,this->class_name().c_str());
15696 : #endif
15697 :
15698 0 : p_bitflag = bitflag;
15699 :
15700 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
15701 :
15702 : #if 0
15703 : // DQ (7/30/2014): Call a virtual function.
15704 : std::string s = this->class_name();
15705 : #endif
15706 :
15707 : // Test the variant virtual function
15708 : // assert(BitAttributeTag == variant());
15709 0 : assert(BitAttributeTag == this->variant());
15710 0 : ROSE_ASSERT(BitAttributeTag == (int)(this->variantT()));
15711 0 : post_construction_initialization();
15712 :
15713 : // Test the isSgBitAttribute() function since it has been problematic
15714 0 : assert(isSgBitAttribute(this) != NULL);
15715 0 : }
15716 :
15717 : // Generated constructor (all data members)
15718 :
15719 : /* #line 15720 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15720 :
15721 :
15722 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
15723 :
15724 :
15725 : // ********************************************************
15726 : // member functions common across all array grammar objects
15727 : // ********************************************************
15728 :
15729 :
15730 :
15731 : /* #line 15732 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15732 :
15733 :
15734 :
15735 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
15736 :
15737 : // ********************************************************
15738 : // member functions specific to each node in the grammar
15739 : // ********************************************************
15740 :
15741 :
15742 : /* #line 15743 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15743 :
15744 : // Start of memberFunctionString
15745 : /* #line 5700 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
15746 :
15747 :
15748 : // JH (1/18/2006): Added default constructor explicitly to avoid having it be generated by the compiler
15749 0 : SgFuncDecl_attr::SgFuncDecl_attr()
15750 0 : : SgBitAttribute(NULL,0)
15751 : {
15752 : // Build the default constructor (nothing to build here since no data members)
15753 0 : }
15754 :
15755 :
15756 :
15757 : // End of memberFunctionString
15758 : // Start of memberFunctionString
15759 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
15760 :
15761 : // *** COMMON CODE SECTION BEGINS HERE ***
15762 :
15763 : #if 0
15764 : int
15765 : SgFuncDecl_attr::getVariant() const
15766 : {
15767 : // This function is used in ROSE while "variant()" is used in SAGE
15768 : assert(this != NULL);
15769 : return variant();
15770 : }
15771 : #endif
15772 :
15773 : // This function is used in ROSE in treeTraversal code
15774 : // eventually replaces getVariant() and variant()
15775 : // though after variant() has been removed for a while we will
15776 : // want to change the name of variantT() back to variant()
15777 : // (since the "T" was ment to stand for temporary).
15778 : // When this happens the variantT() will be depricated.
15779 : VariantT
15780 0 : SgFuncDecl_attr::variantT() const
15781 : {
15782 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
15783 0 : ROSE_ASSERT(this != NULL);
15784 0 : return V_SgFuncDecl_attr;
15785 : }
15786 :
15787 : #if 0
15788 : int
15789 : SgFuncDecl_attr::variant() const
15790 : {
15791 : // This function is used in SAGE
15792 : ROSE_ASSERT(this != NULL);
15793 : return FuncDecl_attrTag;
15794 : }
15795 : #endif
15796 :
15797 : ROSE_DLL_API const char*
15798 0 : SgFuncDecl_attr::sage_class_name() const
15799 : {
15800 0 : ROSE_ASSERT(this != NULL);
15801 0 : return "SgFuncDecl_attr";
15802 : }
15803 :
15804 : std::string
15805 0 : SgFuncDecl_attr::class_name() const
15806 : {
15807 0 : ROSE_ASSERT(this != NULL);
15808 0 : return "SgFuncDecl_attr";
15809 : }
15810 :
15811 : // DQ (11/26/2005): Support for visitor pattern mechanims
15812 : // (inferior to ROSE traversal mechanism, experimental).
15813 : void
15814 0 : SgFuncDecl_attr::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
15815 : {
15816 0 : ROSE_ASSERT(this != NULL);
15817 0 : visitor.visit(this);
15818 0 : }
15819 :
15820 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
15821 0 : void SgFuncDecl_attr::accept (ROSE_VisitorPattern & visitor) {
15822 0 : ROSE_ASSERT(this != NULL);
15823 0 : visitor.visit(this);
15824 0 : }
15825 :
15826 : SgFuncDecl_attr*
15827 0 : SgFuncDecl_attr::addRegExpAttribute(std::string s, AstRegExAttribute* a)
15828 : {
15829 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
15830 : // This function is currently only supported for the AST used the represent Binary executables.
15831 : if (0 /* isSgAsmNode(this) != NULL */)
15832 : {
15833 : // Support for regex specification.
15834 : std::string prefixCode = "REGEX:";
15835 : addNewAttribute(prefixCode + s,a);
15836 : }
15837 : #endif
15838 :
15839 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
15840 0 : return this;
15841 : }
15842 :
15843 : // *** COMMON CODE SECTION ENDS HERE ***
15844 :
15845 :
15846 : // End of memberFunctionString
15847 : // Start of memberFunctionString
15848 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
15849 :
15850 :
15851 : #if 0
15852 : //! Error checking support
15853 : /*! Verifies the following:
15854 : - working getVariant() member function
15855 : - calls base class's error() member function
15856 : Every class has one of these functions.
15857 : */
15858 : bool
15859 : SgFuncDecl_attr::error()
15860 : {
15861 : // Put error checking here
15862 :
15863 : ROSE_ASSERT (this != NULL);
15864 : if (getVariant() != FuncDecl_attrTag)
15865 : {
15866 : printf ("Error in SgFuncDecl_attr::error(): SgFuncDecl_attr object has a %s variant \n",
15867 : Cxx_GrammarTerminalNames[getVariant()].name);
15868 : // printf ("Error in SgFuncDecl_attr::error() \n");
15869 : ROSE_ABORT();
15870 : }
15871 :
15872 : ROSE_ASSERT (getVariant() == FuncDecl_attrTag);
15873 : return SgBitAttribute::error();
15874 : }
15875 : #endif
15876 :
15877 :
15878 :
15879 : // End of memberFunctionString
15880 :
15881 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
15882 :
15883 0 : SgFuncDecl_attr* isSgFuncDecl_attr ( SgNode* inputDerivedClassPointer )
15884 : {
15885 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
15886 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
15887 : // So to fix this we return NULL directly when the input is NULL and avoid the
15888 : // dynamic_cast in this case. This is likely a performance improvement as well.
15889 : // return dynamic_cast<SgFuncDecl_attr*>(inputDerivedClassPointer);
15890 : // Milind Chabbi (8/28/2013): isSgFuncDecl_attr uses table-driven castability instead of c++ default dynamic_cast
15891 : // this improves the running time performance by 10-20%.
15892 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFuncDecl_attr*>(inputDerivedClassPointer);
15893 0 : return IS_SgFuncDecl_attr_FAST_MACRO(inputDerivedClassPointer);
15894 : }
15895 :
15896 : // DQ (11/8/2003): Added version of functions taking const pointer
15897 0 : const SgFuncDecl_attr* isSgFuncDecl_attr ( const SgNode* inputDerivedClassPointer )
15898 : {
15899 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
15900 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
15901 : // So to fix this we return NULL directly when the input is NULL and avoid the
15902 : // dynamic_cast in this case. This is likely a performance improvement as well.
15903 : // return dynamic_cast<const SgFuncDecl_attr*>(inputDerivedClassPointer);
15904 : // Milind Chabbi (8/28/2013): isSgFuncDecl_attr uses table-driven castability instead of c++ default dynamic_cast
15905 : // this improves the running time performance by 10-20%.
15906 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFuncDecl_attr*>(inputDerivedClassPointer);
15907 0 : return IS_SgFuncDecl_attr_FAST_MACRO(inputDerivedClassPointer);
15908 : }
15909 :
15910 :
15911 :
15912 : /* #line 15913 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15913 :
15914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
15915 :
15916 : /**
15917 : \brief Generated destructor
15918 :
15919 : This destructor is automatically generated (by ROSETTA). This destructor
15920 : only frees memory of data members associated with the parts of the current IR node which
15921 : are NOT traversed. Those data members that are part of a traversal can be freed using
15922 : a traversal (calling this destructor on all children in a post-order traversal). Such
15923 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
15924 :
15925 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
15926 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
15927 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
15928 :
15929 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
15930 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
15931 : pointers are not yet implemented to call delete on eash pointer in the container.
15932 : (This could be done by derivation from the STL containers to define containers that
15933 : automatically deleted their members.)
15934 :
15935 : */
15936 0 : SgFuncDecl_attr::~SgFuncDecl_attr () {
15937 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
15938 :
15939 :
15940 :
15941 : }
15942 :
15943 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
15944 0 : }
15945 :
15946 :
15947 : /* #line 15948 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15948 :
15949 :
15950 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
15951 :
15952 :
15953 : // ********************************************************
15954 : // member functions common across all array grammar objects
15955 : // ********************************************************
15956 :
15957 :
15958 :
15959 : /* #line 15960 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15960 :
15961 :
15962 :
15963 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
15964 :
15965 : // ********************************************************
15966 : // member functions specific to each node in the grammar
15967 : // ********************************************************
15968 :
15969 :
15970 : /* #line 15971 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
15971 :
15972 : // Start of memberFunctionString
15973 : /* #line 5727 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
15974 :
15975 :
15976 : // JH (1/18/2006): Added default constructor explicitly to avoid having it be generated by the compiler
15977 0 : SgClassDecl_attr::SgClassDecl_attr()
15978 0 : : SgBitAttribute(NULL,0)
15979 : {
15980 : // Build the default constructor (nothing to build here since no data members)
15981 0 : }
15982 :
15983 :
15984 :
15985 : // End of memberFunctionString
15986 : // Start of memberFunctionString
15987 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
15988 :
15989 : // *** COMMON CODE SECTION BEGINS HERE ***
15990 :
15991 : #if 0
15992 : int
15993 : SgClassDecl_attr::getVariant() const
15994 : {
15995 : // This function is used in ROSE while "variant()" is used in SAGE
15996 : assert(this != NULL);
15997 : return variant();
15998 : }
15999 : #endif
16000 :
16001 : // This function is used in ROSE in treeTraversal code
16002 : // eventually replaces getVariant() and variant()
16003 : // though after variant() has been removed for a while we will
16004 : // want to change the name of variantT() back to variant()
16005 : // (since the "T" was ment to stand for temporary).
16006 : // When this happens the variantT() will be depricated.
16007 : VariantT
16008 0 : SgClassDecl_attr::variantT() const
16009 : {
16010 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
16011 0 : ROSE_ASSERT(this != NULL);
16012 0 : return V_SgClassDecl_attr;
16013 : }
16014 :
16015 : #if 0
16016 : int
16017 : SgClassDecl_attr::variant() const
16018 : {
16019 : // This function is used in SAGE
16020 : ROSE_ASSERT(this != NULL);
16021 : return ClassDecl_attrTag;
16022 : }
16023 : #endif
16024 :
16025 : ROSE_DLL_API const char*
16026 0 : SgClassDecl_attr::sage_class_name() const
16027 : {
16028 0 : ROSE_ASSERT(this != NULL);
16029 0 : return "SgClassDecl_attr";
16030 : }
16031 :
16032 : std::string
16033 0 : SgClassDecl_attr::class_name() const
16034 : {
16035 0 : ROSE_ASSERT(this != NULL);
16036 0 : return "SgClassDecl_attr";
16037 : }
16038 :
16039 : // DQ (11/26/2005): Support for visitor pattern mechanims
16040 : // (inferior to ROSE traversal mechanism, experimental).
16041 : void
16042 0 : SgClassDecl_attr::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
16043 : {
16044 0 : ROSE_ASSERT(this != NULL);
16045 0 : visitor.visit(this);
16046 0 : }
16047 :
16048 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
16049 0 : void SgClassDecl_attr::accept (ROSE_VisitorPattern & visitor) {
16050 0 : ROSE_ASSERT(this != NULL);
16051 0 : visitor.visit(this);
16052 0 : }
16053 :
16054 : SgClassDecl_attr*
16055 0 : SgClassDecl_attr::addRegExpAttribute(std::string s, AstRegExAttribute* a)
16056 : {
16057 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
16058 : // This function is currently only supported for the AST used the represent Binary executables.
16059 : if (0 /* isSgAsmNode(this) != NULL */)
16060 : {
16061 : // Support for regex specification.
16062 : std::string prefixCode = "REGEX:";
16063 : addNewAttribute(prefixCode + s,a);
16064 : }
16065 : #endif
16066 :
16067 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
16068 0 : return this;
16069 : }
16070 :
16071 : // *** COMMON CODE SECTION ENDS HERE ***
16072 :
16073 :
16074 : // End of memberFunctionString
16075 : // Start of memberFunctionString
16076 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
16077 :
16078 :
16079 : #if 0
16080 : //! Error checking support
16081 : /*! Verifies the following:
16082 : - working getVariant() member function
16083 : - calls base class's error() member function
16084 : Every class has one of these functions.
16085 : */
16086 : bool
16087 : SgClassDecl_attr::error()
16088 : {
16089 : // Put error checking here
16090 :
16091 : ROSE_ASSERT (this != NULL);
16092 : if (getVariant() != ClassDecl_attrTag)
16093 : {
16094 : printf ("Error in SgClassDecl_attr::error(): SgClassDecl_attr object has a %s variant \n",
16095 : Cxx_GrammarTerminalNames[getVariant()].name);
16096 : // printf ("Error in SgClassDecl_attr::error() \n");
16097 : ROSE_ABORT();
16098 : }
16099 :
16100 : ROSE_ASSERT (getVariant() == ClassDecl_attrTag);
16101 : return SgBitAttribute::error();
16102 : }
16103 : #endif
16104 :
16105 :
16106 :
16107 : // End of memberFunctionString
16108 :
16109 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
16110 :
16111 0 : SgClassDecl_attr* isSgClassDecl_attr ( SgNode* inputDerivedClassPointer )
16112 : {
16113 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
16114 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
16115 : // So to fix this we return NULL directly when the input is NULL and avoid the
16116 : // dynamic_cast in this case. This is likely a performance improvement as well.
16117 : // return dynamic_cast<SgClassDecl_attr*>(inputDerivedClassPointer);
16118 : // Milind Chabbi (8/28/2013): isSgClassDecl_attr uses table-driven castability instead of c++ default dynamic_cast
16119 : // this improves the running time performance by 10-20%.
16120 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassDecl_attr*>(inputDerivedClassPointer);
16121 0 : return IS_SgClassDecl_attr_FAST_MACRO(inputDerivedClassPointer);
16122 : }
16123 :
16124 : // DQ (11/8/2003): Added version of functions taking const pointer
16125 0 : const SgClassDecl_attr* isSgClassDecl_attr ( const SgNode* inputDerivedClassPointer )
16126 : {
16127 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
16128 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
16129 : // So to fix this we return NULL directly when the input is NULL and avoid the
16130 : // dynamic_cast in this case. This is likely a performance improvement as well.
16131 : // return dynamic_cast<const SgClassDecl_attr*>(inputDerivedClassPointer);
16132 : // Milind Chabbi (8/28/2013): isSgClassDecl_attr uses table-driven castability instead of c++ default dynamic_cast
16133 : // this improves the running time performance by 10-20%.
16134 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassDecl_attr*>(inputDerivedClassPointer);
16135 0 : return IS_SgClassDecl_attr_FAST_MACRO(inputDerivedClassPointer);
16136 : }
16137 :
16138 :
16139 :
16140 : /* #line 16141 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
16141 :
16142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
16143 :
16144 : /**
16145 : \brief Generated destructor
16146 :
16147 : This destructor is automatically generated (by ROSETTA). This destructor
16148 : only frees memory of data members associated with the parts of the current IR node which
16149 : are NOT traversed. Those data members that are part of a traversal can be freed using
16150 : a traversal (calling this destructor on all children in a post-order traversal). Such
16151 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
16152 :
16153 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
16154 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
16155 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
16156 :
16157 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
16158 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
16159 : pointers are not yet implemented to call delete on eash pointer in the container.
16160 : (This could be done by derivation from the STL containers to define containers that
16161 : automatically deleted their members.)
16162 :
16163 : */
16164 0 : SgClassDecl_attr::~SgClassDecl_attr () {
16165 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
16166 :
16167 :
16168 :
16169 : }
16170 :
16171 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
16172 0 : }
16173 :
16174 :
16175 : /* #line 16176 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
16176 :
16177 :
16178 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
16179 :
16180 :
16181 : // ********************************************************
16182 : // member functions common across all array grammar objects
16183 : // ********************************************************
16184 :
16185 :
16186 :
16187 : /* #line 16188 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
16188 :
16189 :
16190 :
16191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
16192 :
16193 : // ********************************************************
16194 : // member functions specific to each node in the grammar
16195 : // ********************************************************
16196 :
16197 :
16198 : /* #line 16199 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
16199 :
16200 : // Start of memberFunctionString
16201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
16202 :
16203 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
16204 :
16205 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
16206 : const SgFileIdList &
16207 0 : Sg_File_Info::get_fileIDsToUnparse () const
16208 : {
16209 0 : assert (this != NULL);
16210 0 : return p_fileIDsToUnparse;
16211 : }
16212 :
16213 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
16214 : SgFileIdList &
16215 2669270 : Sg_File_Info::get_fileIDsToUnparse ()
16216 : {
16217 2669270 : assert (this != NULL);
16218 :
16219 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
16220 : // As a rule only set_ access functions can set the isModified flag.
16221 : // set_isModified(true);
16222 :
16223 2669270 : return p_fileIDsToUnparse;
16224 : }
16225 :
16226 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
16227 :
16228 :
16229 : // End of memberFunctionString
16230 : // Start of memberFunctionString
16231 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
16232 :
16233 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
16234 :
16235 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
16236 : const SgFileLineNumberList &
16237 0 : Sg_File_Info::get_fileLineNumbersToUnparse () const
16238 : {
16239 0 : assert (this != NULL);
16240 0 : return p_fileLineNumbersToUnparse;
16241 : }
16242 :
16243 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
16244 : SgFileLineNumberList &
16245 52628 : Sg_File_Info::get_fileLineNumbersToUnparse ()
16246 : {
16247 52628 : assert (this != NULL);
16248 :
16249 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
16250 : // As a rule only set_ access functions can set the isModified flag.
16251 : // set_isModified(true);
16252 :
16253 52628 : return p_fileLineNumbersToUnparse;
16254 : }
16255 :
16256 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
16257 :
16258 :
16259 : // End of memberFunctionString
16260 : // Start of memberFunctionString
16261 :
16262 :
16263 : // End of memberFunctionString
16264 : // Start of memberFunctionString
16265 : /* #line 13718 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
16266 :
16267 :
16268 : // int Sg_File_Info::p_cur_line ROSE_DEPRECATED_VARIABLE = 0;
16269 : // std::string Sg_File_Info::p_cur_file ROSE_DEPRECATED_VARIABLE = "";
16270 :
16271 : // MK (7/22/05) : Added support for file ids. Here we initialize the static file maps, etc
16272 : // int Sg_File_Info::p_max_file_id = 0;
16273 : std::map<std::string, int> Sg_File_Info::p_nametofileid_map;
16274 : std::map<int, std::string> Sg_File_Info::p_fileidtoname_map;
16275 :
16276 :
16277 : // DQ (7/4/2005): Added to test internal consistancy
16278 : bool
16279 0 : Sg_File_Info::ok() const
16280 : {
16281 0 : assert(this != NULL);
16282 :
16283 : // DQ (10/22/2007): Are these reasonable constraints when #line n "" are used?
16284 0 : bool lineNumberOK = p_line > 0;
16285 0 : bool columnNumberOK = p_col > 0;
16286 :
16287 : // MK (7/22/05) We compare using p_fileid instead of p_filename now
16288 : // bool filenameOK = p_filename != NULL;
16289 0 : bool filenameOK = p_file_id != NULL_FILE_ID;
16290 :
16291 : // A compiler generated node has no defined association with a file, line number, or column number.
16292 0 : bool compilerGenerated = isCompilerGenerated();
16293 :
16294 : // DQ (11/22/2006): Some nodes have no source position information and we have the live with this at points in the processing.
16295 : // A node which was explicitly marked as a sourcePositionUnavailableInFrontendcompiler has no defined association with a file, line number, or column number.
16296 0 : bool sourcePositionUnavailableInFrontend = isSourcePositionUnavailableInFrontend();
16297 :
16298 : // DQ (12/23/2006): If this is part of a transformation then it is OK by definition.
16299 : // A node introduced as part of a transformation has no defined association with a file, line number, or column number.
16300 0 : bool transformation = isTransformation();
16301 :
16302 0 : bool physicalFileOK = (p_physical_file_id >= 0);
16303 :
16304 0 : if (physicalFileOK == false)
16305 : {
16306 0 : mprintf ("Note: In Sg_File_Info::ok(): p_physical_file_id = %d \n",p_physical_file_id);
16307 : }
16308 :
16309 : // return compilerGenerated || (lineNumberOK && filenameOK);
16310 : // return sourcePositionUnavailableInFrontend || compilerGenerated || (lineNumberOK && filenameOK);
16311 : // return transformation || sourcePositionUnavailableInFrontend || compilerGenerated || (lineNumberOK && columnNumberOK && filenameOK);
16312 0 : return (lineNumberOK && columnNumberOK && filenameOK) || compilerGenerated || sourcePositionUnavailableInFrontend || transformation;
16313 : }
16314 :
16315 : void
16316 0 : Sg_File_Info::updateSourcePosition ( Sg_File_Info* update )
16317 : {
16318 : // DQ (12/22/2006): This copies the line number and column number information and verifies that
16319 : // the file name is the same (it does not reset any of the classification flags). This is more
16320 : // useful than the assignment operator for updating information and is used in the file:
16321 : // fixupSourcePositionInformation.C.
16322 :
16323 0 : assert(update != NULL);
16324 :
16325 : // Must have matching file name (only have to compare file_id's)
16326 0 : assert(p_file_id == update->p_file_id);
16327 :
16328 : // Update only the line number and column number after verifying that the filenames are the same.
16329 0 : p_line = update->p_line;
16330 0 : p_col = update->p_col;
16331 :
16332 : // DQ (12/20/2012): Added support for physical source position (existing file_id and line data represents logical position data).
16333 0 : ROSE_ASSERT(p_physical_file_id == update->p_physical_file_id);
16334 0 : p_physical_line = update->p_physical_line;
16335 :
16336 : // DQ (1/23/2013): Added support for source sequence numbering information.
16337 0 : p_source_sequence_number = update->p_source_sequence_number;
16338 0 : }
16339 :
16340 :
16341 : // DQ (8/1/2005): use static function to return new Sg_File_Info object set to default values
16342 : // Static function to return new Sg_File_Info object set to default values
16343 23386700 : Sg_File_Info* Sg_File_Info::generateDefaultFileInfo()
16344 : {
16345 23386700 : Sg_File_Info* returnValue = new Sg_File_Info("NULL_FILE",0,0);
16346 23386700 : assert(returnValue != NULL);
16347 :
16348 : // DQ (6/7/2007): This causes "NULL_FILE" filenames to be introduced into the AST.
16349 : // Gergo pointed out this problems and removing such entries will simplify the tests
16350 : // that are done in the traverseInputFile traversal.
16351 : // mprintf ("Sg_File_Info::generateDefaultFileInfo(): This function is depricated and is an error to call! \n");
16352 : // assert(false);
16353 :
16354 : #if 0
16355 : mprintf ("In Sg_File_Info::generateDefaultFileInfo() return = %p \n",returnValue);
16356 : #endif
16357 :
16358 23386700 : return returnValue;
16359 : }
16360 :
16361 : // Static function to return new Sg_File_Info object set to default values appropriate for transformations
16362 : // static Sg_File_Info* generateTransformationDefaultFileInfo()
16363 77859 : Sg_File_Info* Sg_File_Info::generateDefaultFileInfoForTransformationNode()
16364 : {
16365 : // IR nodes using this function's return value will be marked as transformations
16366 77859 : Sg_File_Info* returnValue = generateDefaultFileInfo();
16367 77859 : returnValue->setTransformation();
16368 :
16369 : // DQ (1/11/2006): Added call to setOutputInCodeGeneration() because the default
16370 : // behavior is to output all transformations. Other functions allow transformations
16371 : // to be specified that would not be output (useful for when including new header files).
16372 77859 : returnValue->setOutputInCodeGeneration();
16373 :
16374 77859 : returnValue->set_file_id( TRANSFORMATION_FILE_ID );
16375 :
16376 : #if 0
16377 : mprintf ("In Sg_File_Info::generateDefaultFileInfoForTransformationNode() return = %p \n",returnValue);
16378 : #endif
16379 :
16380 77859 : return returnValue;
16381 : }
16382 :
16383 :
16384 : // DQ (1/11/2006): Added version of function where filename (file_id) can
16385 : // be explicitly set to be the non-default value.
16386 0 : Sg_File_Info* Sg_File_Info::generateFileInfoForTransformationNode( int file_id )
16387 : {
16388 : // IR nodes using this function's return value will be marked as transformations
16389 0 : Sg_File_Info* returnValue = generateDefaultFileInfoForTransformationNode();
16390 :
16391 0 : returnValue->set_file_id( file_id );
16392 :
16393 : #if 0
16394 : mprintf ("In Sg_File_Info::generateFileInfoForTransformationNode(file_id = %d) return = %p \n",file_id,returnValue);
16395 : #endif
16396 :
16397 0 : return returnValue;
16398 : }
16399 :
16400 :
16401 : // DQ (1/11/2006): Added version of function where filename (file_id) can
16402 : // be explicitly set to be the non-default value.
16403 0 : Sg_File_Info* Sg_File_Info::generateFileInfoForTransformationNode( string filename )
16404 : {
16405 : // IR nodes using this function's return value will be marked as transformations
16406 0 : Sg_File_Info* returnValue = generateDefaultFileInfoForTransformationNode();
16407 :
16408 0 : returnValue->set_filenameString( filename );
16409 :
16410 : #if 0
16411 : mprintf ("In Sg_File_Info::generateFileInfoForTransformationNode(filename = %s) return = %p \n",filename.c_str(),returnValue);
16412 : #endif
16413 :
16414 0 : return returnValue;
16415 : }
16416 :
16417 :
16418 : // Static function to return new Sg_File_Info object set to default values appropriate for compiler generated code
16419 : // static Sg_File_Info* generateCompilerGeneratedDefaultFileInfo()
16420 1588070 : Sg_File_Info* Sg_File_Info::generateDefaultFileInfoForCompilerGeneratedNode()
16421 : {
16422 : // IR nodes using this function's return value will be marked as compiler generated (but not output, unless also marked as such)
16423 1588070 : Sg_File_Info* returnValue = generateDefaultFileInfo();
16424 1588070 : returnValue->setCompilerGenerated();
16425 :
16426 1588070 : returnValue->set_file_id( COMPILER_GENERATED_FILE_ID );
16427 :
16428 : #if 0
16429 : mprintf ("In Sg_File_Info::generateDefaultFileInfoForCompilerGeneratedNode() return = %p \n",returnValue);
16430 : #endif
16431 :
16432 1588070 : return returnValue;
16433 : }
16434 :
16435 :
16436 : // DQ (11/2/2006): Added operator= member function to simple assignment (used in fixupSourcePositionInformation.C
16437 : // to modify Sg_File_Info objects so that they better reflect the original source code).
16438 : Sg_File_Info &
16439 212968 : Sg_File_Info::operator= ( const Sg_File_Info & X )
16440 : {
16441 : #if 0
16442 : mprintf ("In Sg_File_Info::operator=(): get_parent() = %p = %s \n",get_parent(),(get_parent() != NULL) ? get_parent()->class_name().c_str() : "null");
16443 : mprintf ("In Sg_File_Info::operator=(): this = %p &X = %p \n",this,&X);
16444 : #endif
16445 :
16446 212968 : p_file_id = X.p_file_id;
16447 212968 : p_line = X.p_line;
16448 212968 : p_col = X.p_col;
16449 212968 : p_classificationBitField = X.p_classificationBitField;
16450 212968 : p_fileIDsToUnparse = X.p_fileIDsToUnparse;
16451 212968 : p_fileLineNumbersToUnparse = X.p_fileLineNumbersToUnparse;
16452 :
16453 : // DQ (12/20/2012): Added support for physical source position (existing file_id and line data represents logical position data).
16454 212968 : p_physical_file_id = X.p_physical_file_id;
16455 212968 : p_physical_line = X.p_physical_line;
16456 :
16457 : // DQ (1/23/2013): Added support for source sequence numbering information.
16458 212968 : p_source_sequence_number = X.p_source_sequence_number;
16459 :
16460 : // Record that this source position information was updated.
16461 212968 : set_isModified(true);
16462 :
16463 212968 : return *this;
16464 : }
16465 :
16466 :
16467 : // DQ (9/26/2004): Added operator== friend function to permit testing of reused definitions of defining declarations!
16468 : bool
16469 130832 : operator== ( const Sg_File_Info & X, const Sg_File_Info & Y )
16470 : {
16471 130832 : bool returnValue = false;
16472 :
16473 : // Make this most efficent by putting the least likely match first
16474 : // (col, line, file) and the most expensive test (file) last.
16475 130832 : if (X.get_col() == Y.get_col())
16476 : {
16477 : // DQ (9/17/2013): We always want to use the physical source position.
16478 : // if (X.get_line() == Y.get_line())
16479 130832 : if (X.get_physical_line() == Y.get_physical_line())
16480 : {
16481 : // MK (7/22/05) : Replaced string comparisons with file_id comparisons
16482 : /*
16483 : if ( string(X.get_filename()) == string(Y.get_filename()))
16484 : {
16485 : returnValue = true;
16486 : }
16487 : */
16488 : // DQ (9/17/2013): We always want to use the physical source position.
16489 : // if (X.p_file_id == Y.p_file_id)
16490 130832 : if (X.p_physical_file_id == Y.p_physical_file_id)
16491 : {
16492 130832 : returnValue = true;
16493 : }
16494 : }
16495 : }
16496 :
16497 130832 : return returnValue;
16498 : }
16499 :
16500 :
16501 : // DQ (10/6/2004): Added operator!= friend function to permit testing of reused definitions of defining declarations!
16502 : bool
16503 0 : operator!= ( const Sg_File_Info & X, const Sg_File_Info & Y )
16504 : {
16505 0 : return operator==(X,Y) ? false : true;
16506 : }
16507 :
16508 :
16509 : // DQ (10/25/2004): Added relational operators to permit testing of strting vs. ending file info object (assert starting < ending)
16510 : bool
16511 2153980 : operator> ( const Sg_File_Info & X, const Sg_File_Info & Y )
16512 : {
16513 2153980 : bool result = false;
16514 : // mprintf ("In operator > (Sg_File_Info,Sg_File_Info): X.isSameFile(Y) = %s \n",X.isSameFile(Y) ? "true" : "false");
16515 2153980 : if (X.isSameFile(Y) == true)
16516 : {
16517 : // DQ (9/17/2013): We always want to use the physical source position.
16518 : // mprintf ("X.p_line = %d Y.p_line = %d \n",X.p_line,Y.p_line);
16519 : // mprintf ("X.p_col = %d Y.p_col = %d \n",X.p_col,Y.p_col);
16520 : // if (X.p_line > Y.p_line)
16521 2153980 : if (X.p_physical_line > Y.p_physical_line)
16522 : {
16523 : // mprintf ("TRUE: X.p_line = %d > X.p_line = %d \n",X.p_line,X.p_line);
16524 : result = true;
16525 : }
16526 : else
16527 : {
16528 : // DQ (9/17/2013): We always want to use the physical source position.
16529 : // if (X.p_line == Y.p_line)
16530 2088670 : if (X.p_physical_line == Y.p_physical_line)
16531 : {
16532 1552860 : if (X.p_col > Y.p_col)
16533 : {
16534 : // mprintf ("TRUE: X.p_col = %d > Y.p_col = %d \n",X.p_col,Y.p_col);
16535 104 : result = true;
16536 : }
16537 : }
16538 : }
16539 : }
16540 :
16541 : // mprintf ("Sorry operator> (const Sg_File_Info & X, const Sg_File_Info & Y) not implemented! \n");
16542 : // assert(false);
16543 : // return true;
16544 :
16545 2153980 : return result;
16546 : }
16547 :
16548 :
16549 : bool
16550 0 : operator< ( const Sg_File_Info & X, const Sg_File_Info & Y )
16551 : {
16552 0 : bool result = false;
16553 : // mprintf ("In operator < (Sg_File_Info,Sg_File_Info): X.isSameFile(Y) = %s \n",X.isSameFile(Y) ? "true" : "false");
16554 0 : if (X.isSameFile(Y) == true)
16555 : {
16556 : // DQ (9/17/2013): We always want to use the physical source position.
16557 : // mprintf ("X.p_line = %d Y.p_line = %d \n",X.p_line,Y.p_line);
16558 : // mprintf ("X.p_col = %d Y.p_col = %d \n",X.p_col,Y.p_col);
16559 : // if (X.p_line < Y.p_line)
16560 0 : if (X.p_physical_line < Y.p_physical_line)
16561 : {
16562 : // mprintf ("TRUE: X.p_line = %d < Y.p_line = %d \n",X.p_line,Y.p_line);
16563 : result = true;
16564 : }
16565 : else
16566 : {
16567 : // DQ (9/17/2013): We always want to use the physical source position.
16568 : // if (X.p_line == Y.p_line)
16569 0 : if (X.p_physical_line == Y.p_physical_line)
16570 : {
16571 0 : if (X.p_col < Y.p_col)
16572 : {
16573 : // mprintf ("TRUE: X.p_col = %d < Y.p_col = %d \n",X.p_col,Y.p_col);
16574 0 : result = true;
16575 : }
16576 : }
16577 : }
16578 : }
16579 :
16580 : // mprintf ("Sorry operator< (const Sg_File_Info & X, const Sg_File_Info & Y) not implemented! \n");
16581 : // assert(false);
16582 : // return true;
16583 :
16584 0 : return result;
16585 : }
16586 :
16587 :
16588 : bool
16589 0 : operator>= ( const Sg_File_Info & X, const Sg_File_Info & Y )
16590 : {
16591 0 : bool result = false;
16592 0 : if (X.isSameFile(Y) == true)
16593 : {
16594 : // DQ (9/17/2013): We always want to use the physical source position.
16595 : // if (X.p_line > Y.p_line)
16596 0 : if (X.p_physical_line > Y.p_physical_line)
16597 : {
16598 : result = true;
16599 : }
16600 : else
16601 : {
16602 : // DQ (9/17/2013): We always want to use the physical source position.
16603 : // if (X.p_line == Y.p_line)
16604 0 : if (X.p_physical_line == Y.p_physical_line)
16605 : {
16606 0 : if (X.p_col >= Y.p_col)
16607 0 : result = true;
16608 : }
16609 : }
16610 : }
16611 :
16612 : // mprintf ("Sorry operator>= (const Sg_File_Info & X, const Sg_File_Info & Y) not implemented! \n");
16613 : // assert(false);
16614 : // return true;
16615 :
16616 0 : return result;
16617 : }
16618 :
16619 :
16620 : bool
16621 1 : operator<= ( const Sg_File_Info & X, const Sg_File_Info & Y )
16622 : {
16623 1 : bool result = false;
16624 1 : if (X.isSameFile(Y) == true)
16625 : {
16626 : // DQ (9/17/2013): We always want to use the physical source position.
16627 : // if (X.p_line < Y.p_line)
16628 1 : if (X.p_physical_line < Y.p_physical_line)
16629 : {
16630 : result = true;
16631 : }
16632 : else
16633 : {
16634 : // DQ (9/17/2013): We always want to use the physical source position.
16635 : // if (X.p_line == Y.p_line)
16636 1 : if (X.p_physical_line == Y.p_physical_line)
16637 : {
16638 0 : if (X.p_col <= Y.p_col)
16639 0 : result = true;
16640 : }
16641 : }
16642 : }
16643 :
16644 : // mprintf ("Sorry operator<= (const Sg_File_Info & X, const Sg_File_Info & Y) not implemented! \n");
16645 : // assert(false);
16646 : // return true;
16647 :
16648 1 : return result;
16649 : }
16650 :
16651 :
16652 : //Liao 4/16/2010. The default value for display(label) cannot be instantiated from gdb,
16653 : // which is very annoying during debugging. I added the empty parameter one to better support debugging.
16654 : void
16655 0 : Sg_File_Info::display() const
16656 : {
16657 0 : display ("");
16658 0 : }
16659 :
16660 :
16661 : void
16662 22 : Sg_File_Info::display( const std::string label ) const
16663 : {
16664 22 : assert(this != NULL);
16665 :
16666 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
16667 22 : printf ("Inside of Sg_File_Info::display(%s) of this pointer = %p \n",label.c_str(), this);
16668 22 : printf (" isTransformation = %s \n",isTransformation() == true ? "true (part of a transformation)" : "false");
16669 22 : printf (" isCompilerGenerated = %s \n",isCompilerGenerated() == true ? "true (no position information)" : "false");
16670 22 : printf (" isOutputInCodeGeneration = %s \n",isOutputInCodeGeneration() == true ? "true (output in code generator)" : "false");
16671 22 : printf (" isShared = %s \n",isShared() == true ? "true (shared within merged AST)" : "false");
16672 22 : printf (" isFrontendSpecific = %s \n",isFrontendSpecific() == true ? "true (part of ROSE support for gnu compatability)" : "false");
16673 22 : printf (" isSourcePositionUnavailableInFrontend = %s \n",isSourcePositionUnavailableInFrontend() == true ? "true (source position unavailable in frontend)" : "false");
16674 22 : printf (" isCommentOrDirective = %s \n",isCommentOrDirective() == true ? "true (this is a comment or CPP directive)" : "false");
16675 22 : printf (" isToken = %s \n",isToken() == true ? "true (this is from the token stream woven into the AST)" : "false");
16676 22 : printf (" isDefaultArgument = %s \n",isDefaultArgument() == true ? "true (root of default argument)" : "false");
16677 22 : printf (" isImplicitCast = %s \n",isImplicitCast() == true ? "true (implicit instead of explicit cast)" : "false");
16678 :
16679 : // if (isCompilerGenerated() == false)
16680 22 : if (!isTransformation() && !isCompilerGenerated())
16681 : {
16682 22 : printf (" (computed) filename = %s \n",get_filename());
16683 22 : printf (" (computed) line = %d column = %d \n",get_line(),get_col());
16684 : }
16685 : else // Liao, 11/12/2012, more information for debugging
16686 : {
16687 0 : printf (" Filename and line, column info should be invalid for transformation or compiler generated objects\n");
16688 0 : printf (" we print their values anyway for your reference\n");
16689 0 : printf (" (computed) filename = %s \n",get_filename());
16690 0 : printf (" (computed) line = %d column = %d \n",get_line(),get_col());
16691 : }
16692 :
16693 : // DQ (6/17/2005): Way to get extra debugging information, if the
16694 : // substring "debug" is found then extra information is output
16695 : // if (label == "debug")
16696 22 : if (label.find("debug") != std::string::npos)
16697 : {
16698 0 : printf (" (internal) file_id = %d \n",get_file_id());
16699 0 : printf (" (internal) filename = %s \n",get_raw_filename().c_str());
16700 0 : printf (" (internal line = %d column = %d \n",p_line,p_col);
16701 : }
16702 :
16703 22 : printf (" (computed) physical_file_id = %d = %s \n",get_physical_file_id(),get_physical_filename().c_str());
16704 22 : printf (" (internal) physical_file_id = %d = %s \n",get_physical_file_id(),getFilenameFromID(get_physical_file_id()).c_str());
16705 22 : printf (" (internal) physical_file_id = %d = %s \n",p_physical_file_id,getFilenameFromID(p_physical_file_id).c_str());
16706 22 : printf (" (computed) physical_line = %d \n",p_physical_line);
16707 :
16708 : // DQ (1/23/2013): Added support for source sequence numbering information.
16709 22 : printf (" source_sequence_number = %d \n",p_source_sequence_number);
16710 :
16711 : // DQ (5/16/2005): output these values, but I think they might be removed
16712 : // later since I don't see the point of storing this information!
16713 : // printf (" isDeclaration = %s \n",isDeclaration() == true ? "true" : "false");
16714 : // printf (" isInitialization = %s \n",isInitialization() == true ? "true" : "false");
16715 22 : }
16716 :
16717 : string
16718 0 : Sg_File_Info::displayString(const std::string & label ) const
16719 : {
16720 0 : assert(this != NULL);
16721 :
16722 0 : std::string s;
16723 0 : s += std::string("Inside of Sg_File_Info::displayString(") + label + std::string (") \n");
16724 0 : s += std::string("isTransformation = ") + std::string(isTransformation() ? "true " : "false ") + std::string(" ");
16725 0 : s += std::string("isCompilerGenerated = ") + std::string(isCompilerGenerated() ? "true " : "false ") + std::string(" ");
16726 0 : if (!isTransformation() && !isCompilerGenerated())
16727 : {
16728 0 : s += std::string("line number = ") + Rose::StringUtility::numberToString(get_line()) + std::string(" ");
16729 0 : s += std::string("column number = ") + Rose::StringUtility::numberToString(get_col()) + std::string(" ");
16730 0 : s += std::string("filename = ") + std::string(get_filename()) + std::string(" ");
16731 : }
16732 :
16733 0 : return s;
16734 : }
16735 :
16736 : void
16737 0 : Sg_File_Info::display_static_data( const std::string label )
16738 : {
16739 : // DQ (6/11/2007): output static data for debugging
16740 :
16741 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
16742 0 : printf ("Inside of Sg_File_Info::display_static_data(%s) \n",label.c_str());
16743 :
16744 : // mprintf ("p_cur_line = %d \n",p_cur_line);
16745 : // mprintf ("p_cur_file = %s \n",p_cur_file.c_str());
16746 :
16747 : // mprintf ("p_max_file_id = %d \n",p_max_file_id);
16748 :
16749 0 : printf ("p_nametofileid_map: \n");
16750 0 : for (std::map<std::string,int>::iterator i = p_nametofileid_map.begin(); i != p_nametofileid_map.end(); i++)
16751 : {
16752 0 : printf ("name = %s id = %d \n",i->first.c_str(),i->second);
16753 : }
16754 :
16755 0 : printf ("p_fileidtoname_map: \n");
16756 0 : for (std::map<int,std::string>::iterator i = p_fileidtoname_map.begin(); i != p_fileidtoname_map.end(); i++)
16757 : {
16758 0 : printf ("id = %d name = %s \n",i->first,i->second.c_str());
16759 : }
16760 0 : }
16761 :
16762 : // Since we make the arguments in the other constructor
16763 : // have default values this constructor is redundant/ambiguous
16764 : // Sg_File_Info::Sg_File_Info() {}
16765 :
16766 34146 : Sg_File_Info::Sg_File_Info()
16767 : : p_file_id(COPY_FILE_ID), p_line(0), p_col(0),
16768 : p_classificationBitField(0),
16769 : p_physical_file_id(NULL_FILE_ID),
16770 : p_physical_line(0),
16771 : p_source_sequence_number(0),
16772 : p_fileIDsToUnparse(),
16773 34146 : p_fileLineNumbersToUnparse()
16774 : {
16775 34146 : ROSE_ASSERT(this != NULL);
16776 34146 : post_construction_initialization();
16777 34146 : }
16778 :
16779 : // DQ (4/19/2006): Added constructor to take std::string as part of move
16780 : // away from C style strings to C++ style strings.
16781 45717800 : Sg_File_Info::Sg_File_Info ( const std::string & filename, int line, int col )
16782 : : p_file_id(NULL_FILE_ID), p_line(line), p_col(col),
16783 : p_classificationBitField(0),
16784 : p_physical_file_id(NULL_FILE_ID),
16785 : p_physical_line(0),
16786 : p_source_sequence_number(0),
16787 : p_fileIDsToUnparse(),
16788 45717800 : p_fileLineNumbersToUnparse()
16789 : {
16790 45717800 : if (filename != "NULL_FILE")
16791 : {
16792 22331100 : set_filenameString(filename);
16793 : }
16794 :
16795 45717800 : set_physical_source_position_to_match_logical_source_position();
16796 :
16797 45717800 : post_construction_initialization();
16798 45717800 : }
16799 :
16800 : // DQ (2/15/2003): added copy constructor
16801 18677300 : Sg_File_Info::Sg_File_Info(const Sg_File_Info & X)
16802 18677300 : : p_file_id(X.p_file_id),
16803 18677300 : p_line(X.p_line),
16804 18677300 : p_col(X.p_col),
16805 18677300 : p_classificationBitField(X.p_classificationBitField),
16806 18677300 : p_physical_file_id(X.p_physical_file_id),
16807 18677300 : p_physical_line(X.p_physical_line),
16808 18677300 : p_source_sequence_number(X.p_source_sequence_number),
16809 18677300 : p_fileIDsToUnparse(X.p_fileIDsToUnparse),
16810 18677300 : p_fileLineNumbersToUnparse(X.p_fileLineNumbersToUnparse)
16811 : {
16812 18677300 : post_construction_initialization();
16813 18677300 : }
16814 :
16815 : // DQ (11/6/2008): added constructor to support building objects from Dwarf
16816 : // information (which uses a pre-resolved integer file_id instead of a string)
16817 0 : Sg_File_Info::Sg_File_Info( int file_id, int line, int column )
16818 : : p_file_id(file_id),
16819 : p_line(line),
16820 : p_col(column),
16821 : p_classificationBitField(0),
16822 : p_physical_file_id(NULL_FILE_ID),
16823 : p_physical_line(0),
16824 : p_source_sequence_number(0),
16825 : p_fileIDsToUnparse(),
16826 0 : p_fileLineNumbersToUnparse()
16827 : {
16828 0 : post_construction_initialization();
16829 0 : }
16830 :
16831 : void
16832 64429200 : Sg_File_Info::post_construction_initialization()
16833 : {
16834 64429200 : ROSE_ASSERT(this != NULL);
16835 : // JJW 10-26-2007 ensure that this object is not on the stack
16836 64429200 : preventConstructionOnStack(this);
16837 :
16838 : // ROSE-1499 check that p_file_id is valid
16839 64429200 : check_file_id("Sg_File_Info::post_construction_initialization");
16840 64429200 : }
16841 :
16842 : // ROSE-1499, ROSE-1639 (added const to char*)
16843 279549000 : void Sg_File_Info::check_file_id(const char * label, bool assertion) const {
16844 506178000 : if ( ( (p_file_id >= 0) && (p_fileidtoname_map.count(p_file_id) == 0) ) || ( (p_file_id < -6) || ( p_file_id > (int)p_fileidtoname_map.size() ) ) ) {
16845 0 : printf("ERROR from %s:\n", label);
16846 0 : printf(" Sg_File_Info::this = %p\n", this);
16847 0 : printf(" p_file_id = %d\n", p_file_id);
16848 0 : printf(" p_nametofileid_map.size() = %zu\n", p_nametofileid_map.size());
16849 0 : printf(" p_fileidtoname_map.size() = %zu\n", p_fileidtoname_map.size());
16850 0 : printf(" isTransformation() = %d\n", isTransformation());
16851 0 : printf(" isCompilerGenerated() = %d\n", isCompilerGenerated());
16852 0 : printf(" isFrontendSpecific() = %d\n", isFrontendSpecific());
16853 : }
16854 279549000 : if (assertion) {
16855 506178000 : ROSE_ASSERT((p_file_id < 0) || (p_fileidtoname_map.count(p_file_id) > 0));
16856 279549000 : ROSE_ASSERT((p_file_id > -7) && (p_file_id < (int)p_fileidtoname_map.size()));
16857 : }
16858 279549000 : }
16859 :
16860 : int
16861 181611000 : Sg_File_Info::get_file_id () const
16862 : {
16863 : // DQ (10/27/2007): This is custom generated so that it can be consistant with the get_filename() member function
16864 181611000 : assert (this != NULL);
16865 :
16866 181611000 : check_file_id("Sg_File_Info::get_file_id");
16867 :
16868 : // initialize to bad value
16869 181611000 : int returnValue = -99;
16870 :
16871 181611000 : if (isTransformation() == true)
16872 : {
16873 : // returnValue = undefinedValue;
16874 : returnValue = TRANSFORMATION_FILE_ID;
16875 : }
16876 : else
16877 : {
16878 : // DQ (11/1/2007): This does not allow for isSameFile() to compare properly when testing for "rose_edg_required_macros_and_functions.h"
16879 181611000 : if ( isCompilerGenerated() == true )
16880 : {
16881 : // DQ (11/1/2007): check if this is frontEndSpecific, and if so return the file_id of the associated file ("rose_edg_required_macros_and_functions.h")
16882 : // returnValue = undefinedValue;
16883 64629700 : if ( isFrontendSpecific() == true )
16884 : {
16885 : #define FAIL_ON_ROSE_1532 0
16886 : #if FAIL_ON_ROSE_1532
16887 : if (p_fileidtoname_map.count(p_file_id) == 0 && p_file_id == COMPILER_GENERATED_FILE_ID) {
16888 : printf("ERROR: Sg_File_Info::get_file_id(this = %p):\n", this);
16889 : printf(" isFrontendSpecific() == true => p_file_id == file_id_of(\"rose_edg_required_macros_and_functions.h\")\n");
16890 : printf(" BUT: p_file_id = %d\n", p_file_id);
16891 : printf(" HERE: p_file_id == COMPILER_GENERATED_FILE_ID\n");
16892 : printf(" BYPASSED: seen for a SgInitializedName in the parameter list of __builtin_atan2\n");
16893 : ROSE_ASSERT(false);
16894 : }
16895 : #endif
16896 : // ROSE-1499: check that p_file_id is valid
16897 120451000 : ROSE_ASSERT(p_file_id == COMPILER_GENERATED_FILE_ID || p_fileidtoname_map.count(p_file_id) > 0);
16898 : // In this case return the file_id of the specific file which indicates this properly ("rose_edg_required_macros_and_functions.h").
16899 61153400 : returnValue = p_file_id;
16900 : }
16901 : else
16902 : {
16903 : returnValue = COMPILER_GENERATED_FILE_ID;
16904 : }
16905 : }
16906 : else
16907 : {
16908 : #define FAIL_ON_ROSE_1533 0
16909 : #if FAIL_ON_ROSE_1533
16910 : if (p_fileidtoname_map.count(p_file_id) == 0 && p_file_id == NULL_FILE_ID) {
16911 : printf("ERROR: Sg_File_Info::get_file_id(this = %p):\n", this);
16912 : printf(" p_nametofileid_map.size() = %d\n", p_nametofileid_map.size());
16913 : printf(" p_fileidtoname_map.size() = %d\n", p_fileidtoname_map.size());
16914 : printf(" p_file_id should represent a valid file.\n", p_file_id);
16915 : printf(" HERE: p_file_id == NULL_FILE_ID\n");
16916 : printf(" BYPASSED: seen for a SgCtorInitializerList of foo1 in Cxx_tests/test2003_01.C (the SgCtorInitializerList is implicit).\n");
16917 : ROSE_ASSERT(false);
16918 : }
16919 : #endif
16920 : // ROSE-1499: check that p_file_id is valid
16921 233819000 : ROSE_ASSERT(p_file_id == NULL_FILE_ID || p_file_id == COMPILER_GENERATED_FILE_ID || p_fileidtoname_map.count(p_file_id) > 0);
16922 116981000 : returnValue = p_file_id;
16923 : }
16924 : }
16925 :
16926 : // DQ (12/18/2012): Added assertion.
16927 181611000 : ROSE_ASSERT(returnValue != -99);
16928 :
16929 181611000 : return returnValue;
16930 : }
16931 :
16932 : void
16933 1665930 : Sg_File_Info::set_file_id( int file_id )
16934 : {
16935 1665930 : assert (this != NULL);
16936 1665930 : set_isModified(true);
16937 :
16938 1665930 : check_file_id("Sg_File_Info::set_file_id");
16939 :
16940 : #if 0
16941 : mprintf ("In Sg_File_Info::set_file_id(file_id = %d) this = %p \n",file_id,this);
16942 : #endif
16943 :
16944 1665930 : p_file_id = file_id;
16945 1665930 : }
16946 :
16947 :
16948 : int
16949 79859200 : Sg_File_Info::get_physical_file_id() const
16950 : {
16951 : // DQ (12/18/2012): Added support for physical file position information.
16952 79859200 : assert (this != NULL);
16953 :
16954 : // Initialize to error value.
16955 79859200 : int return_physical_file_id = NULL_FILE_ID;
16956 :
16957 : #if 0
16958 : // Match the behavior (transformation, compiler generated, etc.) of the p_file_id.
16959 : int file_id = get_file_id();
16960 : #else
16961 : // DQ (8/20/2018): Fix this to not report generic "transformed" for any statement marked as a transformation when querying the physical file id.
16962 : // This is (I think) required support for the unparsing of header files.
16963 79859200 : bool physicalFileOK = (p_physical_file_id >= 0);
16964 79859200 : int file_id = get_file_id();
16965 : #endif
16966 :
16967 : // DQ (8/20/2018): Not clear why this language specific rule is a good idea.
16968 : // PHL (01/06/2014) use get_line for Fortran frontend
16969 79859200 : if (SageInterface::is_Fortran_language() )
16970 : {
16971 : return file_id;
16972 : }
16973 :
16974 : // DQ (8/20/2018): Fix this to not report generic "transformed" for any statement marked as a transformation when querying the physical file id.
16975 : // This is (I think) required support for the unparsing of header files.
16976 : #if 0
16977 : if (file_id < 0)
16978 : #else
16979 79825900 : if (physicalFileOK == false && file_id < 0)
16980 : #endif
16981 : {
16982 : return_physical_file_id = file_id;
16983 : }
16984 : else
16985 : {
16986 : #if 0
16987 : return_physical_file_id = p_physical_file_id;
16988 : #else
16989 : // DQ (8/22/2018): Use the file_id for compiler generated nodes, because they don't have a valid source position.
16990 : #if 0
16991 : mprintf ("In Sg_File_Info::get_physical_file_id(): isCompilerGenerated() = %s file_id = %d p_physical_file_id = %d \n",isCompilerGenerated() ? "true" : "false",file_id,p_physical_file_id);
16992 : #endif
16993 79527800 : if (isCompilerGenerated() == true)
16994 : {
16995 : return_physical_file_id = file_id;
16996 : }
16997 : else
16998 : {
16999 49340700 : return_physical_file_id = p_physical_file_id;
17000 : }
17001 : #endif
17002 : }
17003 :
17004 : return return_physical_file_id;
17005 : }
17006 :
17007 :
17008 : int
17009 11162900 : Sg_File_Info::get_physical_file_id(int input_file_id) const
17010 : {
17011 : // DQ (12/18/2012): Added support for physical file position information.
17012 11162900 : assert (this != NULL);
17013 :
17014 : // Initialize to error value.
17015 11162900 : int return_physical_file_id = NULL_FILE_ID;
17016 :
17017 : // DQ (8/20/2018): Fix this to not report generic "transformed" for any statement marked as a transformation when querying the physical file id.
17018 : // This is (I think) required support for the unparsing of header files.
17019 11162900 : bool physicalFileOK = (p_physical_file_id >= 0);
17020 11162900 : int local_file_id = get_file_id();
17021 :
17022 : // DQ (8/20/2018): Not clear why this language specific rule is a good idea.
17023 : // PHL (01/06/2014) use get_line for Fortran frontend
17024 11162900 : if (SageInterface::is_Fortran_language() )
17025 : {
17026 : return local_file_id;
17027 : }
17028 :
17029 : #if 0
17030 : mprintf ("In Sg_File_Info::get_physical_file_id(int): physicalFileOK = %s \n",physicalFileOK ? "true" : "false");
17031 : mprintf (" --- local_file_id = %d \n",local_file_id);
17032 : #endif
17033 :
17034 : // DQ (8/20/2018): Fix this to not report generic "transformed" for any statement marked as a transformation when querying the physical file id.
17035 : // This is (I think) required support for the unparsing of header files.
17036 11155700 : if (physicalFileOK == false && local_file_id < 0)
17037 : {
17038 : return_physical_file_id = local_file_id;
17039 : }
17040 : else
17041 : {
17042 : // DQ (8/22/2018): Use the file_id for compiler generated nodes, because they don't have a valid source position.
17043 : #if 0
17044 : mprintf ("In Sg_File_Info::get_physical_file_id(int): isCompilerGenerated() = %s local_file_id = %d p_physical_file_id = %d \n",isCompilerGenerated() ? "true" : "false",local_file_id,p_physical_file_id);
17045 : #endif
17046 10597800 : if (isCompilerGenerated() == true)
17047 : {
17048 : return_physical_file_id = local_file_id;
17049 : }
17050 : else
17051 : {
17052 : // return_physical_file_id = p_physical_file_id;
17053 :
17054 586677 : if (input_file_id == this->get_physical_file_id())
17055 : {
17056 130186 : return_physical_file_id = p_physical_file_id;
17057 : }
17058 : else
17059 : {
17060 456491 : SgFileIdList::const_iterator pos = find(p_fileIDsToUnparse.begin(),p_fileIDsToUnparse.end(),input_file_id);
17061 456491 : if (pos != p_fileIDsToUnparse.end())
17062 : {
17063 : #if 1
17064 0 : mprintf ("Sg_File_Info::get_physical_file_id(int): input file is sharing this IR node: input_file_id = %d physical_file_id = %d \n",input_file_id,this->get_physical_file_id());
17065 : #endif
17066 0 : ptrdiff_t index = pos - p_fileIDsToUnparse.begin();
17067 0 : ROSE_ASSERT(index >= 0);
17068 0 : ROSE_ASSERT(index < (ptrdiff_t)p_fileIDsToUnparse.size());
17069 :
17070 : // DQ (12/23/2019): Added debugging info.
17071 0 : if (p_fileLineNumbersToUnparse.size() != p_fileIDsToUnparse.size())
17072 : {
17073 0 : mprintf ("Error: p_fileLineNumbersToUnparse.size() != p_fileIDsToUnparse.size() \n");
17074 0 : mprintf (" --- p_fileLineNumbersToUnparse.size() = %zu \n",p_fileLineNumbersToUnparse.size());
17075 0 : mprintf (" --- p_fileIDsToUnparse.size() = %zu \n",p_fileIDsToUnparse.size());
17076 : }
17077 0 : ROSE_ASSERT(p_fileLineNumbersToUnparse.size() == p_fileIDsToUnparse.size());
17078 : #if 1
17079 0 : mprintf (" --- index = %d shared input file id = %d \n",(int)index,p_fileIDsToUnparse[index]);
17080 : #endif
17081 0 : ROSE_ASSERT(input_file_id == p_fileIDsToUnparse[index]);
17082 0 : return_physical_file_id = p_fileIDsToUnparse[index];
17083 : #if 1
17084 0 : mprintf (" --- returning return_physical_file_id = %d \n",return_physical_file_id);
17085 : #endif
17086 : #if 0
17087 : mprintf ("Exiting as a test! \n");
17088 : ROSE_ASSERT(false);
17089 : #endif
17090 : }
17091 : else
17092 : {
17093 : // This case means that the file_id provided was incorrect, the IR node is not shared with that file.
17094 : // This is a reasonable default, if we don't want to make this an error.
17095 :
17096 456491 : return_physical_file_id = p_physical_file_id;
17097 : }
17098 : }
17099 : }
17100 : }
17101 :
17102 : #if 0
17103 : mprintf ("Leaving Sg_File_Info::get_physical_file_id(int): p_physical_file_id = %d \n",p_physical_file_id);
17104 : #endif
17105 :
17106 : return return_physical_file_id;
17107 : }
17108 :
17109 :
17110 : void
17111 0 : Sg_File_Info::set_physical_file_id( int physical_file_id )
17112 : {
17113 0 : assert (this != NULL);
17114 :
17115 0 : set_isModified(true);
17116 :
17117 : #if 0
17118 : mprintf ("In Sg_File_Info::set_physical_file_id(physical_file_id = %d) this = %p \n",physical_file_id,this);
17119 : #endif
17120 :
17121 0 : p_physical_file_id = physical_file_id;
17122 :
17123 : // Make sure this is a previously handled file.
17124 0 : if (p_physical_file_id >= 0)
17125 : {
17126 0 : ROSE_ASSERT(p_fileidtoname_map.find(p_physical_file_id) != p_fileidtoname_map.end());
17127 : }
17128 0 : }
17129 :
17130 :
17131 : void
17132 45718100 : Sg_File_Info::set_physical_source_position_to_match_logical_source_position()
17133 : {
17134 45718100 : assert (this != NULL);
17135 :
17136 45718100 : set_isModified(true);
17137 :
17138 45718100 : p_physical_file_id = p_file_id;
17139 45718100 : p_physical_line = p_line;
17140 :
17141 : // Make sure this is a previously handled file.
17142 45718100 : if (p_physical_file_id >= 0)
17143 : {
17144 44662900 : ROSE_ASSERT(p_fileidtoname_map.find(p_physical_file_id) != p_fileidtoname_map.end());
17145 : }
17146 45718100 : }
17147 :
17148 :
17149 : int
17150 0 : Sg_File_Info::numberOfSourceFiles()
17151 : {
17152 0 : return p_nametofileid_map.size();
17153 : }
17154 :
17155 :
17156 : int
17157 0 : Sg_File_Info::addFilenameToMap ( const std::string & filename )
17158 : {
17159 : // DQ (11/6/2008): Added support for extending the internal static filename to integer id map.
17160 : // This static function is used the the Dwarf support to convert filenames to integer values and
17161 : // maintain a map similar to the Dwarf mapping of integers to filenames as a way to save space
17162 : // in the represnetation of source position mappings of the instructions in the binary.
17163 :
17164 0 : int returnValue = 0;
17165 0 : if (p_nametofileid_map.count(filename) == 0)
17166 : {
17167 0 : returnValue = p_nametofileid_map.size();
17168 0 : p_nametofileid_map[filename] = returnValue;
17169 0 : p_fileidtoname_map[returnValue] = filename;
17170 : }
17171 : else
17172 : {
17173 0 : returnValue = p_nametofileid_map[filename];
17174 : }
17175 :
17176 : // ROSE-1499 check that the maps are the same size
17177 0 : ROSE_ASSERT(p_nametofileid_map.size() == p_fileidtoname_map.size());
17178 :
17179 0 : return returnValue;
17180 : }
17181 :
17182 : void
17183 : // DQ (9/5/2006): renamed functions to swap the implementations
17184 : // Sg_File_Info::set_filename(const char* filename)
17185 22332100 : Sg_File_Info::set_filenameString ( const std::string & filename )
17186 : {
17187 22332100 : assert (this != NULL);
17188 :
17189 22332100 : check_file_id("Sg_File_Info::set_filenameString");
17190 :
17191 : #if 0
17192 : mprintf ("In Sg_File_Info::set_filenameString(filename = %s) this = %p \n",filename.c_str(),this);
17193 : #endif
17194 :
17195 : // DQ (6/6/2019): I think this is a more efficent implementation.
17196 : // p_nametofileid_map has type: std::map<std::string, int>
17197 : // if (p_nametofileid_map.count(filename) == 0)
17198 22332100 : if (p_nametofileid_map.find(filename) == p_nametofileid_map.end())
17199 : {
17200 11600 : p_file_id = p_nametofileid_map.size();
17201 11600 : p_nametofileid_map[filename] = p_file_id;
17202 11600 : p_fileidtoname_map[p_file_id] = filename;
17203 : }
17204 : else
17205 : {
17206 22320500 : p_file_id = p_nametofileid_map[filename];
17207 : }
17208 :
17209 : // ROSE-1499 check that the maps are the same size
17210 22332100 : ROSE_ASSERT(p_nametofileid_map.size() == p_fileidtoname_map.size());
17211 :
17212 : // DQ (3/19/2017): Note that this is important for Fortran support (where IR nodes frequently
17213 : // start with (isSourcePositionUnavailableInFrontend() == true) and are fixed up afterward.
17214 22332100 : if ( isSourcePositionUnavailableInFrontend() == true )
17215 : {
17216 : #if 0
17217 : mprintf ("In Sg_File_Info::set_filenameString(): reset isSourcePositionUnavailableInFrontend() to false: filename = %s \n",filename.c_str());
17218 : #endif
17219 48 : unsetSourcePositionUnavailableInFrontend();
17220 : }
17221 :
17222 : // DQ (8/31/2006): We can't enforce that this is an absolute path (test2001_04.C and test2004_60.C demonstrate why).
17223 : // DQ (8/31/2006): Verify that this is a absolute path
17224 : // string targetSubstring = "/";
17225 : // string filenameString = filename;
17226 : // if (filenameString.substr(0,targetSubstring.size()) != targetSubstring)
17227 : // mprintf ("@@@@@@@@@@@@@@@@@@@@ In Sg_File_Info::Sg_File_Info(string,int,int): filename = %s @@@@@@@@@@@@@@@@@@@@\n",filenameString.c_str());
17228 : // assert(filenameString.substr(0,targetSubstring.size()) == targetSubstring);
17229 :
17230 : // Detect use of AST Rewrite intermediate files (need to make sure they get absolute paths)
17231 : // string targetSubstring2 = "rose_";
17232 : // assert(filenameString.substr(0,targetSubstring2.size()) != targetSubstring2);
17233 22332100 : }
17234 :
17235 : void
17236 22310000 : Sg_File_Info::set_physical_filename ( const std::string & filename )
17237 : {
17238 22310000 : assert (this != NULL);
17239 :
17240 : #if 0
17241 : mprintf ("In Sg_File_Info::set_physical_filename(filename = %s) this = %p p_nametofileid_map.count(filename) = %" PRIuPTR " \n",filename.c_str(),this,p_nametofileid_map.count(filename));
17242 : #endif
17243 :
17244 : // DQ (6/6/2019): I think this is a more efficent implementation.
17245 : // p_nametofileid_map has type: std::map<std::string, int>
17246 : // if (p_nametofileid_map.count(filename) == 0)
17247 22310000 : if (p_nametofileid_map.find(filename) == p_nametofileid_map.end())
17248 : {
17249 : // If the filename is not in the p_nametofileid_map then we need to add it.
17250 0 : p_physical_file_id = p_nametofileid_map.size();
17251 0 : p_nametofileid_map[filename] = p_physical_file_id;
17252 0 : p_fileidtoname_map[p_physical_file_id] = filename;
17253 : }
17254 : else
17255 : {
17256 : // If it is in the p_nametofileid_map then we just need to get the integer file id.
17257 22310000 : p_physical_file_id = p_nametofileid_map[filename];
17258 : }
17259 :
17260 : // ROSE-1499 check that the maps are the same size
17261 22310000 : ROSE_ASSERT(p_nametofileid_map.size() == p_fileidtoname_map.size());
17262 22310000 : }
17263 :
17264 : void
17265 : // DQ (9/5/2006): renamed functions to swap the implementations
17266 : // Sg_File_Info::set_filenameString ( const std::string & filename )
17267 46 : Sg_File_Info::set_filename(const char* filename)
17268 : {
17269 46 : check_file_id("Sg_File_Info::set_filename");
17270 :
17271 : // DQ (9/5/2006): Modified implementation
17272 : // set_filename(filename.c_str());
17273 46 : assert(filename != NULL);
17274 46 : set_filenameString(filename);
17275 46 : }
17276 :
17277 : const std::string &
17278 9369000 : Sg_File_Info::get_filenameString() const
17279 : {
17280 9369000 : assert (this != NULL);
17281 9369000 : check_file_id("Sg_File_Info::get_filenameString");
17282 :
17283 9369000 : const std::string* returnString = NULL;
17284 :
17285 9369000 : if (isTransformation() == true)
17286 : {
17287 2257 : static const std::string transformation_string = "transformation";
17288 : returnString = &transformation_string;
17289 : }
17290 : else
17291 : {
17292 9366740 : if (isCompilerGenerated() == true)
17293 : {
17294 : // DQ (11/1/2007): check if this is frontEndSpecific, and if so return the filename of the associated file ("rose_edg_required_macros_and_functions.h")
17295 : // This has been fixed to be consistant with the implementation of get_file_id().
17296 1923760 : if ( isFrontendSpecific() == true )
17297 : {
17298 : // In this case return the filename of the specific file which indicates this properly ("rose_edg_required_macros_and_functions.h").
17299 328580 : returnString = &getFilenameFromID(p_file_id);
17300 : }
17301 : else
17302 : {
17303 1595180 : static const std::string compilerGenerated_string = "compilerGenerated";
17304 : returnString = &compilerGenerated_string;
17305 : }
17306 : }
17307 : else
17308 : {
17309 7442980 : returnString = &getFilenameFromID(p_file_id);
17310 : }
17311 : }
17312 :
17313 9369000 : assert (returnString != NULL);
17314 :
17315 9369000 : return *returnString;
17316 : }
17317 :
17318 : const char*
17319 142091 : Sg_File_Info::get_filename() const
17320 : {
17321 :
17322 142091 : check_file_id("Sg_File_Info::get_filename");
17323 :
17324 : // DQ (10/15/2005): This function is the C string version of the get_filename()
17325 : // function which has been depricated. At some point the get_filename() function
17326 : // will be eliminated and later reinfroduced as get_filename() (finally building
17327 : // a C++ string implementation instead of a char* (C style string) based implementation).
17328 142091 : return get_filenameString().c_str();
17329 : }
17330 :
17331 : string
17332 42210 : Sg_File_Info::get_raw_filename() const
17333 : {
17334 42210 : assert (this != NULL);
17335 :
17336 : // return whatever name is in the map
17337 42210 : return getFilenameFromID(p_file_id);
17338 : }
17339 :
17340 : string
17341 24700100 : Sg_File_Info::get_physical_filename() const
17342 : {
17343 24700100 : assert (this != NULL);
17344 :
17345 : #if 0
17346 : // return whatever name is in the map
17347 : return getFilenameFromID(p_physical_file_id);
17348 : #else
17349 : // DQ (9/21/2013): The support to return the filename must account for when this is compiler generated, a transformations, part of the front-end, etc.
17350 24700100 : const std::string* returnString = NULL;
17351 :
17352 24700100 : if (isTransformation() == true)
17353 : {
17354 0 : static const std::string transformation_string = "transformation";
17355 : returnString = &transformation_string;
17356 : }
17357 : else
17358 : {
17359 24700100 : if (isCompilerGenerated() == true)
17360 : {
17361 : // DQ (11/1/2007): check if this is frontEndSpecific, and if so return the filename of the associated file ("rose_edg_required_macros_and_functions.h")
17362 : // This has been fixed to be consistant with the implementation of get_file_id().
17363 2163300 : if ( isFrontendSpecific() == true )
17364 : {
17365 : // In this case return the filename of the specific file which indicates this properly ("rose_edg_required_macros_and_functions.h").
17366 2153780 : returnString = &getFilenameFromID(p_physical_file_id);
17367 : }
17368 : else
17369 : {
17370 9518 : static const std::string compilerGenerated_string = "compilerGenerated";
17371 : returnString = &compilerGenerated_string;
17372 : }
17373 : }
17374 : else
17375 : {
17376 22536800 : returnString = &getFilenameFromID(p_physical_file_id);
17377 : }
17378 : }
17379 :
17380 24700100 : assert (returnString != NULL);
17381 :
17382 24700100 : return *returnString;
17383 : #endif
17384 : }
17385 :
17386 : void
17387 557 : Sg_File_Info::set_line(int line)
17388 : {
17389 557 : assert (this != NULL);
17390 :
17391 557 : p_line = line;
17392 557 : if (isTransformation() || isCompilerGenerated())
17393 : {
17394 0 : if (line !=0) // Liao, 11/12/2012. get_line() won't return the value being set!!
17395 : {
17396 0 : mprintf ("warning: Sg_File_Info::set_line() tried to set non-zero line number to a transformation or compiler generated file info obj.\n");
17397 : }
17398 : }
17399 : else
17400 : {
17401 : // DQ (3/19/2017): Note that this is important for Fortran support (where IR nodes frequently
17402 : // start with (isSourcePositionUnavailableInFrontend() == true) and are fixed up afterward.
17403 557 : if ( isSourcePositionUnavailableInFrontend() == true )
17404 : {
17405 : #if 0
17406 : mprintf ("In Sg_File_Info::set_line(): reset isSourcePositionUnavailableInFrontend() to false: line = %d \n",line);
17407 : #endif
17408 48 : unsetSourcePositionUnavailableInFrontend();
17409 : }
17410 : }
17411 557 : }
17412 :
17413 : int
17414 2565300 : Sg_File_Info::get_line() const
17415 : {
17416 2565300 : assert (this != NULL);
17417 :
17418 : // return p_line;
17419 : // const int undefinedValue = INT_MAX-1;
17420 2565300 : const int undefinedValue = 0;
17421 2565300 : int returnValue = 0;
17422 2565300 : if (isTransformation() == true)
17423 : {
17424 : // mprintf ("Sg_File_Info::get_line called for transformation IR node (p_line = %d) \n",p_line);
17425 : returnValue = undefinedValue;
17426 : }
17427 : else
17428 : {
17429 : // DQ (8/17/2005): only undefinedValue when compiler generate (not when marked for output)
17430 : // if ( isCompilerGenerated() == true || isCompilerGeneratedNodeToBeUnparsed() == true )
17431 2565150 : if ( isCompilerGenerated() == true )
17432 : {
17433 : // mprintf ("Sg_File_Info::get_line called for compiler generated IR node (p_line = %d) \n",p_line);
17434 :
17435 : // DQ (6/14/2005): Temp code to permit identification of line number of template declaration!
17436 : // returnValue = undefinedValue;
17437 : // returnValue = p_line;
17438 : returnValue = undefinedValue;
17439 : }
17440 : else
17441 : {
17442 : #if 0
17443 : // DQ (3/18/2017): Original code.
17444 : returnValue = p_line;
17445 : #else
17446 : // DQ (3/18/2017): Add to the cases where we want to output an undefined value.
17447 : // I think it is helpful to know the position in the rose_edg_required_macros_and_functions.h
17448 : // file (so don't output undefined value for case of isFrontendSpecific() == true).
17449 : // if (isFrontendSpecific() == true || isSourcePositionUnavailableInFrontend() == true )
17450 2209950 : if ( isSourcePositionUnavailableInFrontend() == true )
17451 : {
17452 : returnValue = undefinedValue;
17453 : }
17454 : else
17455 : {
17456 1965840 : returnValue = p_line;
17457 : }
17458 : #endif
17459 : }
17460 : }
17461 :
17462 1965840 : assert (returnValue >= 0);
17463 2565300 : return returnValue;
17464 : }
17465 :
17466 :
17467 : // DQ (2/28/2019): Support for multi-file handling.
17468 : int
17469 0 : Sg_File_Info::get_line(int file_id) const
17470 : {
17471 : // Where this is a shared IR node across multiple files, return the line number location of the IR node for a specific file.
17472 :
17473 0 : assert (this != NULL);
17474 :
17475 0 : const int undefinedValue = 0;
17476 0 : int returnValue = 0;
17477 :
17478 0 : if (isTransformation() == true)
17479 : {
17480 : // mprintf ("Sg_File_Info::get_line called for transformation IR node (p_line = %d) \n",p_line);
17481 : returnValue = undefinedValue;
17482 : }
17483 : else
17484 : {
17485 : // DQ (8/17/2005): only undefinedValue when compiler generate (not when marked for output)
17486 0 : if ( isCompilerGenerated() == true )
17487 : {
17488 : // DQ (6/14/2005): Temp code to permit identification of line number of template declaration!
17489 : returnValue = undefinedValue;
17490 : }
17491 : else
17492 : {
17493 : // DQ (3/18/2017): Add to the cases where we want to output an undefined value.
17494 : // I think it is helpful to know the position in the rose_edg_required_macros_and_functions.h
17495 : // file (so don't output undefined value for case of isFrontendSpecific() == true).
17496 : // if (isFrontendSpecific() == true || isSourcePositionUnavailableInFrontend() == true )
17497 0 : if ( isSourcePositionUnavailableInFrontend() == true )
17498 : {
17499 : returnValue = undefinedValue;
17500 : }
17501 : else
17502 : {
17503 0 : if (file_id == this->get_physical_file_id())
17504 : {
17505 0 : returnValue = p_line;
17506 : }
17507 : else
17508 : {
17509 : // SgFileIdList::const_iterator pos = find(p_fileIDsToUnparse.begin(),p_fileIDsToUnparse.end(),this->get_physical_file_id());
17510 0 : SgFileIdList::const_iterator pos = find(p_fileIDsToUnparse.begin(),p_fileIDsToUnparse.end(),file_id);
17511 0 : if (pos != p_fileIDsToUnparse.end())
17512 : {
17513 : #if 0
17514 : mprintf ("Sg_File_Info::get_line(int): input file is sharing this IR node: input file_id = %d physical_file_id = %d \n",file_id,this->get_physical_file_id());
17515 : #endif
17516 0 : ptrdiff_t index = pos - p_fileIDsToUnparse.begin();
17517 0 : ROSE_ASSERT(index >= 0);
17518 0 : ROSE_ASSERT(index < (ptrdiff_t)p_fileIDsToUnparse.size());
17519 0 : ROSE_ASSERT(p_fileLineNumbersToUnparse.size() == p_fileIDsToUnparse.size());
17520 : #if 0
17521 : mprintf (" --- index = %d shared file id = %d \n",(int)index,p_fileIDsToUnparse[index]);
17522 : #endif
17523 0 : ROSE_ASSERT(file_id == p_fileIDsToUnparse[index]);
17524 0 : returnValue = p_fileLineNumbersToUnparse[index];
17525 : #if 0
17526 : mprintf (" --- returning returnValue = %d \n",returnValue);
17527 : #endif
17528 : }
17529 : else
17530 : {
17531 : // This case means that the file_id provided was incorrect, the IR node is not shared with that file.
17532 : // This is a reasonable default, if we don't want to make this an error.
17533 :
17534 0 : returnValue = p_line;
17535 : }
17536 : }
17537 : }
17538 : }
17539 : }
17540 :
17541 0 : assert (returnValue >= 0);
17542 0 : return returnValue;
17543 : }
17544 :
17545 :
17546 : int
17547 68541 : Sg_File_Info::get_raw_line() const
17548 : {
17549 68541 : assert (this != NULL);
17550 68541 : return p_line;
17551 : }
17552 :
17553 : void
17554 22310000 : Sg_File_Info::set_physical_line(int line)
17555 : {
17556 22310000 : assert (this != NULL);
17557 22310000 : p_physical_line = line;
17558 22310000 : }
17559 :
17560 : int
17561 46682 : Sg_File_Info::get_physical_line(int file_id) const
17562 : {
17563 46682 : assert (this != NULL);
17564 :
17565 46682 : int returnValue = 0;
17566 :
17567 : // DQ (2/28/2019): Physical source position information is not supported for Fortran yet (not debugged at least).
17568 46682 : if (SageInterface::is_Fortran_language() )
17569 : {
17570 1583 : returnValue = Sg_File_Info::get_line();
17571 : }
17572 : else
17573 : {
17574 : // returnValue = p_physical_line;
17575 45099 : if (file_id == this->get_physical_file_id())
17576 : {
17577 45099 : returnValue = p_physical_line;
17578 : }
17579 : else
17580 : {
17581 0 : SgFileIdList::const_iterator pos = find(p_fileIDsToUnparse.begin(),p_fileIDsToUnparse.end(),file_id);
17582 0 : if (pos != p_fileIDsToUnparse.end())
17583 : {
17584 : #if 0
17585 : mprintf ("Sg_File_Info::get_physical_line(int): input file is sharing this IR node: input file_id = %d physical_file_id = %d \n",file_id,this->get_physical_file_id());
17586 : #endif
17587 0 : ptrdiff_t index = pos - p_fileIDsToUnparse.begin();
17588 0 : ROSE_ASSERT(index >= 0);
17589 0 : ROSE_ASSERT(index < (ptrdiff_t)p_fileIDsToUnparse.size());
17590 0 : ROSE_ASSERT(p_fileLineNumbersToUnparse.size() == p_fileIDsToUnparse.size());
17591 : #if 0
17592 : mprintf (" --- index = %d shared file id = %d \n",(int)index,p_fileIDsToUnparse[index]);
17593 : #endif
17594 0 : ROSE_ASSERT(file_id == p_fileIDsToUnparse[index]);
17595 0 : returnValue = p_fileLineNumbersToUnparse[index];
17596 : #if 0
17597 : mprintf (" --- returning returnValue = %d \n",returnValue);
17598 : #endif
17599 : }
17600 : else
17601 : {
17602 : // This case means that the file_id provided was incorrect, the IR node is not shared with that file.
17603 : // This is a reasonable default, if we don't want to make this an error.
17604 :
17605 0 : returnValue = p_physical_line;
17606 : }
17607 : }
17608 : }
17609 :
17610 46682 : return returnValue;
17611 : }
17612 :
17613 : int
17614 329790 : Sg_File_Info::get_physical_line() const
17615 : {
17616 329790 : assert (this != NULL);
17617 : // PHL (11/25/2013) use get_line for Fortran frontend
17618 329790 : if (SageInterface::is_Fortran_language() )
17619 : {
17620 0 : return Sg_File_Info::get_line();
17621 : }else{
17622 329790 : return p_physical_line;
17623 : }
17624 : }
17625 :
17626 : // DQ (1/23/2013): Added source position sequence information.
17627 : // This work supports the handling of default arguments and addes
17628 : // new future capabilities to ROSE.
17629 : void
17630 22310200 : Sg_File_Info::set_source_sequence_number (unsigned int n)
17631 : {
17632 22310200 : assert (this != NULL);
17633 22310200 : p_source_sequence_number = n;
17634 22310200 : }
17635 :
17636 : unsigned int
17637 55231 : Sg_File_Info::get_source_sequence_number() const
17638 : {
17639 55231 : assert (this != NULL);
17640 55231 : return p_source_sequence_number;
17641 : }
17642 :
17643 : int
17644 2049760 : Sg_File_Info::get_col() const
17645 : {
17646 2049760 : assert (this != NULL);
17647 2049760 : assert (p_col >= 0);
17648 : // return p_col;
17649 :
17650 : // const int undefinedValue = INT_MAX-1;
17651 2049760 : const int undefinedValue = 0;
17652 2049760 : int returnValue = 0;
17653 2049760 : if (isTransformation() == true)
17654 : {
17655 : // mprintf ("Sg_File_Info::get_col called for transformation IR node \n");
17656 : returnValue = undefinedValue;
17657 : }
17658 : else
17659 : {
17660 : // DQ (8/17/2005): only undefinedValue when compiler generate (not when marked for output)
17661 : // if ( isCompilerGenerated() == true || isCompilerGeneratedNodeToBeUnparsed() == true )
17662 2049600 : if ( isCompilerGenerated() == true )
17663 : {
17664 : // mprintf ("Sg_File_Info::get_col called for compiler generated IR node \n");
17665 : returnValue = undefinedValue;
17666 : }
17667 : else
17668 : {
17669 : #if 0
17670 : // DQ (3/18/2017): Original code.
17671 : returnValue = p_col;
17672 : #else
17673 : // DQ (3/18/2017): Add to the cases where we want to output an undefined value.
17674 : // I think it is helpful to know the position in the rose_edg_required_macros_and_functions.h
17675 : // file (so don't output undefined value for case of isFrontendSpecific() == true).
17676 : // if (isFrontendSpecific() == true || isSourcePositionUnavailableInFrontend() == true )
17677 1742880 : if ( isSourcePositionUnavailableInFrontend() == true )
17678 : {
17679 : returnValue = undefinedValue;
17680 : }
17681 : else
17682 : {
17683 1741280 : returnValue = p_col;
17684 : }
17685 : #endif
17686 : }
17687 : }
17688 :
17689 1741280 : assert (returnValue >= 0);
17690 2049760 : return returnValue;
17691 : }
17692 :
17693 : int
17694 68291 : Sg_File_Info::get_raw_col() const
17695 : {
17696 68291 : assert (this != NULL);
17697 68291 : assert (p_col >= 0);
17698 68291 : return p_col;
17699 : }
17700 :
17701 : // DQ (5/24/2005): This function is impemented using the newer classification mechanism
17702 : void
17703 0 : Sg_File_Info::set_isPartOfTransformation( bool isPartOfTransformation )
17704 : {
17705 0 : assert (this != NULL);
17706 : // p_isPartOfTransformation = isPartOfTransformation;
17707 :
17708 0 : if (isPartOfTransformation == true)
17709 0 : setTransformation();
17710 : else
17711 0 : unsetTransformation();
17712 0 : }
17713 :
17714 : // DQ (5/24/2005): This function is impemented using the newer classification mechanism
17715 : bool
17716 0 : Sg_File_Info::get_isPartOfTransformation()
17717 : {
17718 0 : assert (this != NULL);
17719 : // return p_isPartOfTransformation;
17720 0 : return isTransformation();
17721 : }
17722 :
17723 : void
17724 0 : Sg_File_Info::register_node(SgLocatedNode* node)
17725 0 : {} /* register interest */
17726 :
17727 : void
17728 0 : Sg_File_Info::deregister_node(SgLocatedNode* node)
17729 0 : {}
17730 :
17731 : // functions added by Dan Quinlan (suggested by Gary Lee)
17732 : void
17733 1762 : Sg_File_Info::set_col( int n )
17734 : {
17735 1762 : assert (this != NULL);
17736 1762 : p_col = n;
17737 1762 : assert (p_col >= 0);
17738 1762 : }
17739 :
17740 : #if 0
17741 : int
17742 : Sg_File_Info::getCurrentLine () const
17743 : {
17744 : assert (this != NULL);
17745 : mprintf ("This is a depricated function: char* Sg_File_Info::getCurrentLine() const \n");
17746 : return p_cur_line;
17747 : }
17748 : #endif
17749 :
17750 : #if 0
17751 : std::string
17752 : Sg_File_Info::getCurrentFilename () const
17753 : {
17754 : assert (this != NULL);
17755 : mprintf ("This is a depricated function: char* Sg_File_Info::getCurrentFilename() const \n");
17756 : return p_cur_file;
17757 : }
17758 : #endif
17759 :
17760 : bool
17761 11481300 : Sg_File_Info::hasPositionInSource() const
17762 : {
17763 11481300 : assert(this != NULL);
17764 : // DQ (1/11/2006): Modified to not use the output function which mixed
17765 : // concepts of compiler generated with output (deprecated function).
17766 : // bool result = ( ! ( isTransformation() || isCompilerGenerated() || isCompilerGeneratedNodeToBeUnparsed() ) );
17767 11481300 : bool result = ( ! ( isTransformation() || isCompilerGenerated() || isOutputInCodeGeneration() ) );
17768 :
17769 11481300 : return result;
17770 : }
17771 :
17772 : // DQ (9/5/2008): Switched back to using SgFile instead of SgSourceFile.
17773 : // bool Sg_File_Info::isSameFile(SgFile* file) const
17774 : // bool Sg_File_Info::isSameFile(SgSourceFile* file) const
17775 : bool
17776 5187500 : Sg_File_Info::isSameFile(SgFile* file) const
17777 : {
17778 : // DQ (6/21/2005): check if this file info object is from the same file
17779 :
17780 : // This function abstracts the mechanism of comparing if a file info object is associated with a specific SgFile.
17781 : // this function will be made more efficient later when we can abstract out the string comparision from the test.
17782 : // Later we will implement a map from filename to unique "file number identifiers", this will permit significant
17783 : // spaces saving in the IR by avoiding redundant storage of filename strings and also improve the efficiency of
17784 : // testing if two file info objects represent the same file (an integer equality test instead of string comparision).
17785 : // File names are particularly long (since they include full path), so this will allow us to save a lot of space.
17786 :
17787 5187500 : assert(this != NULL);
17788 :
17789 5187500 : assert(file != NULL);
17790 :
17791 : // MK (7/22/05) : removing use of p_filename in favor of p_file_id
17792 : // Generate names of the files
17793 : /*
17794 : string inputFilename = file->getFileName();
17795 : string currentFilename = get_filename();
17796 :
17797 : bool result = (currentFilename == inputFilename);
17798 : */
17799 : #if 0
17800 : SgScopeStatement * globalScope = (SgScopeStatement *)(file->get_root());
17801 : assert(globalScope != NULL);
17802 : Sg_File_Info* fileInfo = globalScope->get_file_info();
17803 : #else
17804 : // DQ (9/5/2008): Use the local Sg_File_Info instead of the one on the root (which is only available for a SgSourceFile)
17805 5187500 : Sg_File_Info* fileInfo = file->get_startOfConstruct();
17806 : #endif
17807 5187500 : assert(fileInfo != NULL);
17808 :
17809 : // DQ (9/17/2013): This function should always refer to physical file data.
17810 : // DQ (10/27/2007): Make this consistant with new semantics of get_file_id()
17811 : // bool result = (p_file_id == fileInfo->get_file_id());
17812 : // bool result = (this->get_file_id() == fileInfo->get_file_id());
17813 5187500 : bool result = (this->get_physical_file_id() == fileInfo->get_physical_file_id());
17814 :
17815 : #if 0
17816 : mprintf ("In Sg_File_Info::isSameFile(): \n");
17817 : mprintf (" --- this->get_physical_file_id() = %d physical_filename = %s \n",this->get_physical_file_id(),this->get_physical_filename().c_str());
17818 : mprintf (" --- fileInfo->get_physical_file_id() = %d physical_filename = %s \n",fileInfo->get_physical_file_id(),fileInfo->get_physical_filename().c_str());
17819 : #endif
17820 :
17821 : // DQ (2/27/2019): Adding support for shared IR nodes, so that they can be traversed from AST for each of multiple files.
17822 5187500 : if (result == false)
17823 : {
17824 : // Check is this could be a shared file info.
17825 : // if (this->get_fileIDsToUnparse().empty() == false)
17826 5084180 : if (p_fileIDsToUnparse.empty() == false)
17827 : {
17828 : #if 0
17829 : mprintf ("Sg_File_Info::isSameFile(SgFile*): p_fileIDsToUnparse.size() = %zu \n",p_fileIDsToUnparse.size());
17830 : #endif
17831 : // if (find(p_fileIDsToUnparse.begin(),p_fileIDsToUnparse.end(),fileInfo->get_physical_file_id()) != p_fileIDsToUnparse.end())
17832 5630 : SgFileIdList::const_iterator pos = find(p_fileIDsToUnparse.begin(),p_fileIDsToUnparse.end(),fileInfo->get_physical_file_id());
17833 5630 : if (pos != p_fileIDsToUnparse.end())
17834 : {
17835 : #if 0
17836 : mprintf ("Sg_File_Info::isSameFile(SgFile*): input file is sharing this IR node: input file_id = %d \n",fileInfo->get_physical_file_id());
17837 : #endif
17838 0 : ptrdiff_t index = pos - p_fileIDsToUnparse.begin();
17839 0 : ROSE_ASSERT(index >= 0);
17840 0 : ROSE_ASSERT(index < (ptrdiff_t)p_fileIDsToUnparse.size());
17841 : #if 0
17842 : mprintf (" --- index = %d shared file id = %d \n",(int)index,p_fileIDsToUnparse[index]);
17843 : #endif
17844 : // result = true;
17845 0 : result = (fileInfo->get_physical_file_id() == p_fileIDsToUnparse[index]);
17846 : #if 0
17847 : mprintf (" --- returning result = %s \n",result ? "true" : "false");
17848 : #endif
17849 : }
17850 : }
17851 : }
17852 :
17853 5187500 : return result;
17854 : }
17855 :
17856 : // DQ (1/18/2006): Added new function with more useful interface.
17857 : bool
17858 21521 : Sg_File_Info::isSameFile(Sg_File_Info* fileInfo) const
17859 : {
17860 21521 : assert(fileInfo != NULL);
17861 :
17862 : // DQ (9/17/2013): This function should always refer to physical file data.
17863 : // DQ (10/27/2007): Make this consistant with new semantics of get_file_id()
17864 : // bool result = (p_file_id == fileInfo->get_file_id());
17865 : // bool result = (this->get_file_id() == fileInfo->get_file_id());
17866 21521 : bool result = (this->get_physical_file_id() == fileInfo->get_physical_file_id());
17867 :
17868 21521 : return result;
17869 : }
17870 :
17871 : // DQ (1/18/2006): Added new function with more useful interface.
17872 : bool
17873 3297380 : Sg_File_Info::isSameFile(const Sg_File_Info & fileInfo) const
17874 : {
17875 : // DQ (9/17/2013): This function should always refer to physical file data.
17876 : // DQ (10/27/2007): Make this consistant with new semantics of get_file_id()
17877 : // bool result = (p_file_id == fileInfo.get_file_id());
17878 : // bool result = (this->get_file_id() == fileInfo.get_file_id());
17879 3297380 : bool result = (this->get_physical_file_id() == fileInfo.get_physical_file_id());
17880 :
17881 3297380 : return result;
17882 : }
17883 :
17884 : //! Access functions for classification of File_Info objects
17885 : bool
17886 355584000 : Sg_File_Info::isTransformation() const
17887 : {
17888 355584000 : assert(this != NULL);
17889 355584000 : return (p_classificationBitField & e_transformation);
17890 : }
17891 :
17892 : void
17893 77870 : Sg_File_Info::setTransformation()
17894 : {
17895 77870 : assert(this != NULL);
17896 77870 : p_classificationBitField |= e_transformation;
17897 77870 : }
17898 :
17899 : void
17900 0 : Sg_File_Info::unsetTransformation()
17901 : {
17902 0 : assert(this != NULL);
17903 0 : p_classificationBitField &= ~e_transformation;
17904 0 : }
17905 :
17906 : bool
17907 401214000 : Sg_File_Info::isCompilerGenerated() const
17908 : {
17909 401214000 : assert(this != NULL);
17910 :
17911 : #if 0
17912 : mprintf ("In Sg_File_Info::isCompilerGenerated(): this = %p \n",this);
17913 : #endif
17914 :
17915 401214000 : return (p_classificationBitField & e_compiler_generated);
17916 : }
17917 :
17918 : void
17919 17176800 : Sg_File_Info::setCompilerGenerated()
17920 : {
17921 17176800 : assert(this != NULL);
17922 :
17923 : #if 0
17924 : mprintf ("In Sg_File_Info::setCompilerGenerated(): this = %p \n",this);
17925 : #endif
17926 :
17927 17176800 : p_classificationBitField |= e_compiler_generated;
17928 17176800 : }
17929 :
17930 : void
17931 0 : Sg_File_Info::unsetCompilerGenerated()
17932 : {
17933 0 : assert(this != NULL);
17934 0 : p_classificationBitField &= ~e_compiler_generated;
17935 0 : }
17936 :
17937 : // bool isCompilerGeneratedNodeToBeUnparsed() const;
17938 : bool
17939 17724200 : Sg_File_Info::isCompilerGeneratedNodeToBeUnparsed() const
17940 : {
17941 : // Make sure that both bits are set!
17942 17724200 : assert(this != NULL);
17943 17724200 : return (p_classificationBitField & e_output_in_code_generation);
17944 :
17945 : #if 0
17946 : // DQ (6/17/2005): Allow these to be set separately so that setting a whole function to
17947 : // be unparsed will not make any expecific casts as compiler generated and not required!
17948 : // If casts are the only issue then perhaps they should be marked explicitly as implicit
17949 : // or explicit (rather than compiler generated).
17950 : bool result = (p_classificationBitField & e_output_in_code_generation);
17951 :
17952 : // error checking: if e_compiler_generated_node_to_be_unparsed then also e_compiler_generated
17953 : if (result == true)
17954 : assert(isCompilerGenerated() == true);
17955 :
17956 : return result;
17957 : #endif
17958 : }
17959 :
17960 : void
17961 0 : Sg_File_Info::setCompilerGeneratedNodeToBeUnparsed()
17962 : {
17963 : // Make sure that both bits are set!
17964 : // setCompilerGenerated();
17965 0 : assert(this != NULL);
17966 :
17967 : #if 0
17968 : mprintf ("In Sg_File_Info::setCompilerGeneratedNodeToBeUnparsed(): this = %p \n",this);
17969 : #endif
17970 :
17971 0 : p_classificationBitField |= e_output_in_code_generation;
17972 0 : }
17973 :
17974 : void
17975 0 : Sg_File_Info::unsetCompilerGeneratedNodeToBeUnparsed()
17976 : {
17977 0 : assert(this != NULL);
17978 0 : p_classificationBitField &= ~e_output_in_code_generation;
17979 0 : }
17980 :
17981 : bool
17982 13356000 : Sg_File_Info::isOutputInCodeGeneration() const
17983 : {
17984 : // Make sure that both bits are set!
17985 13356000 : assert(this != NULL);
17986 13356000 : return (p_classificationBitField & e_output_in_code_generation);
17987 : }
17988 :
17989 : void
17990 23359700 : Sg_File_Info::setOutputInCodeGeneration()
17991 : {
17992 : // Make sure that both bits are set!
17993 : // setCompilerGenerated();
17994 23359700 : assert(this != NULL);
17995 :
17996 : #if 0
17997 : mprintf ("In setOutputInCodeGeneration(): this = %p parent = %p \n",this,this->get_parent());
17998 : #endif
17999 :
18000 : // DQ (5/19/2013): Testing...debugging test2013_171.C.
18001 : // ROSE_ASSERT(isSgNamespaceDefinitionStatement(this->get_parent()) == NULL);
18002 :
18003 23359700 : p_classificationBitField |= e_output_in_code_generation;
18004 23359700 : }
18005 :
18006 : void
18007 222 : Sg_File_Info::unsetOutputInCodeGeneration()
18008 : {
18009 222 : assert(this != NULL);
18010 222 : p_classificationBitField &= ~e_output_in_code_generation;
18011 222 : }
18012 :
18013 : bool
18014 19020000 : Sg_File_Info::isShared() const
18015 : {
18016 19020000 : assert(this != NULL);
18017 19020000 : return (p_classificationBitField & e_shared);
18018 : }
18019 :
18020 : void
18021 29893 : Sg_File_Info::setShared()
18022 : {
18023 : // MK (8/3/05) : We always want to unparse the current file (this is a performance issue)
18024 29893 : assert(this != NULL);
18025 : // DQ (10/27/2007): Make sure this is a valid file that we are trying to share.
18026 : // I am unclear as to how important this is.
18027 29893 : int temp_file_id = this->get_file_id();
18028 29893 : if (temp_file_id < 0)
18029 : {
18030 4583 : if (SgProject::get_verbose() > 0)
18031 0 : mprintf ("Warning: trying to share file id = %d < 0 \n",temp_file_id);
18032 : }
18033 :
18034 : #if 0
18035 : // DQ (2/27/2019): Disable this since it conflicts with using this as a mechanism to support additional files to support.
18036 : if (isShared() == false)
18037 : {
18038 : p_fileIDsToUnparse.push_back(p_file_id);
18039 : }
18040 : #endif
18041 :
18042 29893 : p_classificationBitField |= e_shared;
18043 29893 : }
18044 :
18045 : void
18046 0 : Sg_File_Info::unsetShared()
18047 : {
18048 0 : assert(this != NULL);
18049 0 : p_classificationBitField &= ~e_shared;
18050 :
18051 : #if 0
18052 : // DQ (2/27/2019): Disable this since it conflicts with using this as a mechanism to support additional files to support.
18053 : // MK (8/2/05) : Initialize the fileid set
18054 : p_fileIDsToUnparse.clear();
18055 : #endif
18056 0 : }
18057 :
18058 : bool
18059 131850000 : Sg_File_Info::isFrontendSpecific() const
18060 : {
18061 131850000 : assert(this != NULL);
18062 131850000 : return (p_classificationBitField & e_frontend_specific);
18063 : }
18064 :
18065 : void
18066 20103800 : Sg_File_Info::setFrontendSpecific()
18067 : {
18068 20103800 : assert(this != NULL);
18069 20103800 : p_classificationBitField |= e_frontend_specific;
18070 20103800 : }
18071 :
18072 : void
18073 0 : Sg_File_Info::unsetFrontendSpecific()
18074 : {
18075 0 : assert(this != NULL);
18076 0 : p_classificationBitField &= ~e_frontend_specific;
18077 0 : }
18078 :
18079 : bool
18080 86617200 : Sg_File_Info::isSourcePositionUnavailableInFrontend() const
18081 : {
18082 86617200 : assert(this != NULL);
18083 86617200 : return (p_classificationBitField & e_source_position_unavailable_in_frontend);
18084 : }
18085 :
18086 : void
18087 21720800 : Sg_File_Info::setSourcePositionUnavailableInFrontend()
18088 : {
18089 21720800 : assert(this != NULL);
18090 21720800 : p_classificationBitField |= e_source_position_unavailable_in_frontend;
18091 :
18092 : #if 0
18093 : // DQ (8/3/2012): We don't want to use this unless absolutely required; so output a message to support debugging.
18094 : mprintf ("In Sg_File_Info::setSourcePositionUnavailableInFrontend() \n");
18095 : #endif
18096 21720800 : }
18097 :
18098 : void
18099 96 : Sg_File_Info::unsetSourcePositionUnavailableInFrontend()
18100 : {
18101 96 : assert(this != NULL);
18102 96 : p_classificationBitField &= ~e_source_position_unavailable_in_frontend;
18103 :
18104 : #if 0
18105 : // DQ (8/3/2012): We don't want to use this unless absolutely required; so output a message to support debugging.
18106 : mprintf ("In Sg_File_Info::unsetSourcePositionUnavailableInFrontend() \n");
18107 : #endif
18108 96 : }
18109 :
18110 : bool
18111 564462 : Sg_File_Info::isCommentOrDirective() const
18112 : {
18113 564462 : assert(this != NULL);
18114 564462 : return (p_classificationBitField & e_comment_or_directive);
18115 : }
18116 :
18117 : void
18118 2204 : Sg_File_Info::setCommentOrDirective()
18119 : {
18120 2204 : assert(this != NULL);
18121 2204 : p_classificationBitField |= e_comment_or_directive;
18122 2204 : }
18123 :
18124 : void
18125 0 : Sg_File_Info::unsetCommentOrDirective()
18126 : {
18127 0 : assert(this != NULL);
18128 0 : p_classificationBitField &= ~e_comment_or_directive;
18129 0 : }
18130 :
18131 : bool
18132 561480 : Sg_File_Info::isToken() const
18133 : {
18134 561480 : assert(this != NULL);
18135 561480 : return (p_classificationBitField & e_token);
18136 : }
18137 :
18138 : void
18139 0 : Sg_File_Info::setToken()
18140 : {
18141 0 : assert(this != NULL);
18142 0 : p_classificationBitField |= e_token;
18143 0 : }
18144 :
18145 : void
18146 0 : Sg_File_Info::unsetToken()
18147 : {
18148 0 : assert(this != NULL);
18149 0 : p_classificationBitField &= ~e_token;
18150 0 : }
18151 :
18152 : // DQ (4/24/2013): Added support for marking as default argument. Note that compiler generated is not specific
18153 : // enough because even implicit casts would then be confused as default arguments.
18154 : bool
18155 316858 : Sg_File_Info::isDefaultArgument() const
18156 : {
18157 316858 : assert(this != NULL);
18158 316858 : return (p_classificationBitField & e_default_argument);
18159 : }
18160 :
18161 : void
18162 0 : Sg_File_Info::unsetDefaultArgument()
18163 : {
18164 0 : assert(this != NULL);
18165 0 : p_classificationBitField &= ~e_default_argument;
18166 0 : }
18167 :
18168 : void
18169 5805 : Sg_File_Info::setDefaultArgument()
18170 : {
18171 5805 : assert(this != NULL);
18172 5805 : p_classificationBitField |= e_default_argument;
18173 5805 : }
18174 :
18175 : // DQ (4/26/2013): Added support for marking as implicit casts. Note that compiler generated is not
18176 : // as specific as we want (though it has worked for a long time, we want a more precise mechanism).
18177 : bool
18178 36 : Sg_File_Info::isImplicitCast() const
18179 : {
18180 36 : assert(this != NULL);
18181 36 : return (p_classificationBitField & e_implicit_cast);
18182 : }
18183 :
18184 : void
18185 0 : Sg_File_Info::unsetImplicitCast()
18186 : {
18187 0 : assert(this != NULL);
18188 0 : p_classificationBitField &= ~e_implicit_cast;
18189 0 : }
18190 :
18191 : void
18192 0 : Sg_File_Info::setImplicitCast()
18193 : {
18194 0 : assert(this != NULL);
18195 0 : p_classificationBitField |= e_implicit_cast;
18196 0 : }
18197 :
18198 :
18199 :
18200 :
18201 : // MK (8/2/05) : Implementation for function to handle unparsing of particular files
18202 : void
18203 0 : Sg_File_Info::addFileToUnparse(int file_id)
18204 : {
18205 0 : assert(this != NULL);
18206 :
18207 : #if 1
18208 : // DQ (2/27/2019): Debugging how this is getting out of sync with the list of line numbers for multi-file handling.
18209 0 : mprintf ("Error: In Sg_File_Info::addFileToUnparse(): I think this function should not be called \n");
18210 0 : ROSE_ASSERT(false);
18211 : #endif
18212 :
18213 : p_fileIDsToUnparse.push_back(file_id);
18214 : }
18215 :
18216 : bool
18217 0 : Sg_File_Info::shouldUnparse(int file_id)
18218 : {
18219 0 : assert(this != NULL);
18220 0 : return std::find(p_fileIDsToUnparse.begin(), p_fileIDsToUnparse.end(), file_id) != p_fileIDsToUnparse.end();
18221 : }
18222 :
18223 : unsigned int
18224 0 : Sg_File_Info::get_classificationBitField(void) const
18225 : {
18226 0 : assert(this != NULL);
18227 0 : return p_classificationBitField;
18228 : }
18229 :
18230 : void
18231 0 : Sg_File_Info::set_classificationBitField( unsigned int bitflags )
18232 : {
18233 0 : assert(this != NULL);
18234 0 : p_classificationBitField = bitflags;
18235 0 : }
18236 :
18237 : // MK (8/2/05): Added implementations for static functions to support interface to fileid maps
18238 : const string&
18239 38010700 : Sg_File_Info::getFilenameFromID(int id)
18240 : {
18241 : // This is a static function
18242 :
18243 38010700 : const std::string* name = NULL;
18244 38010700 : switch(id)
18245 : {
18246 : // special cases
18247 174443 : case NULL_FILE_ID:
18248 174443 : {
18249 174443 : static const std::string null_file_string = "NULL_FILE";
18250 : name = &null_file_string;
18251 : break;
18252 : }
18253 0 : case COPY_FILE_ID:
18254 0 : {
18255 0 : static const std::string copy_file_string = "COPY";
18256 : name = ©_file_string;
18257 : break;
18258 : }
18259 0 : case TRANSFORMATION_FILE_ID:
18260 0 : {
18261 0 : static const std::string transformation_string = "transformation";
18262 : name = &transformation_string;
18263 : break;
18264 : }
18265 468949 : case COMPILER_GENERATED_FILE_ID:
18266 468949 : {
18267 468949 : static const std::string compilerGenerated_string = "compilerGenerated";
18268 : name = &compilerGenerated_string;
18269 : break;
18270 : }
18271 0 : case COMPILER_GENERATED_MARKED_FOR_OUTPUT_FILE_ID:
18272 0 : {
18273 : // name = "compilerGenerated";
18274 0 : mprintf ("The concept of COMPILER_GENERATED and OUTPUT are now decoupled, so make this an error \n");
18275 0 : assert(false);
18276 : break;
18277 : }
18278 0 : case BAD_FILE_ID:
18279 0 : {
18280 0 : static const std::string badfile_string = "badfile";
18281 : name = &badfile_string;
18282 : break;
18283 : }
18284 :
18285 : // normal case
18286 37367300 : default:
18287 37367300 : {
18288 : // assert that the id is present in the map (else error)
18289 : // assert(p_fileidtoname_map.count(id) != 0);
18290 37367300 : bool failure = (p_fileidtoname_map.count(id) == 0);
18291 0 : if (failure == true)
18292 : {
18293 0 : mprintf ("Error: bad id number for file id (id = %d) \n",id);
18294 :
18295 0 : display_static_data("error in getFilenameFromID");
18296 :
18297 : // Note: this causes an empty entry to be generated in p_fileidtoname_map for the id == p_max_file_id (value of max map size)
18298 : // std::cout << p_fileidtoname_map[id] << std::endl;
18299 : // mprintf ("Error: bad id number for file id (id = %d) \n",id);
18300 : }
18301 37367300 : ROSE_ASSERT(failure == false);
18302 :
18303 : // get the filename from the map using the valid id
18304 37367300 : name = &p_fileidtoname_map[id];
18305 : }
18306 : }
18307 :
18308 38010700 : return *name;
18309 : }
18310 :
18311 : int
18312 357 : Sg_File_Info::getIDFromFilename( std::string filename )
18313 : {
18314 : // This is a static function
18315 : #if 1
18316 : // DQ (10/22/2007): Should this be commented out?
18317 :
18318 : #if 0
18319 : mprintf ("In Sg_File_Info::getIDFromFilename(): filename = %s \n",filename.c_str());
18320 : #endif
18321 :
18322 357 : if (p_nametofileid_map.count(filename) == 0)
18323 : {
18324 : #if 0
18325 : mprintf ("In Sg_File_Info::getIDFromFilename(): p_nametofileid_map.count(filename) == 0 \n");
18326 : mprintf (" --- filename = %s \n",filename.c_str());
18327 : #endif
18328 :
18329 0 : return BAD_FILE_ID;
18330 : }
18331 : #endif
18332 :
18333 357 : return p_nametofileid_map[filename];
18334 : }
18335 :
18336 : // DQ (2/24/2010): These are static access functions where previously the ROSETTA generated ones were not static functions.
18337 : std::map<int, std::string> &
18338 40597600 : Sg_File_Info::get_fileidtoname_map()
18339 : {
18340 40597600 : return p_fileidtoname_map;
18341 : }
18342 :
18343 : // DQ (2/24/2010): These are static access functions where previously the ROSETTA generated ones were not static functions.
18344 : void
18345 2 : Sg_File_Info::set_fileidtoname_map(std::map<int, std::string> & X)
18346 : {
18347 2 : p_fileidtoname_map = X;
18348 2 : }
18349 :
18350 : // DQ (2/24/2010): These are static access functions where previously the ROSETTA generated ones were not static functions.
18351 : std::map<std::string, int> &
18352 69379800 : Sg_File_Info::get_nametofileid_map()
18353 : {
18354 69379800 : return p_nametofileid_map;
18355 : }
18356 :
18357 : // DQ (2/24/2010): These are static access functions where previously the ROSETTA generated ones were not static functions.
18358 : void
18359 2 : Sg_File_Info::set_nametofileid_map(std::map<std::string,int> & X)
18360 : {
18361 2 : p_nametofileid_map = X;
18362 2 : }
18363 :
18364 : #if 0
18365 : // DQ (2/27/2019): Adding support for access function to list of fileIds and line numbers associated with
18366 : // support for multi-file sharing of IR nodes and the support to know there source position information
18367 : // from each file.
18368 : const SgFileIdList &
18369 : Sg_File_Info::get_fileIDsToUnparse () const
18370 : {
18371 : ROSE_ASSERT (this != NULL);
18372 : return p_fileIDsToUnparse;
18373 : }
18374 :
18375 : // DQ (2/27/2019): Adding support for access function to list of fileIds and line numbers associated with
18376 : // support for multi-file sharing of IR nodes and the support to know there source position information
18377 : // from each file.
18378 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
18379 : SgFileIdList &
18380 : Sg_File_Info::get_fileIDsToUnparse ()
18381 : {
18382 : ROSE_ASSERT (this != NULL);
18383 :
18384 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not
18385 : // have to set the isModified flag. As a rule only set_ access functions can set the isModified flag.
18386 : // set_isModified(true);
18387 :
18388 : return p_fileIDsToUnparse;
18389 : }
18390 : #endif
18391 :
18392 :
18393 :
18394 : // End of memberFunctionString
18395 : // Start of memberFunctionString
18396 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
18397 :
18398 : // *** COMMON CODE SECTION BEGINS HERE ***
18399 :
18400 : #if 0
18401 : int
18402 : Sg_File_Info::getVariant() const
18403 : {
18404 : // This function is used in ROSE while "variant()" is used in SAGE
18405 : assert(this != NULL);
18406 : return variant();
18407 : }
18408 : #endif
18409 :
18410 : // This function is used in ROSE in treeTraversal code
18411 : // eventually replaces getVariant() and variant()
18412 : // though after variant() has been removed for a while we will
18413 : // want to change the name of variantT() back to variant()
18414 : // (since the "T" was ment to stand for temporary).
18415 : // When this happens the variantT() will be depricated.
18416 : VariantT
18417 1170650000 : Sg_File_Info::variantT() const
18418 : {
18419 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
18420 1170650000 : ROSE_ASSERT(this != NULL);
18421 1170650000 : return V_Sg_File_Info;
18422 : }
18423 :
18424 : #if 0
18425 : int
18426 : Sg_File_Info::variant() const
18427 : {
18428 : // This function is used in SAGE
18429 : ROSE_ASSERT(this != NULL);
18430 : return _File_InfoTag;
18431 : }
18432 : #endif
18433 :
18434 : ROSE_DLL_API const char*
18435 0 : Sg_File_Info::sage_class_name() const
18436 : {
18437 0 : ROSE_ASSERT(this != NULL);
18438 0 : return "Sg_File_Info";
18439 : }
18440 :
18441 : std::string
18442 36766900 : Sg_File_Info::class_name() const
18443 : {
18444 36766900 : ROSE_ASSERT(this != NULL);
18445 36766900 : return "Sg_File_Info";
18446 : }
18447 :
18448 : // DQ (11/26/2005): Support for visitor pattern mechanims
18449 : // (inferior to ROSE traversal mechanism, experimental).
18450 : void
18451 70392000 : Sg_File_Info::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
18452 : {
18453 70392000 : ROSE_ASSERT(this != NULL);
18454 70392000 : visitor.visit(this);
18455 70392000 : }
18456 :
18457 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
18458 0 : void Sg_File_Info::accept (ROSE_VisitorPattern & visitor) {
18459 0 : ROSE_ASSERT(this != NULL);
18460 0 : visitor.visit(this);
18461 0 : }
18462 :
18463 : Sg_File_Info*
18464 0 : Sg_File_Info::addRegExpAttribute(std::string s, AstRegExAttribute* a)
18465 : {
18466 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
18467 : // This function is currently only supported for the AST used the represent Binary executables.
18468 : if (0 /* isSgAsmNode(this) != NULL */)
18469 : {
18470 : // Support for regex specification.
18471 : std::string prefixCode = "REGEX:";
18472 : addNewAttribute(prefixCode + s,a);
18473 : }
18474 : #endif
18475 :
18476 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
18477 0 : return this;
18478 : }
18479 :
18480 : // *** COMMON CODE SECTION ENDS HERE ***
18481 :
18482 :
18483 : // End of memberFunctionString
18484 : // Start of memberFunctionString
18485 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
18486 :
18487 :
18488 : #if 0
18489 : //! Error checking support
18490 : /*! Verifies the following:
18491 : - working getVariant() member function
18492 : - calls base class's error() member function
18493 : Every class has one of these functions.
18494 : */
18495 : bool
18496 : Sg_File_Info::error()
18497 : {
18498 : // Put error checking here
18499 :
18500 : ROSE_ASSERT (this != NULL);
18501 : if (getVariant() != _File_InfoTag)
18502 : {
18503 : printf ("Error in Sg_File_Info::error(): Sg_File_Info object has a %s variant \n",
18504 : Cxx_GrammarTerminalNames[getVariant()].name);
18505 : // printf ("Error in Sg_File_Info::error() \n");
18506 : ROSE_ABORT();
18507 : }
18508 :
18509 : ROSE_ASSERT (getVariant() == _File_InfoTag);
18510 : return SgSupport::error();
18511 : }
18512 : #endif
18513 :
18514 :
18515 :
18516 : // End of memberFunctionString
18517 :
18518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
18519 :
18520 30846000 : Sg_File_Info* isSg_File_Info ( SgNode* inputDerivedClassPointer )
18521 : {
18522 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
18523 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
18524 : // So to fix this we return NULL directly when the input is NULL and avoid the
18525 : // dynamic_cast in this case. This is likely a performance improvement as well.
18526 : // return dynamic_cast<Sg_File_Info*>(inputDerivedClassPointer);
18527 : // Milind Chabbi (8/28/2013): isSg_File_Info uses table-driven castability instead of c++ default dynamic_cast
18528 : // this improves the running time performance by 10-20%.
18529 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<Sg_File_Info*>(inputDerivedClassPointer);
18530 30846000 : return IS_Sg_File_Info_FAST_MACRO(inputDerivedClassPointer);
18531 : }
18532 :
18533 : // DQ (11/8/2003): Added version of functions taking const pointer
18534 0 : const Sg_File_Info* isSg_File_Info ( const SgNode* inputDerivedClassPointer )
18535 : {
18536 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
18537 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
18538 : // So to fix this we return NULL directly when the input is NULL and avoid the
18539 : // dynamic_cast in this case. This is likely a performance improvement as well.
18540 : // return dynamic_cast<const Sg_File_Info*>(inputDerivedClassPointer);
18541 : // Milind Chabbi (8/28/2013): isSg_File_Info uses table-driven castability instead of c++ default dynamic_cast
18542 : // this improves the running time performance by 10-20%.
18543 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const Sg_File_Info*>(inputDerivedClassPointer);
18544 0 : return IS_Sg_File_Info_FAST_MACRO(inputDerivedClassPointer);
18545 : }
18546 :
18547 :
18548 :
18549 : /* #line 18550 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
18550 :
18551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
18552 :
18553 : /**
18554 : \brief Generated destructor
18555 :
18556 : This destructor is automatically generated (by ROSETTA). This destructor
18557 : only frees memory of data members associated with the parts of the current IR node which
18558 : are NOT traversed. Those data members that are part of a traversal can be freed using
18559 : a traversal (calling this destructor on all children in a post-order traversal). Such
18560 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
18561 :
18562 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
18563 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
18564 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
18565 :
18566 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
18567 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
18568 : pointers are not yet implemented to call delete on eash pointer in the container.
18569 : (This could be done by derivation from the STL containers to define containers that
18570 : automatically deleted their members.)
18571 :
18572 : */
18573 51189400 : Sg_File_Info::~Sg_File_Info () {
18574 25591200 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
18575 :
18576 :
18577 : // case: not a listType for file_id
18578 25591200 : p_file_id = NULL_FILE_ID; // non list case
18579 : // case: not a listType for line
18580 25591200 : p_line = 0; // non list case
18581 : // case: not a listType for col
18582 25591200 : p_col = 0; // non list case
18583 : // case: not a listType for classificationBitField
18584 25591200 : p_classificationBitField = 0; // non list case
18585 : // case: not a listType for physical_file_id
18586 25591200 : p_physical_file_id = NULL_FILE_ID; // non list case
18587 : // case: not a listType for physical_line
18588 25591200 : p_physical_line = 0; // non list case
18589 : // case: not a listType for source_sequence_number
18590 25591200 : p_source_sequence_number = 0; // non list case
18591 :
18592 : }
18593 :
18594 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
18595 51182400 : }
18596 :
18597 :
18598 : /* #line 18599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
18599 :
18600 :
18601 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
18602 :
18603 :
18604 : // ********************************************************
18605 : // member functions common across all array grammar objects
18606 : // ********************************************************
18607 :
18608 :
18609 :
18610 : /* #line 18611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
18611 :
18612 :
18613 :
18614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
18615 :
18616 : // ********************************************************
18617 : // member functions specific to each node in the grammar
18618 : // ********************************************************
18619 :
18620 :
18621 : /* #line 18622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
18622 :
18623 : // Start of memberFunctionString
18624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
18625 :
18626 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18627 :
18628 : Sg_File_Info*
18629 6441110 : SgFile::get_startOfConstruct () const
18630 : {
18631 6441110 : ROSE_ASSERT (this != NULL);
18632 :
18633 : #if 0
18634 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18635 : // used to trigger marking transformations for the token-based unparsing.
18636 : printf ("SgFile::get_startOfConstruct = %p = %s \n",this,this->class_name().c_str());
18637 : #endif
18638 :
18639 6441110 : return p_startOfConstruct;
18640 : }
18641 :
18642 : void
18643 11254 : SgFile::set_startOfConstruct ( Sg_File_Info* startOfConstruct )
18644 : {
18645 11254 : ROSE_ASSERT (this != NULL);
18646 :
18647 : #if 0
18648 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18649 : // used to trigger marking transformations for the token-based unparsing.
18650 : printf ("SgFile::set_startOfConstruct = %p = %s \n",this,this->class_name().c_str());
18651 : #endif
18652 :
18653 11254 : set_isModified(true);
18654 :
18655 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
18656 : if (p_startOfConstruct != NULL && startOfConstruct != NULL && p_startOfConstruct != startOfConstruct)
18657 : {
18658 : printf ("Warning: startOfConstruct = %p overwriting valid pointer p_startOfConstruct = %p \n",startOfConstruct,p_startOfConstruct);
18659 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
18660 : printf ("Error fails assertion (p_startOfConstruct != NULL && startOfConstruct != NULL && p_startOfConstruct != startOfConstruct) is false\n");
18661 : ROSE_ASSERT(false);
18662 : #endif
18663 : }
18664 : #endif
18665 11254 : p_startOfConstruct = startOfConstruct;
18666 11254 : }
18667 :
18668 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18669 :
18670 :
18671 : // End of memberFunctionString
18672 : // Start of memberFunctionString
18673 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
18674 :
18675 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18676 :
18677 : SgStringList
18678 704 : SgFile::get_originalCommandLineArgumentList () const
18679 : {
18680 704 : ROSE_ASSERT (this != NULL);
18681 :
18682 : #if 0
18683 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18684 : // used to trigger marking transformations for the token-based unparsing.
18685 : printf ("SgFile::get_originalCommandLineArgumentList = %p = %s \n",this,this->class_name().c_str());
18686 : #endif
18687 :
18688 704 : return p_originalCommandLineArgumentList;
18689 : }
18690 :
18691 : void
18692 357 : SgFile::set_originalCommandLineArgumentList ( SgStringList originalCommandLineArgumentList )
18693 : {
18694 357 : ROSE_ASSERT (this != NULL);
18695 :
18696 : #if 0
18697 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18698 : // used to trigger marking transformations for the token-based unparsing.
18699 : printf ("SgFile::set_originalCommandLineArgumentList = %p = %s \n",this,this->class_name().c_str());
18700 : #endif
18701 :
18702 357 : set_isModified(true);
18703 :
18704 357 : p_originalCommandLineArgumentList = originalCommandLineArgumentList;
18705 357 : }
18706 :
18707 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18708 :
18709 :
18710 : // End of memberFunctionString
18711 : // Start of memberFunctionString
18712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18713 :
18714 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18715 :
18716 : int
18717 2678 : SgFile::get_verbose () const
18718 : {
18719 2678 : ROSE_ASSERT (this != NULL);
18720 2678 : return p_verbose;
18721 : }
18722 :
18723 : void
18724 319 : SgFile::set_verbose ( int verbose )
18725 : {
18726 319 : ROSE_ASSERT (this != NULL);
18727 :
18728 319 : p_verbose = verbose;
18729 319 : }
18730 :
18731 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18732 :
18733 :
18734 : // End of memberFunctionString
18735 : // Start of memberFunctionString
18736 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18737 :
18738 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18739 :
18740 : bool
18741 394 : SgFile::get_output_warnings () const
18742 : {
18743 394 : ROSE_ASSERT (this != NULL);
18744 394 : return p_output_warnings;
18745 : }
18746 :
18747 : void
18748 357 : SgFile::set_output_warnings ( bool output_warnings )
18749 : {
18750 357 : ROSE_ASSERT (this != NULL);
18751 :
18752 357 : p_output_warnings = output_warnings;
18753 357 : }
18754 :
18755 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18756 :
18757 :
18758 : // End of memberFunctionString
18759 : // Start of memberFunctionString
18760 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18761 :
18762 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18763 :
18764 : bool
18765 33873 : SgFile::get_C_only () const
18766 : {
18767 33873 : ROSE_ASSERT (this != NULL);
18768 33873 : return p_C_only;
18769 : }
18770 :
18771 : void
18772 11435 : SgFile::set_C_only ( bool C_only )
18773 : {
18774 11435 : ROSE_ASSERT (this != NULL);
18775 :
18776 11435 : p_C_only = C_only;
18777 11435 : }
18778 :
18779 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18780 :
18781 :
18782 : // End of memberFunctionString
18783 : // Start of memberFunctionString
18784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18785 :
18786 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18787 :
18788 : bool
18789 1162900 : SgFile::get_Cxx_only () const
18790 : {
18791 1162900 : ROSE_ASSERT (this != NULL);
18792 1162900 : return p_Cxx_only;
18793 : }
18794 :
18795 : void
18796 11246 : SgFile::set_Cxx_only ( bool Cxx_only )
18797 : {
18798 11246 : ROSE_ASSERT (this != NULL);
18799 :
18800 11246 : p_Cxx_only = Cxx_only;
18801 11246 : }
18802 :
18803 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18804 :
18805 :
18806 : // End of memberFunctionString
18807 : // Start of memberFunctionString
18808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18809 :
18810 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18811 :
18812 : bool
18813 6062060 : SgFile::get_Fortran_only () const
18814 : {
18815 6062060 : ROSE_ASSERT (this != NULL);
18816 6062060 : return p_Fortran_only;
18817 : }
18818 :
18819 : void
18820 75 : SgFile::set_Fortran_only ( bool Fortran_only )
18821 : {
18822 75 : ROSE_ASSERT (this != NULL);
18823 :
18824 75 : p_Fortran_only = Fortran_only;
18825 75 : }
18826 :
18827 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18828 :
18829 :
18830 : // End of memberFunctionString
18831 : // Start of memberFunctionString
18832 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18833 :
18834 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18835 :
18836 : bool
18837 60587 : SgFile::get_CoArrayFortran_only () const
18838 : {
18839 60587 : ROSE_ASSERT (this != NULL);
18840 60587 : return p_CoArrayFortran_only;
18841 : }
18842 :
18843 : void
18844 0 : SgFile::set_CoArrayFortran_only ( bool CoArrayFortran_only )
18845 : {
18846 0 : ROSE_ASSERT (this != NULL);
18847 :
18848 0 : p_CoArrayFortran_only = CoArrayFortran_only;
18849 0 : }
18850 :
18851 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18852 :
18853 :
18854 : // End of memberFunctionString
18855 : // Start of memberFunctionString
18856 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
18857 :
18858 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18859 :
18860 : int
18861 320 : SgFile::get_upc_threads () const
18862 : {
18863 320 : ROSE_ASSERT (this != NULL);
18864 :
18865 : #if 0
18866 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18867 : // used to trigger marking transformations for the token-based unparsing.
18868 : printf ("SgFile::get_upc_threads = %p = %s \n",this,this->class_name().c_str());
18869 : #endif
18870 :
18871 320 : return p_upc_threads;
18872 : }
18873 :
18874 : void
18875 3 : SgFile::set_upc_threads ( int upc_threads )
18876 : {
18877 3 : ROSE_ASSERT (this != NULL);
18878 :
18879 : #if 0
18880 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18881 : // used to trigger marking transformations for the token-based unparsing.
18882 : printf ("SgFile::set_upc_threads = %p = %s \n",this,this->class_name().c_str());
18883 : #endif
18884 :
18885 3 : set_isModified(true);
18886 :
18887 3 : p_upc_threads = upc_threads;
18888 3 : }
18889 :
18890 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18891 :
18892 :
18893 : // End of memberFunctionString
18894 : // Start of memberFunctionString
18895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18896 :
18897 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18898 :
18899 : bool
18900 923 : SgFile::get_Cuda_only () const
18901 : {
18902 923 : ROSE_ASSERT (this != NULL);
18903 923 : return p_Cuda_only;
18904 : }
18905 :
18906 : void
18907 0 : SgFile::set_Cuda_only ( bool Cuda_only )
18908 : {
18909 0 : ROSE_ASSERT (this != NULL);
18910 :
18911 0 : p_Cuda_only = Cuda_only;
18912 0 : }
18913 :
18914 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18915 :
18916 :
18917 : // End of memberFunctionString
18918 : // Start of memberFunctionString
18919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18920 :
18921 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18922 :
18923 : bool
18924 610 : SgFile::get_OpenCL_only () const
18925 : {
18926 610 : ROSE_ASSERT (this != NULL);
18927 610 : return p_OpenCL_only;
18928 : }
18929 :
18930 : void
18931 0 : SgFile::set_OpenCL_only ( bool OpenCL_only )
18932 : {
18933 0 : ROSE_ASSERT (this != NULL);
18934 :
18935 0 : p_OpenCL_only = OpenCL_only;
18936 0 : }
18937 :
18938 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18939 :
18940 :
18941 : // End of memberFunctionString
18942 : // Start of memberFunctionString
18943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
18944 :
18945 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18946 :
18947 : bool
18948 16562500 : SgFile::get_requires_C_preprocessor () const
18949 : {
18950 16562500 : ROSE_ASSERT (this != NULL);
18951 16562500 : return p_requires_C_preprocessor;
18952 : }
18953 :
18954 : void
18955 10934 : SgFile::set_requires_C_preprocessor ( bool requires_C_preprocessor )
18956 : {
18957 10934 : ROSE_ASSERT (this != NULL);
18958 :
18959 10934 : p_requires_C_preprocessor = requires_C_preprocessor;
18960 10934 : }
18961 :
18962 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
18963 :
18964 :
18965 : // End of memberFunctionString
18966 : // Start of memberFunctionString
18967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
18968 :
18969 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
18970 :
18971 : SgFile::outputFormatOption_enum
18972 423 : SgFile::get_inputFormat () const
18973 : {
18974 423 : ROSE_ASSERT (this != NULL);
18975 :
18976 : #if 0
18977 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18978 : // used to trigger marking transformations for the token-based unparsing.
18979 : printf ("SgFile::get_inputFormat = %p = %s \n",this,this->class_name().c_str());
18980 : #endif
18981 :
18982 423 : return p_inputFormat;
18983 : }
18984 :
18985 : void
18986 357 : SgFile::set_inputFormat ( SgFile::outputFormatOption_enum inputFormat )
18987 : {
18988 357 : ROSE_ASSERT (this != NULL);
18989 :
18990 : #if 0
18991 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
18992 : // used to trigger marking transformations for the token-based unparsing.
18993 : printf ("SgFile::set_inputFormat = %p = %s \n",this,this->class_name().c_str());
18994 : #endif
18995 :
18996 357 : set_isModified(true);
18997 :
18998 357 : p_inputFormat = inputFormat;
18999 357 : }
19000 :
19001 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19002 :
19003 :
19004 : // End of memberFunctionString
19005 : // Start of memberFunctionString
19006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
19007 :
19008 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19009 :
19010 : SgFile::outputFormatOption_enum
19011 832 : SgFile::get_outputFormat () const
19012 : {
19013 832 : ROSE_ASSERT (this != NULL);
19014 :
19015 : #if 0
19016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19017 : // used to trigger marking transformations for the token-based unparsing.
19018 : printf ("SgFile::get_outputFormat = %p = %s \n",this,this->class_name().c_str());
19019 : #endif
19020 :
19021 832 : return p_outputFormat;
19022 : }
19023 :
19024 : void
19025 394 : SgFile::set_outputFormat ( SgFile::outputFormatOption_enum outputFormat )
19026 : {
19027 394 : ROSE_ASSERT (this != NULL);
19028 :
19029 : #if 0
19030 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19031 : // used to trigger marking transformations for the token-based unparsing.
19032 : printf ("SgFile::set_outputFormat = %p = %s \n",this,this->class_name().c_str());
19033 : #endif
19034 :
19035 394 : set_isModified(true);
19036 :
19037 394 : p_outputFormat = outputFormat;
19038 394 : }
19039 :
19040 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19041 :
19042 :
19043 : // End of memberFunctionString
19044 : // Start of memberFunctionString
19045 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
19046 :
19047 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19048 :
19049 : SgFile::outputFormatOption_enum
19050 43 : SgFile::get_backendCompileFormat () const
19051 : {
19052 43 : ROSE_ASSERT (this != NULL);
19053 :
19054 : #if 0
19055 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19056 : // used to trigger marking transformations for the token-based unparsing.
19057 : printf ("SgFile::get_backendCompileFormat = %p = %s \n",this,this->class_name().c_str());
19058 : #endif
19059 :
19060 43 : return p_backendCompileFormat;
19061 : }
19062 :
19063 : void
19064 394 : SgFile::set_backendCompileFormat ( SgFile::outputFormatOption_enum backendCompileFormat )
19065 : {
19066 394 : ROSE_ASSERT (this != NULL);
19067 :
19068 : #if 0
19069 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19070 : // used to trigger marking transformations for the token-based unparsing.
19071 : printf ("SgFile::set_backendCompileFormat = %p = %s \n",this,this->class_name().c_str());
19072 : #endif
19073 :
19074 394 : set_isModified(true);
19075 :
19076 394 : p_backendCompileFormat = backendCompileFormat;
19077 394 : }
19078 :
19079 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19080 :
19081 :
19082 : // End of memberFunctionString
19083 : // Start of memberFunctionString
19084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19085 :
19086 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19087 :
19088 : bool
19089 357 : SgFile::get_fortran_implicit_none () const
19090 : {
19091 357 : ROSE_ASSERT (this != NULL);
19092 357 : return p_fortran_implicit_none;
19093 : }
19094 :
19095 : void
19096 357 : SgFile::set_fortran_implicit_none ( bool fortran_implicit_none )
19097 : {
19098 357 : ROSE_ASSERT (this != NULL);
19099 :
19100 357 : p_fortran_implicit_none = fortran_implicit_none;
19101 357 : }
19102 :
19103 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19104 :
19105 :
19106 : // End of memberFunctionString
19107 : // Start of memberFunctionString
19108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19109 :
19110 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19111 :
19112 : bool
19113 1345 : SgFile::get_openmp () const
19114 : {
19115 1345 : ROSE_ASSERT (this != NULL);
19116 1345 : return p_openmp;
19117 : }
19118 :
19119 : void
19120 645 : SgFile::set_openmp ( bool openmp )
19121 : {
19122 645 : ROSE_ASSERT (this != NULL);
19123 :
19124 645 : p_openmp = openmp;
19125 645 : }
19126 :
19127 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19128 :
19129 :
19130 : // End of memberFunctionString
19131 : // Start of memberFunctionString
19132 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19133 :
19134 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19135 :
19136 : bool
19137 645 : SgFile::get_openmp_parse_only () const
19138 : {
19139 645 : ROSE_ASSERT (this != NULL);
19140 645 : return p_openmp_parse_only;
19141 : }
19142 :
19143 : void
19144 288 : SgFile::set_openmp_parse_only ( bool openmp_parse_only )
19145 : {
19146 288 : ROSE_ASSERT (this != NULL);
19147 :
19148 288 : p_openmp_parse_only = openmp_parse_only;
19149 288 : }
19150 :
19151 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19152 :
19153 :
19154 : // End of memberFunctionString
19155 : // Start of memberFunctionString
19156 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19157 :
19158 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19159 :
19160 : bool
19161 645 : SgFile::get_openmp_ast_only () const
19162 : {
19163 645 : ROSE_ASSERT (this != NULL);
19164 645 : return p_openmp_ast_only;
19165 : }
19166 :
19167 : void
19168 288 : SgFile::set_openmp_ast_only ( bool openmp_ast_only )
19169 : {
19170 288 : ROSE_ASSERT (this != NULL);
19171 :
19172 288 : p_openmp_ast_only = openmp_ast_only;
19173 288 : }
19174 :
19175 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19176 :
19177 :
19178 : // End of memberFunctionString
19179 : // Start of memberFunctionString
19180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19181 :
19182 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19183 :
19184 : bool
19185 1051 : SgFile::get_openmp_lowering () const
19186 : {
19187 1051 : ROSE_ASSERT (this != NULL);
19188 1051 : return p_openmp_lowering;
19189 : }
19190 :
19191 : void
19192 0 : SgFile::set_openmp_lowering ( bool openmp_lowering )
19193 : {
19194 0 : ROSE_ASSERT (this != NULL);
19195 :
19196 0 : p_openmp_lowering = openmp_lowering;
19197 0 : }
19198 :
19199 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19200 :
19201 :
19202 : // End of memberFunctionString
19203 : // Start of memberFunctionString
19204 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19205 :
19206 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19207 :
19208 : bool
19209 0 : SgFile::get_openmp_analyzing () const
19210 : {
19211 0 : ROSE_ASSERT (this != NULL);
19212 0 : return p_openmp_analyzing;
19213 : }
19214 :
19215 : void
19216 0 : SgFile::set_openmp_analyzing ( bool openmp_analyzing )
19217 : {
19218 0 : ROSE_ASSERT (this != NULL);
19219 :
19220 0 : p_openmp_analyzing = openmp_analyzing;
19221 0 : }
19222 :
19223 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19224 :
19225 :
19226 : // End of memberFunctionString
19227 : // Start of memberFunctionString
19228 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19229 :
19230 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19231 :
19232 : bool
19233 394 : SgFile::get_cray_pointer_support () const
19234 : {
19235 394 : ROSE_ASSERT (this != NULL);
19236 394 : return p_cray_pointer_support;
19237 : }
19238 :
19239 : void
19240 357 : SgFile::set_cray_pointer_support ( bool cray_pointer_support )
19241 : {
19242 357 : ROSE_ASSERT (this != NULL);
19243 :
19244 357 : p_cray_pointer_support = cray_pointer_support;
19245 357 : }
19246 :
19247 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19248 :
19249 :
19250 : // End of memberFunctionString
19251 : // Start of memberFunctionString
19252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19253 :
19254 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19255 :
19256 : bool
19257 357 : SgFile::get_failsafe () const
19258 : {
19259 357 : ROSE_ASSERT (this != NULL);
19260 357 : return p_failsafe;
19261 : }
19262 :
19263 : void
19264 357 : SgFile::set_failsafe ( bool failsafe )
19265 : {
19266 357 : ROSE_ASSERT (this != NULL);
19267 :
19268 357 : p_failsafe = failsafe;
19269 357 : }
19270 :
19271 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19272 :
19273 :
19274 : // End of memberFunctionString
19275 : // Start of memberFunctionString
19276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19277 :
19278 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19279 :
19280 : bool
19281 394 : SgFile::get_output_parser_actions () const
19282 : {
19283 394 : ROSE_ASSERT (this != NULL);
19284 394 : return p_output_parser_actions;
19285 : }
19286 :
19287 : void
19288 357 : SgFile::set_output_parser_actions ( bool output_parser_actions )
19289 : {
19290 357 : ROSE_ASSERT (this != NULL);
19291 :
19292 357 : p_output_parser_actions = output_parser_actions;
19293 357 : }
19294 :
19295 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19296 :
19297 :
19298 : // End of memberFunctionString
19299 : // Start of memberFunctionString
19300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19301 :
19302 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19303 :
19304 : bool
19305 1071 : SgFile::get_exit_after_parser () const
19306 : {
19307 1071 : ROSE_ASSERT (this != NULL);
19308 1071 : return p_exit_after_parser;
19309 : }
19310 :
19311 : void
19312 357 : SgFile::set_exit_after_parser ( bool exit_after_parser )
19313 : {
19314 357 : ROSE_ASSERT (this != NULL);
19315 :
19316 357 : p_exit_after_parser = exit_after_parser;
19317 357 : }
19318 :
19319 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19320 :
19321 :
19322 : // End of memberFunctionString
19323 : // Start of memberFunctionString
19324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19325 :
19326 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19327 :
19328 : bool
19329 394 : SgFile::get_skip_syntax_check () const
19330 : {
19331 394 : ROSE_ASSERT (this != NULL);
19332 394 : return p_skip_syntax_check;
19333 : }
19334 :
19335 : void
19336 357 : SgFile::set_skip_syntax_check ( bool skip_syntax_check )
19337 : {
19338 357 : ROSE_ASSERT (this != NULL);
19339 :
19340 357 : p_skip_syntax_check = skip_syntax_check;
19341 357 : }
19342 :
19343 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19344 :
19345 :
19346 : // End of memberFunctionString
19347 : // Start of memberFunctionString
19348 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19349 :
19350 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19351 :
19352 : bool
19353 357 : SgFile::get_skip_parser () const
19354 : {
19355 357 : ROSE_ASSERT (this != NULL);
19356 357 : return p_skip_parser;
19357 : }
19358 :
19359 : void
19360 0 : SgFile::set_skip_parser ( bool skip_parser )
19361 : {
19362 0 : ROSE_ASSERT (this != NULL);
19363 :
19364 0 : p_skip_parser = skip_parser;
19365 0 : }
19366 :
19367 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19368 :
19369 :
19370 : // End of memberFunctionString
19371 : // Start of memberFunctionString
19372 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19373 :
19374 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19375 :
19376 : bool
19377 394 : SgFile::get_relax_syntax_check () const
19378 : {
19379 394 : ROSE_ASSERT (this != NULL);
19380 394 : return p_relax_syntax_check;
19381 : }
19382 :
19383 : void
19384 357 : SgFile::set_relax_syntax_check ( bool relax_syntax_check )
19385 : {
19386 357 : ROSE_ASSERT (this != NULL);
19387 :
19388 357 : p_relax_syntax_check = relax_syntax_check;
19389 357 : }
19390 :
19391 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19392 :
19393 :
19394 : // End of memberFunctionString
19395 : // Start of memberFunctionString
19396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19397 :
19398 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19399 :
19400 : bool
19401 320 : SgFile::get_skip_translation_from_edg_ast_to_rose_ast () const
19402 : {
19403 320 : ROSE_ASSERT (this != NULL);
19404 320 : return p_skip_translation_from_edg_ast_to_rose_ast;
19405 : }
19406 :
19407 : void
19408 0 : SgFile::set_skip_translation_from_edg_ast_to_rose_ast ( bool skip_translation_from_edg_ast_to_rose_ast )
19409 : {
19410 0 : ROSE_ASSERT (this != NULL);
19411 :
19412 0 : p_skip_translation_from_edg_ast_to_rose_ast = skip_translation_from_edg_ast_to_rose_ast;
19413 0 : }
19414 :
19415 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19416 :
19417 :
19418 : // End of memberFunctionString
19419 : // Start of memberFunctionString
19420 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19421 :
19422 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19423 :
19424 : bool
19425 0 : SgFile::get_skip_transformation () const
19426 : {
19427 0 : ROSE_ASSERT (this != NULL);
19428 0 : return p_skip_transformation;
19429 : }
19430 :
19431 : void
19432 0 : SgFile::set_skip_transformation ( bool skip_transformation )
19433 : {
19434 0 : ROSE_ASSERT (this != NULL);
19435 :
19436 0 : p_skip_transformation = skip_transformation;
19437 0 : }
19438 :
19439 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19440 :
19441 :
19442 : // End of memberFunctionString
19443 : // Start of memberFunctionString
19444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19445 :
19446 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19447 :
19448 : bool
19449 1765 : SgFile::get_skip_unparse () const
19450 : {
19451 1765 : ROSE_ASSERT (this != NULL);
19452 1765 : return p_skip_unparse;
19453 : }
19454 :
19455 : void
19456 0 : SgFile::set_skip_unparse ( bool skip_unparse )
19457 : {
19458 0 : ROSE_ASSERT (this != NULL);
19459 :
19460 0 : p_skip_unparse = skip_unparse;
19461 0 : }
19462 :
19463 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19464 :
19465 :
19466 : // End of memberFunctionString
19467 : // Start of memberFunctionString
19468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19469 :
19470 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19471 :
19472 : bool
19473 357 : SgFile::get_skipfinalCompileStep () const
19474 : {
19475 357 : ROSE_ASSERT (this != NULL);
19476 357 : return p_skipfinalCompileStep;
19477 : }
19478 :
19479 : void
19480 17 : SgFile::set_skipfinalCompileStep ( bool skipfinalCompileStep )
19481 : {
19482 17 : ROSE_ASSERT (this != NULL);
19483 :
19484 17 : p_skipfinalCompileStep = skipfinalCompileStep;
19485 17 : }
19486 :
19487 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19488 :
19489 :
19490 : // End of memberFunctionString
19491 : // Start of memberFunctionString
19492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19493 :
19494 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19495 :
19496 : bool
19497 356 : SgFile::get_unparse_includes () const
19498 : {
19499 356 : ROSE_ASSERT (this != NULL);
19500 356 : return p_unparse_includes;
19501 : }
19502 :
19503 : void
19504 0 : SgFile::set_unparse_includes ( bool unparse_includes )
19505 : {
19506 0 : ROSE_ASSERT (this != NULL);
19507 :
19508 0 : p_unparse_includes = unparse_includes;
19509 0 : }
19510 :
19511 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19512 :
19513 :
19514 : // End of memberFunctionString
19515 : // Start of memberFunctionString
19516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19517 :
19518 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19519 :
19520 : bool
19521 356 : SgFile::get_unparse_line_directives () const
19522 : {
19523 356 : ROSE_ASSERT (this != NULL);
19524 356 : return p_unparse_line_directives;
19525 : }
19526 :
19527 : void
19528 0 : SgFile::set_unparse_line_directives ( bool unparse_line_directives )
19529 : {
19530 0 : ROSE_ASSERT (this != NULL);
19531 :
19532 0 : p_unparse_line_directives = unparse_line_directives;
19533 0 : }
19534 :
19535 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19536 :
19537 :
19538 : // End of memberFunctionString
19539 : // Start of memberFunctionString
19540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19541 :
19542 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19543 :
19544 : bool
19545 320 : SgFile::get_unparse_function_calls_using_operator_syntax () const
19546 : {
19547 320 : ROSE_ASSERT (this != NULL);
19548 320 : return p_unparse_function_calls_using_operator_syntax;
19549 : }
19550 :
19551 : void
19552 0 : SgFile::set_unparse_function_calls_using_operator_syntax ( bool unparse_function_calls_using_operator_syntax )
19553 : {
19554 0 : ROSE_ASSERT (this != NULL);
19555 :
19556 0 : p_unparse_function_calls_using_operator_syntax = unparse_function_calls_using_operator_syntax;
19557 0 : }
19558 :
19559 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19560 :
19561 :
19562 : // End of memberFunctionString
19563 : // Start of memberFunctionString
19564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19565 :
19566 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19567 :
19568 : bool
19569 320 : SgFile::get_unparse_function_calls_using_operator_names () const
19570 : {
19571 320 : ROSE_ASSERT (this != NULL);
19572 320 : return p_unparse_function_calls_using_operator_names;
19573 : }
19574 :
19575 : void
19576 0 : SgFile::set_unparse_function_calls_using_operator_names ( bool unparse_function_calls_using_operator_names )
19577 : {
19578 0 : ROSE_ASSERT (this != NULL);
19579 :
19580 0 : p_unparse_function_calls_using_operator_names = unparse_function_calls_using_operator_names;
19581 0 : }
19582 :
19583 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19584 :
19585 :
19586 : // End of memberFunctionString
19587 : // Start of memberFunctionString
19588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19589 :
19590 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19591 :
19592 : bool
19593 0 : SgFile::get_unparse_instruction_addresses () const
19594 : {
19595 0 : ROSE_ASSERT (this != NULL);
19596 0 : return p_unparse_instruction_addresses;
19597 : }
19598 :
19599 : void
19600 0 : SgFile::set_unparse_instruction_addresses ( bool unparse_instruction_addresses )
19601 : {
19602 0 : ROSE_ASSERT (this != NULL);
19603 :
19604 0 : p_unparse_instruction_addresses = unparse_instruction_addresses;
19605 0 : }
19606 :
19607 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19608 :
19609 :
19610 : // End of memberFunctionString
19611 : // Start of memberFunctionString
19612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19613 :
19614 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19615 :
19616 : bool
19617 0 : SgFile::get_unparse_raw_memory_contents () const
19618 : {
19619 0 : ROSE_ASSERT (this != NULL);
19620 0 : return p_unparse_raw_memory_contents;
19621 : }
19622 :
19623 : void
19624 0 : SgFile::set_unparse_raw_memory_contents ( bool unparse_raw_memory_contents )
19625 : {
19626 0 : ROSE_ASSERT (this != NULL);
19627 :
19628 0 : p_unparse_raw_memory_contents = unparse_raw_memory_contents;
19629 0 : }
19630 :
19631 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19632 :
19633 :
19634 : // End of memberFunctionString
19635 : // Start of memberFunctionString
19636 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19637 :
19638 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19639 :
19640 : bool
19641 0 : SgFile::get_unparse_binary_file_format () const
19642 : {
19643 0 : ROSE_ASSERT (this != NULL);
19644 0 : return p_unparse_binary_file_format;
19645 : }
19646 :
19647 : void
19648 0 : SgFile::set_unparse_binary_file_format ( bool unparse_binary_file_format )
19649 : {
19650 0 : ROSE_ASSERT (this != NULL);
19651 :
19652 0 : p_unparse_binary_file_format = unparse_binary_file_format;
19653 0 : }
19654 :
19655 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19656 :
19657 :
19658 : // End of memberFunctionString
19659 : // Start of memberFunctionString
19660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
19661 :
19662 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19663 :
19664 : SgFile::languageOption_enum
19665 5020 : SgFile::get_outputLanguage () const
19666 : {
19667 5020 : ROSE_ASSERT (this != NULL);
19668 :
19669 : #if 0
19670 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19671 : // used to trigger marking transformations for the token-based unparsing.
19672 : printf ("SgFile::get_outputLanguage = %p = %s \n",this,this->class_name().c_str());
19673 : #endif
19674 :
19675 5020 : return p_outputLanguage;
19676 : }
19677 :
19678 : void
19679 357 : SgFile::set_outputLanguage ( SgFile::languageOption_enum outputLanguage )
19680 : {
19681 357 : ROSE_ASSERT (this != NULL);
19682 :
19683 : #if 0
19684 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19685 : // used to trigger marking transformations for the token-based unparsing.
19686 : printf ("SgFile::set_outputLanguage = %p = %s \n",this,this->class_name().c_str());
19687 : #endif
19688 :
19689 357 : set_isModified(true);
19690 :
19691 357 : p_outputLanguage = outputLanguage;
19692 357 : }
19693 :
19694 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19695 :
19696 :
19697 : // End of memberFunctionString
19698 : // Start of memberFunctionString
19699 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
19700 :
19701 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19702 :
19703 : SgFile::languageOption_enum
19704 1050 : SgFile::get_inputLanguage () const
19705 : {
19706 1050 : ROSE_ASSERT (this != NULL);
19707 :
19708 : #if 0
19709 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19710 : // used to trigger marking transformations for the token-based unparsing.
19711 : printf ("SgFile::get_inputLanguage = %p = %s \n",this,this->class_name().c_str());
19712 : #endif
19713 :
19714 1050 : return p_inputLanguage;
19715 : }
19716 :
19717 : void
19718 357 : SgFile::set_inputLanguage ( SgFile::languageOption_enum inputLanguage )
19719 : {
19720 357 : ROSE_ASSERT (this != NULL);
19721 :
19722 : #if 0
19723 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19724 : // used to trigger marking transformations for the token-based unparsing.
19725 : printf ("SgFile::set_inputLanguage = %p = %s \n",this,this->class_name().c_str());
19726 : #endif
19727 :
19728 357 : set_isModified(true);
19729 :
19730 357 : p_inputLanguage = inputLanguage;
19731 357 : }
19732 :
19733 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19734 :
19735 :
19736 : // End of memberFunctionString
19737 : // Start of memberFunctionString
19738 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19739 :
19740 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19741 :
19742 : std::string
19743 4586 : SgFile::get_sourceFileNameWithPath () const
19744 : {
19745 4586 : ROSE_ASSERT (this != NULL);
19746 4586 : return p_sourceFileNameWithPath;
19747 : }
19748 :
19749 : void
19750 11254 : SgFile::set_sourceFileNameWithPath ( std::string sourceFileNameWithPath )
19751 : {
19752 11254 : ROSE_ASSERT (this != NULL);
19753 :
19754 11254 : p_sourceFileNameWithPath = sourceFileNameWithPath;
19755 11254 : }
19756 :
19757 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19758 :
19759 :
19760 : // End of memberFunctionString
19761 : // Start of memberFunctionString
19762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19763 :
19764 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19765 :
19766 : std::string
19767 663 : SgFile::get_sourceFileNameWithoutPath () const
19768 : {
19769 663 : ROSE_ASSERT (this != NULL);
19770 663 : return p_sourceFileNameWithoutPath;
19771 : }
19772 :
19773 : void
19774 357 : SgFile::set_sourceFileNameWithoutPath ( std::string sourceFileNameWithoutPath )
19775 : {
19776 357 : ROSE_ASSERT (this != NULL);
19777 :
19778 357 : p_sourceFileNameWithoutPath = sourceFileNameWithoutPath;
19779 357 : }
19780 :
19781 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19782 :
19783 :
19784 : // End of memberFunctionString
19785 : // Start of memberFunctionString
19786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19787 :
19788 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19789 :
19790 : std::string
19791 3874 : SgFile::get_unparse_output_filename () const
19792 : {
19793 3874 : ROSE_ASSERT (this != NULL);
19794 3874 : return p_unparse_output_filename;
19795 : }
19796 :
19797 : void
19798 355 : SgFile::set_unparse_output_filename ( std::string unparse_output_filename )
19799 : {
19800 355 : ROSE_ASSERT (this != NULL);
19801 :
19802 355 : p_unparse_output_filename = unparse_output_filename;
19803 355 : }
19804 :
19805 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19806 :
19807 :
19808 : // End of memberFunctionString
19809 : // Start of memberFunctionString
19810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19811 :
19812 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19813 :
19814 : std::string
19815 347 : SgFile::get_objectFileNameWithPath () const
19816 : {
19817 347 : ROSE_ASSERT (this != NULL);
19818 347 : return p_objectFileNameWithPath;
19819 : }
19820 :
19821 : void
19822 5 : SgFile::set_objectFileNameWithPath ( std::string objectFileNameWithPath )
19823 : {
19824 5 : ROSE_ASSERT (this != NULL);
19825 :
19826 5 : p_objectFileNameWithPath = objectFileNameWithPath;
19827 5 : }
19828 :
19829 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19830 :
19831 :
19832 : // End of memberFunctionString
19833 : // Start of memberFunctionString
19834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19835 :
19836 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19837 :
19838 : std::string
19839 0 : SgFile::get_objectFileNameWithoutPath () const
19840 : {
19841 0 : ROSE_ASSERT (this != NULL);
19842 0 : return p_objectFileNameWithoutPath;
19843 : }
19844 :
19845 : void
19846 0 : SgFile::set_objectFileNameWithoutPath ( std::string objectFileNameWithoutPath )
19847 : {
19848 0 : ROSE_ASSERT (this != NULL);
19849 :
19850 0 : p_objectFileNameWithoutPath = objectFileNameWithoutPath;
19851 0 : }
19852 :
19853 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19854 :
19855 :
19856 : // End of memberFunctionString
19857 : // Start of memberFunctionString
19858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19859 :
19860 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19861 :
19862 : bool
19863 698 : SgFile::get_useBackendOnly () const
19864 : {
19865 698 : ROSE_ASSERT (this != NULL);
19866 698 : return p_useBackendOnly;
19867 : }
19868 :
19869 : void
19870 0 : SgFile::set_useBackendOnly ( bool useBackendOnly )
19871 : {
19872 0 : ROSE_ASSERT (this != NULL);
19873 :
19874 0 : p_useBackendOnly = useBackendOnly;
19875 0 : }
19876 :
19877 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19878 :
19879 :
19880 : // End of memberFunctionString
19881 : // Start of memberFunctionString
19882 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19883 :
19884 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19885 :
19886 : bool
19887 684 : SgFile::get_compileOnly () const
19888 : {
19889 684 : ROSE_ASSERT (this != NULL);
19890 684 : return p_compileOnly;
19891 : }
19892 :
19893 : void
19894 663 : SgFile::set_compileOnly ( bool compileOnly )
19895 : {
19896 663 : ROSE_ASSERT (this != NULL);
19897 :
19898 663 : p_compileOnly = compileOnly;
19899 663 : }
19900 :
19901 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19902 :
19903 :
19904 : // End of memberFunctionString
19905 : // Start of memberFunctionString
19906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
19907 :
19908 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19909 :
19910 : std::string
19911 0 : SgFile::get_savedFrontendCommandLine () const
19912 : {
19913 0 : ROSE_ASSERT (this != NULL);
19914 :
19915 : #if 0
19916 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19917 : // used to trigger marking transformations for the token-based unparsing.
19918 : printf ("SgFile::get_savedFrontendCommandLine = %p = %s \n",this,this->class_name().c_str());
19919 : #endif
19920 :
19921 0 : return p_savedFrontendCommandLine;
19922 : }
19923 :
19924 : void
19925 357 : SgFile::set_savedFrontendCommandLine ( std::string savedFrontendCommandLine )
19926 : {
19927 357 : ROSE_ASSERT (this != NULL);
19928 :
19929 : #if 0
19930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
19931 : // used to trigger marking transformations for the token-based unparsing.
19932 : printf ("SgFile::set_savedFrontendCommandLine = %p = %s \n",this,this->class_name().c_str());
19933 : #endif
19934 :
19935 357 : set_isModified(true);
19936 :
19937 357 : p_savedFrontendCommandLine = savedFrontendCommandLine;
19938 357 : }
19939 :
19940 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19941 :
19942 :
19943 : // End of memberFunctionString
19944 : // Start of memberFunctionString
19945 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19946 :
19947 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19948 :
19949 : bool
19950 0 : SgFile::get_no_implicit_templates () const
19951 : {
19952 0 : ROSE_ASSERT (this != NULL);
19953 0 : return p_no_implicit_templates;
19954 : }
19955 :
19956 : void
19957 0 : SgFile::set_no_implicit_templates ( bool no_implicit_templates )
19958 : {
19959 0 : ROSE_ASSERT (this != NULL);
19960 :
19961 0 : p_no_implicit_templates = no_implicit_templates;
19962 0 : }
19963 :
19964 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19965 :
19966 :
19967 : // End of memberFunctionString
19968 : // Start of memberFunctionString
19969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19970 :
19971 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19972 :
19973 : bool
19974 0 : SgFile::get_no_implicit_inline_templates () const
19975 : {
19976 0 : ROSE_ASSERT (this != NULL);
19977 0 : return p_no_implicit_inline_templates;
19978 : }
19979 :
19980 : void
19981 0 : SgFile::set_no_implicit_inline_templates ( bool no_implicit_inline_templates )
19982 : {
19983 0 : ROSE_ASSERT (this != NULL);
19984 :
19985 0 : p_no_implicit_inline_templates = no_implicit_inline_templates;
19986 0 : }
19987 :
19988 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
19989 :
19990 :
19991 : // End of memberFunctionString
19992 : // Start of memberFunctionString
19993 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
19994 :
19995 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
19996 :
19997 : bool
19998 353 : SgFile::get_skip_commentsAndDirectives () const
19999 : {
20000 353 : ROSE_ASSERT (this != NULL);
20001 353 : return p_skip_commentsAndDirectives;
20002 : }
20003 :
20004 : void
20005 0 : SgFile::set_skip_commentsAndDirectives ( bool skip_commentsAndDirectives )
20006 : {
20007 0 : ROSE_ASSERT (this != NULL);
20008 :
20009 0 : p_skip_commentsAndDirectives = skip_commentsAndDirectives;
20010 0 : }
20011 :
20012 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20013 :
20014 :
20015 : // End of memberFunctionString
20016 : // Start of memberFunctionString
20017 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20018 :
20019 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20020 :
20021 : bool
20022 0 : SgFile::get_collectAllCommentsAndDirectives () const
20023 : {
20024 0 : ROSE_ASSERT (this != NULL);
20025 0 : return p_collectAllCommentsAndDirectives;
20026 : }
20027 :
20028 : void
20029 0 : SgFile::set_collectAllCommentsAndDirectives ( bool collectAllCommentsAndDirectives )
20030 : {
20031 0 : ROSE_ASSERT (this != NULL);
20032 :
20033 0 : p_collectAllCommentsAndDirectives = collectAllCommentsAndDirectives;
20034 0 : }
20035 :
20036 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20037 :
20038 :
20039 : // End of memberFunctionString
20040 : // Start of memberFunctionString
20041 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
20042 :
20043 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20044 :
20045 : bool
20046 0 : SgFile::get_translateCommentsAndDirectivesIntoAST () const
20047 : {
20048 0 : ROSE_ASSERT (this != NULL);
20049 :
20050 : #if 0
20051 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20052 : // used to trigger marking transformations for the token-based unparsing.
20053 : printf ("SgFile::get_translateCommentsAndDirectivesIntoAST = %p = %s \n",this,this->class_name().c_str());
20054 : #endif
20055 :
20056 0 : return p_translateCommentsAndDirectivesIntoAST;
20057 : }
20058 :
20059 : void
20060 0 : SgFile::set_translateCommentsAndDirectivesIntoAST ( bool translateCommentsAndDirectivesIntoAST )
20061 : {
20062 0 : ROSE_ASSERT (this != NULL);
20063 :
20064 : #if 0
20065 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20066 : // used to trigger marking transformations for the token-based unparsing.
20067 : printf ("SgFile::set_translateCommentsAndDirectivesIntoAST = %p = %s \n",this,this->class_name().c_str());
20068 : #endif
20069 :
20070 0 : set_isModified(true);
20071 :
20072 0 : p_translateCommentsAndDirectivesIntoAST = translateCommentsAndDirectivesIntoAST;
20073 0 : }
20074 :
20075 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20076 :
20077 :
20078 : // End of memberFunctionString
20079 : // Start of memberFunctionString
20080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20081 :
20082 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20083 :
20084 : bool
20085 1224940 : SgFile::get_unparseHeaderFiles () const
20086 : {
20087 1224940 : ROSE_ASSERT (this != NULL);
20088 1224940 : return p_unparseHeaderFiles;
20089 : }
20090 :
20091 : void
20092 0 : SgFile::set_unparseHeaderFiles ( bool unparseHeaderFiles )
20093 : {
20094 0 : ROSE_ASSERT (this != NULL);
20095 :
20096 0 : p_unparseHeaderFiles = unparseHeaderFiles;
20097 0 : }
20098 :
20099 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20100 :
20101 :
20102 : // End of memberFunctionString
20103 : // Start of memberFunctionString
20104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
20105 :
20106 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20107 :
20108 : ROSEAttributesListContainerPtr
20109 2495 : SgFile::get_preprocessorDirectivesAndCommentsList () const
20110 : {
20111 2495 : ROSE_ASSERT (this != NULL);
20112 :
20113 : #if 0
20114 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20115 : // used to trigger marking transformations for the token-based unparsing.
20116 : printf ("SgFile::get_preprocessorDirectivesAndCommentsList = %p = %s \n",this,this->class_name().c_str());
20117 : #endif
20118 :
20119 2495 : return p_preprocessorDirectivesAndCommentsList;
20120 : }
20121 :
20122 : void
20123 357 : SgFile::set_preprocessorDirectivesAndCommentsList ( ROSEAttributesListContainerPtr preprocessorDirectivesAndCommentsList )
20124 : {
20125 357 : ROSE_ASSERT (this != NULL);
20126 :
20127 : #if 0
20128 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20129 : // used to trigger marking transformations for the token-based unparsing.
20130 : printf ("SgFile::set_preprocessorDirectivesAndCommentsList = %p = %s \n",this,this->class_name().c_str());
20131 : #endif
20132 :
20133 357 : set_isModified(true);
20134 :
20135 357 : p_preprocessorDirectivesAndCommentsList = preprocessorDirectivesAndCommentsList;
20136 357 : }
20137 :
20138 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20139 :
20140 :
20141 : // End of memberFunctionString
20142 : // Start of memberFunctionString
20143 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20144 :
20145 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20146 :
20147 : AstAttributeMechanism*
20148 10 : SgFile::get_attributeMechanism () const
20149 : {
20150 10 : ROSE_ASSERT (this != NULL);
20151 10 : return p_attributeMechanism;
20152 : }
20153 :
20154 : void
20155 0 : SgFile::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
20156 : {
20157 0 : ROSE_ASSERT (this != NULL);
20158 :
20159 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
20160 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
20161 : {
20162 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
20163 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
20164 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
20165 : ROSE_ASSERT(false);
20166 : #endif
20167 : }
20168 : #endif
20169 0 : p_attributeMechanism = attributeMechanism;
20170 0 : }
20171 :
20172 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20173 :
20174 :
20175 : // End of memberFunctionString
20176 : // Start of memberFunctionString
20177 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
20178 :
20179 :
20180 : #if 0
20181 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
20182 : // a pointer and the interface represented directly at the SgNode
20183 : AstAttributeMechanism &
20184 : SgFile::attribute()
20185 : {
20186 : // DQ (1/2/2006): This function preserves as much of
20187 : // the syntax of attribute being a public data member.
20188 : if (p_attribute == NULL)
20189 : {
20190 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
20191 : assert(false);
20192 : }
20193 :
20194 : return *p_attribute;
20195 : }
20196 : #endif
20197 :
20198 : void
20199 0 : SgFile::addNewAttribute( std::string s, AstAttribute* a )
20200 : {
20201 0 : if (get_attributeMechanism() == NULL)
20202 : {
20203 0 : set_attributeMechanism( new AstAttributeMechanism() );
20204 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
20205 : }
20206 0 : get_attributeMechanism()->add(s,a);
20207 0 : }
20208 :
20209 : void
20210 0 : SgFile::setAttribute( std::string s, AstAttribute* a )
20211 : {
20212 0 : if (get_attributeMechanism() == NULL)
20213 : {
20214 0 : set_attributeMechanism( new AstAttributeMechanism() );
20215 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
20216 : }
20217 0 : get_attributeMechanism()->set(s,a);
20218 0 : }
20219 :
20220 : AstAttribute*
20221 0 : SgFile::getAttribute(std::string s) const
20222 : {
20223 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
20224 0 : if (attributeExists(s)==false) return NULL;
20225 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
20226 0 : ROSE_ASSERT(returnValue != NULL);
20227 0 : return returnValue;
20228 : }
20229 :
20230 : void
20231 0 : SgFile::updateAttribute( std::string s, AstAttribute* a )
20232 : {
20233 : // formerly called: replace
20234 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
20235 0 : get_attributeMechanism()->replace(s,a);
20236 0 : }
20237 :
20238 : void
20239 0 : SgFile::removeAttribute(std::string s)
20240 : {
20241 0 : if (get_attributeMechanism())
20242 0 : get_attributeMechanism()->remove(s);
20243 :
20244 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
20245 0 : int remainingCount = numberOfAttributes();
20246 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
20247 0 : if (remainingCount == 0)
20248 : {
20249 0 : delete get_attributeMechanism();
20250 0 : set_attributeMechanism(NULL);
20251 : }
20252 0 : }
20253 :
20254 : bool
20255 0 : SgFile::attributeExists(std::string s) const
20256 : {
20257 0 : bool returnValue = false;
20258 0 : if (get_attributeMechanism() != NULL)
20259 0 : returnValue = get_attributeMechanism()->exists(s);
20260 0 : return returnValue;
20261 : }
20262 :
20263 : int
20264 0 : SgFile::numberOfAttributes() const
20265 : {
20266 0 : int returnValue = 0;
20267 0 : if (get_attributeMechanism() != NULL)
20268 0 : returnValue = get_attributeMechanism()->size();
20269 0 : return returnValue;
20270 : }
20271 :
20272 :
20273 :
20274 : // End of memberFunctionString
20275 : // Start of memberFunctionString
20276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20277 :
20278 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20279 :
20280 : bool
20281 320 : SgFile::get_KCC_frontend () const
20282 : {
20283 320 : ROSE_ASSERT (this != NULL);
20284 320 : return p_KCC_frontend;
20285 : }
20286 :
20287 : void
20288 0 : SgFile::set_KCC_frontend ( bool KCC_frontend )
20289 : {
20290 0 : ROSE_ASSERT (this != NULL);
20291 :
20292 0 : p_KCC_frontend = KCC_frontend;
20293 0 : }
20294 :
20295 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20296 :
20297 :
20298 : // End of memberFunctionString
20299 : // Start of memberFunctionString
20300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20301 :
20302 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20303 :
20304 : bool
20305 640 : SgFile::get_new_frontend () const
20306 : {
20307 640 : ROSE_ASSERT (this != NULL);
20308 640 : return p_new_frontend;
20309 : }
20310 :
20311 : void
20312 0 : SgFile::set_new_frontend ( bool new_frontend )
20313 : {
20314 0 : ROSE_ASSERT (this != NULL);
20315 :
20316 0 : p_new_frontend = new_frontend;
20317 0 : }
20318 :
20319 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20320 :
20321 :
20322 : // End of memberFunctionString
20323 : // Start of memberFunctionString
20324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20325 :
20326 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20327 :
20328 : bool
20329 1313 : SgFile::get_disable_edg_backend () const
20330 : {
20331 1313 : ROSE_ASSERT (this != NULL);
20332 1313 : return p_disable_edg_backend;
20333 : }
20334 :
20335 : void
20336 0 : SgFile::set_disable_edg_backend ( bool disable_edg_backend )
20337 : {
20338 0 : ROSE_ASSERT (this != NULL);
20339 :
20340 0 : p_disable_edg_backend = disable_edg_backend;
20341 0 : }
20342 :
20343 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20344 :
20345 :
20346 : // End of memberFunctionString
20347 : // Start of memberFunctionString
20348 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20349 :
20350 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20351 :
20352 : bool
20353 0 : SgFile::get_disable_sage_backend () const
20354 : {
20355 0 : ROSE_ASSERT (this != NULL);
20356 0 : return p_disable_sage_backend;
20357 : }
20358 :
20359 : void
20360 0 : SgFile::set_disable_sage_backend ( bool disable_sage_backend )
20361 : {
20362 0 : ROSE_ASSERT (this != NULL);
20363 :
20364 0 : p_disable_sage_backend = disable_sage_backend;
20365 0 : }
20366 :
20367 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20368 :
20369 :
20370 : // End of memberFunctionString
20371 : // Start of memberFunctionString
20372 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20373 :
20374 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20375 :
20376 : int
20377 0 : SgFile::get_testingLevel () const
20378 : {
20379 0 : ROSE_ASSERT (this != NULL);
20380 0 : return p_testingLevel;
20381 : }
20382 :
20383 : void
20384 0 : SgFile::set_testingLevel ( int testingLevel )
20385 : {
20386 0 : ROSE_ASSERT (this != NULL);
20387 :
20388 0 : p_testingLevel = testingLevel;
20389 0 : }
20390 :
20391 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20392 :
20393 :
20394 : // End of memberFunctionString
20395 : // Start of memberFunctionString
20396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20397 :
20398 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20399 :
20400 : bool
20401 0 : SgFile::get_preinit_il () const
20402 : {
20403 0 : ROSE_ASSERT (this != NULL);
20404 0 : return p_preinit_il;
20405 : }
20406 :
20407 : void
20408 0 : SgFile::set_preinit_il ( bool preinit_il )
20409 : {
20410 0 : ROSE_ASSERT (this != NULL);
20411 :
20412 0 : p_preinit_il = preinit_il;
20413 0 : }
20414 :
20415 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20416 :
20417 :
20418 : // End of memberFunctionString
20419 : // Start of memberFunctionString
20420 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20421 :
20422 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20423 :
20424 : bool
20425 0 : SgFile::get_enable_cp_backend () const
20426 : {
20427 0 : ROSE_ASSERT (this != NULL);
20428 0 : return p_enable_cp_backend;
20429 : }
20430 :
20431 : void
20432 0 : SgFile::set_enable_cp_backend ( bool enable_cp_backend )
20433 : {
20434 0 : ROSE_ASSERT (this != NULL);
20435 :
20436 0 : p_enable_cp_backend = enable_cp_backend;
20437 0 : }
20438 :
20439 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20440 :
20441 :
20442 : // End of memberFunctionString
20443 : // Start of memberFunctionString
20444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20445 :
20446 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20447 :
20448 : bool
20449 356 : SgFile::get_markGeneratedFiles () const
20450 : {
20451 356 : ROSE_ASSERT (this != NULL);
20452 356 : return p_markGeneratedFiles;
20453 : }
20454 :
20455 : void
20456 357 : SgFile::set_markGeneratedFiles ( bool markGeneratedFiles )
20457 : {
20458 357 : ROSE_ASSERT (this != NULL);
20459 :
20460 357 : p_markGeneratedFiles = markGeneratedFiles;
20461 357 : }
20462 :
20463 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20464 :
20465 :
20466 : // End of memberFunctionString
20467 : // Start of memberFunctionString
20468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20469 :
20470 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20471 :
20472 : bool
20473 347 : SgFile::get_negative_test () const
20474 : {
20475 347 : ROSE_ASSERT (this != NULL);
20476 347 : return p_negative_test;
20477 : }
20478 :
20479 : void
20480 0 : SgFile::set_negative_test ( bool negative_test )
20481 : {
20482 0 : ROSE_ASSERT (this != NULL);
20483 :
20484 0 : p_negative_test = negative_test;
20485 0 : }
20486 :
20487 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20488 :
20489 :
20490 : // End of memberFunctionString
20491 : // Start of memberFunctionString
20492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20493 :
20494 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20495 :
20496 : bool
20497 1307 : SgFile::get_strict_language_handling () const
20498 : {
20499 1307 : ROSE_ASSERT (this != NULL);
20500 1307 : return p_strict_language_handling;
20501 : }
20502 :
20503 : void
20504 0 : SgFile::set_strict_language_handling ( bool strict_language_handling )
20505 : {
20506 0 : ROSE_ASSERT (this != NULL);
20507 :
20508 0 : p_strict_language_handling = strict_language_handling;
20509 0 : }
20510 :
20511 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20512 :
20513 :
20514 : // End of memberFunctionString
20515 : // Start of memberFunctionString
20516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20517 :
20518 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20519 :
20520 : bool
20521 706 : SgFile::get_wave () const
20522 : {
20523 706 : ROSE_ASSERT (this != NULL);
20524 706 : return p_wave;
20525 : }
20526 :
20527 : void
20528 0 : SgFile::set_wave ( bool wave )
20529 : {
20530 0 : ROSE_ASSERT (this != NULL);
20531 :
20532 0 : p_wave = wave;
20533 0 : }
20534 :
20535 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20536 :
20537 :
20538 : // End of memberFunctionString
20539 : // Start of memberFunctionString
20540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20541 :
20542 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20543 :
20544 : int
20545 356 : SgFile::get_embedColorCodesInGeneratedCode () const
20546 : {
20547 356 : ROSE_ASSERT (this != NULL);
20548 356 : return p_embedColorCodesInGeneratedCode;
20549 : }
20550 :
20551 : void
20552 0 : SgFile::set_embedColorCodesInGeneratedCode ( int embedColorCodesInGeneratedCode )
20553 : {
20554 0 : ROSE_ASSERT (this != NULL);
20555 :
20556 0 : p_embedColorCodesInGeneratedCode = embedColorCodesInGeneratedCode;
20557 0 : }
20558 :
20559 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20560 :
20561 :
20562 : // End of memberFunctionString
20563 : // Start of memberFunctionString
20564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20565 :
20566 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20567 :
20568 : int
20569 356 : SgFile::get_generateSourcePositionCodes () const
20570 : {
20571 356 : ROSE_ASSERT (this != NULL);
20572 356 : return p_generateSourcePositionCodes;
20573 : }
20574 :
20575 : void
20576 0 : SgFile::set_generateSourcePositionCodes ( int generateSourcePositionCodes )
20577 : {
20578 0 : ROSE_ASSERT (this != NULL);
20579 :
20580 0 : p_generateSourcePositionCodes = generateSourcePositionCodes;
20581 0 : }
20582 :
20583 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20584 :
20585 :
20586 : // End of memberFunctionString
20587 : // Start of memberFunctionString
20588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20589 :
20590 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20591 :
20592 : bool
20593 505 : SgFile::get_sourceFileUsesCppFileExtension () const
20594 : {
20595 505 : ROSE_ASSERT (this != NULL);
20596 505 : return p_sourceFileUsesCppFileExtension;
20597 : }
20598 :
20599 : void
20600 320 : SgFile::set_sourceFileUsesCppFileExtension ( bool sourceFileUsesCppFileExtension )
20601 : {
20602 320 : ROSE_ASSERT (this != NULL);
20603 :
20604 320 : p_sourceFileUsesCppFileExtension = sourceFileUsesCppFileExtension;
20605 320 : }
20606 :
20607 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20608 :
20609 :
20610 : // End of memberFunctionString
20611 : // Start of memberFunctionString
20612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20613 :
20614 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20615 :
20616 : bool
20617 0 : SgFile::get_sourceFileUsesFortranFileExtension () const
20618 : {
20619 0 : ROSE_ASSERT (this != NULL);
20620 0 : return p_sourceFileUsesFortranFileExtension;
20621 : }
20622 :
20623 : void
20624 357 : SgFile::set_sourceFileUsesFortranFileExtension ( bool sourceFileUsesFortranFileExtension )
20625 : {
20626 357 : ROSE_ASSERT (this != NULL);
20627 :
20628 357 : p_sourceFileUsesFortranFileExtension = sourceFileUsesFortranFileExtension;
20629 357 : }
20630 :
20631 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20632 :
20633 :
20634 : // End of memberFunctionString
20635 : // Start of memberFunctionString
20636 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20637 :
20638 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20639 :
20640 : bool
20641 31 : SgFile::get_sourceFileUsesFortran77FileExtension () const
20642 : {
20643 31 : ROSE_ASSERT (this != NULL);
20644 31 : return p_sourceFileUsesFortran77FileExtension;
20645 : }
20646 :
20647 : void
20648 31 : SgFile::set_sourceFileUsesFortran77FileExtension ( bool sourceFileUsesFortran77FileExtension )
20649 : {
20650 31 : ROSE_ASSERT (this != NULL);
20651 :
20652 31 : p_sourceFileUsesFortran77FileExtension = sourceFileUsesFortran77FileExtension;
20653 31 : }
20654 :
20655 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20656 :
20657 :
20658 : // End of memberFunctionString
20659 : // Start of memberFunctionString
20660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20661 :
20662 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20663 :
20664 : bool
20665 6 : SgFile::get_sourceFileUsesFortran90FileExtension () const
20666 : {
20667 6 : ROSE_ASSERT (this != NULL);
20668 6 : return p_sourceFileUsesFortran90FileExtension;
20669 : }
20670 :
20671 : void
20672 6 : SgFile::set_sourceFileUsesFortran90FileExtension ( bool sourceFileUsesFortran90FileExtension )
20673 : {
20674 6 : ROSE_ASSERT (this != NULL);
20675 :
20676 6 : p_sourceFileUsesFortran90FileExtension = sourceFileUsesFortran90FileExtension;
20677 6 : }
20678 :
20679 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20680 :
20681 :
20682 : // End of memberFunctionString
20683 : // Start of memberFunctionString
20684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20685 :
20686 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20687 :
20688 : bool
20689 0 : SgFile::get_sourceFileUsesFortran95FileExtension () const
20690 : {
20691 0 : ROSE_ASSERT (this != NULL);
20692 0 : return p_sourceFileUsesFortran95FileExtension;
20693 : }
20694 :
20695 : void
20696 0 : SgFile::set_sourceFileUsesFortran95FileExtension ( bool sourceFileUsesFortran95FileExtension )
20697 : {
20698 0 : ROSE_ASSERT (this != NULL);
20699 :
20700 0 : p_sourceFileUsesFortran95FileExtension = sourceFileUsesFortran95FileExtension;
20701 0 : }
20702 :
20703 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20704 :
20705 :
20706 : // End of memberFunctionString
20707 : // Start of memberFunctionString
20708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20709 :
20710 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20711 :
20712 : bool
20713 0 : SgFile::get_sourceFileUsesFortran2003FileExtension () const
20714 : {
20715 0 : ROSE_ASSERT (this != NULL);
20716 0 : return p_sourceFileUsesFortran2003FileExtension;
20717 : }
20718 :
20719 : void
20720 0 : SgFile::set_sourceFileUsesFortran2003FileExtension ( bool sourceFileUsesFortran2003FileExtension )
20721 : {
20722 0 : ROSE_ASSERT (this != NULL);
20723 :
20724 0 : p_sourceFileUsesFortran2003FileExtension = sourceFileUsesFortran2003FileExtension;
20725 0 : }
20726 :
20727 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20728 :
20729 :
20730 : // End of memberFunctionString
20731 : // Start of memberFunctionString
20732 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20733 :
20734 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20735 :
20736 : bool
20737 0 : SgFile::get_sourceFileUsesFortran2008FileExtension () const
20738 : {
20739 0 : ROSE_ASSERT (this != NULL);
20740 0 : return p_sourceFileUsesFortran2008FileExtension;
20741 : }
20742 :
20743 : void
20744 0 : SgFile::set_sourceFileUsesFortran2008FileExtension ( bool sourceFileUsesFortran2008FileExtension )
20745 : {
20746 0 : ROSE_ASSERT (this != NULL);
20747 :
20748 0 : p_sourceFileUsesFortran2008FileExtension = sourceFileUsesFortran2008FileExtension;
20749 0 : }
20750 :
20751 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20752 :
20753 :
20754 : // End of memberFunctionString
20755 : // Start of memberFunctionString
20756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20757 :
20758 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20759 :
20760 : bool
20761 0 : SgFile::get_sourceFileUsesCoArrayFortranFileExtension () const
20762 : {
20763 0 : ROSE_ASSERT (this != NULL);
20764 0 : return p_sourceFileUsesCoArrayFortranFileExtension;
20765 : }
20766 :
20767 : void
20768 0 : SgFile::set_sourceFileUsesCoArrayFortranFileExtension ( bool sourceFileUsesCoArrayFortranFileExtension )
20769 : {
20770 0 : ROSE_ASSERT (this != NULL);
20771 :
20772 0 : p_sourceFileUsesCoArrayFortranFileExtension = sourceFileUsesCoArrayFortranFileExtension;
20773 0 : }
20774 :
20775 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20776 :
20777 :
20778 : // End of memberFunctionString
20779 : // Start of memberFunctionString
20780 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20781 :
20782 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20783 :
20784 : bool
20785 0 : SgFile::get_sourceFileUsesPHPFileExtension () const
20786 : {
20787 0 : ROSE_ASSERT (this != NULL);
20788 0 : return p_sourceFileUsesPHPFileExtension;
20789 : }
20790 :
20791 : void
20792 0 : SgFile::set_sourceFileUsesPHPFileExtension ( bool sourceFileUsesPHPFileExtension )
20793 : {
20794 0 : ROSE_ASSERT (this != NULL);
20795 :
20796 0 : p_sourceFileUsesPHPFileExtension = sourceFileUsesPHPFileExtension;
20797 0 : }
20798 :
20799 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20800 :
20801 :
20802 : // End of memberFunctionString
20803 : // Start of memberFunctionString
20804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20805 :
20806 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20807 :
20808 : bool
20809 0 : SgFile::get_sourceFileUsesPythonFileExtension () const
20810 : {
20811 0 : ROSE_ASSERT (this != NULL);
20812 0 : return p_sourceFileUsesPythonFileExtension;
20813 : }
20814 :
20815 : void
20816 0 : SgFile::set_sourceFileUsesPythonFileExtension ( bool sourceFileUsesPythonFileExtension )
20817 : {
20818 0 : ROSE_ASSERT (this != NULL);
20819 :
20820 0 : p_sourceFileUsesPythonFileExtension = sourceFileUsesPythonFileExtension;
20821 0 : }
20822 :
20823 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20824 :
20825 :
20826 : // End of memberFunctionString
20827 : // Start of memberFunctionString
20828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20829 :
20830 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20831 :
20832 : bool
20833 0 : SgFile::get_sourceFileTypeIsUnknown () const
20834 : {
20835 0 : ROSE_ASSERT (this != NULL);
20836 0 : return p_sourceFileTypeIsUnknown;
20837 : }
20838 :
20839 : void
20840 0 : SgFile::set_sourceFileTypeIsUnknown ( bool sourceFileTypeIsUnknown )
20841 : {
20842 0 : ROSE_ASSERT (this != NULL);
20843 :
20844 0 : p_sourceFileTypeIsUnknown = sourceFileTypeIsUnknown;
20845 0 : }
20846 :
20847 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20848 :
20849 :
20850 : // End of memberFunctionString
20851 : // Start of memberFunctionString
20852 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
20853 :
20854 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20855 :
20856 : int
20857 329 : SgFile::get_detect_dangling_pointers () const
20858 : {
20859 329 : ROSE_ASSERT (this != NULL);
20860 329 : return p_detect_dangling_pointers;
20861 : }
20862 :
20863 : void
20864 0 : SgFile::set_detect_dangling_pointers ( int detect_dangling_pointers )
20865 : {
20866 0 : ROSE_ASSERT (this != NULL);
20867 :
20868 0 : p_detect_dangling_pointers = detect_dangling_pointers;
20869 0 : }
20870 :
20871 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20872 :
20873 :
20874 : // End of memberFunctionString
20875 : // Start of memberFunctionString
20876 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
20877 :
20878 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20879 :
20880 : bool
20881 394 : SgFile::get_experimental_fortran_frontend () const
20882 : {
20883 394 : ROSE_ASSERT (this != NULL);
20884 :
20885 : #if 0
20886 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20887 : // used to trigger marking transformations for the token-based unparsing.
20888 : printf ("SgFile::get_experimental_fortran_frontend = %p = %s \n",this,this->class_name().c_str());
20889 : #endif
20890 :
20891 394 : return p_experimental_fortran_frontend;
20892 : }
20893 :
20894 : void
20895 357 : SgFile::set_experimental_fortran_frontend ( bool experimental_fortran_frontend )
20896 : {
20897 357 : ROSE_ASSERT (this != NULL);
20898 :
20899 : #if 0
20900 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20901 : // used to trigger marking transformations for the token-based unparsing.
20902 : printf ("SgFile::set_experimental_fortran_frontend = %p = %s \n",this,this->class_name().c_str());
20903 : #endif
20904 :
20905 357 : set_isModified(true);
20906 :
20907 357 : p_experimental_fortran_frontend = experimental_fortran_frontend;
20908 357 : }
20909 :
20910 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20911 :
20912 :
20913 : // End of memberFunctionString
20914 : // Start of memberFunctionString
20915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
20916 :
20917 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20918 :
20919 : bool
20920 431 : SgFile::get_experimental_flang_frontend () const
20921 : {
20922 431 : ROSE_ASSERT (this != NULL);
20923 :
20924 : #if 0
20925 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20926 : // used to trigger marking transformations for the token-based unparsing.
20927 : printf ("SgFile::get_experimental_flang_frontend = %p = %s \n",this,this->class_name().c_str());
20928 : #endif
20929 :
20930 431 : return p_experimental_flang_frontend;
20931 : }
20932 :
20933 : void
20934 0 : SgFile::set_experimental_flang_frontend ( bool experimental_flang_frontend )
20935 : {
20936 0 : ROSE_ASSERT (this != NULL);
20937 :
20938 : #if 0
20939 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20940 : // used to trigger marking transformations for the token-based unparsing.
20941 : printf ("SgFile::set_experimental_flang_frontend = %p = %s \n",this,this->class_name().c_str());
20942 : #endif
20943 :
20944 0 : set_isModified(true);
20945 :
20946 0 : p_experimental_flang_frontend = experimental_flang_frontend;
20947 0 : }
20948 :
20949 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20950 :
20951 :
20952 : // End of memberFunctionString
20953 : // Start of memberFunctionString
20954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
20955 :
20956 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20957 :
20958 : bool
20959 0 : SgFile::get_experimental_cuda_fortran_frontend () const
20960 : {
20961 0 : ROSE_ASSERT (this != NULL);
20962 :
20963 : #if 0
20964 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20965 : // used to trigger marking transformations for the token-based unparsing.
20966 : printf ("SgFile::get_experimental_cuda_fortran_frontend = %p = %s \n",this,this->class_name().c_str());
20967 : #endif
20968 :
20969 0 : return p_experimental_cuda_fortran_frontend;
20970 : }
20971 :
20972 : void
20973 0 : SgFile::set_experimental_cuda_fortran_frontend ( bool experimental_cuda_fortran_frontend )
20974 : {
20975 0 : ROSE_ASSERT (this != NULL);
20976 :
20977 : #if 0
20978 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
20979 : // used to trigger marking transformations for the token-based unparsing.
20980 : printf ("SgFile::set_experimental_cuda_fortran_frontend = %p = %s \n",this,this->class_name().c_str());
20981 : #endif
20982 :
20983 0 : set_isModified(true);
20984 :
20985 0 : p_experimental_cuda_fortran_frontend = experimental_cuda_fortran_frontend;
20986 0 : }
20987 :
20988 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
20989 :
20990 :
20991 : // End of memberFunctionString
20992 : // Start of memberFunctionString
20993 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
20994 :
20995 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
20996 :
20997 : bool
20998 0 : SgFile::get_experimental_fortran_frontend_OFP_test () const
20999 : {
21000 0 : ROSE_ASSERT (this != NULL);
21001 :
21002 : #if 0
21003 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21004 : // used to trigger marking transformations for the token-based unparsing.
21005 : printf ("SgFile::get_experimental_fortran_frontend_OFP_test = %p = %s \n",this,this->class_name().c_str());
21006 : #endif
21007 :
21008 0 : return p_experimental_fortran_frontend_OFP_test;
21009 : }
21010 :
21011 : void
21012 357 : SgFile::set_experimental_fortran_frontend_OFP_test ( bool experimental_fortran_frontend_OFP_test )
21013 : {
21014 357 : ROSE_ASSERT (this != NULL);
21015 :
21016 : #if 0
21017 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21018 : // used to trigger marking transformations for the token-based unparsing.
21019 : printf ("SgFile::set_experimental_fortran_frontend_OFP_test = %p = %s \n",this,this->class_name().c_str());
21020 : #endif
21021 :
21022 357 : set_isModified(true);
21023 :
21024 357 : p_experimental_fortran_frontend_OFP_test = experimental_fortran_frontend_OFP_test;
21025 357 : }
21026 :
21027 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21028 :
21029 :
21030 : // End of memberFunctionString
21031 : // Start of memberFunctionString
21032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21033 :
21034 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21035 :
21036 : bool
21037 0 : SgFile::get_read_executable_file_format_only () const
21038 : {
21039 0 : ROSE_ASSERT (this != NULL);
21040 0 : return p_read_executable_file_format_only;
21041 : }
21042 :
21043 : void
21044 0 : SgFile::set_read_executable_file_format_only ( bool read_executable_file_format_only )
21045 : {
21046 0 : ROSE_ASSERT (this != NULL);
21047 :
21048 0 : p_read_executable_file_format_only = read_executable_file_format_only;
21049 0 : }
21050 :
21051 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21052 :
21053 :
21054 : // End of memberFunctionString
21055 : // Start of memberFunctionString
21056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21057 :
21058 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21059 :
21060 : bool
21061 0 : SgFile::get_visualize_executable_file_format_skip_symbols () const
21062 : {
21063 0 : ROSE_ASSERT (this != NULL);
21064 0 : return p_visualize_executable_file_format_skip_symbols;
21065 : }
21066 :
21067 : void
21068 0 : SgFile::set_visualize_executable_file_format_skip_symbols ( bool visualize_executable_file_format_skip_symbols )
21069 : {
21070 0 : ROSE_ASSERT (this != NULL);
21071 :
21072 0 : p_visualize_executable_file_format_skip_symbols = visualize_executable_file_format_skip_symbols;
21073 0 : }
21074 :
21075 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21076 :
21077 :
21078 : // End of memberFunctionString
21079 : // Start of memberFunctionString
21080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21081 :
21082 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21083 :
21084 : bool
21085 0 : SgFile::get_visualize_dwarf_only () const
21086 : {
21087 0 : ROSE_ASSERT (this != NULL);
21088 0 : return p_visualize_dwarf_only;
21089 : }
21090 :
21091 : void
21092 0 : SgFile::set_visualize_dwarf_only ( bool visualize_dwarf_only )
21093 : {
21094 0 : ROSE_ASSERT (this != NULL);
21095 :
21096 0 : p_visualize_dwarf_only = visualize_dwarf_only;
21097 0 : }
21098 :
21099 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21100 :
21101 :
21102 : // End of memberFunctionString
21103 : // Start of memberFunctionString
21104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21105 :
21106 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21107 :
21108 : bool
21109 0 : SgFile::get_read_instructions_only () const
21110 : {
21111 0 : ROSE_ASSERT (this != NULL);
21112 0 : return p_read_instructions_only;
21113 : }
21114 :
21115 : void
21116 0 : SgFile::set_read_instructions_only ( bool read_instructions_only )
21117 : {
21118 0 : ROSE_ASSERT (this != NULL);
21119 :
21120 0 : p_read_instructions_only = read_instructions_only;
21121 0 : }
21122 :
21123 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21124 :
21125 :
21126 : // End of memberFunctionString
21127 : // Start of memberFunctionString
21128 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
21129 :
21130 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21131 :
21132 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
21133 : const SgStringList &
21134 0 : SgFile::get_libraryArchiveObjectFileNameList () const
21135 : {
21136 0 : assert (this != NULL);
21137 0 : return p_libraryArchiveObjectFileNameList;
21138 : }
21139 :
21140 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
21141 : SgStringList &
21142 0 : SgFile::get_libraryArchiveObjectFileNameList ()
21143 : {
21144 0 : assert (this != NULL);
21145 :
21146 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
21147 : // As a rule only set_ access functions can set the isModified flag.
21148 : // set_isModified(true);
21149 :
21150 0 : return p_libraryArchiveObjectFileNameList;
21151 : }
21152 :
21153 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21154 :
21155 :
21156 : // End of memberFunctionString
21157 : // Start of memberFunctionString
21158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21159 :
21160 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21161 :
21162 : bool
21163 0 : SgFile::get_isLibraryArchive () const
21164 : {
21165 0 : ROSE_ASSERT (this != NULL);
21166 0 : return p_isLibraryArchive;
21167 : }
21168 :
21169 : void
21170 0 : SgFile::set_isLibraryArchive ( bool isLibraryArchive )
21171 : {
21172 0 : ROSE_ASSERT (this != NULL);
21173 :
21174 0 : p_isLibraryArchive = isLibraryArchive;
21175 0 : }
21176 :
21177 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21178 :
21179 :
21180 : // End of memberFunctionString
21181 : // Start of memberFunctionString
21182 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21183 :
21184 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21185 :
21186 : bool
21187 0 : SgFile::get_isObjectFile () const
21188 : {
21189 0 : ROSE_ASSERT (this != NULL);
21190 0 : return p_isObjectFile;
21191 : }
21192 :
21193 : void
21194 0 : SgFile::set_isObjectFile ( bool isObjectFile )
21195 : {
21196 0 : ROSE_ASSERT (this != NULL);
21197 :
21198 0 : p_isObjectFile = isObjectFile;
21199 0 : }
21200 :
21201 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21202 :
21203 :
21204 : // End of memberFunctionString
21205 : // Start of memberFunctionString
21206 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21207 :
21208 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21209 :
21210 : bool
21211 2441250 : SgFile::get_unparse_tokens () const
21212 : {
21213 2441250 : ROSE_ASSERT (this != NULL);
21214 2441250 : return p_unparse_tokens;
21215 : }
21216 :
21217 : void
21218 357 : SgFile::set_unparse_tokens ( bool unparse_tokens )
21219 : {
21220 357 : ROSE_ASSERT (this != NULL);
21221 :
21222 357 : p_unparse_tokens = unparse_tokens;
21223 357 : }
21224 :
21225 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21226 :
21227 :
21228 : // End of memberFunctionString
21229 : // Start of memberFunctionString
21230 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21231 :
21232 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21233 :
21234 : int
21235 357 : SgFile::get_unparse_tokens_testing () const
21236 : {
21237 357 : ROSE_ASSERT (this != NULL);
21238 :
21239 : #if 0
21240 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21241 : // used to trigger marking transformations for the token-based unparsing.
21242 : printf ("SgFile::get_unparse_tokens_testing = %p = %s \n",this,this->class_name().c_str());
21243 : #endif
21244 :
21245 357 : return p_unparse_tokens_testing;
21246 : }
21247 :
21248 : void
21249 357 : SgFile::set_unparse_tokens_testing ( int unparse_tokens_testing )
21250 : {
21251 357 : ROSE_ASSERT (this != NULL);
21252 :
21253 : #if 0
21254 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21255 : // used to trigger marking transformations for the token-based unparsing.
21256 : printf ("SgFile::set_unparse_tokens_testing = %p = %s \n",this,this->class_name().c_str());
21257 : #endif
21258 :
21259 357 : set_isModified(true);
21260 :
21261 357 : p_unparse_tokens_testing = unparse_tokens_testing;
21262 357 : }
21263 :
21264 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21265 :
21266 :
21267 : // End of memberFunctionString
21268 : // Start of memberFunctionString
21269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21270 :
21271 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21272 :
21273 : bool
21274 357 : SgFile::get_unparse_using_leading_and_trailing_token_mappings () const
21275 : {
21276 357 : ROSE_ASSERT (this != NULL);
21277 :
21278 : #if 0
21279 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21280 : // used to trigger marking transformations for the token-based unparsing.
21281 : printf ("SgFile::get_unparse_using_leading_and_trailing_token_mappings = %p = %s \n",this,this->class_name().c_str());
21282 : #endif
21283 :
21284 357 : return p_unparse_using_leading_and_trailing_token_mappings;
21285 : }
21286 :
21287 : void
21288 357 : SgFile::set_unparse_using_leading_and_trailing_token_mappings ( bool unparse_using_leading_and_trailing_token_mappings )
21289 : {
21290 357 : ROSE_ASSERT (this != NULL);
21291 :
21292 : #if 0
21293 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21294 : // used to trigger marking transformations for the token-based unparsing.
21295 : printf ("SgFile::set_unparse_using_leading_and_trailing_token_mappings = %p = %s \n",this,this->class_name().c_str());
21296 : #endif
21297 :
21298 357 : set_isModified(true);
21299 :
21300 357 : p_unparse_using_leading_and_trailing_token_mappings = unparse_using_leading_and_trailing_token_mappings;
21301 357 : }
21302 :
21303 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21304 :
21305 :
21306 : // End of memberFunctionString
21307 : // Start of memberFunctionString
21308 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21309 :
21310 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21311 :
21312 : bool
21313 373 : SgFile::get_unparse_template_ast () const
21314 : {
21315 373 : ROSE_ASSERT (this != NULL);
21316 373 : return p_unparse_template_ast;
21317 : }
21318 :
21319 : void
21320 358 : SgFile::set_unparse_template_ast ( bool unparse_template_ast )
21321 : {
21322 358 : ROSE_ASSERT (this != NULL);
21323 :
21324 358 : p_unparse_template_ast = unparse_template_ast;
21325 358 : }
21326 :
21327 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21328 :
21329 :
21330 : // End of memberFunctionString
21331 : // Start of memberFunctionString
21332 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21333 :
21334 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21335 :
21336 : bool
21337 326 : SgFile::get_skipAstConsistancyTests () const
21338 : {
21339 326 : ROSE_ASSERT (this != NULL);
21340 326 : return p_skipAstConsistancyTests;
21341 : }
21342 :
21343 : void
21344 0 : SgFile::set_skipAstConsistancyTests ( bool skipAstConsistancyTests )
21345 : {
21346 0 : ROSE_ASSERT (this != NULL);
21347 :
21348 0 : p_skipAstConsistancyTests = skipAstConsistancyTests;
21349 0 : }
21350 :
21351 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21352 :
21353 :
21354 : // End of memberFunctionString
21355 : // Start of memberFunctionString
21356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21357 :
21358 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21359 :
21360 : bool
21361 0 : SgFile::get_multifile_support () const
21362 : {
21363 0 : ROSE_ASSERT (this != NULL);
21364 :
21365 : #if 0
21366 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21367 : // used to trigger marking transformations for the token-based unparsing.
21368 : printf ("SgFile::get_multifile_support = %p = %s \n",this,this->class_name().c_str());
21369 : #endif
21370 :
21371 0 : return p_multifile_support;
21372 : }
21373 :
21374 : void
21375 2 : SgFile::set_multifile_support ( bool multifile_support )
21376 : {
21377 2 : ROSE_ASSERT (this != NULL);
21378 :
21379 : #if 0
21380 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21381 : // used to trigger marking transformations for the token-based unparsing.
21382 : printf ("SgFile::set_multifile_support = %p = %s \n",this,this->class_name().c_str());
21383 : #endif
21384 :
21385 2 : set_isModified(true);
21386 :
21387 2 : p_multifile_support = multifile_support;
21388 2 : }
21389 :
21390 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21391 :
21392 :
21393 : // End of memberFunctionString
21394 : // Start of memberFunctionString
21395 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21396 :
21397 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21398 :
21399 : bool
21400 320 : SgFile::get_optimization () const
21401 : {
21402 320 : ROSE_ASSERT (this != NULL);
21403 :
21404 : #if 0
21405 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21406 : // used to trigger marking transformations for the token-based unparsing.
21407 : printf ("SgFile::get_optimization = %p = %s \n",this,this->class_name().c_str());
21408 : #endif
21409 :
21410 320 : return p_optimization;
21411 : }
21412 :
21413 : void
21414 357 : SgFile::set_optimization ( bool optimization )
21415 : {
21416 357 : ROSE_ASSERT (this != NULL);
21417 :
21418 : #if 0
21419 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21420 : // used to trigger marking transformations for the token-based unparsing.
21421 : printf ("SgFile::set_optimization = %p = %s \n",this,this->class_name().c_str());
21422 : #endif
21423 :
21424 357 : set_isModified(true);
21425 :
21426 357 : p_optimization = optimization;
21427 357 : }
21428 :
21429 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21430 :
21431 :
21432 : // End of memberFunctionString
21433 : // Start of memberFunctionString
21434 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21435 :
21436 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21437 :
21438 : bool
21439 673 : SgFile::get_use_token_stream_to_improve_source_position_info () const
21440 : {
21441 673 : ROSE_ASSERT (this != NULL);
21442 673 : return p_use_token_stream_to_improve_source_position_info;
21443 : }
21444 :
21445 : void
21446 357 : SgFile::set_use_token_stream_to_improve_source_position_info ( bool use_token_stream_to_improve_source_position_info )
21447 : {
21448 357 : ROSE_ASSERT (this != NULL);
21449 :
21450 357 : p_use_token_stream_to_improve_source_position_info = use_token_stream_to_improve_source_position_info;
21451 357 : }
21452 :
21453 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21454 :
21455 :
21456 : // End of memberFunctionString
21457 : // Start of memberFunctionString
21458 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21459 :
21460 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21461 :
21462 : bool
21463 677 : SgFile::get_suppress_variable_declaration_normalization () const
21464 : {
21465 677 : ROSE_ASSERT (this != NULL);
21466 677 : return p_suppress_variable_declaration_normalization;
21467 : }
21468 :
21469 : void
21470 357 : SgFile::set_suppress_variable_declaration_normalization ( bool suppress_variable_declaration_normalization )
21471 : {
21472 357 : ROSE_ASSERT (this != NULL);
21473 :
21474 357 : p_suppress_variable_declaration_normalization = suppress_variable_declaration_normalization;
21475 357 : }
21476 :
21477 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21478 :
21479 :
21480 : // End of memberFunctionString
21481 : // Start of memberFunctionString
21482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21483 :
21484 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21485 :
21486 : bool
21487 677 : SgFile::get_edg_il_to_graphviz () const
21488 : {
21489 677 : ROSE_ASSERT (this != NULL);
21490 677 : return p_edg_il_to_graphviz;
21491 : }
21492 :
21493 : void
21494 357 : SgFile::set_edg_il_to_graphviz ( bool edg_il_to_graphviz )
21495 : {
21496 357 : ROSE_ASSERT (this != NULL);
21497 :
21498 357 : p_edg_il_to_graphviz = edg_il_to_graphviz;
21499 357 : }
21500 :
21501 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21502 :
21503 :
21504 : // End of memberFunctionString
21505 : // Start of memberFunctionString
21506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21507 :
21508 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21509 :
21510 : bool
21511 357 : SgFile::get_clang_il_to_graphviz () const
21512 : {
21513 357 : ROSE_ASSERT (this != NULL);
21514 357 : return p_clang_il_to_graphviz;
21515 : }
21516 :
21517 : void
21518 357 : SgFile::set_clang_il_to_graphviz ( bool clang_il_to_graphviz )
21519 : {
21520 357 : ROSE_ASSERT (this != NULL);
21521 :
21522 357 : p_clang_il_to_graphviz = clang_il_to_graphviz;
21523 357 : }
21524 :
21525 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21526 :
21527 :
21528 : // End of memberFunctionString
21529 : // Start of memberFunctionString
21530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21531 :
21532 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21533 :
21534 : bool
21535 0 : SgFile::get_no_optimize_flag_for_frontend () const
21536 : {
21537 0 : ROSE_ASSERT (this != NULL);
21538 0 : return p_no_optimize_flag_for_frontend;
21539 : }
21540 :
21541 : void
21542 357 : SgFile::set_no_optimize_flag_for_frontend ( bool no_optimize_flag_for_frontend )
21543 : {
21544 357 : ROSE_ASSERT (this != NULL);
21545 :
21546 357 : p_no_optimize_flag_for_frontend = no_optimize_flag_for_frontend;
21547 357 : }
21548 :
21549 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21550 :
21551 :
21552 : // End of memberFunctionString
21553 : // Start of memberFunctionString
21554 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21555 :
21556 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21557 :
21558 : bool
21559 1 : SgFile::get_unparse_edg_normalized_method_ROSE_1392 () const
21560 : {
21561 1 : ROSE_ASSERT (this != NULL);
21562 1 : return p_unparse_edg_normalized_method_ROSE_1392;
21563 : }
21564 :
21565 : void
21566 357 : SgFile::set_unparse_edg_normalized_method_ROSE_1392 ( bool unparse_edg_normalized_method_ROSE_1392 )
21567 : {
21568 357 : ROSE_ASSERT (this != NULL);
21569 :
21570 357 : p_unparse_edg_normalized_method_ROSE_1392 = unparse_edg_normalized_method_ROSE_1392;
21571 357 : }
21572 :
21573 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21574 :
21575 :
21576 : // End of memberFunctionString
21577 : // Start of memberFunctionString
21578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21579 :
21580 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21581 :
21582 : bool
21583 357 : SgFile::get_header_file_unparsing_optimization_source_file () const
21584 : {
21585 357 : ROSE_ASSERT (this != NULL);
21586 357 : return p_header_file_unparsing_optimization_source_file;
21587 : }
21588 :
21589 : void
21590 0 : SgFile::set_header_file_unparsing_optimization_source_file ( bool header_file_unparsing_optimization_source_file )
21591 : {
21592 0 : ROSE_ASSERT (this != NULL);
21593 :
21594 0 : p_header_file_unparsing_optimization_source_file = header_file_unparsing_optimization_source_file;
21595 0 : }
21596 :
21597 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21598 :
21599 :
21600 : // End of memberFunctionString
21601 : // Start of memberFunctionString
21602 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21603 :
21604 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21605 :
21606 : bool
21607 713 : SgFile::get_header_file_unparsing_optimization_header_file () const
21608 : {
21609 713 : ROSE_ASSERT (this != NULL);
21610 713 : return p_header_file_unparsing_optimization_header_file;
21611 : }
21612 :
21613 : void
21614 0 : SgFile::set_header_file_unparsing_optimization_header_file ( bool header_file_unparsing_optimization_header_file )
21615 : {
21616 0 : ROSE_ASSERT (this != NULL);
21617 :
21618 0 : p_header_file_unparsing_optimization_header_file = header_file_unparsing_optimization_header_file;
21619 0 : }
21620 :
21621 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21622 :
21623 :
21624 : // End of memberFunctionString
21625 : // Start of memberFunctionString
21626 :
21627 :
21628 : // End of memberFunctionString
21629 : // Start of memberFunctionString
21630 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21631 :
21632 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21633 :
21634 : int
21635 703 : SgFile::get_frontendErrorCode () const
21636 : {
21637 703 : ROSE_ASSERT (this != NULL);
21638 :
21639 : #if 0
21640 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21641 : // used to trigger marking transformations for the token-based unparsing.
21642 : printf ("SgFile::get_frontendErrorCode = %p = %s \n",this,this->class_name().c_str());
21643 : #endif
21644 :
21645 703 : return p_frontendErrorCode;
21646 : }
21647 :
21648 : void
21649 357 : SgFile::set_frontendErrorCode ( int frontendErrorCode )
21650 : {
21651 357 : ROSE_ASSERT (this != NULL);
21652 :
21653 : #if 0
21654 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21655 : // used to trigger marking transformations for the token-based unparsing.
21656 : printf ("SgFile::set_frontendErrorCode = %p = %s \n",this,this->class_name().c_str());
21657 : #endif
21658 :
21659 357 : set_isModified(true);
21660 :
21661 357 : p_frontendErrorCode = frontendErrorCode;
21662 357 : }
21663 :
21664 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21665 :
21666 :
21667 : // End of memberFunctionString
21668 : // Start of memberFunctionString
21669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21670 :
21671 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21672 :
21673 : int
21674 0 : SgFile::get_javacErrorCode () const
21675 : {
21676 0 : ROSE_ASSERT (this != NULL);
21677 :
21678 : #if 0
21679 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21680 : // used to trigger marking transformations for the token-based unparsing.
21681 : printf ("SgFile::get_javacErrorCode = %p = %s \n",this,this->class_name().c_str());
21682 : #endif
21683 :
21684 0 : return p_javacErrorCode;
21685 : }
21686 :
21687 : void
21688 0 : SgFile::set_javacErrorCode ( int javacErrorCode )
21689 : {
21690 0 : ROSE_ASSERT (this != NULL);
21691 :
21692 : #if 0
21693 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21694 : // used to trigger marking transformations for the token-based unparsing.
21695 : printf ("SgFile::set_javacErrorCode = %p = %s \n",this,this->class_name().c_str());
21696 : #endif
21697 :
21698 0 : set_isModified(true);
21699 :
21700 0 : p_javacErrorCode = javacErrorCode;
21701 0 : }
21702 :
21703 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21704 :
21705 :
21706 : // End of memberFunctionString
21707 : // Start of memberFunctionString
21708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21709 :
21710 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21711 :
21712 : int
21713 0 : SgFile::get_ecjErrorCode () const
21714 : {
21715 0 : ROSE_ASSERT (this != NULL);
21716 :
21717 : #if 0
21718 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21719 : // used to trigger marking transformations for the token-based unparsing.
21720 : printf ("SgFile::get_ecjErrorCode = %p = %s \n",this,this->class_name().c_str());
21721 : #endif
21722 :
21723 0 : return p_ecjErrorCode;
21724 : }
21725 :
21726 : void
21727 0 : SgFile::set_ecjErrorCode ( int ecjErrorCode )
21728 : {
21729 0 : ROSE_ASSERT (this != NULL);
21730 :
21731 : #if 0
21732 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21733 : // used to trigger marking transformations for the token-based unparsing.
21734 : printf ("SgFile::set_ecjErrorCode = %p = %s \n",this,this->class_name().c_str());
21735 : #endif
21736 :
21737 0 : set_isModified(true);
21738 :
21739 0 : p_ecjErrorCode = ecjErrorCode;
21740 0 : }
21741 :
21742 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21743 :
21744 :
21745 : // End of memberFunctionString
21746 : // Start of memberFunctionString
21747 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21748 :
21749 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21750 :
21751 : int
21752 0 : SgFile::get_midendErrorCode () const
21753 : {
21754 0 : ROSE_ASSERT (this != NULL);
21755 :
21756 : #if 0
21757 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21758 : // used to trigger marking transformations for the token-based unparsing.
21759 : printf ("SgFile::get_midendErrorCode = %p = %s \n",this,this->class_name().c_str());
21760 : #endif
21761 :
21762 0 : return p_midendErrorCode;
21763 : }
21764 :
21765 : void
21766 0 : SgFile::set_midendErrorCode ( int midendErrorCode )
21767 : {
21768 0 : ROSE_ASSERT (this != NULL);
21769 :
21770 : #if 0
21771 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21772 : // used to trigger marking transformations for the token-based unparsing.
21773 : printf ("SgFile::set_midendErrorCode = %p = %s \n",this,this->class_name().c_str());
21774 : #endif
21775 :
21776 0 : set_isModified(true);
21777 :
21778 0 : p_midendErrorCode = midendErrorCode;
21779 0 : }
21780 :
21781 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21782 :
21783 :
21784 : // End of memberFunctionString
21785 : // Start of memberFunctionString
21786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21787 :
21788 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21789 :
21790 : int
21791 347 : SgFile::get_unparserErrorCode () const
21792 : {
21793 347 : ROSE_ASSERT (this != NULL);
21794 :
21795 : #if 0
21796 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21797 : // used to trigger marking transformations for the token-based unparsing.
21798 : printf ("SgFile::get_unparserErrorCode = %p = %s \n",this,this->class_name().c_str());
21799 : #endif
21800 :
21801 347 : return p_unparserErrorCode;
21802 : }
21803 :
21804 : void
21805 0 : SgFile::set_unparserErrorCode ( int unparserErrorCode )
21806 : {
21807 0 : ROSE_ASSERT (this != NULL);
21808 :
21809 : #if 0
21810 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21811 : // used to trigger marking transformations for the token-based unparsing.
21812 : printf ("SgFile::set_unparserErrorCode = %p = %s \n",this,this->class_name().c_str());
21813 : #endif
21814 :
21815 0 : set_isModified(true);
21816 :
21817 0 : p_unparserErrorCode = unparserErrorCode;
21818 0 : }
21819 :
21820 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21821 :
21822 :
21823 : // End of memberFunctionString
21824 : // Start of memberFunctionString
21825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
21826 :
21827 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21828 :
21829 : int
21830 347 : SgFile::get_backendCompilerErrorCode () const
21831 : {
21832 347 : ROSE_ASSERT (this != NULL);
21833 347 : return p_backendCompilerErrorCode;
21834 : }
21835 :
21836 : void
21837 0 : SgFile::set_backendCompilerErrorCode ( int backendCompilerErrorCode )
21838 : {
21839 0 : ROSE_ASSERT (this != NULL);
21840 :
21841 0 : p_backendCompilerErrorCode = backendCompilerErrorCode;
21842 0 : }
21843 :
21844 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21845 :
21846 :
21847 : // End of memberFunctionString
21848 : // Start of memberFunctionString
21849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
21850 :
21851 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
21852 :
21853 : bool
21854 0 : SgFile::get_unparsedFileFailedCompilation () const
21855 : {
21856 0 : ROSE_ASSERT (this != NULL);
21857 :
21858 : #if 0
21859 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21860 : // used to trigger marking transformations for the token-based unparsing.
21861 : printf ("SgFile::get_unparsedFileFailedCompilation = %p = %s \n",this,this->class_name().c_str());
21862 : #endif
21863 :
21864 0 : return p_unparsedFileFailedCompilation;
21865 : }
21866 :
21867 : void
21868 0 : SgFile::set_unparsedFileFailedCompilation ( bool unparsedFileFailedCompilation )
21869 : {
21870 0 : ROSE_ASSERT (this != NULL);
21871 :
21872 : #if 0
21873 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
21874 : // used to trigger marking transformations for the token-based unparsing.
21875 : printf ("SgFile::set_unparsedFileFailedCompilation = %p = %s \n",this,this->class_name().c_str());
21876 : #endif
21877 :
21878 0 : set_isModified(true);
21879 :
21880 0 : p_unparsedFileFailedCompilation = unparsedFileFailedCompilation;
21881 0 : }
21882 :
21883 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
21884 :
21885 :
21886 : // End of memberFunctionString
21887 : // Start of memberFunctionString
21888 : /* #line 15847 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
21889 :
21890 :
21891 : // DQ (5/23/2015): Add static data member declaration.
21892 : bool SgFile::p_skip_unparse_asm_commands = false;
21893 :
21894 : // DQ (4/24/2021): Add static data member declaration.
21895 : bool SgFile::p_header_file_unparsing_optimization = false;
21896 :
21897 : // std::string SgFile::get_outputLanguageOptionName ( SgFile::outputLanguageOption_enum lang )
21898 : std::string
21899 0 : SgFile::get_outputLanguageOptionName ( SgFile::languageOption_enum lang )
21900 : {
21901 0 : string s;
21902 0 : switch (lang)
21903 : {
21904 0 : case SgFile::e_error_language: s = "error"; break;
21905 0 : case SgFile::e_default_language: s = "default"; break;
21906 0 : case SgFile::e_C_language: s = "C"; break;
21907 0 : case SgFile::e_Cxx_language: s = "C++"; break;
21908 0 : case SgFile::e_Fortran_language: s = "Fortran"; break;
21909 0 : default:
21910 0 : {
21911 0 : mprintf ("In SgFile::outputLanguageOption(): lang = %" PRIuPTR " \n",(size_t)lang);
21912 : // mprintf ("In SgFile::outputLanguageOption(): lang = %d \n",lang);
21913 0 : ROSE_ASSERT(false);
21914 : }
21915 : }
21916 :
21917 0 : return s;
21918 : }
21919 :
21920 0 : int SgFile::buildAST( std::vector<std::string> argv, std::vector<std::string> inputCommandLine )
21921 : {
21922 0 : mprintf ("Base class of virtual function, SgFile::buildAST(), called by mistake! \n");
21923 0 : ROSE_ASSERT(false);
21924 :
21925 : // tps (12/11/2009): Windows error : needs a return value
21926 : return 0;
21927 : }
21928 :
21929 : Sg_File_Info*
21930 1233100 : SgFile::get_file_info() const
21931 : {
21932 : // This redefines get_file_info() as it is implemented for a SgLocatedNode
21933 : // to use the "get_startOfConstruct()" for consistancy with SgLocatedNode IR nodes.
21934 1233100 : return get_startOfConstruct();
21935 : }
21936 :
21937 : void
21938 0 : SgFile::set_file_info( Sg_File_Info* fileinfo )
21939 : {
21940 : // This redefines set_file_info() as it is implemented for a SgLocatedNode
21941 : // to use the "set_startOfConstruct()" for consistancy with SgLocatedNode IR nodes.
21942 0 : set_startOfConstruct(fileinfo);
21943 0 : }
21944 :
21945 : std::string
21946 7807 : SgFile::getFileName () const
21947 : {
21948 : // Get the filename from the Sage III file object
21949 :
21950 7807 : assert(this != NULL);
21951 :
21952 : // assert(get_fileInfo() != NULL);
21953 : #if 0
21954 : // DQ (9/4/2008): Moved the global scope to the new SgSourceFile IR node.
21955 : SgScopeStatement *globalScope = (SgScopeStatement *)(&(root()));
21956 : assert (globalScope != NULL);
21957 : Sg_File_Info* fileInfo = globalScope->get_file_info();
21958 : #else
21959 7807 : Sg_File_Info* fileInfo = p_startOfConstruct;
21960 : #endif
21961 7807 : assert (fileInfo != NULL);
21962 :
21963 : #if 0
21964 : // Original code
21965 : std::string fileName = fileInfo->get_filenameString();
21966 : #else
21967 :
21968 : #if 0
21969 : mprintf ("In SgFile::getFileName(): using the raw (uninterpreted) filename instead! \n");
21970 : #endif
21971 :
21972 : #if 0
21973 : // DQ (8/15/2018): I think we want to original physical filename. since if it is transformed
21974 : // as a file we don't what the name "transformation".
21975 : std::string fileName = fileInfo->get_physical_filename();
21976 : #else
21977 : // DQ (8/16/2018): I think we want to original filename as constructed and reported by the
21978 : // get_raw_filename() function, since if the statement is transformed as a file we don't what
21979 : // the name "transformation".
21980 7807 : std::string fileName = fileInfo->get_raw_filename();
21981 : #endif
21982 : #endif
21983 :
21984 7807 : return fileName;
21985 : }
21986 :
21987 : // DQ (1/4/2021): I don't think we need this function prototype.
21988 : // function prototype
21989 : // ROSEAttributesListPtr getPreprocessorDirectives( char *fileName);
21990 :
21991 : // DQ (2/3/2004): Debugging segfault in use of il_header within ROSE
21992 : // #include "sageCommonSourceHeader.h"
21993 : // extern an_il_header il_header;
21994 :
21995 : // Moved to sage_support.cpp: void SgFile::setupSourceFilename ( const vector<string>& argv )
21996 : // Moved to sage_support.cpp: void SgFile::doSetupForConstructor(const vector<string>& argv, int& errorCode, int fileNameIndex, SgProject* project)
21997 :
21998 0 : SgFile::SgFile ( int & argc, char** & argv , SgProject* project )
21999 : // : p_numberOfCommandLineArguments(argc) , p_commandLineArgumentList(NULL)
22000 : {
22001 : // This constructor actually makes the call to EDG to build the AST (via callFrontEnd()).
22002 0 : assert (argv && argc >= 0);
22003 :
22004 : // Note use of pointer arithmetic in the computation of "argv + argc", this is standard STL fair.
22005 0 : doSetupForConstructor(vector<string>(argv, argv + argc), project);
22006 0 : }
22007 :
22008 0 : SgFile::SgFile ( vector<string> & argv , SgProject* project )
22009 : // : p_numberOfCommandLineArguments(argc) , p_commandLineArgumentList(NULL)
22010 : {
22011 : // This constructor actually makes the call to EDG to build the AST (via callFrontEnd()).
22012 0 : doSetupForConstructor(argv, project);
22013 0 : }
22014 :
22015 :
22016 : // DQ (1/17/2006): Added this (copy constructor) to be explicit
22017 : // and avoid difficult bugs where it is compiler generated.
22018 0 : SgFile::SgFile ( const SgFile & X )
22019 : {
22020 0 : mprintf ("Error: calling private copy constructor! \n");
22021 0 : ROSE_ASSERT(false);
22022 : }
22023 :
22024 : void
22025 357 : SgFile::initialization()
22026 : {
22027 357 : assert(this != NULL);
22028 :
22029 357 : p_verbose = 0;
22030 : // version = false;
22031 : // help = false;
22032 :
22033 : // DQ (4/4/2020): Adding support for unparse headers feature specific diagnostics.
22034 : // p_unparseHeaderFilesDebug = 0;
22035 :
22036 : // DQ (12/8/2007): use "-Wall" to control output of warnings
22037 357 : p_output_warnings = false;
22038 :
22039 : // DQ (7/13/2004): Not previously initialized!
22040 357 : p_C_only = false;
22041 357 : p_upc_threads = 0;
22042 :
22043 357 : p_Cxx_only = false;
22044 :
22045 : // DQ (8/11/2007): Added support for Fortran
22046 357 : p_Fortran_only = false;
22047 :
22048 : // DQ (1/23/2009): Added CoArray Fortran support.
22049 357 : p_CoArrayFortran_only = false;
22050 :
22051 357 : p_requires_C_preprocessor = false;
22052 :
22053 357 : p_inputFormat = SgFile::e_unknown_output_format;
22054 357 : p_outputFormat = SgFile::e_unknown_output_format;
22055 357 : p_backendCompileFormat = SgFile::e_unknown_output_format;
22056 357 : p_fortran_implicit_none = false;
22057 357 : p_openmp = false;
22058 357 : p_openmp_parse_only = true;
22059 357 : p_openmp_ast_only = false;
22060 357 : p_openmp_lowering = false;
22061 357 : p_openmp_analyzing = false;
22062 :
22063 : // DQ (12/8/2007): Added commandline support for cray pointers.
22064 357 : p_cray_pointer_support = false;
22065 :
22066 : // DQ (12/11/2007): Added to support debugging of Fortran support in ROSE using OFP.
22067 357 : p_output_parser_actions = false;
22068 :
22069 : // DQ (12/11/2007): Added to support debugging of Fortran support in ROSE using OFP.
22070 357 : p_exit_after_parser = false;
22071 :
22072 357 : p_skip_parser = false;
22073 :
22074 : // DQ (1/4/2008): gFortran versions greater than 4.1 have bugs that prevent it from
22075 : // being used to to syntax checking on Fortran 2003 applications. To allow Fortran
22076 : // 2003 applications to be processed the syntax checking step done in ROSE using
22077 : // that backend compiler (typically gfortran) needs to be skipped. ROSE it self can
22078 : // handle the Fortran 2003 code, but can not yet do sufficent syntax checking to
22079 : // report errors in illegal Fortran 2003 code.
22080 357 : p_skip_syntax_check = false;
22081 :
22082 : // After higher level ASTs are build optionally apply transformations
22083 357 : p_skip_transformation = false;
22084 357 : p_skip_unparse = false;
22085 :
22086 : // DQ (11/1/2011): Added support to skip translation of EDG AST to ROSE AST.
22087 357 : p_skip_translation_from_edg_ast_to_rose_ast = false;
22088 :
22089 : #if 1
22090 : // The default should be to act like a C++ compiler
22091 357 : p_skipfinalCompileStep = false;
22092 : #else
22093 : p_skipfinalCompileStep = true;
22094 : #endif
22095 :
22096 : // p_new_unparser = true; // by default use the new unparser
22097 357 : p_unparse_includes = false; // by default do NOT unparse include files into the source code
22098 357 : p_unparse_line_directives = false; // by default do NOT unparse #line directives into the source code
22099 :
22100 : // DQ (4/14/2013): Added options to permit selection of either overloaded operator names or use of operator syntax
22101 : // for function calls in the unparsed code. The default is to reproduce the same use as in the input code.
22102 357 : p_unparse_function_calls_using_operator_syntax = false;
22103 357 : p_unparse_function_calls_using_operator_names = false;
22104 :
22105 : // DQ (8/30/2008): Added support to tailor the unparsing of disassembled instructions and the binary file format.
22106 357 : p_unparse_instruction_addresses = true;
22107 357 : p_unparse_raw_memory_contents = true;
22108 357 : p_unparse_binary_file_format = true;
22109 :
22110 : // DQ (8/27/2007): Support for alternative langauge code generation (unparsing), useful for testing specific language unparsers.
22111 357 : p_outputLanguage = SgFile::e_default_language;
22112 :
22113 357 : p_standard = e_default_standard;
22114 357 : p_gnu_standard = false;
22115 :
22116 : // initialize p_useBackendOnly data member
22117 357 : p_useBackendOnly = false;
22118 :
22119 357 : p_compileOnly = false;
22120 :
22121 : // DQ (6/21/2005): initialize g++ specific template instantiation control flags
22122 357 : p_no_implicit_templates = false;
22123 357 : p_no_implicit_inline_templates = false;
22124 :
22125 : // Added to permit all comments and CPP directives to be skipped (e.g. when unparsing all hearders)
22126 357 : p_skip_commentsAndDirectives = false;
22127 :
22128 : // DQ (4/19/2006): Added to control comment and directive handling (takes more time to process header files).
22129 357 : p_collectAllCommentsAndDirectives = false;
22130 :
22131 : // negara1 (07/08/2011): Added to control whether header files should be unparsed.
22132 357 : p_unparseHeaderFiles = false;
22133 :
22134 : // At construction this is a NULL pointer, it is updated later after construction of the AST.
22135 357 : p_preprocessorDirectivesAndCommentsList = NULL; // new ROSEAttributesListContainer();
22136 : // assert (p_preprocessorDirectivesAndCommentsList != NULL);
22137 357 : assert (p_preprocessorDirectivesAndCommentsList == NULL);
22138 :
22139 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
22140 : // a pointer and the interface represented directly at the SgNode
22141 : // DQ (1/13/2006): Initialize new AstAttributeMechanism pointer (moved from SgNode)
22142 357 : p_attributeMechanism = NULL;
22143 :
22144 357 : p_KCC_frontend = false;
22145 :
22146 : // Alternatively we can call the new edg frontend to test the edg process
22147 357 : p_new_frontend = false;
22148 :
22149 : // controls call to the edg_main (disables all processing
22150 : // and acts like a shell which calls the compiler)
22151 357 : p_disable_edg_backend = false;
22152 :
22153 : // Disable parsing of the EDG program tree into the SAGE program tree
22154 357 : p_disable_sage_backend = false;
22155 :
22156 : // Shorthand form for different levels of testing (default is -1)
22157 357 : p_testingLevel = -1;
22158 :
22159 : // enable processing specific to templates
22160 357 : p_preinit_il = false;
22161 357 : p_enable_cp_backend = false;
22162 :
22163 : // p_outputGrammarTreeFiles = false; // default should be false (set to true while debugging)
22164 : // p_outputGrammarTreeFilesForHeaderFiles = false; // default is to skip headers
22165 :
22166 : // Support for faster processing of pdf output (where we likely don't need the pdf output of the the EDG AST)
22167 : // p_outputGrammarTreeFilesForEDG = false;
22168 :
22169 : // DQ (9/5/2006): Added mechanism to optionally watermark files generated by ROSE
22170 357 : p_markGeneratedFiles = false;
22171 :
22172 : // DQ (9/19/2006): Allow testing of ROSE using input that is expected to fail (return passed if test failed)
22173 357 : p_negative_test = false;
22174 :
22175 : // DQ (9/24/2006): Permit optional enforcement of ANSI standards
22176 357 : p_strict_language_handling = false;
22177 :
22178 : // AS (9/29/2008): Use Wave
22179 357 : p_wave = false;
22180 :
22181 : // DQ (10/31/2006): Output information that can be used to colorize properties of generated code (useful for debugging).
22182 357 : p_embedColorCodesInGeneratedCode = 0;
22183 :
22184 : // DQ (10/31/2006): Output separate file containing source position information for highlighting (useful for debugging).
22185 357 : p_generateSourcePositionCodes = 0;
22186 :
22187 : // DQ (12/2/2006): This we be used (as in GNU) to set the languge mode (C++ files will turn on C++ language mode
22188 : // and only ".c" (C files) will turn on C language mode).
22189 357 : p_sourceFileUsesCppFileExtension = false;
22190 :
22191 : // DQ (12/11/2007): Added default initialization of these values
22192 357 : p_sourceFileUsesFortranFileExtension = false;
22193 357 : p_sourceFileUsesFortran77FileExtension = false;
22194 357 : p_sourceFileUsesFortran90FileExtension = false;
22195 357 : p_sourceFileUsesFortran95FileExtension = false;
22196 357 : p_sourceFileUsesFortran2003FileExtension = false;
22197 :
22198 : #if 0
22199 : // DQ (1/25/2016): Added initial support in command line handling for Fortran 2008 files.
22200 : File.setDataPrototype ( "bool", "sourceFileUsesFortran2008FileExtension", "= false",
22201 : NO_CONSTRUCTOR_PARAMETER, BUILD_FLAG_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22202 :
22203 : File.setDataPrototype ( "bool", "sourceFileUsesCoArrayFortranFileExtension", "= false",
22204 : NO_CONSTRUCTOR_PARAMETER, BUILD_FLAG_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22205 : File.setDataPrototype ( "bool", "sourceFileTypeIsUnknown", "= false",
22206 : NO_CONSTRUCTOR_PARAMETER, BUILD_FLAG_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22207 : #endif
22208 : // DQ (9/17/2020): Adding missing data member initialization.
22209 357 : p_sourceFileUsesFortran2008FileExtension = false;
22210 :
22211 : // DQ (1/23/2009): Added support for Co-Array Fortran (file extensions)
22212 357 : p_sourceFileUsesCoArrayFortranFileExtension = false;
22213 :
22214 : // DQ (9/26/2011): This was not initialized previosuly so I have added it.
22215 357 : p_sourceFileTypeIsUnknown = false;
22216 :
22217 : #if 0
22218 : File.setDataPrototype ( "int", "detect_dangling_pointers", "= false",
22219 : NO_CONSTRUCTOR_PARAMETER, BUILD_FLAG_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22220 :
22221 : // DQ (6/7/2013): Added support for use of experimental fortran front-end.
22222 : File.setDataPrototype("bool", "experimental_fortran_frontend", "= false",
22223 : NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22224 :
22225 : // Rasmussen (8/30/2010): Added experimental support for using the Flang parser for Fortran
22226 : File.setDataPrototype("bool", "experimental_flang_frontend", "= false",
22227 : NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22228 :
22229 : // Rasmussen (3/12/2018): Added support for CUDA Fortran within the experimental fortran frontend.
22230 : File.setDataPrototype("bool", "experimental_cuda_fortran_frontend", "= false",
22231 : NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22232 :
22233 : // DQ (1/23/2016): Added support for OFP parsing and pretty printing of generated Aterm
22234 : // (this is part of the internal testing of the new (experimental) Fortran support).
22235 : File.setDataPrototype("bool", "experimental_fortran_frontend_OFP_test", "= false",
22236 : NO_CONSTRUCTOR_PARAMETER, BUILD_ACCESS_FUNCTIONS, NO_TRAVERSAL, NO_DELETE);
22237 : #endif
22238 : // DQ (9/26/2011): New support for option to specify debugging support in ROSE to
22239 : // detect dangling pointers to IR nodes as part of the AST Consistancy tests. At
22240 : // some point this will default to always being on as an AST consistancy test.
22241 357 : p_detect_dangling_pointers = 0;
22242 :
22243 : // DQ (9/17/2020): Adding missing data member initialization.
22244 357 : p_experimental_flang_frontend = false;
22245 :
22246 : // DQ (6/7/2013): Added support for using experimental fortran frontend.
22247 : // Rasmussen (3/12/2018): Added support for CUDA Fortran within the experimental fortran frontend.
22248 357 : p_experimental_fortran_frontend = false;
22249 357 : p_experimental_cuda_fortran_frontend = false;
22250 :
22251 : // DQ (1/23/2016): Added support for OFP parsing and pretty printing of generated Aterm
22252 : // (this is part of the internal testing of the new (experimental) Fortran support).
22253 357 : p_experimental_fortran_frontend_OFP_test = false;
22254 :
22255 : // This will cause only the binary file format to be read and skipps instruction disassembly
22256 357 : p_read_executable_file_format_only = false;
22257 :
22258 : // DQ (11/11/2008): Added to support visualization of only parts of the AST.
22259 : // this will cause attributes to be added to IR nodes that will be skipped
22260 : // in the generation of DOT files. This is helpful for debugging and in
22261 : // tutorial examples/presentations.
22262 357 : p_visualize_executable_file_format_skip_symbols = false;
22263 :
22264 : // DQ (5/23/2015): This has been modified to be a static data member (for details see comments in ROSETTA/src/support.C).
22265 : // I am not clear if static variables should be set in this function (but it appears that other static variables are
22266 : // set there and if not here then where should they be set, unless we build a static initialization phase for code
22267 : // generated by ROSETTA (which does not presently exist).
22268 357 : p_skip_unparse_asm_commands = false;
22269 :
22270 357 : p_read_instructions_only = false;
22271 :
22272 : // DQ (11/20/2010): Support for token handling.
22273 357 : p_unparse_tokens = false;
22274 :
22275 : // DQ (1/30/2014): Support for testing of token unparsing.
22276 357 : p_unparse_tokens_testing = 0;
22277 :
22278 : // DQ (11/12/2014): Addded to support test modes for token unparsing.
22279 357 : p_unparse_using_leading_and_trailing_token_mappings = false;
22280 :
22281 : // DQ (2/17/2013): This permits skipping the AST consistancy test if the AstTests::runAllTests()
22282 : // function is called as part of the user's translator.
22283 357 : p_skipAstConsistancyTests = false;
22284 :
22285 : // DQ (4/17/2015): Adding multifile handling support for commandline generation.
22286 357 : p_multifile_support = false;
22287 :
22288 : // DQ (5/24/2015): Record if optimization was specified on the command line.
22289 357 : p_optimization = false;
22290 :
22291 : // DQ (12/11/2015): Option to use the token stream mapping and local tests of the
22292 : // token sequence, to improve the source position information stored in the AST.
22293 357 : p_use_token_stream_to_improve_source_position_info = false;
22294 :
22295 : // DQ (12/23/2015): Suppress variable declaration normalizations
22296 357 : p_suppress_variable_declaration_normalization = false;
22297 :
22298 : // Matzke (12/05/2016): Added missing initialization
22299 357 : p_frontendErrorCode = 0;
22300 357 : p_unparserErrorCode = 0;
22301 357 : p_midendErrorCode= 0; // Liao, 4/26/2017 add midend error code
22302 357 : p_backendCompilerErrorCode = 0;
22303 :
22304 : // DQ (9/19/2019): Added these missing variable initializations.
22305 357 : p_edg_il_to_graphviz = false;
22306 357 : p_no_optimize_flag_for_frontend = false;
22307 357 : p_unparse_edg_normalized_method_ROSE_1392 = false;
22308 :
22309 : // DQ (4/24/2021): Made p_header_file_unparsing_optimization a static data member.
22310 : // DQ (9/19/2019): Support optimizations of header file unparsing (specifically restricting
22311 : // the number of header files for which we collect comments and CPP directives).
22312 : // p_header_file_unparsing_optimization = false;
22313 357 : p_header_file_unparsing_optimization_source_file = false;
22314 357 : p_header_file_unparsing_optimization_header_file = false;
22315 :
22316 : // DQ (9/17/2020): Added these missing variable initializations.
22317 357 : p_standard = e_default_standard;
22318 357 : p_gnu_standard = false;
22319 357 : }
22320 :
22321 : #if 0
22322 : // DQ (9/4/2008): This is now in SgSourceFile (and built using ROSETTA with a different name)
22323 : SgGlobal &
22324 : SgFile::root() ROSE_DEPRECATED_FUNCTION
22325 : {
22326 : assert(p_root != NULL);
22327 : return *p_root;
22328 : }
22329 : #endif
22330 :
22331 : #if 0
22332 : // DQ (7/19/2005): Added to support better naming of global scope (root is not very clear)
22333 : // get_root() set_root() and root() will be depricated.
22334 : SgGlobal*
22335 : SgFile::get_globalScope() const
22336 : {
22337 : // This variable name will be changed in the future (to globalScope)
22338 : assert(p_root != NULL);
22339 : return p_root;
22340 : }
22341 : #endif
22342 :
22343 : #if 0
22344 : // DQ (5/9/2008): Added to support for previous variable name for some backward compatability.
22345 : SgGlobal*
22346 : SgSourceFile::get_root() const
22347 : {
22348 : // This variable name will be changed in the future (to globalScope)
22349 : assert(p_globalScope != NULL);
22350 : return p_globalScope;
22351 : }
22352 : #endif
22353 :
22354 1634 : enum SgFile::standard_enum SgFile::get_standard(void) const { return p_standard; }
22355 1 : void SgFile::set_standard(enum standard_enum e_std) { p_standard = e_std; }
22356 0 : void SgFile::set_default_standard(void) { p_standard = e_default_standard; }
22357 :
22358 : // DQ (1/10/2019): Add way to output a string to report standard in debug messages.
22359 0 : std::string SgFile::display_standard(enum standard_enum e_std)
22360 : {
22361 0 : string s;
22362 :
22363 0 : switch (e_std)
22364 : {
22365 0 : case e_default_standard: s = "e_default_standard"; break;
22366 0 : case e_c89_standard: s = "e_c89_standard"; break;
22367 0 : case e_c90_standard: s = "e_c90_standard"; break;
22368 0 : case e_c99_standard: s = "e_c99_standard"; break;
22369 0 : case e_c11_standard: s = "e_c11_standard"; break;
22370 0 : case e_c14_standard: s = "e_c14_standard"; break;
22371 0 : case e_c18_standard: s = "e_c18_standard"; break;
22372 0 : case e_upc_standard: s = "e_upc_standard"; break;
22373 0 : case e_cxx98_standard: s = "e_cxx98_standard"; break;
22374 0 : case e_cxx03_standard: s = "e_cxx03_standard"; break;
22375 0 : case e_cxx11_standard: s = "e_cxx11_standard"; break;
22376 0 : case e_cxx14_standard: s = "e_cxx14_standard"; break;
22377 0 : case e_cxx17_standard: s = "e_cxx17_standard"; break;
22378 0 : case e_cxx20_standard: s = "e_cxx20_standard"; break;
22379 0 : case e_upcxx_standard: s = "e_upcxx_standard"; break;
22380 0 : case e_f77_standard: s = "e_f77_standard"; break;
22381 0 : case e_f90_standard: s = "e_f90_standard"; break;
22382 0 : case e_f95_standard: s = "e_f95_standard"; break;
22383 0 : case e_f03_standard: s = "e_f03_standard"; break;
22384 0 : case e_f08_standard: s = "e_f08_standard"; break;
22385 0 : case e_f18_standard: s = "e_f18_standard"; break;
22386 :
22387 0 : default:
22388 0 : {
22389 0 : printf ("Error default reached in switch: SgFile::display_standard(): e_std = %x \n",e_std);
22390 0 : ROSE_ASSERT(false);
22391 : }
22392 : }
22393 :
22394 0 : return s;
22395 : }
22396 :
22397 317 : bool SgFile::is_gnu_standard(void) const { return p_gnu_standard; }
22398 0 : void SgFile::set_gnu_standard(void) { p_gnu_standard = true; }
22399 0 : void SgFile::unset_gnu_standard(void) { p_gnu_standard = false; }
22400 :
22401 460 : bool SgFile::get_C89_only (void) const { return p_standard == e_c89_standard; }
22402 0 : void SgFile::set_C89_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c89_standard; }
22403 :
22404 0 : bool SgFile::get_C89_gnu_only (void) const { return p_standard == e_c89_standard && p_gnu_standard; }
22405 0 : void SgFile::set_C89_gnu_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c89_standard; p_gnu_standard = true; }
22406 :
22407 0 : bool SgFile::get_C90_only (void) const { return p_standard == e_c90_standard; }
22408 0 : void SgFile::set_C90_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c90_standard; }
22409 :
22410 0 : bool SgFile::get_C90_gnu_only (void) const { return p_standard == e_c90_standard && p_gnu_standard; }
22411 0 : void SgFile::set_C90_gnu_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c90_standard; p_gnu_standard = true; }
22412 :
22413 15132 : bool SgFile::get_C99_only (void) const { return p_standard == e_c99_standard; }
22414 0 : void SgFile::set_C99_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c99_standard; }
22415 :
22416 0 : bool SgFile::get_C99_gnu_only (void) const { return p_standard == e_c99_standard && p_gnu_standard; }
22417 251 : void SgFile::set_C99_gnu_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c99_standard; p_gnu_standard = true; }
22418 :
22419 132 : bool SgFile::get_C11_only (void) const { return p_standard == e_c11_standard; }
22420 0 : void SgFile::set_C11_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c11_standard; }
22421 :
22422 0 : bool SgFile::get_C11_gnu_only (void) const { return p_standard == e_c11_standard && p_gnu_standard; }
22423 0 : void SgFile::set_C11_gnu_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c11_standard; p_gnu_standard = true; }
22424 :
22425 66 : bool SgFile::get_C14_only (void) const { return p_standard == e_c14_standard; }
22426 0 : void SgFile::set_C14_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c14_standard; }
22427 :
22428 0 : bool SgFile::get_C14_gnu_only (void) const { return p_standard == e_c14_standard && p_gnu_standard; }
22429 0 : void SgFile::set_C14_gnu_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c14_standard; p_gnu_standard = true; }
22430 :
22431 0 : bool SgFile::get_C18_only (void) const { return p_standard == e_c18_standard; }
22432 0 : void SgFile::set_C18_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c18_standard; }
22433 :
22434 0 : bool SgFile::get_C18_gnu_only (void) const { return p_standard == e_c18_standard && p_gnu_standard; }
22435 0 : void SgFile::set_C18_gnu_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_c18_standard; p_gnu_standard = true; }
22436 :
22437 677 : bool SgFile::get_UPC_only (void) const { return p_standard == e_upc_standard; }
22438 3 : void SgFile::set_UPC_only (void) { set_C_only(true); set_Cxx_only(false); p_standard = e_upc_standard; }
22439 :
22440 0 : bool SgFile::get_Cxx98_only (void) const { return p_standard == e_cxx98_standard; }
22441 0 : void SgFile::set_Cxx98_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx98_standard; }
22442 :
22443 0 : bool SgFile::get_Cxx98_gnu_only (void) const { return p_standard == e_cxx98_standard && p_gnu_standard; }
22444 0 : void SgFile::set_Cxx98_gnu_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx98_standard; p_gnu_standard = true; }
22445 :
22446 0 : bool SgFile::get_Cxx03_only (void) const { return p_standard == e_cxx03_standard; }
22447 0 : void SgFile::set_Cxx03_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx03_standard; }
22448 :
22449 0 : bool SgFile::get_Cxx03_gnu_only (void) const { return p_standard == e_cxx03_standard && p_gnu_standard; }
22450 0 : void SgFile::set_Cxx03_gnu_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx03_standard; p_gnu_standard = true; }
22451 :
22452 53 : bool SgFile::get_Cxx11_only (void) const { return p_standard == e_cxx11_standard; }
22453 0 : void SgFile::set_Cxx11_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx11_standard; }
22454 :
22455 0 : bool SgFile::get_Cxx11_gnu_only (void) const { return p_standard == e_cxx11_standard && p_gnu_standard; }
22456 0 : void SgFile::set_Cxx11_gnu_only (void) {set_C_only(false); set_Cxx_only(true); p_standard = e_cxx11_standard; p_gnu_standard = true; }
22457 :
22458 53 : bool SgFile::get_Cxx14_only (void) const { return p_standard == e_cxx14_standard; }
22459 0 : void SgFile::set_Cxx14_only (void) {set_C_only(false); set_Cxx_only(true); p_standard = e_cxx14_standard; }
22460 :
22461 0 : bool SgFile::get_Cxx14_gnu_only (void) const { return p_standard == e_cxx14_standard && p_gnu_standard; }
22462 0 : void SgFile::set_Cxx14_gnu_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx14_standard; p_gnu_standard = true; }
22463 :
22464 0 : bool SgFile::get_Cxx17_only (void) const { return p_standard == e_cxx17_standard; }
22465 0 : void SgFile::set_Cxx17_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx17_standard; }
22466 :
22467 0 : bool SgFile::get_Cxx17_gnu_only (void) const { return p_standard == e_cxx17_standard && p_gnu_standard; }
22468 0 : void SgFile::set_Cxx17_gnu_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx17_standard; p_gnu_standard = true; }
22469 :
22470 0 : bool SgFile::get_Cxx20_only (void) const { return p_standard == e_cxx20_standard; }
22471 0 : void SgFile::set_Cxx20_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx20_standard; }
22472 :
22473 0 : bool SgFile::get_Cxx20_gnu_only (void) const { return p_standard == e_cxx20_standard && p_gnu_standard; }
22474 0 : void SgFile::set_Cxx20_gnu_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_cxx20_standard; p_gnu_standard = true; }
22475 :
22476 677 : bool SgFile::get_UPCxx_only (void) const { return p_standard == e_upcxx_standard; }
22477 0 : void SgFile::set_UPCxx_only (void) { set_C_only(false); set_Cxx_only(true); p_standard = e_upcxx_standard; }
22478 :
22479 614 : bool SgFile::get_F77_only (void) const { return p_standard == e_f77_standard; }
22480 31 : void SgFile::set_F77_only (void) { set_Fortran_only(true); p_standard = e_f77_standard; }
22481 :
22482 61146 : bool SgFile::get_F90_only (void) const { return p_standard == e_f90_standard; }
22483 6 : void SgFile::set_F90_only (void) { set_Fortran_only(true); p_standard = e_f90_standard; }
22484 :
22485 288 : bool SgFile::get_F95_only (void) const { return p_standard == e_f95_standard; }
22486 0 : void SgFile::set_F95_only (void) { set_Fortran_only(true); p_standard = e_f95_standard; }
22487 :
22488 288 : bool SgFile::get_F2003_only (void) const { return p_standard == e_f03_standard; }
22489 0 : void SgFile::set_F2003_only (void) { set_Fortran_only(true); p_standard = e_f03_standard; }
22490 :
22491 388 : bool SgFile::get_F2008_only (void) const { return p_standard == e_f08_standard; }
22492 0 : void SgFile::set_F2008_only (void) { set_Fortran_only(true); p_standard = e_f08_standard; }
22493 :
22494 0 : bool SgFile::get_F2018_only (void) const { return p_standard == e_f18_standard; }
22495 0 : void SgFile::set_F2018_only (void) { set_Fortran_only(true); p_standard = e_f18_standard; }
22496 :
22497 : // int SgFile::compileOutput ( int fileNameIndex, const std::string& compilerName )
22498 : int
22499 347 : SgFile::compileOutput ( int fileNameIndex )
22500 : {
22501 : // Compile the output file from the unparing
22502 347 : vector<string> argv = get_originalCommandLineArgumentList();
22503 347 : assert(!argv.empty());
22504 :
22505 : // DQ (4/21/2006): I think we can now assert this! This is an unused function parameter!
22506 347 : assert(fileNameIndex == 0);
22507 :
22508 : // DQ (1/17/2006): test this
22509 : // assert(get_fileInfo() != NULL);
22510 :
22511 : // error checking
22512 347 : assert (argv.size() > 1);
22513 :
22514 : // BP : 10/31/2001, strip out any rose options before passing the command line.
22515 347 : stripRoseCommandLineOptions( argv );
22516 :
22517 347 : if (get_C_only() || get_Cxx_only() || get_Fortran_only() )
22518 : {
22519 347 : stripEdgCommandLineOptions( argv );
22520 : }
22521 :
22522 : // Pei-Hung: 12/20/2021, strip out options for frontend parsing. Needed by ada2cpp
22523 347 : if (get_Cxx_only())
22524 : {
22525 57 : stripTranslationCommandLineOptions( argv );
22526 : }
22527 :
22528 347 : if (get_Fortran_only())
22529 : {
22530 37 : stripFortranCommandLineOptions( argv );
22531 : }
22532 :
22533 : // Call the compile
22534 : // int errorCode = compileOutput ( argv, fileNameIndex, compilerName );
22535 347 : int errorCode = compileOutput ( argv, fileNameIndex );
22536 :
22537 : // return the error code from the compilation
22538 347 : return errorCode;
22539 : }
22540 :
22541 : // function prototype
22542 : // void pdfPrintAbstractSyntaxTreeSage ( SgFile & sageFile, bool writeOutHeaderFiles );
22543 :
22544 : #if 0
22545 : void
22546 : SgFile::outputPDF ()
22547 : {
22548 : // Output the program tree
22549 : mprintf ("In SgFile::outputPDF(): Dumping the program tree (AST) to a file \n");
22550 :
22551 : // Use Markus's new pdf generator
22552 : AstPDFGeneration pdftest;
22553 : pdftest.generateWithinFile(this);
22554 : }
22555 : #endif
22556 :
22557 : #if 0
22558 : void
22559 : roseDisplayMechanism( SgFile *file )
22560 : {
22561 : // This is the function called by EDG if set using the set_sage_transform_function()
22562 : // function. We use it to permit the EDG AST to be dumped out to a file. This
22563 : // step must be done before EDG's AST is deleted and so can't be done when other
22564 : // Sage/ROSE transformations are done (which is now after the EDG AST is released
22565 : // under the new (simplified) interface).
22566 :
22567 : // This function is called at the point where the EDG program tree has already
22568 : // been parsed into the C++ (modified Sage) grammar but the EDG AST still exists.
22569 :
22570 : #if ROSE_INTERNAL_DEBUG
22571 : if ( file->get_verbose() > 1 )
22572 : {
22573 : // Find out what file we are doing transformations upon
22574 : mprintf ("In roseDisplayMechanism: globalSourceFileName = %s \n",file->getFileName());
22575 : }
22576 : #endif
22577 :
22578 : if (file->get_outputGrammarTreeFiles() == true)
22579 : {
22580 : // Output the program tree
22581 : mprintf ("## Dumping the program tree (AST) to a file ## \n");
22582 :
22583 : // Permit the AST for the header files to be output
22584 : // as well (this makes the output files very large)
22585 : bool writeOutHeaderFiles = file->get_outputGrammarTreeFilesForHeaderFiles();
22586 :
22587 : // Added to speed up processing of large files when we just want the SAGE 3 AST
22588 : bool writeOutEDG_AST = file->get_outputGrammarTreeFilesForEDG();
22589 :
22590 : // Output the source code file (as represented by the EDG AST) as a PDF file (with bookmarks)
22591 : // Allow this to be off by default since the files generated are so large and most often we just want the SAGE 3 AST
22592 : if (writeOutEDG_AST == true)
22593 : pdfPrintAbstractSyntaxTreeEDG ( file, writeOutHeaderFiles );
22594 : else
22595 : mprintf ("Skipping output of EDG AST in PDF format (EDG output must be turned on explicitly using commandline option) \n");
22596 :
22597 : // Output the source code file (as represented by the SAGE AST) as a PDF file (with bookmarks)
22598 : // pdfPrintAbstractSyntaxTreeSage ( file, writeOutHeaderFiles );
22599 :
22600 : // mprintf ("Exiting after testing pdf file output of source code! \n");
22601 : // ROSE_ABORT();
22602 : }
22603 : else
22604 : {
22605 : // mprintf ("## Skip dumping the EDG program tree to a file ## \n");
22606 : }
22607 : }
22608 : #endif
22609 :
22610 : // Moved to sage_support.cpp: int SgFile::callFrontEnd ()
22611 : // Moved to sage_support.cpp: void SgFile::stripRoseCommandLineOptions ( vector<string>& argv )
22612 : // Moved to sage_support.cpp: void SgFile::processRoseCommandLineOptions ( vector<string> & argv )
22613 : // Moved to sage_support.cpp: void SgFile::stripEdgCommandLineOptions ( vector<string> & argv )
22614 : // Moved to sage_support.cpp: void SgFile::processBackendSpecificCommandLineOptions ( const vector<string>& argvOrig )
22615 : // Moved to sage_support.cpp: bool SgFile::isPrelinkPhase() const
22616 :
22617 : SgProject*
22618 23880 : SgFile::get_project()
22619 : {
22620 : // If the project is a parent of the current SgFile then we find it, else return NULL.
22621 :
22622 23880 : SgNode* parent = get_parent();
22623 :
22624 : // DQ (7/12/2005): The parent is NULL if we have only built a single file (e.g. within the rewrite mechanism)
22625 : // assert(parent != NULL);
22626 :
22627 23880 : SgProject* project = NULL;
22628 :
22629 : // DQ (7/12/2005): The parent is NULL if we have only built a single file (e.g. within the rewrite mechanism)
22630 : // Just return NULL in this case!
22631 23880 : if (parent != NULL)
22632 : {
22633 23880 : project = isSgProject(parent);
22634 47760 : while ( project == NULL && parent->get_parent() != NULL )
22635 : {
22636 23880 : parent = parent->get_parent();
22637 23880 : assert(parent != NULL);
22638 23880 : project = isSgProject(parent);
22639 : }
22640 23880 : assert ( project != NULL );
22641 : }
22642 :
22643 23880 : return project;
22644 : }
22645 :
22646 : // Moved to sage_support.cpp: void SgFile::build_EDG_CommandLine ( vector<string> & inputCommandLine, vector<string> & argv, int fileNameIndex )
22647 : // Moved to sage_support.cpp: void SgFile::usage ( int status )
22648 :
22649 : #ifdef _MSC_VER
22650 : #include <direct.h> // getcwd()
22651 : #endif
22652 :
22653 : //! get the current directory
22654 : string
22655 347 : SgFile::getWorkingDirectory ()
22656 : {
22657 347 : int i = 0; // index variable declaration
22658 :
22659 347 : const int maxPathNameLength = 1024;
22660 347 : char* currentDirectory = new char [maxPathNameLength];
22661 355675 : for (i=0; i < maxPathNameLength; i++)
22662 355328 : currentDirectory[i] = '\0'; // set to NULL string
22663 :
22664 : // CH (4/8/2010): "direct.h" in MSVC provides getcwd()
22665 : //#ifdef _MSCx_VER
22666 : //#pragma message ("WARNING: support for Linux getcwd() unavailable in Microsoft Visual Studio.")
22667 : // mprintf ("Error: support for Linux getcwd() unavailable in Microsoft Visual Studio.");
22668 : // assert(false);
22669 : // char* returnString = NULL;
22670 : //#else
22671 347 : char* returnString = getcwd(currentDirectory,maxPathNameLength - 1);
22672 : //#endif
22673 347 : assert (returnString != NULL);
22674 347 : currentDirectory[maxPathNameLength - 1] = 0; // Just in case
22675 :
22676 : // The semantics of the getcwd is that these shuld be the same (see if they are)
22677 : // mprintf ("In Rose::getWorkingDirectory: Current directory = %s \n",currentDirectory);
22678 : // mprintf ("In Rose::getWorkingDirectory: Current directory = %s \n",returnString);
22679 :
22680 : // live with the possible memory leak for now
22681 : // delete currentDirectory;
22682 347 : currentDirectory = NULL;
22683 :
22684 347 : return returnString;
22685 : }
22686 :
22687 : //! get the source directory
22688 : string
22689 99 : SgFile::getSourceDirectory ()
22690 : {
22691 : #if 0
22692 : int i = 0; // index variable declaration
22693 :
22694 : const int maxPathNameLength = 1024;
22695 : char* currentDirectory = new char [maxPathNameLength];
22696 : for (i=0; i < maxPathNameLength; i++)
22697 : currentDirectory[i] = '\0'; // set to NULL string
22698 :
22699 : mprintf ("SgFile::getSourceDirectory not implemented! \n");
22700 : ROSE_ABORT();
22701 :
22702 : return "";
22703 : #endif
22704 :
22705 99 : string sourceFile = get_sourceFileNameWithPath();
22706 99 : assert(sourceFile.empty() == false);
22707 198 : return Rose::StringUtility::getPathFromFileName(sourceFile);
22708 : }
22709 :
22710 :
22711 : string
22712 350 : SgFile::generateOutputFileName() const
22713 : {
22714 : // DQ (10/16/2005): This function abstracts the generation of an
22715 : // output file name from the source file name.
22716 :
22717 350 : std::string sourceFileName = get_sourceFileNameWithPath();
22718 :
22719 : // std::string baseFileName = Rose::utility_stripPathFromFileName(sourceFileName.c_str());
22720 700 : std::string baseFileName = Rose::StringUtility::stripPathFromFileName(sourceFileName);
22721 :
22722 700 : std::string baseFileNameWithoutSuffix = Rose::StringUtility::stripFileSuffixFromFileName(baseFileName);
22723 :
22724 : // mprintf ("sourceFileName = %s oldFileName = %s\n",sourceFileName.c_str(),baseFileName.c_str());
22725 :
22726 350 : std::string objectFileName;
22727 :
22728 : // DQ (1/17/2006): test this
22729 : // assert(get_fileInfo() != NULL);
22730 :
22731 : #if 0
22732 : mprintf ("sourceFileName = %s \n",sourceFileName.c_str());
22733 : mprintf ("baseFileName = %s \n",baseFileName.c_str());
22734 : mprintf ("baseFileNameWithoutSuffix = %s \n",baseFileNameWithoutSuffix.c_str());
22735 : #endif
22736 :
22737 : #ifndef USE_ORIGINAL_SOURCE_FILE_NAME_IN_PRELINKING
22738 :
22739 : // DQ (8/12/2007): I think this was part of the prelinker which is not no longer used!
22740 : // mprintf ("isPrelinkPhase() = %s \n",isPrelinkPhase() ? "true" : "false");
22741 350 : assert(isPrelinkPhase() == false);
22742 :
22743 350 : if (isPrelinkPhase() == true)
22744 : {
22745 : // test for leading "rose_" prefix in name (it should be present)
22746 0 : assert(baseFileName.find("rose_") == 0);
22747 : // and remove it since we want the unmodified file name to be used as a name of the object file!
22748 0 : baseFileName.erase(0,5);
22749 :
22750 : // test for leading "rose_" prefix in name (it should NOT be present now)
22751 0 : assert(baseFileName.find("rose_") == std::string::npos);
22752 : }
22753 : #else
22754 :
22755 : #error "DEAD CODE"
22756 :
22757 : #endif
22758 :
22759 350 : {
22760 : // DQ (8/12/2007): Newer simpler code, made possible because of better internal support.
22761 : // This version is also now language independent and so supports the Fortran work.
22762 350 : objectFileName = baseFileNameWithoutSuffix + ".o";
22763 : }
22764 :
22765 : // mprintf ("At base of SgFile::generateOutputFileName(): objectFileName = %s \n",objectFileName.c_str());
22766 : // display("In SgFile::generateOutputFileName()");
22767 :
22768 700 : return objectFileName;
22769 : }
22770 :
22771 :
22772 : // Moved to cmdline.cpp: string SgFile::buildCompilerCommandLineOptions ( vector<string> & argv, int fileNameIndex, const string& compilerName )
22773 :
22774 :
22775 : // Forward declarations of classes used to control and tailor the code generation.
22776 : // class UnparseDelegate;
22777 : // class UnparseFormatHelp;
22778 :
22779 : // DQ (3/18/2006): Modified interface to allow specification of pointer to user
22780 : // defined UnparseFormatHelp object (to control code generation).
22781 : // DQ (8/20/2005): Removed default parameter from extern function declaration
22782 : // extern void unparseFile( SgFile&, UnparseDelegate* repl = NULL );
22783 : // Liao (2/8/2008): Removed default parameters due to conflicts with src/backend/unparser/unparser.h
22784 : // extern void unparseFile( SgFile* file, UnparseFormatHelp *unparseFormatHelp /* = NULL */, UnparseDelegate* unparseDelegate/* = NULL */, SgScopeStatement* unparseScope /* = NULL */);
22785 :
22786 : void
22787 : // SgFile::unparse ()
22788 0 : SgFile::unparse ( UnparseFormatHelp *unparseFormatHelp, UnparseDelegate* unparseDelegate )
22789 : {
22790 : // DQ (1/24/2010): This call to the timer has been moved to the unparseFile() function.
22791 : // DQ (7/12/2005): Introduce tracking of performance of ROSE.
22792 : // TimingPerformance timer ("AST Code Generation (unparsing):");
22793 :
22794 : // mprintf ("Inside of SgFile::unparse () ROSE_DEBUG = %d \n",ROSE_DEBUG);
22795 :
22796 : // Not clear if we can or should eliminate this function.
22797 : // mprintf ("This SgFile::unparse() function should no longer be called (I think)! \n");
22798 : // assert(false);
22799 :
22800 : // Call the unparser mechanism
22801 : // DQ (1/24/2010): Moved the extern declaration for unparseFile() to be local to this function (better code design).
22802 0 : extern void unparseFile( SgFile* file, UnparseFormatHelp *unparseFormatHelp /* = NULL */, UnparseDelegate* unparseDelegate/* = NULL */, SgScopeStatement* unparseScope /* = NULL */);
22803 0 : unparseFile ( this, unparseFormatHelp, unparseDelegate, NULL );
22804 0 : }
22805 :
22806 : // Moved to sage_support.cpp: int SgFile::compileOutput ( vector<string>& argv, int fileNameIndex, const string& compilerNameOrig )
22807 :
22808 :
22809 : // DQ (5/8/2010): Added support to reset the Sg_File_Info (source code position information)
22810 : // to be relative to the generated code instead of the original input code. This is useful when
22811 : // we want to output references to the position of language constructs in the generated code
22812 : // instead of the original input code. Also useful for building references to locations in
22813 : // automatically generated code.
22814 : void
22815 0 : SgFile::resetSourcePositionToGeneratedCode ( UnparseFormatHelp *unparseFormatHelp )
22816 : {
22817 0 : extern void resetSourcePositionToGeneratedCode( SgFile* file, UnparseFormatHelp *unparseHelp );
22818 0 : resetSourcePositionToGeneratedCode( this, unparseFormatHelp );
22819 0 : }
22820 :
22821 : void
22822 0 : SgFile::display ( const std::string & label ) const
22823 : {
22824 : // This function prints out the member data values within the object
22825 :
22826 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
22827 0 : printf ("\nIn SgFile::display(%s) \n",label.c_str());
22828 :
22829 : // DQ (1/17/2006): test this
22830 : // assert(get_fileInfo() != NULL);
22831 : #if 0
22832 : // DQ (9/4/2008): Moved p_root to SgSourceFile
22833 : mprintf (" p_root is %s pointer \n",(p_root != NULL) ? "VALID" : "NULL");
22834 : assert (p_root != NULL);
22835 : #endif
22836 :
22837 : // mprintf ("Output the SgFile::p_file_info object = %p \n",get_file_info());
22838 : // get_file_info()->display("Called from SgFile::display");
22839 0 : mprintf ("Output the SgFile::p_startOfConstruct object = %p \n",get_startOfConstruct());
22840 0 : assert (get_startOfConstruct() != NULL);
22841 0 : get_startOfConstruct()->display("Called from SgFile::display");
22842 :
22843 0 : printf (" p_verbose = %s (value=%d) \n",(p_verbose > 1) ? "true" : "false",p_verbose);
22844 : // printf (" p_unparseHeaderFilesDebug = %s (value=%d) \n",(p_unparseHeaderFilesDebug > 1) ? "true" : "false",p_unparseHeaderFilesDebug);
22845 :
22846 0 : printf (" p_output_warnings = %s \n",(p_output_warnings == true) ? "true" : "false");
22847 :
22848 0 : printf (" p_C_only() = %s \n",(p_C_only == true) ? "true" : "false");
22849 0 : printf (" p_upc_threads = %s (value=%d) \n", (p_upc_threads > 1) ? "true" : "false",p_upc_threads);
22850 :
22851 : // DQ (3/28/2013): Added support to specify C89 support, so that default can be C99 support (same as EDG3x branch).
22852 0 : printf (" p_Cxx_only() = %s \n",(p_Cxx_only == true) ? "true" : "false");
22853 0 : printf (" p_Fortran_only() = %s \n",(p_Fortran_only == true) ? "true" : "false");
22854 0 : printf (" p_CoArrayFortran_only() = %s \n",(p_CoArrayFortran_only == true) ? "true" : "false");
22855 :
22856 0 : printf (" p_requires_C_preprocessor = %s \n",(p_requires_C_preprocessor == true) ? "true" : "false");
22857 :
22858 : // DQ (2/5/2009): Putting this back now, so we have one at the SgProject and one at the SgFile.
22859 0 : string inputFormatName;
22860 0 : switch(p_inputFormat)
22861 : {
22862 0 : case SgFile::e_unknown_output_format: inputFormatName = "unknown"; break;
22863 0 : case SgFile::e_fixed_form_output_format: inputFormatName = "fixed"; break;
22864 0 : case SgFile::e_free_form_output_format: inputFormatName = "free"; break;
22865 :
22866 0 : default:
22867 0 : {
22868 0 : printf ("Error: default reached p_inputFormat = %d \n",p_inputFormat);
22869 0 : assert(false);
22870 : }
22871 : }
22872 :
22873 0 : printf (" p_inputFormat = %s input format \n",inputFormatName.c_str());
22874 :
22875 0 : string outputFormatName;
22876 0 : switch(p_outputFormat)
22877 : {
22878 0 : case SgFile::e_unknown_output_format: outputFormatName = "unknown"; break;
22879 0 : case SgFile::e_fixed_form_output_format: outputFormatName = "fixed"; break;
22880 0 : case SgFile::e_free_form_output_format: outputFormatName = "free"; break;
22881 :
22882 0 : default:
22883 0 : {
22884 0 : printf ("Error: default reached p_outputFormat = %d \n",p_outputFormat);
22885 0 : assert(false);
22886 : }
22887 : }
22888 :
22889 0 : printf (" p_outputFormat = %s output format \n",outputFormatName.c_str());
22890 :
22891 0 : string backendCompileFormatName;
22892 0 : switch(p_backendCompileFormat)
22893 : {
22894 0 : case SgFile::e_unknown_output_format: backendCompileFormatName = "unknown"; break;
22895 0 : case SgFile::e_fixed_form_output_format: backendCompileFormatName = "fixed"; break;
22896 0 : case SgFile::e_free_form_output_format: backendCompileFormatName = "free"; break;
22897 :
22898 0 : default:
22899 0 : {
22900 0 : printf ("Error: default reached p_backendCompileFormat = %d \n",p_backendCompileFormat);
22901 0 : assert(false);
22902 : }
22903 : }
22904 :
22905 0 : printf (" p_backendCompileFormat = %s output format \n",backendCompileFormatName.c_str());
22906 :
22907 0 : printf (" p_fortran_implicit_none = %s \n",(p_fortran_implicit_none == true) ? "true" : "false");
22908 0 : printf (" p_openmp = %s \n",(p_openmp == true) ? "true" : "false");
22909 0 : printf (" p_cray_pointer_support = %s \n",(p_cray_pointer_support == true) ? "true" : "false");
22910 0 : printf (" p_output_parser_actions = %s \n",(p_output_parser_actions == true) ? "true" : "false");
22911 0 : printf (" p_exit_after_parser = %s \n",(p_exit_after_parser == true) ? "true" : "false");
22912 :
22913 0 : printf (" p_skip_syntax_check = %s \n",(p_skip_syntax_check == true) ? "true" : "false");
22914 0 : printf (" p_skip_translation_from_edg_ast_to_rose_ast = %s \n",(p_skip_translation_from_edg_ast_to_rose_ast == true) ? "true" : "false");
22915 0 : printf (" p_skip_transformation = %s \n",(p_skip_transformation == true) ? "true" : "false");
22916 0 : printf (" p_skip_unparse = %s \n",(p_skip_unparse == true) ? "true" : "false");
22917 0 : printf (" p_skipfinalCompileStep = %s \n",(p_skipfinalCompileStep == true) ? "true" : "false");
22918 :
22919 0 : printf (" p_unparse_includes = %s \n",(p_unparse_includes == true) ? "true" : "false");
22920 0 : printf (" p_unparse_line_directives = %s \n",(p_unparse_line_directives == true) ? "true" : "false");
22921 :
22922 : // DQ (4/14/2013): Added options to permit selection of either overloaded operator names or use of operator syntax
22923 : // for function calls in the unparsed code. The default is to reproduce the same use as in the input code.
22924 0 : printf (" p_unparse_function_calls_using_operator_syntax = %s \n",(p_unparse_function_calls_using_operator_syntax == true) ? "true" : "false");
22925 0 : printf (" p_unparse_function_calls_using_operator_names = %s \n",(p_unparse_function_calls_using_operator_names == true) ? "true" : "false");
22926 :
22927 0 : printf (" p_unparse_instruction_addresses = %s \n",(p_unparse_instruction_addresses == true) ? "true" : "false");
22928 0 : printf (" p_unparse_raw_memory_contents = %s \n",(p_unparse_raw_memory_contents == true) ? "true" : "false");
22929 0 : printf (" p_unparse_binary_file_format = %s \n",(p_unparse_binary_file_format == true) ? "true" : "false");
22930 :
22931 0 : string outputLanguageName = get_outputLanguageOptionName(p_outputLanguage);
22932 :
22933 0 : printf (" p_outputLanguage = %s output language \n",outputLanguageName.c_str());
22934 :
22935 0 : printf (" p_sourceFileNameWithPath = %s \n",p_sourceFileNameWithPath.c_str());
22936 0 : printf (" p_sourceFileNameWithoutPath = %s \n",p_sourceFileNameWithoutPath.c_str());
22937 0 : printf (" p_unparse_output_filename = %s \n",p_unparse_output_filename.c_str());
22938 :
22939 0 : printf (" p_useBackendOnly = %s \n",(p_useBackendOnly == true) ? "true" : "false");
22940 0 : printf (" p_compileOnly = %s \n",(p_compileOnly == true) ? "true" : "false");
22941 :
22942 0 : printf (" p_savedFrontendCommandLine = %s \n",p_savedFrontendCommandLine.c_str());
22943 :
22944 0 : printf (" p_no_implicit_templates = %s \n",(p_no_implicit_templates == true) ? "true" : "false");
22945 0 : printf (" p_no_implicit_inline_templates = %s \n",(p_no_implicit_inline_templates == true) ? "true" : "false");
22946 0 : printf (" p_skip_commentsAndDirectives = %s \n",(p_skip_commentsAndDirectives == true) ? "true" : "false");
22947 0 : printf (" p_collectAllCommentsAndDirectives = %s \n",(p_collectAllCommentsAndDirectives == true) ? "true" : "false");
22948 0 : printf (" p_unparseHeaderFiles = %s \n",(p_unparseHeaderFiles == true) ? "true" : "false");
22949 :
22950 0 : printf (" p_preprocessorDirectivesAndCommentsList is %s pointer \n",(p_preprocessorDirectivesAndCommentsList != NULL) ? "VALID" : "NULL");
22951 :
22952 0 : printf (" p_KCC_frontend = %s \n",(p_KCC_frontend == true) ? "true" : "false");
22953 0 : printf (" p_new_frontend = %s \n",(p_new_frontend == true) ? "true" : "false");
22954 0 : printf (" p_disable_edg_backend = %s \n",(p_disable_edg_backend == true) ? "true" : "false");
22955 0 : printf (" p_disable_sage_backend = %s \n",(p_disable_sage_backend == true) ? "true" : "false");
22956 0 : printf (" p_testingLevel = %d \n",p_testingLevel);
22957 :
22958 0 : printf (" p_preinit_il = %s \n",(p_preinit_il == true) ? "true" : "false");
22959 0 : printf (" p_enable_cp_backend = %s \n",(p_enable_cp_backend == true) ? "true" : "false");
22960 :
22961 : #if 0
22962 : printf (" p_outputGrammarTreeFiles = %s \n",(p_outputGrammarTreeFiles == true) ? "true" : "false");
22963 : printf (" p_outputGrammarTreeFilesForHeaderFiles = %s \n",(p_outputGrammarTreeFilesForHeaderFiles == true) ? "true" : "false");
22964 : printf (" p_outputGrammarTreeFilesForEDG = %s \n",(p_outputGrammarTreeFilesForEDG == true) ? "true" : "false");
22965 : #endif
22966 :
22967 0 : printf (" p_markGeneratedFiles = %s \n",(p_markGeneratedFiles == true) ? "true" : "false");
22968 0 : printf (" p_negative_test = %s \n",(p_negative_test == true) ? "true" : "false");
22969 0 : printf (" p_strict_language_handling = %s \n",(p_strict_language_handling == true) ? "true" : "false");
22970 0 : printf (" p_wave = %s \n",(p_wave == true) ? "true" : "false");
22971 0 : printf (" p_embedColorCodesInGeneratedCode = %s \n",(p_embedColorCodesInGeneratedCode == true) ? "true" : "false");
22972 0 : printf (" p_generateSourcePositionCodes = %s \n",(p_generateSourcePositionCodes == true) ? "true" : "false");
22973 0 : printf (" p_sourceFileUsesCppFileExtension = %s \n",(p_sourceFileUsesCppFileExtension == true) ? "true" : "false");
22974 0 : printf (" p_sourceFileUsesFortranFileExtension = %s \n",(p_sourceFileUsesFortranFileExtension == true) ? "true" : "false");
22975 0 : printf (" p_sourceFileUsesFortran77FileExtension = %s \n",(p_sourceFileUsesFortran77FileExtension == true) ? "true" : "false");
22976 0 : printf (" p_sourceFileUsesFortran90FileExtension = %s \n",(p_sourceFileUsesFortran90FileExtension == true) ? "true" : "false");
22977 0 : printf (" p_sourceFileUsesFortran95FileExtension = %s \n",(p_sourceFileUsesFortran95FileExtension == true) ? "true" : "false");
22978 0 : printf (" p_read_executable_file_format_only = %s \n",(p_read_executable_file_format_only == true) ? "true" : "false");
22979 0 : printf (" p_read_instructions_only = %s \n",(p_read_instructions_only == true) ? "true" : "false");
22980 :
22981 0 : printf (" p_unparse_tokens = %s \n",(p_unparse_tokens == true) ? "true" : "false");
22982 0 : printf (" p_unparse_tokens_testing = %d \n",p_unparse_tokens_testing);
22983 :
22984 : // DQ (11/12/2014): Addded to support test modes for token unparsing.
22985 0 : printf (" p_unparse_using_leading_and_trailing_token_mappings = %s \n",(p_unparse_using_leading_and_trailing_token_mappings == true) ? "true" : "false");
22986 :
22987 0 : printf (" p_detect_dangling_pointers = %d \n",p_detect_dangling_pointers);
22988 :
22989 0 : printf (" p_skipAstConsistancyTests = %s \n",(p_skipAstConsistancyTests == true) ? "true" : "false");
22990 :
22991 : // DQ (6/8/2013): Added support for experimental fortran frontend.
22992 0 : printf (" p_experimental_fortran_frontend = %s \n",(p_experimental_fortran_frontend == true) ? "true" : "false");
22993 0 : printf (" p_experimental_fortran_frontend_OFP_test = %s \n",(p_experimental_fortran_frontend_OFP_test == true) ? "true" : "false");
22994 :
22995 : // Rasmussen (3/12/2018): Added support for CUDA Fortran within the experimental fortran frontend.
22996 0 : printf (" p_experimental_cuda_fortran_frontend = %s \n",(p_experimental_cuda_fortran_frontend == true) ? "true" : "false");
22997 :
22998 : // DQ (4/17/2015): Adding multifile handling support for commandline generation.
22999 0 : printf (" p_multifile_support = %s \n",(p_multifile_support == true) ? "true" : "false");
23000 :
23001 : // DQ (12/11/2015): Option to use the token stream mapping and local tests of the
23002 : // token sequence, to improve the source position information stored in the AST.
23003 0 : printf (" p_use_token_stream_to_improve_source_position_info = %s \n",(p_use_token_stream_to_improve_source_position_info == true) ? "true" : "false");
23004 :
23005 : // DQ (12/23/2015): Suppress variable declaration normalizations
23006 0 : printf (" p_suppress_variable_declaration_normalization = %s \n",(p_suppress_variable_declaration_normalization == true) ? "true" : "false");
23007 :
23008 : #if 0
23009 : // Order of data member entries in support.C, matched against the
23010 : // initialization to make sure that all data members are initialized.
23011 : X startOfConstruct
23012 : X root
23013 : X verbose
23014 : X output_warnings
23015 : X C_only
23016 : X UPC_only
23017 : X upc_threads
23018 : X C99_only
23019 : X Cxx_only
23020 : X Fortran_only
23021 : X F77_only
23022 : X F90_only
23023 : X F95_only
23024 : X F2003_only
23025 : X requires_C_preprocessor
23026 : X inputFormat
23027 : X outputFormat
23028 : X backendCompileFormat
23029 : X fortran_implicit_none
23030 : X fortran_openmp
23031 : X cray_pointer_support
23032 : X output_parser_actions
23033 : X exit_after_parser
23034 : X skip_syntax_check
23035 : X skip_transformation
23036 : X skip_unparse
23037 : X skipfinalCompileStep
23038 : X unparse_includes
23039 : X unparse_line_directives
23040 : X unparse_instruction_addresses
23041 : X unparse_raw_memory_contents
23042 : X unparse_binary_file_format
23043 : X outputLanguage
23044 : STRING sourceFileNameWithPath
23045 : STRING sourceFileNameWithoutPath
23046 : STRING unparse_output_filename
23047 : X useBackendOnly
23048 : X compileOnly
23049 : STRING savedFrontendCommandLine
23050 : X no_implicit_templates
23051 : X no_implicit_inline_templates
23052 : X skip_commentsAndDirectives
23053 : X collectAllCommentsAndDirectives
23054 : X unparseHeaderFiles
23055 : X preprocessorDirectivesAndCommentsList
23056 : X attributeMechanism
23057 : X KCC_frontend
23058 : X new_frontend
23059 : X disable_edg_backend
23060 : X disable_sage_backend
23061 : X testingLevel
23062 : X preinit_il
23063 : X enable_cp_backend
23064 : // X outputGrammarTreeFiles
23065 : // X outputGrammarTreeFilesForHeaderFiles
23066 : // X outputGrammarTreeFilesForEDG
23067 :
23068 : X markGeneratedFiles
23069 : X negative_test
23070 : X strict_language_handling
23071 : X embedColorCodesInGeneratedCode
23072 : X generateSourcePositionCodes
23073 : X sourceFileUsesCppFileExtension
23074 : X sourceFileUsesFortranFileExtension
23075 : X sourceFileUsesFortran77FileExtension
23076 : X sourceFileUsesFortran90FileExtension
23077 : X sourceFileUsesFortran95FileExtension
23078 : X sourceFileUsesPHPFileExtension
23079 : X sourceFileUsesBinaryFileExtension
23080 : X binaryFile
23081 : X read_executable_file_format_only
23082 : X read_instructions_only
23083 : X aggressive
23084 : #endif
23085 0 : }
23086 :
23087 :
23088 : // DQ (5/23/2015): Added support for p_skip_unparse_asm_commands to be implemented
23089 : // as a static member variable instead of non-static member variable. See test2015_141.c
23090 : // for where this is required.
23091 : bool
23092 0 : SgFile::get_skip_unparse_asm_commands()
23093 : {
23094 0 : return p_skip_unparse_asm_commands;
23095 : }
23096 :
23097 : // DQ (5/23/2015): Added support for p_skip_unparse_asm_commands to be implemented
23098 : // as a static member variable instead of non-static member variable. See test2015_141.c
23099 : // for where this is required.
23100 : void
23101 0 : SgFile::set_skip_unparse_asm_commands( bool b )
23102 : {
23103 0 : p_skip_unparse_asm_commands = b;
23104 0 : }
23105 :
23106 :
23107 : // DQ (5/23/2015): Added support for p_header_file_unparsing_optimization to be implemented
23108 : // as a static member variable instead of non-static member variable.
23109 : bool
23110 4 : SgFile::get_header_file_unparsing_optimization()
23111 : {
23112 : #if 0
23113 : printf ("In SgFile::get_header_file_unparsing_optimization(): returning %s \n",p_header_file_unparsing_optimization ? "true" : "false");
23114 : #endif
23115 4 : return p_header_file_unparsing_optimization;
23116 : }
23117 :
23118 : // DQ (5/23/2015): Added support for p_header_file_unparsing_optimization to be implemented
23119 : // as a static member variable instead of non-static member variable.
23120 : void
23121 0 : SgFile::set_header_file_unparsing_optimization( bool b )
23122 : {
23123 : #if 0
23124 : printf ("In SgFile::set_header_file_unparsing_optimization(): setting to %s \n",b ? "true" : "false");
23125 : #endif
23126 : #if 0
23127 : // DQ (4/28/2021): This is for debugging.
23128 : if (b == false)
23129 : {
23130 : printf ("In SgFile::set_header_file_unparsing_optimization(): exiting when setting to false \n");
23131 : ROSE_ASSERT(false);
23132 : }
23133 : #endif
23134 :
23135 0 : p_header_file_unparsing_optimization = b;
23136 0 : }
23137 :
23138 :
23139 :
23140 :
23141 : // End of memberFunctionString
23142 : // Start of memberFunctionString
23143 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
23144 :
23145 : // *** COMMON CODE SECTION BEGINS HERE ***
23146 :
23147 : #if 0
23148 : int
23149 : SgFile::getVariant() const
23150 : {
23151 : // This function is used in ROSE while "variant()" is used in SAGE
23152 : assert(this != NULL);
23153 : return variant();
23154 : }
23155 : #endif
23156 :
23157 : // This function is used in ROSE in treeTraversal code
23158 : // eventually replaces getVariant() and variant()
23159 : // though after variant() has been removed for a while we will
23160 : // want to change the name of variantT() back to variant()
23161 : // (since the "T" was ment to stand for temporary).
23162 : // When this happens the variantT() will be depricated.
23163 : VariantT
23164 33762 : SgFile::variantT() const
23165 : {
23166 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
23167 33762 : ROSE_ASSERT(this != NULL);
23168 33762 : return V_SgFile;
23169 : }
23170 :
23171 : #if 0
23172 : int
23173 : SgFile::variant() const
23174 : {
23175 : // This function is used in SAGE
23176 : ROSE_ASSERT(this != NULL);
23177 : return FileTag;
23178 : }
23179 : #endif
23180 :
23181 : ROSE_DLL_API const char*
23182 0 : SgFile::sage_class_name() const
23183 : {
23184 0 : ROSE_ASSERT(this != NULL);
23185 0 : return "SgFile";
23186 : }
23187 :
23188 : std::string
23189 0 : SgFile::class_name() const
23190 : {
23191 0 : ROSE_ASSERT(this != NULL);
23192 0 : return "SgFile";
23193 : }
23194 :
23195 : // DQ (11/26/2005): Support for visitor pattern mechanims
23196 : // (inferior to ROSE traversal mechanism, experimental).
23197 : void
23198 0 : SgFile::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
23199 : {
23200 0 : ROSE_ASSERT(this != NULL);
23201 0 : visitor.visit(this);
23202 0 : }
23203 :
23204 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
23205 0 : void SgFile::accept (ROSE_VisitorPattern & visitor) {
23206 0 : ROSE_ASSERT(this != NULL);
23207 0 : visitor.visit(this);
23208 0 : }
23209 :
23210 : SgFile*
23211 0 : SgFile::addRegExpAttribute(std::string s, AstRegExAttribute* a)
23212 : {
23213 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
23214 : // This function is currently only supported for the AST used the represent Binary executables.
23215 : if (0 /* isSgAsmNode(this) != NULL */)
23216 : {
23217 : // Support for regex specification.
23218 : std::string prefixCode = "REGEX:";
23219 : addNewAttribute(prefixCode + s,a);
23220 : }
23221 : #endif
23222 :
23223 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
23224 0 : return this;
23225 : }
23226 :
23227 : // *** COMMON CODE SECTION ENDS HERE ***
23228 :
23229 :
23230 : // End of memberFunctionString
23231 : // Start of memberFunctionString
23232 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
23233 :
23234 :
23235 : #if 0
23236 : //! Error checking support
23237 : /*! Verifies the following:
23238 : - working getVariant() member function
23239 : - calls base class's error() member function
23240 : Every class has one of these functions.
23241 : */
23242 : bool
23243 : SgFile::error()
23244 : {
23245 : // Put error checking here
23246 :
23247 : ROSE_ASSERT (this != NULL);
23248 : if (getVariant() != FileTag)
23249 : {
23250 : printf ("Error in SgFile::error(): SgFile object has a %s variant \n",
23251 : Cxx_GrammarTerminalNames[getVariant()].name);
23252 : // printf ("Error in SgFile::error() \n");
23253 : ROSE_ABORT();
23254 : }
23255 :
23256 : ROSE_ASSERT (getVariant() == FileTag);
23257 : return SgSupport::error();
23258 : }
23259 : #endif
23260 :
23261 :
23262 :
23263 : // End of memberFunctionString
23264 :
23265 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
23266 :
23267 22784000 : SgFile* isSgFile ( SgNode* inputDerivedClassPointer )
23268 : {
23269 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
23270 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
23271 : // So to fix this we return NULL directly when the input is NULL and avoid the
23272 : // dynamic_cast in this case. This is likely a performance improvement as well.
23273 : // return dynamic_cast<SgFile*>(inputDerivedClassPointer);
23274 : // Milind Chabbi (8/28/2013): isSgFile uses table-driven castability instead of c++ default dynamic_cast
23275 : // this improves the running time performance by 10-20%.
23276 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFile*>(inputDerivedClassPointer);
23277 22784000 : return IS_SgFile_FAST_MACRO(inputDerivedClassPointer);
23278 : }
23279 :
23280 : // DQ (11/8/2003): Added version of functions taking const pointer
23281 6097260 : const SgFile* isSgFile ( const SgNode* inputDerivedClassPointer )
23282 : {
23283 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
23284 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
23285 : // So to fix this we return NULL directly when the input is NULL and avoid the
23286 : // dynamic_cast in this case. This is likely a performance improvement as well.
23287 : // return dynamic_cast<const SgFile*>(inputDerivedClassPointer);
23288 : // Milind Chabbi (8/28/2013): isSgFile uses table-driven castability instead of c++ default dynamic_cast
23289 : // this improves the running time performance by 10-20%.
23290 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFile*>(inputDerivedClassPointer);
23291 6097260 : return IS_SgFile_FAST_MACRO(inputDerivedClassPointer);
23292 : }
23293 :
23294 :
23295 :
23296 : /* #line 23297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
23297 :
23298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
23299 :
23300 : /**
23301 : \brief Generated destructor
23302 :
23303 : This destructor is automatically generated (by ROSETTA). This destructor
23304 : only frees memory of data members associated with the parts of the current IR node which
23305 : are NOT traversed. Those data members that are part of a traversal can be freed using
23306 : a traversal (calling this destructor on all children in a post-order traversal). Such
23307 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
23308 :
23309 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
23310 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
23311 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
23312 :
23313 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
23314 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
23315 : pointers are not yet implemented to call delete on eash pointer in the container.
23316 : (This could be done by derivation from the STL containers to define containers that
23317 : automatically deleted their members.)
23318 :
23319 : */
23320 800 : SgFile::~SgFile () {
23321 395 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
23322 :
23323 395 : if (p_startOfConstruct && p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_startOfConstruct; }
23324 :
23325 : // case: not a listType for startOfConstruct
23326 395 : p_startOfConstruct = NULL; // non list case
23327 : // case: not a listType for verbose
23328 395 : p_verbose = 0; // non list case
23329 : // case: not a listType for output_warnings
23330 395 : p_output_warnings = false; // non list case
23331 : // case: not a listType for C_only
23332 395 : p_C_only = false; // non list case
23333 : // case: not a listType for Cxx_only
23334 395 : p_Cxx_only = false; // non list case
23335 : // case: not a listType for Fortran_only
23336 395 : p_Fortran_only = false; // non list case
23337 : // case: not a listType for CoArrayFortran_only
23338 395 : p_CoArrayFortran_only = false; // non list case
23339 : // case: not a listType for upc_threads
23340 395 : p_upc_threads = 0; // non list case
23341 : // case: not a listType for Cuda_only
23342 395 : p_Cuda_only = false; // non list case
23343 : // case: not a listType for OpenCL_only
23344 395 : p_OpenCL_only = false; // non list case
23345 : // case: not a listType for requires_C_preprocessor
23346 395 : p_requires_C_preprocessor = true; // non list case
23347 : // case: not a listType for inputFormat
23348 395 : p_inputFormat = SgFile::e_unknown_output_format; // non list case
23349 : // case: not a listType for outputFormat
23350 395 : p_outputFormat = SgFile::e_unknown_output_format; // non list case
23351 : // case: not a listType for backendCompileFormat
23352 395 : p_backendCompileFormat = SgFile::e_unknown_output_format; // non list case
23353 : // case: not a listType for fortran_implicit_none
23354 395 : p_fortran_implicit_none = false; // non list case
23355 : // case: not a listType for openmp
23356 395 : p_openmp = false; // non list case
23357 : // case: not a listType for openmp_parse_only
23358 395 : p_openmp_parse_only = false; // non list case
23359 : // case: not a listType for openmp_ast_only
23360 395 : p_openmp_ast_only = false; // non list case
23361 : // case: not a listType for openmp_lowering
23362 395 : p_openmp_lowering = false; // non list case
23363 : // case: not a listType for openmp_analyzing
23364 395 : p_openmp_analyzing = false; // non list case
23365 : // case: not a listType for cray_pointer_support
23366 395 : p_cray_pointer_support = false; // non list case
23367 : // case: not a listType for failsafe
23368 395 : p_failsafe = false; // non list case
23369 : // case: not a listType for output_parser_actions
23370 395 : p_output_parser_actions = false; // non list case
23371 : // case: not a listType for exit_after_parser
23372 395 : p_exit_after_parser = false; // non list case
23373 : // case: not a listType for skip_syntax_check
23374 395 : p_skip_syntax_check = false; // non list case
23375 : // case: not a listType for skip_parser
23376 395 : p_skip_parser = false; // non list case
23377 : // case: not a listType for relax_syntax_check
23378 395 : p_relax_syntax_check = false; // non list case
23379 : // case: not a listType for skip_translation_from_edg_ast_to_rose_ast
23380 395 : p_skip_translation_from_edg_ast_to_rose_ast = false; // non list case
23381 : // case: not a listType for skip_transformation
23382 395 : p_skip_transformation = false; // non list case
23383 : // case: not a listType for skip_unparse
23384 395 : p_skip_unparse = false; // non list case
23385 : // case: not a listType for skipfinalCompileStep
23386 395 : p_skipfinalCompileStep = false; // non list case
23387 : // case: not a listType for unparse_includes
23388 395 : p_unparse_includes = false; // non list case
23389 : // case: not a listType for unparse_line_directives
23390 395 : p_unparse_line_directives = false; // non list case
23391 : // case: not a listType for unparse_function_calls_using_operator_syntax
23392 395 : p_unparse_function_calls_using_operator_syntax = false; // non list case
23393 : // case: not a listType for unparse_function_calls_using_operator_names
23394 395 : p_unparse_function_calls_using_operator_names = false; // non list case
23395 : // case: not a listType for unparse_instruction_addresses
23396 395 : p_unparse_instruction_addresses = true; // non list case
23397 : // case: not a listType for unparse_raw_memory_contents
23398 395 : p_unparse_raw_memory_contents = true; // non list case
23399 : // case: not a listType for unparse_binary_file_format
23400 395 : p_unparse_binary_file_format = true; // non list case
23401 : // case: not a listType for outputLanguage
23402 395 : p_outputLanguage = SgFile::e_default_language; // non list case
23403 : // case: not a listType for inputLanguage
23404 395 : p_inputLanguage = SgFile::e_default_language; // non list case
23405 : // case: not a listType for sourceFileNameWithPath
23406 395 : p_sourceFileNameWithPath = ""; // non list case
23407 : // case: not a listType for sourceFileNameWithoutPath
23408 395 : p_sourceFileNameWithoutPath = ""; // non list case
23409 : // case: not a listType for unparse_output_filename
23410 395 : p_unparse_output_filename = ""; // non list case
23411 : // case: not a listType for objectFileNameWithPath
23412 395 : p_objectFileNameWithPath = ""; // non list case
23413 : // case: not a listType for objectFileNameWithoutPath
23414 395 : p_objectFileNameWithoutPath = ""; // non list case
23415 : // case: not a listType for useBackendOnly
23416 395 : p_useBackendOnly = false; // non list case
23417 : // case: not a listType for compileOnly
23418 395 : p_compileOnly = false; // non list case
23419 : // case: not a listType for savedFrontendCommandLine
23420 395 : p_savedFrontendCommandLine = ""; // non list case
23421 : // case: not a listType for no_implicit_templates
23422 395 : p_no_implicit_templates = false; // non list case
23423 : // case: not a listType for no_implicit_inline_templates
23424 395 : p_no_implicit_inline_templates = false; // non list case
23425 : // case: not a listType for skip_commentsAndDirectives
23426 395 : p_skip_commentsAndDirectives = false; // non list case
23427 : // case: not a listType for collectAllCommentsAndDirectives
23428 395 : p_collectAllCommentsAndDirectives = false; // non list case
23429 : // case: not a listType for translateCommentsAndDirectivesIntoAST
23430 395 : p_translateCommentsAndDirectivesIntoAST = false; // non list case
23431 : // case: not a listType for unparseHeaderFiles
23432 395 : p_unparseHeaderFiles = false; // non list case
23433 : // case: not a listType for preprocessorDirectivesAndCommentsList
23434 395 : p_preprocessorDirectivesAndCommentsList = NULL; // non list case
23435 : // case: not a listType for attributeMechanism
23436 395 : p_attributeMechanism = NULL; // non list case
23437 : // case: not a listType for KCC_frontend
23438 395 : p_KCC_frontend = false; // non list case
23439 : // case: not a listType for new_frontend
23440 395 : p_new_frontend = false; // non list case
23441 : // case: not a listType for disable_edg_backend
23442 395 : p_disable_edg_backend = false; // non list case
23443 : // case: not a listType for disable_sage_backend
23444 395 : p_disable_sage_backend = false; // non list case
23445 : // case: not a listType for testingLevel
23446 395 : p_testingLevel = -1; // non list case
23447 : // case: not a listType for preinit_il
23448 395 : p_preinit_il = false; // non list case
23449 : // case: not a listType for enable_cp_backend
23450 395 : p_enable_cp_backend = false; // non list case
23451 : // case: not a listType for markGeneratedFiles
23452 395 : p_markGeneratedFiles = false; // non list case
23453 : // case: not a listType for negative_test
23454 395 : p_negative_test = false; // non list case
23455 : // case: not a listType for strict_language_handling
23456 395 : p_strict_language_handling = false; // non list case
23457 : // case: not a listType for wave
23458 395 : p_wave = false; // non list case
23459 : // case: not a listType for embedColorCodesInGeneratedCode
23460 395 : p_embedColorCodesInGeneratedCode = 0; // non list case
23461 : // case: not a listType for generateSourcePositionCodes
23462 395 : p_generateSourcePositionCodes = 0; // non list case
23463 : // case: not a listType for sourceFileUsesCppFileExtension
23464 395 : p_sourceFileUsesCppFileExtension = false; // non list case
23465 : // case: not a listType for sourceFileUsesFortranFileExtension
23466 395 : p_sourceFileUsesFortranFileExtension = false; // non list case
23467 : // case: not a listType for sourceFileUsesFortran77FileExtension
23468 395 : p_sourceFileUsesFortran77FileExtension = false; // non list case
23469 : // case: not a listType for sourceFileUsesFortran90FileExtension
23470 395 : p_sourceFileUsesFortran90FileExtension = false; // non list case
23471 : // case: not a listType for sourceFileUsesFortran95FileExtension
23472 395 : p_sourceFileUsesFortran95FileExtension = false; // non list case
23473 : // case: not a listType for sourceFileUsesFortran2003FileExtension
23474 395 : p_sourceFileUsesFortran2003FileExtension = false; // non list case
23475 : // case: not a listType for sourceFileUsesFortran2008FileExtension
23476 395 : p_sourceFileUsesFortran2008FileExtension = false; // non list case
23477 : // case: not a listType for sourceFileUsesCoArrayFortranFileExtension
23478 395 : p_sourceFileUsesCoArrayFortranFileExtension = false; // non list case
23479 : // case: not a listType for sourceFileUsesPHPFileExtension
23480 395 : p_sourceFileUsesPHPFileExtension = false; // non list case
23481 : // case: not a listType for sourceFileUsesPythonFileExtension
23482 395 : p_sourceFileUsesPythonFileExtension = false; // non list case
23483 : // case: not a listType for sourceFileTypeIsUnknown
23484 395 : p_sourceFileTypeIsUnknown = false; // non list case
23485 : // case: not a listType for detect_dangling_pointers
23486 395 : p_detect_dangling_pointers = false; // non list case
23487 : // case: not a listType for experimental_fortran_frontend
23488 395 : p_experimental_fortran_frontend = false; // non list case
23489 : // case: not a listType for experimental_flang_frontend
23490 395 : p_experimental_flang_frontend = false; // non list case
23491 : // case: not a listType for experimental_cuda_fortran_frontend
23492 395 : p_experimental_cuda_fortran_frontend = false; // non list case
23493 : // case: not a listType for experimental_fortran_frontend_OFP_test
23494 395 : p_experimental_fortran_frontend_OFP_test = false; // non list case
23495 : // case: not a listType for read_executable_file_format_only
23496 395 : p_read_executable_file_format_only = false; // non list case
23497 : // case: not a listType for visualize_executable_file_format_skip_symbols
23498 395 : p_visualize_executable_file_format_skip_symbols = false; // non list case
23499 : // case: not a listType for visualize_dwarf_only
23500 395 : p_visualize_dwarf_only = false; // non list case
23501 : // case: not a listType for read_instructions_only
23502 395 : p_read_instructions_only = false; // non list case
23503 : // case: not a listType for isLibraryArchive
23504 395 : p_isLibraryArchive = false; // non list case
23505 : // case: not a listType for isObjectFile
23506 395 : p_isObjectFile = false; // non list case
23507 : // case: not a listType for unparse_tokens
23508 395 : p_unparse_tokens = false; // non list case
23509 : // case: not a listType for unparse_tokens_testing
23510 395 : p_unparse_tokens_testing = 0; // non list case
23511 : // case: not a listType for unparse_using_leading_and_trailing_token_mappings
23512 395 : p_unparse_using_leading_and_trailing_token_mappings = false; // non list case
23513 : // case: not a listType for unparse_template_ast
23514 395 : p_unparse_template_ast = false; // non list case
23515 : // case: not a listType for skipAstConsistancyTests
23516 395 : p_skipAstConsistancyTests = false; // non list case
23517 : // case: not a listType for multifile_support
23518 395 : p_multifile_support = false; // non list case
23519 : // case: not a listType for optimization
23520 395 : p_optimization = false; // non list case
23521 : // case: not a listType for use_token_stream_to_improve_source_position_info
23522 395 : p_use_token_stream_to_improve_source_position_info = false; // non list case
23523 : // case: not a listType for suppress_variable_declaration_normalization
23524 395 : p_suppress_variable_declaration_normalization = false; // non list case
23525 : // case: not a listType for edg_il_to_graphviz
23526 395 : p_edg_il_to_graphviz = false; // non list case
23527 : // case: not a listType for clang_il_to_graphviz
23528 395 : p_clang_il_to_graphviz = false; // non list case
23529 : // case: not a listType for no_optimize_flag_for_frontend
23530 395 : p_no_optimize_flag_for_frontend = false; // non list case
23531 : // case: not a listType for unparse_edg_normalized_method_ROSE_1392
23532 395 : p_unparse_edg_normalized_method_ROSE_1392 = false; // non list case
23533 : // case: not a listType for header_file_unparsing_optimization_source_file
23534 395 : p_header_file_unparsing_optimization_source_file = false; // non list case
23535 : // case: not a listType for header_file_unparsing_optimization_header_file
23536 395 : p_header_file_unparsing_optimization_header_file = false; // non list case
23537 : // case: not a listType for standard
23538 395 : p_standard = e_default_standard; // non list case
23539 : // case: not a listType for gnu_standard
23540 395 : p_gnu_standard = false; // non list case
23541 : // case: not a listType for frontendErrorCode
23542 395 : p_frontendErrorCode = 0; // non list case
23543 : // case: not a listType for javacErrorCode
23544 395 : p_javacErrorCode = 0; // non list case
23545 : // case: not a listType for ecjErrorCode
23546 395 : p_ecjErrorCode = 0; // non list case
23547 : // case: not a listType for midendErrorCode
23548 395 : p_midendErrorCode = 0; // non list case
23549 : // case: not a listType for unparserErrorCode
23550 395 : p_unparserErrorCode = 0; // non list case
23551 : // case: not a listType for backendCompilerErrorCode
23552 395 : p_backendCompilerErrorCode = 0; // non list case
23553 : // case: not a listType for unparsedFileFailedCompilation
23554 395 : p_unparsedFileFailedCompilation = false; // non list case
23555 :
23556 : }
23557 :
23558 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
23559 395 : }
23560 :
23561 :
23562 : /* #line 23563 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
23563 :
23564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
23565 :
23566 : // Generated constructor
23567 11254 : SgFile::SgFile ( )
23568 11254 : : SgSupport()
23569 : {
23570 : #ifdef DEBUG
23571 : // printf ("In SgFile::SgFile () sage_class_name() = %s \n",sage_class_name());
23572 : #endif
23573 : #if 0
23574 : // debugging information!
23575 : printf ("In SgFile::SgFile (): this = %p = %s \n",this,this->class_name().c_str());
23576 : #endif
23577 :
23578 11254 : p_startOfConstruct = NULL;
23579 11254 : p_verbose = 0;
23580 11254 : p_output_warnings = false;
23581 11254 : p_C_only = false;
23582 11254 : p_Cxx_only = false;
23583 11254 : p_Fortran_only = false;
23584 11254 : p_CoArrayFortran_only = false;
23585 11254 : p_upc_threads = 0;
23586 11254 : p_Cuda_only = false;
23587 11254 : p_OpenCL_only = false;
23588 11254 : p_requires_C_preprocessor = true;
23589 11254 : p_inputFormat = SgFile::e_unknown_output_format;
23590 11254 : p_outputFormat = SgFile::e_unknown_output_format;
23591 11254 : p_backendCompileFormat = SgFile::e_unknown_output_format;
23592 11254 : p_fortran_implicit_none = false;
23593 11254 : p_openmp = false;
23594 11254 : p_openmp_parse_only = false;
23595 11254 : p_openmp_ast_only = false;
23596 11254 : p_openmp_lowering = false;
23597 11254 : p_openmp_analyzing = false;
23598 11254 : p_cray_pointer_support = false;
23599 11254 : p_failsafe = false;
23600 11254 : p_output_parser_actions = false;
23601 11254 : p_exit_after_parser = false;
23602 11254 : p_skip_syntax_check = false;
23603 11254 : p_skip_parser = false;
23604 11254 : p_relax_syntax_check = false;
23605 11254 : p_skip_translation_from_edg_ast_to_rose_ast = false;
23606 11254 : p_skip_transformation = false;
23607 11254 : p_skip_unparse = false;
23608 11254 : p_skipfinalCompileStep = false;
23609 11254 : p_unparse_includes = false;
23610 11254 : p_unparse_line_directives = false;
23611 11254 : p_unparse_function_calls_using_operator_syntax = false;
23612 11254 : p_unparse_function_calls_using_operator_names = false;
23613 11254 : p_unparse_instruction_addresses = true;
23614 11254 : p_unparse_raw_memory_contents = true;
23615 11254 : p_unparse_binary_file_format = true;
23616 11254 : p_outputLanguage = SgFile::e_default_language;
23617 11254 : p_inputLanguage = SgFile::e_default_language;
23618 11254 : p_sourceFileNameWithPath = "";
23619 11254 : p_sourceFileNameWithoutPath = "";
23620 11254 : p_unparse_output_filename = "";
23621 11254 : p_objectFileNameWithPath = "";
23622 11254 : p_objectFileNameWithoutPath = "";
23623 11254 : p_useBackendOnly = false;
23624 11254 : p_compileOnly = false;
23625 11254 : p_savedFrontendCommandLine = "";
23626 11254 : p_no_implicit_templates = false;
23627 11254 : p_no_implicit_inline_templates = false;
23628 11254 : p_skip_commentsAndDirectives = false;
23629 11254 : p_collectAllCommentsAndDirectives = false;
23630 11254 : p_translateCommentsAndDirectivesIntoAST = false;
23631 11254 : p_unparseHeaderFiles = false;
23632 11254 : p_preprocessorDirectivesAndCommentsList = NULL;
23633 11254 : p_attributeMechanism = NULL;
23634 11254 : p_KCC_frontend = false;
23635 11254 : p_new_frontend = false;
23636 11254 : p_disable_edg_backend = false;
23637 11254 : p_disable_sage_backend = false;
23638 11254 : p_testingLevel = -1;
23639 11254 : p_preinit_il = false;
23640 11254 : p_enable_cp_backend = false;
23641 11254 : p_markGeneratedFiles = false;
23642 11254 : p_negative_test = false;
23643 11254 : p_strict_language_handling = false;
23644 11254 : p_wave = false;
23645 11254 : p_embedColorCodesInGeneratedCode = 0;
23646 11254 : p_generateSourcePositionCodes = 0;
23647 11254 : p_sourceFileUsesCppFileExtension = false;
23648 11254 : p_sourceFileUsesFortranFileExtension = false;
23649 11254 : p_sourceFileUsesFortran77FileExtension = false;
23650 11254 : p_sourceFileUsesFortran90FileExtension = false;
23651 11254 : p_sourceFileUsesFortran95FileExtension = false;
23652 11254 : p_sourceFileUsesFortran2003FileExtension = false;
23653 11254 : p_sourceFileUsesFortran2008FileExtension = false;
23654 11254 : p_sourceFileUsesCoArrayFortranFileExtension = false;
23655 11254 : p_sourceFileUsesPHPFileExtension = false;
23656 11254 : p_sourceFileUsesPythonFileExtension = false;
23657 11254 : p_sourceFileTypeIsUnknown = false;
23658 11254 : p_detect_dangling_pointers = false;
23659 11254 : p_experimental_fortran_frontend = false;
23660 11254 : p_experimental_flang_frontend = false;
23661 11254 : p_experimental_cuda_fortran_frontend = false;
23662 11254 : p_experimental_fortran_frontend_OFP_test = false;
23663 11254 : p_read_executable_file_format_only = false;
23664 11254 : p_visualize_executable_file_format_skip_symbols = false;
23665 11254 : p_visualize_dwarf_only = false;
23666 11254 : p_read_instructions_only = false;
23667 11254 : p_skip_unparse_asm_commands = false;
23668 11254 : p_isLibraryArchive = false;
23669 11254 : p_isObjectFile = false;
23670 11254 : p_unparse_tokens = false;
23671 11254 : p_unparse_tokens_testing = 0;
23672 11254 : p_unparse_using_leading_and_trailing_token_mappings = false;
23673 11254 : p_unparse_template_ast = false;
23674 11254 : p_skipAstConsistancyTests = false;
23675 11254 : p_multifile_support = false;
23676 11254 : p_optimization = false;
23677 11254 : p_use_token_stream_to_improve_source_position_info = false;
23678 11254 : p_suppress_variable_declaration_normalization = false;
23679 11254 : p_edg_il_to_graphviz = false;
23680 11254 : p_clang_il_to_graphviz = false;
23681 11254 : p_no_optimize_flag_for_frontend = false;
23682 11254 : p_unparse_edg_normalized_method_ROSE_1392 = false;
23683 11254 : p_header_file_unparsing_optimization = false;
23684 11254 : p_header_file_unparsing_optimization_source_file = false;
23685 11254 : p_header_file_unparsing_optimization_header_file = false;
23686 11254 : p_standard = e_default_standard;
23687 11254 : p_gnu_standard = false;
23688 11254 : p_frontendErrorCode = 0;
23689 11254 : p_javacErrorCode = 0;
23690 11254 : p_ecjErrorCode = 0;
23691 11254 : p_midendErrorCode = 0;
23692 11254 : p_unparserErrorCode = 0;
23693 11254 : p_backendCompilerErrorCode = 0;
23694 11254 : p_unparsedFileFailedCompilation = false;
23695 :
23696 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
23697 :
23698 : #if 0
23699 : // DQ (7/30/2014): Call a virtual function.
23700 : std::string s = this->class_name();
23701 : #endif
23702 :
23703 : // Test the variant virtual function
23704 : // assert(FileTag == variant());
23705 11254 : assert(FileTag == this->variant());
23706 11254 : ROSE_ASSERT(FileTag == (int)(this->variantT()));
23707 11254 : post_construction_initialization();
23708 :
23709 : // Test the isSgFile() function since it has been problematic
23710 11254 : assert(isSgFile(this) != NULL);
23711 11254 : }
23712 :
23713 : // Generated constructor (all data members)
23714 :
23715 : /* #line 23716 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
23716 :
23717 :
23718 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
23719 :
23720 :
23721 : // ********************************************************
23722 : // member functions common across all array grammar objects
23723 : // ********************************************************
23724 :
23725 :
23726 :
23727 : /* #line 23728 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
23728 :
23729 :
23730 :
23731 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
23732 :
23733 : // ********************************************************
23734 : // member functions specific to each node in the grammar
23735 : // ********************************************************
23736 :
23737 :
23738 : /* #line 23739 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
23739 :
23740 : // Start of memberFunctionString
23741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
23742 :
23743 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23744 :
23745 : SgGlobal*
23746 41323 : SgSourceFile::get_globalScope () const
23747 : {
23748 41323 : ROSE_ASSERT (this != NULL);
23749 :
23750 : #if 0
23751 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23752 : // used to trigger marking transformations for the token-based unparsing.
23753 : printf ("SgSourceFile::get_globalScope = %p = %s \n",this,this->class_name().c_str());
23754 : #endif
23755 :
23756 41323 : return p_globalScope;
23757 : }
23758 :
23759 : void
23760 11931 : SgSourceFile::set_globalScope ( SgGlobal* globalScope )
23761 : {
23762 11931 : ROSE_ASSERT (this != NULL);
23763 :
23764 : #if 0
23765 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23766 : // used to trigger marking transformations for the token-based unparsing.
23767 : printf ("SgSourceFile::set_globalScope = %p = %s \n",this,this->class_name().c_str());
23768 : #endif
23769 :
23770 11931 : set_isModified(true);
23771 :
23772 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
23773 : if (p_globalScope != NULL && globalScope != NULL && p_globalScope != globalScope)
23774 : {
23775 : printf ("Warning: globalScope = %p overwriting valid pointer p_globalScope = %p \n",globalScope,p_globalScope);
23776 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
23777 : printf ("Error fails assertion (p_globalScope != NULL && globalScope != NULL && p_globalScope != globalScope) is false\n");
23778 : ROSE_ASSERT(false);
23779 : #endif
23780 : }
23781 : #endif
23782 11931 : p_globalScope = globalScope;
23783 11931 : }
23784 :
23785 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
23786 :
23787 :
23788 : // End of memberFunctionString
23789 : // Start of memberFunctionString
23790 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
23791 :
23792 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23793 :
23794 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
23795 : const SgModuleStatementPtrList &
23796 0 : SgSourceFile::get_module_list () const
23797 : {
23798 0 : assert (this != NULL);
23799 0 : return p_module_list;
23800 : }
23801 :
23802 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
23803 : SgModuleStatementPtrList &
23804 0 : SgSourceFile::get_module_list ()
23805 : {
23806 0 : assert (this != NULL);
23807 :
23808 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
23809 : // As a rule only set_ access functions can set the isModified flag.
23810 : // set_isModified(true);
23811 :
23812 0 : return p_module_list;
23813 : }
23814 :
23815 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
23816 :
23817 :
23818 : // End of memberFunctionString
23819 : // Start of memberFunctionString
23820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
23821 :
23822 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23823 :
23824 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
23825 : const SgTokenPtrList &
23826 0 : SgSourceFile::get_token_list () const
23827 : {
23828 0 : assert (this != NULL);
23829 0 : return p_token_list;
23830 : }
23831 :
23832 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
23833 : SgTokenPtrList &
23834 0 : SgSourceFile::get_token_list ()
23835 : {
23836 0 : assert (this != NULL);
23837 :
23838 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
23839 : // As a rule only set_ access functions can set the isModified flag.
23840 : // set_isModified(true);
23841 :
23842 0 : return p_token_list;
23843 : }
23844 :
23845 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
23846 :
23847 :
23848 : // End of memberFunctionString
23849 : // Start of memberFunctionString
23850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
23851 :
23852 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23853 :
23854 : SgGlobal*
23855 0 : SgSourceFile::get_temp_holding_scope () const
23856 : {
23857 0 : ROSE_ASSERT (this != NULL);
23858 :
23859 : #if 0
23860 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23861 : // used to trigger marking transformations for the token-based unparsing.
23862 : printf ("SgSourceFile::get_temp_holding_scope = %p = %s \n",this,this->class_name().c_str());
23863 : #endif
23864 :
23865 0 : return p_temp_holding_scope;
23866 : }
23867 :
23868 : void
23869 357 : SgSourceFile::set_temp_holding_scope ( SgGlobal* temp_holding_scope )
23870 : {
23871 357 : ROSE_ASSERT (this != NULL);
23872 :
23873 : #if 0
23874 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23875 : // used to trigger marking transformations for the token-based unparsing.
23876 : printf ("SgSourceFile::set_temp_holding_scope = %p = %s \n",this,this->class_name().c_str());
23877 : #endif
23878 :
23879 357 : set_isModified(true);
23880 :
23881 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
23882 : if (p_temp_holding_scope != NULL && temp_holding_scope != NULL && p_temp_holding_scope != temp_holding_scope)
23883 : {
23884 : printf ("Warning: temp_holding_scope = %p overwriting valid pointer p_temp_holding_scope = %p \n",temp_holding_scope,p_temp_holding_scope);
23885 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
23886 : printf ("Error fails assertion (p_temp_holding_scope != NULL && temp_holding_scope != NULL && p_temp_holding_scope != temp_holding_scope) is false\n");
23887 : ROSE_ASSERT(false);
23888 : #endif
23889 : }
23890 : #endif
23891 357 : p_temp_holding_scope = temp_holding_scope;
23892 357 : }
23893 :
23894 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
23895 :
23896 :
23897 : // End of memberFunctionString
23898 : // Start of memberFunctionString
23899 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
23900 :
23901 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23902 :
23903 : bool
23904 24480 : SgSourceFile::get_isHeaderFile () const
23905 : {
23906 24480 : ROSE_ASSERT (this != NULL);
23907 :
23908 : #if 0
23909 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23910 : // used to trigger marking transformations for the token-based unparsing.
23911 : printf ("SgSourceFile::get_isHeaderFile = %p = %s \n",this,this->class_name().c_str());
23912 : #endif
23913 :
23914 24480 : return p_isHeaderFile;
23915 : }
23916 :
23917 : void
23918 23777 : SgSourceFile::set_isHeaderFile ( bool isHeaderFile )
23919 : {
23920 23777 : ROSE_ASSERT (this != NULL);
23921 :
23922 : #if 0
23923 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23924 : // used to trigger marking transformations for the token-based unparsing.
23925 : printf ("SgSourceFile::set_isHeaderFile = %p = %s \n",this,this->class_name().c_str());
23926 : #endif
23927 :
23928 23777 : set_isModified(true);
23929 :
23930 23777 : p_isHeaderFile = isHeaderFile;
23931 23777 : }
23932 :
23933 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
23934 :
23935 :
23936 : // End of memberFunctionString
23937 : // Start of memberFunctionString
23938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
23939 :
23940 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23941 :
23942 : bool
23943 0 : SgSourceFile::get_isHeaderFileIncludedMoreThanOnce () const
23944 : {
23945 0 : ROSE_ASSERT (this != NULL);
23946 :
23947 : #if 0
23948 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23949 : // used to trigger marking transformations for the token-based unparsing.
23950 : printf ("SgSourceFile::get_isHeaderFileIncludedMoreThanOnce = %p = %s \n",this,this->class_name().c_str());
23951 : #endif
23952 :
23953 0 : return p_isHeaderFileIncludedMoreThanOnce;
23954 : }
23955 :
23956 : void
23957 23777 : SgSourceFile::set_isHeaderFileIncludedMoreThanOnce ( bool isHeaderFileIncludedMoreThanOnce )
23958 : {
23959 23777 : ROSE_ASSERT (this != NULL);
23960 :
23961 : #if 0
23962 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23963 : // used to trigger marking transformations for the token-based unparsing.
23964 : printf ("SgSourceFile::set_isHeaderFileIncludedMoreThanOnce = %p = %s \n",this,this->class_name().c_str());
23965 : #endif
23966 :
23967 23777 : set_isModified(true);
23968 :
23969 23777 : p_isHeaderFileIncludedMoreThanOnce = isHeaderFileIncludedMoreThanOnce;
23970 23777 : }
23971 :
23972 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
23973 :
23974 :
23975 : // End of memberFunctionString
23976 : // Start of memberFunctionString
23977 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
23978 :
23979 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
23980 :
23981 : SgHeaderFileReport*
23982 0 : SgSourceFile::get_headerFileReport () const
23983 : {
23984 0 : ROSE_ASSERT (this != NULL);
23985 :
23986 : #if 0
23987 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
23988 : // used to trigger marking transformations for the token-based unparsing.
23989 : printf ("SgSourceFile::get_headerFileReport = %p = %s \n",this,this->class_name().c_str());
23990 : #endif
23991 :
23992 0 : return p_headerFileReport;
23993 : }
23994 :
23995 : void
23996 0 : SgSourceFile::set_headerFileReport ( SgHeaderFileReport* headerFileReport )
23997 : {
23998 0 : ROSE_ASSERT (this != NULL);
23999 :
24000 : #if 0
24001 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24002 : // used to trigger marking transformations for the token-based unparsing.
24003 : printf ("SgSourceFile::set_headerFileReport = %p = %s \n",this,this->class_name().c_str());
24004 : #endif
24005 :
24006 0 : set_isModified(true);
24007 :
24008 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
24009 : if (p_headerFileReport != NULL && headerFileReport != NULL && p_headerFileReport != headerFileReport)
24010 : {
24011 : printf ("Warning: headerFileReport = %p overwriting valid pointer p_headerFileReport = %p \n",headerFileReport,p_headerFileReport);
24012 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
24013 : printf ("Error fails assertion (p_headerFileReport != NULL && headerFileReport != NULL && p_headerFileReport != headerFileReport) is false\n");
24014 : ROSE_ASSERT(false);
24015 : #endif
24016 : }
24017 : #endif
24018 0 : p_headerFileReport = headerFileReport;
24019 0 : }
24020 :
24021 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24022 :
24023 :
24024 : // End of memberFunctionString
24025 : // Start of memberFunctionString
24026 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
24027 :
24028 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
24029 :
24030 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
24031 : const SgStringList &
24032 0 : SgSourceFile::get_extraIncludeDirectorySpecifierBeforeList () const
24033 : {
24034 0 : assert (this != NULL);
24035 0 : return p_extraIncludeDirectorySpecifierBeforeList;
24036 : }
24037 :
24038 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
24039 : SgStringList &
24040 0 : SgSourceFile::get_extraIncludeDirectorySpecifierBeforeList ()
24041 : {
24042 0 : assert (this != NULL);
24043 :
24044 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
24045 : // As a rule only set_ access functions can set the isModified flag.
24046 : // set_isModified(true);
24047 :
24048 0 : return p_extraIncludeDirectorySpecifierBeforeList;
24049 : }
24050 :
24051 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24052 :
24053 :
24054 : // End of memberFunctionString
24055 : // Start of memberFunctionString
24056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
24057 :
24058 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
24059 :
24060 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
24061 : const SgStringList &
24062 0 : SgSourceFile::get_extraIncludeDirectorySpecifierAfterList () const
24063 : {
24064 0 : assert (this != NULL);
24065 0 : return p_extraIncludeDirectorySpecifierAfterList;
24066 : }
24067 :
24068 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
24069 : SgStringList &
24070 0 : SgSourceFile::get_extraIncludeDirectorySpecifierAfterList ()
24071 : {
24072 0 : assert (this != NULL);
24073 :
24074 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
24075 : // As a rule only set_ access functions can set the isModified flag.
24076 : // set_isModified(true);
24077 :
24078 0 : return p_extraIncludeDirectorySpecifierAfterList;
24079 : }
24080 :
24081 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24082 :
24083 :
24084 : // End of memberFunctionString
24085 : // Start of memberFunctionString
24086 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
24087 :
24088 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
24089 :
24090 : SgIncludeFile*
24091 356 : SgSourceFile::get_associated_include_file () const
24092 : {
24093 356 : ROSE_ASSERT (this != NULL);
24094 :
24095 : #if 0
24096 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24097 : // used to trigger marking transformations for the token-based unparsing.
24098 : printf ("SgSourceFile::get_associated_include_file = %p = %s \n",this,this->class_name().c_str());
24099 : #endif
24100 :
24101 356 : return p_associated_include_file;
24102 : }
24103 :
24104 : void
24105 11217 : SgSourceFile::set_associated_include_file ( SgIncludeFile* associated_include_file )
24106 : {
24107 11217 : ROSE_ASSERT (this != NULL);
24108 :
24109 : #if 0
24110 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24111 : // used to trigger marking transformations for the token-based unparsing.
24112 : printf ("SgSourceFile::set_associated_include_file = %p = %s \n",this,this->class_name().c_str());
24113 : #endif
24114 :
24115 11217 : set_isModified(true);
24116 :
24117 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
24118 : if (p_associated_include_file != NULL && associated_include_file != NULL && p_associated_include_file != associated_include_file)
24119 : {
24120 : printf ("Warning: associated_include_file = %p overwriting valid pointer p_associated_include_file = %p \n",associated_include_file,p_associated_include_file);
24121 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
24122 : printf ("Error fails assertion (p_associated_include_file != NULL && associated_include_file != NULL && p_associated_include_file != associated_include_file) is false\n");
24123 : ROSE_ASSERT(false);
24124 : #endif
24125 : }
24126 : #endif
24127 11217 : p_associated_include_file = associated_include_file;
24128 11217 : }
24129 :
24130 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24131 :
24132 :
24133 : // End of memberFunctionString
24134 : // Start of memberFunctionString
24135 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
24136 :
24137 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
24138 :
24139 : bool
24140 706 : SgSourceFile::get_processedToIncludeCppDirectivesAndComments () const
24141 : {
24142 706 : ROSE_ASSERT (this != NULL);
24143 :
24144 : #if 0
24145 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24146 : // used to trigger marking transformations for the token-based unparsing.
24147 : printf ("SgSourceFile::get_processedToIncludeCppDirectivesAndComments = %p = %s \n",this,this->class_name().c_str());
24148 : #endif
24149 :
24150 706 : return p_processedToIncludeCppDirectivesAndComments;
24151 : }
24152 :
24153 : void
24154 353 : SgSourceFile::set_processedToIncludeCppDirectivesAndComments ( bool processedToIncludeCppDirectivesAndComments )
24155 : {
24156 353 : ROSE_ASSERT (this != NULL);
24157 :
24158 : #if 0
24159 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24160 : // used to trigger marking transformations for the token-based unparsing.
24161 : printf ("SgSourceFile::set_processedToIncludeCppDirectivesAndComments = %p = %s \n",this,this->class_name().c_str());
24162 : #endif
24163 :
24164 353 : set_isModified(true);
24165 :
24166 353 : p_processedToIncludeCppDirectivesAndComments = processedToIncludeCppDirectivesAndComments;
24167 353 : }
24168 :
24169 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24170 :
24171 :
24172 : // End of memberFunctionString
24173 : // Start of memberFunctionString
24174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
24175 :
24176 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
24177 :
24178 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
24179 : const SgNodePtrList &
24180 0 : SgSourceFile::get_extra_nodes_for_namequal_init () const
24181 : {
24182 0 : assert (this != NULL);
24183 0 : return p_extra_nodes_for_namequal_init;
24184 : }
24185 :
24186 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
24187 : SgNodePtrList &
24188 66 : SgSourceFile::get_extra_nodes_for_namequal_init ()
24189 : {
24190 66 : assert (this != NULL);
24191 :
24192 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
24193 : // As a rule only set_ access functions can set the isModified flag.
24194 : // set_isModified(true);
24195 :
24196 66 : return p_extra_nodes_for_namequal_init;
24197 : }
24198 :
24199 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24200 :
24201 :
24202 : // End of memberFunctionString
24203 : // Start of memberFunctionString
24204 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
24205 :
24206 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
24207 :
24208 : bool
24209 0 : SgSourceFile::get_isDynamicLibrary () const
24210 : {
24211 0 : ROSE_ASSERT (this != NULL);
24212 :
24213 : #if 0
24214 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24215 : // used to trigger marking transformations for the token-based unparsing.
24216 : printf ("SgSourceFile::get_isDynamicLibrary = %p = %s \n",this,this->class_name().c_str());
24217 : #endif
24218 :
24219 0 : return p_isDynamicLibrary;
24220 : }
24221 :
24222 : void
24223 0 : SgSourceFile::set_isDynamicLibrary ( bool isDynamicLibrary )
24224 : {
24225 0 : ROSE_ASSERT (this != NULL);
24226 :
24227 : #if 0
24228 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
24229 : // used to trigger marking transformations for the token-based unparsing.
24230 : printf ("SgSourceFile::set_isDynamicLibrary = %p = %s \n",this,this->class_name().c_str());
24231 : #endif
24232 :
24233 0 : set_isModified(true);
24234 :
24235 0 : p_isDynamicLibrary = isDynamicLibrary;
24236 0 : }
24237 :
24238 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
24239 :
24240 :
24241 : // End of memberFunctionString
24242 : // Start of memberFunctionString
24243 : /* #line 17100 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
24244 :
24245 :
24246 : #if 0
24247 : SgSourceFile::SgSourceFile ()
24248 : {
24249 : // Default constructor
24250 :
24251 : assert (p_root == NULL);
24252 :
24253 : // DQ (9/4/2008): Setup of global scope moved from SgFile to SgSourceFile
24254 : // DQ (8/31/2006): Generate a NULL_FILE (instead of SgFile::SgFile) so that we can
24255 : // enforce that the filename is always an absolute path (starting with "/").
24256 : // Sg_File_Info* globalScopeFileInfo = new Sg_File_Info("SgGlobal::SgGlobal",0,0);
24257 : Sg_File_Info* globalScopeFileInfo = new Sg_File_Info("",0,0);
24258 : assert (globalScopeFileInfo != NULL);
24259 :
24260 : p_root = new SgGlobal( globalScopeFileInfo );
24261 : assert (p_root != NULL);
24262 :
24263 : // DQ (2/15/2006): Set the parent of the SgGlobal IR node
24264 : p_root->set_parent(this);
24265 :
24266 : // DQ (8/21/2008): Set the end of the global scope (even if it is updated later)
24267 : // mprintf ("In SgFile::initialization(): p_root->get_endOfConstruct() = %p \n",p_root->get_endOfConstruct());
24268 : assert(p_root->get_endOfConstruct() == NULL);
24269 : p_root->set_endOfConstruct(new Sg_File_Info("",0,0));
24270 : assert(p_root->get_endOfConstruct() != NULL);
24271 : }
24272 : #endif
24273 :
24274 : // DQ (1/20/2021): Changed the API to use a pointer to a std::map<SgNode*,TokenStreamSequenceToNodeMapping*> instead of a reference.
24275 : // void SgSourceFile::set_tokenSubsequenceMap(std::map<SgNode*,TokenStreamSequenceToNodeMapping*> & tokenStreamSequenceMap)
24276 : void
24277 0 : SgSourceFile::set_tokenSubsequenceMap(std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* tokenStreamSequenceMap)
24278 : {
24279 : #if 1
24280 : // DQ (1/19/2021): This is a newer version of this function that only inserts the input map into
24281 : // a map container that is using the SgSourceFile instead of the file_id as a key (to the map).
24282 :
24283 0 : if (Rose::tokenSubsequenceMapOfMapsBySourceFile.find(this) == Rose::tokenSubsequenceMapOfMapsBySourceFile.end())
24284 : {
24285 : #if 0
24286 : printf ("Adding a new object to the Rose::tokenSubsequenceMapOfMapsBySourceFile: (before) size = %zu \n",Rose::tokenSubsequenceMapOfMapsBySourceFile.size());
24287 : printf (" --- associated source file = %p \n",this);
24288 : printf (" --- associated filename = %s \n",this->getFileName().c_str());
24289 : printf (" --- associated global scope = %p \n",this->get_globalScope());
24290 : #endif
24291 0 : Rose::tokenSubsequenceMapOfMapsBySourceFile.insert(std::pair<SgSourceFile*,std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* >(this,tokenStreamSequenceMap));
24292 : #if 0
24293 : printf ("DONE: Adding a new object to the Rose::tokenSubsequenceMapOfMapsBySourceFile: (before) size = %zu \n",Rose::tokenSubsequenceMapOfMapsBySourceFile.size());
24294 : #endif
24295 : }
24296 : else
24297 : {
24298 0 : printf ("Error: entry for SgSourceFile = %p is already present in Rose::tokenSubsequenceMapOfMapsBySourceFile \n",this);
24299 0 : ROSE_ASSERT(false);
24300 : }
24301 : #else
24302 : // DQ (1/19/2021): OLDER CODE
24303 :
24304 : // DQ (10/28/2013): Not sure I want this to be copy by value, but OK for now.
24305 : // We could later make this a map of maps using the SgSourceFile IR node as the key (or the Sg_File_Info fileId value (which is tied to the filename)).
24306 :
24307 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24308 : // multiple files (or header files in addition to the source file).
24309 : // Rose::tokenSubsequenceMap = tokenStreamSequenceMap;
24310 :
24311 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*> & tokenMap = this->get_tokenSubsequenceMap();
24312 :
24313 : #if 1
24314 : // DQ (1/11/2021): Added support for debugging.
24315 : printf ("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n");
24316 : printf ("In SgSourceFile::set_tokenSubsequenceMap(): (before): tokenMap.size() = %zu \n",tokenMap.size());
24317 : printf (" --- SgSourceFile: filename = %s \n",this->getFileName().c_str());
24318 : printf ("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n");
24319 : #endif
24320 :
24321 : #if 1
24322 : // DQ (1/12/2021): I think this function is never called (which might be an issue).
24323 : printf ("Exiting as a test! \n");
24324 : ROSE_ASSERT(false);
24325 : #endif
24326 :
24327 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*>::iterator i = tokenStreamSequenceMap.begin();
24328 : while (i != tokenStreamSequenceMap.end())
24329 : {
24330 : ROSE_ASSERT(i->first != NULL);
24331 : ROSE_ASSERT(i->second != NULL);
24332 :
24333 : #if 1
24334 : // DQ (6/3/2019): Testing (unparse headers active, but token-based unparsing inactive) with an alternative implementation.
24335 :
24336 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24337 : if (tokenMap.find(i->first) != tokenMap.end())
24338 : {
24339 : #if 1
24340 : // DQ (1/11/2021): Added support for debugging.
24341 : printf ("In SgSourceFile::set_tokenSubsequenceMap(): This is a redundant entry in the tokenMap (not inserted) \n");
24342 : #endif
24343 : // DQ (6/3/2019): comment this out, but don't include this map.
24344 : // ROSE_ASSERT(false);
24345 : }
24346 : else
24347 : {
24348 : tokenMap.insert(*i);
24349 : }
24350 : #else
24351 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24352 : if (tokenMap.find(i->first) != tokenMap.end())
24353 : {
24354 : mprintf ("This is a redundant entry in the tokenMap \n");
24355 : ROSE_ASSERT(false);
24356 : }
24357 :
24358 : tokenMap.insert(*i);
24359 : #endif
24360 :
24361 : i++;
24362 : }
24363 :
24364 : #if 1
24365 : printf ("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n");
24366 : printf ("In SgSourceFile::set_tokenSubsequenceMap(): (after): tokenMap.size() = %zu \n",tokenMap.size());
24367 : printf ("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ \n");
24368 : #endif
24369 : #endif
24370 0 : }
24371 :
24372 :
24373 : // DQ (9/26/2018): Added so that we can call the display function for TokenStreamSequenceToNodeMapping (for debugging).
24374 : #include "tokenStreamMapping.h"
24375 :
24376 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*> &
24377 11600 : SgSourceFile::get_tokenSubsequenceMap()
24378 : {
24379 : #if 1
24380 : // DQ (1/23/2021): Newer version, uses the "this" pointer as a key so that multiple SgSourceFile IR nodes
24381 : // can use the same file (reading the same filename).
24382 11600 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* result = NULL;
24383 :
24384 23200 : if (Rose::tokenSubsequenceMapOfMapsBySourceFile.find(this) != Rose::tokenSubsequenceMapOfMapsBySourceFile.end())
24385 : {
24386 : #if 0
24387 : printf ("In SgSourceFile::get_tokenSubsequenceMap(): Accessing and existing std::map<SgNode*,TokenStreamSequenceToNodeMapping*> object from Rose::tokenSubsequenceMapOfMapsBySourceFile: (before) size = %zu \n",
24388 : Rose::tokenSubsequenceMapOfMapsBySourceFile.size());
24389 : #endif
24390 0 : result = Rose::tokenSubsequenceMapOfMapsBySourceFile[this];
24391 : #if 0
24392 : printf ("DONE: Accessing and existing std::map<SgNode*,TokenStreamSequenceToNodeMapping*> object from Rose::tokenSubsequenceMapOfMapsBySourceFile \n");
24393 : #endif
24394 : }
24395 : else
24396 : {
24397 : #if 0
24398 : printf ("In SgSourceFile::get_tokenSubsequenceMap(): NOTE: SgSourceFile = %p not found in Rose::tokenSubsequenceMapOfMapsBySourceFile (might be because it is not saved in the AST write) \n",this);
24399 : #endif
24400 : // DQ (2/19/2021): Disable this as an error since the AST read (after the AST write) will not have this data structure.
24401 : // We are not trying to currently support the token-based unparsing after an AST write and AST read.
24402 : // DQ (1/30/2021): Added an assertion.
24403 : // ROSE_ASSERT(false);
24404 : }
24405 :
24406 11600 : return *result;
24407 :
24408 : #else
24409 : // DQ (1/23/2021): Older version.
24410 : // DQ (10/28/2013): Not sure I want this to be copy by value, but OK for now.
24411 :
24412 : #error "DEAD CODE!"
24413 :
24414 : #if 1
24415 : printf ("$$$$$$$$$$$$$$$$$$$$ In SgSourceFile::get_tokenSubsequenceMap() $$$$$$$$$$$$$$$$$$$$$$ \n");
24416 : #endif
24417 :
24418 : // DQ (9/27/2018): To support multiple files with the token based unparsing, we need to have one map per file
24419 : // (to simplify the debugging if not fix a current bug in the use of the token based unparsing across multiple
24420 : // files, as is being tested with the header file unparsing).
24421 : // return Rose::tokenSubsequenceMap;
24422 :
24423 : ROSE_ASSERT(this != NULL);
24424 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
24425 :
24426 : // DQ (1/11/2021): This is using the file_id instead of the filename, as a result it should be unique, I think.
24427 : // So this is a better solution than using the filename, since the filename is not unique when a file is read
24428 : // twice as in when buildSourceFile is called to build another copy fo the file which is edited (transformed)
24429 : // to become a dynamic library (as in the codeSegregation tool).
24430 : int index = this->get_startOfConstruct()->get_file_id();
24431 :
24432 : #if 1
24433 : printf ("In SgSourceFile::get_tokenSubsequenceMap(): index = %d filename = %s \n",index,this->getFileName().c_str());
24434 : // mprintf ("In SgSourceFile::get_tokenSubsequenceMap(): index = %d \n",index);
24435 : printf ("In SgSourceFile::get_tokenSubsequenceMap(): Rose::tokenSubsequenceMapOfMaps.size() = %zu \n",Rose::tokenSubsequenceMapOfMaps.size());
24436 : #endif
24437 :
24438 : #error "DEAD CODE!"
24439 :
24440 : if (index < 0)
24441 : {
24442 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
24443 : ROSE_ASSERT(false);
24444 : }
24445 :
24446 : if (Rose::tokenSubsequenceMapOfMaps.find(index) == Rose::tokenSubsequenceMapOfMaps.end())
24447 : {
24448 : #if 1
24449 : printf ("Adding a new std::map<SgNode*,TokenStreamSequenceToNodeMapping*> object to the Rose::tokenSubsequenceMapOfMaps: (before) size = %zu \n",Rose::tokenSubsequenceMapOfMaps.size());
24450 : #endif
24451 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* tokenSubsequenceMap = new std::map<SgNode*,TokenStreamSequenceToNodeMapping*>();
24452 : ROSE_ASSERT(tokenSubsequenceMap != NULL);
24453 :
24454 : Rose::tokenSubsequenceMapOfMaps.insert(std::pair<int,std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* >(index,tokenSubsequenceMap));
24455 : #if 1
24456 : printf ("Adding a new std::map<SgNode*,TokenStreamSequenceToNodeMapping*> object to the Rose::tokenSubsequenceMapOfMaps: (after) size = %zu \n",Rose::tokenSubsequenceMapOfMaps.size());
24457 : #endif
24458 : #if 1
24459 : // DQ (1/13/2021): I think the semantics of this function should be to return a tokenSubsequenceMap only if one already exists.
24460 : // To put make a tokenSubsequenceMap available the set_tokenSubsequenceMap() function must be called first.
24461 : // I think that this clear and simple semantics will make it easier to debug the current issues that are causing specific
24462 : // file_ids to be reused when the second file is build using the buildSourceFile() function.
24463 : printf ("Error: exiting in SgSourceFile::get_tokenSubsequenceMap(): NOT USED (call set_tokenSubsequenceMap() first): index = %d filename = %s \n",index,this->getFileName().c_str());
24464 : ROSE_ASSERT(false);
24465 : #endif
24466 : }
24467 : else
24468 : {
24469 : // DQ (1/11/2021): Debugging case there the token sequence from the second file (with the same name)
24470 : // might not be added to the Rose::tokenSubsequenceMapOfMaps data structure. Added this debugging code.
24471 :
24472 : // DQ (1/12/2021): This can be the case when a file is copied (read a second time uisng the buildSourceFile() function).
24473 : // In this can we need to use a different file_id to insert the token sequence into the Rose::tokenSubsequenceMapOfMaps.
24474 : // But is it reasonable to get entry from the Rose::tokenSubsequenceMapOfMaps if is exists, so this should not be an error.
24475 :
24476 : printf ("Note: In SgSourceFile::get_tokenSubsequenceMap(): ALREADY USED: index = %d filename = %s \n",index,this->getFileName().c_str());
24477 : printf (" --- Rose::tokenSubsequenceMapOfMaps[index = %d]->size() = %zu \n",index,Rose::tokenSubsequenceMapOfMaps[index]->size());
24478 :
24479 : std::map<int,std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* >::iterator i = Rose::tokenSubsequenceMapOfMaps.begin();
24480 : while (i != Rose::tokenSubsequenceMapOfMaps.end())
24481 : {
24482 : printf (" --- i->first = %d \n",i->first);
24483 : printf (" --- i->second (TokenStreamSequenceToNodeMapping*) = %p \n",i->second);
24484 :
24485 : ROSE_ASSERT(i->second != NULL);
24486 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*>::iterator j = i->second->begin();
24487 :
24488 : while (j != i->second->end())
24489 : {
24490 : ROSE_ASSERT(j->first != NULL);
24491 : ROSE_ASSERT(j->second != NULL);
24492 :
24493 : printf (" --- --- j->first = %p = %s \n",j->first,j->first->class_name().c_str());
24494 : printf (" --- --- j->second (TokenStreamSequenceToNodeMapping*) = %p \n",j->second);
24495 : j->second->display("In SgSourceFile::get_tokenSubsequenceMap()");
24496 :
24497 : j++;
24498 : }
24499 :
24500 : i++;
24501 : }
24502 :
24503 : // DQ (1/12/2021): Adding debug information about whast file ids are available.
24504 : Sg_File_Info::display_static_data("In SgSourceFile::get_tokenSubsequenceMap()");
24505 : #if 0
24506 : printf ("Error: exiting in SgSourceFile::get_tokenSubsequenceMap(): ALREADY USED: index = %d filename = %s \n",index,this->getFileName().c_str());
24507 : ROSE_ASSERT(false);
24508 : #endif
24509 : }
24510 :
24511 : #error "DEAD CODE!"
24512 :
24513 : ROSE_ASSERT(Rose::tokenSubsequenceMapOfMaps.find(index) != Rose::tokenSubsequenceMapOfMaps.end());
24514 : ROSE_ASSERT(Rose::tokenSubsequenceMapOfMaps[index] != NULL);
24515 :
24516 : // return *(Rose::tokenSubsequenceMapOfMaps[index]);
24517 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*>* result = Rose::tokenSubsequenceMapOfMaps[index];
24518 : ROSE_ASSERT(result != NULL);
24519 :
24520 : #if 0
24521 : // DQ (10/4/2018): Run a test each time this map is accessed: Output the tokenStreamSequenceMap:
24522 : #if 1
24523 : printf ("In SgSourceFile::get_tokenSubsequenceMap(): Output TokenStreamSequenceToNodeMapping \n");
24524 : #endif
24525 :
24526 : std::map<SgNode*,TokenStreamSequenceToNodeMapping*>::iterator k = result->begin();
24527 : while (k != result->end())
24528 : {
24529 : #if 1
24530 : printf ("k->first = %p = %s: \n",k->first,k->first->class_name().c_str());
24531 : #endif
24532 : // DQ (9/28/2018): Adding assertion.
24533 : ROSE_ASSERT(k->second->node != NULL);
24534 : #if 1
24535 : k->second->display("token sequence");
24536 : #endif
24537 : k++;
24538 : }
24539 : #endif
24540 :
24541 : #error "DEAD CODE!"
24542 :
24543 : return *result;
24544 : #endif
24545 : }
24546 :
24547 :
24548 : // void SgSourceFile::set_token_unparse_frontier(std::vector<FrontierNode*> & tokenStreamSequenceMap)
24549 : void
24550 0 : SgSourceFile::set_token_unparse_frontier(std::map<SgStatement*,FrontierNode*> & tokenStreamSequenceMap)
24551 : {
24552 : // DQ (10/28/2013): Not sure I want this to be copy by value, but OK for now.
24553 : // We could later make this a map of maps using the SgSourceFile IR node as the key (or the Sg_File_Info fileId value (which is tied to the filename)).
24554 :
24555 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24556 : // multiple files (or header files in addition to the source file).
24557 : // Rose::frontierNodes = tokenStreamSequenceMap;
24558 :
24559 0 : std::map<SgStatement*,FrontierNode*> & frontierMap = this->get_token_unparse_frontier();
24560 :
24561 : #if 0
24562 : mprintf ("In SgSourceFile::set_token_unparse_frontier(): (before): frontierMap.size() = %zu \n",frontierMap.size());
24563 : #endif
24564 :
24565 0 : std::map<SgStatement*,FrontierNode*>::iterator i = tokenStreamSequenceMap.begin();
24566 0 : while (i != tokenStreamSequenceMap.end())
24567 : {
24568 0 : ROSE_ASSERT(i->first != NULL);
24569 0 : ROSE_ASSERT(i->second != NULL);
24570 :
24571 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24572 0 : if (frontierMap.find(i->first) != frontierMap.end())
24573 : {
24574 0 : mprintf ("SgSourceFile::set_token_unparse_frontier(): This is a redundant entry in the Map \n");
24575 0 : ROSE_ASSERT(false);
24576 : }
24577 :
24578 0 : frontierMap.insert(*i);
24579 :
24580 0 : i++;
24581 : }
24582 :
24583 : #if 0
24584 : mprintf ("In SgSourceFile::set_token_unparse_frontier(): (after): frontierMap.size() = %zu \n",frontierMap.size());
24585 : #endif
24586 0 : }
24587 :
24588 : // std::vector<FrontierNode*> & SgSourceFile::get_token_unparse_frontier()
24589 : std::map<SgStatement*,FrontierNode*> &
24590 0 : SgSourceFile::get_token_unparse_frontier()
24591 : {
24592 : // DQ (10/28/2013): Not sure I want this to be copy by value, but OK for now.
24593 :
24594 : // DQ (9/28/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24595 : // multiple files (or header files in addition to the source file).
24596 : // return Rose::frontierNodes;
24597 :
24598 0 : ROSE_ASSERT(this != NULL);
24599 0 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
24600 :
24601 0 : int index = this->get_startOfConstruct()->get_file_id();
24602 :
24603 : #if 0
24604 : mprintf ("In SgSourceFile::get_token_unparse_frontier(): index = %d filename = %s \n",index,this->getFileName().c_str());
24605 : mprintf ("In SgSourceFile::get_token_unparse_frontier(): Rose::frontierNodesMapOfMaps.size() = %zu \n",Rose::frontierNodesMapOfMaps.size());
24606 : #endif
24607 :
24608 0 : if (index < 0)
24609 : {
24610 0 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
24611 0 : ROSE_ASSERT(false);
24612 : }
24613 :
24614 0 : if (Rose::frontierNodesMapOfMaps.find(index) == Rose::frontierNodesMapOfMaps.end())
24615 : {
24616 : #if 0
24617 : mprintf ("Adding a new std::map<SgStatement*,FrontierNode*> object to the Rose::frontierNodesMapOfMaps: (before) size = %zu \n",Rose::frontierNodesMapOfMaps.size());
24618 : #endif
24619 0 : std::map<SgStatement*,FrontierNode*>* frontierNodesMap = new std::map<SgStatement*,FrontierNode*>();
24620 0 : ROSE_ASSERT(frontierNodesMap != NULL);
24621 :
24622 0 : Rose::frontierNodesMapOfMaps.insert(std::pair<int,std::map<SgStatement*,FrontierNode*>* >(index,frontierNodesMap));
24623 : #if 0
24624 : mprintf ("Adding a new std::map<SgStatement*,FrontierNode*> object to the Rose::frontierNodesMapOfMaps: (after) size = %zu \n",Rose::frontierNodesMapOfMaps.size());
24625 : #endif
24626 : }
24627 :
24628 0 : ROSE_ASSERT(Rose::frontierNodesMapOfMaps.find(index) != Rose::frontierNodesMapOfMaps.end());
24629 0 : ROSE_ASSERT(Rose::frontierNodesMapOfMaps[index] != NULL);
24630 :
24631 0 : std::map<SgStatement*,FrontierNode*>* result = Rose::frontierNodesMapOfMaps[index];
24632 0 : ROSE_ASSERT(result != NULL);
24633 :
24634 0 : return *result;
24635 : }
24636 :
24637 :
24638 :
24639 :
24640 :
24641 :
24642 :
24643 :
24644 :
24645 :
24646 :
24647 :
24648 :
24649 :
24650 :
24651 :
24652 :
24653 :
24654 : void
24655 0 : SgSourceFile::set_token_unparse_frontier_adjacency(std::map<SgNode*,PreviousAndNextNodeData*> & tokenStreamSequenceMap)
24656 : {
24657 : // DQ (10/28/2013): Not sure I want this to be copy by value, but OK for now.
24658 : // We could later make this a map of maps using the SgSourceFile IR node as the key (or the Sg_File_Info fileId value (which is tied to the filename)).
24659 :
24660 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24661 : // multiple files (or header files in addition to the source file).
24662 : // Rose::previousAndNextNodeMap = tokenStreamSequenceMap;
24663 :
24664 0 : std::map<SgNode*,PreviousAndNextNodeData*> & frontierMap = this->get_token_unparse_frontier_adjacency();
24665 :
24666 : #if 0
24667 : mprintf ("In SgSourceFile::set_token_unparse_frontier_adjacency(): (before): frontierMap.size() = %zu \n",frontierMap.size());
24668 : #endif
24669 :
24670 0 : std::map<SgNode*,PreviousAndNextNodeData*>::iterator i = tokenStreamSequenceMap.begin();
24671 0 : while (i != tokenStreamSequenceMap.end())
24672 : {
24673 0 : ROSE_ASSERT(i->first != NULL);
24674 0 : ROSE_ASSERT(i->second != NULL);
24675 :
24676 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24677 0 : if (frontierMap.find(i->first) != frontierMap.end())
24678 : {
24679 0 : mprintf ("SgSourceFile::set_token_unparse_frontier_adjacency(): This is a redundant entry in the Map \n");
24680 0 : ROSE_ASSERT(false);
24681 : }
24682 :
24683 0 : frontierMap.insert(*i);
24684 :
24685 0 : i++;
24686 : }
24687 :
24688 : #if 0
24689 : mprintf ("In SgSourceFile::set_token_unparse_frontier_adjacency(): (after): frontierMap.size() = %zu \n",frontierMap.size());
24690 : #endif
24691 0 : }
24692 :
24693 : std::map<SgNode*,PreviousAndNextNodeData*> &
24694 0 : SgSourceFile::get_token_unparse_frontier_adjacency()
24695 : {
24696 : // DQ (10/28/2013): Not sure I want this to be copy by value, but OK for now.
24697 : // return Rose::previousAndNextNodeMap;
24698 :
24699 0 : ROSE_ASSERT(this != NULL);
24700 0 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
24701 :
24702 0 : int index = this->get_startOfConstruct()->get_file_id();
24703 :
24704 : #if 0
24705 : mprintf ("In SgSourceFile::get_token_unparse_frontier_adjacency(): index = %d filename = %s \n",index,this->getFileName().c_str());
24706 : #endif
24707 :
24708 0 : if (index < 0)
24709 : {
24710 0 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
24711 0 : ROSE_ASSERT(false);
24712 : }
24713 :
24714 0 : if (Rose::previousAndNextNodeMapOfMaps.find(index) == Rose::previousAndNextNodeMapOfMaps.end())
24715 : {
24716 : #if 0
24717 : mprintf ("Adding a new std::map<SgNode*,PreviousAndNextNodeData*> object to the Rose::previousAndNextNodeMapOfMaps: (before) size = %zu \n",Rose::previousAndNextNodeMapOfMaps.size());
24718 : #endif
24719 0 : std::map<SgNode*,PreviousAndNextNodeData*>* frontierNodesMap = new std::map<SgNode*,PreviousAndNextNodeData*>();
24720 0 : ROSE_ASSERT(frontierNodesMap != NULL);
24721 :
24722 0 : Rose::previousAndNextNodeMapOfMaps.insert(std::pair<int,std::map<SgNode*,PreviousAndNextNodeData*>* >(index,frontierNodesMap));
24723 : #if 0
24724 : mprintf ("Adding a new std::map<SgNode*,PreviousAndNextNodeData*> object to the Rose::previousAndNextNodeMapOfMaps: (after) size = %zu \n",Rose::previousAndNextNodeMapOfMaps.size());
24725 : #endif
24726 : }
24727 :
24728 0 : ROSE_ASSERT(Rose::previousAndNextNodeMapOfMaps.find(index) != Rose::previousAndNextNodeMapOfMaps.end());
24729 0 : ROSE_ASSERT(Rose::previousAndNextNodeMapOfMaps[index] != NULL);
24730 :
24731 0 : std::map<SgNode*,PreviousAndNextNodeData*>* result = Rose::previousAndNextNodeMapOfMaps[index];
24732 0 : ROSE_ASSERT(result != NULL);
24733 :
24734 0 : return *result;
24735 : }
24736 :
24737 :
24738 :
24739 :
24740 :
24741 :
24742 :
24743 :
24744 :
24745 :
24746 :
24747 :
24748 :
24749 :
24750 :
24751 :
24752 :
24753 : // DQ (11/29/2013): Added to support access to multi-map of redundant mapping of frontier IR nodes to token subsequences.
24754 : void
24755 0 : SgSourceFile::set_redundantlyMappedTokensToStatementMultimap(std::multimap<int,SgStatement*> & X)
24756 : {
24757 : // Rose::redundantlyMappedTokensToStatementMultimap = X;
24758 :
24759 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24760 : // multiple files (or header files in addition to the source file).
24761 : // Rose::frontierNodes = tokenStreamSequenceMap;
24762 :
24763 0 : std::multimap<int,SgStatement*> & frontierMap = this->get_redundantlyMappedTokensToStatementMultimap();
24764 :
24765 : #if 0
24766 : mprintf ("In SgSourceFile::set_redundantlyMappedTokensToStatementMultimap(): (before): frontierMap.size() = %zu \n",frontierMap.size());
24767 : #endif
24768 :
24769 0 : std::multimap<int,SgStatement*>::iterator i = X.begin();
24770 0 : while (i != X.end())
24771 : {
24772 : // ROSE_ASSERT(i->first != NULL);
24773 0 : ROSE_ASSERT(i->second != NULL);
24774 :
24775 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24776 0 : if (frontierMap.find(i->first) != frontierMap.end())
24777 : {
24778 : ROSE_ASSERT(i->second != NULL);
24779 : #if 0
24780 : mprintf ("SgSourceFile::set_redundantlyMappedTokensToStatementMultimap(): This is a redundant entry in the Map: i->first = %d i->second = %p = %s \n",i->first,i->second,i->second->class_name().c_str());
24781 : #endif
24782 : // DQ (11/1/2018): Since this is a multimap, this might be OK (debugging move tool tests).
24783 : // ROSE_ASSERT(false);
24784 : }
24785 : else
24786 : {
24787 : #if 0
24788 : mprintf ("SgSourceFile::set_redundantlyMappedTokensToStatementMultimap(): new entry in the map: i->first = %d i->second = %p = %s \n",i->first,i->second,i->second->class_name().c_str());
24789 : #endif
24790 : }
24791 :
24792 0 : frontierMap.insert(*i);
24793 :
24794 0 : i++;
24795 : }
24796 :
24797 : #if 0
24798 : mprintf ("In SgSourceFile::set_redundantlyMappedTokensToStatementMultimap(): (after): frontierMap.size() = %zu \n",frontierMap.size());
24799 : #endif
24800 0 : }
24801 :
24802 : // DQ (11/29/2013): Added to support access to multi-map of redundant mapping of frontier IR nodes to token subsequences.
24803 : std::multimap<int,SgStatement*> &
24804 0 : SgSourceFile::get_redundantlyMappedTokensToStatementMultimap()
24805 : {
24806 : // return Rose::redundantlyMappedTokensToStatementMultimap;
24807 :
24808 0 : ROSE_ASSERT(this != NULL);
24809 0 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
24810 :
24811 0 : int index = this->get_startOfConstruct()->get_file_id();
24812 :
24813 : #if 0
24814 : mprintf ("In SgSourceFile::get_redundantlyMappedTokensToStatementMultimap(): index = %d filename = %s \n",index,this->getFileName().c_str());
24815 : #endif
24816 :
24817 0 : if (index < 0)
24818 : {
24819 0 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
24820 0 : ROSE_ASSERT(false);
24821 : }
24822 :
24823 0 : if (Rose::redundantlyMappedTokensToStatementMapOfMultimaps.find(index) == Rose::redundantlyMappedTokensToStatementMapOfMultimaps.end())
24824 : {
24825 : #if 0
24826 : mprintf ("Adding a new std::map<SgStatement*,FrontierNode*> object to the Rose::redundantlyMappedTokensToStatementMapOfMultimaps: (before) size = %zu \n",Rose::redundantlyMappedTokensToStatementMapOfMultimaps.size());
24827 : #endif
24828 0 : std::multimap<int,SgStatement*>* frontierNodesMap = new std::multimap<int,SgStatement*>();
24829 0 : ROSE_ASSERT(frontierNodesMap != NULL);
24830 :
24831 0 : Rose::redundantlyMappedTokensToStatementMapOfMultimaps.insert(std::pair<int,std::multimap<int,SgStatement*>* >(index,frontierNodesMap));
24832 : #if 0
24833 : mprintf ("Adding a new std::map<SgStatement*,FrontierNode*> object to the Rose::redundantlyMappedTokensToStatementMapOfMultimaps: (after) size = %zu \n",Rose::redundantlyMappedTokensToStatementMapOfMultimaps.size());
24834 : #endif
24835 : }
24836 :
24837 0 : ROSE_ASSERT(Rose::redundantlyMappedTokensToStatementMapOfMultimaps.find(index) != Rose::redundantlyMappedTokensToStatementMapOfMultimaps.end());
24838 0 : ROSE_ASSERT(Rose::redundantlyMappedTokensToStatementMapOfMultimaps[index] != NULL);
24839 :
24840 0 : std::multimap<int,SgStatement*>* result = Rose::redundantlyMappedTokensToStatementMapOfMultimaps[index];
24841 0 : ROSE_ASSERT(result != NULL);
24842 :
24843 0 : return *result;
24844 : }
24845 :
24846 :
24847 :
24848 :
24849 :
24850 :
24851 :
24852 :
24853 :
24854 :
24855 :
24856 :
24857 :
24858 :
24859 :
24860 :
24861 : // DQ (11/29/2013): Added to support access to multi-map of redundant mapping of frontier IR nodes to token subsequences.
24862 : void
24863 0 : SgSourceFile::set_redundantTokenEndingsSet(std::set<int> & X)
24864 : {
24865 : // Rose::redundantTokenEndingsSet = X;
24866 :
24867 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24868 : // multiple files (or header files in addition to the source file).
24869 : // Rose::frontierNodes = tokenStreamSequenceMap;
24870 :
24871 0 : std::set<int> & frontierMap = this->get_redundantTokenEndingsSet();
24872 :
24873 : #if 0
24874 : mprintf ("In SgSourceFile::set_redundantTokenEndingsSet(): (before): frontierMap.size() = %zu \n",frontierMap.size());
24875 : #endif
24876 :
24877 0 : std::set<int>::iterator i = X.begin();
24878 0 : while (i != X.end())
24879 : {
24880 : // ROSE_ASSERT(i->first != NULL);
24881 : // ROSE_ASSERT(i->second != NULL);
24882 :
24883 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24884 : // if (frontierMap.find(i->first) != frontierMap.end())
24885 0 : if (frontierMap.find(*i) != frontierMap.end())
24886 : {
24887 0 : mprintf ("SgSourceFile::set_redundantTokenEndingsSet(): This is a redundant entry in the Map \n");
24888 0 : ROSE_ASSERT(false);
24889 : }
24890 :
24891 0 : frontierMap.insert(*i);
24892 :
24893 0 : i++;
24894 : }
24895 :
24896 : #if 0
24897 : mprintf ("In SgSourceFile::set_redundantTokenEndingsSet(): (after): frontierMap.size() = %zu \n",frontierMap.size());
24898 : #endif
24899 0 : }
24900 :
24901 : // DQ (11/29/2013): Added to support access to multi-map of redundant mapping of frontier IR nodes to token subsequences.
24902 : std::set<int> &
24903 0 : SgSourceFile::get_redundantTokenEndingsSet()
24904 : {
24905 : // return Rose::redundantTokenEndingsSet;
24906 :
24907 0 : ROSE_ASSERT(this != NULL);
24908 0 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
24909 :
24910 0 : int index = this->get_startOfConstruct()->get_file_id();
24911 :
24912 : #if 0
24913 : mprintf ("In SgSourceFile::get_token_unparse_frontier(): index = %d filename = %s \n",index,this->getFileName().c_str());
24914 : #endif
24915 :
24916 0 : if (index < 0)
24917 : {
24918 0 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
24919 0 : ROSE_ASSERT(false);
24920 : }
24921 :
24922 0 : if (Rose::redundantTokenEndingsMapOfSets.find(index) == Rose::redundantTokenEndingsMapOfSets.end())
24923 : {
24924 : #if 0
24925 : mprintf ("Adding a new std::set<int> object to the Rose::redundantTokenEndingsMapOfSets: (before) size = %zu \n",Rose::redundantTokenEndingsMapOfSets.size());
24926 : #endif
24927 0 : std::set<int>* frontierNodesMap = new std::set<int>();
24928 0 : ROSE_ASSERT(frontierNodesMap != NULL);
24929 :
24930 0 : Rose::redundantTokenEndingsMapOfSets.insert(std::pair<int,std::set<int>* >(index,frontierNodesMap));
24931 : #if 0
24932 : mprintf ("Adding a new std::set<int> object to the Rose::redundantTokenEndingsMapOfSets: (after) size = %zu \n",Rose::redundantTokenEndingsMapOfSets.size());
24933 : #endif
24934 : }
24935 :
24936 0 : ROSE_ASSERT(Rose::redundantTokenEndingsMapOfSets.find(index) != Rose::redundantTokenEndingsMapOfSets.end());
24937 0 : ROSE_ASSERT(Rose::redundantTokenEndingsMapOfSets[index] != NULL);
24938 :
24939 0 : std::set<int>* result = Rose::redundantTokenEndingsMapOfSets[index];
24940 0 : ROSE_ASSERT(result != NULL);
24941 :
24942 0 : return *result;
24943 : }
24944 :
24945 :
24946 :
24947 :
24948 :
24949 :
24950 :
24951 :
24952 :
24953 :
24954 :
24955 :
24956 :
24957 :
24958 : void
24959 0 : SgSourceFile::set_representativeWhitespaceStatementMap(std::map<SgScopeStatement*,SgStatement*> & representativeWhitespaceStatementMap)
24960 : {
24961 : // DQ (11/20/2015): Provide a statement to use as a key in the token sequence map to get representative whitespace.
24962 : // Rose::representativeWhitespaceStatementMap = representativeWhitespaceStatementMap;
24963 :
24964 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
24965 : // multiple files (or header files in addition to the source file).
24966 : // Rose::frontierNodes = tokenStreamSequenceMap;
24967 :
24968 0 : std::map<SgScopeStatement*,SgStatement*> & frontierMap = this->get_representativeWhitespaceStatementMap();
24969 :
24970 : #if 0
24971 : mprintf ("In SgSourceFile::set_representativeWhitespaceStatementMap(): (before): frontierMap.size() = %zu \n",frontierMap.size());
24972 : #endif
24973 :
24974 0 : std::map<SgScopeStatement*,SgStatement*>::iterator i = representativeWhitespaceStatementMap.begin();
24975 0 : while (i != representativeWhitespaceStatementMap.end())
24976 : {
24977 0 : ROSE_ASSERT(i->first != NULL);
24978 0 : ROSE_ASSERT(i->second != NULL);
24979 :
24980 : #if 1
24981 : // DQ (6/3/2019): Testing (unparse heaaders active, but token-based unparsing inactive) with an alternative implementation.
24982 :
24983 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24984 0 : if (frontierMap.find(i->first) != frontierMap.end())
24985 : {
24986 0 : mprintf ("SgSourceFile::set_representativeWhitespaceStatementMap(): This is a redundant entry in the Map \n");
24987 0 : mprintf (" --- filename = %s \n",getFileName().c_str());
24988 0 : mprintf (" --- i->first = %p = %s \n",i->first,i->first->class_name().c_str());
24989 0 : mprintf (" --- i->second = %p = %s \n",i->second,i->second->class_name().c_str());
24990 : // ROSE_ASSERT(false);
24991 : }
24992 : else
24993 : {
24994 0 : frontierMap.insert(*i);
24995 : }
24996 : #else
24997 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
24998 : if (frontierMap.find(i->first) != frontierMap.end())
24999 : {
25000 : mprintf ("SgSourceFile::set_representativeWhitespaceStatementMap(): This is a redundant entry in the Map \n");
25001 : mprintf (" --- filename = %s \n",getFileName().c_str());
25002 : mprintf (" --- i->first = %p = %s \n",i->first,i->first->class_name().c_str());
25003 : mprintf (" --- i->second = %p = %s \n",i->second,i->second->class_name().c_str());
25004 : ROSE_ASSERT(false);
25005 : }
25006 :
25007 : frontierMap.insert(*i);
25008 : #endif
25009 0 : i++;
25010 : }
25011 :
25012 : #if 0
25013 : mprintf ("In SgSourceFile::set_representativeWhitespaceStatementMap(): (after): frontierMap.size() = %zu \n",frontierMap.size());
25014 : #endif
25015 0 : }
25016 :
25017 : std::map<SgScopeStatement*,SgStatement*> &
25018 2850 : SgSourceFile::get_representativeWhitespaceStatementMap()
25019 : {
25020 : // DQ (11/20/2015): Provide a statement to use as a key in the token sequence map to get representative whitespace.
25021 : // DQ (11/20/2015): Not sure I want this to be copy by value, but OK for now.
25022 : // return Rose::representativeWhitespaceStatementMap;
25023 :
25024 2850 : ROSE_ASSERT(this != NULL);
25025 2850 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
25026 :
25027 2850 : int index = this->get_startOfConstruct()->get_file_id();
25028 :
25029 : #if 0
25030 : mprintf ("In SgSourceFile::get_representativeWhitespaceStatementMap(): index = %d filename = %s \n",index,this->getFileName().c_str());
25031 : #endif
25032 :
25033 2850 : if (index < 0)
25034 : {
25035 0 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
25036 0 : ROSE_ASSERT(false);
25037 : }
25038 :
25039 5700 : if (Rose::representativeWhitespaceStatementMapOfMaps.find(index) == Rose::representativeWhitespaceStatementMapOfMaps.end())
25040 : {
25041 : #if 0
25042 : mprintf ("Adding a new std::map<SgScopeStatement*,SgStatement*> object to the Rose::representativeWhitespaceStatementMapOfMaps: (before) size = %zu \n",Rose::representativeWhitespaceStatementMapOfMaps.size());
25043 : #endif
25044 292 : std::map<SgScopeStatement*,SgStatement*>* frontierNodesMap = new std::map<SgScopeStatement*,SgStatement*>();
25045 292 : ROSE_ASSERT(frontierNodesMap != NULL);
25046 :
25047 292 : Rose::representativeWhitespaceStatementMapOfMaps.insert(std::pair<int,std::map<SgScopeStatement*,SgStatement*>* >(index,frontierNodesMap));
25048 : #if 0
25049 : mprintf ("Adding a new std::map<SgScopeStatement*,SgStatement*> object to the Rose::representativeWhitespaceStatementMapOfMaps: (after) size = %zu \n",Rose::representativeWhitespaceStatementMapOfMaps.size());
25050 : #endif
25051 : }
25052 :
25053 5700 : ROSE_ASSERT(Rose::representativeWhitespaceStatementMapOfMaps.find(index) != Rose::representativeWhitespaceStatementMapOfMaps.end());
25054 2850 : ROSE_ASSERT(Rose::representativeWhitespaceStatementMapOfMaps[index] != NULL);
25055 :
25056 2850 : std::map<SgScopeStatement*,SgStatement*>* result = Rose::representativeWhitespaceStatementMapOfMaps[index];
25057 2850 : ROSE_ASSERT(result != NULL);
25058 :
25059 2850 : return *result;
25060 : }
25061 :
25062 :
25063 :
25064 :
25065 :
25066 :
25067 :
25068 :
25069 :
25070 :
25071 :
25072 :
25073 :
25074 :
25075 :
25076 :
25077 : void
25078 0 : SgSourceFile::set_macroExpansionMap(std::map<SgStatement*,MacroExpansion*> & macroExpansionMap)
25079 : {
25080 : // DQ (11/30/2015): Provide a statement to use as a key in the macro expansion map to get info about macro expansions.
25081 : // Rose::macroExpansionMap = macroExpansionMap;
25082 :
25083 : // DQ (9/26/2018): We need to merge these results not overright the initial results. This is essential when we are supporting
25084 : // multiple files (or header files in addition to the source file).
25085 : // Rose::frontierNodes = tokenStreamSequenceMap;
25086 :
25087 0 : std::map<SgStatement*,MacroExpansion*> & frontierMap = this->get_macroExpansionMap();
25088 :
25089 : #if 0
25090 : mprintf ("In SgSourceFile::set_macroExpansionMap(): (before): frontierMap.size() = %zu \n",frontierMap.size());
25091 : #endif
25092 :
25093 0 : std::map<SgStatement*,MacroExpansion*>::iterator i = macroExpansionMap.begin();
25094 0 : while (i != macroExpansionMap.end())
25095 : {
25096 0 : ROSE_ASSERT(i->first != NULL);
25097 0 : ROSE_ASSERT(i->second != NULL);
25098 :
25099 : // DQ (9/26/2018): Make sure this is not an entry that already exists in the map.
25100 0 : if (frontierMap.find(i->first) != frontierMap.end())
25101 : {
25102 0 : mprintf ("SgSourceFile::set_macroExpansionMap(): This is a redundant entry in the Map \n");
25103 0 : ROSE_ASSERT(false);
25104 : }
25105 :
25106 0 : frontierMap.insert(*i);
25107 :
25108 0 : i++;
25109 : }
25110 :
25111 : #if 0
25112 : mprintf ("In SgSourceFile::set_macroExpansionMap(): (after): frontierMap.size() = %zu \n",frontierMap.size());
25113 : #endif
25114 0 : }
25115 :
25116 : std::map<SgStatement*,MacroExpansion*> &
25117 1066 : SgSourceFile::get_macroExpansionMap()
25118 : {
25119 : // DQ (11/30/2015): Provide a statement to use as a key in the macro expansion map to get info about macro expansions.
25120 : // DQ (11/30/2015): Not sure I want this to be copy by value, but OK for now.
25121 : // return Rose::macroExpansionMap;
25122 :
25123 1066 : ROSE_ASSERT(this != NULL);
25124 1066 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
25125 :
25126 1066 : int index = this->get_startOfConstruct()->get_file_id();
25127 :
25128 : #if 0
25129 : mprintf ("In SgSourceFile::get_macroExpansionMapOfMaps(): index = %d filename = %s \n",index,this->getFileName().c_str());
25130 : #endif
25131 :
25132 1066 : if (index < 0)
25133 : {
25134 0 : mprintf ("ERROR: we only have token stream subsequences for valid files: fileid < 0: index = %d \n",index);
25135 0 : ROSE_ASSERT(false);
25136 : }
25137 :
25138 2132 : if (Rose::macroExpansionMapOfMaps.find(index) == Rose::macroExpansionMapOfMaps.end())
25139 : {
25140 : #if 0
25141 : mprintf ("Adding a new std::map<SgStatement*,MacroExpansion*> object to the Rose::macroExpansionMapOfMaps: (before) size = %zu \n",Rose::macroExpansionMapOfMaps.size());
25142 : #endif
25143 279 : std::map<SgStatement*,MacroExpansion*>* frontierNodesMap = new std::map<SgStatement*,MacroExpansion*>();
25144 279 : ROSE_ASSERT(frontierNodesMap != NULL);
25145 :
25146 279 : Rose::macroExpansionMapOfMaps.insert(std::pair<int,std::map<SgStatement*,MacroExpansion*>* >(index,frontierNodesMap));
25147 : #if 0
25148 : mprintf ("Adding a new std::map<SgStatement*,MacroExpansion*> object to the Rose::macroExpansionMapOfMaps: (after) size = %zu \n",Rose::macroExpansionMapOfMaps.size());
25149 : #endif
25150 : }
25151 :
25152 2132 : ROSE_ASSERT(Rose::macroExpansionMapOfMaps.find(index) != Rose::macroExpansionMapOfMaps.end());
25153 1066 : ROSE_ASSERT(Rose::macroExpansionMapOfMaps[index] != NULL);
25154 :
25155 1066 : std::map<SgStatement*,MacroExpansion*>* result = Rose::macroExpansionMapOfMaps[index];
25156 1066 : ROSE_ASSERT(result != NULL);
25157 :
25158 1066 : return *result;
25159 : }
25160 :
25161 :
25162 :
25163 :
25164 :
25165 :
25166 :
25167 :
25168 :
25169 :
25170 :
25171 :
25172 :
25173 :
25174 :
25175 :
25176 :
25177 :
25178 :
25179 :
25180 :
25181 :
25182 :
25183 :
25184 :
25185 :
25186 :
25187 : // End of memberFunctionString
25188 : // Start of memberFunctionString
25189 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
25190 :
25191 : // *** COMMON CODE SECTION BEGINS HERE ***
25192 :
25193 : #if 0
25194 : int
25195 : SgSourceFile::getVariant() const
25196 : {
25197 : // This function is used in ROSE while "variant()" is used in SAGE
25198 : assert(this != NULL);
25199 : return variant();
25200 : }
25201 : #endif
25202 :
25203 : // This function is used in ROSE in treeTraversal code
25204 : // eventually replaces getVariant() and variant()
25205 : // though after variant() has been removed for a while we will
25206 : // want to change the name of variantT() back to variant()
25207 : // (since the "T" was ment to stand for temporary).
25208 : // When this happens the variantT() will be depricated.
25209 : VariantT
25210 16487000 : SgSourceFile::variantT() const
25211 : {
25212 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
25213 16487000 : ROSE_ASSERT(this != NULL);
25214 16487000 : return V_SgSourceFile;
25215 : }
25216 :
25217 : #if 0
25218 : int
25219 : SgSourceFile::variant() const
25220 : {
25221 : // This function is used in SAGE
25222 : ROSE_ASSERT(this != NULL);
25223 : return SourceFileTag;
25224 : }
25225 : #endif
25226 :
25227 : ROSE_DLL_API const char*
25228 3228 : SgSourceFile::sage_class_name() const
25229 : {
25230 3228 : ROSE_ASSERT(this != NULL);
25231 3228 : return "SgSourceFile";
25232 : }
25233 :
25234 : std::string
25235 10746 : SgSourceFile::class_name() const
25236 : {
25237 10746 : ROSE_ASSERT(this != NULL);
25238 10746 : return "SgSourceFile";
25239 : }
25240 :
25241 : // DQ (11/26/2005): Support for visitor pattern mechanims
25242 : // (inferior to ROSE traversal mechanism, experimental).
25243 : void
25244 23799 : SgSourceFile::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
25245 : {
25246 23799 : ROSE_ASSERT(this != NULL);
25247 23799 : visitor.visit(this);
25248 23799 : }
25249 :
25250 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
25251 0 : void SgSourceFile::accept (ROSE_VisitorPattern & visitor) {
25252 0 : ROSE_ASSERT(this != NULL);
25253 0 : visitor.visit(this);
25254 0 : }
25255 :
25256 : SgSourceFile*
25257 0 : SgSourceFile::addRegExpAttribute(std::string s, AstRegExAttribute* a)
25258 : {
25259 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
25260 : // This function is currently only supported for the AST used the represent Binary executables.
25261 : if (0 /* isSgAsmNode(this) != NULL */)
25262 : {
25263 : // Support for regex specification.
25264 : std::string prefixCode = "REGEX:";
25265 : addNewAttribute(prefixCode + s,a);
25266 : }
25267 : #endif
25268 :
25269 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
25270 0 : return this;
25271 : }
25272 :
25273 : // *** COMMON CODE SECTION ENDS HERE ***
25274 :
25275 :
25276 : // End of memberFunctionString
25277 : // Start of memberFunctionString
25278 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
25279 :
25280 :
25281 : #if 0
25282 : //! Error checking support
25283 : /*! Verifies the following:
25284 : - working getVariant() member function
25285 : - calls base class's error() member function
25286 : Every class has one of these functions.
25287 : */
25288 : bool
25289 : SgSourceFile::error()
25290 : {
25291 : // Put error checking here
25292 :
25293 : ROSE_ASSERT (this != NULL);
25294 : if (getVariant() != SourceFileTag)
25295 : {
25296 : printf ("Error in SgSourceFile::error(): SgSourceFile object has a %s variant \n",
25297 : Cxx_GrammarTerminalNames[getVariant()].name);
25298 : // printf ("Error in SgSourceFile::error() \n");
25299 : ROSE_ABORT();
25300 : }
25301 :
25302 : ROSE_ASSERT (getVariant() == SourceFileTag);
25303 : return SgFile::error();
25304 : }
25305 : #endif
25306 :
25307 :
25308 :
25309 : // End of memberFunctionString
25310 :
25311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
25312 :
25313 17316400 : SgSourceFile* isSgSourceFile ( SgNode* inputDerivedClassPointer )
25314 : {
25315 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
25316 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
25317 : // So to fix this we return NULL directly when the input is NULL and avoid the
25318 : // dynamic_cast in this case. This is likely a performance improvement as well.
25319 : // return dynamic_cast<SgSourceFile*>(inputDerivedClassPointer);
25320 : // Milind Chabbi (8/28/2013): isSgSourceFile uses table-driven castability instead of c++ default dynamic_cast
25321 : // this improves the running time performance by 10-20%.
25322 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSourceFile*>(inputDerivedClassPointer);
25323 17316400 : return IS_SgSourceFile_FAST_MACRO(inputDerivedClassPointer);
25324 : }
25325 :
25326 : // DQ (11/8/2003): Added version of functions taking const pointer
25327 1914680 : const SgSourceFile* isSgSourceFile ( const SgNode* inputDerivedClassPointer )
25328 : {
25329 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
25330 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
25331 : // So to fix this we return NULL directly when the input is NULL and avoid the
25332 : // dynamic_cast in this case. This is likely a performance improvement as well.
25333 : // return dynamic_cast<const SgSourceFile*>(inputDerivedClassPointer);
25334 : // Milind Chabbi (8/28/2013): isSgSourceFile uses table-driven castability instead of c++ default dynamic_cast
25335 : // this improves the running time performance by 10-20%.
25336 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSourceFile*>(inputDerivedClassPointer);
25337 1914680 : return IS_SgSourceFile_FAST_MACRO(inputDerivedClassPointer);
25338 : }
25339 :
25340 :
25341 :
25342 : /* #line 25343 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25343 :
25344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
25345 :
25346 : /**
25347 : \brief Generated destructor
25348 :
25349 : This destructor is automatically generated (by ROSETTA). This destructor
25350 : only frees memory of data members associated with the parts of the current IR node which
25351 : are NOT traversed. Those data members that are part of a traversal can be freed using
25352 : a traversal (calling this destructor on all children in a post-order traversal). Such
25353 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
25354 :
25355 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
25356 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
25357 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
25358 :
25359 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
25360 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
25361 : pointers are not yet implemented to call delete on eash pointer in the container.
25362 : (This could be done by derivation from the STL containers to define containers that
25363 : automatically deleted their members.)
25364 :
25365 : */
25366 790 : SgSourceFile::~SgSourceFile () {
25367 395 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
25368 :
25369 395 : if (p_headerFileReport && p_headerFileReport->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_headerFileReport; }
25370 395 : if (p_associated_include_file && p_associated_include_file->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_associated_include_file; }
25371 :
25372 : // case: not a listType for globalScope
25373 395 : p_globalScope = NULL; // non list case
25374 : // case: not a listType for temp_holding_scope
25375 395 : p_temp_holding_scope = NULL; // non list case
25376 : // case: not a listType for isHeaderFile
25377 395 : p_isHeaderFile = false; // non list case
25378 : // case: not a listType for isHeaderFileIncludedMoreThanOnce
25379 395 : p_isHeaderFileIncludedMoreThanOnce = false; // non list case
25380 : // case: not a listType for headerFileReport
25381 395 : p_headerFileReport = NULL; // non list case
25382 : // case: not a listType for associated_include_file
25383 395 : p_associated_include_file = NULL; // non list case
25384 : // case: not a listType for processedToIncludeCppDirectivesAndComments
25385 395 : p_processedToIncludeCppDirectivesAndComments = false; // non list case
25386 : // case: not a listType for isDynamicLibrary
25387 395 : p_isDynamicLibrary = false; // non list case
25388 :
25389 : }
25390 :
25391 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
25392 790 : }
25393 :
25394 :
25395 : /* #line 25396 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25396 :
25397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
25398 :
25399 : // Generated constructor
25400 10897 : SgSourceFile::SgSourceFile ( )
25401 10897 : : SgFile()
25402 : {
25403 : #ifdef DEBUG
25404 : // printf ("In SgSourceFile::SgSourceFile () sage_class_name() = %s \n",sage_class_name());
25405 : #endif
25406 : #if 0
25407 : // debugging information!
25408 : printf ("In SgSourceFile::SgSourceFile (): this = %p = %s \n",this,this->class_name().c_str());
25409 : #endif
25410 :
25411 10897 : p_globalScope = NULL;
25412 10897 : p_temp_holding_scope = NULL;
25413 10897 : p_isHeaderFile = false;
25414 10897 : p_isHeaderFileIncludedMoreThanOnce = false;
25415 10897 : p_headerFileReport = NULL;
25416 10897 : p_associated_include_file = NULL;
25417 10897 : p_processedToIncludeCppDirectivesAndComments = false;
25418 10897 : p_isDynamicLibrary = false;
25419 :
25420 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
25421 :
25422 : #if 0
25423 : // DQ (7/30/2014): Call a virtual function.
25424 : std::string s = this->class_name();
25425 : #endif
25426 :
25427 : // Test the variant virtual function
25428 : // assert(SourceFileTag == variant());
25429 10897 : assert(SourceFileTag == this->variant());
25430 10897 : ROSE_ASSERT(SourceFileTag == (int)(this->variantT()));
25431 10897 : post_construction_initialization();
25432 :
25433 : // Test the isSgSourceFile() function since it has been problematic
25434 10897 : assert(isSgSourceFile(this) != NULL);
25435 10897 : }
25436 :
25437 : // Generated constructor (all data members)
25438 :
25439 : /* #line 25440 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25440 :
25441 :
25442 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
25443 :
25444 :
25445 : // ********************************************************
25446 : // member functions common across all array grammar objects
25447 : // ********************************************************
25448 :
25449 :
25450 :
25451 : /* #line 25452 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25452 :
25453 :
25454 :
25455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
25456 :
25457 : // ********************************************************
25458 : // member functions specific to each node in the grammar
25459 : // ********************************************************
25460 :
25461 :
25462 : /* #line 25463 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25463 :
25464 : // Start of memberFunctionString
25465 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25466 :
25467 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25468 :
25469 : SgGlobal*
25470 0 : SgUnknownFile::get_globalScope () const
25471 : {
25472 0 : ROSE_ASSERT (this != NULL);
25473 :
25474 : #if 0
25475 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25476 : // used to trigger marking transformations for the token-based unparsing.
25477 : printf ("SgUnknownFile::get_globalScope = %p = %s \n",this,this->class_name().c_str());
25478 : #endif
25479 :
25480 0 : return p_globalScope;
25481 : }
25482 :
25483 : void
25484 0 : SgUnknownFile::set_globalScope ( SgGlobal* globalScope )
25485 : {
25486 0 : ROSE_ASSERT (this != NULL);
25487 :
25488 : #if 0
25489 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25490 : // used to trigger marking transformations for the token-based unparsing.
25491 : printf ("SgUnknownFile::set_globalScope = %p = %s \n",this,this->class_name().c_str());
25492 : #endif
25493 :
25494 0 : set_isModified(true);
25495 :
25496 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
25497 : if (p_globalScope != NULL && globalScope != NULL && p_globalScope != globalScope)
25498 : {
25499 : printf ("Warning: globalScope = %p overwriting valid pointer p_globalScope = %p \n",globalScope,p_globalScope);
25500 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
25501 : printf ("Error fails assertion (p_globalScope != NULL && globalScope != NULL && p_globalScope != globalScope) is false\n");
25502 : ROSE_ASSERT(false);
25503 : #endif
25504 : }
25505 : #endif
25506 0 : p_globalScope = globalScope;
25507 0 : }
25508 :
25509 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
25510 :
25511 :
25512 : // End of memberFunctionString
25513 : // Start of memberFunctionString
25514 : /* #line 18141 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
25515 :
25516 0 : SgUnknownFile::SgUnknownFile ( vector<string> & argv , SgProject* project )
25517 0 : : SgFile(argv, project)
25518 : {
25519 : // set_parent(project);
25520 0 : }
25521 :
25522 :
25523 :
25524 : // End of memberFunctionString
25525 : // Start of memberFunctionString
25526 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
25527 :
25528 : // *** COMMON CODE SECTION BEGINS HERE ***
25529 :
25530 : #if 0
25531 : int
25532 : SgUnknownFile::getVariant() const
25533 : {
25534 : // This function is used in ROSE while "variant()" is used in SAGE
25535 : assert(this != NULL);
25536 : return variant();
25537 : }
25538 : #endif
25539 :
25540 : // This function is used in ROSE in treeTraversal code
25541 : // eventually replaces getVariant() and variant()
25542 : // though after variant() has been removed for a while we will
25543 : // want to change the name of variantT() back to variant()
25544 : // (since the "T" was ment to stand for temporary).
25545 : // When this happens the variantT() will be depricated.
25546 : VariantT
25547 0 : SgUnknownFile::variantT() const
25548 : {
25549 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
25550 0 : ROSE_ASSERT(this != NULL);
25551 0 : return V_SgUnknownFile;
25552 : }
25553 :
25554 : #if 0
25555 : int
25556 : SgUnknownFile::variant() const
25557 : {
25558 : // This function is used in SAGE
25559 : ROSE_ASSERT(this != NULL);
25560 : return UnknownFileTag;
25561 : }
25562 : #endif
25563 :
25564 : ROSE_DLL_API const char*
25565 0 : SgUnknownFile::sage_class_name() const
25566 : {
25567 0 : ROSE_ASSERT(this != NULL);
25568 0 : return "SgUnknownFile";
25569 : }
25570 :
25571 : std::string
25572 0 : SgUnknownFile::class_name() const
25573 : {
25574 0 : ROSE_ASSERT(this != NULL);
25575 0 : return "SgUnknownFile";
25576 : }
25577 :
25578 : // DQ (11/26/2005): Support for visitor pattern mechanims
25579 : // (inferior to ROSE traversal mechanism, experimental).
25580 : void
25581 0 : SgUnknownFile::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
25582 : {
25583 0 : ROSE_ASSERT(this != NULL);
25584 0 : visitor.visit(this);
25585 0 : }
25586 :
25587 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
25588 0 : void SgUnknownFile::accept (ROSE_VisitorPattern & visitor) {
25589 0 : ROSE_ASSERT(this != NULL);
25590 0 : visitor.visit(this);
25591 0 : }
25592 :
25593 : SgUnknownFile*
25594 0 : SgUnknownFile::addRegExpAttribute(std::string s, AstRegExAttribute* a)
25595 : {
25596 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
25597 : // This function is currently only supported for the AST used the represent Binary executables.
25598 : if (0 /* isSgAsmNode(this) != NULL */)
25599 : {
25600 : // Support for regex specification.
25601 : std::string prefixCode = "REGEX:";
25602 : addNewAttribute(prefixCode + s,a);
25603 : }
25604 : #endif
25605 :
25606 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
25607 0 : return this;
25608 : }
25609 :
25610 : // *** COMMON CODE SECTION ENDS HERE ***
25611 :
25612 :
25613 : // End of memberFunctionString
25614 : // Start of memberFunctionString
25615 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
25616 :
25617 :
25618 : #if 0
25619 : //! Error checking support
25620 : /*! Verifies the following:
25621 : - working getVariant() member function
25622 : - calls base class's error() member function
25623 : Every class has one of these functions.
25624 : */
25625 : bool
25626 : SgUnknownFile::error()
25627 : {
25628 : // Put error checking here
25629 :
25630 : ROSE_ASSERT (this != NULL);
25631 : if (getVariant() != UnknownFileTag)
25632 : {
25633 : printf ("Error in SgUnknownFile::error(): SgUnknownFile object has a %s variant \n",
25634 : Cxx_GrammarTerminalNames[getVariant()].name);
25635 : // printf ("Error in SgUnknownFile::error() \n");
25636 : ROSE_ABORT();
25637 : }
25638 :
25639 : ROSE_ASSERT (getVariant() == UnknownFileTag);
25640 : return SgFile::error();
25641 : }
25642 : #endif
25643 :
25644 :
25645 :
25646 : // End of memberFunctionString
25647 :
25648 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
25649 :
25650 357 : SgUnknownFile* isSgUnknownFile ( SgNode* inputDerivedClassPointer )
25651 : {
25652 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
25653 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
25654 : // So to fix this we return NULL directly when the input is NULL and avoid the
25655 : // dynamic_cast in this case. This is likely a performance improvement as well.
25656 : // return dynamic_cast<SgUnknownFile*>(inputDerivedClassPointer);
25657 : // Milind Chabbi (8/28/2013): isSgUnknownFile uses table-driven castability instead of c++ default dynamic_cast
25658 : // this improves the running time performance by 10-20%.
25659 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnknownFile*>(inputDerivedClassPointer);
25660 357 : return IS_SgUnknownFile_FAST_MACRO(inputDerivedClassPointer);
25661 : }
25662 :
25663 : // DQ (11/8/2003): Added version of functions taking const pointer
25664 0 : const SgUnknownFile* isSgUnknownFile ( const SgNode* inputDerivedClassPointer )
25665 : {
25666 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
25667 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
25668 : // So to fix this we return NULL directly when the input is NULL and avoid the
25669 : // dynamic_cast in this case. This is likely a performance improvement as well.
25670 : // return dynamic_cast<const SgUnknownFile*>(inputDerivedClassPointer);
25671 : // Milind Chabbi (8/28/2013): isSgUnknownFile uses table-driven castability instead of c++ default dynamic_cast
25672 : // this improves the running time performance by 10-20%.
25673 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnknownFile*>(inputDerivedClassPointer);
25674 0 : return IS_SgUnknownFile_FAST_MACRO(inputDerivedClassPointer);
25675 : }
25676 :
25677 :
25678 :
25679 : /* #line 25680 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25680 :
25681 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
25682 :
25683 : /**
25684 : \brief Generated destructor
25685 :
25686 : This destructor is automatically generated (by ROSETTA). This destructor
25687 : only frees memory of data members associated with the parts of the current IR node which
25688 : are NOT traversed. Those data members that are part of a traversal can be freed using
25689 : a traversal (calling this destructor on all children in a post-order traversal). Such
25690 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
25691 :
25692 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
25693 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
25694 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
25695 :
25696 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
25697 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
25698 : pointers are not yet implemented to call delete on eash pointer in the container.
25699 : (This could be done by derivation from the STL containers to define containers that
25700 : automatically deleted their members.)
25701 :
25702 : */
25703 0 : SgUnknownFile::~SgUnknownFile () {
25704 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
25705 :
25706 :
25707 : // case: not a listType for globalScope
25708 0 : p_globalScope = NULL; // non list case
25709 :
25710 : }
25711 :
25712 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
25713 0 : }
25714 :
25715 :
25716 : /* #line 25717 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25717 :
25718 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
25719 :
25720 : // Generated constructor
25721 0 : SgUnknownFile::SgUnknownFile ( )
25722 0 : : SgFile()
25723 : {
25724 : #ifdef DEBUG
25725 : // printf ("In SgUnknownFile::SgUnknownFile () sage_class_name() = %s \n",sage_class_name());
25726 : #endif
25727 : #if 0
25728 : // debugging information!
25729 : printf ("In SgUnknownFile::SgUnknownFile (): this = %p = %s \n",this,this->class_name().c_str());
25730 : #endif
25731 :
25732 0 : p_globalScope = NULL;
25733 :
25734 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
25735 :
25736 : #if 0
25737 : // DQ (7/30/2014): Call a virtual function.
25738 : std::string s = this->class_name();
25739 : #endif
25740 :
25741 : // Test the variant virtual function
25742 : // assert(UnknownFileTag == variant());
25743 0 : assert(UnknownFileTag == this->variant());
25744 0 : ROSE_ASSERT(UnknownFileTag == (int)(this->variantT()));
25745 0 : post_construction_initialization();
25746 :
25747 : // Test the isSgUnknownFile() function since it has been problematic
25748 0 : assert(isSgUnknownFile(this) != NULL);
25749 0 : }
25750 :
25751 : // Generated constructor (all data members)
25752 :
25753 : /* #line 25754 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25754 :
25755 :
25756 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
25757 :
25758 :
25759 : // ********************************************************
25760 : // member functions common across all array grammar objects
25761 : // ********************************************************
25762 :
25763 :
25764 :
25765 : /* #line 25766 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25766 :
25767 :
25768 :
25769 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
25770 :
25771 : // ********************************************************
25772 : // member functions specific to each node in the grammar
25773 : // ********************************************************
25774 :
25775 :
25776 : /* #line 25777 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
25777 :
25778 : // Start of memberFunctionString
25779 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25780 :
25781 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25782 :
25783 : SgFileList*
25784 12672 : SgProject::get_fileList_ptr () const
25785 : {
25786 12672 : ROSE_ASSERT (this != NULL);
25787 :
25788 : #if 0
25789 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25790 : // used to trigger marking transformations for the token-based unparsing.
25791 : printf ("SgProject::get_fileList_ptr = %p = %s \n",this,this->class_name().c_str());
25792 : #endif
25793 :
25794 12672 : return p_fileList_ptr;
25795 : }
25796 :
25797 : void
25798 0 : SgProject::set_fileList_ptr ( SgFileList* fileList_ptr )
25799 : {
25800 0 : ROSE_ASSERT (this != NULL);
25801 :
25802 : #if 0
25803 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25804 : // used to trigger marking transformations for the token-based unparsing.
25805 : printf ("SgProject::set_fileList_ptr = %p = %s \n",this,this->class_name().c_str());
25806 : #endif
25807 :
25808 0 : set_isModified(true);
25809 :
25810 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
25811 : if (p_fileList_ptr != NULL && fileList_ptr != NULL && p_fileList_ptr != fileList_ptr)
25812 : {
25813 : printf ("Warning: fileList_ptr = %p overwriting valid pointer p_fileList_ptr = %p \n",fileList_ptr,p_fileList_ptr);
25814 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
25815 : printf ("Error fails assertion (p_fileList_ptr != NULL && fileList_ptr != NULL && p_fileList_ptr != fileList_ptr) is false\n");
25816 : ROSE_ASSERT(false);
25817 : #endif
25818 : }
25819 : #endif
25820 0 : p_fileList_ptr = fileList_ptr;
25821 0 : }
25822 :
25823 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
25824 :
25825 :
25826 : // End of memberFunctionString
25827 : // Start of memberFunctionString
25828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25829 :
25830 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25831 :
25832 : SgStringList
25833 1105 : SgProject::get_originalCommandLineArgumentList () const
25834 : {
25835 1105 : ROSE_ASSERT (this != NULL);
25836 :
25837 : #if 0
25838 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25839 : // used to trigger marking transformations for the token-based unparsing.
25840 : printf ("SgProject::get_originalCommandLineArgumentList = %p = %s \n",this,this->class_name().c_str());
25841 : #endif
25842 :
25843 1105 : return p_originalCommandLineArgumentList;
25844 : }
25845 :
25846 : void
25847 357 : SgProject::set_originalCommandLineArgumentList ( SgStringList originalCommandLineArgumentList )
25848 : {
25849 357 : ROSE_ASSERT (this != NULL);
25850 :
25851 : #if 0
25852 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25853 : // used to trigger marking transformations for the token-based unparsing.
25854 : printf ("SgProject::set_originalCommandLineArgumentList = %p = %s \n",this,this->class_name().c_str());
25855 : #endif
25856 :
25857 357 : set_isModified(true);
25858 :
25859 357 : p_originalCommandLineArgumentList = originalCommandLineArgumentList;
25860 357 : }
25861 :
25862 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
25863 :
25864 :
25865 : // End of memberFunctionString
25866 : // Start of memberFunctionString
25867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25868 :
25869 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25870 :
25871 : int
25872 4 : SgProject::get_frontendErrorCode () const
25873 : {
25874 4 : ROSE_ASSERT (this != NULL);
25875 :
25876 : #if 0
25877 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25878 : // used to trigger marking transformations for the token-based unparsing.
25879 : printf ("SgProject::get_frontendErrorCode = %p = %s \n",this,this->class_name().c_str());
25880 : #endif
25881 :
25882 4 : return p_frontendErrorCode;
25883 : }
25884 :
25885 : void
25886 1414 : SgProject::set_frontendErrorCode ( int frontendErrorCode )
25887 : {
25888 1414 : ROSE_ASSERT (this != NULL);
25889 :
25890 : #if 0
25891 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25892 : // used to trigger marking transformations for the token-based unparsing.
25893 : printf ("SgProject::set_frontendErrorCode = %p = %s \n",this,this->class_name().c_str());
25894 : #endif
25895 :
25896 1414 : set_isModified(true);
25897 :
25898 1414 : p_frontendErrorCode = frontendErrorCode;
25899 1414 : }
25900 :
25901 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
25902 :
25903 :
25904 : // End of memberFunctionString
25905 : // Start of memberFunctionString
25906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25907 :
25908 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25909 :
25910 : int
25911 0 : SgProject::get_javacErrorCode () const
25912 : {
25913 0 : ROSE_ASSERT (this != NULL);
25914 :
25915 : #if 0
25916 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25917 : // used to trigger marking transformations for the token-based unparsing.
25918 : printf ("SgProject::get_javacErrorCode = %p = %s \n",this,this->class_name().c_str());
25919 : #endif
25920 :
25921 0 : return p_javacErrorCode;
25922 : }
25923 :
25924 : void
25925 0 : SgProject::set_javacErrorCode ( int javacErrorCode )
25926 : {
25927 0 : ROSE_ASSERT (this != NULL);
25928 :
25929 : #if 0
25930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25931 : // used to trigger marking transformations for the token-based unparsing.
25932 : printf ("SgProject::set_javacErrorCode = %p = %s \n",this,this->class_name().c_str());
25933 : #endif
25934 :
25935 0 : set_isModified(true);
25936 :
25937 0 : p_javacErrorCode = javacErrorCode;
25938 0 : }
25939 :
25940 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
25941 :
25942 :
25943 : // End of memberFunctionString
25944 : // Start of memberFunctionString
25945 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25946 :
25947 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25948 :
25949 : int
25950 0 : SgProject::get_ecjErrorCode () const
25951 : {
25952 0 : ROSE_ASSERT (this != NULL);
25953 :
25954 : #if 0
25955 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25956 : // used to trigger marking transformations for the token-based unparsing.
25957 : printf ("SgProject::get_ecjErrorCode = %p = %s \n",this,this->class_name().c_str());
25958 : #endif
25959 :
25960 0 : return p_ecjErrorCode;
25961 : }
25962 :
25963 : void
25964 0 : SgProject::set_ecjErrorCode ( int ecjErrorCode )
25965 : {
25966 0 : ROSE_ASSERT (this != NULL);
25967 :
25968 : #if 0
25969 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25970 : // used to trigger marking transformations for the token-based unparsing.
25971 : printf ("SgProject::set_ecjErrorCode = %p = %s \n",this,this->class_name().c_str());
25972 : #endif
25973 :
25974 0 : set_isModified(true);
25975 :
25976 0 : p_ecjErrorCode = ecjErrorCode;
25977 0 : }
25978 :
25979 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
25980 :
25981 :
25982 : // End of memberFunctionString
25983 : // Start of memberFunctionString
25984 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
25985 :
25986 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
25987 :
25988 : int
25989 347 : SgProject::get_midendErrorCode () const
25990 : {
25991 347 : ROSE_ASSERT (this != NULL);
25992 :
25993 : #if 0
25994 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
25995 : // used to trigger marking transformations for the token-based unparsing.
25996 : printf ("SgProject::get_midendErrorCode = %p = %s \n",this,this->class_name().c_str());
25997 : #endif
25998 :
25999 347 : return p_midendErrorCode;
26000 : }
26001 :
26002 : void
26003 0 : SgProject::set_midendErrorCode ( int midendErrorCode )
26004 : {
26005 0 : ROSE_ASSERT (this != NULL);
26006 :
26007 : #if 0
26008 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26009 : // used to trigger marking transformations for the token-based unparsing.
26010 : printf ("SgProject::set_midendErrorCode = %p = %s \n",this,this->class_name().c_str());
26011 : #endif
26012 :
26013 0 : set_isModified(true);
26014 :
26015 0 : p_midendErrorCode = midendErrorCode;
26016 0 : }
26017 :
26018 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26019 :
26020 :
26021 : // End of memberFunctionString
26022 : // Start of memberFunctionString
26023 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
26024 :
26025 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26026 :
26027 : int
26028 346 : SgProject::get_backendErrorCode () const
26029 : {
26030 346 : ROSE_ASSERT (this != NULL);
26031 346 : return p_backendErrorCode;
26032 : }
26033 :
26034 : void
26035 346 : SgProject::set_backendErrorCode ( int backendErrorCode )
26036 : {
26037 346 : ROSE_ASSERT (this != NULL);
26038 :
26039 346 : p_backendErrorCode = backendErrorCode;
26040 346 : }
26041 :
26042 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26043 :
26044 :
26045 : // End of memberFunctionString
26046 : // Start of memberFunctionString
26047 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
26048 :
26049 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26050 :
26051 : bool
26052 0 : SgProject::get_keep_going () const
26053 : {
26054 0 : ROSE_ASSERT (this != NULL);
26055 0 : return p_keep_going;
26056 : }
26057 :
26058 : void
26059 0 : SgProject::set_keep_going ( bool keep_going )
26060 : {
26061 0 : ROSE_ASSERT (this != NULL);
26062 :
26063 0 : p_keep_going = keep_going;
26064 0 : }
26065 :
26066 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26067 :
26068 :
26069 : // End of memberFunctionString
26070 : // Start of memberFunctionString
26071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
26072 :
26073 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26074 :
26075 : bool
26076 350 : SgProject::get_unparser__clobber_input_file () const
26077 : {
26078 350 : ROSE_ASSERT (this != NULL);
26079 350 : return p_unparser__clobber_input_file;
26080 : }
26081 :
26082 : void
26083 354 : SgProject::set_unparser__clobber_input_file ( bool unparser__clobber_input_file )
26084 : {
26085 354 : ROSE_ASSERT (this != NULL);
26086 :
26087 354 : p_unparser__clobber_input_file = unparser__clobber_input_file;
26088 354 : }
26089 :
26090 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26091 :
26092 :
26093 : // End of memberFunctionString
26094 : // Start of memberFunctionString
26095 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26096 :
26097 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26098 :
26099 : std::string
26100 2 : SgProject::get_outputFileName () const
26101 : {
26102 2 : ROSE_ASSERT (this != NULL);
26103 :
26104 : #if 0
26105 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26106 : // used to trigger marking transformations for the token-based unparsing.
26107 : printf ("SgProject::get_outputFileName = %p = %s \n",this,this->class_name().c_str());
26108 : #endif
26109 :
26110 2 : return p_outputFileName;
26111 : }
26112 :
26113 : void
26114 0 : SgProject::set_outputFileName ( std::string outputFileName )
26115 : {
26116 0 : ROSE_ASSERT (this != NULL);
26117 :
26118 : #if 0
26119 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26120 : // used to trigger marking transformations for the token-based unparsing.
26121 : printf ("SgProject::set_outputFileName = %p = %s \n",this,this->class_name().c_str());
26122 : #endif
26123 :
26124 0 : set_isModified(true);
26125 :
26126 0 : p_outputFileName = outputFileName;
26127 0 : }
26128 :
26129 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26130 :
26131 :
26132 : // End of memberFunctionString
26133 : // Start of memberFunctionString
26134 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26135 :
26136 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26137 :
26138 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26139 : const SgStringList &
26140 0 : SgProject::get_sourceFileNameList () const
26141 : {
26142 0 : assert (this != NULL);
26143 0 : return p_sourceFileNameList;
26144 : }
26145 :
26146 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26147 : SgStringList &
26148 712 : SgProject::get_sourceFileNameList ()
26149 : {
26150 712 : assert (this != NULL);
26151 :
26152 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26153 : // As a rule only set_ access functions can set the isModified flag.
26154 : // set_isModified(true);
26155 :
26156 712 : return p_sourceFileNameList;
26157 : }
26158 :
26159 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26160 :
26161 :
26162 : // End of memberFunctionString
26163 : // Start of memberFunctionString
26164 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26165 :
26166 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26167 :
26168 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26169 : const SgStringList &
26170 0 : SgProject::get_objectFileNameList () const
26171 : {
26172 0 : assert (this != NULL);
26173 0 : return p_objectFileNameList;
26174 : }
26175 :
26176 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26177 : SgStringList &
26178 0 : SgProject::get_objectFileNameList ()
26179 : {
26180 0 : assert (this != NULL);
26181 :
26182 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26183 : // As a rule only set_ access functions can set the isModified flag.
26184 : // set_isModified(true);
26185 :
26186 0 : return p_objectFileNameList;
26187 : }
26188 :
26189 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26190 :
26191 :
26192 : // End of memberFunctionString
26193 : // Start of memberFunctionString
26194 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26195 :
26196 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26197 :
26198 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26199 : const SgStringList &
26200 0 : SgProject::get_libraryFileList () const
26201 : {
26202 0 : assert (this != NULL);
26203 0 : return p_libraryFileList;
26204 : }
26205 :
26206 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26207 : SgStringList &
26208 0 : SgProject::get_libraryFileList ()
26209 : {
26210 0 : assert (this != NULL);
26211 :
26212 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26213 : // As a rule only set_ access functions can set the isModified flag.
26214 : // set_isModified(true);
26215 :
26216 0 : return p_libraryFileList;
26217 : }
26218 :
26219 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26220 :
26221 :
26222 : // End of memberFunctionString
26223 : // Start of memberFunctionString
26224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26225 :
26226 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26227 :
26228 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26229 : const SgStringList &
26230 0 : SgProject::get_librarySpecifierList () const
26231 : {
26232 0 : assert (this != NULL);
26233 0 : return p_librarySpecifierList;
26234 : }
26235 :
26236 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26237 : SgStringList &
26238 0 : SgProject::get_librarySpecifierList ()
26239 : {
26240 0 : assert (this != NULL);
26241 :
26242 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26243 : // As a rule only set_ access functions can set the isModified flag.
26244 : // set_isModified(true);
26245 :
26246 0 : return p_librarySpecifierList;
26247 : }
26248 :
26249 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26250 :
26251 :
26252 : // End of memberFunctionString
26253 : // Start of memberFunctionString
26254 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26255 :
26256 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26257 :
26258 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26259 : const SgStringList &
26260 0 : SgProject::get_libraryDirectorySpecifierList () const
26261 : {
26262 0 : assert (this != NULL);
26263 0 : return p_libraryDirectorySpecifierList;
26264 : }
26265 :
26266 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26267 : SgStringList &
26268 0 : SgProject::get_libraryDirectorySpecifierList ()
26269 : {
26270 0 : assert (this != NULL);
26271 :
26272 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26273 : // As a rule only set_ access functions can set the isModified flag.
26274 : // set_isModified(true);
26275 :
26276 0 : return p_libraryDirectorySpecifierList;
26277 : }
26278 :
26279 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26280 :
26281 :
26282 : // End of memberFunctionString
26283 : // Start of memberFunctionString
26284 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26285 :
26286 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26287 :
26288 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26289 : const SgStringList &
26290 0 : SgProject::get_includeDirectorySpecifierList () const
26291 : {
26292 0 : assert (this != NULL);
26293 0 : return p_includeDirectorySpecifierList;
26294 : }
26295 :
26296 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26297 : SgStringList &
26298 74 : SgProject::get_includeDirectorySpecifierList ()
26299 : {
26300 74 : assert (this != NULL);
26301 :
26302 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26303 : // As a rule only set_ access functions can set the isModified flag.
26304 : // set_isModified(true);
26305 :
26306 74 : return p_includeDirectorySpecifierList;
26307 : }
26308 :
26309 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26310 :
26311 :
26312 : // End of memberFunctionString
26313 : // Start of memberFunctionString
26314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26315 :
26316 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26317 :
26318 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26319 : const SgStringList &
26320 0 : SgProject::get_macroSpecifierList () const
26321 : {
26322 0 : assert (this != NULL);
26323 0 : return p_macroSpecifierList;
26324 : }
26325 :
26326 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26327 : SgStringList &
26328 37 : SgProject::get_macroSpecifierList ()
26329 : {
26330 37 : assert (this != NULL);
26331 :
26332 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26333 : // As a rule only set_ access functions can set the isModified flag.
26334 : // set_isModified(true);
26335 :
26336 37 : return p_macroSpecifierList;
26337 : }
26338 :
26339 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26340 :
26341 :
26342 : // End of memberFunctionString
26343 : // Start of memberFunctionString
26344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26345 :
26346 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26347 :
26348 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26349 : const SgStringList &
26350 0 : SgProject::get_preincludeFileList () const
26351 : {
26352 0 : assert (this != NULL);
26353 0 : return p_preincludeFileList;
26354 : }
26355 :
26356 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26357 : SgStringList &
26358 640 : SgProject::get_preincludeFileList ()
26359 : {
26360 640 : assert (this != NULL);
26361 :
26362 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26363 : // As a rule only set_ access functions can set the isModified flag.
26364 : // set_isModified(true);
26365 :
26366 640 : return p_preincludeFileList;
26367 : }
26368 :
26369 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26370 :
26371 :
26372 : // End of memberFunctionString
26373 : // Start of memberFunctionString
26374 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
26375 :
26376 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26377 :
26378 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26379 : const SgStringList &
26380 0 : SgProject::get_preincludeDirectoryList () const
26381 : {
26382 0 : assert (this != NULL);
26383 0 : return p_preincludeDirectoryList;
26384 : }
26385 :
26386 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
26387 : SgStringList &
26388 640 : SgProject::get_preincludeDirectoryList ()
26389 : {
26390 640 : assert (this != NULL);
26391 :
26392 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
26393 : // As a rule only set_ access functions can set the isModified flag.
26394 : // set_isModified(true);
26395 :
26396 640 : return p_preincludeDirectoryList;
26397 : }
26398 :
26399 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26400 :
26401 :
26402 : // End of memberFunctionString
26403 : // Start of memberFunctionString
26404 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26405 :
26406 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26407 :
26408 : bool
26409 351 : SgProject::get_compileOnly () const
26410 : {
26411 351 : ROSE_ASSERT (this != NULL);
26412 :
26413 : #if 0
26414 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26415 : // used to trigger marking transformations for the token-based unparsing.
26416 : printf ("SgProject::get_compileOnly = %p = %s \n",this,this->class_name().c_str());
26417 : #endif
26418 :
26419 351 : return p_compileOnly;
26420 : }
26421 :
26422 : void
26423 348 : SgProject::set_compileOnly ( bool compileOnly )
26424 : {
26425 348 : ROSE_ASSERT (this != NULL);
26426 :
26427 : #if 0
26428 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26429 : // used to trigger marking transformations for the token-based unparsing.
26430 : printf ("SgProject::set_compileOnly = %p = %s \n",this,this->class_name().c_str());
26431 : #endif
26432 :
26433 348 : set_isModified(true);
26434 :
26435 348 : p_compileOnly = compileOnly;
26436 348 : }
26437 :
26438 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26439 :
26440 :
26441 : // End of memberFunctionString
26442 : // Start of memberFunctionString
26443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26444 :
26445 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26446 :
26447 : bool
26448 0 : SgProject::get_wave () const
26449 : {
26450 0 : ROSE_ASSERT (this != NULL);
26451 :
26452 : #if 0
26453 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26454 : // used to trigger marking transformations for the token-based unparsing.
26455 : printf ("SgProject::get_wave = %p = %s \n",this,this->class_name().c_str());
26456 : #endif
26457 :
26458 0 : return p_wave;
26459 : }
26460 :
26461 : void
26462 0 : SgProject::set_wave ( bool wave )
26463 : {
26464 0 : ROSE_ASSERT (this != NULL);
26465 :
26466 : #if 0
26467 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26468 : // used to trigger marking transformations for the token-based unparsing.
26469 : printf ("SgProject::set_wave = %p = %s \n",this,this->class_name().c_str());
26470 : #endif
26471 :
26472 0 : set_isModified(true);
26473 :
26474 0 : p_wave = wave;
26475 0 : }
26476 :
26477 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26478 :
26479 :
26480 : // End of memberFunctionString
26481 : // Start of memberFunctionString
26482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26483 :
26484 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26485 :
26486 : bool
26487 1020 : SgProject::get_prelink () const
26488 : {
26489 1020 : ROSE_ASSERT (this != NULL);
26490 :
26491 : #if 0
26492 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26493 : // used to trigger marking transformations for the token-based unparsing.
26494 : printf ("SgProject::get_prelink = %p = %s \n",this,this->class_name().c_str());
26495 : #endif
26496 :
26497 1020 : return p_prelink;
26498 : }
26499 :
26500 : void
26501 354 : SgProject::set_prelink ( bool prelink )
26502 : {
26503 354 : ROSE_ASSERT (this != NULL);
26504 :
26505 : #if 0
26506 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26507 : // used to trigger marking transformations for the token-based unparsing.
26508 : printf ("SgProject::set_prelink = %p = %s \n",this,this->class_name().c_str());
26509 : #endif
26510 :
26511 354 : set_isModified(true);
26512 :
26513 354 : p_prelink = prelink;
26514 354 : }
26515 :
26516 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26517 :
26518 :
26519 : // End of memberFunctionString
26520 : // Start of memberFunctionString
26521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26522 :
26523 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26524 :
26525 : SgProject::template_instantiation_enum
26526 325 : SgProject::get_template_instantiation_mode () const
26527 : {
26528 325 : ROSE_ASSERT (this != NULL);
26529 :
26530 : #if 0
26531 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26532 : // used to trigger marking transformations for the token-based unparsing.
26533 : printf ("SgProject::get_template_instantiation_mode = %p = %s \n",this,this->class_name().c_str());
26534 : #endif
26535 :
26536 325 : return p_template_instantiation_mode;
26537 : }
26538 :
26539 : void
26540 0 : SgProject::set_template_instantiation_mode ( SgProject::template_instantiation_enum template_instantiation_mode )
26541 : {
26542 0 : ROSE_ASSERT (this != NULL);
26543 :
26544 : #if 0
26545 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26546 : // used to trigger marking transformations for the token-based unparsing.
26547 : printf ("SgProject::set_template_instantiation_mode = %p = %s \n",this,this->class_name().c_str());
26548 : #endif
26549 :
26550 0 : set_isModified(true);
26551 :
26552 0 : p_template_instantiation_mode = template_instantiation_mode;
26553 0 : }
26554 :
26555 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26556 :
26557 :
26558 : // End of memberFunctionString
26559 : // Start of memberFunctionString
26560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26561 :
26562 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26563 :
26564 : bool
26565 1008 : SgProject::get_ast_merge () const
26566 : {
26567 1008 : ROSE_ASSERT (this != NULL);
26568 :
26569 : #if 0
26570 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26571 : // used to trigger marking transformations for the token-based unparsing.
26572 : printf ("SgProject::get_ast_merge = %p = %s \n",this,this->class_name().c_str());
26573 : #endif
26574 :
26575 1008 : return p_ast_merge;
26576 : }
26577 :
26578 : void
26579 0 : SgProject::set_ast_merge ( bool ast_merge )
26580 : {
26581 0 : ROSE_ASSERT (this != NULL);
26582 :
26583 : #if 0
26584 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26585 : // used to trigger marking transformations for the token-based unparsing.
26586 : printf ("SgProject::set_ast_merge = %p = %s \n",this,this->class_name().c_str());
26587 : #endif
26588 :
26589 0 : set_isModified(true);
26590 :
26591 0 : p_ast_merge = ast_merge;
26592 0 : }
26593 :
26594 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26595 :
26596 :
26597 : // End of memberFunctionString
26598 : // Start of memberFunctionString
26599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26600 :
26601 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26602 :
26603 : std::string
26604 0 : SgProject::get_projectSpecificDatabaseFile () const
26605 : {
26606 0 : ROSE_ASSERT (this != NULL);
26607 :
26608 : #if 0
26609 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26610 : // used to trigger marking transformations for the token-based unparsing.
26611 : printf ("SgProject::get_projectSpecificDatabaseFile = %p = %s \n",this,this->class_name().c_str());
26612 : #endif
26613 :
26614 0 : return p_projectSpecificDatabaseFile;
26615 : }
26616 :
26617 : void
26618 0 : SgProject::set_projectSpecificDatabaseFile ( std::string projectSpecificDatabaseFile )
26619 : {
26620 0 : ROSE_ASSERT (this != NULL);
26621 :
26622 : #if 0
26623 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26624 : // used to trigger marking transformations for the token-based unparsing.
26625 : printf ("SgProject::set_projectSpecificDatabaseFile = %p = %s \n",this,this->class_name().c_str());
26626 : #endif
26627 :
26628 0 : set_isModified(true);
26629 :
26630 0 : p_projectSpecificDatabaseFile = projectSpecificDatabaseFile;
26631 0 : }
26632 :
26633 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26634 :
26635 :
26636 : // End of memberFunctionString
26637 : // Start of memberFunctionString
26638 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26639 :
26640 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26641 :
26642 : bool
26643 346 : SgProject::get_C_PreprocessorOnly () const
26644 : {
26645 346 : ROSE_ASSERT (this != NULL);
26646 :
26647 : #if 0
26648 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26649 : // used to trigger marking transformations for the token-based unparsing.
26650 : printf ("SgProject::get_C_PreprocessorOnly = %p = %s \n",this,this->class_name().c_str());
26651 : #endif
26652 :
26653 346 : return p_C_PreprocessorOnly;
26654 : }
26655 :
26656 : void
26657 0 : SgProject::set_C_PreprocessorOnly ( bool C_PreprocessorOnly )
26658 : {
26659 0 : ROSE_ASSERT (this != NULL);
26660 :
26661 : #if 0
26662 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26663 : // used to trigger marking transformations for the token-based unparsing.
26664 : printf ("SgProject::set_C_PreprocessorOnly = %p = %s \n",this,this->class_name().c_str());
26665 : #endif
26666 :
26667 0 : set_isModified(true);
26668 :
26669 0 : p_C_PreprocessorOnly = C_PreprocessorOnly;
26670 0 : }
26671 :
26672 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26673 :
26674 :
26675 : // End of memberFunctionString
26676 : // Start of memberFunctionString
26677 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
26678 :
26679 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26680 :
26681 : AstAttributeMechanism*
26682 8 : SgProject::get_attributeMechanism () const
26683 : {
26684 8 : ROSE_ASSERT (this != NULL);
26685 8 : return p_attributeMechanism;
26686 : }
26687 :
26688 : void
26689 0 : SgProject::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
26690 : {
26691 0 : ROSE_ASSERT (this != NULL);
26692 :
26693 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
26694 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
26695 : {
26696 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
26697 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
26698 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
26699 : ROSE_ASSERT(false);
26700 : #endif
26701 : }
26702 : #endif
26703 0 : p_attributeMechanism = attributeMechanism;
26704 0 : }
26705 :
26706 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26707 :
26708 :
26709 : // End of memberFunctionString
26710 : // Start of memberFunctionString
26711 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
26712 :
26713 :
26714 : #if 0
26715 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
26716 : // a pointer and the interface represented directly at the SgNode
26717 : AstAttributeMechanism &
26718 : SgProject::attribute()
26719 : {
26720 : // DQ (1/2/2006): This function preserves as much of
26721 : // the syntax of attribute being a public data member.
26722 : if (p_attribute == NULL)
26723 : {
26724 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
26725 : assert(false);
26726 : }
26727 :
26728 : return *p_attribute;
26729 : }
26730 : #endif
26731 :
26732 : void
26733 0 : SgProject::addNewAttribute( std::string s, AstAttribute* a )
26734 : {
26735 0 : if (get_attributeMechanism() == NULL)
26736 : {
26737 0 : set_attributeMechanism( new AstAttributeMechanism() );
26738 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
26739 : }
26740 0 : get_attributeMechanism()->add(s,a);
26741 0 : }
26742 :
26743 : void
26744 0 : SgProject::setAttribute( std::string s, AstAttribute* a )
26745 : {
26746 0 : if (get_attributeMechanism() == NULL)
26747 : {
26748 0 : set_attributeMechanism( new AstAttributeMechanism() );
26749 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
26750 : }
26751 0 : get_attributeMechanism()->set(s,a);
26752 0 : }
26753 :
26754 : AstAttribute*
26755 0 : SgProject::getAttribute(std::string s) const
26756 : {
26757 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
26758 0 : if (attributeExists(s)==false) return NULL;
26759 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
26760 0 : ROSE_ASSERT(returnValue != NULL);
26761 0 : return returnValue;
26762 : }
26763 :
26764 : void
26765 0 : SgProject::updateAttribute( std::string s, AstAttribute* a )
26766 : {
26767 : // formerly called: replace
26768 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
26769 0 : get_attributeMechanism()->replace(s,a);
26770 0 : }
26771 :
26772 : void
26773 0 : SgProject::removeAttribute(std::string s)
26774 : {
26775 0 : if (get_attributeMechanism())
26776 0 : get_attributeMechanism()->remove(s);
26777 :
26778 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
26779 0 : int remainingCount = numberOfAttributes();
26780 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
26781 0 : if (remainingCount == 0)
26782 : {
26783 0 : delete get_attributeMechanism();
26784 0 : set_attributeMechanism(NULL);
26785 : }
26786 0 : }
26787 :
26788 : bool
26789 0 : SgProject::attributeExists(std::string s) const
26790 : {
26791 0 : bool returnValue = false;
26792 0 : if (get_attributeMechanism() != NULL)
26793 0 : returnValue = get_attributeMechanism()->exists(s);
26794 0 : return returnValue;
26795 : }
26796 :
26797 : int
26798 0 : SgProject::numberOfAttributes() const
26799 : {
26800 0 : int returnValue = 0;
26801 0 : if (get_attributeMechanism() != NULL)
26802 0 : returnValue = get_attributeMechanism()->size();
26803 0 : return returnValue;
26804 : }
26805 :
26806 :
26807 :
26808 : // End of memberFunctionString
26809 : // Start of memberFunctionString
26810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26811 :
26812 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26813 :
26814 : std::string
26815 0 : SgProject::get_compilationPerformanceFile () const
26816 : {
26817 0 : ROSE_ASSERT (this != NULL);
26818 :
26819 : #if 0
26820 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26821 : // used to trigger marking transformations for the token-based unparsing.
26822 : printf ("SgProject::get_compilationPerformanceFile = %p = %s \n",this,this->class_name().c_str());
26823 : #endif
26824 :
26825 0 : return p_compilationPerformanceFile;
26826 : }
26827 :
26828 : void
26829 0 : SgProject::set_compilationPerformanceFile ( std::string compilationPerformanceFile )
26830 : {
26831 0 : ROSE_ASSERT (this != NULL);
26832 :
26833 : #if 0
26834 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26835 : // used to trigger marking transformations for the token-based unparsing.
26836 : printf ("SgProject::set_compilationPerformanceFile = %p = %s \n",this,this->class_name().c_str());
26837 : #endif
26838 :
26839 0 : set_isModified(true);
26840 :
26841 0 : p_compilationPerformanceFile = compilationPerformanceFile;
26842 0 : }
26843 :
26844 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26845 :
26846 :
26847 : // End of memberFunctionString
26848 : // Start of memberFunctionString
26849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
26850 :
26851 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26852 :
26853 : bool
26854 3954 : SgProject::get_binary_only () const
26855 : {
26856 3954 : ROSE_ASSERT (this != NULL);
26857 3954 : return p_binary_only;
26858 : }
26859 :
26860 : void
26861 0 : SgProject::set_binary_only ( bool binary_only )
26862 : {
26863 0 : ROSE_ASSERT (this != NULL);
26864 :
26865 0 : p_binary_only = binary_only;
26866 0 : }
26867 :
26868 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26869 :
26870 :
26871 : // End of memberFunctionString
26872 : // Start of memberFunctionString
26873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26874 :
26875 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26876 :
26877 : SgDirectoryList*
26878 0 : SgProject::get_directoryList () const
26879 : {
26880 0 : ROSE_ASSERT (this != NULL);
26881 :
26882 : #if 0
26883 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26884 : // used to trigger marking transformations for the token-based unparsing.
26885 : printf ("SgProject::get_directoryList = %p = %s \n",this,this->class_name().c_str());
26886 : #endif
26887 :
26888 0 : return p_directoryList;
26889 : }
26890 :
26891 : void
26892 0 : SgProject::set_directoryList ( SgDirectoryList* directoryList )
26893 : {
26894 0 : ROSE_ASSERT (this != NULL);
26895 :
26896 : #if 0
26897 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26898 : // used to trigger marking transformations for the token-based unparsing.
26899 : printf ("SgProject::set_directoryList = %p = %s \n",this,this->class_name().c_str());
26900 : #endif
26901 :
26902 0 : set_isModified(true);
26903 :
26904 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
26905 : if (p_directoryList != NULL && directoryList != NULL && p_directoryList != directoryList)
26906 : {
26907 : printf ("Warning: directoryList = %p overwriting valid pointer p_directoryList = %p \n",directoryList,p_directoryList);
26908 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
26909 : printf ("Error fails assertion (p_directoryList != NULL && directoryList != NULL && p_directoryList != directoryList) is false\n");
26910 : ROSE_ASSERT(false);
26911 : #endif
26912 : }
26913 : #endif
26914 0 : p_directoryList = directoryList;
26915 0 : }
26916 :
26917 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26918 :
26919 :
26920 : // End of memberFunctionString
26921 : // Start of memberFunctionString
26922 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26923 :
26924 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26925 :
26926 : std::list<std::string>
26927 0 : SgProject::get_Fortran_ofp_jvm_options () const
26928 : {
26929 0 : ROSE_ASSERT (this != NULL);
26930 :
26931 : #if 0
26932 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26933 : // used to trigger marking transformations for the token-based unparsing.
26934 : printf ("SgProject::get_Fortran_ofp_jvm_options = %p = %s \n",this,this->class_name().c_str());
26935 : #endif
26936 :
26937 0 : return p_Fortran_ofp_jvm_options;
26938 : }
26939 :
26940 : void
26941 0 : SgProject::set_Fortran_ofp_jvm_options ( std::list<std::string> Fortran_ofp_jvm_options )
26942 : {
26943 0 : ROSE_ASSERT (this != NULL);
26944 :
26945 : #if 0
26946 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26947 : // used to trigger marking transformations for the token-based unparsing.
26948 : printf ("SgProject::set_Fortran_ofp_jvm_options = %p = %s \n",this,this->class_name().c_str());
26949 : #endif
26950 :
26951 0 : set_isModified(true);
26952 :
26953 0 : p_Fortran_ofp_jvm_options = Fortran_ofp_jvm_options;
26954 0 : }
26955 :
26956 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26957 :
26958 :
26959 : // End of memberFunctionString
26960 : // Start of memberFunctionString
26961 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
26962 :
26963 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26964 :
26965 : bool
26966 3 : SgProject::get_openmp_linking () const
26967 : {
26968 3 : ROSE_ASSERT (this != NULL);
26969 3 : return p_openmp_linking;
26970 : }
26971 :
26972 : void
26973 354 : SgProject::set_openmp_linking ( bool openmp_linking )
26974 : {
26975 354 : ROSE_ASSERT (this != NULL);
26976 :
26977 354 : p_openmp_linking = openmp_linking;
26978 354 : }
26979 :
26980 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
26981 :
26982 :
26983 : // End of memberFunctionString
26984 : // Start of memberFunctionString
26985 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
26986 :
26987 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
26988 :
26989 : std::list<std::string>
26990 0 : SgProject::get_Java_ecj_jvm_options () const
26991 : {
26992 0 : ROSE_ASSERT (this != NULL);
26993 :
26994 : #if 0
26995 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
26996 : // used to trigger marking transformations for the token-based unparsing.
26997 : printf ("SgProject::get_Java_ecj_jvm_options = %p = %s \n",this,this->class_name().c_str());
26998 : #endif
26999 :
27000 0 : return p_Java_ecj_jvm_options;
27001 : }
27002 :
27003 : void
27004 0 : SgProject::set_Java_ecj_jvm_options ( std::list<std::string> Java_ecj_jvm_options )
27005 : {
27006 0 : ROSE_ASSERT (this != NULL);
27007 :
27008 : #if 0
27009 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27010 : // used to trigger marking transformations for the token-based unparsing.
27011 : printf ("SgProject::set_Java_ecj_jvm_options = %p = %s \n",this,this->class_name().c_str());
27012 : #endif
27013 :
27014 0 : set_isModified(true);
27015 :
27016 0 : p_Java_ecj_jvm_options = Java_ecj_jvm_options;
27017 0 : }
27018 :
27019 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27020 :
27021 :
27022 : // End of memberFunctionString
27023 : // Start of memberFunctionString
27024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
27025 :
27026 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27027 :
27028 : bool
27029 0 : SgProject::get_Java_batch_mode () const
27030 : {
27031 0 : ROSE_ASSERT (this != NULL);
27032 0 : return p_Java_batch_mode;
27033 : }
27034 :
27035 : void
27036 0 : SgProject::set_Java_batch_mode ( bool Java_batch_mode )
27037 : {
27038 0 : ROSE_ASSERT (this != NULL);
27039 :
27040 0 : p_Java_batch_mode = Java_batch_mode;
27041 0 : }
27042 :
27043 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27044 :
27045 :
27046 : // End of memberFunctionString
27047 : // Start of memberFunctionString
27048 :
27049 :
27050 : // End of memberFunctionString
27051 : // Start of memberFunctionString
27052 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
27053 :
27054 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27055 :
27056 : bool
27057 354 : SgProject::get_addCppDirectivesToAST () const
27058 : {
27059 354 : ROSE_ASSERT (this != NULL);
27060 354 : return p_addCppDirectivesToAST;
27061 : }
27062 :
27063 : void
27064 354 : SgProject::set_addCppDirectivesToAST ( bool addCppDirectivesToAST )
27065 : {
27066 354 : ROSE_ASSERT (this != NULL);
27067 :
27068 354 : p_addCppDirectivesToAST = addCppDirectivesToAST;
27069 354 : }
27070 :
27071 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27072 :
27073 :
27074 : // End of memberFunctionString
27075 : // Start of memberFunctionString
27076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27077 :
27078 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27079 :
27080 : std::map<std::string, std::set<PreprocessingInfo*> >
27081 0 : SgProject::get_includingPreprocessingInfosMap () const
27082 : {
27083 0 : ROSE_ASSERT (this != NULL);
27084 :
27085 : #if 0
27086 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27087 : // used to trigger marking transformations for the token-based unparsing.
27088 : printf ("SgProject::get_includingPreprocessingInfosMap = %p = %s \n",this,this->class_name().c_str());
27089 : #endif
27090 :
27091 0 : return p_includingPreprocessingInfosMap;
27092 : }
27093 :
27094 : void
27095 0 : SgProject::set_includingPreprocessingInfosMap ( std::map<std::string, std::set<PreprocessingInfo*> > includingPreprocessingInfosMap )
27096 : {
27097 0 : ROSE_ASSERT (this != NULL);
27098 :
27099 : #if 0
27100 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27101 : // used to trigger marking transformations for the token-based unparsing.
27102 : printf ("SgProject::set_includingPreprocessingInfosMap = %p = %s \n",this,this->class_name().c_str());
27103 : #endif
27104 :
27105 0 : set_isModified(true);
27106 :
27107 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
27108 : if (p_includingPreprocessingInfosMap != NULL && includingPreprocessingInfosMap != NULL && p_includingPreprocessingInfosMap != includingPreprocessingInfosMap)
27109 : {
27110 : printf ("Warning: includingPreprocessingInfosMap = %p overwriting valid pointer p_includingPreprocessingInfosMap = %p \n",includingPreprocessingInfosMap,p_includingPreprocessingInfosMap);
27111 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
27112 : printf ("Error fails assertion (p_includingPreprocessingInfosMap != NULL && includingPreprocessingInfosMap != NULL && p_includingPreprocessingInfosMap != includingPreprocessingInfosMap) is false\n");
27113 : ROSE_ASSERT(false);
27114 : #endif
27115 : }
27116 : #endif
27117 0 : p_includingPreprocessingInfosMap = includingPreprocessingInfosMap;
27118 0 : }
27119 :
27120 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27121 :
27122 :
27123 : // End of memberFunctionString
27124 : // Start of memberFunctionString
27125 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27126 :
27127 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27128 :
27129 : std::list<std::string>
27130 0 : SgProject::get_quotedIncludesSearchPaths () const
27131 : {
27132 0 : ROSE_ASSERT (this != NULL);
27133 :
27134 : #if 0
27135 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27136 : // used to trigger marking transformations for the token-based unparsing.
27137 : printf ("SgProject::get_quotedIncludesSearchPaths = %p = %s \n",this,this->class_name().c_str());
27138 : #endif
27139 :
27140 0 : return p_quotedIncludesSearchPaths;
27141 : }
27142 :
27143 : void
27144 0 : SgProject::set_quotedIncludesSearchPaths ( std::list<std::string> quotedIncludesSearchPaths )
27145 : {
27146 0 : ROSE_ASSERT (this != NULL);
27147 :
27148 : #if 0
27149 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27150 : // used to trigger marking transformations for the token-based unparsing.
27151 : printf ("SgProject::set_quotedIncludesSearchPaths = %p = %s \n",this,this->class_name().c_str());
27152 : #endif
27153 :
27154 0 : set_isModified(true);
27155 :
27156 0 : p_quotedIncludesSearchPaths = quotedIncludesSearchPaths;
27157 0 : }
27158 :
27159 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27160 :
27161 :
27162 : // End of memberFunctionString
27163 : // Start of memberFunctionString
27164 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27165 :
27166 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27167 :
27168 : std::list<std::string>
27169 0 : SgProject::get_bracketedIncludesSearchPaths () const
27170 : {
27171 0 : ROSE_ASSERT (this != NULL);
27172 :
27173 : #if 0
27174 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27175 : // used to trigger marking transformations for the token-based unparsing.
27176 : printf ("SgProject::get_bracketedIncludesSearchPaths = %p = %s \n",this,this->class_name().c_str());
27177 : #endif
27178 :
27179 0 : return p_bracketedIncludesSearchPaths;
27180 : }
27181 :
27182 : void
27183 0 : SgProject::set_bracketedIncludesSearchPaths ( std::list<std::string> bracketedIncludesSearchPaths )
27184 : {
27185 0 : ROSE_ASSERT (this != NULL);
27186 :
27187 : #if 0
27188 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27189 : // used to trigger marking transformations for the token-based unparsing.
27190 : printf ("SgProject::set_bracketedIncludesSearchPaths = %p = %s \n",this,this->class_name().c_str());
27191 : #endif
27192 :
27193 0 : set_isModified(true);
27194 :
27195 0 : p_bracketedIncludesSearchPaths = bracketedIncludesSearchPaths;
27196 0 : }
27197 :
27198 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27199 :
27200 :
27201 : // End of memberFunctionString
27202 : // Start of memberFunctionString
27203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27204 :
27205 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27206 :
27207 : std::string
27208 0 : SgProject::get_unparseHeaderFilesRootFolder () const
27209 : {
27210 0 : ROSE_ASSERT (this != NULL);
27211 :
27212 : #if 0
27213 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27214 : // used to trigger marking transformations for the token-based unparsing.
27215 : printf ("SgProject::get_unparseHeaderFilesRootFolder = %p = %s \n",this,this->class_name().c_str());
27216 : #endif
27217 :
27218 0 : return p_unparseHeaderFilesRootFolder;
27219 : }
27220 :
27221 : void
27222 0 : SgProject::set_unparseHeaderFilesRootFolder ( std::string unparseHeaderFilesRootFolder )
27223 : {
27224 0 : ROSE_ASSERT (this != NULL);
27225 :
27226 : #if 0
27227 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27228 : // used to trigger marking transformations for the token-based unparsing.
27229 : printf ("SgProject::set_unparseHeaderFilesRootFolder = %p = %s \n",this,this->class_name().c_str());
27230 : #endif
27231 :
27232 0 : set_isModified(true);
27233 :
27234 0 : p_unparseHeaderFilesRootFolder = unparseHeaderFilesRootFolder;
27235 0 : }
27236 :
27237 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27238 :
27239 :
27240 : // End of memberFunctionString
27241 : // Start of memberFunctionString
27242 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27243 :
27244 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27245 :
27246 : bool
27247 316 : SgProject::get_frontendConstantFolding () const
27248 : {
27249 316 : ROSE_ASSERT (this != NULL);
27250 :
27251 : #if 0
27252 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27253 : // used to trigger marking transformations for the token-based unparsing.
27254 : printf ("SgProject::get_frontendConstantFolding = %p = %s \n",this,this->class_name().c_str());
27255 : #endif
27256 :
27257 316 : return p_frontendConstantFolding;
27258 : }
27259 :
27260 : void
27261 0 : SgProject::set_frontendConstantFolding ( bool frontendConstantFolding )
27262 : {
27263 0 : ROSE_ASSERT (this != NULL);
27264 :
27265 : #if 0
27266 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27267 : // used to trigger marking transformations for the token-based unparsing.
27268 : printf ("SgProject::set_frontendConstantFolding = %p = %s \n",this,this->class_name().c_str());
27269 : #endif
27270 :
27271 0 : set_isModified(true);
27272 :
27273 0 : p_frontendConstantFolding = frontendConstantFolding;
27274 0 : }
27275 :
27276 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27277 :
27278 :
27279 : // End of memberFunctionString
27280 : // Start of memberFunctionString
27281 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27282 :
27283 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27284 :
27285 : SgGlobal*
27286 6651180 : SgProject::get_globalScopeAcrossFiles () const
27287 : {
27288 6651180 : ROSE_ASSERT (this != NULL);
27289 :
27290 : #if 0
27291 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27292 : // used to trigger marking transformations for the token-based unparsing.
27293 : printf ("SgProject::get_globalScopeAcrossFiles = %p = %s \n",this,this->class_name().c_str());
27294 : #endif
27295 :
27296 6651180 : return p_globalScopeAcrossFiles;
27297 : }
27298 :
27299 : void
27300 0 : SgProject::set_globalScopeAcrossFiles ( SgGlobal* globalScopeAcrossFiles )
27301 : {
27302 0 : ROSE_ASSERT (this != NULL);
27303 :
27304 : #if 0
27305 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27306 : // used to trigger marking transformations for the token-based unparsing.
27307 : printf ("SgProject::set_globalScopeAcrossFiles = %p = %s \n",this,this->class_name().c_str());
27308 : #endif
27309 :
27310 0 : set_isModified(true);
27311 :
27312 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
27313 : if (p_globalScopeAcrossFiles != NULL && globalScopeAcrossFiles != NULL && p_globalScopeAcrossFiles != globalScopeAcrossFiles)
27314 : {
27315 : printf ("Warning: globalScopeAcrossFiles = %p overwriting valid pointer p_globalScopeAcrossFiles = %p \n",globalScopeAcrossFiles,p_globalScopeAcrossFiles);
27316 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
27317 : printf ("Error fails assertion (p_globalScopeAcrossFiles != NULL && globalScopeAcrossFiles != NULL && p_globalScopeAcrossFiles != globalScopeAcrossFiles) is false\n");
27318 : ROSE_ASSERT(false);
27319 : #endif
27320 : }
27321 : #endif
27322 0 : p_globalScopeAcrossFiles = globalScopeAcrossFiles;
27323 0 : }
27324 :
27325 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27326 :
27327 :
27328 : // End of memberFunctionString
27329 : // Start of memberFunctionString
27330 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27331 :
27332 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27333 :
27334 : bool
27335 660 : SgProject::get_unparse_in_same_directory_as_input_file () const
27336 : {
27337 660 : ROSE_ASSERT (this != NULL);
27338 :
27339 : #if 0
27340 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27341 : // used to trigger marking transformations for the token-based unparsing.
27342 : printf ("SgProject::get_unparse_in_same_directory_as_input_file = %p = %s \n",this,this->class_name().c_str());
27343 : #endif
27344 :
27345 660 : return p_unparse_in_same_directory_as_input_file;
27346 : }
27347 :
27348 : void
27349 354 : SgProject::set_unparse_in_same_directory_as_input_file ( bool unparse_in_same_directory_as_input_file )
27350 : {
27351 354 : ROSE_ASSERT (this != NULL);
27352 :
27353 : #if 0
27354 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27355 : // used to trigger marking transformations for the token-based unparsing.
27356 : printf ("SgProject::set_unparse_in_same_directory_as_input_file = %p = %s \n",this,this->class_name().c_str());
27357 : #endif
27358 :
27359 354 : set_isModified(true);
27360 :
27361 354 : p_unparse_in_same_directory_as_input_file = unparse_in_same_directory_as_input_file;
27362 354 : }
27363 :
27364 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27365 :
27366 :
27367 : // End of memberFunctionString
27368 : // Start of memberFunctionString
27369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27370 :
27371 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27372 :
27373 : bool
27374 346 : SgProject::get_stop_after_compilation_do_not_assemble_file () const
27375 : {
27376 346 : ROSE_ASSERT (this != NULL);
27377 :
27378 : #if 0
27379 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27380 : // used to trigger marking transformations for the token-based unparsing.
27381 : printf ("SgProject::get_stop_after_compilation_do_not_assemble_file = %p = %s \n",this,this->class_name().c_str());
27382 : #endif
27383 :
27384 346 : return p_stop_after_compilation_do_not_assemble_file;
27385 : }
27386 :
27387 : void
27388 0 : SgProject::set_stop_after_compilation_do_not_assemble_file ( bool stop_after_compilation_do_not_assemble_file )
27389 : {
27390 0 : ROSE_ASSERT (this != NULL);
27391 :
27392 : #if 0
27393 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27394 : // used to trigger marking transformations for the token-based unparsing.
27395 : printf ("SgProject::set_stop_after_compilation_do_not_assemble_file = %p = %s \n",this,this->class_name().c_str());
27396 : #endif
27397 :
27398 0 : set_isModified(true);
27399 :
27400 0 : p_stop_after_compilation_do_not_assemble_file = stop_after_compilation_do_not_assemble_file;
27401 0 : }
27402 :
27403 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27404 :
27405 :
27406 : // End of memberFunctionString
27407 : // Start of memberFunctionString
27408 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27409 :
27410 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27411 :
27412 : std::string
27413 0 : SgProject::get_gnuOptionForUndefinedSymbol () const
27414 : {
27415 0 : ROSE_ASSERT (this != NULL);
27416 :
27417 : #if 0
27418 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27419 : // used to trigger marking transformations for the token-based unparsing.
27420 : printf ("SgProject::get_gnuOptionForUndefinedSymbol = %p = %s \n",this,this->class_name().c_str());
27421 : #endif
27422 :
27423 0 : return p_gnuOptionForUndefinedSymbol;
27424 : }
27425 :
27426 : void
27427 0 : SgProject::set_gnuOptionForUndefinedSymbol ( std::string gnuOptionForUndefinedSymbol )
27428 : {
27429 0 : ROSE_ASSERT (this != NULL);
27430 :
27431 : #if 0
27432 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27433 : // used to trigger marking transformations for the token-based unparsing.
27434 : printf ("SgProject::set_gnuOptionForUndefinedSymbol = %p = %s \n",this,this->class_name().c_str());
27435 : #endif
27436 :
27437 0 : set_isModified(true);
27438 :
27439 0 : p_gnuOptionForUndefinedSymbol = gnuOptionForUndefinedSymbol;
27440 0 : }
27441 :
27442 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27443 :
27444 :
27445 : // End of memberFunctionString
27446 : // Start of memberFunctionString
27447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27448 :
27449 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27450 :
27451 : bool
27452 320 : SgProject::get_mode_32_bit () const
27453 : {
27454 320 : ROSE_ASSERT (this != NULL);
27455 :
27456 : #if 0
27457 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27458 : // used to trigger marking transformations for the token-based unparsing.
27459 : printf ("SgProject::get_mode_32_bit = %p = %s \n",this,this->class_name().c_str());
27460 : #endif
27461 :
27462 320 : return p_mode_32_bit;
27463 : }
27464 :
27465 : void
27466 0 : SgProject::set_mode_32_bit ( bool mode_32_bit )
27467 : {
27468 0 : ROSE_ASSERT (this != NULL);
27469 :
27470 : #if 0
27471 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27472 : // used to trigger marking transformations for the token-based unparsing.
27473 : printf ("SgProject::set_mode_32_bit = %p = %s \n",this,this->class_name().c_str());
27474 : #endif
27475 :
27476 0 : set_isModified(true);
27477 :
27478 0 : p_mode_32_bit = mode_32_bit;
27479 0 : }
27480 :
27481 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27482 :
27483 :
27484 : // End of memberFunctionString
27485 : // Start of memberFunctionString
27486 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27487 :
27488 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27489 :
27490 : bool
27491 5 : SgProject::get_noclobber_output_file () const
27492 : {
27493 5 : ROSE_ASSERT (this != NULL);
27494 :
27495 : #if 0
27496 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27497 : // used to trigger marking transformations for the token-based unparsing.
27498 : printf ("SgProject::get_noclobber_output_file = %p = %s \n",this,this->class_name().c_str());
27499 : #endif
27500 :
27501 5 : return p_noclobber_output_file;
27502 : }
27503 :
27504 : void
27505 0 : SgProject::set_noclobber_output_file ( bool noclobber_output_file )
27506 : {
27507 0 : ROSE_ASSERT (this != NULL);
27508 :
27509 : #if 0
27510 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27511 : // used to trigger marking transformations for the token-based unparsing.
27512 : printf ("SgProject::set_noclobber_output_file = %p = %s \n",this,this->class_name().c_str());
27513 : #endif
27514 :
27515 0 : set_isModified(true);
27516 :
27517 0 : p_noclobber_output_file = noclobber_output_file;
27518 0 : }
27519 :
27520 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27521 :
27522 :
27523 : // End of memberFunctionString
27524 : // Start of memberFunctionString
27525 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27526 :
27527 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27528 :
27529 : bool
27530 5 : SgProject::get_noclobber_if_different_output_file () const
27531 : {
27532 5 : ROSE_ASSERT (this != NULL);
27533 :
27534 : #if 0
27535 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27536 : // used to trigger marking transformations for the token-based unparsing.
27537 : printf ("SgProject::get_noclobber_if_different_output_file = %p = %s \n",this,this->class_name().c_str());
27538 : #endif
27539 :
27540 5 : return p_noclobber_if_different_output_file;
27541 : }
27542 :
27543 : void
27544 0 : SgProject::set_noclobber_if_different_output_file ( bool noclobber_if_different_output_file )
27545 : {
27546 0 : ROSE_ASSERT (this != NULL);
27547 :
27548 : #if 0
27549 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27550 : // used to trigger marking transformations for the token-based unparsing.
27551 : printf ("SgProject::set_noclobber_if_different_output_file = %p = %s \n",this,this->class_name().c_str());
27552 : #endif
27553 :
27554 0 : set_isModified(true);
27555 :
27556 0 : p_noclobber_if_different_output_file = noclobber_if_different_output_file;
27557 0 : }
27558 :
27559 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27560 :
27561 :
27562 : // End of memberFunctionString
27563 : // Start of memberFunctionString
27564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27565 :
27566 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27567 :
27568 : bool
27569 670 : SgProject::get_suppressConstantFoldingPostProcessing () const
27570 : {
27571 670 : ROSE_ASSERT (this != NULL);
27572 :
27573 : #if 0
27574 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27575 : // used to trigger marking transformations for the token-based unparsing.
27576 : printf ("SgProject::get_suppressConstantFoldingPostProcessing = %p = %s \n",this,this->class_name().c_str());
27577 : #endif
27578 :
27579 670 : return p_suppressConstantFoldingPostProcessing;
27580 : }
27581 :
27582 : void
27583 354 : SgProject::set_suppressConstantFoldingPostProcessing ( bool suppressConstantFoldingPostProcessing )
27584 : {
27585 354 : ROSE_ASSERT (this != NULL);
27586 :
27587 : #if 0
27588 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27589 : // used to trigger marking transformations for the token-based unparsing.
27590 : printf ("SgProject::set_suppressConstantFoldingPostProcessing = %p = %s \n",this,this->class_name().c_str());
27591 : #endif
27592 :
27593 354 : set_isModified(true);
27594 :
27595 354 : p_suppressConstantFoldingPostProcessing = suppressConstantFoldingPostProcessing;
27596 354 : }
27597 :
27598 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27599 :
27600 :
27601 : // End of memberFunctionString
27602 : // Start of memberFunctionString
27603 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27604 :
27605 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27606 :
27607 : bool
27608 5 : SgProject::get_appendPID () const
27609 : {
27610 5 : ROSE_ASSERT (this != NULL);
27611 :
27612 : #if 0
27613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27614 : // used to trigger marking transformations for the token-based unparsing.
27615 : printf ("SgProject::get_appendPID = %p = %s \n",this,this->class_name().c_str());
27616 : #endif
27617 :
27618 5 : return p_appendPID;
27619 : }
27620 :
27621 : void
27622 0 : SgProject::set_appendPID ( bool appendPID )
27623 : {
27624 0 : ROSE_ASSERT (this != NULL);
27625 :
27626 : #if 0
27627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27628 : // used to trigger marking transformations for the token-based unparsing.
27629 : printf ("SgProject::set_appendPID = %p = %s \n",this,this->class_name().c_str());
27630 : #endif
27631 :
27632 0 : set_isModified(true);
27633 :
27634 0 : p_appendPID = appendPID;
27635 0 : }
27636 :
27637 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27638 :
27639 :
27640 : // End of memberFunctionString
27641 : // Start of memberFunctionString
27642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27643 :
27644 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27645 :
27646 : bool
27647 0 : SgProject::get_reportOnHeaderFileUnparsing () const
27648 : {
27649 0 : ROSE_ASSERT (this != NULL);
27650 :
27651 : #if 0
27652 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27653 : // used to trigger marking transformations for the token-based unparsing.
27654 : printf ("SgProject::get_reportOnHeaderFileUnparsing = %p = %s \n",this,this->class_name().c_str());
27655 : #endif
27656 :
27657 0 : return p_reportOnHeaderFileUnparsing;
27658 : }
27659 :
27660 : void
27661 0 : SgProject::set_reportOnHeaderFileUnparsing ( bool reportOnHeaderFileUnparsing )
27662 : {
27663 0 : ROSE_ASSERT (this != NULL);
27664 :
27665 : #if 0
27666 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27667 : // used to trigger marking transformations for the token-based unparsing.
27668 : printf ("SgProject::set_reportOnHeaderFileUnparsing = %p = %s \n",this,this->class_name().c_str());
27669 : #endif
27670 :
27671 0 : set_isModified(true);
27672 :
27673 0 : p_reportOnHeaderFileUnparsing = reportOnHeaderFileUnparsing;
27674 0 : }
27675 :
27676 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27677 :
27678 :
27679 : // End of memberFunctionString
27680 : // Start of memberFunctionString
27681 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27682 :
27683 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27684 :
27685 : std::string
27686 11532 : SgProject::get_applicationRootDirectory () const
27687 : {
27688 11532 : ROSE_ASSERT (this != NULL);
27689 :
27690 : #if 0
27691 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27692 : // used to trigger marking transformations for the token-based unparsing.
27693 : printf ("SgProject::get_applicationRootDirectory = %p = %s \n",this,this->class_name().c_str());
27694 : #endif
27695 :
27696 11532 : return p_applicationRootDirectory;
27697 : }
27698 :
27699 : void
27700 0 : SgProject::set_applicationRootDirectory ( std::string applicationRootDirectory )
27701 : {
27702 0 : ROSE_ASSERT (this != NULL);
27703 :
27704 : #if 0
27705 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27706 : // used to trigger marking transformations for the token-based unparsing.
27707 : printf ("SgProject::set_applicationRootDirectory = %p = %s \n",this,this->class_name().c_str());
27708 : #endif
27709 :
27710 0 : set_isModified(true);
27711 :
27712 0 : p_applicationRootDirectory = applicationRootDirectory;
27713 0 : }
27714 :
27715 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27716 :
27717 :
27718 : // End of memberFunctionString
27719 : // Start of memberFunctionString
27720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27721 :
27722 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27723 :
27724 : bool
27725 0 : SgProject::get_usingApplicationRootDirectory () const
27726 : {
27727 0 : ROSE_ASSERT (this != NULL);
27728 :
27729 : #if 0
27730 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27731 : // used to trigger marking transformations for the token-based unparsing.
27732 : printf ("SgProject::get_usingApplicationRootDirectory = %p = %s \n",this,this->class_name().c_str());
27733 : #endif
27734 :
27735 0 : return p_usingApplicationRootDirectory;
27736 : }
27737 :
27738 : void
27739 0 : SgProject::set_usingApplicationRootDirectory ( bool usingApplicationRootDirectory )
27740 : {
27741 0 : ROSE_ASSERT (this != NULL);
27742 :
27743 : #if 0
27744 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27745 : // used to trigger marking transformations for the token-based unparsing.
27746 : printf ("SgProject::set_usingApplicationRootDirectory = %p = %s \n",this,this->class_name().c_str());
27747 : #endif
27748 :
27749 0 : set_isModified(true);
27750 :
27751 0 : p_usingApplicationRootDirectory = usingApplicationRootDirectory;
27752 0 : }
27753 :
27754 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27755 :
27756 :
27757 : // End of memberFunctionString
27758 : // Start of memberFunctionString
27759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27760 :
27761 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27762 :
27763 : bool
27764 0 : SgProject::get_usingDeferredTransformations () const
27765 : {
27766 0 : ROSE_ASSERT (this != NULL);
27767 :
27768 : #if 0
27769 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27770 : // used to trigger marking transformations for the token-based unparsing.
27771 : printf ("SgProject::get_usingDeferredTransformations = %p = %s \n",this,this->class_name().c_str());
27772 : #endif
27773 :
27774 0 : return p_usingDeferredTransformations;
27775 : }
27776 :
27777 : void
27778 0 : SgProject::set_usingDeferredTransformations ( bool usingDeferredTransformations )
27779 : {
27780 0 : ROSE_ASSERT (this != NULL);
27781 :
27782 : #if 0
27783 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27784 : // used to trigger marking transformations for the token-based unparsing.
27785 : printf ("SgProject::set_usingDeferredTransformations = %p = %s \n",this,this->class_name().c_str());
27786 : #endif
27787 :
27788 0 : set_isModified(true);
27789 :
27790 0 : p_usingDeferredTransformations = usingDeferredTransformations;
27791 0 : }
27792 :
27793 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27794 :
27795 :
27796 : // End of memberFunctionString
27797 : // Start of memberFunctionString
27798 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27799 :
27800 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27801 :
27802 : std::string
27803 349 : SgProject::get_astfile_out () const
27804 : {
27805 349 : ROSE_ASSERT (this != NULL);
27806 :
27807 : #if 0
27808 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27809 : // used to trigger marking transformations for the token-based unparsing.
27810 : printf ("SgProject::get_astfile_out = %p = %s \n",this,this->class_name().c_str());
27811 : #endif
27812 :
27813 349 : return p_astfile_out;
27814 : }
27815 :
27816 : void
27817 0 : SgProject::set_astfile_out ( std::string astfile_out )
27818 : {
27819 0 : ROSE_ASSERT (this != NULL);
27820 :
27821 : #if 0
27822 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27823 : // used to trigger marking transformations for the token-based unparsing.
27824 : printf ("SgProject::set_astfile_out = %p = %s \n",this,this->class_name().c_str());
27825 : #endif
27826 :
27827 0 : set_isModified(true);
27828 :
27829 0 : p_astfile_out = astfile_out;
27830 0 : }
27831 :
27832 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27833 :
27834 :
27835 : // End of memberFunctionString
27836 : // Start of memberFunctionString
27837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
27838 :
27839 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27840 :
27841 : std::list<std::string>
27842 354 : SgProject::get_astfiles_in () const
27843 : {
27844 354 : ROSE_ASSERT (this != NULL);
27845 :
27846 : #if 0
27847 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27848 : // used to trigger marking transformations for the token-based unparsing.
27849 : printf ("SgProject::get_astfiles_in = %p = %s \n",this,this->class_name().c_str());
27850 : #endif
27851 :
27852 354 : return p_astfiles_in;
27853 : }
27854 :
27855 : void
27856 3 : SgProject::set_astfiles_in ( std::list<std::string> astfiles_in )
27857 : {
27858 3 : ROSE_ASSERT (this != NULL);
27859 :
27860 : #if 0
27861 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
27862 : // used to trigger marking transformations for the token-based unparsing.
27863 : printf ("SgProject::set_astfiles_in = %p = %s \n",this,this->class_name().c_str());
27864 : #endif
27865 :
27866 3 : set_isModified(true);
27867 :
27868 3 : p_astfiles_in = astfiles_in;
27869 3 : }
27870 :
27871 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27872 :
27873 :
27874 : // End of memberFunctionString
27875 : // Start of memberFunctionString
27876 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
27877 :
27878 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27879 :
27880 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
27881 : const SgStringList &
27882 0 : SgProject::get_extraIncludeDirectorySpecifierBeforeList () const
27883 : {
27884 0 : assert (this != NULL);
27885 0 : return p_extraIncludeDirectorySpecifierBeforeList;
27886 : }
27887 :
27888 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
27889 : SgStringList &
27890 1735 : SgProject::get_extraIncludeDirectorySpecifierBeforeList ()
27891 : {
27892 1735 : assert (this != NULL);
27893 :
27894 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
27895 : // As a rule only set_ access functions can set the isModified flag.
27896 : // set_isModified(true);
27897 :
27898 1735 : return p_extraIncludeDirectorySpecifierBeforeList;
27899 : }
27900 :
27901 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27902 :
27903 :
27904 : // End of memberFunctionString
27905 : // Start of memberFunctionString
27906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
27907 :
27908 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
27909 :
27910 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
27911 : const SgStringList &
27912 0 : SgProject::get_extraIncludeDirectorySpecifierAfterList () const
27913 : {
27914 0 : assert (this != NULL);
27915 0 : return p_extraIncludeDirectorySpecifierAfterList;
27916 : }
27917 :
27918 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
27919 : SgStringList &
27920 1388 : SgProject::get_extraIncludeDirectorySpecifierAfterList ()
27921 : {
27922 1388 : assert (this != NULL);
27923 :
27924 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
27925 : // As a rule only set_ access functions can set the isModified flag.
27926 : // set_isModified(true);
27927 :
27928 1388 : return p_extraIncludeDirectorySpecifierAfterList;
27929 : }
27930 :
27931 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
27932 :
27933 :
27934 : // End of memberFunctionString
27935 : // Start of memberFunctionString
27936 : /* #line 18215 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
27937 :
27938 :
27939 : //! Declaration of space for static variables
27940 : //static int SgProject::p_defaultNumberOfCommandLineArguments = 0;
27941 : //static char** SgProject::p_defaultCommandLineArgumentList = NULL;
27942 :
27943 :
27944 : //! (static data) global concept of verbose level which controls useful output from the compiler
27945 : int SgProject::p_verbose = 0;
27946 :
27947 : // DQ (4/4/2020): Adding support for unparse headers feature specific diagnostics.
27948 : int SgProject::p_unparseHeaderFilesDebug = 0;
27949 :
27950 : //! this can constructor can be used but parse(int argc, char** argv) needs to be called
27951 2 : SgProject::SgProject()
27952 : {
27953 2 : initialization();
27954 2 : }
27955 :
27956 0 : SgProject::SgProject( const SgProject & project )
27957 : {
27958 : // This copy constructor is not supported, it is implemented with to return an error message!
27959 :
27960 0 : initialization();
27961 :
27962 : // What is the point of this code!
27963 : // p_numberOfCommandLineArguments(project.p_numberOfCommandLineArguments),
27964 : // p_commandLineArgumentList(project.p_commandLineArgumentList),
27965 : // p_defaultNumberOfCommandLineArguments(project.p_defaultNumberOfCommandLineArguments),
27966 : // p_defaultCommandLineArgumentList(project.p_defaultCommandLineArgumentList),
27967 :
27968 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
27969 : // DQ (1/20/2010): This is no longer a list and is now a pointer to a SgFileList IR node.
27970 :
27971 : // Build the empty STL lists
27972 : p_fileList.clear();
27973 : #endif
27974 :
27975 : // print error message and quit
27976 0 : mprintf ("ERROR: this SgProject copy constructor is not supposed to be used \n");
27977 0 : mprintf (" use SgProject ( int & argc, char** & argv , int & errorCode ) OR copy member function instead \n");
27978 0 : ROSE_ABORT();
27979 : }
27980 :
27981 : //! constructor invokes EDG front end and creates AST. Use frontend() instead.
27982 0 : SgProject::SgProject ( int argc, char** argv, bool frontendConstantFolding)
27983 : {
27984 : // DQ (11/4/2015): Added assertion.
27985 0 : ROSE_ASSERT(this != NULL);
27986 :
27987 0 : initialization();
27988 :
27989 : // DQ (9/18/2011): Added support to use frontend specific constnat folding (applies to C/C++ using EDG).
27990 : // All other languges have no specific constant folding options in there frontends. We use to support
27991 : // the original expression tree in the AST, and this provided both the constant folded value and
27992 : // the original expression tree, but this was a problem for analysis (which tened to mix them together).
27993 : // mprintf ("In SgProject(int argc,char** argv): frontendConstantFolding = %s \n",frontendConstantFolding == true ? "true" : "false");
27994 0 : p_frontendConstantFolding = frontendConstantFolding;
27995 :
27996 0 : std::vector<std::string> argvList(argv, argv + argc);
27997 0 : int errorCode = parse(argvList);
27998 0 : set_frontendErrorCode(errorCode);
27999 0 : }
28000 :
28001 : //! constructor invokes EDG front end and creates AST. Use frontend() instead.
28002 355 : SgProject::SgProject ( const std::vector<std::string>& argv, bool frontendConstantFolding )
28003 : {
28004 : // DQ (11/4/2015): Added assertion.
28005 355 : ROSE_ASSERT(this != NULL);
28006 :
28007 355 : initialization();
28008 :
28009 : // DQ (9/18/2011): Added support to use frontend specific constnat folding (applies to C/C++ using EDG).
28010 : // All other languges have no specific constant folding options in there frontends. We use to support
28011 : // the original expression tree in the AST, and this provided both the constant folded value and
28012 : // the original expression tree, but this was a problem for analysis (which tened to mix them together).
28013 : // mprintf ("In SgProject(const std::vector<std::string>& argv): frontendConstantFolding = %s \n",frontendConstantFolding == true ? "true" : "false");
28014 355 : p_frontendConstantFolding = frontendConstantFolding;
28015 :
28016 355 : int errorCode = parse(argv);
28017 354 : set_frontendErrorCode(errorCode);
28018 354 : }
28019 :
28020 : void
28021 357 : SgProject::initialization()
28022 : {
28023 : // DQ (4/11/2017): Some implementations of ROSE tools are just calling the SgProject constructor directly, these
28024 : // need to call ROSE_INITIALIZE. Here is a reasonable point to make that call.
28025 357 : ROSE_INITIALIZE;
28026 :
28027 : // DQ (10/16/2005): This function initializes default values (until we use an automatically generated version)
28028 :
28029 : // Matzke (12/06/2016): Added missing initializations identified by valgrind and code inspection
28030 357 : p_javacErrorCode = 0;
28031 357 : p_ecjErrorCode = 0;
28032 357 : p_midendErrorCode = 0;
28033 357 : p_openmp_linking = false;
28034 :
28035 : // DQ (11/10/2016): Added initialization for keep_going data member and otehr data members that appear to be missing.
28036 357 : p_keep_going = false;
28037 357 : p_unparser__clobber_input_file = false;
28038 :
28039 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28040 : p_fileList.clear();
28041 : #else
28042 : // Initialize to IR node
28043 357 : p_fileList_ptr = new SgFileList();
28044 357 : assert(p_fileList_ptr != NULL);
28045 :
28046 357 : p_fileList_ptr->set_parent(this);
28047 : #endif
28048 :
28049 : // p_numberOfCommandLineArguments = 0;
28050 : // p_commandLineArgumentList = NULL;
28051 : // p_defaultNumberOfCommandLineArguments = 0;
28052 : // p_defaultCommandLineArgumentList = NULL;
28053 357 : p_frontendErrorCode = 0;
28054 357 : p_backendErrorCode = 0;
28055 357 : p_outputFileName = "";
28056 357 : p_compileOnly = false;
28057 :
28058 : // DQ (11/10/2016): Added initialization for data member that appeared to be missing.
28059 357 : p_wave = false;
28060 :
28061 357 : p_prelink = false;
28062 357 : p_template_instantiation_mode = e_unknown;
28063 357 : p_ast_merge = false;
28064 357 : p_projectSpecificDatabaseFile = "";
28065 357 : p_compilationPerformanceFile = "";
28066 357 : p_C_PreprocessorOnly = false;
28067 :
28068 : // DQ (5/2/2006): Added initialization to prevent valgrind warning.
28069 357 : p_attributeMechanism = NULL;
28070 :
28071 : // DQ (1/23/2010): Added support for the project to have directory structure
28072 357 : p_directoryList = NULL;
28073 :
28074 : // DQ (3/9/2009): Allow the verbose level to be set before we even call the SgProject constructor (helps debug Intel Pin usage).
28075 357 : if (p_verbose > 0)
28076 : {
28077 0 : mprintf ("Note: Verbose was already set to non-zero value = %d (valid range is 0...10) \n",p_verbose);
28078 0 : assert(p_verbose <= 10);
28079 : }
28080 : else
28081 : {
28082 357 : p_verbose = 0;
28083 : }
28084 :
28085 : // DQ (2/4/2009): This was moved to the SgProject from the SgFile
28086 357 : p_binary_only = false;
28087 :
28088 : // DQ (1/16/2008): This is part of a ROSE supported mechanism for the
28089 : // specification of exclude/include paths/files for interpretation by
28090 : // the ROSE translator.
28091 : // p_lookForIncludePaths = false;
28092 : // p_lookForExcludePaths = false;
28093 :
28094 : // DQ (1/20/2010): Added support for the project to have directory structure
28095 : // (usefult for large scale code generation).
28096 357 : assert(p_directoryList == NULL);
28097 :
28098 : // Initialize pointers to valid opjects with empty lists.
28099 357 : p_directoryList = new SgDirectoryList();
28100 357 : assert(p_directoryList != NULL);
28101 357 : p_directoryList->set_parent(this);
28102 :
28103 : // DQ (10/3/2010): Added entries that had not be properly set previously.
28104 357 : p_C_only = false;
28105 357 : p_Cxx_only = false;
28106 :
28107 : // DQ (11/10/2016): Added initialization for data member that appeared to be missing.
28108 357 : p_C11_only = false;
28109 357 : p_Cxx0x_only = false;
28110 357 : p_Cxx11_only = false;
28111 357 : p_C14_only = false;
28112 357 : p_Cxx14_only = false;
28113 :
28114 357 : p_Fortran_only = false;
28115 357 : p_addCppDirectivesToAST = false;
28116 :
28117 357 : p_addCppDirectivesToAST = false;
28118 :
28119 : // DQ (9/18/2011): Added support for using more constant AST to select to use or not use frontend specific constant folding.
28120 357 : p_frontendConstantFolding = false;
28121 :
28122 : // TV (07/18/2013): Initialise the global GlobalScope for multiple flie handeling
28123 357 : Sg_File_Info * fi_gsaf = Sg_File_Info::generateDefaultFileInfoForCompilerGeneratedNode();
28124 357 : p_globalScopeAcrossFiles = new SgGlobal(fi_gsaf);
28125 357 : fi_gsaf->set_parent(p_globalScopeAcrossFiles);
28126 357 : p_globalScopeAcrossFiles->set_parent(this);
28127 :
28128 : // DQ (9/15/2013): Adding support to handle output of files into the same directory as the source file.
28129 : // This avoids some subtle issues in how header files are resolved by the backend compiler.
28130 : // See documentation in src/ROSETTA/src/support.C.
28131 357 : p_unparse_in_same_directory_as_input_file = false;
28132 :
28133 : // DQ (1/19/2014): This option "-S" is required for some build systems (e.g. valgrind).
28134 357 : p_stop_after_compilation_do_not_assemble_file = false;
28135 :
28136 : // DQ (1/20/2014): This option "-m32" over-rides the 64-bit mode on 64-bit environments and is required for some build systems (e.g. valgrind).
28137 357 : p_mode_32_bit = false;
28138 :
28139 : // DQ (3/19/2014): This option causes the output of source code to an existing file to be an error.
28140 357 : p_noclobber_output_file = false;
28141 :
28142 : // DQ (3/19/2014): This option causes the output of source code to an existing file to be an error if it results in a different file.
28143 357 : p_noclobber_if_different_output_file = false;
28144 :
28145 : // DQ (1/31/2014): Option to skip AST post-processing constant folding support. Currently required for OpenMP and C++, but not for C.
28146 : // This option only makes a perfromance difference on a handful of files in the (large) wireshark application (2.5 million line application).
28147 357 : p_suppressConstantFoldingPostProcessing = false;
28148 :
28149 : // Pei-Hung (8/6/2014): This option appends PID into the output name to avoid file collision in parallel compilation.
28150 357 : p_appendPID = false;
28151 :
28152 : // DQ (9/15/2018): Added support for a report on the internal use of header file unparsing.
28153 : // This is to support the header file unparsing when used with and without the token based unparsing.
28154 357 : p_reportOnHeaderFileUnparsing = false;
28155 :
28156 : // DQ (11/16/2019): this was not added previously.
28157 357 : p_usingApplicationRootDirectory = false;
28158 :
28159 : // DQ (11/16/2019): this is a new data member just added.
28160 357 : p_usingDeferredTransformations = false;
28161 357 : }
28162 :
28163 :
28164 : // DQ (2/1/2007): Added new operator so that w could depricate the inconsistant usage of
28165 : // SgFile& in get_file() member function. The get_file() member function is now depricated.
28166 : SgFile*
28167 391 : SgProject::operator[]( unsigned int i )
28168 : {
28169 :
28170 : // Since we use an STL vector internally we can use the vector::operator[] directly.
28171 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28172 : assert(i < get_fileList().size());
28173 : return p_fileList[i];
28174 : #else
28175 391 : assert(p_fileList_ptr != NULL);
28176 391 : assert(i < (unsigned)numberOfFiles());
28177 391 : return p_fileList_ptr->get_listOfFiles()[i];
28178 : #endif
28179 : }
28180 :
28181 : // DQ (6/13/2013): Access function for retriving a SgFile object from the list stored internally,
28182 : // but using the filename with full path. This is part of the new Java performance support and
28183 : // a design change that first builds all of the SgFile IR nodes and then calls the frontend for
28184 : // each of them. This permits a more sophisticated level of command line multiple file support.
28185 353 : SgFile* SgProject::operator[]( std::string filename )
28186 : {
28187 : // Since we use an STL vector internally we can use the vector::operator[] directly.
28188 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28189 : #error "ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT should be FALSE"
28190 : #else
28191 353 : ROSE_ASSERT(p_fileList_ptr != NULL);
28192 353 : ROSE_ASSERT(numberOfFiles() > 0);
28193 :
28194 : #if 0
28195 : mprintf ("In SgProject::operator[]( std::string filename ): Searching for the SgFile matching filename: filename = %s \n",filename.c_str());
28196 : #endif
28197 :
28198 353 : SgFilePtrList::iterator i = p_fileList_ptr->get_listOfFiles().begin();
28199 354 : while (i != p_fileList_ptr->get_listOfFiles().end())
28200 : {
28201 354 : ROSE_ASSERT(*i != NULL);
28202 : #if 0
28203 : mprintf ("Searching for the matching filename: filename = %s *i = %p \n",filename.c_str(),*i);
28204 : #endif
28205 : // Find the matching SgFile object using the get_sourceFileNameWithPath()
28206 708 : if (filename == (*i)->get_sourceFileNameWithPath())
28207 : {
28208 : #if 0
28209 : mprintf ("Found the matching filename: filename = %s *i = %p \n",filename.c_str(),*i);
28210 : #endif
28211 353 : return *i;
28212 : }
28213 :
28214 1 : i++;
28215 : }
28216 :
28217 : return NULL;
28218 : #endif
28219 : }
28220 :
28221 :
28222 : // Moved to sage_support.cpp: int SgProject::parse(const vector<string>& argv)
28223 : // Moved to sage_support.cpp: void SgProject::processCommandLine(const vector<string>& input_argv)
28224 :
28225 0 : std::ostream & operator<< ( std::ostream & os, const Rose_STL_Container<string> & l )
28226 : {
28227 : // mprintf ("Output Rose_STL_Container<string> in operator<< (std::ostream,Rose_STL_Container<string>) \n");
28228 0 : return os;
28229 : }
28230 :
28231 : // DQ (5/22/2007): Moved to astPostProcessing
28232 : // DQ (5/8/2007): Function prototype declared in HiddenList.h
28233 : // void buildHiddenTypeAndDeclarationLists( SgProject* project );
28234 :
28235 : #if 0
28236 : // Moved the sage_support.cpp
28237 : int
28238 : SgProject::parse()
28239 : {
28240 : int errorCode = 0;
28241 :
28242 : #error "DEAD CODE!"
28243 :
28244 : return errorCode;
28245 : }
28246 : #endif
28247 :
28248 :
28249 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28250 : #else
28251 : // DQ (1/21/2010): In this case we want to support the previous interface so that we can transition easily.
28252 :
28253 : SgFilePtrList &
28254 5336 : SgProject::get_fileList() const
28255 : {
28256 5336 : assert (this != NULL);
28257 5336 : return p_fileList_ptr->get_listOfFiles();
28258 : }
28259 :
28260 : void
28261 0 : SgProject::set_fileList( SgFilePtrList & fileList )
28262 : {
28263 0 : assert (this != NULL);
28264 0 : set_isModified(true);
28265 :
28266 0 : p_fileList_ptr->get_listOfFiles() = fileList;
28267 0 : }
28268 :
28269 : #endif
28270 :
28271 : int
28272 12133 : SgProject::numberOfFiles() const
28273 : {
28274 : // This function does not return a meaningful result until all the files have been processed
28275 : // assert (p_fileList != NULL);
28276 :
28277 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28278 : int returnValue = p_fileList.size();
28279 : #else
28280 12133 : assert (p_fileList_ptr != NULL);
28281 12133 : int returnValue = p_fileList_ptr->get_listOfFiles().size();
28282 : #endif
28283 : // assert ( returnValue > 0 );
28284 :
28285 : // Seems like a good upper bound for now!
28286 : // assert ( returnValue < 100 );
28287 :
28288 12133 : return returnValue;
28289 : }
28290 :
28291 : int
28292 353 : SgProject::numberOfDirectories() const
28293 : {
28294 353 : assert (p_directoryList != NULL);
28295 353 : int returnValue = p_directoryList->get_listOfDirectories().size();
28296 :
28297 353 : return returnValue;
28298 : }
28299 :
28300 : SgFile &
28301 2757 : SgProject::get_file ( int i ) const
28302 : {
28303 : // error checking
28304 2757 : assert (i >= 0);
28305 2757 : assert (i < numberOfFiles());
28306 :
28307 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28308 : SgFile* targetFile = p_fileList[i];
28309 : #else
28310 2757 : assert (p_fileList_ptr != NULL);
28311 2757 : SgFile* targetFile = p_fileList_ptr->get_listOfFiles()[i];
28312 : // SgFile* targetFile = NULL;
28313 :
28314 : // mprintf ("Exiting since this is not finished. \n");
28315 : // assert(false);
28316 : #endif
28317 2757 : assert (targetFile != NULL);
28318 :
28319 2757 : return *targetFile;
28320 : }
28321 :
28322 : void
28323 357 : SgProject::set_file ( SgFile & file )
28324 : {
28325 : // assert (p_fileList != NULL);
28326 :
28327 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
28328 : p_fileList.push_back(&file);
28329 : #else
28330 357 : assert (p_fileList_ptr != NULL);
28331 357 : p_fileList_ptr->get_listOfFiles().push_back(&file);
28332 :
28333 : // DQ (1/25/2010): Set the parent of the file to point to the list (this is a change and may break some code).
28334 : // But it is consistant within ROSE for how we handle list objects in the IR.
28335 357 : file.set_parent(p_fileList_ptr);
28336 :
28337 : // mprintf ("Exiting since this is not finished. \n");
28338 : // assert(false);
28339 : #endif
28340 :
28341 357 : assert (numberOfFiles() > 0);
28342 357 : }
28343 :
28344 : SgFilePtrList
28345 3 : SgProject::get_files() const
28346 : {
28347 3 : return p_fileList_ptr->get_listOfFiles();
28348 : }
28349 :
28350 : SgFilePtrList
28351 0 : SgProject::get_files_with_errors() const
28352 : {
28353 0 : SgFilePtrList files_with_errors;
28354 :
28355 0 : SgFilePtrList files = p_fileList_ptr->get_listOfFiles();
28356 0 : SgFilePtrList::iterator it;
28357 0 : for (it = files.begin(); it != files.end(); ++it)
28358 : {
28359 0 : SgFile* file = *it;
28360 0 : bool has_errors =
28361 0 : file->get_javacErrorCode() != 0 ||
28362 0 : file->get_frontendErrorCode() != 0 ||
28363 0 : file->get_midendErrorCode() != 0 ||
28364 0 : file->get_unparserErrorCode() != 0 ||
28365 0 : file->get_backendCompilerErrorCode() != 0;
28366 0 : if (has_errors)
28367 : {
28368 0 : files_with_errors.push_back(file);
28369 : }
28370 : }
28371 :
28372 0 : return files_with_errors;
28373 : }
28374 :
28375 : SgFilePtrList
28376 0 : SgProject::get_files_without_errors() const
28377 : {
28378 0 : SgFilePtrList files_without_errors;
28379 :
28380 0 : SgFilePtrList files = p_fileList_ptr->get_listOfFiles();
28381 0 : SgFilePtrList::iterator it;
28382 0 : for (it = files.begin(); it != files.end(); ++it)
28383 : {
28384 0 : SgFile* file = *it;
28385 0 : bool has_no_errors =
28386 0 : file->get_javacErrorCode() == 0 &&
28387 0 : file->get_frontendErrorCode() == 0 &&
28388 0 : file->get_midendErrorCode() == 0 &&
28389 0 : file->get_unparserErrorCode() == 0 &&
28390 0 : file->get_backendCompilerErrorCode() == 0;
28391 0 : if (has_no_errors)
28392 : {
28393 0 : files_without_errors.push_back(file);
28394 : }
28395 : }
28396 :
28397 0 : return files_without_errors;
28398 : }
28399 :
28400 : void
28401 353 : SgProject::unparse ( UnparseFormatHelp *unparseFormatHelp, UnparseDelegate* unparseDelegate )
28402 : {
28403 : #if 0
28404 : for (int i = 0; i < numberOfFiles(); i++)
28405 : {
28406 : // mprintf ("In SgProject::unparse(): Unparsing file #%d \n",i);
28407 : SgFile & file = get_file(i);
28408 :
28409 : // DQ (3/18/2006): Added support for user defined control of code generation
28410 : file.unparse(unparseFormatHelp,unparseDelegate);
28411 : }
28412 : #else
28413 : // DQ (1/24/2010): refactored code to call existing function.
28414 353 : extern void unparseProject( SgProject* project, UnparseFormatHelp *unparseFormatHelp /* = NULL */, UnparseDelegate* unparseDelegate/* = NULL */);
28415 353 : unparseProject( this, unparseFormatHelp, unparseDelegate);
28416 : #endif
28417 353 : }
28418 :
28419 : // Moved to sage_support.cpp: int SgProject::compileOutput( const std::string& compilerName )
28420 :
28421 : void
28422 0 : SgProject::resetSourcePositionToGeneratedCode ( UnparseFormatHelp *unparseFormatHelp )
28423 : {
28424 0 : for (int i = 0; i < numberOfFiles(); i++)
28425 : {
28426 0 : SgFile & file = get_file(i);
28427 0 : file.resetSourcePositionToGeneratedCode( unparseFormatHelp );
28428 : }
28429 0 : }
28430 :
28431 :
28432 : #if 0
28433 : // DQ (9/2/2008): Removed this redundant function
28434 : // DQ (10/16/2005): I would like to get rid of this function since it is redundant with other
28435 : // automatically generated functions containing list of source files (with and without paths).
28436 : Rose_STL_Container<string>
28437 : SgProject::getFileNames() const
28438 : {
28439 : Rose_STL_Container<string> nameList;
28440 : for (int i = 0; i < numberOfFiles(); i++)
28441 : {
28442 : SgFile & file = get_file(i);
28443 : nameList.push_back(std::string(file.getFileName()));
28444 : }
28445 :
28446 : return nameList;
28447 : }
28448 : #endif
28449 :
28450 : #if 1
28451 : // DQ (9/2/2008): Readded this function with a clearer name, since it is different from the
28452 : // list of filenames that appear on the command line; these are resolved to be absolute paths.
28453 : Rose_STL_Container<string>
28454 330 : SgProject::getAbsolutePathFileNames() const
28455 : {
28456 330 : Rose_STL_Container<string> nameList;
28457 663 : for (int i = 0; i < numberOfFiles(); i++)
28458 : {
28459 333 : SgFile & file = get_file(i);
28460 666 : nameList.push_back(std::string(file.getFileName()));
28461 : }
28462 :
28463 330 : return nameList;
28464 : }
28465 : #endif
28466 :
28467 : // DQ (1/5/2008): I think this could be an automatically generated function!
28468 : // Unless the point is that it should not trigger a transformation to be recorded on the AST.
28469 : int
28470 6510810 : SgProject::get_verbose (void)
28471 : {
28472 6510810 : return p_verbose;
28473 : }
28474 :
28475 : // DQ (1/5/2008): I think this could be an automatically generated function!
28476 : // Unless the point is that it should not trigger a transformation to be recorded on the AST.
28477 : void
28478 316 : SgProject::set_verbose ( int x )
28479 : {
28480 316 : p_verbose = x;
28481 316 : }
28482 :
28483 : // DQ (4/4/2020): Adding support for unparse headers feature specific diagnostics.
28484 : // DQ (1/5/2008): I think this could be an automatically generated function!
28485 : // Unless the point is that it should not trigger a transformation to be recorded on the AST.
28486 : int
28487 2740110 : SgProject::get_unparseHeaderFilesDebug (void)
28488 : {
28489 2740110 : return p_unparseHeaderFilesDebug;
28490 : }
28491 :
28492 : // DQ (1/5/2008): I think this could be an automatically generated function!
28493 : // Unless the point is that it should not trigger a transformation to be recorded on the AST.
28494 : void
28495 0 : SgProject::set_unparseHeaderFilesDebug ( int x )
28496 : {
28497 0 : p_unparseHeaderFilesDebug = x;
28498 0 : }
28499 :
28500 :
28501 :
28502 : bool
28503 0 : SgProject::get_skip_translation_from_edg_ast_to_rose_ast (void) const
28504 : {
28505 : // look at how the files are set
28506 0 : bool returnSkipTranslation = (numberOfFiles() > 0) ? true : false;
28507 0 : for (int i = 0; i < numberOfFiles(); i++)
28508 : {
28509 0 : SgFile & file = get_file(i);
28510 0 : returnSkipTranslation = returnSkipTranslation && (bool) file.get_skip_translation_from_edg_ast_to_rose_ast();
28511 : }
28512 0 : return returnSkipTranslation;
28513 : }
28514 :
28515 : bool
28516 0 : SgProject::get_skip_transformation (void) const
28517 : {
28518 : // look at how the files are set
28519 0 : bool returnSkipTransformation = (numberOfFiles() > 0) ? true : false;
28520 0 : for (int i = 0; i < numberOfFiles(); i++)
28521 : {
28522 0 : SgFile & file = get_file(i);
28523 0 : returnSkipTransformation = returnSkipTransformation && (bool) file.get_skip_transformation();
28524 : }
28525 0 : return returnSkipTransformation;
28526 : }
28527 :
28528 : bool
28529 0 : SgProject::get_skip_unparse (void) const
28530 : {
28531 : // look at how the files are set
28532 0 : bool returnSkipUnparse = (numberOfFiles() > 0) ? true : false;
28533 0 : for (int i = 0; i < numberOfFiles(); i++)
28534 : {
28535 0 : SgFile & file = get_file(i);
28536 0 : returnSkipUnparse = returnSkipUnparse && (bool) file.get_skip_unparse();
28537 : }
28538 0 : return returnSkipUnparse;
28539 : }
28540 :
28541 : bool
28542 698 : SgProject::get_useBackendOnly (void) const
28543 : {
28544 : // look at how the files are set
28545 698 : bool returnUseBackendOnly = (numberOfFiles() > 0) ? true : false;
28546 1398 : for (int i = 0; i < numberOfFiles(); i++)
28547 : {
28548 700 : SgFile & file = get_file(i);
28549 1398 : returnUseBackendOnly = returnUseBackendOnly && (bool) file.get_useBackendOnly();
28550 : }
28551 698 : return returnUseBackendOnly;
28552 : }
28553 :
28554 : // DQ (4/6/2010): Added to support parsing only option.
28555 : bool
28556 353 : SgProject::get_exit_after_parser(void) const
28557 : {
28558 : // look at how the files are set
28559 353 : bool returnExitAfterParse = (numberOfFiles() > 0) ? true : false;
28560 707 : for (int i = 0; i < numberOfFiles(); i++)
28561 : {
28562 354 : SgFile & file = get_file(i);
28563 707 : returnExitAfterParse = returnExitAfterParse && (bool) file.get_exit_after_parser();
28564 : }
28565 353 : return returnExitAfterParse;
28566 : }
28567 :
28568 : bool
28569 2 : SgProject::get_skipfinalCompileStep (void) const
28570 : {
28571 : // look at how the files are set
28572 2 : bool returnSkipFinalCompileStep = (numberOfFiles() > 0) ? true : false;
28573 4 : for (int i = 0; i < numberOfFiles(); i++)
28574 : {
28575 2 : SgFile & file = get_file(i);
28576 2 : returnSkipFinalCompileStep = returnSkipFinalCompileStep && (bool) file.get_skipfinalCompileStep();
28577 : }
28578 2 : return returnSkipFinalCompileStep;
28579 : }
28580 :
28581 : void
28582 354 : SgProject::set_C_only (bool value)
28583 : {
28584 354 : ROSE_ASSERT(this != NULL);
28585 354 : p_C_only = value;
28586 354 : }
28587 :
28588 : void
28589 354 : SgProject::set_Cxx_only (bool value)
28590 : {
28591 354 : ROSE_ASSERT(this != NULL);
28592 354 : p_Cxx_only = value;
28593 354 : }
28594 :
28595 : void
28596 0 : SgProject::set_Fortran_only (bool value)
28597 : {
28598 0 : ROSE_ASSERT(this != NULL);
28599 0 : p_Fortran_only = value;
28600 0 : }
28601 :
28602 : bool
28603 357 : SgProject::get_C_only (void) const
28604 : {
28605 357 : bool result = p_C_only;
28606 360 : for (int i = 0; i < numberOfFiles(); i++)
28607 : {
28608 3 : SgFile & file = get_file(i);
28609 4 : result = result || (bool) file.get_C_only();
28610 : }
28611 357 : return result;
28612 : }
28613 :
28614 : bool
28615 0 : SgProject::get_C89_only (void) const
28616 : {
28617 0 : bool result = false;
28618 0 : for (int i = 0; i < numberOfFiles(); i++)
28619 : {
28620 0 : SgFile & file = get_file(i);
28621 0 : result = result || (bool) file.get_C89_only();
28622 : }
28623 0 : return result;
28624 : }
28625 :
28626 : bool
28627 0 : SgProject::get_C89_gnu_only (void) const
28628 : {
28629 0 : bool result = false;
28630 0 : for (int i = 0; i < numberOfFiles(); i++)
28631 : {
28632 0 : SgFile & file = get_file(i);
28633 0 : result = result || (bool) file.get_C89_gnu_only();
28634 : }
28635 0 : return result;
28636 : }
28637 :
28638 : bool
28639 0 : SgProject::get_C90_only (void) const
28640 : {
28641 0 : bool result = false;
28642 0 : for (int i = 0; i < numberOfFiles(); i++)
28643 : {
28644 0 : SgFile & file = get_file(i);
28645 0 : result = result || (bool) file.get_C90_only();
28646 : }
28647 0 : return result;
28648 : }
28649 :
28650 : bool
28651 0 : SgProject::get_C90_gnu_only (void) const
28652 : {
28653 0 : bool result = false;
28654 0 : for (int i = 0; i < numberOfFiles(); i++)
28655 : {
28656 0 : SgFile & file = get_file(i);
28657 0 : result = result || (bool) file.get_C90_gnu_only();
28658 : }
28659 0 : return result;
28660 : }
28661 :
28662 :
28663 : bool
28664 2 : SgProject::get_C99_only (void) const
28665 : {
28666 2 : bool result = false;
28667 4 : for (int i = 0; i < numberOfFiles(); i++)
28668 : {
28669 2 : SgFile & file = get_file(i);
28670 2 : result = result || (bool) file.get_C99_only();
28671 : }
28672 2 : return result;
28673 : }
28674 :
28675 : bool
28676 0 : SgProject::get_C99_gnu_only (void) const
28677 : {
28678 0 : bool result = false;
28679 0 : for (int i = 0; i < numberOfFiles(); i++)
28680 : {
28681 0 : SgFile & file = get_file(i);
28682 0 : result = result || (bool) file.get_C99_gnu_only();
28683 : }
28684 0 : return result;
28685 : }
28686 :
28687 : bool
28688 0 : SgProject::get_C11_only (void) const
28689 : {
28690 0 : bool result = false;
28691 0 : for (int i = 0; i < numberOfFiles(); i++)
28692 : {
28693 0 : SgFile & file = get_file(i);
28694 0 : result = result || (bool) file.get_C11_only();
28695 : }
28696 0 : return result;
28697 : }
28698 :
28699 : bool
28700 0 : SgProject::get_C11_gnu_only (void) const
28701 : {
28702 0 : bool result = false;
28703 0 : for (int i = 0; i < numberOfFiles(); i++)
28704 : {
28705 0 : SgFile & file = get_file(i);
28706 0 : result = result || (bool) file.get_C11_gnu_only();
28707 : }
28708 0 : return result;
28709 : }
28710 :
28711 : bool
28712 0 : SgProject::get_C14_only (void) const
28713 : {
28714 0 : bool result = false;
28715 0 : for (int i = 0; i < numberOfFiles(); i++)
28716 : {
28717 0 : SgFile & file = get_file(i);
28718 0 : result = result || (bool) file.get_C14_only();
28719 : }
28720 0 : return result;
28721 : }
28722 :
28723 : bool
28724 0 : SgProject::get_C14_gnu_only (void) const
28725 : {
28726 0 : bool result = false;
28727 0 : for (int i = 0; i < numberOfFiles(); i++)
28728 : {
28729 0 : SgFile & file = get_file(i);
28730 0 : result = result || (bool) file.get_C14_gnu_only();
28731 : }
28732 0 : return result;
28733 : }
28734 :
28735 : bool
28736 354 : SgProject::get_Cxx_only (void) const
28737 : {
28738 354 : bool result = p_Cxx_only;
28739 354 : for (int i = 0; i < numberOfFiles(); i++)
28740 : {
28741 0 : SgFile & file = get_file(i);
28742 0 : result = result || (bool) file.get_Cxx_only();
28743 : }
28744 354 : return result;
28745 : }
28746 :
28747 : bool
28748 0 : SgProject::get_Cxx98_only (void) const
28749 : {
28750 0 : bool result = false;
28751 0 : for (int i = 0; i < numberOfFiles(); i++)
28752 : {
28753 0 : SgFile & file = get_file(i);
28754 0 : result = result || (bool) file.get_Cxx98_only();
28755 : }
28756 0 : return result;
28757 : }
28758 :
28759 : bool
28760 0 : SgProject::get_Cxx98_gnu_only (void) const
28761 : {
28762 0 : bool result = false;
28763 0 : for (int i = 0; i < numberOfFiles(); i++)
28764 : {
28765 0 : SgFile & file = get_file(i);
28766 0 : result = result || (bool) file.get_Cxx98_gnu_only();
28767 : }
28768 0 : return result;
28769 : }
28770 :
28771 : bool
28772 0 : SgProject::get_Cxx03_only (void) const
28773 : {
28774 0 : bool result = false;
28775 0 : for (int i = 0; i < numberOfFiles(); i++)
28776 : {
28777 0 : SgFile & file = get_file(i);
28778 0 : result = result || (bool) file.get_Cxx03_only();
28779 : }
28780 0 : return result;
28781 : }
28782 :
28783 : bool
28784 0 : SgProject::get_Cxx03_gnu_only (void) const
28785 : {
28786 0 : bool result = false;
28787 0 : for (int i = 0; i < numberOfFiles(); i++)
28788 : {
28789 0 : SgFile & file = get_file(i);
28790 0 : result = result || (bool) file.get_Cxx03_gnu_only();
28791 : }
28792 0 : return result;
28793 : }
28794 :
28795 : bool
28796 0 : SgProject::get_Cxx11_only (void) const
28797 : {
28798 0 : bool result = false;
28799 0 : for (int i = 0; i < numberOfFiles(); i++)
28800 : {
28801 0 : SgFile & file = get_file(i);
28802 0 : result = result || (bool) file.get_Cxx11_only();
28803 : }
28804 0 : return result;
28805 : }
28806 :
28807 : bool
28808 0 : SgProject::get_Cxx11_gnu_only (void) const
28809 : {
28810 0 : bool result = false;
28811 0 : for (int i = 0; i < numberOfFiles(); i++)
28812 : {
28813 0 : SgFile & file = get_file(i);
28814 0 : result = result || (bool) file.get_Cxx11_gnu_only();
28815 : }
28816 0 : return result;
28817 : }
28818 :
28819 : bool
28820 0 : SgProject::get_Cxx14_only (void) const
28821 : {
28822 0 : bool result = false;
28823 0 : for (int i = 0; i < numberOfFiles(); i++)
28824 : {
28825 0 : SgFile & file = get_file(i);
28826 0 : result = result || (bool) file.get_Cxx14_only();
28827 : }
28828 0 : return result;
28829 : }
28830 :
28831 : bool
28832 0 : SgProject::get_Cxx14_gnu_only (void) const
28833 : {
28834 0 : bool result = false;
28835 0 : for (int i = 0; i < numberOfFiles(); i++)
28836 : {
28837 0 : SgFile & file = get_file(i);
28838 0 : result = result || (bool) file.get_Cxx14_gnu_only();
28839 : }
28840 0 : return result;
28841 : }
28842 :
28843 : bool
28844 0 : SgProject::get_Cxx17_only (void) const
28845 : {
28846 0 : bool result = false;
28847 0 : for (int i = 0; i < numberOfFiles(); i++)
28848 : {
28849 0 : SgFile & file = get_file(i);
28850 0 : result = result || (bool) file.get_Cxx17_only();
28851 : }
28852 0 : return result;
28853 : }
28854 :
28855 : bool
28856 0 : SgProject::get_Cxx17_gnu_only (void) const
28857 : {
28858 0 : bool result = false;
28859 0 : for (int i = 0; i < numberOfFiles(); i++)
28860 : {
28861 0 : SgFile & file = get_file(i);
28862 0 : result = result || (bool) file.get_Cxx17_gnu_only();
28863 : }
28864 0 : return result;
28865 : }
28866 :
28867 : bool
28868 654 : SgProject::get_Fortran_only (void) const
28869 : {
28870 654 : bool result = p_Fortran_only;
28871 1314 : for (int i = 0; i < numberOfFiles(); i++)
28872 : {
28873 660 : SgFile & file = get_file(i);
28874 733 : result = result || (bool) file.get_Fortran_only();
28875 : }
28876 654 : return result;
28877 : }
28878 :
28879 : bool
28880 0 : SgProject::get_F77_only (void) const
28881 : {
28882 0 : bool result = false;
28883 0 : for (int i = 0; i < numberOfFiles(); i++)
28884 : {
28885 0 : SgFile & file = get_file(i);
28886 0 : result = result || (bool) file.get_F77_only();
28887 : }
28888 0 : return result;
28889 : }
28890 :
28891 : bool
28892 0 : SgProject::get_F90_only (void) const
28893 : {
28894 0 : bool result = false;
28895 0 : for (int i = 0; i < numberOfFiles(); i++)
28896 : {
28897 0 : SgFile & file = get_file(i);
28898 0 : result = result || (bool) file.get_F90_only();
28899 : }
28900 0 : return result;
28901 : }
28902 :
28903 : bool
28904 0 : SgProject::get_F95_only (void) const
28905 : {
28906 0 : bool result = false;
28907 0 : for (int i = 0; i < numberOfFiles(); i++)
28908 : {
28909 0 : SgFile & file = get_file(i);
28910 0 : result = result || (bool) file.get_F95_only();
28911 : }
28912 0 : return result;
28913 : }
28914 :
28915 : bool
28916 0 : SgProject::get_F2003_only (void) const
28917 : {
28918 0 : bool result = false;
28919 0 : for (int i = 0; i < numberOfFiles(); i++)
28920 : {
28921 0 : SgFile & file = get_file(i);
28922 0 : result = result || (bool) file.get_F2003_only();
28923 : }
28924 0 : return result;
28925 : }
28926 :
28927 : bool
28928 0 : SgProject::get_F2008_only (void) const
28929 : {
28930 0 : bool result = false;
28931 0 : for (int i = 0; i < numberOfFiles(); i++)
28932 : {
28933 0 : SgFile & file = get_file(i);
28934 0 : result = result || (bool) file.get_F2008_only();
28935 : }
28936 0 : return result;
28937 : }
28938 :
28939 : bool
28940 0 : SgProject::get_F2018_only (void) const
28941 : {
28942 0 : bool result = false;
28943 0 : for (int i = 0; i < numberOfFiles(); i++)
28944 : {
28945 0 : SgFile & file = get_file(i);
28946 0 : result = result || (bool) file.get_F2018_only();
28947 : }
28948 0 : return result;
28949 : }
28950 :
28951 : bool
28952 0 : SgProject::get_CoArrayFortran_only (void) const
28953 : {
28954 : // look at how the files are set
28955 0 : bool result = false;
28956 0 : for (int i = 0; i < numberOfFiles(); i++)
28957 : {
28958 0 : SgFile & file = get_file(i);
28959 0 : result = result || (bool) file.get_CoArrayFortran_only();
28960 : }
28961 0 : return result;
28962 : }
28963 :
28964 : void
28965 0 : SgProject::set_Java_classpath (std::list<std::string> param)
28966 : {
28967 0 : p_Java_classpath = param;
28968 0 : }
28969 :
28970 : std::list<std::string>
28971 37 : SgProject::get_Java_classpath (void) const
28972 : {
28973 37 : return p_Java_classpath;
28974 : }
28975 :
28976 : void
28977 0 : SgProject::set_Java_sourcepath (std::list<std::string> param)
28978 : {
28979 0 : p_Java_sourcepath = param;
28980 0 : }
28981 :
28982 : std::list<std::string>
28983 0 : SgProject::get_Java_sourcepath (void) const
28984 : {
28985 0 : return p_Java_sourcepath;
28986 : }
28987 :
28988 : void
28989 0 : SgProject::set_Java_destdir (std::string param)
28990 : {
28991 0 : p_Java_destdir = param;
28992 0 : }
28993 :
28994 : std::string
28995 0 : SgProject::get_Java_destdir (void) const
28996 : {
28997 0 : if (p_Java_destdir == "") {
28998 0 : return Rose::getWorkingDirectory();
28999 : }
29000 0 : return p_Java_destdir;
29001 : }
29002 :
29003 : void
29004 0 : SgProject::set_Java_source_destdir (std::string param)
29005 : {
29006 0 : p_Java_source_destdir = param;
29007 0 : }
29008 :
29009 : std::string
29010 0 : SgProject::get_Java_source_destdir (void) const
29011 : {
29012 0 : if (p_Java_source_destdir == "") {
29013 0 : return Rose::getWorkingDirectory();
29014 : }
29015 0 : return p_Java_source_destdir;
29016 : }
29017 :
29018 :
29019 : void
29020 1 : SgProject::skipfinalCompileStep(bool value)
29021 : {
29022 2 : for (int i = 0; i < numberOfFiles(); i++)
29023 : {
29024 1 : get_file(i).set_skipfinalCompileStep(value);
29025 : }
29026 1 : }
29027 :
29028 :
29029 : int
29030 326 : SgProject::get_detect_dangling_pointers(void) const
29031 : {
29032 : // look at how the files are set
29033 326 : int result = 0;
29034 655 : for (int i = 0; i < numberOfFiles(); i++)
29035 : {
29036 329 : SgFile & file = get_file(i);
29037 329 : result = result | file.get_detect_dangling_pointers();
29038 : }
29039 :
29040 326 : return result;
29041 : }
29042 :
29043 :
29044 : void
29045 0 : SgProject::display ( const std::string & label ) const
29046 : {
29047 : // DQ (4/4/2020): Fixing this to not use the mprintf, since when called by the user it should output data.
29048 : // I think this wasa a bit over zellous use of "mprintf" via search and replace.
29049 :
29050 0 : printf ("In SgProject::display(%s) \n",label.c_str());
29051 :
29052 0 : printf (" p_verbose = %d \n",p_verbose);
29053 0 : printf (" p_unparseHeaderFilesDebug = %d \n",p_unparseHeaderFilesDebug);
29054 :
29055 0 : printf (" p_outputFileName = %s \n",p_outputFileName.c_str());
29056 :
29057 0 : printf (" p_sourceFileNameList.size() = %" PRIuPTR " \n", p_sourceFileNameList.size());
29058 0 : printf (" p_sourceFileNameList = \n %s \n",Rose::StringUtility::listToString(p_sourceFileNameList).c_str());
29059 :
29060 0 : printf (" p_objectFileNameList.size() = %" PRIuPTR " \n", p_objectFileNameList.size());
29061 0 : printf (" p_objectFileNameList = \n %s \n",Rose::StringUtility::listToString(p_objectFileNameList).c_str());
29062 :
29063 0 : printf (" p_libraryFileList.size() = %" PRIuPTR " \n", p_libraryFileList.size());
29064 0 : printf (" p_libraryFileList = \n %s \n",Rose::StringUtility::listToString(p_libraryFileList).c_str());
29065 :
29066 0 : printf (" p_librarySpecifierList.size() = %" PRIuPTR " \n", p_librarySpecifierList.size());
29067 0 : printf (" p_librarySpecifierList = \n %s \n",Rose::StringUtility::listToString(p_librarySpecifierList).c_str());
29068 :
29069 0 : printf (" p_libraryDirectorySpecifierList.size() = %" PRIuPTR " \n", p_libraryDirectorySpecifierList.size());
29070 0 : printf (" p_libraryDirectorySpecifierList = \n %s \n",Rose::StringUtility::listToString(p_libraryDirectorySpecifierList).c_str());
29071 :
29072 0 : printf (" p_includeDirectorySpecifierList.size() = %" PRIuPTR " \n", p_includeDirectorySpecifierList.size());
29073 0 : printf (" p_includeDirectorySpecifierList = \n %s \n",Rose::StringUtility::listToString(p_includeDirectorySpecifierList).c_str());
29074 :
29075 0 : printf (" p_compileOnly = %s \n",(p_compileOnly == true) ? "true" : "false");
29076 0 : printf (" p_prelink = %s \n",(p_prelink == true) ? "true" : "false");
29077 :
29078 0 : printf (" p_template_instantiation_mode = %d \n",p_template_instantiation_mode);
29079 :
29080 : // DQ (7/3/2020): I think these data members have been removed by Tristan, not a problem.
29081 : // printf (" p_astMerge = %s \n",(p_astMerge == true) ? "true" : "false");
29082 : // printf (" p_astMergeCommandFile = %s \n",p_astMergeCommandFile.c_str());
29083 :
29084 0 : printf (" p_ast_merge = %s \n",(p_ast_merge == true) ? "true" : "false");
29085 0 : printf (" p_projectSpecificDatabaseFile = %s \n",p_projectSpecificDatabaseFile.c_str());
29086 0 : printf (" p_compilationPerformanceFile = %s \n",p_compilationPerformanceFile.c_str());
29087 :
29088 : // DQ (1/16/2008): This is part of a ROSE supported mechanism for the
29089 : // specification of exclude/include paths/files for interpretation by
29090 : // the ROSE translator.
29091 : // printf (" p_lookForIncludePaths = %s \n",(p_lookForIncludePaths == true) ? "true" : "false");
29092 : // printf (" p_lookForExcludePaths = %s \n",(p_lookForExcludePaths == true) ? "true" : "false");
29093 :
29094 0 : printf (" p_includePathList.size() = %" PRIuPTR " \n", p_includePathList.size());
29095 0 : printf (" p_includePathList = \n %s \n",Rose::StringUtility::listToString(p_includePathList).c_str());
29096 :
29097 0 : printf (" p_excludePathList.size() = %" PRIuPTR " \n", p_excludePathList.size());
29098 0 : printf (" p_excludePathList = \n %s \n",Rose::StringUtility::listToString(p_excludePathList).c_str());
29099 :
29100 0 : printf (" p_includeFileList.size() = %" PRIuPTR " \n", p_includeFileList.size());
29101 0 : printf (" p_includeFileList = \n %s \n",Rose::StringUtility::listToString(p_includeFileList).c_str());
29102 :
29103 0 : printf (" p_excludeFileList.size() = %" PRIuPTR " \n", p_excludeFileList.size());
29104 0 : printf (" p_excludeFileList = \n %s \n",Rose::StringUtility::listToString(p_excludeFileList).c_str());
29105 :
29106 0 : printf (" p_preincludeFileList.size() = %" PRIuPTR " \n", p_preincludeFileList.size());
29107 0 : printf (" p_preincludeFileList = \n %s \n",Rose::StringUtility::listToString(p_preincludeFileList).c_str());
29108 :
29109 0 : printf (" p_preincludeDirectoryList.size() = %" PRIuPTR " \n", p_preincludeDirectoryList.size());
29110 0 : printf (" p_preincludeDirectoryList = \n %s \n",Rose::StringUtility::listToString(p_preincludeDirectoryList).c_str());
29111 :
29112 : // DQ (2/4/2009): Moved from SgFile to SgProject.
29113 0 : printf (" p_binary_only() = %s \n",(p_binary_only == true) ? "true" : "false");
29114 :
29115 : // DQ (9/15/2013): Added debugging support for a previously missed data member.
29116 0 : printf (" p_frontendConstantFolding = %s \n",(p_frontendConstantFolding == true) ? "true" : "false");
29117 :
29118 : // DQ (9/15/2013): Added debugging support for a new data member.
29119 0 : printf (" p_unparse_in_same_directory_as_input_file = %s \n",(p_unparse_in_same_directory_as_input_file == true) ? "true" : "false");
29120 :
29121 : // DQ (3/19/2014): This option causes the output of source code to an existing file to be an error.
29122 0 : printf (" p_noclobber_output_file = %s \n",(p_noclobber_output_file == true) ? "true" : "false");
29123 :
29124 : // DQ (3/19/2014): This option causes the output of source code to an existing file to be an error if it results in a different file.
29125 0 : printf (" p_noclobber_if_different_output_file = %s \n",(p_noclobber_if_different_output_file == true) ? "true" : "false");
29126 :
29127 : // Pei-Hung (8/6/2014): This option appends PID into the output name to avoid file collision in parallel compilation.
29128 0 : printf (" p_appendPID = %s \n",(p_appendPID == true) ? "true" : "false");
29129 :
29130 0 : printf ("In this project: numberOfFiles() = %d \n",numberOfFiles());
29131 0 : for (int i = 0; i < numberOfFiles(); i++)
29132 : {
29133 0 : SgFile & file = get_file(i);
29134 0 : file.display("called from SgProject::display()");
29135 : }
29136 0 : }
29137 :
29138 :
29139 : // Moved to sage_support.cpp: int SgProject::link ( std::string linkerName )
29140 : // Moved to sage_support.cpp: int SgProject::link ( const std::vector<std::string>& argv, std::string linkerName )
29141 :
29142 : const SgStringList &
29143 0 : SgProject::get_includePathList () const
29144 : {
29145 0 : assert (this != NULL);
29146 0 : return p_includePathList;
29147 : }
29148 :
29149 : SgStringList &
29150 0 : SgProject::get_includePathList ()
29151 : {
29152 0 : assert (this != NULL);
29153 0 : return p_includePathList;
29154 : }
29155 :
29156 : void
29157 0 : SgProject::set_includePathList ( const SgStringList & includePathList )
29158 : {
29159 0 : assert (this != NULL);
29160 0 : set_isModified(true);
29161 :
29162 0 : p_includePathList = includePathList;
29163 0 : }
29164 :
29165 :
29166 : const SgStringList &
29167 0 : SgProject::get_excludePathList () const
29168 : {
29169 0 : assert (this != NULL);
29170 0 : return p_excludePathList;
29171 : }
29172 :
29173 : SgStringList &
29174 0 : SgProject::get_excludePathList ()
29175 : {
29176 0 : assert (this != NULL);
29177 0 : return p_excludePathList;
29178 : }
29179 :
29180 : void
29181 0 : SgProject::set_excludePathList ( const SgStringList & excludePathList )
29182 : {
29183 0 : assert (this != NULL);
29184 0 : set_isModified(true);
29185 :
29186 0 : p_excludePathList = excludePathList;
29187 0 : }
29188 :
29189 : const SgStringList &
29190 0 : SgProject::get_includeFileList () const
29191 : {
29192 0 : assert (this != NULL);
29193 0 : return p_includeFileList;
29194 : }
29195 :
29196 : SgStringList &
29197 0 : SgProject::get_includeFileList ()
29198 : {
29199 0 : assert (this != NULL);
29200 0 : return p_includeFileList;
29201 : }
29202 :
29203 : void
29204 0 : SgProject::set_includeFileList ( const SgStringList & includeFileList )
29205 : {
29206 0 : assert (this != NULL);
29207 0 : set_isModified(true);
29208 :
29209 0 : p_includeFileList = includeFileList;
29210 0 : }
29211 :
29212 :
29213 : const SgStringList &
29214 0 : SgProject::get_excludeFileList () const
29215 : {
29216 0 : assert (this != NULL);
29217 0 : return p_excludeFileList;
29218 : }
29219 :
29220 : SgStringList &
29221 0 : SgProject::get_excludeFileList ()
29222 : {
29223 0 : assert (this != NULL);
29224 0 : return p_excludeFileList;
29225 : }
29226 :
29227 : void
29228 0 : SgProject::set_excludeFileList ( const SgStringList & excludeFileList )
29229 : {
29230 0 : assert (this != NULL);
29231 0 : set_isModified(true);
29232 :
29233 0 : p_excludeFileList = excludeFileList;
29234 0 : }
29235 :
29236 : bool
29237 0 : SgProject::get_unparse_tokens (void) const
29238 : {
29239 : // DQ (8/3/2018): Added support for evaluation of options at the project level (which are normally associated with files).
29240 :
29241 : // look at how the files are set
29242 0 : bool result = false;
29243 0 : for (int i = 0; i < numberOfFiles(); i++)
29244 : {
29245 0 : SgFile & file = get_file(i);
29246 0 : result = result || (bool) file.get_unparse_tokens();
29247 : }
29248 :
29249 0 : return result;
29250 : }
29251 :
29252 :
29253 :
29254 :
29255 : // End of memberFunctionString
29256 : // Start of memberFunctionString
29257 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
29258 :
29259 : // *** COMMON CODE SECTION BEGINS HERE ***
29260 :
29261 : #if 0
29262 : int
29263 : SgProject::getVariant() const
29264 : {
29265 : // This function is used in ROSE while "variant()" is used in SAGE
29266 : assert(this != NULL);
29267 : return variant();
29268 : }
29269 : #endif
29270 :
29271 : // This function is used in ROSE in treeTraversal code
29272 : // eventually replaces getVariant() and variant()
29273 : // though after variant() has been removed for a while we will
29274 : // want to change the name of variantT() back to variant()
29275 : // (since the "T" was ment to stand for temporary).
29276 : // When this happens the variantT() will be depricated.
29277 : VariantT
29278 13872400 : SgProject::variantT() const
29279 : {
29280 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
29281 13872400 : ROSE_ASSERT(this != NULL);
29282 13872400 : return V_SgProject;
29283 : }
29284 :
29285 : #if 0
29286 : int
29287 : SgProject::variant() const
29288 : {
29289 : // This function is used in SAGE
29290 : ROSE_ASSERT(this != NULL);
29291 : return ProjectTag;
29292 : }
29293 : #endif
29294 :
29295 : ROSE_DLL_API const char*
29296 3187 : SgProject::sage_class_name() const
29297 : {
29298 3187 : ROSE_ASSERT(this != NULL);
29299 3187 : return "SgProject";
29300 : }
29301 :
29302 : std::string
29303 333 : SgProject::class_name() const
29304 : {
29305 333 : ROSE_ASSERT(this != NULL);
29306 333 : return "SgProject";
29307 : }
29308 :
29309 : // DQ (11/26/2005): Support for visitor pattern mechanims
29310 : // (inferior to ROSE traversal mechanism, experimental).
29311 : void
29312 194 : SgProject::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
29313 : {
29314 194 : ROSE_ASSERT(this != NULL);
29315 194 : visitor.visit(this);
29316 194 : }
29317 :
29318 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
29319 0 : void SgProject::accept (ROSE_VisitorPattern & visitor) {
29320 0 : ROSE_ASSERT(this != NULL);
29321 0 : visitor.visit(this);
29322 0 : }
29323 :
29324 : SgProject*
29325 0 : SgProject::addRegExpAttribute(std::string s, AstRegExAttribute* a)
29326 : {
29327 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
29328 : // This function is currently only supported for the AST used the represent Binary executables.
29329 : if (0 /* isSgAsmNode(this) != NULL */)
29330 : {
29331 : // Support for regex specification.
29332 : std::string prefixCode = "REGEX:";
29333 : addNewAttribute(prefixCode + s,a);
29334 : }
29335 : #endif
29336 :
29337 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
29338 0 : return this;
29339 : }
29340 :
29341 : // *** COMMON CODE SECTION ENDS HERE ***
29342 :
29343 :
29344 : // End of memberFunctionString
29345 : // Start of memberFunctionString
29346 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
29347 :
29348 :
29349 : #if 0
29350 : //! Error checking support
29351 : /*! Verifies the following:
29352 : - working getVariant() member function
29353 : - calls base class's error() member function
29354 : Every class has one of these functions.
29355 : */
29356 : bool
29357 : SgProject::error()
29358 : {
29359 : // Put error checking here
29360 :
29361 : ROSE_ASSERT (this != NULL);
29362 : if (getVariant() != ProjectTag)
29363 : {
29364 : printf ("Error in SgProject::error(): SgProject object has a %s variant \n",
29365 : Cxx_GrammarTerminalNames[getVariant()].name);
29366 : // printf ("Error in SgProject::error() \n");
29367 : ROSE_ABORT();
29368 : }
29369 :
29370 : ROSE_ASSERT (getVariant() == ProjectTag);
29371 : return SgSupport::error();
29372 : }
29373 : #endif
29374 :
29375 :
29376 :
29377 : // End of memberFunctionString
29378 :
29379 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
29380 :
29381 14533600 : SgProject* isSgProject ( SgNode* inputDerivedClassPointer )
29382 : {
29383 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
29384 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
29385 : // So to fix this we return NULL directly when the input is NULL and avoid the
29386 : // dynamic_cast in this case. This is likely a performance improvement as well.
29387 : // return dynamic_cast<SgProject*>(inputDerivedClassPointer);
29388 : // Milind Chabbi (8/28/2013): isSgProject uses table-driven castability instead of c++ default dynamic_cast
29389 : // this improves the running time performance by 10-20%.
29390 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgProject*>(inputDerivedClassPointer);
29391 14533600 : return IS_SgProject_FAST_MACRO(inputDerivedClassPointer);
29392 : }
29393 :
29394 : // DQ (11/8/2003): Added version of functions taking const pointer
29395 7525800 : const SgProject* isSgProject ( const SgNode* inputDerivedClassPointer )
29396 : {
29397 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
29398 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
29399 : // So to fix this we return NULL directly when the input is NULL and avoid the
29400 : // dynamic_cast in this case. This is likely a performance improvement as well.
29401 : // return dynamic_cast<const SgProject*>(inputDerivedClassPointer);
29402 : // Milind Chabbi (8/28/2013): isSgProject uses table-driven castability instead of c++ default dynamic_cast
29403 : // this improves the running time performance by 10-20%.
29404 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgProject*>(inputDerivedClassPointer);
29405 7525800 : return IS_SgProject_FAST_MACRO(inputDerivedClassPointer);
29406 : }
29407 :
29408 :
29409 :
29410 : /* #line 29411 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29411 :
29412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
29413 :
29414 : /**
29415 : \brief Generated destructor
29416 :
29417 : This destructor is automatically generated (by ROSETTA). This destructor
29418 : only frees memory of data members associated with the parts of the current IR node which
29419 : are NOT traversed. Those data members that are part of a traversal can be freed using
29420 : a traversal (calling this destructor on all children in a post-order traversal). Such
29421 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
29422 :
29423 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
29424 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
29425 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
29426 :
29427 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
29428 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
29429 : pointers are not yet implemented to call delete on eash pointer in the container.
29430 : (This could be done by derivation from the STL containers to define containers that
29431 : automatically deleted their members.)
29432 :
29433 : */
29434 33 : SgProject::~SgProject () {
29435 7 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
29436 :
29437 7 : if (p_globalScopeAcrossFiles && p_globalScopeAcrossFiles->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_globalScopeAcrossFiles; }
29438 :
29439 : // case: not a listType for fileList_ptr
29440 7 : p_fileList_ptr = NULL; // non list case
29441 : // case: not a listType for frontendErrorCode
29442 7 : p_frontendErrorCode = 0; // non list case
29443 : // case: not a listType for javacErrorCode
29444 7 : p_javacErrorCode = 0; // non list case
29445 : // case: not a listType for ecjErrorCode
29446 7 : p_ecjErrorCode = 0; // non list case
29447 : // case: not a listType for midendErrorCode
29448 7 : p_midendErrorCode = 0; // non list case
29449 : // case: not a listType for backendErrorCode
29450 7 : p_backendErrorCode = 0; // non list case
29451 : // case: not a listType for keep_going
29452 7 : p_keep_going = false; // non list case
29453 : // case: not a listType for unparser__clobber_input_file
29454 7 : p_unparser__clobber_input_file = false; // non list case
29455 : // case: not a listType for outputFileName
29456 7 : p_outputFileName = ""; // non list case
29457 : // case: not a listType for compileOnly
29458 7 : p_compileOnly = false; // non list case
29459 : // case: not a listType for wave
29460 7 : p_wave = false; // non list case
29461 : // case: not a listType for prelink
29462 7 : p_prelink = false; // non list case
29463 : // case: not a listType for template_instantiation_mode
29464 7 : p_template_instantiation_mode = SgProject::e_default; // non list case
29465 : // case: not a listType for ast_merge
29466 7 : p_ast_merge = false; // non list case
29467 : // case: not a listType for projectSpecificDatabaseFile
29468 7 : p_projectSpecificDatabaseFile = ""; // non list case
29469 : // case: not a listType for C_PreprocessorOnly
29470 7 : p_C_PreprocessorOnly = false; // non list case
29471 : // case: not a listType for attributeMechanism
29472 7 : p_attributeMechanism = NULL; // non list case
29473 : // case: not a listType for compilationPerformanceFile
29474 7 : p_compilationPerformanceFile = ""; // non list case
29475 : // case: not a listType for binary_only
29476 7 : p_binary_only = false; // non list case
29477 : // case: not a listType for directoryList
29478 7 : p_directoryList = NULL; // non list case
29479 : // case: not a listType for C_only
29480 7 : p_C_only = false; // non list case
29481 : // case: not a listType for Cxx_only
29482 7 : p_Cxx_only = false; // non list case
29483 : // case: not a listType for C11_only
29484 7 : p_C11_only = false; // non list case
29485 : // case: not a listType for Cxx0x_only
29486 7 : p_Cxx0x_only = false; // non list case
29487 : // case: not a listType for Cxx11_only
29488 7 : p_Cxx11_only = false; // non list case
29489 : // case: not a listType for C14_only
29490 7 : p_C14_only = false; // non list case
29491 : // case: not a listType for Cxx14_only
29492 7 : p_Cxx14_only = false; // non list case
29493 : // case: not a listType for Fortran_only
29494 7 : p_Fortran_only = false; // non list case
29495 : // case: not a listType for openmp_linking
29496 7 : p_openmp_linking = false; // non list case
29497 : // case: not a listType for Java_batch_mode
29498 7 : p_Java_batch_mode = false; // non list case
29499 : // case: not a listType for Java_destdir
29500 7 : p_Java_destdir = Rose::getWorkingDirectory(); // non list case
29501 : // case: not a listType for Java_source_destdir
29502 7 : p_Java_source_destdir = Rose::getWorkingDirectory(); // non list case
29503 : // case: not a listType for addCppDirectivesToAST
29504 7 : p_addCppDirectivesToAST = false; // non list case
29505 : // case: not a listType for unparseHeaderFilesRootFolder
29506 7 : p_unparseHeaderFilesRootFolder = ""; // non list case
29507 : // case: not a listType for frontendConstantFolding
29508 7 : p_frontendConstantFolding = false; // non list case
29509 : // case: not a listType for globalScopeAcrossFiles
29510 7 : p_globalScopeAcrossFiles = NULL; // non list case
29511 : // case: not a listType for unparse_in_same_directory_as_input_file
29512 7 : p_unparse_in_same_directory_as_input_file = false; // non list case
29513 : // case: not a listType for stop_after_compilation_do_not_assemble_file
29514 7 : p_stop_after_compilation_do_not_assemble_file = false; // non list case
29515 : // case: not a listType for gnuOptionForUndefinedSymbol
29516 7 : p_gnuOptionForUndefinedSymbol = ""; // non list case
29517 : // case: not a listType for mode_32_bit
29518 7 : p_mode_32_bit = false; // non list case
29519 : // case: not a listType for noclobber_output_file
29520 7 : p_noclobber_output_file = false; // non list case
29521 : // case: not a listType for noclobber_if_different_output_file
29522 7 : p_noclobber_if_different_output_file = false; // non list case
29523 : // case: not a listType for suppressConstantFoldingPostProcessing
29524 7 : p_suppressConstantFoldingPostProcessing = false; // non list case
29525 : // case: not a listType for appendPID
29526 7 : p_appendPID = false; // non list case
29527 : // case: not a listType for reportOnHeaderFileUnparsing
29528 7 : p_reportOnHeaderFileUnparsing = false; // non list case
29529 : // case: not a listType for applicationRootDirectory
29530 7 : p_applicationRootDirectory = ""; // non list case
29531 : // case: not a listType for usingApplicationRootDirectory
29532 7 : p_usingApplicationRootDirectory = false; // non list case
29533 : // case: not a listType for usingDeferredTransformations
29534 7 : p_usingDeferredTransformations = false; // non list case
29535 :
29536 : }
29537 :
29538 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
29539 14 : }
29540 :
29541 :
29542 : /* #line 29543 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29543 :
29544 :
29545 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
29546 :
29547 :
29548 : // ********************************************************
29549 : // member functions common across all array grammar objects
29550 : // ********************************************************
29551 :
29552 :
29553 :
29554 : /* #line 29555 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29555 :
29556 :
29557 :
29558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
29559 :
29560 : // ********************************************************
29561 : // member functions specific to each node in the grammar
29562 : // ********************************************************
29563 :
29564 :
29565 : /* #line 29566 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29566 :
29567 : // Start of memberFunctionString
29568 :
29569 :
29570 : // End of memberFunctionString
29571 : // Start of memberFunctionString
29572 : /* #line 19534 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
29573 :
29574 :
29575 :
29576 : // End of memberFunctionString
29577 : // Start of memberFunctionString
29578 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
29579 :
29580 : // *** COMMON CODE SECTION BEGINS HERE ***
29581 :
29582 : #if 0
29583 : int
29584 : SgOptions::getVariant() const
29585 : {
29586 : // This function is used in ROSE while "variant()" is used in SAGE
29587 : assert(this != NULL);
29588 : return variant();
29589 : }
29590 : #endif
29591 :
29592 : // This function is used in ROSE in treeTraversal code
29593 : // eventually replaces getVariant() and variant()
29594 : // though after variant() has been removed for a while we will
29595 : // want to change the name of variantT() back to variant()
29596 : // (since the "T" was ment to stand for temporary).
29597 : // When this happens the variantT() will be depricated.
29598 : VariantT
29599 0 : SgOptions::variantT() const
29600 : {
29601 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
29602 0 : ROSE_ASSERT(this != NULL);
29603 0 : return V_SgOptions;
29604 : }
29605 :
29606 : #if 0
29607 : int
29608 : SgOptions::variant() const
29609 : {
29610 : // This function is used in SAGE
29611 : ROSE_ASSERT(this != NULL);
29612 : return OptionsTag;
29613 : }
29614 : #endif
29615 :
29616 : ROSE_DLL_API const char*
29617 0 : SgOptions::sage_class_name() const
29618 : {
29619 0 : ROSE_ASSERT(this != NULL);
29620 0 : return "SgOptions";
29621 : }
29622 :
29623 : std::string
29624 0 : SgOptions::class_name() const
29625 : {
29626 0 : ROSE_ASSERT(this != NULL);
29627 0 : return "SgOptions";
29628 : }
29629 :
29630 : // DQ (11/26/2005): Support for visitor pattern mechanims
29631 : // (inferior to ROSE traversal mechanism, experimental).
29632 : void
29633 0 : SgOptions::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
29634 : {
29635 0 : ROSE_ASSERT(this != NULL);
29636 0 : visitor.visit(this);
29637 0 : }
29638 :
29639 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
29640 0 : void SgOptions::accept (ROSE_VisitorPattern & visitor) {
29641 0 : ROSE_ASSERT(this != NULL);
29642 0 : visitor.visit(this);
29643 0 : }
29644 :
29645 : SgOptions*
29646 0 : SgOptions::addRegExpAttribute(std::string s, AstRegExAttribute* a)
29647 : {
29648 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
29649 : // This function is currently only supported for the AST used the represent Binary executables.
29650 : if (0 /* isSgAsmNode(this) != NULL */)
29651 : {
29652 : // Support for regex specification.
29653 : std::string prefixCode = "REGEX:";
29654 : addNewAttribute(prefixCode + s,a);
29655 : }
29656 : #endif
29657 :
29658 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
29659 0 : return this;
29660 : }
29661 :
29662 : // *** COMMON CODE SECTION ENDS HERE ***
29663 :
29664 :
29665 : // End of memberFunctionString
29666 : // Start of memberFunctionString
29667 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
29668 :
29669 :
29670 : #if 0
29671 : //! Error checking support
29672 : /*! Verifies the following:
29673 : - working getVariant() member function
29674 : - calls base class's error() member function
29675 : Every class has one of these functions.
29676 : */
29677 : bool
29678 : SgOptions::error()
29679 : {
29680 : // Put error checking here
29681 :
29682 : ROSE_ASSERT (this != NULL);
29683 : if (getVariant() != OptionsTag)
29684 : {
29685 : printf ("Error in SgOptions::error(): SgOptions object has a %s variant \n",
29686 : Cxx_GrammarTerminalNames[getVariant()].name);
29687 : // printf ("Error in SgOptions::error() \n");
29688 : ROSE_ABORT();
29689 : }
29690 :
29691 : ROSE_ASSERT (getVariant() == OptionsTag);
29692 : return SgSupport::error();
29693 : }
29694 : #endif
29695 :
29696 :
29697 :
29698 : // End of memberFunctionString
29699 :
29700 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
29701 :
29702 0 : SgOptions* isSgOptions ( SgNode* inputDerivedClassPointer )
29703 : {
29704 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
29705 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
29706 : // So to fix this we return NULL directly when the input is NULL and avoid the
29707 : // dynamic_cast in this case. This is likely a performance improvement as well.
29708 : // return dynamic_cast<SgOptions*>(inputDerivedClassPointer);
29709 : // Milind Chabbi (8/28/2013): isSgOptions uses table-driven castability instead of c++ default dynamic_cast
29710 : // this improves the running time performance by 10-20%.
29711 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOptions*>(inputDerivedClassPointer);
29712 0 : return IS_SgOptions_FAST_MACRO(inputDerivedClassPointer);
29713 : }
29714 :
29715 : // DQ (11/8/2003): Added version of functions taking const pointer
29716 0 : const SgOptions* isSgOptions ( const SgNode* inputDerivedClassPointer )
29717 : {
29718 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
29719 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
29720 : // So to fix this we return NULL directly when the input is NULL and avoid the
29721 : // dynamic_cast in this case. This is likely a performance improvement as well.
29722 : // return dynamic_cast<const SgOptions*>(inputDerivedClassPointer);
29723 : // Milind Chabbi (8/28/2013): isSgOptions uses table-driven castability instead of c++ default dynamic_cast
29724 : // this improves the running time performance by 10-20%.
29725 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOptions*>(inputDerivedClassPointer);
29726 0 : return IS_SgOptions_FAST_MACRO(inputDerivedClassPointer);
29727 : }
29728 :
29729 :
29730 :
29731 : /* #line 29732 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29732 :
29733 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
29734 :
29735 : /**
29736 : \brief Generated destructor
29737 :
29738 : This destructor is automatically generated (by ROSETTA). This destructor
29739 : only frees memory of data members associated with the parts of the current IR node which
29740 : are NOT traversed. Those data members that are part of a traversal can be freed using
29741 : a traversal (calling this destructor on all children in a post-order traversal). Such
29742 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
29743 :
29744 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
29745 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
29746 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
29747 :
29748 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
29749 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
29750 : pointers are not yet implemented to call delete on eash pointer in the container.
29751 : (This could be done by derivation from the STL containers to define containers that
29752 : automatically deleted their members.)
29753 :
29754 : */
29755 0 : SgOptions::~SgOptions () {
29756 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
29757 :
29758 :
29759 : // case: not a listType for default_output
29760 0 : p_default_output = NULL; // non list case
29761 : // case: not a listType for debug_output
29762 0 : p_debug_output = NULL; // non list case
29763 : // case: not a listType for error_output
29764 0 : p_error_output = NULL; // non list case
29765 : // case: not a listType for logging_output
29766 0 : p_logging_output = NULL; // non list case
29767 : // case: not a listType for debug_level
29768 0 : p_debug_level = 0; // non list case
29769 : // case: not a listType for logging_level
29770 0 : p_logging_level = 0; // non list case
29771 :
29772 : }
29773 :
29774 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
29775 0 : }
29776 :
29777 :
29778 : /* #line 29779 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29779 :
29780 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
29781 :
29782 : // Generated constructor
29783 0 : SgOptions::SgOptions ( )
29784 0 : : SgSupport()
29785 : {
29786 : #ifdef DEBUG
29787 : // printf ("In SgOptions::SgOptions () sage_class_name() = %s \n",sage_class_name());
29788 : #endif
29789 : #if 0
29790 : // debugging information!
29791 : printf ("In SgOptions::SgOptions (): this = %p = %s \n",this,this->class_name().c_str());
29792 : #endif
29793 :
29794 0 : p_default_output = NULL;
29795 0 : p_debug_output = NULL;
29796 0 : p_error_output = NULL;
29797 0 : p_logging_output = NULL;
29798 0 : p_debug_level = 0;
29799 0 : p_logging_level = 0;
29800 :
29801 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
29802 :
29803 : #if 0
29804 : // DQ (7/30/2014): Call a virtual function.
29805 : std::string s = this->class_name();
29806 : #endif
29807 :
29808 : // Test the variant virtual function
29809 : // assert(OptionsTag == variant());
29810 0 : assert(OptionsTag == this->variant());
29811 0 : ROSE_ASSERT(OptionsTag == (int)(this->variantT()));
29812 0 : post_construction_initialization();
29813 :
29814 : // Test the isSgOptions() function since it has been problematic
29815 0 : assert(isSgOptions(this) != NULL);
29816 0 : }
29817 :
29818 : // Generated constructor (all data members)
29819 :
29820 : /* #line 29821 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29821 :
29822 :
29823 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
29824 :
29825 :
29826 : // ********************************************************
29827 : // member functions common across all array grammar objects
29828 : // ********************************************************
29829 :
29830 :
29831 :
29832 : /* #line 29833 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29833 :
29834 :
29835 :
29836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
29837 :
29838 : // ********************************************************
29839 : // member functions specific to each node in the grammar
29840 : // ********************************************************
29841 :
29842 :
29843 : /* #line 29844 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
29844 :
29845 : // Start of memberFunctionString
29846 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
29847 :
29848 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
29849 :
29850 : int
29851 4934 : SgUnparse_Info::get_access_attribute () const
29852 : {
29853 4934 : ROSE_ASSERT (this != NULL);
29854 :
29855 : #if 0
29856 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29857 : // used to trigger marking transformations for the token-based unparsing.
29858 : printf ("SgUnparse_Info::get_access_attribute = %p = %s \n",this,this->class_name().c_str());
29859 : #endif
29860 :
29861 4934 : return p_access_attribute;
29862 : }
29863 :
29864 : void
29865 4934 : SgUnparse_Info::set_access_attribute ( int access_attribute )
29866 : {
29867 4934 : ROSE_ASSERT (this != NULL);
29868 :
29869 : #if 0
29870 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29871 : // used to trigger marking transformations for the token-based unparsing.
29872 : printf ("SgUnparse_Info::set_access_attribute = %p = %s \n",this,this->class_name().c_str());
29873 : #endif
29874 :
29875 4934 : set_isModified(true);
29876 :
29877 4934 : p_access_attribute = access_attribute;
29878 4934 : }
29879 :
29880 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
29881 :
29882 :
29883 : // End of memberFunctionString
29884 : // Start of memberFunctionString
29885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
29886 :
29887 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
29888 :
29889 : SgDeclarationStatement*
29890 23890 : SgUnparse_Info::get_declstatement_ptr () const
29891 : {
29892 23890 : ROSE_ASSERT (this != NULL);
29893 :
29894 : #if 0
29895 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29896 : // used to trigger marking transformations for the token-based unparsing.
29897 : printf ("SgUnparse_Info::get_declstatement_ptr = %p = %s \n",this,this->class_name().c_str());
29898 : #endif
29899 :
29900 23890 : return p_declstatement_ptr;
29901 : }
29902 :
29903 : void
29904 25318 : SgUnparse_Info::set_declstatement_ptr ( SgDeclarationStatement* declstatement_ptr )
29905 : {
29906 25318 : ROSE_ASSERT (this != NULL);
29907 :
29908 : #if 0
29909 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29910 : // used to trigger marking transformations for the token-based unparsing.
29911 : printf ("SgUnparse_Info::set_declstatement_ptr = %p = %s \n",this,this->class_name().c_str());
29912 : #endif
29913 :
29914 25318 : set_isModified(true);
29915 :
29916 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
29917 : if (p_declstatement_ptr != NULL && declstatement_ptr != NULL && p_declstatement_ptr != declstatement_ptr)
29918 : {
29919 : printf ("Warning: declstatement_ptr = %p overwriting valid pointer p_declstatement_ptr = %p \n",declstatement_ptr,p_declstatement_ptr);
29920 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
29921 : printf ("Error fails assertion (p_declstatement_ptr != NULL && declstatement_ptr != NULL && p_declstatement_ptr != declstatement_ptr) is false\n");
29922 : ROSE_ASSERT(false);
29923 : #endif
29924 : }
29925 : #endif
29926 25318 : p_declstatement_ptr = declstatement_ptr;
29927 25318 : }
29928 :
29929 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
29930 :
29931 :
29932 : // End of memberFunctionString
29933 : // Start of memberFunctionString
29934 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
29935 :
29936 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
29937 :
29938 : SgDeclarationStatement*
29939 442 : SgUnparse_Info::get_declaration_of_context () const
29940 : {
29941 442 : ROSE_ASSERT (this != NULL);
29942 :
29943 : #if 0
29944 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29945 : // used to trigger marking transformations for the token-based unparsing.
29946 : printf ("SgUnparse_Info::get_declaration_of_context = %p = %s \n",this,this->class_name().c_str());
29947 : #endif
29948 :
29949 442 : return p_declaration_of_context;
29950 : }
29951 :
29952 : void
29953 3 : SgUnparse_Info::set_declaration_of_context ( SgDeclarationStatement* declaration_of_context )
29954 : {
29955 3 : ROSE_ASSERT (this != NULL);
29956 :
29957 : #if 0
29958 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29959 : // used to trigger marking transformations for the token-based unparsing.
29960 : printf ("SgUnparse_Info::set_declaration_of_context = %p = %s \n",this,this->class_name().c_str());
29961 : #endif
29962 :
29963 3 : set_isModified(true);
29964 :
29965 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
29966 : if (p_declaration_of_context != NULL && declaration_of_context != NULL && p_declaration_of_context != declaration_of_context)
29967 : {
29968 : printf ("Warning: declaration_of_context = %p overwriting valid pointer p_declaration_of_context = %p \n",declaration_of_context,p_declaration_of_context);
29969 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
29970 : printf ("Error fails assertion (p_declaration_of_context != NULL && declaration_of_context != NULL && p_declaration_of_context != declaration_of_context) is false\n");
29971 : ROSE_ASSERT(false);
29972 : #endif
29973 : }
29974 : #endif
29975 3 : p_declaration_of_context = declaration_of_context;
29976 3 : }
29977 :
29978 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
29979 :
29980 :
29981 : // End of memberFunctionString
29982 : // Start of memberFunctionString
29983 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
29984 :
29985 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
29986 :
29987 : SgNamedType*
29988 1066 : SgUnparse_Info::get_current_context () const
29989 : {
29990 1066 : ROSE_ASSERT (this != NULL);
29991 :
29992 : #if 0
29993 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
29994 : // used to trigger marking transformations for the token-based unparsing.
29995 : printf ("SgUnparse_Info::get_current_context = %p = %s \n",this,this->class_name().c_str());
29996 : #endif
29997 :
29998 1066 : return p_current_context;
29999 : }
30000 :
30001 : void
30002 4264 : SgUnparse_Info::set_current_context ( SgNamedType* current_context )
30003 : {
30004 4264 : ROSE_ASSERT (this != NULL);
30005 :
30006 : #if 0
30007 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30008 : // used to trigger marking transformations for the token-based unparsing.
30009 : printf ("SgUnparse_Info::set_current_context = %p = %s \n",this,this->class_name().c_str());
30010 : #endif
30011 :
30012 4264 : set_isModified(true);
30013 :
30014 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30015 : if (p_current_context != NULL && current_context != NULL && p_current_context != current_context)
30016 : {
30017 : printf ("Warning: current_context = %p overwriting valid pointer p_current_context = %p \n",current_context,p_current_context);
30018 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30019 : printf ("Error fails assertion (p_current_context != NULL && current_context != NULL && p_current_context != current_context) is false\n");
30020 : ROSE_ASSERT(false);
30021 : #endif
30022 : }
30023 : #endif
30024 4264 : p_current_context = current_context;
30025 4264 : }
30026 :
30027 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30028 :
30029 :
30030 : // End of memberFunctionString
30031 : // Start of memberFunctionString
30032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30033 :
30034 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30035 :
30036 : SgName
30037 0 : SgUnparse_Info::get_array_index_list () const
30038 : {
30039 0 : ROSE_ASSERT (this != NULL);
30040 :
30041 : #if 0
30042 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30043 : // used to trigger marking transformations for the token-based unparsing.
30044 : printf ("SgUnparse_Info::get_array_index_list = %p = %s \n",this,this->class_name().c_str());
30045 : #endif
30046 :
30047 0 : return p_array_index_list;
30048 : }
30049 :
30050 : void
30051 0 : SgUnparse_Info::set_array_index_list ( SgName array_index_list )
30052 : {
30053 0 : ROSE_ASSERT (this != NULL);
30054 :
30055 : #if 0
30056 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30057 : // used to trigger marking transformations for the token-based unparsing.
30058 : printf ("SgUnparse_Info::set_array_index_list = %p = %s \n",this,this->class_name().c_str());
30059 : #endif
30060 :
30061 0 : set_isModified(true);
30062 :
30063 0 : p_array_index_list = array_index_list;
30064 0 : }
30065 :
30066 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30067 :
30068 :
30069 : // End of memberFunctionString
30070 : // Start of memberFunctionString
30071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30072 :
30073 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30074 :
30075 : SgNamespaceDeclarationStatement*
30076 6 : SgUnparse_Info::get_current_namespace () const
30077 : {
30078 6 : ROSE_ASSERT (this != NULL);
30079 :
30080 : #if 0
30081 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30082 : // used to trigger marking transformations for the token-based unparsing.
30083 : printf ("SgUnparse_Info::get_current_namespace = %p = %s \n",this,this->class_name().c_str());
30084 : #endif
30085 :
30086 6 : return p_current_namespace;
30087 : }
30088 :
30089 : void
30090 24 : SgUnparse_Info::set_current_namespace ( SgNamespaceDeclarationStatement* current_namespace )
30091 : {
30092 24 : ROSE_ASSERT (this != NULL);
30093 :
30094 : #if 0
30095 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30096 : // used to trigger marking transformations for the token-based unparsing.
30097 : printf ("SgUnparse_Info::set_current_namespace = %p = %s \n",this,this->class_name().c_str());
30098 : #endif
30099 :
30100 24 : set_isModified(true);
30101 :
30102 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30103 : if (p_current_namespace != NULL && current_namespace != NULL && p_current_namespace != current_namespace)
30104 : {
30105 : printf ("Warning: current_namespace = %p overwriting valid pointer p_current_namespace = %p \n",current_namespace,p_current_namespace);
30106 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30107 : printf ("Error fails assertion (p_current_namespace != NULL && current_namespace != NULL && p_current_namespace != current_namespace) is false\n");
30108 : ROSE_ASSERT(false);
30109 : #endif
30110 : }
30111 : #endif
30112 24 : p_current_namespace = current_namespace;
30113 24 : }
30114 :
30115 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30116 :
30117 :
30118 : // End of memberFunctionString
30119 : // Start of memberFunctionString
30120 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30121 :
30122 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30123 :
30124 : bool
30125 338314 : SgUnparse_Info::get_outputCodeGenerationFormatDelimiters () const
30126 : {
30127 338314 : ROSE_ASSERT (this != NULL);
30128 :
30129 : #if 0
30130 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30131 : // used to trigger marking transformations for the token-based unparsing.
30132 : printf ("SgUnparse_Info::get_outputCodeGenerationFormatDelimiters = %p = %s \n",this,this->class_name().c_str());
30133 : #endif
30134 :
30135 338314 : return p_outputCodeGenerationFormatDelimiters;
30136 : }
30137 :
30138 : void
30139 0 : SgUnparse_Info::set_outputCodeGenerationFormatDelimiters ( bool outputCodeGenerationFormatDelimiters )
30140 : {
30141 0 : ROSE_ASSERT (this != NULL);
30142 :
30143 : #if 0
30144 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30145 : // used to trigger marking transformations for the token-based unparsing.
30146 : printf ("SgUnparse_Info::set_outputCodeGenerationFormatDelimiters = %p = %s \n",this,this->class_name().c_str());
30147 : #endif
30148 :
30149 0 : set_isModified(true);
30150 :
30151 0 : p_outputCodeGenerationFormatDelimiters = outputCodeGenerationFormatDelimiters;
30152 0 : }
30153 :
30154 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30155 :
30156 :
30157 : // End of memberFunctionString
30158 : // Start of memberFunctionString
30159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30160 :
30161 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30162 :
30163 : SgQualifiedNamePtrList
30164 0 : SgUnparse_Info::get_qualifiedNameList () const
30165 : {
30166 0 : ROSE_ASSERT (this != NULL);
30167 :
30168 : #if 0
30169 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30170 : // used to trigger marking transformations for the token-based unparsing.
30171 : printf ("SgUnparse_Info::get_qualifiedNameList = %p = %s \n",this,this->class_name().c_str());
30172 : #endif
30173 :
30174 0 : return p_qualifiedNameList;
30175 : }
30176 :
30177 : void
30178 0 : SgUnparse_Info::set_qualifiedNameList ( SgQualifiedNamePtrList qualifiedNameList )
30179 : {
30180 0 : ROSE_ASSERT (this != NULL);
30181 :
30182 : #if 0
30183 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30184 : // used to trigger marking transformations for the token-based unparsing.
30185 : printf ("SgUnparse_Info::set_qualifiedNameList = %p = %s \n",this,this->class_name().c_str());
30186 : #endif
30187 :
30188 0 : set_isModified(true);
30189 :
30190 0 : p_qualifiedNameList = qualifiedNameList;
30191 0 : }
30192 :
30193 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30194 :
30195 :
30196 : // End of memberFunctionString
30197 : // Start of memberFunctionString
30198 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30199 :
30200 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30201 :
30202 : SgFunctionCallExp*
30203 0 : SgUnparse_Info::get_current_function_call () const
30204 : {
30205 0 : ROSE_ASSERT (this != NULL);
30206 :
30207 : #if 0
30208 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30209 : // used to trigger marking transformations for the token-based unparsing.
30210 : printf ("SgUnparse_Info::get_current_function_call = %p = %s \n",this,this->class_name().c_str());
30211 : #endif
30212 :
30213 0 : return p_current_function_call;
30214 : }
30215 :
30216 : void
30217 3068 : SgUnparse_Info::set_current_function_call ( SgFunctionCallExp* current_function_call )
30218 : {
30219 3068 : ROSE_ASSERT (this != NULL);
30220 :
30221 : #if 0
30222 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30223 : // used to trigger marking transformations for the token-based unparsing.
30224 : printf ("SgUnparse_Info::set_current_function_call = %p = %s \n",this,this->class_name().c_str());
30225 : #endif
30226 :
30227 3068 : set_isModified(true);
30228 :
30229 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30230 : if (p_current_function_call != NULL && current_function_call != NULL && p_current_function_call != current_function_call)
30231 : {
30232 : printf ("Warning: current_function_call = %p overwriting valid pointer p_current_function_call = %p \n",current_function_call,p_current_function_call);
30233 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30234 : printf ("Error fails assertion (p_current_function_call != NULL && current_function_call != NULL && p_current_function_call != current_function_call) is false\n");
30235 : ROSE_ASSERT(false);
30236 : #endif
30237 : }
30238 : #endif
30239 3068 : p_current_function_call = current_function_call;
30240 3068 : }
30241 :
30242 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30243 :
30244 :
30245 : // End of memberFunctionString
30246 : // Start of memberFunctionString
30247 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30248 :
30249 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30250 :
30251 : SgScopeStatement*
30252 1646960 : SgUnparse_Info::get_current_scope () const
30253 : {
30254 1646960 : ROSE_ASSERT (this != NULL);
30255 :
30256 : #if 0
30257 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30258 : // used to trigger marking transformations for the token-based unparsing.
30259 : printf ("SgUnparse_Info::get_current_scope = %p = %s \n",this,this->class_name().c_str());
30260 : #endif
30261 :
30262 1646960 : return p_current_scope;
30263 : }
30264 :
30265 : void
30266 1630170 : SgUnparse_Info::set_current_scope ( SgScopeStatement* current_scope )
30267 : {
30268 1630170 : ROSE_ASSERT (this != NULL);
30269 :
30270 : #if 0
30271 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30272 : // used to trigger marking transformations for the token-based unparsing.
30273 : printf ("SgUnparse_Info::set_current_scope = %p = %s \n",this,this->class_name().c_str());
30274 : #endif
30275 :
30276 1630170 : set_isModified(true);
30277 :
30278 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30279 : if (p_current_scope != NULL && current_scope != NULL && p_current_scope != current_scope)
30280 : {
30281 : printf ("Warning: current_scope = %p overwriting valid pointer p_current_scope = %p \n",current_scope,p_current_scope);
30282 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30283 : printf ("Error fails assertion (p_current_scope != NULL && current_scope != NULL && p_current_scope != current_scope) is false\n");
30284 : ROSE_ASSERT(false);
30285 : #endif
30286 : }
30287 : #endif
30288 1630170 : p_current_scope = current_scope;
30289 1630170 : }
30290 :
30291 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30292 :
30293 :
30294 : // End of memberFunctionString
30295 : // Start of memberFunctionString
30296 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30297 :
30298 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30299 :
30300 : SgNode*
30301 5320750 : SgUnparse_Info::get_reference_node_for_qualification () const
30302 : {
30303 5320750 : ROSE_ASSERT (this != NULL);
30304 :
30305 : #if 0
30306 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30307 : // used to trigger marking transformations for the token-based unparsing.
30308 : printf ("SgUnparse_Info::get_reference_node_for_qualification = %p = %s \n",this,this->class_name().c_str());
30309 : #endif
30310 :
30311 5320750 : return p_reference_node_for_qualification;
30312 : }
30313 :
30314 : void
30315 1834840 : SgUnparse_Info::set_reference_node_for_qualification ( SgNode* reference_node_for_qualification )
30316 : {
30317 1834840 : ROSE_ASSERT (this != NULL);
30318 :
30319 : #if 0
30320 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30321 : // used to trigger marking transformations for the token-based unparsing.
30322 : printf ("SgUnparse_Info::set_reference_node_for_qualification = %p = %s \n",this,this->class_name().c_str());
30323 : #endif
30324 :
30325 1834840 : set_isModified(true);
30326 :
30327 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30328 : if (p_reference_node_for_qualification != NULL && reference_node_for_qualification != NULL && p_reference_node_for_qualification != reference_node_for_qualification)
30329 : {
30330 : printf ("Warning: reference_node_for_qualification = %p overwriting valid pointer p_reference_node_for_qualification = %p \n",reference_node_for_qualification,p_reference_node_for_qualification);
30331 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30332 : printf ("Error fails assertion (p_reference_node_for_qualification != NULL && reference_node_for_qualification != NULL && p_reference_node_for_qualification != reference_node_for_qualification) is false\n");
30333 : ROSE_ASSERT(false);
30334 : #endif
30335 : }
30336 : #endif
30337 1834840 : p_reference_node_for_qualification = reference_node_for_qualification;
30338 1834840 : }
30339 :
30340 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30341 :
30342 :
30343 : // End of memberFunctionString
30344 : // Start of memberFunctionString
30345 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30346 :
30347 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30348 :
30349 : int
30350 0 : SgUnparse_Info::get_name_qualification_length () const
30351 : {
30352 0 : ROSE_ASSERT (this != NULL);
30353 :
30354 : #if 0
30355 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30356 : // used to trigger marking transformations for the token-based unparsing.
30357 : printf ("SgUnparse_Info::get_name_qualification_length = %p = %s \n",this,this->class_name().c_str());
30358 : #endif
30359 :
30360 0 : return p_name_qualification_length;
30361 : }
30362 :
30363 : void
30364 288050 : SgUnparse_Info::set_name_qualification_length ( int name_qualification_length )
30365 : {
30366 288050 : ROSE_ASSERT (this != NULL);
30367 :
30368 : #if 0
30369 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30370 : // used to trigger marking transformations for the token-based unparsing.
30371 : printf ("SgUnparse_Info::set_name_qualification_length = %p = %s \n",this,this->class_name().c_str());
30372 : #endif
30373 :
30374 288050 : set_isModified(true);
30375 :
30376 288050 : p_name_qualification_length = name_qualification_length;
30377 288050 : }
30378 :
30379 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30380 :
30381 :
30382 : // End of memberFunctionString
30383 : // Start of memberFunctionString
30384 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30385 :
30386 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30387 :
30388 : bool
30389 0 : SgUnparse_Info::get_type_elaboration_required () const
30390 : {
30391 0 : ROSE_ASSERT (this != NULL);
30392 :
30393 : #if 0
30394 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30395 : // used to trigger marking transformations for the token-based unparsing.
30396 : printf ("SgUnparse_Info::get_type_elaboration_required = %p = %s \n",this,this->class_name().c_str());
30397 : #endif
30398 :
30399 0 : return p_type_elaboration_required;
30400 : }
30401 :
30402 : void
30403 285229 : SgUnparse_Info::set_type_elaboration_required ( bool type_elaboration_required )
30404 : {
30405 285229 : ROSE_ASSERT (this != NULL);
30406 :
30407 : #if 0
30408 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30409 : // used to trigger marking transformations for the token-based unparsing.
30410 : printf ("SgUnparse_Info::set_type_elaboration_required = %p = %s \n",this,this->class_name().c_str());
30411 : #endif
30412 :
30413 285229 : set_isModified(true);
30414 :
30415 285229 : p_type_elaboration_required = type_elaboration_required;
30416 285229 : }
30417 :
30418 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30419 :
30420 :
30421 : // End of memberFunctionString
30422 : // Start of memberFunctionString
30423 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30424 :
30425 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30426 :
30427 : bool
30428 0 : SgUnparse_Info::get_global_qualification_required () const
30429 : {
30430 0 : ROSE_ASSERT (this != NULL);
30431 :
30432 : #if 0
30433 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30434 : // used to trigger marking transformations for the token-based unparsing.
30435 : printf ("SgUnparse_Info::get_global_qualification_required = %p = %s \n",this,this->class_name().c_str());
30436 : #endif
30437 :
30438 0 : return p_global_qualification_required;
30439 : }
30440 :
30441 : void
30442 365570 : SgUnparse_Info::set_global_qualification_required ( bool global_qualification_required )
30443 : {
30444 365570 : ROSE_ASSERT (this != NULL);
30445 :
30446 : #if 0
30447 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30448 : // used to trigger marking transformations for the token-based unparsing.
30449 : printf ("SgUnparse_Info::set_global_qualification_required = %p = %s \n",this,this->class_name().c_str());
30450 : #endif
30451 :
30452 365570 : set_isModified(true);
30453 :
30454 365570 : p_global_qualification_required = global_qualification_required;
30455 365570 : }
30456 :
30457 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30458 :
30459 :
30460 : // End of memberFunctionString
30461 : // Start of memberFunctionString
30462 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30463 :
30464 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30465 :
30466 : int
30467 0 : SgUnparse_Info::get_nestingLevel () const
30468 : {
30469 0 : ROSE_ASSERT (this != NULL);
30470 :
30471 : #if 0
30472 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30473 : // used to trigger marking transformations for the token-based unparsing.
30474 : printf ("SgUnparse_Info::get_nestingLevel = %p = %s \n",this,this->class_name().c_str());
30475 : #endif
30476 :
30477 0 : return p_nestingLevel;
30478 : }
30479 :
30480 : void
30481 0 : SgUnparse_Info::set_nestingLevel ( int nestingLevel )
30482 : {
30483 0 : ROSE_ASSERT (this != NULL);
30484 :
30485 : #if 0
30486 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30487 : // used to trigger marking transformations for the token-based unparsing.
30488 : printf ("SgUnparse_Info::set_nestingLevel = %p = %s \n",this,this->class_name().c_str());
30489 : #endif
30490 :
30491 0 : set_isModified(true);
30492 :
30493 0 : p_nestingLevel = nestingLevel;
30494 0 : }
30495 :
30496 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30497 :
30498 :
30499 : // End of memberFunctionString
30500 : // Start of memberFunctionString
30501 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30502 :
30503 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30504 :
30505 : SgFile::languageOption_enum
30506 1196100 : SgUnparse_Info::get_language () const
30507 : {
30508 1196100 : ROSE_ASSERT (this != NULL);
30509 :
30510 : #if 0
30511 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30512 : // used to trigger marking transformations for the token-based unparsing.
30513 : printf ("SgUnparse_Info::get_language = %p = %s \n",this,this->class_name().c_str());
30514 : #endif
30515 :
30516 1196100 : return p_language;
30517 : }
30518 :
30519 : void
30520 105338 : SgUnparse_Info::set_language ( SgFile::languageOption_enum language )
30521 : {
30522 105338 : ROSE_ASSERT (this != NULL);
30523 :
30524 : #if 0
30525 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30526 : // used to trigger marking transformations for the token-based unparsing.
30527 : printf ("SgUnparse_Info::set_language = %p = %s \n",this,this->class_name().c_str());
30528 : #endif
30529 :
30530 105338 : set_isModified(true);
30531 :
30532 105338 : p_language = language;
30533 105338 : }
30534 :
30535 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30536 :
30537 :
30538 : // End of memberFunctionString
30539 : // Start of memberFunctionString
30540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30541 :
30542 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30543 :
30544 : SgSourceFile*
30545 1513700 : SgUnparse_Info::get_current_source_file () const
30546 : {
30547 1513700 : ROSE_ASSERT (this != NULL);
30548 :
30549 : #if 0
30550 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30551 : // used to trigger marking transformations for the token-based unparsing.
30552 : printf ("SgUnparse_Info::get_current_source_file = %p = %s \n",this,this->class_name().c_str());
30553 : #endif
30554 :
30555 1513700 : return p_current_source_file;
30556 : }
30557 :
30558 : void
30559 48794 : SgUnparse_Info::set_current_source_file ( SgSourceFile* current_source_file )
30560 : {
30561 48794 : ROSE_ASSERT (this != NULL);
30562 :
30563 : #if 0
30564 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30565 : // used to trigger marking transformations for the token-based unparsing.
30566 : printf ("SgUnparse_Info::set_current_source_file = %p = %s \n",this,this->class_name().c_str());
30567 : #endif
30568 :
30569 48794 : set_isModified(true);
30570 :
30571 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30572 : if (p_current_source_file != NULL && current_source_file != NULL && p_current_source_file != current_source_file)
30573 : {
30574 : printf ("Warning: current_source_file = %p overwriting valid pointer p_current_source_file = %p \n",current_source_file,p_current_source_file);
30575 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30576 : printf ("Error fails assertion (p_current_source_file != NULL && current_source_file != NULL && p_current_source_file != current_source_file) is false\n");
30577 : ROSE_ASSERT(false);
30578 : #endif
30579 : }
30580 : #endif
30581 48794 : p_current_source_file = current_source_file;
30582 48794 : }
30583 :
30584 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30585 :
30586 :
30587 : // End of memberFunctionString
30588 : // Start of memberFunctionString
30589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30590 :
30591 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30592 :
30593 : bool
30594 5 : SgUnparse_Info::get_use_generated_name_for_template_arguments () const
30595 : {
30596 5 : ROSE_ASSERT (this != NULL);
30597 :
30598 : #if 0
30599 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30600 : // used to trigger marking transformations for the token-based unparsing.
30601 : printf ("SgUnparse_Info::get_use_generated_name_for_template_arguments = %p = %s \n",this,this->class_name().c_str());
30602 : #endif
30603 :
30604 5 : return p_use_generated_name_for_template_arguments;
30605 : }
30606 :
30607 : void
30608 104982 : SgUnparse_Info::set_use_generated_name_for_template_arguments ( bool use_generated_name_for_template_arguments )
30609 : {
30610 104982 : ROSE_ASSERT (this != NULL);
30611 :
30612 : #if 0
30613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30614 : // used to trigger marking transformations for the token-based unparsing.
30615 : printf ("SgUnparse_Info::set_use_generated_name_for_template_arguments = %p = %s \n",this,this->class_name().c_str());
30616 : #endif
30617 :
30618 104982 : set_isModified(true);
30619 :
30620 104982 : p_use_generated_name_for_template_arguments = use_generated_name_for_template_arguments;
30621 104982 : }
30622 :
30623 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30624 :
30625 :
30626 : // End of memberFunctionString
30627 : // Start of memberFunctionString
30628 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30629 :
30630 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30631 :
30632 : bool
30633 3 : SgUnparse_Info::get_user_defined_literal () const
30634 : {
30635 3 : ROSE_ASSERT (this != NULL);
30636 :
30637 : #if 0
30638 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30639 : // used to trigger marking transformations for the token-based unparsing.
30640 : printf ("SgUnparse_Info::get_user_defined_literal = %p = %s \n",this,this->class_name().c_str());
30641 : #endif
30642 :
30643 3 : return p_user_defined_literal;
30644 : }
30645 :
30646 : void
30647 0 : SgUnparse_Info::set_user_defined_literal ( bool user_defined_literal )
30648 : {
30649 0 : ROSE_ASSERT (this != NULL);
30650 :
30651 : #if 0
30652 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30653 : // used to trigger marking transformations for the token-based unparsing.
30654 : printf ("SgUnparse_Info::set_user_defined_literal = %p = %s \n",this,this->class_name().c_str());
30655 : #endif
30656 :
30657 0 : set_isModified(true);
30658 :
30659 0 : p_user_defined_literal = user_defined_literal;
30660 0 : }
30661 :
30662 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30663 :
30664 :
30665 : // End of memberFunctionString
30666 : // Start of memberFunctionString
30667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30668 :
30669 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30670 :
30671 : SgDeclarationStatement*
30672 4 : SgUnparse_Info::get_declstatement_associated_with_type () const
30673 : {
30674 4 : ROSE_ASSERT (this != NULL);
30675 :
30676 : #if 0
30677 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30678 : // used to trigger marking transformations for the token-based unparsing.
30679 : printf ("SgUnparse_Info::get_declstatement_associated_with_type = %p = %s \n",this,this->class_name().c_str());
30680 : #endif
30681 :
30682 4 : return p_declstatement_associated_with_type;
30683 : }
30684 :
30685 : void
30686 2 : SgUnparse_Info::set_declstatement_associated_with_type ( SgDeclarationStatement* declstatement_associated_with_type )
30687 : {
30688 2 : ROSE_ASSERT (this != NULL);
30689 :
30690 : #if 0
30691 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30692 : // used to trigger marking transformations for the token-based unparsing.
30693 : printf ("SgUnparse_Info::set_declstatement_associated_with_type = %p = %s \n",this,this->class_name().c_str());
30694 : #endif
30695 :
30696 2 : set_isModified(true);
30697 :
30698 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
30699 : if (p_declstatement_associated_with_type != NULL && declstatement_associated_with_type != NULL && p_declstatement_associated_with_type != declstatement_associated_with_type)
30700 : {
30701 : printf ("Warning: declstatement_associated_with_type = %p overwriting valid pointer p_declstatement_associated_with_type = %p \n",declstatement_associated_with_type,p_declstatement_associated_with_type);
30702 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
30703 : printf ("Error fails assertion (p_declstatement_associated_with_type != NULL && declstatement_associated_with_type != NULL && p_declstatement_associated_with_type != declstatement_associated_with_type) is false\n");
30704 : ROSE_ASSERT(false);
30705 : #endif
30706 : }
30707 : #endif
30708 2 : p_declstatement_associated_with_type = declstatement_associated_with_type;
30709 2 : }
30710 :
30711 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30712 :
30713 :
30714 : // End of memberFunctionString
30715 : // Start of memberFunctionString
30716 :
30717 :
30718 : // End of memberFunctionString
30719 : // Start of memberFunctionString
30720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
30721 :
30722 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
30723 :
30724 : bool
30725 34 : SgUnparse_Info::get_context_for_added_parentheses () const
30726 : {
30727 34 : ROSE_ASSERT (this != NULL);
30728 :
30729 : #if 0
30730 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30731 : // used to trigger marking transformations for the token-based unparsing.
30732 : printf ("SgUnparse_Info::get_context_for_added_parentheses = %p = %s \n",this,this->class_name().c_str());
30733 : #endif
30734 :
30735 34 : return p_context_for_added_parentheses;
30736 : }
30737 :
30738 : void
30739 144 : SgUnparse_Info::set_context_for_added_parentheses ( bool context_for_added_parentheses )
30740 : {
30741 144 : ROSE_ASSERT (this != NULL);
30742 :
30743 : #if 0
30744 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
30745 : // used to trigger marking transformations for the token-based unparsing.
30746 : printf ("SgUnparse_Info::set_context_for_added_parentheses = %p = %s \n",this,this->class_name().c_str());
30747 : #endif
30748 :
30749 144 : set_isModified(true);
30750 :
30751 144 : p_context_for_added_parentheses = context_for_added_parentheses;
30752 144 : }
30753 :
30754 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
30755 :
30756 :
30757 : // End of memberFunctionString
30758 : // Start of memberFunctionString
30759 : /* #line 19538 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
30760 :
30761 :
30762 : // SgUnparse_Info SgNO_UNPARSE_INFO;
30763 : extern void printSgVariant(std::ostream&,int);
30764 :
30765 : // DQ (1/11/2004): Remove this static member and make it a member pointer
30766 : // Declaration of static member to support unparsing complex structures
30767 : SgTypePtrList SgUnparse_Info::p_structureTagProcessingList;
30768 :
30769 : /*! \brief Debugging support
30770 :
30771 : Debugging support to test correctness of the implementation the SgUnparse_Info
30772 : object as an inherited attribute in the unparser.
30773 : */
30774 : bool SgUnparse_Info::p_forceDefaultConstructorToTriggerError = false;
30775 :
30776 : bool
30777 0 : SgUnparse_Info::get_forceDefaultConstructorToTriggerError()
30778 : {
30779 0 : return p_forceDefaultConstructorToTriggerError;
30780 : }
30781 :
30782 : void
30783 712 : SgUnparse_Info::set_forceDefaultConstructorToTriggerError( bool forceDefaultConstructorToTriggerError)
30784 : {
30785 712 : p_forceDefaultConstructorToTriggerError = forceDefaultConstructorToTriggerError;
30786 712 : }
30787 :
30788 : /*! \brief Extern C support when using braces.
30789 :
30790 : When using braced extern C we need to avoid nesting of these structures in the generated code.
30791 : */
30792 : // DQ (8/15/2020): Record when we are in an extern "C" so that we can avoid nesting (see Cxx_tests/test2020_28.C).
30793 : bool SgUnparse_Info::p_extern_C_with_braces = false;
30794 :
30795 : bool
30796 0 : SgUnparse_Info::get_extern_C_with_braces()
30797 : {
30798 0 : return p_extern_C_with_braces;
30799 : }
30800 :
30801 : void
30802 2 : SgUnparse_Info::set_extern_C_with_braces( bool extern_C_with_braces)
30803 : {
30804 2 : p_extern_C_with_braces = extern_C_with_braces;
30805 2 : }
30806 :
30807 :
30808 : // Default constructor defined here because the automatically generated constructor
30809 : // would not be generated with the error checking that I require to debug the use of
30810 : // the SgUnparse_Info object as an inherited attribute in the unparser.
30811 1662470 : SgUnparse_Info::SgUnparse_Info ()
30812 1662470 : : SgSupport()
30813 : {
30814 1662470 : static int counter = 0;
30815 1662470 : counter++;
30816 :
30817 : #ifdef DEBUG
30818 : mprintf ("In SgUnparse_Info::SgUnparse_Info () sage_class_name() = %s counter = %d \n",sage_class_name(),counter);
30819 : #endif
30820 :
30821 : // Supporting error checking for test of SgUnparse_Info as an inherited attribute in the unparser
30822 1662470 : if (p_forceDefaultConstructorToTriggerError == true)
30823 : {
30824 0 : mprintf ("SgUnparse_Info constructor called in inappropriate location (part of debugging code) counter = %d \n",counter);
30825 : #if 1
30826 : // DQ (11/9/2009): This can be allowed to be uncommented!
30827 0 : ROSE_ABORT();
30828 : #else
30829 : // DQ (11/9/2009): Allow this to support debugging of the unparser (posabily recursive behavior) \n");
30830 : mprintf ("Warning: Allow this to support debugging of the unparser (posabily recursive behavior) \n");
30831 : #endif
30832 : }
30833 :
30834 : // Test the variant virtual function
30835 1662470 : assert(Unparse_InfoTag == variant());
30836 1662470 : post_construction_initialization();
30837 :
30838 : // mprintf ("p_unparse_attribute.size() = %" PRIuPTR " \n",p_unparse_attribute.size());
30839 : // mprintf ("SgNO_UNPARSE_INFO.p_unparse_attribute.size() = %" PRIuPTR " \n",SgNO_UNPARSE_INFO.p_unparse_attribute.size());
30840 1662470 : assert (p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30841 : // assert (SgNO_UNPARSE_INFO.p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30842 :
30843 : // Test the isSgUnparse_Info() function since it has been problematic
30844 1662470 : assert(isSgUnparse_Info(this) != NULL);
30845 :
30846 : // Initialize the nesting level to 0 (for python).
30847 1662470 : p_nestingLevel = 0;
30848 1662470 : }
30849 :
30850 : // DQ (1/5/2008): I think this is a redundant function with the one in sageInterface.C
30851 : std::string
30852 0 : getSgVariant ( int variant )
30853 : {
30854 : // Return a string associated with the input variant!
30855 : // check to make sure we have the correct variant and a valid string
30856 0 : assert(variant == Cxx_GrammarTerminalNames[variant].variant);
30857 :
30858 0 : return Cxx_GrammarTerminalNames[variant].name;
30859 : }
30860 :
30861 1832010 : SgUnparse_Info::SgUnparse_Info ( const SgUnparse_Info & X )
30862 1832010 : : SgSupport()
30863 : {
30864 1832010 : assert (X.p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30865 :
30866 1832010 : *this = X;
30867 :
30868 1832010 : assert (p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30869 : // assert (SgNO_UNPARSE_INFO.p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30870 :
30871 : // Copy nesting level (for python).
30872 1832010 : p_nestingLevel = X.p_nestingLevel;
30873 :
30874 : // DQ (1/10/2014): Added to support token based unparsing.
30875 1832010 : ROSE_ASSERT(p_current_source_file == X.p_current_source_file);
30876 : // p_current_source_file = X.p_current_source_file;
30877 1832010 : }
30878 :
30879 1832010 : SgUnparse_Info & SgUnparse_Info::operator= ( const SgUnparse_Info & X )
30880 : {
30881 1832010 : p_unparse_attribute = X.p_unparse_attribute;
30882 1832010 : p_access_attribute = X.p_access_attribute;
30883 1832010 : p_nested_expression = X.p_nested_expression;
30884 1832010 : p_operator_name = X.p_operator_name;
30885 1832010 : p_var_name = X.p_var_name;
30886 1832010 : p_declstatement_ptr = X.p_declstatement_ptr;
30887 1832010 : p_declaration_of_context = X.p_declaration_of_context;
30888 1832010 : p_current_context = X.p_current_context;
30889 1832010 : p_array_index_list = X.p_array_index_list;
30890 :
30891 : // DQ (11/6/2004): aded initialization of namespace context
30892 1832010 : p_current_namespace = X.p_current_namespace;
30893 :
30894 : // DQ (3/18/2006): Support for specification of output useful in debugging formatting
30895 : // of generated code (unparsing).
30896 1832010 : p_outputCodeGenerationFormatDelimiters = X.p_outputCodeGenerationFormatDelimiters;
30897 :
30898 1832010 : assert (X.p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30899 1832010 : assert (p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30900 : // assert (SgNO_UNPARSE_INFO.p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30901 :
30902 : // DQ (10/10/2006): Added support for qualified name lists.
30903 1832010 : p_qualifiedNameList = X.p_qualifiedNameList;
30904 :
30905 : // DQ (10/20/2006): Added support for function call context information.
30906 1832010 : p_current_function_call = X.p_current_function_call;
30907 :
30908 : // DQ (5/22/2007): Added to support name qualification and access to the new hidden
30909 : // type, declaration and class elaboration lists stored in the scopes.
30910 1832010 : p_current_scope = X.p_current_scope;
30911 :
30912 : // DQ (5/11/2011): New support for name qualification.
30913 1832010 : p_name_qualification_length = X.p_name_qualification_length;
30914 1832010 : p_type_elaboration_required = X.p_type_elaboration_required;
30915 1832010 : p_global_qualification_required = X.p_global_qualification_required;
30916 :
30917 : // DQ (5/21/2011): New support for name qualification.
30918 1832010 : p_reference_node_for_qualification = X.p_reference_node_for_qualification;
30919 :
30920 : // DQ (9/15/2012): Added mechanism to specify the language more directly.
30921 : // Required to know when to unparse boolean values as integer for C and C99/C++
30922 1832010 : p_language = X.p_language;
30923 :
30924 : // DQ (1/10/2014): Added to support token based unparsing.
30925 1832010 : p_current_source_file = X.p_current_source_file;
30926 :
30927 : // DQ (4/28/2017): Added information required for use of generated names in the output of types for template
30928 : // arguments as used in symbol table lookup.
30929 1832010 : p_use_generated_name_for_template_arguments = X.p_use_generated_name_for_template_arguments;
30930 :
30931 : // DQ (12/26/2019): When supporting multiple files, the defining declaration in a named type must refer to the
30932 : // defining declaration associated with the appropriate file (to be unparsed correctly).
30933 1832010 : p_declstatement_associated_with_type = X.p_declstatement_associated_with_type;
30934 :
30935 1832010 : p_user_defined_literal = X.p_user_defined_literal;
30936 :
30937 : // DQ (8/15/2020): Record when we are in an extern "C" so that we can avoid nesting (see Cxx_tests/test2020_28.C).
30938 : // p_extern_C_with_braces = X.p_extern_C_with_braces;
30939 :
30940 : // DQ (8/24/2020): debugging Cxx_tests/test2020_44.C need to communicate when to suppress extra parenthesis use around SgFunctionType arguments.
30941 1832010 : p_context_for_added_parentheses = X.p_context_for_added_parentheses;
30942 1832010 : return *this;
30943 : }
30944 :
30945 : bool
30946 28692500 : SgUnparse_Info::checkBit(unparse_type_num bit) const
30947 : {
30948 : // if(p_unparse_attribute & bit) return 1; else return 0;
30949 : // bool returnValue = false;
30950 : // if (p_unparse_attribute[bit])
30951 : // returnValue = true;
30952 : // return returnValue;
30953 :
30954 28692500 : assert (this != NULL);
30955 28692500 : assert (bit > 0);
30956 28692500 : assert (bit < UNPARSE_TYPE_LAST);
30957 28692500 : assert (p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30958 :
30959 28692500 : return p_unparse_attribute[bit];
30960 : }
30961 :
30962 : void
30963 10460200 : SgUnparse_Info::setBit(unparse_type_num bit)
30964 : {
30965 : // p_unparse_attribute |= bit;
30966 :
30967 10460200 : assert (this != NULL);
30968 10460200 : assert (bit > 0);
30969 10460200 : assert (bit < UNPARSE_TYPE_LAST);
30970 10460200 : assert (p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30971 :
30972 10460200 : p_unparse_attribute[bit] = true;
30973 10460200 : }
30974 :
30975 : void
30976 1748250 : SgUnparse_Info::unsetBit(unparse_type_num bit)
30977 : {
30978 : // p_unparse_attribute &= ~bit;
30979 :
30980 1748250 : assert (this != NULL);
30981 1748250 : assert (bit > 0);
30982 1748250 : assert (bit < UNPARSE_TYPE_LAST);
30983 1748250 : assert (p_unparse_attribute.size() == UNPARSE_TYPE_LAST);
30984 :
30985 1748250 : p_unparse_attribute[bit] = false;
30986 1748250 : }
30987 :
30988 : void
30989 1662470 : SgUnparse_Info::post_construction_initialization()
30990 : {
30991 : // DQ (11/4/2003): Modified initialization from "0" to "NULL"
30992 : // and "" for non-integer values
30993 :
30994 1662470 : assert (this != NULL);
30995 :
30996 : // Clear all bit flags
30997 : // p_unparse_attribute = b_enum_defaultValue;
30998 94760800 : for (int i = 0; i < UNPARSE_TYPE_LAST; i++)
30999 : {
31000 93098400 : p_unparse_attribute.push_back(false);
31001 : }
31002 1662470 : assert (p_unparse_attribute.size() > 0);
31003 :
31004 1662470 : p_access_attribute = a_unset_access;
31005 1662470 : p_nested_expression = false;
31006 1662470 : p_operator_name = "";
31007 1662470 : p_var_name = "";
31008 1662470 : p_declstatement_ptr = NULL;
31009 1662470 : p_declaration_of_context = NULL;
31010 1662470 : p_current_context = NULL;
31011 1662470 : p_array_index_list = "";
31012 :
31013 : // DQ (1/12/2003): If calling constructor then empty the list
31014 : // constructors (except copy constructor) are only call in the
31015 : // initiation of a unparser traversal (precisely where there
31016 : // is no context yet build up).
31017 :
31018 : // mprintf ("p_structureTagProcessingList.size() = %" PRIuPTR " \n",p_structureTagProcessingList.size());
31019 1662470 : if (p_structureTagProcessingList.empty() != true)
31020 : {
31021 : // empty the list (using STL list's assignment operator)
31022 0 : SgTypePtrList emptyList;
31023 0 : p_structureTagProcessingList = emptyList;
31024 : }
31025 :
31026 : // DQ (11/6/2004): Added initialization of namespace context (error reported valgrind)
31027 1662470 : p_current_namespace = NULL;
31028 :
31029 : // DQ (3/18/2006): Support for specification of output useful in debugging formatting
31030 : // of generated code (unparsing).
31031 1662470 : p_outputCodeGenerationFormatDelimiters = false;
31032 :
31033 : // DQ (10/10/2006): Added support for qualified name lists.
31034 1662470 : p_qualifiedNameList.clear();
31035 :
31036 : // DQ (10/20/2006): Added support for function call context information.
31037 1662470 : p_current_function_call = NULL;
31038 :
31039 : // DQ (6/2/2007): Added initialization of new data member.
31040 1662470 : p_current_scope = NULL;
31041 :
31042 : // DQ (5/21/2011): New support for name qualification.
31043 1662470 : p_reference_node_for_qualification = NULL;
31044 :
31045 : // DQ (5/11/2011): New support for name qualification.
31046 1662470 : p_name_qualification_length = 0;
31047 1662470 : p_type_elaboration_required = false;
31048 1662470 : p_global_qualification_required = false;
31049 :
31050 : // DQ (12/26/2019): Added initialization.
31051 1662470 : p_nestingLevel = 0;
31052 :
31053 : // DQ (12/26/2019): Added initialization.
31054 1662470 : p_language = SgFile::e_default_language;
31055 :
31056 : // DQ (1/10/2014): Added to support token based unparsing.
31057 1662470 : p_current_source_file = NULL;
31058 :
31059 : // DQ (4/28/2017): Added information required for use of generated names in the output of types for template
31060 : // arguments as used in symbol table lookup.
31061 1662470 : p_use_generated_name_for_template_arguments = false;
31062 :
31063 : // DQ (12/26/2019): Added initialization.
31064 1662470 : p_user_defined_literal = false;
31065 :
31066 : // DQ (12/26/2019): When supporting multiple files, the defining declaration in a named type must refer to the
31067 : // defining declaration associated with the appropriate file (to be unparsed correctly).
31068 1662470 : p_declstatement_associated_with_type = NULL;
31069 :
31070 : // DQ (8/15/2020): Record when we are in an extern "C" so that we can avoid nesting (see Cxx_tests/test2020_28.C).
31071 : // p_extern_C_with_braces = false;
31072 :
31073 : // DQ (8/24/2020): debugging Cxx_tests/test2020_44.C need to communicate when to suppress extra parenthesis use around SgFunctionType arguments.
31074 1662470 : p_context_for_added_parentheses = false;
31075 1662470 : }
31076 :
31077 : bool
31078 11922 : SgUnparse_Info::isUnsetAccess() const
31079 11922 : { return p_access_attribute == a_unset_access; }
31080 :
31081 : void
31082 14991 : SgUnparse_Info::set_isUnsetAccess()
31083 14991 : { p_access_attribute = a_unset_access; }
31084 :
31085 : bool
31086 11922 : SgUnparse_Info::isPrivateAccess() const
31087 11922 : { return p_access_attribute == a_private_access; }
31088 :
31089 : void
31090 4385 : SgUnparse_Info::set_isPrivateAccess()
31091 4385 : { p_access_attribute = a_private_access; }
31092 :
31093 : bool
31094 7840 : SgUnparse_Info::isProtectedAccess() const
31095 7840 : { return p_access_attribute == a_protected_access; }
31096 :
31097 : void
31098 431 : SgUnparse_Info::set_isProtectedAccess()
31099 431 : { p_access_attribute = a_protected_access; }
31100 :
31101 : bool
31102 7135 : SgUnparse_Info::isPublicAccess() const
31103 7135 : { return p_access_attribute == a_public_access; }
31104 :
31105 : void
31106 7100 : SgUnparse_Info::set_isPublicAccess()
31107 7100 : { p_access_attribute = a_public_access; }
31108 :
31109 : // DQ (8/12/2020): Adding a default value for when it is not set explicitly.
31110 : bool
31111 402 : SgUnparse_Info::isDefaultAccess() const
31112 402 : { return p_access_attribute == a_default_access; }
31113 :
31114 : void
31115 6 : SgUnparse_Info::set_isDefaultAccess()
31116 6 : { p_access_attribute = a_default_access; }
31117 :
31118 :
31119 :
31120 : bool
31121 58728 : SgUnparse_Info::isPointerToSomething() const
31122 58728 : { return checkBit(b_isPointerToSomething); }
31123 :
31124 : void
31125 1345 : SgUnparse_Info::set_isPointerToSomething()
31126 1345 : { setBit(b_isPointerToSomething); }
31127 :
31128 : void
31129 1357 : SgUnparse_Info::unset_isPointerToSomething()
31130 1357 : { unsetBit(b_isPointerToSomething); }
31131 :
31132 : bool
31133 59182 : SgUnparse_Info::isReferenceToSomething() const
31134 59182 : { return checkBit(b_isReferenceToSomething); }
31135 :
31136 : void
31137 19648 : SgUnparse_Info::set_isReferenceToSomething()
31138 19648 : { setBit(b_isReferenceToSomething); }
31139 :
31140 : void
31141 1357 : SgUnparse_Info::unset_isReferenceToSomething()
31142 1357 : { unsetBit(b_isReferenceToSomething); }
31143 :
31144 : bool
31145 3725 : SgUnparse_Info::inVarDecl() const
31146 3725 : { return checkBit(b_inVarDecl); }
31147 :
31148 : void
31149 0 : SgUnparse_Info::set_inVarDecl()
31150 0 : { setBit(b_inVarDecl); }
31151 :
31152 : void
31153 3 : SgUnparse_Info::unset_inVarDecl()
31154 3 : { unsetBit(b_inVarDecl); }
31155 :
31156 : bool
31157 6036 : SgUnparse_Info::inArgList() const
31158 6036 : { return checkBit(b_inArgList); }
31159 :
31160 : void
31161 1198130 : SgUnparse_Info::set_inArgList()
31162 1198130 : { setBit(b_inArgList); }
31163 :
31164 : void
31165 967 : SgUnparse_Info::unset_inArgList()
31166 967 : { unsetBit(b_inArgList); }
31167 :
31168 : bool
31169 21227 : SgUnparse_Info::SkipSemiColon() const
31170 21227 : { return checkBit(b_SkipSemiColon); }
31171 :
31172 : void
31173 10230 : SgUnparse_Info::set_SkipSemiColon()
31174 10230 : { setBit(b_SkipSemiColon); }
31175 :
31176 : void
31177 5377 : SgUnparse_Info::unset_SkipSemiColon()
31178 5377 : { unsetBit(b_SkipSemiColon); }
31179 :
31180 : bool
31181 7534 : SgUnparse_Info::inEnumDecl() const
31182 7534 : { return checkBit(b_inEnumDecl); }
31183 :
31184 : void
31185 295 : SgUnparse_Info::set_inEnumDecl()
31186 295 : { setBit(b_inEnumDecl); }
31187 :
31188 : void
31189 0 : SgUnparse_Info::unset_inEnumDecl()
31190 0 : { unsetBit(b_inEnumDecl); }
31191 :
31192 : bool
31193 0 : SgUnparse_Info::inTemplateList() const
31194 0 : { return checkBit(b_inTemplateList); }
31195 :
31196 : void
31197 0 : SgUnparse_Info::set_inTemplateList()
31198 0 : { setBit(b_inTemplateList); }
31199 :
31200 : void
31201 0 : SgUnparse_Info::unset_inTemplateList()
31202 0 : { unsetBit(b_inTemplateList); }
31203 :
31204 : bool
31205 333504 : SgUnparse_Info::SkipBaseType() const
31206 333504 : { return checkBit(b_SkipBaseType); }
31207 :
31208 : void
31209 605 : SgUnparse_Info::set_SkipBaseType()
31210 605 : { setBit(b_SkipBaseType); }
31211 :
31212 : void
31213 14347 : SgUnparse_Info::unset_SkipBaseType()
31214 14347 : { unsetBit(b_SkipBaseType); }
31215 :
31216 : bool
31217 48 : SgUnparse_Info::inAggregateInitializer() const
31218 48 : { return checkBit(b_inAggregateInitializer); }
31219 :
31220 : void
31221 231 : SgUnparse_Info::set_inAggregateInitializer()
31222 231 : { setBit(b_inAggregateInitializer); }
31223 :
31224 : void
31225 0 : SgUnparse_Info::unset_inAggregateInitializer()
31226 0 : { unsetBit(b_inAggregateInitializer); }
31227 :
31228 : bool
31229 1599480 : SgUnparse_Info::isWithType() const
31230 1599480 : { return checkBit(b_isWithType); }
31231 :
31232 : void
31233 3560 : SgUnparse_Info::set_isWithType()
31234 3560 : { setBit(b_isWithType); }
31235 :
31236 : void
31237 119 : SgUnparse_Info::unset_isWithType()
31238 119 : { unsetBit(b_isWithType); }
31239 :
31240 : bool
31241 74521 : SgUnparse_Info::inConditional() const
31242 74521 : { return checkBit(b_inConditional); }
31243 :
31244 : void
31245 1344 : SgUnparse_Info::set_inConditional()
31246 1344 : { setBit(b_inConditional); }
31247 :
31248 : void
31249 863 : SgUnparse_Info::unset_inConditional()
31250 863 : { unsetBit(b_inConditional); }
31251 :
31252 : // DQ (1/23/03) Modified use of SkipDefinition to separate the functionality across
31253 : // different types of definitions (Enum, Function, and Class definitions).
31254 : bool
31255 22358 : SgUnparse_Info::SkipDefinition() const
31256 : { // return checkBit(b_SkipDefinition);
31257 44716 : return checkBit(b_SkipEnumDefinition) &&
31258 44716 : checkBit(b_SkipFunctionDefinition) &&
31259 22358 : checkBit(b_SkipClassDefinition);
31260 : }
31261 :
31262 : void
31263 39540 : SgUnparse_Info::set_SkipDefinition()
31264 : {
31265 : // setBit(b_SkipDefinition);
31266 39540 : setBit(b_SkipEnumDefinition);
31267 39540 : setBit(b_SkipFunctionDefinition);
31268 39540 : setBit(b_SkipClassDefinition);
31269 39540 : }
31270 :
31271 : void
31272 0 : SgUnparse_Info::unset_SkipDefinition()
31273 : {
31274 : // unsetBit(b_SkipDefinition);
31275 0 : unsetBit(b_SkipEnumDefinition);
31276 0 : unsetBit(b_SkipFunctionDefinition);
31277 0 : unsetBit(b_SkipClassDefinition);
31278 0 : }
31279 :
31280 : bool
31281 106481 : SgUnparse_Info::SkipClassSpecifier() const
31282 106481 : { return checkBit(b_SkipClassSpecifier); }
31283 :
31284 : void
31285 255913 : SgUnparse_Info::set_SkipClassSpecifier()
31286 255913 : { setBit(b_SkipClassSpecifier); }
31287 :
31288 : void
31289 1817 : SgUnparse_Info::unset_SkipClassSpecifier()
31290 1817 : { unsetBit(b_SkipClassSpecifier); }
31291 :
31292 : bool
31293 9754 : SgUnparse_Info::inEmbeddedDecl() const
31294 9754 : { return checkBit(b_inEmbeddedDecl); }
31295 :
31296 : void
31297 3592 : SgUnparse_Info::set_inEmbeddedDecl()
31298 3592 : { setBit(b_inEmbeddedDecl); }
31299 :
31300 : void
31301 4264 : SgUnparse_Info::unset_inEmbeddedDecl()
31302 4264 : { unsetBit(b_inEmbeddedDecl); }
31303 :
31304 : bool
31305 0 : SgUnparse_Info::SkipGlobal() const
31306 0 : { return checkBit(b_SkipGlobal); }
31307 :
31308 : void
31309 0 : SgUnparse_Info::set_SkipGlobal()
31310 0 : { setBit(b_SkipGlobal); }
31311 :
31312 : void
31313 0 : SgUnparse_Info::unset_SkipGlobal()
31314 0 : { unsetBit(b_SkipGlobal); }
31315 :
31316 : bool
31317 0 : SgUnparse_Info::SkipAtomic() const
31318 0 : { return checkBit(b_SkipAtomic); }
31319 :
31320 : void
31321 0 : SgUnparse_Info::set_SkipAtomic()
31322 0 : { setBit(b_SkipAtomic); }
31323 :
31324 : void
31325 0 : SgUnparse_Info::unset_SkipAtomic()
31326 0 : { unsetBit(b_SkipAtomic); }
31327 :
31328 : bool
31329 584 : SgUnparse_Info::PrintName() const
31330 584 : { return checkBit(b_PrintName); }
31331 :
31332 : void
31333 639 : SgUnparse_Info::set_PrintName()
31334 : {
31335 : #if 0
31336 : mprintf ("p_var_name.is_null() = %s p_var_name = %s \n",p_var_name.is_null() ? "true" : "false",p_var_name.str());
31337 :
31338 : // This is the older version of the code (dependent on an internal variable that was easy to forget to set).
31339 : if(!p_var_name.is_null())
31340 : {
31341 : setBit(b_PrintName);
31342 : }
31343 : else
31344 : {
31345 : mprintf ("PrintName is not set! \n");
31346 : }
31347 : #else
31348 : // DQ (7/30/2012): I like this simpler semantics better.
31349 639 : setBit(b_PrintName);
31350 : #endif
31351 : #if 0
31352 : mprintf ("Leaving set_PrintName(): PrintName() = %s \n",PrintName() ? "true" : "false");
31353 : #endif
31354 639 : }
31355 :
31356 : void
31357 5106 : SgUnparse_Info::unset_PrintName()
31358 5106 : { unsetBit(b_PrintName); }
31359 :
31360 : bool
31361 15323 : SgUnparse_Info::CheckAccess() const
31362 15323 : { return checkBit(b_CheckAccess); }
31363 :
31364 : void
31365 11922 : SgUnparse_Info::set_CheckAccess()
31366 11922 : { setBit(b_CheckAccess); }
31367 :
31368 : void
31369 58208 : SgUnparse_Info::unset_CheckAccess()
31370 58208 : { unsetBit(b_CheckAccess); }
31371 :
31372 : bool
31373 357 : SgUnparse_Info::SkipFunctionQualifier() const
31374 357 : { return checkBit(b_SkipFunctionQualifier); }
31375 :
31376 : void
31377 5196 : SgUnparse_Info::set_SkipFunctionQualifier()
31378 5196 : { setBit(b_SkipFunctionQualifier); }
31379 :
31380 : void
31381 0 : SgUnparse_Info::unset_SkipFunctionQualifier()
31382 0 : { unsetBit(b_SkipFunctionQualifier); }
31383 :
31384 : bool
31385 0 : SgUnparse_Info::isArrayType() const
31386 0 : { return checkBit(b_isArrayType); }
31387 :
31388 : void
31389 0 : SgUnparse_Info::set_isArrayType()
31390 0 : { setBit(b_isArrayType); }
31391 :
31392 : void
31393 0 : SgUnparse_Info::unset_isArrayType()
31394 0 : { unsetBit(b_isArrayType); }
31395 :
31396 : bool
31397 0 : SgUnparse_Info::inRhsExpr() const
31398 0 : { return checkBit(b_inRhsExpr); }
31399 :
31400 : void
31401 0 : SgUnparse_Info::set_inRhsExpr()
31402 0 : { setBit(b_inRhsExpr); }
31403 :
31404 : void
31405 0 : SgUnparse_Info::unset_inRhsExpr()
31406 0 : { unsetBit(b_inRhsExpr); }
31407 :
31408 : bool
31409 0 : SgUnparse_Info::SkipParen() const
31410 0 : { return checkBit(b_SkipParen); }
31411 :
31412 : void
31413 23 : SgUnparse_Info::set_SkipParen()
31414 23 : { setBit(b_SkipParen); }
31415 :
31416 : void
31417 0 : SgUnparse_Info::unset_SkipParen()
31418 0 : { unsetBit(b_SkipParen); }
31419 :
31420 : bool
31421 2479370 : SgUnparse_Info::isTypeSecondPart() const
31422 2479370 : { return checkBit(b_isTypeSecondPart); }
31423 :
31424 : void
31425 60595 : SgUnparse_Info::set_isTypeSecondPart()
31426 60595 : { setBit(b_isTypeSecondPart); unsetBit(b_isTypeFirstPart); }
31427 :
31428 : void
31429 15622 : SgUnparse_Info::unset_isTypeSecondPart()
31430 15622 : { unsetBit(b_isTypeSecondPart); }
31431 :
31432 : bool
31433 1043090 : SgUnparse_Info::isTypeFirstPart() const
31434 1043090 : { return checkBit(b_isTypeFirstPart); }
31435 :
31436 : void
31437 1504700 : SgUnparse_Info::set_isTypeFirstPart()
31438 1504700 : { setBit(b_isTypeFirstPart); unsetBit(b_isTypeSecondPart); }
31439 :
31440 : void
31441 60497 : SgUnparse_Info::unset_isTypeFirstPart()
31442 60497 : { unsetBit( b_isTypeFirstPart); }
31443 :
31444 : std::string
31445 16772 : SgUnparse_Info::get_operator_name()
31446 16772 : { return p_operator_name; }
31447 :
31448 : void
31449 9519 : SgUnparse_Info::set_operator_name(const std::string& on)
31450 : {
31451 9519 : p_operator_name = on;
31452 9519 : }
31453 :
31454 : //! (1/15/03) DQ: Added to support use of unparser in rewrite mechanism
31455 : bool
31456 626 : SgUnparse_Info::SkipInitializer() const
31457 626 : { return checkBit(b_SkipInitializer); }
31458 :
31459 : void
31460 0 : SgUnparse_Info::set_SkipInitializer()
31461 0 : { setBit(b_SkipInitializer); }
31462 :
31463 : void
31464 0 : SgUnparse_Info::unset_SkipInitializer()
31465 0 : { unsetBit(b_SkipInitializer); }
31466 :
31467 : //! (1/15/03) DQ: Added to support use of unparser in rewrite mechanism
31468 : bool
31469 123941 : SgUnparse_Info::SkipComments() const
31470 123941 : { return checkBit(b_SkipComments); }
31471 :
31472 : void
31473 69965 : SgUnparse_Info::set_SkipComments()
31474 69965 : { setBit(b_SkipComments); }
31475 :
31476 : void
31477 0 : SgUnparse_Info::unset_SkipComments()
31478 0 : { unsetBit(b_SkipComments); }
31479 :
31480 : //! (09/03/03) MS: Added to make whitespace optional
31481 : bool
31482 1729160 : SgUnparse_Info::SkipWhitespaces() const
31483 1729160 : { return checkBit(b_SkipWhitespaces); }
31484 :
31485 : void
31486 69965 : SgUnparse_Info::set_SkipWhitespaces()
31487 69965 : { setBit(b_SkipWhitespaces); }
31488 :
31489 : void
31490 0 : SgUnparse_Info::unset_SkipWhitespaces()
31491 0 : { unsetBit(b_SkipWhitespaces); }
31492 :
31493 : //! (1/15/03) DQ: Added to support use of unparser in rewrite mechanism
31494 : bool
31495 70559 : SgUnparse_Info::SkipCPPDirectives() const
31496 70559 : { return checkBit(b_SkipCPPDirectives); }
31497 :
31498 : void
31499 69965 : SgUnparse_Info::set_SkipCPPDirectives()
31500 69965 : { setBit(b_SkipCPPDirectives); }
31501 :
31502 : void
31503 0 : SgUnparse_Info::unset_SkipCPPDirectives()
31504 0 : { unsetBit(b_SkipCPPDirectives); }
31505 :
31506 : bool
31507 9339050 : SgUnparse_Info::SkipEnumDefinition() const
31508 9339050 : { return checkBit(b_SkipEnumDefinition); }
31509 :
31510 : void
31511 1838870 : SgUnparse_Info::set_SkipEnumDefinition()
31512 1838870 : { setBit(b_SkipEnumDefinition); }
31513 :
31514 : void
31515 692 : SgUnparse_Info::unset_SkipEnumDefinition()
31516 692 : { unsetBit(b_SkipEnumDefinition); }
31517 :
31518 : bool
31519 8633 : SgUnparse_Info::SkipFunctionDefinition() const
31520 8633 : { return checkBit(b_SkipFunctionDefinition); }
31521 :
31522 : void
31523 846 : SgUnparse_Info::set_SkipFunctionDefinition()
31524 846 : { setBit(b_SkipFunctionDefinition); }
31525 :
31526 : void
31527 846 : SgUnparse_Info::unset_SkipFunctionDefinition()
31528 846 : { unsetBit(b_SkipFunctionDefinition); }
31529 :
31530 : bool
31531 9490980 : SgUnparse_Info::SkipClassDefinition() const
31532 9490980 : { return checkBit(b_SkipClassDefinition); }
31533 :
31534 : void
31535 1839230 : SgUnparse_Info::set_SkipClassDefinition()
31536 1839230 : { setBit(b_SkipClassDefinition); }
31537 :
31538 : void
31539 692 : SgUnparse_Info::unset_SkipClassDefinition()
31540 692 : { unsetBit(b_SkipClassDefinition); }
31541 :
31542 : bool
31543 1808 : SgUnparse_Info::AddSemiColonAfterDeclaration() const
31544 1808 : { return checkBit(b_AddSemiColonAfterDeclaration); }
31545 :
31546 : void
31547 0 : SgUnparse_Info::set_AddSemiColonAfterDeclaration()
31548 0 : { setBit(b_AddSemiColonAfterDeclaration); }
31549 :
31550 : void
31551 0 : SgUnparse_Info::unset_AddSemiColonAfterDeclaration()
31552 0 : { unsetBit(b_AddSemiColonAfterDeclaration); }
31553 :
31554 : bool
31555 1154 : SgUnparse_Info::SkipBasicBlock() const
31556 1154 : { return checkBit(b_SkipBasicBlock); }
31557 :
31558 : void
31559 0 : SgUnparse_Info::set_SkipBasicBlock()
31560 0 : { setBit(b_SkipBasicBlock); }
31561 :
31562 : void
31563 0 : SgUnparse_Info::unset_SkipBasicBlock()
31564 0 : { unsetBit(b_SkipBasicBlock); }
31565 :
31566 : // DQ (3/18/2004): Added to support unparsing of class templates in variables but
31567 : // not in in instatiated template declarations (unless the template is transformed
31568 : // in which case another test is used).
31569 : bool
31570 0 : SgUnparse_Info::outputClassTemplateName() const
31571 0 : { return checkBit(b_outputClassTemplateName); }
31572 :
31573 : void
31574 0 : SgUnparse_Info::set_outputClassTemplateName()
31575 0 : { setBit(b_outputClassTemplateName); }
31576 :
31577 : void
31578 0 : SgUnparse_Info::unset_outputClassTemplateName()
31579 0 : { unsetBit(b_outputClassTemplateName); }
31580 :
31581 : // DQ (5/27/2005): support (see documentation above, in header file enum value)
31582 : bool
31583 1417120 : SgUnparse_Info::outputCompilerGeneratedStatements() const
31584 1417120 : { return checkBit(b_outputCompilerGeneratedStatements); }
31585 :
31586 : void
31587 1535250 : SgUnparse_Info::set_outputCompilerGeneratedStatements()
31588 1535250 : { setBit(b_outputCompilerGeneratedStatements); }
31589 :
31590 : void
31591 0 : SgUnparse_Info::unset_outputCompilerGeneratedStatements()
31592 0 : { unsetBit(b_outputCompilerGeneratedStatements); }
31593 :
31594 :
31595 : // DQ (4/5/2006): Added support for constant folded values to be optionally output
31596 : bool
31597 378 : SgUnparse_Info::SkipConstantFoldedExpressions() const
31598 378 : { return checkBit(b_SkipConstantFoldedExpressions); }
31599 :
31600 : void
31601 0 : SgUnparse_Info::set_SkipConstantFoldedExpressions()
31602 0 : { setBit(b_SkipConstantFoldedExpressions); }
31603 :
31604 : void
31605 0 : SgUnparse_Info::unset_SkipConstantFoldedExpressions()
31606 0 : { unsetBit(b_SkipConstantFoldedExpressions); }
31607 :
31608 :
31609 : // DQ and PC (6/1/2006): Added Peter's suggested fixes to support unparsing fully qualified names.
31610 : bool
31611 6699 : SgUnparse_Info::forceQualifiedNames() const
31612 6699 : { return checkBit(b_forceQualifiedNames); }
31613 :
31614 : void
31615 48082 : SgUnparse_Info::set_forceQualifiedNames()
31616 48082 : { setBit(b_forceQualifiedNames); }
31617 :
31618 : void
31619 0 : SgUnparse_Info::unset_forceQualifiedNames()
31620 0 : { unsetBit(b_forceQualifiedNames); }
31621 :
31622 : bool
31623 1265 : SgUnparse_Info::skipCheckAccess() const
31624 1265 : { return checkBit(b_skipCheckAccess); }
31625 :
31626 : void
31627 0 : SgUnparse_Info::set_skipCheckAccess()
31628 0 : { setBit(b_skipCheckAccess); }
31629 :
31630 : void
31631 0 : SgUnparse_Info::unset_skipCheckAccess()
31632 0 : { unsetBit(b_skipCheckAccess); }
31633 :
31634 : // DQ (10/11/2006): Added to support new implementation of name qualification
31635 : bool
31636 0 : SgUnparse_Info::SkipQualifiedNames() const
31637 0 : { return checkBit(b_SkipQualifiedNames); }
31638 :
31639 : void
31640 396 : SgUnparse_Info::set_SkipQualifiedNames()
31641 396 : { setBit(b_SkipQualifiedNames); }
31642 :
31643 : void
31644 0 : SgUnparse_Info::unset_SkipQualifiedNames()
31645 0 : { unsetBit(b_SkipQualifiedNames); }
31646 :
31647 : bool
31648 273295 : SgUnparse_Info::requiresGlobalNameQualification() const
31649 273295 : { return checkBit(b_requiresGlobalNameQualification); }
31650 :
31651 : void
31652 104982 : SgUnparse_Info::set_requiresGlobalNameQualification()
31653 104982 : { setBit(b_requiresGlobalNameQualification); }
31654 :
31655 : void
31656 0 : SgUnparse_Info::unset_requiresGlobalNameQualification()
31657 0 : { unsetBit(b_requiresGlobalNameQualification); }
31658 :
31659 : // DQ (9/22/2007): Added optional handling of Fortran type attributes, these may have to be setup for each different kind of type attribute.
31660 : bool
31661 0 : SgUnparse_Info::useTypeAttributes() const
31662 0 : { return checkBit(b_useTypeAttributes); }
31663 :
31664 : void
31665 0 : SgUnparse_Info::set_useTypeAttributes()
31666 0 : { setBit(b_useTypeAttributes); }
31667 :
31668 : void
31669 0 : SgUnparse_Info::unset_useTypeAttributes()
31670 0 : { unsetBit(b_useTypeAttributes); }
31671 :
31672 : // DQ (12/26/2007): Added support to restrict formatting of Fortran code.
31673 : // This allows us to put statements on the same line as if-stmt, where-stmt, etc.
31674 : // Plus it allows us to skip the insertion of leading 6 spaces in fixed format output.
31675 : bool
31676 417 : SgUnparse_Info::SkipFormatting() const
31677 417 : { return checkBit(b_SkipFormatting); }
31678 :
31679 : void
31680 1 : SgUnparse_Info::set_SkipFormatting()
31681 1 : { setBit(b_SkipFormatting); }
31682 :
31683 : void
31684 0 : SgUnparse_Info::unset_SkipFormatting()
31685 0 : { unsetBit(b_SkipFormatting); }
31686 :
31687 : // DQ (9/22/2007): Added optional handling of Fortran type attributes, these may have to be setup for each different kind of type attribute.
31688 : bool
31689 7 : SgUnparse_Info::supressStrippedTypeName() const
31690 7 : { return checkBit(b_supressStrippedTypeName); }
31691 :
31692 : void
31693 7 : SgUnparse_Info::set_supressStrippedTypeName()
31694 7 : { setBit(b_supressStrippedTypeName); }
31695 :
31696 : void
31697 0 : SgUnparse_Info::unset_supressStrippedTypeName()
31698 0 : { unsetBit(b_supressStrippedTypeName); }
31699 :
31700 :
31701 : SgName&
31702 0 : SgUnparse_Info::get_name()
31703 0 : { return p_var_name; }
31704 :
31705 : void
31706 0 : SgUnparse_Info::set_name(const SgName& name)
31707 0 : { p_var_name = name; set_PrintName(); }
31708 :
31709 : void
31710 0 : SgUnparse_Info::unset_name()
31711 : {
31712 0 : unset_PrintName();
31713 0 : p_var_name=0;
31714 0 : }
31715 :
31716 : SgDeclarationStatement*
31717 3397 : SgUnparse_Info::get_decl_stmt()
31718 3397 : { return p_declstatement_ptr; }
31719 :
31720 : void
31721 0 : SgUnparse_Info::set_decl_stmt(SgDeclarationStatement* stmt )
31722 0 : { p_declstatement_ptr = stmt; }
31723 :
31724 : void
31725 0 : SgUnparse_Info::unset_decl_stmt()
31726 0 : { p_declstatement_ptr=0; }
31727 :
31728 : int
31729 7384 : SgUnparse_Info::get_nested_expression()
31730 7384 : { return p_nested_expression; }
31731 :
31732 : void
31733 11232 : SgUnparse_Info::set_nested_expression()
31734 11232 : { p_nested_expression++; }
31735 :
31736 : void
31737 11231 : SgUnparse_Info::unset_nested_expression()
31738 11231 : { p_nested_expression--; }
31739 :
31740 :
31741 : #if 0
31742 : // DQ (11/21/2021): Adding support for types to be unparsed with the context of the correct declaration to support multi-file handling.
31743 : SgDeclarationStatement*
31744 : SgUnparse_Info::get_declaration_of_context()
31745 : { return p_declaration_of_context; }
31746 :
31747 : // DQ (11/21/2021): Adding support for types to be unparsed with the context of the correct declaration to support multi-file handling.
31748 : void
31749 : SgUnparse_Info::set_declaration_of_context(SgDeclarationStatement* d )
31750 : { p_declaration_of_context = d; }
31751 : #endif
31752 :
31753 : // DQ (11/21/2021): Adding support for types to be unparsed with the context of the correct declaration to support multi-file handling.
31754 : void
31755 0 : SgUnparse_Info::unset_declaration_of_context()
31756 0 : { p_declaration_of_context = NULL; }
31757 :
31758 : void
31759 0 : SgUnparse_Info::unset_current_context()
31760 0 : { p_current_context = NULL; }
31761 :
31762 : SgName
31763 0 : SgUnparse_Info::get_array_index_list()
31764 0 : { return p_array_index_list; }
31765 :
31766 : void
31767 0 : SgUnparse_Info::set_array_index_list(SgExpression *e, SgUnparse_Info finfo )
31768 : {
31769 : #if 1
31770 0 : mprintf ("ERROR: not implemented in SAGE3! \n");
31771 0 : ROSE_ABORT();
31772 : #else
31773 : p_array_index_list << "[";
31774 : ostringstream buffer;
31775 : if(e) e->unparse(finfo,buffer);
31776 : p_array_index_list << buffer.str() << "]";
31777 : #endif
31778 : }
31779 :
31780 : void
31781 0 : SgUnparse_Info::unset_array_index_list()
31782 0 : { p_array_index_list=0; }
31783 :
31784 : // FMZ : Added to support to generated XX.rose_mod file for a module
31785 : // (based on fortran unparser).
31786 : bool
31787 1177 : SgUnparse_Info::outputFortranModFile() const
31788 1177 : { return checkBit(b_outputFortranModFile); }
31789 :
31790 : void
31791 0 : SgUnparse_Info::set_outputFortranModFile()
31792 0 : { setBit(b_outputFortranModFile); }
31793 :
31794 : void
31795 0 : SgUnparse_Info::unset_outputFortranModFile()
31796 0 : { unsetBit(b_outputFortranModFile); }
31797 :
31798 :
31799 : // DQ (4/13/2013): Added support to mark overloaded operators as prefix operators so they can be unparsed before the lhs.
31800 : bool
31801 0 : SgUnparse_Info::isPrefixOperator() const
31802 0 : { return checkBit(b_prefixOperator); }
31803 :
31804 : void
31805 1 : SgUnparse_Info::set_prefixOperator()
31806 1 : { setBit(b_prefixOperator); }
31807 :
31808 : void
31809 0 : SgUnparse_Info::unset_prefixOperator()
31810 0 : { unsetBit(b_prefixOperator); }
31811 :
31812 : // DQ (2/2/2014): Supress output of array bound in array type. Used to support array declearations with empty bracket syntax (e.g. int array[];).
31813 1266 : bool SgUnparse_Info::supressArrayBound() const
31814 1266 : { return checkBit(b_supressArrayBound); }
31815 :
31816 0 : void SgUnparse_Info::set_supressArrayBound()
31817 0 : { setBit(b_supressArrayBound); }
31818 :
31819 0 : void SgUnparse_Info::unset_supressArrayBound()
31820 0 : { unsetBit(b_supressArrayBound); }
31821 :
31822 :
31823 : // DQ (9/3/2014): Supress output of this operator where compiler generated (required to support lambda function code generation).
31824 8256 : bool SgUnparse_Info::supressImplicitThisOperator() const
31825 8256 : { return checkBit(b_supressImplicitThisOperator); }
31826 :
31827 0 : void SgUnparse_Info::set_supressImplicitThisOperator()
31828 0 : { setBit(b_supressImplicitThisOperator); }
31829 :
31830 0 : void SgUnparse_Info::unset_supressImplicitThisOperator()
31831 0 : { unsetBit(b_supressImplicitThisOperator); }
31832 :
31833 : // DQ (12/5/2014): Record that the statement was partially unparsed using the token stream.
31834 241696 : bool SgUnparse_Info::unparsedPartiallyUsingTokenStream() const
31835 241696 : { return checkBit(b_unparsedPartiallyUsingTokenStream); }
31836 :
31837 0 : void SgUnparse_Info::set_unparsedPartiallyUsingTokenStream()
31838 0 : { setBit(b_unparsedPartiallyUsingTokenStream); }
31839 :
31840 0 : void SgUnparse_Info::unset_unparsedPartiallyUsingTokenStream()
31841 0 : { unsetBit(b_unparsedPartiallyUsingTokenStream); }
31842 :
31843 : // DQ (3/25/2015): This is the support required for the offsetof() function family (__offsetof(), __builtin_offsetof(), etc.).
31844 8163 : bool SgUnparse_Info::skipCompilerGeneratedSubExpressions() const
31845 8163 : { return checkBit(b_skipCompilerGeneratedSubExpressions); }
31846 :
31847 0 : void SgUnparse_Info::set_skipCompilerGeneratedSubExpressions()
31848 0 : { setBit(b_skipCompilerGeneratedSubExpressions); }
31849 :
31850 0 : void SgUnparse_Info::unset_skipCompilerGeneratedSubExpressions()
31851 0 : { unsetBit(b_skipCompilerGeneratedSubExpressions); }
31852 :
31853 : // DQ (11/15/2015): Token-based unparsing support for partial token sequence unparsing of lists of statements (controls fromatting).
31854 76127 : bool SgUnparse_Info::parentStatementListBeingUnparsedUsingPartialTokenSequence() const
31855 76127 : { return checkBit(b_parentStatementListBeingUnparsedUsingPartialTokenSequence); }
31856 :
31857 0 : void SgUnparse_Info::set_parentStatementListBeingUnparsedUsingPartialTokenSequence()
31858 0 : { setBit(b_parentStatementListBeingUnparsedUsingPartialTokenSequence); }
31859 :
31860 1685 : void SgUnparse_Info::unset_parentStatementListBeingUnparsedUsingPartialTokenSequence()
31861 1685 : { unsetBit(b_parentStatementListBeingUnparsedUsingPartialTokenSequence); }
31862 :
31863 : // DQ (2/8/2016): Adding support for C++11 specific initialization lists.
31864 : bool
31865 0 : SgUnparse_Info::get_cxx11_initialization_list() const
31866 0 : { return checkBit(b_cxx11_initialization_list); }
31867 :
31868 : void
31869 0 : SgUnparse_Info::set_cxx11_initialization_list()
31870 0 : { setBit(b_cxx11_initialization_list); }
31871 :
31872 : void
31873 0 : SgUnparse_Info::unset_cxx11_initialization_list()
31874 0 : { unsetBit(b_cxx11_initialization_list); }
31875 :
31876 : // DQ (2/3/2019): We need to record when we are in a typedef declaration so that when a member pointer base type is used, extra parenthesis can be unparsed).
31877 : bool
31878 322 : SgUnparse_Info::inTypedefDecl() const
31879 322 : { return checkBit(b_inTypedefDecl); }
31880 :
31881 : // DQ (2/3/2019): We need to record when we are in a typedef declaration so that when a member pointer base type is used, extra parenthesis can be unparsed).
31882 : void
31883 23313 : SgUnparse_Info::set_inTypedefDecl()
31884 23313 : { setBit(b_inTypedefDecl); }
31885 :
31886 : // DQ (2/3/2019): We need to record when we are in a typedef declaration so that when a member pointer base type is used, extra parenthesis can be unparsed).
31887 : void
31888 5191 : SgUnparse_Info::unset_inTypedefDecl()
31889 5191 : { unsetBit(b_inTypedefDecl); }
31890 :
31891 : // DQ (4/13/2019): unparsing for generated template instantiations need to sometime skip the initial name qualification.
31892 : bool
31893 3941 : SgUnparse_Info::SkipNameQualification() const
31894 3941 : { return checkBit(b_SkipNameQualification); }
31895 :
31896 : // DQ (4/13/2019): unparsing for generated template instantiations need to sometime skip the initial name qualification.
31897 : void
31898 3592 : SgUnparse_Info::set_SkipNameQualification()
31899 3592 : { setBit(b_SkipNameQualification); }
31900 :
31901 : // DQ (4/13/2019): unparsing for generated template instantiations need to sometime skip the initial name qualification.
31902 : void
31903 3941 : SgUnparse_Info::unset_SkipNameQualification()
31904 3941 : { unsetBit(b_SkipNameQualification); }
31905 :
31906 : // DQ (12/26/2019): unparsing for defining declarations in named types defined in multiple translation units (multi-file support).
31907 : bool
31908 438 : SgUnparse_Info::useAlternativeDefiningDeclaration() const
31909 438 : { return checkBit(b_useAlternativeDefiningDeclaration); }
31910 :
31911 : void
31912 2 : SgUnparse_Info::set_useAlternativeDefiningDeclaration()
31913 2 : { setBit(b_useAlternativeDefiningDeclaration); }
31914 :
31915 : void
31916 0 : SgUnparse_Info::unset_useAlternativeDefiningDeclaration()
31917 0 : { unsetBit(b_useAlternativeDefiningDeclaration); }
31918 :
31919 : // DQ (1/6/2021): Adding support to detect use of unparseToString() functionality. This is required to avoid premature saving of state
31920 : // regarding the static previouslyUnparsedTokenSubsequences which is required to support multiple statements (e.g. a variable declarations
31921 : // with containing multiple variables which translates (typically) to multiple variable declarations (each with one variable) within the AST).
31922 : bool
31923 0 : SgUnparse_Info::usedInUparseToStringFunction() const
31924 0 : { return checkBit(b_usedInUparseToStringFunction); }
31925 :
31926 : void
31927 1659190 : SgUnparse_Info::set_usedInUparseToStringFunction()
31928 1659190 : { setBit(b_usedInUparseToStringFunction); }
31929 :
31930 : void
31931 0 : SgUnparse_Info::unset_usedInUparseToStringFunction()
31932 0 : { unsetBit(b_usedInUparseToStringFunction); }
31933 :
31934 :
31935 : void
31936 0 : SgUnparse_Info::display ( const std::string & label ) const
31937 : {
31938 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
31939 0 : printf ("\nInside of SgUnparse_Info::display(%s) \n",label.c_str());
31940 :
31941 : #if 0
31942 : #define PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(XX) mprintf (#XX" = %s \n",(XX() == true) ? "true" : "false");
31943 :
31944 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(isPointerToSomething)
31945 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(isReferenceToSomething)
31946 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inVarDecl)
31947 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inArgList)
31948 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipSemiColon)
31949 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inEnumDecl)
31950 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inTemplateList)
31951 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipBaseType)
31952 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inAggregateInitializer)
31953 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(isWithType)
31954 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inConditional)
31955 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipDefinition)
31956 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipClassSpecifier)
31957 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inEmbeddedDecl)
31958 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipGlobal)
31959 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipAtomic)
31960 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(PrintName)
31961 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(CheckAccess)
31962 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipFunctionQualifier)
31963 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(isArrayType)
31964 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(inRhsExpr)
31965 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipParen)
31966 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(isTypeSecondPart)
31967 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(isTypeFirstPart)
31968 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipInitializer)
31969 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipComments)
31970 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipCPPDirectives)
31971 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipEnumDefinition)
31972 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipFunctionDefinition)
31973 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipClassDefinition)
31974 : PRINT_INFO_MEMBER_DATA_OUTPUT_MACRO(AddSemiColonAfterDeclaration)
31975 : #else
31976 : // DQ: Note that this provides better formatting of the output!
31977 0 : printf ("isPointerToSomething = %s \n",( isPointerToSomething() == true ) ? "true" : "false");
31978 0 : printf ("isReferenceToSomething = %s \n",( isReferenceToSomething() == true ) ? "true" : "false");
31979 0 : printf ("inVarDecl = %s \n",( inVarDecl() == true ) ? "true" : "false");
31980 0 : printf ("inArgList = %s \n",( inArgList() == true ) ? "true" : "false");
31981 0 : printf ("SkipSemiColon = %s \n",( SkipSemiColon() == true ) ? "true" : "false");
31982 0 : printf ("inEnumDecl = %s \n",( inEnumDecl() == true ) ? "true" : "false");
31983 0 : printf ("inTemplateList = %s \n",( inTemplateList() == true ) ? "true" : "false");
31984 0 : printf ("SkipBaseType = %s \n",( SkipBaseType() == true ) ? "true" : "false");
31985 0 : printf ("inAggregateInitializer = %s \n",( inAggregateInitializer() == true ) ? "true" : "false");
31986 0 : printf ("isWithType = %s \n",( isWithType() == true ) ? "true" : "false");
31987 0 : printf ("inConditional = %s \n",( inConditional() == true ) ? "true" : "false");
31988 0 : printf ("SkipDefinition = %s \n",( SkipDefinition() == true ) ? "true" : "false");
31989 0 : printf ("SkipClassSpecifier = %s \n",( SkipClassSpecifier() == true ) ? "true" : "false");
31990 0 : printf ("inEmbeddedDecl = %s \n",( inEmbeddedDecl() == true ) ? "true" : "false");
31991 0 : printf ("SkipGlobal = %s \n",( SkipGlobal() == true ) ? "true" : "false");
31992 0 : printf ("SkipAtomic = %s \n",( SkipAtomic() == true ) ? "true" : "false");
31993 0 : printf ("PrintName = %s \n",( PrintName() == true ) ? "true" : "false");
31994 0 : printf ("CheckAccess = %s \n",( CheckAccess() == true ) ? "true" : "false");
31995 0 : printf ("SkipFunctionQualifier = %s \n",( SkipFunctionQualifier() == true ) ? "true" : "false");
31996 0 : printf ("isArrayType = %s \n",( isArrayType() == true ) ? "true" : "false");
31997 0 : printf ("inRhsExpr = %s \n",( inRhsExpr() == true ) ? "true" : "false");
31998 0 : printf ("SkipParen = %s \n",( SkipParen() == true ) ? "true" : "false");
31999 0 : printf ("isTypeSecondPart = %s \n",( isTypeSecondPart() == true ) ? "true" : "false");
32000 0 : printf ("isTypeFirstPart = %s \n",( isTypeFirstPart() == true ) ? "true" : "false");
32001 0 : printf ("SkipInitializer = %s \n",( SkipInitializer() == true ) ? "true" : "false");
32002 0 : printf ("SkipComments = %s \n",( SkipComments() == true ) ? "true" : "false");
32003 0 : printf ("SkipCPPDirectives = %s \n",( SkipCPPDirectives() == true ) ? "true" : "false");
32004 0 : printf ("SkipEnumDefinition = %s \n",( SkipEnumDefinition() == true ) ? "true" : "false");
32005 0 : printf ("SkipFunctionDefinition = %s \n",( SkipFunctionDefinition() == true ) ? "true" : "false");
32006 0 : printf ("SkipClassDefinition = %s \n",( SkipClassDefinition() == true ) ? "true" : "false");
32007 0 : printf ("AddSemiColonAfterDeclaration = %s \n",( AddSemiColonAfterDeclaration() == true ) ? "true" : "false");
32008 0 : printf ("SkipWhitespaces = %s \n",( SkipWhitespaces() == true ) ? "true" : "false");
32009 0 : printf ("SkipBasicBlock = %s \n",( SkipBasicBlock() == true ) ? "true" : "false");
32010 0 : printf ("outputClassTemplateName = %s \n",( outputClassTemplateName() == true ) ? "true" : "false");
32011 0 : printf ("outputCompilerGeneratedStatements = %s \n",( outputCompilerGeneratedStatements() == true ) ? "true" : "false");
32012 0 : printf ("SkipConstantFoldedExpressions = %s \n",( SkipConstantFoldedExpressions() == true ) ? "true" : "false");
32013 0 : printf ("forceQualifiedNames = %s \n",( forceQualifiedNames() == true ) ? "true" : "false");
32014 0 : printf ("SkipQualifiedNames = %s \n",( SkipQualifiedNames() == true ) ? "true" : "false");
32015 0 : printf ("skipCheckAccess = %s \n",( skipCheckAccess() == true ) ? "true" : "false");
32016 0 : printf ("requiresGlobalNameQualification = %s \n",( requiresGlobalNameQualification() == true ) ? "true" : "false");
32017 0 : printf ("supressArrayBound = %s \n",( supressArrayBound() == true ) ? "true" : "false");
32018 0 : printf ("supressImplicitThisOperator = %s \n",( supressImplicitThisOperator() == true ) ? "true" : "false");
32019 0 : printf ("unparsedPartiallyUsingTokenStream = %s \n",( unparsedPartiallyUsingTokenStream() == true ) ? "true" : "false");
32020 0 : printf ("skipCompilerGeneratedSubExpressions = %s \n",( skipCompilerGeneratedSubExpressions() == true ) ? "true" : "false");
32021 :
32022 0 : printf ("parentStatementListBeingUnparsedUsingPartialTokenSequence = %s \n",( parentStatementListBeingUnparsedUsingPartialTokenSequence() == true ) ? "true" : "false");
32023 :
32024 : // DQ (2/3/2019): Ading support to know when we are in a typedef.
32025 0 : printf ("inTypedefDecl = %s \n",( inTypedefDecl() == true ) ? "true" : "false");
32026 :
32027 : // DQ (4/13/2019): unparsing for generated template instantiations need to sometime skip the initial name qualification.
32028 0 : printf ("SkipNameQualification = %s \n",( SkipNameQualification() == true ) ? "true" : "false");
32029 : #endif
32030 :
32031 0 : switch (p_access_attribute)
32032 : {
32033 0 : case a_unset_access:
32034 0 : printf ("p_access = unset access \n");
32035 : break;
32036 0 : case a_private_access:
32037 0 : printf ("p_access = private access \n");
32038 : break;
32039 0 : case a_protected_access:
32040 0 : printf ("p_access = protected access \n");
32041 : break;
32042 0 : case a_public_access:
32043 0 : printf ("p_access = public access \n");
32044 : break;
32045 0 : default:
32046 0 : printf ("Error: default reached in switch \n");
32047 0 : assert(false);
32048 : }
32049 :
32050 : // DQ (1/26/2006): Modified to handle 64 bit machines
32051 0 : printf ("p_structureTagProcessingList.size() = %" PRIuPTR " \n", p_structureTagProcessingList.size());
32052 0 : SgTypePtrList::iterator i;
32053 0 : for (i = p_structureTagProcessingList.begin(); i != p_structureTagProcessingList.end(); i++)
32054 : {
32055 : // print out the pointer values
32056 0 : printf ("--- structure tag pointer = %p class name = %s \n",*i,(*i)->sage_class_name());
32057 :
32058 0 : SgClassType* classType = isSgClassType(*i);
32059 0 : if (classType != NULL)
32060 : {
32061 0 : printf (" Class name = %s \n",classType->get_name().str());
32062 : // ROSE_ABORT();
32063 : }
32064 : }
32065 :
32066 0 : printf ("p_nested_expression = %d \n",p_nested_expression);
32067 0 : printf ("p_operator_name = %s \n", p_operator_name.c_str());
32068 0 : printf ("p_var_name = %s \n",(p_var_name.is_null() == false) ? p_var_name.str() : "EmPtY sTrInG");
32069 :
32070 : // printf ("p_declstatement_ptr = %p \n",p_declstatement_ptr);
32071 0 : printf ("p_declstatement_ptr = %p = %s \n",p_declstatement_ptr,p_declstatement_ptr != NULL ? p_declstatement_ptr->class_name().c_str() : "null");
32072 0 : if (p_declstatement_ptr != NULL)
32073 : {
32074 0 : printf (" --- firstNondefiningDeclaration = %p \n",p_declstatement_ptr->get_firstNondefiningDeclaration());
32075 0 : printf (" --- definingDeclaration = %p \n",p_declstatement_ptr->get_definingDeclaration());
32076 : }
32077 :
32078 0 : printf ("p_declaration_of_context = %p \n",p_declaration_of_context);
32079 0 : printf ("p_current_context = %p \n",p_current_context);
32080 0 : printf ("p_array_index_list = %s \n",(p_array_index_list.is_null() == false) ? p_array_index_list.str() : "EmPtY sTrInG");
32081 0 : printf ("p_current_namespace = %p \n",p_current_namespace);
32082 0 : printf ("p_outputCodeGenerationFormatDelimiters = %s \n",p_outputCodeGenerationFormatDelimiters ? "true" : "false");
32083 :
32084 0 : printf ("p_current_function_call = %p \n",p_current_function_call);
32085 0 : printf ("p_current_scope = %p = %s \n",p_current_scope,p_current_scope != NULL ? p_current_scope->class_name().c_str() : "EmPtY sTrInG");
32086 :
32087 : // DQ (5/21/2011): Added support for name qualification...
32088 0 : printf ("p_reference_node_for_qualification = %p = %s \n",p_reference_node_for_qualification,p_reference_node_for_qualification != NULL ? p_reference_node_for_qualification->class_name().c_str() : "EmPtY sTrInG");
32089 :
32090 0 : printf ("p_language (value) = %d \n",p_language);
32091 :
32092 : // DQ (9/24/2013): Added function to output the name of the language for the generated code.
32093 0 : printf ("p_language (name) = %s \n",SgFile::get_outputLanguageOptionName(p_language).c_str());
32094 :
32095 : // DQ (1/10/2015): Added support for debugging the SgUnparse_Info object.
32096 0 : printf ("p_current_source_file = %p = %s \n",p_current_source_file,p_current_source_file != NULL ? p_current_source_file->class_name().c_str() : "EmPtY sTrInG");
32097 :
32098 : // DQ (10/23/2018): Output the name of the file to support debugging of the token based unparsing.
32099 0 : if (p_current_source_file != NULL)
32100 : {
32101 0 : printf (" --- p_current_source_file = %s \n",p_current_source_file->getFileName().c_str());
32102 : }
32103 :
32104 : // DQ (4/28/2017): Added information required for use of generated names in the output of types for template
32105 : // arguments as used in symbol table lookup.
32106 0 : printf ("p_use_generated_name_for_template_arguments = %s \n",p_use_generated_name_for_template_arguments ? "true" : "false");
32107 :
32108 : // DQ (8/15/2020): Record when we are in an extern "C" so that we can avoid nesting (see Cxx_tests/test2020_28.C).
32109 0 : printf ("p_extern_C_with_braces = %s \n",p_extern_C_with_braces ? "true" : "false");
32110 :
32111 : // DQ (8/24/2020): debugging Cxx_tests/test2020_44.C need to communicate when to suppress extra parenthesis use around SgFunctionType arguments.
32112 0 : printf ("p_context_for_added_parentheses = %s \n",p_context_for_added_parentheses ? "true" : "false");
32113 0 : }
32114 :
32115 : string
32116 0 : SgUnparse_Info::displayString ( const std::string & label ) const
32117 : {
32118 : // using namespace std;
32119 0 : std::string returnString = std::string("Inside of SgUnparse_Info::display( ") + label + std::string(" )\n");
32120 :
32121 : #define STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(XX) \
32122 : returnString += std::string(" ") + std::string(#XX) + std::string(" = ") + std::string((XX() == true) ? "true" : "false") + std::string(" \n");
32123 :
32124 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(isPointerToSomething)
32125 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(isReferenceToSomething)
32126 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inVarDecl)
32127 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inArgList)
32128 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipSemiColon)
32129 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inEnumDecl)
32130 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inTemplateList)
32131 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipBaseType)
32132 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inAggregateInitializer)
32133 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(isWithType)
32134 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inConditional)
32135 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipDefinition)
32136 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipClassSpecifier)
32137 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inEmbeddedDecl)
32138 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipGlobal)
32139 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipAtomic)
32140 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(PrintName)
32141 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(CheckAccess)
32142 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipFunctionQualifier)
32143 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(isArrayType)
32144 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inRhsExpr)
32145 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipParen)
32146 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(isTypeSecondPart)
32147 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(isTypeFirstPart)
32148 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipInitializer)
32149 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipComments)
32150 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipCPPDirectives)
32151 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipEnumDefinition)
32152 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipFunctionDefinition)
32153 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(SkipClassDefinition)
32154 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(AddSemiColonAfterDeclaration)
32155 :
32156 : // DQ (2/3/2019): Adding support to know when we are in a typedef.
32157 0 : STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(inTypedefDecl)
32158 :
32159 : // DQ (8/15/2020): Record when we are in an extern "C" so that we can avoid nesting (see Cxx_tests/test2020_28.C).
32160 : // STRINGIFY_INFO_MEMBER_DATA_OUTPUT_MACRO(extern_C_with_braces)
32161 :
32162 0 : switch (p_access_attribute)
32163 : {
32164 0 : case a_unset_access:
32165 0 : returnString += std::string("p_access = unset access \n");
32166 0 : break;
32167 0 : case a_private_access:
32168 0 : returnString += std::string("p_access = private access \n");
32169 0 : break;
32170 0 : case a_protected_access:
32171 0 : returnString += std::string("p_access = protected access \n");
32172 0 : break;
32173 0 : case a_public_access:
32174 0 : returnString += std::string("p_access = public access \n");
32175 0 : break;
32176 0 : default:
32177 0 : printf("Error: default reached in switch \n");
32178 0 : assert(false);
32179 : }
32180 :
32181 0 : returnString += std::string("p_structureTagProcessingList.size() = ") +
32182 0 : Rose::StringUtility::numberToString(p_structureTagProcessingList.size()) + std::string("\n");
32183 0 : SgTypePtrList::iterator i;
32184 0 : for (i = p_structureTagProcessingList.begin(); i != p_structureTagProcessingList.end(); i++)
32185 : {
32186 : // print out the pointer values
32187 0 : returnString += std::string("--- structure tag pointer = ") +
32188 0 : Rose::StringUtility::numberToString((void*)(*i)) +
32189 0 : std::string("= class name = ") + std::string((*i)->sage_class_name()) + std::string("\n");
32190 0 : SgClassType* classType = isSgClassType(*i);
32191 0 : if (classType != NULL)
32192 : {
32193 0 : returnString += std::string(" Class name = ") + std::string(classType->get_name().str()) + std::string("\n");
32194 : // mprintf (" Class name = %s \n",classType->get_name().str());
32195 : // ROSE_ABORT();
32196 : }
32197 : }
32198 :
32199 0 : return returnString;
32200 : }
32201 :
32202 : void
32203 0 : SgUnparse_Info::addStructureTag ( SgNamedType* structureTag )
32204 : {
32205 : // push the pointer to the back of the list
32206 0 : p_structureTagProcessingList.push_back(structureTag);
32207 0 : }
32208 :
32209 : SgTypePtrList &
32210 0 : SgUnparse_Info::getStructureTagList ()
32211 : {
32212 : // Access function for internal STL list
32213 0 : return p_structureTagProcessingList;
32214 : }
32215 :
32216 : void
32217 0 : SgUnparse_Info::inc_nestingLevel() {
32218 0 : p_nestingLevel += 1;
32219 0 : }
32220 :
32221 : void
32222 0 : SgUnparse_Info::dec_nestingLevel() {
32223 0 : p_nestingLevel -= 1;
32224 0 : if (p_nestingLevel < 0) {
32225 0 : cerr << "warning: SgUnparse_Info.p_nestingLevel decremented below zero." << endl;
32226 : }
32227 0 : }
32228 :
32229 :
32230 :
32231 : // End of memberFunctionString
32232 : // Start of memberFunctionString
32233 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
32234 :
32235 : // *** COMMON CODE SECTION BEGINS HERE ***
32236 :
32237 : #if 0
32238 : int
32239 : SgUnparse_Info::getVariant() const
32240 : {
32241 : // This function is used in ROSE while "variant()" is used in SAGE
32242 : assert(this != NULL);
32243 : return variant();
32244 : }
32245 : #endif
32246 :
32247 : // This function is used in ROSE in treeTraversal code
32248 : // eventually replaces getVariant() and variant()
32249 : // though after variant() has been removed for a while we will
32250 : // want to change the name of variantT() back to variant()
32251 : // (since the "T" was ment to stand for temporary).
32252 : // When this happens the variantT() will be depricated.
32253 : VariantT
32254 3324940 : SgUnparse_Info::variantT() const
32255 : {
32256 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
32257 3324940 : ROSE_ASSERT(this != NULL);
32258 3324940 : return V_SgUnparse_Info;
32259 : }
32260 :
32261 : #if 0
32262 : int
32263 : SgUnparse_Info::variant() const
32264 : {
32265 : // This function is used in SAGE
32266 : ROSE_ASSERT(this != NULL);
32267 : return Unparse_InfoTag;
32268 : }
32269 : #endif
32270 :
32271 : ROSE_DLL_API const char*
32272 0 : SgUnparse_Info::sage_class_name() const
32273 : {
32274 0 : ROSE_ASSERT(this != NULL);
32275 0 : return "SgUnparse_Info";
32276 : }
32277 :
32278 : std::string
32279 0 : SgUnparse_Info::class_name() const
32280 : {
32281 0 : ROSE_ASSERT(this != NULL);
32282 0 : return "SgUnparse_Info";
32283 : }
32284 :
32285 : // DQ (11/26/2005): Support for visitor pattern mechanims
32286 : // (inferior to ROSE traversal mechanism, experimental).
32287 : void
32288 0 : SgUnparse_Info::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
32289 : {
32290 0 : ROSE_ASSERT(this != NULL);
32291 0 : visitor.visit(this);
32292 0 : }
32293 :
32294 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
32295 0 : void SgUnparse_Info::accept (ROSE_VisitorPattern & visitor) {
32296 0 : ROSE_ASSERT(this != NULL);
32297 0 : visitor.visit(this);
32298 0 : }
32299 :
32300 : SgUnparse_Info*
32301 0 : SgUnparse_Info::addRegExpAttribute(std::string s, AstRegExAttribute* a)
32302 : {
32303 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
32304 : // This function is currently only supported for the AST used the represent Binary executables.
32305 : if (0 /* isSgAsmNode(this) != NULL */)
32306 : {
32307 : // Support for regex specification.
32308 : std::string prefixCode = "REGEX:";
32309 : addNewAttribute(prefixCode + s,a);
32310 : }
32311 : #endif
32312 :
32313 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
32314 0 : return this;
32315 : }
32316 :
32317 : // *** COMMON CODE SECTION ENDS HERE ***
32318 :
32319 :
32320 : // End of memberFunctionString
32321 : // Start of memberFunctionString
32322 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
32323 :
32324 :
32325 : #if 0
32326 : //! Error checking support
32327 : /*! Verifies the following:
32328 : - working getVariant() member function
32329 : - calls base class's error() member function
32330 : Every class has one of these functions.
32331 : */
32332 : bool
32333 : SgUnparse_Info::error()
32334 : {
32335 : // Put error checking here
32336 :
32337 : ROSE_ASSERT (this != NULL);
32338 : if (getVariant() != Unparse_InfoTag)
32339 : {
32340 : printf ("Error in SgUnparse_Info::error(): SgUnparse_Info object has a %s variant \n",
32341 : Cxx_GrammarTerminalNames[getVariant()].name);
32342 : // printf ("Error in SgUnparse_Info::error() \n");
32343 : ROSE_ABORT();
32344 : }
32345 :
32346 : ROSE_ASSERT (getVariant() == Unparse_InfoTag);
32347 : return SgSupport::error();
32348 : }
32349 : #endif
32350 :
32351 :
32352 :
32353 : // End of memberFunctionString
32354 :
32355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
32356 :
32357 1662470 : SgUnparse_Info* isSgUnparse_Info ( SgNode* inputDerivedClassPointer )
32358 : {
32359 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
32360 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
32361 : // So to fix this we return NULL directly when the input is NULL and avoid the
32362 : // dynamic_cast in this case. This is likely a performance improvement as well.
32363 : // return dynamic_cast<SgUnparse_Info*>(inputDerivedClassPointer);
32364 : // Milind Chabbi (8/28/2013): isSgUnparse_Info uses table-driven castability instead of c++ default dynamic_cast
32365 : // this improves the running time performance by 10-20%.
32366 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnparse_Info*>(inputDerivedClassPointer);
32367 1662470 : return IS_SgUnparse_Info_FAST_MACRO(inputDerivedClassPointer);
32368 : }
32369 :
32370 : // DQ (11/8/2003): Added version of functions taking const pointer
32371 0 : const SgUnparse_Info* isSgUnparse_Info ( const SgNode* inputDerivedClassPointer )
32372 : {
32373 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
32374 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
32375 : // So to fix this we return NULL directly when the input is NULL and avoid the
32376 : // dynamic_cast in this case. This is likely a performance improvement as well.
32377 : // return dynamic_cast<const SgUnparse_Info*>(inputDerivedClassPointer);
32378 : // Milind Chabbi (8/28/2013): isSgUnparse_Info uses table-driven castability instead of c++ default dynamic_cast
32379 : // this improves the running time performance by 10-20%.
32380 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnparse_Info*>(inputDerivedClassPointer);
32381 0 : return IS_SgUnparse_Info_FAST_MACRO(inputDerivedClassPointer);
32382 : }
32383 :
32384 :
32385 :
32386 : /* #line 32387 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
32387 :
32388 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
32389 :
32390 : /**
32391 : \brief Generated destructor
32392 :
32393 : This destructor is automatically generated (by ROSETTA). This destructor
32394 : only frees memory of data members associated with the parts of the current IR node which
32395 : are NOT traversed. Those data members that are part of a traversal can be freed using
32396 : a traversal (calling this destructor on all children in a post-order traversal). Such
32397 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
32398 :
32399 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
32400 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
32401 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
32402 :
32403 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
32404 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
32405 : pointers are not yet implemented to call delete on eash pointer in the container.
32406 : (This could be done by derivation from the STL containers to define containers that
32407 : automatically deleted their members.)
32408 :
32409 : */
32410 5105130 : SgUnparse_Info::~SgUnparse_Info () {
32411 3479690 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
32412 :
32413 :
32414 : // case: not a listType for access_attribute
32415 3479690 : p_access_attribute = 0; // non list case
32416 : // case: not a listType for nested_expression
32417 3479690 : p_nested_expression = 0; // non list case
32418 : // case: not a listType for operator_name
32419 3479690 : p_operator_name = ""; // non list case
32420 : // case: not a listType for var_name
32421 3479690 : p_var_name = ""; // non list case
32422 : // case: not a listType for declstatement_ptr
32423 3479690 : p_declstatement_ptr = NULL; // non list case
32424 : // case: not a listType for declaration_of_context
32425 3479690 : p_declaration_of_context = NULL; // non list case
32426 : // case: not a listType for current_context
32427 3479690 : p_current_context = NULL; // non list case
32428 : // case: not a listType for array_index_list
32429 3479690 : p_array_index_list = ""; // non list case
32430 : // case: not a listType for current_namespace
32431 3479690 : p_current_namespace = NULL; // non list case
32432 : // case: not a listType for outputCodeGenerationFormatDelimiters
32433 3479690 : p_outputCodeGenerationFormatDelimiters = false; // non list case
32434 : // case: listType for qualifiedNameList
32435 : // case: listType (typeIsPointerToList == false) for qualifiedNameList
32436 3479690 : p_qualifiedNameList.erase(p_qualifiedNameList.begin(),p_qualifiedNameList.end());
32437 : // case: not a listType for current_function_call
32438 3479690 : p_current_function_call = NULL; // non list case
32439 : // case: not a listType for current_scope
32440 3479690 : p_current_scope = NULL; // non list case
32441 : // case: not a listType for reference_node_for_qualification
32442 3479690 : p_reference_node_for_qualification = NULL; // non list case
32443 : // case: not a listType for name_qualification_length
32444 3479690 : p_name_qualification_length = 0; // non list case
32445 : // case: not a listType for type_elaboration_required
32446 3479690 : p_type_elaboration_required = false; // non list case
32447 : // case: not a listType for global_qualification_required
32448 3479690 : p_global_qualification_required = false; // non list case
32449 : // case: not a listType for nestingLevel
32450 3479690 : p_nestingLevel = 0; // non list case
32451 : // case: not a listType for language
32452 3479690 : p_language = SgFile::e_default_language; // non list case
32453 : // case: not a listType for current_source_file
32454 3479690 : p_current_source_file = NULL; // non list case
32455 : // case: not a listType for use_generated_name_for_template_arguments
32456 3479690 : p_use_generated_name_for_template_arguments = false; // non list case
32457 : // case: not a listType for user_defined_literal
32458 3479690 : p_user_defined_literal = false; // non list case
32459 : // case: not a listType for declstatement_associated_with_type
32460 3479690 : p_declstatement_associated_with_type = NULL; // non list case
32461 : // case: not a listType for context_for_added_parentheses
32462 3479690 : p_context_for_added_parentheses = false; // non list case
32463 :
32464 : }
32465 :
32466 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
32467 5105130 : }
32468 :
32469 :
32470 : /* #line 32471 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
32471 :
32472 :
32473 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
32474 :
32475 :
32476 : // ********************************************************
32477 : // member functions common across all array grammar objects
32478 : // ********************************************************
32479 :
32480 :
32481 :
32482 : /* #line 32483 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
32483 :
32484 :
32485 :
32486 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
32487 :
32488 : // ********************************************************
32489 : // member functions specific to each node in the grammar
32490 : // ********************************************************
32491 :
32492 :
32493 : /* #line 32494 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
32494 :
32495 : // Start of memberFunctionString
32496 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
32497 :
32498 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
32499 :
32500 : SgClassDeclaration*
32501 66127 : SgBaseClass::get_base_class () const
32502 : {
32503 66127 : ROSE_ASSERT (this != NULL);
32504 :
32505 : #if 0
32506 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
32507 : // used to trigger marking transformations for the token-based unparsing.
32508 : printf ("SgBaseClass::get_base_class = %p = %s \n",this,this->class_name().c_str());
32509 : #endif
32510 :
32511 66127 : return p_base_class;
32512 : }
32513 :
32514 : void
32515 0 : SgBaseClass::set_base_class ( SgClassDeclaration* base_class )
32516 : {
32517 0 : ROSE_ASSERT (this != NULL);
32518 :
32519 : #if 0
32520 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
32521 : // used to trigger marking transformations for the token-based unparsing.
32522 : printf ("SgBaseClass::set_base_class = %p = %s \n",this,this->class_name().c_str());
32523 : #endif
32524 :
32525 0 : set_isModified(true);
32526 :
32527 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
32528 : if (p_base_class != NULL && base_class != NULL && p_base_class != base_class)
32529 : {
32530 : printf ("Warning: base_class = %p overwriting valid pointer p_base_class = %p \n",base_class,p_base_class);
32531 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
32532 : printf ("Error fails assertion (p_base_class != NULL && base_class != NULL && p_base_class != base_class) is false\n");
32533 : ROSE_ASSERT(false);
32534 : #endif
32535 : }
32536 : #endif
32537 0 : p_base_class = base_class;
32538 0 : }
32539 :
32540 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
32541 :
32542 :
32543 : // End of memberFunctionString
32544 : // Start of memberFunctionString
32545 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
32546 :
32547 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
32548 :
32549 : bool
32550 0 : SgBaseClass::get_isDirectBaseClass () const
32551 : {
32552 0 : ROSE_ASSERT (this != NULL);
32553 :
32554 : #if 0
32555 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
32556 : // used to trigger marking transformations for the token-based unparsing.
32557 : printf ("SgBaseClass::get_isDirectBaseClass = %p = %s \n",this,this->class_name().c_str());
32558 : #endif
32559 :
32560 0 : return p_isDirectBaseClass;
32561 : }
32562 :
32563 : void
32564 0 : SgBaseClass::set_isDirectBaseClass ( bool isDirectBaseClass )
32565 : {
32566 0 : ROSE_ASSERT (this != NULL);
32567 :
32568 : #if 0
32569 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
32570 : // used to trigger marking transformations for the token-based unparsing.
32571 : printf ("SgBaseClass::set_isDirectBaseClass = %p = %s \n",this,this->class_name().c_str());
32572 : #endif
32573 :
32574 0 : set_isModified(true);
32575 :
32576 0 : p_isDirectBaseClass = isDirectBaseClass;
32577 0 : }
32578 :
32579 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
32580 :
32581 :
32582 : // End of memberFunctionString
32583 : // Start of memberFunctionString
32584 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
32585 :
32586 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
32587 :
32588 : SgBaseClassModifier*
32589 74144 : SgBaseClass::get_baseClassModifier () const
32590 : {
32591 74144 : ROSE_ASSERT (this != NULL);
32592 :
32593 : #if 0
32594 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
32595 : // used to trigger marking transformations for the token-based unparsing.
32596 : printf ("SgBaseClass::get_baseClassModifier = %p = %s \n",this,this->class_name().c_str());
32597 : #endif
32598 :
32599 74144 : return p_baseClassModifier;
32600 : }
32601 :
32602 : void
32603 0 : SgBaseClass::set_baseClassModifier ( SgBaseClassModifier* baseClassModifier )
32604 : {
32605 0 : ROSE_ASSERT (this != NULL);
32606 :
32607 : #if 0
32608 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
32609 : // used to trigger marking transformations for the token-based unparsing.
32610 : printf ("SgBaseClass::set_baseClassModifier = %p = %s \n",this,this->class_name().c_str());
32611 : #endif
32612 :
32613 0 : set_isModified(true);
32614 :
32615 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
32616 : if (p_baseClassModifier != NULL && baseClassModifier != NULL && p_baseClassModifier != baseClassModifier)
32617 : {
32618 : printf ("Warning: baseClassModifier = %p overwriting valid pointer p_baseClassModifier = %p \n",baseClassModifier,p_baseClassModifier);
32619 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
32620 : printf ("Error fails assertion (p_baseClassModifier != NULL && baseClassModifier != NULL && p_baseClassModifier != baseClassModifier) is false\n");
32621 : ROSE_ASSERT(false);
32622 : #endif
32623 : }
32624 : #endif
32625 0 : p_baseClassModifier = baseClassModifier;
32626 0 : }
32627 :
32628 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
32629 :
32630 :
32631 : // End of memberFunctionString
32632 : // Start of memberFunctionString
32633 :
32634 :
32635 : // End of memberFunctionString
32636 : // Start of memberFunctionString
32637 : /* #line 11934 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
32638 :
32639 :
32640 : void
32641 5725 : SgBaseClass::post_construction_initialization()
32642 : {
32643 : // JJW 10-26-2007 ensure that this object is not on the stack
32644 5725 : preventConstructionOnStack(this);
32645 :
32646 : // DQ (4/25/2004): Note that because of limitiations in the ordering of output
32647 : // class declarations in ROSETTA, I was unable make this SgBaseClassModifier a
32648 : // data member and was forced to handle it as a pointer).
32649 5725 : p_baseClassModifier = new SgBaseClassModifier();
32650 5725 : ROSE_ASSERT ( p_baseClassModifier != NULL);
32651 :
32652 : // DQ (5/12/2011): New support for name qualification.
32653 5725 : p_name_qualification_length = 0;
32654 5725 : p_type_elaboration_required = false;
32655 5725 : p_global_qualification_required = false;
32656 5725 : }
32657 :
32658 : #if 0
32659 : // This function should be autogenerated
32660 : SgBaseClass::SgBaseClass(int specifier ,SgClassDeclaration* ptr, int dir)
32661 : : p_specifier(specifier), p_ptr(ptr), p_isDirectBaseClass(dir)
32662 : {
32663 : }
32664 : #endif
32665 :
32666 0 : SgBaseClass::SgBaseClass(const SgBaseClass& X)
32667 : {
32668 : // these are the old names
32669 : // p_specifier = ptr.p_specifier;
32670 : // p_ptr = ptr.p_ptr;
32671 : // p_base_specifier = X.p_base_specifier;
32672 0 : p_base_class = X.p_base_class;
32673 :
32674 : // DQ (6/21/2005): Commented out since it is not used, we might want it later!
32675 : // DQ: initialize all values
32676 0 : p_isDirectBaseClass = 0;
32677 :
32678 0 : ROSE_ASSERT ( X.p_baseClassModifier != NULL);
32679 0 : p_baseClassModifier = new SgBaseClassModifier( *(X.p_baseClassModifier) );
32680 0 : ROSE_ASSERT ( p_baseClassModifier != NULL);
32681 :
32682 : // DQ (5/12/2011): New support for name qualification.
32683 0 : p_name_qualification_length = X.p_name_qualification_length;
32684 0 : p_type_elaboration_required = X.p_type_elaboration_required;
32685 0 : p_global_qualification_required = X.p_global_qualification_required;
32686 0 : }
32687 :
32688 : #if 0
32689 : // generated automatically
32690 : SgBaseClass::~SgBaseClass()
32691 : {
32692 : /* delete p_ptr; */
32693 : }
32694 : #endif
32695 :
32696 : SgBaseClass &
32697 0 : SgBaseClass::operator= (const SgBaseClass & X)
32698 : {
32699 : // Old names
32700 : // p_specifier = ptr.p_specifier;
32701 : // p_direct = ptr.p_direct;
32702 : // p_ptr = ptr.p_ptr;
32703 :
32704 : // p_base_specifier = X.p_base_specifier;
32705 0 : p_base_class = X.p_base_class;
32706 :
32707 : // DQ (6/21/2005): Renamed to make this more clear
32708 0 : p_isDirectBaseClass = X.p_isDirectBaseClass;
32709 :
32710 0 : ROSE_ASSERT (p_baseClassModifier != NULL);
32711 0 : ROSE_ASSERT (X.p_baseClassModifier != NULL);
32712 0 : *p_baseClassModifier = *X.p_baseClassModifier;
32713 :
32714 : // DQ (5/12/2011): New support for name qualification.
32715 0 : p_name_qualification_length = X.p_name_qualification_length;
32716 0 : p_type_elaboration_required = X.p_type_elaboration_required;
32717 0 : p_global_qualification_required = X.p_global_qualification_required;
32718 :
32719 0 : return *this;
32720 : }
32721 :
32722 : #if 0
32723 : // These are automatically generated now!
32724 : int
32725 : SgBaseClass::get_base_specifier() const
32726 : { return p_specifier; }
32727 :
32728 : SgClassDeclaration*
32729 : SgBaseClass::get_base_class() const
32730 : { return p_ptr; }
32731 : #endif
32732 :
32733 : #if 0
32734 : // DQ: I don't think this is used anywhere
32735 : SgClassDeclaration*
32736 : replace_base_class(SgClassDeclaration *);
32737 : #endif
32738 :
32739 : // I assume these relational member functions are added to permit use with STL
32740 : bool
32741 0 : SgBaseClass::operator== (const SgBaseClass& ) const
32742 0 : { return false; }
32743 :
32744 : bool
32745 0 : SgBaseClass::operator< (const SgBaseClass&) const
32746 0 : { return false; }
32747 :
32748 : #if 0
32749 : // DQ (1/21/2019): This should be an automatically generated access function.
32750 : // DQ (4/25/2004): Part of new modifier interface
32751 : SgBaseClassModifier &
32752 : SgBaseClass::get_baseClassModifier()
32753 : {
32754 : ROSE_ASSERT ( p_baseClassModifier != NULL);
32755 : return *p_baseClassModifier;
32756 : }
32757 : #endif
32758 :
32759 : SgName
32760 359 : SgBaseClass::get_qualified_name_prefix() const
32761 : {
32762 : // DQ (5/29/2011): Added to support for new qualified name generation.
32763 : // This only applies to specific SgSupport IR nodes:
32764 : // SgBaseClass
32765 : // SgTemplateArgument
32766 :
32767 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
32768 : // different and so it depends upon where the type is referenced. Thus the qualified name is
32769 : // stored in a map to the IR node that references the type.
32770 359 : SgName nameQualifier;
32771 359 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgBaseClass*>(this));
32772 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
32773 :
32774 359 : if (i != SgNode::get_globalQualifiedNameMapForNames().end())
32775 : {
32776 1 : nameQualifier = i->second;
32777 : // mprintf ("Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
32778 : }
32779 :
32780 : // mprintf ("nameQualifier for SgBaseClass = %s = %s \n",class_name().c_str(),nameQualifier.str());
32781 :
32782 359 : return nameQualifier;
32783 : }
32784 :
32785 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
32786 : // so that we could avoid them setting the isModified flag which is a problem in the
32787 : // name qualification support for C++ (interfering with the token-based unparsing).
32788 : int
32789 359 : SgBaseClass::get_name_qualification_length () const
32790 : {
32791 359 : ROSE_ASSERT (this != NULL);
32792 359 : return p_name_qualification_length;
32793 : }
32794 :
32795 : void
32796 4237 : SgBaseClass::set_name_qualification_length ( int name_qualification_length )
32797 : {
32798 4237 : ROSE_ASSERT (this != NULL);
32799 : // This can't be called by the name qualification API (see test2015_26.C).
32800 : // set_isModified(true);
32801 :
32802 4237 : p_name_qualification_length = name_qualification_length;
32803 4237 : }
32804 :
32805 : bool
32806 0 : SgBaseClass::get_type_elaboration_required () const
32807 : {
32808 0 : ROSE_ASSERT (this != NULL);
32809 0 : return p_type_elaboration_required;
32810 : }
32811 :
32812 : void
32813 4237 : SgBaseClass::set_type_elaboration_required ( bool type_elaboration_required )
32814 : {
32815 4237 : ROSE_ASSERT (this != NULL);
32816 : // This can't be called by the name qualification API (see test2015_26.C).
32817 : // set_isModified(true);
32818 :
32819 4237 : p_type_elaboration_required = type_elaboration_required;
32820 4237 : }
32821 :
32822 : bool
32823 359 : SgBaseClass::get_global_qualification_required () const
32824 : {
32825 359 : ROSE_ASSERT (this != NULL);
32826 359 : return p_global_qualification_required;
32827 : }
32828 :
32829 : void
32830 4237 : SgBaseClass::set_global_qualification_required ( bool global_qualification_required )
32831 : {
32832 4237 : ROSE_ASSERT (this != NULL);
32833 :
32834 : // This can't be called by the name qualification API (see test2015_26.C).
32835 : // set_isModified(true);
32836 :
32837 4237 : p_global_qualification_required = global_qualification_required;
32838 4237 : }
32839 :
32840 :
32841 :
32842 :
32843 : // End of memberFunctionString
32844 : // Start of memberFunctionString
32845 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
32846 :
32847 : // *** COMMON CODE SECTION BEGINS HERE ***
32848 :
32849 : #if 0
32850 : int
32851 : SgBaseClass::getVariant() const
32852 : {
32853 : // This function is used in ROSE while "variant()" is used in SAGE
32854 : assert(this != NULL);
32855 : return variant();
32856 : }
32857 : #endif
32858 :
32859 : // This function is used in ROSE in treeTraversal code
32860 : // eventually replaces getVariant() and variant()
32861 : // though after variant() has been removed for a while we will
32862 : // want to change the name of variantT() back to variant()
32863 : // (since the "T" was ment to stand for temporary).
32864 : // When this happens the variantT() will be depricated.
32865 : VariantT
32866 415032 : SgBaseClass::variantT() const
32867 : {
32868 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
32869 415032 : ROSE_ASSERT(this != NULL);
32870 415032 : return V_SgBaseClass;
32871 : }
32872 :
32873 : #if 0
32874 : int
32875 : SgBaseClass::variant() const
32876 : {
32877 : // This function is used in SAGE
32878 : ROSE_ASSERT(this != NULL);
32879 : return BaseClassTag;
32880 : }
32881 : #endif
32882 :
32883 : ROSE_DLL_API const char*
32884 0 : SgBaseClass::sage_class_name() const
32885 : {
32886 0 : ROSE_ASSERT(this != NULL);
32887 0 : return "SgBaseClass";
32888 : }
32889 :
32890 : std::string
32891 2734 : SgBaseClass::class_name() const
32892 : {
32893 2734 : ROSE_ASSERT(this != NULL);
32894 2734 : return "SgBaseClass";
32895 : }
32896 :
32897 : // DQ (11/26/2005): Support for visitor pattern mechanims
32898 : // (inferior to ROSE traversal mechanism, experimental).
32899 : void
32900 58016 : SgBaseClass::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
32901 : {
32902 58016 : ROSE_ASSERT(this != NULL);
32903 58016 : visitor.visit(this);
32904 58016 : }
32905 :
32906 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
32907 0 : void SgBaseClass::accept (ROSE_VisitorPattern & visitor) {
32908 0 : ROSE_ASSERT(this != NULL);
32909 0 : visitor.visit(this);
32910 0 : }
32911 :
32912 : SgBaseClass*
32913 0 : SgBaseClass::addRegExpAttribute(std::string s, AstRegExAttribute* a)
32914 : {
32915 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
32916 : // This function is currently only supported for the AST used the represent Binary executables.
32917 : if (0 /* isSgAsmNode(this) != NULL */)
32918 : {
32919 : // Support for regex specification.
32920 : std::string prefixCode = "REGEX:";
32921 : addNewAttribute(prefixCode + s,a);
32922 : }
32923 : #endif
32924 :
32925 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
32926 0 : return this;
32927 : }
32928 :
32929 : // *** COMMON CODE SECTION ENDS HERE ***
32930 :
32931 :
32932 : // End of memberFunctionString
32933 : // Start of memberFunctionString
32934 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
32935 :
32936 :
32937 : #if 0
32938 : //! Error checking support
32939 : /*! Verifies the following:
32940 : - working getVariant() member function
32941 : - calls base class's error() member function
32942 : Every class has one of these functions.
32943 : */
32944 : bool
32945 : SgBaseClass::error()
32946 : {
32947 : // Put error checking here
32948 :
32949 : ROSE_ASSERT (this != NULL);
32950 : if (getVariant() != BaseClassTag)
32951 : {
32952 : printf ("Error in SgBaseClass::error(): SgBaseClass object has a %s variant \n",
32953 : Cxx_GrammarTerminalNames[getVariant()].name);
32954 : // printf ("Error in SgBaseClass::error() \n");
32955 : ROSE_ABORT();
32956 : }
32957 :
32958 : ROSE_ASSERT (getVariant() == BaseClassTag);
32959 : return SgSupport::error();
32960 : }
32961 : #endif
32962 :
32963 :
32964 :
32965 : // End of memberFunctionString
32966 :
32967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
32968 :
32969 2880350 : SgBaseClass* isSgBaseClass ( SgNode* inputDerivedClassPointer )
32970 : {
32971 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
32972 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
32973 : // So to fix this we return NULL directly when the input is NULL and avoid the
32974 : // dynamic_cast in this case. This is likely a performance improvement as well.
32975 : // return dynamic_cast<SgBaseClass*>(inputDerivedClassPointer);
32976 : // Milind Chabbi (8/28/2013): isSgBaseClass uses table-driven castability instead of c++ default dynamic_cast
32977 : // this improves the running time performance by 10-20%.
32978 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBaseClass*>(inputDerivedClassPointer);
32979 2880350 : return IS_SgBaseClass_FAST_MACRO(inputDerivedClassPointer);
32980 : }
32981 :
32982 : // DQ (11/8/2003): Added version of functions taking const pointer
32983 0 : const SgBaseClass* isSgBaseClass ( const SgNode* inputDerivedClassPointer )
32984 : {
32985 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
32986 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
32987 : // So to fix this we return NULL directly when the input is NULL and avoid the
32988 : // dynamic_cast in this case. This is likely a performance improvement as well.
32989 : // return dynamic_cast<const SgBaseClass*>(inputDerivedClassPointer);
32990 : // Milind Chabbi (8/28/2013): isSgBaseClass uses table-driven castability instead of c++ default dynamic_cast
32991 : // this improves the running time performance by 10-20%.
32992 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBaseClass*>(inputDerivedClassPointer);
32993 0 : return IS_SgBaseClass_FAST_MACRO(inputDerivedClassPointer);
32994 : }
32995 :
32996 :
32997 :
32998 : /* #line 32999 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
32999 :
33000 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33001 :
33002 : /**
33003 : \brief Generated destructor
33004 :
33005 : This destructor is automatically generated (by ROSETTA). This destructor
33006 : only frees memory of data members associated with the parts of the current IR node which
33007 : are NOT traversed. Those data members that are part of a traversal can be freed using
33008 : a traversal (calling this destructor on all children in a post-order traversal). Such
33009 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
33010 :
33011 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
33012 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
33013 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
33014 :
33015 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
33016 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
33017 : pointers are not yet implemented to call delete on eash pointer in the container.
33018 : (This could be done by derivation from the STL containers to define containers that
33019 : automatically deleted their members.)
33020 :
33021 : */
33022 2080 : SgBaseClass::~SgBaseClass () {
33023 1240 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
33024 :
33025 1240 : if (p_baseClassModifier && p_baseClassModifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_baseClassModifier; }
33026 :
33027 : // case: not a listType for base_class
33028 1240 : p_base_class = NULL; // non list case
33029 : // case: not a listType for isDirectBaseClass
33030 1240 : p_isDirectBaseClass = false; // non list case
33031 : // case: not a listType for baseClassModifier
33032 1240 : p_baseClassModifier = NULL; // non list case
33033 : // case: not a listType for name_qualification_length
33034 1240 : p_name_qualification_length = 0; // non list case
33035 : // case: not a listType for type_elaboration_required
33036 1240 : p_type_elaboration_required = false; // non list case
33037 : // case: not a listType for global_qualification_required
33038 1240 : p_global_qualification_required = false; // non list case
33039 :
33040 : }
33041 :
33042 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33043 2080 : }
33044 :
33045 :
33046 : /* #line 33047 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33047 :
33048 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33049 :
33050 : // Generated constructor
33051 5725 : SgBaseClass::SgBaseClass ( SgClassDeclaration* base_class, bool isDirectBaseClass )
33052 5725 : : SgSupport()
33053 : {
33054 : #ifdef DEBUG
33055 : // printf ("In SgBaseClass::SgBaseClass (SgClassDeclaration* base_class, bool isDirectBaseClass) sage_class_name() = %s \n",sage_class_name());
33056 : #endif
33057 : #if 0
33058 : // debugging information!
33059 : printf ("In SgBaseClass::SgBaseClass (SgClassDeclaration* base_class, bool isDirectBaseClass): this = %p = %s \n",this,this->class_name().c_str());
33060 : #endif
33061 :
33062 5725 : p_base_class = base_class;
33063 5725 : p_isDirectBaseClass = isDirectBaseClass;
33064 5725 : p_baseClassModifier = NULL;
33065 5725 : p_name_qualification_length = 0;
33066 5725 : p_type_elaboration_required = false;
33067 5725 : p_global_qualification_required = false;
33068 :
33069 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33070 :
33071 : #if 0
33072 : // DQ (7/30/2014): Call a virtual function.
33073 : std::string s = this->class_name();
33074 : #endif
33075 :
33076 : // Test the variant virtual function
33077 : // assert(BaseClassTag == variant());
33078 5725 : assert(BaseClassTag == this->variant());
33079 5725 : ROSE_ASSERT(BaseClassTag == (int)(this->variantT()));
33080 5725 : post_construction_initialization();
33081 :
33082 : // Test the isSgBaseClass() function since it has been problematic
33083 5725 : assert(isSgBaseClass(this) != NULL);
33084 5725 : }
33085 :
33086 : // Generated constructor (all data members)
33087 :
33088 : /* #line 33089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33089 :
33090 :
33091 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33092 :
33093 :
33094 : // ********************************************************
33095 : // member functions common across all array grammar objects
33096 : // ********************************************************
33097 :
33098 :
33099 :
33100 : /* #line 33101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33101 :
33102 :
33103 :
33104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33105 :
33106 : // ********************************************************
33107 : // member functions specific to each node in the grammar
33108 : // ********************************************************
33109 :
33110 :
33111 : /* #line 33112 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33112 :
33113 : // Start of memberFunctionString
33114 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
33115 :
33116 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
33117 :
33118 : SgExpression*
33119 0 : SgExpBaseClass::get_base_class_exp () const
33120 : {
33121 0 : ROSE_ASSERT (this != NULL);
33122 :
33123 : #if 0
33124 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
33125 : // used to trigger marking transformations for the token-based unparsing.
33126 : printf ("SgExpBaseClass::get_base_class_exp = %p = %s \n",this,this->class_name().c_str());
33127 : #endif
33128 :
33129 0 : return p_base_class_exp;
33130 : }
33131 :
33132 : void
33133 0 : SgExpBaseClass::set_base_class_exp ( SgExpression* base_class_exp )
33134 : {
33135 0 : ROSE_ASSERT (this != NULL);
33136 :
33137 : #if 0
33138 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
33139 : // used to trigger marking transformations for the token-based unparsing.
33140 : printf ("SgExpBaseClass::set_base_class_exp = %p = %s \n",this,this->class_name().c_str());
33141 : #endif
33142 :
33143 0 : set_isModified(true);
33144 :
33145 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
33146 : if (p_base_class_exp != NULL && base_class_exp != NULL && p_base_class_exp != base_class_exp)
33147 : {
33148 : printf ("Warning: base_class_exp = %p overwriting valid pointer p_base_class_exp = %p \n",base_class_exp,p_base_class_exp);
33149 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
33150 : printf ("Error fails assertion (p_base_class_exp != NULL && base_class_exp != NULL && p_base_class_exp != base_class_exp) is false\n");
33151 : ROSE_ASSERT(false);
33152 : #endif
33153 : }
33154 : #endif
33155 0 : p_base_class_exp = base_class_exp;
33156 0 : }
33157 :
33158 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
33159 :
33160 :
33161 : // End of memberFunctionString
33162 : // Start of memberFunctionString
33163 : /* #line 12139 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
33164 :
33165 : void
33166 0 : SgExpBaseClass::post_construction_initialization()
33167 : {
33168 0 : }
33169 :
33170 :
33171 : // End of memberFunctionString
33172 : // Start of memberFunctionString
33173 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
33174 :
33175 : // *** COMMON CODE SECTION BEGINS HERE ***
33176 :
33177 : #if 0
33178 : int
33179 : SgExpBaseClass::getVariant() const
33180 : {
33181 : // This function is used in ROSE while "variant()" is used in SAGE
33182 : assert(this != NULL);
33183 : return variant();
33184 : }
33185 : #endif
33186 :
33187 : // This function is used in ROSE in treeTraversal code
33188 : // eventually replaces getVariant() and variant()
33189 : // though after variant() has been removed for a while we will
33190 : // want to change the name of variantT() back to variant()
33191 : // (since the "T" was ment to stand for temporary).
33192 : // When this happens the variantT() will be depricated.
33193 : VariantT
33194 0 : SgExpBaseClass::variantT() const
33195 : {
33196 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
33197 0 : ROSE_ASSERT(this != NULL);
33198 0 : return V_SgExpBaseClass;
33199 : }
33200 :
33201 : #if 0
33202 : int
33203 : SgExpBaseClass::variant() const
33204 : {
33205 : // This function is used in SAGE
33206 : ROSE_ASSERT(this != NULL);
33207 : return ExpBaseClassTag;
33208 : }
33209 : #endif
33210 :
33211 : ROSE_DLL_API const char*
33212 0 : SgExpBaseClass::sage_class_name() const
33213 : {
33214 0 : ROSE_ASSERT(this != NULL);
33215 0 : return "SgExpBaseClass";
33216 : }
33217 :
33218 : std::string
33219 0 : SgExpBaseClass::class_name() const
33220 : {
33221 0 : ROSE_ASSERT(this != NULL);
33222 0 : return "SgExpBaseClass";
33223 : }
33224 :
33225 : // DQ (11/26/2005): Support for visitor pattern mechanims
33226 : // (inferior to ROSE traversal mechanism, experimental).
33227 : void
33228 0 : SgExpBaseClass::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
33229 : {
33230 0 : ROSE_ASSERT(this != NULL);
33231 0 : visitor.visit(this);
33232 0 : }
33233 :
33234 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
33235 0 : void SgExpBaseClass::accept (ROSE_VisitorPattern & visitor) {
33236 0 : ROSE_ASSERT(this != NULL);
33237 0 : visitor.visit(this);
33238 0 : }
33239 :
33240 : SgExpBaseClass*
33241 0 : SgExpBaseClass::addRegExpAttribute(std::string s, AstRegExAttribute* a)
33242 : {
33243 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
33244 : // This function is currently only supported for the AST used the represent Binary executables.
33245 : if (0 /* isSgAsmNode(this) != NULL */)
33246 : {
33247 : // Support for regex specification.
33248 : std::string prefixCode = "REGEX:";
33249 : addNewAttribute(prefixCode + s,a);
33250 : }
33251 : #endif
33252 :
33253 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
33254 0 : return this;
33255 : }
33256 :
33257 : // *** COMMON CODE SECTION ENDS HERE ***
33258 :
33259 :
33260 : // End of memberFunctionString
33261 : // Start of memberFunctionString
33262 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
33263 :
33264 :
33265 : #if 0
33266 : //! Error checking support
33267 : /*! Verifies the following:
33268 : - working getVariant() member function
33269 : - calls base class's error() member function
33270 : Every class has one of these functions.
33271 : */
33272 : bool
33273 : SgExpBaseClass::error()
33274 : {
33275 : // Put error checking here
33276 :
33277 : ROSE_ASSERT (this != NULL);
33278 : if (getVariant() != ExpBaseClassTag)
33279 : {
33280 : printf ("Error in SgExpBaseClass::error(): SgExpBaseClass object has a %s variant \n",
33281 : Cxx_GrammarTerminalNames[getVariant()].name);
33282 : // printf ("Error in SgExpBaseClass::error() \n");
33283 : ROSE_ABORT();
33284 : }
33285 :
33286 : ROSE_ASSERT (getVariant() == ExpBaseClassTag);
33287 : return SgBaseClass::error();
33288 : }
33289 : #endif
33290 :
33291 :
33292 :
33293 : // End of memberFunctionString
33294 :
33295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
33296 :
33297 6102 : SgExpBaseClass* isSgExpBaseClass ( SgNode* inputDerivedClassPointer )
33298 : {
33299 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
33300 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
33301 : // So to fix this we return NULL directly when the input is NULL and avoid the
33302 : // dynamic_cast in this case. This is likely a performance improvement as well.
33303 : // return dynamic_cast<SgExpBaseClass*>(inputDerivedClassPointer);
33304 : // Milind Chabbi (8/28/2013): isSgExpBaseClass uses table-driven castability instead of c++ default dynamic_cast
33305 : // this improves the running time performance by 10-20%.
33306 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExpBaseClass*>(inputDerivedClassPointer);
33307 6102 : return IS_SgExpBaseClass_FAST_MACRO(inputDerivedClassPointer);
33308 : }
33309 :
33310 : // DQ (11/8/2003): Added version of functions taking const pointer
33311 0 : const SgExpBaseClass* isSgExpBaseClass ( const SgNode* inputDerivedClassPointer )
33312 : {
33313 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
33314 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
33315 : // So to fix this we return NULL directly when the input is NULL and avoid the
33316 : // dynamic_cast in this case. This is likely a performance improvement as well.
33317 : // return dynamic_cast<const SgExpBaseClass*>(inputDerivedClassPointer);
33318 : // Milind Chabbi (8/28/2013): isSgExpBaseClass uses table-driven castability instead of c++ default dynamic_cast
33319 : // this improves the running time performance by 10-20%.
33320 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExpBaseClass*>(inputDerivedClassPointer);
33321 0 : return IS_SgExpBaseClass_FAST_MACRO(inputDerivedClassPointer);
33322 : }
33323 :
33324 :
33325 :
33326 : /* #line 33327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33327 :
33328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33329 :
33330 : /**
33331 : \brief Generated destructor
33332 :
33333 : This destructor is automatically generated (by ROSETTA). This destructor
33334 : only frees memory of data members associated with the parts of the current IR node which
33335 : are NOT traversed. Those data members that are part of a traversal can be freed using
33336 : a traversal (calling this destructor on all children in a post-order traversal). Such
33337 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
33338 :
33339 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
33340 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
33341 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
33342 :
33343 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
33344 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
33345 : pointers are not yet implemented to call delete on eash pointer in the container.
33346 : (This could be done by derivation from the STL containers to define containers that
33347 : automatically deleted their members.)
33348 :
33349 : */
33350 0 : SgExpBaseClass::~SgExpBaseClass () {
33351 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
33352 :
33353 :
33354 : // case: not a listType for base_class_exp
33355 0 : p_base_class_exp = NULL; // non list case
33356 :
33357 : }
33358 :
33359 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33360 0 : }
33361 :
33362 :
33363 : /* #line 33364 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33364 :
33365 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33366 :
33367 : // Generated constructor
33368 0 : SgExpBaseClass::SgExpBaseClass ( SgClassDeclaration* base_class, bool isDirectBaseClass, SgExpression* base_class_exp )
33369 0 : : SgBaseClass(base_class, isDirectBaseClass)
33370 : {
33371 : #ifdef DEBUG
33372 : // printf ("In SgExpBaseClass::SgExpBaseClass (SgClassDeclaration* base_class, bool isDirectBaseClass, SgExpression* base_class_exp) sage_class_name() = %s \n",sage_class_name());
33373 : #endif
33374 : #if 0
33375 : // debugging information!
33376 : printf ("In SgExpBaseClass::SgExpBaseClass (SgClassDeclaration* base_class, bool isDirectBaseClass, SgExpression* base_class_exp): this = %p = %s \n",this,this->class_name().c_str());
33377 : #endif
33378 :
33379 0 : p_base_class_exp = base_class_exp;
33380 :
33381 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33382 :
33383 : #if 0
33384 : // DQ (7/30/2014): Call a virtual function.
33385 : std::string s = this->class_name();
33386 : #endif
33387 :
33388 : // Test the variant virtual function
33389 : // assert(ExpBaseClassTag == variant());
33390 0 : assert(ExpBaseClassTag == this->variant());
33391 0 : ROSE_ASSERT(ExpBaseClassTag == (int)(this->variantT()));
33392 0 : post_construction_initialization();
33393 :
33394 : // Test the isSgExpBaseClass() function since it has been problematic
33395 0 : assert(isSgExpBaseClass(this) != NULL);
33396 0 : }
33397 :
33398 : // Generated constructor (all data members)
33399 :
33400 : /* #line 33401 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33401 :
33402 :
33403 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33404 :
33405 :
33406 : // ********************************************************
33407 : // member functions common across all array grammar objects
33408 : // ********************************************************
33409 :
33410 :
33411 :
33412 : /* #line 33413 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33413 :
33414 :
33415 :
33416 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33417 :
33418 : // ********************************************************
33419 : // member functions specific to each node in the grammar
33420 : // ********************************************************
33421 :
33422 :
33423 : /* #line 33424 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33424 :
33425 : // Start of memberFunctionString
33426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
33427 :
33428 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
33429 :
33430 : SgNonrealDecl*
33431 8709 : SgNonrealBaseClass::get_base_class_nonreal () const
33432 : {
33433 8709 : ROSE_ASSERT (this != NULL);
33434 :
33435 : #if 0
33436 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
33437 : // used to trigger marking transformations for the token-based unparsing.
33438 : printf ("SgNonrealBaseClass::get_base_class_nonreal = %p = %s \n",this,this->class_name().c_str());
33439 : #endif
33440 :
33441 8709 : return p_base_class_nonreal;
33442 : }
33443 :
33444 : void
33445 0 : SgNonrealBaseClass::set_base_class_nonreal ( SgNonrealDecl* base_class_nonreal )
33446 : {
33447 0 : ROSE_ASSERT (this != NULL);
33448 :
33449 : #if 0
33450 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
33451 : // used to trigger marking transformations for the token-based unparsing.
33452 : printf ("SgNonrealBaseClass::set_base_class_nonreal = %p = %s \n",this,this->class_name().c_str());
33453 : #endif
33454 :
33455 0 : set_isModified(true);
33456 :
33457 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
33458 : if (p_base_class_nonreal != NULL && base_class_nonreal != NULL && p_base_class_nonreal != base_class_nonreal)
33459 : {
33460 : printf ("Warning: base_class_nonreal = %p overwriting valid pointer p_base_class_nonreal = %p \n",base_class_nonreal,p_base_class_nonreal);
33461 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
33462 : printf ("Error fails assertion (p_base_class_nonreal != NULL && base_class_nonreal != NULL && p_base_class_nonreal != base_class_nonreal) is false\n");
33463 : ROSE_ASSERT(false);
33464 : #endif
33465 : }
33466 : #endif
33467 0 : p_base_class_nonreal = base_class_nonreal;
33468 0 : }
33469 :
33470 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
33471 :
33472 :
33473 : // End of memberFunctionString
33474 : // Start of memberFunctionString
33475 : /* #line 12146 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
33476 :
33477 : void
33478 1908 : SgNonrealBaseClass::post_construction_initialization()
33479 : {
33480 1908 : }
33481 :
33482 :
33483 : // End of memberFunctionString
33484 : // Start of memberFunctionString
33485 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
33486 :
33487 : // *** COMMON CODE SECTION BEGINS HERE ***
33488 :
33489 : #if 0
33490 : int
33491 : SgNonrealBaseClass::getVariant() const
33492 : {
33493 : // This function is used in ROSE while "variant()" is used in SAGE
33494 : assert(this != NULL);
33495 : return variant();
33496 : }
33497 : #endif
33498 :
33499 : // This function is used in ROSE in treeTraversal code
33500 : // eventually replaces getVariant() and variant()
33501 : // though after variant() has been removed for a while we will
33502 : // want to change the name of variantT() back to variant()
33503 : // (since the "T" was ment to stand for temporary).
33504 : // When this happens the variantT() will be depricated.
33505 : VariantT
33506 182074 : SgNonrealBaseClass::variantT() const
33507 : {
33508 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
33509 182074 : ROSE_ASSERT(this != NULL);
33510 182074 : return V_SgNonrealBaseClass;
33511 : }
33512 :
33513 : #if 0
33514 : int
33515 : SgNonrealBaseClass::variant() const
33516 : {
33517 : // This function is used in SAGE
33518 : ROSE_ASSERT(this != NULL);
33519 : return NonrealBaseClassTag;
33520 : }
33521 : #endif
33522 :
33523 : ROSE_DLL_API const char*
33524 0 : SgNonrealBaseClass::sage_class_name() const
33525 : {
33526 0 : ROSE_ASSERT(this != NULL);
33527 0 : return "SgNonrealBaseClass";
33528 : }
33529 :
33530 : std::string
33531 1350 : SgNonrealBaseClass::class_name() const
33532 : {
33533 1350 : ROSE_ASSERT(this != NULL);
33534 1350 : return "SgNonrealBaseClass";
33535 : }
33536 :
33537 : // DQ (11/26/2005): Support for visitor pattern mechanims
33538 : // (inferior to ROSE traversal mechanism, experimental).
33539 : void
33540 27544 : SgNonrealBaseClass::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
33541 : {
33542 27544 : ROSE_ASSERT(this != NULL);
33543 27544 : visitor.visit(this);
33544 27544 : }
33545 :
33546 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
33547 0 : void SgNonrealBaseClass::accept (ROSE_VisitorPattern & visitor) {
33548 0 : ROSE_ASSERT(this != NULL);
33549 0 : visitor.visit(this);
33550 0 : }
33551 :
33552 : SgNonrealBaseClass*
33553 0 : SgNonrealBaseClass::addRegExpAttribute(std::string s, AstRegExAttribute* a)
33554 : {
33555 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
33556 : // This function is currently only supported for the AST used the represent Binary executables.
33557 : if (0 /* isSgAsmNode(this) != NULL */)
33558 : {
33559 : // Support for regex specification.
33560 : std::string prefixCode = "REGEX:";
33561 : addNewAttribute(prefixCode + s,a);
33562 : }
33563 : #endif
33564 :
33565 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
33566 0 : return this;
33567 : }
33568 :
33569 : // *** COMMON CODE SECTION ENDS HERE ***
33570 :
33571 :
33572 : // End of memberFunctionString
33573 : // Start of memberFunctionString
33574 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
33575 :
33576 :
33577 : #if 0
33578 : //! Error checking support
33579 : /*! Verifies the following:
33580 : - working getVariant() member function
33581 : - calls base class's error() member function
33582 : Every class has one of these functions.
33583 : */
33584 : bool
33585 : SgNonrealBaseClass::error()
33586 : {
33587 : // Put error checking here
33588 :
33589 : ROSE_ASSERT (this != NULL);
33590 : if (getVariant() != NonrealBaseClassTag)
33591 : {
33592 : printf ("Error in SgNonrealBaseClass::error(): SgNonrealBaseClass object has a %s variant \n",
33593 : Cxx_GrammarTerminalNames[getVariant()].name);
33594 : // printf ("Error in SgNonrealBaseClass::error() \n");
33595 : ROSE_ABORT();
33596 : }
33597 :
33598 : ROSE_ASSERT (getVariant() == NonrealBaseClassTag);
33599 : return SgBaseClass::error();
33600 : }
33601 : #endif
33602 :
33603 :
33604 :
33605 : // End of memberFunctionString
33606 :
33607 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
33608 :
33609 55564 : SgNonrealBaseClass* isSgNonrealBaseClass ( SgNode* inputDerivedClassPointer )
33610 : {
33611 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
33612 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
33613 : // So to fix this we return NULL directly when the input is NULL and avoid the
33614 : // dynamic_cast in this case. This is likely a performance improvement as well.
33615 : // return dynamic_cast<SgNonrealBaseClass*>(inputDerivedClassPointer);
33616 : // Milind Chabbi (8/28/2013): isSgNonrealBaseClass uses table-driven castability instead of c++ default dynamic_cast
33617 : // this improves the running time performance by 10-20%.
33618 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNonrealBaseClass*>(inputDerivedClassPointer);
33619 55564 : return IS_SgNonrealBaseClass_FAST_MACRO(inputDerivedClassPointer);
33620 : }
33621 :
33622 : // DQ (11/8/2003): Added version of functions taking const pointer
33623 0 : const SgNonrealBaseClass* isSgNonrealBaseClass ( const SgNode* inputDerivedClassPointer )
33624 : {
33625 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
33626 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
33627 : // So to fix this we return NULL directly when the input is NULL and avoid the
33628 : // dynamic_cast in this case. This is likely a performance improvement as well.
33629 : // return dynamic_cast<const SgNonrealBaseClass*>(inputDerivedClassPointer);
33630 : // Milind Chabbi (8/28/2013): isSgNonrealBaseClass uses table-driven castability instead of c++ default dynamic_cast
33631 : // this improves the running time performance by 10-20%.
33632 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNonrealBaseClass*>(inputDerivedClassPointer);
33633 0 : return IS_SgNonrealBaseClass_FAST_MACRO(inputDerivedClassPointer);
33634 : }
33635 :
33636 :
33637 :
33638 : /* #line 33639 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33639 :
33640 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33641 :
33642 : /**
33643 : \brief Generated destructor
33644 :
33645 : This destructor is automatically generated (by ROSETTA). This destructor
33646 : only frees memory of data members associated with the parts of the current IR node which
33647 : are NOT traversed. Those data members that are part of a traversal can be freed using
33648 : a traversal (calling this destructor on all children in a post-order traversal). Such
33649 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
33650 :
33651 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
33652 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
33653 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
33654 :
33655 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
33656 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
33657 : pointers are not yet implemented to call delete on eash pointer in the container.
33658 : (This could be done by derivation from the STL containers to define containers that
33659 : automatically deleted their members.)
33660 :
33661 : */
33662 800 : SgNonrealBaseClass::~SgNonrealBaseClass () {
33663 400 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
33664 :
33665 :
33666 : // case: not a listType for base_class_nonreal
33667 400 : p_base_class_nonreal = NULL; // non list case
33668 :
33669 : }
33670 :
33671 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33672 800 : }
33673 :
33674 :
33675 : /* #line 33676 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33676 :
33677 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33678 :
33679 : // Generated constructor
33680 1908 : SgNonrealBaseClass::SgNonrealBaseClass ( SgClassDeclaration* base_class, bool isDirectBaseClass, SgNonrealDecl* base_class_nonreal )
33681 1908 : : SgBaseClass(base_class, isDirectBaseClass)
33682 : {
33683 : #ifdef DEBUG
33684 : // printf ("In SgNonrealBaseClass::SgNonrealBaseClass (SgClassDeclaration* base_class, bool isDirectBaseClass, SgNonrealDecl* base_class_nonreal) sage_class_name() = %s \n",sage_class_name());
33685 : #endif
33686 : #if 0
33687 : // debugging information!
33688 : printf ("In SgNonrealBaseClass::SgNonrealBaseClass (SgClassDeclaration* base_class, bool isDirectBaseClass, SgNonrealDecl* base_class_nonreal): this = %p = %s \n",this,this->class_name().c_str());
33689 : #endif
33690 :
33691 1908 : p_base_class_nonreal = base_class_nonreal;
33692 :
33693 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33694 :
33695 : #if 0
33696 : // DQ (7/30/2014): Call a virtual function.
33697 : std::string s = this->class_name();
33698 : #endif
33699 :
33700 : // Test the variant virtual function
33701 : // assert(NonrealBaseClassTag == variant());
33702 1908 : assert(NonrealBaseClassTag == this->variant());
33703 1908 : ROSE_ASSERT(NonrealBaseClassTag == (int)(this->variantT()));
33704 1908 : post_construction_initialization();
33705 :
33706 : // Test the isSgNonrealBaseClass() function since it has been problematic
33707 1908 : assert(isSgNonrealBaseClass(this) != NULL);
33708 1908 : }
33709 :
33710 : // Generated constructor (all data members)
33711 :
33712 : /* #line 33713 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33713 :
33714 :
33715 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33716 :
33717 :
33718 : // ********************************************************
33719 : // member functions common across all array grammar objects
33720 : // ********************************************************
33721 :
33722 :
33723 :
33724 : /* #line 33725 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33725 :
33726 :
33727 :
33728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33729 :
33730 : // ********************************************************
33731 : // member functions specific to each node in the grammar
33732 : // ********************************************************
33733 :
33734 :
33735 : /* #line 33736 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33736 :
33737 : // Start of memberFunctionString
33738 : /* #line 21026 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
33739 :
33740 : const SgTypePtrList &
33741 0 : SgTypedefSeq::get_typedefs() const
33742 0 : { return p_typedefs; }
33743 :
33744 : SgTypePtrList &
33745 642859 : SgTypedefSeq::get_typedefs()
33746 642859 : { return p_typedefs; }
33747 :
33748 : void
33749 0 : SgTypedefSeq::append_typedef( SgType* what)
33750 : {
33751 0 : insert_typedef(p_typedefs.end(),what);
33752 0 : }
33753 :
33754 : void
33755 0 : SgTypedefSeq::insert_typedef(const SgTypePtrList::iterator& where, SgType* what)
33756 : {
33757 0 : p_typedefs.insert(where,what);
33758 0 : }
33759 :
33760 :
33761 : // End of memberFunctionString
33762 : // Start of memberFunctionString
33763 :
33764 :
33765 : // End of memberFunctionString
33766 : // Start of memberFunctionString
33767 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
33768 :
33769 : // *** COMMON CODE SECTION BEGINS HERE ***
33770 :
33771 : #if 0
33772 : int
33773 : SgTypedefSeq::getVariant() const
33774 : {
33775 : // This function is used in ROSE while "variant()" is used in SAGE
33776 : assert(this != NULL);
33777 : return variant();
33778 : }
33779 : #endif
33780 :
33781 : // This function is used in ROSE in treeTraversal code
33782 : // eventually replaces getVariant() and variant()
33783 : // though after variant() has been removed for a while we will
33784 : // want to change the name of variantT() back to variant()
33785 : // (since the "T" was ment to stand for temporary).
33786 : // When this happens the variantT() will be depricated.
33787 : VariantT
33788 16757800 : SgTypedefSeq::variantT() const
33789 : {
33790 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
33791 16757800 : ROSE_ASSERT(this != NULL);
33792 16757800 : return V_SgTypedefSeq;
33793 : }
33794 :
33795 : #if 0
33796 : int
33797 : SgTypedefSeq::variant() const
33798 : {
33799 : // This function is used in SAGE
33800 : ROSE_ASSERT(this != NULL);
33801 : return T_TYPEDEF_SEQ;
33802 : }
33803 : #endif
33804 :
33805 : ROSE_DLL_API const char*
33806 0 : SgTypedefSeq::sage_class_name() const
33807 : {
33808 0 : ROSE_ASSERT(this != NULL);
33809 0 : return "SgTypedefSeq";
33810 : }
33811 :
33812 : std::string
33813 385951 : SgTypedefSeq::class_name() const
33814 : {
33815 385951 : ROSE_ASSERT(this != NULL);
33816 385951 : return "SgTypedefSeq";
33817 : }
33818 :
33819 : // DQ (11/26/2005): Support for visitor pattern mechanims
33820 : // (inferior to ROSE traversal mechanism, experimental).
33821 : void
33822 2202800 : SgTypedefSeq::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
33823 : {
33824 2202800 : ROSE_ASSERT(this != NULL);
33825 2202800 : visitor.visit(this);
33826 2202800 : }
33827 :
33828 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
33829 0 : void SgTypedefSeq::accept (ROSE_VisitorPattern & visitor) {
33830 0 : ROSE_ASSERT(this != NULL);
33831 0 : visitor.visit(this);
33832 0 : }
33833 :
33834 : SgTypedefSeq*
33835 0 : SgTypedefSeq::addRegExpAttribute(std::string s, AstRegExAttribute* a)
33836 : {
33837 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
33838 : // This function is currently only supported for the AST used the represent Binary executables.
33839 : if (0 /* isSgAsmNode(this) != NULL */)
33840 : {
33841 : // Support for regex specification.
33842 : std::string prefixCode = "REGEX:";
33843 : addNewAttribute(prefixCode + s,a);
33844 : }
33845 : #endif
33846 :
33847 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
33848 0 : return this;
33849 : }
33850 :
33851 : // *** COMMON CODE SECTION ENDS HERE ***
33852 :
33853 :
33854 : // End of memberFunctionString
33855 : // Start of memberFunctionString
33856 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
33857 :
33858 :
33859 : #if 0
33860 : //! Error checking support
33861 : /*! Verifies the following:
33862 : - working getVariant() member function
33863 : - calls base class's error() member function
33864 : Every class has one of these functions.
33865 : */
33866 : bool
33867 : SgTypedefSeq::error()
33868 : {
33869 : // Put error checking here
33870 :
33871 : ROSE_ASSERT (this != NULL);
33872 : if (getVariant() != T_TYPEDEF_SEQ)
33873 : {
33874 : printf ("Error in SgTypedefSeq::error(): SgTypedefSeq object has a %s variant \n",
33875 : Cxx_GrammarTerminalNames[getVariant()].name);
33876 : // printf ("Error in SgTypedefSeq::error() \n");
33877 : ROSE_ABORT();
33878 : }
33879 :
33880 : ROSE_ASSERT (getVariant() == T_TYPEDEF_SEQ);
33881 : return SgSupport::error();
33882 : }
33883 : #endif
33884 :
33885 :
33886 :
33887 : // End of memberFunctionString
33888 :
33889 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
33890 :
33891 610000 : SgTypedefSeq* isSgTypedefSeq ( SgNode* inputDerivedClassPointer )
33892 : {
33893 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
33894 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
33895 : // So to fix this we return NULL directly when the input is NULL and avoid the
33896 : // dynamic_cast in this case. This is likely a performance improvement as well.
33897 : // return dynamic_cast<SgTypedefSeq*>(inputDerivedClassPointer);
33898 : // Milind Chabbi (8/28/2013): isSgTypedefSeq uses table-driven castability instead of c++ default dynamic_cast
33899 : // this improves the running time performance by 10-20%.
33900 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypedefSeq*>(inputDerivedClassPointer);
33901 610000 : return IS_SgTypedefSeq_FAST_MACRO(inputDerivedClassPointer);
33902 : }
33903 :
33904 : // DQ (11/8/2003): Added version of functions taking const pointer
33905 0 : const SgTypedefSeq* isSgTypedefSeq ( const SgNode* inputDerivedClassPointer )
33906 : {
33907 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
33908 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
33909 : // So to fix this we return NULL directly when the input is NULL and avoid the
33910 : // dynamic_cast in this case. This is likely a performance improvement as well.
33911 : // return dynamic_cast<const SgTypedefSeq*>(inputDerivedClassPointer);
33912 : // Milind Chabbi (8/28/2013): isSgTypedefSeq uses table-driven castability instead of c++ default dynamic_cast
33913 : // this improves the running time performance by 10-20%.
33914 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypedefSeq*>(inputDerivedClassPointer);
33915 0 : return IS_SgTypedefSeq_FAST_MACRO(inputDerivedClassPointer);
33916 : }
33917 :
33918 :
33919 :
33920 : /* #line 33921 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33921 :
33922 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33923 :
33924 : /**
33925 : \brief Generated destructor
33926 :
33927 : This destructor is automatically generated (by ROSETTA). This destructor
33928 : only frees memory of data members associated with the parts of the current IR node which
33929 : are NOT traversed. Those data members that are part of a traversal can be freed using
33930 : a traversal (calling this destructor on all children in a post-order traversal). Such
33931 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
33932 :
33933 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
33934 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
33935 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
33936 :
33937 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
33938 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
33939 : pointers are not yet implemented to call delete on eash pointer in the container.
33940 : (This could be done by derivation from the STL containers to define containers that
33941 : automatically deleted their members.)
33942 :
33943 : */
33944 396572 : SgTypedefSeq::~SgTypedefSeq () {
33945 197209 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
33946 :
33947 :
33948 :
33949 : }
33950 :
33951 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
33952 394418 : }
33953 :
33954 :
33955 : /* #line 33956 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33956 :
33957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
33958 :
33959 : // Generated constructor
33960 609681 : SgTypedefSeq::SgTypedefSeq ( )
33961 609681 : : SgSupport()
33962 : {
33963 : #ifdef DEBUG
33964 : // printf ("In SgTypedefSeq::SgTypedefSeq () sage_class_name() = %s \n",sage_class_name());
33965 : #endif
33966 : #if 0
33967 : // debugging information!
33968 : printf ("In SgTypedefSeq::SgTypedefSeq (): this = %p = %s \n",this,this->class_name().c_str());
33969 : #endif
33970 :
33971 :
33972 :
33973 : #if 0
33974 : // DQ (7/30/2014): Call a virtual function.
33975 : std::string s = this->class_name();
33976 : #endif
33977 :
33978 : // Test the variant virtual function
33979 : // assert(T_TYPEDEF_SEQ == variant());
33980 609681 : assert(T_TYPEDEF_SEQ == this->variant());
33981 609681 : ROSE_ASSERT(T_TYPEDEF_SEQ == (int)(this->variantT()));
33982 609681 : post_construction_initialization();
33983 :
33984 : // Test the isSgTypedefSeq() function since it has been problematic
33985 609681 : assert(isSgTypedefSeq(this) != NULL);
33986 609681 : }
33987 :
33988 : // Generated constructor (all data members)
33989 :
33990 : /* #line 33991 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
33991 :
33992 :
33993 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
33994 :
33995 :
33996 : // ********************************************************
33997 : // member functions common across all array grammar objects
33998 : // ********************************************************
33999 :
34000 :
34001 :
34002 : /* #line 34003 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34003 :
34004 :
34005 :
34006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
34007 :
34008 : // ********************************************************
34009 : // member functions specific to each node in the grammar
34010 : // ********************************************************
34011 :
34012 :
34013 : /* #line 34014 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34014 :
34015 : // Start of memberFunctionString
34016 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34017 :
34018 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34019 :
34020 : SgTemplateParameter::template_parameter_enum
34021 129472 : SgTemplateParameter::get_parameterType () const
34022 : {
34023 129472 : ROSE_ASSERT (this != NULL);
34024 :
34025 : #if 0
34026 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34027 : // used to trigger marking transformations for the token-based unparsing.
34028 : printf ("SgTemplateParameter::get_parameterType = %p = %s \n",this,this->class_name().c_str());
34029 : #endif
34030 :
34031 129472 : return p_parameterType;
34032 : }
34033 :
34034 : void
34035 0 : SgTemplateParameter::set_parameterType ( SgTemplateParameter::template_parameter_enum parameterType )
34036 : {
34037 0 : ROSE_ASSERT (this != NULL);
34038 :
34039 : #if 0
34040 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34041 : // used to trigger marking transformations for the token-based unparsing.
34042 : printf ("SgTemplateParameter::set_parameterType = %p = %s \n",this,this->class_name().c_str());
34043 : #endif
34044 :
34045 0 : set_isModified(true);
34046 :
34047 0 : p_parameterType = parameterType;
34048 0 : }
34049 :
34050 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34051 :
34052 :
34053 : // End of memberFunctionString
34054 : // Start of memberFunctionString
34055 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34056 :
34057 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34058 :
34059 : SgType*
34060 86297 : SgTemplateParameter::get_type () const
34061 : {
34062 86297 : ROSE_ASSERT (this != NULL);
34063 :
34064 : #if 0
34065 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34066 : // used to trigger marking transformations for the token-based unparsing.
34067 : printf ("SgTemplateParameter::get_type = %p = %s \n",this,this->class_name().c_str());
34068 : #endif
34069 :
34070 86297 : return p_type;
34071 : }
34072 :
34073 : void
34074 0 : SgTemplateParameter::set_type ( SgType* type )
34075 : {
34076 0 : ROSE_ASSERT (this != NULL);
34077 :
34078 : #if 0
34079 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34080 : // used to trigger marking transformations for the token-based unparsing.
34081 : printf ("SgTemplateParameter::set_type = %p = %s \n",this,this->class_name().c_str());
34082 : #endif
34083 :
34084 0 : set_isModified(true);
34085 :
34086 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34087 : if (p_type != NULL && type != NULL && p_type != type)
34088 : {
34089 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
34090 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34091 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
34092 : ROSE_ASSERT(false);
34093 : #endif
34094 : }
34095 : #endif
34096 0 : p_type = type;
34097 0 : }
34098 :
34099 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34100 :
34101 :
34102 : // End of memberFunctionString
34103 : // Start of memberFunctionString
34104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34105 :
34106 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34107 :
34108 : SgType*
34109 34471 : SgTemplateParameter::get_defaultTypeParameter () const
34110 : {
34111 34471 : ROSE_ASSERT (this != NULL);
34112 :
34113 : #if 0
34114 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34115 : // used to trigger marking transformations for the token-based unparsing.
34116 : printf ("SgTemplateParameter::get_defaultTypeParameter = %p = %s \n",this,this->class_name().c_str());
34117 : #endif
34118 :
34119 34471 : return p_defaultTypeParameter;
34120 : }
34121 :
34122 : void
34123 0 : SgTemplateParameter::set_defaultTypeParameter ( SgType* defaultTypeParameter )
34124 : {
34125 0 : ROSE_ASSERT (this != NULL);
34126 :
34127 : #if 0
34128 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34129 : // used to trigger marking transformations for the token-based unparsing.
34130 : printf ("SgTemplateParameter::set_defaultTypeParameter = %p = %s \n",this,this->class_name().c_str());
34131 : #endif
34132 :
34133 0 : set_isModified(true);
34134 :
34135 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34136 : if (p_defaultTypeParameter != NULL && defaultTypeParameter != NULL && p_defaultTypeParameter != defaultTypeParameter)
34137 : {
34138 : printf ("Warning: defaultTypeParameter = %p overwriting valid pointer p_defaultTypeParameter = %p \n",defaultTypeParameter,p_defaultTypeParameter);
34139 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34140 : printf ("Error fails assertion (p_defaultTypeParameter != NULL && defaultTypeParameter != NULL && p_defaultTypeParameter != defaultTypeParameter) is false\n");
34141 : ROSE_ASSERT(false);
34142 : #endif
34143 : }
34144 : #endif
34145 0 : p_defaultTypeParameter = defaultTypeParameter;
34146 0 : }
34147 :
34148 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34149 :
34150 :
34151 : // End of memberFunctionString
34152 : // Start of memberFunctionString
34153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34154 :
34155 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34156 :
34157 : SgExpression*
34158 1697 : SgTemplateParameter::get_expression () const
34159 : {
34160 1697 : ROSE_ASSERT (this != NULL);
34161 :
34162 : #if 0
34163 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34164 : // used to trigger marking transformations for the token-based unparsing.
34165 : printf ("SgTemplateParameter::get_expression = %p = %s \n",this,this->class_name().c_str());
34166 : #endif
34167 :
34168 1697 : return p_expression;
34169 : }
34170 :
34171 : void
34172 0 : SgTemplateParameter::set_expression ( SgExpression* expression )
34173 : {
34174 0 : ROSE_ASSERT (this != NULL);
34175 :
34176 : #if 0
34177 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34178 : // used to trigger marking transformations for the token-based unparsing.
34179 : printf ("SgTemplateParameter::set_expression = %p = %s \n",this,this->class_name().c_str());
34180 : #endif
34181 :
34182 0 : set_isModified(true);
34183 :
34184 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34185 : if (p_expression != NULL && expression != NULL && p_expression != expression)
34186 : {
34187 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
34188 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34189 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
34190 : ROSE_ASSERT(false);
34191 : #endif
34192 : }
34193 : #endif
34194 0 : p_expression = expression;
34195 0 : }
34196 :
34197 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34198 :
34199 :
34200 : // End of memberFunctionString
34201 : // Start of memberFunctionString
34202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34203 :
34204 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34205 :
34206 : SgExpression*
34207 0 : SgTemplateParameter::get_defaultExpressionParameter () const
34208 : {
34209 0 : ROSE_ASSERT (this != NULL);
34210 :
34211 : #if 0
34212 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34213 : // used to trigger marking transformations for the token-based unparsing.
34214 : printf ("SgTemplateParameter::get_defaultExpressionParameter = %p = %s \n",this,this->class_name().c_str());
34215 : #endif
34216 :
34217 0 : return p_defaultExpressionParameter;
34218 : }
34219 :
34220 : void
34221 0 : SgTemplateParameter::set_defaultExpressionParameter ( SgExpression* defaultExpressionParameter )
34222 : {
34223 0 : ROSE_ASSERT (this != NULL);
34224 :
34225 : #if 0
34226 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34227 : // used to trigger marking transformations for the token-based unparsing.
34228 : printf ("SgTemplateParameter::set_defaultExpressionParameter = %p = %s \n",this,this->class_name().c_str());
34229 : #endif
34230 :
34231 0 : set_isModified(true);
34232 :
34233 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34234 : if (p_defaultExpressionParameter != NULL && defaultExpressionParameter != NULL && p_defaultExpressionParameter != defaultExpressionParameter)
34235 : {
34236 : printf ("Warning: defaultExpressionParameter = %p overwriting valid pointer p_defaultExpressionParameter = %p \n",defaultExpressionParameter,p_defaultExpressionParameter);
34237 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34238 : printf ("Error fails assertion (p_defaultExpressionParameter != NULL && defaultExpressionParameter != NULL && p_defaultExpressionParameter != defaultExpressionParameter) is false\n");
34239 : ROSE_ASSERT(false);
34240 : #endif
34241 : }
34242 : #endif
34243 0 : p_defaultExpressionParameter = defaultExpressionParameter;
34244 0 : }
34245 :
34246 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34247 :
34248 :
34249 : // End of memberFunctionString
34250 : // Start of memberFunctionString
34251 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34252 :
34253 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34254 :
34255 : SgDeclarationStatement*
34256 0 : SgTemplateParameter::get_templateDeclaration () const
34257 : {
34258 0 : ROSE_ASSERT (this != NULL);
34259 :
34260 : #if 0
34261 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34262 : // used to trigger marking transformations for the token-based unparsing.
34263 : printf ("SgTemplateParameter::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
34264 : #endif
34265 :
34266 0 : return p_templateDeclaration;
34267 : }
34268 :
34269 : void
34270 0 : SgTemplateParameter::set_templateDeclaration ( SgDeclarationStatement* templateDeclaration )
34271 : {
34272 0 : ROSE_ASSERT (this != NULL);
34273 :
34274 : #if 0
34275 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34276 : // used to trigger marking transformations for the token-based unparsing.
34277 : printf ("SgTemplateParameter::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
34278 : #endif
34279 :
34280 0 : set_isModified(true);
34281 :
34282 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34283 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
34284 : {
34285 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
34286 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34287 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
34288 : ROSE_ASSERT(false);
34289 : #endif
34290 : }
34291 : #endif
34292 0 : p_templateDeclaration = templateDeclaration;
34293 0 : }
34294 :
34295 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34296 :
34297 :
34298 : // End of memberFunctionString
34299 : // Start of memberFunctionString
34300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34301 :
34302 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34303 :
34304 : SgDeclarationStatement*
34305 0 : SgTemplateParameter::get_defaultTemplateDeclarationParameter () const
34306 : {
34307 0 : ROSE_ASSERT (this != NULL);
34308 :
34309 : #if 0
34310 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34311 : // used to trigger marking transformations for the token-based unparsing.
34312 : printf ("SgTemplateParameter::get_defaultTemplateDeclarationParameter = %p = %s \n",this,this->class_name().c_str());
34313 : #endif
34314 :
34315 0 : return p_defaultTemplateDeclarationParameter;
34316 : }
34317 :
34318 : void
34319 0 : SgTemplateParameter::set_defaultTemplateDeclarationParameter ( SgDeclarationStatement* defaultTemplateDeclarationParameter )
34320 : {
34321 0 : ROSE_ASSERT (this != NULL);
34322 :
34323 : #if 0
34324 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34325 : // used to trigger marking transformations for the token-based unparsing.
34326 : printf ("SgTemplateParameter::set_defaultTemplateDeclarationParameter = %p = %s \n",this,this->class_name().c_str());
34327 : #endif
34328 :
34329 0 : set_isModified(true);
34330 :
34331 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34332 : if (p_defaultTemplateDeclarationParameter != NULL && defaultTemplateDeclarationParameter != NULL && p_defaultTemplateDeclarationParameter != defaultTemplateDeclarationParameter)
34333 : {
34334 : printf ("Warning: defaultTemplateDeclarationParameter = %p overwriting valid pointer p_defaultTemplateDeclarationParameter = %p \n",defaultTemplateDeclarationParameter,p_defaultTemplateDeclarationParameter);
34335 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34336 : printf ("Error fails assertion (p_defaultTemplateDeclarationParameter != NULL && defaultTemplateDeclarationParameter != NULL && p_defaultTemplateDeclarationParameter != defaultTemplateDeclarationParameter) is false\n");
34337 : ROSE_ASSERT(false);
34338 : #endif
34339 : }
34340 : #endif
34341 0 : p_defaultTemplateDeclarationParameter = defaultTemplateDeclarationParameter;
34342 0 : }
34343 :
34344 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34345 :
34346 :
34347 : // End of memberFunctionString
34348 : // Start of memberFunctionString
34349 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34350 :
34351 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34352 :
34353 : SgInitializedName*
34354 3636 : SgTemplateParameter::get_initializedName () const
34355 : {
34356 3636 : ROSE_ASSERT (this != NULL);
34357 :
34358 : #if 0
34359 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34360 : // used to trigger marking transformations for the token-based unparsing.
34361 : printf ("SgTemplateParameter::get_initializedName = %p = %s \n",this,this->class_name().c_str());
34362 : #endif
34363 :
34364 3636 : return p_initializedName;
34365 : }
34366 :
34367 : void
34368 0 : SgTemplateParameter::set_initializedName ( SgInitializedName* initializedName )
34369 : {
34370 0 : ROSE_ASSERT (this != NULL);
34371 :
34372 : #if 0
34373 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34374 : // used to trigger marking transformations for the token-based unparsing.
34375 : printf ("SgTemplateParameter::set_initializedName = %p = %s \n",this,this->class_name().c_str());
34376 : #endif
34377 :
34378 0 : set_isModified(true);
34379 :
34380 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34381 : if (p_initializedName != NULL && initializedName != NULL && p_initializedName != initializedName)
34382 : {
34383 : printf ("Warning: initializedName = %p overwriting valid pointer p_initializedName = %p \n",initializedName,p_initializedName);
34384 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34385 : printf ("Error fails assertion (p_initializedName != NULL && initializedName != NULL && p_initializedName != initializedName) is false\n");
34386 : ROSE_ASSERT(false);
34387 : #endif
34388 : }
34389 : #endif
34390 0 : p_initializedName = initializedName;
34391 0 : }
34392 :
34393 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34394 :
34395 :
34396 : // End of memberFunctionString
34397 : // Start of memberFunctionString
34398 : /* #line 21104 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
34399 :
34400 :
34401 21009 : void SgTemplateParameter::post_construction_initialization()
34402 : {
34403 : // JJW 10-26-2007 ensure that this object is not on the stack
34404 21009 : preventConstructionOnStack(this);
34405 :
34406 : #if 0
34407 : // DQ (11/28/2011): Commented out since this code prevents the ROSETTA generated constructor from working correctly.
34408 : // Values initialized in the constructor are reset by this code.
34409 :
34410 : p_parameterType = parameter_undefined;
34411 : p_type = NULL;
34412 : p_defaultTypeParameter = NULL;
34413 : p_expression = NULL;
34414 : p_defaultExpressionParameter = NULL;
34415 : p_templateDeclaration = NULL;
34416 : p_defaultTemplateDeclarationParameter = NULL;
34417 : #endif
34418 21009 : }
34419 :
34420 : // Different constructors for use in building the different types of parameters possible
34421 0 : SgTemplateParameter::SgTemplateParameter ( SgType* parameter, SgType* defaultParameter )
34422 : {
34423 : // This is normally called last (but because it is called first we had to comment out the
34424 : // initialization in the SgTemplateParameter::post_construction_initialization() function.
34425 0 : post_construction_initialization();
34426 :
34427 0 : p_parameterType = type_parameter;
34428 0 : p_type = parameter;
34429 0 : p_defaultTypeParameter = defaultParameter;
34430 :
34431 0 : p_expression = NULL;
34432 0 : p_defaultExpressionParameter = NULL;
34433 0 : p_templateDeclaration = NULL;
34434 0 : p_defaultTemplateDeclarationParameter = NULL;
34435 :
34436 0 : p_initializedName = NULL;
34437 0 : }
34438 :
34439 0 : SgTemplateParameter::SgTemplateParameter ( SgExpression* parameter, SgExpression* defaultParameter )
34440 : {
34441 : // This is normally called last (but because it is called first we had to comment out the
34442 : // initialization in the SgTemplateParameter::post_construction_initialization() function.
34443 0 : post_construction_initialization();
34444 :
34445 0 : p_parameterType = nontype_parameter;
34446 :
34447 : // DQ (11/28/2011): These were not initialized properly.
34448 : // p_expression = NULL;
34449 : // p_defaultExpressionParameter = NULL;
34450 0 : p_expression = parameter;
34451 0 : p_defaultExpressionParameter = defaultParameter;
34452 :
34453 0 : p_type = NULL;
34454 0 : p_defaultTypeParameter = NULL;
34455 0 : p_templateDeclaration = NULL;
34456 0 : p_defaultTemplateDeclarationParameter = NULL;
34457 :
34458 0 : p_initializedName = NULL;
34459 0 : }
34460 :
34461 0 : SgTemplateParameter::SgTemplateParameter ( SgTemplateDeclaration* parameter, SgTemplateDeclaration* defaultParameter )
34462 : {
34463 : // This is normally called last (but because it is called first we had to comment out the
34464 : // initialization in the SgTemplateParameter::post_construction_initialization() function.
34465 0 : post_construction_initialization();
34466 :
34467 0 : p_parameterType = template_parameter;
34468 0 : p_templateDeclaration = parameter;
34469 0 : p_defaultTemplateDeclarationParameter = defaultParameter;
34470 :
34471 0 : p_type = NULL;
34472 0 : p_defaultTypeParameter = NULL;
34473 0 : p_expression = NULL;
34474 0 : p_defaultExpressionParameter = NULL;
34475 :
34476 0 : p_initializedName = NULL;
34477 0 : }
34478 :
34479 : // DQ (8/10/2013): commonly names functions for SgTemplateParameter and SgTemplateArgument.
34480 : bool
34481 21052 : SgTemplateParameter::is_matching_type (const SgTemplateParameter & X, const SgTemplateParameter & Y)
34482 : {
34483 21052 : return (X.get_parameterType() == SgTemplateParameter::type_parameter) && (X.get_parameterType() == Y.get_parameterType());
34484 : }
34485 :
34486 : bool
34487 291 : SgTemplateParameter::is_matching_nontype (const SgTemplateParameter & X, const SgTemplateParameter & Y)
34488 : {
34489 291 : return (X.get_parameterType() == SgTemplateParameter::nontype_parameter) && (X.get_parameterType() == Y.get_parameterType());
34490 : }
34491 :
34492 : bool
34493 0 : SgTemplateParameter::is_matching_template(const SgTemplateParameter & X, const SgTemplateParameter & Y)
34494 : {
34495 0 : return (X.get_parameterType() == SgTemplateParameter::template_parameter) && (X.get_parameterType() == Y.get_parameterType());
34496 : }
34497 :
34498 : // DQ (5/19/2014): This is added to symetry in the functions that are template on either SgTemplateArgument or SgTemplateParameter.
34499 : bool
34500 0 : SgTemplateParameter::is_matching_template_pack_expansion (const SgTemplateParameter & X, const SgTemplateParameter & Y)
34501 : {
34502 : // There is not associated value for the SgTemplateParameter enums, so this function should always return SgTemplateParameter::is_matching_kind().
34503 : // return true;
34504 : // return (X.get_parameterType() == Y.get_parameterType());
34505 0 : return is_matching_kind(X,Y);
34506 : }
34507 :
34508 : bool
34509 0 : SgTemplateParameter::is_matching_kind (const SgTemplateParameter & X, const SgTemplateParameter & Y)
34510 : {
34511 0 : return (X.get_parameterType() == Y.get_parameterType());
34512 : }
34513 :
34514 :
34515 : SgName
34516 280 : SgTemplateParameter::get_mangled_name (void) const
34517 : {
34518 280 : ROSE_ASSERT(this != NULL);
34519 :
34520 : #if 0
34521 : // mprintf ("In SgTemplateParameter::get_mangled_name(): this = %p get_argumentType() = %d unparseToString() = %s \n",this,get_argumentType(),unparseToString().c_str());
34522 : mprintf ("In SgTemplateParameter::get_mangled_name(): this = %p get_argumentType() = %d \n",this,get_argumentType());
34523 : mprintf ("In SgTemplateParameter::get_mangled_name(): unparseToString() = %s \n",unparseToString().c_str());
34524 : #endif
34525 :
34526 280 : ostringstream mangled_name;
34527 280 : switch (get_parameterType())
34528 : {
34529 280 : case SgTemplateParameter::type_parameter:
34530 280 : {
34531 280 : const SgType* type = get_type();
34532 280 : assert (type != NULL);
34533 280 : mangled_name << type->get_mangled().str();
34534 280 : break;
34535 : }
34536 :
34537 0 : case SgTemplateParameter::nontype_parameter:
34538 0 : {
34539 0 : const SgExpression* expr = get_expression();
34540 0 : if (expr != NULL)
34541 : {
34542 0 : mangled_name << mangleExpression(expr);
34543 : }
34544 : else
34545 : {
34546 0 : ROSE_ASSERT(get_initializedName() != NULL);
34547 0 : ROSE_ASSERT(get_initializedName()->get_scope() != NULL);
34548 0 : mangled_name << get_initializedName()->get_name().str();
34549 : }
34550 : break;
34551 : }
34552 :
34553 0 : case SgTemplateParameter::template_parameter:
34554 0 : {
34555 0 : const SgDeclarationStatement* templateDeclaration = get_templateDeclaration();
34556 0 : ROSE_ASSERT(templateDeclaration != NULL);
34557 0 : mangled_name << templateDeclaration->get_mangled_name().str();
34558 0 : break;
34559 : }
34560 :
34561 0 : default:
34562 0 : {
34563 : // mangled_name << "UNKNOWN";
34564 0 : mprintf ("ERROR: In SgTemplateParameter::get_mangled_name(): default reached in switch: get_parameterType() = %d \n",get_parameterType());
34565 0 : ROSE_ASSERT(false);
34566 : break;
34567 : }
34568 : }
34569 :
34570 : #if 0
34571 : mprintf ("In SgTemplateParameter::get_mangled_name(): mangled_name = %s \n",mangled_name.str());
34572 : #endif
34573 :
34574 560 : string str_mangled_name (mangled_name.str());
34575 :
34576 : #if 1
34577 : // DQ (9/24/2012): Added test for template syntax in the generated mangled name (convert to std::string so we can simplify the test).
34578 280 : if ( str_mangled_name.find('<') != string::npos )
34579 : {
34580 0 : mprintf ("In SgTemplateParameter::get_mangled_name(): this = %p = %s mangled template argument name = %s \n",this,this->class_name().c_str(),str_mangled_name.c_str());
34581 : }
34582 280 : ROSE_ASSERT(str_mangled_name.find('<') == string::npos);
34583 : #endif
34584 :
34585 : // return SgName(str_mangled_name.c_str());
34586 560 : return str_mangled_name;
34587 : }
34588 :
34589 :
34590 :
34591 :
34592 : // End of memberFunctionString
34593 : // Start of memberFunctionString
34594 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
34595 :
34596 : // *** COMMON CODE SECTION BEGINS HERE ***
34597 :
34598 : #if 0
34599 : int
34600 : SgTemplateParameter::getVariant() const
34601 : {
34602 : // This function is used in ROSE while "variant()" is used in SAGE
34603 : assert(this != NULL);
34604 : return variant();
34605 : }
34606 : #endif
34607 :
34608 : // This function is used in ROSE in treeTraversal code
34609 : // eventually replaces getVariant() and variant()
34610 : // though after variant() has been removed for a while we will
34611 : // want to change the name of variantT() back to variant()
34612 : // (since the "T" was ment to stand for temporary).
34613 : // When this happens the variantT() will be depricated.
34614 : VariantT
34615 1998660 : SgTemplateParameter::variantT() const
34616 : {
34617 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
34618 1998660 : ROSE_ASSERT(this != NULL);
34619 1998660 : return V_SgTemplateParameter;
34620 : }
34621 :
34622 : #if 0
34623 : int
34624 : SgTemplateParameter::variant() const
34625 : {
34626 : // This function is used in SAGE
34627 : ROSE_ASSERT(this != NULL);
34628 : return TemplateParameterTag;
34629 : }
34630 : #endif
34631 :
34632 : ROSE_DLL_API const char*
34633 0 : SgTemplateParameter::sage_class_name() const
34634 : {
34635 0 : ROSE_ASSERT(this != NULL);
34636 0 : return "SgTemplateParameter";
34637 : }
34638 :
34639 : std::string
34640 14729 : SgTemplateParameter::class_name() const
34641 : {
34642 14729 : ROSE_ASSERT(this != NULL);
34643 14729 : return "SgTemplateParameter";
34644 : }
34645 :
34646 : // DQ (11/26/2005): Support for visitor pattern mechanims
34647 : // (inferior to ROSE traversal mechanism, experimental).
34648 : void
34649 300839 : SgTemplateParameter::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
34650 : {
34651 300839 : ROSE_ASSERT(this != NULL);
34652 300839 : visitor.visit(this);
34653 300839 : }
34654 :
34655 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
34656 0 : void SgTemplateParameter::accept (ROSE_VisitorPattern & visitor) {
34657 0 : ROSE_ASSERT(this != NULL);
34658 0 : visitor.visit(this);
34659 0 : }
34660 :
34661 : SgTemplateParameter*
34662 0 : SgTemplateParameter::addRegExpAttribute(std::string s, AstRegExAttribute* a)
34663 : {
34664 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
34665 : // This function is currently only supported for the AST used the represent Binary executables.
34666 : if (0 /* isSgAsmNode(this) != NULL */)
34667 : {
34668 : // Support for regex specification.
34669 : std::string prefixCode = "REGEX:";
34670 : addNewAttribute(prefixCode + s,a);
34671 : }
34672 : #endif
34673 :
34674 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
34675 0 : return this;
34676 : }
34677 :
34678 : // *** COMMON CODE SECTION ENDS HERE ***
34679 :
34680 :
34681 : // End of memberFunctionString
34682 : // Start of memberFunctionString
34683 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
34684 :
34685 :
34686 : #if 0
34687 : //! Error checking support
34688 : /*! Verifies the following:
34689 : - working getVariant() member function
34690 : - calls base class's error() member function
34691 : Every class has one of these functions.
34692 : */
34693 : bool
34694 : SgTemplateParameter::error()
34695 : {
34696 : // Put error checking here
34697 :
34698 : ROSE_ASSERT (this != NULL);
34699 : if (getVariant() != TemplateParameterTag)
34700 : {
34701 : printf ("Error in SgTemplateParameter::error(): SgTemplateParameter object has a %s variant \n",
34702 : Cxx_GrammarTerminalNames[getVariant()].name);
34703 : // printf ("Error in SgTemplateParameter::error() \n");
34704 : ROSE_ABORT();
34705 : }
34706 :
34707 : ROSE_ASSERT (getVariant() == TemplateParameterTag);
34708 : return SgSupport::error();
34709 : }
34710 : #endif
34711 :
34712 :
34713 :
34714 : // End of memberFunctionString
34715 :
34716 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
34717 :
34718 23147 : SgTemplateParameter* isSgTemplateParameter ( SgNode* inputDerivedClassPointer )
34719 : {
34720 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
34721 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
34722 : // So to fix this we return NULL directly when the input is NULL and avoid the
34723 : // dynamic_cast in this case. This is likely a performance improvement as well.
34724 : // return dynamic_cast<SgTemplateParameter*>(inputDerivedClassPointer);
34725 : // Milind Chabbi (8/28/2013): isSgTemplateParameter uses table-driven castability instead of c++ default dynamic_cast
34726 : // this improves the running time performance by 10-20%.
34727 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateParameter*>(inputDerivedClassPointer);
34728 23147 : return IS_SgTemplateParameter_FAST_MACRO(inputDerivedClassPointer);
34729 : }
34730 :
34731 : // DQ (11/8/2003): Added version of functions taking const pointer
34732 10090 : const SgTemplateParameter* isSgTemplateParameter ( const SgNode* inputDerivedClassPointer )
34733 : {
34734 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
34735 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
34736 : // So to fix this we return NULL directly when the input is NULL and avoid the
34737 : // dynamic_cast in this case. This is likely a performance improvement as well.
34738 : // return dynamic_cast<const SgTemplateParameter*>(inputDerivedClassPointer);
34739 : // Milind Chabbi (8/28/2013): isSgTemplateParameter uses table-driven castability instead of c++ default dynamic_cast
34740 : // this improves the running time performance by 10-20%.
34741 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateParameter*>(inputDerivedClassPointer);
34742 10090 : return IS_SgTemplateParameter_FAST_MACRO(inputDerivedClassPointer);
34743 : }
34744 :
34745 :
34746 :
34747 : /* #line 34748 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34748 :
34749 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
34750 :
34751 : /**
34752 : \brief Generated destructor
34753 :
34754 : This destructor is automatically generated (by ROSETTA). This destructor
34755 : only frees memory of data members associated with the parts of the current IR node which
34756 : are NOT traversed. Those data members that are part of a traversal can be freed using
34757 : a traversal (calling this destructor on all children in a post-order traversal). Such
34758 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
34759 :
34760 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
34761 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
34762 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
34763 :
34764 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
34765 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
34766 : pointers are not yet implemented to call delete on eash pointer in the container.
34767 : (This could be done by derivation from the STL containers to define containers that
34768 : automatically deleted their members.)
34769 :
34770 : */
34771 8668 : SgTemplateParameter::~SgTemplateParameter () {
34772 4334 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
34773 :
34774 :
34775 : // case: not a listType for parameterType
34776 4334 : p_parameterType = parameter_undefined; // non list case
34777 : // case: not a listType for type
34778 4334 : p_type = NULL; // non list case
34779 : // case: not a listType for defaultTypeParameter
34780 4334 : p_defaultTypeParameter = NULL; // non list case
34781 : // case: not a listType for expression
34782 4334 : p_expression = NULL; // non list case
34783 : // case: not a listType for defaultExpressionParameter
34784 4334 : p_defaultExpressionParameter = NULL; // non list case
34785 : // case: not a listType for templateDeclaration
34786 4334 : p_templateDeclaration = NULL; // non list case
34787 : // case: not a listType for defaultTemplateDeclarationParameter
34788 4334 : p_defaultTemplateDeclarationParameter = NULL; // non list case
34789 : // case: not a listType for initializedName
34790 4334 : p_initializedName = NULL; // non list case
34791 :
34792 : }
34793 :
34794 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
34795 8668 : }
34796 :
34797 :
34798 : /* #line 34799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34799 :
34800 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
34801 :
34802 : // Generated constructor
34803 21009 : SgTemplateParameter::SgTemplateParameter ( SgTemplateParameter::template_parameter_enum parameterType, SgType* type, SgType* defaultTypeParameter, SgExpression* expression, SgExpression* defaultExpressionParameter, SgDeclarationStatement* templateDeclaration, SgDeclarationStatement* defaultTemplateDeclarationParameter, SgInitializedName* initializedName )
34804 21009 : : SgSupport()
34805 : {
34806 : #ifdef DEBUG
34807 : // printf ("In SgTemplateParameter::SgTemplateParameter (SgTemplateParameter::template_parameter_enum parameterType, SgType* type, SgType* defaultTypeParameter, SgExpression* expression, SgExpression* defaultExpressionParameter, SgDeclarationStatement* templateDeclaration, SgDeclarationStatement* defaultTemplateDeclarationParameter, SgInitializedName* initializedName) sage_class_name() = %s \n",sage_class_name());
34808 : #endif
34809 : #if 0
34810 : // debugging information!
34811 : printf ("In SgTemplateParameter::SgTemplateParameter (SgTemplateParameter::template_parameter_enum parameterType, SgType* type, SgType* defaultTypeParameter, SgExpression* expression, SgExpression* defaultExpressionParameter, SgDeclarationStatement* templateDeclaration, SgDeclarationStatement* defaultTemplateDeclarationParameter, SgInitializedName* initializedName): this = %p = %s \n",this,this->class_name().c_str());
34812 : #endif
34813 :
34814 21009 : p_parameterType = parameterType;
34815 21009 : p_type = type;
34816 21009 : p_defaultTypeParameter = defaultTypeParameter;
34817 21009 : p_expression = expression;
34818 21009 : p_defaultExpressionParameter = defaultExpressionParameter;
34819 21009 : p_templateDeclaration = templateDeclaration;
34820 21009 : p_defaultTemplateDeclarationParameter = defaultTemplateDeclarationParameter;
34821 21009 : p_initializedName = initializedName;
34822 :
34823 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
34824 :
34825 : #if 0
34826 : // DQ (7/30/2014): Call a virtual function.
34827 : std::string s = this->class_name();
34828 : #endif
34829 :
34830 : // Test the variant virtual function
34831 : // assert(TemplateParameterTag == variant());
34832 21009 : assert(TemplateParameterTag == this->variant());
34833 21009 : ROSE_ASSERT(TemplateParameterTag == (int)(this->variantT()));
34834 21009 : post_construction_initialization();
34835 :
34836 : // Test the isSgTemplateParameter() function since it has been problematic
34837 21009 : assert(isSgTemplateParameter(this) != NULL);
34838 21009 : }
34839 :
34840 : // Generated constructor (all data members)
34841 :
34842 : /* #line 34843 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34843 :
34844 :
34845 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
34846 :
34847 :
34848 : // ********************************************************
34849 : // member functions common across all array grammar objects
34850 : // ********************************************************
34851 :
34852 :
34853 :
34854 : /* #line 34855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34855 :
34856 :
34857 :
34858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
34859 :
34860 : // ********************************************************
34861 : // member functions specific to each node in the grammar
34862 : // ********************************************************
34863 :
34864 :
34865 : /* #line 34866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
34866 :
34867 : // Start of memberFunctionString
34868 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34869 :
34870 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34871 :
34872 : SgTemplateArgument::template_argument_enum
34873 1881480 : SgTemplateArgument::get_argumentType () const
34874 : {
34875 1881480 : ROSE_ASSERT (this != NULL);
34876 :
34877 : #if 0
34878 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34879 : // used to trigger marking transformations for the token-based unparsing.
34880 : printf ("SgTemplateArgument::get_argumentType = %p = %s \n",this,this->class_name().c_str());
34881 : #endif
34882 :
34883 1881480 : return p_argumentType;
34884 : }
34885 :
34886 : void
34887 0 : SgTemplateArgument::set_argumentType ( SgTemplateArgument::template_argument_enum argumentType )
34888 : {
34889 0 : ROSE_ASSERT (this != NULL);
34890 :
34891 : #if 0
34892 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34893 : // used to trigger marking transformations for the token-based unparsing.
34894 : printf ("SgTemplateArgument::set_argumentType = %p = %s \n",this,this->class_name().c_str());
34895 : #endif
34896 :
34897 0 : set_isModified(true);
34898 :
34899 0 : p_argumentType = argumentType;
34900 0 : }
34901 :
34902 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34903 :
34904 :
34905 : // End of memberFunctionString
34906 : // Start of memberFunctionString
34907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34908 :
34909 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34910 :
34911 : bool
34912 8505 : SgTemplateArgument::get_isArrayBoundUnknownType () const
34913 : {
34914 8505 : ROSE_ASSERT (this != NULL);
34915 :
34916 : #if 0
34917 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34918 : // used to trigger marking transformations for the token-based unparsing.
34919 : printf ("SgTemplateArgument::get_isArrayBoundUnknownType = %p = %s \n",this,this->class_name().c_str());
34920 : #endif
34921 :
34922 8505 : return p_isArrayBoundUnknownType;
34923 : }
34924 :
34925 : void
34926 0 : SgTemplateArgument::set_isArrayBoundUnknownType ( bool isArrayBoundUnknownType )
34927 : {
34928 0 : ROSE_ASSERT (this != NULL);
34929 :
34930 : #if 0
34931 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34932 : // used to trigger marking transformations for the token-based unparsing.
34933 : printf ("SgTemplateArgument::set_isArrayBoundUnknownType = %p = %s \n",this,this->class_name().c_str());
34934 : #endif
34935 :
34936 0 : set_isModified(true);
34937 :
34938 0 : p_isArrayBoundUnknownType = isArrayBoundUnknownType;
34939 0 : }
34940 :
34941 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34942 :
34943 :
34944 : // End of memberFunctionString
34945 : // Start of memberFunctionString
34946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34947 :
34948 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34949 :
34950 : SgType*
34951 2246980 : SgTemplateArgument::get_type () const
34952 : {
34953 2246980 : ROSE_ASSERT (this != NULL);
34954 :
34955 : #if 0
34956 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34957 : // used to trigger marking transformations for the token-based unparsing.
34958 : printf ("SgTemplateArgument::get_type = %p = %s \n",this,this->class_name().c_str());
34959 : #endif
34960 :
34961 2246980 : return p_type;
34962 : }
34963 :
34964 : void
34965 0 : SgTemplateArgument::set_type ( SgType* type )
34966 : {
34967 0 : ROSE_ASSERT (this != NULL);
34968 :
34969 : #if 0
34970 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
34971 : // used to trigger marking transformations for the token-based unparsing.
34972 : printf ("SgTemplateArgument::set_type = %p = %s \n",this,this->class_name().c_str());
34973 : #endif
34974 :
34975 0 : set_isModified(true);
34976 :
34977 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
34978 : if (p_type != NULL && type != NULL && p_type != type)
34979 : {
34980 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
34981 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
34982 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
34983 : ROSE_ASSERT(false);
34984 : #endif
34985 : }
34986 : #endif
34987 0 : p_type = type;
34988 0 : }
34989 :
34990 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
34991 :
34992 :
34993 : // End of memberFunctionString
34994 : // Start of memberFunctionString
34995 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
34996 :
34997 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
34998 :
34999 : SgType*
35000 235164 : SgTemplateArgument::get_unparsable_type_alias () const
35001 : {
35002 235164 : ROSE_ASSERT (this != NULL);
35003 :
35004 : #if 0
35005 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35006 : // used to trigger marking transformations for the token-based unparsing.
35007 : printf ("SgTemplateArgument::get_unparsable_type_alias = %p = %s \n",this,this->class_name().c_str());
35008 : #endif
35009 :
35010 235164 : return p_unparsable_type_alias;
35011 : }
35012 :
35013 : void
35014 0 : SgTemplateArgument::set_unparsable_type_alias ( SgType* unparsable_type_alias )
35015 : {
35016 0 : ROSE_ASSERT (this != NULL);
35017 :
35018 : #if 0
35019 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35020 : // used to trigger marking transformations for the token-based unparsing.
35021 : printf ("SgTemplateArgument::set_unparsable_type_alias = %p = %s \n",this,this->class_name().c_str());
35022 : #endif
35023 :
35024 0 : set_isModified(true);
35025 :
35026 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
35027 : if (p_unparsable_type_alias != NULL && unparsable_type_alias != NULL && p_unparsable_type_alias != unparsable_type_alias)
35028 : {
35029 : printf ("Warning: unparsable_type_alias = %p overwriting valid pointer p_unparsable_type_alias = %p \n",unparsable_type_alias,p_unparsable_type_alias);
35030 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
35031 : printf ("Error fails assertion (p_unparsable_type_alias != NULL && unparsable_type_alias != NULL && p_unparsable_type_alias != unparsable_type_alias) is false\n");
35032 : ROSE_ASSERT(false);
35033 : #endif
35034 : }
35035 : #endif
35036 0 : p_unparsable_type_alias = unparsable_type_alias;
35037 0 : }
35038 :
35039 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35040 :
35041 :
35042 : // End of memberFunctionString
35043 : // Start of memberFunctionString
35044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35045 :
35046 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35047 :
35048 : SgExpression*
35049 501421 : SgTemplateArgument::get_expression () const
35050 : {
35051 501421 : ROSE_ASSERT (this != NULL);
35052 :
35053 : #if 0
35054 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35055 : // used to trigger marking transformations for the token-based unparsing.
35056 : printf ("SgTemplateArgument::get_expression = %p = %s \n",this,this->class_name().c_str());
35057 : #endif
35058 :
35059 501421 : return p_expression;
35060 : }
35061 :
35062 : void
35063 0 : SgTemplateArgument::set_expression ( SgExpression* expression )
35064 : {
35065 0 : ROSE_ASSERT (this != NULL);
35066 :
35067 : #if 0
35068 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35069 : // used to trigger marking transformations for the token-based unparsing.
35070 : printf ("SgTemplateArgument::set_expression = %p = %s \n",this,this->class_name().c_str());
35071 : #endif
35072 :
35073 0 : set_isModified(true);
35074 :
35075 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
35076 : if (p_expression != NULL && expression != NULL && p_expression != expression)
35077 : {
35078 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
35079 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
35080 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
35081 : ROSE_ASSERT(false);
35082 : #endif
35083 : }
35084 : #endif
35085 0 : p_expression = expression;
35086 0 : }
35087 :
35088 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35089 :
35090 :
35091 : // End of memberFunctionString
35092 : // Start of memberFunctionString
35093 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35094 :
35095 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35096 :
35097 : SgDeclarationStatement*
35098 323584 : SgTemplateArgument::get_templateDeclaration () const
35099 : {
35100 323584 : ROSE_ASSERT (this != NULL);
35101 :
35102 : #if 0
35103 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35104 : // used to trigger marking transformations for the token-based unparsing.
35105 : printf ("SgTemplateArgument::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
35106 : #endif
35107 :
35108 323584 : return p_templateDeclaration;
35109 : }
35110 :
35111 : void
35112 0 : SgTemplateArgument::set_templateDeclaration ( SgDeclarationStatement* templateDeclaration )
35113 : {
35114 0 : ROSE_ASSERT (this != NULL);
35115 :
35116 : #if 0
35117 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35118 : // used to trigger marking transformations for the token-based unparsing.
35119 : printf ("SgTemplateArgument::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
35120 : #endif
35121 :
35122 0 : set_isModified(true);
35123 :
35124 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
35125 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
35126 : {
35127 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
35128 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
35129 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
35130 : ROSE_ASSERT(false);
35131 : #endif
35132 : }
35133 : #endif
35134 0 : p_templateDeclaration = templateDeclaration;
35135 0 : }
35136 :
35137 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35138 :
35139 :
35140 : // End of memberFunctionString
35141 : // Start of memberFunctionString
35142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35143 :
35144 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35145 :
35146 : SgInitializedName*
35147 360265 : SgTemplateArgument::get_initializedName () const
35148 : {
35149 360265 : ROSE_ASSERT (this != NULL);
35150 :
35151 : #if 0
35152 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35153 : // used to trigger marking transformations for the token-based unparsing.
35154 : printf ("SgTemplateArgument::get_initializedName = %p = %s \n",this,this->class_name().c_str());
35155 : #endif
35156 :
35157 360265 : return p_initializedName;
35158 : }
35159 :
35160 : void
35161 8505 : SgTemplateArgument::set_initializedName ( SgInitializedName* initializedName )
35162 : {
35163 8505 : ROSE_ASSERT (this != NULL);
35164 :
35165 : #if 0
35166 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35167 : // used to trigger marking transformations for the token-based unparsing.
35168 : printf ("SgTemplateArgument::set_initializedName = %p = %s \n",this,this->class_name().c_str());
35169 : #endif
35170 :
35171 8505 : set_isModified(true);
35172 :
35173 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
35174 : if (p_initializedName != NULL && initializedName != NULL && p_initializedName != initializedName)
35175 : {
35176 : printf ("Warning: initializedName = %p overwriting valid pointer p_initializedName = %p \n",initializedName,p_initializedName);
35177 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
35178 : printf ("Error fails assertion (p_initializedName != NULL && initializedName != NULL && p_initializedName != initializedName) is false\n");
35179 : ROSE_ASSERT(false);
35180 : #endif
35181 : }
35182 : #endif
35183 8505 : p_initializedName = initializedName;
35184 8505 : }
35185 :
35186 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35187 :
35188 :
35189 : // End of memberFunctionString
35190 : // Start of memberFunctionString
35191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35192 :
35193 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35194 :
35195 : bool
35196 187423 : SgTemplateArgument::get_explicitlySpecified () const
35197 : {
35198 187423 : ROSE_ASSERT (this != NULL);
35199 :
35200 : #if 0
35201 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35202 : // used to trigger marking transformations for the token-based unparsing.
35203 : printf ("SgTemplateArgument::get_explicitlySpecified = %p = %s \n",this,this->class_name().c_str());
35204 : #endif
35205 :
35206 187423 : return p_explicitlySpecified;
35207 : }
35208 :
35209 : void
35210 6511 : SgTemplateArgument::set_explicitlySpecified ( bool explicitlySpecified )
35211 : {
35212 6511 : ROSE_ASSERT (this != NULL);
35213 :
35214 : #if 0
35215 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35216 : // used to trigger marking transformations for the token-based unparsing.
35217 : printf ("SgTemplateArgument::set_explicitlySpecified = %p = %s \n",this,this->class_name().c_str());
35218 : #endif
35219 :
35220 6511 : set_isModified(true);
35221 :
35222 6511 : p_explicitlySpecified = explicitlySpecified;
35223 6511 : }
35224 :
35225 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35226 :
35227 :
35228 : // End of memberFunctionString
35229 : // Start of memberFunctionString
35230 :
35231 :
35232 : // End of memberFunctionString
35233 : // Start of memberFunctionString
35234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35235 :
35236 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35237 :
35238 : SgTemplateArgument*
35239 0 : SgTemplateArgument::get_previous_instance () const
35240 : {
35241 0 : ROSE_ASSERT (this != NULL);
35242 :
35243 : #if 0
35244 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35245 : // used to trigger marking transformations for the token-based unparsing.
35246 : printf ("SgTemplateArgument::get_previous_instance = %p = %s \n",this,this->class_name().c_str());
35247 : #endif
35248 :
35249 0 : return p_previous_instance;
35250 : }
35251 :
35252 : void
35253 8505 : SgTemplateArgument::set_previous_instance ( SgTemplateArgument* previous_instance )
35254 : {
35255 8505 : ROSE_ASSERT (this != NULL);
35256 :
35257 : #if 0
35258 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35259 : // used to trigger marking transformations for the token-based unparsing.
35260 : printf ("SgTemplateArgument::set_previous_instance = %p = %s \n",this,this->class_name().c_str());
35261 : #endif
35262 :
35263 8505 : set_isModified(true);
35264 :
35265 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
35266 : if (p_previous_instance != NULL && previous_instance != NULL && p_previous_instance != previous_instance)
35267 : {
35268 : printf ("Warning: previous_instance = %p overwriting valid pointer p_previous_instance = %p \n",previous_instance,p_previous_instance);
35269 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
35270 : printf ("Error fails assertion (p_previous_instance != NULL && previous_instance != NULL && p_previous_instance != previous_instance) is false\n");
35271 : ROSE_ASSERT(false);
35272 : #endif
35273 : }
35274 : #endif
35275 8505 : p_previous_instance = previous_instance;
35276 8505 : }
35277 :
35278 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35279 :
35280 :
35281 : // End of memberFunctionString
35282 : // Start of memberFunctionString
35283 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35284 :
35285 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35286 :
35287 : SgTemplateArgument*
35288 0 : SgTemplateArgument::get_next_instance () const
35289 : {
35290 0 : ROSE_ASSERT (this != NULL);
35291 :
35292 : #if 0
35293 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35294 : // used to trigger marking transformations for the token-based unparsing.
35295 : printf ("SgTemplateArgument::get_next_instance = %p = %s \n",this,this->class_name().c_str());
35296 : #endif
35297 :
35298 0 : return p_next_instance;
35299 : }
35300 :
35301 : void
35302 8505 : SgTemplateArgument::set_next_instance ( SgTemplateArgument* next_instance )
35303 : {
35304 8505 : ROSE_ASSERT (this != NULL);
35305 :
35306 : #if 0
35307 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35308 : // used to trigger marking transformations for the token-based unparsing.
35309 : printf ("SgTemplateArgument::set_next_instance = %p = %s \n",this,this->class_name().c_str());
35310 : #endif
35311 :
35312 8505 : set_isModified(true);
35313 :
35314 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
35315 : if (p_next_instance != NULL && next_instance != NULL && p_next_instance != next_instance)
35316 : {
35317 : printf ("Warning: next_instance = %p overwriting valid pointer p_next_instance = %p \n",next_instance,p_next_instance);
35318 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
35319 : printf ("Error fails assertion (p_next_instance != NULL && next_instance != NULL && p_next_instance != next_instance) is false\n");
35320 : ROSE_ASSERT(false);
35321 : #endif
35322 : }
35323 : #endif
35324 8505 : p_next_instance = next_instance;
35325 8505 : }
35326 :
35327 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35328 :
35329 :
35330 : // End of memberFunctionString
35331 : // Start of memberFunctionString
35332 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
35333 :
35334 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
35335 :
35336 : bool
35337 256786 : SgTemplateArgument::get_is_pack_element () const
35338 : {
35339 256786 : ROSE_ASSERT (this != NULL);
35340 :
35341 : #if 0
35342 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35343 : // used to trigger marking transformations for the token-based unparsing.
35344 : printf ("SgTemplateArgument::get_is_pack_element = %p = %s \n",this,this->class_name().c_str());
35345 : #endif
35346 :
35347 256786 : return p_is_pack_element;
35348 : }
35349 :
35350 : void
35351 56795 : SgTemplateArgument::set_is_pack_element ( bool is_pack_element )
35352 : {
35353 56795 : ROSE_ASSERT (this != NULL);
35354 :
35355 : #if 0
35356 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
35357 : // used to trigger marking transformations for the token-based unparsing.
35358 : printf ("SgTemplateArgument::set_is_pack_element = %p = %s \n",this,this->class_name().c_str());
35359 : #endif
35360 :
35361 56795 : set_isModified(true);
35362 :
35363 56795 : p_is_pack_element = is_pack_element;
35364 56795 : }
35365 :
35366 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
35367 :
35368 :
35369 : // End of memberFunctionString
35370 : // Start of memberFunctionString
35371 : /* #line 21298 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
35372 :
35373 :
35374 63173 : void SgTemplateArgument::post_construction_initialization()
35375 : {
35376 : // JJW 10-26-2007 ensure that this object is not on the stack
35377 63173 : preventConstructionOnStack(this);
35378 :
35379 : #if 0
35380 : // DQ (11/22/2011): These are set in the constrcutors and should not be reset.
35381 : p_argumentType = argument_undefined;
35382 : p_type = NULL;
35383 : p_expression = NULL;
35384 :
35385 : // p_templateInstantiation = NULL;
35386 : p_templateDeclaration = NULL;
35387 : #endif
35388 :
35389 : // DQ (5/14/2011): Added to support name qualification on types referenced by template arguments.
35390 63173 : p_name_qualification_length = 0;
35391 63173 : p_type_elaboration_required = false;
35392 63173 : p_global_qualification_required = false;
35393 63173 : }
35394 :
35395 : // Different constructors for use in building the different types of arguments possible
35396 0 : SgTemplateArgument::SgTemplateArgument ( SgType* argument, bool explicitlySpecified )
35397 : {
35398 0 : post_construction_initialization();
35399 :
35400 0 : p_argumentType = type_argument;
35401 0 : p_type = argument;
35402 0 : p_explicitlySpecified = explicitlySpecified;
35403 :
35404 0 : p_expression = NULL;
35405 :
35406 : // DQ (11/22/2011): This is no longer set in the post_construction_initialization() function.
35407 0 : p_templateDeclaration = NULL;
35408 :
35409 : // Don't set the parent of a type!
35410 : // argument->set_parent(this);
35411 0 : }
35412 :
35413 0 : SgTemplateArgument::SgTemplateArgument ( SgExpression* argument, bool explicitlySpecified )
35414 : {
35415 0 : post_construction_initialization();
35416 :
35417 0 : p_argumentType = nontype_argument;
35418 0 : p_expression = argument;
35419 0 : p_explicitlySpecified = explicitlySpecified;
35420 :
35421 0 : p_type = NULL;
35422 :
35423 : // DQ (11/22/2011): This is no longer set in the post_construction_initialization() function.
35424 0 : p_templateDeclaration = NULL;
35425 :
35426 : // DQ (8/24/2006): Set the parent
35427 0 : argument->set_parent(this);
35428 0 : }
35429 :
35430 : #if 0
35431 : // DQ (8/24/2006): This is the incorrect constructor to have, it should have been a SgTemplateDeclaration (see new version below)
35432 : SgTemplateArgument::SgTemplateArgument ( SgTemplateInstantiationDecl* parameter, bool explicitlySpecified )
35433 : {
35434 : // Should this be a SgTemplateInstantiationDecl instead of a SgTemplateDeclaration?
35435 : post_construction_initialization();
35436 :
35437 : p_argumentType = template_argument;
35438 : p_templateInstantiation = parameter;
35439 : p_explicitlySpecified = explicitlySpecified;
35440 : }
35441 : #endif
35442 :
35443 : // DQ (8/24/2006): This is the more correct version to have.
35444 0 : SgTemplateArgument::SgTemplateArgument ( SgTemplateDeclaration* argument, bool explicitlySpecified )
35445 : {
35446 : // Should this be a SgTemplateInstantiationDecl instead of a SgTemplateDeclaration?
35447 0 : post_construction_initialization();
35448 :
35449 0 : p_argumentType = template_template_argument;
35450 0 : p_templateDeclaration = argument;
35451 0 : p_explicitlySpecified = explicitlySpecified;
35452 :
35453 : // DQ (11/22/2011): These are no longer set in the post_construction_initialization() function.
35454 0 : p_expression = NULL;
35455 0 : p_type = NULL;
35456 :
35457 : // DQ (8/24/2006): Set the parent ??? (make sure it is not already set!)
35458 : // This is likely a shared IR node, so we don't want to set the parent here!
35459 : // assert(argument->get_parent() == NULL);
35460 : // argument->set_parent(this);
35461 : #if PRINT_DEVELOPER_WARNINGS
35462 : mprintf ("Skipping setting of parent on SgTemplateDeclaration in SgTemplateArgument \n");
35463 : #endif
35464 0 : }
35465 :
35466 : // DQ (7/3/2013): Added new type of template argument type to support varadic template arguments.
35467 0 : SgTemplateArgument::SgTemplateArgument ( bool explicitlySpecified )
35468 : {
35469 0 : post_construction_initialization();
35470 :
35471 0 : p_argumentType = start_of_pack_expansion_argument;
35472 0 : p_expression = NULL;
35473 0 : p_explicitlySpecified = explicitlySpecified;
35474 :
35475 0 : p_type = NULL;
35476 :
35477 : // DQ (11/22/2011): This is no longer set in the post_construction_initialization() function.
35478 0 : p_templateDeclaration = NULL;
35479 :
35480 : // DQ (8/24/2006): Set the parent
35481 : // argument->set_parent(this);
35482 0 : }
35483 :
35484 : #define DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME 0
35485 :
35486 : // RV (2/2/2006): Added mangling of template arguments.
35487 : SgName
35488 296000 : SgTemplateArgument::get_mangled_name (void) const
35489 : {
35490 296000 : ROSE_ASSERT(this != NULL);
35491 :
35492 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35493 : // mprintf ("In SgTemplateArgument::get_mangled_name(): this = %p get_argumentType() = %d unparseToString() = %s \n",this,get_argumentType(),unparseToString().c_str());
35494 : mprintf ("In SgTemplateArgument::get_mangled_name(): this = %p get_argumentType() = %d \n",this,get_argumentType());
35495 : // mprintf ("In SgTemplateArgument::get_mangled_name(): unparseToString() = %s \n",unparseToString().c_str());
35496 : #endif
35497 :
35498 296000 : ostringstream mangled_name;
35499 296000 : switch (get_argumentType())
35500 : {
35501 260062 : case SgTemplateArgument::type_argument:
35502 260062 : {
35503 260062 : const SgType* type = get_type();
35504 260062 : assert (type != NULL);
35505 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35506 : mprintf ("In SgTemplateArgument::get_mangled_name(): type = %p = %s = %s \n",type,type->class_name().c_str(),type->unparseToString().c_str());
35507 : #endif
35508 260062 : SgName mangled_type = type->get_mangled();
35509 :
35510 260062 : SgNode* parent = this->get_parent();
35511 260062 : ROSE_ASSERT(parent != NULL);
35512 :
35513 : // DQ (9/21/2012): We need to support defining a mangled name that uses the name of the declaration where the template
35514 : // argument is used. E.g. In "template <class T> X<T> foo();", the return type "X<T>" shuld have a uniquely mangled
35515 : // name from that of a similar return type in any other function. The template declaration support will define an
35516 : // instantiation of "X<T>" which must be seperate from all other tempalte functions having a similar return type.
35517 : // This is the say that te restrict sharing of "X<T>" by supporting a mangled name that forces each functions reference
35518 : // to such a type to be different.
35519 260062 : ROSE_ASSERT(this->get_parent() != NULL);
35520 :
35521 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35522 : ROSE_ASSERT(parent != NULL);
35523 : mprintf ("In SgTemplateArgument::get_mangled_name(): case SgTemplateArgument::type_argument: this->get_parent() = %p = %s \n",this->get_parent(),this->get_parent()->class_name().c_str());
35524 : #endif
35525 260062 : SgTemplateInstantiationDecl* templateClassInstantiationDeclaration = isSgTemplateInstantiationDecl(parent);
35526 260062 : if (templateClassInstantiationDeclaration != NULL)
35527 : {
35528 : // DQ (12/26/2012): I think that to generate a unique mangled name we need to alwasy reference the same declaration, so set this and enforce that it is a valid pointer.
35529 37003 : templateClassInstantiationDeclaration = isSgTemplateInstantiationDecl(templateClassInstantiationDeclaration->get_firstNondefiningDeclaration());
35530 37003 : ROSE_ASSERT(templateClassInstantiationDeclaration != NULL);
35531 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35532 : mprintf ("In SgTemplateArgument::get_mangled_name(): case SgTemplateArgument::type_argument: templateClassInstantiationDeclaration = %p name = %s \n",templateClassInstantiationDeclaration,templateClassInstantiationDeclaration->get_name().str());
35533 : #endif
35534 37003 : mangled_type += Rose::StringUtility::numberToString(templateClassInstantiationDeclaration);
35535 :
35536 : // DQ (12/26/2012): This assert fails for copyAST_tests/copytest2007_40.C, but I think it is unreasonable
35537 : // to expect it to always be true. So I have made it a warning for now.
35538 37003 : if (templateClassInstantiationDeclaration != templateClassInstantiationDeclaration->get_firstNondefiningDeclaration())
35539 : {
35540 0 : mprintf ("Warning: In SgTemplateArgument::get_mangled_name(): templateClassInstantiationDeclaration used for mangled name was not the firstNondefiningDeclaration \n");
35541 : }
35542 37003 : ROSE_ASSERT(templateClassInstantiationDeclaration == templateClassInstantiationDeclaration->get_firstNondefiningDeclaration());
35543 : }
35544 : else
35545 : {
35546 : // DQ (8/19/2014): I am not clear how important it is to warn about this issue.
35547 : // #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
35548 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35549 : mprintf ("WARNING: In SgTemplateArgument::get_mangled_name(): parent declaration is not handled: this->get_parent() = %p = %s \n",parent,parent->class_name().c_str());
35550 : #endif
35551 : }
35552 :
35553 260062 : mangled_name << mangled_type.str();
35554 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35555 : mprintf ("In SgTemplateArgument::get_mangled_name(): case SgTemplateArgument::type_argument: mangled_type = %s \n",mangled_type.str());
35556 : #endif
35557 260062 : break;
35558 : }
35559 :
35560 23912 : case SgTemplateArgument::nontype_argument:
35561 23912 : {
35562 23912 : const SgExpression* expr = get_expression();
35563 :
35564 : // assert(expr != NULL);
35565 : // mangled_name << mangleExpression(expr);
35566 23912 : if (expr != NULL)
35567 : {
35568 60745 : mangled_name << mangleExpression(expr);
35569 : }
35570 : else
35571 : {
35572 0 : ROSE_ASSERT(get_initializedName() != NULL);
35573 0 : ROSE_ASSERT(get_initializedName()->get_scope() != NULL);
35574 : // mangled_name << mangleExpression(expr);
35575 : // mangled_name << get_initializedName()->get_mangled_name();
35576 0 : mangled_name << get_initializedName()->get_name().str();
35577 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35578 : mprintf ("In SgTemplateArgument::get_mangled_name(): case SgTemplateArgument::nontype_argument: get_initializedName()->get_name() = %s \n",get_initializedName()->get_name().str());
35579 : #endif
35580 : #if 0
35581 : mprintf ("In SgTemplateArgument::get_mangled_name(): case SgTemplateArgument::nontype_argument: Need to support name mangling for SgInitializedName \n");
35582 : ROSE_ASSERT(false);
35583 : #endif
35584 : }
35585 : break;
35586 : }
35587 :
35588 539 : case SgTemplateArgument::template_template_argument:
35589 539 : {
35590 : // DQ (12/22/2011): The new design has a SgTemplateClassDeclaration derived from a SgClassDeclaration (and
35591 : // the same for SgTemplateFunctionDeclaration, etc.) So we have to change this to support the new design.
35592 : // Now we have to use a common base class which would be the SgDeclarationStatement.
35593 : // const SgTemplateDeclaration* templateDeclaration = get_templateDeclaration();
35594 539 : const SgDeclarationStatement* templateDeclaration = get_templateDeclaration();
35595 539 : ROSE_ASSERT(templateDeclaration != NULL);
35596 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35597 : mprintf ("In SgTemplateArgument::get_mangled_name(): case SgTemplateArgument::template_template_argument: = %p = %s \n",templateDeclaration,templateDeclaration->class_name().c_str());
35598 : #endif
35599 :
35600 539 : SgName mangled_templateDeclaration = templateDeclaration->get_mangled_name();
35601 :
35602 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35603 : mprintf ("Mangling of template template argument to template type not well tested yet mangled name = %s \n",mangled_templateDeclaration.str());
35604 : #endif
35605 539 : mangled_name << mangled_templateDeclaration.str();
35606 539 : break;
35607 : }
35608 :
35609 : // DQ (5/19/2014): Added support for varadic template argument.
35610 11487 : case SgTemplateArgument::start_of_pack_expansion_argument:
35611 11487 : {
35612 11487 : mangled_name << "start_of_pack_expansion_argument";
35613 : break;
35614 : }
35615 :
35616 0 : default:
35617 0 : {
35618 : // mangled_name << "UNKNOWN";
35619 0 : mprintf ("ERROR: In SgTemplateArgument::get_mangled_name(): default reached in switch: get_argumentType() = %d \n",get_argumentType());
35620 0 : ROSE_ASSERT(false);
35621 : break;
35622 : }
35623 : }
35624 :
35625 : #if DEBUG_TEMPLATE_ARGUMENT_GET_MANGLED_NAME
35626 : mprintf ("In SgTemplateArgument::get_mangled_name(): mangled_name = %s \n",mangled_name.str().c_str());
35627 : #endif
35628 :
35629 592000 : string str_mangled_name (mangled_name.str());
35630 :
35631 : #if 1
35632 : // DQ (9/24/2012): Added test for template syntax in the generated mangled name (convert to std::string so we can simplify the test).
35633 296000 : if ( str_mangled_name.find('<') != string::npos )
35634 : {
35635 0 : mprintf ("In SgTemplateArgument::get_mangled_name(): this = %p = %s mangled template argument name = %s \n",this,this->class_name().c_str(),str_mangled_name.c_str());
35636 : }
35637 296000 : ROSE_ASSERT(str_mangled_name.find('<') == string::npos);
35638 : #endif
35639 :
35640 : // return SgName(str_mangled_name.c_str());
35641 592000 : return str_mangled_name;
35642 : }
35643 :
35644 :
35645 : // DQ (6/9/2007): Some template arguments have a concept of scope, this is required to get the name qualification correct.
35646 : SgScopeStatement*
35647 21883 : SgTemplateArgument::get_scope () const
35648 : {
35649 : // DQ (6/9/2007): This function traverses through the parents to the first scope (used for name qualification support of template arguments)
35650 :
35651 21883 : const SgNode* parentNode = this;
35652 21883 : ROSE_ASSERT(parentNode != NULL);
35653 :
35654 66912 : while ( (isSgScopeStatement(parentNode) == NULL) && (parentNode->get_parent() != NULL) )
35655 : {
35656 45029 : ROSE_ASSERT(parentNode != NULL);
35657 45029 : parentNode = parentNode->get_parent();
35658 45029 : ROSE_ASSERT(parentNode != NULL);
35659 : }
35660 :
35661 21883 : ROSE_ASSERT(parentNode != NULL);
35662 :
35663 : // Check to see if we made it back to the root (current root is SgProject).
35664 : // It is also OK to stop at a node for which get_parent() returns NULL (SgType and SgSymbol nodes).
35665 21883 : if ( isSgScopeStatement(parentNode) == NULL &&
35666 21883 : dynamic_cast<const SgType*>(parentNode) == NULL &&
35667 0 : dynamic_cast<const SgSymbol*>(parentNode) == NULL )
35668 : {
35669 0 : mprintf ("Error in SgTemplateArgument::get_scope(): could not trace back to SgScopeStatement node this = %p = %s parentNode = %p = %s \n",this,this->class_name().c_str(),parentNode,parentNode->class_name().c_str());
35670 0 : const SgTemplateInstantiationDecl* templateInstantiation = isSgTemplateInstantiationDecl(parentNode);
35671 0 : if (templateInstantiation != NULL)
35672 : {
35673 0 : mprintf ("templateInstantiation->get_name() = %s \n",templateInstantiation->get_name().str());
35674 :
35675 : // DQ (8/23/2012): This is not defined for a SgTemplateInstantiationDecl (which is not a template).
35676 : // mprintf ("templateInstantiation->get_template_name() = %s \n",templateInstantiation->get_template_name().str());
35677 0 : templateInstantiation->get_startOfConstruct()->display("Error in SgTemplateArgument::get_scope()");
35678 : }
35679 :
35680 0 : if (parentNode->get_parent() == NULL)
35681 : {
35682 0 : mprintf ("Error: parent not set for parentNode = %p = %s \n",parentNode,parentNode->class_name().c_str());
35683 : }
35684 :
35685 0 : ROSE_ASSERT(parentNode->get_parent() != NULL);
35686 :
35687 0 : return NULL;
35688 : }
35689 : else
35690 : {
35691 21883 : if ( dynamic_cast<const SgType*>(parentNode) != NULL || dynamic_cast<const SgSymbol*>(parentNode) != NULL )
35692 : {
35693 0 : mprintf ("Error: can't locate an associated SgStatement from SgTemplateArgument = %p \n",this);
35694 0 : return NULL;
35695 : }
35696 : }
35697 :
35698 : // Make sure we have a SgStatement node
35699 21883 : const SgScopeStatement* scopeStatement = isSgScopeStatement(parentNode);
35700 21883 : assert (scopeStatement != NULL);
35701 :
35702 : // return statement;
35703 : return const_cast<SgScopeStatement*>(scopeStatement);
35704 : }
35705 :
35706 : #if 0
35707 : // Not the correct idea!
35708 : SgScopeStatement*
35709 : SgTemplateArgument::get_scope () const
35710 : {
35711 : SgScopeStatement* scope = NULL;
35712 : switch (get_argumentType())
35713 : {
35714 : case SgTemplateArgument::type_argument:
35715 : {
35716 : const SgType* type = get_type();
35717 : assert (type != NULL);
35718 : const SgNamedType* namedType = isSgNamedType(type);
35719 : if (namedType != NULL)
35720 : {
35721 : assert(namedType->get_declaration() != NULL);
35722 : scope = namedType->get_declaration()->get_scope();
35723 : }
35724 : break;
35725 : }
35726 :
35727 : case SgTemplateArgument::nontype_argument:
35728 : {
35729 : // Not clear if the scope should be defined here!
35730 : // const SgExpression* expr = get_expression();
35731 : assert(get_expression() != NULL);
35732 : scope = NULL;
35733 : break;
35734 : }
35735 :
35736 : case SgTemplateArgument::template_template_argument:
35737 : {
35738 : const SgTemplateDeclaration* templateDeclaration = get_templateDeclaration();
35739 : assert (templateDeclaration != NULL);
35740 :
35741 : scope = templateDeclaration->get_scope();
35742 : break;
35743 : }
35744 :
35745 : default:
35746 : {
35747 : mprintf ("Error in SgTemplateArgument::get_scope(): default reached! \n");
35748 : assert (false);
35749 : break;
35750 : }
35751 : }
35752 :
35753 : return scope;
35754 : }
35755 : #endif
35756 :
35757 : #if 1
35758 : // DQ (2/10/2019): Debugging information
35759 : std::string
35760 0 : SgTemplateArgument::template_argument_kind () const
35761 : {
35762 0 : std::string kindOfTemplateArgument;
35763 :
35764 0 : switch (get_argumentType())
35765 : {
35766 0 : case SgTemplateArgument::type_argument:
35767 0 : {
35768 0 : const SgType* type = get_type();
35769 0 : assert (type != NULL);
35770 0 : const SgNamedType* namedType = isSgNamedType(type);
35771 0 : if (namedType != NULL)
35772 : {
35773 0 : assert(namedType->get_declaration() != NULL);
35774 : }
35775 0 : kindOfTemplateArgument = "type_argument";
35776 : break;
35777 : }
35778 :
35779 0 : case SgTemplateArgument::nontype_argument:
35780 0 : {
35781 : // Not clear if the scope should be defined here!
35782 : // const SgExpression* expr = get_expression();
35783 : // assert(get_expression() != NULL);
35784 0 : if (get_expression() == NULL)
35785 : {
35786 0 : mprintf ("NOTE: In SgTemplateArgument::template_argument_kind(): case SgTemplateArgument::nontype_argument: get_expression() == NULL: what is this? \n");
35787 0 : mprintf (" --- get_type() = %p \n",get_type());
35788 0 : mprintf (" --- get_initializedName() = %p \n",get_initializedName());
35789 0 : mprintf (" --- get_templateDeclaration() = %p \n",get_templateDeclaration());
35790 : }
35791 :
35792 0 : kindOfTemplateArgument = "nontype_argument";
35793 : break;
35794 : }
35795 :
35796 0 : case SgTemplateArgument::template_template_argument:
35797 0 : {
35798 : // const SgTemplateDeclaration* templateDeclaration = get_templateDeclaration();
35799 : // assert (templateDeclaration != NULL);
35800 :
35801 0 : kindOfTemplateArgument = "template_template_argument";
35802 : break;
35803 : }
35804 :
35805 0 : case SgTemplateArgument::start_of_pack_expansion_argument:
35806 0 : {
35807 0 : kindOfTemplateArgument = "start_of_pack_expansion_argument";
35808 : break;
35809 : }
35810 :
35811 0 : default:
35812 0 : {
35813 0 : mprintf ("Error in SgTemplateArgument::template_kind(): default reached! \n");
35814 0 : assert (false);
35815 : break;
35816 : }
35817 : }
35818 :
35819 0 : return kindOfTemplateArgument;
35820 : }
35821 : #endif
35822 :
35823 :
35824 : bool
35825 157466 : SgTemplateArgument::isTemplateArgumentFromAnonymousClass() const
35826 : {
35827 157466 : bool isAnonymous = false;
35828 :
35829 : #define DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS 0
35830 :
35831 157466 : bool hasLambdaFollowed = false;
35832 :
35833 157466 : if (SgClassType * ctype = isSgClassType (this->get_type()))
35834 : {
35835 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS
35836 : mprintf ("ctype != NULL \n");
35837 : #endif
35838 41274 : if (SgNode* pnode = ctype->get_declaration()->get_parent())
35839 : {
35840 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS
35841 : mprintf ("pnode != NULL \n");
35842 : #endif
35843 41274 : if (isSgLambdaExp(pnode))
35844 : {
35845 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS
35846 : mprintf ("Found a SgLambdaExp parent for the class: set hasLambdaFollowed = true \n");
35847 : #endif
35848 0 : hasLambdaFollowed = true;
35849 : }
35850 : }
35851 :
35852 : // DQ (1/21/2018): Check if this is an unnamed class (used as a template argument, which is not alloweded, so we should not unparse it).
35853 : // bool isAnonymous = isAnonymousClass(ctype);
35854 :
35855 : // SgClassType* classType = isSgClassType(templateArgumentType);
35856 41274 : SgClassType* classType = ctype;
35857 41274 : if (classType != NULL)
35858 : {
35859 41274 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(classType->get_declaration());
35860 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS
35861 : mprintf ("In isAnonymousClass(): case SgTemplateArgument::type_argument: classDeclaration = %p = %s classDeclaration->get_name() = %s \n",
35862 : classDeclaration,classDeclaration->class_name().c_str(),classDeclaration->get_name().str());
35863 : #endif
35864 122881 : bool isUnnamed = (string(classDeclaration->get_name()).substr(0,14) == "__anonymous_0x");
35865 : #if 0
35866 : if (isUnnamed == true)
35867 : {
35868 : mprintf ("In isAnonymousClass(): case SgTemplateArgument::type_argument: isUnnamed = %s \n",isUnnamed ? "true" : "false");
35869 : }
35870 : #endif
35871 41274 : isAnonymous = isUnnamed;
35872 : }
35873 :
35874 41274 : if (isAnonymous == true)
35875 : {
35876 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS || 0
35877 : mprintf ("isAnonymous == true: set hasLambdaFollowed = true \n");
35878 : #endif
35879 : // DQ (1/21/2018): This is mixing logic for explicitlySpecified with something Liao introduced
35880 : // which checks for a trailing lambda function. So we should fix this up later.
35881 0 : hasLambdaFollowed = true;
35882 : }
35883 : #if 0
35884 : else
35885 : {
35886 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS
35887 : mprintf ("isAnonymous == false \n");
35888 : #endif
35889 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(ctype->get_declaration());
35890 : if (classDeclaration != NULL)
35891 : {
35892 : mprintf ("In unparseTemplateArgumentList(): last template argument: classDeclaration->get_name() = %s \n",classDeclaration->get_name().str());
35893 : }
35894 : }
35895 : #endif
35896 : }
35897 :
35898 : #if DEBUG_IS_TEMPLATE_ARGUMENT_FROM_ANONYOUS_CLASS
35899 : mprintf ("Leaving SgTemplateArgument::isTemplateArgumentFromAnonymousClass(): isAnonymous = %s hasLambdaFollowed = %s \n",isAnonymous ? "true" : "false",hasLambdaFollowed ? "true" : "false");
35900 : #endif
35901 :
35902 : // return (isAnonymous == true);
35903 314932 : return (isAnonymous == true) || (hasLambdaFollowed == true);
35904 : }
35905 :
35906 :
35907 :
35908 : SgName
35909 6678 : SgTemplateArgument::get_qualified_name_prefix() const
35910 : {
35911 : // DQ (5/29/2011): Added to support for new qualified name generation.
35912 : // This only applies to specific SgSupport IR nodes:
35913 : // SgBaseClass
35914 : // SgTemplateArgument
35915 :
35916 : // #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
35917 : #if 0
35918 : // DQ (9/27/2012): This does appear to be called in processing test2004_127.C.
35919 : mprintf ("This is not called see the function: SgTemplateArgument::get_qualified_name_prefix_for_type() \n");
35920 : #endif
35921 :
35922 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
35923 : // different and so it depends upon where the type is referenced. Thus the qualified name is
35924 : // stored in a map to the IR node that references the type.
35925 6678 : SgName nameQualifier;
35926 6678 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgTemplateArgument*>(this));
35927 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
35928 :
35929 6678 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
35930 : {
35931 6678 : nameQualifier = i->second;
35932 : // mprintf ("Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
35933 : }
35934 :
35935 : // mprintf ("nameQualifier for SgBaseClass = %s = %s \n",class_name().c_str(),nameQualifier.str());
35936 :
35937 6678 : return nameQualifier;
35938 : }
35939 :
35940 : SgName
35941 64128 : SgTemplateArgument::get_qualified_name_prefix_for_type() const
35942 : {
35943 : // DQ (5/29/2011): Added to support for new qualified name generation.
35944 :
35945 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
35946 : // different and so it depends upon where the type is referenced. Thus the qualified name is
35947 : // stored in a map to the IR node that references the type.
35948 64128 : SgName nameQualifier;
35949 64128 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgTemplateArgument*>(this));
35950 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
35951 :
35952 64128 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
35953 : {
35954 45017 : nameQualifier = i->second;
35955 : #if 0
35956 : mprintf ("Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
35957 : #endif
35958 : }
35959 :
35960 : #if 0
35961 : mprintf ("nameQualifier for SgTemplateArgument = %s = %s \n",class_name().c_str(),nameQualifier.str());
35962 : #endif
35963 :
35964 64128 : return nameQualifier;
35965 : }
35966 :
35967 : // DQ (8/10/2013): commonly names functions for SgTemplateParameter and SgTemplateArgument.
35968 : bool
35969 38147 : SgTemplateArgument::is_matching_type (const SgTemplateArgument & X, const SgTemplateArgument & Y)
35970 : {
35971 38147 : return (X.get_argumentType() == SgTemplateArgument::type_argument) && (X.get_argumentType() == Y.get_argumentType());
35972 : }
35973 :
35974 : bool
35975 1521 : SgTemplateArgument::is_matching_nontype (const SgTemplateArgument & X, const SgTemplateArgument & Y)
35976 : {
35977 1521 : return (X.get_argumentType() == SgTemplateArgument::nontype_argument) && (X.get_argumentType() == Y.get_argumentType());
35978 : }
35979 :
35980 : bool
35981 1014 : SgTemplateArgument::is_matching_template(const SgTemplateArgument & X, const SgTemplateArgument & Y)
35982 : {
35983 1014 : return (X.get_argumentType() == SgTemplateArgument::template_template_argument) && (X.get_argumentType() == Y.get_argumentType());
35984 : }
35985 :
35986 : // DQ (5/19/2014): Added support for matching on this kind of template argument (only applies to SgTemplateArgument and not SgTemplateParemeter).
35987 : bool
35988 1014 : SgTemplateArgument::is_matching_template_pack_expansion (const SgTemplateArgument & X, const SgTemplateArgument & Y)
35989 : {
35990 1014 : return (X.get_argumentType() == SgTemplateArgument::start_of_pack_expansion_argument) && (X.get_argumentType() == Y.get_argumentType());
35991 : }
35992 :
35993 : bool
35994 1014 : SgTemplateArgument::is_matching_kind (const SgTemplateArgument & X, const SgTemplateArgument & Y)
35995 : {
35996 1014 : return (X.get_argumentType() == Y.get_argumentType());
35997 : }
35998 :
35999 :
36000 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
36001 : // so that we could avoid them setting the isModified flag which is a problem in the
36002 : // name qualification support for C++ (interfering with the token-based unparsing).
36003 : int
36004 507492 : SgTemplateArgument::get_name_qualification_length () const
36005 : {
36006 507492 : ROSE_ASSERT (this != NULL);
36007 507492 : return p_name_qualification_length;
36008 : }
36009 :
36010 : void
36011 125159 : SgTemplateArgument::set_name_qualification_length ( int name_qualification_length )
36012 : {
36013 125159 : ROSE_ASSERT (this != NULL);
36014 : // This can't be called by the name qualification API (see test2015_26.C).
36015 : // set_isModified(true);
36016 :
36017 125159 : p_name_qualification_length = name_qualification_length;
36018 125159 : }
36019 :
36020 : bool
36021 272328 : SgTemplateArgument::get_type_elaboration_required () const
36022 : {
36023 272328 : ROSE_ASSERT (this != NULL);
36024 272328 : return p_type_elaboration_required;
36025 : }
36026 :
36027 : void
36028 125159 : SgTemplateArgument::set_type_elaboration_required ( bool type_elaboration_required )
36029 : {
36030 125159 : ROSE_ASSERT (this != NULL);
36031 : // This can't be called by the name qualification API (see test2015_26.C).
36032 : // set_isModified(true);
36033 :
36034 125159 : p_type_elaboration_required = type_elaboration_required;
36035 125159 : }
36036 :
36037 : bool
36038 272328 : SgTemplateArgument::get_global_qualification_required () const
36039 : {
36040 272328 : ROSE_ASSERT (this != NULL);
36041 272328 : return p_global_qualification_required;
36042 : }
36043 :
36044 : void
36045 125159 : SgTemplateArgument::set_global_qualification_required ( bool global_qualification_required )
36046 : {
36047 125159 : ROSE_ASSERT (this != NULL);
36048 :
36049 : // This can't be called by the name qualification API (see test2015_26.C).
36050 : // set_isModified(true);
36051 :
36052 125159 : p_global_qualification_required = global_qualification_required;
36053 125159 : }
36054 :
36055 : bool
36056 18680 : SgTemplateArgument::get_requiresGlobalNameQualificationOnType () const
36057 : {
36058 18680 : ROSE_ASSERT (this != NULL);
36059 18680 : return p_requiresGlobalNameQualificationOnType;
36060 : }
36061 :
36062 : void
36063 0 : SgTemplateArgument::set_requiresGlobalNameQualificationOnType ( bool requiresGlobalNameQualificationOnType )
36064 : {
36065 0 : ROSE_ASSERT (this != NULL);
36066 : // This can't be called by the name qualification API (see test2015_26.C).
36067 : // set_isModified(true);
36068 :
36069 0 : p_requiresGlobalNameQualificationOnType = requiresGlobalNameQualificationOnType;
36070 0 : }
36071 :
36072 : int
36073 18680 : SgTemplateArgument::get_name_qualification_length_for_type () const
36074 : {
36075 18680 : ROSE_ASSERT (this != NULL);
36076 18680 : return p_name_qualification_length_for_type;
36077 : }
36078 :
36079 : void
36080 18680 : SgTemplateArgument::set_name_qualification_length_for_type ( int name_qualification_length_for_type )
36081 : {
36082 18680 : ROSE_ASSERT (this != NULL);
36083 : // This can't be called by the name qualification API (see test2015_26.C).
36084 : // set_isModified(true);
36085 :
36086 18680 : p_name_qualification_length_for_type = name_qualification_length_for_type;
36087 18680 : }
36088 :
36089 : // DQ (6/11/2015): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
36090 : bool
36091 18680 : SgTemplateArgument::get_type_elaboration_required_for_type() const
36092 : {
36093 18680 : ROSE_ASSERT (this != NULL);
36094 18680 : return p_type_elaboration_required_for_type;
36095 : }
36096 :
36097 : void
36098 18680 : SgTemplateArgument::set_type_elaboration_required_for_type(bool type_elaboration_required_for_type)
36099 : {
36100 18680 : ROSE_ASSERT (this != NULL);
36101 : // This can't be called by the name qualification API (see test2015_26.C).
36102 : // set_isModified(true);
36103 :
36104 18680 : p_type_elaboration_required_for_type = type_elaboration_required_for_type;
36105 18680 : }
36106 :
36107 : // DQ (6/11/2015): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
36108 : bool
36109 18680 : SgTemplateArgument::get_global_qualification_required_for_type() const
36110 : {
36111 18680 : ROSE_ASSERT (this != NULL);
36112 18680 : return p_global_qualification_required_for_type;
36113 : }
36114 :
36115 : void
36116 18680 : SgTemplateArgument::set_global_qualification_required_for_type(bool global_qualification_required_for_type)
36117 : {
36118 18680 : ROSE_ASSERT (this != NULL);
36119 : // This can't be called by the name qualification API (see test2015_26.C).
36120 : // set_isModified(true);
36121 :
36122 18680 : p_global_qualification_required_for_type = global_qualification_required_for_type;
36123 18680 : }
36124 :
36125 : void
36126 0 : SgTemplateArgument::display( const std::string & label) const
36127 : {
36128 : // DQ (5/22/2016): Adding display function for debugging.
36129 :
36130 0 : ROSE_ASSERT(this != NULL);
36131 :
36132 0 : switch (get_argumentType())
36133 : {
36134 0 : case SgTemplateArgument::type_argument:
36135 0 : {
36136 0 : const SgType* type = get_type();
36137 0 : assert (type != NULL);
36138 : #if 1
36139 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
36140 0 : printf ("In SgTemplateArgument::display(): type = %p = %s = %s \n",type,type->class_name().c_str(),type->unparseToString().c_str());
36141 : #endif
36142 0 : Rose_STL_Container<SgType*> typeChain = type->getInternalTypes();
36143 :
36144 : // Debugging output.
36145 0 : mprintf (" --- Output of type chain for template argument \n");
36146 0 : for (size_t i = 0; i < typeChain.size(); i++)
36147 : {
36148 0 : SgType* element_type = typeChain[i];
36149 0 : printf (" --- element_type = %p = %s \n",element_type,element_type->class_name().c_str());
36150 0 : SgModifierType* modifierType = isSgModifierType(element_type);
36151 0 : if (modifierType != NULL)
36152 : {
36153 : // modifierType->get_typeModifier().display("X type chain");
36154 0 : string s = modifierType->get_typeModifier().displayString();
36155 0 : printf (" ------ type chain modifier: %s \n",s.c_str());
36156 : }
36157 : }
36158 0 : break;
36159 : }
36160 :
36161 0 : case SgTemplateArgument::nontype_argument:
36162 0 : {
36163 0 : const SgExpression* expr = get_expression();
36164 :
36165 : // DQ (12/28/2018): Added assertion.
36166 : // ROSE_ASSERT(expr != NULL);
36167 : #if 0
36168 : // DQ (12/28/2018): original version of code.
36169 : printf ("SgTemplateArgument::nontype_argument: expr = %s \n",expr->unparseToString().c_str());
36170 : #else
36171 : // DQ (12/28/2018): This is a better implementation (it was here, but commented out).
36172 0 : if (expr != NULL)
36173 : {
36174 0 : printf ("SgTemplateArgument::nontype_argument: expr = %s \n",expr->unparseToString().c_str());
36175 : }
36176 : else
36177 : {
36178 0 : ROSE_ASSERT(get_initializedName() != NULL);
36179 0 : ROSE_ASSERT(get_initializedName()->get_scope() != NULL);
36180 :
36181 : // DQ (12/28/2018): original version of code, fixed to output the name.
36182 : // printf ("SgTemplateArgument::nontype_argument: expr = %s \n",expr->unparseToString().c_str());
36183 0 : printf ("SgTemplateArgument::nontype_argument: initializedName = %s \n",get_initializedName()->get_name().str());
36184 : }
36185 : #endif
36186 : break;
36187 : }
36188 :
36189 0 : case SgTemplateArgument::template_template_argument:
36190 0 : {
36191 0 : const SgDeclarationStatement* templateDeclaration = get_templateDeclaration();
36192 0 : ROSE_ASSERT(templateDeclaration != NULL);
36193 : #if 1
36194 0 : printf ("In SgTemplateArgument::display(): case SgTemplateArgument::template_template_argument: = %p = %s \n",templateDeclaration,templateDeclaration->class_name().c_str());
36195 : #endif
36196 0 : SgName mangled_templateDeclaration = templateDeclaration->get_mangled_name();
36197 0 : printf ("case SgTemplateArgument::template_template_argument: mangled_templateDeclaration = %s \n",mangled_templateDeclaration.str());
36198 0 : break;
36199 : }
36200 :
36201 0 : case SgTemplateArgument::start_of_pack_expansion_argument:
36202 0 : {
36203 : // const SgExpression* expr = get_expression();
36204 0 : assert(get_expression() != NULL);
36205 : #if 1
36206 0 : printf ("WARNING: In SgTemplateArgument::display(): handling of display for varadic template argument is incomplete! \n");
36207 : #endif
36208 0 : printf ("In SgTemplateArgument::display(): case SgTemplateArgument::start_of_pack_expansion_argument: varadic_template_argument \n");
36209 :
36210 : // DQ (12/28/2018): Add support to handle this case.
36211 0 : const SgExpression* expr = get_expression();
36212 0 : printf ("SgTemplateArgument::start_of_pack_expansion_argument: expr = %s \n",expr->unparseToString().c_str());
36213 :
36214 0 : break;
36215 : }
36216 :
36217 0 : default:
36218 0 : {
36219 0 : printf ("ERROR: In SgTemplateArgument::display(): default reached in switch: get_argumentType() = %d \n",get_argumentType());
36220 0 : ROSE_ASSERT(false);
36221 : break;
36222 : }
36223 : }
36224 0 : }
36225 :
36226 : std::string
36227 0 : SgTemplateArgument::unparseToStringSupport()
36228 : {
36229 : // DQ (3/10/2018): This is a function mostly used for debugging.
36230 0 : ROSE_ASSERT(this != NULL);
36231 :
36232 0 : SgUnparse_Info *info = new SgUnparse_Info();
36233 0 : ROSE_ASSERT(info != NULL);
36234 :
36235 0 : info->set_language(SgFile::e_Cxx_language);
36236 :
36237 : // DQ (4/28/2017): For template arguments we never want to output the definitions of classes, and enums.
36238 0 : info->set_SkipClassDefinition();
36239 0 : info->set_SkipEnumDefinition();
36240 0 : info->set_use_generated_name_for_template_arguments(true);
36241 :
36242 0 : std::string returnName = this->unparseToString(info);
36243 :
36244 0 : delete info;
36245 0 : info = NULL;
36246 :
36247 0 : return returnName;
36248 : }
36249 :
36250 :
36251 :
36252 : // End of memberFunctionString
36253 : // Start of memberFunctionString
36254 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
36255 :
36256 : // *** COMMON CODE SECTION BEGINS HERE ***
36257 :
36258 : #if 0
36259 : int
36260 : SgTemplateArgument::getVariant() const
36261 : {
36262 : // This function is used in ROSE while "variant()" is used in SAGE
36263 : assert(this != NULL);
36264 : return variant();
36265 : }
36266 : #endif
36267 :
36268 : // This function is used in ROSE in treeTraversal code
36269 : // eventually replaces getVariant() and variant()
36270 : // though after variant() has been removed for a while we will
36271 : // want to change the name of variantT() back to variant()
36272 : // (since the "T" was ment to stand for temporary).
36273 : // When this happens the variantT() will be depricated.
36274 : VariantT
36275 5328640 : SgTemplateArgument::variantT() const
36276 : {
36277 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
36278 5328640 : ROSE_ASSERT(this != NULL);
36279 5328640 : return V_SgTemplateArgument;
36280 : }
36281 :
36282 : #if 0
36283 : int
36284 : SgTemplateArgument::variant() const
36285 : {
36286 : // This function is used in SAGE
36287 : ROSE_ASSERT(this != NULL);
36288 : return TemplateArgumentTag;
36289 : }
36290 : #endif
36291 :
36292 : ROSE_DLL_API const char*
36293 0 : SgTemplateArgument::sage_class_name() const
36294 : {
36295 0 : ROSE_ASSERT(this != NULL);
36296 0 : return "SgTemplateArgument";
36297 : }
36298 :
36299 : std::string
36300 44871 : SgTemplateArgument::class_name() const
36301 : {
36302 44871 : ROSE_ASSERT(this != NULL);
36303 44871 : return "SgTemplateArgument";
36304 : }
36305 :
36306 : // DQ (11/26/2005): Support for visitor pattern mechanims
36307 : // (inferior to ROSE traversal mechanism, experimental).
36308 : void
36309 935333 : SgTemplateArgument::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
36310 : {
36311 935333 : ROSE_ASSERT(this != NULL);
36312 935333 : visitor.visit(this);
36313 935333 : }
36314 :
36315 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
36316 0 : void SgTemplateArgument::accept (ROSE_VisitorPattern & visitor) {
36317 0 : ROSE_ASSERT(this != NULL);
36318 0 : visitor.visit(this);
36319 0 : }
36320 :
36321 : SgTemplateArgument*
36322 0 : SgTemplateArgument::addRegExpAttribute(std::string s, AstRegExAttribute* a)
36323 : {
36324 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
36325 : // This function is currently only supported for the AST used the represent Binary executables.
36326 : if (0 /* isSgAsmNode(this) != NULL */)
36327 : {
36328 : // Support for regex specification.
36329 : std::string prefixCode = "REGEX:";
36330 : addNewAttribute(prefixCode + s,a);
36331 : }
36332 : #endif
36333 :
36334 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
36335 0 : return this;
36336 : }
36337 :
36338 : // *** COMMON CODE SECTION ENDS HERE ***
36339 :
36340 :
36341 : // End of memberFunctionString
36342 : // Start of memberFunctionString
36343 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
36344 :
36345 :
36346 : #if 0
36347 : //! Error checking support
36348 : /*! Verifies the following:
36349 : - working getVariant() member function
36350 : - calls base class's error() member function
36351 : Every class has one of these functions.
36352 : */
36353 : bool
36354 : SgTemplateArgument::error()
36355 : {
36356 : // Put error checking here
36357 :
36358 : ROSE_ASSERT (this != NULL);
36359 : if (getVariant() != TemplateArgumentTag)
36360 : {
36361 : printf ("Error in SgTemplateArgument::error(): SgTemplateArgument object has a %s variant \n",
36362 : Cxx_GrammarTerminalNames[getVariant()].name);
36363 : // printf ("Error in SgTemplateArgument::error() \n");
36364 : ROSE_ABORT();
36365 : }
36366 :
36367 : ROSE_ASSERT (getVariant() == TemplateArgumentTag);
36368 : return SgSupport::error();
36369 : }
36370 : #endif
36371 :
36372 :
36373 :
36374 : // End of memberFunctionString
36375 :
36376 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
36377 :
36378 56091800 : SgTemplateArgument* isSgTemplateArgument ( SgNode* inputDerivedClassPointer )
36379 : {
36380 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
36381 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
36382 : // So to fix this we return NULL directly when the input is NULL and avoid the
36383 : // dynamic_cast in this case. This is likely a performance improvement as well.
36384 : // return dynamic_cast<SgTemplateArgument*>(inputDerivedClassPointer);
36385 : // Milind Chabbi (8/28/2013): isSgTemplateArgument uses table-driven castability instead of c++ default dynamic_cast
36386 : // this improves the running time performance by 10-20%.
36387 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateArgument*>(inputDerivedClassPointer);
36388 56091800 : return IS_SgTemplateArgument_FAST_MACRO(inputDerivedClassPointer);
36389 : }
36390 :
36391 : // DQ (11/8/2003): Added version of functions taking const pointer
36392 1723100 : const SgTemplateArgument* isSgTemplateArgument ( const SgNode* inputDerivedClassPointer )
36393 : {
36394 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
36395 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
36396 : // So to fix this we return NULL directly when the input is NULL and avoid the
36397 : // dynamic_cast in this case. This is likely a performance improvement as well.
36398 : // return dynamic_cast<const SgTemplateArgument*>(inputDerivedClassPointer);
36399 : // Milind Chabbi (8/28/2013): isSgTemplateArgument uses table-driven castability instead of c++ default dynamic_cast
36400 : // this improves the running time performance by 10-20%.
36401 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateArgument*>(inputDerivedClassPointer);
36402 1723100 : return IS_SgTemplateArgument_FAST_MACRO(inputDerivedClassPointer);
36403 : }
36404 :
36405 :
36406 :
36407 : /* #line 36408 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
36408 :
36409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
36410 :
36411 : /**
36412 : \brief Generated destructor
36413 :
36414 : This destructor is automatically generated (by ROSETTA). This destructor
36415 : only frees memory of data members associated with the parts of the current IR node which
36416 : are NOT traversed. Those data members that are part of a traversal can be freed using
36417 : a traversal (calling this destructor on all children in a post-order traversal). Such
36418 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
36419 :
36420 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
36421 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
36422 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
36423 :
36424 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
36425 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
36426 : pointers are not yet implemented to call delete on eash pointer in the container.
36427 : (This could be done by derivation from the STL containers to define containers that
36428 : automatically deleted their members.)
36429 :
36430 : */
36431 26900 : SgTemplateArgument::~SgTemplateArgument () {
36432 13450 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
36433 :
36434 :
36435 : // case: not a listType for argumentType
36436 13450 : p_argumentType = argument_undefined; // non list case
36437 : // case: not a listType for isArrayBoundUnknownType
36438 13450 : p_isArrayBoundUnknownType = false; // non list case
36439 : // case: not a listType for type
36440 13450 : p_type = NULL; // non list case
36441 : // case: not a listType for unparsable_type_alias
36442 13450 : p_unparsable_type_alias = NULL; // non list case
36443 : // case: not a listType for expression
36444 13450 : p_expression = NULL; // non list case
36445 : // case: not a listType for templateDeclaration
36446 13450 : p_templateDeclaration = NULL; // non list case
36447 : // case: not a listType for initializedName
36448 13450 : p_initializedName = NULL; // non list case
36449 : // case: not a listType for explicitlySpecified
36450 13450 : p_explicitlySpecified = true; // non list case
36451 : // case: not a listType for name_qualification_length
36452 13450 : p_name_qualification_length = 0; // non list case
36453 : // case: not a listType for type_elaboration_required
36454 13450 : p_type_elaboration_required = false; // non list case
36455 : // case: not a listType for global_qualification_required
36456 13450 : p_global_qualification_required = false; // non list case
36457 : // case: not a listType for requiresGlobalNameQualificationOnType
36458 13450 : p_requiresGlobalNameQualificationOnType = false; // non list case
36459 : // case: not a listType for name_qualification_length_for_type
36460 13450 : p_name_qualification_length_for_type = 0; // non list case
36461 : // case: not a listType for type_elaboration_required_for_type
36462 13450 : p_type_elaboration_required_for_type = false; // non list case
36463 : // case: not a listType for global_qualification_required_for_type
36464 13450 : p_global_qualification_required_for_type = false; // non list case
36465 : // case: not a listType for previous_instance
36466 13450 : p_previous_instance = NULL; // non list case
36467 : // case: not a listType for next_instance
36468 13450 : p_next_instance = NULL; // non list case
36469 : // case: not a listType for is_pack_element
36470 13450 : p_is_pack_element = false; // non list case
36471 :
36472 : }
36473 :
36474 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
36475 26900 : }
36476 :
36477 :
36478 : /* #line 36479 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
36479 :
36480 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
36481 :
36482 : // Generated constructor
36483 63173 : SgTemplateArgument::SgTemplateArgument ( SgTemplateArgument::template_argument_enum argumentType, bool isArrayBoundUnknownType, SgType* type, SgExpression* expression, SgDeclarationStatement* templateDeclaration, bool explicitlySpecified )
36484 63173 : : SgSupport()
36485 : {
36486 : #ifdef DEBUG
36487 : // printf ("In SgTemplateArgument::SgTemplateArgument (SgTemplateArgument::template_argument_enum argumentType, bool isArrayBoundUnknownType, SgType* type, SgExpression* expression, SgDeclarationStatement* templateDeclaration, bool explicitlySpecified) sage_class_name() = %s \n",sage_class_name());
36488 : #endif
36489 : #if 0
36490 : // debugging information!
36491 : printf ("In SgTemplateArgument::SgTemplateArgument (SgTemplateArgument::template_argument_enum argumentType, bool isArrayBoundUnknownType, SgType* type, SgExpression* expression, SgDeclarationStatement* templateDeclaration, bool explicitlySpecified): this = %p = %s \n",this,this->class_name().c_str());
36492 : #endif
36493 :
36494 63173 : p_argumentType = argumentType;
36495 63173 : p_isArrayBoundUnknownType = isArrayBoundUnknownType;
36496 63173 : p_type = type;
36497 63173 : p_unparsable_type_alias = NULL;
36498 63173 : p_expression = expression;
36499 63173 : p_templateDeclaration = templateDeclaration;
36500 63173 : p_initializedName = NULL;
36501 63173 : p_explicitlySpecified = explicitlySpecified;
36502 63173 : p_name_qualification_length = 0;
36503 63173 : p_type_elaboration_required = false;
36504 63173 : p_global_qualification_required = false;
36505 63173 : p_requiresGlobalNameQualificationOnType = false;
36506 63173 : p_name_qualification_length_for_type = 0;
36507 63173 : p_type_elaboration_required_for_type = false;
36508 63173 : p_global_qualification_required_for_type = false;
36509 63173 : p_previous_instance = NULL;
36510 63173 : p_next_instance = NULL;
36511 63173 : p_is_pack_element = false;
36512 :
36513 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
36514 :
36515 : #if 0
36516 : // DQ (7/30/2014): Call a virtual function.
36517 : std::string s = this->class_name();
36518 : #endif
36519 :
36520 : // Test the variant virtual function
36521 : // assert(TemplateArgumentTag == variant());
36522 63173 : assert(TemplateArgumentTag == this->variant());
36523 63173 : ROSE_ASSERT(TemplateArgumentTag == (int)(this->variantT()));
36524 63173 : post_construction_initialization();
36525 :
36526 : // Test the isSgTemplateArgument() function since it has been problematic
36527 63173 : assert(isSgTemplateArgument(this) != NULL);
36528 63173 : }
36529 :
36530 : // Generated constructor (all data members)
36531 :
36532 : /* #line 36533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
36533 :
36534 :
36535 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
36536 :
36537 :
36538 : // ********************************************************
36539 : // member functions common across all array grammar objects
36540 : // ********************************************************
36541 :
36542 :
36543 :
36544 : /* #line 36545 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
36545 :
36546 :
36547 :
36548 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
36549 :
36550 : // ********************************************************
36551 : // member functions specific to each node in the grammar
36552 : // ********************************************************
36553 :
36554 :
36555 : /* #line 36556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
36556 :
36557 : // Start of memberFunctionString
36558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
36559 :
36560 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
36561 :
36562 : std::string
36563 0 : SgDirectory::get_name () const
36564 : {
36565 0 : ROSE_ASSERT (this != NULL);
36566 :
36567 : #if 0
36568 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
36569 : // used to trigger marking transformations for the token-based unparsing.
36570 : printf ("SgDirectory::get_name = %p = %s \n",this,this->class_name().c_str());
36571 : #endif
36572 :
36573 0 : return p_name;
36574 : }
36575 :
36576 : void
36577 0 : SgDirectory::set_name ( std::string name )
36578 : {
36579 0 : ROSE_ASSERT (this != NULL);
36580 :
36581 : #if 0
36582 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
36583 : // used to trigger marking transformations for the token-based unparsing.
36584 : printf ("SgDirectory::set_name = %p = %s \n",this,this->class_name().c_str());
36585 : #endif
36586 :
36587 0 : set_isModified(true);
36588 :
36589 0 : p_name = name;
36590 0 : }
36591 :
36592 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
36593 :
36594 :
36595 : // End of memberFunctionString
36596 : // Start of memberFunctionString
36597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
36598 :
36599 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
36600 :
36601 : SgFileList*
36602 0 : SgDirectory::get_fileList () const
36603 : {
36604 0 : ROSE_ASSERT (this != NULL);
36605 :
36606 : #if 0
36607 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
36608 : // used to trigger marking transformations for the token-based unparsing.
36609 : printf ("SgDirectory::get_fileList = %p = %s \n",this,this->class_name().c_str());
36610 : #endif
36611 :
36612 0 : return p_fileList;
36613 : }
36614 :
36615 : void
36616 0 : SgDirectory::set_fileList ( SgFileList* fileList )
36617 : {
36618 0 : ROSE_ASSERT (this != NULL);
36619 :
36620 : #if 0
36621 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
36622 : // used to trigger marking transformations for the token-based unparsing.
36623 : printf ("SgDirectory::set_fileList = %p = %s \n",this,this->class_name().c_str());
36624 : #endif
36625 :
36626 0 : set_isModified(true);
36627 :
36628 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
36629 : if (p_fileList != NULL && fileList != NULL && p_fileList != fileList)
36630 : {
36631 : printf ("Warning: fileList = %p overwriting valid pointer p_fileList = %p \n",fileList,p_fileList);
36632 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
36633 : printf ("Error fails assertion (p_fileList != NULL && fileList != NULL && p_fileList != fileList) is false\n");
36634 : ROSE_ASSERT(false);
36635 : #endif
36636 : }
36637 : #endif
36638 0 : p_fileList = fileList;
36639 0 : }
36640 :
36641 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
36642 :
36643 :
36644 : // End of memberFunctionString
36645 : // Start of memberFunctionString
36646 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
36647 :
36648 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
36649 :
36650 : SgDirectoryList*
36651 0 : SgDirectory::get_directoryList () const
36652 : {
36653 0 : ROSE_ASSERT (this != NULL);
36654 :
36655 : #if 0
36656 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
36657 : // used to trigger marking transformations for the token-based unparsing.
36658 : printf ("SgDirectory::get_directoryList = %p = %s \n",this,this->class_name().c_str());
36659 : #endif
36660 :
36661 0 : return p_directoryList;
36662 : }
36663 :
36664 : void
36665 0 : SgDirectory::set_directoryList ( SgDirectoryList* directoryList )
36666 : {
36667 0 : ROSE_ASSERT (this != NULL);
36668 :
36669 : #if 0
36670 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
36671 : // used to trigger marking transformations for the token-based unparsing.
36672 : printf ("SgDirectory::set_directoryList = %p = %s \n",this,this->class_name().c_str());
36673 : #endif
36674 :
36675 0 : set_isModified(true);
36676 :
36677 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
36678 : if (p_directoryList != NULL && directoryList != NULL && p_directoryList != directoryList)
36679 : {
36680 : printf ("Warning: directoryList = %p overwriting valid pointer p_directoryList = %p \n",directoryList,p_directoryList);
36681 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
36682 : printf ("Error fails assertion (p_directoryList != NULL && directoryList != NULL && p_directoryList != directoryList) is false\n");
36683 : ROSE_ASSERT(false);
36684 : #endif
36685 : }
36686 : #endif
36687 0 : p_directoryList = directoryList;
36688 0 : }
36689 :
36690 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
36691 :
36692 :
36693 : // End of memberFunctionString
36694 : // Start of memberFunctionString
36695 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
36696 :
36697 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
36698 :
36699 : AstAttributeMechanism*
36700 0 : SgDirectory::get_attributeMechanism () const
36701 : {
36702 0 : ROSE_ASSERT (this != NULL);
36703 0 : return p_attributeMechanism;
36704 : }
36705 :
36706 : void
36707 0 : SgDirectory::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
36708 : {
36709 0 : ROSE_ASSERT (this != NULL);
36710 :
36711 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
36712 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
36713 : {
36714 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
36715 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
36716 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
36717 : ROSE_ASSERT(false);
36718 : #endif
36719 : }
36720 : #endif
36721 0 : p_attributeMechanism = attributeMechanism;
36722 0 : }
36723 :
36724 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
36725 :
36726 :
36727 : // End of memberFunctionString
36728 : // Start of memberFunctionString
36729 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
36730 :
36731 :
36732 : #if 0
36733 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
36734 : // a pointer and the interface represented directly at the SgNode
36735 : AstAttributeMechanism &
36736 : SgDirectory::attribute()
36737 : {
36738 : // DQ (1/2/2006): This function preserves as much of
36739 : // the syntax of attribute being a public data member.
36740 : if (p_attribute == NULL)
36741 : {
36742 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
36743 : assert(false);
36744 : }
36745 :
36746 : return *p_attribute;
36747 : }
36748 : #endif
36749 :
36750 : void
36751 0 : SgDirectory::addNewAttribute( std::string s, AstAttribute* a )
36752 : {
36753 0 : if (get_attributeMechanism() == NULL)
36754 : {
36755 0 : set_attributeMechanism( new AstAttributeMechanism() );
36756 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
36757 : }
36758 0 : get_attributeMechanism()->add(s,a);
36759 0 : }
36760 :
36761 : void
36762 0 : SgDirectory::setAttribute( std::string s, AstAttribute* a )
36763 : {
36764 0 : if (get_attributeMechanism() == NULL)
36765 : {
36766 0 : set_attributeMechanism( new AstAttributeMechanism() );
36767 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
36768 : }
36769 0 : get_attributeMechanism()->set(s,a);
36770 0 : }
36771 :
36772 : AstAttribute*
36773 0 : SgDirectory::getAttribute(std::string s) const
36774 : {
36775 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
36776 0 : if (attributeExists(s)==false) return NULL;
36777 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
36778 0 : ROSE_ASSERT(returnValue != NULL);
36779 0 : return returnValue;
36780 : }
36781 :
36782 : void
36783 0 : SgDirectory::updateAttribute( std::string s, AstAttribute* a )
36784 : {
36785 : // formerly called: replace
36786 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
36787 0 : get_attributeMechanism()->replace(s,a);
36788 0 : }
36789 :
36790 : void
36791 0 : SgDirectory::removeAttribute(std::string s)
36792 : {
36793 0 : if (get_attributeMechanism())
36794 0 : get_attributeMechanism()->remove(s);
36795 :
36796 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
36797 0 : int remainingCount = numberOfAttributes();
36798 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
36799 0 : if (remainingCount == 0)
36800 : {
36801 0 : delete get_attributeMechanism();
36802 0 : set_attributeMechanism(NULL);
36803 : }
36804 0 : }
36805 :
36806 : bool
36807 0 : SgDirectory::attributeExists(std::string s) const
36808 : {
36809 0 : bool returnValue = false;
36810 0 : if (get_attributeMechanism() != NULL)
36811 0 : returnValue = get_attributeMechanism()->exists(s);
36812 0 : return returnValue;
36813 : }
36814 :
36815 : int
36816 0 : SgDirectory::numberOfAttributes() const
36817 : {
36818 0 : int returnValue = 0;
36819 0 : if (get_attributeMechanism() != NULL)
36820 0 : returnValue = get_attributeMechanism()->size();
36821 0 : return returnValue;
36822 : }
36823 :
36824 :
36825 :
36826 : // End of memberFunctionString
36827 : // Start of memberFunctionString
36828 : /* #line 18154 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
36829 :
36830 : int
36831 0 : SgDirectory::numberOfFiles() const
36832 : {
36833 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
36834 : return -1;
36835 : #else
36836 0 : assert(p_fileList != NULL);
36837 0 : return p_fileList->get_listOfFiles().size();
36838 : #endif
36839 : }
36840 :
36841 : SgFile*
36842 0 : SgDirectory::get_file(int i) const
36843 : {
36844 : #if ROSE_USING_OLD_PROJECT_FILE_LIST_SUPPORT
36845 : return NULL;
36846 : #else
36847 0 : assert(p_fileList != NULL);
36848 0 : return p_fileList->get_listOfFiles()[i];
36849 : #endif
36850 : }
36851 :
36852 : int
36853 0 : SgDirectory::numberOfDirectories() const
36854 : {
36855 0 : assert(p_directoryList != NULL);
36856 0 : return p_directoryList->get_listOfDirectories().size();
36857 : }
36858 :
36859 : SgDirectory*
36860 0 : SgDirectory::get_directory(int i) const
36861 : {
36862 0 : assert(p_directoryList != NULL);
36863 0 : return p_directoryList->get_listOfDirectories()[i];
36864 : }
36865 :
36866 : void
36867 0 : SgDirectory::post_construction_initialization()
36868 : {
36869 : // Make sure these data members start out as NULL.
36870 0 : assert(p_fileList == NULL);
36871 0 : assert(p_directoryList == NULL);
36872 :
36873 : // Initialize pointers to valid opjects with empty lists.
36874 0 : p_fileList = new SgFileList();
36875 0 : p_directoryList = new SgDirectoryList();
36876 :
36877 0 : assert(p_fileList != NULL);
36878 0 : assert(p_directoryList != NULL);
36879 :
36880 0 : p_fileList->set_parent(this);
36881 0 : p_directoryList->set_parent(this);
36882 0 : }
36883 :
36884 :
36885 :
36886 : // End of memberFunctionString
36887 : // Start of memberFunctionString
36888 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
36889 :
36890 : // *** COMMON CODE SECTION BEGINS HERE ***
36891 :
36892 : #if 0
36893 : int
36894 : SgDirectory::getVariant() const
36895 : {
36896 : // This function is used in ROSE while "variant()" is used in SAGE
36897 : assert(this != NULL);
36898 : return variant();
36899 : }
36900 : #endif
36901 :
36902 : // This function is used in ROSE in treeTraversal code
36903 : // eventually replaces getVariant() and variant()
36904 : // though after variant() has been removed for a while we will
36905 : // want to change the name of variantT() back to variant()
36906 : // (since the "T" was ment to stand for temporary).
36907 : // When this happens the variantT() will be depricated.
36908 : VariantT
36909 0 : SgDirectory::variantT() const
36910 : {
36911 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
36912 0 : ROSE_ASSERT(this != NULL);
36913 0 : return V_SgDirectory;
36914 : }
36915 :
36916 : #if 0
36917 : int
36918 : SgDirectory::variant() const
36919 : {
36920 : // This function is used in SAGE
36921 : ROSE_ASSERT(this != NULL);
36922 : return DirectoryTag;
36923 : }
36924 : #endif
36925 :
36926 : ROSE_DLL_API const char*
36927 0 : SgDirectory::sage_class_name() const
36928 : {
36929 0 : ROSE_ASSERT(this != NULL);
36930 0 : return "SgDirectory";
36931 : }
36932 :
36933 : std::string
36934 0 : SgDirectory::class_name() const
36935 : {
36936 0 : ROSE_ASSERT(this != NULL);
36937 0 : return "SgDirectory";
36938 : }
36939 :
36940 : // DQ (11/26/2005): Support for visitor pattern mechanims
36941 : // (inferior to ROSE traversal mechanism, experimental).
36942 : void
36943 0 : SgDirectory::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
36944 : {
36945 0 : ROSE_ASSERT(this != NULL);
36946 0 : visitor.visit(this);
36947 0 : }
36948 :
36949 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
36950 0 : void SgDirectory::accept (ROSE_VisitorPattern & visitor) {
36951 0 : ROSE_ASSERT(this != NULL);
36952 0 : visitor.visit(this);
36953 0 : }
36954 :
36955 : SgDirectory*
36956 0 : SgDirectory::addRegExpAttribute(std::string s, AstRegExAttribute* a)
36957 : {
36958 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
36959 : // This function is currently only supported for the AST used the represent Binary executables.
36960 : if (0 /* isSgAsmNode(this) != NULL */)
36961 : {
36962 : // Support for regex specification.
36963 : std::string prefixCode = "REGEX:";
36964 : addNewAttribute(prefixCode + s,a);
36965 : }
36966 : #endif
36967 :
36968 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
36969 0 : return this;
36970 : }
36971 :
36972 : // *** COMMON CODE SECTION ENDS HERE ***
36973 :
36974 :
36975 : // End of memberFunctionString
36976 : // Start of memberFunctionString
36977 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
36978 :
36979 :
36980 : #if 0
36981 : //! Error checking support
36982 : /*! Verifies the following:
36983 : - working getVariant() member function
36984 : - calls base class's error() member function
36985 : Every class has one of these functions.
36986 : */
36987 : bool
36988 : SgDirectory::error()
36989 : {
36990 : // Put error checking here
36991 :
36992 : ROSE_ASSERT (this != NULL);
36993 : if (getVariant() != DirectoryTag)
36994 : {
36995 : printf ("Error in SgDirectory::error(): SgDirectory object has a %s variant \n",
36996 : Cxx_GrammarTerminalNames[getVariant()].name);
36997 : // printf ("Error in SgDirectory::error() \n");
36998 : ROSE_ABORT();
36999 : }
37000 :
37001 : ROSE_ASSERT (getVariant() == DirectoryTag);
37002 : return SgSupport::error();
37003 : }
37004 : #endif
37005 :
37006 :
37007 :
37008 : // End of memberFunctionString
37009 :
37010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
37011 :
37012 5465830 : SgDirectory* isSgDirectory ( SgNode* inputDerivedClassPointer )
37013 : {
37014 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
37015 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
37016 : // So to fix this we return NULL directly when the input is NULL and avoid the
37017 : // dynamic_cast in this case. This is likely a performance improvement as well.
37018 : // return dynamic_cast<SgDirectory*>(inputDerivedClassPointer);
37019 : // Milind Chabbi (8/28/2013): isSgDirectory uses table-driven castability instead of c++ default dynamic_cast
37020 : // this improves the running time performance by 10-20%.
37021 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDirectory*>(inputDerivedClassPointer);
37022 5465830 : return IS_SgDirectory_FAST_MACRO(inputDerivedClassPointer);
37023 : }
37024 :
37025 : // DQ (11/8/2003): Added version of functions taking const pointer
37026 0 : const SgDirectory* isSgDirectory ( const SgNode* inputDerivedClassPointer )
37027 : {
37028 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
37029 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
37030 : // So to fix this we return NULL directly when the input is NULL and avoid the
37031 : // dynamic_cast in this case. This is likely a performance improvement as well.
37032 : // return dynamic_cast<const SgDirectory*>(inputDerivedClassPointer);
37033 : // Milind Chabbi (8/28/2013): isSgDirectory uses table-driven castability instead of c++ default dynamic_cast
37034 : // this improves the running time performance by 10-20%.
37035 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDirectory*>(inputDerivedClassPointer);
37036 0 : return IS_SgDirectory_FAST_MACRO(inputDerivedClassPointer);
37037 : }
37038 :
37039 :
37040 :
37041 : /* #line 37042 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37042 :
37043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
37044 :
37045 : /**
37046 : \brief Generated destructor
37047 :
37048 : This destructor is automatically generated (by ROSETTA). This destructor
37049 : only frees memory of data members associated with the parts of the current IR node which
37050 : are NOT traversed. Those data members that are part of a traversal can be freed using
37051 : a traversal (calling this destructor on all children in a post-order traversal). Such
37052 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
37053 :
37054 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
37055 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
37056 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
37057 :
37058 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
37059 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
37060 : pointers are not yet implemented to call delete on eash pointer in the container.
37061 : (This could be done by derivation from the STL containers to define containers that
37062 : automatically deleted their members.)
37063 :
37064 : */
37065 0 : SgDirectory::~SgDirectory () {
37066 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
37067 :
37068 :
37069 : // case: not a listType for name
37070 0 : p_name = ""; // non list case
37071 : // case: not a listType for fileList
37072 0 : p_fileList = NULL; // non list case
37073 : // case: not a listType for directoryList
37074 0 : p_directoryList = NULL; // non list case
37075 : // case: not a listType for attributeMechanism
37076 0 : p_attributeMechanism = NULL; // non list case
37077 :
37078 : }
37079 :
37080 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
37081 0 : }
37082 :
37083 :
37084 : /* #line 37085 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37085 :
37086 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
37087 :
37088 : // Generated constructor
37089 0 : SgDirectory::SgDirectory ( std::string name )
37090 0 : : SgSupport()
37091 : {
37092 : #ifdef DEBUG
37093 : // printf ("In SgDirectory::SgDirectory (std::string name) sage_class_name() = %s \n",sage_class_name());
37094 : #endif
37095 : #if 0
37096 : // debugging information!
37097 : printf ("In SgDirectory::SgDirectory (std::string name): this = %p = %s \n",this,this->class_name().c_str());
37098 : #endif
37099 :
37100 0 : p_name = name;
37101 0 : p_fileList = NULL;
37102 0 : p_directoryList = NULL;
37103 0 : p_attributeMechanism = NULL;
37104 :
37105 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
37106 :
37107 : #if 0
37108 : // DQ (7/30/2014): Call a virtual function.
37109 : std::string s = this->class_name();
37110 : #endif
37111 :
37112 : // Test the variant virtual function
37113 : // assert(DirectoryTag == variant());
37114 0 : assert(DirectoryTag == this->variant());
37115 0 : ROSE_ASSERT(DirectoryTag == (int)(this->variantT()));
37116 0 : post_construction_initialization();
37117 :
37118 : // Test the isSgDirectory() function since it has been problematic
37119 0 : assert(isSgDirectory(this) != NULL);
37120 0 : }
37121 :
37122 : // Generated constructor (all data members)
37123 :
37124 : /* #line 37125 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37125 :
37126 :
37127 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
37128 :
37129 :
37130 : // ********************************************************
37131 : // member functions common across all array grammar objects
37132 : // ********************************************************
37133 :
37134 :
37135 :
37136 : /* #line 37137 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37137 :
37138 :
37139 :
37140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
37141 :
37142 : // ********************************************************
37143 : // member functions specific to each node in the grammar
37144 : // ********************************************************
37145 :
37146 :
37147 : /* #line 37148 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37148 :
37149 : // Start of memberFunctionString
37150 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
37151 :
37152 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
37153 :
37154 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
37155 : const SgFilePtrList &
37156 0 : SgFileList::get_listOfFiles () const
37157 : {
37158 0 : assert (this != NULL);
37159 0 : return p_listOfFiles;
37160 : }
37161 :
37162 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
37163 : SgFilePtrList &
37164 56238 : SgFileList::get_listOfFiles ()
37165 : {
37166 56238 : assert (this != NULL);
37167 :
37168 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
37169 : // As a rule only set_ access functions can set the isModified flag.
37170 : // set_isModified(true);
37171 :
37172 56238 : return p_listOfFiles;
37173 : }
37174 :
37175 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
37176 :
37177 :
37178 : // End of memberFunctionString
37179 : // Start of memberFunctionString
37180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
37181 :
37182 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
37183 :
37184 : AstAttributeMechanism*
37185 8 : SgFileList::get_attributeMechanism () const
37186 : {
37187 8 : ROSE_ASSERT (this != NULL);
37188 8 : return p_attributeMechanism;
37189 : }
37190 :
37191 : void
37192 0 : SgFileList::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
37193 : {
37194 0 : ROSE_ASSERT (this != NULL);
37195 :
37196 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
37197 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
37198 : {
37199 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
37200 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
37201 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
37202 : ROSE_ASSERT(false);
37203 : #endif
37204 : }
37205 : #endif
37206 0 : p_attributeMechanism = attributeMechanism;
37207 0 : }
37208 :
37209 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
37210 :
37211 :
37212 : // End of memberFunctionString
37213 : // Start of memberFunctionString
37214 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
37215 :
37216 :
37217 : #if 0
37218 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
37219 : // a pointer and the interface represented directly at the SgNode
37220 : AstAttributeMechanism &
37221 : SgFileList::attribute()
37222 : {
37223 : // DQ (1/2/2006): This function preserves as much of
37224 : // the syntax of attribute being a public data member.
37225 : if (p_attribute == NULL)
37226 : {
37227 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
37228 : assert(false);
37229 : }
37230 :
37231 : return *p_attribute;
37232 : }
37233 : #endif
37234 :
37235 : void
37236 0 : SgFileList::addNewAttribute( std::string s, AstAttribute* a )
37237 : {
37238 0 : if (get_attributeMechanism() == NULL)
37239 : {
37240 0 : set_attributeMechanism( new AstAttributeMechanism() );
37241 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
37242 : }
37243 0 : get_attributeMechanism()->add(s,a);
37244 0 : }
37245 :
37246 : void
37247 0 : SgFileList::setAttribute( std::string s, AstAttribute* a )
37248 : {
37249 0 : if (get_attributeMechanism() == NULL)
37250 : {
37251 0 : set_attributeMechanism( new AstAttributeMechanism() );
37252 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
37253 : }
37254 0 : get_attributeMechanism()->set(s,a);
37255 0 : }
37256 :
37257 : AstAttribute*
37258 0 : SgFileList::getAttribute(std::string s) const
37259 : {
37260 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
37261 0 : if (attributeExists(s)==false) return NULL;
37262 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
37263 0 : ROSE_ASSERT(returnValue != NULL);
37264 0 : return returnValue;
37265 : }
37266 :
37267 : void
37268 0 : SgFileList::updateAttribute( std::string s, AstAttribute* a )
37269 : {
37270 : // formerly called: replace
37271 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
37272 0 : get_attributeMechanism()->replace(s,a);
37273 0 : }
37274 :
37275 : void
37276 0 : SgFileList::removeAttribute(std::string s)
37277 : {
37278 0 : if (get_attributeMechanism())
37279 0 : get_attributeMechanism()->remove(s);
37280 :
37281 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
37282 0 : int remainingCount = numberOfAttributes();
37283 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
37284 0 : if (remainingCount == 0)
37285 : {
37286 0 : delete get_attributeMechanism();
37287 0 : set_attributeMechanism(NULL);
37288 : }
37289 0 : }
37290 :
37291 : bool
37292 0 : SgFileList::attributeExists(std::string s) const
37293 : {
37294 0 : bool returnValue = false;
37295 0 : if (get_attributeMechanism() != NULL)
37296 0 : returnValue = get_attributeMechanism()->exists(s);
37297 0 : return returnValue;
37298 : }
37299 :
37300 : int
37301 0 : SgFileList::numberOfAttributes() const
37302 : {
37303 0 : int returnValue = 0;
37304 0 : if (get_attributeMechanism() != NULL)
37305 0 : returnValue = get_attributeMechanism()->size();
37306 0 : return returnValue;
37307 : }
37308 :
37309 :
37310 :
37311 : // End of memberFunctionString
37312 : // Start of memberFunctionString
37313 : /* #line 18151 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
37314 :
37315 :
37316 :
37317 : // End of memberFunctionString
37318 : // Start of memberFunctionString
37319 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
37320 :
37321 : // *** COMMON CODE SECTION BEGINS HERE ***
37322 :
37323 : #if 0
37324 : int
37325 : SgFileList::getVariant() const
37326 : {
37327 : // This function is used in ROSE while "variant()" is used in SAGE
37328 : assert(this != NULL);
37329 : return variant();
37330 : }
37331 : #endif
37332 :
37333 : // This function is used in ROSE in treeTraversal code
37334 : // eventually replaces getVariant() and variant()
37335 : // though after variant() has been removed for a while we will
37336 : // want to change the name of variantT() back to variant()
37337 : // (since the "T" was ment to stand for temporary).
37338 : // When this happens the variantT() will be depricated.
37339 : VariantT
37340 8032780 : SgFileList::variantT() const
37341 : {
37342 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
37343 8032780 : ROSE_ASSERT(this != NULL);
37344 8032780 : return V_SgFileList;
37345 : }
37346 :
37347 : #if 0
37348 : int
37349 : SgFileList::variant() const
37350 : {
37351 : // This function is used in SAGE
37352 : ROSE_ASSERT(this != NULL);
37353 : return FileListTag;
37354 : }
37355 : #endif
37356 :
37357 : ROSE_DLL_API const char*
37358 3224 : SgFileList::sage_class_name() const
37359 : {
37360 3224 : ROSE_ASSERT(this != NULL);
37361 3224 : return "SgFileList";
37362 : }
37363 :
37364 : std::string
37365 333 : SgFileList::class_name() const
37366 : {
37367 333 : ROSE_ASSERT(this != NULL);
37368 333 : return "SgFileList";
37369 : }
37370 :
37371 : // DQ (11/26/2005): Support for visitor pattern mechanims
37372 : // (inferior to ROSE traversal mechanism, experimental).
37373 : void
37374 194 : SgFileList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
37375 : {
37376 194 : ROSE_ASSERT(this != NULL);
37377 194 : visitor.visit(this);
37378 194 : }
37379 :
37380 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
37381 0 : void SgFileList::accept (ROSE_VisitorPattern & visitor) {
37382 0 : ROSE_ASSERT(this != NULL);
37383 0 : visitor.visit(this);
37384 0 : }
37385 :
37386 : SgFileList*
37387 0 : SgFileList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
37388 : {
37389 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
37390 : // This function is currently only supported for the AST used the represent Binary executables.
37391 : if (0 /* isSgAsmNode(this) != NULL */)
37392 : {
37393 : // Support for regex specification.
37394 : std::string prefixCode = "REGEX:";
37395 : addNewAttribute(prefixCode + s,a);
37396 : }
37397 : #endif
37398 :
37399 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
37400 0 : return this;
37401 : }
37402 :
37403 : // *** COMMON CODE SECTION ENDS HERE ***
37404 :
37405 :
37406 : // End of memberFunctionString
37407 : // Start of memberFunctionString
37408 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
37409 :
37410 :
37411 : #if 0
37412 : //! Error checking support
37413 : /*! Verifies the following:
37414 : - working getVariant() member function
37415 : - calls base class's error() member function
37416 : Every class has one of these functions.
37417 : */
37418 : bool
37419 : SgFileList::error()
37420 : {
37421 : // Put error checking here
37422 :
37423 : ROSE_ASSERT (this != NULL);
37424 : if (getVariant() != FileListTag)
37425 : {
37426 : printf ("Error in SgFileList::error(): SgFileList object has a %s variant \n",
37427 : Cxx_GrammarTerminalNames[getVariant()].name);
37428 : // printf ("Error in SgFileList::error() \n");
37429 : ROSE_ABORT();
37430 : }
37431 :
37432 : ROSE_ASSERT (getVariant() == FileListTag);
37433 : return SgSupport::error();
37434 : }
37435 : #endif
37436 :
37437 :
37438 :
37439 : // End of memberFunctionString
37440 :
37441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
37442 :
37443 5466520 : SgFileList* isSgFileList ( SgNode* inputDerivedClassPointer )
37444 : {
37445 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
37446 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
37447 : // So to fix this we return NULL directly when the input is NULL and avoid the
37448 : // dynamic_cast in this case. This is likely a performance improvement as well.
37449 : // return dynamic_cast<SgFileList*>(inputDerivedClassPointer);
37450 : // Milind Chabbi (8/28/2013): isSgFileList uses table-driven castability instead of c++ default dynamic_cast
37451 : // this improves the running time performance by 10-20%.
37452 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFileList*>(inputDerivedClassPointer);
37453 5466520 : return IS_SgFileList_FAST_MACRO(inputDerivedClassPointer);
37454 : }
37455 :
37456 : // DQ (11/8/2003): Added version of functions taking const pointer
37457 0 : const SgFileList* isSgFileList ( const SgNode* inputDerivedClassPointer )
37458 : {
37459 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
37460 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
37461 : // So to fix this we return NULL directly when the input is NULL and avoid the
37462 : // dynamic_cast in this case. This is likely a performance improvement as well.
37463 : // return dynamic_cast<const SgFileList*>(inputDerivedClassPointer);
37464 : // Milind Chabbi (8/28/2013): isSgFileList uses table-driven castability instead of c++ default dynamic_cast
37465 : // this improves the running time performance by 10-20%.
37466 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFileList*>(inputDerivedClassPointer);
37467 0 : return IS_SgFileList_FAST_MACRO(inputDerivedClassPointer);
37468 : }
37469 :
37470 :
37471 :
37472 : /* #line 37473 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37473 :
37474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
37475 :
37476 : /**
37477 : \brief Generated destructor
37478 :
37479 : This destructor is automatically generated (by ROSETTA). This destructor
37480 : only frees memory of data members associated with the parts of the current IR node which
37481 : are NOT traversed. Those data members that are part of a traversal can be freed using
37482 : a traversal (calling this destructor on all children in a post-order traversal). Such
37483 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
37484 :
37485 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
37486 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
37487 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
37488 :
37489 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
37490 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
37491 : pointers are not yet implemented to call delete on eash pointer in the container.
37492 : (This could be done by derivation from the STL containers to define containers that
37493 : automatically deleted their members.)
37494 :
37495 : */
37496 21 : SgFileList::~SgFileList () {
37497 7 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
37498 :
37499 :
37500 : // case: not a listType for attributeMechanism
37501 7 : p_attributeMechanism = NULL; // non list case
37502 :
37503 : }
37504 :
37505 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
37506 14 : }
37507 :
37508 :
37509 : /* #line 37510 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37510 :
37511 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
37512 :
37513 : // Generated constructor
37514 357 : SgFileList::SgFileList ( )
37515 357 : : SgSupport()
37516 : {
37517 : #ifdef DEBUG
37518 : // printf ("In SgFileList::SgFileList () sage_class_name() = %s \n",sage_class_name());
37519 : #endif
37520 : #if 0
37521 : // debugging information!
37522 : printf ("In SgFileList::SgFileList (): this = %p = %s \n",this,this->class_name().c_str());
37523 : #endif
37524 :
37525 357 : p_attributeMechanism = NULL;
37526 :
37527 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
37528 :
37529 : #if 0
37530 : // DQ (7/30/2014): Call a virtual function.
37531 : std::string s = this->class_name();
37532 : #endif
37533 :
37534 : // Test the variant virtual function
37535 : // assert(FileListTag == variant());
37536 357 : assert(FileListTag == this->variant());
37537 357 : ROSE_ASSERT(FileListTag == (int)(this->variantT()));
37538 357 : post_construction_initialization();
37539 :
37540 : // Test the isSgFileList() function since it has been problematic
37541 357 : assert(isSgFileList(this) != NULL);
37542 357 : }
37543 :
37544 : // Generated constructor (all data members)
37545 :
37546 : /* #line 37547 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37547 :
37548 :
37549 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
37550 :
37551 :
37552 : // ********************************************************
37553 : // member functions common across all array grammar objects
37554 : // ********************************************************
37555 :
37556 :
37557 :
37558 : /* #line 37559 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37559 :
37560 :
37561 :
37562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
37563 :
37564 : // ********************************************************
37565 : // member functions specific to each node in the grammar
37566 : // ********************************************************
37567 :
37568 :
37569 : /* #line 37570 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37570 :
37571 : // Start of memberFunctionString
37572 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
37573 :
37574 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
37575 :
37576 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
37577 : const SgDirectoryPtrList &
37578 0 : SgDirectoryList::get_listOfDirectories () const
37579 : {
37580 0 : assert (this != NULL);
37581 0 : return p_listOfDirectories;
37582 : }
37583 :
37584 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
37585 : SgDirectoryPtrList &
37586 353 : SgDirectoryList::get_listOfDirectories ()
37587 : {
37588 353 : assert (this != NULL);
37589 :
37590 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
37591 : // As a rule only set_ access functions can set the isModified flag.
37592 : // set_isModified(true);
37593 :
37594 353 : return p_listOfDirectories;
37595 : }
37596 :
37597 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
37598 :
37599 :
37600 : // End of memberFunctionString
37601 : // Start of memberFunctionString
37602 : /* #line 18211 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
37603 :
37604 :
37605 :
37606 : // End of memberFunctionString
37607 : // Start of memberFunctionString
37608 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
37609 :
37610 : // *** COMMON CODE SECTION BEGINS HERE ***
37611 :
37612 : #if 0
37613 : int
37614 : SgDirectoryList::getVariant() const
37615 : {
37616 : // This function is used in ROSE while "variant()" is used in SAGE
37617 : assert(this != NULL);
37618 : return variant();
37619 : }
37620 : #endif
37621 :
37622 : // This function is used in ROSE in treeTraversal code
37623 : // eventually replaces getVariant() and variant()
37624 : // though after variant() has been removed for a while we will
37625 : // want to change the name of variantT() back to variant()
37626 : // (since the "T" was ment to stand for temporary).
37627 : // When this happens the variantT() will be depricated.
37628 : VariantT
37629 13212 : SgDirectoryList::variantT() const
37630 : {
37631 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
37632 13212 : ROSE_ASSERT(this != NULL);
37633 13212 : return V_SgDirectoryList;
37634 : }
37635 :
37636 : #if 0
37637 : int
37638 : SgDirectoryList::variant() const
37639 : {
37640 : // This function is used in SAGE
37641 : ROSE_ASSERT(this != NULL);
37642 : return DirectoryListTag;
37643 : }
37644 : #endif
37645 :
37646 : ROSE_DLL_API const char*
37647 0 : SgDirectoryList::sage_class_name() const
37648 : {
37649 0 : ROSE_ASSERT(this != NULL);
37650 0 : return "SgDirectoryList";
37651 : }
37652 :
37653 : std::string
37654 331 : SgDirectoryList::class_name() const
37655 : {
37656 331 : ROSE_ASSERT(this != NULL);
37657 331 : return "SgDirectoryList";
37658 : }
37659 :
37660 : // DQ (11/26/2005): Support for visitor pattern mechanims
37661 : // (inferior to ROSE traversal mechanism, experimental).
37662 : void
37663 194 : SgDirectoryList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
37664 : {
37665 194 : ROSE_ASSERT(this != NULL);
37666 194 : visitor.visit(this);
37667 194 : }
37668 :
37669 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
37670 0 : void SgDirectoryList::accept (ROSE_VisitorPattern & visitor) {
37671 0 : ROSE_ASSERT(this != NULL);
37672 0 : visitor.visit(this);
37673 0 : }
37674 :
37675 : SgDirectoryList*
37676 0 : SgDirectoryList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
37677 : {
37678 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
37679 : // This function is currently only supported for the AST used the represent Binary executables.
37680 : if (0 /* isSgAsmNode(this) != NULL */)
37681 : {
37682 : // Support for regex specification.
37683 : std::string prefixCode = "REGEX:";
37684 : addNewAttribute(prefixCode + s,a);
37685 : }
37686 : #endif
37687 :
37688 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
37689 0 : return this;
37690 : }
37691 :
37692 : // *** COMMON CODE SECTION ENDS HERE ***
37693 :
37694 :
37695 : // End of memberFunctionString
37696 : // Start of memberFunctionString
37697 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
37698 :
37699 :
37700 : #if 0
37701 : //! Error checking support
37702 : /*! Verifies the following:
37703 : - working getVariant() member function
37704 : - calls base class's error() member function
37705 : Every class has one of these functions.
37706 : */
37707 : bool
37708 : SgDirectoryList::error()
37709 : {
37710 : // Put error checking here
37711 :
37712 : ROSE_ASSERT (this != NULL);
37713 : if (getVariant() != DirectoryListTag)
37714 : {
37715 : printf ("Error in SgDirectoryList::error(): SgDirectoryList object has a %s variant \n",
37716 : Cxx_GrammarTerminalNames[getVariant()].name);
37717 : // printf ("Error in SgDirectoryList::error() \n");
37718 : ROSE_ABORT();
37719 : }
37720 :
37721 : ROSE_ASSERT (getVariant() == DirectoryListTag);
37722 : return SgSupport::error();
37723 : }
37724 : #endif
37725 :
37726 :
37727 :
37728 : // End of memberFunctionString
37729 :
37730 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
37731 :
37732 357 : SgDirectoryList* isSgDirectoryList ( SgNode* inputDerivedClassPointer )
37733 : {
37734 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
37735 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
37736 : // So to fix this we return NULL directly when the input is NULL and avoid the
37737 : // dynamic_cast in this case. This is likely a performance improvement as well.
37738 : // return dynamic_cast<SgDirectoryList*>(inputDerivedClassPointer);
37739 : // Milind Chabbi (8/28/2013): isSgDirectoryList uses table-driven castability instead of c++ default dynamic_cast
37740 : // this improves the running time performance by 10-20%.
37741 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDirectoryList*>(inputDerivedClassPointer);
37742 357 : return IS_SgDirectoryList_FAST_MACRO(inputDerivedClassPointer);
37743 : }
37744 :
37745 : // DQ (11/8/2003): Added version of functions taking const pointer
37746 0 : const SgDirectoryList* isSgDirectoryList ( const SgNode* inputDerivedClassPointer )
37747 : {
37748 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
37749 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
37750 : // So to fix this we return NULL directly when the input is NULL and avoid the
37751 : // dynamic_cast in this case. This is likely a performance improvement as well.
37752 : // return dynamic_cast<const SgDirectoryList*>(inputDerivedClassPointer);
37753 : // Milind Chabbi (8/28/2013): isSgDirectoryList uses table-driven castability instead of c++ default dynamic_cast
37754 : // this improves the running time performance by 10-20%.
37755 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDirectoryList*>(inputDerivedClassPointer);
37756 0 : return IS_SgDirectoryList_FAST_MACRO(inputDerivedClassPointer);
37757 : }
37758 :
37759 :
37760 :
37761 : /* #line 37762 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37762 :
37763 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
37764 :
37765 : /**
37766 : \brief Generated destructor
37767 :
37768 : This destructor is automatically generated (by ROSETTA). This destructor
37769 : only frees memory of data members associated with the parts of the current IR node which
37770 : are NOT traversed. Those data members that are part of a traversal can be freed using
37771 : a traversal (calling this destructor on all children in a post-order traversal). Such
37772 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
37773 :
37774 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
37775 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
37776 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
37777 :
37778 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
37779 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
37780 : pointers are not yet implemented to call delete on eash pointer in the container.
37781 : (This could be done by derivation from the STL containers to define containers that
37782 : automatically deleted their members.)
37783 :
37784 : */
37785 14 : SgDirectoryList::~SgDirectoryList () {
37786 7 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
37787 :
37788 :
37789 :
37790 : }
37791 :
37792 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
37793 14 : }
37794 :
37795 :
37796 : /* #line 37797 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37797 :
37798 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
37799 :
37800 : // Generated constructor
37801 357 : SgDirectoryList::SgDirectoryList ( )
37802 357 : : SgSupport()
37803 : {
37804 : #ifdef DEBUG
37805 : // printf ("In SgDirectoryList::SgDirectoryList () sage_class_name() = %s \n",sage_class_name());
37806 : #endif
37807 : #if 0
37808 : // debugging information!
37809 : printf ("In SgDirectoryList::SgDirectoryList (): this = %p = %s \n",this,this->class_name().c_str());
37810 : #endif
37811 :
37812 :
37813 :
37814 : #if 0
37815 : // DQ (7/30/2014): Call a virtual function.
37816 : std::string s = this->class_name();
37817 : #endif
37818 :
37819 : // Test the variant virtual function
37820 : // assert(DirectoryListTag == variant());
37821 357 : assert(DirectoryListTag == this->variant());
37822 357 : ROSE_ASSERT(DirectoryListTag == (int)(this->variantT()));
37823 357 : post_construction_initialization();
37824 :
37825 : // Test the isSgDirectoryList() function since it has been problematic
37826 357 : assert(isSgDirectoryList(this) != NULL);
37827 357 : }
37828 :
37829 : // Generated constructor (all data members)
37830 :
37831 : /* #line 37832 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37832 :
37833 :
37834 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
37835 :
37836 :
37837 : // ********************************************************
37838 : // member functions common across all array grammar objects
37839 : // ********************************************************
37840 :
37841 :
37842 :
37843 : /* #line 37844 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37844 :
37845 :
37846 :
37847 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
37848 :
37849 : // ********************************************************
37850 : // member functions specific to each node in the grammar
37851 : // ********************************************************
37852 :
37853 :
37854 : /* #line 37855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
37855 :
37856 : // Start of memberFunctionString
37857 : /* #line 21071 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
37858 :
37859 : const SgTypePtrList &
37860 0 : SgFunctionParameterTypeList::get_arguments() const
37861 0 : { return p_arguments; }
37862 :
37863 : SgTypePtrList &
37864 8305200 : SgFunctionParameterTypeList::get_arguments()
37865 8305200 : { return p_arguments; }
37866 :
37867 : void
37868 29455 : SgFunctionParameterTypeList::append_argument( SgType* what)
37869 : {
37870 29455 : insert_argument(p_arguments.end(),what);
37871 29455 : }
37872 :
37873 : void
37874 29455 : SgFunctionParameterTypeList::insert_argument(const SgTypePtrList::iterator& where, SgType* what)
37875 : {
37876 : // WAS: void SgFunctionType::insert_argument(const SgTypePtrList::iterator& where, const SgTypePtr & what)
37877 : // mprintf ("ERROR (in modified SAGE3 function): not implemented in SAGE3! \n");
37878 : // abort();
37879 29455 : p_arguments.insert(where,what);
37880 29455 : }
37881 :
37882 : // DQ (1/18/2006): Added default constructor explicitly to avoid having it be generated by the compiler
37883 2593490 : SgFunctionParameterTypeList::SgFunctionParameterTypeList()
37884 : {
37885 : // Build the default constructor (nothing to build here since the only data member is an STL list)
37886 2593490 : }
37887 :
37888 :
37889 :
37890 : // End of memberFunctionString
37891 : // Start of memberFunctionString
37892 :
37893 :
37894 : // End of memberFunctionString
37895 : // Start of memberFunctionString
37896 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
37897 :
37898 : // *** COMMON CODE SECTION BEGINS HERE ***
37899 :
37900 : #if 0
37901 : int
37902 : SgFunctionParameterTypeList::getVariant() const
37903 : {
37904 : // This function is used in ROSE while "variant()" is used in SAGE
37905 : assert(this != NULL);
37906 : return variant();
37907 : }
37908 : #endif
37909 :
37910 : // This function is used in ROSE in treeTraversal code
37911 : // eventually replaces getVariant() and variant()
37912 : // though after variant() has been removed for a while we will
37913 : // want to change the name of variantT() back to variant()
37914 : // (since the "T" was ment to stand for temporary).
37915 : // When this happens the variantT() will be depricated.
37916 : VariantT
37917 804246000 : SgFunctionParameterTypeList::variantT() const
37918 : {
37919 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
37920 804246000 : ROSE_ASSERT(this != NULL);
37921 804246000 : return V_SgFunctionParameterTypeList;
37922 : }
37923 :
37924 : #if 0
37925 : int
37926 : SgFunctionParameterTypeList::variant() const
37927 : {
37928 : // This function is used in SAGE
37929 : ROSE_ASSERT(this != NULL);
37930 : return T_FUNCTION_PARAMETER_TYPE_LIST;
37931 : }
37932 : #endif
37933 :
37934 : ROSE_DLL_API const char*
37935 0 : SgFunctionParameterTypeList::sage_class_name() const
37936 : {
37937 0 : ROSE_ASSERT(this != NULL);
37938 0 : return "SgFunctionParameterTypeList";
37939 : }
37940 :
37941 : std::string
37942 244459 : SgFunctionParameterTypeList::class_name() const
37943 : {
37944 244459 : ROSE_ASSERT(this != NULL);
37945 244459 : return "SgFunctionParameterTypeList";
37946 : }
37947 :
37948 : // DQ (11/26/2005): Support for visitor pattern mechanims
37949 : // (inferior to ROSE traversal mechanism, experimental).
37950 : void
37951 1115420 : SgFunctionParameterTypeList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
37952 : {
37953 1115420 : ROSE_ASSERT(this != NULL);
37954 1115420 : visitor.visit(this);
37955 1115420 : }
37956 :
37957 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
37958 0 : void SgFunctionParameterTypeList::accept (ROSE_VisitorPattern & visitor) {
37959 0 : ROSE_ASSERT(this != NULL);
37960 0 : visitor.visit(this);
37961 0 : }
37962 :
37963 : SgFunctionParameterTypeList*
37964 0 : SgFunctionParameterTypeList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
37965 : {
37966 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
37967 : // This function is currently only supported for the AST used the represent Binary executables.
37968 : if (0 /* isSgAsmNode(this) != NULL */)
37969 : {
37970 : // Support for regex specification.
37971 : std::string prefixCode = "REGEX:";
37972 : addNewAttribute(prefixCode + s,a);
37973 : }
37974 : #endif
37975 :
37976 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
37977 0 : return this;
37978 : }
37979 :
37980 : // *** COMMON CODE SECTION ENDS HERE ***
37981 :
37982 :
37983 : // End of memberFunctionString
37984 : // Start of memberFunctionString
37985 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
37986 :
37987 :
37988 : #if 0
37989 : //! Error checking support
37990 : /*! Verifies the following:
37991 : - working getVariant() member function
37992 : - calls base class's error() member function
37993 : Every class has one of these functions.
37994 : */
37995 : bool
37996 : SgFunctionParameterTypeList::error()
37997 : {
37998 : // Put error checking here
37999 :
38000 : ROSE_ASSERT (this != NULL);
38001 : if (getVariant() != T_FUNCTION_PARAMETER_TYPE_LIST)
38002 : {
38003 : printf ("Error in SgFunctionParameterTypeList::error(): SgFunctionParameterTypeList object has a %s variant \n",
38004 : Cxx_GrammarTerminalNames[getVariant()].name);
38005 : // printf ("Error in SgFunctionParameterTypeList::error() \n");
38006 : ROSE_ABORT();
38007 : }
38008 :
38009 : ROSE_ASSERT (getVariant() == T_FUNCTION_PARAMETER_TYPE_LIST);
38010 : return SgSupport::error();
38011 : }
38012 : #endif
38013 :
38014 :
38015 :
38016 : // End of memberFunctionString
38017 :
38018 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
38019 :
38020 1161190 : SgFunctionParameterTypeList* isSgFunctionParameterTypeList ( SgNode* inputDerivedClassPointer )
38021 : {
38022 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38023 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38024 : // So to fix this we return NULL directly when the input is NULL and avoid the
38025 : // dynamic_cast in this case. This is likely a performance improvement as well.
38026 : // return dynamic_cast<SgFunctionParameterTypeList*>(inputDerivedClassPointer);
38027 : // Milind Chabbi (8/28/2013): isSgFunctionParameterTypeList uses table-driven castability instead of c++ default dynamic_cast
38028 : // this improves the running time performance by 10-20%.
38029 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionParameterTypeList*>(inputDerivedClassPointer);
38030 1161190 : return IS_SgFunctionParameterTypeList_FAST_MACRO(inputDerivedClassPointer);
38031 : }
38032 :
38033 : // DQ (11/8/2003): Added version of functions taking const pointer
38034 0 : const SgFunctionParameterTypeList* isSgFunctionParameterTypeList ( const SgNode* inputDerivedClassPointer )
38035 : {
38036 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38037 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38038 : // So to fix this we return NULL directly when the input is NULL and avoid the
38039 : // dynamic_cast in this case. This is likely a performance improvement as well.
38040 : // return dynamic_cast<const SgFunctionParameterTypeList*>(inputDerivedClassPointer);
38041 : // Milind Chabbi (8/28/2013): isSgFunctionParameterTypeList uses table-driven castability instead of c++ default dynamic_cast
38042 : // this improves the running time performance by 10-20%.
38043 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionParameterTypeList*>(inputDerivedClassPointer);
38044 0 : return IS_SgFunctionParameterTypeList_FAST_MACRO(inputDerivedClassPointer);
38045 : }
38046 :
38047 :
38048 :
38049 : /* #line 38050 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38050 :
38051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38052 :
38053 : /**
38054 : \brief Generated destructor
38055 :
38056 : This destructor is automatically generated (by ROSETTA). This destructor
38057 : only frees memory of data members associated with the parts of the current IR node which
38058 : are NOT traversed. Those data members that are part of a traversal can be freed using
38059 : a traversal (calling this destructor on all children in a post-order traversal). Such
38060 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
38061 :
38062 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
38063 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
38064 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
38065 :
38066 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
38067 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
38068 : pointers are not yet implemented to call delete on eash pointer in the container.
38069 : (This could be done by derivation from the STL containers to define containers that
38070 : automatically deleted their members.)
38071 :
38072 : */
38073 6705890 : SgFunctionParameterTypeList::~SgFunctionParameterTypeList () {
38074 2332860 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
38075 :
38076 :
38077 :
38078 : }
38079 :
38080 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38081 4665720 : }
38082 :
38083 :
38084 : /* #line 38085 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38085 :
38086 :
38087 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38088 :
38089 :
38090 : // ********************************************************
38091 : // member functions common across all array grammar objects
38092 : // ********************************************************
38093 :
38094 :
38095 :
38096 : /* #line 38097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38097 :
38098 :
38099 :
38100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38101 :
38102 : // ********************************************************
38103 : // member functions specific to each node in the grammar
38104 : // ********************************************************
38105 :
38106 :
38107 : /* #line 38108 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38108 :
38109 : // Start of memberFunctionString
38110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
38111 :
38112 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
38113 :
38114 : SgScopeStatement*
38115 0 : SgQualifiedName::get_scope () const
38116 : {
38117 0 : ROSE_ASSERT (this != NULL);
38118 :
38119 : #if 0
38120 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
38121 : // used to trigger marking transformations for the token-based unparsing.
38122 : printf ("SgQualifiedName::get_scope = %p = %s \n",this,this->class_name().c_str());
38123 : #endif
38124 :
38125 0 : return p_scope;
38126 : }
38127 :
38128 : void
38129 0 : SgQualifiedName::set_scope ( SgScopeStatement* scope )
38130 : {
38131 0 : ROSE_ASSERT (this != NULL);
38132 :
38133 : #if 0
38134 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
38135 : // used to trigger marking transformations for the token-based unparsing.
38136 : printf ("SgQualifiedName::set_scope = %p = %s \n",this,this->class_name().c_str());
38137 : #endif
38138 :
38139 0 : set_isModified(true);
38140 :
38141 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
38142 : if (p_scope != NULL && scope != NULL && p_scope != scope)
38143 : {
38144 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
38145 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
38146 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
38147 : ROSE_ASSERT(false);
38148 : #endif
38149 : }
38150 : #endif
38151 0 : p_scope = scope;
38152 0 : }
38153 :
38154 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
38155 :
38156 :
38157 : // End of memberFunctionString
38158 : // Start of memberFunctionString
38159 : /* #line 13645 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
38160 :
38161 :
38162 :
38163 : // End of memberFunctionString
38164 : // Start of memberFunctionString
38165 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
38166 :
38167 : // *** COMMON CODE SECTION BEGINS HERE ***
38168 :
38169 : #if 0
38170 : int
38171 : SgQualifiedName::getVariant() const
38172 : {
38173 : // This function is used in ROSE while "variant()" is used in SAGE
38174 : assert(this != NULL);
38175 : return variant();
38176 : }
38177 : #endif
38178 :
38179 : // This function is used in ROSE in treeTraversal code
38180 : // eventually replaces getVariant() and variant()
38181 : // though after variant() has been removed for a while we will
38182 : // want to change the name of variantT() back to variant()
38183 : // (since the "T" was ment to stand for temporary).
38184 : // When this happens the variantT() will be depricated.
38185 : VariantT
38186 0 : SgQualifiedName::variantT() const
38187 : {
38188 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
38189 0 : ROSE_ASSERT(this != NULL);
38190 0 : return V_SgQualifiedName;
38191 : }
38192 :
38193 : #if 0
38194 : int
38195 : SgQualifiedName::variant() const
38196 : {
38197 : // This function is used in SAGE
38198 : ROSE_ASSERT(this != NULL);
38199 : return QualifiedNameTag;
38200 : }
38201 : #endif
38202 :
38203 : ROSE_DLL_API const char*
38204 0 : SgQualifiedName::sage_class_name() const
38205 : {
38206 0 : ROSE_ASSERT(this != NULL);
38207 0 : return "SgQualifiedName";
38208 : }
38209 :
38210 : std::string
38211 0 : SgQualifiedName::class_name() const
38212 : {
38213 0 : ROSE_ASSERT(this != NULL);
38214 0 : return "SgQualifiedName";
38215 : }
38216 :
38217 : // DQ (11/26/2005): Support for visitor pattern mechanims
38218 : // (inferior to ROSE traversal mechanism, experimental).
38219 : void
38220 0 : SgQualifiedName::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
38221 : {
38222 0 : ROSE_ASSERT(this != NULL);
38223 0 : visitor.visit(this);
38224 0 : }
38225 :
38226 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
38227 0 : void SgQualifiedName::accept (ROSE_VisitorPattern & visitor) {
38228 0 : ROSE_ASSERT(this != NULL);
38229 0 : visitor.visit(this);
38230 0 : }
38231 :
38232 : SgQualifiedName*
38233 0 : SgQualifiedName::addRegExpAttribute(std::string s, AstRegExAttribute* a)
38234 : {
38235 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
38236 : // This function is currently only supported for the AST used the represent Binary executables.
38237 : if (0 /* isSgAsmNode(this) != NULL */)
38238 : {
38239 : // Support for regex specification.
38240 : std::string prefixCode = "REGEX:";
38241 : addNewAttribute(prefixCode + s,a);
38242 : }
38243 : #endif
38244 :
38245 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
38246 0 : return this;
38247 : }
38248 :
38249 : // *** COMMON CODE SECTION ENDS HERE ***
38250 :
38251 :
38252 : // End of memberFunctionString
38253 : // Start of memberFunctionString
38254 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
38255 :
38256 :
38257 : #if 0
38258 : //! Error checking support
38259 : /*! Verifies the following:
38260 : - working getVariant() member function
38261 : - calls base class's error() member function
38262 : Every class has one of these functions.
38263 : */
38264 : bool
38265 : SgQualifiedName::error()
38266 : {
38267 : // Put error checking here
38268 :
38269 : ROSE_ASSERT (this != NULL);
38270 : if (getVariant() != QualifiedNameTag)
38271 : {
38272 : printf ("Error in SgQualifiedName::error(): SgQualifiedName object has a %s variant \n",
38273 : Cxx_GrammarTerminalNames[getVariant()].name);
38274 : // printf ("Error in SgQualifiedName::error() \n");
38275 : ROSE_ABORT();
38276 : }
38277 :
38278 : ROSE_ASSERT (getVariant() == QualifiedNameTag);
38279 : return SgSupport::error();
38280 : }
38281 : #endif
38282 :
38283 :
38284 :
38285 : // End of memberFunctionString
38286 :
38287 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
38288 :
38289 0 : SgQualifiedName* isSgQualifiedName ( SgNode* inputDerivedClassPointer )
38290 : {
38291 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38292 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38293 : // So to fix this we return NULL directly when the input is NULL and avoid the
38294 : // dynamic_cast in this case. This is likely a performance improvement as well.
38295 : // return dynamic_cast<SgQualifiedName*>(inputDerivedClassPointer);
38296 : // Milind Chabbi (8/28/2013): isSgQualifiedName uses table-driven castability instead of c++ default dynamic_cast
38297 : // this improves the running time performance by 10-20%.
38298 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgQualifiedName*>(inputDerivedClassPointer);
38299 0 : return IS_SgQualifiedName_FAST_MACRO(inputDerivedClassPointer);
38300 : }
38301 :
38302 : // DQ (11/8/2003): Added version of functions taking const pointer
38303 28489 : const SgQualifiedName* isSgQualifiedName ( const SgNode* inputDerivedClassPointer )
38304 : {
38305 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38306 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38307 : // So to fix this we return NULL directly when the input is NULL and avoid the
38308 : // dynamic_cast in this case. This is likely a performance improvement as well.
38309 : // return dynamic_cast<const SgQualifiedName*>(inputDerivedClassPointer);
38310 : // Milind Chabbi (8/28/2013): isSgQualifiedName uses table-driven castability instead of c++ default dynamic_cast
38311 : // this improves the running time performance by 10-20%.
38312 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgQualifiedName*>(inputDerivedClassPointer);
38313 28489 : return IS_SgQualifiedName_FAST_MACRO(inputDerivedClassPointer);
38314 : }
38315 :
38316 :
38317 :
38318 : /* #line 38319 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38319 :
38320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38321 :
38322 : /**
38323 : \brief Generated destructor
38324 :
38325 : This destructor is automatically generated (by ROSETTA). This destructor
38326 : only frees memory of data members associated with the parts of the current IR node which
38327 : are NOT traversed. Those data members that are part of a traversal can be freed using
38328 : a traversal (calling this destructor on all children in a post-order traversal). Such
38329 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
38330 :
38331 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
38332 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
38333 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
38334 :
38335 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
38336 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
38337 : pointers are not yet implemented to call delete on eash pointer in the container.
38338 : (This could be done by derivation from the STL containers to define containers that
38339 : automatically deleted their members.)
38340 :
38341 : */
38342 0 : SgQualifiedName::~SgQualifiedName () {
38343 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
38344 :
38345 :
38346 : // case: not a listType for scope
38347 0 : p_scope = NULL; // non list case
38348 :
38349 : }
38350 :
38351 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38352 0 : }
38353 :
38354 :
38355 : /* #line 38356 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38356 :
38357 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
38358 :
38359 : // Generated constructor
38360 0 : SgQualifiedName::SgQualifiedName ( SgScopeStatement* scope )
38361 0 : : SgSupport()
38362 : {
38363 : #ifdef DEBUG
38364 : // printf ("In SgQualifiedName::SgQualifiedName (SgScopeStatement* scope) sage_class_name() = %s \n",sage_class_name());
38365 : #endif
38366 : #if 0
38367 : // debugging information!
38368 : printf ("In SgQualifiedName::SgQualifiedName (SgScopeStatement* scope): this = %p = %s \n",this,this->class_name().c_str());
38369 : #endif
38370 :
38371 0 : p_scope = scope;
38372 :
38373 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
38374 :
38375 : #if 0
38376 : // DQ (7/30/2014): Call a virtual function.
38377 : std::string s = this->class_name();
38378 : #endif
38379 :
38380 : // Test the variant virtual function
38381 : // assert(QualifiedNameTag == variant());
38382 0 : assert(QualifiedNameTag == this->variant());
38383 0 : ROSE_ASSERT(QualifiedNameTag == (int)(this->variantT()));
38384 0 : post_construction_initialization();
38385 :
38386 : // Test the isSgQualifiedName() function since it has been problematic
38387 0 : assert(isSgQualifiedName(this) != NULL);
38388 0 : }
38389 :
38390 : // Generated constructor (all data members)
38391 :
38392 : /* #line 38393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38393 :
38394 :
38395 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38396 :
38397 :
38398 : // ********************************************************
38399 : // member functions common across all array grammar objects
38400 : // ********************************************************
38401 :
38402 :
38403 :
38404 : /* #line 38405 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38405 :
38406 :
38407 :
38408 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38409 :
38410 : // ********************************************************
38411 : // member functions specific to each node in the grammar
38412 : // ********************************************************
38413 :
38414 :
38415 : /* #line 38416 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38416 :
38417 : // Start of memberFunctionString
38418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
38419 :
38420 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
38421 :
38422 : SgTemplateArgumentPtrList
38423 0 : SgTemplateArgumentList::get_args () const
38424 : {
38425 0 : ROSE_ASSERT (this != NULL);
38426 :
38427 : #if 0
38428 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
38429 : // used to trigger marking transformations for the token-based unparsing.
38430 : printf ("SgTemplateArgumentList::get_args = %p = %s \n",this,this->class_name().c_str());
38431 : #endif
38432 :
38433 0 : return p_args;
38434 : }
38435 :
38436 : void
38437 0 : SgTemplateArgumentList::set_args ( SgTemplateArgumentPtrList args )
38438 : {
38439 0 : ROSE_ASSERT (this != NULL);
38440 :
38441 : #if 0
38442 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
38443 : // used to trigger marking transformations for the token-based unparsing.
38444 : printf ("SgTemplateArgumentList::set_args = %p = %s \n",this,this->class_name().c_str());
38445 : #endif
38446 :
38447 0 : set_isModified(true);
38448 :
38449 0 : p_args = args;
38450 0 : }
38451 :
38452 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
38453 :
38454 :
38455 : // End of memberFunctionString
38456 : // Start of memberFunctionString
38457 : /* #line 22183 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
38458 :
38459 :
38460 :
38461 : // End of memberFunctionString
38462 : // Start of memberFunctionString
38463 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
38464 :
38465 : // *** COMMON CODE SECTION BEGINS HERE ***
38466 :
38467 : #if 0
38468 : int
38469 : SgTemplateArgumentList::getVariant() const
38470 : {
38471 : // This function is used in ROSE while "variant()" is used in SAGE
38472 : assert(this != NULL);
38473 : return variant();
38474 : }
38475 : #endif
38476 :
38477 : // This function is used in ROSE in treeTraversal code
38478 : // eventually replaces getVariant() and variant()
38479 : // though after variant() has been removed for a while we will
38480 : // want to change the name of variantT() back to variant()
38481 : // (since the "T" was ment to stand for temporary).
38482 : // When this happens the variantT() will be depricated.
38483 : VariantT
38484 0 : SgTemplateArgumentList::variantT() const
38485 : {
38486 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
38487 0 : ROSE_ASSERT(this != NULL);
38488 0 : return V_SgTemplateArgumentList;
38489 : }
38490 :
38491 : #if 0
38492 : int
38493 : SgTemplateArgumentList::variant() const
38494 : {
38495 : // This function is used in SAGE
38496 : ROSE_ASSERT(this != NULL);
38497 : return TemplateArgumentListTag;
38498 : }
38499 : #endif
38500 :
38501 : ROSE_DLL_API const char*
38502 0 : SgTemplateArgumentList::sage_class_name() const
38503 : {
38504 0 : ROSE_ASSERT(this != NULL);
38505 0 : return "SgTemplateArgumentList";
38506 : }
38507 :
38508 : std::string
38509 0 : SgTemplateArgumentList::class_name() const
38510 : {
38511 0 : ROSE_ASSERT(this != NULL);
38512 0 : return "SgTemplateArgumentList";
38513 : }
38514 :
38515 : // DQ (11/26/2005): Support for visitor pattern mechanims
38516 : // (inferior to ROSE traversal mechanism, experimental).
38517 : void
38518 0 : SgTemplateArgumentList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
38519 : {
38520 0 : ROSE_ASSERT(this != NULL);
38521 0 : visitor.visit(this);
38522 0 : }
38523 :
38524 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
38525 0 : void SgTemplateArgumentList::accept (ROSE_VisitorPattern & visitor) {
38526 0 : ROSE_ASSERT(this != NULL);
38527 0 : visitor.visit(this);
38528 0 : }
38529 :
38530 : SgTemplateArgumentList*
38531 0 : SgTemplateArgumentList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
38532 : {
38533 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
38534 : // This function is currently only supported for the AST used the represent Binary executables.
38535 : if (0 /* isSgAsmNode(this) != NULL */)
38536 : {
38537 : // Support for regex specification.
38538 : std::string prefixCode = "REGEX:";
38539 : addNewAttribute(prefixCode + s,a);
38540 : }
38541 : #endif
38542 :
38543 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
38544 0 : return this;
38545 : }
38546 :
38547 : // *** COMMON CODE SECTION ENDS HERE ***
38548 :
38549 :
38550 : // End of memberFunctionString
38551 : // Start of memberFunctionString
38552 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
38553 :
38554 :
38555 : #if 0
38556 : //! Error checking support
38557 : /*! Verifies the following:
38558 : - working getVariant() member function
38559 : - calls base class's error() member function
38560 : Every class has one of these functions.
38561 : */
38562 : bool
38563 : SgTemplateArgumentList::error()
38564 : {
38565 : // Put error checking here
38566 :
38567 : ROSE_ASSERT (this != NULL);
38568 : if (getVariant() != TemplateArgumentListTag)
38569 : {
38570 : printf ("Error in SgTemplateArgumentList::error(): SgTemplateArgumentList object has a %s variant \n",
38571 : Cxx_GrammarTerminalNames[getVariant()].name);
38572 : // printf ("Error in SgTemplateArgumentList::error() \n");
38573 : ROSE_ABORT();
38574 : }
38575 :
38576 : ROSE_ASSERT (getVariant() == TemplateArgumentListTag);
38577 : return SgSupport::error();
38578 : }
38579 : #endif
38580 :
38581 :
38582 :
38583 : // End of memberFunctionString
38584 :
38585 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
38586 :
38587 0 : SgTemplateArgumentList* isSgTemplateArgumentList ( SgNode* inputDerivedClassPointer )
38588 : {
38589 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38590 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38591 : // So to fix this we return NULL directly when the input is NULL and avoid the
38592 : // dynamic_cast in this case. This is likely a performance improvement as well.
38593 : // return dynamic_cast<SgTemplateArgumentList*>(inputDerivedClassPointer);
38594 : // Milind Chabbi (8/28/2013): isSgTemplateArgumentList uses table-driven castability instead of c++ default dynamic_cast
38595 : // this improves the running time performance by 10-20%.
38596 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateArgumentList*>(inputDerivedClassPointer);
38597 0 : return IS_SgTemplateArgumentList_FAST_MACRO(inputDerivedClassPointer);
38598 : }
38599 :
38600 : // DQ (11/8/2003): Added version of functions taking const pointer
38601 0 : const SgTemplateArgumentList* isSgTemplateArgumentList ( const SgNode* inputDerivedClassPointer )
38602 : {
38603 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38604 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38605 : // So to fix this we return NULL directly when the input is NULL and avoid the
38606 : // dynamic_cast in this case. This is likely a performance improvement as well.
38607 : // return dynamic_cast<const SgTemplateArgumentList*>(inputDerivedClassPointer);
38608 : // Milind Chabbi (8/28/2013): isSgTemplateArgumentList uses table-driven castability instead of c++ default dynamic_cast
38609 : // this improves the running time performance by 10-20%.
38610 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateArgumentList*>(inputDerivedClassPointer);
38611 0 : return IS_SgTemplateArgumentList_FAST_MACRO(inputDerivedClassPointer);
38612 : }
38613 :
38614 :
38615 :
38616 : /* #line 38617 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38617 :
38618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38619 :
38620 : /**
38621 : \brief Generated destructor
38622 :
38623 : This destructor is automatically generated (by ROSETTA). This destructor
38624 : only frees memory of data members associated with the parts of the current IR node which
38625 : are NOT traversed. Those data members that are part of a traversal can be freed using
38626 : a traversal (calling this destructor on all children in a post-order traversal). Such
38627 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
38628 :
38629 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
38630 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
38631 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
38632 :
38633 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
38634 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
38635 : pointers are not yet implemented to call delete on eash pointer in the container.
38636 : (This could be done by derivation from the STL containers to define containers that
38637 : automatically deleted their members.)
38638 :
38639 : */
38640 0 : SgTemplateArgumentList::~SgTemplateArgumentList () {
38641 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
38642 :
38643 :
38644 :
38645 : }
38646 :
38647 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38648 0 : }
38649 :
38650 :
38651 : /* #line 38652 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38652 :
38653 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
38654 :
38655 : // Generated constructor
38656 0 : SgTemplateArgumentList::SgTemplateArgumentList ( )
38657 0 : : SgSupport()
38658 : {
38659 : #ifdef DEBUG
38660 : // printf ("In SgTemplateArgumentList::SgTemplateArgumentList () sage_class_name() = %s \n",sage_class_name());
38661 : #endif
38662 : #if 0
38663 : // debugging information!
38664 : printf ("In SgTemplateArgumentList::SgTemplateArgumentList (): this = %p = %s \n",this,this->class_name().c_str());
38665 : #endif
38666 :
38667 :
38668 :
38669 : #if 0
38670 : // DQ (7/30/2014): Call a virtual function.
38671 : std::string s = this->class_name();
38672 : #endif
38673 :
38674 : // Test the variant virtual function
38675 : // assert(TemplateArgumentListTag == variant());
38676 0 : assert(TemplateArgumentListTag == this->variant());
38677 0 : ROSE_ASSERT(TemplateArgumentListTag == (int)(this->variantT()));
38678 0 : post_construction_initialization();
38679 :
38680 : // Test the isSgTemplateArgumentList() function since it has been problematic
38681 0 : assert(isSgTemplateArgumentList(this) != NULL);
38682 0 : }
38683 :
38684 : // Generated constructor (all data members)
38685 :
38686 : /* #line 38687 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38687 :
38688 :
38689 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38690 :
38691 :
38692 : // ********************************************************
38693 : // member functions common across all array grammar objects
38694 : // ********************************************************
38695 :
38696 :
38697 :
38698 : /* #line 38699 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38699 :
38700 :
38701 :
38702 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38703 :
38704 : // ********************************************************
38705 : // member functions specific to each node in the grammar
38706 : // ********************************************************
38707 :
38708 :
38709 : /* #line 38710 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38710 :
38711 : // Start of memberFunctionString
38712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
38713 :
38714 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
38715 :
38716 : SgTemplateParameterPtrList
38717 0 : SgTemplateParameterList::get_args () const
38718 : {
38719 0 : ROSE_ASSERT (this != NULL);
38720 :
38721 : #if 0
38722 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
38723 : // used to trigger marking transformations for the token-based unparsing.
38724 : printf ("SgTemplateParameterList::get_args = %p = %s \n",this,this->class_name().c_str());
38725 : #endif
38726 :
38727 0 : return p_args;
38728 : }
38729 :
38730 : void
38731 0 : SgTemplateParameterList::set_args ( SgTemplateParameterPtrList args )
38732 : {
38733 0 : ROSE_ASSERT (this != NULL);
38734 :
38735 : #if 0
38736 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
38737 : // used to trigger marking transformations for the token-based unparsing.
38738 : printf ("SgTemplateParameterList::set_args = %p = %s \n",this,this->class_name().c_str());
38739 : #endif
38740 :
38741 0 : set_isModified(true);
38742 :
38743 0 : p_args = args;
38744 0 : }
38745 :
38746 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
38747 :
38748 :
38749 : // End of memberFunctionString
38750 : // Start of memberFunctionString
38751 : /* #line 22179 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
38752 :
38753 :
38754 :
38755 : // End of memberFunctionString
38756 : // Start of memberFunctionString
38757 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
38758 :
38759 : // *** COMMON CODE SECTION BEGINS HERE ***
38760 :
38761 : #if 0
38762 : int
38763 : SgTemplateParameterList::getVariant() const
38764 : {
38765 : // This function is used in ROSE while "variant()" is used in SAGE
38766 : assert(this != NULL);
38767 : return variant();
38768 : }
38769 : #endif
38770 :
38771 : // This function is used in ROSE in treeTraversal code
38772 : // eventually replaces getVariant() and variant()
38773 : // though after variant() has been removed for a while we will
38774 : // want to change the name of variantT() back to variant()
38775 : // (since the "T" was ment to stand for temporary).
38776 : // When this happens the variantT() will be depricated.
38777 : VariantT
38778 0 : SgTemplateParameterList::variantT() const
38779 : {
38780 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
38781 0 : ROSE_ASSERT(this != NULL);
38782 0 : return V_SgTemplateParameterList;
38783 : }
38784 :
38785 : #if 0
38786 : int
38787 : SgTemplateParameterList::variant() const
38788 : {
38789 : // This function is used in SAGE
38790 : ROSE_ASSERT(this != NULL);
38791 : return TemplateParameterListTag;
38792 : }
38793 : #endif
38794 :
38795 : ROSE_DLL_API const char*
38796 0 : SgTemplateParameterList::sage_class_name() const
38797 : {
38798 0 : ROSE_ASSERT(this != NULL);
38799 0 : return "SgTemplateParameterList";
38800 : }
38801 :
38802 : std::string
38803 0 : SgTemplateParameterList::class_name() const
38804 : {
38805 0 : ROSE_ASSERT(this != NULL);
38806 0 : return "SgTemplateParameterList";
38807 : }
38808 :
38809 : // DQ (11/26/2005): Support for visitor pattern mechanims
38810 : // (inferior to ROSE traversal mechanism, experimental).
38811 : void
38812 0 : SgTemplateParameterList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
38813 : {
38814 0 : ROSE_ASSERT(this != NULL);
38815 0 : visitor.visit(this);
38816 0 : }
38817 :
38818 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
38819 0 : void SgTemplateParameterList::accept (ROSE_VisitorPattern & visitor) {
38820 0 : ROSE_ASSERT(this != NULL);
38821 0 : visitor.visit(this);
38822 0 : }
38823 :
38824 : SgTemplateParameterList*
38825 0 : SgTemplateParameterList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
38826 : {
38827 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
38828 : // This function is currently only supported for the AST used the represent Binary executables.
38829 : if (0 /* isSgAsmNode(this) != NULL */)
38830 : {
38831 : // Support for regex specification.
38832 : std::string prefixCode = "REGEX:";
38833 : addNewAttribute(prefixCode + s,a);
38834 : }
38835 : #endif
38836 :
38837 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
38838 0 : return this;
38839 : }
38840 :
38841 : // *** COMMON CODE SECTION ENDS HERE ***
38842 :
38843 :
38844 : // End of memberFunctionString
38845 : // Start of memberFunctionString
38846 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
38847 :
38848 :
38849 : #if 0
38850 : //! Error checking support
38851 : /*! Verifies the following:
38852 : - working getVariant() member function
38853 : - calls base class's error() member function
38854 : Every class has one of these functions.
38855 : */
38856 : bool
38857 : SgTemplateParameterList::error()
38858 : {
38859 : // Put error checking here
38860 :
38861 : ROSE_ASSERT (this != NULL);
38862 : if (getVariant() != TemplateParameterListTag)
38863 : {
38864 : printf ("Error in SgTemplateParameterList::error(): SgTemplateParameterList object has a %s variant \n",
38865 : Cxx_GrammarTerminalNames[getVariant()].name);
38866 : // printf ("Error in SgTemplateParameterList::error() \n");
38867 : ROSE_ABORT();
38868 : }
38869 :
38870 : ROSE_ASSERT (getVariant() == TemplateParameterListTag);
38871 : return SgSupport::error();
38872 : }
38873 : #endif
38874 :
38875 :
38876 :
38877 : // End of memberFunctionString
38878 :
38879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
38880 :
38881 0 : SgTemplateParameterList* isSgTemplateParameterList ( SgNode* inputDerivedClassPointer )
38882 : {
38883 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38884 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38885 : // So to fix this we return NULL directly when the input is NULL and avoid the
38886 : // dynamic_cast in this case. This is likely a performance improvement as well.
38887 : // return dynamic_cast<SgTemplateParameterList*>(inputDerivedClassPointer);
38888 : // Milind Chabbi (8/28/2013): isSgTemplateParameterList uses table-driven castability instead of c++ default dynamic_cast
38889 : // this improves the running time performance by 10-20%.
38890 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateParameterList*>(inputDerivedClassPointer);
38891 0 : return IS_SgTemplateParameterList_FAST_MACRO(inputDerivedClassPointer);
38892 : }
38893 :
38894 : // DQ (11/8/2003): Added version of functions taking const pointer
38895 0 : const SgTemplateParameterList* isSgTemplateParameterList ( const SgNode* inputDerivedClassPointer )
38896 : {
38897 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
38898 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
38899 : // So to fix this we return NULL directly when the input is NULL and avoid the
38900 : // dynamic_cast in this case. This is likely a performance improvement as well.
38901 : // return dynamic_cast<const SgTemplateParameterList*>(inputDerivedClassPointer);
38902 : // Milind Chabbi (8/28/2013): isSgTemplateParameterList uses table-driven castability instead of c++ default dynamic_cast
38903 : // this improves the running time performance by 10-20%.
38904 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateParameterList*>(inputDerivedClassPointer);
38905 0 : return IS_SgTemplateParameterList_FAST_MACRO(inputDerivedClassPointer);
38906 : }
38907 :
38908 :
38909 :
38910 : /* #line 38911 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38911 :
38912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38913 :
38914 : /**
38915 : \brief Generated destructor
38916 :
38917 : This destructor is automatically generated (by ROSETTA). This destructor
38918 : only frees memory of data members associated with the parts of the current IR node which
38919 : are NOT traversed. Those data members that are part of a traversal can be freed using
38920 : a traversal (calling this destructor on all children in a post-order traversal). Such
38921 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
38922 :
38923 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
38924 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
38925 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
38926 :
38927 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
38928 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
38929 : pointers are not yet implemented to call delete on eash pointer in the container.
38930 : (This could be done by derivation from the STL containers to define containers that
38931 : automatically deleted their members.)
38932 :
38933 : */
38934 0 : SgTemplateParameterList::~SgTemplateParameterList () {
38935 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
38936 :
38937 :
38938 :
38939 : }
38940 :
38941 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
38942 0 : }
38943 :
38944 :
38945 : /* #line 38946 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38946 :
38947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
38948 :
38949 : // Generated constructor
38950 0 : SgTemplateParameterList::SgTemplateParameterList ( )
38951 0 : : SgSupport()
38952 : {
38953 : #ifdef DEBUG
38954 : // printf ("In SgTemplateParameterList::SgTemplateParameterList () sage_class_name() = %s \n",sage_class_name());
38955 : #endif
38956 : #if 0
38957 : // debugging information!
38958 : printf ("In SgTemplateParameterList::SgTemplateParameterList (): this = %p = %s \n",this,this->class_name().c_str());
38959 : #endif
38960 :
38961 :
38962 :
38963 : #if 0
38964 : // DQ (7/30/2014): Call a virtual function.
38965 : std::string s = this->class_name();
38966 : #endif
38967 :
38968 : // Test the variant virtual function
38969 : // assert(TemplateParameterListTag == variant());
38970 0 : assert(TemplateParameterListTag == this->variant());
38971 0 : ROSE_ASSERT(TemplateParameterListTag == (int)(this->variantT()));
38972 0 : post_construction_initialization();
38973 :
38974 : // Test the isSgTemplateParameterList() function since it has been problematic
38975 0 : assert(isSgTemplateParameterList(this) != NULL);
38976 0 : }
38977 :
38978 : // Generated constructor (all data members)
38979 :
38980 : /* #line 38981 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38981 :
38982 :
38983 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38984 :
38985 :
38986 : // ********************************************************
38987 : // member functions common across all array grammar objects
38988 : // ********************************************************
38989 :
38990 :
38991 :
38992 : /* #line 38993 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
38993 :
38994 :
38995 :
38996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
38997 :
38998 : // ********************************************************
38999 : // member functions specific to each node in the grammar
39000 : // ********************************************************
39001 :
39002 :
39003 : /* #line 39004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
39004 :
39005 : // Start of memberFunctionString
39006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
39007 :
39008 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39009 :
39010 : std::string
39011 0 : SgGraph::get_name () const
39012 : {
39013 0 : ROSE_ASSERT (this != NULL);
39014 :
39015 : #if 0
39016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
39017 : // used to trigger marking transformations for the token-based unparsing.
39018 : printf ("SgGraph::get_name = %p = %s \n",this,this->class_name().c_str());
39019 : #endif
39020 :
39021 0 : return p_name;
39022 : }
39023 :
39024 : void
39025 0 : SgGraph::set_name ( std::string name )
39026 : {
39027 0 : ROSE_ASSERT (this != NULL);
39028 :
39029 : #if 0
39030 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
39031 : // used to trigger marking transformations for the token-based unparsing.
39032 : printf ("SgGraph::set_name = %p = %s \n",this,this->class_name().c_str());
39033 : #endif
39034 :
39035 0 : set_isModified(true);
39036 :
39037 0 : p_name = name;
39038 0 : }
39039 :
39040 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39041 :
39042 :
39043 : // End of memberFunctionString
39044 : // Start of memberFunctionString
39045 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39046 :
39047 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39048 :
39049 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39050 : const rose_graph_integer_node_hash_map &
39051 0 : SgGraph::get_node_index_to_node_map () const
39052 : {
39053 0 : assert (this != NULL);
39054 0 : return p_node_index_to_node_map;
39055 : }
39056 :
39057 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39058 : rose_graph_integer_node_hash_map &
39059 0 : SgGraph::get_node_index_to_node_map ()
39060 : {
39061 0 : assert (this != NULL);
39062 :
39063 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39064 : // As a rule only set_ access functions can set the isModified flag.
39065 : // set_isModified(true);
39066 :
39067 0 : return p_node_index_to_node_map;
39068 : }
39069 :
39070 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39071 :
39072 :
39073 : // End of memberFunctionString
39074 : // Start of memberFunctionString
39075 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39076 :
39077 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39078 :
39079 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39080 : const rose_graph_integer_edge_hash_map &
39081 0 : SgGraph::get_edge_index_to_edge_map () const
39082 : {
39083 0 : assert (this != NULL);
39084 0 : return p_edge_index_to_edge_map;
39085 : }
39086 :
39087 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39088 : rose_graph_integer_edge_hash_map &
39089 0 : SgGraph::get_edge_index_to_edge_map ()
39090 : {
39091 0 : assert (this != NULL);
39092 :
39093 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39094 : // As a rule only set_ access functions can set the isModified flag.
39095 : // set_isModified(true);
39096 :
39097 0 : return p_edge_index_to_edge_map;
39098 : }
39099 :
39100 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39101 :
39102 :
39103 : // End of memberFunctionString
39104 : // Start of memberFunctionString
39105 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39106 :
39107 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39108 :
39109 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39110 : const rose_graph_integerpair_edge_hash_multimap &
39111 0 : SgGraph::get_node_index_pair_to_edge_multimap () const
39112 : {
39113 0 : assert (this != NULL);
39114 0 : return p_node_index_pair_to_edge_multimap;
39115 : }
39116 :
39117 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39118 : rose_graph_integerpair_edge_hash_multimap &
39119 0 : SgGraph::get_node_index_pair_to_edge_multimap ()
39120 : {
39121 0 : assert (this != NULL);
39122 :
39123 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39124 : // As a rule only set_ access functions can set the isModified flag.
39125 : // set_isModified(true);
39126 :
39127 0 : return p_node_index_pair_to_edge_multimap;
39128 : }
39129 :
39130 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39131 :
39132 :
39133 : // End of memberFunctionString
39134 : // Start of memberFunctionString
39135 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39136 :
39137 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39138 :
39139 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39140 : const rose_graph_string_integer_hash_multimap &
39141 0 : SgGraph::get_string_to_node_index_multimap () const
39142 : {
39143 0 : assert (this != NULL);
39144 0 : return p_string_to_node_index_multimap;
39145 : }
39146 :
39147 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39148 : rose_graph_string_integer_hash_multimap &
39149 0 : SgGraph::get_string_to_node_index_multimap ()
39150 : {
39151 0 : assert (this != NULL);
39152 :
39153 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39154 : // As a rule only set_ access functions can set the isModified flag.
39155 : // set_isModified(true);
39156 :
39157 0 : return p_string_to_node_index_multimap;
39158 : }
39159 :
39160 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39161 :
39162 :
39163 : // End of memberFunctionString
39164 : // Start of memberFunctionString
39165 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39166 :
39167 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39168 :
39169 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39170 : const rose_graph_string_integer_hash_multimap &
39171 0 : SgGraph::get_string_to_edge_index_multimap () const
39172 : {
39173 0 : assert (this != NULL);
39174 0 : return p_string_to_edge_index_multimap;
39175 : }
39176 :
39177 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39178 : rose_graph_string_integer_hash_multimap &
39179 0 : SgGraph::get_string_to_edge_index_multimap ()
39180 : {
39181 0 : assert (this != NULL);
39182 :
39183 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39184 : // As a rule only set_ access functions can set the isModified flag.
39185 : // set_isModified(true);
39186 :
39187 0 : return p_string_to_edge_index_multimap;
39188 : }
39189 :
39190 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39191 :
39192 :
39193 : // End of memberFunctionString
39194 : // Start of memberFunctionString
39195 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39196 :
39197 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39198 :
39199 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39200 : const rose_graph_integer_edge_hash_multimap &
39201 0 : SgGraph::get_node_index_to_edge_multimap () const
39202 : {
39203 0 : assert (this != NULL);
39204 0 : return p_node_index_to_edge_multimap;
39205 : }
39206 :
39207 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39208 : rose_graph_integer_edge_hash_multimap &
39209 0 : SgGraph::get_node_index_to_edge_multimap ()
39210 : {
39211 0 : assert (this != NULL);
39212 :
39213 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39214 : // As a rule only set_ access functions can set the isModified flag.
39215 : // set_isModified(true);
39216 :
39217 0 : return p_node_index_to_edge_multimap;
39218 : }
39219 :
39220 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39221 :
39222 :
39223 : // End of memberFunctionString
39224 : // Start of memberFunctionString
39225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
39226 :
39227 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39228 :
39229 : int
39230 0 : SgGraph::get_index () const
39231 : {
39232 0 : ROSE_ASSERT (this != NULL);
39233 :
39234 : #if 0
39235 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
39236 : // used to trigger marking transformations for the token-based unparsing.
39237 : printf ("SgGraph::get_index = %p = %s \n",this,this->class_name().c_str());
39238 : #endif
39239 :
39240 0 : return p_index;
39241 : }
39242 :
39243 : void
39244 0 : SgGraph::set_index ( int index )
39245 : {
39246 0 : ROSE_ASSERT (this != NULL);
39247 :
39248 : #if 0
39249 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
39250 : // used to trigger marking transformations for the token-based unparsing.
39251 : printf ("SgGraph::set_index = %p = %s \n",this,this->class_name().c_str());
39252 : #endif
39253 :
39254 0 : set_isModified(true);
39255 :
39256 0 : p_index = index;
39257 0 : }
39258 :
39259 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39260 :
39261 :
39262 : // End of memberFunctionString
39263 : // Start of memberFunctionString
39264 :
39265 :
39266 : // End of memberFunctionString
39267 : // Start of memberFunctionString
39268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39269 :
39270 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39271 :
39272 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39273 : const SgBoostEdgeList &
39274 0 : SgGraph::get_boost_edges () const
39275 : {
39276 0 : assert (this != NULL);
39277 0 : return p_boost_edges;
39278 : }
39279 :
39280 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39281 : SgBoostEdgeList &
39282 0 : SgGraph::get_boost_edges ()
39283 : {
39284 0 : assert (this != NULL);
39285 :
39286 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39287 : // As a rule only set_ access functions can set the isModified flag.
39288 : // set_isModified(true);
39289 :
39290 0 : return p_boost_edges;
39291 : }
39292 :
39293 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39294 :
39295 :
39296 : // End of memberFunctionString
39297 : // Start of memberFunctionString
39298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39299 :
39300 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39301 :
39302 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39303 : const SgBoostEdgeWeightList &
39304 0 : SgGraph::get_boost_edge_weights () const
39305 : {
39306 0 : assert (this != NULL);
39307 0 : return p_boost_edge_weights;
39308 : }
39309 :
39310 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39311 : SgBoostEdgeWeightList &
39312 0 : SgGraph::get_boost_edge_weights ()
39313 : {
39314 0 : assert (this != NULL);
39315 :
39316 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39317 : // As a rule only set_ access functions can set the isModified flag.
39318 : // set_isModified(true);
39319 :
39320 0 : return p_boost_edge_weights;
39321 : }
39322 :
39323 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39324 :
39325 :
39326 : // End of memberFunctionString
39327 : // Start of memberFunctionString
39328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
39329 :
39330 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39331 :
39332 : AstAttributeMechanism*
39333 0 : SgGraph::get_attributeMechanism () const
39334 : {
39335 0 : ROSE_ASSERT (this != NULL);
39336 0 : return p_attributeMechanism;
39337 : }
39338 :
39339 : void
39340 0 : SgGraph::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
39341 : {
39342 0 : ROSE_ASSERT (this != NULL);
39343 :
39344 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
39345 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
39346 : {
39347 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
39348 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
39349 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
39350 : ROSE_ASSERT(false);
39351 : #endif
39352 : }
39353 : #endif
39354 0 : p_attributeMechanism = attributeMechanism;
39355 0 : }
39356 :
39357 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39358 :
39359 :
39360 : // End of memberFunctionString
39361 : // Start of memberFunctionString
39362 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
39363 :
39364 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
39365 :
39366 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39367 : const std::map<int, std::string> &
39368 0 : SgGraph::get_properties () const
39369 : {
39370 0 : assert (this != NULL);
39371 0 : return p_properties;
39372 : }
39373 :
39374 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
39375 : std::map<int, std::string> &
39376 0 : SgGraph::get_properties ()
39377 : {
39378 0 : assert (this != NULL);
39379 :
39380 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
39381 : // As a rule only set_ access functions can set the isModified flag.
39382 : // set_isModified(true);
39383 :
39384 0 : return p_properties;
39385 : }
39386 :
39387 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
39388 :
39389 :
39390 : // End of memberFunctionString
39391 : // Start of memberFunctionString
39392 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
39393 :
39394 :
39395 : #if 0
39396 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
39397 : // a pointer and the interface represented directly at the SgNode
39398 : AstAttributeMechanism &
39399 : SgGraph::attribute()
39400 : {
39401 : // DQ (1/2/2006): This function preserves as much of
39402 : // the syntax of attribute being a public data member.
39403 : if (p_attribute == NULL)
39404 : {
39405 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
39406 : assert(false);
39407 : }
39408 :
39409 : return *p_attribute;
39410 : }
39411 : #endif
39412 :
39413 : void
39414 0 : SgGraph::addNewAttribute( std::string s, AstAttribute* a )
39415 : {
39416 0 : if (get_attributeMechanism() == NULL)
39417 : {
39418 0 : set_attributeMechanism( new AstAttributeMechanism() );
39419 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
39420 : }
39421 0 : get_attributeMechanism()->add(s,a);
39422 0 : }
39423 :
39424 : void
39425 0 : SgGraph::setAttribute( std::string s, AstAttribute* a )
39426 : {
39427 0 : if (get_attributeMechanism() == NULL)
39428 : {
39429 0 : set_attributeMechanism( new AstAttributeMechanism() );
39430 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
39431 : }
39432 0 : get_attributeMechanism()->set(s,a);
39433 0 : }
39434 :
39435 : AstAttribute*
39436 0 : SgGraph::getAttribute(std::string s) const
39437 : {
39438 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
39439 0 : if (attributeExists(s)==false) return NULL;
39440 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
39441 0 : ROSE_ASSERT(returnValue != NULL);
39442 0 : return returnValue;
39443 : }
39444 :
39445 : void
39446 0 : SgGraph::updateAttribute( std::string s, AstAttribute* a )
39447 : {
39448 : // formerly called: replace
39449 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
39450 0 : get_attributeMechanism()->replace(s,a);
39451 0 : }
39452 :
39453 : void
39454 0 : SgGraph::removeAttribute(std::string s)
39455 : {
39456 0 : if (get_attributeMechanism())
39457 0 : get_attributeMechanism()->remove(s);
39458 :
39459 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
39460 0 : int remainingCount = numberOfAttributes();
39461 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
39462 0 : if (remainingCount == 0)
39463 : {
39464 0 : delete get_attributeMechanism();
39465 0 : set_attributeMechanism(NULL);
39466 : }
39467 0 : }
39468 :
39469 : bool
39470 0 : SgGraph::attributeExists(std::string s) const
39471 : {
39472 0 : bool returnValue = false;
39473 0 : if (get_attributeMechanism() != NULL)
39474 0 : returnValue = get_attributeMechanism()->exists(s);
39475 0 : return returnValue;
39476 : }
39477 :
39478 : int
39479 0 : SgGraph::numberOfAttributes() const
39480 : {
39481 0 : int returnValue = 0;
39482 0 : if (get_attributeMechanism() != NULL)
39483 0 : returnValue = get_attributeMechanism()->size();
39484 0 : return returnValue;
39485 : }
39486 :
39487 :
39488 :
39489 : // End of memberFunctionString
39490 : // Start of memberFunctionString
39491 : /* #line 22249 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
39492 :
39493 :
39494 : //#if defined(ROSE_USE_NEW_GRAPH_NODES) && !defined(ROSE_USING_GRAPH_IR_NODES_FOR_BACKWARD_COMPATABILITY)
39495 : //#warning "ROSE_USING_GRAPH_IR_NODES_FOR_BACKWARD_COMPATABILITY not set"
39496 : //#endif
39497 :
39498 :
39499 : // DQ (4/29/2009): Declaration of space for static data member.
39500 : int SgGraph::p_index_counter = 0;
39501 :
39502 :
39503 :
39504 : // tps : todo : remove me -----------------------------------------
39505 : void
39506 0 : SgGraph::append_properties( int addr, const std::string & prop )
39507 : {
39508 0 : assert(this != NULL);
39509 : /* implemented directly until we can fix how the statementList is built */
39510 0 : p_properties[addr] = prop;
39511 0 : }
39512 :
39513 : int
39514 0 : SgGraph::hashCode( const char* p, int len) const // hash a character array
39515 : {
39516 0 : assert(this != NULL);
39517 : unsigned int h = 0;
39518 0 : for (int i=0; i < len; i++)
39519 : {
39520 0 : h = (h<<5) | (h>>27); // 5-bit cyclic shift
39521 0 : h += (unsigned int)p[i]; // add in next character
39522 : }
39523 0 : return (int)h;
39524 : }
39525 : // -----------------------------------------------------
39526 :
39527 :
39528 :
39529 : // DQ (4/28/2009): Added support to have internal list nodes built automatically in the SgGraph constructor.
39530 : void
39531 0 : SgGraph::post_construction_initialization()
39532 : {
39533 0 : assert(this != NULL);
39534 :
39535 :
39536 : // Setup an internal graph_id
39537 0 : p_index = p_index_counter++;
39538 :
39539 0 : }
39540 :
39541 :
39542 :
39543 : std::string
39544 0 : SgGraph::getProperty(SgGraph::GraphProperties property, SgGraphNode* node) {
39545 0 : string value="";
39546 0 : map < int , string> node_p = node->get_properties();
39547 0 : map < int , string>::iterator prop = node_p.find(property);
39548 0 : if (prop!=node_p.end()) {
39549 0 : value = prop->second;
39550 : }
39551 0 : return value;
39552 : }
39553 :
39554 : std::string
39555 0 : SgGraph::getProperty(SgGraph::GraphProperties property, SgGraphEdge* edge) {
39556 0 : string value="";
39557 0 : map < int , string> node_p = edge->get_properties();
39558 0 : map < int , string>::iterator prop = node_p.find(property);
39559 0 : if (prop!=node_p.end()) {
39560 0 : value = prop->second;
39561 : }
39562 0 : return value;
39563 : }
39564 :
39565 :
39566 : void
39567 0 : SgGraph::setProperty(SgGraph::GraphProperties property, SgGraphNode* node,
39568 : std::string value) {
39569 0 : node->append_properties(property, value);
39570 0 : }
39571 :
39572 : void
39573 0 : SgGraph::setProperty(SgGraph::GraphProperties property, SgGraphEdge* edge,
39574 : std::string value) {
39575 0 : edge->append_properties(property, value);
39576 0 : }
39577 :
39578 :
39579 :
39580 :
39581 : void
39582 0 : SgGraph::checkIfGraphNodeExists(const string& trg_mnemonic, std::vector<SgGraphNode*>& nodes) {
39583 0 : rose_graph_string_integer_hash_multimap::const_iterator it1, it2;
39584 0 : pair <rose_graph_string_integer_hash_multimap::const_iterator, rose_graph_string_integer_hash_multimap::const_iterator>
39585 0 : iter = p_string_to_node_index_multimap.equal_range(trg_mnemonic);
39586 0 : it1 = iter.first;
39587 0 : it2 = iter.second;
39588 0 : SgGraphNode* node = NULL;
39589 0 : for (;it1!=it2; ++it1) {
39590 : //
39591 : //rose_graph_string_integer_hash_multimap::iterator it = p_string_to_node_index_multimap.find(trg_mnemonic);
39592 : //if (it!=p_string_to_node_index_multimap.end()) {
39593 0 : int index = it1->second;
39594 0 : node = p_node_index_to_node_map.find(index)->second;
39595 0 : nodes.push_back(node);
39596 : }
39597 : // return nodes;
39598 :
39599 : // return NULL;
39600 0 : }
39601 :
39602 : #if 0
39603 : // old interface
39604 : SgGraphNode*
39605 : SgGraph::checkIfGraphNodeExists(string& trg_mnemonic) {
39606 : #if 1
39607 : SgGraphNode* node = NULL;
39608 : SgGraphNodeList* gnodes = get_nodes();
39609 : rose_graph_hash_multimap nodes = gnodes->get_nodes();
39610 : rose_graph_hash_multimap::iterator it = nodes.find(trg_mnemonic);
39611 : if (it!=nodes.end()) {
39612 : node = it->second;
39613 : return node;
39614 : }
39615 : #endif
39616 :
39617 : return NULL;
39618 : }
39619 :
39620 : // Increase the size of the hash_map
39621 : resize_hash_maps( 1000 );
39622 : #endif
39623 :
39624 :
39625 :
39626 :
39627 : // End of memberFunctionString
39628 : // Start of memberFunctionString
39629 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
39630 :
39631 : // *** COMMON CODE SECTION BEGINS HERE ***
39632 :
39633 : #if 0
39634 : int
39635 : SgGraph::getVariant() const
39636 : {
39637 : // This function is used in ROSE while "variant()" is used in SAGE
39638 : assert(this != NULL);
39639 : return variant();
39640 : }
39641 : #endif
39642 :
39643 : // This function is used in ROSE in treeTraversal code
39644 : // eventually replaces getVariant() and variant()
39645 : // though after variant() has been removed for a while we will
39646 : // want to change the name of variantT() back to variant()
39647 : // (since the "T" was ment to stand for temporary).
39648 : // When this happens the variantT() will be depricated.
39649 : VariantT
39650 0 : SgGraph::variantT() const
39651 : {
39652 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
39653 0 : ROSE_ASSERT(this != NULL);
39654 0 : return V_SgGraph;
39655 : }
39656 :
39657 : #if 0
39658 : int
39659 : SgGraph::variant() const
39660 : {
39661 : // This function is used in SAGE
39662 : ROSE_ASSERT(this != NULL);
39663 : return GraphTag;
39664 : }
39665 : #endif
39666 :
39667 : ROSE_DLL_API const char*
39668 0 : SgGraph::sage_class_name() const
39669 : {
39670 0 : ROSE_ASSERT(this != NULL);
39671 0 : return "SgGraph";
39672 : }
39673 :
39674 : std::string
39675 0 : SgGraph::class_name() const
39676 : {
39677 0 : ROSE_ASSERT(this != NULL);
39678 0 : return "SgGraph";
39679 : }
39680 :
39681 : // DQ (11/26/2005): Support for visitor pattern mechanims
39682 : // (inferior to ROSE traversal mechanism, experimental).
39683 : void
39684 0 : SgGraph::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
39685 : {
39686 0 : ROSE_ASSERT(this != NULL);
39687 0 : visitor.visit(this);
39688 0 : }
39689 :
39690 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
39691 0 : void SgGraph::accept (ROSE_VisitorPattern & visitor) {
39692 0 : ROSE_ASSERT(this != NULL);
39693 0 : visitor.visit(this);
39694 0 : }
39695 :
39696 : SgGraph*
39697 0 : SgGraph::addRegExpAttribute(std::string s, AstRegExAttribute* a)
39698 : {
39699 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
39700 : // This function is currently only supported for the AST used the represent Binary executables.
39701 : if (0 /* isSgAsmNode(this) != NULL */)
39702 : {
39703 : // Support for regex specification.
39704 : std::string prefixCode = "REGEX:";
39705 : addNewAttribute(prefixCode + s,a);
39706 : }
39707 : #endif
39708 :
39709 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
39710 0 : return this;
39711 : }
39712 :
39713 : // *** COMMON CODE SECTION ENDS HERE ***
39714 :
39715 :
39716 : // End of memberFunctionString
39717 : // Start of memberFunctionString
39718 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
39719 :
39720 :
39721 : #if 0
39722 : //! Error checking support
39723 : /*! Verifies the following:
39724 : - working getVariant() member function
39725 : - calls base class's error() member function
39726 : Every class has one of these functions.
39727 : */
39728 : bool
39729 : SgGraph::error()
39730 : {
39731 : // Put error checking here
39732 :
39733 : ROSE_ASSERT (this != NULL);
39734 : if (getVariant() != GraphTag)
39735 : {
39736 : printf ("Error in SgGraph::error(): SgGraph object has a %s variant \n",
39737 : Cxx_GrammarTerminalNames[getVariant()].name);
39738 : // printf ("Error in SgGraph::error() \n");
39739 : ROSE_ABORT();
39740 : }
39741 :
39742 : ROSE_ASSERT (getVariant() == GraphTag);
39743 : return SgSupport::error();
39744 : }
39745 : #endif
39746 :
39747 :
39748 :
39749 : // End of memberFunctionString
39750 :
39751 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
39752 :
39753 0 : SgGraph* isSgGraph ( SgNode* inputDerivedClassPointer )
39754 : {
39755 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
39756 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
39757 : // So to fix this we return NULL directly when the input is NULL and avoid the
39758 : // dynamic_cast in this case. This is likely a performance improvement as well.
39759 : // return dynamic_cast<SgGraph*>(inputDerivedClassPointer);
39760 : // Milind Chabbi (8/28/2013): isSgGraph uses table-driven castability instead of c++ default dynamic_cast
39761 : // this improves the running time performance by 10-20%.
39762 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGraph*>(inputDerivedClassPointer);
39763 0 : return IS_SgGraph_FAST_MACRO(inputDerivedClassPointer);
39764 : }
39765 :
39766 : // DQ (11/8/2003): Added version of functions taking const pointer
39767 0 : const SgGraph* isSgGraph ( const SgNode* inputDerivedClassPointer )
39768 : {
39769 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
39770 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
39771 : // So to fix this we return NULL directly when the input is NULL and avoid the
39772 : // dynamic_cast in this case. This is likely a performance improvement as well.
39773 : // return dynamic_cast<const SgGraph*>(inputDerivedClassPointer);
39774 : // Milind Chabbi (8/28/2013): isSgGraph uses table-driven castability instead of c++ default dynamic_cast
39775 : // this improves the running time performance by 10-20%.
39776 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGraph*>(inputDerivedClassPointer);
39777 0 : return IS_SgGraph_FAST_MACRO(inputDerivedClassPointer);
39778 : }
39779 :
39780 :
39781 :
39782 : /* #line 39783 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
39783 :
39784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
39785 :
39786 : /**
39787 : \brief Generated destructor
39788 :
39789 : This destructor is automatically generated (by ROSETTA). This destructor
39790 : only frees memory of data members associated with the parts of the current IR node which
39791 : are NOT traversed. Those data members that are part of a traversal can be freed using
39792 : a traversal (calling this destructor on all children in a post-order traversal). Such
39793 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
39794 :
39795 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
39796 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
39797 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
39798 :
39799 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
39800 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
39801 : pointers are not yet implemented to call delete on eash pointer in the container.
39802 : (This could be done by derivation from the STL containers to define containers that
39803 : automatically deleted their members.)
39804 :
39805 : */
39806 0 : SgGraph::~SgGraph () {
39807 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
39808 :
39809 :
39810 : // case: not a listType for name
39811 0 : p_name = ""; // non list case
39812 : // case: not a listType for index
39813 0 : p_index = -1; // non list case
39814 : // case: not a listType for attributeMechanism
39815 0 : p_attributeMechanism = NULL; // non list case
39816 :
39817 : }
39818 :
39819 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
39820 0 : }
39821 :
39822 :
39823 : /* #line 39824 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
39824 :
39825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
39826 :
39827 : // Generated constructor
39828 0 : SgGraph::SgGraph ( std::string name )
39829 0 : : SgSupport()
39830 : {
39831 : #ifdef DEBUG
39832 : // printf ("In SgGraph::SgGraph (std::string name) sage_class_name() = %s \n",sage_class_name());
39833 : #endif
39834 : #if 0
39835 : // debugging information!
39836 : printf ("In SgGraph::SgGraph (std::string name): this = %p = %s \n",this,this->class_name().c_str());
39837 : #endif
39838 :
39839 0 : p_name = name;
39840 0 : p_index = -1;
39841 0 : p_attributeMechanism = NULL;
39842 :
39843 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
39844 :
39845 : #if 0
39846 : // DQ (7/30/2014): Call a virtual function.
39847 : std::string s = this->class_name();
39848 : #endif
39849 :
39850 : // Test the variant virtual function
39851 : // assert(GraphTag == variant());
39852 0 : assert(GraphTag == this->variant());
39853 0 : ROSE_ASSERT(GraphTag == (int)(this->variantT()));
39854 0 : post_construction_initialization();
39855 :
39856 : // Test the isSgGraph() function since it has been problematic
39857 0 : assert(isSgGraph(this) != NULL);
39858 0 : }
39859 :
39860 : // Generated constructor (all data members)
39861 :
39862 : /* #line 39863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
39863 :
39864 :
39865 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
39866 :
39867 :
39868 : // ********************************************************
39869 : // member functions common across all array grammar objects
39870 : // ********************************************************
39871 :
39872 :
39873 :
39874 : /* #line 39875 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
39875 :
39876 :
39877 :
39878 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
39879 :
39880 : // ********************************************************
39881 : // member functions specific to each node in the grammar
39882 : // ********************************************************
39883 :
39884 :
39885 : /* #line 39886 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
39886 :
39887 : // Start of memberFunctionString
39888 : /* #line 22425 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
39889 :
39890 :
39891 :
39892 : void
39893 0 : SgIncidenceDirectedGraph::post_construction_initialization()
39894 : {
39895 0 : assert(this != NULL);
39896 :
39897 0 : }
39898 :
39899 :
39900 : bool
39901 0 : SgIncidenceDirectedGraph::checkIfGraphEdgeExists(SgGraphNode* src) {
39902 0 : const rose_graph_integer_edge_hash_multimap& edges = get_node_index_to_edge_multimap_edgesOut();
39903 0 : rose_graph_integer_edge_hash_multimap::const_iterator it = edges.find(src->get_index());
39904 :
39905 0 : return (it != edges.end());
39906 : }
39907 :
39908 : std::set <SgGraphEdge*>
39909 0 : SgIncidenceDirectedGraph::getEdge(SgGraphNode* src) {
39910 0 : const rose_graph_integer_edge_hash_multimap& edges = get_node_index_to_edge_multimap_edgesOut();
39911 0 : set<SgGraphEdge*> medges;
39912 0 : rose_graph_integer_edge_hash_multimap::const_iterator it1, it2;
39913 0 : pair <rose_graph_integer_edge_hash_multimap::const_iterator, rose_graph_integer_edge_hash_multimap::const_iterator> iter =
39914 0 : edges.equal_range(src->get_index());
39915 0 : it1 = iter.first;
39916 0 : it2 = iter.second;
39917 0 : for (;it1!=it2; ++it1) {
39918 : // SgGraphNode* source = it1->first;
39919 0 : SgGraphEdge* edge = isSgGraphEdge(it1->second);
39920 0 : medges.insert(edge);
39921 : }
39922 0 : return medges;
39923 : }
39924 :
39925 :
39926 :
39927 :
39928 :
39929 :
39930 : void
39931 0 : SgIncidenceDirectedGraph::getSuccessors(const SgGraphNode* node, std::vector <SgGraphNode*>& vec ) const
39932 : {
39933 : //SgGraphEdgeList* gedges = get_edgesOut();
39934 0 : const rose_graph_integer_edge_hash_multimap& edges = get_node_index_to_edge_multimap_edgesOut();
39935 0 : rose_graph_integer_edge_hash_multimap::const_iterator it1, it2;
39936 0 : pair <rose_graph_integer_edge_hash_multimap::const_iterator, rose_graph_integer_edge_hash_multimap::const_iterator> iter =
39937 0 : edges.equal_range(node->get_index());
39938 0 : it1 = iter.first;
39939 0 : it2 = iter.second;
39940 : // cerr << " >>>>>>>>>>>>>>> Outedges for node " << node->get_index() << endl;
39941 0 : assert(node);
39942 0 : for (;it1!=it2; ++it1) {
39943 0 : SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
39944 : // cerr << " are : " << edge->get_index() << endl;
39945 0 : assert(edge);
39946 0 : if (edge) {
39947 0 : SgGraphNode* target = isSgGraphNode(edge->get_to());
39948 0 : assert(target);
39949 0 : if (target) {
39950 0 : vec.push_back(target);
39951 : }
39952 : } else {
39953 : printf("This is not a DirectedGraphEdge.\n");
39954 : assert(edge);
39955 : }
39956 : }
39957 0 : }
39958 :
39959 : void
39960 0 : SgIncidenceDirectedGraph::getPredecessors(const SgGraphNode* node, std::vector <SgGraphNode*>& vec ) const
39961 : {
39962 : //SgGraphEdgeList* gredges = get_edgesIn();
39963 0 : rose_graph_integer_edge_hash_multimap edges = get_node_index_to_edge_multimap_edgesIn();
39964 0 : rose_graph_integer_edge_hash_multimap::iterator it1, it2;
39965 0 : pair <rose_graph_integer_edge_hash_multimap::iterator, rose_graph_integer_edge_hash_multimap::iterator> iter =
39966 : //fails
39967 : // get_edgesIn()->get_edges().equal_range(node);
39968 0 : edges.equal_range(node->get_index());
39969 0 : it1 = iter.first;
39970 0 : it2 = iter.second;
39971 0 : for (;it1!=it2; ++it1) {
39972 0 : SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
39973 0 : if (edge) {
39974 0 : SgGraphNode* source = isSgGraphNode(edge->get_from());
39975 0 : if (source) {
39976 : //string type_n = getProperty(SgGraph::type, edge);
39977 0 : vec.push_back(source);
39978 : }
39979 : }
39980 : }
39981 0 : }
39982 :
39983 :
39984 :
39985 : set<SgDirectedGraphEdge*>
39986 0 : SgIncidenceDirectedGraph::getDirectedEdge(SgGraphNode* src, SgGraphNode* trg) {
39987 : //SgGraphEdgeList* gedges = get_edgesOut();
39988 0 : const rose_graph_integer_edge_hash_multimap& edges = get_node_index_to_edge_multimap_edgesOut();
39989 0 : set<SgDirectedGraphEdge*> medges;
39990 0 : rose_graph_integer_edge_hash_multimap::const_iterator it1, it2;
39991 0 : pair <rose_graph_integer_edge_hash_multimap::const_iterator, rose_graph_integer_edge_hash_multimap::const_iterator> iter =
39992 0 : edges.equal_range(src->get_index());
39993 0 : it1 = iter.first;
39994 0 : it2 = iter.second;
39995 0 : for (;it1!=it2; ++it1) {
39996 : // SgGraphNode* source = it1->first;
39997 0 : SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
39998 :
39999 : // DQ (3/19/2016): Klocworks reports this as an issue, since "edge" could be NULL. Fix by adding an addertion.
40000 0 : ROSE_ASSERT(edge != NULL);
40001 :
40002 0 : SgGraphNode* target = isSgGraphNode(edge->get_to());
40003 0 : if (target==trg)
40004 0 : medges.insert(edge);
40005 : }
40006 0 : return medges;
40007 : }
40008 :
40009 :
40010 : bool
40011 0 : SgIncidenceDirectedGraph::checkIfDirectedGraphEdgeExists(SgGraphNode* src, SgGraphNode* trg) {
40012 0 : if (src==NULL)
40013 : return false;
40014 0 : if (trg==NULL)
40015 : return false;
40016 :
40017 0 : const rose_graph_integer_edge_hash_multimap& edges = get_node_index_to_edge_multimap_edgesOut();
40018 :
40019 0 : rose_graph_integer_edge_hash_multimap::const_iterator it1, it2;
40020 0 : pair <rose_graph_integer_edge_hash_multimap::const_iterator, rose_graph_integer_edge_hash_multimap::const_iterator> iter =
40021 0 : edges.equal_range(src->get_index());
40022 0 : it1 = iter.first;
40023 0 : it2 = iter.second;
40024 0 : for (;it1!=it2; ++it1) {
40025 0 : SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
40026 :
40027 : // DQ (3/19/2016): Klocworks reports this as an issue, since "edge" could be NULL. Fix by adding an addertion.
40028 0 : ROSE_ASSERT(edge != NULL);
40029 :
40030 0 : SgGraphNode* target = edge->get_to();
40031 0 : if (target==trg)
40032 : return true;
40033 : }
40034 : return false;
40035 : }
40036 :
40037 :
40038 :
40039 :
40040 :
40041 : // End of memberFunctionString
40042 : // Start of memberFunctionString
40043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
40044 :
40045 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
40046 :
40047 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
40048 : const rose_graph_integer_edge_hash_multimap &
40049 0 : SgIncidenceDirectedGraph::get_node_index_to_edge_multimap_edgesOut () const
40050 : {
40051 0 : assert (this != NULL);
40052 0 : return p_node_index_to_edge_multimap_edgesOut;
40053 : }
40054 :
40055 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
40056 : rose_graph_integer_edge_hash_multimap &
40057 0 : SgIncidenceDirectedGraph::get_node_index_to_edge_multimap_edgesOut ()
40058 : {
40059 0 : assert (this != NULL);
40060 :
40061 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
40062 : // As a rule only set_ access functions can set the isModified flag.
40063 : // set_isModified(true);
40064 :
40065 0 : return p_node_index_to_edge_multimap_edgesOut;
40066 : }
40067 :
40068 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
40069 :
40070 :
40071 : // End of memberFunctionString
40072 : // Start of memberFunctionString
40073 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
40074 :
40075 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
40076 :
40077 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
40078 : const rose_graph_integer_edge_hash_multimap &
40079 0 : SgIncidenceDirectedGraph::get_node_index_to_edge_multimap_edgesIn () const
40080 : {
40081 0 : assert (this != NULL);
40082 0 : return p_node_index_to_edge_multimap_edgesIn;
40083 : }
40084 :
40085 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
40086 : rose_graph_integer_edge_hash_multimap &
40087 0 : SgIncidenceDirectedGraph::get_node_index_to_edge_multimap_edgesIn ()
40088 : {
40089 0 : assert (this != NULL);
40090 :
40091 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
40092 : // As a rule only set_ access functions can set the isModified flag.
40093 : // set_isModified(true);
40094 :
40095 0 : return p_node_index_to_edge_multimap_edgesIn;
40096 : }
40097 :
40098 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
40099 :
40100 :
40101 : // End of memberFunctionString
40102 : // Start of memberFunctionString
40103 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
40104 :
40105 : // *** COMMON CODE SECTION BEGINS HERE ***
40106 :
40107 : #if 0
40108 : int
40109 : SgIncidenceDirectedGraph::getVariant() const
40110 : {
40111 : // This function is used in ROSE while "variant()" is used in SAGE
40112 : assert(this != NULL);
40113 : return variant();
40114 : }
40115 : #endif
40116 :
40117 : // This function is used in ROSE in treeTraversal code
40118 : // eventually replaces getVariant() and variant()
40119 : // though after variant() has been removed for a while we will
40120 : // want to change the name of variantT() back to variant()
40121 : // (since the "T" was ment to stand for temporary).
40122 : // When this happens the variantT() will be depricated.
40123 : VariantT
40124 0 : SgIncidenceDirectedGraph::variantT() const
40125 : {
40126 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
40127 0 : ROSE_ASSERT(this != NULL);
40128 0 : return V_SgIncidenceDirectedGraph;
40129 : }
40130 :
40131 : #if 0
40132 : int
40133 : SgIncidenceDirectedGraph::variant() const
40134 : {
40135 : // This function is used in SAGE
40136 : ROSE_ASSERT(this != NULL);
40137 : return IncidenceDirectedGraphTag;
40138 : }
40139 : #endif
40140 :
40141 : ROSE_DLL_API const char*
40142 0 : SgIncidenceDirectedGraph::sage_class_name() const
40143 : {
40144 0 : ROSE_ASSERT(this != NULL);
40145 0 : return "SgIncidenceDirectedGraph";
40146 : }
40147 :
40148 : std::string
40149 0 : SgIncidenceDirectedGraph::class_name() const
40150 : {
40151 0 : ROSE_ASSERT(this != NULL);
40152 0 : return "SgIncidenceDirectedGraph";
40153 : }
40154 :
40155 : // DQ (11/26/2005): Support for visitor pattern mechanims
40156 : // (inferior to ROSE traversal mechanism, experimental).
40157 : void
40158 0 : SgIncidenceDirectedGraph::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
40159 : {
40160 0 : ROSE_ASSERT(this != NULL);
40161 0 : visitor.visit(this);
40162 0 : }
40163 :
40164 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
40165 0 : void SgIncidenceDirectedGraph::accept (ROSE_VisitorPattern & visitor) {
40166 0 : ROSE_ASSERT(this != NULL);
40167 0 : visitor.visit(this);
40168 0 : }
40169 :
40170 : SgIncidenceDirectedGraph*
40171 0 : SgIncidenceDirectedGraph::addRegExpAttribute(std::string s, AstRegExAttribute* a)
40172 : {
40173 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
40174 : // This function is currently only supported for the AST used the represent Binary executables.
40175 : if (0 /* isSgAsmNode(this) != NULL */)
40176 : {
40177 : // Support for regex specification.
40178 : std::string prefixCode = "REGEX:";
40179 : addNewAttribute(prefixCode + s,a);
40180 : }
40181 : #endif
40182 :
40183 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
40184 0 : return this;
40185 : }
40186 :
40187 : // *** COMMON CODE SECTION ENDS HERE ***
40188 :
40189 :
40190 : // End of memberFunctionString
40191 : // Start of memberFunctionString
40192 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
40193 :
40194 :
40195 : #if 0
40196 : //! Error checking support
40197 : /*! Verifies the following:
40198 : - working getVariant() member function
40199 : - calls base class's error() member function
40200 : Every class has one of these functions.
40201 : */
40202 : bool
40203 : SgIncidenceDirectedGraph::error()
40204 : {
40205 : // Put error checking here
40206 :
40207 : ROSE_ASSERT (this != NULL);
40208 : if (getVariant() != IncidenceDirectedGraphTag)
40209 : {
40210 : printf ("Error in SgIncidenceDirectedGraph::error(): SgIncidenceDirectedGraph object has a %s variant \n",
40211 : Cxx_GrammarTerminalNames[getVariant()].name);
40212 : // printf ("Error in SgIncidenceDirectedGraph::error() \n");
40213 : ROSE_ABORT();
40214 : }
40215 :
40216 : ROSE_ASSERT (getVariant() == IncidenceDirectedGraphTag);
40217 : return SgGraph::error();
40218 : }
40219 : #endif
40220 :
40221 :
40222 :
40223 : // End of memberFunctionString
40224 :
40225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
40226 :
40227 0 : SgIncidenceDirectedGraph* isSgIncidenceDirectedGraph ( SgNode* inputDerivedClassPointer )
40228 : {
40229 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40230 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40231 : // So to fix this we return NULL directly when the input is NULL and avoid the
40232 : // dynamic_cast in this case. This is likely a performance improvement as well.
40233 : // return dynamic_cast<SgIncidenceDirectedGraph*>(inputDerivedClassPointer);
40234 : // Milind Chabbi (8/28/2013): isSgIncidenceDirectedGraph uses table-driven castability instead of c++ default dynamic_cast
40235 : // this improves the running time performance by 10-20%.
40236 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIncidenceDirectedGraph*>(inputDerivedClassPointer);
40237 0 : return IS_SgIncidenceDirectedGraph_FAST_MACRO(inputDerivedClassPointer);
40238 : }
40239 :
40240 : // DQ (11/8/2003): Added version of functions taking const pointer
40241 0 : const SgIncidenceDirectedGraph* isSgIncidenceDirectedGraph ( const SgNode* inputDerivedClassPointer )
40242 : {
40243 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40244 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40245 : // So to fix this we return NULL directly when the input is NULL and avoid the
40246 : // dynamic_cast in this case. This is likely a performance improvement as well.
40247 : // return dynamic_cast<const SgIncidenceDirectedGraph*>(inputDerivedClassPointer);
40248 : // Milind Chabbi (8/28/2013): isSgIncidenceDirectedGraph uses table-driven castability instead of c++ default dynamic_cast
40249 : // this improves the running time performance by 10-20%.
40250 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIncidenceDirectedGraph*>(inputDerivedClassPointer);
40251 0 : return IS_SgIncidenceDirectedGraph_FAST_MACRO(inputDerivedClassPointer);
40252 : }
40253 :
40254 :
40255 :
40256 : /* #line 40257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40257 :
40258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
40259 :
40260 : /**
40261 : \brief Generated destructor
40262 :
40263 : This destructor is automatically generated (by ROSETTA). This destructor
40264 : only frees memory of data members associated with the parts of the current IR node which
40265 : are NOT traversed. Those data members that are part of a traversal can be freed using
40266 : a traversal (calling this destructor on all children in a post-order traversal). Such
40267 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
40268 :
40269 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
40270 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
40271 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
40272 :
40273 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
40274 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
40275 : pointers are not yet implemented to call delete on eash pointer in the container.
40276 : (This could be done by derivation from the STL containers to define containers that
40277 : automatically deleted their members.)
40278 :
40279 : */
40280 0 : SgIncidenceDirectedGraph::~SgIncidenceDirectedGraph () {
40281 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
40282 :
40283 :
40284 :
40285 : }
40286 :
40287 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
40288 0 : }
40289 :
40290 :
40291 : /* #line 40292 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40292 :
40293 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
40294 :
40295 : // Generated constructor
40296 0 : SgIncidenceDirectedGraph::SgIncidenceDirectedGraph ( std::string name )
40297 0 : : SgGraph(name)
40298 : {
40299 : #ifdef DEBUG
40300 : // printf ("In SgIncidenceDirectedGraph::SgIncidenceDirectedGraph (std::string name) sage_class_name() = %s \n",sage_class_name());
40301 : #endif
40302 : #if 0
40303 : // debugging information!
40304 : printf ("In SgIncidenceDirectedGraph::SgIncidenceDirectedGraph (std::string name): this = %p = %s \n",this,this->class_name().c_str());
40305 : #endif
40306 :
40307 :
40308 :
40309 : #if 0
40310 : // DQ (7/30/2014): Call a virtual function.
40311 : std::string s = this->class_name();
40312 : #endif
40313 :
40314 : // Test the variant virtual function
40315 : // assert(IncidenceDirectedGraphTag == variant());
40316 0 : assert(IncidenceDirectedGraphTag == this->variant());
40317 0 : ROSE_ASSERT(IncidenceDirectedGraphTag == (int)(this->variantT()));
40318 0 : post_construction_initialization();
40319 :
40320 : // Test the isSgIncidenceDirectedGraph() function since it has been problematic
40321 0 : assert(isSgIncidenceDirectedGraph(this) != NULL);
40322 0 : }
40323 :
40324 : // Generated constructor (all data members)
40325 :
40326 : /* #line 40327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40327 :
40328 :
40329 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
40330 :
40331 :
40332 : // ********************************************************
40333 : // member functions common across all array grammar objects
40334 : // ********************************************************
40335 :
40336 :
40337 :
40338 : /* #line 40339 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40339 :
40340 :
40341 :
40342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
40343 :
40344 : // ********************************************************
40345 : // member functions specific to each node in the grammar
40346 : // ********************************************************
40347 :
40348 :
40349 : /* #line 40350 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40350 :
40351 : // Start of memberFunctionString
40352 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
40353 :
40354 : // *** COMMON CODE SECTION BEGINS HERE ***
40355 :
40356 : #if 0
40357 : int
40358 : SgBidirectionalGraph::getVariant() const
40359 : {
40360 : // This function is used in ROSE while "variant()" is used in SAGE
40361 : assert(this != NULL);
40362 : return variant();
40363 : }
40364 : #endif
40365 :
40366 : // This function is used in ROSE in treeTraversal code
40367 : // eventually replaces getVariant() and variant()
40368 : // though after variant() has been removed for a while we will
40369 : // want to change the name of variantT() back to variant()
40370 : // (since the "T" was ment to stand for temporary).
40371 : // When this happens the variantT() will be depricated.
40372 : VariantT
40373 0 : SgBidirectionalGraph::variantT() const
40374 : {
40375 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
40376 0 : ROSE_ASSERT(this != NULL);
40377 0 : return V_SgBidirectionalGraph;
40378 : }
40379 :
40380 : #if 0
40381 : int
40382 : SgBidirectionalGraph::variant() const
40383 : {
40384 : // This function is used in SAGE
40385 : ROSE_ASSERT(this != NULL);
40386 : return BidirectionalGraphTag;
40387 : }
40388 : #endif
40389 :
40390 : ROSE_DLL_API const char*
40391 0 : SgBidirectionalGraph::sage_class_name() const
40392 : {
40393 0 : ROSE_ASSERT(this != NULL);
40394 0 : return "SgBidirectionalGraph";
40395 : }
40396 :
40397 : std::string
40398 0 : SgBidirectionalGraph::class_name() const
40399 : {
40400 0 : ROSE_ASSERT(this != NULL);
40401 0 : return "SgBidirectionalGraph";
40402 : }
40403 :
40404 : // DQ (11/26/2005): Support for visitor pattern mechanims
40405 : // (inferior to ROSE traversal mechanism, experimental).
40406 : void
40407 0 : SgBidirectionalGraph::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
40408 : {
40409 0 : ROSE_ASSERT(this != NULL);
40410 0 : visitor.visit(this);
40411 0 : }
40412 :
40413 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
40414 0 : void SgBidirectionalGraph::accept (ROSE_VisitorPattern & visitor) {
40415 0 : ROSE_ASSERT(this != NULL);
40416 0 : visitor.visit(this);
40417 0 : }
40418 :
40419 : SgBidirectionalGraph*
40420 0 : SgBidirectionalGraph::addRegExpAttribute(std::string s, AstRegExAttribute* a)
40421 : {
40422 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
40423 : // This function is currently only supported for the AST used the represent Binary executables.
40424 : if (0 /* isSgAsmNode(this) != NULL */)
40425 : {
40426 : // Support for regex specification.
40427 : std::string prefixCode = "REGEX:";
40428 : addNewAttribute(prefixCode + s,a);
40429 : }
40430 : #endif
40431 :
40432 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
40433 0 : return this;
40434 : }
40435 :
40436 : // *** COMMON CODE SECTION ENDS HERE ***
40437 :
40438 :
40439 : // End of memberFunctionString
40440 : // Start of memberFunctionString
40441 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
40442 :
40443 :
40444 : #if 0
40445 : //! Error checking support
40446 : /*! Verifies the following:
40447 : - working getVariant() member function
40448 : - calls base class's error() member function
40449 : Every class has one of these functions.
40450 : */
40451 : bool
40452 : SgBidirectionalGraph::error()
40453 : {
40454 : // Put error checking here
40455 :
40456 : ROSE_ASSERT (this != NULL);
40457 : if (getVariant() != BidirectionalGraphTag)
40458 : {
40459 : printf ("Error in SgBidirectionalGraph::error(): SgBidirectionalGraph object has a %s variant \n",
40460 : Cxx_GrammarTerminalNames[getVariant()].name);
40461 : // printf ("Error in SgBidirectionalGraph::error() \n");
40462 : ROSE_ABORT();
40463 : }
40464 :
40465 : ROSE_ASSERT (getVariant() == BidirectionalGraphTag);
40466 : return SgIncidenceDirectedGraph::error();
40467 : }
40468 : #endif
40469 :
40470 :
40471 :
40472 : // End of memberFunctionString
40473 :
40474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
40475 :
40476 0 : SgBidirectionalGraph* isSgBidirectionalGraph ( SgNode* inputDerivedClassPointer )
40477 : {
40478 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40479 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40480 : // So to fix this we return NULL directly when the input is NULL and avoid the
40481 : // dynamic_cast in this case. This is likely a performance improvement as well.
40482 : // return dynamic_cast<SgBidirectionalGraph*>(inputDerivedClassPointer);
40483 : // Milind Chabbi (8/28/2013): isSgBidirectionalGraph uses table-driven castability instead of c++ default dynamic_cast
40484 : // this improves the running time performance by 10-20%.
40485 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBidirectionalGraph*>(inputDerivedClassPointer);
40486 0 : return IS_SgBidirectionalGraph_FAST_MACRO(inputDerivedClassPointer);
40487 : }
40488 :
40489 : // DQ (11/8/2003): Added version of functions taking const pointer
40490 0 : const SgBidirectionalGraph* isSgBidirectionalGraph ( const SgNode* inputDerivedClassPointer )
40491 : {
40492 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40493 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40494 : // So to fix this we return NULL directly when the input is NULL and avoid the
40495 : // dynamic_cast in this case. This is likely a performance improvement as well.
40496 : // return dynamic_cast<const SgBidirectionalGraph*>(inputDerivedClassPointer);
40497 : // Milind Chabbi (8/28/2013): isSgBidirectionalGraph uses table-driven castability instead of c++ default dynamic_cast
40498 : // this improves the running time performance by 10-20%.
40499 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBidirectionalGraph*>(inputDerivedClassPointer);
40500 0 : return IS_SgBidirectionalGraph_FAST_MACRO(inputDerivedClassPointer);
40501 : }
40502 :
40503 :
40504 :
40505 : /* #line 40506 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40506 :
40507 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
40508 :
40509 : /**
40510 : \brief Generated destructor
40511 :
40512 : This destructor is automatically generated (by ROSETTA). This destructor
40513 : only frees memory of data members associated with the parts of the current IR node which
40514 : are NOT traversed. Those data members that are part of a traversal can be freed using
40515 : a traversal (calling this destructor on all children in a post-order traversal). Such
40516 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
40517 :
40518 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
40519 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
40520 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
40521 :
40522 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
40523 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
40524 : pointers are not yet implemented to call delete on eash pointer in the container.
40525 : (This could be done by derivation from the STL containers to define containers that
40526 : automatically deleted their members.)
40527 :
40528 : */
40529 0 : SgBidirectionalGraph::~SgBidirectionalGraph () {
40530 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
40531 :
40532 :
40533 :
40534 : }
40535 :
40536 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
40537 0 : }
40538 :
40539 :
40540 : /* #line 40541 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40541 :
40542 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
40543 :
40544 : // Generated constructor
40545 0 : SgBidirectionalGraph::SgBidirectionalGraph ( std::string name )
40546 0 : : SgIncidenceDirectedGraph(name)
40547 : {
40548 : #ifdef DEBUG
40549 : // printf ("In SgBidirectionalGraph::SgBidirectionalGraph (std::string name) sage_class_name() = %s \n",sage_class_name());
40550 : #endif
40551 : #if 0
40552 : // debugging information!
40553 : printf ("In SgBidirectionalGraph::SgBidirectionalGraph (std::string name): this = %p = %s \n",this,this->class_name().c_str());
40554 : #endif
40555 :
40556 :
40557 :
40558 : #if 0
40559 : // DQ (7/30/2014): Call a virtual function.
40560 : std::string s = this->class_name();
40561 : #endif
40562 :
40563 : // Test the variant virtual function
40564 : // assert(BidirectionalGraphTag == variant());
40565 0 : assert(BidirectionalGraphTag == this->variant());
40566 0 : ROSE_ASSERT(BidirectionalGraphTag == (int)(this->variantT()));
40567 0 : post_construction_initialization();
40568 :
40569 : // Test the isSgBidirectionalGraph() function since it has been problematic
40570 0 : assert(isSgBidirectionalGraph(this) != NULL);
40571 0 : }
40572 :
40573 : // Generated constructor (all data members)
40574 :
40575 : /* #line 40576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40576 :
40577 :
40578 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
40579 :
40580 :
40581 : // ********************************************************
40582 : // member functions common across all array grammar objects
40583 : // ********************************************************
40584 :
40585 :
40586 :
40587 : /* #line 40588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40588 :
40589 :
40590 :
40591 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
40592 :
40593 : // ********************************************************
40594 : // member functions specific to each node in the grammar
40595 : // ********************************************************
40596 :
40597 :
40598 : /* #line 40599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40599 :
40600 : // Start of memberFunctionString
40601 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
40602 :
40603 : // *** COMMON CODE SECTION BEGINS HERE ***
40604 :
40605 : #if 0
40606 : int
40607 : SgStringKeyedBidirectionalGraph::getVariant() const
40608 : {
40609 : // This function is used in ROSE while "variant()" is used in SAGE
40610 : assert(this != NULL);
40611 : return variant();
40612 : }
40613 : #endif
40614 :
40615 : // This function is used in ROSE in treeTraversal code
40616 : // eventually replaces getVariant() and variant()
40617 : // though after variant() has been removed for a while we will
40618 : // want to change the name of variantT() back to variant()
40619 : // (since the "T" was ment to stand for temporary).
40620 : // When this happens the variantT() will be depricated.
40621 : VariantT
40622 0 : SgStringKeyedBidirectionalGraph::variantT() const
40623 : {
40624 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
40625 0 : ROSE_ASSERT(this != NULL);
40626 0 : return V_SgStringKeyedBidirectionalGraph;
40627 : }
40628 :
40629 : #if 0
40630 : int
40631 : SgStringKeyedBidirectionalGraph::variant() const
40632 : {
40633 : // This function is used in SAGE
40634 : ROSE_ASSERT(this != NULL);
40635 : return StringKeyedBidirectionalGraphTag;
40636 : }
40637 : #endif
40638 :
40639 : ROSE_DLL_API const char*
40640 0 : SgStringKeyedBidirectionalGraph::sage_class_name() const
40641 : {
40642 0 : ROSE_ASSERT(this != NULL);
40643 0 : return "SgStringKeyedBidirectionalGraph";
40644 : }
40645 :
40646 : std::string
40647 0 : SgStringKeyedBidirectionalGraph::class_name() const
40648 : {
40649 0 : ROSE_ASSERT(this != NULL);
40650 0 : return "SgStringKeyedBidirectionalGraph";
40651 : }
40652 :
40653 : // DQ (11/26/2005): Support for visitor pattern mechanims
40654 : // (inferior to ROSE traversal mechanism, experimental).
40655 : void
40656 0 : SgStringKeyedBidirectionalGraph::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
40657 : {
40658 0 : ROSE_ASSERT(this != NULL);
40659 0 : visitor.visit(this);
40660 0 : }
40661 :
40662 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
40663 0 : void SgStringKeyedBidirectionalGraph::accept (ROSE_VisitorPattern & visitor) {
40664 0 : ROSE_ASSERT(this != NULL);
40665 0 : visitor.visit(this);
40666 0 : }
40667 :
40668 : SgStringKeyedBidirectionalGraph*
40669 0 : SgStringKeyedBidirectionalGraph::addRegExpAttribute(std::string s, AstRegExAttribute* a)
40670 : {
40671 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
40672 : // This function is currently only supported for the AST used the represent Binary executables.
40673 : if (0 /* isSgAsmNode(this) != NULL */)
40674 : {
40675 : // Support for regex specification.
40676 : std::string prefixCode = "REGEX:";
40677 : addNewAttribute(prefixCode + s,a);
40678 : }
40679 : #endif
40680 :
40681 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
40682 0 : return this;
40683 : }
40684 :
40685 : // *** COMMON CODE SECTION ENDS HERE ***
40686 :
40687 :
40688 : // End of memberFunctionString
40689 : // Start of memberFunctionString
40690 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
40691 :
40692 :
40693 : #if 0
40694 : //! Error checking support
40695 : /*! Verifies the following:
40696 : - working getVariant() member function
40697 : - calls base class's error() member function
40698 : Every class has one of these functions.
40699 : */
40700 : bool
40701 : SgStringKeyedBidirectionalGraph::error()
40702 : {
40703 : // Put error checking here
40704 :
40705 : ROSE_ASSERT (this != NULL);
40706 : if (getVariant() != StringKeyedBidirectionalGraphTag)
40707 : {
40708 : printf ("Error in SgStringKeyedBidirectionalGraph::error(): SgStringKeyedBidirectionalGraph object has a %s variant \n",
40709 : Cxx_GrammarTerminalNames[getVariant()].name);
40710 : // printf ("Error in SgStringKeyedBidirectionalGraph::error() \n");
40711 : ROSE_ABORT();
40712 : }
40713 :
40714 : ROSE_ASSERT (getVariant() == StringKeyedBidirectionalGraphTag);
40715 : return SgBidirectionalGraph::error();
40716 : }
40717 : #endif
40718 :
40719 :
40720 :
40721 : // End of memberFunctionString
40722 :
40723 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
40724 :
40725 0 : SgStringKeyedBidirectionalGraph* isSgStringKeyedBidirectionalGraph ( SgNode* inputDerivedClassPointer )
40726 : {
40727 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40728 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40729 : // So to fix this we return NULL directly when the input is NULL and avoid the
40730 : // dynamic_cast in this case. This is likely a performance improvement as well.
40731 : // return dynamic_cast<SgStringKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40732 : // Milind Chabbi (8/28/2013): isSgStringKeyedBidirectionalGraph uses table-driven castability instead of c++ default dynamic_cast
40733 : // this improves the running time performance by 10-20%.
40734 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStringKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40735 0 : return IS_SgStringKeyedBidirectionalGraph_FAST_MACRO(inputDerivedClassPointer);
40736 : }
40737 :
40738 : // DQ (11/8/2003): Added version of functions taking const pointer
40739 0 : const SgStringKeyedBidirectionalGraph* isSgStringKeyedBidirectionalGraph ( const SgNode* inputDerivedClassPointer )
40740 : {
40741 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40742 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40743 : // So to fix this we return NULL directly when the input is NULL and avoid the
40744 : // dynamic_cast in this case. This is likely a performance improvement as well.
40745 : // return dynamic_cast<const SgStringKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40746 : // Milind Chabbi (8/28/2013): isSgStringKeyedBidirectionalGraph uses table-driven castability instead of c++ default dynamic_cast
40747 : // this improves the running time performance by 10-20%.
40748 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStringKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40749 0 : return IS_SgStringKeyedBidirectionalGraph_FAST_MACRO(inputDerivedClassPointer);
40750 : }
40751 :
40752 :
40753 :
40754 : /* #line 40755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40755 :
40756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
40757 :
40758 : /**
40759 : \brief Generated destructor
40760 :
40761 : This destructor is automatically generated (by ROSETTA). This destructor
40762 : only frees memory of data members associated with the parts of the current IR node which
40763 : are NOT traversed. Those data members that are part of a traversal can be freed using
40764 : a traversal (calling this destructor on all children in a post-order traversal). Such
40765 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
40766 :
40767 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
40768 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
40769 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
40770 :
40771 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
40772 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
40773 : pointers are not yet implemented to call delete on eash pointer in the container.
40774 : (This could be done by derivation from the STL containers to define containers that
40775 : automatically deleted their members.)
40776 :
40777 : */
40778 0 : SgStringKeyedBidirectionalGraph::~SgStringKeyedBidirectionalGraph () {
40779 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
40780 :
40781 :
40782 :
40783 : }
40784 :
40785 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
40786 0 : }
40787 :
40788 :
40789 : /* #line 40790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40790 :
40791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
40792 :
40793 : // Generated constructor
40794 0 : SgStringKeyedBidirectionalGraph::SgStringKeyedBidirectionalGraph ( std::string name )
40795 0 : : SgBidirectionalGraph(name)
40796 : {
40797 : #ifdef DEBUG
40798 : // printf ("In SgStringKeyedBidirectionalGraph::SgStringKeyedBidirectionalGraph (std::string name) sage_class_name() = %s \n",sage_class_name());
40799 : #endif
40800 : #if 0
40801 : // debugging information!
40802 : printf ("In SgStringKeyedBidirectionalGraph::SgStringKeyedBidirectionalGraph (std::string name): this = %p = %s \n",this,this->class_name().c_str());
40803 : #endif
40804 :
40805 :
40806 :
40807 : #if 0
40808 : // DQ (7/30/2014): Call a virtual function.
40809 : std::string s = this->class_name();
40810 : #endif
40811 :
40812 : // Test the variant virtual function
40813 : // assert(StringKeyedBidirectionalGraphTag == variant());
40814 0 : assert(StringKeyedBidirectionalGraphTag == this->variant());
40815 0 : ROSE_ASSERT(StringKeyedBidirectionalGraphTag == (int)(this->variantT()));
40816 0 : post_construction_initialization();
40817 :
40818 : // Test the isSgStringKeyedBidirectionalGraph() function since it has been problematic
40819 0 : assert(isSgStringKeyedBidirectionalGraph(this) != NULL);
40820 0 : }
40821 :
40822 : // Generated constructor (all data members)
40823 :
40824 : /* #line 40825 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40825 :
40826 :
40827 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
40828 :
40829 :
40830 : // ********************************************************
40831 : // member functions common across all array grammar objects
40832 : // ********************************************************
40833 :
40834 :
40835 :
40836 : /* #line 40837 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40837 :
40838 :
40839 :
40840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
40841 :
40842 : // ********************************************************
40843 : // member functions specific to each node in the grammar
40844 : // ********************************************************
40845 :
40846 :
40847 : /* #line 40848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
40848 :
40849 : // Start of memberFunctionString
40850 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
40851 :
40852 : // *** COMMON CODE SECTION BEGINS HERE ***
40853 :
40854 : #if 0
40855 : int
40856 : SgIntKeyedBidirectionalGraph::getVariant() const
40857 : {
40858 : // This function is used in ROSE while "variant()" is used in SAGE
40859 : assert(this != NULL);
40860 : return variant();
40861 : }
40862 : #endif
40863 :
40864 : // This function is used in ROSE in treeTraversal code
40865 : // eventually replaces getVariant() and variant()
40866 : // though after variant() has been removed for a while we will
40867 : // want to change the name of variantT() back to variant()
40868 : // (since the "T" was ment to stand for temporary).
40869 : // When this happens the variantT() will be depricated.
40870 : VariantT
40871 0 : SgIntKeyedBidirectionalGraph::variantT() const
40872 : {
40873 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
40874 0 : ROSE_ASSERT(this != NULL);
40875 0 : return V_SgIntKeyedBidirectionalGraph;
40876 : }
40877 :
40878 : #if 0
40879 : int
40880 : SgIntKeyedBidirectionalGraph::variant() const
40881 : {
40882 : // This function is used in SAGE
40883 : ROSE_ASSERT(this != NULL);
40884 : return IntKeyedBidirectionalGraphTag;
40885 : }
40886 : #endif
40887 :
40888 : ROSE_DLL_API const char*
40889 0 : SgIntKeyedBidirectionalGraph::sage_class_name() const
40890 : {
40891 0 : ROSE_ASSERT(this != NULL);
40892 0 : return "SgIntKeyedBidirectionalGraph";
40893 : }
40894 :
40895 : std::string
40896 0 : SgIntKeyedBidirectionalGraph::class_name() const
40897 : {
40898 0 : ROSE_ASSERT(this != NULL);
40899 0 : return "SgIntKeyedBidirectionalGraph";
40900 : }
40901 :
40902 : // DQ (11/26/2005): Support for visitor pattern mechanims
40903 : // (inferior to ROSE traversal mechanism, experimental).
40904 : void
40905 0 : SgIntKeyedBidirectionalGraph::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
40906 : {
40907 0 : ROSE_ASSERT(this != NULL);
40908 0 : visitor.visit(this);
40909 0 : }
40910 :
40911 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
40912 0 : void SgIntKeyedBidirectionalGraph::accept (ROSE_VisitorPattern & visitor) {
40913 0 : ROSE_ASSERT(this != NULL);
40914 0 : visitor.visit(this);
40915 0 : }
40916 :
40917 : SgIntKeyedBidirectionalGraph*
40918 0 : SgIntKeyedBidirectionalGraph::addRegExpAttribute(std::string s, AstRegExAttribute* a)
40919 : {
40920 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
40921 : // This function is currently only supported for the AST used the represent Binary executables.
40922 : if (0 /* isSgAsmNode(this) != NULL */)
40923 : {
40924 : // Support for regex specification.
40925 : std::string prefixCode = "REGEX:";
40926 : addNewAttribute(prefixCode + s,a);
40927 : }
40928 : #endif
40929 :
40930 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
40931 0 : return this;
40932 : }
40933 :
40934 : // *** COMMON CODE SECTION ENDS HERE ***
40935 :
40936 :
40937 : // End of memberFunctionString
40938 : // Start of memberFunctionString
40939 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
40940 :
40941 :
40942 : #if 0
40943 : //! Error checking support
40944 : /*! Verifies the following:
40945 : - working getVariant() member function
40946 : - calls base class's error() member function
40947 : Every class has one of these functions.
40948 : */
40949 : bool
40950 : SgIntKeyedBidirectionalGraph::error()
40951 : {
40952 : // Put error checking here
40953 :
40954 : ROSE_ASSERT (this != NULL);
40955 : if (getVariant() != IntKeyedBidirectionalGraphTag)
40956 : {
40957 : printf ("Error in SgIntKeyedBidirectionalGraph::error(): SgIntKeyedBidirectionalGraph object has a %s variant \n",
40958 : Cxx_GrammarTerminalNames[getVariant()].name);
40959 : // printf ("Error in SgIntKeyedBidirectionalGraph::error() \n");
40960 : ROSE_ABORT();
40961 : }
40962 :
40963 : ROSE_ASSERT (getVariant() == IntKeyedBidirectionalGraphTag);
40964 : return SgBidirectionalGraph::error();
40965 : }
40966 : #endif
40967 :
40968 :
40969 :
40970 : // End of memberFunctionString
40971 :
40972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
40973 :
40974 0 : SgIntKeyedBidirectionalGraph* isSgIntKeyedBidirectionalGraph ( SgNode* inputDerivedClassPointer )
40975 : {
40976 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40977 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40978 : // So to fix this we return NULL directly when the input is NULL and avoid the
40979 : // dynamic_cast in this case. This is likely a performance improvement as well.
40980 : // return dynamic_cast<SgIntKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40981 : // Milind Chabbi (8/28/2013): isSgIntKeyedBidirectionalGraph uses table-driven castability instead of c++ default dynamic_cast
40982 : // this improves the running time performance by 10-20%.
40983 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIntKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40984 0 : return IS_SgIntKeyedBidirectionalGraph_FAST_MACRO(inputDerivedClassPointer);
40985 : }
40986 :
40987 : // DQ (11/8/2003): Added version of functions taking const pointer
40988 0 : const SgIntKeyedBidirectionalGraph* isSgIntKeyedBidirectionalGraph ( const SgNode* inputDerivedClassPointer )
40989 : {
40990 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
40991 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
40992 : // So to fix this we return NULL directly when the input is NULL and avoid the
40993 : // dynamic_cast in this case. This is likely a performance improvement as well.
40994 : // return dynamic_cast<const SgIntKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40995 : // Milind Chabbi (8/28/2013): isSgIntKeyedBidirectionalGraph uses table-driven castability instead of c++ default dynamic_cast
40996 : // this improves the running time performance by 10-20%.
40997 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIntKeyedBidirectionalGraph*>(inputDerivedClassPointer);
40998 0 : return IS_SgIntKeyedBidirectionalGraph_FAST_MACRO(inputDerivedClassPointer);
40999 : }
41000 :
41001 :
41002 :
41003 : /* #line 41004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41004 :
41005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
41006 :
41007 : /**
41008 : \brief Generated destructor
41009 :
41010 : This destructor is automatically generated (by ROSETTA). This destructor
41011 : only frees memory of data members associated with the parts of the current IR node which
41012 : are NOT traversed. Those data members that are part of a traversal can be freed using
41013 : a traversal (calling this destructor on all children in a post-order traversal). Such
41014 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
41015 :
41016 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
41017 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
41018 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
41019 :
41020 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
41021 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
41022 : pointers are not yet implemented to call delete on eash pointer in the container.
41023 : (This could be done by derivation from the STL containers to define containers that
41024 : automatically deleted their members.)
41025 :
41026 : */
41027 0 : SgIntKeyedBidirectionalGraph::~SgIntKeyedBidirectionalGraph () {
41028 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
41029 :
41030 :
41031 :
41032 : }
41033 :
41034 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
41035 0 : }
41036 :
41037 :
41038 : /* #line 41039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41039 :
41040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
41041 :
41042 : // Generated constructor
41043 0 : SgIntKeyedBidirectionalGraph::SgIntKeyedBidirectionalGraph ( std::string name )
41044 0 : : SgBidirectionalGraph(name)
41045 : {
41046 : #ifdef DEBUG
41047 : // printf ("In SgIntKeyedBidirectionalGraph::SgIntKeyedBidirectionalGraph (std::string name) sage_class_name() = %s \n",sage_class_name());
41048 : #endif
41049 : #if 0
41050 : // debugging information!
41051 : printf ("In SgIntKeyedBidirectionalGraph::SgIntKeyedBidirectionalGraph (std::string name): this = %p = %s \n",this,this->class_name().c_str());
41052 : #endif
41053 :
41054 :
41055 :
41056 : #if 0
41057 : // DQ (7/30/2014): Call a virtual function.
41058 : std::string s = this->class_name();
41059 : #endif
41060 :
41061 : // Test the variant virtual function
41062 : // assert(IntKeyedBidirectionalGraphTag == variant());
41063 0 : assert(IntKeyedBidirectionalGraphTag == this->variant());
41064 0 : ROSE_ASSERT(IntKeyedBidirectionalGraphTag == (int)(this->variantT()));
41065 0 : post_construction_initialization();
41066 :
41067 : // Test the isSgIntKeyedBidirectionalGraph() function since it has been problematic
41068 0 : assert(isSgIntKeyedBidirectionalGraph(this) != NULL);
41069 0 : }
41070 :
41071 : // Generated constructor (all data members)
41072 :
41073 : /* #line 41074 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41074 :
41075 :
41076 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
41077 :
41078 :
41079 : // ********************************************************
41080 : // member functions common across all array grammar objects
41081 : // ********************************************************
41082 :
41083 :
41084 :
41085 : /* #line 41086 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41086 :
41087 :
41088 :
41089 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
41090 :
41091 : // ********************************************************
41092 : // member functions specific to each node in the grammar
41093 : // ********************************************************
41094 :
41095 :
41096 : /* #line 41097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41097 :
41098 : // Start of memberFunctionString
41099 : /* #line 22421 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
41100 :
41101 :
41102 :
41103 : // End of memberFunctionString
41104 : // Start of memberFunctionString
41105 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
41106 :
41107 : // *** COMMON CODE SECTION BEGINS HERE ***
41108 :
41109 : #if 0
41110 : int
41111 : SgIncidenceUndirectedGraph::getVariant() const
41112 : {
41113 : // This function is used in ROSE while "variant()" is used in SAGE
41114 : assert(this != NULL);
41115 : return variant();
41116 : }
41117 : #endif
41118 :
41119 : // This function is used in ROSE in treeTraversal code
41120 : // eventually replaces getVariant() and variant()
41121 : // though after variant() has been removed for a while we will
41122 : // want to change the name of variantT() back to variant()
41123 : // (since the "T" was ment to stand for temporary).
41124 : // When this happens the variantT() will be depricated.
41125 : VariantT
41126 0 : SgIncidenceUndirectedGraph::variantT() const
41127 : {
41128 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
41129 0 : ROSE_ASSERT(this != NULL);
41130 0 : return V_SgIncidenceUndirectedGraph;
41131 : }
41132 :
41133 : #if 0
41134 : int
41135 : SgIncidenceUndirectedGraph::variant() const
41136 : {
41137 : // This function is used in SAGE
41138 : ROSE_ASSERT(this != NULL);
41139 : return IncidenceUndirectedGraphTag;
41140 : }
41141 : #endif
41142 :
41143 : ROSE_DLL_API const char*
41144 0 : SgIncidenceUndirectedGraph::sage_class_name() const
41145 : {
41146 0 : ROSE_ASSERT(this != NULL);
41147 0 : return "SgIncidenceUndirectedGraph";
41148 : }
41149 :
41150 : std::string
41151 0 : SgIncidenceUndirectedGraph::class_name() const
41152 : {
41153 0 : ROSE_ASSERT(this != NULL);
41154 0 : return "SgIncidenceUndirectedGraph";
41155 : }
41156 :
41157 : // DQ (11/26/2005): Support for visitor pattern mechanims
41158 : // (inferior to ROSE traversal mechanism, experimental).
41159 : void
41160 0 : SgIncidenceUndirectedGraph::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
41161 : {
41162 0 : ROSE_ASSERT(this != NULL);
41163 0 : visitor.visit(this);
41164 0 : }
41165 :
41166 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
41167 0 : void SgIncidenceUndirectedGraph::accept (ROSE_VisitorPattern & visitor) {
41168 0 : ROSE_ASSERT(this != NULL);
41169 0 : visitor.visit(this);
41170 0 : }
41171 :
41172 : SgIncidenceUndirectedGraph*
41173 0 : SgIncidenceUndirectedGraph::addRegExpAttribute(std::string s, AstRegExAttribute* a)
41174 : {
41175 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
41176 : // This function is currently only supported for the AST used the represent Binary executables.
41177 : if (0 /* isSgAsmNode(this) != NULL */)
41178 : {
41179 : // Support for regex specification.
41180 : std::string prefixCode = "REGEX:";
41181 : addNewAttribute(prefixCode + s,a);
41182 : }
41183 : #endif
41184 :
41185 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
41186 0 : return this;
41187 : }
41188 :
41189 : // *** COMMON CODE SECTION ENDS HERE ***
41190 :
41191 :
41192 : // End of memberFunctionString
41193 : // Start of memberFunctionString
41194 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
41195 :
41196 :
41197 : #if 0
41198 : //! Error checking support
41199 : /*! Verifies the following:
41200 : - working getVariant() member function
41201 : - calls base class's error() member function
41202 : Every class has one of these functions.
41203 : */
41204 : bool
41205 : SgIncidenceUndirectedGraph::error()
41206 : {
41207 : // Put error checking here
41208 :
41209 : ROSE_ASSERT (this != NULL);
41210 : if (getVariant() != IncidenceUndirectedGraphTag)
41211 : {
41212 : printf ("Error in SgIncidenceUndirectedGraph::error(): SgIncidenceUndirectedGraph object has a %s variant \n",
41213 : Cxx_GrammarTerminalNames[getVariant()].name);
41214 : // printf ("Error in SgIncidenceUndirectedGraph::error() \n");
41215 : ROSE_ABORT();
41216 : }
41217 :
41218 : ROSE_ASSERT (getVariant() == IncidenceUndirectedGraphTag);
41219 : return SgGraph::error();
41220 : }
41221 : #endif
41222 :
41223 :
41224 :
41225 : // End of memberFunctionString
41226 :
41227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
41228 :
41229 0 : SgIncidenceUndirectedGraph* isSgIncidenceUndirectedGraph ( SgNode* inputDerivedClassPointer )
41230 : {
41231 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
41232 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
41233 : // So to fix this we return NULL directly when the input is NULL and avoid the
41234 : // dynamic_cast in this case. This is likely a performance improvement as well.
41235 : // return dynamic_cast<SgIncidenceUndirectedGraph*>(inputDerivedClassPointer);
41236 : // Milind Chabbi (8/28/2013): isSgIncidenceUndirectedGraph uses table-driven castability instead of c++ default dynamic_cast
41237 : // this improves the running time performance by 10-20%.
41238 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIncidenceUndirectedGraph*>(inputDerivedClassPointer);
41239 0 : return IS_SgIncidenceUndirectedGraph_FAST_MACRO(inputDerivedClassPointer);
41240 : }
41241 :
41242 : // DQ (11/8/2003): Added version of functions taking const pointer
41243 0 : const SgIncidenceUndirectedGraph* isSgIncidenceUndirectedGraph ( const SgNode* inputDerivedClassPointer )
41244 : {
41245 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
41246 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
41247 : // So to fix this we return NULL directly when the input is NULL and avoid the
41248 : // dynamic_cast in this case. This is likely a performance improvement as well.
41249 : // return dynamic_cast<const SgIncidenceUndirectedGraph*>(inputDerivedClassPointer);
41250 : // Milind Chabbi (8/28/2013): isSgIncidenceUndirectedGraph uses table-driven castability instead of c++ default dynamic_cast
41251 : // this improves the running time performance by 10-20%.
41252 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIncidenceUndirectedGraph*>(inputDerivedClassPointer);
41253 0 : return IS_SgIncidenceUndirectedGraph_FAST_MACRO(inputDerivedClassPointer);
41254 : }
41255 :
41256 :
41257 :
41258 : /* #line 41259 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41259 :
41260 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
41261 :
41262 : /**
41263 : \brief Generated destructor
41264 :
41265 : This destructor is automatically generated (by ROSETTA). This destructor
41266 : only frees memory of data members associated with the parts of the current IR node which
41267 : are NOT traversed. Those data members that are part of a traversal can be freed using
41268 : a traversal (calling this destructor on all children in a post-order traversal). Such
41269 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
41270 :
41271 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
41272 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
41273 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
41274 :
41275 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
41276 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
41277 : pointers are not yet implemented to call delete on eash pointer in the container.
41278 : (This could be done by derivation from the STL containers to define containers that
41279 : automatically deleted their members.)
41280 :
41281 : */
41282 0 : SgIncidenceUndirectedGraph::~SgIncidenceUndirectedGraph () {
41283 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
41284 :
41285 :
41286 :
41287 : }
41288 :
41289 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
41290 0 : }
41291 :
41292 :
41293 : /* #line 41294 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41294 :
41295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
41296 :
41297 : // Generated constructor
41298 0 : SgIncidenceUndirectedGraph::SgIncidenceUndirectedGraph ( std::string name )
41299 0 : : SgGraph(name)
41300 : {
41301 : #ifdef DEBUG
41302 : // printf ("In SgIncidenceUndirectedGraph::SgIncidenceUndirectedGraph (std::string name) sage_class_name() = %s \n",sage_class_name());
41303 : #endif
41304 : #if 0
41305 : // debugging information!
41306 : printf ("In SgIncidenceUndirectedGraph::SgIncidenceUndirectedGraph (std::string name): this = %p = %s \n",this,this->class_name().c_str());
41307 : #endif
41308 :
41309 :
41310 :
41311 : #if 0
41312 : // DQ (7/30/2014): Call a virtual function.
41313 : std::string s = this->class_name();
41314 : #endif
41315 :
41316 : // Test the variant virtual function
41317 : // assert(IncidenceUndirectedGraphTag == variant());
41318 0 : assert(IncidenceUndirectedGraphTag == this->variant());
41319 0 : ROSE_ASSERT(IncidenceUndirectedGraphTag == (int)(this->variantT()));
41320 0 : post_construction_initialization();
41321 :
41322 : // Test the isSgIncidenceUndirectedGraph() function since it has been problematic
41323 0 : assert(isSgIncidenceUndirectedGraph(this) != NULL);
41324 0 : }
41325 :
41326 : // Generated constructor (all data members)
41327 :
41328 : /* #line 41329 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41329 :
41330 :
41331 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
41332 :
41333 :
41334 : // ********************************************************
41335 : // member functions common across all array grammar objects
41336 : // ********************************************************
41337 :
41338 :
41339 :
41340 : /* #line 41341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41341 :
41342 :
41343 :
41344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
41345 :
41346 : // ********************************************************
41347 : // member functions specific to each node in the grammar
41348 : // ********************************************************
41349 :
41350 :
41351 : /* #line 41352 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41352 :
41353 : // Start of memberFunctionString
41354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
41355 :
41356 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41357 :
41358 : std::string
41359 0 : SgGraphNode::get_name () const
41360 : {
41361 0 : ROSE_ASSERT (this != NULL);
41362 :
41363 : #if 0
41364 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41365 : // used to trigger marking transformations for the token-based unparsing.
41366 : printf ("SgGraphNode::get_name = %p = %s \n",this,this->class_name().c_str());
41367 : #endif
41368 :
41369 0 : return p_name;
41370 : }
41371 :
41372 : void
41373 0 : SgGraphNode::set_name ( std::string name )
41374 : {
41375 0 : ROSE_ASSERT (this != NULL);
41376 :
41377 : #if 0
41378 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41379 : // used to trigger marking transformations for the token-based unparsing.
41380 : printf ("SgGraphNode::set_name = %p = %s \n",this,this->class_name().c_str());
41381 : #endif
41382 :
41383 0 : set_isModified(true);
41384 :
41385 0 : p_name = name;
41386 0 : }
41387 :
41388 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
41389 :
41390 :
41391 : // End of memberFunctionString
41392 : // Start of memberFunctionString
41393 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
41394 :
41395 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41396 :
41397 : SgNode*
41398 0 : SgGraphNode::get_SgNode () const
41399 : {
41400 0 : ROSE_ASSERT (this != NULL);
41401 :
41402 : #if 0
41403 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41404 : // used to trigger marking transformations for the token-based unparsing.
41405 : printf ("SgGraphNode::get_SgNode = %p = %s \n",this,this->class_name().c_str());
41406 : #endif
41407 :
41408 0 : return p_SgNode;
41409 : }
41410 :
41411 : void
41412 0 : SgGraphNode::set_SgNode ( SgNode* SgNode )
41413 : {
41414 0 : ROSE_ASSERT (this != NULL);
41415 :
41416 : #if 0
41417 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41418 : // used to trigger marking transformations for the token-based unparsing.
41419 : printf ("SgGraphNode::set_SgNode = %p = %s \n",this,this->class_name().c_str());
41420 : #endif
41421 :
41422 0 : set_isModified(true);
41423 :
41424 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
41425 : if (p_SgNode != NULL && SgNode != NULL && p_SgNode != SgNode)
41426 : {
41427 : printf ("Warning: SgNode = %p overwriting valid pointer p_SgNode = %p \n",SgNode,p_SgNode);
41428 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
41429 : printf ("Error fails assertion (p_SgNode != NULL && SgNode != NULL && p_SgNode != SgNode) is false\n");
41430 : ROSE_ASSERT(false);
41431 : #endif
41432 : }
41433 : #endif
41434 0 : p_SgNode = SgNode;
41435 0 : }
41436 :
41437 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
41438 :
41439 :
41440 : // End of memberFunctionString
41441 : // Start of memberFunctionString
41442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
41443 :
41444 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41445 :
41446 : int
41447 0 : SgGraphNode::get_index () const
41448 : {
41449 0 : ROSE_ASSERT (this != NULL);
41450 :
41451 : #if 0
41452 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41453 : // used to trigger marking transformations for the token-based unparsing.
41454 : printf ("SgGraphNode::get_index = %p = %s \n",this,this->class_name().c_str());
41455 : #endif
41456 :
41457 0 : return p_index;
41458 : }
41459 :
41460 : void
41461 0 : SgGraphNode::set_index ( int index )
41462 : {
41463 0 : ROSE_ASSERT (this != NULL);
41464 :
41465 : #if 0
41466 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41467 : // used to trigger marking transformations for the token-based unparsing.
41468 : printf ("SgGraphNode::set_index = %p = %s \n",this,this->class_name().c_str());
41469 : #endif
41470 :
41471 0 : set_isModified(true);
41472 :
41473 0 : p_index = index;
41474 0 : }
41475 :
41476 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
41477 :
41478 :
41479 : // End of memberFunctionString
41480 : // Start of memberFunctionString
41481 :
41482 :
41483 : // End of memberFunctionString
41484 : // Start of memberFunctionString
41485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
41486 :
41487 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41488 :
41489 : AstAttributeMechanism*
41490 0 : SgGraphNode::get_attributeMechanism () const
41491 : {
41492 0 : ROSE_ASSERT (this != NULL);
41493 0 : return p_attributeMechanism;
41494 : }
41495 :
41496 : void
41497 0 : SgGraphNode::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
41498 : {
41499 0 : ROSE_ASSERT (this != NULL);
41500 :
41501 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
41502 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
41503 : {
41504 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
41505 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
41506 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
41507 : ROSE_ASSERT(false);
41508 : #endif
41509 : }
41510 : #endif
41511 0 : p_attributeMechanism = attributeMechanism;
41512 0 : }
41513 :
41514 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
41515 :
41516 :
41517 : // End of memberFunctionString
41518 : // Start of memberFunctionString
41519 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
41520 :
41521 :
41522 : #if 0
41523 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
41524 : // a pointer and the interface represented directly at the SgNode
41525 : AstAttributeMechanism &
41526 : SgGraphNode::attribute()
41527 : {
41528 : // DQ (1/2/2006): This function preserves as much of
41529 : // the syntax of attribute being a public data member.
41530 : if (p_attribute == NULL)
41531 : {
41532 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
41533 : assert(false);
41534 : }
41535 :
41536 : return *p_attribute;
41537 : }
41538 : #endif
41539 :
41540 : void
41541 0 : SgGraphNode::addNewAttribute( std::string s, AstAttribute* a )
41542 : {
41543 0 : if (get_attributeMechanism() == NULL)
41544 : {
41545 0 : set_attributeMechanism( new AstAttributeMechanism() );
41546 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
41547 : }
41548 0 : get_attributeMechanism()->add(s,a);
41549 0 : }
41550 :
41551 : void
41552 0 : SgGraphNode::setAttribute( std::string s, AstAttribute* a )
41553 : {
41554 0 : if (get_attributeMechanism() == NULL)
41555 : {
41556 0 : set_attributeMechanism( new AstAttributeMechanism() );
41557 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
41558 : }
41559 0 : get_attributeMechanism()->set(s,a);
41560 0 : }
41561 :
41562 : AstAttribute*
41563 0 : SgGraphNode::getAttribute(std::string s) const
41564 : {
41565 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
41566 0 : if (attributeExists(s)==false) return NULL;
41567 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
41568 0 : ROSE_ASSERT(returnValue != NULL);
41569 0 : return returnValue;
41570 : }
41571 :
41572 : void
41573 0 : SgGraphNode::updateAttribute( std::string s, AstAttribute* a )
41574 : {
41575 : // formerly called: replace
41576 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
41577 0 : get_attributeMechanism()->replace(s,a);
41578 0 : }
41579 :
41580 : void
41581 0 : SgGraphNode::removeAttribute(std::string s)
41582 : {
41583 0 : if (get_attributeMechanism())
41584 0 : get_attributeMechanism()->remove(s);
41585 :
41586 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
41587 0 : int remainingCount = numberOfAttributes();
41588 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
41589 0 : if (remainingCount == 0)
41590 : {
41591 0 : delete get_attributeMechanism();
41592 0 : set_attributeMechanism(NULL);
41593 : }
41594 0 : }
41595 :
41596 : bool
41597 0 : SgGraphNode::attributeExists(std::string s) const
41598 : {
41599 0 : bool returnValue = false;
41600 0 : if (get_attributeMechanism() != NULL)
41601 0 : returnValue = get_attributeMechanism()->exists(s);
41602 0 : return returnValue;
41603 : }
41604 :
41605 : int
41606 0 : SgGraphNode::numberOfAttributes() const
41607 : {
41608 0 : int returnValue = 0;
41609 0 : if (get_attributeMechanism() != NULL)
41610 0 : returnValue = get_attributeMechanism()->size();
41611 0 : return returnValue;
41612 : }
41613 :
41614 :
41615 :
41616 : // End of memberFunctionString
41617 : // Start of memberFunctionString
41618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
41619 :
41620 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41621 :
41622 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
41623 : const std::map<int, std::string> &
41624 0 : SgGraphNode::get_properties () const
41625 : {
41626 0 : assert (this != NULL);
41627 0 : return p_properties;
41628 : }
41629 :
41630 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
41631 : std::map<int, std::string> &
41632 0 : SgGraphNode::get_properties ()
41633 : {
41634 0 : assert (this != NULL);
41635 :
41636 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
41637 : // As a rule only set_ access functions can set the isModified flag.
41638 : // set_isModified(true);
41639 :
41640 0 : return p_properties;
41641 : }
41642 :
41643 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
41644 :
41645 :
41646 : // End of memberFunctionString
41647 : // Start of memberFunctionString
41648 : /* #line 22187 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
41649 :
41650 :
41651 :
41652 : // DQ (4/29/2009): Declaration of space for static data member.
41653 : int SgGraphNode::p_index_counter = 0;
41654 :
41655 :
41656 : // tps : todo : remove this soon
41657 : void
41658 0 : SgGraphNode::append_properties( int addr, const std::string & prop )
41659 : {
41660 0 : assert(this != NULL);
41661 : /* implemented directly until we can fix how the statementList is built */
41662 0 : p_properties[addr] = prop;
41663 0 : }
41664 :
41665 :
41666 : void
41667 0 : SgGraphNode::post_construction_initialization()
41668 : {
41669 :
41670 : // DQ (4/29/2009): This function could be inlined for better performance.
41671 0 : p_index = p_index_counter++;
41672 :
41673 : // mprintf ("In SgGraphNode::post_construction_initialization(): p_index = %u p_index_counter = %u \n",p_index,p_index_counter);
41674 :
41675 0 : }
41676 :
41677 :
41678 :
41679 : // End of memberFunctionString
41680 : // Start of memberFunctionString
41681 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
41682 :
41683 : // *** COMMON CODE SECTION BEGINS HERE ***
41684 :
41685 : #if 0
41686 : int
41687 : SgGraphNode::getVariant() const
41688 : {
41689 : // This function is used in ROSE while "variant()" is used in SAGE
41690 : assert(this != NULL);
41691 : return variant();
41692 : }
41693 : #endif
41694 :
41695 : // This function is used in ROSE in treeTraversal code
41696 : // eventually replaces getVariant() and variant()
41697 : // though after variant() has been removed for a while we will
41698 : // want to change the name of variantT() back to variant()
41699 : // (since the "T" was ment to stand for temporary).
41700 : // When this happens the variantT() will be depricated.
41701 : VariantT
41702 0 : SgGraphNode::variantT() const
41703 : {
41704 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
41705 0 : ROSE_ASSERT(this != NULL);
41706 0 : return V_SgGraphNode;
41707 : }
41708 :
41709 : #if 0
41710 : int
41711 : SgGraphNode::variant() const
41712 : {
41713 : // This function is used in SAGE
41714 : ROSE_ASSERT(this != NULL);
41715 : return GraphNodeTag;
41716 : }
41717 : #endif
41718 :
41719 : ROSE_DLL_API const char*
41720 0 : SgGraphNode::sage_class_name() const
41721 : {
41722 0 : ROSE_ASSERT(this != NULL);
41723 0 : return "SgGraphNode";
41724 : }
41725 :
41726 : std::string
41727 0 : SgGraphNode::class_name() const
41728 : {
41729 0 : ROSE_ASSERT(this != NULL);
41730 0 : return "SgGraphNode";
41731 : }
41732 :
41733 : // DQ (11/26/2005): Support for visitor pattern mechanims
41734 : // (inferior to ROSE traversal mechanism, experimental).
41735 : void
41736 0 : SgGraphNode::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
41737 : {
41738 0 : ROSE_ASSERT(this != NULL);
41739 0 : visitor.visit(this);
41740 0 : }
41741 :
41742 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
41743 0 : void SgGraphNode::accept (ROSE_VisitorPattern & visitor) {
41744 0 : ROSE_ASSERT(this != NULL);
41745 0 : visitor.visit(this);
41746 0 : }
41747 :
41748 : SgGraphNode*
41749 0 : SgGraphNode::addRegExpAttribute(std::string s, AstRegExAttribute* a)
41750 : {
41751 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
41752 : // This function is currently only supported for the AST used the represent Binary executables.
41753 : if (0 /* isSgAsmNode(this) != NULL */)
41754 : {
41755 : // Support for regex specification.
41756 : std::string prefixCode = "REGEX:";
41757 : addNewAttribute(prefixCode + s,a);
41758 : }
41759 : #endif
41760 :
41761 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
41762 0 : return this;
41763 : }
41764 :
41765 : // *** COMMON CODE SECTION ENDS HERE ***
41766 :
41767 :
41768 : // End of memberFunctionString
41769 : // Start of memberFunctionString
41770 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
41771 :
41772 :
41773 : #if 0
41774 : //! Error checking support
41775 : /*! Verifies the following:
41776 : - working getVariant() member function
41777 : - calls base class's error() member function
41778 : Every class has one of these functions.
41779 : */
41780 : bool
41781 : SgGraphNode::error()
41782 : {
41783 : // Put error checking here
41784 :
41785 : ROSE_ASSERT (this != NULL);
41786 : if (getVariant() != GraphNodeTag)
41787 : {
41788 : printf ("Error in SgGraphNode::error(): SgGraphNode object has a %s variant \n",
41789 : Cxx_GrammarTerminalNames[getVariant()].name);
41790 : // printf ("Error in SgGraphNode::error() \n");
41791 : ROSE_ABORT();
41792 : }
41793 :
41794 : ROSE_ASSERT (getVariant() == GraphNodeTag);
41795 : return SgSupport::error();
41796 : }
41797 : #endif
41798 :
41799 :
41800 :
41801 : // End of memberFunctionString
41802 :
41803 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
41804 :
41805 0 : SgGraphNode* isSgGraphNode ( SgNode* inputDerivedClassPointer )
41806 : {
41807 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
41808 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
41809 : // So to fix this we return NULL directly when the input is NULL and avoid the
41810 : // dynamic_cast in this case. This is likely a performance improvement as well.
41811 : // return dynamic_cast<SgGraphNode*>(inputDerivedClassPointer);
41812 : // Milind Chabbi (8/28/2013): isSgGraphNode uses table-driven castability instead of c++ default dynamic_cast
41813 : // this improves the running time performance by 10-20%.
41814 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGraphNode*>(inputDerivedClassPointer);
41815 0 : return IS_SgGraphNode_FAST_MACRO(inputDerivedClassPointer);
41816 : }
41817 :
41818 : // DQ (11/8/2003): Added version of functions taking const pointer
41819 0 : const SgGraphNode* isSgGraphNode ( const SgNode* inputDerivedClassPointer )
41820 : {
41821 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
41822 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
41823 : // So to fix this we return NULL directly when the input is NULL and avoid the
41824 : // dynamic_cast in this case. This is likely a performance improvement as well.
41825 : // return dynamic_cast<const SgGraphNode*>(inputDerivedClassPointer);
41826 : // Milind Chabbi (8/28/2013): isSgGraphNode uses table-driven castability instead of c++ default dynamic_cast
41827 : // this improves the running time performance by 10-20%.
41828 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGraphNode*>(inputDerivedClassPointer);
41829 0 : return IS_SgGraphNode_FAST_MACRO(inputDerivedClassPointer);
41830 : }
41831 :
41832 :
41833 :
41834 : /* #line 41835 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41835 :
41836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
41837 :
41838 : /**
41839 : \brief Generated destructor
41840 :
41841 : This destructor is automatically generated (by ROSETTA). This destructor
41842 : only frees memory of data members associated with the parts of the current IR node which
41843 : are NOT traversed. Those data members that are part of a traversal can be freed using
41844 : a traversal (calling this destructor on all children in a post-order traversal). Such
41845 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
41846 :
41847 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
41848 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
41849 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
41850 :
41851 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
41852 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
41853 : pointers are not yet implemented to call delete on eash pointer in the container.
41854 : (This could be done by derivation from the STL containers to define containers that
41855 : automatically deleted their members.)
41856 :
41857 : */
41858 0 : SgGraphNode::~SgGraphNode () {
41859 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
41860 :
41861 :
41862 : // case: not a listType for name
41863 0 : p_name = ""; // non list case
41864 : // case: not a listType for SgNode
41865 0 : p_SgNode = NULL; // non list case
41866 : // case: not a listType for index
41867 0 : p_index = -1; // non list case
41868 : // case: not a listType for attributeMechanism
41869 0 : p_attributeMechanism = NULL; // non list case
41870 :
41871 : }
41872 :
41873 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
41874 0 : }
41875 :
41876 :
41877 : /* #line 41878 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41878 :
41879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
41880 :
41881 : // Generated constructor
41882 0 : SgGraphNode::SgGraphNode ( std::string name )
41883 0 : : SgSupport()
41884 : {
41885 : #ifdef DEBUG
41886 : // printf ("In SgGraphNode::SgGraphNode (std::string name) sage_class_name() = %s \n",sage_class_name());
41887 : #endif
41888 : #if 0
41889 : // debugging information!
41890 : printf ("In SgGraphNode::SgGraphNode (std::string name): this = %p = %s \n",this,this->class_name().c_str());
41891 : #endif
41892 :
41893 0 : p_name = name;
41894 0 : p_SgNode = NULL;
41895 0 : p_index = -1;
41896 0 : p_attributeMechanism = NULL;
41897 :
41898 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
41899 :
41900 : #if 0
41901 : // DQ (7/30/2014): Call a virtual function.
41902 : std::string s = this->class_name();
41903 : #endif
41904 :
41905 : // Test the variant virtual function
41906 : // assert(GraphNodeTag == variant());
41907 0 : assert(GraphNodeTag == this->variant());
41908 0 : ROSE_ASSERT(GraphNodeTag == (int)(this->variantT()));
41909 0 : post_construction_initialization();
41910 :
41911 : // Test the isSgGraphNode() function since it has been problematic
41912 0 : assert(isSgGraphNode(this) != NULL);
41913 0 : }
41914 :
41915 : // Generated constructor (all data members)
41916 :
41917 : /* #line 41918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41918 :
41919 :
41920 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
41921 :
41922 :
41923 : // ********************************************************
41924 : // member functions common across all array grammar objects
41925 : // ********************************************************
41926 :
41927 :
41928 :
41929 : /* #line 41930 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41930 :
41931 :
41932 :
41933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
41934 :
41935 : // ********************************************************
41936 : // member functions specific to each node in the grammar
41937 : // ********************************************************
41938 :
41939 :
41940 : /* #line 41941 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
41941 :
41942 : // Start of memberFunctionString
41943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
41944 :
41945 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41946 :
41947 : SgGraphNode*
41948 0 : SgGraphEdge::get_node_A () const
41949 : {
41950 0 : ROSE_ASSERT (this != NULL);
41951 :
41952 : #if 0
41953 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41954 : // used to trigger marking transformations for the token-based unparsing.
41955 : printf ("SgGraphEdge::get_node_A = %p = %s \n",this,this->class_name().c_str());
41956 : #endif
41957 :
41958 0 : return p_node_A;
41959 : }
41960 :
41961 : void
41962 0 : SgGraphEdge::set_node_A ( SgGraphNode* node_A )
41963 : {
41964 0 : ROSE_ASSERT (this != NULL);
41965 :
41966 : #if 0
41967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
41968 : // used to trigger marking transformations for the token-based unparsing.
41969 : printf ("SgGraphEdge::set_node_A = %p = %s \n",this,this->class_name().c_str());
41970 : #endif
41971 :
41972 0 : set_isModified(true);
41973 :
41974 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
41975 : if (p_node_A != NULL && node_A != NULL && p_node_A != node_A)
41976 : {
41977 : printf ("Warning: node_A = %p overwriting valid pointer p_node_A = %p \n",node_A,p_node_A);
41978 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
41979 : printf ("Error fails assertion (p_node_A != NULL && node_A != NULL && p_node_A != node_A) is false\n");
41980 : ROSE_ASSERT(false);
41981 : #endif
41982 : }
41983 : #endif
41984 0 : p_node_A = node_A;
41985 0 : }
41986 :
41987 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
41988 :
41989 :
41990 : // End of memberFunctionString
41991 : // Start of memberFunctionString
41992 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
41993 :
41994 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
41995 :
41996 : SgGraphNode*
41997 0 : SgGraphEdge::get_node_B () const
41998 : {
41999 0 : ROSE_ASSERT (this != NULL);
42000 :
42001 : #if 0
42002 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
42003 : // used to trigger marking transformations for the token-based unparsing.
42004 : printf ("SgGraphEdge::get_node_B = %p = %s \n",this,this->class_name().c_str());
42005 : #endif
42006 :
42007 0 : return p_node_B;
42008 : }
42009 :
42010 : void
42011 0 : SgGraphEdge::set_node_B ( SgGraphNode* node_B )
42012 : {
42013 0 : ROSE_ASSERT (this != NULL);
42014 :
42015 : #if 0
42016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
42017 : // used to trigger marking transformations for the token-based unparsing.
42018 : printf ("SgGraphEdge::set_node_B = %p = %s \n",this,this->class_name().c_str());
42019 : #endif
42020 :
42021 0 : set_isModified(true);
42022 :
42023 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
42024 : if (p_node_B != NULL && node_B != NULL && p_node_B != node_B)
42025 : {
42026 : printf ("Warning: node_B = %p overwriting valid pointer p_node_B = %p \n",node_B,p_node_B);
42027 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
42028 : printf ("Error fails assertion (p_node_B != NULL && node_B != NULL && p_node_B != node_B) is false\n");
42029 : ROSE_ASSERT(false);
42030 : #endif
42031 : }
42032 : #endif
42033 0 : p_node_B = node_B;
42034 0 : }
42035 :
42036 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
42037 :
42038 :
42039 : // End of memberFunctionString
42040 : // Start of memberFunctionString
42041 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
42042 :
42043 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
42044 :
42045 : std::string
42046 0 : SgGraphEdge::get_name () const
42047 : {
42048 0 : ROSE_ASSERT (this != NULL);
42049 :
42050 : #if 0
42051 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
42052 : // used to trigger marking transformations for the token-based unparsing.
42053 : printf ("SgGraphEdge::get_name = %p = %s \n",this,this->class_name().c_str());
42054 : #endif
42055 :
42056 0 : return p_name;
42057 : }
42058 :
42059 : void
42060 0 : SgGraphEdge::set_name ( std::string name )
42061 : {
42062 0 : ROSE_ASSERT (this != NULL);
42063 :
42064 : #if 0
42065 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
42066 : // used to trigger marking transformations for the token-based unparsing.
42067 : printf ("SgGraphEdge::set_name = %p = %s \n",this,this->class_name().c_str());
42068 : #endif
42069 :
42070 0 : set_isModified(true);
42071 :
42072 0 : p_name = name;
42073 0 : }
42074 :
42075 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
42076 :
42077 :
42078 : // End of memberFunctionString
42079 : // Start of memberFunctionString
42080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
42081 :
42082 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
42083 :
42084 : int
42085 0 : SgGraphEdge::get_index () const
42086 : {
42087 0 : ROSE_ASSERT (this != NULL);
42088 :
42089 : #if 0
42090 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
42091 : // used to trigger marking transformations for the token-based unparsing.
42092 : printf ("SgGraphEdge::get_index = %p = %s \n",this,this->class_name().c_str());
42093 : #endif
42094 :
42095 0 : return p_index;
42096 : }
42097 :
42098 : void
42099 0 : SgGraphEdge::set_index ( int index )
42100 : {
42101 0 : ROSE_ASSERT (this != NULL);
42102 :
42103 : #if 0
42104 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
42105 : // used to trigger marking transformations for the token-based unparsing.
42106 : printf ("SgGraphEdge::set_index = %p = %s \n",this,this->class_name().c_str());
42107 : #endif
42108 :
42109 0 : set_isModified(true);
42110 :
42111 0 : p_index = index;
42112 0 : }
42113 :
42114 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
42115 :
42116 :
42117 : // End of memberFunctionString
42118 : // Start of memberFunctionString
42119 :
42120 :
42121 : // End of memberFunctionString
42122 : // Start of memberFunctionString
42123 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
42124 :
42125 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
42126 :
42127 : AstAttributeMechanism*
42128 0 : SgGraphEdge::get_attributeMechanism () const
42129 : {
42130 0 : ROSE_ASSERT (this != NULL);
42131 0 : return p_attributeMechanism;
42132 : }
42133 :
42134 : void
42135 0 : SgGraphEdge::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
42136 : {
42137 0 : ROSE_ASSERT (this != NULL);
42138 :
42139 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
42140 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
42141 : {
42142 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
42143 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
42144 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
42145 : ROSE_ASSERT(false);
42146 : #endif
42147 : }
42148 : #endif
42149 0 : p_attributeMechanism = attributeMechanism;
42150 0 : }
42151 :
42152 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
42153 :
42154 :
42155 : // End of memberFunctionString
42156 : // Start of memberFunctionString
42157 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
42158 :
42159 :
42160 : #if 0
42161 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
42162 : // a pointer and the interface represented directly at the SgNode
42163 : AstAttributeMechanism &
42164 : SgGraphEdge::attribute()
42165 : {
42166 : // DQ (1/2/2006): This function preserves as much of
42167 : // the syntax of attribute being a public data member.
42168 : if (p_attribute == NULL)
42169 : {
42170 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
42171 : assert(false);
42172 : }
42173 :
42174 : return *p_attribute;
42175 : }
42176 : #endif
42177 :
42178 : void
42179 0 : SgGraphEdge::addNewAttribute( std::string s, AstAttribute* a )
42180 : {
42181 0 : if (get_attributeMechanism() == NULL)
42182 : {
42183 0 : set_attributeMechanism( new AstAttributeMechanism() );
42184 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
42185 : }
42186 0 : get_attributeMechanism()->add(s,a);
42187 0 : }
42188 :
42189 : void
42190 0 : SgGraphEdge::setAttribute( std::string s, AstAttribute* a )
42191 : {
42192 0 : if (get_attributeMechanism() == NULL)
42193 : {
42194 0 : set_attributeMechanism( new AstAttributeMechanism() );
42195 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
42196 : }
42197 0 : get_attributeMechanism()->set(s,a);
42198 0 : }
42199 :
42200 : AstAttribute*
42201 0 : SgGraphEdge::getAttribute(std::string s) const
42202 : {
42203 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
42204 0 : if (attributeExists(s)==false) return NULL;
42205 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
42206 0 : ROSE_ASSERT(returnValue != NULL);
42207 0 : return returnValue;
42208 : }
42209 :
42210 : void
42211 0 : SgGraphEdge::updateAttribute( std::string s, AstAttribute* a )
42212 : {
42213 : // formerly called: replace
42214 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
42215 0 : get_attributeMechanism()->replace(s,a);
42216 0 : }
42217 :
42218 : void
42219 0 : SgGraphEdge::removeAttribute(std::string s)
42220 : {
42221 0 : if (get_attributeMechanism())
42222 0 : get_attributeMechanism()->remove(s);
42223 :
42224 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
42225 0 : int remainingCount = numberOfAttributes();
42226 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
42227 0 : if (remainingCount == 0)
42228 : {
42229 0 : delete get_attributeMechanism();
42230 0 : set_attributeMechanism(NULL);
42231 : }
42232 0 : }
42233 :
42234 : bool
42235 0 : SgGraphEdge::attributeExists(std::string s) const
42236 : {
42237 0 : bool returnValue = false;
42238 0 : if (get_attributeMechanism() != NULL)
42239 0 : returnValue = get_attributeMechanism()->exists(s);
42240 0 : return returnValue;
42241 : }
42242 :
42243 : int
42244 0 : SgGraphEdge::numberOfAttributes() const
42245 : {
42246 0 : int returnValue = 0;
42247 0 : if (get_attributeMechanism() != NULL)
42248 0 : returnValue = get_attributeMechanism()->size();
42249 0 : return returnValue;
42250 : }
42251 :
42252 :
42253 :
42254 : // End of memberFunctionString
42255 : // Start of memberFunctionString
42256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
42257 :
42258 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
42259 :
42260 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
42261 : const std::map<int, std::string> &
42262 0 : SgGraphEdge::get_properties () const
42263 : {
42264 0 : assert (this != NULL);
42265 0 : return p_properties;
42266 : }
42267 :
42268 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
42269 : std::map<int, std::string> &
42270 0 : SgGraphEdge::get_properties ()
42271 : {
42272 0 : assert (this != NULL);
42273 :
42274 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
42275 : // As a rule only set_ access functions can set the isModified flag.
42276 : // set_isModified(true);
42277 :
42278 0 : return p_properties;
42279 : }
42280 :
42281 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
42282 :
42283 :
42284 : // End of memberFunctionString
42285 : // Start of memberFunctionString
42286 : /* #line 22218 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
42287 :
42288 :
42289 :
42290 : // DQ (4/29/2009): Declaration of space for static data member.
42291 : int SgGraphEdge::p_index_counter = 0;
42292 :
42293 :
42294 : // tps : todo : remove me
42295 : void
42296 0 : SgGraphEdge::append_properties( int addr, const std::string & prop )
42297 : {
42298 : // DQ (4/29/2009): Unclear what this comment (below) means...
42299 : // implemented directly until we can fix how the statementList is built
42300 0 : p_properties[addr] = prop;
42301 0 : }
42302 :
42303 :
42304 : void
42305 0 : SgGraphEdge::post_construction_initialization()
42306 : {
42307 :
42308 : // DQ (4/29/2009): This function could be inlined for better performance.
42309 0 : p_index = p_index_counter++;
42310 :
42311 : // mprintf ("In SgGraphEdge::post_construction_initialization(): p_index = %u p_index_counter = %u \n",p_index,p_index_counter);
42312 :
42313 0 : }
42314 :
42315 :
42316 :
42317 : // End of memberFunctionString
42318 : // Start of memberFunctionString
42319 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
42320 :
42321 : // *** COMMON CODE SECTION BEGINS HERE ***
42322 :
42323 : #if 0
42324 : int
42325 : SgGraphEdge::getVariant() const
42326 : {
42327 : // This function is used in ROSE while "variant()" is used in SAGE
42328 : assert(this != NULL);
42329 : return variant();
42330 : }
42331 : #endif
42332 :
42333 : // This function is used in ROSE in treeTraversal code
42334 : // eventually replaces getVariant() and variant()
42335 : // though after variant() has been removed for a while we will
42336 : // want to change the name of variantT() back to variant()
42337 : // (since the "T" was ment to stand for temporary).
42338 : // When this happens the variantT() will be depricated.
42339 : VariantT
42340 0 : SgGraphEdge::variantT() const
42341 : {
42342 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
42343 0 : ROSE_ASSERT(this != NULL);
42344 0 : return V_SgGraphEdge;
42345 : }
42346 :
42347 : #if 0
42348 : int
42349 : SgGraphEdge::variant() const
42350 : {
42351 : // This function is used in SAGE
42352 : ROSE_ASSERT(this != NULL);
42353 : return GraphEdgeTag;
42354 : }
42355 : #endif
42356 :
42357 : ROSE_DLL_API const char*
42358 0 : SgGraphEdge::sage_class_name() const
42359 : {
42360 0 : ROSE_ASSERT(this != NULL);
42361 0 : return "SgGraphEdge";
42362 : }
42363 :
42364 : std::string
42365 0 : SgGraphEdge::class_name() const
42366 : {
42367 0 : ROSE_ASSERT(this != NULL);
42368 0 : return "SgGraphEdge";
42369 : }
42370 :
42371 : // DQ (11/26/2005): Support for visitor pattern mechanims
42372 : // (inferior to ROSE traversal mechanism, experimental).
42373 : void
42374 0 : SgGraphEdge::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
42375 : {
42376 0 : ROSE_ASSERT(this != NULL);
42377 0 : visitor.visit(this);
42378 0 : }
42379 :
42380 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
42381 0 : void SgGraphEdge::accept (ROSE_VisitorPattern & visitor) {
42382 0 : ROSE_ASSERT(this != NULL);
42383 0 : visitor.visit(this);
42384 0 : }
42385 :
42386 : SgGraphEdge*
42387 0 : SgGraphEdge::addRegExpAttribute(std::string s, AstRegExAttribute* a)
42388 : {
42389 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
42390 : // This function is currently only supported for the AST used the represent Binary executables.
42391 : if (0 /* isSgAsmNode(this) != NULL */)
42392 : {
42393 : // Support for regex specification.
42394 : std::string prefixCode = "REGEX:";
42395 : addNewAttribute(prefixCode + s,a);
42396 : }
42397 : #endif
42398 :
42399 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
42400 0 : return this;
42401 : }
42402 :
42403 : // *** COMMON CODE SECTION ENDS HERE ***
42404 :
42405 :
42406 : // End of memberFunctionString
42407 : // Start of memberFunctionString
42408 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
42409 :
42410 :
42411 : #if 0
42412 : //! Error checking support
42413 : /*! Verifies the following:
42414 : - working getVariant() member function
42415 : - calls base class's error() member function
42416 : Every class has one of these functions.
42417 : */
42418 : bool
42419 : SgGraphEdge::error()
42420 : {
42421 : // Put error checking here
42422 :
42423 : ROSE_ASSERT (this != NULL);
42424 : if (getVariant() != GraphEdgeTag)
42425 : {
42426 : printf ("Error in SgGraphEdge::error(): SgGraphEdge object has a %s variant \n",
42427 : Cxx_GrammarTerminalNames[getVariant()].name);
42428 : // printf ("Error in SgGraphEdge::error() \n");
42429 : ROSE_ABORT();
42430 : }
42431 :
42432 : ROSE_ASSERT (getVariant() == GraphEdgeTag);
42433 : return SgSupport::error();
42434 : }
42435 : #endif
42436 :
42437 :
42438 :
42439 : // End of memberFunctionString
42440 :
42441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
42442 :
42443 0 : SgGraphEdge* isSgGraphEdge ( SgNode* inputDerivedClassPointer )
42444 : {
42445 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
42446 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
42447 : // So to fix this we return NULL directly when the input is NULL and avoid the
42448 : // dynamic_cast in this case. This is likely a performance improvement as well.
42449 : // return dynamic_cast<SgGraphEdge*>(inputDerivedClassPointer);
42450 : // Milind Chabbi (8/28/2013): isSgGraphEdge uses table-driven castability instead of c++ default dynamic_cast
42451 : // this improves the running time performance by 10-20%.
42452 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGraphEdge*>(inputDerivedClassPointer);
42453 0 : return IS_SgGraphEdge_FAST_MACRO(inputDerivedClassPointer);
42454 : }
42455 :
42456 : // DQ (11/8/2003): Added version of functions taking const pointer
42457 0 : const SgGraphEdge* isSgGraphEdge ( const SgNode* inputDerivedClassPointer )
42458 : {
42459 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
42460 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
42461 : // So to fix this we return NULL directly when the input is NULL and avoid the
42462 : // dynamic_cast in this case. This is likely a performance improvement as well.
42463 : // return dynamic_cast<const SgGraphEdge*>(inputDerivedClassPointer);
42464 : // Milind Chabbi (8/28/2013): isSgGraphEdge uses table-driven castability instead of c++ default dynamic_cast
42465 : // this improves the running time performance by 10-20%.
42466 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGraphEdge*>(inputDerivedClassPointer);
42467 0 : return IS_SgGraphEdge_FAST_MACRO(inputDerivedClassPointer);
42468 : }
42469 :
42470 :
42471 :
42472 : /* #line 42473 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42473 :
42474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
42475 :
42476 : /**
42477 : \brief Generated destructor
42478 :
42479 : This destructor is automatically generated (by ROSETTA). This destructor
42480 : only frees memory of data members associated with the parts of the current IR node which
42481 : are NOT traversed. Those data members that are part of a traversal can be freed using
42482 : a traversal (calling this destructor on all children in a post-order traversal). Such
42483 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
42484 :
42485 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
42486 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
42487 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
42488 :
42489 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
42490 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
42491 : pointers are not yet implemented to call delete on eash pointer in the container.
42492 : (This could be done by derivation from the STL containers to define containers that
42493 : automatically deleted their members.)
42494 :
42495 : */
42496 0 : SgGraphEdge::~SgGraphEdge () {
42497 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
42498 :
42499 :
42500 : // case: not a listType for node_A
42501 0 : p_node_A = NULL; // non list case
42502 : // case: not a listType for node_B
42503 0 : p_node_B = NULL; // non list case
42504 : // case: not a listType for name
42505 0 : p_name = ""; // non list case
42506 : // case: not a listType for index
42507 0 : p_index = -1; // non list case
42508 : // case: not a listType for attributeMechanism
42509 0 : p_attributeMechanism = NULL; // non list case
42510 :
42511 : }
42512 :
42513 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
42514 0 : }
42515 :
42516 :
42517 : /* #line 42518 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42518 :
42519 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
42520 :
42521 : // Generated constructor
42522 0 : SgGraphEdge::SgGraphEdge ( SgGraphNode* node_A, SgGraphNode* node_B, std::string name )
42523 0 : : SgSupport()
42524 : {
42525 : #ifdef DEBUG
42526 : // printf ("In SgGraphEdge::SgGraphEdge (SgGraphNode* node_A, SgGraphNode* node_B, std::string name) sage_class_name() = %s \n",sage_class_name());
42527 : #endif
42528 : #if 0
42529 : // debugging information!
42530 : printf ("In SgGraphEdge::SgGraphEdge (SgGraphNode* node_A, SgGraphNode* node_B, std::string name): this = %p = %s \n",this,this->class_name().c_str());
42531 : #endif
42532 :
42533 0 : p_node_A = node_A;
42534 0 : p_node_B = node_B;
42535 0 : p_name = name;
42536 0 : p_index = -1;
42537 0 : p_attributeMechanism = NULL;
42538 :
42539 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
42540 :
42541 : #if 0
42542 : // DQ (7/30/2014): Call a virtual function.
42543 : std::string s = this->class_name();
42544 : #endif
42545 :
42546 : // Test the variant virtual function
42547 : // assert(GraphEdgeTag == variant());
42548 0 : assert(GraphEdgeTag == this->variant());
42549 0 : ROSE_ASSERT(GraphEdgeTag == (int)(this->variantT()));
42550 0 : post_construction_initialization();
42551 :
42552 : // Test the isSgGraphEdge() function since it has been problematic
42553 0 : assert(isSgGraphEdge(this) != NULL);
42554 0 : }
42555 :
42556 : // Generated constructor (all data members)
42557 :
42558 : /* #line 42559 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42559 :
42560 :
42561 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
42562 :
42563 :
42564 : // ********************************************************
42565 : // member functions common across all array grammar objects
42566 : // ********************************************************
42567 :
42568 :
42569 :
42570 : /* #line 42571 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42571 :
42572 :
42573 :
42574 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
42575 :
42576 : // ********************************************************
42577 : // member functions specific to each node in the grammar
42578 : // ********************************************************
42579 :
42580 :
42581 : /* #line 42582 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42582 :
42583 : // Start of memberFunctionString
42584 : /* #line 22385 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
42585 :
42586 :
42587 :
42588 0 : SgDirectedGraphEdge::SgDirectedGraphEdge(std::string label, std::string type, int n, SgGraphNode* from, SgGraphNode* to)
42589 :
42590 : {
42591 0 : p_name = label;
42592 : // p_type=t;
42593 0 : p_node_A = from;
42594 0 : p_node_B=to;
42595 0 : }
42596 :
42597 :
42598 :
42599 : // End of memberFunctionString
42600 : // Start of memberFunctionString
42601 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
42602 :
42603 : // *** COMMON CODE SECTION BEGINS HERE ***
42604 :
42605 : #if 0
42606 : int
42607 : SgDirectedGraphEdge::getVariant() const
42608 : {
42609 : // This function is used in ROSE while "variant()" is used in SAGE
42610 : assert(this != NULL);
42611 : return variant();
42612 : }
42613 : #endif
42614 :
42615 : // This function is used in ROSE in treeTraversal code
42616 : // eventually replaces getVariant() and variant()
42617 : // though after variant() has been removed for a while we will
42618 : // want to change the name of variantT() back to variant()
42619 : // (since the "T" was ment to stand for temporary).
42620 : // When this happens the variantT() will be depricated.
42621 : VariantT
42622 0 : SgDirectedGraphEdge::variantT() const
42623 : {
42624 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
42625 0 : ROSE_ASSERT(this != NULL);
42626 0 : return V_SgDirectedGraphEdge;
42627 : }
42628 :
42629 : #if 0
42630 : int
42631 : SgDirectedGraphEdge::variant() const
42632 : {
42633 : // This function is used in SAGE
42634 : ROSE_ASSERT(this != NULL);
42635 : return DirectedGraphEdgeTag;
42636 : }
42637 : #endif
42638 :
42639 : ROSE_DLL_API const char*
42640 0 : SgDirectedGraphEdge::sage_class_name() const
42641 : {
42642 0 : ROSE_ASSERT(this != NULL);
42643 0 : return "SgDirectedGraphEdge";
42644 : }
42645 :
42646 : std::string
42647 0 : SgDirectedGraphEdge::class_name() const
42648 : {
42649 0 : ROSE_ASSERT(this != NULL);
42650 0 : return "SgDirectedGraphEdge";
42651 : }
42652 :
42653 : // DQ (11/26/2005): Support for visitor pattern mechanims
42654 : // (inferior to ROSE traversal mechanism, experimental).
42655 : void
42656 0 : SgDirectedGraphEdge::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
42657 : {
42658 0 : ROSE_ASSERT(this != NULL);
42659 0 : visitor.visit(this);
42660 0 : }
42661 :
42662 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
42663 0 : void SgDirectedGraphEdge::accept (ROSE_VisitorPattern & visitor) {
42664 0 : ROSE_ASSERT(this != NULL);
42665 0 : visitor.visit(this);
42666 0 : }
42667 :
42668 : SgDirectedGraphEdge*
42669 0 : SgDirectedGraphEdge::addRegExpAttribute(std::string s, AstRegExAttribute* a)
42670 : {
42671 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
42672 : // This function is currently only supported for the AST used the represent Binary executables.
42673 : if (0 /* isSgAsmNode(this) != NULL */)
42674 : {
42675 : // Support for regex specification.
42676 : std::string prefixCode = "REGEX:";
42677 : addNewAttribute(prefixCode + s,a);
42678 : }
42679 : #endif
42680 :
42681 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
42682 0 : return this;
42683 : }
42684 :
42685 : // *** COMMON CODE SECTION ENDS HERE ***
42686 :
42687 :
42688 : // End of memberFunctionString
42689 : // Start of memberFunctionString
42690 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
42691 :
42692 :
42693 : #if 0
42694 : //! Error checking support
42695 : /*! Verifies the following:
42696 : - working getVariant() member function
42697 : - calls base class's error() member function
42698 : Every class has one of these functions.
42699 : */
42700 : bool
42701 : SgDirectedGraphEdge::error()
42702 : {
42703 : // Put error checking here
42704 :
42705 : ROSE_ASSERT (this != NULL);
42706 : if (getVariant() != DirectedGraphEdgeTag)
42707 : {
42708 : printf ("Error in SgDirectedGraphEdge::error(): SgDirectedGraphEdge object has a %s variant \n",
42709 : Cxx_GrammarTerminalNames[getVariant()].name);
42710 : // printf ("Error in SgDirectedGraphEdge::error() \n");
42711 : ROSE_ABORT();
42712 : }
42713 :
42714 : ROSE_ASSERT (getVariant() == DirectedGraphEdgeTag);
42715 : return SgGraphEdge::error();
42716 : }
42717 : #endif
42718 :
42719 :
42720 :
42721 : // End of memberFunctionString
42722 :
42723 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
42724 :
42725 0 : SgDirectedGraphEdge* isSgDirectedGraphEdge ( SgNode* inputDerivedClassPointer )
42726 : {
42727 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
42728 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
42729 : // So to fix this we return NULL directly when the input is NULL and avoid the
42730 : // dynamic_cast in this case. This is likely a performance improvement as well.
42731 : // return dynamic_cast<SgDirectedGraphEdge*>(inputDerivedClassPointer);
42732 : // Milind Chabbi (8/28/2013): isSgDirectedGraphEdge uses table-driven castability instead of c++ default dynamic_cast
42733 : // this improves the running time performance by 10-20%.
42734 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDirectedGraphEdge*>(inputDerivedClassPointer);
42735 0 : return IS_SgDirectedGraphEdge_FAST_MACRO(inputDerivedClassPointer);
42736 : }
42737 :
42738 : // DQ (11/8/2003): Added version of functions taking const pointer
42739 0 : const SgDirectedGraphEdge* isSgDirectedGraphEdge ( const SgNode* inputDerivedClassPointer )
42740 : {
42741 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
42742 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
42743 : // So to fix this we return NULL directly when the input is NULL and avoid the
42744 : // dynamic_cast in this case. This is likely a performance improvement as well.
42745 : // return dynamic_cast<const SgDirectedGraphEdge*>(inputDerivedClassPointer);
42746 : // Milind Chabbi (8/28/2013): isSgDirectedGraphEdge uses table-driven castability instead of c++ default dynamic_cast
42747 : // this improves the running time performance by 10-20%.
42748 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDirectedGraphEdge*>(inputDerivedClassPointer);
42749 0 : return IS_SgDirectedGraphEdge_FAST_MACRO(inputDerivedClassPointer);
42750 : }
42751 :
42752 :
42753 :
42754 : /* #line 42755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42755 :
42756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
42757 :
42758 : /**
42759 : \brief Generated destructor
42760 :
42761 : This destructor is automatically generated (by ROSETTA). This destructor
42762 : only frees memory of data members associated with the parts of the current IR node which
42763 : are NOT traversed. Those data members that are part of a traversal can be freed using
42764 : a traversal (calling this destructor on all children in a post-order traversal). Such
42765 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
42766 :
42767 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
42768 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
42769 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
42770 :
42771 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
42772 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
42773 : pointers are not yet implemented to call delete on eash pointer in the container.
42774 : (This could be done by derivation from the STL containers to define containers that
42775 : automatically deleted their members.)
42776 :
42777 : */
42778 0 : SgDirectedGraphEdge::~SgDirectedGraphEdge () {
42779 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
42780 :
42781 :
42782 :
42783 : }
42784 :
42785 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
42786 0 : }
42787 :
42788 :
42789 : /* #line 42790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42790 :
42791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
42792 :
42793 : // Generated constructor
42794 0 : SgDirectedGraphEdge::SgDirectedGraphEdge ( SgGraphNode* node_A, SgGraphNode* node_B, std::string name )
42795 0 : : SgGraphEdge(node_A, node_B, name)
42796 : {
42797 : #ifdef DEBUG
42798 : // printf ("In SgDirectedGraphEdge::SgDirectedGraphEdge (SgGraphNode* node_A, SgGraphNode* node_B, std::string name) sage_class_name() = %s \n",sage_class_name());
42799 : #endif
42800 : #if 0
42801 : // debugging information!
42802 : printf ("In SgDirectedGraphEdge::SgDirectedGraphEdge (SgGraphNode* node_A, SgGraphNode* node_B, std::string name): this = %p = %s \n",this,this->class_name().c_str());
42803 : #endif
42804 :
42805 :
42806 :
42807 : #if 0
42808 : // DQ (7/30/2014): Call a virtual function.
42809 : std::string s = this->class_name();
42810 : #endif
42811 :
42812 : // Test the variant virtual function
42813 : // assert(DirectedGraphEdgeTag == variant());
42814 0 : assert(DirectedGraphEdgeTag == this->variant());
42815 0 : ROSE_ASSERT(DirectedGraphEdgeTag == (int)(this->variantT()));
42816 0 : post_construction_initialization();
42817 :
42818 : // Test the isSgDirectedGraphEdge() function since it has been problematic
42819 0 : assert(isSgDirectedGraphEdge(this) != NULL);
42820 0 : }
42821 :
42822 : // Generated constructor (all data members)
42823 :
42824 : /* #line 42825 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42825 :
42826 :
42827 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
42828 :
42829 :
42830 : // ********************************************************
42831 : // member functions common across all array grammar objects
42832 : // ********************************************************
42833 :
42834 :
42835 :
42836 : /* #line 42837 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42837 :
42838 :
42839 :
42840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
42841 :
42842 : // ********************************************************
42843 : // member functions specific to each node in the grammar
42844 : // ********************************************************
42845 :
42846 :
42847 : /* #line 42848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
42848 :
42849 : // Start of memberFunctionString
42850 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
42851 :
42852 : // *** COMMON CODE SECTION BEGINS HERE ***
42853 :
42854 : #if 0
42855 : int
42856 : SgUndirectedGraphEdge::getVariant() const
42857 : {
42858 : // This function is used in ROSE while "variant()" is used in SAGE
42859 : assert(this != NULL);
42860 : return variant();
42861 : }
42862 : #endif
42863 :
42864 : // This function is used in ROSE in treeTraversal code
42865 : // eventually replaces getVariant() and variant()
42866 : // though after variant() has been removed for a while we will
42867 : // want to change the name of variantT() back to variant()
42868 : // (since the "T" was ment to stand for temporary).
42869 : // When this happens the variantT() will be depricated.
42870 : VariantT
42871 0 : SgUndirectedGraphEdge::variantT() const
42872 : {
42873 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
42874 0 : ROSE_ASSERT(this != NULL);
42875 0 : return V_SgUndirectedGraphEdge;
42876 : }
42877 :
42878 : #if 0
42879 : int
42880 : SgUndirectedGraphEdge::variant() const
42881 : {
42882 : // This function is used in SAGE
42883 : ROSE_ASSERT(this != NULL);
42884 : return UndirectedGraphEdgeTag;
42885 : }
42886 : #endif
42887 :
42888 : ROSE_DLL_API const char*
42889 0 : SgUndirectedGraphEdge::sage_class_name() const
42890 : {
42891 0 : ROSE_ASSERT(this != NULL);
42892 0 : return "SgUndirectedGraphEdge";
42893 : }
42894 :
42895 : std::string
42896 0 : SgUndirectedGraphEdge::class_name() const
42897 : {
42898 0 : ROSE_ASSERT(this != NULL);
42899 0 : return "SgUndirectedGraphEdge";
42900 : }
42901 :
42902 : // DQ (11/26/2005): Support for visitor pattern mechanims
42903 : // (inferior to ROSE traversal mechanism, experimental).
42904 : void
42905 0 : SgUndirectedGraphEdge::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
42906 : {
42907 0 : ROSE_ASSERT(this != NULL);
42908 0 : visitor.visit(this);
42909 0 : }
42910 :
42911 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
42912 0 : void SgUndirectedGraphEdge::accept (ROSE_VisitorPattern & visitor) {
42913 0 : ROSE_ASSERT(this != NULL);
42914 0 : visitor.visit(this);
42915 0 : }
42916 :
42917 : SgUndirectedGraphEdge*
42918 0 : SgUndirectedGraphEdge::addRegExpAttribute(std::string s, AstRegExAttribute* a)
42919 : {
42920 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
42921 : // This function is currently only supported for the AST used the represent Binary executables.
42922 : if (0 /* isSgAsmNode(this) != NULL */)
42923 : {
42924 : // Support for regex specification.
42925 : std::string prefixCode = "REGEX:";
42926 : addNewAttribute(prefixCode + s,a);
42927 : }
42928 : #endif
42929 :
42930 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
42931 0 : return this;
42932 : }
42933 :
42934 : // *** COMMON CODE SECTION ENDS HERE ***
42935 :
42936 :
42937 : // End of memberFunctionString
42938 : // Start of memberFunctionString
42939 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
42940 :
42941 :
42942 : #if 0
42943 : //! Error checking support
42944 : /*! Verifies the following:
42945 : - working getVariant() member function
42946 : - calls base class's error() member function
42947 : Every class has one of these functions.
42948 : */
42949 : bool
42950 : SgUndirectedGraphEdge::error()
42951 : {
42952 : // Put error checking here
42953 :
42954 : ROSE_ASSERT (this != NULL);
42955 : if (getVariant() != UndirectedGraphEdgeTag)
42956 : {
42957 : printf ("Error in SgUndirectedGraphEdge::error(): SgUndirectedGraphEdge object has a %s variant \n",
42958 : Cxx_GrammarTerminalNames[getVariant()].name);
42959 : // printf ("Error in SgUndirectedGraphEdge::error() \n");
42960 : ROSE_ABORT();
42961 : }
42962 :
42963 : ROSE_ASSERT (getVariant() == UndirectedGraphEdgeTag);
42964 : return SgGraphEdge::error();
42965 : }
42966 : #endif
42967 :
42968 :
42969 :
42970 : // End of memberFunctionString
42971 :
42972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
42973 :
42974 0 : SgUndirectedGraphEdge* isSgUndirectedGraphEdge ( SgNode* inputDerivedClassPointer )
42975 : {
42976 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
42977 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
42978 : // So to fix this we return NULL directly when the input is NULL and avoid the
42979 : // dynamic_cast in this case. This is likely a performance improvement as well.
42980 : // return dynamic_cast<SgUndirectedGraphEdge*>(inputDerivedClassPointer);
42981 : // Milind Chabbi (8/28/2013): isSgUndirectedGraphEdge uses table-driven castability instead of c++ default dynamic_cast
42982 : // this improves the running time performance by 10-20%.
42983 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUndirectedGraphEdge*>(inputDerivedClassPointer);
42984 0 : return IS_SgUndirectedGraphEdge_FAST_MACRO(inputDerivedClassPointer);
42985 : }
42986 :
42987 : // DQ (11/8/2003): Added version of functions taking const pointer
42988 0 : const SgUndirectedGraphEdge* isSgUndirectedGraphEdge ( const SgNode* inputDerivedClassPointer )
42989 : {
42990 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
42991 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
42992 : // So to fix this we return NULL directly when the input is NULL and avoid the
42993 : // dynamic_cast in this case. This is likely a performance improvement as well.
42994 : // return dynamic_cast<const SgUndirectedGraphEdge*>(inputDerivedClassPointer);
42995 : // Milind Chabbi (8/28/2013): isSgUndirectedGraphEdge uses table-driven castability instead of c++ default dynamic_cast
42996 : // this improves the running time performance by 10-20%.
42997 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUndirectedGraphEdge*>(inputDerivedClassPointer);
42998 0 : return IS_SgUndirectedGraphEdge_FAST_MACRO(inputDerivedClassPointer);
42999 : }
43000 :
43001 :
43002 :
43003 : /* #line 43004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43004 :
43005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43006 :
43007 : /**
43008 : \brief Generated destructor
43009 :
43010 : This destructor is automatically generated (by ROSETTA). This destructor
43011 : only frees memory of data members associated with the parts of the current IR node which
43012 : are NOT traversed. Those data members that are part of a traversal can be freed using
43013 : a traversal (calling this destructor on all children in a post-order traversal). Such
43014 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
43015 :
43016 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
43017 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
43018 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
43019 :
43020 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
43021 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
43022 : pointers are not yet implemented to call delete on eash pointer in the container.
43023 : (This could be done by derivation from the STL containers to define containers that
43024 : automatically deleted their members.)
43025 :
43026 : */
43027 0 : SgUndirectedGraphEdge::~SgUndirectedGraphEdge () {
43028 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
43029 :
43030 :
43031 :
43032 : }
43033 :
43034 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43035 0 : }
43036 :
43037 :
43038 : /* #line 43039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43039 :
43040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
43041 :
43042 : // Generated constructor
43043 0 : SgUndirectedGraphEdge::SgUndirectedGraphEdge ( SgGraphNode* node_A, SgGraphNode* node_B, std::string name )
43044 0 : : SgGraphEdge(node_A, node_B, name)
43045 : {
43046 : #ifdef DEBUG
43047 : // printf ("In SgUndirectedGraphEdge::SgUndirectedGraphEdge (SgGraphNode* node_A, SgGraphNode* node_B, std::string name) sage_class_name() = %s \n",sage_class_name());
43048 : #endif
43049 : #if 0
43050 : // debugging information!
43051 : printf ("In SgUndirectedGraphEdge::SgUndirectedGraphEdge (SgGraphNode* node_A, SgGraphNode* node_B, std::string name): this = %p = %s \n",this,this->class_name().c_str());
43052 : #endif
43053 :
43054 :
43055 :
43056 : #if 0
43057 : // DQ (7/30/2014): Call a virtual function.
43058 : std::string s = this->class_name();
43059 : #endif
43060 :
43061 : // Test the variant virtual function
43062 : // assert(UndirectedGraphEdgeTag == variant());
43063 0 : assert(UndirectedGraphEdgeTag == this->variant());
43064 0 : ROSE_ASSERT(UndirectedGraphEdgeTag == (int)(this->variantT()));
43065 0 : post_construction_initialization();
43066 :
43067 : // Test the isSgUndirectedGraphEdge() function since it has been problematic
43068 0 : assert(isSgUndirectedGraphEdge(this) != NULL);
43069 0 : }
43070 :
43071 : // Generated constructor (all data members)
43072 :
43073 : /* #line 43074 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43074 :
43075 :
43076 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43077 :
43078 :
43079 : // ********************************************************
43080 : // member functions common across all array grammar objects
43081 : // ********************************************************
43082 :
43083 :
43084 :
43085 : /* #line 43086 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43086 :
43087 :
43088 :
43089 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43090 :
43091 : // ********************************************************
43092 : // member functions specific to each node in the grammar
43093 : // ********************************************************
43094 :
43095 :
43096 : /* #line 43097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43097 :
43098 : // Start of memberFunctionString
43099 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
43100 :
43101 : // *** COMMON CODE SECTION BEGINS HERE ***
43102 :
43103 : #if 0
43104 : int
43105 : SgGraphNodeList::getVariant() const
43106 : {
43107 : // This function is used in ROSE while "variant()" is used in SAGE
43108 : assert(this != NULL);
43109 : return variant();
43110 : }
43111 : #endif
43112 :
43113 : // This function is used in ROSE in treeTraversal code
43114 : // eventually replaces getVariant() and variant()
43115 : // though after variant() has been removed for a while we will
43116 : // want to change the name of variantT() back to variant()
43117 : // (since the "T" was ment to stand for temporary).
43118 : // When this happens the variantT() will be depricated.
43119 : VariantT
43120 0 : SgGraphNodeList::variantT() const
43121 : {
43122 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
43123 0 : ROSE_ASSERT(this != NULL);
43124 0 : return V_SgGraphNodeList;
43125 : }
43126 :
43127 : #if 0
43128 : int
43129 : SgGraphNodeList::variant() const
43130 : {
43131 : // This function is used in SAGE
43132 : ROSE_ASSERT(this != NULL);
43133 : return GraphNodeListTag;
43134 : }
43135 : #endif
43136 :
43137 : ROSE_DLL_API const char*
43138 0 : SgGraphNodeList::sage_class_name() const
43139 : {
43140 0 : ROSE_ASSERT(this != NULL);
43141 0 : return "SgGraphNodeList";
43142 : }
43143 :
43144 : std::string
43145 0 : SgGraphNodeList::class_name() const
43146 : {
43147 0 : ROSE_ASSERT(this != NULL);
43148 0 : return "SgGraphNodeList";
43149 : }
43150 :
43151 : // DQ (11/26/2005): Support for visitor pattern mechanims
43152 : // (inferior to ROSE traversal mechanism, experimental).
43153 : void
43154 0 : SgGraphNodeList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
43155 : {
43156 0 : ROSE_ASSERT(this != NULL);
43157 0 : visitor.visit(this);
43158 0 : }
43159 :
43160 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
43161 0 : void SgGraphNodeList::accept (ROSE_VisitorPattern & visitor) {
43162 0 : ROSE_ASSERT(this != NULL);
43163 0 : visitor.visit(this);
43164 0 : }
43165 :
43166 : SgGraphNodeList*
43167 0 : SgGraphNodeList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
43168 : {
43169 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
43170 : // This function is currently only supported for the AST used the represent Binary executables.
43171 : if (0 /* isSgAsmNode(this) != NULL */)
43172 : {
43173 : // Support for regex specification.
43174 : std::string prefixCode = "REGEX:";
43175 : addNewAttribute(prefixCode + s,a);
43176 : }
43177 : #endif
43178 :
43179 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
43180 0 : return this;
43181 : }
43182 :
43183 : // *** COMMON CODE SECTION ENDS HERE ***
43184 :
43185 :
43186 : // End of memberFunctionString
43187 : // Start of memberFunctionString
43188 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
43189 :
43190 :
43191 : #if 0
43192 : //! Error checking support
43193 : /*! Verifies the following:
43194 : - working getVariant() member function
43195 : - calls base class's error() member function
43196 : Every class has one of these functions.
43197 : */
43198 : bool
43199 : SgGraphNodeList::error()
43200 : {
43201 : // Put error checking here
43202 :
43203 : ROSE_ASSERT (this != NULL);
43204 : if (getVariant() != GraphNodeListTag)
43205 : {
43206 : printf ("Error in SgGraphNodeList::error(): SgGraphNodeList object has a %s variant \n",
43207 : Cxx_GrammarTerminalNames[getVariant()].name);
43208 : // printf ("Error in SgGraphNodeList::error() \n");
43209 : ROSE_ABORT();
43210 : }
43211 :
43212 : ROSE_ASSERT (getVariant() == GraphNodeListTag);
43213 : return SgSupport::error();
43214 : }
43215 : #endif
43216 :
43217 :
43218 :
43219 : // End of memberFunctionString
43220 :
43221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
43222 :
43223 0 : SgGraphNodeList* isSgGraphNodeList ( SgNode* inputDerivedClassPointer )
43224 : {
43225 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
43226 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
43227 : // So to fix this we return NULL directly when the input is NULL and avoid the
43228 : // dynamic_cast in this case. This is likely a performance improvement as well.
43229 : // return dynamic_cast<SgGraphNodeList*>(inputDerivedClassPointer);
43230 : // Milind Chabbi (8/28/2013): isSgGraphNodeList uses table-driven castability instead of c++ default dynamic_cast
43231 : // this improves the running time performance by 10-20%.
43232 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGraphNodeList*>(inputDerivedClassPointer);
43233 0 : return IS_SgGraphNodeList_FAST_MACRO(inputDerivedClassPointer);
43234 : }
43235 :
43236 : // DQ (11/8/2003): Added version of functions taking const pointer
43237 0 : const SgGraphNodeList* isSgGraphNodeList ( const SgNode* inputDerivedClassPointer )
43238 : {
43239 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
43240 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
43241 : // So to fix this we return NULL directly when the input is NULL and avoid the
43242 : // dynamic_cast in this case. This is likely a performance improvement as well.
43243 : // return dynamic_cast<const SgGraphNodeList*>(inputDerivedClassPointer);
43244 : // Milind Chabbi (8/28/2013): isSgGraphNodeList uses table-driven castability instead of c++ default dynamic_cast
43245 : // this improves the running time performance by 10-20%.
43246 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGraphNodeList*>(inputDerivedClassPointer);
43247 0 : return IS_SgGraphNodeList_FAST_MACRO(inputDerivedClassPointer);
43248 : }
43249 :
43250 :
43251 :
43252 : /* #line 43253 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43253 :
43254 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43255 :
43256 : /**
43257 : \brief Generated destructor
43258 :
43259 : This destructor is automatically generated (by ROSETTA). This destructor
43260 : only frees memory of data members associated with the parts of the current IR node which
43261 : are NOT traversed. Those data members that are part of a traversal can be freed using
43262 : a traversal (calling this destructor on all children in a post-order traversal). Such
43263 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
43264 :
43265 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
43266 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
43267 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
43268 :
43269 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
43270 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
43271 : pointers are not yet implemented to call delete on eash pointer in the container.
43272 : (This could be done by derivation from the STL containers to define containers that
43273 : automatically deleted their members.)
43274 :
43275 : */
43276 0 : SgGraphNodeList::~SgGraphNodeList () {
43277 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
43278 :
43279 :
43280 :
43281 : }
43282 :
43283 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43284 0 : }
43285 :
43286 :
43287 : /* #line 43288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43288 :
43289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
43290 :
43291 : // Generated constructor
43292 0 : SgGraphNodeList::SgGraphNodeList ( )
43293 0 : : SgSupport()
43294 : {
43295 : #ifdef DEBUG
43296 : // printf ("In SgGraphNodeList::SgGraphNodeList () sage_class_name() = %s \n",sage_class_name());
43297 : #endif
43298 : #if 0
43299 : // debugging information!
43300 : printf ("In SgGraphNodeList::SgGraphNodeList (): this = %p = %s \n",this,this->class_name().c_str());
43301 : #endif
43302 :
43303 :
43304 :
43305 : #if 0
43306 : // DQ (7/30/2014): Call a virtual function.
43307 : std::string s = this->class_name();
43308 : #endif
43309 :
43310 : // Test the variant virtual function
43311 : // assert(GraphNodeListTag == variant());
43312 0 : assert(GraphNodeListTag == this->variant());
43313 0 : ROSE_ASSERT(GraphNodeListTag == (int)(this->variantT()));
43314 0 : post_construction_initialization();
43315 :
43316 : // Test the isSgGraphNodeList() function since it has been problematic
43317 0 : assert(isSgGraphNodeList(this) != NULL);
43318 0 : }
43319 :
43320 : // Generated constructor (all data members)
43321 :
43322 : /* #line 43323 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43323 :
43324 :
43325 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43326 :
43327 :
43328 : // ********************************************************
43329 : // member functions common across all array grammar objects
43330 : // ********************************************************
43331 :
43332 :
43333 :
43334 : /* #line 43335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43335 :
43336 :
43337 :
43338 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43339 :
43340 : // ********************************************************
43341 : // member functions specific to each node in the grammar
43342 : // ********************************************************
43343 :
43344 :
43345 : /* #line 43346 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43346 :
43347 : // Start of memberFunctionString
43348 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
43349 :
43350 : // *** COMMON CODE SECTION BEGINS HERE ***
43351 :
43352 : #if 0
43353 : int
43354 : SgGraphEdgeList::getVariant() const
43355 : {
43356 : // This function is used in ROSE while "variant()" is used in SAGE
43357 : assert(this != NULL);
43358 : return variant();
43359 : }
43360 : #endif
43361 :
43362 : // This function is used in ROSE in treeTraversal code
43363 : // eventually replaces getVariant() and variant()
43364 : // though after variant() has been removed for a while we will
43365 : // want to change the name of variantT() back to variant()
43366 : // (since the "T" was ment to stand for temporary).
43367 : // When this happens the variantT() will be depricated.
43368 : VariantT
43369 0 : SgGraphEdgeList::variantT() const
43370 : {
43371 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
43372 0 : ROSE_ASSERT(this != NULL);
43373 0 : return V_SgGraphEdgeList;
43374 : }
43375 :
43376 : #if 0
43377 : int
43378 : SgGraphEdgeList::variant() const
43379 : {
43380 : // This function is used in SAGE
43381 : ROSE_ASSERT(this != NULL);
43382 : return GraphEdgeListTag;
43383 : }
43384 : #endif
43385 :
43386 : ROSE_DLL_API const char*
43387 0 : SgGraphEdgeList::sage_class_name() const
43388 : {
43389 0 : ROSE_ASSERT(this != NULL);
43390 0 : return "SgGraphEdgeList";
43391 : }
43392 :
43393 : std::string
43394 0 : SgGraphEdgeList::class_name() const
43395 : {
43396 0 : ROSE_ASSERT(this != NULL);
43397 0 : return "SgGraphEdgeList";
43398 : }
43399 :
43400 : // DQ (11/26/2005): Support for visitor pattern mechanims
43401 : // (inferior to ROSE traversal mechanism, experimental).
43402 : void
43403 0 : SgGraphEdgeList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
43404 : {
43405 0 : ROSE_ASSERT(this != NULL);
43406 0 : visitor.visit(this);
43407 0 : }
43408 :
43409 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
43410 0 : void SgGraphEdgeList::accept (ROSE_VisitorPattern & visitor) {
43411 0 : ROSE_ASSERT(this != NULL);
43412 0 : visitor.visit(this);
43413 0 : }
43414 :
43415 : SgGraphEdgeList*
43416 0 : SgGraphEdgeList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
43417 : {
43418 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
43419 : // This function is currently only supported for the AST used the represent Binary executables.
43420 : if (0 /* isSgAsmNode(this) != NULL */)
43421 : {
43422 : // Support for regex specification.
43423 : std::string prefixCode = "REGEX:";
43424 : addNewAttribute(prefixCode + s,a);
43425 : }
43426 : #endif
43427 :
43428 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
43429 0 : return this;
43430 : }
43431 :
43432 : // *** COMMON CODE SECTION ENDS HERE ***
43433 :
43434 :
43435 : // End of memberFunctionString
43436 : // Start of memberFunctionString
43437 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
43438 :
43439 :
43440 : #if 0
43441 : //! Error checking support
43442 : /*! Verifies the following:
43443 : - working getVariant() member function
43444 : - calls base class's error() member function
43445 : Every class has one of these functions.
43446 : */
43447 : bool
43448 : SgGraphEdgeList::error()
43449 : {
43450 : // Put error checking here
43451 :
43452 : ROSE_ASSERT (this != NULL);
43453 : if (getVariant() != GraphEdgeListTag)
43454 : {
43455 : printf ("Error in SgGraphEdgeList::error(): SgGraphEdgeList object has a %s variant \n",
43456 : Cxx_GrammarTerminalNames[getVariant()].name);
43457 : // printf ("Error in SgGraphEdgeList::error() \n");
43458 : ROSE_ABORT();
43459 : }
43460 :
43461 : ROSE_ASSERT (getVariant() == GraphEdgeListTag);
43462 : return SgSupport::error();
43463 : }
43464 : #endif
43465 :
43466 :
43467 :
43468 : // End of memberFunctionString
43469 :
43470 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
43471 :
43472 0 : SgGraphEdgeList* isSgGraphEdgeList ( SgNode* inputDerivedClassPointer )
43473 : {
43474 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
43475 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
43476 : // So to fix this we return NULL directly when the input is NULL and avoid the
43477 : // dynamic_cast in this case. This is likely a performance improvement as well.
43478 : // return dynamic_cast<SgGraphEdgeList*>(inputDerivedClassPointer);
43479 : // Milind Chabbi (8/28/2013): isSgGraphEdgeList uses table-driven castability instead of c++ default dynamic_cast
43480 : // this improves the running time performance by 10-20%.
43481 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGraphEdgeList*>(inputDerivedClassPointer);
43482 0 : return IS_SgGraphEdgeList_FAST_MACRO(inputDerivedClassPointer);
43483 : }
43484 :
43485 : // DQ (11/8/2003): Added version of functions taking const pointer
43486 0 : const SgGraphEdgeList* isSgGraphEdgeList ( const SgNode* inputDerivedClassPointer )
43487 : {
43488 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
43489 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
43490 : // So to fix this we return NULL directly when the input is NULL and avoid the
43491 : // dynamic_cast in this case. This is likely a performance improvement as well.
43492 : // return dynamic_cast<const SgGraphEdgeList*>(inputDerivedClassPointer);
43493 : // Milind Chabbi (8/28/2013): isSgGraphEdgeList uses table-driven castability instead of c++ default dynamic_cast
43494 : // this improves the running time performance by 10-20%.
43495 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGraphEdgeList*>(inputDerivedClassPointer);
43496 0 : return IS_SgGraphEdgeList_FAST_MACRO(inputDerivedClassPointer);
43497 : }
43498 :
43499 :
43500 :
43501 : /* #line 43502 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43502 :
43503 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43504 :
43505 : /**
43506 : \brief Generated destructor
43507 :
43508 : This destructor is automatically generated (by ROSETTA). This destructor
43509 : only frees memory of data members associated with the parts of the current IR node which
43510 : are NOT traversed. Those data members that are part of a traversal can be freed using
43511 : a traversal (calling this destructor on all children in a post-order traversal). Such
43512 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
43513 :
43514 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
43515 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
43516 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
43517 :
43518 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
43519 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
43520 : pointers are not yet implemented to call delete on eash pointer in the container.
43521 : (This could be done by derivation from the STL containers to define containers that
43522 : automatically deleted their members.)
43523 :
43524 : */
43525 0 : SgGraphEdgeList::~SgGraphEdgeList () {
43526 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
43527 :
43528 :
43529 :
43530 : }
43531 :
43532 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43533 0 : }
43534 :
43535 :
43536 : /* #line 43537 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43537 :
43538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
43539 :
43540 : // Generated constructor
43541 0 : SgGraphEdgeList::SgGraphEdgeList ( )
43542 0 : : SgSupport()
43543 : {
43544 : #ifdef DEBUG
43545 : // printf ("In SgGraphEdgeList::SgGraphEdgeList () sage_class_name() = %s \n",sage_class_name());
43546 : #endif
43547 : #if 0
43548 : // debugging information!
43549 : printf ("In SgGraphEdgeList::SgGraphEdgeList (): this = %p = %s \n",this,this->class_name().c_str());
43550 : #endif
43551 :
43552 :
43553 :
43554 : #if 0
43555 : // DQ (7/30/2014): Call a virtual function.
43556 : std::string s = this->class_name();
43557 : #endif
43558 :
43559 : // Test the variant virtual function
43560 : // assert(GraphEdgeListTag == variant());
43561 0 : assert(GraphEdgeListTag == this->variant());
43562 0 : ROSE_ASSERT(GraphEdgeListTag == (int)(this->variantT()));
43563 0 : post_construction_initialization();
43564 :
43565 : // Test the isSgGraphEdgeList() function since it has been problematic
43566 0 : assert(isSgGraphEdgeList(this) != NULL);
43567 0 : }
43568 :
43569 : // Generated constructor (all data members)
43570 :
43571 : /* #line 43572 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43572 :
43573 :
43574 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43575 :
43576 :
43577 : // ********************************************************
43578 : // member functions common across all array grammar objects
43579 : // ********************************************************
43580 :
43581 :
43582 :
43583 : /* #line 43584 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43584 :
43585 :
43586 :
43587 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43588 :
43589 : // ********************************************************
43590 : // member functions specific to each node in the grammar
43591 : // ********************************************************
43592 :
43593 :
43594 : /* #line 43595 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43595 :
43596 : // Start of memberFunctionString
43597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
43598 :
43599 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
43600 :
43601 : SgSymbolTable*
43602 4 : SgTypeTable::get_type_table () const
43603 : {
43604 4 : ROSE_ASSERT (this != NULL);
43605 :
43606 : #if 0
43607 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
43608 : // used to trigger marking transformations for the token-based unparsing.
43609 : printf ("SgTypeTable::get_type_table = %p = %s \n",this,this->class_name().c_str());
43610 : #endif
43611 :
43612 4 : return p_type_table;
43613 : }
43614 :
43615 : void
43616 0 : SgTypeTable::set_type_table ( SgSymbolTable* type_table )
43617 : {
43618 0 : ROSE_ASSERT (this != NULL);
43619 :
43620 : #if 0
43621 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
43622 : // used to trigger marking transformations for the token-based unparsing.
43623 : printf ("SgTypeTable::set_type_table = %p = %s \n",this,this->class_name().c_str());
43624 : #endif
43625 :
43626 0 : set_isModified(true);
43627 :
43628 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
43629 : if (p_type_table != NULL && type_table != NULL && p_type_table != type_table)
43630 : {
43631 : printf ("Warning: type_table = %p overwriting valid pointer p_type_table = %p \n",type_table,p_type_table);
43632 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
43633 : printf ("Error fails assertion (p_type_table != NULL && type_table != NULL && p_type_table != type_table) is false\n");
43634 : ROSE_ASSERT(false);
43635 : #endif
43636 : }
43637 : #endif
43638 0 : p_type_table = type_table;
43639 0 : }
43640 :
43641 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
43642 :
43643 :
43644 : // End of memberFunctionString
43645 : // Start of memberFunctionString
43646 : /* #line 22746 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
43647 :
43648 :
43649 : /* \brief Hash table of types (table is stored on global scope).
43650 :
43651 : Hash table of types (table is stored on global scope and includes types
43652 : from all scopes). Types are placed into and retrieved from this data
43653 : base (simple hash table) of SgTypes.
43654 : */
43655 138601 : SgTypeTable::SgTypeTable ()
43656 : {
43657 : // DQ (2/19/2007): Use a much larger size symbol table for the function types (the input value is the hash table size, which should be a prime number)!
43658 : // p_function_type_table = new SgSymbolTable();
43659 138601 : p_type_table = new SgSymbolTable(1001);
43660 138601 : ROSE_ASSERT(p_type_table != NULL);
43661 :
43662 : // DQ (2/16/2006): Set this parent directly (now tested)
43663 138601 : p_type_table->set_parent(this);
43664 138601 : }
43665 :
43666 : #if 0
43667 : // DQ (2/19/2007): This appears to not be called but is here because
43668 : // the ROSETTA code requires it (I think).
43669 : void
43670 : SgTypeTable::post_construction_initialization()
43671 : {
43672 : }
43673 : #endif
43674 :
43675 : void
43676 0 : SgTypeTable::print_typetable(std::ostream& os)
43677 : {
43678 : // mprintf ("ERROR: Sage SgTypeTable::print_functypetable function called! \n");
43679 : // abort();
43680 :
43681 0 : os << endl << "...TypeTbl..." << endl;
43682 : // p_type_table.print(os);
43683 :
43684 0 : ROSE_ASSERT(p_type_table != NULL);
43685 : // p_type_table->print(os);
43686 0 : p_type_table->print("Called from SgTypeTable::print_typetable");
43687 0 : }
43688 :
43689 : void
43690 104658 : SgTypeTable::insert_type(const SgName& n, SgType *t)
43691 : {
43692 104658 : ROSE_ASSERT (p_type_table != NULL);
43693 104658 : ROSE_ASSERT (t != NULL);
43694 :
43695 : // DQ (7/22/2010): We might want to reuse the SgFunctionTypeSymbol or change the name of it to SgTypeSymbol
43696 104658 : SgFunctionTypeSymbol* newSymbol = new SgFunctionTypeSymbol(n,t);
43697 104658 : ROSE_ASSERT (newSymbol != NULL);
43698 : #if 0
43699 : // DQ (7/29/2010): This can sometimes fail in unparsing types. This is important becasse we now support type tables in ROSE.
43700 : mprintf ("Inside of SgTypeTable::insert_function_type(SgName,SgType*): n = %s type = %s = %s newSymbol = %p \n",
43701 : n.str(),t->sage_class_name(),t->unparseToString().c_str(),newSymbol);
43702 : #endif
43703 : #if 0
43704 : // DQ (7/29/2010): This is more robust for the new type table support.
43705 : mprintf ("Inside of SgTypeTable::insert_function_type(SgName,SgType*): n = %s type = %s newSymbol = %p \n",
43706 : n.str(),t->sage_class_name(),newSymbol);
43707 : #endif
43708 : // mprintf ("Is the qualified name being used! \n");
43709 : // ROSE_ASSERT(false);
43710 :
43711 : // DQ (7/26/2010): Set the parent of the type to it symbol.
43712 : // This is a new idea and will allow the parent pointer to be valid for all types and also
43713 : // point to something meaningful. This is another benefit of using the type table idea.
43714 104658 : t->set_parent(newSymbol);
43715 :
43716 104658 : p_type_table->insert(n, newSymbol);
43717 104658 : }
43718 :
43719 : // DQ (1/31/2007): Added support for removing function type symbols (used in AST merge)
43720 : void
43721 0 : SgTypeTable::remove_type(const SgName& n)
43722 : {
43723 0 : ROSE_ASSERT (p_type_table != NULL);
43724 0 : p_type_table->remove_function_type(n);
43725 0 : }
43726 :
43727 : #if 0
43728 : // see if this is ever used!
43729 : void
43730 : SgTypeTable::insert_type(const SgFunctionDeclaration *fdecl)
43731 : {
43732 : assert(fdecl != NULL);
43733 : mprintf ("Inside of SgTypeTable::insert_function_type(SgFunctionDeclaration = %s) \n",fdecl->get_name().str());
43734 : SgFunctionType* type = isSgFunctionType(fdecl->get_type());
43735 : ROSE_ASSERT(type != NULL);
43736 :
43737 : SgName n = type->get_mangled_type();
43738 : // mprintf ("Using function name = %s should be using qualified function type name \n",n.str());
43739 :
43740 : mprintf ("Looking up %s in function table \n",n.str());
43741 : if (lookup_function_type(n) != NULL)
43742 : {
43743 : mprintf ("Found function %s (skip reinsertion) \n",n.str());
43744 : // return; // DQ: no need for multiple return!
43745 : }
43746 : else
43747 : {
43748 : // mprintf ("Function NOT Found: so insert in table %s \n",n.str());
43749 : insert_function_type(n,type);
43750 : }
43751 : }
43752 : #endif
43753 :
43754 : SgType*
43755 282555 : SgTypeTable::lookup_type(const SgName& n)
43756 : {
43757 : #if 0
43758 : mprintf ("In SgTypeTable::lookup_type: Looking for %s \n",n.str());
43759 : #endif
43760 :
43761 282555 : ROSE_ASSERT (p_type_table != NULL);
43762 :
43763 : // SgFunctionTypeSymbol *fsymb = isSgFunctionTypeSymbol(p_function_type_table->findfunctype(n));
43764 :
43765 : #if 0
43766 : mprintf ("Is this an error: shouldn't this be looking for any type, and not just a function Type? \n");
43767 : #endif
43768 :
43769 282555 : SgSymbol *symbol = p_type_table->find_function_type(n);
43770 :
43771 : #if 0
43772 : mprintf ("In SgTypeTable::lookup_type: symbol = %p \n",symbol);
43773 : #endif
43774 :
43775 282555 : SgFunctionTypeSymbol *fsymb = isSgFunctionTypeSymbol(symbol);
43776 :
43777 282555 : SgType* returnType = NULL;
43778 :
43779 282555 : if (fsymb != NULL)
43780 : {
43781 145293 : returnType = fsymb->get_type();
43782 145293 : ROSE_ASSERT(returnType != NULL);
43783 : #if 0
43784 : mprintf ("In SgTypeTable::lookup_type(): found function type %s \n",returnType->class_name().c_str());
43785 : #endif
43786 : }
43787 :
43788 : #if 0
43789 : mprintf ("In SgTypeTable::lookup_type: returnType = %p \n",returnType);
43790 : #endif
43791 :
43792 282555 : return returnType;
43793 : }
43794 :
43795 :
43796 :
43797 : // End of memberFunctionString
43798 : // Start of memberFunctionString
43799 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
43800 :
43801 : // *** COMMON CODE SECTION BEGINS HERE ***
43802 :
43803 : #if 0
43804 : int
43805 : SgTypeTable::getVariant() const
43806 : {
43807 : // This function is used in ROSE while "variant()" is used in SAGE
43808 : assert(this != NULL);
43809 : return variant();
43810 : }
43811 : #endif
43812 :
43813 : // This function is used in ROSE in treeTraversal code
43814 : // eventually replaces getVariant() and variant()
43815 : // though after variant() has been removed for a while we will
43816 : // want to change the name of variantT() back to variant()
43817 : // (since the "T" was ment to stand for temporary).
43818 : // When this happens the variantT() will be depricated.
43819 : VariantT
43820 7959400 : SgTypeTable::variantT() const
43821 : {
43822 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
43823 7959400 : ROSE_ASSERT(this != NULL);
43824 7959400 : return V_SgTypeTable;
43825 : }
43826 :
43827 : #if 0
43828 : int
43829 : SgTypeTable::variant() const
43830 : {
43831 : // This function is used in SAGE
43832 : ROSE_ASSERT(this != NULL);
43833 : return TYPE_TABLE;
43834 : }
43835 : #endif
43836 :
43837 : ROSE_DLL_API const char*
43838 0 : SgTypeTable::sage_class_name() const
43839 : {
43840 0 : ROSE_ASSERT(this != NULL);
43841 0 : return "SgTypeTable";
43842 : }
43843 :
43844 : std::string
43845 100479 : SgTypeTable::class_name() const
43846 : {
43847 100479 : ROSE_ASSERT(this != NULL);
43848 100479 : return "SgTypeTable";
43849 : }
43850 :
43851 : // DQ (11/26/2005): Support for visitor pattern mechanims
43852 : // (inferior to ROSE traversal mechanism, experimental).
43853 : void
43854 1875170 : SgTypeTable::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
43855 : {
43856 1875170 : ROSE_ASSERT(this != NULL);
43857 1875170 : visitor.visit(this);
43858 1875170 : }
43859 :
43860 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
43861 0 : void SgTypeTable::accept (ROSE_VisitorPattern & visitor) {
43862 0 : ROSE_ASSERT(this != NULL);
43863 0 : visitor.visit(this);
43864 0 : }
43865 :
43866 : SgTypeTable*
43867 0 : SgTypeTable::addRegExpAttribute(std::string s, AstRegExAttribute* a)
43868 : {
43869 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
43870 : // This function is currently only supported for the AST used the represent Binary executables.
43871 : if (0 /* isSgAsmNode(this) != NULL */)
43872 : {
43873 : // Support for regex specification.
43874 : std::string prefixCode = "REGEX:";
43875 : addNewAttribute(prefixCode + s,a);
43876 : }
43877 : #endif
43878 :
43879 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
43880 0 : return this;
43881 : }
43882 :
43883 : // *** COMMON CODE SECTION ENDS HERE ***
43884 :
43885 :
43886 : // End of memberFunctionString
43887 : // Start of memberFunctionString
43888 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
43889 :
43890 :
43891 : #if 0
43892 : //! Error checking support
43893 : /*! Verifies the following:
43894 : - working getVariant() member function
43895 : - calls base class's error() member function
43896 : Every class has one of these functions.
43897 : */
43898 : bool
43899 : SgTypeTable::error()
43900 : {
43901 : // Put error checking here
43902 :
43903 : ROSE_ASSERT (this != NULL);
43904 : if (getVariant() != TYPE_TABLE)
43905 : {
43906 : printf ("Error in SgTypeTable::error(): SgTypeTable object has a %s variant \n",
43907 : Cxx_GrammarTerminalNames[getVariant()].name);
43908 : // printf ("Error in SgTypeTable::error() \n");
43909 : ROSE_ABORT();
43910 : }
43911 :
43912 : ROSE_ASSERT (getVariant() == TYPE_TABLE);
43913 : return SgSupport::error();
43914 : }
43915 : #endif
43916 :
43917 :
43918 :
43919 : // End of memberFunctionString
43920 :
43921 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
43922 :
43923 0 : SgTypeTable* isSgTypeTable ( SgNode* inputDerivedClassPointer )
43924 : {
43925 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
43926 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
43927 : // So to fix this we return NULL directly when the input is NULL and avoid the
43928 : // dynamic_cast in this case. This is likely a performance improvement as well.
43929 : // return dynamic_cast<SgTypeTable*>(inputDerivedClassPointer);
43930 : // Milind Chabbi (8/28/2013): isSgTypeTable uses table-driven castability instead of c++ default dynamic_cast
43931 : // this improves the running time performance by 10-20%.
43932 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeTable*>(inputDerivedClassPointer);
43933 0 : return IS_SgTypeTable_FAST_MACRO(inputDerivedClassPointer);
43934 : }
43935 :
43936 : // DQ (11/8/2003): Added version of functions taking const pointer
43937 0 : const SgTypeTable* isSgTypeTable ( const SgNode* inputDerivedClassPointer )
43938 : {
43939 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
43940 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
43941 : // So to fix this we return NULL directly when the input is NULL and avoid the
43942 : // dynamic_cast in this case. This is likely a performance improvement as well.
43943 : // return dynamic_cast<const SgTypeTable*>(inputDerivedClassPointer);
43944 : // Milind Chabbi (8/28/2013): isSgTypeTable uses table-driven castability instead of c++ default dynamic_cast
43945 : // this improves the running time performance by 10-20%.
43946 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeTable*>(inputDerivedClassPointer);
43947 0 : return IS_SgTypeTable_FAST_MACRO(inputDerivedClassPointer);
43948 : }
43949 :
43950 :
43951 :
43952 : /* #line 43953 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43953 :
43954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43955 :
43956 : /**
43957 : \brief Generated destructor
43958 :
43959 : This destructor is automatically generated (by ROSETTA). This destructor
43960 : only frees memory of data members associated with the parts of the current IR node which
43961 : are NOT traversed. Those data members that are part of a traversal can be freed using
43962 : a traversal (calling this destructor on all children in a post-order traversal). Such
43963 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
43964 :
43965 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
43966 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
43967 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
43968 :
43969 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
43970 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
43971 : pointers are not yet implemented to call delete on eash pointer in the container.
43972 : (This could be done by derivation from the STL containers to define containers that
43973 : automatically deleted their members.)
43974 :
43975 : */
43976 54458 : SgTypeTable::~SgTypeTable () {
43977 27229 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
43978 :
43979 27229 : if (p_type_table && p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_type_table; }
43980 :
43981 : // case: not a listType for type_table
43982 27229 : p_type_table = NULL; // non list case
43983 :
43984 : }
43985 :
43986 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
43987 54458 : }
43988 :
43989 :
43990 : /* #line 43991 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
43991 :
43992 :
43993 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
43994 :
43995 :
43996 : // ********************************************************
43997 : // member functions common across all array grammar objects
43998 : // ********************************************************
43999 :
44000 :
44001 :
44002 : /* #line 44003 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44003 :
44004 :
44005 :
44006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
44007 :
44008 : // ********************************************************
44009 : // member functions specific to each node in the grammar
44010 : // ********************************************************
44011 :
44012 :
44013 : /* #line 44014 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44014 :
44015 : // Start of memberFunctionString
44016 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
44017 :
44018 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
44019 :
44020 : std::string
44021 0 : SgNameGroup::get_group_name () const
44022 : {
44023 0 : ROSE_ASSERT (this != NULL);
44024 :
44025 : #if 0
44026 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44027 : // used to trigger marking transformations for the token-based unparsing.
44028 : printf ("SgNameGroup::get_group_name = %p = %s \n",this,this->class_name().c_str());
44029 : #endif
44030 :
44031 0 : return p_group_name;
44032 : }
44033 :
44034 : void
44035 0 : SgNameGroup::set_group_name ( std::string group_name )
44036 : {
44037 0 : ROSE_ASSERT (this != NULL);
44038 :
44039 : #if 0
44040 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44041 : // used to trigger marking transformations for the token-based unparsing.
44042 : printf ("SgNameGroup::set_group_name = %p = %s \n",this,this->class_name().c_str());
44043 : #endif
44044 :
44045 0 : set_isModified(true);
44046 :
44047 0 : p_group_name = group_name;
44048 0 : }
44049 :
44050 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
44051 :
44052 :
44053 : // End of memberFunctionString
44054 : // Start of memberFunctionString
44055 :
44056 :
44057 : // End of memberFunctionString
44058 : // Start of memberFunctionString
44059 : /* #line 22580 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
44060 :
44061 : const SgStringList &
44062 0 : SgNameGroup::get_name_list() const
44063 : {
44064 0 : return p_name_list;
44065 : }
44066 :
44067 : SgStringList &
44068 0 : SgNameGroup::get_name_list()
44069 : {
44070 0 : return p_name_list;
44071 : }
44072 :
44073 :
44074 : // End of memberFunctionString
44075 : // Start of memberFunctionString
44076 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
44077 :
44078 : // *** COMMON CODE SECTION BEGINS HERE ***
44079 :
44080 : #if 0
44081 : int
44082 : SgNameGroup::getVariant() const
44083 : {
44084 : // This function is used in ROSE while "variant()" is used in SAGE
44085 : assert(this != NULL);
44086 : return variant();
44087 : }
44088 : #endif
44089 :
44090 : // This function is used in ROSE in treeTraversal code
44091 : // eventually replaces getVariant() and variant()
44092 : // though after variant() has been removed for a while we will
44093 : // want to change the name of variantT() back to variant()
44094 : // (since the "T" was ment to stand for temporary).
44095 : // When this happens the variantT() will be depricated.
44096 : VariantT
44097 0 : SgNameGroup::variantT() const
44098 : {
44099 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
44100 0 : ROSE_ASSERT(this != NULL);
44101 0 : return V_SgNameGroup;
44102 : }
44103 :
44104 : #if 0
44105 : int
44106 : SgNameGroup::variant() const
44107 : {
44108 : // This function is used in SAGE
44109 : ROSE_ASSERT(this != NULL);
44110 : return TEMP_Name_Group;
44111 : }
44112 : #endif
44113 :
44114 : ROSE_DLL_API const char*
44115 0 : SgNameGroup::sage_class_name() const
44116 : {
44117 0 : ROSE_ASSERT(this != NULL);
44118 0 : return "SgNameGroup";
44119 : }
44120 :
44121 : std::string
44122 0 : SgNameGroup::class_name() const
44123 : {
44124 0 : ROSE_ASSERT(this != NULL);
44125 0 : return "SgNameGroup";
44126 : }
44127 :
44128 : // DQ (11/26/2005): Support for visitor pattern mechanims
44129 : // (inferior to ROSE traversal mechanism, experimental).
44130 : void
44131 0 : SgNameGroup::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
44132 : {
44133 0 : ROSE_ASSERT(this != NULL);
44134 0 : visitor.visit(this);
44135 0 : }
44136 :
44137 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
44138 0 : void SgNameGroup::accept (ROSE_VisitorPattern & visitor) {
44139 0 : ROSE_ASSERT(this != NULL);
44140 0 : visitor.visit(this);
44141 0 : }
44142 :
44143 : SgNameGroup*
44144 0 : SgNameGroup::addRegExpAttribute(std::string s, AstRegExAttribute* a)
44145 : {
44146 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
44147 : // This function is currently only supported for the AST used the represent Binary executables.
44148 : if (0 /* isSgAsmNode(this) != NULL */)
44149 : {
44150 : // Support for regex specification.
44151 : std::string prefixCode = "REGEX:";
44152 : addNewAttribute(prefixCode + s,a);
44153 : }
44154 : #endif
44155 :
44156 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
44157 0 : return this;
44158 : }
44159 :
44160 : // *** COMMON CODE SECTION ENDS HERE ***
44161 :
44162 :
44163 : // End of memberFunctionString
44164 : // Start of memberFunctionString
44165 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
44166 :
44167 :
44168 : #if 0
44169 : //! Error checking support
44170 : /*! Verifies the following:
44171 : - working getVariant() member function
44172 : - calls base class's error() member function
44173 : Every class has one of these functions.
44174 : */
44175 : bool
44176 : SgNameGroup::error()
44177 : {
44178 : // Put error checking here
44179 :
44180 : ROSE_ASSERT (this != NULL);
44181 : if (getVariant() != TEMP_Name_Group)
44182 : {
44183 : printf ("Error in SgNameGroup::error(): SgNameGroup object has a %s variant \n",
44184 : Cxx_GrammarTerminalNames[getVariant()].name);
44185 : // printf ("Error in SgNameGroup::error() \n");
44186 : ROSE_ABORT();
44187 : }
44188 :
44189 : ROSE_ASSERT (getVariant() == TEMP_Name_Group);
44190 : return SgSupport::error();
44191 : }
44192 : #endif
44193 :
44194 :
44195 :
44196 : // End of memberFunctionString
44197 :
44198 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
44199 :
44200 0 : SgNameGroup* isSgNameGroup ( SgNode* inputDerivedClassPointer )
44201 : {
44202 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
44203 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
44204 : // So to fix this we return NULL directly when the input is NULL and avoid the
44205 : // dynamic_cast in this case. This is likely a performance improvement as well.
44206 : // return dynamic_cast<SgNameGroup*>(inputDerivedClassPointer);
44207 : // Milind Chabbi (8/28/2013): isSgNameGroup uses table-driven castability instead of c++ default dynamic_cast
44208 : // this improves the running time performance by 10-20%.
44209 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNameGroup*>(inputDerivedClassPointer);
44210 0 : return IS_SgNameGroup_FAST_MACRO(inputDerivedClassPointer);
44211 : }
44212 :
44213 : // DQ (11/8/2003): Added version of functions taking const pointer
44214 0 : const SgNameGroup* isSgNameGroup ( const SgNode* inputDerivedClassPointer )
44215 : {
44216 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
44217 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
44218 : // So to fix this we return NULL directly when the input is NULL and avoid the
44219 : // dynamic_cast in this case. This is likely a performance improvement as well.
44220 : // return dynamic_cast<const SgNameGroup*>(inputDerivedClassPointer);
44221 : // Milind Chabbi (8/28/2013): isSgNameGroup uses table-driven castability instead of c++ default dynamic_cast
44222 : // this improves the running time performance by 10-20%.
44223 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNameGroup*>(inputDerivedClassPointer);
44224 0 : return IS_SgNameGroup_FAST_MACRO(inputDerivedClassPointer);
44225 : }
44226 :
44227 :
44228 :
44229 : /* #line 44230 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44230 :
44231 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
44232 :
44233 : /**
44234 : \brief Generated destructor
44235 :
44236 : This destructor is automatically generated (by ROSETTA). This destructor
44237 : only frees memory of data members associated with the parts of the current IR node which
44238 : are NOT traversed. Those data members that are part of a traversal can be freed using
44239 : a traversal (calling this destructor on all children in a post-order traversal). Such
44240 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
44241 :
44242 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
44243 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
44244 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
44245 :
44246 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
44247 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
44248 : pointers are not yet implemented to call delete on eash pointer in the container.
44249 : (This could be done by derivation from the STL containers to define containers that
44250 : automatically deleted their members.)
44251 :
44252 : */
44253 0 : SgNameGroup::~SgNameGroup () {
44254 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
44255 :
44256 :
44257 : // case: not a listType for group_name
44258 0 : p_group_name =""; // non list case
44259 :
44260 : }
44261 :
44262 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
44263 0 : }
44264 :
44265 :
44266 : /* #line 44267 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44267 :
44268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
44269 :
44270 : // Generated constructor
44271 0 : SgNameGroup::SgNameGroup ( )
44272 0 : : SgSupport()
44273 : {
44274 : #ifdef DEBUG
44275 : // printf ("In SgNameGroup::SgNameGroup () sage_class_name() = %s \n",sage_class_name());
44276 : #endif
44277 : #if 0
44278 : // debugging information!
44279 : printf ("In SgNameGroup::SgNameGroup (): this = %p = %s \n",this,this->class_name().c_str());
44280 : #endif
44281 :
44282 0 : p_group_name ="";
44283 :
44284 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
44285 :
44286 : #if 0
44287 : // DQ (7/30/2014): Call a virtual function.
44288 : std::string s = this->class_name();
44289 : #endif
44290 :
44291 : // Test the variant virtual function
44292 : // assert(TEMP_Name_Group == variant());
44293 0 : assert(TEMP_Name_Group == this->variant());
44294 0 : ROSE_ASSERT(TEMP_Name_Group == (int)(this->variantT()));
44295 0 : post_construction_initialization();
44296 :
44297 : // Test the isSgNameGroup() function since it has been problematic
44298 0 : assert(isSgNameGroup(this) != NULL);
44299 0 : }
44300 :
44301 : // Generated constructor (all data members)
44302 :
44303 : /* #line 44304 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44304 :
44305 :
44306 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
44307 :
44308 :
44309 : // ********************************************************
44310 : // member functions common across all array grammar objects
44311 : // ********************************************************
44312 :
44313 :
44314 :
44315 : /* #line 44316 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44316 :
44317 :
44318 :
44319 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
44320 :
44321 : // ********************************************************
44322 : // member functions specific to each node in the grammar
44323 : // ********************************************************
44324 :
44325 :
44326 : /* #line 44327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44327 :
44328 : // Start of memberFunctionString
44329 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
44330 :
44331 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
44332 :
44333 : SgInitializedName*
44334 0 : SgDimensionObject::get_array () const
44335 : {
44336 0 : ROSE_ASSERT (this != NULL);
44337 :
44338 : #if 0
44339 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44340 : // used to trigger marking transformations for the token-based unparsing.
44341 : printf ("SgDimensionObject::get_array = %p = %s \n",this,this->class_name().c_str());
44342 : #endif
44343 :
44344 0 : return p_array;
44345 : }
44346 :
44347 : void
44348 0 : SgDimensionObject::set_array ( SgInitializedName* array )
44349 : {
44350 0 : ROSE_ASSERT (this != NULL);
44351 :
44352 : #if 0
44353 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44354 : // used to trigger marking transformations for the token-based unparsing.
44355 : printf ("SgDimensionObject::set_array = %p = %s \n",this,this->class_name().c_str());
44356 : #endif
44357 :
44358 0 : set_isModified(true);
44359 :
44360 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
44361 : if (p_array != NULL && array != NULL && p_array != array)
44362 : {
44363 : printf ("Warning: array = %p overwriting valid pointer p_array = %p \n",array,p_array);
44364 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
44365 : printf ("Error fails assertion (p_array != NULL && array != NULL && p_array != array) is false\n");
44366 : ROSE_ASSERT(false);
44367 : #endif
44368 : }
44369 : #endif
44370 0 : p_array = array;
44371 0 : }
44372 :
44373 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
44374 :
44375 :
44376 : // End of memberFunctionString
44377 : // Start of memberFunctionString
44378 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
44379 :
44380 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
44381 :
44382 : SgExprListExp*
44383 0 : SgDimensionObject::get_shape () const
44384 : {
44385 0 : ROSE_ASSERT (this != NULL);
44386 :
44387 : #if 0
44388 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44389 : // used to trigger marking transformations for the token-based unparsing.
44390 : printf ("SgDimensionObject::get_shape = %p = %s \n",this,this->class_name().c_str());
44391 : #endif
44392 :
44393 0 : return p_shape;
44394 : }
44395 :
44396 : void
44397 0 : SgDimensionObject::set_shape ( SgExprListExp* shape )
44398 : {
44399 0 : ROSE_ASSERT (this != NULL);
44400 :
44401 : #if 0
44402 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44403 : // used to trigger marking transformations for the token-based unparsing.
44404 : printf ("SgDimensionObject::set_shape = %p = %s \n",this,this->class_name().c_str());
44405 : #endif
44406 :
44407 0 : set_isModified(true);
44408 :
44409 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
44410 : if (p_shape != NULL && shape != NULL && p_shape != shape)
44411 : {
44412 : printf ("Warning: shape = %p overwriting valid pointer p_shape = %p \n",shape,p_shape);
44413 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
44414 : printf ("Error fails assertion (p_shape != NULL && shape != NULL && p_shape != shape) is false\n");
44415 : ROSE_ASSERT(false);
44416 : #endif
44417 : }
44418 : #endif
44419 0 : p_shape = shape;
44420 0 : }
44421 :
44422 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
44423 :
44424 :
44425 : // End of memberFunctionString
44426 : // Start of memberFunctionString
44427 : /* #line 22599 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
44428 :
44429 :
44430 :
44431 : // End of memberFunctionString
44432 : // Start of memberFunctionString
44433 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
44434 :
44435 : // *** COMMON CODE SECTION BEGINS HERE ***
44436 :
44437 : #if 0
44438 : int
44439 : SgDimensionObject::getVariant() const
44440 : {
44441 : // This function is used in ROSE while "variant()" is used in SAGE
44442 : assert(this != NULL);
44443 : return variant();
44444 : }
44445 : #endif
44446 :
44447 : // This function is used in ROSE in treeTraversal code
44448 : // eventually replaces getVariant() and variant()
44449 : // though after variant() has been removed for a while we will
44450 : // want to change the name of variantT() back to variant()
44451 : // (since the "T" was ment to stand for temporary).
44452 : // When this happens the variantT() will be depricated.
44453 : VariantT
44454 0 : SgDimensionObject::variantT() const
44455 : {
44456 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
44457 0 : ROSE_ASSERT(this != NULL);
44458 0 : return V_SgDimensionObject;
44459 : }
44460 :
44461 : #if 0
44462 : int
44463 : SgDimensionObject::variant() const
44464 : {
44465 : // This function is used in SAGE
44466 : ROSE_ASSERT(this != NULL);
44467 : return TEMP_DimensionObject;
44468 : }
44469 : #endif
44470 :
44471 : ROSE_DLL_API const char*
44472 0 : SgDimensionObject::sage_class_name() const
44473 : {
44474 0 : ROSE_ASSERT(this != NULL);
44475 0 : return "SgDimensionObject";
44476 : }
44477 :
44478 : std::string
44479 0 : SgDimensionObject::class_name() const
44480 : {
44481 0 : ROSE_ASSERT(this != NULL);
44482 0 : return "SgDimensionObject";
44483 : }
44484 :
44485 : // DQ (11/26/2005): Support for visitor pattern mechanims
44486 : // (inferior to ROSE traversal mechanism, experimental).
44487 : void
44488 0 : SgDimensionObject::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
44489 : {
44490 0 : ROSE_ASSERT(this != NULL);
44491 0 : visitor.visit(this);
44492 0 : }
44493 :
44494 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
44495 0 : void SgDimensionObject::accept (ROSE_VisitorPattern & visitor) {
44496 0 : ROSE_ASSERT(this != NULL);
44497 0 : visitor.visit(this);
44498 0 : }
44499 :
44500 : SgDimensionObject*
44501 0 : SgDimensionObject::addRegExpAttribute(std::string s, AstRegExAttribute* a)
44502 : {
44503 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
44504 : // This function is currently only supported for the AST used the represent Binary executables.
44505 : if (0 /* isSgAsmNode(this) != NULL */)
44506 : {
44507 : // Support for regex specification.
44508 : std::string prefixCode = "REGEX:";
44509 : addNewAttribute(prefixCode + s,a);
44510 : }
44511 : #endif
44512 :
44513 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
44514 0 : return this;
44515 : }
44516 :
44517 : // *** COMMON CODE SECTION ENDS HERE ***
44518 :
44519 :
44520 : // End of memberFunctionString
44521 : // Start of memberFunctionString
44522 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
44523 :
44524 :
44525 : #if 0
44526 : //! Error checking support
44527 : /*! Verifies the following:
44528 : - working getVariant() member function
44529 : - calls base class's error() member function
44530 : Every class has one of these functions.
44531 : */
44532 : bool
44533 : SgDimensionObject::error()
44534 : {
44535 : // Put error checking here
44536 :
44537 : ROSE_ASSERT (this != NULL);
44538 : if (getVariant() != TEMP_DimensionObject)
44539 : {
44540 : printf ("Error in SgDimensionObject::error(): SgDimensionObject object has a %s variant \n",
44541 : Cxx_GrammarTerminalNames[getVariant()].name);
44542 : // printf ("Error in SgDimensionObject::error() \n");
44543 : ROSE_ABORT();
44544 : }
44545 :
44546 : ROSE_ASSERT (getVariant() == TEMP_DimensionObject);
44547 : return SgSupport::error();
44548 : }
44549 : #endif
44550 :
44551 :
44552 :
44553 : // End of memberFunctionString
44554 :
44555 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
44556 :
44557 0 : SgDimensionObject* isSgDimensionObject ( SgNode* inputDerivedClassPointer )
44558 : {
44559 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
44560 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
44561 : // So to fix this we return NULL directly when the input is NULL and avoid the
44562 : // dynamic_cast in this case. This is likely a performance improvement as well.
44563 : // return dynamic_cast<SgDimensionObject*>(inputDerivedClassPointer);
44564 : // Milind Chabbi (8/28/2013): isSgDimensionObject uses table-driven castability instead of c++ default dynamic_cast
44565 : // this improves the running time performance by 10-20%.
44566 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDimensionObject*>(inputDerivedClassPointer);
44567 0 : return IS_SgDimensionObject_FAST_MACRO(inputDerivedClassPointer);
44568 : }
44569 :
44570 : // DQ (11/8/2003): Added version of functions taking const pointer
44571 0 : const SgDimensionObject* isSgDimensionObject ( const SgNode* inputDerivedClassPointer )
44572 : {
44573 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
44574 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
44575 : // So to fix this we return NULL directly when the input is NULL and avoid the
44576 : // dynamic_cast in this case. This is likely a performance improvement as well.
44577 : // return dynamic_cast<const SgDimensionObject*>(inputDerivedClassPointer);
44578 : // Milind Chabbi (8/28/2013): isSgDimensionObject uses table-driven castability instead of c++ default dynamic_cast
44579 : // this improves the running time performance by 10-20%.
44580 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDimensionObject*>(inputDerivedClassPointer);
44581 0 : return IS_SgDimensionObject_FAST_MACRO(inputDerivedClassPointer);
44582 : }
44583 :
44584 :
44585 :
44586 : /* #line 44587 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44587 :
44588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
44589 :
44590 : /**
44591 : \brief Generated destructor
44592 :
44593 : This destructor is automatically generated (by ROSETTA). This destructor
44594 : only frees memory of data members associated with the parts of the current IR node which
44595 : are NOT traversed. Those data members that are part of a traversal can be freed using
44596 : a traversal (calling this destructor on all children in a post-order traversal). Such
44597 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
44598 :
44599 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
44600 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
44601 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
44602 :
44603 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
44604 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
44605 : pointers are not yet implemented to call delete on eash pointer in the container.
44606 : (This could be done by derivation from the STL containers to define containers that
44607 : automatically deleted their members.)
44608 :
44609 : */
44610 0 : SgDimensionObject::~SgDimensionObject () {
44611 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
44612 :
44613 :
44614 : // case: not a listType for array
44615 0 : p_array = NULL; // non list case
44616 : // case: not a listType for shape
44617 0 : p_shape = NULL; // non list case
44618 :
44619 : }
44620 :
44621 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
44622 0 : }
44623 :
44624 :
44625 : /* #line 44626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44626 :
44627 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
44628 :
44629 : // Generated constructor
44630 0 : SgDimensionObject::SgDimensionObject ( )
44631 0 : : SgSupport()
44632 : {
44633 : #ifdef DEBUG
44634 : // printf ("In SgDimensionObject::SgDimensionObject () sage_class_name() = %s \n",sage_class_name());
44635 : #endif
44636 : #if 0
44637 : // debugging information!
44638 : printf ("In SgDimensionObject::SgDimensionObject (): this = %p = %s \n",this,this->class_name().c_str());
44639 : #endif
44640 :
44641 0 : p_array = NULL;
44642 0 : p_shape = NULL;
44643 :
44644 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
44645 :
44646 : #if 0
44647 : // DQ (7/30/2014): Call a virtual function.
44648 : std::string s = this->class_name();
44649 : #endif
44650 :
44651 : // Test the variant virtual function
44652 : // assert(TEMP_DimensionObject == variant());
44653 0 : assert(TEMP_DimensionObject == this->variant());
44654 0 : ROSE_ASSERT(TEMP_DimensionObject == (int)(this->variantT()));
44655 0 : post_construction_initialization();
44656 :
44657 : // Test the isSgDimensionObject() function since it has been problematic
44658 0 : assert(isSgDimensionObject(this) != NULL);
44659 0 : }
44660 :
44661 : // Generated constructor (all data members)
44662 :
44663 : /* #line 44664 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44664 :
44665 :
44666 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
44667 :
44668 :
44669 : // ********************************************************
44670 : // member functions common across all array grammar objects
44671 : // ********************************************************
44672 :
44673 :
44674 :
44675 : /* #line 44676 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44676 :
44677 :
44678 :
44679 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
44680 :
44681 : // ********************************************************
44682 : // member functions specific to each node in the grammar
44683 : // ********************************************************
44684 :
44685 :
44686 : /* #line 44687 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44687 :
44688 : // Start of memberFunctionString
44689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
44690 :
44691 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
44692 :
44693 : int
44694 0 : SgFormatItem::get_repeat_specification () const
44695 : {
44696 0 : ROSE_ASSERT (this != NULL);
44697 :
44698 : #if 0
44699 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44700 : // used to trigger marking transformations for the token-based unparsing.
44701 : printf ("SgFormatItem::get_repeat_specification = %p = %s \n",this,this->class_name().c_str());
44702 : #endif
44703 :
44704 0 : return p_repeat_specification;
44705 : }
44706 :
44707 : void
44708 0 : SgFormatItem::set_repeat_specification ( int repeat_specification )
44709 : {
44710 0 : ROSE_ASSERT (this != NULL);
44711 :
44712 : #if 0
44713 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44714 : // used to trigger marking transformations for the token-based unparsing.
44715 : printf ("SgFormatItem::set_repeat_specification = %p = %s \n",this,this->class_name().c_str());
44716 : #endif
44717 :
44718 0 : set_isModified(true);
44719 :
44720 0 : p_repeat_specification = repeat_specification;
44721 0 : }
44722 :
44723 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
44724 :
44725 :
44726 : // End of memberFunctionString
44727 : // Start of memberFunctionString
44728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
44729 :
44730 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
44731 :
44732 : SgExpression*
44733 0 : SgFormatItem::get_data () const
44734 : {
44735 0 : ROSE_ASSERT (this != NULL);
44736 :
44737 : #if 0
44738 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44739 : // used to trigger marking transformations for the token-based unparsing.
44740 : printf ("SgFormatItem::get_data = %p = %s \n",this,this->class_name().c_str());
44741 : #endif
44742 :
44743 0 : return p_data;
44744 : }
44745 :
44746 : void
44747 0 : SgFormatItem::set_data ( SgExpression* data )
44748 : {
44749 0 : ROSE_ASSERT (this != NULL);
44750 :
44751 : #if 0
44752 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44753 : // used to trigger marking transformations for the token-based unparsing.
44754 : printf ("SgFormatItem::set_data = %p = %s \n",this,this->class_name().c_str());
44755 : #endif
44756 :
44757 0 : set_isModified(true);
44758 :
44759 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
44760 : if (p_data != NULL && data != NULL && p_data != data)
44761 : {
44762 : printf ("Warning: data = %p overwriting valid pointer p_data = %p \n",data,p_data);
44763 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
44764 : printf ("Error fails assertion (p_data != NULL && data != NULL && p_data != data) is false\n");
44765 : ROSE_ASSERT(false);
44766 : #endif
44767 : }
44768 : #endif
44769 0 : p_data = data;
44770 0 : }
44771 :
44772 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
44773 :
44774 :
44775 : // End of memberFunctionString
44776 : // Start of memberFunctionString
44777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
44778 :
44779 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
44780 :
44781 : SgFormatItemList*
44782 0 : SgFormatItem::get_format_item_list () const
44783 : {
44784 0 : ROSE_ASSERT (this != NULL);
44785 :
44786 : #if 0
44787 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44788 : // used to trigger marking transformations for the token-based unparsing.
44789 : printf ("SgFormatItem::get_format_item_list = %p = %s \n",this,this->class_name().c_str());
44790 : #endif
44791 :
44792 0 : return p_format_item_list;
44793 : }
44794 :
44795 : void
44796 0 : SgFormatItem::set_format_item_list ( SgFormatItemList* format_item_list )
44797 : {
44798 0 : ROSE_ASSERT (this != NULL);
44799 :
44800 : #if 0
44801 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
44802 : // used to trigger marking transformations for the token-based unparsing.
44803 : printf ("SgFormatItem::set_format_item_list = %p = %s \n",this,this->class_name().c_str());
44804 : #endif
44805 :
44806 0 : set_isModified(true);
44807 :
44808 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
44809 : if (p_format_item_list != NULL && format_item_list != NULL && p_format_item_list != format_item_list)
44810 : {
44811 : printf ("Warning: format_item_list = %p overwriting valid pointer p_format_item_list = %p \n",format_item_list,p_format_item_list);
44812 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
44813 : printf ("Error fails assertion (p_format_item_list != NULL && format_item_list != NULL && p_format_item_list != format_item_list) is false\n");
44814 : ROSE_ASSERT(false);
44815 : #endif
44816 : }
44817 : #endif
44818 0 : p_format_item_list = format_item_list;
44819 0 : }
44820 :
44821 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
44822 :
44823 :
44824 : // End of memberFunctionString
44825 : // Start of memberFunctionString
44826 : /* #line 22652 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
44827 :
44828 :
44829 :
44830 : // End of memberFunctionString
44831 : // Start of memberFunctionString
44832 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
44833 :
44834 : // *** COMMON CODE SECTION BEGINS HERE ***
44835 :
44836 : #if 0
44837 : int
44838 : SgFormatItem::getVariant() const
44839 : {
44840 : // This function is used in ROSE while "variant()" is used in SAGE
44841 : assert(this != NULL);
44842 : return variant();
44843 : }
44844 : #endif
44845 :
44846 : // This function is used in ROSE in treeTraversal code
44847 : // eventually replaces getVariant() and variant()
44848 : // though after variant() has been removed for a while we will
44849 : // want to change the name of variantT() back to variant()
44850 : // (since the "T" was ment to stand for temporary).
44851 : // When this happens the variantT() will be depricated.
44852 : VariantT
44853 0 : SgFormatItem::variantT() const
44854 : {
44855 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
44856 0 : ROSE_ASSERT(this != NULL);
44857 0 : return V_SgFormatItem;
44858 : }
44859 :
44860 : #if 0
44861 : int
44862 : SgFormatItem::variant() const
44863 : {
44864 : // This function is used in SAGE
44865 : ROSE_ASSERT(this != NULL);
44866 : return TEMP_FormatItem;
44867 : }
44868 : #endif
44869 :
44870 : ROSE_DLL_API const char*
44871 0 : SgFormatItem::sage_class_name() const
44872 : {
44873 0 : ROSE_ASSERT(this != NULL);
44874 0 : return "SgFormatItem";
44875 : }
44876 :
44877 : std::string
44878 0 : SgFormatItem::class_name() const
44879 : {
44880 0 : ROSE_ASSERT(this != NULL);
44881 0 : return "SgFormatItem";
44882 : }
44883 :
44884 : // DQ (11/26/2005): Support for visitor pattern mechanims
44885 : // (inferior to ROSE traversal mechanism, experimental).
44886 : void
44887 0 : SgFormatItem::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
44888 : {
44889 0 : ROSE_ASSERT(this != NULL);
44890 0 : visitor.visit(this);
44891 0 : }
44892 :
44893 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
44894 0 : void SgFormatItem::accept (ROSE_VisitorPattern & visitor) {
44895 0 : ROSE_ASSERT(this != NULL);
44896 0 : visitor.visit(this);
44897 0 : }
44898 :
44899 : SgFormatItem*
44900 0 : SgFormatItem::addRegExpAttribute(std::string s, AstRegExAttribute* a)
44901 : {
44902 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
44903 : // This function is currently only supported for the AST used the represent Binary executables.
44904 : if (0 /* isSgAsmNode(this) != NULL */)
44905 : {
44906 : // Support for regex specification.
44907 : std::string prefixCode = "REGEX:";
44908 : addNewAttribute(prefixCode + s,a);
44909 : }
44910 : #endif
44911 :
44912 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
44913 0 : return this;
44914 : }
44915 :
44916 : // *** COMMON CODE SECTION ENDS HERE ***
44917 :
44918 :
44919 : // End of memberFunctionString
44920 : // Start of memberFunctionString
44921 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
44922 :
44923 :
44924 : #if 0
44925 : //! Error checking support
44926 : /*! Verifies the following:
44927 : - working getVariant() member function
44928 : - calls base class's error() member function
44929 : Every class has one of these functions.
44930 : */
44931 : bool
44932 : SgFormatItem::error()
44933 : {
44934 : // Put error checking here
44935 :
44936 : ROSE_ASSERT (this != NULL);
44937 : if (getVariant() != TEMP_FormatItem)
44938 : {
44939 : printf ("Error in SgFormatItem::error(): SgFormatItem object has a %s variant \n",
44940 : Cxx_GrammarTerminalNames[getVariant()].name);
44941 : // printf ("Error in SgFormatItem::error() \n");
44942 : ROSE_ABORT();
44943 : }
44944 :
44945 : ROSE_ASSERT (getVariant() == TEMP_FormatItem);
44946 : return SgSupport::error();
44947 : }
44948 : #endif
44949 :
44950 :
44951 :
44952 : // End of memberFunctionString
44953 :
44954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
44955 :
44956 0 : SgFormatItem* isSgFormatItem ( SgNode* inputDerivedClassPointer )
44957 : {
44958 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
44959 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
44960 : // So to fix this we return NULL directly when the input is NULL and avoid the
44961 : // dynamic_cast in this case. This is likely a performance improvement as well.
44962 : // return dynamic_cast<SgFormatItem*>(inputDerivedClassPointer);
44963 : // Milind Chabbi (8/28/2013): isSgFormatItem uses table-driven castability instead of c++ default dynamic_cast
44964 : // this improves the running time performance by 10-20%.
44965 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFormatItem*>(inputDerivedClassPointer);
44966 0 : return IS_SgFormatItem_FAST_MACRO(inputDerivedClassPointer);
44967 : }
44968 :
44969 : // DQ (11/8/2003): Added version of functions taking const pointer
44970 0 : const SgFormatItem* isSgFormatItem ( const SgNode* inputDerivedClassPointer )
44971 : {
44972 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
44973 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
44974 : // So to fix this we return NULL directly when the input is NULL and avoid the
44975 : // dynamic_cast in this case. This is likely a performance improvement as well.
44976 : // return dynamic_cast<const SgFormatItem*>(inputDerivedClassPointer);
44977 : // Milind Chabbi (8/28/2013): isSgFormatItem uses table-driven castability instead of c++ default dynamic_cast
44978 : // this improves the running time performance by 10-20%.
44979 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFormatItem*>(inputDerivedClassPointer);
44980 0 : return IS_SgFormatItem_FAST_MACRO(inputDerivedClassPointer);
44981 : }
44982 :
44983 :
44984 :
44985 : /* #line 44986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
44986 :
44987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
44988 :
44989 : /**
44990 : \brief Generated destructor
44991 :
44992 : This destructor is automatically generated (by ROSETTA). This destructor
44993 : only frees memory of data members associated with the parts of the current IR node which
44994 : are NOT traversed. Those data members that are part of a traversal can be freed using
44995 : a traversal (calling this destructor on all children in a post-order traversal). Such
44996 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
44997 :
44998 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
44999 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
45000 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
45001 :
45002 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
45003 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
45004 : pointers are not yet implemented to call delete on eash pointer in the container.
45005 : (This could be done by derivation from the STL containers to define containers that
45006 : automatically deleted their members.)
45007 :
45008 : */
45009 0 : SgFormatItem::~SgFormatItem () {
45010 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
45011 :
45012 :
45013 : // case: not a listType for repeat_specification
45014 0 : p_repeat_specification = -1; // non list case
45015 : // case: not a listType for data
45016 0 : p_data = NULL; // non list case
45017 : // case: not a listType for format_item_list
45018 0 : p_format_item_list = NULL; // non list case
45019 :
45020 : }
45021 :
45022 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45023 0 : }
45024 :
45025 :
45026 : /* #line 45027 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45027 :
45028 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
45029 :
45030 : // Generated constructor
45031 0 : SgFormatItem::SgFormatItem ( )
45032 0 : : SgSupport()
45033 : {
45034 : #ifdef DEBUG
45035 : // printf ("In SgFormatItem::SgFormatItem () sage_class_name() = %s \n",sage_class_name());
45036 : #endif
45037 : #if 0
45038 : // debugging information!
45039 : printf ("In SgFormatItem::SgFormatItem (): this = %p = %s \n",this,this->class_name().c_str());
45040 : #endif
45041 :
45042 0 : p_repeat_specification = -1;
45043 0 : p_data = NULL;
45044 0 : p_format_item_list = NULL;
45045 :
45046 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
45047 :
45048 : #if 0
45049 : // DQ (7/30/2014): Call a virtual function.
45050 : std::string s = this->class_name();
45051 : #endif
45052 :
45053 : // Test the variant virtual function
45054 : // assert(TEMP_FormatItem == variant());
45055 0 : assert(TEMP_FormatItem == this->variant());
45056 0 : ROSE_ASSERT(TEMP_FormatItem == (int)(this->variantT()));
45057 0 : post_construction_initialization();
45058 :
45059 : // Test the isSgFormatItem() function since it has been problematic
45060 0 : assert(isSgFormatItem(this) != NULL);
45061 0 : }
45062 :
45063 : // Generated constructor (all data members)
45064 :
45065 : /* #line 45066 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45066 :
45067 :
45068 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45069 :
45070 :
45071 : // ********************************************************
45072 : // member functions common across all array grammar objects
45073 : // ********************************************************
45074 :
45075 :
45076 :
45077 : /* #line 45078 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45078 :
45079 :
45080 :
45081 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45082 :
45083 : // ********************************************************
45084 : // member functions specific to each node in the grammar
45085 : // ********************************************************
45086 :
45087 :
45088 : /* #line 45089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45089 :
45090 : // Start of memberFunctionString
45091 :
45092 :
45093 : // End of memberFunctionString
45094 : // Start of memberFunctionString
45095 : /* #line 22656 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
45096 :
45097 :
45098 : const SgFormatItemPtrList &
45099 0 : SgFormatItemList::get_format_item_list() const
45100 : {
45101 0 : return p_format_item_list;
45102 : }
45103 :
45104 : SgFormatItemPtrList &
45105 0 : SgFormatItemList::get_format_item_list()
45106 : {
45107 0 : return p_format_item_list;
45108 : }
45109 :
45110 : void
45111 0 : SgFormatItemList::set_format_item_list ( const SgFormatItemPtrList & formatItemList )
45112 : {
45113 0 : p_format_item_list = formatItemList;
45114 0 : }
45115 :
45116 :
45117 :
45118 :
45119 : // End of memberFunctionString
45120 : // Start of memberFunctionString
45121 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
45122 :
45123 : // *** COMMON CODE SECTION BEGINS HERE ***
45124 :
45125 : #if 0
45126 : int
45127 : SgFormatItemList::getVariant() const
45128 : {
45129 : // This function is used in ROSE while "variant()" is used in SAGE
45130 : assert(this != NULL);
45131 : return variant();
45132 : }
45133 : #endif
45134 :
45135 : // This function is used in ROSE in treeTraversal code
45136 : // eventually replaces getVariant() and variant()
45137 : // though after variant() has been removed for a while we will
45138 : // want to change the name of variantT() back to variant()
45139 : // (since the "T" was ment to stand for temporary).
45140 : // When this happens the variantT() will be depricated.
45141 : VariantT
45142 0 : SgFormatItemList::variantT() const
45143 : {
45144 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
45145 0 : ROSE_ASSERT(this != NULL);
45146 0 : return V_SgFormatItemList;
45147 : }
45148 :
45149 : #if 0
45150 : int
45151 : SgFormatItemList::variant() const
45152 : {
45153 : // This function is used in SAGE
45154 : ROSE_ASSERT(this != NULL);
45155 : return TEMP_FormatItemList;
45156 : }
45157 : #endif
45158 :
45159 : ROSE_DLL_API const char*
45160 0 : SgFormatItemList::sage_class_name() const
45161 : {
45162 0 : ROSE_ASSERT(this != NULL);
45163 0 : return "SgFormatItemList";
45164 : }
45165 :
45166 : std::string
45167 0 : SgFormatItemList::class_name() const
45168 : {
45169 0 : ROSE_ASSERT(this != NULL);
45170 0 : return "SgFormatItemList";
45171 : }
45172 :
45173 : // DQ (11/26/2005): Support for visitor pattern mechanims
45174 : // (inferior to ROSE traversal mechanism, experimental).
45175 : void
45176 0 : SgFormatItemList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
45177 : {
45178 0 : ROSE_ASSERT(this != NULL);
45179 0 : visitor.visit(this);
45180 0 : }
45181 :
45182 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
45183 0 : void SgFormatItemList::accept (ROSE_VisitorPattern & visitor) {
45184 0 : ROSE_ASSERT(this != NULL);
45185 0 : visitor.visit(this);
45186 0 : }
45187 :
45188 : SgFormatItemList*
45189 0 : SgFormatItemList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
45190 : {
45191 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
45192 : // This function is currently only supported for the AST used the represent Binary executables.
45193 : if (0 /* isSgAsmNode(this) != NULL */)
45194 : {
45195 : // Support for regex specification.
45196 : std::string prefixCode = "REGEX:";
45197 : addNewAttribute(prefixCode + s,a);
45198 : }
45199 : #endif
45200 :
45201 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
45202 0 : return this;
45203 : }
45204 :
45205 : // *** COMMON CODE SECTION ENDS HERE ***
45206 :
45207 :
45208 : // End of memberFunctionString
45209 : // Start of memberFunctionString
45210 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
45211 :
45212 :
45213 : #if 0
45214 : //! Error checking support
45215 : /*! Verifies the following:
45216 : - working getVariant() member function
45217 : - calls base class's error() member function
45218 : Every class has one of these functions.
45219 : */
45220 : bool
45221 : SgFormatItemList::error()
45222 : {
45223 : // Put error checking here
45224 :
45225 : ROSE_ASSERT (this != NULL);
45226 : if (getVariant() != TEMP_FormatItemList)
45227 : {
45228 : printf ("Error in SgFormatItemList::error(): SgFormatItemList object has a %s variant \n",
45229 : Cxx_GrammarTerminalNames[getVariant()].name);
45230 : // printf ("Error in SgFormatItemList::error() \n");
45231 : ROSE_ABORT();
45232 : }
45233 :
45234 : ROSE_ASSERT (getVariant() == TEMP_FormatItemList);
45235 : return SgSupport::error();
45236 : }
45237 : #endif
45238 :
45239 :
45240 :
45241 : // End of memberFunctionString
45242 :
45243 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
45244 :
45245 0 : SgFormatItemList* isSgFormatItemList ( SgNode* inputDerivedClassPointer )
45246 : {
45247 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
45248 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
45249 : // So to fix this we return NULL directly when the input is NULL and avoid the
45250 : // dynamic_cast in this case. This is likely a performance improvement as well.
45251 : // return dynamic_cast<SgFormatItemList*>(inputDerivedClassPointer);
45252 : // Milind Chabbi (8/28/2013): isSgFormatItemList uses table-driven castability instead of c++ default dynamic_cast
45253 : // this improves the running time performance by 10-20%.
45254 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFormatItemList*>(inputDerivedClassPointer);
45255 0 : return IS_SgFormatItemList_FAST_MACRO(inputDerivedClassPointer);
45256 : }
45257 :
45258 : // DQ (11/8/2003): Added version of functions taking const pointer
45259 0 : const SgFormatItemList* isSgFormatItemList ( const SgNode* inputDerivedClassPointer )
45260 : {
45261 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
45262 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
45263 : // So to fix this we return NULL directly when the input is NULL and avoid the
45264 : // dynamic_cast in this case. This is likely a performance improvement as well.
45265 : // return dynamic_cast<const SgFormatItemList*>(inputDerivedClassPointer);
45266 : // Milind Chabbi (8/28/2013): isSgFormatItemList uses table-driven castability instead of c++ default dynamic_cast
45267 : // this improves the running time performance by 10-20%.
45268 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFormatItemList*>(inputDerivedClassPointer);
45269 0 : return IS_SgFormatItemList_FAST_MACRO(inputDerivedClassPointer);
45270 : }
45271 :
45272 :
45273 :
45274 : /* #line 45275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45275 :
45276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45277 :
45278 : /**
45279 : \brief Generated destructor
45280 :
45281 : This destructor is automatically generated (by ROSETTA). This destructor
45282 : only frees memory of data members associated with the parts of the current IR node which
45283 : are NOT traversed. Those data members that are part of a traversal can be freed using
45284 : a traversal (calling this destructor on all children in a post-order traversal). Such
45285 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
45286 :
45287 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
45288 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
45289 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
45290 :
45291 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
45292 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
45293 : pointers are not yet implemented to call delete on eash pointer in the container.
45294 : (This could be done by derivation from the STL containers to define containers that
45295 : automatically deleted their members.)
45296 :
45297 : */
45298 0 : SgFormatItemList::~SgFormatItemList () {
45299 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
45300 :
45301 :
45302 :
45303 : }
45304 :
45305 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45306 0 : }
45307 :
45308 :
45309 : /* #line 45310 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45310 :
45311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
45312 :
45313 : // Generated constructor
45314 0 : SgFormatItemList::SgFormatItemList ( )
45315 0 : : SgSupport()
45316 : {
45317 : #ifdef DEBUG
45318 : // printf ("In SgFormatItemList::SgFormatItemList () sage_class_name() = %s \n",sage_class_name());
45319 : #endif
45320 : #if 0
45321 : // debugging information!
45322 : printf ("In SgFormatItemList::SgFormatItemList (): this = %p = %s \n",this,this->class_name().c_str());
45323 : #endif
45324 :
45325 :
45326 :
45327 : #if 0
45328 : // DQ (7/30/2014): Call a virtual function.
45329 : std::string s = this->class_name();
45330 : #endif
45331 :
45332 : // Test the variant virtual function
45333 : // assert(TEMP_FormatItemList == variant());
45334 0 : assert(TEMP_FormatItemList == this->variant());
45335 0 : ROSE_ASSERT(TEMP_FormatItemList == (int)(this->variantT()));
45336 0 : post_construction_initialization();
45337 :
45338 : // Test the isSgFormatItemList() function since it has been problematic
45339 0 : assert(isSgFormatItemList(this) != NULL);
45340 0 : }
45341 :
45342 : // Generated constructor (all data members)
45343 :
45344 : /* #line 45345 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45345 :
45346 :
45347 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45348 :
45349 :
45350 : // ********************************************************
45351 : // member functions common across all array grammar objects
45352 : // ********************************************************
45353 :
45354 :
45355 :
45356 : /* #line 45357 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45357 :
45358 :
45359 :
45360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45361 :
45362 : // ********************************************************
45363 : // member functions specific to each node in the grammar
45364 : // ********************************************************
45365 :
45366 :
45367 : /* #line 45368 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45368 :
45369 : // Start of memberFunctionString
45370 :
45371 :
45372 : // End of memberFunctionString
45373 : // Start of memberFunctionString
45374 : /* #line 22603 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
45375 :
45376 :
45377 : const SgDataStatementObjectPtrList &
45378 0 : SgDataStatementGroup::get_object_list() const
45379 : {
45380 0 : return p_object_list;
45381 : }
45382 :
45383 : SgDataStatementObjectPtrList &
45384 0 : SgDataStatementGroup::get_object_list()
45385 : {
45386 0 : return p_object_list;
45387 : }
45388 :
45389 : const SgDataStatementValuePtrList &
45390 0 : SgDataStatementGroup::get_value_list() const
45391 : {
45392 0 : return p_value_list;
45393 : }
45394 :
45395 : SgDataStatementValuePtrList &
45396 0 : SgDataStatementGroup::get_value_list()
45397 : {
45398 0 : return p_value_list;
45399 : }
45400 :
45401 :
45402 :
45403 : // End of memberFunctionString
45404 : // Start of memberFunctionString
45405 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
45406 :
45407 : // *** COMMON CODE SECTION BEGINS HERE ***
45408 :
45409 : #if 0
45410 : int
45411 : SgDataStatementGroup::getVariant() const
45412 : {
45413 : // This function is used in ROSE while "variant()" is used in SAGE
45414 : assert(this != NULL);
45415 : return variant();
45416 : }
45417 : #endif
45418 :
45419 : // This function is used in ROSE in treeTraversal code
45420 : // eventually replaces getVariant() and variant()
45421 : // though after variant() has been removed for a while we will
45422 : // want to change the name of variantT() back to variant()
45423 : // (since the "T" was ment to stand for temporary).
45424 : // When this happens the variantT() will be depricated.
45425 : VariantT
45426 0 : SgDataStatementGroup::variantT() const
45427 : {
45428 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
45429 0 : ROSE_ASSERT(this != NULL);
45430 0 : return V_SgDataStatementGroup;
45431 : }
45432 :
45433 : #if 0
45434 : int
45435 : SgDataStatementGroup::variant() const
45436 : {
45437 : // This function is used in SAGE
45438 : ROSE_ASSERT(this != NULL);
45439 : return TEMP_DataStatementGroup;
45440 : }
45441 : #endif
45442 :
45443 : ROSE_DLL_API const char*
45444 0 : SgDataStatementGroup::sage_class_name() const
45445 : {
45446 0 : ROSE_ASSERT(this != NULL);
45447 0 : return "SgDataStatementGroup";
45448 : }
45449 :
45450 : std::string
45451 0 : SgDataStatementGroup::class_name() const
45452 : {
45453 0 : ROSE_ASSERT(this != NULL);
45454 0 : return "SgDataStatementGroup";
45455 : }
45456 :
45457 : // DQ (11/26/2005): Support for visitor pattern mechanims
45458 : // (inferior to ROSE traversal mechanism, experimental).
45459 : void
45460 0 : SgDataStatementGroup::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
45461 : {
45462 0 : ROSE_ASSERT(this != NULL);
45463 0 : visitor.visit(this);
45464 0 : }
45465 :
45466 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
45467 0 : void SgDataStatementGroup::accept (ROSE_VisitorPattern & visitor) {
45468 0 : ROSE_ASSERT(this != NULL);
45469 0 : visitor.visit(this);
45470 0 : }
45471 :
45472 : SgDataStatementGroup*
45473 0 : SgDataStatementGroup::addRegExpAttribute(std::string s, AstRegExAttribute* a)
45474 : {
45475 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
45476 : // This function is currently only supported for the AST used the represent Binary executables.
45477 : if (0 /* isSgAsmNode(this) != NULL */)
45478 : {
45479 : // Support for regex specification.
45480 : std::string prefixCode = "REGEX:";
45481 : addNewAttribute(prefixCode + s,a);
45482 : }
45483 : #endif
45484 :
45485 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
45486 0 : return this;
45487 : }
45488 :
45489 : // *** COMMON CODE SECTION ENDS HERE ***
45490 :
45491 :
45492 : // End of memberFunctionString
45493 : // Start of memberFunctionString
45494 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
45495 :
45496 :
45497 : #if 0
45498 : //! Error checking support
45499 : /*! Verifies the following:
45500 : - working getVariant() member function
45501 : - calls base class's error() member function
45502 : Every class has one of these functions.
45503 : */
45504 : bool
45505 : SgDataStatementGroup::error()
45506 : {
45507 : // Put error checking here
45508 :
45509 : ROSE_ASSERT (this != NULL);
45510 : if (getVariant() != TEMP_DataStatementGroup)
45511 : {
45512 : printf ("Error in SgDataStatementGroup::error(): SgDataStatementGroup object has a %s variant \n",
45513 : Cxx_GrammarTerminalNames[getVariant()].name);
45514 : // printf ("Error in SgDataStatementGroup::error() \n");
45515 : ROSE_ABORT();
45516 : }
45517 :
45518 : ROSE_ASSERT (getVariant() == TEMP_DataStatementGroup);
45519 : return SgSupport::error();
45520 : }
45521 : #endif
45522 :
45523 :
45524 :
45525 : // End of memberFunctionString
45526 :
45527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
45528 :
45529 0 : SgDataStatementGroup* isSgDataStatementGroup ( SgNode* inputDerivedClassPointer )
45530 : {
45531 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
45532 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
45533 : // So to fix this we return NULL directly when the input is NULL and avoid the
45534 : // dynamic_cast in this case. This is likely a performance improvement as well.
45535 : // return dynamic_cast<SgDataStatementGroup*>(inputDerivedClassPointer);
45536 : // Milind Chabbi (8/28/2013): isSgDataStatementGroup uses table-driven castability instead of c++ default dynamic_cast
45537 : // this improves the running time performance by 10-20%.
45538 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDataStatementGroup*>(inputDerivedClassPointer);
45539 0 : return IS_SgDataStatementGroup_FAST_MACRO(inputDerivedClassPointer);
45540 : }
45541 :
45542 : // DQ (11/8/2003): Added version of functions taking const pointer
45543 0 : const SgDataStatementGroup* isSgDataStatementGroup ( const SgNode* inputDerivedClassPointer )
45544 : {
45545 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
45546 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
45547 : // So to fix this we return NULL directly when the input is NULL and avoid the
45548 : // dynamic_cast in this case. This is likely a performance improvement as well.
45549 : // return dynamic_cast<const SgDataStatementGroup*>(inputDerivedClassPointer);
45550 : // Milind Chabbi (8/28/2013): isSgDataStatementGroup uses table-driven castability instead of c++ default dynamic_cast
45551 : // this improves the running time performance by 10-20%.
45552 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDataStatementGroup*>(inputDerivedClassPointer);
45553 0 : return IS_SgDataStatementGroup_FAST_MACRO(inputDerivedClassPointer);
45554 : }
45555 :
45556 :
45557 :
45558 : /* #line 45559 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45559 :
45560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45561 :
45562 : /**
45563 : \brief Generated destructor
45564 :
45565 : This destructor is automatically generated (by ROSETTA). This destructor
45566 : only frees memory of data members associated with the parts of the current IR node which
45567 : are NOT traversed. Those data members that are part of a traversal can be freed using
45568 : a traversal (calling this destructor on all children in a post-order traversal). Such
45569 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
45570 :
45571 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
45572 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
45573 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
45574 :
45575 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
45576 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
45577 : pointers are not yet implemented to call delete on eash pointer in the container.
45578 : (This could be done by derivation from the STL containers to define containers that
45579 : automatically deleted their members.)
45580 :
45581 : */
45582 0 : SgDataStatementGroup::~SgDataStatementGroup () {
45583 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
45584 :
45585 :
45586 :
45587 : }
45588 :
45589 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45590 0 : }
45591 :
45592 :
45593 : /* #line 45594 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45594 :
45595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
45596 :
45597 : // Generated constructor
45598 0 : SgDataStatementGroup::SgDataStatementGroup ( )
45599 0 : : SgSupport()
45600 : {
45601 : #ifdef DEBUG
45602 : // printf ("In SgDataStatementGroup::SgDataStatementGroup () sage_class_name() = %s \n",sage_class_name());
45603 : #endif
45604 : #if 0
45605 : // debugging information!
45606 : printf ("In SgDataStatementGroup::SgDataStatementGroup (): this = %p = %s \n",this,this->class_name().c_str());
45607 : #endif
45608 :
45609 :
45610 :
45611 : #if 0
45612 : // DQ (7/30/2014): Call a virtual function.
45613 : std::string s = this->class_name();
45614 : #endif
45615 :
45616 : // Test the variant virtual function
45617 : // assert(TEMP_DataStatementGroup == variant());
45618 0 : assert(TEMP_DataStatementGroup == this->variant());
45619 0 : ROSE_ASSERT(TEMP_DataStatementGroup == (int)(this->variantT()));
45620 0 : post_construction_initialization();
45621 :
45622 : // Test the isSgDataStatementGroup() function since it has been problematic
45623 0 : assert(isSgDataStatementGroup(this) != NULL);
45624 0 : }
45625 :
45626 : // Generated constructor (all data members)
45627 :
45628 : /* #line 45629 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45629 :
45630 :
45631 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45632 :
45633 :
45634 : // ********************************************************
45635 : // member functions common across all array grammar objects
45636 : // ********************************************************
45637 :
45638 :
45639 :
45640 : /* #line 45641 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45641 :
45642 :
45643 :
45644 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45645 :
45646 : // ********************************************************
45647 : // member functions specific to each node in the grammar
45648 : // ********************************************************
45649 :
45650 :
45651 : /* #line 45652 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45652 :
45653 : // Start of memberFunctionString
45654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
45655 :
45656 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
45657 :
45658 : SgExprListExp*
45659 0 : SgDataStatementObject::get_variableReference_list () const
45660 : {
45661 0 : ROSE_ASSERT (this != NULL);
45662 :
45663 : #if 0
45664 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
45665 : // used to trigger marking transformations for the token-based unparsing.
45666 : printf ("SgDataStatementObject::get_variableReference_list = %p = %s \n",this,this->class_name().c_str());
45667 : #endif
45668 :
45669 0 : return p_variableReference_list;
45670 : }
45671 :
45672 : void
45673 0 : SgDataStatementObject::set_variableReference_list ( SgExprListExp* variableReference_list )
45674 : {
45675 0 : ROSE_ASSERT (this != NULL);
45676 :
45677 : #if 0
45678 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
45679 : // used to trigger marking transformations for the token-based unparsing.
45680 : printf ("SgDataStatementObject::set_variableReference_list = %p = %s \n",this,this->class_name().c_str());
45681 : #endif
45682 :
45683 0 : set_isModified(true);
45684 :
45685 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
45686 : if (p_variableReference_list != NULL && variableReference_list != NULL && p_variableReference_list != variableReference_list)
45687 : {
45688 : printf ("Warning: variableReference_list = %p overwriting valid pointer p_variableReference_list = %p \n",variableReference_list,p_variableReference_list);
45689 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
45690 : printf ("Error fails assertion (p_variableReference_list != NULL && variableReference_list != NULL && p_variableReference_list != variableReference_list) is false\n");
45691 : ROSE_ASSERT(false);
45692 : #endif
45693 : }
45694 : #endif
45695 0 : p_variableReference_list = variableReference_list;
45696 0 : }
45697 :
45698 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
45699 :
45700 :
45701 : // End of memberFunctionString
45702 : // Start of memberFunctionString
45703 : /* #line 22631 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
45704 :
45705 :
45706 :
45707 : // End of memberFunctionString
45708 : // Start of memberFunctionString
45709 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
45710 :
45711 : // *** COMMON CODE SECTION BEGINS HERE ***
45712 :
45713 : #if 0
45714 : int
45715 : SgDataStatementObject::getVariant() const
45716 : {
45717 : // This function is used in ROSE while "variant()" is used in SAGE
45718 : assert(this != NULL);
45719 : return variant();
45720 : }
45721 : #endif
45722 :
45723 : // This function is used in ROSE in treeTraversal code
45724 : // eventually replaces getVariant() and variant()
45725 : // though after variant() has been removed for a while we will
45726 : // want to change the name of variantT() back to variant()
45727 : // (since the "T" was ment to stand for temporary).
45728 : // When this happens the variantT() will be depricated.
45729 : VariantT
45730 0 : SgDataStatementObject::variantT() const
45731 : {
45732 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
45733 0 : ROSE_ASSERT(this != NULL);
45734 0 : return V_SgDataStatementObject;
45735 : }
45736 :
45737 : #if 0
45738 : int
45739 : SgDataStatementObject::variant() const
45740 : {
45741 : // This function is used in SAGE
45742 : ROSE_ASSERT(this != NULL);
45743 : return TEMP_DataStatementObject;
45744 : }
45745 : #endif
45746 :
45747 : ROSE_DLL_API const char*
45748 0 : SgDataStatementObject::sage_class_name() const
45749 : {
45750 0 : ROSE_ASSERT(this != NULL);
45751 0 : return "SgDataStatementObject";
45752 : }
45753 :
45754 : std::string
45755 0 : SgDataStatementObject::class_name() const
45756 : {
45757 0 : ROSE_ASSERT(this != NULL);
45758 0 : return "SgDataStatementObject";
45759 : }
45760 :
45761 : // DQ (11/26/2005): Support for visitor pattern mechanims
45762 : // (inferior to ROSE traversal mechanism, experimental).
45763 : void
45764 0 : SgDataStatementObject::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
45765 : {
45766 0 : ROSE_ASSERT(this != NULL);
45767 0 : visitor.visit(this);
45768 0 : }
45769 :
45770 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
45771 0 : void SgDataStatementObject::accept (ROSE_VisitorPattern & visitor) {
45772 0 : ROSE_ASSERT(this != NULL);
45773 0 : visitor.visit(this);
45774 0 : }
45775 :
45776 : SgDataStatementObject*
45777 0 : SgDataStatementObject::addRegExpAttribute(std::string s, AstRegExAttribute* a)
45778 : {
45779 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
45780 : // This function is currently only supported for the AST used the represent Binary executables.
45781 : if (0 /* isSgAsmNode(this) != NULL */)
45782 : {
45783 : // Support for regex specification.
45784 : std::string prefixCode = "REGEX:";
45785 : addNewAttribute(prefixCode + s,a);
45786 : }
45787 : #endif
45788 :
45789 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
45790 0 : return this;
45791 : }
45792 :
45793 : // *** COMMON CODE SECTION ENDS HERE ***
45794 :
45795 :
45796 : // End of memberFunctionString
45797 : // Start of memberFunctionString
45798 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
45799 :
45800 :
45801 : #if 0
45802 : //! Error checking support
45803 : /*! Verifies the following:
45804 : - working getVariant() member function
45805 : - calls base class's error() member function
45806 : Every class has one of these functions.
45807 : */
45808 : bool
45809 : SgDataStatementObject::error()
45810 : {
45811 : // Put error checking here
45812 :
45813 : ROSE_ASSERT (this != NULL);
45814 : if (getVariant() != TEMP_DataStatementObject)
45815 : {
45816 : printf ("Error in SgDataStatementObject::error(): SgDataStatementObject object has a %s variant \n",
45817 : Cxx_GrammarTerminalNames[getVariant()].name);
45818 : // printf ("Error in SgDataStatementObject::error() \n");
45819 : ROSE_ABORT();
45820 : }
45821 :
45822 : ROSE_ASSERT (getVariant() == TEMP_DataStatementObject);
45823 : return SgSupport::error();
45824 : }
45825 : #endif
45826 :
45827 :
45828 :
45829 : // End of memberFunctionString
45830 :
45831 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
45832 :
45833 0 : SgDataStatementObject* isSgDataStatementObject ( SgNode* inputDerivedClassPointer )
45834 : {
45835 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
45836 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
45837 : // So to fix this we return NULL directly when the input is NULL and avoid the
45838 : // dynamic_cast in this case. This is likely a performance improvement as well.
45839 : // return dynamic_cast<SgDataStatementObject*>(inputDerivedClassPointer);
45840 : // Milind Chabbi (8/28/2013): isSgDataStatementObject uses table-driven castability instead of c++ default dynamic_cast
45841 : // this improves the running time performance by 10-20%.
45842 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDataStatementObject*>(inputDerivedClassPointer);
45843 0 : return IS_SgDataStatementObject_FAST_MACRO(inputDerivedClassPointer);
45844 : }
45845 :
45846 : // DQ (11/8/2003): Added version of functions taking const pointer
45847 0 : const SgDataStatementObject* isSgDataStatementObject ( const SgNode* inputDerivedClassPointer )
45848 : {
45849 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
45850 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
45851 : // So to fix this we return NULL directly when the input is NULL and avoid the
45852 : // dynamic_cast in this case. This is likely a performance improvement as well.
45853 : // return dynamic_cast<const SgDataStatementObject*>(inputDerivedClassPointer);
45854 : // Milind Chabbi (8/28/2013): isSgDataStatementObject uses table-driven castability instead of c++ default dynamic_cast
45855 : // this improves the running time performance by 10-20%.
45856 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDataStatementObject*>(inputDerivedClassPointer);
45857 0 : return IS_SgDataStatementObject_FAST_MACRO(inputDerivedClassPointer);
45858 : }
45859 :
45860 :
45861 :
45862 : /* #line 45863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45863 :
45864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45865 :
45866 : /**
45867 : \brief Generated destructor
45868 :
45869 : This destructor is automatically generated (by ROSETTA). This destructor
45870 : only frees memory of data members associated with the parts of the current IR node which
45871 : are NOT traversed. Those data members that are part of a traversal can be freed using
45872 : a traversal (calling this destructor on all children in a post-order traversal). Such
45873 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
45874 :
45875 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
45876 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
45877 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
45878 :
45879 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
45880 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
45881 : pointers are not yet implemented to call delete on eash pointer in the container.
45882 : (This could be done by derivation from the STL containers to define containers that
45883 : automatically deleted their members.)
45884 :
45885 : */
45886 0 : SgDataStatementObject::~SgDataStatementObject () {
45887 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
45888 :
45889 :
45890 : // case: not a listType for variableReference_list
45891 0 : p_variableReference_list = NULL; // non list case
45892 :
45893 : }
45894 :
45895 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
45896 0 : }
45897 :
45898 :
45899 : /* #line 45900 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45900 :
45901 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
45902 :
45903 : // Generated constructor
45904 0 : SgDataStatementObject::SgDataStatementObject ( )
45905 0 : : SgSupport()
45906 : {
45907 : #ifdef DEBUG
45908 : // printf ("In SgDataStatementObject::SgDataStatementObject () sage_class_name() = %s \n",sage_class_name());
45909 : #endif
45910 : #if 0
45911 : // debugging information!
45912 : printf ("In SgDataStatementObject::SgDataStatementObject (): this = %p = %s \n",this,this->class_name().c_str());
45913 : #endif
45914 :
45915 0 : p_variableReference_list = NULL;
45916 :
45917 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
45918 :
45919 : #if 0
45920 : // DQ (7/30/2014): Call a virtual function.
45921 : std::string s = this->class_name();
45922 : #endif
45923 :
45924 : // Test the variant virtual function
45925 : // assert(TEMP_DataStatementObject == variant());
45926 0 : assert(TEMP_DataStatementObject == this->variant());
45927 0 : ROSE_ASSERT(TEMP_DataStatementObject == (int)(this->variantT()));
45928 0 : post_construction_initialization();
45929 :
45930 : // Test the isSgDataStatementObject() function since it has been problematic
45931 0 : assert(isSgDataStatementObject(this) != NULL);
45932 0 : }
45933 :
45934 : // Generated constructor (all data members)
45935 :
45936 : /* #line 45937 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45937 :
45938 :
45939 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45940 :
45941 :
45942 : // ********************************************************
45943 : // member functions common across all array grammar objects
45944 : // ********************************************************
45945 :
45946 :
45947 :
45948 : /* #line 45949 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45949 :
45950 :
45951 :
45952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
45953 :
45954 : // ********************************************************
45955 : // member functions specific to each node in the grammar
45956 : // ********************************************************
45957 :
45958 :
45959 : /* #line 45960 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
45960 :
45961 : // Start of memberFunctionString
45962 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
45963 :
45964 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
45965 :
45966 : SgName
45967 0 : SgIncludeFile::get_filename () const
45968 : {
45969 0 : ROSE_ASSERT (this != NULL);
45970 :
45971 : #if 0
45972 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
45973 : // used to trigger marking transformations for the token-based unparsing.
45974 : printf ("SgIncludeFile::get_filename = %p = %s \n",this,this->class_name().c_str());
45975 : #endif
45976 :
45977 0 : return p_filename;
45978 : }
45979 :
45980 : void
45981 0 : SgIncludeFile::set_filename ( SgName filename )
45982 : {
45983 0 : ROSE_ASSERT (this != NULL);
45984 :
45985 : #if 0
45986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
45987 : // used to trigger marking transformations for the token-based unparsing.
45988 : printf ("SgIncludeFile::set_filename = %p = %s \n",this,this->class_name().c_str());
45989 : #endif
45990 :
45991 0 : set_isModified(true);
45992 :
45993 0 : p_filename = filename;
45994 0 : }
45995 :
45996 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
45997 :
45998 :
45999 : // End of memberFunctionString
46000 : // Start of memberFunctionString
46001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46002 :
46003 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46004 :
46005 : SgSourceFile*
46006 72291 : SgIncludeFile::get_source_file () const
46007 : {
46008 72291 : ROSE_ASSERT (this != NULL);
46009 :
46010 : #if 0
46011 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46012 : // used to trigger marking transformations for the token-based unparsing.
46013 : printf ("SgIncludeFile::get_source_file = %p = %s \n",this,this->class_name().c_str());
46014 : #endif
46015 :
46016 72291 : return p_source_file;
46017 : }
46018 :
46019 : void
46020 11217 : SgIncludeFile::set_source_file ( SgSourceFile* source_file )
46021 : {
46022 11217 : ROSE_ASSERT (this != NULL);
46023 :
46024 : #if 0
46025 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46026 : // used to trigger marking transformations for the token-based unparsing.
46027 : printf ("SgIncludeFile::set_source_file = %p = %s \n",this,this->class_name().c_str());
46028 : #endif
46029 :
46030 11217 : set_isModified(true);
46031 :
46032 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
46033 : if (p_source_file != NULL && source_file != NULL && p_source_file != source_file)
46034 : {
46035 : printf ("Warning: source_file = %p overwriting valid pointer p_source_file = %p \n",source_file,p_source_file);
46036 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
46037 : printf ("Error fails assertion (p_source_file != NULL && source_file != NULL && p_source_file != source_file) is false\n");
46038 : ROSE_ASSERT(false);
46039 : #endif
46040 : }
46041 : #endif
46042 11217 : p_source_file = source_file;
46043 11217 : }
46044 :
46045 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46046 :
46047 :
46048 : // End of memberFunctionString
46049 : // Start of memberFunctionString
46050 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
46051 :
46052 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46053 :
46054 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
46055 : const SgIncludeFilePtrList &
46056 0 : SgIncludeFile::get_include_file_list () const
46057 : {
46058 0 : assert (this != NULL);
46059 0 : return p_include_file_list;
46060 : }
46061 :
46062 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
46063 : SgIncludeFilePtrList &
46064 22109 : SgIncludeFile::get_include_file_list ()
46065 : {
46066 22109 : assert (this != NULL);
46067 :
46068 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
46069 : // As a rule only set_ access functions can set the isModified flag.
46070 : // set_isModified(true);
46071 :
46072 22109 : return p_include_file_list;
46073 : }
46074 :
46075 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46076 :
46077 :
46078 : // End of memberFunctionString
46079 : // Start of memberFunctionString
46080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46081 :
46082 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46083 :
46084 : unsigned int
46085 0 : SgIncludeFile::get_first_source_sequence_number () const
46086 : {
46087 0 : ROSE_ASSERT (this != NULL);
46088 :
46089 : #if 0
46090 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46091 : // used to trigger marking transformations for the token-based unparsing.
46092 : printf ("SgIncludeFile::get_first_source_sequence_number = %p = %s \n",this,this->class_name().c_str());
46093 : #endif
46094 :
46095 0 : return p_first_source_sequence_number;
46096 : }
46097 :
46098 : void
46099 11212 : SgIncludeFile::set_first_source_sequence_number ( unsigned int first_source_sequence_number )
46100 : {
46101 11212 : ROSE_ASSERT (this != NULL);
46102 :
46103 : #if 0
46104 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46105 : // used to trigger marking transformations for the token-based unparsing.
46106 : printf ("SgIncludeFile::set_first_source_sequence_number = %p = %s \n",this,this->class_name().c_str());
46107 : #endif
46108 :
46109 11212 : set_isModified(true);
46110 :
46111 11212 : p_first_source_sequence_number = first_source_sequence_number;
46112 11212 : }
46113 :
46114 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46115 :
46116 :
46117 : // End of memberFunctionString
46118 : // Start of memberFunctionString
46119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46120 :
46121 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46122 :
46123 : unsigned int
46124 0 : SgIncludeFile::get_last_source_sequence_number () const
46125 : {
46126 0 : ROSE_ASSERT (this != NULL);
46127 :
46128 : #if 0
46129 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46130 : // used to trigger marking transformations for the token-based unparsing.
46131 : printf ("SgIncludeFile::get_last_source_sequence_number = %p = %s \n",this,this->class_name().c_str());
46132 : #endif
46133 :
46134 0 : return p_last_source_sequence_number;
46135 : }
46136 :
46137 : void
46138 11212 : SgIncludeFile::set_last_source_sequence_number ( unsigned int last_source_sequence_number )
46139 : {
46140 11212 : ROSE_ASSERT (this != NULL);
46141 :
46142 : #if 0
46143 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46144 : // used to trigger marking transformations for the token-based unparsing.
46145 : printf ("SgIncludeFile::set_last_source_sequence_number = %p = %s \n",this,this->class_name().c_str());
46146 : #endif
46147 :
46148 11212 : set_isModified(true);
46149 :
46150 11212 : p_last_source_sequence_number = last_source_sequence_number;
46151 11212 : }
46152 :
46153 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46154 :
46155 :
46156 : // End of memberFunctionString
46157 : // Start of memberFunctionString
46158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46159 :
46160 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46161 :
46162 : bool
46163 0 : SgIncludeFile::get_isIncludedMoreThanOnce () const
46164 : {
46165 0 : ROSE_ASSERT (this != NULL);
46166 :
46167 : #if 0
46168 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46169 : // used to trigger marking transformations for the token-based unparsing.
46170 : printf ("SgIncludeFile::get_isIncludedMoreThanOnce = %p = %s \n",this,this->class_name().c_str());
46171 : #endif
46172 :
46173 0 : return p_isIncludedMoreThanOnce;
46174 : }
46175 :
46176 : void
46177 3326 : SgIncludeFile::set_isIncludedMoreThanOnce ( bool isIncludedMoreThanOnce )
46178 : {
46179 3326 : ROSE_ASSERT (this != NULL);
46180 :
46181 : #if 0
46182 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46183 : // used to trigger marking transformations for the token-based unparsing.
46184 : printf ("SgIncludeFile::set_isIncludedMoreThanOnce = %p = %s \n",this,this->class_name().c_str());
46185 : #endif
46186 :
46187 3326 : set_isModified(true);
46188 :
46189 3326 : p_isIncludedMoreThanOnce = isIncludedMoreThanOnce;
46190 3326 : }
46191 :
46192 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46193 :
46194 :
46195 : // End of memberFunctionString
46196 : // Start of memberFunctionString
46197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46198 :
46199 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46200 :
46201 : bool
46202 0 : SgIncludeFile::get_isPrimaryUse () const
46203 : {
46204 0 : ROSE_ASSERT (this != NULL);
46205 :
46206 : #if 0
46207 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46208 : // used to trigger marking transformations for the token-based unparsing.
46209 : printf ("SgIncludeFile::get_isPrimaryUse = %p = %s \n",this,this->class_name().c_str());
46210 : #endif
46211 :
46212 0 : return p_isPrimaryUse;
46213 : }
46214 :
46215 : void
46216 1663 : SgIncludeFile::set_isPrimaryUse ( bool isPrimaryUse )
46217 : {
46218 1663 : ROSE_ASSERT (this != NULL);
46219 :
46220 : #if 0
46221 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46222 : // used to trigger marking transformations for the token-based unparsing.
46223 : printf ("SgIncludeFile::set_isPrimaryUse = %p = %s \n",this,this->class_name().c_str());
46224 : #endif
46225 :
46226 1663 : set_isModified(true);
46227 :
46228 1663 : p_isPrimaryUse = isPrimaryUse;
46229 1663 : }
46230 :
46231 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46232 :
46233 :
46234 : // End of memberFunctionString
46235 : // Start of memberFunctionString
46236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46237 :
46238 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46239 :
46240 : std::string
46241 0 : SgIncludeFile::get_file_hash () const
46242 : {
46243 0 : ROSE_ASSERT (this != NULL);
46244 :
46245 : #if 0
46246 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46247 : // used to trigger marking transformations for the token-based unparsing.
46248 : printf ("SgIncludeFile::get_file_hash = %p = %s \n",this,this->class_name().c_str());
46249 : #endif
46250 :
46251 0 : return p_file_hash;
46252 : }
46253 :
46254 : void
46255 12880 : SgIncludeFile::set_file_hash ( std::string file_hash )
46256 : {
46257 12880 : ROSE_ASSERT (this != NULL);
46258 :
46259 : #if 0
46260 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46261 : // used to trigger marking transformations for the token-based unparsing.
46262 : printf ("SgIncludeFile::set_file_hash = %p = %s \n",this,this->class_name().c_str());
46263 : #endif
46264 :
46265 12880 : set_isModified(true);
46266 :
46267 12880 : p_file_hash = file_hash;
46268 12880 : }
46269 :
46270 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46271 :
46272 :
46273 : // End of memberFunctionString
46274 : // Start of memberFunctionString
46275 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46276 :
46277 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46278 :
46279 : SgName
46280 0 : SgIncludeFile::get_name_used_in_include_directive () const
46281 : {
46282 0 : ROSE_ASSERT (this != NULL);
46283 :
46284 : #if 0
46285 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46286 : // used to trigger marking transformations for the token-based unparsing.
46287 : printf ("SgIncludeFile::get_name_used_in_include_directive = %p = %s \n",this,this->class_name().c_str());
46288 : #endif
46289 :
46290 0 : return p_name_used_in_include_directive;
46291 : }
46292 :
46293 : void
46294 13200 : SgIncludeFile::set_name_used_in_include_directive ( SgName name_used_in_include_directive )
46295 : {
46296 13200 : ROSE_ASSERT (this != NULL);
46297 :
46298 : #if 0
46299 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46300 : // used to trigger marking transformations for the token-based unparsing.
46301 : printf ("SgIncludeFile::set_name_used_in_include_directive = %p = %s \n",this,this->class_name().c_str());
46302 : #endif
46303 :
46304 13200 : set_isModified(true);
46305 :
46306 13200 : p_name_used_in_include_directive = name_used_in_include_directive;
46307 13200 : }
46308 :
46309 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46310 :
46311 :
46312 : // End of memberFunctionString
46313 : // Start of memberFunctionString
46314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46315 :
46316 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46317 :
46318 : SgSourceFile*
46319 32691 : SgIncludeFile::get_source_file_of_translation_unit () const
46320 : {
46321 32691 : ROSE_ASSERT (this != NULL);
46322 :
46323 : #if 0
46324 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46325 : // used to trigger marking transformations for the token-based unparsing.
46326 : printf ("SgIncludeFile::get_source_file_of_translation_unit = %p = %s \n",this,this->class_name().c_str());
46327 : #endif
46328 :
46329 32691 : return p_source_file_of_translation_unit;
46330 : }
46331 :
46332 : void
46333 13200 : SgIncludeFile::set_source_file_of_translation_unit ( SgSourceFile* source_file_of_translation_unit )
46334 : {
46335 13200 : ROSE_ASSERT (this != NULL);
46336 :
46337 : #if 0
46338 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46339 : // used to trigger marking transformations for the token-based unparsing.
46340 : printf ("SgIncludeFile::set_source_file_of_translation_unit = %p = %s \n",this,this->class_name().c_str());
46341 : #endif
46342 :
46343 13200 : set_isModified(true);
46344 :
46345 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
46346 : if (p_source_file_of_translation_unit != NULL && source_file_of_translation_unit != NULL && p_source_file_of_translation_unit != source_file_of_translation_unit)
46347 : {
46348 : printf ("Warning: source_file_of_translation_unit = %p overwriting valid pointer p_source_file_of_translation_unit = %p \n",source_file_of_translation_unit,p_source_file_of_translation_unit);
46349 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
46350 : printf ("Error fails assertion (p_source_file_of_translation_unit != NULL && source_file_of_translation_unit != NULL && p_source_file_of_translation_unit != source_file_of_translation_unit) is false\n");
46351 : ROSE_ASSERT(false);
46352 : #endif
46353 : }
46354 : #endif
46355 13200 : p_source_file_of_translation_unit = source_file_of_translation_unit;
46356 13200 : }
46357 :
46358 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46359 :
46360 :
46361 : // End of memberFunctionString
46362 : // Start of memberFunctionString
46363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46364 :
46365 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46366 :
46367 : SgSourceFile*
46368 0 : SgIncludeFile::get_including_source_file () const
46369 : {
46370 0 : ROSE_ASSERT (this != NULL);
46371 :
46372 : #if 0
46373 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46374 : // used to trigger marking transformations for the token-based unparsing.
46375 : printf ("SgIncludeFile::get_including_source_file = %p = %s \n",this,this->class_name().c_str());
46376 : #endif
46377 :
46378 0 : return p_including_source_file;
46379 : }
46380 :
46381 : void
46382 0 : SgIncludeFile::set_including_source_file ( SgSourceFile* including_source_file )
46383 : {
46384 0 : ROSE_ASSERT (this != NULL);
46385 :
46386 : #if 0
46387 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46388 : // used to trigger marking transformations for the token-based unparsing.
46389 : printf ("SgIncludeFile::set_including_source_file = %p = %s \n",this,this->class_name().c_str());
46390 : #endif
46391 :
46392 0 : set_isModified(true);
46393 :
46394 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
46395 : if (p_including_source_file != NULL && including_source_file != NULL && p_including_source_file != including_source_file)
46396 : {
46397 : printf ("Warning: including_source_file = %p overwriting valid pointer p_including_source_file = %p \n",including_source_file,p_including_source_file);
46398 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
46399 : printf ("Error fails assertion (p_including_source_file != NULL && including_source_file != NULL && p_including_source_file != including_source_file) is false\n");
46400 : ROSE_ASSERT(false);
46401 : #endif
46402 : }
46403 : #endif
46404 0 : p_including_source_file = including_source_file;
46405 0 : }
46406 :
46407 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46408 :
46409 :
46410 : // End of memberFunctionString
46411 : // Start of memberFunctionString
46412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46413 :
46414 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46415 :
46416 : SgIncludeFile*
46417 0 : SgIncludeFile::get_parent_include_file () const
46418 : {
46419 0 : ROSE_ASSERT (this != NULL);
46420 :
46421 : #if 0
46422 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46423 : // used to trigger marking transformations for the token-based unparsing.
46424 : printf ("SgIncludeFile::get_parent_include_file = %p = %s \n",this,this->class_name().c_str());
46425 : #endif
46426 :
46427 0 : return p_parent_include_file;
46428 : }
46429 :
46430 : void
46431 13200 : SgIncludeFile::set_parent_include_file ( SgIncludeFile* parent_include_file )
46432 : {
46433 13200 : ROSE_ASSERT (this != NULL);
46434 :
46435 : #if 0
46436 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46437 : // used to trigger marking transformations for the token-based unparsing.
46438 : printf ("SgIncludeFile::set_parent_include_file = %p = %s \n",this,this->class_name().c_str());
46439 : #endif
46440 :
46441 13200 : set_isModified(true);
46442 :
46443 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
46444 : if (p_parent_include_file != NULL && parent_include_file != NULL && p_parent_include_file != parent_include_file)
46445 : {
46446 : printf ("Warning: parent_include_file = %p overwriting valid pointer p_parent_include_file = %p \n",parent_include_file,p_parent_include_file);
46447 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
46448 : printf ("Error fails assertion (p_parent_include_file != NULL && parent_include_file != NULL && p_parent_include_file != parent_include_file) is false\n");
46449 : ROSE_ASSERT(false);
46450 : #endif
46451 : }
46452 : #endif
46453 13200 : p_parent_include_file = parent_include_file;
46454 13200 : }
46455 :
46456 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46457 :
46458 :
46459 : // End of memberFunctionString
46460 : // Start of memberFunctionString
46461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46462 :
46463 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46464 :
46465 : bool
46466 30 : SgIncludeFile::get_isSystemInclude () const
46467 : {
46468 30 : ROSE_ASSERT (this != NULL);
46469 :
46470 : #if 0
46471 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46472 : // used to trigger marking transformations for the token-based unparsing.
46473 : printf ("SgIncludeFile::get_isSystemInclude = %p = %s \n",this,this->class_name().c_str());
46474 : #endif
46475 :
46476 30 : return p_isSystemInclude;
46477 : }
46478 :
46479 : void
46480 12880 : SgIncludeFile::set_isSystemInclude ( bool isSystemInclude )
46481 : {
46482 12880 : ROSE_ASSERT (this != NULL);
46483 :
46484 : #if 0
46485 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46486 : // used to trigger marking transformations for the token-based unparsing.
46487 : printf ("SgIncludeFile::set_isSystemInclude = %p = %s \n",this,this->class_name().c_str());
46488 : #endif
46489 :
46490 12880 : set_isModified(true);
46491 :
46492 12880 : p_isSystemInclude = isSystemInclude;
46493 12880 : }
46494 :
46495 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46496 :
46497 :
46498 : // End of memberFunctionString
46499 : // Start of memberFunctionString
46500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46501 :
46502 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46503 :
46504 : bool
46505 0 : SgIncludeFile::get_isPreinclude () const
46506 : {
46507 0 : ROSE_ASSERT (this != NULL);
46508 :
46509 : #if 0
46510 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46511 : // used to trigger marking transformations for the token-based unparsing.
46512 : printf ("SgIncludeFile::get_isPreinclude = %p = %s \n",this,this->class_name().c_str());
46513 : #endif
46514 :
46515 0 : return p_isPreinclude;
46516 : }
46517 :
46518 : void
46519 12880 : SgIncludeFile::set_isPreinclude ( bool isPreinclude )
46520 : {
46521 12880 : ROSE_ASSERT (this != NULL);
46522 :
46523 : #if 0
46524 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46525 : // used to trigger marking transformations for the token-based unparsing.
46526 : printf ("SgIncludeFile::set_isPreinclude = %p = %s \n",this,this->class_name().c_str());
46527 : #endif
46528 :
46529 12880 : set_isModified(true);
46530 :
46531 12880 : p_isPreinclude = isPreinclude;
46532 12880 : }
46533 :
46534 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46535 :
46536 :
46537 : // End of memberFunctionString
46538 : // Start of memberFunctionString
46539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46540 :
46541 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46542 :
46543 : bool
46544 0 : SgIncludeFile::get_requires_explict_path_for_unparsed_headers () const
46545 : {
46546 0 : ROSE_ASSERT (this != NULL);
46547 :
46548 : #if 0
46549 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46550 : // used to trigger marking transformations for the token-based unparsing.
46551 : printf ("SgIncludeFile::get_requires_explict_path_for_unparsed_headers = %p = %s \n",this,this->class_name().c_str());
46552 : #endif
46553 :
46554 0 : return p_requires_explict_path_for_unparsed_headers;
46555 : }
46556 :
46557 : void
46558 0 : SgIncludeFile::set_requires_explict_path_for_unparsed_headers ( bool requires_explict_path_for_unparsed_headers )
46559 : {
46560 0 : ROSE_ASSERT (this != NULL);
46561 :
46562 : #if 0
46563 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46564 : // used to trigger marking transformations for the token-based unparsing.
46565 : printf ("SgIncludeFile::set_requires_explict_path_for_unparsed_headers = %p = %s \n",this,this->class_name().c_str());
46566 : #endif
46567 :
46568 0 : set_isModified(true);
46569 :
46570 0 : p_requires_explict_path_for_unparsed_headers = requires_explict_path_for_unparsed_headers;
46571 0 : }
46572 :
46573 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46574 :
46575 :
46576 : // End of memberFunctionString
46577 : // Start of memberFunctionString
46578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46579 :
46580 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46581 :
46582 : bool
46583 0 : SgIncludeFile::get_can_be_supported_using_token_based_unparsing () const
46584 : {
46585 0 : ROSE_ASSERT (this != NULL);
46586 :
46587 : #if 0
46588 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46589 : // used to trigger marking transformations for the token-based unparsing.
46590 : printf ("SgIncludeFile::get_can_be_supported_using_token_based_unparsing = %p = %s \n",this,this->class_name().c_str());
46591 : #endif
46592 :
46593 0 : return p_can_be_supported_using_token_based_unparsing;
46594 : }
46595 :
46596 : void
46597 30 : SgIncludeFile::set_can_be_supported_using_token_based_unparsing ( bool can_be_supported_using_token_based_unparsing )
46598 : {
46599 30 : ROSE_ASSERT (this != NULL);
46600 :
46601 : #if 0
46602 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46603 : // used to trigger marking transformations for the token-based unparsing.
46604 : printf ("SgIncludeFile::set_can_be_supported_using_token_based_unparsing = %p = %s \n",this,this->class_name().c_str());
46605 : #endif
46606 :
46607 30 : set_isModified(true);
46608 :
46609 30 : p_can_be_supported_using_token_based_unparsing = can_be_supported_using_token_based_unparsing;
46610 30 : }
46611 :
46612 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46613 :
46614 :
46615 : // End of memberFunctionString
46616 : // Start of memberFunctionString
46617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46618 :
46619 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46620 :
46621 : SgName
46622 0 : SgIncludeFile::get_directory_prefix () const
46623 : {
46624 0 : ROSE_ASSERT (this != NULL);
46625 :
46626 : #if 0
46627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46628 : // used to trigger marking transformations for the token-based unparsing.
46629 : printf ("SgIncludeFile::get_directory_prefix = %p = %s \n",this,this->class_name().c_str());
46630 : #endif
46631 :
46632 0 : return p_directory_prefix;
46633 : }
46634 :
46635 : void
46636 13200 : SgIncludeFile::set_directory_prefix ( SgName directory_prefix )
46637 : {
46638 13200 : ROSE_ASSERT (this != NULL);
46639 :
46640 : #if 0
46641 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46642 : // used to trigger marking transformations for the token-based unparsing.
46643 : printf ("SgIncludeFile::set_directory_prefix = %p = %s \n",this,this->class_name().c_str());
46644 : #endif
46645 :
46646 13200 : set_isModified(true);
46647 :
46648 13200 : p_directory_prefix = directory_prefix;
46649 13200 : }
46650 :
46651 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46652 :
46653 :
46654 : // End of memberFunctionString
46655 : // Start of memberFunctionString
46656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46657 :
46658 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46659 :
46660 : SgName
46661 0 : SgIncludeFile::get_name_without_path () const
46662 : {
46663 0 : ROSE_ASSERT (this != NULL);
46664 :
46665 : #if 0
46666 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46667 : // used to trigger marking transformations for the token-based unparsing.
46668 : printf ("SgIncludeFile::get_name_without_path = %p = %s \n",this,this->class_name().c_str());
46669 : #endif
46670 :
46671 0 : return p_name_without_path;
46672 : }
46673 :
46674 : void
46675 12880 : SgIncludeFile::set_name_without_path ( SgName name_without_path )
46676 : {
46677 12880 : ROSE_ASSERT (this != NULL);
46678 :
46679 : #if 0
46680 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46681 : // used to trigger marking transformations for the token-based unparsing.
46682 : printf ("SgIncludeFile::set_name_without_path = %p = %s \n",this,this->class_name().c_str());
46683 : #endif
46684 :
46685 12880 : set_isModified(true);
46686 :
46687 12880 : p_name_without_path = name_without_path;
46688 12880 : }
46689 :
46690 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46691 :
46692 :
46693 : // End of memberFunctionString
46694 : // Start of memberFunctionString
46695 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46696 :
46697 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46698 :
46699 : SgName
46700 0 : SgIncludeFile::get_applicationRootDirectory () const
46701 : {
46702 0 : ROSE_ASSERT (this != NULL);
46703 :
46704 : #if 0
46705 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46706 : // used to trigger marking transformations for the token-based unparsing.
46707 : printf ("SgIncludeFile::get_applicationRootDirectory = %p = %s \n",this,this->class_name().c_str());
46708 : #endif
46709 :
46710 0 : return p_applicationRootDirectory;
46711 : }
46712 :
46713 : void
46714 13200 : SgIncludeFile::set_applicationRootDirectory ( SgName applicationRootDirectory )
46715 : {
46716 13200 : ROSE_ASSERT (this != NULL);
46717 :
46718 : #if 0
46719 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46720 : // used to trigger marking transformations for the token-based unparsing.
46721 : printf ("SgIncludeFile::set_applicationRootDirectory = %p = %s \n",this,this->class_name().c_str());
46722 : #endif
46723 :
46724 13200 : set_isModified(true);
46725 :
46726 13200 : p_applicationRootDirectory = applicationRootDirectory;
46727 13200 : }
46728 :
46729 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46730 :
46731 :
46732 : // End of memberFunctionString
46733 : // Start of memberFunctionString
46734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46735 :
46736 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46737 :
46738 : bool
46739 0 : SgIncludeFile::get_will_be_unparsed () const
46740 : {
46741 0 : ROSE_ASSERT (this != NULL);
46742 :
46743 : #if 0
46744 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46745 : // used to trigger marking transformations for the token-based unparsing.
46746 : printf ("SgIncludeFile::get_will_be_unparsed = %p = %s \n",this,this->class_name().c_str());
46747 : #endif
46748 :
46749 0 : return p_will_be_unparsed;
46750 : }
46751 :
46752 : void
46753 0 : SgIncludeFile::set_will_be_unparsed ( bool will_be_unparsed )
46754 : {
46755 0 : ROSE_ASSERT (this != NULL);
46756 :
46757 : #if 0
46758 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46759 : // used to trigger marking transformations for the token-based unparsing.
46760 : printf ("SgIncludeFile::set_will_be_unparsed = %p = %s \n",this,this->class_name().c_str());
46761 : #endif
46762 :
46763 0 : set_isModified(true);
46764 :
46765 0 : p_will_be_unparsed = will_be_unparsed;
46766 0 : }
46767 :
46768 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46769 :
46770 :
46771 : // End of memberFunctionString
46772 : // Start of memberFunctionString
46773 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46774 :
46775 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46776 :
46777 : bool
46778 0 : SgIncludeFile::get_isRoseSystemInclude () const
46779 : {
46780 0 : ROSE_ASSERT (this != NULL);
46781 :
46782 : #if 0
46783 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46784 : // used to trigger marking transformations for the token-based unparsing.
46785 : printf ("SgIncludeFile::get_isRoseSystemInclude = %p = %s \n",this,this->class_name().c_str());
46786 : #endif
46787 :
46788 0 : return p_isRoseSystemInclude;
46789 : }
46790 :
46791 : void
46792 320 : SgIncludeFile::set_isRoseSystemInclude ( bool isRoseSystemInclude )
46793 : {
46794 320 : ROSE_ASSERT (this != NULL);
46795 :
46796 : #if 0
46797 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46798 : // used to trigger marking transformations for the token-based unparsing.
46799 : printf ("SgIncludeFile::set_isRoseSystemInclude = %p = %s \n",this,this->class_name().c_str());
46800 : #endif
46801 :
46802 320 : set_isModified(true);
46803 :
46804 320 : p_isRoseSystemInclude = isRoseSystemInclude;
46805 320 : }
46806 :
46807 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46808 :
46809 :
46810 : // End of memberFunctionString
46811 : // Start of memberFunctionString
46812 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46813 :
46814 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46815 :
46816 : bool
46817 0 : SgIncludeFile::get_from_system_include_dir () const
46818 : {
46819 0 : ROSE_ASSERT (this != NULL);
46820 :
46821 : #if 0
46822 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46823 : // used to trigger marking transformations for the token-based unparsing.
46824 : printf ("SgIncludeFile::get_from_system_include_dir = %p = %s \n",this,this->class_name().c_str());
46825 : #endif
46826 :
46827 0 : return p_from_system_include_dir;
46828 : }
46829 :
46830 : void
46831 12880 : SgIncludeFile::set_from_system_include_dir ( bool from_system_include_dir )
46832 : {
46833 12880 : ROSE_ASSERT (this != NULL);
46834 :
46835 : #if 0
46836 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46837 : // used to trigger marking transformations for the token-based unparsing.
46838 : printf ("SgIncludeFile::set_from_system_include_dir = %p = %s \n",this,this->class_name().c_str());
46839 : #endif
46840 :
46841 12880 : set_isModified(true);
46842 :
46843 12880 : p_from_system_include_dir = from_system_include_dir;
46844 12880 : }
46845 :
46846 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46847 :
46848 :
46849 : // End of memberFunctionString
46850 : // Start of memberFunctionString
46851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46852 :
46853 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46854 :
46855 : bool
46856 0 : SgIncludeFile::get_preinclude_macros_only () const
46857 : {
46858 0 : ROSE_ASSERT (this != NULL);
46859 :
46860 : #if 0
46861 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46862 : // used to trigger marking transformations for the token-based unparsing.
46863 : printf ("SgIncludeFile::get_preinclude_macros_only = %p = %s \n",this,this->class_name().c_str());
46864 : #endif
46865 :
46866 0 : return p_preinclude_macros_only;
46867 : }
46868 :
46869 : void
46870 12880 : SgIncludeFile::set_preinclude_macros_only ( bool preinclude_macros_only )
46871 : {
46872 12880 : ROSE_ASSERT (this != NULL);
46873 :
46874 : #if 0
46875 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46876 : // used to trigger marking transformations for the token-based unparsing.
46877 : printf ("SgIncludeFile::set_preinclude_macros_only = %p = %s \n",this,this->class_name().c_str());
46878 : #endif
46879 :
46880 12880 : set_isModified(true);
46881 :
46882 12880 : p_preinclude_macros_only = preinclude_macros_only;
46883 12880 : }
46884 :
46885 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46886 :
46887 :
46888 : // End of memberFunctionString
46889 : // Start of memberFunctionString
46890 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46891 :
46892 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46893 :
46894 : bool
46895 0 : SgIncludeFile::get_isApplicationFile () const
46896 : {
46897 0 : ROSE_ASSERT (this != NULL);
46898 :
46899 : #if 0
46900 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46901 : // used to trigger marking transformations for the token-based unparsing.
46902 : printf ("SgIncludeFile::get_isApplicationFile = %p = %s \n",this,this->class_name().c_str());
46903 : #endif
46904 :
46905 0 : return p_isApplicationFile;
46906 : }
46907 :
46908 : void
46909 12880 : SgIncludeFile::set_isApplicationFile ( bool isApplicationFile )
46910 : {
46911 12880 : ROSE_ASSERT (this != NULL);
46912 :
46913 : #if 0
46914 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46915 : // used to trigger marking transformations for the token-based unparsing.
46916 : printf ("SgIncludeFile::set_isApplicationFile = %p = %s \n",this,this->class_name().c_str());
46917 : #endif
46918 :
46919 12880 : set_isModified(true);
46920 :
46921 12880 : p_isApplicationFile = isApplicationFile;
46922 12880 : }
46923 :
46924 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46925 :
46926 :
46927 : // End of memberFunctionString
46928 : // Start of memberFunctionString
46929 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46930 :
46931 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46932 :
46933 : bool
46934 0 : SgIncludeFile::get_isRootSourceFile () const
46935 : {
46936 0 : ROSE_ASSERT (this != NULL);
46937 :
46938 : #if 0
46939 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46940 : // used to trigger marking transformations for the token-based unparsing.
46941 : printf ("SgIncludeFile::get_isRootSourceFile = %p = %s \n",this,this->class_name().c_str());
46942 : #endif
46943 :
46944 0 : return p_isRootSourceFile;
46945 : }
46946 :
46947 : void
46948 320 : SgIncludeFile::set_isRootSourceFile ( bool isRootSourceFile )
46949 : {
46950 320 : ROSE_ASSERT (this != NULL);
46951 :
46952 : #if 0
46953 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46954 : // used to trigger marking transformations for the token-based unparsing.
46955 : printf ("SgIncludeFile::set_isRootSourceFile = %p = %s \n",this,this->class_name().c_str());
46956 : #endif
46957 :
46958 320 : set_isModified(true);
46959 :
46960 320 : p_isRootSourceFile = isRootSourceFile;
46961 320 : }
46962 :
46963 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
46964 :
46965 :
46966 : // End of memberFunctionString
46967 : // Start of memberFunctionString
46968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
46969 :
46970 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
46971 :
46972 : SgStatement*
46973 319 : SgIncludeFile::get_firstStatement () const
46974 : {
46975 319 : ROSE_ASSERT (this != NULL);
46976 :
46977 : #if 0
46978 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46979 : // used to trigger marking transformations for the token-based unparsing.
46980 : printf ("SgIncludeFile::get_firstStatement = %p = %s \n",this,this->class_name().c_str());
46981 : #endif
46982 :
46983 319 : return p_firstStatement;
46984 : }
46985 :
46986 : void
46987 0 : SgIncludeFile::set_firstStatement ( SgStatement* firstStatement )
46988 : {
46989 0 : ROSE_ASSERT (this != NULL);
46990 :
46991 : #if 0
46992 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
46993 : // used to trigger marking transformations for the token-based unparsing.
46994 : printf ("SgIncludeFile::set_firstStatement = %p = %s \n",this,this->class_name().c_str());
46995 : #endif
46996 :
46997 0 : set_isModified(true);
46998 :
46999 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
47000 : if (p_firstStatement != NULL && firstStatement != NULL && p_firstStatement != firstStatement)
47001 : {
47002 : printf ("Warning: firstStatement = %p overwriting valid pointer p_firstStatement = %p \n",firstStatement,p_firstStatement);
47003 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
47004 : printf ("Error fails assertion (p_firstStatement != NULL && firstStatement != NULL && p_firstStatement != firstStatement) is false\n");
47005 : ROSE_ASSERT(false);
47006 : #endif
47007 : }
47008 : #endif
47009 0 : p_firstStatement = firstStatement;
47010 0 : }
47011 :
47012 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47013 :
47014 :
47015 : // End of memberFunctionString
47016 : // Start of memberFunctionString
47017 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
47018 :
47019 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47020 :
47021 : SgStatement*
47022 319 : SgIncludeFile::get_lastStatement () const
47023 : {
47024 319 : ROSE_ASSERT (this != NULL);
47025 :
47026 : #if 0
47027 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47028 : // used to trigger marking transformations for the token-based unparsing.
47029 : printf ("SgIncludeFile::get_lastStatement = %p = %s \n",this,this->class_name().c_str());
47030 : #endif
47031 :
47032 319 : return p_lastStatement;
47033 : }
47034 :
47035 : void
47036 0 : SgIncludeFile::set_lastStatement ( SgStatement* lastStatement )
47037 : {
47038 0 : ROSE_ASSERT (this != NULL);
47039 :
47040 : #if 0
47041 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47042 : // used to trigger marking transformations for the token-based unparsing.
47043 : printf ("SgIncludeFile::set_lastStatement = %p = %s \n",this,this->class_name().c_str());
47044 : #endif
47045 :
47046 0 : set_isModified(true);
47047 :
47048 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
47049 : if (p_lastStatement != NULL && lastStatement != NULL && p_lastStatement != lastStatement)
47050 : {
47051 : printf ("Warning: lastStatement = %p overwriting valid pointer p_lastStatement = %p \n",lastStatement,p_lastStatement);
47052 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
47053 : printf ("Error fails assertion (p_lastStatement != NULL && lastStatement != NULL && p_lastStatement != lastStatement) is false\n");
47054 : ROSE_ASSERT(false);
47055 : #endif
47056 : }
47057 : #endif
47058 0 : p_lastStatement = lastStatement;
47059 0 : }
47060 :
47061 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47062 :
47063 :
47064 : // End of memberFunctionString
47065 : // Start of memberFunctionString
47066 : /* #line 18044 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
47067 :
47068 :
47069 :
47070 : // End of memberFunctionString
47071 : // Start of memberFunctionString
47072 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
47073 :
47074 : // *** COMMON CODE SECTION BEGINS HERE ***
47075 :
47076 : #if 0
47077 : int
47078 : SgIncludeFile::getVariant() const
47079 : {
47080 : // This function is used in ROSE while "variant()" is used in SAGE
47081 : assert(this != NULL);
47082 : return variant();
47083 : }
47084 : #endif
47085 :
47086 : // This function is used in ROSE in treeTraversal code
47087 : // eventually replaces getVariant() and variant()
47088 : // though after variant() has been removed for a while we will
47089 : // want to change the name of variantT() back to variant()
47090 : // (since the "T" was ment to stand for temporary).
47091 : // When this happens the variantT() will be depricated.
47092 : VariantT
47093 473280 : SgIncludeFile::variantT() const
47094 : {
47095 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
47096 473280 : ROSE_ASSERT(this != NULL);
47097 473280 : return V_SgIncludeFile;
47098 : }
47099 :
47100 : #if 0
47101 : int
47102 : SgIncludeFile::variant() const
47103 : {
47104 : // This function is used in SAGE
47105 : ROSE_ASSERT(this != NULL);
47106 : return IncludeFileTag;
47107 : }
47108 : #endif
47109 :
47110 : ROSE_DLL_API const char*
47111 0 : SgIncludeFile::sage_class_name() const
47112 : {
47113 0 : ROSE_ASSERT(this != NULL);
47114 0 : return "SgIncludeFile";
47115 : }
47116 :
47117 : std::string
47118 12589 : SgIncludeFile::class_name() const
47119 : {
47120 12589 : ROSE_ASSERT(this != NULL);
47121 12589 : return "SgIncludeFile";
47122 : }
47123 :
47124 : // DQ (11/26/2005): Support for visitor pattern mechanims
47125 : // (inferior to ROSE traversal mechanism, experimental).
47126 : void
47127 27298 : SgIncludeFile::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
47128 : {
47129 27298 : ROSE_ASSERT(this != NULL);
47130 27298 : visitor.visit(this);
47131 27298 : }
47132 :
47133 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
47134 0 : void SgIncludeFile::accept (ROSE_VisitorPattern & visitor) {
47135 0 : ROSE_ASSERT(this != NULL);
47136 0 : visitor.visit(this);
47137 0 : }
47138 :
47139 : SgIncludeFile*
47140 0 : SgIncludeFile::addRegExpAttribute(std::string s, AstRegExAttribute* a)
47141 : {
47142 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
47143 : // This function is currently only supported for the AST used the represent Binary executables.
47144 : if (0 /* isSgAsmNode(this) != NULL */)
47145 : {
47146 : // Support for regex specification.
47147 : std::string prefixCode = "REGEX:";
47148 : addNewAttribute(prefixCode + s,a);
47149 : }
47150 : #endif
47151 :
47152 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
47153 0 : return this;
47154 : }
47155 :
47156 : // *** COMMON CODE SECTION ENDS HERE ***
47157 :
47158 :
47159 : // End of memberFunctionString
47160 : // Start of memberFunctionString
47161 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
47162 :
47163 :
47164 : #if 0
47165 : //! Error checking support
47166 : /*! Verifies the following:
47167 : - working getVariant() member function
47168 : - calls base class's error() member function
47169 : Every class has one of these functions.
47170 : */
47171 : bool
47172 : SgIncludeFile::error()
47173 : {
47174 : // Put error checking here
47175 :
47176 : ROSE_ASSERT (this != NULL);
47177 : if (getVariant() != IncludeFileTag)
47178 : {
47179 : printf ("Error in SgIncludeFile::error(): SgIncludeFile object has a %s variant \n",
47180 : Cxx_GrammarTerminalNames[getVariant()].name);
47181 : // printf ("Error in SgIncludeFile::error() \n");
47182 : ROSE_ABORT();
47183 : }
47184 :
47185 : ROSE_ASSERT (getVariant() == IncludeFileTag);
47186 : return SgSupport::error();
47187 : }
47188 : #endif
47189 :
47190 :
47191 :
47192 : // End of memberFunctionString
47193 :
47194 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
47195 :
47196 13200 : SgIncludeFile* isSgIncludeFile ( SgNode* inputDerivedClassPointer )
47197 : {
47198 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
47199 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
47200 : // So to fix this we return NULL directly when the input is NULL and avoid the
47201 : // dynamic_cast in this case. This is likely a performance improvement as well.
47202 : // return dynamic_cast<SgIncludeFile*>(inputDerivedClassPointer);
47203 : // Milind Chabbi (8/28/2013): isSgIncludeFile uses table-driven castability instead of c++ default dynamic_cast
47204 : // this improves the running time performance by 10-20%.
47205 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIncludeFile*>(inputDerivedClassPointer);
47206 13200 : return IS_SgIncludeFile_FAST_MACRO(inputDerivedClassPointer);
47207 : }
47208 :
47209 : // DQ (11/8/2003): Added version of functions taking const pointer
47210 0 : const SgIncludeFile* isSgIncludeFile ( const SgNode* inputDerivedClassPointer )
47211 : {
47212 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
47213 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
47214 : // So to fix this we return NULL directly when the input is NULL and avoid the
47215 : // dynamic_cast in this case. This is likely a performance improvement as well.
47216 : // return dynamic_cast<const SgIncludeFile*>(inputDerivedClassPointer);
47217 : // Milind Chabbi (8/28/2013): isSgIncludeFile uses table-driven castability instead of c++ default dynamic_cast
47218 : // this improves the running time performance by 10-20%.
47219 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIncludeFile*>(inputDerivedClassPointer);
47220 0 : return IS_SgIncludeFile_FAST_MACRO(inputDerivedClassPointer);
47221 : }
47222 :
47223 :
47224 :
47225 : /* #line 47226 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47226 :
47227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
47228 :
47229 : /**
47230 : \brief Generated destructor
47231 :
47232 : This destructor is automatically generated (by ROSETTA). This destructor
47233 : only frees memory of data members associated with the parts of the current IR node which
47234 : are NOT traversed. Those data members that are part of a traversal can be freed using
47235 : a traversal (calling this destructor on all children in a post-order traversal). Such
47236 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
47237 :
47238 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
47239 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
47240 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
47241 :
47242 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
47243 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
47244 : pointers are not yet implemented to call delete on eash pointer in the container.
47245 : (This could be done by derivation from the STL containers to define containers that
47246 : automatically deleted their members.)
47247 :
47248 : */
47249 1520 : SgIncludeFile::~SgIncludeFile () {
47250 448 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
47251 :
47252 :
47253 : // case: not a listType for filename
47254 448 : p_filename = ""; // non list case
47255 : // case: not a listType for source_file
47256 448 : p_source_file = NULL; // non list case
47257 : // case: not a listType for first_source_sequence_number
47258 448 : p_first_source_sequence_number = 0; // non list case
47259 : // case: not a listType for last_source_sequence_number
47260 448 : p_last_source_sequence_number = 0; // non list case
47261 : // case: not a listType for isIncludedMoreThanOnce
47262 448 : p_isIncludedMoreThanOnce = false; // non list case
47263 : // case: not a listType for isPrimaryUse
47264 448 : p_isPrimaryUse = false; // non list case
47265 : // case: not a listType for file_hash
47266 448 : p_file_hash = ""; // non list case
47267 : // case: not a listType for name_used_in_include_directive
47268 448 : p_name_used_in_include_directive = ""; // non list case
47269 : // case: not a listType for source_file_of_translation_unit
47270 448 : p_source_file_of_translation_unit = NULL; // non list case
47271 : // case: not a listType for including_source_file
47272 448 : p_including_source_file = NULL; // non list case
47273 : // case: not a listType for parent_include_file
47274 448 : p_parent_include_file = NULL; // non list case
47275 : // case: not a listType for isSystemInclude
47276 448 : p_isSystemInclude = false; // non list case
47277 : // case: not a listType for isPreinclude
47278 448 : p_isPreinclude = false; // non list case
47279 : // case: not a listType for requires_explict_path_for_unparsed_headers
47280 448 : p_requires_explict_path_for_unparsed_headers = false; // non list case
47281 : // case: not a listType for can_be_supported_using_token_based_unparsing
47282 448 : p_can_be_supported_using_token_based_unparsing = true; // non list case
47283 : // case: not a listType for directory_prefix
47284 448 : p_directory_prefix = ""; // non list case
47285 : // case: not a listType for name_without_path
47286 448 : p_name_without_path = ""; // non list case
47287 : // case: not a listType for applicationRootDirectory
47288 448 : p_applicationRootDirectory = ""; // non list case
47289 : // case: not a listType for will_be_unparsed
47290 448 : p_will_be_unparsed = false; // non list case
47291 : // case: not a listType for isRoseSystemInclude
47292 448 : p_isRoseSystemInclude = false; // non list case
47293 : // case: not a listType for from_system_include_dir
47294 448 : p_from_system_include_dir = false; // non list case
47295 : // case: not a listType for preinclude_macros_only
47296 448 : p_preinclude_macros_only = false; // non list case
47297 : // case: not a listType for isApplicationFile
47298 448 : p_isApplicationFile = false; // non list case
47299 : // case: not a listType for isRootSourceFile
47300 448 : p_isRootSourceFile = false; // non list case
47301 : // case: not a listType for firstStatement
47302 448 : p_firstStatement = NULL; // non list case
47303 : // case: not a listType for lastStatement
47304 448 : p_lastStatement = NULL; // non list case
47305 :
47306 : }
47307 :
47308 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
47309 896 : }
47310 :
47311 :
47312 : /* #line 47313 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47313 :
47314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
47315 :
47316 : // Generated constructor
47317 13200 : SgIncludeFile::SgIncludeFile ( SgName filename )
47318 13200 : : SgSupport()
47319 : {
47320 : #ifdef DEBUG
47321 : // printf ("In SgIncludeFile::SgIncludeFile (SgName filename) sage_class_name() = %s \n",sage_class_name());
47322 : #endif
47323 : #if 0
47324 : // debugging information!
47325 : printf ("In SgIncludeFile::SgIncludeFile (SgName filename): this = %p = %s \n",this,this->class_name().c_str());
47326 : #endif
47327 :
47328 13200 : p_filename = filename;
47329 13200 : p_source_file = NULL;
47330 13200 : p_first_source_sequence_number = 0;
47331 13200 : p_last_source_sequence_number = 0;
47332 13200 : p_isIncludedMoreThanOnce = false;
47333 13200 : p_isPrimaryUse = false;
47334 13200 : p_file_hash = "";
47335 13200 : p_name_used_in_include_directive = "";
47336 13200 : p_source_file_of_translation_unit = NULL;
47337 13200 : p_including_source_file = NULL;
47338 13200 : p_parent_include_file = NULL;
47339 13200 : p_isSystemInclude = false;
47340 13200 : p_isPreinclude = false;
47341 13200 : p_requires_explict_path_for_unparsed_headers = false;
47342 13200 : p_can_be_supported_using_token_based_unparsing = true;
47343 13200 : p_directory_prefix = "";
47344 13200 : p_name_without_path = "";
47345 13200 : p_applicationRootDirectory = "";
47346 13200 : p_will_be_unparsed = false;
47347 13200 : p_isRoseSystemInclude = false;
47348 13200 : p_from_system_include_dir = false;
47349 13200 : p_preinclude_macros_only = false;
47350 13200 : p_isApplicationFile = false;
47351 13200 : p_isRootSourceFile = false;
47352 13200 : p_firstStatement = NULL;
47353 13200 : p_lastStatement = NULL;
47354 :
47355 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
47356 :
47357 : #if 0
47358 : // DQ (7/30/2014): Call a virtual function.
47359 : std::string s = this->class_name();
47360 : #endif
47361 :
47362 : // Test the variant virtual function
47363 : // assert(IncludeFileTag == variant());
47364 13200 : assert(IncludeFileTag == this->variant());
47365 13200 : ROSE_ASSERT(IncludeFileTag == (int)(this->variantT()));
47366 13200 : post_construction_initialization();
47367 :
47368 : // Test the isSgIncludeFile() function since it has been problematic
47369 13200 : assert(isSgIncludeFile(this) != NULL);
47370 13200 : }
47371 :
47372 : // Generated constructor (all data members)
47373 :
47374 : /* #line 47375 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47375 :
47376 :
47377 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
47378 :
47379 :
47380 : // ********************************************************
47381 : // member functions common across all array grammar objects
47382 : // ********************************************************
47383 :
47384 :
47385 :
47386 : /* #line 47387 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47387 :
47388 :
47389 :
47390 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
47391 :
47392 : // ********************************************************
47393 : // member functions specific to each node in the grammar
47394 : // ********************************************************
47395 :
47396 :
47397 : /* #line 47398 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47398 :
47399 : // Start of memberFunctionString
47400 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
47401 :
47402 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47403 :
47404 : SgDataStatementValue::data_statement_value_enum
47405 0 : SgDataStatementValue::get_data_initialization_format () const
47406 : {
47407 0 : ROSE_ASSERT (this != NULL);
47408 :
47409 : #if 0
47410 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47411 : // used to trigger marking transformations for the token-based unparsing.
47412 : printf ("SgDataStatementValue::get_data_initialization_format = %p = %s \n",this,this->class_name().c_str());
47413 : #endif
47414 :
47415 0 : return p_data_initialization_format;
47416 : }
47417 :
47418 : void
47419 0 : SgDataStatementValue::set_data_initialization_format ( SgDataStatementValue::data_statement_value_enum data_initialization_format )
47420 : {
47421 0 : ROSE_ASSERT (this != NULL);
47422 :
47423 : #if 0
47424 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47425 : // used to trigger marking transformations for the token-based unparsing.
47426 : printf ("SgDataStatementValue::set_data_initialization_format = %p = %s \n",this,this->class_name().c_str());
47427 : #endif
47428 :
47429 0 : set_isModified(true);
47430 :
47431 0 : p_data_initialization_format = data_initialization_format;
47432 0 : }
47433 :
47434 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47435 :
47436 :
47437 : // End of memberFunctionString
47438 : // Start of memberFunctionString
47439 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
47440 :
47441 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47442 :
47443 : SgExprListExp*
47444 0 : SgDataStatementValue::get_initializer_list () const
47445 : {
47446 0 : ROSE_ASSERT (this != NULL);
47447 :
47448 : #if 0
47449 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47450 : // used to trigger marking transformations for the token-based unparsing.
47451 : printf ("SgDataStatementValue::get_initializer_list = %p = %s \n",this,this->class_name().c_str());
47452 : #endif
47453 :
47454 0 : return p_initializer_list;
47455 : }
47456 :
47457 : void
47458 0 : SgDataStatementValue::set_initializer_list ( SgExprListExp* initializer_list )
47459 : {
47460 0 : ROSE_ASSERT (this != NULL);
47461 :
47462 : #if 0
47463 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47464 : // used to trigger marking transformations for the token-based unparsing.
47465 : printf ("SgDataStatementValue::set_initializer_list = %p = %s \n",this,this->class_name().c_str());
47466 : #endif
47467 :
47468 0 : set_isModified(true);
47469 :
47470 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
47471 : if (p_initializer_list != NULL && initializer_list != NULL && p_initializer_list != initializer_list)
47472 : {
47473 : printf ("Warning: initializer_list = %p overwriting valid pointer p_initializer_list = %p \n",initializer_list,p_initializer_list);
47474 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
47475 : printf ("Error fails assertion (p_initializer_list != NULL && initializer_list != NULL && p_initializer_list != initializer_list) is false\n");
47476 : ROSE_ASSERT(false);
47477 : #endif
47478 : }
47479 : #endif
47480 0 : p_initializer_list = initializer_list;
47481 0 : }
47482 :
47483 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47484 :
47485 :
47486 : // End of memberFunctionString
47487 : // Start of memberFunctionString
47488 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
47489 :
47490 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47491 :
47492 : SgExpression*
47493 0 : SgDataStatementValue::get_repeat_expression () const
47494 : {
47495 0 : ROSE_ASSERT (this != NULL);
47496 :
47497 : #if 0
47498 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47499 : // used to trigger marking transformations for the token-based unparsing.
47500 : printf ("SgDataStatementValue::get_repeat_expression = %p = %s \n",this,this->class_name().c_str());
47501 : #endif
47502 :
47503 0 : return p_repeat_expression;
47504 : }
47505 :
47506 : void
47507 0 : SgDataStatementValue::set_repeat_expression ( SgExpression* repeat_expression )
47508 : {
47509 0 : ROSE_ASSERT (this != NULL);
47510 :
47511 : #if 0
47512 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47513 : // used to trigger marking transformations for the token-based unparsing.
47514 : printf ("SgDataStatementValue::set_repeat_expression = %p = %s \n",this,this->class_name().c_str());
47515 : #endif
47516 :
47517 0 : set_isModified(true);
47518 :
47519 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
47520 : if (p_repeat_expression != NULL && repeat_expression != NULL && p_repeat_expression != repeat_expression)
47521 : {
47522 : printf ("Warning: repeat_expression = %p overwriting valid pointer p_repeat_expression = %p \n",repeat_expression,p_repeat_expression);
47523 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
47524 : printf ("Error fails assertion (p_repeat_expression != NULL && repeat_expression != NULL && p_repeat_expression != repeat_expression) is false\n");
47525 : ROSE_ASSERT(false);
47526 : #endif
47527 : }
47528 : #endif
47529 0 : p_repeat_expression = repeat_expression;
47530 0 : }
47531 :
47532 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47533 :
47534 :
47535 : // End of memberFunctionString
47536 : // Start of memberFunctionString
47537 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
47538 :
47539 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47540 :
47541 : SgExpression*
47542 0 : SgDataStatementValue::get_constant_expression () const
47543 : {
47544 0 : ROSE_ASSERT (this != NULL);
47545 :
47546 : #if 0
47547 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47548 : // used to trigger marking transformations for the token-based unparsing.
47549 : printf ("SgDataStatementValue::get_constant_expression = %p = %s \n",this,this->class_name().c_str());
47550 : #endif
47551 :
47552 0 : return p_constant_expression;
47553 : }
47554 :
47555 : void
47556 0 : SgDataStatementValue::set_constant_expression ( SgExpression* constant_expression )
47557 : {
47558 0 : ROSE_ASSERT (this != NULL);
47559 :
47560 : #if 0
47561 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47562 : // used to trigger marking transformations for the token-based unparsing.
47563 : printf ("SgDataStatementValue::set_constant_expression = %p = %s \n",this,this->class_name().c_str());
47564 : #endif
47565 :
47566 0 : set_isModified(true);
47567 :
47568 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
47569 : if (p_constant_expression != NULL && constant_expression != NULL && p_constant_expression != constant_expression)
47570 : {
47571 : printf ("Warning: constant_expression = %p overwriting valid pointer p_constant_expression = %p \n",constant_expression,p_constant_expression);
47572 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
47573 : printf ("Error fails assertion (p_constant_expression != NULL && constant_expression != NULL && p_constant_expression != constant_expression) is false\n");
47574 : ROSE_ASSERT(false);
47575 : #endif
47576 : }
47577 : #endif
47578 0 : p_constant_expression = constant_expression;
47579 0 : }
47580 :
47581 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47582 :
47583 :
47584 : // End of memberFunctionString
47585 : // Start of memberFunctionString
47586 : /* #line 22634 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
47587 :
47588 :
47589 : void
47590 0 : SgDataStatementValue::post_construction_initialization()
47591 : {
47592 : #if 0
47593 : mprintf ("Inside of SgDataStatementValue::post_construction_initialization() initializer_list = %p \n",p_initializer_list);
47594 : if (p_initializer_list == NULL)
47595 : {
47596 : p_initializer_list = new SgExprListExp();
47597 : p_initializer_list->set_parent(this);
47598 : }
47599 : #endif
47600 0 : }
47601 :
47602 :
47603 :
47604 : // End of memberFunctionString
47605 : // Start of memberFunctionString
47606 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
47607 :
47608 : // *** COMMON CODE SECTION BEGINS HERE ***
47609 :
47610 : #if 0
47611 : int
47612 : SgDataStatementValue::getVariant() const
47613 : {
47614 : // This function is used in ROSE while "variant()" is used in SAGE
47615 : assert(this != NULL);
47616 : return variant();
47617 : }
47618 : #endif
47619 :
47620 : // This function is used in ROSE in treeTraversal code
47621 : // eventually replaces getVariant() and variant()
47622 : // though after variant() has been removed for a while we will
47623 : // want to change the name of variantT() back to variant()
47624 : // (since the "T" was ment to stand for temporary).
47625 : // When this happens the variantT() will be depricated.
47626 : VariantT
47627 0 : SgDataStatementValue::variantT() const
47628 : {
47629 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
47630 0 : ROSE_ASSERT(this != NULL);
47631 0 : return V_SgDataStatementValue;
47632 : }
47633 :
47634 : #if 0
47635 : int
47636 : SgDataStatementValue::variant() const
47637 : {
47638 : // This function is used in SAGE
47639 : ROSE_ASSERT(this != NULL);
47640 : return TEMP_DataStatementValue;
47641 : }
47642 : #endif
47643 :
47644 : ROSE_DLL_API const char*
47645 0 : SgDataStatementValue::sage_class_name() const
47646 : {
47647 0 : ROSE_ASSERT(this != NULL);
47648 0 : return "SgDataStatementValue";
47649 : }
47650 :
47651 : std::string
47652 0 : SgDataStatementValue::class_name() const
47653 : {
47654 0 : ROSE_ASSERT(this != NULL);
47655 0 : return "SgDataStatementValue";
47656 : }
47657 :
47658 : // DQ (11/26/2005): Support for visitor pattern mechanims
47659 : // (inferior to ROSE traversal mechanism, experimental).
47660 : void
47661 0 : SgDataStatementValue::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
47662 : {
47663 0 : ROSE_ASSERT(this != NULL);
47664 0 : visitor.visit(this);
47665 0 : }
47666 :
47667 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
47668 0 : void SgDataStatementValue::accept (ROSE_VisitorPattern & visitor) {
47669 0 : ROSE_ASSERT(this != NULL);
47670 0 : visitor.visit(this);
47671 0 : }
47672 :
47673 : SgDataStatementValue*
47674 0 : SgDataStatementValue::addRegExpAttribute(std::string s, AstRegExAttribute* a)
47675 : {
47676 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
47677 : // This function is currently only supported for the AST used the represent Binary executables.
47678 : if (0 /* isSgAsmNode(this) != NULL */)
47679 : {
47680 : // Support for regex specification.
47681 : std::string prefixCode = "REGEX:";
47682 : addNewAttribute(prefixCode + s,a);
47683 : }
47684 : #endif
47685 :
47686 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
47687 0 : return this;
47688 : }
47689 :
47690 : // *** COMMON CODE SECTION ENDS HERE ***
47691 :
47692 :
47693 : // End of memberFunctionString
47694 : // Start of memberFunctionString
47695 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
47696 :
47697 :
47698 : #if 0
47699 : //! Error checking support
47700 : /*! Verifies the following:
47701 : - working getVariant() member function
47702 : - calls base class's error() member function
47703 : Every class has one of these functions.
47704 : */
47705 : bool
47706 : SgDataStatementValue::error()
47707 : {
47708 : // Put error checking here
47709 :
47710 : ROSE_ASSERT (this != NULL);
47711 : if (getVariant() != TEMP_DataStatementValue)
47712 : {
47713 : printf ("Error in SgDataStatementValue::error(): SgDataStatementValue object has a %s variant \n",
47714 : Cxx_GrammarTerminalNames[getVariant()].name);
47715 : // printf ("Error in SgDataStatementValue::error() \n");
47716 : ROSE_ABORT();
47717 : }
47718 :
47719 : ROSE_ASSERT (getVariant() == TEMP_DataStatementValue);
47720 : return SgSupport::error();
47721 : }
47722 : #endif
47723 :
47724 :
47725 :
47726 : // End of memberFunctionString
47727 :
47728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
47729 :
47730 0 : SgDataStatementValue* isSgDataStatementValue ( SgNode* inputDerivedClassPointer )
47731 : {
47732 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
47733 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
47734 : // So to fix this we return NULL directly when the input is NULL and avoid the
47735 : // dynamic_cast in this case. This is likely a performance improvement as well.
47736 : // return dynamic_cast<SgDataStatementValue*>(inputDerivedClassPointer);
47737 : // Milind Chabbi (8/28/2013): isSgDataStatementValue uses table-driven castability instead of c++ default dynamic_cast
47738 : // this improves the running time performance by 10-20%.
47739 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDataStatementValue*>(inputDerivedClassPointer);
47740 0 : return IS_SgDataStatementValue_FAST_MACRO(inputDerivedClassPointer);
47741 : }
47742 :
47743 : // DQ (11/8/2003): Added version of functions taking const pointer
47744 0 : const SgDataStatementValue* isSgDataStatementValue ( const SgNode* inputDerivedClassPointer )
47745 : {
47746 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
47747 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
47748 : // So to fix this we return NULL directly when the input is NULL and avoid the
47749 : // dynamic_cast in this case. This is likely a performance improvement as well.
47750 : // return dynamic_cast<const SgDataStatementValue*>(inputDerivedClassPointer);
47751 : // Milind Chabbi (8/28/2013): isSgDataStatementValue uses table-driven castability instead of c++ default dynamic_cast
47752 : // this improves the running time performance by 10-20%.
47753 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDataStatementValue*>(inputDerivedClassPointer);
47754 0 : return IS_SgDataStatementValue_FAST_MACRO(inputDerivedClassPointer);
47755 : }
47756 :
47757 :
47758 :
47759 : /* #line 47760 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47760 :
47761 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
47762 :
47763 : /**
47764 : \brief Generated destructor
47765 :
47766 : This destructor is automatically generated (by ROSETTA). This destructor
47767 : only frees memory of data members associated with the parts of the current IR node which
47768 : are NOT traversed. Those data members that are part of a traversal can be freed using
47769 : a traversal (calling this destructor on all children in a post-order traversal). Such
47770 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
47771 :
47772 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
47773 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
47774 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
47775 :
47776 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
47777 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
47778 : pointers are not yet implemented to call delete on eash pointer in the container.
47779 : (This could be done by derivation from the STL containers to define containers that
47780 : automatically deleted their members.)
47781 :
47782 : */
47783 0 : SgDataStatementValue::~SgDataStatementValue () {
47784 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
47785 :
47786 :
47787 : // case: not a listType for data_initialization_format
47788 0 : p_data_initialization_format = SgDataStatementValue::e_unknown; // non list case
47789 : // case: not a listType for initializer_list
47790 0 : p_initializer_list = NULL; // non list case
47791 : // case: not a listType for repeat_expression
47792 0 : p_repeat_expression = NULL; // non list case
47793 : // case: not a listType for constant_expression
47794 0 : p_constant_expression = NULL; // non list case
47795 :
47796 : }
47797 :
47798 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
47799 0 : }
47800 :
47801 :
47802 : /* #line 47803 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47803 :
47804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
47805 :
47806 : // Generated constructor
47807 0 : SgDataStatementValue::SgDataStatementValue ( SgDataStatementValue::data_statement_value_enum data_initialization_format )
47808 0 : : SgSupport()
47809 : {
47810 : #ifdef DEBUG
47811 : // printf ("In SgDataStatementValue::SgDataStatementValue (SgDataStatementValue::data_statement_value_enum data_initialization_format) sage_class_name() = %s \n",sage_class_name());
47812 : #endif
47813 : #if 0
47814 : // debugging information!
47815 : printf ("In SgDataStatementValue::SgDataStatementValue (SgDataStatementValue::data_statement_value_enum data_initialization_format): this = %p = %s \n",this,this->class_name().c_str());
47816 : #endif
47817 :
47818 0 : p_data_initialization_format = data_initialization_format;
47819 0 : p_initializer_list = NULL;
47820 0 : p_repeat_expression = NULL;
47821 0 : p_constant_expression = NULL;
47822 :
47823 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
47824 :
47825 : #if 0
47826 : // DQ (7/30/2014): Call a virtual function.
47827 : std::string s = this->class_name();
47828 : #endif
47829 :
47830 : // Test the variant virtual function
47831 : // assert(TEMP_DataStatementValue == variant());
47832 0 : assert(TEMP_DataStatementValue == this->variant());
47833 0 : ROSE_ASSERT(TEMP_DataStatementValue == (int)(this->variantT()));
47834 0 : post_construction_initialization();
47835 :
47836 : // Test the isSgDataStatementValue() function since it has been problematic
47837 0 : assert(isSgDataStatementValue(this) != NULL);
47838 0 : }
47839 :
47840 : // Generated constructor (all data members)
47841 :
47842 : /* #line 47843 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47843 :
47844 :
47845 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
47846 :
47847 :
47848 : // ********************************************************
47849 : // member functions common across all array grammar objects
47850 : // ********************************************************
47851 :
47852 :
47853 :
47854 : /* #line 47855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47855 :
47856 :
47857 :
47858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
47859 :
47860 : // ********************************************************
47861 : // member functions specific to each node in the grammar
47862 : // ********************************************************
47863 :
47864 :
47865 : /* #line 47866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
47866 :
47867 : // Start of memberFunctionString
47868 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
47869 :
47870 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47871 :
47872 : SgSourceFile*
47873 0 : SgHeaderFileReport::get_source_file () const
47874 : {
47875 0 : ROSE_ASSERT (this != NULL);
47876 :
47877 : #if 0
47878 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47879 : // used to trigger marking transformations for the token-based unparsing.
47880 : printf ("SgHeaderFileReport::get_source_file = %p = %s \n",this,this->class_name().c_str());
47881 : #endif
47882 :
47883 0 : return p_source_file;
47884 : }
47885 :
47886 : void
47887 0 : SgHeaderFileReport::set_source_file ( SgSourceFile* source_file )
47888 : {
47889 0 : ROSE_ASSERT (this != NULL);
47890 :
47891 : #if 0
47892 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
47893 : // used to trigger marking transformations for the token-based unparsing.
47894 : printf ("SgHeaderFileReport::set_source_file = %p = %s \n",this,this->class_name().c_str());
47895 : #endif
47896 :
47897 0 : set_isModified(true);
47898 :
47899 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
47900 : if (p_source_file != NULL && source_file != NULL && p_source_file != source_file)
47901 : {
47902 : printf ("Warning: source_file = %p overwriting valid pointer p_source_file = %p \n",source_file,p_source_file);
47903 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
47904 : printf ("Error fails assertion (p_source_file != NULL && source_file != NULL && p_source_file != source_file) is false\n");
47905 : ROSE_ASSERT(false);
47906 : #endif
47907 : }
47908 : #endif
47909 0 : p_source_file = source_file;
47910 0 : }
47911 :
47912 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47913 :
47914 :
47915 : // End of memberFunctionString
47916 : // Start of memberFunctionString
47917 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
47918 :
47919 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
47920 :
47921 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
47922 : const SgSourceFilePtrList &
47923 0 : SgHeaderFileReport::get_include_file_list () const
47924 : {
47925 0 : assert (this != NULL);
47926 0 : return p_include_file_list;
47927 : }
47928 :
47929 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
47930 : SgSourceFilePtrList &
47931 0 : SgHeaderFileReport::get_include_file_list ()
47932 : {
47933 0 : assert (this != NULL);
47934 :
47935 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
47936 : // As a rule only set_ access functions can set the isModified flag.
47937 : // set_isModified(true);
47938 :
47939 0 : return p_include_file_list;
47940 : }
47941 :
47942 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
47943 :
47944 :
47945 : // End of memberFunctionString
47946 : // Start of memberFunctionString
47947 : /* #line 18048 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
47948 :
47949 :
47950 : #if 0
47951 : SgHeaderFileReport::SgHeaderFileReport( SgSourceFile* sourceFile )
47952 : {
47953 : // Nothing to do here (so far).
47954 : }
47955 : #endif
47956 :
47957 :
47958 : // DQ (9/26/2018): Added so that we can call the display function for TokenStreamSequenceToNodeMapping (for debugging).
47959 : #include "tokenStreamMapping.h"
47960 :
47961 : void
47962 0 : SgHeaderFileReport::display( const string & label) const
47963 : {
47964 : // DQ (6/25/2020): If we call display, then we mean for it to be displayed, not hidden.
47965 0 : printf ("\nIn HeaderFileReport::display(): label = %s \n",label.c_str());
47966 :
47967 0 : ROSE_ASSERT(this != NULL);
47968 :
47969 : #if 1
47970 0 : printf ("In HeaderFileReport::display(): p_source_file = %p \n",p_source_file);
47971 0 : ROSE_ASSERT(p_source_file != NULL);
47972 0 : printf (" --- source filename = %s \n",p_source_file->getFileName().c_str());
47973 0 : printf (" --- isHeaderFile = %s \n",p_source_file->get_isHeaderFile() ? "true" : "false");
47974 0 : printf (" --- isHeaderFileIncludedMoreThanOnce = %s \n",p_source_file->get_isHeaderFileIncludedMoreThanOnce() ? "true" : "false");
47975 :
47976 : // DQ (11/15/2018): removed the include list from SgSourceFile so that we could support traversals on the inlcude tree.
47977 : // printf (" --- include_file_list size = %zu \n",p_source_file->get_include_file_list().size());
47978 0 : printf (" --- associated_include_file = %p \n",p_source_file->get_associated_include_file());
47979 0 : ROSE_ASSERT(p_source_file->get_associated_include_file() != NULL);
47980 0 : printf (" --- associated_include_file include_file_list size = %zu \n",p_source_file->get_associated_include_file()->get_include_file_list().size());
47981 :
47982 : #if 0
47983 : printf (" --- source_file_of_translation_unit = %p = %s \n",
47984 : p_source_file->get_source_file_of_translation_unit(),p_source_file->get_source_file_of_translation_unit()->getFileName().c_str());
47985 : printf (" --- including_source_file = %p = %s \n",
47986 : p_source_file->get_including_source_file(),p_source_file->get_including_source_file()->getFileName().c_str());
47987 : #endif
47988 :
47989 0 : printf ("In HeaderFileReport::display(): p_include_file_list.size() = %zu \n",p_include_file_list.size());
47990 :
47991 0 : Rose_STL_Container<SgSourceFile*>::const_iterator i = p_include_file_list.begin();
47992 0 : while (i != p_include_file_list.end())
47993 : {
47994 : // const SgSourceFile* includedFile = *i;
47995 0 : SgSourceFile* includedFile = *i;
47996 0 : ROSE_ASSERT(includedFile != NULL);
47997 :
47998 0 : printf (" --- includedFile: name = %s \n",includedFile->getFileName().c_str());
47999 0 : printf (" --- --- # of statements in global scope = %zu \n",includedFile->get_globalScope()->get_declarations().size());
48000 0 : printf (" --- --- isHeaderFile = %s \n",includedFile->get_isHeaderFile() ? "true" : "false");
48001 0 : printf (" --- --- isHeaderFileIncludedMoreThanOnce = %s \n",includedFile->get_isHeaderFileIncludedMoreThanOnce() ? "true" : "false");
48002 :
48003 : // DQ (11/15/2018): removed the include list from SgSourceFile so that we could support traversals on the inlcude tree.
48004 : // printf (" --- --- include_file_list size = %zu \n",includedFile->get_include_file_list().size());
48005 0 : printf (" --- --- associated_include_file = %p \n",includedFile->get_associated_include_file());
48006 0 : ROSE_ASSERT(includedFile->get_associated_include_file() != NULL);
48007 0 : printf (" --- --- associated_include_file include_file_list size = %zu \n",includedFile->get_associated_include_file()->get_include_file_list().size());
48008 :
48009 : #if 0
48010 : printf (" --- --- source_file_of_translation_unit = %p = %s \n",
48011 : includedFile->get_source_file_of_translation_unit(),includedFile->get_source_file_of_translation_unit()->getFileName().c_str());
48012 : printf (" --- --- including_source_file = %p = %s \n",
48013 : includedFile->get_including_source_file(),includedFile->get_including_source_file()->getFileName().c_str());
48014 : #endif
48015 : #if 0
48016 : printf ("In SgHeaderFileReport::display(): includedFile = %p file name = %s \n",includedFile,includedFile->getFileName().c_str());
48017 : printf (" --- includedFile->get_globalScope() = %p \n",includedFile->get_globalScope());
48018 : printf (" --- includedFile->get_tokenSubsequenceMap().size() = %zu \n",includedFile->get_tokenSubsequenceMap().size());
48019 : #endif
48020 : #if 0
48021 : ROSE_ASSERT(includedFile->get_tokenSubsequenceMap().find(includedFile->get_globalScope()) != includedFile->get_tokenSubsequenceMap().end());
48022 :
48023 : printf ("In SgHeaderFileReport::display(): Calling display on token sequence for global scope \n");
48024 : ROSE_ASSERT(includedFile->get_tokenSubsequenceMap()[includedFile->get_globalScope()] != NULL);
48025 : TokenStreamSequenceToNodeMapping* tokenSequence = includedFile->get_tokenSubsequenceMap()[includedFile->get_globalScope()];
48026 : ROSE_ASSERT(tokenSequence != NULL);
48027 : tokenSequence->display("token sequence for global scope");
48028 : #endif
48029 :
48030 0 : i++;
48031 : }
48032 : #endif
48033 :
48034 :
48035 :
48036 0 : }
48037 :
48038 :
48039 :
48040 : // End of memberFunctionString
48041 : // Start of memberFunctionString
48042 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
48043 :
48044 : // *** COMMON CODE SECTION BEGINS HERE ***
48045 :
48046 : #if 0
48047 : int
48048 : SgHeaderFileReport::getVariant() const
48049 : {
48050 : // This function is used in ROSE while "variant()" is used in SAGE
48051 : assert(this != NULL);
48052 : return variant();
48053 : }
48054 : #endif
48055 :
48056 : // This function is used in ROSE in treeTraversal code
48057 : // eventually replaces getVariant() and variant()
48058 : // though after variant() has been removed for a while we will
48059 : // want to change the name of variantT() back to variant()
48060 : // (since the "T" was ment to stand for temporary).
48061 : // When this happens the variantT() will be depricated.
48062 : VariantT
48063 0 : SgHeaderFileReport::variantT() const
48064 : {
48065 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
48066 0 : ROSE_ASSERT(this != NULL);
48067 0 : return V_SgHeaderFileReport;
48068 : }
48069 :
48070 : #if 0
48071 : int
48072 : SgHeaderFileReport::variant() const
48073 : {
48074 : // This function is used in SAGE
48075 : ROSE_ASSERT(this != NULL);
48076 : return HeaderFileReportTag;
48077 : }
48078 : #endif
48079 :
48080 : ROSE_DLL_API const char*
48081 0 : SgHeaderFileReport::sage_class_name() const
48082 : {
48083 0 : ROSE_ASSERT(this != NULL);
48084 0 : return "SgHeaderFileReport";
48085 : }
48086 :
48087 : std::string
48088 0 : SgHeaderFileReport::class_name() const
48089 : {
48090 0 : ROSE_ASSERT(this != NULL);
48091 0 : return "SgHeaderFileReport";
48092 : }
48093 :
48094 : // DQ (11/26/2005): Support for visitor pattern mechanims
48095 : // (inferior to ROSE traversal mechanism, experimental).
48096 : void
48097 0 : SgHeaderFileReport::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
48098 : {
48099 0 : ROSE_ASSERT(this != NULL);
48100 0 : visitor.visit(this);
48101 0 : }
48102 :
48103 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
48104 0 : void SgHeaderFileReport::accept (ROSE_VisitorPattern & visitor) {
48105 0 : ROSE_ASSERT(this != NULL);
48106 0 : visitor.visit(this);
48107 0 : }
48108 :
48109 : SgHeaderFileReport*
48110 0 : SgHeaderFileReport::addRegExpAttribute(std::string s, AstRegExAttribute* a)
48111 : {
48112 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
48113 : // This function is currently only supported for the AST used the represent Binary executables.
48114 : if (0 /* isSgAsmNode(this) != NULL */)
48115 : {
48116 : // Support for regex specification.
48117 : std::string prefixCode = "REGEX:";
48118 : addNewAttribute(prefixCode + s,a);
48119 : }
48120 : #endif
48121 :
48122 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
48123 0 : return this;
48124 : }
48125 :
48126 : // *** COMMON CODE SECTION ENDS HERE ***
48127 :
48128 :
48129 : // End of memberFunctionString
48130 : // Start of memberFunctionString
48131 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
48132 :
48133 :
48134 : #if 0
48135 : //! Error checking support
48136 : /*! Verifies the following:
48137 : - working getVariant() member function
48138 : - calls base class's error() member function
48139 : Every class has one of these functions.
48140 : */
48141 : bool
48142 : SgHeaderFileReport::error()
48143 : {
48144 : // Put error checking here
48145 :
48146 : ROSE_ASSERT (this != NULL);
48147 : if (getVariant() != HeaderFileReportTag)
48148 : {
48149 : printf ("Error in SgHeaderFileReport::error(): SgHeaderFileReport object has a %s variant \n",
48150 : Cxx_GrammarTerminalNames[getVariant()].name);
48151 : // printf ("Error in SgHeaderFileReport::error() \n");
48152 : ROSE_ABORT();
48153 : }
48154 :
48155 : ROSE_ASSERT (getVariant() == HeaderFileReportTag);
48156 : return SgSupport::error();
48157 : }
48158 : #endif
48159 :
48160 :
48161 :
48162 : // End of memberFunctionString
48163 :
48164 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
48165 :
48166 0 : SgHeaderFileReport* isSgHeaderFileReport ( SgNode* inputDerivedClassPointer )
48167 : {
48168 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
48169 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
48170 : // So to fix this we return NULL directly when the input is NULL and avoid the
48171 : // dynamic_cast in this case. This is likely a performance improvement as well.
48172 : // return dynamic_cast<SgHeaderFileReport*>(inputDerivedClassPointer);
48173 : // Milind Chabbi (8/28/2013): isSgHeaderFileReport uses table-driven castability instead of c++ default dynamic_cast
48174 : // this improves the running time performance by 10-20%.
48175 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgHeaderFileReport*>(inputDerivedClassPointer);
48176 0 : return IS_SgHeaderFileReport_FAST_MACRO(inputDerivedClassPointer);
48177 : }
48178 :
48179 : // DQ (11/8/2003): Added version of functions taking const pointer
48180 0 : const SgHeaderFileReport* isSgHeaderFileReport ( const SgNode* inputDerivedClassPointer )
48181 : {
48182 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
48183 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
48184 : // So to fix this we return NULL directly when the input is NULL and avoid the
48185 : // dynamic_cast in this case. This is likely a performance improvement as well.
48186 : // return dynamic_cast<const SgHeaderFileReport*>(inputDerivedClassPointer);
48187 : // Milind Chabbi (8/28/2013): isSgHeaderFileReport uses table-driven castability instead of c++ default dynamic_cast
48188 : // this improves the running time performance by 10-20%.
48189 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgHeaderFileReport*>(inputDerivedClassPointer);
48190 0 : return IS_SgHeaderFileReport_FAST_MACRO(inputDerivedClassPointer);
48191 : }
48192 :
48193 :
48194 :
48195 : /* #line 48196 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
48196 :
48197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
48198 :
48199 : /**
48200 : \brief Generated destructor
48201 :
48202 : This destructor is automatically generated (by ROSETTA). This destructor
48203 : only frees memory of data members associated with the parts of the current IR node which
48204 : are NOT traversed. Those data members that are part of a traversal can be freed using
48205 : a traversal (calling this destructor on all children in a post-order traversal). Such
48206 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
48207 :
48208 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
48209 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
48210 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
48211 :
48212 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
48213 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
48214 : pointers are not yet implemented to call delete on eash pointer in the container.
48215 : (This could be done by derivation from the STL containers to define containers that
48216 : automatically deleted their members.)
48217 :
48218 : */
48219 0 : SgHeaderFileReport::~SgHeaderFileReport () {
48220 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
48221 :
48222 :
48223 : // case: not a listType for source_file
48224 0 : p_source_file = NULL; // non list case
48225 :
48226 : }
48227 :
48228 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
48229 0 : }
48230 :
48231 :
48232 : /* #line 48233 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
48233 :
48234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
48235 :
48236 : // Generated constructor
48237 0 : SgHeaderFileReport::SgHeaderFileReport ( SgSourceFile* source_file )
48238 0 : : SgSupport()
48239 : {
48240 : #ifdef DEBUG
48241 : // printf ("In SgHeaderFileReport::SgHeaderFileReport (SgSourceFile* source_file) sage_class_name() = %s \n",sage_class_name());
48242 : #endif
48243 : #if 0
48244 : // debugging information!
48245 : printf ("In SgHeaderFileReport::SgHeaderFileReport (SgSourceFile* source_file): this = %p = %s \n",this,this->class_name().c_str());
48246 : #endif
48247 :
48248 0 : p_source_file = source_file;
48249 :
48250 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
48251 :
48252 : #if 0
48253 : // DQ (7/30/2014): Call a virtual function.
48254 : std::string s = this->class_name();
48255 : #endif
48256 :
48257 : // Test the variant virtual function
48258 : // assert(HeaderFileReportTag == variant());
48259 0 : assert(HeaderFileReportTag == this->variant());
48260 0 : ROSE_ASSERT(HeaderFileReportTag == (int)(this->variantT()));
48261 0 : post_construction_initialization();
48262 :
48263 : // Test the isSgHeaderFileReport() function since it has been problematic
48264 0 : assert(isSgHeaderFileReport(this) != NULL);
48265 0 : }
48266 :
48267 : // Generated constructor (all data members)
48268 :
48269 : /* #line 48270 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
48270 :
48271 :
48272 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
48273 :
48274 :
48275 : // ********************************************************
48276 : // member functions common across all array grammar objects
48277 : // ********************************************************
48278 :
48279 :
48280 :
48281 : /* #line 48282 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
48282 :
48283 :
48284 :
48285 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
48286 :
48287 : // ********************************************************
48288 : // member functions specific to each node in the grammar
48289 : // ********************************************************
48290 :
48291 :
48292 : /* #line 48293 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
48293 :
48294 : // Start of memberFunctionString
48295 : /* #line 1438 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
48296 :
48297 :
48298 : //! SgType default constructor (initializes all local variables)
48299 609681 : SgType::SgType()
48300 : : p_substitutedForTemplateParam(false),
48301 : p_ref_to(NULL),
48302 : p_ptr_to(NULL),
48303 : p_modifiers(NULL),
48304 : p_typedefs(NULL),
48305 : p_rvalue_ref_to(NULL),
48306 : p_decltype_ref_to(NULL),
48307 : p_typeof_ref_to(NULL),
48308 : // DQ (10/3/2010): Readded to the SgType since it is used uniformally within Fortran types.
48309 : // DQ (12/1/2007): This has been moved to the SgModifierType
48310 : p_type_kind(NULL),
48311 609681 : p_attributeMechanism(NULL)
48312 : {
48313 609681 : ROSE_ASSERT(p_ref_to == NULL);
48314 609681 : ROSE_ASSERT(p_ptr_to == NULL);
48315 609681 : ROSE_ASSERT(p_modifiers == NULL);
48316 :
48317 609681 : p_typedefs = new SgTypedefSeq();
48318 :
48319 609681 : ROSE_ASSERT(p_typedefs != NULL);
48320 609681 : ROSE_ASSERT(p_rvalue_ref_to == NULL);
48321 609681 : ROSE_ASSERT(p_decltype_ref_to == NULL);
48322 609681 : ROSE_ASSERT(p_typeof_ref_to == NULL);
48323 :
48324 : // FMZ (2/6/2009): Added a flag for CoArray
48325 609681 : p_isCoArray = false;
48326 :
48327 : // DQ (12/1/2007): This has been moved to the SgModifierType
48328 : // ROSE_ASSERT(p_type_kind == NULL);
48329 :
48330 : // DQ (1/25/2007): Let's try this again!
48331 : // DQ (6/25/2006): Commented out to allow File I/O to work, I don't understand why it is required!
48332 : // DQ (5/11/2006): Added to avoid NULL pointer
48333 609681 : p_typedefs->set_parent(this);
48334 609681 : }
48335 :
48336 :
48337 0 : SgType::SgType(const SgType & X)
48338 0 : : p_substitutedForTemplateParam(X.p_substitutedForTemplateParam),
48339 0 : p_ref_to(X.p_ref_to),
48340 0 : p_ptr_to(X.p_ptr_to),
48341 0 : p_modifiers(X.p_modifiers),
48342 0 : p_typedefs(X.p_typedefs),
48343 0 : p_rvalue_ref_to(X.p_rvalue_ref_to),
48344 0 : p_decltype_ref_to(X.p_decltype_ref_to),
48345 0 : p_typeof_ref_to(X.p_typeof_ref_to),
48346 : // DQ (10/3/2010): Readded to the SgType since it is used uniformally within Fortran types.
48347 : // DQ (12/1/2007): This has been moved to the SgModifierType
48348 0 : p_type_kind(X.p_type_kind),
48349 0 : p_attributeMechanism(X.p_attributeMechanism)
48350 : {
48351 : // DQ (10/17/2007): This copy constructor is built to support the AST copy mechanism where for
48352 : // some declarations that generate named types, the types are copied. and fixed up in a later
48353 : // phase (e.g. SgClassDeclaration::fixupCopy()).
48354 :
48355 : // I think if we copy X then we want to assume that it has these values, but it might
48356 : // be acceptable if it didn't, but then a more complex copy would be required.
48357 :
48358 : #if 0
48359 : // DQ (10/17/2007) Commented out (see copytest2007_14.C).
48360 : ROSE_ASSERT(p_ref_to == NULL);
48361 : ROSE_ASSERT(p_ptr_to == NULL);
48362 : ROSE_ASSERT(p_modifiers == NULL);
48363 : ROSE_ASSERT(p_rvalue_ref_to == NULL);
48364 : ROSE_ASSERT(p_decltype_ref_to == NULL);
48365 : ROSE_ASSERT(p_typeof_ref_to == NULL);
48366 : // DQ (12/1/2007): This has been moved to the SgModifierType
48367 : // ROSE_ASSERT(p_type_kind == NULL);
48368 : #endif
48369 :
48370 : // FMZ (2/6/2009): Added a flag for CoArray
48371 0 : p_isCoArray = false;
48372 :
48373 0 : p_typedefs = new SgTypedefSeq();
48374 0 : ROSE_ASSERT(p_typedefs != NULL);
48375 0 : p_typedefs->set_parent(this);
48376 0 : }
48377 :
48378 :
48379 : #if 0
48380 : SgType::~SgType()
48381 : {
48382 : delete p_modifiers;
48383 : delete p_typedefs;
48384 : }
48385 : #endif
48386 :
48387 : // SgName SgType::get_mangled(SgUnparse_Info& info)
48388 : SgName
48389 0 : SgType::get_mangled(void) const
48390 : {
48391 : // This should be an error, I think!
48392 0 : printf ("ERROR: base calss get_mangled functions should not be called! \n");
48393 0 : ROSE_ABORT();
48394 :
48395 : return "";
48396 : }
48397 :
48398 : #if 0
48399 : // DQ (3/2/2003): Implement get_parent from SgNode
48400 : SgNode*
48401 : SgType::get_parent() const
48402 : {
48403 : ROSE_ASSERT(this != NULL);
48404 : return NULL; // this is the original sage 2 code (but I think it should return p_parent)
48405 : // return (SgType*) p_parent;
48406 : }
48407 : #endif
48408 :
48409 : #if 0
48410 : //! virtual functions define to return false
48411 : //! (will be overwritten on only a few of the derived classes)
48412 : bool SgType::isConst() const { return false; }
48413 : bool SgType::isVolatile() const { return false; }
48414 : bool SgType::isRestrict() const { return false; }
48415 : bool SgType::isUPC_Shared() const { return false; }
48416 : bool SgType::isUPC_Strict() const { return false; }
48417 : bool SgType::isUPC_Relaxed() const { return false; }
48418 : #endif
48419 :
48420 : #if 0
48421 : bool SgType::isExtern() const { return false; }
48422 : bool SgType::isTypedef() const { return false; }
48423 : bool SgType::isVirtual() const { return false; }
48424 : bool SgType::isProtected() const { return false; }
48425 : bool SgType::isPrivate() const { return false; }
48426 : bool SgType::isPublic() const { return false; }
48427 : bool SgType::isAuto() const { return false; }
48428 : #endif
48429 :
48430 : // bool SgType::isGlobal() const { return false; }
48431 : // bool SgType::isSync() const { return false; }
48432 :
48433 : #if 0
48434 : // These are unimplemented within SAGE 2
48435 : bool
48436 : SgType::isLong() const
48437 : { return false; }
48438 :
48439 : bool
48440 : SgType::isShort() const
48441 : { return false; }
48442 : #endif
48443 :
48444 : #if 0
48445 : // This codes was part of an experiment to distinguish struct tag { int x; } X; from struct tag X;
48446 : // It turns out that the declaration of the tag in this case in placed into the EDG orphan list
48447 : // as a type and that we don't require this mechanism (thought we might in the future so for now
48448 : // it is just commented out.
48449 : bool
48450 : SgType::isFirstDeclaration() const
48451 : { return (p_useWithinDeclaration & e_first_declaration); }
48452 :
48453 : void
48454 : SgType::setFirstDeclaration()
48455 : { p_useWithinDeclaration |= e_first_declaration; }
48456 :
48457 : void
48458 : SgType::unsetFirstDeclaration()
48459 : { p_useWithinDeclaration &= ~e_first_declaration; }
48460 :
48461 : bool
48462 : SgType::isAutonomousTagDeclaration() const
48463 : { return (p_useWithinDeclaration & e_autonomous_tag_declaration); }
48464 :
48465 : void
48466 : SgType::setAutonomousTagDeclaration()
48467 : { p_useWithinDeclaration |= e_autonomous_tag_declaration; }
48468 :
48469 : void
48470 : SgType::unsetAutonomousTagDeclaration()
48471 : { p_useWithinDeclaration &= ~e_autonomous_tag_declaration; }
48472 : #endif
48473 :
48474 : #if 0
48475 : // DQ (7/26/2010): Now we finally need this function!
48476 : SgModifierType*
48477 : SgType::matchModifiers (unsigned int f)
48478 : {
48479 : #if 0
48480 : // DQ (7/26/2010): Not clear if we want this function to return a reference to itself.
48481 : ROSE_ASSERT (p_modifiers == NULL);
48482 :
48483 : if (p_modifiers)
48484 : {
48485 : return p_modifiers->match(this, f);
48486 : }
48487 : else
48488 : {
48489 : return (p_modifiers = new SgModifierNodes())->match(this, f);
48490 : }
48491 : #else
48492 :
48493 : #endif
48494 : }
48495 : #endif
48496 :
48497 : bool
48498 21718 : SgType::isIntegerType() const
48499 : {
48500 21718 : const SgType* t = this;
48501 21718 : ROSE_ASSERT(t != NULL);
48502 :
48503 26211 : while (t->variant() == T_TYPEDEF)
48504 : {
48505 4493 : t = ((SgTypedefType *) t)->get_base_type();
48506 4493 : ROSE_ASSERT(t != NULL);
48507 : }
48508 :
48509 21718 : switch (variant())
48510 : {
48511 : case T_CHAR:
48512 : case T_SIGNED_CHAR:
48513 : case T_UNSIGNED_CHAR:
48514 : case T_SHORT:
48515 : case T_SIGNED_SHORT:
48516 : case T_UNSIGNED_SHORT:
48517 : case T_INT:
48518 : case T_SIGNED_INT:
48519 : case T_UNSIGNED_INT:
48520 : case T_LONG:
48521 : case T_SIGNED_LONG:
48522 : case T_UNSIGNED_LONG:
48523 : case T_WCHAR:
48524 :
48525 : // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
48526 : case T_CHAR16:
48527 : case T_CHAR32:
48528 :
48529 : case T_LONG_LONG:
48530 : case T_SIGNED_LONG_LONG:
48531 : case T_UNSIGNED_LONG_LONG:
48532 : // DQ (3/24/2014): Added support for 128 bit integers.
48533 : case T_SIGNED_128BIT_INTEGER:
48534 : case T_UNSIGNED_128BIT_INTEGER:
48535 : case T_BOOL:
48536 : return true; // 1
48537 3964 : break;
48538 :
48539 3964 : default:
48540 3964 : return false; // 0
48541 : }
48542 : }
48543 :
48544 : bool
48545 3964 : SgType::isFloatType() const
48546 : {
48547 3964 : const SgType* t = this;
48548 3964 : ROSE_ASSERT(t != NULL);
48549 :
48550 8457 : while (t->variant() == T_TYPEDEF)
48551 4493 : t = ((SgTypedefType *) t)->get_base_type();
48552 :
48553 3964 : switch (t->variant())
48554 : {
48555 : case T_FLOAT :
48556 :
48557 : // DQ (4/20/2019): Added additional floating point types to be classified as (isFloatType() == true) by this function.
48558 : case T_FLOAT80 :
48559 : case T_FLOAT128 :
48560 :
48561 : case T_DOUBLE:
48562 : case T_LONG_DOUBLE:
48563 : return 1;
48564 3564 : break;
48565 :
48566 3564 : default:
48567 3564 : return 0;
48568 : }
48569 : }
48570 :
48571 : bool
48572 0 : SgType::isUnsignedType() const
48573 : {
48574 0 : switch (variant())
48575 : {
48576 : case T_UNSIGNED_CHAR:
48577 : case T_UNSIGNED_SHORT:
48578 : case T_UNSIGNED_INT:
48579 : case T_UNSIGNED_LONG:
48580 : // DQ (3/24/2014): Added support for 128 bit integers.
48581 : case T_UNSIGNED_LONG_LONG:
48582 : case T_UNSIGNED_128BIT_INTEGER:
48583 : return 1;
48584 0 : break;
48585 :
48586 0 : default:
48587 0 : return 0;
48588 : }
48589 : }
48590 :
48591 :
48592 : bool
48593 1531140 : SgType::isPrimativeType() const
48594 : {
48595 : // DQ (4/20/2019): Added query for primative types so that they can be easily skipped in name qualification.
48596 : // Note that a typedef type is not a primative type, even if it resolves to such a type (because it can be name qualified).
48597 : // A typedef type may be otherwise type equvalent to a primative type.
48598 :
48599 1531140 : switch (variant())
48600 : {
48601 : // The list of types from isIntegerType() function
48602 : case T_CHAR:
48603 : case T_SIGNED_CHAR:
48604 : case T_UNSIGNED_CHAR:
48605 : case T_SHORT:
48606 : case T_SIGNED_SHORT:
48607 : case T_UNSIGNED_SHORT:
48608 : case T_INT:
48609 : case T_SIGNED_INT:
48610 : case T_UNSIGNED_INT:
48611 : case T_LONG:
48612 : case T_SIGNED_LONG:
48613 : case T_UNSIGNED_LONG:
48614 : case T_WCHAR:
48615 :
48616 : // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
48617 : case T_CHAR16:
48618 : case T_CHAR32:
48619 :
48620 : case T_LONG_LONG:
48621 : case T_SIGNED_LONG_LONG:
48622 : case T_UNSIGNED_LONG_LONG:
48623 : // DQ (3/24/2014): Added support for 128 bit integers.
48624 : case T_SIGNED_128BIT_INTEGER:
48625 : case T_UNSIGNED_128BIT_INTEGER:
48626 : case T_BOOL:
48627 :
48628 : // float types
48629 : case T_FLOAT :
48630 : case T_FLOAT80 :
48631 : case T_FLOAT128 :
48632 : case T_DOUBLE:
48633 : case T_LONG_DOUBLE:
48634 :
48635 : // Other kinds of float types.
48636 : case T_COMPLEX:
48637 : case T_IMAGINARY:
48638 :
48639 : // Other types
48640 : case T_VOID:
48641 : case T_LABEL:
48642 : case T_NULLPTR:
48643 : case T_DECLTYPE:
48644 : case T_STRING:
48645 :
48646 : return true; // 1
48647 1447100 : break;
48648 :
48649 1447100 : default:
48650 1447100 : return false; // 0
48651 : }
48652 : }
48653 :
48654 :
48655 :
48656 : SgType*
48657 0 : SgType::integer_promotion(SgType * t1, SgType * t2)
48658 : {
48659 0 : if(!t1) return t2;
48660 0 : if(!t2) return t1;
48661 :
48662 0 : if (t1->variant() == T_UNSIGNED_LONG || t2->variant() == T_UNSIGNED_LONG)
48663 0 : return SgTypeUnsignedLong::createType();
48664 :
48665 : // This should only be if long can hold unsigned int, not always true!!
48666 0 : if (t1->variant() == T_UNSIGNED_INT || t2->variant() == T_UNSIGNED_INT)
48667 0 : return SgTypeLong::createType();
48668 :
48669 0 : if (t1->isUnsignedType())
48670 : return t1;
48671 : else
48672 0 : if (t2->isUnsignedType() )
48673 : return t2;
48674 : else
48675 0 : return SgTypeInt::createType();
48676 : }
48677 :
48678 : SgType*
48679 0 : SgType::float_promotion( SgType* t1, SgType* t2 )
48680 : {
48681 0 : if(!t1) return t2;
48682 0 : if(!t2) return t1;
48683 :
48684 0 : if (t1->variant() == T_LONG_DOUBLE)
48685 : return t1;
48686 : else
48687 0 : if (t2->variant() == T_LONG_DOUBLE)
48688 : return t2;
48689 : else
48690 0 : if (t1->variant() == T_DOUBLE)
48691 : return t1;
48692 : else
48693 0 : if (t2->variant() == T_DOUBLE)
48694 : return t2;
48695 : else
48696 0 : return t1;
48697 : }
48698 :
48699 : #if 0
48700 : // DQ (4/5/2004): Removed since it is not used anywhere!
48701 : SgType*
48702 : SgType::rmModifier ( SgType* t1, int which )
48703 : {
48704 : SgType* tmp_type = t1;
48705 :
48706 : ROSE_ASSERT(t1 != NULL);
48707 :
48708 : if(t1->variant()==T_MODIFIER)
48709 : {
48710 : SgModifierType *mod = (SgModifierType *) t1;
48711 : ROSE_ASSERT(mod != NULL);
48712 :
48713 : SgType *btype = mod->get_base_type();
48714 :
48715 : int modval = mod->get_bitfield();
48716 :
48717 : if(mod->isSync() && (which & e_sync))
48718 : modval &= ~SgModifierType::m_sync;
48719 :
48720 : if(mod->isGlobal() && (which & e_global))
48721 : modval &= ~SgModifierType::m_global;
48722 :
48723 : if(mod->isConst() && (which & e_const))
48724 : modval &= ~SgModifierType::m_const;
48725 :
48726 : tmp_type = (modval) ? SgModifierType::createType(btype,modval) : btype;
48727 : }
48728 :
48729 : return tmp_type;
48730 : }
48731 : #endif
48732 :
48733 : #if 0
48734 : // DQ (4/5/2004): Removed since it is not used anywhere!
48735 : SgType*
48736 : SgType::addModifier(SgType *t1, int which)
48737 : {
48738 : SgType* tmp_type = t1;
48739 : SgType* btype;
48740 : int modval;
48741 :
48742 : ROSE_ASSERT(t1 != NULL);
48743 :
48744 : if(t1->variant()==T_MODIFIER)
48745 : {
48746 : SgModifierType *mod=(SgModifierType *) t1;
48747 : btype=mod->get_base_type();
48748 : modval=mod->get_bitfield();
48749 : }
48750 : else
48751 : {
48752 : btype=t1;
48753 : modval=0;
48754 : }
48755 :
48756 : if(which & e_sync) modval |= SgModifierType::m_sync;
48757 : if(which & e_global) modval |= SgModifierType::m_global;
48758 : if(which & e_const) modval |= SgModifierType::m_const;
48759 :
48760 : tmp_type = SgModifierType::createType(btype,modval);
48761 :
48762 : return tmp_type;
48763 : }
48764 : #endif
48765 :
48766 : SgType*
48767 0 : SgType::arithmetic_conversions ( SgType* t1, SgType* t2 )
48768 : {
48769 0 : if(!t1) return t2;
48770 0 : if(!t2) return t1;
48771 :
48772 : // DQ (4/5/2004): Removed since it is the only use of rmModifier and e_sync is not used anywhere!
48773 : // if (isSgModifierType(t1)) t1 = rmModifier(t1,e_sync);
48774 : // if (isSgModifierType(t2)) t2 = rmModifier(t2,e_sync);
48775 :
48776 0 : if (t1->isFloatType() && t2->isIntegerType())
48777 : return t1;
48778 :
48779 0 : if (t2->isFloatType() && t1->isIntegerType())
48780 : return t2;
48781 :
48782 0 : if (t1->isIntegerType())
48783 0 : return integer_promotion(t1,t2);
48784 : else
48785 0 : return float_promotion(t1,t2);
48786 : }
48787 :
48788 : SgType*
48789 0 : SgType::dereference()
48790 : {
48791 : // This function does not recursively decend into types, so it should not use the lower
48792 : // level SgType::stripType() member function.
48793 :
48794 0 : SgType* t = this;
48795 0 : ROSE_ASSERT(t != NULL);
48796 0 : while (t->variant() == T_TYPEDEF)
48797 0 : t = ((SgTypedefType *) t)->get_base_type();
48798 :
48799 0 : if (t->variant() == T_POINTER)
48800 0 : return ((SgPointerType *) t)->get_base_type();
48801 : else
48802 0 : if (t->variant() == T_REFERENCE)
48803 0 : return ((SgReferenceType *) t)->get_base_type();
48804 : else
48805 0 : if(t->variant() == T_ARRAY)
48806 0 : return ((SgArrayType *) t)->get_base_type();
48807 : else
48808 : return (SgType*)t;
48809 : }
48810 :
48811 : SgType*
48812 210825 : SgType::stripTypedefsAndModifiers() const
48813 : {
48814 : // DQ (6/30/2005): This function answers the question of what type is this? It recursively
48815 : // strips away typedefs until we reach something not typedefeds, thus we stop at any pointer
48816 : // or references (but not modifiers).
48817 : #if 0
48818 : SgType *returnType = const_cast<SgType*>(this);
48819 : ROSE_ASSERT(returnType != NULL);
48820 :
48821 : SgTypedefType* typedefType = isSgTypedefType(returnType);
48822 : SgModifierType* modifierType = isSgModifierType(returnType);
48823 : while (typedefType != NULL || modifierType != NULL)
48824 : // while (isSgTypedefType(returnType) != NULL || isSgModifierType(returnType) != NULL)
48825 : {
48826 : if (typedefType != NULL)
48827 : {
48828 : returnType = typedefType->get_base_type();
48829 : }
48830 : if (modifierType != NULL)
48831 : {
48832 : returnType = modifierType->get_base_type();
48833 : }
48834 :
48835 : // reset the typedefType and modifierType variables
48836 : typedefType = isSgTypedefType(returnType);
48837 : modifierType = isSgModifierType(returnType);
48838 : }
48839 :
48840 : ROSE_ASSERT (returnType != NULL);
48841 :
48842 : return returnType;
48843 : #else
48844 : // DQ (10/11/2007): Modified this function to use SgType::stripType().
48845 : // This uses a subset of the possible or'd values available with SgType::stripType()
48846 210825 : return stripType(STRIP_MODIFIER_TYPE | STRIP_TYPEDEF_TYPE);
48847 : #endif
48848 : }
48849 :
48850 : SgType*
48851 4382960 : SgType::findBaseType() const
48852 : {
48853 : #if 0
48854 : // Cast away const of "this" pointer
48855 : SgType* currentType = (SgType*) this;
48856 :
48857 : SgModifierType* modType = NULL;
48858 : SgPointerType* pointType = NULL;
48859 : SgReferenceType* refType = NULL;
48860 : SgArrayType* arrayType = NULL;
48861 : SgTypedefType* typedefType = NULL;
48862 :
48863 :
48864 : while (true)
48865 : {
48866 :
48867 :
48868 : if ( modType = isSgModifierType(currentType) )
48869 : {
48870 : currentType = modType->get_base_type();
48871 : }
48872 : else if ( (refType = isSgReferenceType(currentType)) )
48873 : {
48874 : currentType = refType->get_base_type();
48875 : }
48876 : else if ( (pointType = isSgPointerType(currentType)) )
48877 : {
48878 : currentType = pointType->get_base_type();
48879 : }
48880 : else if ( (arrayType = isSgArrayType(currentType)) )
48881 : {
48882 : currentType = arrayType->get_base_type();
48883 : }
48884 : else if ( (typedefType = isSgTypedefType(currentType)) )
48885 : {
48886 : // DQ (6/21/2005): Added support for typedef types to be uncovered by findBaseType()
48887 :
48888 : currentType = typedefType->get_base_type();
48889 : }
48890 : else {
48891 : // Exit the while(true){} loop!
48892 : break;
48893 : }
48894 :
48895 : }
48896 : #else
48897 : // This uses the default value for SgType::stripType(), namely
48898 : // (bit_array == STRIP_MODIFIER_TYPE | STRIP_REFERENCE_TYPE | STRIP_RVALUE_REFERENCE_TYPE | STRIP_POINTER_TYPE | STRIP_ARRAY_TYPE | STRIP_TYPEDEF_TYPE)
48899 4382960 : return stripType();
48900 : #endif
48901 : }
48902 :
48903 : #define DEBUG_SGTYPE_STRIPTYPE 0
48904 : #define DEBUG_SGTYPE_STRIPTYPE_MORE 0
48905 :
48906 : SgType*
48907 26574800 : SgType::stripType(unsigned char bit_array) const
48908 : {
48909 : // This function forms the low level support for both SgType::findBaseType()
48910 : // and SgType::stripTypedefsAndModifiers(). It takes a default valued
48911 : // bit_array == (STRIP_MODIFIER_TYPE | STRIP_REFERENCE_TYPE | STRIP_RVALUE_REFERENCE_TYPE | STRIP_POINTER_TYPE | STRIP_ARRAY_TYPE | STRIP_TYPEDEF_TYPE | STRIP_POINTER_MEMBER_TYPE)
48912 : // Alternatively any of these value may be ORed together to for other combinations.
48913 :
48914 : // Cast away const of "this" pointer
48915 26574800 : SgType* currentType = (SgType*) this;
48916 :
48917 26574800 : SageInterface::detectCycleInType(currentType, "SgType::stripType");
48918 :
48919 : #if DEBUG_SGTYPE_STRIPTYPE
48920 : printf ("Inside of SgType::stripType(bit_array = %u): this = %p = %s \n",bit_array,currentType,currentType->class_name().c_str());
48921 : #endif
48922 :
48923 26574800 : SgModifierType* modType = NULL;
48924 26574800 : SgPointerType* pointType = NULL;
48925 26574800 : SgReferenceType* refType = NULL;
48926 26574800 : SgRvalueReferenceType* rRefType = NULL;
48927 26574800 : SgArrayType* arrayType = NULL;
48928 26574800 : SgTypedefType* typedefType = NULL;
48929 :
48930 26574800 : SgPointerMemberType* pointerMemberType = NULL;
48931 :
48932 26574800 : size_t counter = 0;
48933 44073000 : while (true)
48934 : {
48935 : #if DEBUG_SGTYPE_STRIPTYPE
48936 : printf ("In loop of SgType::stripType(bit_array = %u): counter = %" PRIuPTR " this = %p = %s = %s \n",bit_array,counter,currentType,currentType->class_name().c_str(),currentType->unparseToString().c_str());
48937 : #endif
48938 35323900 : if ( (bit_array & STRIP_MODIFIER_TYPE) && (modType = isSgModifierType(currentType)) )
48939 : {
48940 : #if DEBUG_SGTYPE_STRIPTYPE_MORE
48941 : printf ("In loop of SgType::stripType(): found SgModifierType \n");
48942 : #endif
48943 777107 : currentType = modType->get_base_type();
48944 : }
48945 34546800 : else if ( (bit_array & STRIP_REFERENCE_TYPE) && (refType = isSgReferenceType(currentType)) )
48946 : {
48947 : #if DEBUG_SGTYPE_STRIPTYPE_MORE
48948 : printf ("In loop of SgType::stripType(): found SgReferenceType \n");
48949 : #endif
48950 314740 : currentType = refType->get_base_type();
48951 : }
48952 34232100 : else if ( (bit_array & STRIP_RVALUE_REFERENCE_TYPE) && (rRefType = isSgRvalueReferenceType(currentType)) )
48953 : {
48954 : #if 0
48955 : printf ("In loop of SgType::stripType(): found SgRvalueReferenceType \n");
48956 : #endif
48957 29369 : currentType = rRefType->get_base_type();
48958 : }
48959 : // DQ (4/15/2019): I don't think this should apply to SgPointerMemberType (which maybe should not be derived from SgPointerType).
48960 : // Is SgPointerMemberType a kind of type that should be something we should support in this stripType function?
48961 : // else if ( (bit_array & STRIP_POINTER_TYPE) && (pointType = isSgPointerType(currentType)) )
48962 34202700 : else if ( (bit_array & STRIP_POINTER_TYPE) && ((pointType = isSgPointerType(currentType)) && (isSgPointerMemberType(currentType) == NULL)) )
48963 : {
48964 : #if DEBUG_SGTYPE_STRIPTYPE_MORE
48965 : printf ("In loop of SgType::stripType(): found SgPointerType (that is not SgPointerMemberType) \n");
48966 : #endif
48967 : // DQ (4/15/2019): Added assertion.
48968 1171600 : ROSE_ASSERT(pointType != NULL);
48969 :
48970 1171600 : currentType = pointType->get_base_type();
48971 : }
48972 33031100 : else if ( (bit_array & STRIP_POINTER_MEMBER_TYPE) && (pointerMemberType = isSgPointerMemberType(currentType)) )
48973 : {
48974 : #if DEBUG_SGTYPE_STRIPTYPE_MORE
48975 : printf ("In loop of SgType::stripType(): found SgPointerMemberType \n");
48976 : #endif
48977 724 : currentType = pointerMemberType->get_base_type();
48978 : }
48979 33030400 : else if ( (bit_array & STRIP_ARRAY_TYPE) && (arrayType = isSgArrayType(currentType)) )
48980 : {
48981 : #if DEBUG_SGTYPE_STRIPTYPE_MORE
48982 : printf ("In loop of SgType::stripType(): found SgArrayType \n");
48983 : #endif
48984 31097 : currentType = arrayType->get_base_type();
48985 : }
48986 32999300 : else if ( (bit_array & STRIP_TYPEDEF_TYPE) && (typedefType = isSgTypedefType(currentType)) )
48987 : {
48988 : #if DEBUG_SGTYPE_STRIPTYPE_MORE
48989 : printf ("In loop of SgType::stripType(): found SgTypedefType: currentType = %p = %s typedefType->get_base_type() = %p = %s \n",
48990 : currentType,currentType->class_name().c_str(),typedefType->get_base_type(),typedefType->get_base_type()->class_name().c_str());
48991 : #endif
48992 : // DQ (6/21/2005): Added support for typedef types to be uncovered by findBaseType()
48993 6424450 : currentType = typedefType->get_base_type();
48994 : }
48995 : else
48996 : {
48997 : // Exit the while(true){} loop!
48998 26574800 : ROSE_ASSERT(currentType != NULL);
48999 : #if DEBUG_SGTYPE_STRIPTYPE
49000 : printf ("In loop of SgType::stripType(): exiting loop: currentType = %p = %s \n",currentType,currentType->class_name().c_str());
49001 : #endif
49002 26574800 : break;
49003 : }
49004 :
49005 : // DQ (7/4/2013): This should be a reasonable limit.
49006 8749080 : if (counter >= 80)
49007 : {
49008 0 : printf ("In loop of SgType::stripType(bit_array = %u): counter = %" PRIuPTR " currentType = %p = %s = %s\n",bit_array,counter,currentType,currentType->class_name().c_str(),currentType->unparseToString().c_str());
49009 : }
49010 :
49011 8749080 : if (counter >= 100)
49012 : {
49013 : // Exit loop and return the currentType...
49014 0 : printf ("In loop of SgType::stripType(bit_array = %u): exiting loop using currentType (counter = %" PRIuPTR ") currentType = %p = %s \n",bit_array,counter,currentType,currentType->class_name().c_str());
49015 : #if 0
49016 : break;
49017 : #endif
49018 : }
49019 8749080 : ROSE_ASSERT(counter < 100);
49020 :
49021 8749080 : counter++;
49022 : }
49023 :
49024 26574800 : ROSE_ASSERT(currentType != NULL);
49025 :
49026 : #if 0
49027 : printf ("Leaving SgType::stripType(): currentType = %p = %s \n",currentType,currentType->class_name().c_str());
49028 : #endif
49029 :
49030 26574800 : return currentType;
49031 : }
49032 :
49033 : #if 0
49034 : SgType*
49035 : SgType::stripType() const
49036 : {
49037 : // DQ (6/21/2005): strip type of all typedefs, modifiers, pointers, references, and array typing
49038 : SgType* returnType = (SgType*) this;
49039 : while ( (isSgTypedefType(returnType) != NULL) ||
49040 : (isSgPointerType(returnType) != NULL) ||
49041 : (isSgModifierType(returnType) != NULL) ||
49042 : (isSgReferenceType(returnType) != NULL) ||
49043 : (isSgArrayType(returnType) != NULL) )
49044 : {
49045 : returnType = returnType->findBaseType();
49046 : ROSE_ASSERT (returnType != NULL);
49047 : // printf ("In stripType(): returnType = %s hidden behind this = %s \n",returnType->sage_class_name(),sage_class_name());
49048 : }
49049 :
49050 : return returnType;
49051 : }
49052 : #endif
49053 :
49054 :
49055 : SgName
49056 0 : SgType::mangledNameSupport(SgName & fname, SgUnparse_Info & info)
49057 : {
49058 0 : ROSE_ASSERT(this != NULL);
49059 :
49060 : // DQ (4/27/2005): This protected function refactors code located into two places into a single implementation!
49061 0 : SgName rtmp;
49062 :
49063 : // This only makes sense to call from either the SgFunctionType or the SgMemberFunctionType
49064 0 : ROSE_ASSERT(isSgFunctionType(this) != NULL || isSgMemberFunctionType(this) != NULL);
49065 :
49066 0 : int len = fname.getString().size();
49067 0 : std::string opstr = "operator";
49068 0 : std::string newstr = "new";
49069 0 : std::string delstr = "delete";
49070 0 : unsigned int m = opstr.size();
49071 :
49072 : // printf ("In SgType::mangledNameSupport(): class_name = %s len = %d m = %d fname = %s \n",sage_class_name(),len,m,fname.str());
49073 :
49074 0 : if (len > 0 && fname.getString().substr(0, m) == opstr)
49075 : {
49076 0 : if (fname.getString()[m]==' ')
49077 : {
49078 : // DQ (4/27/2005): "m+2" should be "m+1"
49079 0 : if (fname.getString().substr(m + 1, newstr.size()) == newstr)
49080 : {
49081 : // DQ (4/27/2005): Added support for array new
49082 0 : int parenStart = m+1+newstr.size();
49083 0 : if (len > parenStart && fname.getString().substr(parenStart, 2) == "[]")
49084 0 : rtmp << "__na";
49085 : else
49086 0 : rtmp << "__nw";
49087 : }
49088 : else
49089 : {
49090 : // DQ (4/27/2005): Added support for array delete
49091 0 : if (fname.getString().substr(m + 1, delstr.size()) == delstr)
49092 : {
49093 0 : int deleteStringLength = delstr.size();
49094 0 : int parenStart = m+1+deleteStringLength;
49095 0 : if (len > parenStart && fname.getString().substr(parenStart, 2) == "[]")
49096 0 : rtmp << "__da";
49097 : else
49098 0 : rtmp << "__dl";
49099 : }
49100 : else
49101 : {
49102 : // DQ (4/27/2005): Not clear where this is used (unless it is used in casting operators)!
49103 : // This is the only part that is dependent upon either the SgFunctionType or SgMemberFunctionType.
49104 0 : SgFunctionType *functionType = isSgFunctionType(this);
49105 0 : ROSE_ASSERT(functionType != NULL);
49106 0 : ROSE_ASSERT(functionType->get_return_type() != NULL);
49107 :
49108 0 : rtmp << "__op" << functionType->get_return_type()->get_mangled().str();
49109 : }
49110 : }
49111 : }
49112 : else
49113 : {
49114 : // real operator (suffix after the substring "operator ")
49115 :
49116 : // I think that this case could be used to handle "operator new", "operator new[]",
49117 : // "operator delete", and "operator delete[]".
49118 :
49119 0 : SgName opname=&(fname.str()[m]);
49120 :
49121 0 : if (opname == SgName("->")) rtmp << "__rf";
49122 0 : else if (opname==SgName("->*")) rtmp << "__rm";
49123 0 : else if (opname==SgName("==")) rtmp << "__eq";
49124 0 : else if (opname==SgName("<")) rtmp << "__lt";
49125 0 : else if (opname==SgName(">")) rtmp << "__gt";
49126 0 : else if (opname==SgName("!=")) rtmp << "__ne";
49127 0 : else if (opname==SgName("<=")) rtmp << "__le";
49128 0 : else if (opname==SgName(">=")) rtmp << "__ge";
49129 0 : else if (opname==SgName("+")) rtmp << "__pl";
49130 0 : else if (opname==SgName("-")) rtmp << "__mi";
49131 0 : else if (opname==SgName("*")) rtmp << "__ml";
49132 0 : else if (opname==SgName("/")) rtmp << "__dv";
49133 0 : else if (opname==SgName("%")) rtmp << "__md";
49134 0 : else if (opname==SgName("&&")) rtmp << "__aa";
49135 0 : else if (opname==SgName("!")) rtmp << "__nt";
49136 0 : else if (opname==SgName("||")) rtmp << "__oo";
49137 0 : else if (opname==SgName("^")) rtmp << "__er";
49138 0 : else if (opname==SgName("&")) rtmp << "__ad";
49139 0 : else if (opname==SgName("|")) rtmp << "__or";
49140 0 : else if (opname==SgName(",")) rtmp << "__cm";
49141 0 : else if (opname==SgName("<<")) rtmp << "__ls";
49142 0 : else if (opname==SgName(">>")) rtmp << "__rs";
49143 0 : else if (opname==SgName("--")) rtmp << "__mm";
49144 0 : else if (opname==SgName("++")) rtmp << "__pp";
49145 0 : else if (opname==SgName("~")) rtmp << "__co";
49146 0 : else if (opname==SgName("=")) rtmp << "__as";
49147 0 : else if (opname==SgName("+=")) rtmp << "__apl";
49148 0 : else if (opname==SgName("-=")) rtmp << "__ami";
49149 0 : else if (opname==SgName("&=")) rtmp << "__aad";
49150 0 : else if (opname==SgName("|=")) rtmp << "__aor";
49151 0 : else if (opname==SgName("*=")) rtmp << "__amu";
49152 0 : else if (opname==SgName("/=")) rtmp << "__adv";
49153 0 : else if (opname==SgName("%=")) rtmp << "__amd";
49154 0 : else if (opname==SgName("^=")) rtmp << "__aer";
49155 0 : else if (opname==SgName("<<=")) rtmp << "__als";
49156 0 : else if (opname==SgName(">>=")) rtmp << "__ars";
49157 0 : else if (opname==SgName("()")) rtmp << "__cl";
49158 0 : else if (opname==SgName("[]")) rtmp << "__xi";
49159 : else
49160 : {
49161 : // printf ("In SgType::mangledNameSupport(): This case should never be reached (fname = %s) \n",fname.str());
49162 : // ROSE_ASSERT(false);
49163 :
49164 : // DQ (1/8/2006): This is the case of a name that just happends to start with
49165 : // the work "operator" (e.g. operator_takes_lvalue_operand, in test2005_198.C)
49166 : // the mangle form is just the unmodified function name.
49167 0 : rtmp = fname;
49168 : }
49169 : }
49170 : }
49171 : else
49172 0 : rtmp << fname.str();
49173 :
49174 0 : return rtmp;
49175 : }
49176 :
49177 : bool
49178 57339 : SgType::handledUsingLocalTable(SgType* t)
49179 : {
49180 : // Not all types can use the global type table, since during construction of the AST the
49181 : // scopes may not be fully defined yet. The local type table can be merged into the
49182 : // global type table as a post-processing step.
49183 :
49184 57339 : bool returnValue = false;
49185 :
49186 : // DQ (9/3/2012): I think this should be modified to include SgTemplateType as well.
49187 57339 : if (isSgEnumType(t) != NULL || isSgClassType(t) != NULL || isSgTypedefType(t) != NULL)
49188 : {
49189 : returnValue = true;
49190 : }
49191 :
49192 : // DQ (9/4/2012): I have made SgTemplateType be stored in the local type table.
49193 : // DQ (9/3/2012): I think this should be modified to include SgTemplateType as well.
49194 57339 : SgTemplateType* templateType = isSgTemplateType(t);
49195 57339 : SgNonrealType* nonrealType = isSgNonrealType(t);
49196 57339 : if (templateType != NULL || nonrealType != NULL)
49197 : {
49198 : // printf ("WARNING: In SgType::handledUsingLocalTable(): I think that SgTemplateType should be handled out of the local type table! templateType = %p = %s \n",templateType,templateType->get_name().str());
49199 12023 : returnValue = true;
49200 : }
49201 :
49202 57339 : return returnValue;
49203 : }
49204 :
49205 : // Kitware 2013/03/25
49206 : // This is a workaround for the lack of EDG on Windows.
49207 : // Once that problem is resolved, this include file can go away.
49208 : #ifdef USE_FAKE_EDG
49209 : #include "fake_EDG.h"
49210 : #endif
49211 :
49212 : // Liao 10/29/2010
49213 : // My understanding of this code (may not be accurate):
49214 : // This function was designed to work with C/C++ and Fortran frontends to generate AST.
49215 : // So code has to be conditionized with proper #ifdef ..#endf around the use of the variable or stack.
49216 : //
49217 : // Now we allow users to build types during AST transformation. This function will be called and scope can be NULL
49218 : // Neither the stack or global variable in frontends are used in this situation either.
49219 : // But this is perfectly legal.
49220 : SgScopeStatement*
49221 74491 : SgType::getCurrentScope()
49222 : {
49223 : // This function is used to provide the global type table support with a common
49224 : // mechanism to know the scope when generating types. So types have to know their
49225 : // declaration's scope and it is taken from the current scope that is kept track
49226 : // of using either of a few (two) mechanisms durring the construction of the AST
49227 : // from the frontend. The mechanism is language dependent, or always returning
49228 : // a NULL pointer (in the case of the AST Builder if the stack is not used, and we
49229 : // are not using the EDG 3.3 connection to ROSE...).
49230 :
49231 : // Note that this function is an alternative to the specification of the scope directly
49232 : // in the construction of each IR node. Though I like the direct specification better,
49233 : // such an approach would force us to change the ROSETTA generated API for a moderate
49234 : // number of SgStatement IR nodes and it would likely break some user code. So we need
49235 : // to schedule this for a later date. It should not be an issue for anyone using the
49236 : // AST Build Interface.
49237 :
49238 : // Liao 8/3/2010, pass fortran only test
49239 : // #ifdef ROSE_BUILD_CXX_LANGUAGE_SUPPORT
49240 :
49241 : // Liao 8/4/2010, support enable-only-c
49242 : #ifdef ROSE_BUILD_FORTRAN_LANGUAGE_SUPPORT
49243 : // This is what is used in the Open Fortran Parser connection.
49244 74491 : extern SgScopeStatement* getTopOfScopeStack();
49245 :
49246 : // These functions are used to test if we can use the fortran specific function above.
49247 74491 : extern bool emptyFortranStateStack();
49248 74491 : extern bool emptyFortranScopeStack();
49249 : #endif
49250 :
49251 74491 : SgScopeStatement* currentScope = NULL;
49252 : #ifdef ROSE_BUILD_CXX_LANGUAGE_SUPPORT
49253 74491 : if (SageBuilder::emptyScopeStack() == false)
49254 : {
49255 : // C/C++ AST being generated (using new connection to EDG 4.x).
49256 74484 : currentScope = SageBuilder::topScopeStack();
49257 74484 : ROSE_ASSERT(isSgScopeStatement(currentScope) != NULL);
49258 : }
49259 : else
49260 : #endif
49261 : {
49262 : #ifdef ROSE_BUILD_FORTRAN_LANGUAGE_SUPPORT // Liao 8/4/2010, support enable-only-c
49263 : // DQ (7/31/2010): If Fortran is not enabled then these functions will not be available.
49264 :
49265 : // Changed check for emptyFortranStateStack to emptyFortranScopeStack. An error can occur
49266 : // when the state stack is not empty but the scope stack is. This error was found when
49267 : // running tests in the experimental_frontend_tests directory. Perhaps junk was left in the
49268 : // Fortran state stack from tests run earlier in the parent Fortran test directory.
49269 : // WARNING, the following relies on short circuiting and emptyFortranStateStack() == false
49270 : // must be checked before emptyFortranScopeStack() == false.
49271 : // Apparently Java is also examining the Fortran stack! [CR 2019-7-18].
49272 7 : if (SageInterface::is_Fortran_language() && emptyFortranStateStack() == false && emptyFortranScopeStack() == false)
49273 : {
49274 : // Fortran AST being generated
49275 0 : currentScope = getTopOfScopeStack();
49276 0 : ROSE_ASSERT(isSgScopeStatement(currentScope) != NULL);
49277 : }
49278 : else
49279 : #endif
49280 : {
49281 7 : {
49282 : // This is a code generated after the initial C/C++/Fortran AST was built, so we don't know the current scope.
49283 : // Liao 10/29/2010. We allow users to build types during AST transformation, which will trigger this line.
49284 7 : if ( SgProject::get_verbose() > 1 )
49285 0 : printf ("In SgType::getCurrentScope(): Not in either the generation of C/C++ or Fortran AST construction \n");
49286 : currentScope = NULL;
49287 : }
49288 : }
49289 : }
49290 :
49291 : // DQ (7/23/2010): Add this as another test...
49292 : // ROSE_ASSERT(isSgScopeStatement(currentScope) != NULL);
49293 :
49294 74491 : return currentScope;
49295 : }
49296 :
49297 : SgDeclarationStatement*
49298 5509000 : SgType::getAssociatedDeclaration() const
49299 : {
49300 5509000 : SgDeclarationStatement* declaration = NULL;
49301 :
49302 : // printf ("In SgType::getAssociatedDeclaration(): type = %s \n",class_name().c_str());
49303 :
49304 : // DQ (4/15/2019): Adding support for SgType::STRIP_POINTER_MEMBER_TYPE, not clear if we need it here.
49305 : // printf ("NOTE: SgType::getAssociatedDeclaration(): not using SgType::STRIP_POINTER_MEMBER_TYPE in call to stripType() \n");
49306 :
49307 : // Resolve to the base type (but not past typedef types). Note that a subtle point is that
49308 : // we want to avoid expressing typedefs that are private in functions that are public.
49309 : // SgType* strippedType = this->stripType(SgType::STRIP_MODIFIER_TYPE|SgType::STRIP_REFERENCE_TYPE|SgType::STRIP_RVALUE_REFERENCE_TYPE|SgType::STRIP_POINTER_TYPE|SgType::STRIP_ARRAY_TYPE);
49310 5509000 : SgType* strippedType = this->stripType(SgType::STRIP_MODIFIER_TYPE|SgType::STRIP_REFERENCE_TYPE|SgType::STRIP_RVALUE_REFERENCE_TYPE|SgType::STRIP_POINTER_TYPE|SgType::STRIP_ARRAY_TYPE);
49311 5509000 : ROSE_ASSERT(strippedType != NULL);
49312 :
49313 : // printf ("In getAssociatedDeclaration(): strippedType = %s \n",strippedType->class_name().c_str());
49314 :
49315 : // Check if this is a named type (either SgClassType, SgEnumType, or SgTypedefType).
49316 5509000 : SgNamedType* namedType = isSgNamedType(strippedType);
49317 5509000 : if (namedType != NULL)
49318 : {
49319 : // Look for the declaration and evaluate if it required qualification.
49320 4322580 : declaration = namedType->get_declaration();
49321 4322580 : ROSE_ASSERT(declaration != NULL);
49322 :
49323 : // printf ("In HiddenListTraversal::getDeclarationAssociatedWithType(): declaration = %p = %s \n",declaration,declaration->class_name().c_str());
49324 :
49325 : // DQ (5/25/2013): Check if the declaration might have been deleted.
49326 4322580 : if (declaration->get_freepointer() != AST_FileIO::IS_VALID_POINTER()) {
49327 0 : printf("Found a pointer to a deleted node:\n");
49328 0 : printf(" - type = %p (%s)\n", this, this->class_name().c_str());
49329 0 : printf(" - decl = %p\n", declaration);
49330 0 : printf(" - name : %s\n", SageInterface::generateUniqueName(this, false).c_str());
49331 : }
49332 4322580 : ROSE_ASSERT(declaration->get_freepointer() == AST_FileIO::IS_VALID_POINTER());
49333 : }
49334 :
49335 : #if 0
49336 : // DQ (4/28/2019): Added support for member functions which are the base type of SgPointerMemberType
49337 : // when they are pointers to member functions.
49338 : SgMemberFunctionType* memberFunctionType = isSgMemberFunctionType(strippedType);
49339 : if (memberFunctionType != NULL)
49340 : {
49341 : #if 0
49342 : SgType* associtedClass = memberFunctionType->get_class_type();
49343 : ROSE_ASSERT(associtedClass != NULL);
49344 :
49345 : declaration = associtedClass->getAssociatedDeclaration();
49346 : ROSE_ASSERT(declaration != NULL);
49347 : #else
49348 : // DQ (4/28/2019): I think this is the better implementation.
49349 : SgType* returnType = memberFunctionType->get_return_type();
49350 : ROSE_ASSERT(returnType != NULL);
49351 :
49352 : declaration = returnType->getAssociatedDeclaration();
49353 : #endif
49354 : }
49355 : #endif
49356 :
49357 : #if 1
49358 : // DQ (4/28/2019): Added support for functions (for which a member function is the base type of SgPointerMemberType
49359 : // when they are pointers to member functions.
49360 5509000 : SgFunctionType* functionType = isSgFunctionType(strippedType);
49361 5509000 : if (functionType != NULL)
49362 : {
49363 : // DQ (4/28/2019): I think this is the better implementation.
49364 229634 : SgType* returnType = functionType->get_return_type();
49365 229634 : ROSE_ASSERT(returnType != NULL);
49366 :
49367 229634 : declaration = returnType->getAssociatedDeclaration();
49368 : }
49369 : #endif
49370 :
49371 5509000 : return declaration;
49372 : }
49373 :
49374 0 : bool SgType::hasExplicitType()
49375 : {
49376 : // DQ (3/7/2014): Tis could be implemented as a virtual function but would require 11 functions to be
49377 : // implemented. I have thus instead implemented it as a single function on the SgType instead. We
49378 : // can review this if it is important.
49379 :
49380 : // This function returns true only if this is either a SgPointerType, SgReferenceType, SgPointerMemberType,
49381 : // SgJavaParameterizedType, SgJavaWildcardType, SgModifierType, SgQualifiedNameType, SgFunctionType,
49382 : // SgMemberFunctionType, SgArrayType, SgTypeComplex, or SgTypeImaginary.
49383 :
49384 0 : bool returnValue = false;
49385 :
49386 0 : if ( isSgPointerType(this) != NULL || isSgArrayType(this) != NULL || isSgReferenceType(this) != NULL ||
49387 0 : isSgPointerMemberType(this) != NULL ||
49388 0 : isSgMemberFunctionType(this) != NULL || isSgTypeComplex(this) != NULL || isSgTypeImaginary(this) != NULL ||
49389 0 : isSgFunctionType(this) != NULL || isSgModifierType(this) != NULL)
49390 : {
49391 : returnValue = true;
49392 : }
49393 :
49394 0 : return returnValue;
49395 : }
49396 :
49397 :
49398 : bool
49399 33693600 : SgType::containsInternalTypes()
49400 : {
49401 : // DQ (1/14/2011): Added function to support collection of types in AST node query support.
49402 : // Some types can hide internal types and we often want to resolve type based properties
49403 : // that require us to dig into these specific type IR nodes. For example, when we traverse
49404 : // an AST subtree we might want to build a list of all referenced types (including indirect
49405 : // references through pointers and arrays, etc.). This function is a simple interface that
49406 : // communicates the type IR nodes that can hide internal types and thus may require a
49407 : // nested traversal or a specialized recursive traversal.
49408 :
49409 : // PP (2/17/22) added Ada types
49410 :
49411 33693600 : bool returnValue = false;
49412 :
49413 97905500 : if ( isSgPointerType(this) != NULL || isSgArrayType(this) != NULL || isSgReferenceType(this) != NULL ||
49414 82754000 : isSgTypedefType(this) != NULL || isSgFunctionType(this) != NULL || isSgModifierType(this) != NULL)
49415 : {
49416 : returnValue = true;
49417 : }
49418 :
49419 33693600 : return returnValue;
49420 : }
49421 :
49422 : Rose_STL_Container<SgType*>
49423 28512100 : SgType::getInternalTypes() const
49424 : {
49425 : // This function builds a collection of internal types (unordered).
49426 :
49427 28512100 : Rose_STL_Container<SgType*> internalTypes;
49428 :
49429 : // Cast away const of "this" pointer
49430 28512100 : SgType* currentType = (SgType*) this;
49431 :
49432 28512100 : SgModifierType* modType = NULL;
49433 28512100 : SgPointerType* pointType = NULL;
49434 28512100 : SgReferenceType* refType = NULL;
49435 28512100 : SgArrayType* arrayType = NULL;
49436 28512100 : SgTypedefType* typedefType = NULL;
49437 :
49438 : #if 0
49439 : printf ("In SgType::getInternalTypes(): TOP: currentType = %p = %s \n",currentType,currentType->class_name().c_str());
49440 : #endif
49441 :
49442 : // DQ (3/16/2014): Of coruse we need this.
49443 : // Initialize with the input type (not clear if this is helpful).
49444 : // internalTypes.push_back(currentType);
49445 28512100 : internalTypes.push_back(currentType);
49446 :
49447 47836400 : while (true)
49448 : {
49449 : #if 0
49450 : printf ("In SgType::getInternalTypes(): currentType = %p = %s \n",currentType,currentType->class_name().c_str());
49451 : #endif
49452 47836400 : if ( (modType = isSgModifierType(currentType)) )
49453 : {
49454 1251670 : currentType = modType->get_base_type();
49455 : }
49456 : else
49457 : {
49458 46584800 : if ( (refType = isSgReferenceType(currentType)) )
49459 : {
49460 477694 : currentType = refType->get_base_type();
49461 : }
49462 : else
49463 : {
49464 46107100 : if ( (pointType = isSgPointerType(currentType)) )
49465 : {
49466 1490330 : currentType = pointType->get_base_type();
49467 : }
49468 : else
49469 : {
49470 44616700 : if ( (arrayType = isSgArrayType(currentType)) )
49471 : {
49472 42311 : currentType = arrayType->get_base_type();
49473 : }
49474 : else
49475 : {
49476 44574400 : if ( (typedefType = isSgTypedefType(currentType)) )
49477 : {
49478 16062300 : currentType = typedefType->get_base_type();
49479 : }
49480 : else
49481 : {
49482 : // Exit the while(true){} loop!
49483 :
49484 : // If we have a SgFunctionType then we have to use a different approach to collect
49485 : // the different associated types. I am not clear if this function should have
49486 : // such broad semantics.
49487 28512100 : SgFunctionType* functionType = isSgFunctionType(currentType);
49488 28512100 : if (functionType != NULL)
49489 : {
49490 : #if 0
49491 : printf ("Note: Found a SgFunctionType within SgType::getInternalTypes(), not clear how to handle this case... \n");
49492 : // ROSE_ASSERT(false);
49493 : #endif
49494 : }
49495 :
49496 28512100 : break;
49497 : }
49498 : }
49499 : }
49500 : }
49501 : }
49502 :
49503 : #if 0
49504 : printf ("In SgType::getInternalTypes(): push_back(): currentType = %p = %s \n",currentType,currentType->class_name().c_str());
49505 : #endif
49506 19324300 : internalTypes.push_back(currentType);
49507 : }
49508 :
49509 28512100 : return internalTypes;
49510 : }
49511 :
49512 : void
49513 0 : SgType::reset_base_type(SgType* baseType)
49514 : {
49515 : // DQ (1/15/2011): This function is used to reset types within Fortran handling.
49516 : // Types that have not been see yet and are required to types within construct declarations
49517 : // are assigned a SgTypeDefault which is then replaces after all declarations have been seem.
49518 :
49519 0 : SgType* parentType = (SgType*) this;
49520 :
49521 0 : ROSE_ASSERT(parentType != NULL);
49522 0 : ROSE_ASSERT(parentType->containsInternalTypes() == true);
49523 :
49524 0 : SgModifierType* modType = NULL;
49525 0 : SgPointerType* pointType = NULL;
49526 0 : SgReferenceType* refType = NULL;
49527 0 : SgArrayType* arrayType = NULL;
49528 0 : SgTypedefType* typedefType = NULL;
49529 :
49530 0 : if ( (modType = isSgModifierType(parentType)) )
49531 : {
49532 0 : modType->set_base_type(baseType);
49533 : }
49534 : else
49535 : {
49536 0 : if ( (refType = isSgReferenceType(parentType)) )
49537 : {
49538 0 : refType->set_base_type(baseType);
49539 : }
49540 : else
49541 : {
49542 0 : if ( (pointType = isSgPointerType(parentType)) )
49543 : {
49544 0 : pointType->set_base_type(baseType);
49545 : }
49546 : else
49547 : {
49548 0 : if ( (arrayType = isSgArrayType(parentType)) )
49549 : {
49550 0 : arrayType->set_base_type(baseType);
49551 : }
49552 : else
49553 : {
49554 0 : if ( (typedefType = isSgTypedefType(parentType)) )
49555 : {
49556 : // DQ (1/15/2011): This does not make sense to approach this way, and I think is not required for Fortran support (at least).
49557 : // typedefType->set_base_type(baseType);
49558 0 : ROSE_ASSERT(typedefType->get_declaration() != NULL);
49559 0 : printf ("Error: Typedef can't have there base type reset! \n");
49560 0 : ROSE_ASSERT(false);
49561 : }
49562 : else
49563 : {
49564 0 : printf ("Unable to reset the base type for parentType = %p = %s \n",parentType,parentType->class_name().c_str());
49565 0 : ROSE_ASSERT(false);
49566 : }
49567 : }
49568 : }
49569 : }
49570 : }
49571 0 : }
49572 :
49573 : // SKW (3/1/2011): Added these explicit implementations since we no longer build them automatically
49574 : SgExpression *
49575 3980900 : SgType::get_type_kind () const
49576 : {
49577 3980900 : return p_type_kind;
49578 : }
49579 :
49580 : void
49581 56 : SgType::set_type_kind ( SgExpression* type_kind )
49582 : {
49583 56 : p_type_kind = type_kind;
49584 56 : }
49585 :
49586 :
49587 : bool
49588 291 : SgType::isEquivalentType (const SgType* other_type) const
49589 : {
49590 : // DQ (12/8/2015): This implementation is now refactored into a function implemented in the SageInterface.
49591 :
49592 291 : return SageInterface::isEquivalentType(this,other_type);
49593 : }
49594 :
49595 : #if 0
49596 : // DQ (11/28/2015): Implementation of type equivalence required to support differentiating template instantiations in the symbol table handling.
49597 : // This code needs to be reviewed, since it is critical to the template name lookup (which a lot of general robustness depends upon).
49598 : // bool SgType::operator== (const SgType & Y) const
49599 : bool
49600 : SgType::isEquivalentType (const SgType & Y) const;
49601 : {
49602 : // DQ (11/28/2015): A better goal for this function should be to define it as a recursive function.
49603 :
49604 : bool isSame = false;
49605 :
49606 : // While debugging avoid infinte loops (most type chains in STL and boost are only a 3-4 long in test2015_127.C, nesting is how it goes wild).
49607 : static int counter = 0;
49608 :
49609 : const SgType & X = *this;
49610 :
49611 : #error "DEAD CODE!"
49612 :
49613 : // DQ (11/28/2015): We don't want to strip off everything.
49614 : // SgType* stripType(unsigned char bit_array = STRIP_MODIFIER_TYPE | STRIP_REFERENCE_TYPE | STRIP_POINTER_TYPE | STRIP_ARRAY_TYPE | STRIP_TYPEDEF_TYPE ) const;
49615 :
49616 : // I think we need to compute the type chain to evaluate equalence.
49617 : // Rose_STL_Container< SgType*> getInternalTypes () const
49618 :
49619 : Rose_STL_Container<SgType*> X_typeChain = X.getInternalTypes();
49620 : Rose_STL_Container<SgType*> Y_typeChain = Y.getInternalTypes();
49621 :
49622 : #define DEBUG_TYPE_EQUIVALENCE 0
49623 :
49624 : #if DEBUG_TYPE_EQUIVALENCE
49625 : printf ("In SgType::operator==(): evaluation of type equivalence for lhs and rhs: counter = %d \n",counter);
49626 : #endif
49627 : #if DEBUG_TYPE_EQUIVALENCE
49628 : // Debugging output.
49629 : printf ("Output of type chain for lhs: \n");
49630 : for (size_t i = 0; i < X_typeChain.size(); i++)
49631 : {
49632 : SgType* element_type = X_typeChain[i];
49633 : printf ("X_element_type = %p = %s \n",element_type,element_type->class_name().c_str());
49634 : SgModifierType* modifierType = isSgModifierType(element_type);
49635 : if (modifierType != NULL)
49636 : {
49637 : // modifierType->get_typeModifier().display("X type chain");
49638 : string s = modifierType->get_typeModifier().displayString();
49639 : printf (" --- type chain modifier: %s \n",s.c_str());
49640 : }
49641 : }
49642 :
49643 : printf ("Output of type chain for rhs: \n");
49644 : for (size_t i = 0; i < Y_typeChain.size(); i++)
49645 : {
49646 : SgType* element_type = Y_typeChain[i];
49647 : printf ("Y_element_type = %p = %s \n",element_type,element_type->class_name().c_str());
49648 : SgModifierType* modifierType = isSgModifierType(element_type);
49649 : if (modifierType != NULL)
49650 : {
49651 : // modifierType->get_typeModifier().display("Y type chain");
49652 : string s = modifierType->get_typeModifier().displayString();
49653 : printf (" --- type chain modifier: %s \n",s.c_str());
49654 : }
49655 : }
49656 : #endif
49657 :
49658 : // Increment the static variable to control the recursive d3epth while we debug this.
49659 : counter++;
49660 :
49661 : // DQ (11/28/2015): exit in stead of infinte recursion.
49662 : if (counter > 100)
49663 : {
49664 : // DQ (11/28/2015): I htink this is a reasonable limit.
49665 : printf ("ERROR: In SgType::operator==(): recursive limit exceeded for : counter = %d \n",counter);
49666 : ROSE_ASSERT(false);
49667 :
49668 : return false;
49669 : }
49670 :
49671 : // bool exit = false;
49672 :
49673 : // DQ (11/28/2015): exit in stead of infinte recursion.
49674 : if (counter > 90)
49675 : {
49676 : printf ("In SgType::operator==(): counter = %d: type chain X_element_type = %s Y_element_type = %s \n",counter,X.class_name().c_str(),Y.class_name().c_str());
49677 : }
49678 :
49679 : // Strip off ant typedefs since they are equivalent by definition.
49680 : SgType* X_element_type = X.stripType( STRIP_TYPEDEF_TYPE );
49681 : SgType* Y_element_type = Y.stripType( STRIP_TYPEDEF_TYPE );
49682 :
49683 : // DQ (11/29/2015): We need to handle reference (when they are both references we can support then uniformally).
49684 : SgReferenceType* X_referenceType = isSgReferenceType(X_element_type);
49685 : SgReferenceType* Y_referenceType = isSgReferenceType(Y_element_type);
49686 :
49687 : if (X_referenceType != NULL && Y_referenceType != NULL)
49688 : {
49689 : X_element_type = X_referenceType->get_base_type();
49690 : Y_element_type = Y_referenceType->get_base_type();
49691 :
49692 : counter--;
49693 :
49694 : // Recursive call.
49695 : return (*X_element_type) == (*Y_element_type);
49696 : }
49697 : else
49698 : {
49699 : }
49700 :
49701 : SgModifierType* X_modifierType = isSgModifierType(X_element_type);
49702 : SgModifierType* Y_modifierType = isSgModifierType(Y_element_type);
49703 :
49704 : #if DEBUG_TYPE_EQUIVALENCE
49705 : printf ("In SgType::operator==(): counter = %d: type chain X_element_type = %p = %s Y_element_type = %p = %s \n",
49706 : counter,X_element_type,X_element_type->class_name().c_str(),Y_element_type,Y_element_type->class_name().c_str());
49707 : #endif
49708 :
49709 : if (X_modifierType != NULL && Y_modifierType != NULL)
49710 : {
49711 : // Handle the case of both modifiers.
49712 : #if DEBUG_TYPE_EQUIVALENCE
49713 : printf ("In SgType::operator==(): loop: these are the both SgModifierType nodes: isSame = %s \n",isSame ? "true" : "false");
49714 : #endif
49715 : if (X_modifierType == Y_modifierType)
49716 : {
49717 : isSame = true;
49718 : #if DEBUG_TYPE_EQUIVALENCE
49719 : printf ("In SgType::operator==(): loop: these are the same modifier type: isSame = %s \n",isSame ? "true" : "false");
49720 : #endif
49721 : }
49722 : else
49723 : {
49724 : if (X_modifierType->get_typeModifier() == Y_modifierType->get_typeModifier())
49725 : {
49726 : #if DEBUG_TYPE_EQUIVALENCE
49727 : printf ("In SgType::operator==(): loop: these are equivalent modifiers: check the base type: isSame = %s \n",isSame ? "true" : "false");
49728 : #endif
49729 : // Recursive call.
49730 : isSame = (*X_modifierType->get_base_type()) == (*Y_modifierType->get_base_type());
49731 : }
49732 : else
49733 : {
49734 : #if DEBUG_TYPE_EQUIVALENCE
49735 : printf ("In SgType::operator==(): loop: these are not equivalent modifier types: check for default settings: isSame = %s \n",isSame ? "true" : "false");
49736 : #endif
49737 : // if (X_modifierType->get_typeModifier().isDefault() == true)
49738 : if (X_modifierType->get_typeModifier().isIdentity() == true)
49739 : {
49740 : #if DEBUG_TYPE_EQUIVALENCE
49741 : printf ("In SgType::operator==(): loop: found self-similar setting for lhs: isSame = %s \n",isSame ? "true" : "false");
49742 : #endif
49743 : X_element_type = X_modifierType->get_base_type();
49744 : }
49745 :
49746 : // if (Y_modifierType->get_typeModifier().isDefault() == true)
49747 : if (Y_modifierType->get_typeModifier().isIdentity() == true)
49748 : {
49749 : #if DEBUG_TYPE_EQUIVALENCE
49750 : printf ("In SgType::operator==(): loop: found self-similar setting for rhs: isSame = %s \n",isSame ? "true" : "false");
49751 : #endif
49752 : Y_element_type = Y_modifierType->get_base_type();
49753 : }
49754 :
49755 : // NOTE: If either of these are a SgTypedefType then the typedefs will be stripped away at the top of the recursive call.
49756 : #if DEBUG_TYPE_EQUIVALENCE
49757 : printf ("In SgType::operator==(): loop: recursive call on different adjusted modifier types: before recursive call to compare base types: isSame = %s \n",isSame ? "true" : "false");
49758 : #endif
49759 : // Recursive call on non-default modifier base types.
49760 : isSame = (*X_element_type) == (*Y_element_type);
49761 : #if DEBUG_TYPE_EQUIVALENCE
49762 : printf ("In SgType::operator==(): loop: these are different modifier types: after recursive call to compare base types: isSame = %s \n",isSame ? "true" : "false");
49763 : #endif
49764 : }
49765 : }
49766 : }
49767 : else
49768 : {
49769 : // At least one of these is not a SgModifierType.
49770 :
49771 : if (X_modifierType != NULL || Y_modifierType != NULL)
49772 : {
49773 : bool isReduceable = false;
49774 :
49775 : // if (X_modifierType != NULL && X_modifierType->get_typeModifier().isDefault() == true)
49776 : if (X_modifierType != NULL && X_modifierType->get_typeModifier().isIdentity() == true)
49777 : {
49778 : #if DEBUG_TYPE_EQUIVALENCE
49779 : printf ("In SgType::operator==(): loop: found default setting for lhs: isSame = %s \n",isSame ? "true" : "false");
49780 : #endif
49781 : X_element_type = X_modifierType->get_base_type();
49782 : isReduceable = true;
49783 : }
49784 :
49785 : // if (Y_modifierType != NULL && Y_modifierType->get_typeModifier().isDefault() == true)
49786 : // if (Y_modifierType != NULL && Y_modifierType->get_typeModifier().isIdentity() == true)
49787 : if (Y_modifierType != NULL && Y_modifierType->get_typeModifier().isIdentity() == true)
49788 : {
49789 : #if DEBUG_TYPE_EQUIVALENCE
49790 : printf ("In SgType::operator==(): loop: found default setting for rhs: isSame = %s \n",isSame ? "true" : "false");
49791 : #endif
49792 : Y_element_type = Y_modifierType->get_base_type();
49793 : isReduceable = true;
49794 : }
49795 :
49796 : // NOTE: If either of these are a SgTypedefType then the typedefs will be stripped away at the top of the recursive call.
49797 : #if DEBUG_TYPE_EQUIVALENCE
49798 : printf ("In SgType::operator==(): loop: these are different modifier types: after recursive call to compare base types: isReduceable = %s \n",isReduceable ? "true" : "false");
49799 : #endif
49800 : if (isReduceable == true)
49801 : {
49802 : // Recursive call on non-default modifier base types.
49803 : isSame = (*X_element_type) == (*Y_element_type);
49804 : }
49805 : else
49806 : {
49807 : // Neither of these types were reducable.
49808 : isSame = false;
49809 : }
49810 :
49811 : #if DEBUG_TYPE_EQUIVALENCE
49812 : printf ("In SgType::operator==(): loop: these are different modifier types: after recursive call to compare base types: isReduceable = %s isSame = %s \n",
49813 : isReduceable ? "true" : "false",isSame ? "true" : "false");
49814 : #endif
49815 : }
49816 : else
49817 : {
49818 : // Neither of these are SgModifierType nodes.
49819 : // X_element_type = X_element_type->stripType( STRIP_TYPEDEF_TYPE );
49820 : // Y_element_type = Y_element_type->stripType( STRIP_TYPEDEF_TYPE );
49821 :
49822 : if (X_element_type == Y_element_type)
49823 : {
49824 : isSame = true;
49825 : #if DEBUG_TYPE_EQUIVALENCE
49826 : printf ("In SgType::operator==(): resolved to equal types: isSame = %s \n",isSame ? "true" : "false");
49827 : #endif
49828 : }
49829 : else
49830 : {
49831 : bool isReduceable = false;
49832 :
49833 : // DQ (11/29/2015): We need to handle reference (when they are both references we can support then uniformally).
49834 : SgReferenceType* X_referenceType = isSgReferenceType(X_element_type);
49835 : SgReferenceType* Y_referenceType = isSgReferenceType(Y_element_type);
49836 :
49837 : if (X_referenceType != NULL || Y_referenceType != NULL)
49838 : {
49839 :
49840 : if (X_referenceType != NULL)
49841 : {
49842 : X_element_type = X_referenceType->get_base_type();
49843 : isReduceable = true;
49844 : }
49845 :
49846 : if (Y_referenceType != NULL)
49847 : {
49848 : Y_element_type = Y_referenceType->get_base_type();
49849 : isReduceable = true;
49850 : }
49851 :
49852 : if (isReduceable == true)
49853 : {
49854 : // Recursive call on non-default modifier base types.
49855 : isSame = (*X_element_type) == (*Y_element_type);
49856 : }
49857 : else
49858 : {
49859 : // Neither of these types were reducable.
49860 : isSame = false;
49861 : }
49862 : }
49863 : else
49864 : {
49865 : // DQ (11/29/2015): I think we need to add support for SgPointerType as well.
49866 :
49867 : // Recursive call on non-typedef base types.
49868 : isSame = (*X_element_type) == (*Y_element_type);
49869 : #if DEBUG_TYPE_EQUIVALENCE
49870 : printf ("In SgType::operator==(): loop: evaluation of inner types: isSame = %s \n",isSame ? "true" : "false");
49871 : #endif
49872 : }
49873 : }
49874 : }
49875 : }
49876 :
49877 : // Decrement the static variable to control the recursive depth while we debug this.
49878 : counter--;
49879 :
49880 : #if DEBUG_TYPE_EQUIVALENCE
49881 : printf ("In SgType::operator==(): isSame = %s \n",isSame ? "true" : "false");
49882 : #endif
49883 :
49884 : #error "DEAD CODE!"
49885 :
49886 : return isSame;
49887 : }
49888 : #endif
49889 :
49890 :
49891 :
49892 :
49893 :
49894 :
49895 :
49896 : // End of memberFunctionString
49897 : // Start of memberFunctionString
49898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
49899 :
49900 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
49901 :
49902 : bool
49903 112 : SgType::get_isCoArray () const
49904 : {
49905 112 : ROSE_ASSERT (this != NULL);
49906 :
49907 : #if 0
49908 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
49909 : // used to trigger marking transformations for the token-based unparsing.
49910 : printf ("SgType::get_isCoArray = %p = %s \n",this,this->class_name().c_str());
49911 : #endif
49912 :
49913 112 : return p_isCoArray;
49914 : }
49915 :
49916 : void
49917 0 : SgType::set_isCoArray ( bool isCoArray )
49918 : {
49919 0 : ROSE_ASSERT (this != NULL);
49920 :
49921 : #if 0
49922 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
49923 : // used to trigger marking transformations for the token-based unparsing.
49924 : printf ("SgType::set_isCoArray = %p = %s \n",this,this->class_name().c_str());
49925 : #endif
49926 :
49927 0 : set_isModified(true);
49928 :
49929 0 : p_isCoArray = isCoArray;
49930 0 : }
49931 :
49932 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
49933 :
49934 :
49935 : // End of memberFunctionString
49936 : // Start of memberFunctionString
49937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
49938 :
49939 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
49940 :
49941 : int
49942 0 : SgType::get_substitutedForTemplateParam () const
49943 : {
49944 0 : ROSE_ASSERT (this != NULL);
49945 :
49946 : #if 0
49947 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
49948 : // used to trigger marking transformations for the token-based unparsing.
49949 : printf ("SgType::get_substitutedForTemplateParam = %p = %s \n",this,this->class_name().c_str());
49950 : #endif
49951 :
49952 0 : return p_substitutedForTemplateParam;
49953 : }
49954 :
49955 : void
49956 0 : SgType::set_substitutedForTemplateParam ( int substitutedForTemplateParam )
49957 : {
49958 0 : ROSE_ASSERT (this != NULL);
49959 :
49960 : #if 0
49961 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
49962 : // used to trigger marking transformations for the token-based unparsing.
49963 : printf ("SgType::set_substitutedForTemplateParam = %p = %s \n",this,this->class_name().c_str());
49964 : #endif
49965 :
49966 0 : set_isModified(true);
49967 :
49968 0 : p_substitutedForTemplateParam = substitutedForTemplateParam;
49969 0 : }
49970 :
49971 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
49972 :
49973 :
49974 : // End of memberFunctionString
49975 : // Start of memberFunctionString
49976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
49977 :
49978 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
49979 :
49980 : SgReferenceType*
49981 0 : SgType::get_ref_to () const
49982 : {
49983 0 : ROSE_ASSERT (this != NULL);
49984 :
49985 : #if 0
49986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
49987 : // used to trigger marking transformations for the token-based unparsing.
49988 : printf ("SgType::get_ref_to = %p = %s \n",this,this->class_name().c_str());
49989 : #endif
49990 :
49991 0 : return p_ref_to;
49992 : }
49993 :
49994 : void
49995 0 : SgType::set_ref_to ( SgReferenceType* ref_to )
49996 : {
49997 0 : ROSE_ASSERT (this != NULL);
49998 :
49999 : #if 0
50000 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50001 : // used to trigger marking transformations for the token-based unparsing.
50002 : printf ("SgType::set_ref_to = %p = %s \n",this,this->class_name().c_str());
50003 : #endif
50004 :
50005 0 : set_isModified(true);
50006 :
50007 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50008 : if (p_ref_to != NULL && ref_to != NULL && p_ref_to != ref_to)
50009 : {
50010 : printf ("Warning: ref_to = %p overwriting valid pointer p_ref_to = %p \n",ref_to,p_ref_to);
50011 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50012 : printf ("Error fails assertion (p_ref_to != NULL && ref_to != NULL && p_ref_to != ref_to) is false\n");
50013 : ROSE_ASSERT(false);
50014 : #endif
50015 : }
50016 : #endif
50017 0 : p_ref_to = ref_to;
50018 0 : }
50019 :
50020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50021 :
50022 :
50023 : // End of memberFunctionString
50024 : // Start of memberFunctionString
50025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50026 :
50027 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50028 :
50029 : SgPointerType*
50030 0 : SgType::get_ptr_to () const
50031 : {
50032 0 : ROSE_ASSERT (this != NULL);
50033 :
50034 : #if 0
50035 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50036 : // used to trigger marking transformations for the token-based unparsing.
50037 : printf ("SgType::get_ptr_to = %p = %s \n",this,this->class_name().c_str());
50038 : #endif
50039 :
50040 0 : return p_ptr_to;
50041 : }
50042 :
50043 : void
50044 0 : SgType::set_ptr_to ( SgPointerType* ptr_to )
50045 : {
50046 0 : ROSE_ASSERT (this != NULL);
50047 :
50048 : #if 0
50049 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50050 : // used to trigger marking transformations for the token-based unparsing.
50051 : printf ("SgType::set_ptr_to = %p = %s \n",this,this->class_name().c_str());
50052 : #endif
50053 :
50054 0 : set_isModified(true);
50055 :
50056 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50057 : if (p_ptr_to != NULL && ptr_to != NULL && p_ptr_to != ptr_to)
50058 : {
50059 : printf ("Warning: ptr_to = %p overwriting valid pointer p_ptr_to = %p \n",ptr_to,p_ptr_to);
50060 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50061 : printf ("Error fails assertion (p_ptr_to != NULL && ptr_to != NULL && p_ptr_to != ptr_to) is false\n");
50062 : ROSE_ASSERT(false);
50063 : #endif
50064 : }
50065 : #endif
50066 0 : p_ptr_to = ptr_to;
50067 0 : }
50068 :
50069 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50070 :
50071 :
50072 : // End of memberFunctionString
50073 : // Start of memberFunctionString
50074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50075 :
50076 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50077 :
50078 : SgModifierNodes*
50079 21817 : SgType::get_modifiers () const
50080 : {
50081 21817 : ROSE_ASSERT (this != NULL);
50082 :
50083 : #if 0
50084 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50085 : // used to trigger marking transformations for the token-based unparsing.
50086 : printf ("SgType::get_modifiers = %p = %s \n",this,this->class_name().c_str());
50087 : #endif
50088 :
50089 21817 : return p_modifiers;
50090 : }
50091 :
50092 : void
50093 0 : SgType::set_modifiers ( SgModifierNodes* modifiers )
50094 : {
50095 0 : ROSE_ASSERT (this != NULL);
50096 :
50097 : #if 0
50098 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50099 : // used to trigger marking transformations for the token-based unparsing.
50100 : printf ("SgType::set_modifiers = %p = %s \n",this,this->class_name().c_str());
50101 : #endif
50102 :
50103 0 : set_isModified(true);
50104 :
50105 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50106 : if (p_modifiers != NULL && modifiers != NULL && p_modifiers != modifiers)
50107 : {
50108 : printf ("Warning: modifiers = %p overwriting valid pointer p_modifiers = %p \n",modifiers,p_modifiers);
50109 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50110 : printf ("Error fails assertion (p_modifiers != NULL && modifiers != NULL && p_modifiers != modifiers) is false\n");
50111 : ROSE_ASSERT(false);
50112 : #endif
50113 : }
50114 : #endif
50115 0 : p_modifiers = modifiers;
50116 0 : }
50117 :
50118 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50119 :
50120 :
50121 : // End of memberFunctionString
50122 : // Start of memberFunctionString
50123 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50124 :
50125 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50126 :
50127 : SgTypedefSeq*
50128 116136 : SgType::get_typedefs () const
50129 : {
50130 116136 : ROSE_ASSERT (this != NULL);
50131 :
50132 : #if 0
50133 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50134 : // used to trigger marking transformations for the token-based unparsing.
50135 : printf ("SgType::get_typedefs = %p = %s \n",this,this->class_name().c_str());
50136 : #endif
50137 :
50138 116136 : return p_typedefs;
50139 : }
50140 :
50141 : void
50142 0 : SgType::set_typedefs ( SgTypedefSeq* typedefs )
50143 : {
50144 0 : ROSE_ASSERT (this != NULL);
50145 :
50146 : #if 0
50147 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50148 : // used to trigger marking transformations for the token-based unparsing.
50149 : printf ("SgType::set_typedefs = %p = %s \n",this,this->class_name().c_str());
50150 : #endif
50151 :
50152 0 : set_isModified(true);
50153 :
50154 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50155 : if (p_typedefs != NULL && typedefs != NULL && p_typedefs != typedefs)
50156 : {
50157 : printf ("Warning: typedefs = %p overwriting valid pointer p_typedefs = %p \n",typedefs,p_typedefs);
50158 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50159 : printf ("Error fails assertion (p_typedefs != NULL && typedefs != NULL && p_typedefs != typedefs) is false\n");
50160 : ROSE_ASSERT(false);
50161 : #endif
50162 : }
50163 : #endif
50164 0 : p_typedefs = typedefs;
50165 0 : }
50166 :
50167 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50168 :
50169 :
50170 : // End of memberFunctionString
50171 : // Start of memberFunctionString
50172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50173 :
50174 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50175 :
50176 : SgRvalueReferenceType*
50177 0 : SgType::get_rvalue_ref_to () const
50178 : {
50179 0 : ROSE_ASSERT (this != NULL);
50180 :
50181 : #if 0
50182 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50183 : // used to trigger marking transformations for the token-based unparsing.
50184 : printf ("SgType::get_rvalue_ref_to = %p = %s \n",this,this->class_name().c_str());
50185 : #endif
50186 :
50187 0 : return p_rvalue_ref_to;
50188 : }
50189 :
50190 : void
50191 0 : SgType::set_rvalue_ref_to ( SgRvalueReferenceType* rvalue_ref_to )
50192 : {
50193 0 : ROSE_ASSERT (this != NULL);
50194 :
50195 : #if 0
50196 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50197 : // used to trigger marking transformations for the token-based unparsing.
50198 : printf ("SgType::set_rvalue_ref_to = %p = %s \n",this,this->class_name().c_str());
50199 : #endif
50200 :
50201 0 : set_isModified(true);
50202 :
50203 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50204 : if (p_rvalue_ref_to != NULL && rvalue_ref_to != NULL && p_rvalue_ref_to != rvalue_ref_to)
50205 : {
50206 : printf ("Warning: rvalue_ref_to = %p overwriting valid pointer p_rvalue_ref_to = %p \n",rvalue_ref_to,p_rvalue_ref_to);
50207 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50208 : printf ("Error fails assertion (p_rvalue_ref_to != NULL && rvalue_ref_to != NULL && p_rvalue_ref_to != rvalue_ref_to) is false\n");
50209 : ROSE_ASSERT(false);
50210 : #endif
50211 : }
50212 : #endif
50213 0 : p_rvalue_ref_to = rvalue_ref_to;
50214 0 : }
50215 :
50216 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50217 :
50218 :
50219 : // End of memberFunctionString
50220 : // Start of memberFunctionString
50221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50222 :
50223 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50224 :
50225 : SgDeclType*
50226 0 : SgType::get_decltype_ref_to () const
50227 : {
50228 0 : ROSE_ASSERT (this != NULL);
50229 :
50230 : #if 0
50231 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50232 : // used to trigger marking transformations for the token-based unparsing.
50233 : printf ("SgType::get_decltype_ref_to = %p = %s \n",this,this->class_name().c_str());
50234 : #endif
50235 :
50236 0 : return p_decltype_ref_to;
50237 : }
50238 :
50239 : void
50240 0 : SgType::set_decltype_ref_to ( SgDeclType* decltype_ref_to )
50241 : {
50242 0 : ROSE_ASSERT (this != NULL);
50243 :
50244 : #if 0
50245 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50246 : // used to trigger marking transformations for the token-based unparsing.
50247 : printf ("SgType::set_decltype_ref_to = %p = %s \n",this,this->class_name().c_str());
50248 : #endif
50249 :
50250 0 : set_isModified(true);
50251 :
50252 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50253 : if (p_decltype_ref_to != NULL && decltype_ref_to != NULL && p_decltype_ref_to != decltype_ref_to)
50254 : {
50255 : printf ("Warning: decltype_ref_to = %p overwriting valid pointer p_decltype_ref_to = %p \n",decltype_ref_to,p_decltype_ref_to);
50256 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50257 : printf ("Error fails assertion (p_decltype_ref_to != NULL && decltype_ref_to != NULL && p_decltype_ref_to != decltype_ref_to) is false\n");
50258 : ROSE_ASSERT(false);
50259 : #endif
50260 : }
50261 : #endif
50262 0 : p_decltype_ref_to = decltype_ref_to;
50263 0 : }
50264 :
50265 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50266 :
50267 :
50268 : // End of memberFunctionString
50269 : // Start of memberFunctionString
50270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50271 :
50272 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50273 :
50274 : SgTypeOfType*
50275 0 : SgType::get_typeof_ref_to () const
50276 : {
50277 0 : ROSE_ASSERT (this != NULL);
50278 :
50279 : #if 0
50280 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50281 : // used to trigger marking transformations for the token-based unparsing.
50282 : printf ("SgType::get_typeof_ref_to = %p = %s \n",this,this->class_name().c_str());
50283 : #endif
50284 :
50285 0 : return p_typeof_ref_to;
50286 : }
50287 :
50288 : void
50289 0 : SgType::set_typeof_ref_to ( SgTypeOfType* typeof_ref_to )
50290 : {
50291 0 : ROSE_ASSERT (this != NULL);
50292 :
50293 : #if 0
50294 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50295 : // used to trigger marking transformations for the token-based unparsing.
50296 : printf ("SgType::set_typeof_ref_to = %p = %s \n",this,this->class_name().c_str());
50297 : #endif
50298 :
50299 0 : set_isModified(true);
50300 :
50301 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50302 : if (p_typeof_ref_to != NULL && typeof_ref_to != NULL && p_typeof_ref_to != typeof_ref_to)
50303 : {
50304 : printf ("Warning: typeof_ref_to = %p overwriting valid pointer p_typeof_ref_to = %p \n",typeof_ref_to,p_typeof_ref_to);
50305 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50306 : printf ("Error fails assertion (p_typeof_ref_to != NULL && typeof_ref_to != NULL && p_typeof_ref_to != typeof_ref_to) is false\n");
50307 : ROSE_ASSERT(false);
50308 : #endif
50309 : }
50310 : #endif
50311 0 : p_typeof_ref_to = typeof_ref_to;
50312 0 : }
50313 :
50314 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50315 :
50316 :
50317 : // End of memberFunctionString
50318 : // Start of memberFunctionString
50319 :
50320 :
50321 : // End of memberFunctionString
50322 : // Start of memberFunctionString
50323 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
50324 :
50325 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50326 :
50327 : AstAttributeMechanism*
50328 0 : SgType::get_attributeMechanism () const
50329 : {
50330 0 : ROSE_ASSERT (this != NULL);
50331 0 : return p_attributeMechanism;
50332 : }
50333 :
50334 : void
50335 0 : SgType::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
50336 : {
50337 0 : ROSE_ASSERT (this != NULL);
50338 :
50339 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
50340 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
50341 : {
50342 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
50343 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
50344 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
50345 : ROSE_ASSERT(false);
50346 : #endif
50347 : }
50348 : #endif
50349 0 : p_attributeMechanism = attributeMechanism;
50350 0 : }
50351 :
50352 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50353 :
50354 :
50355 : // End of memberFunctionString
50356 : // Start of memberFunctionString
50357 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
50358 :
50359 :
50360 : #if 0
50361 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
50362 : // a pointer and the interface represented directly at the SgNode
50363 : AstAttributeMechanism &
50364 : SgType::attribute()
50365 : {
50366 : // DQ (1/2/2006): This function preserves as much of
50367 : // the syntax of attribute being a public data member.
50368 : if (p_attribute == NULL)
50369 : {
50370 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
50371 : assert(false);
50372 : }
50373 :
50374 : return *p_attribute;
50375 : }
50376 : #endif
50377 :
50378 : void
50379 0 : SgType::addNewAttribute( std::string s, AstAttribute* a )
50380 : {
50381 0 : if (get_attributeMechanism() == NULL)
50382 : {
50383 0 : set_attributeMechanism( new AstAttributeMechanism() );
50384 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
50385 : }
50386 0 : get_attributeMechanism()->add(s,a);
50387 0 : }
50388 :
50389 : void
50390 0 : SgType::setAttribute( std::string s, AstAttribute* a )
50391 : {
50392 0 : if (get_attributeMechanism() == NULL)
50393 : {
50394 0 : set_attributeMechanism( new AstAttributeMechanism() );
50395 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
50396 : }
50397 0 : get_attributeMechanism()->set(s,a);
50398 0 : }
50399 :
50400 : AstAttribute*
50401 0 : SgType::getAttribute(std::string s) const
50402 : {
50403 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
50404 0 : if (attributeExists(s)==false) return NULL;
50405 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
50406 0 : ROSE_ASSERT(returnValue != NULL);
50407 0 : return returnValue;
50408 : }
50409 :
50410 : void
50411 0 : SgType::updateAttribute( std::string s, AstAttribute* a )
50412 : {
50413 : // formerly called: replace
50414 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
50415 0 : get_attributeMechanism()->replace(s,a);
50416 0 : }
50417 :
50418 : void
50419 0 : SgType::removeAttribute(std::string s)
50420 : {
50421 0 : if (get_attributeMechanism())
50422 0 : get_attributeMechanism()->remove(s);
50423 :
50424 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
50425 0 : int remainingCount = numberOfAttributes();
50426 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
50427 0 : if (remainingCount == 0)
50428 : {
50429 0 : delete get_attributeMechanism();
50430 0 : set_attributeMechanism(NULL);
50431 : }
50432 0 : }
50433 :
50434 : bool
50435 0 : SgType::attributeExists(std::string s) const
50436 : {
50437 0 : bool returnValue = false;
50438 0 : if (get_attributeMechanism() != NULL)
50439 0 : returnValue = get_attributeMechanism()->exists(s);
50440 0 : return returnValue;
50441 : }
50442 :
50443 : int
50444 0 : SgType::numberOfAttributes() const
50445 : {
50446 0 : int returnValue = 0;
50447 0 : if (get_attributeMechanism() != NULL)
50448 0 : returnValue = get_attributeMechanism()->size();
50449 0 : return returnValue;
50450 : }
50451 :
50452 :
50453 :
50454 : // End of memberFunctionString
50455 : // Start of memberFunctionString
50456 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
50457 :
50458 : // *** COMMON CODE SECTION BEGINS HERE ***
50459 :
50460 : #if 0
50461 : int
50462 : SgType::getVariant() const
50463 : {
50464 : // This function is used in ROSE while "variant()" is used in SAGE
50465 : assert(this != NULL);
50466 : return variant();
50467 : }
50468 : #endif
50469 :
50470 : // This function is used in ROSE in treeTraversal code
50471 : // eventually replaces getVariant() and variant()
50472 : // though after variant() has been removed for a while we will
50473 : // want to change the name of variantT() back to variant()
50474 : // (since the "T" was ment to stand for temporary).
50475 : // When this happens the variantT() will be depricated.
50476 : VariantT
50477 0 : SgType::variantT() const
50478 : {
50479 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
50480 0 : ROSE_ASSERT(this != NULL);
50481 0 : return V_SgType;
50482 : }
50483 :
50484 : #if 0
50485 : int
50486 : SgType::variant() const
50487 : {
50488 : // This function is used in SAGE
50489 : ROSE_ASSERT(this != NULL);
50490 : return TypeTag;
50491 : }
50492 : #endif
50493 :
50494 : ROSE_DLL_API const char*
50495 0 : SgType::sage_class_name() const
50496 : {
50497 0 : ROSE_ASSERT(this != NULL);
50498 0 : return "SgType";
50499 : }
50500 :
50501 : std::string
50502 0 : SgType::class_name() const
50503 : {
50504 0 : ROSE_ASSERT(this != NULL);
50505 0 : return "SgType";
50506 : }
50507 :
50508 : // DQ (11/26/2005): Support for visitor pattern mechanims
50509 : // (inferior to ROSE traversal mechanism, experimental).
50510 : void
50511 0 : SgType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
50512 : {
50513 0 : ROSE_ASSERT(this != NULL);
50514 0 : visitor.visit(this);
50515 0 : }
50516 :
50517 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
50518 0 : void SgType::accept (ROSE_VisitorPattern & visitor) {
50519 0 : ROSE_ASSERT(this != NULL);
50520 0 : visitor.visit(this);
50521 0 : }
50522 :
50523 : SgType*
50524 0 : SgType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
50525 : {
50526 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
50527 : // This function is currently only supported for the AST used the represent Binary executables.
50528 : if (0 /* isSgAsmNode(this) != NULL */)
50529 : {
50530 : // Support for regex specification.
50531 : std::string prefixCode = "REGEX:";
50532 : addNewAttribute(prefixCode + s,a);
50533 : }
50534 : #endif
50535 :
50536 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
50537 0 : return this;
50538 : }
50539 :
50540 : // *** COMMON CODE SECTION ENDS HERE ***
50541 :
50542 :
50543 : // End of memberFunctionString
50544 : // Start of memberFunctionString
50545 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
50546 :
50547 :
50548 : #if 0
50549 : //! Error checking support
50550 : /*! Verifies the following:
50551 : - working getVariant() member function
50552 : - calls base class's error() member function
50553 : Every class has one of these functions.
50554 : */
50555 : bool
50556 : SgType::error()
50557 : {
50558 : // Put error checking here
50559 :
50560 : ROSE_ASSERT (this != NULL);
50561 : if (getVariant() != TypeTag)
50562 : {
50563 : printf ("Error in SgType::error(): SgType object has a %s variant \n",
50564 : Cxx_GrammarTerminalNames[getVariant()].name);
50565 : // printf ("Error in SgType::error() \n");
50566 : ROSE_ABORT();
50567 : }
50568 :
50569 : ROSE_ASSERT (getVariant() == TypeTag);
50570 : return SgNode::error();
50571 : }
50572 : #endif
50573 :
50574 :
50575 :
50576 : // End of memberFunctionString
50577 :
50578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
50579 :
50580 581009000 : SgType* isSgType ( SgNode* inputDerivedClassPointer )
50581 : {
50582 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
50583 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
50584 : // So to fix this we return NULL directly when the input is NULL and avoid the
50585 : // dynamic_cast in this case. This is likely a performance improvement as well.
50586 : // return dynamic_cast<SgType*>(inputDerivedClassPointer);
50587 : // Milind Chabbi (8/28/2013): isSgType uses table-driven castability instead of c++ default dynamic_cast
50588 : // this improves the running time performance by 10-20%.
50589 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgType*>(inputDerivedClassPointer);
50590 581009000 : return IS_SgType_FAST_MACRO(inputDerivedClassPointer);
50591 : }
50592 :
50593 : // DQ (11/8/2003): Added version of functions taking const pointer
50594 3358210 : const SgType* isSgType ( const SgNode* inputDerivedClassPointer )
50595 : {
50596 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
50597 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
50598 : // So to fix this we return NULL directly when the input is NULL and avoid the
50599 : // dynamic_cast in this case. This is likely a performance improvement as well.
50600 : // return dynamic_cast<const SgType*>(inputDerivedClassPointer);
50601 : // Milind Chabbi (8/28/2013): isSgType uses table-driven castability instead of c++ default dynamic_cast
50602 : // this improves the running time performance by 10-20%.
50603 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgType*>(inputDerivedClassPointer);
50604 3358210 : return IS_SgType_FAST_MACRO(inputDerivedClassPointer);
50605 : }
50606 :
50607 :
50608 :
50609 : /* #line 50610 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
50610 :
50611 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
50612 :
50613 : /**
50614 : \brief Generated destructor
50615 :
50616 : This destructor is automatically generated (by ROSETTA). This destructor
50617 : only frees memory of data members associated with the parts of the current IR node which
50618 : are NOT traversed. Those data members that are part of a traversal can be freed using
50619 : a traversal (calling this destructor on all children in a post-order traversal). Such
50620 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
50621 :
50622 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
50623 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
50624 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
50625 :
50626 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
50627 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
50628 : pointers are not yet implemented to call delete on eash pointer in the container.
50629 : (This could be done by derivation from the STL containers to define containers that
50630 : automatically deleted their members.)
50631 :
50632 : */
50633 197209 : SgType::~SgType () {
50634 197209 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
50635 :
50636 197209 : if (p_typedefs && p_typedefs->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_typedefs; }
50637 197209 : if (p_type_kind && p_type_kind->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_type_kind; }
50638 :
50639 : // case: not a listType for isCoArray
50640 197209 : p_isCoArray = 0; // non list case
50641 : // case: not a listType for substitutedForTemplateParam
50642 197209 : p_substitutedForTemplateParam = 0; // non list case
50643 : // case: not a listType for ref_to
50644 197209 : p_ref_to = NULL; // non list case
50645 : // case: not a listType for ptr_to
50646 197209 : p_ptr_to = NULL; // non list case
50647 : // case: not a listType for modifiers
50648 197209 : p_modifiers = NULL; // non list case
50649 : // case: not a listType for typedefs
50650 197209 : p_typedefs = NULL; // non list case
50651 : // case: not a listType for rvalue_ref_to
50652 197209 : p_rvalue_ref_to = NULL; // non list case
50653 : // case: not a listType for decltype_ref_to
50654 197209 : p_decltype_ref_to = NULL; // non list case
50655 : // case: not a listType for typeof_ref_to
50656 197209 : p_typeof_ref_to = NULL; // non list case
50657 : // case: not a listType for type_kind
50658 197209 : p_type_kind = NULL; // non list case
50659 : // case: not a listType for attributeMechanism
50660 197209 : p_attributeMechanism = NULL; // non list case
50661 :
50662 : }
50663 :
50664 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
50665 197209 : }
50666 :
50667 :
50668 : /* #line 50669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
50669 :
50670 :
50671 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
50672 :
50673 :
50674 : // ********************************************************
50675 : // member functions common across all array grammar objects
50676 : // ********************************************************
50677 :
50678 :
50679 :
50680 : /* #line 50681 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
50681 :
50682 :
50683 :
50684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
50685 :
50686 : // ********************************************************
50687 : // member functions specific to each node in the grammar
50688 : // ********************************************************
50689 :
50690 :
50691 : /* #line 50692 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
50692 :
50693 : // Start of memberFunctionString
50694 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50695 :
50696 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50697 :
50698 : std::string
50699 0 : SgTypeUnknown::get_type_name () const
50700 : {
50701 0 : ROSE_ASSERT (this != NULL);
50702 :
50703 : #if 0
50704 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50705 : // used to trigger marking transformations for the token-based unparsing.
50706 : printf ("SgTypeUnknown::get_type_name = %p = %s \n",this,this->class_name().c_str());
50707 : #endif
50708 :
50709 0 : return p_type_name;
50710 : }
50711 :
50712 : void
50713 0 : SgTypeUnknown::set_type_name ( std::string type_name )
50714 : {
50715 0 : ROSE_ASSERT (this != NULL);
50716 :
50717 : #if 0
50718 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50719 : // used to trigger marking transformations for the token-based unparsing.
50720 : printf ("SgTypeUnknown::set_type_name = %p = %s \n",this,this->class_name().c_str());
50721 : #endif
50722 :
50723 0 : set_isModified(true);
50724 :
50725 0 : p_type_name = type_name;
50726 0 : }
50727 :
50728 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50729 :
50730 :
50731 : // End of memberFunctionString
50732 : // Start of memberFunctionString
50733 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
50734 :
50735 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
50736 :
50737 : bool
50738 0 : SgTypeUnknown::get_has_type_name () const
50739 : {
50740 0 : ROSE_ASSERT (this != NULL);
50741 :
50742 : #if 0
50743 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50744 : // used to trigger marking transformations for the token-based unparsing.
50745 : printf ("SgTypeUnknown::get_has_type_name = %p = %s \n",this,this->class_name().c_str());
50746 : #endif
50747 :
50748 0 : return p_has_type_name;
50749 : }
50750 :
50751 : void
50752 0 : SgTypeUnknown::set_has_type_name ( bool has_type_name )
50753 : {
50754 0 : ROSE_ASSERT (this != NULL);
50755 :
50756 : #if 0
50757 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
50758 : // used to trigger marking transformations for the token-based unparsing.
50759 : printf ("SgTypeUnknown::set_has_type_name = %p = %s \n",this,this->class_name().c_str());
50760 : #endif
50761 :
50762 0 : set_isModified(true);
50763 :
50764 0 : p_has_type_name = has_type_name;
50765 0 : }
50766 :
50767 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
50768 :
50769 :
50770 : // End of memberFunctionString
50771 : // Start of memberFunctionString
50772 :
50773 :
50774 : // End of memberFunctionString
50775 : // Start of memberFunctionString
50776 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
50777 :
50778 : // *** COMMON CODE SECTION BEGINS HERE ***
50779 :
50780 : #if 0
50781 : int
50782 : SgTypeUnknown::getVariant() const
50783 : {
50784 : // This function is used in ROSE while "variant()" is used in SAGE
50785 : assert(this != NULL);
50786 : return variant();
50787 : }
50788 : #endif
50789 :
50790 : // This function is used in ROSE in treeTraversal code
50791 : // eventually replaces getVariant() and variant()
50792 : // though after variant() has been removed for a while we will
50793 : // want to change the name of variantT() back to variant()
50794 : // (since the "T" was ment to stand for temporary).
50795 : // When this happens the variantT() will be depricated.
50796 : VariantT
50797 208885 : SgTypeUnknown::variantT() const
50798 : {
50799 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
50800 208885 : ROSE_ASSERT(this != NULL);
50801 208885 : return V_SgTypeUnknown;
50802 : }
50803 :
50804 : #if 0
50805 : int
50806 : SgTypeUnknown::variant() const
50807 : {
50808 : // This function is used in SAGE
50809 : ROSE_ASSERT(this != NULL);
50810 : return T_UNKNOWN;
50811 : }
50812 : #endif
50813 :
50814 : ROSE_DLL_API const char*
50815 0 : SgTypeUnknown::sage_class_name() const
50816 : {
50817 0 : ROSE_ASSERT(this != NULL);
50818 0 : return "SgTypeUnknown";
50819 : }
50820 :
50821 : std::string
50822 1705 : SgTypeUnknown::class_name() const
50823 : {
50824 1705 : ROSE_ASSERT(this != NULL);
50825 1705 : return "SgTypeUnknown";
50826 : }
50827 :
50828 : // DQ (11/26/2005): Support for visitor pattern mechanims
50829 : // (inferior to ROSE traversal mechanism, experimental).
50830 : void
50831 137 : SgTypeUnknown::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
50832 : {
50833 137 : ROSE_ASSERT(this != NULL);
50834 137 : visitor.visit(this);
50835 137 : }
50836 :
50837 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
50838 0 : void SgTypeUnknown::accept (ROSE_VisitorPattern & visitor) {
50839 0 : ROSE_ASSERT(this != NULL);
50840 0 : visitor.visit(this);
50841 0 : }
50842 :
50843 : SgTypeUnknown*
50844 0 : SgTypeUnknown::addRegExpAttribute(std::string s, AstRegExAttribute* a)
50845 : {
50846 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
50847 : // This function is currently only supported for the AST used the represent Binary executables.
50848 : if (0 /* isSgAsmNode(this) != NULL */)
50849 : {
50850 : // Support for regex specification.
50851 : std::string prefixCode = "REGEX:";
50852 : addNewAttribute(prefixCode + s,a);
50853 : }
50854 : #endif
50855 :
50856 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
50857 0 : return this;
50858 : }
50859 :
50860 : // *** COMMON CODE SECTION ENDS HERE ***
50861 :
50862 :
50863 : // End of memberFunctionString
50864 : // Start of memberFunctionString
50865 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
50866 :
50867 :
50868 : #if 0
50869 : //! Error checking support
50870 : /*! Verifies the following:
50871 : - working getVariant() member function
50872 : - calls base class's error() member function
50873 : Every class has one of these functions.
50874 : */
50875 : bool
50876 : SgTypeUnknown::error()
50877 : {
50878 : // Put error checking here
50879 :
50880 : ROSE_ASSERT (this != NULL);
50881 : if (getVariant() != T_UNKNOWN)
50882 : {
50883 : printf ("Error in SgTypeUnknown::error(): SgTypeUnknown object has a %s variant \n",
50884 : Cxx_GrammarTerminalNames[getVariant()].name);
50885 : // printf ("Error in SgTypeUnknown::error() \n");
50886 : ROSE_ABORT();
50887 : }
50888 :
50889 : ROSE_ASSERT (getVariant() == T_UNKNOWN);
50890 : return SgType::error();
50891 : }
50892 : #endif
50893 :
50894 :
50895 :
50896 : // End of memberFunctionString
50897 : // Start of memberFunctionString
50898 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
50899 :
50900 :
50901 : // DQ (1/31/2006): Modified to build all types in the memory pools
50902 : // SgTypeUnknown SgTypeUnknown::builtin_type;
50903 : // SgTypeUnknown* SgTypeUnknown::builtin_type = new SgTypeUnknown();
50904 : SgTypeUnknown* SgTypeUnknown::p_builtin_type = NULL;
50905 :
50906 :
50907 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
50908 : // SgTypeUnknown* SgTypeUnknown::createType(void)
50909 : SgTypeUnknown*
50910 19645 : SgTypeUnknown::createType(SgExpression* optional_fortran_type_kind)
50911 : {
50912 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
50913 : // is not called (likely because static initialization is compiler dependent).
50914 : // DQ (1/31/2006): Modified to build all types in the memory pools
50915 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
50916 : // return &builtin_type;
50917 :
50918 : #if 0
50919 : printf ("In SgTypeUnknown::createType() (COMMON_CREATE_TYPE) \n");
50920 : #endif
50921 :
50922 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
50923 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
50924 :
50925 19645 : SgTypeUnknown* temp_type = new SgTypeUnknown();
50926 :
50927 : #if 0
50928 : printf ("In SgTypeUnknown::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
50929 : #endif
50930 :
50931 : // DQ (10/31/2016): Added assertion.
50932 19645 : ROSE_ASSERT(temp_type != NULL);
50933 :
50934 19645 : if (optional_fortran_type_kind != NULL)
50935 : {
50936 : // DQ (10/31/2016): Added assertion.
50937 0 : ROSE_ASSERT(temp_type != NULL);
50938 :
50939 0 : temp_type->set_type_kind(optional_fortran_type_kind);
50940 : }
50941 : #if 0
50942 : else
50943 : {
50944 : // Let p_builtin_type refer to the unadorned type (no type kind).
50945 : p_builtin_type = temp_type;
50946 : }
50947 : #endif
50948 :
50949 19645 : SgName name = temp_type->get_mangled();
50950 :
50951 : #if 0
50952 : printf ("Mangled type name for SgTypeUnknown = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
50953 : #endif
50954 :
50955 : // DQ (10/31/2016): Added assertion.
50956 19645 : ROSE_ASSERT(get_globalTypeTable() != NULL);
50957 :
50958 19645 : SgType* t = get_globalTypeTable()->lookup_type(name);
50959 :
50960 : #if 0
50961 : printf ("In SgTypeUnknown::createType(): type from lookup_type = %p \n",t);
50962 : #endif
50963 :
50964 19645 : if (t == NULL)
50965 : {
50966 28 : get_globalTypeTable()->insert_type(name,temp_type);
50967 : }
50968 : else
50969 : {
50970 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
50971 19617 : if (t != temp_type)
50972 : {
50973 : #if 0
50974 : printf ("In SgTypeUnknown::createType(): deleting temp_type = %p \n",temp_type);
50975 : #endif
50976 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
50977 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
50978 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
50979 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
50980 19617 : delete temp_type;
50981 : #endif
50982 19617 : temp_type = NULL;
50983 : #if 0
50984 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
50985 : if (optional_fortran_type_kind != NULL)
50986 : {
50987 : p_builtin_type = NULL;
50988 : }
50989 : #endif
50990 : }
50991 :
50992 : // Reuse this tempType variable so we can use the same code below.
50993 19617 : temp_type = isSgTypeUnknown(t);
50994 19617 : ROSE_ASSERT(temp_type != NULL);
50995 : }
50996 :
50997 : #if 0
50998 : printf ("Leaving SgTypeUnknown::createType(): temp_type = %p \n",temp_type);
50999 : #endif
51000 :
51001 19645 : return temp_type;
51002 : }
51003 :
51004 :
51005 :
51006 : // End of memberFunctionString
51007 : // Start of memberFunctionString
51008 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
51009 :
51010 : #if 1
51011 : /*! Support for mangled names (for unparser)
51012 : There are two different cases of source code for the get_mangled member function
51013 : This one is used in all but the classes containing a base type
51014 : */
51015 : // SgName SgTypeUnknown::get_mangled ( SgUnparse_Info & info )
51016 : SgName
51017 19646 : SgTypeUnknown::get_mangled (void) const
51018 : {
51019 19646 : ROSE_ASSERT(this != NULL);
51020 :
51021 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
51022 : // CR (3/6/2020): Now type_kind is also used for Jovial.
51023 19646 : SgName name = "Unknown";
51024 19646 : if (get_type_kind() != NULL)
51025 : {
51026 : // name += get_type_kind()->get_mangled();
51027 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
51028 0 : SgValueExp* value = isSgValueExp(get_type_kind());
51029 0 : if (value != NULL)
51030 : {
51031 : // name += string("_") + StringUtility::numberToString(value->get_value());
51032 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
51033 : }
51034 : else
51035 : {
51036 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
51037 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
51038 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
51039 : // a different prefix for each type of named type. It come down to is there can be multiple
51040 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
51041 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
51042 : // I think the issue is that Unknown is not defined for any of the SgNameType IR nodes.
51043 : #if 0
51044 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Unknown");
51045 : #endif
51046 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
51047 : }
51048 : }
51049 :
51050 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
51051 : // REMOVE_ME please!
51052 19646 : if (isSgTypeFixed(this))
51053 : {
51054 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
51055 0 : if (fixed_type->get_scale() != NULL)
51056 : {
51057 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
51058 0 : if (value != NULL)
51059 : {
51060 0 : name += string("_") + value->get_constant_folded_value_as_string();
51061 : }
51062 : }
51063 0 : if (fixed_type->get_fraction() != NULL)
51064 : {
51065 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
51066 0 : if (value != NULL)
51067 : {
51068 0 : name += string("_") + value->get_constant_folded_value_as_string();
51069 : }
51070 : }
51071 : }
51072 :
51073 : #if 0
51074 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
51075 : #endif
51076 :
51077 19646 : return name;
51078 : }
51079 : #endif
51080 :
51081 :
51082 : // End of memberFunctionString
51083 :
51084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
51085 :
51086 66729 : SgTypeUnknown* isSgTypeUnknown ( SgNode* inputDerivedClassPointer )
51087 : {
51088 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
51089 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
51090 : // So to fix this we return NULL directly when the input is NULL and avoid the
51091 : // dynamic_cast in this case. This is likely a performance improvement as well.
51092 : // return dynamic_cast<SgTypeUnknown*>(inputDerivedClassPointer);
51093 : // Milind Chabbi (8/28/2013): isSgTypeUnknown uses table-driven castability instead of c++ default dynamic_cast
51094 : // this improves the running time performance by 10-20%.
51095 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnknown*>(inputDerivedClassPointer);
51096 66729 : return IS_SgTypeUnknown_FAST_MACRO(inputDerivedClassPointer);
51097 : }
51098 :
51099 : // DQ (11/8/2003): Added version of functions taking const pointer
51100 0 : const SgTypeUnknown* isSgTypeUnknown ( const SgNode* inputDerivedClassPointer )
51101 : {
51102 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
51103 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
51104 : // So to fix this we return NULL directly when the input is NULL and avoid the
51105 : // dynamic_cast in this case. This is likely a performance improvement as well.
51106 : // return dynamic_cast<const SgTypeUnknown*>(inputDerivedClassPointer);
51107 : // Milind Chabbi (8/28/2013): isSgTypeUnknown uses table-driven castability instead of c++ default dynamic_cast
51108 : // this improves the running time performance by 10-20%.
51109 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnknown*>(inputDerivedClassPointer);
51110 0 : return IS_SgTypeUnknown_FAST_MACRO(inputDerivedClassPointer);
51111 : }
51112 :
51113 :
51114 :
51115 : /* #line 51116 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51116 :
51117 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
51118 :
51119 : /**
51120 : \brief Generated destructor
51121 :
51122 : This destructor is automatically generated (by ROSETTA). This destructor
51123 : only frees memory of data members associated with the parts of the current IR node which
51124 : are NOT traversed. Those data members that are part of a traversal can be freed using
51125 : a traversal (calling this destructor on all children in a post-order traversal). Such
51126 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
51127 :
51128 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
51129 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
51130 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
51131 :
51132 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
51133 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
51134 : pointers are not yet implemented to call delete on eash pointer in the container.
51135 : (This could be done by derivation from the STL containers to define containers that
51136 : automatically deleted their members.)
51137 :
51138 : */
51139 39238 : SgTypeUnknown::~SgTypeUnknown () {
51140 19619 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
51141 :
51142 :
51143 : // case: not a listType for type_name
51144 19619 : p_type_name = ""; // non list case
51145 : // case: not a listType for has_type_name
51146 19619 : p_has_type_name = false; // non list case
51147 :
51148 : }
51149 :
51150 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
51151 39238 : }
51152 :
51153 :
51154 : /* #line 51155 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51155 :
51156 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
51157 :
51158 : // Generated constructor
51159 19645 : SgTypeUnknown::SgTypeUnknown ( )
51160 19645 : : SgType()
51161 : {
51162 : #ifdef DEBUG
51163 : // printf ("In SgTypeUnknown::SgTypeUnknown () sage_class_name() = %s \n",sage_class_name());
51164 : #endif
51165 : #if 0
51166 : // debugging information!
51167 : printf ("In SgTypeUnknown::SgTypeUnknown (): this = %p = %s \n",this,this->class_name().c_str());
51168 : #endif
51169 :
51170 19645 : p_type_name = "";
51171 19645 : p_has_type_name = false;
51172 :
51173 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
51174 :
51175 : #if 0
51176 : // DQ (7/30/2014): Call a virtual function.
51177 : std::string s = this->class_name();
51178 : #endif
51179 :
51180 : // Test the variant virtual function
51181 : // assert(T_UNKNOWN == variant());
51182 19645 : assert(T_UNKNOWN == this->variant());
51183 19645 : ROSE_ASSERT(T_UNKNOWN == (int)(this->variantT()));
51184 19645 : post_construction_initialization();
51185 :
51186 : // Test the isSgTypeUnknown() function since it has been problematic
51187 19645 : assert(isSgTypeUnknown(this) != NULL);
51188 19645 : }
51189 :
51190 : // Generated constructor (all data members)
51191 :
51192 : /* #line 51193 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51193 :
51194 :
51195 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
51196 :
51197 :
51198 : // ********************************************************
51199 : // member functions common across all array grammar objects
51200 : // ********************************************************
51201 :
51202 :
51203 :
51204 : /* #line 51205 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51205 :
51206 :
51207 :
51208 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
51209 :
51210 : // ********************************************************
51211 : // member functions specific to each node in the grammar
51212 : // ********************************************************
51213 :
51214 :
51215 : /* #line 51216 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51216 :
51217 : // Start of memberFunctionString
51218 :
51219 :
51220 : // End of memberFunctionString
51221 : // Start of memberFunctionString
51222 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
51223 :
51224 : // *** COMMON CODE SECTION BEGINS HERE ***
51225 :
51226 : #if 0
51227 : int
51228 : SgTypeChar::getVariant() const
51229 : {
51230 : // This function is used in ROSE while "variant()" is used in SAGE
51231 : assert(this != NULL);
51232 : return variant();
51233 : }
51234 : #endif
51235 :
51236 : // This function is used in ROSE in treeTraversal code
51237 : // eventually replaces getVariant() and variant()
51238 : // though after variant() has been removed for a while we will
51239 : // want to change the name of variantT() back to variant()
51240 : // (since the "T" was ment to stand for temporary).
51241 : // When this happens the variantT() will be depricated.
51242 : VariantT
51243 84530000 : SgTypeChar::variantT() const
51244 : {
51245 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
51246 84530000 : ROSE_ASSERT(this != NULL);
51247 84530000 : return V_SgTypeChar;
51248 : }
51249 :
51250 : #if 0
51251 : int
51252 : SgTypeChar::variant() const
51253 : {
51254 : // This function is used in SAGE
51255 : ROSE_ASSERT(this != NULL);
51256 : return T_CHAR;
51257 : }
51258 : #endif
51259 :
51260 : ROSE_DLL_API const char*
51261 0 : SgTypeChar::sage_class_name() const
51262 : {
51263 0 : ROSE_ASSERT(this != NULL);
51264 0 : return "SgTypeChar";
51265 : }
51266 :
51267 : std::string
51268 1001 : SgTypeChar::class_name() const
51269 : {
51270 1001 : ROSE_ASSERT(this != NULL);
51271 1001 : return "SgTypeChar";
51272 : }
51273 :
51274 : // DQ (11/26/2005): Support for visitor pattern mechanims
51275 : // (inferior to ROSE traversal mechanism, experimental).
51276 : void
51277 194 : SgTypeChar::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
51278 : {
51279 194 : ROSE_ASSERT(this != NULL);
51280 194 : visitor.visit(this);
51281 194 : }
51282 :
51283 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
51284 0 : void SgTypeChar::accept (ROSE_VisitorPattern & visitor) {
51285 0 : ROSE_ASSERT(this != NULL);
51286 0 : visitor.visit(this);
51287 0 : }
51288 :
51289 : SgTypeChar*
51290 0 : SgTypeChar::addRegExpAttribute(std::string s, AstRegExAttribute* a)
51291 : {
51292 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
51293 : // This function is currently only supported for the AST used the represent Binary executables.
51294 : if (0 /* isSgAsmNode(this) != NULL */)
51295 : {
51296 : // Support for regex specification.
51297 : std::string prefixCode = "REGEX:";
51298 : addNewAttribute(prefixCode + s,a);
51299 : }
51300 : #endif
51301 :
51302 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
51303 0 : return this;
51304 : }
51305 :
51306 : // *** COMMON CODE SECTION ENDS HERE ***
51307 :
51308 :
51309 : // End of memberFunctionString
51310 : // Start of memberFunctionString
51311 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
51312 :
51313 :
51314 : #if 0
51315 : //! Error checking support
51316 : /*! Verifies the following:
51317 : - working getVariant() member function
51318 : - calls base class's error() member function
51319 : Every class has one of these functions.
51320 : */
51321 : bool
51322 : SgTypeChar::error()
51323 : {
51324 : // Put error checking here
51325 :
51326 : ROSE_ASSERT (this != NULL);
51327 : if (getVariant() != T_CHAR)
51328 : {
51329 : printf ("Error in SgTypeChar::error(): SgTypeChar object has a %s variant \n",
51330 : Cxx_GrammarTerminalNames[getVariant()].name);
51331 : // printf ("Error in SgTypeChar::error() \n");
51332 : ROSE_ABORT();
51333 : }
51334 :
51335 : ROSE_ASSERT (getVariant() == T_CHAR);
51336 : return SgType::error();
51337 : }
51338 : #endif
51339 :
51340 :
51341 :
51342 : // End of memberFunctionString
51343 : // Start of memberFunctionString
51344 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
51345 :
51346 :
51347 : // DQ (1/31/2006): Modified to build all types in the memory pools
51348 : // SgTypeChar SgTypeChar::builtin_type;
51349 : // SgTypeChar* SgTypeChar::builtin_type = new SgTypeChar();
51350 : SgTypeChar* SgTypeChar::p_builtin_type = NULL;
51351 :
51352 :
51353 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
51354 : // SgTypeChar* SgTypeChar::createType(void)
51355 : SgTypeChar*
51356 808 : SgTypeChar::createType(SgExpression* optional_fortran_type_kind)
51357 : {
51358 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
51359 : // is not called (likely because static initialization is compiler dependent).
51360 : // DQ (1/31/2006): Modified to build all types in the memory pools
51361 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
51362 : // return &builtin_type;
51363 :
51364 : #if 0
51365 : printf ("In SgTypeChar::createType() (COMMON_CREATE_TYPE) \n");
51366 : #endif
51367 :
51368 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
51369 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
51370 :
51371 808 : SgTypeChar* temp_type = new SgTypeChar();
51372 :
51373 : #if 0
51374 : printf ("In SgTypeChar::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
51375 : #endif
51376 :
51377 : // DQ (10/31/2016): Added assertion.
51378 808 : ROSE_ASSERT(temp_type != NULL);
51379 :
51380 808 : if (optional_fortran_type_kind != NULL)
51381 : {
51382 : // DQ (10/31/2016): Added assertion.
51383 0 : ROSE_ASSERT(temp_type != NULL);
51384 :
51385 0 : temp_type->set_type_kind(optional_fortran_type_kind);
51386 : }
51387 : #if 0
51388 : else
51389 : {
51390 : // Let p_builtin_type refer to the unadorned type (no type kind).
51391 : p_builtin_type = temp_type;
51392 : }
51393 : #endif
51394 :
51395 808 : SgName name = temp_type->get_mangled();
51396 :
51397 : #if 0
51398 : printf ("Mangled type name for SgTypeChar = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
51399 : #endif
51400 :
51401 : // DQ (10/31/2016): Added assertion.
51402 808 : ROSE_ASSERT(get_globalTypeTable() != NULL);
51403 :
51404 808 : SgType* t = get_globalTypeTable()->lookup_type(name);
51405 :
51406 : #if 0
51407 : printf ("In SgTypeChar::createType(): type from lookup_type = %p \n",t);
51408 : #endif
51409 :
51410 808 : if (t == NULL)
51411 : {
51412 315 : get_globalTypeTable()->insert_type(name,temp_type);
51413 : }
51414 : else
51415 : {
51416 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
51417 493 : if (t != temp_type)
51418 : {
51419 : #if 0
51420 : printf ("In SgTypeChar::createType(): deleting temp_type = %p \n",temp_type);
51421 : #endif
51422 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
51423 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
51424 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
51425 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
51426 493 : delete temp_type;
51427 : #endif
51428 493 : temp_type = NULL;
51429 : #if 0
51430 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
51431 : if (optional_fortran_type_kind != NULL)
51432 : {
51433 : p_builtin_type = NULL;
51434 : }
51435 : #endif
51436 : }
51437 :
51438 : // Reuse this tempType variable so we can use the same code below.
51439 493 : temp_type = isSgTypeChar(t);
51440 493 : ROSE_ASSERT(temp_type != NULL);
51441 : }
51442 :
51443 : #if 0
51444 : printf ("Leaving SgTypeChar::createType(): temp_type = %p \n",temp_type);
51445 : #endif
51446 :
51447 808 : return temp_type;
51448 : }
51449 :
51450 :
51451 :
51452 : // End of memberFunctionString
51453 : // Start of memberFunctionString
51454 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
51455 :
51456 : #if 1
51457 : /*! Support for mangled names (for unparser)
51458 : There are two different cases of source code for the get_mangled member function
51459 : This one is used in all but the classes containing a base type
51460 : */
51461 : // SgName SgTypeChar::get_mangled ( SgUnparse_Info & info )
51462 : SgName
51463 356520 : SgTypeChar::get_mangled (void) const
51464 : {
51465 356520 : ROSE_ASSERT(this != NULL);
51466 :
51467 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
51468 : // CR (3/6/2020): Now type_kind is also used for Jovial.
51469 356520 : SgName name = "c";
51470 356520 : if (get_type_kind() != NULL)
51471 : {
51472 : // name += get_type_kind()->get_mangled();
51473 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
51474 0 : SgValueExp* value = isSgValueExp(get_type_kind());
51475 0 : if (value != NULL)
51476 : {
51477 : // name += string("_") + StringUtility::numberToString(value->get_value());
51478 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
51479 : }
51480 : else
51481 : {
51482 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
51483 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
51484 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
51485 : // a different prefix for each type of named type. It come down to is there can be multiple
51486 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
51487 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
51488 : // I think the issue is that c is not defined for any of the SgNameType IR nodes.
51489 : #if 0
51490 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"c");
51491 : #endif
51492 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
51493 : }
51494 : }
51495 :
51496 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
51497 : // REMOVE_ME please!
51498 356520 : if (isSgTypeFixed(this))
51499 : {
51500 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
51501 0 : if (fixed_type->get_scale() != NULL)
51502 : {
51503 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
51504 0 : if (value != NULL)
51505 : {
51506 0 : name += string("_") + value->get_constant_folded_value_as_string();
51507 : }
51508 : }
51509 0 : if (fixed_type->get_fraction() != NULL)
51510 : {
51511 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
51512 0 : if (value != NULL)
51513 : {
51514 0 : name += string("_") + value->get_constant_folded_value_as_string();
51515 : }
51516 : }
51517 : }
51518 :
51519 : #if 0
51520 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
51521 : #endif
51522 :
51523 356520 : return name;
51524 : }
51525 : #endif
51526 :
51527 :
51528 : // End of memberFunctionString
51529 :
51530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
51531 :
51532 1357 : SgTypeChar* isSgTypeChar ( SgNode* inputDerivedClassPointer )
51533 : {
51534 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
51535 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
51536 : // So to fix this we return NULL directly when the input is NULL and avoid the
51537 : // dynamic_cast in this case. This is likely a performance improvement as well.
51538 : // return dynamic_cast<SgTypeChar*>(inputDerivedClassPointer);
51539 : // Milind Chabbi (8/28/2013): isSgTypeChar uses table-driven castability instead of c++ default dynamic_cast
51540 : // this improves the running time performance by 10-20%.
51541 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeChar*>(inputDerivedClassPointer);
51542 1357 : return IS_SgTypeChar_FAST_MACRO(inputDerivedClassPointer);
51543 : }
51544 :
51545 : // DQ (11/8/2003): Added version of functions taking const pointer
51546 0 : const SgTypeChar* isSgTypeChar ( const SgNode* inputDerivedClassPointer )
51547 : {
51548 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
51549 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
51550 : // So to fix this we return NULL directly when the input is NULL and avoid the
51551 : // dynamic_cast in this case. This is likely a performance improvement as well.
51552 : // return dynamic_cast<const SgTypeChar*>(inputDerivedClassPointer);
51553 : // Milind Chabbi (8/28/2013): isSgTypeChar uses table-driven castability instead of c++ default dynamic_cast
51554 : // this improves the running time performance by 10-20%.
51555 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeChar*>(inputDerivedClassPointer);
51556 0 : return IS_SgTypeChar_FAST_MACRO(inputDerivedClassPointer);
51557 : }
51558 :
51559 :
51560 :
51561 : /* #line 51562 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51562 :
51563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
51564 :
51565 : /**
51566 : \brief Generated destructor
51567 :
51568 : This destructor is automatically generated (by ROSETTA). This destructor
51569 : only frees memory of data members associated with the parts of the current IR node which
51570 : are NOT traversed. Those data members that are part of a traversal can be freed using
51571 : a traversal (calling this destructor on all children in a post-order traversal). Such
51572 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
51573 :
51574 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
51575 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
51576 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
51577 :
51578 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
51579 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
51580 : pointers are not yet implemented to call delete on eash pointer in the container.
51581 : (This could be done by derivation from the STL containers to define containers that
51582 : automatically deleted their members.)
51583 :
51584 : */
51585 994 : SgTypeChar::~SgTypeChar () {
51586 497 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
51587 :
51588 :
51589 :
51590 : }
51591 :
51592 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
51593 994 : }
51594 :
51595 :
51596 : /* #line 51597 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51597 :
51598 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
51599 :
51600 : // Generated constructor
51601 808 : SgTypeChar::SgTypeChar ( )
51602 808 : : SgType()
51603 : {
51604 : #ifdef DEBUG
51605 : // printf ("In SgTypeChar::SgTypeChar () sage_class_name() = %s \n",sage_class_name());
51606 : #endif
51607 : #if 0
51608 : // debugging information!
51609 : printf ("In SgTypeChar::SgTypeChar (): this = %p = %s \n",this,this->class_name().c_str());
51610 : #endif
51611 :
51612 :
51613 :
51614 : #if 0
51615 : // DQ (7/30/2014): Call a virtual function.
51616 : std::string s = this->class_name();
51617 : #endif
51618 :
51619 : // Test the variant virtual function
51620 : // assert(T_CHAR == variant());
51621 808 : assert(T_CHAR == this->variant());
51622 808 : ROSE_ASSERT(T_CHAR == (int)(this->variantT()));
51623 808 : post_construction_initialization();
51624 :
51625 : // Test the isSgTypeChar() function since it has been problematic
51626 808 : assert(isSgTypeChar(this) != NULL);
51627 808 : }
51628 :
51629 : // Generated constructor (all data members)
51630 :
51631 : /* #line 51632 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51632 :
51633 :
51634 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
51635 :
51636 :
51637 : // ********************************************************
51638 : // member functions common across all array grammar objects
51639 : // ********************************************************
51640 :
51641 :
51642 :
51643 : /* #line 51644 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51644 :
51645 :
51646 :
51647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
51648 :
51649 : // ********************************************************
51650 : // member functions specific to each node in the grammar
51651 : // ********************************************************
51652 :
51653 :
51654 : /* #line 51655 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
51655 :
51656 : // Start of memberFunctionString
51657 :
51658 :
51659 : // End of memberFunctionString
51660 : // Start of memberFunctionString
51661 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
51662 :
51663 : // *** COMMON CODE SECTION BEGINS HERE ***
51664 :
51665 : #if 0
51666 : int
51667 : SgTypeSignedChar::getVariant() const
51668 : {
51669 : // This function is used in ROSE while "variant()" is used in SAGE
51670 : assert(this != NULL);
51671 : return variant();
51672 : }
51673 : #endif
51674 :
51675 : // This function is used in ROSE in treeTraversal code
51676 : // eventually replaces getVariant() and variant()
51677 : // though after variant() has been removed for a while we will
51678 : // want to change the name of variantT() back to variant()
51679 : // (since the "T" was ment to stand for temporary).
51680 : // When this happens the variantT() will be depricated.
51681 : VariantT
51682 364836 : SgTypeSignedChar::variantT() const
51683 : {
51684 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
51685 364836 : ROSE_ASSERT(this != NULL);
51686 364836 : return V_SgTypeSignedChar;
51687 : }
51688 :
51689 : #if 0
51690 : int
51691 : SgTypeSignedChar::variant() const
51692 : {
51693 : // This function is used in SAGE
51694 : ROSE_ASSERT(this != NULL);
51695 : return T_SIGNED_CHAR;
51696 : }
51697 : #endif
51698 :
51699 : ROSE_DLL_API const char*
51700 0 : SgTypeSignedChar::sage_class_name() const
51701 : {
51702 0 : ROSE_ASSERT(this != NULL);
51703 0 : return "SgTypeSignedChar";
51704 : }
51705 :
51706 : std::string
51707 201 : SgTypeSignedChar::class_name() const
51708 : {
51709 201 : ROSE_ASSERT(this != NULL);
51710 201 : return "SgTypeSignedChar";
51711 : }
51712 :
51713 : // DQ (11/26/2005): Support for visitor pattern mechanims
51714 : // (inferior to ROSE traversal mechanism, experimental).
51715 : void
51716 137 : SgTypeSignedChar::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
51717 : {
51718 137 : ROSE_ASSERT(this != NULL);
51719 137 : visitor.visit(this);
51720 137 : }
51721 :
51722 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
51723 0 : void SgTypeSignedChar::accept (ROSE_VisitorPattern & visitor) {
51724 0 : ROSE_ASSERT(this != NULL);
51725 0 : visitor.visit(this);
51726 0 : }
51727 :
51728 : SgTypeSignedChar*
51729 0 : SgTypeSignedChar::addRegExpAttribute(std::string s, AstRegExAttribute* a)
51730 : {
51731 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
51732 : // This function is currently only supported for the AST used the represent Binary executables.
51733 : if (0 /* isSgAsmNode(this) != NULL */)
51734 : {
51735 : // Support for regex specification.
51736 : std::string prefixCode = "REGEX:";
51737 : addNewAttribute(prefixCode + s,a);
51738 : }
51739 : #endif
51740 :
51741 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
51742 0 : return this;
51743 : }
51744 :
51745 : // *** COMMON CODE SECTION ENDS HERE ***
51746 :
51747 :
51748 : // End of memberFunctionString
51749 : // Start of memberFunctionString
51750 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
51751 :
51752 :
51753 : #if 0
51754 : //! Error checking support
51755 : /*! Verifies the following:
51756 : - working getVariant() member function
51757 : - calls base class's error() member function
51758 : Every class has one of these functions.
51759 : */
51760 : bool
51761 : SgTypeSignedChar::error()
51762 : {
51763 : // Put error checking here
51764 :
51765 : ROSE_ASSERT (this != NULL);
51766 : if (getVariant() != T_SIGNED_CHAR)
51767 : {
51768 : printf ("Error in SgTypeSignedChar::error(): SgTypeSignedChar object has a %s variant \n",
51769 : Cxx_GrammarTerminalNames[getVariant()].name);
51770 : // printf ("Error in SgTypeSignedChar::error() \n");
51771 : ROSE_ABORT();
51772 : }
51773 :
51774 : ROSE_ASSERT (getVariant() == T_SIGNED_CHAR);
51775 : return SgType::error();
51776 : }
51777 : #endif
51778 :
51779 :
51780 :
51781 : // End of memberFunctionString
51782 : // Start of memberFunctionString
51783 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
51784 :
51785 :
51786 : // DQ (1/31/2006): Modified to build all types in the memory pools
51787 : // SgTypeSignedChar SgTypeSignedChar::builtin_type;
51788 : // SgTypeSignedChar* SgTypeSignedChar::builtin_type = new SgTypeSignedChar();
51789 : SgTypeSignedChar* SgTypeSignedChar::p_builtin_type = NULL;
51790 :
51791 :
51792 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
51793 : // SgTypeSignedChar* SgTypeSignedChar::createType(void)
51794 : SgTypeSignedChar*
51795 198 : SgTypeSignedChar::createType(SgExpression* optional_fortran_type_kind)
51796 : {
51797 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
51798 : // is not called (likely because static initialization is compiler dependent).
51799 : // DQ (1/31/2006): Modified to build all types in the memory pools
51800 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
51801 : // return &builtin_type;
51802 :
51803 : #if 0
51804 : printf ("In SgTypeSignedChar::createType() (COMMON_CREATE_TYPE) \n");
51805 : #endif
51806 :
51807 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
51808 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
51809 :
51810 198 : SgTypeSignedChar* temp_type = new SgTypeSignedChar();
51811 :
51812 : #if 0
51813 : printf ("In SgTypeSignedChar::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
51814 : #endif
51815 :
51816 : // DQ (10/31/2016): Added assertion.
51817 198 : ROSE_ASSERT(temp_type != NULL);
51818 :
51819 198 : if (optional_fortran_type_kind != NULL)
51820 : {
51821 : // DQ (10/31/2016): Added assertion.
51822 0 : ROSE_ASSERT(temp_type != NULL);
51823 :
51824 0 : temp_type->set_type_kind(optional_fortran_type_kind);
51825 : }
51826 : #if 0
51827 : else
51828 : {
51829 : // Let p_builtin_type refer to the unadorned type (no type kind).
51830 : p_builtin_type = temp_type;
51831 : }
51832 : #endif
51833 :
51834 198 : SgName name = temp_type->get_mangled();
51835 :
51836 : #if 0
51837 : printf ("Mangled type name for SgTypeSignedChar = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
51838 : #endif
51839 :
51840 : // DQ (10/31/2016): Added assertion.
51841 198 : ROSE_ASSERT(get_globalTypeTable() != NULL);
51842 :
51843 198 : SgType* t = get_globalTypeTable()->lookup_type(name);
51844 :
51845 : #if 0
51846 : printf ("In SgTypeSignedChar::createType(): type from lookup_type = %p \n",t);
51847 : #endif
51848 :
51849 198 : if (t == NULL)
51850 : {
51851 198 : get_globalTypeTable()->insert_type(name,temp_type);
51852 : }
51853 : else
51854 : {
51855 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
51856 0 : if (t != temp_type)
51857 : {
51858 : #if 0
51859 : printf ("In SgTypeSignedChar::createType(): deleting temp_type = %p \n",temp_type);
51860 : #endif
51861 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
51862 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
51863 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
51864 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
51865 0 : delete temp_type;
51866 : #endif
51867 0 : temp_type = NULL;
51868 : #if 0
51869 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
51870 : if (optional_fortran_type_kind != NULL)
51871 : {
51872 : p_builtin_type = NULL;
51873 : }
51874 : #endif
51875 : }
51876 :
51877 : // Reuse this tempType variable so we can use the same code below.
51878 0 : temp_type = isSgTypeSignedChar(t);
51879 0 : ROSE_ASSERT(temp_type != NULL);
51880 : }
51881 :
51882 : #if 0
51883 : printf ("Leaving SgTypeSignedChar::createType(): temp_type = %p \n",temp_type);
51884 : #endif
51885 :
51886 198 : return temp_type;
51887 : }
51888 :
51889 :
51890 :
51891 : // End of memberFunctionString
51892 : // Start of memberFunctionString
51893 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
51894 :
51895 : #if 1
51896 : /*! Support for mangled names (for unparser)
51897 : There are two different cases of source code for the get_mangled member function
51898 : This one is used in all but the classes containing a base type
51899 : */
51900 : // SgName SgTypeSignedChar::get_mangled ( SgUnparse_Info & info )
51901 : SgName
51902 1501 : SgTypeSignedChar::get_mangled (void) const
51903 : {
51904 1501 : ROSE_ASSERT(this != NULL);
51905 :
51906 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
51907 : // CR (3/6/2020): Now type_kind is also used for Jovial.
51908 1501 : SgName name = "si";
51909 1501 : if (get_type_kind() != NULL)
51910 : {
51911 : // name += get_type_kind()->get_mangled();
51912 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
51913 0 : SgValueExp* value = isSgValueExp(get_type_kind());
51914 0 : if (value != NULL)
51915 : {
51916 : // name += string("_") + StringUtility::numberToString(value->get_value());
51917 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
51918 : }
51919 : else
51920 : {
51921 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
51922 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
51923 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
51924 : // a different prefix for each type of named type. It come down to is there can be multiple
51925 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
51926 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
51927 : // I think the issue is that si is not defined for any of the SgNameType IR nodes.
51928 : #if 0
51929 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"si");
51930 : #endif
51931 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
51932 : }
51933 : }
51934 :
51935 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
51936 : // REMOVE_ME please!
51937 1501 : if (isSgTypeFixed(this))
51938 : {
51939 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
51940 0 : if (fixed_type->get_scale() != NULL)
51941 : {
51942 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
51943 0 : if (value != NULL)
51944 : {
51945 0 : name += string("_") + value->get_constant_folded_value_as_string();
51946 : }
51947 : }
51948 0 : if (fixed_type->get_fraction() != NULL)
51949 : {
51950 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
51951 0 : if (value != NULL)
51952 : {
51953 0 : name += string("_") + value->get_constant_folded_value_as_string();
51954 : }
51955 : }
51956 : }
51957 :
51958 : #if 0
51959 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
51960 : #endif
51961 :
51962 1501 : return name;
51963 : }
51964 : #endif
51965 :
51966 :
51967 : // End of memberFunctionString
51968 :
51969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
51970 :
51971 198 : SgTypeSignedChar* isSgTypeSignedChar ( SgNode* inputDerivedClassPointer )
51972 : {
51973 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
51974 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
51975 : // So to fix this we return NULL directly when the input is NULL and avoid the
51976 : // dynamic_cast in this case. This is likely a performance improvement as well.
51977 : // return dynamic_cast<SgTypeSignedChar*>(inputDerivedClassPointer);
51978 : // Milind Chabbi (8/28/2013): isSgTypeSignedChar uses table-driven castability instead of c++ default dynamic_cast
51979 : // this improves the running time performance by 10-20%.
51980 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeSignedChar*>(inputDerivedClassPointer);
51981 198 : return IS_SgTypeSignedChar_FAST_MACRO(inputDerivedClassPointer);
51982 : }
51983 :
51984 : // DQ (11/8/2003): Added version of functions taking const pointer
51985 0 : const SgTypeSignedChar* isSgTypeSignedChar ( const SgNode* inputDerivedClassPointer )
51986 : {
51987 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
51988 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
51989 : // So to fix this we return NULL directly when the input is NULL and avoid the
51990 : // dynamic_cast in this case. This is likely a performance improvement as well.
51991 : // return dynamic_cast<const SgTypeSignedChar*>(inputDerivedClassPointer);
51992 : // Milind Chabbi (8/28/2013): isSgTypeSignedChar uses table-driven castability instead of c++ default dynamic_cast
51993 : // this improves the running time performance by 10-20%.
51994 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeSignedChar*>(inputDerivedClassPointer);
51995 0 : return IS_SgTypeSignedChar_FAST_MACRO(inputDerivedClassPointer);
51996 : }
51997 :
51998 :
51999 :
52000 : /* #line 52001 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52001 :
52002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
52003 :
52004 : /**
52005 : \brief Generated destructor
52006 :
52007 : This destructor is automatically generated (by ROSETTA). This destructor
52008 : only frees memory of data members associated with the parts of the current IR node which
52009 : are NOT traversed. Those data members that are part of a traversal can be freed using
52010 : a traversal (calling this destructor on all children in a post-order traversal). Such
52011 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
52012 :
52013 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
52014 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
52015 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
52016 :
52017 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
52018 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
52019 : pointers are not yet implemented to call delete on eash pointer in the container.
52020 : (This could be done by derivation from the STL containers to define containers that
52021 : automatically deleted their members.)
52022 :
52023 : */
52024 8 : SgTypeSignedChar::~SgTypeSignedChar () {
52025 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
52026 :
52027 :
52028 :
52029 : }
52030 :
52031 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
52032 8 : }
52033 :
52034 :
52035 : /* #line 52036 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52036 :
52037 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
52038 :
52039 : // Generated constructor
52040 198 : SgTypeSignedChar::SgTypeSignedChar ( )
52041 198 : : SgType()
52042 : {
52043 : #ifdef DEBUG
52044 : // printf ("In SgTypeSignedChar::SgTypeSignedChar () sage_class_name() = %s \n",sage_class_name());
52045 : #endif
52046 : #if 0
52047 : // debugging information!
52048 : printf ("In SgTypeSignedChar::SgTypeSignedChar (): this = %p = %s \n",this,this->class_name().c_str());
52049 : #endif
52050 :
52051 :
52052 :
52053 : #if 0
52054 : // DQ (7/30/2014): Call a virtual function.
52055 : std::string s = this->class_name();
52056 : #endif
52057 :
52058 : // Test the variant virtual function
52059 : // assert(T_SIGNED_CHAR == variant());
52060 198 : assert(T_SIGNED_CHAR == this->variant());
52061 198 : ROSE_ASSERT(T_SIGNED_CHAR == (int)(this->variantT()));
52062 198 : post_construction_initialization();
52063 :
52064 : // Test the isSgTypeSignedChar() function since it has been problematic
52065 198 : assert(isSgTypeSignedChar(this) != NULL);
52066 198 : }
52067 :
52068 : // Generated constructor (all data members)
52069 :
52070 : /* #line 52071 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52071 :
52072 :
52073 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
52074 :
52075 :
52076 : // ********************************************************
52077 : // member functions common across all array grammar objects
52078 : // ********************************************************
52079 :
52080 :
52081 :
52082 : /* #line 52083 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52083 :
52084 :
52085 :
52086 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
52087 :
52088 : // ********************************************************
52089 : // member functions specific to each node in the grammar
52090 : // ********************************************************
52091 :
52092 :
52093 : /* #line 52094 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52094 :
52095 : // Start of memberFunctionString
52096 :
52097 :
52098 : // End of memberFunctionString
52099 : // Start of memberFunctionString
52100 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
52101 :
52102 : // *** COMMON CODE SECTION BEGINS HERE ***
52103 :
52104 : #if 0
52105 : int
52106 : SgTypeUnsignedChar::getVariant() const
52107 : {
52108 : // This function is used in ROSE while "variant()" is used in SAGE
52109 : assert(this != NULL);
52110 : return variant();
52111 : }
52112 : #endif
52113 :
52114 : // This function is used in ROSE in treeTraversal code
52115 : // eventually replaces getVariant() and variant()
52116 : // though after variant() has been removed for a while we will
52117 : // want to change the name of variantT() back to variant()
52118 : // (since the "T" was ment to stand for temporary).
52119 : // When this happens the variantT() will be depricated.
52120 : VariantT
52121 628692000 : SgTypeUnsignedChar::variantT() const
52122 : {
52123 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
52124 628692000 : ROSE_ASSERT(this != NULL);
52125 628692000 : return V_SgTypeUnsignedChar;
52126 : }
52127 :
52128 : #if 0
52129 : int
52130 : SgTypeUnsignedChar::variant() const
52131 : {
52132 : // This function is used in SAGE
52133 : ROSE_ASSERT(this != NULL);
52134 : return T_UNSIGNED_CHAR;
52135 : }
52136 : #endif
52137 :
52138 : ROSE_DLL_API const char*
52139 0 : SgTypeUnsignedChar::sage_class_name() const
52140 : {
52141 0 : ROSE_ASSERT(this != NULL);
52142 0 : return "SgTypeUnsignedChar";
52143 : }
52144 :
52145 : std::string
52146 322 : SgTypeUnsignedChar::class_name() const
52147 : {
52148 322 : ROSE_ASSERT(this != NULL);
52149 322 : return "SgTypeUnsignedChar";
52150 : }
52151 :
52152 : // DQ (11/26/2005): Support for visitor pattern mechanims
52153 : // (inferior to ROSE traversal mechanism, experimental).
52154 : void
52155 194 : SgTypeUnsignedChar::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
52156 : {
52157 194 : ROSE_ASSERT(this != NULL);
52158 194 : visitor.visit(this);
52159 194 : }
52160 :
52161 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
52162 0 : void SgTypeUnsignedChar::accept (ROSE_VisitorPattern & visitor) {
52163 0 : ROSE_ASSERT(this != NULL);
52164 0 : visitor.visit(this);
52165 0 : }
52166 :
52167 : SgTypeUnsignedChar*
52168 0 : SgTypeUnsignedChar::addRegExpAttribute(std::string s, AstRegExAttribute* a)
52169 : {
52170 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
52171 : // This function is currently only supported for the AST used the represent Binary executables.
52172 : if (0 /* isSgAsmNode(this) != NULL */)
52173 : {
52174 : // Support for regex specification.
52175 : std::string prefixCode = "REGEX:";
52176 : addNewAttribute(prefixCode + s,a);
52177 : }
52178 : #endif
52179 :
52180 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
52181 0 : return this;
52182 : }
52183 :
52184 : // *** COMMON CODE SECTION ENDS HERE ***
52185 :
52186 :
52187 : // End of memberFunctionString
52188 : // Start of memberFunctionString
52189 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
52190 :
52191 :
52192 : #if 0
52193 : //! Error checking support
52194 : /*! Verifies the following:
52195 : - working getVariant() member function
52196 : - calls base class's error() member function
52197 : Every class has one of these functions.
52198 : */
52199 : bool
52200 : SgTypeUnsignedChar::error()
52201 : {
52202 : // Put error checking here
52203 :
52204 : ROSE_ASSERT (this != NULL);
52205 : if (getVariant() != T_UNSIGNED_CHAR)
52206 : {
52207 : printf ("Error in SgTypeUnsignedChar::error(): SgTypeUnsignedChar object has a %s variant \n",
52208 : Cxx_GrammarTerminalNames[getVariant()].name);
52209 : // printf ("Error in SgTypeUnsignedChar::error() \n");
52210 : ROSE_ABORT();
52211 : }
52212 :
52213 : ROSE_ASSERT (getVariant() == T_UNSIGNED_CHAR);
52214 : return SgType::error();
52215 : }
52216 : #endif
52217 :
52218 :
52219 :
52220 : // End of memberFunctionString
52221 : // Start of memberFunctionString
52222 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
52223 :
52224 :
52225 : // DQ (1/31/2006): Modified to build all types in the memory pools
52226 : // SgTypeUnsignedChar SgTypeUnsignedChar::builtin_type;
52227 : // SgTypeUnsignedChar* SgTypeUnsignedChar::builtin_type = new SgTypeUnsignedChar();
52228 : SgTypeUnsignedChar* SgTypeUnsignedChar::p_builtin_type = NULL;
52229 :
52230 :
52231 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
52232 : // SgTypeUnsignedChar* SgTypeUnsignedChar::createType(void)
52233 : SgTypeUnsignedChar*
52234 322 : SgTypeUnsignedChar::createType(SgExpression* optional_fortran_type_kind)
52235 : {
52236 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
52237 : // is not called (likely because static initialization is compiler dependent).
52238 : // DQ (1/31/2006): Modified to build all types in the memory pools
52239 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
52240 : // return &builtin_type;
52241 :
52242 : #if 0
52243 : printf ("In SgTypeUnsignedChar::createType() (COMMON_CREATE_TYPE) \n");
52244 : #endif
52245 :
52246 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
52247 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
52248 :
52249 322 : SgTypeUnsignedChar* temp_type = new SgTypeUnsignedChar();
52250 :
52251 : #if 0
52252 : printf ("In SgTypeUnsignedChar::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
52253 : #endif
52254 :
52255 : // DQ (10/31/2016): Added assertion.
52256 322 : ROSE_ASSERT(temp_type != NULL);
52257 :
52258 322 : if (optional_fortran_type_kind != NULL)
52259 : {
52260 : // DQ (10/31/2016): Added assertion.
52261 0 : ROSE_ASSERT(temp_type != NULL);
52262 :
52263 0 : temp_type->set_type_kind(optional_fortran_type_kind);
52264 : }
52265 : #if 0
52266 : else
52267 : {
52268 : // Let p_builtin_type refer to the unadorned type (no type kind).
52269 : p_builtin_type = temp_type;
52270 : }
52271 : #endif
52272 :
52273 322 : SgName name = temp_type->get_mangled();
52274 :
52275 : #if 0
52276 : printf ("Mangled type name for SgTypeUnsignedChar = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
52277 : #endif
52278 :
52279 : // DQ (10/31/2016): Added assertion.
52280 322 : ROSE_ASSERT(get_globalTypeTable() != NULL);
52281 :
52282 322 : SgType* t = get_globalTypeTable()->lookup_type(name);
52283 :
52284 : #if 0
52285 : printf ("In SgTypeUnsignedChar::createType(): type from lookup_type = %p \n",t);
52286 : #endif
52287 :
52288 322 : if (t == NULL)
52289 : {
52290 315 : get_globalTypeTable()->insert_type(name,temp_type);
52291 : }
52292 : else
52293 : {
52294 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
52295 7 : if (t != temp_type)
52296 : {
52297 : #if 0
52298 : printf ("In SgTypeUnsignedChar::createType(): deleting temp_type = %p \n",temp_type);
52299 : #endif
52300 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
52301 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
52302 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
52303 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
52304 7 : delete temp_type;
52305 : #endif
52306 7 : temp_type = NULL;
52307 : #if 0
52308 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
52309 : if (optional_fortran_type_kind != NULL)
52310 : {
52311 : p_builtin_type = NULL;
52312 : }
52313 : #endif
52314 : }
52315 :
52316 : // Reuse this tempType variable so we can use the same code below.
52317 7 : temp_type = isSgTypeUnsignedChar(t);
52318 7 : ROSE_ASSERT(temp_type != NULL);
52319 : }
52320 :
52321 : #if 0
52322 : printf ("Leaving SgTypeUnsignedChar::createType(): temp_type = %p \n",temp_type);
52323 : #endif
52324 :
52325 322 : return temp_type;
52326 : }
52327 :
52328 :
52329 :
52330 : // End of memberFunctionString
52331 : // Start of memberFunctionString
52332 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
52333 :
52334 : #if 1
52335 : /*! Support for mangled names (for unparser)
52336 : There are two different cases of source code for the get_mangled member function
52337 : This one is used in all but the classes containing a base type
52338 : */
52339 : // SgName SgTypeUnsignedChar::get_mangled ( SgUnparse_Info & info )
52340 : SgName
52341 34478 : SgTypeUnsignedChar::get_mangled (void) const
52342 : {
52343 34478 : ROSE_ASSERT(this != NULL);
52344 :
52345 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
52346 : // CR (3/6/2020): Now type_kind is also used for Jovial.
52347 34478 : SgName name = "Uc";
52348 34478 : if (get_type_kind() != NULL)
52349 : {
52350 : // name += get_type_kind()->get_mangled();
52351 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
52352 0 : SgValueExp* value = isSgValueExp(get_type_kind());
52353 0 : if (value != NULL)
52354 : {
52355 : // name += string("_") + StringUtility::numberToString(value->get_value());
52356 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
52357 : }
52358 : else
52359 : {
52360 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
52361 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
52362 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
52363 : // a different prefix for each type of named type. It come down to is there can be multiple
52364 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
52365 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
52366 : // I think the issue is that Uc is not defined for any of the SgNameType IR nodes.
52367 : #if 0
52368 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Uc");
52369 : #endif
52370 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
52371 : }
52372 : }
52373 :
52374 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
52375 : // REMOVE_ME please!
52376 34478 : if (isSgTypeFixed(this))
52377 : {
52378 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
52379 0 : if (fixed_type->get_scale() != NULL)
52380 : {
52381 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
52382 0 : if (value != NULL)
52383 : {
52384 0 : name += string("_") + value->get_constant_folded_value_as_string();
52385 : }
52386 : }
52387 0 : if (fixed_type->get_fraction() != NULL)
52388 : {
52389 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
52390 0 : if (value != NULL)
52391 : {
52392 0 : name += string("_") + value->get_constant_folded_value_as_string();
52393 : }
52394 : }
52395 : }
52396 :
52397 : #if 0
52398 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
52399 : #endif
52400 :
52401 34478 : return name;
52402 : }
52403 : #endif
52404 :
52405 :
52406 : // End of memberFunctionString
52407 :
52408 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
52409 :
52410 329 : SgTypeUnsignedChar* isSgTypeUnsignedChar ( SgNode* inputDerivedClassPointer )
52411 : {
52412 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
52413 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
52414 : // So to fix this we return NULL directly when the input is NULL and avoid the
52415 : // dynamic_cast in this case. This is likely a performance improvement as well.
52416 : // return dynamic_cast<SgTypeUnsignedChar*>(inputDerivedClassPointer);
52417 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedChar uses table-driven castability instead of c++ default dynamic_cast
52418 : // this improves the running time performance by 10-20%.
52419 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnsignedChar*>(inputDerivedClassPointer);
52420 329 : return IS_SgTypeUnsignedChar_FAST_MACRO(inputDerivedClassPointer);
52421 : }
52422 :
52423 : // DQ (11/8/2003): Added version of functions taking const pointer
52424 0 : const SgTypeUnsignedChar* isSgTypeUnsignedChar ( const SgNode* inputDerivedClassPointer )
52425 : {
52426 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
52427 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
52428 : // So to fix this we return NULL directly when the input is NULL and avoid the
52429 : // dynamic_cast in this case. This is likely a performance improvement as well.
52430 : // return dynamic_cast<const SgTypeUnsignedChar*>(inputDerivedClassPointer);
52431 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedChar uses table-driven castability instead of c++ default dynamic_cast
52432 : // this improves the running time performance by 10-20%.
52433 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnsignedChar*>(inputDerivedClassPointer);
52434 0 : return IS_SgTypeUnsignedChar_FAST_MACRO(inputDerivedClassPointer);
52435 : }
52436 :
52437 :
52438 :
52439 : /* #line 52440 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52440 :
52441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
52442 :
52443 : /**
52444 : \brief Generated destructor
52445 :
52446 : This destructor is automatically generated (by ROSETTA). This destructor
52447 : only frees memory of data members associated with the parts of the current IR node which
52448 : are NOT traversed. Those data members that are part of a traversal can be freed using
52449 : a traversal (calling this destructor on all children in a post-order traversal). Such
52450 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
52451 :
52452 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
52453 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
52454 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
52455 :
52456 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
52457 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
52458 : pointers are not yet implemented to call delete on eash pointer in the container.
52459 : (This could be done by derivation from the STL containers to define containers that
52460 : automatically deleted their members.)
52461 :
52462 : */
52463 22 : SgTypeUnsignedChar::~SgTypeUnsignedChar () {
52464 11 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
52465 :
52466 :
52467 :
52468 : }
52469 :
52470 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
52471 22 : }
52472 :
52473 :
52474 : /* #line 52475 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52475 :
52476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
52477 :
52478 : // Generated constructor
52479 322 : SgTypeUnsignedChar::SgTypeUnsignedChar ( )
52480 322 : : SgType()
52481 : {
52482 : #ifdef DEBUG
52483 : // printf ("In SgTypeUnsignedChar::SgTypeUnsignedChar () sage_class_name() = %s \n",sage_class_name());
52484 : #endif
52485 : #if 0
52486 : // debugging information!
52487 : printf ("In SgTypeUnsignedChar::SgTypeUnsignedChar (): this = %p = %s \n",this,this->class_name().c_str());
52488 : #endif
52489 :
52490 :
52491 :
52492 : #if 0
52493 : // DQ (7/30/2014): Call a virtual function.
52494 : std::string s = this->class_name();
52495 : #endif
52496 :
52497 : // Test the variant virtual function
52498 : // assert(T_UNSIGNED_CHAR == variant());
52499 322 : assert(T_UNSIGNED_CHAR == this->variant());
52500 322 : ROSE_ASSERT(T_UNSIGNED_CHAR == (int)(this->variantT()));
52501 322 : post_construction_initialization();
52502 :
52503 : // Test the isSgTypeUnsignedChar() function since it has been problematic
52504 322 : assert(isSgTypeUnsignedChar(this) != NULL);
52505 322 : }
52506 :
52507 : // Generated constructor (all data members)
52508 :
52509 : /* #line 52510 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52510 :
52511 :
52512 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
52513 :
52514 :
52515 : // ********************************************************
52516 : // member functions common across all array grammar objects
52517 : // ********************************************************
52518 :
52519 :
52520 :
52521 : /* #line 52522 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52522 :
52523 :
52524 :
52525 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
52526 :
52527 : // ********************************************************
52528 : // member functions specific to each node in the grammar
52529 : // ********************************************************
52530 :
52531 :
52532 : /* #line 52533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52533 :
52534 : // Start of memberFunctionString
52535 :
52536 :
52537 : // End of memberFunctionString
52538 : // Start of memberFunctionString
52539 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
52540 :
52541 : // *** COMMON CODE SECTION BEGINS HERE ***
52542 :
52543 : #if 0
52544 : int
52545 : SgTypeShort::getVariant() const
52546 : {
52547 : // This function is used in ROSE while "variant()" is used in SAGE
52548 : assert(this != NULL);
52549 : return variant();
52550 : }
52551 : #endif
52552 :
52553 : // This function is used in ROSE in treeTraversal code
52554 : // eventually replaces getVariant() and variant()
52555 : // though after variant() has been removed for a while we will
52556 : // want to change the name of variantT() back to variant()
52557 : // (since the "T" was ment to stand for temporary).
52558 : // When this happens the variantT() will be depricated.
52559 : VariantT
52560 8291920 : SgTypeShort::variantT() const
52561 : {
52562 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
52563 8291920 : ROSE_ASSERT(this != NULL);
52564 8291920 : return V_SgTypeShort;
52565 : }
52566 :
52567 : #if 0
52568 : int
52569 : SgTypeShort::variant() const
52570 : {
52571 : // This function is used in SAGE
52572 : ROSE_ASSERT(this != NULL);
52573 : return T_SHORT;
52574 : }
52575 : #endif
52576 :
52577 : ROSE_DLL_API const char*
52578 0 : SgTypeShort::sage_class_name() const
52579 : {
52580 0 : ROSE_ASSERT(this != NULL);
52581 0 : return "SgTypeShort";
52582 : }
52583 :
52584 : std::string
52585 320 : SgTypeShort::class_name() const
52586 : {
52587 320 : ROSE_ASSERT(this != NULL);
52588 320 : return "SgTypeShort";
52589 : }
52590 :
52591 : // DQ (11/26/2005): Support for visitor pattern mechanims
52592 : // (inferior to ROSE traversal mechanism, experimental).
52593 : void
52594 194 : SgTypeShort::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
52595 : {
52596 194 : ROSE_ASSERT(this != NULL);
52597 194 : visitor.visit(this);
52598 194 : }
52599 :
52600 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
52601 0 : void SgTypeShort::accept (ROSE_VisitorPattern & visitor) {
52602 0 : ROSE_ASSERT(this != NULL);
52603 0 : visitor.visit(this);
52604 0 : }
52605 :
52606 : SgTypeShort*
52607 0 : SgTypeShort::addRegExpAttribute(std::string s, AstRegExAttribute* a)
52608 : {
52609 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
52610 : // This function is currently only supported for the AST used the represent Binary executables.
52611 : if (0 /* isSgAsmNode(this) != NULL */)
52612 : {
52613 : // Support for regex specification.
52614 : std::string prefixCode = "REGEX:";
52615 : addNewAttribute(prefixCode + s,a);
52616 : }
52617 : #endif
52618 :
52619 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
52620 0 : return this;
52621 : }
52622 :
52623 : // *** COMMON CODE SECTION ENDS HERE ***
52624 :
52625 :
52626 : // End of memberFunctionString
52627 : // Start of memberFunctionString
52628 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
52629 :
52630 :
52631 : #if 0
52632 : //! Error checking support
52633 : /*! Verifies the following:
52634 : - working getVariant() member function
52635 : - calls base class's error() member function
52636 : Every class has one of these functions.
52637 : */
52638 : bool
52639 : SgTypeShort::error()
52640 : {
52641 : // Put error checking here
52642 :
52643 : ROSE_ASSERT (this != NULL);
52644 : if (getVariant() != T_SHORT)
52645 : {
52646 : printf ("Error in SgTypeShort::error(): SgTypeShort object has a %s variant \n",
52647 : Cxx_GrammarTerminalNames[getVariant()].name);
52648 : // printf ("Error in SgTypeShort::error() \n");
52649 : ROSE_ABORT();
52650 : }
52651 :
52652 : ROSE_ASSERT (getVariant() == T_SHORT);
52653 : return SgType::error();
52654 : }
52655 : #endif
52656 :
52657 :
52658 :
52659 : // End of memberFunctionString
52660 : // Start of memberFunctionString
52661 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
52662 :
52663 :
52664 : // DQ (1/31/2006): Modified to build all types in the memory pools
52665 : // SgTypeShort SgTypeShort::builtin_type;
52666 : // SgTypeShort* SgTypeShort::builtin_type = new SgTypeShort();
52667 : SgTypeShort* SgTypeShort::p_builtin_type = NULL;
52668 :
52669 :
52670 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
52671 : // SgTypeShort* SgTypeShort::createType(void)
52672 : SgTypeShort*
52673 322 : SgTypeShort::createType(SgExpression* optional_fortran_type_kind)
52674 : {
52675 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
52676 : // is not called (likely because static initialization is compiler dependent).
52677 : // DQ (1/31/2006): Modified to build all types in the memory pools
52678 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
52679 : // return &builtin_type;
52680 :
52681 : #if 0
52682 : printf ("In SgTypeShort::createType() (COMMON_CREATE_TYPE) \n");
52683 : #endif
52684 :
52685 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
52686 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
52687 :
52688 322 : SgTypeShort* temp_type = new SgTypeShort();
52689 :
52690 : #if 0
52691 : printf ("In SgTypeShort::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
52692 : #endif
52693 :
52694 : // DQ (10/31/2016): Added assertion.
52695 322 : ROSE_ASSERT(temp_type != NULL);
52696 :
52697 322 : if (optional_fortran_type_kind != NULL)
52698 : {
52699 : // DQ (10/31/2016): Added assertion.
52700 0 : ROSE_ASSERT(temp_type != NULL);
52701 :
52702 0 : temp_type->set_type_kind(optional_fortran_type_kind);
52703 : }
52704 : #if 0
52705 : else
52706 : {
52707 : // Let p_builtin_type refer to the unadorned type (no type kind).
52708 : p_builtin_type = temp_type;
52709 : }
52710 : #endif
52711 :
52712 322 : SgName name = temp_type->get_mangled();
52713 :
52714 : #if 0
52715 : printf ("Mangled type name for SgTypeShort = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
52716 : #endif
52717 :
52718 : // DQ (10/31/2016): Added assertion.
52719 322 : ROSE_ASSERT(get_globalTypeTable() != NULL);
52720 :
52721 322 : SgType* t = get_globalTypeTable()->lookup_type(name);
52722 :
52723 : #if 0
52724 : printf ("In SgTypeShort::createType(): type from lookup_type = %p \n",t);
52725 : #endif
52726 :
52727 322 : if (t == NULL)
52728 : {
52729 315 : get_globalTypeTable()->insert_type(name,temp_type);
52730 : }
52731 : else
52732 : {
52733 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
52734 7 : if (t != temp_type)
52735 : {
52736 : #if 0
52737 : printf ("In SgTypeShort::createType(): deleting temp_type = %p \n",temp_type);
52738 : #endif
52739 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
52740 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
52741 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
52742 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
52743 7 : delete temp_type;
52744 : #endif
52745 7 : temp_type = NULL;
52746 : #if 0
52747 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
52748 : if (optional_fortran_type_kind != NULL)
52749 : {
52750 : p_builtin_type = NULL;
52751 : }
52752 : #endif
52753 : }
52754 :
52755 : // Reuse this tempType variable so we can use the same code below.
52756 7 : temp_type = isSgTypeShort(t);
52757 7 : ROSE_ASSERT(temp_type != NULL);
52758 : }
52759 :
52760 : #if 0
52761 : printf ("Leaving SgTypeShort::createType(): temp_type = %p \n",temp_type);
52762 : #endif
52763 :
52764 322 : return temp_type;
52765 : }
52766 :
52767 :
52768 :
52769 : // End of memberFunctionString
52770 : // Start of memberFunctionString
52771 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
52772 :
52773 : #if 1
52774 : /*! Support for mangled names (for unparser)
52775 : There are two different cases of source code for the get_mangled member function
52776 : This one is used in all but the classes containing a base type
52777 : */
52778 : // SgName SgTypeShort::get_mangled ( SgUnparse_Info & info )
52779 : SgName
52780 33412 : SgTypeShort::get_mangled (void) const
52781 : {
52782 33412 : ROSE_ASSERT(this != NULL);
52783 :
52784 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
52785 : // CR (3/6/2020): Now type_kind is also used for Jovial.
52786 33412 : SgName name = "s";
52787 33412 : if (get_type_kind() != NULL)
52788 : {
52789 : // name += get_type_kind()->get_mangled();
52790 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
52791 0 : SgValueExp* value = isSgValueExp(get_type_kind());
52792 0 : if (value != NULL)
52793 : {
52794 : // name += string("_") + StringUtility::numberToString(value->get_value());
52795 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
52796 : }
52797 : else
52798 : {
52799 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
52800 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
52801 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
52802 : // a different prefix for each type of named type. It come down to is there can be multiple
52803 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
52804 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
52805 : // I think the issue is that s is not defined for any of the SgNameType IR nodes.
52806 : #if 0
52807 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"s");
52808 : #endif
52809 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
52810 : }
52811 : }
52812 :
52813 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
52814 : // REMOVE_ME please!
52815 33412 : if (isSgTypeFixed(this))
52816 : {
52817 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
52818 0 : if (fixed_type->get_scale() != NULL)
52819 : {
52820 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
52821 0 : if (value != NULL)
52822 : {
52823 0 : name += string("_") + value->get_constant_folded_value_as_string();
52824 : }
52825 : }
52826 0 : if (fixed_type->get_fraction() != NULL)
52827 : {
52828 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
52829 0 : if (value != NULL)
52830 : {
52831 0 : name += string("_") + value->get_constant_folded_value_as_string();
52832 : }
52833 : }
52834 : }
52835 :
52836 : #if 0
52837 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
52838 : #endif
52839 :
52840 33412 : return name;
52841 : }
52842 : #endif
52843 :
52844 :
52845 : // End of memberFunctionString
52846 :
52847 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
52848 :
52849 329 : SgTypeShort* isSgTypeShort ( SgNode* inputDerivedClassPointer )
52850 : {
52851 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
52852 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
52853 : // So to fix this we return NULL directly when the input is NULL and avoid the
52854 : // dynamic_cast in this case. This is likely a performance improvement as well.
52855 : // return dynamic_cast<SgTypeShort*>(inputDerivedClassPointer);
52856 : // Milind Chabbi (8/28/2013): isSgTypeShort uses table-driven castability instead of c++ default dynamic_cast
52857 : // this improves the running time performance by 10-20%.
52858 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeShort*>(inputDerivedClassPointer);
52859 329 : return IS_SgTypeShort_FAST_MACRO(inputDerivedClassPointer);
52860 : }
52861 :
52862 : // DQ (11/8/2003): Added version of functions taking const pointer
52863 0 : const SgTypeShort* isSgTypeShort ( const SgNode* inputDerivedClassPointer )
52864 : {
52865 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
52866 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
52867 : // So to fix this we return NULL directly when the input is NULL and avoid the
52868 : // dynamic_cast in this case. This is likely a performance improvement as well.
52869 : // return dynamic_cast<const SgTypeShort*>(inputDerivedClassPointer);
52870 : // Milind Chabbi (8/28/2013): isSgTypeShort uses table-driven castability instead of c++ default dynamic_cast
52871 : // this improves the running time performance by 10-20%.
52872 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeShort*>(inputDerivedClassPointer);
52873 0 : return IS_SgTypeShort_FAST_MACRO(inputDerivedClassPointer);
52874 : }
52875 :
52876 :
52877 :
52878 : /* #line 52879 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52879 :
52880 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
52881 :
52882 : /**
52883 : \brief Generated destructor
52884 :
52885 : This destructor is automatically generated (by ROSETTA). This destructor
52886 : only frees memory of data members associated with the parts of the current IR node which
52887 : are NOT traversed. Those data members that are part of a traversal can be freed using
52888 : a traversal (calling this destructor on all children in a post-order traversal). Such
52889 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
52890 :
52891 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
52892 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
52893 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
52894 :
52895 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
52896 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
52897 : pointers are not yet implemented to call delete on eash pointer in the container.
52898 : (This could be done by derivation from the STL containers to define containers that
52899 : automatically deleted their members.)
52900 :
52901 : */
52902 22 : SgTypeShort::~SgTypeShort () {
52903 11 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
52904 :
52905 :
52906 :
52907 : }
52908 :
52909 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
52910 22 : }
52911 :
52912 :
52913 : /* #line 52914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52914 :
52915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
52916 :
52917 : // Generated constructor
52918 322 : SgTypeShort::SgTypeShort ( )
52919 322 : : SgType()
52920 : {
52921 : #ifdef DEBUG
52922 : // printf ("In SgTypeShort::SgTypeShort () sage_class_name() = %s \n",sage_class_name());
52923 : #endif
52924 : #if 0
52925 : // debugging information!
52926 : printf ("In SgTypeShort::SgTypeShort (): this = %p = %s \n",this,this->class_name().c_str());
52927 : #endif
52928 :
52929 :
52930 :
52931 : #if 0
52932 : // DQ (7/30/2014): Call a virtual function.
52933 : std::string s = this->class_name();
52934 : #endif
52935 :
52936 : // Test the variant virtual function
52937 : // assert(T_SHORT == variant());
52938 322 : assert(T_SHORT == this->variant());
52939 322 : ROSE_ASSERT(T_SHORT == (int)(this->variantT()));
52940 322 : post_construction_initialization();
52941 :
52942 : // Test the isSgTypeShort() function since it has been problematic
52943 322 : assert(isSgTypeShort(this) != NULL);
52944 322 : }
52945 :
52946 : // Generated constructor (all data members)
52947 :
52948 : /* #line 52949 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52949 :
52950 :
52951 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
52952 :
52953 :
52954 : // ********************************************************
52955 : // member functions common across all array grammar objects
52956 : // ********************************************************
52957 :
52958 :
52959 :
52960 : /* #line 52961 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52961 :
52962 :
52963 :
52964 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
52965 :
52966 : // ********************************************************
52967 : // member functions specific to each node in the grammar
52968 : // ********************************************************
52969 :
52970 :
52971 : /* #line 52972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
52972 :
52973 : // Start of memberFunctionString
52974 :
52975 :
52976 : // End of memberFunctionString
52977 : // Start of memberFunctionString
52978 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
52979 :
52980 : // *** COMMON CODE SECTION BEGINS HERE ***
52981 :
52982 : #if 0
52983 : int
52984 : SgTypeSignedShort::getVariant() const
52985 : {
52986 : // This function is used in ROSE while "variant()" is used in SAGE
52987 : assert(this != NULL);
52988 : return variant();
52989 : }
52990 : #endif
52991 :
52992 : // This function is used in ROSE in treeTraversal code
52993 : // eventually replaces getVariant() and variant()
52994 : // though after variant() has been removed for a while we will
52995 : // want to change the name of variantT() back to variant()
52996 : // (since the "T" was ment to stand for temporary).
52997 : // When this happens the variantT() will be depricated.
52998 : VariantT
52999 132685 : SgTypeSignedShort::variantT() const
53000 : {
53001 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
53002 132685 : ROSE_ASSERT(this != NULL);
53003 132685 : return V_SgTypeSignedShort;
53004 : }
53005 :
53006 : #if 0
53007 : int
53008 : SgTypeSignedShort::variant() const
53009 : {
53010 : // This function is used in SAGE
53011 : ROSE_ASSERT(this != NULL);
53012 : return T_SIGNED_SHORT;
53013 : }
53014 : #endif
53015 :
53016 : ROSE_DLL_API const char*
53017 0 : SgTypeSignedShort::sage_class_name() const
53018 : {
53019 0 : ROSE_ASSERT(this != NULL);
53020 0 : return "SgTypeSignedShort";
53021 : }
53022 :
53023 : std::string
53024 194 : SgTypeSignedShort::class_name() const
53025 : {
53026 194 : ROSE_ASSERT(this != NULL);
53027 194 : return "SgTypeSignedShort";
53028 : }
53029 :
53030 : // DQ (11/26/2005): Support for visitor pattern mechanims
53031 : // (inferior to ROSE traversal mechanism, experimental).
53032 : void
53033 137 : SgTypeSignedShort::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
53034 : {
53035 137 : ROSE_ASSERT(this != NULL);
53036 137 : visitor.visit(this);
53037 137 : }
53038 :
53039 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
53040 0 : void SgTypeSignedShort::accept (ROSE_VisitorPattern & visitor) {
53041 0 : ROSE_ASSERT(this != NULL);
53042 0 : visitor.visit(this);
53043 0 : }
53044 :
53045 : SgTypeSignedShort*
53046 0 : SgTypeSignedShort::addRegExpAttribute(std::string s, AstRegExAttribute* a)
53047 : {
53048 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
53049 : // This function is currently only supported for the AST used the represent Binary executables.
53050 : if (0 /* isSgAsmNode(this) != NULL */)
53051 : {
53052 : // Support for regex specification.
53053 : std::string prefixCode = "REGEX:";
53054 : addNewAttribute(prefixCode + s,a);
53055 : }
53056 : #endif
53057 :
53058 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
53059 0 : return this;
53060 : }
53061 :
53062 : // *** COMMON CODE SECTION ENDS HERE ***
53063 :
53064 :
53065 : // End of memberFunctionString
53066 : // Start of memberFunctionString
53067 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
53068 :
53069 :
53070 : #if 0
53071 : //! Error checking support
53072 : /*! Verifies the following:
53073 : - working getVariant() member function
53074 : - calls base class's error() member function
53075 : Every class has one of these functions.
53076 : */
53077 : bool
53078 : SgTypeSignedShort::error()
53079 : {
53080 : // Put error checking here
53081 :
53082 : ROSE_ASSERT (this != NULL);
53083 : if (getVariant() != T_SIGNED_SHORT)
53084 : {
53085 : printf ("Error in SgTypeSignedShort::error(): SgTypeSignedShort object has a %s variant \n",
53086 : Cxx_GrammarTerminalNames[getVariant()].name);
53087 : // printf ("Error in SgTypeSignedShort::error() \n");
53088 : ROSE_ABORT();
53089 : }
53090 :
53091 : ROSE_ASSERT (getVariant() == T_SIGNED_SHORT);
53092 : return SgType::error();
53093 : }
53094 : #endif
53095 :
53096 :
53097 :
53098 : // End of memberFunctionString
53099 : // Start of memberFunctionString
53100 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
53101 :
53102 :
53103 : // DQ (1/31/2006): Modified to build all types in the memory pools
53104 : // SgTypeSignedShort SgTypeSignedShort::builtin_type;
53105 : // SgTypeSignedShort* SgTypeSignedShort::builtin_type = new SgTypeSignedShort();
53106 : SgTypeSignedShort* SgTypeSignedShort::p_builtin_type = NULL;
53107 :
53108 :
53109 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
53110 : // SgTypeSignedShort* SgTypeSignedShort::createType(void)
53111 : SgTypeSignedShort*
53112 198 : SgTypeSignedShort::createType(SgExpression* optional_fortran_type_kind)
53113 : {
53114 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
53115 : // is not called (likely because static initialization is compiler dependent).
53116 : // DQ (1/31/2006): Modified to build all types in the memory pools
53117 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
53118 : // return &builtin_type;
53119 :
53120 : #if 0
53121 : printf ("In SgTypeSignedShort::createType() (COMMON_CREATE_TYPE) \n");
53122 : #endif
53123 :
53124 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
53125 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
53126 :
53127 198 : SgTypeSignedShort* temp_type = new SgTypeSignedShort();
53128 :
53129 : #if 0
53130 : printf ("In SgTypeSignedShort::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
53131 : #endif
53132 :
53133 : // DQ (10/31/2016): Added assertion.
53134 198 : ROSE_ASSERT(temp_type != NULL);
53135 :
53136 198 : if (optional_fortran_type_kind != NULL)
53137 : {
53138 : // DQ (10/31/2016): Added assertion.
53139 0 : ROSE_ASSERT(temp_type != NULL);
53140 :
53141 0 : temp_type->set_type_kind(optional_fortran_type_kind);
53142 : }
53143 : #if 0
53144 : else
53145 : {
53146 : // Let p_builtin_type refer to the unadorned type (no type kind).
53147 : p_builtin_type = temp_type;
53148 : }
53149 : #endif
53150 :
53151 198 : SgName name = temp_type->get_mangled();
53152 :
53153 : #if 0
53154 : printf ("Mangled type name for SgTypeSignedShort = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
53155 : #endif
53156 :
53157 : // DQ (10/31/2016): Added assertion.
53158 198 : ROSE_ASSERT(get_globalTypeTable() != NULL);
53159 :
53160 198 : SgType* t = get_globalTypeTable()->lookup_type(name);
53161 :
53162 : #if 0
53163 : printf ("In SgTypeSignedShort::createType(): type from lookup_type = %p \n",t);
53164 : #endif
53165 :
53166 198 : if (t == NULL)
53167 : {
53168 198 : get_globalTypeTable()->insert_type(name,temp_type);
53169 : }
53170 : else
53171 : {
53172 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
53173 0 : if (t != temp_type)
53174 : {
53175 : #if 0
53176 : printf ("In SgTypeSignedShort::createType(): deleting temp_type = %p \n",temp_type);
53177 : #endif
53178 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
53179 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
53180 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
53181 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
53182 0 : delete temp_type;
53183 : #endif
53184 0 : temp_type = NULL;
53185 : #if 0
53186 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
53187 : if (optional_fortran_type_kind != NULL)
53188 : {
53189 : p_builtin_type = NULL;
53190 : }
53191 : #endif
53192 : }
53193 :
53194 : // Reuse this tempType variable so we can use the same code below.
53195 0 : temp_type = isSgTypeSignedShort(t);
53196 0 : ROSE_ASSERT(temp_type != NULL);
53197 : }
53198 :
53199 : #if 0
53200 : printf ("Leaving SgTypeSignedShort::createType(): temp_type = %p \n",temp_type);
53201 : #endif
53202 :
53203 198 : return temp_type;
53204 : }
53205 :
53206 :
53207 :
53208 : // End of memberFunctionString
53209 : // Start of memberFunctionString
53210 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
53211 :
53212 : #if 1
53213 : /*! Support for mangled names (for unparser)
53214 : There are two different cases of source code for the get_mangled member function
53215 : This one is used in all but the classes containing a base type
53216 : */
53217 : // SgName SgTypeSignedShort::get_mangled ( SgUnparse_Info & info )
53218 : SgName
53219 200 : SgTypeSignedShort::get_mangled (void) const
53220 : {
53221 200 : ROSE_ASSERT(this != NULL);
53222 :
53223 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
53224 : // CR (3/6/2020): Now type_kind is also used for Jovial.
53225 200 : SgName name = "Ss";
53226 200 : if (get_type_kind() != NULL)
53227 : {
53228 : // name += get_type_kind()->get_mangled();
53229 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
53230 0 : SgValueExp* value = isSgValueExp(get_type_kind());
53231 0 : if (value != NULL)
53232 : {
53233 : // name += string("_") + StringUtility::numberToString(value->get_value());
53234 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
53235 : }
53236 : else
53237 : {
53238 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
53239 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
53240 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
53241 : // a different prefix for each type of named type. It come down to is there can be multiple
53242 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
53243 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
53244 : // I think the issue is that Ss is not defined for any of the SgNameType IR nodes.
53245 : #if 0
53246 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Ss");
53247 : #endif
53248 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
53249 : }
53250 : }
53251 :
53252 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
53253 : // REMOVE_ME please!
53254 200 : if (isSgTypeFixed(this))
53255 : {
53256 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
53257 0 : if (fixed_type->get_scale() != NULL)
53258 : {
53259 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
53260 0 : if (value != NULL)
53261 : {
53262 0 : name += string("_") + value->get_constant_folded_value_as_string();
53263 : }
53264 : }
53265 0 : if (fixed_type->get_fraction() != NULL)
53266 : {
53267 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
53268 0 : if (value != NULL)
53269 : {
53270 0 : name += string("_") + value->get_constant_folded_value_as_string();
53271 : }
53272 : }
53273 : }
53274 :
53275 : #if 0
53276 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
53277 : #endif
53278 :
53279 200 : return name;
53280 : }
53281 : #endif
53282 :
53283 :
53284 : // End of memberFunctionString
53285 :
53286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
53287 :
53288 198 : SgTypeSignedShort* isSgTypeSignedShort ( SgNode* inputDerivedClassPointer )
53289 : {
53290 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
53291 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
53292 : // So to fix this we return NULL directly when the input is NULL and avoid the
53293 : // dynamic_cast in this case. This is likely a performance improvement as well.
53294 : // return dynamic_cast<SgTypeSignedShort*>(inputDerivedClassPointer);
53295 : // Milind Chabbi (8/28/2013): isSgTypeSignedShort uses table-driven castability instead of c++ default dynamic_cast
53296 : // this improves the running time performance by 10-20%.
53297 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeSignedShort*>(inputDerivedClassPointer);
53298 198 : return IS_SgTypeSignedShort_FAST_MACRO(inputDerivedClassPointer);
53299 : }
53300 :
53301 : // DQ (11/8/2003): Added version of functions taking const pointer
53302 0 : const SgTypeSignedShort* isSgTypeSignedShort ( const SgNode* inputDerivedClassPointer )
53303 : {
53304 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
53305 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
53306 : // So to fix this we return NULL directly when the input is NULL and avoid the
53307 : // dynamic_cast in this case. This is likely a performance improvement as well.
53308 : // return dynamic_cast<const SgTypeSignedShort*>(inputDerivedClassPointer);
53309 : // Milind Chabbi (8/28/2013): isSgTypeSignedShort uses table-driven castability instead of c++ default dynamic_cast
53310 : // this improves the running time performance by 10-20%.
53311 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeSignedShort*>(inputDerivedClassPointer);
53312 0 : return IS_SgTypeSignedShort_FAST_MACRO(inputDerivedClassPointer);
53313 : }
53314 :
53315 :
53316 :
53317 : /* #line 53318 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53318 :
53319 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
53320 :
53321 : /**
53322 : \brief Generated destructor
53323 :
53324 : This destructor is automatically generated (by ROSETTA). This destructor
53325 : only frees memory of data members associated with the parts of the current IR node which
53326 : are NOT traversed. Those data members that are part of a traversal can be freed using
53327 : a traversal (calling this destructor on all children in a post-order traversal). Such
53328 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
53329 :
53330 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
53331 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
53332 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
53333 :
53334 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
53335 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
53336 : pointers are not yet implemented to call delete on eash pointer in the container.
53337 : (This could be done by derivation from the STL containers to define containers that
53338 : automatically deleted their members.)
53339 :
53340 : */
53341 8 : SgTypeSignedShort::~SgTypeSignedShort () {
53342 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
53343 :
53344 :
53345 :
53346 : }
53347 :
53348 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
53349 8 : }
53350 :
53351 :
53352 : /* #line 53353 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53353 :
53354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
53355 :
53356 : // Generated constructor
53357 198 : SgTypeSignedShort::SgTypeSignedShort ( )
53358 198 : : SgType()
53359 : {
53360 : #ifdef DEBUG
53361 : // printf ("In SgTypeSignedShort::SgTypeSignedShort () sage_class_name() = %s \n",sage_class_name());
53362 : #endif
53363 : #if 0
53364 : // debugging information!
53365 : printf ("In SgTypeSignedShort::SgTypeSignedShort (): this = %p = %s \n",this,this->class_name().c_str());
53366 : #endif
53367 :
53368 :
53369 :
53370 : #if 0
53371 : // DQ (7/30/2014): Call a virtual function.
53372 : std::string s = this->class_name();
53373 : #endif
53374 :
53375 : // Test the variant virtual function
53376 : // assert(T_SIGNED_SHORT == variant());
53377 198 : assert(T_SIGNED_SHORT == this->variant());
53378 198 : ROSE_ASSERT(T_SIGNED_SHORT == (int)(this->variantT()));
53379 198 : post_construction_initialization();
53380 :
53381 : // Test the isSgTypeSignedShort() function since it has been problematic
53382 198 : assert(isSgTypeSignedShort(this) != NULL);
53383 198 : }
53384 :
53385 : // Generated constructor (all data members)
53386 :
53387 : /* #line 53388 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53388 :
53389 :
53390 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
53391 :
53392 :
53393 : // ********************************************************
53394 : // member functions common across all array grammar objects
53395 : // ********************************************************
53396 :
53397 :
53398 :
53399 : /* #line 53400 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53400 :
53401 :
53402 :
53403 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
53404 :
53405 : // ********************************************************
53406 : // member functions specific to each node in the grammar
53407 : // ********************************************************
53408 :
53409 :
53410 : /* #line 53411 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53411 :
53412 : // Start of memberFunctionString
53413 :
53414 :
53415 : // End of memberFunctionString
53416 : // Start of memberFunctionString
53417 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
53418 :
53419 : // *** COMMON CODE SECTION BEGINS HERE ***
53420 :
53421 : #if 0
53422 : int
53423 : SgTypeUnsignedShort::getVariant() const
53424 : {
53425 : // This function is used in ROSE while "variant()" is used in SAGE
53426 : assert(this != NULL);
53427 : return variant();
53428 : }
53429 : #endif
53430 :
53431 : // This function is used in ROSE in treeTraversal code
53432 : // eventually replaces getVariant() and variant()
53433 : // though after variant() has been removed for a while we will
53434 : // want to change the name of variantT() back to variant()
53435 : // (since the "T" was ment to stand for temporary).
53436 : // When this happens the variantT() will be depricated.
53437 : VariantT
53438 177031000 : SgTypeUnsignedShort::variantT() const
53439 : {
53440 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
53441 177031000 : ROSE_ASSERT(this != NULL);
53442 177031000 : return V_SgTypeUnsignedShort;
53443 : }
53444 :
53445 : #if 0
53446 : int
53447 : SgTypeUnsignedShort::variant() const
53448 : {
53449 : // This function is used in SAGE
53450 : ROSE_ASSERT(this != NULL);
53451 : return T_UNSIGNED_SHORT;
53452 : }
53453 : #endif
53454 :
53455 : ROSE_DLL_API const char*
53456 0 : SgTypeUnsignedShort::sage_class_name() const
53457 : {
53458 0 : ROSE_ASSERT(this != NULL);
53459 0 : return "SgTypeUnsignedShort";
53460 : }
53461 :
53462 : std::string
53463 300 : SgTypeUnsignedShort::class_name() const
53464 : {
53465 300 : ROSE_ASSERT(this != NULL);
53466 300 : return "SgTypeUnsignedShort";
53467 : }
53468 :
53469 : // DQ (11/26/2005): Support for visitor pattern mechanims
53470 : // (inferior to ROSE traversal mechanism, experimental).
53471 : void
53472 194 : SgTypeUnsignedShort::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
53473 : {
53474 194 : ROSE_ASSERT(this != NULL);
53475 194 : visitor.visit(this);
53476 194 : }
53477 :
53478 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
53479 0 : void SgTypeUnsignedShort::accept (ROSE_VisitorPattern & visitor) {
53480 0 : ROSE_ASSERT(this != NULL);
53481 0 : visitor.visit(this);
53482 0 : }
53483 :
53484 : SgTypeUnsignedShort*
53485 0 : SgTypeUnsignedShort::addRegExpAttribute(std::string s, AstRegExAttribute* a)
53486 : {
53487 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
53488 : // This function is currently only supported for the AST used the represent Binary executables.
53489 : if (0 /* isSgAsmNode(this) != NULL */)
53490 : {
53491 : // Support for regex specification.
53492 : std::string prefixCode = "REGEX:";
53493 : addNewAttribute(prefixCode + s,a);
53494 : }
53495 : #endif
53496 :
53497 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
53498 0 : return this;
53499 : }
53500 :
53501 : // *** COMMON CODE SECTION ENDS HERE ***
53502 :
53503 :
53504 : // End of memberFunctionString
53505 : // Start of memberFunctionString
53506 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
53507 :
53508 :
53509 : #if 0
53510 : //! Error checking support
53511 : /*! Verifies the following:
53512 : - working getVariant() member function
53513 : - calls base class's error() member function
53514 : Every class has one of these functions.
53515 : */
53516 : bool
53517 : SgTypeUnsignedShort::error()
53518 : {
53519 : // Put error checking here
53520 :
53521 : ROSE_ASSERT (this != NULL);
53522 : if (getVariant() != T_UNSIGNED_SHORT)
53523 : {
53524 : printf ("Error in SgTypeUnsignedShort::error(): SgTypeUnsignedShort object has a %s variant \n",
53525 : Cxx_GrammarTerminalNames[getVariant()].name);
53526 : // printf ("Error in SgTypeUnsignedShort::error() \n");
53527 : ROSE_ABORT();
53528 : }
53529 :
53530 : ROSE_ASSERT (getVariant() == T_UNSIGNED_SHORT);
53531 : return SgType::error();
53532 : }
53533 : #endif
53534 :
53535 :
53536 :
53537 : // End of memberFunctionString
53538 : // Start of memberFunctionString
53539 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
53540 :
53541 :
53542 : // DQ (1/31/2006): Modified to build all types in the memory pools
53543 : // SgTypeUnsignedShort SgTypeUnsignedShort::builtin_type;
53544 : // SgTypeUnsignedShort* SgTypeUnsignedShort::builtin_type = new SgTypeUnsignedShort();
53545 : SgTypeUnsignedShort* SgTypeUnsignedShort::p_builtin_type = NULL;
53546 :
53547 :
53548 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
53549 : // SgTypeUnsignedShort* SgTypeUnsignedShort::createType(void)
53550 : SgTypeUnsignedShort*
53551 322 : SgTypeUnsignedShort::createType(SgExpression* optional_fortran_type_kind)
53552 : {
53553 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
53554 : // is not called (likely because static initialization is compiler dependent).
53555 : // DQ (1/31/2006): Modified to build all types in the memory pools
53556 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
53557 : // return &builtin_type;
53558 :
53559 : #if 0
53560 : printf ("In SgTypeUnsignedShort::createType() (COMMON_CREATE_TYPE) \n");
53561 : #endif
53562 :
53563 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
53564 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
53565 :
53566 322 : SgTypeUnsignedShort* temp_type = new SgTypeUnsignedShort();
53567 :
53568 : #if 0
53569 : printf ("In SgTypeUnsignedShort::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
53570 : #endif
53571 :
53572 : // DQ (10/31/2016): Added assertion.
53573 322 : ROSE_ASSERT(temp_type != NULL);
53574 :
53575 322 : if (optional_fortran_type_kind != NULL)
53576 : {
53577 : // DQ (10/31/2016): Added assertion.
53578 0 : ROSE_ASSERT(temp_type != NULL);
53579 :
53580 0 : temp_type->set_type_kind(optional_fortran_type_kind);
53581 : }
53582 : #if 0
53583 : else
53584 : {
53585 : // Let p_builtin_type refer to the unadorned type (no type kind).
53586 : p_builtin_type = temp_type;
53587 : }
53588 : #endif
53589 :
53590 322 : SgName name = temp_type->get_mangled();
53591 :
53592 : #if 0
53593 : printf ("Mangled type name for SgTypeUnsignedShort = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
53594 : #endif
53595 :
53596 : // DQ (10/31/2016): Added assertion.
53597 322 : ROSE_ASSERT(get_globalTypeTable() != NULL);
53598 :
53599 322 : SgType* t = get_globalTypeTable()->lookup_type(name);
53600 :
53601 : #if 0
53602 : printf ("In SgTypeUnsignedShort::createType(): type from lookup_type = %p \n",t);
53603 : #endif
53604 :
53605 322 : if (t == NULL)
53606 : {
53607 315 : get_globalTypeTable()->insert_type(name,temp_type);
53608 : }
53609 : else
53610 : {
53611 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
53612 7 : if (t != temp_type)
53613 : {
53614 : #if 0
53615 : printf ("In SgTypeUnsignedShort::createType(): deleting temp_type = %p \n",temp_type);
53616 : #endif
53617 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
53618 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
53619 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
53620 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
53621 7 : delete temp_type;
53622 : #endif
53623 7 : temp_type = NULL;
53624 : #if 0
53625 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
53626 : if (optional_fortran_type_kind != NULL)
53627 : {
53628 : p_builtin_type = NULL;
53629 : }
53630 : #endif
53631 : }
53632 :
53633 : // Reuse this tempType variable so we can use the same code below.
53634 7 : temp_type = isSgTypeUnsignedShort(t);
53635 7 : ROSE_ASSERT(temp_type != NULL);
53636 : }
53637 :
53638 : #if 0
53639 : printf ("Leaving SgTypeUnsignedShort::createType(): temp_type = %p \n",temp_type);
53640 : #endif
53641 :
53642 322 : return temp_type;
53643 : }
53644 :
53645 :
53646 :
53647 : // End of memberFunctionString
53648 : // Start of memberFunctionString
53649 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
53650 :
53651 : #if 1
53652 : /*! Support for mangled names (for unparser)
53653 : There are two different cases of source code for the get_mangled member function
53654 : This one is used in all but the classes containing a base type
53655 : */
53656 : // SgName SgTypeUnsignedShort::get_mangled ( SgUnparse_Info & info )
53657 : SgName
53658 33251 : SgTypeUnsignedShort::get_mangled (void) const
53659 : {
53660 33251 : ROSE_ASSERT(this != NULL);
53661 :
53662 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
53663 : // CR (3/6/2020): Now type_kind is also used for Jovial.
53664 33251 : SgName name = "Us";
53665 33251 : if (get_type_kind() != NULL)
53666 : {
53667 : // name += get_type_kind()->get_mangled();
53668 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
53669 0 : SgValueExp* value = isSgValueExp(get_type_kind());
53670 0 : if (value != NULL)
53671 : {
53672 : // name += string("_") + StringUtility::numberToString(value->get_value());
53673 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
53674 : }
53675 : else
53676 : {
53677 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
53678 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
53679 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
53680 : // a different prefix for each type of named type. It come down to is there can be multiple
53681 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
53682 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
53683 : // I think the issue is that Us is not defined for any of the SgNameType IR nodes.
53684 : #if 0
53685 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Us");
53686 : #endif
53687 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
53688 : }
53689 : }
53690 :
53691 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
53692 : // REMOVE_ME please!
53693 33251 : if (isSgTypeFixed(this))
53694 : {
53695 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
53696 0 : if (fixed_type->get_scale() != NULL)
53697 : {
53698 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
53699 0 : if (value != NULL)
53700 : {
53701 0 : name += string("_") + value->get_constant_folded_value_as_string();
53702 : }
53703 : }
53704 0 : if (fixed_type->get_fraction() != NULL)
53705 : {
53706 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
53707 0 : if (value != NULL)
53708 : {
53709 0 : name += string("_") + value->get_constant_folded_value_as_string();
53710 : }
53711 : }
53712 : }
53713 :
53714 : #if 0
53715 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
53716 : #endif
53717 :
53718 33251 : return name;
53719 : }
53720 : #endif
53721 :
53722 :
53723 : // End of memberFunctionString
53724 :
53725 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
53726 :
53727 329 : SgTypeUnsignedShort* isSgTypeUnsignedShort ( SgNode* inputDerivedClassPointer )
53728 : {
53729 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
53730 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
53731 : // So to fix this we return NULL directly when the input is NULL and avoid the
53732 : // dynamic_cast in this case. This is likely a performance improvement as well.
53733 : // return dynamic_cast<SgTypeUnsignedShort*>(inputDerivedClassPointer);
53734 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedShort uses table-driven castability instead of c++ default dynamic_cast
53735 : // this improves the running time performance by 10-20%.
53736 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnsignedShort*>(inputDerivedClassPointer);
53737 329 : return IS_SgTypeUnsignedShort_FAST_MACRO(inputDerivedClassPointer);
53738 : }
53739 :
53740 : // DQ (11/8/2003): Added version of functions taking const pointer
53741 0 : const SgTypeUnsignedShort* isSgTypeUnsignedShort ( const SgNode* inputDerivedClassPointer )
53742 : {
53743 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
53744 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
53745 : // So to fix this we return NULL directly when the input is NULL and avoid the
53746 : // dynamic_cast in this case. This is likely a performance improvement as well.
53747 : // return dynamic_cast<const SgTypeUnsignedShort*>(inputDerivedClassPointer);
53748 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedShort uses table-driven castability instead of c++ default dynamic_cast
53749 : // this improves the running time performance by 10-20%.
53750 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnsignedShort*>(inputDerivedClassPointer);
53751 0 : return IS_SgTypeUnsignedShort_FAST_MACRO(inputDerivedClassPointer);
53752 : }
53753 :
53754 :
53755 :
53756 : /* #line 53757 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53757 :
53758 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
53759 :
53760 : /**
53761 : \brief Generated destructor
53762 :
53763 : This destructor is automatically generated (by ROSETTA). This destructor
53764 : only frees memory of data members associated with the parts of the current IR node which
53765 : are NOT traversed. Those data members that are part of a traversal can be freed using
53766 : a traversal (calling this destructor on all children in a post-order traversal). Such
53767 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
53768 :
53769 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
53770 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
53771 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
53772 :
53773 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
53774 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
53775 : pointers are not yet implemented to call delete on eash pointer in the container.
53776 : (This could be done by derivation from the STL containers to define containers that
53777 : automatically deleted their members.)
53778 :
53779 : */
53780 22 : SgTypeUnsignedShort::~SgTypeUnsignedShort () {
53781 11 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
53782 :
53783 :
53784 :
53785 : }
53786 :
53787 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
53788 22 : }
53789 :
53790 :
53791 : /* #line 53792 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53792 :
53793 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
53794 :
53795 : // Generated constructor
53796 322 : SgTypeUnsignedShort::SgTypeUnsignedShort ( )
53797 322 : : SgType()
53798 : {
53799 : #ifdef DEBUG
53800 : // printf ("In SgTypeUnsignedShort::SgTypeUnsignedShort () sage_class_name() = %s \n",sage_class_name());
53801 : #endif
53802 : #if 0
53803 : // debugging information!
53804 : printf ("In SgTypeUnsignedShort::SgTypeUnsignedShort (): this = %p = %s \n",this,this->class_name().c_str());
53805 : #endif
53806 :
53807 :
53808 :
53809 : #if 0
53810 : // DQ (7/30/2014): Call a virtual function.
53811 : std::string s = this->class_name();
53812 : #endif
53813 :
53814 : // Test the variant virtual function
53815 : // assert(T_UNSIGNED_SHORT == variant());
53816 322 : assert(T_UNSIGNED_SHORT == this->variant());
53817 322 : ROSE_ASSERT(T_UNSIGNED_SHORT == (int)(this->variantT()));
53818 322 : post_construction_initialization();
53819 :
53820 : // Test the isSgTypeUnsignedShort() function since it has been problematic
53821 322 : assert(isSgTypeUnsignedShort(this) != NULL);
53822 322 : }
53823 :
53824 : // Generated constructor (all data members)
53825 :
53826 : /* #line 53827 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53827 :
53828 :
53829 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
53830 :
53831 :
53832 : // ********************************************************
53833 : // member functions common across all array grammar objects
53834 : // ********************************************************
53835 :
53836 :
53837 :
53838 : /* #line 53839 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53839 :
53840 :
53841 :
53842 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
53843 :
53844 : // ********************************************************
53845 : // member functions specific to each node in the grammar
53846 : // ********************************************************
53847 :
53848 :
53849 : /* #line 53850 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
53850 :
53851 : // Start of memberFunctionString
53852 :
53853 :
53854 : // End of memberFunctionString
53855 : // Start of memberFunctionString
53856 : /* #line 6795 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
53857 :
53858 : const int SgTypeInt::maxBitLength = ROSE_INTEGER_TYPE_MAX_BIT_LENGTH;
53859 : // DQ (1/31/2006): Modified to build all types in the memory pools
53860 : // SgTypeInt SgTypeInt::builtin_type[maxBitLength];
53861 : #if 0
53862 : #if defined __x86_64__
53863 : // 64 bit support
53864 : SgTypeInt* SgTypeInt::p_builtin_type[maxBitLength] = { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
53865 : NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
53866 : NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
53867 : NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
53868 : #else
53869 : // 32 bit support
53870 : SgTypeInt* SgTypeInt::p_builtin_type[maxBitLength] = { NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
53871 : NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
53872 : #endif
53873 : #else
53874 : // DQ (1/31/2006): Convert to a single builtin pointer rather than an array of them.
53875 : // I don't think we really need an array of these internally.
53876 : SgTypeInt* SgTypeInt::p_builtin_type = NULL;
53877 : #endif
53878 :
53879 : // DQ (10/4/2010): Added support for fortran type kind expressions.
53880 : // SgTypeInt* SgTypeInt::createType(int bitLength)
53881 : SgTypeInt*
53882 17947 : SgTypeInt::createType(int bitLength, SgExpression* optional_fortran_type_kind)
53883 : {
53884 : #if 0
53885 : printf ("In SgTypeInt::createType() \n");
53886 : #endif
53887 :
53888 : #if 0
53889 : static bool firstCallToFunction = true;
53890 : if (firstCallToFunction == true)
53891 : {
53892 : // printf ("Build the SgTypeInt objects within the builtin_type array (for bit modified types) \n");
53893 : // Allocate all the required integer types (we require 32 of them for
53894 : // 32 bit architectures because "int i:n" (where "n" is the number of
53895 : // bits), forms a valid type).
53896 : for (int i=0; i < maxBitLength; i++)
53897 : {
53898 : p_builtin_type[bitLength] = new SgTypeInt();
53899 : }
53900 : }
53901 : firstCallToFunction = false;
53902 :
53903 : ROSE_ASSERT(bitLength < maxBitLength);
53904 :
53905 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
53906 : // is not called (likely because static initialization is compiler dependent).
53907 : // DQ (1/31/2006): Modified to build all types in the memory pools
53908 : // builtin_type[bitLength].p_freepointer = AST_FileIO::IS_VALID_POINTER();
53909 : // return &builtin_type[bitLength];
53910 : ROSE_ASSERT(p_builtin_type[bitLength] != NULL);
53911 : p_builtin_type[bitLength]->p_freepointer = AST_FileIO::IS_VALID_POINTER();
53912 : return p_builtin_type[bitLength];
53913 : #else
53914 : #if 0
53915 : // DQ (1/31/2006): Convert to a single builtin pointer rather than an array of them.
53916 : // I don't think we really need an array of these internally.
53917 : if (p_builtin_type == NULL)
53918 : {
53919 : #if 0
53920 : p_builtin_type = new SgTypeInt(bitLength);
53921 : #else
53922 : // DQ (7/22/2010): Use the global type table to get the type.
53923 : p_builtin_type = new SgTypeInt(bitLength);
53924 :
53925 : if (optional_fortran_type_kind != NULL)
53926 : {
53927 : // DQ (10/4/2010): Added fortran type kind support (must be in place before the mangled name is generated).
53928 : p_builtin_type->set_type_kind(optional_fortran_type_kind);
53929 : }
53930 :
53931 : SgName name = p_builtin_type->get_mangled();
53932 : #if 0
53933 : printf ("Mangled type name for SgTypeInt = %s \n",name.str());
53934 : #endif
53935 : get_globalTypeTable()->insert_type(name,p_builtin_type);
53936 : #endif
53937 : }
53938 :
53939 : ROSE_ASSERT(p_builtin_type != NULL);
53940 : return p_builtin_type;
53941 : #else
53942 : // DQ (10/5/2010): New version of code to support multiple kinds of SgTypeInt as required for the Fortran type_kind support within ROSE.
53943 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
53944 :
53945 17947 : SgTypeInt* temp_type = new SgTypeInt();
53946 17947 : if (optional_fortran_type_kind != NULL)
53947 : {
53948 56 : temp_type->set_type_kind(optional_fortran_type_kind);
53949 : }
53950 :
53951 17947 : SgName name = temp_type->get_mangled();
53952 : #if 0
53953 : printf ("Mangled type name for SgTypeInt = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
53954 : #endif
53955 :
53956 17947 : SgType* t = get_globalTypeTable()->lookup_type(name);
53957 : #if 0
53958 : printf ("In SgTypeInt::createType(): type from lookup_type = %p \n",t);
53959 : #endif
53960 17947 : if (t == NULL)
53961 : {
53962 397 : get_globalTypeTable()->insert_type(name,temp_type);
53963 : }
53964 : else
53965 : {
53966 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
53967 17550 : if (t != temp_type)
53968 : {
53969 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
53970 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
53971 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
53972 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
53973 17550 : delete temp_type;
53974 : #endif
53975 17550 : temp_type = NULL;
53976 : }
53977 :
53978 : // Reuse this tempType variable so we can use the same code below.
53979 17550 : temp_type = isSgTypeInt(t);
53980 17550 : ROSE_ASSERT(temp_type != NULL);
53981 : }
53982 :
53983 17947 : return temp_type;
53984 : #endif
53985 : #endif
53986 : }
53987 :
53988 : #if 0
53989 : // DQ (12/26/2005): Supporting function for traverseMemoryPool
53990 : // where static IR nodes (only isn soem SgType IR nodes) are
53991 : // present and must be traversed using specially generated code.
53992 : void
53993 : SgTypeInt::executeVisitorMemberFunctionOnBuiltinData(ROSE_Visitor & visitor)
53994 : {
53995 : for (int i=0; i < SgTypeInt::maxBitLength; i++)
53996 : SgTypeInt::builtin_type[i].executeVisitorMemberFunction(visitor);
53997 : }
53998 : #endif
53999 :
54000 :
54001 : // End of memberFunctionString
54002 : // Start of memberFunctionString
54003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
54004 :
54005 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
54006 :
54007 : int
54008 0 : SgTypeInt::get_field_size () const
54009 : {
54010 0 : ROSE_ASSERT (this != NULL);
54011 :
54012 : #if 0
54013 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
54014 : // used to trigger marking transformations for the token-based unparsing.
54015 : printf ("SgTypeInt::get_field_size = %p = %s \n",this,this->class_name().c_str());
54016 : #endif
54017 :
54018 0 : return p_field_size;
54019 : }
54020 :
54021 : void
54022 0 : SgTypeInt::set_field_size ( int field_size )
54023 : {
54024 0 : ROSE_ASSERT (this != NULL);
54025 :
54026 : #if 0
54027 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
54028 : // used to trigger marking transformations for the token-based unparsing.
54029 : printf ("SgTypeInt::set_field_size = %p = %s \n",this,this->class_name().c_str());
54030 : #endif
54031 :
54032 0 : set_isModified(true);
54033 :
54034 0 : p_field_size = field_size;
54035 0 : }
54036 :
54037 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
54038 :
54039 :
54040 : // End of memberFunctionString
54041 : // Start of memberFunctionString
54042 : /* #line 3083 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
54043 :
54044 :
54045 :
54046 : // End of memberFunctionString
54047 : // Start of memberFunctionString
54048 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
54049 :
54050 : // *** COMMON CODE SECTION BEGINS HERE ***
54051 :
54052 : #if 0
54053 : int
54054 : SgTypeInt::getVariant() const
54055 : {
54056 : // This function is used in ROSE while "variant()" is used in SAGE
54057 : assert(this != NULL);
54058 : return variant();
54059 : }
54060 : #endif
54061 :
54062 : // This function is used in ROSE in treeTraversal code
54063 : // eventually replaces getVariant() and variant()
54064 : // though after variant() has been removed for a while we will
54065 : // want to change the name of variantT() back to variant()
54066 : // (since the "T" was ment to stand for temporary).
54067 : // When this happens the variantT() will be depricated.
54068 : VariantT
54069 138121000 : SgTypeInt::variantT() const
54070 : {
54071 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
54072 138121000 : ROSE_ASSERT(this != NULL);
54073 138121000 : return V_SgTypeInt;
54074 : }
54075 :
54076 : #if 0
54077 : int
54078 : SgTypeInt::variant() const
54079 : {
54080 : // This function is used in SAGE
54081 : ROSE_ASSERT(this != NULL);
54082 : return T_INT;
54083 : }
54084 : #endif
54085 :
54086 : ROSE_DLL_API const char*
54087 0 : SgTypeInt::sage_class_name() const
54088 : {
54089 0 : ROSE_ASSERT(this != NULL);
54090 0 : return "SgTypeInt";
54091 : }
54092 :
54093 : std::string
54094 4913 : SgTypeInt::class_name() const
54095 : {
54096 4913 : ROSE_ASSERT(this != NULL);
54097 4913 : return "SgTypeInt";
54098 : }
54099 :
54100 : // DQ (11/26/2005): Support for visitor pattern mechanims
54101 : // (inferior to ROSE traversal mechanism, experimental).
54102 : void
54103 194 : SgTypeInt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
54104 : {
54105 194 : ROSE_ASSERT(this != NULL);
54106 194 : visitor.visit(this);
54107 194 : }
54108 :
54109 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
54110 0 : void SgTypeInt::accept (ROSE_VisitorPattern & visitor) {
54111 0 : ROSE_ASSERT(this != NULL);
54112 0 : visitor.visit(this);
54113 0 : }
54114 :
54115 : SgTypeInt*
54116 0 : SgTypeInt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
54117 : {
54118 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
54119 : // This function is currently only supported for the AST used the represent Binary executables.
54120 : if (0 /* isSgAsmNode(this) != NULL */)
54121 : {
54122 : // Support for regex specification.
54123 : std::string prefixCode = "REGEX:";
54124 : addNewAttribute(prefixCode + s,a);
54125 : }
54126 : #endif
54127 :
54128 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
54129 0 : return this;
54130 : }
54131 :
54132 : // *** COMMON CODE SECTION ENDS HERE ***
54133 :
54134 :
54135 : // End of memberFunctionString
54136 : // Start of memberFunctionString
54137 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
54138 :
54139 :
54140 : #if 0
54141 : //! Error checking support
54142 : /*! Verifies the following:
54143 : - working getVariant() member function
54144 : - calls base class's error() member function
54145 : Every class has one of these functions.
54146 : */
54147 : bool
54148 : SgTypeInt::error()
54149 : {
54150 : // Put error checking here
54151 :
54152 : ROSE_ASSERT (this != NULL);
54153 : if (getVariant() != T_INT)
54154 : {
54155 : printf ("Error in SgTypeInt::error(): SgTypeInt object has a %s variant \n",
54156 : Cxx_GrammarTerminalNames[getVariant()].name);
54157 : // printf ("Error in SgTypeInt::error() \n");
54158 : ROSE_ABORT();
54159 : }
54160 :
54161 : ROSE_ASSERT (getVariant() == T_INT);
54162 : return SgType::error();
54163 : }
54164 : #endif
54165 :
54166 :
54167 :
54168 : // End of memberFunctionString
54169 : // Start of memberFunctionString
54170 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
54171 :
54172 : #if 1
54173 : /*! Support for mangled names (for unparser)
54174 : There are two different cases of source code for the get_mangled member function
54175 : This one is used in all but the classes containing a base type
54176 : */
54177 : // SgName SgTypeInt::get_mangled ( SgUnparse_Info & info )
54178 : SgName
54179 803517 : SgTypeInt::get_mangled (void) const
54180 : {
54181 803517 : ROSE_ASSERT(this != NULL);
54182 :
54183 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
54184 : // CR (3/6/2020): Now type_kind is also used for Jovial.
54185 803517 : SgName name = "i";
54186 803517 : if (get_type_kind() != NULL)
54187 : {
54188 : // name += get_type_kind()->get_mangled();
54189 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
54190 112 : SgValueExp* value = isSgValueExp(get_type_kind());
54191 112 : if (value != NULL)
54192 : {
54193 : // name += string("_") + StringUtility::numberToString(value->get_value());
54194 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
54195 : }
54196 : else
54197 : {
54198 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
54199 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
54200 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
54201 : // a different prefix for each type of named type. It come down to is there can be multiple
54202 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
54203 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
54204 : // I think the issue is that i is not defined for any of the SgNameType IR nodes.
54205 : #if 0
54206 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"i");
54207 : #endif
54208 224 : name += SageInterface::generateUniqueName(get_type_kind(),false);
54209 : }
54210 : }
54211 :
54212 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
54213 : // REMOVE_ME please!
54214 803517 : if (isSgTypeFixed(this))
54215 : {
54216 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
54217 0 : if (fixed_type->get_scale() != NULL)
54218 : {
54219 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
54220 0 : if (value != NULL)
54221 : {
54222 0 : name += string("_") + value->get_constant_folded_value_as_string();
54223 : }
54224 : }
54225 0 : if (fixed_type->get_fraction() != NULL)
54226 : {
54227 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
54228 0 : if (value != NULL)
54229 : {
54230 0 : name += string("_") + value->get_constant_folded_value_as_string();
54231 : }
54232 : }
54233 : }
54234 :
54235 : #if 0
54236 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
54237 : #endif
54238 :
54239 803517 : return name;
54240 : }
54241 : #endif
54242 :
54243 :
54244 : // End of memberFunctionString
54245 :
54246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
54247 :
54248 35497 : SgTypeInt* isSgTypeInt ( SgNode* inputDerivedClassPointer )
54249 : {
54250 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
54251 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
54252 : // So to fix this we return NULL directly when the input is NULL and avoid the
54253 : // dynamic_cast in this case. This is likely a performance improvement as well.
54254 : // return dynamic_cast<SgTypeInt*>(inputDerivedClassPointer);
54255 : // Milind Chabbi (8/28/2013): isSgTypeInt uses table-driven castability instead of c++ default dynamic_cast
54256 : // this improves the running time performance by 10-20%.
54257 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeInt*>(inputDerivedClassPointer);
54258 35497 : return IS_SgTypeInt_FAST_MACRO(inputDerivedClassPointer);
54259 : }
54260 :
54261 : // DQ (11/8/2003): Added version of functions taking const pointer
54262 0 : const SgTypeInt* isSgTypeInt ( const SgNode* inputDerivedClassPointer )
54263 : {
54264 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
54265 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
54266 : // So to fix this we return NULL directly when the input is NULL and avoid the
54267 : // dynamic_cast in this case. This is likely a performance improvement as well.
54268 : // return dynamic_cast<const SgTypeInt*>(inputDerivedClassPointer);
54269 : // Milind Chabbi (8/28/2013): isSgTypeInt uses table-driven castability instead of c++ default dynamic_cast
54270 : // this improves the running time performance by 10-20%.
54271 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeInt*>(inputDerivedClassPointer);
54272 0 : return IS_SgTypeInt_FAST_MACRO(inputDerivedClassPointer);
54273 : }
54274 :
54275 :
54276 :
54277 : /* #line 54278 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54278 :
54279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
54280 :
54281 : /**
54282 : \brief Generated destructor
54283 :
54284 : This destructor is automatically generated (by ROSETTA). This destructor
54285 : only frees memory of data members associated with the parts of the current IR node which
54286 : are NOT traversed. Those data members that are part of a traversal can be freed using
54287 : a traversal (calling this destructor on all children in a post-order traversal). Such
54288 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
54289 :
54290 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
54291 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
54292 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
54293 :
54294 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
54295 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
54296 : pointers are not yet implemented to call delete on eash pointer in the container.
54297 : (This could be done by derivation from the STL containers to define containers that
54298 : automatically deleted their members.)
54299 :
54300 : */
54301 35108 : SgTypeInt::~SgTypeInt () {
54302 17554 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
54303 :
54304 :
54305 : // case: not a listType for field_size
54306 17554 : p_field_size = 0; // non list case
54307 :
54308 : }
54309 :
54310 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
54311 35108 : }
54312 :
54313 :
54314 : /* #line 54315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54315 :
54316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
54317 :
54318 : // Generated constructor
54319 17947 : SgTypeInt::SgTypeInt ( int field_size )
54320 17947 : : SgType()
54321 : {
54322 : #ifdef DEBUG
54323 : // printf ("In SgTypeInt::SgTypeInt (int field_size) sage_class_name() = %s \n",sage_class_name());
54324 : #endif
54325 : #if 0
54326 : // debugging information!
54327 : printf ("In SgTypeInt::SgTypeInt (int field_size): this = %p = %s \n",this,this->class_name().c_str());
54328 : #endif
54329 :
54330 17947 : p_field_size = field_size;
54331 :
54332 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
54333 :
54334 : #if 0
54335 : // DQ (7/30/2014): Call a virtual function.
54336 : std::string s = this->class_name();
54337 : #endif
54338 :
54339 : // Test the variant virtual function
54340 : // assert(T_INT == variant());
54341 17947 : assert(T_INT == this->variant());
54342 17947 : ROSE_ASSERT(T_INT == (int)(this->variantT()));
54343 17947 : post_construction_initialization();
54344 :
54345 : // Test the isSgTypeInt() function since it has been problematic
54346 17947 : assert(isSgTypeInt(this) != NULL);
54347 17947 : }
54348 :
54349 : // Generated constructor (all data members)
54350 :
54351 : /* #line 54352 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54352 :
54353 :
54354 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
54355 :
54356 :
54357 : // ********************************************************
54358 : // member functions common across all array grammar objects
54359 : // ********************************************************
54360 :
54361 :
54362 :
54363 : /* #line 54364 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54364 :
54365 :
54366 :
54367 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
54368 :
54369 : // ********************************************************
54370 : // member functions specific to each node in the grammar
54371 : // ********************************************************
54372 :
54373 :
54374 : /* #line 54375 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54375 :
54376 : // Start of memberFunctionString
54377 :
54378 :
54379 : // End of memberFunctionString
54380 : // Start of memberFunctionString
54381 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
54382 :
54383 : // *** COMMON CODE SECTION BEGINS HERE ***
54384 :
54385 : #if 0
54386 : int
54387 : SgTypeSignedInt::getVariant() const
54388 : {
54389 : // This function is used in ROSE while "variant()" is used in SAGE
54390 : assert(this != NULL);
54391 : return variant();
54392 : }
54393 : #endif
54394 :
54395 : // This function is used in ROSE in treeTraversal code
54396 : // eventually replaces getVariant() and variant()
54397 : // though after variant() has been removed for a while we will
54398 : // want to change the name of variantT() back to variant()
54399 : // (since the "T" was ment to stand for temporary).
54400 : // When this happens the variantT() will be depricated.
54401 : VariantT
54402 483222 : SgTypeSignedInt::variantT() const
54403 : {
54404 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
54405 483222 : ROSE_ASSERT(this != NULL);
54406 483222 : return V_SgTypeSignedInt;
54407 : }
54408 :
54409 : #if 0
54410 : int
54411 : SgTypeSignedInt::variant() const
54412 : {
54413 : // This function is used in SAGE
54414 : ROSE_ASSERT(this != NULL);
54415 : return T_SIGNED_INT;
54416 : }
54417 : #endif
54418 :
54419 : ROSE_DLL_API const char*
54420 0 : SgTypeSignedInt::sage_class_name() const
54421 : {
54422 0 : ROSE_ASSERT(this != NULL);
54423 0 : return "SgTypeSignedInt";
54424 : }
54425 :
54426 : std::string
54427 194 : SgTypeSignedInt::class_name() const
54428 : {
54429 194 : ROSE_ASSERT(this != NULL);
54430 194 : return "SgTypeSignedInt";
54431 : }
54432 :
54433 : // DQ (11/26/2005): Support for visitor pattern mechanims
54434 : // (inferior to ROSE traversal mechanism, experimental).
54435 : void
54436 137 : SgTypeSignedInt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
54437 : {
54438 137 : ROSE_ASSERT(this != NULL);
54439 137 : visitor.visit(this);
54440 137 : }
54441 :
54442 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
54443 0 : void SgTypeSignedInt::accept (ROSE_VisitorPattern & visitor) {
54444 0 : ROSE_ASSERT(this != NULL);
54445 0 : visitor.visit(this);
54446 0 : }
54447 :
54448 : SgTypeSignedInt*
54449 0 : SgTypeSignedInt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
54450 : {
54451 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
54452 : // This function is currently only supported for the AST used the represent Binary executables.
54453 : if (0 /* isSgAsmNode(this) != NULL */)
54454 : {
54455 : // Support for regex specification.
54456 : std::string prefixCode = "REGEX:";
54457 : addNewAttribute(prefixCode + s,a);
54458 : }
54459 : #endif
54460 :
54461 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
54462 0 : return this;
54463 : }
54464 :
54465 : // *** COMMON CODE SECTION ENDS HERE ***
54466 :
54467 :
54468 : // End of memberFunctionString
54469 : // Start of memberFunctionString
54470 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
54471 :
54472 :
54473 : #if 0
54474 : //! Error checking support
54475 : /*! Verifies the following:
54476 : - working getVariant() member function
54477 : - calls base class's error() member function
54478 : Every class has one of these functions.
54479 : */
54480 : bool
54481 : SgTypeSignedInt::error()
54482 : {
54483 : // Put error checking here
54484 :
54485 : ROSE_ASSERT (this != NULL);
54486 : if (getVariant() != T_SIGNED_INT)
54487 : {
54488 : printf ("Error in SgTypeSignedInt::error(): SgTypeSignedInt object has a %s variant \n",
54489 : Cxx_GrammarTerminalNames[getVariant()].name);
54490 : // printf ("Error in SgTypeSignedInt::error() \n");
54491 : ROSE_ABORT();
54492 : }
54493 :
54494 : ROSE_ASSERT (getVariant() == T_SIGNED_INT);
54495 : return SgType::error();
54496 : }
54497 : #endif
54498 :
54499 :
54500 :
54501 : // End of memberFunctionString
54502 : // Start of memberFunctionString
54503 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
54504 :
54505 :
54506 : // DQ (1/31/2006): Modified to build all types in the memory pools
54507 : // SgTypeSignedInt SgTypeSignedInt::builtin_type;
54508 : // SgTypeSignedInt* SgTypeSignedInt::builtin_type = new SgTypeSignedInt();
54509 : SgTypeSignedInt* SgTypeSignedInt::p_builtin_type = NULL;
54510 :
54511 :
54512 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
54513 : // SgTypeSignedInt* SgTypeSignedInt::createType(void)
54514 : SgTypeSignedInt*
54515 198 : SgTypeSignedInt::createType(SgExpression* optional_fortran_type_kind)
54516 : {
54517 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
54518 : // is not called (likely because static initialization is compiler dependent).
54519 : // DQ (1/31/2006): Modified to build all types in the memory pools
54520 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
54521 : // return &builtin_type;
54522 :
54523 : #if 0
54524 : printf ("In SgTypeSignedInt::createType() (COMMON_CREATE_TYPE) \n");
54525 : #endif
54526 :
54527 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
54528 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
54529 :
54530 198 : SgTypeSignedInt* temp_type = new SgTypeSignedInt();
54531 :
54532 : #if 0
54533 : printf ("In SgTypeSignedInt::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
54534 : #endif
54535 :
54536 : // DQ (10/31/2016): Added assertion.
54537 198 : ROSE_ASSERT(temp_type != NULL);
54538 :
54539 198 : if (optional_fortran_type_kind != NULL)
54540 : {
54541 : // DQ (10/31/2016): Added assertion.
54542 0 : ROSE_ASSERT(temp_type != NULL);
54543 :
54544 0 : temp_type->set_type_kind(optional_fortran_type_kind);
54545 : }
54546 : #if 0
54547 : else
54548 : {
54549 : // Let p_builtin_type refer to the unadorned type (no type kind).
54550 : p_builtin_type = temp_type;
54551 : }
54552 : #endif
54553 :
54554 198 : SgName name = temp_type->get_mangled();
54555 :
54556 : #if 0
54557 : printf ("Mangled type name for SgTypeSignedInt = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
54558 : #endif
54559 :
54560 : // DQ (10/31/2016): Added assertion.
54561 198 : ROSE_ASSERT(get_globalTypeTable() != NULL);
54562 :
54563 198 : SgType* t = get_globalTypeTable()->lookup_type(name);
54564 :
54565 : #if 0
54566 : printf ("In SgTypeSignedInt::createType(): type from lookup_type = %p \n",t);
54567 : #endif
54568 :
54569 198 : if (t == NULL)
54570 : {
54571 198 : get_globalTypeTable()->insert_type(name,temp_type);
54572 : }
54573 : else
54574 : {
54575 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
54576 0 : if (t != temp_type)
54577 : {
54578 : #if 0
54579 : printf ("In SgTypeSignedInt::createType(): deleting temp_type = %p \n",temp_type);
54580 : #endif
54581 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
54582 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
54583 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
54584 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
54585 0 : delete temp_type;
54586 : #endif
54587 0 : temp_type = NULL;
54588 : #if 0
54589 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
54590 : if (optional_fortran_type_kind != NULL)
54591 : {
54592 : p_builtin_type = NULL;
54593 : }
54594 : #endif
54595 : }
54596 :
54597 : // Reuse this tempType variable so we can use the same code below.
54598 0 : temp_type = isSgTypeSignedInt(t);
54599 0 : ROSE_ASSERT(temp_type != NULL);
54600 : }
54601 :
54602 : #if 0
54603 : printf ("Leaving SgTypeSignedInt::createType(): temp_type = %p \n",temp_type);
54604 : #endif
54605 :
54606 198 : return temp_type;
54607 : }
54608 :
54609 :
54610 :
54611 : // End of memberFunctionString
54612 : // Start of memberFunctionString
54613 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
54614 :
54615 : #if 1
54616 : /*! Support for mangled names (for unparser)
54617 : There are two different cases of source code for the get_mangled member function
54618 : This one is used in all but the classes containing a base type
54619 : */
54620 : // SgName SgTypeSignedInt::get_mangled ( SgUnparse_Info & info )
54621 : SgName
54622 200 : SgTypeSignedInt::get_mangled (void) const
54623 : {
54624 200 : ROSE_ASSERT(this != NULL);
54625 :
54626 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
54627 : // CR (3/6/2020): Now type_kind is also used for Jovial.
54628 200 : SgName name = "Si";
54629 200 : if (get_type_kind() != NULL)
54630 : {
54631 : // name += get_type_kind()->get_mangled();
54632 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
54633 0 : SgValueExp* value = isSgValueExp(get_type_kind());
54634 0 : if (value != NULL)
54635 : {
54636 : // name += string("_") + StringUtility::numberToString(value->get_value());
54637 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
54638 : }
54639 : else
54640 : {
54641 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
54642 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
54643 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
54644 : // a different prefix for each type of named type. It come down to is there can be multiple
54645 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
54646 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
54647 : // I think the issue is that Si is not defined for any of the SgNameType IR nodes.
54648 : #if 0
54649 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Si");
54650 : #endif
54651 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
54652 : }
54653 : }
54654 :
54655 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
54656 : // REMOVE_ME please!
54657 200 : if (isSgTypeFixed(this))
54658 : {
54659 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
54660 0 : if (fixed_type->get_scale() != NULL)
54661 : {
54662 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
54663 0 : if (value != NULL)
54664 : {
54665 0 : name += string("_") + value->get_constant_folded_value_as_string();
54666 : }
54667 : }
54668 0 : if (fixed_type->get_fraction() != NULL)
54669 : {
54670 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
54671 0 : if (value != NULL)
54672 : {
54673 0 : name += string("_") + value->get_constant_folded_value_as_string();
54674 : }
54675 : }
54676 : }
54677 :
54678 : #if 0
54679 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
54680 : #endif
54681 :
54682 200 : return name;
54683 : }
54684 : #endif
54685 :
54686 :
54687 : // End of memberFunctionString
54688 :
54689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
54690 :
54691 198 : SgTypeSignedInt* isSgTypeSignedInt ( SgNode* inputDerivedClassPointer )
54692 : {
54693 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
54694 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
54695 : // So to fix this we return NULL directly when the input is NULL and avoid the
54696 : // dynamic_cast in this case. This is likely a performance improvement as well.
54697 : // return dynamic_cast<SgTypeSignedInt*>(inputDerivedClassPointer);
54698 : // Milind Chabbi (8/28/2013): isSgTypeSignedInt uses table-driven castability instead of c++ default dynamic_cast
54699 : // this improves the running time performance by 10-20%.
54700 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeSignedInt*>(inputDerivedClassPointer);
54701 198 : return IS_SgTypeSignedInt_FAST_MACRO(inputDerivedClassPointer);
54702 : }
54703 :
54704 : // DQ (11/8/2003): Added version of functions taking const pointer
54705 0 : const SgTypeSignedInt* isSgTypeSignedInt ( const SgNode* inputDerivedClassPointer )
54706 : {
54707 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
54708 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
54709 : // So to fix this we return NULL directly when the input is NULL and avoid the
54710 : // dynamic_cast in this case. This is likely a performance improvement as well.
54711 : // return dynamic_cast<const SgTypeSignedInt*>(inputDerivedClassPointer);
54712 : // Milind Chabbi (8/28/2013): isSgTypeSignedInt uses table-driven castability instead of c++ default dynamic_cast
54713 : // this improves the running time performance by 10-20%.
54714 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeSignedInt*>(inputDerivedClassPointer);
54715 0 : return IS_SgTypeSignedInt_FAST_MACRO(inputDerivedClassPointer);
54716 : }
54717 :
54718 :
54719 :
54720 : /* #line 54721 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54721 :
54722 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
54723 :
54724 : /**
54725 : \brief Generated destructor
54726 :
54727 : This destructor is automatically generated (by ROSETTA). This destructor
54728 : only frees memory of data members associated with the parts of the current IR node which
54729 : are NOT traversed. Those data members that are part of a traversal can be freed using
54730 : a traversal (calling this destructor on all children in a post-order traversal). Such
54731 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
54732 :
54733 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
54734 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
54735 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
54736 :
54737 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
54738 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
54739 : pointers are not yet implemented to call delete on eash pointer in the container.
54740 : (This could be done by derivation from the STL containers to define containers that
54741 : automatically deleted their members.)
54742 :
54743 : */
54744 8 : SgTypeSignedInt::~SgTypeSignedInt () {
54745 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
54746 :
54747 :
54748 :
54749 : }
54750 :
54751 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
54752 8 : }
54753 :
54754 :
54755 : /* #line 54756 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54756 :
54757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
54758 :
54759 : // Generated constructor
54760 198 : SgTypeSignedInt::SgTypeSignedInt ( )
54761 198 : : SgType()
54762 : {
54763 : #ifdef DEBUG
54764 : // printf ("In SgTypeSignedInt::SgTypeSignedInt () sage_class_name() = %s \n",sage_class_name());
54765 : #endif
54766 : #if 0
54767 : // debugging information!
54768 : printf ("In SgTypeSignedInt::SgTypeSignedInt (): this = %p = %s \n",this,this->class_name().c_str());
54769 : #endif
54770 :
54771 :
54772 :
54773 : #if 0
54774 : // DQ (7/30/2014): Call a virtual function.
54775 : std::string s = this->class_name();
54776 : #endif
54777 :
54778 : // Test the variant virtual function
54779 : // assert(T_SIGNED_INT == variant());
54780 198 : assert(T_SIGNED_INT == this->variant());
54781 198 : ROSE_ASSERT(T_SIGNED_INT == (int)(this->variantT()));
54782 198 : post_construction_initialization();
54783 :
54784 : // Test the isSgTypeSignedInt() function since it has been problematic
54785 198 : assert(isSgTypeSignedInt(this) != NULL);
54786 198 : }
54787 :
54788 : // Generated constructor (all data members)
54789 :
54790 : /* #line 54791 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54791 :
54792 :
54793 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
54794 :
54795 :
54796 : // ********************************************************
54797 : // member functions common across all array grammar objects
54798 : // ********************************************************
54799 :
54800 :
54801 :
54802 : /* #line 54803 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54803 :
54804 :
54805 :
54806 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
54807 :
54808 : // ********************************************************
54809 : // member functions specific to each node in the grammar
54810 : // ********************************************************
54811 :
54812 :
54813 : /* #line 54814 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
54814 :
54815 : // Start of memberFunctionString
54816 :
54817 :
54818 : // End of memberFunctionString
54819 : // Start of memberFunctionString
54820 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
54821 :
54822 : // *** COMMON CODE SECTION BEGINS HERE ***
54823 :
54824 : #if 0
54825 : int
54826 : SgTypeUnsignedInt::getVariant() const
54827 : {
54828 : // This function is used in ROSE while "variant()" is used in SAGE
54829 : assert(this != NULL);
54830 : return variant();
54831 : }
54832 : #endif
54833 :
54834 : // This function is used in ROSE in treeTraversal code
54835 : // eventually replaces getVariant() and variant()
54836 : // though after variant() has been removed for a while we will
54837 : // want to change the name of variantT() back to variant()
54838 : // (since the "T" was ment to stand for temporary).
54839 : // When this happens the variantT() will be depricated.
54840 : VariantT
54841 184321000 : SgTypeUnsignedInt::variantT() const
54842 : {
54843 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
54844 184321000 : ROSE_ASSERT(this != NULL);
54845 184321000 : return V_SgTypeUnsignedInt;
54846 : }
54847 :
54848 : #if 0
54849 : int
54850 : SgTypeUnsignedInt::variant() const
54851 : {
54852 : // This function is used in SAGE
54853 : ROSE_ASSERT(this != NULL);
54854 : return T_UNSIGNED_INT;
54855 : }
54856 : #endif
54857 :
54858 : ROSE_DLL_API const char*
54859 0 : SgTypeUnsignedInt::sage_class_name() const
54860 : {
54861 0 : ROSE_ASSERT(this != NULL);
54862 0 : return "SgTypeUnsignedInt";
54863 : }
54864 :
54865 : std::string
54866 613 : SgTypeUnsignedInt::class_name() const
54867 : {
54868 613 : ROSE_ASSERT(this != NULL);
54869 613 : return "SgTypeUnsignedInt";
54870 : }
54871 :
54872 : // DQ (11/26/2005): Support for visitor pattern mechanims
54873 : // (inferior to ROSE traversal mechanism, experimental).
54874 : void
54875 194 : SgTypeUnsignedInt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
54876 : {
54877 194 : ROSE_ASSERT(this != NULL);
54878 194 : visitor.visit(this);
54879 194 : }
54880 :
54881 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
54882 0 : void SgTypeUnsignedInt::accept (ROSE_VisitorPattern & visitor) {
54883 0 : ROSE_ASSERT(this != NULL);
54884 0 : visitor.visit(this);
54885 0 : }
54886 :
54887 : SgTypeUnsignedInt*
54888 0 : SgTypeUnsignedInt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
54889 : {
54890 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
54891 : // This function is currently only supported for the AST used the represent Binary executables.
54892 : if (0 /* isSgAsmNode(this) != NULL */)
54893 : {
54894 : // Support for regex specification.
54895 : std::string prefixCode = "REGEX:";
54896 : addNewAttribute(prefixCode + s,a);
54897 : }
54898 : #endif
54899 :
54900 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
54901 0 : return this;
54902 : }
54903 :
54904 : // *** COMMON CODE SECTION ENDS HERE ***
54905 :
54906 :
54907 : // End of memberFunctionString
54908 : // Start of memberFunctionString
54909 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
54910 :
54911 :
54912 : #if 0
54913 : //! Error checking support
54914 : /*! Verifies the following:
54915 : - working getVariant() member function
54916 : - calls base class's error() member function
54917 : Every class has one of these functions.
54918 : */
54919 : bool
54920 : SgTypeUnsignedInt::error()
54921 : {
54922 : // Put error checking here
54923 :
54924 : ROSE_ASSERT (this != NULL);
54925 : if (getVariant() != T_UNSIGNED_INT)
54926 : {
54927 : printf ("Error in SgTypeUnsignedInt::error(): SgTypeUnsignedInt object has a %s variant \n",
54928 : Cxx_GrammarTerminalNames[getVariant()].name);
54929 : // printf ("Error in SgTypeUnsignedInt::error() \n");
54930 : ROSE_ABORT();
54931 : }
54932 :
54933 : ROSE_ASSERT (getVariant() == T_UNSIGNED_INT);
54934 : return SgType::error();
54935 : }
54936 : #endif
54937 :
54938 :
54939 :
54940 : // End of memberFunctionString
54941 : // Start of memberFunctionString
54942 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
54943 :
54944 :
54945 : // DQ (1/31/2006): Modified to build all types in the memory pools
54946 : // SgTypeUnsignedInt SgTypeUnsignedInt::builtin_type;
54947 : // SgTypeUnsignedInt* SgTypeUnsignedInt::builtin_type = new SgTypeUnsignedInt();
54948 : SgTypeUnsignedInt* SgTypeUnsignedInt::p_builtin_type = NULL;
54949 :
54950 :
54951 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
54952 : // SgTypeUnsignedInt* SgTypeUnsignedInt::createType(void)
54953 : SgTypeUnsignedInt*
54954 1784 : SgTypeUnsignedInt::createType(SgExpression* optional_fortran_type_kind)
54955 : {
54956 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
54957 : // is not called (likely because static initialization is compiler dependent).
54958 : // DQ (1/31/2006): Modified to build all types in the memory pools
54959 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
54960 : // return &builtin_type;
54961 :
54962 : #if 0
54963 : printf ("In SgTypeUnsignedInt::createType() (COMMON_CREATE_TYPE) \n");
54964 : #endif
54965 :
54966 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
54967 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
54968 :
54969 1784 : SgTypeUnsignedInt* temp_type = new SgTypeUnsignedInt();
54970 :
54971 : #if 0
54972 : printf ("In SgTypeUnsignedInt::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
54973 : #endif
54974 :
54975 : // DQ (10/31/2016): Added assertion.
54976 1784 : ROSE_ASSERT(temp_type != NULL);
54977 :
54978 1784 : if (optional_fortran_type_kind != NULL)
54979 : {
54980 : // DQ (10/31/2016): Added assertion.
54981 0 : ROSE_ASSERT(temp_type != NULL);
54982 :
54983 0 : temp_type->set_type_kind(optional_fortran_type_kind);
54984 : }
54985 : #if 0
54986 : else
54987 : {
54988 : // Let p_builtin_type refer to the unadorned type (no type kind).
54989 : p_builtin_type = temp_type;
54990 : }
54991 : #endif
54992 :
54993 1784 : SgName name = temp_type->get_mangled();
54994 :
54995 : #if 0
54996 : printf ("Mangled type name for SgTypeUnsignedInt = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
54997 : #endif
54998 :
54999 : // DQ (10/31/2016): Added assertion.
55000 1784 : ROSE_ASSERT(get_globalTypeTable() != NULL);
55001 :
55002 1784 : SgType* t = get_globalTypeTable()->lookup_type(name);
55003 :
55004 : #if 0
55005 : printf ("In SgTypeUnsignedInt::createType(): type from lookup_type = %p \n",t);
55006 : #endif
55007 :
55008 1784 : if (t == NULL)
55009 : {
55010 315 : get_globalTypeTable()->insert_type(name,temp_type);
55011 : }
55012 : else
55013 : {
55014 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
55015 1469 : if (t != temp_type)
55016 : {
55017 : #if 0
55018 : printf ("In SgTypeUnsignedInt::createType(): deleting temp_type = %p \n",temp_type);
55019 : #endif
55020 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
55021 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
55022 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
55023 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
55024 1469 : delete temp_type;
55025 : #endif
55026 1469 : temp_type = NULL;
55027 : #if 0
55028 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
55029 : if (optional_fortran_type_kind != NULL)
55030 : {
55031 : p_builtin_type = NULL;
55032 : }
55033 : #endif
55034 : }
55035 :
55036 : // Reuse this tempType variable so we can use the same code below.
55037 1469 : temp_type = isSgTypeUnsignedInt(t);
55038 1469 : ROSE_ASSERT(temp_type != NULL);
55039 : }
55040 :
55041 : #if 0
55042 : printf ("Leaving SgTypeUnsignedInt::createType(): temp_type = %p \n",temp_type);
55043 : #endif
55044 :
55045 1784 : return temp_type;
55046 : }
55047 :
55048 :
55049 :
55050 : // End of memberFunctionString
55051 : // Start of memberFunctionString
55052 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
55053 :
55054 : #if 1
55055 : /*! Support for mangled names (for unparser)
55056 : There are two different cases of source code for the get_mangled member function
55057 : This one is used in all but the classes containing a base type
55058 : */
55059 : // SgName SgTypeUnsignedInt::get_mangled ( SgUnparse_Info & info )
55060 : SgName
55061 686020 : SgTypeUnsignedInt::get_mangled (void) const
55062 : {
55063 686020 : ROSE_ASSERT(this != NULL);
55064 :
55065 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
55066 : // CR (3/6/2020): Now type_kind is also used for Jovial.
55067 686020 : SgName name = "Ui";
55068 686020 : if (get_type_kind() != NULL)
55069 : {
55070 : // name += get_type_kind()->get_mangled();
55071 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
55072 0 : SgValueExp* value = isSgValueExp(get_type_kind());
55073 0 : if (value != NULL)
55074 : {
55075 : // name += string("_") + StringUtility::numberToString(value->get_value());
55076 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
55077 : }
55078 : else
55079 : {
55080 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
55081 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
55082 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
55083 : // a different prefix for each type of named type. It come down to is there can be multiple
55084 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
55085 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
55086 : // I think the issue is that Ui is not defined for any of the SgNameType IR nodes.
55087 : #if 0
55088 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Ui");
55089 : #endif
55090 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
55091 : }
55092 : }
55093 :
55094 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
55095 : // REMOVE_ME please!
55096 686020 : if (isSgTypeFixed(this))
55097 : {
55098 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
55099 0 : if (fixed_type->get_scale() != NULL)
55100 : {
55101 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
55102 0 : if (value != NULL)
55103 : {
55104 0 : name += string("_") + value->get_constant_folded_value_as_string();
55105 : }
55106 : }
55107 0 : if (fixed_type->get_fraction() != NULL)
55108 : {
55109 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
55110 0 : if (value != NULL)
55111 : {
55112 0 : name += string("_") + value->get_constant_folded_value_as_string();
55113 : }
55114 : }
55115 : }
55116 :
55117 : #if 0
55118 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
55119 : #endif
55120 :
55121 686020 : return name;
55122 : }
55123 : #endif
55124 :
55125 :
55126 : // End of memberFunctionString
55127 :
55128 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
55129 :
55130 3253 : SgTypeUnsignedInt* isSgTypeUnsignedInt ( SgNode* inputDerivedClassPointer )
55131 : {
55132 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
55133 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
55134 : // So to fix this we return NULL directly when the input is NULL and avoid the
55135 : // dynamic_cast in this case. This is likely a performance improvement as well.
55136 : // return dynamic_cast<SgTypeUnsignedInt*>(inputDerivedClassPointer);
55137 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedInt uses table-driven castability instead of c++ default dynamic_cast
55138 : // this improves the running time performance by 10-20%.
55139 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnsignedInt*>(inputDerivedClassPointer);
55140 3253 : return IS_SgTypeUnsignedInt_FAST_MACRO(inputDerivedClassPointer);
55141 : }
55142 :
55143 : // DQ (11/8/2003): Added version of functions taking const pointer
55144 0 : const SgTypeUnsignedInt* isSgTypeUnsignedInt ( const SgNode* inputDerivedClassPointer )
55145 : {
55146 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
55147 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
55148 : // So to fix this we return NULL directly when the input is NULL and avoid the
55149 : // dynamic_cast in this case. This is likely a performance improvement as well.
55150 : // return dynamic_cast<const SgTypeUnsignedInt*>(inputDerivedClassPointer);
55151 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedInt uses table-driven castability instead of c++ default dynamic_cast
55152 : // this improves the running time performance by 10-20%.
55153 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnsignedInt*>(inputDerivedClassPointer);
55154 0 : return IS_SgTypeUnsignedInt_FAST_MACRO(inputDerivedClassPointer);
55155 : }
55156 :
55157 :
55158 :
55159 : /* #line 55160 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55160 :
55161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
55162 :
55163 : /**
55164 : \brief Generated destructor
55165 :
55166 : This destructor is automatically generated (by ROSETTA). This destructor
55167 : only frees memory of data members associated with the parts of the current IR node which
55168 : are NOT traversed. Those data members that are part of a traversal can be freed using
55169 : a traversal (calling this destructor on all children in a post-order traversal). Such
55170 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
55171 :
55172 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
55173 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
55174 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
55175 :
55176 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
55177 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
55178 : pointers are not yet implemented to call delete on eash pointer in the container.
55179 : (This could be done by derivation from the STL containers to define containers that
55180 : automatically deleted their members.)
55181 :
55182 : */
55183 2946 : SgTypeUnsignedInt::~SgTypeUnsignedInt () {
55184 1473 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
55185 :
55186 :
55187 :
55188 : }
55189 :
55190 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
55191 2946 : }
55192 :
55193 :
55194 : /* #line 55195 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55195 :
55196 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
55197 :
55198 : // Generated constructor
55199 1784 : SgTypeUnsignedInt::SgTypeUnsignedInt ( )
55200 1784 : : SgType()
55201 : {
55202 : #ifdef DEBUG
55203 : // printf ("In SgTypeUnsignedInt::SgTypeUnsignedInt () sage_class_name() = %s \n",sage_class_name());
55204 : #endif
55205 : #if 0
55206 : // debugging information!
55207 : printf ("In SgTypeUnsignedInt::SgTypeUnsignedInt (): this = %p = %s \n",this,this->class_name().c_str());
55208 : #endif
55209 :
55210 :
55211 :
55212 : #if 0
55213 : // DQ (7/30/2014): Call a virtual function.
55214 : std::string s = this->class_name();
55215 : #endif
55216 :
55217 : // Test the variant virtual function
55218 : // assert(T_UNSIGNED_INT == variant());
55219 1784 : assert(T_UNSIGNED_INT == this->variant());
55220 1784 : ROSE_ASSERT(T_UNSIGNED_INT == (int)(this->variantT()));
55221 1784 : post_construction_initialization();
55222 :
55223 : // Test the isSgTypeUnsignedInt() function since it has been problematic
55224 1784 : assert(isSgTypeUnsignedInt(this) != NULL);
55225 1784 : }
55226 :
55227 : // Generated constructor (all data members)
55228 :
55229 : /* #line 55230 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55230 :
55231 :
55232 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
55233 :
55234 :
55235 : // ********************************************************
55236 : // member functions common across all array grammar objects
55237 : // ********************************************************
55238 :
55239 :
55240 :
55241 : /* #line 55242 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55242 :
55243 :
55244 :
55245 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
55246 :
55247 : // ********************************************************
55248 : // member functions specific to each node in the grammar
55249 : // ********************************************************
55250 :
55251 :
55252 : /* #line 55253 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55253 :
55254 : // Start of memberFunctionString
55255 :
55256 :
55257 : // End of memberFunctionString
55258 : // Start of memberFunctionString
55259 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
55260 :
55261 : // *** COMMON CODE SECTION BEGINS HERE ***
55262 :
55263 : #if 0
55264 : int
55265 : SgTypeLong::getVariant() const
55266 : {
55267 : // This function is used in ROSE while "variant()" is used in SAGE
55268 : assert(this != NULL);
55269 : return variant();
55270 : }
55271 : #endif
55272 :
55273 : // This function is used in ROSE in treeTraversal code
55274 : // eventually replaces getVariant() and variant()
55275 : // though after variant() has been removed for a while we will
55276 : // want to change the name of variantT() back to variant()
55277 : // (since the "T" was ment to stand for temporary).
55278 : // When this happens the variantT() will be depricated.
55279 : VariantT
55280 11683400 : SgTypeLong::variantT() const
55281 : {
55282 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
55283 11683400 : ROSE_ASSERT(this != NULL);
55284 11683400 : return V_SgTypeLong;
55285 : }
55286 :
55287 : #if 0
55288 : int
55289 : SgTypeLong::variant() const
55290 : {
55291 : // This function is used in SAGE
55292 : ROSE_ASSERT(this != NULL);
55293 : return T_LONG;
55294 : }
55295 : #endif
55296 :
55297 : ROSE_DLL_API const char*
55298 0 : SgTypeLong::sage_class_name() const
55299 : {
55300 0 : ROSE_ASSERT(this != NULL);
55301 0 : return "SgTypeLong";
55302 : }
55303 :
55304 : std::string
55305 632 : SgTypeLong::class_name() const
55306 : {
55307 632 : ROSE_ASSERT(this != NULL);
55308 632 : return "SgTypeLong";
55309 : }
55310 :
55311 : // DQ (11/26/2005): Support for visitor pattern mechanims
55312 : // (inferior to ROSE traversal mechanism, experimental).
55313 : void
55314 194 : SgTypeLong::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
55315 : {
55316 194 : ROSE_ASSERT(this != NULL);
55317 194 : visitor.visit(this);
55318 194 : }
55319 :
55320 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
55321 0 : void SgTypeLong::accept (ROSE_VisitorPattern & visitor) {
55322 0 : ROSE_ASSERT(this != NULL);
55323 0 : visitor.visit(this);
55324 0 : }
55325 :
55326 : SgTypeLong*
55327 0 : SgTypeLong::addRegExpAttribute(std::string s, AstRegExAttribute* a)
55328 : {
55329 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
55330 : // This function is currently only supported for the AST used the represent Binary executables.
55331 : if (0 /* isSgAsmNode(this) != NULL */)
55332 : {
55333 : // Support for regex specification.
55334 : std::string prefixCode = "REGEX:";
55335 : addNewAttribute(prefixCode + s,a);
55336 : }
55337 : #endif
55338 :
55339 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
55340 0 : return this;
55341 : }
55342 :
55343 : // *** COMMON CODE SECTION ENDS HERE ***
55344 :
55345 :
55346 : // End of memberFunctionString
55347 : // Start of memberFunctionString
55348 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
55349 :
55350 :
55351 : #if 0
55352 : //! Error checking support
55353 : /*! Verifies the following:
55354 : - working getVariant() member function
55355 : - calls base class's error() member function
55356 : Every class has one of these functions.
55357 : */
55358 : bool
55359 : SgTypeLong::error()
55360 : {
55361 : // Put error checking here
55362 :
55363 : ROSE_ASSERT (this != NULL);
55364 : if (getVariant() != T_LONG)
55365 : {
55366 : printf ("Error in SgTypeLong::error(): SgTypeLong object has a %s variant \n",
55367 : Cxx_GrammarTerminalNames[getVariant()].name);
55368 : // printf ("Error in SgTypeLong::error() \n");
55369 : ROSE_ABORT();
55370 : }
55371 :
55372 : ROSE_ASSERT (getVariant() == T_LONG);
55373 : return SgType::error();
55374 : }
55375 : #endif
55376 :
55377 :
55378 :
55379 : // End of memberFunctionString
55380 : // Start of memberFunctionString
55381 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
55382 :
55383 :
55384 : // DQ (1/31/2006): Modified to build all types in the memory pools
55385 : // SgTypeLong SgTypeLong::builtin_type;
55386 : // SgTypeLong* SgTypeLong::builtin_type = new SgTypeLong();
55387 : SgTypeLong* SgTypeLong::p_builtin_type = NULL;
55388 :
55389 :
55390 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
55391 : // SgTypeLong* SgTypeLong::createType(void)
55392 : SgTypeLong*
55393 484 : SgTypeLong::createType(SgExpression* optional_fortran_type_kind)
55394 : {
55395 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
55396 : // is not called (likely because static initialization is compiler dependent).
55397 : // DQ (1/31/2006): Modified to build all types in the memory pools
55398 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
55399 : // return &builtin_type;
55400 :
55401 : #if 0
55402 : printf ("In SgTypeLong::createType() (COMMON_CREATE_TYPE) \n");
55403 : #endif
55404 :
55405 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
55406 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
55407 :
55408 484 : SgTypeLong* temp_type = new SgTypeLong();
55409 :
55410 : #if 0
55411 : printf ("In SgTypeLong::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
55412 : #endif
55413 :
55414 : // DQ (10/31/2016): Added assertion.
55415 484 : ROSE_ASSERT(temp_type != NULL);
55416 :
55417 484 : if (optional_fortran_type_kind != NULL)
55418 : {
55419 : // DQ (10/31/2016): Added assertion.
55420 0 : ROSE_ASSERT(temp_type != NULL);
55421 :
55422 0 : temp_type->set_type_kind(optional_fortran_type_kind);
55423 : }
55424 : #if 0
55425 : else
55426 : {
55427 : // Let p_builtin_type refer to the unadorned type (no type kind).
55428 : p_builtin_type = temp_type;
55429 : }
55430 : #endif
55431 :
55432 484 : SgName name = temp_type->get_mangled();
55433 :
55434 : #if 0
55435 : printf ("Mangled type name for SgTypeLong = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
55436 : #endif
55437 :
55438 : // DQ (10/31/2016): Added assertion.
55439 484 : ROSE_ASSERT(get_globalTypeTable() != NULL);
55440 :
55441 484 : SgType* t = get_globalTypeTable()->lookup_type(name);
55442 :
55443 : #if 0
55444 : printf ("In SgTypeLong::createType(): type from lookup_type = %p \n",t);
55445 : #endif
55446 :
55447 484 : if (t == NULL)
55448 : {
55449 315 : get_globalTypeTable()->insert_type(name,temp_type);
55450 : }
55451 : else
55452 : {
55453 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
55454 169 : if (t != temp_type)
55455 : {
55456 : #if 0
55457 : printf ("In SgTypeLong::createType(): deleting temp_type = %p \n",temp_type);
55458 : #endif
55459 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
55460 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
55461 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
55462 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
55463 169 : delete temp_type;
55464 : #endif
55465 169 : temp_type = NULL;
55466 : #if 0
55467 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
55468 : if (optional_fortran_type_kind != NULL)
55469 : {
55470 : p_builtin_type = NULL;
55471 : }
55472 : #endif
55473 : }
55474 :
55475 : // Reuse this tempType variable so we can use the same code below.
55476 169 : temp_type = isSgTypeLong(t);
55477 169 : ROSE_ASSERT(temp_type != NULL);
55478 : }
55479 :
55480 : #if 0
55481 : printf ("Leaving SgTypeLong::createType(): temp_type = %p \n",temp_type);
55482 : #endif
55483 :
55484 484 : return temp_type;
55485 : }
55486 :
55487 :
55488 :
55489 : // End of memberFunctionString
55490 : // Start of memberFunctionString
55491 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
55492 :
55493 : #if 1
55494 : /*! Support for mangled names (for unparser)
55495 : There are two different cases of source code for the get_mangled member function
55496 : This one is used in all but the classes containing a base type
55497 : */
55498 : // SgName SgTypeLong::get_mangled ( SgUnparse_Info & info )
55499 : SgName
55500 51071 : SgTypeLong::get_mangled (void) const
55501 : {
55502 51071 : ROSE_ASSERT(this != NULL);
55503 :
55504 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
55505 : // CR (3/6/2020): Now type_kind is also used for Jovial.
55506 51071 : SgName name = "l";
55507 51071 : if (get_type_kind() != NULL)
55508 : {
55509 : // name += get_type_kind()->get_mangled();
55510 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
55511 0 : SgValueExp* value = isSgValueExp(get_type_kind());
55512 0 : if (value != NULL)
55513 : {
55514 : // name += string("_") + StringUtility::numberToString(value->get_value());
55515 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
55516 : }
55517 : else
55518 : {
55519 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
55520 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
55521 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
55522 : // a different prefix for each type of named type. It come down to is there can be multiple
55523 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
55524 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
55525 : // I think the issue is that l is not defined for any of the SgNameType IR nodes.
55526 : #if 0
55527 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"l");
55528 : #endif
55529 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
55530 : }
55531 : }
55532 :
55533 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
55534 : // REMOVE_ME please!
55535 51071 : if (isSgTypeFixed(this))
55536 : {
55537 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
55538 0 : if (fixed_type->get_scale() != NULL)
55539 : {
55540 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
55541 0 : if (value != NULL)
55542 : {
55543 0 : name += string("_") + value->get_constant_folded_value_as_string();
55544 : }
55545 : }
55546 0 : if (fixed_type->get_fraction() != NULL)
55547 : {
55548 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
55549 0 : if (value != NULL)
55550 : {
55551 0 : name += string("_") + value->get_constant_folded_value_as_string();
55552 : }
55553 : }
55554 : }
55555 :
55556 : #if 0
55557 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
55558 : #endif
55559 :
55560 51071 : return name;
55561 : }
55562 : #endif
55563 :
55564 :
55565 : // End of memberFunctionString
55566 :
55567 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
55568 :
55569 653 : SgTypeLong* isSgTypeLong ( SgNode* inputDerivedClassPointer )
55570 : {
55571 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
55572 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
55573 : // So to fix this we return NULL directly when the input is NULL and avoid the
55574 : // dynamic_cast in this case. This is likely a performance improvement as well.
55575 : // return dynamic_cast<SgTypeLong*>(inputDerivedClassPointer);
55576 : // Milind Chabbi (8/28/2013): isSgTypeLong uses table-driven castability instead of c++ default dynamic_cast
55577 : // this improves the running time performance by 10-20%.
55578 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeLong*>(inputDerivedClassPointer);
55579 653 : return IS_SgTypeLong_FAST_MACRO(inputDerivedClassPointer);
55580 : }
55581 :
55582 : // DQ (11/8/2003): Added version of functions taking const pointer
55583 0 : const SgTypeLong* isSgTypeLong ( const SgNode* inputDerivedClassPointer )
55584 : {
55585 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
55586 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
55587 : // So to fix this we return NULL directly when the input is NULL and avoid the
55588 : // dynamic_cast in this case. This is likely a performance improvement as well.
55589 : // return dynamic_cast<const SgTypeLong*>(inputDerivedClassPointer);
55590 : // Milind Chabbi (8/28/2013): isSgTypeLong uses table-driven castability instead of c++ default dynamic_cast
55591 : // this improves the running time performance by 10-20%.
55592 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeLong*>(inputDerivedClassPointer);
55593 0 : return IS_SgTypeLong_FAST_MACRO(inputDerivedClassPointer);
55594 : }
55595 :
55596 :
55597 :
55598 : /* #line 55599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55599 :
55600 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
55601 :
55602 : /**
55603 : \brief Generated destructor
55604 :
55605 : This destructor is automatically generated (by ROSETTA). This destructor
55606 : only frees memory of data members associated with the parts of the current IR node which
55607 : are NOT traversed. Those data members that are part of a traversal can be freed using
55608 : a traversal (calling this destructor on all children in a post-order traversal). Such
55609 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
55610 :
55611 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
55612 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
55613 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
55614 :
55615 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
55616 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
55617 : pointers are not yet implemented to call delete on eash pointer in the container.
55618 : (This could be done by derivation from the STL containers to define containers that
55619 : automatically deleted their members.)
55620 :
55621 : */
55622 346 : SgTypeLong::~SgTypeLong () {
55623 173 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
55624 :
55625 :
55626 :
55627 : }
55628 :
55629 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
55630 346 : }
55631 :
55632 :
55633 : /* #line 55634 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55634 :
55635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
55636 :
55637 : // Generated constructor
55638 484 : SgTypeLong::SgTypeLong ( )
55639 484 : : SgType()
55640 : {
55641 : #ifdef DEBUG
55642 : // printf ("In SgTypeLong::SgTypeLong () sage_class_name() = %s \n",sage_class_name());
55643 : #endif
55644 : #if 0
55645 : // debugging information!
55646 : printf ("In SgTypeLong::SgTypeLong (): this = %p = %s \n",this,this->class_name().c_str());
55647 : #endif
55648 :
55649 :
55650 :
55651 : #if 0
55652 : // DQ (7/30/2014): Call a virtual function.
55653 : std::string s = this->class_name();
55654 : #endif
55655 :
55656 : // Test the variant virtual function
55657 : // assert(T_LONG == variant());
55658 484 : assert(T_LONG == this->variant());
55659 484 : ROSE_ASSERT(T_LONG == (int)(this->variantT()));
55660 484 : post_construction_initialization();
55661 :
55662 : // Test the isSgTypeLong() function since it has been problematic
55663 484 : assert(isSgTypeLong(this) != NULL);
55664 484 : }
55665 :
55666 : // Generated constructor (all data members)
55667 :
55668 : /* #line 55669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55669 :
55670 :
55671 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
55672 :
55673 :
55674 : // ********************************************************
55675 : // member functions common across all array grammar objects
55676 : // ********************************************************
55677 :
55678 :
55679 :
55680 : /* #line 55681 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55681 :
55682 :
55683 :
55684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
55685 :
55686 : // ********************************************************
55687 : // member functions specific to each node in the grammar
55688 : // ********************************************************
55689 :
55690 :
55691 : /* #line 55692 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
55692 :
55693 : // Start of memberFunctionString
55694 :
55695 :
55696 : // End of memberFunctionString
55697 : // Start of memberFunctionString
55698 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
55699 :
55700 : // *** COMMON CODE SECTION BEGINS HERE ***
55701 :
55702 : #if 0
55703 : int
55704 : SgTypeSignedLong::getVariant() const
55705 : {
55706 : // This function is used in ROSE while "variant()" is used in SAGE
55707 : assert(this != NULL);
55708 : return variant();
55709 : }
55710 : #endif
55711 :
55712 : // This function is used in ROSE in treeTraversal code
55713 : // eventually replaces getVariant() and variant()
55714 : // though after variant() has been removed for a while we will
55715 : // want to change the name of variantT() back to variant()
55716 : // (since the "T" was ment to stand for temporary).
55717 : // When this happens the variantT() will be depricated.
55718 : VariantT
55719 73590 : SgTypeSignedLong::variantT() const
55720 : {
55721 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
55722 73590 : ROSE_ASSERT(this != NULL);
55723 73590 : return V_SgTypeSignedLong;
55724 : }
55725 :
55726 : #if 0
55727 : int
55728 : SgTypeSignedLong::variant() const
55729 : {
55730 : // This function is used in SAGE
55731 : ROSE_ASSERT(this != NULL);
55732 : return T_SIGNED_LONG;
55733 : }
55734 : #endif
55735 :
55736 : ROSE_DLL_API const char*
55737 0 : SgTypeSignedLong::sage_class_name() const
55738 : {
55739 0 : ROSE_ASSERT(this != NULL);
55740 0 : return "SgTypeSignedLong";
55741 : }
55742 :
55743 : std::string
55744 194 : SgTypeSignedLong::class_name() const
55745 : {
55746 194 : ROSE_ASSERT(this != NULL);
55747 194 : return "SgTypeSignedLong";
55748 : }
55749 :
55750 : // DQ (11/26/2005): Support for visitor pattern mechanims
55751 : // (inferior to ROSE traversal mechanism, experimental).
55752 : void
55753 137 : SgTypeSignedLong::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
55754 : {
55755 137 : ROSE_ASSERT(this != NULL);
55756 137 : visitor.visit(this);
55757 137 : }
55758 :
55759 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
55760 0 : void SgTypeSignedLong::accept (ROSE_VisitorPattern & visitor) {
55761 0 : ROSE_ASSERT(this != NULL);
55762 0 : visitor.visit(this);
55763 0 : }
55764 :
55765 : SgTypeSignedLong*
55766 0 : SgTypeSignedLong::addRegExpAttribute(std::string s, AstRegExAttribute* a)
55767 : {
55768 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
55769 : // This function is currently only supported for the AST used the represent Binary executables.
55770 : if (0 /* isSgAsmNode(this) != NULL */)
55771 : {
55772 : // Support for regex specification.
55773 : std::string prefixCode = "REGEX:";
55774 : addNewAttribute(prefixCode + s,a);
55775 : }
55776 : #endif
55777 :
55778 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
55779 0 : return this;
55780 : }
55781 :
55782 : // *** COMMON CODE SECTION ENDS HERE ***
55783 :
55784 :
55785 : // End of memberFunctionString
55786 : // Start of memberFunctionString
55787 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
55788 :
55789 :
55790 : #if 0
55791 : //! Error checking support
55792 : /*! Verifies the following:
55793 : - working getVariant() member function
55794 : - calls base class's error() member function
55795 : Every class has one of these functions.
55796 : */
55797 : bool
55798 : SgTypeSignedLong::error()
55799 : {
55800 : // Put error checking here
55801 :
55802 : ROSE_ASSERT (this != NULL);
55803 : if (getVariant() != T_SIGNED_LONG)
55804 : {
55805 : printf ("Error in SgTypeSignedLong::error(): SgTypeSignedLong object has a %s variant \n",
55806 : Cxx_GrammarTerminalNames[getVariant()].name);
55807 : // printf ("Error in SgTypeSignedLong::error() \n");
55808 : ROSE_ABORT();
55809 : }
55810 :
55811 : ROSE_ASSERT (getVariant() == T_SIGNED_LONG);
55812 : return SgType::error();
55813 : }
55814 : #endif
55815 :
55816 :
55817 :
55818 : // End of memberFunctionString
55819 : // Start of memberFunctionString
55820 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
55821 :
55822 :
55823 : // DQ (1/31/2006): Modified to build all types in the memory pools
55824 : // SgTypeSignedLong SgTypeSignedLong::builtin_type;
55825 : // SgTypeSignedLong* SgTypeSignedLong::builtin_type = new SgTypeSignedLong();
55826 : SgTypeSignedLong* SgTypeSignedLong::p_builtin_type = NULL;
55827 :
55828 :
55829 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
55830 : // SgTypeSignedLong* SgTypeSignedLong::createType(void)
55831 : SgTypeSignedLong*
55832 198 : SgTypeSignedLong::createType(SgExpression* optional_fortran_type_kind)
55833 : {
55834 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
55835 : // is not called (likely because static initialization is compiler dependent).
55836 : // DQ (1/31/2006): Modified to build all types in the memory pools
55837 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
55838 : // return &builtin_type;
55839 :
55840 : #if 0
55841 : printf ("In SgTypeSignedLong::createType() (COMMON_CREATE_TYPE) \n");
55842 : #endif
55843 :
55844 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
55845 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
55846 :
55847 198 : SgTypeSignedLong* temp_type = new SgTypeSignedLong();
55848 :
55849 : #if 0
55850 : printf ("In SgTypeSignedLong::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
55851 : #endif
55852 :
55853 : // DQ (10/31/2016): Added assertion.
55854 198 : ROSE_ASSERT(temp_type != NULL);
55855 :
55856 198 : if (optional_fortran_type_kind != NULL)
55857 : {
55858 : // DQ (10/31/2016): Added assertion.
55859 0 : ROSE_ASSERT(temp_type != NULL);
55860 :
55861 0 : temp_type->set_type_kind(optional_fortran_type_kind);
55862 : }
55863 : #if 0
55864 : else
55865 : {
55866 : // Let p_builtin_type refer to the unadorned type (no type kind).
55867 : p_builtin_type = temp_type;
55868 : }
55869 : #endif
55870 :
55871 198 : SgName name = temp_type->get_mangled();
55872 :
55873 : #if 0
55874 : printf ("Mangled type name for SgTypeSignedLong = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
55875 : #endif
55876 :
55877 : // DQ (10/31/2016): Added assertion.
55878 198 : ROSE_ASSERT(get_globalTypeTable() != NULL);
55879 :
55880 198 : SgType* t = get_globalTypeTable()->lookup_type(name);
55881 :
55882 : #if 0
55883 : printf ("In SgTypeSignedLong::createType(): type from lookup_type = %p \n",t);
55884 : #endif
55885 :
55886 198 : if (t == NULL)
55887 : {
55888 198 : get_globalTypeTable()->insert_type(name,temp_type);
55889 : }
55890 : else
55891 : {
55892 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
55893 0 : if (t != temp_type)
55894 : {
55895 : #if 0
55896 : printf ("In SgTypeSignedLong::createType(): deleting temp_type = %p \n",temp_type);
55897 : #endif
55898 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
55899 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
55900 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
55901 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
55902 0 : delete temp_type;
55903 : #endif
55904 0 : temp_type = NULL;
55905 : #if 0
55906 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
55907 : if (optional_fortran_type_kind != NULL)
55908 : {
55909 : p_builtin_type = NULL;
55910 : }
55911 : #endif
55912 : }
55913 :
55914 : // Reuse this tempType variable so we can use the same code below.
55915 0 : temp_type = isSgTypeSignedLong(t);
55916 0 : ROSE_ASSERT(temp_type != NULL);
55917 : }
55918 :
55919 : #if 0
55920 : printf ("Leaving SgTypeSignedLong::createType(): temp_type = %p \n",temp_type);
55921 : #endif
55922 :
55923 198 : return temp_type;
55924 : }
55925 :
55926 :
55927 :
55928 : // End of memberFunctionString
55929 : // Start of memberFunctionString
55930 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
55931 :
55932 : #if 1
55933 : /*! Support for mangled names (for unparser)
55934 : There are two different cases of source code for the get_mangled member function
55935 : This one is used in all but the classes containing a base type
55936 : */
55937 : // SgName SgTypeSignedLong::get_mangled ( SgUnparse_Info & info )
55938 : SgName
55939 200 : SgTypeSignedLong::get_mangled (void) const
55940 : {
55941 200 : ROSE_ASSERT(this != NULL);
55942 :
55943 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
55944 : // CR (3/6/2020): Now type_kind is also used for Jovial.
55945 200 : SgName name = "Sl";
55946 200 : if (get_type_kind() != NULL)
55947 : {
55948 : // name += get_type_kind()->get_mangled();
55949 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
55950 0 : SgValueExp* value = isSgValueExp(get_type_kind());
55951 0 : if (value != NULL)
55952 : {
55953 : // name += string("_") + StringUtility::numberToString(value->get_value());
55954 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
55955 : }
55956 : else
55957 : {
55958 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
55959 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
55960 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
55961 : // a different prefix for each type of named type. It come down to is there can be multiple
55962 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
55963 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
55964 : // I think the issue is that Sl is not defined for any of the SgNameType IR nodes.
55965 : #if 0
55966 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Sl");
55967 : #endif
55968 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
55969 : }
55970 : }
55971 :
55972 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
55973 : // REMOVE_ME please!
55974 200 : if (isSgTypeFixed(this))
55975 : {
55976 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
55977 0 : if (fixed_type->get_scale() != NULL)
55978 : {
55979 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
55980 0 : if (value != NULL)
55981 : {
55982 0 : name += string("_") + value->get_constant_folded_value_as_string();
55983 : }
55984 : }
55985 0 : if (fixed_type->get_fraction() != NULL)
55986 : {
55987 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
55988 0 : if (value != NULL)
55989 : {
55990 0 : name += string("_") + value->get_constant_folded_value_as_string();
55991 : }
55992 : }
55993 : }
55994 :
55995 : #if 0
55996 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
55997 : #endif
55998 :
55999 200 : return name;
56000 : }
56001 : #endif
56002 :
56003 :
56004 : // End of memberFunctionString
56005 :
56006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
56007 :
56008 198 : SgTypeSignedLong* isSgTypeSignedLong ( SgNode* inputDerivedClassPointer )
56009 : {
56010 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
56011 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
56012 : // So to fix this we return NULL directly when the input is NULL and avoid the
56013 : // dynamic_cast in this case. This is likely a performance improvement as well.
56014 : // return dynamic_cast<SgTypeSignedLong*>(inputDerivedClassPointer);
56015 : // Milind Chabbi (8/28/2013): isSgTypeSignedLong uses table-driven castability instead of c++ default dynamic_cast
56016 : // this improves the running time performance by 10-20%.
56017 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeSignedLong*>(inputDerivedClassPointer);
56018 198 : return IS_SgTypeSignedLong_FAST_MACRO(inputDerivedClassPointer);
56019 : }
56020 :
56021 : // DQ (11/8/2003): Added version of functions taking const pointer
56022 0 : const SgTypeSignedLong* isSgTypeSignedLong ( const SgNode* inputDerivedClassPointer )
56023 : {
56024 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
56025 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
56026 : // So to fix this we return NULL directly when the input is NULL and avoid the
56027 : // dynamic_cast in this case. This is likely a performance improvement as well.
56028 : // return dynamic_cast<const SgTypeSignedLong*>(inputDerivedClassPointer);
56029 : // Milind Chabbi (8/28/2013): isSgTypeSignedLong uses table-driven castability instead of c++ default dynamic_cast
56030 : // this improves the running time performance by 10-20%.
56031 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeSignedLong*>(inputDerivedClassPointer);
56032 0 : return IS_SgTypeSignedLong_FAST_MACRO(inputDerivedClassPointer);
56033 : }
56034 :
56035 :
56036 :
56037 : /* #line 56038 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56038 :
56039 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
56040 :
56041 : /**
56042 : \brief Generated destructor
56043 :
56044 : This destructor is automatically generated (by ROSETTA). This destructor
56045 : only frees memory of data members associated with the parts of the current IR node which
56046 : are NOT traversed. Those data members that are part of a traversal can be freed using
56047 : a traversal (calling this destructor on all children in a post-order traversal). Such
56048 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
56049 :
56050 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
56051 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
56052 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
56053 :
56054 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
56055 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
56056 : pointers are not yet implemented to call delete on eash pointer in the container.
56057 : (This could be done by derivation from the STL containers to define containers that
56058 : automatically deleted their members.)
56059 :
56060 : */
56061 8 : SgTypeSignedLong::~SgTypeSignedLong () {
56062 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
56063 :
56064 :
56065 :
56066 : }
56067 :
56068 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
56069 8 : }
56070 :
56071 :
56072 : /* #line 56073 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56073 :
56074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
56075 :
56076 : // Generated constructor
56077 198 : SgTypeSignedLong::SgTypeSignedLong ( )
56078 198 : : SgType()
56079 : {
56080 : #ifdef DEBUG
56081 : // printf ("In SgTypeSignedLong::SgTypeSignedLong () sage_class_name() = %s \n",sage_class_name());
56082 : #endif
56083 : #if 0
56084 : // debugging information!
56085 : printf ("In SgTypeSignedLong::SgTypeSignedLong (): this = %p = %s \n",this,this->class_name().c_str());
56086 : #endif
56087 :
56088 :
56089 :
56090 : #if 0
56091 : // DQ (7/30/2014): Call a virtual function.
56092 : std::string s = this->class_name();
56093 : #endif
56094 :
56095 : // Test the variant virtual function
56096 : // assert(T_SIGNED_LONG == variant());
56097 198 : assert(T_SIGNED_LONG == this->variant());
56098 198 : ROSE_ASSERT(T_SIGNED_LONG == (int)(this->variantT()));
56099 198 : post_construction_initialization();
56100 :
56101 : // Test the isSgTypeSignedLong() function since it has been problematic
56102 198 : assert(isSgTypeSignedLong(this) != NULL);
56103 198 : }
56104 :
56105 : // Generated constructor (all data members)
56106 :
56107 : /* #line 56108 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56108 :
56109 :
56110 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
56111 :
56112 :
56113 : // ********************************************************
56114 : // member functions common across all array grammar objects
56115 : // ********************************************************
56116 :
56117 :
56118 :
56119 : /* #line 56120 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56120 :
56121 :
56122 :
56123 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
56124 :
56125 : // ********************************************************
56126 : // member functions specific to each node in the grammar
56127 : // ********************************************************
56128 :
56129 :
56130 : /* #line 56131 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56131 :
56132 : // Start of memberFunctionString
56133 :
56134 :
56135 : // End of memberFunctionString
56136 : // Start of memberFunctionString
56137 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
56138 :
56139 : // *** COMMON CODE SECTION BEGINS HERE ***
56140 :
56141 : #if 0
56142 : int
56143 : SgTypeUnsignedLong::getVariant() const
56144 : {
56145 : // This function is used in ROSE while "variant()" is used in SAGE
56146 : assert(this != NULL);
56147 : return variant();
56148 : }
56149 : #endif
56150 :
56151 : // This function is used in ROSE in treeTraversal code
56152 : // eventually replaces getVariant() and variant()
56153 : // though after variant() has been removed for a while we will
56154 : // want to change the name of variantT() back to variant()
56155 : // (since the "T" was ment to stand for temporary).
56156 : // When this happens the variantT() will be depricated.
56157 : VariantT
56158 58835400 : SgTypeUnsignedLong::variantT() const
56159 : {
56160 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
56161 58835400 : ROSE_ASSERT(this != NULL);
56162 58835400 : return V_SgTypeUnsignedLong;
56163 : }
56164 :
56165 : #if 0
56166 : int
56167 : SgTypeUnsignedLong::variant() const
56168 : {
56169 : // This function is used in SAGE
56170 : ROSE_ASSERT(this != NULL);
56171 : return T_UNSIGNED_LONG;
56172 : }
56173 : #endif
56174 :
56175 : ROSE_DLL_API const char*
56176 0 : SgTypeUnsignedLong::sage_class_name() const
56177 : {
56178 0 : ROSE_ASSERT(this != NULL);
56179 0 : return "SgTypeUnsignedLong";
56180 : }
56181 :
56182 : std::string
56183 871 : SgTypeUnsignedLong::class_name() const
56184 : {
56185 871 : ROSE_ASSERT(this != NULL);
56186 871 : return "SgTypeUnsignedLong";
56187 : }
56188 :
56189 : // DQ (11/26/2005): Support for visitor pattern mechanims
56190 : // (inferior to ROSE traversal mechanism, experimental).
56191 : void
56192 194 : SgTypeUnsignedLong::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
56193 : {
56194 194 : ROSE_ASSERT(this != NULL);
56195 194 : visitor.visit(this);
56196 194 : }
56197 :
56198 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
56199 0 : void SgTypeUnsignedLong::accept (ROSE_VisitorPattern & visitor) {
56200 0 : ROSE_ASSERT(this != NULL);
56201 0 : visitor.visit(this);
56202 0 : }
56203 :
56204 : SgTypeUnsignedLong*
56205 0 : SgTypeUnsignedLong::addRegExpAttribute(std::string s, AstRegExAttribute* a)
56206 : {
56207 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
56208 : // This function is currently only supported for the AST used the represent Binary executables.
56209 : if (0 /* isSgAsmNode(this) != NULL */)
56210 : {
56211 : // Support for regex specification.
56212 : std::string prefixCode = "REGEX:";
56213 : addNewAttribute(prefixCode + s,a);
56214 : }
56215 : #endif
56216 :
56217 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
56218 0 : return this;
56219 : }
56220 :
56221 : // *** COMMON CODE SECTION ENDS HERE ***
56222 :
56223 :
56224 : // End of memberFunctionString
56225 : // Start of memberFunctionString
56226 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
56227 :
56228 :
56229 : #if 0
56230 : //! Error checking support
56231 : /*! Verifies the following:
56232 : - working getVariant() member function
56233 : - calls base class's error() member function
56234 : Every class has one of these functions.
56235 : */
56236 : bool
56237 : SgTypeUnsignedLong::error()
56238 : {
56239 : // Put error checking here
56240 :
56241 : ROSE_ASSERT (this != NULL);
56242 : if (getVariant() != T_UNSIGNED_LONG)
56243 : {
56244 : printf ("Error in SgTypeUnsignedLong::error(): SgTypeUnsignedLong object has a %s variant \n",
56245 : Cxx_GrammarTerminalNames[getVariant()].name);
56246 : // printf ("Error in SgTypeUnsignedLong::error() \n");
56247 : ROSE_ABORT();
56248 : }
56249 :
56250 : ROSE_ASSERT (getVariant() == T_UNSIGNED_LONG);
56251 : return SgType::error();
56252 : }
56253 : #endif
56254 :
56255 :
56256 :
56257 : // End of memberFunctionString
56258 : // Start of memberFunctionString
56259 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
56260 :
56261 :
56262 : // DQ (1/31/2006): Modified to build all types in the memory pools
56263 : // SgTypeUnsignedLong SgTypeUnsignedLong::builtin_type;
56264 : // SgTypeUnsignedLong* SgTypeUnsignedLong::builtin_type = new SgTypeUnsignedLong();
56265 : SgTypeUnsignedLong* SgTypeUnsignedLong::p_builtin_type = NULL;
56266 :
56267 :
56268 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
56269 : // SgTypeUnsignedLong* SgTypeUnsignedLong::createType(void)
56270 : SgTypeUnsignedLong*
56271 1095 : SgTypeUnsignedLong::createType(SgExpression* optional_fortran_type_kind)
56272 : {
56273 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
56274 : // is not called (likely because static initialization is compiler dependent).
56275 : // DQ (1/31/2006): Modified to build all types in the memory pools
56276 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
56277 : // return &builtin_type;
56278 :
56279 : #if 0
56280 : printf ("In SgTypeUnsignedLong::createType() (COMMON_CREATE_TYPE) \n");
56281 : #endif
56282 :
56283 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
56284 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
56285 :
56286 1095 : SgTypeUnsignedLong* temp_type = new SgTypeUnsignedLong();
56287 :
56288 : #if 0
56289 : printf ("In SgTypeUnsignedLong::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
56290 : #endif
56291 :
56292 : // DQ (10/31/2016): Added assertion.
56293 1095 : ROSE_ASSERT(temp_type != NULL);
56294 :
56295 1095 : if (optional_fortran_type_kind != NULL)
56296 : {
56297 : // DQ (10/31/2016): Added assertion.
56298 0 : ROSE_ASSERT(temp_type != NULL);
56299 :
56300 0 : temp_type->set_type_kind(optional_fortran_type_kind);
56301 : }
56302 : #if 0
56303 : else
56304 : {
56305 : // Let p_builtin_type refer to the unadorned type (no type kind).
56306 : p_builtin_type = temp_type;
56307 : }
56308 : #endif
56309 :
56310 1095 : SgName name = temp_type->get_mangled();
56311 :
56312 : #if 0
56313 : printf ("Mangled type name for SgTypeUnsignedLong = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
56314 : #endif
56315 :
56316 : // DQ (10/31/2016): Added assertion.
56317 1095 : ROSE_ASSERT(get_globalTypeTable() != NULL);
56318 :
56319 1095 : SgType* t = get_globalTypeTable()->lookup_type(name);
56320 :
56321 : #if 0
56322 : printf ("In SgTypeUnsignedLong::createType(): type from lookup_type = %p \n",t);
56323 : #endif
56324 :
56325 1095 : if (t == NULL)
56326 : {
56327 315 : get_globalTypeTable()->insert_type(name,temp_type);
56328 : }
56329 : else
56330 : {
56331 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
56332 780 : if (t != temp_type)
56333 : {
56334 : #if 0
56335 : printf ("In SgTypeUnsignedLong::createType(): deleting temp_type = %p \n",temp_type);
56336 : #endif
56337 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
56338 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
56339 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
56340 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
56341 780 : delete temp_type;
56342 : #endif
56343 780 : temp_type = NULL;
56344 : #if 0
56345 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
56346 : if (optional_fortran_type_kind != NULL)
56347 : {
56348 : p_builtin_type = NULL;
56349 : }
56350 : #endif
56351 : }
56352 :
56353 : // Reuse this tempType variable so we can use the same code below.
56354 780 : temp_type = isSgTypeUnsignedLong(t);
56355 780 : ROSE_ASSERT(temp_type != NULL);
56356 : }
56357 :
56358 : #if 0
56359 : printf ("Leaving SgTypeUnsignedLong::createType(): temp_type = %p \n",temp_type);
56360 : #endif
56361 :
56362 1095 : return temp_type;
56363 : }
56364 :
56365 :
56366 :
56367 : // End of memberFunctionString
56368 : // Start of memberFunctionString
56369 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
56370 :
56371 : #if 1
56372 : /*! Support for mangled names (for unparser)
56373 : There are two different cases of source code for the get_mangled member function
56374 : This one is used in all but the classes containing a base type
56375 : */
56376 : // SgName SgTypeUnsignedLong::get_mangled ( SgUnparse_Info & info )
56377 : SgName
56378 122074 : SgTypeUnsignedLong::get_mangled (void) const
56379 : {
56380 122074 : ROSE_ASSERT(this != NULL);
56381 :
56382 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
56383 : // CR (3/6/2020): Now type_kind is also used for Jovial.
56384 122074 : SgName name = "Ul";
56385 122074 : if (get_type_kind() != NULL)
56386 : {
56387 : // name += get_type_kind()->get_mangled();
56388 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
56389 0 : SgValueExp* value = isSgValueExp(get_type_kind());
56390 0 : if (value != NULL)
56391 : {
56392 : // name += string("_") + StringUtility::numberToString(value->get_value());
56393 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
56394 : }
56395 : else
56396 : {
56397 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
56398 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
56399 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
56400 : // a different prefix for each type of named type. It come down to is there can be multiple
56401 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
56402 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
56403 : // I think the issue is that Ul is not defined for any of the SgNameType IR nodes.
56404 : #if 0
56405 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Ul");
56406 : #endif
56407 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
56408 : }
56409 : }
56410 :
56411 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
56412 : // REMOVE_ME please!
56413 122074 : if (isSgTypeFixed(this))
56414 : {
56415 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
56416 0 : if (fixed_type->get_scale() != NULL)
56417 : {
56418 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
56419 0 : if (value != NULL)
56420 : {
56421 0 : name += string("_") + value->get_constant_folded_value_as_string();
56422 : }
56423 : }
56424 0 : if (fixed_type->get_fraction() != NULL)
56425 : {
56426 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
56427 0 : if (value != NULL)
56428 : {
56429 0 : name += string("_") + value->get_constant_folded_value_as_string();
56430 : }
56431 : }
56432 : }
56433 :
56434 : #if 0
56435 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
56436 : #endif
56437 :
56438 122074 : return name;
56439 : }
56440 : #endif
56441 :
56442 :
56443 : // End of memberFunctionString
56444 :
56445 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
56446 :
56447 1875 : SgTypeUnsignedLong* isSgTypeUnsignedLong ( SgNode* inputDerivedClassPointer )
56448 : {
56449 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
56450 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
56451 : // So to fix this we return NULL directly when the input is NULL and avoid the
56452 : // dynamic_cast in this case. This is likely a performance improvement as well.
56453 : // return dynamic_cast<SgTypeUnsignedLong*>(inputDerivedClassPointer);
56454 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedLong uses table-driven castability instead of c++ default dynamic_cast
56455 : // this improves the running time performance by 10-20%.
56456 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnsignedLong*>(inputDerivedClassPointer);
56457 1875 : return IS_SgTypeUnsignedLong_FAST_MACRO(inputDerivedClassPointer);
56458 : }
56459 :
56460 : // DQ (11/8/2003): Added version of functions taking const pointer
56461 0 : const SgTypeUnsignedLong* isSgTypeUnsignedLong ( const SgNode* inputDerivedClassPointer )
56462 : {
56463 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
56464 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
56465 : // So to fix this we return NULL directly when the input is NULL and avoid the
56466 : // dynamic_cast in this case. This is likely a performance improvement as well.
56467 : // return dynamic_cast<const SgTypeUnsignedLong*>(inputDerivedClassPointer);
56468 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedLong uses table-driven castability instead of c++ default dynamic_cast
56469 : // this improves the running time performance by 10-20%.
56470 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnsignedLong*>(inputDerivedClassPointer);
56471 0 : return IS_SgTypeUnsignedLong_FAST_MACRO(inputDerivedClassPointer);
56472 : }
56473 :
56474 :
56475 :
56476 : /* #line 56477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56477 :
56478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
56479 :
56480 : /**
56481 : \brief Generated destructor
56482 :
56483 : This destructor is automatically generated (by ROSETTA). This destructor
56484 : only frees memory of data members associated with the parts of the current IR node which
56485 : are NOT traversed. Those data members that are part of a traversal can be freed using
56486 : a traversal (calling this destructor on all children in a post-order traversal). Such
56487 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
56488 :
56489 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
56490 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
56491 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
56492 :
56493 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
56494 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
56495 : pointers are not yet implemented to call delete on eash pointer in the container.
56496 : (This could be done by derivation from the STL containers to define containers that
56497 : automatically deleted their members.)
56498 :
56499 : */
56500 1568 : SgTypeUnsignedLong::~SgTypeUnsignedLong () {
56501 784 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
56502 :
56503 :
56504 :
56505 : }
56506 :
56507 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
56508 1568 : }
56509 :
56510 :
56511 : /* #line 56512 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56512 :
56513 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
56514 :
56515 : // Generated constructor
56516 1095 : SgTypeUnsignedLong::SgTypeUnsignedLong ( )
56517 1095 : : SgType()
56518 : {
56519 : #ifdef DEBUG
56520 : // printf ("In SgTypeUnsignedLong::SgTypeUnsignedLong () sage_class_name() = %s \n",sage_class_name());
56521 : #endif
56522 : #if 0
56523 : // debugging information!
56524 : printf ("In SgTypeUnsignedLong::SgTypeUnsignedLong (): this = %p = %s \n",this,this->class_name().c_str());
56525 : #endif
56526 :
56527 :
56528 :
56529 : #if 0
56530 : // DQ (7/30/2014): Call a virtual function.
56531 : std::string s = this->class_name();
56532 : #endif
56533 :
56534 : // Test the variant virtual function
56535 : // assert(T_UNSIGNED_LONG == variant());
56536 1095 : assert(T_UNSIGNED_LONG == this->variant());
56537 1095 : ROSE_ASSERT(T_UNSIGNED_LONG == (int)(this->variantT()));
56538 1095 : post_construction_initialization();
56539 :
56540 : // Test the isSgTypeUnsignedLong() function since it has been problematic
56541 1095 : assert(isSgTypeUnsignedLong(this) != NULL);
56542 1095 : }
56543 :
56544 : // Generated constructor (all data members)
56545 :
56546 : /* #line 56547 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56547 :
56548 :
56549 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
56550 :
56551 :
56552 : // ********************************************************
56553 : // member functions common across all array grammar objects
56554 : // ********************************************************
56555 :
56556 :
56557 :
56558 : /* #line 56559 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56559 :
56560 :
56561 :
56562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
56563 :
56564 : // ********************************************************
56565 : // member functions specific to each node in the grammar
56566 : // ********************************************************
56567 :
56568 :
56569 : /* #line 56570 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56570 :
56571 : // Start of memberFunctionString
56572 :
56573 :
56574 : // End of memberFunctionString
56575 : // Start of memberFunctionString
56576 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
56577 :
56578 : // *** COMMON CODE SECTION BEGINS HERE ***
56579 :
56580 : #if 0
56581 : int
56582 : SgTypeVoid::getVariant() const
56583 : {
56584 : // This function is used in ROSE while "variant()" is used in SAGE
56585 : assert(this != NULL);
56586 : return variant();
56587 : }
56588 : #endif
56589 :
56590 : // This function is used in ROSE in treeTraversal code
56591 : // eventually replaces getVariant() and variant()
56592 : // though after variant() has been removed for a while we will
56593 : // want to change the name of variantT() back to variant()
56594 : // (since the "T" was ment to stand for temporary).
56595 : // When this happens the variantT() will be depricated.
56596 : VariantT
56597 43779800 : SgTypeVoid::variantT() const
56598 : {
56599 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
56600 43779800 : ROSE_ASSERT(this != NULL);
56601 43779800 : return V_SgTypeVoid;
56602 : }
56603 :
56604 : #if 0
56605 : int
56606 : SgTypeVoid::variant() const
56607 : {
56608 : // This function is used in SAGE
56609 : ROSE_ASSERT(this != NULL);
56610 : return T_VOID;
56611 : }
56612 : #endif
56613 :
56614 : ROSE_DLL_API const char*
56615 0 : SgTypeVoid::sage_class_name() const
56616 : {
56617 0 : ROSE_ASSERT(this != NULL);
56618 0 : return "SgTypeVoid";
56619 : }
56620 :
56621 : std::string
56622 1400 : SgTypeVoid::class_name() const
56623 : {
56624 1400 : ROSE_ASSERT(this != NULL);
56625 1400 : return "SgTypeVoid";
56626 : }
56627 :
56628 : // DQ (11/26/2005): Support for visitor pattern mechanims
56629 : // (inferior to ROSE traversal mechanism, experimental).
56630 : void
56631 194 : SgTypeVoid::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
56632 : {
56633 194 : ROSE_ASSERT(this != NULL);
56634 194 : visitor.visit(this);
56635 194 : }
56636 :
56637 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
56638 0 : void SgTypeVoid::accept (ROSE_VisitorPattern & visitor) {
56639 0 : ROSE_ASSERT(this != NULL);
56640 0 : visitor.visit(this);
56641 0 : }
56642 :
56643 : SgTypeVoid*
56644 0 : SgTypeVoid::addRegExpAttribute(std::string s, AstRegExAttribute* a)
56645 : {
56646 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
56647 : // This function is currently only supported for the AST used the represent Binary executables.
56648 : if (0 /* isSgAsmNode(this) != NULL */)
56649 : {
56650 : // Support for regex specification.
56651 : std::string prefixCode = "REGEX:";
56652 : addNewAttribute(prefixCode + s,a);
56653 : }
56654 : #endif
56655 :
56656 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
56657 0 : return this;
56658 : }
56659 :
56660 : // *** COMMON CODE SECTION ENDS HERE ***
56661 :
56662 :
56663 : // End of memberFunctionString
56664 : // Start of memberFunctionString
56665 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
56666 :
56667 :
56668 : #if 0
56669 : //! Error checking support
56670 : /*! Verifies the following:
56671 : - working getVariant() member function
56672 : - calls base class's error() member function
56673 : Every class has one of these functions.
56674 : */
56675 : bool
56676 : SgTypeVoid::error()
56677 : {
56678 : // Put error checking here
56679 :
56680 : ROSE_ASSERT (this != NULL);
56681 : if (getVariant() != T_VOID)
56682 : {
56683 : printf ("Error in SgTypeVoid::error(): SgTypeVoid object has a %s variant \n",
56684 : Cxx_GrammarTerminalNames[getVariant()].name);
56685 : // printf ("Error in SgTypeVoid::error() \n");
56686 : ROSE_ABORT();
56687 : }
56688 :
56689 : ROSE_ASSERT (getVariant() == T_VOID);
56690 : return SgType::error();
56691 : }
56692 : #endif
56693 :
56694 :
56695 :
56696 : // End of memberFunctionString
56697 : // Start of memberFunctionString
56698 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
56699 :
56700 :
56701 : // DQ (1/31/2006): Modified to build all types in the memory pools
56702 : // SgTypeVoid SgTypeVoid::builtin_type;
56703 : // SgTypeVoid* SgTypeVoid::builtin_type = new SgTypeVoid();
56704 : SgTypeVoid* SgTypeVoid::p_builtin_type = NULL;
56705 :
56706 :
56707 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
56708 : // SgTypeVoid* SgTypeVoid::createType(void)
56709 : SgTypeVoid*
56710 938 : SgTypeVoid::createType(SgExpression* optional_fortran_type_kind)
56711 : {
56712 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
56713 : // is not called (likely because static initialization is compiler dependent).
56714 : // DQ (1/31/2006): Modified to build all types in the memory pools
56715 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
56716 : // return &builtin_type;
56717 :
56718 : #if 0
56719 : printf ("In SgTypeVoid::createType() (COMMON_CREATE_TYPE) \n");
56720 : #endif
56721 :
56722 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
56723 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
56724 :
56725 938 : SgTypeVoid* temp_type = new SgTypeVoid();
56726 :
56727 : #if 0
56728 : printf ("In SgTypeVoid::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
56729 : #endif
56730 :
56731 : // DQ (10/31/2016): Added assertion.
56732 938 : ROSE_ASSERT(temp_type != NULL);
56733 :
56734 938 : if (optional_fortran_type_kind != NULL)
56735 : {
56736 : // DQ (10/31/2016): Added assertion.
56737 0 : ROSE_ASSERT(temp_type != NULL);
56738 :
56739 0 : temp_type->set_type_kind(optional_fortran_type_kind);
56740 : }
56741 : #if 0
56742 : else
56743 : {
56744 : // Let p_builtin_type refer to the unadorned type (no type kind).
56745 : p_builtin_type = temp_type;
56746 : }
56747 : #endif
56748 :
56749 938 : SgName name = temp_type->get_mangled();
56750 :
56751 : #if 0
56752 : printf ("Mangled type name for SgTypeVoid = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
56753 : #endif
56754 :
56755 : // DQ (10/31/2016): Added assertion.
56756 938 : ROSE_ASSERT(get_globalTypeTable() != NULL);
56757 :
56758 938 : SgType* t = get_globalTypeTable()->lookup_type(name);
56759 :
56760 : #if 0
56761 : printf ("In SgTypeVoid::createType(): type from lookup_type = %p \n",t);
56762 : #endif
56763 :
56764 938 : if (t == NULL)
56765 : {
56766 351 : get_globalTypeTable()->insert_type(name,temp_type);
56767 : }
56768 : else
56769 : {
56770 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
56771 587 : if (t != temp_type)
56772 : {
56773 : #if 0
56774 : printf ("In SgTypeVoid::createType(): deleting temp_type = %p \n",temp_type);
56775 : #endif
56776 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
56777 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
56778 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
56779 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
56780 587 : delete temp_type;
56781 : #endif
56782 587 : temp_type = NULL;
56783 : #if 0
56784 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
56785 : if (optional_fortran_type_kind != NULL)
56786 : {
56787 : p_builtin_type = NULL;
56788 : }
56789 : #endif
56790 : }
56791 :
56792 : // Reuse this tempType variable so we can use the same code below.
56793 587 : temp_type = isSgTypeVoid(t);
56794 587 : ROSE_ASSERT(temp_type != NULL);
56795 : }
56796 :
56797 : #if 0
56798 : printf ("Leaving SgTypeVoid::createType(): temp_type = %p \n",temp_type);
56799 : #endif
56800 :
56801 938 : return temp_type;
56802 : }
56803 :
56804 :
56805 :
56806 : // End of memberFunctionString
56807 : // Start of memberFunctionString
56808 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
56809 :
56810 : #if 1
56811 : /*! Support for mangled names (for unparser)
56812 : There are two different cases of source code for the get_mangled member function
56813 : This one is used in all but the classes containing a base type
56814 : */
56815 : // SgName SgTypeVoid::get_mangled ( SgUnparse_Info & info )
56816 : SgName
56817 508495 : SgTypeVoid::get_mangled (void) const
56818 : {
56819 508495 : ROSE_ASSERT(this != NULL);
56820 :
56821 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
56822 : // CR (3/6/2020): Now type_kind is also used for Jovial.
56823 508495 : SgName name = "v";
56824 508495 : if (get_type_kind() != NULL)
56825 : {
56826 : // name += get_type_kind()->get_mangled();
56827 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
56828 0 : SgValueExp* value = isSgValueExp(get_type_kind());
56829 0 : if (value != NULL)
56830 : {
56831 : // name += string("_") + StringUtility::numberToString(value->get_value());
56832 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
56833 : }
56834 : else
56835 : {
56836 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
56837 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
56838 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
56839 : // a different prefix for each type of named type. It come down to is there can be multiple
56840 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
56841 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
56842 : // I think the issue is that v is not defined for any of the SgNameType IR nodes.
56843 : #if 0
56844 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"v");
56845 : #endif
56846 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
56847 : }
56848 : }
56849 :
56850 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
56851 : // REMOVE_ME please!
56852 508495 : if (isSgTypeFixed(this))
56853 : {
56854 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
56855 0 : if (fixed_type->get_scale() != NULL)
56856 : {
56857 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
56858 0 : if (value != NULL)
56859 : {
56860 0 : name += string("_") + value->get_constant_folded_value_as_string();
56861 : }
56862 : }
56863 0 : if (fixed_type->get_fraction() != NULL)
56864 : {
56865 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
56866 0 : if (value != NULL)
56867 : {
56868 0 : name += string("_") + value->get_constant_folded_value_as_string();
56869 : }
56870 : }
56871 : }
56872 :
56873 : #if 0
56874 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
56875 : #endif
56876 :
56877 508495 : return name;
56878 : }
56879 : #endif
56880 :
56881 :
56882 : // End of memberFunctionString
56883 :
56884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
56885 :
56886 28888 : SgTypeVoid* isSgTypeVoid ( SgNode* inputDerivedClassPointer )
56887 : {
56888 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
56889 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
56890 : // So to fix this we return NULL directly when the input is NULL and avoid the
56891 : // dynamic_cast in this case. This is likely a performance improvement as well.
56892 : // return dynamic_cast<SgTypeVoid*>(inputDerivedClassPointer);
56893 : // Milind Chabbi (8/28/2013): isSgTypeVoid uses table-driven castability instead of c++ default dynamic_cast
56894 : // this improves the running time performance by 10-20%.
56895 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeVoid*>(inputDerivedClassPointer);
56896 28888 : return IS_SgTypeVoid_FAST_MACRO(inputDerivedClassPointer);
56897 : }
56898 :
56899 : // DQ (11/8/2003): Added version of functions taking const pointer
56900 0 : const SgTypeVoid* isSgTypeVoid ( const SgNode* inputDerivedClassPointer )
56901 : {
56902 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
56903 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
56904 : // So to fix this we return NULL directly when the input is NULL and avoid the
56905 : // dynamic_cast in this case. This is likely a performance improvement as well.
56906 : // return dynamic_cast<const SgTypeVoid*>(inputDerivedClassPointer);
56907 : // Milind Chabbi (8/28/2013): isSgTypeVoid uses table-driven castability instead of c++ default dynamic_cast
56908 : // this improves the running time performance by 10-20%.
56909 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeVoid*>(inputDerivedClassPointer);
56910 0 : return IS_SgTypeVoid_FAST_MACRO(inputDerivedClassPointer);
56911 : }
56912 :
56913 :
56914 :
56915 : /* #line 56916 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56916 :
56917 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
56918 :
56919 : /**
56920 : \brief Generated destructor
56921 :
56922 : This destructor is automatically generated (by ROSETTA). This destructor
56923 : only frees memory of data members associated with the parts of the current IR node which
56924 : are NOT traversed. Those data members that are part of a traversal can be freed using
56925 : a traversal (calling this destructor on all children in a post-order traversal). Such
56926 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
56927 :
56928 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
56929 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
56930 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
56931 :
56932 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
56933 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
56934 : pointers are not yet implemented to call delete on eash pointer in the container.
56935 : (This could be done by derivation from the STL containers to define containers that
56936 : automatically deleted their members.)
56937 :
56938 : */
56939 1184 : SgTypeVoid::~SgTypeVoid () {
56940 592 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
56941 :
56942 :
56943 :
56944 : }
56945 :
56946 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
56947 1184 : }
56948 :
56949 :
56950 : /* #line 56951 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56951 :
56952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
56953 :
56954 : // Generated constructor
56955 938 : SgTypeVoid::SgTypeVoid ( )
56956 938 : : SgType()
56957 : {
56958 : #ifdef DEBUG
56959 : // printf ("In SgTypeVoid::SgTypeVoid () sage_class_name() = %s \n",sage_class_name());
56960 : #endif
56961 : #if 0
56962 : // debugging information!
56963 : printf ("In SgTypeVoid::SgTypeVoid (): this = %p = %s \n",this,this->class_name().c_str());
56964 : #endif
56965 :
56966 :
56967 :
56968 : #if 0
56969 : // DQ (7/30/2014): Call a virtual function.
56970 : std::string s = this->class_name();
56971 : #endif
56972 :
56973 : // Test the variant virtual function
56974 : // assert(T_VOID == variant());
56975 938 : assert(T_VOID == this->variant());
56976 938 : ROSE_ASSERT(T_VOID == (int)(this->variantT()));
56977 938 : post_construction_initialization();
56978 :
56979 : // Test the isSgTypeVoid() function since it has been problematic
56980 938 : assert(isSgTypeVoid(this) != NULL);
56981 938 : }
56982 :
56983 : // Generated constructor (all data members)
56984 :
56985 : /* #line 56986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56986 :
56987 :
56988 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
56989 :
56990 :
56991 : // ********************************************************
56992 : // member functions common across all array grammar objects
56993 : // ********************************************************
56994 :
56995 :
56996 :
56997 : /* #line 56998 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
56998 :
56999 :
57000 :
57001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
57002 :
57003 : // ********************************************************
57004 : // member functions specific to each node in the grammar
57005 : // ********************************************************
57006 :
57007 :
57008 : /* #line 57009 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57009 :
57010 : // Start of memberFunctionString
57011 :
57012 :
57013 : // End of memberFunctionString
57014 : // Start of memberFunctionString
57015 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
57016 :
57017 : // *** COMMON CODE SECTION BEGINS HERE ***
57018 :
57019 : #if 0
57020 : int
57021 : SgTypeGlobalVoid::getVariant() const
57022 : {
57023 : // This function is used in ROSE while "variant()" is used in SAGE
57024 : assert(this != NULL);
57025 : return variant();
57026 : }
57027 : #endif
57028 :
57029 : // This function is used in ROSE in treeTraversal code
57030 : // eventually replaces getVariant() and variant()
57031 : // though after variant() has been removed for a while we will
57032 : // want to change the name of variantT() back to variant()
57033 : // (since the "T" was ment to stand for temporary).
57034 : // When this happens the variantT() will be depricated.
57035 : VariantT
57036 0 : SgTypeGlobalVoid::variantT() const
57037 : {
57038 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
57039 0 : ROSE_ASSERT(this != NULL);
57040 0 : return V_SgTypeGlobalVoid;
57041 : }
57042 :
57043 : #if 0
57044 : int
57045 : SgTypeGlobalVoid::variant() const
57046 : {
57047 : // This function is used in SAGE
57048 : ROSE_ASSERT(this != NULL);
57049 : return T_GLOBAL_VOID;
57050 : }
57051 : #endif
57052 :
57053 : ROSE_DLL_API const char*
57054 0 : SgTypeGlobalVoid::sage_class_name() const
57055 : {
57056 0 : ROSE_ASSERT(this != NULL);
57057 0 : return "SgTypeGlobalVoid";
57058 : }
57059 :
57060 : std::string
57061 0 : SgTypeGlobalVoid::class_name() const
57062 : {
57063 0 : ROSE_ASSERT(this != NULL);
57064 0 : return "SgTypeGlobalVoid";
57065 : }
57066 :
57067 : // DQ (11/26/2005): Support for visitor pattern mechanims
57068 : // (inferior to ROSE traversal mechanism, experimental).
57069 : void
57070 0 : SgTypeGlobalVoid::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
57071 : {
57072 0 : ROSE_ASSERT(this != NULL);
57073 0 : visitor.visit(this);
57074 0 : }
57075 :
57076 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
57077 0 : void SgTypeGlobalVoid::accept (ROSE_VisitorPattern & visitor) {
57078 0 : ROSE_ASSERT(this != NULL);
57079 0 : visitor.visit(this);
57080 0 : }
57081 :
57082 : SgTypeGlobalVoid*
57083 0 : SgTypeGlobalVoid::addRegExpAttribute(std::string s, AstRegExAttribute* a)
57084 : {
57085 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
57086 : // This function is currently only supported for the AST used the represent Binary executables.
57087 : if (0 /* isSgAsmNode(this) != NULL */)
57088 : {
57089 : // Support for regex specification.
57090 : std::string prefixCode = "REGEX:";
57091 : addNewAttribute(prefixCode + s,a);
57092 : }
57093 : #endif
57094 :
57095 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
57096 0 : return this;
57097 : }
57098 :
57099 : // *** COMMON CODE SECTION ENDS HERE ***
57100 :
57101 :
57102 : // End of memberFunctionString
57103 : // Start of memberFunctionString
57104 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
57105 :
57106 :
57107 : #if 0
57108 : //! Error checking support
57109 : /*! Verifies the following:
57110 : - working getVariant() member function
57111 : - calls base class's error() member function
57112 : Every class has one of these functions.
57113 : */
57114 : bool
57115 : SgTypeGlobalVoid::error()
57116 : {
57117 : // Put error checking here
57118 :
57119 : ROSE_ASSERT (this != NULL);
57120 : if (getVariant() != T_GLOBAL_VOID)
57121 : {
57122 : printf ("Error in SgTypeGlobalVoid::error(): SgTypeGlobalVoid object has a %s variant \n",
57123 : Cxx_GrammarTerminalNames[getVariant()].name);
57124 : // printf ("Error in SgTypeGlobalVoid::error() \n");
57125 : ROSE_ABORT();
57126 : }
57127 :
57128 : ROSE_ASSERT (getVariant() == T_GLOBAL_VOID);
57129 : return SgType::error();
57130 : }
57131 : #endif
57132 :
57133 :
57134 :
57135 : // End of memberFunctionString
57136 : // Start of memberFunctionString
57137 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
57138 :
57139 :
57140 : // DQ (1/31/2006): Modified to build all types in the memory pools
57141 : // SgTypeGlobalVoid SgTypeGlobalVoid::builtin_type;
57142 : // SgTypeGlobalVoid* SgTypeGlobalVoid::builtin_type = new SgTypeGlobalVoid();
57143 : SgTypeGlobalVoid* SgTypeGlobalVoid::p_builtin_type = NULL;
57144 :
57145 :
57146 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
57147 : // SgTypeGlobalVoid* SgTypeGlobalVoid::createType(void)
57148 : SgTypeGlobalVoid*
57149 0 : SgTypeGlobalVoid::createType(SgExpression* optional_fortran_type_kind)
57150 : {
57151 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
57152 : // is not called (likely because static initialization is compiler dependent).
57153 : // DQ (1/31/2006): Modified to build all types in the memory pools
57154 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
57155 : // return &builtin_type;
57156 :
57157 : #if 0
57158 : printf ("In SgTypeGlobalVoid::createType() (COMMON_CREATE_TYPE) \n");
57159 : #endif
57160 :
57161 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
57162 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
57163 :
57164 0 : SgTypeGlobalVoid* temp_type = new SgTypeGlobalVoid();
57165 :
57166 : #if 0
57167 : printf ("In SgTypeGlobalVoid::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
57168 : #endif
57169 :
57170 : // DQ (10/31/2016): Added assertion.
57171 0 : ROSE_ASSERT(temp_type != NULL);
57172 :
57173 0 : if (optional_fortran_type_kind != NULL)
57174 : {
57175 : // DQ (10/31/2016): Added assertion.
57176 0 : ROSE_ASSERT(temp_type != NULL);
57177 :
57178 0 : temp_type->set_type_kind(optional_fortran_type_kind);
57179 : }
57180 : #if 0
57181 : else
57182 : {
57183 : // Let p_builtin_type refer to the unadorned type (no type kind).
57184 : p_builtin_type = temp_type;
57185 : }
57186 : #endif
57187 :
57188 0 : SgName name = temp_type->get_mangled();
57189 :
57190 : #if 0
57191 : printf ("Mangled type name for SgTypeGlobalVoid = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
57192 : #endif
57193 :
57194 : // DQ (10/31/2016): Added assertion.
57195 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
57196 :
57197 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
57198 :
57199 : #if 0
57200 : printf ("In SgTypeGlobalVoid::createType(): type from lookup_type = %p \n",t);
57201 : #endif
57202 :
57203 0 : if (t == NULL)
57204 : {
57205 0 : get_globalTypeTable()->insert_type(name,temp_type);
57206 : }
57207 : else
57208 : {
57209 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
57210 0 : if (t != temp_type)
57211 : {
57212 : #if 0
57213 : printf ("In SgTypeGlobalVoid::createType(): deleting temp_type = %p \n",temp_type);
57214 : #endif
57215 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
57216 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
57217 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
57218 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
57219 0 : delete temp_type;
57220 : #endif
57221 0 : temp_type = NULL;
57222 : #if 0
57223 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
57224 : if (optional_fortran_type_kind != NULL)
57225 : {
57226 : p_builtin_type = NULL;
57227 : }
57228 : #endif
57229 : }
57230 :
57231 : // Reuse this tempType variable so we can use the same code below.
57232 0 : temp_type = isSgTypeGlobalVoid(t);
57233 0 : ROSE_ASSERT(temp_type != NULL);
57234 : }
57235 :
57236 : #if 0
57237 : printf ("Leaving SgTypeGlobalVoid::createType(): temp_type = %p \n",temp_type);
57238 : #endif
57239 :
57240 0 : return temp_type;
57241 : }
57242 :
57243 :
57244 :
57245 : // End of memberFunctionString
57246 : // Start of memberFunctionString
57247 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
57248 :
57249 : #if 1
57250 : /*! Support for mangled names (for unparser)
57251 : There are two different cases of source code for the get_mangled member function
57252 : This one is used in all but the classes containing a base type
57253 : */
57254 : // SgName SgTypeGlobalVoid::get_mangled ( SgUnparse_Info & info )
57255 : SgName
57256 0 : SgTypeGlobalVoid::get_mangled (void) const
57257 : {
57258 0 : ROSE_ASSERT(this != NULL);
57259 :
57260 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
57261 : // CR (3/6/2020): Now type_kind is also used for Jovial.
57262 0 : SgName name = "gv";
57263 0 : if (get_type_kind() != NULL)
57264 : {
57265 : // name += get_type_kind()->get_mangled();
57266 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
57267 0 : SgValueExp* value = isSgValueExp(get_type_kind());
57268 0 : if (value != NULL)
57269 : {
57270 : // name += string("_") + StringUtility::numberToString(value->get_value());
57271 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
57272 : }
57273 : else
57274 : {
57275 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
57276 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
57277 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
57278 : // a different prefix for each type of named type. It come down to is there can be multiple
57279 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
57280 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
57281 : // I think the issue is that gv is not defined for any of the SgNameType IR nodes.
57282 : #if 0
57283 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"gv");
57284 : #endif
57285 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
57286 : }
57287 : }
57288 :
57289 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
57290 : // REMOVE_ME please!
57291 0 : if (isSgTypeFixed(this))
57292 : {
57293 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
57294 0 : if (fixed_type->get_scale() != NULL)
57295 : {
57296 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
57297 0 : if (value != NULL)
57298 : {
57299 0 : name += string("_") + value->get_constant_folded_value_as_string();
57300 : }
57301 : }
57302 0 : if (fixed_type->get_fraction() != NULL)
57303 : {
57304 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
57305 0 : if (value != NULL)
57306 : {
57307 0 : name += string("_") + value->get_constant_folded_value_as_string();
57308 : }
57309 : }
57310 : }
57311 :
57312 : #if 0
57313 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
57314 : #endif
57315 :
57316 0 : return name;
57317 : }
57318 : #endif
57319 :
57320 :
57321 : // End of memberFunctionString
57322 :
57323 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
57324 :
57325 0 : SgTypeGlobalVoid* isSgTypeGlobalVoid ( SgNode* inputDerivedClassPointer )
57326 : {
57327 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
57328 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
57329 : // So to fix this we return NULL directly when the input is NULL and avoid the
57330 : // dynamic_cast in this case. This is likely a performance improvement as well.
57331 : // return dynamic_cast<SgTypeGlobalVoid*>(inputDerivedClassPointer);
57332 : // Milind Chabbi (8/28/2013): isSgTypeGlobalVoid uses table-driven castability instead of c++ default dynamic_cast
57333 : // this improves the running time performance by 10-20%.
57334 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeGlobalVoid*>(inputDerivedClassPointer);
57335 0 : return IS_SgTypeGlobalVoid_FAST_MACRO(inputDerivedClassPointer);
57336 : }
57337 :
57338 : // DQ (11/8/2003): Added version of functions taking const pointer
57339 0 : const SgTypeGlobalVoid* isSgTypeGlobalVoid ( const SgNode* inputDerivedClassPointer )
57340 : {
57341 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
57342 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
57343 : // So to fix this we return NULL directly when the input is NULL and avoid the
57344 : // dynamic_cast in this case. This is likely a performance improvement as well.
57345 : // return dynamic_cast<const SgTypeGlobalVoid*>(inputDerivedClassPointer);
57346 : // Milind Chabbi (8/28/2013): isSgTypeGlobalVoid uses table-driven castability instead of c++ default dynamic_cast
57347 : // this improves the running time performance by 10-20%.
57348 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeGlobalVoid*>(inputDerivedClassPointer);
57349 0 : return IS_SgTypeGlobalVoid_FAST_MACRO(inputDerivedClassPointer);
57350 : }
57351 :
57352 :
57353 :
57354 : /* #line 57355 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57355 :
57356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
57357 :
57358 : /**
57359 : \brief Generated destructor
57360 :
57361 : This destructor is automatically generated (by ROSETTA). This destructor
57362 : only frees memory of data members associated with the parts of the current IR node which
57363 : are NOT traversed. Those data members that are part of a traversal can be freed using
57364 : a traversal (calling this destructor on all children in a post-order traversal). Such
57365 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
57366 :
57367 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
57368 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
57369 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
57370 :
57371 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
57372 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
57373 : pointers are not yet implemented to call delete on eash pointer in the container.
57374 : (This could be done by derivation from the STL containers to define containers that
57375 : automatically deleted their members.)
57376 :
57377 : */
57378 0 : SgTypeGlobalVoid::~SgTypeGlobalVoid () {
57379 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
57380 :
57381 :
57382 :
57383 : }
57384 :
57385 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
57386 0 : }
57387 :
57388 :
57389 : /* #line 57390 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57390 :
57391 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
57392 :
57393 : // Generated constructor
57394 0 : SgTypeGlobalVoid::SgTypeGlobalVoid ( )
57395 0 : : SgType()
57396 : {
57397 : #ifdef DEBUG
57398 : // printf ("In SgTypeGlobalVoid::SgTypeGlobalVoid () sage_class_name() = %s \n",sage_class_name());
57399 : #endif
57400 : #if 0
57401 : // debugging information!
57402 : printf ("In SgTypeGlobalVoid::SgTypeGlobalVoid (): this = %p = %s \n",this,this->class_name().c_str());
57403 : #endif
57404 :
57405 :
57406 :
57407 : #if 0
57408 : // DQ (7/30/2014): Call a virtual function.
57409 : std::string s = this->class_name();
57410 : #endif
57411 :
57412 : // Test the variant virtual function
57413 : // assert(T_GLOBAL_VOID == variant());
57414 0 : assert(T_GLOBAL_VOID == this->variant());
57415 0 : ROSE_ASSERT(T_GLOBAL_VOID == (int)(this->variantT()));
57416 0 : post_construction_initialization();
57417 :
57418 : // Test the isSgTypeGlobalVoid() function since it has been problematic
57419 0 : assert(isSgTypeGlobalVoid(this) != NULL);
57420 0 : }
57421 :
57422 : // Generated constructor (all data members)
57423 :
57424 : /* #line 57425 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57425 :
57426 :
57427 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
57428 :
57429 :
57430 : // ********************************************************
57431 : // member functions common across all array grammar objects
57432 : // ********************************************************
57433 :
57434 :
57435 :
57436 : /* #line 57437 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57437 :
57438 :
57439 :
57440 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
57441 :
57442 : // ********************************************************
57443 : // member functions specific to each node in the grammar
57444 : // ********************************************************
57445 :
57446 :
57447 : /* #line 57448 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57448 :
57449 : // Start of memberFunctionString
57450 :
57451 :
57452 : // End of memberFunctionString
57453 : // Start of memberFunctionString
57454 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
57455 :
57456 : // *** COMMON CODE SECTION BEGINS HERE ***
57457 :
57458 : #if 0
57459 : int
57460 : SgTypeWchar::getVariant() const
57461 : {
57462 : // This function is used in ROSE while "variant()" is used in SAGE
57463 : assert(this != NULL);
57464 : return variant();
57465 : }
57466 : #endif
57467 :
57468 : // This function is used in ROSE in treeTraversal code
57469 : // eventually replaces getVariant() and variant()
57470 : // though after variant() has been removed for a while we will
57471 : // want to change the name of variantT() back to variant()
57472 : // (since the "T" was ment to stand for temporary).
57473 : // When this happens the variantT() will be depricated.
57474 : VariantT
57475 8307520 : SgTypeWchar::variantT() const
57476 : {
57477 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
57478 8307520 : ROSE_ASSERT(this != NULL);
57479 8307520 : return V_SgTypeWchar;
57480 : }
57481 :
57482 : #if 0
57483 : int
57484 : SgTypeWchar::variant() const
57485 : {
57486 : // This function is used in SAGE
57487 : ROSE_ASSERT(this != NULL);
57488 : return T_WCHAR;
57489 : }
57490 : #endif
57491 :
57492 : ROSE_DLL_API const char*
57493 0 : SgTypeWchar::sage_class_name() const
57494 : {
57495 0 : ROSE_ASSERT(this != NULL);
57496 0 : return "SgTypeWchar";
57497 : }
57498 :
57499 : std::string
57500 243 : SgTypeWchar::class_name() const
57501 : {
57502 243 : ROSE_ASSERT(this != NULL);
57503 243 : return "SgTypeWchar";
57504 : }
57505 :
57506 : // DQ (11/26/2005): Support for visitor pattern mechanims
57507 : // (inferior to ROSE traversal mechanism, experimental).
57508 : void
57509 137 : SgTypeWchar::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
57510 : {
57511 137 : ROSE_ASSERT(this != NULL);
57512 137 : visitor.visit(this);
57513 137 : }
57514 :
57515 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
57516 0 : void SgTypeWchar::accept (ROSE_VisitorPattern & visitor) {
57517 0 : ROSE_ASSERT(this != NULL);
57518 0 : visitor.visit(this);
57519 0 : }
57520 :
57521 : SgTypeWchar*
57522 0 : SgTypeWchar::addRegExpAttribute(std::string s, AstRegExAttribute* a)
57523 : {
57524 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
57525 : // This function is currently only supported for the AST used the represent Binary executables.
57526 : if (0 /* isSgAsmNode(this) != NULL */)
57527 : {
57528 : // Support for regex specification.
57529 : std::string prefixCode = "REGEX:";
57530 : addNewAttribute(prefixCode + s,a);
57531 : }
57532 : #endif
57533 :
57534 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
57535 0 : return this;
57536 : }
57537 :
57538 : // *** COMMON CODE SECTION ENDS HERE ***
57539 :
57540 :
57541 : // End of memberFunctionString
57542 : // Start of memberFunctionString
57543 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
57544 :
57545 :
57546 : #if 0
57547 : //! Error checking support
57548 : /*! Verifies the following:
57549 : - working getVariant() member function
57550 : - calls base class's error() member function
57551 : Every class has one of these functions.
57552 : */
57553 : bool
57554 : SgTypeWchar::error()
57555 : {
57556 : // Put error checking here
57557 :
57558 : ROSE_ASSERT (this != NULL);
57559 : if (getVariant() != T_WCHAR)
57560 : {
57561 : printf ("Error in SgTypeWchar::error(): SgTypeWchar object has a %s variant \n",
57562 : Cxx_GrammarTerminalNames[getVariant()].name);
57563 : // printf ("Error in SgTypeWchar::error() \n");
57564 : ROSE_ABORT();
57565 : }
57566 :
57567 : ROSE_ASSERT (getVariant() == T_WCHAR);
57568 : return SgType::error();
57569 : }
57570 : #endif
57571 :
57572 :
57573 :
57574 : // End of memberFunctionString
57575 : // Start of memberFunctionString
57576 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
57577 :
57578 :
57579 : // DQ (1/31/2006): Modified to build all types in the memory pools
57580 : // SgTypeWchar SgTypeWchar::builtin_type;
57581 : // SgTypeWchar* SgTypeWchar::builtin_type = new SgTypeWchar();
57582 : SgTypeWchar* SgTypeWchar::p_builtin_type = NULL;
57583 :
57584 :
57585 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
57586 : // SgTypeWchar* SgTypeWchar::createType(void)
57587 : SgTypeWchar*
57588 14 : SgTypeWchar::createType(SgExpression* optional_fortran_type_kind)
57589 : {
57590 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
57591 : // is not called (likely because static initialization is compiler dependent).
57592 : // DQ (1/31/2006): Modified to build all types in the memory pools
57593 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
57594 : // return &builtin_type;
57595 :
57596 : #if 0
57597 : printf ("In SgTypeWchar::createType() (COMMON_CREATE_TYPE) \n");
57598 : #endif
57599 :
57600 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
57601 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
57602 :
57603 14 : SgTypeWchar* temp_type = new SgTypeWchar();
57604 :
57605 : #if 0
57606 : printf ("In SgTypeWchar::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
57607 : #endif
57608 :
57609 : // DQ (10/31/2016): Added assertion.
57610 14 : ROSE_ASSERT(temp_type != NULL);
57611 :
57612 14 : if (optional_fortran_type_kind != NULL)
57613 : {
57614 : // DQ (10/31/2016): Added assertion.
57615 0 : ROSE_ASSERT(temp_type != NULL);
57616 :
57617 0 : temp_type->set_type_kind(optional_fortran_type_kind);
57618 : }
57619 : #if 0
57620 : else
57621 : {
57622 : // Let p_builtin_type refer to the unadorned type (no type kind).
57623 : p_builtin_type = temp_type;
57624 : }
57625 : #endif
57626 :
57627 14 : SgName name = temp_type->get_mangled();
57628 :
57629 : #if 0
57630 : printf ("Mangled type name for SgTypeWchar = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
57631 : #endif
57632 :
57633 : // DQ (10/31/2016): Added assertion.
57634 14 : ROSE_ASSERT(get_globalTypeTable() != NULL);
57635 :
57636 14 : SgType* t = get_globalTypeTable()->lookup_type(name);
57637 :
57638 : #if 0
57639 : printf ("In SgTypeWchar::createType(): type from lookup_type = %p \n",t);
57640 : #endif
57641 :
57642 14 : if (t == NULL)
57643 : {
57644 14 : get_globalTypeTable()->insert_type(name,temp_type);
57645 : }
57646 : else
57647 : {
57648 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
57649 0 : if (t != temp_type)
57650 : {
57651 : #if 0
57652 : printf ("In SgTypeWchar::createType(): deleting temp_type = %p \n",temp_type);
57653 : #endif
57654 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
57655 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
57656 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
57657 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
57658 0 : delete temp_type;
57659 : #endif
57660 0 : temp_type = NULL;
57661 : #if 0
57662 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
57663 : if (optional_fortran_type_kind != NULL)
57664 : {
57665 : p_builtin_type = NULL;
57666 : }
57667 : #endif
57668 : }
57669 :
57670 : // Reuse this tempType variable so we can use the same code below.
57671 0 : temp_type = isSgTypeWchar(t);
57672 0 : ROSE_ASSERT(temp_type != NULL);
57673 : }
57674 :
57675 : #if 0
57676 : printf ("Leaving SgTypeWchar::createType(): temp_type = %p \n",temp_type);
57677 : #endif
57678 :
57679 14 : return temp_type;
57680 : }
57681 :
57682 :
57683 :
57684 : // End of memberFunctionString
57685 : // Start of memberFunctionString
57686 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
57687 :
57688 : #if 1
57689 : /*! Support for mangled names (for unparser)
57690 : There are two different cases of source code for the get_mangled member function
57691 : This one is used in all but the classes containing a base type
57692 : */
57693 : // SgName SgTypeWchar::get_mangled ( SgUnparse_Info & info )
57694 : SgName
57695 23378 : SgTypeWchar::get_mangled (void) const
57696 : {
57697 23378 : ROSE_ASSERT(this != NULL);
57698 :
57699 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
57700 : // CR (3/6/2020): Now type_kind is also used for Jovial.
57701 23378 : SgName name = "wc";
57702 23378 : if (get_type_kind() != NULL)
57703 : {
57704 : // name += get_type_kind()->get_mangled();
57705 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
57706 0 : SgValueExp* value = isSgValueExp(get_type_kind());
57707 0 : if (value != NULL)
57708 : {
57709 : // name += string("_") + StringUtility::numberToString(value->get_value());
57710 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
57711 : }
57712 : else
57713 : {
57714 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
57715 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
57716 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
57717 : // a different prefix for each type of named type. It come down to is there can be multiple
57718 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
57719 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
57720 : // I think the issue is that wc is not defined for any of the SgNameType IR nodes.
57721 : #if 0
57722 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"wc");
57723 : #endif
57724 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
57725 : }
57726 : }
57727 :
57728 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
57729 : // REMOVE_ME please!
57730 23378 : if (isSgTypeFixed(this))
57731 : {
57732 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
57733 0 : if (fixed_type->get_scale() != NULL)
57734 : {
57735 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
57736 0 : if (value != NULL)
57737 : {
57738 0 : name += string("_") + value->get_constant_folded_value_as_string();
57739 : }
57740 : }
57741 0 : if (fixed_type->get_fraction() != NULL)
57742 : {
57743 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
57744 0 : if (value != NULL)
57745 : {
57746 0 : name += string("_") + value->get_constant_folded_value_as_string();
57747 : }
57748 : }
57749 : }
57750 :
57751 : #if 0
57752 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
57753 : #endif
57754 :
57755 23378 : return name;
57756 : }
57757 : #endif
57758 :
57759 :
57760 : // End of memberFunctionString
57761 :
57762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
57763 :
57764 14 : SgTypeWchar* isSgTypeWchar ( SgNode* inputDerivedClassPointer )
57765 : {
57766 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
57767 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
57768 : // So to fix this we return NULL directly when the input is NULL and avoid the
57769 : // dynamic_cast in this case. This is likely a performance improvement as well.
57770 : // return dynamic_cast<SgTypeWchar*>(inputDerivedClassPointer);
57771 : // Milind Chabbi (8/28/2013): isSgTypeWchar uses table-driven castability instead of c++ default dynamic_cast
57772 : // this improves the running time performance by 10-20%.
57773 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeWchar*>(inputDerivedClassPointer);
57774 14 : return IS_SgTypeWchar_FAST_MACRO(inputDerivedClassPointer);
57775 : }
57776 :
57777 : // DQ (11/8/2003): Added version of functions taking const pointer
57778 0 : const SgTypeWchar* isSgTypeWchar ( const SgNode* inputDerivedClassPointer )
57779 : {
57780 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
57781 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
57782 : // So to fix this we return NULL directly when the input is NULL and avoid the
57783 : // dynamic_cast in this case. This is likely a performance improvement as well.
57784 : // return dynamic_cast<const SgTypeWchar*>(inputDerivedClassPointer);
57785 : // Milind Chabbi (8/28/2013): isSgTypeWchar uses table-driven castability instead of c++ default dynamic_cast
57786 : // this improves the running time performance by 10-20%.
57787 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeWchar*>(inputDerivedClassPointer);
57788 0 : return IS_SgTypeWchar_FAST_MACRO(inputDerivedClassPointer);
57789 : }
57790 :
57791 :
57792 :
57793 : /* #line 57794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57794 :
57795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
57796 :
57797 : /**
57798 : \brief Generated destructor
57799 :
57800 : This destructor is automatically generated (by ROSETTA). This destructor
57801 : only frees memory of data members associated with the parts of the current IR node which
57802 : are NOT traversed. Those data members that are part of a traversal can be freed using
57803 : a traversal (calling this destructor on all children in a post-order traversal). Such
57804 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
57805 :
57806 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
57807 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
57808 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
57809 :
57810 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
57811 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
57812 : pointers are not yet implemented to call delete on eash pointer in the container.
57813 : (This could be done by derivation from the STL containers to define containers that
57814 : automatically deleted their members.)
57815 :
57816 : */
57817 4 : SgTypeWchar::~SgTypeWchar () {
57818 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
57819 :
57820 :
57821 :
57822 : }
57823 :
57824 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
57825 4 : }
57826 :
57827 :
57828 : /* #line 57829 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57829 :
57830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
57831 :
57832 : // Generated constructor
57833 14 : SgTypeWchar::SgTypeWchar ( )
57834 14 : : SgType()
57835 : {
57836 : #ifdef DEBUG
57837 : // printf ("In SgTypeWchar::SgTypeWchar () sage_class_name() = %s \n",sage_class_name());
57838 : #endif
57839 : #if 0
57840 : // debugging information!
57841 : printf ("In SgTypeWchar::SgTypeWchar (): this = %p = %s \n",this,this->class_name().c_str());
57842 : #endif
57843 :
57844 :
57845 :
57846 : #if 0
57847 : // DQ (7/30/2014): Call a virtual function.
57848 : std::string s = this->class_name();
57849 : #endif
57850 :
57851 : // Test the variant virtual function
57852 : // assert(T_WCHAR == variant());
57853 14 : assert(T_WCHAR == this->variant());
57854 14 : ROSE_ASSERT(T_WCHAR == (int)(this->variantT()));
57855 14 : post_construction_initialization();
57856 :
57857 : // Test the isSgTypeWchar() function since it has been problematic
57858 14 : assert(isSgTypeWchar(this) != NULL);
57859 14 : }
57860 :
57861 : // Generated constructor (all data members)
57862 :
57863 : /* #line 57864 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57864 :
57865 :
57866 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
57867 :
57868 :
57869 : // ********************************************************
57870 : // member functions common across all array grammar objects
57871 : // ********************************************************
57872 :
57873 :
57874 :
57875 : /* #line 57876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57876 :
57877 :
57878 :
57879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
57880 :
57881 : // ********************************************************
57882 : // member functions specific to each node in the grammar
57883 : // ********************************************************
57884 :
57885 :
57886 : /* #line 57887 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
57887 :
57888 : // Start of memberFunctionString
57889 :
57890 :
57891 : // End of memberFunctionString
57892 : // Start of memberFunctionString
57893 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
57894 :
57895 : // *** COMMON CODE SECTION BEGINS HERE ***
57896 :
57897 : #if 0
57898 : int
57899 : SgTypeFloat::getVariant() const
57900 : {
57901 : // This function is used in ROSE while "variant()" is used in SAGE
57902 : assert(this != NULL);
57903 : return variant();
57904 : }
57905 : #endif
57906 :
57907 : // This function is used in ROSE in treeTraversal code
57908 : // eventually replaces getVariant() and variant()
57909 : // though after variant() has been removed for a while we will
57910 : // want to change the name of variantT() back to variant()
57911 : // (since the "T" was ment to stand for temporary).
57912 : // When this happens the variantT() will be depricated.
57913 : VariantT
57914 51769900 : SgTypeFloat::variantT() const
57915 : {
57916 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
57917 51769900 : ROSE_ASSERT(this != NULL);
57918 51769900 : return V_SgTypeFloat;
57919 : }
57920 :
57921 : #if 0
57922 : int
57923 : SgTypeFloat::variant() const
57924 : {
57925 : // This function is used in SAGE
57926 : ROSE_ASSERT(this != NULL);
57927 : return T_FLOAT;
57928 : }
57929 : #endif
57930 :
57931 : ROSE_DLL_API const char*
57932 0 : SgTypeFloat::sage_class_name() const
57933 : {
57934 0 : ROSE_ASSERT(this != NULL);
57935 0 : return "SgTypeFloat";
57936 : }
57937 :
57938 : std::string
57939 366 : SgTypeFloat::class_name() const
57940 : {
57941 366 : ROSE_ASSERT(this != NULL);
57942 366 : return "SgTypeFloat";
57943 : }
57944 :
57945 : // DQ (11/26/2005): Support for visitor pattern mechanims
57946 : // (inferior to ROSE traversal mechanism, experimental).
57947 : void
57948 194 : SgTypeFloat::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
57949 : {
57950 194 : ROSE_ASSERT(this != NULL);
57951 194 : visitor.visit(this);
57952 194 : }
57953 :
57954 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
57955 0 : void SgTypeFloat::accept (ROSE_VisitorPattern & visitor) {
57956 0 : ROSE_ASSERT(this != NULL);
57957 0 : visitor.visit(this);
57958 0 : }
57959 :
57960 : SgTypeFloat*
57961 0 : SgTypeFloat::addRegExpAttribute(std::string s, AstRegExAttribute* a)
57962 : {
57963 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
57964 : // This function is currently only supported for the AST used the represent Binary executables.
57965 : if (0 /* isSgAsmNode(this) != NULL */)
57966 : {
57967 : // Support for regex specification.
57968 : std::string prefixCode = "REGEX:";
57969 : addNewAttribute(prefixCode + s,a);
57970 : }
57971 : #endif
57972 :
57973 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
57974 0 : return this;
57975 : }
57976 :
57977 : // *** COMMON CODE SECTION ENDS HERE ***
57978 :
57979 :
57980 : // End of memberFunctionString
57981 : // Start of memberFunctionString
57982 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
57983 :
57984 :
57985 : #if 0
57986 : //! Error checking support
57987 : /*! Verifies the following:
57988 : - working getVariant() member function
57989 : - calls base class's error() member function
57990 : Every class has one of these functions.
57991 : */
57992 : bool
57993 : SgTypeFloat::error()
57994 : {
57995 : // Put error checking here
57996 :
57997 : ROSE_ASSERT (this != NULL);
57998 : if (getVariant() != T_FLOAT)
57999 : {
58000 : printf ("Error in SgTypeFloat::error(): SgTypeFloat object has a %s variant \n",
58001 : Cxx_GrammarTerminalNames[getVariant()].name);
58002 : // printf ("Error in SgTypeFloat::error() \n");
58003 : ROSE_ABORT();
58004 : }
58005 :
58006 : ROSE_ASSERT (getVariant() == T_FLOAT);
58007 : return SgType::error();
58008 : }
58009 : #endif
58010 :
58011 :
58012 :
58013 : // End of memberFunctionString
58014 : // Start of memberFunctionString
58015 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
58016 :
58017 :
58018 : // DQ (1/31/2006): Modified to build all types in the memory pools
58019 : // SgTypeFloat SgTypeFloat::builtin_type;
58020 : // SgTypeFloat* SgTypeFloat::builtin_type = new SgTypeFloat();
58021 : SgTypeFloat* SgTypeFloat::p_builtin_type = NULL;
58022 :
58023 :
58024 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
58025 : // SgTypeFloat* SgTypeFloat::createType(void)
58026 : SgTypeFloat*
58027 1160 : SgTypeFloat::createType(SgExpression* optional_fortran_type_kind)
58028 : {
58029 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
58030 : // is not called (likely because static initialization is compiler dependent).
58031 : // DQ (1/31/2006): Modified to build all types in the memory pools
58032 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
58033 : // return &builtin_type;
58034 :
58035 : #if 0
58036 : printf ("In SgTypeFloat::createType() (COMMON_CREATE_TYPE) \n");
58037 : #endif
58038 :
58039 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
58040 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
58041 :
58042 1160 : SgTypeFloat* temp_type = new SgTypeFloat();
58043 :
58044 : #if 0
58045 : printf ("In SgTypeFloat::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
58046 : #endif
58047 :
58048 : // DQ (10/31/2016): Added assertion.
58049 1160 : ROSE_ASSERT(temp_type != NULL);
58050 :
58051 1160 : if (optional_fortran_type_kind != NULL)
58052 : {
58053 : // DQ (10/31/2016): Added assertion.
58054 0 : ROSE_ASSERT(temp_type != NULL);
58055 :
58056 0 : temp_type->set_type_kind(optional_fortran_type_kind);
58057 : }
58058 : #if 0
58059 : else
58060 : {
58061 : // Let p_builtin_type refer to the unadorned type (no type kind).
58062 : p_builtin_type = temp_type;
58063 : }
58064 : #endif
58065 :
58066 1160 : SgName name = temp_type->get_mangled();
58067 :
58068 : #if 0
58069 : printf ("Mangled type name for SgTypeFloat = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
58070 : #endif
58071 :
58072 : // DQ (10/31/2016): Added assertion.
58073 1160 : ROSE_ASSERT(get_globalTypeTable() != NULL);
58074 :
58075 1160 : SgType* t = get_globalTypeTable()->lookup_type(name);
58076 :
58077 : #if 0
58078 : printf ("In SgTypeFloat::createType(): type from lookup_type = %p \n",t);
58079 : #endif
58080 :
58081 1160 : if (t == NULL)
58082 : {
58083 336 : get_globalTypeTable()->insert_type(name,temp_type);
58084 : }
58085 : else
58086 : {
58087 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
58088 824 : if (t != temp_type)
58089 : {
58090 : #if 0
58091 : printf ("In SgTypeFloat::createType(): deleting temp_type = %p \n",temp_type);
58092 : #endif
58093 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
58094 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
58095 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
58096 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
58097 824 : delete temp_type;
58098 : #endif
58099 824 : temp_type = NULL;
58100 : #if 0
58101 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
58102 : if (optional_fortran_type_kind != NULL)
58103 : {
58104 : p_builtin_type = NULL;
58105 : }
58106 : #endif
58107 : }
58108 :
58109 : // Reuse this tempType variable so we can use the same code below.
58110 824 : temp_type = isSgTypeFloat(t);
58111 824 : ROSE_ASSERT(temp_type != NULL);
58112 : }
58113 :
58114 : #if 0
58115 : printf ("Leaving SgTypeFloat::createType(): temp_type = %p \n",temp_type);
58116 : #endif
58117 :
58118 1160 : return temp_type;
58119 : }
58120 :
58121 :
58122 :
58123 : // End of memberFunctionString
58124 : // Start of memberFunctionString
58125 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
58126 :
58127 : #if 1
58128 : /*! Support for mangled names (for unparser)
58129 : There are two different cases of source code for the get_mangled member function
58130 : This one is used in all but the classes containing a base type
58131 : */
58132 : // SgName SgTypeFloat::get_mangled ( SgUnparse_Info & info )
58133 : SgName
58134 259999 : SgTypeFloat::get_mangled (void) const
58135 : {
58136 259999 : ROSE_ASSERT(this != NULL);
58137 :
58138 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
58139 : // CR (3/6/2020): Now type_kind is also used for Jovial.
58140 259999 : SgName name = "f";
58141 259999 : if (get_type_kind() != NULL)
58142 : {
58143 : // name += get_type_kind()->get_mangled();
58144 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
58145 0 : SgValueExp* value = isSgValueExp(get_type_kind());
58146 0 : if (value != NULL)
58147 : {
58148 : // name += string("_") + StringUtility::numberToString(value->get_value());
58149 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
58150 : }
58151 : else
58152 : {
58153 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
58154 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
58155 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
58156 : // a different prefix for each type of named type. It come down to is there can be multiple
58157 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
58158 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
58159 : // I think the issue is that f is not defined for any of the SgNameType IR nodes.
58160 : #if 0
58161 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"f");
58162 : #endif
58163 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
58164 : }
58165 : }
58166 :
58167 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
58168 : // REMOVE_ME please!
58169 259999 : if (isSgTypeFixed(this))
58170 : {
58171 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
58172 0 : if (fixed_type->get_scale() != NULL)
58173 : {
58174 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
58175 0 : if (value != NULL)
58176 : {
58177 0 : name += string("_") + value->get_constant_folded_value_as_string();
58178 : }
58179 : }
58180 0 : if (fixed_type->get_fraction() != NULL)
58181 : {
58182 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
58183 0 : if (value != NULL)
58184 : {
58185 0 : name += string("_") + value->get_constant_folded_value_as_string();
58186 : }
58187 : }
58188 : }
58189 :
58190 : #if 0
58191 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
58192 : #endif
58193 :
58194 259999 : return name;
58195 : }
58196 : #endif
58197 :
58198 :
58199 : // End of memberFunctionString
58200 :
58201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
58202 :
58203 1984 : SgTypeFloat* isSgTypeFloat ( SgNode* inputDerivedClassPointer )
58204 : {
58205 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
58206 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
58207 : // So to fix this we return NULL directly when the input is NULL and avoid the
58208 : // dynamic_cast in this case. This is likely a performance improvement as well.
58209 : // return dynamic_cast<SgTypeFloat*>(inputDerivedClassPointer);
58210 : // Milind Chabbi (8/28/2013): isSgTypeFloat uses table-driven castability instead of c++ default dynamic_cast
58211 : // this improves the running time performance by 10-20%.
58212 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeFloat*>(inputDerivedClassPointer);
58213 1984 : return IS_SgTypeFloat_FAST_MACRO(inputDerivedClassPointer);
58214 : }
58215 :
58216 : // DQ (11/8/2003): Added version of functions taking const pointer
58217 0 : const SgTypeFloat* isSgTypeFloat ( const SgNode* inputDerivedClassPointer )
58218 : {
58219 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
58220 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
58221 : // So to fix this we return NULL directly when the input is NULL and avoid the
58222 : // dynamic_cast in this case. This is likely a performance improvement as well.
58223 : // return dynamic_cast<const SgTypeFloat*>(inputDerivedClassPointer);
58224 : // Milind Chabbi (8/28/2013): isSgTypeFloat uses table-driven castability instead of c++ default dynamic_cast
58225 : // this improves the running time performance by 10-20%.
58226 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeFloat*>(inputDerivedClassPointer);
58227 0 : return IS_SgTypeFloat_FAST_MACRO(inputDerivedClassPointer);
58228 : }
58229 :
58230 :
58231 :
58232 : /* #line 58233 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58233 :
58234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
58235 :
58236 : /**
58237 : \brief Generated destructor
58238 :
58239 : This destructor is automatically generated (by ROSETTA). This destructor
58240 : only frees memory of data members associated with the parts of the current IR node which
58241 : are NOT traversed. Those data members that are part of a traversal can be freed using
58242 : a traversal (calling this destructor on all children in a post-order traversal). Such
58243 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
58244 :
58245 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
58246 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
58247 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
58248 :
58249 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
58250 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
58251 : pointers are not yet implemented to call delete on eash pointer in the container.
58252 : (This could be done by derivation from the STL containers to define containers that
58253 : automatically deleted their members.)
58254 :
58255 : */
58256 1656 : SgTypeFloat::~SgTypeFloat () {
58257 828 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
58258 :
58259 :
58260 :
58261 : }
58262 :
58263 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
58264 1656 : }
58265 :
58266 :
58267 : /* #line 58268 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58268 :
58269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
58270 :
58271 : // Generated constructor
58272 1160 : SgTypeFloat::SgTypeFloat ( )
58273 1160 : : SgType()
58274 : {
58275 : #ifdef DEBUG
58276 : // printf ("In SgTypeFloat::SgTypeFloat () sage_class_name() = %s \n",sage_class_name());
58277 : #endif
58278 : #if 0
58279 : // debugging information!
58280 : printf ("In SgTypeFloat::SgTypeFloat (): this = %p = %s \n",this,this->class_name().c_str());
58281 : #endif
58282 :
58283 :
58284 :
58285 : #if 0
58286 : // DQ (7/30/2014): Call a virtual function.
58287 : std::string s = this->class_name();
58288 : #endif
58289 :
58290 : // Test the variant virtual function
58291 : // assert(T_FLOAT == variant());
58292 1160 : assert(T_FLOAT == this->variant());
58293 1160 : ROSE_ASSERT(T_FLOAT == (int)(this->variantT()));
58294 1160 : post_construction_initialization();
58295 :
58296 : // Test the isSgTypeFloat() function since it has been problematic
58297 1160 : assert(isSgTypeFloat(this) != NULL);
58298 1160 : }
58299 :
58300 : // Generated constructor (all data members)
58301 :
58302 : /* #line 58303 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58303 :
58304 :
58305 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
58306 :
58307 :
58308 : // ********************************************************
58309 : // member functions common across all array grammar objects
58310 : // ********************************************************
58311 :
58312 :
58313 :
58314 : /* #line 58315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58315 :
58316 :
58317 :
58318 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
58319 :
58320 : // ********************************************************
58321 : // member functions specific to each node in the grammar
58322 : // ********************************************************
58323 :
58324 :
58325 : /* #line 58326 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58326 :
58327 : // Start of memberFunctionString
58328 :
58329 :
58330 : // End of memberFunctionString
58331 : // Start of memberFunctionString
58332 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
58333 :
58334 : // *** COMMON CODE SECTION BEGINS HERE ***
58335 :
58336 : #if 0
58337 : int
58338 : SgTypeDouble::getVariant() const
58339 : {
58340 : // This function is used in ROSE while "variant()" is used in SAGE
58341 : assert(this != NULL);
58342 : return variant();
58343 : }
58344 : #endif
58345 :
58346 : // This function is used in ROSE in treeTraversal code
58347 : // eventually replaces getVariant() and variant()
58348 : // though after variant() has been removed for a while we will
58349 : // want to change the name of variantT() back to variant()
58350 : // (since the "T" was ment to stand for temporary).
58351 : // When this happens the variantT() will be depricated.
58352 : VariantT
58353 3094280000 : SgTypeDouble::variantT() const
58354 : {
58355 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
58356 3094280000 : ROSE_ASSERT(this != NULL);
58357 3094280000 : return V_SgTypeDouble;
58358 : }
58359 :
58360 : #if 0
58361 : int
58362 : SgTypeDouble::variant() const
58363 : {
58364 : // This function is used in SAGE
58365 : ROSE_ASSERT(this != NULL);
58366 : return T_DOUBLE;
58367 : }
58368 : #endif
58369 :
58370 : ROSE_DLL_API const char*
58371 0 : SgTypeDouble::sage_class_name() const
58372 : {
58373 0 : ROSE_ASSERT(this != NULL);
58374 0 : return "SgTypeDouble";
58375 : }
58376 :
58377 : std::string
58378 352 : SgTypeDouble::class_name() const
58379 : {
58380 352 : ROSE_ASSERT(this != NULL);
58381 352 : return "SgTypeDouble";
58382 : }
58383 :
58384 : // DQ (11/26/2005): Support for visitor pattern mechanims
58385 : // (inferior to ROSE traversal mechanism, experimental).
58386 : void
58387 194 : SgTypeDouble::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
58388 : {
58389 194 : ROSE_ASSERT(this != NULL);
58390 194 : visitor.visit(this);
58391 194 : }
58392 :
58393 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
58394 0 : void SgTypeDouble::accept (ROSE_VisitorPattern & visitor) {
58395 0 : ROSE_ASSERT(this != NULL);
58396 0 : visitor.visit(this);
58397 0 : }
58398 :
58399 : SgTypeDouble*
58400 0 : SgTypeDouble::addRegExpAttribute(std::string s, AstRegExAttribute* a)
58401 : {
58402 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
58403 : // This function is currently only supported for the AST used the represent Binary executables.
58404 : if (0 /* isSgAsmNode(this) != NULL */)
58405 : {
58406 : // Support for regex specification.
58407 : std::string prefixCode = "REGEX:";
58408 : addNewAttribute(prefixCode + s,a);
58409 : }
58410 : #endif
58411 :
58412 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
58413 0 : return this;
58414 : }
58415 :
58416 : // *** COMMON CODE SECTION ENDS HERE ***
58417 :
58418 :
58419 : // End of memberFunctionString
58420 : // Start of memberFunctionString
58421 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
58422 :
58423 :
58424 : #if 0
58425 : //! Error checking support
58426 : /*! Verifies the following:
58427 : - working getVariant() member function
58428 : - calls base class's error() member function
58429 : Every class has one of these functions.
58430 : */
58431 : bool
58432 : SgTypeDouble::error()
58433 : {
58434 : // Put error checking here
58435 :
58436 : ROSE_ASSERT (this != NULL);
58437 : if (getVariant() != T_DOUBLE)
58438 : {
58439 : printf ("Error in SgTypeDouble::error(): SgTypeDouble object has a %s variant \n",
58440 : Cxx_GrammarTerminalNames[getVariant()].name);
58441 : // printf ("Error in SgTypeDouble::error() \n");
58442 : ROSE_ABORT();
58443 : }
58444 :
58445 : ROSE_ASSERT (getVariant() == T_DOUBLE);
58446 : return SgType::error();
58447 : }
58448 : #endif
58449 :
58450 :
58451 :
58452 : // End of memberFunctionString
58453 : // Start of memberFunctionString
58454 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
58455 :
58456 :
58457 : // DQ (1/31/2006): Modified to build all types in the memory pools
58458 : // SgTypeDouble SgTypeDouble::builtin_type;
58459 : // SgTypeDouble* SgTypeDouble::builtin_type = new SgTypeDouble();
58460 : SgTypeDouble* SgTypeDouble::p_builtin_type = NULL;
58461 :
58462 :
58463 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
58464 : // SgTypeDouble* SgTypeDouble::createType(void)
58465 : SgTypeDouble*
58466 12174 : SgTypeDouble::createType(SgExpression* optional_fortran_type_kind)
58467 : {
58468 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
58469 : // is not called (likely because static initialization is compiler dependent).
58470 : // DQ (1/31/2006): Modified to build all types in the memory pools
58471 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
58472 : // return &builtin_type;
58473 :
58474 : #if 0
58475 : printf ("In SgTypeDouble::createType() (COMMON_CREATE_TYPE) \n");
58476 : #endif
58477 :
58478 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
58479 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
58480 :
58481 12174 : SgTypeDouble* temp_type = new SgTypeDouble();
58482 :
58483 : #if 0
58484 : printf ("In SgTypeDouble::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
58485 : #endif
58486 :
58487 : // DQ (10/31/2016): Added assertion.
58488 12174 : ROSE_ASSERT(temp_type != NULL);
58489 :
58490 12174 : if (optional_fortran_type_kind != NULL)
58491 : {
58492 : // DQ (10/31/2016): Added assertion.
58493 0 : ROSE_ASSERT(temp_type != NULL);
58494 :
58495 0 : temp_type->set_type_kind(optional_fortran_type_kind);
58496 : }
58497 : #if 0
58498 : else
58499 : {
58500 : // Let p_builtin_type refer to the unadorned type (no type kind).
58501 : p_builtin_type = temp_type;
58502 : }
58503 : #endif
58504 :
58505 12174 : SgName name = temp_type->get_mangled();
58506 :
58507 : #if 0
58508 : printf ("Mangled type name for SgTypeDouble = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
58509 : #endif
58510 :
58511 : // DQ (10/31/2016): Added assertion.
58512 12174 : ROSE_ASSERT(get_globalTypeTable() != NULL);
58513 :
58514 12174 : SgType* t = get_globalTypeTable()->lookup_type(name);
58515 :
58516 : #if 0
58517 : printf ("In SgTypeDouble::createType(): type from lookup_type = %p \n",t);
58518 : #endif
58519 :
58520 12174 : if (t == NULL)
58521 : {
58522 327 : get_globalTypeTable()->insert_type(name,temp_type);
58523 : }
58524 : else
58525 : {
58526 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
58527 11847 : if (t != temp_type)
58528 : {
58529 : #if 0
58530 : printf ("In SgTypeDouble::createType(): deleting temp_type = %p \n",temp_type);
58531 : #endif
58532 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
58533 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
58534 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
58535 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
58536 11847 : delete temp_type;
58537 : #endif
58538 11847 : temp_type = NULL;
58539 : #if 0
58540 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
58541 : if (optional_fortran_type_kind != NULL)
58542 : {
58543 : p_builtin_type = NULL;
58544 : }
58545 : #endif
58546 : }
58547 :
58548 : // Reuse this tempType variable so we can use the same code below.
58549 11847 : temp_type = isSgTypeDouble(t);
58550 11847 : ROSE_ASSERT(temp_type != NULL);
58551 : }
58552 :
58553 : #if 0
58554 : printf ("Leaving SgTypeDouble::createType(): temp_type = %p \n",temp_type);
58555 : #endif
58556 :
58557 12174 : return temp_type;
58558 : }
58559 :
58560 :
58561 :
58562 : // End of memberFunctionString
58563 : // Start of memberFunctionString
58564 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
58565 :
58566 : #if 1
58567 : /*! Support for mangled names (for unparser)
58568 : There are two different cases of source code for the get_mangled member function
58569 : This one is used in all but the classes containing a base type
58570 : */
58571 : // SgName SgTypeDouble::get_mangled ( SgUnparse_Info & info )
58572 : SgName
58573 294150 : SgTypeDouble::get_mangled (void) const
58574 : {
58575 294150 : ROSE_ASSERT(this != NULL);
58576 :
58577 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
58578 : // CR (3/6/2020): Now type_kind is also used for Jovial.
58579 294150 : SgName name = "d";
58580 294150 : if (get_type_kind() != NULL)
58581 : {
58582 : // name += get_type_kind()->get_mangled();
58583 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
58584 0 : SgValueExp* value = isSgValueExp(get_type_kind());
58585 0 : if (value != NULL)
58586 : {
58587 : // name += string("_") + StringUtility::numberToString(value->get_value());
58588 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
58589 : }
58590 : else
58591 : {
58592 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
58593 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
58594 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
58595 : // a different prefix for each type of named type. It come down to is there can be multiple
58596 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
58597 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
58598 : // I think the issue is that d is not defined for any of the SgNameType IR nodes.
58599 : #if 0
58600 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"d");
58601 : #endif
58602 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
58603 : }
58604 : }
58605 :
58606 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
58607 : // REMOVE_ME please!
58608 294150 : if (isSgTypeFixed(this))
58609 : {
58610 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
58611 0 : if (fixed_type->get_scale() != NULL)
58612 : {
58613 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
58614 0 : if (value != NULL)
58615 : {
58616 0 : name += string("_") + value->get_constant_folded_value_as_string();
58617 : }
58618 : }
58619 0 : if (fixed_type->get_fraction() != NULL)
58620 : {
58621 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
58622 0 : if (value != NULL)
58623 : {
58624 0 : name += string("_") + value->get_constant_folded_value_as_string();
58625 : }
58626 : }
58627 : }
58628 :
58629 : #if 0
58630 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
58631 : #endif
58632 :
58633 294150 : return name;
58634 : }
58635 : #endif
58636 :
58637 :
58638 : // End of memberFunctionString
58639 :
58640 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
58641 :
58642 24021 : SgTypeDouble* isSgTypeDouble ( SgNode* inputDerivedClassPointer )
58643 : {
58644 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
58645 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
58646 : // So to fix this we return NULL directly when the input is NULL and avoid the
58647 : // dynamic_cast in this case. This is likely a performance improvement as well.
58648 : // return dynamic_cast<SgTypeDouble*>(inputDerivedClassPointer);
58649 : // Milind Chabbi (8/28/2013): isSgTypeDouble uses table-driven castability instead of c++ default dynamic_cast
58650 : // this improves the running time performance by 10-20%.
58651 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeDouble*>(inputDerivedClassPointer);
58652 24021 : return IS_SgTypeDouble_FAST_MACRO(inputDerivedClassPointer);
58653 : }
58654 :
58655 : // DQ (11/8/2003): Added version of functions taking const pointer
58656 0 : const SgTypeDouble* isSgTypeDouble ( const SgNode* inputDerivedClassPointer )
58657 : {
58658 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
58659 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
58660 : // So to fix this we return NULL directly when the input is NULL and avoid the
58661 : // dynamic_cast in this case. This is likely a performance improvement as well.
58662 : // return dynamic_cast<const SgTypeDouble*>(inputDerivedClassPointer);
58663 : // Milind Chabbi (8/28/2013): isSgTypeDouble uses table-driven castability instead of c++ default dynamic_cast
58664 : // this improves the running time performance by 10-20%.
58665 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeDouble*>(inputDerivedClassPointer);
58666 0 : return IS_SgTypeDouble_FAST_MACRO(inputDerivedClassPointer);
58667 : }
58668 :
58669 :
58670 :
58671 : /* #line 58672 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58672 :
58673 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
58674 :
58675 : /**
58676 : \brief Generated destructor
58677 :
58678 : This destructor is automatically generated (by ROSETTA). This destructor
58679 : only frees memory of data members associated with the parts of the current IR node which
58680 : are NOT traversed. Those data members that are part of a traversal can be freed using
58681 : a traversal (calling this destructor on all children in a post-order traversal). Such
58682 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
58683 :
58684 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
58685 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
58686 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
58687 :
58688 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
58689 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
58690 : pointers are not yet implemented to call delete on eash pointer in the container.
58691 : (This could be done by derivation from the STL containers to define containers that
58692 : automatically deleted their members.)
58693 :
58694 : */
58695 23702 : SgTypeDouble::~SgTypeDouble () {
58696 11851 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
58697 :
58698 :
58699 :
58700 : }
58701 :
58702 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
58703 23702 : }
58704 :
58705 :
58706 : /* #line 58707 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58707 :
58708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
58709 :
58710 : // Generated constructor
58711 12174 : SgTypeDouble::SgTypeDouble ( )
58712 12174 : : SgType()
58713 : {
58714 : #ifdef DEBUG
58715 : // printf ("In SgTypeDouble::SgTypeDouble () sage_class_name() = %s \n",sage_class_name());
58716 : #endif
58717 : #if 0
58718 : // debugging information!
58719 : printf ("In SgTypeDouble::SgTypeDouble (): this = %p = %s \n",this,this->class_name().c_str());
58720 : #endif
58721 :
58722 :
58723 :
58724 : #if 0
58725 : // DQ (7/30/2014): Call a virtual function.
58726 : std::string s = this->class_name();
58727 : #endif
58728 :
58729 : // Test the variant virtual function
58730 : // assert(T_DOUBLE == variant());
58731 12174 : assert(T_DOUBLE == this->variant());
58732 12174 : ROSE_ASSERT(T_DOUBLE == (int)(this->variantT()));
58733 12174 : post_construction_initialization();
58734 :
58735 : // Test the isSgTypeDouble() function since it has been problematic
58736 12174 : assert(isSgTypeDouble(this) != NULL);
58737 12174 : }
58738 :
58739 : // Generated constructor (all data members)
58740 :
58741 : /* #line 58742 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58742 :
58743 :
58744 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
58745 :
58746 :
58747 : // ********************************************************
58748 : // member functions common across all array grammar objects
58749 : // ********************************************************
58750 :
58751 :
58752 :
58753 : /* #line 58754 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58754 :
58755 :
58756 :
58757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
58758 :
58759 : // ********************************************************
58760 : // member functions specific to each node in the grammar
58761 : // ********************************************************
58762 :
58763 :
58764 : /* #line 58765 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
58765 :
58766 : // Start of memberFunctionString
58767 :
58768 :
58769 : // End of memberFunctionString
58770 : // Start of memberFunctionString
58771 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
58772 :
58773 : // *** COMMON CODE SECTION BEGINS HERE ***
58774 :
58775 : #if 0
58776 : int
58777 : SgTypeLongLong::getVariant() const
58778 : {
58779 : // This function is used in ROSE while "variant()" is used in SAGE
58780 : assert(this != NULL);
58781 : return variant();
58782 : }
58783 : #endif
58784 :
58785 : // This function is used in ROSE in treeTraversal code
58786 : // eventually replaces getVariant() and variant()
58787 : // though after variant() has been removed for a while we will
58788 : // want to change the name of variantT() back to variant()
58789 : // (since the "T" was ment to stand for temporary).
58790 : // When this happens the variantT() will be depricated.
58791 : VariantT
58792 20592600 : SgTypeLongLong::variantT() const
58793 : {
58794 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
58795 20592600 : ROSE_ASSERT(this != NULL);
58796 20592600 : return V_SgTypeLongLong;
58797 : }
58798 :
58799 : #if 0
58800 : int
58801 : SgTypeLongLong::variant() const
58802 : {
58803 : // This function is used in SAGE
58804 : ROSE_ASSERT(this != NULL);
58805 : return T_LONG_LONG;
58806 : }
58807 : #endif
58808 :
58809 : ROSE_DLL_API const char*
58810 0 : SgTypeLongLong::sage_class_name() const
58811 : {
58812 0 : ROSE_ASSERT(this != NULL);
58813 0 : return "SgTypeLongLong";
58814 : }
58815 :
58816 : std::string
58817 346 : SgTypeLongLong::class_name() const
58818 : {
58819 346 : ROSE_ASSERT(this != NULL);
58820 346 : return "SgTypeLongLong";
58821 : }
58822 :
58823 : // DQ (11/26/2005): Support for visitor pattern mechanims
58824 : // (inferior to ROSE traversal mechanism, experimental).
58825 : void
58826 194 : SgTypeLongLong::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
58827 : {
58828 194 : ROSE_ASSERT(this != NULL);
58829 194 : visitor.visit(this);
58830 194 : }
58831 :
58832 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
58833 0 : void SgTypeLongLong::accept (ROSE_VisitorPattern & visitor) {
58834 0 : ROSE_ASSERT(this != NULL);
58835 0 : visitor.visit(this);
58836 0 : }
58837 :
58838 : SgTypeLongLong*
58839 0 : SgTypeLongLong::addRegExpAttribute(std::string s, AstRegExAttribute* a)
58840 : {
58841 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
58842 : // This function is currently only supported for the AST used the represent Binary executables.
58843 : if (0 /* isSgAsmNode(this) != NULL */)
58844 : {
58845 : // Support for regex specification.
58846 : std::string prefixCode = "REGEX:";
58847 : addNewAttribute(prefixCode + s,a);
58848 : }
58849 : #endif
58850 :
58851 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
58852 0 : return this;
58853 : }
58854 :
58855 : // *** COMMON CODE SECTION ENDS HERE ***
58856 :
58857 :
58858 : // End of memberFunctionString
58859 : // Start of memberFunctionString
58860 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
58861 :
58862 :
58863 : #if 0
58864 : //! Error checking support
58865 : /*! Verifies the following:
58866 : - working getVariant() member function
58867 : - calls base class's error() member function
58868 : Every class has one of these functions.
58869 : */
58870 : bool
58871 : SgTypeLongLong::error()
58872 : {
58873 : // Put error checking here
58874 :
58875 : ROSE_ASSERT (this != NULL);
58876 : if (getVariant() != T_LONG_LONG)
58877 : {
58878 : printf ("Error in SgTypeLongLong::error(): SgTypeLongLong object has a %s variant \n",
58879 : Cxx_GrammarTerminalNames[getVariant()].name);
58880 : // printf ("Error in SgTypeLongLong::error() \n");
58881 : ROSE_ABORT();
58882 : }
58883 :
58884 : ROSE_ASSERT (getVariant() == T_LONG_LONG);
58885 : return SgType::error();
58886 : }
58887 : #endif
58888 :
58889 :
58890 :
58891 : // End of memberFunctionString
58892 : // Start of memberFunctionString
58893 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
58894 :
58895 :
58896 : // DQ (1/31/2006): Modified to build all types in the memory pools
58897 : // SgTypeLongLong SgTypeLongLong::builtin_type;
58898 : // SgTypeLongLong* SgTypeLongLong::builtin_type = new SgTypeLongLong();
58899 : SgTypeLongLong* SgTypeLongLong::p_builtin_type = NULL;
58900 :
58901 :
58902 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
58903 : // SgTypeLongLong* SgTypeLongLong::createType(void)
58904 : SgTypeLongLong*
58905 320 : SgTypeLongLong::createType(SgExpression* optional_fortran_type_kind)
58906 : {
58907 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
58908 : // is not called (likely because static initialization is compiler dependent).
58909 : // DQ (1/31/2006): Modified to build all types in the memory pools
58910 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
58911 : // return &builtin_type;
58912 :
58913 : #if 0
58914 : printf ("In SgTypeLongLong::createType() (COMMON_CREATE_TYPE) \n");
58915 : #endif
58916 :
58917 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
58918 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
58919 :
58920 320 : SgTypeLongLong* temp_type = new SgTypeLongLong();
58921 :
58922 : #if 0
58923 : printf ("In SgTypeLongLong::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
58924 : #endif
58925 :
58926 : // DQ (10/31/2016): Added assertion.
58927 320 : ROSE_ASSERT(temp_type != NULL);
58928 :
58929 320 : if (optional_fortran_type_kind != NULL)
58930 : {
58931 : // DQ (10/31/2016): Added assertion.
58932 0 : ROSE_ASSERT(temp_type != NULL);
58933 :
58934 0 : temp_type->set_type_kind(optional_fortran_type_kind);
58935 : }
58936 : #if 0
58937 : else
58938 : {
58939 : // Let p_builtin_type refer to the unadorned type (no type kind).
58940 : p_builtin_type = temp_type;
58941 : }
58942 : #endif
58943 :
58944 320 : SgName name = temp_type->get_mangled();
58945 :
58946 : #if 0
58947 : printf ("Mangled type name for SgTypeLongLong = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
58948 : #endif
58949 :
58950 : // DQ (10/31/2016): Added assertion.
58951 320 : ROSE_ASSERT(get_globalTypeTable() != NULL);
58952 :
58953 320 : SgType* t = get_globalTypeTable()->lookup_type(name);
58954 :
58955 : #if 0
58956 : printf ("In SgTypeLongLong::createType(): type from lookup_type = %p \n",t);
58957 : #endif
58958 :
58959 320 : if (t == NULL)
58960 : {
58961 315 : get_globalTypeTable()->insert_type(name,temp_type);
58962 : }
58963 : else
58964 : {
58965 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
58966 5 : if (t != temp_type)
58967 : {
58968 : #if 0
58969 : printf ("In SgTypeLongLong::createType(): deleting temp_type = %p \n",temp_type);
58970 : #endif
58971 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
58972 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
58973 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
58974 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
58975 5 : delete temp_type;
58976 : #endif
58977 5 : temp_type = NULL;
58978 : #if 0
58979 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
58980 : if (optional_fortran_type_kind != NULL)
58981 : {
58982 : p_builtin_type = NULL;
58983 : }
58984 : #endif
58985 : }
58986 :
58987 : // Reuse this tempType variable so we can use the same code below.
58988 5 : temp_type = isSgTypeLongLong(t);
58989 5 : ROSE_ASSERT(temp_type != NULL);
58990 : }
58991 :
58992 : #if 0
58993 : printf ("Leaving SgTypeLongLong::createType(): temp_type = %p \n",temp_type);
58994 : #endif
58995 :
58996 320 : return temp_type;
58997 : }
58998 :
58999 :
59000 :
59001 : // End of memberFunctionString
59002 : // Start of memberFunctionString
59003 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
59004 :
59005 : #if 1
59006 : /*! Support for mangled names (for unparser)
59007 : There are two different cases of source code for the get_mangled member function
59008 : This one is used in all but the classes containing a base type
59009 : */
59010 : // SgName SgTypeLongLong::get_mangled ( SgUnparse_Info & info )
59011 : SgName
59012 96335 : SgTypeLongLong::get_mangled (void) const
59013 : {
59014 96335 : ROSE_ASSERT(this != NULL);
59015 :
59016 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
59017 : // CR (3/6/2020): Now type_kind is also used for Jovial.
59018 96335 : SgName name = "L";
59019 96335 : if (get_type_kind() != NULL)
59020 : {
59021 : // name += get_type_kind()->get_mangled();
59022 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
59023 0 : SgValueExp* value = isSgValueExp(get_type_kind());
59024 0 : if (value != NULL)
59025 : {
59026 : // name += string("_") + StringUtility::numberToString(value->get_value());
59027 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
59028 : }
59029 : else
59030 : {
59031 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
59032 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
59033 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
59034 : // a different prefix for each type of named type. It come down to is there can be multiple
59035 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
59036 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
59037 : // I think the issue is that L is not defined for any of the SgNameType IR nodes.
59038 : #if 0
59039 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"L");
59040 : #endif
59041 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
59042 : }
59043 : }
59044 :
59045 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
59046 : // REMOVE_ME please!
59047 96335 : if (isSgTypeFixed(this))
59048 : {
59049 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
59050 0 : if (fixed_type->get_scale() != NULL)
59051 : {
59052 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
59053 0 : if (value != NULL)
59054 : {
59055 0 : name += string("_") + value->get_constant_folded_value_as_string();
59056 : }
59057 : }
59058 0 : if (fixed_type->get_fraction() != NULL)
59059 : {
59060 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
59061 0 : if (value != NULL)
59062 : {
59063 0 : name += string("_") + value->get_constant_folded_value_as_string();
59064 : }
59065 : }
59066 : }
59067 :
59068 : #if 0
59069 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
59070 : #endif
59071 :
59072 96335 : return name;
59073 : }
59074 : #endif
59075 :
59076 :
59077 : // End of memberFunctionString
59078 :
59079 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
59080 :
59081 325 : SgTypeLongLong* isSgTypeLongLong ( SgNode* inputDerivedClassPointer )
59082 : {
59083 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
59084 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
59085 : // So to fix this we return NULL directly when the input is NULL and avoid the
59086 : // dynamic_cast in this case. This is likely a performance improvement as well.
59087 : // return dynamic_cast<SgTypeLongLong*>(inputDerivedClassPointer);
59088 : // Milind Chabbi (8/28/2013): isSgTypeLongLong uses table-driven castability instead of c++ default dynamic_cast
59089 : // this improves the running time performance by 10-20%.
59090 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeLongLong*>(inputDerivedClassPointer);
59091 325 : return IS_SgTypeLongLong_FAST_MACRO(inputDerivedClassPointer);
59092 : }
59093 :
59094 : // DQ (11/8/2003): Added version of functions taking const pointer
59095 0 : const SgTypeLongLong* isSgTypeLongLong ( const SgNode* inputDerivedClassPointer )
59096 : {
59097 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
59098 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
59099 : // So to fix this we return NULL directly when the input is NULL and avoid the
59100 : // dynamic_cast in this case. This is likely a performance improvement as well.
59101 : // return dynamic_cast<const SgTypeLongLong*>(inputDerivedClassPointer);
59102 : // Milind Chabbi (8/28/2013): isSgTypeLongLong uses table-driven castability instead of c++ default dynamic_cast
59103 : // this improves the running time performance by 10-20%.
59104 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeLongLong*>(inputDerivedClassPointer);
59105 0 : return IS_SgTypeLongLong_FAST_MACRO(inputDerivedClassPointer);
59106 : }
59107 :
59108 :
59109 :
59110 : /* #line 59111 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59111 :
59112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
59113 :
59114 : /**
59115 : \brief Generated destructor
59116 :
59117 : This destructor is automatically generated (by ROSETTA). This destructor
59118 : only frees memory of data members associated with the parts of the current IR node which
59119 : are NOT traversed. Those data members that are part of a traversal can be freed using
59120 : a traversal (calling this destructor on all children in a post-order traversal). Such
59121 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
59122 :
59123 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
59124 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
59125 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
59126 :
59127 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
59128 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
59129 : pointers are not yet implemented to call delete on eash pointer in the container.
59130 : (This could be done by derivation from the STL containers to define containers that
59131 : automatically deleted their members.)
59132 :
59133 : */
59134 18 : SgTypeLongLong::~SgTypeLongLong () {
59135 9 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
59136 :
59137 :
59138 :
59139 : }
59140 :
59141 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
59142 18 : }
59143 :
59144 :
59145 : /* #line 59146 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59146 :
59147 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
59148 :
59149 : // Generated constructor
59150 320 : SgTypeLongLong::SgTypeLongLong ( )
59151 320 : : SgType()
59152 : {
59153 : #ifdef DEBUG
59154 : // printf ("In SgTypeLongLong::SgTypeLongLong () sage_class_name() = %s \n",sage_class_name());
59155 : #endif
59156 : #if 0
59157 : // debugging information!
59158 : printf ("In SgTypeLongLong::SgTypeLongLong (): this = %p = %s \n",this,this->class_name().c_str());
59159 : #endif
59160 :
59161 :
59162 :
59163 : #if 0
59164 : // DQ (7/30/2014): Call a virtual function.
59165 : std::string s = this->class_name();
59166 : #endif
59167 :
59168 : // Test the variant virtual function
59169 : // assert(T_LONG_LONG == variant());
59170 320 : assert(T_LONG_LONG == this->variant());
59171 320 : ROSE_ASSERT(T_LONG_LONG == (int)(this->variantT()));
59172 320 : post_construction_initialization();
59173 :
59174 : // Test the isSgTypeLongLong() function since it has been problematic
59175 320 : assert(isSgTypeLongLong(this) != NULL);
59176 320 : }
59177 :
59178 : // Generated constructor (all data members)
59179 :
59180 : /* #line 59181 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59181 :
59182 :
59183 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
59184 :
59185 :
59186 : // ********************************************************
59187 : // member functions common across all array grammar objects
59188 : // ********************************************************
59189 :
59190 :
59191 :
59192 : /* #line 59193 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59193 :
59194 :
59195 :
59196 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
59197 :
59198 : // ********************************************************
59199 : // member functions specific to each node in the grammar
59200 : // ********************************************************
59201 :
59202 :
59203 : /* #line 59204 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59204 :
59205 : // Start of memberFunctionString
59206 :
59207 :
59208 : // End of memberFunctionString
59209 : // Start of memberFunctionString
59210 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
59211 :
59212 : // *** COMMON CODE SECTION BEGINS HERE ***
59213 :
59214 : #if 0
59215 : int
59216 : SgTypeSignedLongLong::getVariant() const
59217 : {
59218 : // This function is used in ROSE while "variant()" is used in SAGE
59219 : assert(this != NULL);
59220 : return variant();
59221 : }
59222 : #endif
59223 :
59224 : // This function is used in ROSE in treeTraversal code
59225 : // eventually replaces getVariant() and variant()
59226 : // though after variant() has been removed for a while we will
59227 : // want to change the name of variantT() back to variant()
59228 : // (since the "T" was ment to stand for temporary).
59229 : // When this happens the variantT() will be depricated.
59230 : VariantT
59231 10234 : SgTypeSignedLongLong::variantT() const
59232 : {
59233 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
59234 10234 : ROSE_ASSERT(this != NULL);
59235 10234 : return V_SgTypeSignedLongLong;
59236 : }
59237 :
59238 : #if 0
59239 : int
59240 : SgTypeSignedLongLong::variant() const
59241 : {
59242 : // This function is used in SAGE
59243 : ROSE_ASSERT(this != NULL);
59244 : return T_SIGNED_LONG_LONG;
59245 : }
59246 : #endif
59247 :
59248 : ROSE_DLL_API const char*
59249 0 : SgTypeSignedLongLong::sage_class_name() const
59250 : {
59251 0 : ROSE_ASSERT(this != NULL);
59252 0 : return "SgTypeSignedLongLong";
59253 : }
59254 :
59255 : std::string
59256 7 : SgTypeSignedLongLong::class_name() const
59257 : {
59258 7 : ROSE_ASSERT(this != NULL);
59259 7 : return "SgTypeSignedLongLong";
59260 : }
59261 :
59262 : // DQ (11/26/2005): Support for visitor pattern mechanims
59263 : // (inferior to ROSE traversal mechanism, experimental).
59264 : void
59265 137 : SgTypeSignedLongLong::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
59266 : {
59267 137 : ROSE_ASSERT(this != NULL);
59268 137 : visitor.visit(this);
59269 137 : }
59270 :
59271 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
59272 0 : void SgTypeSignedLongLong::accept (ROSE_VisitorPattern & visitor) {
59273 0 : ROSE_ASSERT(this != NULL);
59274 0 : visitor.visit(this);
59275 0 : }
59276 :
59277 : SgTypeSignedLongLong*
59278 0 : SgTypeSignedLongLong::addRegExpAttribute(std::string s, AstRegExAttribute* a)
59279 : {
59280 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
59281 : // This function is currently only supported for the AST used the represent Binary executables.
59282 : if (0 /* isSgAsmNode(this) != NULL */)
59283 : {
59284 : // Support for regex specification.
59285 : std::string prefixCode = "REGEX:";
59286 : addNewAttribute(prefixCode + s,a);
59287 : }
59288 : #endif
59289 :
59290 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
59291 0 : return this;
59292 : }
59293 :
59294 : // *** COMMON CODE SECTION ENDS HERE ***
59295 :
59296 :
59297 : // End of memberFunctionString
59298 : // Start of memberFunctionString
59299 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
59300 :
59301 :
59302 : #if 0
59303 : //! Error checking support
59304 : /*! Verifies the following:
59305 : - working getVariant() member function
59306 : - calls base class's error() member function
59307 : Every class has one of these functions.
59308 : */
59309 : bool
59310 : SgTypeSignedLongLong::error()
59311 : {
59312 : // Put error checking here
59313 :
59314 : ROSE_ASSERT (this != NULL);
59315 : if (getVariant() != T_SIGNED_LONG_LONG)
59316 : {
59317 : printf ("Error in SgTypeSignedLongLong::error(): SgTypeSignedLongLong object has a %s variant \n",
59318 : Cxx_GrammarTerminalNames[getVariant()].name);
59319 : // printf ("Error in SgTypeSignedLongLong::error() \n");
59320 : ROSE_ABORT();
59321 : }
59322 :
59323 : ROSE_ASSERT (getVariant() == T_SIGNED_LONG_LONG);
59324 : return SgType::error();
59325 : }
59326 : #endif
59327 :
59328 :
59329 :
59330 : // End of memberFunctionString
59331 : // Start of memberFunctionString
59332 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
59333 :
59334 :
59335 : // DQ (1/31/2006): Modified to build all types in the memory pools
59336 : // SgTypeSignedLongLong SgTypeSignedLongLong::builtin_type;
59337 : // SgTypeSignedLongLong* SgTypeSignedLongLong::builtin_type = new SgTypeSignedLongLong();
59338 : SgTypeSignedLongLong* SgTypeSignedLongLong::p_builtin_type = NULL;
59339 :
59340 :
59341 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
59342 : // SgTypeSignedLongLong* SgTypeSignedLongLong::createType(void)
59343 : SgTypeSignedLongLong*
59344 10 : SgTypeSignedLongLong::createType(SgExpression* optional_fortran_type_kind)
59345 : {
59346 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
59347 : // is not called (likely because static initialization is compiler dependent).
59348 : // DQ (1/31/2006): Modified to build all types in the memory pools
59349 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
59350 : // return &builtin_type;
59351 :
59352 : #if 0
59353 : printf ("In SgTypeSignedLongLong::createType() (COMMON_CREATE_TYPE) \n");
59354 : #endif
59355 :
59356 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
59357 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
59358 :
59359 10 : SgTypeSignedLongLong* temp_type = new SgTypeSignedLongLong();
59360 :
59361 : #if 0
59362 : printf ("In SgTypeSignedLongLong::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
59363 : #endif
59364 :
59365 : // DQ (10/31/2016): Added assertion.
59366 10 : ROSE_ASSERT(temp_type != NULL);
59367 :
59368 10 : if (optional_fortran_type_kind != NULL)
59369 : {
59370 : // DQ (10/31/2016): Added assertion.
59371 0 : ROSE_ASSERT(temp_type != NULL);
59372 :
59373 0 : temp_type->set_type_kind(optional_fortran_type_kind);
59374 : }
59375 : #if 0
59376 : else
59377 : {
59378 : // Let p_builtin_type refer to the unadorned type (no type kind).
59379 : p_builtin_type = temp_type;
59380 : }
59381 : #endif
59382 :
59383 10 : SgName name = temp_type->get_mangled();
59384 :
59385 : #if 0
59386 : printf ("Mangled type name for SgTypeSignedLongLong = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
59387 : #endif
59388 :
59389 : // DQ (10/31/2016): Added assertion.
59390 10 : ROSE_ASSERT(get_globalTypeTable() != NULL);
59391 :
59392 10 : SgType* t = get_globalTypeTable()->lookup_type(name);
59393 :
59394 : #if 0
59395 : printf ("In SgTypeSignedLongLong::createType(): type from lookup_type = %p \n",t);
59396 : #endif
59397 :
59398 10 : if (t == NULL)
59399 : {
59400 10 : get_globalTypeTable()->insert_type(name,temp_type);
59401 : }
59402 : else
59403 : {
59404 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
59405 0 : if (t != temp_type)
59406 : {
59407 : #if 0
59408 : printf ("In SgTypeSignedLongLong::createType(): deleting temp_type = %p \n",temp_type);
59409 : #endif
59410 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
59411 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
59412 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
59413 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
59414 0 : delete temp_type;
59415 : #endif
59416 0 : temp_type = NULL;
59417 : #if 0
59418 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
59419 : if (optional_fortran_type_kind != NULL)
59420 : {
59421 : p_builtin_type = NULL;
59422 : }
59423 : #endif
59424 : }
59425 :
59426 : // Reuse this tempType variable so we can use the same code below.
59427 0 : temp_type = isSgTypeSignedLongLong(t);
59428 0 : ROSE_ASSERT(temp_type != NULL);
59429 : }
59430 :
59431 : #if 0
59432 : printf ("Leaving SgTypeSignedLongLong::createType(): temp_type = %p \n",temp_type);
59433 : #endif
59434 :
59435 10 : return temp_type;
59436 : }
59437 :
59438 :
59439 :
59440 : // End of memberFunctionString
59441 : // Start of memberFunctionString
59442 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
59443 :
59444 : #if 1
59445 : /*! Support for mangled names (for unparser)
59446 : There are two different cases of source code for the get_mangled member function
59447 : This one is used in all but the classes containing a base type
59448 : */
59449 : // SgName SgTypeSignedLongLong::get_mangled ( SgUnparse_Info & info )
59450 : SgName
59451 11 : SgTypeSignedLongLong::get_mangled (void) const
59452 : {
59453 11 : ROSE_ASSERT(this != NULL);
59454 :
59455 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
59456 : // CR (3/6/2020): Now type_kind is also used for Jovial.
59457 11 : SgName name = "SL";
59458 11 : if (get_type_kind() != NULL)
59459 : {
59460 : // name += get_type_kind()->get_mangled();
59461 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
59462 0 : SgValueExp* value = isSgValueExp(get_type_kind());
59463 0 : if (value != NULL)
59464 : {
59465 : // name += string("_") + StringUtility::numberToString(value->get_value());
59466 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
59467 : }
59468 : else
59469 : {
59470 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
59471 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
59472 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
59473 : // a different prefix for each type of named type. It come down to is there can be multiple
59474 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
59475 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
59476 : // I think the issue is that SL is not defined for any of the SgNameType IR nodes.
59477 : #if 0
59478 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"SL");
59479 : #endif
59480 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
59481 : }
59482 : }
59483 :
59484 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
59485 : // REMOVE_ME please!
59486 11 : if (isSgTypeFixed(this))
59487 : {
59488 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
59489 0 : if (fixed_type->get_scale() != NULL)
59490 : {
59491 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
59492 0 : if (value != NULL)
59493 : {
59494 0 : name += string("_") + value->get_constant_folded_value_as_string();
59495 : }
59496 : }
59497 0 : if (fixed_type->get_fraction() != NULL)
59498 : {
59499 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
59500 0 : if (value != NULL)
59501 : {
59502 0 : name += string("_") + value->get_constant_folded_value_as_string();
59503 : }
59504 : }
59505 : }
59506 :
59507 : #if 0
59508 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
59509 : #endif
59510 :
59511 11 : return name;
59512 : }
59513 : #endif
59514 :
59515 :
59516 : // End of memberFunctionString
59517 :
59518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
59519 :
59520 10 : SgTypeSignedLongLong* isSgTypeSignedLongLong ( SgNode* inputDerivedClassPointer )
59521 : {
59522 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
59523 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
59524 : // So to fix this we return NULL directly when the input is NULL and avoid the
59525 : // dynamic_cast in this case. This is likely a performance improvement as well.
59526 : // return dynamic_cast<SgTypeSignedLongLong*>(inputDerivedClassPointer);
59527 : // Milind Chabbi (8/28/2013): isSgTypeSignedLongLong uses table-driven castability instead of c++ default dynamic_cast
59528 : // this improves the running time performance by 10-20%.
59529 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeSignedLongLong*>(inputDerivedClassPointer);
59530 10 : return IS_SgTypeSignedLongLong_FAST_MACRO(inputDerivedClassPointer);
59531 : }
59532 :
59533 : // DQ (11/8/2003): Added version of functions taking const pointer
59534 0 : const SgTypeSignedLongLong* isSgTypeSignedLongLong ( const SgNode* inputDerivedClassPointer )
59535 : {
59536 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
59537 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
59538 : // So to fix this we return NULL directly when the input is NULL and avoid the
59539 : // dynamic_cast in this case. This is likely a performance improvement as well.
59540 : // return dynamic_cast<const SgTypeSignedLongLong*>(inputDerivedClassPointer);
59541 : // Milind Chabbi (8/28/2013): isSgTypeSignedLongLong uses table-driven castability instead of c++ default dynamic_cast
59542 : // this improves the running time performance by 10-20%.
59543 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeSignedLongLong*>(inputDerivedClassPointer);
59544 0 : return IS_SgTypeSignedLongLong_FAST_MACRO(inputDerivedClassPointer);
59545 : }
59546 :
59547 :
59548 :
59549 : /* #line 59550 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59550 :
59551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
59552 :
59553 : /**
59554 : \brief Generated destructor
59555 :
59556 : This destructor is automatically generated (by ROSETTA). This destructor
59557 : only frees memory of data members associated with the parts of the current IR node which
59558 : are NOT traversed. Those data members that are part of a traversal can be freed using
59559 : a traversal (calling this destructor on all children in a post-order traversal). Such
59560 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
59561 :
59562 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
59563 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
59564 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
59565 :
59566 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
59567 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
59568 : pointers are not yet implemented to call delete on eash pointer in the container.
59569 : (This could be done by derivation from the STL containers to define containers that
59570 : automatically deleted their members.)
59571 :
59572 : */
59573 4 : SgTypeSignedLongLong::~SgTypeSignedLongLong () {
59574 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
59575 :
59576 :
59577 :
59578 : }
59579 :
59580 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
59581 4 : }
59582 :
59583 :
59584 : /* #line 59585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59585 :
59586 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
59587 :
59588 : // Generated constructor
59589 10 : SgTypeSignedLongLong::SgTypeSignedLongLong ( )
59590 10 : : SgType()
59591 : {
59592 : #ifdef DEBUG
59593 : // printf ("In SgTypeSignedLongLong::SgTypeSignedLongLong () sage_class_name() = %s \n",sage_class_name());
59594 : #endif
59595 : #if 0
59596 : // debugging information!
59597 : printf ("In SgTypeSignedLongLong::SgTypeSignedLongLong (): this = %p = %s \n",this,this->class_name().c_str());
59598 : #endif
59599 :
59600 :
59601 :
59602 : #if 0
59603 : // DQ (7/30/2014): Call a virtual function.
59604 : std::string s = this->class_name();
59605 : #endif
59606 :
59607 : // Test the variant virtual function
59608 : // assert(T_SIGNED_LONG_LONG == variant());
59609 10 : assert(T_SIGNED_LONG_LONG == this->variant());
59610 10 : ROSE_ASSERT(T_SIGNED_LONG_LONG == (int)(this->variantT()));
59611 10 : post_construction_initialization();
59612 :
59613 : // Test the isSgTypeSignedLongLong() function since it has been problematic
59614 10 : assert(isSgTypeSignedLongLong(this) != NULL);
59615 10 : }
59616 :
59617 : // Generated constructor (all data members)
59618 :
59619 : /* #line 59620 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59620 :
59621 :
59622 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
59623 :
59624 :
59625 : // ********************************************************
59626 : // member functions common across all array grammar objects
59627 : // ********************************************************
59628 :
59629 :
59630 :
59631 : /* #line 59632 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59632 :
59633 :
59634 :
59635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
59636 :
59637 : // ********************************************************
59638 : // member functions specific to each node in the grammar
59639 : // ********************************************************
59640 :
59641 :
59642 : /* #line 59643 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59643 :
59644 : // Start of memberFunctionString
59645 :
59646 :
59647 : // End of memberFunctionString
59648 : // Start of memberFunctionString
59649 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
59650 :
59651 : // *** COMMON CODE SECTION BEGINS HERE ***
59652 :
59653 : #if 0
59654 : int
59655 : SgTypeUnsignedLongLong::getVariant() const
59656 : {
59657 : // This function is used in ROSE while "variant()" is used in SAGE
59658 : assert(this != NULL);
59659 : return variant();
59660 : }
59661 : #endif
59662 :
59663 : // This function is used in ROSE in treeTraversal code
59664 : // eventually replaces getVariant() and variant()
59665 : // though after variant() has been removed for a while we will
59666 : // want to change the name of variantT() back to variant()
59667 : // (since the "T" was ment to stand for temporary).
59668 : // When this happens the variantT() will be depricated.
59669 : VariantT
59670 59800500 : SgTypeUnsignedLongLong::variantT() const
59671 : {
59672 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
59673 59800500 : ROSE_ASSERT(this != NULL);
59674 59800500 : return V_SgTypeUnsignedLongLong;
59675 : }
59676 :
59677 : #if 0
59678 : int
59679 : SgTypeUnsignedLongLong::variant() const
59680 : {
59681 : // This function is used in SAGE
59682 : ROSE_ASSERT(this != NULL);
59683 : return T_UNSIGNED_LONG_LONG;
59684 : }
59685 : #endif
59686 :
59687 : ROSE_DLL_API const char*
59688 0 : SgTypeUnsignedLongLong::sage_class_name() const
59689 : {
59690 0 : ROSE_ASSERT(this != NULL);
59691 0 : return "SgTypeUnsignedLongLong";
59692 : }
59693 :
59694 : std::string
59695 335 : SgTypeUnsignedLongLong::class_name() const
59696 : {
59697 335 : ROSE_ASSERT(this != NULL);
59698 335 : return "SgTypeUnsignedLongLong";
59699 : }
59700 :
59701 : // DQ (11/26/2005): Support for visitor pattern mechanims
59702 : // (inferior to ROSE traversal mechanism, experimental).
59703 : void
59704 194 : SgTypeUnsignedLongLong::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
59705 : {
59706 194 : ROSE_ASSERT(this != NULL);
59707 194 : visitor.visit(this);
59708 194 : }
59709 :
59710 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
59711 0 : void SgTypeUnsignedLongLong::accept (ROSE_VisitorPattern & visitor) {
59712 0 : ROSE_ASSERT(this != NULL);
59713 0 : visitor.visit(this);
59714 0 : }
59715 :
59716 : SgTypeUnsignedLongLong*
59717 0 : SgTypeUnsignedLongLong::addRegExpAttribute(std::string s, AstRegExAttribute* a)
59718 : {
59719 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
59720 : // This function is currently only supported for the AST used the represent Binary executables.
59721 : if (0 /* isSgAsmNode(this) != NULL */)
59722 : {
59723 : // Support for regex specification.
59724 : std::string prefixCode = "REGEX:";
59725 : addNewAttribute(prefixCode + s,a);
59726 : }
59727 : #endif
59728 :
59729 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
59730 0 : return this;
59731 : }
59732 :
59733 : // *** COMMON CODE SECTION ENDS HERE ***
59734 :
59735 :
59736 : // End of memberFunctionString
59737 : // Start of memberFunctionString
59738 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
59739 :
59740 :
59741 : #if 0
59742 : //! Error checking support
59743 : /*! Verifies the following:
59744 : - working getVariant() member function
59745 : - calls base class's error() member function
59746 : Every class has one of these functions.
59747 : */
59748 : bool
59749 : SgTypeUnsignedLongLong::error()
59750 : {
59751 : // Put error checking here
59752 :
59753 : ROSE_ASSERT (this != NULL);
59754 : if (getVariant() != T_UNSIGNED_LONG_LONG)
59755 : {
59756 : printf ("Error in SgTypeUnsignedLongLong::error(): SgTypeUnsignedLongLong object has a %s variant \n",
59757 : Cxx_GrammarTerminalNames[getVariant()].name);
59758 : // printf ("Error in SgTypeUnsignedLongLong::error() \n");
59759 : ROSE_ABORT();
59760 : }
59761 :
59762 : ROSE_ASSERT (getVariant() == T_UNSIGNED_LONG_LONG);
59763 : return SgType::error();
59764 : }
59765 : #endif
59766 :
59767 :
59768 :
59769 : // End of memberFunctionString
59770 : // Start of memberFunctionString
59771 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
59772 :
59773 :
59774 : // DQ (1/31/2006): Modified to build all types in the memory pools
59775 : // SgTypeUnsignedLongLong SgTypeUnsignedLongLong::builtin_type;
59776 : // SgTypeUnsignedLongLong* SgTypeUnsignedLongLong::builtin_type = new SgTypeUnsignedLongLong();
59777 : SgTypeUnsignedLongLong* SgTypeUnsignedLongLong::p_builtin_type = NULL;
59778 :
59779 :
59780 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
59781 : // SgTypeUnsignedLongLong* SgTypeUnsignedLongLong::createType(void)
59782 : SgTypeUnsignedLongLong*
59783 322 : SgTypeUnsignedLongLong::createType(SgExpression* optional_fortran_type_kind)
59784 : {
59785 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
59786 : // is not called (likely because static initialization is compiler dependent).
59787 : // DQ (1/31/2006): Modified to build all types in the memory pools
59788 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
59789 : // return &builtin_type;
59790 :
59791 : #if 0
59792 : printf ("In SgTypeUnsignedLongLong::createType() (COMMON_CREATE_TYPE) \n");
59793 : #endif
59794 :
59795 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
59796 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
59797 :
59798 322 : SgTypeUnsignedLongLong* temp_type = new SgTypeUnsignedLongLong();
59799 :
59800 : #if 0
59801 : printf ("In SgTypeUnsignedLongLong::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
59802 : #endif
59803 :
59804 : // DQ (10/31/2016): Added assertion.
59805 322 : ROSE_ASSERT(temp_type != NULL);
59806 :
59807 322 : if (optional_fortran_type_kind != NULL)
59808 : {
59809 : // DQ (10/31/2016): Added assertion.
59810 0 : ROSE_ASSERT(temp_type != NULL);
59811 :
59812 0 : temp_type->set_type_kind(optional_fortran_type_kind);
59813 : }
59814 : #if 0
59815 : else
59816 : {
59817 : // Let p_builtin_type refer to the unadorned type (no type kind).
59818 : p_builtin_type = temp_type;
59819 : }
59820 : #endif
59821 :
59822 322 : SgName name = temp_type->get_mangled();
59823 :
59824 : #if 0
59825 : printf ("Mangled type name for SgTypeUnsignedLongLong = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
59826 : #endif
59827 :
59828 : // DQ (10/31/2016): Added assertion.
59829 322 : ROSE_ASSERT(get_globalTypeTable() != NULL);
59830 :
59831 322 : SgType* t = get_globalTypeTable()->lookup_type(name);
59832 :
59833 : #if 0
59834 : printf ("In SgTypeUnsignedLongLong::createType(): type from lookup_type = %p \n",t);
59835 : #endif
59836 :
59837 322 : if (t == NULL)
59838 : {
59839 315 : get_globalTypeTable()->insert_type(name,temp_type);
59840 : }
59841 : else
59842 : {
59843 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
59844 7 : if (t != temp_type)
59845 : {
59846 : #if 0
59847 : printf ("In SgTypeUnsignedLongLong::createType(): deleting temp_type = %p \n",temp_type);
59848 : #endif
59849 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
59850 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
59851 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
59852 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
59853 7 : delete temp_type;
59854 : #endif
59855 7 : temp_type = NULL;
59856 : #if 0
59857 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
59858 : if (optional_fortran_type_kind != NULL)
59859 : {
59860 : p_builtin_type = NULL;
59861 : }
59862 : #endif
59863 : }
59864 :
59865 : // Reuse this tempType variable so we can use the same code below.
59866 7 : temp_type = isSgTypeUnsignedLongLong(t);
59867 7 : ROSE_ASSERT(temp_type != NULL);
59868 : }
59869 :
59870 : #if 0
59871 : printf ("Leaving SgTypeUnsignedLongLong::createType(): temp_type = %p \n",temp_type);
59872 : #endif
59873 :
59874 322 : return temp_type;
59875 : }
59876 :
59877 :
59878 :
59879 : // End of memberFunctionString
59880 : // Start of memberFunctionString
59881 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
59882 :
59883 : #if 1
59884 : /*! Support for mangled names (for unparser)
59885 : There are two different cases of source code for the get_mangled member function
59886 : This one is used in all but the classes containing a base type
59887 : */
59888 : // SgName SgTypeUnsignedLongLong::get_mangled ( SgUnparse_Info & info )
59889 : SgName
59890 70546 : SgTypeUnsignedLongLong::get_mangled (void) const
59891 : {
59892 70546 : ROSE_ASSERT(this != NULL);
59893 :
59894 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
59895 : // CR (3/6/2020): Now type_kind is also used for Jovial.
59896 70546 : SgName name = "UL";
59897 70546 : if (get_type_kind() != NULL)
59898 : {
59899 : // name += get_type_kind()->get_mangled();
59900 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
59901 0 : SgValueExp* value = isSgValueExp(get_type_kind());
59902 0 : if (value != NULL)
59903 : {
59904 : // name += string("_") + StringUtility::numberToString(value->get_value());
59905 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
59906 : }
59907 : else
59908 : {
59909 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
59910 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
59911 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
59912 : // a different prefix for each type of named type. It come down to is there can be multiple
59913 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
59914 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
59915 : // I think the issue is that UL is not defined for any of the SgNameType IR nodes.
59916 : #if 0
59917 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"UL");
59918 : #endif
59919 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
59920 : }
59921 : }
59922 :
59923 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
59924 : // REMOVE_ME please!
59925 70546 : if (isSgTypeFixed(this))
59926 : {
59927 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
59928 0 : if (fixed_type->get_scale() != NULL)
59929 : {
59930 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
59931 0 : if (value != NULL)
59932 : {
59933 0 : name += string("_") + value->get_constant_folded_value_as_string();
59934 : }
59935 : }
59936 0 : if (fixed_type->get_fraction() != NULL)
59937 : {
59938 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
59939 0 : if (value != NULL)
59940 : {
59941 0 : name += string("_") + value->get_constant_folded_value_as_string();
59942 : }
59943 : }
59944 : }
59945 :
59946 : #if 0
59947 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
59948 : #endif
59949 :
59950 70546 : return name;
59951 : }
59952 : #endif
59953 :
59954 :
59955 : // End of memberFunctionString
59956 :
59957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
59958 :
59959 329 : SgTypeUnsignedLongLong* isSgTypeUnsignedLongLong ( SgNode* inputDerivedClassPointer )
59960 : {
59961 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
59962 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
59963 : // So to fix this we return NULL directly when the input is NULL and avoid the
59964 : // dynamic_cast in this case. This is likely a performance improvement as well.
59965 : // return dynamic_cast<SgTypeUnsignedLongLong*>(inputDerivedClassPointer);
59966 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedLongLong uses table-driven castability instead of c++ default dynamic_cast
59967 : // this improves the running time performance by 10-20%.
59968 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnsignedLongLong*>(inputDerivedClassPointer);
59969 329 : return IS_SgTypeUnsignedLongLong_FAST_MACRO(inputDerivedClassPointer);
59970 : }
59971 :
59972 : // DQ (11/8/2003): Added version of functions taking const pointer
59973 0 : const SgTypeUnsignedLongLong* isSgTypeUnsignedLongLong ( const SgNode* inputDerivedClassPointer )
59974 : {
59975 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
59976 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
59977 : // So to fix this we return NULL directly when the input is NULL and avoid the
59978 : // dynamic_cast in this case. This is likely a performance improvement as well.
59979 : // return dynamic_cast<const SgTypeUnsignedLongLong*>(inputDerivedClassPointer);
59980 : // Milind Chabbi (8/28/2013): isSgTypeUnsignedLongLong uses table-driven castability instead of c++ default dynamic_cast
59981 : // this improves the running time performance by 10-20%.
59982 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnsignedLongLong*>(inputDerivedClassPointer);
59983 0 : return IS_SgTypeUnsignedLongLong_FAST_MACRO(inputDerivedClassPointer);
59984 : }
59985 :
59986 :
59987 :
59988 : /* #line 59989 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
59989 :
59990 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
59991 :
59992 : /**
59993 : \brief Generated destructor
59994 :
59995 : This destructor is automatically generated (by ROSETTA). This destructor
59996 : only frees memory of data members associated with the parts of the current IR node which
59997 : are NOT traversed. Those data members that are part of a traversal can be freed using
59998 : a traversal (calling this destructor on all children in a post-order traversal). Such
59999 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
60000 :
60001 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
60002 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
60003 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
60004 :
60005 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
60006 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
60007 : pointers are not yet implemented to call delete on eash pointer in the container.
60008 : (This could be done by derivation from the STL containers to define containers that
60009 : automatically deleted their members.)
60010 :
60011 : */
60012 22 : SgTypeUnsignedLongLong::~SgTypeUnsignedLongLong () {
60013 11 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
60014 :
60015 :
60016 :
60017 : }
60018 :
60019 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
60020 22 : }
60021 :
60022 :
60023 : /* #line 60024 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60024 :
60025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
60026 :
60027 : // Generated constructor
60028 322 : SgTypeUnsignedLongLong::SgTypeUnsignedLongLong ( )
60029 322 : : SgType()
60030 : {
60031 : #ifdef DEBUG
60032 : // printf ("In SgTypeUnsignedLongLong::SgTypeUnsignedLongLong () sage_class_name() = %s \n",sage_class_name());
60033 : #endif
60034 : #if 0
60035 : // debugging information!
60036 : printf ("In SgTypeUnsignedLongLong::SgTypeUnsignedLongLong (): this = %p = %s \n",this,this->class_name().c_str());
60037 : #endif
60038 :
60039 :
60040 :
60041 : #if 0
60042 : // DQ (7/30/2014): Call a virtual function.
60043 : std::string s = this->class_name();
60044 : #endif
60045 :
60046 : // Test the variant virtual function
60047 : // assert(T_UNSIGNED_LONG_LONG == variant());
60048 322 : assert(T_UNSIGNED_LONG_LONG == this->variant());
60049 322 : ROSE_ASSERT(T_UNSIGNED_LONG_LONG == (int)(this->variantT()));
60050 322 : post_construction_initialization();
60051 :
60052 : // Test the isSgTypeUnsignedLongLong() function since it has been problematic
60053 322 : assert(isSgTypeUnsignedLongLong(this) != NULL);
60054 322 : }
60055 :
60056 : // Generated constructor (all data members)
60057 :
60058 : /* #line 60059 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60059 :
60060 :
60061 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
60062 :
60063 :
60064 : // ********************************************************
60065 : // member functions common across all array grammar objects
60066 : // ********************************************************
60067 :
60068 :
60069 :
60070 : /* #line 60071 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60071 :
60072 :
60073 :
60074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
60075 :
60076 : // ********************************************************
60077 : // member functions specific to each node in the grammar
60078 : // ********************************************************
60079 :
60080 :
60081 : /* #line 60082 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60082 :
60083 : // Start of memberFunctionString
60084 :
60085 :
60086 : // End of memberFunctionString
60087 : // Start of memberFunctionString
60088 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
60089 :
60090 : // *** COMMON CODE SECTION BEGINS HERE ***
60091 :
60092 : #if 0
60093 : int
60094 : SgTypeSigned128bitInteger::getVariant() const
60095 : {
60096 : // This function is used in ROSE while "variant()" is used in SAGE
60097 : assert(this != NULL);
60098 : return variant();
60099 : }
60100 : #endif
60101 :
60102 : // This function is used in ROSE in treeTraversal code
60103 : // eventually replaces getVariant() and variant()
60104 : // though after variant() has been removed for a while we will
60105 : // want to change the name of variantT() back to variant()
60106 : // (since the "T" was ment to stand for temporary).
60107 : // When this happens the variantT() will be depricated.
60108 : VariantT
60109 3365490 : SgTypeSigned128bitInteger::variantT() const
60110 : {
60111 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
60112 3365490 : ROSE_ASSERT(this != NULL);
60113 3365490 : return V_SgTypeSigned128bitInteger;
60114 : }
60115 :
60116 : #if 0
60117 : int
60118 : SgTypeSigned128bitInteger::variant() const
60119 : {
60120 : // This function is used in SAGE
60121 : ROSE_ASSERT(this != NULL);
60122 : return T_SIGNED_128BIT_INTEGER;
60123 : }
60124 : #endif
60125 :
60126 : ROSE_DLL_API const char*
60127 0 : SgTypeSigned128bitInteger::sage_class_name() const
60128 : {
60129 0 : ROSE_ASSERT(this != NULL);
60130 0 : return "SgTypeSigned128bitInteger";
60131 : }
60132 :
60133 : std::string
60134 50 : SgTypeSigned128bitInteger::class_name() const
60135 : {
60136 50 : ROSE_ASSERT(this != NULL);
60137 50 : return "SgTypeSigned128bitInteger";
60138 : }
60139 :
60140 : // DQ (11/26/2005): Support for visitor pattern mechanims
60141 : // (inferior to ROSE traversal mechanism, experimental).
60142 : void
60143 194 : SgTypeSigned128bitInteger::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
60144 : {
60145 194 : ROSE_ASSERT(this != NULL);
60146 194 : visitor.visit(this);
60147 194 : }
60148 :
60149 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
60150 0 : void SgTypeSigned128bitInteger::accept (ROSE_VisitorPattern & visitor) {
60151 0 : ROSE_ASSERT(this != NULL);
60152 0 : visitor.visit(this);
60153 0 : }
60154 :
60155 : SgTypeSigned128bitInteger*
60156 0 : SgTypeSigned128bitInteger::addRegExpAttribute(std::string s, AstRegExAttribute* a)
60157 : {
60158 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
60159 : // This function is currently only supported for the AST used the represent Binary executables.
60160 : if (0 /* isSgAsmNode(this) != NULL */)
60161 : {
60162 : // Support for regex specification.
60163 : std::string prefixCode = "REGEX:";
60164 : addNewAttribute(prefixCode + s,a);
60165 : }
60166 : #endif
60167 :
60168 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
60169 0 : return this;
60170 : }
60171 :
60172 : // *** COMMON CODE SECTION ENDS HERE ***
60173 :
60174 :
60175 : // End of memberFunctionString
60176 : // Start of memberFunctionString
60177 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
60178 :
60179 :
60180 : #if 0
60181 : //! Error checking support
60182 : /*! Verifies the following:
60183 : - working getVariant() member function
60184 : - calls base class's error() member function
60185 : Every class has one of these functions.
60186 : */
60187 : bool
60188 : SgTypeSigned128bitInteger::error()
60189 : {
60190 : // Put error checking here
60191 :
60192 : ROSE_ASSERT (this != NULL);
60193 : if (getVariant() != T_SIGNED_128BIT_INTEGER)
60194 : {
60195 : printf ("Error in SgTypeSigned128bitInteger::error(): SgTypeSigned128bitInteger object has a %s variant \n",
60196 : Cxx_GrammarTerminalNames[getVariant()].name);
60197 : // printf ("Error in SgTypeSigned128bitInteger::error() \n");
60198 : ROSE_ABORT();
60199 : }
60200 :
60201 : ROSE_ASSERT (getVariant() == T_SIGNED_128BIT_INTEGER);
60202 : return SgType::error();
60203 : }
60204 : #endif
60205 :
60206 :
60207 :
60208 : // End of memberFunctionString
60209 : // Start of memberFunctionString
60210 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
60211 :
60212 :
60213 : // DQ (1/31/2006): Modified to build all types in the memory pools
60214 : // SgTypeSigned128bitInteger SgTypeSigned128bitInteger::builtin_type;
60215 : // SgTypeSigned128bitInteger* SgTypeSigned128bitInteger::builtin_type = new SgTypeSigned128bitInteger();
60216 : SgTypeSigned128bitInteger* SgTypeSigned128bitInteger::p_builtin_type = NULL;
60217 :
60218 :
60219 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
60220 : // SgTypeSigned128bitInteger* SgTypeSigned128bitInteger::createType(void)
60221 : SgTypeSigned128bitInteger*
60222 66 : SgTypeSigned128bitInteger::createType(SgExpression* optional_fortran_type_kind)
60223 : {
60224 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
60225 : // is not called (likely because static initialization is compiler dependent).
60226 : // DQ (1/31/2006): Modified to build all types in the memory pools
60227 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
60228 : // return &builtin_type;
60229 :
60230 : #if 0
60231 : printf ("In SgTypeSigned128bitInteger::createType() (COMMON_CREATE_TYPE) \n");
60232 : #endif
60233 :
60234 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
60235 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
60236 :
60237 66 : SgTypeSigned128bitInteger* temp_type = new SgTypeSigned128bitInteger();
60238 :
60239 : #if 0
60240 : printf ("In SgTypeSigned128bitInteger::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
60241 : #endif
60242 :
60243 : // DQ (10/31/2016): Added assertion.
60244 66 : ROSE_ASSERT(temp_type != NULL);
60245 :
60246 66 : if (optional_fortran_type_kind != NULL)
60247 : {
60248 : // DQ (10/31/2016): Added assertion.
60249 0 : ROSE_ASSERT(temp_type != NULL);
60250 :
60251 0 : temp_type->set_type_kind(optional_fortran_type_kind);
60252 : }
60253 : #if 0
60254 : else
60255 : {
60256 : // Let p_builtin_type refer to the unadorned type (no type kind).
60257 : p_builtin_type = temp_type;
60258 : }
60259 : #endif
60260 :
60261 66 : SgName name = temp_type->get_mangled();
60262 :
60263 : #if 0
60264 : printf ("Mangled type name for SgTypeSigned128bitInteger = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
60265 : #endif
60266 :
60267 : // DQ (10/31/2016): Added assertion.
60268 66 : ROSE_ASSERT(get_globalTypeTable() != NULL);
60269 :
60270 66 : SgType* t = get_globalTypeTable()->lookup_type(name);
60271 :
60272 : #if 0
60273 : printf ("In SgTypeSigned128bitInteger::createType(): type from lookup_type = %p \n",t);
60274 : #endif
60275 :
60276 66 : if (t == NULL)
60277 : {
60278 62 : get_globalTypeTable()->insert_type(name,temp_type);
60279 : }
60280 : else
60281 : {
60282 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
60283 4 : if (t != temp_type)
60284 : {
60285 : #if 0
60286 : printf ("In SgTypeSigned128bitInteger::createType(): deleting temp_type = %p \n",temp_type);
60287 : #endif
60288 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
60289 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
60290 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
60291 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
60292 4 : delete temp_type;
60293 : #endif
60294 4 : temp_type = NULL;
60295 : #if 0
60296 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
60297 : if (optional_fortran_type_kind != NULL)
60298 : {
60299 : p_builtin_type = NULL;
60300 : }
60301 : #endif
60302 : }
60303 :
60304 : // Reuse this tempType variable so we can use the same code below.
60305 4 : temp_type = isSgTypeSigned128bitInteger(t);
60306 4 : ROSE_ASSERT(temp_type != NULL);
60307 : }
60308 :
60309 : #if 0
60310 : printf ("Leaving SgTypeSigned128bitInteger::createType(): temp_type = %p \n",temp_type);
60311 : #endif
60312 :
60313 66 : return temp_type;
60314 : }
60315 :
60316 :
60317 :
60318 : // End of memberFunctionString
60319 : // Start of memberFunctionString
60320 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
60321 :
60322 : #if 1
60323 : /*! Support for mangled names (for unparser)
60324 : There are two different cases of source code for the get_mangled member function
60325 : This one is used in all but the classes containing a base type
60326 : */
60327 : // SgName SgTypeSigned128bitInteger::get_mangled ( SgUnparse_Info & info )
60328 : SgName
60329 12615 : SgTypeSigned128bitInteger::get_mangled (void) const
60330 : {
60331 12615 : ROSE_ASSERT(this != NULL);
60332 :
60333 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
60334 : // CR (3/6/2020): Now type_kind is also used for Jovial.
60335 12615 : SgName name = "SL128";
60336 12615 : if (get_type_kind() != NULL)
60337 : {
60338 : // name += get_type_kind()->get_mangled();
60339 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
60340 0 : SgValueExp* value = isSgValueExp(get_type_kind());
60341 0 : if (value != NULL)
60342 : {
60343 : // name += string("_") + StringUtility::numberToString(value->get_value());
60344 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
60345 : }
60346 : else
60347 : {
60348 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
60349 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
60350 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
60351 : // a different prefix for each type of named type. It come down to is there can be multiple
60352 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
60353 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
60354 : // I think the issue is that SL128 is not defined for any of the SgNameType IR nodes.
60355 : #if 0
60356 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"SL128");
60357 : #endif
60358 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
60359 : }
60360 : }
60361 :
60362 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
60363 : // REMOVE_ME please!
60364 12615 : if (isSgTypeFixed(this))
60365 : {
60366 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
60367 0 : if (fixed_type->get_scale() != NULL)
60368 : {
60369 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
60370 0 : if (value != NULL)
60371 : {
60372 0 : name += string("_") + value->get_constant_folded_value_as_string();
60373 : }
60374 : }
60375 0 : if (fixed_type->get_fraction() != NULL)
60376 : {
60377 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
60378 0 : if (value != NULL)
60379 : {
60380 0 : name += string("_") + value->get_constant_folded_value_as_string();
60381 : }
60382 : }
60383 : }
60384 :
60385 : #if 0
60386 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
60387 : #endif
60388 :
60389 12615 : return name;
60390 : }
60391 : #endif
60392 :
60393 :
60394 : // End of memberFunctionString
60395 :
60396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
60397 :
60398 70 : SgTypeSigned128bitInteger* isSgTypeSigned128bitInteger ( SgNode* inputDerivedClassPointer )
60399 : {
60400 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
60401 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
60402 : // So to fix this we return NULL directly when the input is NULL and avoid the
60403 : // dynamic_cast in this case. This is likely a performance improvement as well.
60404 : // return dynamic_cast<SgTypeSigned128bitInteger*>(inputDerivedClassPointer);
60405 : // Milind Chabbi (8/28/2013): isSgTypeSigned128bitInteger uses table-driven castability instead of c++ default dynamic_cast
60406 : // this improves the running time performance by 10-20%.
60407 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeSigned128bitInteger*>(inputDerivedClassPointer);
60408 70 : return IS_SgTypeSigned128bitInteger_FAST_MACRO(inputDerivedClassPointer);
60409 : }
60410 :
60411 : // DQ (11/8/2003): Added version of functions taking const pointer
60412 0 : const SgTypeSigned128bitInteger* isSgTypeSigned128bitInteger ( const SgNode* inputDerivedClassPointer )
60413 : {
60414 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
60415 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
60416 : // So to fix this we return NULL directly when the input is NULL and avoid the
60417 : // dynamic_cast in this case. This is likely a performance improvement as well.
60418 : // return dynamic_cast<const SgTypeSigned128bitInteger*>(inputDerivedClassPointer);
60419 : // Milind Chabbi (8/28/2013): isSgTypeSigned128bitInteger uses table-driven castability instead of c++ default dynamic_cast
60420 : // this improves the running time performance by 10-20%.
60421 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeSigned128bitInteger*>(inputDerivedClassPointer);
60422 0 : return IS_SgTypeSigned128bitInteger_FAST_MACRO(inputDerivedClassPointer);
60423 : }
60424 :
60425 :
60426 :
60427 : /* #line 60428 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60428 :
60429 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
60430 :
60431 : /**
60432 : \brief Generated destructor
60433 :
60434 : This destructor is automatically generated (by ROSETTA). This destructor
60435 : only frees memory of data members associated with the parts of the current IR node which
60436 : are NOT traversed. Those data members that are part of a traversal can be freed using
60437 : a traversal (calling this destructor on all children in a post-order traversal). Such
60438 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
60439 :
60440 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
60441 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
60442 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
60443 :
60444 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
60445 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
60446 : pointers are not yet implemented to call delete on eash pointer in the container.
60447 : (This could be done by derivation from the STL containers to define containers that
60448 : automatically deleted their members.)
60449 :
60450 : */
60451 12 : SgTypeSigned128bitInteger::~SgTypeSigned128bitInteger () {
60452 6 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
60453 :
60454 :
60455 :
60456 : }
60457 :
60458 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
60459 12 : }
60460 :
60461 :
60462 : /* #line 60463 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60463 :
60464 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
60465 :
60466 : // Generated constructor
60467 66 : SgTypeSigned128bitInteger::SgTypeSigned128bitInteger ( )
60468 66 : : SgType()
60469 : {
60470 : #ifdef DEBUG
60471 : // printf ("In SgTypeSigned128bitInteger::SgTypeSigned128bitInteger () sage_class_name() = %s \n",sage_class_name());
60472 : #endif
60473 : #if 0
60474 : // debugging information!
60475 : printf ("In SgTypeSigned128bitInteger::SgTypeSigned128bitInteger (): this = %p = %s \n",this,this->class_name().c_str());
60476 : #endif
60477 :
60478 :
60479 :
60480 : #if 0
60481 : // DQ (7/30/2014): Call a virtual function.
60482 : std::string s = this->class_name();
60483 : #endif
60484 :
60485 : // Test the variant virtual function
60486 : // assert(T_SIGNED_128BIT_INTEGER == variant());
60487 66 : assert(T_SIGNED_128BIT_INTEGER == this->variant());
60488 66 : ROSE_ASSERT(T_SIGNED_128BIT_INTEGER == (int)(this->variantT()));
60489 66 : post_construction_initialization();
60490 :
60491 : // Test the isSgTypeSigned128bitInteger() function since it has been problematic
60492 66 : assert(isSgTypeSigned128bitInteger(this) != NULL);
60493 66 : }
60494 :
60495 : // Generated constructor (all data members)
60496 :
60497 : /* #line 60498 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60498 :
60499 :
60500 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
60501 :
60502 :
60503 : // ********************************************************
60504 : // member functions common across all array grammar objects
60505 : // ********************************************************
60506 :
60507 :
60508 :
60509 : /* #line 60510 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60510 :
60511 :
60512 :
60513 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
60514 :
60515 : // ********************************************************
60516 : // member functions specific to each node in the grammar
60517 : // ********************************************************
60518 :
60519 :
60520 : /* #line 60521 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60521 :
60522 : // Start of memberFunctionString
60523 :
60524 :
60525 : // End of memberFunctionString
60526 : // Start of memberFunctionString
60527 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
60528 :
60529 : // *** COMMON CODE SECTION BEGINS HERE ***
60530 :
60531 : #if 0
60532 : int
60533 : SgTypeUnsigned128bitInteger::getVariant() const
60534 : {
60535 : // This function is used in ROSE while "variant()" is used in SAGE
60536 : assert(this != NULL);
60537 : return variant();
60538 : }
60539 : #endif
60540 :
60541 : // This function is used in ROSE in treeTraversal code
60542 : // eventually replaces getVariant() and variant()
60543 : // though after variant() has been removed for a while we will
60544 : // want to change the name of variantT() back to variant()
60545 : // (since the "T" was ment to stand for temporary).
60546 : // When this happens the variantT() will be depricated.
60547 : VariantT
60548 52048 : SgTypeUnsigned128bitInteger::variantT() const
60549 : {
60550 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
60551 52048 : ROSE_ASSERT(this != NULL);
60552 52048 : return V_SgTypeUnsigned128bitInteger;
60553 : }
60554 :
60555 : #if 0
60556 : int
60557 : SgTypeUnsigned128bitInteger::variant() const
60558 : {
60559 : // This function is used in SAGE
60560 : ROSE_ASSERT(this != NULL);
60561 : return T_UNSIGNED_128BIT_INTEGER;
60562 : }
60563 : #endif
60564 :
60565 : ROSE_DLL_API const char*
60566 0 : SgTypeUnsigned128bitInteger::sage_class_name() const
60567 : {
60568 0 : ROSE_ASSERT(this != NULL);
60569 0 : return "SgTypeUnsigned128bitInteger";
60570 : }
60571 :
60572 : std::string
60573 8 : SgTypeUnsigned128bitInteger::class_name() const
60574 : {
60575 8 : ROSE_ASSERT(this != NULL);
60576 8 : return "SgTypeUnsigned128bitInteger";
60577 : }
60578 :
60579 : // DQ (11/26/2005): Support for visitor pattern mechanims
60580 : // (inferior to ROSE traversal mechanism, experimental).
60581 : void
60582 137 : SgTypeUnsigned128bitInteger::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
60583 : {
60584 137 : ROSE_ASSERT(this != NULL);
60585 137 : visitor.visit(this);
60586 137 : }
60587 :
60588 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
60589 0 : void SgTypeUnsigned128bitInteger::accept (ROSE_VisitorPattern & visitor) {
60590 0 : ROSE_ASSERT(this != NULL);
60591 0 : visitor.visit(this);
60592 0 : }
60593 :
60594 : SgTypeUnsigned128bitInteger*
60595 0 : SgTypeUnsigned128bitInteger::addRegExpAttribute(std::string s, AstRegExAttribute* a)
60596 : {
60597 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
60598 : // This function is currently only supported for the AST used the represent Binary executables.
60599 : if (0 /* isSgAsmNode(this) != NULL */)
60600 : {
60601 : // Support for regex specification.
60602 : std::string prefixCode = "REGEX:";
60603 : addNewAttribute(prefixCode + s,a);
60604 : }
60605 : #endif
60606 :
60607 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
60608 0 : return this;
60609 : }
60610 :
60611 : // *** COMMON CODE SECTION ENDS HERE ***
60612 :
60613 :
60614 : // End of memberFunctionString
60615 : // Start of memberFunctionString
60616 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
60617 :
60618 :
60619 : #if 0
60620 : //! Error checking support
60621 : /*! Verifies the following:
60622 : - working getVariant() member function
60623 : - calls base class's error() member function
60624 : Every class has one of these functions.
60625 : */
60626 : bool
60627 : SgTypeUnsigned128bitInteger::error()
60628 : {
60629 : // Put error checking here
60630 :
60631 : ROSE_ASSERT (this != NULL);
60632 : if (getVariant() != T_UNSIGNED_128BIT_INTEGER)
60633 : {
60634 : printf ("Error in SgTypeUnsigned128bitInteger::error(): SgTypeUnsigned128bitInteger object has a %s variant \n",
60635 : Cxx_GrammarTerminalNames[getVariant()].name);
60636 : // printf ("Error in SgTypeUnsigned128bitInteger::error() \n");
60637 : ROSE_ABORT();
60638 : }
60639 :
60640 : ROSE_ASSERT (getVariant() == T_UNSIGNED_128BIT_INTEGER);
60641 : return SgType::error();
60642 : }
60643 : #endif
60644 :
60645 :
60646 :
60647 : // End of memberFunctionString
60648 : // Start of memberFunctionString
60649 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
60650 :
60651 :
60652 : // DQ (1/31/2006): Modified to build all types in the memory pools
60653 : // SgTypeUnsigned128bitInteger SgTypeUnsigned128bitInteger::builtin_type;
60654 : // SgTypeUnsigned128bitInteger* SgTypeUnsigned128bitInteger::builtin_type = new SgTypeUnsigned128bitInteger();
60655 : SgTypeUnsigned128bitInteger* SgTypeUnsigned128bitInteger::p_builtin_type = NULL;
60656 :
60657 :
60658 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
60659 : // SgTypeUnsigned128bitInteger* SgTypeUnsigned128bitInteger::createType(void)
60660 : SgTypeUnsigned128bitInteger*
60661 10 : SgTypeUnsigned128bitInteger::createType(SgExpression* optional_fortran_type_kind)
60662 : {
60663 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
60664 : // is not called (likely because static initialization is compiler dependent).
60665 : // DQ (1/31/2006): Modified to build all types in the memory pools
60666 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
60667 : // return &builtin_type;
60668 :
60669 : #if 0
60670 : printf ("In SgTypeUnsigned128bitInteger::createType() (COMMON_CREATE_TYPE) \n");
60671 : #endif
60672 :
60673 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
60674 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
60675 :
60676 10 : SgTypeUnsigned128bitInteger* temp_type = new SgTypeUnsigned128bitInteger();
60677 :
60678 : #if 0
60679 : printf ("In SgTypeUnsigned128bitInteger::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
60680 : #endif
60681 :
60682 : // DQ (10/31/2016): Added assertion.
60683 10 : ROSE_ASSERT(temp_type != NULL);
60684 :
60685 10 : if (optional_fortran_type_kind != NULL)
60686 : {
60687 : // DQ (10/31/2016): Added assertion.
60688 0 : ROSE_ASSERT(temp_type != NULL);
60689 :
60690 0 : temp_type->set_type_kind(optional_fortran_type_kind);
60691 : }
60692 : #if 0
60693 : else
60694 : {
60695 : // Let p_builtin_type refer to the unadorned type (no type kind).
60696 : p_builtin_type = temp_type;
60697 : }
60698 : #endif
60699 :
60700 10 : SgName name = temp_type->get_mangled();
60701 :
60702 : #if 0
60703 : printf ("Mangled type name for SgTypeUnsigned128bitInteger = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
60704 : #endif
60705 :
60706 : // DQ (10/31/2016): Added assertion.
60707 10 : ROSE_ASSERT(get_globalTypeTable() != NULL);
60708 :
60709 10 : SgType* t = get_globalTypeTable()->lookup_type(name);
60710 :
60711 : #if 0
60712 : printf ("In SgTypeUnsigned128bitInteger::createType(): type from lookup_type = %p \n",t);
60713 : #endif
60714 :
60715 10 : if (t == NULL)
60716 : {
60717 10 : get_globalTypeTable()->insert_type(name,temp_type);
60718 : }
60719 : else
60720 : {
60721 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
60722 0 : if (t != temp_type)
60723 : {
60724 : #if 0
60725 : printf ("In SgTypeUnsigned128bitInteger::createType(): deleting temp_type = %p \n",temp_type);
60726 : #endif
60727 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
60728 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
60729 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
60730 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
60731 0 : delete temp_type;
60732 : #endif
60733 0 : temp_type = NULL;
60734 : #if 0
60735 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
60736 : if (optional_fortran_type_kind != NULL)
60737 : {
60738 : p_builtin_type = NULL;
60739 : }
60740 : #endif
60741 : }
60742 :
60743 : // Reuse this tempType variable so we can use the same code below.
60744 0 : temp_type = isSgTypeUnsigned128bitInteger(t);
60745 0 : ROSE_ASSERT(temp_type != NULL);
60746 : }
60747 :
60748 : #if 0
60749 : printf ("Leaving SgTypeUnsigned128bitInteger::createType(): temp_type = %p \n",temp_type);
60750 : #endif
60751 :
60752 10 : return temp_type;
60753 : }
60754 :
60755 :
60756 :
60757 : // End of memberFunctionString
60758 : // Start of memberFunctionString
60759 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
60760 :
60761 : #if 1
60762 : /*! Support for mangled names (for unparser)
60763 : There are two different cases of source code for the get_mangled member function
60764 : This one is used in all but the classes containing a base type
60765 : */
60766 : // SgName SgTypeUnsigned128bitInteger::get_mangled ( SgUnparse_Info & info )
60767 : SgName
60768 301 : SgTypeUnsigned128bitInteger::get_mangled (void) const
60769 : {
60770 301 : ROSE_ASSERT(this != NULL);
60771 :
60772 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
60773 : // CR (3/6/2020): Now type_kind is also used for Jovial.
60774 301 : SgName name = "UL128";
60775 301 : if (get_type_kind() != NULL)
60776 : {
60777 : // name += get_type_kind()->get_mangled();
60778 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
60779 0 : SgValueExp* value = isSgValueExp(get_type_kind());
60780 0 : if (value != NULL)
60781 : {
60782 : // name += string("_") + StringUtility::numberToString(value->get_value());
60783 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
60784 : }
60785 : else
60786 : {
60787 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
60788 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
60789 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
60790 : // a different prefix for each type of named type. It come down to is there can be multiple
60791 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
60792 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
60793 : // I think the issue is that UL128 is not defined for any of the SgNameType IR nodes.
60794 : #if 0
60795 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"UL128");
60796 : #endif
60797 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
60798 : }
60799 : }
60800 :
60801 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
60802 : // REMOVE_ME please!
60803 301 : if (isSgTypeFixed(this))
60804 : {
60805 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
60806 0 : if (fixed_type->get_scale() != NULL)
60807 : {
60808 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
60809 0 : if (value != NULL)
60810 : {
60811 0 : name += string("_") + value->get_constant_folded_value_as_string();
60812 : }
60813 : }
60814 0 : if (fixed_type->get_fraction() != NULL)
60815 : {
60816 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
60817 0 : if (value != NULL)
60818 : {
60819 0 : name += string("_") + value->get_constant_folded_value_as_string();
60820 : }
60821 : }
60822 : }
60823 :
60824 : #if 0
60825 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
60826 : #endif
60827 :
60828 301 : return name;
60829 : }
60830 : #endif
60831 :
60832 :
60833 : // End of memberFunctionString
60834 :
60835 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
60836 :
60837 10 : SgTypeUnsigned128bitInteger* isSgTypeUnsigned128bitInteger ( SgNode* inputDerivedClassPointer )
60838 : {
60839 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
60840 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
60841 : // So to fix this we return NULL directly when the input is NULL and avoid the
60842 : // dynamic_cast in this case. This is likely a performance improvement as well.
60843 : // return dynamic_cast<SgTypeUnsigned128bitInteger*>(inputDerivedClassPointer);
60844 : // Milind Chabbi (8/28/2013): isSgTypeUnsigned128bitInteger uses table-driven castability instead of c++ default dynamic_cast
60845 : // this improves the running time performance by 10-20%.
60846 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeUnsigned128bitInteger*>(inputDerivedClassPointer);
60847 10 : return IS_SgTypeUnsigned128bitInteger_FAST_MACRO(inputDerivedClassPointer);
60848 : }
60849 :
60850 : // DQ (11/8/2003): Added version of functions taking const pointer
60851 0 : const SgTypeUnsigned128bitInteger* isSgTypeUnsigned128bitInteger ( const SgNode* inputDerivedClassPointer )
60852 : {
60853 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
60854 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
60855 : // So to fix this we return NULL directly when the input is NULL and avoid the
60856 : // dynamic_cast in this case. This is likely a performance improvement as well.
60857 : // return dynamic_cast<const SgTypeUnsigned128bitInteger*>(inputDerivedClassPointer);
60858 : // Milind Chabbi (8/28/2013): isSgTypeUnsigned128bitInteger uses table-driven castability instead of c++ default dynamic_cast
60859 : // this improves the running time performance by 10-20%.
60860 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeUnsigned128bitInteger*>(inputDerivedClassPointer);
60861 0 : return IS_SgTypeUnsigned128bitInteger_FAST_MACRO(inputDerivedClassPointer);
60862 : }
60863 :
60864 :
60865 :
60866 : /* #line 60867 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60867 :
60868 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
60869 :
60870 : /**
60871 : \brief Generated destructor
60872 :
60873 : This destructor is automatically generated (by ROSETTA). This destructor
60874 : only frees memory of data members associated with the parts of the current IR node which
60875 : are NOT traversed. Those data members that are part of a traversal can be freed using
60876 : a traversal (calling this destructor on all children in a post-order traversal). Such
60877 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
60878 :
60879 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
60880 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
60881 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
60882 :
60883 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
60884 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
60885 : pointers are not yet implemented to call delete on eash pointer in the container.
60886 : (This could be done by derivation from the STL containers to define containers that
60887 : automatically deleted their members.)
60888 :
60889 : */
60890 4 : SgTypeUnsigned128bitInteger::~SgTypeUnsigned128bitInteger () {
60891 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
60892 :
60893 :
60894 :
60895 : }
60896 :
60897 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
60898 4 : }
60899 :
60900 :
60901 : /* #line 60902 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60902 :
60903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
60904 :
60905 : // Generated constructor
60906 10 : SgTypeUnsigned128bitInteger::SgTypeUnsigned128bitInteger ( )
60907 10 : : SgType()
60908 : {
60909 : #ifdef DEBUG
60910 : // printf ("In SgTypeUnsigned128bitInteger::SgTypeUnsigned128bitInteger () sage_class_name() = %s \n",sage_class_name());
60911 : #endif
60912 : #if 0
60913 : // debugging information!
60914 : printf ("In SgTypeUnsigned128bitInteger::SgTypeUnsigned128bitInteger (): this = %p = %s \n",this,this->class_name().c_str());
60915 : #endif
60916 :
60917 :
60918 :
60919 : #if 0
60920 : // DQ (7/30/2014): Call a virtual function.
60921 : std::string s = this->class_name();
60922 : #endif
60923 :
60924 : // Test the variant virtual function
60925 : // assert(T_UNSIGNED_128BIT_INTEGER == variant());
60926 10 : assert(T_UNSIGNED_128BIT_INTEGER == this->variant());
60927 10 : ROSE_ASSERT(T_UNSIGNED_128BIT_INTEGER == (int)(this->variantT()));
60928 10 : post_construction_initialization();
60929 :
60930 : // Test the isSgTypeUnsigned128bitInteger() function since it has been problematic
60931 10 : assert(isSgTypeUnsigned128bitInteger(this) != NULL);
60932 10 : }
60933 :
60934 : // Generated constructor (all data members)
60935 :
60936 : /* #line 60937 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60937 :
60938 :
60939 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
60940 :
60941 :
60942 : // ********************************************************
60943 : // member functions common across all array grammar objects
60944 : // ********************************************************
60945 :
60946 :
60947 :
60948 : /* #line 60949 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60949 :
60950 :
60951 :
60952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
60953 :
60954 : // ********************************************************
60955 : // member functions specific to each node in the grammar
60956 : // ********************************************************
60957 :
60958 :
60959 : /* #line 60960 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
60960 :
60961 : // Start of memberFunctionString
60962 :
60963 :
60964 : // End of memberFunctionString
60965 : // Start of memberFunctionString
60966 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
60967 :
60968 : // *** COMMON CODE SECTION BEGINS HERE ***
60969 :
60970 : #if 0
60971 : int
60972 : SgTypeFloat80::getVariant() const
60973 : {
60974 : // This function is used in ROSE while "variant()" is used in SAGE
60975 : assert(this != NULL);
60976 : return variant();
60977 : }
60978 : #endif
60979 :
60980 : // This function is used in ROSE in treeTraversal code
60981 : // eventually replaces getVariant() and variant()
60982 : // though after variant() has been removed for a while we will
60983 : // want to change the name of variantT() back to variant()
60984 : // (since the "T" was ment to stand for temporary).
60985 : // When this happens the variantT() will be depricated.
60986 : VariantT
60987 0 : SgTypeFloat80::variantT() const
60988 : {
60989 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
60990 0 : ROSE_ASSERT(this != NULL);
60991 0 : return V_SgTypeFloat80;
60992 : }
60993 :
60994 : #if 0
60995 : int
60996 : SgTypeFloat80::variant() const
60997 : {
60998 : // This function is used in SAGE
60999 : ROSE_ASSERT(this != NULL);
61000 : return T_FLOAT80;
61001 : }
61002 : #endif
61003 :
61004 : ROSE_DLL_API const char*
61005 0 : SgTypeFloat80::sage_class_name() const
61006 : {
61007 0 : ROSE_ASSERT(this != NULL);
61008 0 : return "SgTypeFloat80";
61009 : }
61010 :
61011 : std::string
61012 0 : SgTypeFloat80::class_name() const
61013 : {
61014 0 : ROSE_ASSERT(this != NULL);
61015 0 : return "SgTypeFloat80";
61016 : }
61017 :
61018 : // DQ (11/26/2005): Support for visitor pattern mechanims
61019 : // (inferior to ROSE traversal mechanism, experimental).
61020 : void
61021 0 : SgTypeFloat80::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
61022 : {
61023 0 : ROSE_ASSERT(this != NULL);
61024 0 : visitor.visit(this);
61025 0 : }
61026 :
61027 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
61028 0 : void SgTypeFloat80::accept (ROSE_VisitorPattern & visitor) {
61029 0 : ROSE_ASSERT(this != NULL);
61030 0 : visitor.visit(this);
61031 0 : }
61032 :
61033 : SgTypeFloat80*
61034 0 : SgTypeFloat80::addRegExpAttribute(std::string s, AstRegExAttribute* a)
61035 : {
61036 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
61037 : // This function is currently only supported for the AST used the represent Binary executables.
61038 : if (0 /* isSgAsmNode(this) != NULL */)
61039 : {
61040 : // Support for regex specification.
61041 : std::string prefixCode = "REGEX:";
61042 : addNewAttribute(prefixCode + s,a);
61043 : }
61044 : #endif
61045 :
61046 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
61047 0 : return this;
61048 : }
61049 :
61050 : // *** COMMON CODE SECTION ENDS HERE ***
61051 :
61052 :
61053 : // End of memberFunctionString
61054 : // Start of memberFunctionString
61055 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
61056 :
61057 :
61058 : #if 0
61059 : //! Error checking support
61060 : /*! Verifies the following:
61061 : - working getVariant() member function
61062 : - calls base class's error() member function
61063 : Every class has one of these functions.
61064 : */
61065 : bool
61066 : SgTypeFloat80::error()
61067 : {
61068 : // Put error checking here
61069 :
61070 : ROSE_ASSERT (this != NULL);
61071 : if (getVariant() != T_FLOAT80)
61072 : {
61073 : printf ("Error in SgTypeFloat80::error(): SgTypeFloat80 object has a %s variant \n",
61074 : Cxx_GrammarTerminalNames[getVariant()].name);
61075 : // printf ("Error in SgTypeFloat80::error() \n");
61076 : ROSE_ABORT();
61077 : }
61078 :
61079 : ROSE_ASSERT (getVariant() == T_FLOAT80);
61080 : return SgType::error();
61081 : }
61082 : #endif
61083 :
61084 :
61085 :
61086 : // End of memberFunctionString
61087 : // Start of memberFunctionString
61088 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
61089 :
61090 :
61091 : // DQ (1/31/2006): Modified to build all types in the memory pools
61092 : // SgTypeFloat80 SgTypeFloat80::builtin_type;
61093 : // SgTypeFloat80* SgTypeFloat80::builtin_type = new SgTypeFloat80();
61094 : SgTypeFloat80* SgTypeFloat80::p_builtin_type = NULL;
61095 :
61096 :
61097 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
61098 : // SgTypeFloat80* SgTypeFloat80::createType(void)
61099 : SgTypeFloat80*
61100 0 : SgTypeFloat80::createType(SgExpression* optional_fortran_type_kind)
61101 : {
61102 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
61103 : // is not called (likely because static initialization is compiler dependent).
61104 : // DQ (1/31/2006): Modified to build all types in the memory pools
61105 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
61106 : // return &builtin_type;
61107 :
61108 : #if 0
61109 : printf ("In SgTypeFloat80::createType() (COMMON_CREATE_TYPE) \n");
61110 : #endif
61111 :
61112 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
61113 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
61114 :
61115 0 : SgTypeFloat80* temp_type = new SgTypeFloat80();
61116 :
61117 : #if 0
61118 : printf ("In SgTypeFloat80::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
61119 : #endif
61120 :
61121 : // DQ (10/31/2016): Added assertion.
61122 0 : ROSE_ASSERT(temp_type != NULL);
61123 :
61124 0 : if (optional_fortran_type_kind != NULL)
61125 : {
61126 : // DQ (10/31/2016): Added assertion.
61127 0 : ROSE_ASSERT(temp_type != NULL);
61128 :
61129 0 : temp_type->set_type_kind(optional_fortran_type_kind);
61130 : }
61131 : #if 0
61132 : else
61133 : {
61134 : // Let p_builtin_type refer to the unadorned type (no type kind).
61135 : p_builtin_type = temp_type;
61136 : }
61137 : #endif
61138 :
61139 0 : SgName name = temp_type->get_mangled();
61140 :
61141 : #if 0
61142 : printf ("Mangled type name for SgTypeFloat80 = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
61143 : #endif
61144 :
61145 : // DQ (10/31/2016): Added assertion.
61146 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
61147 :
61148 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
61149 :
61150 : #if 0
61151 : printf ("In SgTypeFloat80::createType(): type from lookup_type = %p \n",t);
61152 : #endif
61153 :
61154 0 : if (t == NULL)
61155 : {
61156 0 : get_globalTypeTable()->insert_type(name,temp_type);
61157 : }
61158 : else
61159 : {
61160 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
61161 0 : if (t != temp_type)
61162 : {
61163 : #if 0
61164 : printf ("In SgTypeFloat80::createType(): deleting temp_type = %p \n",temp_type);
61165 : #endif
61166 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
61167 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
61168 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
61169 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
61170 0 : delete temp_type;
61171 : #endif
61172 0 : temp_type = NULL;
61173 : #if 0
61174 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
61175 : if (optional_fortran_type_kind != NULL)
61176 : {
61177 : p_builtin_type = NULL;
61178 : }
61179 : #endif
61180 : }
61181 :
61182 : // Reuse this tempType variable so we can use the same code below.
61183 0 : temp_type = isSgTypeFloat80(t);
61184 0 : ROSE_ASSERT(temp_type != NULL);
61185 : }
61186 :
61187 : #if 0
61188 : printf ("Leaving SgTypeFloat80::createType(): temp_type = %p \n",temp_type);
61189 : #endif
61190 :
61191 0 : return temp_type;
61192 : }
61193 :
61194 :
61195 :
61196 : // End of memberFunctionString
61197 : // Start of memberFunctionString
61198 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
61199 :
61200 : #if 1
61201 : /*! Support for mangled names (for unparser)
61202 : There are two different cases of source code for the get_mangled member function
61203 : This one is used in all but the classes containing a base type
61204 : */
61205 : // SgName SgTypeFloat80::get_mangled ( SgUnparse_Info & info )
61206 : SgName
61207 0 : SgTypeFloat80::get_mangled (void) const
61208 : {
61209 0 : ROSE_ASSERT(this != NULL);
61210 :
61211 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
61212 : // CR (3/6/2020): Now type_kind is also used for Jovial.
61213 0 : SgName name = "w";
61214 0 : if (get_type_kind() != NULL)
61215 : {
61216 : // name += get_type_kind()->get_mangled();
61217 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
61218 0 : SgValueExp* value = isSgValueExp(get_type_kind());
61219 0 : if (value != NULL)
61220 : {
61221 : // name += string("_") + StringUtility::numberToString(value->get_value());
61222 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
61223 : }
61224 : else
61225 : {
61226 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
61227 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
61228 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
61229 : // a different prefix for each type of named type. It come down to is there can be multiple
61230 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
61231 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
61232 : // I think the issue is that w is not defined for any of the SgNameType IR nodes.
61233 : #if 0
61234 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"w");
61235 : #endif
61236 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
61237 : }
61238 : }
61239 :
61240 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
61241 : // REMOVE_ME please!
61242 0 : if (isSgTypeFixed(this))
61243 : {
61244 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
61245 0 : if (fixed_type->get_scale() != NULL)
61246 : {
61247 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
61248 0 : if (value != NULL)
61249 : {
61250 0 : name += string("_") + value->get_constant_folded_value_as_string();
61251 : }
61252 : }
61253 0 : if (fixed_type->get_fraction() != NULL)
61254 : {
61255 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
61256 0 : if (value != NULL)
61257 : {
61258 0 : name += string("_") + value->get_constant_folded_value_as_string();
61259 : }
61260 : }
61261 : }
61262 :
61263 : #if 0
61264 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
61265 : #endif
61266 :
61267 0 : return name;
61268 : }
61269 : #endif
61270 :
61271 :
61272 : // End of memberFunctionString
61273 :
61274 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
61275 :
61276 0 : SgTypeFloat80* isSgTypeFloat80 ( SgNode* inputDerivedClassPointer )
61277 : {
61278 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
61279 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
61280 : // So to fix this we return NULL directly when the input is NULL and avoid the
61281 : // dynamic_cast in this case. This is likely a performance improvement as well.
61282 : // return dynamic_cast<SgTypeFloat80*>(inputDerivedClassPointer);
61283 : // Milind Chabbi (8/28/2013): isSgTypeFloat80 uses table-driven castability instead of c++ default dynamic_cast
61284 : // this improves the running time performance by 10-20%.
61285 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeFloat80*>(inputDerivedClassPointer);
61286 0 : return IS_SgTypeFloat80_FAST_MACRO(inputDerivedClassPointer);
61287 : }
61288 :
61289 : // DQ (11/8/2003): Added version of functions taking const pointer
61290 0 : const SgTypeFloat80* isSgTypeFloat80 ( const SgNode* inputDerivedClassPointer )
61291 : {
61292 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
61293 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
61294 : // So to fix this we return NULL directly when the input is NULL and avoid the
61295 : // dynamic_cast in this case. This is likely a performance improvement as well.
61296 : // return dynamic_cast<const SgTypeFloat80*>(inputDerivedClassPointer);
61297 : // Milind Chabbi (8/28/2013): isSgTypeFloat80 uses table-driven castability instead of c++ default dynamic_cast
61298 : // this improves the running time performance by 10-20%.
61299 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeFloat80*>(inputDerivedClassPointer);
61300 0 : return IS_SgTypeFloat80_FAST_MACRO(inputDerivedClassPointer);
61301 : }
61302 :
61303 :
61304 :
61305 : /* #line 61306 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61306 :
61307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
61308 :
61309 : /**
61310 : \brief Generated destructor
61311 :
61312 : This destructor is automatically generated (by ROSETTA). This destructor
61313 : only frees memory of data members associated with the parts of the current IR node which
61314 : are NOT traversed. Those data members that are part of a traversal can be freed using
61315 : a traversal (calling this destructor on all children in a post-order traversal). Such
61316 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
61317 :
61318 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
61319 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
61320 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
61321 :
61322 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
61323 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
61324 : pointers are not yet implemented to call delete on eash pointer in the container.
61325 : (This could be done by derivation from the STL containers to define containers that
61326 : automatically deleted their members.)
61327 :
61328 : */
61329 0 : SgTypeFloat80::~SgTypeFloat80 () {
61330 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
61331 :
61332 :
61333 :
61334 : }
61335 :
61336 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
61337 0 : }
61338 :
61339 :
61340 : /* #line 61341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61341 :
61342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
61343 :
61344 : // Generated constructor
61345 0 : SgTypeFloat80::SgTypeFloat80 ( )
61346 0 : : SgType()
61347 : {
61348 : #ifdef DEBUG
61349 : // printf ("In SgTypeFloat80::SgTypeFloat80 () sage_class_name() = %s \n",sage_class_name());
61350 : #endif
61351 : #if 0
61352 : // debugging information!
61353 : printf ("In SgTypeFloat80::SgTypeFloat80 (): this = %p = %s \n",this,this->class_name().c_str());
61354 : #endif
61355 :
61356 :
61357 :
61358 : #if 0
61359 : // DQ (7/30/2014): Call a virtual function.
61360 : std::string s = this->class_name();
61361 : #endif
61362 :
61363 : // Test the variant virtual function
61364 : // assert(T_FLOAT80 == variant());
61365 0 : assert(T_FLOAT80 == this->variant());
61366 0 : ROSE_ASSERT(T_FLOAT80 == (int)(this->variantT()));
61367 0 : post_construction_initialization();
61368 :
61369 : // Test the isSgTypeFloat80() function since it has been problematic
61370 0 : assert(isSgTypeFloat80(this) != NULL);
61371 0 : }
61372 :
61373 : // Generated constructor (all data members)
61374 :
61375 : /* #line 61376 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61376 :
61377 :
61378 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
61379 :
61380 :
61381 : // ********************************************************
61382 : // member functions common across all array grammar objects
61383 : // ********************************************************
61384 :
61385 :
61386 :
61387 : /* #line 61388 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61388 :
61389 :
61390 :
61391 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
61392 :
61393 : // ********************************************************
61394 : // member functions specific to each node in the grammar
61395 : // ********************************************************
61396 :
61397 :
61398 : /* #line 61399 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61399 :
61400 : // Start of memberFunctionString
61401 :
61402 :
61403 : // End of memberFunctionString
61404 : // Start of memberFunctionString
61405 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
61406 :
61407 : // *** COMMON CODE SECTION BEGINS HERE ***
61408 :
61409 : #if 0
61410 : int
61411 : SgTypeLongDouble::getVariant() const
61412 : {
61413 : // This function is used in ROSE while "variant()" is used in SAGE
61414 : assert(this != NULL);
61415 : return variant();
61416 : }
61417 : #endif
61418 :
61419 : // This function is used in ROSE in treeTraversal code
61420 : // eventually replaces getVariant() and variant()
61421 : // though after variant() has been removed for a while we will
61422 : // want to change the name of variantT() back to variant()
61423 : // (since the "T" was ment to stand for temporary).
61424 : // When this happens the variantT() will be depricated.
61425 : VariantT
61426 48877000 : SgTypeLongDouble::variantT() const
61427 : {
61428 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
61429 48877000 : ROSE_ASSERT(this != NULL);
61430 48877000 : return V_SgTypeLongDouble;
61431 : }
61432 :
61433 : #if 0
61434 : int
61435 : SgTypeLongDouble::variant() const
61436 : {
61437 : // This function is used in SAGE
61438 : ROSE_ASSERT(this != NULL);
61439 : return T_LONG_DOUBLE;
61440 : }
61441 : #endif
61442 :
61443 : ROSE_DLL_API const char*
61444 0 : SgTypeLongDouble::sage_class_name() const
61445 : {
61446 0 : ROSE_ASSERT(this != NULL);
61447 0 : return "SgTypeLongDouble";
61448 : }
61449 :
61450 : std::string
61451 329 : SgTypeLongDouble::class_name() const
61452 : {
61453 329 : ROSE_ASSERT(this != NULL);
61454 329 : return "SgTypeLongDouble";
61455 : }
61456 :
61457 : // DQ (11/26/2005): Support for visitor pattern mechanims
61458 : // (inferior to ROSE traversal mechanism, experimental).
61459 : void
61460 194 : SgTypeLongDouble::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
61461 : {
61462 194 : ROSE_ASSERT(this != NULL);
61463 194 : visitor.visit(this);
61464 194 : }
61465 :
61466 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
61467 0 : void SgTypeLongDouble::accept (ROSE_VisitorPattern & visitor) {
61468 0 : ROSE_ASSERT(this != NULL);
61469 0 : visitor.visit(this);
61470 0 : }
61471 :
61472 : SgTypeLongDouble*
61473 0 : SgTypeLongDouble::addRegExpAttribute(std::string s, AstRegExAttribute* a)
61474 : {
61475 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
61476 : // This function is currently only supported for the AST used the represent Binary executables.
61477 : if (0 /* isSgAsmNode(this) != NULL */)
61478 : {
61479 : // Support for regex specification.
61480 : std::string prefixCode = "REGEX:";
61481 : addNewAttribute(prefixCode + s,a);
61482 : }
61483 : #endif
61484 :
61485 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
61486 0 : return this;
61487 : }
61488 :
61489 : // *** COMMON CODE SECTION ENDS HERE ***
61490 :
61491 :
61492 : // End of memberFunctionString
61493 : // Start of memberFunctionString
61494 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
61495 :
61496 :
61497 : #if 0
61498 : //! Error checking support
61499 : /*! Verifies the following:
61500 : - working getVariant() member function
61501 : - calls base class's error() member function
61502 : Every class has one of these functions.
61503 : */
61504 : bool
61505 : SgTypeLongDouble::error()
61506 : {
61507 : // Put error checking here
61508 :
61509 : ROSE_ASSERT (this != NULL);
61510 : if (getVariant() != T_LONG_DOUBLE)
61511 : {
61512 : printf ("Error in SgTypeLongDouble::error(): SgTypeLongDouble object has a %s variant \n",
61513 : Cxx_GrammarTerminalNames[getVariant()].name);
61514 : // printf ("Error in SgTypeLongDouble::error() \n");
61515 : ROSE_ABORT();
61516 : }
61517 :
61518 : ROSE_ASSERT (getVariant() == T_LONG_DOUBLE);
61519 : return SgType::error();
61520 : }
61521 : #endif
61522 :
61523 :
61524 :
61525 : // End of memberFunctionString
61526 : // Start of memberFunctionString
61527 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
61528 :
61529 :
61530 : // DQ (1/31/2006): Modified to build all types in the memory pools
61531 : // SgTypeLongDouble SgTypeLongDouble::builtin_type;
61532 : // SgTypeLongDouble* SgTypeLongDouble::builtin_type = new SgTypeLongDouble();
61533 : SgTypeLongDouble* SgTypeLongDouble::p_builtin_type = NULL;
61534 :
61535 :
61536 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
61537 : // SgTypeLongDouble* SgTypeLongDouble::createType(void)
61538 : SgTypeLongDouble*
61539 642 : SgTypeLongDouble::createType(SgExpression* optional_fortran_type_kind)
61540 : {
61541 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
61542 : // is not called (likely because static initialization is compiler dependent).
61543 : // DQ (1/31/2006): Modified to build all types in the memory pools
61544 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
61545 : // return &builtin_type;
61546 :
61547 : #if 0
61548 : printf ("In SgTypeLongDouble::createType() (COMMON_CREATE_TYPE) \n");
61549 : #endif
61550 :
61551 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
61552 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
61553 :
61554 642 : SgTypeLongDouble* temp_type = new SgTypeLongDouble();
61555 :
61556 : #if 0
61557 : printf ("In SgTypeLongDouble::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
61558 : #endif
61559 :
61560 : // DQ (10/31/2016): Added assertion.
61561 642 : ROSE_ASSERT(temp_type != NULL);
61562 :
61563 642 : if (optional_fortran_type_kind != NULL)
61564 : {
61565 : // DQ (10/31/2016): Added assertion.
61566 0 : ROSE_ASSERT(temp_type != NULL);
61567 :
61568 0 : temp_type->set_type_kind(optional_fortran_type_kind);
61569 : }
61570 : #if 0
61571 : else
61572 : {
61573 : // Let p_builtin_type refer to the unadorned type (no type kind).
61574 : p_builtin_type = temp_type;
61575 : }
61576 : #endif
61577 :
61578 642 : SgName name = temp_type->get_mangled();
61579 :
61580 : #if 0
61581 : printf ("Mangled type name for SgTypeLongDouble = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
61582 : #endif
61583 :
61584 : // DQ (10/31/2016): Added assertion.
61585 642 : ROSE_ASSERT(get_globalTypeTable() != NULL);
61586 :
61587 642 : SgType* t = get_globalTypeTable()->lookup_type(name);
61588 :
61589 : #if 0
61590 : printf ("In SgTypeLongDouble::createType(): type from lookup_type = %p \n",t);
61591 : #endif
61592 :
61593 642 : if (t == NULL)
61594 : {
61595 315 : get_globalTypeTable()->insert_type(name,temp_type);
61596 : }
61597 : else
61598 : {
61599 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
61600 327 : if (t != temp_type)
61601 : {
61602 : #if 0
61603 : printf ("In SgTypeLongDouble::createType(): deleting temp_type = %p \n",temp_type);
61604 : #endif
61605 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
61606 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
61607 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
61608 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
61609 327 : delete temp_type;
61610 : #endif
61611 327 : temp_type = NULL;
61612 : #if 0
61613 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
61614 : if (optional_fortran_type_kind != NULL)
61615 : {
61616 : p_builtin_type = NULL;
61617 : }
61618 : #endif
61619 : }
61620 :
61621 : // Reuse this tempType variable so we can use the same code below.
61622 327 : temp_type = isSgTypeLongDouble(t);
61623 327 : ROSE_ASSERT(temp_type != NULL);
61624 : }
61625 :
61626 : #if 0
61627 : printf ("Leaving SgTypeLongDouble::createType(): temp_type = %p \n",temp_type);
61628 : #endif
61629 :
61630 642 : return temp_type;
61631 : }
61632 :
61633 :
61634 :
61635 : // End of memberFunctionString
61636 : // Start of memberFunctionString
61637 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
61638 :
61639 : #if 1
61640 : /*! Support for mangled names (for unparser)
61641 : There are two different cases of source code for the get_mangled member function
61642 : This one is used in all but the classes containing a base type
61643 : */
61644 : // SgName SgTypeLongDouble::get_mangled ( SgUnparse_Info & info )
61645 : SgName
61646 244152 : SgTypeLongDouble::get_mangled (void) const
61647 : {
61648 244152 : ROSE_ASSERT(this != NULL);
61649 :
61650 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
61651 : // CR (3/6/2020): Now type_kind is also used for Jovial.
61652 244152 : SgName name = "ld";
61653 244152 : if (get_type_kind() != NULL)
61654 : {
61655 : // name += get_type_kind()->get_mangled();
61656 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
61657 0 : SgValueExp* value = isSgValueExp(get_type_kind());
61658 0 : if (value != NULL)
61659 : {
61660 : // name += string("_") + StringUtility::numberToString(value->get_value());
61661 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
61662 : }
61663 : else
61664 : {
61665 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
61666 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
61667 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
61668 : // a different prefix for each type of named type. It come down to is there can be multiple
61669 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
61670 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
61671 : // I think the issue is that ld is not defined for any of the SgNameType IR nodes.
61672 : #if 0
61673 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"ld");
61674 : #endif
61675 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
61676 : }
61677 : }
61678 :
61679 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
61680 : // REMOVE_ME please!
61681 244152 : if (isSgTypeFixed(this))
61682 : {
61683 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
61684 0 : if (fixed_type->get_scale() != NULL)
61685 : {
61686 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
61687 0 : if (value != NULL)
61688 : {
61689 0 : name += string("_") + value->get_constant_folded_value_as_string();
61690 : }
61691 : }
61692 0 : if (fixed_type->get_fraction() != NULL)
61693 : {
61694 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
61695 0 : if (value != NULL)
61696 : {
61697 0 : name += string("_") + value->get_constant_folded_value_as_string();
61698 : }
61699 : }
61700 : }
61701 :
61702 : #if 0
61703 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
61704 : #endif
61705 :
61706 244152 : return name;
61707 : }
61708 : #endif
61709 :
61710 :
61711 : // End of memberFunctionString
61712 :
61713 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
61714 :
61715 969 : SgTypeLongDouble* isSgTypeLongDouble ( SgNode* inputDerivedClassPointer )
61716 : {
61717 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
61718 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
61719 : // So to fix this we return NULL directly when the input is NULL and avoid the
61720 : // dynamic_cast in this case. This is likely a performance improvement as well.
61721 : // return dynamic_cast<SgTypeLongDouble*>(inputDerivedClassPointer);
61722 : // Milind Chabbi (8/28/2013): isSgTypeLongDouble uses table-driven castability instead of c++ default dynamic_cast
61723 : // this improves the running time performance by 10-20%.
61724 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeLongDouble*>(inputDerivedClassPointer);
61725 969 : return IS_SgTypeLongDouble_FAST_MACRO(inputDerivedClassPointer);
61726 : }
61727 :
61728 : // DQ (11/8/2003): Added version of functions taking const pointer
61729 0 : const SgTypeLongDouble* isSgTypeLongDouble ( const SgNode* inputDerivedClassPointer )
61730 : {
61731 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
61732 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
61733 : // So to fix this we return NULL directly when the input is NULL and avoid the
61734 : // dynamic_cast in this case. This is likely a performance improvement as well.
61735 : // return dynamic_cast<const SgTypeLongDouble*>(inputDerivedClassPointer);
61736 : // Milind Chabbi (8/28/2013): isSgTypeLongDouble uses table-driven castability instead of c++ default dynamic_cast
61737 : // this improves the running time performance by 10-20%.
61738 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeLongDouble*>(inputDerivedClassPointer);
61739 0 : return IS_SgTypeLongDouble_FAST_MACRO(inputDerivedClassPointer);
61740 : }
61741 :
61742 :
61743 :
61744 : /* #line 61745 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61745 :
61746 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
61747 :
61748 : /**
61749 : \brief Generated destructor
61750 :
61751 : This destructor is automatically generated (by ROSETTA). This destructor
61752 : only frees memory of data members associated with the parts of the current IR node which
61753 : are NOT traversed. Those data members that are part of a traversal can be freed using
61754 : a traversal (calling this destructor on all children in a post-order traversal). Such
61755 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
61756 :
61757 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
61758 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
61759 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
61760 :
61761 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
61762 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
61763 : pointers are not yet implemented to call delete on eash pointer in the container.
61764 : (This could be done by derivation from the STL containers to define containers that
61765 : automatically deleted their members.)
61766 :
61767 : */
61768 662 : SgTypeLongDouble::~SgTypeLongDouble () {
61769 331 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
61770 :
61771 :
61772 :
61773 : }
61774 :
61775 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
61776 662 : }
61777 :
61778 :
61779 : /* #line 61780 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61780 :
61781 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
61782 :
61783 : // Generated constructor
61784 642 : SgTypeLongDouble::SgTypeLongDouble ( )
61785 642 : : SgType()
61786 : {
61787 : #ifdef DEBUG
61788 : // printf ("In SgTypeLongDouble::SgTypeLongDouble () sage_class_name() = %s \n",sage_class_name());
61789 : #endif
61790 : #if 0
61791 : // debugging information!
61792 : printf ("In SgTypeLongDouble::SgTypeLongDouble (): this = %p = %s \n",this,this->class_name().c_str());
61793 : #endif
61794 :
61795 :
61796 :
61797 : #if 0
61798 : // DQ (7/30/2014): Call a virtual function.
61799 : std::string s = this->class_name();
61800 : #endif
61801 :
61802 : // Test the variant virtual function
61803 : // assert(T_LONG_DOUBLE == variant());
61804 642 : assert(T_LONG_DOUBLE == this->variant());
61805 642 : ROSE_ASSERT(T_LONG_DOUBLE == (int)(this->variantT()));
61806 642 : post_construction_initialization();
61807 :
61808 : // Test the isSgTypeLongDouble() function since it has been problematic
61809 642 : assert(isSgTypeLongDouble(this) != NULL);
61810 642 : }
61811 :
61812 : // Generated constructor (all data members)
61813 :
61814 : /* #line 61815 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61815 :
61816 :
61817 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
61818 :
61819 :
61820 : // ********************************************************
61821 : // member functions common across all array grammar objects
61822 : // ********************************************************
61823 :
61824 :
61825 :
61826 : /* #line 61827 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61827 :
61828 :
61829 :
61830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
61831 :
61832 : // ********************************************************
61833 : // member functions specific to each node in the grammar
61834 : // ********************************************************
61835 :
61836 :
61837 : /* #line 61838 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
61838 :
61839 : // Start of memberFunctionString
61840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
61841 :
61842 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
61843 :
61844 : SgExpression*
61845 0 : SgTypeString::get_lengthExpression () const
61846 : {
61847 0 : ROSE_ASSERT (this != NULL);
61848 :
61849 : #if 0
61850 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
61851 : // used to trigger marking transformations for the token-based unparsing.
61852 : printf ("SgTypeString::get_lengthExpression = %p = %s \n",this,this->class_name().c_str());
61853 : #endif
61854 :
61855 0 : return p_lengthExpression;
61856 : }
61857 :
61858 : void
61859 0 : SgTypeString::set_lengthExpression ( SgExpression* lengthExpression )
61860 : {
61861 0 : ROSE_ASSERT (this != NULL);
61862 :
61863 : #if 0
61864 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
61865 : // used to trigger marking transformations for the token-based unparsing.
61866 : printf ("SgTypeString::set_lengthExpression = %p = %s \n",this,this->class_name().c_str());
61867 : #endif
61868 :
61869 0 : set_isModified(true);
61870 :
61871 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
61872 : if (p_lengthExpression != NULL && lengthExpression != NULL && p_lengthExpression != lengthExpression)
61873 : {
61874 : printf ("Warning: lengthExpression = %p overwriting valid pointer p_lengthExpression = %p \n",lengthExpression,p_lengthExpression);
61875 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
61876 : printf ("Error fails assertion (p_lengthExpression != NULL && lengthExpression != NULL && p_lengthExpression != lengthExpression) is false\n");
61877 : ROSE_ASSERT(false);
61878 : #endif
61879 : }
61880 : #endif
61881 0 : p_lengthExpression = lengthExpression;
61882 0 : }
61883 :
61884 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
61885 :
61886 :
61887 : // End of memberFunctionString
61888 : // Start of memberFunctionString
61889 : /* #line 8206 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
61890 :
61891 :
61892 : // SgTypeString* SgTypeString::createType ( SgExpression* idx, size_t length, SgExpression* optional_fortran_type_kind )
61893 : SgTypeString*
61894 170 : SgTypeString::createType ( SgExpression* lengthExpression, SgExpression* optional_fortran_type_kind )
61895 : {
61896 : // DQ (8/17/2010): This is the new SgStringType IR node (now used in Fortran, but not previously used in C/C++).
61897 :
61898 : // DQ (8/17/2010): lengthExpression can be NULL, and even the length could be zero (e.g. for a empty string).
61899 : // ROSE_ASSERT(idx != NULL);
61900 : // ROSE_ASSERT((idx != NULL) || (length > 0));
61901 :
61902 : #if 0
61903 : printf ("In SgTypeString::createType() \n");
61904 : #endif
61905 :
61906 : // SgTypeString* returnType = new SgTypeString(lengthExpression,length);
61907 170 : SgTypeString* returnType = new SgTypeString(lengthExpression);
61908 170 : if (optional_fortran_type_kind != NULL)
61909 : {
61910 0 : returnType->set_type_kind(optional_fortran_type_kind);
61911 0 : optional_fortran_type_kind->set_parent(returnType);
61912 : }
61913 170 : ROSE_ASSERT(returnType != NULL);
61914 :
61915 170 : SgName name = returnType->get_mangled();
61916 :
61917 : #if 0
61918 : printf ("In SgTypeString::createType(): Building an character string [exp = %p] mangled name = %s \n",lengthExpression,name.str());
61919 : #endif
61920 :
61921 : // Only look for pointers to type in the global type table.
61922 170 : SgType* t = get_globalTypeTable()->lookup_type(name);
61923 :
61924 170 : if (t == NULL)
61925 : {
61926 : // The pointer type was not found in the type table, put it into the global type table.
61927 : #if 0
61928 : printf ("Mangled type name for SgTypeString = %s (does NOT exist in type table) inserting it... \n",name.str());
61929 : #endif
61930 61 : get_globalTypeTable()->insert_type(name,returnType);
61931 : }
61932 : else
61933 : {
61934 : // If it is already present in the type table then delete the type (so that it will remain unique).
61935 : #if 0
61936 : printf ("Mangled type name for SgStringType = %s (already exists in type table) \n",name.str());
61937 : #endif
61938 109 : ROSE_ASSERT(t != returnType);
61939 :
61940 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
61941 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
61942 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
61943 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
61944 109 : delete returnType;
61945 : #endif
61946 109 : returnType = NULL;
61947 : // TV (09/29/2021): lengthExpression was owned by returnType so it got deleted. This prevent setting the parent on deleted node below
61948 109 : lengthExpression = NULL;
61949 :
61950 109 : returnType = isSgTypeString(t);
61951 : }
61952 :
61953 : // DQ (2/20/2007): Added setting the parent (which should not have been set already)
61954 : // note also that the index expression is not required to be specified.
61955 61 : if (lengthExpression != NULL)
61956 : {
61957 61 : ROSE_ASSERT(lengthExpression->get_parent() == NULL);
61958 61 : lengthExpression->set_parent(returnType);
61959 : }
61960 :
61961 : // DQ (10/9/2010): Added setting the parent (which should not have been set already)
61962 : // note also that the index expression is not required to be specified.
61963 170 : if (optional_fortran_type_kind != NULL && optional_fortran_type_kind->get_parent() == NULL)
61964 : {
61965 : // ROSE_ASSERT(optional_fortran_type_kind->get_parent() == NULL);
61966 0 : optional_fortran_type_kind->set_parent(returnType);
61967 : }
61968 :
61969 170 : return returnType;
61970 : }
61971 :
61972 :
61973 :
61974 : // End of memberFunctionString
61975 : // Start of memberFunctionString
61976 : /* #line 3181 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
61977 :
61978 :
61979 : // DQ (8/17/2010): Added support for SgTypeString.
61980 : void
61981 170 : SgTypeString::post_construction_initialization()
61982 : {
61983 : // printf ("Inside of SgTypeString::post_construction_initialization() \n");
61984 :
61985 : // DQ (10/5/2010): We no longer use this scalar mechanism (comment out).
61986 : #if 0
61987 : p_definedUsingScalarLength = (p_lengthExpression == NULL);
61988 :
61989 : if (p_definedUsingScalarLength && p_lengthScalar == 0)
61990 : {
61991 : // DQ (8/21/2010): This is not a problem.
61992 : // printf ("Warning: Zero length string specified, might be OK. \n");
61993 : }
61994 : #endif
61995 170 : }
61996 :
61997 :
61998 :
61999 : // End of memberFunctionString
62000 : // Start of memberFunctionString
62001 : /* #line 1217 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
62002 :
62003 :
62004 : /*! Returns a mangled name representation of strings types with the size of the string
62005 : * (e.g., literal, *, or integer expression).
62006 : */
62007 : SgName
62008 178 : SgTypeString::get_mangled (void) const
62009 : {
62010 : #if 1
62011 :
62012 : // DXN (08/01/2011): add type kind to the mangled name
62013 178 : SgName mangled_name;
62014 178 : SgValueExp* lenValExp = isSgValueExp(p_lengthExpression);
62015 178 : SgName mangled_length_name = lenValExp? lenValExp->get_constant_folded_value_as_string():
62016 178 : SageInterface::generateUniqueName(p_lengthExpression,false);
62017 178 : if (p_type_kind)
62018 : {
62019 0 : SgValueExp* kindValExp = isSgValueExp(p_type_kind);
62020 0 : SgName mangled_kind_name = kindValExp? kindValExp->get_constant_folded_value_as_string():
62021 0 : SageInterface::generateUniqueName(p_type_kind,false);
62022 0 : mangled_name << "__" << "str" << "b__" // start tag
62023 0 : << mangled_length_name.str () // length
62024 0 : << "__" << mangled_kind_name.str() // kind
62025 0 : << "__" << "str" << "e__"; // end tag
62026 : }
62027 : else
62028 : {
62029 356 : mangled_name << "__" << "str" << "b__" // start tag
62030 356 : << mangled_length_name.str () // length
62031 356 : << "__" << "str" << "e__"; // end tag
62032 : }
62033 :
62034 178 : return mangled_name;
62035 :
62036 : #else
62037 : // DQ (10/5/2010): Note that we do not include the type_kind data member in the mangled name,
62038 : // but for Fortran this value must always be "1" and the data member is only relevant for Fortran.
62039 :
62040 : ROSE_ASSERT(this != NULL);
62041 :
62042 : // DQ (10/5/2010): This is now always false (this fails for test2007_15.f90)
62043 : // ROSE_ASSERT(this->p_definedUsingScalarLength == false);
62044 :
62045 : SgName mangled_length_name;
62046 :
62047 : // Note that a better implementation would separate out the mangling of scalar valued length expressions.
62048 : SgValueExp* valueExpression = isSgValueExp(p_lengthExpression);
62049 : #if 0
62050 : if (valueExpression != NULL)
62051 : {
62052 : printf ("In SgTypeString::get_mangled(): separate out case of where lengthExpression is a SgValueExp. \n");
62053 : }
62054 : #endif
62055 : #if 0
62056 : if (this->p_definedUsingScalarLength == true)
62057 : {
62058 : mangled_length_name = Rose::StringUtility::numberToString(this->p_lengthScalar);
62059 : }
62060 : else
62061 : {
62062 : ROSE_ASSERT(this->p_lengthExpression != NULL);
62063 : // mangled_length_name = this->p_lengthExpression->get_mangled_name();
62064 : mangled_length_name = SageInterface::generateUniqueName(p_lengthExpression,false);
62065 : }
62066 : #else
62067 : ROSE_ASSERT(this->p_lengthExpression != NULL);
62068 : // mangled_length_name = this->p_lengthExpression->get_mangled_name();
62069 : if (valueExpression != NULL)
62070 : {
62071 : mangled_length_name = valueExpression->get_constant_folded_value_as_string();
62072 : }
62073 : else
62074 : {
62075 : mangled_length_name = SageInterface::generateUniqueName(p_lengthExpression,false);
62076 : }
62077 : #endif
62078 :
62079 : SgName mangled_name;
62080 : mangled_name << "__" << "str" << "b__" // start tag
62081 : << mangled_length_name.str () // length
62082 : << "__" << "str" << "e__"; // end tag
62083 :
62084 : // printf ("LEAVING: In SgTypeString::get_mangled(): definedUsingScalarLength = %s lengthScalar = %" PRIuPTR " lengthExpression = %p mangled_name = %s \n",p_definedUsingScalarLength ? "true" : "false",p_lengthScalar,p_lengthExpression,mangled_name.str());
62085 :
62086 : return mangled_name;
62087 : #endif
62088 : }
62089 :
62090 :
62091 :
62092 : // End of memberFunctionString
62093 : // Start of memberFunctionString
62094 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
62095 :
62096 : // *** COMMON CODE SECTION BEGINS HERE ***
62097 :
62098 : #if 0
62099 : int
62100 : SgTypeString::getVariant() const
62101 : {
62102 : // This function is used in ROSE while "variant()" is used in SAGE
62103 : assert(this != NULL);
62104 : return variant();
62105 : }
62106 : #endif
62107 :
62108 : // This function is used in ROSE in treeTraversal code
62109 : // eventually replaces getVariant() and variant()
62110 : // though after variant() has been removed for a while we will
62111 : // want to change the name of variantT() back to variant()
62112 : // (since the "T" was ment to stand for temporary).
62113 : // When this happens the variantT() will be depricated.
62114 : VariantT
62115 8803 : SgTypeString::variantT() const
62116 : {
62117 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
62118 8803 : ROSE_ASSERT(this != NULL);
62119 8803 : return V_SgTypeString;
62120 : }
62121 :
62122 : #if 0
62123 : int
62124 : SgTypeString::variant() const
62125 : {
62126 : // This function is used in SAGE
62127 : ROSE_ASSERT(this != NULL);
62128 : return T_STRING;
62129 : }
62130 : #endif
62131 :
62132 : ROSE_DLL_API const char*
62133 0 : SgTypeString::sage_class_name() const
62134 : {
62135 0 : ROSE_ASSERT(this != NULL);
62136 0 : return "SgTypeString";
62137 : }
62138 :
62139 : std::string
62140 126 : SgTypeString::class_name() const
62141 : {
62142 126 : ROSE_ASSERT(this != NULL);
62143 126 : return "SgTypeString";
62144 : }
62145 :
62146 : // DQ (11/26/2005): Support for visitor pattern mechanims
62147 : // (inferior to ROSE traversal mechanism, experimental).
62148 : void
62149 32 : SgTypeString::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
62150 : {
62151 32 : ROSE_ASSERT(this != NULL);
62152 32 : visitor.visit(this);
62153 32 : }
62154 :
62155 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
62156 0 : void SgTypeString::accept (ROSE_VisitorPattern & visitor) {
62157 0 : ROSE_ASSERT(this != NULL);
62158 0 : visitor.visit(this);
62159 0 : }
62160 :
62161 : SgTypeString*
62162 0 : SgTypeString::addRegExpAttribute(std::string s, AstRegExAttribute* a)
62163 : {
62164 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
62165 : // This function is currently only supported for the AST used the represent Binary executables.
62166 : if (0 /* isSgAsmNode(this) != NULL */)
62167 : {
62168 : // Support for regex specification.
62169 : std::string prefixCode = "REGEX:";
62170 : addNewAttribute(prefixCode + s,a);
62171 : }
62172 : #endif
62173 :
62174 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
62175 0 : return this;
62176 : }
62177 :
62178 : // *** COMMON CODE SECTION ENDS HERE ***
62179 :
62180 :
62181 : // End of memberFunctionString
62182 : // Start of memberFunctionString
62183 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
62184 :
62185 :
62186 : #if 0
62187 : //! Error checking support
62188 : /*! Verifies the following:
62189 : - working getVariant() member function
62190 : - calls base class's error() member function
62191 : Every class has one of these functions.
62192 : */
62193 : bool
62194 : SgTypeString::error()
62195 : {
62196 : // Put error checking here
62197 :
62198 : ROSE_ASSERT (this != NULL);
62199 : if (getVariant() != T_STRING)
62200 : {
62201 : printf ("Error in SgTypeString::error(): SgTypeString object has a %s variant \n",
62202 : Cxx_GrammarTerminalNames[getVariant()].name);
62203 : // printf ("Error in SgTypeString::error() \n");
62204 : ROSE_ABORT();
62205 : }
62206 :
62207 : ROSE_ASSERT (getVariant() == T_STRING);
62208 : return SgType::error();
62209 : }
62210 : #endif
62211 :
62212 :
62213 :
62214 : // End of memberFunctionString
62215 :
62216 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
62217 :
62218 399 : SgTypeString* isSgTypeString ( SgNode* inputDerivedClassPointer )
62219 : {
62220 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
62221 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
62222 : // So to fix this we return NULL directly when the input is NULL and avoid the
62223 : // dynamic_cast in this case. This is likely a performance improvement as well.
62224 : // return dynamic_cast<SgTypeString*>(inputDerivedClassPointer);
62225 : // Milind Chabbi (8/28/2013): isSgTypeString uses table-driven castability instead of c++ default dynamic_cast
62226 : // this improves the running time performance by 10-20%.
62227 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeString*>(inputDerivedClassPointer);
62228 399 : return IS_SgTypeString_FAST_MACRO(inputDerivedClassPointer);
62229 : }
62230 :
62231 : // DQ (11/8/2003): Added version of functions taking const pointer
62232 0 : const SgTypeString* isSgTypeString ( const SgNode* inputDerivedClassPointer )
62233 : {
62234 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
62235 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
62236 : // So to fix this we return NULL directly when the input is NULL and avoid the
62237 : // dynamic_cast in this case. This is likely a performance improvement as well.
62238 : // return dynamic_cast<const SgTypeString*>(inputDerivedClassPointer);
62239 : // Milind Chabbi (8/28/2013): isSgTypeString uses table-driven castability instead of c++ default dynamic_cast
62240 : // this improves the running time performance by 10-20%.
62241 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeString*>(inputDerivedClassPointer);
62242 0 : return IS_SgTypeString_FAST_MACRO(inputDerivedClassPointer);
62243 : }
62244 :
62245 :
62246 :
62247 : /* #line 62248 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62248 :
62249 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
62250 :
62251 : /**
62252 : \brief Generated destructor
62253 :
62254 : This destructor is automatically generated (by ROSETTA). This destructor
62255 : only frees memory of data members associated with the parts of the current IR node which
62256 : are NOT traversed. Those data members that are part of a traversal can be freed using
62257 : a traversal (calling this destructor on all children in a post-order traversal). Such
62258 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
62259 :
62260 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
62261 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
62262 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
62263 :
62264 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
62265 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
62266 : pointers are not yet implemented to call delete on eash pointer in the container.
62267 : (This could be done by derivation from the STL containers to define containers that
62268 : automatically deleted their members.)
62269 :
62270 : */
62271 218 : SgTypeString::~SgTypeString () {
62272 109 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
62273 :
62274 109 : if (p_lengthExpression && p_lengthExpression->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_lengthExpression; }
62275 :
62276 : // case: not a listType for lengthExpression
62277 109 : p_lengthExpression = NULL; // non list case
62278 :
62279 : }
62280 :
62281 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
62282 218 : }
62283 :
62284 :
62285 : /* #line 62286 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62286 :
62287 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
62288 :
62289 : // Generated constructor
62290 170 : SgTypeString::SgTypeString ( SgExpression* lengthExpression )
62291 170 : : SgType()
62292 : {
62293 : #ifdef DEBUG
62294 : // printf ("In SgTypeString::SgTypeString (SgExpression* lengthExpression) sage_class_name() = %s \n",sage_class_name());
62295 : #endif
62296 : #if 0
62297 : // debugging information!
62298 : printf ("In SgTypeString::SgTypeString (SgExpression* lengthExpression): this = %p = %s \n",this,this->class_name().c_str());
62299 : #endif
62300 :
62301 170 : p_lengthExpression = lengthExpression;
62302 :
62303 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
62304 :
62305 : #if 0
62306 : // DQ (7/30/2014): Call a virtual function.
62307 : std::string s = this->class_name();
62308 : #endif
62309 :
62310 : // Test the variant virtual function
62311 : // assert(T_STRING == variant());
62312 170 : assert(T_STRING == this->variant());
62313 170 : ROSE_ASSERT(T_STRING == (int)(this->variantT()));
62314 170 : post_construction_initialization();
62315 :
62316 : // Test the isSgTypeString() function since it has been problematic
62317 170 : assert(isSgTypeString(this) != NULL);
62318 170 : }
62319 :
62320 : // Generated constructor (all data members)
62321 :
62322 : /* #line 62323 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62323 :
62324 :
62325 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
62326 :
62327 :
62328 : // ********************************************************
62329 : // member functions common across all array grammar objects
62330 : // ********************************************************
62331 :
62332 :
62333 :
62334 : /* #line 62335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62335 :
62336 :
62337 :
62338 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
62339 :
62340 : // ********************************************************
62341 : // member functions specific to each node in the grammar
62342 : // ********************************************************
62343 :
62344 :
62345 : /* #line 62346 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62346 :
62347 : // Start of memberFunctionString
62348 :
62349 :
62350 : // End of memberFunctionString
62351 : // Start of memberFunctionString
62352 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
62353 :
62354 : // *** COMMON CODE SECTION BEGINS HERE ***
62355 :
62356 : #if 0
62357 : int
62358 : SgTypeBool::getVariant() const
62359 : {
62360 : // This function is used in ROSE while "variant()" is used in SAGE
62361 : assert(this != NULL);
62362 : return variant();
62363 : }
62364 : #endif
62365 :
62366 : // This function is used in ROSE in treeTraversal code
62367 : // eventually replaces getVariant() and variant()
62368 : // though after variant() has been removed for a while we will
62369 : // want to change the name of variantT() back to variant()
62370 : // (since the "T" was ment to stand for temporary).
62371 : // When this happens the variantT() will be depricated.
62372 : VariantT
62373 5310330 : SgTypeBool::variantT() const
62374 : {
62375 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
62376 5310330 : ROSE_ASSERT(this != NULL);
62377 5310330 : return V_SgTypeBool;
62378 : }
62379 :
62380 : #if 0
62381 : int
62382 : SgTypeBool::variant() const
62383 : {
62384 : // This function is used in SAGE
62385 : ROSE_ASSERT(this != NULL);
62386 : return T_BOOL;
62387 : }
62388 : #endif
62389 :
62390 : ROSE_DLL_API const char*
62391 0 : SgTypeBool::sage_class_name() const
62392 : {
62393 0 : ROSE_ASSERT(this != NULL);
62394 0 : return "SgTypeBool";
62395 : }
62396 :
62397 : std::string
62398 7801 : SgTypeBool::class_name() const
62399 : {
62400 7801 : ROSE_ASSERT(this != NULL);
62401 7801 : return "SgTypeBool";
62402 : }
62403 :
62404 : // DQ (11/26/2005): Support for visitor pattern mechanims
62405 : // (inferior to ROSE traversal mechanism, experimental).
62406 : void
62407 194 : SgTypeBool::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
62408 : {
62409 194 : ROSE_ASSERT(this != NULL);
62410 194 : visitor.visit(this);
62411 194 : }
62412 :
62413 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
62414 0 : void SgTypeBool::accept (ROSE_VisitorPattern & visitor) {
62415 0 : ROSE_ASSERT(this != NULL);
62416 0 : visitor.visit(this);
62417 0 : }
62418 :
62419 : SgTypeBool*
62420 0 : SgTypeBool::addRegExpAttribute(std::string s, AstRegExAttribute* a)
62421 : {
62422 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
62423 : // This function is currently only supported for the AST used the represent Binary executables.
62424 : if (0 /* isSgAsmNode(this) != NULL */)
62425 : {
62426 : // Support for regex specification.
62427 : std::string prefixCode = "REGEX:";
62428 : addNewAttribute(prefixCode + s,a);
62429 : }
62430 : #endif
62431 :
62432 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
62433 0 : return this;
62434 : }
62435 :
62436 : // *** COMMON CODE SECTION ENDS HERE ***
62437 :
62438 :
62439 : // End of memberFunctionString
62440 : // Start of memberFunctionString
62441 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
62442 :
62443 :
62444 : #if 0
62445 : //! Error checking support
62446 : /*! Verifies the following:
62447 : - working getVariant() member function
62448 : - calls base class's error() member function
62449 : Every class has one of these functions.
62450 : */
62451 : bool
62452 : SgTypeBool::error()
62453 : {
62454 : // Put error checking here
62455 :
62456 : ROSE_ASSERT (this != NULL);
62457 : if (getVariant() != T_BOOL)
62458 : {
62459 : printf ("Error in SgTypeBool::error(): SgTypeBool object has a %s variant \n",
62460 : Cxx_GrammarTerminalNames[getVariant()].name);
62461 : // printf ("Error in SgTypeBool::error() \n");
62462 : ROSE_ABORT();
62463 : }
62464 :
62465 : ROSE_ASSERT (getVariant() == T_BOOL);
62466 : return SgType::error();
62467 : }
62468 : #endif
62469 :
62470 :
62471 :
62472 : // End of memberFunctionString
62473 : // Start of memberFunctionString
62474 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
62475 :
62476 :
62477 : // DQ (1/31/2006): Modified to build all types in the memory pools
62478 : // SgTypeBool SgTypeBool::builtin_type;
62479 : // SgTypeBool* SgTypeBool::builtin_type = new SgTypeBool();
62480 : SgTypeBool* SgTypeBool::p_builtin_type = NULL;
62481 :
62482 :
62483 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
62484 : // SgTypeBool* SgTypeBool::createType(void)
62485 : SgTypeBool*
62486 26842 : SgTypeBool::createType(SgExpression* optional_fortran_type_kind)
62487 : {
62488 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
62489 : // is not called (likely because static initialization is compiler dependent).
62490 : // DQ (1/31/2006): Modified to build all types in the memory pools
62491 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
62492 : // return &builtin_type;
62493 :
62494 : #if 0
62495 : printf ("In SgTypeBool::createType() (COMMON_CREATE_TYPE) \n");
62496 : #endif
62497 :
62498 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
62499 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
62500 :
62501 26842 : SgTypeBool* temp_type = new SgTypeBool();
62502 :
62503 : #if 0
62504 : printf ("In SgTypeBool::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
62505 : #endif
62506 :
62507 : // DQ (10/31/2016): Added assertion.
62508 26842 : ROSE_ASSERT(temp_type != NULL);
62509 :
62510 26842 : if (optional_fortran_type_kind != NULL)
62511 : {
62512 : // DQ (10/31/2016): Added assertion.
62513 0 : ROSE_ASSERT(temp_type != NULL);
62514 :
62515 0 : temp_type->set_type_kind(optional_fortran_type_kind);
62516 : }
62517 : #if 0
62518 : else
62519 : {
62520 : // Let p_builtin_type refer to the unadorned type (no type kind).
62521 : p_builtin_type = temp_type;
62522 : }
62523 : #endif
62524 :
62525 26842 : SgName name = temp_type->get_mangled();
62526 :
62527 : #if 0
62528 : printf ("Mangled type name for SgTypeBool = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
62529 : #endif
62530 :
62531 : // DQ (10/31/2016): Added assertion.
62532 26842 : ROSE_ASSERT(get_globalTypeTable() != NULL);
62533 :
62534 26842 : SgType* t = get_globalTypeTable()->lookup_type(name);
62535 :
62536 : #if 0
62537 : printf ("In SgTypeBool::createType(): type from lookup_type = %p \n",t);
62538 : #endif
62539 :
62540 26842 : if (t == NULL)
62541 : {
62542 76 : get_globalTypeTable()->insert_type(name,temp_type);
62543 : }
62544 : else
62545 : {
62546 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
62547 26766 : if (t != temp_type)
62548 : {
62549 : #if 0
62550 : printf ("In SgTypeBool::createType(): deleting temp_type = %p \n",temp_type);
62551 : #endif
62552 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
62553 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
62554 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
62555 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
62556 26766 : delete temp_type;
62557 : #endif
62558 26766 : temp_type = NULL;
62559 : #if 0
62560 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
62561 : if (optional_fortran_type_kind != NULL)
62562 : {
62563 : p_builtin_type = NULL;
62564 : }
62565 : #endif
62566 : }
62567 :
62568 : // Reuse this tempType variable so we can use the same code below.
62569 26766 : temp_type = isSgTypeBool(t);
62570 26766 : ROSE_ASSERT(temp_type != NULL);
62571 : }
62572 :
62573 : #if 0
62574 : printf ("Leaving SgTypeBool::createType(): temp_type = %p \n",temp_type);
62575 : #endif
62576 :
62577 26842 : return temp_type;
62578 : }
62579 :
62580 :
62581 :
62582 : // End of memberFunctionString
62583 : // Start of memberFunctionString
62584 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
62585 :
62586 : #if 1
62587 : /*! Support for mangled names (for unparser)
62588 : There are two different cases of source code for the get_mangled member function
62589 : This one is used in all but the classes containing a base type
62590 : */
62591 : // SgName SgTypeBool::get_mangled ( SgUnparse_Info & info )
62592 : SgName
62593 63314 : SgTypeBool::get_mangled (void) const
62594 : {
62595 63314 : ROSE_ASSERT(this != NULL);
62596 :
62597 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
62598 : // CR (3/6/2020): Now type_kind is also used for Jovial.
62599 63314 : SgName name = "b";
62600 63314 : if (get_type_kind() != NULL)
62601 : {
62602 : // name += get_type_kind()->get_mangled();
62603 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
62604 0 : SgValueExp* value = isSgValueExp(get_type_kind());
62605 0 : if (value != NULL)
62606 : {
62607 : // name += string("_") + StringUtility::numberToString(value->get_value());
62608 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
62609 : }
62610 : else
62611 : {
62612 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
62613 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
62614 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
62615 : // a different prefix for each type of named type. It come down to is there can be multiple
62616 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
62617 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
62618 : // I think the issue is that b is not defined for any of the SgNameType IR nodes.
62619 : #if 0
62620 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"b");
62621 : #endif
62622 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
62623 : }
62624 : }
62625 :
62626 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
62627 : // REMOVE_ME please!
62628 63314 : if (isSgTypeFixed(this))
62629 : {
62630 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
62631 0 : if (fixed_type->get_scale() != NULL)
62632 : {
62633 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
62634 0 : if (value != NULL)
62635 : {
62636 0 : name += string("_") + value->get_constant_folded_value_as_string();
62637 : }
62638 : }
62639 0 : if (fixed_type->get_fraction() != NULL)
62640 : {
62641 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
62642 0 : if (value != NULL)
62643 : {
62644 0 : name += string("_") + value->get_constant_folded_value_as_string();
62645 : }
62646 : }
62647 : }
62648 :
62649 : #if 0
62650 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
62651 : #endif
62652 :
62653 63314 : return name;
62654 : }
62655 : #endif
62656 :
62657 :
62658 : // End of memberFunctionString
62659 :
62660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
62661 :
62662 53610 : SgTypeBool* isSgTypeBool ( SgNode* inputDerivedClassPointer )
62663 : {
62664 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
62665 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
62666 : // So to fix this we return NULL directly when the input is NULL and avoid the
62667 : // dynamic_cast in this case. This is likely a performance improvement as well.
62668 : // return dynamic_cast<SgTypeBool*>(inputDerivedClassPointer);
62669 : // Milind Chabbi (8/28/2013): isSgTypeBool uses table-driven castability instead of c++ default dynamic_cast
62670 : // this improves the running time performance by 10-20%.
62671 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeBool*>(inputDerivedClassPointer);
62672 53610 : return IS_SgTypeBool_FAST_MACRO(inputDerivedClassPointer);
62673 : }
62674 :
62675 : // DQ (11/8/2003): Added version of functions taking const pointer
62676 0 : const SgTypeBool* isSgTypeBool ( const SgNode* inputDerivedClassPointer )
62677 : {
62678 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
62679 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
62680 : // So to fix this we return NULL directly when the input is NULL and avoid the
62681 : // dynamic_cast in this case. This is likely a performance improvement as well.
62682 : // return dynamic_cast<const SgTypeBool*>(inputDerivedClassPointer);
62683 : // Milind Chabbi (8/28/2013): isSgTypeBool uses table-driven castability instead of c++ default dynamic_cast
62684 : // this improves the running time performance by 10-20%.
62685 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeBool*>(inputDerivedClassPointer);
62686 0 : return IS_SgTypeBool_FAST_MACRO(inputDerivedClassPointer);
62687 : }
62688 :
62689 :
62690 :
62691 : /* #line 62692 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62692 :
62693 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
62694 :
62695 : /**
62696 : \brief Generated destructor
62697 :
62698 : This destructor is automatically generated (by ROSETTA). This destructor
62699 : only frees memory of data members associated with the parts of the current IR node which
62700 : are NOT traversed. Those data members that are part of a traversal can be freed using
62701 : a traversal (calling this destructor on all children in a post-order traversal). Such
62702 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
62703 :
62704 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
62705 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
62706 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
62707 :
62708 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
62709 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
62710 : pointers are not yet implemented to call delete on eash pointer in the container.
62711 : (This could be done by derivation from the STL containers to define containers that
62712 : automatically deleted their members.)
62713 :
62714 : */
62715 53536 : SgTypeBool::~SgTypeBool () {
62716 26768 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
62717 :
62718 :
62719 :
62720 : }
62721 :
62722 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
62723 53536 : }
62724 :
62725 :
62726 : /* #line 62727 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62727 :
62728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
62729 :
62730 : // Generated constructor
62731 26842 : SgTypeBool::SgTypeBool ( )
62732 26842 : : SgType()
62733 : {
62734 : #ifdef DEBUG
62735 : // printf ("In SgTypeBool::SgTypeBool () sage_class_name() = %s \n",sage_class_name());
62736 : #endif
62737 : #if 0
62738 : // debugging information!
62739 : printf ("In SgTypeBool::SgTypeBool (): this = %p = %s \n",this,this->class_name().c_str());
62740 : #endif
62741 :
62742 :
62743 :
62744 : #if 0
62745 : // DQ (7/30/2014): Call a virtual function.
62746 : std::string s = this->class_name();
62747 : #endif
62748 :
62749 : // Test the variant virtual function
62750 : // assert(T_BOOL == variant());
62751 26842 : assert(T_BOOL == this->variant());
62752 26842 : ROSE_ASSERT(T_BOOL == (int)(this->variantT()));
62753 26842 : post_construction_initialization();
62754 :
62755 : // Test the isSgTypeBool() function since it has been problematic
62756 26842 : assert(isSgTypeBool(this) != NULL);
62757 26842 : }
62758 :
62759 : // Generated constructor (all data members)
62760 :
62761 : /* #line 62762 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62762 :
62763 :
62764 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
62765 :
62766 :
62767 : // ********************************************************
62768 : // member functions common across all array grammar objects
62769 : // ********************************************************
62770 :
62771 :
62772 :
62773 : /* #line 62774 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62774 :
62775 :
62776 :
62777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
62778 :
62779 : // ********************************************************
62780 : // member functions specific to each node in the grammar
62781 : // ********************************************************
62782 :
62783 :
62784 : /* #line 62785 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
62785 :
62786 : // Start of memberFunctionString
62787 : /* #line 7396 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
62788 :
62789 : // SgPointerType* SgPointerType::createType(SgType* base_type)
62790 : SgPointerType*
62791 180273 : SgPointerType::createType(SgType* base_type, SgExpression* optional_fortran_type_kind)
62792 : {
62793 180273 : ROSE_ASSERT(base_type != NULL);
62794 :
62795 : // DQ (10/4/2010): I think that pointer types can't have a kind parameter, so this should be NULL.
62796 180273 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
62797 :
62798 : #if 0
62799 : printf ("In SgPointerType::createType() \n");
62800 : #endif
62801 :
62802 180273 : if (base_type->p_ptr_to != NULL)
62803 : {
62804 : return base_type->p_ptr_to;
62805 : }
62806 : else
62807 : {
62808 : #if 0
62809 : SgPointerType* newType = new SgPointerType(base_type);
62810 : assert(newType != NULL);
62811 : #else
62812 27122 : SgPointerType* newType = new SgPointerType(base_type);
62813 27122 : assert(newType != NULL);
62814 :
62815 27122 : SgName name = newType->get_mangled();
62816 :
62817 : #if 0
62818 : printf ("Building a pointer to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
62819 : #endif
62820 :
62821 : // Only look for pointers to type in the global type table.
62822 27122 : SgType* t = get_globalTypeTable()->lookup_type(name);
62823 :
62824 27122 : if (t == NULL)
62825 : {
62826 : // The pointer type was not found in the type table, put it into the global type table.
62827 : #if 0
62828 : // This is too agressive and fails for some test codes!
62829 : printf ("Mangled type name for SgPointerType = %s (does NOT exist in type table) \n",name.str());
62830 : get_globalTypeTable()->insert_type(name,newType);
62831 : #else
62832 27038 : SgType* root_type = base_type->stripType();
62833 27038 : ROSE_ASSERT(root_type != NULL);
62834 27038 : if (handledUsingLocalTable(root_type) == false)
62835 : {
62836 : #if 0
62837 : printf ("Mangled type name for SgPointerType = %s (does NOT exist in type table) inserting it... \n",name.str());
62838 : #endif
62839 20684 : get_globalTypeTable()->insert_type(name,newType);
62840 : }
62841 : else
62842 : {
62843 : #if 0
62844 : printf ("Skip putting the SgPointerType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
62845 : #endif
62846 : }
62847 : #endif
62848 : }
62849 : else
62850 : {
62851 : // This should be only a pointer to a SgModifierType (e.g. a pointer to a const base_type) NOT TRUE.
62852 : // ROSE_ASSERT(isSgModifierType(base_type) != NULL || isSgFunctionType(base_type) != NULL);
62853 :
62854 : // The pointer type was found in either the local or global table (but the base_type->p_ptr_to should have been valid).
62855 : // printf ("WARNING: the pointer to a base type = %p = %s should exist, we need to find it! \n",base_type,base_type->class_name().c_str());
62856 : // ROSE_ASSERT(false);
62857 :
62858 : // If it is already present in the type table then delete the type (so that it will remain unique).
62859 : #if 0
62860 : printf ("Mangled type name for SgPointerType = %s (already exists in type table) \n",name.str());
62861 : #endif
62862 84 : ROSE_ASSERT(t != newType);
62863 :
62864 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
62865 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
62866 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
62867 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
62868 84 : delete newType;
62869 : #endif
62870 84 : newType = NULL;
62871 :
62872 84 : newType = isSgPointerType(t);
62873 : }
62874 : #endif
62875 :
62876 27122 : base_type->p_ptr_to = newType;
62877 27122 : assert(base_type->p_ptr_to != NULL);
62878 :
62879 27122 : return base_type->p_ptr_to;
62880 : }
62881 : }
62882 :
62883 :
62884 :
62885 : // End of memberFunctionString
62886 : // Start of memberFunctionString
62887 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
62888 :
62889 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
62890 :
62891 : SgType*
62892 6473920 : SgPointerType::get_base_type () const
62893 : {
62894 6473920 : ROSE_ASSERT (this != NULL);
62895 :
62896 : #if 0
62897 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
62898 : // used to trigger marking transformations for the token-based unparsing.
62899 : printf ("SgPointerType::get_base_type = %p = %s \n",this,this->class_name().c_str());
62900 : #endif
62901 :
62902 6473920 : return p_base_type;
62903 : }
62904 :
62905 : void
62906 0 : SgPointerType::set_base_type ( SgType* base_type )
62907 : {
62908 0 : ROSE_ASSERT (this != NULL);
62909 :
62910 : #if 0
62911 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
62912 : // used to trigger marking transformations for the token-based unparsing.
62913 : printf ("SgPointerType::set_base_type = %p = %s \n",this,this->class_name().c_str());
62914 : #endif
62915 :
62916 0 : set_isModified(true);
62917 :
62918 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
62919 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
62920 : {
62921 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
62922 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
62923 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
62924 : ROSE_ASSERT(false);
62925 : #endif
62926 : }
62927 : #endif
62928 0 : p_base_type = base_type;
62929 0 : }
62930 :
62931 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
62932 :
62933 :
62934 : // End of memberFunctionString
62935 : // Start of memberFunctionString
62936 : /* #line 1094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
62937 :
62938 :
62939 : /*! Returns a mangled name representation of types with base types
62940 : * (e.g., pointer, reference).
62941 : */
62942 : SgName
62943 1223760 : SgPointerType::get_mangled (void) const
62944 : {
62945 : // DQ (10/23/2015): Note that these functions are called in the AST construction and that might not be
62946 : // required, plus it might be a performance issue as well. I didn't expect to see this while debugging
62947 : // a different subject. In general, I think we would like to push the generation of mangled names to
62948 : // the end of the AST processing; unless it is required for computing symble table keys (which is the
62949 : // likely usage within the AST construction, if so then I guess we have to allow these functions to be
62950 : // called in the frontend AST construction).
62951 :
62952 1223760 : ROSE_ASSERT(this != NULL);
62953 :
62954 1223760 : const SgType* base_type = get_base_type();
62955 1223760 : ROSE_ASSERT (base_type != NULL);
62956 :
62957 : #if 0
62958 : printf ("In SgPointerType::get_mangled(): base_type = %p = %s \n",base_type,base_type->class_name().c_str());
62959 : #endif
62960 :
62961 1223760 : SgName base_name = base_type->get_mangled();
62962 :
62963 : #if 0
62964 : printf ("DONE: In SgPointerType::get_mangled(): base_type = %p = %s base_name = %s \n",base_type,base_type->class_name().c_str(),base_name.str());
62965 : #endif
62966 :
62967 : // DQ (6/21/2006): Use is_null() instead of counting the size (and fixed case were it is null)
62968 : // ROSE_ASSERT (base_name.get_length ());
62969 1223760 : if (base_name.is_null() == true)
62970 : {
62971 : // This happens for code such as: "typedef struct {int id; } *XYZ;"
62972 : // printf ("Warning: In SgPointerType::get_mangled(), empty base type name found \n");
62973 0 : base_name = "un_named_base_type";
62974 : }
62975 1223760 : ROSE_ASSERT (base_name.is_null() == false);
62976 :
62977 1223760 : SgName mangled_name;
62978 2447520 : mangled_name << "__" << "P" << "b__" // start tag
62979 2447520 : << base_name.str () // base type
62980 2447520 : << "__" << "P" << "e__"; // end tag
62981 :
62982 : // printf ("LEAVING: In SgPointerType::get_mangled(): base_type = %p = %s mangled_name = %s \n",base_type,base_type->class_name().c_str(),mangled_name.str());
62983 :
62984 1223760 : return mangled_name;
62985 : }
62986 :
62987 : #if 0
62988 : // Old version of function
62989 : SgName
62990 : SgPointerType::get_mangled ( SgUnparse_Info & info )
62991 : {
62992 : SgName tmp("P");
62993 :
62994 : // DQ (3/15/2005): Should be be using a qualified name???
62995 :
62996 : ROSE_ASSERT(get_base_type() != NULL);
62997 : ROSE_ASSERT(get_base_type()->get_mangled(info).get_length() > 0);
62998 : tmp << get_base_type()->get_mangled(info).str();
62999 :
63000 : #if 0
63001 : printf ("########### In SgPointerType::get_mangled(): tmp = %s (get_base_type() = %s is a %s) ########## \n",
63002 : tmp.str(),get_base_type()->get_mangled(info).str(),get_base_type()->sage_class_name());
63003 : // ROSE_ASSERT(false);
63004 : #endif
63005 :
63006 : return tmp;
63007 : }
63008 : #endif
63009 :
63010 :
63011 :
63012 : // End of memberFunctionString
63013 : // Start of memberFunctionString
63014 : /* #line 3368 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
63015 :
63016 :
63017 :
63018 : // End of memberFunctionString
63019 : // Start of memberFunctionString
63020 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
63021 :
63022 : // *** COMMON CODE SECTION BEGINS HERE ***
63023 :
63024 : #if 0
63025 : int
63026 : SgPointerType::getVariant() const
63027 : {
63028 : // This function is used in ROSE while "variant()" is used in SAGE
63029 : assert(this != NULL);
63030 : return variant();
63031 : }
63032 : #endif
63033 :
63034 : // This function is used in ROSE in treeTraversal code
63035 : // eventually replaces getVariant() and variant()
63036 : // though after variant() has been removed for a while we will
63037 : // want to change the name of variantT() back to variant()
63038 : // (since the "T" was ment to stand for temporary).
63039 : // When this happens the variantT() will be depricated.
63040 : VariantT
63041 557958000 : SgPointerType::variantT() const
63042 : {
63043 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
63044 557958000 : ROSE_ASSERT(this != NULL);
63045 557958000 : return V_SgPointerType;
63046 : }
63047 :
63048 : #if 0
63049 : int
63050 : SgPointerType::variant() const
63051 : {
63052 : // This function is used in SAGE
63053 : ROSE_ASSERT(this != NULL);
63054 : return T_POINTER;
63055 : }
63056 : #endif
63057 :
63058 : ROSE_DLL_API const char*
63059 0 : SgPointerType::sage_class_name() const
63060 : {
63061 0 : ROSE_ASSERT(this != NULL);
63062 0 : return "SgPointerType";
63063 : }
63064 :
63065 : std::string
63066 24134 : SgPointerType::class_name() const
63067 : {
63068 24134 : ROSE_ASSERT(this != NULL);
63069 24134 : return "SgPointerType";
63070 : }
63071 :
63072 : // DQ (11/26/2005): Support for visitor pattern mechanims
63073 : // (inferior to ROSE traversal mechanism, experimental).
63074 : void
63075 81737 : SgPointerType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
63076 : {
63077 81737 : ROSE_ASSERT(this != NULL);
63078 81737 : visitor.visit(this);
63079 81737 : }
63080 :
63081 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
63082 0 : void SgPointerType::accept (ROSE_VisitorPattern & visitor) {
63083 0 : ROSE_ASSERT(this != NULL);
63084 0 : visitor.visit(this);
63085 0 : }
63086 :
63087 : SgPointerType*
63088 0 : SgPointerType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
63089 : {
63090 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
63091 : // This function is currently only supported for the AST used the represent Binary executables.
63092 : if (0 /* isSgAsmNode(this) != NULL */)
63093 : {
63094 : // Support for regex specification.
63095 : std::string prefixCode = "REGEX:";
63096 : addNewAttribute(prefixCode + s,a);
63097 : }
63098 : #endif
63099 :
63100 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
63101 0 : return this;
63102 : }
63103 :
63104 : // *** COMMON CODE SECTION ENDS HERE ***
63105 :
63106 :
63107 : // End of memberFunctionString
63108 : // Start of memberFunctionString
63109 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
63110 :
63111 :
63112 : #if 0
63113 : //! Error checking support
63114 : /*! Verifies the following:
63115 : - working getVariant() member function
63116 : - calls base class's error() member function
63117 : Every class has one of these functions.
63118 : */
63119 : bool
63120 : SgPointerType::error()
63121 : {
63122 : // Put error checking here
63123 :
63124 : ROSE_ASSERT (this != NULL);
63125 : if (getVariant() != T_POINTER)
63126 : {
63127 : printf ("Error in SgPointerType::error(): SgPointerType object has a %s variant \n",
63128 : Cxx_GrammarTerminalNames[getVariant()].name);
63129 : // printf ("Error in SgPointerType::error() \n");
63130 : ROSE_ABORT();
63131 : }
63132 :
63133 : ROSE_ASSERT (getVariant() == T_POINTER);
63134 : return SgType::error();
63135 : }
63136 : #endif
63137 :
63138 :
63139 :
63140 : // End of memberFunctionString
63141 :
63142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
63143 :
63144 188652000 : SgPointerType* isSgPointerType ( SgNode* inputDerivedClassPointer )
63145 : {
63146 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
63147 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
63148 : // So to fix this we return NULL directly when the input is NULL and avoid the
63149 : // dynamic_cast in this case. This is likely a performance improvement as well.
63150 : // return dynamic_cast<SgPointerType*>(inputDerivedClassPointer);
63151 : // Milind Chabbi (8/28/2013): isSgPointerType uses table-driven castability instead of c++ default dynamic_cast
63152 : // this improves the running time performance by 10-20%.
63153 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPointerType*>(inputDerivedClassPointer);
63154 188652000 : return IS_SgPointerType_FAST_MACRO(inputDerivedClassPointer);
63155 : }
63156 :
63157 : // DQ (11/8/2003): Added version of functions taking const pointer
63158 5588 : const SgPointerType* isSgPointerType ( const SgNode* inputDerivedClassPointer )
63159 : {
63160 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
63161 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
63162 : // So to fix this we return NULL directly when the input is NULL and avoid the
63163 : // dynamic_cast in this case. This is likely a performance improvement as well.
63164 : // return dynamic_cast<const SgPointerType*>(inputDerivedClassPointer);
63165 : // Milind Chabbi (8/28/2013): isSgPointerType uses table-driven castability instead of c++ default dynamic_cast
63166 : // this improves the running time performance by 10-20%.
63167 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPointerType*>(inputDerivedClassPointer);
63168 5588 : return IS_SgPointerType_FAST_MACRO(inputDerivedClassPointer);
63169 : }
63170 :
63171 :
63172 :
63173 : /* #line 63174 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63174 :
63175 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
63176 :
63177 : /**
63178 : \brief Generated destructor
63179 :
63180 : This destructor is automatically generated (by ROSETTA). This destructor
63181 : only frees memory of data members associated with the parts of the current IR node which
63182 : are NOT traversed. Those data members that are part of a traversal can be freed using
63183 : a traversal (calling this destructor on all children in a post-order traversal). Such
63184 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
63185 :
63186 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
63187 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
63188 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
63189 :
63190 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
63191 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
63192 : pointers are not yet implemented to call delete on eash pointer in the container.
63193 : (This could be done by derivation from the STL containers to define containers that
63194 : automatically deleted their members.)
63195 :
63196 : */
63197 2822 : SgPointerType::~SgPointerType () {
63198 1440 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
63199 :
63200 :
63201 : // case: not a listType for base_type
63202 1440 : p_base_type = NULL; // non list case
63203 :
63204 : }
63205 :
63206 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
63207 2822 : }
63208 :
63209 :
63210 : /* #line 63211 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63211 :
63212 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
63213 :
63214 : // Generated constructor
63215 27368 : SgPointerType::SgPointerType ( SgType* base_type )
63216 27368 : : SgType()
63217 : {
63218 : #ifdef DEBUG
63219 : // printf ("In SgPointerType::SgPointerType (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
63220 : #endif
63221 : #if 0
63222 : // debugging information!
63223 : printf ("In SgPointerType::SgPointerType (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
63224 : #endif
63225 :
63226 27368 : p_base_type = base_type;
63227 :
63228 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
63229 :
63230 : #if 0
63231 : // DQ (7/30/2014): Call a virtual function.
63232 : std::string s = this->class_name();
63233 : #endif
63234 :
63235 : // Test the variant virtual function
63236 : // assert(T_POINTER == variant());
63237 27368 : assert(T_POINTER == this->variant());
63238 27368 : ROSE_ASSERT(T_POINTER == (int)(this->variantT()));
63239 27368 : post_construction_initialization();
63240 :
63241 : // Test the isSgPointerType() function since it has been problematic
63242 27368 : assert(isSgPointerType(this) != NULL);
63243 27368 : }
63244 :
63245 : // Generated constructor (all data members)
63246 :
63247 : /* #line 63248 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63248 :
63249 :
63250 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
63251 :
63252 :
63253 : // ********************************************************
63254 : // member functions common across all array grammar objects
63255 : // ********************************************************
63256 :
63257 :
63258 :
63259 : /* #line 63260 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63260 :
63261 :
63262 :
63263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
63264 :
63265 : // ********************************************************
63266 : // member functions specific to each node in the grammar
63267 : // ********************************************************
63268 :
63269 :
63270 : /* #line 63271 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63271 :
63272 : // Start of memberFunctionString
63273 : /* #line 6776 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
63274 :
63275 : // SgPointerMemberType* SgPointerMemberType::createType ( SgType* base_type, SgType *class_type )
63276 : SgPointerMemberType*
63277 0 : SgPointerMemberType::createType ( SgType* base_type, SgType *class_type, SgExpression* optional_fortran_type_kind )
63278 : {
63279 : // DQ (10/4/2010): I don't think this type can have a fortran type kind parameter.
63280 0 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
63281 :
63282 : #if 0
63283 : printf ("In SgPointerMemberType::createType() (CREATE_TYPE_FOR_POINTER_MEMBER_TYPE) \n");
63284 : #endif
63285 :
63286 0 : SgPointerMemberType* returnType = new SgPointerMemberType(base_type,class_type);
63287 0 : assert(returnType != NULL);
63288 0 : return returnType;
63289 : }
63290 :
63291 :
63292 :
63293 : // End of memberFunctionString
63294 : // Start of memberFunctionString
63295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
63296 :
63297 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
63298 :
63299 : SgType*
63300 3374 : SgPointerMemberType::get_class_type () const
63301 : {
63302 3374 : ROSE_ASSERT (this != NULL);
63303 :
63304 : #if 0
63305 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
63306 : // used to trigger marking transformations for the token-based unparsing.
63307 : printf ("SgPointerMemberType::get_class_type = %p = %s \n",this,this->class_name().c_str());
63308 : #endif
63309 :
63310 3374 : return p_class_type;
63311 : }
63312 :
63313 : void
63314 0 : SgPointerMemberType::set_class_type ( SgType* class_type )
63315 : {
63316 0 : ROSE_ASSERT (this != NULL);
63317 :
63318 : #if 0
63319 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
63320 : // used to trigger marking transformations for the token-based unparsing.
63321 : printf ("SgPointerMemberType::set_class_type = %p = %s \n",this,this->class_name().c_str());
63322 : #endif
63323 :
63324 0 : set_isModified(true);
63325 :
63326 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
63327 : if (p_class_type != NULL && class_type != NULL && p_class_type != class_type)
63328 : {
63329 : printf ("Warning: class_type = %p overwriting valid pointer p_class_type = %p \n",class_type,p_class_type);
63330 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
63331 : printf ("Error fails assertion (p_class_type != NULL && class_type != NULL && p_class_type != class_type) is false\n");
63332 : ROSE_ASSERT(false);
63333 : #endif
63334 : }
63335 : #endif
63336 0 : p_class_type = class_type;
63337 0 : }
63338 :
63339 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
63340 :
63341 :
63342 : // End of memberFunctionString
63343 : // Start of memberFunctionString
63344 : /* #line 1170 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
63345 :
63346 : // RV (2/3/2006): Updated this routine to use the mangling of the parent type.
63347 : SgName
63348 1254 : SgPointerMemberType::get_mangled (void) const
63349 : {
63350 1254 : ROSE_ASSERT(this != NULL);
63351 :
63352 : // Generate a pointer type _without_ the class name in it
63353 2508 : string base_str = SgPointerType::get_mangled ().getString ();
63354 :
63355 : // Mangle the class name
63356 1254 : const SgType* cls_type = get_class_type ();
63357 1254 : ROSE_ASSERT (cls_type);
63358 3762 : string cls_name = cls_type->get_mangled ().getString ();
63359 :
63360 : // Now embed the fully qualified class name in it
63361 2508 : string mangled_name (base_str);
63362 2508 : const string ptr_begin_tag ("__Pb__");
63363 1254 : string::size_type pos_begin = mangled_name.find (ptr_begin_tag);
63364 1254 : mangled_name.replace (pos_begin, ptr_begin_tag.size (), "__PMb__" + cls_name);
63365 :
63366 2508 : return SgName (mangled_name.c_str ());
63367 : }
63368 :
63369 : #if 0
63370 : // Old code
63371 : SgName
63372 : SgPointerMemberType::get_mangled ( SgUnparse_Info& info )
63373 : {
63374 : SgName tmp("M");
63375 : int cnt = 0;
63376 : ROSE_ASSERT(get_class_of() != NULL);
63377 : tmp << get_class_of()->get_mangled_qualified_name(cnt).str();
63378 :
63379 : #if 0
63380 : printf ("########### In SgPointerMemberType::get_mangled(): tmp = %s (get_base_type() = %s is a %s) ########## \n",
63381 : tmp.str(),get_class_of()->get_mangled_qualified_name(cnt).str(),get_class_of()->sage_class_name());
63382 : // ROSE_ASSERT(false);
63383 : #endif
63384 :
63385 : return tmp;
63386 : }
63387 : #endif
63388 :
63389 :
63390 :
63391 : // End of memberFunctionString
63392 : // Start of memberFunctionString
63393 : /* #line 3372 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
63394 :
63395 :
63396 : // DQ (4/11/2019): This function supports returning a SgDeclarationStatement instead of a SgClassDeclaration,
63397 : // which will always be well define where returning a SgClassDefinition is not always well defined. Using
63398 : // a SgDeclarationStatement will also allow it to work with the case of pointer to member associated with
63399 : // SgNonrealType IR nodes as well.
63400 : SgDeclarationStatement*
63401 786 : SgPointerMemberType::get_class_declaration_of() const
63402 : {
63403 786 : SgDeclarationStatement* result = NULL;
63404 :
63405 786 : if (get_class_type() != NULL)
63406 : {
63407 786 : SgType* type = get_class_type()->stripTypedefsAndModifiers();
63408 : // SgClassType *clsType = isSgClassType(get_class_type()->stripTypedefsAndModifiers());
63409 786 : SgClassType *clsType = isSgClassType(type);
63410 : // ROSE_ASSERT(clsType != NULL);
63411 :
63412 786 : if (clsType != NULL)
63413 : {
63414 : // DQ (4/11/2019): Note that the defining declaration may not exist.
63415 : // SgClassDeclaration *clsDecl = isSgClassDeclaration(clsType->get_declaration()->get_definingDeclaration());
63416 0 : SgClassDeclaration *clsDecl = isSgClassDeclaration(clsType->get_declaration());
63417 0 : result = clsDecl;
63418 : }
63419 : else
63420 : {
63421 : #if 0
63422 : printf ("WARNING: SgPointerMemberType::get_class_declaration_of() retuning NULL type = %p = %s \n",type,type->class_name().c_str());
63423 : #endif
63424 786 : SgNonrealType* nonrealType = isSgNonrealType(type);
63425 786 : ROSE_ASSERT(nonrealType != NULL);
63426 786 : result = nonrealType->get_declaration();
63427 : }
63428 :
63429 786 : ROSE_ASSERT(result != NULL);
63430 : }
63431 :
63432 0 : ROSE_ASSERT(result != NULL);
63433 :
63434 786 : return result;
63435 : }
63436 :
63437 : // DQ (4/11/2019): This is a depricated function, because it can not always return a valid SgClassDefinition.
63438 : SgClassDefinition*
63439 0 : SgPointerMemberType::get_class_definition_of() const
63440 : {
63441 0 : SgClassDefinition* result = NULL;
63442 :
63443 0 : if (get_class_type() != NULL)
63444 : {
63445 0 : SgType* type = get_class_type()->stripTypedefsAndModifiers();
63446 : // SgClassType *clsType = isSgClassType(get_class_type()->stripTypedefsAndModifiers());
63447 0 : SgClassType *clsType = isSgClassType(type);
63448 : // ROSE_ASSERT(clsType != NULL);
63449 : // SgClassType *clsType = isSgClassType(get_class_type()->stripTypedefsAndModifiers());
63450 : // ROSE_ASSERT(clsType != NULL);
63451 :
63452 0 : if (clsType != NULL)
63453 : {
63454 0 : SgClassDeclaration *clsDecl = isSgClassDeclaration(clsType->get_declaration()->get_definingDeclaration());
63455 :
63456 : // DQ (4/10/2019): This should not be an error when the SgClassDefinition is not available.
63457 : // But we might want to change the API to return the SgClassDeclaration instead.
63458 : // ROSE_ASSERT(clsDecl != NULL);
63459 : // return clsDecl->get_definition();
63460 :
63461 : // DQ (4/10/2019): This should not be an error when the SgClassDefinition is not available.
63462 0 : if (clsDecl != NULL)
63463 : {
63464 0 : result = clsDecl->get_definition();
63465 : }
63466 : else
63467 : {
63468 0 : printf ("NOTE: SgPointerMemberType::get_class_definition_of() retuning NULL: use SgPointerMemberType::get_class_declaration_of() instead! \n");
63469 : }
63470 : }
63471 : else
63472 : {
63473 0 : printf ("WARNING: SgPointerMemberType::get_class_definition_of() retuning NULL type = %p = %s \n",type,type->class_name().c_str());
63474 : }
63475 : }
63476 :
63477 0 : return result;
63478 : }
63479 :
63480 :
63481 : SgName
63482 548 : SgPointerMemberType::get_qualified_name_prefix_for_class_of() const
63483 : {
63484 : // DQ (4/18/2019): Adding support for type chains of types (including SgPointerMemberType).
63485 :
63486 : // DQ (5/29/2011): Added to support for new qualified name generation.
63487 : // This only applies to specific SgSupport IR nodes:
63488 : // SgVarRefExp
63489 : // SgFunctionRefExp
63490 : // SgMemberFunctionRefExp
63491 :
63492 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63493 : // printf ("In SgPointerMemberType::get_qualified_name_prefix_for_class_of(): search globalQualifiedNameMapForNames: this = %p = %s \n",this,this->class_name().c_str());
63494 : // printf ("In SgPointerMemberType::get_qualified_name_prefix_for_class_of(): search globalQualifiedNameMapForTypes: this = %p = %s \n",this,this->class_name().c_str());
63495 : printf ("In SgPointerMemberType::get_qualified_name_prefix_for_class_of(): search globalQualifiedNameMapForNames: this = %p = %s \n",this,this->class_name().c_str());
63496 : #endif
63497 :
63498 : // DQ (4/20/2019): Use the globalQualifiedNameMapForNames for the get_qualified_name_prefix_for_class_of() function.
63499 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
63500 : // different and so it depends upon where the type is referenced. Thus the qualified name is
63501 : // stored in a map to the IR node that references the type.
63502 548 : SgName nameQualifier;
63503 : // std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgPointerMemberType*>(this));
63504 : // std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgPointerMemberType*>(this));
63505 548 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgPointerMemberType*>(this));
63506 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
63507 :
63508 : // if (i != SgNode::get_globalQualifiedNameMapForNames().end())
63509 : // if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
63510 548 : if (i != SgNode::get_globalQualifiedNameMapForNames().end())
63511 : {
63512 382 : nameQualifier = i->second;
63513 :
63514 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63515 : printf ("In SgPointerMemberType::get_qualified_name_prefix_for_class_of(): Found a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
63516 : #endif
63517 : }
63518 : else
63519 : {
63520 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63521 : printf ("In SgPointerMemberType::get_qualified_name_prefix_for_class_of(): Could NOT find a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
63522 : #endif
63523 : }
63524 :
63525 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63526 : printf ("nameQualifier for SgType = %p = %p = %s = %s \n",this,const_cast<SgType*>(this),class_name().c_str(),nameQualifier.str());
63527 : #endif
63528 :
63529 : #if 0
63530 : // DQ (8/19/2013): Error checking on the globalTypeNameMap...check if there is an entry here that we might have wanted to use instead.
63531 : std::map<SgNode*,std::string>::iterator j = SgNode::get_globalTypeNameMap().find(const_cast<SgPointerMemberType*>(this));
63532 : if (j != SgNode::get_globalTypeNameMap().end())
63533 : {
63534 : SgName debug_nameQualifier = j->second;
63535 : printf ("In SgPointerMemberType::get_qualified_name_prefix_for_class_of(): Found a valid name qualification in the globalTypeNameMap: debug_nameQualifier = %s \n",debug_nameQualifier.str());
63536 : }
63537 : #endif
63538 :
63539 548 : return nameQualifier;
63540 : }
63541 :
63542 :
63543 : SgName
63544 548 : SgPointerMemberType::get_qualified_name_prefix_for_base_type() const
63545 : {
63546 : // DQ (4/18/2019): Adding support for type chains of types (including SgPointerMemberType).
63547 :
63548 : // DQ (5/29/2011): Added to support for new qualified name generation.
63549 : // This only applies to specific SgSupport IR nodes:
63550 : // SgVarRefExp
63551 : // SgFunctionRefExp
63552 : // SgMemberFunctionRefExp
63553 :
63554 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63555 : // printf ("In SgPointerMemberType::get_qualified_name_prefix(): search globalQualifiedNameMapForNames: this = %p = %s \n",this,this->class_name().c_str());
63556 : printf ("In SgPointerMemberType::get_qualified_name_prefix(): search globalQualifiedNameMapForTypes: this = %p = %s \n",this,this->class_name().c_str());
63557 : #endif
63558 :
63559 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
63560 : // different and so it depends upon where the type is referenced. Thus the qualified name is
63561 : // stored in a map to the IR node that references the type.
63562 548 : SgName nameQualifier;
63563 : // std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgPointerMemberType*>(this));
63564 548 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgPointerMemberType*>(this));
63565 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
63566 :
63567 : // if (i != SgNode::get_globalQualifiedNameMapForNames().end())
63568 548 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
63569 : {
63570 382 : nameQualifier = i->second;
63571 :
63572 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63573 : printf ("In SgPointerMemberType::get_qualified_name_prefix(): Found a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
63574 : #endif
63575 : }
63576 : else
63577 : {
63578 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63579 : printf ("In SgPointerMemberType::get_qualified_name_prefix(): Could NOT find a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
63580 : #endif
63581 : }
63582 :
63583 : #if DEBUG_SGTYPE_GET_QUALIFIED_NAME_PREFIX
63584 : printf ("nameQualifier for SgType = %p = %p = %s = %s \n",this,const_cast<SgType*>(this),class_name().c_str(),nameQualifier.str());
63585 : #endif
63586 :
63587 : #if 0
63588 : // DQ (8/19/2013): Error checking on the globalTypeNameMap...check if there is an entry here that we might have wanted to use instead.
63589 : std::map<SgNode*,std::string>::iterator j = SgNode::get_globalTypeNameMap().find(const_cast<SgPointerMemberType*>(this));
63590 : if (j != SgNode::get_globalTypeNameMap().end())
63591 : {
63592 : SgName debug_nameQualifier = j->second;
63593 : printf ("In SgPointerMemberType::get_qualified_name_prefix(): Found a valid name qualification in the globalTypeNameMap: debug_nameQualifier = %s \n",debug_nameQualifier.str());
63594 : }
63595 : #endif
63596 :
63597 548 : return nameQualifier;
63598 : }
63599 :
63600 :
63601 :
63602 :
63603 :
63604 : // End of memberFunctionString
63605 : // Start of memberFunctionString
63606 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
63607 :
63608 : // *** COMMON CODE SECTION BEGINS HERE ***
63609 :
63610 : #if 0
63611 : int
63612 : SgPointerMemberType::getVariant() const
63613 : {
63614 : // This function is used in ROSE while "variant()" is used in SAGE
63615 : assert(this != NULL);
63616 : return variant();
63617 : }
63618 : #endif
63619 :
63620 : // This function is used in ROSE in treeTraversal code
63621 : // eventually replaces getVariant() and variant()
63622 : // though after variant() has been removed for a while we will
63623 : // want to change the name of variantT() back to variant()
63624 : // (since the "T" was ment to stand for temporary).
63625 : // When this happens the variantT() will be depricated.
63626 : VariantT
63627 723540 : SgPointerMemberType::variantT() const
63628 : {
63629 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
63630 723540 : ROSE_ASSERT(this != NULL);
63631 723540 : return V_SgPointerMemberType;
63632 : }
63633 :
63634 : #if 0
63635 : int
63636 : SgPointerMemberType::variant() const
63637 : {
63638 : // This function is used in SAGE
63639 : ROSE_ASSERT(this != NULL);
63640 : return T_MEMBER_POINTER;
63641 : }
63642 : #endif
63643 :
63644 : ROSE_DLL_API const char*
63645 0 : SgPointerMemberType::sage_class_name() const
63646 : {
63647 0 : ROSE_ASSERT(this != NULL);
63648 0 : return "SgPointerMemberType";
63649 : }
63650 :
63651 : std::string
63652 219 : SgPointerMemberType::class_name() const
63653 : {
63654 219 : ROSE_ASSERT(this != NULL);
63655 219 : return "SgPointerMemberType";
63656 : }
63657 :
63658 : // DQ (11/26/2005): Support for visitor pattern mechanims
63659 : // (inferior to ROSE traversal mechanism, experimental).
63660 : void
63661 3973 : SgPointerMemberType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
63662 : {
63663 3973 : ROSE_ASSERT(this != NULL);
63664 3973 : visitor.visit(this);
63665 3973 : }
63666 :
63667 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
63668 0 : void SgPointerMemberType::accept (ROSE_VisitorPattern & visitor) {
63669 0 : ROSE_ASSERT(this != NULL);
63670 0 : visitor.visit(this);
63671 0 : }
63672 :
63673 : SgPointerMemberType*
63674 0 : SgPointerMemberType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
63675 : {
63676 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
63677 : // This function is currently only supported for the AST used the represent Binary executables.
63678 : if (0 /* isSgAsmNode(this) != NULL */)
63679 : {
63680 : // Support for regex specification.
63681 : std::string prefixCode = "REGEX:";
63682 : addNewAttribute(prefixCode + s,a);
63683 : }
63684 : #endif
63685 :
63686 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
63687 0 : return this;
63688 : }
63689 :
63690 : // *** COMMON CODE SECTION ENDS HERE ***
63691 :
63692 :
63693 : // End of memberFunctionString
63694 : // Start of memberFunctionString
63695 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
63696 :
63697 :
63698 : #if 0
63699 : //! Error checking support
63700 : /*! Verifies the following:
63701 : - working getVariant() member function
63702 : - calls base class's error() member function
63703 : Every class has one of these functions.
63704 : */
63705 : bool
63706 : SgPointerMemberType::error()
63707 : {
63708 : // Put error checking here
63709 :
63710 : ROSE_ASSERT (this != NULL);
63711 : if (getVariant() != T_MEMBER_POINTER)
63712 : {
63713 : printf ("Error in SgPointerMemberType::error(): SgPointerMemberType object has a %s variant \n",
63714 : Cxx_GrammarTerminalNames[getVariant()].name);
63715 : // printf ("Error in SgPointerMemberType::error() \n");
63716 : ROSE_ABORT();
63717 : }
63718 :
63719 : ROSE_ASSERT (getVariant() == T_MEMBER_POINTER);
63720 : return SgPointerType::error();
63721 : }
63722 : #endif
63723 :
63724 :
63725 :
63726 : // End of memberFunctionString
63727 :
63728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
63729 :
63730 25277100 : SgPointerMemberType* isSgPointerMemberType ( SgNode* inputDerivedClassPointer )
63731 : {
63732 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
63733 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
63734 : // So to fix this we return NULL directly when the input is NULL and avoid the
63735 : // dynamic_cast in this case. This is likely a performance improvement as well.
63736 : // return dynamic_cast<SgPointerMemberType*>(inputDerivedClassPointer);
63737 : // Milind Chabbi (8/28/2013): isSgPointerMemberType uses table-driven castability instead of c++ default dynamic_cast
63738 : // this improves the running time performance by 10-20%.
63739 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPointerMemberType*>(inputDerivedClassPointer);
63740 25277100 : return IS_SgPointerMemberType_FAST_MACRO(inputDerivedClassPointer);
63741 : }
63742 :
63743 : // DQ (11/8/2003): Added version of functions taking const pointer
63744 0 : const SgPointerMemberType* isSgPointerMemberType ( const SgNode* inputDerivedClassPointer )
63745 : {
63746 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
63747 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
63748 : // So to fix this we return NULL directly when the input is NULL and avoid the
63749 : // dynamic_cast in this case. This is likely a performance improvement as well.
63750 : // return dynamic_cast<const SgPointerMemberType*>(inputDerivedClassPointer);
63751 : // Milind Chabbi (8/28/2013): isSgPointerMemberType uses table-driven castability instead of c++ default dynamic_cast
63752 : // this improves the running time performance by 10-20%.
63753 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPointerMemberType*>(inputDerivedClassPointer);
63754 0 : return IS_SgPointerMemberType_FAST_MACRO(inputDerivedClassPointer);
63755 : }
63756 :
63757 :
63758 :
63759 : /* #line 63760 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63760 :
63761 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
63762 :
63763 : /**
63764 : \brief Generated destructor
63765 :
63766 : This destructor is automatically generated (by ROSETTA). This destructor
63767 : only frees memory of data members associated with the parts of the current IR node which
63768 : are NOT traversed. Those data members that are part of a traversal can be freed using
63769 : a traversal (calling this destructor on all children in a post-order traversal). Such
63770 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
63771 :
63772 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
63773 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
63774 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
63775 :
63776 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
63777 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
63778 : pointers are not yet implemented to call delete on eash pointer in the container.
63779 : (This could be done by derivation from the STL containers to define containers that
63780 : automatically deleted their members.)
63781 :
63782 : */
63783 116 : SgPointerMemberType::~SgPointerMemberType () {
63784 58 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
63785 :
63786 :
63787 : // case: not a listType for class_type
63788 58 : p_class_type = NULL; // non list case
63789 :
63790 : }
63791 :
63792 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
63793 116 : }
63794 :
63795 :
63796 : /* #line 63797 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63797 :
63798 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
63799 :
63800 : // Generated constructor
63801 242 : SgPointerMemberType::SgPointerMemberType ( SgType* base_type, SgType* class_type )
63802 242 : : SgPointerType(base_type)
63803 : {
63804 : #ifdef DEBUG
63805 : // printf ("In SgPointerMemberType::SgPointerMemberType (SgType* base_type, SgType* class_type) sage_class_name() = %s \n",sage_class_name());
63806 : #endif
63807 : #if 0
63808 : // debugging information!
63809 : printf ("In SgPointerMemberType::SgPointerMemberType (SgType* base_type, SgType* class_type): this = %p = %s \n",this,this->class_name().c_str());
63810 : #endif
63811 :
63812 242 : p_class_type = class_type;
63813 :
63814 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
63815 :
63816 : #if 0
63817 : // DQ (7/30/2014): Call a virtual function.
63818 : std::string s = this->class_name();
63819 : #endif
63820 :
63821 : // Test the variant virtual function
63822 : // assert(T_MEMBER_POINTER == variant());
63823 242 : assert(T_MEMBER_POINTER == this->variant());
63824 242 : ROSE_ASSERT(T_MEMBER_POINTER == (int)(this->variantT()));
63825 242 : post_construction_initialization();
63826 :
63827 : // Test the isSgPointerMemberType() function since it has been problematic
63828 242 : assert(isSgPointerMemberType(this) != NULL);
63829 242 : }
63830 :
63831 : // Generated constructor (all data members)
63832 :
63833 : /* #line 63834 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63834 :
63835 :
63836 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
63837 :
63838 :
63839 : // ********************************************************
63840 : // member functions common across all array grammar objects
63841 : // ********************************************************
63842 :
63843 :
63844 :
63845 : /* #line 63846 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63846 :
63847 :
63848 :
63849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
63850 :
63851 : // ********************************************************
63852 : // member functions specific to each node in the grammar
63853 : // ********************************************************
63854 :
63855 :
63856 : /* #line 63857 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
63857 :
63858 : // Start of memberFunctionString
63859 : /* #line 7494 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
63860 :
63861 : // SgReferenceType* SgReferenceType::createType(SgType* base_type)
63862 : SgReferenceType*
63863 6863 : SgReferenceType::createType(SgType* base_type, SgExpression* optional_fortran_type_kind)
63864 : {
63865 6863 : ROSE_ASSERT(base_type != NULL);
63866 :
63867 : // DQ (10/4/2010): I think that reference types can't have a kind parameter, so this should be NULL.
63868 6863 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
63869 :
63870 : #if 0
63871 : printf ("In SgReferenceType::createType() \n");
63872 : #endif
63873 :
63874 6863 : if (base_type->p_ref_to)
63875 : {
63876 : return base_type->p_ref_to;
63877 : }
63878 : else
63879 : {
63880 : #if 0
63881 : SgReferenceType* newType = new SgReferenceType(base_type);
63882 : assert(newType != NULL);
63883 : #else
63884 6835 : SgReferenceType* newType = new SgReferenceType(base_type);
63885 6835 : assert(newType != NULL);
63886 :
63887 6835 : SgName name = newType->get_mangled();
63888 :
63889 : #if 0
63890 : printf ("Building a reference to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
63891 : #endif
63892 : // Only look for pointers to type in the global type table.
63893 6835 : SgType* t = get_globalTypeTable()->lookup_type(name);
63894 :
63895 6835 : if (t == NULL)
63896 : {
63897 : // The pointer type was not found in the type table, put it into the global type table.
63898 : #if 0
63899 : // This is too agressive and fails for some test codes!
63900 : printf ("Mangled type name for SgReferenceType = %s (does NOT exist in type table) \n",name.str());
63901 : get_globalTypeTable()->insert_type(name,newType);
63902 : #else
63903 6831 : SgType* root_type = base_type->stripType();
63904 6831 : ROSE_ASSERT(root_type != NULL);
63905 6831 : if (handledUsingLocalTable(root_type) == false)
63906 : {
63907 : #if 0
63908 : printf ("Mangled type name for SgReferenceType = %s (does NOT exist in type table) inserting it... \n",name.str());
63909 : #endif
63910 777 : get_globalTypeTable()->insert_type(name,newType);
63911 : }
63912 : else
63913 : {
63914 : #if 0
63915 : printf ("Skip putting the SgReferenceType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
63916 : #endif
63917 : }
63918 : #endif
63919 : }
63920 : else
63921 : {
63922 : // If it is already present in the type table then delete the type (so that it will remain unique).
63923 : #if 0
63924 : printf ("Mangled type name for SgReferenceType = %s (already exists in type table) \n",name.str());
63925 : #endif
63926 4 : ROSE_ASSERT(t != newType);
63927 :
63928 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
63929 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
63930 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
63931 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
63932 4 : delete newType;
63933 : #endif
63934 4 : newType = NULL;
63935 :
63936 4 : newType = isSgReferenceType(t);
63937 : }
63938 : #endif
63939 :
63940 6835 : base_type->p_ref_to = newType;
63941 6835 : assert(base_type->p_ref_to != NULL);
63942 :
63943 6835 : return base_type->p_ref_to;
63944 : }
63945 : }
63946 :
63947 :
63948 :
63949 : // End of memberFunctionString
63950 : // Start of memberFunctionString
63951 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
63952 :
63953 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
63954 :
63955 : SgType*
63956 1765360 : SgReferenceType::get_base_type () const
63957 : {
63958 1765360 : ROSE_ASSERT (this != NULL);
63959 :
63960 : #if 0
63961 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
63962 : // used to trigger marking transformations for the token-based unparsing.
63963 : printf ("SgReferenceType::get_base_type = %p = %s \n",this,this->class_name().c_str());
63964 : #endif
63965 :
63966 1765360 : return p_base_type;
63967 : }
63968 :
63969 : void
63970 0 : SgReferenceType::set_base_type ( SgType* base_type )
63971 : {
63972 0 : ROSE_ASSERT (this != NULL);
63973 :
63974 : #if 0
63975 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
63976 : // used to trigger marking transformations for the token-based unparsing.
63977 : printf ("SgReferenceType::set_base_type = %p = %s \n",this,this->class_name().c_str());
63978 : #endif
63979 :
63980 0 : set_isModified(true);
63981 :
63982 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
63983 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
63984 : {
63985 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
63986 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
63987 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
63988 : ROSE_ASSERT(false);
63989 : #endif
63990 : }
63991 : #endif
63992 0 : p_base_type = base_type;
63993 0 : }
63994 :
63995 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
63996 :
63997 :
63998 : // End of memberFunctionString
63999 : // Start of memberFunctionString
64000 : /* #line 1094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
64001 :
64002 :
64003 : /*! Returns a mangled name representation of types with base types
64004 : * (e.g., pointer, reference).
64005 : */
64006 : SgName
64007 165573 : SgReferenceType::get_mangled (void) const
64008 : {
64009 : // DQ (10/23/2015): Note that these functions are called in the AST construction and that might not be
64010 : // required, plus it might be a performance issue as well. I didn't expect to see this while debugging
64011 : // a different subject. In general, I think we would like to push the generation of mangled names to
64012 : // the end of the AST processing; unless it is required for computing symble table keys (which is the
64013 : // likely usage within the AST construction, if so then I guess we have to allow these functions to be
64014 : // called in the frontend AST construction).
64015 :
64016 165573 : ROSE_ASSERT(this != NULL);
64017 :
64018 165573 : const SgType* base_type = get_base_type();
64019 165573 : ROSE_ASSERT (base_type != NULL);
64020 :
64021 : #if 0
64022 : printf ("In SgReferenceType::get_mangled(): base_type = %p = %s \n",base_type,base_type->class_name().c_str());
64023 : #endif
64024 :
64025 165573 : SgName base_name = base_type->get_mangled();
64026 :
64027 : #if 0
64028 : printf ("DONE: In SgReferenceType::get_mangled(): base_type = %p = %s base_name = %s \n",base_type,base_type->class_name().c_str(),base_name.str());
64029 : #endif
64030 :
64031 : // DQ (6/21/2006): Use is_null() instead of counting the size (and fixed case were it is null)
64032 : // ROSE_ASSERT (base_name.get_length ());
64033 165573 : if (base_name.is_null() == true)
64034 : {
64035 : // This happens for code such as: "typedef struct {int id; } *XYZ;"
64036 : // printf ("Warning: In SgReferenceType::get_mangled(), empty base type name found \n");
64037 0 : base_name = "un_named_base_type";
64038 : }
64039 165573 : ROSE_ASSERT (base_name.is_null() == false);
64040 :
64041 165573 : SgName mangled_name;
64042 331146 : mangled_name << "__" << "R" << "b__" // start tag
64043 331146 : << base_name.str () // base type
64044 331146 : << "__" << "R" << "e__"; // end tag
64045 :
64046 : // printf ("LEAVING: In SgReferenceType::get_mangled(): base_type = %p = %s mangled_name = %s \n",base_type,base_type->class_name().c_str(),mangled_name.str());
64047 :
64048 165573 : return mangled_name;
64049 : }
64050 :
64051 : #if 0
64052 : // Old version of function
64053 : SgName
64054 : SgReferenceType::get_mangled ( SgUnparse_Info & info )
64055 : {
64056 : SgName tmp("R");
64057 :
64058 : // DQ (3/15/2005): Should be be using a qualified name???
64059 :
64060 : ROSE_ASSERT(get_base_type() != NULL);
64061 : ROSE_ASSERT(get_base_type()->get_mangled(info).get_length() > 0);
64062 : tmp << get_base_type()->get_mangled(info).str();
64063 :
64064 : #if 0
64065 : printf ("########### In SgReferenceType::get_mangled(): tmp = %s (get_base_type() = %s is a %s) ########## \n",
64066 : tmp.str(),get_base_type()->get_mangled(info).str(),get_base_type()->sage_class_name());
64067 : // ROSE_ASSERT(false);
64068 : #endif
64069 :
64070 : return tmp;
64071 : }
64072 : #endif
64073 :
64074 :
64075 :
64076 : // End of memberFunctionString
64077 : // Start of memberFunctionString
64078 : /* #line 3583 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
64079 :
64080 :
64081 :
64082 : // End of memberFunctionString
64083 : // Start of memberFunctionString
64084 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
64085 :
64086 : // *** COMMON CODE SECTION BEGINS HERE ***
64087 :
64088 : #if 0
64089 : int
64090 : SgReferenceType::getVariant() const
64091 : {
64092 : // This function is used in ROSE while "variant()" is used in SAGE
64093 : assert(this != NULL);
64094 : return variant();
64095 : }
64096 : #endif
64097 :
64098 : // This function is used in ROSE in treeTraversal code
64099 : // eventually replaces getVariant() and variant()
64100 : // though after variant() has been removed for a while we will
64101 : // want to change the name of variantT() back to variant()
64102 : // (since the "T" was ment to stand for temporary).
64103 : // When this happens the variantT() will be depricated.
64104 : VariantT
64105 62666900 : SgReferenceType::variantT() const
64106 : {
64107 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
64108 62666900 : ROSE_ASSERT(this != NULL);
64109 62666900 : return V_SgReferenceType;
64110 : }
64111 :
64112 : #if 0
64113 : int
64114 : SgReferenceType::variant() const
64115 : {
64116 : // This function is used in SAGE
64117 : ROSE_ASSERT(this != NULL);
64118 : return T_REFERENCE;
64119 : }
64120 : #endif
64121 :
64122 : ROSE_DLL_API const char*
64123 0 : SgReferenceType::sage_class_name() const
64124 : {
64125 0 : ROSE_ASSERT(this != NULL);
64126 0 : return "SgReferenceType";
64127 : }
64128 :
64129 : std::string
64130 4868 : SgReferenceType::class_name() const
64131 : {
64132 4868 : ROSE_ASSERT(this != NULL);
64133 4868 : return "SgReferenceType";
64134 : }
64135 :
64136 : // DQ (11/26/2005): Support for visitor pattern mechanims
64137 : // (inferior to ROSE traversal mechanism, experimental).
64138 : void
64139 100828 : SgReferenceType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
64140 : {
64141 100828 : ROSE_ASSERT(this != NULL);
64142 100828 : visitor.visit(this);
64143 100828 : }
64144 :
64145 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
64146 0 : void SgReferenceType::accept (ROSE_VisitorPattern & visitor) {
64147 0 : ROSE_ASSERT(this != NULL);
64148 0 : visitor.visit(this);
64149 0 : }
64150 :
64151 : SgReferenceType*
64152 0 : SgReferenceType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
64153 : {
64154 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
64155 : // This function is currently only supported for the AST used the represent Binary executables.
64156 : if (0 /* isSgAsmNode(this) != NULL */)
64157 : {
64158 : // Support for regex specification.
64159 : std::string prefixCode = "REGEX:";
64160 : addNewAttribute(prefixCode + s,a);
64161 : }
64162 : #endif
64163 :
64164 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
64165 0 : return this;
64166 : }
64167 :
64168 : // *** COMMON CODE SECTION ENDS HERE ***
64169 :
64170 :
64171 : // End of memberFunctionString
64172 : // Start of memberFunctionString
64173 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
64174 :
64175 :
64176 : #if 0
64177 : //! Error checking support
64178 : /*! Verifies the following:
64179 : - working getVariant() member function
64180 : - calls base class's error() member function
64181 : Every class has one of these functions.
64182 : */
64183 : bool
64184 : SgReferenceType::error()
64185 : {
64186 : // Put error checking here
64187 :
64188 : ROSE_ASSERT (this != NULL);
64189 : if (getVariant() != T_REFERENCE)
64190 : {
64191 : printf ("Error in SgReferenceType::error(): SgReferenceType object has a %s variant \n",
64192 : Cxx_GrammarTerminalNames[getVariant()].name);
64193 : // printf ("Error in SgReferenceType::error() \n");
64194 : ROSE_ABORT();
64195 : }
64196 :
64197 : ROSE_ASSERT (getVariant() == T_REFERENCE);
64198 : return SgType::error();
64199 : }
64200 : #endif
64201 :
64202 :
64203 :
64204 : // End of memberFunctionString
64205 :
64206 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
64207 :
64208 188041000 : SgReferenceType* isSgReferenceType ( SgNode* inputDerivedClassPointer )
64209 : {
64210 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
64211 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
64212 : // So to fix this we return NULL directly when the input is NULL and avoid the
64213 : // dynamic_cast in this case. This is likely a performance improvement as well.
64214 : // return dynamic_cast<SgReferenceType*>(inputDerivedClassPointer);
64215 : // Milind Chabbi (8/28/2013): isSgReferenceType uses table-driven castability instead of c++ default dynamic_cast
64216 : // this improves the running time performance by 10-20%.
64217 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgReferenceType*>(inputDerivedClassPointer);
64218 188041000 : return IS_SgReferenceType_FAST_MACRO(inputDerivedClassPointer);
64219 : }
64220 :
64221 : // DQ (11/8/2003): Added version of functions taking const pointer
64222 1997 : const SgReferenceType* isSgReferenceType ( const SgNode* inputDerivedClassPointer )
64223 : {
64224 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
64225 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
64226 : // So to fix this we return NULL directly when the input is NULL and avoid the
64227 : // dynamic_cast in this case. This is likely a performance improvement as well.
64228 : // return dynamic_cast<const SgReferenceType*>(inputDerivedClassPointer);
64229 : // Milind Chabbi (8/28/2013): isSgReferenceType uses table-driven castability instead of c++ default dynamic_cast
64230 : // this improves the running time performance by 10-20%.
64231 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgReferenceType*>(inputDerivedClassPointer);
64232 1997 : return IS_SgReferenceType_FAST_MACRO(inputDerivedClassPointer);
64233 : }
64234 :
64235 :
64236 :
64237 : /* #line 64238 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64238 :
64239 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
64240 :
64241 : /**
64242 : \brief Generated destructor
64243 :
64244 : This destructor is automatically generated (by ROSETTA). This destructor
64245 : only frees memory of data members associated with the parts of the current IR node which
64246 : are NOT traversed. Those data members that are part of a traversal can be freed using
64247 : a traversal (calling this destructor on all children in a post-order traversal). Such
64248 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
64249 :
64250 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
64251 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
64252 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
64253 :
64254 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
64255 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
64256 : pointers are not yet implemented to call delete on eash pointer in the container.
64257 : (This could be done by derivation from the STL containers to define containers that
64258 : automatically deleted their members.)
64259 :
64260 : */
64261 2904 : SgReferenceType::~SgReferenceType () {
64262 1452 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
64263 :
64264 :
64265 : // case: not a listType for base_type
64266 1452 : p_base_type = NULL; // non list case
64267 :
64268 : }
64269 :
64270 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
64271 2904 : }
64272 :
64273 :
64274 : /* #line 64275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64275 :
64276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
64277 :
64278 : // Generated constructor
64279 6835 : SgReferenceType::SgReferenceType ( SgType* base_type )
64280 6835 : : SgType()
64281 : {
64282 : #ifdef DEBUG
64283 : // printf ("In SgReferenceType::SgReferenceType (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
64284 : #endif
64285 : #if 0
64286 : // debugging information!
64287 : printf ("In SgReferenceType::SgReferenceType (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
64288 : #endif
64289 :
64290 6835 : p_base_type = base_type;
64291 :
64292 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
64293 :
64294 : #if 0
64295 : // DQ (7/30/2014): Call a virtual function.
64296 : std::string s = this->class_name();
64297 : #endif
64298 :
64299 : // Test the variant virtual function
64300 : // assert(T_REFERENCE == variant());
64301 6835 : assert(T_REFERENCE == this->variant());
64302 6835 : ROSE_ASSERT(T_REFERENCE == (int)(this->variantT()));
64303 6835 : post_construction_initialization();
64304 :
64305 : // Test the isSgReferenceType() function since it has been problematic
64306 6835 : assert(isSgReferenceType(this) != NULL);
64307 6835 : }
64308 :
64309 : // Generated constructor (all data members)
64310 :
64311 : /* #line 64312 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64312 :
64313 :
64314 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
64315 :
64316 :
64317 : // ********************************************************
64318 : // member functions common across all array grammar objects
64319 : // ********************************************************
64320 :
64321 :
64322 :
64323 : /* #line 64324 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64324 :
64325 :
64326 :
64327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
64328 :
64329 : // ********************************************************
64330 : // member functions specific to each node in the grammar
64331 : // ********************************************************
64332 :
64333 :
64334 : /* #line 64335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64335 :
64336 : // Start of memberFunctionString
64337 :
64338 :
64339 : // End of memberFunctionString
64340 : // Start of memberFunctionString
64341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
64342 :
64343 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
64344 :
64345 : SgDeclarationStatement*
64346 197849000 : SgNamedType::get_declaration () const
64347 : {
64348 197849000 : ROSE_ASSERT (this != NULL);
64349 :
64350 : #if 0
64351 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
64352 : // used to trigger marking transformations for the token-based unparsing.
64353 : printf ("SgNamedType::get_declaration = %p = %s \n",this,this->class_name().c_str());
64354 : #endif
64355 :
64356 197849000 : return p_declaration;
64357 : }
64358 :
64359 : void
64360 49325 : SgNamedType::set_declaration ( SgDeclarationStatement* declaration )
64361 : {
64362 49325 : ROSE_ASSERT (this != NULL);
64363 :
64364 : #if 0
64365 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
64366 : // used to trigger marking transformations for the token-based unparsing.
64367 : printf ("SgNamedType::set_declaration = %p = %s \n",this,this->class_name().c_str());
64368 : #endif
64369 :
64370 49325 : set_isModified(true);
64371 :
64372 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
64373 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
64374 : {
64375 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
64376 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
64377 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
64378 : ROSE_ASSERT(false);
64379 : #endif
64380 : }
64381 : #endif
64382 49325 : p_declaration = declaration;
64383 49325 : }
64384 :
64385 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
64386 :
64387 :
64388 : // End of memberFunctionString
64389 : // Start of memberFunctionString
64390 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
64391 :
64392 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
64393 :
64394 : bool
64395 0 : SgNamedType::get_autonomous_declaration () const
64396 : {
64397 0 : ROSE_ASSERT (this != NULL);
64398 :
64399 : #if 0
64400 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
64401 : // used to trigger marking transformations for the token-based unparsing.
64402 : printf ("SgNamedType::get_autonomous_declaration = %p = %s \n",this,this->class_name().c_str());
64403 : #endif
64404 :
64405 0 : return p_autonomous_declaration;
64406 : }
64407 :
64408 : void
64409 0 : SgNamedType::set_autonomous_declaration ( bool autonomous_declaration )
64410 : {
64411 0 : ROSE_ASSERT (this != NULL);
64412 :
64413 : #if 0
64414 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
64415 : // used to trigger marking transformations for the token-based unparsing.
64416 : printf ("SgNamedType::set_autonomous_declaration = %p = %s \n",this,this->class_name().c_str());
64417 : #endif
64418 :
64419 0 : set_isModified(true);
64420 :
64421 0 : p_autonomous_declaration = autonomous_declaration;
64422 0 : }
64423 :
64424 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
64425 :
64426 :
64427 : // End of memberFunctionString
64428 : // Start of memberFunctionString
64429 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
64430 :
64431 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
64432 :
64433 : bool
64434 0 : SgNamedType::get_is_from_template_parameter () const
64435 : {
64436 0 : ROSE_ASSERT (this != NULL);
64437 :
64438 : #if 0
64439 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
64440 : // used to trigger marking transformations for the token-based unparsing.
64441 : printf ("SgNamedType::get_is_from_template_parameter = %p = %s \n",this,this->class_name().c_str());
64442 : #endif
64443 :
64444 0 : return p_is_from_template_parameter;
64445 : }
64446 :
64447 : void
64448 0 : SgNamedType::set_is_from_template_parameter ( bool is_from_template_parameter )
64449 : {
64450 0 : ROSE_ASSERT (this != NULL);
64451 :
64452 : #if 0
64453 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
64454 : // used to trigger marking transformations for the token-based unparsing.
64455 : printf ("SgNamedType::set_is_from_template_parameter = %p = %s \n",this,this->class_name().c_str());
64456 : #endif
64457 :
64458 0 : set_isModified(true);
64459 :
64460 0 : p_is_from_template_parameter = is_from_template_parameter;
64461 0 : }
64462 :
64463 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
64464 :
64465 :
64466 : // End of memberFunctionString
64467 : // Start of memberFunctionString
64468 : /* #line 3762 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
64469 :
64470 : // DQ (12/21/2005): Build the static empty list to use as a default argument for the SgQualifiedNameType constructor
64471 : // SgQualifiedNamePtrList SgNamedType::p_defaultQualifiedNamePtrList;
64472 :
64473 0 : SgNamedType::SgNamedType ( const SgNamedType & X )
64474 : {
64475 0 : p_declaration = X.p_declaration;
64476 0 : p_autonomous_declaration = X.p_autonomous_declaration;
64477 :
64478 0 : ROSE_ASSERT(p_declaration != NULL);
64479 0 : }
64480 :
64481 : SgName
64482 0 : SgNamedType::get_name() const
64483 : {
64484 0 : printf ("Error: base class SgNamedType::get_name() called! \n");
64485 0 : ROSE_ABORT();
64486 :
64487 : return SgName();
64488 : }
64489 :
64490 :
64491 : SgName
64492 44856 : SgNamedType::get_qualified_name() const
64493 : {
64494 : // DQ (10/15/2004): This function is similar to the one for SgClassDeclaration.
64495 : // This function calls get_scope() which uses the parent pointers, thus
64496 : // it should not be called before the parent pointers are set (within the AST fixup after
64497 : // the Sage III AST is fully constructed).
64498 :
64499 : // printf ("In SgNamedType::get_qualified_name() for %p = %s name = %s \n",this,sage_class_name(),get_name().str());
64500 :
64501 44856 : ROSE_ASSERT(get_declaration() != NULL);
64502 :
64503 : // DQ (6/23/2005): This does not appear to be required any more (I think)
64504 : // ROSE_ASSERT(get_declaration()->get_parent() != NULL);
64505 :
64506 : #if 0
64507 : printf ("In SgNamedType::get_qualified_name() get_declaration() = %p = %s at: \n",get_declaration(),get_declaration()->sage_class_name());
64508 : get_declaration()->get_file_info()->display("In SgNamedType::get_qualified_name(): location of declaration");
64509 : #endif
64510 :
64511 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
64512 44856 : SgScopeStatement* scope = get_declaration()->get_scope();
64513 44856 : ROSE_ASSERT(scope != NULL);
64514 :
64515 : // printf ("In SgNamedType::get_qualified_name(): scope->sage_class_name() = %s \n",scope->sage_class_name());
64516 :
64517 89712 : SgName returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
64518 :
64519 : // printf ("In SgNamedType::get_qualified_name() returnName = %s \n",returnName.str());
64520 :
64521 : // printf ("Exiting at end of SgNamedType::get_qualified_name() \n");
64522 : // ROSE_ASSERT(false);
64523 :
64524 44856 : return returnName;
64525 : }
64526 :
64527 :
64528 :
64529 : // End of memberFunctionString
64530 : // Start of memberFunctionString
64531 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
64532 :
64533 : // *** COMMON CODE SECTION BEGINS HERE ***
64534 :
64535 : #if 0
64536 : int
64537 : SgNamedType::getVariant() const
64538 : {
64539 : // This function is used in ROSE while "variant()" is used in SAGE
64540 : assert(this != NULL);
64541 : return variant();
64542 : }
64543 : #endif
64544 :
64545 : // This function is used in ROSE in treeTraversal code
64546 : // eventually replaces getVariant() and variant()
64547 : // though after variant() has been removed for a while we will
64548 : // want to change the name of variantT() back to variant()
64549 : // (since the "T" was ment to stand for temporary).
64550 : // When this happens the variantT() will be depricated.
64551 : VariantT
64552 371448 : SgNamedType::variantT() const
64553 : {
64554 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
64555 371448 : ROSE_ASSERT(this != NULL);
64556 371448 : return V_SgNamedType;
64557 : }
64558 :
64559 : #if 0
64560 : int
64561 : SgNamedType::variant() const
64562 : {
64563 : // This function is used in SAGE
64564 : ROSE_ASSERT(this != NULL);
64565 : return T_NAME;
64566 : }
64567 : #endif
64568 :
64569 : ROSE_DLL_API const char*
64570 0 : SgNamedType::sage_class_name() const
64571 : {
64572 0 : ROSE_ASSERT(this != NULL);
64573 0 : return "SgNamedType";
64574 : }
64575 :
64576 : std::string
64577 0 : SgNamedType::class_name() const
64578 : {
64579 0 : ROSE_ASSERT(this != NULL);
64580 0 : return "SgNamedType";
64581 : }
64582 :
64583 : // DQ (11/26/2005): Support for visitor pattern mechanims
64584 : // (inferior to ROSE traversal mechanism, experimental).
64585 : void
64586 0 : SgNamedType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
64587 : {
64588 0 : ROSE_ASSERT(this != NULL);
64589 0 : visitor.visit(this);
64590 0 : }
64591 :
64592 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
64593 0 : void SgNamedType::accept (ROSE_VisitorPattern & visitor) {
64594 0 : ROSE_ASSERT(this != NULL);
64595 0 : visitor.visit(this);
64596 0 : }
64597 :
64598 : SgNamedType*
64599 0 : SgNamedType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
64600 : {
64601 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
64602 : // This function is currently only supported for the AST used the represent Binary executables.
64603 : if (0 /* isSgAsmNode(this) != NULL */)
64604 : {
64605 : // Support for regex specification.
64606 : std::string prefixCode = "REGEX:";
64607 : addNewAttribute(prefixCode + s,a);
64608 : }
64609 : #endif
64610 :
64611 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
64612 0 : return this;
64613 : }
64614 :
64615 : // *** COMMON CODE SECTION ENDS HERE ***
64616 :
64617 :
64618 : // End of memberFunctionString
64619 : // Start of memberFunctionString
64620 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
64621 :
64622 :
64623 : #if 0
64624 : //! Error checking support
64625 : /*! Verifies the following:
64626 : - working getVariant() member function
64627 : - calls base class's error() member function
64628 : Every class has one of these functions.
64629 : */
64630 : bool
64631 : SgNamedType::error()
64632 : {
64633 : // Put error checking here
64634 :
64635 : ROSE_ASSERT (this != NULL);
64636 : if (getVariant() != T_NAME)
64637 : {
64638 : printf ("Error in SgNamedType::error(): SgNamedType object has a %s variant \n",
64639 : Cxx_GrammarTerminalNames[getVariant()].name);
64640 : // printf ("Error in SgNamedType::error() \n");
64641 : ROSE_ABORT();
64642 : }
64643 :
64644 : ROSE_ASSERT (getVariant() == T_NAME);
64645 : return SgType::error();
64646 : }
64647 : #endif
64648 :
64649 :
64650 :
64651 : // End of memberFunctionString
64652 : // Start of memberFunctionString
64653 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
64654 :
64655 :
64656 : // DQ (1/31/2006): Modified to build all types in the memory pools
64657 : // SgNamedType SgNamedType::builtin_type;
64658 : // SgNamedType* SgNamedType::builtin_type = new SgNamedType();
64659 : SgNamedType* SgNamedType::p_builtin_type = NULL;
64660 :
64661 :
64662 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
64663 : // SgNamedType* SgNamedType::createType(void)
64664 : SgNamedType*
64665 0 : SgNamedType::createType(SgExpression* optional_fortran_type_kind)
64666 : {
64667 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
64668 : // is not called (likely because static initialization is compiler dependent).
64669 : // DQ (1/31/2006): Modified to build all types in the memory pools
64670 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
64671 : // return &builtin_type;
64672 :
64673 : #if 0
64674 : printf ("In SgNamedType::createType() (COMMON_CREATE_TYPE) \n");
64675 : #endif
64676 :
64677 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
64678 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
64679 :
64680 0 : SgNamedType* temp_type = new SgNamedType();
64681 :
64682 : #if 0
64683 : printf ("In SgNamedType::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
64684 : #endif
64685 :
64686 : // DQ (10/31/2016): Added assertion.
64687 0 : ROSE_ASSERT(temp_type != NULL);
64688 :
64689 0 : if (optional_fortran_type_kind != NULL)
64690 : {
64691 : // DQ (10/31/2016): Added assertion.
64692 0 : ROSE_ASSERT(temp_type != NULL);
64693 :
64694 0 : temp_type->set_type_kind(optional_fortran_type_kind);
64695 : }
64696 : #if 0
64697 : else
64698 : {
64699 : // Let p_builtin_type refer to the unadorned type (no type kind).
64700 : p_builtin_type = temp_type;
64701 : }
64702 : #endif
64703 :
64704 0 : SgName name = temp_type->get_mangled();
64705 :
64706 : #if 0
64707 : printf ("Mangled type name for SgNamedType = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
64708 : #endif
64709 :
64710 : // DQ (10/31/2016): Added assertion.
64711 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
64712 :
64713 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
64714 :
64715 : #if 0
64716 : printf ("In SgNamedType::createType(): type from lookup_type = %p \n",t);
64717 : #endif
64718 :
64719 0 : if (t == NULL)
64720 : {
64721 0 : get_globalTypeTable()->insert_type(name,temp_type);
64722 : }
64723 : else
64724 : {
64725 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
64726 0 : if (t != temp_type)
64727 : {
64728 : #if 0
64729 : printf ("In SgNamedType::createType(): deleting temp_type = %p \n",temp_type);
64730 : #endif
64731 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
64732 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
64733 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
64734 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
64735 0 : delete temp_type;
64736 : #endif
64737 0 : temp_type = NULL;
64738 : #if 0
64739 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
64740 : if (optional_fortran_type_kind != NULL)
64741 : {
64742 : p_builtin_type = NULL;
64743 : }
64744 : #endif
64745 : }
64746 :
64747 : // Reuse this tempType variable so we can use the same code below.
64748 0 : temp_type = isSgNamedType(t);
64749 0 : ROSE_ASSERT(temp_type != NULL);
64750 : }
64751 :
64752 : #if 0
64753 : printf ("Leaving SgNamedType::createType(): temp_type = %p \n",temp_type);
64754 : #endif
64755 :
64756 0 : return temp_type;
64757 : }
64758 :
64759 :
64760 :
64761 : // End of memberFunctionString
64762 :
64763 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
64764 :
64765 14619300 : SgNamedType* isSgNamedType ( SgNode* inputDerivedClassPointer )
64766 : {
64767 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
64768 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
64769 : // So to fix this we return NULL directly when the input is NULL and avoid the
64770 : // dynamic_cast in this case. This is likely a performance improvement as well.
64771 : // return dynamic_cast<SgNamedType*>(inputDerivedClassPointer);
64772 : // Milind Chabbi (8/28/2013): isSgNamedType uses table-driven castability instead of c++ default dynamic_cast
64773 : // this improves the running time performance by 10-20%.
64774 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNamedType*>(inputDerivedClassPointer);
64775 14619300 : return IS_SgNamedType_FAST_MACRO(inputDerivedClassPointer);
64776 : }
64777 :
64778 : // DQ (11/8/2003): Added version of functions taking const pointer
64779 62714 : const SgNamedType* isSgNamedType ( const SgNode* inputDerivedClassPointer )
64780 : {
64781 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
64782 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
64783 : // So to fix this we return NULL directly when the input is NULL and avoid the
64784 : // dynamic_cast in this case. This is likely a performance improvement as well.
64785 : // return dynamic_cast<const SgNamedType*>(inputDerivedClassPointer);
64786 : // Milind Chabbi (8/28/2013): isSgNamedType uses table-driven castability instead of c++ default dynamic_cast
64787 : // this improves the running time performance by 10-20%.
64788 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNamedType*>(inputDerivedClassPointer);
64789 62714 : return IS_SgNamedType_FAST_MACRO(inputDerivedClassPointer);
64790 : }
64791 :
64792 :
64793 :
64794 : /* #line 64795 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64795 :
64796 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
64797 :
64798 : /**
64799 : \brief Generated destructor
64800 :
64801 : This destructor is automatically generated (by ROSETTA). This destructor
64802 : only frees memory of data members associated with the parts of the current IR node which
64803 : are NOT traversed. Those data members that are part of a traversal can be freed using
64804 : a traversal (calling this destructor on all children in a post-order traversal). Such
64805 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
64806 :
64807 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
64808 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
64809 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
64810 :
64811 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
64812 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
64813 : pointers are not yet implemented to call delete on eash pointer in the container.
64814 : (This could be done by derivation from the STL containers to define containers that
64815 : automatically deleted their members.)
64816 :
64817 : */
64818 18512 : SgNamedType::~SgNamedType () {
64819 18512 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
64820 :
64821 :
64822 : // case: not a listType for declaration
64823 18512 : p_declaration = NULL; // non list case
64824 : // case: not a listType for autonomous_declaration
64825 18512 : p_autonomous_declaration = true; // non list case
64826 : // case: not a listType for is_from_template_parameter
64827 18512 : p_is_from_template_parameter = false; // non list case
64828 :
64829 : }
64830 :
64831 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
64832 18512 : }
64833 :
64834 :
64835 : /* #line 64836 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64836 :
64837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
64838 :
64839 : // Generated constructor
64840 123816 : SgNamedType::SgNamedType ( SgDeclarationStatement* declaration )
64841 123816 : : SgType()
64842 : {
64843 : #ifdef DEBUG
64844 : // printf ("In SgNamedType::SgNamedType (SgDeclarationStatement* declaration) sage_class_name() = %s \n",sage_class_name());
64845 : #endif
64846 : #if 0
64847 : // debugging information!
64848 : printf ("In SgNamedType::SgNamedType (SgDeclarationStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
64849 : #endif
64850 :
64851 123816 : p_declaration = declaration;
64852 123816 : p_autonomous_declaration = true;
64853 123816 : p_is_from_template_parameter = false;
64854 :
64855 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
64856 :
64857 : #if 0
64858 : // DQ (7/30/2014): Call a virtual function.
64859 : std::string s = this->class_name();
64860 : #endif
64861 :
64862 : // Test the variant virtual function
64863 : // assert(T_NAME == variant());
64864 123816 : assert(T_NAME == this->variant());
64865 123816 : ROSE_ASSERT(T_NAME == (int)(this->variantT()));
64866 123816 : post_construction_initialization();
64867 :
64868 : // Test the isSgNamedType() function since it has been problematic
64869 123816 : assert(isSgNamedType(this) != NULL);
64870 123816 : }
64871 :
64872 : // Generated constructor (all data members)
64873 :
64874 : /* #line 64875 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64875 :
64876 :
64877 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
64878 :
64879 :
64880 : // ********************************************************
64881 : // member functions common across all array grammar objects
64882 : // ********************************************************
64883 :
64884 :
64885 :
64886 : /* #line 64887 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64887 :
64888 :
64889 :
64890 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
64891 :
64892 : // ********************************************************
64893 : // member functions specific to each node in the grammar
64894 : // ********************************************************
64895 :
64896 :
64897 : /* #line 64898 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
64898 :
64899 : // Start of memberFunctionString
64900 : /* #line 7050 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
64901 :
64902 :
64903 : // SgClassType* SgClassType::createType(SgClassDeclaration * cd)
64904 : // SgClassType* SgClassType::createType(SgClassDeclaration * cd, SgExpression* optional_fortran_type_kind)
64905 : SgClassType*
64906 19930 : SgClassType::createType(SgDeclarationStatement* cd, SgExpression* optional_fortran_type_kind)
64907 : {
64908 19930 : ROSE_ASSERT(cd != NULL);
64909 :
64910 : #define DEBUG_CREATE_TYPE_FOR_CLASS_TYPE 0
64911 :
64912 : // DQ (10/4/2010): I think that pointer types can't have a kind parameter, so this should be NULL.
64913 19930 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
64914 :
64915 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64916 : printf ("In SgClassType::createType() \n");
64917 : #endif
64918 :
64919 : // DQ (12/4/2011): Adding template declaration support to AST. An SgClassType is modified to hold a SgTemplateClassDeclaration or a SgClassDeclaration.
64920 19930 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(cd);
64921 19930 : SgTemplateClassDeclaration* templateClassDeclaration = isSgTemplateClassDeclaration(cd);
64922 19930 : ROSE_ASSERT(classDeclaration != NULL || templateClassDeclaration != NULL);
64923 19930 : ROSE_ASSERT(classDeclaration != NULL);
64924 :
64925 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64926 : // These debugging statements don't deal with the modifications to handle SgTemplateClassDeclaration.
64927 : printf ("In SgClassType::createType(): cd = %p = %s cd->get_definition() = %p = %s \n",classDeclaration,classDeclaration->class_name().c_str(),
64928 : classDeclaration->get_definition(),(classDeclaration->get_definition() != NULL) ? classDeclaration->get_definition()->class_name().c_str() : "NULL");
64929 : printf ("In SgClassType::createType(): cd->get_type() = %p \n",classDeclaration->get_type());
64930 : printf ("In SgClassType::createType(): cd = %p cd->get_definingDeclaration() = %p \n",classDeclaration,classDeclaration->get_definingDeclaration());
64931 : printf ("In SgClassType::createType(): cd = %p cd->get_firstNondefiningDeclaration() = %p \n",classDeclaration,classDeclaration->get_firstNondefiningDeclaration());
64932 : #endif
64933 :
64934 19930 : SgType* type_from_declaration = NULL;
64935 : // if (classDeclaration != NULL)
64936 19930 : if (templateClassDeclaration == NULL)
64937 : {
64938 14392 : ROSE_ASSERT(classDeclaration != NULL);
64939 14392 : type_from_declaration = classDeclaration->get_type();
64940 : // ROSE_ASSERT(type_from_declaration != NULL);
64941 : }
64942 : else
64943 : {
64944 5538 : ROSE_ASSERT(templateClassDeclaration != NULL);
64945 5538 : type_from_declaration = templateClassDeclaration->get_type();
64946 : // ROSE_ASSERT(type_from_declaration != NULL);
64947 : }
64948 :
64949 : // ROSE_ASSERT(type_from_declaration != NULL);
64950 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64951 : printf ("Inside of SgClassType::createType(): cd = %p = %s type_from_declaration = %p \n",cd,cd->class_name().c_str(),type_from_declaration);
64952 : #endif
64953 :
64954 : // if (!cd->get_type())
64955 19930 : if (type_from_declaration == NULL)
64956 : {
64957 : #if 0
64958 : SgClassType* newType = new SgClassType(cd);
64959 : ROSE_ASSERT(newType != NULL);
64960 : cd->set_type(newType);
64961 : // cd->set_type(new SgClassType(cd));
64962 : #else
64963 : // DQ (7/22/2010): Use the global type table to get the type.
64964 19074 : SgClassType* newType = new SgClassType(cd);
64965 19074 : ROSE_ASSERT(newType != NULL);
64966 :
64967 : // DQ (3/14/2012): Note that the new template support allows that classDeclaration is non-null (since template classes are derived from non-template classes).
64968 19074 : ROSE_ASSERT(classDeclaration != NULL);
64969 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64970 : printf ("Inside of SgClassType::createType(): cd = %p = %s = %s newType = %p = %s \n",cd,cd->class_name().c_str(),classDeclaration->get_name().str(),newType,newType->class_name().c_str());
64971 : #endif
64972 19074 : SgScopeStatement* currentScope = getCurrentScope();
64973 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64974 : printf ("Inside of SgClassType::createType(): currentScope = %p = %s \n",currentScope,currentScope->class_name().c_str());
64975 : #endif
64976 : // DQ (3/14/2012): Make sure that this is a valid pointer else it might explain why qualification is not being use to generate the mangled names.
64977 : // ROSE_ASSERT(cd->get_scope() != NULL);
64978 19074 : if (cd->get_scope() == NULL && currentScope != NULL)
64979 : {
64980 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64981 : printf ("Inside of SgClassType::createType(): Setting scope for cd = %p = %s to currentScope = %p = %s \n",cd,cd->class_name().c_str(),currentScope,currentScope->class_name().c_str());
64982 : #endif
64983 0 : cd->set_scope(currentScope);
64984 : }
64985 19074 : ROSE_ASSERT(cd->get_scope() != NULL);
64986 :
64987 : // We have to build the type before we can generate a mangled name for it.
64988 38148 : SgName name = newType->get_mangled();
64989 :
64990 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64991 : printf ("Inside of SgClassType::createType(): type name (newType->get_mangled()) = %s \n",name.str());
64992 : #endif
64993 19074 : if (name.is_null() == true)
64994 : {
64995 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
64996 : printf ("Need to handle special case of SgClassDeclaration of un-named class cd = %p = %s \n",cd,cd->class_name().c_str());
64997 : #endif
64998 : #if 0
64999 : printf ("Need to handle special case of SgClassDeclaration of un-named class cd = %p = %s \n",cd,cd->class_name().c_str());
65000 : ROSE_ASSERT(cd->get_file_info() != NULL);
65001 : cd->get_file_info()->display("Need to handle special case of SgClassDeclaration of un-named class");
65002 : #endif
65003 : // name = SageInterface::generateUniqueName(cd,/* ignoreDifferenceBetweenDefiningAndNondefiningDeclarations = */ true);
65004 2 : name = SageInterface::generateUniqueName(newType,/* ignoreDifferenceBetweenDefiningAndNondefiningDeclarations = */ true);
65005 : #if 0
65006 : printf ("Generated a unique name (using SageInterface::generateUniqueName())= %s \n",name.str());
65007 : #endif
65008 : // name = SageInterface::get_name(newType);
65009 : // printf ("Generated a unique name (using SageInterface::get_name()) = %s \n",name.str());
65010 : // ROSE_ASSERT(false);
65011 : }
65012 19074 : ROSE_ASSERT(name.is_null() == false);
65013 :
65014 : // SgScopeStatement* currentScope = getCurrentScope();
65015 :
65016 19074 : if (currentScope != NULL)
65017 : {
65018 : // DQ (7/30/2010): If valid pointer then we are in the process of building the C/C++/Fortran AST.
65019 : // SgType* t = currentScope->get_type_table()->lookup_type(name);
65020 19069 : SgType* t = currentScope->get_type_table()->lookup_type(name);
65021 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65022 : printf ("Inside of SgClassType::createType(): after calling lookup_type(): t = %p = %s \n",t,(t != NULL) ? t->class_name().c_str() : "null");
65023 : #endif
65024 19069 : if (t == NULL)
65025 : {
65026 : // If the type is not in the type table then insert it so that we can reuse it.
65027 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65028 : printf ("Mangled type name for SgClassType = %s (not available in type table) \n",name.str());
65029 : #endif
65030 : // get_globalTypeTable()->insert_type(name,newType);
65031 18839 : currentScope->get_type_table()->insert_type(name,newType);
65032 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65033 : printf ("This SgClassType::createType() function also sets the type in the SgClassDeclaration = %p \n",cd);
65034 : #endif
65035 :
65036 : // DQ (12/4/2011): Modified to support template declarations in the AST.
65037 : // cd->set_type(newType);
65038 18839 : if (classDeclaration != NULL)
65039 18839 : classDeclaration->set_type(newType);
65040 : else
65041 : templateClassDeclaration->set_type(newType);
65042 : }
65043 : else
65044 : {
65045 : // If it is already present in the type table then delete the type (so that it will remain unique).
65046 230 : SgClassType* classType = isSgClassType(t);
65047 230 : ROSE_ASSERT(classType != NULL);
65048 230 : ROSE_ASSERT(classType->get_declaration() != NULL);
65049 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65050 : printf ("Mangled type classType = %p (classType->get_declaration() = %p = %s) name for SgClassType name = %s (already exists in type table) \n",t,classType->get_declaration(),classType->get_declaration()->class_name().c_str(),name.str());
65051 : #endif
65052 : // DQ (3/21/2012): New test.
65053 : // ROSE_ASSERT(t != newType);
65054 : // delete newType;
65055 : // newType = NULL;
65056 :
65057 : // DQ (3/21/2012): New conditional test for t != newType (and delete new type only then).
65058 230 : if (t != newType)
65059 : {
65060 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65061 : printf ("Deleting the just built exploritory type = %p (case of t != newType) t = %p = %s \n",newType,t,t->class_name().c_str());
65062 : #endif
65063 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
65064 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
65065 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
65066 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
65067 230 : delete newType;
65068 : #endif
65069 230 : newType = NULL;
65070 : }
65071 : else
65072 : {
65073 0 : printf ("WARNING: In SgClassType::createType(): Found a case of t == newType \n");
65074 : }
65075 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65076 : printf ("This SgClassType::createType() function also sets the type in the SgClassDeclaration = %p \n",cd);
65077 : #endif
65078 230 : SgClassType* typeFromTypeTable = isSgClassType(t);
65079 :
65080 : // DQ (3/21/2012): New test.
65081 230 : ROSE_ASSERT(typeFromTypeTable != NULL);
65082 :
65083 : // DQ (12/4/2011): Modified to support template declarations in the AST.
65084 : // cd->set_type(typeFromTypeTable);
65085 230 : if (classDeclaration != NULL)
65086 230 : classDeclaration->set_type(typeFromTypeTable);
65087 : else
65088 : templateClassDeclaration->set_type(typeFromTypeTable);
65089 : }
65090 : }
65091 : else
65092 : {
65093 : // Set the type using the generated type that might be redundant with a previously
65094 : // generated type (something to sort out when we either merge local type tables or
65095 : // when we connect the AST fragment being built (bottom up) into the large AST).
65096 :
65097 : // DQ (12/4/2011): Modified to support template declarations in the AST.
65098 : // cd->set_type(newType);
65099 : // if (classDeclaration != NULL)
65100 5 : if (templateClassDeclaration == NULL)
65101 : {
65102 4 : ROSE_ASSERT(classDeclaration != NULL);
65103 4 : classDeclaration->set_type(newType);
65104 : }
65105 : else
65106 : {
65107 1 : ROSE_ASSERT(templateClassDeclaration != NULL);
65108 1 : templateClassDeclaration->set_type(newType);
65109 : }
65110 :
65111 : }
65112 : #endif
65113 : }
65114 :
65115 : // return (SgClassType*) cd->get_type();
65116 :
65117 : // ROSE_ASSERT(type_from_declaration != NULL);
65118 : // return (SgClassType*) type_from_declaration;
65119 :
65120 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65121 : printf ("SgClassType::createType(): classDeclaration = %p \n",classDeclaration);
65122 : printf ("SgClassType::createType(): templateClassDeclaration = %p \n",templateClassDeclaration);
65123 : #endif
65124 :
65125 19930 : SgClassType* returnType = NULL;
65126 19930 : if (classDeclaration != NULL)
65127 : {
65128 19930 : ROSE_ASSERT(classDeclaration->get_type() != NULL);
65129 19930 : returnType = isSgClassType(classDeclaration->get_type());
65130 19930 : if (returnType == NULL)
65131 : {
65132 0 : printf ("Error: returnType == NULL: classDeclaration->get_type() = %p = %s \n",classDeclaration->get_type(),classDeclaration->get_type()->class_name().c_str());
65133 : }
65134 19930 : ROSE_ASSERT(returnType != NULL);
65135 : }
65136 : else
65137 : {
65138 : returnType = isSgClassType(templateClassDeclaration->get_type());
65139 : ROSE_ASSERT(returnType != NULL);
65140 : }
65141 :
65142 19930 : ROSE_ASSERT(returnType != NULL);
65143 :
65144 : // DQ (3/22/2012): Added assertions.
65145 19930 : if (returnType->get_declaration() != cd)
65146 : {
65147 : #if 0
65148 : printf ("In SgClassType::createType(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
65149 : printf ("In SgClassType::createType(): returnType->get_declaration() = %p = %s cd = %p = %s \n",returnType->get_declaration(),
65150 : returnType->get_declaration()->class_name().c_str(),cd,cd->class_name().c_str());
65151 : printf ("In SgClassType::createType(): returnType->get_declaration() = %p = %s cd = %p = %s \n",returnType->get_declaration(),
65152 : isSgClassDeclaration(returnType->get_declaration())->get_name().str(),classDeclaration,classDeclaration->get_name().str());
65153 : #endif
65154 230 : ROSE_ASSERT(returnType->get_declaration()->get_firstNondefiningDeclaration() != NULL);
65155 230 : ROSE_ASSERT(cd->get_firstNondefiningDeclaration() != NULL);
65156 : #if 0
65157 : printf ("In SgClassType::createType(): returnType->get_declaration()->get_firstNondefiningDeclaration() = %p = %s cd->get_firstNondefiningDeclaration() = %p = %s \n",
65158 : returnType->get_declaration()->get_firstNondefiningDeclaration(),returnType->get_declaration()->get_firstNondefiningDeclaration()->class_name().c_str(),
65159 : cd->get_firstNondefiningDeclaration(),cd->get_firstNondefiningDeclaration()->class_name().c_str());
65160 : #endif
65161 : }
65162 : #if 0
65163 : // DQ (1/22/2013): We can't assert this when we have complex template handling as in Boost.
65164 : // This case is demonstrated in Boost as part of ROSE compiling ROSE in testRoseHeaders_01.C
65165 :
65166 : // DQ (8/23/2012): Restoring the original code...
65167 : ROSE_ASSERT(returnType->get_declaration() == cd);
65168 : #else
65169 : // DQ (8/23/2012): Note clear if this is helpful given the new name handling to resolve template instantiations when template arguments are NOT name qualified.
65170 : // This fails for test2011_121.C.
65171 : // ROSE_ASSERT(returnType->get_declaration() == cd);
65172 :
65173 : #if 0
65174 : // DQ (3/12/2015): This is failing the test for spurious output, so I will comment out the warning.
65175 : // DQ (2/14/2015): Adding filter to throttle this output. I think it is important, but it appears to not be critical at the moment.
65176 : // It also appears to be a direct result of the bug fix that removed the collision of computed function types in test2015_11.C.
65177 : if (returnType->get_declaration() != cd)
65178 : {
65179 : static int counter = 0;
65180 : if (counter % 100 == 0)
65181 : {
65182 : printf ("WARNING: In SgClassType::createType(): commented out asertion returnType->get_declaration() == cd \n");
65183 : }
65184 :
65185 : counter++;
65186 : }
65187 : #endif
65188 : #endif
65189 :
65190 : #if DEBUG_CREATE_TYPE_FOR_CLASS_TYPE
65191 : printf ("Leaving SgClassType::createType(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
65192 : #endif
65193 :
65194 : // return (SgClassType*) returnType;
65195 19930 : return returnType;
65196 : }
65197 :
65198 :
65199 :
65200 : // End of memberFunctionString
65201 : // Start of memberFunctionString
65202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
65203 :
65204 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
65205 :
65206 : bool
65207 0 : SgClassType::get_packed () const
65208 : {
65209 0 : ROSE_ASSERT (this != NULL);
65210 :
65211 : #if 0
65212 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
65213 : // used to trigger marking transformations for the token-based unparsing.
65214 : printf ("SgClassType::get_packed = %p = %s \n",this,this->class_name().c_str());
65215 : #endif
65216 :
65217 0 : return p_packed;
65218 : }
65219 :
65220 : void
65221 0 : SgClassType::set_packed ( bool packed )
65222 : {
65223 0 : ROSE_ASSERT (this != NULL);
65224 :
65225 : #if 0
65226 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
65227 : // used to trigger marking transformations for the token-based unparsing.
65228 : printf ("SgClassType::set_packed = %p = %s \n",this,this->class_name().c_str());
65229 : #endif
65230 :
65231 0 : set_isModified(true);
65232 :
65233 0 : p_packed = packed;
65234 0 : }
65235 :
65236 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
65237 :
65238 :
65239 : // End of memberFunctionString
65240 : // Start of memberFunctionString
65241 : /* #line 3823 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
65242 :
65243 0 : SgClassType::SgClassType ( const SgClassType & X )
65244 0 : : SgNamedType(X)
65245 : {
65246 0 : }
65247 :
65248 :
65249 : SgName
65250 343641 : SgClassType::get_name() const
65251 : {
65252 : // DQ (12/4/2011): Adding support for template declarations in the AST.
65253 : // if (get_declaration() != NULL)
65254 343641 : SgDeclarationStatement* declaration = get_declaration();
65255 343641 : if (declaration != NULL)
65256 : {
65257 : // DQ (12/4/2011): Handling support for SgClassDeclaration and SgTemplateClassDeclaration declarations.
65258 : // return isSgClassDeclaration(get_declaration())->get_name();
65259 343641 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(declaration);
65260 343641 : SgTemplateClassDeclaration* templateClassDeclaration = isSgTemplateClassDeclaration(declaration);
65261 343641 : if (templateClassDeclaration != NULL) {
65262 63547 : return templateClassDeclaration->get_name();
65263 280094 : } else if (classDeclaration != NULL) {
65264 280094 : return classDeclaration->get_name();
65265 : } else {
65266 0 : ROSE_ASSERT(false);
65267 : }
65268 : }
65269 : else
65270 : {
65271 0 : return SgName((char *)0L);
65272 : }
65273 : }
65274 :
65275 :
65276 : // RV (1/31/2006): Changed behavior to return a fully-qualified, mangled name.
65277 : /*! Returns a mangled name (with embedded, mangled qualifiers).
65278 : * \note If the class is anonymous, e.g.,
65279 : * typedef struct { int a; char b; } tag_t;
65280 : * then this routine returns an empty name.
65281 : */
65282 : #define DEBUG_CLASS_TYPE_GET_MANGLED 0
65283 : SgName
65284 278610 : SgClassType::get_mangled(void) const
65285 : {
65286 278610 : ROSE_ASSERT(this != NULL);
65287 :
65288 : #if DEBUG_CLASS_TYPE_GET_MANGLED
65289 : printf ("In SgClassType::get_mangled(): get_name() = %s \n",get_name().str());
65290 : #endif
65291 :
65292 278610 : SgName mangled_name;
65293 : // if (get_name().get_length() != 0) // not anonymous
65294 278610 : if (get_name().is_null() == false) // not anonymous
65295 : {
65296 278609 : const SgClassDeclaration* class_decl = isSgClassDeclaration(get_declaration());
65297 : #if DEBUG_CLASS_TYPE_GET_MANGLED
65298 : printf ("In SgClassType::get_mangled(): class_decl = %p = %s \n",class_decl, ((class_decl == NULL) ? "NULL" : class_decl->class_name().c_str()) );
65299 : #endif
65300 278609 : if (class_decl != NULL)
65301 : {
65302 : // DQ (3/14/2012): We need to have a valid scope or else the name qualification will be empty.
65303 278609 : ROSE_ASSERT(class_decl->get_scope() != NULL);
65304 :
65305 : // DQ (7/29/2010): Template instantiation declarations can differ on template parameters so we have to dig a little farther.
65306 278609 : const SgTemplateInstantiationDecl* template_class_inst = isSgTemplateInstantiationDecl(get_declaration());
65307 278609 : const SgTemplateClassDeclaration* template_class_decl = isSgTemplateClassDeclaration(get_declaration());
65308 278609 : if (template_class_inst != NULL)
65309 : {
65310 118527 : mangled_name = template_class_inst->get_mangled_name();
65311 : #if DEBUG_CLASS_TYPE_GET_MANGLED
65312 : printf ("In SgClassType::get_mangled(): SgTemplateInstantiationDecl mangled_name = %s \n",mangled_name.str());
65313 : #endif
65314 : }
65315 160082 : else if (template_class_decl != NULL)
65316 : {
65317 61067 : mangled_name = template_class_decl->get_mangled_name();
65318 : #if 0
65319 : printf ("In SgClassType::get_mangled(): SgTemplateClassDeclaration mangled_name = %s \n",mangled_name.str());
65320 : #endif
65321 : }
65322 : else
65323 : {
65324 : // DQ (3/14/2012): We need to have a valid scope or else the name qualification will be empty.
65325 99015 : ROSE_ASSERT(class_decl->get_scope() != NULL);
65326 :
65327 : // This is for just a simple SgClassDeclaration.
65328 99015 : mangled_name = class_decl->get_mangled_name();
65329 : #if DEBUG_CLASS_TYPE_GET_MANGLED
65330 : printf ("In SgClassType::get_mangled(): SgClassDeclaration calling class_decl->get_mangled_name() --- mangled_name = %s \n",mangled_name.str());
65331 : #endif
65332 : }
65333 : }
65334 : }
65335 :
65336 : #if DEBUG_CLASS_TYPE_GET_MANGLED
65337 : printf ("Leaving SgClassType::get_mangled(): mangled_name = %s \n",mangled_name.str());
65338 : #endif
65339 :
65340 278610 : return mangled_name;
65341 : }
65342 :
65343 : #if 0
65344 : // Older code
65345 : SgName
65346 : SgClassType::get_mangled(SgUnparse_Info&)
65347 : {
65348 : SgName tmp;
65349 : // todo: what should be done when the class name is nil (anonymous class?)
65350 :
65351 : #if 0
65352 : SgName name = get_name();
65353 : if (!name.is_null())
65354 : {
65355 : tmp << strlen(name.str()) << name.str();
65356 : }
65357 : #else
65358 : SgName name = get_qualified_name();
65359 : // printf ("Using get_qualified_name() instead of get_name() in get_mangled() name = %s \n",name.str());
65360 : if (!name.is_null())
65361 : {
65362 : // DQ (6/23/2005): type names put into the symbol table (function symbol table) should be name qualified (maybe)
65363 : // tmp << strlen(get_name().str()) << get_name().str();
65364 : // tmp << strlen(get_mangled_name().str()) << get_mangled_name().str();
65365 : tmp << strlen(name.str()) << name.str();
65366 : }
65367 : #endif
65368 :
65369 : return tmp;
65370 : }
65371 : #endif
65372 :
65373 :
65374 :
65375 : // End of memberFunctionString
65376 : // Start of memberFunctionString
65377 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
65378 :
65379 : // *** COMMON CODE SECTION BEGINS HERE ***
65380 :
65381 : #if 0
65382 : int
65383 : SgClassType::getVariant() const
65384 : {
65385 : // This function is used in ROSE while "variant()" is used in SAGE
65386 : assert(this != NULL);
65387 : return variant();
65388 : }
65389 : #endif
65390 :
65391 : // This function is used in ROSE in treeTraversal code
65392 : // eventually replaces getVariant() and variant()
65393 : // though after variant() has been removed for a while we will
65394 : // want to change the name of variantT() back to variant()
65395 : // (since the "T" was ment to stand for temporary).
65396 : // When this happens the variantT() will be depricated.
65397 : VariantT
65398 69552200 : SgClassType::variantT() const
65399 : {
65400 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
65401 69552200 : ROSE_ASSERT(this != NULL);
65402 69552200 : return V_SgClassType;
65403 : }
65404 :
65405 : #if 0
65406 : int
65407 : SgClassType::variant() const
65408 : {
65409 : // This function is used in SAGE
65410 : ROSE_ASSERT(this != NULL);
65411 : return T_CLASS;
65412 : }
65413 : #endif
65414 :
65415 : ROSE_DLL_API const char*
65416 0 : SgClassType::sage_class_name() const
65417 : {
65418 0 : ROSE_ASSERT(this != NULL);
65419 0 : return "SgClassType";
65420 : }
65421 :
65422 : std::string
65423 15120 : SgClassType::class_name() const
65424 : {
65425 15120 : ROSE_ASSERT(this != NULL);
65426 15120 : return "SgClassType";
65427 : }
65428 :
65429 : // DQ (11/26/2005): Support for visitor pattern mechanims
65430 : // (inferior to ROSE traversal mechanism, experimental).
65431 : void
65432 192585 : SgClassType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
65433 : {
65434 192585 : ROSE_ASSERT(this != NULL);
65435 192585 : visitor.visit(this);
65436 192585 : }
65437 :
65438 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
65439 0 : void SgClassType::accept (ROSE_VisitorPattern & visitor) {
65440 0 : ROSE_ASSERT(this != NULL);
65441 0 : visitor.visit(this);
65442 0 : }
65443 :
65444 : SgClassType*
65445 0 : SgClassType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
65446 : {
65447 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
65448 : // This function is currently only supported for the AST used the represent Binary executables.
65449 : if (0 /* isSgAsmNode(this) != NULL */)
65450 : {
65451 : // Support for regex specification.
65452 : std::string prefixCode = "REGEX:";
65453 : addNewAttribute(prefixCode + s,a);
65454 : }
65455 : #endif
65456 :
65457 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
65458 0 : return this;
65459 : }
65460 :
65461 : // *** COMMON CODE SECTION ENDS HERE ***
65462 :
65463 :
65464 : // End of memberFunctionString
65465 : // Start of memberFunctionString
65466 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
65467 :
65468 :
65469 : #if 0
65470 : //! Error checking support
65471 : /*! Verifies the following:
65472 : - working getVariant() member function
65473 : - calls base class's error() member function
65474 : Every class has one of these functions.
65475 : */
65476 : bool
65477 : SgClassType::error()
65478 : {
65479 : // Put error checking here
65480 :
65481 : ROSE_ASSERT (this != NULL);
65482 : if (getVariant() != T_CLASS)
65483 : {
65484 : printf ("Error in SgClassType::error(): SgClassType object has a %s variant \n",
65485 : Cxx_GrammarTerminalNames[getVariant()].name);
65486 : // printf ("Error in SgClassType::error() \n");
65487 : ROSE_ABORT();
65488 : }
65489 :
65490 : ROSE_ASSERT (getVariant() == T_CLASS);
65491 : return SgNamedType::error();
65492 : }
65493 : #endif
65494 :
65495 :
65496 :
65497 : // End of memberFunctionString
65498 :
65499 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
65500 :
65501 11855300 : SgClassType* isSgClassType ( SgNode* inputDerivedClassPointer )
65502 : {
65503 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
65504 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
65505 : // So to fix this we return NULL directly when the input is NULL and avoid the
65506 : // dynamic_cast in this case. This is likely a performance improvement as well.
65507 : // return dynamic_cast<SgClassType*>(inputDerivedClassPointer);
65508 : // Milind Chabbi (8/28/2013): isSgClassType uses table-driven castability instead of c++ default dynamic_cast
65509 : // this improves the running time performance by 10-20%.
65510 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassType*>(inputDerivedClassPointer);
65511 11855300 : return IS_SgClassType_FAST_MACRO(inputDerivedClassPointer);
65512 : }
65513 :
65514 : // DQ (11/8/2003): Added version of functions taking const pointer
65515 0 : const SgClassType* isSgClassType ( const SgNode* inputDerivedClassPointer )
65516 : {
65517 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
65518 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
65519 : // So to fix this we return NULL directly when the input is NULL and avoid the
65520 : // dynamic_cast in this case. This is likely a performance improvement as well.
65521 : // return dynamic_cast<const SgClassType*>(inputDerivedClassPointer);
65522 : // Milind Chabbi (8/28/2013): isSgClassType uses table-driven castability instead of c++ default dynamic_cast
65523 : // this improves the running time performance by 10-20%.
65524 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassType*>(inputDerivedClassPointer);
65525 0 : return IS_SgClassType_FAST_MACRO(inputDerivedClassPointer);
65526 : }
65527 :
65528 :
65529 :
65530 : /* #line 65531 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
65531 :
65532 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
65533 :
65534 : /**
65535 : \brief Generated destructor
65536 :
65537 : This destructor is automatically generated (by ROSETTA). This destructor
65538 : only frees memory of data members associated with the parts of the current IR node which
65539 : are NOT traversed. Those data members that are part of a traversal can be freed using
65540 : a traversal (calling this destructor on all children in a post-order traversal). Such
65541 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
65542 :
65543 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
65544 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
65545 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
65546 :
65547 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
65548 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
65549 : pointers are not yet implemented to call delete on eash pointer in the container.
65550 : (This could be done by derivation from the STL containers to define containers that
65551 : automatically deleted their members.)
65552 :
65553 : */
65554 6064 : SgClassType::~SgClassType () {
65555 3032 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
65556 :
65557 :
65558 : // case: not a listType for packed
65559 3032 : p_packed = false; // non list case
65560 :
65561 : }
65562 :
65563 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
65564 6064 : }
65565 :
65566 :
65567 : /* #line 65568 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
65568 :
65569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
65570 :
65571 : // Generated constructor
65572 19074 : SgClassType::SgClassType ( SgDeclarationStatement* declaration )
65573 19074 : : SgNamedType(declaration)
65574 : {
65575 : #ifdef DEBUG
65576 : // printf ("In SgClassType::SgClassType (SgDeclarationStatement* declaration) sage_class_name() = %s \n",sage_class_name());
65577 : #endif
65578 : #if 0
65579 : // debugging information!
65580 : printf ("In SgClassType::SgClassType (SgDeclarationStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
65581 : #endif
65582 :
65583 19074 : p_packed = false;
65584 :
65585 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
65586 :
65587 : #if 0
65588 : // DQ (7/30/2014): Call a virtual function.
65589 : std::string s = this->class_name();
65590 : #endif
65591 :
65592 : // Test the variant virtual function
65593 : // assert(T_CLASS == variant());
65594 19074 : assert(T_CLASS == this->variant());
65595 19074 : ROSE_ASSERT(T_CLASS == (int)(this->variantT()));
65596 19074 : post_construction_initialization();
65597 :
65598 : // Test the isSgClassType() function since it has been problematic
65599 19074 : assert(isSgClassType(this) != NULL);
65600 19074 : }
65601 :
65602 : // Generated constructor (all data members)
65603 :
65604 : /* #line 65605 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
65605 :
65606 :
65607 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
65608 :
65609 :
65610 : // ********************************************************
65611 : // member functions common across all array grammar objects
65612 : // ********************************************************
65613 :
65614 :
65615 :
65616 : /* #line 65617 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
65617 :
65618 :
65619 :
65620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
65621 :
65622 : // ********************************************************
65623 : // member functions specific to each node in the grammar
65624 : // ********************************************************
65625 :
65626 :
65627 : /* #line 65628 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
65628 :
65629 : // Start of memberFunctionString
65630 : /* #line 6940 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
65631 :
65632 : // SgEnumType* SgEnumType::createType(SgEnumDeclaration* cd)
65633 : SgEnumType*
65634 25595 : SgEnumType::createType(SgEnumDeclaration* cd, SgExpression* optional_fortran_type_kind)
65635 : {
65636 : // DQ (10/4/2010): I think that pointer types can't have a kind parameter, so this should be NULL.
65637 25595 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
65638 :
65639 25595 : SgEnumType* returnType = NULL;
65640 : // return cd->get_type() ? cd->get_type() : new SgEnumType(cd);
65641 :
65642 25595 : assert(cd != NULL);
65643 :
65644 : #if 0
65645 : printf ("In SgEnumType::createType() \n");
65646 : #endif
65647 :
65648 25595 : returnType = cd->get_type();
65649 25595 : if (returnType == NULL)
65650 : {
65651 : #if 0
65652 : returnType = new SgEnumType(cd);
65653 : #else
65654 : // DQ (7/22/2010): Use the global type table to get the type.
65655 :
65656 2932 : returnType = new SgEnumType(cd);
65657 2932 : ROSE_ASSERT(returnType != NULL);
65658 :
65659 : // We have to build the type before we can generate a mangle name for it.
65660 5864 : SgName name = returnType->get_mangled();
65661 :
65662 : #if 0
65663 : printf ("In SgEnumType::createType(): cd = %p = %s \n",cd,name.str());
65664 : #endif
65665 :
65666 2932 : if (name.is_null() == true)
65667 : {
65668 : #if 0
65669 : printf ("Need to handle special case of SgEnumDeclaration of un-named class cd = %p = %s \n",cd,cd->class_name().c_str());
65670 : // ROSE_ASSERT(cd->get_file_info() != NULL);
65671 : // cd->get_file_info()->display("Need to handle special case of SgClassDeclaration of un-named class");
65672 : #endif
65673 0 : name = SageInterface::generateUniqueName(returnType,/* ignoreDifferenceBetweenDefiningAndNondefiningDeclarations = */ true);
65674 : #if 0
65675 : printf ("In SgEnumType::createType(): Generated a unique name (using SageInterface::generateUniqueName())= %s \n",name.str());
65676 : #endif
65677 : }
65678 2932 : ROSE_ASSERT(name.is_null() == false);
65679 :
65680 2932 : SgScopeStatement* currentScope = getCurrentScope();
65681 :
65682 : #if 0
65683 : printf ("In SgEnumType::createType(): currentScope = %p = %s \n",currentScope,currentScope != NULL ? currentScope->class_name().c_str() : "NULL");
65684 : #endif
65685 :
65686 2932 : if (currentScope != NULL)
65687 : {
65688 : // DQ (7/30/2010): If valid pointer then we are in the process of building the C/C++/Fortran AST.
65689 2932 : SgType* t = currentScope->get_type_table()->lookup_type(name);
65690 2932 : if (t == NULL)
65691 : {
65692 : // If the type is not in the type table then insert it so that we can reuse it.
65693 : #if 0
65694 : printf ("Mangled type name for SgEnumType = %s (not available in type table) \n",name.str());
65695 : #endif
65696 : // get_globalTypeTable()->insert_type(name,returnType);
65697 1482 : currentScope->get_type_table()->insert_type(name,returnType);
65698 : }
65699 : else
65700 : {
65701 : // If it is already present in the type table then delete the type (so that it will remain unique).
65702 : #if 0
65703 : printf ("Mangled type name for SgEnumType = %s (already exists in type table) \n",name.str());
65704 : #endif
65705 1450 : ROSE_ASSERT(t != returnType);
65706 :
65707 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
65708 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
65709 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
65710 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
65711 1450 : delete returnType;
65712 : #endif
65713 1450 : returnType = NULL;
65714 :
65715 : // Reuse this returnType variable so we can use the same code below.
65716 1450 : ROSE_ASSERT(t != NULL);
65717 1450 : returnType = isSgEnumType(t);
65718 :
65719 1450 : if (returnType == NULL)
65720 : {
65721 0 : printf ("ERROR: returnType == NULL --- t = %p = %s \n",t,t->class_name().c_str());
65722 0 : cd->get_file_info()->display("ERROR: returnType == NULL");
65723 : }
65724 1450 : ROSE_ASSERT(returnType != NULL);
65725 : }
65726 : }
65727 : #endif
65728 : }
65729 : #if 0
65730 : printf ("This SgEnumType::createType() function does NOT set the type in the SgEnumDeclaration = %p \n",cd);
65731 : #endif
65732 :
65733 25595 : ROSE_ASSERT(returnType != NULL);
65734 :
65735 25595 : return returnType;
65736 : }
65737 :
65738 :
65739 :
65740 : // End of memberFunctionString
65741 : // Start of memberFunctionString
65742 : /* #line 4032 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
65743 :
65744 :
65745 0 : SgEnumType::SgEnumType ( const SgEnumType & X )
65746 0 : : SgNamedType(X)
65747 : {
65748 0 : }
65749 :
65750 :
65751 : SgName
65752 1381 : SgEnumType::get_name() const
65753 : {
65754 1381 : if(get_declaration())
65755 1381 : return isSgEnumDeclaration(get_declaration())->get_name();
65756 : else
65757 0 : return SgName((char *)0L);
65758 : }
65759 :
65760 :
65761 : // RV (2/1/2006): Updated to use the declaration's mangling routine.
65762 : SgName
65763 8091 : SgEnumType::get_mangled (void) const
65764 : {
65765 8091 : ROSE_ASSERT(this != NULL);
65766 :
65767 8091 : const SgEnumDeclaration* decl = isSgEnumDeclaration (get_declaration());
65768 8091 : ROSE_ASSERT (decl != NULL);
65769 :
65770 : // DQ (1/12/13): Assert that this is not a previously deleted IR node (which will have the name = "SgNode").
65771 : // ROSE_ASSERT(decl->get_scope() != NULL);
65772 :
65773 : #if 0
65774 : printf ("SgEnumType::get_mangled(): decl->get_scope() = %p \n",decl->get_scope());
65775 : #endif
65776 :
65777 8091 : if (decl->get_scope() != NULL)
65778 : {
65779 : #if 0
65780 : printf ("SgEnumType::get_mangled(): decl->get_scope() = %p = %s name = %s \n",decl->get_scope(),decl->get_scope()->class_name().c_str(),SageInterface::get_name(decl->get_scope()).c_str());
65781 : #endif
65782 :
65783 9544 : ROSE_ASSERT(decl->get_scope()->class_name() != "SgNode");
65784 : }
65785 :
65786 : // DQ (1/12/13): Added assertion (only makes sense for non SgGlobal scopes).
65787 8091 : if (isSgGlobal(decl->get_scope()) == NULL)
65788 : {
65789 : // ROSE_ASSERT(decl->get_scope()->get_scope() != NULL);
65790 : }
65791 :
65792 8091 : return decl->get_mangled_name ();
65793 : }
65794 :
65795 :
65796 : #if 0
65797 : // Older code
65798 : SgName
65799 : SgEnumType::get_mangled(SgUnparse_Info&)
65800 : {
65801 : // DQ (6/23/2005): Use the qualified name here
65802 : // return get_name();
65803 : return get_qualified_name();
65804 : }
65805 : #endif
65806 :
65807 :
65808 :
65809 : // End of memberFunctionString
65810 : // Start of memberFunctionString
65811 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
65812 :
65813 : // *** COMMON CODE SECTION BEGINS HERE ***
65814 :
65815 : #if 0
65816 : int
65817 : SgEnumType::getVariant() const
65818 : {
65819 : // This function is used in ROSE while "variant()" is used in SAGE
65820 : assert(this != NULL);
65821 : return variant();
65822 : }
65823 : #endif
65824 :
65825 : // This function is used in ROSE in treeTraversal code
65826 : // eventually replaces getVariant() and variant()
65827 : // though after variant() has been removed for a while we will
65828 : // want to change the name of variantT() back to variant()
65829 : // (since the "T" was ment to stand for temporary).
65830 : // When this happens the variantT() will be depricated.
65831 : VariantT
65832 5023910 : SgEnumType::variantT() const
65833 : {
65834 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
65835 5023910 : ROSE_ASSERT(this != NULL);
65836 5023910 : return V_SgEnumType;
65837 : }
65838 :
65839 : #if 0
65840 : int
65841 : SgEnumType::variant() const
65842 : {
65843 : // This function is used in SAGE
65844 : ROSE_ASSERT(this != NULL);
65845 : return T_ENUM;
65846 : }
65847 : #endif
65848 :
65849 : ROSE_DLL_API const char*
65850 0 : SgEnumType::sage_class_name() const
65851 : {
65852 0 : ROSE_ASSERT(this != NULL);
65853 0 : return "SgEnumType";
65854 : }
65855 :
65856 : std::string
65857 1258 : SgEnumType::class_name() const
65858 : {
65859 1258 : ROSE_ASSERT(this != NULL);
65860 1258 : return "SgEnumType";
65861 : }
65862 :
65863 : // DQ (11/26/2005): Support for visitor pattern mechanims
65864 : // (inferior to ROSE traversal mechanism, experimental).
65865 : void
65866 12005 : SgEnumType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
65867 : {
65868 12005 : ROSE_ASSERT(this != NULL);
65869 12005 : visitor.visit(this);
65870 12005 : }
65871 :
65872 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
65873 0 : void SgEnumType::accept (ROSE_VisitorPattern & visitor) {
65874 0 : ROSE_ASSERT(this != NULL);
65875 0 : visitor.visit(this);
65876 0 : }
65877 :
65878 : SgEnumType*
65879 0 : SgEnumType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
65880 : {
65881 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
65882 : // This function is currently only supported for the AST used the represent Binary executables.
65883 : if (0 /* isSgAsmNode(this) != NULL */)
65884 : {
65885 : // Support for regex specification.
65886 : std::string prefixCode = "REGEX:";
65887 : addNewAttribute(prefixCode + s,a);
65888 : }
65889 : #endif
65890 :
65891 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
65892 0 : return this;
65893 : }
65894 :
65895 : // *** COMMON CODE SECTION ENDS HERE ***
65896 :
65897 :
65898 : // End of memberFunctionString
65899 : // Start of memberFunctionString
65900 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
65901 :
65902 :
65903 : #if 0
65904 : //! Error checking support
65905 : /*! Verifies the following:
65906 : - working getVariant() member function
65907 : - calls base class's error() member function
65908 : Every class has one of these functions.
65909 : */
65910 : bool
65911 : SgEnumType::error()
65912 : {
65913 : // Put error checking here
65914 :
65915 : ROSE_ASSERT (this != NULL);
65916 : if (getVariant() != T_ENUM)
65917 : {
65918 : printf ("Error in SgEnumType::error(): SgEnumType object has a %s variant \n",
65919 : Cxx_GrammarTerminalNames[getVariant()].name);
65920 : // printf ("Error in SgEnumType::error() \n");
65921 : ROSE_ABORT();
65922 : }
65923 :
65924 : ROSE_ASSERT (getVariant() == T_ENUM);
65925 : return SgNamedType::error();
65926 : }
65927 : #endif
65928 :
65929 :
65930 :
65931 : // End of memberFunctionString
65932 :
65933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
65934 :
65935 1592910 : SgEnumType* isSgEnumType ( SgNode* inputDerivedClassPointer )
65936 : {
65937 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
65938 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
65939 : // So to fix this we return NULL directly when the input is NULL and avoid the
65940 : // dynamic_cast in this case. This is likely a performance improvement as well.
65941 : // return dynamic_cast<SgEnumType*>(inputDerivedClassPointer);
65942 : // Milind Chabbi (8/28/2013): isSgEnumType uses table-driven castability instead of c++ default dynamic_cast
65943 : // this improves the running time performance by 10-20%.
65944 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEnumType*>(inputDerivedClassPointer);
65945 1592910 : return IS_SgEnumType_FAST_MACRO(inputDerivedClassPointer);
65946 : }
65947 :
65948 : // DQ (11/8/2003): Added version of functions taking const pointer
65949 0 : const SgEnumType* isSgEnumType ( const SgNode* inputDerivedClassPointer )
65950 : {
65951 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
65952 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
65953 : // So to fix this we return NULL directly when the input is NULL and avoid the
65954 : // dynamic_cast in this case. This is likely a performance improvement as well.
65955 : // return dynamic_cast<const SgEnumType*>(inputDerivedClassPointer);
65956 : // Milind Chabbi (8/28/2013): isSgEnumType uses table-driven castability instead of c++ default dynamic_cast
65957 : // this improves the running time performance by 10-20%.
65958 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEnumType*>(inputDerivedClassPointer);
65959 0 : return IS_SgEnumType_FAST_MACRO(inputDerivedClassPointer);
65960 : }
65961 :
65962 :
65963 :
65964 : /* #line 65965 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
65965 :
65966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
65967 :
65968 : /**
65969 : \brief Generated destructor
65970 :
65971 : This destructor is automatically generated (by ROSETTA). This destructor
65972 : only frees memory of data members associated with the parts of the current IR node which
65973 : are NOT traversed. Those data members that are part of a traversal can be freed using
65974 : a traversal (calling this destructor on all children in a post-order traversal). Such
65975 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
65976 :
65977 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
65978 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
65979 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
65980 :
65981 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
65982 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
65983 : pointers are not yet implemented to call delete on eash pointer in the container.
65984 : (This could be done by derivation from the STL containers to define containers that
65985 : automatically deleted their members.)
65986 :
65987 : */
65988 3248 : SgEnumType::~SgEnumType () {
65989 1624 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
65990 :
65991 :
65992 :
65993 : }
65994 :
65995 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
65996 3248 : }
65997 :
65998 :
65999 : /* #line 66000 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66000 :
66001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
66002 :
66003 : // Generated constructor
66004 2932 : SgEnumType::SgEnumType ( SgDeclarationStatement* declaration )
66005 2932 : : SgNamedType(declaration)
66006 : {
66007 : #ifdef DEBUG
66008 : // printf ("In SgEnumType::SgEnumType (SgDeclarationStatement* declaration) sage_class_name() = %s \n",sage_class_name());
66009 : #endif
66010 : #if 0
66011 : // debugging information!
66012 : printf ("In SgEnumType::SgEnumType (SgDeclarationStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
66013 : #endif
66014 :
66015 :
66016 :
66017 : #if 0
66018 : // DQ (7/30/2014): Call a virtual function.
66019 : std::string s = this->class_name();
66020 : #endif
66021 :
66022 : // Test the variant virtual function
66023 : // assert(T_ENUM == variant());
66024 2932 : assert(T_ENUM == this->variant());
66025 2932 : ROSE_ASSERT(T_ENUM == (int)(this->variantT()));
66026 2932 : post_construction_initialization();
66027 :
66028 : // Test the isSgEnumType() function since it has been problematic
66029 2932 : assert(isSgEnumType(this) != NULL);
66030 2932 : }
66031 :
66032 : // Generated constructor (all data members)
66033 :
66034 : /* #line 66035 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66035 :
66036 :
66037 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
66038 :
66039 :
66040 : // ********************************************************
66041 : // member functions common across all array grammar objects
66042 : // ********************************************************
66043 :
66044 :
66045 :
66046 : /* #line 66047 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66047 :
66048 :
66049 :
66050 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
66051 :
66052 : // ********************************************************
66053 : // member functions specific to each node in the grammar
66054 : // ********************************************************
66055 :
66056 :
66057 : /* #line 66058 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66058 :
66059 : // Start of memberFunctionString
66060 : /* #line 6422 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
66061 :
66062 : // SgTypedefType* SgTypedefType::createType(SgTypedefDeclaration *decl)
66063 : SgTypedefType*
66064 56574 : SgTypedefType::createType(SgTypedefDeclaration *decl, SgExpression* optional_fortran_type_kind)
66065 : {
66066 : // printf ("Inside of SgTypedefType::createType() \n");
66067 56574 : assert(decl != NULL);
66068 :
66069 : // DQ (10/4/2010): I don't think this type can have a fortran type kind parameter.
66070 56574 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
66071 :
66072 : #if 0
66073 : printf ("In SgTypedefType::createType() (CREATE_TYPE_FOR_TYPEDEF_TYPE) \n");
66074 : #endif
66075 :
66076 : // if (!decl->get_type())
66077 56574 : if (decl->get_type() == NULL)
66078 : {
66079 56574 : assert(decl->get_base_type() != NULL);
66080 :
66081 56574 : ROSE_ASSERT (decl->get_base_type() != NULL);
66082 56574 : ROSE_ASSERT (decl->get_base_type()->p_typedefs != NULL);
66083 : // printf ("Before loop over typedef chain: (decl->get_base_type()->p_typedefs)->get_typedefs().size() = %d \n",
66084 : // (decl->get_base_type()->p_typedefs)->get_typedefs().size());
66085 :
66086 56574 : SgTypePtrList::iterator i = ((decl->get_base_type()->p_typedefs)->get_typedefs().begin());
66087 423241 : while (i != ((decl->get_base_type()->p_typedefs)->get_typedefs().end()))
66088 : {
66089 : // printf ("In loop over typedef chain \n");
66090 :
66091 : // SgName dname = decl->get_name();
66092 : // SgTypedefType *tptr= isSgTypedefType((*i).irep());
66093 370756 : ROSE_ASSERT( (*i) != NULL);
66094 370756 : SgTypedefType *tptr = isSgTypedefType(*i);
66095 370756 : ROSE_ASSERT(tptr != NULL);
66096 :
66097 : // DQ (3/21/2012): No, test2004_48.C fails this test.
66098 : // DQ (3/3/2012): I think this is always NULL pointer to a SgSymbol.
66099 : // ROSE_ASSERT(decl->get_parent_scope() == NULL);
66100 :
66101 : // DQ (3/21/2012): No, test2003_08.C fails this test.
66102 : // DQ (3/3/2012): I think this is always NULL pointer to a SgSymbol.
66103 : // ROSE_ASSERT(tptr->get_parent_scope() == NULL);
66104 :
66105 : #if 0
66106 : // DQ (2/27/2018): I think this is the wrong code because the value returned by get_name() contains
66107 : // the name of the template instantiation with template arguments, and the value of the function
66108 : // get_templateName() has the value of the associated template name (without template arguments).
66109 :
66110 : SgName name = decl->get_name();
66111 : // SgTemplateTypedefDeclaration* templateTypedefDeclaration = isSgTemplateTypedefDeclaration(decl);
66112 : SgTemplateInstantiationTypedefDeclaration* templateInstantiationTypedefDeclaration = isSgTemplateInstantiationTypedefDeclaration(decl);
66113 : if (templateInstantiationTypedefDeclaration != NULL)
66114 : {
66115 : name = templateInstantiationTypedefDeclaration->get_templateName();
66116 : printf ("In SgTypedefType::createType(): case of SgTemplateInstantiationTypedefDeclaration: name = %s \n",name.str());
66117 : ROSE_ASSERT(name != "");
66118 : }
66119 : else
66120 : {
66121 : // DQ (2/25/2018): If this is a SgTemplateTypedefDeclaration then it might be that we can't just use the name (but I'm not ceertain).
66122 : SgTemplateTypedefDeclaration* templateTypedefDeclaration = isSgTemplateTypedefDeclaration(decl);
66123 : if (templateTypedefDeclaration != NULL)
66124 : {
66125 : printf ("In SgTypedefType::createType(): case of SgTemplateTypedefDeclaration: Need to handle this special case (I think)! \n");
66126 : }
66127 : }
66128 :
66129 : SgName i_name = decl->get_name();
66130 : // SgTemplateTypedefDeclaration* i_templateTypedefDeclaration = isSgTemplateTypedefDeclaration(decl);
66131 : SgTemplateInstantiationTypedefDeclaration* i_templateInstantiationTypedefDeclaration = isSgTemplateInstantiationTypedefDeclaration(tptr->get_declaration());
66132 : if (i_templateInstantiationTypedefDeclaration != NULL)
66133 : {
66134 : i_name = i_templateInstantiationTypedefDeclaration->get_templateName();
66135 : printf ("In SgTypedefType::createType(): case of SgTemplateInstantiationTypedefDeclaration: i_name = %s \n",i_name.str());
66136 : ROSE_ASSERT(i_name != "");
66137 : }
66138 : else
66139 : {
66140 : // DQ (2/25/2018): If this is a SgTemplateTypedefDeclaration then it might be that we can't just use the name (but I'm not ceertain).
66141 : SgTemplateTypedefDeclaration* templateTypedefDeclaration = isSgTemplateTypedefDeclaration(tptr->get_declaration());
66142 : if (templateTypedefDeclaration != NULL)
66143 : {
66144 : printf ("In SgTypedefType::createType(): case of SgTemplateTypedefDeclaration: Need to handle this special case (I think)! \n");
66145 : }
66146 : }
66147 : #if 1
66148 : printf ("In SgTypedefType::createType(): decl = %p decl->get_firstNondefiningDeclaration() = %p \n",decl,decl->get_firstNondefiningDeclaration());
66149 : printf ("In SgTypedefType::createType(): decl = %p decl->get_definingDeclaration() = %p \n",decl,decl->get_definingDeclaration());
66150 : printf ("In SgTypedefType::createType(): case of %s: name = %s \n",decl->class_name().c_str(),name.str());
66151 : printf ("In SgTypedefType::createType(): case of %s: i_name = %s \n",tptr->get_declaration()->class_name().c_str(),i_name.str());
66152 : #endif
66153 : // if ( (decl->get_name() == tptr->get_name()) && (decl->get_parent_scope() == tptr->get_parent_scope()) )
66154 : if ( (name == i_name) && (decl->get_parent_scope() == tptr->get_parent_scope()) )
66155 : {
66156 : return (tptr);
66157 : }
66158 : #else
66159 : // DQ (2/27/2018): This is the original code, and I think it maybe the best version.
66160 395625 : if ( (decl->get_name() == tptr->get_name()) && (decl->get_parent_scope() == tptr->get_parent_scope()) )
66161 : {
66162 4089 : return tptr;
66163 : }
66164 : #endif
66165 366667 : i++;
66166 : }
66167 :
66168 : // decl->set_type(new SgTypedefType(decl, decl->get_parent_scope()));
66169 :
66170 : // debugging code
66171 : // decl->get_file_info()->display("declration used in SgTypedefType::createType()");
66172 :
66173 : // Parent scope is NULL for declarations in global scope
66174 : // ROSE_ASSERT (decl->get_parent_scope() != NULL);
66175 : #if 0
66176 : SgTypedefType* tempType = new SgTypedefType(decl, decl->get_parent_scope());
66177 : #else
66178 : // DQ (7/22/2010): Use the global type table to get the type.
66179 :
66180 : // We have to build the type before we can generate a mangle name for it.
66181 52485 : SgTypedefType* tempType = new SgTypedefType(decl, decl->get_parent_scope());
66182 52485 : SgName name = tempType->get_mangled();
66183 52485 : ROSE_ASSERT(name.is_null() == false);
66184 :
66185 52485 : SgScopeStatement* currentScope = getCurrentScope();
66186 :
66187 : // ROSE_ASSERT(currentScope != NULL);
66188 52485 : if (currentScope != NULL)
66189 : {
66190 : // DQ (7/30/2010): If valid pointer then we are in the process of building the C/C++/Fortran AST.
66191 52483 : SgType* t = currentScope->get_type_table()->lookup_type(name);
66192 :
66193 52483 : if (t == NULL)
66194 : {
66195 : // If the type is not in the type table then insert it so that we can reuse it.
66196 : #if 0
66197 : printf ("Mangled type name for SgTypedefType = %s (not available in type table) \n",name.str());
66198 : #endif
66199 : // get_globalTypeTable()->insert_type(name,tempType);
66200 52483 : currentScope->get_type_table()->insert_type(name,tempType);
66201 : }
66202 : else
66203 : {
66204 : // If it is already present in the type table then delete the type (so that it will remain unique).
66205 : #if 0
66206 : printf ("Mangled type name for SgTypedefType = %s (already exists in type table) \n",name.str());
66207 : #endif
66208 0 : ROSE_ASSERT(t != tempType);
66209 :
66210 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
66211 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
66212 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
66213 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
66214 0 : delete tempType;
66215 : #endif
66216 0 : tempType = NULL;
66217 :
66218 : // Reuse this tempType variable so we can use the same code below.
66219 0 : tempType = isSgTypedefType(t);
66220 : }
66221 : }
66222 : #endif
66223 52485 : ROSE_ASSERT (tempType != NULL);
66224 52485 : decl->set_type(tempType);
66225 :
66226 52485 : ROSE_ASSERT (decl->get_type() != NULL);
66227 52485 : ROSE_ASSERT (decl->get_base_type() != NULL);
66228 52485 : ROSE_ASSERT (decl->get_base_type()->p_typedefs != NULL);
66229 :
66230 : // printf ("Before updating list: (decl->get_base_type()->p_typedefs)->get_typedefs().size() = %d \n",
66231 : // (decl->get_base_type()->p_typedefs)->get_typedefs().size());
66232 :
66233 52485 : (decl->get_base_type()->p_typedefs)->get_typedefs().push_back(decl->get_type());
66234 : }
66235 :
66236 : // printf ("Leaving SgTypedefType::createType() \n");
66237 :
66238 52485 : ROSE_ASSERT(decl != NULL);
66239 52485 : ROSE_ASSERT(decl->get_type() != NULL); // I think we can assert this!
66240 :
66241 52485 : ROSE_ASSERT ((decl->get_base_type()->p_typedefs)->get_typedefs().size() > 0);
66242 :
66243 52485 : return decl->get_type();
66244 : }
66245 :
66246 :
66247 :
66248 : // End of memberFunctionString
66249 : // Start of memberFunctionString
66250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
66251 :
66252 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
66253 :
66254 : SgSymbol*
66255 28958 : SgTypedefType::get_parent_scope () const
66256 : {
66257 28958 : ROSE_ASSERT (this != NULL);
66258 :
66259 : #if 0
66260 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
66261 : // used to trigger marking transformations for the token-based unparsing.
66262 : printf ("SgTypedefType::get_parent_scope = %p = %s \n",this,this->class_name().c_str());
66263 : #endif
66264 :
66265 28958 : return p_parent_scope;
66266 : }
66267 :
66268 : void
66269 0 : SgTypedefType::set_parent_scope ( SgSymbol* parent_scope )
66270 : {
66271 0 : ROSE_ASSERT (this != NULL);
66272 :
66273 : #if 0
66274 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
66275 : // used to trigger marking transformations for the token-based unparsing.
66276 : printf ("SgTypedefType::set_parent_scope = %p = %s \n",this,this->class_name().c_str());
66277 : #endif
66278 :
66279 0 : set_isModified(true);
66280 :
66281 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
66282 : if (p_parent_scope != NULL && parent_scope != NULL && p_parent_scope != parent_scope)
66283 : {
66284 : printf ("Warning: parent_scope = %p overwriting valid pointer p_parent_scope = %p \n",parent_scope,p_parent_scope);
66285 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
66286 : printf ("Error fails assertion (p_parent_scope != NULL && parent_scope != NULL && p_parent_scope != parent_scope) is false\n");
66287 : ROSE_ASSERT(false);
66288 : #endif
66289 : }
66290 : #endif
66291 0 : p_parent_scope = parent_scope;
66292 0 : }
66293 :
66294 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
66295 :
66296 :
66297 : // End of memberFunctionString
66298 : // Start of memberFunctionString
66299 : /* #line 4099 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
66300 :
66301 :
66302 0 : SgTypedefType::SgTypedefType ( const SgTypedefType & X )
66303 : // : SgNamedType(X.get_declaration())
66304 0 : : SgNamedType(X), p_parent_scope(X.p_parent_scope)
66305 : {
66306 : // DQ (10/18/2007): This copy constructor is to support the AST copy mechansim, specifically
66307 : // to permit the SgTypedefSeq to be updated with new copies of SgTypedefType objects.
66308 :
66309 : // DQ (10/19/2007): Make sure that this is true (though we could not test it before building the base class.
66310 0 : ROSE_ASSERT( X.get_declaration() != NULL);
66311 :
66312 : // Typedefs need to setup the fixup the SgTypedefSeq list.
66313 0 : SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(X.get_declaration());
66314 0 : ROSE_ASSERT( typedefDeclaration != NULL);
66315 0 : SgType* baseType = typedefDeclaration->get_base_type();
66316 0 : ROSE_ASSERT(baseType != NULL);
66317 :
66318 : // Fixup the SgTypedefSeq object.
66319 0 : baseType->get_typedefs()->append_typedef(this);
66320 0 : }
66321 :
66322 : SgName
66323 1835690 : SgTypedefType::get_name() const
66324 : {
66325 1835690 : if (get_declaration() != NULL)
66326 : {
66327 1835690 : return isSgTypedefDeclaration(get_declaration())->get_name();
66328 : }
66329 : else
66330 : {
66331 0 : printf ("Warning: Returning an empty name from SgTypedefType::get_name() \n");
66332 0 : return SgName((char *)0L);
66333 : }
66334 : }
66335 :
66336 : SgType*
66337 53711900 : SgTypedefType::get_base_type() const
66338 : {
66339 : // DQ (6/30/2005): Added assertion (I think this makes sense!)
66340 53711900 : ROSE_ASSERT(isSgTypedefDeclaration(get_declaration()) != NULL);
66341 53711900 : return (get_declaration() != NULL) ? isSgTypedefDeclaration(get_declaration())->get_base_type() : NULL;
66342 : }
66343 :
66344 : // RV (2/1/2006): Updated to use the declaration's mangling routine.
66345 : SgName
66346 17401700 : SgTypedefType::get_mangled (void) const
66347 : {
66348 17401700 : ROSE_ASSERT(this != NULL);
66349 :
66350 17401700 : const SgTypedefDeclaration* decl = isSgTypedefDeclaration (get_declaration());
66351 17401700 : ROSE_ASSERT (decl != NULL);
66352 :
66353 : #if 0
66354 : // DQ (5/23/2018): Added debugging support for infinite loop bug.
66355 : printf ("In SgTypedefType::get_mangled(): decl = %p = %s = %s \n",decl,decl->class_name().c_str(),decl->get_name().str());
66356 : #endif
66357 : #if 0
66358 : if (decl->get_file_info() != NULL)
66359 : {
66360 : printf (" --- typedef source position: decl = %p line = %d \n",decl,decl->get_file_info()->get_line());
66361 : }
66362 : else
66363 : {
66364 : printf (" --- typedef source position: line = (unknown) \n");
66365 : }
66366 : #endif
66367 :
66368 17401700 : return decl->get_mangled_name();
66369 : }
66370 :
66371 :
66372 :
66373 : // End of memberFunctionString
66374 : // Start of memberFunctionString
66375 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
66376 :
66377 : // *** COMMON CODE SECTION BEGINS HERE ***
66378 :
66379 : #if 0
66380 : int
66381 : SgTypedefType::getVariant() const
66382 : {
66383 : // This function is used in ROSE while "variant()" is used in SAGE
66384 : assert(this != NULL);
66385 : return variant();
66386 : }
66387 : #endif
66388 :
66389 : // This function is used in ROSE in treeTraversal code
66390 : // eventually replaces getVariant() and variant()
66391 : // though after variant() has been removed for a while we will
66392 : // want to change the name of variantT() back to variant()
66393 : // (since the "T" was ment to stand for temporary).
66394 : // When this happens the variantT() will be depricated.
66395 : VariantT
66396 7750840000 : SgTypedefType::variantT() const
66397 : {
66398 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
66399 7750840000 : ROSE_ASSERT(this != NULL);
66400 7750840000 : return V_SgTypedefType;
66401 : }
66402 :
66403 : #if 0
66404 : int
66405 : SgTypedefType::variant() const
66406 : {
66407 : // This function is used in SAGE
66408 : ROSE_ASSERT(this != NULL);
66409 : return T_TYPEDEF;
66410 : }
66411 : #endif
66412 :
66413 : ROSE_DLL_API const char*
66414 0 : SgTypedefType::sage_class_name() const
66415 : {
66416 0 : ROSE_ASSERT(this != NULL);
66417 0 : return "SgTypedefType";
66418 : }
66419 :
66420 : std::string
66421 46989 : SgTypedefType::class_name() const
66422 : {
66423 46989 : ROSE_ASSERT(this != NULL);
66424 46989 : return "SgTypedefType";
66425 : }
66426 :
66427 : // DQ (11/26/2005): Support for visitor pattern mechanims
66428 : // (inferior to ROSE traversal mechanism, experimental).
66429 : void
66430 242426 : SgTypedefType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
66431 : {
66432 242426 : ROSE_ASSERT(this != NULL);
66433 242426 : visitor.visit(this);
66434 242426 : }
66435 :
66436 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
66437 0 : void SgTypedefType::accept (ROSE_VisitorPattern & visitor) {
66438 0 : ROSE_ASSERT(this != NULL);
66439 0 : visitor.visit(this);
66440 0 : }
66441 :
66442 : SgTypedefType*
66443 0 : SgTypedefType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
66444 : {
66445 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
66446 : // This function is currently only supported for the AST used the represent Binary executables.
66447 : if (0 /* isSgAsmNode(this) != NULL */)
66448 : {
66449 : // Support for regex specification.
66450 : std::string prefixCode = "REGEX:";
66451 : addNewAttribute(prefixCode + s,a);
66452 : }
66453 : #endif
66454 :
66455 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
66456 0 : return this;
66457 : }
66458 :
66459 : // *** COMMON CODE SECTION ENDS HERE ***
66460 :
66461 :
66462 : // End of memberFunctionString
66463 : // Start of memberFunctionString
66464 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
66465 :
66466 :
66467 : #if 0
66468 : //! Error checking support
66469 : /*! Verifies the following:
66470 : - working getVariant() member function
66471 : - calls base class's error() member function
66472 : Every class has one of these functions.
66473 : */
66474 : bool
66475 : SgTypedefType::error()
66476 : {
66477 : // Put error checking here
66478 :
66479 : ROSE_ASSERT (this != NULL);
66480 : if (getVariant() != T_TYPEDEF)
66481 : {
66482 : printf ("Error in SgTypedefType::error(): SgTypedefType object has a %s variant \n",
66483 : Cxx_GrammarTerminalNames[getVariant()].name);
66484 : // printf ("Error in SgTypedefType::error() \n");
66485 : ROSE_ABORT();
66486 : }
66487 :
66488 : ROSE_ASSERT (getVariant() == T_TYPEDEF);
66489 : return SgNamedType::error();
66490 : }
66491 : #endif
66492 :
66493 :
66494 :
66495 : // End of memberFunctionString
66496 :
66497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
66498 :
66499 225304000 : SgTypedefType* isSgTypedefType ( SgNode* inputDerivedClassPointer )
66500 : {
66501 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
66502 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
66503 : // So to fix this we return NULL directly when the input is NULL and avoid the
66504 : // dynamic_cast in this case. This is likely a performance improvement as well.
66505 : // return dynamic_cast<SgTypedefType*>(inputDerivedClassPointer);
66506 : // Milind Chabbi (8/28/2013): isSgTypedefType uses table-driven castability instead of c++ default dynamic_cast
66507 : // this improves the running time performance by 10-20%.
66508 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypedefType*>(inputDerivedClassPointer);
66509 225304000 : return IS_SgTypedefType_FAST_MACRO(inputDerivedClassPointer);
66510 : }
66511 :
66512 : // DQ (11/8/2003): Added version of functions taking const pointer
66513 0 : const SgTypedefType* isSgTypedefType ( const SgNode* inputDerivedClassPointer )
66514 : {
66515 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
66516 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
66517 : // So to fix this we return NULL directly when the input is NULL and avoid the
66518 : // dynamic_cast in this case. This is likely a performance improvement as well.
66519 : // return dynamic_cast<const SgTypedefType*>(inputDerivedClassPointer);
66520 : // Milind Chabbi (8/28/2013): isSgTypedefType uses table-driven castability instead of c++ default dynamic_cast
66521 : // this improves the running time performance by 10-20%.
66522 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypedefType*>(inputDerivedClassPointer);
66523 0 : return IS_SgTypedefType_FAST_MACRO(inputDerivedClassPointer);
66524 : }
66525 :
66526 :
66527 :
66528 : /* #line 66529 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66529 :
66530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
66531 :
66532 : /**
66533 : \brief Generated destructor
66534 :
66535 : This destructor is automatically generated (by ROSETTA). This destructor
66536 : only frees memory of data members associated with the parts of the current IR node which
66537 : are NOT traversed. Those data members that are part of a traversal can be freed using
66538 : a traversal (calling this destructor on all children in a post-order traversal). Such
66539 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
66540 :
66541 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
66542 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
66543 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
66544 :
66545 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
66546 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
66547 : pointers are not yet implemented to call delete on eash pointer in the container.
66548 : (This could be done by derivation from the STL containers to define containers that
66549 : automatically deleted their members.)
66550 :
66551 : */
66552 7392 : SgTypedefType::~SgTypedefType () {
66553 3696 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
66554 :
66555 :
66556 : // case: not a listType for parent_scope
66557 3696 : p_parent_scope = NULL; // non list case
66558 :
66559 : }
66560 :
66561 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
66562 7392 : }
66563 :
66564 :
66565 : /* #line 66566 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66566 :
66567 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
66568 :
66569 : // Generated constructor
66570 52485 : SgTypedefType::SgTypedefType ( SgDeclarationStatement* declaration, SgSymbol* parent_scope )
66571 52485 : : SgNamedType(declaration)
66572 : {
66573 : #ifdef DEBUG
66574 : // printf ("In SgTypedefType::SgTypedefType (SgDeclarationStatement* declaration, SgSymbol* parent_scope) sage_class_name() = %s \n",sage_class_name());
66575 : #endif
66576 : #if 0
66577 : // debugging information!
66578 : printf ("In SgTypedefType::SgTypedefType (SgDeclarationStatement* declaration, SgSymbol* parent_scope): this = %p = %s \n",this,this->class_name().c_str());
66579 : #endif
66580 :
66581 52485 : p_parent_scope = parent_scope;
66582 :
66583 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
66584 :
66585 : #if 0
66586 : // DQ (7/30/2014): Call a virtual function.
66587 : std::string s = this->class_name();
66588 : #endif
66589 :
66590 : // Test the variant virtual function
66591 : // assert(T_TYPEDEF == variant());
66592 52485 : assert(T_TYPEDEF == this->variant());
66593 52485 : ROSE_ASSERT(T_TYPEDEF == (int)(this->variantT()));
66594 52485 : post_construction_initialization();
66595 :
66596 : // Test the isSgTypedefType() function since it has been problematic
66597 52485 : assert(isSgTypedefType(this) != NULL);
66598 52485 : }
66599 :
66600 : // Generated constructor (all data members)
66601 :
66602 : /* #line 66603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66603 :
66604 :
66605 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
66606 :
66607 :
66608 : // ********************************************************
66609 : // member functions common across all array grammar objects
66610 : // ********************************************************
66611 :
66612 :
66613 :
66614 : /* #line 66615 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66615 :
66616 :
66617 :
66618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
66619 :
66620 : // ********************************************************
66621 : // member functions specific to each node in the grammar
66622 : // ********************************************************
66623 :
66624 :
66625 : /* #line 66626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66626 :
66627 : // Start of memberFunctionString
66628 : /* #line 7368 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
66629 :
66630 :
66631 : SgNonrealType*
66632 0 : SgNonrealType::createType(SgNonrealDecl* decl, SgExpression* optional_fortran_type_kind)
66633 : {
66634 0 : ROSE_ASSERT(decl != NULL);
66635 :
66636 0 : printf ("SgNonrealType::createType(SgTemplateDeclaration*,SgExpression*) implemented to return NULL \n");
66637 0 : ROSE_ASSERT(false);
66638 :
66639 : return NULL;
66640 : }
66641 :
66642 :
66643 :
66644 : // End of memberFunctionString
66645 : // Start of memberFunctionString
66646 : /* #line 3956 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
66647 :
66648 :
66649 0 : SgNonrealType::SgNonrealType ( const SgNonrealType & X )
66650 0 : : SgNamedType(X)
66651 : {
66652 0 : }
66653 :
66654 : SgName
66655 359591 : SgNonrealType::get_mangled(void) const
66656 : {
66657 359591 : SgNonrealDecl * nrdecl = isSgNonrealDecl(get_declaration());
66658 359591 : ROSE_ASSERT(nrdecl != NULL);
66659 359591 : return nrdecl->get_mangled_name();
66660 : }
66661 :
66662 165204 : SgName SgNonrealType::get_name() const {
66663 165204 : SgDeclarationStatement * decl_stmt = get_declaration();
66664 165204 : ROSE_ASSERT(decl_stmt != NULL);
66665 165204 : SgNonrealDecl * nonreal_decl = isSgNonrealDecl(decl_stmt);
66666 165204 : ROSE_ASSERT(nonreal_decl != NULL);
66667 165204 : return nonreal_decl->get_name();
66668 : }
66669 :
66670 :
66671 :
66672 : // End of memberFunctionString
66673 : // Start of memberFunctionString
66674 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
66675 :
66676 : // *** COMMON CODE SECTION BEGINS HERE ***
66677 :
66678 : #if 0
66679 : int
66680 : SgNonrealType::getVariant() const
66681 : {
66682 : // This function is used in ROSE while "variant()" is used in SAGE
66683 : assert(this != NULL);
66684 : return variant();
66685 : }
66686 : #endif
66687 :
66688 : // This function is used in ROSE in treeTraversal code
66689 : // eventually replaces getVariant() and variant()
66690 : // though after variant() has been removed for a while we will
66691 : // want to change the name of variantT() back to variant()
66692 : // (since the "T" was ment to stand for temporary).
66693 : // When this happens the variantT() will be depricated.
66694 : VariantT
66695 59538200 : SgNonrealType::variantT() const
66696 : {
66697 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
66698 59538200 : ROSE_ASSERT(this != NULL);
66699 59538200 : return V_SgNonrealType;
66700 : }
66701 :
66702 : #if 0
66703 : int
66704 : SgNonrealType::variant() const
66705 : {
66706 : // This function is used in SAGE
66707 : ROSE_ASSERT(this != NULL);
66708 : return T_NONREAL;
66709 : }
66710 : #endif
66711 :
66712 : ROSE_DLL_API const char*
66713 0 : SgNonrealType::sage_class_name() const
66714 : {
66715 0 : ROSE_ASSERT(this != NULL);
66716 0 : return "SgNonrealType";
66717 : }
66718 :
66719 : std::string
66720 34576 : SgNonrealType::class_name() const
66721 : {
66722 34576 : ROSE_ASSERT(this != NULL);
66723 34576 : return "SgNonrealType";
66724 : }
66725 :
66726 : // DQ (11/26/2005): Support for visitor pattern mechanims
66727 : // (inferior to ROSE traversal mechanism, experimental).
66728 : void
66729 704852 : SgNonrealType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
66730 : {
66731 704852 : ROSE_ASSERT(this != NULL);
66732 704852 : visitor.visit(this);
66733 704852 : }
66734 :
66735 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
66736 0 : void SgNonrealType::accept (ROSE_VisitorPattern & visitor) {
66737 0 : ROSE_ASSERT(this != NULL);
66738 0 : visitor.visit(this);
66739 0 : }
66740 :
66741 : SgNonrealType*
66742 0 : SgNonrealType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
66743 : {
66744 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
66745 : // This function is currently only supported for the AST used the represent Binary executables.
66746 : if (0 /* isSgAsmNode(this) != NULL */)
66747 : {
66748 : // Support for regex specification.
66749 : std::string prefixCode = "REGEX:";
66750 : addNewAttribute(prefixCode + s,a);
66751 : }
66752 : #endif
66753 :
66754 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
66755 0 : return this;
66756 : }
66757 :
66758 : // *** COMMON CODE SECTION ENDS HERE ***
66759 :
66760 :
66761 : // End of memberFunctionString
66762 : // Start of memberFunctionString
66763 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
66764 :
66765 :
66766 : #if 0
66767 : //! Error checking support
66768 : /*! Verifies the following:
66769 : - working getVariant() member function
66770 : - calls base class's error() member function
66771 : Every class has one of these functions.
66772 : */
66773 : bool
66774 : SgNonrealType::error()
66775 : {
66776 : // Put error checking here
66777 :
66778 : ROSE_ASSERT (this != NULL);
66779 : if (getVariant() != T_NONREAL)
66780 : {
66781 : printf ("Error in SgNonrealType::error(): SgNonrealType object has a %s variant \n",
66782 : Cxx_GrammarTerminalNames[getVariant()].name);
66783 : // printf ("Error in SgNonrealType::error() \n");
66784 : ROSE_ABORT();
66785 : }
66786 :
66787 : ROSE_ASSERT (getVariant() == T_NONREAL);
66788 : return SgNamedType::error();
66789 : }
66790 : #endif
66791 :
66792 :
66793 :
66794 : // End of memberFunctionString
66795 :
66796 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
66797 :
66798 661823 : SgNonrealType* isSgNonrealType ( SgNode* inputDerivedClassPointer )
66799 : {
66800 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
66801 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
66802 : // So to fix this we return NULL directly when the input is NULL and avoid the
66803 : // dynamic_cast in this case. This is likely a performance improvement as well.
66804 : // return dynamic_cast<SgNonrealType*>(inputDerivedClassPointer);
66805 : // Milind Chabbi (8/28/2013): isSgNonrealType uses table-driven castability instead of c++ default dynamic_cast
66806 : // this improves the running time performance by 10-20%.
66807 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNonrealType*>(inputDerivedClassPointer);
66808 661823 : return IS_SgNonrealType_FAST_MACRO(inputDerivedClassPointer);
66809 : }
66810 :
66811 : // DQ (11/8/2003): Added version of functions taking const pointer
66812 0 : const SgNonrealType* isSgNonrealType ( const SgNode* inputDerivedClassPointer )
66813 : {
66814 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
66815 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
66816 : // So to fix this we return NULL directly when the input is NULL and avoid the
66817 : // dynamic_cast in this case. This is likely a performance improvement as well.
66818 : // return dynamic_cast<const SgNonrealType*>(inputDerivedClassPointer);
66819 : // Milind Chabbi (8/28/2013): isSgNonrealType uses table-driven castability instead of c++ default dynamic_cast
66820 : // this improves the running time performance by 10-20%.
66821 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNonrealType*>(inputDerivedClassPointer);
66822 0 : return IS_SgNonrealType_FAST_MACRO(inputDerivedClassPointer);
66823 : }
66824 :
66825 :
66826 :
66827 : /* #line 66828 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66828 :
66829 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
66830 :
66831 : /**
66832 : \brief Generated destructor
66833 :
66834 : This destructor is automatically generated (by ROSETTA). This destructor
66835 : only frees memory of data members associated with the parts of the current IR node which
66836 : are NOT traversed. Those data members that are part of a traversal can be freed using
66837 : a traversal (calling this destructor on all children in a post-order traversal). Such
66838 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
66839 :
66840 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
66841 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
66842 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
66843 :
66844 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
66845 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
66846 : pointers are not yet implemented to call delete on eash pointer in the container.
66847 : (This could be done by derivation from the STL containers to define containers that
66848 : automatically deleted their members.)
66849 :
66850 : */
66851 20320 : SgNonrealType::~SgNonrealType () {
66852 10160 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
66853 :
66854 :
66855 :
66856 : }
66857 :
66858 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
66859 20320 : }
66860 :
66861 :
66862 : /* #line 66863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66863 :
66864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
66865 :
66866 : // Generated constructor
66867 49325 : SgNonrealType::SgNonrealType ( SgDeclarationStatement* declaration )
66868 49325 : : SgNamedType(declaration)
66869 : {
66870 : #ifdef DEBUG
66871 : // printf ("In SgNonrealType::SgNonrealType (SgDeclarationStatement* declaration) sage_class_name() = %s \n",sage_class_name());
66872 : #endif
66873 : #if 0
66874 : // debugging information!
66875 : printf ("In SgNonrealType::SgNonrealType (SgDeclarationStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
66876 : #endif
66877 :
66878 :
66879 :
66880 : #if 0
66881 : // DQ (7/30/2014): Call a virtual function.
66882 : std::string s = this->class_name();
66883 : #endif
66884 :
66885 : // Test the variant virtual function
66886 : // assert(T_NONREAL == variant());
66887 49325 : assert(T_NONREAL == this->variant());
66888 49325 : ROSE_ASSERT(T_NONREAL == (int)(this->variantT()));
66889 49325 : post_construction_initialization();
66890 :
66891 : // Test the isSgNonrealType() function since it has been problematic
66892 49325 : assert(isSgNonrealType(this) != NULL);
66893 49325 : }
66894 :
66895 : // Generated constructor (all data members)
66896 :
66897 : /* #line 66898 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66898 :
66899 :
66900 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
66901 :
66902 :
66903 : // ********************************************************
66904 : // member functions common across all array grammar objects
66905 : // ********************************************************
66906 :
66907 :
66908 :
66909 : /* #line 66910 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66910 :
66911 :
66912 :
66913 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
66914 :
66915 : // ********************************************************
66916 : // member functions specific to each node in the grammar
66917 : // ********************************************************
66918 :
66919 :
66920 : /* #line 66921 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
66921 :
66922 : // Start of memberFunctionString
66923 : /* #line 8291 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
66924 :
66925 :
66926 : // SgModifierType* SgModifierType::createType(SgType* base_type, unsigned int f)
66927 : SgModifierType*
66928 0 : SgModifierType::createType(SgType* base_type, unsigned int f, SgExpression* optional_fortran_type_kind )
66929 : {
66930 : // DQ (7/28/2010): Now we make it an error to call this function!
66931 0 : printf ("ERROR: This function should not be called (replaced by different API plus insertModifierTypeIntoTypeTable()) \n");
66932 0 : ROSE_ASSERT(false);
66933 :
66934 : // DQ (10/4/2010): I think that reference types can't have a kind parameter, so this should be NULL.
66935 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
66936 :
66937 : #if 0
66938 : // DQ (7/26/2010): Note that "unsigned int f" is not used!
66939 : ROSE_ASSERT(base_type != NULL);
66940 :
66941 : // DQ (4/13/2004): See if we can get rid of this function, but first lets find out where it is called!
66942 : // This is part of the work to reorganize now modifiers are used internally.
66943 : // return base_type->matchModifiers(f);
66944 : // printf ("Error, no longer supported! \n");
66945 : // ROSE_ASSERT (false);
66946 : // return NULL;
66947 :
66948 : #if 0
66949 : // DQ (7/26/2010): Alternative code which does NOT properly abstract the creation of the type using the new type table.
66950 : SgModifierType* newType = new SgModifierType(base_type);
66951 : ROSE_ASSERT(newType != NULL);
66952 : // base_type->matchModifiers(f);
66953 : #else
66954 : SgModifierType* newType = new SgModifierType(base_type);
66955 : ROSE_ASSERT(newType != NULL);
66956 : // base_type->matchModifiers(f);
66957 :
66958 : SgName name = newType->get_mangled();
66959 :
66960 : #if 0
66961 : printf ("Building a modifier type to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
66962 : #endif
66963 :
66964 : // Only look for modifiers to type in the global type table.
66965 : SgType* t = get_globalTypeTable()->lookup_type(name);
66966 :
66967 : if (t == NULL)
66968 : {
66969 : // The pointer type was not found in the type table, put it into the global type table.
66970 : #if 0
66971 : // This is too agressive and fails for some test codes!
66972 : printf ("Mangled type name for SgModifierType = %s (does NOT exist in type table) \n",name.str());
66973 : get_globalTypeTable()->insert_type(name,newType);
66974 : #else
66975 : SgType* root_type = base_type->stripType();
66976 : ROSE_ASSERT(root_type != NULL);
66977 : if (handledUsingLocalTable(root_type) == false)
66978 : {
66979 : #if 0
66980 : printf ("Mangled type name for SgModifierType = %s (does NOT exist in type table) inserting it... \n",name.str());
66981 : #endif
66982 : get_globalTypeTable()->insert_type(name,newType);
66983 : }
66984 : else
66985 : {
66986 : // For now we can skip this case and then later use the local type table from the scope of the declaration.
66987 : #if 0
66988 : printf ("Skip putting the SgModifierType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
66989 : #endif
66990 : }
66991 : #endif
66992 : }
66993 : else
66994 : {
66995 : // This should be only a pointer to a SgModifierType (e.g. a pointer to a const base_type) NOT TRUE.
66996 : // ROSE_ASSERT(isSgModifierType(base_type) != NULL || isSgFunctionType(base_type) != NULL);
66997 :
66998 : // The pointer type was found in either the local or global table (but the base_type->p_ptr_to should have been valid).
66999 : // printf ("WARNING: the pointer to a base type = %p = %s should exist, we need to find it! \n",base_type,base_type->class_name().c_str());
67000 : // ROSE_ASSERT(false);
67001 :
67002 : // If it is already present in the type table then delete the type (so that it will remain unique).
67003 : #if 0
67004 : printf ("Mangled type name for SgModifierType = %s t = %p = %s (already exists in type table) \n",name.str(),t,t->class_name().c_str());
67005 : #endif
67006 : ROSE_ASSERT(t != newType);
67007 :
67008 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
67009 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
67010 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
67011 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
67012 : delete newType;
67013 : #endif
67014 : newType = NULL;
67015 :
67016 : newType = isSgModifierType(t);
67017 : ROSE_ASSERT(newType != NULL);
67018 : }
67019 : #endif
67020 :
67021 : ROSE_ASSERT(newType != NULL);
67022 : return newType;
67023 : #else
67024 : return NULL;
67025 : #endif
67026 : }
67027 :
67028 : SgModifierType*
67029 21967 : SgModifierType::insertModifierTypeIntoTypeTable( SgModifierType* result )
67030 : {
67031 : // DQ (7/28/2010): Insert result type into type table and return it, or
67032 : // replace the result type, if already available in the type table, with
67033 : // the type from type table.
67034 :
67035 : // An assumption (that I don't know how to check currently) is that this is a newly built
67036 : // type not previously used and not yet returned from any of the following functions
67037 : // calling this function. Thus is has not been added yet to any (global or local) type table.
67038 21967 : ROSE_ASSERT(result != NULL);
67039 :
67040 : #if 0
67041 : // DQ (7/26/2010): Alternative code which does NOT properly abstract the creation of the type using the new type table.
67042 : return result;
67043 : #else
67044 : // This is the type after some specification (setting) via type modifier flags. We could verify
67045 : // this by testing that at least one type modifier flag was set, not done yet.
67046 21967 : SgName name = result->get_mangled();
67047 :
67048 : #if 0
67049 : printf ("insertModifierTypeIntoTypeTable(): result is modifier type to base_type = %p = %s name = %s \n",result->get_base_type(),result->get_base_type()->class_name().c_str(),name.str());
67050 : #endif
67051 :
67052 : // Only look for modifiers to type in the global type table.
67053 21967 : SgType* t = get_globalTypeTable()->lookup_type(name);
67054 :
67055 21967 : if (t == NULL)
67056 : {
67057 : // The pointer type was not found in the type table, put it into the global type table.
67058 : #if 0
67059 : // This is too agressive and fails for some test codes!
67060 : printf ("insertModifierTypeIntoTypeTable(): Mangled type name for SgModifierType = %s (does NOT exist in type table) \n",name.str());
67061 : get_globalTypeTable()->insert_type(name,newType);
67062 : #else
67063 : // DQ (4/15/2019): Adding pointer to member support: not using SgType::STRIP_POINTER_MEMBER_TYPE
67064 : // printf ("In SgModifierType::insertModifierTypeIntoTypeTable(): Adding pointer to member support: not using SgType::STRIP_POINTER_MEMBER_TYPE \n");
67065 :
67066 : // DQ (7/30/2018): This function can't just strip down to the bae type (past typedefs, since we need
67067 : // to resolve different typedefs in different classes to be different, we need to stop at typedefs.
67068 : // This issue is important ot Cxx11_tests/test2018_134.C where a typedef is not to be shared since it
67069 : // exists in two different classes. Basically typedefs have a declaration which make then have a local
67070 : // scope which is different from other types (such a modifiers, references, pointers, and array types).
67071 : // SgType* root_type = result->stripType();
67072 : // unsigned char bit_array = STRIP_MODIFIER_TYPE | STRIP_REFERENCE_TYPE | STRIP_POINTER_TYPE | STRIP_ARRAY_TYPE | STRIP_TYPEDEF_TYPE;
67073 : // unsigned char bit_array = STRIP_ARRAY_TYPE | STRIP_TYPEDEF_TYPE;
67074 21699 : unsigned char bit_array = STRIP_MODIFIER_TYPE | STRIP_REFERENCE_TYPE | STRIP_RVALUE_REFERENCE_TYPE | STRIP_POINTER_TYPE | STRIP_ARRAY_TYPE;
67075 21699 : SgType* root_type = result->stripType(bit_array);
67076 21699 : ROSE_ASSERT(root_type != NULL);
67077 : #if 0
67078 : printf ("insertModifierTypeIntoTypeTable(): result not previously seen (or not in globalTypeTable) result = %p = %s name = %s \n",result,result->class_name().c_str(),name.str());
67079 : printf ("insertModifierTypeIntoTypeTable(): root_type = %p = %s \n",root_type,root_type->class_name().c_str());
67080 : #endif
67081 21699 : if (handledUsingLocalTable(root_type) == false)
67082 : {
67083 : #if 0
67084 : printf ("insertModifierTypeIntoTypeTable(): Mangled type name for SgModifierType = %s (does NOT exist in type table) inserting it... \n",name.str());
67085 : #endif
67086 3240 : get_globalTypeTable()->insert_type(name,result);
67087 : }
67088 : else
67089 : {
67090 : // For now we can skip this case and then later use the local type table from the scope of the declaration.
67091 : #if 0
67092 : printf ("insertModifierTypeIntoTypeTable(): Skip putting the SgModifierType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
67093 : #endif
67094 : }
67095 : #endif
67096 : }
67097 : else
67098 : {
67099 : // TV (07/13/2018): At the very least they should have the same stripped type... (it would happen if the base types have colliding mangled name)
67100 : // ROSE_ASSERT(t->stripType() == result->stripType());
67101 268 : if (t->stripType() != result->stripType())
67102 : {
67103 0 : printf ("insertModifierTypeIntoTypeTable(): result is modifier type to base_type = %p = %s name = %s \n",result->get_base_type(),result->get_base_type()->class_name().c_str(),name.str());
67104 0 : printf ("t = %p = %s \n",t,t->class_name().c_str());
67105 0 : printf ("result = %p = %s \n",result,result->class_name().c_str());
67106 0 : SgType* t_stripped = t->stripType();
67107 0 : SgType* result_stripped = result->stripType();
67108 0 : printf ("t_stripped = %p = %s \n",t_stripped,t_stripped->class_name().c_str());
67109 0 : printf ("result_stripped = %p = %s \n",result_stripped,result_stripped->class_name().c_str());
67110 :
67111 0 : SgName t_name = t->get_mangled();
67112 0 : SgName result_name = result->get_mangled();
67113 :
67114 0 : printf ("t_name = %s \n",t_name.str());
67115 0 : printf ("result_name = %s \n",result_name.str());
67116 :
67117 0 : bool t_isTypeEquivalent = t->isEquivalentType(result);
67118 0 : bool t_stripped_isTypeEquivalent = t_stripped->isEquivalentType(result_stripped);
67119 :
67120 0 : printf ("t_isTypeEquivalent = %s \n",t_isTypeEquivalent ? "true" : "false");
67121 0 : printf ("t_stripped_isTypeEquivalent = %s \n",t_stripped_isTypeEquivalent ? "true" : "false");
67122 :
67123 0 : SgNamedType* t_namedType = isSgNamedType(t_stripped);
67124 0 : SgNamedType* result_namedType = isSgNamedType(result_stripped);
67125 0 : if (t_namedType != NULL && result_namedType != NULL)
67126 : {
67127 0 : SgDeclarationStatement* t_declaration = isSgDeclarationStatement(t_namedType->get_declaration());
67128 0 : ROSE_ASSERT(t_declaration != NULL);
67129 0 : SgDeclarationStatement* result_declaration = isSgDeclarationStatement(result_namedType->get_declaration());
67130 0 : ROSE_ASSERT(result_declaration != NULL);
67131 :
67132 0 : printf ("t_declaration = %p = %s \n",t_declaration,t_declaration->class_name().c_str());
67133 0 : printf ("result_declaration = %p = %s \n",result_declaration,result_declaration->class_name().c_str());
67134 :
67135 0 : printf ("t_namedType->get_name() = %s \n",t_namedType->get_name().str());
67136 0 : printf ("result_namedType->get_name() = %s \n",result_namedType->get_name().str());
67137 :
67138 0 : SgName t_stripped_name = t_stripped->get_mangled();
67139 0 : SgName result_stripped_name = result_stripped->get_mangled();
67140 :
67141 0 : printf ("t_stripped_name = %s \n",t_stripped_name.str());
67142 0 : printf ("result_stripped_name = %s \n",result_stripped_name.str());
67143 :
67144 0 : SgNonrealDecl* t_nonreal_declaration = isSgNonrealDecl(t_declaration);
67145 0 : SgNonrealDecl* result_nonreal_declaration = isSgNonrealDecl(result_declaration);
67146 :
67147 0 : if (t_nonreal_declaration != NULL && result_nonreal_declaration != NULL)
67148 : {
67149 0 : printf ("t_nonreal_declaration->get_name() = %s \n",t_nonreal_declaration->get_name().str());
67150 0 : printf ("result_nonreal_declaration->get_name() = %s \n",result_nonreal_declaration->get_name().str());
67151 : }
67152 : }
67153 : }
67154 : // DQ (12/15/2019): Comment out as a test!
67155 : // ROSE_ASSERT(t->stripType() == result->stripType());
67156 :
67157 : // This should be only a pointer to a SgModifierType (e.g. a pointer to a const base_type) NOT TRUE.
67158 : // ROSE_ASSERT(isSgModifierType(base_type) != NULL || isSgFunctionType(base_type) != NULL);
67159 :
67160 : // The pointer type was found in either the local or global table (but the base_type->p_ptr_to should have been valid).
67161 : // printf ("WARNING: the pointer to a base type = %p = %s should exist, we need to find it! \n",base_type,base_type->class_name().c_str());
67162 : // ROSE_ASSERT(false);
67163 :
67164 : // If it is already present in the type table then delete the type (so that it will remain unique).
67165 : #if 0
67166 : printf ("insertModifierTypeIntoTypeTable(): Mangled type name for SgModifierType = %s t = %p = %s (already exists in type table) \n",name.str(),t,t->class_name().c_str());
67167 : printf ("insertModifierTypeIntoTypeTable(): t = %p result = %p \n",t,result);
67168 : #endif
67169 :
67170 : #if 0
67171 : if (t != result)
67172 : {
67173 : // Never delete the input type!
67174 : // delete result;
67175 : // result = NULL;
67176 :
67177 : result = isSgModifierType(t);
67178 : }
67179 : #else
67180 : // DQ (7/30/2010): Because SageBuilder::buildModifierType(SgType*) can be still
67181 : // called by mistake, we have to handle the case of where the type in the table is
67182 : // not a SgModifierType.
67183 268 : if (isSgModifierType(t) != NULL)
67184 : {
67185 : #if 0
67186 : printf ("insertModifierTypeIntoTypeTable(): Reset result (the return variabel) to be the SgModifier found in the type table (t = %p) \n",t);
67187 : #endif
67188 154 : result = isSgModifierType(t);
67189 : }
67190 : #if 0
67191 : // DQ (8/27/2010): There is no problem with t not being a SgModifierType.
67192 : else
67193 : {
67194 : // We want to later make this an error (the cause for this problem is the change to the build API for modifiers.
67195 : ROSE_ASSERT(t != NULL);
67196 : printf ("Error: SageBuilder::buildModifierType(SgType*) was called inapropriately internally t = %p = %s \n",t,t->class_name().c_str());
67197 : }
67198 : #endif
67199 : #endif
67200 268 : ROSE_ASSERT(result != NULL);
67201 : }
67202 : #endif
67203 :
67204 21967 : ROSE_ASSERT(result != NULL);
67205 :
67206 21967 : return result;
67207 : }
67208 :
67209 :
67210 :
67211 : // End of memberFunctionString
67212 : // Start of memberFunctionString
67213 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
67214 :
67215 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
67216 :
67217 : SgType*
67218 4050160 : SgModifierType::get_base_type () const
67219 : {
67220 4050160 : ROSE_ASSERT (this != NULL);
67221 :
67222 : #if 0
67223 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
67224 : // used to trigger marking transformations for the token-based unparsing.
67225 : printf ("SgModifierType::get_base_type = %p = %s \n",this,this->class_name().c_str());
67226 : #endif
67227 :
67228 4050160 : return p_base_type;
67229 : }
67230 :
67231 : void
67232 1382 : SgModifierType::set_base_type ( SgType* base_type )
67233 : {
67234 1382 : ROSE_ASSERT (this != NULL);
67235 :
67236 : #if 0
67237 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
67238 : // used to trigger marking transformations for the token-based unparsing.
67239 : printf ("SgModifierType::set_base_type = %p = %s \n",this,this->class_name().c_str());
67240 : #endif
67241 :
67242 1382 : set_isModified(true);
67243 :
67244 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
67245 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
67246 : {
67247 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
67248 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
67249 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
67250 : ROSE_ASSERT(false);
67251 : #endif
67252 : }
67253 : #endif
67254 1382 : p_base_type = base_type;
67255 1382 : }
67256 :
67257 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
67258 :
67259 :
67260 : // End of memberFunctionString
67261 : // Start of memberFunctionString
67262 :
67263 :
67264 : // End of memberFunctionString
67265 : // Start of memberFunctionString
67266 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
67267 :
67268 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
67269 :
67270 : char*
67271 29513 : SgModifierType::get_frontend_type_reference () const
67272 : {
67273 29513 : ROSE_ASSERT (this != NULL);
67274 :
67275 : #if 0
67276 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
67277 : // used to trigger marking transformations for the token-based unparsing.
67278 : printf ("SgModifierType::get_frontend_type_reference = %p = %s \n",this,this->class_name().c_str());
67279 : #endif
67280 :
67281 29513 : return p_frontend_type_reference;
67282 : }
67283 :
67284 : void
67285 14532 : SgModifierType::set_frontend_type_reference ( char* frontend_type_reference )
67286 : {
67287 14532 : ROSE_ASSERT (this != NULL);
67288 :
67289 : #if 0
67290 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
67291 : // used to trigger marking transformations for the token-based unparsing.
67292 : printf ("SgModifierType::set_frontend_type_reference = %p = %s \n",this,this->class_name().c_str());
67293 : #endif
67294 :
67295 14532 : set_isModified(true);
67296 :
67297 14532 : p_frontend_type_reference = frontend_type_reference;
67298 14532 : }
67299 :
67300 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
67301 :
67302 :
67303 : // End of memberFunctionString
67304 : // Start of memberFunctionString
67305 : /* #line 4173 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
67306 :
67307 :
67308 : // mask some bit on or off
67309 : // void set_modifier (int flag);
67310 : // void unset_modifier (int flag);
67311 :
67312 : SgTypeModifier &
67313 526259 : SgModifierType::get_typeModifier ()
67314 : {
67315 526259 : assert (this != NULL);
67316 526259 : return p_typeModifier;
67317 : }
67318 :
67319 : // RV (2/2/2006): Created this 'const' version.
67320 : const SgTypeModifier &
67321 548502 : SgModifierType::get_typeModifier (void) const
67322 : {
67323 548502 : assert (this != NULL);
67324 548502 : return p_typeModifier;
67325 : }
67326 :
67327 : #if 0
67328 : // DQ (11/28/2015): I think that I might not require this (not that I have reviewed the new implementation).
67329 : // It appears that it is already implemented as a friend function (acording to doxygen documentation).
67330 : // Actually it shows up in Doxygen, but it does not appear to be implemented.
67331 : // That was a mistake, it appears that the SgTypeModifier has an operator==(), but not the SgModifierType.
67332 : // These names make it easy to get confused!
67333 : bool
67334 : // SgModifierType::operator== (const SgModifierType & X, const SgModifierType & Y)
67335 : SgModifierType::operator== (const SgModifierType & Y) const
67336 : {
67337 : // return ( (X.get_base_type() == Y.get_base_type()) && (X.get_typeModifier() == Y.get_typeModifier()) );
67338 : bool isSame = false;
67339 :
67340 : #error "DEAD CODE!"
67341 :
67342 : const SgModifierType & X = *this;
67343 :
67344 : // DQ (11/28/2015): We don't want to strip off everything.
67345 : // SgType* stripType(unsigned char bit_array = STRIP_MODIFIER_TYPE | STRIP_REFERENCE_TYPE | STRIP_POINTER_TYPE | STRIP_ARRAY_TYPE | STRIP_TYPEDEF_TYPE ) const;
67346 :
67347 : // I think we need to compute the type chain to evaluate equalence.
67348 : // Rose_STL_Container< SgType*> getInternalTypes () const
67349 :
67350 : // Rose_STL_Container<SgType*> X_typeChain = X.get_base_type()->getInternalTypes();
67351 : // Rose_STL_Container<SgType*> Y_typeChain = Y.get_base_type()->getInternalTypes();
67352 : Rose_STL_Container<SgType*> X_typeChain = X.getInternalTypes();
67353 : Rose_STL_Container<SgType*> Y_typeChain = Y.getInternalTypes();
67354 :
67355 : #if 1
67356 : for (size_t i = 0; i < X_typeChain.size(); i++)
67357 : {
67358 : SgType* element_type = X_typeChain[i];
67359 : printf ("X_element_type = %p = %s \n",element_type,element_type->class_name().c_str());
67360 : SgModifierType* modifierType = isSgModifierType(element_type);
67361 : if (modifierType != NULL)
67362 : {
67363 : modifierType->get_typeModifier().display("X type chain");
67364 : }
67365 : }
67366 : for (size_t i = 0; i < Y_typeChain.size(); i++)
67367 : {
67368 : SgType* element_type = Y_typeChain[i];
67369 : printf ("Y_element_type = %p = %s \n",element_type,element_type->class_name().c_str());
67370 : SgModifierType* modifierType = isSgModifierType(element_type);
67371 : if (modifierType != NULL)
67372 : {
67373 : modifierType->get_typeModifier().display("Y type chain");
67374 : }
67375 : }
67376 :
67377 : int counter = 0;
67378 : bool exit = false;
67379 :
67380 : Rose_STL_Container<SgType*>::iterator i = X_typeChain.begin();
67381 : Rose_STL_Container<SgType*>::iterator j = Y_typeChain.begin();
67382 : while ( counter < 10 && exit == false && (i != X_typeChain.end() && j != Y_typeChain.end()))
67383 : {
67384 : #if 1
67385 : printf ("In SgModifierType::operator==(): counter = %d: type chain *i = %p = %s *j = %p = %s \n",counter,*i,(*i)->class_name().c_str(),*j,(*j)->class_name().c_str());
67386 : #endif
67387 : SgType* X_element_type = *i;
67388 : SgType* Y_element_type = *j;
67389 :
67390 : if (X_element_type == Y_element_type)
67391 : {
67392 : isSame = true;
67393 : exit = true;
67394 : #if 1
67395 : printf ("In SgModifierType::operator==(): loop: X_element_type == Y_element_type: isSame = %s \n",isSame ? "true" : "false");
67396 : #endif
67397 : }
67398 : else
67399 : {
67400 : // SgType* X_type = X.get_base_type()->stripType( STRIP_TYPEDEF_TYPE );
67401 : // SgType* Y_type = Y.get_base_type()->stripType( STRIP_TYPEDEF_TYPE );
67402 :
67403 : X_element_type = X_element_type->stripType( STRIP_TYPEDEF_TYPE );
67404 : Y_element_type = Y_element_type->stripType( STRIP_TYPEDEF_TYPE );
67405 : #if 0
67406 : SgTypedefType* X_typedefType = isSgTypedefType(X_element_type);
67407 : SgTypedefType* Y_typedefType = isSgTypedefType(Y_element_type);
67408 : if (X_typedefType != NULL && X_typedefType == Y_typedefType)
67409 : {
67410 : isSame = true;
67411 : exit = true;
67412 : #if 1
67413 : printf ("In SgModifierType::operator==(): loop: these are the same typedef type: isSame = %s \n",isSame ? "true" : "false");
67414 : #endif
67415 : }
67416 : else
67417 : {
67418 : if (X_typedefType != NULL || Y_typedefType != NULL)
67419 : {
67420 : if (X_typedefType != NULL)
67421 : {
67422 : i++;
67423 : }
67424 : if (Y_typedefType != NULL)
67425 : {
67426 : j++;
67427 : }
67428 : }
67429 : #else
67430 : {
67431 : #endif
67432 : // if ()
67433 : {
67434 : SgModifierType* X_modifierType = isSgModifierType(X_element_type);
67435 : SgModifierType* Y_modifierType = isSgModifierType(Y_element_type);
67436 :
67437 : if (X_modifierType != NULL && X_modifierType == Y_modifierType)
67438 : {
67439 : isSame = true;
67440 : exit = true;
67441 : #if 1
67442 : printf ("In SgModifierType::operator==(): loop: these are the same modifier type: isSame = %s \n",isSame ? "true" : "false");
67443 : #endif
67444 : }
67445 : else
67446 : {
67447 : if (X_modifierType != NULL || Y_modifierType != NULL)
67448 : {
67449 : if (X_modifierType != NULL && Y_modifierType != NULL)
67450 : {
67451 : if (X_modifierType->get_typeModifier() == Y_modifierType->get_typeModifier())
67452 : {
67453 : i++;
67454 : j++;
67455 : }
67456 : else
67457 : {
67458 : isSame = false;
67459 : exit = true;
67460 : #if 1
67461 : printf ("In SgModifierType::operator==(): loop: these are different modifier types: isSame = %s \n",isSame ? "true" : "false");
67462 : #endif
67463 : }
67464 : }
67465 : else
67466 : {
67467 : // Skip past default modifiers.
67468 : if (X_modifierType != NULL)
67469 : {
67470 : if (X_modifierType->get_typeModifier().isDefault() == true)
67471 : {
67472 : i++;
67473 : }
67474 : else
67475 : {
67476 : isSame = false;
67477 : exit = true;
67478 : #if 1
67479 : printf ("In SgModifierType::operator==(): loop: X is a non-default modifier type: isSame = %s \n",isSame ? "true" : "false");
67480 : #endif
67481 : }
67482 : }
67483 : else
67484 : {
67485 : isSame = false;
67486 : exit = true;
67487 : #if 1
67488 : printf ("In SgModifierType::operator==(): loop: X_element_type is not a modifier: X_element_type = %p = %s \n",X_element_type,X_element_type->class_name().c_str());
67489 : #endif
67490 : }
67491 :
67492 : // Skip past default modifiers.
67493 : if (Y_modifierType != NULL)
67494 : {
67495 : if (Y_modifierType->get_typeModifier().isDefault() == true)
67496 : {
67497 : j++;
67498 : }
67499 : else
67500 : {
67501 : isSame = false;
67502 : exit = true;
67503 : #if 1
67504 : printf ("In SgModifierType::operator==(): loop: Y is a non-default modifier type: isSame = %s \n",isSame ? "true" : "false");
67505 : #endif
67506 : }
67507 : }
67508 : else
67509 : {
67510 : isSame = false;
67511 : exit = true;
67512 : #if 1
67513 : printf ("In SgModifierType::operator==(): loop: Y_element_type is not a modifier: Y_element_type = %p = %s \n",Y_element_type,Y_element_type->class_name().c_str());
67514 : #endif
67515 : }
67516 : }
67517 : }
67518 : else
67519 : {
67520 : // if (X_typedefType != NULL || Y_typedefType != NULL)
67521 : // if (X_modifierType == NULL && Y_modifierType == NULL)
67522 : // if (X_typedefType == NULL && Y_typedefType == NULL && X_modifierType == NULL && Y_modifierType == NULL)
67523 : if ( (X_typedefType == NULL && X_modifierType == NULL) || (Y_typedefType == NULL && Y_modifierType == NULL) )
67524 : {
67525 : #if 0
67526 : printf ("In SgModifierType::operator==(): loop: one of both are neither a typedef or modifier type: isSame = %s \n",isSame ? "true" : "false");
67527 : #endif
67528 : if (X_element_type == Y_element_type)
67529 : {
67530 : isSame = true;
67531 : exit = true;
67532 : #if 1
67533 : printf ("In SgModifierType::operator==(): loop: X_element_type == Y_element_type: isSame = %s \n",isSame ? "true" : "false");
67534 : #endif
67535 : }
67536 : else
67537 : {
67538 : isSame = false;
67539 : exit = true;
67540 : #if 1
67541 : printf ("In SgModifierType::operator==(): loop: X_element_type != Y_element_type: isSame = %s \n",isSame ? "true" : "false");
67542 : #endif
67543 : }
67544 : }
67545 : #if 0
67546 : else
67547 : {
67548 : #if 1
67549 : printf ("In SgModifierType::operator==(): loop: both of them are not a modifier or typedef type: isSame = %s \n",isSame ? "true" : "false");
67550 : #endif
67551 : if (X_modifierType == NULL || Y_modifierType == NULL)
67552 : {
67553 : }
67554 : }
67555 : #endif
67556 : }
67557 : }
67558 : }
67559 : }
67560 : }
67561 :
67562 : // Use a counter to avoid long type chains while we debug this code.
67563 : counter++;
67564 : }
67565 : #endif
67566 : #if 1
67567 : printf ("In SgModifierType::operator==(): after using loop over type chains: isSame = %s \n",isSame ? "true" : "false");
67568 : #endif
67569 :
67570 : #error "DEAD CODE!"
67571 :
67572 : #if 0
67573 : isSame = false;
67574 :
67575 : // SgType* X_type = X.get_base_type()->stripType();
67576 : // SgType* Y_type = Y.get_base_type()->stripType();
67577 : // SgType* X_type = X.get_base_type()->stripType( STRIP_MODIFIER_TYPE | STRIP_TYPEDEF_TYPE );
67578 : // SgType* Y_type = Y.get_base_type()->stripType( STRIP_MODIFIER_TYPE | STRIP_TYPEDEF_TYPE );
67579 : SgType* X_type = X.get_base_type()->stripType( STRIP_TYPEDEF_TYPE );
67580 : SgType* Y_type = Y.get_base_type()->stripType( STRIP_TYPEDEF_TYPE );
67581 :
67582 : ROSE_ASSERT(X_type != NULL);
67583 : ROSE_ASSERT(Y_type != NULL);
67584 :
67585 : #if 1
67586 : printf ("In SgModifierType::operator==(): base_type X = %p = %s Y = %p = %s \n",X.get_base_type(),X.get_base_type()->class_name().c_str(),Y.get_base_type(),Y.get_base_type()->class_name().c_str());
67587 : printf (" --- stripped base types: X = %p = %s Y = %p = %s \n",X_type,X_type->class_name().c_str(),Y_type,Y_type->class_name().c_str());
67588 : #endif
67589 :
67590 : // if (X.get_base_type() == Y.get_base_type())
67591 : if (X_type == Y_type)
67592 : {
67593 : #if 1
67594 : printf ("In SgModifierType::operator==(): base_type are the same: get_base_type() = %p = %s \n",X.get_base_type(),X.get_base_type()->class_name().c_str());
67595 : X.get_typeModifier().display("In SgModifierType::operator==()");
67596 : Y.get_typeModifier().display("In SgModifierType::operator==()");
67597 : #endif
67598 : if (X.get_typeModifier() == Y.get_typeModifier())
67599 : {
67600 : #if 1
67601 : printf ("In SgModifierType::operator==(): internal typeModifiers are the same \n");
67602 : #endif
67603 : isSame = true;
67604 : }
67605 : }
67606 : else
67607 : {
67608 : #if 0
67609 : SgModifierType* X_modifier = isSgModifierType(X_type);
67610 : SgModifierType* Y_modifier = isSgModifierType(Y_type);
67611 : if (X_modifier->get_typeModifier().isDefault())
67612 : {
67613 : X_type = X_modifier->get_base_type();
67614 : }
67615 : #endif
67616 : }
67617 : #endif
67618 :
67619 : #if 1
67620 : printf ("In SgModifierType::operator==(): isSame = %s \n",isSame ? "true" : "false");
67621 : #endif
67622 :
67623 : #error "DEAD CODE!"
67624 :
67625 : return isSame;
67626 : }
67627 : #endif
67628 :
67629 :
67630 :
67631 : #if 0
67632 : bool
67633 : SgModifierType::isSync() const
67634 : {
67635 : // CC++ specific modifier!
67636 : return p_bitfield & m_sync;
67637 : }
67638 :
67639 : bool
67640 : SgModifierType::isGlobal() const
67641 : { return p_bitfield & m_global; }
67642 : #endif
67643 : #if 0
67644 : void
67645 : SgModifierType::unsetSync()
67646 : { p_bitfield &= ~m_sync; }
67647 :
67648 : void
67649 : SgModifierType::setSync()
67650 : {
67651 : // DQ (12/7/2003): != is meaningless
67652 : // p_bitfield != m_sync;
67653 : p_bitfield |= m_sync;
67654 : }
67655 :
67656 : void
67657 : SgModifierType::unsetGlobal()
67658 : { p_bitfield &= ~m_global; }
67659 :
67660 : void
67661 : SgModifierType::setGlobal()
67662 : {
67663 : // DQ (12/7/2003): != is meaningless
67664 : // p_bitfield != m_global;
67665 : p_bitfield |= m_global;
67666 : }
67667 : #endif
67668 :
67669 : #if 0
67670 : // Access the function at the lower level typeModifier, storageModifier, or accessModifier objects
67671 : bool SgModifierType::isRestrict() const { return p_typeModifier.isRestrict(); }
67672 : bool SgModifierType::isConst() const { return p_typeModifier.get_constVolatileModifier().isConst(); }
67673 : bool SgModifierType::isVolatile() const { return p_typeModifier.get_constVolatileModifier().isVolatile(); }
67674 : bool SgModifierType::isUPC_Shared() const { return p_typeModifier.get_upcModifier().isUPC_Shared(); }
67675 : bool SgModifierType::isUPC_Strict() const { return p_typeModifier.get_upcModifier().isUPC_Strict(); }
67676 : bool SgModifierType::isUPC_Relaxed() const { return p_typeModifier.get_upcModifier().isUPC_Relaxed(); }
67677 :
67678 : void SgModifierType::unsetRestrict() { p_typeModifier.unsetRestrict(); }
67679 : void SgModifierType::setRestrict() { p_typeModifier.setRestrict(); }
67680 : #endif
67681 :
67682 : #if 0
67683 : void SgModifierType::unsetConst() { p_typeModifier.get_constVolatileModifier().unsetConst(); }
67684 : void SgModifierType::setConst() { p_typeModifier.get_constVolatileModifier().setConst(); }
67685 : void SgModifierType::unsetVolatile() { p_typeModifier.get_constVolatileModifier().unsetVolatile(); }
67686 : void SgModifierType::setVolatile() { p_typeModifier.get_constVolatileModifier().setVolatile(); }
67687 : void SgModifierType::unsetUPC_Shared() { p_typeModifier.get_upcModifier().unsetUPC_Shared(); }
67688 : void SgModifierType::setUPC_Shared() { p_typeModifier.get_upcModifier().setUPC_Shared(); }
67689 : void SgModifierType::unsetUPC_Strict() { p_typeModifier.get_upcModifier().unsetUPC_Strict(); }
67690 : void SgModifierType::setUPC_Strict() { p_typeModifier.get_upcModifier().setUPC_Strict(); }
67691 : void SgModifierType::unsetUPC_Relaxed() { p_typeModifier.get_upcModifier().unsetUPC_Relaxed(); }
67692 : void SgModifierType::setUPC_Relaxed() { p_typeModifier.get_upcModifier().setUPC_Relaxed(); }
67693 : #endif
67694 :
67695 : #if 0
67696 : bool SgModifierType::isExtern() const { return p_storageModifier.isExtern(); }
67697 : bool SgModifierType::isStatic() const { return p_storageModifier.isStatic(); }
67698 : bool SgModifierType::isAuto() const { return p_storageModifier.isAuto(); }
67699 : bool SgModifierType::isUnspecified() const { return p_storageModifier.isUnspecified(); }
67700 : bool SgModifierType::isTypedef() const { return p_storageModifier.isTypedef(); }
67701 : bool SgModifierType::isRegister() const { return p_storageModifier.isRegister(); }
67702 : bool SgModifierType::isAsm() const { return p_storageModifier.isAsm(); }
67703 : bool SgModifierType::isVirtual() const { return p_accessModifier.isVirtual(); }
67704 : bool SgModifierType::isProtected() const { return p_accessModifier.isProtected(); }
67705 : bool SgModifierType::isPrivate() const { return p_accessModifier.isPrivate(); }
67706 : bool SgModifierType::isPublic() const { return p_accessModifier.isPublic(); }
67707 :
67708 : void SgModifierType::setExtern() { p_storageModifier.setExtern(); }
67709 : void SgModifierType::setStatic() { p_storageModifier.setStatic(); }
67710 : void SgModifierType::setAuto() { p_storageModifier.setAuto(); }
67711 : void SgModifierType::setUnspecified() { p_storageModifier.setUnspecified(); }
67712 : void SgModifierType::setTypedef() { p_storageModifier.setTypedef(); }
67713 : void SgModifierType::setRegister() { p_storageModifier.setRegister(); }
67714 : void SgModifierType::setAsm() { p_storageModifier.setAsm(); }
67715 : void SgModifierType::setPrivate() { p_accessModifier.setPrivate(); }
67716 : void SgModifierType::setProtected() { p_accessModifier.setProtected(); }
67717 : void SgModifierType::setPublic() { p_accessModifier.setPublic(); }
67718 : void SgModifierType::setVirtual() { p_accessModifier.setVirtual(); }
67719 : #endif
67720 :
67721 : #if 0
67722 : unsigned int
67723 : SgModifierType::bitfield(void)
67724 : { return p_bitfield; }
67725 : #endif
67726 :
67727 : // RV (1/31/2006): Removed dependence on SgUnparse_Info
67728 : SgName
67729 544313 : SgModifierType::get_mangled (void) const
67730 : {
67731 544313 : ROSE_ASSERT(this != NULL);
67732 :
67733 544313 : SgName mangled_name;
67734 :
67735 544313 : const SgTypeModifier & type_mod = get_typeModifier();
67736 544313 : const SgConstVolatileModifier & cv_mod = type_mod.get_constVolatileModifier();
67737 544313 : const SgUPC_AccessModifier & upc_mod = type_mod.get_upcModifier();
67738 :
67739 : // PP (02/17/22) Add aliased information to mangled name
67740 544313 : if (type_mod.isAliased()) mangled_name << "A";
67741 :
67742 984686 : if (cv_mod.isConst()) mangled_name << "C";
67743 585117 : if (cv_mod.isVolatile()) mangled_name << "V";
67744 :
67745 : // DQ (4/22/2004): Removed support for CC++
67746 : // if (isSync()) mangled_name << "SYN";
67747 : // if (isGlobal()) mangled_name << "GLB";
67748 544315 : if (type_mod.isRestrict()) mangled_name << "RST";
67749 : // if (upc_mod.isUPC_Shared()) mangled_name << "SHD";
67750 :
67751 : // PP make mangled name depend on blocksize
67752 544313 : if (upc_mod.get_isShared())
67753 : {
67754 33 : mangled_name << "SHD";
67755 :
67756 33 : std::stringstream sstr;
67757 33 : long blocksize = upc_mod.get_layout();
67758 33 : ROSE_ASSERT(blocksize >= -2);
67759 :
67760 : // \pp just add the blocksize as string to the mangled name.
67761 : // The TypeTable implementation needs to differentiate types
67762 : // with different shared blocksize.
67763 33 : sstr << blocksize;
67764 66 : mangled_name << sstr.str();
67765 : }
67766 :
67767 544313 : if (upc_mod.isUPC_Strict()) mangled_name << "STR";
67768 544313 : if (upc_mod.isUPC_Relaxed()) mangled_name << "RLX";
67769 :
67770 1088630 : mangled_name << get_base_type()->get_mangled().str();
67771 :
67772 544313 : return mangled_name;
67773 : }
67774 :
67775 : #if 0
67776 : // Older code
67777 : SgName
67778 : SgModifierType::get_mangled(SgUnparse_Info& info)
67779 : {
67780 : SgName tmp;
67781 : if (get_typeModifier().get_constVolatileModifier().isConst()) tmp << "C";
67782 : if (get_typeModifier().get_constVolatileModifier().isVolatile()) tmp << "V";
67783 : // DQ (4/22/2004): Removed support for CC++
67784 : // if (isSync()) tmp << "SYN";
67785 : // if (isGlobal()) tmp << "GLB";
67786 : if (get_typeModifier().isRestrict()) tmp << "RST";
67787 : if (get_typeModifier().get_upcModifier().isUPC_Shared()) tmp << "SHD";
67788 : if (get_typeModifier().get_upcModifier().isUPC_Strict()) tmp << "STR";
67789 : if (get_typeModifier().get_upcModifier().isUPC_Relaxed()) tmp << "RLX";
67790 :
67791 : tmp << get_base_type()->get_mangled(info).str();
67792 :
67793 : return tmp;
67794 : }
67795 : #endif
67796 :
67797 : // DQ (7/24/2010): Adding post_construction_initialization() function.
67798 : void
67799 21967 : SgModifierType::post_construction_initialization()
67800 : {
67801 21967 : ROSE_ASSERT(p_base_type != NULL);
67802 :
67803 : // DQ (7/24/2010): There can be a number of different types of modifiers for a given base type and
67804 : // the SgModifierType contains a list of them. But I don't think it is used!
67805 21967 : if (isSgModifierType(p_base_type) == NULL)
67806 : {
67807 21817 : ROSE_ASSERT(p_base_type->get_modifiers() == NULL);
67808 : }
67809 :
67810 : // The local reference to the SgModifierType should also be NULL.
67811 : // ROSE_ASSERT(get_modifiers() == NULL);
67812 21967 : }
67813 :
67814 :
67815 :
67816 : // End of memberFunctionString
67817 : // Start of memberFunctionString
67818 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
67819 :
67820 : // *** COMMON CODE SECTION BEGINS HERE ***
67821 :
67822 : #if 0
67823 : int
67824 : SgModifierType::getVariant() const
67825 : {
67826 : // This function is used in ROSE while "variant()" is used in SAGE
67827 : assert(this != NULL);
67828 : return variant();
67829 : }
67830 : #endif
67831 :
67832 : // This function is used in ROSE in treeTraversal code
67833 : // eventually replaces getVariant() and variant()
67834 : // though after variant() has been removed for a while we will
67835 : // want to change the name of variantT() back to variant()
67836 : // (since the "T" was ment to stand for temporary).
67837 : // When this happens the variantT() will be depricated.
67838 : VariantT
67839 177017000 : SgModifierType::variantT() const
67840 : {
67841 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
67842 177017000 : ROSE_ASSERT(this != NULL);
67843 177017000 : return V_SgModifierType;
67844 : }
67845 :
67846 : #if 0
67847 : int
67848 : SgModifierType::variant() const
67849 : {
67850 : // This function is used in SAGE
67851 : ROSE_ASSERT(this != NULL);
67852 : return T_MODIFIER;
67853 : }
67854 : #endif
67855 :
67856 : ROSE_DLL_API const char*
67857 0 : SgModifierType::sage_class_name() const
67858 : {
67859 0 : ROSE_ASSERT(this != NULL);
67860 0 : return "SgModifierType";
67861 : }
67862 :
67863 : std::string
67864 18686 : SgModifierType::class_name() const
67865 : {
67866 18686 : ROSE_ASSERT(this != NULL);
67867 18686 : return "SgModifierType";
67868 : }
67869 :
67870 : // DQ (11/26/2005): Support for visitor pattern mechanims
67871 : // (inferior to ROSE traversal mechanism, experimental).
67872 : void
67873 118952 : SgModifierType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
67874 : {
67875 118952 : ROSE_ASSERT(this != NULL);
67876 118952 : visitor.visit(this);
67877 118952 : }
67878 :
67879 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
67880 0 : void SgModifierType::accept (ROSE_VisitorPattern & visitor) {
67881 0 : ROSE_ASSERT(this != NULL);
67882 0 : visitor.visit(this);
67883 0 : }
67884 :
67885 : SgModifierType*
67886 0 : SgModifierType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
67887 : {
67888 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
67889 : // This function is currently only supported for the AST used the represent Binary executables.
67890 : if (0 /* isSgAsmNode(this) != NULL */)
67891 : {
67892 : // Support for regex specification.
67893 : std::string prefixCode = "REGEX:";
67894 : addNewAttribute(prefixCode + s,a);
67895 : }
67896 : #endif
67897 :
67898 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
67899 0 : return this;
67900 : }
67901 :
67902 : // *** COMMON CODE SECTION ENDS HERE ***
67903 :
67904 :
67905 : // End of memberFunctionString
67906 : // Start of memberFunctionString
67907 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
67908 :
67909 :
67910 : #if 0
67911 : //! Error checking support
67912 : /*! Verifies the following:
67913 : - working getVariant() member function
67914 : - calls base class's error() member function
67915 : Every class has one of these functions.
67916 : */
67917 : bool
67918 : SgModifierType::error()
67919 : {
67920 : // Put error checking here
67921 :
67922 : ROSE_ASSERT (this != NULL);
67923 : if (getVariant() != T_MODIFIER)
67924 : {
67925 : printf ("Error in SgModifierType::error(): SgModifierType object has a %s variant \n",
67926 : Cxx_GrammarTerminalNames[getVariant()].name);
67927 : // printf ("Error in SgModifierType::error() \n");
67928 : ROSE_ABORT();
67929 : }
67930 :
67931 : ROSE_ASSERT (getVariant() == T_MODIFIER);
67932 : return SgType::error();
67933 : }
67934 : #endif
67935 :
67936 :
67937 :
67938 : // End of memberFunctionString
67939 :
67940 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
67941 :
67942 164682000 : SgModifierType* isSgModifierType ( SgNode* inputDerivedClassPointer )
67943 : {
67944 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
67945 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
67946 : // So to fix this we return NULL directly when the input is NULL and avoid the
67947 : // dynamic_cast in this case. This is likely a performance improvement as well.
67948 : // return dynamic_cast<SgModifierType*>(inputDerivedClassPointer);
67949 : // Milind Chabbi (8/28/2013): isSgModifierType uses table-driven castability instead of c++ default dynamic_cast
67950 : // this improves the running time performance by 10-20%.
67951 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModifierType*>(inputDerivedClassPointer);
67952 164682000 : return IS_SgModifierType_FAST_MACRO(inputDerivedClassPointer);
67953 : }
67954 :
67955 : // DQ (11/8/2003): Added version of functions taking const pointer
67956 4243 : const SgModifierType* isSgModifierType ( const SgNode* inputDerivedClassPointer )
67957 : {
67958 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
67959 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
67960 : // So to fix this we return NULL directly when the input is NULL and avoid the
67961 : // dynamic_cast in this case. This is likely a performance improvement as well.
67962 : // return dynamic_cast<const SgModifierType*>(inputDerivedClassPointer);
67963 : // Milind Chabbi (8/28/2013): isSgModifierType uses table-driven castability instead of c++ default dynamic_cast
67964 : // this improves the running time performance by 10-20%.
67965 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModifierType*>(inputDerivedClassPointer);
67966 4243 : return IS_SgModifierType_FAST_MACRO(inputDerivedClassPointer);
67967 : }
67968 :
67969 :
67970 :
67971 : /* #line 67972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
67972 :
67973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
67974 :
67975 : /**
67976 : \brief Generated destructor
67977 :
67978 : This destructor is automatically generated (by ROSETTA). This destructor
67979 : only frees memory of data members associated with the parts of the current IR node which
67980 : are NOT traversed. Those data members that are part of a traversal can be freed using
67981 : a traversal (calling this destructor on all children in a post-order traversal). Such
67982 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
67983 :
67984 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
67985 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
67986 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
67987 :
67988 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
67989 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
67990 : pointers are not yet implemented to call delete on eash pointer in the container.
67991 : (This could be done by derivation from the STL containers to define containers that
67992 : automatically deleted their members.)
67993 :
67994 : */
67995 3812 : SgModifierType::~SgModifierType () {
67996 1906 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
67997 :
67998 :
67999 : // case: not a listType for base_type
68000 1906 : p_base_type = NULL; // non list case
68001 : // case: typeName == char* or char** for frontend_type_reference
68002 1906 : p_frontend_type_reference = NULL;
68003 :
68004 : }
68005 :
68006 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
68007 3812 : }
68008 :
68009 :
68010 : /* #line 68011 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
68011 :
68012 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
68013 :
68014 : // Generated constructor
68015 21967 : SgModifierType::SgModifierType ( SgType* base_type )
68016 21967 : : SgType()
68017 : {
68018 : #ifdef DEBUG
68019 : // printf ("In SgModifierType::SgModifierType (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
68020 : #endif
68021 : #if 0
68022 : // debugging information!
68023 : printf ("In SgModifierType::SgModifierType (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
68024 : #endif
68025 :
68026 21967 : p_base_type = base_type;
68027 21967 : p_frontend_type_reference = NULL;
68028 :
68029 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
68030 :
68031 : #if 0
68032 : // DQ (7/30/2014): Call a virtual function.
68033 : std::string s = this->class_name();
68034 : #endif
68035 :
68036 : // Test the variant virtual function
68037 : // assert(T_MODIFIER == variant());
68038 21967 : assert(T_MODIFIER == this->variant());
68039 21967 : ROSE_ASSERT(T_MODIFIER == (int)(this->variantT()));
68040 21967 : post_construction_initialization();
68041 :
68042 : // Test the isSgModifierType() function since it has been problematic
68043 21967 : assert(isSgModifierType(this) != NULL);
68044 21967 : }
68045 :
68046 : // Generated constructor (all data members)
68047 :
68048 : /* #line 68049 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
68049 :
68050 :
68051 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
68052 :
68053 :
68054 : // ********************************************************
68055 : // member functions common across all array grammar objects
68056 : // ********************************************************
68057 :
68058 :
68059 :
68060 : /* #line 68061 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
68061 :
68062 :
68063 :
68064 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
68065 :
68066 : // ********************************************************
68067 : // member functions specific to each node in the grammar
68068 : // ********************************************************
68069 :
68070 :
68071 : /* #line 68072 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
68072 :
68073 : // Start of memberFunctionString
68074 : /* #line 6610 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
68075 :
68076 : // SgFunctionType* SgFunctionType::createType(SgPartialFunctionType* ft)
68077 : SgFunctionType*
68078 0 : SgFunctionType::createType(SgPartialFunctionType* ft, SgExpression* optional_fortran_type_kind)
68079 : {
68080 : // The problem with this function is that I have not added the name mangling into SAGE 3 yet!
68081 :
68082 0 : ROSE_ASSERT(ft != NULL);
68083 :
68084 : // DQ (10/4/2010): I don't think this type can have a fortran type kind parameter.
68085 0 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
68086 :
68087 : #if 0
68088 : printf ("In SgFunctionType::createType() (CREATE_TYPE_FOR_FUNCTION_TYPE) \n");
68089 : #endif
68090 :
68091 : #if 1
68092 : // DQ (3/29/2006):
68093 : // Simplify this function to not use the function type table, thus SgFunctionType nodes are not
68094 : // shared. During function creation. As a result we don't have to call the functions to mangle
68095 : // the names of things (which traverse parents to compute scopes and can be a problem if called
68096 : // before the parents are set, done in post processing of AST). However, this design requires
68097 : // that the funtion type symbol table be constructed after the AST is built (and parent pointers
68098 : // are set). If functions are created then the function type table must also be updated.
68099 0 : SgFunctionType* theType = new SgFunctionType(ft);
68100 :
68101 : // DQ (6/21/2006): Since we mangle the return type into the mangled function as part of building
68102 : // the symbol table we don't have to worry about sharing function types that would have different
68103 : // return types. Here we set the orig_return_type stored explicitly (it seems it is always the
68104 : // same as the return_type.
68105 0 : ROSE_ASSERT (ft->get_return_type() != NULL);
68106 0 : theType->set_orig_return_type(ft->get_return_type());
68107 : #else
68108 : // printf ("In SgFunctionType::createType(SgPartialFunctionType* ft): calling ft->get_mangled_type \n");
68109 : // SgName nname = ft->get_mangled_type();
68110 :
68111 : // DQ (3/29/2006): experiment with generating a unique name for the function type table lookup
68112 : // This will avoid calling the get_mangled_type() function durring the construction
68113 : // of the AST. Because the name will be unique there will be no collision in the
68114 : // function type symbol table. The function type symbol tabel will then have to
68115 : // be rebuilt after the AST is build (in a post-processing phase).
68116 : static int functionCounter = 0;
68117 : string baseName = "function_";
68118 : string mangleName = baseName + Rose::StringUtility::numberToString(functionCounter++);
68119 : SgName nname = mangleName;
68120 :
68121 : #if 0
68122 : SgName nname = "NOT YET SUPPORTED IN SAGE3 YET"; // ft->get_mangled_type();
68123 : printf ("WARNING: Name mangling not yet suppported in SAGE 3! (required in SgFunctionType::createType()) \n");
68124 : #endif
68125 :
68126 : // check the function type table
68127 : // DQ (1/31/2006): Modified to build all types in the memory pools
68128 : // SgType *t = Sgfunc_type_table.lookup_function_type(nname);
68129 : ROSE_ASSERT(get_globalFunctionTypeTable() != NULL);
68130 : SgType *t = get_globalFunctionTypeTable()->lookup_function_type(nname);
68131 :
68132 : SgFunctionType *theType = isSgFunctionType(t);
68133 : // if(!theType)
68134 : if(theType == NULL)
68135 : {
68136 : // printf ("##### Building a default type since theType == NULL \n");
68137 : theType = new SgFunctionType(ft);
68138 : ROSE_ASSERT(theType != NULL);
68139 : // DQ (1/31/2006): Modified to build all types in the memory pools
68140 : // Sgfunc_type_table.insert_function_type(nname, theType);
68141 : ROSE_ASSERT(get_globalFunctionTypeTable() != NULL);
68142 : get_globalFunctionTypeTable()->insert_function_type(nname, theType);
68143 : }
68144 : else
68145 : {
68146 : theType->set_orig_return_type(ft->get_return_type());
68147 : }
68148 :
68149 : // Commented out to avoid deleting the input data (poor design, I think)
68150 : // delete ft;
68151 : #endif
68152 :
68153 0 : ROSE_ASSERT(theType != NULL);
68154 0 : return theType;
68155 : }
68156 :
68157 :
68158 :
68159 : // End of memberFunctionString
68160 : // Start of memberFunctionString
68161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
68162 :
68163 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
68164 :
68165 : SgType*
68166 3559360 : SgFunctionType::get_return_type () const
68167 : {
68168 3559360 : ROSE_ASSERT (this != NULL);
68169 :
68170 : #if 0
68171 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68172 : // used to trigger marking transformations for the token-based unparsing.
68173 : printf ("SgFunctionType::get_return_type = %p = %s \n",this,this->class_name().c_str());
68174 : #endif
68175 :
68176 3559360 : return p_return_type;
68177 : }
68178 :
68179 : void
68180 0 : SgFunctionType::set_return_type ( SgType* return_type )
68181 : {
68182 0 : ROSE_ASSERT (this != NULL);
68183 :
68184 : #if 0
68185 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68186 : // used to trigger marking transformations for the token-based unparsing.
68187 : printf ("SgFunctionType::set_return_type = %p = %s \n",this,this->class_name().c_str());
68188 : #endif
68189 :
68190 0 : set_isModified(true);
68191 :
68192 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
68193 : if (p_return_type != NULL && return_type != NULL && p_return_type != return_type)
68194 : {
68195 : printf ("Warning: return_type = %p overwriting valid pointer p_return_type = %p \n",return_type,p_return_type);
68196 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
68197 : printf ("Error fails assertion (p_return_type != NULL && return_type != NULL && p_return_type != return_type) is false\n");
68198 : ROSE_ASSERT(false);
68199 : #endif
68200 : }
68201 : #endif
68202 0 : p_return_type = return_type;
68203 0 : }
68204 :
68205 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
68206 :
68207 :
68208 : // End of memberFunctionString
68209 : // Start of memberFunctionString
68210 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
68211 :
68212 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
68213 :
68214 : bool
68215 0 : SgFunctionType::get_has_ellipses () const
68216 : {
68217 0 : ROSE_ASSERT (this != NULL);
68218 :
68219 : #if 0
68220 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68221 : // used to trigger marking transformations for the token-based unparsing.
68222 : printf ("SgFunctionType::get_has_ellipses = %p = %s \n",this,this->class_name().c_str());
68223 : #endif
68224 :
68225 0 : return p_has_ellipses;
68226 : }
68227 :
68228 : void
68229 0 : SgFunctionType::set_has_ellipses ( bool has_ellipses )
68230 : {
68231 0 : ROSE_ASSERT (this != NULL);
68232 :
68233 : #if 0
68234 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68235 : // used to trigger marking transformations for the token-based unparsing.
68236 : printf ("SgFunctionType::set_has_ellipses = %p = %s \n",this,this->class_name().c_str());
68237 : #endif
68238 :
68239 0 : set_isModified(true);
68240 :
68241 0 : p_has_ellipses = has_ellipses;
68242 0 : }
68243 :
68244 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
68245 :
68246 :
68247 : // End of memberFunctionString
68248 : // Start of memberFunctionString
68249 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
68250 :
68251 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
68252 :
68253 : SgType*
68254 1422570 : SgFunctionType::get_orig_return_type () const
68255 : {
68256 1422570 : ROSE_ASSERT (this != NULL);
68257 :
68258 : #if 0
68259 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68260 : // used to trigger marking transformations for the token-based unparsing.
68261 : printf ("SgFunctionType::get_orig_return_type = %p = %s \n",this,this->class_name().c_str());
68262 : #endif
68263 :
68264 1422570 : return p_orig_return_type;
68265 : }
68266 :
68267 : void
68268 288581 : SgFunctionType::set_orig_return_type ( SgType* orig_return_type )
68269 : {
68270 288581 : ROSE_ASSERT (this != NULL);
68271 :
68272 : #if 0
68273 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68274 : // used to trigger marking transformations for the token-based unparsing.
68275 : printf ("SgFunctionType::set_orig_return_type = %p = %s \n",this,this->class_name().c_str());
68276 : #endif
68277 :
68278 288581 : set_isModified(true);
68279 :
68280 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
68281 : if (p_orig_return_type != NULL && orig_return_type != NULL && p_orig_return_type != orig_return_type)
68282 : {
68283 : printf ("Warning: orig_return_type = %p overwriting valid pointer p_orig_return_type = %p \n",orig_return_type,p_orig_return_type);
68284 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
68285 : printf ("Error fails assertion (p_orig_return_type != NULL && orig_return_type != NULL && p_orig_return_type != orig_return_type) is false\n");
68286 : ROSE_ASSERT(false);
68287 : #endif
68288 : }
68289 : #endif
68290 288581 : p_orig_return_type = orig_return_type;
68291 288581 : }
68292 :
68293 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
68294 :
68295 :
68296 : // End of memberFunctionString
68297 : // Start of memberFunctionString
68298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
68299 :
68300 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
68301 :
68302 : SgFunctionParameterTypeList*
68303 5758850 : SgFunctionType::get_argument_list () const
68304 : {
68305 5758850 : ROSE_ASSERT (this != NULL);
68306 :
68307 : #if 0
68308 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68309 : // used to trigger marking transformations for the token-based unparsing.
68310 : printf ("SgFunctionType::get_argument_list = %p = %s \n",this,this->class_name().c_str());
68311 : #endif
68312 :
68313 5758850 : return p_argument_list;
68314 : }
68315 :
68316 : void
68317 518892 : SgFunctionType::set_argument_list ( SgFunctionParameterTypeList* argument_list )
68318 : {
68319 518892 : ROSE_ASSERT (this != NULL);
68320 :
68321 : #if 0
68322 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
68323 : // used to trigger marking transformations for the token-based unparsing.
68324 : printf ("SgFunctionType::set_argument_list = %p = %s \n",this,this->class_name().c_str());
68325 : #endif
68326 :
68327 518892 : set_isModified(true);
68328 :
68329 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
68330 : if (p_argument_list != NULL && argument_list != NULL && p_argument_list != argument_list)
68331 : {
68332 : printf ("Warning: argument_list = %p overwriting valid pointer p_argument_list = %p \n",argument_list,p_argument_list);
68333 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
68334 : printf ("Error fails assertion (p_argument_list != NULL && argument_list != NULL && p_argument_list != argument_list) is false\n");
68335 : ROSE_ASSERT(false);
68336 : #endif
68337 : }
68338 : #endif
68339 518892 : p_argument_list = argument_list;
68340 518892 : }
68341 :
68342 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
68343 :
68344 :
68345 : // End of memberFunctionString
68346 : // Start of memberFunctionString
68347 : /* #line 4775 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
68348 :
68349 :
68350 : // Specialized constructor
68351 19092 : SgFunctionType::SgFunctionType(SgPartialFunctionType *ft)
68352 : {
68353 19092 : assert(ft != NULL);
68354 19092 : p_return_type = ft->p_return_type;
68355 19092 : p_has_ellipses = ft->p_has_ellipses;
68356 :
68357 : // DQ (12/13/2012): We have to set this to NULL since it is checked in the call to post_construction_initialization().
68358 19092 : p_argument_list = NULL;
68359 :
68360 : #if 0
68361 : p_orig_return_type = ft->p_return_type;
68362 :
68363 : // DQ (6/25/2006): Handle the allocation of the SgFunctionParameterTypeList in one place if possible!
68364 : // This is part of debugging the AST File I/O.
68365 :
68366 : /* process argument type */
68367 : p_argument_list = new SgFunctionParameterTypeList();
68368 : ROSE_ASSERT(p_argument_list != NULL);
68369 :
68370 : // DQ (5/11/2006): Set the parent to avoid having NULL pointers
68371 : p_argument_list->set_parent(this);
68372 : #else
68373 19092 : post_construction_initialization();
68374 : #endif
68375 :
68376 19092 : SgTypePtrList::iterator p = ft->get_arguments().begin();
68377 : // printf ("PartialFunctionType->get_arguments().size() = %" PRIuPTR " \n",ft->get_arguments().size());
68378 48547 : while(p != ft->get_arguments().end())
68379 : {
68380 : // printf (" function argument = %p = %s \n",*p,(*p)->sage_class_name());
68381 29455 : append_argument((*p));
68382 29455 : p++;
68383 : }
68384 19092 : }
68385 :
68386 : void
68387 269489 : SgFunctionType::post_construction_initialization ()
68388 : {
68389 269489 : p_orig_return_type = NULL;
68390 :
68391 : // DQ (12/6/2012): Added assertion.
68392 269489 : ROSE_ASSERT(p_argument_list == NULL);
68393 :
68394 269489 : p_argument_list = new SgFunctionParameterTypeList();
68395 269489 : ROSE_ASSERT(p_argument_list != NULL);
68396 :
68397 : // DQ (6/25/2006): Commented out to allow File I/O to work, I don't understand why it is required!
68398 : // DQ (5/11/2006): Set the parent to avoid having NULL pointers
68399 269489 : p_argument_list->set_parent(this);
68400 :
68401 : // DQ (6/22/2006): Initialize the orig_return_type
68402 269489 : ROSE_ASSERT(p_return_type != NULL);
68403 269489 : set_orig_return_type(p_return_type);
68404 269489 : ROSE_ASSERT(p_orig_return_type != NULL);
68405 :
68406 269489 : }
68407 :
68408 : const SgTypePtrList &
68409 22388 : SgFunctionType::get_arguments() const
68410 22388 : { return p_argument_list->get_arguments(); }
68411 :
68412 : SgTypePtrList &
68413 120758 : SgFunctionType::get_arguments()
68414 120758 : { return p_argument_list->get_arguments(); }
68415 :
68416 : void
68417 29455 : SgFunctionType::append_argument( SgType* what)
68418 : {
68419 29455 : p_argument_list->append_argument(what);
68420 29455 : }
68421 :
68422 : void
68423 0 : SgFunctionType::insert_argument(const SgTypePtrList::iterator& where, SgType* what)
68424 : {
68425 0 : p_argument_list->insert_argument(where,what);
68426 0 : }
68427 :
68428 : SgName
68429 3830770 : SgFunctionType::get_mangled(SgType* ret_type, SgFunctionParameterTypeList * typeList)
68430 : {
68431 : // Note that this is a static member function.
68432 : #if 0
68433 : printf ("In SgFunctionType::get_mangled(SgType*,SgFunctionParameterTypeList*): TOP \n");
68434 : #endif
68435 :
68436 : // process argument type
68437 7661540 : SgName arg_names;
68438 3830770 : if (typeList != NULL)
68439 : {
68440 3830770 : const SgTypePtrList & args = typeList->get_arguments ();
68441 3830770 : arg_names = mangleTypes (args.begin (), args.end ());
68442 : }
68443 :
68444 : #if 0
68445 : printf ("In SgFunctionType::get_mangled(SgType*,SgFunctionParameterTypeList*): arg_names = %s \n",arg_names.str());
68446 : #endif
68447 :
68448 : #if 0
68449 : printf ("In SgFunctionType::get_mangled(SgType*,SgFunctionParameterTypeList*): ret_type = %p (%s) \n",ret_type, ret_type->class_name().c_str());
68450 : #endif
68451 :
68452 : // process return type
68453 3830770 : ROSE_ASSERT (ret_type != NULL);
68454 3830770 : SgName ret_name = ret_type->get_mangled();
68455 :
68456 : #if 0
68457 : printf ("In SgFunctionType::get_mangled(SgType*,SgFunctionParameterTypeList*): ret_name = %s \n",ret_name.str());
68458 : #endif
68459 :
68460 : // Build complete mangled name
68461 3830770 : SgName mangled_name;
68462 3830770 : mangled_name << "_Fb_" // begin function signature
68463 7661540 : << ret_name.str () // return type
68464 7661540 : << "_Gb_" // argument list begin
68465 7661540 : << arg_names.str () // argument types
68466 7661540 : << "_Fe_"; // end function signature
68467 :
68468 : #if 0
68469 : printf ("Leaving SgFunctionType::get_mangled(SgType*,SgFunctionParameterTypeList*): mangled_name = %s \n",mangled_name.str());
68470 : #endif
68471 :
68472 7661540 : return mangled_name;
68473 : }
68474 :
68475 : // RV (1/31/2006): Changed the form of the mangled name.
68476 : SgName
68477 1506770 : SgFunctionType::get_mangled (void) const
68478 : {
68479 1506770 : ROSE_ASSERT(this != NULL);
68480 :
68481 : // TV (04/19/2011): I outlined the mangling of function type in a static function to avoid
68482 : // building of a function type in 'SageBuilder::buildFunctionType' (This was used
68483 : // to do a search in 'globalFunctionTypeTable')
68484 : // return get_mangled(get_return_type(), get_argument_list());
68485 :
68486 1506770 : SgName name = get_mangled(get_return_type(), get_argument_list());
68487 :
68488 : #if 0
68489 : printf ("In SgFunctionType::get_mangled(void): name = %s \n",name.str());
68490 : #endif
68491 :
68492 1506770 : return name;
68493 : }
68494 :
68495 :
68496 : #if 0
68497 : // virtual SgName SgFunctionType::get_mangled_name ( SgUnparse_Info & info );
68498 : SgName
68499 : SgFunctionType::get_mangled_name(SgUnparse_Info& info)
68500 : {
68501 : SgName rtmp;
68502 : // SgDeclarationStatement *dstmt = info.get_decl_stmt();
68503 : SgFunctionDeclaration *dstmt = isSgFunctionDeclaration(info.get_decl_stmt());
68504 : ROSE_ASSERT (dstmt != NULL);
68505 : SgName fname = info.get_name();
68506 :
68507 : // int len = strlen(fname.str());
68508 : // SgName tmp(fname);
68509 : // char *opstr = "operator";
68510 : // char *newstr = "new";
68511 : // char *delstr = "delete";
68512 : // int m = strlen(opstr);
68513 :
68514 : #if 0
68515 : printf ("In SgFunctionType::get_mangled_name(): fname = %s \n",fname.str());
68516 : printf (" unused function qualified name = %s \n",dstmt->get_qualified_name().str());
68517 : #endif
68518 :
68519 : #if 0
68520 : // DQ (4/28/2005): These should be false since this is not a member function
68521 : ROSE_ASSERT(dstmt->get_specialFunctionModifier().isConstructor() == false);
68522 : ROSE_ASSERT(dstmt->get_specialFunctionModifier().isConversion() == false);
68523 : ROSE_ASSERT(dstmt->get_specialFunctionModifier().isDestructor() == false);
68524 :
68525 : // DQ (4/29/2005): This is all that we need since non-member function can never be
68526 : // constructor, destructors, or conversion operators.
68527 : rtmp = mangledNameSupport(fname,info);
68528 : #else
68529 : if (dstmt->get_specialFunctionModifier().isConstructor())
68530 : rtmp << "__ct";
68531 : else
68532 : if (dstmt->get_specialFunctionModifier().isDestructor()) rtmp << "__dt";
68533 : else
68534 : if (dstmt->get_specialFunctionModifier().isConversion())
68535 : {
68536 : rtmp << "__conversion__";
68537 : // rtmp = mangledNameSupport(fname,info);
68538 : }
68539 : else
68540 : {
68541 : // These are just normal functions
68542 : // ROSE_ASSERT (dstmt->get_specialFunctionModifier().isOperator());
68543 : rtmp = mangledNameSupport(fname,info);
68544 : }
68545 : #endif
68546 :
68547 : string mangledName = rtmp.str();
68548 : ROSE_ASSERT (mangledName.find("<") == string::npos);
68549 : ROSE_ASSERT (mangledName.find(">") == string::npos);
68550 :
68551 : ROSE_ASSERT(mangledName.find('`') == string::npos);
68552 : ROSE_ASSERT(mangledName.find('~') == string::npos);
68553 : ROSE_ASSERT(mangledName.find('!') == string::npos);
68554 : ROSE_ASSERT(mangledName.find('@') == string::npos);
68555 : ROSE_ASSERT(mangledName.find('#') == string::npos);
68556 : ROSE_ASSERT(mangledName.find('$') == string::npos);
68557 : ROSE_ASSERT(mangledName.find('%') == string::npos);
68558 : ROSE_ASSERT(mangledName.find('^') == string::npos);
68559 : ROSE_ASSERT(mangledName.find('&') == string::npos);
68560 : ROSE_ASSERT(mangledName.find('*') == string::npos);
68561 : ROSE_ASSERT(mangledName.find('(') == string::npos);
68562 : ROSE_ASSERT(mangledName.find(')') == string::npos);
68563 : ROSE_ASSERT(mangledName.find('-') == string::npos);
68564 : ROSE_ASSERT(mangledName.find('+') == string::npos);
68565 : ROSE_ASSERT(mangledName.find('=') == string::npos);
68566 : ROSE_ASSERT(mangledName.find('{') == string::npos);
68567 : ROSE_ASSERT(mangledName.find('}') == string::npos);
68568 : ROSE_ASSERT(mangledName.find('[') == string::npos);
68569 : ROSE_ASSERT(mangledName.find(']') == string::npos);
68570 : ROSE_ASSERT(mangledName.find('|') == string::npos);
68571 : ROSE_ASSERT(mangledName.find('\\') == string::npos);
68572 : ROSE_ASSERT(mangledName.find(':') == string::npos);
68573 : ROSE_ASSERT(mangledName.find(';') == string::npos);
68574 : ROSE_ASSERT(mangledName.find('\"') == string::npos);
68575 : ROSE_ASSERT(mangledName.find('\'') == string::npos);
68576 : ROSE_ASSERT(mangledName.find('?') == string::npos);
68577 : ROSE_ASSERT(mangledName.find('.') == string::npos);
68578 : ROSE_ASSERT(mangledName.find('/') == string::npos);
68579 : ROSE_ASSERT(mangledName.find(',') == string::npos);
68580 :
68581 : // These are the most common cases that fail
68582 : ROSE_ASSERT(mangledName.find('<') == string::npos);
68583 : ROSE_ASSERT(mangledName.find('>') == string::npos);
68584 :
68585 : #if 0
68586 : if (dstmt->get_specialFunctionModifier().isConstructor())
68587 : rtmp << "__ct";
68588 : else
68589 : if (dstmt->get_specialFunctionModifier().isDestructor())
68590 : rtmp << "__dt";
68591 : else
68592 : #if 1
68593 : {
68594 : rtmp = mangledNameSupport(fname,info);
68595 : }
68596 : #else
68597 : if (len > 0 && strncmp(fname.str(),opstr,m) == 0)
68598 : {
68599 : if (fname.str()[m]==' ')
68600 : {
68601 : // DQ (4/27/2005): "m+2" should be "m+1"
68602 : if (strncmp(&(fname.str()[m+1]),newstr,strlen(newstr)) == 0)
68603 : {
68604 : // DQ (4/27/2005): Added support for array new
68605 : int newStringLength = strlen(newstr);
68606 : int parenStart = m+1+newStringLength;
68607 : if (len > parenStart && strncmp(&(fname.str()[parenStart]),"[]",2) == 0)
68608 : rtmp << "__na";
68609 : else
68610 : rtmp << "__nw";
68611 : }
68612 : else
68613 : {
68614 : // DQ (4/27/2005): Added support for array delete
68615 : if (strncmp(&(fname.str()[m+1]),delstr,strlen(delstr)) == 0)
68616 : {
68617 : int deleteStringLength = strlen(delstr);
68618 : int parenStart = m+1+deleteStringLength;
68619 : if (len > parenStart && strncmp(&(fname.str()[parenStart]),"[]",2) == 0)
68620 : rtmp << "__da";
68621 : else
68622 : rtmp << "__dl";
68623 : }
68624 : else
68625 : {
68626 : // DQ (4/27/2005): Not clear where this is used (unless it is used in casting operators)!
68627 : rtmp << "__op" << get_return_type()->get_mangled(info).str();
68628 : }
68629 : }
68630 : }
68631 : else
68632 : {
68633 : // real operator
68634 : SgName opname=&(fname.str()[m]);
68635 : if(opname==SgName("->")) rtmp << "__rf";
68636 : else if (opname==SgName("->*")) rtmp << "__rm";
68637 : else if (opname==SgName("==")) rtmp << "__eq";
68638 : else if (opname==SgName("<")) rtmp << "__lt";
68639 : else if (opname==SgName(">")) rtmp << "__gt";
68640 : else if (opname==SgName("!=")) rtmp << "__ne";
68641 : else if (opname==SgName("<=")) rtmp << "__le";
68642 : else if (opname==SgName(">=")) rtmp << "__ge";
68643 : else if (opname==SgName("+")) rtmp << "__pl";
68644 : else if (opname==SgName("-")) rtmp << "__mi";
68645 : else if (opname==SgName("*")) rtmp << "__ml";
68646 : else if (opname==SgName("/")) rtmp << "__dv";
68647 : else if (opname==SgName("%")) rtmp << "__md";
68648 : else if (opname==SgName("&&")) rtmp << "__aa";
68649 : else if (opname==SgName("!")) rtmp << "__nt";
68650 : else if (opname==SgName("||")) rtmp << "__oo";
68651 : else if (opname==SgName("^")) rtmp << "__er";
68652 : else if (opname==SgName("&")) rtmp << "__ad";
68653 : else if (opname==SgName("|")) rtmp << "__or";
68654 : else if (opname==SgName(",")) rtmp << "__cm";
68655 : else if (opname==SgName("<<")) rtmp << "__ls";
68656 : else if (opname==SgName(">>")) rtmp << "__rs";
68657 : else if (opname==SgName("--")) rtmp << "__mm";
68658 : else if (opname==SgName("++")) rtmp << "__pp";
68659 : else if (opname==SgName("~")) rtmp << "__co";
68660 : else if (opname==SgName("=")) rtmp << "__as";
68661 : else if (opname==SgName("+=")) rtmp << "__apl";
68662 : else if (opname==SgName("-=")) rtmp << "__ami";
68663 : else if (opname==SgName("&=")) rtmp << "__aad";
68664 : else if (opname==SgName("|=")) rtmp << "__aor";
68665 : else if (opname==SgName("*=")) rtmp << "__amu";
68666 : else if (opname==SgName("/=")) rtmp << "__adv";
68667 : else if (opname==SgName("%=")) rtmp << "__amd";
68668 : else if (opname==SgName("^=")) rtmp << "__aer";
68669 : else if (opname==SgName("<<=")) rtmp << "__als";
68670 : else if (opname==SgName(">>=")) rtmp << "__ars";
68671 : else if (opname==SgName("()")) rtmp << "__cl";
68672 : else if (opname==SgName("[]")) rtmp << "__xi";
68673 : else
68674 : {
68675 : printf ("In SgFunctionType::get_mangled_name(): This case should never be reached (fname = %s) \n",fname.str());
68676 : ROSE_ASSERT(false);
68677 : }
68678 : }
68679 : }
68680 : else
68681 : rtmp << fname.str();
68682 : #endif
68683 : #endif
68684 :
68685 : return rtmp;
68686 : }
68687 : #endif
68688 :
68689 : #if 0
68690 : // Old code
68691 :
68692 : // this routine can do 2 things,
68693 : // mangle a type - without funcname and class name(if member function)
68694 : // mangle a complete function declaration with name and class name
68695 : SgName
68696 : SgFunctionType::get_mangled(SgUnparse_Info & info)
68697 : {
68698 : SgName tmp;
68699 :
68700 : // printf ("In SgFunctionType::get_mangled(SgUnparse_Info&) info.PrintName() = %s \n",(info.PrintName() == true) ? "true" : "false");
68701 :
68702 : /* should have a name to start with */
68703 : if (info.PrintName())
68704 : {
68705 : // DQ (6/23/2005): This path is taken for constructors, destructors and conversion operators (I think!)
68706 : // SgName name = get_mangled_name(info);
68707 : // printf ("In SgFunctionType::get_mangled(SgUnparse_Info&): (assuming info.PrintName() == true): name = %s \n",name.str());
68708 : // tmp << get_mangled_name(info).str();
68709 : tmp << name.str();
68710 : }
68711 :
68712 : tmp << "__";
68713 : tmp << "F";
68714 :
68715 : /* process argument type */
68716 : SgTypePtrList::iterator p = get_arguments().begin();
68717 : while(p != get_arguments().end())
68718 : {
68719 : tmp << (*p)->get_mangled(info).str();
68720 :
68721 : // DQ (5/2/2005): Added to handle function arguments which are templates
68722 : tmp = fixupTemplateNameForMangledNameSupport(tmp);
68723 :
68724 : p++;
68725 : }
68726 :
68727 : /* process return type */
68728 : SgName returnTypeName = get_return_type()->get_mangled(info);
68729 : // tmp << "_" << get_return_type()->get_mangled(info).str();
68730 : tmp << "_" << returnTypeName.str();
68731 :
68732 : // DQ (5/2/2005): Added to handle function arguments which are templates
68733 : tmp = fixupTemplateNameForMangledNameSupport(tmp);
68734 :
68735 : #if 0
68736 : printf ("########## In SgFunctionType::get_mangled(): tmp = %s (returnTypeName = %s is a %s) ########## \n",
68737 : tmp.str(),returnTypeName.str(),get_return_type()->sage_class_name());
68738 : // ROSE_ASSERT(false);
68739 : #endif
68740 :
68741 : return tmp;
68742 : }
68743 : #endif
68744 :
68745 : //! \deprecated by RV (1/31/2006)
68746 : SgName
68747 0 : SgFunctionType::get_mangled_type ()
68748 : {
68749 0 : ROSE_ASSERT(this != NULL);
68750 0 : return get_mangled();
68751 : }
68752 :
68753 : #if 0
68754 : SgName
68755 : SgFunctionType::get_mangled_type ()
68756 : {
68757 : SgUnparse_Info info;
68758 :
68759 : // DQ (6/23/2005): Get the name (and qualified name) of the type into the mangled name
68760 : // info.set_name();
68761 : // printf ("In SgFunctionType::get_mangled_type(): calling info.set_PrintName() \n");
68762 : // info.set_PrintName();
68763 : // ROSE_ASSERT(info.PrintName() == true);
68764 :
68765 : // return get_mangled (SgNO_UNPARSE_INFO);
68766 : return get_mangled (info);
68767 : }
68768 : #endif
68769 :
68770 :
68771 : // SgFunctionType* SgFunctionType::mkAnotherType(SgType *);
68772 : // void sym_print(ostream& os);
68773 :
68774 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
68775 : SgSymbol*
68776 0 : SgFunctionType::get_symbol_from_symbol_table() const
68777 : {
68778 0 : return SgNode::get_globalFunctionTypeTable()->get_function_type_table()->find(this);
68779 : }
68780 :
68781 :
68782 :
68783 : // End of memberFunctionString
68784 : // Start of memberFunctionString
68785 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
68786 :
68787 : // *** COMMON CODE SECTION BEGINS HERE ***
68788 :
68789 : #if 0
68790 : int
68791 : SgFunctionType::getVariant() const
68792 : {
68793 : // This function is used in ROSE while "variant()" is used in SAGE
68794 : assert(this != NULL);
68795 : return variant();
68796 : }
68797 : #endif
68798 :
68799 : // This function is used in ROSE in treeTraversal code
68800 : // eventually replaces getVariant() and variant()
68801 : // though after variant() has been removed for a while we will
68802 : // want to change the name of variantT() back to variant()
68803 : // (since the "T" was ment to stand for temporary).
68804 : // When this happens the variantT() will be depricated.
68805 : VariantT
68806 1787040000 : SgFunctionType::variantT() const
68807 : {
68808 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
68809 1787040000 : ROSE_ASSERT(this != NULL);
68810 1787040000 : return V_SgFunctionType;
68811 : }
68812 :
68813 : #if 0
68814 : int
68815 : SgFunctionType::variant() const
68816 : {
68817 : // This function is used in SAGE
68818 : ROSE_ASSERT(this != NULL);
68819 : return T_FUNCTION;
68820 : }
68821 : #endif
68822 :
68823 : ROSE_DLL_API const char*
68824 2583 : SgFunctionType::sage_class_name() const
68825 : {
68826 2583 : ROSE_ASSERT(this != NULL);
68827 2583 : return "SgFunctionType";
68828 : }
68829 :
68830 : std::string
68831 215153 : SgFunctionType::class_name() const
68832 : {
68833 215153 : ROSE_ASSERT(this != NULL);
68834 215153 : return "SgFunctionType";
68835 : }
68836 :
68837 : // DQ (11/26/2005): Support for visitor pattern mechanims
68838 : // (inferior to ROSE traversal mechanism, experimental).
68839 : void
68840 382485 : SgFunctionType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
68841 : {
68842 382485 : ROSE_ASSERT(this != NULL);
68843 382485 : visitor.visit(this);
68844 382485 : }
68845 :
68846 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
68847 0 : void SgFunctionType::accept (ROSE_VisitorPattern & visitor) {
68848 0 : ROSE_ASSERT(this != NULL);
68849 0 : visitor.visit(this);
68850 0 : }
68851 :
68852 : SgFunctionType*
68853 0 : SgFunctionType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
68854 : {
68855 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
68856 : // This function is currently only supported for the AST used the represent Binary executables.
68857 : if (0 /* isSgAsmNode(this) != NULL */)
68858 : {
68859 : // Support for regex specification.
68860 : std::string prefixCode = "REGEX:";
68861 : addNewAttribute(prefixCode + s,a);
68862 : }
68863 : #endif
68864 :
68865 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
68866 0 : return this;
68867 : }
68868 :
68869 : // *** COMMON CODE SECTION ENDS HERE ***
68870 :
68871 :
68872 : // End of memberFunctionString
68873 : // Start of memberFunctionString
68874 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
68875 :
68876 :
68877 : #if 0
68878 : //! Error checking support
68879 : /*! Verifies the following:
68880 : - working getVariant() member function
68881 : - calls base class's error() member function
68882 : Every class has one of these functions.
68883 : */
68884 : bool
68885 : SgFunctionType::error()
68886 : {
68887 : // Put error checking here
68888 :
68889 : ROSE_ASSERT (this != NULL);
68890 : if (getVariant() != T_FUNCTION)
68891 : {
68892 : printf ("Error in SgFunctionType::error(): SgFunctionType object has a %s variant \n",
68893 : Cxx_GrammarTerminalNames[getVariant()].name);
68894 : // printf ("Error in SgFunctionType::error() \n");
68895 : ROSE_ABORT();
68896 : }
68897 :
68898 : ROSE_ASSERT (getVariant() == T_FUNCTION);
68899 : return SgType::error();
68900 : }
68901 : #endif
68902 :
68903 :
68904 :
68905 : // End of memberFunctionString
68906 :
68907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
68908 :
68909 58608500 : SgFunctionType* isSgFunctionType ( SgNode* inputDerivedClassPointer )
68910 : {
68911 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
68912 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
68913 : // So to fix this we return NULL directly when the input is NULL and avoid the
68914 : // dynamic_cast in this case. This is likely a performance improvement as well.
68915 : // return dynamic_cast<SgFunctionType*>(inputDerivedClassPointer);
68916 : // Milind Chabbi (8/28/2013): isSgFunctionType uses table-driven castability instead of c++ default dynamic_cast
68917 : // this improves the running time performance by 10-20%.
68918 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionType*>(inputDerivedClassPointer);
68919 58608500 : return IS_SgFunctionType_FAST_MACRO(inputDerivedClassPointer);
68920 : }
68921 :
68922 : // DQ (11/8/2003): Added version of functions taking const pointer
68923 0 : const SgFunctionType* isSgFunctionType ( const SgNode* inputDerivedClassPointer )
68924 : {
68925 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
68926 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
68927 : // So to fix this we return NULL directly when the input is NULL and avoid the
68928 : // dynamic_cast in this case. This is likely a performance improvement as well.
68929 : // return dynamic_cast<const SgFunctionType*>(inputDerivedClassPointer);
68930 : // Milind Chabbi (8/28/2013): isSgFunctionType uses table-driven castability instead of c++ default dynamic_cast
68931 : // this improves the running time performance by 10-20%.
68932 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionType*>(inputDerivedClassPointer);
68933 0 : return IS_SgFunctionType_FAST_MACRO(inputDerivedClassPointer);
68934 : }
68935 :
68936 :
68937 :
68938 : /* #line 68939 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
68939 :
68940 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
68941 :
68942 : /**
68943 : \brief Generated destructor
68944 :
68945 : This destructor is automatically generated (by ROSETTA). This destructor
68946 : only frees memory of data members associated with the parts of the current IR node which
68947 : are NOT traversed. Those data members that are part of a traversal can be freed using
68948 : a traversal (calling this destructor on all children in a post-order traversal). Such
68949 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
68950 :
68951 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
68952 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
68953 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
68954 :
68955 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
68956 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
68957 : pointers are not yet implemented to call delete on eash pointer in the container.
68958 : (This could be done by derivation from the STL containers to define containers that
68959 : automatically deleted their members.)
68960 :
68961 : */
68962 36024 : SgFunctionType::~SgFunctionType () {
68963 29725 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
68964 :
68965 29725 : if (p_argument_list && p_argument_list->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_argument_list; }
68966 :
68967 : // case: not a listType for return_type
68968 29725 : p_return_type = NULL; // non list case
68969 : // case: not a listType for has_ellipses
68970 29725 : p_has_ellipses = true; // non list case
68971 : // case: not a listType for orig_return_type
68972 29725 : p_orig_return_type = NULL; // non list case
68973 : // case: not a listType for argument_list
68974 29725 : p_argument_list = NULL; // non list case
68975 :
68976 : }
68977 :
68978 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
68979 36024 : }
68980 :
68981 :
68982 : /* #line 68983 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
68983 :
68984 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
68985 :
68986 : // Generated constructor
68987 250397 : SgFunctionType::SgFunctionType ( SgType* return_type, bool has_ellipses )
68988 250397 : : SgType()
68989 : {
68990 : #ifdef DEBUG
68991 : // printf ("In SgFunctionType::SgFunctionType (SgType* return_type, bool has_ellipses) sage_class_name() = %s \n",sage_class_name());
68992 : #endif
68993 : #if 0
68994 : // debugging information!
68995 : printf ("In SgFunctionType::SgFunctionType (SgType* return_type, bool has_ellipses): this = %p = %s \n",this,this->class_name().c_str());
68996 : #endif
68997 :
68998 250397 : p_return_type = return_type;
68999 250397 : p_has_ellipses = has_ellipses;
69000 250397 : p_orig_return_type = NULL;
69001 250397 : p_argument_list = NULL;
69002 :
69003 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
69004 :
69005 : #if 0
69006 : // DQ (7/30/2014): Call a virtual function.
69007 : std::string s = this->class_name();
69008 : #endif
69009 :
69010 : // Test the variant virtual function
69011 : // assert(T_FUNCTION == variant());
69012 250397 : assert(T_FUNCTION == this->variant());
69013 250397 : ROSE_ASSERT(T_FUNCTION == (int)(this->variantT()));
69014 250397 : post_construction_initialization();
69015 :
69016 : // Test the isSgFunctionType() function since it has been problematic
69017 250397 : assert(isSgFunctionType(this) != NULL);
69018 250397 : }
69019 :
69020 : // Generated constructor (all data members)
69021 :
69022 : /* #line 69023 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
69023 :
69024 :
69025 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
69026 :
69027 :
69028 : // ********************************************************
69029 : // member functions common across all array grammar objects
69030 : // ********************************************************
69031 :
69032 :
69033 :
69034 : /* #line 69035 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
69035 :
69036 :
69037 :
69038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
69039 :
69040 : // ********************************************************
69041 : // member functions specific to each node in the grammar
69042 : // ********************************************************
69043 :
69044 :
69045 : /* #line 69046 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
69046 :
69047 : // Start of memberFunctionString
69048 : /* #line 6695 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
69049 :
69050 : // SgMemberFunctionType* SgMemberFunctionType::createType(SgPartialFunctionType* ft)
69051 : SgMemberFunctionType*
69052 19092 : SgMemberFunctionType::createType(SgPartialFunctionType* ft, SgExpression* optional_fortran_type_kind)
69053 : {
69054 19092 : ROSE_ASSERT(ft != NULL);
69055 : // printf ("In SgMemberFunctionType::createType(SgPartialFunctionType* ft): calling ft->get_mangled_type \n");
69056 : // SgName nname = ft->get_mangled_type();
69057 :
69058 : // DQ (10/4/2010): I don't think this type can have a fortran type kind parameter.
69059 19092 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
69060 :
69061 : #if 0
69062 : printf ("In SgMemberFunctionType::createType() (CREATE_TYPE_FOR_MEMBER_FUNCTION_TYPE) \n");
69063 : #endif
69064 :
69065 : #if 1
69066 : // DQ (3/29/2006):
69067 : // Simplify this function to not use the function type table, thus SgFunctionType nodes are not
69068 : // shared. During function creation. As a result we don't have to call the functions to mangle
69069 : // the names of things (which traverse parents to compute scopes and can be a problem if called
69070 : // before the parents are set, done in post processing of AST). However, this design requires
69071 : // that the funtion type symbol table be constructed after the AST is build (and parent pointers
69072 : // are set). If functions are created then the function type table must also be updated.
69073 19092 : SgMemberFunctionType* theType = new SgMemberFunctionType(ft);
69074 :
69075 : // DQ (6/22/2006): Since we mangle the return type into the mangled function as part of building
69076 : // the symbol table we don't have to worry about sharing function types that would have different
69077 : // return types. Here we set the orig_return_type stored explicitly (it seems it is always the
69078 : // same as the return_type.
69079 19092 : ROSE_ASSERT (ft->get_return_type() != NULL);
69080 19092 : theType->set_orig_return_type(ft->get_return_type());
69081 : #else
69082 : // DQ (3/29/2006): experiment with generating a unique name for the function type table lookup
69083 : // This will avoid calling the get_mangled_type() function durring the construction
69084 : // of the AST. Because the name will be unique there will be no collision in the
69085 : // function type symbol table. The function type symbol tabel will then have to
69086 : // be rebuilt after the AST is build (in a post-processing phase).
69087 : static int functionCounter = 0;
69088 : string baseName = "memberfunction_";
69089 : string mangleName = baseName + Rose::StringUtility::numberToString(functionCounter++);
69090 : SgName nname = mangleName;
69091 :
69092 : #if 0
69093 : SgName nname = "NOT YET SUPPORTED"; // ft->get_mangled_type();
69094 : printf ("WARNING: Name mangling not yet suppported in SAGE 3! (required in SgFunctionType::createType()) \n");
69095 : #endif
69096 :
69097 : // check the function type table
69098 : // DQ (1/31/2006): Modified to build all types in the memory pools
69099 : // SgType *t = Sgfunc_type_table.lookup_function_type(nname);
69100 : ROSE_ASSERT(get_globalFunctionTypeTable() != NULL);
69101 : SgType *t = get_globalFunctionTypeTable()->lookup_function_type(nname);
69102 : SgMemberFunctionType* theType = isSgMemberFunctionType(t);
69103 : // if (!theType)
69104 : if (theType == NULL)
69105 : {
69106 : theType = new SgMemberFunctionType(ft);
69107 : ROSE_ASSERT(theType != NULL);
69108 : // printf ("In SgMemberFunctionType::createType(): insert function type into symbol table: nname = %s \n",nname.str());
69109 : // Sgfunc_type_table.insert_function_type(nname, theType);
69110 : ROSE_ASSERT(get_globalFunctionTypeTable() != NULL);
69111 : get_globalFunctionTypeTable()->insert_function_type(nname, theType);
69112 : }
69113 : else
69114 : {
69115 : // printf ("In SgMemberFunctionType::createType(): function type found in symbol table: nname = %s \n",nname.str());
69116 : theType->set_orig_return_type(ft->get_return_type());
69117 : }
69118 :
69119 : // DQ: commented out the delete of the input structure (poor design, I think)
69120 : // delete ft;
69121 : #endif
69122 :
69123 19092 : ROSE_ASSERT(theType != NULL);
69124 19092 : return theType;
69125 : }
69126 :
69127 :
69128 :
69129 : // End of memberFunctionString
69130 : // Start of memberFunctionString
69131 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
69132 :
69133 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
69134 :
69135 : SgType*
69136 76101 : SgMemberFunctionType::get_class_type () const
69137 : {
69138 76101 : ROSE_ASSERT (this != NULL);
69139 :
69140 : #if 0
69141 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
69142 : // used to trigger marking transformations for the token-based unparsing.
69143 : printf ("SgMemberFunctionType::get_class_type = %p = %s \n",this,this->class_name().c_str());
69144 : #endif
69145 :
69146 76101 : return p_class_type;
69147 : }
69148 :
69149 : void
69150 0 : SgMemberFunctionType::set_class_type ( SgType* class_type )
69151 : {
69152 0 : ROSE_ASSERT (this != NULL);
69153 :
69154 : #if 0
69155 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
69156 : // used to trigger marking transformations for the token-based unparsing.
69157 : printf ("SgMemberFunctionType::set_class_type = %p = %s \n",this,this->class_name().c_str());
69158 : #endif
69159 :
69160 0 : set_isModified(true);
69161 :
69162 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
69163 : if (p_class_type != NULL && class_type != NULL && p_class_type != class_type)
69164 : {
69165 : printf ("Warning: class_type = %p overwriting valid pointer p_class_type = %p \n",class_type,p_class_type);
69166 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
69167 : printf ("Error fails assertion (p_class_type != NULL && class_type != NULL && p_class_type != class_type) is false\n");
69168 : ROSE_ASSERT(false);
69169 : #endif
69170 : }
69171 : #endif
69172 0 : p_class_type = class_type;
69173 0 : }
69174 :
69175 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
69176 :
69177 :
69178 : // End of memberFunctionString
69179 : // Start of memberFunctionString
69180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
69181 :
69182 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
69183 :
69184 : unsigned int
69185 0 : SgMemberFunctionType::get_mfunc_specifier () const
69186 : {
69187 0 : ROSE_ASSERT (this != NULL);
69188 :
69189 : #if 0
69190 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
69191 : // used to trigger marking transformations for the token-based unparsing.
69192 : printf ("SgMemberFunctionType::get_mfunc_specifier = %p = %s \n",this,this->class_name().c_str());
69193 : #endif
69194 :
69195 0 : return p_mfunc_specifier;
69196 : }
69197 :
69198 : void
69199 0 : SgMemberFunctionType::set_mfunc_specifier ( unsigned int mfunc_specifier )
69200 : {
69201 0 : ROSE_ASSERT (this != NULL);
69202 :
69203 : #if 0
69204 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
69205 : // used to trigger marking transformations for the token-based unparsing.
69206 : printf ("SgMemberFunctionType::set_mfunc_specifier = %p = %s \n",this,this->class_name().c_str());
69207 : #endif
69208 :
69209 0 : set_isModified(true);
69210 :
69211 0 : p_mfunc_specifier = mfunc_specifier;
69212 0 : }
69213 :
69214 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
69215 :
69216 :
69217 : // End of memberFunctionString
69218 : // Start of memberFunctionString
69219 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
69220 :
69221 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
69222 :
69223 : unsigned int
69224 0 : SgMemberFunctionType::get_ref_qualifiers () const
69225 : {
69226 0 : ROSE_ASSERT (this != NULL);
69227 :
69228 : #if 0
69229 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
69230 : // used to trigger marking transformations for the token-based unparsing.
69231 : printf ("SgMemberFunctionType::get_ref_qualifiers = %p = %s \n",this,this->class_name().c_str());
69232 : #endif
69233 :
69234 0 : return p_ref_qualifiers;
69235 : }
69236 :
69237 : void
69238 0 : SgMemberFunctionType::set_ref_qualifiers ( unsigned int ref_qualifiers )
69239 : {
69240 0 : ROSE_ASSERT (this != NULL);
69241 :
69242 : #if 0
69243 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
69244 : // used to trigger marking transformations for the token-based unparsing.
69245 : printf ("SgMemberFunctionType::set_ref_qualifiers = %p = %s \n",this,this->class_name().c_str());
69246 : #endif
69247 :
69248 0 : set_isModified(true);
69249 :
69250 0 : p_ref_qualifiers = ref_qualifiers;
69251 0 : }
69252 :
69253 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
69254 :
69255 :
69256 : // End of memberFunctionString
69257 : // Start of memberFunctionString
69258 : /* #line 5211 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
69259 :
69260 :
69261 19092 : SgMemberFunctionType::SgMemberFunctionType ( SgPartialFunctionType* ft )
69262 19092 : : SgFunctionType(ft)
69263 : {
69264 19092 : p_class_type = ft->p_class_type ;
69265 19092 : p_mfunc_specifier = ft->p_mfunc_specifier;
69266 19092 : }
69267 :
69268 : void
69269 19092 : SgMemberFunctionType::post_construction_initialization()
69270 : {
69271 : // DQ (3/8/2012): We want to avoid resetting the data members (just set in the SgMemberFunctionType constructor).
69272 : #if 0
69273 : printf ("In SgMemberFunctionType::post_construction_initialization(): avoid resetting the data members. \n");
69274 : #endif
69275 : // p_class_type =0;
69276 :
69277 : // DQ (3/8/2012): We can't assert that this is true (likely because of how SgPartialFunctionType is used to build non-memb4r function types.
69278 : // ROSE_ASSERT(p_class_type != NULL);
69279 :
69280 : // p_mfunc_specifier = 0;
69281 :
69282 : // DQ (3/8/2012): Since we are not including support for restrict in the function type, don't allow it to be set (basic testing).
69283 : // If we discover that we need this then we will have to re-enable restrict support, else we can eliminate the e_restrict value
69284 : // in the enum type (either way this will be an improvement).
69285 : // ROSE_ASSERT((e_restrict && p_mfunc_specifier) == 0);
69286 :
69287 : // DQ (3/10/2012): If this is non-zero then the SgPartialFunctionType should have somethin set internally.
69288 19092 : if (p_mfunc_specifier != 0)
69289 : {
69290 : #if 0
69291 : printf ("In SgMemberFunctionType::post_construction_initialization(): p_mfunc_specifier = %u isConstFunc() = %s \n",p_mfunc_specifier,isConstFunc() ? "true" : "false");
69292 : printf ("In SgMemberFunctionType::post_construction_initialization(): p_mfunc_specifier = %u isVolatileFunc() = %s \n",p_mfunc_specifier,isVolatileFunc() ? "true" : "false");
69293 : printf ("In SgMemberFunctionType::post_construction_initialization(): p_mfunc_specifier = %u isRestrictFunc() = %s \n",p_mfunc_specifier,isRestrictFunc() ? "true" : "false");
69294 : #endif
69295 : // DQ (1/9/2020): Adding support for reference qualification.
69296 : // ROSE_ASSERT(partialFunctionType->isConstFunc() == true || partialFunctionType->isVolatileFunc() == true);
69297 : // ROSE_ASSERT(isConstFunc() == true || isVolatileFunc() == true || isRestrictFunc() == true);
69298 : // ROSE_ASSERT( (isConstFunc() == true) || (isVolatileFunc() == true) || (isRestrictFunc() == true) );
69299 4916 : ROSE_ASSERT( (isConstFunc() == true) || (isVolatileFunc() == true) || (isRestrictFunc() == true) || (isLvalueReferenceFunc() == true) || (isRvalueReferenceFunc() == true));
69300 : }
69301 19092 : }
69302 :
69303 : // static SgMemberFunctionType* createType(SgPartialFunctionType *);
69304 :
69305 : // RV (2/1/2006): Made a 'const' member function.
69306 : bool
69307 71081 : SgMemberFunctionType::isConstFunc() const
69308 71081 : { return (p_mfunc_specifier & e_const); }
69309 :
69310 : void
69311 3468 : SgMemberFunctionType::setConstFunc()
69312 3468 : { p_mfunc_specifier |= e_const; }
69313 :
69314 : void
69315 0 : SgMemberFunctionType::unsetConstFunc()
69316 0 : { p_mfunc_specifier &= ~e_const; }
69317 :
69318 : // RV (2/1/2006): Made a 'volatile' member function.
69319 : bool
69320 66165 : SgMemberFunctionType::isVolatileFunc() const
69321 66165 : { return (p_mfunc_specifier & e_volatile); }
69322 :
69323 : void
69324 0 : SgMemberFunctionType::setVolatileFunc()
69325 0 : { p_mfunc_specifier |= e_volatile; }
69326 :
69327 : void
69328 0 : SgMemberFunctionType::unsetVolatileFunc()
69329 0 : { p_mfunc_specifier &= ~e_volatile; }
69330 :
69331 :
69332 : // DQ (3/8/2012): Added support for restict on member function types.
69333 : bool
69334 87681 : SgMemberFunctionType::isRestrictFunc() const
69335 87681 : { return (p_mfunc_specifier & e_restrict); }
69336 :
69337 : void
69338 0 : SgMemberFunctionType::setRestrictFunc()
69339 0 : { p_mfunc_specifier |= e_restrict; }
69340 :
69341 : void
69342 0 : SgMemberFunctionType::unsetRestrictFunc()
69343 0 : { p_mfunc_specifier &= ~e_restrict; }
69344 :
69345 : // DQ (1/9/2020): Enabled the use of reference qualification recorded in the function type.
69346 : // L-value reference access/set/unset member functions and member function type
69347 : bool
69348 3340 : SgMemberFunctionType::isLvalueReferenceFunc() const
69349 3340 : { return (p_mfunc_specifier & e_ref_qualifier_lvalue); }
69350 :
69351 : void
69352 0 : SgMemberFunctionType::setLvalueReferenceFunc()
69353 0 : { p_mfunc_specifier |= e_ref_qualifier_lvalue; }
69354 :
69355 : void
69356 0 : SgMemberFunctionType::unsetLvalueReferenceFunc()
69357 0 : { p_mfunc_specifier &= ~e_ref_qualifier_lvalue; }
69358 :
69359 :
69360 : // DQ (1/9/2020): Enabled the use of reference qualification recorded in the function type.
69361 : // R-value reference access/set/unset member functions and member function type
69362 : bool
69363 3340 : SgMemberFunctionType::isRvalueReferenceFunc() const
69364 3340 : { return (p_mfunc_specifier & e_ref_qualifier_rvalue); }
69365 :
69366 : void
69367 0 : SgMemberFunctionType::setRvalueReferenceFunc()
69368 0 : { p_mfunc_specifier |= e_ref_qualifier_rvalue; }
69369 :
69370 : void
69371 0 : SgMemberFunctionType::unsetRvalueReferenceFunc()
69372 0 : { p_mfunc_specifier &= ~e_ref_qualifier_rvalue; }
69373 :
69374 :
69375 :
69376 : SgName
69377 0 : SgMemberFunctionType::get_mangled_name (void) const
69378 : {
69379 0 : ROSE_ASSERT(this != NULL);
69380 0 : return get_mangled ();
69381 : }
69382 :
69383 :
69384 : // DQ (12/6/2012): Adding member function specifier data (since this will be a part of the generated mangled name).
69385 : // SgName SgMemberFunctionType::get_mangled(SgType* ret_type, SgFunctionParameterTypeList * typeList, SgClassType* classType )
69386 39463 : SgName SgMemberFunctionType::get_mangled(SgType* ret_type, SgFunctionParameterTypeList * typeList, SgType* classType, unsigned int mfunc_specifier )
69387 : {
69388 : // DQ (12/3/2011): Added this static function to simplify (refactor) how mangled names are generated).
69389 : // The advantage of refactoring this code to a static function is that the managle name generated to
69390 : // support the global function type table hash key could be generated more directly that what we do
69391 : // now (which is the generate a SgMemberFunctionType, call the get_mangled() function, and then delete
69392 : // the newly built SgMemberFunctionType if the name is alread in the global function type table.
69393 :
69394 : // Unfortunaely, this function makes too many calls to non-static member functions, and thus would be
69395 : // harder than expected to turn into a simple static function.
69396 :
69397 : // Member-function specific information (class name, const/volatile qualifiers).
69398 78926 : SgName mangled_cls_tag;
69399 :
69400 : // ROSE_ASSERT(classType != NULL);
69401 :
69402 : // Compute class scope
69403 : //! \todo Figure out why member function types are sometimes used
69404 : //! incorrectly in place of plain function types.
69405 : // const SgType* cls_type = get_class_type();
69406 39463 : const SgType* cls_type = classType;
69407 39463 : if (cls_type != NULL)
69408 : {
69409 78926 : SgName class_scope = cls_type->get_mangled();
69410 39463 : mangled_cls_tag += class_scope;
69411 : }
69412 :
69413 39463 : SgName mangled_name;
69414 :
69415 : #if 0
69416 : // DQ (12/3/2011): Because of these member function calls this can't be refactored to be a static function.
69417 : // Append modifiers
69418 : if (isConstFunc())
69419 : mangled_cls_tag << "_cf";
69420 : if (isVolatileFunc())
69421 : mangled_cls_tag << "_vf";
69422 :
69423 : // Mangle the function type without qualifiers
69424 : SgName basic_func_type = SgFunctionType::get_mangled();
69425 : #else
69426 : // DQ (12/6/2012): New version of this function using the input parameter (mfunc_specifier) so that we can
69427 : // have this be a static member function. The goal is to use this function to rewite the SageBuilder::buildMemberFunctionType()
69428 : // to both be more clear and fix the handling of SgFunctionParameterTypeList which appears to be a problem for
69429 : // the AST File I/O and the graphs that we generate of the AST in the new EDG 4.x branch.
69430 :
69431 : #if 0
69432 : printf ("mfunc_specifier = %u SgMemberFunctionType::e_const = %d SgMemberFunctionType::e_volatile = %d SgMemberFunctionType::e_restrict = %d \n",
69433 : mfunc_specifier,SgMemberFunctionType::e_const,SgMemberFunctionType::e_volatile,SgMemberFunctionType::e_restrict);
69434 : #endif
69435 :
69436 39463 : if (mfunc_specifier & SgMemberFunctionType::e_const)
69437 : {
69438 : // Mark as const
69439 23102 : mangled_cls_tag << "_cf";
69440 : }
69441 :
69442 39463 : if (mfunc_specifier & SgMemberFunctionType::e_volatile)
69443 : {
69444 : // Mark as volatile
69445 0 : mangled_cls_tag << "_vf";
69446 : }
69447 :
69448 39463 : if (mfunc_specifier & SgMemberFunctionType::e_restrict)
69449 : {
69450 : // Mark as restrict
69451 0 : mangled_cls_tag << "_rf";
69452 : }
69453 :
69454 39463 : if (mfunc_specifier & SgMemberFunctionType::e_ref_qualifier_lvalue)
69455 : {
69456 : // Mark as restrict
69457 0 : mangled_cls_tag << "_lvf";
69458 : }
69459 :
69460 39463 : if (mfunc_specifier & SgMemberFunctionType::e_ref_qualifier_rvalue)
69461 : {
69462 : // Mark as restrict
69463 0 : mangled_cls_tag << "_rvf";
69464 : }
69465 :
69466 : // DQ (12/6/2012): Now use the static function taking extra parameters.
69467 : // Mangle the function type without qualifiers
69468 39463 : SgName basic_func_type = SgFunctionType::get_mangled(ret_type,typeList);
69469 :
69470 : #if 0
69471 : // DQ (12/3/2011): If the data fro these non-static member fucntions were passed in as parameters it might be possible to refactor this code.
69472 : printf ("This function can be used as a refactored version of SgMemberFunctionType::get_mangled(void) \n");
69473 : ROSE_ASSERT(false);
69474 : #endif
69475 : #endif
69476 :
69477 : // Compute mangled member function pointer type
69478 : // SgName mangled_name;
69479 39463 : if (mangled_cls_tag.get_length () > 0)
69480 78926 : mangled_name << "__MFb_" << mangled_cls_tag.str (); // really is a member function
69481 :
69482 78926 : mangled_name << "_" << basic_func_type.str (); // Append standard argument signature.
69483 :
69484 78926 : return mangled_name;
69485 : }
69486 :
69487 : // RV (1/31/2006): Changed form of mangling to include begin/end tags.
69488 : SgName
69489 62825 : SgMemberFunctionType::get_mangled (void) const
69490 : {
69491 62825 : ROSE_ASSERT(this != NULL);
69492 :
69493 : #if 1
69494 : // Member-function specific information (class name, const/volatile qualifiers)
69495 125650 : SgName mangled_cls_tag;
69496 :
69497 : // Compute class scope
69498 : //! \todo Figure out why member function types are sometimes used
69499 : //! incorrectly in place of plain function types.
69500 62825 : const SgType* cls_type = get_class_type ();
69501 62825 : if (cls_type)
69502 : {
69503 125650 : SgName class_scope = cls_type->get_mangled ();
69504 62825 : mangled_cls_tag += class_scope;
69505 : }
69506 : #if 0
69507 : printf ("In SgMemberFunctionType::get_mangled(): after class scope evaluation: mangled_cls_tag = %s \n",mangled_cls_tag.str());
69508 : #endif
69509 :
69510 : // DQ (12/3/2011): Because of these member function calls this can't be refactored to be a static function.
69511 : // Append modifiers
69512 62825 : if (isConstFunc() == true)
69513 36476 : mangled_cls_tag << "_cf";
69514 62825 : if (isVolatileFunc() == true)
69515 0 : mangled_cls_tag << "_vf";
69516 :
69517 : // DQ (3/8/2012): Added support for restrict on member function types.
69518 62825 : if (isRestrictFunc() == true)
69519 0 : mangled_cls_tag << "_rf";
69520 :
69521 : #if 0
69522 : printf ("In SgMemberFunctionType::get_mangled(): after function modifier evaluation: mangled_cls_tag = %s \n",mangled_cls_tag.str());
69523 : #endif
69524 :
69525 : // Mangle the function type without qualifiers
69526 62825 : SgName basic_func_type = SgFunctionType::get_mangled();
69527 :
69528 : #if 0
69529 : printf ("In SgMemberFunctionType::get_mangled(): after call to SgFunctionType::get_mangled(): basic_func_type = %s \n",basic_func_type.str());
69530 : #endif
69531 :
69532 : // Compute mangled member function pointer type
69533 62825 : SgName mangled_name;
69534 62825 : if (mangled_cls_tag.get_length () > 0)
69535 : {
69536 125650 : mangled_name << "__MFb_" << mangled_cls_tag.str(); // really is a member function
69537 : }
69538 :
69539 : #if 0
69540 : printf ("In SgMemberFunctionType::get_mangled(): after mangled member function pointer type evaluation: mangled_cls_tag = %s \n",mangled_name.str());
69541 : #endif
69542 :
69543 125650 : mangled_name << "_" << basic_func_type.str (); // Append standard argument signature.
69544 :
69545 : #if 0
69546 : printf ("In SgMemberFunctionType::get_mangled(): returning: mangled_name = %s \n",mangled_name.str());
69547 : #endif
69548 :
69549 : #else
69550 : // DQ (12/3/2011): Not sure how to construct this case...leaving the older code (unrefactored).
69551 : SgMemberFunctionType::get_mangled(get_return_type(),get_argument_list(),get_class_type());
69552 : #endif
69553 :
69554 125650 : return mangled_name;
69555 : }
69556 :
69557 :
69558 : #if 0
69559 : SgName
69560 : SgMemberFunctionType::get_mangled_type()
69561 : {
69562 : SgUnparse_Info info;
69563 :
69564 : // DQ (6/23/2005): Get the name (and qualified name) of the type into the mangled name
69565 : // printf ("In SgMemberFunctionType::get_mangled_type(): calling info.set_PrintName() \n");
69566 : // info.set_PrintName();
69567 : // ROSE_ASSERT(info.PrintName() == true);
69568 :
69569 : // return get_mangled(SgNO_UNPARSE_INFO);
69570 : return get_mangled(info);
69571 : }
69572 : #endif
69573 :
69574 : #if 0
69575 : // SgMemberFunctionType::get_mangled_name(SgUnparse_Info&);
69576 :
69577 : //! This function repreents the name mangleing support for unparsing
69578 : SgName
69579 : SgMemberFunctionType::get_mangled_name(SgUnparse_Info& info)
69580 : {
69581 : SgName rtmp;
69582 : // SgDeclarationStatement *dstmt = info.get_decl_stmt();
69583 : SgFunctionDeclaration *dstmt = isSgFunctionDeclaration(info.get_decl_stmt());
69584 : ROSE_ASSERT (dstmt != NULL);
69585 : SgName fname = info.get_name();
69586 :
69587 : // int len = strlen(fname.str());
69588 : // SgName tmp(fname);
69589 : // char *opstr = "operator";
69590 : // char *newstr = "new";
69591 : // char *delstr = "delete";
69592 : // int m = strlen(opstr);
69593 :
69594 : // printf ("In SgMemberFunctionType::get_mangled_name(): fname = %s \n",fname.str());
69595 :
69596 : #if 0
69597 : // ***** What about cast operators !!! *****
69598 : if (dstmt->get_specialFunctionModifier().isConversion())
69599 : {
69600 : printf ("Found a conversion operator in SgMemberFunctionType::get_mangled_name \n");
69601 : }
69602 :
69603 : if (dstmt->get_specialFunctionModifier().isOperator())
69604 : {
69605 : printf ("Found an operator in SgMemberFunctionType::get_mangled_name \n");
69606 : }
69607 : #endif
69608 :
69609 : if (dstmt->get_specialFunctionModifier().isConstructor())
69610 : rtmp << "__ct";
69611 : else
69612 : if (dstmt->get_specialFunctionModifier().isDestructor()) rtmp << "__dt";
69613 : else
69614 : if (dstmt->get_specialFunctionModifier().isConversion())
69615 : {
69616 : rtmp << "__conversion__";
69617 : // rtmp = mangledNameSupport(fname,info);
69618 : }
69619 : else
69620 : {
69621 : // These are just normal member functions
69622 : // ROSE_ASSERT (dstmt->get_specialFunctionModifier().isOperator());
69623 : rtmp = mangledNameSupport(fname,info);
69624 : }
69625 :
69626 : string mangledName = rtmp.str();
69627 : ROSE_ASSERT (mangledName.find("<") == string::npos);
69628 : ROSE_ASSERT (mangledName.find(">") == string::npos);
69629 :
69630 : ROSE_ASSERT(mangledName.find('`') == string::npos);
69631 : ROSE_ASSERT(mangledName.find('~') == string::npos);
69632 : ROSE_ASSERT(mangledName.find('!') == string::npos);
69633 : ROSE_ASSERT(mangledName.find('@') == string::npos);
69634 : ROSE_ASSERT(mangledName.find('#') == string::npos);
69635 : ROSE_ASSERT(mangledName.find('$') == string::npos);
69636 : ROSE_ASSERT(mangledName.find('%') == string::npos);
69637 : ROSE_ASSERT(mangledName.find('^') == string::npos);
69638 : ROSE_ASSERT(mangledName.find('&') == string::npos);
69639 : ROSE_ASSERT(mangledName.find('*') == string::npos);
69640 : ROSE_ASSERT(mangledName.find('(') == string::npos);
69641 : ROSE_ASSERT(mangledName.find(')') == string::npos);
69642 : ROSE_ASSERT(mangledName.find('-') == string::npos);
69643 : ROSE_ASSERT(mangledName.find('+') == string::npos);
69644 : ROSE_ASSERT(mangledName.find('=') == string::npos);
69645 : ROSE_ASSERT(mangledName.find('{') == string::npos);
69646 : ROSE_ASSERT(mangledName.find('}') == string::npos);
69647 : ROSE_ASSERT(mangledName.find('[') == string::npos);
69648 : ROSE_ASSERT(mangledName.find(']') == string::npos);
69649 : ROSE_ASSERT(mangledName.find('|') == string::npos);
69650 : ROSE_ASSERT(mangledName.find('\\') == string::npos);
69651 : ROSE_ASSERT(mangledName.find(':') == string::npos);
69652 : ROSE_ASSERT(mangledName.find(';') == string::npos);
69653 : ROSE_ASSERT(mangledName.find('\"') == string::npos);
69654 : ROSE_ASSERT(mangledName.find('\'') == string::npos);
69655 : ROSE_ASSERT(mangledName.find('?') == string::npos);
69656 : ROSE_ASSERT(mangledName.find('.') == string::npos);
69657 : ROSE_ASSERT(mangledName.find('/') == string::npos);
69658 : ROSE_ASSERT(mangledName.find(',') == string::npos);
69659 :
69660 : // These are the most common cases that fail
69661 : ROSE_ASSERT(mangledName.find('<') == string::npos);
69662 : ROSE_ASSERT(mangledName.find('>') == string::npos);
69663 :
69664 : // printf ("Leaving SgMemberFunctionType::get_mangled_name(): mangledName = %s \n",mangledName.c_str());
69665 :
69666 : #if 0
69667 : // This code has been refactored and place in a separate function: mangledNameSupport()
69668 : if (len > 0 && strncmp(fname.str(),opstr,m)==0)
69669 : {
69670 : if (fname.str()[m]==' ')
69671 : {
69672 : #if 0
69673 : if (strncmp(&(fname.str()[m+2]),newstr,strlen(newstr)))
69674 : rtmp << "__nw";
69675 : else
69676 : if (strncmp(&(fname.str()[m+2]),delstr, strlen(delstr)))
69677 : rtmp << "__dl";
69678 : else
69679 : rtmp << "__op" << get_return_type()->get_mangled(info).str();
69680 : #else
69681 : // DQ (4/27/2005): "m+2" should be "m+1"
69682 : if (strncmp(&(fname.str()[m+1]),newstr,strlen(newstr)) == 0)
69683 : {
69684 : // DQ (4/27/2005): Added support for array new
69685 : int newStringLength = strlen(newstr);
69686 : int parenStart = m+1+newStringLength;
69687 : if (len > parenStart && strncmp(&(fname.str()[parenStart]),"[]",2) == 0)
69688 : rtmp << "__na";
69689 : else
69690 : rtmp << "__nw";
69691 : }
69692 : else
69693 : {
69694 : // DQ (4/27/2005): Added support for array delete
69695 : if (strncmp(&(fname.str()[m+1]),delstr,strlen(delstr)) == 0)
69696 : {
69697 : int deleteStringLength = strlen(delstr);
69698 : int parenStart = m+1+deleteStringLength;
69699 : if (len > parenStart && strncmp(&(fname.str()[parenStart]),"[]",2) == 0)
69700 : rtmp << "__da";
69701 : else
69702 : rtmp << "__dl";
69703 : }
69704 : else
69705 : {
69706 : // DQ (4/27/2005): Not clear where this is used (unless it is used in casting operators)!
69707 : rtmp << "__op" << get_return_type()->get_mangled(info).str();
69708 : }
69709 : }
69710 : #endif
69711 : }
69712 : else
69713 : {
69714 : // real operator
69715 : SgName opname=&(fname.str()[m]);
69716 : if (opname==SgName("->")) rtmp << "__rf";
69717 : else if (opname==SgName("->*")) rtmp << "__rm";
69718 : else if (opname==SgName("==")) rtmp << "__eq";
69719 : else if (opname==SgName("<")) rtmp << "__lt";
69720 : else if (opname==SgName(">")) rtmp << "__gt";
69721 : else if (opname==SgName("!=")) rtmp << "__ne";
69722 : else if (opname==SgName("<=")) rtmp << "__le";
69723 : else if (opname==SgName(">=")) rtmp << "__ge";
69724 : else if (opname==SgName("+")) rtmp << "__pl";
69725 : else if (opname==SgName("-")) rtmp << "__mi";
69726 : else if (opname==SgName("*")) rtmp << "__ml";
69727 : else if (opname==SgName("/")) rtmp << "__dv";
69728 : else if (opname==SgName("%")) rtmp << "__md";
69729 : else if (opname==SgName("&&")) rtmp << "__aa";
69730 : else if (opname==SgName("!")) rtmp << "__nt";
69731 : else if (opname==SgName("||")) rtmp << "__oo";
69732 : else if (opname==SgName("^")) rtmp << "__er";
69733 : else if (opname==SgName("&")) rtmp << "__ad";
69734 : else if (opname==SgName("|")) rtmp << "__or";
69735 : else if (opname==SgName(",")) rtmp << "__cm";
69736 : else if (opname==SgName("<<")) rtmp << "__ls";
69737 : else if (opname==SgName(">>")) rtmp << "__rs";
69738 : else if (opname==SgName("--")) rtmp << "__mm";
69739 : else if (opname==SgName("++")) rtmp << "__pp";
69740 : else if (opname==SgName("~")) rtmp << "__co";
69741 : else if (opname==SgName("=")) rtmp << "__as";
69742 : else if (opname==SgName("+=")) rtmp << "__apl";
69743 : else if (opname==SgName("-=")) rtmp << "__ami";
69744 : else if (opname==SgName("&=")) rtmp << "__aad";
69745 : else if (opname==SgName("|=")) rtmp << "__aor";
69746 : else if (opname==SgName("*=")) rtmp << "__amu";
69747 : else if (opname==SgName("/=")) rtmp << "__adv";
69748 : else if (opname==SgName("%=")) rtmp << "__amd";
69749 : else if (opname==SgName("^=")) rtmp << "__aer";
69750 : else if (opname==SgName("<<=")) rtmp << "__als";
69751 : else if (opname==SgName(">>=")) rtmp << "__ars";
69752 : else if (opname==SgName("()")) rtmp << "__cl";
69753 : else if (opname==SgName("[]")) rtmp << "__xi";
69754 : else
69755 : {
69756 : printf ("In SgMemberFunctionType::get_mangled_name(): This case should never be reached (fname = %s) \n",fname.str());
69757 : ROSE_ASSERT(false);
69758 : }
69759 : }
69760 : }
69761 : else
69762 : rtmp << fname.str();
69763 : #endif
69764 :
69765 : return rtmp;
69766 : }
69767 : #endif
69768 :
69769 : #if 0
69770 : //! This function repreents the name mangling support for unparsing
69771 : /*! this routine can do 2 things,
69772 : mangle a type with class name - without funcname
69773 : mangle a complete function declaration with name and class name
69774 : */
69775 : SgName
69776 : SgMemberFunctionType::get_mangled(SgUnparse_Info & info)
69777 : {
69778 : SgName tmp;
69779 :
69780 : // printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&) info.PrintName() = %s \n",(info.PrintName() == true) ? "true" : "false");
69781 :
69782 : /* should have a name to start with */
69783 : if (info.PrintName())
69784 : {
69785 : // DQ (6/23/2005): This path is taken for constructors, destructors and conversion operators (I think!)
69786 : // tmp << get_mangled_name(info).str();
69787 : // SgName name = get_mangled_name(info);
69788 : // printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): (assuming info.PrintName() == true): name = %s \n",name.str());
69789 : tmp << name.str();
69790 : }
69791 : #if 0
69792 : printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): #1 tmp = %s \n",tmp.str());
69793 : #endif
69794 : tmp << "__";
69795 : // if(info.PrintName()) { // only if needs to print name
69796 : if (p_struct_name != NULL)
69797 : {
69798 : // a member function
69799 : int cnt=0;
69800 : SgName p_nm = p_struct_name->get_mangled_qualified_name(cnt);
69801 : if(cnt>1)
69802 : tmp << "Q" << cnt << p_nm.str();
69803 : else
69804 : tmp << p_nm.str();
69805 : }
69806 : // }
69807 : tmp << "F";
69808 : #if 0
69809 : printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): #2 tmp = %s \n",tmp.str());
69810 : #endif
69811 : /* process argument type */
69812 : SgTypePtrList::iterator p = get_arguments().begin();
69813 : while (p != get_arguments().end())
69814 : {
69815 : tmp << (*p)->get_mangled(info).str();
69816 :
69817 : // DQ (5/2/2005): Added to handle function arguments which are templates
69818 : tmp = fixupTemplateNameForMangledNameSupport(tmp);
69819 :
69820 : p++;
69821 : }
69822 : #if 0
69823 : printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): #3 tmp = %s \n",tmp.str());
69824 : #endif
69825 : /* process return type */
69826 : SgName returnTypeName = get_return_type()->get_mangled(info);
69827 : #if 0
69828 : printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): get_return_type() = %s returnTypeName = %s \n",
69829 : get_return_type()->sage_class_name(),returnTypeName.str());
69830 : #endif
69831 :
69832 : returnTypeName = fixupTemplateNameForMangledNameSupport(returnTypeName);
69833 : #if 0
69834 : printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): #4 tmp = %s \n",tmp.str());
69835 : #endif
69836 : // tmp << "_" << get_return_type()->get_mangled(info).str();
69837 : tmp << "_" << returnTypeName.str();
69838 :
69839 : if (isConstFunc())
69840 : tmp << "_cf";
69841 :
69842 : if (isVolatileFunc())
69843 : tmp << "_vf";
69844 : #if 0
69845 : printf ("In SgMemberFunctionType::get_mangled(SgUnparse_Info&): #5 tmp = %s \n",tmp.str());
69846 : #endif
69847 : #if 0
69848 : printf ("########### In SgMemberFunctionType::get_mangled(): tmp = %s (returnTypeName = %s is a %s) ########## \n",
69849 : tmp.str(),returnTypeName.str(),get_return_type()->sage_class_name());
69850 : // ROSE_ASSERT(false);
69851 : #endif
69852 :
69853 : return tmp;
69854 : }
69855 : #endif
69856 :
69857 :
69858 : // SgMemberFunctionType * mkAnotherType(SgType *);
69859 : SgMemberFunctionType *
69860 0 : SgMemberFunctionType::mkAnotherType(SgType *rtype)
69861 : {
69862 0 : if (rtype == get_return_type())
69863 : return NULL;
69864 :
69865 0 : SgPartialFunctionType *part_type = SgPartialFunctionType::createType(rtype);
69866 :
69867 : /* process argument type */
69868 0 : SgTypePtrList::iterator p = this->get_arguments().begin();
69869 0 : while (p != this->get_arguments().end())
69870 : {
69871 0 : part_type->append_argument((*p));
69872 0 : p++;
69873 : }
69874 0 : part_type->set_class_type(this->get_class_type());
69875 0 : part_type->set_mfunc_specifier(this->get_mfunc_specifier());
69876 :
69877 0 : SgMemberFunctionType *ntype = SgMemberFunctionType::createType(part_type);
69878 0 : if (ntype == this)
69879 : return NULL;
69880 : else
69881 0 : return ntype;
69882 : }
69883 :
69884 : // PC (10/29/2009): Deprecated compatibility routine for those still using get_struct_name()
69885 : SgClassDefinition*
69886 0 : SgMemberFunctionType::get_struct_name() const
69887 : {
69888 0 : if (get_class_type() == NULL)
69889 : return NULL;
69890 0 : SgClassType *clsType = isSgClassType(get_class_type()->stripTypedefsAndModifiers());
69891 0 : ROSE_ASSERT(clsType != NULL);
69892 0 : SgClassDeclaration *clsDecl = isSgClassDeclaration(clsType->get_declaration()->get_definingDeclaration());
69893 0 : ROSE_ASSERT(clsDecl != NULL);
69894 0 : return clsDecl->get_definition();
69895 : }
69896 :
69897 :
69898 :
69899 :
69900 : // End of memberFunctionString
69901 : // Start of memberFunctionString
69902 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
69903 :
69904 : // *** COMMON CODE SECTION BEGINS HERE ***
69905 :
69906 : #if 0
69907 : int
69908 : SgMemberFunctionType::getVariant() const
69909 : {
69910 : // This function is used in ROSE while "variant()" is used in SAGE
69911 : assert(this != NULL);
69912 : return variant();
69913 : }
69914 : #endif
69915 :
69916 : // This function is used in ROSE in treeTraversal code
69917 : // eventually replaces getVariant() and variant()
69918 : // though after variant() has been removed for a while we will
69919 : // want to change the name of variantT() back to variant()
69920 : // (since the "T" was ment to stand for temporary).
69921 : // When this happens the variantT() will be depricated.
69922 : VariantT
69923 73957700 : SgMemberFunctionType::variantT() const
69924 : {
69925 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
69926 73957700 : ROSE_ASSERT(this != NULL);
69927 73957700 : return V_SgMemberFunctionType;
69928 : }
69929 :
69930 : #if 0
69931 : int
69932 : SgMemberFunctionType::variant() const
69933 : {
69934 : // This function is used in SAGE
69935 : ROSE_ASSERT(this != NULL);
69936 : return T_MEMBERFUNCTION;
69937 : }
69938 : #endif
69939 :
69940 : ROSE_DLL_API const char*
69941 2439 : SgMemberFunctionType::sage_class_name() const
69942 : {
69943 2439 : ROSE_ASSERT(this != NULL);
69944 2439 : return "SgMemberFunctionType";
69945 : }
69946 :
69947 : std::string
69948 19681 : SgMemberFunctionType::class_name() const
69949 : {
69950 19681 : ROSE_ASSERT(this != NULL);
69951 19681 : return "SgMemberFunctionType";
69952 : }
69953 :
69954 : // DQ (11/26/2005): Support for visitor pattern mechanims
69955 : // (inferior to ROSE traversal mechanism, experimental).
69956 : void
69957 301911 : SgMemberFunctionType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
69958 : {
69959 301911 : ROSE_ASSERT(this != NULL);
69960 301911 : visitor.visit(this);
69961 301911 : }
69962 :
69963 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
69964 0 : void SgMemberFunctionType::accept (ROSE_VisitorPattern & visitor) {
69965 0 : ROSE_ASSERT(this != NULL);
69966 0 : visitor.visit(this);
69967 0 : }
69968 :
69969 : SgMemberFunctionType*
69970 0 : SgMemberFunctionType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
69971 : {
69972 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
69973 : // This function is currently only supported for the AST used the represent Binary executables.
69974 : if (0 /* isSgAsmNode(this) != NULL */)
69975 : {
69976 : // Support for regex specification.
69977 : std::string prefixCode = "REGEX:";
69978 : addNewAttribute(prefixCode + s,a);
69979 : }
69980 : #endif
69981 :
69982 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
69983 0 : return this;
69984 : }
69985 :
69986 : // *** COMMON CODE SECTION ENDS HERE ***
69987 :
69988 :
69989 : // End of memberFunctionString
69990 : // Start of memberFunctionString
69991 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
69992 :
69993 :
69994 : #if 0
69995 : //! Error checking support
69996 : /*! Verifies the following:
69997 : - working getVariant() member function
69998 : - calls base class's error() member function
69999 : Every class has one of these functions.
70000 : */
70001 : bool
70002 : SgMemberFunctionType::error()
70003 : {
70004 : // Put error checking here
70005 :
70006 : ROSE_ASSERT (this != NULL);
70007 : if (getVariant() != T_MEMBERFUNCTION)
70008 : {
70009 : printf ("Error in SgMemberFunctionType::error(): SgMemberFunctionType object has a %s variant \n",
70010 : Cxx_GrammarTerminalNames[getVariant()].name);
70011 : // printf ("Error in SgMemberFunctionType::error() \n");
70012 : ROSE_ABORT();
70013 : }
70014 :
70015 : ROSE_ASSERT (getVariant() == T_MEMBERFUNCTION);
70016 : return SgFunctionType::error();
70017 : }
70018 : #endif
70019 :
70020 :
70021 :
70022 : // End of memberFunctionString
70023 :
70024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
70025 :
70026 1386400 : SgMemberFunctionType* isSgMemberFunctionType ( SgNode* inputDerivedClassPointer )
70027 : {
70028 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
70029 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
70030 : // So to fix this we return NULL directly when the input is NULL and avoid the
70031 : // dynamic_cast in this case. This is likely a performance improvement as well.
70032 : // return dynamic_cast<SgMemberFunctionType*>(inputDerivedClassPointer);
70033 : // Milind Chabbi (8/28/2013): isSgMemberFunctionType uses table-driven castability instead of c++ default dynamic_cast
70034 : // this improves the running time performance by 10-20%.
70035 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMemberFunctionType*>(inputDerivedClassPointer);
70036 1386400 : return IS_SgMemberFunctionType_FAST_MACRO(inputDerivedClassPointer);
70037 : }
70038 :
70039 : // DQ (11/8/2003): Added version of functions taking const pointer
70040 0 : const SgMemberFunctionType* isSgMemberFunctionType ( const SgNode* inputDerivedClassPointer )
70041 : {
70042 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
70043 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
70044 : // So to fix this we return NULL directly when the input is NULL and avoid the
70045 : // dynamic_cast in this case. This is likely a performance improvement as well.
70046 : // return dynamic_cast<const SgMemberFunctionType*>(inputDerivedClassPointer);
70047 : // Milind Chabbi (8/28/2013): isSgMemberFunctionType uses table-driven castability instead of c++ default dynamic_cast
70048 : // this improves the running time performance by 10-20%.
70049 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMemberFunctionType*>(inputDerivedClassPointer);
70050 0 : return IS_SgMemberFunctionType_FAST_MACRO(inputDerivedClassPointer);
70051 : }
70052 :
70053 :
70054 :
70055 : /* #line 70056 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70056 :
70057 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
70058 :
70059 : /**
70060 : \brief Generated destructor
70061 :
70062 : This destructor is automatically generated (by ROSETTA). This destructor
70063 : only frees memory of data members associated with the parts of the current IR node which
70064 : are NOT traversed. Those data members that are part of a traversal can be freed using
70065 : a traversal (calling this destructor on all children in a post-order traversal). Such
70066 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
70067 :
70068 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
70069 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
70070 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
70071 :
70072 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
70073 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
70074 : pointers are not yet implemented to call delete on eash pointer in the container.
70075 : (This could be done by derivation from the STL containers to define containers that
70076 : automatically deleted their members.)
70077 :
70078 : */
70079 27760 : SgMemberFunctionType::~SgMemberFunctionType () {
70080 23426 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
70081 :
70082 :
70083 : // case: not a listType for class_type
70084 23426 : p_class_type = NULL; // non list case
70085 : // case: not a listType for mfunc_specifier
70086 23426 : p_mfunc_specifier = 0; // non list case
70087 : // case: not a listType for ref_qualifiers
70088 23426 : p_ref_qualifiers = 0; // non list case
70089 :
70090 : }
70091 :
70092 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
70093 27760 : }
70094 :
70095 :
70096 : /* #line 70097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70097 :
70098 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
70099 :
70100 : // Generated constructor
70101 19092 : SgMemberFunctionType::SgMemberFunctionType ( SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers )
70102 19092 : : SgFunctionType(return_type, has_ellipses)
70103 : {
70104 : #ifdef DEBUG
70105 : // printf ("In SgMemberFunctionType::SgMemberFunctionType (SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers) sage_class_name() = %s \n",sage_class_name());
70106 : #endif
70107 : #if 0
70108 : // debugging information!
70109 : printf ("In SgMemberFunctionType::SgMemberFunctionType (SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers): this = %p = %s \n",this,this->class_name().c_str());
70110 : #endif
70111 :
70112 19092 : p_class_type = class_type;
70113 19092 : p_mfunc_specifier = mfunc_specifier;
70114 19092 : p_ref_qualifiers = ref_qualifiers;
70115 :
70116 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
70117 :
70118 : #if 0
70119 : // DQ (7/30/2014): Call a virtual function.
70120 : std::string s = this->class_name();
70121 : #endif
70122 :
70123 : // Test the variant virtual function
70124 : // assert(T_MEMBERFUNCTION == variant());
70125 19092 : assert(T_MEMBERFUNCTION == this->variant());
70126 19092 : ROSE_ASSERT(T_MEMBERFUNCTION == (int)(this->variantT()));
70127 19092 : post_construction_initialization();
70128 :
70129 : // Test the isSgMemberFunctionType() function since it has been problematic
70130 19092 : assert(isSgMemberFunctionType(this) != NULL);
70131 19092 : }
70132 :
70133 : // Generated constructor (all data members)
70134 :
70135 : /* #line 70136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70136 :
70137 :
70138 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
70139 :
70140 :
70141 : // ********************************************************
70142 : // member functions common across all array grammar objects
70143 : // ********************************************************
70144 :
70145 :
70146 :
70147 : /* #line 70148 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70148 :
70149 :
70150 :
70151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
70152 :
70153 : // ********************************************************
70154 : // member functions specific to each node in the grammar
70155 : // ********************************************************
70156 :
70157 :
70158 : /* #line 70159 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70159 :
70160 : // Start of memberFunctionString
70161 : /* #line 6399 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
70162 :
70163 : // SgPartialFunctionType* SgPartialFunctionType::createType(SgType* rtype)
70164 : SgPartialFunctionType*
70165 0 : SgPartialFunctionType::createType(SgType* rtype,SgExpression* optional_fortran_type_kind)
70166 : {
70167 : // return new SgPartialFunctionType(rtype);
70168 :
70169 : // DQ (10/4/2010): I don't think this type can have a fortran type kind parameter.
70170 0 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
70171 :
70172 : #if 0
70173 : printf ("In SgPartialFunctionType::createType() (CREATE_TYPE_FOR_PARTIAL_FUNCTION_TYPE) \n");
70174 : #endif
70175 :
70176 0 : SgPartialFunctionType* returnType = new SgPartialFunctionType(rtype);
70177 0 : ROSE_ASSERT(returnType != NULL);
70178 :
70179 0 : return returnType;
70180 : }
70181 :
70182 :
70183 :
70184 : // End of memberFunctionString
70185 : // Start of memberFunctionString
70186 : /* #line 5853 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
70187 :
70188 : //! This is an empty function (no data to initialize)
70189 : void
70190 19092 : SgPartialFunctionType::post_construction_initialization ()
70191 : {
70192 19092 : }
70193 :
70194 :
70195 :
70196 : // End of memberFunctionString
70197 : // Start of memberFunctionString
70198 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
70199 :
70200 : // *** COMMON CODE SECTION BEGINS HERE ***
70201 :
70202 : #if 0
70203 : int
70204 : SgPartialFunctionType::getVariant() const
70205 : {
70206 : // This function is used in ROSE while "variant()" is used in SAGE
70207 : assert(this != NULL);
70208 : return variant();
70209 : }
70210 : #endif
70211 :
70212 : // This function is used in ROSE in treeTraversal code
70213 : // eventually replaces getVariant() and variant()
70214 : // though after variant() has been removed for a while we will
70215 : // want to change the name of variantT() back to variant()
70216 : // (since the "T" was ment to stand for temporary).
70217 : // When this happens the variantT() will be depricated.
70218 : VariantT
70219 57276 : SgPartialFunctionType::variantT() const
70220 : {
70221 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
70222 57276 : ROSE_ASSERT(this != NULL);
70223 57276 : return V_SgPartialFunctionType;
70224 : }
70225 :
70226 : #if 0
70227 : int
70228 : SgPartialFunctionType::variant() const
70229 : {
70230 : // This function is used in SAGE
70231 : ROSE_ASSERT(this != NULL);
70232 : return T_PARTIAL_FUNCTION;
70233 : }
70234 : #endif
70235 :
70236 : ROSE_DLL_API const char*
70237 0 : SgPartialFunctionType::sage_class_name() const
70238 : {
70239 0 : ROSE_ASSERT(this != NULL);
70240 0 : return "SgPartialFunctionType";
70241 : }
70242 :
70243 : std::string
70244 0 : SgPartialFunctionType::class_name() const
70245 : {
70246 0 : ROSE_ASSERT(this != NULL);
70247 0 : return "SgPartialFunctionType";
70248 : }
70249 :
70250 : // DQ (11/26/2005): Support for visitor pattern mechanims
70251 : // (inferior to ROSE traversal mechanism, experimental).
70252 : void
70253 0 : SgPartialFunctionType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
70254 : {
70255 0 : ROSE_ASSERT(this != NULL);
70256 0 : visitor.visit(this);
70257 0 : }
70258 :
70259 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
70260 0 : void SgPartialFunctionType::accept (ROSE_VisitorPattern & visitor) {
70261 0 : ROSE_ASSERT(this != NULL);
70262 0 : visitor.visit(this);
70263 0 : }
70264 :
70265 : SgPartialFunctionType*
70266 0 : SgPartialFunctionType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
70267 : {
70268 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
70269 : // This function is currently only supported for the AST used the represent Binary executables.
70270 : if (0 /* isSgAsmNode(this) != NULL */)
70271 : {
70272 : // Support for regex specification.
70273 : std::string prefixCode = "REGEX:";
70274 : addNewAttribute(prefixCode + s,a);
70275 : }
70276 : #endif
70277 :
70278 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
70279 0 : return this;
70280 : }
70281 :
70282 : // *** COMMON CODE SECTION ENDS HERE ***
70283 :
70284 :
70285 : // End of memberFunctionString
70286 : // Start of memberFunctionString
70287 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
70288 :
70289 :
70290 : #if 0
70291 : //! Error checking support
70292 : /*! Verifies the following:
70293 : - working getVariant() member function
70294 : - calls base class's error() member function
70295 : Every class has one of these functions.
70296 : */
70297 : bool
70298 : SgPartialFunctionType::error()
70299 : {
70300 : // Put error checking here
70301 :
70302 : ROSE_ASSERT (this != NULL);
70303 : if (getVariant() != T_PARTIAL_FUNCTION)
70304 : {
70305 : printf ("Error in SgPartialFunctionType::error(): SgPartialFunctionType object has a %s variant \n",
70306 : Cxx_GrammarTerminalNames[getVariant()].name);
70307 : // printf ("Error in SgPartialFunctionType::error() \n");
70308 : ROSE_ABORT();
70309 : }
70310 :
70311 : ROSE_ASSERT (getVariant() == T_PARTIAL_FUNCTION);
70312 : return SgMemberFunctionType::error();
70313 : }
70314 : #endif
70315 :
70316 :
70317 :
70318 : // End of memberFunctionString
70319 :
70320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
70321 :
70322 1204210 : SgPartialFunctionType* isSgPartialFunctionType ( SgNode* inputDerivedClassPointer )
70323 : {
70324 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
70325 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
70326 : // So to fix this we return NULL directly when the input is NULL and avoid the
70327 : // dynamic_cast in this case. This is likely a performance improvement as well.
70328 : // return dynamic_cast<SgPartialFunctionType*>(inputDerivedClassPointer);
70329 : // Milind Chabbi (8/28/2013): isSgPartialFunctionType uses table-driven castability instead of c++ default dynamic_cast
70330 : // this improves the running time performance by 10-20%.
70331 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPartialFunctionType*>(inputDerivedClassPointer);
70332 1204210 : return IS_SgPartialFunctionType_FAST_MACRO(inputDerivedClassPointer);
70333 : }
70334 :
70335 : // DQ (11/8/2003): Added version of functions taking const pointer
70336 0 : const SgPartialFunctionType* isSgPartialFunctionType ( const SgNode* inputDerivedClassPointer )
70337 : {
70338 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
70339 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
70340 : // So to fix this we return NULL directly when the input is NULL and avoid the
70341 : // dynamic_cast in this case. This is likely a performance improvement as well.
70342 : // return dynamic_cast<const SgPartialFunctionType*>(inputDerivedClassPointer);
70343 : // Milind Chabbi (8/28/2013): isSgPartialFunctionType uses table-driven castability instead of c++ default dynamic_cast
70344 : // this improves the running time performance by 10-20%.
70345 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPartialFunctionType*>(inputDerivedClassPointer);
70346 0 : return IS_SgPartialFunctionType_FAST_MACRO(inputDerivedClassPointer);
70347 : }
70348 :
70349 :
70350 :
70351 : /* #line 70352 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70352 :
70353 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
70354 :
70355 : /**
70356 : \brief Generated destructor
70357 :
70358 : This destructor is automatically generated (by ROSETTA). This destructor
70359 : only frees memory of data members associated with the parts of the current IR node which
70360 : are NOT traversed. Those data members that are part of a traversal can be freed using
70361 : a traversal (calling this destructor on all children in a post-order traversal). Such
70362 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
70363 :
70364 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
70365 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
70366 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
70367 :
70368 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
70369 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
70370 : pointers are not yet implemented to call delete on eash pointer in the container.
70371 : (This could be done by derivation from the STL containers to define containers that
70372 : automatically deleted their members.)
70373 :
70374 : */
70375 38184 : SgPartialFunctionType::~SgPartialFunctionType () {
70376 19092 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
70377 :
70378 :
70379 :
70380 : }
70381 :
70382 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
70383 38184 : }
70384 :
70385 :
70386 : /* #line 70387 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70387 :
70388 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
70389 :
70390 : // Generated constructor
70391 19092 : SgPartialFunctionType::SgPartialFunctionType ( SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers )
70392 19092 : : SgMemberFunctionType(return_type, has_ellipses, class_type, mfunc_specifier, ref_qualifiers)
70393 : {
70394 : #ifdef DEBUG
70395 : // printf ("In SgPartialFunctionType::SgPartialFunctionType (SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers) sage_class_name() = %s \n",sage_class_name());
70396 : #endif
70397 : #if 0
70398 : // debugging information!
70399 : printf ("In SgPartialFunctionType::SgPartialFunctionType (SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers): this = %p = %s \n",this,this->class_name().c_str());
70400 : #endif
70401 :
70402 :
70403 :
70404 : #if 0
70405 : // DQ (7/30/2014): Call a virtual function.
70406 : std::string s = this->class_name();
70407 : #endif
70408 :
70409 : // Test the variant virtual function
70410 : // assert(T_PARTIAL_FUNCTION == variant());
70411 19092 : assert(T_PARTIAL_FUNCTION == this->variant());
70412 19092 : ROSE_ASSERT(T_PARTIAL_FUNCTION == (int)(this->variantT()));
70413 19092 : post_construction_initialization();
70414 :
70415 : // Test the isSgPartialFunctionType() function since it has been problematic
70416 19092 : assert(isSgPartialFunctionType(this) != NULL);
70417 19092 : }
70418 :
70419 : // Generated constructor (all data members)
70420 :
70421 : /* #line 70422 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70422 :
70423 :
70424 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
70425 :
70426 :
70427 : // ********************************************************
70428 : // member functions common across all array grammar objects
70429 : // ********************************************************
70430 :
70431 :
70432 :
70433 : /* #line 70434 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70434 :
70435 :
70436 :
70437 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
70438 :
70439 : // ********************************************************
70440 : // member functions specific to each node in the grammar
70441 : // ********************************************************
70442 :
70443 :
70444 : /* #line 70445 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70445 :
70446 : // Start of memberFunctionString
70447 :
70448 :
70449 : // End of memberFunctionString
70450 : // Start of memberFunctionString
70451 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
70452 :
70453 : // *** COMMON CODE SECTION BEGINS HERE ***
70454 :
70455 : #if 0
70456 : int
70457 : SgPartialFunctionModifierType::getVariant() const
70458 : {
70459 : // This function is used in ROSE while "variant()" is used in SAGE
70460 : assert(this != NULL);
70461 : return variant();
70462 : }
70463 : #endif
70464 :
70465 : // This function is used in ROSE in treeTraversal code
70466 : // eventually replaces getVariant() and variant()
70467 : // though after variant() has been removed for a while we will
70468 : // want to change the name of variantT() back to variant()
70469 : // (since the "T" was ment to stand for temporary).
70470 : // When this happens the variantT() will be depricated.
70471 : VariantT
70472 0 : SgPartialFunctionModifierType::variantT() const
70473 : {
70474 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
70475 0 : ROSE_ASSERT(this != NULL);
70476 0 : return V_SgPartialFunctionModifierType;
70477 : }
70478 :
70479 : #if 0
70480 : int
70481 : SgPartialFunctionModifierType::variant() const
70482 : {
70483 : // This function is used in SAGE
70484 : ROSE_ASSERT(this != NULL);
70485 : return T_PARTIAL_FUNCTION_MODIFIER;
70486 : }
70487 : #endif
70488 :
70489 : ROSE_DLL_API const char*
70490 0 : SgPartialFunctionModifierType::sage_class_name() const
70491 : {
70492 0 : ROSE_ASSERT(this != NULL);
70493 0 : return "SgPartialFunctionModifierType";
70494 : }
70495 :
70496 : std::string
70497 0 : SgPartialFunctionModifierType::class_name() const
70498 : {
70499 0 : ROSE_ASSERT(this != NULL);
70500 0 : return "SgPartialFunctionModifierType";
70501 : }
70502 :
70503 : // DQ (11/26/2005): Support for visitor pattern mechanims
70504 : // (inferior to ROSE traversal mechanism, experimental).
70505 : void
70506 0 : SgPartialFunctionModifierType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
70507 : {
70508 0 : ROSE_ASSERT(this != NULL);
70509 0 : visitor.visit(this);
70510 0 : }
70511 :
70512 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
70513 0 : void SgPartialFunctionModifierType::accept (ROSE_VisitorPattern & visitor) {
70514 0 : ROSE_ASSERT(this != NULL);
70515 0 : visitor.visit(this);
70516 0 : }
70517 :
70518 : SgPartialFunctionModifierType*
70519 0 : SgPartialFunctionModifierType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
70520 : {
70521 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
70522 : // This function is currently only supported for the AST used the represent Binary executables.
70523 : if (0 /* isSgAsmNode(this) != NULL */)
70524 : {
70525 : // Support for regex specification.
70526 : std::string prefixCode = "REGEX:";
70527 : addNewAttribute(prefixCode + s,a);
70528 : }
70529 : #endif
70530 :
70531 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
70532 0 : return this;
70533 : }
70534 :
70535 : // *** COMMON CODE SECTION ENDS HERE ***
70536 :
70537 :
70538 : // End of memberFunctionString
70539 : // Start of memberFunctionString
70540 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
70541 :
70542 :
70543 : #if 0
70544 : //! Error checking support
70545 : /*! Verifies the following:
70546 : - working getVariant() member function
70547 : - calls base class's error() member function
70548 : Every class has one of these functions.
70549 : */
70550 : bool
70551 : SgPartialFunctionModifierType::error()
70552 : {
70553 : // Put error checking here
70554 :
70555 : ROSE_ASSERT (this != NULL);
70556 : if (getVariant() != T_PARTIAL_FUNCTION_MODIFIER)
70557 : {
70558 : printf ("Error in SgPartialFunctionModifierType::error(): SgPartialFunctionModifierType object has a %s variant \n",
70559 : Cxx_GrammarTerminalNames[getVariant()].name);
70560 : // printf ("Error in SgPartialFunctionModifierType::error() \n");
70561 : ROSE_ABORT();
70562 : }
70563 :
70564 : ROSE_ASSERT (getVariant() == T_PARTIAL_FUNCTION_MODIFIER);
70565 : return SgPartialFunctionType::error();
70566 : }
70567 : #endif
70568 :
70569 :
70570 :
70571 : // End of memberFunctionString
70572 : // Start of memberFunctionString
70573 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
70574 :
70575 :
70576 : // DQ (1/31/2006): Modified to build all types in the memory pools
70577 : // SgPartialFunctionModifierType SgPartialFunctionModifierType::builtin_type;
70578 : // SgPartialFunctionModifierType* SgPartialFunctionModifierType::builtin_type = new SgPartialFunctionModifierType();
70579 : SgPartialFunctionModifierType* SgPartialFunctionModifierType::p_builtin_type = NULL;
70580 :
70581 :
70582 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
70583 : // SgPartialFunctionModifierType* SgPartialFunctionModifierType::createType(void)
70584 : SgPartialFunctionModifierType*
70585 0 : SgPartialFunctionModifierType::createType(SgExpression* optional_fortran_type_kind)
70586 : {
70587 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
70588 : // is not called (likely because static initialization is compiler dependent).
70589 : // DQ (1/31/2006): Modified to build all types in the memory pools
70590 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
70591 : // return &builtin_type;
70592 :
70593 : #if 0
70594 : printf ("In SgPartialFunctionModifierType::createType() (COMMON_CREATE_TYPE) \n");
70595 : #endif
70596 :
70597 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
70598 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
70599 :
70600 0 : SgPartialFunctionModifierType* temp_type = new SgPartialFunctionModifierType();
70601 :
70602 : #if 0
70603 : printf ("In SgPartialFunctionModifierType::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
70604 : #endif
70605 :
70606 : // DQ (10/31/2016): Added assertion.
70607 0 : ROSE_ASSERT(temp_type != NULL);
70608 :
70609 0 : if (optional_fortran_type_kind != NULL)
70610 : {
70611 : // DQ (10/31/2016): Added assertion.
70612 0 : ROSE_ASSERT(temp_type != NULL);
70613 :
70614 0 : temp_type->set_type_kind(optional_fortran_type_kind);
70615 : }
70616 : #if 0
70617 : else
70618 : {
70619 : // Let p_builtin_type refer to the unadorned type (no type kind).
70620 : p_builtin_type = temp_type;
70621 : }
70622 : #endif
70623 :
70624 0 : SgName name = temp_type->get_mangled();
70625 :
70626 : #if 0
70627 : printf ("Mangled type name for SgPartialFunctionModifierType = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
70628 : #endif
70629 :
70630 : // DQ (10/31/2016): Added assertion.
70631 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
70632 :
70633 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
70634 :
70635 : #if 0
70636 : printf ("In SgPartialFunctionModifierType::createType(): type from lookup_type = %p \n",t);
70637 : #endif
70638 :
70639 0 : if (t == NULL)
70640 : {
70641 0 : get_globalTypeTable()->insert_type(name,temp_type);
70642 : }
70643 : else
70644 : {
70645 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
70646 0 : if (t != temp_type)
70647 : {
70648 : #if 0
70649 : printf ("In SgPartialFunctionModifierType::createType(): deleting temp_type = %p \n",temp_type);
70650 : #endif
70651 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
70652 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
70653 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
70654 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
70655 0 : delete temp_type;
70656 : #endif
70657 0 : temp_type = NULL;
70658 : #if 0
70659 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
70660 : if (optional_fortran_type_kind != NULL)
70661 : {
70662 : p_builtin_type = NULL;
70663 : }
70664 : #endif
70665 : }
70666 :
70667 : // Reuse this tempType variable so we can use the same code below.
70668 0 : temp_type = isSgPartialFunctionModifierType(t);
70669 0 : ROSE_ASSERT(temp_type != NULL);
70670 : }
70671 :
70672 : #if 0
70673 : printf ("Leaving SgPartialFunctionModifierType::createType(): temp_type = %p \n",temp_type);
70674 : #endif
70675 :
70676 0 : return temp_type;
70677 : }
70678 :
70679 :
70680 :
70681 : // End of memberFunctionString
70682 : // Start of memberFunctionString
70683 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
70684 :
70685 : #if 1
70686 : /*! Support for mangled names (for unparser)
70687 : There are two different cases of source code for the get_mangled member function
70688 : This one is used in all but the classes containing a base type
70689 : */
70690 : // SgName SgPartialFunctionModifierType::get_mangled ( SgUnparse_Info & info )
70691 : SgName
70692 0 : SgPartialFunctionModifierType::get_mangled (void) const
70693 : {
70694 0 : ROSE_ASSERT(this != NULL);
70695 :
70696 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
70697 : // CR (3/6/2020): Now type_kind is also used for Jovial.
70698 0 : SgName name = "PartialFunctionType";
70699 0 : if (get_type_kind() != NULL)
70700 : {
70701 : // name += get_type_kind()->get_mangled();
70702 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
70703 0 : SgValueExp* value = isSgValueExp(get_type_kind());
70704 0 : if (value != NULL)
70705 : {
70706 : // name += string("_") + StringUtility::numberToString(value->get_value());
70707 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
70708 : }
70709 : else
70710 : {
70711 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
70712 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
70713 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
70714 : // a different prefix for each type of named type. It come down to is there can be multiple
70715 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
70716 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
70717 : // I think the issue is that PartialFunctionType is not defined for any of the SgNameType IR nodes.
70718 : #if 0
70719 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"PartialFunctionType");
70720 : #endif
70721 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
70722 : }
70723 : }
70724 :
70725 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
70726 : // REMOVE_ME please!
70727 0 : if (isSgTypeFixed(this))
70728 : {
70729 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
70730 0 : if (fixed_type->get_scale() != NULL)
70731 : {
70732 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
70733 0 : if (value != NULL)
70734 : {
70735 0 : name += string("_") + value->get_constant_folded_value_as_string();
70736 : }
70737 : }
70738 0 : if (fixed_type->get_fraction() != NULL)
70739 : {
70740 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
70741 0 : if (value != NULL)
70742 : {
70743 0 : name += string("_") + value->get_constant_folded_value_as_string();
70744 : }
70745 : }
70746 : }
70747 :
70748 : #if 0
70749 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
70750 : #endif
70751 :
70752 0 : return name;
70753 : }
70754 : #endif
70755 :
70756 :
70757 : // End of memberFunctionString
70758 :
70759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
70760 :
70761 0 : SgPartialFunctionModifierType* isSgPartialFunctionModifierType ( SgNode* inputDerivedClassPointer )
70762 : {
70763 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
70764 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
70765 : // So to fix this we return NULL directly when the input is NULL and avoid the
70766 : // dynamic_cast in this case. This is likely a performance improvement as well.
70767 : // return dynamic_cast<SgPartialFunctionModifierType*>(inputDerivedClassPointer);
70768 : // Milind Chabbi (8/28/2013): isSgPartialFunctionModifierType uses table-driven castability instead of c++ default dynamic_cast
70769 : // this improves the running time performance by 10-20%.
70770 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPartialFunctionModifierType*>(inputDerivedClassPointer);
70771 0 : return IS_SgPartialFunctionModifierType_FAST_MACRO(inputDerivedClassPointer);
70772 : }
70773 :
70774 : // DQ (11/8/2003): Added version of functions taking const pointer
70775 0 : const SgPartialFunctionModifierType* isSgPartialFunctionModifierType ( const SgNode* inputDerivedClassPointer )
70776 : {
70777 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
70778 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
70779 : // So to fix this we return NULL directly when the input is NULL and avoid the
70780 : // dynamic_cast in this case. This is likely a performance improvement as well.
70781 : // return dynamic_cast<const SgPartialFunctionModifierType*>(inputDerivedClassPointer);
70782 : // Milind Chabbi (8/28/2013): isSgPartialFunctionModifierType uses table-driven castability instead of c++ default dynamic_cast
70783 : // this improves the running time performance by 10-20%.
70784 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPartialFunctionModifierType*>(inputDerivedClassPointer);
70785 0 : return IS_SgPartialFunctionModifierType_FAST_MACRO(inputDerivedClassPointer);
70786 : }
70787 :
70788 :
70789 :
70790 : /* #line 70791 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70791 :
70792 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
70793 :
70794 : /**
70795 : \brief Generated destructor
70796 :
70797 : This destructor is automatically generated (by ROSETTA). This destructor
70798 : only frees memory of data members associated with the parts of the current IR node which
70799 : are NOT traversed. Those data members that are part of a traversal can be freed using
70800 : a traversal (calling this destructor on all children in a post-order traversal). Such
70801 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
70802 :
70803 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
70804 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
70805 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
70806 :
70807 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
70808 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
70809 : pointers are not yet implemented to call delete on eash pointer in the container.
70810 : (This could be done by derivation from the STL containers to define containers that
70811 : automatically deleted their members.)
70812 :
70813 : */
70814 0 : SgPartialFunctionModifierType::~SgPartialFunctionModifierType () {
70815 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
70816 :
70817 :
70818 :
70819 : }
70820 :
70821 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
70822 0 : }
70823 :
70824 :
70825 : /* #line 70826 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70826 :
70827 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
70828 :
70829 : // Generated constructor
70830 0 : SgPartialFunctionModifierType::SgPartialFunctionModifierType ( SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers )
70831 0 : : SgPartialFunctionType(return_type, has_ellipses, class_type, mfunc_specifier, ref_qualifiers)
70832 : {
70833 : #ifdef DEBUG
70834 : // printf ("In SgPartialFunctionModifierType::SgPartialFunctionModifierType (SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers) sage_class_name() = %s \n",sage_class_name());
70835 : #endif
70836 : #if 0
70837 : // debugging information!
70838 : printf ("In SgPartialFunctionModifierType::SgPartialFunctionModifierType (SgType* return_type, bool has_ellipses, SgType* class_type, unsigned int mfunc_specifier, unsigned int ref_qualifiers): this = %p = %s \n",this,this->class_name().c_str());
70839 : #endif
70840 :
70841 :
70842 :
70843 : #if 0
70844 : // DQ (7/30/2014): Call a virtual function.
70845 : std::string s = this->class_name();
70846 : #endif
70847 :
70848 : // Test the variant virtual function
70849 : // assert(T_PARTIAL_FUNCTION_MODIFIER == variant());
70850 0 : assert(T_PARTIAL_FUNCTION_MODIFIER == this->variant());
70851 0 : ROSE_ASSERT(T_PARTIAL_FUNCTION_MODIFIER == (int)(this->variantT()));
70852 0 : post_construction_initialization();
70853 :
70854 : // Test the isSgPartialFunctionModifierType() function since it has been problematic
70855 0 : assert(isSgPartialFunctionModifierType(this) != NULL);
70856 0 : }
70857 :
70858 : // Generated constructor (all data members)
70859 :
70860 : /* #line 70861 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70861 :
70862 :
70863 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
70864 :
70865 :
70866 : // ********************************************************
70867 : // member functions common across all array grammar objects
70868 : // ********************************************************
70869 :
70870 :
70871 :
70872 : /* #line 70873 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70873 :
70874 :
70875 :
70876 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
70877 :
70878 : // ********************************************************
70879 : // member functions specific to each node in the grammar
70880 : // ********************************************************
70881 :
70882 :
70883 : /* #line 70884 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
70884 :
70885 : // Start of memberFunctionString
70886 : /* #line 7984 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
70887 :
70888 :
70889 : // SgArrayType* SgArrayType::createType ( SgType* base_type, SgExpression* idx )
70890 : SgArrayType*
70891 58 : SgArrayType::createType ( SgType* base_type, SgExpression* idx, SgExpression* optional_fortran_type_kind)
70892 : {
70893 : // DQ (8/11/2010): It is OK for idx to be NULL, since it implies a declaration such as: "int array[]" which can be OK.
70894 :
70895 : // DQ (10/4/2010): I think that reference types can't have a kind parameter, so this should be NULL.
70896 58 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
70897 :
70898 : #if 0
70899 : printf ("In SgArrayType::createType() \n");
70900 : #endif
70901 :
70902 58 : SgArrayType* returnType = new SgArrayType(base_type, idx);
70903 58 : ROSE_ASSERT(returnType != NULL);
70904 :
70905 58 : SgName name = returnType->get_mangled();
70906 :
70907 : #if 0
70908 : printf ("In SgArrayType::createType(): Building an array [exp = %p] of base_type = %p = %s name = %s \n",idx,base_type,base_type->class_name().c_str(),name.str());
70909 : printf (" --- idx = %p = %s \n",idx,idx->class_name().c_str());
70910 : #endif
70911 :
70912 : // Only look for pointers to type in the global type table.
70913 58 : SgType* t = get_globalTypeTable()->lookup_type(name);
70914 :
70915 : #if 0
70916 : printf ("In SgArrayType::createType(): After get_globalTypeTable()->lookup_type(%s) t = %p \n",name.str(),t);
70917 : #endif
70918 :
70919 58 : if (t == NULL)
70920 : {
70921 : // The pointer type was not found in the type table, put it into the global type table.
70922 : #if 0
70923 : // This is too agressive and fails for some test codes!
70924 : printf ("Mangled type name for SgArrayType = %s (does NOT exist in type table) \n",name.str());
70925 : get_globalTypeTable()->insert_type(name,returnType);
70926 : #else
70927 58 : SgType* root_type = base_type->stripType();
70928 58 : ROSE_ASSERT(root_type != NULL);
70929 58 : if (handledUsingLocalTable(root_type) == false)
70930 : {
70931 : #if 0
70932 : printf ("Mangled type name for SgArrayType = %s (does NOT exist in type table) inserting it... \n",name.str());
70933 : #endif
70934 10 : get_globalTypeTable()->insert_type(name,returnType);
70935 : }
70936 : else
70937 : {
70938 : #if 0
70939 : printf ("Skip putting the SgArrayType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
70940 : #endif
70941 : }
70942 : #endif
70943 : }
70944 : else
70945 : {
70946 : // If it is already present in the type table then delete the type (so that it will remain unique).
70947 : #if 0
70948 : printf ("Mangled type name for SgArrayType = %s (already exists in type table) t = %p returnType = %p \n",name.str(),t,returnType);
70949 : #endif
70950 0 : ROSE_ASSERT(t != returnType);
70951 :
70952 : // DQ (9/25/2011): the array index can be an expression tree (not just one node) and it can have valid
70953 : // original expression trees from constant folding. So we don't want to delete the index unless we are
70954 : // going to do the job completely. so we want to:
70955 : // 1) Avoid having it be deleted by the SgArrayType destructor.
70956 : // 2) Delete it using the SageInterface::deleteAST() function.
70957 0 : if (idx != NULL)
70958 : {
70959 : #if 0
70960 : printf ("In SgArrayType::createType(): idx = %p (deleting the index subtree) \n",idx);
70961 : #endif
70962 0 : ROSE_ASSERT(idx->get_parent() == NULL);
70963 :
70964 : // Let the parent point to the SgArrayType that we will return.
70965 0 : idx->set_parent(t);
70966 :
70967 0 : returnType->set_index(NULL);
70968 : // SageInterface::deleteAST(idx);
70969 0 : SageInterface::deleteExpressionTreeWithOriginalExpressionSubtrees(idx);
70970 : idx = NULL;
70971 : }
70972 0 : ROSE_ASSERT(returnType->get_index() == NULL);
70973 :
70974 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
70975 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
70976 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
70977 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
70978 0 : delete returnType;
70979 : #endif
70980 0 : returnType = NULL;
70981 :
70982 0 : returnType = isSgArrayType(t);
70983 : }
70984 :
70985 : #if 0
70986 : printf ("In SgArrayType::createType(): idx = %p \n",idx);
70987 : #endif
70988 :
70989 : // DQ (2/20/2007): Added setting the parent (which should not have been set already)
70990 : // note also that the index expression is not required to be specified.
70991 58 : if (idx != NULL)
70992 : {
70993 : #if 0
70994 : printf ("In SgArrayType::createType(): fixing up the array index idx = %p = %s \n",idx,idx->class_name().c_str());
70995 : #endif
70996 : // DQ (9/25/2011): If we have deleted the array index then it should be listed as V_SgNode (which would be an error we would want to catch).
70997 58 : ROSE_ASSERT(idx->variantT() != V_SgNode);
70998 :
70999 58 : ROSE_ASSERT(idx->get_parent() == NULL);
71000 58 : idx->set_parent(returnType);
71001 : }
71002 :
71003 58 : return returnType;
71004 : // return new SgArrayType(base_type, idx);
71005 : }
71006 :
71007 :
71008 :
71009 : // End of memberFunctionString
71010 : // Start of memberFunctionString
71011 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
71012 :
71013 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
71014 :
71015 : SgType*
71016 149564 : SgArrayType::get_base_type () const
71017 : {
71018 149564 : ROSE_ASSERT (this != NULL);
71019 :
71020 : #if 0
71021 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71022 : // used to trigger marking transformations for the token-based unparsing.
71023 : printf ("SgArrayType::get_base_type = %p = %s \n",this,this->class_name().c_str());
71024 : #endif
71025 :
71026 149564 : return p_base_type;
71027 : }
71028 :
71029 : void
71030 0 : SgArrayType::set_base_type ( SgType* base_type )
71031 : {
71032 0 : ROSE_ASSERT (this != NULL);
71033 :
71034 : #if 0
71035 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71036 : // used to trigger marking transformations for the token-based unparsing.
71037 : printf ("SgArrayType::set_base_type = %p = %s \n",this,this->class_name().c_str());
71038 : #endif
71039 :
71040 0 : set_isModified(true);
71041 :
71042 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
71043 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
71044 : {
71045 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
71046 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
71047 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
71048 : ROSE_ASSERT(false);
71049 : #endif
71050 : }
71051 : #endif
71052 0 : p_base_type = base_type;
71053 0 : }
71054 :
71055 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
71056 :
71057 :
71058 : // End of memberFunctionString
71059 : // Start of memberFunctionString
71060 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
71061 :
71062 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
71063 :
71064 : SgExpression*
71065 37824 : SgArrayType::get_index () const
71066 : {
71067 37824 : ROSE_ASSERT (this != NULL);
71068 :
71069 : #if 0
71070 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71071 : // used to trigger marking transformations for the token-based unparsing.
71072 : printf ("SgArrayType::get_index = %p = %s \n",this,this->class_name().c_str());
71073 : #endif
71074 :
71075 37824 : return p_index;
71076 : }
71077 :
71078 : void
71079 0 : SgArrayType::set_index ( SgExpression* index )
71080 : {
71081 0 : ROSE_ASSERT (this != NULL);
71082 :
71083 : #if 0
71084 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71085 : // used to trigger marking transformations for the token-based unparsing.
71086 : printf ("SgArrayType::set_index = %p = %s \n",this,this->class_name().c_str());
71087 : #endif
71088 :
71089 0 : set_isModified(true);
71090 :
71091 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
71092 : if (p_index != NULL && index != NULL && p_index != index)
71093 : {
71094 : printf ("Warning: index = %p overwriting valid pointer p_index = %p \n",index,p_index);
71095 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
71096 : printf ("Error fails assertion (p_index != NULL && index != NULL && p_index != index) is false\n");
71097 : ROSE_ASSERT(false);
71098 : #endif
71099 : }
71100 : #endif
71101 0 : p_index = index;
71102 0 : }
71103 :
71104 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
71105 :
71106 :
71107 : // End of memberFunctionString
71108 : // Start of memberFunctionString
71109 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
71110 :
71111 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
71112 :
71113 : SgExprListExp*
71114 12 : SgArrayType::get_dim_info () const
71115 : {
71116 12 : ROSE_ASSERT (this != NULL);
71117 :
71118 : #if 0
71119 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71120 : // used to trigger marking transformations for the token-based unparsing.
71121 : printf ("SgArrayType::get_dim_info = %p = %s \n",this,this->class_name().c_str());
71122 : #endif
71123 :
71124 12 : return p_dim_info;
71125 : }
71126 :
71127 : void
71128 12 : SgArrayType::set_dim_info ( SgExprListExp* dim_info )
71129 : {
71130 12 : ROSE_ASSERT (this != NULL);
71131 :
71132 : #if 0
71133 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71134 : // used to trigger marking transformations for the token-based unparsing.
71135 : printf ("SgArrayType::set_dim_info = %p = %s \n",this,this->class_name().c_str());
71136 : #endif
71137 :
71138 12 : set_isModified(true);
71139 :
71140 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
71141 : if (p_dim_info != NULL && dim_info != NULL && p_dim_info != dim_info)
71142 : {
71143 : printf ("Warning: dim_info = %p overwriting valid pointer p_dim_info = %p \n",dim_info,p_dim_info);
71144 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
71145 : printf ("Error fails assertion (p_dim_info != NULL && dim_info != NULL && p_dim_info != dim_info) is false\n");
71146 : ROSE_ASSERT(false);
71147 : #endif
71148 : }
71149 : #endif
71150 12 : p_dim_info = dim_info;
71151 12 : }
71152 :
71153 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
71154 :
71155 :
71156 : // End of memberFunctionString
71157 : // Start of memberFunctionString
71158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
71159 :
71160 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
71161 :
71162 : int
71163 3 : SgArrayType::get_rank () const
71164 : {
71165 3 : ROSE_ASSERT (this != NULL);
71166 :
71167 : #if 0
71168 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71169 : // used to trigger marking transformations for the token-based unparsing.
71170 : printf ("SgArrayType::get_rank = %p = %s \n",this,this->class_name().c_str());
71171 : #endif
71172 :
71173 3 : return p_rank;
71174 : }
71175 :
71176 : void
71177 12 : SgArrayType::set_rank ( int rank )
71178 : {
71179 12 : ROSE_ASSERT (this != NULL);
71180 :
71181 : #if 0
71182 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71183 : // used to trigger marking transformations for the token-based unparsing.
71184 : printf ("SgArrayType::set_rank = %p = %s \n",this,this->class_name().c_str());
71185 : #endif
71186 :
71187 12 : set_isModified(true);
71188 :
71189 12 : p_rank = rank;
71190 12 : }
71191 :
71192 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
71193 :
71194 :
71195 : // End of memberFunctionString
71196 : // Start of memberFunctionString
71197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
71198 :
71199 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
71200 :
71201 : int
71202 2189 : SgArrayType::get_number_of_elements () const
71203 : {
71204 2189 : ROSE_ASSERT (this != NULL);
71205 :
71206 : #if 0
71207 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71208 : // used to trigger marking transformations for the token-based unparsing.
71209 : printf ("SgArrayType::get_number_of_elements = %p = %s \n",this,this->class_name().c_str());
71210 : #endif
71211 :
71212 2189 : return p_number_of_elements;
71213 : }
71214 :
71215 : void
71216 6606 : SgArrayType::set_number_of_elements ( int number_of_elements )
71217 : {
71218 6606 : ROSE_ASSERT (this != NULL);
71219 :
71220 : #if 0
71221 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71222 : // used to trigger marking transformations for the token-based unparsing.
71223 : printf ("SgArrayType::set_number_of_elements = %p = %s \n",this,this->class_name().c_str());
71224 : #endif
71225 :
71226 6606 : set_isModified(true);
71227 :
71228 6606 : p_number_of_elements = number_of_elements;
71229 6606 : }
71230 :
71231 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
71232 :
71233 :
71234 : // End of memberFunctionString
71235 : // Start of memberFunctionString
71236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
71237 :
71238 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
71239 :
71240 : bool
71241 25290 : SgArrayType::get_is_variable_length_array () const
71242 : {
71243 25290 : ROSE_ASSERT (this != NULL);
71244 :
71245 : #if 0
71246 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71247 : // used to trigger marking transformations for the token-based unparsing.
71248 : printf ("SgArrayType::get_is_variable_length_array = %p = %s \n",this,this->class_name().c_str());
71249 : #endif
71250 :
71251 25290 : return p_is_variable_length_array;
71252 : }
71253 :
71254 : void
71255 24 : SgArrayType::set_is_variable_length_array ( bool is_variable_length_array )
71256 : {
71257 24 : ROSE_ASSERT (this != NULL);
71258 :
71259 : #if 0
71260 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
71261 : // used to trigger marking transformations for the token-based unparsing.
71262 : printf ("SgArrayType::set_is_variable_length_array = %p = %s \n",this,this->class_name().c_str());
71263 : #endif
71264 :
71265 24 : set_isModified(true);
71266 :
71267 24 : p_is_variable_length_array = is_variable_length_array;
71268 24 : }
71269 :
71270 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
71271 :
71272 :
71273 : // End of memberFunctionString
71274 : // Start of memberFunctionString
71275 : /* #line 5863 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
71276 :
71277 :
71278 : #if 1
71279 : // DQ (3/22/2017): I would like to remove this function if possible (it is not sufficiently general).
71280 : // Note that this is used within ROSE (which might be worth checking out in more detail later).
71281 : SgName
71282 0 : SgArrayType::get_name(void) const {
71283 0 : string dimensions = "[]";
71284 0 : SgType *type = p_base_type;
71285 :
71286 0 : for (SgArrayType *array_type = isSgArrayType(type); array_type; array_type = isSgArrayType(type))
71287 : {
71288 0 : dimensions += "[]";
71289 0 : type = array_type -> get_base_type();
71290 : }
71291 :
71292 0 : string name;
71293 0 : if (isSgTypeBool(type)) {
71294 0 : name = "boolean";
71295 : }
71296 0 : else if (isSgTypeSignedChar(type)) {
71297 0 : name = "byte";
71298 : }
71299 0 : else if (isSgTypeWchar(type)) {
71300 0 : name = "char";
71301 : }
71302 : // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
71303 0 : else if (isSgTypeChar16(type)) {
71304 0 : name = "char16";
71305 : }
71306 : // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
71307 0 : else if (isSgTypeChar32(type)) {
71308 0 : name = "char32";
71309 : }
71310 0 : else if (isSgTypeInt(type)) {
71311 0 : name = "int";
71312 : }
71313 0 : else if (isSgTypeShort(type)) {
71314 0 : name = "short";
71315 : }
71316 0 : else if (isSgTypeFloat(type)) {
71317 0 : name = "float";
71318 : }
71319 0 : else if (isSgTypeLong(type)) {
71320 0 : name = "long";
71321 : }
71322 0 : else if (isSgTypeDouble(type)) {
71323 0 : name = "double";
71324 : }
71325 0 : else if (isSgTypeVoid(type)) {
71326 0 : name = "void";
71327 : }
71328 0 : else if (isSgTypeString(type)) {
71329 0 : name = "String";
71330 : }
71331 : else
71332 : {
71333 : // DQ (3/19/2016): Klocworks reports this as an issue because the result of the 2nd call to isSgNamedType()
71334 : // is not clearly the same result as the first call. The fix is to just make a single call and save the result.
71335 : // if (isSgNamedType(type))
71336 0 : SgNamedType* namedType = isSgNamedType(type);
71337 0 : if (namedType != NULL)
71338 : {
71339 : // name = isSgNamedType(type) -> get_name().getString();
71340 0 : name = namedType -> get_name().getString();
71341 : }
71342 : }
71343 :
71344 0 : name += dimensions;
71345 :
71346 0 : return SgName(name);
71347 : }
71348 : #endif
71349 :
71350 : SgName
71351 0 : SgArrayType::get_qualified_name(void) const {
71352 0 : string dimensions = "[]";
71353 0 : SgType *type = p_base_type;
71354 :
71355 0 : for (SgArrayType *array_type = isSgArrayType(type); array_type; array_type = isSgArrayType(type))
71356 : {
71357 0 : dimensions += "[]";
71358 0 : type = array_type -> get_base_type();
71359 : }
71360 :
71361 0 : string name;
71362 0 : if (isSgTypeBool(type)) {
71363 0 : name = "boolean";
71364 : }
71365 0 : else if (isSgTypeSignedChar(type)) {
71366 0 : name = "byte";
71367 : }
71368 0 : else if (isSgTypeWchar(type)) {
71369 0 : name = "char";
71370 : }
71371 : // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
71372 0 : else if (isSgTypeChar16(type)) {
71373 0 : name = "char16";
71374 : }
71375 : // DQ (2/16/2018): Adding support for char16_t and char32_t (C99 and C++11 specific types).
71376 0 : else if (isSgTypeChar32(type)) {
71377 0 : name = "char32";
71378 : }
71379 0 : else if (isSgTypeInt(type)) {
71380 0 : name = "int";
71381 : }
71382 0 : else if (isSgTypeShort(type)) {
71383 0 : name = "short";
71384 : }
71385 0 : else if (isSgTypeFloat(type)) {
71386 0 : name = "float";
71387 : }
71388 0 : else if (isSgTypeLong(type)) {
71389 0 : name = "long";
71390 : }
71391 0 : else if (isSgTypeDouble(type)) {
71392 0 : name = "double";
71393 : }
71394 0 : else if (isSgTypeVoid(type)) {
71395 0 : name = "void";
71396 : }
71397 0 : else if (isSgTypeString(type)) {
71398 0 : name = "String";
71399 : }
71400 : else
71401 : {
71402 : // DQ (3/19/2016): Klocworks reports this as an issue because the result of the 2nd call to isSgNamedType()
71403 : // is not clearly the same result as the first call. The fix is to just make a single call and save the result.
71404 : // if (isSgNamedType(type))
71405 0 : SgNamedType* namedType = isSgNamedType(type);
71406 0 : if (namedType != NULL)
71407 : {
71408 : // name = isSgNamedType(type) -> get_qualified_name().getString();
71409 0 : name = namedType -> get_qualified_name().getString();
71410 : }
71411 : }
71412 :
71413 0 : name += dimensions;
71414 :
71415 0 : return SgName(name);
71416 : }
71417 :
71418 : // DQ (6/13/2015): Added forward declaration of namespace function for constant folding.
71419 : namespace ConstantFolding
71420 : {
71421 : // ROSE_DLL_API void constantFoldingOptimization(SgNode* n, bool internalTestingAgainstFrontend = false);
71422 : ROSE_DLL_API SgValueExp* returnConstantFoldedValueExpression(SgNode* n, bool internalTestingAgainstFrontend = false);
71423 : }
71424 :
71425 : // RV (1/31/2006): Changed the form of the mangled name to include begin/end tags.
71426 : SgName
71427 17814 : SgArrayType::get_mangled(void) const
71428 : {
71429 17814 : ROSE_ASSERT(this != NULL);
71430 :
71431 17814 : const SgType* base_type = get_base_type();
71432 17814 : ROSE_ASSERT (base_type != NULL);
71433 35628 : SgName base_name = base_type->get_mangled();
71434 :
71435 : #define DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING 0
71436 :
71437 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71438 : printf ("In SgArrayType::get_mangled(): mangled base type name = %s \n",base_name.str());
71439 : #endif
71440 :
71441 : // DQ (2/14/2016): Adding support for variable length arrays.
71442 17814 : const bool is_variable_length_array = this->get_is_variable_length_array();
71443 :
71444 : #if 0
71445 : printf ("In SgArrayType::get_mangled(): is_variable_length_array = %s \n",is_variable_length_array ? "true" : "false");
71446 : #endif
71447 :
71448 17814 : const SgExpression* index_exp = get_index();
71449 17814 : SgName index_name;
71450 17814 : if (index_exp != NULL)
71451 : {
71452 : // DQ (2/12/2011): Now that we support saving the original expression in an array type's size argument
71453 : // we want to generate the name from the constant folded expression instead of the original expression.
71454 : // index_name = index_exp->unparseToString();
71455 : // printf ("In SgArrayType::get_mangled(): index_name = %s index_exp = %p = %s = %s \n",index_name.str(),index_exp,index_exp->class_name().c_str(),SageInterface::generateUniqueName(index_exp,true).c_str());
71456 : // SgUnsignedLongVal* value = isSgUnsignedLongVal(index_exp);
71457 :
71458 : // DQ (9/23/2015): This code is important to the passing of test2015_78.C for both C++98 and C++11 modes.
71459 : // In C++98 mode a cast is not present and we see a SgIntVal expression, where as for C++11 mode we see a SgUnsignedLongVal expression.
71460 : // The result was that the variable "value" below was either NULL or non-NULL and the ROSE AST was different for for C++98 as for C++11.
71461 : // This is important for the Intel C++ compiler (version 14) because it defaults to C++11 instead of C++98.
71462 : // Forcing the false branch below does at least make the C++98 and C++11 modes uniform, and allows the test code to now pass uniformally
71463 : // for both C++98 and C++11 modes, but does not really fix the problem well. We want to where ever possible evaluate the expression to
71464 : // a constant value literal, but this is part of a seperate issue specific to use of expressions in array bounds (test2015_.C).
71465 :
71466 : // DQ (6/13/2015): Changed from SgUnsignedLongVal to SgValueExp. Or maybe we need to test for more general case where we handle the contant folding case below.
71467 : // const SgValueExp* value = isSgUnsignedLongVal(index_exp);
71468 : // const SgValueExp* value = isSgValueExp(index_exp);
71469 : // const SgValueExp* value = isSgUnsignedLongVal(index_exp);
71470 : // const SgValueExp* value = isSgValueExp(index_exp);
71471 17814 : const SgValueExp* value = NULL;
71472 :
71473 : // DQ (2/12/2011): I wonder if we can enforce this...No!
71474 : // ROSE_ASSERT(value != NULL);
71475 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71476 : printf ("In SgArrayType::get_mangled() index_exp = %p = %s value = %p \n",index_exp,index_exp->class_name().c_str(),value);
71477 : #endif
71478 17814 : if (value != NULL)
71479 : {
71480 : // index_name = StringUtility::numberToString(value->get_value());
71481 : // printf ("In SgArrayType::get_mangled() (special case of index as numberToString): index_name = %s index_exp = %p = %s = %s \n",index_name.str(),index_exp,index_exp->class_name().c_str(),SageInterface::generateUniqueName(index_exp,true).c_str());
71482 :
71483 : index_name = value->get_constant_folded_value_as_string().c_str();
71484 : #if 1
71485 : printf ("In SgArrayType::get_mangled() (special case of index as get_constant_folded_value_as_string): index_name = %s index_exp = %p = %s = %s \n",index_name.str(),index_exp,index_exp->class_name().c_str(),SageInterface::generateUniqueName(index_exp,true).c_str());
71486 : #endif
71487 : }
71488 : else
71489 : {
71490 : // DQ (1/27/2015): Debugging test2015_05.C. Not clear if this handles the case were there
71491 : // might be a more complex array index expressions that could have the same name.
71492 : // index_name = index_exp->unparseToString();
71493 17814 : const SgVarRefExp* varRefExp = isSgVarRefExp(index_exp);
71494 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71495 : printf ("In SgArrayType::get_mangled() varRefExp = %p \n",varRefExp);
71496 : #endif
71497 17814 : if (varRefExp != NULL)
71498 : {
71499 : // index_name = index_exp->unparseToString();
71500 1186 : SgSymbol* index_symbol = varRefExp->get_symbol();
71501 1186 : ROSE_ASSERT(index_symbol != NULL);
71502 : #if 0
71503 : printf ("In SgArrayType::createType(): index_symbol = %p = %s \n",index_symbol,index_symbol->class_name().c_str());
71504 : #endif
71505 1186 : SgVariableSymbol* variableSymbol = isSgVariableSymbol(index_symbol);
71506 1186 : SgInitializedName* index_declaration = variableSymbol->get_declaration();
71507 1186 : ROSE_ASSERT(index_declaration != NULL);
71508 : #if 0
71509 : printf ("In SgArrayType::createType(): index_declaration = %p = %s \n",index_declaration,index_declaration->class_name().c_str());
71510 : #endif
71511 : #if 0
71512 : SgScopeStatement* associatedScope = index_declaration->get_scope();
71513 : ROSE_ASSERT(associatedScope != NULL);
71514 : #if 0
71515 : printf ("In SgArrayType::createType(): associatedScope = %p = %s \n",associatedScope,associatedScope->class_name().c_str());
71516 : #endif
71517 : // t = associatedScope->get_type_table()->lookup_type(name);
71518 : // index_name = associatedScope->get_mangled_name();
71519 : #else
71520 : // DQ (2/14/2016): Adding support for VLA types (if we evaluate the mangled name we will cause endless recursion).
71521 : // index_name = index_declaration->get_mangled_name();
71522 1186 : if (is_variable_length_array == true)
71523 : {
71524 54 : index_name = "vla_dimention";
71525 : }
71526 : else
71527 : {
71528 1132 : index_name = index_declaration->get_mangled_name();
71529 : }
71530 : #endif
71531 : #if 0
71532 : printf ("SgInitializedName part of index_name = %s \n",index_name.str());
71533 : #endif
71534 1186 : index_name += "_";
71535 1186 : index_name += index_exp->unparseToString();
71536 : #if 0
71537 : printf ("final index_name = %s \n",index_name.str());
71538 : #endif
71539 : }
71540 : else
71541 : {
71542 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71543 : printf ("In SgArrayType::get_mangled() index_exp = %p = %s \n",index_exp,index_exp->class_name().c_str());
71544 : #endif
71545 : #if 0
71546 : // DQ (6/13/2015): Original code causing expressions to be mixed into the mangled names.
71547 : index_name = index_exp->unparseToString();
71548 : #else
71549 : // DQ (6/13/2015): bugfix to permit constant valued expressions to be evaluated to constants and the constants used in the mangled names.
71550 16628 : SgExpression* original_constant_index_exp = get_index();
71551 16628 : ROSE_ASSERT(original_constant_index_exp != NULL);
71552 :
71553 : // To narrow this further we could constrain the lhs and rhs to be SgInitVal nodes.
71554 :
71555 : #define TEST_CONSTANT_FOLDING_IN_NAME_MANGLING_OF_TYPES 0
71556 :
71557 : #if TEST_CONSTANT_FOLDING_IN_NAME_MANGLING_OF_TYPES
71558 : // DQ (6/14/2015): This is test code to evaluate if we want to use the constant folding in the name mangling.
71559 : // This appears to cause test2011_117.C to fail (C++ template issue) (also similar test code in test2014_143.C).
71560 :
71561 : // if (isSgAddOp(original_constant_index_exp) != NULL && true)
71562 : if (true)
71563 : #else
71564 : // DQ (6/14/2015): This predicate will turn off this support for constant folding in the name mangling.
71565 16628 : if (isSgAddOp(original_constant_index_exp) != NULL && false)
71566 : #endif
71567 : {
71568 : // This is a narrow case where this should work, but we need more general support.
71569 :
71570 : // Build a shadow copy of the expression so that we can do the constant folding without sideffects on the array index expression.
71571 : // SgExpression* shadow_expr = SageInterface::deepCopy<SgExpression>(original_constant_index_exp);
71572 : SgExpression* shadow_expr = original_constant_index_exp;
71573 : ROSE_ASSERT(shadow_expr != NULL);
71574 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71575 : printf (" --- BEFORE: shadow_expr = %p = %s \n",shadow_expr,shadow_expr->class_name().c_str());
71576 : printf (" --- BEFORE: shadow_expr->get_parent() = %p \n",shadow_expr->get_parent());
71577 : #endif
71578 : // ConstantFolding::constantFoldingOptimization(const_cast<SgExpression*>(index_exp),false);
71579 : // ConstantFolding::constantFoldingOptimization(original_constant_index_exp,false);
71580 : // ConstantFolding::constantFoldingOptimization(shadow_expr,false);
71581 :
71582 : // DQ (6/13/2015): Added support to return the SgValueExp holding the constant folded value.
71583 : // Note that constant folding will have to be extended to support more generality before this will work well.
71584 : SgExpression* shadow_constant_value_exp = ConstantFolding::returnConstantFoldedValueExpression(shadow_expr,false);
71585 : // index_name = "unknown_constant_valued_index";
71586 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71587 : if (shadow_constant_value_exp != NULL)
71588 : {
71589 : printf (" --- AFTER: shadow_constant_value_exp->get_parent() = %p \n",shadow_constant_value_exp->get_parent());
71590 : }
71591 : #endif
71592 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71593 : printf (" --- AFTER: shadow_expr = %p = %s \n",shadow_expr,shadow_expr->class_name().c_str());
71594 : printf (" --- AFTER: shadow_constant_value_exp = %p = %s \n",shadow_constant_value_exp,shadow_constant_value_exp != NULL ? shadow_constant_value_exp->class_name().c_str() : "null");
71595 : #endif
71596 : // SgExpression* shadow_constant_value_exp = shadow_expr;
71597 : SgValueExp* shadow_constant_value = isSgValueExp(shadow_constant_value_exp);
71598 : // ROSE_ASSERT(shadow_constant_value != NULL);
71599 : // index_name = shadow_constant_value->get_constant_folded_value_as_string().c_str();
71600 : if (shadow_constant_value != NULL)
71601 : {
71602 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71603 : printf ("Generate string from shadow_constant_value->get_constant_folded_value_as_string() \n");
71604 : #endif
71605 : index_name = shadow_constant_value->get_constant_folded_value_as_string().c_str();
71606 : }
71607 : else
71608 : {
71609 : // This may be the case where ConstantFolding::returnConstantFoldedValueExpression() returned a NULL pointer.
71610 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71611 : printf ("Using backup plan #1: index_exp->unparseToString() \n");
71612 : #endif
71613 : index_name = index_exp->unparseToString();
71614 : }
71615 :
71616 : // Remove node used to hold the constant value expression.
71617 : delete shadow_constant_value_exp;
71618 : shadow_constant_value_exp = NULL;
71619 : shadow_constant_value = NULL;
71620 :
71621 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71622 : SgExpression* constant_value_index_exp = get_index();
71623 : printf ("constant_value_index_exp = %p = %s \n",constant_value_index_exp,constant_value_index_exp->class_name().c_str());
71624 : #endif
71625 : // SgValueExp* constant_value = isSgValueExp(constant_value_index_exp);
71626 : // Now this should not be a constant value (since we now support in remaining the original expression).
71627 : // ROSE_ASSERT(constant_value != NULL);
71628 : // ROSE_ASSERT(constant_value == NULL);
71629 : // index_name = constant_value->get_constant_folded_value_as_string().c_str();
71630 : #endif
71631 : }
71632 : else
71633 : {
71634 : // DQ (6/13/2015): Original code causing expressions to be mixed into the mangled names.
71635 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71636 : printf ("Using backup plan #2: index_exp->unparseToString() \n");
71637 : #endif
71638 17516 : index_name = index_exp->unparseToString();
71639 : }
71640 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71641 : printf ("In SgArrayType::get_mangled(): after constant folding: index_name = %s \n",index_name.str());
71642 : #endif
71643 : }
71644 : #if DEBUG_ARRAY_TYPE_MANGLED_NAME_WITH_CONSTANT_FOLDING
71645 : printf ("In SgArrayType::get_mangled(): index_name = %s index_exp = %p = %s = %s \n",index_name.str(),index_exp,index_exp->class_name().c_str(),SageInterface::generateUniqueName(index_exp,true).c_str());
71646 : #endif
71647 : }
71648 : }
71649 :
71650 : // DQ (6/21/2006): Use is_null() instead of counting the size (and fixed case were it is null)
71651 : // ROSE_ASSERT (base_name.get_length ());
71652 17814 : if (base_name.is_null() == true)
71653 : {
71654 : // This happens for code such as: "typedef struct {int id; } *XYZ;"
71655 : // printf ("Warning: In SgArrayType::get_mangled(), empty base type name found \n");
71656 0 : base_name = "unnamed_base_type";
71657 : }
71658 17814 : ROSE_ASSERT (base_name.is_null() == false);
71659 :
71660 17814 : if (index_name.is_null() == true)
71661 : {
71662 : // This happens for code such as: "typedef struct {int id; } *XYZ;"
71663 : // printf ("Warning: In SgArrayType::get_mangled(), no empty base type name found \n");
71664 2136 : index_name = "unnamed_index";
71665 : }
71666 17814 : ROSE_ASSERT (base_name.is_null() == false);
71667 :
71668 17814 : SgName mangled_name;
71669 17814 : mangled_name << "_Ab_"
71670 35628 : << base_name.str ()
71671 35628 : << "_index_"
71672 35628 : << index_name.str ()
71673 35628 : << "_Ae_";
71674 :
71675 : #if 0
71676 : printf ("SgArrayType::get_mangled(): mangled_name = %s \n",mangled_name.str());
71677 : #endif
71678 :
71679 35628 : return mangled_name;
71680 : }
71681 :
71682 :
71683 :
71684 : // End of memberFunctionString
71685 : // Start of memberFunctionString
71686 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
71687 :
71688 : // *** COMMON CODE SECTION BEGINS HERE ***
71689 :
71690 : #if 0
71691 : int
71692 : SgArrayType::getVariant() const
71693 : {
71694 : // This function is used in ROSE while "variant()" is used in SAGE
71695 : assert(this != NULL);
71696 : return variant();
71697 : }
71698 : #endif
71699 :
71700 : // This function is used in ROSE in treeTraversal code
71701 : // eventually replaces getVariant() and variant()
71702 : // though after variant() has been removed for a while we will
71703 : // want to change the name of variantT() back to variant()
71704 : // (since the "T" was ment to stand for temporary).
71705 : // When this happens the variantT() will be depricated.
71706 : VariantT
71707 6978890 : SgArrayType::variantT() const
71708 : {
71709 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
71710 6978890 : ROSE_ASSERT(this != NULL);
71711 6978890 : return V_SgArrayType;
71712 : }
71713 :
71714 : #if 0
71715 : int
71716 : SgArrayType::variant() const
71717 : {
71718 : // This function is used in SAGE
71719 : ROSE_ASSERT(this != NULL);
71720 : return T_ARRAY;
71721 : }
71722 : #endif
71723 :
71724 : ROSE_DLL_API const char*
71725 0 : SgArrayType::sage_class_name() const
71726 : {
71727 0 : ROSE_ASSERT(this != NULL);
71728 0 : return "SgArrayType";
71729 : }
71730 :
71731 : std::string
71732 6345 : SgArrayType::class_name() const
71733 : {
71734 6345 : ROSE_ASSERT(this != NULL);
71735 6345 : return "SgArrayType";
71736 : }
71737 :
71738 : // DQ (11/26/2005): Support for visitor pattern mechanims
71739 : // (inferior to ROSE traversal mechanism, experimental).
71740 : void
71741 14533 : SgArrayType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
71742 : {
71743 14533 : ROSE_ASSERT(this != NULL);
71744 14533 : visitor.visit(this);
71745 14533 : }
71746 :
71747 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
71748 0 : void SgArrayType::accept (ROSE_VisitorPattern & visitor) {
71749 0 : ROSE_ASSERT(this != NULL);
71750 0 : visitor.visit(this);
71751 0 : }
71752 :
71753 : SgArrayType*
71754 0 : SgArrayType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
71755 : {
71756 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
71757 : // This function is currently only supported for the AST used the represent Binary executables.
71758 : if (0 /* isSgAsmNode(this) != NULL */)
71759 : {
71760 : // Support for regex specification.
71761 : std::string prefixCode = "REGEX:";
71762 : addNewAttribute(prefixCode + s,a);
71763 : }
71764 : #endif
71765 :
71766 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
71767 0 : return this;
71768 : }
71769 :
71770 : // *** COMMON CODE SECTION ENDS HERE ***
71771 :
71772 :
71773 : // End of memberFunctionString
71774 : // Start of memberFunctionString
71775 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
71776 :
71777 :
71778 : #if 0
71779 : //! Error checking support
71780 : /*! Verifies the following:
71781 : - working getVariant() member function
71782 : - calls base class's error() member function
71783 : Every class has one of these functions.
71784 : */
71785 : bool
71786 : SgArrayType::error()
71787 : {
71788 : // Put error checking here
71789 :
71790 : ROSE_ASSERT (this != NULL);
71791 : if (getVariant() != T_ARRAY)
71792 : {
71793 : printf ("Error in SgArrayType::error(): SgArrayType object has a %s variant \n",
71794 : Cxx_GrammarTerminalNames[getVariant()].name);
71795 : // printf ("Error in SgArrayType::error() \n");
71796 : ROSE_ABORT();
71797 : }
71798 :
71799 : ROSE_ASSERT (getVariant() == T_ARRAY);
71800 : return SgType::error();
71801 : }
71802 : #endif
71803 :
71804 :
71805 :
71806 : // End of memberFunctionString
71807 :
71808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
71809 :
71810 202287000 : SgArrayType* isSgArrayType ( SgNode* inputDerivedClassPointer )
71811 : {
71812 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
71813 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
71814 : // So to fix this we return NULL directly when the input is NULL and avoid the
71815 : // dynamic_cast in this case. This is likely a performance improvement as well.
71816 : // return dynamic_cast<SgArrayType*>(inputDerivedClassPointer);
71817 : // Milind Chabbi (8/28/2013): isSgArrayType uses table-driven castability instead of c++ default dynamic_cast
71818 : // this improves the running time performance by 10-20%.
71819 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgArrayType*>(inputDerivedClassPointer);
71820 202287000 : return IS_SgArrayType_FAST_MACRO(inputDerivedClassPointer);
71821 : }
71822 :
71823 : // DQ (11/8/2003): Added version of functions taking const pointer
71824 52076 : const SgArrayType* isSgArrayType ( const SgNode* inputDerivedClassPointer )
71825 : {
71826 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
71827 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
71828 : // So to fix this we return NULL directly when the input is NULL and avoid the
71829 : // dynamic_cast in this case. This is likely a performance improvement as well.
71830 : // return dynamic_cast<const SgArrayType*>(inputDerivedClassPointer);
71831 : // Milind Chabbi (8/28/2013): isSgArrayType uses table-driven castability instead of c++ default dynamic_cast
71832 : // this improves the running time performance by 10-20%.
71833 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgArrayType*>(inputDerivedClassPointer);
71834 52076 : return IS_SgArrayType_FAST_MACRO(inputDerivedClassPointer);
71835 : }
71836 :
71837 :
71838 :
71839 : /* #line 71840 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
71840 :
71841 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
71842 :
71843 : /**
71844 : \brief Generated destructor
71845 :
71846 : This destructor is automatically generated (by ROSETTA). This destructor
71847 : only frees memory of data members associated with the parts of the current IR node which
71848 : are NOT traversed. Those data members that are part of a traversal can be freed using
71849 : a traversal (calling this destructor on all children in a post-order traversal). Such
71850 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
71851 :
71852 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
71853 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
71854 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
71855 :
71856 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
71857 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
71858 : pointers are not yet implemented to call delete on eash pointer in the container.
71859 : (This could be done by derivation from the STL containers to define containers that
71860 : automatically deleted their members.)
71861 :
71862 : */
71863 432 : SgArrayType::~SgArrayType () {
71864 216 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
71865 :
71866 216 : if (p_index && p_index->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_index; }
71867 216 : if (p_dim_info && p_dim_info->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_dim_info; }
71868 :
71869 : // case: not a listType for base_type
71870 216 : p_base_type = NULL; // non list case
71871 : // case: not a listType for index
71872 216 : p_index = NULL; // non list case
71873 : // case: not a listType for dim_info
71874 216 : p_dim_info = NULL; // non list case
71875 : // case: not a listType for rank
71876 216 : p_rank = 0; // non list case
71877 : // case: not a listType for number_of_elements
71878 216 : p_number_of_elements = 0; // non list case
71879 : // case: not a listType for is_variable_length_array
71880 216 : p_is_variable_length_array = false; // non list case
71881 :
71882 : }
71883 :
71884 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
71885 432 : }
71886 :
71887 :
71888 : /* #line 71889 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
71889 :
71890 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
71891 :
71892 : // Generated constructor
71893 6676 : SgArrayType::SgArrayType ( SgType* base_type, SgExpression* index )
71894 6676 : : SgType()
71895 : {
71896 : #ifdef DEBUG
71897 : // printf ("In SgArrayType::SgArrayType (SgType* base_type, SgExpression* index) sage_class_name() = %s \n",sage_class_name());
71898 : #endif
71899 : #if 0
71900 : // debugging information!
71901 : printf ("In SgArrayType::SgArrayType (SgType* base_type, SgExpression* index): this = %p = %s \n",this,this->class_name().c_str());
71902 : #endif
71903 :
71904 6676 : p_base_type = base_type;
71905 6676 : p_index = index;
71906 6676 : p_dim_info = NULL;
71907 6676 : p_rank = 0;
71908 6676 : p_number_of_elements = 0;
71909 6676 : p_is_variable_length_array = false;
71910 :
71911 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
71912 :
71913 : #if 0
71914 : // DQ (7/30/2014): Call a virtual function.
71915 : std::string s = this->class_name();
71916 : #endif
71917 :
71918 : // Test the variant virtual function
71919 : // assert(T_ARRAY == variant());
71920 6676 : assert(T_ARRAY == this->variant());
71921 6676 : ROSE_ASSERT(T_ARRAY == (int)(this->variantT()));
71922 6676 : post_construction_initialization();
71923 :
71924 : // Test the isSgArrayType() function since it has been problematic
71925 6676 : assert(isSgArrayType(this) != NULL);
71926 6676 : }
71927 :
71928 : // Generated constructor (all data members)
71929 :
71930 : /* #line 71931 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
71931 :
71932 :
71933 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
71934 :
71935 :
71936 : // ********************************************************
71937 : // member functions common across all array grammar objects
71938 : // ********************************************************
71939 :
71940 :
71941 :
71942 : /* #line 71943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
71943 :
71944 :
71945 :
71946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
71947 :
71948 : // ********************************************************
71949 : // member functions specific to each node in the grammar
71950 : // ********************************************************
71951 :
71952 :
71953 : /* #line 71954 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
71954 :
71955 : // Start of memberFunctionString
71956 :
71957 :
71958 : // End of memberFunctionString
71959 : // Start of memberFunctionString
71960 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
71961 :
71962 : // *** COMMON CODE SECTION BEGINS HERE ***
71963 :
71964 : #if 0
71965 : int
71966 : SgTypeEllipse::getVariant() const
71967 : {
71968 : // This function is used in ROSE while "variant()" is used in SAGE
71969 : assert(this != NULL);
71970 : return variant();
71971 : }
71972 : #endif
71973 :
71974 : // This function is used in ROSE in treeTraversal code
71975 : // eventually replaces getVariant() and variant()
71976 : // though after variant() has been removed for a while we will
71977 : // want to change the name of variantT() back to variant()
71978 : // (since the "T" was ment to stand for temporary).
71979 : // When this happens the variantT() will be depricated.
71980 : VariantT
71981 16141500 : SgTypeEllipse::variantT() const
71982 : {
71983 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
71984 16141500 : ROSE_ASSERT(this != NULL);
71985 16141500 : return V_SgTypeEllipse;
71986 : }
71987 :
71988 : #if 0
71989 : int
71990 : SgTypeEllipse::variant() const
71991 : {
71992 : // This function is used in SAGE
71993 : ROSE_ASSERT(this != NULL);
71994 : return T_ELLIPSE;
71995 : }
71996 : #endif
71997 :
71998 : ROSE_DLL_API const char*
71999 0 : SgTypeEllipse::sage_class_name() const
72000 : {
72001 0 : ROSE_ASSERT(this != NULL);
72002 0 : return "SgTypeEllipse";
72003 : }
72004 :
72005 : std::string
72006 188 : SgTypeEllipse::class_name() const
72007 : {
72008 188 : ROSE_ASSERT(this != NULL);
72009 188 : return "SgTypeEllipse";
72010 : }
72011 :
72012 : // DQ (11/26/2005): Support for visitor pattern mechanims
72013 : // (inferior to ROSE traversal mechanism, experimental).
72014 : void
72015 194 : SgTypeEllipse::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
72016 : {
72017 194 : ROSE_ASSERT(this != NULL);
72018 194 : visitor.visit(this);
72019 194 : }
72020 :
72021 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
72022 0 : void SgTypeEllipse::accept (ROSE_VisitorPattern & visitor) {
72023 0 : ROSE_ASSERT(this != NULL);
72024 0 : visitor.visit(this);
72025 0 : }
72026 :
72027 : SgTypeEllipse*
72028 0 : SgTypeEllipse::addRegExpAttribute(std::string s, AstRegExAttribute* a)
72029 : {
72030 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
72031 : // This function is currently only supported for the AST used the represent Binary executables.
72032 : if (0 /* isSgAsmNode(this) != NULL */)
72033 : {
72034 : // Support for regex specification.
72035 : std::string prefixCode = "REGEX:";
72036 : addNewAttribute(prefixCode + s,a);
72037 : }
72038 : #endif
72039 :
72040 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
72041 0 : return this;
72042 : }
72043 :
72044 : // *** COMMON CODE SECTION ENDS HERE ***
72045 :
72046 :
72047 : // End of memberFunctionString
72048 : // Start of memberFunctionString
72049 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
72050 :
72051 :
72052 : #if 0
72053 : //! Error checking support
72054 : /*! Verifies the following:
72055 : - working getVariant() member function
72056 : - calls base class's error() member function
72057 : Every class has one of these functions.
72058 : */
72059 : bool
72060 : SgTypeEllipse::error()
72061 : {
72062 : // Put error checking here
72063 :
72064 : ROSE_ASSERT (this != NULL);
72065 : if (getVariant() != T_ELLIPSE)
72066 : {
72067 : printf ("Error in SgTypeEllipse::error(): SgTypeEllipse object has a %s variant \n",
72068 : Cxx_GrammarTerminalNames[getVariant()].name);
72069 : // printf ("Error in SgTypeEllipse::error() \n");
72070 : ROSE_ABORT();
72071 : }
72072 :
72073 : ROSE_ASSERT (getVariant() == T_ELLIPSE);
72074 : return SgType::error();
72075 : }
72076 : #endif
72077 :
72078 :
72079 :
72080 : // End of memberFunctionString
72081 : // Start of memberFunctionString
72082 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
72083 :
72084 :
72085 : // DQ (1/31/2006): Modified to build all types in the memory pools
72086 : // SgTypeEllipse SgTypeEllipse::builtin_type;
72087 : // SgTypeEllipse* SgTypeEllipse::builtin_type = new SgTypeEllipse();
72088 : SgTypeEllipse* SgTypeEllipse::p_builtin_type = NULL;
72089 :
72090 :
72091 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
72092 : // SgTypeEllipse* SgTypeEllipse::createType(void)
72093 : SgTypeEllipse*
72094 28336 : SgTypeEllipse::createType(SgExpression* optional_fortran_type_kind)
72095 : {
72096 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
72097 : // is not called (likely because static initialization is compiler dependent).
72098 : // DQ (1/31/2006): Modified to build all types in the memory pools
72099 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
72100 : // return &builtin_type;
72101 :
72102 : #if 0
72103 : printf ("In SgTypeEllipse::createType() (COMMON_CREATE_TYPE) \n");
72104 : #endif
72105 :
72106 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
72107 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
72108 :
72109 28336 : SgTypeEllipse* temp_type = new SgTypeEllipse();
72110 :
72111 : #if 0
72112 : printf ("In SgTypeEllipse::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
72113 : #endif
72114 :
72115 : // DQ (10/31/2016): Added assertion.
72116 28336 : ROSE_ASSERT(temp_type != NULL);
72117 :
72118 28336 : if (optional_fortran_type_kind != NULL)
72119 : {
72120 : // DQ (10/31/2016): Added assertion.
72121 0 : ROSE_ASSERT(temp_type != NULL);
72122 :
72123 0 : temp_type->set_type_kind(optional_fortran_type_kind);
72124 : }
72125 : #if 0
72126 : else
72127 : {
72128 : // Let p_builtin_type refer to the unadorned type (no type kind).
72129 : p_builtin_type = temp_type;
72130 : }
72131 : #endif
72132 :
72133 28336 : SgName name = temp_type->get_mangled();
72134 :
72135 : #if 0
72136 : printf ("Mangled type name for SgTypeEllipse = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
72137 : #endif
72138 :
72139 : // DQ (10/31/2016): Added assertion.
72140 28336 : ROSE_ASSERT(get_globalTypeTable() != NULL);
72141 :
72142 28336 : SgType* t = get_globalTypeTable()->lookup_type(name);
72143 :
72144 : #if 0
72145 : printf ("In SgTypeEllipse::createType(): type from lookup_type = %p \n",t);
72146 : #endif
72147 :
72148 28336 : if (t == NULL)
72149 : {
72150 208 : get_globalTypeTable()->insert_type(name,temp_type);
72151 : }
72152 : else
72153 : {
72154 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
72155 28128 : if (t != temp_type)
72156 : {
72157 : #if 0
72158 : printf ("In SgTypeEllipse::createType(): deleting temp_type = %p \n",temp_type);
72159 : #endif
72160 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
72161 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
72162 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
72163 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
72164 28128 : delete temp_type;
72165 : #endif
72166 28128 : temp_type = NULL;
72167 : #if 0
72168 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
72169 : if (optional_fortran_type_kind != NULL)
72170 : {
72171 : p_builtin_type = NULL;
72172 : }
72173 : #endif
72174 : }
72175 :
72176 : // Reuse this tempType variable so we can use the same code below.
72177 28128 : temp_type = isSgTypeEllipse(t);
72178 28128 : ROSE_ASSERT(temp_type != NULL);
72179 : }
72180 :
72181 : #if 0
72182 : printf ("Leaving SgTypeEllipse::createType(): temp_type = %p \n",temp_type);
72183 : #endif
72184 :
72185 28336 : return temp_type;
72186 : }
72187 :
72188 :
72189 :
72190 : // End of memberFunctionString
72191 : // Start of memberFunctionString
72192 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
72193 :
72194 : #if 1
72195 : /*! Support for mangled names (for unparser)
72196 : There are two different cases of source code for the get_mangled member function
72197 : This one is used in all but the classes containing a base type
72198 : */
72199 : // SgName SgTypeEllipse::get_mangled ( SgUnparse_Info & info )
72200 : SgName
72201 74763 : SgTypeEllipse::get_mangled (void) const
72202 : {
72203 74763 : ROSE_ASSERT(this != NULL);
72204 :
72205 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
72206 : // CR (3/6/2020): Now type_kind is also used for Jovial.
72207 74763 : SgName name = "e";
72208 74763 : if (get_type_kind() != NULL)
72209 : {
72210 : // name += get_type_kind()->get_mangled();
72211 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
72212 0 : SgValueExp* value = isSgValueExp(get_type_kind());
72213 0 : if (value != NULL)
72214 : {
72215 : // name += string("_") + StringUtility::numberToString(value->get_value());
72216 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
72217 : }
72218 : else
72219 : {
72220 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
72221 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
72222 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
72223 : // a different prefix for each type of named type. It come down to is there can be multiple
72224 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
72225 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
72226 : // I think the issue is that e is not defined for any of the SgNameType IR nodes.
72227 : #if 0
72228 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"e");
72229 : #endif
72230 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
72231 : }
72232 : }
72233 :
72234 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
72235 : // REMOVE_ME please!
72236 74763 : if (isSgTypeFixed(this))
72237 : {
72238 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
72239 0 : if (fixed_type->get_scale() != NULL)
72240 : {
72241 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
72242 0 : if (value != NULL)
72243 : {
72244 0 : name += string("_") + value->get_constant_folded_value_as_string();
72245 : }
72246 : }
72247 0 : if (fixed_type->get_fraction() != NULL)
72248 : {
72249 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
72250 0 : if (value != NULL)
72251 : {
72252 0 : name += string("_") + value->get_constant_folded_value_as_string();
72253 : }
72254 : }
72255 : }
72256 :
72257 : #if 0
72258 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
72259 : #endif
72260 :
72261 74763 : return name;
72262 : }
72263 : #endif
72264 :
72265 :
72266 : // End of memberFunctionString
72267 :
72268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
72269 :
72270 102421 : SgTypeEllipse* isSgTypeEllipse ( SgNode* inputDerivedClassPointer )
72271 : {
72272 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
72273 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
72274 : // So to fix this we return NULL directly when the input is NULL and avoid the
72275 : // dynamic_cast in this case. This is likely a performance improvement as well.
72276 : // return dynamic_cast<SgTypeEllipse*>(inputDerivedClassPointer);
72277 : // Milind Chabbi (8/28/2013): isSgTypeEllipse uses table-driven castability instead of c++ default dynamic_cast
72278 : // this improves the running time performance by 10-20%.
72279 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeEllipse*>(inputDerivedClassPointer);
72280 102421 : return IS_SgTypeEllipse_FAST_MACRO(inputDerivedClassPointer);
72281 : }
72282 :
72283 : // DQ (11/8/2003): Added version of functions taking const pointer
72284 0 : const SgTypeEllipse* isSgTypeEllipse ( const SgNode* inputDerivedClassPointer )
72285 : {
72286 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
72287 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
72288 : // So to fix this we return NULL directly when the input is NULL and avoid the
72289 : // dynamic_cast in this case. This is likely a performance improvement as well.
72290 : // return dynamic_cast<const SgTypeEllipse*>(inputDerivedClassPointer);
72291 : // Milind Chabbi (8/28/2013): isSgTypeEllipse uses table-driven castability instead of c++ default dynamic_cast
72292 : // this improves the running time performance by 10-20%.
72293 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeEllipse*>(inputDerivedClassPointer);
72294 0 : return IS_SgTypeEllipse_FAST_MACRO(inputDerivedClassPointer);
72295 : }
72296 :
72297 :
72298 :
72299 : /* #line 72300 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
72300 :
72301 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
72302 :
72303 : /**
72304 : \brief Generated destructor
72305 :
72306 : This destructor is automatically generated (by ROSETTA). This destructor
72307 : only frees memory of data members associated with the parts of the current IR node which
72308 : are NOT traversed. Those data members that are part of a traversal can be freed using
72309 : a traversal (calling this destructor on all children in a post-order traversal). Such
72310 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
72311 :
72312 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
72313 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
72314 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
72315 :
72316 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
72317 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
72318 : pointers are not yet implemented to call delete on eash pointer in the container.
72319 : (This could be done by derivation from the STL containers to define containers that
72320 : automatically deleted their members.)
72321 :
72322 : */
72323 56264 : SgTypeEllipse::~SgTypeEllipse () {
72324 28132 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
72325 :
72326 :
72327 :
72328 : }
72329 :
72330 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
72331 56264 : }
72332 :
72333 :
72334 : /* #line 72335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
72335 :
72336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
72337 :
72338 : // Generated constructor
72339 28336 : SgTypeEllipse::SgTypeEllipse ( )
72340 28336 : : SgType()
72341 : {
72342 : #ifdef DEBUG
72343 : // printf ("In SgTypeEllipse::SgTypeEllipse () sage_class_name() = %s \n",sage_class_name());
72344 : #endif
72345 : #if 0
72346 : // debugging information!
72347 : printf ("In SgTypeEllipse::SgTypeEllipse (): this = %p = %s \n",this,this->class_name().c_str());
72348 : #endif
72349 :
72350 :
72351 :
72352 : #if 0
72353 : // DQ (7/30/2014): Call a virtual function.
72354 : std::string s = this->class_name();
72355 : #endif
72356 :
72357 : // Test the variant virtual function
72358 : // assert(T_ELLIPSE == variant());
72359 28336 : assert(T_ELLIPSE == this->variant());
72360 28336 : ROSE_ASSERT(T_ELLIPSE == (int)(this->variantT()));
72361 28336 : post_construction_initialization();
72362 :
72363 : // Test the isSgTypeEllipse() function since it has been problematic
72364 28336 : assert(isSgTypeEllipse(this) != NULL);
72365 28336 : }
72366 :
72367 : // Generated constructor (all data members)
72368 :
72369 : /* #line 72370 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
72370 :
72371 :
72372 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
72373 :
72374 :
72375 : // ********************************************************
72376 : // member functions common across all array grammar objects
72377 : // ********************************************************
72378 :
72379 :
72380 :
72381 : /* #line 72382 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
72382 :
72383 :
72384 :
72385 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
72386 :
72387 : // ********************************************************
72388 : // member functions specific to each node in the grammar
72389 : // ********************************************************
72390 :
72391 :
72392 : /* #line 72393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
72393 :
72394 : // Start of memberFunctionString
72395 : /* #line 7349 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
72396 :
72397 :
72398 : SgTemplateType*
72399 0 : SgTemplateType::createType(SgTemplateDeclaration* cd, SgExpression* optional_fortran_type_kind)
72400 : {
72401 0 : ROSE_ASSERT(cd != NULL);
72402 :
72403 : // DQ (10/4/2010): I think that pointer types can't have a kind parameter, so this should be NULL.
72404 0 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
72405 :
72406 0 : printf ("SgTemplateType::createType(SgTemplateDeclaration*,SgExpression*) implemented to return NULL \n");
72407 0 : ROSE_ASSERT(false);
72408 :
72409 : // return (SgTemplateType*) cd->get_type();
72410 : return NULL;
72411 : }
72412 :
72413 :
72414 :
72415 : // End of memberFunctionString
72416 : // Start of memberFunctionString
72417 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72418 :
72419 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72420 :
72421 : SgName
72422 0 : SgTemplateType::get_name () const
72423 : {
72424 0 : ROSE_ASSERT (this != NULL);
72425 :
72426 : #if 0
72427 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72428 : // used to trigger marking transformations for the token-based unparsing.
72429 : printf ("SgTemplateType::get_name = %p = %s \n",this,this->class_name().c_str());
72430 : #endif
72431 :
72432 0 : return p_name;
72433 : }
72434 :
72435 : void
72436 0 : SgTemplateType::set_name ( SgName name )
72437 : {
72438 0 : ROSE_ASSERT (this != NULL);
72439 :
72440 : #if 0
72441 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72442 : // used to trigger marking transformations for the token-based unparsing.
72443 : printf ("SgTemplateType::set_name = %p = %s \n",this,this->class_name().c_str());
72444 : #endif
72445 :
72446 0 : set_isModified(true);
72447 :
72448 0 : p_name = name;
72449 0 : }
72450 :
72451 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72452 :
72453 :
72454 : // End of memberFunctionString
72455 : // Start of memberFunctionString
72456 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72457 :
72458 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72459 :
72460 : int
72461 0 : SgTemplateType::get_template_parameter_position () const
72462 : {
72463 0 : ROSE_ASSERT (this != NULL);
72464 :
72465 : #if 0
72466 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72467 : // used to trigger marking transformations for the token-based unparsing.
72468 : printf ("SgTemplateType::get_template_parameter_position = %p = %s \n",this,this->class_name().c_str());
72469 : #endif
72470 :
72471 0 : return p_template_parameter_position;
72472 : }
72473 :
72474 : void
72475 0 : SgTemplateType::set_template_parameter_position ( int template_parameter_position )
72476 : {
72477 0 : ROSE_ASSERT (this != NULL);
72478 :
72479 : #if 0
72480 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72481 : // used to trigger marking transformations for the token-based unparsing.
72482 : printf ("SgTemplateType::set_template_parameter_position = %p = %s \n",this,this->class_name().c_str());
72483 : #endif
72484 :
72485 0 : set_isModified(true);
72486 :
72487 0 : p_template_parameter_position = template_parameter_position;
72488 0 : }
72489 :
72490 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72491 :
72492 :
72493 : // End of memberFunctionString
72494 : // Start of memberFunctionString
72495 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72496 :
72497 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72498 :
72499 : int
72500 0 : SgTemplateType::get_template_parameter_depth () const
72501 : {
72502 0 : ROSE_ASSERT (this != NULL);
72503 :
72504 : #if 0
72505 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72506 : // used to trigger marking transformations for the token-based unparsing.
72507 : printf ("SgTemplateType::get_template_parameter_depth = %p = %s \n",this,this->class_name().c_str());
72508 : #endif
72509 :
72510 0 : return p_template_parameter_depth;
72511 : }
72512 :
72513 : void
72514 0 : SgTemplateType::set_template_parameter_depth ( int template_parameter_depth )
72515 : {
72516 0 : ROSE_ASSERT (this != NULL);
72517 :
72518 : #if 0
72519 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72520 : // used to trigger marking transformations for the token-based unparsing.
72521 : printf ("SgTemplateType::set_template_parameter_depth = %p = %s \n",this,this->class_name().c_str());
72522 : #endif
72523 :
72524 0 : set_isModified(true);
72525 :
72526 0 : p_template_parameter_depth = template_parameter_depth;
72527 0 : }
72528 :
72529 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72530 :
72531 :
72532 : // End of memberFunctionString
72533 : // Start of memberFunctionString
72534 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72535 :
72536 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72537 :
72538 : SgType *
72539 0 : SgTemplateType::get_class_type () const
72540 : {
72541 0 : ROSE_ASSERT (this != NULL);
72542 :
72543 : #if 0
72544 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72545 : // used to trigger marking transformations for the token-based unparsing.
72546 : printf ("SgTemplateType::get_class_type = %p = %s \n",this,this->class_name().c_str());
72547 : #endif
72548 :
72549 0 : return p_class_type;
72550 : }
72551 :
72552 : void
72553 0 : SgTemplateType::set_class_type ( SgType * class_type )
72554 : {
72555 0 : ROSE_ASSERT (this != NULL);
72556 :
72557 : #if 0
72558 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72559 : // used to trigger marking transformations for the token-based unparsing.
72560 : printf ("SgTemplateType::set_class_type = %p = %s \n",this,this->class_name().c_str());
72561 : #endif
72562 :
72563 0 : set_isModified(true);
72564 :
72565 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
72566 : if (p_class_type != NULL && class_type != NULL && p_class_type != class_type)
72567 : {
72568 : printf ("Warning: class_type = %p overwriting valid pointer p_class_type = %p \n",class_type,p_class_type);
72569 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
72570 : printf ("Error fails assertion (p_class_type != NULL && class_type != NULL && p_class_type != class_type) is false\n");
72571 : ROSE_ASSERT(false);
72572 : #endif
72573 : }
72574 : #endif
72575 0 : p_class_type = class_type;
72576 0 : }
72577 :
72578 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72579 :
72580 :
72581 : // End of memberFunctionString
72582 : // Start of memberFunctionString
72583 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72584 :
72585 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72586 :
72587 : SgType *
72588 0 : SgTemplateType::get_parent_class_type () const
72589 : {
72590 0 : ROSE_ASSERT (this != NULL);
72591 :
72592 : #if 0
72593 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72594 : // used to trigger marking transformations for the token-based unparsing.
72595 : printf ("SgTemplateType::get_parent_class_type = %p = %s \n",this,this->class_name().c_str());
72596 : #endif
72597 :
72598 0 : return p_parent_class_type;
72599 : }
72600 :
72601 : void
72602 0 : SgTemplateType::set_parent_class_type ( SgType * parent_class_type )
72603 : {
72604 0 : ROSE_ASSERT (this != NULL);
72605 :
72606 : #if 0
72607 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72608 : // used to trigger marking transformations for the token-based unparsing.
72609 : printf ("SgTemplateType::set_parent_class_type = %p = %s \n",this,this->class_name().c_str());
72610 : #endif
72611 :
72612 0 : set_isModified(true);
72613 :
72614 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
72615 : if (p_parent_class_type != NULL && parent_class_type != NULL && p_parent_class_type != parent_class_type)
72616 : {
72617 : printf ("Warning: parent_class_type = %p overwriting valid pointer p_parent_class_type = %p \n",parent_class_type,p_parent_class_type);
72618 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
72619 : printf ("Error fails assertion (p_parent_class_type != NULL && parent_class_type != NULL && p_parent_class_type != parent_class_type) is false\n");
72620 : ROSE_ASSERT(false);
72621 : #endif
72622 : }
72623 : #endif
72624 0 : p_parent_class_type = parent_class_type;
72625 0 : }
72626 :
72627 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72628 :
72629 :
72630 : // End of memberFunctionString
72631 : // Start of memberFunctionString
72632 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72633 :
72634 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72635 :
72636 : SgTemplateParameter *
72637 0 : SgTemplateType::get_template_parameter () const
72638 : {
72639 0 : ROSE_ASSERT (this != NULL);
72640 :
72641 : #if 0
72642 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72643 : // used to trigger marking transformations for the token-based unparsing.
72644 : printf ("SgTemplateType::get_template_parameter = %p = %s \n",this,this->class_name().c_str());
72645 : #endif
72646 :
72647 0 : return p_template_parameter;
72648 : }
72649 :
72650 : void
72651 0 : SgTemplateType::set_template_parameter ( SgTemplateParameter * template_parameter )
72652 : {
72653 0 : ROSE_ASSERT (this != NULL);
72654 :
72655 : #if 0
72656 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72657 : // used to trigger marking transformations for the token-based unparsing.
72658 : printf ("SgTemplateType::set_template_parameter = %p = %s \n",this,this->class_name().c_str());
72659 : #endif
72660 :
72661 0 : set_isModified(true);
72662 :
72663 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
72664 : if (p_template_parameter != NULL && template_parameter != NULL && p_template_parameter != template_parameter)
72665 : {
72666 : printf ("Warning: template_parameter = %p overwriting valid pointer p_template_parameter = %p \n",template_parameter,p_template_parameter);
72667 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
72668 : printf ("Error fails assertion (p_template_parameter != NULL && template_parameter != NULL && p_template_parameter != template_parameter) is false\n");
72669 : ROSE_ASSERT(false);
72670 : #endif
72671 : }
72672 : #endif
72673 0 : p_template_parameter = template_parameter;
72674 0 : }
72675 :
72676 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72677 :
72678 :
72679 : // End of memberFunctionString
72680 : // Start of memberFunctionString
72681 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
72682 :
72683 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72684 :
72685 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
72686 : const SgTemplateArgumentPtrList &
72687 0 : SgTemplateType::get_tpl_args () const
72688 : {
72689 0 : assert (this != NULL);
72690 0 : return p_tpl_args;
72691 : }
72692 :
72693 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
72694 : SgTemplateArgumentPtrList &
72695 0 : SgTemplateType::get_tpl_args ()
72696 : {
72697 0 : assert (this != NULL);
72698 :
72699 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
72700 : // As a rule only set_ access functions can set the isModified flag.
72701 : // set_isModified(true);
72702 :
72703 0 : return p_tpl_args;
72704 : }
72705 :
72706 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72707 :
72708 :
72709 : // End of memberFunctionString
72710 : // Start of memberFunctionString
72711 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
72712 :
72713 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72714 :
72715 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
72716 : const SgTemplateArgumentPtrList &
72717 0 : SgTemplateType::get_part_spec_tpl_args () const
72718 : {
72719 0 : assert (this != NULL);
72720 0 : return p_part_spec_tpl_args;
72721 : }
72722 :
72723 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
72724 : SgTemplateArgumentPtrList &
72725 0 : SgTemplateType::get_part_spec_tpl_args ()
72726 : {
72727 0 : assert (this != NULL);
72728 :
72729 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
72730 : // As a rule only set_ access functions can set the isModified flag.
72731 : // set_isModified(true);
72732 :
72733 0 : return p_part_spec_tpl_args;
72734 : }
72735 :
72736 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72737 :
72738 :
72739 : // End of memberFunctionString
72740 : // Start of memberFunctionString
72741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
72742 :
72743 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
72744 :
72745 : bool
72746 0 : SgTemplateType::get_packed () const
72747 : {
72748 0 : ROSE_ASSERT (this != NULL);
72749 :
72750 : #if 0
72751 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72752 : // used to trigger marking transformations for the token-based unparsing.
72753 : printf ("SgTemplateType::get_packed = %p = %s \n",this,this->class_name().c_str());
72754 : #endif
72755 :
72756 0 : return p_packed;
72757 : }
72758 :
72759 : void
72760 0 : SgTemplateType::set_packed ( bool packed )
72761 : {
72762 0 : ROSE_ASSERT (this != NULL);
72763 :
72764 : #if 0
72765 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
72766 : // used to trigger marking transformations for the token-based unparsing.
72767 : printf ("SgTemplateType::set_packed = %p = %s \n",this,this->class_name().c_str());
72768 : #endif
72769 :
72770 0 : set_isModified(true);
72771 :
72772 0 : p_packed = packed;
72773 0 : }
72774 :
72775 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
72776 :
72777 :
72778 : // End of memberFunctionString
72779 : // Start of memberFunctionString
72780 : /* #line 4003 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
72781 :
72782 :
72783 : SgName
72784 0 : SgTemplateType::get_mangled(void) const
72785 : {
72786 0 : ROSE_ASSERT(this != NULL);
72787 :
72788 : #if 0
72789 : printf ("In SgTemplateType::get_mangled(): this = %p get_name() = %s \n",this,get_name().str());
72790 : #endif
72791 :
72792 0 : SgName mangled_name = get_name();
72793 :
72794 : // DQ (9/21/2012): Add the pointer value for the first undefined declaration as a way to make this a unique mangled value.
72795 : // We need to asspciate template template arguments with their associated declarations and not just there name.
72796 : // See test2012_217.C (return types of functions should be different, have different mangled names, for each function).
72797 : // mangled_name += StringUtility::numberToString(this->get_declaration());
72798 0 : mangled_name += Rose::StringUtility::numberToString(this);
72799 :
72800 : #if 0
72801 : printf ("In SgTemplateType::get_mangled(): this = %p mangled_name = %s \n",this,mangled_name.str());
72802 : #endif
72803 :
72804 0 : return mangled_name;
72805 : }
72806 :
72807 :
72808 :
72809 : // End of memberFunctionString
72810 : // Start of memberFunctionString
72811 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
72812 :
72813 : // *** COMMON CODE SECTION BEGINS HERE ***
72814 :
72815 : #if 0
72816 : int
72817 : SgTemplateType::getVariant() const
72818 : {
72819 : // This function is used in ROSE while "variant()" is used in SAGE
72820 : assert(this != NULL);
72821 : return variant();
72822 : }
72823 : #endif
72824 :
72825 : // This function is used in ROSE in treeTraversal code
72826 : // eventually replaces getVariant() and variant()
72827 : // though after variant() has been removed for a while we will
72828 : // want to change the name of variantT() back to variant()
72829 : // (since the "T" was ment to stand for temporary).
72830 : // When this happens the variantT() will be depricated.
72831 : VariantT
72832 0 : SgTemplateType::variantT() const
72833 : {
72834 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
72835 0 : ROSE_ASSERT(this != NULL);
72836 0 : return V_SgTemplateType;
72837 : }
72838 :
72839 : #if 0
72840 : int
72841 : SgTemplateType::variant() const
72842 : {
72843 : // This function is used in SAGE
72844 : ROSE_ASSERT(this != NULL);
72845 : return T_TEMPLATE;
72846 : }
72847 : #endif
72848 :
72849 : ROSE_DLL_API const char*
72850 0 : SgTemplateType::sage_class_name() const
72851 : {
72852 0 : ROSE_ASSERT(this != NULL);
72853 0 : return "SgTemplateType";
72854 : }
72855 :
72856 : std::string
72857 0 : SgTemplateType::class_name() const
72858 : {
72859 0 : ROSE_ASSERT(this != NULL);
72860 0 : return "SgTemplateType";
72861 : }
72862 :
72863 : // DQ (11/26/2005): Support for visitor pattern mechanims
72864 : // (inferior to ROSE traversal mechanism, experimental).
72865 : void
72866 0 : SgTemplateType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
72867 : {
72868 0 : ROSE_ASSERT(this != NULL);
72869 0 : visitor.visit(this);
72870 0 : }
72871 :
72872 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
72873 0 : void SgTemplateType::accept (ROSE_VisitorPattern & visitor) {
72874 0 : ROSE_ASSERT(this != NULL);
72875 0 : visitor.visit(this);
72876 0 : }
72877 :
72878 : SgTemplateType*
72879 0 : SgTemplateType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
72880 : {
72881 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
72882 : // This function is currently only supported for the AST used the represent Binary executables.
72883 : if (0 /* isSgAsmNode(this) != NULL */)
72884 : {
72885 : // Support for regex specification.
72886 : std::string prefixCode = "REGEX:";
72887 : addNewAttribute(prefixCode + s,a);
72888 : }
72889 : #endif
72890 :
72891 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
72892 0 : return this;
72893 : }
72894 :
72895 : // *** COMMON CODE SECTION ENDS HERE ***
72896 :
72897 :
72898 : // End of memberFunctionString
72899 : // Start of memberFunctionString
72900 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
72901 :
72902 :
72903 : #if 0
72904 : //! Error checking support
72905 : /*! Verifies the following:
72906 : - working getVariant() member function
72907 : - calls base class's error() member function
72908 : Every class has one of these functions.
72909 : */
72910 : bool
72911 : SgTemplateType::error()
72912 : {
72913 : // Put error checking here
72914 :
72915 : ROSE_ASSERT (this != NULL);
72916 : if (getVariant() != T_TEMPLATE)
72917 : {
72918 : printf ("Error in SgTemplateType::error(): SgTemplateType object has a %s variant \n",
72919 : Cxx_GrammarTerminalNames[getVariant()].name);
72920 : // printf ("Error in SgTemplateType::error() \n");
72921 : ROSE_ABORT();
72922 : }
72923 :
72924 : ROSE_ASSERT (getVariant() == T_TEMPLATE);
72925 : return SgType::error();
72926 : }
72927 : #endif
72928 :
72929 :
72930 :
72931 : // End of memberFunctionString
72932 :
72933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
72934 :
72935 94730 : SgTemplateType* isSgTemplateType ( SgNode* inputDerivedClassPointer )
72936 : {
72937 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
72938 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
72939 : // So to fix this we return NULL directly when the input is NULL and avoid the
72940 : // dynamic_cast in this case. This is likely a performance improvement as well.
72941 : // return dynamic_cast<SgTemplateType*>(inputDerivedClassPointer);
72942 : // Milind Chabbi (8/28/2013): isSgTemplateType uses table-driven castability instead of c++ default dynamic_cast
72943 : // this improves the running time performance by 10-20%.
72944 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateType*>(inputDerivedClassPointer);
72945 94730 : return IS_SgTemplateType_FAST_MACRO(inputDerivedClassPointer);
72946 : }
72947 :
72948 : // DQ (11/8/2003): Added version of functions taking const pointer
72949 0 : const SgTemplateType* isSgTemplateType ( const SgNode* inputDerivedClassPointer )
72950 : {
72951 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
72952 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
72953 : // So to fix this we return NULL directly when the input is NULL and avoid the
72954 : // dynamic_cast in this case. This is likely a performance improvement as well.
72955 : // return dynamic_cast<const SgTemplateType*>(inputDerivedClassPointer);
72956 : // Milind Chabbi (8/28/2013): isSgTemplateType uses table-driven castability instead of c++ default dynamic_cast
72957 : // this improves the running time performance by 10-20%.
72958 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateType*>(inputDerivedClassPointer);
72959 0 : return IS_SgTemplateType_FAST_MACRO(inputDerivedClassPointer);
72960 : }
72961 :
72962 :
72963 :
72964 : /* #line 72965 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
72965 :
72966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
72967 :
72968 : /**
72969 : \brief Generated destructor
72970 :
72971 : This destructor is automatically generated (by ROSETTA). This destructor
72972 : only frees memory of data members associated with the parts of the current IR node which
72973 : are NOT traversed. Those data members that are part of a traversal can be freed using
72974 : a traversal (calling this destructor on all children in a post-order traversal). Such
72975 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
72976 :
72977 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
72978 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
72979 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
72980 :
72981 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
72982 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
72983 : pointers are not yet implemented to call delete on eash pointer in the container.
72984 : (This could be done by derivation from the STL containers to define containers that
72985 : automatically deleted their members.)
72986 :
72987 : */
72988 0 : SgTemplateType::~SgTemplateType () {
72989 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
72990 :
72991 0 : if (p_class_type && p_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_class_type; }
72992 0 : if (p_parent_class_type && p_parent_class_type->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_parent_class_type; }
72993 0 : if (p_template_parameter && p_template_parameter->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_template_parameter; }
72994 :
72995 : // case: not a listType for name
72996 0 : p_name = ""; // non list case
72997 : // case: not a listType for template_parameter_position
72998 0 : p_template_parameter_position = -1; // non list case
72999 : // case: not a listType for template_parameter_depth
73000 0 : p_template_parameter_depth = -1; // non list case
73001 : // case: not a listType for class_type
73002 0 : p_class_type = NULL; // non list case
73003 : // case: not a listType for parent_class_type
73004 0 : p_parent_class_type = NULL; // non list case
73005 : // case: not a listType for template_parameter
73006 0 : p_template_parameter = NULL; // non list case
73007 : // case: listType for tpl_args
73008 : // case: listType (typeIsPointerToList == false) for tpl_args
73009 0 : p_tpl_args.erase(p_tpl_args.begin(),p_tpl_args.end());
73010 : // case: listType for part_spec_tpl_args
73011 : // case: listType (typeIsPointerToList == false) for part_spec_tpl_args
73012 0 : p_part_spec_tpl_args.erase(p_part_spec_tpl_args.begin(),p_part_spec_tpl_args.end());
73013 : // case: not a listType for packed
73014 0 : p_packed = false; // non list case
73015 :
73016 : }
73017 :
73018 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
73019 0 : }
73020 :
73021 :
73022 : /* #line 73023 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73023 :
73024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
73025 :
73026 : // Generated constructor
73027 0 : SgTemplateType::SgTemplateType ( SgName name )
73028 0 : : SgType()
73029 : {
73030 : #ifdef DEBUG
73031 : // printf ("In SgTemplateType::SgTemplateType (SgName name) sage_class_name() = %s \n",sage_class_name());
73032 : #endif
73033 : #if 0
73034 : // debugging information!
73035 : printf ("In SgTemplateType::SgTemplateType (SgName name): this = %p = %s \n",this,this->class_name().c_str());
73036 : #endif
73037 :
73038 0 : p_name = name;
73039 0 : p_template_parameter_position = -1;
73040 0 : p_template_parameter_depth = -1;
73041 0 : p_class_type = NULL;
73042 0 : p_parent_class_type = NULL;
73043 0 : p_template_parameter = NULL;
73044 0 : p_tpl_args = SgTemplateArgumentPtrList();
73045 0 : p_part_spec_tpl_args = SgTemplateArgumentPtrList();
73046 0 : p_packed = false;
73047 :
73048 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
73049 :
73050 : #if 0
73051 : // DQ (7/30/2014): Call a virtual function.
73052 : std::string s = this->class_name();
73053 : #endif
73054 :
73055 : // Test the variant virtual function
73056 : // assert(T_TEMPLATE == variant());
73057 0 : assert(T_TEMPLATE == this->variant());
73058 0 : ROSE_ASSERT(T_TEMPLATE == (int)(this->variantT()));
73059 0 : post_construction_initialization();
73060 :
73061 : // Test the isSgTemplateType() function since it has been problematic
73062 0 : assert(isSgTemplateType(this) != NULL);
73063 0 : }
73064 :
73065 : // Generated constructor (all data members)
73066 :
73067 : /* #line 73068 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73068 :
73069 :
73070 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
73071 :
73072 :
73073 : // ********************************************************
73074 : // member functions common across all array grammar objects
73075 : // ********************************************************
73076 :
73077 :
73078 :
73079 : /* #line 73080 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73080 :
73081 :
73082 :
73083 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
73084 :
73085 : // ********************************************************
73086 : // member functions specific to each node in the grammar
73087 : // ********************************************************
73088 :
73089 :
73090 : /* #line 73091 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73091 :
73092 : // Start of memberFunctionString
73093 : /* #line 8578 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
73094 :
73095 : // SgQualifiedNameType* SgQualifiedNameType::createType(SgType* base_type, unsigned int f)
73096 : SgQualifiedNameType*
73097 0 : SgQualifiedNameType::createType(SgType* base_type, unsigned int f, SgExpression* optional_fortran_type_kind)
73098 : {
73099 0 : ROSE_ASSERT(base_type != NULL);
73100 :
73101 : // DQ (10/4/2010): I think that reference types can't have a kind parameter, so this should be NULL.
73102 0 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
73103 :
73104 : // DQ (12/21/2005): This is a copy of the function from SgModifierType
73105 : // (I think we need it to override the base class implementation).
73106 :
73107 0 : printf ("Error, this function SgQualifiedNameType should not have been called! \n");
73108 0 : ROSE_ASSERT (false);
73109 :
73110 : return NULL;
73111 : }
73112 :
73113 :
73114 :
73115 : // End of memberFunctionString
73116 : // Start of memberFunctionString
73117 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
73118 :
73119 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
73120 :
73121 : SgType*
73122 0 : SgQualifiedNameType::get_base_type () const
73123 : {
73124 0 : ROSE_ASSERT (this != NULL);
73125 :
73126 : #if 0
73127 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
73128 : // used to trigger marking transformations for the token-based unparsing.
73129 : printf ("SgQualifiedNameType::get_base_type = %p = %s \n",this,this->class_name().c_str());
73130 : #endif
73131 :
73132 0 : return p_base_type;
73133 : }
73134 :
73135 : void
73136 0 : SgQualifiedNameType::set_base_type ( SgType* base_type )
73137 : {
73138 0 : ROSE_ASSERT (this != NULL);
73139 :
73140 : #if 0
73141 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
73142 : // used to trigger marking transformations for the token-based unparsing.
73143 : printf ("SgQualifiedNameType::set_base_type = %p = %s \n",this,this->class_name().c_str());
73144 : #endif
73145 :
73146 0 : set_isModified(true);
73147 :
73148 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
73149 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
73150 : {
73151 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
73152 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
73153 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
73154 : ROSE_ASSERT(false);
73155 : #endif
73156 : }
73157 : #endif
73158 0 : p_base_type = base_type;
73159 0 : }
73160 :
73161 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
73162 :
73163 :
73164 : // End of memberFunctionString
73165 : // Start of memberFunctionString
73166 :
73167 :
73168 : // End of memberFunctionString
73169 : // Start of memberFunctionString
73170 : /* #line 4684 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
73171 :
73172 : // DQ (12/21/2005): Build the static empty list to use as a default argument for the SgQualifiedNameType constructor
73173 : // SgQualifiedNamePtrList SgQualifiedNameType::p_defaultQualifiedNamePtrList;
73174 :
73175 : SgQualifiedNamePtrList &
73176 0 : SgQualifiedNameType::get_qualifiedNameList()
73177 : {
73178 0 : return p_qualifiedNameList;
73179 : }
73180 :
73181 : const SgQualifiedNamePtrList &
73182 0 : SgQualifiedNameType::get_qualifiedNameList() const
73183 : {
73184 0 : return p_qualifiedNameList;
73185 : }
73186 :
73187 : void
73188 0 : SgQualifiedNameType::set_qualifiedNameList( const SgQualifiedNamePtrList & x )
73189 : {
73190 0 : p_qualifiedNameList = x;
73191 0 : }
73192 :
73193 : SgName
73194 0 : SgQualifiedNameType::get_prefix() const
73195 : {
73196 0 : SgName tmp;
73197 :
73198 : #if 1
73199 0 : SgQualifiedNamePtrList::const_iterator i = p_qualifiedNameList.begin();
73200 0 : while(i != p_qualifiedNameList.end())
73201 : {
73202 0 : printf ("Found a qualified name \n");
73203 0 : if (isSgGlobal((*i)->get_scope()) != NULL)
73204 : {
73205 0 : printf ("Output the global scope qualifier \n");
73206 0 : tmp << "::";
73207 : }
73208 : else
73209 : {
73210 : // Use the generated name until we are ready to select between generated or stored qualified names
73211 0 : printf ("Use the generated name until we are ready to select between generated or stored qualified names \n");
73212 : }
73213 0 : i++;
73214 : }
73215 : #else
73216 : printf ("Error: SgQualifiedNameType::get_prefix() not used! \n");
73217 : ROSE_ASSERT(false);
73218 : #endif
73219 :
73220 0 : return tmp;
73221 : }
73222 :
73223 : #if 1
73224 : // SgName SgQualifiedNameType::get_mangled (SgUnparse_Info & info)
73225 : SgName
73226 0 : SgQualifiedNameType::get_mangled (void) const
73227 : {
73228 0 : ROSE_ASSERT(this != NULL);
73229 :
73230 0 : SgName tmp;
73231 :
73232 : // DQ (6/23/2005): Get the name (and qualified name) of the type into the mangled name
73233 : // info.set_name();
73234 : // printf ("In SgQualifiedNameType::get_mangled_type(): calling info.set_PrintName() \n");
73235 : // info.set_PrintName();
73236 : // ROSE_ASSERT(info.PrintName() == true);
73237 :
73238 : // return get_mangled (SgNO_UNPARSE_INFO);
73239 :
73240 : // printf ("WARNING: The generated name in SgQualifiedNameType::get_mangled() should use a prefix generated from mangled names \n");
73241 :
73242 : #if 1
73243 : // SgName qualifiedName = get_prefix();
73244 :
73245 : // tmp << qualifiedName.str() << get_base_type()->get_mangled(info).str();
73246 :
73247 : // DQ (10/10/2006): The base_type should be fully qualified before mangling, so I don't think we need the prefix!
73248 : // tmp << qualifiedName.str() << get_base_type()->get_mangled().str();
73249 0 : tmp << "qualified_name_" << get_base_type()->get_mangled().str();
73250 : #else
73251 : printf ("Error: SgQualifiedNameType::get_mangled() not used! \n");
73252 : ROSE_ASSERT(false);
73253 : #endif
73254 :
73255 0 : return tmp;
73256 : }
73257 : #endif
73258 :
73259 :
73260 :
73261 : // End of memberFunctionString
73262 : // Start of memberFunctionString
73263 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
73264 :
73265 : // *** COMMON CODE SECTION BEGINS HERE ***
73266 :
73267 : #if 0
73268 : int
73269 : SgQualifiedNameType::getVariant() const
73270 : {
73271 : // This function is used in ROSE while "variant()" is used in SAGE
73272 : assert(this != NULL);
73273 : return variant();
73274 : }
73275 : #endif
73276 :
73277 : // This function is used in ROSE in treeTraversal code
73278 : // eventually replaces getVariant() and variant()
73279 : // though after variant() has been removed for a while we will
73280 : // want to change the name of variantT() back to variant()
73281 : // (since the "T" was ment to stand for temporary).
73282 : // When this happens the variantT() will be depricated.
73283 : VariantT
73284 0 : SgQualifiedNameType::variantT() const
73285 : {
73286 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
73287 0 : ROSE_ASSERT(this != NULL);
73288 0 : return V_SgQualifiedNameType;
73289 : }
73290 :
73291 : #if 0
73292 : int
73293 : SgQualifiedNameType::variant() const
73294 : {
73295 : // This function is used in SAGE
73296 : ROSE_ASSERT(this != NULL);
73297 : return T_QUALIFIED_NAME;
73298 : }
73299 : #endif
73300 :
73301 : ROSE_DLL_API const char*
73302 0 : SgQualifiedNameType::sage_class_name() const
73303 : {
73304 0 : ROSE_ASSERT(this != NULL);
73305 0 : return "SgQualifiedNameType";
73306 : }
73307 :
73308 : std::string
73309 0 : SgQualifiedNameType::class_name() const
73310 : {
73311 0 : ROSE_ASSERT(this != NULL);
73312 0 : return "SgQualifiedNameType";
73313 : }
73314 :
73315 : // DQ (11/26/2005): Support for visitor pattern mechanims
73316 : // (inferior to ROSE traversal mechanism, experimental).
73317 : void
73318 0 : SgQualifiedNameType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
73319 : {
73320 0 : ROSE_ASSERT(this != NULL);
73321 0 : visitor.visit(this);
73322 0 : }
73323 :
73324 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
73325 0 : void SgQualifiedNameType::accept (ROSE_VisitorPattern & visitor) {
73326 0 : ROSE_ASSERT(this != NULL);
73327 0 : visitor.visit(this);
73328 0 : }
73329 :
73330 : SgQualifiedNameType*
73331 0 : SgQualifiedNameType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
73332 : {
73333 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
73334 : // This function is currently only supported for the AST used the represent Binary executables.
73335 : if (0 /* isSgAsmNode(this) != NULL */)
73336 : {
73337 : // Support for regex specification.
73338 : std::string prefixCode = "REGEX:";
73339 : addNewAttribute(prefixCode + s,a);
73340 : }
73341 : #endif
73342 :
73343 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
73344 0 : return this;
73345 : }
73346 :
73347 : // *** COMMON CODE SECTION ENDS HERE ***
73348 :
73349 :
73350 : // End of memberFunctionString
73351 : // Start of memberFunctionString
73352 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
73353 :
73354 :
73355 : #if 0
73356 : //! Error checking support
73357 : /*! Verifies the following:
73358 : - working getVariant() member function
73359 : - calls base class's error() member function
73360 : Every class has one of these functions.
73361 : */
73362 : bool
73363 : SgQualifiedNameType::error()
73364 : {
73365 : // Put error checking here
73366 :
73367 : ROSE_ASSERT (this != NULL);
73368 : if (getVariant() != T_QUALIFIED_NAME)
73369 : {
73370 : printf ("Error in SgQualifiedNameType::error(): SgQualifiedNameType object has a %s variant \n",
73371 : Cxx_GrammarTerminalNames[getVariant()].name);
73372 : // printf ("Error in SgQualifiedNameType::error() \n");
73373 : ROSE_ABORT();
73374 : }
73375 :
73376 : ROSE_ASSERT (getVariant() == T_QUALIFIED_NAME);
73377 : return SgType::error();
73378 : }
73379 : #endif
73380 :
73381 :
73382 :
73383 : // End of memberFunctionString
73384 :
73385 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
73386 :
73387 0 : SgQualifiedNameType* isSgQualifiedNameType ( SgNode* inputDerivedClassPointer )
73388 : {
73389 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
73390 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
73391 : // So to fix this we return NULL directly when the input is NULL and avoid the
73392 : // dynamic_cast in this case. This is likely a performance improvement as well.
73393 : // return dynamic_cast<SgQualifiedNameType*>(inputDerivedClassPointer);
73394 : // Milind Chabbi (8/28/2013): isSgQualifiedNameType uses table-driven castability instead of c++ default dynamic_cast
73395 : // this improves the running time performance by 10-20%.
73396 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgQualifiedNameType*>(inputDerivedClassPointer);
73397 0 : return IS_SgQualifiedNameType_FAST_MACRO(inputDerivedClassPointer);
73398 : }
73399 :
73400 : // DQ (11/8/2003): Added version of functions taking const pointer
73401 0 : const SgQualifiedNameType* isSgQualifiedNameType ( const SgNode* inputDerivedClassPointer )
73402 : {
73403 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
73404 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
73405 : // So to fix this we return NULL directly when the input is NULL and avoid the
73406 : // dynamic_cast in this case. This is likely a performance improvement as well.
73407 : // return dynamic_cast<const SgQualifiedNameType*>(inputDerivedClassPointer);
73408 : // Milind Chabbi (8/28/2013): isSgQualifiedNameType uses table-driven castability instead of c++ default dynamic_cast
73409 : // this improves the running time performance by 10-20%.
73410 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgQualifiedNameType*>(inputDerivedClassPointer);
73411 0 : return IS_SgQualifiedNameType_FAST_MACRO(inputDerivedClassPointer);
73412 : }
73413 :
73414 :
73415 :
73416 : /* #line 73417 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73417 :
73418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
73419 :
73420 : /**
73421 : \brief Generated destructor
73422 :
73423 : This destructor is automatically generated (by ROSETTA). This destructor
73424 : only frees memory of data members associated with the parts of the current IR node which
73425 : are NOT traversed. Those data members that are part of a traversal can be freed using
73426 : a traversal (calling this destructor on all children in a post-order traversal). Such
73427 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
73428 :
73429 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
73430 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
73431 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
73432 :
73433 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
73434 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
73435 : pointers are not yet implemented to call delete on eash pointer in the container.
73436 : (This could be done by derivation from the STL containers to define containers that
73437 : automatically deleted their members.)
73438 :
73439 : */
73440 0 : SgQualifiedNameType::~SgQualifiedNameType () {
73441 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
73442 :
73443 :
73444 : // case: not a listType for base_type
73445 0 : p_base_type = NULL; // non list case
73446 :
73447 : }
73448 :
73449 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
73450 0 : }
73451 :
73452 :
73453 : /* #line 73454 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73454 :
73455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
73456 :
73457 : // Generated constructor
73458 0 : SgQualifiedNameType::SgQualifiedNameType ( SgType* base_type )
73459 0 : : SgType()
73460 : {
73461 : #ifdef DEBUG
73462 : // printf ("In SgQualifiedNameType::SgQualifiedNameType (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
73463 : #endif
73464 : #if 0
73465 : // debugging information!
73466 : printf ("In SgQualifiedNameType::SgQualifiedNameType (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
73467 : #endif
73468 :
73469 0 : p_base_type = base_type;
73470 :
73471 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
73472 :
73473 : #if 0
73474 : // DQ (7/30/2014): Call a virtual function.
73475 : std::string s = this->class_name();
73476 : #endif
73477 :
73478 : // Test the variant virtual function
73479 : // assert(T_QUALIFIED_NAME == variant());
73480 0 : assert(T_QUALIFIED_NAME == this->variant());
73481 0 : ROSE_ASSERT(T_QUALIFIED_NAME == (int)(this->variantT()));
73482 0 : post_construction_initialization();
73483 :
73484 : // Test the isSgQualifiedNameType() function since it has been problematic
73485 0 : assert(isSgQualifiedNameType(this) != NULL);
73486 0 : }
73487 :
73488 : // Generated constructor (all data members)
73489 :
73490 : /* #line 73491 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73491 :
73492 :
73493 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
73494 :
73495 :
73496 : // ********************************************************
73497 : // member functions common across all array grammar objects
73498 : // ********************************************************
73499 :
73500 :
73501 :
73502 : /* #line 73503 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73503 :
73504 :
73505 :
73506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
73507 :
73508 : // ********************************************************
73509 : // member functions specific to each node in the grammar
73510 : // ********************************************************
73511 :
73512 :
73513 : /* #line 73514 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73514 :
73515 : // Start of memberFunctionString
73516 : /* #line 8600 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
73517 :
73518 :
73519 : // DQ (8/27/2006): This code is used for both SgTypeComplex and SgTypeImaginary.
73520 :
73521 : SgTypeComplex*
73522 4 : SgTypeComplex::createType(SgType* t, SgExpression* optional_fortran_type_kind)
73523 : {
73524 : #if 0
73525 : printf ("In SgTypeComplex::createType() (CREATE_TYPE_FOR_COMPLEX_TYPE) \n");
73526 : #endif
73527 :
73528 : // Not clear why this is using a map???
73529 4 : static std::map<SgType*, SgTypeComplex*> cache;
73530 :
73531 4 : SgTypeComplex*& returnType = cache[t];
73532 :
73533 4 : if (returnType == NULL)
73534 : {
73535 2 : returnType = new SgTypeComplex(t);
73536 : }
73537 4 : ROSE_ASSERT(returnType != NULL);
73538 :
73539 4 : return returnType;
73540 : }
73541 :
73542 : SgExpression *
73543 176888 : SgTypeComplex::get_type_kind () const
73544 : {
73545 176888 : return this->get_base_type()->get_type_kind();
73546 : }
73547 :
73548 : void
73549 0 : SgTypeComplex::set_type_kind ( SgExpression* type_kind )
73550 : {
73551 0 : this->get_base_type()->set_type_kind(type_kind);
73552 0 : }
73553 :
73554 :
73555 :
73556 : // End of memberFunctionString
73557 : // Start of memberFunctionString
73558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
73559 :
73560 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
73561 :
73562 : SgType*
73563 177335 : SgTypeComplex::get_base_type () const
73564 : {
73565 177335 : ROSE_ASSERT (this != NULL);
73566 :
73567 : #if 0
73568 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
73569 : // used to trigger marking transformations for the token-based unparsing.
73570 : printf ("SgTypeComplex::get_base_type = %p = %s \n",this,this->class_name().c_str());
73571 : #endif
73572 :
73573 177335 : return p_base_type;
73574 : }
73575 :
73576 : void
73577 0 : SgTypeComplex::set_base_type ( SgType* base_type )
73578 : {
73579 0 : ROSE_ASSERT (this != NULL);
73580 :
73581 : #if 0
73582 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
73583 : // used to trigger marking transformations for the token-based unparsing.
73584 : printf ("SgTypeComplex::set_base_type = %p = %s \n",this,this->class_name().c_str());
73585 : #endif
73586 :
73587 0 : set_isModified(true);
73588 :
73589 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
73590 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
73591 : {
73592 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
73593 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
73594 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
73595 : ROSE_ASSERT(false);
73596 : #endif
73597 : }
73598 : #endif
73599 0 : p_base_type = base_type;
73600 0 : }
73601 :
73602 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
73603 :
73604 :
73605 : // End of memberFunctionString
73606 : // Start of memberFunctionString
73607 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
73608 :
73609 : // *** COMMON CODE SECTION BEGINS HERE ***
73610 :
73611 : #if 0
73612 : int
73613 : SgTypeComplex::getVariant() const
73614 : {
73615 : // This function is used in ROSE while "variant()" is used in SAGE
73616 : assert(this != NULL);
73617 : return variant();
73618 : }
73619 : #endif
73620 :
73621 : // This function is used in ROSE in treeTraversal code
73622 : // eventually replaces getVariant() and variant()
73623 : // though after variant() has been removed for a while we will
73624 : // want to change the name of variantT() back to variant()
73625 : // (since the "T" was ment to stand for temporary).
73626 : // When this happens the variantT() will be depricated.
73627 : VariantT
73628 33859100 : SgTypeComplex::variantT() const
73629 : {
73630 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
73631 33859100 : ROSE_ASSERT(this != NULL);
73632 33859100 : return V_SgTypeComplex;
73633 : }
73634 :
73635 : #if 0
73636 : int
73637 : SgTypeComplex::variant() const
73638 : {
73639 : // This function is used in SAGE
73640 : ROSE_ASSERT(this != NULL);
73641 : return T_COMPLEX;
73642 : }
73643 : #endif
73644 :
73645 : ROSE_DLL_API const char*
73646 0 : SgTypeComplex::sage_class_name() const
73647 : {
73648 0 : ROSE_ASSERT(this != NULL);
73649 0 : return "SgTypeComplex";
73650 : }
73651 :
73652 : std::string
73653 915 : SgTypeComplex::class_name() const
73654 : {
73655 915 : ROSE_ASSERT(this != NULL);
73656 915 : return "SgTypeComplex";
73657 : }
73658 :
73659 : // DQ (11/26/2005): Support for visitor pattern mechanims
73660 : // (inferior to ROSE traversal mechanism, experimental).
73661 : void
73662 719 : SgTypeComplex::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
73663 : {
73664 719 : ROSE_ASSERT(this != NULL);
73665 719 : visitor.visit(this);
73666 719 : }
73667 :
73668 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
73669 0 : void SgTypeComplex::accept (ROSE_VisitorPattern & visitor) {
73670 0 : ROSE_ASSERT(this != NULL);
73671 0 : visitor.visit(this);
73672 0 : }
73673 :
73674 : SgTypeComplex*
73675 0 : SgTypeComplex::addRegExpAttribute(std::string s, AstRegExAttribute* a)
73676 : {
73677 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
73678 : // This function is currently only supported for the AST used the represent Binary executables.
73679 : if (0 /* isSgAsmNode(this) != NULL */)
73680 : {
73681 : // Support for regex specification.
73682 : std::string prefixCode = "REGEX:";
73683 : addNewAttribute(prefixCode + s,a);
73684 : }
73685 : #endif
73686 :
73687 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
73688 0 : return this;
73689 : }
73690 :
73691 : // *** COMMON CODE SECTION ENDS HERE ***
73692 :
73693 :
73694 : // End of memberFunctionString
73695 : // Start of memberFunctionString
73696 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
73697 :
73698 :
73699 : #if 0
73700 : //! Error checking support
73701 : /*! Verifies the following:
73702 : - working getVariant() member function
73703 : - calls base class's error() member function
73704 : Every class has one of these functions.
73705 : */
73706 : bool
73707 : SgTypeComplex::error()
73708 : {
73709 : // Put error checking here
73710 :
73711 : ROSE_ASSERT (this != NULL);
73712 : if (getVariant() != T_COMPLEX)
73713 : {
73714 : printf ("Error in SgTypeComplex::error(): SgTypeComplex object has a %s variant \n",
73715 : Cxx_GrammarTerminalNames[getVariant()].name);
73716 : // printf ("Error in SgTypeComplex::error() \n");
73717 : ROSE_ABORT();
73718 : }
73719 :
73720 : ROSE_ASSERT (getVariant() == T_COMPLEX);
73721 : return SgType::error();
73722 : }
73723 : #endif
73724 :
73725 :
73726 :
73727 : // End of memberFunctionString
73728 : // Start of memberFunctionString
73729 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
73730 :
73731 : #if 1
73732 : /*! Support for mangled names (for unparser)
73733 : There are two different cases of source code for the get_mangled member function
73734 : This one is used in all but the classes containing a base type
73735 : */
73736 : // SgName SgTypeComplex::get_mangled ( SgUnparse_Info & info )
73737 : SgName
73738 176888 : SgTypeComplex::get_mangled (void) const
73739 : {
73740 176888 : ROSE_ASSERT(this != NULL);
73741 :
73742 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
73743 : // CR (3/6/2020): Now type_kind is also used for Jovial.
73744 176888 : SgName name = "Complex";
73745 176888 : if (get_type_kind() != NULL)
73746 : {
73747 : // name += get_type_kind()->get_mangled();
73748 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
73749 0 : SgValueExp* value = isSgValueExp(get_type_kind());
73750 0 : if (value != NULL)
73751 : {
73752 : // name += string("_") + StringUtility::numberToString(value->get_value());
73753 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
73754 : }
73755 : else
73756 : {
73757 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
73758 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
73759 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
73760 : // a different prefix for each type of named type. It come down to is there can be multiple
73761 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
73762 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
73763 : // I think the issue is that Complex is not defined for any of the SgNameType IR nodes.
73764 : #if 0
73765 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Complex");
73766 : #endif
73767 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
73768 : }
73769 : }
73770 :
73771 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
73772 : // REMOVE_ME please!
73773 176888 : if (isSgTypeFixed(this))
73774 : {
73775 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
73776 0 : if (fixed_type->get_scale() != NULL)
73777 : {
73778 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
73779 0 : if (value != NULL)
73780 : {
73781 0 : name += string("_") + value->get_constant_folded_value_as_string();
73782 : }
73783 : }
73784 0 : if (fixed_type->get_fraction() != NULL)
73785 : {
73786 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
73787 0 : if (value != NULL)
73788 : {
73789 0 : name += string("_") + value->get_constant_folded_value_as_string();
73790 : }
73791 : }
73792 : }
73793 :
73794 : #if 0
73795 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
73796 : #endif
73797 :
73798 176888 : return name;
73799 : }
73800 : #endif
73801 :
73802 :
73803 : // End of memberFunctionString
73804 :
73805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
73806 :
73807 28783 : SgTypeComplex* isSgTypeComplex ( SgNode* inputDerivedClassPointer )
73808 : {
73809 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
73810 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
73811 : // So to fix this we return NULL directly when the input is NULL and avoid the
73812 : // dynamic_cast in this case. This is likely a performance improvement as well.
73813 : // return dynamic_cast<SgTypeComplex*>(inputDerivedClassPointer);
73814 : // Milind Chabbi (8/28/2013): isSgTypeComplex uses table-driven castability instead of c++ default dynamic_cast
73815 : // this improves the running time performance by 10-20%.
73816 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeComplex*>(inputDerivedClassPointer);
73817 28783 : return IS_SgTypeComplex_FAST_MACRO(inputDerivedClassPointer);
73818 : }
73819 :
73820 : // DQ (11/8/2003): Added version of functions taking const pointer
73821 0 : const SgTypeComplex* isSgTypeComplex ( const SgNode* inputDerivedClassPointer )
73822 : {
73823 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
73824 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
73825 : // So to fix this we return NULL directly when the input is NULL and avoid the
73826 : // dynamic_cast in this case. This is likely a performance improvement as well.
73827 : // return dynamic_cast<const SgTypeComplex*>(inputDerivedClassPointer);
73828 : // Milind Chabbi (8/28/2013): isSgTypeComplex uses table-driven castability instead of c++ default dynamic_cast
73829 : // this improves the running time performance by 10-20%.
73830 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeComplex*>(inputDerivedClassPointer);
73831 0 : return IS_SgTypeComplex_FAST_MACRO(inputDerivedClassPointer);
73832 : }
73833 :
73834 :
73835 :
73836 : /* #line 73837 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73837 :
73838 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
73839 :
73840 : /**
73841 : \brief Generated destructor
73842 :
73843 : This destructor is automatically generated (by ROSETTA). This destructor
73844 : only frees memory of data members associated with the parts of the current IR node which
73845 : are NOT traversed. Those data members that are part of a traversal can be freed using
73846 : a traversal (calling this destructor on all children in a post-order traversal). Such
73847 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
73848 :
73849 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
73850 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
73851 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
73852 :
73853 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
73854 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
73855 : pointers are not yet implemented to call delete on eash pointer in the container.
73856 : (This could be done by derivation from the STL containers to define containers that
73857 : automatically deleted their members.)
73858 :
73859 : */
73860 28 : SgTypeComplex::~SgTypeComplex () {
73861 14 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
73862 :
73863 :
73864 : // case: not a listType for base_type
73865 14 : p_base_type = NULL; // non list case
73866 :
73867 : }
73868 :
73869 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
73870 28 : }
73871 :
73872 :
73873 : /* #line 73874 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73874 :
73875 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
73876 :
73877 : // Generated constructor
73878 975 : SgTypeComplex::SgTypeComplex ( SgType* base_type )
73879 975 : : SgType()
73880 : {
73881 : #ifdef DEBUG
73882 : // printf ("In SgTypeComplex::SgTypeComplex (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
73883 : #endif
73884 : #if 0
73885 : // debugging information!
73886 : printf ("In SgTypeComplex::SgTypeComplex (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
73887 : #endif
73888 :
73889 975 : p_base_type = base_type;
73890 :
73891 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
73892 :
73893 : #if 0
73894 : // DQ (7/30/2014): Call a virtual function.
73895 : std::string s = this->class_name();
73896 : #endif
73897 :
73898 : // Test the variant virtual function
73899 : // assert(T_COMPLEX == variant());
73900 975 : assert(T_COMPLEX == this->variant());
73901 975 : ROSE_ASSERT(T_COMPLEX == (int)(this->variantT()));
73902 975 : post_construction_initialization();
73903 :
73904 : // Test the isSgTypeComplex() function since it has been problematic
73905 975 : assert(isSgTypeComplex(this) != NULL);
73906 975 : }
73907 :
73908 : // Generated constructor (all data members)
73909 :
73910 : /* #line 73911 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73911 :
73912 :
73913 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
73914 :
73915 :
73916 : // ********************************************************
73917 : // member functions common across all array grammar objects
73918 : // ********************************************************
73919 :
73920 :
73921 :
73922 : /* #line 73923 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73923 :
73924 :
73925 :
73926 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
73927 :
73928 : // ********************************************************
73929 : // member functions specific to each node in the grammar
73930 : // ********************************************************
73931 :
73932 :
73933 : /* #line 73934 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
73934 :
73935 : // Start of memberFunctionString
73936 : /* #line 8600 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
73937 :
73938 :
73939 : // DQ (8/27/2006): This code is used for both SgTypeComplex and SgTypeImaginary.
73940 :
73941 : SgTypeImaginary*
73942 0 : SgTypeImaginary::createType(SgType* t, SgExpression* optional_fortran_type_kind)
73943 : {
73944 : #if 0
73945 : printf ("In SgTypeImaginary::createType() (CREATE_TYPE_FOR_COMPLEX_TYPE) \n");
73946 : #endif
73947 :
73948 : // Not clear why this is using a map???
73949 0 : static std::map<SgType*, SgTypeImaginary*> cache;
73950 :
73951 0 : SgTypeImaginary*& returnType = cache[t];
73952 :
73953 0 : if (returnType == NULL)
73954 : {
73955 0 : returnType = new SgTypeImaginary(t);
73956 : }
73957 0 : ROSE_ASSERT(returnType != NULL);
73958 :
73959 0 : return returnType;
73960 : }
73961 :
73962 : SgExpression *
73963 0 : SgTypeImaginary::get_type_kind () const
73964 : {
73965 0 : return this->get_base_type()->get_type_kind();
73966 : }
73967 :
73968 : void
73969 0 : SgTypeImaginary::set_type_kind ( SgExpression* type_kind )
73970 : {
73971 0 : this->get_base_type()->set_type_kind(type_kind);
73972 0 : }
73973 :
73974 :
73975 :
73976 : // End of memberFunctionString
73977 : // Start of memberFunctionString
73978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
73979 :
73980 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
73981 :
73982 : SgType*
73983 0 : SgTypeImaginary::get_base_type () const
73984 : {
73985 0 : ROSE_ASSERT (this != NULL);
73986 :
73987 : #if 0
73988 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
73989 : // used to trigger marking transformations for the token-based unparsing.
73990 : printf ("SgTypeImaginary::get_base_type = %p = %s \n",this,this->class_name().c_str());
73991 : #endif
73992 :
73993 0 : return p_base_type;
73994 : }
73995 :
73996 : void
73997 0 : SgTypeImaginary::set_base_type ( SgType* base_type )
73998 : {
73999 0 : ROSE_ASSERT (this != NULL);
74000 :
74001 : #if 0
74002 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
74003 : // used to trigger marking transformations for the token-based unparsing.
74004 : printf ("SgTypeImaginary::set_base_type = %p = %s \n",this,this->class_name().c_str());
74005 : #endif
74006 :
74007 0 : set_isModified(true);
74008 :
74009 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
74010 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
74011 : {
74012 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
74013 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
74014 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
74015 : ROSE_ASSERT(false);
74016 : #endif
74017 : }
74018 : #endif
74019 0 : p_base_type = base_type;
74020 0 : }
74021 :
74022 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
74023 :
74024 :
74025 : // End of memberFunctionString
74026 : // Start of memberFunctionString
74027 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
74028 :
74029 : // *** COMMON CODE SECTION BEGINS HERE ***
74030 :
74031 : #if 0
74032 : int
74033 : SgTypeImaginary::getVariant() const
74034 : {
74035 : // This function is used in ROSE while "variant()" is used in SAGE
74036 : assert(this != NULL);
74037 : return variant();
74038 : }
74039 : #endif
74040 :
74041 : // This function is used in ROSE in treeTraversal code
74042 : // eventually replaces getVariant() and variant()
74043 : // though after variant() has been removed for a while we will
74044 : // want to change the name of variantT() back to variant()
74045 : // (since the "T" was ment to stand for temporary).
74046 : // When this happens the variantT() will be depricated.
74047 : VariantT
74048 0 : SgTypeImaginary::variantT() const
74049 : {
74050 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
74051 0 : ROSE_ASSERT(this != NULL);
74052 0 : return V_SgTypeImaginary;
74053 : }
74054 :
74055 : #if 0
74056 : int
74057 : SgTypeImaginary::variant() const
74058 : {
74059 : // This function is used in SAGE
74060 : ROSE_ASSERT(this != NULL);
74061 : return T_IMAGINARY;
74062 : }
74063 : #endif
74064 :
74065 : ROSE_DLL_API const char*
74066 0 : SgTypeImaginary::sage_class_name() const
74067 : {
74068 0 : ROSE_ASSERT(this != NULL);
74069 0 : return "SgTypeImaginary";
74070 : }
74071 :
74072 : std::string
74073 0 : SgTypeImaginary::class_name() const
74074 : {
74075 0 : ROSE_ASSERT(this != NULL);
74076 0 : return "SgTypeImaginary";
74077 : }
74078 :
74079 : // DQ (11/26/2005): Support for visitor pattern mechanims
74080 : // (inferior to ROSE traversal mechanism, experimental).
74081 : void
74082 0 : SgTypeImaginary::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
74083 : {
74084 0 : ROSE_ASSERT(this != NULL);
74085 0 : visitor.visit(this);
74086 0 : }
74087 :
74088 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
74089 0 : void SgTypeImaginary::accept (ROSE_VisitorPattern & visitor) {
74090 0 : ROSE_ASSERT(this != NULL);
74091 0 : visitor.visit(this);
74092 0 : }
74093 :
74094 : SgTypeImaginary*
74095 0 : SgTypeImaginary::addRegExpAttribute(std::string s, AstRegExAttribute* a)
74096 : {
74097 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
74098 : // This function is currently only supported for the AST used the represent Binary executables.
74099 : if (0 /* isSgAsmNode(this) != NULL */)
74100 : {
74101 : // Support for regex specification.
74102 : std::string prefixCode = "REGEX:";
74103 : addNewAttribute(prefixCode + s,a);
74104 : }
74105 : #endif
74106 :
74107 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
74108 0 : return this;
74109 : }
74110 :
74111 : // *** COMMON CODE SECTION ENDS HERE ***
74112 :
74113 :
74114 : // End of memberFunctionString
74115 : // Start of memberFunctionString
74116 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
74117 :
74118 :
74119 : #if 0
74120 : //! Error checking support
74121 : /*! Verifies the following:
74122 : - working getVariant() member function
74123 : - calls base class's error() member function
74124 : Every class has one of these functions.
74125 : */
74126 : bool
74127 : SgTypeImaginary::error()
74128 : {
74129 : // Put error checking here
74130 :
74131 : ROSE_ASSERT (this != NULL);
74132 : if (getVariant() != T_IMAGINARY)
74133 : {
74134 : printf ("Error in SgTypeImaginary::error(): SgTypeImaginary object has a %s variant \n",
74135 : Cxx_GrammarTerminalNames[getVariant()].name);
74136 : // printf ("Error in SgTypeImaginary::error() \n");
74137 : ROSE_ABORT();
74138 : }
74139 :
74140 : ROSE_ASSERT (getVariant() == T_IMAGINARY);
74141 : return SgType::error();
74142 : }
74143 : #endif
74144 :
74145 :
74146 :
74147 : // End of memberFunctionString
74148 : // Start of memberFunctionString
74149 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
74150 :
74151 : #if 1
74152 : /*! Support for mangled names (for unparser)
74153 : There are two different cases of source code for the get_mangled member function
74154 : This one is used in all but the classes containing a base type
74155 : */
74156 : // SgName SgTypeImaginary::get_mangled ( SgUnparse_Info & info )
74157 : SgName
74158 0 : SgTypeImaginary::get_mangled (void) const
74159 : {
74160 0 : ROSE_ASSERT(this != NULL);
74161 :
74162 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
74163 : // CR (3/6/2020): Now type_kind is also used for Jovial.
74164 0 : SgName name = "Imaginary";
74165 0 : if (get_type_kind() != NULL)
74166 : {
74167 : // name += get_type_kind()->get_mangled();
74168 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
74169 0 : SgValueExp* value = isSgValueExp(get_type_kind());
74170 0 : if (value != NULL)
74171 : {
74172 : // name += string("_") + StringUtility::numberToString(value->get_value());
74173 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
74174 : }
74175 : else
74176 : {
74177 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
74178 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
74179 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
74180 : // a different prefix for each type of named type. It come down to is there can be multiple
74181 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
74182 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
74183 : // I think the issue is that Imaginary is not defined for any of the SgNameType IR nodes.
74184 : #if 0
74185 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"Imaginary");
74186 : #endif
74187 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
74188 : }
74189 : }
74190 :
74191 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
74192 : // REMOVE_ME please!
74193 0 : if (isSgTypeFixed(this))
74194 : {
74195 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
74196 0 : if (fixed_type->get_scale() != NULL)
74197 : {
74198 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
74199 0 : if (value != NULL)
74200 : {
74201 0 : name += string("_") + value->get_constant_folded_value_as_string();
74202 : }
74203 : }
74204 0 : if (fixed_type->get_fraction() != NULL)
74205 : {
74206 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
74207 0 : if (value != NULL)
74208 : {
74209 0 : name += string("_") + value->get_constant_folded_value_as_string();
74210 : }
74211 : }
74212 : }
74213 :
74214 : #if 0
74215 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
74216 : #endif
74217 :
74218 0 : return name;
74219 : }
74220 : #endif
74221 :
74222 :
74223 : // End of memberFunctionString
74224 :
74225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
74226 :
74227 0 : SgTypeImaginary* isSgTypeImaginary ( SgNode* inputDerivedClassPointer )
74228 : {
74229 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
74230 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
74231 : // So to fix this we return NULL directly when the input is NULL and avoid the
74232 : // dynamic_cast in this case. This is likely a performance improvement as well.
74233 : // return dynamic_cast<SgTypeImaginary*>(inputDerivedClassPointer);
74234 : // Milind Chabbi (8/28/2013): isSgTypeImaginary uses table-driven castability instead of c++ default dynamic_cast
74235 : // this improves the running time performance by 10-20%.
74236 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeImaginary*>(inputDerivedClassPointer);
74237 0 : return IS_SgTypeImaginary_FAST_MACRO(inputDerivedClassPointer);
74238 : }
74239 :
74240 : // DQ (11/8/2003): Added version of functions taking const pointer
74241 0 : const SgTypeImaginary* isSgTypeImaginary ( const SgNode* inputDerivedClassPointer )
74242 : {
74243 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
74244 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
74245 : // So to fix this we return NULL directly when the input is NULL and avoid the
74246 : // dynamic_cast in this case. This is likely a performance improvement as well.
74247 : // return dynamic_cast<const SgTypeImaginary*>(inputDerivedClassPointer);
74248 : // Milind Chabbi (8/28/2013): isSgTypeImaginary uses table-driven castability instead of c++ default dynamic_cast
74249 : // this improves the running time performance by 10-20%.
74250 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeImaginary*>(inputDerivedClassPointer);
74251 0 : return IS_SgTypeImaginary_FAST_MACRO(inputDerivedClassPointer);
74252 : }
74253 :
74254 :
74255 :
74256 : /* #line 74257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74257 :
74258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
74259 :
74260 : /**
74261 : \brief Generated destructor
74262 :
74263 : This destructor is automatically generated (by ROSETTA). This destructor
74264 : only frees memory of data members associated with the parts of the current IR node which
74265 : are NOT traversed. Those data members that are part of a traversal can be freed using
74266 : a traversal (calling this destructor on all children in a post-order traversal). Such
74267 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
74268 :
74269 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
74270 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
74271 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
74272 :
74273 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
74274 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
74275 : pointers are not yet implemented to call delete on eash pointer in the container.
74276 : (This could be done by derivation from the STL containers to define containers that
74277 : automatically deleted their members.)
74278 :
74279 : */
74280 0 : SgTypeImaginary::~SgTypeImaginary () {
74281 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
74282 :
74283 :
74284 : // case: not a listType for base_type
74285 0 : p_base_type = NULL; // non list case
74286 :
74287 : }
74288 :
74289 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
74290 0 : }
74291 :
74292 :
74293 : /* #line 74294 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74294 :
74295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
74296 :
74297 : // Generated constructor
74298 0 : SgTypeImaginary::SgTypeImaginary ( SgType* base_type )
74299 0 : : SgType()
74300 : {
74301 : #ifdef DEBUG
74302 : // printf ("In SgTypeImaginary::SgTypeImaginary (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
74303 : #endif
74304 : #if 0
74305 : // debugging information!
74306 : printf ("In SgTypeImaginary::SgTypeImaginary (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
74307 : #endif
74308 :
74309 0 : p_base_type = base_type;
74310 :
74311 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
74312 :
74313 : #if 0
74314 : // DQ (7/30/2014): Call a virtual function.
74315 : std::string s = this->class_name();
74316 : #endif
74317 :
74318 : // Test the variant virtual function
74319 : // assert(T_IMAGINARY == variant());
74320 0 : assert(T_IMAGINARY == this->variant());
74321 0 : ROSE_ASSERT(T_IMAGINARY == (int)(this->variantT()));
74322 0 : post_construction_initialization();
74323 :
74324 : // Test the isSgTypeImaginary() function since it has been problematic
74325 0 : assert(isSgTypeImaginary(this) != NULL);
74326 0 : }
74327 :
74328 : // Generated constructor (all data members)
74329 :
74330 : /* #line 74331 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74331 :
74332 :
74333 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
74334 :
74335 :
74336 : // ********************************************************
74337 : // member functions common across all array grammar objects
74338 : // ********************************************************
74339 :
74340 :
74341 :
74342 : /* #line 74343 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74343 :
74344 :
74345 :
74346 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
74347 :
74348 : // ********************************************************
74349 : // member functions specific to each node in the grammar
74350 : // ********************************************************
74351 :
74352 :
74353 : /* #line 74354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74354 :
74355 : // Start of memberFunctionString
74356 :
74357 :
74358 : // End of memberFunctionString
74359 : // Start of memberFunctionString
74360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
74361 :
74362 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
74363 :
74364 : SgName
74365 0 : SgTypeDefault::get_name () const
74366 : {
74367 0 : ROSE_ASSERT (this != NULL);
74368 :
74369 : #if 0
74370 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
74371 : // used to trigger marking transformations for the token-based unparsing.
74372 : printf ("SgTypeDefault::get_name = %p = %s \n",this,this->class_name().c_str());
74373 : #endif
74374 :
74375 0 : return p_name;
74376 : }
74377 :
74378 : void
74379 0 : SgTypeDefault::set_name ( SgName name )
74380 : {
74381 0 : ROSE_ASSERT (this != NULL);
74382 :
74383 : #if 0
74384 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
74385 : // used to trigger marking transformations for the token-based unparsing.
74386 : printf ("SgTypeDefault::set_name = %p = %s \n",this,this->class_name().c_str());
74387 : #endif
74388 :
74389 0 : set_isModified(true);
74390 :
74391 0 : p_name = name;
74392 0 : }
74393 :
74394 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
74395 :
74396 :
74397 : // End of memberFunctionString
74398 : // Start of memberFunctionString
74399 : /* #line 3213 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
74400 :
74401 :
74402 : SgName
74403 34526 : SgTypeDefault::get_mangled (void) const
74404 : {
74405 34526 : ROSE_ASSERT(this != NULL);
74406 :
74407 34526 : SgName mangled_name;
74408 103578 : mangled_name << "__" << "MANGLED_ID_DEFAULT_TYPE" << "b__" // start tag
74409 69052 : << p_name.str() // name of default type
74410 103578 : << "__" << "MANGLED_ID_DEFAULT_TYPE" << "e__"; // end tag
74411 :
74412 : #if 0
74413 : printf ("LEAVING: In SgTypeDefault::get_mangled(): mangled_name = %s \n",mangled_name.str());
74414 : #endif
74415 :
74416 34526 : return mangled_name;
74417 : }
74418 :
74419 : SgTypeDefault*
74420 0 : SgTypeDefault::createType ( const SgName & nameOfType )
74421 : {
74422 : #if 0
74423 : printf ("In SgTypeDefault::createType(): calling new SgTypeDefault \n");
74424 : printf (" --- nameOfType = %s \n",nameOfType.str());
74425 : #endif
74426 :
74427 0 : SgTypeDefault* returnType = new SgTypeDefault();
74428 0 : if (nameOfType.is_null() == false)
74429 : {
74430 0 : returnType->set_name(nameOfType);
74431 : }
74432 0 : ROSE_ASSERT(returnType != NULL);
74433 :
74434 0 : SgName name = returnType->get_mangled();
74435 :
74436 : #if 0
74437 : printf ("In SgTypeDefault::createType(): Building a default type = %p mangled name = %s \n",returnType,name.str());
74438 : #endif
74439 :
74440 : // Only look for pointers to type in the global type table.
74441 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
74442 :
74443 0 : if (t == NULL)
74444 : {
74445 : // The pointer type was not found in the type table, put it into the global type table.
74446 : #if 0
74447 : printf ("Mangled type name for SgTypeDefault = %s (does NOT exist in type table) inserting it... \n",name.str());
74448 : #endif
74449 0 : get_globalTypeTable()->insert_type(name,returnType);
74450 : }
74451 : else
74452 : {
74453 : // If it is already present in the type table then delete the type (so that it will remain unique).
74454 : #if 0
74455 : printf ("Mangled type name for SgTypeDefault = %s (already exists in type table) \n",name.str());
74456 : #endif
74457 0 : ROSE_ASSERT(t != returnType);
74458 :
74459 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
74460 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
74461 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
74462 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
74463 0 : delete returnType;
74464 : #endif
74465 0 : returnType = NULL;
74466 :
74467 0 : returnType = isSgTypeDefault(t);
74468 : }
74469 :
74470 : #if 0
74471 : printf ("Leaving SgTypeDefault::createType(): returnType = %p \n",returnType);
74472 : #endif
74473 :
74474 0 : return returnType;
74475 : }
74476 :
74477 :
74478 :
74479 : // End of memberFunctionString
74480 : // Start of memberFunctionString
74481 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
74482 :
74483 : // *** COMMON CODE SECTION BEGINS HERE ***
74484 :
74485 : #if 0
74486 : int
74487 : SgTypeDefault::getVariant() const
74488 : {
74489 : // This function is used in ROSE while "variant()" is used in SAGE
74490 : assert(this != NULL);
74491 : return variant();
74492 : }
74493 : #endif
74494 :
74495 : // This function is used in ROSE in treeTraversal code
74496 : // eventually replaces getVariant() and variant()
74497 : // though after variant() has been removed for a while we will
74498 : // want to change the name of variantT() back to variant()
74499 : // (since the "T" was ment to stand for temporary).
74500 : // When this happens the variantT() will be depricated.
74501 : VariantT
74502 6039550 : SgTypeDefault::variantT() const
74503 : {
74504 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
74505 6039550 : ROSE_ASSERT(this != NULL);
74506 6039550 : return V_SgTypeDefault;
74507 : }
74508 :
74509 : #if 0
74510 : int
74511 : SgTypeDefault::variant() const
74512 : {
74513 : // This function is used in SAGE
74514 : ROSE_ASSERT(this != NULL);
74515 : return T_DEFAULT;
74516 : }
74517 : #endif
74518 :
74519 : ROSE_DLL_API const char*
74520 0 : SgTypeDefault::sage_class_name() const
74521 : {
74522 0 : ROSE_ASSERT(this != NULL);
74523 0 : return "SgTypeDefault";
74524 : }
74525 :
74526 : std::string
74527 6467 : SgTypeDefault::class_name() const
74528 : {
74529 6467 : ROSE_ASSERT(this != NULL);
74530 6467 : return "SgTypeDefault";
74531 : }
74532 :
74533 : // DQ (11/26/2005): Support for visitor pattern mechanims
74534 : // (inferior to ROSE traversal mechanism, experimental).
74535 : void
74536 349 : SgTypeDefault::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
74537 : {
74538 349 : ROSE_ASSERT(this != NULL);
74539 349 : visitor.visit(this);
74540 349 : }
74541 :
74542 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
74543 0 : void SgTypeDefault::accept (ROSE_VisitorPattern & visitor) {
74544 0 : ROSE_ASSERT(this != NULL);
74545 0 : visitor.visit(this);
74546 0 : }
74547 :
74548 : SgTypeDefault*
74549 0 : SgTypeDefault::addRegExpAttribute(std::string s, AstRegExAttribute* a)
74550 : {
74551 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
74552 : // This function is currently only supported for the AST used the represent Binary executables.
74553 : if (0 /* isSgAsmNode(this) != NULL */)
74554 : {
74555 : // Support for regex specification.
74556 : std::string prefixCode = "REGEX:";
74557 : addNewAttribute(prefixCode + s,a);
74558 : }
74559 : #endif
74560 :
74561 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
74562 0 : return this;
74563 : }
74564 :
74565 : // *** COMMON CODE SECTION ENDS HERE ***
74566 :
74567 :
74568 : // End of memberFunctionString
74569 : // Start of memberFunctionString
74570 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
74571 :
74572 :
74573 : #if 0
74574 : //! Error checking support
74575 : /*! Verifies the following:
74576 : - working getVariant() member function
74577 : - calls base class's error() member function
74578 : Every class has one of these functions.
74579 : */
74580 : bool
74581 : SgTypeDefault::error()
74582 : {
74583 : // Put error checking here
74584 :
74585 : ROSE_ASSERT (this != NULL);
74586 : if (getVariant() != T_DEFAULT)
74587 : {
74588 : printf ("Error in SgTypeDefault::error(): SgTypeDefault object has a %s variant \n",
74589 : Cxx_GrammarTerminalNames[getVariant()].name);
74590 : // printf ("Error in SgTypeDefault::error() \n");
74591 : ROSE_ABORT();
74592 : }
74593 :
74594 : ROSE_ASSERT (getVariant() == T_DEFAULT);
74595 : return SgType::error();
74596 : }
74597 : #endif
74598 :
74599 :
74600 :
74601 : // End of memberFunctionString
74602 : // Start of memberFunctionString
74603 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
74604 :
74605 :
74606 : // DQ (1/31/2006): Modified to build all types in the memory pools
74607 : // SgTypeDefault SgTypeDefault::builtin_type;
74608 : // SgTypeDefault* SgTypeDefault::builtin_type = new SgTypeDefault();
74609 : SgTypeDefault* SgTypeDefault::p_builtin_type = NULL;
74610 :
74611 :
74612 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
74613 : // SgTypeDefault* SgTypeDefault::createType(void)
74614 : SgTypeDefault*
74615 34516 : SgTypeDefault::createType(SgExpression* optional_fortran_type_kind)
74616 : {
74617 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
74618 : // is not called (likely because static initialization is compiler dependent).
74619 : // DQ (1/31/2006): Modified to build all types in the memory pools
74620 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
74621 : // return &builtin_type;
74622 :
74623 : #if 0
74624 : printf ("In SgTypeDefault::createType() (COMMON_CREATE_TYPE) \n");
74625 : #endif
74626 :
74627 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
74628 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
74629 :
74630 34516 : SgTypeDefault* temp_type = new SgTypeDefault();
74631 :
74632 : #if 0
74633 : printf ("In SgTypeDefault::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
74634 : #endif
74635 :
74636 : // DQ (10/31/2016): Added assertion.
74637 34516 : ROSE_ASSERT(temp_type != NULL);
74638 :
74639 34516 : if (optional_fortran_type_kind != NULL)
74640 : {
74641 : // DQ (10/31/2016): Added assertion.
74642 0 : ROSE_ASSERT(temp_type != NULL);
74643 :
74644 0 : temp_type->set_type_kind(optional_fortran_type_kind);
74645 : }
74646 : #if 0
74647 : else
74648 : {
74649 : // Let p_builtin_type refer to the unadorned type (no type kind).
74650 : p_builtin_type = temp_type;
74651 : }
74652 : #endif
74653 :
74654 34516 : SgName name = temp_type->get_mangled();
74655 :
74656 : #if 0
74657 : printf ("Mangled type name for SgTypeDefault = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
74658 : #endif
74659 :
74660 : // DQ (10/31/2016): Added assertion.
74661 34516 : ROSE_ASSERT(get_globalTypeTable() != NULL);
74662 :
74663 34516 : SgType* t = get_globalTypeTable()->lookup_type(name);
74664 :
74665 : #if 0
74666 : printf ("In SgTypeDefault::createType(): type from lookup_type = %p \n",t);
74667 : #endif
74668 :
74669 34516 : if (t == NULL)
74670 : {
74671 311 : get_globalTypeTable()->insert_type(name,temp_type);
74672 : }
74673 : else
74674 : {
74675 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
74676 34205 : if (t != temp_type)
74677 : {
74678 : #if 0
74679 : printf ("In SgTypeDefault::createType(): deleting temp_type = %p \n",temp_type);
74680 : #endif
74681 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
74682 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
74683 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
74684 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
74685 34205 : delete temp_type;
74686 : #endif
74687 34205 : temp_type = NULL;
74688 : #if 0
74689 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
74690 : if (optional_fortran_type_kind != NULL)
74691 : {
74692 : p_builtin_type = NULL;
74693 : }
74694 : #endif
74695 : }
74696 :
74697 : // Reuse this tempType variable so we can use the same code below.
74698 34205 : temp_type = isSgTypeDefault(t);
74699 34205 : ROSE_ASSERT(temp_type != NULL);
74700 : }
74701 :
74702 : #if 0
74703 : printf ("Leaving SgTypeDefault::createType(): temp_type = %p \n",temp_type);
74704 : #endif
74705 :
74706 34516 : return temp_type;
74707 : }
74708 :
74709 :
74710 :
74711 : // End of memberFunctionString
74712 :
74713 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
74714 :
74715 88103 : SgTypeDefault* isSgTypeDefault ( SgNode* inputDerivedClassPointer )
74716 : {
74717 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
74718 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
74719 : // So to fix this we return NULL directly when the input is NULL and avoid the
74720 : // dynamic_cast in this case. This is likely a performance improvement as well.
74721 : // return dynamic_cast<SgTypeDefault*>(inputDerivedClassPointer);
74722 : // Milind Chabbi (8/28/2013): isSgTypeDefault uses table-driven castability instead of c++ default dynamic_cast
74723 : // this improves the running time performance by 10-20%.
74724 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeDefault*>(inputDerivedClassPointer);
74725 88103 : return IS_SgTypeDefault_FAST_MACRO(inputDerivedClassPointer);
74726 : }
74727 :
74728 : // DQ (11/8/2003): Added version of functions taking const pointer
74729 0 : const SgTypeDefault* isSgTypeDefault ( const SgNode* inputDerivedClassPointer )
74730 : {
74731 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
74732 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
74733 : // So to fix this we return NULL directly when the input is NULL and avoid the
74734 : // dynamic_cast in this case. This is likely a performance improvement as well.
74735 : // return dynamic_cast<const SgTypeDefault*>(inputDerivedClassPointer);
74736 : // Milind Chabbi (8/28/2013): isSgTypeDefault uses table-driven castability instead of c++ default dynamic_cast
74737 : // this improves the running time performance by 10-20%.
74738 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeDefault*>(inputDerivedClassPointer);
74739 0 : return IS_SgTypeDefault_FAST_MACRO(inputDerivedClassPointer);
74740 : }
74741 :
74742 :
74743 :
74744 : /* #line 74745 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74745 :
74746 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
74747 :
74748 : /**
74749 : \brief Generated destructor
74750 :
74751 : This destructor is automatically generated (by ROSETTA). This destructor
74752 : only frees memory of data members associated with the parts of the current IR node which
74753 : are NOT traversed. Those data members that are part of a traversal can be freed using
74754 : a traversal (calling this destructor on all children in a post-order traversal). Such
74755 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
74756 :
74757 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
74758 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
74759 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
74760 :
74761 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
74762 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
74763 : pointers are not yet implemented to call delete on eash pointer in the container.
74764 : (This could be done by derivation from the STL containers to define containers that
74765 : automatically deleted their members.)
74766 :
74767 : */
74768 68426 : SgTypeDefault::~SgTypeDefault () {
74769 34213 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
74770 :
74771 :
74772 : // case: not a listType for name
74773 34213 : p_name = ""; // non list case
74774 :
74775 : }
74776 :
74777 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
74778 68426 : }
74779 :
74780 :
74781 : /* #line 74782 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74782 :
74783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
74784 :
74785 : // Generated constructor
74786 34836 : SgTypeDefault::SgTypeDefault ( )
74787 34836 : : SgType()
74788 : {
74789 : #ifdef DEBUG
74790 : // printf ("In SgTypeDefault::SgTypeDefault () sage_class_name() = %s \n",sage_class_name());
74791 : #endif
74792 : #if 0
74793 : // debugging information!
74794 : printf ("In SgTypeDefault::SgTypeDefault (): this = %p = %s \n",this,this->class_name().c_str());
74795 : #endif
74796 :
74797 34836 : p_name = "";
74798 :
74799 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
74800 :
74801 : #if 0
74802 : // DQ (7/30/2014): Call a virtual function.
74803 : std::string s = this->class_name();
74804 : #endif
74805 :
74806 : // Test the variant virtual function
74807 : // assert(T_DEFAULT == variant());
74808 34836 : assert(T_DEFAULT == this->variant());
74809 34836 : ROSE_ASSERT(T_DEFAULT == (int)(this->variantT()));
74810 34836 : post_construction_initialization();
74811 :
74812 : // Test the isSgTypeDefault() function since it has been problematic
74813 34836 : assert(isSgTypeDefault(this) != NULL);
74814 34836 : }
74815 :
74816 : // Generated constructor (all data members)
74817 :
74818 : /* #line 74819 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74819 :
74820 :
74821 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
74822 :
74823 :
74824 : // ********************************************************
74825 : // member functions common across all array grammar objects
74826 : // ********************************************************
74827 :
74828 :
74829 :
74830 : /* #line 74831 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74831 :
74832 :
74833 :
74834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
74835 :
74836 : // ********************************************************
74837 : // member functions specific to each node in the grammar
74838 : // ********************************************************
74839 :
74840 :
74841 : /* #line 74842 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
74842 :
74843 : // Start of memberFunctionString
74844 :
74845 :
74846 : // End of memberFunctionString
74847 : // Start of memberFunctionString
74848 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
74849 :
74850 : // *** COMMON CODE SECTION BEGINS HERE ***
74851 :
74852 : #if 0
74853 : int
74854 : SgTypeCAFTeam::getVariant() const
74855 : {
74856 : // This function is used in ROSE while "variant()" is used in SAGE
74857 : assert(this != NULL);
74858 : return variant();
74859 : }
74860 : #endif
74861 :
74862 : // This function is used in ROSE in treeTraversal code
74863 : // eventually replaces getVariant() and variant()
74864 : // though after variant() has been removed for a while we will
74865 : // want to change the name of variantT() back to variant()
74866 : // (since the "T" was ment to stand for temporary).
74867 : // When this happens the variantT() will be depricated.
74868 : VariantT
74869 0 : SgTypeCAFTeam::variantT() const
74870 : {
74871 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
74872 0 : ROSE_ASSERT(this != NULL);
74873 0 : return V_SgTypeCAFTeam;
74874 : }
74875 :
74876 : #if 0
74877 : int
74878 : SgTypeCAFTeam::variant() const
74879 : {
74880 : // This function is used in SAGE
74881 : ROSE_ASSERT(this != NULL);
74882 : return T_CAFTEAM;
74883 : }
74884 : #endif
74885 :
74886 : ROSE_DLL_API const char*
74887 0 : SgTypeCAFTeam::sage_class_name() const
74888 : {
74889 0 : ROSE_ASSERT(this != NULL);
74890 0 : return "SgTypeCAFTeam";
74891 : }
74892 :
74893 : std::string
74894 0 : SgTypeCAFTeam::class_name() const
74895 : {
74896 0 : ROSE_ASSERT(this != NULL);
74897 0 : return "SgTypeCAFTeam";
74898 : }
74899 :
74900 : // DQ (11/26/2005): Support for visitor pattern mechanims
74901 : // (inferior to ROSE traversal mechanism, experimental).
74902 : void
74903 0 : SgTypeCAFTeam::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
74904 : {
74905 0 : ROSE_ASSERT(this != NULL);
74906 0 : visitor.visit(this);
74907 0 : }
74908 :
74909 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
74910 0 : void SgTypeCAFTeam::accept (ROSE_VisitorPattern & visitor) {
74911 0 : ROSE_ASSERT(this != NULL);
74912 0 : visitor.visit(this);
74913 0 : }
74914 :
74915 : SgTypeCAFTeam*
74916 0 : SgTypeCAFTeam::addRegExpAttribute(std::string s, AstRegExAttribute* a)
74917 : {
74918 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
74919 : // This function is currently only supported for the AST used the represent Binary executables.
74920 : if (0 /* isSgAsmNode(this) != NULL */)
74921 : {
74922 : // Support for regex specification.
74923 : std::string prefixCode = "REGEX:";
74924 : addNewAttribute(prefixCode + s,a);
74925 : }
74926 : #endif
74927 :
74928 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
74929 0 : return this;
74930 : }
74931 :
74932 : // *** COMMON CODE SECTION ENDS HERE ***
74933 :
74934 :
74935 : // End of memberFunctionString
74936 : // Start of memberFunctionString
74937 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
74938 :
74939 :
74940 : #if 0
74941 : //! Error checking support
74942 : /*! Verifies the following:
74943 : - working getVariant() member function
74944 : - calls base class's error() member function
74945 : Every class has one of these functions.
74946 : */
74947 : bool
74948 : SgTypeCAFTeam::error()
74949 : {
74950 : // Put error checking here
74951 :
74952 : ROSE_ASSERT (this != NULL);
74953 : if (getVariant() != T_CAFTEAM)
74954 : {
74955 : printf ("Error in SgTypeCAFTeam::error(): SgTypeCAFTeam object has a %s variant \n",
74956 : Cxx_GrammarTerminalNames[getVariant()].name);
74957 : // printf ("Error in SgTypeCAFTeam::error() \n");
74958 : ROSE_ABORT();
74959 : }
74960 :
74961 : ROSE_ASSERT (getVariant() == T_CAFTEAM);
74962 : return SgType::error();
74963 : }
74964 : #endif
74965 :
74966 :
74967 :
74968 : // End of memberFunctionString
74969 : // Start of memberFunctionString
74970 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
74971 :
74972 :
74973 : // DQ (1/31/2006): Modified to build all types in the memory pools
74974 : // SgTypeCAFTeam SgTypeCAFTeam::builtin_type;
74975 : // SgTypeCAFTeam* SgTypeCAFTeam::builtin_type = new SgTypeCAFTeam();
74976 : SgTypeCAFTeam* SgTypeCAFTeam::p_builtin_type = NULL;
74977 :
74978 :
74979 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
74980 : // SgTypeCAFTeam* SgTypeCAFTeam::createType(void)
74981 : SgTypeCAFTeam*
74982 0 : SgTypeCAFTeam::createType(SgExpression* optional_fortran_type_kind)
74983 : {
74984 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
74985 : // is not called (likely because static initialization is compiler dependent).
74986 : // DQ (1/31/2006): Modified to build all types in the memory pools
74987 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
74988 : // return &builtin_type;
74989 :
74990 : #if 0
74991 : printf ("In SgTypeCAFTeam::createType() (COMMON_CREATE_TYPE) \n");
74992 : #endif
74993 :
74994 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
74995 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
74996 :
74997 0 : SgTypeCAFTeam* temp_type = new SgTypeCAFTeam();
74998 :
74999 : #if 0
75000 : printf ("In SgTypeCAFTeam::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
75001 : #endif
75002 :
75003 : // DQ (10/31/2016): Added assertion.
75004 0 : ROSE_ASSERT(temp_type != NULL);
75005 :
75006 0 : if (optional_fortran_type_kind != NULL)
75007 : {
75008 : // DQ (10/31/2016): Added assertion.
75009 0 : ROSE_ASSERT(temp_type != NULL);
75010 :
75011 0 : temp_type->set_type_kind(optional_fortran_type_kind);
75012 : }
75013 : #if 0
75014 : else
75015 : {
75016 : // Let p_builtin_type refer to the unadorned type (no type kind).
75017 : p_builtin_type = temp_type;
75018 : }
75019 : #endif
75020 :
75021 0 : SgName name = temp_type->get_mangled();
75022 :
75023 : #if 0
75024 : printf ("Mangled type name for SgTypeCAFTeam = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
75025 : #endif
75026 :
75027 : // DQ (10/31/2016): Added assertion.
75028 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
75029 :
75030 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
75031 :
75032 : #if 0
75033 : printf ("In SgTypeCAFTeam::createType(): type from lookup_type = %p \n",t);
75034 : #endif
75035 :
75036 0 : if (t == NULL)
75037 : {
75038 0 : get_globalTypeTable()->insert_type(name,temp_type);
75039 : }
75040 : else
75041 : {
75042 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
75043 0 : if (t != temp_type)
75044 : {
75045 : #if 0
75046 : printf ("In SgTypeCAFTeam::createType(): deleting temp_type = %p \n",temp_type);
75047 : #endif
75048 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
75049 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
75050 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
75051 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
75052 0 : delete temp_type;
75053 : #endif
75054 0 : temp_type = NULL;
75055 : #if 0
75056 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
75057 : if (optional_fortran_type_kind != NULL)
75058 : {
75059 : p_builtin_type = NULL;
75060 : }
75061 : #endif
75062 : }
75063 :
75064 : // Reuse this tempType variable so we can use the same code below.
75065 0 : temp_type = isSgTypeCAFTeam(t);
75066 0 : ROSE_ASSERT(temp_type != NULL);
75067 : }
75068 :
75069 : #if 0
75070 : printf ("Leaving SgTypeCAFTeam::createType(): temp_type = %p \n",temp_type);
75071 : #endif
75072 :
75073 0 : return temp_type;
75074 : }
75075 :
75076 :
75077 :
75078 : // End of memberFunctionString
75079 : // Start of memberFunctionString
75080 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
75081 :
75082 : #if 1
75083 : /*! Support for mangled names (for unparser)
75084 : There are two different cases of source code for the get_mangled member function
75085 : This one is used in all but the classes containing a base type
75086 : */
75087 : // SgName SgTypeCAFTeam::get_mangled ( SgUnparse_Info & info )
75088 : SgName
75089 0 : SgTypeCAFTeam::get_mangled (void) const
75090 : {
75091 0 : ROSE_ASSERT(this != NULL);
75092 :
75093 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
75094 : // CR (3/6/2020): Now type_kind is also used for Jovial.
75095 0 : SgName name = "s";
75096 0 : if (get_type_kind() != NULL)
75097 : {
75098 : // name += get_type_kind()->get_mangled();
75099 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
75100 0 : SgValueExp* value = isSgValueExp(get_type_kind());
75101 0 : if (value != NULL)
75102 : {
75103 : // name += string("_") + StringUtility::numberToString(value->get_value());
75104 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
75105 : }
75106 : else
75107 : {
75108 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
75109 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
75110 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
75111 : // a different prefix for each type of named type. It come down to is there can be multiple
75112 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
75113 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
75114 : // I think the issue is that s is not defined for any of the SgNameType IR nodes.
75115 : #if 0
75116 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"s");
75117 : #endif
75118 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
75119 : }
75120 : }
75121 :
75122 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
75123 : // REMOVE_ME please!
75124 0 : if (isSgTypeFixed(this))
75125 : {
75126 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
75127 0 : if (fixed_type->get_scale() != NULL)
75128 : {
75129 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
75130 0 : if (value != NULL)
75131 : {
75132 0 : name += string("_") + value->get_constant_folded_value_as_string();
75133 : }
75134 : }
75135 0 : if (fixed_type->get_fraction() != NULL)
75136 : {
75137 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
75138 0 : if (value != NULL)
75139 : {
75140 0 : name += string("_") + value->get_constant_folded_value_as_string();
75141 : }
75142 : }
75143 : }
75144 :
75145 : #if 0
75146 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
75147 : #endif
75148 :
75149 0 : return name;
75150 : }
75151 : #endif
75152 :
75153 :
75154 : // End of memberFunctionString
75155 :
75156 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
75157 :
75158 0 : SgTypeCAFTeam* isSgTypeCAFTeam ( SgNode* inputDerivedClassPointer )
75159 : {
75160 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
75161 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
75162 : // So to fix this we return NULL directly when the input is NULL and avoid the
75163 : // dynamic_cast in this case. This is likely a performance improvement as well.
75164 : // return dynamic_cast<SgTypeCAFTeam*>(inputDerivedClassPointer);
75165 : // Milind Chabbi (8/28/2013): isSgTypeCAFTeam uses table-driven castability instead of c++ default dynamic_cast
75166 : // this improves the running time performance by 10-20%.
75167 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeCAFTeam*>(inputDerivedClassPointer);
75168 0 : return IS_SgTypeCAFTeam_FAST_MACRO(inputDerivedClassPointer);
75169 : }
75170 :
75171 : // DQ (11/8/2003): Added version of functions taking const pointer
75172 0 : const SgTypeCAFTeam* isSgTypeCAFTeam ( const SgNode* inputDerivedClassPointer )
75173 : {
75174 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
75175 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
75176 : // So to fix this we return NULL directly when the input is NULL and avoid the
75177 : // dynamic_cast in this case. This is likely a performance improvement as well.
75178 : // return dynamic_cast<const SgTypeCAFTeam*>(inputDerivedClassPointer);
75179 : // Milind Chabbi (8/28/2013): isSgTypeCAFTeam uses table-driven castability instead of c++ default dynamic_cast
75180 : // this improves the running time performance by 10-20%.
75181 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeCAFTeam*>(inputDerivedClassPointer);
75182 0 : return IS_SgTypeCAFTeam_FAST_MACRO(inputDerivedClassPointer);
75183 : }
75184 :
75185 :
75186 :
75187 : /* #line 75188 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75188 :
75189 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
75190 :
75191 : /**
75192 : \brief Generated destructor
75193 :
75194 : This destructor is automatically generated (by ROSETTA). This destructor
75195 : only frees memory of data members associated with the parts of the current IR node which
75196 : are NOT traversed. Those data members that are part of a traversal can be freed using
75197 : a traversal (calling this destructor on all children in a post-order traversal). Such
75198 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
75199 :
75200 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
75201 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
75202 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
75203 :
75204 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
75205 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
75206 : pointers are not yet implemented to call delete on eash pointer in the container.
75207 : (This could be done by derivation from the STL containers to define containers that
75208 : automatically deleted their members.)
75209 :
75210 : */
75211 0 : SgTypeCAFTeam::~SgTypeCAFTeam () {
75212 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
75213 :
75214 :
75215 :
75216 : }
75217 :
75218 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
75219 0 : }
75220 :
75221 :
75222 : /* #line 75223 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75223 :
75224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
75225 :
75226 : // Generated constructor
75227 0 : SgTypeCAFTeam::SgTypeCAFTeam ( )
75228 0 : : SgType()
75229 : {
75230 : #ifdef DEBUG
75231 : // printf ("In SgTypeCAFTeam::SgTypeCAFTeam () sage_class_name() = %s \n",sage_class_name());
75232 : #endif
75233 : #if 0
75234 : // debugging information!
75235 : printf ("In SgTypeCAFTeam::SgTypeCAFTeam (): this = %p = %s \n",this,this->class_name().c_str());
75236 : #endif
75237 :
75238 :
75239 :
75240 : #if 0
75241 : // DQ (7/30/2014): Call a virtual function.
75242 : std::string s = this->class_name();
75243 : #endif
75244 :
75245 : // Test the variant virtual function
75246 : // assert(T_CAFTEAM == variant());
75247 0 : assert(T_CAFTEAM == this->variant());
75248 0 : ROSE_ASSERT(T_CAFTEAM == (int)(this->variantT()));
75249 0 : post_construction_initialization();
75250 :
75251 : // Test the isSgTypeCAFTeam() function since it has been problematic
75252 0 : assert(isSgTypeCAFTeam(this) != NULL);
75253 0 : }
75254 :
75255 : // Generated constructor (all data members)
75256 :
75257 : /* #line 75258 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75258 :
75259 :
75260 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
75261 :
75262 :
75263 : // ********************************************************
75264 : // member functions common across all array grammar objects
75265 : // ********************************************************
75266 :
75267 :
75268 :
75269 : /* #line 75270 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75270 :
75271 :
75272 :
75273 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
75274 :
75275 : // ********************************************************
75276 : // member functions specific to each node in the grammar
75277 : // ********************************************************
75278 :
75279 :
75280 : /* #line 75281 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75281 :
75282 : // Start of memberFunctionString
75283 :
75284 :
75285 : // End of memberFunctionString
75286 : // Start of memberFunctionString
75287 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
75288 :
75289 : // *** COMMON CODE SECTION BEGINS HERE ***
75290 :
75291 : #if 0
75292 : int
75293 : SgTypeCrayPointer::getVariant() const
75294 : {
75295 : // This function is used in ROSE while "variant()" is used in SAGE
75296 : assert(this != NULL);
75297 : return variant();
75298 : }
75299 : #endif
75300 :
75301 : // This function is used in ROSE in treeTraversal code
75302 : // eventually replaces getVariant() and variant()
75303 : // though after variant() has been removed for a while we will
75304 : // want to change the name of variantT() back to variant()
75305 : // (since the "T" was ment to stand for temporary).
75306 : // When this happens the variantT() will be depricated.
75307 : VariantT
75308 0 : SgTypeCrayPointer::variantT() const
75309 : {
75310 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
75311 0 : ROSE_ASSERT(this != NULL);
75312 0 : return V_SgTypeCrayPointer;
75313 : }
75314 :
75315 : #if 0
75316 : int
75317 : SgTypeCrayPointer::variant() const
75318 : {
75319 : // This function is used in SAGE
75320 : ROSE_ASSERT(this != NULL);
75321 : return T_CRAY_POINTER;
75322 : }
75323 : #endif
75324 :
75325 : ROSE_DLL_API const char*
75326 0 : SgTypeCrayPointer::sage_class_name() const
75327 : {
75328 0 : ROSE_ASSERT(this != NULL);
75329 0 : return "SgTypeCrayPointer";
75330 : }
75331 :
75332 : std::string
75333 0 : SgTypeCrayPointer::class_name() const
75334 : {
75335 0 : ROSE_ASSERT(this != NULL);
75336 0 : return "SgTypeCrayPointer";
75337 : }
75338 :
75339 : // DQ (11/26/2005): Support for visitor pattern mechanims
75340 : // (inferior to ROSE traversal mechanism, experimental).
75341 : void
75342 0 : SgTypeCrayPointer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
75343 : {
75344 0 : ROSE_ASSERT(this != NULL);
75345 0 : visitor.visit(this);
75346 0 : }
75347 :
75348 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
75349 0 : void SgTypeCrayPointer::accept (ROSE_VisitorPattern & visitor) {
75350 0 : ROSE_ASSERT(this != NULL);
75351 0 : visitor.visit(this);
75352 0 : }
75353 :
75354 : SgTypeCrayPointer*
75355 0 : SgTypeCrayPointer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
75356 : {
75357 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
75358 : // This function is currently only supported for the AST used the represent Binary executables.
75359 : if (0 /* isSgAsmNode(this) != NULL */)
75360 : {
75361 : // Support for regex specification.
75362 : std::string prefixCode = "REGEX:";
75363 : addNewAttribute(prefixCode + s,a);
75364 : }
75365 : #endif
75366 :
75367 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
75368 0 : return this;
75369 : }
75370 :
75371 : // *** COMMON CODE SECTION ENDS HERE ***
75372 :
75373 :
75374 : // End of memberFunctionString
75375 : // Start of memberFunctionString
75376 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
75377 :
75378 :
75379 : #if 0
75380 : //! Error checking support
75381 : /*! Verifies the following:
75382 : - working getVariant() member function
75383 : - calls base class's error() member function
75384 : Every class has one of these functions.
75385 : */
75386 : bool
75387 : SgTypeCrayPointer::error()
75388 : {
75389 : // Put error checking here
75390 :
75391 : ROSE_ASSERT (this != NULL);
75392 : if (getVariant() != T_CRAY_POINTER)
75393 : {
75394 : printf ("Error in SgTypeCrayPointer::error(): SgTypeCrayPointer object has a %s variant \n",
75395 : Cxx_GrammarTerminalNames[getVariant()].name);
75396 : // printf ("Error in SgTypeCrayPointer::error() \n");
75397 : ROSE_ABORT();
75398 : }
75399 :
75400 : ROSE_ASSERT (getVariant() == T_CRAY_POINTER);
75401 : return SgType::error();
75402 : }
75403 : #endif
75404 :
75405 :
75406 :
75407 : // End of memberFunctionString
75408 : // Start of memberFunctionString
75409 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
75410 :
75411 :
75412 : // DQ (1/31/2006): Modified to build all types in the memory pools
75413 : // SgTypeCrayPointer SgTypeCrayPointer::builtin_type;
75414 : // SgTypeCrayPointer* SgTypeCrayPointer::builtin_type = new SgTypeCrayPointer();
75415 : SgTypeCrayPointer* SgTypeCrayPointer::p_builtin_type = NULL;
75416 :
75417 :
75418 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
75419 : // SgTypeCrayPointer* SgTypeCrayPointer::createType(void)
75420 : SgTypeCrayPointer*
75421 0 : SgTypeCrayPointer::createType(SgExpression* optional_fortran_type_kind)
75422 : {
75423 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
75424 : // is not called (likely because static initialization is compiler dependent).
75425 : // DQ (1/31/2006): Modified to build all types in the memory pools
75426 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
75427 : // return &builtin_type;
75428 :
75429 : #if 0
75430 : printf ("In SgTypeCrayPointer::createType() (COMMON_CREATE_TYPE) \n");
75431 : #endif
75432 :
75433 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
75434 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
75435 :
75436 0 : SgTypeCrayPointer* temp_type = new SgTypeCrayPointer();
75437 :
75438 : #if 0
75439 : printf ("In SgTypeCrayPointer::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
75440 : #endif
75441 :
75442 : // DQ (10/31/2016): Added assertion.
75443 0 : ROSE_ASSERT(temp_type != NULL);
75444 :
75445 0 : if (optional_fortran_type_kind != NULL)
75446 : {
75447 : // DQ (10/31/2016): Added assertion.
75448 0 : ROSE_ASSERT(temp_type != NULL);
75449 :
75450 0 : temp_type->set_type_kind(optional_fortran_type_kind);
75451 : }
75452 : #if 0
75453 : else
75454 : {
75455 : // Let p_builtin_type refer to the unadorned type (no type kind).
75456 : p_builtin_type = temp_type;
75457 : }
75458 : #endif
75459 :
75460 0 : SgName name = temp_type->get_mangled();
75461 :
75462 : #if 0
75463 : printf ("Mangled type name for SgTypeCrayPointer = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
75464 : #endif
75465 :
75466 : // DQ (10/31/2016): Added assertion.
75467 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
75468 :
75469 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
75470 :
75471 : #if 0
75472 : printf ("In SgTypeCrayPointer::createType(): type from lookup_type = %p \n",t);
75473 : #endif
75474 :
75475 0 : if (t == NULL)
75476 : {
75477 0 : get_globalTypeTable()->insert_type(name,temp_type);
75478 : }
75479 : else
75480 : {
75481 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
75482 0 : if (t != temp_type)
75483 : {
75484 : #if 0
75485 : printf ("In SgTypeCrayPointer::createType(): deleting temp_type = %p \n",temp_type);
75486 : #endif
75487 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
75488 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
75489 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
75490 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
75491 0 : delete temp_type;
75492 : #endif
75493 0 : temp_type = NULL;
75494 : #if 0
75495 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
75496 : if (optional_fortran_type_kind != NULL)
75497 : {
75498 : p_builtin_type = NULL;
75499 : }
75500 : #endif
75501 : }
75502 :
75503 : // Reuse this tempType variable so we can use the same code below.
75504 0 : temp_type = isSgTypeCrayPointer(t);
75505 0 : ROSE_ASSERT(temp_type != NULL);
75506 : }
75507 :
75508 : #if 0
75509 : printf ("Leaving SgTypeCrayPointer::createType(): temp_type = %p \n",temp_type);
75510 : #endif
75511 :
75512 0 : return temp_type;
75513 : }
75514 :
75515 :
75516 :
75517 : // End of memberFunctionString
75518 : // Start of memberFunctionString
75519 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
75520 :
75521 : #if 1
75522 : /*! Support for mangled names (for unparser)
75523 : There are two different cases of source code for the get_mangled member function
75524 : This one is used in all but the classes containing a base type
75525 : */
75526 : // SgName SgTypeCrayPointer::get_mangled ( SgUnparse_Info & info )
75527 : SgName
75528 0 : SgTypeCrayPointer::get_mangled (void) const
75529 : {
75530 0 : ROSE_ASSERT(this != NULL);
75531 :
75532 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
75533 : // CR (3/6/2020): Now type_kind is also used for Jovial.
75534 0 : SgName name = "CrayPointer";
75535 0 : if (get_type_kind() != NULL)
75536 : {
75537 : // name += get_type_kind()->get_mangled();
75538 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
75539 0 : SgValueExp* value = isSgValueExp(get_type_kind());
75540 0 : if (value != NULL)
75541 : {
75542 : // name += string("_") + StringUtility::numberToString(value->get_value());
75543 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
75544 : }
75545 : else
75546 : {
75547 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
75548 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
75549 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
75550 : // a different prefix for each type of named type. It come down to is there can be multiple
75551 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
75552 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
75553 : // I think the issue is that CrayPointer is not defined for any of the SgNameType IR nodes.
75554 : #if 0
75555 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"CrayPointer");
75556 : #endif
75557 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
75558 : }
75559 : }
75560 :
75561 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
75562 : // REMOVE_ME please!
75563 0 : if (isSgTypeFixed(this))
75564 : {
75565 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
75566 0 : if (fixed_type->get_scale() != NULL)
75567 : {
75568 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
75569 0 : if (value != NULL)
75570 : {
75571 0 : name += string("_") + value->get_constant_folded_value_as_string();
75572 : }
75573 : }
75574 0 : if (fixed_type->get_fraction() != NULL)
75575 : {
75576 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
75577 0 : if (value != NULL)
75578 : {
75579 0 : name += string("_") + value->get_constant_folded_value_as_string();
75580 : }
75581 : }
75582 : }
75583 :
75584 : #if 0
75585 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
75586 : #endif
75587 :
75588 0 : return name;
75589 : }
75590 : #endif
75591 :
75592 :
75593 : // End of memberFunctionString
75594 :
75595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
75596 :
75597 128 : SgTypeCrayPointer* isSgTypeCrayPointer ( SgNode* inputDerivedClassPointer )
75598 : {
75599 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
75600 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
75601 : // So to fix this we return NULL directly when the input is NULL and avoid the
75602 : // dynamic_cast in this case. This is likely a performance improvement as well.
75603 : // return dynamic_cast<SgTypeCrayPointer*>(inputDerivedClassPointer);
75604 : // Milind Chabbi (8/28/2013): isSgTypeCrayPointer uses table-driven castability instead of c++ default dynamic_cast
75605 : // this improves the running time performance by 10-20%.
75606 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeCrayPointer*>(inputDerivedClassPointer);
75607 128 : return IS_SgTypeCrayPointer_FAST_MACRO(inputDerivedClassPointer);
75608 : }
75609 :
75610 : // DQ (11/8/2003): Added version of functions taking const pointer
75611 0 : const SgTypeCrayPointer* isSgTypeCrayPointer ( const SgNode* inputDerivedClassPointer )
75612 : {
75613 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
75614 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
75615 : // So to fix this we return NULL directly when the input is NULL and avoid the
75616 : // dynamic_cast in this case. This is likely a performance improvement as well.
75617 : // return dynamic_cast<const SgTypeCrayPointer*>(inputDerivedClassPointer);
75618 : // Milind Chabbi (8/28/2013): isSgTypeCrayPointer uses table-driven castability instead of c++ default dynamic_cast
75619 : // this improves the running time performance by 10-20%.
75620 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeCrayPointer*>(inputDerivedClassPointer);
75621 0 : return IS_SgTypeCrayPointer_FAST_MACRO(inputDerivedClassPointer);
75622 : }
75623 :
75624 :
75625 :
75626 : /* #line 75627 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75627 :
75628 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
75629 :
75630 : /**
75631 : \brief Generated destructor
75632 :
75633 : This destructor is automatically generated (by ROSETTA). This destructor
75634 : only frees memory of data members associated with the parts of the current IR node which
75635 : are NOT traversed. Those data members that are part of a traversal can be freed using
75636 : a traversal (calling this destructor on all children in a post-order traversal). Such
75637 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
75638 :
75639 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
75640 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
75641 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
75642 :
75643 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
75644 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
75645 : pointers are not yet implemented to call delete on eash pointer in the container.
75646 : (This could be done by derivation from the STL containers to define containers that
75647 : automatically deleted their members.)
75648 :
75649 : */
75650 0 : SgTypeCrayPointer::~SgTypeCrayPointer () {
75651 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
75652 :
75653 :
75654 :
75655 : }
75656 :
75657 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
75658 0 : }
75659 :
75660 :
75661 : /* #line 75662 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75662 :
75663 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
75664 :
75665 : // Generated constructor
75666 0 : SgTypeCrayPointer::SgTypeCrayPointer ( )
75667 0 : : SgType()
75668 : {
75669 : #ifdef DEBUG
75670 : // printf ("In SgTypeCrayPointer::SgTypeCrayPointer () sage_class_name() = %s \n",sage_class_name());
75671 : #endif
75672 : #if 0
75673 : // debugging information!
75674 : printf ("In SgTypeCrayPointer::SgTypeCrayPointer (): this = %p = %s \n",this,this->class_name().c_str());
75675 : #endif
75676 :
75677 :
75678 :
75679 : #if 0
75680 : // DQ (7/30/2014): Call a virtual function.
75681 : std::string s = this->class_name();
75682 : #endif
75683 :
75684 : // Test the variant virtual function
75685 : // assert(T_CRAY_POINTER == variant());
75686 0 : assert(T_CRAY_POINTER == this->variant());
75687 0 : ROSE_ASSERT(T_CRAY_POINTER == (int)(this->variantT()));
75688 0 : post_construction_initialization();
75689 :
75690 : // Test the isSgTypeCrayPointer() function since it has been problematic
75691 0 : assert(isSgTypeCrayPointer(this) != NULL);
75692 0 : }
75693 :
75694 : // Generated constructor (all data members)
75695 :
75696 : /* #line 75697 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75697 :
75698 :
75699 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
75700 :
75701 :
75702 : // ********************************************************
75703 : // member functions common across all array grammar objects
75704 : // ********************************************************
75705 :
75706 :
75707 :
75708 : /* #line 75709 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75709 :
75710 :
75711 :
75712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
75713 :
75714 : // ********************************************************
75715 : // member functions specific to each node in the grammar
75716 : // ********************************************************
75717 :
75718 :
75719 : /* #line 75720 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
75720 :
75721 : // Start of memberFunctionString
75722 :
75723 :
75724 : // End of memberFunctionString
75725 : // Start of memberFunctionString
75726 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
75727 :
75728 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
75729 :
75730 : SgName
75731 0 : SgTypeLabel::get_name () const
75732 : {
75733 0 : ROSE_ASSERT (this != NULL);
75734 :
75735 : #if 0
75736 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
75737 : // used to trigger marking transformations for the token-based unparsing.
75738 : printf ("SgTypeLabel::get_name = %p = %s \n",this,this->class_name().c_str());
75739 : #endif
75740 :
75741 0 : return p_name;
75742 : }
75743 :
75744 : void
75745 0 : SgTypeLabel::set_name ( SgName name )
75746 : {
75747 0 : ROSE_ASSERT (this != NULL);
75748 :
75749 : #if 0
75750 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
75751 : // used to trigger marking transformations for the token-based unparsing.
75752 : printf ("SgTypeLabel::set_name = %p = %s \n",this,this->class_name().c_str());
75753 : #endif
75754 :
75755 0 : set_isModified(true);
75756 :
75757 0 : p_name = name;
75758 0 : }
75759 :
75760 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
75761 :
75762 :
75763 : // End of memberFunctionString
75764 : // Start of memberFunctionString
75765 : /* #line 3293 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
75766 :
75767 :
75768 : SgName
75769 0 : SgTypeLabel::get_mangled (void) const
75770 : {
75771 0 : ROSE_ASSERT(this != NULL);
75772 :
75773 0 : SgName mangled_name;
75774 0 : mangled_name << "__" << "MANGLED_ID_LABEL_TYPE" << "b__" // start tag
75775 0 : << p_name.str() // name of default type
75776 0 : << "__" << "MANGLED_ID_LABEL_TYPE" << "e__"; // end tag
75777 :
75778 : #if 0
75779 : printf ("LEAVING: In SgTypeLabel::get_mangled(): mangled_name = %s \n",mangled_name.str());
75780 : #endif
75781 :
75782 0 : return mangled_name;
75783 : }
75784 :
75785 : SgTypeLabel*
75786 0 : SgTypeLabel::createType ( const SgName & nameOfType )
75787 : {
75788 : #if 0
75789 : printf ("In SgTypeLabel::createType(): \n");
75790 : #endif
75791 :
75792 0 : SgTypeLabel* returnType = new SgTypeLabel();
75793 0 : if (nameOfType.is_null() == false)
75794 : {
75795 0 : returnType->set_name(nameOfType);
75796 : }
75797 0 : ROSE_ASSERT(returnType != NULL);
75798 :
75799 0 : SgName name = returnType->get_mangled();
75800 :
75801 : #if 0
75802 : printf ("In SgTypeLabel::createType(): Building a label type = %p mangled name = %s \n",returnType,name.str());
75803 : #endif
75804 :
75805 : // Only look for pointers to type in the global type table.
75806 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
75807 :
75808 0 : if (t == NULL)
75809 : {
75810 : // The pointer type was not found in the type table, put it into the global type table.
75811 : #if 0
75812 : printf ("Mangled type name for SgTypeLabel = %s (does NOT exist in type table) inserting it... \n",name.str());
75813 : #endif
75814 0 : get_globalTypeTable()->insert_type(name,returnType);
75815 : }
75816 : else
75817 : {
75818 : // If it is already present in the type table then delete the type (so that it will remain unique).
75819 : #if 0
75820 : printf ("Mangled type name for SgStringType = %s (already exists in type table) \n",name.str());
75821 : #endif
75822 0 : ROSE_ASSERT(t != returnType);
75823 :
75824 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
75825 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
75826 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
75827 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
75828 0 : delete returnType;
75829 : #endif
75830 0 : returnType = NULL;
75831 :
75832 0 : returnType = isSgTypeLabel(t);
75833 : }
75834 :
75835 0 : return returnType;
75836 : }
75837 :
75838 :
75839 :
75840 : // End of memberFunctionString
75841 : // Start of memberFunctionString
75842 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
75843 :
75844 : // *** COMMON CODE SECTION BEGINS HERE ***
75845 :
75846 : #if 0
75847 : int
75848 : SgTypeLabel::getVariant() const
75849 : {
75850 : // This function is used in ROSE while "variant()" is used in SAGE
75851 : assert(this != NULL);
75852 : return variant();
75853 : }
75854 : #endif
75855 :
75856 : // This function is used in ROSE in treeTraversal code
75857 : // eventually replaces getVariant() and variant()
75858 : // though after variant() has been removed for a while we will
75859 : // want to change the name of variantT() back to variant()
75860 : // (since the "T" was ment to stand for temporary).
75861 : // When this happens the variantT() will be depricated.
75862 : VariantT
75863 0 : SgTypeLabel::variantT() const
75864 : {
75865 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
75866 0 : ROSE_ASSERT(this != NULL);
75867 0 : return V_SgTypeLabel;
75868 : }
75869 :
75870 : #if 0
75871 : int
75872 : SgTypeLabel::variant() const
75873 : {
75874 : // This function is used in SAGE
75875 : ROSE_ASSERT(this != NULL);
75876 : return T_LABEL;
75877 : }
75878 : #endif
75879 :
75880 : ROSE_DLL_API const char*
75881 0 : SgTypeLabel::sage_class_name() const
75882 : {
75883 0 : ROSE_ASSERT(this != NULL);
75884 0 : return "SgTypeLabel";
75885 : }
75886 :
75887 : std::string
75888 0 : SgTypeLabel::class_name() const
75889 : {
75890 0 : ROSE_ASSERT(this != NULL);
75891 0 : return "SgTypeLabel";
75892 : }
75893 :
75894 : // DQ (11/26/2005): Support for visitor pattern mechanims
75895 : // (inferior to ROSE traversal mechanism, experimental).
75896 : void
75897 0 : SgTypeLabel::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
75898 : {
75899 0 : ROSE_ASSERT(this != NULL);
75900 0 : visitor.visit(this);
75901 0 : }
75902 :
75903 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
75904 0 : void SgTypeLabel::accept (ROSE_VisitorPattern & visitor) {
75905 0 : ROSE_ASSERT(this != NULL);
75906 0 : visitor.visit(this);
75907 0 : }
75908 :
75909 : SgTypeLabel*
75910 0 : SgTypeLabel::addRegExpAttribute(std::string s, AstRegExAttribute* a)
75911 : {
75912 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
75913 : // This function is currently only supported for the AST used the represent Binary executables.
75914 : if (0 /* isSgAsmNode(this) != NULL */)
75915 : {
75916 : // Support for regex specification.
75917 : std::string prefixCode = "REGEX:";
75918 : addNewAttribute(prefixCode + s,a);
75919 : }
75920 : #endif
75921 :
75922 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
75923 0 : return this;
75924 : }
75925 :
75926 : // *** COMMON CODE SECTION ENDS HERE ***
75927 :
75928 :
75929 : // End of memberFunctionString
75930 : // Start of memberFunctionString
75931 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
75932 :
75933 :
75934 : #if 0
75935 : //! Error checking support
75936 : /*! Verifies the following:
75937 : - working getVariant() member function
75938 : - calls base class's error() member function
75939 : Every class has one of these functions.
75940 : */
75941 : bool
75942 : SgTypeLabel::error()
75943 : {
75944 : // Put error checking here
75945 :
75946 : ROSE_ASSERT (this != NULL);
75947 : if (getVariant() != T_LABEL)
75948 : {
75949 : printf ("Error in SgTypeLabel::error(): SgTypeLabel object has a %s variant \n",
75950 : Cxx_GrammarTerminalNames[getVariant()].name);
75951 : // printf ("Error in SgTypeLabel::error() \n");
75952 : ROSE_ABORT();
75953 : }
75954 :
75955 : ROSE_ASSERT (getVariant() == T_LABEL);
75956 : return SgType::error();
75957 : }
75958 : #endif
75959 :
75960 :
75961 :
75962 : // End of memberFunctionString
75963 : // Start of memberFunctionString
75964 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
75965 :
75966 :
75967 : // DQ (1/31/2006): Modified to build all types in the memory pools
75968 : // SgTypeLabel SgTypeLabel::builtin_type;
75969 : // SgTypeLabel* SgTypeLabel::builtin_type = new SgTypeLabel();
75970 : SgTypeLabel* SgTypeLabel::p_builtin_type = NULL;
75971 :
75972 :
75973 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
75974 : // SgTypeLabel* SgTypeLabel::createType(void)
75975 : SgTypeLabel*
75976 0 : SgTypeLabel::createType(SgExpression* optional_fortran_type_kind)
75977 : {
75978 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
75979 : // is not called (likely because static initialization is compiler dependent).
75980 : // DQ (1/31/2006): Modified to build all types in the memory pools
75981 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
75982 : // return &builtin_type;
75983 :
75984 : #if 0
75985 : printf ("In SgTypeLabel::createType() (COMMON_CREATE_TYPE) \n");
75986 : #endif
75987 :
75988 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
75989 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
75990 :
75991 0 : SgTypeLabel* temp_type = new SgTypeLabel();
75992 :
75993 : #if 0
75994 : printf ("In SgTypeLabel::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
75995 : #endif
75996 :
75997 : // DQ (10/31/2016): Added assertion.
75998 0 : ROSE_ASSERT(temp_type != NULL);
75999 :
76000 0 : if (optional_fortran_type_kind != NULL)
76001 : {
76002 : // DQ (10/31/2016): Added assertion.
76003 0 : ROSE_ASSERT(temp_type != NULL);
76004 :
76005 0 : temp_type->set_type_kind(optional_fortran_type_kind);
76006 : }
76007 : #if 0
76008 : else
76009 : {
76010 : // Let p_builtin_type refer to the unadorned type (no type kind).
76011 : p_builtin_type = temp_type;
76012 : }
76013 : #endif
76014 :
76015 0 : SgName name = temp_type->get_mangled();
76016 :
76017 : #if 0
76018 : printf ("Mangled type name for SgTypeLabel = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
76019 : #endif
76020 :
76021 : // DQ (10/31/2016): Added assertion.
76022 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
76023 :
76024 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
76025 :
76026 : #if 0
76027 : printf ("In SgTypeLabel::createType(): type from lookup_type = %p \n",t);
76028 : #endif
76029 :
76030 0 : if (t == NULL)
76031 : {
76032 0 : get_globalTypeTable()->insert_type(name,temp_type);
76033 : }
76034 : else
76035 : {
76036 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
76037 0 : if (t != temp_type)
76038 : {
76039 : #if 0
76040 : printf ("In SgTypeLabel::createType(): deleting temp_type = %p \n",temp_type);
76041 : #endif
76042 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
76043 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
76044 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
76045 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
76046 0 : delete temp_type;
76047 : #endif
76048 0 : temp_type = NULL;
76049 : #if 0
76050 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
76051 : if (optional_fortran_type_kind != NULL)
76052 : {
76053 : p_builtin_type = NULL;
76054 : }
76055 : #endif
76056 : }
76057 :
76058 : // Reuse this tempType variable so we can use the same code below.
76059 0 : temp_type = isSgTypeLabel(t);
76060 0 : ROSE_ASSERT(temp_type != NULL);
76061 : }
76062 :
76063 : #if 0
76064 : printf ("Leaving SgTypeLabel::createType(): temp_type = %p \n",temp_type);
76065 : #endif
76066 :
76067 0 : return temp_type;
76068 : }
76069 :
76070 :
76071 :
76072 : // End of memberFunctionString
76073 :
76074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
76075 :
76076 0 : SgTypeLabel* isSgTypeLabel ( SgNode* inputDerivedClassPointer )
76077 : {
76078 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
76079 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
76080 : // So to fix this we return NULL directly when the input is NULL and avoid the
76081 : // dynamic_cast in this case. This is likely a performance improvement as well.
76082 : // return dynamic_cast<SgTypeLabel*>(inputDerivedClassPointer);
76083 : // Milind Chabbi (8/28/2013): isSgTypeLabel uses table-driven castability instead of c++ default dynamic_cast
76084 : // this improves the running time performance by 10-20%.
76085 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeLabel*>(inputDerivedClassPointer);
76086 0 : return IS_SgTypeLabel_FAST_MACRO(inputDerivedClassPointer);
76087 : }
76088 :
76089 : // DQ (11/8/2003): Added version of functions taking const pointer
76090 0 : const SgTypeLabel* isSgTypeLabel ( const SgNode* inputDerivedClassPointer )
76091 : {
76092 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
76093 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
76094 : // So to fix this we return NULL directly when the input is NULL and avoid the
76095 : // dynamic_cast in this case. This is likely a performance improvement as well.
76096 : // return dynamic_cast<const SgTypeLabel*>(inputDerivedClassPointer);
76097 : // Milind Chabbi (8/28/2013): isSgTypeLabel uses table-driven castability instead of c++ default dynamic_cast
76098 : // this improves the running time performance by 10-20%.
76099 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeLabel*>(inputDerivedClassPointer);
76100 0 : return IS_SgTypeLabel_FAST_MACRO(inputDerivedClassPointer);
76101 : }
76102 :
76103 :
76104 :
76105 : /* #line 76106 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76106 :
76107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
76108 :
76109 : /**
76110 : \brief Generated destructor
76111 :
76112 : This destructor is automatically generated (by ROSETTA). This destructor
76113 : only frees memory of data members associated with the parts of the current IR node which
76114 : are NOT traversed. Those data members that are part of a traversal can be freed using
76115 : a traversal (calling this destructor on all children in a post-order traversal). Such
76116 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
76117 :
76118 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
76119 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
76120 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
76121 :
76122 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
76123 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
76124 : pointers are not yet implemented to call delete on eash pointer in the container.
76125 : (This could be done by derivation from the STL containers to define containers that
76126 : automatically deleted their members.)
76127 :
76128 : */
76129 0 : SgTypeLabel::~SgTypeLabel () {
76130 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
76131 :
76132 :
76133 : // case: not a listType for name
76134 0 : p_name = ""; // non list case
76135 :
76136 : }
76137 :
76138 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
76139 0 : }
76140 :
76141 :
76142 : /* #line 76143 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76143 :
76144 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
76145 :
76146 : // Generated constructor
76147 0 : SgTypeLabel::SgTypeLabel ( )
76148 0 : : SgType()
76149 : {
76150 : #ifdef DEBUG
76151 : // printf ("In SgTypeLabel::SgTypeLabel () sage_class_name() = %s \n",sage_class_name());
76152 : #endif
76153 : #if 0
76154 : // debugging information!
76155 : printf ("In SgTypeLabel::SgTypeLabel (): this = %p = %s \n",this,this->class_name().c_str());
76156 : #endif
76157 :
76158 0 : p_name = "";
76159 :
76160 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
76161 :
76162 : #if 0
76163 : // DQ (7/30/2014): Call a virtual function.
76164 : std::string s = this->class_name();
76165 : #endif
76166 :
76167 : // Test the variant virtual function
76168 : // assert(T_LABEL == variant());
76169 0 : assert(T_LABEL == this->variant());
76170 0 : ROSE_ASSERT(T_LABEL == (int)(this->variantT()));
76171 0 : post_construction_initialization();
76172 :
76173 : // Test the isSgTypeLabel() function since it has been problematic
76174 0 : assert(isSgTypeLabel(this) != NULL);
76175 0 : }
76176 :
76177 : // Generated constructor (all data members)
76178 :
76179 : /* #line 76180 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76180 :
76181 :
76182 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
76183 :
76184 :
76185 : // ********************************************************
76186 : // member functions common across all array grammar objects
76187 : // ********************************************************
76188 :
76189 :
76190 :
76191 : /* #line 76192 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76192 :
76193 :
76194 :
76195 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
76196 :
76197 : // ********************************************************
76198 : // member functions specific to each node in the grammar
76199 : // ********************************************************
76200 :
76201 :
76202 : /* #line 76203 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76203 :
76204 : // Start of memberFunctionString
76205 : /* #line 7584 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
76206 :
76207 : SgRvalueReferenceType*
76208 1783 : SgRvalueReferenceType::createType(SgType* base_type, SgExpression* optional_fortran_type_kind)
76209 : {
76210 1783 : ROSE_ASSERT(base_type != NULL);
76211 :
76212 : // DQ (7/29/2014): I think that rvalue reference types can't have a kind parameter, so this should be NULL.
76213 1783 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
76214 :
76215 : #if 0
76216 : printf ("In SgRvalueReferenceType::createType() \n");
76217 : #endif
76218 :
76219 1783 : if (base_type->p_rvalue_ref_to)
76220 : {
76221 : return base_type->p_rvalue_ref_to;
76222 : }
76223 : else
76224 : {
76225 1677 : SgRvalueReferenceType* newType = new SgRvalueReferenceType(base_type);
76226 1677 : assert(newType != NULL);
76227 :
76228 1677 : SgName name = newType->get_mangled();
76229 :
76230 : #if 0
76231 : printf ("Building a rvalue reference to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
76232 : #endif
76233 : // Only look for pointers to type in the global type table.
76234 1677 : SgType* t = get_globalTypeTable()->lookup_type(name);
76235 :
76236 1677 : if (t == NULL)
76237 : {
76238 : // The pointer type was not found in the type table, put it into the global type table.
76239 1677 : SgType* root_type = base_type->stripType();
76240 1677 : ROSE_ASSERT(root_type != NULL);
76241 1677 : if (handledUsingLocalTable(root_type) == false)
76242 : {
76243 : #if 0
76244 : printf ("Mangled type name for SgRvalueReferenceType = %s (does NOT exist in type table) inserting it... \n",name.str());
76245 : #endif
76246 18 : get_globalTypeTable()->insert_type(name,newType);
76247 : }
76248 : else
76249 : {
76250 : #if 0
76251 : printf ("Skip putting the SgReferenceType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
76252 : #endif
76253 : }
76254 : }
76255 : else
76256 : {
76257 : // If it is already present in the type table then delete the type (so that it will remain unique).
76258 : #if 0
76259 : printf ("Mangled type name for SgReferenceType = %s (already exists in type table) \n",name.str());
76260 : #endif
76261 0 : ROSE_ASSERT(t != newType);
76262 :
76263 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
76264 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
76265 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
76266 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
76267 0 : delete newType;
76268 : #endif
76269 0 : newType = NULL;
76270 :
76271 0 : newType = isSgRvalueReferenceType(t);
76272 : }
76273 :
76274 1677 : base_type->p_rvalue_ref_to = newType;
76275 1677 : assert(base_type->p_rvalue_ref_to != NULL);
76276 :
76277 1677 : return base_type->p_rvalue_ref_to;
76278 : }
76279 : }
76280 :
76281 :
76282 :
76283 : // End of memberFunctionString
76284 : // Start of memberFunctionString
76285 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
76286 :
76287 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
76288 :
76289 : SgType*
76290 86482 : SgRvalueReferenceType::get_base_type () const
76291 : {
76292 86482 : ROSE_ASSERT (this != NULL);
76293 :
76294 : #if 0
76295 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
76296 : // used to trigger marking transformations for the token-based unparsing.
76297 : printf ("SgRvalueReferenceType::get_base_type = %p = %s \n",this,this->class_name().c_str());
76298 : #endif
76299 :
76300 86482 : return p_base_type;
76301 : }
76302 :
76303 : void
76304 0 : SgRvalueReferenceType::set_base_type ( SgType* base_type )
76305 : {
76306 0 : ROSE_ASSERT (this != NULL);
76307 :
76308 : #if 0
76309 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
76310 : // used to trigger marking transformations for the token-based unparsing.
76311 : printf ("SgRvalueReferenceType::set_base_type = %p = %s \n",this,this->class_name().c_str());
76312 : #endif
76313 :
76314 0 : set_isModified(true);
76315 :
76316 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
76317 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
76318 : {
76319 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
76320 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
76321 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
76322 : ROSE_ASSERT(false);
76323 : #endif
76324 : }
76325 : #endif
76326 0 : p_base_type = base_type;
76327 0 : }
76328 :
76329 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
76330 :
76331 :
76332 : // End of memberFunctionString
76333 : // Start of memberFunctionString
76334 : /* #line 1094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
76335 :
76336 :
76337 : /*! Returns a mangled name representation of types with base types
76338 : * (e.g., pointer, reference).
76339 : */
76340 : SgName
76341 18681 : SgRvalueReferenceType::get_mangled (void) const
76342 : {
76343 : // DQ (10/23/2015): Note that these functions are called in the AST construction and that might not be
76344 : // required, plus it might be a performance issue as well. I didn't expect to see this while debugging
76345 : // a different subject. In general, I think we would like to push the generation of mangled names to
76346 : // the end of the AST processing; unless it is required for computing symble table keys (which is the
76347 : // likely usage within the AST construction, if so then I guess we have to allow these functions to be
76348 : // called in the frontend AST construction).
76349 :
76350 18681 : ROSE_ASSERT(this != NULL);
76351 :
76352 18681 : const SgType* base_type = get_base_type();
76353 18681 : ROSE_ASSERT (base_type != NULL);
76354 :
76355 : #if 0
76356 : printf ("In SgRvalueReferenceType::get_mangled(): base_type = %p = %s \n",base_type,base_type->class_name().c_str());
76357 : #endif
76358 :
76359 18681 : SgName base_name = base_type->get_mangled();
76360 :
76361 : #if 0
76362 : printf ("DONE: In SgRvalueReferenceType::get_mangled(): base_type = %p = %s base_name = %s \n",base_type,base_type->class_name().c_str(),base_name.str());
76363 : #endif
76364 :
76365 : // DQ (6/21/2006): Use is_null() instead of counting the size (and fixed case were it is null)
76366 : // ROSE_ASSERT (base_name.get_length ());
76367 18681 : if (base_name.is_null() == true)
76368 : {
76369 : // This happens for code such as: "typedef struct {int id; } *XYZ;"
76370 : // printf ("Warning: In SgRvalueReferenceType::get_mangled(), empty base type name found \n");
76371 0 : base_name = "un_named_base_type";
76372 : }
76373 18681 : ROSE_ASSERT (base_name.is_null() == false);
76374 :
76375 18681 : SgName mangled_name;
76376 37362 : mangled_name << "__" << "Rvalue" << "b__" // start tag
76377 37362 : << base_name.str () // base type
76378 37362 : << "__" << "Rvalue" << "e__"; // end tag
76379 :
76380 : // printf ("LEAVING: In SgRvalueReferenceType::get_mangled(): base_type = %p = %s mangled_name = %s \n",base_type,base_type->class_name().c_str(),mangled_name.str());
76381 :
76382 18681 : return mangled_name;
76383 : }
76384 :
76385 : #if 0
76386 : // Old version of function
76387 : SgName
76388 : SgRvalueReferenceType::get_mangled ( SgUnparse_Info & info )
76389 : {
76390 : SgName tmp("Rvalue");
76391 :
76392 : // DQ (3/15/2005): Should be be using a qualified name???
76393 :
76394 : ROSE_ASSERT(get_base_type() != NULL);
76395 : ROSE_ASSERT(get_base_type()->get_mangled(info).get_length() > 0);
76396 : tmp << get_base_type()->get_mangled(info).str();
76397 :
76398 : #if 0
76399 : printf ("########### In SgRvalueReferenceType::get_mangled(): tmp = %s (get_base_type() = %s is a %s) ########## \n",
76400 : tmp.str(),get_base_type()->get_mangled(info).str(),get_base_type()->sage_class_name());
76401 : // ROSE_ASSERT(false);
76402 : #endif
76403 :
76404 : return tmp;
76405 : }
76406 : #endif
76407 :
76408 :
76409 :
76410 : // End of memberFunctionString
76411 : // Start of memberFunctionString
76412 : /* #line 3587 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
76413 :
76414 :
76415 :
76416 : // End of memberFunctionString
76417 : // Start of memberFunctionString
76418 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
76419 :
76420 : // *** COMMON CODE SECTION BEGINS HERE ***
76421 :
76422 : #if 0
76423 : int
76424 : SgRvalueReferenceType::getVariant() const
76425 : {
76426 : // This function is used in ROSE while "variant()" is used in SAGE
76427 : assert(this != NULL);
76428 : return variant();
76429 : }
76430 : #endif
76431 :
76432 : // This function is used in ROSE in treeTraversal code
76433 : // eventually replaces getVariant() and variant()
76434 : // though after variant() has been removed for a while we will
76435 : // want to change the name of variantT() back to variant()
76436 : // (since the "T" was ment to stand for temporary).
76437 : // When this happens the variantT() will be depricated.
76438 : VariantT
76439 4698560 : SgRvalueReferenceType::variantT() const
76440 : {
76441 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
76442 4698560 : ROSE_ASSERT(this != NULL);
76443 4698560 : return V_SgRvalueReferenceType;
76444 : }
76445 :
76446 : #if 0
76447 : int
76448 : SgRvalueReferenceType::variant() const
76449 : {
76450 : // This function is used in SAGE
76451 : ROSE_ASSERT(this != NULL);
76452 : return T_RVALUE_REFERENCE;
76453 : }
76454 : #endif
76455 :
76456 : ROSE_DLL_API const char*
76457 0 : SgRvalueReferenceType::sage_class_name() const
76458 : {
76459 0 : ROSE_ASSERT(this != NULL);
76460 0 : return "SgRvalueReferenceType";
76461 : }
76462 :
76463 : std::string
76464 1648 : SgRvalueReferenceType::class_name() const
76465 : {
76466 1648 : ROSE_ASSERT(this != NULL);
76467 1648 : return "SgRvalueReferenceType";
76468 : }
76469 :
76470 : // DQ (11/26/2005): Support for visitor pattern mechanims
76471 : // (inferior to ROSE traversal mechanism, experimental).
76472 : void
76473 25295 : SgRvalueReferenceType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
76474 : {
76475 25295 : ROSE_ASSERT(this != NULL);
76476 25295 : visitor.visit(this);
76477 25295 : }
76478 :
76479 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
76480 0 : void SgRvalueReferenceType::accept (ROSE_VisitorPattern & visitor) {
76481 0 : ROSE_ASSERT(this != NULL);
76482 0 : visitor.visit(this);
76483 0 : }
76484 :
76485 : SgRvalueReferenceType*
76486 0 : SgRvalueReferenceType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
76487 : {
76488 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
76489 : // This function is currently only supported for the AST used the represent Binary executables.
76490 : if (0 /* isSgAsmNode(this) != NULL */)
76491 : {
76492 : // Support for regex specification.
76493 : std::string prefixCode = "REGEX:";
76494 : addNewAttribute(prefixCode + s,a);
76495 : }
76496 : #endif
76497 :
76498 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
76499 0 : return this;
76500 : }
76501 :
76502 : // *** COMMON CODE SECTION ENDS HERE ***
76503 :
76504 :
76505 : // End of memberFunctionString
76506 : // Start of memberFunctionString
76507 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
76508 :
76509 :
76510 : #if 0
76511 : //! Error checking support
76512 : /*! Verifies the following:
76513 : - working getVariant() member function
76514 : - calls base class's error() member function
76515 : Every class has one of these functions.
76516 : */
76517 : bool
76518 : SgRvalueReferenceType::error()
76519 : {
76520 : // Put error checking here
76521 :
76522 : ROSE_ASSERT (this != NULL);
76523 : if (getVariant() != T_RVALUE_REFERENCE)
76524 : {
76525 : printf ("Error in SgRvalueReferenceType::error(): SgRvalueReferenceType object has a %s variant \n",
76526 : Cxx_GrammarTerminalNames[getVariant()].name);
76527 : // printf ("Error in SgRvalueReferenceType::error() \n");
76528 : ROSE_ABORT();
76529 : }
76530 :
76531 : ROSE_ASSERT (getVariant() == T_RVALUE_REFERENCE);
76532 : return SgType::error();
76533 : }
76534 : #endif
76535 :
76536 :
76537 :
76538 : // End of memberFunctionString
76539 :
76540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
76541 :
76542 33686000 : SgRvalueReferenceType* isSgRvalueReferenceType ( SgNode* inputDerivedClassPointer )
76543 : {
76544 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
76545 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
76546 : // So to fix this we return NULL directly when the input is NULL and avoid the
76547 : // dynamic_cast in this case. This is likely a performance improvement as well.
76548 : // return dynamic_cast<SgRvalueReferenceType*>(inputDerivedClassPointer);
76549 : // Milind Chabbi (8/28/2013): isSgRvalueReferenceType uses table-driven castability instead of c++ default dynamic_cast
76550 : // this improves the running time performance by 10-20%.
76551 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRvalueReferenceType*>(inputDerivedClassPointer);
76552 33686000 : return IS_SgRvalueReferenceType_FAST_MACRO(inputDerivedClassPointer);
76553 : }
76554 :
76555 : // DQ (11/8/2003): Added version of functions taking const pointer
76556 0 : const SgRvalueReferenceType* isSgRvalueReferenceType ( const SgNode* inputDerivedClassPointer )
76557 : {
76558 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
76559 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
76560 : // So to fix this we return NULL directly when the input is NULL and avoid the
76561 : // dynamic_cast in this case. This is likely a performance improvement as well.
76562 : // return dynamic_cast<const SgRvalueReferenceType*>(inputDerivedClassPointer);
76563 : // Milind Chabbi (8/28/2013): isSgRvalueReferenceType uses table-driven castability instead of c++ default dynamic_cast
76564 : // this improves the running time performance by 10-20%.
76565 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRvalueReferenceType*>(inputDerivedClassPointer);
76566 0 : return IS_SgRvalueReferenceType_FAST_MACRO(inputDerivedClassPointer);
76567 : }
76568 :
76569 :
76570 :
76571 : /* #line 76572 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76572 :
76573 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
76574 :
76575 : /**
76576 : \brief Generated destructor
76577 :
76578 : This destructor is automatically generated (by ROSETTA). This destructor
76579 : only frees memory of data members associated with the parts of the current IR node which
76580 : are NOT traversed. Those data members that are part of a traversal can be freed using
76581 : a traversal (calling this destructor on all children in a post-order traversal). Such
76582 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
76583 :
76584 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
76585 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
76586 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
76587 :
76588 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
76589 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
76590 : pointers are not yet implemented to call delete on eash pointer in the container.
76591 : (This could be done by derivation from the STL containers to define containers that
76592 : automatically deleted their members.)
76593 :
76594 : */
76595 728 : SgRvalueReferenceType::~SgRvalueReferenceType () {
76596 364 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
76597 :
76598 :
76599 : // case: not a listType for base_type
76600 364 : p_base_type = NULL; // non list case
76601 :
76602 : }
76603 :
76604 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
76605 728 : }
76606 :
76607 :
76608 : /* #line 76609 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76609 :
76610 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
76611 :
76612 : // Generated constructor
76613 1677 : SgRvalueReferenceType::SgRvalueReferenceType ( SgType* base_type )
76614 1677 : : SgType()
76615 : {
76616 : #ifdef DEBUG
76617 : // printf ("In SgRvalueReferenceType::SgRvalueReferenceType (SgType* base_type) sage_class_name() = %s \n",sage_class_name());
76618 : #endif
76619 : #if 0
76620 : // debugging information!
76621 : printf ("In SgRvalueReferenceType::SgRvalueReferenceType (SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
76622 : #endif
76623 :
76624 1677 : p_base_type = base_type;
76625 :
76626 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
76627 :
76628 : #if 0
76629 : // DQ (7/30/2014): Call a virtual function.
76630 : std::string s = this->class_name();
76631 : #endif
76632 :
76633 : // Test the variant virtual function
76634 : // assert(T_RVALUE_REFERENCE == variant());
76635 1677 : assert(T_RVALUE_REFERENCE == this->variant());
76636 1677 : ROSE_ASSERT(T_RVALUE_REFERENCE == (int)(this->variantT()));
76637 1677 : post_construction_initialization();
76638 :
76639 : // Test the isSgRvalueReferenceType() function since it has been problematic
76640 1677 : assert(isSgRvalueReferenceType(this) != NULL);
76641 1677 : }
76642 :
76643 : // Generated constructor (all data members)
76644 :
76645 : /* #line 76646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76646 :
76647 :
76648 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
76649 :
76650 :
76651 : // ********************************************************
76652 : // member functions common across all array grammar objects
76653 : // ********************************************************
76654 :
76655 :
76656 :
76657 : /* #line 76658 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76658 :
76659 :
76660 :
76661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
76662 :
76663 : // ********************************************************
76664 : // member functions specific to each node in the grammar
76665 : // ********************************************************
76666 :
76667 :
76668 : /* #line 76669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
76669 :
76670 : // Start of memberFunctionString
76671 :
76672 :
76673 : // End of memberFunctionString
76674 : // Start of memberFunctionString
76675 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
76676 :
76677 : // *** COMMON CODE SECTION BEGINS HERE ***
76678 :
76679 : #if 0
76680 : int
76681 : SgTypeNullptr::getVariant() const
76682 : {
76683 : // This function is used in ROSE while "variant()" is used in SAGE
76684 : assert(this != NULL);
76685 : return variant();
76686 : }
76687 : #endif
76688 :
76689 : // This function is used in ROSE in treeTraversal code
76690 : // eventually replaces getVariant() and variant()
76691 : // though after variant() has been removed for a while we will
76692 : // want to change the name of variantT() back to variant()
76693 : // (since the "T" was ment to stand for temporary).
76694 : // When this happens the variantT() will be depricated.
76695 : VariantT
76696 4924 : SgTypeNullptr::variantT() const
76697 : {
76698 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
76699 4924 : ROSE_ASSERT(this != NULL);
76700 4924 : return V_SgTypeNullptr;
76701 : }
76702 :
76703 : #if 0
76704 : int
76705 : SgTypeNullptr::variant() const
76706 : {
76707 : // This function is used in SAGE
76708 : ROSE_ASSERT(this != NULL);
76709 : return T_NULLPTR;
76710 : }
76711 : #endif
76712 :
76713 : ROSE_DLL_API const char*
76714 0 : SgTypeNullptr::sage_class_name() const
76715 : {
76716 0 : ROSE_ASSERT(this != NULL);
76717 0 : return "SgTypeNullptr";
76718 : }
76719 :
76720 : std::string
76721 54 : SgTypeNullptr::class_name() const
76722 : {
76723 54 : ROSE_ASSERT(this != NULL);
76724 54 : return "SgTypeNullptr";
76725 : }
76726 :
76727 : // DQ (11/26/2005): Support for visitor pattern mechanims
76728 : // (inferior to ROSE traversal mechanism, experimental).
76729 : void
76730 194 : SgTypeNullptr::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
76731 : {
76732 194 : ROSE_ASSERT(this != NULL);
76733 194 : visitor.visit(this);
76734 194 : }
76735 :
76736 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
76737 0 : void SgTypeNullptr::accept (ROSE_VisitorPattern & visitor) {
76738 0 : ROSE_ASSERT(this != NULL);
76739 0 : visitor.visit(this);
76740 0 : }
76741 :
76742 : SgTypeNullptr*
76743 0 : SgTypeNullptr::addRegExpAttribute(std::string s, AstRegExAttribute* a)
76744 : {
76745 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
76746 : // This function is currently only supported for the AST used the represent Binary executables.
76747 : if (0 /* isSgAsmNode(this) != NULL */)
76748 : {
76749 : // Support for regex specification.
76750 : std::string prefixCode = "REGEX:";
76751 : addNewAttribute(prefixCode + s,a);
76752 : }
76753 : #endif
76754 :
76755 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
76756 0 : return this;
76757 : }
76758 :
76759 : // *** COMMON CODE SECTION ENDS HERE ***
76760 :
76761 :
76762 : // End of memberFunctionString
76763 : // Start of memberFunctionString
76764 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
76765 :
76766 :
76767 : #if 0
76768 : //! Error checking support
76769 : /*! Verifies the following:
76770 : - working getVariant() member function
76771 : - calls base class's error() member function
76772 : Every class has one of these functions.
76773 : */
76774 : bool
76775 : SgTypeNullptr::error()
76776 : {
76777 : // Put error checking here
76778 :
76779 : ROSE_ASSERT (this != NULL);
76780 : if (getVariant() != T_NULLPTR)
76781 : {
76782 : printf ("Error in SgTypeNullptr::error(): SgTypeNullptr object has a %s variant \n",
76783 : Cxx_GrammarTerminalNames[getVariant()].name);
76784 : // printf ("Error in SgTypeNullptr::error() \n");
76785 : ROSE_ABORT();
76786 : }
76787 :
76788 : ROSE_ASSERT (getVariant() == T_NULLPTR);
76789 : return SgType::error();
76790 : }
76791 : #endif
76792 :
76793 :
76794 :
76795 : // End of memberFunctionString
76796 : // Start of memberFunctionString
76797 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
76798 :
76799 :
76800 : // DQ (1/31/2006): Modified to build all types in the memory pools
76801 : // SgTypeNullptr SgTypeNullptr::builtin_type;
76802 : // SgTypeNullptr* SgTypeNullptr::builtin_type = new SgTypeNullptr();
76803 : SgTypeNullptr* SgTypeNullptr::p_builtin_type = NULL;
76804 :
76805 :
76806 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
76807 : // SgTypeNullptr* SgTypeNullptr::createType(void)
76808 : SgTypeNullptr*
76809 245 : SgTypeNullptr::createType(SgExpression* optional_fortran_type_kind)
76810 : {
76811 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
76812 : // is not called (likely because static initialization is compiler dependent).
76813 : // DQ (1/31/2006): Modified to build all types in the memory pools
76814 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
76815 : // return &builtin_type;
76816 :
76817 : #if 0
76818 : printf ("In SgTypeNullptr::createType() (COMMON_CREATE_TYPE) \n");
76819 : #endif
76820 :
76821 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
76822 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
76823 :
76824 245 : SgTypeNullptr* temp_type = new SgTypeNullptr();
76825 :
76826 : #if 0
76827 : printf ("In SgTypeNullptr::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
76828 : #endif
76829 :
76830 : // DQ (10/31/2016): Added assertion.
76831 245 : ROSE_ASSERT(temp_type != NULL);
76832 :
76833 245 : if (optional_fortran_type_kind != NULL)
76834 : {
76835 : // DQ (10/31/2016): Added assertion.
76836 0 : ROSE_ASSERT(temp_type != NULL);
76837 :
76838 0 : temp_type->set_type_kind(optional_fortran_type_kind);
76839 : }
76840 : #if 0
76841 : else
76842 : {
76843 : // Let p_builtin_type refer to the unadorned type (no type kind).
76844 : p_builtin_type = temp_type;
76845 : }
76846 : #endif
76847 :
76848 245 : SgName name = temp_type->get_mangled();
76849 :
76850 : #if 0
76851 : printf ("Mangled type name for SgTypeNullptr = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
76852 : #endif
76853 :
76854 : // DQ (10/31/2016): Added assertion.
76855 245 : ROSE_ASSERT(get_globalTypeTable() != NULL);
76856 :
76857 245 : SgType* t = get_globalTypeTable()->lookup_type(name);
76858 :
76859 : #if 0
76860 : printf ("In SgTypeNullptr::createType(): type from lookup_type = %p \n",t);
76861 : #endif
76862 :
76863 245 : if (t == NULL)
76864 : {
76865 62 : get_globalTypeTable()->insert_type(name,temp_type);
76866 : }
76867 : else
76868 : {
76869 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
76870 183 : if (t != temp_type)
76871 : {
76872 : #if 0
76873 : printf ("In SgTypeNullptr::createType(): deleting temp_type = %p \n",temp_type);
76874 : #endif
76875 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
76876 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
76877 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
76878 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
76879 183 : delete temp_type;
76880 : #endif
76881 183 : temp_type = NULL;
76882 : #if 0
76883 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
76884 : if (optional_fortran_type_kind != NULL)
76885 : {
76886 : p_builtin_type = NULL;
76887 : }
76888 : #endif
76889 : }
76890 :
76891 : // Reuse this tempType variable so we can use the same code below.
76892 183 : temp_type = isSgTypeNullptr(t);
76893 183 : ROSE_ASSERT(temp_type != NULL);
76894 : }
76895 :
76896 : #if 0
76897 : printf ("Leaving SgTypeNullptr::createType(): temp_type = %p \n",temp_type);
76898 : #endif
76899 :
76900 245 : return temp_type;
76901 : }
76902 :
76903 :
76904 :
76905 : // End of memberFunctionString
76906 : // Start of memberFunctionString
76907 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
76908 :
76909 : #if 1
76910 : /*! Support for mangled names (for unparser)
76911 : There are two different cases of source code for the get_mangled member function
76912 : This one is used in all but the classes containing a base type
76913 : */
76914 : // SgName SgTypeNullptr::get_mangled ( SgUnparse_Info & info )
76915 : SgName
76916 247 : SgTypeNullptr::get_mangled (void) const
76917 : {
76918 247 : ROSE_ASSERT(this != NULL);
76919 :
76920 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
76921 : // CR (3/6/2020): Now type_kind is also used for Jovial.
76922 247 : SgName name = "nullptr_t";
76923 247 : if (get_type_kind() != NULL)
76924 : {
76925 : // name += get_type_kind()->get_mangled();
76926 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
76927 0 : SgValueExp* value = isSgValueExp(get_type_kind());
76928 0 : if (value != NULL)
76929 : {
76930 : // name += string("_") + StringUtility::numberToString(value->get_value());
76931 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
76932 : }
76933 : else
76934 : {
76935 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
76936 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
76937 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
76938 : // a different prefix for each type of named type. It come down to is there can be multiple
76939 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
76940 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
76941 : // I think the issue is that nullptr_t is not defined for any of the SgNameType IR nodes.
76942 : #if 0
76943 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"nullptr_t");
76944 : #endif
76945 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
76946 : }
76947 : }
76948 :
76949 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
76950 : // REMOVE_ME please!
76951 247 : if (isSgTypeFixed(this))
76952 : {
76953 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
76954 0 : if (fixed_type->get_scale() != NULL)
76955 : {
76956 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
76957 0 : if (value != NULL)
76958 : {
76959 0 : name += string("_") + value->get_constant_folded_value_as_string();
76960 : }
76961 : }
76962 0 : if (fixed_type->get_fraction() != NULL)
76963 : {
76964 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
76965 0 : if (value != NULL)
76966 : {
76967 0 : name += string("_") + value->get_constant_folded_value_as_string();
76968 : }
76969 : }
76970 : }
76971 :
76972 : #if 0
76973 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
76974 : #endif
76975 :
76976 247 : return name;
76977 : }
76978 : #endif
76979 :
76980 :
76981 : // End of memberFunctionString
76982 :
76983 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
76984 :
76985 27789 : SgTypeNullptr* isSgTypeNullptr ( SgNode* inputDerivedClassPointer )
76986 : {
76987 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
76988 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
76989 : // So to fix this we return NULL directly when the input is NULL and avoid the
76990 : // dynamic_cast in this case. This is likely a performance improvement as well.
76991 : // return dynamic_cast<SgTypeNullptr*>(inputDerivedClassPointer);
76992 : // Milind Chabbi (8/28/2013): isSgTypeNullptr uses table-driven castability instead of c++ default dynamic_cast
76993 : // this improves the running time performance by 10-20%.
76994 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeNullptr*>(inputDerivedClassPointer);
76995 27789 : return IS_SgTypeNullptr_FAST_MACRO(inputDerivedClassPointer);
76996 : }
76997 :
76998 : // DQ (11/8/2003): Added version of functions taking const pointer
76999 0 : const SgTypeNullptr* isSgTypeNullptr ( const SgNode* inputDerivedClassPointer )
77000 : {
77001 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
77002 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
77003 : // So to fix this we return NULL directly when the input is NULL and avoid the
77004 : // dynamic_cast in this case. This is likely a performance improvement as well.
77005 : // return dynamic_cast<const SgTypeNullptr*>(inputDerivedClassPointer);
77006 : // Milind Chabbi (8/28/2013): isSgTypeNullptr uses table-driven castability instead of c++ default dynamic_cast
77007 : // this improves the running time performance by 10-20%.
77008 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeNullptr*>(inputDerivedClassPointer);
77009 0 : return IS_SgTypeNullptr_FAST_MACRO(inputDerivedClassPointer);
77010 : }
77011 :
77012 :
77013 :
77014 : /* #line 77015 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77015 :
77016 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
77017 :
77018 : /**
77019 : \brief Generated destructor
77020 :
77021 : This destructor is automatically generated (by ROSETTA). This destructor
77022 : only frees memory of data members associated with the parts of the current IR node which
77023 : are NOT traversed. Those data members that are part of a traversal can be freed using
77024 : a traversal (calling this destructor on all children in a post-order traversal). Such
77025 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
77026 :
77027 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
77028 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
77029 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
77030 :
77031 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
77032 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
77033 : pointers are not yet implemented to call delete on eash pointer in the container.
77034 : (This could be done by derivation from the STL containers to define containers that
77035 : automatically deleted their members.)
77036 :
77037 : */
77038 370 : SgTypeNullptr::~SgTypeNullptr () {
77039 185 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
77040 :
77041 :
77042 :
77043 : }
77044 :
77045 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
77046 370 : }
77047 :
77048 :
77049 : /* #line 77050 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77050 :
77051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
77052 :
77053 : // Generated constructor
77054 245 : SgTypeNullptr::SgTypeNullptr ( )
77055 245 : : SgType()
77056 : {
77057 : #ifdef DEBUG
77058 : // printf ("In SgTypeNullptr::SgTypeNullptr () sage_class_name() = %s \n",sage_class_name());
77059 : #endif
77060 : #if 0
77061 : // debugging information!
77062 : printf ("In SgTypeNullptr::SgTypeNullptr (): this = %p = %s \n",this,this->class_name().c_str());
77063 : #endif
77064 :
77065 :
77066 :
77067 : #if 0
77068 : // DQ (7/30/2014): Call a virtual function.
77069 : std::string s = this->class_name();
77070 : #endif
77071 :
77072 : // Test the variant virtual function
77073 : // assert(T_NULLPTR == variant());
77074 245 : assert(T_NULLPTR == this->variant());
77075 245 : ROSE_ASSERT(T_NULLPTR == (int)(this->variantT()));
77076 245 : post_construction_initialization();
77077 :
77078 : // Test the isSgTypeNullptr() function since it has been problematic
77079 245 : assert(isSgTypeNullptr(this) != NULL);
77080 245 : }
77081 :
77082 : // Generated constructor (all data members)
77083 :
77084 : /* #line 77085 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77085 :
77086 :
77087 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
77088 :
77089 :
77090 : // ********************************************************
77091 : // member functions common across all array grammar objects
77092 : // ********************************************************
77093 :
77094 :
77095 :
77096 : /* #line 77097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77097 :
77098 :
77099 :
77100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
77101 :
77102 : // ********************************************************
77103 : // member functions specific to each node in the grammar
77104 : // ********************************************************
77105 :
77106 :
77107 : /* #line 77108 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77108 :
77109 : // Start of memberFunctionString
77110 : /* #line 7662 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
77111 :
77112 : // SgDeclType* SgDeclType::createType(SgType* base_type, SgExpression* optional_fortran_type_kind)
77113 : SgDeclType*
77114 1044 : SgDeclType::createType(SgExpression* base_expression, SgExpression* optional_fortran_type_kind)
77115 : {
77116 : #if 1
77117 : // DQ (8/2/2014): I think that decltype reference types can't have a kind parameter, so this should be NULL.
77118 1044 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
77119 :
77120 1044 : SgDeclType* newType = new SgDeclType(base_expression);
77121 1044 : assert(newType != NULL);
77122 : #define INSERT_DECL_TYPE_IN_GLOBAL_TYPE_TABLE 1
77123 : #if INSERT_DECL_TYPE_IN_GLOBAL_TYPE_TABLE
77124 1044 : SgName name = newType->get_mangled();
77125 1044 : SgType* t = get_globalTypeTable()->lookup_type(name);
77126 1044 : ROSE_ASSERT(!(t != NULL) || isSgDeclType(t)); // (t != NULL) => isDeclType(t)
77127 1044 : if (t != NULL) {
77128 153 : delete newType;
77129 153 : newType = isSgDeclType(t);
77130 : } else {
77131 891 : get_globalTypeTable()->insert_type(name,newType);
77132 : }
77133 : #endif
77134 1044 : return newType;
77135 : #else
77136 : // DQ (8/2/2014): The decltype takes an expression (and stores it) but references the type of that expression.
77137 : SgType* base_type = base_expression->get_type();
77138 : ROSE_ASSERT(base_type != NULL);
77139 :
77140 : // DQ (8/2/2014): I think that decltype reference types can't have a kind parameter, so this should be NULL.
77141 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
77142 :
77143 : #if 0
77144 : printf ("In SgDeclType::createType() \n");
77145 : #endif
77146 :
77147 : if (base_type->p_decltype_ref_to)
77148 : {
77149 : return base_type->p_decltype_ref_to;
77150 : }
77151 : else
77152 : {
77153 : SgDeclType* newType = new SgDeclType(base_expression);
77154 : assert(newType != NULL);
77155 :
77156 : SgName name = newType->get_mangled();
77157 :
77158 : #if 0
77159 : printf ("Building a decltype reference to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
77160 : #endif
77161 : // Only look for pointers to type in the global type table.
77162 : SgType* t = get_globalTypeTable()->lookup_type(name);
77163 :
77164 : // DQ (2/23/2016): Add test and reset type returned from globalTypeTable if it is not a SgDeclType.
77165 : // I have at least one case where the type table returns a SgModifierType (not clear if that is correct behavior).
77166 : // Detect this case for now and make sure it can't happen in general.
77167 : if (t != NULL && isSgDeclType(t) == NULL)
77168 : {
77169 : printf ("Error: This name = %s does not return the correct type from the globalTypeTable: t = %p = %s reset t == NULL \n",name.str(),t,t->class_name().c_str());
77170 :
77171 : // Note: were we detect that this is a SgModifierType it is a default built SgModifierType.
77172 : // This kind of SgModifierType is only used in the frontend to support references to types
77173 : // in templates that have not been defined yet. It is rare to see these. In this case the
77174 : // modifier's name mangling does not change the name and so that name can appear in the
77175 : // globalTypeTable() and a SgModifierType. For now we are issuing a warning about this and
77176 : // forcing a new SgDeclType type to be used.
77177 : SgModifierType* modifierType = isSgModifierType(t);
77178 : if (modifierType != NULL)
77179 : {
77180 : #if 0
77181 : SgTypeModifier & typeModifier = modifierType->get_typeModifier();
77182 : typeModifier.display("does not return the correct type from the globalTypeTable");
77183 : #endif
77184 : #if 0
77185 : printf ("Exiting as a test! \n");
77186 : ROSE_ASSERT(false);
77187 : #endif
77188 : }
77189 : t = NULL;
77190 : }
77191 :
77192 : if (t == NULL)
77193 : {
77194 : // The pointer type was not found in the type table, put it into the global type table.
77195 : SgType* root_type = base_type->stripType();
77196 : ROSE_ASSERT(root_type != NULL);
77197 : if (handledUsingLocalTable(root_type) == false)
77198 : {
77199 : #if 0
77200 : printf ("Mangled type name for SgDeclType = %s (does NOT exist in type table) inserting it... \n",name.str());
77201 : #endif
77202 : get_globalTypeTable()->insert_type(name,newType);
77203 : }
77204 : else
77205 : {
77206 : #if 0
77207 : printf ("Skip putting the SgDeclType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
77208 : #endif
77209 : }
77210 : }
77211 : else
77212 : {
77213 : // If it is already present in the type table then delete the type (so that it will remain unique).
77214 : #if 0
77215 : printf ("Mangled type name for SgDeclType = %s (already exists in type table) \n",name.str());
77216 : #endif
77217 : ROSE_ASSERT(t != newType);
77218 :
77219 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
77220 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
77221 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
77222 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
77223 : delete newType;
77224 : #endif
77225 : newType = NULL;
77226 :
77227 : newType = isSgDeclType(t);
77228 :
77229 : // DQ (2/23/2016): Added assertion.
77230 : if (newType == NULL)
77231 : {
77232 : printf ("In createType(SgExpression* base_expression, SgExpression* kind): isSgDeclType(t) == NULL: error: t = %p = %s \n",t,t->class_name().c_str());
77233 : }
77234 : assert(newType != NULL);
77235 : }
77236 :
77237 : // DQ (2/23/2016): Added assertion.
77238 : assert(newType != NULL);
77239 :
77240 : base_type->p_decltype_ref_to = newType;
77241 : assert(base_type->p_decltype_ref_to != NULL);
77242 :
77243 : return base_type->p_decltype_ref_to;
77244 : }
77245 : #endif
77246 : }
77247 :
77248 :
77249 :
77250 : // End of memberFunctionString
77251 : // Start of memberFunctionString
77252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
77253 :
77254 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
77255 :
77256 : SgExpression*
77257 554 : SgDeclType::get_base_expression () const
77258 : {
77259 554 : ROSE_ASSERT (this != NULL);
77260 :
77261 : #if 0
77262 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
77263 : // used to trigger marking transformations for the token-based unparsing.
77264 : printf ("SgDeclType::get_base_expression = %p = %s \n",this,this->class_name().c_str());
77265 : #endif
77266 :
77267 554 : return p_base_expression;
77268 : }
77269 :
77270 : void
77271 0 : SgDeclType::set_base_expression ( SgExpression* base_expression )
77272 : {
77273 0 : ROSE_ASSERT (this != NULL);
77274 :
77275 : #if 0
77276 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
77277 : // used to trigger marking transformations for the token-based unparsing.
77278 : printf ("SgDeclType::set_base_expression = %p = %s \n",this,this->class_name().c_str());
77279 : #endif
77280 :
77281 0 : set_isModified(true);
77282 :
77283 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
77284 : if (p_base_expression != NULL && base_expression != NULL && p_base_expression != base_expression)
77285 : {
77286 : printf ("Warning: base_expression = %p overwriting valid pointer p_base_expression = %p \n",base_expression,p_base_expression);
77287 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
77288 : printf ("Error fails assertion (p_base_expression != NULL && base_expression != NULL && p_base_expression != base_expression) is false\n");
77289 : ROSE_ASSERT(false);
77290 : #endif
77291 : }
77292 : #endif
77293 0 : p_base_expression = base_expression;
77294 0 : }
77295 :
77296 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
77297 :
77298 :
77299 : // End of memberFunctionString
77300 : // Start of memberFunctionString
77301 :
77302 :
77303 : // End of memberFunctionString
77304 : // Start of memberFunctionString
77305 : /* #line 3591 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
77306 :
77307 :
77308 : void
77309 0 : SgDeclType::set_base_type(SgType* base_type)
77310 : {
77311 0 : ROSE_ASSERT(base_type != NULL);
77312 0 : if (p_base_expression == NULL || (isSgFunctionParameterRefExp(p_base_expression) != NULL))
77313 : {
77314 0 : p_base_type = base_type;
77315 : }
77316 : else
77317 : {
77318 : // Prefer the one available in p_base_expression.
77319 0 : p_base_type = NULL;
77320 0 : if (base_type != p_base_expression->get_type())
77321 : {
77322 0 : printf ("Error: base_type in SgDeclType::set_base_type() does not match p_base_expression->get_type() \n");
77323 : }
77324 0 : ROSE_ASSERT(base_type == p_base_expression->get_type());
77325 : }
77326 0 : }
77327 :
77328 : SgType*
77329 143 : SgDeclType::get_base_type() const
77330 : {
77331 143 : SgType* return_type = NULL;
77332 143 : ROSE_ASSERT(this != NULL);
77333 143 : ROSE_ASSERT(p_base_expression != NULL);
77334 143 : if (p_base_expression == NULL || isSgFunctionParameterRefExp(p_base_expression) != NULL)
77335 : {
77336 0 : return_type = p_base_type;
77337 : }
77338 : else
77339 : {
77340 143 : return_type = p_base_expression->get_type();
77341 : }
77342 :
77343 143 : ROSE_ASSERT(return_type != NULL);
77344 :
77345 143 : return return_type;
77346 : // return p_base_expression->get_type();
77347 : }
77348 :
77349 : SgName
77350 5089 : SgDeclType::get_mangled (void) const
77351 : {
77352 5089 : ROSE_ASSERT(this != NULL);
77353 :
77354 5089 : ROSE_ASSERT (p_base_expression != NULL);
77355 :
77356 5089 : SgName mangled_name;
77357 5089 : mangled_name << "__bdecltype__"
77358 10178 : << mangleExpression(p_base_expression)
77359 10178 : << "__edecltype__";
77360 :
77361 :
77362 5089 : return mangled_name;
77363 : }
77364 :
77365 :
77366 :
77367 : // End of memberFunctionString
77368 : // Start of memberFunctionString
77369 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
77370 :
77371 : // *** COMMON CODE SECTION BEGINS HERE ***
77372 :
77373 : #if 0
77374 : int
77375 : SgDeclType::getVariant() const
77376 : {
77377 : // This function is used in ROSE while "variant()" is used in SAGE
77378 : assert(this != NULL);
77379 : return variant();
77380 : }
77381 : #endif
77382 :
77383 : // This function is used in ROSE in treeTraversal code
77384 : // eventually replaces getVariant() and variant()
77385 : // though after variant() has been removed for a while we will
77386 : // want to change the name of variantT() back to variant()
77387 : // (since the "T" was ment to stand for temporary).
77388 : // When this happens the variantT() will be depricated.
77389 : VariantT
77390 487316 : SgDeclType::variantT() const
77391 : {
77392 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
77393 487316 : ROSE_ASSERT(this != NULL);
77394 487316 : return V_SgDeclType;
77395 : }
77396 :
77397 : #if 0
77398 : int
77399 : SgDeclType::variant() const
77400 : {
77401 : // This function is used in SAGE
77402 : ROSE_ASSERT(this != NULL);
77403 : return T_DECLTYPE;
77404 : }
77405 : #endif
77406 :
77407 : ROSE_DLL_API const char*
77408 0 : SgDeclType::sage_class_name() const
77409 : {
77410 0 : ROSE_ASSERT(this != NULL);
77411 0 : return "SgDeclType";
77412 : }
77413 :
77414 : std::string
77415 673 : SgDeclType::class_name() const
77416 : {
77417 673 : ROSE_ASSERT(this != NULL);
77418 673 : return "SgDeclType";
77419 : }
77420 :
77421 : // DQ (11/26/2005): Support for visitor pattern mechanims
77422 : // (inferior to ROSE traversal mechanism, experimental).
77423 : void
77424 12645 : SgDeclType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
77425 : {
77426 12645 : ROSE_ASSERT(this != NULL);
77427 12645 : visitor.visit(this);
77428 12645 : }
77429 :
77430 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
77431 0 : void SgDeclType::accept (ROSE_VisitorPattern & visitor) {
77432 0 : ROSE_ASSERT(this != NULL);
77433 0 : visitor.visit(this);
77434 0 : }
77435 :
77436 : SgDeclType*
77437 0 : SgDeclType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
77438 : {
77439 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
77440 : // This function is currently only supported for the AST used the represent Binary executables.
77441 : if (0 /* isSgAsmNode(this) != NULL */)
77442 : {
77443 : // Support for regex specification.
77444 : std::string prefixCode = "REGEX:";
77445 : addNewAttribute(prefixCode + s,a);
77446 : }
77447 : #endif
77448 :
77449 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
77450 0 : return this;
77451 : }
77452 :
77453 : // *** COMMON CODE SECTION ENDS HERE ***
77454 :
77455 :
77456 : // End of memberFunctionString
77457 : // Start of memberFunctionString
77458 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
77459 :
77460 :
77461 : #if 0
77462 : //! Error checking support
77463 : /*! Verifies the following:
77464 : - working getVariant() member function
77465 : - calls base class's error() member function
77466 : Every class has one of these functions.
77467 : */
77468 : bool
77469 : SgDeclType::error()
77470 : {
77471 : // Put error checking here
77472 :
77473 : ROSE_ASSERT (this != NULL);
77474 : if (getVariant() != T_DECLTYPE)
77475 : {
77476 : printf ("Error in SgDeclType::error(): SgDeclType object has a %s variant \n",
77477 : Cxx_GrammarTerminalNames[getVariant()].name);
77478 : // printf ("Error in SgDeclType::error() \n");
77479 : ROSE_ABORT();
77480 : }
77481 :
77482 : ROSE_ASSERT (getVariant() == T_DECLTYPE);
77483 : return SgType::error();
77484 : }
77485 : #endif
77486 :
77487 :
77488 :
77489 : // End of memberFunctionString
77490 :
77491 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
77492 :
77493 1490900 : SgDeclType* isSgDeclType ( SgNode* inputDerivedClassPointer )
77494 : {
77495 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
77496 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
77497 : // So to fix this we return NULL directly when the input is NULL and avoid the
77498 : // dynamic_cast in this case. This is likely a performance improvement as well.
77499 : // return dynamic_cast<SgDeclType*>(inputDerivedClassPointer);
77500 : // Milind Chabbi (8/28/2013): isSgDeclType uses table-driven castability instead of c++ default dynamic_cast
77501 : // this improves the running time performance by 10-20%.
77502 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeclType*>(inputDerivedClassPointer);
77503 1490900 : return IS_SgDeclType_FAST_MACRO(inputDerivedClassPointer);
77504 : }
77505 :
77506 : // DQ (11/8/2003): Added version of functions taking const pointer
77507 0 : const SgDeclType* isSgDeclType ( const SgNode* inputDerivedClassPointer )
77508 : {
77509 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
77510 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
77511 : // So to fix this we return NULL directly when the input is NULL and avoid the
77512 : // dynamic_cast in this case. This is likely a performance improvement as well.
77513 : // return dynamic_cast<const SgDeclType*>(inputDerivedClassPointer);
77514 : // Milind Chabbi (8/28/2013): isSgDeclType uses table-driven castability instead of c++ default dynamic_cast
77515 : // this improves the running time performance by 10-20%.
77516 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeclType*>(inputDerivedClassPointer);
77517 0 : return IS_SgDeclType_FAST_MACRO(inputDerivedClassPointer);
77518 : }
77519 :
77520 :
77521 :
77522 : /* #line 77523 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77523 :
77524 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
77525 :
77526 : /**
77527 : \brief Generated destructor
77528 :
77529 : This destructor is automatically generated (by ROSETTA). This destructor
77530 : only frees memory of data members associated with the parts of the current IR node which
77531 : are NOT traversed. Those data members that are part of a traversal can be freed using
77532 : a traversal (calling this destructor on all children in a post-order traversal). Such
77533 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
77534 :
77535 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
77536 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
77537 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
77538 :
77539 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
77540 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
77541 : pointers are not yet implemented to call delete on eash pointer in the container.
77542 : (This could be done by derivation from the STL containers to define containers that
77543 : automatically deleted their members.)
77544 :
77545 : */
77546 674 : SgDeclType::~SgDeclType () {
77547 337 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
77548 :
77549 :
77550 : // case: not a listType for base_expression
77551 337 : p_base_expression = NULL; // non list case
77552 : // case: not a listType for base_type
77553 337 : p_base_type = NULL; // non list case
77554 :
77555 : }
77556 :
77557 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
77558 674 : }
77559 :
77560 :
77561 : /* #line 77562 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77562 :
77563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
77564 :
77565 : // Generated constructor
77566 1044 : SgDeclType::SgDeclType ( SgExpression* base_expression, SgType* base_type )
77567 1044 : : SgType()
77568 : {
77569 : #ifdef DEBUG
77570 : // printf ("In SgDeclType::SgDeclType (SgExpression* base_expression, SgType* base_type) sage_class_name() = %s \n",sage_class_name());
77571 : #endif
77572 : #if 0
77573 : // debugging information!
77574 : printf ("In SgDeclType::SgDeclType (SgExpression* base_expression, SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
77575 : #endif
77576 :
77577 1044 : p_base_expression = base_expression;
77578 1044 : p_base_type = base_type;
77579 :
77580 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
77581 :
77582 : #if 0
77583 : // DQ (7/30/2014): Call a virtual function.
77584 : std::string s = this->class_name();
77585 : #endif
77586 :
77587 : // Test the variant virtual function
77588 : // assert(T_DECLTYPE == variant());
77589 1044 : assert(T_DECLTYPE == this->variant());
77590 1044 : ROSE_ASSERT(T_DECLTYPE == (int)(this->variantT()));
77591 1044 : post_construction_initialization();
77592 :
77593 : // Test the isSgDeclType() function since it has been problematic
77594 1044 : assert(isSgDeclType(this) != NULL);
77595 1044 : }
77596 :
77597 : // Generated constructor (all data members)
77598 :
77599 : /* #line 77600 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77600 :
77601 :
77602 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
77603 :
77604 :
77605 : // ********************************************************
77606 : // member functions common across all array grammar objects
77607 : // ********************************************************
77608 :
77609 :
77610 :
77611 : /* #line 77612 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77612 :
77613 :
77614 :
77615 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
77616 :
77617 : // ********************************************************
77618 : // member functions specific to each node in the grammar
77619 : // ********************************************************
77620 :
77621 :
77622 : /* #line 77623 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
77623 :
77624 : // Start of memberFunctionString
77625 : /* #line 7802 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
77626 :
77627 : // SgDeclType* SgDeclType::createType(SgType* base_type, SgExpression* optional_fortran_type_kind)
77628 : SgTypeOfType*
77629 30 : SgTypeOfType::createType(SgExpression* base_expression, SgExpression* optional_fortran_type_kind)
77630 : {
77631 : #if 0
77632 : printf ("In SgTypeOfType::createType() \n");
77633 : #endif
77634 :
77635 : // DQ (8/2/2014): The decltype takes an expression (and stores it) but references the type of that expression.
77636 30 : SgType* base_type = base_expression->get_type();
77637 30 : ROSE_ASSERT(base_type != NULL);
77638 :
77639 : // DQ (8/2/2014): I think that decltype reference types can't have a kind parameter, so this should be NULL.
77640 30 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
77641 :
77642 : #define DEBUG_TYPEOF_CREATETYPE_EXP 0
77643 :
77644 30 : if (base_type->p_typeof_ref_to != NULL)
77645 : {
77646 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77647 : printf ("In SgTypeOfType::createType(SgExpression*): test 1: base_type->p_typeof_ref_to = %p = %s \n",base_type->p_typeof_ref_to,base_type->p_typeof_ref_to->class_name().c_str());
77648 : #endif
77649 : return base_type->p_typeof_ref_to;
77650 : }
77651 : else
77652 : {
77653 30 : SgTypeOfType* newType = new SgTypeOfType(base_expression,NULL);
77654 30 : ROSE_ASSERT(newType != NULL);
77655 :
77656 30 : SgName name = newType->get_mangled();
77657 :
77658 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77659 : printf ("Building a typeoftype (expression argument) reference to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
77660 : #endif
77661 : // Only look for pointers to type in the global type table.
77662 30 : SgType* t = get_globalTypeTable()->lookup_type(name);
77663 :
77664 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77665 : printf ("Building a typeoftype (expression argument): t = get_globalTypeTable()->lookup_type(name): t = %p \n",t);
77666 : #endif
77667 30 : if (t == NULL)
77668 : {
77669 : // The pointer type was not found in the type table, put it into the global type table.
77670 30 : SgType* root_type = base_type->stripType();
77671 30 : ROSE_ASSERT(root_type != NULL);
77672 30 : if (handledUsingLocalTable(root_type) == false)
77673 : {
77674 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77675 : printf ("Mangled type name for SgTypeOfType = %s (does NOT exist in type table) inserting it... \n",name.str());
77676 : #endif
77677 0 : get_globalTypeTable()->insert_type(name,newType);
77678 : }
77679 : else
77680 : {
77681 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77682 : printf ("Skip putting the SgTypeOfType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
77683 : #endif
77684 : }
77685 : }
77686 : else
77687 : {
77688 : // If it is already present in the type table then delete the type (so that it will remain unique).
77689 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77690 : printf ("Mangled type name for SgTypeOfType = %s (already exists in type table) \n",name.str());
77691 : #endif
77692 0 : ROSE_ASSERT(t != newType);
77693 :
77694 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
77695 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
77696 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
77697 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
77698 0 : delete newType;
77699 : #endif
77700 0 : newType = NULL;
77701 :
77702 0 : newType = isSgTypeOfType(t);
77703 : }
77704 :
77705 : #if 0
77706 : // DQ (4/7/2015): We have to allow that all expressions could be different, so we can't reuse the same typeof type.
77707 : base_type->p_typeof_ref_to = newType;
77708 : assert(base_type->p_typeof_ref_to != NULL);
77709 : #if DEBUG_TYPEOF_CREATETYPE_EXP
77710 : printf ("In SgTypeOfType::createType(SgExpression*): test 2: base_type->p_typeof_ref_to = %p = %s \n",base_type->p_typeof_ref_to,base_type->p_typeof_ref_to->class_name().c_str());
77711 : #endif
77712 : return base_type->p_typeof_ref_to;
77713 : #else
77714 : // DQ (4/7/2015): We have to allow that all expressions could be different, so we can't reuse the same typeof type (return the neType).
77715 30 : return newType;
77716 : #endif
77717 : }
77718 : }
77719 :
77720 : SgTypeOfType*
77721 6 : SgTypeOfType::createType(SgType* base_type, SgExpression* optional_fortran_type_kind)
77722 : {
77723 : // DQ (8/2/2014): The decltype takes an expression (and stores it) but references the type of that expression.
77724 : // SgType* base_type = base_type;
77725 6 : ROSE_ASSERT(base_type != NULL);
77726 :
77727 : // DQ (8/2/2014): I think that decltype reference types can't have a kind parameter, so this should be NULL.
77728 6 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
77729 :
77730 : #define DEBUG_TYPEOF_CREATETYPE_TYPE 0
77731 :
77732 : #if DEBUG_TYPEOF_CREATETYPE_TYPE
77733 : printf ("Building a typeoftype (type argument) base_type->p_typeof_ref_to = %p \n",base_type->p_typeof_ref_to);
77734 : #endif
77735 :
77736 : #if 0
77737 : printf ("In SgTypeOfType::createType() \n");
77738 : #endif
77739 :
77740 6 : if (base_type->p_typeof_ref_to)
77741 : {
77742 : return base_type->p_typeof_ref_to;
77743 : }
77744 : else
77745 : {
77746 6 : SgTypeOfType* newType = new SgTypeOfType(NULL,base_type);
77747 6 : ROSE_ASSERT(newType != NULL);
77748 :
77749 6 : SgName name = newType->get_mangled();
77750 :
77751 : #if DEBUG_TYPEOF_CREATETYPE_TYPE
77752 : printf ("Building a typeoftype (type argument) reference to base_type = %p = %s name = %s \n",base_type,base_type->class_name().c_str(),name.str());
77753 : #endif
77754 : // Only look for pointers to type in the global type table.
77755 6 : SgType* t = get_globalTypeTable()->lookup_type(name);
77756 :
77757 : #if DEBUG_TYPEOF_CREATETYPE_TYPE
77758 : printf ("Building a typeoftype (type argument) get_globalTypeTable()->lookup_type(name = %s) = %p = %s \n",name.str(),t,t != NULL ? t->class_name().c_str() : "null");
77759 : #endif
77760 6 : if (t == NULL)
77761 : {
77762 : // The pointer type was not found in the type table, put it into the global type table.
77763 6 : SgType* root_type = base_type->stripType();
77764 6 : ROSE_ASSERT(root_type != NULL);
77765 6 : if (handledUsingLocalTable(root_type) == false)
77766 : {
77767 : #if DEBUG_TYPEOF_CREATETYPE_TYPE
77768 : printf ("Mangled type name for SgTypeOfType = %s (does NOT exist in type table) inserting it... \n",name.str());
77769 : #endif
77770 6 : get_globalTypeTable()->insert_type(name,newType);
77771 : }
77772 : else
77773 : {
77774 : #if DEBUG_TYPEOF_CREATETYPE_TYPE
77775 : printf ("Skip putting the SgTypeOfType into the global type table for specific root types = %s name = %s \n",root_type->class_name().c_str(),name.str());
77776 : #endif
77777 : }
77778 : }
77779 : else
77780 : {
77781 : // If it is already present in the type table then delete the type (so that it will remain unique).
77782 : #if DEBUG_TYPEOF_CREATETYPE_TYPE
77783 : printf ("Mangled type name for SgTypeOfType = %s (already exists in type table) \n",name.str());
77784 : #endif
77785 0 : ROSE_ASSERT(t != newType);
77786 :
77787 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
77788 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
77789 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
77790 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
77791 0 : delete newType;
77792 : #endif
77793 0 : newType = NULL;
77794 :
77795 0 : newType = isSgTypeOfType(t);
77796 : }
77797 :
77798 6 : base_type->p_typeof_ref_to = newType;
77799 6 : assert(base_type->p_typeof_ref_to != NULL);
77800 :
77801 6 : return base_type->p_typeof_ref_to;
77802 : }
77803 : }
77804 :
77805 :
77806 :
77807 : // End of memberFunctionString
77808 : // Start of memberFunctionString
77809 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
77810 :
77811 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
77812 :
77813 : SgExpression*
77814 105 : SgTypeOfType::get_base_expression () const
77815 : {
77816 105 : ROSE_ASSERT (this != NULL);
77817 :
77818 : #if 0
77819 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
77820 : // used to trigger marking transformations for the token-based unparsing.
77821 : printf ("SgTypeOfType::get_base_expression = %p = %s \n",this,this->class_name().c_str());
77822 : #endif
77823 :
77824 105 : return p_base_expression;
77825 : }
77826 :
77827 : void
77828 0 : SgTypeOfType::set_base_expression ( SgExpression* base_expression )
77829 : {
77830 0 : ROSE_ASSERT (this != NULL);
77831 :
77832 : #if 0
77833 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
77834 : // used to trigger marking transformations for the token-based unparsing.
77835 : printf ("SgTypeOfType::set_base_expression = %p = %s \n",this,this->class_name().c_str());
77836 : #endif
77837 :
77838 0 : set_isModified(true);
77839 :
77840 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
77841 : if (p_base_expression != NULL && base_expression != NULL && p_base_expression != base_expression)
77842 : {
77843 : printf ("Warning: base_expression = %p overwriting valid pointer p_base_expression = %p \n",base_expression,p_base_expression);
77844 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
77845 : printf ("Error fails assertion (p_base_expression != NULL && base_expression != NULL && p_base_expression != base_expression) is false\n");
77846 : ROSE_ASSERT(false);
77847 : #endif
77848 : }
77849 : #endif
77850 0 : p_base_expression = base_expression;
77851 0 : }
77852 :
77853 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
77854 :
77855 :
77856 : // End of memberFunctionString
77857 : // Start of memberFunctionString
77858 :
77859 :
77860 : // End of memberFunctionString
77861 : // Start of memberFunctionString
77862 : /* #line 3653 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
77863 :
77864 :
77865 : void
77866 0 : SgTypeOfType::set_base_type(SgType* base_type)
77867 : {
77868 0 : ROSE_ASSERT(base_type != NULL);
77869 0 : if (p_base_expression == NULL || (isSgFunctionParameterRefExp(p_base_expression) != NULL))
77870 : {
77871 0 : p_base_type = base_type;
77872 : }
77873 : else
77874 : {
77875 : // Prefer the one available in p_base_expression.
77876 0 : p_base_type = NULL;
77877 0 : if (base_type != p_base_expression->get_type())
77878 : {
77879 0 : printf ("Error: base_type in SgTypeOfType::set_base_type() does not match p_base_expression->get_type() \n");
77880 : }
77881 0 : ROSE_ASSERT(base_type == p_base_expression->get_type());
77882 : }
77883 0 : }
77884 :
77885 : SgType*
77886 45 : SgTypeOfType::get_base_type() const
77887 : {
77888 45 : SgType* return_type = NULL;
77889 45 : ROSE_ASSERT(this != NULL);
77890 : // ROSE_ASSERT(p_base_expression != NULL);
77891 45 : if (p_base_expression == NULL || isSgFunctionParameterRefExp(p_base_expression) != NULL)
77892 : {
77893 12 : return_type = p_base_type;
77894 : }
77895 : else
77896 : {
77897 33 : return_type = p_base_expression->get_type();
77898 : }
77899 :
77900 45 : ROSE_ASSERT(return_type != NULL);
77901 :
77902 45 : return return_type;
77903 : // return p_base_expression->get_type();
77904 : }
77905 :
77906 : /*! Returns a mangled name representation of types taking expressions and base types (e.g., pointer, reference).
77907 : */
77908 : SgName
77909 39 : SgTypeOfType::get_mangled (void) const
77910 : {
77911 39 : ROSE_ASSERT(this != NULL);
77912 :
77913 39 : const SgType* base_type = get_base_type();
77914 39 : ROSE_ASSERT (base_type != NULL);
77915 :
77916 : #if 0
77917 : printf ("In SgTypeOfType::get_mangled(): base_type = %p = %s \n",base_type,base_type->class_name().c_str());
77918 : #endif
77919 :
77920 39 : SgName base_name = base_type->get_mangled();
77921 :
77922 : #if 0
77923 : printf ("DONE: In SgTypeOfType::get_mangled(): base_type = %p = %s base_name = %s \n",base_type,base_type->class_name().c_str(),base_name.str());
77924 : #endif
77925 :
77926 : // This can be NULL.
77927 39 : const SgExpression* base_expression = get_base_expression();
77928 : // ROSE_ASSERT (base_expression != NULL);
77929 39 : if (base_expression != NULL)
77930 : {
77931 : #if 0
77932 : printf ("In SgTypeOfType::get_mangled(): base_expression = %p = %s \n",base_expression,base_expression->class_name().c_str());
77933 : #endif
77934 :
77935 : // base_name += base_expression->get_mangled();
77936 : // base_name += SageInterface::get_name(base_expression);
77937 66 : base_name += string("_base_expr_") + Rose::StringUtility::numberToString(this);
77938 :
77939 : #if 0
77940 : printf ("DONE: In SgTypeOfType::get_mangled(): base_expression = %p = %s accumulated base_name = %s \n",base_expression,base_expression->class_name().c_str(),base_name.str());
77941 : #endif
77942 : }
77943 :
77944 : // DQ (6/21/2006): Use is_null() instead of counting the size (and fixed case were it is null)
77945 : // ROSE_ASSERT (base_name.get_length ());
77946 39 : if (base_name.is_null() == true)
77947 : {
77948 : // This happens for code such as: "typedef struct {int id; } *XYZ;"
77949 : #if 0
77950 : printf ("Warning: In SgTypeOfType::get_mangled(), empty base type name found \n");
77951 : #endif
77952 0 : base_name = "un_named_base_type";
77953 : }
77954 39 : ROSE_ASSERT (base_name.is_null() == false);
77955 :
77956 39 : SgName mangled_name;
77957 78 : mangled_name << "__" << "typeOftype" << "b__" // start tag
77958 78 : << base_name.str () // base expression and type
77959 78 : << "__" << "typeOftype" << "e__"; // end tag
77960 : #if 0
77961 : printf ("LEAVING: In SgTypeOfType::get_mangled(): base_expression = %p = %s base_type = %p = %s mangled_name = %s \n",
77962 : base_expression,base_expression != NULL ? base_expression->class_name().c_str() : "null",
77963 : base_type,base_type->class_name().c_str(),mangled_name.str());
77964 : #endif
77965 :
77966 39 : return mangled_name;
77967 : }
77968 :
77969 :
77970 :
77971 : // End of memberFunctionString
77972 : // Start of memberFunctionString
77973 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
77974 :
77975 : // *** COMMON CODE SECTION BEGINS HERE ***
77976 :
77977 : #if 0
77978 : int
77979 : SgTypeOfType::getVariant() const
77980 : {
77981 : // This function is used in ROSE while "variant()" is used in SAGE
77982 : assert(this != NULL);
77983 : return variant();
77984 : }
77985 : #endif
77986 :
77987 : // This function is used in ROSE in treeTraversal code
77988 : // eventually replaces getVariant() and variant()
77989 : // though after variant() has been removed for a while we will
77990 : // want to change the name of variantT() back to variant()
77991 : // (since the "T" was ment to stand for temporary).
77992 : // When this happens the variantT() will be depricated.
77993 : VariantT
77994 46059 : SgTypeOfType::variantT() const
77995 : {
77996 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
77997 46059 : ROSE_ASSERT(this != NULL);
77998 46059 : return V_SgTypeOfType;
77999 : }
78000 :
78001 : #if 0
78002 : int
78003 : SgTypeOfType::variant() const
78004 : {
78005 : // This function is used in SAGE
78006 : ROSE_ASSERT(this != NULL);
78007 : return T_TYPEOF_TYPE;
78008 : }
78009 : #endif
78010 :
78011 : ROSE_DLL_API const char*
78012 0 : SgTypeOfType::sage_class_name() const
78013 : {
78014 0 : ROSE_ASSERT(this != NULL);
78015 0 : return "SgTypeOfType";
78016 : }
78017 :
78018 : std::string
78019 24 : SgTypeOfType::class_name() const
78020 : {
78021 24 : ROSE_ASSERT(this != NULL);
78022 24 : return "SgTypeOfType";
78023 : }
78024 :
78025 : // DQ (11/26/2005): Support for visitor pattern mechanims
78026 : // (inferior to ROSE traversal mechanism, experimental).
78027 : void
78028 411 : SgTypeOfType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
78029 : {
78030 411 : ROSE_ASSERT(this != NULL);
78031 411 : visitor.visit(this);
78032 411 : }
78033 :
78034 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
78035 0 : void SgTypeOfType::accept (ROSE_VisitorPattern & visitor) {
78036 0 : ROSE_ASSERT(this != NULL);
78037 0 : visitor.visit(this);
78038 0 : }
78039 :
78040 : SgTypeOfType*
78041 0 : SgTypeOfType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
78042 : {
78043 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
78044 : // This function is currently only supported for the AST used the represent Binary executables.
78045 : if (0 /* isSgAsmNode(this) != NULL */)
78046 : {
78047 : // Support for regex specification.
78048 : std::string prefixCode = "REGEX:";
78049 : addNewAttribute(prefixCode + s,a);
78050 : }
78051 : #endif
78052 :
78053 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
78054 0 : return this;
78055 : }
78056 :
78057 : // *** COMMON CODE SECTION ENDS HERE ***
78058 :
78059 :
78060 : // End of memberFunctionString
78061 : // Start of memberFunctionString
78062 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
78063 :
78064 :
78065 : #if 0
78066 : //! Error checking support
78067 : /*! Verifies the following:
78068 : - working getVariant() member function
78069 : - calls base class's error() member function
78070 : Every class has one of these functions.
78071 : */
78072 : bool
78073 : SgTypeOfType::error()
78074 : {
78075 : // Put error checking here
78076 :
78077 : ROSE_ASSERT (this != NULL);
78078 : if (getVariant() != T_TYPEOF_TYPE)
78079 : {
78080 : printf ("Error in SgTypeOfType::error(): SgTypeOfType object has a %s variant \n",
78081 : Cxx_GrammarTerminalNames[getVariant()].name);
78082 : // printf ("Error in SgTypeOfType::error() \n");
78083 : ROSE_ABORT();
78084 : }
78085 :
78086 : ROSE_ASSERT (getVariant() == T_TYPEOF_TYPE);
78087 : return SgType::error();
78088 : }
78089 : #endif
78090 :
78091 :
78092 :
78093 : // End of memberFunctionString
78094 :
78095 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
78096 :
78097 110531 : SgTypeOfType* isSgTypeOfType ( SgNode* inputDerivedClassPointer )
78098 : {
78099 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
78100 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
78101 : // So to fix this we return NULL directly when the input is NULL and avoid the
78102 : // dynamic_cast in this case. This is likely a performance improvement as well.
78103 : // return dynamic_cast<SgTypeOfType*>(inputDerivedClassPointer);
78104 : // Milind Chabbi (8/28/2013): isSgTypeOfType uses table-driven castability instead of c++ default dynamic_cast
78105 : // this improves the running time performance by 10-20%.
78106 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeOfType*>(inputDerivedClassPointer);
78107 110531 : return IS_SgTypeOfType_FAST_MACRO(inputDerivedClassPointer);
78108 : }
78109 :
78110 : // DQ (11/8/2003): Added version of functions taking const pointer
78111 0 : const SgTypeOfType* isSgTypeOfType ( const SgNode* inputDerivedClassPointer )
78112 : {
78113 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
78114 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
78115 : // So to fix this we return NULL directly when the input is NULL and avoid the
78116 : // dynamic_cast in this case. This is likely a performance improvement as well.
78117 : // return dynamic_cast<const SgTypeOfType*>(inputDerivedClassPointer);
78118 : // Milind Chabbi (8/28/2013): isSgTypeOfType uses table-driven castability instead of c++ default dynamic_cast
78119 : // this improves the running time performance by 10-20%.
78120 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeOfType*>(inputDerivedClassPointer);
78121 0 : return IS_SgTypeOfType_FAST_MACRO(inputDerivedClassPointer);
78122 : }
78123 :
78124 :
78125 :
78126 : /* #line 78127 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78127 :
78128 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
78129 :
78130 : /**
78131 : \brief Generated destructor
78132 :
78133 : This destructor is automatically generated (by ROSETTA). This destructor
78134 : only frees memory of data members associated with the parts of the current IR node which
78135 : are NOT traversed. Those data members that are part of a traversal can be freed using
78136 : a traversal (calling this destructor on all children in a post-order traversal). Such
78137 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
78138 :
78139 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
78140 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
78141 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
78142 :
78143 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
78144 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
78145 : pointers are not yet implemented to call delete on eash pointer in the container.
78146 : (This could be done by derivation from the STL containers to define containers that
78147 : automatically deleted their members.)
78148 :
78149 : */
78150 12 : SgTypeOfType::~SgTypeOfType () {
78151 6 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
78152 :
78153 :
78154 : // case: not a listType for base_expression
78155 6 : p_base_expression = NULL; // non list case
78156 : // case: not a listType for base_type
78157 6 : p_base_type = NULL; // non list case
78158 :
78159 : }
78160 :
78161 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
78162 12 : }
78163 :
78164 :
78165 : /* #line 78166 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78166 :
78167 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
78168 :
78169 : // Generated constructor
78170 36 : SgTypeOfType::SgTypeOfType ( SgExpression* base_expression, SgType* base_type )
78171 36 : : SgType()
78172 : {
78173 : #ifdef DEBUG
78174 : // printf ("In SgTypeOfType::SgTypeOfType (SgExpression* base_expression, SgType* base_type) sage_class_name() = %s \n",sage_class_name());
78175 : #endif
78176 : #if 0
78177 : // debugging information!
78178 : printf ("In SgTypeOfType::SgTypeOfType (SgExpression* base_expression, SgType* base_type): this = %p = %s \n",this,this->class_name().c_str());
78179 : #endif
78180 :
78181 36 : p_base_expression = base_expression;
78182 36 : p_base_type = base_type;
78183 :
78184 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
78185 :
78186 : #if 0
78187 : // DQ (7/30/2014): Call a virtual function.
78188 : std::string s = this->class_name();
78189 : #endif
78190 :
78191 : // Test the variant virtual function
78192 : // assert(T_TYPEOF_TYPE == variant());
78193 36 : assert(T_TYPEOF_TYPE == this->variant());
78194 36 : ROSE_ASSERT(T_TYPEOF_TYPE == (int)(this->variantT()));
78195 36 : post_construction_initialization();
78196 :
78197 : // Test the isSgTypeOfType() function since it has been problematic
78198 36 : assert(isSgTypeOfType(this) != NULL);
78199 36 : }
78200 :
78201 : // Generated constructor (all data members)
78202 :
78203 : /* #line 78204 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78204 :
78205 :
78206 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
78207 :
78208 :
78209 : // ********************************************************
78210 : // member functions common across all array grammar objects
78211 : // ********************************************************
78212 :
78213 :
78214 :
78215 : /* #line 78216 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78216 :
78217 :
78218 :
78219 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
78220 :
78221 : // ********************************************************
78222 : // member functions specific to each node in the grammar
78223 : // ********************************************************
78224 :
78225 :
78226 : /* #line 78227 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78227 :
78228 : // Start of memberFunctionString
78229 :
78230 :
78231 : // End of memberFunctionString
78232 : // Start of memberFunctionString
78233 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
78234 :
78235 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
78236 :
78237 : SgType*
78238 0 : SgTypeMatrix::get_base_type () const
78239 : {
78240 0 : ROSE_ASSERT (this != NULL);
78241 :
78242 : #if 0
78243 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
78244 : // used to trigger marking transformations for the token-based unparsing.
78245 : printf ("SgTypeMatrix::get_base_type = %p = %s \n",this,this->class_name().c_str());
78246 : #endif
78247 :
78248 0 : return p_base_type;
78249 : }
78250 :
78251 : void
78252 0 : SgTypeMatrix::set_base_type ( SgType* base_type )
78253 : {
78254 0 : ROSE_ASSERT (this != NULL);
78255 :
78256 : #if 0
78257 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
78258 : // used to trigger marking transformations for the token-based unparsing.
78259 : printf ("SgTypeMatrix::set_base_type = %p = %s \n",this,this->class_name().c_str());
78260 : #endif
78261 :
78262 0 : set_isModified(true);
78263 :
78264 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
78265 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
78266 : {
78267 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
78268 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
78269 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
78270 : ROSE_ASSERT(false);
78271 : #endif
78272 : }
78273 : #endif
78274 0 : p_base_type = base_type;
78275 0 : }
78276 :
78277 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
78278 :
78279 :
78280 : // End of memberFunctionString
78281 : // Start of memberFunctionString
78282 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
78283 :
78284 : // *** COMMON CODE SECTION BEGINS HERE ***
78285 :
78286 : #if 0
78287 : int
78288 : SgTypeMatrix::getVariant() const
78289 : {
78290 : // This function is used in ROSE while "variant()" is used in SAGE
78291 : assert(this != NULL);
78292 : return variant();
78293 : }
78294 : #endif
78295 :
78296 : // This function is used in ROSE in treeTraversal code
78297 : // eventually replaces getVariant() and variant()
78298 : // though after variant() has been removed for a while we will
78299 : // want to change the name of variantT() back to variant()
78300 : // (since the "T" was ment to stand for temporary).
78301 : // When this happens the variantT() will be depricated.
78302 : VariantT
78303 0 : SgTypeMatrix::variantT() const
78304 : {
78305 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
78306 0 : ROSE_ASSERT(this != NULL);
78307 0 : return V_SgTypeMatrix;
78308 : }
78309 :
78310 : #if 0
78311 : int
78312 : SgTypeMatrix::variant() const
78313 : {
78314 : // This function is used in SAGE
78315 : ROSE_ASSERT(this != NULL);
78316 : return T_MATRIX;
78317 : }
78318 : #endif
78319 :
78320 : ROSE_DLL_API const char*
78321 0 : SgTypeMatrix::sage_class_name() const
78322 : {
78323 0 : ROSE_ASSERT(this != NULL);
78324 0 : return "SgTypeMatrix";
78325 : }
78326 :
78327 : std::string
78328 0 : SgTypeMatrix::class_name() const
78329 : {
78330 0 : ROSE_ASSERT(this != NULL);
78331 0 : return "SgTypeMatrix";
78332 : }
78333 :
78334 : // DQ (11/26/2005): Support for visitor pattern mechanims
78335 : // (inferior to ROSE traversal mechanism, experimental).
78336 : void
78337 0 : SgTypeMatrix::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
78338 : {
78339 0 : ROSE_ASSERT(this != NULL);
78340 0 : visitor.visit(this);
78341 0 : }
78342 :
78343 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
78344 0 : void SgTypeMatrix::accept (ROSE_VisitorPattern & visitor) {
78345 0 : ROSE_ASSERT(this != NULL);
78346 0 : visitor.visit(this);
78347 0 : }
78348 :
78349 : SgTypeMatrix*
78350 0 : SgTypeMatrix::addRegExpAttribute(std::string s, AstRegExAttribute* a)
78351 : {
78352 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
78353 : // This function is currently only supported for the AST used the represent Binary executables.
78354 : if (0 /* isSgAsmNode(this) != NULL */)
78355 : {
78356 : // Support for regex specification.
78357 : std::string prefixCode = "REGEX:";
78358 : addNewAttribute(prefixCode + s,a);
78359 : }
78360 : #endif
78361 :
78362 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
78363 0 : return this;
78364 : }
78365 :
78366 : // *** COMMON CODE SECTION ENDS HERE ***
78367 :
78368 :
78369 : // End of memberFunctionString
78370 : // Start of memberFunctionString
78371 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
78372 :
78373 :
78374 : #if 0
78375 : //! Error checking support
78376 : /*! Verifies the following:
78377 : - working getVariant() member function
78378 : - calls base class's error() member function
78379 : Every class has one of these functions.
78380 : */
78381 : bool
78382 : SgTypeMatrix::error()
78383 : {
78384 : // Put error checking here
78385 :
78386 : ROSE_ASSERT (this != NULL);
78387 : if (getVariant() != T_MATRIX)
78388 : {
78389 : printf ("Error in SgTypeMatrix::error(): SgTypeMatrix object has a %s variant \n",
78390 : Cxx_GrammarTerminalNames[getVariant()].name);
78391 : // printf ("Error in SgTypeMatrix::error() \n");
78392 : ROSE_ABORT();
78393 : }
78394 :
78395 : ROSE_ASSERT (getVariant() == T_MATRIX);
78396 : return SgType::error();
78397 : }
78398 : #endif
78399 :
78400 :
78401 :
78402 : // End of memberFunctionString
78403 : // Start of memberFunctionString
78404 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
78405 :
78406 :
78407 : // DQ (1/31/2006): Modified to build all types in the memory pools
78408 : // SgTypeMatrix SgTypeMatrix::builtin_type;
78409 : // SgTypeMatrix* SgTypeMatrix::builtin_type = new SgTypeMatrix();
78410 : SgTypeMatrix* SgTypeMatrix::p_builtin_type = NULL;
78411 :
78412 :
78413 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
78414 : // SgTypeMatrix* SgTypeMatrix::createType(void)
78415 : SgTypeMatrix*
78416 0 : SgTypeMatrix::createType(SgExpression* optional_fortran_type_kind)
78417 : {
78418 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
78419 : // is not called (likely because static initialization is compiler dependent).
78420 : // DQ (1/31/2006): Modified to build all types in the memory pools
78421 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
78422 : // return &builtin_type;
78423 :
78424 : #if 0
78425 : printf ("In SgTypeMatrix::createType() (COMMON_CREATE_TYPE) \n");
78426 : #endif
78427 :
78428 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
78429 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
78430 :
78431 0 : SgTypeMatrix* temp_type = new SgTypeMatrix();
78432 :
78433 : #if 0
78434 : printf ("In SgTypeMatrix::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
78435 : #endif
78436 :
78437 : // DQ (10/31/2016): Added assertion.
78438 0 : ROSE_ASSERT(temp_type != NULL);
78439 :
78440 0 : if (optional_fortran_type_kind != NULL)
78441 : {
78442 : // DQ (10/31/2016): Added assertion.
78443 0 : ROSE_ASSERT(temp_type != NULL);
78444 :
78445 0 : temp_type->set_type_kind(optional_fortran_type_kind);
78446 : }
78447 : #if 0
78448 : else
78449 : {
78450 : // Let p_builtin_type refer to the unadorned type (no type kind).
78451 : p_builtin_type = temp_type;
78452 : }
78453 : #endif
78454 :
78455 0 : SgName name = temp_type->get_mangled();
78456 :
78457 : #if 0
78458 : printf ("Mangled type name for SgTypeMatrix = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
78459 : #endif
78460 :
78461 : // DQ (10/31/2016): Added assertion.
78462 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
78463 :
78464 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
78465 :
78466 : #if 0
78467 : printf ("In SgTypeMatrix::createType(): type from lookup_type = %p \n",t);
78468 : #endif
78469 :
78470 0 : if (t == NULL)
78471 : {
78472 0 : get_globalTypeTable()->insert_type(name,temp_type);
78473 : }
78474 : else
78475 : {
78476 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
78477 0 : if (t != temp_type)
78478 : {
78479 : #if 0
78480 : printf ("In SgTypeMatrix::createType(): deleting temp_type = %p \n",temp_type);
78481 : #endif
78482 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
78483 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
78484 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
78485 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
78486 0 : delete temp_type;
78487 : #endif
78488 0 : temp_type = NULL;
78489 : #if 0
78490 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
78491 : if (optional_fortran_type_kind != NULL)
78492 : {
78493 : p_builtin_type = NULL;
78494 : }
78495 : #endif
78496 : }
78497 :
78498 : // Reuse this tempType variable so we can use the same code below.
78499 0 : temp_type = isSgTypeMatrix(t);
78500 0 : ROSE_ASSERT(temp_type != NULL);
78501 : }
78502 :
78503 : #if 0
78504 : printf ("Leaving SgTypeMatrix::createType(): temp_type = %p \n",temp_type);
78505 : #endif
78506 :
78507 0 : return temp_type;
78508 : }
78509 :
78510 :
78511 :
78512 : // End of memberFunctionString
78513 : // Start of memberFunctionString
78514 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
78515 :
78516 : #if 1
78517 : /*! Support for mangled names (for unparser)
78518 : There are two different cases of source code for the get_mangled member function
78519 : This one is used in all but the classes containing a base type
78520 : */
78521 : // SgName SgTypeMatrix::get_mangled ( SgUnparse_Info & info )
78522 : SgName
78523 0 : SgTypeMatrix::get_mangled (void) const
78524 : {
78525 0 : ROSE_ASSERT(this != NULL);
78526 :
78527 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
78528 : // CR (3/6/2020): Now type_kind is also used for Jovial.
78529 0 : SgName name = "matrix_t";
78530 0 : if (get_type_kind() != NULL)
78531 : {
78532 : // name += get_type_kind()->get_mangled();
78533 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
78534 0 : SgValueExp* value = isSgValueExp(get_type_kind());
78535 0 : if (value != NULL)
78536 : {
78537 : // name += string("_") + StringUtility::numberToString(value->get_value());
78538 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
78539 : }
78540 : else
78541 : {
78542 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
78543 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
78544 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
78545 : // a different prefix for each type of named type. It come down to is there can be multiple
78546 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
78547 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
78548 : // I think the issue is that matrix_t is not defined for any of the SgNameType IR nodes.
78549 : #if 0
78550 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"matrix_t");
78551 : #endif
78552 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
78553 : }
78554 : }
78555 :
78556 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
78557 : // REMOVE_ME please!
78558 0 : if (isSgTypeFixed(this))
78559 : {
78560 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
78561 0 : if (fixed_type->get_scale() != NULL)
78562 : {
78563 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
78564 0 : if (value != NULL)
78565 : {
78566 0 : name += string("_") + value->get_constant_folded_value_as_string();
78567 : }
78568 : }
78569 0 : if (fixed_type->get_fraction() != NULL)
78570 : {
78571 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
78572 0 : if (value != NULL)
78573 : {
78574 0 : name += string("_") + value->get_constant_folded_value_as_string();
78575 : }
78576 : }
78577 : }
78578 :
78579 : #if 0
78580 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
78581 : #endif
78582 :
78583 0 : return name;
78584 : }
78585 : #endif
78586 :
78587 :
78588 : // End of memberFunctionString
78589 :
78590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
78591 :
78592 0 : SgTypeMatrix* isSgTypeMatrix ( SgNode* inputDerivedClassPointer )
78593 : {
78594 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
78595 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
78596 : // So to fix this we return NULL directly when the input is NULL and avoid the
78597 : // dynamic_cast in this case. This is likely a performance improvement as well.
78598 : // return dynamic_cast<SgTypeMatrix*>(inputDerivedClassPointer);
78599 : // Milind Chabbi (8/28/2013): isSgTypeMatrix uses table-driven castability instead of c++ default dynamic_cast
78600 : // this improves the running time performance by 10-20%.
78601 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeMatrix*>(inputDerivedClassPointer);
78602 0 : return IS_SgTypeMatrix_FAST_MACRO(inputDerivedClassPointer);
78603 : }
78604 :
78605 : // DQ (11/8/2003): Added version of functions taking const pointer
78606 0 : const SgTypeMatrix* isSgTypeMatrix ( const SgNode* inputDerivedClassPointer )
78607 : {
78608 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
78609 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
78610 : // So to fix this we return NULL directly when the input is NULL and avoid the
78611 : // dynamic_cast in this case. This is likely a performance improvement as well.
78612 : // return dynamic_cast<const SgTypeMatrix*>(inputDerivedClassPointer);
78613 : // Milind Chabbi (8/28/2013): isSgTypeMatrix uses table-driven castability instead of c++ default dynamic_cast
78614 : // this improves the running time performance by 10-20%.
78615 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeMatrix*>(inputDerivedClassPointer);
78616 0 : return IS_SgTypeMatrix_FAST_MACRO(inputDerivedClassPointer);
78617 : }
78618 :
78619 :
78620 :
78621 : /* #line 78622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78622 :
78623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
78624 :
78625 : /**
78626 : \brief Generated destructor
78627 :
78628 : This destructor is automatically generated (by ROSETTA). This destructor
78629 : only frees memory of data members associated with the parts of the current IR node which
78630 : are NOT traversed. Those data members that are part of a traversal can be freed using
78631 : a traversal (calling this destructor on all children in a post-order traversal). Such
78632 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
78633 :
78634 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
78635 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
78636 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
78637 :
78638 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
78639 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
78640 : pointers are not yet implemented to call delete on eash pointer in the container.
78641 : (This could be done by derivation from the STL containers to define containers that
78642 : automatically deleted their members.)
78643 :
78644 : */
78645 0 : SgTypeMatrix::~SgTypeMatrix () {
78646 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
78647 :
78648 :
78649 : // case: not a listType for base_type
78650 0 : p_base_type = NULL; // non list case
78651 :
78652 : }
78653 :
78654 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
78655 0 : }
78656 :
78657 :
78658 : /* #line 78659 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78659 :
78660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
78661 :
78662 : // Generated constructor
78663 0 : SgTypeMatrix::SgTypeMatrix ( )
78664 0 : : SgType()
78665 : {
78666 : #ifdef DEBUG
78667 : // printf ("In SgTypeMatrix::SgTypeMatrix () sage_class_name() = %s \n",sage_class_name());
78668 : #endif
78669 : #if 0
78670 : // debugging information!
78671 : printf ("In SgTypeMatrix::SgTypeMatrix (): this = %p = %s \n",this,this->class_name().c_str());
78672 : #endif
78673 :
78674 0 : p_base_type = NULL;
78675 :
78676 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
78677 :
78678 : #if 0
78679 : // DQ (7/30/2014): Call a virtual function.
78680 : std::string s = this->class_name();
78681 : #endif
78682 :
78683 : // Test the variant virtual function
78684 : // assert(T_MATRIX == variant());
78685 0 : assert(T_MATRIX == this->variant());
78686 0 : ROSE_ASSERT(T_MATRIX == (int)(this->variantT()));
78687 0 : post_construction_initialization();
78688 :
78689 : // Test the isSgTypeMatrix() function since it has been problematic
78690 0 : assert(isSgTypeMatrix(this) != NULL);
78691 0 : }
78692 :
78693 : // Generated constructor (all data members)
78694 :
78695 : /* #line 78696 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78696 :
78697 :
78698 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
78699 :
78700 :
78701 : // ********************************************************
78702 : // member functions common across all array grammar objects
78703 : // ********************************************************
78704 :
78705 :
78706 :
78707 : /* #line 78708 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78708 :
78709 :
78710 :
78711 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
78712 :
78713 : // ********************************************************
78714 : // member functions specific to each node in the grammar
78715 : // ********************************************************
78716 :
78717 :
78718 : /* #line 78719 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
78719 :
78720 : // Start of memberFunctionString
78721 :
78722 :
78723 : // End of memberFunctionString
78724 : // Start of memberFunctionString
78725 : /* #line 3157 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
78726 :
78727 :
78728 : SgTypePtrList&
78729 0 : SgTypeTuple::get_types()
78730 0 : { return p_types; }
78731 :
78732 : const SgTypePtrList&
78733 0 : SgTypeTuple::get_types() const
78734 0 : { return p_types; }
78735 :
78736 : void
78737 0 : SgTypeTuple::append_type(SgType *what)
78738 0 : { what->set_parent(this); p_types.push_back(what); }
78739 :
78740 : void
78741 0 : SgTypeTuple::prepend_type(SgType *what)
78742 0 : { what->set_parent(this); p_types.insert(p_types.begin(), what); }
78743 :
78744 :
78745 :
78746 : // End of memberFunctionString
78747 : // Start of memberFunctionString
78748 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
78749 :
78750 : // *** COMMON CODE SECTION BEGINS HERE ***
78751 :
78752 : #if 0
78753 : int
78754 : SgTypeTuple::getVariant() const
78755 : {
78756 : // This function is used in ROSE while "variant()" is used in SAGE
78757 : assert(this != NULL);
78758 : return variant();
78759 : }
78760 : #endif
78761 :
78762 : // This function is used in ROSE in treeTraversal code
78763 : // eventually replaces getVariant() and variant()
78764 : // though after variant() has been removed for a while we will
78765 : // want to change the name of variantT() back to variant()
78766 : // (since the "T" was ment to stand for temporary).
78767 : // When this happens the variantT() will be depricated.
78768 : VariantT
78769 0 : SgTypeTuple::variantT() const
78770 : {
78771 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
78772 0 : ROSE_ASSERT(this != NULL);
78773 0 : return V_SgTypeTuple;
78774 : }
78775 :
78776 : #if 0
78777 : int
78778 : SgTypeTuple::variant() const
78779 : {
78780 : // This function is used in SAGE
78781 : ROSE_ASSERT(this != NULL);
78782 : return T_TUPLE;
78783 : }
78784 : #endif
78785 :
78786 : ROSE_DLL_API const char*
78787 0 : SgTypeTuple::sage_class_name() const
78788 : {
78789 0 : ROSE_ASSERT(this != NULL);
78790 0 : return "SgTypeTuple";
78791 : }
78792 :
78793 : std::string
78794 0 : SgTypeTuple::class_name() const
78795 : {
78796 0 : ROSE_ASSERT(this != NULL);
78797 0 : return "SgTypeTuple";
78798 : }
78799 :
78800 : // DQ (11/26/2005): Support for visitor pattern mechanims
78801 : // (inferior to ROSE traversal mechanism, experimental).
78802 : void
78803 0 : SgTypeTuple::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
78804 : {
78805 0 : ROSE_ASSERT(this != NULL);
78806 0 : visitor.visit(this);
78807 0 : }
78808 :
78809 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
78810 0 : void SgTypeTuple::accept (ROSE_VisitorPattern & visitor) {
78811 0 : ROSE_ASSERT(this != NULL);
78812 0 : visitor.visit(this);
78813 0 : }
78814 :
78815 : SgTypeTuple*
78816 0 : SgTypeTuple::addRegExpAttribute(std::string s, AstRegExAttribute* a)
78817 : {
78818 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
78819 : // This function is currently only supported for the AST used the represent Binary executables.
78820 : if (0 /* isSgAsmNode(this) != NULL */)
78821 : {
78822 : // Support for regex specification.
78823 : std::string prefixCode = "REGEX:";
78824 : addNewAttribute(prefixCode + s,a);
78825 : }
78826 : #endif
78827 :
78828 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
78829 0 : return this;
78830 : }
78831 :
78832 : // *** COMMON CODE SECTION ENDS HERE ***
78833 :
78834 :
78835 : // End of memberFunctionString
78836 : // Start of memberFunctionString
78837 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
78838 :
78839 :
78840 : #if 0
78841 : //! Error checking support
78842 : /*! Verifies the following:
78843 : - working getVariant() member function
78844 : - calls base class's error() member function
78845 : Every class has one of these functions.
78846 : */
78847 : bool
78848 : SgTypeTuple::error()
78849 : {
78850 : // Put error checking here
78851 :
78852 : ROSE_ASSERT (this != NULL);
78853 : if (getVariant() != T_TUPLE)
78854 : {
78855 : printf ("Error in SgTypeTuple::error(): SgTypeTuple object has a %s variant \n",
78856 : Cxx_GrammarTerminalNames[getVariant()].name);
78857 : // printf ("Error in SgTypeTuple::error() \n");
78858 : ROSE_ABORT();
78859 : }
78860 :
78861 : ROSE_ASSERT (getVariant() == T_TUPLE);
78862 : return SgType::error();
78863 : }
78864 : #endif
78865 :
78866 :
78867 :
78868 : // End of memberFunctionString
78869 : // Start of memberFunctionString
78870 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
78871 :
78872 :
78873 : // DQ (1/31/2006): Modified to build all types in the memory pools
78874 : // SgTypeTuple SgTypeTuple::builtin_type;
78875 : // SgTypeTuple* SgTypeTuple::builtin_type = new SgTypeTuple();
78876 : SgTypeTuple* SgTypeTuple::p_builtin_type = NULL;
78877 :
78878 :
78879 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
78880 : // SgTypeTuple* SgTypeTuple::createType(void)
78881 : SgTypeTuple*
78882 0 : SgTypeTuple::createType(SgExpression* optional_fortran_type_kind)
78883 : {
78884 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
78885 : // is not called (likely because static initialization is compiler dependent).
78886 : // DQ (1/31/2006): Modified to build all types in the memory pools
78887 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
78888 : // return &builtin_type;
78889 :
78890 : #if 0
78891 : printf ("In SgTypeTuple::createType() (COMMON_CREATE_TYPE) \n");
78892 : #endif
78893 :
78894 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
78895 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
78896 :
78897 0 : SgTypeTuple* temp_type = new SgTypeTuple();
78898 :
78899 : #if 0
78900 : printf ("In SgTypeTuple::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
78901 : #endif
78902 :
78903 : // DQ (10/31/2016): Added assertion.
78904 0 : ROSE_ASSERT(temp_type != NULL);
78905 :
78906 0 : if (optional_fortran_type_kind != NULL)
78907 : {
78908 : // DQ (10/31/2016): Added assertion.
78909 0 : ROSE_ASSERT(temp_type != NULL);
78910 :
78911 0 : temp_type->set_type_kind(optional_fortran_type_kind);
78912 : }
78913 : #if 0
78914 : else
78915 : {
78916 : // Let p_builtin_type refer to the unadorned type (no type kind).
78917 : p_builtin_type = temp_type;
78918 : }
78919 : #endif
78920 :
78921 0 : SgName name = temp_type->get_mangled();
78922 :
78923 : #if 0
78924 : printf ("Mangled type name for SgTypeTuple = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
78925 : #endif
78926 :
78927 : // DQ (10/31/2016): Added assertion.
78928 0 : ROSE_ASSERT(get_globalTypeTable() != NULL);
78929 :
78930 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
78931 :
78932 : #if 0
78933 : printf ("In SgTypeTuple::createType(): type from lookup_type = %p \n",t);
78934 : #endif
78935 :
78936 0 : if (t == NULL)
78937 : {
78938 0 : get_globalTypeTable()->insert_type(name,temp_type);
78939 : }
78940 : else
78941 : {
78942 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
78943 0 : if (t != temp_type)
78944 : {
78945 : #if 0
78946 : printf ("In SgTypeTuple::createType(): deleting temp_type = %p \n",temp_type);
78947 : #endif
78948 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
78949 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
78950 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
78951 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
78952 0 : delete temp_type;
78953 : #endif
78954 0 : temp_type = NULL;
78955 : #if 0
78956 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
78957 : if (optional_fortran_type_kind != NULL)
78958 : {
78959 : p_builtin_type = NULL;
78960 : }
78961 : #endif
78962 : }
78963 :
78964 : // Reuse this tempType variable so we can use the same code below.
78965 0 : temp_type = isSgTypeTuple(t);
78966 0 : ROSE_ASSERT(temp_type != NULL);
78967 : }
78968 :
78969 : #if 0
78970 : printf ("Leaving SgTypeTuple::createType(): temp_type = %p \n",temp_type);
78971 : #endif
78972 :
78973 0 : return temp_type;
78974 : }
78975 :
78976 :
78977 :
78978 : // End of memberFunctionString
78979 : // Start of memberFunctionString
78980 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
78981 :
78982 : #if 1
78983 : /*! Support for mangled names (for unparser)
78984 : There are two different cases of source code for the get_mangled member function
78985 : This one is used in all but the classes containing a base type
78986 : */
78987 : // SgName SgTypeTuple::get_mangled ( SgUnparse_Info & info )
78988 : SgName
78989 0 : SgTypeTuple::get_mangled (void) const
78990 : {
78991 0 : ROSE_ASSERT(this != NULL);
78992 :
78993 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
78994 : // CR (3/6/2020): Now type_kind is also used for Jovial.
78995 0 : SgName name = "tuple_t";
78996 0 : if (get_type_kind() != NULL)
78997 : {
78998 : // name += get_type_kind()->get_mangled();
78999 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
79000 0 : SgValueExp* value = isSgValueExp(get_type_kind());
79001 0 : if (value != NULL)
79002 : {
79003 : // name += string("_") + StringUtility::numberToString(value->get_value());
79004 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
79005 : }
79006 : else
79007 : {
79008 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
79009 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
79010 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
79011 : // a different prefix for each type of named type. It come down to is there can be multiple
79012 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
79013 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
79014 : // I think the issue is that tuple_t is not defined for any of the SgNameType IR nodes.
79015 : #if 0
79016 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"tuple_t");
79017 : #endif
79018 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
79019 : }
79020 : }
79021 :
79022 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
79023 : // REMOVE_ME please!
79024 0 : if (isSgTypeFixed(this))
79025 : {
79026 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
79027 0 : if (fixed_type->get_scale() != NULL)
79028 : {
79029 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
79030 0 : if (value != NULL)
79031 : {
79032 0 : name += string("_") + value->get_constant_folded_value_as_string();
79033 : }
79034 : }
79035 0 : if (fixed_type->get_fraction() != NULL)
79036 : {
79037 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
79038 0 : if (value != NULL)
79039 : {
79040 0 : name += string("_") + value->get_constant_folded_value_as_string();
79041 : }
79042 : }
79043 : }
79044 :
79045 : #if 0
79046 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
79047 : #endif
79048 :
79049 0 : return name;
79050 : }
79051 : #endif
79052 :
79053 :
79054 : // End of memberFunctionString
79055 :
79056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
79057 :
79058 0 : SgTypeTuple* isSgTypeTuple ( SgNode* inputDerivedClassPointer )
79059 : {
79060 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
79061 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
79062 : // So to fix this we return NULL directly when the input is NULL and avoid the
79063 : // dynamic_cast in this case. This is likely a performance improvement as well.
79064 : // return dynamic_cast<SgTypeTuple*>(inputDerivedClassPointer);
79065 : // Milind Chabbi (8/28/2013): isSgTypeTuple uses table-driven castability instead of c++ default dynamic_cast
79066 : // this improves the running time performance by 10-20%.
79067 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeTuple*>(inputDerivedClassPointer);
79068 0 : return IS_SgTypeTuple_FAST_MACRO(inputDerivedClassPointer);
79069 : }
79070 :
79071 : // DQ (11/8/2003): Added version of functions taking const pointer
79072 0 : const SgTypeTuple* isSgTypeTuple ( const SgNode* inputDerivedClassPointer )
79073 : {
79074 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
79075 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
79076 : // So to fix this we return NULL directly when the input is NULL and avoid the
79077 : // dynamic_cast in this case. This is likely a performance improvement as well.
79078 : // return dynamic_cast<const SgTypeTuple*>(inputDerivedClassPointer);
79079 : // Milind Chabbi (8/28/2013): isSgTypeTuple uses table-driven castability instead of c++ default dynamic_cast
79080 : // this improves the running time performance by 10-20%.
79081 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeTuple*>(inputDerivedClassPointer);
79082 0 : return IS_SgTypeTuple_FAST_MACRO(inputDerivedClassPointer);
79083 : }
79084 :
79085 :
79086 :
79087 : /* #line 79088 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79088 :
79089 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
79090 :
79091 : /**
79092 : \brief Generated destructor
79093 :
79094 : This destructor is automatically generated (by ROSETTA). This destructor
79095 : only frees memory of data members associated with the parts of the current IR node which
79096 : are NOT traversed. Those data members that are part of a traversal can be freed using
79097 : a traversal (calling this destructor on all children in a post-order traversal). Such
79098 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
79099 :
79100 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
79101 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
79102 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
79103 :
79104 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
79105 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
79106 : pointers are not yet implemented to call delete on eash pointer in the container.
79107 : (This could be done by derivation from the STL containers to define containers that
79108 : automatically deleted their members.)
79109 :
79110 : */
79111 0 : SgTypeTuple::~SgTypeTuple () {
79112 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
79113 :
79114 :
79115 :
79116 : }
79117 :
79118 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
79119 0 : }
79120 :
79121 :
79122 : /* #line 79123 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79123 :
79124 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
79125 :
79126 : // Generated constructor
79127 0 : SgTypeTuple::SgTypeTuple ( )
79128 0 : : SgType()
79129 : {
79130 : #ifdef DEBUG
79131 : // printf ("In SgTypeTuple::SgTypeTuple () sage_class_name() = %s \n",sage_class_name());
79132 : #endif
79133 : #if 0
79134 : // debugging information!
79135 : printf ("In SgTypeTuple::SgTypeTuple (): this = %p = %s \n",this,this->class_name().c_str());
79136 : #endif
79137 :
79138 :
79139 :
79140 : #if 0
79141 : // DQ (7/30/2014): Call a virtual function.
79142 : std::string s = this->class_name();
79143 : #endif
79144 :
79145 : // Test the variant virtual function
79146 : // assert(T_TUPLE == variant());
79147 0 : assert(T_TUPLE == this->variant());
79148 0 : ROSE_ASSERT(T_TUPLE == (int)(this->variantT()));
79149 0 : post_construction_initialization();
79150 :
79151 : // Test the isSgTypeTuple() function since it has been problematic
79152 0 : assert(isSgTypeTuple(this) != NULL);
79153 0 : }
79154 :
79155 : // Generated constructor (all data members)
79156 :
79157 : /* #line 79158 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79158 :
79159 :
79160 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
79161 :
79162 :
79163 : // ********************************************************
79164 : // member functions common across all array grammar objects
79165 : // ********************************************************
79166 :
79167 :
79168 :
79169 : /* #line 79170 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79170 :
79171 :
79172 :
79173 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
79174 :
79175 : // ********************************************************
79176 : // member functions specific to each node in the grammar
79177 : // ********************************************************
79178 :
79179 :
79180 : /* #line 79181 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79181 :
79182 : // Start of memberFunctionString
79183 :
79184 :
79185 : // End of memberFunctionString
79186 : // Start of memberFunctionString
79187 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
79188 :
79189 : // *** COMMON CODE SECTION BEGINS HERE ***
79190 :
79191 : #if 0
79192 : int
79193 : SgTypeChar16::getVariant() const
79194 : {
79195 : // This function is used in ROSE while "variant()" is used in SAGE
79196 : assert(this != NULL);
79197 : return variant();
79198 : }
79199 : #endif
79200 :
79201 : // This function is used in ROSE in treeTraversal code
79202 : // eventually replaces getVariant() and variant()
79203 : // though after variant() has been removed for a while we will
79204 : // want to change the name of variantT() back to variant()
79205 : // (since the "T" was ment to stand for temporary).
79206 : // When this happens the variantT() will be depricated.
79207 : VariantT
79208 2694610 : SgTypeChar16::variantT() const
79209 : {
79210 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
79211 2694610 : ROSE_ASSERT(this != NULL);
79212 2694610 : return V_SgTypeChar16;
79213 : }
79214 :
79215 : #if 0
79216 : int
79217 : SgTypeChar16::variant() const
79218 : {
79219 : // This function is used in SAGE
79220 : ROSE_ASSERT(this != NULL);
79221 : return T_CHAR16;
79222 : }
79223 : #endif
79224 :
79225 : ROSE_DLL_API const char*
79226 0 : SgTypeChar16::sage_class_name() const
79227 : {
79228 0 : ROSE_ASSERT(this != NULL);
79229 0 : return "SgTypeChar16";
79230 : }
79231 :
79232 : std::string
79233 66 : SgTypeChar16::class_name() const
79234 : {
79235 66 : ROSE_ASSERT(this != NULL);
79236 66 : return "SgTypeChar16";
79237 : }
79238 :
79239 : // DQ (11/26/2005): Support for visitor pattern mechanims
79240 : // (inferior to ROSE traversal mechanism, experimental).
79241 : void
79242 137 : SgTypeChar16::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
79243 : {
79244 137 : ROSE_ASSERT(this != NULL);
79245 137 : visitor.visit(this);
79246 137 : }
79247 :
79248 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
79249 0 : void SgTypeChar16::accept (ROSE_VisitorPattern & visitor) {
79250 0 : ROSE_ASSERT(this != NULL);
79251 0 : visitor.visit(this);
79252 0 : }
79253 :
79254 : SgTypeChar16*
79255 0 : SgTypeChar16::addRegExpAttribute(std::string s, AstRegExAttribute* a)
79256 : {
79257 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
79258 : // This function is currently only supported for the AST used the represent Binary executables.
79259 : if (0 /* isSgAsmNode(this) != NULL */)
79260 : {
79261 : // Support for regex specification.
79262 : std::string prefixCode = "REGEX:";
79263 : addNewAttribute(prefixCode + s,a);
79264 : }
79265 : #endif
79266 :
79267 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
79268 0 : return this;
79269 : }
79270 :
79271 : // *** COMMON CODE SECTION ENDS HERE ***
79272 :
79273 :
79274 : // End of memberFunctionString
79275 : // Start of memberFunctionString
79276 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
79277 :
79278 :
79279 : #if 0
79280 : //! Error checking support
79281 : /*! Verifies the following:
79282 : - working getVariant() member function
79283 : - calls base class's error() member function
79284 : Every class has one of these functions.
79285 : */
79286 : bool
79287 : SgTypeChar16::error()
79288 : {
79289 : // Put error checking here
79290 :
79291 : ROSE_ASSERT (this != NULL);
79292 : if (getVariant() != T_CHAR16)
79293 : {
79294 : printf ("Error in SgTypeChar16::error(): SgTypeChar16 object has a %s variant \n",
79295 : Cxx_GrammarTerminalNames[getVariant()].name);
79296 : // printf ("Error in SgTypeChar16::error() \n");
79297 : ROSE_ABORT();
79298 : }
79299 :
79300 : ROSE_ASSERT (getVariant() == T_CHAR16);
79301 : return SgType::error();
79302 : }
79303 : #endif
79304 :
79305 :
79306 :
79307 : // End of memberFunctionString
79308 : // Start of memberFunctionString
79309 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
79310 :
79311 :
79312 : // DQ (1/31/2006): Modified to build all types in the memory pools
79313 : // SgTypeChar16 SgTypeChar16::builtin_type;
79314 : // SgTypeChar16* SgTypeChar16::builtin_type = new SgTypeChar16();
79315 : SgTypeChar16* SgTypeChar16::p_builtin_type = NULL;
79316 :
79317 :
79318 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
79319 : // SgTypeChar16* SgTypeChar16::createType(void)
79320 : SgTypeChar16*
79321 10 : SgTypeChar16::createType(SgExpression* optional_fortran_type_kind)
79322 : {
79323 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
79324 : // is not called (likely because static initialization is compiler dependent).
79325 : // DQ (1/31/2006): Modified to build all types in the memory pools
79326 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
79327 : // return &builtin_type;
79328 :
79329 : #if 0
79330 : printf ("In SgTypeChar16::createType() (COMMON_CREATE_TYPE) \n");
79331 : #endif
79332 :
79333 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
79334 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
79335 :
79336 10 : SgTypeChar16* temp_type = new SgTypeChar16();
79337 :
79338 : #if 0
79339 : printf ("In SgTypeChar16::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
79340 : #endif
79341 :
79342 : // DQ (10/31/2016): Added assertion.
79343 10 : ROSE_ASSERT(temp_type != NULL);
79344 :
79345 10 : if (optional_fortran_type_kind != NULL)
79346 : {
79347 : // DQ (10/31/2016): Added assertion.
79348 0 : ROSE_ASSERT(temp_type != NULL);
79349 :
79350 0 : temp_type->set_type_kind(optional_fortran_type_kind);
79351 : }
79352 : #if 0
79353 : else
79354 : {
79355 : // Let p_builtin_type refer to the unadorned type (no type kind).
79356 : p_builtin_type = temp_type;
79357 : }
79358 : #endif
79359 :
79360 10 : SgName name = temp_type->get_mangled();
79361 :
79362 : #if 0
79363 : printf ("Mangled type name for SgTypeChar16 = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
79364 : #endif
79365 :
79366 : // DQ (10/31/2016): Added assertion.
79367 10 : ROSE_ASSERT(get_globalTypeTable() != NULL);
79368 :
79369 10 : SgType* t = get_globalTypeTable()->lookup_type(name);
79370 :
79371 : #if 0
79372 : printf ("In SgTypeChar16::createType(): type from lookup_type = %p \n",t);
79373 : #endif
79374 :
79375 10 : if (t == NULL)
79376 : {
79377 10 : get_globalTypeTable()->insert_type(name,temp_type);
79378 : }
79379 : else
79380 : {
79381 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
79382 0 : if (t != temp_type)
79383 : {
79384 : #if 0
79385 : printf ("In SgTypeChar16::createType(): deleting temp_type = %p \n",temp_type);
79386 : #endif
79387 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
79388 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
79389 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
79390 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
79391 0 : delete temp_type;
79392 : #endif
79393 0 : temp_type = NULL;
79394 : #if 0
79395 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
79396 : if (optional_fortran_type_kind != NULL)
79397 : {
79398 : p_builtin_type = NULL;
79399 : }
79400 : #endif
79401 : }
79402 :
79403 : // Reuse this tempType variable so we can use the same code below.
79404 0 : temp_type = isSgTypeChar16(t);
79405 0 : ROSE_ASSERT(temp_type != NULL);
79406 : }
79407 :
79408 : #if 0
79409 : printf ("Leaving SgTypeChar16::createType(): temp_type = %p \n",temp_type);
79410 : #endif
79411 :
79412 10 : return temp_type;
79413 : }
79414 :
79415 :
79416 :
79417 : // End of memberFunctionString
79418 : // Start of memberFunctionString
79419 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
79420 :
79421 : #if 1
79422 : /*! Support for mangled names (for unparser)
79423 : There are two different cases of source code for the get_mangled member function
79424 : This one is used in all but the classes containing a base type
79425 : */
79426 : // SgName SgTypeChar16::get_mangled ( SgUnparse_Info & info )
79427 : SgName
79428 6649 : SgTypeChar16::get_mangled (void) const
79429 : {
79430 6649 : ROSE_ASSERT(this != NULL);
79431 :
79432 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
79433 : // CR (3/6/2020): Now type_kind is also used for Jovial.
79434 6649 : SgName name = "c16";
79435 6649 : if (get_type_kind() != NULL)
79436 : {
79437 : // name += get_type_kind()->get_mangled();
79438 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
79439 0 : SgValueExp* value = isSgValueExp(get_type_kind());
79440 0 : if (value != NULL)
79441 : {
79442 : // name += string("_") + StringUtility::numberToString(value->get_value());
79443 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
79444 : }
79445 : else
79446 : {
79447 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
79448 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
79449 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
79450 : // a different prefix for each type of named type. It come down to is there can be multiple
79451 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
79452 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
79453 : // I think the issue is that c16 is not defined for any of the SgNameType IR nodes.
79454 : #if 0
79455 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"c16");
79456 : #endif
79457 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
79458 : }
79459 : }
79460 :
79461 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
79462 : // REMOVE_ME please!
79463 6649 : if (isSgTypeFixed(this))
79464 : {
79465 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
79466 0 : if (fixed_type->get_scale() != NULL)
79467 : {
79468 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
79469 0 : if (value != NULL)
79470 : {
79471 0 : name += string("_") + value->get_constant_folded_value_as_string();
79472 : }
79473 : }
79474 0 : if (fixed_type->get_fraction() != NULL)
79475 : {
79476 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
79477 0 : if (value != NULL)
79478 : {
79479 0 : name += string("_") + value->get_constant_folded_value_as_string();
79480 : }
79481 : }
79482 : }
79483 :
79484 : #if 0
79485 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
79486 : #endif
79487 :
79488 6649 : return name;
79489 : }
79490 : #endif
79491 :
79492 :
79493 : // End of memberFunctionString
79494 :
79495 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
79496 :
79497 10 : SgTypeChar16* isSgTypeChar16 ( SgNode* inputDerivedClassPointer )
79498 : {
79499 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
79500 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
79501 : // So to fix this we return NULL directly when the input is NULL and avoid the
79502 : // dynamic_cast in this case. This is likely a performance improvement as well.
79503 : // return dynamic_cast<SgTypeChar16*>(inputDerivedClassPointer);
79504 : // Milind Chabbi (8/28/2013): isSgTypeChar16 uses table-driven castability instead of c++ default dynamic_cast
79505 : // this improves the running time performance by 10-20%.
79506 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeChar16*>(inputDerivedClassPointer);
79507 10 : return IS_SgTypeChar16_FAST_MACRO(inputDerivedClassPointer);
79508 : }
79509 :
79510 : // DQ (11/8/2003): Added version of functions taking const pointer
79511 0 : const SgTypeChar16* isSgTypeChar16 ( const SgNode* inputDerivedClassPointer )
79512 : {
79513 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
79514 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
79515 : // So to fix this we return NULL directly when the input is NULL and avoid the
79516 : // dynamic_cast in this case. This is likely a performance improvement as well.
79517 : // return dynamic_cast<const SgTypeChar16*>(inputDerivedClassPointer);
79518 : // Milind Chabbi (8/28/2013): isSgTypeChar16 uses table-driven castability instead of c++ default dynamic_cast
79519 : // this improves the running time performance by 10-20%.
79520 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeChar16*>(inputDerivedClassPointer);
79521 0 : return IS_SgTypeChar16_FAST_MACRO(inputDerivedClassPointer);
79522 : }
79523 :
79524 :
79525 :
79526 : /* #line 79527 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79527 :
79528 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
79529 :
79530 : /**
79531 : \brief Generated destructor
79532 :
79533 : This destructor is automatically generated (by ROSETTA). This destructor
79534 : only frees memory of data members associated with the parts of the current IR node which
79535 : are NOT traversed. Those data members that are part of a traversal can be freed using
79536 : a traversal (calling this destructor on all children in a post-order traversal). Such
79537 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
79538 :
79539 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
79540 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
79541 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
79542 :
79543 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
79544 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
79545 : pointers are not yet implemented to call delete on eash pointer in the container.
79546 : (This could be done by derivation from the STL containers to define containers that
79547 : automatically deleted their members.)
79548 :
79549 : */
79550 4 : SgTypeChar16::~SgTypeChar16 () {
79551 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
79552 :
79553 :
79554 :
79555 : }
79556 :
79557 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
79558 4 : }
79559 :
79560 :
79561 : /* #line 79562 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79562 :
79563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
79564 :
79565 : // Generated constructor
79566 10 : SgTypeChar16::SgTypeChar16 ( )
79567 10 : : SgType()
79568 : {
79569 : #ifdef DEBUG
79570 : // printf ("In SgTypeChar16::SgTypeChar16 () sage_class_name() = %s \n",sage_class_name());
79571 : #endif
79572 : #if 0
79573 : // debugging information!
79574 : printf ("In SgTypeChar16::SgTypeChar16 (): this = %p = %s \n",this,this->class_name().c_str());
79575 : #endif
79576 :
79577 :
79578 :
79579 : #if 0
79580 : // DQ (7/30/2014): Call a virtual function.
79581 : std::string s = this->class_name();
79582 : #endif
79583 :
79584 : // Test the variant virtual function
79585 : // assert(T_CHAR16 == variant());
79586 10 : assert(T_CHAR16 == this->variant());
79587 10 : ROSE_ASSERT(T_CHAR16 == (int)(this->variantT()));
79588 10 : post_construction_initialization();
79589 :
79590 : // Test the isSgTypeChar16() function since it has been problematic
79591 10 : assert(isSgTypeChar16(this) != NULL);
79592 10 : }
79593 :
79594 : // Generated constructor (all data members)
79595 :
79596 : /* #line 79597 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79597 :
79598 :
79599 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
79600 :
79601 :
79602 : // ********************************************************
79603 : // member functions common across all array grammar objects
79604 : // ********************************************************
79605 :
79606 :
79607 :
79608 : /* #line 79609 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79609 :
79610 :
79611 :
79612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
79613 :
79614 : // ********************************************************
79615 : // member functions specific to each node in the grammar
79616 : // ********************************************************
79617 :
79618 :
79619 : /* #line 79620 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79620 :
79621 : // Start of memberFunctionString
79622 :
79623 :
79624 : // End of memberFunctionString
79625 : // Start of memberFunctionString
79626 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
79627 :
79628 : // *** COMMON CODE SECTION BEGINS HERE ***
79629 :
79630 : #if 0
79631 : int
79632 : SgTypeChar32::getVariant() const
79633 : {
79634 : // This function is used in ROSE while "variant()" is used in SAGE
79635 : assert(this != NULL);
79636 : return variant();
79637 : }
79638 : #endif
79639 :
79640 : // This function is used in ROSE in treeTraversal code
79641 : // eventually replaces getVariant() and variant()
79642 : // though after variant() has been removed for a while we will
79643 : // want to change the name of variantT() back to variant()
79644 : // (since the "T" was ment to stand for temporary).
79645 : // When this happens the variantT() will be depricated.
79646 : VariantT
79647 2686570 : SgTypeChar32::variantT() const
79648 : {
79649 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
79650 2686570 : ROSE_ASSERT(this != NULL);
79651 2686570 : return V_SgTypeChar32;
79652 : }
79653 :
79654 : #if 0
79655 : int
79656 : SgTypeChar32::variant() const
79657 : {
79658 : // This function is used in SAGE
79659 : ROSE_ASSERT(this != NULL);
79660 : return T_CHAR32;
79661 : }
79662 : #endif
79663 :
79664 : ROSE_DLL_API const char*
79665 0 : SgTypeChar32::sage_class_name() const
79666 : {
79667 0 : ROSE_ASSERT(this != NULL);
79668 0 : return "SgTypeChar32";
79669 : }
79670 :
79671 : std::string
79672 66 : SgTypeChar32::class_name() const
79673 : {
79674 66 : ROSE_ASSERT(this != NULL);
79675 66 : return "SgTypeChar32";
79676 : }
79677 :
79678 : // DQ (11/26/2005): Support for visitor pattern mechanims
79679 : // (inferior to ROSE traversal mechanism, experimental).
79680 : void
79681 137 : SgTypeChar32::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
79682 : {
79683 137 : ROSE_ASSERT(this != NULL);
79684 137 : visitor.visit(this);
79685 137 : }
79686 :
79687 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
79688 0 : void SgTypeChar32::accept (ROSE_VisitorPattern & visitor) {
79689 0 : ROSE_ASSERT(this != NULL);
79690 0 : visitor.visit(this);
79691 0 : }
79692 :
79693 : SgTypeChar32*
79694 0 : SgTypeChar32::addRegExpAttribute(std::string s, AstRegExAttribute* a)
79695 : {
79696 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
79697 : // This function is currently only supported for the AST used the represent Binary executables.
79698 : if (0 /* isSgAsmNode(this) != NULL */)
79699 : {
79700 : // Support for regex specification.
79701 : std::string prefixCode = "REGEX:";
79702 : addNewAttribute(prefixCode + s,a);
79703 : }
79704 : #endif
79705 :
79706 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
79707 0 : return this;
79708 : }
79709 :
79710 : // *** COMMON CODE SECTION ENDS HERE ***
79711 :
79712 :
79713 : // End of memberFunctionString
79714 : // Start of memberFunctionString
79715 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
79716 :
79717 :
79718 : #if 0
79719 : //! Error checking support
79720 : /*! Verifies the following:
79721 : - working getVariant() member function
79722 : - calls base class's error() member function
79723 : Every class has one of these functions.
79724 : */
79725 : bool
79726 : SgTypeChar32::error()
79727 : {
79728 : // Put error checking here
79729 :
79730 : ROSE_ASSERT (this != NULL);
79731 : if (getVariant() != T_CHAR32)
79732 : {
79733 : printf ("Error in SgTypeChar32::error(): SgTypeChar32 object has a %s variant \n",
79734 : Cxx_GrammarTerminalNames[getVariant()].name);
79735 : // printf ("Error in SgTypeChar32::error() \n");
79736 : ROSE_ABORT();
79737 : }
79738 :
79739 : ROSE_ASSERT (getVariant() == T_CHAR32);
79740 : return SgType::error();
79741 : }
79742 : #endif
79743 :
79744 :
79745 :
79746 : // End of memberFunctionString
79747 : // Start of memberFunctionString
79748 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
79749 :
79750 :
79751 : // DQ (1/31/2006): Modified to build all types in the memory pools
79752 : // SgTypeChar32 SgTypeChar32::builtin_type;
79753 : // SgTypeChar32* SgTypeChar32::builtin_type = new SgTypeChar32();
79754 : SgTypeChar32* SgTypeChar32::p_builtin_type = NULL;
79755 :
79756 :
79757 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
79758 : // SgTypeChar32* SgTypeChar32::createType(void)
79759 : SgTypeChar32*
79760 10 : SgTypeChar32::createType(SgExpression* optional_fortran_type_kind)
79761 : {
79762 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
79763 : // is not called (likely because static initialization is compiler dependent).
79764 : // DQ (1/31/2006): Modified to build all types in the memory pools
79765 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
79766 : // return &builtin_type;
79767 :
79768 : #if 0
79769 : printf ("In SgTypeChar32::createType() (COMMON_CREATE_TYPE) \n");
79770 : #endif
79771 :
79772 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
79773 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
79774 :
79775 10 : SgTypeChar32* temp_type = new SgTypeChar32();
79776 :
79777 : #if 0
79778 : printf ("In SgTypeChar32::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
79779 : #endif
79780 :
79781 : // DQ (10/31/2016): Added assertion.
79782 10 : ROSE_ASSERT(temp_type != NULL);
79783 :
79784 10 : if (optional_fortran_type_kind != NULL)
79785 : {
79786 : // DQ (10/31/2016): Added assertion.
79787 0 : ROSE_ASSERT(temp_type != NULL);
79788 :
79789 0 : temp_type->set_type_kind(optional_fortran_type_kind);
79790 : }
79791 : #if 0
79792 : else
79793 : {
79794 : // Let p_builtin_type refer to the unadorned type (no type kind).
79795 : p_builtin_type = temp_type;
79796 : }
79797 : #endif
79798 :
79799 10 : SgName name = temp_type->get_mangled();
79800 :
79801 : #if 0
79802 : printf ("Mangled type name for SgTypeChar32 = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
79803 : #endif
79804 :
79805 : // DQ (10/31/2016): Added assertion.
79806 10 : ROSE_ASSERT(get_globalTypeTable() != NULL);
79807 :
79808 10 : SgType* t = get_globalTypeTable()->lookup_type(name);
79809 :
79810 : #if 0
79811 : printf ("In SgTypeChar32::createType(): type from lookup_type = %p \n",t);
79812 : #endif
79813 :
79814 10 : if (t == NULL)
79815 : {
79816 10 : get_globalTypeTable()->insert_type(name,temp_type);
79817 : }
79818 : else
79819 : {
79820 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
79821 0 : if (t != temp_type)
79822 : {
79823 : #if 0
79824 : printf ("In SgTypeChar32::createType(): deleting temp_type = %p \n",temp_type);
79825 : #endif
79826 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
79827 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
79828 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
79829 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
79830 0 : delete temp_type;
79831 : #endif
79832 0 : temp_type = NULL;
79833 : #if 0
79834 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
79835 : if (optional_fortran_type_kind != NULL)
79836 : {
79837 : p_builtin_type = NULL;
79838 : }
79839 : #endif
79840 : }
79841 :
79842 : // Reuse this tempType variable so we can use the same code below.
79843 0 : temp_type = isSgTypeChar32(t);
79844 0 : ROSE_ASSERT(temp_type != NULL);
79845 : }
79846 :
79847 : #if 0
79848 : printf ("Leaving SgTypeChar32::createType(): temp_type = %p \n",temp_type);
79849 : #endif
79850 :
79851 10 : return temp_type;
79852 : }
79853 :
79854 :
79855 :
79856 : // End of memberFunctionString
79857 : // Start of memberFunctionString
79858 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
79859 :
79860 : #if 1
79861 : /*! Support for mangled names (for unparser)
79862 : There are two different cases of source code for the get_mangled member function
79863 : This one is used in all but the classes containing a base type
79864 : */
79865 : // SgName SgTypeChar32::get_mangled ( SgUnparse_Info & info )
79866 : SgName
79867 6649 : SgTypeChar32::get_mangled (void) const
79868 : {
79869 6649 : ROSE_ASSERT(this != NULL);
79870 :
79871 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
79872 : // CR (3/6/2020): Now type_kind is also used for Jovial.
79873 6649 : SgName name = "c32";
79874 6649 : if (get_type_kind() != NULL)
79875 : {
79876 : // name += get_type_kind()->get_mangled();
79877 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
79878 0 : SgValueExp* value = isSgValueExp(get_type_kind());
79879 0 : if (value != NULL)
79880 : {
79881 : // name += string("_") + StringUtility::numberToString(value->get_value());
79882 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
79883 : }
79884 : else
79885 : {
79886 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
79887 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
79888 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
79889 : // a different prefix for each type of named type. It come down to is there can be multiple
79890 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
79891 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
79892 : // I think the issue is that c32 is not defined for any of the SgNameType IR nodes.
79893 : #if 0
79894 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"c32");
79895 : #endif
79896 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
79897 : }
79898 : }
79899 :
79900 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
79901 : // REMOVE_ME please!
79902 6649 : if (isSgTypeFixed(this))
79903 : {
79904 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
79905 0 : if (fixed_type->get_scale() != NULL)
79906 : {
79907 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
79908 0 : if (value != NULL)
79909 : {
79910 0 : name += string("_") + value->get_constant_folded_value_as_string();
79911 : }
79912 : }
79913 0 : if (fixed_type->get_fraction() != NULL)
79914 : {
79915 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
79916 0 : if (value != NULL)
79917 : {
79918 0 : name += string("_") + value->get_constant_folded_value_as_string();
79919 : }
79920 : }
79921 : }
79922 :
79923 : #if 0
79924 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
79925 : #endif
79926 :
79927 6649 : return name;
79928 : }
79929 : #endif
79930 :
79931 :
79932 : // End of memberFunctionString
79933 :
79934 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
79935 :
79936 10 : SgTypeChar32* isSgTypeChar32 ( SgNode* inputDerivedClassPointer )
79937 : {
79938 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
79939 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
79940 : // So to fix this we return NULL directly when the input is NULL and avoid the
79941 : // dynamic_cast in this case. This is likely a performance improvement as well.
79942 : // return dynamic_cast<SgTypeChar32*>(inputDerivedClassPointer);
79943 : // Milind Chabbi (8/28/2013): isSgTypeChar32 uses table-driven castability instead of c++ default dynamic_cast
79944 : // this improves the running time performance by 10-20%.
79945 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeChar32*>(inputDerivedClassPointer);
79946 10 : return IS_SgTypeChar32_FAST_MACRO(inputDerivedClassPointer);
79947 : }
79948 :
79949 : // DQ (11/8/2003): Added version of functions taking const pointer
79950 0 : const SgTypeChar32* isSgTypeChar32 ( const SgNode* inputDerivedClassPointer )
79951 : {
79952 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
79953 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
79954 : // So to fix this we return NULL directly when the input is NULL and avoid the
79955 : // dynamic_cast in this case. This is likely a performance improvement as well.
79956 : // return dynamic_cast<const SgTypeChar32*>(inputDerivedClassPointer);
79957 : // Milind Chabbi (8/28/2013): isSgTypeChar32 uses table-driven castability instead of c++ default dynamic_cast
79958 : // this improves the running time performance by 10-20%.
79959 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeChar32*>(inputDerivedClassPointer);
79960 0 : return IS_SgTypeChar32_FAST_MACRO(inputDerivedClassPointer);
79961 : }
79962 :
79963 :
79964 :
79965 : /* #line 79966 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
79966 :
79967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
79968 :
79969 : /**
79970 : \brief Generated destructor
79971 :
79972 : This destructor is automatically generated (by ROSETTA). This destructor
79973 : only frees memory of data members associated with the parts of the current IR node which
79974 : are NOT traversed. Those data members that are part of a traversal can be freed using
79975 : a traversal (calling this destructor on all children in a post-order traversal). Such
79976 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
79977 :
79978 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
79979 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
79980 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
79981 :
79982 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
79983 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
79984 : pointers are not yet implemented to call delete on eash pointer in the container.
79985 : (This could be done by derivation from the STL containers to define containers that
79986 : automatically deleted their members.)
79987 :
79988 : */
79989 4 : SgTypeChar32::~SgTypeChar32 () {
79990 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
79991 :
79992 :
79993 :
79994 : }
79995 :
79996 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
79997 4 : }
79998 :
79999 :
80000 : /* #line 80001 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80001 :
80002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
80003 :
80004 : // Generated constructor
80005 10 : SgTypeChar32::SgTypeChar32 ( )
80006 10 : : SgType()
80007 : {
80008 : #ifdef DEBUG
80009 : // printf ("In SgTypeChar32::SgTypeChar32 () sage_class_name() = %s \n",sage_class_name());
80010 : #endif
80011 : #if 0
80012 : // debugging information!
80013 : printf ("In SgTypeChar32::SgTypeChar32 (): this = %p = %s \n",this,this->class_name().c_str());
80014 : #endif
80015 :
80016 :
80017 :
80018 : #if 0
80019 : // DQ (7/30/2014): Call a virtual function.
80020 : std::string s = this->class_name();
80021 : #endif
80022 :
80023 : // Test the variant virtual function
80024 : // assert(T_CHAR32 == variant());
80025 10 : assert(T_CHAR32 == this->variant());
80026 10 : ROSE_ASSERT(T_CHAR32 == (int)(this->variantT()));
80027 10 : post_construction_initialization();
80028 :
80029 : // Test the isSgTypeChar32() function since it has been problematic
80030 10 : assert(isSgTypeChar32(this) != NULL);
80031 10 : }
80032 :
80033 : // Generated constructor (all data members)
80034 :
80035 : /* #line 80036 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80036 :
80037 :
80038 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
80039 :
80040 :
80041 : // ********************************************************
80042 : // member functions common across all array grammar objects
80043 : // ********************************************************
80044 :
80045 :
80046 :
80047 : /* #line 80048 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80048 :
80049 :
80050 :
80051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
80052 :
80053 : // ********************************************************
80054 : // member functions specific to each node in the grammar
80055 : // ********************************************************
80056 :
80057 :
80058 : /* #line 80059 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80059 :
80060 : // Start of memberFunctionString
80061 :
80062 :
80063 : // End of memberFunctionString
80064 : // Start of memberFunctionString
80065 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
80066 :
80067 : // *** COMMON CODE SECTION BEGINS HERE ***
80068 :
80069 : #if 0
80070 : int
80071 : SgTypeFloat128::getVariant() const
80072 : {
80073 : // This function is used in ROSE while "variant()" is used in SAGE
80074 : assert(this != NULL);
80075 : return variant();
80076 : }
80077 : #endif
80078 :
80079 : // This function is used in ROSE in treeTraversal code
80080 : // eventually replaces getVariant() and variant()
80081 : // though after variant() has been removed for a while we will
80082 : // want to change the name of variantT() back to variant()
80083 : // (since the "T" was ment to stand for temporary).
80084 : // When this happens the variantT() will be depricated.
80085 : VariantT
80086 1780850 : SgTypeFloat128::variantT() const
80087 : {
80088 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
80089 1780850 : ROSE_ASSERT(this != NULL);
80090 1780850 : return V_SgTypeFloat128;
80091 : }
80092 :
80093 : #if 0
80094 : int
80095 : SgTypeFloat128::variant() const
80096 : {
80097 : // This function is used in SAGE
80098 : ROSE_ASSERT(this != NULL);
80099 : return T_FLOAT128;
80100 : }
80101 : #endif
80102 :
80103 : ROSE_DLL_API const char*
80104 0 : SgTypeFloat128::sage_class_name() const
80105 : {
80106 0 : ROSE_ASSERT(this != NULL);
80107 0 : return "SgTypeFloat128";
80108 : }
80109 :
80110 : std::string
80111 10 : SgTypeFloat128::class_name() const
80112 : {
80113 10 : ROSE_ASSERT(this != NULL);
80114 10 : return "SgTypeFloat128";
80115 : }
80116 :
80117 : // DQ (11/26/2005): Support for visitor pattern mechanims
80118 : // (inferior to ROSE traversal mechanism, experimental).
80119 : void
80120 137 : SgTypeFloat128::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
80121 : {
80122 137 : ROSE_ASSERT(this != NULL);
80123 137 : visitor.visit(this);
80124 137 : }
80125 :
80126 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
80127 0 : void SgTypeFloat128::accept (ROSE_VisitorPattern & visitor) {
80128 0 : ROSE_ASSERT(this != NULL);
80129 0 : visitor.visit(this);
80130 0 : }
80131 :
80132 : SgTypeFloat128*
80133 0 : SgTypeFloat128::addRegExpAttribute(std::string s, AstRegExAttribute* a)
80134 : {
80135 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
80136 : // This function is currently only supported for the AST used the represent Binary executables.
80137 : if (0 /* isSgAsmNode(this) != NULL */)
80138 : {
80139 : // Support for regex specification.
80140 : std::string prefixCode = "REGEX:";
80141 : addNewAttribute(prefixCode + s,a);
80142 : }
80143 : #endif
80144 :
80145 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
80146 0 : return this;
80147 : }
80148 :
80149 : // *** COMMON CODE SECTION ENDS HERE ***
80150 :
80151 :
80152 : // End of memberFunctionString
80153 : // Start of memberFunctionString
80154 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
80155 :
80156 :
80157 : #if 0
80158 : //! Error checking support
80159 : /*! Verifies the following:
80160 : - working getVariant() member function
80161 : - calls base class's error() member function
80162 : Every class has one of these functions.
80163 : */
80164 : bool
80165 : SgTypeFloat128::error()
80166 : {
80167 : // Put error checking here
80168 :
80169 : ROSE_ASSERT (this != NULL);
80170 : if (getVariant() != T_FLOAT128)
80171 : {
80172 : printf ("Error in SgTypeFloat128::error(): SgTypeFloat128 object has a %s variant \n",
80173 : Cxx_GrammarTerminalNames[getVariant()].name);
80174 : // printf ("Error in SgTypeFloat128::error() \n");
80175 : ROSE_ABORT();
80176 : }
80177 :
80178 : ROSE_ASSERT (getVariant() == T_FLOAT128);
80179 : return SgType::error();
80180 : }
80181 : #endif
80182 :
80183 :
80184 :
80185 : // End of memberFunctionString
80186 : // Start of memberFunctionString
80187 : /* #line 6288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
80188 :
80189 :
80190 : // DQ (1/31/2006): Modified to build all types in the memory pools
80191 : // SgTypeFloat128 SgTypeFloat128::builtin_type;
80192 : // SgTypeFloat128* SgTypeFloat128::builtin_type = new SgTypeFloat128();
80193 : SgTypeFloat128* SgTypeFloat128::p_builtin_type = NULL;
80194 :
80195 :
80196 : // DQ (10/4/2010): Added support for optional Fotran type_kind specification.
80197 : // SgTypeFloat128* SgTypeFloat128::createType(void)
80198 : SgTypeFloat128*
80199 26 : SgTypeFloat128::createType(SgExpression* optional_fortran_type_kind)
80200 : {
80201 : // DQ (12/22/2005): Jochen thinks that we need this because the SgNode constructor
80202 : // is not called (likely because static initialization is compiler dependent).
80203 : // DQ (1/31/2006): Modified to build all types in the memory pools
80204 : // builtin_type.p_freepointer = AST_FileIO::IS_VALID_POINTER();
80205 : // return &builtin_type;
80206 :
80207 : #if 0
80208 : printf ("In SgTypeFloat128::createType() (COMMON_CREATE_TYPE) \n");
80209 : #endif
80210 :
80211 : // DQ (10/4/2010): New version of code to support multiple kinds of bool as required for the Fortran type_kind support within ROSE.
80212 : // Note that this implementation does not use p_builtin_type, since with the global type table it is not required.
80213 :
80214 26 : SgTypeFloat128* temp_type = new SgTypeFloat128();
80215 :
80216 : #if 0
80217 : printf ("In SgTypeFloat128::createType() (COMMON_CREATE_TYPE): temp_type = %p \n",temp_type);
80218 : #endif
80219 :
80220 : // DQ (10/31/2016): Added assertion.
80221 26 : ROSE_ASSERT(temp_type != NULL);
80222 :
80223 26 : if (optional_fortran_type_kind != NULL)
80224 : {
80225 : // DQ (10/31/2016): Added assertion.
80226 0 : ROSE_ASSERT(temp_type != NULL);
80227 :
80228 0 : temp_type->set_type_kind(optional_fortran_type_kind);
80229 : }
80230 : #if 0
80231 : else
80232 : {
80233 : // Let p_builtin_type refer to the unadorned type (no type kind).
80234 : p_builtin_type = temp_type;
80235 : }
80236 : #endif
80237 :
80238 26 : SgName name = temp_type->get_mangled();
80239 :
80240 : #if 0
80241 : printf ("Mangled type name for SgTypeFloat128 = %s get_globalTypeTable()->get_type_table()->size() = %d \n",name.str(),get_globalTypeTable()->get_type_table()->size());
80242 : #endif
80243 :
80244 : // DQ (10/31/2016): Added assertion.
80245 26 : ROSE_ASSERT(get_globalTypeTable() != NULL);
80246 :
80247 26 : SgType* t = get_globalTypeTable()->lookup_type(name);
80248 :
80249 : #if 0
80250 : printf ("In SgTypeFloat128::createType(): type from lookup_type = %p \n",t);
80251 : #endif
80252 :
80253 26 : if (t == NULL)
80254 : {
80255 13 : get_globalTypeTable()->insert_type(name,temp_type);
80256 : }
80257 : else
80258 : {
80259 : // If t is the same as p_builtin_type then we can't delete it...(only comes up in merging AST's read from files).
80260 13 : if (t != temp_type)
80261 : {
80262 : #if 0
80263 : printf ("In SgTypeFloat128::createType(): deleting temp_type = %p \n",temp_type);
80264 : #endif
80265 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
80266 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
80267 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
80268 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
80269 13 : delete temp_type;
80270 : #endif
80271 13 : temp_type = NULL;
80272 : #if 0
80273 : // Should we clear the p_builtin_type? I think we have to, but it will be overwritten below.
80274 : if (optional_fortran_type_kind != NULL)
80275 : {
80276 : p_builtin_type = NULL;
80277 : }
80278 : #endif
80279 : }
80280 :
80281 : // Reuse this tempType variable so we can use the same code below.
80282 13 : temp_type = isSgTypeFloat128(t);
80283 13 : ROSE_ASSERT(temp_type != NULL);
80284 : }
80285 :
80286 : #if 0
80287 : printf ("Leaving SgTypeFloat128::createType(): temp_type = %p \n",temp_type);
80288 : #endif
80289 :
80290 26 : return temp_type;
80291 : }
80292 :
80293 :
80294 :
80295 : // End of memberFunctionString
80296 : // Start of memberFunctionString
80297 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
80298 :
80299 : #if 1
80300 : /*! Support for mangled names (for unparser)
80301 : There are two different cases of source code for the get_mangled member function
80302 : This one is used in all but the classes containing a base type
80303 : */
80304 : // SgName SgTypeFloat128::get_mangled ( SgUnparse_Info & info )
80305 : SgName
80306 40 : SgTypeFloat128::get_mangled (void) const
80307 : {
80308 40 : ROSE_ASSERT(this != NULL);
80309 :
80310 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
80311 : // CR (3/6/2020): Now type_kind is also used for Jovial.
80312 40 : SgName name = "q";
80313 40 : if (get_type_kind() != NULL)
80314 : {
80315 : // name += get_type_kind()->get_mangled();
80316 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
80317 0 : SgValueExp* value = isSgValueExp(get_type_kind());
80318 0 : if (value != NULL)
80319 : {
80320 : // name += string("_") + StringUtility::numberToString(value->get_value());
80321 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
80322 : }
80323 : else
80324 : {
80325 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
80326 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
80327 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
80328 : // a different prefix for each type of named type. It come down to is there can be multiple
80329 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
80330 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
80331 : // I think the issue is that q is not defined for any of the SgNameType IR nodes.
80332 : #if 0
80333 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"q");
80334 : #endif
80335 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
80336 : }
80337 : }
80338 :
80339 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
80340 : // REMOVE_ME please!
80341 40 : if (isSgTypeFixed(this))
80342 : {
80343 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
80344 0 : if (fixed_type->get_scale() != NULL)
80345 : {
80346 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
80347 0 : if (value != NULL)
80348 : {
80349 0 : name += string("_") + value->get_constant_folded_value_as_string();
80350 : }
80351 : }
80352 0 : if (fixed_type->get_fraction() != NULL)
80353 : {
80354 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
80355 0 : if (value != NULL)
80356 : {
80357 0 : name += string("_") + value->get_constant_folded_value_as_string();
80358 : }
80359 : }
80360 : }
80361 :
80362 : #if 0
80363 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
80364 : #endif
80365 :
80366 40 : return name;
80367 : }
80368 : #endif
80369 :
80370 :
80371 : // End of memberFunctionString
80372 :
80373 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
80374 :
80375 39 : SgTypeFloat128* isSgTypeFloat128 ( SgNode* inputDerivedClassPointer )
80376 : {
80377 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
80378 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
80379 : // So to fix this we return NULL directly when the input is NULL and avoid the
80380 : // dynamic_cast in this case. This is likely a performance improvement as well.
80381 : // return dynamic_cast<SgTypeFloat128*>(inputDerivedClassPointer);
80382 : // Milind Chabbi (8/28/2013): isSgTypeFloat128 uses table-driven castability instead of c++ default dynamic_cast
80383 : // this improves the running time performance by 10-20%.
80384 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeFloat128*>(inputDerivedClassPointer);
80385 39 : return IS_SgTypeFloat128_FAST_MACRO(inputDerivedClassPointer);
80386 : }
80387 :
80388 : // DQ (11/8/2003): Added version of functions taking const pointer
80389 0 : const SgTypeFloat128* isSgTypeFloat128 ( const SgNode* inputDerivedClassPointer )
80390 : {
80391 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
80392 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
80393 : // So to fix this we return NULL directly when the input is NULL and avoid the
80394 : // dynamic_cast in this case. This is likely a performance improvement as well.
80395 : // return dynamic_cast<const SgTypeFloat128*>(inputDerivedClassPointer);
80396 : // Milind Chabbi (8/28/2013): isSgTypeFloat128 uses table-driven castability instead of c++ default dynamic_cast
80397 : // this improves the running time performance by 10-20%.
80398 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeFloat128*>(inputDerivedClassPointer);
80399 0 : return IS_SgTypeFloat128_FAST_MACRO(inputDerivedClassPointer);
80400 : }
80401 :
80402 :
80403 :
80404 : /* #line 80405 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80405 :
80406 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
80407 :
80408 : /**
80409 : \brief Generated destructor
80410 :
80411 : This destructor is automatically generated (by ROSETTA). This destructor
80412 : only frees memory of data members associated with the parts of the current IR node which
80413 : are NOT traversed. Those data members that are part of a traversal can be freed using
80414 : a traversal (calling this destructor on all children in a post-order traversal). Such
80415 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
80416 :
80417 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
80418 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
80419 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
80420 :
80421 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
80422 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
80423 : pointers are not yet implemented to call delete on eash pointer in the container.
80424 : (This could be done by derivation from the STL containers to define containers that
80425 : automatically deleted their members.)
80426 :
80427 : */
80428 30 : SgTypeFloat128::~SgTypeFloat128 () {
80429 15 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
80430 :
80431 :
80432 :
80433 : }
80434 :
80435 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
80436 30 : }
80437 :
80438 :
80439 : /* #line 80440 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80440 :
80441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
80442 :
80443 : // Generated constructor
80444 26 : SgTypeFloat128::SgTypeFloat128 ( )
80445 26 : : SgType()
80446 : {
80447 : #ifdef DEBUG
80448 : // printf ("In SgTypeFloat128::SgTypeFloat128 () sage_class_name() = %s \n",sage_class_name());
80449 : #endif
80450 : #if 0
80451 : // debugging information!
80452 : printf ("In SgTypeFloat128::SgTypeFloat128 (): this = %p = %s \n",this,this->class_name().c_str());
80453 : #endif
80454 :
80455 :
80456 :
80457 : #if 0
80458 : // DQ (7/30/2014): Call a virtual function.
80459 : std::string s = this->class_name();
80460 : #endif
80461 :
80462 : // Test the variant virtual function
80463 : // assert(T_FLOAT128 == variant());
80464 26 : assert(T_FLOAT128 == this->variant());
80465 26 : ROSE_ASSERT(T_FLOAT128 == (int)(this->variantT()));
80466 26 : post_construction_initialization();
80467 :
80468 : // Test the isSgTypeFloat128() function since it has been problematic
80469 26 : assert(isSgTypeFloat128(this) != NULL);
80470 26 : }
80471 :
80472 : // Generated constructor (all data members)
80473 :
80474 : /* #line 80475 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80475 :
80476 :
80477 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
80478 :
80479 :
80480 : // ********************************************************
80481 : // member functions common across all array grammar objects
80482 : // ********************************************************
80483 :
80484 :
80485 :
80486 : /* #line 80487 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80487 :
80488 :
80489 :
80490 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
80491 :
80492 : // ********************************************************
80493 : // member functions specific to each node in the grammar
80494 : // ********************************************************
80495 :
80496 :
80497 : /* #line 80498 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80498 :
80499 : // Start of memberFunctionString
80500 : /* #line 8107 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
80501 :
80502 :
80503 : SgTypeFixed*
80504 0 : SgTypeFixed::createType ( SgExpression* scale, SgExpression* fraction, SgExpression* optional_fortran_type_kind )
80505 : {
80506 : // There is no size (equivalent to Fortran kind) parameter for Jovial fixed type
80507 0 : ROSE_ASSERT(optional_fortran_type_kind == NULL);
80508 :
80509 0 : SgTypeFixed* return_type = new SgTypeFixed(scale, fraction);
80510 0 : ROSE_ASSERT(return_type != NULL);
80511 :
80512 0 : SgName name = return_type->get_mangled();
80513 :
80514 : // Only look for pointers to type in the global type table.
80515 0 : SgType* t = get_globalTypeTable()->lookup_type(name);
80516 0 : if (t == NULL)
80517 : {
80518 0 : get_globalTypeTable()->insert_type(name,return_type);
80519 : }
80520 : else
80521 : {
80522 : // If it is already present in the type table then delete the type (so that it will remain unique).
80523 : #if ALLOW_DELETE_OF_EXPLORATORY_NODE
80524 : // DQ (10/26/2016): Suppress the delete to test mergeTest_04 behavior.
80525 : // It might be that in the memory pool traversal we can't be allocating and deallocating IR nodes that we might be traversing.
80526 : // This is now fixed by making a copy of the nodes to be traversed with the visit function before calling the visit function on those IR nodes.
80527 0 : ROSE_ASSERT(t != return_type);
80528 0 : delete return_type;
80529 : #endif
80530 0 : return_type = isSgTypeFixed(t);
80531 : }
80532 :
80533 0 : return return_type;
80534 : }
80535 :
80536 :
80537 :
80538 : // End of memberFunctionString
80539 : // Start of memberFunctionString
80540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
80541 :
80542 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
80543 :
80544 : SgExpression*
80545 0 : SgTypeFixed::get_scale () const
80546 : {
80547 0 : ROSE_ASSERT (this != NULL);
80548 :
80549 : #if 0
80550 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
80551 : // used to trigger marking transformations for the token-based unparsing.
80552 : printf ("SgTypeFixed::get_scale = %p = %s \n",this,this->class_name().c_str());
80553 : #endif
80554 :
80555 0 : return p_scale;
80556 : }
80557 :
80558 : void
80559 0 : SgTypeFixed::set_scale ( SgExpression* scale )
80560 : {
80561 0 : ROSE_ASSERT (this != NULL);
80562 :
80563 : #if 0
80564 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
80565 : // used to trigger marking transformations for the token-based unparsing.
80566 : printf ("SgTypeFixed::set_scale = %p = %s \n",this,this->class_name().c_str());
80567 : #endif
80568 :
80569 0 : set_isModified(true);
80570 :
80571 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
80572 : if (p_scale != NULL && scale != NULL && p_scale != scale)
80573 : {
80574 : printf ("Warning: scale = %p overwriting valid pointer p_scale = %p \n",scale,p_scale);
80575 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
80576 : printf ("Error fails assertion (p_scale != NULL && scale != NULL && p_scale != scale) is false\n");
80577 : ROSE_ASSERT(false);
80578 : #endif
80579 : }
80580 : #endif
80581 0 : p_scale = scale;
80582 0 : }
80583 :
80584 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
80585 :
80586 :
80587 : // End of memberFunctionString
80588 : // Start of memberFunctionString
80589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
80590 :
80591 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
80592 :
80593 : SgExpression*
80594 0 : SgTypeFixed::get_fraction () const
80595 : {
80596 0 : ROSE_ASSERT (this != NULL);
80597 :
80598 : #if 0
80599 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
80600 : // used to trigger marking transformations for the token-based unparsing.
80601 : printf ("SgTypeFixed::get_fraction = %p = %s \n",this,this->class_name().c_str());
80602 : #endif
80603 :
80604 0 : return p_fraction;
80605 : }
80606 :
80607 : void
80608 0 : SgTypeFixed::set_fraction ( SgExpression* fraction )
80609 : {
80610 0 : ROSE_ASSERT (this != NULL);
80611 :
80612 : #if 0
80613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
80614 : // used to trigger marking transformations for the token-based unparsing.
80615 : printf ("SgTypeFixed::set_fraction = %p = %s \n",this,this->class_name().c_str());
80616 : #endif
80617 :
80618 0 : set_isModified(true);
80619 :
80620 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
80621 : if (p_fraction != NULL && fraction != NULL && p_fraction != fraction)
80622 : {
80623 : printf ("Warning: fraction = %p overwriting valid pointer p_fraction = %p \n",fraction,p_fraction);
80624 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
80625 : printf ("Error fails assertion (p_fraction != NULL && fraction != NULL && p_fraction != fraction) is false\n");
80626 : ROSE_ASSERT(false);
80627 : #endif
80628 : }
80629 : #endif
80630 0 : p_fraction = fraction;
80631 0 : }
80632 :
80633 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
80634 :
80635 :
80636 : // End of memberFunctionString
80637 : // Start of memberFunctionString
80638 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
80639 :
80640 : // *** COMMON CODE SECTION BEGINS HERE ***
80641 :
80642 : #if 0
80643 : int
80644 : SgTypeFixed::getVariant() const
80645 : {
80646 : // This function is used in ROSE while "variant()" is used in SAGE
80647 : assert(this != NULL);
80648 : return variant();
80649 : }
80650 : #endif
80651 :
80652 : // This function is used in ROSE in treeTraversal code
80653 : // eventually replaces getVariant() and variant()
80654 : // though after variant() has been removed for a while we will
80655 : // want to change the name of variantT() back to variant()
80656 : // (since the "T" was ment to stand for temporary).
80657 : // When this happens the variantT() will be depricated.
80658 : VariantT
80659 0 : SgTypeFixed::variantT() const
80660 : {
80661 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
80662 0 : ROSE_ASSERT(this != NULL);
80663 0 : return V_SgTypeFixed;
80664 : }
80665 :
80666 : #if 0
80667 : int
80668 : SgTypeFixed::variant() const
80669 : {
80670 : // This function is used in SAGE
80671 : ROSE_ASSERT(this != NULL);
80672 : return T_FIXED;
80673 : }
80674 : #endif
80675 :
80676 : ROSE_DLL_API const char*
80677 0 : SgTypeFixed::sage_class_name() const
80678 : {
80679 0 : ROSE_ASSERT(this != NULL);
80680 0 : return "SgTypeFixed";
80681 : }
80682 :
80683 : std::string
80684 0 : SgTypeFixed::class_name() const
80685 : {
80686 0 : ROSE_ASSERT(this != NULL);
80687 0 : return "SgTypeFixed";
80688 : }
80689 :
80690 : // DQ (11/26/2005): Support for visitor pattern mechanims
80691 : // (inferior to ROSE traversal mechanism, experimental).
80692 : void
80693 0 : SgTypeFixed::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
80694 : {
80695 0 : ROSE_ASSERT(this != NULL);
80696 0 : visitor.visit(this);
80697 0 : }
80698 :
80699 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
80700 0 : void SgTypeFixed::accept (ROSE_VisitorPattern & visitor) {
80701 0 : ROSE_ASSERT(this != NULL);
80702 0 : visitor.visit(this);
80703 0 : }
80704 :
80705 : SgTypeFixed*
80706 0 : SgTypeFixed::addRegExpAttribute(std::string s, AstRegExAttribute* a)
80707 : {
80708 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
80709 : // This function is currently only supported for the AST used the represent Binary executables.
80710 : if (0 /* isSgAsmNode(this) != NULL */)
80711 : {
80712 : // Support for regex specification.
80713 : std::string prefixCode = "REGEX:";
80714 : addNewAttribute(prefixCode + s,a);
80715 : }
80716 : #endif
80717 :
80718 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
80719 0 : return this;
80720 : }
80721 :
80722 : // *** COMMON CODE SECTION ENDS HERE ***
80723 :
80724 :
80725 : // End of memberFunctionString
80726 : // Start of memberFunctionString
80727 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
80728 :
80729 :
80730 : #if 0
80731 : //! Error checking support
80732 : /*! Verifies the following:
80733 : - working getVariant() member function
80734 : - calls base class's error() member function
80735 : Every class has one of these functions.
80736 : */
80737 : bool
80738 : SgTypeFixed::error()
80739 : {
80740 : // Put error checking here
80741 :
80742 : ROSE_ASSERT (this != NULL);
80743 : if (getVariant() != T_FIXED)
80744 : {
80745 : printf ("Error in SgTypeFixed::error(): SgTypeFixed object has a %s variant \n",
80746 : Cxx_GrammarTerminalNames[getVariant()].name);
80747 : // printf ("Error in SgTypeFixed::error() \n");
80748 : ROSE_ABORT();
80749 : }
80750 :
80751 : ROSE_ASSERT (getVariant() == T_FIXED);
80752 : return SgType::error();
80753 : }
80754 : #endif
80755 :
80756 :
80757 :
80758 : // End of memberFunctionString
80759 : // Start of memberFunctionString
80760 : /* #line 1021 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
80761 :
80762 : #if 1
80763 : /*! Support for mangled names (for unparser)
80764 : There are two different cases of source code for the get_mangled member function
80765 : This one is used in all but the classes containing a base type
80766 : */
80767 : // SgName SgTypeFixed::get_mangled ( SgUnparse_Info & info )
80768 : SgName
80769 0 : SgTypeFixed::get_mangled (void) const
80770 : {
80771 0 : ROSE_ASSERT(this != NULL);
80772 :
80773 : // DQ (10/4/2010): Modified to provide Fortran support (type_kind is a data member used for Fortran only, it is always NULL for other languages)
80774 : // CR (3/6/2020): Now type_kind is also used for Jovial.
80775 0 : SgName name = "fx";
80776 0 : if (get_type_kind() != NULL)
80777 : {
80778 : // name += get_type_kind()->get_mangled();
80779 : // name += SageInterface::generateUniqueName(get_type_kind(),false);
80780 0 : SgValueExp* value = isSgValueExp(get_type_kind());
80781 0 : if (value != NULL)
80782 : {
80783 : // name += string("_") + StringUtility::numberToString(value->get_value());
80784 0 : name += string("_kind") + value->get_constant_folded_value_as_string();
80785 : }
80786 : else
80787 : {
80788 : // DQ (9/6/2016): This is where the name of the class is used and where it can collide with a
80789 : // complex type (SgTypeComplex) if the class name is "_Complex". This is why we need something
80790 : // other than the name to be used here. Unclear if a single prefix is sufficent or if we need
80791 : // a different prefix for each type of named type. It come down to is there can be multiple
80792 : // types with the same name, and there is only a choice of SgNamedTypes: SgClassType, SgTypedefType,
80793 : // and SgEnumType. These can't have the same name, so we need not have a unity prefix for each type.
80794 : // I think the issue is that fx is not defined for any of the SgNameType IR nodes.
80795 : #if 0
80796 : printf ("In get_mangled(void): (get_type_kind() != NULL): this = %p = %s MANGLED ID STRING = %s \n",this,this->class_name().c_str(),"fx");
80797 : #endif
80798 0 : name += SageInterface::generateUniqueName(get_type_kind(),false);
80799 : }
80800 : }
80801 :
80802 : // CR (3/6/2020): This is a hack but I can't get SgTypeFixed::get_mangled() to work
80803 : // REMOVE_ME please!
80804 0 : if (isSgTypeFixed(this))
80805 : {
80806 0 : const SgTypeFixed* fixed_type = isSgTypeFixed(this);
80807 0 : if (fixed_type->get_scale() != NULL)
80808 : {
80809 0 : SgValueExp* value = isSgValueExp(fixed_type->get_scale());
80810 0 : if (value != NULL)
80811 : {
80812 0 : name += string("_") + value->get_constant_folded_value_as_string();
80813 : }
80814 : }
80815 0 : if (fixed_type->get_fraction() != NULL)
80816 : {
80817 0 : SgValueExp* value = isSgValueExp(fixed_type->get_fraction());
80818 0 : if (value != NULL)
80819 : {
80820 0 : name += string("_") + value->get_constant_folded_value_as_string();
80821 : }
80822 : }
80823 : }
80824 :
80825 : #if 0
80826 : printf("Leaving get_mangled(void): this = %p = %s mangled name = %s \n",this,this->class_name().c_str(),name.str());
80827 : #endif
80828 :
80829 0 : return name;
80830 : }
80831 : #endif
80832 :
80833 :
80834 : // End of memberFunctionString
80835 :
80836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
80837 :
80838 0 : SgTypeFixed* isSgTypeFixed ( SgNode* inputDerivedClassPointer )
80839 : {
80840 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
80841 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
80842 : // So to fix this we return NULL directly when the input is NULL and avoid the
80843 : // dynamic_cast in this case. This is likely a performance improvement as well.
80844 : // return dynamic_cast<SgTypeFixed*>(inputDerivedClassPointer);
80845 : // Milind Chabbi (8/28/2013): isSgTypeFixed uses table-driven castability instead of c++ default dynamic_cast
80846 : // this improves the running time performance by 10-20%.
80847 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeFixed*>(inputDerivedClassPointer);
80848 0 : return IS_SgTypeFixed_FAST_MACRO(inputDerivedClassPointer);
80849 : }
80850 :
80851 : // DQ (11/8/2003): Added version of functions taking const pointer
80852 3980620 : const SgTypeFixed* isSgTypeFixed ( const SgNode* inputDerivedClassPointer )
80853 : {
80854 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
80855 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
80856 : // So to fix this we return NULL directly when the input is NULL and avoid the
80857 : // dynamic_cast in this case. This is likely a performance improvement as well.
80858 : // return dynamic_cast<const SgTypeFixed*>(inputDerivedClassPointer);
80859 : // Milind Chabbi (8/28/2013): isSgTypeFixed uses table-driven castability instead of c++ default dynamic_cast
80860 : // this improves the running time performance by 10-20%.
80861 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeFixed*>(inputDerivedClassPointer);
80862 3980620 : return IS_SgTypeFixed_FAST_MACRO(inputDerivedClassPointer);
80863 : }
80864 :
80865 :
80866 :
80867 : /* #line 80868 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80868 :
80869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
80870 :
80871 : /**
80872 : \brief Generated destructor
80873 :
80874 : This destructor is automatically generated (by ROSETTA). This destructor
80875 : only frees memory of data members associated with the parts of the current IR node which
80876 : are NOT traversed. Those data members that are part of a traversal can be freed using
80877 : a traversal (calling this destructor on all children in a post-order traversal). Such
80878 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
80879 :
80880 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
80881 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
80882 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
80883 :
80884 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
80885 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
80886 : pointers are not yet implemented to call delete on eash pointer in the container.
80887 : (This could be done by derivation from the STL containers to define containers that
80888 : automatically deleted their members.)
80889 :
80890 : */
80891 0 : SgTypeFixed::~SgTypeFixed () {
80892 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
80893 :
80894 0 : if (p_scale && p_scale->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_scale; }
80895 0 : if (p_fraction && p_fraction->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_fraction; }
80896 :
80897 : // case: not a listType for scale
80898 0 : p_scale = NULL; // non list case
80899 : // case: not a listType for fraction
80900 0 : p_fraction = NULL; // non list case
80901 :
80902 : }
80903 :
80904 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
80905 0 : }
80906 :
80907 :
80908 : /* #line 80909 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80909 :
80910 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
80911 :
80912 : // Generated constructor
80913 0 : SgTypeFixed::SgTypeFixed ( SgExpression* scale, SgExpression* fraction )
80914 0 : : SgType()
80915 : {
80916 : #ifdef DEBUG
80917 : // printf ("In SgTypeFixed::SgTypeFixed (SgExpression* scale, SgExpression* fraction) sage_class_name() = %s \n",sage_class_name());
80918 : #endif
80919 : #if 0
80920 : // debugging information!
80921 : printf ("In SgTypeFixed::SgTypeFixed (SgExpression* scale, SgExpression* fraction): this = %p = %s \n",this,this->class_name().c_str());
80922 : #endif
80923 :
80924 0 : p_scale = scale;
80925 0 : p_fraction = fraction;
80926 :
80927 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
80928 :
80929 : #if 0
80930 : // DQ (7/30/2014): Call a virtual function.
80931 : std::string s = this->class_name();
80932 : #endif
80933 :
80934 : // Test the variant virtual function
80935 : // assert(T_FIXED == variant());
80936 0 : assert(T_FIXED == this->variant());
80937 0 : ROSE_ASSERT(T_FIXED == (int)(this->variantT()));
80938 0 : post_construction_initialization();
80939 :
80940 : // Test the isSgTypeFixed() function since it has been problematic
80941 0 : assert(isSgTypeFixed(this) != NULL);
80942 0 : }
80943 :
80944 : // Generated constructor (all data members)
80945 :
80946 : /* #line 80947 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80947 :
80948 :
80949 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
80950 :
80951 :
80952 : // ********************************************************
80953 : // member functions common across all array grammar objects
80954 : // ********************************************************
80955 :
80956 :
80957 :
80958 : /* #line 80959 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80959 :
80960 :
80961 :
80962 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
80963 :
80964 : // ********************************************************
80965 : // member functions specific to each node in the grammar
80966 : // ********************************************************
80967 :
80968 :
80969 : /* #line 80970 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
80970 :
80971 : // Start of memberFunctionString
80972 : /* #line 7383 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
80973 :
80974 :
80975 : SgAutoType*
80976 0 : SgAutoType::createType(SgNode* n, SgExpression* optional_fortran_type_kind)
80977 : {
80978 0 : printf ("SgAutoType::createType(SgNode*,SgExpression*) implemented to return NULL \n");
80979 0 : ROSE_ASSERT(false);
80980 :
80981 : return NULL;
80982 : }
80983 :
80984 :
80985 :
80986 : // End of memberFunctionString
80987 : // Start of memberFunctionString
80988 : /* #line 3981 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Type.code" */
80989 :
80990 :
80991 0 : SgAutoType::SgAutoType ( const SgAutoType & X )
80992 0 : : SgType(X)
80993 : {
80994 0 : }
80995 :
80996 : SgName
80997 333 : SgAutoType::get_mangled(void) const
80998 : {
80999 333 : std::ostringstream oss;
81000 333 : oss << "auto_" << std::hex << this;
81001 666 : return SgName(oss.str());
81002 : }
81003 :
81004 : /*SgName
81005 : SgAutoType::get_name() const {
81006 : return SgName("auto");
81007 : }*/
81008 :
81009 :
81010 :
81011 : // End of memberFunctionString
81012 : // Start of memberFunctionString
81013 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
81014 :
81015 : // *** COMMON CODE SECTION BEGINS HERE ***
81016 :
81017 : #if 0
81018 : int
81019 : SgAutoType::getVariant() const
81020 : {
81021 : // This function is used in ROSE while "variant()" is used in SAGE
81022 : assert(this != NULL);
81023 : return variant();
81024 : }
81025 : #endif
81026 :
81027 : // This function is used in ROSE in treeTraversal code
81028 : // eventually replaces getVariant() and variant()
81029 : // though after variant() has been removed for a while we will
81030 : // want to change the name of variantT() back to variant()
81031 : // (since the "T" was ment to stand for temporary).
81032 : // When this happens the variantT() will be depricated.
81033 : VariantT
81034 154636 : SgAutoType::variantT() const
81035 : {
81036 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
81037 154636 : ROSE_ASSERT(this != NULL);
81038 154636 : return V_SgAutoType;
81039 : }
81040 :
81041 : #if 0
81042 : int
81043 : SgAutoType::variant() const
81044 : {
81045 : // This function is used in SAGE
81046 : ROSE_ASSERT(this != NULL);
81047 : return T_AUTO;
81048 : }
81049 : #endif
81050 :
81051 : ROSE_DLL_API const char*
81052 0 : SgAutoType::sage_class_name() const
81053 : {
81054 0 : ROSE_ASSERT(this != NULL);
81055 0 : return "SgAutoType";
81056 : }
81057 :
81058 : std::string
81059 166 : SgAutoType::class_name() const
81060 : {
81061 166 : ROSE_ASSERT(this != NULL);
81062 166 : return "SgAutoType";
81063 : }
81064 :
81065 : // DQ (11/26/2005): Support for visitor pattern mechanims
81066 : // (inferior to ROSE traversal mechanism, experimental).
81067 : void
81068 2062 : SgAutoType::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
81069 : {
81070 2062 : ROSE_ASSERT(this != NULL);
81071 2062 : visitor.visit(this);
81072 2062 : }
81073 :
81074 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
81075 0 : void SgAutoType::accept (ROSE_VisitorPattern & visitor) {
81076 0 : ROSE_ASSERT(this != NULL);
81077 0 : visitor.visit(this);
81078 0 : }
81079 :
81080 : SgAutoType*
81081 0 : SgAutoType::addRegExpAttribute(std::string s, AstRegExAttribute* a)
81082 : {
81083 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
81084 : // This function is currently only supported for the AST used the represent Binary executables.
81085 : if (0 /* isSgAsmNode(this) != NULL */)
81086 : {
81087 : // Support for regex specification.
81088 : std::string prefixCode = "REGEX:";
81089 : addNewAttribute(prefixCode + s,a);
81090 : }
81091 : #endif
81092 :
81093 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
81094 0 : return this;
81095 : }
81096 :
81097 : // *** COMMON CODE SECTION ENDS HERE ***
81098 :
81099 :
81100 : // End of memberFunctionString
81101 : // Start of memberFunctionString
81102 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
81103 :
81104 :
81105 : #if 0
81106 : //! Error checking support
81107 : /*! Verifies the following:
81108 : - working getVariant() member function
81109 : - calls base class's error() member function
81110 : Every class has one of these functions.
81111 : */
81112 : bool
81113 : SgAutoType::error()
81114 : {
81115 : // Put error checking here
81116 :
81117 : ROSE_ASSERT (this != NULL);
81118 : if (getVariant() != T_AUTO)
81119 : {
81120 : printf ("Error in SgAutoType::error(): SgAutoType object has a %s variant \n",
81121 : Cxx_GrammarTerminalNames[getVariant()].name);
81122 : // printf ("Error in SgAutoType::error() \n");
81123 : ROSE_ABORT();
81124 : }
81125 :
81126 : ROSE_ASSERT (getVariant() == T_AUTO);
81127 : return SgType::error();
81128 : }
81129 : #endif
81130 :
81131 :
81132 :
81133 : // End of memberFunctionString
81134 :
81135 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
81136 :
81137 27551 : SgAutoType* isSgAutoType ( SgNode* inputDerivedClassPointer )
81138 : {
81139 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
81140 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
81141 : // So to fix this we return NULL directly when the input is NULL and avoid the
81142 : // dynamic_cast in this case. This is likely a performance improvement as well.
81143 : // return dynamic_cast<SgAutoType*>(inputDerivedClassPointer);
81144 : // Milind Chabbi (8/28/2013): isSgAutoType uses table-driven castability instead of c++ default dynamic_cast
81145 : // this improves the running time performance by 10-20%.
81146 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAutoType*>(inputDerivedClassPointer);
81147 27551 : return IS_SgAutoType_FAST_MACRO(inputDerivedClassPointer);
81148 : }
81149 :
81150 : // DQ (11/8/2003): Added version of functions taking const pointer
81151 0 : const SgAutoType* isSgAutoType ( const SgNode* inputDerivedClassPointer )
81152 : {
81153 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
81154 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
81155 : // So to fix this we return NULL directly when the input is NULL and avoid the
81156 : // dynamic_cast in this case. This is likely a performance improvement as well.
81157 : // return dynamic_cast<const SgAutoType*>(inputDerivedClassPointer);
81158 : // Milind Chabbi (8/28/2013): isSgAutoType uses table-driven castability instead of c++ default dynamic_cast
81159 : // this improves the running time performance by 10-20%.
81160 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAutoType*>(inputDerivedClassPointer);
81161 0 : return IS_SgAutoType_FAST_MACRO(inputDerivedClassPointer);
81162 : }
81163 :
81164 :
81165 :
81166 : /* #line 81167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
81167 :
81168 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
81169 :
81170 : /**
81171 : \brief Generated destructor
81172 :
81173 : This destructor is automatically generated (by ROSETTA). This destructor
81174 : only frees memory of data members associated with the parts of the current IR node which
81175 : are NOT traversed. Those data members that are part of a traversal can be freed using
81176 : a traversal (calling this destructor on all children in a post-order traversal). Such
81177 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
81178 :
81179 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
81180 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
81181 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
81182 :
81183 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
81184 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
81185 : pointers are not yet implemented to call delete on eash pointer in the container.
81186 : (This could be done by derivation from the STL containers to define containers that
81187 : automatically deleted their members.)
81188 :
81189 : */
81190 56 : SgAutoType::~SgAutoType () {
81191 28 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
81192 :
81193 :
81194 :
81195 : }
81196 :
81197 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
81198 56 : }
81199 :
81200 :
81201 : /* #line 81202 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
81202 :
81203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
81204 :
81205 : // Generated constructor
81206 146 : SgAutoType::SgAutoType ( )
81207 146 : : SgType()
81208 : {
81209 : #ifdef DEBUG
81210 : // printf ("In SgAutoType::SgAutoType () sage_class_name() = %s \n",sage_class_name());
81211 : #endif
81212 : #if 0
81213 : // debugging information!
81214 : printf ("In SgAutoType::SgAutoType (): this = %p = %s \n",this,this->class_name().c_str());
81215 : #endif
81216 :
81217 :
81218 :
81219 : #if 0
81220 : // DQ (7/30/2014): Call a virtual function.
81221 : std::string s = this->class_name();
81222 : #endif
81223 :
81224 : // Test the variant virtual function
81225 : // assert(T_AUTO == variant());
81226 146 : assert(T_AUTO == this->variant());
81227 146 : ROSE_ASSERT(T_AUTO == (int)(this->variantT()));
81228 146 : post_construction_initialization();
81229 :
81230 : // Test the isSgAutoType() function since it has been problematic
81231 146 : assert(isSgAutoType(this) != NULL);
81232 146 : }
81233 :
81234 : // Generated constructor (all data members)
81235 :
81236 : /* #line 81237 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
81237 :
81238 :
81239 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
81240 :
81241 :
81242 : // ********************************************************
81243 : // member functions common across all array grammar objects
81244 : // ********************************************************
81245 :
81246 :
81247 :
81248 : /* #line 81249 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
81249 :
81250 :
81251 :
81252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
81253 :
81254 : // ********************************************************
81255 : // member functions specific to each node in the grammar
81256 : // ********************************************************
81257 :
81258 :
81259 : /* #line 81260 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
81260 :
81261 : // Start of memberFunctionString
81262 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
81263 :
81264 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
81265 :
81266 : Sg_File_Info*
81267 474154000 : SgLocatedNode::get_startOfConstruct () const
81268 : {
81269 474154000 : ROSE_ASSERT (this != NULL);
81270 :
81271 : #if 0
81272 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
81273 : // used to trigger marking transformations for the token-based unparsing.
81274 : printf ("SgLocatedNode::get_startOfConstruct = %p = %s \n",this,this->class_name().c_str());
81275 : #endif
81276 :
81277 474154000 : return p_startOfConstruct;
81278 : }
81279 :
81280 : void
81281 34304300 : SgLocatedNode::set_startOfConstruct ( Sg_File_Info* startOfConstruct )
81282 : {
81283 34304300 : ROSE_ASSERT (this != NULL);
81284 :
81285 : #if 0
81286 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
81287 : // used to trigger marking transformations for the token-based unparsing.
81288 : printf ("SgLocatedNode::set_startOfConstruct = %p = %s \n",this,this->class_name().c_str());
81289 : #endif
81290 :
81291 34304300 : set_isModified(true);
81292 :
81293 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
81294 : if (p_startOfConstruct != NULL && startOfConstruct != NULL && p_startOfConstruct != startOfConstruct)
81295 : {
81296 : printf ("Warning: startOfConstruct = %p overwriting valid pointer p_startOfConstruct = %p \n",startOfConstruct,p_startOfConstruct);
81297 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
81298 : printf ("Error fails assertion (p_startOfConstruct != NULL && startOfConstruct != NULL && p_startOfConstruct != startOfConstruct) is false\n");
81299 : ROSE_ASSERT(false);
81300 : #endif
81301 : }
81302 : #endif
81303 34304300 : p_startOfConstruct = startOfConstruct;
81304 34304300 : }
81305 :
81306 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
81307 :
81308 :
81309 : // End of memberFunctionString
81310 : // Start of memberFunctionString
81311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
81312 :
81313 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
81314 :
81315 : Sg_File_Info*
81316 268039000 : SgLocatedNode::get_endOfConstruct () const
81317 : {
81318 268039000 : ROSE_ASSERT (this != NULL);
81319 :
81320 : #if 0
81321 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
81322 : // used to trigger marking transformations for the token-based unparsing.
81323 : printf ("SgLocatedNode::get_endOfConstruct = %p = %s \n",this,this->class_name().c_str());
81324 : #endif
81325 :
81326 268039000 : return p_endOfConstruct;
81327 : }
81328 :
81329 : void
81330 34308400 : SgLocatedNode::set_endOfConstruct ( Sg_File_Info* endOfConstruct )
81331 : {
81332 34308400 : ROSE_ASSERT (this != NULL);
81333 :
81334 : #if 0
81335 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
81336 : // used to trigger marking transformations for the token-based unparsing.
81337 : printf ("SgLocatedNode::set_endOfConstruct = %p = %s \n",this,this->class_name().c_str());
81338 : #endif
81339 :
81340 34308400 : set_isModified(true);
81341 :
81342 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
81343 : if (p_endOfConstruct != NULL && endOfConstruct != NULL && p_endOfConstruct != endOfConstruct)
81344 : {
81345 : printf ("Warning: endOfConstruct = %p overwriting valid pointer p_endOfConstruct = %p \n",endOfConstruct,p_endOfConstruct);
81346 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
81347 : printf ("Error fails assertion (p_endOfConstruct != NULL && endOfConstruct != NULL && p_endOfConstruct != endOfConstruct) is false\n");
81348 : ROSE_ASSERT(false);
81349 : #endif
81350 : }
81351 : #endif
81352 34308400 : p_endOfConstruct = endOfConstruct;
81353 34308400 : }
81354 :
81355 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
81356 :
81357 :
81358 : // End of memberFunctionString
81359 : // Start of memberFunctionString
81360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
81361 :
81362 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
81363 :
81364 : AttachedPreprocessingInfoType*
81365 0 : SgLocatedNode::get_attachedPreprocessingInfoPtr () const
81366 : {
81367 0 : ROSE_ASSERT (this != NULL);
81368 :
81369 : #if 0
81370 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
81371 : // used to trigger marking transformations for the token-based unparsing.
81372 : printf ("SgLocatedNode::get_attachedPreprocessingInfoPtr = %p = %s \n",this,this->class_name().c_str());
81373 : #endif
81374 :
81375 0 : return p_attachedPreprocessingInfoPtr;
81376 : }
81377 :
81378 : void
81379 0 : SgLocatedNode::set_attachedPreprocessingInfoPtr ( AttachedPreprocessingInfoType* attachedPreprocessingInfoPtr )
81380 : {
81381 0 : ROSE_ASSERT (this != NULL);
81382 :
81383 : #if 0
81384 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
81385 : // used to trigger marking transformations for the token-based unparsing.
81386 : printf ("SgLocatedNode::set_attachedPreprocessingInfoPtr = %p = %s \n",this,this->class_name().c_str());
81387 : #endif
81388 :
81389 0 : set_isModified(true);
81390 :
81391 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
81392 : if (p_attachedPreprocessingInfoPtr != NULL && attachedPreprocessingInfoPtr != NULL && p_attachedPreprocessingInfoPtr != attachedPreprocessingInfoPtr)
81393 : {
81394 : printf ("Warning: attachedPreprocessingInfoPtr = %p overwriting valid pointer p_attachedPreprocessingInfoPtr = %p \n",attachedPreprocessingInfoPtr,p_attachedPreprocessingInfoPtr);
81395 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
81396 : printf ("Error fails assertion (p_attachedPreprocessingInfoPtr != NULL && attachedPreprocessingInfoPtr != NULL && p_attachedPreprocessingInfoPtr != attachedPreprocessingInfoPtr) is false\n");
81397 : ROSE_ASSERT(false);
81398 : #endif
81399 : }
81400 : #endif
81401 0 : p_attachedPreprocessingInfoPtr = attachedPreprocessingInfoPtr;
81402 0 : }
81403 :
81404 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
81405 :
81406 :
81407 : // End of memberFunctionString
81408 : // Start of memberFunctionString
81409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
81410 :
81411 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
81412 :
81413 : AstAttributeMechanism*
81414 300674 : SgLocatedNode::get_attributeMechanism () const
81415 : {
81416 300674 : ROSE_ASSERT (this != NULL);
81417 300674 : return p_attributeMechanism;
81418 : }
81419 :
81420 : void
81421 8 : SgLocatedNode::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
81422 : {
81423 8 : ROSE_ASSERT (this != NULL);
81424 :
81425 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
81426 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
81427 : {
81428 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
81429 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
81430 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
81431 : ROSE_ASSERT(false);
81432 : #endif
81433 : }
81434 : #endif
81435 8 : p_attributeMechanism = attributeMechanism;
81436 8 : }
81437 :
81438 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
81439 :
81440 :
81441 : // End of memberFunctionString
81442 : // Start of memberFunctionString
81443 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
81444 :
81445 :
81446 : #if 0
81447 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
81448 : // a pointer and the interface represented directly at the SgNode
81449 : AstAttributeMechanism &
81450 : SgLocatedNode::attribute()
81451 : {
81452 : // DQ (1/2/2006): This function preserves as much of
81453 : // the syntax of attribute being a public data member.
81454 : if (p_attribute == NULL)
81455 : {
81456 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
81457 : assert(false);
81458 : }
81459 :
81460 : return *p_attribute;
81461 : }
81462 : #endif
81463 :
81464 : void
81465 8 : SgLocatedNode::addNewAttribute( std::string s, AstAttribute* a )
81466 : {
81467 8 : if (get_attributeMechanism() == NULL)
81468 : {
81469 8 : set_attributeMechanism( new AstAttributeMechanism() );
81470 8 : ROSE_ASSERT(get_attributeMechanism() != NULL);
81471 : }
81472 8 : get_attributeMechanism()->add(s,a);
81473 8 : }
81474 :
81475 : void
81476 0 : SgLocatedNode::setAttribute( std::string s, AstAttribute* a )
81477 : {
81478 0 : if (get_attributeMechanism() == NULL)
81479 : {
81480 0 : set_attributeMechanism( new AstAttributeMechanism() );
81481 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
81482 : }
81483 0 : get_attributeMechanism()->set(s,a);
81484 0 : }
81485 :
81486 : AstAttribute*
81487 153721 : SgLocatedNode::getAttribute(std::string s) const
81488 : {
81489 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
81490 307442 : if (attributeExists(s)==false) return NULL;
81491 8 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
81492 8 : ROSE_ASSERT(returnValue != NULL);
81493 8 : return returnValue;
81494 : }
81495 :
81496 : void
81497 0 : SgLocatedNode::updateAttribute( std::string s, AstAttribute* a )
81498 : {
81499 : // formerly called: replace
81500 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
81501 0 : get_attributeMechanism()->replace(s,a);
81502 0 : }
81503 :
81504 : void
81505 0 : SgLocatedNode::removeAttribute(std::string s)
81506 : {
81507 0 : if (get_attributeMechanism())
81508 0 : get_attributeMechanism()->remove(s);
81509 :
81510 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
81511 0 : int remainingCount = numberOfAttributes();
81512 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
81513 0 : if (remainingCount == 0)
81514 : {
81515 0 : delete get_attributeMechanism();
81516 0 : set_attributeMechanism(NULL);
81517 : }
81518 0 : }
81519 :
81520 : bool
81521 153721 : SgLocatedNode::attributeExists(std::string s) const
81522 : {
81523 153721 : bool returnValue = false;
81524 153721 : if (get_attributeMechanism() != NULL)
81525 16 : returnValue = get_attributeMechanism()->exists(s);
81526 153721 : return returnValue;
81527 : }
81528 :
81529 : int
81530 0 : SgLocatedNode::numberOfAttributes() const
81531 : {
81532 0 : int returnValue = 0;
81533 0 : if (get_attributeMechanism() != NULL)
81534 0 : returnValue = get_attributeMechanism()->size();
81535 0 : return returnValue;
81536 : }
81537 :
81538 :
81539 :
81540 : // End of memberFunctionString
81541 : // Start of memberFunctionString
81542 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
81543 :
81544 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
81545 :
81546 : bool
81547 34109 : SgLocatedNode::get_containsTransformationToSurroundingWhitespace () const
81548 : {
81549 34109 : ROSE_ASSERT (this != NULL);
81550 34109 : return p_containsTransformationToSurroundingWhitespace;
81551 : }
81552 :
81553 : void
81554 165 : SgLocatedNode::set_containsTransformationToSurroundingWhitespace ( bool containsTransformationToSurroundingWhitespace )
81555 : {
81556 165 : ROSE_ASSERT (this != NULL);
81557 :
81558 165 : p_containsTransformationToSurroundingWhitespace = containsTransformationToSurroundingWhitespace;
81559 165 : }
81560 :
81561 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
81562 :
81563 :
81564 : // End of memberFunctionString
81565 : // Start of memberFunctionString
81566 : /* #line 631 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
81567 :
81568 :
81569 : #if 0
81570 : // DQ (4/10/2006): This is replaced by a better interface for attributes.
81571 : AstAttributeMechanism &
81572 : SgLocatedNode::attribute()
81573 : {
81574 : // DQ (1/2/2006): This function preserves as much of
81575 : // the syntax of attribute being a public data member.
81576 : if (p_attribute == NULL)
81577 : {
81578 : printf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
81579 : ROSE_ASSERT(false);
81580 : }
81581 :
81582 : return *p_attribute;
81583 : }
81584 : #endif
81585 :
81586 : #if 0
81587 : const char*
81588 : SgLocatedNode::getFileName ()
81589 : {
81590 : // Function added by DQ (7/22/2001)
81591 :
81592 : const char* fileName = "NO NAME FILE";
81593 : // Sometimes the locatedNode doesn't have a SgFile object
81594 : // (likely because it is part of a parent statement object)
81595 : if (get_file_info() != NULL)
81596 : {
81597 : Sg_File_Info* fileInfo = get_file_info();
81598 : ROSE_ASSERT (fileInfo != NULL);
81599 : fileName = fileInfo->get_filename();
81600 : ROSE_ASSERT (fileName != NULL);
81601 : }
81602 :
81603 : return fileName;
81604 : }
81605 : #endif
81606 :
81607 : const std::string &
81608 58 : SgLocatedNode::getFilenameString() const
81609 : {
81610 : // Function added by DQ (2/2/2007) to replace depricated function const char* SgLocatedNode::getFileName()
81611 58 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81612 58 : return get_startOfConstruct()->get_filenameString();
81613 : }
81614 :
81615 : Sg_File_Info*
81616 153965000 : SgLocatedNode::get_file_info() const
81617 : {
81618 : // DQ (11/8/2006):
81619 : // At this level in the hierarchy of AST IR nodes we want the get_file_info()
81620 : // member function to be mapped to the get_startOfConstruct() member function.
81621 : // For SgExpression IR nodes we will map it to the get_operatorPosition()
81622 : // member function.
81623 153965000 : return get_startOfConstruct();
81624 : }
81625 :
81626 : void
81627 668 : SgLocatedNode::set_file_info( Sg_File_Info* fileInfo )
81628 : {
81629 : // DQ (5.14.2006): Allow input to be NULL so that we can safely reset the Sg_File_Info pointer.
81630 : // ROSE_ASSERT (fileInfo != NULL);
81631 668 : set_startOfConstruct(fileInfo);
81632 : #ifndef REMOVE_SET_PARENT_FUNCTION
81633 : fileInfo->set_parent(this);
81634 : #endif
81635 668 : }
81636 :
81637 : void
81638 18259900 : SgLocatedNode::post_construction_initialization()
81639 : {
81640 : // JJW 10-26-2007 ensure that this object is not on the stack
81641 18259900 : preventConstructionOnStack(this);
81642 :
81643 : // Make sure that the pointer to the data structure storing the
81644 : // attached PreprocessingInfo objects is NULL
81645 18259900 : p_attachedPreprocessingInfoPtr = NULL;
81646 :
81647 : // DQ (12/17/2006): Added semantics to set the parent of any avaliable Sg_File_Info objects.
81648 18259900 : if (p_startOfConstruct != NULL)
81649 : {
81650 12785 : p_startOfConstruct->set_parent(this);
81651 : }
81652 :
81653 : // DQ (12/17/2006): Added semantics to set the parent of any avaliable Sg_File_Info objects.
81654 18259900 : if (p_endOfConstruct != NULL)
81655 : {
81656 0 : p_endOfConstruct->set_parent(this);
81657 : }
81658 18259900 : }
81659 :
81660 : // DQ (12/22/2006): These function are part of a move to lift the interface for
81661 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81662 : void
81663 1267310 : SgLocatedNode::setCompilerGenerated ()
81664 : {
81665 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81666 1267310 : ROSE_ASSERT(this != NULL);
81667 :
81668 1267310 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81669 1267310 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81670 1267310 : get_startOfConstruct()->setCompilerGenerated();
81671 1267310 : get_endOfConstruct()->setCompilerGenerated();
81672 :
81673 1267310 : SgExpression* expression = isSgExpression(this);
81674 1267310 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81675 : {
81676 0 : expression->get_operatorPosition()->setCompilerGenerated();
81677 : }
81678 1267310 : }
81679 :
81680 : // DQ (12/22/2006): These function are part of a move to lift the interface for
81681 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81682 : void
81683 0 : SgLocatedNode::unsetCompilerGenerated()
81684 : {
81685 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81686 0 : ROSE_ASSERT(this != NULL);
81687 :
81688 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81689 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81690 0 : get_startOfConstruct()->unsetCompilerGenerated();
81691 0 : get_endOfConstruct()->unsetCompilerGenerated();
81692 :
81693 0 : SgExpression* expression = isSgExpression(this);
81694 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81695 : {
81696 0 : ROSE_ASSERT(expression->get_operatorPosition() != NULL);
81697 0 : expression->get_operatorPosition()->unsetCompilerGenerated();
81698 : }
81699 0 : }
81700 :
81701 : bool
81702 26990 : SgLocatedNode::isCompilerGenerated () const
81703 : {
81704 : // DQ (7/5/2014): Added function to define a simple API.
81705 :
81706 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81707 26990 : ROSE_ASSERT(this != NULL);
81708 :
81709 26990 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81710 26990 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81711 :
81712 26990 : bool result = get_startOfConstruct()->isCompilerGenerated();
81713 : // ROSE_ASSERT(result == get_endOfConstruct()->isCompilerGenerated()); // FIXME fails on SgInitializedName = ::std::_Vector_base < Real_t , allocator< Real_t > >::_M_impl
81714 :
81715 26990 : const SgExpression* expression = isSgExpression(this);
81716 26990 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81717 : {
81718 6150 : if (result != expression->get_operatorPosition()->isCompilerGenerated()) {
81719 0 : printf ("[SgLocatedNode::isCompilerGenerated] FATAL: expression->get_operatorPosition() does not match get_startOfConstruct().\n");
81720 : }
81721 6150 : ROSE_ASSERT(result == expression->get_operatorPosition()->isCompilerGenerated());
81722 : }
81723 :
81724 26990 : return result;
81725 : }
81726 :
81727 :
81728 : // DQ (4/14/2015): These function are part of a move to lift the interface for
81729 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81730 : void
81731 0 : SgLocatedNode::setTransformation ()
81732 : {
81733 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81734 0 : ROSE_ASSERT(this != NULL);
81735 :
81736 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81737 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81738 0 : get_startOfConstruct()->setTransformation();
81739 0 : get_endOfConstruct()->setTransformation();
81740 :
81741 0 : SgExpression* expression = isSgExpression(this);
81742 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81743 : {
81744 0 : expression->get_operatorPosition()->setTransformation();
81745 : }
81746 0 : }
81747 :
81748 : // DQ (4/14/2015): These function are part of a move to lift the interface for
81749 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81750 : void
81751 0 : SgLocatedNode::unsetTransformation()
81752 : {
81753 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81754 0 : ROSE_ASSERT(this != NULL);
81755 :
81756 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81757 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81758 0 : get_startOfConstruct()->unsetTransformation();
81759 0 : get_endOfConstruct()->unsetTransformation();
81760 :
81761 0 : SgExpression* expression = isSgExpression(this);
81762 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81763 : {
81764 0 : ROSE_ASSERT(expression->get_operatorPosition() != NULL);
81765 0 : expression->get_operatorPosition()->unsetTransformation();
81766 : }
81767 0 : }
81768 :
81769 : bool
81770 129060 : SgLocatedNode::isTransformation () const
81771 : {
81772 : // DQ (12/4/2014): Added function to define a simple API.
81773 :
81774 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81775 129060 : ROSE_ASSERT(this != NULL);
81776 :
81777 129060 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81778 :
81779 129060 : bool result = get_startOfConstruct()->isTransformation();
81780 :
81781 : // DQ (4/6/2015): Allow this to work even when the endOfConstruct is not yet set (required for inlining).
81782 : // ROSE_ASSERT(get_endOfConstruct() != NULL);
81783 129060 : if (get_endOfConstruct() != NULL)
81784 : {
81785 129060 : ROSE_ASSERT(result == get_endOfConstruct()->isTransformation());
81786 : }
81787 : else
81788 : {
81789 0 : printf ("WARNING: In SgLocatedNode::isTransformation(): this = %p = %s testing: get_endOfConstruct() != NULL (failed) \n",this,this->class_name().c_str());
81790 : }
81791 :
81792 129060 : const SgExpression* expression = isSgExpression(this);
81793 129060 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81794 : {
81795 : #if 0
81796 : printf ("NOTE: this = %p = %s testing: result != expression->get_operatorPosition()->isTransformation() \n",this,this->class_name().c_str());
81797 : #endif
81798 91 : if (result != expression->get_operatorPosition()->isTransformation())
81799 : {
81800 0 : printf ("Warning: this = %p = %s result != expression->get_operatorPosition()->isTransformation() \n",this,this->class_name().c_str());
81801 0 : printf (" --- Suggest calling the set transformation on the SgLocated node directly, instead of on the SgFileInfo objects seperately. \n");
81802 : }
81803 : // DQ (12/13/2018): This is difficult to enforce and causes an error in the outlining tests for Fortran in roseTests/astOutliningTests.
81804 : // When we eliminate the alternative interface to set this in each Sg_FileInfo object then it will be easier to enforce. So for now
81805 : // just issue the warning.
81806 : // ROSE_ASSERT(result == expression->get_operatorPosition()->isTransformation());
81807 : }
81808 :
81809 129060 : return result;
81810 : }
81811 :
81812 :
81813 : // DQ (12/21/2019): These function are part of a move to lift the interface for
81814 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81815 : void
81816 0 : SgLocatedNode::setShared ()
81817 : {
81818 : // DQ (12/21/2019): Detect if this is called from a NULL pointer.
81819 0 : ROSE_ASSERT(this != NULL);
81820 :
81821 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81822 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81823 0 : get_startOfConstruct()->setShared();
81824 0 : get_endOfConstruct()->setShared();
81825 :
81826 0 : SgExpression* expression = isSgExpression(this);
81827 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81828 : {
81829 0 : expression->get_operatorPosition()->setShared();
81830 : }
81831 0 : }
81832 :
81833 : // DQ (12/21/2019): These function are part of a move to lift the interface for
81834 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81835 : void
81836 0 : SgLocatedNode::unsetShared()
81837 : {
81838 : // DQ (12/21/2019): Detect if this is called from a NULL pointer.
81839 0 : ROSE_ASSERT(this != NULL);
81840 :
81841 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81842 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81843 0 : get_startOfConstruct()->unsetShared();
81844 0 : get_endOfConstruct()->unsetShared();
81845 :
81846 0 : SgExpression* expression = isSgExpression(this);
81847 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81848 : {
81849 0 : ROSE_ASSERT(expression->get_operatorPosition() != NULL);
81850 0 : expression->get_operatorPosition()->unsetShared();
81851 : }
81852 0 : }
81853 :
81854 : bool
81855 0 : SgLocatedNode::isShared () const
81856 : {
81857 : // DQ (12/21/2019): Added function to define a simple API.
81858 :
81859 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81860 0 : ROSE_ASSERT(this != NULL);
81861 :
81862 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81863 :
81864 0 : bool result = get_startOfConstruct()->isShared();
81865 :
81866 : // DQ (4/6/2015): Allow this to work even when the endOfConstruct is not yet set (required for inlining).
81867 : // ROSE_ASSERT(get_endOfConstruct() != NULL);
81868 0 : if (get_endOfConstruct() != NULL)
81869 : {
81870 0 : ROSE_ASSERT(result == get_endOfConstruct()->isShared());
81871 : }
81872 : else
81873 : {
81874 0 : printf ("WARNING: In SgLocatedNode::isShared(): this = %p = %s testing: get_endOfConstruct() != NULL (failed) \n",this,this->class_name().c_str());
81875 : }
81876 :
81877 0 : const SgExpression* expression = isSgExpression(this);
81878 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81879 : {
81880 : #if 0
81881 : printf ("NOTE: this = %p = %s testing: result != expression->get_operatorPosition()->isShared() \n",this,this->class_name().c_str());
81882 : #endif
81883 0 : if (result != expression->get_operatorPosition()->isShared())
81884 : {
81885 0 : printf ("Warning: this = %p = %s result != expression->get_operatorPosition()->isShared() \n",this,this->class_name().c_str());
81886 0 : printf (" --- Suggest calling the set shared on the SgLocated node directly, instead of on the SgFileInfo objects seperately. \n");
81887 : }
81888 : // DQ (12/13/2018): This is difficult to enforce and causes an error in the outlining tests for Fortran in roseTests/astOutliningTests.
81889 : // When we eliminate the alternative interface to set this in each Sg_FileInfo object then it will be easier to enforce. So for now
81890 : // just issue the warning.
81891 : // ROSE_ASSERT(result == expression->get_operatorPosition()->isShared());
81892 : }
81893 :
81894 0 : return result;
81895 : }
81896 :
81897 :
81898 : // DQ (12/22/2006): These function are part of a move to lift the interface for
81899 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81900 : void
81901 0 : SgLocatedNode::setFrontendSpecific ()
81902 : {
81903 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81904 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81905 0 : get_startOfConstruct()->setFrontendSpecific();
81906 0 : get_endOfConstruct()->setFrontendSpecific();
81907 :
81908 0 : SgExpression* expression = isSgExpression(this);
81909 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81910 : {
81911 0 : expression->get_operatorPosition()->setFrontendSpecific();
81912 : }
81913 0 : }
81914 :
81915 : // DQ (12/22/2006): These function are part of a move to lift the interface for
81916 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81917 : void
81918 0 : SgLocatedNode::unsetFrontendSpecific()
81919 : {
81920 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81921 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81922 0 : get_startOfConstruct()->unsetFrontendSpecific();
81923 0 : get_endOfConstruct()->unsetFrontendSpecific();
81924 :
81925 0 : SgExpression* expression = isSgExpression(this);
81926 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81927 : {
81928 0 : ROSE_ASSERT(expression->get_operatorPosition() != NULL);
81929 0 : expression->get_operatorPosition()->unsetFrontendSpecific();
81930 : }
81931 0 : }
81932 :
81933 : bool
81934 0 : SgLocatedNode::isFrontendSpecific () const
81935 : {
81936 : // DQ (12/21/2019): Added function to define a simple API.
81937 :
81938 : // DQ (4/14/2015): Detect if this is called from a NULL pointer.
81939 0 : ROSE_ASSERT(this != NULL);
81940 :
81941 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81942 :
81943 0 : bool result = get_startOfConstruct()->isFrontendSpecific();
81944 :
81945 : // DQ (4/6/2015): Allow this to work even when the endOfConstruct is not yet set (required for inlining).
81946 : // ROSE_ASSERT(get_endOfConstruct() != NULL);
81947 0 : if (get_endOfConstruct() != NULL)
81948 : {
81949 0 : ROSE_ASSERT(result == get_endOfConstruct()->isFrontendSpecific());
81950 : }
81951 : else
81952 : {
81953 0 : printf ("WARNING: In SgLocatedNode::isFrontendSpecific(): this = %p = %s testing: get_endOfConstruct() != NULL (failed) \n",this,this->class_name().c_str());
81954 : }
81955 :
81956 0 : const SgExpression* expression = isSgExpression(this);
81957 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81958 : {
81959 : #if 0
81960 : printf ("NOTE: this = %p = %s testing: result != expression->get_operatorPosition()->isFrontendSpecific() \n",this,this->class_name().c_str());
81961 : #endif
81962 0 : if (result != expression->get_operatorPosition()->isFrontendSpecific())
81963 : {
81964 0 : printf ("Warning: this = %p = %s result != expression->get_operatorPosition()->isFrontendSpecific() \n",this,this->class_name().c_str());
81965 0 : printf (" --- Suggest calling the set shared on the SgLocated node directly, instead of on the SgFileInfo objects seperately. \n");
81966 : }
81967 : // DQ (12/13/2018): This is difficult to enforce and causes an error in the outlining tests for Fortran in roseTests/astOutliningTests.
81968 : // When we eliminate the alternative interface to set this in each Sg_FileInfo object then it will be easier to enforce. So for now
81969 : // just issue the warning.
81970 : // ROSE_ASSERT(result == expression->get_operatorPosition()->isFrontendSpecific());
81971 : }
81972 :
81973 0 : return result;
81974 : }
81975 :
81976 :
81977 :
81978 : // DQ (12/22/2006): These function are part of a move to lift the interface for
81979 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81980 : void
81981 0 : SgLocatedNode::setSourcePositionUnavailableInFrontend ()
81982 : {
81983 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
81984 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
81985 0 : get_startOfConstruct()->setSourcePositionUnavailableInFrontend();
81986 0 : get_endOfConstruct()->setSourcePositionUnavailableInFrontend();
81987 :
81988 0 : SgExpression* expression = isSgExpression(this);
81989 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
81990 : {
81991 0 : expression->get_operatorPosition()->setSourcePositionUnavailableInFrontend();
81992 : }
81993 0 : }
81994 :
81995 : // DQ (12/22/2006): These function are part of a move to lift the interface for
81996 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
81997 : void
81998 0 : SgLocatedNode::unsetSourcePositionUnavailableInFrontend()
81999 : {
82000 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
82001 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
82002 0 : get_startOfConstruct()->unsetSourcePositionUnavailableInFrontend();
82003 0 : get_endOfConstruct()->unsetSourcePositionUnavailableInFrontend();
82004 :
82005 0 : SgExpression* expression = isSgExpression(this);
82006 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
82007 : {
82008 0 : ROSE_ASSERT(expression->get_operatorPosition() != NULL);
82009 0 : expression->get_operatorPosition()->unsetSourcePositionUnavailableInFrontend();
82010 : }
82011 0 : }
82012 :
82013 : // DQ (12/22/2006): These function are part of a move to lift the interface for
82014 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
82015 : void
82016 0 : SgLocatedNode::setOutputInCodeGeneration ()
82017 : {
82018 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
82019 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
82020 0 : get_startOfConstruct()->setOutputInCodeGeneration();
82021 0 : get_endOfConstruct()->setOutputInCodeGeneration();
82022 :
82023 0 : SgExpression* expression = isSgExpression(this);
82024 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
82025 : {
82026 0 : expression->get_operatorPosition()->setOutputInCodeGeneration();
82027 : }
82028 0 : }
82029 :
82030 : // DQ (12/22/2006): These function are part of a move to lift the interface for
82031 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
82032 : void
82033 0 : SgLocatedNode::unsetOutputInCodeGeneration()
82034 : {
82035 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
82036 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
82037 0 : get_startOfConstruct()->unsetOutputInCodeGeneration();
82038 0 : get_endOfConstruct()->unsetOutputInCodeGeneration();
82039 :
82040 0 : SgExpression* expression = isSgExpression(this);
82041 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
82042 : {
82043 0 : ROSE_ASSERT(expression->get_operatorPosition() != NULL);
82044 0 : expression->get_operatorPosition()->unsetOutputInCodeGeneration();
82045 : }
82046 0 : }
82047 :
82048 : // DQ (10/25/20018): These function are part of a move to lift the interface for
82049 : // IR node classification from the Sg_File_Info object to the SgLocatedNode (at least).
82050 : int
82051 0 : SgLocatedNode::get_physical_file_id()
82052 : {
82053 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
82054 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
82055 0 : ROSE_ASSERT(get_startOfConstruct()->get_physical_file_id() == get_endOfConstruct()->get_physical_file_id());
82056 :
82057 0 : SgExpression* expression = isSgExpression(this);
82058 0 : if (expression != NULL && expression->get_operatorPosition() != NULL)
82059 : {
82060 0 : expression->get_operatorPosition()->setOutputInCodeGeneration();
82061 0 : ROSE_ASSERT(expression->get_operatorPosition()->get_physical_file_id() == get_endOfConstruct()->get_physical_file_id());
82062 : }
82063 :
82064 : // Return any one of these since they are all checked to be equal.
82065 0 : return get_startOfConstruct()->get_physical_file_id();
82066 : }
82067 :
82068 :
82069 : #if 0
82070 : SgLocatedNode::~SgLocatedNode()
82071 : {
82072 : // Some expressions are initialized with NULL_FILE (which is a null Sg_File_Info pointer)
82073 : // so we can't assert that p_file_info != NULL.
82074 : // ROSE_ASSERT(p_file_info != NULL);
82075 :
82076 : #if 0
82077 : // At the moment uncommenting this will cause SAGE 3 to crash
82078 : // (SAGE 2 never tried to cleanup memory leaks and is it not
82079 : // done well in SAGE 3 yet either, though it is started).
82080 : ROSE_ASSERT(get_file_info()->getReferenceCount() > 0);
82081 : get_file_info()->decrementReferenceCount();
82082 : if (get_file_info()->getReferenceCount() == 0)
82083 : {
82084 : // We need to add reference counting to Sg_File_Info objects
82085 : // before we can properly cleanup the meory that they allocate
82086 : delete p _ file _ info;
82087 : }
82088 : #endif
82089 :
82090 : // p_file_info = NULL;
82091 : set_startOfConstruct(NULL);
82092 : set_endOfConstruct(NULL);
82093 : }
82094 : #endif
82095 :
82096 : #if 0
82097 : void SgLocatedNode::directives(ostream& os)
82098 : {
82099 : #if 0
82100 : if (p_file_info)
82101 : {
82102 : p_file_info->output(os);
82103 : }
82104 : output_pragma(os);
82105 :
82106 : #if MEIDEBUG
82107 : SgExpression *e=isSgExpression(this);
82108 : if(e && e->get_is_lvalue())
82109 : {
82110 : os << "<a_LVAL>";
82111 : }
82112 : #endif
82113 : #else
82114 : printf ("ERROR: not yet implemented within SAGE3! \n");
82115 : abort();
82116 : #endif
82117 : }
82118 : #endif
82119 :
82120 : #if 0
82121 : void
82122 : SgLocatedNode::setlineNumber(unsigned long new_line)
82123 : {
82124 : if (p_file_info == 0)
82125 : {
82126 : p_file_info = new Sg_File_Info(0, new_line, 0);
82127 : }
82128 : else
82129 : {
82130 : p_file_info->set_line(new_line);
82131 : }
82132 : }
82133 : #endif
82134 :
82135 : #if 0
82136 : void
82137 : SgLocatedNode::delete_file_info()
82138 : {
82139 : if (p_file_info != 0)
82140 : {
82141 : p_file_info->deregister_node(this);
82142 : p_file_info = 0;
82143 : }
82144 : }
82145 : #endif
82146 :
82147 : #if 0
82148 : bool
82149 : SgLocatedNode::_print(int depth) const
82150 : {
82151 : if (SgNode::_print(depth))
82152 : {
82153 : Sg_print_info().output_field(get_file_info(),depth+1);
82154 : return true;
82155 : }
82156 :
82157 : return false;
82158 : }
82159 : #endif
82160 :
82161 : // [MK] Member function to attach PreprocessingInfo object to the node
82162 : void
82163 2405 : SgLocatedNode::addToAttachedPreprocessingInfo(
82164 : PreprocessingInfo *prepInfoPtr,
82165 : // PositionOfPreprocessingInfoInListType locationInList )
82166 : PreprocessingInfo::RelativePositionType locationInList )
82167 : {
82168 : // DQ (11/23/2008): Is this comment still true? Is there something to fix here?
82169 : // There are places in ROSE where the comments is added before the statement
82170 : // though most commonly the comment is added after the statement. So I think that
82171 : // this interface is required adn that it need not be fixed.
82172 :
82173 : // DQ (9/19/2003)
82174 : // This function takes a PreprocessingInfo::RelativePositionType type parameter which
82175 : // makes no since because it is used only to determine if the new comment/directive is
82176 : // added to the front or back of the current list of comments/directives. It does not
82177 : // change the value of the PreprocessingInfo::RelativePositionType field in the
82178 : // PreprocessingInfo object that it takes for the other parameter (nor should it).
82179 : // This function was poorly desinged in the first place and needs to be fixed!!!
82180 : // printf ("In LocatedNode::addToAttachedPreprocessingInfo(PreprocessingInfo,PreprocessingInfo::RelativePositionType): FIX INTERFACE!!!! \n");
82181 :
82182 2405 : ROSE_ASSERT(prepInfoPtr != NULL);
82183 :
82184 : #if 0
82185 : printf ("In SgLocatedNode::addToAttachedPreprocessingInfo(): Current node %p is a %s: prepInfoPtr->getString() = %s \n",this,class_name().c_str(),prepInfoPtr->getString().c_str());
82186 : #endif
82187 :
82188 : // Nodes that should not have comments attached (since they are not unparsed)
82189 :
82190 : // DQ (1/28/2013): Now that we correctly handle the source position for SgForInitStatement,
82191 : // I think we can allow CPP directives and comments to be attached to this IR node (failed
82192 : // for Zsh: params.c). Now tested using test2013_48.C, though comments not output precisely.
82193 : // ROSE_ASSERT (dynamic_cast<SgForInitStatement*>(this) == NULL);
82194 :
82195 2405 : ROSE_ASSERT (dynamic_cast<SgTypedefSeq*>(this) == NULL);
82196 2405 : ROSE_ASSERT (dynamic_cast<SgCatchStatementSeq*>(this) == NULL);
82197 :
82198 : // These should not be used but are are least handled in the unparser (if not debugged)
82199 : // ROSE_ASSERT (dynamic_cast<SgFunctionParameterList*>(this) == NULL);
82200 2405 : ROSE_ASSERT (dynamic_cast<SgCtorInitializerList*>(this) == NULL);
82201 :
82202 2405 : SgFunctionParameterList* functionParameterList = isSgFunctionParameterList(this);
82203 2405 : if (functionParameterList != NULL)
82204 : {
82205 : #if 0
82206 : // DQ (10/8/2012): Commented out to provide less output spew.
82207 : printf ("SgFunctionParameterList are not typically associated with comments or CPP directives \n");
82208 : #endif
82209 0 : ROSE_ASSERT(get_startOfConstruct() != NULL);
82210 0 : ROSE_ASSERT(get_endOfConstruct() != NULL);
82211 : }
82212 :
82213 : // Create data structure for storing the attached PreprocessingInfo objects, if necessary
82214 2405 : if (p_attachedPreprocessingInfoPtr == NULL)
82215 : {
82216 1179 : p_attachedPreprocessingInfoPtr = new AttachedPreprocessingInfoType;
82217 1179 : ROSE_ASSERT(p_attachedPreprocessingInfoPtr != NULL);
82218 : }
82219 :
82220 : #if 0
82221 : printf ("In SgLocatedNode::addToAttachedPreprocessingInfo(): locationInList = %s \n",PreprocessingInfo::relativePositionName(locationInList).c_str());
82222 : #endif
82223 :
82224 : #if 0
82225 : // DQ (4/22/2020): Check to see if we are adding a comment of CPP directive redundantly.
82226 :
82227 : printf ("Output the associated comments and CPP directives for this IR node: \n");
82228 :
82229 : AttachedPreprocessingInfoType *tmp_prepInfoPtr = this->getAttachedPreprocessingInfo();
82230 : AttachedPreprocessingInfoType::iterator i;
82231 : for (i = tmp_prepInfoPtr->begin(); i != tmp_prepInfoPtr->end(); ++i)
82232 : {
82233 : // i is a pointer to the current prepInfo object, print current preprocessing info
82234 : // Assert that i points to a valid preprocssingInfo object
82235 : ROSE_ASSERT ((*i) != NULL);
82236 : ROSE_ASSERT ((*i)->getTypeOfDirective() != PreprocessingInfo::CpreprocessorUnknownDeclaration);
82237 : ROSE_ASSERT ((*i)->getRelativePosition() == PreprocessingInfo::before ||
82238 : (*i)->getRelativePosition() == PreprocessingInfo::after ||
82239 : (*i)->getRelativePosition() == PreprocessingInfo::inside);
82240 :
82241 : // DQ (1/28/2013): Fixed to use output of PreprocessingInfo::relativePositionName() and thus provide more accurate debug information.
82242 : printf (" --- Stored comment: (*i)->getRelativePosition() = %s (*i)->getString() = %s \n",
82243 : // ((*i)->getRelativePosition() == PreprocessingInfo::before) ? "before" : "after",
82244 : PreprocessingInfo::relativePositionName((*i)->getRelativePosition()).c_str(),
82245 : (*i)->getString().c_str());
82246 :
82247 : // DQ (2/27/2019): Adding support for multi-file handling.
82248 : // printf (" --- --- SgUnparse_Info: filename = %s \n",info.get_current_source_file()->getFileName().c_str());
82249 : // printf (" --- --- file_id = %d line = %d filename = %s \n",(*i)->getFileId(),(*i)->getLineNumber(),(*i)->getFilename().c_str());
82250 : #if 0
82251 : // if (prepInfoPtr->getString() == "// The use of \"\" instead of <> forces the current directory (where Simple2.h is located) to be used.")
82252 : // if (prepInfoPtr->getString() == "// Test comment")
82253 : // const size_t found = prepInfoPtr->getString().substr("// Test comment");
82254 : size_t found = prepInfoPtr->getString().find("// Test comment");
82255 : if (found != string::npos)
82256 : {
82257 : printf ("ERROR: found specific comment or CPP directive being added: prepInfoPtr->getString() = %s \n",prepInfoPtr->getString().c_str());
82258 :
82259 : printf ("Exiting as a test! \n");
82260 : ROSE_ASSERT(false);
82261 : }
82262 : #endif
82263 : #if 0
82264 : if (prepInfoPtr->getString() == (*i)->getString())
82265 : {
82266 : printf ("ERROR: redundant comment or CPP directive being added: prepInfoPtr->getString() = %s \n",prepInfoPtr->getString().c_str());
82267 :
82268 : printf ("Exiting as a test! \n");
82269 : ROSE_ASSERT(false);
82270 : }
82271 : #endif
82272 : }
82273 : #endif
82274 :
82275 : // Add the current PreprocessingInfo object
82276 2405 : switch (locationInList)
82277 : {
82278 0 : case PreprocessingInfo::defaultValue:
82279 0 : case PreprocessingInfo::undef:
82280 0 : printf ("Error: defaultValue or undef value found in switch statement \n");
82281 0 : ROSE_ASSERT(false);
82282 : break;
82283 :
82284 7 : case PreprocessingInfo::before:
82285 7 : {
82286 : #if 0
82287 : printf ("p_attachedPreprocessingInfoPtr = %p insert before \n",p_attachedPreprocessingInfoPtr);
82288 : #endif
82289 7 : p_attachedPreprocessingInfoPtr->insert(p_attachedPreprocessingInfoPtr->begin(),prepInfoPtr);
82290 7 : break;
82291 : }
82292 :
82293 2398 : case PreprocessingInfo::after:
82294 2398 : {
82295 : #if 0
82296 : printf ("p_attachedPreprocessingInfoPtr = %p insert after \n",p_attachedPreprocessingInfoPtr);
82297 : #endif
82298 : // (9/10/2003) DQ: Force new comments to be attached closest to the target statement
82299 2398 : p_attachedPreprocessingInfoPtr->push_back(prepInfoPtr);
82300 2398 : break;
82301 : }
82302 :
82303 0 : default:
82304 0 : printf ("Error: default found in switch statement \n");
82305 0 : ROSE_ASSERT(false);
82306 : }
82307 2405 : }
82308 :
82309 :
82310 : // Liao 1/27/2015
82311 : // Insert prepInfo right after (or before) an existing anchor info in the preprocessing info list
82312 : void
82313 0 : SgLocatedNode::insertToAttachedPreprocessingInfo(
82314 : PreprocessingInfo *prepInfoPtr,
82315 : PreprocessingInfo *anchorInfoPtr,
82316 : bool insertAfter /*= true*/
82317 : )
82318 : {
82319 0 : ROSE_ASSERT(prepInfoPtr != NULL);
82320 0 : ROSE_ASSERT(anchorInfoPtr != NULL);
82321 : // This function assumes the list already exists
82322 0 : ROSE_ASSERT (p_attachedPreprocessingInfoPtr != NULL);
82323 :
82324 0 : AttachedPreprocessingInfoType::iterator anchor_iter = find(
82325 0 : p_attachedPreprocessingInfoPtr->begin(), p_attachedPreprocessingInfoPtr->end(), anchorInfoPtr);
82326 :
82327 0 : if (insertAfter )
82328 0 : p_attachedPreprocessingInfoPtr->insert(anchor_iter+1,prepInfoPtr);
82329 : else
82330 0 : p_attachedPreprocessingInfoPtr->insert(anchor_iter, prepInfoPtr);
82331 0 : }
82332 :
82333 :
82334 : // [MK] Member function to return attached PreprocessingInfo objects
82335 : AttachedPreprocessingInfoType*&
82336 785502 : SgLocatedNode::getAttachedPreprocessingInfo(void)
82337 : {
82338 785502 : return p_attachedPreprocessingInfoPtr;
82339 : }
82340 :
82341 : Sg_File_Info*
82342 18378700 : SgLocatedNode::generateMatchingFileInfo()
82343 : {
82344 : // DQ (12/30/2009): Added this function to remove previous global function in large
82345 : // ROSETTA generated file so that we could support smaller ROSETTA generated files.
82346 :
82347 : // DQ (11/20/2004): Modified to provide more accurate information, use the
82348 : // copy constructor instead of the constructor that takes a file name.
82349 : // return new Sg_File_Info( p->get_file_info()->get_filename());
82350 :
82351 : #if 0
82352 : // DQ (1/27/2019): Skipping the generation of a proper symbol when get_startOfConstruct() == NULL
82353 : // so that we can debug the dot graph for a symbol withouth proper basis.
82354 :
82355 : // DQ (11/6/2006): startOfConstruct is the one Sg_File_Info that will always exist and must exist.
82356 : // ROSE_ASSERT(get_startOfConstruct() != NULL);
82357 : Sg_File_Info* returnFileInfo = NULL;
82358 : if (get_startOfConstruct() != NULL)
82359 : {
82360 : returnFileInfo = new Sg_File_Info(*(get_startOfConstruct()));
82361 : }
82362 : else
82363 : {
82364 : printf ("In SgLocatedNode::generateMatchingFileInfo(): Skipping the generation of a proper symbol when get_startOfConstruct() == NULL \n");
82365 : // returnFileInfo = new Sg_File_Info();
82366 : returnFileInfo = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
82367 : }
82368 : ROSE_ASSERT(returnFileInfo != NULL);
82369 : #else
82370 18378700 : ROSE_ASSERT(get_startOfConstruct() != NULL);
82371 18378700 : Sg_File_Info* returnFileInfo = new Sg_File_Info(*(get_startOfConstruct()));
82372 18378700 : ROSE_ASSERT(returnFileInfo != NULL);
82373 : #endif
82374 :
82375 : // printf ("In New_File_Info: returnFileInfo = %p \n",returnFileInfo);
82376 :
82377 18378700 : return returnFileInfo;
82378 : }
82379 :
82380 :
82381 :
82382 : // End of memberFunctionString
82383 : // Start of memberFunctionString
82384 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
82385 :
82386 : // *** COMMON CODE SECTION BEGINS HERE ***
82387 :
82388 : #if 0
82389 : int
82390 : SgLocatedNode::getVariant() const
82391 : {
82392 : // This function is used in ROSE while "variant()" is used in SAGE
82393 : assert(this != NULL);
82394 : return variant();
82395 : }
82396 : #endif
82397 :
82398 : // This function is used in ROSE in treeTraversal code
82399 : // eventually replaces getVariant() and variant()
82400 : // though after variant() has been removed for a while we will
82401 : // want to change the name of variantT() back to variant()
82402 : // (since the "T" was ment to stand for temporary).
82403 : // When this happens the variantT() will be depricated.
82404 : VariantT
82405 35652300 : SgLocatedNode::variantT() const
82406 : {
82407 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
82408 35652300 : ROSE_ASSERT(this != NULL);
82409 35652300 : return V_SgLocatedNode;
82410 : }
82411 :
82412 : #if 0
82413 : int
82414 : SgLocatedNode::variant() const
82415 : {
82416 : // This function is used in SAGE
82417 : ROSE_ASSERT(this != NULL);
82418 : return LocatedNodeTag;
82419 : }
82420 : #endif
82421 :
82422 : ROSE_DLL_API const char*
82423 0 : SgLocatedNode::sage_class_name() const
82424 : {
82425 0 : ROSE_ASSERT(this != NULL);
82426 0 : return "SgLocatedNode";
82427 : }
82428 :
82429 : std::string
82430 0 : SgLocatedNode::class_name() const
82431 : {
82432 0 : ROSE_ASSERT(this != NULL);
82433 0 : return "SgLocatedNode";
82434 : }
82435 :
82436 : // DQ (11/26/2005): Support for visitor pattern mechanims
82437 : // (inferior to ROSE traversal mechanism, experimental).
82438 : void
82439 0 : SgLocatedNode::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
82440 : {
82441 0 : ROSE_ASSERT(this != NULL);
82442 0 : visitor.visit(this);
82443 0 : }
82444 :
82445 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
82446 0 : void SgLocatedNode::accept (ROSE_VisitorPattern & visitor) {
82447 0 : ROSE_ASSERT(this != NULL);
82448 0 : visitor.visit(this);
82449 0 : }
82450 :
82451 : SgLocatedNode*
82452 0 : SgLocatedNode::addRegExpAttribute(std::string s, AstRegExAttribute* a)
82453 : {
82454 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
82455 : // This function is currently only supported for the AST used the represent Binary executables.
82456 : if (0 /* isSgAsmNode(this) != NULL */)
82457 : {
82458 : // Support for regex specification.
82459 : std::string prefixCode = "REGEX:";
82460 : addNewAttribute(prefixCode + s,a);
82461 : }
82462 : #endif
82463 :
82464 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
82465 0 : return this;
82466 : }
82467 :
82468 : // *** COMMON CODE SECTION ENDS HERE ***
82469 :
82470 :
82471 : // End of memberFunctionString
82472 : // Start of memberFunctionString
82473 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
82474 :
82475 :
82476 : #if 0
82477 : //! Error checking support
82478 : /*! Verifies the following:
82479 : - working getVariant() member function
82480 : - calls base class's error() member function
82481 : Every class has one of these functions.
82482 : */
82483 : bool
82484 : SgLocatedNode::error()
82485 : {
82486 : // Put error checking here
82487 :
82488 : ROSE_ASSERT (this != NULL);
82489 : if (getVariant() != LocatedNodeTag)
82490 : {
82491 : printf ("Error in SgLocatedNode::error(): SgLocatedNode object has a %s variant \n",
82492 : Cxx_GrammarTerminalNames[getVariant()].name);
82493 : // printf ("Error in SgLocatedNode::error() \n");
82494 : ROSE_ABORT();
82495 : }
82496 :
82497 : ROSE_ASSERT (getVariant() == LocatedNodeTag);
82498 : return SgNode::error();
82499 : }
82500 : #endif
82501 :
82502 :
82503 :
82504 : // End of memberFunctionString
82505 :
82506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
82507 :
82508 253807000 : SgLocatedNode* isSgLocatedNode ( SgNode* inputDerivedClassPointer )
82509 : {
82510 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
82511 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
82512 : // So to fix this we return NULL directly when the input is NULL and avoid the
82513 : // dynamic_cast in this case. This is likely a performance improvement as well.
82514 : // return dynamic_cast<SgLocatedNode*>(inputDerivedClassPointer);
82515 : // Milind Chabbi (8/28/2013): isSgLocatedNode uses table-driven castability instead of c++ default dynamic_cast
82516 : // this improves the running time performance by 10-20%.
82517 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLocatedNode*>(inputDerivedClassPointer);
82518 253807000 : return IS_SgLocatedNode_FAST_MACRO(inputDerivedClassPointer);
82519 : }
82520 :
82521 : // DQ (11/8/2003): Added version of functions taking const pointer
82522 1659300 : const SgLocatedNode* isSgLocatedNode ( const SgNode* inputDerivedClassPointer )
82523 : {
82524 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
82525 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
82526 : // So to fix this we return NULL directly when the input is NULL and avoid the
82527 : // dynamic_cast in this case. This is likely a performance improvement as well.
82528 : // return dynamic_cast<const SgLocatedNode*>(inputDerivedClassPointer);
82529 : // Milind Chabbi (8/28/2013): isSgLocatedNode uses table-driven castability instead of c++ default dynamic_cast
82530 : // this improves the running time performance by 10-20%.
82531 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLocatedNode*>(inputDerivedClassPointer);
82532 1659300 : return IS_SgLocatedNode_FAST_MACRO(inputDerivedClassPointer);
82533 : }
82534 :
82535 :
82536 :
82537 : /* #line 82538 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
82538 :
82539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
82540 :
82541 : /**
82542 : \brief Generated destructor
82543 :
82544 : This destructor is automatically generated (by ROSETTA). This destructor
82545 : only frees memory of data members associated with the parts of the current IR node which
82546 : are NOT traversed. Those data members that are part of a traversal can be freed using
82547 : a traversal (calling this destructor on all children in a post-order traversal). Such
82548 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
82549 :
82550 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
82551 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
82552 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
82553 :
82554 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
82555 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
82556 : pointers are not yet implemented to call delete on eash pointer in the container.
82557 : (This could be done by derivation from the STL containers to define containers that
82558 : automatically deleted their members.)
82559 :
82560 : */
82561 1538340 : SgLocatedNode::~SgLocatedNode () {
82562 1538340 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
82563 :
82564 1538340 : if (p_startOfConstruct && p_startOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_startOfConstruct; }
82565 1538340 : if (p_endOfConstruct && p_endOfConstruct->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_endOfConstruct; }
82566 :
82567 : // case: not a listType for startOfConstruct
82568 1538340 : p_startOfConstruct = NULL; // non list case
82569 : // case: not a listType for endOfConstruct
82570 1538340 : p_endOfConstruct = NULL; // non list case
82571 : // case: not a listType for attachedPreprocessingInfoPtr
82572 1538340 : p_attachedPreprocessingInfoPtr = NULL; // non list case
82573 : // case: not a listType for attributeMechanism
82574 1538340 : p_attributeMechanism = NULL; // non list case
82575 : // case: not a listType for containsTransformationToSurroundingWhitespace
82576 1538340 : p_containsTransformationToSurroundingWhitespace = false; // non list case
82577 :
82578 : }
82579 :
82580 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
82581 1538340 : }
82582 :
82583 :
82584 : /* #line 82585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
82585 :
82586 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
82587 :
82588 : // Generated constructor
82589 11884100 : SgLocatedNode::SgLocatedNode ( Sg_File_Info* startOfConstruct )
82590 11884100 : : SgNode()
82591 : {
82592 : #ifdef DEBUG
82593 : // printf ("In SgLocatedNode::SgLocatedNode (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
82594 : #endif
82595 : #if 0
82596 : // debugging information!
82597 : printf ("In SgLocatedNode::SgLocatedNode (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
82598 : #endif
82599 :
82600 11884100 : p_startOfConstruct = startOfConstruct;
82601 11884100 : p_endOfConstruct = NULL;
82602 11884100 : p_attachedPreprocessingInfoPtr = NULL;
82603 11884100 : p_attributeMechanism = NULL;
82604 11884100 : p_containsTransformationToSurroundingWhitespace = false;
82605 :
82606 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
82607 :
82608 : #if 0
82609 : // DQ (7/30/2014): Call a virtual function.
82610 : std::string s = this->class_name();
82611 : #endif
82612 :
82613 : // Test the variant virtual function
82614 : // assert(LocatedNodeTag == variant());
82615 11884100 : assert(LocatedNodeTag == this->variant());
82616 11884100 : ROSE_ASSERT(LocatedNodeTag == (int)(this->variantT()));
82617 11884100 : post_construction_initialization();
82618 :
82619 : // Test the isSgLocatedNode() function since it has been problematic
82620 11884100 : assert(isSgLocatedNode(this) != NULL);
82621 11884100 : }
82622 :
82623 : // Generated constructor (all data members)
82624 :
82625 : /* #line 82626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
82626 :
82627 :
82628 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
82629 :
82630 :
82631 : // ********************************************************
82632 : // member functions common across all array grammar objects
82633 : // ********************************************************
82634 :
82635 :
82636 :
82637 : /* #line 82638 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
82638 :
82639 :
82640 :
82641 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
82642 :
82643 : // ********************************************************
82644 : // member functions specific to each node in the grammar
82645 : // ********************************************************
82646 :
82647 :
82648 : /* #line 82649 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
82649 :
82650 : // Start of memberFunctionString
82651 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
82652 :
82653 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
82654 :
82655 : std::string
82656 0 : SgToken::get_lexeme_string () const
82657 : {
82658 0 : ROSE_ASSERT (this != NULL);
82659 :
82660 : #if 0
82661 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
82662 : // used to trigger marking transformations for the token-based unparsing.
82663 : printf ("SgToken::get_lexeme_string = %p = %s \n",this,this->class_name().c_str());
82664 : #endif
82665 :
82666 0 : return p_lexeme_string;
82667 : }
82668 :
82669 : void
82670 0 : SgToken::set_lexeme_string ( std::string lexeme_string )
82671 : {
82672 0 : ROSE_ASSERT (this != NULL);
82673 :
82674 : #if 0
82675 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
82676 : // used to trigger marking transformations for the token-based unparsing.
82677 : printf ("SgToken::set_lexeme_string = %p = %s \n",this,this->class_name().c_str());
82678 : #endif
82679 :
82680 0 : set_isModified(true);
82681 :
82682 0 : p_lexeme_string = lexeme_string;
82683 0 : }
82684 :
82685 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
82686 :
82687 :
82688 : // End of memberFunctionString
82689 : // Start of memberFunctionString
82690 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
82691 :
82692 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
82693 :
82694 : unsigned int
82695 0 : SgToken::get_classification_code () const
82696 : {
82697 0 : ROSE_ASSERT (this != NULL);
82698 :
82699 : #if 0
82700 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
82701 : // used to trigger marking transformations for the token-based unparsing.
82702 : printf ("SgToken::get_classification_code = %p = %s \n",this,this->class_name().c_str());
82703 : #endif
82704 :
82705 0 : return p_classification_code;
82706 : }
82707 :
82708 : void
82709 0 : SgToken::set_classification_code ( unsigned int classification_code )
82710 : {
82711 0 : ROSE_ASSERT (this != NULL);
82712 :
82713 : #if 0
82714 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
82715 : // used to trigger marking transformations for the token-based unparsing.
82716 : printf ("SgToken::set_classification_code = %p = %s \n",this,this->class_name().c_str());
82717 : #endif
82718 :
82719 0 : set_isModified(true);
82720 :
82721 0 : p_classification_code = classification_code;
82722 0 : }
82723 :
82724 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
82725 :
82726 :
82727 : // End of memberFunctionString
82728 : // Start of memberFunctionString
82729 : /* #line 1448 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
82730 :
82731 : /*
82732 : Some assumptions:
82733 : We know that keywords in FORTRAN can be separated by whitespace
82734 : Our lexer handles end if as two identifiers with lexemes "end", "if"
82735 : A later pass can coalese these two identifers into one token
82736 : of type ROSE_IDENTIFIER
82737 : of lexeme "end if"
82738 : Look at the the coalese tokens phase
82739 : */
82740 :
82741 : // DQ (4/14/2007): Modified to use new enum values
82742 : // DQ (3/24/2007): I would like to make this a const array (double check with Rama).
82743 : const SgToken::token_element SgToken::ROSE_Fortran_keyword_map[127] =
82744 : {
82745 : {"abstract", SgToken::FORTRAN_ABSTRACT},
82746 : {"access", SgToken::FORTRAN_ACCESS},
82747 : {"action", SgToken::FORTRAN_ACTION},
82748 : {"abstractinterface", SgToken::FORTRAN_INTERFACE}, /* GFORTRAN/G95 equivalent is ST_INTERFACE */
82749 : {"allocate", SgToken::FORTRAN_ALLOCATE}, /* GFORTRAN/G95 equivalent is ST_ALLOCATE */
82750 : {"allocatable", SgToken::FORTRAN_ALLOCATABLE}, /* GFORTRAN/G95 equivalent is ST_ALLOCATABLE */
82751 : {"assign", SgToken::FORTRAN_ASSIGN}, /* GFORTRAN/G95 equivalent is ST_ASSIGN */
82752 : {"associate", SgToken::FORTRAN_ASSOCIATE},
82753 : {"asynchronous", SgToken::FORTRAN_ASYNCHRONOUS}, /* GFORTRAN/G95 equivalent is ST_ASYNCHRONOUS */
82754 : {"backspace", SgToken::FORTRAN_BACKSPACE}, /* GFORTRAN/G95 equivalent is ST_BACKSPACE */
82755 : {"bind", SgToken::FORTRAN_BIND}, /* GFORTRAN/G95 equivalent is ST_BIND */
82756 : {"blank", SgToken::FORTRAN_BLANK},
82757 : {"blockdata", SgToken::FORTRAN_BLOCK_DATA}, /* GFORTRAN/G95 equivalent is ST_BLOCK_DATA */
82758 : {"call", SgToken::FORTRAN_CALL}, /* GFORTRAN/G95 equivalent is ST_CALL */
82759 : {"character", SgToken::FORTRAN_CHARACTER},
82760 : {"class", SgToken::FORTRAN_CLASS},
82761 : {"close", SgToken::FORTRAN_CLOSE}, /* GFORTRAN/G95 equivalent is ST_CLOSE */
82762 : {"continue", SgToken::FORTRAN_CONTINUE}, /* GFORTRAN/G95 equivalent is ST_CONTINUE */
82763 : {"cycle", SgToken::FORTRAN_CYCLE}, /* GFORTRAN/G95 equivalent is ST_CYCLE */
82764 : {"case", SgToken::FORTRAN_CASE}, /* GFORTRAN/G95 equivalent is ST_CASE */
82765 : {"common", SgToken::FORTRAN_COMMON}, /* GFORTRAN/G95 equivalent is ST_COMMON */
82766 : {"complex", SgToken::FORTRAN_COMPLEX},
82767 : {"contains", SgToken::FORTRAN_CONTAINS}, /* GFORTRAN/G95 equivalent is ST_CONTAINS */
82768 : {"deallocate", SgToken::FORTRAN_DEALLOCATE}, /* GFORTRAN/G95 equivalent is ST_DEALLOCATE */
82769 : {"data", SgToken::FORTRAN_DATA}, /* GFORTRAN/G95 equivalent is ST_DATA */
82770 : {"deferred", SgToken::FORTRAN_DEFERRED},
82771 : {"delim", SgToken::FORTRAN_DELIM},
82772 : {"dimension", SgToken::FORTRAN_DIMENSION}, /* GFORTRAN/G95 equivalent is ST_DIMENSION */
82773 : {"do", SgToken::FORTRAN_DO},
82774 : {"dt", SgToken::FORTRAN_DT},
82775 : {"doubleprecision", SgToken::FORTRAN_DOUBLEPRECISION},
82776 : {"encoding", SgToken::FORTRAN_ENCODING}, /* GFORTRAN/G95 equivalent is ST_END_FILE */
82777 : {"endcase", SgToken::FORTRAN_END_CASE}, /* GFORTRAN/G95 equivalent is ST_END_FILE */
82778 : {"enddo", SgToken::FORTRAN_ENDDO}, /* GFORTRAN/G95 equivalent is ST_END_FILE */
82779 : {"endfile", SgToken::FORTRAN_END_FILE}, /* GFORTRAN/G95 equivalent is ST_END_FILE */
82780 : {"endenum", SgToken::FORTRAN_END_ENUM},
82781 : {"endinterface", SgToken::FORTRAN_END_INTERFACE},
82782 : {"endtype", SgToken::FORTRAN_END_TYPE},
82783 : {"err", SgToken::FORTRAN_ERR},
82784 : {"errmsg", SgToken::FORTRAN_ERRMSG},
82785 : {"exit", SgToken::FORTRAN_EXIT}, /* GFORTRAN/G95 equivalent is ST_EXIT */
82786 : {"else", SgToken::FORTRAN_ELSE}, /* GFORTRAN/G95 equivalent is ST_ELSE */
82787 : {"elsewhere", SgToken::FORTRAN_ELSEWHERE}, /* GFORTRAN/G95 equivalent is ST_ELSEWHERE */
82788 : {"elseif", SgToken::FORTRAN_ELSEIF}, /* GFORTRAN/G95 equivalent is ST_ELSEIF */
82789 : {"endif", SgToken::FORTRAN_ENDIF},
82790 : {"entry% ", SgToken::FORTRAN_ENTRY}, /* GFORTRAN/G95 equivalent is ST_ENTRY */
82791 : {"end", SgToken::FORTRAN_END},
82792 : {"enum", SgToken::FORTRAN_ENUM}, /* GFORTRAN/G95 equivalent is ST_ENUM */
82793 : {"enumerator", SgToken::FORTRAN_ENUMERATOR}, /* GFORTRAN/G95 equivalent is ST_ENUMERATOR */
82794 : {"equivalence", SgToken::FORTRAN_EQUIVALENCE}, /* GFORTRAN/G95 equivalent is ST_EQUIVALENCE */
82795 : {"external", SgToken::FORTRAN_EXTERNAL}, /* GFORTRAN/G95 equivalent is ST_EXTERNAL */
82796 : {"extends", SgToken::FORTRAN_EXTENDS},
82797 : {"file", SgToken::FORTRAN_FILE},
82798 : {"final", SgToken::FORTRAN_FINAL}, /* GFORTRAN/G95 equivalent is ST_FORALL */
82799 : {"fmt", SgToken::FORTRAN_FMT}, /* GFORTRAN/G95 equivalent is ST_FORALL */
82800 : {"forall", SgToken::FORTRAN_FORALL}, /* GFORTRAN/G95 equivalent is ST_FORALL */
82801 : {"form", SgToken::FORTRAN_FORM},
82802 : {"formatted", SgToken::FORTRAN_FORMATTED},
82803 : {"format", SgToken::FORTRAN_FORMAT}, /* GFORTRAN/G95 equivalent is ST_FORMAT */
82804 : {"flush", SgToken::FORTRAN_FLUSH}, /* GFORTRAN/G95 equivalent is ST_FLUSH */
82805 : {"function", SgToken::FORTRAN_FUNCTION},
82806 : {"generic", SgToken::FORTRAN_GENERIC}, /* GFORTRAN/G95 equivalent is ST_GOTO */
82807 : {"goto", SgToken::FORTRAN_GOTO}, /* GFORTRAN/G95 equivalent is ST_GOTO */
82808 : {"id", SgToken::FORTRAN_ID}, /* GFORTRAN/G95 equivalent is ST_IF, */
82809 : {"if", SgToken::FORTRAN_IF}, /* GFORTRAN/G95 equivalent is ST_IF, */
82810 : {"inquire", SgToken::FORTRAN_INQUIRE}, /* GFORTRAN/G95 equivalent is ST_INQUIRE */
82811 : {"integer", SgToken::FORTRAN_INTEGER}, /* GFORTRAN/G95 equivalent is ST_INQUIRE */
82812 : {"iomsg", SgToken::FORTRAN_IOMSG},
82813 : {"iostat", SgToken::FORTRAN_IOSTAT},
82814 : {"implicit", SgToken::FORTRAN_IMPLICIT}, /* GFORTRAN/G95 equivalent is ST_IMPLICIT */
82815 : {"implicitnone", SgToken::FORTRAN_IMPLICIT_NONE}, /* GFORTRAN/G95 equivalent is ST_IMPLICIT_NONE */
82816 : {"import", SgToken::FORTRAN_IMPORT}, /* GFORTRAN/G95 equivalent is ST_IMPORT */
82817 : {"interface", SgToken::FORTRAN_INTERFACE}, /* GFORTRAN/G95 equivalent is ST_INTERFACE */
82818 : {"intent", SgToken::FORTRAN_INTENT}, /* GFORTRAN/G95 equivalent is ST_INTENT */
82819 : {"intrinsic", SgToken::FORTRAN_INTRINSIC}, /* GFORTRAN/G95 equivalent is ST_INTRINSIC */
82820 : {"len", SgToken::FORTRAN_LEN},
82821 : {"logical", SgToken::FORTRAN_LOGICAL},
82822 : {"kind", SgToken::FORTRAN_KIND},
82823 : {"moduleprocedure", SgToken::FORTRAN_MODULE_PROC}, /* GFORTRAN/G95 equivalent is ST_E_MODULE_PROC */
82824 : {"module", SgToken::FORTRAN_MODULE}, /* GFORTRAN/G95 equivalent is ST_MODULE */
82825 : {"non_intrinsic", SgToken::FORTRAN_NON_INTRINSIC}, /* GFORTRAN/G95 equivalent is ST_NULLIFY */
82826 : {"non_overridable", SgToken::FORTRAN_NON_OVERRIDABLE}, /* GFORTRAN/G95 equivalent is ST_NULLIFY */
82827 : {"null", SgToken::FORTRAN_NULL},
82828 : {"nullify", SgToken::FORTRAN_NULLIFY}, /* GFORTRAN/G95 equivalent is ST_NULLIFY */
82829 : {"namelist", SgToken::FORTRAN_NAMELIST}, /* GFORTRAN/G95 equivalent is ST_NAMELIST */
82830 : {"nml", SgToken::FORTRAN_NML},
82831 : {"none", SgToken::FORTRAN_NONE}, /* GFORTRAN/G95 equivalent is ST_NONE */
82832 : {"nopass", SgToken::FORTRAN_NOPASS},
82833 : {"only", SgToken::FORTRAN_ONLY}, /* GFORTRAN/G95 equivalent is ST_OPEN */
82834 : {"open", SgToken::FORTRAN_OPEN}, /* GFORTRAN/G95 equivalent is ST_OPEN */
82835 : {"optional", SgToken::FORTRAN_OPTIONAL}, /* GFORTRAN/G95 equivalent is ST_OPTIONAL */
82836 : {"parameter", SgToken::FORTRAN_PARAMETER}, /* GFORTRAN/G95 equivalent is ST_PARAMETER */
82837 : {"pass", SgToken::FORTRAN_PASS},
82838 : {"pause", SgToken::FORTRAN_PAUSE}, /* GFORTRAN/G95 equivalent is ST_PAUSE */
82839 : {"pointer", SgToken::FORTRAN_POINTER}, /* GFORTRAN/G95 equivalent is ST_POINTER */
82840 : {"print", SgToken::FORTRAN_PRINT}, /* GFORTRAN/G95 equivalent is ST_PRINT */
82841 : {"private", SgToken::FORTRAN_PRIVATE}, /* GFORTRAN/G95 equivalent is ST_PRINT */
82842 : {"procedure", SgToken::FORTRAN_PROCEDURE}, /* GFORTRAN/G95 equivalent is ST_DATA_DECL */
82843 : {"program", SgToken::FORTRAN_PROGRAM}, /* GFORTRAN/G95 equivalent is ST_PROGRAM */
82844 : {"protected", SgToken::FORTRAN_PROTECTED}, /* GFORTRAN/G95 equivalent is ST_DATA_DECL */
82845 : {"read", SgToken::FORTRAN_READ}, /* GFORTRAN/G95 equivalent is ST_READ */
82846 : {"real", SgToken::FORTRAN_REAL},
82847 : {"return", SgToken::FORTRAN_RETURN}, /* GFORTRAN/G95 equivalent is ST_RETURN */
82848 : {"rewind", SgToken::FORTRAN_REWIND}, /* GFORTRAN/G95 equivalent is ST_REWIND */
82849 : {"round", SgToken::FORTRAN_ROUND},
82850 : {"selectcase", SgToken::FORTRAN_SELECTCASE},
82851 : {"selecttype", SgToken::FORTRAN_SELECTTYPE},
82852 : {"sequence", SgToken::FORTRAN_SEQUENCE}, /* GFORTRAN/G95 equivalent is ST_SEQUENCE */
82853 : {"save", SgToken::FORTRAN_SAVE}, /* GFORTRAN/G95 equivalent is ST_SAVE */
82854 : {"sign", SgToken::FORTRAN_SIGN},
82855 : {"size", SgToken::FORTRAN_SIZE},
82856 : {"source", SgToken::FORTRAN_SOURCE}, /* GFORTRAN/G95 equivalent is ST_SAVE */
82857 : {"stat", SgToken::FORTRAN_STAT},
82858 : {"stop", SgToken::FORTRAN_STOP}, /* GFORTRAN/G95 equivalent is ST_STOP */
82859 : {"subroutine", SgToken::FORTRAN_SUBROUTINE},
82860 : {"target", SgToken::FORTRAN_TARGET}, /* GFORTRAN/G95 equivalent is ST_TARGET */
82861 : {"then", SgToken::FORTRAN_THEN},
82862 : {"type", SgToken::FORTRAN_DERIVED_DECL}, /* GFORTRAN/G95 equivalent is ST_DERIVED_DECL */
82863 : {"typeis", SgToken::FORTRAN_TYPEIS},
82864 : {"unformatted", SgToken::FORTRAN_UNFORMATTED},
82865 : {"unit", SgToken::FORTRAN_UNIT},
82866 : {"use", SgToken::FORTRAN_USE}, /* GFORTRAN/G95 equivalent is ST_USE */
82867 : {"value", SgToken::FORTRAN_VALUE}, /* GFORTRAN/G95 equivalent is ST_VALUE */
82868 : {"volatile", SgToken::FORTRAN_VOLATILE}, /* GFORTRAN/G95 equivalent is ST_VOLATILE */
82869 : {"wait", SgToken::FORTRAN_WAIT}, /* GFORTRAN/G95 equivalent is ST_WAIT */
82870 : {"where", SgToken::FORTRAN_WHERE}, /* GFORTRAN/G95 equivalent is ST_WHERE, */
82871 : {"write", SgToken::FORTRAN_WRITE} /* GFORTRAN/G95 equivalent is ST_WRITE */
82872 : };
82873 :
82874 :
82875 : bool
82876 0 : SgToken::isCarriageReturn() const
82877 : {
82878 : // DQ (11/20/2015): Added function to detect CR to support unparsing of whitespace defined up to an including only the first CR.
82879 0 : return (get_lexeme_string() == "\n");
82880 : }
82881 :
82882 :
82883 :
82884 : // End of memberFunctionString
82885 : // Start of memberFunctionString
82886 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
82887 :
82888 : // *** COMMON CODE SECTION BEGINS HERE ***
82889 :
82890 : #if 0
82891 : int
82892 : SgToken::getVariant() const
82893 : {
82894 : // This function is used in ROSE while "variant()" is used in SAGE
82895 : assert(this != NULL);
82896 : return variant();
82897 : }
82898 : #endif
82899 :
82900 : // This function is used in ROSE in treeTraversal code
82901 : // eventually replaces getVariant() and variant()
82902 : // though after variant() has been removed for a while we will
82903 : // want to change the name of variantT() back to variant()
82904 : // (since the "T" was ment to stand for temporary).
82905 : // When this happens the variantT() will be depricated.
82906 : VariantT
82907 0 : SgToken::variantT() const
82908 : {
82909 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
82910 0 : ROSE_ASSERT(this != NULL);
82911 0 : return V_SgToken;
82912 : }
82913 :
82914 : #if 0
82915 : int
82916 : SgToken::variant() const
82917 : {
82918 : // This function is used in SAGE
82919 : ROSE_ASSERT(this != NULL);
82920 : return TOKEN;
82921 : }
82922 : #endif
82923 :
82924 : ROSE_DLL_API const char*
82925 0 : SgToken::sage_class_name() const
82926 : {
82927 0 : ROSE_ASSERT(this != NULL);
82928 0 : return "SgToken";
82929 : }
82930 :
82931 : std::string
82932 0 : SgToken::class_name() const
82933 : {
82934 0 : ROSE_ASSERT(this != NULL);
82935 0 : return "SgToken";
82936 : }
82937 :
82938 : // DQ (11/26/2005): Support for visitor pattern mechanims
82939 : // (inferior to ROSE traversal mechanism, experimental).
82940 : void
82941 0 : SgToken::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
82942 : {
82943 0 : ROSE_ASSERT(this != NULL);
82944 0 : visitor.visit(this);
82945 0 : }
82946 :
82947 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
82948 0 : void SgToken::accept (ROSE_VisitorPattern & visitor) {
82949 0 : ROSE_ASSERT(this != NULL);
82950 0 : visitor.visit(this);
82951 0 : }
82952 :
82953 : SgToken*
82954 0 : SgToken::addRegExpAttribute(std::string s, AstRegExAttribute* a)
82955 : {
82956 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
82957 : // This function is currently only supported for the AST used the represent Binary executables.
82958 : if (0 /* isSgAsmNode(this) != NULL */)
82959 : {
82960 : // Support for regex specification.
82961 : std::string prefixCode = "REGEX:";
82962 : addNewAttribute(prefixCode + s,a);
82963 : }
82964 : #endif
82965 :
82966 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
82967 0 : return this;
82968 : }
82969 :
82970 : // *** COMMON CODE SECTION ENDS HERE ***
82971 :
82972 :
82973 : // End of memberFunctionString
82974 : // Start of memberFunctionString
82975 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
82976 :
82977 :
82978 : #if 0
82979 : //! Error checking support
82980 : /*! Verifies the following:
82981 : - working getVariant() member function
82982 : - calls base class's error() member function
82983 : Every class has one of these functions.
82984 : */
82985 : bool
82986 : SgToken::error()
82987 : {
82988 : // Put error checking here
82989 :
82990 : ROSE_ASSERT (this != NULL);
82991 : if (getVariant() != TOKEN)
82992 : {
82993 : printf ("Error in SgToken::error(): SgToken object has a %s variant \n",
82994 : Cxx_GrammarTerminalNames[getVariant()].name);
82995 : // printf ("Error in SgToken::error() \n");
82996 : ROSE_ABORT();
82997 : }
82998 :
82999 : ROSE_ASSERT (getVariant() == TOKEN);
83000 : return SgLocatedNode::error();
83001 : }
83002 : #endif
83003 :
83004 :
83005 :
83006 : // End of memberFunctionString
83007 :
83008 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
83009 :
83010 963683 : SgToken* isSgToken ( SgNode* inputDerivedClassPointer )
83011 : {
83012 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
83013 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
83014 : // So to fix this we return NULL directly when the input is NULL and avoid the
83015 : // dynamic_cast in this case. This is likely a performance improvement as well.
83016 : // return dynamic_cast<SgToken*>(inputDerivedClassPointer);
83017 : // Milind Chabbi (8/28/2013): isSgToken uses table-driven castability instead of c++ default dynamic_cast
83018 : // this improves the running time performance by 10-20%.
83019 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgToken*>(inputDerivedClassPointer);
83020 963683 : return IS_SgToken_FAST_MACRO(inputDerivedClassPointer);
83021 : }
83022 :
83023 : // DQ (11/8/2003): Added version of functions taking const pointer
83024 0 : const SgToken* isSgToken ( const SgNode* inputDerivedClassPointer )
83025 : {
83026 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
83027 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
83028 : // So to fix this we return NULL directly when the input is NULL and avoid the
83029 : // dynamic_cast in this case. This is likely a performance improvement as well.
83030 : // return dynamic_cast<const SgToken*>(inputDerivedClassPointer);
83031 : // Milind Chabbi (8/28/2013): isSgToken uses table-driven castability instead of c++ default dynamic_cast
83032 : // this improves the running time performance by 10-20%.
83033 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgToken*>(inputDerivedClassPointer);
83034 0 : return IS_SgToken_FAST_MACRO(inputDerivedClassPointer);
83035 : }
83036 :
83037 :
83038 :
83039 : /* #line 83040 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83040 :
83041 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
83042 :
83043 : /**
83044 : \brief Generated destructor
83045 :
83046 : This destructor is automatically generated (by ROSETTA). This destructor
83047 : only frees memory of data members associated with the parts of the current IR node which
83048 : are NOT traversed. Those data members that are part of a traversal can be freed using
83049 : a traversal (calling this destructor on all children in a post-order traversal). Such
83050 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
83051 :
83052 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
83053 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
83054 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
83055 :
83056 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
83057 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
83058 : pointers are not yet implemented to call delete on eash pointer in the container.
83059 : (This could be done by derivation from the STL containers to define containers that
83060 : automatically deleted their members.)
83061 :
83062 : */
83063 0 : SgToken::~SgToken () {
83064 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
83065 :
83066 :
83067 : // case: not a listType for lexeme_string
83068 0 : p_lexeme_string = ""; // non list case
83069 : // case: not a listType for classification_code
83070 0 : p_classification_code = 0; // non list case
83071 :
83072 : }
83073 :
83074 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
83075 0 : }
83076 :
83077 :
83078 : /* #line 83079 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83079 :
83080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
83081 :
83082 : // Generated constructor
83083 0 : SgToken::SgToken ( Sg_File_Info* startOfConstruct, std::string lexeme_string, unsigned int classification_code )
83084 0 : : SgLocatedNode(startOfConstruct)
83085 : {
83086 : #ifdef DEBUG
83087 : // printf ("In SgToken::SgToken (Sg_File_Info* startOfConstruct, std::string lexeme_string, unsigned int classification_code) sage_class_name() = %s \n",sage_class_name());
83088 : #endif
83089 : #if 0
83090 : // debugging information!
83091 : printf ("In SgToken::SgToken (Sg_File_Info* startOfConstruct, std::string lexeme_string, unsigned int classification_code): this = %p = %s \n",this,this->class_name().c_str());
83092 : #endif
83093 :
83094 0 : p_lexeme_string = lexeme_string;
83095 0 : p_classification_code = classification_code;
83096 :
83097 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
83098 :
83099 : #if 0
83100 : // DQ (7/30/2014): Call a virtual function.
83101 : std::string s = this->class_name();
83102 : #endif
83103 :
83104 : // Test the variant virtual function
83105 : // assert(TOKEN == variant());
83106 0 : assert(TOKEN == this->variant());
83107 0 : ROSE_ASSERT(TOKEN == (int)(this->variantT()));
83108 0 : post_construction_initialization();
83109 :
83110 : // Test the isSgToken() function since it has been problematic
83111 0 : assert(isSgToken(this) != NULL);
83112 0 : }
83113 :
83114 : // Generated constructor (all data members)
83115 :
83116 : /* #line 83117 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83117 :
83118 :
83119 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
83120 :
83121 :
83122 : // ********************************************************
83123 : // member functions common across all array grammar objects
83124 : // ********************************************************
83125 :
83126 :
83127 :
83128 : /* #line 83129 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83129 :
83130 :
83131 :
83132 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
83133 :
83134 : // ********************************************************
83135 : // member functions specific to each node in the grammar
83136 : // ********************************************************
83137 :
83138 :
83139 : /* #line 83140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83140 :
83141 : // Start of memberFunctionString
83142 : /* #line 1602 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
83143 :
83144 :
83145 :
83146 : // End of memberFunctionString
83147 : // Start of memberFunctionString
83148 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
83149 :
83150 : // *** COMMON CODE SECTION BEGINS HERE ***
83151 :
83152 : #if 0
83153 : int
83154 : SgLocatedNodeSupport::getVariant() const
83155 : {
83156 : // This function is used in ROSE while "variant()" is used in SAGE
83157 : assert(this != NULL);
83158 : return variant();
83159 : }
83160 : #endif
83161 :
83162 : // This function is used in ROSE in treeTraversal code
83163 : // eventually replaces getVariant() and variant()
83164 : // though after variant() has been removed for a while we will
83165 : // want to change the name of variantT() back to variant()
83166 : // (since the "T" was ment to stand for temporary).
83167 : // When this happens the variantT() will be depricated.
83168 : VariantT
83169 19121600 : SgLocatedNodeSupport::variantT() const
83170 : {
83171 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
83172 19121600 : ROSE_ASSERT(this != NULL);
83173 19121600 : return V_SgLocatedNodeSupport;
83174 : }
83175 :
83176 : #if 0
83177 : int
83178 : SgLocatedNodeSupport::variant() const
83179 : {
83180 : // This function is used in SAGE
83181 : ROSE_ASSERT(this != NULL);
83182 : return LocatedNodeSupportTag;
83183 : }
83184 : #endif
83185 :
83186 : ROSE_DLL_API const char*
83187 0 : SgLocatedNodeSupport::sage_class_name() const
83188 : {
83189 0 : ROSE_ASSERT(this != NULL);
83190 0 : return "SgLocatedNodeSupport";
83191 : }
83192 :
83193 : std::string
83194 0 : SgLocatedNodeSupport::class_name() const
83195 : {
83196 0 : ROSE_ASSERT(this != NULL);
83197 0 : return "SgLocatedNodeSupport";
83198 : }
83199 :
83200 : // DQ (11/26/2005): Support for visitor pattern mechanims
83201 : // (inferior to ROSE traversal mechanism, experimental).
83202 : void
83203 0 : SgLocatedNodeSupport::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
83204 : {
83205 0 : ROSE_ASSERT(this != NULL);
83206 0 : visitor.visit(this);
83207 0 : }
83208 :
83209 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
83210 0 : void SgLocatedNodeSupport::accept (ROSE_VisitorPattern & visitor) {
83211 0 : ROSE_ASSERT(this != NULL);
83212 0 : visitor.visit(this);
83213 0 : }
83214 :
83215 : SgLocatedNodeSupport*
83216 0 : SgLocatedNodeSupport::addRegExpAttribute(std::string s, AstRegExAttribute* a)
83217 : {
83218 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
83219 : // This function is currently only supported for the AST used the represent Binary executables.
83220 : if (0 /* isSgAsmNode(this) != NULL */)
83221 : {
83222 : // Support for regex specification.
83223 : std::string prefixCode = "REGEX:";
83224 : addNewAttribute(prefixCode + s,a);
83225 : }
83226 : #endif
83227 :
83228 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
83229 0 : return this;
83230 : }
83231 :
83232 : // *** COMMON CODE SECTION ENDS HERE ***
83233 :
83234 :
83235 : // End of memberFunctionString
83236 : // Start of memberFunctionString
83237 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
83238 :
83239 :
83240 : #if 0
83241 : //! Error checking support
83242 : /*! Verifies the following:
83243 : - working getVariant() member function
83244 : - calls base class's error() member function
83245 : Every class has one of these functions.
83246 : */
83247 : bool
83248 : SgLocatedNodeSupport::error()
83249 : {
83250 : // Put error checking here
83251 :
83252 : ROSE_ASSERT (this != NULL);
83253 : if (getVariant() != LocatedNodeSupportTag)
83254 : {
83255 : printf ("Error in SgLocatedNodeSupport::error(): SgLocatedNodeSupport object has a %s variant \n",
83256 : Cxx_GrammarTerminalNames[getVariant()].name);
83257 : // printf ("Error in SgLocatedNodeSupport::error() \n");
83258 : ROSE_ABORT();
83259 : }
83260 :
83261 : ROSE_ASSERT (getVariant() == LocatedNodeSupportTag);
83262 : return SgLocatedNode::error();
83263 : }
83264 : #endif
83265 :
83266 :
83267 :
83268 : // End of memberFunctionString
83269 :
83270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
83271 :
83272 6373860 : SgLocatedNodeSupport* isSgLocatedNodeSupport ( SgNode* inputDerivedClassPointer )
83273 : {
83274 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
83275 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
83276 : // So to fix this we return NULL directly when the input is NULL and avoid the
83277 : // dynamic_cast in this case. This is likely a performance improvement as well.
83278 : // return dynamic_cast<SgLocatedNodeSupport*>(inputDerivedClassPointer);
83279 : // Milind Chabbi (8/28/2013): isSgLocatedNodeSupport uses table-driven castability instead of c++ default dynamic_cast
83280 : // this improves the running time performance by 10-20%.
83281 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLocatedNodeSupport*>(inputDerivedClassPointer);
83282 6373860 : return IS_SgLocatedNodeSupport_FAST_MACRO(inputDerivedClassPointer);
83283 : }
83284 :
83285 : // DQ (11/8/2003): Added version of functions taking const pointer
83286 1659260 : const SgLocatedNodeSupport* isSgLocatedNodeSupport ( const SgNode* inputDerivedClassPointer )
83287 : {
83288 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
83289 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
83290 : // So to fix this we return NULL directly when the input is NULL and avoid the
83291 : // dynamic_cast in this case. This is likely a performance improvement as well.
83292 : // return dynamic_cast<const SgLocatedNodeSupport*>(inputDerivedClassPointer);
83293 : // Milind Chabbi (8/28/2013): isSgLocatedNodeSupport uses table-driven castability instead of c++ default dynamic_cast
83294 : // this improves the running time performance by 10-20%.
83295 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLocatedNodeSupport*>(inputDerivedClassPointer);
83296 1659260 : return IS_SgLocatedNodeSupport_FAST_MACRO(inputDerivedClassPointer);
83297 : }
83298 :
83299 :
83300 :
83301 : /* #line 83302 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83302 :
83303 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
83304 :
83305 : /**
83306 : \brief Generated destructor
83307 :
83308 : This destructor is automatically generated (by ROSETTA). This destructor
83309 : only frees memory of data members associated with the parts of the current IR node which
83310 : are NOT traversed. Those data members that are part of a traversal can be freed using
83311 : a traversal (calling this destructor on all children in a post-order traversal). Such
83312 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
83313 :
83314 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
83315 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
83316 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
83317 :
83318 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
83319 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
83320 : pointers are not yet implemented to call delete on eash pointer in the container.
83321 : (This could be done by derivation from the STL containers to define containers that
83322 : automatically deleted their members.)
83323 :
83324 : */
83325 110459 : SgLocatedNodeSupport::~SgLocatedNodeSupport () {
83326 110459 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
83327 :
83328 :
83329 :
83330 : }
83331 :
83332 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
83333 110459 : }
83334 :
83335 :
83336 : /* #line 83337 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83337 :
83338 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
83339 :
83340 : // Generated constructor
83341 40 : SgLocatedNodeSupport::SgLocatedNodeSupport ( Sg_File_Info* startOfConstruct )
83342 40 : : SgLocatedNode(startOfConstruct)
83343 : {
83344 : #ifdef DEBUG
83345 : // printf ("In SgLocatedNodeSupport::SgLocatedNodeSupport (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
83346 : #endif
83347 : #if 0
83348 : // debugging information!
83349 : printf ("In SgLocatedNodeSupport::SgLocatedNodeSupport (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
83350 : #endif
83351 :
83352 :
83353 :
83354 : #if 0
83355 : // DQ (7/30/2014): Call a virtual function.
83356 : std::string s = this->class_name();
83357 : #endif
83358 :
83359 : // Test the variant virtual function
83360 : // assert(LocatedNodeSupportTag == variant());
83361 40 : assert(LocatedNodeSupportTag == this->variant());
83362 40 : ROSE_ASSERT(LocatedNodeSupportTag == (int)(this->variantT()));
83363 40 : post_construction_initialization();
83364 :
83365 : // Test the isSgLocatedNodeSupport() function since it has been problematic
83366 40 : assert(isSgLocatedNodeSupport(this) != NULL);
83367 40 : }
83368 :
83369 : // Generated constructor (all data members)
83370 :
83371 : /* #line 83372 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83372 :
83373 :
83374 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
83375 :
83376 :
83377 : // ********************************************************
83378 : // member functions common across all array grammar objects
83379 : // ********************************************************
83380 :
83381 :
83382 :
83383 : /* #line 83384 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83384 :
83385 :
83386 :
83387 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
83388 :
83389 : // ********************************************************
83390 : // member functions specific to each node in the grammar
83391 : // ********************************************************
83392 :
83393 :
83394 : /* #line 83395 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83395 :
83396 : // Start of memberFunctionString
83397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83398 :
83399 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83400 :
83401 : std::string
83402 7 : SgCommonBlockObject::get_block_name () const
83403 : {
83404 7 : ROSE_ASSERT (this != NULL);
83405 :
83406 : #if 0
83407 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83408 : // used to trigger marking transformations for the token-based unparsing.
83409 : printf ("SgCommonBlockObject::get_block_name = %p = %s \n",this,this->class_name().c_str());
83410 : #endif
83411 :
83412 7 : return p_block_name;
83413 : }
83414 :
83415 : void
83416 6 : SgCommonBlockObject::set_block_name ( std::string block_name )
83417 : {
83418 6 : ROSE_ASSERT (this != NULL);
83419 :
83420 : #if 0
83421 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83422 : // used to trigger marking transformations for the token-based unparsing.
83423 : printf ("SgCommonBlockObject::set_block_name = %p = %s \n",this,this->class_name().c_str());
83424 : #endif
83425 :
83426 6 : set_isModified(true);
83427 :
83428 6 : p_block_name = block_name;
83429 6 : }
83430 :
83431 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83432 :
83433 :
83434 : // End of memberFunctionString
83435 : // Start of memberFunctionString
83436 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83437 :
83438 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83439 :
83440 : SgExprListExp*
83441 7 : SgCommonBlockObject::get_variable_reference_list () const
83442 : {
83443 7 : ROSE_ASSERT (this != NULL);
83444 :
83445 : #if 0
83446 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83447 : // used to trigger marking transformations for the token-based unparsing.
83448 : printf ("SgCommonBlockObject::get_variable_reference_list = %p = %s \n",this,this->class_name().c_str());
83449 : #endif
83450 :
83451 7 : return p_variable_reference_list;
83452 : }
83453 :
83454 : void
83455 6 : SgCommonBlockObject::set_variable_reference_list ( SgExprListExp* variable_reference_list )
83456 : {
83457 6 : ROSE_ASSERT (this != NULL);
83458 :
83459 : #if 0
83460 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83461 : // used to trigger marking transformations for the token-based unparsing.
83462 : printf ("SgCommonBlockObject::set_variable_reference_list = %p = %s \n",this,this->class_name().c_str());
83463 : #endif
83464 :
83465 6 : set_isModified(true);
83466 :
83467 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
83468 : if (p_variable_reference_list != NULL && variable_reference_list != NULL && p_variable_reference_list != variable_reference_list)
83469 : {
83470 : printf ("Warning: variable_reference_list = %p overwriting valid pointer p_variable_reference_list = %p \n",variable_reference_list,p_variable_reference_list);
83471 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
83472 : printf ("Error fails assertion (p_variable_reference_list != NULL && variable_reference_list != NULL && p_variable_reference_list != variable_reference_list) is false\n");
83473 : ROSE_ASSERT(false);
83474 : #endif
83475 : }
83476 : #endif
83477 6 : p_variable_reference_list = variable_reference_list;
83478 6 : }
83479 :
83480 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83481 :
83482 :
83483 : // End of memberFunctionString
83484 : // Start of memberFunctionString
83485 : /* #line 22595 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
83486 :
83487 :
83488 :
83489 : // End of memberFunctionString
83490 : // Start of memberFunctionString
83491 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
83492 :
83493 : // *** COMMON CODE SECTION BEGINS HERE ***
83494 :
83495 : #if 0
83496 : int
83497 : SgCommonBlockObject::getVariant() const
83498 : {
83499 : // This function is used in ROSE while "variant()" is used in SAGE
83500 : assert(this != NULL);
83501 : return variant();
83502 : }
83503 : #endif
83504 :
83505 : // This function is used in ROSE in treeTraversal code
83506 : // eventually replaces getVariant() and variant()
83507 : // though after variant() has been removed for a while we will
83508 : // want to change the name of variantT() back to variant()
83509 : // (since the "T" was ment to stand for temporary).
83510 : // When this happens the variantT() will be depricated.
83511 : VariantT
83512 5098 : SgCommonBlockObject::variantT() const
83513 : {
83514 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
83515 5098 : ROSE_ASSERT(this != NULL);
83516 5098 : return V_SgCommonBlockObject;
83517 : }
83518 :
83519 : #if 0
83520 : int
83521 : SgCommonBlockObject::variant() const
83522 : {
83523 : // This function is used in SAGE
83524 : ROSE_ASSERT(this != NULL);
83525 : return TEMP_CommonBlockObject;
83526 : }
83527 : #endif
83528 :
83529 : ROSE_DLL_API const char*
83530 10 : SgCommonBlockObject::sage_class_name() const
83531 : {
83532 10 : ROSE_ASSERT(this != NULL);
83533 10 : return "SgCommonBlockObject";
83534 : }
83535 :
83536 : std::string
83537 6 : SgCommonBlockObject::class_name() const
83538 : {
83539 6 : ROSE_ASSERT(this != NULL);
83540 6 : return "SgCommonBlockObject";
83541 : }
83542 :
83543 : // DQ (11/26/2005): Support for visitor pattern mechanims
83544 : // (inferior to ROSE traversal mechanism, experimental).
83545 : void
83546 0 : SgCommonBlockObject::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
83547 : {
83548 0 : ROSE_ASSERT(this != NULL);
83549 0 : visitor.visit(this);
83550 0 : }
83551 :
83552 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
83553 0 : void SgCommonBlockObject::accept (ROSE_VisitorPattern & visitor) {
83554 0 : ROSE_ASSERT(this != NULL);
83555 0 : visitor.visit(this);
83556 0 : }
83557 :
83558 : SgCommonBlockObject*
83559 0 : SgCommonBlockObject::addRegExpAttribute(std::string s, AstRegExAttribute* a)
83560 : {
83561 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
83562 : // This function is currently only supported for the AST used the represent Binary executables.
83563 : if (0 /* isSgAsmNode(this) != NULL */)
83564 : {
83565 : // Support for regex specification.
83566 : std::string prefixCode = "REGEX:";
83567 : addNewAttribute(prefixCode + s,a);
83568 : }
83569 : #endif
83570 :
83571 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
83572 0 : return this;
83573 : }
83574 :
83575 : // *** COMMON CODE SECTION ENDS HERE ***
83576 :
83577 :
83578 : // End of memberFunctionString
83579 : // Start of memberFunctionString
83580 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
83581 :
83582 :
83583 : #if 0
83584 : //! Error checking support
83585 : /*! Verifies the following:
83586 : - working getVariant() member function
83587 : - calls base class's error() member function
83588 : Every class has one of these functions.
83589 : */
83590 : bool
83591 : SgCommonBlockObject::error()
83592 : {
83593 : // Put error checking here
83594 :
83595 : ROSE_ASSERT (this != NULL);
83596 : if (getVariant() != TEMP_CommonBlockObject)
83597 : {
83598 : printf ("Error in SgCommonBlockObject::error(): SgCommonBlockObject object has a %s variant \n",
83599 : Cxx_GrammarTerminalNames[getVariant()].name);
83600 : // printf ("Error in SgCommonBlockObject::error() \n");
83601 : ROSE_ABORT();
83602 : }
83603 :
83604 : ROSE_ASSERT (getVariant() == TEMP_CommonBlockObject);
83605 : return SgLocatedNodeSupport::error();
83606 : }
83607 : #endif
83608 :
83609 :
83610 :
83611 : // End of memberFunctionString
83612 :
83613 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
83614 :
83615 11 : SgCommonBlockObject* isSgCommonBlockObject ( SgNode* inputDerivedClassPointer )
83616 : {
83617 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
83618 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
83619 : // So to fix this we return NULL directly when the input is NULL and avoid the
83620 : // dynamic_cast in this case. This is likely a performance improvement as well.
83621 : // return dynamic_cast<SgCommonBlockObject*>(inputDerivedClassPointer);
83622 : // Milind Chabbi (8/28/2013): isSgCommonBlockObject uses table-driven castability instead of c++ default dynamic_cast
83623 : // this improves the running time performance by 10-20%.
83624 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCommonBlockObject*>(inputDerivedClassPointer);
83625 11 : return IS_SgCommonBlockObject_FAST_MACRO(inputDerivedClassPointer);
83626 : }
83627 :
83628 : // DQ (11/8/2003): Added version of functions taking const pointer
83629 0 : const SgCommonBlockObject* isSgCommonBlockObject ( const SgNode* inputDerivedClassPointer )
83630 : {
83631 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
83632 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
83633 : // So to fix this we return NULL directly when the input is NULL and avoid the
83634 : // dynamic_cast in this case. This is likely a performance improvement as well.
83635 : // return dynamic_cast<const SgCommonBlockObject*>(inputDerivedClassPointer);
83636 : // Milind Chabbi (8/28/2013): isSgCommonBlockObject uses table-driven castability instead of c++ default dynamic_cast
83637 : // this improves the running time performance by 10-20%.
83638 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCommonBlockObject*>(inputDerivedClassPointer);
83639 0 : return IS_SgCommonBlockObject_FAST_MACRO(inputDerivedClassPointer);
83640 : }
83641 :
83642 :
83643 :
83644 : /* #line 83645 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83645 :
83646 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
83647 :
83648 : /**
83649 : \brief Generated destructor
83650 :
83651 : This destructor is automatically generated (by ROSETTA). This destructor
83652 : only frees memory of data members associated with the parts of the current IR node which
83653 : are NOT traversed. Those data members that are part of a traversal can be freed using
83654 : a traversal (calling this destructor on all children in a post-order traversal). Such
83655 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
83656 :
83657 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
83658 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
83659 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
83660 :
83661 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
83662 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
83663 : pointers are not yet implemented to call delete on eash pointer in the container.
83664 : (This could be done by derivation from the STL containers to define containers that
83665 : automatically deleted their members.)
83666 :
83667 : */
83668 0 : SgCommonBlockObject::~SgCommonBlockObject () {
83669 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
83670 :
83671 :
83672 : // case: not a listType for block_name
83673 0 : p_block_name =""; // non list case
83674 : // case: not a listType for variable_reference_list
83675 0 : p_variable_reference_list = NULL; // non list case
83676 :
83677 : }
83678 :
83679 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
83680 0 : }
83681 :
83682 :
83683 : /* #line 83684 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83684 :
83685 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
83686 :
83687 : // Generated constructor
83688 0 : SgCommonBlockObject::SgCommonBlockObject ( Sg_File_Info* startOfConstruct )
83689 0 : : SgLocatedNodeSupport(startOfConstruct)
83690 : {
83691 : #ifdef DEBUG
83692 : // printf ("In SgCommonBlockObject::SgCommonBlockObject (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
83693 : #endif
83694 : #if 0
83695 : // debugging information!
83696 : printf ("In SgCommonBlockObject::SgCommonBlockObject (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
83697 : #endif
83698 :
83699 0 : p_block_name ="";
83700 0 : p_variable_reference_list = NULL;
83701 :
83702 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
83703 :
83704 : #if 0
83705 : // DQ (7/30/2014): Call a virtual function.
83706 : std::string s = this->class_name();
83707 : #endif
83708 :
83709 : // Test the variant virtual function
83710 : // assert(TEMP_CommonBlockObject == variant());
83711 0 : assert(TEMP_CommonBlockObject == this->variant());
83712 0 : ROSE_ASSERT(TEMP_CommonBlockObject == (int)(this->variantT()));
83713 0 : post_construction_initialization();
83714 :
83715 : // Test the isSgCommonBlockObject() function since it has been problematic
83716 0 : assert(isSgCommonBlockObject(this) != NULL);
83717 0 : }
83718 :
83719 : // Generated constructor (all data members)
83720 :
83721 : /* #line 83722 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83722 :
83723 :
83724 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
83725 :
83726 :
83727 : // ********************************************************
83728 : // member functions common across all array grammar objects
83729 : // ********************************************************
83730 :
83731 :
83732 :
83733 : /* #line 83734 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83734 :
83735 :
83736 :
83737 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
83738 :
83739 : // ********************************************************
83740 : // member functions specific to each node in the grammar
83741 : // ********************************************************
83742 :
83743 :
83744 : /* #line 83745 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
83745 :
83746 : // Start of memberFunctionString
83747 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83748 :
83749 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83750 :
83751 : SgName
83752 9299760 : SgInitializedName::get_name () const
83753 : {
83754 9299760 : ROSE_ASSERT (this != NULL);
83755 :
83756 : #if 0
83757 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83758 : // used to trigger marking transformations for the token-based unparsing.
83759 : printf ("SgInitializedName::get_name = %p = %s \n",this,this->class_name().c_str());
83760 : #endif
83761 :
83762 9299760 : return p_name;
83763 : }
83764 :
83765 : void
83766 0 : SgInitializedName::set_name ( SgName name )
83767 : {
83768 0 : ROSE_ASSERT (this != NULL);
83769 :
83770 : #if 0
83771 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83772 : // used to trigger marking transformations for the token-based unparsing.
83773 : printf ("SgInitializedName::set_name = %p = %s \n",this,this->class_name().c_str());
83774 : #endif
83775 :
83776 0 : set_isModified(true);
83777 :
83778 0 : p_name = name;
83779 0 : }
83780 :
83781 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83782 :
83783 :
83784 : // End of memberFunctionString
83785 : // Start of memberFunctionString
83786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83787 :
83788 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83789 :
83790 : std::string
83791 0 : SgInitializedName::get_microsoft_uuid_string () const
83792 : {
83793 0 : ROSE_ASSERT (this != NULL);
83794 :
83795 : #if 0
83796 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83797 : // used to trigger marking transformations for the token-based unparsing.
83798 : printf ("SgInitializedName::get_microsoft_uuid_string = %p = %s \n",this,this->class_name().c_str());
83799 : #endif
83800 :
83801 0 : return p_microsoft_uuid_string;
83802 : }
83803 :
83804 : void
83805 0 : SgInitializedName::set_microsoft_uuid_string ( std::string microsoft_uuid_string )
83806 : {
83807 0 : ROSE_ASSERT (this != NULL);
83808 :
83809 : #if 0
83810 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83811 : // used to trigger marking transformations for the token-based unparsing.
83812 : printf ("SgInitializedName::set_microsoft_uuid_string = %p = %s \n",this,this->class_name().c_str());
83813 : #endif
83814 :
83815 0 : set_isModified(true);
83816 :
83817 0 : p_microsoft_uuid_string = microsoft_uuid_string;
83818 0 : }
83819 :
83820 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83821 :
83822 :
83823 : // End of memberFunctionString
83824 : // Start of memberFunctionString
83825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83826 :
83827 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83828 :
83829 : SgType*
83830 417 : SgInitializedName::get_typeptr () const
83831 : {
83832 417 : ROSE_ASSERT (this != NULL);
83833 :
83834 : #if 0
83835 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83836 : // used to trigger marking transformations for the token-based unparsing.
83837 : printf ("SgInitializedName::get_typeptr = %p = %s \n",this,this->class_name().c_str());
83838 : #endif
83839 :
83840 417 : return p_typeptr;
83841 : }
83842 :
83843 : void
83844 0 : SgInitializedName::set_typeptr ( SgType* typeptr )
83845 : {
83846 0 : ROSE_ASSERT (this != NULL);
83847 :
83848 : #if 0
83849 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83850 : // used to trigger marking transformations for the token-based unparsing.
83851 : printf ("SgInitializedName::set_typeptr = %p = %s \n",this,this->class_name().c_str());
83852 : #endif
83853 :
83854 0 : set_isModified(true);
83855 :
83856 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
83857 : if (p_typeptr != NULL && typeptr != NULL && p_typeptr != typeptr)
83858 : {
83859 : printf ("Warning: typeptr = %p overwriting valid pointer p_typeptr = %p \n",typeptr,p_typeptr);
83860 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
83861 : printf ("Error fails assertion (p_typeptr != NULL && typeptr != NULL && p_typeptr != typeptr) is false\n");
83862 : ROSE_ASSERT(false);
83863 : #endif
83864 : }
83865 : #endif
83866 0 : p_typeptr = typeptr;
83867 0 : }
83868 :
83869 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83870 :
83871 :
83872 : // End of memberFunctionString
83873 : // Start of memberFunctionString
83874 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83875 :
83876 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83877 :
83878 : SgInitializer*
83879 1563680 : SgInitializedName::get_initptr () const
83880 : {
83881 1563680 : ROSE_ASSERT (this != NULL);
83882 :
83883 : #if 0
83884 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83885 : // used to trigger marking transformations for the token-based unparsing.
83886 : printf ("SgInitializedName::get_initptr = %p = %s \n",this,this->class_name().c_str());
83887 : #endif
83888 :
83889 1563680 : return p_initptr;
83890 : }
83891 :
83892 : void
83893 1 : SgInitializedName::set_initptr ( SgInitializer* initptr )
83894 : {
83895 1 : ROSE_ASSERT (this != NULL);
83896 :
83897 : #if 0
83898 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83899 : // used to trigger marking transformations for the token-based unparsing.
83900 : printf ("SgInitializedName::set_initptr = %p = %s \n",this,this->class_name().c_str());
83901 : #endif
83902 :
83903 1 : set_isModified(true);
83904 :
83905 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
83906 : if (p_initptr != NULL && initptr != NULL && p_initptr != initptr)
83907 : {
83908 : printf ("Warning: initptr = %p overwriting valid pointer p_initptr = %p \n",initptr,p_initptr);
83909 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
83910 : printf ("Error fails assertion (p_initptr != NULL && initptr != NULL && p_initptr != initptr) is false\n");
83911 : ROSE_ASSERT(false);
83912 : #endif
83913 : }
83914 : #endif
83915 1 : p_initptr = initptr;
83916 1 : }
83917 :
83918 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83919 :
83920 :
83921 : // End of memberFunctionString
83922 : // Start of memberFunctionString
83923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83924 :
83925 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83926 :
83927 : SgInitializedName*
83928 4774000 : SgInitializedName::get_prev_decl_item () const
83929 : {
83930 4774000 : ROSE_ASSERT (this != NULL);
83931 :
83932 : #if 0
83933 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83934 : // used to trigger marking transformations for the token-based unparsing.
83935 : printf ("SgInitializedName::get_prev_decl_item = %p = %s \n",this,this->class_name().c_str());
83936 : #endif
83937 :
83938 4774000 : return p_prev_decl_item;
83939 : }
83940 :
83941 : void
83942 749 : SgInitializedName::set_prev_decl_item ( SgInitializedName* prev_decl_item )
83943 : {
83944 749 : ROSE_ASSERT (this != NULL);
83945 :
83946 : #if 0
83947 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83948 : // used to trigger marking transformations for the token-based unparsing.
83949 : printf ("SgInitializedName::set_prev_decl_item = %p = %s \n",this,this->class_name().c_str());
83950 : #endif
83951 :
83952 749 : set_isModified(true);
83953 :
83954 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
83955 : if (p_prev_decl_item != NULL && prev_decl_item != NULL && p_prev_decl_item != prev_decl_item)
83956 : {
83957 : printf ("Warning: prev_decl_item = %p overwriting valid pointer p_prev_decl_item = %p \n",prev_decl_item,p_prev_decl_item);
83958 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
83959 : printf ("Error fails assertion (p_prev_decl_item != NULL && prev_decl_item != NULL && p_prev_decl_item != prev_decl_item) is false\n");
83960 : ROSE_ASSERT(false);
83961 : #endif
83962 : }
83963 : #endif
83964 749 : p_prev_decl_item = prev_decl_item;
83965 749 : }
83966 :
83967 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
83968 :
83969 :
83970 : // End of memberFunctionString
83971 : // Start of memberFunctionString
83972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
83973 :
83974 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
83975 :
83976 : SgDeclarationStatement*
83977 187887 : SgInitializedName::get_declptr () const
83978 : {
83979 187887 : ROSE_ASSERT (this != NULL);
83980 :
83981 : #if 0
83982 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83983 : // used to trigger marking transformations for the token-based unparsing.
83984 : printf ("SgInitializedName::get_declptr = %p = %s \n",this,this->class_name().c_str());
83985 : #endif
83986 :
83987 187887 : return p_declptr;
83988 : }
83989 :
83990 : void
83991 3235400 : SgInitializedName::set_declptr ( SgDeclarationStatement* declptr )
83992 : {
83993 3235400 : ROSE_ASSERT (this != NULL);
83994 :
83995 : #if 0
83996 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
83997 : // used to trigger marking transformations for the token-based unparsing.
83998 : printf ("SgInitializedName::set_declptr = %p = %s \n",this,this->class_name().c_str());
83999 : #endif
84000 :
84001 3235400 : set_isModified(true);
84002 :
84003 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
84004 : if (p_declptr != NULL && declptr != NULL && p_declptr != declptr)
84005 : {
84006 : printf ("Warning: declptr = %p overwriting valid pointer p_declptr = %p \n",declptr,p_declptr);
84007 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
84008 : printf ("Error fails assertion (p_declptr != NULL && declptr != NULL && p_declptr != declptr) is false\n");
84009 : ROSE_ASSERT(false);
84010 : #endif
84011 : }
84012 : #endif
84013 3235400 : p_declptr = declptr;
84014 3235400 : }
84015 :
84016 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84017 :
84018 :
84019 : // End of memberFunctionString
84020 : // Start of memberFunctionString
84021 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84022 :
84023 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84024 :
84025 : SgScopeStatement*
84026 35398100 : SgInitializedName::get_scope () const
84027 : {
84028 35398100 : ROSE_ASSERT (this != NULL);
84029 :
84030 : #if 0
84031 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84032 : // used to trigger marking transformations for the token-based unparsing.
84033 : printf ("SgInitializedName::get_scope = %p = %s \n",this,this->class_name().c_str());
84034 : #endif
84035 :
84036 35398100 : return p_scope;
84037 : }
84038 :
84039 : void
84040 19044100 : SgInitializedName::set_scope ( SgScopeStatement* scope )
84041 : {
84042 19044100 : ROSE_ASSERT (this != NULL);
84043 :
84044 : #if 0
84045 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84046 : // used to trigger marking transformations for the token-based unparsing.
84047 : printf ("SgInitializedName::set_scope = %p = %s \n",this,this->class_name().c_str());
84048 : #endif
84049 :
84050 19044100 : set_isModified(true);
84051 :
84052 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
84053 : if (p_scope != NULL && scope != NULL && p_scope != scope)
84054 : {
84055 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
84056 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
84057 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
84058 : ROSE_ASSERT(false);
84059 : #endif
84060 : }
84061 : #endif
84062 19044100 : p_scope = scope;
84063 19044100 : }
84064 :
84065 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84066 :
84067 :
84068 : // End of memberFunctionString
84069 : // Start of memberFunctionString
84070 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84071 :
84072 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84073 :
84074 : SgInitializedName::preinitialization_enum
84075 1464670 : SgInitializedName::get_preinitialization () const
84076 : {
84077 1464670 : ROSE_ASSERT (this != NULL);
84078 :
84079 : #if 0
84080 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84081 : // used to trigger marking transformations for the token-based unparsing.
84082 : printf ("SgInitializedName::get_preinitialization = %p = %s \n",this,this->class_name().c_str());
84083 : #endif
84084 :
84085 1464670 : return p_preinitialization;
84086 : }
84087 :
84088 : void
84089 2428 : SgInitializedName::set_preinitialization ( SgInitializedName::preinitialization_enum preinitialization )
84090 : {
84091 2428 : ROSE_ASSERT (this != NULL);
84092 :
84093 : #if 0
84094 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84095 : // used to trigger marking transformations for the token-based unparsing.
84096 : printf ("SgInitializedName::set_preinitialization = %p = %s \n",this,this->class_name().c_str());
84097 : #endif
84098 :
84099 2428 : set_isModified(true);
84100 :
84101 2428 : p_preinitialization = preinitialization;
84102 2428 : }
84103 :
84104 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84105 :
84106 :
84107 : // End of memberFunctionString
84108 : // Start of memberFunctionString
84109 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84110 :
84111 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84112 :
84113 : bool
84114 0 : SgInitializedName::get_isCoArray () const
84115 : {
84116 0 : ROSE_ASSERT (this != NULL);
84117 :
84118 : #if 0
84119 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84120 : // used to trigger marking transformations for the token-based unparsing.
84121 : printf ("SgInitializedName::get_isCoArray = %p = %s \n",this,this->class_name().c_str());
84122 : #endif
84123 :
84124 0 : return p_isCoArray;
84125 : }
84126 :
84127 : void
84128 0 : SgInitializedName::set_isCoArray ( bool isCoArray )
84129 : {
84130 0 : ROSE_ASSERT (this != NULL);
84131 :
84132 : #if 0
84133 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84134 : // used to trigger marking transformations for the token-based unparsing.
84135 : printf ("SgInitializedName::set_isCoArray = %p = %s \n",this,this->class_name().c_str());
84136 : #endif
84137 :
84138 0 : set_isModified(true);
84139 :
84140 0 : p_isCoArray = isCoArray;
84141 0 : }
84142 :
84143 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84144 :
84145 :
84146 : // End of memberFunctionString
84147 : // Start of memberFunctionString
84148 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
84149 :
84150 :
84151 : #if 0
84152 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
84153 : // a pointer and the interface represented directly at the SgNode
84154 : AstAttributeMechanism &
84155 : SgInitializedName::attribute()
84156 : {
84157 : // DQ (1/2/2006): This function preserves as much of
84158 : // the syntax of attribute being a public data member.
84159 : if (p_attribute == NULL)
84160 : {
84161 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
84162 : assert(false);
84163 : }
84164 :
84165 : return *p_attribute;
84166 : }
84167 : #endif
84168 :
84169 : void
84170 0 : SgInitializedName::addNewAttribute( std::string s, AstAttribute* a )
84171 : {
84172 0 : if (get_attributeMechanism() == NULL)
84173 : {
84174 0 : set_attributeMechanism( new AstAttributeMechanism() );
84175 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
84176 : }
84177 0 : get_attributeMechanism()->add(s,a);
84178 0 : }
84179 :
84180 : void
84181 0 : SgInitializedName::setAttribute( std::string s, AstAttribute* a )
84182 : {
84183 0 : if (get_attributeMechanism() == NULL)
84184 : {
84185 0 : set_attributeMechanism( new AstAttributeMechanism() );
84186 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
84187 : }
84188 0 : get_attributeMechanism()->set(s,a);
84189 0 : }
84190 :
84191 : AstAttribute*
84192 0 : SgInitializedName::getAttribute(std::string s) const
84193 : {
84194 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
84195 0 : if (attributeExists(s)==false) return NULL;
84196 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
84197 0 : ROSE_ASSERT(returnValue != NULL);
84198 0 : return returnValue;
84199 : }
84200 :
84201 : void
84202 0 : SgInitializedName::updateAttribute( std::string s, AstAttribute* a )
84203 : {
84204 : // formerly called: replace
84205 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
84206 0 : get_attributeMechanism()->replace(s,a);
84207 0 : }
84208 :
84209 : void
84210 0 : SgInitializedName::removeAttribute(std::string s)
84211 : {
84212 0 : if (get_attributeMechanism())
84213 0 : get_attributeMechanism()->remove(s);
84214 :
84215 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
84216 0 : int remainingCount = numberOfAttributes();
84217 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
84218 0 : if (remainingCount == 0)
84219 : {
84220 0 : delete get_attributeMechanism();
84221 0 : set_attributeMechanism(NULL);
84222 : }
84223 0 : }
84224 :
84225 : bool
84226 0 : SgInitializedName::attributeExists(std::string s) const
84227 : {
84228 0 : bool returnValue = false;
84229 0 : if (get_attributeMechanism() != NULL)
84230 0 : returnValue = get_attributeMechanism()->exists(s);
84231 0 : return returnValue;
84232 : }
84233 :
84234 : int
84235 0 : SgInitializedName::numberOfAttributes() const
84236 : {
84237 0 : int returnValue = 0;
84238 0 : if (get_attributeMechanism() != NULL)
84239 0 : returnValue = get_attributeMechanism()->size();
84240 0 : return returnValue;
84241 : }
84242 :
84243 :
84244 :
84245 : // End of memberFunctionString
84246 : // Start of memberFunctionString
84247 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84248 :
84249 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84250 :
84251 : SgInitializedName::asm_register_name_enum
84252 3560 : SgInitializedName::get_register_name_code () const
84253 : {
84254 3560 : ROSE_ASSERT (this != NULL);
84255 :
84256 : #if 0
84257 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84258 : // used to trigger marking transformations for the token-based unparsing.
84259 : printf ("SgInitializedName::get_register_name_code = %p = %s \n",this,this->class_name().c_str());
84260 : #endif
84261 :
84262 3560 : return p_register_name_code;
84263 : }
84264 :
84265 : void
84266 0 : SgInitializedName::set_register_name_code ( SgInitializedName::asm_register_name_enum register_name_code )
84267 : {
84268 0 : ROSE_ASSERT (this != NULL);
84269 :
84270 : #if 0
84271 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84272 : // used to trigger marking transformations for the token-based unparsing.
84273 : printf ("SgInitializedName::set_register_name_code = %p = %s \n",this,this->class_name().c_str());
84274 : #endif
84275 :
84276 0 : set_isModified(true);
84277 :
84278 0 : p_register_name_code = register_name_code;
84279 0 : }
84280 :
84281 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84282 :
84283 :
84284 : // End of memberFunctionString
84285 : // Start of memberFunctionString
84286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84287 :
84288 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84289 :
84290 : SgInitializedName::excess_specifier_enum
84291 0 : SgInitializedName::get_excess_specifier () const
84292 : {
84293 0 : ROSE_ASSERT (this != NULL);
84294 :
84295 : #if 0
84296 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84297 : // used to trigger marking transformations for the token-based unparsing.
84298 : printf ("SgInitializedName::get_excess_specifier = %p = %s \n",this,this->class_name().c_str());
84299 : #endif
84300 :
84301 0 : return p_excess_specifier;
84302 : }
84303 :
84304 : void
84305 0 : SgInitializedName::set_excess_specifier ( SgInitializedName::excess_specifier_enum excess_specifier )
84306 : {
84307 0 : ROSE_ASSERT (this != NULL);
84308 :
84309 : #if 0
84310 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84311 : // used to trigger marking transformations for the token-based unparsing.
84312 : printf ("SgInitializedName::set_excess_specifier = %p = %s \n",this,this->class_name().c_str());
84313 : #endif
84314 :
84315 0 : set_isModified(true);
84316 :
84317 0 : p_excess_specifier = excess_specifier;
84318 0 : }
84319 :
84320 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84321 :
84322 :
84323 : // End of memberFunctionString
84324 : // Start of memberFunctionString
84325 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84326 :
84327 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84328 :
84329 : std::string
84330 3560 : SgInitializedName::get_register_name_string () const
84331 : {
84332 3560 : ROSE_ASSERT (this != NULL);
84333 :
84334 : #if 0
84335 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84336 : // used to trigger marking transformations for the token-based unparsing.
84337 : printf ("SgInitializedName::get_register_name_string = %p = %s \n",this,this->class_name().c_str());
84338 : #endif
84339 :
84340 3560 : return p_register_name_string;
84341 : }
84342 :
84343 : void
84344 0 : SgInitializedName::set_register_name_string ( std::string register_name_string )
84345 : {
84346 0 : ROSE_ASSERT (this != NULL);
84347 :
84348 : #if 0
84349 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84350 : // used to trigger marking transformations for the token-based unparsing.
84351 : printf ("SgInitializedName::set_register_name_string = %p = %s \n",this,this->class_name().c_str());
84352 : #endif
84353 :
84354 0 : set_isModified(true);
84355 :
84356 0 : p_register_name_string = register_name_string;
84357 0 : }
84358 :
84359 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84360 :
84361 :
84362 : // End of memberFunctionString
84363 : // Start of memberFunctionString
84364 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84365 :
84366 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84367 :
84368 : bool
84369 967 : SgInitializedName::get_requiresGlobalNameQualificationOnType () const
84370 : {
84371 967 : ROSE_ASSERT (this != NULL);
84372 :
84373 : #if 0
84374 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84375 : // used to trigger marking transformations for the token-based unparsing.
84376 : printf ("SgInitializedName::get_requiresGlobalNameQualificationOnType = %p = %s \n",this,this->class_name().c_str());
84377 : #endif
84378 :
84379 967 : return p_requiresGlobalNameQualificationOnType;
84380 : }
84381 :
84382 : void
84383 0 : SgInitializedName::set_requiresGlobalNameQualificationOnType ( bool requiresGlobalNameQualificationOnType )
84384 : {
84385 0 : ROSE_ASSERT (this != NULL);
84386 :
84387 : #if 0
84388 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84389 : // used to trigger marking transformations for the token-based unparsing.
84390 : printf ("SgInitializedName::set_requiresGlobalNameQualificationOnType = %p = %s \n",this,this->class_name().c_str());
84391 : #endif
84392 :
84393 0 : set_isModified(true);
84394 :
84395 0 : p_requiresGlobalNameQualificationOnType = requiresGlobalNameQualificationOnType;
84396 0 : }
84397 :
84398 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84399 :
84400 :
84401 : // End of memberFunctionString
84402 : // Start of memberFunctionString
84403 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84404 :
84405 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84406 :
84407 : bool
84408 0 : SgInitializedName::get_shapeDeferred () const
84409 : {
84410 0 : ROSE_ASSERT (this != NULL);
84411 :
84412 : #if 0
84413 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84414 : // used to trigger marking transformations for the token-based unparsing.
84415 : printf ("SgInitializedName::get_shapeDeferred = %p = %s \n",this,this->class_name().c_str());
84416 : #endif
84417 :
84418 0 : return p_shapeDeferred;
84419 : }
84420 :
84421 : void
84422 0 : SgInitializedName::set_shapeDeferred ( bool shapeDeferred )
84423 : {
84424 0 : ROSE_ASSERT (this != NULL);
84425 :
84426 : #if 0
84427 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84428 : // used to trigger marking transformations for the token-based unparsing.
84429 : printf ("SgInitializedName::set_shapeDeferred = %p = %s \n",this,this->class_name().c_str());
84430 : #endif
84431 :
84432 0 : set_isModified(true);
84433 :
84434 0 : p_shapeDeferred = shapeDeferred;
84435 0 : }
84436 :
84437 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84438 :
84439 :
84440 : // End of memberFunctionString
84441 : // Start of memberFunctionString
84442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84443 :
84444 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84445 :
84446 : bool
84447 0 : SgInitializedName::get_initializationDeferred () const
84448 : {
84449 0 : ROSE_ASSERT (this != NULL);
84450 :
84451 : #if 0
84452 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84453 : // used to trigger marking transformations for the token-based unparsing.
84454 : printf ("SgInitializedName::get_initializationDeferred = %p = %s \n",this,this->class_name().c_str());
84455 : #endif
84456 :
84457 0 : return p_initializationDeferred;
84458 : }
84459 :
84460 : void
84461 0 : SgInitializedName::set_initializationDeferred ( bool initializationDeferred )
84462 : {
84463 0 : ROSE_ASSERT (this != NULL);
84464 :
84465 : #if 0
84466 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84467 : // used to trigger marking transformations for the token-based unparsing.
84468 : printf ("SgInitializedName::set_initializationDeferred = %p = %s \n",this,this->class_name().c_str());
84469 : #endif
84470 :
84471 0 : set_isModified(true);
84472 :
84473 0 : p_initializationDeferred = initializationDeferred;
84474 0 : }
84475 :
84476 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84477 :
84478 :
84479 : // End of memberFunctionString
84480 : // Start of memberFunctionString
84481 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84482 :
84483 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84484 :
84485 : SgBitVector
84486 0 : SgInitializedName::get_gnu_attribute_modifierVector () const
84487 : {
84488 0 : ROSE_ASSERT (this != NULL);
84489 :
84490 : #if 0
84491 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84492 : // used to trigger marking transformations for the token-based unparsing.
84493 : printf ("SgInitializedName::get_gnu_attribute_modifierVector = %p = %s \n",this,this->class_name().c_str());
84494 : #endif
84495 :
84496 0 : return p_gnu_attribute_modifierVector;
84497 : }
84498 :
84499 : void
84500 0 : SgInitializedName::set_gnu_attribute_modifierVector ( SgBitVector gnu_attribute_modifierVector )
84501 : {
84502 0 : ROSE_ASSERT (this != NULL);
84503 :
84504 : #if 0
84505 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84506 : // used to trigger marking transformations for the token-based unparsing.
84507 : printf ("SgInitializedName::set_gnu_attribute_modifierVector = %p = %s \n",this,this->class_name().c_str());
84508 : #endif
84509 :
84510 0 : set_isModified(true);
84511 :
84512 0 : p_gnu_attribute_modifierVector = gnu_attribute_modifierVector;
84513 0 : }
84514 :
84515 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84516 :
84517 :
84518 : // End of memberFunctionString
84519 : // Start of memberFunctionString
84520 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84521 :
84522 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84523 :
84524 : unsigned long int
84525 0 : SgInitializedName::get_gnu_attribute_initialization_priority () const
84526 : {
84527 0 : ROSE_ASSERT (this != NULL);
84528 :
84529 : #if 0
84530 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84531 : // used to trigger marking transformations for the token-based unparsing.
84532 : printf ("SgInitializedName::get_gnu_attribute_initialization_priority = %p = %s \n",this,this->class_name().c_str());
84533 : #endif
84534 :
84535 0 : return p_gnu_attribute_initialization_priority;
84536 : }
84537 :
84538 : void
84539 0 : SgInitializedName::set_gnu_attribute_initialization_priority ( unsigned long int gnu_attribute_initialization_priority )
84540 : {
84541 0 : ROSE_ASSERT (this != NULL);
84542 :
84543 : #if 0
84544 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84545 : // used to trigger marking transformations for the token-based unparsing.
84546 : printf ("SgInitializedName::set_gnu_attribute_initialization_priority = %p = %s \n",this,this->class_name().c_str());
84547 : #endif
84548 :
84549 0 : set_isModified(true);
84550 :
84551 0 : p_gnu_attribute_initialization_priority = gnu_attribute_initialization_priority;
84552 0 : }
84553 :
84554 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84555 :
84556 :
84557 : // End of memberFunctionString
84558 : // Start of memberFunctionString
84559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84560 :
84561 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84562 :
84563 : std::string
84564 0 : SgInitializedName::get_gnu_attribute_named_weak_reference () const
84565 : {
84566 0 : ROSE_ASSERT (this != NULL);
84567 :
84568 : #if 0
84569 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84570 : // used to trigger marking transformations for the token-based unparsing.
84571 : printf ("SgInitializedName::get_gnu_attribute_named_weak_reference = %p = %s \n",this,this->class_name().c_str());
84572 : #endif
84573 :
84574 0 : return p_gnu_attribute_named_weak_reference;
84575 : }
84576 :
84577 : void
84578 0 : SgInitializedName::set_gnu_attribute_named_weak_reference ( std::string gnu_attribute_named_weak_reference )
84579 : {
84580 0 : ROSE_ASSERT (this != NULL);
84581 :
84582 : #if 0
84583 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84584 : // used to trigger marking transformations for the token-based unparsing.
84585 : printf ("SgInitializedName::set_gnu_attribute_named_weak_reference = %p = %s \n",this,this->class_name().c_str());
84586 : #endif
84587 :
84588 0 : set_isModified(true);
84589 :
84590 0 : p_gnu_attribute_named_weak_reference = gnu_attribute_named_weak_reference;
84591 0 : }
84592 :
84593 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84594 :
84595 :
84596 : // End of memberFunctionString
84597 : // Start of memberFunctionString
84598 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84599 :
84600 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84601 :
84602 : std::string
84603 0 : SgInitializedName::get_gnu_attribute_named_alias () const
84604 : {
84605 0 : ROSE_ASSERT (this != NULL);
84606 :
84607 : #if 0
84608 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84609 : // used to trigger marking transformations for the token-based unparsing.
84610 : printf ("SgInitializedName::get_gnu_attribute_named_alias = %p = %s \n",this,this->class_name().c_str());
84611 : #endif
84612 :
84613 0 : return p_gnu_attribute_named_alias;
84614 : }
84615 :
84616 : void
84617 0 : SgInitializedName::set_gnu_attribute_named_alias ( std::string gnu_attribute_named_alias )
84618 : {
84619 0 : ROSE_ASSERT (this != NULL);
84620 :
84621 : #if 0
84622 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84623 : // used to trigger marking transformations for the token-based unparsing.
84624 : printf ("SgInitializedName::set_gnu_attribute_named_alias = %p = %s \n",this,this->class_name().c_str());
84625 : #endif
84626 :
84627 0 : set_isModified(true);
84628 :
84629 0 : p_gnu_attribute_named_alias = gnu_attribute_named_alias;
84630 0 : }
84631 :
84632 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84633 :
84634 :
84635 : // End of memberFunctionString
84636 : // Start of memberFunctionString
84637 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84638 :
84639 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84640 :
84641 : std::string
84642 0 : SgInitializedName::get_gnu_attribute_cleanup_function () const
84643 : {
84644 0 : ROSE_ASSERT (this != NULL);
84645 :
84646 : #if 0
84647 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84648 : // used to trigger marking transformations for the token-based unparsing.
84649 : printf ("SgInitializedName::get_gnu_attribute_cleanup_function = %p = %s \n",this,this->class_name().c_str());
84650 : #endif
84651 :
84652 0 : return p_gnu_attribute_cleanup_function;
84653 : }
84654 :
84655 : void
84656 0 : SgInitializedName::set_gnu_attribute_cleanup_function ( std::string gnu_attribute_cleanup_function )
84657 : {
84658 0 : ROSE_ASSERT (this != NULL);
84659 :
84660 : #if 0
84661 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84662 : // used to trigger marking transformations for the token-based unparsing.
84663 : printf ("SgInitializedName::set_gnu_attribute_cleanup_function = %p = %s \n",this,this->class_name().c_str());
84664 : #endif
84665 :
84666 0 : set_isModified(true);
84667 :
84668 0 : p_gnu_attribute_cleanup_function = gnu_attribute_cleanup_function;
84669 0 : }
84670 :
84671 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84672 :
84673 :
84674 : // End of memberFunctionString
84675 : // Start of memberFunctionString
84676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84677 :
84678 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84679 :
84680 : std::string
84681 3560 : SgInitializedName::get_gnu_attribute_section_name () const
84682 : {
84683 3560 : ROSE_ASSERT (this != NULL);
84684 :
84685 : #if 0
84686 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84687 : // used to trigger marking transformations for the token-based unparsing.
84688 : printf ("SgInitializedName::get_gnu_attribute_section_name = %p = %s \n",this,this->class_name().c_str());
84689 : #endif
84690 :
84691 3560 : return p_gnu_attribute_section_name;
84692 : }
84693 :
84694 : void
84695 0 : SgInitializedName::set_gnu_attribute_section_name ( std::string gnu_attribute_section_name )
84696 : {
84697 0 : ROSE_ASSERT (this != NULL);
84698 :
84699 : #if 0
84700 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84701 : // used to trigger marking transformations for the token-based unparsing.
84702 : printf ("SgInitializedName::set_gnu_attribute_section_name = %p = %s \n",this,this->class_name().c_str());
84703 : #endif
84704 :
84705 0 : set_isModified(true);
84706 :
84707 0 : p_gnu_attribute_section_name = gnu_attribute_section_name;
84708 0 : }
84709 :
84710 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84711 :
84712 :
84713 : // End of memberFunctionString
84714 : // Start of memberFunctionString
84715 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84716 :
84717 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84718 :
84719 : int
84720 3560 : SgInitializedName::get_gnu_attribute_alignment () const
84721 : {
84722 3560 : ROSE_ASSERT (this != NULL);
84723 :
84724 : #if 0
84725 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84726 : // used to trigger marking transformations for the token-based unparsing.
84727 : printf ("SgInitializedName::get_gnu_attribute_alignment = %p = %s \n",this,this->class_name().c_str());
84728 : #endif
84729 :
84730 3560 : return p_gnu_attribute_alignment;
84731 : }
84732 :
84733 : void
84734 0 : SgInitializedName::set_gnu_attribute_alignment ( int gnu_attribute_alignment )
84735 : {
84736 0 : ROSE_ASSERT (this != NULL);
84737 :
84738 : #if 0
84739 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84740 : // used to trigger marking transformations for the token-based unparsing.
84741 : printf ("SgInitializedName::set_gnu_attribute_alignment = %p = %s \n",this,this->class_name().c_str());
84742 : #endif
84743 :
84744 0 : set_isModified(true);
84745 :
84746 0 : p_gnu_attribute_alignment = gnu_attribute_alignment;
84747 0 : }
84748 :
84749 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84750 :
84751 :
84752 : // End of memberFunctionString
84753 : // Start of memberFunctionString
84754 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84755 :
84756 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84757 :
84758 : SgDeclarationModifier::gnu_declaration_visability_enum
84759 0 : SgInitializedName::get_gnu_attribute_visability () const
84760 : {
84761 0 : ROSE_ASSERT (this != NULL);
84762 :
84763 : #if 0
84764 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84765 : // used to trigger marking transformations for the token-based unparsing.
84766 : printf ("SgInitializedName::get_gnu_attribute_visability = %p = %s \n",this,this->class_name().c_str());
84767 : #endif
84768 :
84769 0 : return p_gnu_attribute_visability;
84770 : }
84771 :
84772 : void
84773 7985 : SgInitializedName::set_gnu_attribute_visability ( SgDeclarationModifier::gnu_declaration_visability_enum gnu_attribute_visability )
84774 : {
84775 7985 : ROSE_ASSERT (this != NULL);
84776 :
84777 : #if 0
84778 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84779 : // used to trigger marking transformations for the token-based unparsing.
84780 : printf ("SgInitializedName::set_gnu_attribute_visability = %p = %s \n",this,this->class_name().c_str());
84781 : #endif
84782 :
84783 7985 : set_isModified(true);
84784 :
84785 7985 : p_gnu_attribute_visability = gnu_attribute_visability;
84786 7985 : }
84787 :
84788 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84789 :
84790 :
84791 : // End of memberFunctionString
84792 : // Start of memberFunctionString
84793 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84794 :
84795 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84796 :
84797 : bool
84798 79 : SgInitializedName::get_protected_declaration () const
84799 : {
84800 79 : ROSE_ASSERT (this != NULL);
84801 :
84802 : #if 0
84803 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84804 : // used to trigger marking transformations for the token-based unparsing.
84805 : printf ("SgInitializedName::get_protected_declaration = %p = %s \n",this,this->class_name().c_str());
84806 : #endif
84807 :
84808 79 : return p_protected_declaration;
84809 : }
84810 :
84811 : void
84812 0 : SgInitializedName::set_protected_declaration ( bool protected_declaration )
84813 : {
84814 0 : ROSE_ASSERT (this != NULL);
84815 :
84816 : #if 0
84817 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84818 : // used to trigger marking transformations for the token-based unparsing.
84819 : printf ("SgInitializedName::set_protected_declaration = %p = %s \n",this,this->class_name().c_str());
84820 : #endif
84821 :
84822 0 : set_isModified(true);
84823 :
84824 0 : p_protected_declaration = protected_declaration;
84825 0 : }
84826 :
84827 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84828 :
84829 :
84830 : // End of memberFunctionString
84831 : // Start of memberFunctionString
84832 :
84833 :
84834 : // End of memberFunctionString
84835 : // Start of memberFunctionString
84836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84837 :
84838 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84839 :
84840 : bool
84841 3560 : SgInitializedName::get_hasArrayTypeWithEmptyBracketSyntax () const
84842 : {
84843 3560 : ROSE_ASSERT (this != NULL);
84844 :
84845 : #if 0
84846 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84847 : // used to trigger marking transformations for the token-based unparsing.
84848 : printf ("SgInitializedName::get_hasArrayTypeWithEmptyBracketSyntax = %p = %s \n",this,this->class_name().c_str());
84849 : #endif
84850 :
84851 3560 : return p_hasArrayTypeWithEmptyBracketSyntax;
84852 : }
84853 :
84854 : void
84855 234 : SgInitializedName::set_hasArrayTypeWithEmptyBracketSyntax ( bool hasArrayTypeWithEmptyBracketSyntax )
84856 : {
84857 234 : ROSE_ASSERT (this != NULL);
84858 :
84859 : #if 0
84860 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84861 : // used to trigger marking transformations for the token-based unparsing.
84862 : printf ("SgInitializedName::set_hasArrayTypeWithEmptyBracketSyntax = %p = %s \n",this,this->class_name().c_str());
84863 : #endif
84864 :
84865 234 : set_isModified(true);
84866 :
84867 234 : p_hasArrayTypeWithEmptyBracketSyntax = hasArrayTypeWithEmptyBracketSyntax;
84868 234 : }
84869 :
84870 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84871 :
84872 :
84873 : // End of memberFunctionString
84874 : // Start of memberFunctionString
84875 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84876 :
84877 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84878 :
84879 : bool
84880 7120 : SgInitializedName::get_using_C11_Alignas_keyword () const
84881 : {
84882 7120 : ROSE_ASSERT (this != NULL);
84883 :
84884 : #if 0
84885 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84886 : // used to trigger marking transformations for the token-based unparsing.
84887 : printf ("SgInitializedName::get_using_C11_Alignas_keyword = %p = %s \n",this,this->class_name().c_str());
84888 : #endif
84889 :
84890 7120 : return p_using_C11_Alignas_keyword;
84891 : }
84892 :
84893 : void
84894 0 : SgInitializedName::set_using_C11_Alignas_keyword ( bool using_C11_Alignas_keyword )
84895 : {
84896 0 : ROSE_ASSERT (this != NULL);
84897 :
84898 : #if 0
84899 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84900 : // used to trigger marking transformations for the token-based unparsing.
84901 : printf ("SgInitializedName::set_using_C11_Alignas_keyword = %p = %s \n",this,this->class_name().c_str());
84902 : #endif
84903 :
84904 0 : set_isModified(true);
84905 :
84906 0 : p_using_C11_Alignas_keyword = using_C11_Alignas_keyword;
84907 0 : }
84908 :
84909 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84910 :
84911 :
84912 : // End of memberFunctionString
84913 : // Start of memberFunctionString
84914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84915 :
84916 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84917 :
84918 : SgNode*
84919 0 : SgInitializedName::get_constant_or_type_argument_for_Alignas_keyword () const
84920 : {
84921 0 : ROSE_ASSERT (this != NULL);
84922 :
84923 : #if 0
84924 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84925 : // used to trigger marking transformations for the token-based unparsing.
84926 : printf ("SgInitializedName::get_constant_or_type_argument_for_Alignas_keyword = %p = %s \n",this,this->class_name().c_str());
84927 : #endif
84928 :
84929 0 : return p_constant_or_type_argument_for_Alignas_keyword;
84930 : }
84931 :
84932 : void
84933 0 : SgInitializedName::set_constant_or_type_argument_for_Alignas_keyword ( SgNode* constant_or_type_argument_for_Alignas_keyword )
84934 : {
84935 0 : ROSE_ASSERT (this != NULL);
84936 :
84937 : #if 0
84938 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84939 : // used to trigger marking transformations for the token-based unparsing.
84940 : printf ("SgInitializedName::set_constant_or_type_argument_for_Alignas_keyword = %p = %s \n",this,this->class_name().c_str());
84941 : #endif
84942 :
84943 0 : set_isModified(true);
84944 :
84945 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
84946 : if (p_constant_or_type_argument_for_Alignas_keyword != NULL && constant_or_type_argument_for_Alignas_keyword != NULL && p_constant_or_type_argument_for_Alignas_keyword != constant_or_type_argument_for_Alignas_keyword)
84947 : {
84948 : printf ("Warning: constant_or_type_argument_for_Alignas_keyword = %p overwriting valid pointer p_constant_or_type_argument_for_Alignas_keyword = %p \n",constant_or_type_argument_for_Alignas_keyword,p_constant_or_type_argument_for_Alignas_keyword);
84949 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
84950 : printf ("Error fails assertion (p_constant_or_type_argument_for_Alignas_keyword != NULL && constant_or_type_argument_for_Alignas_keyword != NULL && p_constant_or_type_argument_for_Alignas_keyword != constant_or_type_argument_for_Alignas_keyword) is false\n");
84951 : ROSE_ASSERT(false);
84952 : #endif
84953 : }
84954 : #endif
84955 0 : p_constant_or_type_argument_for_Alignas_keyword = constant_or_type_argument_for_Alignas_keyword;
84956 0 : }
84957 :
84958 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84959 :
84960 :
84961 : // End of memberFunctionString
84962 : // Start of memberFunctionString
84963 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
84964 :
84965 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
84966 :
84967 : bool
84968 0 : SgInitializedName::get_using_auto_keyword () const
84969 : {
84970 0 : ROSE_ASSERT (this != NULL);
84971 :
84972 : #if 0
84973 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84974 : // used to trigger marking transformations for the token-based unparsing.
84975 : printf ("SgInitializedName::get_using_auto_keyword = %p = %s \n",this,this->class_name().c_str());
84976 : #endif
84977 :
84978 0 : return p_using_auto_keyword;
84979 : }
84980 :
84981 : void
84982 114 : SgInitializedName::set_using_auto_keyword ( bool using_auto_keyword )
84983 : {
84984 114 : ROSE_ASSERT (this != NULL);
84985 :
84986 : #if 0
84987 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
84988 : // used to trigger marking transformations for the token-based unparsing.
84989 : printf ("SgInitializedName::set_using_auto_keyword = %p = %s \n",this,this->class_name().c_str());
84990 : #endif
84991 :
84992 114 : set_isModified(true);
84993 :
84994 114 : p_using_auto_keyword = using_auto_keyword;
84995 114 : }
84996 :
84997 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
84998 :
84999 :
85000 : // End of memberFunctionString
85001 : // Start of memberFunctionString
85002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85003 :
85004 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85005 :
85006 : SgType *
85007 1323180 : SgInitializedName::get_auto_decltype () const
85008 : {
85009 1323180 : ROSE_ASSERT (this != NULL);
85010 :
85011 : #if 0
85012 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85013 : // used to trigger marking transformations for the token-based unparsing.
85014 : printf ("SgInitializedName::get_auto_decltype = %p = %s \n",this,this->class_name().c_str());
85015 : #endif
85016 :
85017 1323180 : return p_auto_decltype;
85018 : }
85019 :
85020 : void
85021 18 : SgInitializedName::set_auto_decltype ( SgType * auto_decltype )
85022 : {
85023 18 : ROSE_ASSERT (this != NULL);
85024 :
85025 : #if 0
85026 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85027 : // used to trigger marking transformations for the token-based unparsing.
85028 : printf ("SgInitializedName::set_auto_decltype = %p = %s \n",this,this->class_name().c_str());
85029 : #endif
85030 :
85031 18 : set_isModified(true);
85032 :
85033 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
85034 : if (p_auto_decltype != NULL && auto_decltype != NULL && p_auto_decltype != auto_decltype)
85035 : {
85036 : printf ("Warning: auto_decltype = %p overwriting valid pointer p_auto_decltype = %p \n",auto_decltype,p_auto_decltype);
85037 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
85038 : printf ("Error fails assertion (p_auto_decltype != NULL && auto_decltype != NULL && p_auto_decltype != auto_decltype) is false\n");
85039 : ROSE_ASSERT(false);
85040 : #endif
85041 : }
85042 : #endif
85043 18 : p_auto_decltype = auto_decltype;
85044 18 : }
85045 :
85046 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85047 :
85048 :
85049 : // End of memberFunctionString
85050 : // Start of memberFunctionString
85051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85052 :
85053 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85054 :
85055 : bool
85056 4 : SgInitializedName::get_using_device_keyword () const
85057 : {
85058 4 : ROSE_ASSERT (this != NULL);
85059 :
85060 : #if 0
85061 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85062 : // used to trigger marking transformations for the token-based unparsing.
85063 : printf ("SgInitializedName::get_using_device_keyword = %p = %s \n",this,this->class_name().c_str());
85064 : #endif
85065 :
85066 4 : return p_using_device_keyword;
85067 : }
85068 :
85069 : void
85070 0 : SgInitializedName::set_using_device_keyword ( bool using_device_keyword )
85071 : {
85072 0 : ROSE_ASSERT (this != NULL);
85073 :
85074 : #if 0
85075 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85076 : // used to trigger marking transformations for the token-based unparsing.
85077 : printf ("SgInitializedName::set_using_device_keyword = %p = %s \n",this,this->class_name().c_str());
85078 : #endif
85079 :
85080 0 : set_isModified(true);
85081 :
85082 0 : p_using_device_keyword = using_device_keyword;
85083 0 : }
85084 :
85085 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85086 :
85087 :
85088 : // End of memberFunctionString
85089 : // Start of memberFunctionString
85090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85091 :
85092 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85093 :
85094 : bool
85095 0 : SgInitializedName::get_is_braced_initialized () const
85096 : {
85097 0 : ROSE_ASSERT (this != NULL);
85098 :
85099 : #if 0
85100 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85101 : // used to trigger marking transformations for the token-based unparsing.
85102 : printf ("SgInitializedName::get_is_braced_initialized = %p = %s \n",this,this->class_name().c_str());
85103 : #endif
85104 :
85105 0 : return p_is_braced_initialized;
85106 : }
85107 :
85108 : void
85109 0 : SgInitializedName::set_is_braced_initialized ( bool is_braced_initialized )
85110 : {
85111 0 : ROSE_ASSERT (this != NULL);
85112 :
85113 : #if 0
85114 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85115 : // used to trigger marking transformations for the token-based unparsing.
85116 : printf ("SgInitializedName::set_is_braced_initialized = %p = %s \n",this,this->class_name().c_str());
85117 : #endif
85118 :
85119 0 : set_isModified(true);
85120 :
85121 0 : p_is_braced_initialized = is_braced_initialized;
85122 0 : }
85123 :
85124 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85125 :
85126 :
85127 : // End of memberFunctionString
85128 : // Start of memberFunctionString
85129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85130 :
85131 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85132 :
85133 : bool
85134 626 : SgInitializedName::get_using_assignment_copy_constructor_syntax () const
85135 : {
85136 626 : ROSE_ASSERT (this != NULL);
85137 :
85138 : #if 0
85139 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85140 : // used to trigger marking transformations for the token-based unparsing.
85141 : printf ("SgInitializedName::get_using_assignment_copy_constructor_syntax = %p = %s \n",this,this->class_name().c_str());
85142 : #endif
85143 :
85144 626 : return p_using_assignment_copy_constructor_syntax;
85145 : }
85146 :
85147 : void
85148 7567 : SgInitializedName::set_using_assignment_copy_constructor_syntax ( bool using_assignment_copy_constructor_syntax )
85149 : {
85150 7567 : ROSE_ASSERT (this != NULL);
85151 :
85152 : #if 0
85153 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85154 : // used to trigger marking transformations for the token-based unparsing.
85155 : printf ("SgInitializedName::set_using_assignment_copy_constructor_syntax = %p = %s \n",this,this->class_name().c_str());
85156 : #endif
85157 :
85158 7567 : set_isModified(true);
85159 :
85160 7567 : p_using_assignment_copy_constructor_syntax = using_assignment_copy_constructor_syntax;
85161 7567 : }
85162 :
85163 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85164 :
85165 :
85166 : // End of memberFunctionString
85167 : // Start of memberFunctionString
85168 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85169 :
85170 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85171 :
85172 : bool
85173 967 : SgInitializedName::get_needs_definitions () const
85174 : {
85175 967 : ROSE_ASSERT (this != NULL);
85176 :
85177 : #if 0
85178 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85179 : // used to trigger marking transformations for the token-based unparsing.
85180 : printf ("SgInitializedName::get_needs_definitions = %p = %s \n",this,this->class_name().c_str());
85181 : #endif
85182 :
85183 967 : return p_needs_definitions;
85184 : }
85185 :
85186 : void
85187 0 : SgInitializedName::set_needs_definitions ( bool needs_definitions )
85188 : {
85189 0 : ROSE_ASSERT (this != NULL);
85190 :
85191 : #if 0
85192 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85193 : // used to trigger marking transformations for the token-based unparsing.
85194 : printf ("SgInitializedName::set_needs_definitions = %p = %s \n",this,this->class_name().c_str());
85195 : #endif
85196 :
85197 0 : set_isModified(true);
85198 :
85199 0 : p_needs_definitions = needs_definitions;
85200 0 : }
85201 :
85202 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85203 :
85204 :
85205 : // End of memberFunctionString
85206 : // Start of memberFunctionString
85207 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85208 :
85209 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85210 :
85211 : bool
85212 0 : SgInitializedName::get_is_parameter_pack () const
85213 : {
85214 0 : ROSE_ASSERT (this != NULL);
85215 :
85216 : #if 0
85217 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85218 : // used to trigger marking transformations for the token-based unparsing.
85219 : printf ("SgInitializedName::get_is_parameter_pack = %p = %s \n",this,this->class_name().c_str());
85220 : #endif
85221 :
85222 0 : return p_is_parameter_pack;
85223 : }
85224 :
85225 : void
85226 0 : SgInitializedName::set_is_parameter_pack ( bool is_parameter_pack )
85227 : {
85228 0 : ROSE_ASSERT (this != NULL);
85229 :
85230 : #if 0
85231 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85232 : // used to trigger marking transformations for the token-based unparsing.
85233 : printf ("SgInitializedName::set_is_parameter_pack = %p = %s \n",this,this->class_name().c_str());
85234 : #endif
85235 :
85236 0 : set_isModified(true);
85237 :
85238 0 : p_is_parameter_pack = is_parameter_pack;
85239 0 : }
85240 :
85241 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85242 :
85243 :
85244 : // End of memberFunctionString
85245 : // Start of memberFunctionString
85246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
85247 :
85248 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
85249 :
85250 : bool
85251 0 : SgInitializedName::get_is_pack_element () const
85252 : {
85253 0 : ROSE_ASSERT (this != NULL);
85254 :
85255 : #if 0
85256 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85257 : // used to trigger marking transformations for the token-based unparsing.
85258 : printf ("SgInitializedName::get_is_pack_element = %p = %s \n",this,this->class_name().c_str());
85259 : #endif
85260 :
85261 0 : return p_is_pack_element;
85262 : }
85263 :
85264 : void
85265 0 : SgInitializedName::set_is_pack_element ( bool is_pack_element )
85266 : {
85267 0 : ROSE_ASSERT (this != NULL);
85268 :
85269 : #if 0
85270 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
85271 : // used to trigger marking transformations for the token-based unparsing.
85272 : printf ("SgInitializedName::set_is_pack_element = %p = %s \n",this,this->class_name().c_str());
85273 : #endif
85274 :
85275 0 : set_isModified(true);
85276 :
85277 0 : p_is_pack_element = is_pack_element;
85278 0 : }
85279 :
85280 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
85281 :
85282 :
85283 : // End of memberFunctionString
85284 : // Start of memberFunctionString
85285 : /* #line 12173 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
85286 :
85287 :
85288 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
85289 : SgSymbol*
85290 5007840 : SgInitializedName::get_symbol_from_symbol_table() const
85291 : {
85292 5007840 : ROSE_ASSERT(get_scope() != NULL);
85293 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
85294 : // return get_scope()->get_symbol_table()->find(this);
85295 5007840 : return get_scope()->find_symbol_from_declaration(this);
85296 : }
85297 :
85298 : // PC (10/1/2009): Added support to get the symbol from the correct associated declaration
85299 : SgSymbol*
85300 7 : SgInitializedName::search_for_symbol_from_symbol_table() const
85301 : {
85302 7 : SgInitializedName* aPrevDeclItem = p_prev_decl_item;
85303 7 : while(aPrevDeclItem != NULL && aPrevDeclItem->p_prev_decl_item != NULL)
85304 : {
85305 : // DQ (11/19/2011): This loop will not terminate if (aPrevDeclItem->p_prev_decl_item == aPrevDeclItem).
85306 : // This should not happen but this mistake has happened and this assertion helps it be caught instead
85307 : // of be an infinite loop.
85308 0 : ROSE_ASSERT(aPrevDeclItem->p_prev_decl_item != aPrevDeclItem);
85309 :
85310 0 : aPrevDeclItem = aPrevDeclItem->p_prev_decl_item;
85311 : }
85312 :
85313 7 : SgSymbol* symbol=0;
85314 7 : if (aPrevDeclItem != NULL)
85315 7 : symbol = aPrevDeclItem->get_symbol_from_symbol_table();
85316 : else
85317 0 : symbol = get_symbol_from_symbol_table();
85318 :
85319 : // MS: for SgInitializedName in a forward declaration this always fails because no symbol exists. Therefore
85320 : // this assert can be put back, once symbols for such variables are available.
85321 : // assert(symbol != NULL);
85322 7 : return symbol;
85323 : }
85324 :
85325 : // DQ (10/13/2014): Adding a default constructor for compatability with what was previously the API before the newer aterm support.
85326 0 : SgInitializedName::SgInitializedName() ROSE_DEPRECATED_FUNCTION
85327 : : p_name(""),
85328 : p_microsoft_uuid_string(""),
85329 : p_typeptr(NULL),
85330 : p_initptr(NULL),
85331 : p_prev_decl_item(NULL),
85332 : p_is_initializer(true),
85333 : p_declptr(NULL),
85334 : p_storageModifier(NULL),
85335 : p_scope(NULL),
85336 : p_preinitialization(e_unknown_preinitialization),
85337 : p_isCoArray(false),
85338 : p_register_name_code(SgInitializedName::e_invalid_register),
85339 : p_excess_specifier(SgInitializedName::e_excess_specifier_none),
85340 : p_register_name_string(""),
85341 : p_requiresGlobalNameQualificationOnType(false),
85342 : p_shapeDeferred(false),
85343 : p_initializationDeferred(false),
85344 0 : p_gnu_attribute_modifierVector(e_last_gnu_variable_attribute,false),
85345 : p_gnu_attribute_initialization_priority(0),
85346 : p_gnu_attribute_named_weak_reference(""),
85347 : p_gnu_attribute_named_alias(""),
85348 : p_gnu_attribute_cleanup_function(""),
85349 : p_gnu_attribute_section_name(""),
85350 : p_gnu_attribute_alignment(-1),
85351 : p_gnu_attribute_visability(SgDeclarationModifier::e_unknown_visibility),
85352 : p_protected_declaration(false),
85353 : p_name_qualification_length(0),
85354 : p_type_elaboration_required(false),
85355 : p_global_qualification_required(false),
85356 : p_name_qualification_length_for_type(false),
85357 : p_type_elaboration_required_for_type(0),
85358 : p_global_qualification_required_for_type(false),
85359 : p_hasArrayTypeWithEmptyBracketSyntax(false),
85360 : p_using_C11_Alignas_keyword(false),
85361 : p_constant_or_type_argument_for_Alignas_keyword(NULL),
85362 : p_using_auto_keyword(false),
85363 : p_auto_decltype(NULL),
85364 : p_using_device_keyword(false),
85365 : p_is_braced_initialized(false),
85366 : p_using_assignment_copy_constructor_syntax(false),
85367 : p_needs_definitions(false),
85368 : p_is_parameter_pack(false),
85369 0 : p_is_pack_element(false)
85370 : {
85371 : // This constructor has been added to support the previous API, I would like to depricate it.
85372 0 : }
85373 :
85374 : SgStorageModifier &
85375 3245120 : SgInitializedName::get_storageModifier()
85376 : {
85377 3245120 : assert (this != NULL);
85378 3245120 : assert (p_storageModifier != NULL);
85379 3245120 : return *p_storageModifier;
85380 : }
85381 :
85382 : const SgStorageModifier &
85383 39638 : SgInitializedName::get_storageModifier() const
85384 : {
85385 39638 : assert (this != NULL);
85386 39638 : assert (p_storageModifier != NULL);
85387 39638 : return *p_storageModifier;
85388 : }
85389 :
85390 : SgName
85391 54 : SgInitializedName::get_qualified_name() const
85392 : {
85393 : // DQ (8/22/2005): This function is similar to the one for SgClassDeclaration.
85394 : // This function calls get_scope() which uses the parent pointers, thus
85395 : // it should not be called before the parent pointers are set (within the AST fixup after
85396 : // the Sage III AST is fully constructed).
85397 :
85398 : // mprintf ("In SgInitializedName::get_qualified_name() name = %s \n",get_name().str());
85399 :
85400 54 : SgName returnName;
85401 :
85402 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
85403 54 : SgScopeStatement* scope = get_scope();
85404 54 : assert(scope != NULL);
85405 :
85406 54 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
85407 :
85408 : // mprintf ("In SgInitializedName::get_qualified_name() returnName = %s \n",returnName.str());
85409 :
85410 54 : return returnName;
85411 : }
85412 :
85413 :
85414 : SgName
85415 2390 : SgInitializedName::get_qualified_name_prefix() const
85416 : {
85417 : // DQ (12/16/2013): Added support for name qualification on SgInitializedName for use in preinitialization lists.
85418 :
85419 2390 : SgName nameQualifier;
85420 2390 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgInitializedName*>(this));
85421 :
85422 2390 : if (i != SgNode::get_globalQualifiedNameMapForNames().end())
85423 : {
85424 19 : nameQualifier = i->second;
85425 : #if 0
85426 : mprintf ("In SgInitializedName::get_qualified_name_prefix(): Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
85427 : #endif
85428 : }
85429 :
85430 : #if 0
85431 : mprintf ("In SgInitializedName::get_qualified_name_prefix(): nameQualifier for SgInitializedName = %s = %s \n",class_name().c_str(),nameQualifier.str());
85432 : #endif
85433 :
85434 2390 : return nameQualifier;
85435 : }
85436 :
85437 :
85438 : SgName
85439 1185700 : SgInitializedName::get_qualified_name_prefix_for_type() const
85440 : {
85441 : // DQ (5/29/2011): Added to support for new qualified name generation.
85442 :
85443 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
85444 : // different and so it depends upon where the type is referenced. Thus the qualified name is
85445 : // stored in a map to the IR node that references the type.
85446 1185700 : SgName nameQualifier;
85447 1185700 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgInitializedName*>(this));
85448 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
85449 :
85450 1185700 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
85451 : {
85452 1183930 : nameQualifier = i->second;
85453 : #if 0
85454 : mprintf ("SgInitializedName::get_qualified_name_prefix_for_type(): Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
85455 : #endif
85456 : }
85457 :
85458 : #if 0
85459 : mprintf ("SgInitializedName::get_qualified_name_prefix_for_type(): nameQualifier for SgInitializedName = %s = %s \n",class_name().c_str(),nameQualifier.str());
85460 : #endif
85461 :
85462 1185700 : return nameQualifier;
85463 : }
85464 :
85465 :
85466 : void
85467 6373160 : SgInitializedName::post_construction_initialization()
85468 : {
85469 : // Liao 11/5/2010, for debugging purpose
85470 : // if (p_name.getString() == string("a0"))
85471 : // abort();
85472 : // JJW 10-26-2007 ensure that this object is not on the stack
85473 6373160 : preventConstructionOnStack(this);
85474 :
85475 : // mprintf ("In SgInitializedName::post_construction_initialization() this = %p \n",this);
85476 :
85477 6373160 : p_storageModifier = new SgStorageModifier();
85478 6373160 : assert (p_storageModifier != NULL);
85479 6373160 : p_storageModifier->setDefault();
85480 :
85481 : // DQ (6/20/2006): Set the parent of the SgStorageModifier
85482 6373160 : p_storageModifier->set_parent(this);
85483 :
85484 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
85485 : // a pointer and the interface represented directly at the SgNode
85486 : // DQ (1/17/2006): Added initialization to prevent valgrind warning.
85487 6373160 : p_attributeMechanism = NULL;
85488 :
85489 : // DQ (11/19/2004): Added to support explicit scopes for variables within variable declarations.
85490 6373160 : p_scope = NULL;
85491 :
85492 : // DQ (12/17/2006): Added semantics that constructors (which are structural) should set the parents of their inputs.
85493 6373160 : if (p_initptr != NULL)
85494 : {
85495 : // mprintf ("In SgInitializedName::post_construction_initialization(): resetting parent of valid initializer (p_initptr = %p) \n",p_initptr);
85496 12874 : p_initptr->set_parent(this);
85497 : }
85498 :
85499 : // DQ (1/3/2009): Added support for GNU variable attributes (std::strings will default to null, so they are not setup).
85500 6373160 : p_gnu_attribute_modifierVector = SgBitVector(e_last_gnu_variable_attribute,false);
85501 6373160 : p_gnu_attribute_initialization_priority = 0;
85502 :
85503 : // DQ (3/1/2013): Changed default value to -1 and type to signed short so that we could reserve negative values to be a marked for not explicitly specified.
85504 6373160 : p_gnu_attribute_alignment = -1;
85505 :
85506 : // Borrow the enum definition (and default value from SgDeclarationModifier).
85507 6373160 : p_gnu_attribute_visability = SgDeclarationModifier::e_unknown_visibility;
85508 :
85509 : // FMZ added for coarray
85510 6373160 : p_isCoArray = false;
85511 :
85512 : // DQ (10/26/2010): These were not properly initialized.
85513 6373160 : p_shapeDeferred = false;
85514 6373160 : p_initializationDeferred = false;
85515 6373160 : p_protected_declaration = false;
85516 :
85517 : // DQ (2/5/2014): I just noticed that the initialization of these were missing.
85518 6373160 : p_name_qualification_length_for_type = 0;
85519 6373160 : p_type_elaboration_required_for_type = false;
85520 6373160 : p_global_qualification_required_for_type = false;
85521 :
85522 : // DQ (2/2/2014): The secondary declaration for an array may be specified using empty bracket sysntax.
85523 6373160 : p_hasArrayTypeWithEmptyBracketSyntax = false;
85524 :
85525 : // DQ (7/27/2014): Added support for C11 "_Alignas" keyword (alternative alignment specification).
85526 6373160 : p_using_C11_Alignas_keyword = false;
85527 6373160 : p_constant_or_type_argument_for_Alignas_keyword = NULL;
85528 :
85529 : // DQ (8/2/2014): Adding support for C++11 auto keyword.
85530 6373160 : p_using_auto_keyword = false;
85531 6373160 : p_auto_decltype = NULL;
85532 :
85533 : // DQ (1/24/2016): Adding support to mark this to use the __device__ keyword.
85534 6373160 : p_using_device_keyword = false;
85535 :
85536 : // DQ (6/10/2012): Testing for test2012_102.C.
85537 : // mprintf ("In SgInitializedName::post_construction_initialization(): this = %p \n",this);
85538 6373160 : }
85539 :
85540 : // This constructor is specific to the creation of SgInitializedName objects used as initializers
85541 6373120 : SgInitializedName::SgInitializedName (
85542 : const SgName& name, SgType *typeptr, SgInitializer* iptr,
85543 : SgDeclarationStatement *declptr,
85544 : SgInitializedName *prev_itemptr
85545 6373120 : ) ROSE_DEPRECATED_FUNCTION :
85546 : p_name(name),
85547 : p_microsoft_uuid_string(""),
85548 : p_typeptr(typeptr),
85549 : p_initptr(iptr),
85550 : p_prev_decl_item(prev_itemptr),
85551 : p_is_initializer(true),
85552 : p_declptr(declptr),
85553 : p_storageModifier(NULL),
85554 : p_scope(NULL),
85555 : p_preinitialization(e_unknown_preinitialization),
85556 : p_isCoArray(false),
85557 : p_register_name_code(SgInitializedName::e_invalid_register),
85558 : p_excess_specifier(SgInitializedName::e_excess_specifier_none),
85559 : p_register_name_string(""),
85560 : p_requiresGlobalNameQualificationOnType(false),
85561 : p_shapeDeferred(false),
85562 : p_initializationDeferred(false),
85563 6373120 : p_gnu_attribute_modifierVector(e_last_gnu_variable_attribute,false),
85564 : p_gnu_attribute_initialization_priority(0),
85565 : p_gnu_attribute_named_weak_reference(""),
85566 : p_gnu_attribute_named_alias(""),
85567 : p_gnu_attribute_cleanup_function(""),
85568 : p_gnu_attribute_section_name(""),
85569 : p_gnu_attribute_alignment(-1),
85570 : p_gnu_attribute_visability(SgDeclarationModifier::e_unknown_visibility),
85571 : p_protected_declaration(false),
85572 : p_name_qualification_length(0),
85573 : p_type_elaboration_required(false),
85574 : p_global_qualification_required(false),
85575 : p_name_qualification_length_for_type(false),
85576 : p_type_elaboration_required_for_type(0),
85577 : p_global_qualification_required_for_type(false),
85578 : p_hasArrayTypeWithEmptyBracketSyntax(false),
85579 : p_using_C11_Alignas_keyword(false),
85580 : p_constant_or_type_argument_for_Alignas_keyword(NULL),
85581 : p_using_auto_keyword(false),
85582 : p_auto_decltype(NULL),
85583 : p_using_device_keyword(false),
85584 : p_is_braced_initialized(false),
85585 : p_using_assignment_copy_constructor_syntax(false),
85586 : p_needs_definitions(false),
85587 : p_is_parameter_pack(false),
85588 6373120 : p_is_pack_element(false)
85589 : {
85590 6373120 : post_construction_initialization();
85591 6373120 : }
85592 :
85593 0 : SgInitializedName::SgInitializedName(
85594 : Sg_File_Info* fileInfo, const SgName& name, SgType *typeptr, SgInitializer* iptr,
85595 : SgDeclarationStatement *declptr, SgScopeStatement* scope, SgInitializedName *prev_itemptr
85596 0 : ) :
85597 : p_name(name),
85598 : p_microsoft_uuid_string(""),
85599 : p_typeptr(typeptr),
85600 : p_initptr(iptr),
85601 : p_prev_decl_item(prev_itemptr),
85602 : p_is_initializer(true),
85603 : p_declptr(declptr),
85604 : p_storageModifier(NULL),
85605 : p_scope(scope),
85606 : p_preinitialization(e_unknown_preinitialization),
85607 : p_isCoArray(false),
85608 : p_register_name_code(SgInitializedName::e_invalid_register),
85609 : p_excess_specifier(SgInitializedName::e_excess_specifier_none),
85610 : p_register_name_string(""),
85611 : p_requiresGlobalNameQualificationOnType(false),
85612 : p_shapeDeferred(false),
85613 : p_initializationDeferred(false),
85614 0 : p_gnu_attribute_modifierVector(e_last_gnu_variable_attribute,false),
85615 : p_gnu_attribute_initialization_priority(0),
85616 : p_gnu_attribute_named_weak_reference(""),
85617 : p_gnu_attribute_named_alias(""),
85618 : p_gnu_attribute_cleanup_function(""),
85619 : p_gnu_attribute_section_name(""),
85620 : p_gnu_attribute_alignment(-1),
85621 : p_gnu_attribute_visability(SgDeclarationModifier::e_unknown_visibility),
85622 : p_protected_declaration(false),
85623 : p_name_qualification_length(0),
85624 : p_type_elaboration_required(false),
85625 : p_global_qualification_required(false),
85626 : p_name_qualification_length_for_type(false),
85627 : p_type_elaboration_required_for_type(0),
85628 : p_global_qualification_required_for_type(false),
85629 : p_hasArrayTypeWithEmptyBracketSyntax(false),
85630 : p_using_C11_Alignas_keyword(false),
85631 : p_constant_or_type_argument_for_Alignas_keyword(NULL),
85632 : p_using_auto_keyword(false),
85633 : p_auto_decltype(NULL),
85634 : p_using_device_keyword(false),
85635 : p_is_braced_initialized(false),
85636 : p_using_assignment_copy_constructor_syntax(false),
85637 : p_needs_definitions(false),
85638 : p_is_parameter_pack(false),
85639 0 : p_is_pack_element(false)
85640 : {
85641 0 : p_startOfConstruct = fileInfo;
85642 0 : post_construction_initialization();
85643 0 : }
85644 :
85645 0 : SgInitializedName::SgInitializedName (const SgInitializedName& ptr)
85646 : {
85647 0 : p_name = ptr.p_name;
85648 :
85649 0 : p_typeptr = ptr.p_typeptr;
85650 0 : p_initptr = ptr.p_initptr;
85651 :
85652 : // DQ (12/17/2006): Added semantics that constructors (which are structural) should set the parents of their inputs.
85653 0 : if (p_initptr != NULL)
85654 : {
85655 0 : mprintf ("In SgInitializedName constructor: resetting parent of valid initializer (p_initptr = %p) (likely sharing violation in copy constructor) \n",p_initptr);
85656 0 : p_initptr->set_parent(this);
85657 : }
85658 :
85659 : // p_prev_itemptr = ptr.p_prev_itemptr;
85660 0 : p_is_initializer = ptr.p_is_initializer;
85661 0 : p_declptr = ptr.p_declptr;
85662 : // p_itemptr = ptr.p_itemptr;
85663 :
85664 : // DQ (1/18/2006): Avoid reusing Sg_File_Info objects
85665 : // p_fileInfo = ptr.p_fileInfo;
85666 : // p_file_info = (ptr.p_file_info != NULL) ? new Sg_File_Info(*ptr.p_file_info) : NULL;
85667 :
85668 : // DQ (12/17/2006): See if we can enforce this!
85669 : // p_startOfConstruct = (ptr.p_startOfConstruct != NULL) ? new Sg_File_Info(*ptr.p_startOfConstruct) : NULL;
85670 0 : assert(ptr.p_startOfConstruct != NULL);
85671 0 : p_startOfConstruct = new Sg_File_Info(*ptr.p_startOfConstruct);
85672 0 : assert(p_startOfConstruct != NULL);
85673 :
85674 : // DQ (12/17/2006): Fixup the parent of the new or borrowed Sg_File_Info object.
85675 0 : p_startOfConstruct->set_parent(this);
85676 :
85677 : // DQ (11/19/2004): Added to support explicit scopes for variables within variable declarations.
85678 0 : p_scope = ptr.p_scope;
85679 :
85680 : // DQ (3/1/2005): Added to avoid valgrind warning about uninitialized use
85681 0 : p_preinitialization = ptr.p_preinitialization;
85682 :
85683 : // DQ (4/28/2004): Added storage modifier support (replacing the old interface)
85684 0 : assert (ptr.p_storageModifier != NULL);
85685 0 : p_storageModifier = new SgStorageModifier ( *(ptr.p_storageModifier) );
85686 0 : assert (p_storageModifier != NULL);
85687 :
85688 : // DQ (6/20/2006): Set the parent of the SgStorageModifier
85689 0 : p_storageModifier->set_parent(this);
85690 :
85691 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
85692 : // a pointer and the interface represented directly at the SgNode
85693 : // DQ (1/17/2006): Moved attribute mechanism to specific IR nodes
85694 0 : p_attributeMechanism = NULL;
85695 :
85696 : // DQ (7/31/2006): Added support for asm declarations on variables (using GNU register codes)
85697 0 : p_register_name_code = SgInitializedName::e_invalid_register;
85698 :
85699 : // DQ (8/9/2006): Added support for asm declarations on variables (using strings)
85700 : // Note: don't copy the register string (I think this is best, but it is debatable)
85701 0 : p_register_name_string = "";
85702 :
85703 : // DQ (10/10/2007): Added support for initialization of this data member (reported as uninitialized by valgrind).
85704 0 : p_requiresGlobalNameQualificationOnType = ptr.p_requiresGlobalNameQualificationOnType;
85705 :
85706 : // DQ (1/3/2009): Added support for GNU variable attribues
85707 0 : p_gnu_attribute_modifierVector = ptr.p_gnu_attribute_modifierVector;
85708 0 : p_gnu_attribute_initialization_priority = ptr.p_gnu_attribute_initialization_priority;
85709 0 : p_gnu_attribute_alignment = ptr.p_gnu_attribute_alignment;
85710 0 : p_gnu_attribute_visability = ptr.p_gnu_attribute_visability;
85711 0 : p_isCoArray = ptr.p_isCoArray;
85712 :
85713 : // DQ (10/26/2010): Previously uninitialized data members.
85714 0 : p_shapeDeferred = ptr.p_shapeDeferred;
85715 0 : p_initializationDeferred = ptr.p_initializationDeferred;
85716 0 : p_protected_declaration = ptr.p_protected_declaration;
85717 :
85718 : // DQ (2/5/2014): I just noticed that the initialization of these were missing.
85719 0 : p_name_qualification_length_for_type = ptr.p_name_qualification_length_for_type;
85720 0 : p_type_elaboration_required_for_type = ptr.p_type_elaboration_required_for_type;
85721 0 : p_global_qualification_required_for_type = ptr.p_global_qualification_required_for_type;
85722 :
85723 :
85724 : // DQ (2/2/2014): The secondary declaration for an array may be specified using empty bracket sysntax.
85725 0 : p_hasArrayTypeWithEmptyBracketSyntax = ptr.p_hasArrayTypeWithEmptyBracketSyntax;
85726 :
85727 : // DQ (7/27/2014): Added support for C11 "_Alignas" keyword (alternative alignment specification).
85728 0 : p_using_C11_Alignas_keyword = ptr.p_using_C11_Alignas_keyword;
85729 0 : p_constant_or_type_argument_for_Alignas_keyword = ptr.p_constant_or_type_argument_for_Alignas_keyword;
85730 :
85731 : // DQ (8/2/2014): Adding support for C++11 auto keyword.
85732 0 : p_using_auto_keyword = ptr.p_using_auto_keyword;
85733 0 : p_auto_decltype = ptr.p_auto_decltype;
85734 :
85735 : // DQ (1/24/2016): Adding support to mark this to use the __device__ keyword.
85736 0 : p_using_device_keyword = ptr.p_using_device_keyword;
85737 0 : }
85738 :
85739 : SgInitializedName&
85740 0 : SgInitializedName::operator= (const SgInitializedName& ptr)
85741 : {
85742 0 : assert(this != NULL);
85743 :
85744 : /* check they are not the same name */
85745 0 : if (this != &ptr)
85746 : {
85747 0 : p_name = ptr.p_name;
85748 :
85749 0 : p_typeptr = ptr.p_typeptr;
85750 0 : p_initptr = ptr.p_initptr;
85751 :
85752 : // DQ (12/17/2006): Added semantics that constructors (which are structural) should set the parents of their inputs.
85753 0 : if (p_initptr != NULL)
85754 : {
85755 : // mprintf ("In SgInitializedName constructor: resetting parent of valid initializer (p_initptr = %p) (likely sharing violation in operator=) \n",p_initptr);
85756 : #if 0
85757 : // DQ (12/22/2006): Don't allow the parent of the input SgInitializedName to be modified, but make sure that it is set!
85758 : // p_initptr->set_parent(this);
85759 : if (p_initptr->get_parent() == NULL)
85760 : {
85761 : p_initptr->set_parent(this);
85762 : }
85763 : #else
85764 : // DQ (12/22/2006): Interestingly, the inliner is dependent upon this working this way! We should maybe look into this later.
85765 0 : p_initptr->set_parent(this);
85766 : #endif
85767 0 : assert(p_initptr->get_parent() != NULL);
85768 :
85769 : // mprintf ("Exiting as a test! operator= \n");
85770 : // assert(false);
85771 : }
85772 :
85773 : // p_prev_itemptr = ptr.p_prev_itemptr;
85774 0 : p_is_initializer = ptr.p_is_initializer;
85775 0 : p_declptr = ptr.p_declptr;
85776 : // p_itemptr = ptr.p_itemptr;
85777 :
85778 : // DQ (1/18/2006): Avoid reusing Sg_File_Info objects
85779 : // p_fileInfo = ptr.p_fileInfo;
85780 :
85781 : // DQ (6/23/2006): Added assertion to detect errors
85782 : // assert(ptr.p_file_info != NULL);
85783 : // p_file_info = (ptr.p_file_info != NULL) ? new Sg_File_Info(*ptr.p_file_info) : NULL;
85784 : // assert(p_file_info != NULL);
85785 0 : assert(ptr.p_startOfConstruct != NULL);
85786 : // p_startOfConstruct = (ptr.p_startOfConstruct != NULL) ? new Sg_File_Info(*ptr.p_startOfConstruct) : NULL;
85787 0 : p_startOfConstruct = new Sg_File_Info(*ptr.p_startOfConstruct);
85788 0 : assert(p_startOfConstruct != NULL);
85789 :
85790 : // DQ (12/17/2006): Fixup the parent of the new or borrowed Sg_File_Info object.
85791 0 : p_startOfConstruct->set_parent(this);
85792 :
85793 : // DQ (11/19/2004): Added to support explicit scopes for variables within variable declarations.
85794 0 : p_scope = ptr.p_scope;
85795 :
85796 : // DQ (3/1/2005): Added to avoid valgrind warning about uninitialized use
85797 0 : p_preinitialization = ptr.p_preinitialization;
85798 :
85799 0 : assert (p_storageModifier != NULL);
85800 0 : *p_storageModifier = *(ptr.p_storageModifier);
85801 :
85802 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
85803 : // a pointer and the interface represented directly at the SgNode
85804 : // DQ (1/17/2006): Moved attribute mechanism to specific IR nodes
85805 0 : p_attributeMechanism = NULL;
85806 :
85807 : // DQ (7/31/2006): Added support for asm declarations on variables
85808 0 : p_register_name_code = ptr.p_register_name_code;
85809 :
85810 : // DQ (7/31/2006): Added support for asm declarations on variables
85811 0 : p_register_name_string = ptr.p_register_name_string;
85812 :
85813 : // DQ (10/10/2007): Added support for initialization of this data member (reported as uninitialized by valgrind).
85814 0 : p_requiresGlobalNameQualificationOnType = ptr.p_requiresGlobalNameQualificationOnType;
85815 :
85816 : // DQ (1/3/2009): Added support for GNU variable attribues
85817 0 : p_gnu_attribute_modifierVector = ptr.p_gnu_attribute_modifierVector;
85818 0 : p_gnu_attribute_initialization_priority = ptr.p_gnu_attribute_initialization_priority;
85819 0 : p_gnu_attribute_alignment = ptr.p_gnu_attribute_alignment;
85820 0 : p_gnu_attribute_visability = ptr.p_gnu_attribute_visability;
85821 0 : p_isCoArray = ptr.p_isCoArray;
85822 :
85823 : // DQ (2/5/2014): I just noticed that the initialization of these were missing.
85824 0 : p_name_qualification_length_for_type = ptr.p_name_qualification_length_for_type;
85825 0 : p_type_elaboration_required_for_type = ptr.p_type_elaboration_required_for_type;
85826 0 : p_global_qualification_required_for_type = ptr.p_global_qualification_required_for_type;
85827 :
85828 : // DQ (2/2/2014): The secondary declaration for an array may be specified using empty bracket sysntax.
85829 0 : p_hasArrayTypeWithEmptyBracketSyntax = ptr.p_hasArrayTypeWithEmptyBracketSyntax;
85830 :
85831 : // DQ (7/27/2014): Added support for C11 "_Alignas" keyword (alternative alignment specification).
85832 0 : p_using_C11_Alignas_keyword = ptr.p_using_C11_Alignas_keyword;
85833 0 : p_constant_or_type_argument_for_Alignas_keyword = ptr.p_constant_or_type_argument_for_Alignas_keyword;
85834 :
85835 : // DQ (8/2/2014): Adding support for C++11 auto keyword.
85836 0 : p_using_auto_keyword = ptr.p_using_auto_keyword;
85837 :
85838 : // DQ (1/24/2016): Adding support to mark this to use the __device__ keyword.
85839 0 : p_using_device_keyword = ptr.p_using_device_keyword;
85840 : }
85841 : else
85842 : {
85843 : // DQ (6/23/2006): Added debugging message to track this issue.
85844 0 : mprintf ("SgInitializedName::operator=(): Attempt to copy self to self \n");
85845 : }
85846 :
85847 : // assert(p_file_info != NULL);
85848 0 : assert(p_startOfConstruct != NULL);
85849 :
85850 0 : return *this;
85851 : }
85852 :
85853 : bool
85854 0 : SgInitializedName::operator== (const SgInitializedName& ) const
85855 0 : { return false; }
85856 :
85857 : bool
85858 0 : SgInitializedName::operator< (const SgInitializedName&) const
85859 0 : { return false; }
85860 :
85861 : #if 0
85862 : // DQ (10/9/2007): Use the ROSETTA generated version to test failure
85863 :
85864 : // DQ (12/9/2004): This is how an automatically generated function!
85865 : SgName
85866 : SgInitializedName::get_name() const
85867 : {
85868 : assert (this != NULL);
85869 : return p_name;
85870 : }
85871 : #endif
85872 :
85873 : #if 0
85874 : void
85875 : SgInitializedName::set_name ( SgName name )
85876 : {
85877 : assert (this != NULL);
85878 :
85879 : p_name = name;
85880 : }
85881 : #endif
85882 :
85883 : #if 0
85884 : // DQ (10/9/2007): Use the ROSETTA generated version to test failure
85885 :
85886 : // DQ (10/5/2007): This was a mistake to comment out, we want this functionality. It is likely that
85887 : // similar function ality should be provided for all other names declarations that generate symbols
85888 : // for the symbol table.
85889 : // DQ (12/9/2004): This is now an automatically generated function!
85890 : // AJ (10/21/2004): Added support for changing the symbol name associated with an SgInitializedName
85891 : // by updating the symbol table
85892 : int
85893 : SgInitializedName::set_name(SgName new_name)
85894 : {
85895 : // This function could likely be simpler now that we have better symbol table support.
85896 :
85897 : set_isModified(true);
85898 :
85899 : // find the appropriate symbol table.
85900 : SgNode * node = this;
85901 :
85902 : // DQ (12/9/2004): This should likely call the get_scope function (which is more robust than traversing
85903 : // parents, there is a reason why we are forced to include the scope explicitly on some IR nodes,
85904 : // see test2004_133.C for details).
85905 : while((node!=NULL) && ( isSgScopeStatement(node)==NULL))
85906 : node = node->get_parent();
85907 :
85908 : assert(node!=NULL);
85909 :
85910 : SgScopeStatement * scope_stmt = isSgScopeStatement(node);
85911 :
85912 : assert(scope_stmt != NULL);
85913 : assert(scope_stmt->get_symbol_table() != NULL);
85914 : assert(scope_stmt->get_symbol_table()->get_table() != NULL);
85915 :
85916 : SgDeclarationStatement * parent_declaration = get_declaration();
85917 :
85918 : assert(parent_declaration != NULL);
85919 :
85920 : // Find the symbols associated with p_name
85921 : std::pair<SgSymbolTable::hash_iterator,SgSymbolTable::hash_iterator> pair_it =
85922 : scope_stmt->get_symbol_table()->get_table()->equal_range(p_name);
85923 :
85924 : SgSymbolTable::hash_iterator found_it=scope_stmt->get_symbol_table()->get_table()->end();
85925 :
85926 : for(SgSymbolTable::hash_iterator it = pair_it.first; it != pair_it.second; ++it)
85927 : {
85928 : switch(parent_declaration->getVariant())
85929 : {
85930 : case V_SgVariableDeclaration:
85931 : {
85932 : if (isSgVariableSymbol((*it).second)!=NULL)
85933 : found_it = it;
85934 : break;
85935 : }
85936 : case V_SgClassDeclaration:
85937 : {
85938 : if (isSgClassSymbol((*it).second)!=NULL)
85939 : found_it = it;
85940 : break;
85941 : }
85942 : case V_SgFunctionDeclaration:
85943 : {
85944 : if (isSgFunctionSymbol((*it).second)!=NULL)
85945 : found_it = it;
85946 : break;
85947 : }
85948 : default:
85949 : {
85950 : }
85951 : };
85952 : }
85953 :
85954 : // there is no Variable,Class or Function symbol associated with p_name
85955 : if (found_it == scope_stmt->get_symbol_table()->get_table()->end())
85956 : {
85957 : mprintf ("Warning: There is no Variable,Class or Function symbol associated with p_name \n");
85958 : return 0;
85959 : }
85960 :
85961 : SgSymbol * associated_symbol = (*found_it).second;
85962 :
85963 : // erase the name from there
85964 : scope_stmt->get_symbol_table()->get_table()->erase(found_it);
85965 :
85966 : // insert the new_name in the symbol table
85967 : found_it = scope_stmt->get_symbol_table()->get_table()->insert(pair<SgName,SgSymbol*> ( new_name,associated_symbol));
85968 :
85969 : // if insertion failed
85970 : if (found_it == scope_stmt->get_symbol_table()->get_table()->end())
85971 : {
85972 : mprintf ("Warning: insertion of new symbol failed \n");
85973 : return 0;
85974 : }
85975 :
85976 : // Set the p_name to the new_name
85977 : mprintf ("Reset p_name = %s to new_name = %s \n",p_name.str(),new_name.str());
85978 : p_name = new_name;
85979 :
85980 : // Invalidate the p_iterator, p_no_name and p_name data members in the Symbol table
85981 :
85982 : return 1;
85983 : }
85984 : #endif
85985 :
85986 : SgType*
85987 30078000 : SgInitializedName::get_type() const
85988 : {
85989 30078000 : assert(this != NULL);
85990 30078000 : return p_typeptr;
85991 : }
85992 :
85993 : void
85994 46 : SgInitializedName::set_type(SgType *t)
85995 : {
85996 46 : assert(this != NULL);
85997 :
85998 : // DQ (4/14/2015): Added call to set_isModified() function to record change to this IR node.
85999 46 : set_isModified(true);
86000 :
86001 46 : p_typeptr = t;
86002 46 : }
86003 :
86004 : SgInitializer*
86005 3199800 : SgInitializedName::get_initializer() const
86006 : {
86007 : // DQ (12/17/2006): These should be able to be generated by ROSETTA!
86008 : // The semantics of p_is_initializer appears to not be required.
86009 :
86010 3199800 : assert(this != NULL);
86011 3199800 : if (p_is_initializer)
86012 3199800 : return p_initptr;
86013 : else
86014 : return NULL;
86015 : }
86016 :
86017 : void
86018 40901 : SgInitializedName::set_initializer(SgInitializer* i)
86019 : {
86020 : // DQ (12/17/2006): These should be able to be generated by ROSETTA!
86021 : // The semantics of p_is_initializer appears to not be required.
86022 :
86023 40901 : assert(this != NULL);
86024 :
86025 : // DQ (4/14/2015): Added call to set_isModified() function to record change to this IR node.
86026 40901 : set_isModified(true);
86027 :
86028 40901 : p_initptr = i;
86029 40901 : p_is_initializer = 1;
86030 40901 : }
86031 :
86032 :
86033 : // DQ (3/31/2006): New version from Rich (fixes bug where empty mangled name was generated)
86034 : SgName
86035 12100000 : SgInitializedName::get_mangled_name (void) const
86036 : {
86037 12100000 : SgName mangled_name; // return value
86038 :
86039 : // Case 1: Function parameters.
86040 : // Generate names for parameters such that
86041 : // int foo (int x, int y) { return x + y; }
86042 : // int foo (int, int);
86043 : // int foo (int a, int b);
86044 : // all generate the same unique names for equivalent parameters.
86045 12100000 : const SgFunctionParameterList* func_params = isSgFunctionParameterList (get_declaration ());
86046 12100000 : if (func_params)
86047 : {
86048 : // Find position (parameter number) in parameter list
86049 11988500 : const SgInitializedNamePtrList& func_args = func_params->get_args ();
86050 11988500 : SgInitializedNamePtrList::const_iterator i;
86051 11988500 : size_t param_num = 0;
86052 25355300 : for (i = func_args.begin (); i != func_args.end () && *i != this; ++i)
86053 13366800 : param_num++;
86054 11988500 : if (i != func_args.end ()) // found position
86055 : {
86056 : // Compute a mangled prefix from the function declaration.
86057 11988500 : ostringstream s;
86058 11988500 : const SgFunctionDeclaration* func_decl = isSgFunctionDeclaration (func_params->get_parent ());
86059 11988500 : if (func_decl)
86060 11988500 : s << func_decl->get_mangled_name ().str ();
86061 11988500 : s << "__ARG" << param_num+1; // Append argument number (1-based)
86062 20994600 : mangled_name = SgName (s.str ());
86063 : }
86064 : // else, an error (see below).
86065 : }
86066 : else // Case 2: Not a function parameter
86067 : {
86068 111511 : SgScopeStatement* scope = get_scope ();
86069 111511 : if (scope == NULL)
86070 : {
86071 0 : mprintf ("SgInitializedName = %p = %s \n",this,get_name().str());
86072 0 : get_file_info()->display("Error scope of SgInitializedName == NULL");
86073 : }
86074 111511 : assert (scope != NULL);
86075 :
86076 223022 : SgName qual_name = mangleQualifiers (scope);
86077 :
86078 223022 : SgName name = get_name();
86079 111511 : if (name.get_length() > 0) // not empty
86080 : {
86081 109398 : mangled_name = joinMangledQualifiers (qual_name, get_name ());
86082 : }
86083 : else
86084 : {
86085 : // name is empty
86086 2113 : if (isSgCatchOptionStmt (scope)) // e.g., 'try {...} catch (int) {...}
86087 : {
86088 1890 : mangled_name = joinMangledQualifiers (qual_name, SgName ("CATCHARG"));
86089 : }
86090 : else
86091 : {
86092 : // mprintf ("Must be a padding declaration (e.g. int:16) \n");
86093 223 : mangled_name = joinMangledQualifiers (qual_name, SgName ("PADDING_VARIABLE"));
86094 : }
86095 : }
86096 : }
86097 :
86098 12100000 : if (!mangled_name.get_length ()) // Error: could not come up with a name.
86099 : {
86100 0 : mprintf ("Error in SgInitializedName::get_mangled_name(void): zero length mangled name generated (see if this is realistic)\n");
86101 0 : SgScopeStatement* scope = get_scope ();
86102 0 : assert (scope);
86103 0 : mprintf (" Surrounding scope is '%s'\n", scope->sage_class_name ());
86104 0 : const SgDeclarationStatement* decl = get_declaration ();
86105 0 : mprintf (" Decl is '%s'\n", decl ? decl->sage_class_name () : "(none)");
86106 0 : const SgDeclarationStatement* def = get_definition ();
86107 0 : mprintf (" Def is '%s'\n", def ? def->sage_class_name () : "(none)");
86108 0 : const SgNode* par = decl ? decl->get_parent () : 0;
86109 0 : mprintf (" Parent(decl) is '%s'\n", par ? par->sage_class_name () : "(none)");
86110 :
86111 : // DQ (2/21/2007): I think this is OK for un-named function parameters, leave as a warning for now!.
86112 : // assert(false);
86113 : }
86114 :
86115 12100000 : return mangled_name;
86116 : }
86117 :
86118 :
86119 : // QY 11/3/04
86120 : SgDeclarationStatement*
86121 15112700 : SgInitializedName::get_declaration() const
86122 : {
86123 15112700 : assert (this != NULL);
86124 : // DQ (6/13/2005): This function assumes that the parents have been set!
86125 : // so it should not be used in the EDG/Sage translation!
86126 : // assert(get_parent() != NULL);
86127 :
86128 : #if 1
86129 : // DQ (6/21/2006): Return to using this version of the code
86130 : // DQ (6/21/2005): This is trying to traverse back through the scopes which might not make sense
86131 15118100 : for (SgNode* r = get_parent(); r != NULL; r = r->get_parent())
86132 : {
86133 15116200 : SgDeclarationStatement* d = isSgDeclarationStatement(r);
86134 :
86135 : // DQ (6/21/2005): I think this should always be true!
86136 : // assert(d != NULL);
86137 :
86138 15116200 : if (d != NULL)
86139 : {
86140 15110800 : return d;
86141 : }
86142 : }
86143 :
86144 : return NULL;
86145 : #else
86146 : // DQ (6/18/2006): Since we store the declaration we should use the explictly stored
86147 : // value instead of anything generated from parents (structure can be problematic for C++).
86148 : return get_declptr();
86149 : #endif
86150 : }
86151 :
86152 : SgDeclarationStatement*
86153 86425 : SgInitializedName::get_definition() const
86154 : {
86155 : // mprintf ("Why does SgInitializedName::get_definition() return a declaration! \n");
86156 : // DQ (6/21/2005): Because the SgVariableDefinition is derived from a SgDeclarationStatement
86157 : // and we return a SgVariableDefinition
86158 :
86159 : // DQ (6/21/2005): Is this always true? NO!
86160 : // assert(isSgVariableDefinition(get_declptr()) != NULL);
86161 :
86162 86425 : return get_declptr();
86163 : }
86164 :
86165 : /*
86166 : void
86167 : SgInitializedName::set_declaration(SgDeclarationStatement * decl)
86168 : {
86169 : //p_declptr = decl;
86170 : set_parent(decl);
86171 : }
86172 : */
86173 :
86174 : void
86175 34364 : SgInitializedName::set_definition(SgDeclarationStatement * def)
86176 : {
86177 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
86178 : // DQ (6/12/2007): New access function tests using DEBUG_SAGE_ACCESS_FUNCTIONS and
86179 : // DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION in sage3.h indicate this is required.
86180 : if (get_declptr() != NULL)
86181 : {
86182 : mprintf ("Note: overwriting SgInitializedName::get_declptr() = %p with NULL before assignment to def = %p \n",get_declptr(),def);
86183 : set_declptr(NULL);
86184 : }
86185 : #endif
86186 :
86187 : // DQ (4/14/2015): Added call to set_isModified() function to record change to this IR node.
86188 34364 : set_isModified(true);
86189 :
86190 34364 : set_declptr(def);
86191 34364 : }
86192 :
86193 : bool
86194 3184700 : SgInitializedName::checkBit ( unsigned int bit ) const
86195 : {
86196 3184700 : assert (bit < e_last_gnu_variable_attribute);
86197 : // return p_gnu_attribute_modifierVector[bit];
86198 3184700 : return (p_gnu_attribute_modifierVector[bit] == true);
86199 : }
86200 :
86201 : void
86202 0 : SgInitializedName::setBit ( unsigned int bit )
86203 : {
86204 0 : assert (bit < e_last_gnu_variable_attribute);
86205 0 : p_gnu_attribute_modifierVector[bit] = true;
86206 0 : }
86207 :
86208 : void
86209 0 : SgInitializedName::unsetBit ( unsigned int bit )
86210 : {
86211 0 : assert (bit < e_last_gnu_variable_attribute);
86212 0 : p_gnu_attribute_modifierVector[bit] = false;
86213 0 : }
86214 :
86215 :
86216 : // DQ (1/3/2009): Added GNU specific attributes
86217 3560 : bool SgInitializedName::isGnuAttributeWeak() const { return checkBit(e_gnu_attribute__weak__); }
86218 0 : void SgInitializedName::setGnuAttributeWeak() { setBit(e_gnu_attribute__weak__); }
86219 0 : void SgInitializedName::unsetGnuAttributeWeak() { unsetBit(e_gnu_attribute__weak__); }
86220 :
86221 : // DQ (1/3/2009): Added GNU specific attributes
86222 3560 : bool SgInitializedName::isGnuAttributeUnused() const { return checkBit(e_gnu_attribute__unused__); }
86223 0 : void SgInitializedName::setGnuAttributeUnused() { setBit(e_gnu_attribute__unused__); }
86224 0 : void SgInitializedName::unsetGnuAttributeUnused() { unsetBit(e_gnu_attribute__unused__); }
86225 :
86226 : // DQ (1/3/2009): Added GNU specific attributes
86227 3560 : bool SgInitializedName::isGnuAttributeUsed() const { return checkBit(e_gnu_attribute__used__); }
86228 0 : void SgInitializedName::setGnuAttributeUsed() { setBit(e_gnu_attribute__used__); }
86229 0 : void SgInitializedName::unsetGnuAttributeUsed() { unsetBit(e_gnu_attribute__used__); }
86230 :
86231 : // DQ (1/3/2009): Added GNU specific attributes
86232 3560 : bool SgInitializedName::isGnuAttributeDeprecated() const { return checkBit(e_gnu_attribute__deprecated__); }
86233 0 : void SgInitializedName::setGnuAttributeDeprecated() { setBit(e_gnu_attribute__deprecated__); }
86234 0 : void SgInitializedName::unsetGnuAttributeDeprecated() { unsetBit(e_gnu_attribute__deprecated__); }
86235 :
86236 : // DQ (1/3/2009): Added GNU specific attributes
86237 3560 : bool SgInitializedName::isGnuAttributeNoCommon() const { return checkBit(e_gnu_attribute__nocommon__); }
86238 0 : void SgInitializedName::setGnuAttributeNoCommon() { setBit(e_gnu_attribute__nocommon__); }
86239 0 : void SgInitializedName::unsetGnuAttributeNoCommon() { unsetBit(e_gnu_attribute__nocommon__); }
86240 :
86241 : // DQ (1/3/2009): Added GNU specific attributes
86242 3560 : bool SgInitializedName::isGnuAttributeTransparentUnion() const { return checkBit(e_gnu_attribute__transparent_union__); }
86243 0 : void SgInitializedName::setGnuAttributeTransparentUnion() { setBit(e_gnu_attribute__transparent_union__); }
86244 0 : void SgInitializedName::unsetGnuAttributeTransparentUnion() { unsetBit(e_gnu_attribute__transparent_union__); }
86245 :
86246 : // DQ (1/3/2009): Added GNU specific attributes
86247 3560 : bool SgInitializedName::isGnuAttributeWeakReference() const { return checkBit(e_gnu_attribute__weakref__); }
86248 0 : void SgInitializedName::setGnuAttributeWeakReference() { setBit(e_gnu_attribute__weakref__); }
86249 0 : void SgInitializedName::unsetGnuAttributeWeakReference() { unsetBit(e_gnu_attribute__weakref__); }
86250 :
86251 : // DQ (12/30/2013): Added support for packing on variables (instead of just on the types).
86252 7040 : bool SgInitializedName::isGnuAttributePacked() const { return checkBit(e_gnu_attribute__packed__); }
86253 0 : void SgInitializedName::setGnuAttributePacked() { setBit(e_gnu_attribute__packed__); }
86254 0 : void SgInitializedName::unsetGnuAttributePacked() { unsetBit(e_gnu_attribute__packed__); }
86255 :
86256 : // DQ (12/30/2013): Added support for packing on variables (instead of just on the types).
86257 3139510 : bool SgInitializedName::isGnuAttributeNoReturn() const { return checkBit(e_gnu_attribute__noreturn__); }
86258 0 : void SgInitializedName::setGnuAttributeNoReturn() { setBit(e_gnu_attribute__noreturn__); }
86259 0 : void SgInitializedName::unsetGnuAttributeNoReturn() { unsetBit(e_gnu_attribute__noreturn__); }
86260 :
86261 3560 : bool SgInitializedName::isGnuAttributeNoReorder() const { return checkBit(e_gnu_attribute__noreorder__); }
86262 0 : void SgInitializedName::setGnuAttributeNoReorder() { setBit(e_gnu_attribute__noreorder__); }
86263 0 : void SgInitializedName::unsetGnuAttributeNoReorder() { unsetBit(e_gnu_attribute__noreorder__); }
86264 :
86265 : #if 0
86266 : // DQ (8/17/2014): Associated Microsoft attributes that are valid in a function parameter.
86267 : appdomain
86268 : deprecated
86269 : dllimport
86270 : dllexport
86271 : novtable
86272 : process
86273 : restrict
86274 : selectany
86275 : thread
86276 : uuid(" ComObjectGUID ")
86277 : #endif
86278 :
86279 967 : bool SgInitializedName::is_ms_declspec_parameter_appdomain() const { return checkBit(e_ms_declspec_parameter_appdomain); }
86280 0 : void SgInitializedName::set_ms_declspec_parameter_appdomain() { setBit(e_ms_declspec_parameter_appdomain); }
86281 0 : void SgInitializedName::unset_ms_declspec_parameter_appdomain() { unsetBit(e_ms_declspec_parameter_appdomain); }
86282 :
86283 967 : bool SgInitializedName::is_ms_declspec_parameter_deprecated() const { return checkBit(e_ms_declspec_parameter_deprecated); }
86284 0 : void SgInitializedName::set_ms_declspec_parameter_deprecated() { setBit(e_ms_declspec_parameter_deprecated); }
86285 0 : void SgInitializedName::unset_ms_declspec_parameter_deprecated() { unsetBit(e_ms_declspec_parameter_deprecated); }
86286 :
86287 967 : bool SgInitializedName::is_ms_declspec_parameter_dllimport() const { return checkBit(e_ms_declspec_parameter_dllimport); }
86288 0 : void SgInitializedName::set_ms_declspec_parameter_dllimport() { setBit(e_ms_declspec_parameter_dllimport); }
86289 0 : void SgInitializedName::unset_ms_declspec_parameter_dllimport() { unsetBit(e_ms_declspec_parameter_dllimport); }
86290 :
86291 967 : bool SgInitializedName::is_ms_declspec_parameter_dllexport() const { return checkBit(e_ms_declspec_parameter_dllexport); }
86292 0 : void SgInitializedName::set_ms_declspec_parameter_dllexport() { setBit(e_ms_declspec_parameter_dllexport); }
86293 0 : void SgInitializedName::unset_ms_declspec_parameter_dllexport() { unsetBit(e_ms_declspec_parameter_dllexport); }
86294 :
86295 967 : bool SgInitializedName::is_ms_declspec_parameter_novtable() const { return checkBit(e_ms_declspec_parameter_novtable); }
86296 0 : void SgInitializedName::set_ms_declspec_parameter_novtable() { setBit(e_ms_declspec_parameter_novtable); }
86297 0 : void SgInitializedName::unset_ms_declspec_parameter_novtable() { unsetBit(e_ms_declspec_parameter_novtable); }
86298 :
86299 967 : bool SgInitializedName::is_ms_declspec_parameter_process() const { return checkBit(e_ms_declspec_parameter_process); }
86300 0 : void SgInitializedName::set_ms_declspec_parameter_process() { setBit(e_ms_declspec_parameter_process); }
86301 0 : void SgInitializedName::unset_ms_declspec_parameter_process() { unsetBit(e_ms_declspec_parameter_process); }
86302 :
86303 967 : bool SgInitializedName::is_ms_declspec_parameter_restrict() const { return checkBit(e_ms_declspec_parameter_restrict); }
86304 0 : void SgInitializedName::set_ms_declspec_parameter_restrict() { setBit(e_ms_declspec_parameter_restrict); }
86305 0 : void SgInitializedName::unset_ms_declspec_parameter_restrict() { unsetBit(e_ms_declspec_parameter_restrict); }
86306 :
86307 967 : bool SgInitializedName::is_ms_declspec_parameter_selectany() const { return checkBit(e_ms_declspec_parameter_selectany); }
86308 0 : void SgInitializedName::set_ms_declspec_parameter_selectany() { setBit(e_ms_declspec_parameter_selectany); }
86309 0 : void SgInitializedName::unset_ms_declspec_parameter_selectany() { unsetBit(e_ms_declspec_parameter_selectany); }
86310 :
86311 967 : bool SgInitializedName::is_ms_declspec_parameter_thread() const { return checkBit(e_ms_declspec_parameter_thread); }
86312 0 : void SgInitializedName::set_ms_declspec_parameter_thread() { setBit(e_ms_declspec_parameter_thread); }
86313 0 : void SgInitializedName::unset_ms_declspec_parameter_thread() { unsetBit(e_ms_declspec_parameter_thread); }
86314 :
86315 967 : bool SgInitializedName::is_ms_declspec_parameter_uuid() const { return checkBit(e_ms_declspec_parameter_uuid); }
86316 0 : void SgInitializedName::set_ms_declspec_parameter_uuid() { setBit(e_ms_declspec_parameter_uuid); }
86317 0 : void SgInitializedName::unset_ms_declspec_parameter_uuid() { unsetBit(e_ms_declspec_parameter_uuid); }
86318 :
86319 : // DQ (3/31/2019): Added support for name qualification on the SgInitializedName (as part fo support for SgMemberPointerType).
86320 : int
86321 2921 : SgInitializedName::get_name_qualification_length() const
86322 : {
86323 2921 : ROSE_ASSERT (this != NULL);
86324 2921 : return p_name_qualification_length;
86325 : }
86326 :
86327 : void
86328 462 : SgInitializedName::set_name_qualification_length ( int name_qualification_length )
86329 : {
86330 462 : ROSE_ASSERT (this != NULL);
86331 : // This can't be called by the name qualification API (see test2015_26.C).
86332 : // set_isModified(true);
86333 :
86334 462 : p_name_qualification_length = name_qualification_length;
86335 462 : }
86336 :
86337 : // DQ (3/31/2019): Added support for name qualification on the SgInitializedName (as part fo support for SgMemberPointerType).
86338 : bool
86339 0 : SgInitializedName::get_type_elaboration_required () const
86340 : {
86341 0 : ROSE_ASSERT (this != NULL);
86342 0 : return p_type_elaboration_required;
86343 : }
86344 :
86345 : void
86346 462 : SgInitializedName::set_type_elaboration_required ( bool type_elaboration_required )
86347 : {
86348 462 : ROSE_ASSERT (this != NULL);
86349 : // This can't be called by the name qualification API (see test2015_26.C).
86350 : // set_isModified(true);
86351 :
86352 462 : p_type_elaboration_required = type_elaboration_required;
86353 462 : }
86354 :
86355 : // DQ (3/31/2019): Added support for name qualification on the SgInitializedName (as part fo support for SgMemberPointerType).
86356 : bool
86357 0 : SgInitializedName::get_global_qualification_required () const
86358 : {
86359 0 : ROSE_ASSERT (this != NULL);
86360 0 : return p_global_qualification_required;
86361 : }
86362 :
86363 : void
86364 462 : SgInitializedName::set_global_qualification_required ( bool global_qualification_required )
86365 : {
86366 462 : ROSE_ASSERT (this != NULL);
86367 : // This can't be called by the name qualification API (see test2015_26.C).
86368 : // set_isModified(true);
86369 :
86370 462 : p_global_qualification_required = global_qualification_required;
86371 462 : }
86372 :
86373 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
86374 : // so that we could avoid them setting the isModified flag which is a problem in the
86375 : // name qualification support for C++ (interfering with the token-based unparsing).
86376 : int
86377 4527 : SgInitializedName::get_name_qualification_length_for_type() const
86378 : {
86379 4527 : ROSE_ASSERT (this != NULL);
86380 4527 : return p_name_qualification_length_for_type;
86381 : }
86382 :
86383 : void
86384 1209960 : SgInitializedName::set_name_qualification_length_for_type ( int name_qualification_length_for_type )
86385 : {
86386 1209960 : ROSE_ASSERT (this != NULL);
86387 : // This can't be called by the name qualification API (see test2015_26.C).
86388 : // set_isModified(true);
86389 :
86390 1209960 : p_name_qualification_length_for_type = name_qualification_length_for_type;
86391 1209960 : }
86392 :
86393 : bool
86394 4527 : SgInitializedName::get_type_elaboration_required_for_type () const
86395 : {
86396 4527 : ROSE_ASSERT (this != NULL);
86397 4527 : return p_type_elaboration_required_for_type;
86398 : }
86399 :
86400 : void
86401 1209960 : SgInitializedName::set_type_elaboration_required_for_type ( bool type_elaboration_required_for_type )
86402 : {
86403 1209960 : ROSE_ASSERT (this != NULL);
86404 : // This can't be called by the name qualification API (see test2015_26.C).
86405 : // set_isModified(true);
86406 :
86407 1209960 : p_type_elaboration_required_for_type = type_elaboration_required_for_type;
86408 1209960 : }
86409 :
86410 : bool
86411 4527 : SgInitializedName::get_global_qualification_required_for_type () const
86412 : {
86413 4527 : ROSE_ASSERT (this != NULL);
86414 4527 : return p_global_qualification_required_for_type;
86415 : }
86416 :
86417 : void
86418 1209960 : SgInitializedName::set_global_qualification_required_for_type ( bool global_qualification_required_for_type )
86419 : {
86420 1209960 : ROSE_ASSERT (this != NULL);
86421 : // This can't be called by the name qualification API (see test2015_26.C).
86422 : // set_isModified(true);
86423 :
86424 1209960 : p_global_qualification_required_for_type = global_qualification_required_for_type;
86425 1209960 : }
86426 :
86427 :
86428 :
86429 : // End of memberFunctionString
86430 : // Start of memberFunctionString
86431 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
86432 :
86433 : // *** COMMON CODE SECTION BEGINS HERE ***
86434 :
86435 : #if 0
86436 : int
86437 : SgInitializedName::getVariant() const
86438 : {
86439 : // This function is used in ROSE while "variant()" is used in SAGE
86440 : assert(this != NULL);
86441 : return variant();
86442 : }
86443 : #endif
86444 :
86445 : // This function is used in ROSE in treeTraversal code
86446 : // eventually replaces getVariant() and variant()
86447 : // though after variant() has been removed for a while we will
86448 : // want to change the name of variantT() back to variant()
86449 : // (since the "T" was ment to stand for temporary).
86450 : // When this happens the variantT() will be depricated.
86451 : VariantT
86452 2802960000 : SgInitializedName::variantT() const
86453 : {
86454 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
86455 2802960000 : ROSE_ASSERT(this != NULL);
86456 2802960000 : return V_SgInitializedName;
86457 : }
86458 :
86459 : #if 0
86460 : int
86461 : SgInitializedName::variant() const
86462 : {
86463 : // This function is used in SAGE
86464 : ROSE_ASSERT(this != NULL);
86465 : return InitializedNameTag;
86466 : }
86467 : #endif
86468 :
86469 : ROSE_DLL_API const char*
86470 3327 : SgInitializedName::sage_class_name() const
86471 : {
86472 3327 : ROSE_ASSERT(this != NULL);
86473 3327 : return "SgInitializedName";
86474 : }
86475 :
86476 : std::string
86477 5994060 : SgInitializedName::class_name() const
86478 : {
86479 5994060 : ROSE_ASSERT(this != NULL);
86480 5994060 : return "SgInitializedName";
86481 : }
86482 :
86483 : // DQ (11/26/2005): Support for visitor pattern mechanims
86484 : // (inferior to ROSE traversal mechanism, experimental).
86485 : void
86486 6131590 : SgInitializedName::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
86487 : {
86488 6131590 : ROSE_ASSERT(this != NULL);
86489 6131590 : visitor.visit(this);
86490 6131590 : }
86491 :
86492 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
86493 0 : void SgInitializedName::accept (ROSE_VisitorPattern & visitor) {
86494 0 : ROSE_ASSERT(this != NULL);
86495 0 : visitor.visit(this);
86496 0 : }
86497 :
86498 : SgInitializedName*
86499 0 : SgInitializedName::addRegExpAttribute(std::string s, AstRegExAttribute* a)
86500 : {
86501 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
86502 : // This function is currently only supported for the AST used the represent Binary executables.
86503 : if (0 /* isSgAsmNode(this) != NULL */)
86504 : {
86505 : // Support for regex specification.
86506 : std::string prefixCode = "REGEX:";
86507 : addNewAttribute(prefixCode + s,a);
86508 : }
86509 : #endif
86510 :
86511 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
86512 0 : return this;
86513 : }
86514 :
86515 : // *** COMMON CODE SECTION ENDS HERE ***
86516 :
86517 :
86518 : // End of memberFunctionString
86519 : // Start of memberFunctionString
86520 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
86521 :
86522 :
86523 : #if 0
86524 : //! Error checking support
86525 : /*! Verifies the following:
86526 : - working getVariant() member function
86527 : - calls base class's error() member function
86528 : Every class has one of these functions.
86529 : */
86530 : bool
86531 : SgInitializedName::error()
86532 : {
86533 : // Put error checking here
86534 :
86535 : ROSE_ASSERT (this != NULL);
86536 : if (getVariant() != InitializedNameTag)
86537 : {
86538 : printf ("Error in SgInitializedName::error(): SgInitializedName object has a %s variant \n",
86539 : Cxx_GrammarTerminalNames[getVariant()].name);
86540 : // printf ("Error in SgInitializedName::error() \n");
86541 : ROSE_ABORT();
86542 : }
86543 :
86544 : ROSE_ASSERT (getVariant() == InitializedNameTag);
86545 : return SgLocatedNodeSupport::error();
86546 : }
86547 : #endif
86548 :
86549 :
86550 :
86551 : // End of memberFunctionString
86552 :
86553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
86554 :
86555 101808000 : SgInitializedName* isSgInitializedName ( SgNode* inputDerivedClassPointer )
86556 : {
86557 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
86558 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
86559 : // So to fix this we return NULL directly when the input is NULL and avoid the
86560 : // dynamic_cast in this case. This is likely a performance improvement as well.
86561 : // return dynamic_cast<SgInitializedName*>(inputDerivedClassPointer);
86562 : // Milind Chabbi (8/28/2013): isSgInitializedName uses table-driven castability instead of c++ default dynamic_cast
86563 : // this improves the running time performance by 10-20%.
86564 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgInitializedName*>(inputDerivedClassPointer);
86565 101808000 : return IS_SgInitializedName_FAST_MACRO(inputDerivedClassPointer);
86566 : }
86567 :
86568 : // DQ (11/8/2003): Added version of functions taking const pointer
86569 3222180 : const SgInitializedName* isSgInitializedName ( const SgNode* inputDerivedClassPointer )
86570 : {
86571 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
86572 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
86573 : // So to fix this we return NULL directly when the input is NULL and avoid the
86574 : // dynamic_cast in this case. This is likely a performance improvement as well.
86575 : // return dynamic_cast<const SgInitializedName*>(inputDerivedClassPointer);
86576 : // Milind Chabbi (8/28/2013): isSgInitializedName uses table-driven castability instead of c++ default dynamic_cast
86577 : // this improves the running time performance by 10-20%.
86578 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgInitializedName*>(inputDerivedClassPointer);
86579 3222180 : return IS_SgInitializedName_FAST_MACRO(inputDerivedClassPointer);
86580 : }
86581 :
86582 :
86583 :
86584 : /* #line 86585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
86585 :
86586 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
86587 :
86588 : /**
86589 : \brief Generated destructor
86590 :
86591 : This destructor is automatically generated (by ROSETTA). This destructor
86592 : only frees memory of data members associated with the parts of the current IR node which
86593 : are NOT traversed. Those data members that are part of a traversal can be freed using
86594 : a traversal (calling this destructor on all children in a post-order traversal). Such
86595 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
86596 :
86597 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
86598 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
86599 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
86600 :
86601 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
86602 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
86603 : pointers are not yet implemented to call delete on eash pointer in the container.
86604 : (This could be done by derivation from the STL containers to define containers that
86605 : automatically deleted their members.)
86606 :
86607 : */
86608 220918 : SgInitializedName::~SgInitializedName () {
86609 110459 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
86610 :
86611 110459 : if (p_storageModifier && p_storageModifier->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_storageModifier; }
86612 :
86613 : // case: not a listType for name
86614 110459 : p_name = NULL; // non list case
86615 : // case: not a listType for microsoft_uuid_string
86616 110459 : p_microsoft_uuid_string =""; // non list case
86617 : // case: not a listType for typeptr
86618 110459 : p_typeptr = NULL; // non list case
86619 : // case: not a listType for initptr
86620 110459 : p_initptr = NULL; // non list case
86621 : // case: not a listType for prev_decl_item
86622 110459 : p_prev_decl_item = NULL; // non list case
86623 : // case: not a listType for is_initializer
86624 110459 : p_is_initializer = false; // non list case
86625 : // case: not a listType for declptr
86626 110459 : p_declptr = NULL; // non list case
86627 : // case: not a listType for storageModifier
86628 110459 : p_storageModifier = NULL; // non list case
86629 : // case: not a listType for scope
86630 110459 : p_scope = NULL; // non list case
86631 : // case: not a listType for preinitialization
86632 110459 : p_preinitialization = e_unknown_preinitialization; // non list case
86633 : // case: not a listType for isCoArray
86634 110459 : p_isCoArray = false; // non list case
86635 : // case: not a listType for register_name_code
86636 110459 : p_register_name_code = SgInitializedName::e_invalid_register; // non list case
86637 : // case: not a listType for excess_specifier
86638 110459 : p_excess_specifier = SgInitializedName::e_excess_specifier_none; // non list case
86639 : // case: not a listType for register_name_string
86640 110459 : p_register_name_string = ""; // non list case
86641 : // case: not a listType for requiresGlobalNameQualificationOnType
86642 110459 : p_requiresGlobalNameQualificationOnType = false; // non list case
86643 : // case: not a listType for shapeDeferred
86644 110459 : p_shapeDeferred = false; // non list case
86645 : // case: not a listType for initializationDeferred
86646 110459 : p_initializationDeferred = false; // non list case
86647 : // case: not a listType for gnu_attribute_initialization_priority
86648 110459 : p_gnu_attribute_initialization_priority = 0; // non list case
86649 : // case: not a listType for gnu_attribute_named_weak_reference
86650 110459 : p_gnu_attribute_named_weak_reference =""; // non list case
86651 : // case: not a listType for gnu_attribute_named_alias
86652 110459 : p_gnu_attribute_named_alias =""; // non list case
86653 : // case: not a listType for gnu_attribute_cleanup_function
86654 110459 : p_gnu_attribute_cleanup_function =""; // non list case
86655 : // case: not a listType for gnu_attribute_section_name
86656 110459 : p_gnu_attribute_section_name =""; // non list case
86657 : // case: not a listType for gnu_attribute_alignment
86658 110459 : p_gnu_attribute_alignment = -1; // non list case
86659 : // case: not a listType for gnu_attribute_visability
86660 110459 : p_gnu_attribute_visability = SgDeclarationModifier::e_unknown_visibility; // non list case
86661 : // case: not a listType for protected_declaration
86662 110459 : p_protected_declaration = false; // non list case
86663 : // case: not a listType for name_qualification_length
86664 110459 : p_name_qualification_length = 0; // non list case
86665 : // case: not a listType for type_elaboration_required
86666 110459 : p_type_elaboration_required = false; // non list case
86667 : // case: not a listType for global_qualification_required
86668 110459 : p_global_qualification_required = false; // non list case
86669 : // case: not a listType for name_qualification_length_for_type
86670 110459 : p_name_qualification_length_for_type = 0; // non list case
86671 : // case: not a listType for type_elaboration_required_for_type
86672 110459 : p_type_elaboration_required_for_type = false; // non list case
86673 : // case: not a listType for global_qualification_required_for_type
86674 110459 : p_global_qualification_required_for_type = false; // non list case
86675 : // case: not a listType for hasArrayTypeWithEmptyBracketSyntax
86676 110459 : p_hasArrayTypeWithEmptyBracketSyntax = false; // non list case
86677 : // case: not a listType for using_C11_Alignas_keyword
86678 110459 : p_using_C11_Alignas_keyword = false; // non list case
86679 : // case: not a listType for constant_or_type_argument_for_Alignas_keyword
86680 110459 : p_constant_or_type_argument_for_Alignas_keyword = NULL; // non list case
86681 : // case: not a listType for using_auto_keyword
86682 110459 : p_using_auto_keyword = false; // non list case
86683 : // case: not a listType for auto_decltype
86684 110459 : p_auto_decltype = NULL; // non list case
86685 : // case: not a listType for using_device_keyword
86686 110459 : p_using_device_keyword = false; // non list case
86687 : // case: not a listType for is_braced_initialized
86688 110459 : p_is_braced_initialized = false; // non list case
86689 : // case: not a listType for using_assignment_copy_constructor_syntax
86690 110459 : p_using_assignment_copy_constructor_syntax = false; // non list case
86691 : // case: not a listType for needs_definitions
86692 110459 : p_needs_definitions = false; // non list case
86693 : // case: not a listType for is_parameter_pack
86694 110459 : p_is_parameter_pack = false; // non list case
86695 : // case: not a listType for is_pack_element
86696 110459 : p_is_pack_element = false; // non list case
86697 :
86698 : }
86699 :
86700 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
86701 220918 : }
86702 :
86703 :
86704 : /* #line 86705 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
86705 :
86706 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
86707 :
86708 : // Generated constructor
86709 40 : SgInitializedName::SgInitializedName ( Sg_File_Info* startOfConstruct, SgName name, SgType* typeptr )
86710 40 : : SgLocatedNodeSupport(startOfConstruct)
86711 : {
86712 : #ifdef DEBUG
86713 : // printf ("In SgInitializedName::SgInitializedName (Sg_File_Info* startOfConstruct, SgName name, SgType* typeptr) sage_class_name() = %s \n",sage_class_name());
86714 : #endif
86715 : #if 0
86716 : // debugging information!
86717 : printf ("In SgInitializedName::SgInitializedName (Sg_File_Info* startOfConstruct, SgName name, SgType* typeptr): this = %p = %s \n",this,this->class_name().c_str());
86718 : #endif
86719 :
86720 40 : p_name = name;
86721 40 : p_microsoft_uuid_string ="";
86722 40 : p_typeptr = typeptr;
86723 40 : p_initptr = NULL;
86724 40 : p_prev_decl_item = NULL;
86725 40 : p_is_initializer = false;
86726 40 : p_declptr = NULL;
86727 40 : p_storageModifier = NULL;
86728 40 : p_scope = NULL;
86729 40 : p_preinitialization = e_unknown_preinitialization;
86730 40 : p_isCoArray = false;
86731 40 : p_register_name_code = SgInitializedName::e_invalid_register;
86732 40 : p_excess_specifier = SgInitializedName::e_excess_specifier_none;
86733 40 : p_register_name_string = "";
86734 40 : p_requiresGlobalNameQualificationOnType = false;
86735 40 : p_shapeDeferred = false;
86736 40 : p_initializationDeferred = false;
86737 40 : p_gnu_attribute_initialization_priority = 0;
86738 40 : p_gnu_attribute_named_weak_reference ="";
86739 40 : p_gnu_attribute_named_alias ="";
86740 40 : p_gnu_attribute_cleanup_function ="";
86741 40 : p_gnu_attribute_section_name ="";
86742 40 : p_gnu_attribute_alignment = -1;
86743 40 : p_gnu_attribute_visability = SgDeclarationModifier::e_unknown_visibility;
86744 40 : p_protected_declaration = false;
86745 40 : p_name_qualification_length = 0;
86746 40 : p_type_elaboration_required = false;
86747 40 : p_global_qualification_required = false;
86748 40 : p_name_qualification_length_for_type = 0;
86749 40 : p_type_elaboration_required_for_type = false;
86750 40 : p_global_qualification_required_for_type = false;
86751 40 : p_hasArrayTypeWithEmptyBracketSyntax = false;
86752 40 : p_using_C11_Alignas_keyword = false;
86753 40 : p_constant_or_type_argument_for_Alignas_keyword = NULL;
86754 40 : p_using_auto_keyword = false;
86755 40 : p_auto_decltype = NULL;
86756 40 : p_using_device_keyword = false;
86757 40 : p_is_braced_initialized = false;
86758 40 : p_using_assignment_copy_constructor_syntax = false;
86759 40 : p_needs_definitions = false;
86760 40 : p_is_parameter_pack = false;
86761 40 : p_is_pack_element = false;
86762 :
86763 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
86764 :
86765 : #if 0
86766 : // DQ (7/30/2014): Call a virtual function.
86767 : std::string s = this->class_name();
86768 : #endif
86769 :
86770 : // Test the variant virtual function
86771 : // assert(InitializedNameTag == variant());
86772 40 : assert(InitializedNameTag == this->variant());
86773 40 : ROSE_ASSERT(InitializedNameTag == (int)(this->variantT()));
86774 40 : post_construction_initialization();
86775 :
86776 : // Test the isSgInitializedName() function since it has been problematic
86777 40 : assert(isSgInitializedName(this) != NULL);
86778 40 : }
86779 :
86780 : // Generated constructor (all data members)
86781 :
86782 : /* #line 86783 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
86783 :
86784 :
86785 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
86786 :
86787 :
86788 : // ********************************************************
86789 : // member functions common across all array grammar objects
86790 : // ********************************************************
86791 :
86792 :
86793 :
86794 : /* #line 86795 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
86795 :
86796 :
86797 :
86798 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
86799 :
86800 : // ********************************************************
86801 : // member functions specific to each node in the grammar
86802 : // ********************************************************
86803 :
86804 :
86805 : /* #line 86806 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
86806 :
86807 : // Start of memberFunctionString
86808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
86809 :
86810 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
86811 :
86812 : SgName
86813 0 : SgInterfaceBody::get_function_name () const
86814 : {
86815 0 : ROSE_ASSERT (this != NULL);
86816 :
86817 : #if 0
86818 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
86819 : // used to trigger marking transformations for the token-based unparsing.
86820 : printf ("SgInterfaceBody::get_function_name = %p = %s \n",this,this->class_name().c_str());
86821 : #endif
86822 :
86823 0 : return p_function_name;
86824 : }
86825 :
86826 : void
86827 0 : SgInterfaceBody::set_function_name ( SgName function_name )
86828 : {
86829 0 : ROSE_ASSERT (this != NULL);
86830 :
86831 : #if 0
86832 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
86833 : // used to trigger marking transformations for the token-based unparsing.
86834 : printf ("SgInterfaceBody::set_function_name = %p = %s \n",this,this->class_name().c_str());
86835 : #endif
86836 :
86837 0 : set_isModified(true);
86838 :
86839 0 : p_function_name = function_name;
86840 0 : }
86841 :
86842 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
86843 :
86844 :
86845 : // End of memberFunctionString
86846 : // Start of memberFunctionString
86847 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
86848 :
86849 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
86850 :
86851 : SgFunctionDeclaration*
86852 0 : SgInterfaceBody::get_functionDeclaration () const
86853 : {
86854 0 : ROSE_ASSERT (this != NULL);
86855 :
86856 : #if 0
86857 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
86858 : // used to trigger marking transformations for the token-based unparsing.
86859 : printf ("SgInterfaceBody::get_functionDeclaration = %p = %s \n",this,this->class_name().c_str());
86860 : #endif
86861 :
86862 0 : return p_functionDeclaration;
86863 : }
86864 :
86865 : void
86866 0 : SgInterfaceBody::set_functionDeclaration ( SgFunctionDeclaration* functionDeclaration )
86867 : {
86868 0 : ROSE_ASSERT (this != NULL);
86869 :
86870 : #if 0
86871 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
86872 : // used to trigger marking transformations for the token-based unparsing.
86873 : printf ("SgInterfaceBody::set_functionDeclaration = %p = %s \n",this,this->class_name().c_str());
86874 : #endif
86875 :
86876 0 : set_isModified(true);
86877 :
86878 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
86879 : if (p_functionDeclaration != NULL && functionDeclaration != NULL && p_functionDeclaration != functionDeclaration)
86880 : {
86881 : printf ("Warning: functionDeclaration = %p overwriting valid pointer p_functionDeclaration = %p \n",functionDeclaration,p_functionDeclaration);
86882 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
86883 : printf ("Error fails assertion (p_functionDeclaration != NULL && functionDeclaration != NULL && p_functionDeclaration != functionDeclaration) is false\n");
86884 : ROSE_ASSERT(false);
86885 : #endif
86886 : }
86887 : #endif
86888 0 : p_functionDeclaration = functionDeclaration;
86889 0 : }
86890 :
86891 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
86892 :
86893 :
86894 : // End of memberFunctionString
86895 : // Start of memberFunctionString
86896 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
86897 :
86898 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
86899 :
86900 : bool
86901 0 : SgInterfaceBody::get_use_function_name () const
86902 : {
86903 0 : ROSE_ASSERT (this != NULL);
86904 :
86905 : #if 0
86906 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
86907 : // used to trigger marking transformations for the token-based unparsing.
86908 : printf ("SgInterfaceBody::get_use_function_name = %p = %s \n",this,this->class_name().c_str());
86909 : #endif
86910 :
86911 0 : return p_use_function_name;
86912 : }
86913 :
86914 : void
86915 0 : SgInterfaceBody::set_use_function_name ( bool use_function_name )
86916 : {
86917 0 : ROSE_ASSERT (this != NULL);
86918 :
86919 : #if 0
86920 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
86921 : // used to trigger marking transformations for the token-based unparsing.
86922 : printf ("SgInterfaceBody::set_use_function_name = %p = %s \n",this,this->class_name().c_str());
86923 : #endif
86924 :
86925 0 : set_isModified(true);
86926 :
86927 0 : p_use_function_name = use_function_name;
86928 0 : }
86929 :
86930 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
86931 :
86932 :
86933 : // End of memberFunctionString
86934 : // Start of memberFunctionString
86935 : /* #line 1616 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
86936 :
86937 :
86938 :
86939 :
86940 : // End of memberFunctionString
86941 : // Start of memberFunctionString
86942 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
86943 :
86944 : // *** COMMON CODE SECTION BEGINS HERE ***
86945 :
86946 : #if 0
86947 : int
86948 : SgInterfaceBody::getVariant() const
86949 : {
86950 : // This function is used in ROSE while "variant()" is used in SAGE
86951 : assert(this != NULL);
86952 : return variant();
86953 : }
86954 : #endif
86955 :
86956 : // This function is used in ROSE in treeTraversal code
86957 : // eventually replaces getVariant() and variant()
86958 : // though after variant() has been removed for a while we will
86959 : // want to change the name of variantT() back to variant()
86960 : // (since the "T" was ment to stand for temporary).
86961 : // When this happens the variantT() will be depricated.
86962 : VariantT
86963 0 : SgInterfaceBody::variantT() const
86964 : {
86965 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
86966 0 : ROSE_ASSERT(this != NULL);
86967 0 : return V_SgInterfaceBody;
86968 : }
86969 :
86970 : #if 0
86971 : int
86972 : SgInterfaceBody::variant() const
86973 : {
86974 : // This function is used in SAGE
86975 : ROSE_ASSERT(this != NULL);
86976 : return TEMP_Interface_Body;
86977 : }
86978 : #endif
86979 :
86980 : ROSE_DLL_API const char*
86981 0 : SgInterfaceBody::sage_class_name() const
86982 : {
86983 0 : ROSE_ASSERT(this != NULL);
86984 0 : return "SgInterfaceBody";
86985 : }
86986 :
86987 : std::string
86988 0 : SgInterfaceBody::class_name() const
86989 : {
86990 0 : ROSE_ASSERT(this != NULL);
86991 0 : return "SgInterfaceBody";
86992 : }
86993 :
86994 : // DQ (11/26/2005): Support for visitor pattern mechanims
86995 : // (inferior to ROSE traversal mechanism, experimental).
86996 : void
86997 0 : SgInterfaceBody::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
86998 : {
86999 0 : ROSE_ASSERT(this != NULL);
87000 0 : visitor.visit(this);
87001 0 : }
87002 :
87003 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
87004 0 : void SgInterfaceBody::accept (ROSE_VisitorPattern & visitor) {
87005 0 : ROSE_ASSERT(this != NULL);
87006 0 : visitor.visit(this);
87007 0 : }
87008 :
87009 : SgInterfaceBody*
87010 0 : SgInterfaceBody::addRegExpAttribute(std::string s, AstRegExAttribute* a)
87011 : {
87012 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
87013 : // This function is currently only supported for the AST used the represent Binary executables.
87014 : if (0 /* isSgAsmNode(this) != NULL */)
87015 : {
87016 : // Support for regex specification.
87017 : std::string prefixCode = "REGEX:";
87018 : addNewAttribute(prefixCode + s,a);
87019 : }
87020 : #endif
87021 :
87022 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
87023 0 : return this;
87024 : }
87025 :
87026 : // *** COMMON CODE SECTION ENDS HERE ***
87027 :
87028 :
87029 : // End of memberFunctionString
87030 : // Start of memberFunctionString
87031 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
87032 :
87033 :
87034 : #if 0
87035 : //! Error checking support
87036 : /*! Verifies the following:
87037 : - working getVariant() member function
87038 : - calls base class's error() member function
87039 : Every class has one of these functions.
87040 : */
87041 : bool
87042 : SgInterfaceBody::error()
87043 : {
87044 : // Put error checking here
87045 :
87046 : ROSE_ASSERT (this != NULL);
87047 : if (getVariant() != TEMP_Interface_Body)
87048 : {
87049 : printf ("Error in SgInterfaceBody::error(): SgInterfaceBody object has a %s variant \n",
87050 : Cxx_GrammarTerminalNames[getVariant()].name);
87051 : // printf ("Error in SgInterfaceBody::error() \n");
87052 : ROSE_ABORT();
87053 : }
87054 :
87055 : ROSE_ASSERT (getVariant() == TEMP_Interface_Body);
87056 : return SgLocatedNodeSupport::error();
87057 : }
87058 : #endif
87059 :
87060 :
87061 :
87062 : // End of memberFunctionString
87063 :
87064 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
87065 :
87066 0 : SgInterfaceBody* isSgInterfaceBody ( SgNode* inputDerivedClassPointer )
87067 : {
87068 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87069 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87070 : // So to fix this we return NULL directly when the input is NULL and avoid the
87071 : // dynamic_cast in this case. This is likely a performance improvement as well.
87072 : // return dynamic_cast<SgInterfaceBody*>(inputDerivedClassPointer);
87073 : // Milind Chabbi (8/28/2013): isSgInterfaceBody uses table-driven castability instead of c++ default dynamic_cast
87074 : // this improves the running time performance by 10-20%.
87075 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgInterfaceBody*>(inputDerivedClassPointer);
87076 0 : return IS_SgInterfaceBody_FAST_MACRO(inputDerivedClassPointer);
87077 : }
87078 :
87079 : // DQ (11/8/2003): Added version of functions taking const pointer
87080 0 : const SgInterfaceBody* isSgInterfaceBody ( const SgNode* inputDerivedClassPointer )
87081 : {
87082 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87083 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87084 : // So to fix this we return NULL directly when the input is NULL and avoid the
87085 : // dynamic_cast in this case. This is likely a performance improvement as well.
87086 : // return dynamic_cast<const SgInterfaceBody*>(inputDerivedClassPointer);
87087 : // Milind Chabbi (8/28/2013): isSgInterfaceBody uses table-driven castability instead of c++ default dynamic_cast
87088 : // this improves the running time performance by 10-20%.
87089 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgInterfaceBody*>(inputDerivedClassPointer);
87090 0 : return IS_SgInterfaceBody_FAST_MACRO(inputDerivedClassPointer);
87091 : }
87092 :
87093 :
87094 :
87095 : /* #line 87096 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87096 :
87097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
87098 :
87099 : /**
87100 : \brief Generated destructor
87101 :
87102 : This destructor is automatically generated (by ROSETTA). This destructor
87103 : only frees memory of data members associated with the parts of the current IR node which
87104 : are NOT traversed. Those data members that are part of a traversal can be freed using
87105 : a traversal (calling this destructor on all children in a post-order traversal). Such
87106 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
87107 :
87108 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
87109 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
87110 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
87111 :
87112 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
87113 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
87114 : pointers are not yet implemented to call delete on eash pointer in the container.
87115 : (This could be done by derivation from the STL containers to define containers that
87116 : automatically deleted their members.)
87117 :
87118 : */
87119 0 : SgInterfaceBody::~SgInterfaceBody () {
87120 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
87121 :
87122 :
87123 : // case: not a listType for function_name
87124 0 : p_function_name = ""; // non list case
87125 : // case: not a listType for functionDeclaration
87126 0 : p_functionDeclaration = NULL; // non list case
87127 : // case: not a listType for use_function_name
87128 0 : p_use_function_name = false; // non list case
87129 :
87130 : }
87131 :
87132 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
87133 0 : }
87134 :
87135 :
87136 : /* #line 87137 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87137 :
87138 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
87139 :
87140 : // Generated constructor
87141 0 : SgInterfaceBody::SgInterfaceBody ( Sg_File_Info* startOfConstruct, SgName function_name, SgFunctionDeclaration* functionDeclaration, bool use_function_name )
87142 0 : : SgLocatedNodeSupport(startOfConstruct)
87143 : {
87144 : #ifdef DEBUG
87145 : // printf ("In SgInterfaceBody::SgInterfaceBody (Sg_File_Info* startOfConstruct, SgName function_name, SgFunctionDeclaration* functionDeclaration, bool use_function_name) sage_class_name() = %s \n",sage_class_name());
87146 : #endif
87147 : #if 0
87148 : // debugging information!
87149 : printf ("In SgInterfaceBody::SgInterfaceBody (Sg_File_Info* startOfConstruct, SgName function_name, SgFunctionDeclaration* functionDeclaration, bool use_function_name): this = %p = %s \n",this,this->class_name().c_str());
87150 : #endif
87151 :
87152 0 : p_function_name = function_name;
87153 0 : p_functionDeclaration = functionDeclaration;
87154 0 : p_use_function_name = use_function_name;
87155 :
87156 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
87157 :
87158 : #if 0
87159 : // DQ (7/30/2014): Call a virtual function.
87160 : std::string s = this->class_name();
87161 : #endif
87162 :
87163 : // Test the variant virtual function
87164 : // assert(TEMP_Interface_Body == variant());
87165 0 : assert(TEMP_Interface_Body == this->variant());
87166 0 : ROSE_ASSERT(TEMP_Interface_Body == (int)(this->variantT()));
87167 0 : post_construction_initialization();
87168 :
87169 : // Test the isSgInterfaceBody() function since it has been problematic
87170 0 : assert(isSgInterfaceBody(this) != NULL);
87171 0 : }
87172 :
87173 : // Generated constructor (all data members)
87174 :
87175 : /* #line 87176 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87176 :
87177 :
87178 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
87179 :
87180 :
87181 : // ********************************************************
87182 : // member functions common across all array grammar objects
87183 : // ********************************************************
87184 :
87185 :
87186 :
87187 : /* #line 87188 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87188 :
87189 :
87190 :
87191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
87192 :
87193 : // ********************************************************
87194 : // member functions specific to each node in the grammar
87195 : // ********************************************************
87196 :
87197 :
87198 : /* #line 87199 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87199 :
87200 : // Start of memberFunctionString
87201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
87202 :
87203 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
87204 :
87205 : SgSourceFile*
87206 0 : SgHeaderFileBody::get_include_file () const
87207 : {
87208 0 : ROSE_ASSERT (this != NULL);
87209 :
87210 : #if 0
87211 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
87212 : // used to trigger marking transformations for the token-based unparsing.
87213 : printf ("SgHeaderFileBody::get_include_file = %p = %s \n",this,this->class_name().c_str());
87214 : #endif
87215 :
87216 0 : return p_include_file;
87217 : }
87218 :
87219 : void
87220 0 : SgHeaderFileBody::set_include_file ( SgSourceFile* include_file )
87221 : {
87222 0 : ROSE_ASSERT (this != NULL);
87223 :
87224 : #if 0
87225 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
87226 : // used to trigger marking transformations for the token-based unparsing.
87227 : printf ("SgHeaderFileBody::set_include_file = %p = %s \n",this,this->class_name().c_str());
87228 : #endif
87229 :
87230 0 : set_isModified(true);
87231 :
87232 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
87233 : if (p_include_file != NULL && include_file != NULL && p_include_file != include_file)
87234 : {
87235 : printf ("Warning: include_file = %p overwriting valid pointer p_include_file = %p \n",include_file,p_include_file);
87236 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
87237 : printf ("Error fails assertion (p_include_file != NULL && include_file != NULL && p_include_file != include_file) is false\n");
87238 : ROSE_ASSERT(false);
87239 : #endif
87240 : }
87241 : #endif
87242 0 : p_include_file = include_file;
87243 0 : }
87244 :
87245 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
87246 :
87247 :
87248 : // End of memberFunctionString
87249 : // Start of memberFunctionString
87250 : /* #line 1620 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
87251 :
87252 :
87253 :
87254 :
87255 : // End of memberFunctionString
87256 : // Start of memberFunctionString
87257 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
87258 :
87259 : // *** COMMON CODE SECTION BEGINS HERE ***
87260 :
87261 : #if 0
87262 : int
87263 : SgHeaderFileBody::getVariant() const
87264 : {
87265 : // This function is used in ROSE while "variant()" is used in SAGE
87266 : assert(this != NULL);
87267 : return variant();
87268 : }
87269 : #endif
87270 :
87271 : // This function is used in ROSE in treeTraversal code
87272 : // eventually replaces getVariant() and variant()
87273 : // though after variant() has been removed for a while we will
87274 : // want to change the name of variantT() back to variant()
87275 : // (since the "T" was ment to stand for temporary).
87276 : // When this happens the variantT() will be depricated.
87277 : VariantT
87278 0 : SgHeaderFileBody::variantT() const
87279 : {
87280 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
87281 0 : ROSE_ASSERT(this != NULL);
87282 0 : return V_SgHeaderFileBody;
87283 : }
87284 :
87285 : #if 0
87286 : int
87287 : SgHeaderFileBody::variant() const
87288 : {
87289 : // This function is used in SAGE
87290 : ROSE_ASSERT(this != NULL);
87291 : return TEMP_Header_File_Body;
87292 : }
87293 : #endif
87294 :
87295 : ROSE_DLL_API const char*
87296 0 : SgHeaderFileBody::sage_class_name() const
87297 : {
87298 0 : ROSE_ASSERT(this != NULL);
87299 0 : return "SgHeaderFileBody";
87300 : }
87301 :
87302 : std::string
87303 0 : SgHeaderFileBody::class_name() const
87304 : {
87305 0 : ROSE_ASSERT(this != NULL);
87306 0 : return "SgHeaderFileBody";
87307 : }
87308 :
87309 : // DQ (11/26/2005): Support for visitor pattern mechanims
87310 : // (inferior to ROSE traversal mechanism, experimental).
87311 : void
87312 0 : SgHeaderFileBody::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
87313 : {
87314 0 : ROSE_ASSERT(this != NULL);
87315 0 : visitor.visit(this);
87316 0 : }
87317 :
87318 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
87319 0 : void SgHeaderFileBody::accept (ROSE_VisitorPattern & visitor) {
87320 0 : ROSE_ASSERT(this != NULL);
87321 0 : visitor.visit(this);
87322 0 : }
87323 :
87324 : SgHeaderFileBody*
87325 0 : SgHeaderFileBody::addRegExpAttribute(std::string s, AstRegExAttribute* a)
87326 : {
87327 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
87328 : // This function is currently only supported for the AST used the represent Binary executables.
87329 : if (0 /* isSgAsmNode(this) != NULL */)
87330 : {
87331 : // Support for regex specification.
87332 : std::string prefixCode = "REGEX:";
87333 : addNewAttribute(prefixCode + s,a);
87334 : }
87335 : #endif
87336 :
87337 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
87338 0 : return this;
87339 : }
87340 :
87341 : // *** COMMON CODE SECTION ENDS HERE ***
87342 :
87343 :
87344 : // End of memberFunctionString
87345 : // Start of memberFunctionString
87346 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
87347 :
87348 :
87349 : #if 0
87350 : //! Error checking support
87351 : /*! Verifies the following:
87352 : - working getVariant() member function
87353 : - calls base class's error() member function
87354 : Every class has one of these functions.
87355 : */
87356 : bool
87357 : SgHeaderFileBody::error()
87358 : {
87359 : // Put error checking here
87360 :
87361 : ROSE_ASSERT (this != NULL);
87362 : if (getVariant() != TEMP_Header_File_Body)
87363 : {
87364 : printf ("Error in SgHeaderFileBody::error(): SgHeaderFileBody object has a %s variant \n",
87365 : Cxx_GrammarTerminalNames[getVariant()].name);
87366 : // printf ("Error in SgHeaderFileBody::error() \n");
87367 : ROSE_ABORT();
87368 : }
87369 :
87370 : ROSE_ASSERT (getVariant() == TEMP_Header_File_Body);
87371 : return SgLocatedNodeSupport::error();
87372 : }
87373 : #endif
87374 :
87375 :
87376 :
87377 : // End of memberFunctionString
87378 :
87379 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
87380 :
87381 638 : SgHeaderFileBody* isSgHeaderFileBody ( SgNode* inputDerivedClassPointer )
87382 : {
87383 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87384 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87385 : // So to fix this we return NULL directly when the input is NULL and avoid the
87386 : // dynamic_cast in this case. This is likely a performance improvement as well.
87387 : // return dynamic_cast<SgHeaderFileBody*>(inputDerivedClassPointer);
87388 : // Milind Chabbi (8/28/2013): isSgHeaderFileBody uses table-driven castability instead of c++ default dynamic_cast
87389 : // this improves the running time performance by 10-20%.
87390 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgHeaderFileBody*>(inputDerivedClassPointer);
87391 638 : return IS_SgHeaderFileBody_FAST_MACRO(inputDerivedClassPointer);
87392 : }
87393 :
87394 : // DQ (11/8/2003): Added version of functions taking const pointer
87395 0 : const SgHeaderFileBody* isSgHeaderFileBody ( const SgNode* inputDerivedClassPointer )
87396 : {
87397 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87398 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87399 : // So to fix this we return NULL directly when the input is NULL and avoid the
87400 : // dynamic_cast in this case. This is likely a performance improvement as well.
87401 : // return dynamic_cast<const SgHeaderFileBody*>(inputDerivedClassPointer);
87402 : // Milind Chabbi (8/28/2013): isSgHeaderFileBody uses table-driven castability instead of c++ default dynamic_cast
87403 : // this improves the running time performance by 10-20%.
87404 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgHeaderFileBody*>(inputDerivedClassPointer);
87405 0 : return IS_SgHeaderFileBody_FAST_MACRO(inputDerivedClassPointer);
87406 : }
87407 :
87408 :
87409 :
87410 : /* #line 87411 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87411 :
87412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
87413 :
87414 : /**
87415 : \brief Generated destructor
87416 :
87417 : This destructor is automatically generated (by ROSETTA). This destructor
87418 : only frees memory of data members associated with the parts of the current IR node which
87419 : are NOT traversed. Those data members that are part of a traversal can be freed using
87420 : a traversal (calling this destructor on all children in a post-order traversal). Such
87421 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
87422 :
87423 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
87424 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
87425 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
87426 :
87427 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
87428 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
87429 : pointers are not yet implemented to call delete on eash pointer in the container.
87430 : (This could be done by derivation from the STL containers to define containers that
87431 : automatically deleted their members.)
87432 :
87433 : */
87434 0 : SgHeaderFileBody::~SgHeaderFileBody () {
87435 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
87436 :
87437 :
87438 : // case: not a listType for include_file
87439 0 : p_include_file = NULL; // non list case
87440 :
87441 : }
87442 :
87443 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
87444 0 : }
87445 :
87446 :
87447 : /* #line 87448 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87448 :
87449 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
87450 :
87451 : // Generated constructor
87452 0 : SgHeaderFileBody::SgHeaderFileBody ( Sg_File_Info* startOfConstruct )
87453 0 : : SgLocatedNodeSupport(startOfConstruct)
87454 : {
87455 : #ifdef DEBUG
87456 : // printf ("In SgHeaderFileBody::SgHeaderFileBody (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
87457 : #endif
87458 : #if 0
87459 : // debugging information!
87460 : printf ("In SgHeaderFileBody::SgHeaderFileBody (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
87461 : #endif
87462 :
87463 0 : p_include_file = NULL;
87464 :
87465 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
87466 :
87467 : #if 0
87468 : // DQ (7/30/2014): Call a virtual function.
87469 : std::string s = this->class_name();
87470 : #endif
87471 :
87472 : // Test the variant virtual function
87473 : // assert(TEMP_Header_File_Body == variant());
87474 0 : assert(TEMP_Header_File_Body == this->variant());
87475 0 : ROSE_ASSERT(TEMP_Header_File_Body == (int)(this->variantT()));
87476 0 : post_construction_initialization();
87477 :
87478 : // Test the isSgHeaderFileBody() function since it has been problematic
87479 0 : assert(isSgHeaderFileBody(this) != NULL);
87480 0 : }
87481 :
87482 : // Generated constructor (all data members)
87483 :
87484 : /* #line 87485 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87485 :
87486 :
87487 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
87488 :
87489 :
87490 : // ********************************************************
87491 : // member functions common across all array grammar objects
87492 : // ********************************************************
87493 :
87494 :
87495 :
87496 : /* #line 87497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87497 :
87498 :
87499 :
87500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
87501 :
87502 : // ********************************************************
87503 : // member functions specific to each node in the grammar
87504 : // ********************************************************
87505 :
87506 :
87507 : /* #line 87508 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87508 :
87509 : // Start of memberFunctionString
87510 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
87511 :
87512 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
87513 :
87514 : SgName
87515 0 : SgRenamePair::get_local_name () const
87516 : {
87517 0 : ROSE_ASSERT (this != NULL);
87518 :
87519 : #if 0
87520 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
87521 : // used to trigger marking transformations for the token-based unparsing.
87522 : printf ("SgRenamePair::get_local_name = %p = %s \n",this,this->class_name().c_str());
87523 : #endif
87524 :
87525 0 : return p_local_name;
87526 : }
87527 :
87528 : void
87529 0 : SgRenamePair::set_local_name ( SgName local_name )
87530 : {
87531 0 : ROSE_ASSERT (this != NULL);
87532 :
87533 : #if 0
87534 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
87535 : // used to trigger marking transformations for the token-based unparsing.
87536 : printf ("SgRenamePair::set_local_name = %p = %s \n",this,this->class_name().c_str());
87537 : #endif
87538 :
87539 0 : set_isModified(true);
87540 :
87541 0 : p_local_name = local_name;
87542 0 : }
87543 :
87544 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
87545 :
87546 :
87547 : // End of memberFunctionString
87548 : // Start of memberFunctionString
87549 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
87550 :
87551 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
87552 :
87553 : SgName
87554 0 : SgRenamePair::get_use_name () const
87555 : {
87556 0 : ROSE_ASSERT (this != NULL);
87557 :
87558 : #if 0
87559 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
87560 : // used to trigger marking transformations for the token-based unparsing.
87561 : printf ("SgRenamePair::get_use_name = %p = %s \n",this,this->class_name().c_str());
87562 : #endif
87563 :
87564 0 : return p_use_name;
87565 : }
87566 :
87567 : void
87568 0 : SgRenamePair::set_use_name ( SgName use_name )
87569 : {
87570 0 : ROSE_ASSERT (this != NULL);
87571 :
87572 : #if 0
87573 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
87574 : // used to trigger marking transformations for the token-based unparsing.
87575 : printf ("SgRenamePair::set_use_name = %p = %s \n",this,this->class_name().c_str());
87576 : #endif
87577 :
87578 0 : set_isModified(true);
87579 :
87580 0 : p_use_name = use_name;
87581 0 : }
87582 :
87583 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
87584 :
87585 :
87586 : // End of memberFunctionString
87587 : // Start of memberFunctionString
87588 : /* #line 1605 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
87589 :
87590 :
87591 : bool
87592 0 : SgRenamePair::isRename() const
87593 : {
87594 : // This a treated as a valid renaming if the names are different.
87595 0 : return (p_local_name != p_use_name);
87596 : }
87597 :
87598 :
87599 :
87600 : // End of memberFunctionString
87601 : // Start of memberFunctionString
87602 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
87603 :
87604 : // *** COMMON CODE SECTION BEGINS HERE ***
87605 :
87606 : #if 0
87607 : int
87608 : SgRenamePair::getVariant() const
87609 : {
87610 : // This function is used in ROSE while "variant()" is used in SAGE
87611 : assert(this != NULL);
87612 : return variant();
87613 : }
87614 : #endif
87615 :
87616 : // This function is used in ROSE in treeTraversal code
87617 : // eventually replaces getVariant() and variant()
87618 : // though after variant() has been removed for a while we will
87619 : // want to change the name of variantT() back to variant()
87620 : // (since the "T" was ment to stand for temporary).
87621 : // When this happens the variantT() will be depricated.
87622 : VariantT
87623 0 : SgRenamePair::variantT() const
87624 : {
87625 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
87626 0 : ROSE_ASSERT(this != NULL);
87627 0 : return V_SgRenamePair;
87628 : }
87629 :
87630 : #if 0
87631 : int
87632 : SgRenamePair::variant() const
87633 : {
87634 : // This function is used in SAGE
87635 : ROSE_ASSERT(this != NULL);
87636 : return TEMP_Rename_Pair;
87637 : }
87638 : #endif
87639 :
87640 : ROSE_DLL_API const char*
87641 0 : SgRenamePair::sage_class_name() const
87642 : {
87643 0 : ROSE_ASSERT(this != NULL);
87644 0 : return "SgRenamePair";
87645 : }
87646 :
87647 : std::string
87648 0 : SgRenamePair::class_name() const
87649 : {
87650 0 : ROSE_ASSERT(this != NULL);
87651 0 : return "SgRenamePair";
87652 : }
87653 :
87654 : // DQ (11/26/2005): Support for visitor pattern mechanims
87655 : // (inferior to ROSE traversal mechanism, experimental).
87656 : void
87657 0 : SgRenamePair::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
87658 : {
87659 0 : ROSE_ASSERT(this != NULL);
87660 0 : visitor.visit(this);
87661 0 : }
87662 :
87663 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
87664 0 : void SgRenamePair::accept (ROSE_VisitorPattern & visitor) {
87665 0 : ROSE_ASSERT(this != NULL);
87666 0 : visitor.visit(this);
87667 0 : }
87668 :
87669 : SgRenamePair*
87670 0 : SgRenamePair::addRegExpAttribute(std::string s, AstRegExAttribute* a)
87671 : {
87672 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
87673 : // This function is currently only supported for the AST used the represent Binary executables.
87674 : if (0 /* isSgAsmNode(this) != NULL */)
87675 : {
87676 : // Support for regex specification.
87677 : std::string prefixCode = "REGEX:";
87678 : addNewAttribute(prefixCode + s,a);
87679 : }
87680 : #endif
87681 :
87682 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
87683 0 : return this;
87684 : }
87685 :
87686 : // *** COMMON CODE SECTION ENDS HERE ***
87687 :
87688 :
87689 : // End of memberFunctionString
87690 : // Start of memberFunctionString
87691 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
87692 :
87693 :
87694 : #if 0
87695 : //! Error checking support
87696 : /*! Verifies the following:
87697 : - working getVariant() member function
87698 : - calls base class's error() member function
87699 : Every class has one of these functions.
87700 : */
87701 : bool
87702 : SgRenamePair::error()
87703 : {
87704 : // Put error checking here
87705 :
87706 : ROSE_ASSERT (this != NULL);
87707 : if (getVariant() != TEMP_Rename_Pair)
87708 : {
87709 : printf ("Error in SgRenamePair::error(): SgRenamePair object has a %s variant \n",
87710 : Cxx_GrammarTerminalNames[getVariant()].name);
87711 : // printf ("Error in SgRenamePair::error() \n");
87712 : ROSE_ABORT();
87713 : }
87714 :
87715 : ROSE_ASSERT (getVariant() == TEMP_Rename_Pair);
87716 : return SgLocatedNodeSupport::error();
87717 : }
87718 : #endif
87719 :
87720 :
87721 :
87722 : // End of memberFunctionString
87723 :
87724 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
87725 :
87726 0 : SgRenamePair* isSgRenamePair ( SgNode* inputDerivedClassPointer )
87727 : {
87728 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87729 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87730 : // So to fix this we return NULL directly when the input is NULL and avoid the
87731 : // dynamic_cast in this case. This is likely a performance improvement as well.
87732 : // return dynamic_cast<SgRenamePair*>(inputDerivedClassPointer);
87733 : // Milind Chabbi (8/28/2013): isSgRenamePair uses table-driven castability instead of c++ default dynamic_cast
87734 : // this improves the running time performance by 10-20%.
87735 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRenamePair*>(inputDerivedClassPointer);
87736 0 : return IS_SgRenamePair_FAST_MACRO(inputDerivedClassPointer);
87737 : }
87738 :
87739 : // DQ (11/8/2003): Added version of functions taking const pointer
87740 0 : const SgRenamePair* isSgRenamePair ( const SgNode* inputDerivedClassPointer )
87741 : {
87742 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87743 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87744 : // So to fix this we return NULL directly when the input is NULL and avoid the
87745 : // dynamic_cast in this case. This is likely a performance improvement as well.
87746 : // return dynamic_cast<const SgRenamePair*>(inputDerivedClassPointer);
87747 : // Milind Chabbi (8/28/2013): isSgRenamePair uses table-driven castability instead of c++ default dynamic_cast
87748 : // this improves the running time performance by 10-20%.
87749 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRenamePair*>(inputDerivedClassPointer);
87750 0 : return IS_SgRenamePair_FAST_MACRO(inputDerivedClassPointer);
87751 : }
87752 :
87753 :
87754 :
87755 : /* #line 87756 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87756 :
87757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
87758 :
87759 : /**
87760 : \brief Generated destructor
87761 :
87762 : This destructor is automatically generated (by ROSETTA). This destructor
87763 : only frees memory of data members associated with the parts of the current IR node which
87764 : are NOT traversed. Those data members that are part of a traversal can be freed using
87765 : a traversal (calling this destructor on all children in a post-order traversal). Such
87766 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
87767 :
87768 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
87769 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
87770 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
87771 :
87772 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
87773 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
87774 : pointers are not yet implemented to call delete on eash pointer in the container.
87775 : (This could be done by derivation from the STL containers to define containers that
87776 : automatically deleted their members.)
87777 :
87778 : */
87779 0 : SgRenamePair::~SgRenamePair () {
87780 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
87781 :
87782 :
87783 : // case: not a listType for local_name
87784 0 : p_local_name = ""; // non list case
87785 : // case: not a listType for use_name
87786 0 : p_use_name = ""; // non list case
87787 :
87788 : }
87789 :
87790 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
87791 0 : }
87792 :
87793 :
87794 : /* #line 87795 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87795 :
87796 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
87797 :
87798 : // Generated constructor
87799 0 : SgRenamePair::SgRenamePair ( Sg_File_Info* startOfConstruct, SgName local_name, SgName use_name )
87800 0 : : SgLocatedNodeSupport(startOfConstruct)
87801 : {
87802 : #ifdef DEBUG
87803 : // printf ("In SgRenamePair::SgRenamePair (Sg_File_Info* startOfConstruct, SgName local_name, SgName use_name) sage_class_name() = %s \n",sage_class_name());
87804 : #endif
87805 : #if 0
87806 : // debugging information!
87807 : printf ("In SgRenamePair::SgRenamePair (Sg_File_Info* startOfConstruct, SgName local_name, SgName use_name): this = %p = %s \n",this,this->class_name().c_str());
87808 : #endif
87809 :
87810 0 : p_local_name = local_name;
87811 0 : p_use_name = use_name;
87812 :
87813 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
87814 :
87815 : #if 0
87816 : // DQ (7/30/2014): Call a virtual function.
87817 : std::string s = this->class_name();
87818 : #endif
87819 :
87820 : // Test the variant virtual function
87821 : // assert(TEMP_Rename_Pair == variant());
87822 0 : assert(TEMP_Rename_Pair == this->variant());
87823 0 : ROSE_ASSERT(TEMP_Rename_Pair == (int)(this->variantT()));
87824 0 : post_construction_initialization();
87825 :
87826 : // Test the isSgRenamePair() function since it has been problematic
87827 0 : assert(isSgRenamePair(this) != NULL);
87828 0 : }
87829 :
87830 : // Generated constructor (all data members)
87831 :
87832 : /* #line 87833 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87833 :
87834 :
87835 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
87836 :
87837 :
87838 : // ********************************************************
87839 : // member functions common across all array grammar objects
87840 : // ********************************************************
87841 :
87842 :
87843 :
87844 : /* #line 87845 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87845 :
87846 :
87847 :
87848 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
87849 :
87850 : // ********************************************************
87851 : // member functions specific to each node in the grammar
87852 : // ********************************************************
87853 :
87854 :
87855 : /* #line 87856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
87856 :
87857 : // Start of memberFunctionString
87858 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
87859 :
87860 : // *** COMMON CODE SECTION BEGINS HERE ***
87861 :
87862 : #if 0
87863 : int
87864 : SgOmpClause::getVariant() const
87865 : {
87866 : // This function is used in ROSE while "variant()" is used in SAGE
87867 : assert(this != NULL);
87868 : return variant();
87869 : }
87870 : #endif
87871 :
87872 : // This function is used in ROSE in treeTraversal code
87873 : // eventually replaces getVariant() and variant()
87874 : // though after variant() has been removed for a while we will
87875 : // want to change the name of variantT() back to variant()
87876 : // (since the "T" was ment to stand for temporary).
87877 : // When this happens the variantT() will be depricated.
87878 : VariantT
87879 2088 : SgOmpClause::variantT() const
87880 : {
87881 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
87882 2088 : ROSE_ASSERT(this != NULL);
87883 2088 : return V_SgOmpClause;
87884 : }
87885 :
87886 : #if 0
87887 : int
87888 : SgOmpClause::variant() const
87889 : {
87890 : // This function is used in SAGE
87891 : ROSE_ASSERT(this != NULL);
87892 : return OmpClauseTag;
87893 : }
87894 : #endif
87895 :
87896 : ROSE_DLL_API const char*
87897 0 : SgOmpClause::sage_class_name() const
87898 : {
87899 0 : ROSE_ASSERT(this != NULL);
87900 0 : return "SgOmpClause";
87901 : }
87902 :
87903 : std::string
87904 0 : SgOmpClause::class_name() const
87905 : {
87906 0 : ROSE_ASSERT(this != NULL);
87907 0 : return "SgOmpClause";
87908 : }
87909 :
87910 : // DQ (11/26/2005): Support for visitor pattern mechanims
87911 : // (inferior to ROSE traversal mechanism, experimental).
87912 : void
87913 0 : SgOmpClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
87914 : {
87915 0 : ROSE_ASSERT(this != NULL);
87916 0 : visitor.visit(this);
87917 0 : }
87918 :
87919 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
87920 0 : void SgOmpClause::accept (ROSE_VisitorPattern & visitor) {
87921 0 : ROSE_ASSERT(this != NULL);
87922 0 : visitor.visit(this);
87923 0 : }
87924 :
87925 : SgOmpClause*
87926 0 : SgOmpClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
87927 : {
87928 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
87929 : // This function is currently only supported for the AST used the represent Binary executables.
87930 : if (0 /* isSgAsmNode(this) != NULL */)
87931 : {
87932 : // Support for regex specification.
87933 : std::string prefixCode = "REGEX:";
87934 : addNewAttribute(prefixCode + s,a);
87935 : }
87936 : #endif
87937 :
87938 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
87939 0 : return this;
87940 : }
87941 :
87942 : // *** COMMON CODE SECTION ENDS HERE ***
87943 :
87944 :
87945 : // End of memberFunctionString
87946 : // Start of memberFunctionString
87947 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
87948 :
87949 :
87950 : #if 0
87951 : //! Error checking support
87952 : /*! Verifies the following:
87953 : - working getVariant() member function
87954 : - calls base class's error() member function
87955 : Every class has one of these functions.
87956 : */
87957 : bool
87958 : SgOmpClause::error()
87959 : {
87960 : // Put error checking here
87961 :
87962 : ROSE_ASSERT (this != NULL);
87963 : if (getVariant() != OmpClauseTag)
87964 : {
87965 : printf ("Error in SgOmpClause::error(): SgOmpClause object has a %s variant \n",
87966 : Cxx_GrammarTerminalNames[getVariant()].name);
87967 : // printf ("Error in SgOmpClause::error() \n");
87968 : ROSE_ABORT();
87969 : }
87970 :
87971 : ROSE_ASSERT (getVariant() == OmpClauseTag);
87972 : return SgLocatedNodeSupport::error();
87973 : }
87974 : #endif
87975 :
87976 :
87977 :
87978 : // End of memberFunctionString
87979 :
87980 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
87981 :
87982 696 : SgOmpClause* isSgOmpClause ( SgNode* inputDerivedClassPointer )
87983 : {
87984 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87985 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
87986 : // So to fix this we return NULL directly when the input is NULL and avoid the
87987 : // dynamic_cast in this case. This is likely a performance improvement as well.
87988 : // return dynamic_cast<SgOmpClause*>(inputDerivedClassPointer);
87989 : // Milind Chabbi (8/28/2013): isSgOmpClause uses table-driven castability instead of c++ default dynamic_cast
87990 : // this improves the running time performance by 10-20%.
87991 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpClause*>(inputDerivedClassPointer);
87992 696 : return IS_SgOmpClause_FAST_MACRO(inputDerivedClassPointer);
87993 : }
87994 :
87995 : // DQ (11/8/2003): Added version of functions taking const pointer
87996 21 : const SgOmpClause* isSgOmpClause ( const SgNode* inputDerivedClassPointer )
87997 : {
87998 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
87999 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88000 : // So to fix this we return NULL directly when the input is NULL and avoid the
88001 : // dynamic_cast in this case. This is likely a performance improvement as well.
88002 : // return dynamic_cast<const SgOmpClause*>(inputDerivedClassPointer);
88003 : // Milind Chabbi (8/28/2013): isSgOmpClause uses table-driven castability instead of c++ default dynamic_cast
88004 : // this improves the running time performance by 10-20%.
88005 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpClause*>(inputDerivedClassPointer);
88006 21 : return IS_SgOmpClause_FAST_MACRO(inputDerivedClassPointer);
88007 : }
88008 :
88009 :
88010 :
88011 : /* #line 88012 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88012 :
88013 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88014 :
88015 : /**
88016 : \brief Generated destructor
88017 :
88018 : This destructor is automatically generated (by ROSETTA). This destructor
88019 : only frees memory of data members associated with the parts of the current IR node which
88020 : are NOT traversed. Those data members that are part of a traversal can be freed using
88021 : a traversal (calling this destructor on all children in a post-order traversal). Such
88022 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
88023 :
88024 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
88025 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
88026 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
88027 :
88028 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
88029 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
88030 : pointers are not yet implemented to call delete on eash pointer in the container.
88031 : (This could be done by derivation from the STL containers to define containers that
88032 : automatically deleted their members.)
88033 :
88034 : */
88035 0 : SgOmpClause::~SgOmpClause () {
88036 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
88037 :
88038 :
88039 :
88040 : }
88041 :
88042 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88043 0 : }
88044 :
88045 :
88046 : /* #line 88047 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88047 :
88048 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
88049 :
88050 : // Generated constructor
88051 0 : SgOmpClause::SgOmpClause ( Sg_File_Info* startOfConstruct )
88052 0 : : SgLocatedNodeSupport(startOfConstruct)
88053 : {
88054 : #ifdef DEBUG
88055 : // printf ("In SgOmpClause::SgOmpClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
88056 : #endif
88057 : #if 0
88058 : // debugging information!
88059 : printf ("In SgOmpClause::SgOmpClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
88060 : #endif
88061 :
88062 :
88063 :
88064 : #if 0
88065 : // DQ (7/30/2014): Call a virtual function.
88066 : std::string s = this->class_name();
88067 : #endif
88068 :
88069 : // Test the variant virtual function
88070 : // assert(OmpClauseTag == variant());
88071 0 : assert(OmpClauseTag == this->variant());
88072 0 : ROSE_ASSERT(OmpClauseTag == (int)(this->variantT()));
88073 0 : post_construction_initialization();
88074 :
88075 : // Test the isSgOmpClause() function since it has been problematic
88076 0 : assert(isSgOmpClause(this) != NULL);
88077 0 : }
88078 :
88079 : // Generated constructor (all data members)
88080 :
88081 : /* #line 88082 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88082 :
88083 :
88084 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88085 :
88086 :
88087 : // ********************************************************
88088 : // member functions common across all array grammar objects
88089 : // ********************************************************
88090 :
88091 :
88092 :
88093 : /* #line 88094 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88094 :
88095 :
88096 :
88097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88098 :
88099 : // ********************************************************
88100 : // member functions specific to each node in the grammar
88101 : // ********************************************************
88102 :
88103 :
88104 : /* #line 88105 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88105 :
88106 : // Start of memberFunctionString
88107 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
88108 :
88109 : // *** COMMON CODE SECTION BEGINS HERE ***
88110 :
88111 : #if 0
88112 : int
88113 : SgOmpNowaitClause::getVariant() const
88114 : {
88115 : // This function is used in ROSE while "variant()" is used in SAGE
88116 : assert(this != NULL);
88117 : return variant();
88118 : }
88119 : #endif
88120 :
88121 : // This function is used in ROSE in treeTraversal code
88122 : // eventually replaces getVariant() and variant()
88123 : // though after variant() has been removed for a while we will
88124 : // want to change the name of variantT() back to variant()
88125 : // (since the "T" was ment to stand for temporary).
88126 : // When this happens the variantT() will be depricated.
88127 : VariantT
88128 858 : SgOmpNowaitClause::variantT() const
88129 : {
88130 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
88131 858 : ROSE_ASSERT(this != NULL);
88132 858 : return V_SgOmpNowaitClause;
88133 : }
88134 :
88135 : #if 0
88136 : int
88137 : SgOmpNowaitClause::variant() const
88138 : {
88139 : // This function is used in SAGE
88140 : ROSE_ASSERT(this != NULL);
88141 : return OmpNowaitClauseTag;
88142 : }
88143 : #endif
88144 :
88145 : ROSE_DLL_API const char*
88146 0 : SgOmpNowaitClause::sage_class_name() const
88147 : {
88148 0 : ROSE_ASSERT(this != NULL);
88149 0 : return "SgOmpNowaitClause";
88150 : }
88151 :
88152 : std::string
88153 25 : SgOmpNowaitClause::class_name() const
88154 : {
88155 25 : ROSE_ASSERT(this != NULL);
88156 25 : return "SgOmpNowaitClause";
88157 : }
88158 :
88159 : // DQ (11/26/2005): Support for visitor pattern mechanims
88160 : // (inferior to ROSE traversal mechanism, experimental).
88161 : void
88162 0 : SgOmpNowaitClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
88163 : {
88164 0 : ROSE_ASSERT(this != NULL);
88165 0 : visitor.visit(this);
88166 0 : }
88167 :
88168 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
88169 0 : void SgOmpNowaitClause::accept (ROSE_VisitorPattern & visitor) {
88170 0 : ROSE_ASSERT(this != NULL);
88171 0 : visitor.visit(this);
88172 0 : }
88173 :
88174 : SgOmpNowaitClause*
88175 0 : SgOmpNowaitClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
88176 : {
88177 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
88178 : // This function is currently only supported for the AST used the represent Binary executables.
88179 : if (0 /* isSgAsmNode(this) != NULL */)
88180 : {
88181 : // Support for regex specification.
88182 : std::string prefixCode = "REGEX:";
88183 : addNewAttribute(prefixCode + s,a);
88184 : }
88185 : #endif
88186 :
88187 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
88188 0 : return this;
88189 : }
88190 :
88191 : // *** COMMON CODE SECTION ENDS HERE ***
88192 :
88193 :
88194 : // End of memberFunctionString
88195 : // Start of memberFunctionString
88196 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
88197 :
88198 :
88199 : #if 0
88200 : //! Error checking support
88201 : /*! Verifies the following:
88202 : - working getVariant() member function
88203 : - calls base class's error() member function
88204 : Every class has one of these functions.
88205 : */
88206 : bool
88207 : SgOmpNowaitClause::error()
88208 : {
88209 : // Put error checking here
88210 :
88211 : ROSE_ASSERT (this != NULL);
88212 : if (getVariant() != OmpNowaitClauseTag)
88213 : {
88214 : printf ("Error in SgOmpNowaitClause::error(): SgOmpNowaitClause object has a %s variant \n",
88215 : Cxx_GrammarTerminalNames[getVariant()].name);
88216 : // printf ("Error in SgOmpNowaitClause::error() \n");
88217 : ROSE_ABORT();
88218 : }
88219 :
88220 : ROSE_ASSERT (getVariant() == OmpNowaitClauseTag);
88221 : return SgOmpClause::error();
88222 : }
88223 : #endif
88224 :
88225 :
88226 :
88227 : // End of memberFunctionString
88228 :
88229 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
88230 :
88231 109 : SgOmpNowaitClause* isSgOmpNowaitClause ( SgNode* inputDerivedClassPointer )
88232 : {
88233 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88234 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88235 : // So to fix this we return NULL directly when the input is NULL and avoid the
88236 : // dynamic_cast in this case. This is likely a performance improvement as well.
88237 : // return dynamic_cast<SgOmpNowaitClause*>(inputDerivedClassPointer);
88238 : // Milind Chabbi (8/28/2013): isSgOmpNowaitClause uses table-driven castability instead of c++ default dynamic_cast
88239 : // this improves the running time performance by 10-20%.
88240 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpNowaitClause*>(inputDerivedClassPointer);
88241 109 : return IS_SgOmpNowaitClause_FAST_MACRO(inputDerivedClassPointer);
88242 : }
88243 :
88244 : // DQ (11/8/2003): Added version of functions taking const pointer
88245 0 : const SgOmpNowaitClause* isSgOmpNowaitClause ( const SgNode* inputDerivedClassPointer )
88246 : {
88247 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88248 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88249 : // So to fix this we return NULL directly when the input is NULL and avoid the
88250 : // dynamic_cast in this case. This is likely a performance improvement as well.
88251 : // return dynamic_cast<const SgOmpNowaitClause*>(inputDerivedClassPointer);
88252 : // Milind Chabbi (8/28/2013): isSgOmpNowaitClause uses table-driven castability instead of c++ default dynamic_cast
88253 : // this improves the running time performance by 10-20%.
88254 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpNowaitClause*>(inputDerivedClassPointer);
88255 0 : return IS_SgOmpNowaitClause_FAST_MACRO(inputDerivedClassPointer);
88256 : }
88257 :
88258 :
88259 :
88260 : /* #line 88261 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88261 :
88262 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88263 :
88264 : /**
88265 : \brief Generated destructor
88266 :
88267 : This destructor is automatically generated (by ROSETTA). This destructor
88268 : only frees memory of data members associated with the parts of the current IR node which
88269 : are NOT traversed. Those data members that are part of a traversal can be freed using
88270 : a traversal (calling this destructor on all children in a post-order traversal). Such
88271 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
88272 :
88273 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
88274 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
88275 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
88276 :
88277 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
88278 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
88279 : pointers are not yet implemented to call delete on eash pointer in the container.
88280 : (This could be done by derivation from the STL containers to define containers that
88281 : automatically deleted their members.)
88282 :
88283 : */
88284 0 : SgOmpNowaitClause::~SgOmpNowaitClause () {
88285 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
88286 :
88287 :
88288 :
88289 : }
88290 :
88291 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88292 0 : }
88293 :
88294 :
88295 : /* #line 88296 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88296 :
88297 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
88298 :
88299 : // Generated constructor
88300 0 : SgOmpNowaitClause::SgOmpNowaitClause ( Sg_File_Info* startOfConstruct )
88301 0 : : SgOmpClause(startOfConstruct)
88302 : {
88303 : #ifdef DEBUG
88304 : // printf ("In SgOmpNowaitClause::SgOmpNowaitClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
88305 : #endif
88306 : #if 0
88307 : // debugging information!
88308 : printf ("In SgOmpNowaitClause::SgOmpNowaitClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
88309 : #endif
88310 :
88311 :
88312 :
88313 : #if 0
88314 : // DQ (7/30/2014): Call a virtual function.
88315 : std::string s = this->class_name();
88316 : #endif
88317 :
88318 : // Test the variant virtual function
88319 : // assert(OmpNowaitClauseTag == variant());
88320 0 : assert(OmpNowaitClauseTag == this->variant());
88321 0 : ROSE_ASSERT(OmpNowaitClauseTag == (int)(this->variantT()));
88322 0 : post_construction_initialization();
88323 :
88324 : // Test the isSgOmpNowaitClause() function since it has been problematic
88325 0 : assert(isSgOmpNowaitClause(this) != NULL);
88326 0 : }
88327 :
88328 : // Generated constructor (all data members)
88329 :
88330 : /* #line 88331 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88331 :
88332 :
88333 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88334 :
88335 :
88336 : // ********************************************************
88337 : // member functions common across all array grammar objects
88338 : // ********************************************************
88339 :
88340 :
88341 :
88342 : /* #line 88343 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88343 :
88344 :
88345 :
88346 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88347 :
88348 : // ********************************************************
88349 : // member functions specific to each node in the grammar
88350 : // ********************************************************
88351 :
88352 :
88353 : /* #line 88354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88354 :
88355 : // Start of memberFunctionString
88356 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
88357 :
88358 : // *** COMMON CODE SECTION BEGINS HERE ***
88359 :
88360 : #if 0
88361 : int
88362 : SgOmpReadClause::getVariant() const
88363 : {
88364 : // This function is used in ROSE while "variant()" is used in SAGE
88365 : assert(this != NULL);
88366 : return variant();
88367 : }
88368 : #endif
88369 :
88370 : // This function is used in ROSE in treeTraversal code
88371 : // eventually replaces getVariant() and variant()
88372 : // though after variant() has been removed for a while we will
88373 : // want to change the name of variantT() back to variant()
88374 : // (since the "T" was ment to stand for temporary).
88375 : // When this happens the variantT() will be depricated.
88376 : VariantT
88377 104 : SgOmpReadClause::variantT() const
88378 : {
88379 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
88380 104 : ROSE_ASSERT(this != NULL);
88381 104 : return V_SgOmpReadClause;
88382 : }
88383 :
88384 : #if 0
88385 : int
88386 : SgOmpReadClause::variant() const
88387 : {
88388 : // This function is used in SAGE
88389 : ROSE_ASSERT(this != NULL);
88390 : return OmpReadClauseTag;
88391 : }
88392 : #endif
88393 :
88394 : ROSE_DLL_API const char*
88395 0 : SgOmpReadClause::sage_class_name() const
88396 : {
88397 0 : ROSE_ASSERT(this != NULL);
88398 0 : return "SgOmpReadClause";
88399 : }
88400 :
88401 : std::string
88402 2 : SgOmpReadClause::class_name() const
88403 : {
88404 2 : ROSE_ASSERT(this != NULL);
88405 2 : return "SgOmpReadClause";
88406 : }
88407 :
88408 : // DQ (11/26/2005): Support for visitor pattern mechanims
88409 : // (inferior to ROSE traversal mechanism, experimental).
88410 : void
88411 0 : SgOmpReadClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
88412 : {
88413 0 : ROSE_ASSERT(this != NULL);
88414 0 : visitor.visit(this);
88415 0 : }
88416 :
88417 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
88418 0 : void SgOmpReadClause::accept (ROSE_VisitorPattern & visitor) {
88419 0 : ROSE_ASSERT(this != NULL);
88420 0 : visitor.visit(this);
88421 0 : }
88422 :
88423 : SgOmpReadClause*
88424 0 : SgOmpReadClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
88425 : {
88426 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
88427 : // This function is currently only supported for the AST used the represent Binary executables.
88428 : if (0 /* isSgAsmNode(this) != NULL */)
88429 : {
88430 : // Support for regex specification.
88431 : std::string prefixCode = "REGEX:";
88432 : addNewAttribute(prefixCode + s,a);
88433 : }
88434 : #endif
88435 :
88436 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
88437 0 : return this;
88438 : }
88439 :
88440 : // *** COMMON CODE SECTION ENDS HERE ***
88441 :
88442 :
88443 : // End of memberFunctionString
88444 : // Start of memberFunctionString
88445 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
88446 :
88447 :
88448 : #if 0
88449 : //! Error checking support
88450 : /*! Verifies the following:
88451 : - working getVariant() member function
88452 : - calls base class's error() member function
88453 : Every class has one of these functions.
88454 : */
88455 : bool
88456 : SgOmpReadClause::error()
88457 : {
88458 : // Put error checking here
88459 :
88460 : ROSE_ASSERT (this != NULL);
88461 : if (getVariant() != OmpReadClauseTag)
88462 : {
88463 : printf ("Error in SgOmpReadClause::error(): SgOmpReadClause object has a %s variant \n",
88464 : Cxx_GrammarTerminalNames[getVariant()].name);
88465 : // printf ("Error in SgOmpReadClause::error() \n");
88466 : ROSE_ABORT();
88467 : }
88468 :
88469 : ROSE_ASSERT (getVariant() == OmpReadClauseTag);
88470 : return SgOmpClause::error();
88471 : }
88472 : #endif
88473 :
88474 :
88475 :
88476 : // End of memberFunctionString
88477 :
88478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
88479 :
88480 2 : SgOmpReadClause* isSgOmpReadClause ( SgNode* inputDerivedClassPointer )
88481 : {
88482 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88483 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88484 : // So to fix this we return NULL directly when the input is NULL and avoid the
88485 : // dynamic_cast in this case. This is likely a performance improvement as well.
88486 : // return dynamic_cast<SgOmpReadClause*>(inputDerivedClassPointer);
88487 : // Milind Chabbi (8/28/2013): isSgOmpReadClause uses table-driven castability instead of c++ default dynamic_cast
88488 : // this improves the running time performance by 10-20%.
88489 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpReadClause*>(inputDerivedClassPointer);
88490 2 : return IS_SgOmpReadClause_FAST_MACRO(inputDerivedClassPointer);
88491 : }
88492 :
88493 : // DQ (11/8/2003): Added version of functions taking const pointer
88494 0 : const SgOmpReadClause* isSgOmpReadClause ( const SgNode* inputDerivedClassPointer )
88495 : {
88496 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88497 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88498 : // So to fix this we return NULL directly when the input is NULL and avoid the
88499 : // dynamic_cast in this case. This is likely a performance improvement as well.
88500 : // return dynamic_cast<const SgOmpReadClause*>(inputDerivedClassPointer);
88501 : // Milind Chabbi (8/28/2013): isSgOmpReadClause uses table-driven castability instead of c++ default dynamic_cast
88502 : // this improves the running time performance by 10-20%.
88503 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpReadClause*>(inputDerivedClassPointer);
88504 0 : return IS_SgOmpReadClause_FAST_MACRO(inputDerivedClassPointer);
88505 : }
88506 :
88507 :
88508 :
88509 : /* #line 88510 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88510 :
88511 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88512 :
88513 : /**
88514 : \brief Generated destructor
88515 :
88516 : This destructor is automatically generated (by ROSETTA). This destructor
88517 : only frees memory of data members associated with the parts of the current IR node which
88518 : are NOT traversed. Those data members that are part of a traversal can be freed using
88519 : a traversal (calling this destructor on all children in a post-order traversal). Such
88520 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
88521 :
88522 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
88523 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
88524 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
88525 :
88526 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
88527 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
88528 : pointers are not yet implemented to call delete on eash pointer in the container.
88529 : (This could be done by derivation from the STL containers to define containers that
88530 : automatically deleted their members.)
88531 :
88532 : */
88533 0 : SgOmpReadClause::~SgOmpReadClause () {
88534 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
88535 :
88536 :
88537 :
88538 : }
88539 :
88540 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88541 0 : }
88542 :
88543 :
88544 : /* #line 88545 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88545 :
88546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
88547 :
88548 : // Generated constructor
88549 0 : SgOmpReadClause::SgOmpReadClause ( Sg_File_Info* startOfConstruct )
88550 0 : : SgOmpClause(startOfConstruct)
88551 : {
88552 : #ifdef DEBUG
88553 : // printf ("In SgOmpReadClause::SgOmpReadClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
88554 : #endif
88555 : #if 0
88556 : // debugging information!
88557 : printf ("In SgOmpReadClause::SgOmpReadClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
88558 : #endif
88559 :
88560 :
88561 :
88562 : #if 0
88563 : // DQ (7/30/2014): Call a virtual function.
88564 : std::string s = this->class_name();
88565 : #endif
88566 :
88567 : // Test the variant virtual function
88568 : // assert(OmpReadClauseTag == variant());
88569 0 : assert(OmpReadClauseTag == this->variant());
88570 0 : ROSE_ASSERT(OmpReadClauseTag == (int)(this->variantT()));
88571 0 : post_construction_initialization();
88572 :
88573 : // Test the isSgOmpReadClause() function since it has been problematic
88574 0 : assert(isSgOmpReadClause(this) != NULL);
88575 0 : }
88576 :
88577 : // Generated constructor (all data members)
88578 :
88579 : /* #line 88580 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88580 :
88581 :
88582 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88583 :
88584 :
88585 : // ********************************************************
88586 : // member functions common across all array grammar objects
88587 : // ********************************************************
88588 :
88589 :
88590 :
88591 : /* #line 88592 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88592 :
88593 :
88594 :
88595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88596 :
88597 : // ********************************************************
88598 : // member functions specific to each node in the grammar
88599 : // ********************************************************
88600 :
88601 :
88602 : /* #line 88603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88603 :
88604 : // Start of memberFunctionString
88605 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
88606 :
88607 : // *** COMMON CODE SECTION BEGINS HERE ***
88608 :
88609 : #if 0
88610 : int
88611 : SgOmpThreadsClause::getVariant() const
88612 : {
88613 : // This function is used in ROSE while "variant()" is used in SAGE
88614 : assert(this != NULL);
88615 : return variant();
88616 : }
88617 : #endif
88618 :
88619 : // This function is used in ROSE in treeTraversal code
88620 : // eventually replaces getVariant() and variant()
88621 : // though after variant() has been removed for a while we will
88622 : // want to change the name of variantT() back to variant()
88623 : // (since the "T" was ment to stand for temporary).
88624 : // When this happens the variantT() will be depricated.
88625 : VariantT
88626 0 : SgOmpThreadsClause::variantT() const
88627 : {
88628 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
88629 0 : ROSE_ASSERT(this != NULL);
88630 0 : return V_SgOmpThreadsClause;
88631 : }
88632 :
88633 : #if 0
88634 : int
88635 : SgOmpThreadsClause::variant() const
88636 : {
88637 : // This function is used in SAGE
88638 : ROSE_ASSERT(this != NULL);
88639 : return OmpThreadsClauseTag;
88640 : }
88641 : #endif
88642 :
88643 : ROSE_DLL_API const char*
88644 0 : SgOmpThreadsClause::sage_class_name() const
88645 : {
88646 0 : ROSE_ASSERT(this != NULL);
88647 0 : return "SgOmpThreadsClause";
88648 : }
88649 :
88650 : std::string
88651 0 : SgOmpThreadsClause::class_name() const
88652 : {
88653 0 : ROSE_ASSERT(this != NULL);
88654 0 : return "SgOmpThreadsClause";
88655 : }
88656 :
88657 : // DQ (11/26/2005): Support for visitor pattern mechanims
88658 : // (inferior to ROSE traversal mechanism, experimental).
88659 : void
88660 0 : SgOmpThreadsClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
88661 : {
88662 0 : ROSE_ASSERT(this != NULL);
88663 0 : visitor.visit(this);
88664 0 : }
88665 :
88666 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
88667 0 : void SgOmpThreadsClause::accept (ROSE_VisitorPattern & visitor) {
88668 0 : ROSE_ASSERT(this != NULL);
88669 0 : visitor.visit(this);
88670 0 : }
88671 :
88672 : SgOmpThreadsClause*
88673 0 : SgOmpThreadsClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
88674 : {
88675 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
88676 : // This function is currently only supported for the AST used the represent Binary executables.
88677 : if (0 /* isSgAsmNode(this) != NULL */)
88678 : {
88679 : // Support for regex specification.
88680 : std::string prefixCode = "REGEX:";
88681 : addNewAttribute(prefixCode + s,a);
88682 : }
88683 : #endif
88684 :
88685 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
88686 0 : return this;
88687 : }
88688 :
88689 : // *** COMMON CODE SECTION ENDS HERE ***
88690 :
88691 :
88692 : // End of memberFunctionString
88693 : // Start of memberFunctionString
88694 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
88695 :
88696 :
88697 : #if 0
88698 : //! Error checking support
88699 : /*! Verifies the following:
88700 : - working getVariant() member function
88701 : - calls base class's error() member function
88702 : Every class has one of these functions.
88703 : */
88704 : bool
88705 : SgOmpThreadsClause::error()
88706 : {
88707 : // Put error checking here
88708 :
88709 : ROSE_ASSERT (this != NULL);
88710 : if (getVariant() != OmpThreadsClauseTag)
88711 : {
88712 : printf ("Error in SgOmpThreadsClause::error(): SgOmpThreadsClause object has a %s variant \n",
88713 : Cxx_GrammarTerminalNames[getVariant()].name);
88714 : // printf ("Error in SgOmpThreadsClause::error() \n");
88715 : ROSE_ABORT();
88716 : }
88717 :
88718 : ROSE_ASSERT (getVariant() == OmpThreadsClauseTag);
88719 : return SgOmpClause::error();
88720 : }
88721 : #endif
88722 :
88723 :
88724 :
88725 : // End of memberFunctionString
88726 :
88727 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
88728 :
88729 0 : SgOmpThreadsClause* isSgOmpThreadsClause ( SgNode* inputDerivedClassPointer )
88730 : {
88731 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88732 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88733 : // So to fix this we return NULL directly when the input is NULL and avoid the
88734 : // dynamic_cast in this case. This is likely a performance improvement as well.
88735 : // return dynamic_cast<SgOmpThreadsClause*>(inputDerivedClassPointer);
88736 : // Milind Chabbi (8/28/2013): isSgOmpThreadsClause uses table-driven castability instead of c++ default dynamic_cast
88737 : // this improves the running time performance by 10-20%.
88738 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpThreadsClause*>(inputDerivedClassPointer);
88739 0 : return IS_SgOmpThreadsClause_FAST_MACRO(inputDerivedClassPointer);
88740 : }
88741 :
88742 : // DQ (11/8/2003): Added version of functions taking const pointer
88743 0 : const SgOmpThreadsClause* isSgOmpThreadsClause ( const SgNode* inputDerivedClassPointer )
88744 : {
88745 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88746 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88747 : // So to fix this we return NULL directly when the input is NULL and avoid the
88748 : // dynamic_cast in this case. This is likely a performance improvement as well.
88749 : // return dynamic_cast<const SgOmpThreadsClause*>(inputDerivedClassPointer);
88750 : // Milind Chabbi (8/28/2013): isSgOmpThreadsClause uses table-driven castability instead of c++ default dynamic_cast
88751 : // this improves the running time performance by 10-20%.
88752 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpThreadsClause*>(inputDerivedClassPointer);
88753 0 : return IS_SgOmpThreadsClause_FAST_MACRO(inputDerivedClassPointer);
88754 : }
88755 :
88756 :
88757 :
88758 : /* #line 88759 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88759 :
88760 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88761 :
88762 : /**
88763 : \brief Generated destructor
88764 :
88765 : This destructor is automatically generated (by ROSETTA). This destructor
88766 : only frees memory of data members associated with the parts of the current IR node which
88767 : are NOT traversed. Those data members that are part of a traversal can be freed using
88768 : a traversal (calling this destructor on all children in a post-order traversal). Such
88769 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
88770 :
88771 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
88772 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
88773 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
88774 :
88775 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
88776 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
88777 : pointers are not yet implemented to call delete on eash pointer in the container.
88778 : (This could be done by derivation from the STL containers to define containers that
88779 : automatically deleted their members.)
88780 :
88781 : */
88782 0 : SgOmpThreadsClause::~SgOmpThreadsClause () {
88783 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
88784 :
88785 :
88786 :
88787 : }
88788 :
88789 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
88790 0 : }
88791 :
88792 :
88793 : /* #line 88794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88794 :
88795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
88796 :
88797 : // Generated constructor
88798 0 : SgOmpThreadsClause::SgOmpThreadsClause ( Sg_File_Info* startOfConstruct )
88799 0 : : SgOmpClause(startOfConstruct)
88800 : {
88801 : #ifdef DEBUG
88802 : // printf ("In SgOmpThreadsClause::SgOmpThreadsClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
88803 : #endif
88804 : #if 0
88805 : // debugging information!
88806 : printf ("In SgOmpThreadsClause::SgOmpThreadsClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
88807 : #endif
88808 :
88809 :
88810 :
88811 : #if 0
88812 : // DQ (7/30/2014): Call a virtual function.
88813 : std::string s = this->class_name();
88814 : #endif
88815 :
88816 : // Test the variant virtual function
88817 : // assert(OmpThreadsClauseTag == variant());
88818 0 : assert(OmpThreadsClauseTag == this->variant());
88819 0 : ROSE_ASSERT(OmpThreadsClauseTag == (int)(this->variantT()));
88820 0 : post_construction_initialization();
88821 :
88822 : // Test the isSgOmpThreadsClause() function since it has been problematic
88823 0 : assert(isSgOmpThreadsClause(this) != NULL);
88824 0 : }
88825 :
88826 : // Generated constructor (all data members)
88827 :
88828 : /* #line 88829 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88829 :
88830 :
88831 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88832 :
88833 :
88834 : // ********************************************************
88835 : // member functions common across all array grammar objects
88836 : // ********************************************************
88837 :
88838 :
88839 :
88840 : /* #line 88841 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88841 :
88842 :
88843 :
88844 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
88845 :
88846 : // ********************************************************
88847 : // member functions specific to each node in the grammar
88848 : // ********************************************************
88849 :
88850 :
88851 : /* #line 88852 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
88852 :
88853 : // Start of memberFunctionString
88854 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
88855 :
88856 : // *** COMMON CODE SECTION BEGINS HERE ***
88857 :
88858 : #if 0
88859 : int
88860 : SgOmpSimdClause::getVariant() const
88861 : {
88862 : // This function is used in ROSE while "variant()" is used in SAGE
88863 : assert(this != NULL);
88864 : return variant();
88865 : }
88866 : #endif
88867 :
88868 : // This function is used in ROSE in treeTraversal code
88869 : // eventually replaces getVariant() and variant()
88870 : // though after variant() has been removed for a while we will
88871 : // want to change the name of variantT() back to variant()
88872 : // (since the "T" was ment to stand for temporary).
88873 : // When this happens the variantT() will be depricated.
88874 : VariantT
88875 0 : SgOmpSimdClause::variantT() const
88876 : {
88877 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
88878 0 : ROSE_ASSERT(this != NULL);
88879 0 : return V_SgOmpSimdClause;
88880 : }
88881 :
88882 : #if 0
88883 : int
88884 : SgOmpSimdClause::variant() const
88885 : {
88886 : // This function is used in SAGE
88887 : ROSE_ASSERT(this != NULL);
88888 : return OmpSimdClauseTag;
88889 : }
88890 : #endif
88891 :
88892 : ROSE_DLL_API const char*
88893 0 : SgOmpSimdClause::sage_class_name() const
88894 : {
88895 0 : ROSE_ASSERT(this != NULL);
88896 0 : return "SgOmpSimdClause";
88897 : }
88898 :
88899 : std::string
88900 0 : SgOmpSimdClause::class_name() const
88901 : {
88902 0 : ROSE_ASSERT(this != NULL);
88903 0 : return "SgOmpSimdClause";
88904 : }
88905 :
88906 : // DQ (11/26/2005): Support for visitor pattern mechanims
88907 : // (inferior to ROSE traversal mechanism, experimental).
88908 : void
88909 0 : SgOmpSimdClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
88910 : {
88911 0 : ROSE_ASSERT(this != NULL);
88912 0 : visitor.visit(this);
88913 0 : }
88914 :
88915 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
88916 0 : void SgOmpSimdClause::accept (ROSE_VisitorPattern & visitor) {
88917 0 : ROSE_ASSERT(this != NULL);
88918 0 : visitor.visit(this);
88919 0 : }
88920 :
88921 : SgOmpSimdClause*
88922 0 : SgOmpSimdClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
88923 : {
88924 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
88925 : // This function is currently only supported for the AST used the represent Binary executables.
88926 : if (0 /* isSgAsmNode(this) != NULL */)
88927 : {
88928 : // Support for regex specification.
88929 : std::string prefixCode = "REGEX:";
88930 : addNewAttribute(prefixCode + s,a);
88931 : }
88932 : #endif
88933 :
88934 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
88935 0 : return this;
88936 : }
88937 :
88938 : // *** COMMON CODE SECTION ENDS HERE ***
88939 :
88940 :
88941 : // End of memberFunctionString
88942 : // Start of memberFunctionString
88943 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
88944 :
88945 :
88946 : #if 0
88947 : //! Error checking support
88948 : /*! Verifies the following:
88949 : - working getVariant() member function
88950 : - calls base class's error() member function
88951 : Every class has one of these functions.
88952 : */
88953 : bool
88954 : SgOmpSimdClause::error()
88955 : {
88956 : // Put error checking here
88957 :
88958 : ROSE_ASSERT (this != NULL);
88959 : if (getVariant() != OmpSimdClauseTag)
88960 : {
88961 : printf ("Error in SgOmpSimdClause::error(): SgOmpSimdClause object has a %s variant \n",
88962 : Cxx_GrammarTerminalNames[getVariant()].name);
88963 : // printf ("Error in SgOmpSimdClause::error() \n");
88964 : ROSE_ABORT();
88965 : }
88966 :
88967 : ROSE_ASSERT (getVariant() == OmpSimdClauseTag);
88968 : return SgOmpClause::error();
88969 : }
88970 : #endif
88971 :
88972 :
88973 :
88974 : // End of memberFunctionString
88975 :
88976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
88977 :
88978 0 : SgOmpSimdClause* isSgOmpSimdClause ( SgNode* inputDerivedClassPointer )
88979 : {
88980 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88981 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88982 : // So to fix this we return NULL directly when the input is NULL and avoid the
88983 : // dynamic_cast in this case. This is likely a performance improvement as well.
88984 : // return dynamic_cast<SgOmpSimdClause*>(inputDerivedClassPointer);
88985 : // Milind Chabbi (8/28/2013): isSgOmpSimdClause uses table-driven castability instead of c++ default dynamic_cast
88986 : // this improves the running time performance by 10-20%.
88987 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSimdClause*>(inputDerivedClassPointer);
88988 0 : return IS_SgOmpSimdClause_FAST_MACRO(inputDerivedClassPointer);
88989 : }
88990 :
88991 : // DQ (11/8/2003): Added version of functions taking const pointer
88992 0 : const SgOmpSimdClause* isSgOmpSimdClause ( const SgNode* inputDerivedClassPointer )
88993 : {
88994 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
88995 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
88996 : // So to fix this we return NULL directly when the input is NULL and avoid the
88997 : // dynamic_cast in this case. This is likely a performance improvement as well.
88998 : // return dynamic_cast<const SgOmpSimdClause*>(inputDerivedClassPointer);
88999 : // Milind Chabbi (8/28/2013): isSgOmpSimdClause uses table-driven castability instead of c++ default dynamic_cast
89000 : // this improves the running time performance by 10-20%.
89001 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSimdClause*>(inputDerivedClassPointer);
89002 0 : return IS_SgOmpSimdClause_FAST_MACRO(inputDerivedClassPointer);
89003 : }
89004 :
89005 :
89006 :
89007 : /* #line 89008 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89008 :
89009 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89010 :
89011 : /**
89012 : \brief Generated destructor
89013 :
89014 : This destructor is automatically generated (by ROSETTA). This destructor
89015 : only frees memory of data members associated with the parts of the current IR node which
89016 : are NOT traversed. Those data members that are part of a traversal can be freed using
89017 : a traversal (calling this destructor on all children in a post-order traversal). Such
89018 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
89019 :
89020 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
89021 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
89022 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
89023 :
89024 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
89025 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
89026 : pointers are not yet implemented to call delete on eash pointer in the container.
89027 : (This could be done by derivation from the STL containers to define containers that
89028 : automatically deleted their members.)
89029 :
89030 : */
89031 0 : SgOmpSimdClause::~SgOmpSimdClause () {
89032 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
89033 :
89034 :
89035 :
89036 : }
89037 :
89038 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89039 0 : }
89040 :
89041 :
89042 : /* #line 89043 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89043 :
89044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
89045 :
89046 : // Generated constructor
89047 0 : SgOmpSimdClause::SgOmpSimdClause ( Sg_File_Info* startOfConstruct )
89048 0 : : SgOmpClause(startOfConstruct)
89049 : {
89050 : #ifdef DEBUG
89051 : // printf ("In SgOmpSimdClause::SgOmpSimdClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
89052 : #endif
89053 : #if 0
89054 : // debugging information!
89055 : printf ("In SgOmpSimdClause::SgOmpSimdClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
89056 : #endif
89057 :
89058 :
89059 :
89060 : #if 0
89061 : // DQ (7/30/2014): Call a virtual function.
89062 : std::string s = this->class_name();
89063 : #endif
89064 :
89065 : // Test the variant virtual function
89066 : // assert(OmpSimdClauseTag == variant());
89067 0 : assert(OmpSimdClauseTag == this->variant());
89068 0 : ROSE_ASSERT(OmpSimdClauseTag == (int)(this->variantT()));
89069 0 : post_construction_initialization();
89070 :
89071 : // Test the isSgOmpSimdClause() function since it has been problematic
89072 0 : assert(isSgOmpSimdClause(this) != NULL);
89073 0 : }
89074 :
89075 : // Generated constructor (all data members)
89076 :
89077 : /* #line 89078 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89078 :
89079 :
89080 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89081 :
89082 :
89083 : // ********************************************************
89084 : // member functions common across all array grammar objects
89085 : // ********************************************************
89086 :
89087 :
89088 :
89089 : /* #line 89090 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89090 :
89091 :
89092 :
89093 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89094 :
89095 : // ********************************************************
89096 : // member functions specific to each node in the grammar
89097 : // ********************************************************
89098 :
89099 :
89100 : /* #line 89101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89101 :
89102 : // Start of memberFunctionString
89103 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
89104 :
89105 : // *** COMMON CODE SECTION BEGINS HERE ***
89106 :
89107 : #if 0
89108 : int
89109 : SgOmpWriteClause::getVariant() const
89110 : {
89111 : // This function is used in ROSE while "variant()" is used in SAGE
89112 : assert(this != NULL);
89113 : return variant();
89114 : }
89115 : #endif
89116 :
89117 : // This function is used in ROSE in treeTraversal code
89118 : // eventually replaces getVariant() and variant()
89119 : // though after variant() has been removed for a while we will
89120 : // want to change the name of variantT() back to variant()
89121 : // (since the "T" was ment to stand for temporary).
89122 : // When this happens the variantT() will be depricated.
89123 : VariantT
89124 52 : SgOmpWriteClause::variantT() const
89125 : {
89126 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
89127 52 : ROSE_ASSERT(this != NULL);
89128 52 : return V_SgOmpWriteClause;
89129 : }
89130 :
89131 : #if 0
89132 : int
89133 : SgOmpWriteClause::variant() const
89134 : {
89135 : // This function is used in SAGE
89136 : ROSE_ASSERT(this != NULL);
89137 : return OmpWriteClauseTag;
89138 : }
89139 : #endif
89140 :
89141 : ROSE_DLL_API const char*
89142 0 : SgOmpWriteClause::sage_class_name() const
89143 : {
89144 0 : ROSE_ASSERT(this != NULL);
89145 0 : return "SgOmpWriteClause";
89146 : }
89147 :
89148 : std::string
89149 1 : SgOmpWriteClause::class_name() const
89150 : {
89151 1 : ROSE_ASSERT(this != NULL);
89152 1 : return "SgOmpWriteClause";
89153 : }
89154 :
89155 : // DQ (11/26/2005): Support for visitor pattern mechanims
89156 : // (inferior to ROSE traversal mechanism, experimental).
89157 : void
89158 0 : SgOmpWriteClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
89159 : {
89160 0 : ROSE_ASSERT(this != NULL);
89161 0 : visitor.visit(this);
89162 0 : }
89163 :
89164 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
89165 0 : void SgOmpWriteClause::accept (ROSE_VisitorPattern & visitor) {
89166 0 : ROSE_ASSERT(this != NULL);
89167 0 : visitor.visit(this);
89168 0 : }
89169 :
89170 : SgOmpWriteClause*
89171 0 : SgOmpWriteClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
89172 : {
89173 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
89174 : // This function is currently only supported for the AST used the represent Binary executables.
89175 : if (0 /* isSgAsmNode(this) != NULL */)
89176 : {
89177 : // Support for regex specification.
89178 : std::string prefixCode = "REGEX:";
89179 : addNewAttribute(prefixCode + s,a);
89180 : }
89181 : #endif
89182 :
89183 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
89184 0 : return this;
89185 : }
89186 :
89187 : // *** COMMON CODE SECTION ENDS HERE ***
89188 :
89189 :
89190 : // End of memberFunctionString
89191 : // Start of memberFunctionString
89192 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
89193 :
89194 :
89195 : #if 0
89196 : //! Error checking support
89197 : /*! Verifies the following:
89198 : - working getVariant() member function
89199 : - calls base class's error() member function
89200 : Every class has one of these functions.
89201 : */
89202 : bool
89203 : SgOmpWriteClause::error()
89204 : {
89205 : // Put error checking here
89206 :
89207 : ROSE_ASSERT (this != NULL);
89208 : if (getVariant() != OmpWriteClauseTag)
89209 : {
89210 : printf ("Error in SgOmpWriteClause::error(): SgOmpWriteClause object has a %s variant \n",
89211 : Cxx_GrammarTerminalNames[getVariant()].name);
89212 : // printf ("Error in SgOmpWriteClause::error() \n");
89213 : ROSE_ABORT();
89214 : }
89215 :
89216 : ROSE_ASSERT (getVariant() == OmpWriteClauseTag);
89217 : return SgOmpClause::error();
89218 : }
89219 : #endif
89220 :
89221 :
89222 :
89223 : // End of memberFunctionString
89224 :
89225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
89226 :
89227 1 : SgOmpWriteClause* isSgOmpWriteClause ( SgNode* inputDerivedClassPointer )
89228 : {
89229 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
89230 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
89231 : // So to fix this we return NULL directly when the input is NULL and avoid the
89232 : // dynamic_cast in this case. This is likely a performance improvement as well.
89233 : // return dynamic_cast<SgOmpWriteClause*>(inputDerivedClassPointer);
89234 : // Milind Chabbi (8/28/2013): isSgOmpWriteClause uses table-driven castability instead of c++ default dynamic_cast
89235 : // this improves the running time performance by 10-20%.
89236 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpWriteClause*>(inputDerivedClassPointer);
89237 1 : return IS_SgOmpWriteClause_FAST_MACRO(inputDerivedClassPointer);
89238 : }
89239 :
89240 : // DQ (11/8/2003): Added version of functions taking const pointer
89241 0 : const SgOmpWriteClause* isSgOmpWriteClause ( const SgNode* inputDerivedClassPointer )
89242 : {
89243 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
89244 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
89245 : // So to fix this we return NULL directly when the input is NULL and avoid the
89246 : // dynamic_cast in this case. This is likely a performance improvement as well.
89247 : // return dynamic_cast<const SgOmpWriteClause*>(inputDerivedClassPointer);
89248 : // Milind Chabbi (8/28/2013): isSgOmpWriteClause uses table-driven castability instead of c++ default dynamic_cast
89249 : // this improves the running time performance by 10-20%.
89250 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpWriteClause*>(inputDerivedClassPointer);
89251 0 : return IS_SgOmpWriteClause_FAST_MACRO(inputDerivedClassPointer);
89252 : }
89253 :
89254 :
89255 :
89256 : /* #line 89257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89257 :
89258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89259 :
89260 : /**
89261 : \brief Generated destructor
89262 :
89263 : This destructor is automatically generated (by ROSETTA). This destructor
89264 : only frees memory of data members associated with the parts of the current IR node which
89265 : are NOT traversed. Those data members that are part of a traversal can be freed using
89266 : a traversal (calling this destructor on all children in a post-order traversal). Such
89267 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
89268 :
89269 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
89270 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
89271 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
89272 :
89273 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
89274 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
89275 : pointers are not yet implemented to call delete on eash pointer in the container.
89276 : (This could be done by derivation from the STL containers to define containers that
89277 : automatically deleted their members.)
89278 :
89279 : */
89280 0 : SgOmpWriteClause::~SgOmpWriteClause () {
89281 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
89282 :
89283 :
89284 :
89285 : }
89286 :
89287 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89288 0 : }
89289 :
89290 :
89291 : /* #line 89292 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89292 :
89293 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
89294 :
89295 : // Generated constructor
89296 0 : SgOmpWriteClause::SgOmpWriteClause ( Sg_File_Info* startOfConstruct )
89297 0 : : SgOmpClause(startOfConstruct)
89298 : {
89299 : #ifdef DEBUG
89300 : // printf ("In SgOmpWriteClause::SgOmpWriteClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
89301 : #endif
89302 : #if 0
89303 : // debugging information!
89304 : printf ("In SgOmpWriteClause::SgOmpWriteClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
89305 : #endif
89306 :
89307 :
89308 :
89309 : #if 0
89310 : // DQ (7/30/2014): Call a virtual function.
89311 : std::string s = this->class_name();
89312 : #endif
89313 :
89314 : // Test the variant virtual function
89315 : // assert(OmpWriteClauseTag == variant());
89316 0 : assert(OmpWriteClauseTag == this->variant());
89317 0 : ROSE_ASSERT(OmpWriteClauseTag == (int)(this->variantT()));
89318 0 : post_construction_initialization();
89319 :
89320 : // Test the isSgOmpWriteClause() function since it has been problematic
89321 0 : assert(isSgOmpWriteClause(this) != NULL);
89322 0 : }
89323 :
89324 : // Generated constructor (all data members)
89325 :
89326 : /* #line 89327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89327 :
89328 :
89329 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89330 :
89331 :
89332 : // ********************************************************
89333 : // member functions common across all array grammar objects
89334 : // ********************************************************
89335 :
89336 :
89337 :
89338 : /* #line 89339 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89339 :
89340 :
89341 :
89342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89343 :
89344 : // ********************************************************
89345 : // member functions specific to each node in the grammar
89346 : // ********************************************************
89347 :
89348 :
89349 : /* #line 89350 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89350 :
89351 : // Start of memberFunctionString
89352 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
89353 :
89354 : // *** COMMON CODE SECTION BEGINS HERE ***
89355 :
89356 : #if 0
89357 : int
89358 : SgOmpUpdateClause::getVariant() const
89359 : {
89360 : // This function is used in ROSE while "variant()" is used in SAGE
89361 : assert(this != NULL);
89362 : return variant();
89363 : }
89364 : #endif
89365 :
89366 : // This function is used in ROSE in treeTraversal code
89367 : // eventually replaces getVariant() and variant()
89368 : // though after variant() has been removed for a while we will
89369 : // want to change the name of variantT() back to variant()
89370 : // (since the "T" was ment to stand for temporary).
89371 : // When this happens the variantT() will be depricated.
89372 : VariantT
89373 52 : SgOmpUpdateClause::variantT() const
89374 : {
89375 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
89376 52 : ROSE_ASSERT(this != NULL);
89377 52 : return V_SgOmpUpdateClause;
89378 : }
89379 :
89380 : #if 0
89381 : int
89382 : SgOmpUpdateClause::variant() const
89383 : {
89384 : // This function is used in SAGE
89385 : ROSE_ASSERT(this != NULL);
89386 : return OmpUpdateClauseTag;
89387 : }
89388 : #endif
89389 :
89390 : ROSE_DLL_API const char*
89391 0 : SgOmpUpdateClause::sage_class_name() const
89392 : {
89393 0 : ROSE_ASSERT(this != NULL);
89394 0 : return "SgOmpUpdateClause";
89395 : }
89396 :
89397 : std::string
89398 1 : SgOmpUpdateClause::class_name() const
89399 : {
89400 1 : ROSE_ASSERT(this != NULL);
89401 1 : return "SgOmpUpdateClause";
89402 : }
89403 :
89404 : // DQ (11/26/2005): Support for visitor pattern mechanims
89405 : // (inferior to ROSE traversal mechanism, experimental).
89406 : void
89407 0 : SgOmpUpdateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
89408 : {
89409 0 : ROSE_ASSERT(this != NULL);
89410 0 : visitor.visit(this);
89411 0 : }
89412 :
89413 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
89414 0 : void SgOmpUpdateClause::accept (ROSE_VisitorPattern & visitor) {
89415 0 : ROSE_ASSERT(this != NULL);
89416 0 : visitor.visit(this);
89417 0 : }
89418 :
89419 : SgOmpUpdateClause*
89420 0 : SgOmpUpdateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
89421 : {
89422 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
89423 : // This function is currently only supported for the AST used the represent Binary executables.
89424 : if (0 /* isSgAsmNode(this) != NULL */)
89425 : {
89426 : // Support for regex specification.
89427 : std::string prefixCode = "REGEX:";
89428 : addNewAttribute(prefixCode + s,a);
89429 : }
89430 : #endif
89431 :
89432 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
89433 0 : return this;
89434 : }
89435 :
89436 : // *** COMMON CODE SECTION ENDS HERE ***
89437 :
89438 :
89439 : // End of memberFunctionString
89440 : // Start of memberFunctionString
89441 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
89442 :
89443 :
89444 : #if 0
89445 : //! Error checking support
89446 : /*! Verifies the following:
89447 : - working getVariant() member function
89448 : - calls base class's error() member function
89449 : Every class has one of these functions.
89450 : */
89451 : bool
89452 : SgOmpUpdateClause::error()
89453 : {
89454 : // Put error checking here
89455 :
89456 : ROSE_ASSERT (this != NULL);
89457 : if (getVariant() != OmpUpdateClauseTag)
89458 : {
89459 : printf ("Error in SgOmpUpdateClause::error(): SgOmpUpdateClause object has a %s variant \n",
89460 : Cxx_GrammarTerminalNames[getVariant()].name);
89461 : // printf ("Error in SgOmpUpdateClause::error() \n");
89462 : ROSE_ABORT();
89463 : }
89464 :
89465 : ROSE_ASSERT (getVariant() == OmpUpdateClauseTag);
89466 : return SgOmpClause::error();
89467 : }
89468 : #endif
89469 :
89470 :
89471 :
89472 : // End of memberFunctionString
89473 :
89474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
89475 :
89476 1 : SgOmpUpdateClause* isSgOmpUpdateClause ( SgNode* inputDerivedClassPointer )
89477 : {
89478 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
89479 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
89480 : // So to fix this we return NULL directly when the input is NULL and avoid the
89481 : // dynamic_cast in this case. This is likely a performance improvement as well.
89482 : // return dynamic_cast<SgOmpUpdateClause*>(inputDerivedClassPointer);
89483 : // Milind Chabbi (8/28/2013): isSgOmpUpdateClause uses table-driven castability instead of c++ default dynamic_cast
89484 : // this improves the running time performance by 10-20%.
89485 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUpdateClause*>(inputDerivedClassPointer);
89486 1 : return IS_SgOmpUpdateClause_FAST_MACRO(inputDerivedClassPointer);
89487 : }
89488 :
89489 : // DQ (11/8/2003): Added version of functions taking const pointer
89490 0 : const SgOmpUpdateClause* isSgOmpUpdateClause ( const SgNode* inputDerivedClassPointer )
89491 : {
89492 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
89493 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
89494 : // So to fix this we return NULL directly when the input is NULL and avoid the
89495 : // dynamic_cast in this case. This is likely a performance improvement as well.
89496 : // return dynamic_cast<const SgOmpUpdateClause*>(inputDerivedClassPointer);
89497 : // Milind Chabbi (8/28/2013): isSgOmpUpdateClause uses table-driven castability instead of c++ default dynamic_cast
89498 : // this improves the running time performance by 10-20%.
89499 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUpdateClause*>(inputDerivedClassPointer);
89500 0 : return IS_SgOmpUpdateClause_FAST_MACRO(inputDerivedClassPointer);
89501 : }
89502 :
89503 :
89504 :
89505 : /* #line 89506 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89506 :
89507 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89508 :
89509 : /**
89510 : \brief Generated destructor
89511 :
89512 : This destructor is automatically generated (by ROSETTA). This destructor
89513 : only frees memory of data members associated with the parts of the current IR node which
89514 : are NOT traversed. Those data members that are part of a traversal can be freed using
89515 : a traversal (calling this destructor on all children in a post-order traversal). Such
89516 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
89517 :
89518 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
89519 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
89520 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
89521 :
89522 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
89523 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
89524 : pointers are not yet implemented to call delete on eash pointer in the container.
89525 : (This could be done by derivation from the STL containers to define containers that
89526 : automatically deleted their members.)
89527 :
89528 : */
89529 0 : SgOmpUpdateClause::~SgOmpUpdateClause () {
89530 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
89531 :
89532 :
89533 :
89534 : }
89535 :
89536 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89537 0 : }
89538 :
89539 :
89540 : /* #line 89541 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89541 :
89542 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
89543 :
89544 : // Generated constructor
89545 0 : SgOmpUpdateClause::SgOmpUpdateClause ( Sg_File_Info* startOfConstruct )
89546 0 : : SgOmpClause(startOfConstruct)
89547 : {
89548 : #ifdef DEBUG
89549 : // printf ("In SgOmpUpdateClause::SgOmpUpdateClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
89550 : #endif
89551 : #if 0
89552 : // debugging information!
89553 : printf ("In SgOmpUpdateClause::SgOmpUpdateClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
89554 : #endif
89555 :
89556 :
89557 :
89558 : #if 0
89559 : // DQ (7/30/2014): Call a virtual function.
89560 : std::string s = this->class_name();
89561 : #endif
89562 :
89563 : // Test the variant virtual function
89564 : // assert(OmpUpdateClauseTag == variant());
89565 0 : assert(OmpUpdateClauseTag == this->variant());
89566 0 : ROSE_ASSERT(OmpUpdateClauseTag == (int)(this->variantT()));
89567 0 : post_construction_initialization();
89568 :
89569 : // Test the isSgOmpUpdateClause() function since it has been problematic
89570 0 : assert(isSgOmpUpdateClause(this) != NULL);
89571 0 : }
89572 :
89573 : // Generated constructor (all data members)
89574 :
89575 : /* #line 89576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89576 :
89577 :
89578 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89579 :
89580 :
89581 : // ********************************************************
89582 : // member functions common across all array grammar objects
89583 : // ********************************************************
89584 :
89585 :
89586 :
89587 : /* #line 89588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89588 :
89589 :
89590 :
89591 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89592 :
89593 : // ********************************************************
89594 : // member functions specific to each node in the grammar
89595 : // ********************************************************
89596 :
89597 :
89598 : /* #line 89599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89599 :
89600 : // Start of memberFunctionString
89601 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
89602 :
89603 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
89604 :
89605 : SgOmpClause::omp_depobj_modifier_enum
89606 1 : SgOmpDepobjUpdateClause::get_modifier () const
89607 : {
89608 1 : ROSE_ASSERT (this != NULL);
89609 :
89610 : #if 0
89611 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
89612 : // used to trigger marking transformations for the token-based unparsing.
89613 : printf ("SgOmpDepobjUpdateClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
89614 : #endif
89615 :
89616 1 : return p_modifier;
89617 : }
89618 :
89619 : void
89620 0 : SgOmpDepobjUpdateClause::set_modifier ( SgOmpClause::omp_depobj_modifier_enum modifier )
89621 : {
89622 0 : ROSE_ASSERT (this != NULL);
89623 :
89624 : #if 0
89625 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
89626 : // used to trigger marking transformations for the token-based unparsing.
89627 : printf ("SgOmpDepobjUpdateClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
89628 : #endif
89629 :
89630 0 : set_isModified(true);
89631 :
89632 0 : p_modifier = modifier;
89633 0 : }
89634 :
89635 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
89636 :
89637 :
89638 : // End of memberFunctionString
89639 : // Start of memberFunctionString
89640 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
89641 :
89642 : // *** COMMON CODE SECTION BEGINS HERE ***
89643 :
89644 : #if 0
89645 : int
89646 : SgOmpDepobjUpdateClause::getVariant() const
89647 : {
89648 : // This function is used in ROSE while "variant()" is used in SAGE
89649 : assert(this != NULL);
89650 : return variant();
89651 : }
89652 : #endif
89653 :
89654 : // This function is used in ROSE in treeTraversal code
89655 : // eventually replaces getVariant() and variant()
89656 : // though after variant() has been removed for a while we will
89657 : // want to change the name of variantT() back to variant()
89658 : // (since the "T" was ment to stand for temporary).
89659 : // When this happens the variantT() will be depricated.
89660 : VariantT
89661 54 : SgOmpDepobjUpdateClause::variantT() const
89662 : {
89663 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
89664 54 : ROSE_ASSERT(this != NULL);
89665 54 : return V_SgOmpDepobjUpdateClause;
89666 : }
89667 :
89668 : #if 0
89669 : int
89670 : SgOmpDepobjUpdateClause::variant() const
89671 : {
89672 : // This function is used in SAGE
89673 : ROSE_ASSERT(this != NULL);
89674 : return OmpDepobjUpdateClauseTag;
89675 : }
89676 : #endif
89677 :
89678 : ROSE_DLL_API const char*
89679 0 : SgOmpDepobjUpdateClause::sage_class_name() const
89680 : {
89681 0 : ROSE_ASSERT(this != NULL);
89682 0 : return "SgOmpDepobjUpdateClause";
89683 : }
89684 :
89685 : std::string
89686 1 : SgOmpDepobjUpdateClause::class_name() const
89687 : {
89688 1 : ROSE_ASSERT(this != NULL);
89689 1 : return "SgOmpDepobjUpdateClause";
89690 : }
89691 :
89692 : // DQ (11/26/2005): Support for visitor pattern mechanims
89693 : // (inferior to ROSE traversal mechanism, experimental).
89694 : void
89695 0 : SgOmpDepobjUpdateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
89696 : {
89697 0 : ROSE_ASSERT(this != NULL);
89698 0 : visitor.visit(this);
89699 0 : }
89700 :
89701 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
89702 0 : void SgOmpDepobjUpdateClause::accept (ROSE_VisitorPattern & visitor) {
89703 0 : ROSE_ASSERT(this != NULL);
89704 0 : visitor.visit(this);
89705 0 : }
89706 :
89707 : SgOmpDepobjUpdateClause*
89708 0 : SgOmpDepobjUpdateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
89709 : {
89710 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
89711 : // This function is currently only supported for the AST used the represent Binary executables.
89712 : if (0 /* isSgAsmNode(this) != NULL */)
89713 : {
89714 : // Support for regex specification.
89715 : std::string prefixCode = "REGEX:";
89716 : addNewAttribute(prefixCode + s,a);
89717 : }
89718 : #endif
89719 :
89720 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
89721 0 : return this;
89722 : }
89723 :
89724 : // *** COMMON CODE SECTION ENDS HERE ***
89725 :
89726 :
89727 : // End of memberFunctionString
89728 : // Start of memberFunctionString
89729 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
89730 :
89731 :
89732 : #if 0
89733 : //! Error checking support
89734 : /*! Verifies the following:
89735 : - working getVariant() member function
89736 : - calls base class's error() member function
89737 : Every class has one of these functions.
89738 : */
89739 : bool
89740 : SgOmpDepobjUpdateClause::error()
89741 : {
89742 : // Put error checking here
89743 :
89744 : ROSE_ASSERT (this != NULL);
89745 : if (getVariant() != OmpDepobjUpdateClauseTag)
89746 : {
89747 : printf ("Error in SgOmpDepobjUpdateClause::error(): SgOmpDepobjUpdateClause object has a %s variant \n",
89748 : Cxx_GrammarTerminalNames[getVariant()].name);
89749 : // printf ("Error in SgOmpDepobjUpdateClause::error() \n");
89750 : ROSE_ABORT();
89751 : }
89752 :
89753 : ROSE_ASSERT (getVariant() == OmpDepobjUpdateClauseTag);
89754 : return SgOmpClause::error();
89755 : }
89756 : #endif
89757 :
89758 :
89759 :
89760 : // End of memberFunctionString
89761 :
89762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
89763 :
89764 3 : SgOmpDepobjUpdateClause* isSgOmpDepobjUpdateClause ( SgNode* inputDerivedClassPointer )
89765 : {
89766 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
89767 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
89768 : // So to fix this we return NULL directly when the input is NULL and avoid the
89769 : // dynamic_cast in this case. This is likely a performance improvement as well.
89770 : // return dynamic_cast<SgOmpDepobjUpdateClause*>(inputDerivedClassPointer);
89771 : // Milind Chabbi (8/28/2013): isSgOmpDepobjUpdateClause uses table-driven castability instead of c++ default dynamic_cast
89772 : // this improves the running time performance by 10-20%.
89773 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDepobjUpdateClause*>(inputDerivedClassPointer);
89774 3 : return IS_SgOmpDepobjUpdateClause_FAST_MACRO(inputDerivedClassPointer);
89775 : }
89776 :
89777 : // DQ (11/8/2003): Added version of functions taking const pointer
89778 0 : const SgOmpDepobjUpdateClause* isSgOmpDepobjUpdateClause ( const SgNode* inputDerivedClassPointer )
89779 : {
89780 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
89781 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
89782 : // So to fix this we return NULL directly when the input is NULL and avoid the
89783 : // dynamic_cast in this case. This is likely a performance improvement as well.
89784 : // return dynamic_cast<const SgOmpDepobjUpdateClause*>(inputDerivedClassPointer);
89785 : // Milind Chabbi (8/28/2013): isSgOmpDepobjUpdateClause uses table-driven castability instead of c++ default dynamic_cast
89786 : // this improves the running time performance by 10-20%.
89787 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDepobjUpdateClause*>(inputDerivedClassPointer);
89788 0 : return IS_SgOmpDepobjUpdateClause_FAST_MACRO(inputDerivedClassPointer);
89789 : }
89790 :
89791 :
89792 :
89793 : /* #line 89794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89794 :
89795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89796 :
89797 : /**
89798 : \brief Generated destructor
89799 :
89800 : This destructor is automatically generated (by ROSETTA). This destructor
89801 : only frees memory of data members associated with the parts of the current IR node which
89802 : are NOT traversed. Those data members that are part of a traversal can be freed using
89803 : a traversal (calling this destructor on all children in a post-order traversal). Such
89804 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
89805 :
89806 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
89807 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
89808 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
89809 :
89810 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
89811 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
89812 : pointers are not yet implemented to call delete on eash pointer in the container.
89813 : (This could be done by derivation from the STL containers to define containers that
89814 : automatically deleted their members.)
89815 :
89816 : */
89817 0 : SgOmpDepobjUpdateClause::~SgOmpDepobjUpdateClause () {
89818 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
89819 :
89820 :
89821 : // case: not a listType for modifier
89822 0 : p_modifier =e_omp_depobj_modifier_unknown; // non list case
89823 :
89824 : }
89825 :
89826 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
89827 0 : }
89828 :
89829 :
89830 : /* #line 89831 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89831 :
89832 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
89833 :
89834 : // Generated constructor
89835 0 : SgOmpDepobjUpdateClause::SgOmpDepobjUpdateClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_depobj_modifier_enum modifier )
89836 0 : : SgOmpClause(startOfConstruct)
89837 : {
89838 : #ifdef DEBUG
89839 : // printf ("In SgOmpDepobjUpdateClause::SgOmpDepobjUpdateClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_depobj_modifier_enum modifier) sage_class_name() = %s \n",sage_class_name());
89840 : #endif
89841 : #if 0
89842 : // debugging information!
89843 : printf ("In SgOmpDepobjUpdateClause::SgOmpDepobjUpdateClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_depobj_modifier_enum modifier): this = %p = %s \n",this,this->class_name().c_str());
89844 : #endif
89845 :
89846 0 : p_modifier = modifier;
89847 :
89848 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
89849 :
89850 : #if 0
89851 : // DQ (7/30/2014): Call a virtual function.
89852 : std::string s = this->class_name();
89853 : #endif
89854 :
89855 : // Test the variant virtual function
89856 : // assert(OmpDepobjUpdateClauseTag == variant());
89857 0 : assert(OmpDepobjUpdateClauseTag == this->variant());
89858 0 : ROSE_ASSERT(OmpDepobjUpdateClauseTag == (int)(this->variantT()));
89859 0 : post_construction_initialization();
89860 :
89861 : // Test the isSgOmpDepobjUpdateClause() function since it has been problematic
89862 0 : assert(isSgOmpDepobjUpdateClause(this) != NULL);
89863 0 : }
89864 :
89865 : // Generated constructor (all data members)
89866 :
89867 : /* #line 89868 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89868 :
89869 :
89870 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89871 :
89872 :
89873 : // ********************************************************
89874 : // member functions common across all array grammar objects
89875 : // ********************************************************
89876 :
89877 :
89878 :
89879 : /* #line 89880 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89880 :
89881 :
89882 :
89883 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
89884 :
89885 : // ********************************************************
89886 : // member functions specific to each node in the grammar
89887 : // ********************************************************
89888 :
89889 :
89890 : /* #line 89891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
89891 :
89892 : // Start of memberFunctionString
89893 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
89894 :
89895 : // *** COMMON CODE SECTION BEGINS HERE ***
89896 :
89897 : #if 0
89898 : int
89899 : SgOmpDestroyClause::getVariant() const
89900 : {
89901 : // This function is used in ROSE while "variant()" is used in SAGE
89902 : assert(this != NULL);
89903 : return variant();
89904 : }
89905 : #endif
89906 :
89907 : // This function is used in ROSE in treeTraversal code
89908 : // eventually replaces getVariant() and variant()
89909 : // though after variant() has been removed for a while we will
89910 : // want to change the name of variantT() back to variant()
89911 : // (since the "T" was ment to stand for temporary).
89912 : // When this happens the variantT() will be depricated.
89913 : VariantT
89914 52 : SgOmpDestroyClause::variantT() const
89915 : {
89916 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
89917 52 : ROSE_ASSERT(this != NULL);
89918 52 : return V_SgOmpDestroyClause;
89919 : }
89920 :
89921 : #if 0
89922 : int
89923 : SgOmpDestroyClause::variant() const
89924 : {
89925 : // This function is used in SAGE
89926 : ROSE_ASSERT(this != NULL);
89927 : return OmpDestroyClauseTag;
89928 : }
89929 : #endif
89930 :
89931 : ROSE_DLL_API const char*
89932 0 : SgOmpDestroyClause::sage_class_name() const
89933 : {
89934 0 : ROSE_ASSERT(this != NULL);
89935 0 : return "SgOmpDestroyClause";
89936 : }
89937 :
89938 : std::string
89939 1 : SgOmpDestroyClause::class_name() const
89940 : {
89941 1 : ROSE_ASSERT(this != NULL);
89942 1 : return "SgOmpDestroyClause";
89943 : }
89944 :
89945 : // DQ (11/26/2005): Support for visitor pattern mechanims
89946 : // (inferior to ROSE traversal mechanism, experimental).
89947 : void
89948 0 : SgOmpDestroyClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
89949 : {
89950 0 : ROSE_ASSERT(this != NULL);
89951 0 : visitor.visit(this);
89952 0 : }
89953 :
89954 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
89955 0 : void SgOmpDestroyClause::accept (ROSE_VisitorPattern & visitor) {
89956 0 : ROSE_ASSERT(this != NULL);
89957 0 : visitor.visit(this);
89958 0 : }
89959 :
89960 : SgOmpDestroyClause*
89961 0 : SgOmpDestroyClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
89962 : {
89963 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
89964 : // This function is currently only supported for the AST used the represent Binary executables.
89965 : if (0 /* isSgAsmNode(this) != NULL */)
89966 : {
89967 : // Support for regex specification.
89968 : std::string prefixCode = "REGEX:";
89969 : addNewAttribute(prefixCode + s,a);
89970 : }
89971 : #endif
89972 :
89973 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
89974 0 : return this;
89975 : }
89976 :
89977 : // *** COMMON CODE SECTION ENDS HERE ***
89978 :
89979 :
89980 : // End of memberFunctionString
89981 : // Start of memberFunctionString
89982 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
89983 :
89984 :
89985 : #if 0
89986 : //! Error checking support
89987 : /*! Verifies the following:
89988 : - working getVariant() member function
89989 : - calls base class's error() member function
89990 : Every class has one of these functions.
89991 : */
89992 : bool
89993 : SgOmpDestroyClause::error()
89994 : {
89995 : // Put error checking here
89996 :
89997 : ROSE_ASSERT (this != NULL);
89998 : if (getVariant() != OmpDestroyClauseTag)
89999 : {
90000 : printf ("Error in SgOmpDestroyClause::error(): SgOmpDestroyClause object has a %s variant \n",
90001 : Cxx_GrammarTerminalNames[getVariant()].name);
90002 : // printf ("Error in SgOmpDestroyClause::error() \n");
90003 : ROSE_ABORT();
90004 : }
90005 :
90006 : ROSE_ASSERT (getVariant() == OmpDestroyClauseTag);
90007 : return SgOmpClause::error();
90008 : }
90009 : #endif
90010 :
90011 :
90012 :
90013 : // End of memberFunctionString
90014 :
90015 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
90016 :
90017 1 : SgOmpDestroyClause* isSgOmpDestroyClause ( SgNode* inputDerivedClassPointer )
90018 : {
90019 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90020 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90021 : // So to fix this we return NULL directly when the input is NULL and avoid the
90022 : // dynamic_cast in this case. This is likely a performance improvement as well.
90023 : // return dynamic_cast<SgOmpDestroyClause*>(inputDerivedClassPointer);
90024 : // Milind Chabbi (8/28/2013): isSgOmpDestroyClause uses table-driven castability instead of c++ default dynamic_cast
90025 : // this improves the running time performance by 10-20%.
90026 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDestroyClause*>(inputDerivedClassPointer);
90027 1 : return IS_SgOmpDestroyClause_FAST_MACRO(inputDerivedClassPointer);
90028 : }
90029 :
90030 : // DQ (11/8/2003): Added version of functions taking const pointer
90031 0 : const SgOmpDestroyClause* isSgOmpDestroyClause ( const SgNode* inputDerivedClassPointer )
90032 : {
90033 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90034 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90035 : // So to fix this we return NULL directly when the input is NULL and avoid the
90036 : // dynamic_cast in this case. This is likely a performance improvement as well.
90037 : // return dynamic_cast<const SgOmpDestroyClause*>(inputDerivedClassPointer);
90038 : // Milind Chabbi (8/28/2013): isSgOmpDestroyClause uses table-driven castability instead of c++ default dynamic_cast
90039 : // this improves the running time performance by 10-20%.
90040 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDestroyClause*>(inputDerivedClassPointer);
90041 0 : return IS_SgOmpDestroyClause_FAST_MACRO(inputDerivedClassPointer);
90042 : }
90043 :
90044 :
90045 :
90046 : /* #line 90047 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90047 :
90048 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90049 :
90050 : /**
90051 : \brief Generated destructor
90052 :
90053 : This destructor is automatically generated (by ROSETTA). This destructor
90054 : only frees memory of data members associated with the parts of the current IR node which
90055 : are NOT traversed. Those data members that are part of a traversal can be freed using
90056 : a traversal (calling this destructor on all children in a post-order traversal). Such
90057 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
90058 :
90059 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
90060 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
90061 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
90062 :
90063 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
90064 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
90065 : pointers are not yet implemented to call delete on eash pointer in the container.
90066 : (This could be done by derivation from the STL containers to define containers that
90067 : automatically deleted their members.)
90068 :
90069 : */
90070 0 : SgOmpDestroyClause::~SgOmpDestroyClause () {
90071 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
90072 :
90073 :
90074 :
90075 : }
90076 :
90077 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90078 0 : }
90079 :
90080 :
90081 : /* #line 90082 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90082 :
90083 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
90084 :
90085 : // Generated constructor
90086 0 : SgOmpDestroyClause::SgOmpDestroyClause ( Sg_File_Info* startOfConstruct )
90087 0 : : SgOmpClause(startOfConstruct)
90088 : {
90089 : #ifdef DEBUG
90090 : // printf ("In SgOmpDestroyClause::SgOmpDestroyClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
90091 : #endif
90092 : #if 0
90093 : // debugging information!
90094 : printf ("In SgOmpDestroyClause::SgOmpDestroyClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
90095 : #endif
90096 :
90097 :
90098 :
90099 : #if 0
90100 : // DQ (7/30/2014): Call a virtual function.
90101 : std::string s = this->class_name();
90102 : #endif
90103 :
90104 : // Test the variant virtual function
90105 : // assert(OmpDestroyClauseTag == variant());
90106 0 : assert(OmpDestroyClauseTag == this->variant());
90107 0 : ROSE_ASSERT(OmpDestroyClauseTag == (int)(this->variantT()));
90108 0 : post_construction_initialization();
90109 :
90110 : // Test the isSgOmpDestroyClause() function since it has been problematic
90111 0 : assert(isSgOmpDestroyClause(this) != NULL);
90112 0 : }
90113 :
90114 : // Generated constructor (all data members)
90115 :
90116 : /* #line 90117 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90117 :
90118 :
90119 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90120 :
90121 :
90122 : // ********************************************************
90123 : // member functions common across all array grammar objects
90124 : // ********************************************************
90125 :
90126 :
90127 :
90128 : /* #line 90129 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90129 :
90130 :
90131 :
90132 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90133 :
90134 : // ********************************************************
90135 : // member functions specific to each node in the grammar
90136 : // ********************************************************
90137 :
90138 :
90139 : /* #line 90140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90140 :
90141 : // Start of memberFunctionString
90142 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
90143 :
90144 : // *** COMMON CODE SECTION BEGINS HERE ***
90145 :
90146 : #if 0
90147 : int
90148 : SgOmpCaptureClause::getVariant() const
90149 : {
90150 : // This function is used in ROSE while "variant()" is used in SAGE
90151 : assert(this != NULL);
90152 : return variant();
90153 : }
90154 : #endif
90155 :
90156 : // This function is used in ROSE in treeTraversal code
90157 : // eventually replaces getVariant() and variant()
90158 : // though after variant() has been removed for a while we will
90159 : // want to change the name of variantT() back to variant()
90160 : // (since the "T" was ment to stand for temporary).
90161 : // When this happens the variantT() will be depricated.
90162 : VariantT
90163 52 : SgOmpCaptureClause::variantT() const
90164 : {
90165 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
90166 52 : ROSE_ASSERT(this != NULL);
90167 52 : return V_SgOmpCaptureClause;
90168 : }
90169 :
90170 : #if 0
90171 : int
90172 : SgOmpCaptureClause::variant() const
90173 : {
90174 : // This function is used in SAGE
90175 : ROSE_ASSERT(this != NULL);
90176 : return OmpCaptureClauseTag;
90177 : }
90178 : #endif
90179 :
90180 : ROSE_DLL_API const char*
90181 0 : SgOmpCaptureClause::sage_class_name() const
90182 : {
90183 0 : ROSE_ASSERT(this != NULL);
90184 0 : return "SgOmpCaptureClause";
90185 : }
90186 :
90187 : std::string
90188 1 : SgOmpCaptureClause::class_name() const
90189 : {
90190 1 : ROSE_ASSERT(this != NULL);
90191 1 : return "SgOmpCaptureClause";
90192 : }
90193 :
90194 : // DQ (11/26/2005): Support for visitor pattern mechanims
90195 : // (inferior to ROSE traversal mechanism, experimental).
90196 : void
90197 0 : SgOmpCaptureClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
90198 : {
90199 0 : ROSE_ASSERT(this != NULL);
90200 0 : visitor.visit(this);
90201 0 : }
90202 :
90203 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
90204 0 : void SgOmpCaptureClause::accept (ROSE_VisitorPattern & visitor) {
90205 0 : ROSE_ASSERT(this != NULL);
90206 0 : visitor.visit(this);
90207 0 : }
90208 :
90209 : SgOmpCaptureClause*
90210 0 : SgOmpCaptureClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
90211 : {
90212 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
90213 : // This function is currently only supported for the AST used the represent Binary executables.
90214 : if (0 /* isSgAsmNode(this) != NULL */)
90215 : {
90216 : // Support for regex specification.
90217 : std::string prefixCode = "REGEX:";
90218 : addNewAttribute(prefixCode + s,a);
90219 : }
90220 : #endif
90221 :
90222 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
90223 0 : return this;
90224 : }
90225 :
90226 : // *** COMMON CODE SECTION ENDS HERE ***
90227 :
90228 :
90229 : // End of memberFunctionString
90230 : // Start of memberFunctionString
90231 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
90232 :
90233 :
90234 : #if 0
90235 : //! Error checking support
90236 : /*! Verifies the following:
90237 : - working getVariant() member function
90238 : - calls base class's error() member function
90239 : Every class has one of these functions.
90240 : */
90241 : bool
90242 : SgOmpCaptureClause::error()
90243 : {
90244 : // Put error checking here
90245 :
90246 : ROSE_ASSERT (this != NULL);
90247 : if (getVariant() != OmpCaptureClauseTag)
90248 : {
90249 : printf ("Error in SgOmpCaptureClause::error(): SgOmpCaptureClause object has a %s variant \n",
90250 : Cxx_GrammarTerminalNames[getVariant()].name);
90251 : // printf ("Error in SgOmpCaptureClause::error() \n");
90252 : ROSE_ABORT();
90253 : }
90254 :
90255 : ROSE_ASSERT (getVariant() == OmpCaptureClauseTag);
90256 : return SgOmpClause::error();
90257 : }
90258 : #endif
90259 :
90260 :
90261 :
90262 : // End of memberFunctionString
90263 :
90264 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
90265 :
90266 1 : SgOmpCaptureClause* isSgOmpCaptureClause ( SgNode* inputDerivedClassPointer )
90267 : {
90268 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90269 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90270 : // So to fix this we return NULL directly when the input is NULL and avoid the
90271 : // dynamic_cast in this case. This is likely a performance improvement as well.
90272 : // return dynamic_cast<SgOmpCaptureClause*>(inputDerivedClassPointer);
90273 : // Milind Chabbi (8/28/2013): isSgOmpCaptureClause uses table-driven castability instead of c++ default dynamic_cast
90274 : // this improves the running time performance by 10-20%.
90275 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCaptureClause*>(inputDerivedClassPointer);
90276 1 : return IS_SgOmpCaptureClause_FAST_MACRO(inputDerivedClassPointer);
90277 : }
90278 :
90279 : // DQ (11/8/2003): Added version of functions taking const pointer
90280 0 : const SgOmpCaptureClause* isSgOmpCaptureClause ( const SgNode* inputDerivedClassPointer )
90281 : {
90282 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90283 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90284 : // So to fix this we return NULL directly when the input is NULL and avoid the
90285 : // dynamic_cast in this case. This is likely a performance improvement as well.
90286 : // return dynamic_cast<const SgOmpCaptureClause*>(inputDerivedClassPointer);
90287 : // Milind Chabbi (8/28/2013): isSgOmpCaptureClause uses table-driven castability instead of c++ default dynamic_cast
90288 : // this improves the running time performance by 10-20%.
90289 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCaptureClause*>(inputDerivedClassPointer);
90290 0 : return IS_SgOmpCaptureClause_FAST_MACRO(inputDerivedClassPointer);
90291 : }
90292 :
90293 :
90294 :
90295 : /* #line 90296 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90296 :
90297 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90298 :
90299 : /**
90300 : \brief Generated destructor
90301 :
90302 : This destructor is automatically generated (by ROSETTA). This destructor
90303 : only frees memory of data members associated with the parts of the current IR node which
90304 : are NOT traversed. Those data members that are part of a traversal can be freed using
90305 : a traversal (calling this destructor on all children in a post-order traversal). Such
90306 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
90307 :
90308 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
90309 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
90310 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
90311 :
90312 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
90313 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
90314 : pointers are not yet implemented to call delete on eash pointer in the container.
90315 : (This could be done by derivation from the STL containers to define containers that
90316 : automatically deleted their members.)
90317 :
90318 : */
90319 0 : SgOmpCaptureClause::~SgOmpCaptureClause () {
90320 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
90321 :
90322 :
90323 :
90324 : }
90325 :
90326 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90327 0 : }
90328 :
90329 :
90330 : /* #line 90331 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90331 :
90332 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
90333 :
90334 : // Generated constructor
90335 0 : SgOmpCaptureClause::SgOmpCaptureClause ( Sg_File_Info* startOfConstruct )
90336 0 : : SgOmpClause(startOfConstruct)
90337 : {
90338 : #ifdef DEBUG
90339 : // printf ("In SgOmpCaptureClause::SgOmpCaptureClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
90340 : #endif
90341 : #if 0
90342 : // debugging information!
90343 : printf ("In SgOmpCaptureClause::SgOmpCaptureClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
90344 : #endif
90345 :
90346 :
90347 :
90348 : #if 0
90349 : // DQ (7/30/2014): Call a virtual function.
90350 : std::string s = this->class_name();
90351 : #endif
90352 :
90353 : // Test the variant virtual function
90354 : // assert(OmpCaptureClauseTag == variant());
90355 0 : assert(OmpCaptureClauseTag == this->variant());
90356 0 : ROSE_ASSERT(OmpCaptureClauseTag == (int)(this->variantT()));
90357 0 : post_construction_initialization();
90358 :
90359 : // Test the isSgOmpCaptureClause() function since it has been problematic
90360 0 : assert(isSgOmpCaptureClause(this) != NULL);
90361 0 : }
90362 :
90363 : // Generated constructor (all data members)
90364 :
90365 : /* #line 90366 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90366 :
90367 :
90368 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90369 :
90370 :
90371 : // ********************************************************
90372 : // member functions common across all array grammar objects
90373 : // ********************************************************
90374 :
90375 :
90376 :
90377 : /* #line 90378 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90378 :
90379 :
90380 :
90381 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90382 :
90383 : // ********************************************************
90384 : // member functions specific to each node in the grammar
90385 : // ********************************************************
90386 :
90387 :
90388 : /* #line 90389 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90389 :
90390 : // Start of memberFunctionString
90391 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
90392 :
90393 : // *** COMMON CODE SECTION BEGINS HERE ***
90394 :
90395 : #if 0
90396 : int
90397 : SgOmpBeginClause::getVariant() const
90398 : {
90399 : // This function is used in ROSE while "variant()" is used in SAGE
90400 : assert(this != NULL);
90401 : return variant();
90402 : }
90403 : #endif
90404 :
90405 : // This function is used in ROSE in treeTraversal code
90406 : // eventually replaces getVariant() and variant()
90407 : // though after variant() has been removed for a while we will
90408 : // want to change the name of variantT() back to variant()
90409 : // (since the "T" was ment to stand for temporary).
90410 : // When this happens the variantT() will be depricated.
90411 : VariantT
90412 0 : SgOmpBeginClause::variantT() const
90413 : {
90414 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
90415 0 : ROSE_ASSERT(this != NULL);
90416 0 : return V_SgOmpBeginClause;
90417 : }
90418 :
90419 : #if 0
90420 : int
90421 : SgOmpBeginClause::variant() const
90422 : {
90423 : // This function is used in SAGE
90424 : ROSE_ASSERT(this != NULL);
90425 : return OmpBeginClauseTag;
90426 : }
90427 : #endif
90428 :
90429 : ROSE_DLL_API const char*
90430 0 : SgOmpBeginClause::sage_class_name() const
90431 : {
90432 0 : ROSE_ASSERT(this != NULL);
90433 0 : return "SgOmpBeginClause";
90434 : }
90435 :
90436 : std::string
90437 0 : SgOmpBeginClause::class_name() const
90438 : {
90439 0 : ROSE_ASSERT(this != NULL);
90440 0 : return "SgOmpBeginClause";
90441 : }
90442 :
90443 : // DQ (11/26/2005): Support for visitor pattern mechanims
90444 : // (inferior to ROSE traversal mechanism, experimental).
90445 : void
90446 0 : SgOmpBeginClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
90447 : {
90448 0 : ROSE_ASSERT(this != NULL);
90449 0 : visitor.visit(this);
90450 0 : }
90451 :
90452 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
90453 0 : void SgOmpBeginClause::accept (ROSE_VisitorPattern & visitor) {
90454 0 : ROSE_ASSERT(this != NULL);
90455 0 : visitor.visit(this);
90456 0 : }
90457 :
90458 : SgOmpBeginClause*
90459 0 : SgOmpBeginClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
90460 : {
90461 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
90462 : // This function is currently only supported for the AST used the represent Binary executables.
90463 : if (0 /* isSgAsmNode(this) != NULL */)
90464 : {
90465 : // Support for regex specification.
90466 : std::string prefixCode = "REGEX:";
90467 : addNewAttribute(prefixCode + s,a);
90468 : }
90469 : #endif
90470 :
90471 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
90472 0 : return this;
90473 : }
90474 :
90475 : // *** COMMON CODE SECTION ENDS HERE ***
90476 :
90477 :
90478 : // End of memberFunctionString
90479 : // Start of memberFunctionString
90480 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
90481 :
90482 :
90483 : #if 0
90484 : //! Error checking support
90485 : /*! Verifies the following:
90486 : - working getVariant() member function
90487 : - calls base class's error() member function
90488 : Every class has one of these functions.
90489 : */
90490 : bool
90491 : SgOmpBeginClause::error()
90492 : {
90493 : // Put error checking here
90494 :
90495 : ROSE_ASSERT (this != NULL);
90496 : if (getVariant() != OmpBeginClauseTag)
90497 : {
90498 : printf ("Error in SgOmpBeginClause::error(): SgOmpBeginClause object has a %s variant \n",
90499 : Cxx_GrammarTerminalNames[getVariant()].name);
90500 : // printf ("Error in SgOmpBeginClause::error() \n");
90501 : ROSE_ABORT();
90502 : }
90503 :
90504 : ROSE_ASSERT (getVariant() == OmpBeginClauseTag);
90505 : return SgOmpClause::error();
90506 : }
90507 : #endif
90508 :
90509 :
90510 :
90511 : // End of memberFunctionString
90512 :
90513 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
90514 :
90515 0 : SgOmpBeginClause* isSgOmpBeginClause ( SgNode* inputDerivedClassPointer )
90516 : {
90517 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90518 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90519 : // So to fix this we return NULL directly when the input is NULL and avoid the
90520 : // dynamic_cast in this case. This is likely a performance improvement as well.
90521 : // return dynamic_cast<SgOmpBeginClause*>(inputDerivedClassPointer);
90522 : // Milind Chabbi (8/28/2013): isSgOmpBeginClause uses table-driven castability instead of c++ default dynamic_cast
90523 : // this improves the running time performance by 10-20%.
90524 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpBeginClause*>(inputDerivedClassPointer);
90525 0 : return IS_SgOmpBeginClause_FAST_MACRO(inputDerivedClassPointer);
90526 : }
90527 :
90528 : // DQ (11/8/2003): Added version of functions taking const pointer
90529 0 : const SgOmpBeginClause* isSgOmpBeginClause ( const SgNode* inputDerivedClassPointer )
90530 : {
90531 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90532 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90533 : // So to fix this we return NULL directly when the input is NULL and avoid the
90534 : // dynamic_cast in this case. This is likely a performance improvement as well.
90535 : // return dynamic_cast<const SgOmpBeginClause*>(inputDerivedClassPointer);
90536 : // Milind Chabbi (8/28/2013): isSgOmpBeginClause uses table-driven castability instead of c++ default dynamic_cast
90537 : // this improves the running time performance by 10-20%.
90538 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpBeginClause*>(inputDerivedClassPointer);
90539 0 : return IS_SgOmpBeginClause_FAST_MACRO(inputDerivedClassPointer);
90540 : }
90541 :
90542 :
90543 :
90544 : /* #line 90545 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90545 :
90546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90547 :
90548 : /**
90549 : \brief Generated destructor
90550 :
90551 : This destructor is automatically generated (by ROSETTA). This destructor
90552 : only frees memory of data members associated with the parts of the current IR node which
90553 : are NOT traversed. Those data members that are part of a traversal can be freed using
90554 : a traversal (calling this destructor on all children in a post-order traversal). Such
90555 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
90556 :
90557 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
90558 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
90559 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
90560 :
90561 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
90562 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
90563 : pointers are not yet implemented to call delete on eash pointer in the container.
90564 : (This could be done by derivation from the STL containers to define containers that
90565 : automatically deleted their members.)
90566 :
90567 : */
90568 0 : SgOmpBeginClause::~SgOmpBeginClause () {
90569 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
90570 :
90571 :
90572 :
90573 : }
90574 :
90575 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90576 0 : }
90577 :
90578 :
90579 : /* #line 90580 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90580 :
90581 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
90582 :
90583 : // Generated constructor
90584 0 : SgOmpBeginClause::SgOmpBeginClause ( Sg_File_Info* startOfConstruct )
90585 0 : : SgOmpClause(startOfConstruct)
90586 : {
90587 : #ifdef DEBUG
90588 : // printf ("In SgOmpBeginClause::SgOmpBeginClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
90589 : #endif
90590 : #if 0
90591 : // debugging information!
90592 : printf ("In SgOmpBeginClause::SgOmpBeginClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
90593 : #endif
90594 :
90595 :
90596 :
90597 : #if 0
90598 : // DQ (7/30/2014): Call a virtual function.
90599 : std::string s = this->class_name();
90600 : #endif
90601 :
90602 : // Test the variant virtual function
90603 : // assert(OmpBeginClauseTag == variant());
90604 0 : assert(OmpBeginClauseTag == this->variant());
90605 0 : ROSE_ASSERT(OmpBeginClauseTag == (int)(this->variantT()));
90606 0 : post_construction_initialization();
90607 :
90608 : // Test the isSgOmpBeginClause() function since it has been problematic
90609 0 : assert(isSgOmpBeginClause(this) != NULL);
90610 0 : }
90611 :
90612 : // Generated constructor (all data members)
90613 :
90614 : /* #line 90615 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90615 :
90616 :
90617 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90618 :
90619 :
90620 : // ********************************************************
90621 : // member functions common across all array grammar objects
90622 : // ********************************************************
90623 :
90624 :
90625 :
90626 : /* #line 90627 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90627 :
90628 :
90629 :
90630 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90631 :
90632 : // ********************************************************
90633 : // member functions specific to each node in the grammar
90634 : // ********************************************************
90635 :
90636 :
90637 : /* #line 90638 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90638 :
90639 : // Start of memberFunctionString
90640 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
90641 :
90642 : // *** COMMON CODE SECTION BEGINS HERE ***
90643 :
90644 : #if 0
90645 : int
90646 : SgOmpEndClause::getVariant() const
90647 : {
90648 : // This function is used in ROSE while "variant()" is used in SAGE
90649 : assert(this != NULL);
90650 : return variant();
90651 : }
90652 : #endif
90653 :
90654 : // This function is used in ROSE in treeTraversal code
90655 : // eventually replaces getVariant() and variant()
90656 : // though after variant() has been removed for a while we will
90657 : // want to change the name of variantT() back to variant()
90658 : // (since the "T" was ment to stand for temporary).
90659 : // When this happens the variantT() will be depricated.
90660 : VariantT
90661 0 : SgOmpEndClause::variantT() const
90662 : {
90663 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
90664 0 : ROSE_ASSERT(this != NULL);
90665 0 : return V_SgOmpEndClause;
90666 : }
90667 :
90668 : #if 0
90669 : int
90670 : SgOmpEndClause::variant() const
90671 : {
90672 : // This function is used in SAGE
90673 : ROSE_ASSERT(this != NULL);
90674 : return OmpEndClauseTag;
90675 : }
90676 : #endif
90677 :
90678 : ROSE_DLL_API const char*
90679 0 : SgOmpEndClause::sage_class_name() const
90680 : {
90681 0 : ROSE_ASSERT(this != NULL);
90682 0 : return "SgOmpEndClause";
90683 : }
90684 :
90685 : std::string
90686 0 : SgOmpEndClause::class_name() const
90687 : {
90688 0 : ROSE_ASSERT(this != NULL);
90689 0 : return "SgOmpEndClause";
90690 : }
90691 :
90692 : // DQ (11/26/2005): Support for visitor pattern mechanims
90693 : // (inferior to ROSE traversal mechanism, experimental).
90694 : void
90695 0 : SgOmpEndClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
90696 : {
90697 0 : ROSE_ASSERT(this != NULL);
90698 0 : visitor.visit(this);
90699 0 : }
90700 :
90701 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
90702 0 : void SgOmpEndClause::accept (ROSE_VisitorPattern & visitor) {
90703 0 : ROSE_ASSERT(this != NULL);
90704 0 : visitor.visit(this);
90705 0 : }
90706 :
90707 : SgOmpEndClause*
90708 0 : SgOmpEndClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
90709 : {
90710 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
90711 : // This function is currently only supported for the AST used the represent Binary executables.
90712 : if (0 /* isSgAsmNode(this) != NULL */)
90713 : {
90714 : // Support for regex specification.
90715 : std::string prefixCode = "REGEX:";
90716 : addNewAttribute(prefixCode + s,a);
90717 : }
90718 : #endif
90719 :
90720 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
90721 0 : return this;
90722 : }
90723 :
90724 : // *** COMMON CODE SECTION ENDS HERE ***
90725 :
90726 :
90727 : // End of memberFunctionString
90728 : // Start of memberFunctionString
90729 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
90730 :
90731 :
90732 : #if 0
90733 : //! Error checking support
90734 : /*! Verifies the following:
90735 : - working getVariant() member function
90736 : - calls base class's error() member function
90737 : Every class has one of these functions.
90738 : */
90739 : bool
90740 : SgOmpEndClause::error()
90741 : {
90742 : // Put error checking here
90743 :
90744 : ROSE_ASSERT (this != NULL);
90745 : if (getVariant() != OmpEndClauseTag)
90746 : {
90747 : printf ("Error in SgOmpEndClause::error(): SgOmpEndClause object has a %s variant \n",
90748 : Cxx_GrammarTerminalNames[getVariant()].name);
90749 : // printf ("Error in SgOmpEndClause::error() \n");
90750 : ROSE_ABORT();
90751 : }
90752 :
90753 : ROSE_ASSERT (getVariant() == OmpEndClauseTag);
90754 : return SgOmpClause::error();
90755 : }
90756 : #endif
90757 :
90758 :
90759 :
90760 : // End of memberFunctionString
90761 :
90762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
90763 :
90764 0 : SgOmpEndClause* isSgOmpEndClause ( SgNode* inputDerivedClassPointer )
90765 : {
90766 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90767 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90768 : // So to fix this we return NULL directly when the input is NULL and avoid the
90769 : // dynamic_cast in this case. This is likely a performance improvement as well.
90770 : // return dynamic_cast<SgOmpEndClause*>(inputDerivedClassPointer);
90771 : // Milind Chabbi (8/28/2013): isSgOmpEndClause uses table-driven castability instead of c++ default dynamic_cast
90772 : // this improves the running time performance by 10-20%.
90773 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpEndClause*>(inputDerivedClassPointer);
90774 0 : return IS_SgOmpEndClause_FAST_MACRO(inputDerivedClassPointer);
90775 : }
90776 :
90777 : // DQ (11/8/2003): Added version of functions taking const pointer
90778 0 : const SgOmpEndClause* isSgOmpEndClause ( const SgNode* inputDerivedClassPointer )
90779 : {
90780 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
90781 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
90782 : // So to fix this we return NULL directly when the input is NULL and avoid the
90783 : // dynamic_cast in this case. This is likely a performance improvement as well.
90784 : // return dynamic_cast<const SgOmpEndClause*>(inputDerivedClassPointer);
90785 : // Milind Chabbi (8/28/2013): isSgOmpEndClause uses table-driven castability instead of c++ default dynamic_cast
90786 : // this improves the running time performance by 10-20%.
90787 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpEndClause*>(inputDerivedClassPointer);
90788 0 : return IS_SgOmpEndClause_FAST_MACRO(inputDerivedClassPointer);
90789 : }
90790 :
90791 :
90792 :
90793 : /* #line 90794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90794 :
90795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90796 :
90797 : /**
90798 : \brief Generated destructor
90799 :
90800 : This destructor is automatically generated (by ROSETTA). This destructor
90801 : only frees memory of data members associated with the parts of the current IR node which
90802 : are NOT traversed. Those data members that are part of a traversal can be freed using
90803 : a traversal (calling this destructor on all children in a post-order traversal). Such
90804 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
90805 :
90806 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
90807 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
90808 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
90809 :
90810 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
90811 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
90812 : pointers are not yet implemented to call delete on eash pointer in the container.
90813 : (This could be done by derivation from the STL containers to define containers that
90814 : automatically deleted their members.)
90815 :
90816 : */
90817 0 : SgOmpEndClause::~SgOmpEndClause () {
90818 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
90819 :
90820 :
90821 :
90822 : }
90823 :
90824 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
90825 0 : }
90826 :
90827 :
90828 : /* #line 90829 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90829 :
90830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
90831 :
90832 : // Generated constructor
90833 0 : SgOmpEndClause::SgOmpEndClause ( Sg_File_Info* startOfConstruct )
90834 0 : : SgOmpClause(startOfConstruct)
90835 : {
90836 : #ifdef DEBUG
90837 : // printf ("In SgOmpEndClause::SgOmpEndClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
90838 : #endif
90839 : #if 0
90840 : // debugging information!
90841 : printf ("In SgOmpEndClause::SgOmpEndClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
90842 : #endif
90843 :
90844 :
90845 :
90846 : #if 0
90847 : // DQ (7/30/2014): Call a virtual function.
90848 : std::string s = this->class_name();
90849 : #endif
90850 :
90851 : // Test the variant virtual function
90852 : // assert(OmpEndClauseTag == variant());
90853 0 : assert(OmpEndClauseTag == this->variant());
90854 0 : ROSE_ASSERT(OmpEndClauseTag == (int)(this->variantT()));
90855 0 : post_construction_initialization();
90856 :
90857 : // Test the isSgOmpEndClause() function since it has been problematic
90858 0 : assert(isSgOmpEndClause(this) != NULL);
90859 0 : }
90860 :
90861 : // Generated constructor (all data members)
90862 :
90863 : /* #line 90864 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90864 :
90865 :
90866 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90867 :
90868 :
90869 : // ********************************************************
90870 : // member functions common across all array grammar objects
90871 : // ********************************************************
90872 :
90873 :
90874 :
90875 : /* #line 90876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90876 :
90877 :
90878 :
90879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
90880 :
90881 : // ********************************************************
90882 : // member functions specific to each node in the grammar
90883 : // ********************************************************
90884 :
90885 :
90886 : /* #line 90887 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
90887 :
90888 : // Start of memberFunctionString
90889 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
90890 :
90891 : // *** COMMON CODE SECTION BEGINS HERE ***
90892 :
90893 : #if 0
90894 : int
90895 : SgOmpUntiedClause::getVariant() const
90896 : {
90897 : // This function is used in ROSE while "variant()" is used in SAGE
90898 : assert(this != NULL);
90899 : return variant();
90900 : }
90901 : #endif
90902 :
90903 : // This function is used in ROSE in treeTraversal code
90904 : // eventually replaces getVariant() and variant()
90905 : // though after variant() has been removed for a while we will
90906 : // want to change the name of variantT() back to variant()
90907 : // (since the "T" was ment to stand for temporary).
90908 : // When this happens the variantT() will be depricated.
90909 : VariantT
90910 233 : SgOmpUntiedClause::variantT() const
90911 : {
90912 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
90913 233 : ROSE_ASSERT(this != NULL);
90914 233 : return V_SgOmpUntiedClause;
90915 : }
90916 :
90917 : #if 0
90918 : int
90919 : SgOmpUntiedClause::variant() const
90920 : {
90921 : // This function is used in SAGE
90922 : ROSE_ASSERT(this != NULL);
90923 : return OmpUntiedClauseTag;
90924 : }
90925 : #endif
90926 :
90927 : ROSE_DLL_API const char*
90928 0 : SgOmpUntiedClause::sage_class_name() const
90929 : {
90930 0 : ROSE_ASSERT(this != NULL);
90931 0 : return "SgOmpUntiedClause";
90932 : }
90933 :
90934 : std::string
90935 5 : SgOmpUntiedClause::class_name() const
90936 : {
90937 5 : ROSE_ASSERT(this != NULL);
90938 5 : return "SgOmpUntiedClause";
90939 : }
90940 :
90941 : // DQ (11/26/2005): Support for visitor pattern mechanims
90942 : // (inferior to ROSE traversal mechanism, experimental).
90943 : void
90944 0 : SgOmpUntiedClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
90945 : {
90946 0 : ROSE_ASSERT(this != NULL);
90947 0 : visitor.visit(this);
90948 0 : }
90949 :
90950 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
90951 0 : void SgOmpUntiedClause::accept (ROSE_VisitorPattern & visitor) {
90952 0 : ROSE_ASSERT(this != NULL);
90953 0 : visitor.visit(this);
90954 0 : }
90955 :
90956 : SgOmpUntiedClause*
90957 0 : SgOmpUntiedClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
90958 : {
90959 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
90960 : // This function is currently only supported for the AST used the represent Binary executables.
90961 : if (0 /* isSgAsmNode(this) != NULL */)
90962 : {
90963 : // Support for regex specification.
90964 : std::string prefixCode = "REGEX:";
90965 : addNewAttribute(prefixCode + s,a);
90966 : }
90967 : #endif
90968 :
90969 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
90970 0 : return this;
90971 : }
90972 :
90973 : // *** COMMON CODE SECTION ENDS HERE ***
90974 :
90975 :
90976 : // End of memberFunctionString
90977 : // Start of memberFunctionString
90978 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
90979 :
90980 :
90981 : #if 0
90982 : //! Error checking support
90983 : /*! Verifies the following:
90984 : - working getVariant() member function
90985 : - calls base class's error() member function
90986 : Every class has one of these functions.
90987 : */
90988 : bool
90989 : SgOmpUntiedClause::error()
90990 : {
90991 : // Put error checking here
90992 :
90993 : ROSE_ASSERT (this != NULL);
90994 : if (getVariant() != OmpUntiedClauseTag)
90995 : {
90996 : printf ("Error in SgOmpUntiedClause::error(): SgOmpUntiedClause object has a %s variant \n",
90997 : Cxx_GrammarTerminalNames[getVariant()].name);
90998 : // printf ("Error in SgOmpUntiedClause::error() \n");
90999 : ROSE_ABORT();
91000 : }
91001 :
91002 : ROSE_ASSERT (getVariant() == OmpUntiedClauseTag);
91003 : return SgOmpClause::error();
91004 : }
91005 : #endif
91006 :
91007 :
91008 :
91009 : // End of memberFunctionString
91010 :
91011 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
91012 :
91013 5 : SgOmpUntiedClause* isSgOmpUntiedClause ( SgNode* inputDerivedClassPointer )
91014 : {
91015 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91016 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91017 : // So to fix this we return NULL directly when the input is NULL and avoid the
91018 : // dynamic_cast in this case. This is likely a performance improvement as well.
91019 : // return dynamic_cast<SgOmpUntiedClause*>(inputDerivedClassPointer);
91020 : // Milind Chabbi (8/28/2013): isSgOmpUntiedClause uses table-driven castability instead of c++ default dynamic_cast
91021 : // this improves the running time performance by 10-20%.
91022 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUntiedClause*>(inputDerivedClassPointer);
91023 5 : return IS_SgOmpUntiedClause_FAST_MACRO(inputDerivedClassPointer);
91024 : }
91025 :
91026 : // DQ (11/8/2003): Added version of functions taking const pointer
91027 0 : const SgOmpUntiedClause* isSgOmpUntiedClause ( const SgNode* inputDerivedClassPointer )
91028 : {
91029 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91030 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91031 : // So to fix this we return NULL directly when the input is NULL and avoid the
91032 : // dynamic_cast in this case. This is likely a performance improvement as well.
91033 : // return dynamic_cast<const SgOmpUntiedClause*>(inputDerivedClassPointer);
91034 : // Milind Chabbi (8/28/2013): isSgOmpUntiedClause uses table-driven castability instead of c++ default dynamic_cast
91035 : // this improves the running time performance by 10-20%.
91036 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUntiedClause*>(inputDerivedClassPointer);
91037 0 : return IS_SgOmpUntiedClause_FAST_MACRO(inputDerivedClassPointer);
91038 : }
91039 :
91040 :
91041 :
91042 : /* #line 91043 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91043 :
91044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91045 :
91046 : /**
91047 : \brief Generated destructor
91048 :
91049 : This destructor is automatically generated (by ROSETTA). This destructor
91050 : only frees memory of data members associated with the parts of the current IR node which
91051 : are NOT traversed. Those data members that are part of a traversal can be freed using
91052 : a traversal (calling this destructor on all children in a post-order traversal). Such
91053 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
91054 :
91055 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
91056 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
91057 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
91058 :
91059 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
91060 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
91061 : pointers are not yet implemented to call delete on eash pointer in the container.
91062 : (This could be done by derivation from the STL containers to define containers that
91063 : automatically deleted their members.)
91064 :
91065 : */
91066 0 : SgOmpUntiedClause::~SgOmpUntiedClause () {
91067 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
91068 :
91069 :
91070 :
91071 : }
91072 :
91073 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91074 0 : }
91075 :
91076 :
91077 : /* #line 91078 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91078 :
91079 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
91080 :
91081 : // Generated constructor
91082 0 : SgOmpUntiedClause::SgOmpUntiedClause ( Sg_File_Info* startOfConstruct )
91083 0 : : SgOmpClause(startOfConstruct)
91084 : {
91085 : #ifdef DEBUG
91086 : // printf ("In SgOmpUntiedClause::SgOmpUntiedClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
91087 : #endif
91088 : #if 0
91089 : // debugging information!
91090 : printf ("In SgOmpUntiedClause::SgOmpUntiedClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
91091 : #endif
91092 :
91093 :
91094 :
91095 : #if 0
91096 : // DQ (7/30/2014): Call a virtual function.
91097 : std::string s = this->class_name();
91098 : #endif
91099 :
91100 : // Test the variant virtual function
91101 : // assert(OmpUntiedClauseTag == variant());
91102 0 : assert(OmpUntiedClauseTag == this->variant());
91103 0 : ROSE_ASSERT(OmpUntiedClauseTag == (int)(this->variantT()));
91104 0 : post_construction_initialization();
91105 :
91106 : // Test the isSgOmpUntiedClause() function since it has been problematic
91107 0 : assert(isSgOmpUntiedClause(this) != NULL);
91108 0 : }
91109 :
91110 : // Generated constructor (all data members)
91111 :
91112 : /* #line 91113 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91113 :
91114 :
91115 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91116 :
91117 :
91118 : // ********************************************************
91119 : // member functions common across all array grammar objects
91120 : // ********************************************************
91121 :
91122 :
91123 :
91124 : /* #line 91125 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91125 :
91126 :
91127 :
91128 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91129 :
91130 : // ********************************************************
91131 : // member functions specific to each node in the grammar
91132 : // ********************************************************
91133 :
91134 :
91135 : /* #line 91136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91136 :
91137 : // Start of memberFunctionString
91138 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
91139 :
91140 : // *** COMMON CODE SECTION BEGINS HERE ***
91141 :
91142 : #if 0
91143 : int
91144 : SgOmpSeqCstClause::getVariant() const
91145 : {
91146 : // This function is used in ROSE while "variant()" is used in SAGE
91147 : assert(this != NULL);
91148 : return variant();
91149 : }
91150 : #endif
91151 :
91152 : // This function is used in ROSE in treeTraversal code
91153 : // eventually replaces getVariant() and variant()
91154 : // though after variant() has been removed for a while we will
91155 : // want to change the name of variantT() back to variant()
91156 : // (since the "T" was ment to stand for temporary).
91157 : // When this happens the variantT() will be depricated.
91158 : VariantT
91159 0 : SgOmpSeqCstClause::variantT() const
91160 : {
91161 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
91162 0 : ROSE_ASSERT(this != NULL);
91163 0 : return V_SgOmpSeqCstClause;
91164 : }
91165 :
91166 : #if 0
91167 : int
91168 : SgOmpSeqCstClause::variant() const
91169 : {
91170 : // This function is used in SAGE
91171 : ROSE_ASSERT(this != NULL);
91172 : return OmpSeqCstClauseTag;
91173 : }
91174 : #endif
91175 :
91176 : ROSE_DLL_API const char*
91177 0 : SgOmpSeqCstClause::sage_class_name() const
91178 : {
91179 0 : ROSE_ASSERT(this != NULL);
91180 0 : return "SgOmpSeqCstClause";
91181 : }
91182 :
91183 : std::string
91184 0 : SgOmpSeqCstClause::class_name() const
91185 : {
91186 0 : ROSE_ASSERT(this != NULL);
91187 0 : return "SgOmpSeqCstClause";
91188 : }
91189 :
91190 : // DQ (11/26/2005): Support for visitor pattern mechanims
91191 : // (inferior to ROSE traversal mechanism, experimental).
91192 : void
91193 0 : SgOmpSeqCstClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
91194 : {
91195 0 : ROSE_ASSERT(this != NULL);
91196 0 : visitor.visit(this);
91197 0 : }
91198 :
91199 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
91200 0 : void SgOmpSeqCstClause::accept (ROSE_VisitorPattern & visitor) {
91201 0 : ROSE_ASSERT(this != NULL);
91202 0 : visitor.visit(this);
91203 0 : }
91204 :
91205 : SgOmpSeqCstClause*
91206 0 : SgOmpSeqCstClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
91207 : {
91208 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
91209 : // This function is currently only supported for the AST used the represent Binary executables.
91210 : if (0 /* isSgAsmNode(this) != NULL */)
91211 : {
91212 : // Support for regex specification.
91213 : std::string prefixCode = "REGEX:";
91214 : addNewAttribute(prefixCode + s,a);
91215 : }
91216 : #endif
91217 :
91218 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
91219 0 : return this;
91220 : }
91221 :
91222 : // *** COMMON CODE SECTION ENDS HERE ***
91223 :
91224 :
91225 : // End of memberFunctionString
91226 : // Start of memberFunctionString
91227 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
91228 :
91229 :
91230 : #if 0
91231 : //! Error checking support
91232 : /*! Verifies the following:
91233 : - working getVariant() member function
91234 : - calls base class's error() member function
91235 : Every class has one of these functions.
91236 : */
91237 : bool
91238 : SgOmpSeqCstClause::error()
91239 : {
91240 : // Put error checking here
91241 :
91242 : ROSE_ASSERT (this != NULL);
91243 : if (getVariant() != OmpSeqCstClauseTag)
91244 : {
91245 : printf ("Error in SgOmpSeqCstClause::error(): SgOmpSeqCstClause object has a %s variant \n",
91246 : Cxx_GrammarTerminalNames[getVariant()].name);
91247 : // printf ("Error in SgOmpSeqCstClause::error() \n");
91248 : ROSE_ABORT();
91249 : }
91250 :
91251 : ROSE_ASSERT (getVariant() == OmpSeqCstClauseTag);
91252 : return SgOmpClause::error();
91253 : }
91254 : #endif
91255 :
91256 :
91257 :
91258 : // End of memberFunctionString
91259 :
91260 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
91261 :
91262 0 : SgOmpSeqCstClause* isSgOmpSeqCstClause ( SgNode* inputDerivedClassPointer )
91263 : {
91264 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91265 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91266 : // So to fix this we return NULL directly when the input is NULL and avoid the
91267 : // dynamic_cast in this case. This is likely a performance improvement as well.
91268 : // return dynamic_cast<SgOmpSeqCstClause*>(inputDerivedClassPointer);
91269 : // Milind Chabbi (8/28/2013): isSgOmpSeqCstClause uses table-driven castability instead of c++ default dynamic_cast
91270 : // this improves the running time performance by 10-20%.
91271 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSeqCstClause*>(inputDerivedClassPointer);
91272 0 : return IS_SgOmpSeqCstClause_FAST_MACRO(inputDerivedClassPointer);
91273 : }
91274 :
91275 : // DQ (11/8/2003): Added version of functions taking const pointer
91276 0 : const SgOmpSeqCstClause* isSgOmpSeqCstClause ( const SgNode* inputDerivedClassPointer )
91277 : {
91278 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91279 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91280 : // So to fix this we return NULL directly when the input is NULL and avoid the
91281 : // dynamic_cast in this case. This is likely a performance improvement as well.
91282 : // return dynamic_cast<const SgOmpSeqCstClause*>(inputDerivedClassPointer);
91283 : // Milind Chabbi (8/28/2013): isSgOmpSeqCstClause uses table-driven castability instead of c++ default dynamic_cast
91284 : // this improves the running time performance by 10-20%.
91285 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSeqCstClause*>(inputDerivedClassPointer);
91286 0 : return IS_SgOmpSeqCstClause_FAST_MACRO(inputDerivedClassPointer);
91287 : }
91288 :
91289 :
91290 :
91291 : /* #line 91292 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91292 :
91293 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91294 :
91295 : /**
91296 : \brief Generated destructor
91297 :
91298 : This destructor is automatically generated (by ROSETTA). This destructor
91299 : only frees memory of data members associated with the parts of the current IR node which
91300 : are NOT traversed. Those data members that are part of a traversal can be freed using
91301 : a traversal (calling this destructor on all children in a post-order traversal). Such
91302 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
91303 :
91304 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
91305 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
91306 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
91307 :
91308 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
91309 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
91310 : pointers are not yet implemented to call delete on eash pointer in the container.
91311 : (This could be done by derivation from the STL containers to define containers that
91312 : automatically deleted their members.)
91313 :
91314 : */
91315 0 : SgOmpSeqCstClause::~SgOmpSeqCstClause () {
91316 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
91317 :
91318 :
91319 :
91320 : }
91321 :
91322 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91323 0 : }
91324 :
91325 :
91326 : /* #line 91327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91327 :
91328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
91329 :
91330 : // Generated constructor
91331 0 : SgOmpSeqCstClause::SgOmpSeqCstClause ( Sg_File_Info* startOfConstruct )
91332 0 : : SgOmpClause(startOfConstruct)
91333 : {
91334 : #ifdef DEBUG
91335 : // printf ("In SgOmpSeqCstClause::SgOmpSeqCstClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
91336 : #endif
91337 : #if 0
91338 : // debugging information!
91339 : printf ("In SgOmpSeqCstClause::SgOmpSeqCstClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
91340 : #endif
91341 :
91342 :
91343 :
91344 : #if 0
91345 : // DQ (7/30/2014): Call a virtual function.
91346 : std::string s = this->class_name();
91347 : #endif
91348 :
91349 : // Test the variant virtual function
91350 : // assert(OmpSeqCstClauseTag == variant());
91351 0 : assert(OmpSeqCstClauseTag == this->variant());
91352 0 : ROSE_ASSERT(OmpSeqCstClauseTag == (int)(this->variantT()));
91353 0 : post_construction_initialization();
91354 :
91355 : // Test the isSgOmpSeqCstClause() function since it has been problematic
91356 0 : assert(isSgOmpSeqCstClause(this) != NULL);
91357 0 : }
91358 :
91359 : // Generated constructor (all data members)
91360 :
91361 : /* #line 91362 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91362 :
91363 :
91364 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91365 :
91366 :
91367 : // ********************************************************
91368 : // member functions common across all array grammar objects
91369 : // ********************************************************
91370 :
91371 :
91372 :
91373 : /* #line 91374 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91374 :
91375 :
91376 :
91377 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91378 :
91379 : // ********************************************************
91380 : // member functions specific to each node in the grammar
91381 : // ********************************************************
91382 :
91383 :
91384 : /* #line 91385 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91385 :
91386 : // Start of memberFunctionString
91387 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
91388 :
91389 : // *** COMMON CODE SECTION BEGINS HERE ***
91390 :
91391 : #if 0
91392 : int
91393 : SgOmpAcqRelClause::getVariant() const
91394 : {
91395 : // This function is used in ROSE while "variant()" is used in SAGE
91396 : assert(this != NULL);
91397 : return variant();
91398 : }
91399 : #endif
91400 :
91401 : // This function is used in ROSE in treeTraversal code
91402 : // eventually replaces getVariant() and variant()
91403 : // though after variant() has been removed for a while we will
91404 : // want to change the name of variantT() back to variant()
91405 : // (since the "T" was ment to stand for temporary).
91406 : // When this happens the variantT() will be depricated.
91407 : VariantT
91408 26 : SgOmpAcqRelClause::variantT() const
91409 : {
91410 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
91411 26 : ROSE_ASSERT(this != NULL);
91412 26 : return V_SgOmpAcqRelClause;
91413 : }
91414 :
91415 : #if 0
91416 : int
91417 : SgOmpAcqRelClause::variant() const
91418 : {
91419 : // This function is used in SAGE
91420 : ROSE_ASSERT(this != NULL);
91421 : return OmpAcqRelClauseTag;
91422 : }
91423 : #endif
91424 :
91425 : ROSE_DLL_API const char*
91426 0 : SgOmpAcqRelClause::sage_class_name() const
91427 : {
91428 0 : ROSE_ASSERT(this != NULL);
91429 0 : return "SgOmpAcqRelClause";
91430 : }
91431 :
91432 : std::string
91433 1 : SgOmpAcqRelClause::class_name() const
91434 : {
91435 1 : ROSE_ASSERT(this != NULL);
91436 1 : return "SgOmpAcqRelClause";
91437 : }
91438 :
91439 : // DQ (11/26/2005): Support for visitor pattern mechanims
91440 : // (inferior to ROSE traversal mechanism, experimental).
91441 : void
91442 0 : SgOmpAcqRelClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
91443 : {
91444 0 : ROSE_ASSERT(this != NULL);
91445 0 : visitor.visit(this);
91446 0 : }
91447 :
91448 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
91449 0 : void SgOmpAcqRelClause::accept (ROSE_VisitorPattern & visitor) {
91450 0 : ROSE_ASSERT(this != NULL);
91451 0 : visitor.visit(this);
91452 0 : }
91453 :
91454 : SgOmpAcqRelClause*
91455 0 : SgOmpAcqRelClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
91456 : {
91457 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
91458 : // This function is currently only supported for the AST used the represent Binary executables.
91459 : if (0 /* isSgAsmNode(this) != NULL */)
91460 : {
91461 : // Support for regex specification.
91462 : std::string prefixCode = "REGEX:";
91463 : addNewAttribute(prefixCode + s,a);
91464 : }
91465 : #endif
91466 :
91467 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
91468 0 : return this;
91469 : }
91470 :
91471 : // *** COMMON CODE SECTION ENDS HERE ***
91472 :
91473 :
91474 : // End of memberFunctionString
91475 : // Start of memberFunctionString
91476 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
91477 :
91478 :
91479 : #if 0
91480 : //! Error checking support
91481 : /*! Verifies the following:
91482 : - working getVariant() member function
91483 : - calls base class's error() member function
91484 : Every class has one of these functions.
91485 : */
91486 : bool
91487 : SgOmpAcqRelClause::error()
91488 : {
91489 : // Put error checking here
91490 :
91491 : ROSE_ASSERT (this != NULL);
91492 : if (getVariant() != OmpAcqRelClauseTag)
91493 : {
91494 : printf ("Error in SgOmpAcqRelClause::error(): SgOmpAcqRelClause object has a %s variant \n",
91495 : Cxx_GrammarTerminalNames[getVariant()].name);
91496 : // printf ("Error in SgOmpAcqRelClause::error() \n");
91497 : ROSE_ABORT();
91498 : }
91499 :
91500 : ROSE_ASSERT (getVariant() == OmpAcqRelClauseTag);
91501 : return SgOmpClause::error();
91502 : }
91503 : #endif
91504 :
91505 :
91506 :
91507 : // End of memberFunctionString
91508 :
91509 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
91510 :
91511 1 : SgOmpAcqRelClause* isSgOmpAcqRelClause ( SgNode* inputDerivedClassPointer )
91512 : {
91513 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91514 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91515 : // So to fix this we return NULL directly when the input is NULL and avoid the
91516 : // dynamic_cast in this case. This is likely a performance improvement as well.
91517 : // return dynamic_cast<SgOmpAcqRelClause*>(inputDerivedClassPointer);
91518 : // Milind Chabbi (8/28/2013): isSgOmpAcqRelClause uses table-driven castability instead of c++ default dynamic_cast
91519 : // this improves the running time performance by 10-20%.
91520 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAcqRelClause*>(inputDerivedClassPointer);
91521 1 : return IS_SgOmpAcqRelClause_FAST_MACRO(inputDerivedClassPointer);
91522 : }
91523 :
91524 : // DQ (11/8/2003): Added version of functions taking const pointer
91525 0 : const SgOmpAcqRelClause* isSgOmpAcqRelClause ( const SgNode* inputDerivedClassPointer )
91526 : {
91527 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91528 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91529 : // So to fix this we return NULL directly when the input is NULL and avoid the
91530 : // dynamic_cast in this case. This is likely a performance improvement as well.
91531 : // return dynamic_cast<const SgOmpAcqRelClause*>(inputDerivedClassPointer);
91532 : // Milind Chabbi (8/28/2013): isSgOmpAcqRelClause uses table-driven castability instead of c++ default dynamic_cast
91533 : // this improves the running time performance by 10-20%.
91534 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAcqRelClause*>(inputDerivedClassPointer);
91535 0 : return IS_SgOmpAcqRelClause_FAST_MACRO(inputDerivedClassPointer);
91536 : }
91537 :
91538 :
91539 :
91540 : /* #line 91541 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91541 :
91542 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91543 :
91544 : /**
91545 : \brief Generated destructor
91546 :
91547 : This destructor is automatically generated (by ROSETTA). This destructor
91548 : only frees memory of data members associated with the parts of the current IR node which
91549 : are NOT traversed. Those data members that are part of a traversal can be freed using
91550 : a traversal (calling this destructor on all children in a post-order traversal). Such
91551 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
91552 :
91553 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
91554 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
91555 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
91556 :
91557 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
91558 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
91559 : pointers are not yet implemented to call delete on eash pointer in the container.
91560 : (This could be done by derivation from the STL containers to define containers that
91561 : automatically deleted their members.)
91562 :
91563 : */
91564 0 : SgOmpAcqRelClause::~SgOmpAcqRelClause () {
91565 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
91566 :
91567 :
91568 :
91569 : }
91570 :
91571 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91572 0 : }
91573 :
91574 :
91575 : /* #line 91576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91576 :
91577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
91578 :
91579 : // Generated constructor
91580 0 : SgOmpAcqRelClause::SgOmpAcqRelClause ( Sg_File_Info* startOfConstruct )
91581 0 : : SgOmpClause(startOfConstruct)
91582 : {
91583 : #ifdef DEBUG
91584 : // printf ("In SgOmpAcqRelClause::SgOmpAcqRelClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
91585 : #endif
91586 : #if 0
91587 : // debugging information!
91588 : printf ("In SgOmpAcqRelClause::SgOmpAcqRelClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
91589 : #endif
91590 :
91591 :
91592 :
91593 : #if 0
91594 : // DQ (7/30/2014): Call a virtual function.
91595 : std::string s = this->class_name();
91596 : #endif
91597 :
91598 : // Test the variant virtual function
91599 : // assert(OmpAcqRelClauseTag == variant());
91600 0 : assert(OmpAcqRelClauseTag == this->variant());
91601 0 : ROSE_ASSERT(OmpAcqRelClauseTag == (int)(this->variantT()));
91602 0 : post_construction_initialization();
91603 :
91604 : // Test the isSgOmpAcqRelClause() function since it has been problematic
91605 0 : assert(isSgOmpAcqRelClause(this) != NULL);
91606 0 : }
91607 :
91608 : // Generated constructor (all data members)
91609 :
91610 : /* #line 91611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91611 :
91612 :
91613 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91614 :
91615 :
91616 : // ********************************************************
91617 : // member functions common across all array grammar objects
91618 : // ********************************************************
91619 :
91620 :
91621 :
91622 : /* #line 91623 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91623 :
91624 :
91625 :
91626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91627 :
91628 : // ********************************************************
91629 : // member functions specific to each node in the grammar
91630 : // ********************************************************
91631 :
91632 :
91633 : /* #line 91634 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91634 :
91635 : // Start of memberFunctionString
91636 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
91637 :
91638 : // *** COMMON CODE SECTION BEGINS HERE ***
91639 :
91640 : #if 0
91641 : int
91642 : SgOmpReleaseClause::getVariant() const
91643 : {
91644 : // This function is used in ROSE while "variant()" is used in SAGE
91645 : assert(this != NULL);
91646 : return variant();
91647 : }
91648 : #endif
91649 :
91650 : // This function is used in ROSE in treeTraversal code
91651 : // eventually replaces getVariant() and variant()
91652 : // though after variant() has been removed for a while we will
91653 : // want to change the name of variantT() back to variant()
91654 : // (since the "T" was ment to stand for temporary).
91655 : // When this happens the variantT() will be depricated.
91656 : VariantT
91657 52 : SgOmpReleaseClause::variantT() const
91658 : {
91659 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
91660 52 : ROSE_ASSERT(this != NULL);
91661 52 : return V_SgOmpReleaseClause;
91662 : }
91663 :
91664 : #if 0
91665 : int
91666 : SgOmpReleaseClause::variant() const
91667 : {
91668 : // This function is used in SAGE
91669 : ROSE_ASSERT(this != NULL);
91670 : return OmpReleaseClauseTag;
91671 : }
91672 : #endif
91673 :
91674 : ROSE_DLL_API const char*
91675 0 : SgOmpReleaseClause::sage_class_name() const
91676 : {
91677 0 : ROSE_ASSERT(this != NULL);
91678 0 : return "SgOmpReleaseClause";
91679 : }
91680 :
91681 : std::string
91682 1 : SgOmpReleaseClause::class_name() const
91683 : {
91684 1 : ROSE_ASSERT(this != NULL);
91685 1 : return "SgOmpReleaseClause";
91686 : }
91687 :
91688 : // DQ (11/26/2005): Support for visitor pattern mechanims
91689 : // (inferior to ROSE traversal mechanism, experimental).
91690 : void
91691 0 : SgOmpReleaseClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
91692 : {
91693 0 : ROSE_ASSERT(this != NULL);
91694 0 : visitor.visit(this);
91695 0 : }
91696 :
91697 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
91698 0 : void SgOmpReleaseClause::accept (ROSE_VisitorPattern & visitor) {
91699 0 : ROSE_ASSERT(this != NULL);
91700 0 : visitor.visit(this);
91701 0 : }
91702 :
91703 : SgOmpReleaseClause*
91704 0 : SgOmpReleaseClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
91705 : {
91706 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
91707 : // This function is currently only supported for the AST used the represent Binary executables.
91708 : if (0 /* isSgAsmNode(this) != NULL */)
91709 : {
91710 : // Support for regex specification.
91711 : std::string prefixCode = "REGEX:";
91712 : addNewAttribute(prefixCode + s,a);
91713 : }
91714 : #endif
91715 :
91716 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
91717 0 : return this;
91718 : }
91719 :
91720 : // *** COMMON CODE SECTION ENDS HERE ***
91721 :
91722 :
91723 : // End of memberFunctionString
91724 : // Start of memberFunctionString
91725 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
91726 :
91727 :
91728 : #if 0
91729 : //! Error checking support
91730 : /*! Verifies the following:
91731 : - working getVariant() member function
91732 : - calls base class's error() member function
91733 : Every class has one of these functions.
91734 : */
91735 : bool
91736 : SgOmpReleaseClause::error()
91737 : {
91738 : // Put error checking here
91739 :
91740 : ROSE_ASSERT (this != NULL);
91741 : if (getVariant() != OmpReleaseClauseTag)
91742 : {
91743 : printf ("Error in SgOmpReleaseClause::error(): SgOmpReleaseClause object has a %s variant \n",
91744 : Cxx_GrammarTerminalNames[getVariant()].name);
91745 : // printf ("Error in SgOmpReleaseClause::error() \n");
91746 : ROSE_ABORT();
91747 : }
91748 :
91749 : ROSE_ASSERT (getVariant() == OmpReleaseClauseTag);
91750 : return SgOmpClause::error();
91751 : }
91752 : #endif
91753 :
91754 :
91755 :
91756 : // End of memberFunctionString
91757 :
91758 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
91759 :
91760 1 : SgOmpReleaseClause* isSgOmpReleaseClause ( SgNode* inputDerivedClassPointer )
91761 : {
91762 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91763 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91764 : // So to fix this we return NULL directly when the input is NULL and avoid the
91765 : // dynamic_cast in this case. This is likely a performance improvement as well.
91766 : // return dynamic_cast<SgOmpReleaseClause*>(inputDerivedClassPointer);
91767 : // Milind Chabbi (8/28/2013): isSgOmpReleaseClause uses table-driven castability instead of c++ default dynamic_cast
91768 : // this improves the running time performance by 10-20%.
91769 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpReleaseClause*>(inputDerivedClassPointer);
91770 1 : return IS_SgOmpReleaseClause_FAST_MACRO(inputDerivedClassPointer);
91771 : }
91772 :
91773 : // DQ (11/8/2003): Added version of functions taking const pointer
91774 0 : const SgOmpReleaseClause* isSgOmpReleaseClause ( const SgNode* inputDerivedClassPointer )
91775 : {
91776 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
91777 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
91778 : // So to fix this we return NULL directly when the input is NULL and avoid the
91779 : // dynamic_cast in this case. This is likely a performance improvement as well.
91780 : // return dynamic_cast<const SgOmpReleaseClause*>(inputDerivedClassPointer);
91781 : // Milind Chabbi (8/28/2013): isSgOmpReleaseClause uses table-driven castability instead of c++ default dynamic_cast
91782 : // this improves the running time performance by 10-20%.
91783 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpReleaseClause*>(inputDerivedClassPointer);
91784 0 : return IS_SgOmpReleaseClause_FAST_MACRO(inputDerivedClassPointer);
91785 : }
91786 :
91787 :
91788 :
91789 : /* #line 91790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91790 :
91791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91792 :
91793 : /**
91794 : \brief Generated destructor
91795 :
91796 : This destructor is automatically generated (by ROSETTA). This destructor
91797 : only frees memory of data members associated with the parts of the current IR node which
91798 : are NOT traversed. Those data members that are part of a traversal can be freed using
91799 : a traversal (calling this destructor on all children in a post-order traversal). Such
91800 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
91801 :
91802 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
91803 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
91804 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
91805 :
91806 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
91807 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
91808 : pointers are not yet implemented to call delete on eash pointer in the container.
91809 : (This could be done by derivation from the STL containers to define containers that
91810 : automatically deleted their members.)
91811 :
91812 : */
91813 0 : SgOmpReleaseClause::~SgOmpReleaseClause () {
91814 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
91815 :
91816 :
91817 :
91818 : }
91819 :
91820 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
91821 0 : }
91822 :
91823 :
91824 : /* #line 91825 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91825 :
91826 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
91827 :
91828 : // Generated constructor
91829 0 : SgOmpReleaseClause::SgOmpReleaseClause ( Sg_File_Info* startOfConstruct )
91830 0 : : SgOmpClause(startOfConstruct)
91831 : {
91832 : #ifdef DEBUG
91833 : // printf ("In SgOmpReleaseClause::SgOmpReleaseClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
91834 : #endif
91835 : #if 0
91836 : // debugging information!
91837 : printf ("In SgOmpReleaseClause::SgOmpReleaseClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
91838 : #endif
91839 :
91840 :
91841 :
91842 : #if 0
91843 : // DQ (7/30/2014): Call a virtual function.
91844 : std::string s = this->class_name();
91845 : #endif
91846 :
91847 : // Test the variant virtual function
91848 : // assert(OmpReleaseClauseTag == variant());
91849 0 : assert(OmpReleaseClauseTag == this->variant());
91850 0 : ROSE_ASSERT(OmpReleaseClauseTag == (int)(this->variantT()));
91851 0 : post_construction_initialization();
91852 :
91853 : // Test the isSgOmpReleaseClause() function since it has been problematic
91854 0 : assert(isSgOmpReleaseClause(this) != NULL);
91855 0 : }
91856 :
91857 : // Generated constructor (all data members)
91858 :
91859 : /* #line 91860 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91860 :
91861 :
91862 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91863 :
91864 :
91865 : // ********************************************************
91866 : // member functions common across all array grammar objects
91867 : // ********************************************************
91868 :
91869 :
91870 :
91871 : /* #line 91872 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91872 :
91873 :
91874 :
91875 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
91876 :
91877 : // ********************************************************
91878 : // member functions specific to each node in the grammar
91879 : // ********************************************************
91880 :
91881 :
91882 : /* #line 91883 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
91883 :
91884 : // Start of memberFunctionString
91885 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
91886 :
91887 : // *** COMMON CODE SECTION BEGINS HERE ***
91888 :
91889 : #if 0
91890 : int
91891 : SgOmpAcquireClause::getVariant() const
91892 : {
91893 : // This function is used in ROSE while "variant()" is used in SAGE
91894 : assert(this != NULL);
91895 : return variant();
91896 : }
91897 : #endif
91898 :
91899 : // This function is used in ROSE in treeTraversal code
91900 : // eventually replaces getVariant() and variant()
91901 : // though after variant() has been removed for a while we will
91902 : // want to change the name of variantT() back to variant()
91903 : // (since the "T" was ment to stand for temporary).
91904 : // When this happens the variantT() will be depricated.
91905 : VariantT
91906 0 : SgOmpAcquireClause::variantT() const
91907 : {
91908 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
91909 0 : ROSE_ASSERT(this != NULL);
91910 0 : return V_SgOmpAcquireClause;
91911 : }
91912 :
91913 : #if 0
91914 : int
91915 : SgOmpAcquireClause::variant() const
91916 : {
91917 : // This function is used in SAGE
91918 : ROSE_ASSERT(this != NULL);
91919 : return OmpAcquireClauseTag;
91920 : }
91921 : #endif
91922 :
91923 : ROSE_DLL_API const char*
91924 0 : SgOmpAcquireClause::sage_class_name() const
91925 : {
91926 0 : ROSE_ASSERT(this != NULL);
91927 0 : return "SgOmpAcquireClause";
91928 : }
91929 :
91930 : std::string
91931 0 : SgOmpAcquireClause::class_name() const
91932 : {
91933 0 : ROSE_ASSERT(this != NULL);
91934 0 : return "SgOmpAcquireClause";
91935 : }
91936 :
91937 : // DQ (11/26/2005): Support for visitor pattern mechanims
91938 : // (inferior to ROSE traversal mechanism, experimental).
91939 : void
91940 0 : SgOmpAcquireClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
91941 : {
91942 0 : ROSE_ASSERT(this != NULL);
91943 0 : visitor.visit(this);
91944 0 : }
91945 :
91946 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
91947 0 : void SgOmpAcquireClause::accept (ROSE_VisitorPattern & visitor) {
91948 0 : ROSE_ASSERT(this != NULL);
91949 0 : visitor.visit(this);
91950 0 : }
91951 :
91952 : SgOmpAcquireClause*
91953 0 : SgOmpAcquireClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
91954 : {
91955 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
91956 : // This function is currently only supported for the AST used the represent Binary executables.
91957 : if (0 /* isSgAsmNode(this) != NULL */)
91958 : {
91959 : // Support for regex specification.
91960 : std::string prefixCode = "REGEX:";
91961 : addNewAttribute(prefixCode + s,a);
91962 : }
91963 : #endif
91964 :
91965 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
91966 0 : return this;
91967 : }
91968 :
91969 : // *** COMMON CODE SECTION ENDS HERE ***
91970 :
91971 :
91972 : // End of memberFunctionString
91973 : // Start of memberFunctionString
91974 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
91975 :
91976 :
91977 : #if 0
91978 : //! Error checking support
91979 : /*! Verifies the following:
91980 : - working getVariant() member function
91981 : - calls base class's error() member function
91982 : Every class has one of these functions.
91983 : */
91984 : bool
91985 : SgOmpAcquireClause::error()
91986 : {
91987 : // Put error checking here
91988 :
91989 : ROSE_ASSERT (this != NULL);
91990 : if (getVariant() != OmpAcquireClauseTag)
91991 : {
91992 : printf ("Error in SgOmpAcquireClause::error(): SgOmpAcquireClause object has a %s variant \n",
91993 : Cxx_GrammarTerminalNames[getVariant()].name);
91994 : // printf ("Error in SgOmpAcquireClause::error() \n");
91995 : ROSE_ABORT();
91996 : }
91997 :
91998 : ROSE_ASSERT (getVariant() == OmpAcquireClauseTag);
91999 : return SgOmpClause::error();
92000 : }
92001 : #endif
92002 :
92003 :
92004 :
92005 : // End of memberFunctionString
92006 :
92007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
92008 :
92009 0 : SgOmpAcquireClause* isSgOmpAcquireClause ( SgNode* inputDerivedClassPointer )
92010 : {
92011 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92012 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92013 : // So to fix this we return NULL directly when the input is NULL and avoid the
92014 : // dynamic_cast in this case. This is likely a performance improvement as well.
92015 : // return dynamic_cast<SgOmpAcquireClause*>(inputDerivedClassPointer);
92016 : // Milind Chabbi (8/28/2013): isSgOmpAcquireClause uses table-driven castability instead of c++ default dynamic_cast
92017 : // this improves the running time performance by 10-20%.
92018 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAcquireClause*>(inputDerivedClassPointer);
92019 0 : return IS_SgOmpAcquireClause_FAST_MACRO(inputDerivedClassPointer);
92020 : }
92021 :
92022 : // DQ (11/8/2003): Added version of functions taking const pointer
92023 0 : const SgOmpAcquireClause* isSgOmpAcquireClause ( const SgNode* inputDerivedClassPointer )
92024 : {
92025 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92026 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92027 : // So to fix this we return NULL directly when the input is NULL and avoid the
92028 : // dynamic_cast in this case. This is likely a performance improvement as well.
92029 : // return dynamic_cast<const SgOmpAcquireClause*>(inputDerivedClassPointer);
92030 : // Milind Chabbi (8/28/2013): isSgOmpAcquireClause uses table-driven castability instead of c++ default dynamic_cast
92031 : // this improves the running time performance by 10-20%.
92032 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAcquireClause*>(inputDerivedClassPointer);
92033 0 : return IS_SgOmpAcquireClause_FAST_MACRO(inputDerivedClassPointer);
92034 : }
92035 :
92036 :
92037 :
92038 : /* #line 92039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92039 :
92040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92041 :
92042 : /**
92043 : \brief Generated destructor
92044 :
92045 : This destructor is automatically generated (by ROSETTA). This destructor
92046 : only frees memory of data members associated with the parts of the current IR node which
92047 : are NOT traversed. Those data members that are part of a traversal can be freed using
92048 : a traversal (calling this destructor on all children in a post-order traversal). Such
92049 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
92050 :
92051 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
92052 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
92053 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
92054 :
92055 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
92056 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
92057 : pointers are not yet implemented to call delete on eash pointer in the container.
92058 : (This could be done by derivation from the STL containers to define containers that
92059 : automatically deleted their members.)
92060 :
92061 : */
92062 0 : SgOmpAcquireClause::~SgOmpAcquireClause () {
92063 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
92064 :
92065 :
92066 :
92067 : }
92068 :
92069 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92070 0 : }
92071 :
92072 :
92073 : /* #line 92074 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92074 :
92075 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
92076 :
92077 : // Generated constructor
92078 0 : SgOmpAcquireClause::SgOmpAcquireClause ( Sg_File_Info* startOfConstruct )
92079 0 : : SgOmpClause(startOfConstruct)
92080 : {
92081 : #ifdef DEBUG
92082 : // printf ("In SgOmpAcquireClause::SgOmpAcquireClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
92083 : #endif
92084 : #if 0
92085 : // debugging information!
92086 : printf ("In SgOmpAcquireClause::SgOmpAcquireClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
92087 : #endif
92088 :
92089 :
92090 :
92091 : #if 0
92092 : // DQ (7/30/2014): Call a virtual function.
92093 : std::string s = this->class_name();
92094 : #endif
92095 :
92096 : // Test the variant virtual function
92097 : // assert(OmpAcquireClauseTag == variant());
92098 0 : assert(OmpAcquireClauseTag == this->variant());
92099 0 : ROSE_ASSERT(OmpAcquireClauseTag == (int)(this->variantT()));
92100 0 : post_construction_initialization();
92101 :
92102 : // Test the isSgOmpAcquireClause() function since it has been problematic
92103 0 : assert(isSgOmpAcquireClause(this) != NULL);
92104 0 : }
92105 :
92106 : // Generated constructor (all data members)
92107 :
92108 : /* #line 92109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92109 :
92110 :
92111 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92112 :
92113 :
92114 : // ********************************************************
92115 : // member functions common across all array grammar objects
92116 : // ********************************************************
92117 :
92118 :
92119 :
92120 : /* #line 92121 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92121 :
92122 :
92123 :
92124 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92125 :
92126 : // ********************************************************
92127 : // member functions specific to each node in the grammar
92128 : // ********************************************************
92129 :
92130 :
92131 : /* #line 92132 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92132 :
92133 : // Start of memberFunctionString
92134 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
92135 :
92136 : // *** COMMON CODE SECTION BEGINS HERE ***
92137 :
92138 : #if 0
92139 : int
92140 : SgOmpRelaxedClause::getVariant() const
92141 : {
92142 : // This function is used in ROSE while "variant()" is used in SAGE
92143 : assert(this != NULL);
92144 : return variant();
92145 : }
92146 : #endif
92147 :
92148 : // This function is used in ROSE in treeTraversal code
92149 : // eventually replaces getVariant() and variant()
92150 : // though after variant() has been removed for a while we will
92151 : // want to change the name of variantT() back to variant()
92152 : // (since the "T" was ment to stand for temporary).
92153 : // When this happens the variantT() will be depricated.
92154 : VariantT
92155 0 : SgOmpRelaxedClause::variantT() const
92156 : {
92157 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
92158 0 : ROSE_ASSERT(this != NULL);
92159 0 : return V_SgOmpRelaxedClause;
92160 : }
92161 :
92162 : #if 0
92163 : int
92164 : SgOmpRelaxedClause::variant() const
92165 : {
92166 : // This function is used in SAGE
92167 : ROSE_ASSERT(this != NULL);
92168 : return OmpRelaxedClauseTag;
92169 : }
92170 : #endif
92171 :
92172 : ROSE_DLL_API const char*
92173 0 : SgOmpRelaxedClause::sage_class_name() const
92174 : {
92175 0 : ROSE_ASSERT(this != NULL);
92176 0 : return "SgOmpRelaxedClause";
92177 : }
92178 :
92179 : std::string
92180 0 : SgOmpRelaxedClause::class_name() const
92181 : {
92182 0 : ROSE_ASSERT(this != NULL);
92183 0 : return "SgOmpRelaxedClause";
92184 : }
92185 :
92186 : // DQ (11/26/2005): Support for visitor pattern mechanims
92187 : // (inferior to ROSE traversal mechanism, experimental).
92188 : void
92189 0 : SgOmpRelaxedClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
92190 : {
92191 0 : ROSE_ASSERT(this != NULL);
92192 0 : visitor.visit(this);
92193 0 : }
92194 :
92195 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
92196 0 : void SgOmpRelaxedClause::accept (ROSE_VisitorPattern & visitor) {
92197 0 : ROSE_ASSERT(this != NULL);
92198 0 : visitor.visit(this);
92199 0 : }
92200 :
92201 : SgOmpRelaxedClause*
92202 0 : SgOmpRelaxedClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
92203 : {
92204 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
92205 : // This function is currently only supported for the AST used the represent Binary executables.
92206 : if (0 /* isSgAsmNode(this) != NULL */)
92207 : {
92208 : // Support for regex specification.
92209 : std::string prefixCode = "REGEX:";
92210 : addNewAttribute(prefixCode + s,a);
92211 : }
92212 : #endif
92213 :
92214 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
92215 0 : return this;
92216 : }
92217 :
92218 : // *** COMMON CODE SECTION ENDS HERE ***
92219 :
92220 :
92221 : // End of memberFunctionString
92222 : // Start of memberFunctionString
92223 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
92224 :
92225 :
92226 : #if 0
92227 : //! Error checking support
92228 : /*! Verifies the following:
92229 : - working getVariant() member function
92230 : - calls base class's error() member function
92231 : Every class has one of these functions.
92232 : */
92233 : bool
92234 : SgOmpRelaxedClause::error()
92235 : {
92236 : // Put error checking here
92237 :
92238 : ROSE_ASSERT (this != NULL);
92239 : if (getVariant() != OmpRelaxedClauseTag)
92240 : {
92241 : printf ("Error in SgOmpRelaxedClause::error(): SgOmpRelaxedClause object has a %s variant \n",
92242 : Cxx_GrammarTerminalNames[getVariant()].name);
92243 : // printf ("Error in SgOmpRelaxedClause::error() \n");
92244 : ROSE_ABORT();
92245 : }
92246 :
92247 : ROSE_ASSERT (getVariant() == OmpRelaxedClauseTag);
92248 : return SgOmpClause::error();
92249 : }
92250 : #endif
92251 :
92252 :
92253 :
92254 : // End of memberFunctionString
92255 :
92256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
92257 :
92258 0 : SgOmpRelaxedClause* isSgOmpRelaxedClause ( SgNode* inputDerivedClassPointer )
92259 : {
92260 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92261 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92262 : // So to fix this we return NULL directly when the input is NULL and avoid the
92263 : // dynamic_cast in this case. This is likely a performance improvement as well.
92264 : // return dynamic_cast<SgOmpRelaxedClause*>(inputDerivedClassPointer);
92265 : // Milind Chabbi (8/28/2013): isSgOmpRelaxedClause uses table-driven castability instead of c++ default dynamic_cast
92266 : // this improves the running time performance by 10-20%.
92267 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpRelaxedClause*>(inputDerivedClassPointer);
92268 0 : return IS_SgOmpRelaxedClause_FAST_MACRO(inputDerivedClassPointer);
92269 : }
92270 :
92271 : // DQ (11/8/2003): Added version of functions taking const pointer
92272 0 : const SgOmpRelaxedClause* isSgOmpRelaxedClause ( const SgNode* inputDerivedClassPointer )
92273 : {
92274 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92275 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92276 : // So to fix this we return NULL directly when the input is NULL and avoid the
92277 : // dynamic_cast in this case. This is likely a performance improvement as well.
92278 : // return dynamic_cast<const SgOmpRelaxedClause*>(inputDerivedClassPointer);
92279 : // Milind Chabbi (8/28/2013): isSgOmpRelaxedClause uses table-driven castability instead of c++ default dynamic_cast
92280 : // this improves the running time performance by 10-20%.
92281 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpRelaxedClause*>(inputDerivedClassPointer);
92282 0 : return IS_SgOmpRelaxedClause_FAST_MACRO(inputDerivedClassPointer);
92283 : }
92284 :
92285 :
92286 :
92287 : /* #line 92288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92288 :
92289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92290 :
92291 : /**
92292 : \brief Generated destructor
92293 :
92294 : This destructor is automatically generated (by ROSETTA). This destructor
92295 : only frees memory of data members associated with the parts of the current IR node which
92296 : are NOT traversed. Those data members that are part of a traversal can be freed using
92297 : a traversal (calling this destructor on all children in a post-order traversal). Such
92298 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
92299 :
92300 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
92301 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
92302 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
92303 :
92304 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
92305 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
92306 : pointers are not yet implemented to call delete on eash pointer in the container.
92307 : (This could be done by derivation from the STL containers to define containers that
92308 : automatically deleted their members.)
92309 :
92310 : */
92311 0 : SgOmpRelaxedClause::~SgOmpRelaxedClause () {
92312 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
92313 :
92314 :
92315 :
92316 : }
92317 :
92318 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92319 0 : }
92320 :
92321 :
92322 : /* #line 92323 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92323 :
92324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
92325 :
92326 : // Generated constructor
92327 0 : SgOmpRelaxedClause::SgOmpRelaxedClause ( Sg_File_Info* startOfConstruct )
92328 0 : : SgOmpClause(startOfConstruct)
92329 : {
92330 : #ifdef DEBUG
92331 : // printf ("In SgOmpRelaxedClause::SgOmpRelaxedClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
92332 : #endif
92333 : #if 0
92334 : // debugging information!
92335 : printf ("In SgOmpRelaxedClause::SgOmpRelaxedClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
92336 : #endif
92337 :
92338 :
92339 :
92340 : #if 0
92341 : // DQ (7/30/2014): Call a virtual function.
92342 : std::string s = this->class_name();
92343 : #endif
92344 :
92345 : // Test the variant virtual function
92346 : // assert(OmpRelaxedClauseTag == variant());
92347 0 : assert(OmpRelaxedClauseTag == this->variant());
92348 0 : ROSE_ASSERT(OmpRelaxedClauseTag == (int)(this->variantT()));
92349 0 : post_construction_initialization();
92350 :
92351 : // Test the isSgOmpRelaxedClause() function since it has been problematic
92352 0 : assert(isSgOmpRelaxedClause(this) != NULL);
92353 0 : }
92354 :
92355 : // Generated constructor (all data members)
92356 :
92357 : /* #line 92358 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92358 :
92359 :
92360 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92361 :
92362 :
92363 : // ********************************************************
92364 : // member functions common across all array grammar objects
92365 : // ********************************************************
92366 :
92367 :
92368 :
92369 : /* #line 92370 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92370 :
92371 :
92372 :
92373 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92374 :
92375 : // ********************************************************
92376 : // member functions specific to each node in the grammar
92377 : // ********************************************************
92378 :
92379 :
92380 : /* #line 92381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92381 :
92382 : // Start of memberFunctionString
92383 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
92384 :
92385 : // *** COMMON CODE SECTION BEGINS HERE ***
92386 :
92387 : #if 0
92388 : int
92389 : SgOmpReverseOffloadClause::getVariant() const
92390 : {
92391 : // This function is used in ROSE while "variant()" is used in SAGE
92392 : assert(this != NULL);
92393 : return variant();
92394 : }
92395 : #endif
92396 :
92397 : // This function is used in ROSE in treeTraversal code
92398 : // eventually replaces getVariant() and variant()
92399 : // though after variant() has been removed for a while we will
92400 : // want to change the name of variantT() back to variant()
92401 : // (since the "T" was ment to stand for temporary).
92402 : // When this happens the variantT() will be depricated.
92403 : VariantT
92404 102 : SgOmpReverseOffloadClause::variantT() const
92405 : {
92406 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
92407 102 : ROSE_ASSERT(this != NULL);
92408 102 : return V_SgOmpReverseOffloadClause;
92409 : }
92410 :
92411 : #if 0
92412 : int
92413 : SgOmpReverseOffloadClause::variant() const
92414 : {
92415 : // This function is used in SAGE
92416 : ROSE_ASSERT(this != NULL);
92417 : return OmpReverseOffloadClauseTag;
92418 : }
92419 : #endif
92420 :
92421 : ROSE_DLL_API const char*
92422 0 : SgOmpReverseOffloadClause::sage_class_name() const
92423 : {
92424 0 : ROSE_ASSERT(this != NULL);
92425 0 : return "SgOmpReverseOffloadClause";
92426 : }
92427 :
92428 : std::string
92429 2 : SgOmpReverseOffloadClause::class_name() const
92430 : {
92431 2 : ROSE_ASSERT(this != NULL);
92432 2 : return "SgOmpReverseOffloadClause";
92433 : }
92434 :
92435 : // DQ (11/26/2005): Support for visitor pattern mechanims
92436 : // (inferior to ROSE traversal mechanism, experimental).
92437 : void
92438 0 : SgOmpReverseOffloadClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
92439 : {
92440 0 : ROSE_ASSERT(this != NULL);
92441 0 : visitor.visit(this);
92442 0 : }
92443 :
92444 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
92445 0 : void SgOmpReverseOffloadClause::accept (ROSE_VisitorPattern & visitor) {
92446 0 : ROSE_ASSERT(this != NULL);
92447 0 : visitor.visit(this);
92448 0 : }
92449 :
92450 : SgOmpReverseOffloadClause*
92451 0 : SgOmpReverseOffloadClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
92452 : {
92453 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
92454 : // This function is currently only supported for the AST used the represent Binary executables.
92455 : if (0 /* isSgAsmNode(this) != NULL */)
92456 : {
92457 : // Support for regex specification.
92458 : std::string prefixCode = "REGEX:";
92459 : addNewAttribute(prefixCode + s,a);
92460 : }
92461 : #endif
92462 :
92463 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
92464 0 : return this;
92465 : }
92466 :
92467 : // *** COMMON CODE SECTION ENDS HERE ***
92468 :
92469 :
92470 : // End of memberFunctionString
92471 : // Start of memberFunctionString
92472 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
92473 :
92474 :
92475 : #if 0
92476 : //! Error checking support
92477 : /*! Verifies the following:
92478 : - working getVariant() member function
92479 : - calls base class's error() member function
92480 : Every class has one of these functions.
92481 : */
92482 : bool
92483 : SgOmpReverseOffloadClause::error()
92484 : {
92485 : // Put error checking here
92486 :
92487 : ROSE_ASSERT (this != NULL);
92488 : if (getVariant() != OmpReverseOffloadClauseTag)
92489 : {
92490 : printf ("Error in SgOmpReverseOffloadClause::error(): SgOmpReverseOffloadClause object has a %s variant \n",
92491 : Cxx_GrammarTerminalNames[getVariant()].name);
92492 : // printf ("Error in SgOmpReverseOffloadClause::error() \n");
92493 : ROSE_ABORT();
92494 : }
92495 :
92496 : ROSE_ASSERT (getVariant() == OmpReverseOffloadClauseTag);
92497 : return SgOmpClause::error();
92498 : }
92499 : #endif
92500 :
92501 :
92502 :
92503 : // End of memberFunctionString
92504 :
92505 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
92506 :
92507 2 : SgOmpReverseOffloadClause* isSgOmpReverseOffloadClause ( SgNode* inputDerivedClassPointer )
92508 : {
92509 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92510 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92511 : // So to fix this we return NULL directly when the input is NULL and avoid the
92512 : // dynamic_cast in this case. This is likely a performance improvement as well.
92513 : // return dynamic_cast<SgOmpReverseOffloadClause*>(inputDerivedClassPointer);
92514 : // Milind Chabbi (8/28/2013): isSgOmpReverseOffloadClause uses table-driven castability instead of c++ default dynamic_cast
92515 : // this improves the running time performance by 10-20%.
92516 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpReverseOffloadClause*>(inputDerivedClassPointer);
92517 2 : return IS_SgOmpReverseOffloadClause_FAST_MACRO(inputDerivedClassPointer);
92518 : }
92519 :
92520 : // DQ (11/8/2003): Added version of functions taking const pointer
92521 0 : const SgOmpReverseOffloadClause* isSgOmpReverseOffloadClause ( const SgNode* inputDerivedClassPointer )
92522 : {
92523 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92524 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92525 : // So to fix this we return NULL directly when the input is NULL and avoid the
92526 : // dynamic_cast in this case. This is likely a performance improvement as well.
92527 : // return dynamic_cast<const SgOmpReverseOffloadClause*>(inputDerivedClassPointer);
92528 : // Milind Chabbi (8/28/2013): isSgOmpReverseOffloadClause uses table-driven castability instead of c++ default dynamic_cast
92529 : // this improves the running time performance by 10-20%.
92530 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpReverseOffloadClause*>(inputDerivedClassPointer);
92531 0 : return IS_SgOmpReverseOffloadClause_FAST_MACRO(inputDerivedClassPointer);
92532 : }
92533 :
92534 :
92535 :
92536 : /* #line 92537 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92537 :
92538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92539 :
92540 : /**
92541 : \brief Generated destructor
92542 :
92543 : This destructor is automatically generated (by ROSETTA). This destructor
92544 : only frees memory of data members associated with the parts of the current IR node which
92545 : are NOT traversed. Those data members that are part of a traversal can be freed using
92546 : a traversal (calling this destructor on all children in a post-order traversal). Such
92547 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
92548 :
92549 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
92550 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
92551 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
92552 :
92553 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
92554 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
92555 : pointers are not yet implemented to call delete on eash pointer in the container.
92556 : (This could be done by derivation from the STL containers to define containers that
92557 : automatically deleted their members.)
92558 :
92559 : */
92560 0 : SgOmpReverseOffloadClause::~SgOmpReverseOffloadClause () {
92561 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
92562 :
92563 :
92564 :
92565 : }
92566 :
92567 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92568 0 : }
92569 :
92570 :
92571 : /* #line 92572 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92572 :
92573 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
92574 :
92575 : // Generated constructor
92576 0 : SgOmpReverseOffloadClause::SgOmpReverseOffloadClause ( Sg_File_Info* startOfConstruct )
92577 0 : : SgOmpClause(startOfConstruct)
92578 : {
92579 : #ifdef DEBUG
92580 : // printf ("In SgOmpReverseOffloadClause::SgOmpReverseOffloadClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
92581 : #endif
92582 : #if 0
92583 : // debugging information!
92584 : printf ("In SgOmpReverseOffloadClause::SgOmpReverseOffloadClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
92585 : #endif
92586 :
92587 :
92588 :
92589 : #if 0
92590 : // DQ (7/30/2014): Call a virtual function.
92591 : std::string s = this->class_name();
92592 : #endif
92593 :
92594 : // Test the variant virtual function
92595 : // assert(OmpReverseOffloadClauseTag == variant());
92596 0 : assert(OmpReverseOffloadClauseTag == this->variant());
92597 0 : ROSE_ASSERT(OmpReverseOffloadClauseTag == (int)(this->variantT()));
92598 0 : post_construction_initialization();
92599 :
92600 : // Test the isSgOmpReverseOffloadClause() function since it has been problematic
92601 0 : assert(isSgOmpReverseOffloadClause(this) != NULL);
92602 0 : }
92603 :
92604 : // Generated constructor (all data members)
92605 :
92606 : /* #line 92607 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92607 :
92608 :
92609 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92610 :
92611 :
92612 : // ********************************************************
92613 : // member functions common across all array grammar objects
92614 : // ********************************************************
92615 :
92616 :
92617 :
92618 : /* #line 92619 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92619 :
92620 :
92621 :
92622 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92623 :
92624 : // ********************************************************
92625 : // member functions specific to each node in the grammar
92626 : // ********************************************************
92627 :
92628 :
92629 : /* #line 92630 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92630 :
92631 : // Start of memberFunctionString
92632 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
92633 :
92634 : // *** COMMON CODE SECTION BEGINS HERE ***
92635 :
92636 : #if 0
92637 : int
92638 : SgOmpUnifiedAddressClause::getVariant() const
92639 : {
92640 : // This function is used in ROSE while "variant()" is used in SAGE
92641 : assert(this != NULL);
92642 : return variant();
92643 : }
92644 : #endif
92645 :
92646 : // This function is used in ROSE in treeTraversal code
92647 : // eventually replaces getVariant() and variant()
92648 : // though after variant() has been removed for a while we will
92649 : // want to change the name of variantT() back to variant()
92650 : // (since the "T" was ment to stand for temporary).
92651 : // When this happens the variantT() will be depricated.
92652 : VariantT
92653 51 : SgOmpUnifiedAddressClause::variantT() const
92654 : {
92655 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
92656 51 : ROSE_ASSERT(this != NULL);
92657 51 : return V_SgOmpUnifiedAddressClause;
92658 : }
92659 :
92660 : #if 0
92661 : int
92662 : SgOmpUnifiedAddressClause::variant() const
92663 : {
92664 : // This function is used in SAGE
92665 : ROSE_ASSERT(this != NULL);
92666 : return OmpUnifiedAddressClauseTag;
92667 : }
92668 : #endif
92669 :
92670 : ROSE_DLL_API const char*
92671 0 : SgOmpUnifiedAddressClause::sage_class_name() const
92672 : {
92673 0 : ROSE_ASSERT(this != NULL);
92674 0 : return "SgOmpUnifiedAddressClause";
92675 : }
92676 :
92677 : std::string
92678 1 : SgOmpUnifiedAddressClause::class_name() const
92679 : {
92680 1 : ROSE_ASSERT(this != NULL);
92681 1 : return "SgOmpUnifiedAddressClause";
92682 : }
92683 :
92684 : // DQ (11/26/2005): Support for visitor pattern mechanims
92685 : // (inferior to ROSE traversal mechanism, experimental).
92686 : void
92687 0 : SgOmpUnifiedAddressClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
92688 : {
92689 0 : ROSE_ASSERT(this != NULL);
92690 0 : visitor.visit(this);
92691 0 : }
92692 :
92693 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
92694 0 : void SgOmpUnifiedAddressClause::accept (ROSE_VisitorPattern & visitor) {
92695 0 : ROSE_ASSERT(this != NULL);
92696 0 : visitor.visit(this);
92697 0 : }
92698 :
92699 : SgOmpUnifiedAddressClause*
92700 0 : SgOmpUnifiedAddressClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
92701 : {
92702 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
92703 : // This function is currently only supported for the AST used the represent Binary executables.
92704 : if (0 /* isSgAsmNode(this) != NULL */)
92705 : {
92706 : // Support for regex specification.
92707 : std::string prefixCode = "REGEX:";
92708 : addNewAttribute(prefixCode + s,a);
92709 : }
92710 : #endif
92711 :
92712 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
92713 0 : return this;
92714 : }
92715 :
92716 : // *** COMMON CODE SECTION ENDS HERE ***
92717 :
92718 :
92719 : // End of memberFunctionString
92720 : // Start of memberFunctionString
92721 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
92722 :
92723 :
92724 : #if 0
92725 : //! Error checking support
92726 : /*! Verifies the following:
92727 : - working getVariant() member function
92728 : - calls base class's error() member function
92729 : Every class has one of these functions.
92730 : */
92731 : bool
92732 : SgOmpUnifiedAddressClause::error()
92733 : {
92734 : // Put error checking here
92735 :
92736 : ROSE_ASSERT (this != NULL);
92737 : if (getVariant() != OmpUnifiedAddressClauseTag)
92738 : {
92739 : printf ("Error in SgOmpUnifiedAddressClause::error(): SgOmpUnifiedAddressClause object has a %s variant \n",
92740 : Cxx_GrammarTerminalNames[getVariant()].name);
92741 : // printf ("Error in SgOmpUnifiedAddressClause::error() \n");
92742 : ROSE_ABORT();
92743 : }
92744 :
92745 : ROSE_ASSERT (getVariant() == OmpUnifiedAddressClauseTag);
92746 : return SgOmpClause::error();
92747 : }
92748 : #endif
92749 :
92750 :
92751 :
92752 : // End of memberFunctionString
92753 :
92754 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
92755 :
92756 1 : SgOmpUnifiedAddressClause* isSgOmpUnifiedAddressClause ( SgNode* inputDerivedClassPointer )
92757 : {
92758 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92759 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92760 : // So to fix this we return NULL directly when the input is NULL and avoid the
92761 : // dynamic_cast in this case. This is likely a performance improvement as well.
92762 : // return dynamic_cast<SgOmpUnifiedAddressClause*>(inputDerivedClassPointer);
92763 : // Milind Chabbi (8/28/2013): isSgOmpUnifiedAddressClause uses table-driven castability instead of c++ default dynamic_cast
92764 : // this improves the running time performance by 10-20%.
92765 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUnifiedAddressClause*>(inputDerivedClassPointer);
92766 1 : return IS_SgOmpUnifiedAddressClause_FAST_MACRO(inputDerivedClassPointer);
92767 : }
92768 :
92769 : // DQ (11/8/2003): Added version of functions taking const pointer
92770 0 : const SgOmpUnifiedAddressClause* isSgOmpUnifiedAddressClause ( const SgNode* inputDerivedClassPointer )
92771 : {
92772 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
92773 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
92774 : // So to fix this we return NULL directly when the input is NULL and avoid the
92775 : // dynamic_cast in this case. This is likely a performance improvement as well.
92776 : // return dynamic_cast<const SgOmpUnifiedAddressClause*>(inputDerivedClassPointer);
92777 : // Milind Chabbi (8/28/2013): isSgOmpUnifiedAddressClause uses table-driven castability instead of c++ default dynamic_cast
92778 : // this improves the running time performance by 10-20%.
92779 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUnifiedAddressClause*>(inputDerivedClassPointer);
92780 0 : return IS_SgOmpUnifiedAddressClause_FAST_MACRO(inputDerivedClassPointer);
92781 : }
92782 :
92783 :
92784 :
92785 : /* #line 92786 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92786 :
92787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92788 :
92789 : /**
92790 : \brief Generated destructor
92791 :
92792 : This destructor is automatically generated (by ROSETTA). This destructor
92793 : only frees memory of data members associated with the parts of the current IR node which
92794 : are NOT traversed. Those data members that are part of a traversal can be freed using
92795 : a traversal (calling this destructor on all children in a post-order traversal). Such
92796 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
92797 :
92798 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
92799 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
92800 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
92801 :
92802 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
92803 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
92804 : pointers are not yet implemented to call delete on eash pointer in the container.
92805 : (This could be done by derivation from the STL containers to define containers that
92806 : automatically deleted their members.)
92807 :
92808 : */
92809 0 : SgOmpUnifiedAddressClause::~SgOmpUnifiedAddressClause () {
92810 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
92811 :
92812 :
92813 :
92814 : }
92815 :
92816 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
92817 0 : }
92818 :
92819 :
92820 : /* #line 92821 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92821 :
92822 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
92823 :
92824 : // Generated constructor
92825 0 : SgOmpUnifiedAddressClause::SgOmpUnifiedAddressClause ( Sg_File_Info* startOfConstruct )
92826 0 : : SgOmpClause(startOfConstruct)
92827 : {
92828 : #ifdef DEBUG
92829 : // printf ("In SgOmpUnifiedAddressClause::SgOmpUnifiedAddressClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
92830 : #endif
92831 : #if 0
92832 : // debugging information!
92833 : printf ("In SgOmpUnifiedAddressClause::SgOmpUnifiedAddressClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
92834 : #endif
92835 :
92836 :
92837 :
92838 : #if 0
92839 : // DQ (7/30/2014): Call a virtual function.
92840 : std::string s = this->class_name();
92841 : #endif
92842 :
92843 : // Test the variant virtual function
92844 : // assert(OmpUnifiedAddressClauseTag == variant());
92845 0 : assert(OmpUnifiedAddressClauseTag == this->variant());
92846 0 : ROSE_ASSERT(OmpUnifiedAddressClauseTag == (int)(this->variantT()));
92847 0 : post_construction_initialization();
92848 :
92849 : // Test the isSgOmpUnifiedAddressClause() function since it has been problematic
92850 0 : assert(isSgOmpUnifiedAddressClause(this) != NULL);
92851 0 : }
92852 :
92853 : // Generated constructor (all data members)
92854 :
92855 : /* #line 92856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92856 :
92857 :
92858 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92859 :
92860 :
92861 : // ********************************************************
92862 : // member functions common across all array grammar objects
92863 : // ********************************************************
92864 :
92865 :
92866 :
92867 : /* #line 92868 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92868 :
92869 :
92870 :
92871 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
92872 :
92873 : // ********************************************************
92874 : // member functions specific to each node in the grammar
92875 : // ********************************************************
92876 :
92877 :
92878 : /* #line 92879 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
92879 :
92880 : // Start of memberFunctionString
92881 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
92882 :
92883 : // *** COMMON CODE SECTION BEGINS HERE ***
92884 :
92885 : #if 0
92886 : int
92887 : SgOmpUnifiedSharedMemoryClause::getVariant() const
92888 : {
92889 : // This function is used in ROSE while "variant()" is used in SAGE
92890 : assert(this != NULL);
92891 : return variant();
92892 : }
92893 : #endif
92894 :
92895 : // This function is used in ROSE in treeTraversal code
92896 : // eventually replaces getVariant() and variant()
92897 : // though after variant() has been removed for a while we will
92898 : // want to change the name of variantT() back to variant()
92899 : // (since the "T" was ment to stand for temporary).
92900 : // When this happens the variantT() will be depricated.
92901 : VariantT
92902 51 : SgOmpUnifiedSharedMemoryClause::variantT() const
92903 : {
92904 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
92905 51 : ROSE_ASSERT(this != NULL);
92906 51 : return V_SgOmpUnifiedSharedMemoryClause;
92907 : }
92908 :
92909 : #if 0
92910 : int
92911 : SgOmpUnifiedSharedMemoryClause::variant() const
92912 : {
92913 : // This function is used in SAGE
92914 : ROSE_ASSERT(this != NULL);
92915 : return OmpUnifiedSharedMemoryClauseTag;
92916 : }
92917 : #endif
92918 :
92919 : ROSE_DLL_API const char*
92920 0 : SgOmpUnifiedSharedMemoryClause::sage_class_name() const
92921 : {
92922 0 : ROSE_ASSERT(this != NULL);
92923 0 : return "SgOmpUnifiedSharedMemoryClause";
92924 : }
92925 :
92926 : std::string
92927 1 : SgOmpUnifiedSharedMemoryClause::class_name() const
92928 : {
92929 1 : ROSE_ASSERT(this != NULL);
92930 1 : return "SgOmpUnifiedSharedMemoryClause";
92931 : }
92932 :
92933 : // DQ (11/26/2005): Support for visitor pattern mechanims
92934 : // (inferior to ROSE traversal mechanism, experimental).
92935 : void
92936 0 : SgOmpUnifiedSharedMemoryClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
92937 : {
92938 0 : ROSE_ASSERT(this != NULL);
92939 0 : visitor.visit(this);
92940 0 : }
92941 :
92942 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
92943 0 : void SgOmpUnifiedSharedMemoryClause::accept (ROSE_VisitorPattern & visitor) {
92944 0 : ROSE_ASSERT(this != NULL);
92945 0 : visitor.visit(this);
92946 0 : }
92947 :
92948 : SgOmpUnifiedSharedMemoryClause*
92949 0 : SgOmpUnifiedSharedMemoryClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
92950 : {
92951 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
92952 : // This function is currently only supported for the AST used the represent Binary executables.
92953 : if (0 /* isSgAsmNode(this) != NULL */)
92954 : {
92955 : // Support for regex specification.
92956 : std::string prefixCode = "REGEX:";
92957 : addNewAttribute(prefixCode + s,a);
92958 : }
92959 : #endif
92960 :
92961 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
92962 0 : return this;
92963 : }
92964 :
92965 : // *** COMMON CODE SECTION ENDS HERE ***
92966 :
92967 :
92968 : // End of memberFunctionString
92969 : // Start of memberFunctionString
92970 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
92971 :
92972 :
92973 : #if 0
92974 : //! Error checking support
92975 : /*! Verifies the following:
92976 : - working getVariant() member function
92977 : - calls base class's error() member function
92978 : Every class has one of these functions.
92979 : */
92980 : bool
92981 : SgOmpUnifiedSharedMemoryClause::error()
92982 : {
92983 : // Put error checking here
92984 :
92985 : ROSE_ASSERT (this != NULL);
92986 : if (getVariant() != OmpUnifiedSharedMemoryClauseTag)
92987 : {
92988 : printf ("Error in SgOmpUnifiedSharedMemoryClause::error(): SgOmpUnifiedSharedMemoryClause object has a %s variant \n",
92989 : Cxx_GrammarTerminalNames[getVariant()].name);
92990 : // printf ("Error in SgOmpUnifiedSharedMemoryClause::error() \n");
92991 : ROSE_ABORT();
92992 : }
92993 :
92994 : ROSE_ASSERT (getVariant() == OmpUnifiedSharedMemoryClauseTag);
92995 : return SgOmpClause::error();
92996 : }
92997 : #endif
92998 :
92999 :
93000 :
93001 : // End of memberFunctionString
93002 :
93003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
93004 :
93005 1 : SgOmpUnifiedSharedMemoryClause* isSgOmpUnifiedSharedMemoryClause ( SgNode* inputDerivedClassPointer )
93006 : {
93007 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93008 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93009 : // So to fix this we return NULL directly when the input is NULL and avoid the
93010 : // dynamic_cast in this case. This is likely a performance improvement as well.
93011 : // return dynamic_cast<SgOmpUnifiedSharedMemoryClause*>(inputDerivedClassPointer);
93012 : // Milind Chabbi (8/28/2013): isSgOmpUnifiedSharedMemoryClause uses table-driven castability instead of c++ default dynamic_cast
93013 : // this improves the running time performance by 10-20%.
93014 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUnifiedSharedMemoryClause*>(inputDerivedClassPointer);
93015 1 : return IS_SgOmpUnifiedSharedMemoryClause_FAST_MACRO(inputDerivedClassPointer);
93016 : }
93017 :
93018 : // DQ (11/8/2003): Added version of functions taking const pointer
93019 0 : const SgOmpUnifiedSharedMemoryClause* isSgOmpUnifiedSharedMemoryClause ( const SgNode* inputDerivedClassPointer )
93020 : {
93021 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93022 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93023 : // So to fix this we return NULL directly when the input is NULL and avoid the
93024 : // dynamic_cast in this case. This is likely a performance improvement as well.
93025 : // return dynamic_cast<const SgOmpUnifiedSharedMemoryClause*>(inputDerivedClassPointer);
93026 : // Milind Chabbi (8/28/2013): isSgOmpUnifiedSharedMemoryClause uses table-driven castability instead of c++ default dynamic_cast
93027 : // this improves the running time performance by 10-20%.
93028 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUnifiedSharedMemoryClause*>(inputDerivedClassPointer);
93029 0 : return IS_SgOmpUnifiedSharedMemoryClause_FAST_MACRO(inputDerivedClassPointer);
93030 : }
93031 :
93032 :
93033 :
93034 : /* #line 93035 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93035 :
93036 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93037 :
93038 : /**
93039 : \brief Generated destructor
93040 :
93041 : This destructor is automatically generated (by ROSETTA). This destructor
93042 : only frees memory of data members associated with the parts of the current IR node which
93043 : are NOT traversed. Those data members that are part of a traversal can be freed using
93044 : a traversal (calling this destructor on all children in a post-order traversal). Such
93045 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
93046 :
93047 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
93048 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
93049 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
93050 :
93051 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
93052 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
93053 : pointers are not yet implemented to call delete on eash pointer in the container.
93054 : (This could be done by derivation from the STL containers to define containers that
93055 : automatically deleted their members.)
93056 :
93057 : */
93058 0 : SgOmpUnifiedSharedMemoryClause::~SgOmpUnifiedSharedMemoryClause () {
93059 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
93060 :
93061 :
93062 :
93063 : }
93064 :
93065 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93066 0 : }
93067 :
93068 :
93069 : /* #line 93070 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93070 :
93071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
93072 :
93073 : // Generated constructor
93074 0 : SgOmpUnifiedSharedMemoryClause::SgOmpUnifiedSharedMemoryClause ( Sg_File_Info* startOfConstruct )
93075 0 : : SgOmpClause(startOfConstruct)
93076 : {
93077 : #ifdef DEBUG
93078 : // printf ("In SgOmpUnifiedSharedMemoryClause::SgOmpUnifiedSharedMemoryClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
93079 : #endif
93080 : #if 0
93081 : // debugging information!
93082 : printf ("In SgOmpUnifiedSharedMemoryClause::SgOmpUnifiedSharedMemoryClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
93083 : #endif
93084 :
93085 :
93086 :
93087 : #if 0
93088 : // DQ (7/30/2014): Call a virtual function.
93089 : std::string s = this->class_name();
93090 : #endif
93091 :
93092 : // Test the variant virtual function
93093 : // assert(OmpUnifiedSharedMemoryClauseTag == variant());
93094 0 : assert(OmpUnifiedSharedMemoryClauseTag == this->variant());
93095 0 : ROSE_ASSERT(OmpUnifiedSharedMemoryClauseTag == (int)(this->variantT()));
93096 0 : post_construction_initialization();
93097 :
93098 : // Test the isSgOmpUnifiedSharedMemoryClause() function since it has been problematic
93099 0 : assert(isSgOmpUnifiedSharedMemoryClause(this) != NULL);
93100 0 : }
93101 :
93102 : // Generated constructor (all data members)
93103 :
93104 : /* #line 93105 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93105 :
93106 :
93107 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93108 :
93109 :
93110 : // ********************************************************
93111 : // member functions common across all array grammar objects
93112 : // ********************************************************
93113 :
93114 :
93115 :
93116 : /* #line 93117 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93117 :
93118 :
93119 :
93120 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93121 :
93122 : // ********************************************************
93123 : // member functions specific to each node in the grammar
93124 : // ********************************************************
93125 :
93126 :
93127 : /* #line 93128 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93128 :
93129 : // Start of memberFunctionString
93130 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
93131 :
93132 : // *** COMMON CODE SECTION BEGINS HERE ***
93133 :
93134 : #if 0
93135 : int
93136 : SgOmpDynamicAllocatorsClause::getVariant() const
93137 : {
93138 : // This function is used in ROSE while "variant()" is used in SAGE
93139 : assert(this != NULL);
93140 : return variant();
93141 : }
93142 : #endif
93143 :
93144 : // This function is used in ROSE in treeTraversal code
93145 : // eventually replaces getVariant() and variant()
93146 : // though after variant() has been removed for a while we will
93147 : // want to change the name of variantT() back to variant()
93148 : // (since the "T" was ment to stand for temporary).
93149 : // When this happens the variantT() will be depricated.
93150 : VariantT
93151 51 : SgOmpDynamicAllocatorsClause::variantT() const
93152 : {
93153 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
93154 51 : ROSE_ASSERT(this != NULL);
93155 51 : return V_SgOmpDynamicAllocatorsClause;
93156 : }
93157 :
93158 : #if 0
93159 : int
93160 : SgOmpDynamicAllocatorsClause::variant() const
93161 : {
93162 : // This function is used in SAGE
93163 : ROSE_ASSERT(this != NULL);
93164 : return OmpDynamicAllocatorsClauseTag;
93165 : }
93166 : #endif
93167 :
93168 : ROSE_DLL_API const char*
93169 0 : SgOmpDynamicAllocatorsClause::sage_class_name() const
93170 : {
93171 0 : ROSE_ASSERT(this != NULL);
93172 0 : return "SgOmpDynamicAllocatorsClause";
93173 : }
93174 :
93175 : std::string
93176 1 : SgOmpDynamicAllocatorsClause::class_name() const
93177 : {
93178 1 : ROSE_ASSERT(this != NULL);
93179 1 : return "SgOmpDynamicAllocatorsClause";
93180 : }
93181 :
93182 : // DQ (11/26/2005): Support for visitor pattern mechanims
93183 : // (inferior to ROSE traversal mechanism, experimental).
93184 : void
93185 0 : SgOmpDynamicAllocatorsClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
93186 : {
93187 0 : ROSE_ASSERT(this != NULL);
93188 0 : visitor.visit(this);
93189 0 : }
93190 :
93191 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
93192 0 : void SgOmpDynamicAllocatorsClause::accept (ROSE_VisitorPattern & visitor) {
93193 0 : ROSE_ASSERT(this != NULL);
93194 0 : visitor.visit(this);
93195 0 : }
93196 :
93197 : SgOmpDynamicAllocatorsClause*
93198 0 : SgOmpDynamicAllocatorsClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
93199 : {
93200 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
93201 : // This function is currently only supported for the AST used the represent Binary executables.
93202 : if (0 /* isSgAsmNode(this) != NULL */)
93203 : {
93204 : // Support for regex specification.
93205 : std::string prefixCode = "REGEX:";
93206 : addNewAttribute(prefixCode + s,a);
93207 : }
93208 : #endif
93209 :
93210 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
93211 0 : return this;
93212 : }
93213 :
93214 : // *** COMMON CODE SECTION ENDS HERE ***
93215 :
93216 :
93217 : // End of memberFunctionString
93218 : // Start of memberFunctionString
93219 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
93220 :
93221 :
93222 : #if 0
93223 : //! Error checking support
93224 : /*! Verifies the following:
93225 : - working getVariant() member function
93226 : - calls base class's error() member function
93227 : Every class has one of these functions.
93228 : */
93229 : bool
93230 : SgOmpDynamicAllocatorsClause::error()
93231 : {
93232 : // Put error checking here
93233 :
93234 : ROSE_ASSERT (this != NULL);
93235 : if (getVariant() != OmpDynamicAllocatorsClauseTag)
93236 : {
93237 : printf ("Error in SgOmpDynamicAllocatorsClause::error(): SgOmpDynamicAllocatorsClause object has a %s variant \n",
93238 : Cxx_GrammarTerminalNames[getVariant()].name);
93239 : // printf ("Error in SgOmpDynamicAllocatorsClause::error() \n");
93240 : ROSE_ABORT();
93241 : }
93242 :
93243 : ROSE_ASSERT (getVariant() == OmpDynamicAllocatorsClauseTag);
93244 : return SgOmpClause::error();
93245 : }
93246 : #endif
93247 :
93248 :
93249 :
93250 : // End of memberFunctionString
93251 :
93252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
93253 :
93254 1 : SgOmpDynamicAllocatorsClause* isSgOmpDynamicAllocatorsClause ( SgNode* inputDerivedClassPointer )
93255 : {
93256 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93257 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93258 : // So to fix this we return NULL directly when the input is NULL and avoid the
93259 : // dynamic_cast in this case. This is likely a performance improvement as well.
93260 : // return dynamic_cast<SgOmpDynamicAllocatorsClause*>(inputDerivedClassPointer);
93261 : // Milind Chabbi (8/28/2013): isSgOmpDynamicAllocatorsClause uses table-driven castability instead of c++ default dynamic_cast
93262 : // this improves the running time performance by 10-20%.
93263 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDynamicAllocatorsClause*>(inputDerivedClassPointer);
93264 1 : return IS_SgOmpDynamicAllocatorsClause_FAST_MACRO(inputDerivedClassPointer);
93265 : }
93266 :
93267 : // DQ (11/8/2003): Added version of functions taking const pointer
93268 0 : const SgOmpDynamicAllocatorsClause* isSgOmpDynamicAllocatorsClause ( const SgNode* inputDerivedClassPointer )
93269 : {
93270 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93271 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93272 : // So to fix this we return NULL directly when the input is NULL and avoid the
93273 : // dynamic_cast in this case. This is likely a performance improvement as well.
93274 : // return dynamic_cast<const SgOmpDynamicAllocatorsClause*>(inputDerivedClassPointer);
93275 : // Milind Chabbi (8/28/2013): isSgOmpDynamicAllocatorsClause uses table-driven castability instead of c++ default dynamic_cast
93276 : // this improves the running time performance by 10-20%.
93277 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDynamicAllocatorsClause*>(inputDerivedClassPointer);
93278 0 : return IS_SgOmpDynamicAllocatorsClause_FAST_MACRO(inputDerivedClassPointer);
93279 : }
93280 :
93281 :
93282 :
93283 : /* #line 93284 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93284 :
93285 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93286 :
93287 : /**
93288 : \brief Generated destructor
93289 :
93290 : This destructor is automatically generated (by ROSETTA). This destructor
93291 : only frees memory of data members associated with the parts of the current IR node which
93292 : are NOT traversed. Those data members that are part of a traversal can be freed using
93293 : a traversal (calling this destructor on all children in a post-order traversal). Such
93294 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
93295 :
93296 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
93297 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
93298 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
93299 :
93300 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
93301 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
93302 : pointers are not yet implemented to call delete on eash pointer in the container.
93303 : (This could be done by derivation from the STL containers to define containers that
93304 : automatically deleted their members.)
93305 :
93306 : */
93307 0 : SgOmpDynamicAllocatorsClause::~SgOmpDynamicAllocatorsClause () {
93308 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
93309 :
93310 :
93311 :
93312 : }
93313 :
93314 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93315 0 : }
93316 :
93317 :
93318 : /* #line 93319 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93319 :
93320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
93321 :
93322 : // Generated constructor
93323 0 : SgOmpDynamicAllocatorsClause::SgOmpDynamicAllocatorsClause ( Sg_File_Info* startOfConstruct )
93324 0 : : SgOmpClause(startOfConstruct)
93325 : {
93326 : #ifdef DEBUG
93327 : // printf ("In SgOmpDynamicAllocatorsClause::SgOmpDynamicAllocatorsClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
93328 : #endif
93329 : #if 0
93330 : // debugging information!
93331 : printf ("In SgOmpDynamicAllocatorsClause::SgOmpDynamicAllocatorsClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
93332 : #endif
93333 :
93334 :
93335 :
93336 : #if 0
93337 : // DQ (7/30/2014): Call a virtual function.
93338 : std::string s = this->class_name();
93339 : #endif
93340 :
93341 : // Test the variant virtual function
93342 : // assert(OmpDynamicAllocatorsClauseTag == variant());
93343 0 : assert(OmpDynamicAllocatorsClauseTag == this->variant());
93344 0 : ROSE_ASSERT(OmpDynamicAllocatorsClauseTag == (int)(this->variantT()));
93345 0 : post_construction_initialization();
93346 :
93347 : // Test the isSgOmpDynamicAllocatorsClause() function since it has been problematic
93348 0 : assert(isSgOmpDynamicAllocatorsClause(this) != NULL);
93349 0 : }
93350 :
93351 : // Generated constructor (all data members)
93352 :
93353 : /* #line 93354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93354 :
93355 :
93356 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93357 :
93358 :
93359 : // ********************************************************
93360 : // member functions common across all array grammar objects
93361 : // ********************************************************
93362 :
93363 :
93364 :
93365 : /* #line 93366 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93366 :
93367 :
93368 :
93369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93370 :
93371 : // ********************************************************
93372 : // member functions specific to each node in the grammar
93373 : // ********************************************************
93374 :
93375 :
93376 : /* #line 93377 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93377 :
93378 : // Start of memberFunctionString
93379 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
93380 :
93381 : // *** COMMON CODE SECTION BEGINS HERE ***
93382 :
93383 : #if 0
93384 : int
93385 : SgOmpParallelClause::getVariant() const
93386 : {
93387 : // This function is used in ROSE while "variant()" is used in SAGE
93388 : assert(this != NULL);
93389 : return variant();
93390 : }
93391 : #endif
93392 :
93393 : // This function is used in ROSE in treeTraversal code
93394 : // eventually replaces getVariant() and variant()
93395 : // though after variant() has been removed for a while we will
93396 : // want to change the name of variantT() back to variant()
93397 : // (since the "T" was ment to stand for temporary).
93398 : // When this happens the variantT() will be depricated.
93399 : VariantT
93400 52 : SgOmpParallelClause::variantT() const
93401 : {
93402 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
93403 52 : ROSE_ASSERT(this != NULL);
93404 52 : return V_SgOmpParallelClause;
93405 : }
93406 :
93407 : #if 0
93408 : int
93409 : SgOmpParallelClause::variant() const
93410 : {
93411 : // This function is used in SAGE
93412 : ROSE_ASSERT(this != NULL);
93413 : return OmpParallelClauseTag;
93414 : }
93415 : #endif
93416 :
93417 : ROSE_DLL_API const char*
93418 0 : SgOmpParallelClause::sage_class_name() const
93419 : {
93420 0 : ROSE_ASSERT(this != NULL);
93421 0 : return "SgOmpParallelClause";
93422 : }
93423 :
93424 : std::string
93425 2 : SgOmpParallelClause::class_name() const
93426 : {
93427 2 : ROSE_ASSERT(this != NULL);
93428 2 : return "SgOmpParallelClause";
93429 : }
93430 :
93431 : // DQ (11/26/2005): Support for visitor pattern mechanims
93432 : // (inferior to ROSE traversal mechanism, experimental).
93433 : void
93434 0 : SgOmpParallelClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
93435 : {
93436 0 : ROSE_ASSERT(this != NULL);
93437 0 : visitor.visit(this);
93438 0 : }
93439 :
93440 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
93441 0 : void SgOmpParallelClause::accept (ROSE_VisitorPattern & visitor) {
93442 0 : ROSE_ASSERT(this != NULL);
93443 0 : visitor.visit(this);
93444 0 : }
93445 :
93446 : SgOmpParallelClause*
93447 0 : SgOmpParallelClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
93448 : {
93449 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
93450 : // This function is currently only supported for the AST used the represent Binary executables.
93451 : if (0 /* isSgAsmNode(this) != NULL */)
93452 : {
93453 : // Support for regex specification.
93454 : std::string prefixCode = "REGEX:";
93455 : addNewAttribute(prefixCode + s,a);
93456 : }
93457 : #endif
93458 :
93459 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
93460 0 : return this;
93461 : }
93462 :
93463 : // *** COMMON CODE SECTION ENDS HERE ***
93464 :
93465 :
93466 : // End of memberFunctionString
93467 : // Start of memberFunctionString
93468 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
93469 :
93470 :
93471 : #if 0
93472 : //! Error checking support
93473 : /*! Verifies the following:
93474 : - working getVariant() member function
93475 : - calls base class's error() member function
93476 : Every class has one of these functions.
93477 : */
93478 : bool
93479 : SgOmpParallelClause::error()
93480 : {
93481 : // Put error checking here
93482 :
93483 : ROSE_ASSERT (this != NULL);
93484 : if (getVariant() != OmpParallelClauseTag)
93485 : {
93486 : printf ("Error in SgOmpParallelClause::error(): SgOmpParallelClause object has a %s variant \n",
93487 : Cxx_GrammarTerminalNames[getVariant()].name);
93488 : // printf ("Error in SgOmpParallelClause::error() \n");
93489 : ROSE_ABORT();
93490 : }
93491 :
93492 : ROSE_ASSERT (getVariant() == OmpParallelClauseTag);
93493 : return SgOmpClause::error();
93494 : }
93495 : #endif
93496 :
93497 :
93498 :
93499 : // End of memberFunctionString
93500 :
93501 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
93502 :
93503 2 : SgOmpParallelClause* isSgOmpParallelClause ( SgNode* inputDerivedClassPointer )
93504 : {
93505 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93506 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93507 : // So to fix this we return NULL directly when the input is NULL and avoid the
93508 : // dynamic_cast in this case. This is likely a performance improvement as well.
93509 : // return dynamic_cast<SgOmpParallelClause*>(inputDerivedClassPointer);
93510 : // Milind Chabbi (8/28/2013): isSgOmpParallelClause uses table-driven castability instead of c++ default dynamic_cast
93511 : // this improves the running time performance by 10-20%.
93512 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpParallelClause*>(inputDerivedClassPointer);
93513 2 : return IS_SgOmpParallelClause_FAST_MACRO(inputDerivedClassPointer);
93514 : }
93515 :
93516 : // DQ (11/8/2003): Added version of functions taking const pointer
93517 0 : const SgOmpParallelClause* isSgOmpParallelClause ( const SgNode* inputDerivedClassPointer )
93518 : {
93519 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93520 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93521 : // So to fix this we return NULL directly when the input is NULL and avoid the
93522 : // dynamic_cast in this case. This is likely a performance improvement as well.
93523 : // return dynamic_cast<const SgOmpParallelClause*>(inputDerivedClassPointer);
93524 : // Milind Chabbi (8/28/2013): isSgOmpParallelClause uses table-driven castability instead of c++ default dynamic_cast
93525 : // this improves the running time performance by 10-20%.
93526 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpParallelClause*>(inputDerivedClassPointer);
93527 0 : return IS_SgOmpParallelClause_FAST_MACRO(inputDerivedClassPointer);
93528 : }
93529 :
93530 :
93531 :
93532 : /* #line 93533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93533 :
93534 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93535 :
93536 : /**
93537 : \brief Generated destructor
93538 :
93539 : This destructor is automatically generated (by ROSETTA). This destructor
93540 : only frees memory of data members associated with the parts of the current IR node which
93541 : are NOT traversed. Those data members that are part of a traversal can be freed using
93542 : a traversal (calling this destructor on all children in a post-order traversal). Such
93543 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
93544 :
93545 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
93546 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
93547 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
93548 :
93549 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
93550 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
93551 : pointers are not yet implemented to call delete on eash pointer in the container.
93552 : (This could be done by derivation from the STL containers to define containers that
93553 : automatically deleted their members.)
93554 :
93555 : */
93556 0 : SgOmpParallelClause::~SgOmpParallelClause () {
93557 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
93558 :
93559 :
93560 :
93561 : }
93562 :
93563 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93564 0 : }
93565 :
93566 :
93567 : /* #line 93568 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93568 :
93569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
93570 :
93571 : // Generated constructor
93572 0 : SgOmpParallelClause::SgOmpParallelClause ( Sg_File_Info* startOfConstruct )
93573 0 : : SgOmpClause(startOfConstruct)
93574 : {
93575 : #ifdef DEBUG
93576 : // printf ("In SgOmpParallelClause::SgOmpParallelClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
93577 : #endif
93578 : #if 0
93579 : // debugging information!
93580 : printf ("In SgOmpParallelClause::SgOmpParallelClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
93581 : #endif
93582 :
93583 :
93584 :
93585 : #if 0
93586 : // DQ (7/30/2014): Call a virtual function.
93587 : std::string s = this->class_name();
93588 : #endif
93589 :
93590 : // Test the variant virtual function
93591 : // assert(OmpParallelClauseTag == variant());
93592 0 : assert(OmpParallelClauseTag == this->variant());
93593 0 : ROSE_ASSERT(OmpParallelClauseTag == (int)(this->variantT()));
93594 0 : post_construction_initialization();
93595 :
93596 : // Test the isSgOmpParallelClause() function since it has been problematic
93597 0 : assert(isSgOmpParallelClause(this) != NULL);
93598 0 : }
93599 :
93600 : // Generated constructor (all data members)
93601 :
93602 : /* #line 93603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93603 :
93604 :
93605 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93606 :
93607 :
93608 : // ********************************************************
93609 : // member functions common across all array grammar objects
93610 : // ********************************************************
93611 :
93612 :
93613 :
93614 : /* #line 93615 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93615 :
93616 :
93617 :
93618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93619 :
93620 : // ********************************************************
93621 : // member functions specific to each node in the grammar
93622 : // ********************************************************
93623 :
93624 :
93625 : /* #line 93626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93626 :
93627 : // Start of memberFunctionString
93628 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
93629 :
93630 : // *** COMMON CODE SECTION BEGINS HERE ***
93631 :
93632 : #if 0
93633 : int
93634 : SgOmpSectionsClause::getVariant() const
93635 : {
93636 : // This function is used in ROSE while "variant()" is used in SAGE
93637 : assert(this != NULL);
93638 : return variant();
93639 : }
93640 : #endif
93641 :
93642 : // This function is used in ROSE in treeTraversal code
93643 : // eventually replaces getVariant() and variant()
93644 : // though after variant() has been removed for a while we will
93645 : // want to change the name of variantT() back to variant()
93646 : // (since the "T" was ment to stand for temporary).
93647 : // When this happens the variantT() will be depricated.
93648 : VariantT
93649 0 : SgOmpSectionsClause::variantT() const
93650 : {
93651 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
93652 0 : ROSE_ASSERT(this != NULL);
93653 0 : return V_SgOmpSectionsClause;
93654 : }
93655 :
93656 : #if 0
93657 : int
93658 : SgOmpSectionsClause::variant() const
93659 : {
93660 : // This function is used in SAGE
93661 : ROSE_ASSERT(this != NULL);
93662 : return OmpSectionsClauseTag;
93663 : }
93664 : #endif
93665 :
93666 : ROSE_DLL_API const char*
93667 0 : SgOmpSectionsClause::sage_class_name() const
93668 : {
93669 0 : ROSE_ASSERT(this != NULL);
93670 0 : return "SgOmpSectionsClause";
93671 : }
93672 :
93673 : std::string
93674 0 : SgOmpSectionsClause::class_name() const
93675 : {
93676 0 : ROSE_ASSERT(this != NULL);
93677 0 : return "SgOmpSectionsClause";
93678 : }
93679 :
93680 : // DQ (11/26/2005): Support for visitor pattern mechanims
93681 : // (inferior to ROSE traversal mechanism, experimental).
93682 : void
93683 0 : SgOmpSectionsClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
93684 : {
93685 0 : ROSE_ASSERT(this != NULL);
93686 0 : visitor.visit(this);
93687 0 : }
93688 :
93689 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
93690 0 : void SgOmpSectionsClause::accept (ROSE_VisitorPattern & visitor) {
93691 0 : ROSE_ASSERT(this != NULL);
93692 0 : visitor.visit(this);
93693 0 : }
93694 :
93695 : SgOmpSectionsClause*
93696 0 : SgOmpSectionsClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
93697 : {
93698 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
93699 : // This function is currently only supported for the AST used the represent Binary executables.
93700 : if (0 /* isSgAsmNode(this) != NULL */)
93701 : {
93702 : // Support for regex specification.
93703 : std::string prefixCode = "REGEX:";
93704 : addNewAttribute(prefixCode + s,a);
93705 : }
93706 : #endif
93707 :
93708 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
93709 0 : return this;
93710 : }
93711 :
93712 : // *** COMMON CODE SECTION ENDS HERE ***
93713 :
93714 :
93715 : // End of memberFunctionString
93716 : // Start of memberFunctionString
93717 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
93718 :
93719 :
93720 : #if 0
93721 : //! Error checking support
93722 : /*! Verifies the following:
93723 : - working getVariant() member function
93724 : - calls base class's error() member function
93725 : Every class has one of these functions.
93726 : */
93727 : bool
93728 : SgOmpSectionsClause::error()
93729 : {
93730 : // Put error checking here
93731 :
93732 : ROSE_ASSERT (this != NULL);
93733 : if (getVariant() != OmpSectionsClauseTag)
93734 : {
93735 : printf ("Error in SgOmpSectionsClause::error(): SgOmpSectionsClause object has a %s variant \n",
93736 : Cxx_GrammarTerminalNames[getVariant()].name);
93737 : // printf ("Error in SgOmpSectionsClause::error() \n");
93738 : ROSE_ABORT();
93739 : }
93740 :
93741 : ROSE_ASSERT (getVariant() == OmpSectionsClauseTag);
93742 : return SgOmpClause::error();
93743 : }
93744 : #endif
93745 :
93746 :
93747 :
93748 : // End of memberFunctionString
93749 :
93750 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
93751 :
93752 0 : SgOmpSectionsClause* isSgOmpSectionsClause ( SgNode* inputDerivedClassPointer )
93753 : {
93754 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93755 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93756 : // So to fix this we return NULL directly when the input is NULL and avoid the
93757 : // dynamic_cast in this case. This is likely a performance improvement as well.
93758 : // return dynamic_cast<SgOmpSectionsClause*>(inputDerivedClassPointer);
93759 : // Milind Chabbi (8/28/2013): isSgOmpSectionsClause uses table-driven castability instead of c++ default dynamic_cast
93760 : // this improves the running time performance by 10-20%.
93761 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSectionsClause*>(inputDerivedClassPointer);
93762 0 : return IS_SgOmpSectionsClause_FAST_MACRO(inputDerivedClassPointer);
93763 : }
93764 :
93765 : // DQ (11/8/2003): Added version of functions taking const pointer
93766 0 : const SgOmpSectionsClause* isSgOmpSectionsClause ( const SgNode* inputDerivedClassPointer )
93767 : {
93768 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
93769 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
93770 : // So to fix this we return NULL directly when the input is NULL and avoid the
93771 : // dynamic_cast in this case. This is likely a performance improvement as well.
93772 : // return dynamic_cast<const SgOmpSectionsClause*>(inputDerivedClassPointer);
93773 : // Milind Chabbi (8/28/2013): isSgOmpSectionsClause uses table-driven castability instead of c++ default dynamic_cast
93774 : // this improves the running time performance by 10-20%.
93775 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSectionsClause*>(inputDerivedClassPointer);
93776 0 : return IS_SgOmpSectionsClause_FAST_MACRO(inputDerivedClassPointer);
93777 : }
93778 :
93779 :
93780 :
93781 : /* #line 93782 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93782 :
93783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93784 :
93785 : /**
93786 : \brief Generated destructor
93787 :
93788 : This destructor is automatically generated (by ROSETTA). This destructor
93789 : only frees memory of data members associated with the parts of the current IR node which
93790 : are NOT traversed. Those data members that are part of a traversal can be freed using
93791 : a traversal (calling this destructor on all children in a post-order traversal). Such
93792 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
93793 :
93794 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
93795 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
93796 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
93797 :
93798 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
93799 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
93800 : pointers are not yet implemented to call delete on eash pointer in the container.
93801 : (This could be done by derivation from the STL containers to define containers that
93802 : automatically deleted their members.)
93803 :
93804 : */
93805 0 : SgOmpSectionsClause::~SgOmpSectionsClause () {
93806 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
93807 :
93808 :
93809 :
93810 : }
93811 :
93812 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
93813 0 : }
93814 :
93815 :
93816 : /* #line 93817 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93817 :
93818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
93819 :
93820 : // Generated constructor
93821 0 : SgOmpSectionsClause::SgOmpSectionsClause ( Sg_File_Info* startOfConstruct )
93822 0 : : SgOmpClause(startOfConstruct)
93823 : {
93824 : #ifdef DEBUG
93825 : // printf ("In SgOmpSectionsClause::SgOmpSectionsClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
93826 : #endif
93827 : #if 0
93828 : // debugging information!
93829 : printf ("In SgOmpSectionsClause::SgOmpSectionsClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
93830 : #endif
93831 :
93832 :
93833 :
93834 : #if 0
93835 : // DQ (7/30/2014): Call a virtual function.
93836 : std::string s = this->class_name();
93837 : #endif
93838 :
93839 : // Test the variant virtual function
93840 : // assert(OmpSectionsClauseTag == variant());
93841 0 : assert(OmpSectionsClauseTag == this->variant());
93842 0 : ROSE_ASSERT(OmpSectionsClauseTag == (int)(this->variantT()));
93843 0 : post_construction_initialization();
93844 :
93845 : // Test the isSgOmpSectionsClause() function since it has been problematic
93846 0 : assert(isSgOmpSectionsClause(this) != NULL);
93847 0 : }
93848 :
93849 : // Generated constructor (all data members)
93850 :
93851 : /* #line 93852 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93852 :
93853 :
93854 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93855 :
93856 :
93857 : // ********************************************************
93858 : // member functions common across all array grammar objects
93859 : // ********************************************************
93860 :
93861 :
93862 :
93863 : /* #line 93864 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93864 :
93865 :
93866 :
93867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
93868 :
93869 : // ********************************************************
93870 : // member functions specific to each node in the grammar
93871 : // ********************************************************
93872 :
93873 :
93874 : /* #line 93875 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
93875 :
93876 : // Start of memberFunctionString
93877 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
93878 :
93879 : // *** COMMON CODE SECTION BEGINS HERE ***
93880 :
93881 : #if 0
93882 : int
93883 : SgOmpForClause::getVariant() const
93884 : {
93885 : // This function is used in ROSE while "variant()" is used in SAGE
93886 : assert(this != NULL);
93887 : return variant();
93888 : }
93889 : #endif
93890 :
93891 : // This function is used in ROSE in treeTraversal code
93892 : // eventually replaces getVariant() and variant()
93893 : // though after variant() has been removed for a while we will
93894 : // want to change the name of variantT() back to variant()
93895 : // (since the "T" was ment to stand for temporary).
93896 : // When this happens the variantT() will be depricated.
93897 : VariantT
93898 0 : SgOmpForClause::variantT() const
93899 : {
93900 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
93901 0 : ROSE_ASSERT(this != NULL);
93902 0 : return V_SgOmpForClause;
93903 : }
93904 :
93905 : #if 0
93906 : int
93907 : SgOmpForClause::variant() const
93908 : {
93909 : // This function is used in SAGE
93910 : ROSE_ASSERT(this != NULL);
93911 : return OmpForClauseTag;
93912 : }
93913 : #endif
93914 :
93915 : ROSE_DLL_API const char*
93916 0 : SgOmpForClause::sage_class_name() const
93917 : {
93918 0 : ROSE_ASSERT(this != NULL);
93919 0 : return "SgOmpForClause";
93920 : }
93921 :
93922 : std::string
93923 0 : SgOmpForClause::class_name() const
93924 : {
93925 0 : ROSE_ASSERT(this != NULL);
93926 0 : return "SgOmpForClause";
93927 : }
93928 :
93929 : // DQ (11/26/2005): Support for visitor pattern mechanims
93930 : // (inferior to ROSE traversal mechanism, experimental).
93931 : void
93932 0 : SgOmpForClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
93933 : {
93934 0 : ROSE_ASSERT(this != NULL);
93935 0 : visitor.visit(this);
93936 0 : }
93937 :
93938 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
93939 0 : void SgOmpForClause::accept (ROSE_VisitorPattern & visitor) {
93940 0 : ROSE_ASSERT(this != NULL);
93941 0 : visitor.visit(this);
93942 0 : }
93943 :
93944 : SgOmpForClause*
93945 0 : SgOmpForClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
93946 : {
93947 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
93948 : // This function is currently only supported for the AST used the represent Binary executables.
93949 : if (0 /* isSgAsmNode(this) != NULL */)
93950 : {
93951 : // Support for regex specification.
93952 : std::string prefixCode = "REGEX:";
93953 : addNewAttribute(prefixCode + s,a);
93954 : }
93955 : #endif
93956 :
93957 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
93958 0 : return this;
93959 : }
93960 :
93961 : // *** COMMON CODE SECTION ENDS HERE ***
93962 :
93963 :
93964 : // End of memberFunctionString
93965 : // Start of memberFunctionString
93966 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
93967 :
93968 :
93969 : #if 0
93970 : //! Error checking support
93971 : /*! Verifies the following:
93972 : - working getVariant() member function
93973 : - calls base class's error() member function
93974 : Every class has one of these functions.
93975 : */
93976 : bool
93977 : SgOmpForClause::error()
93978 : {
93979 : // Put error checking here
93980 :
93981 : ROSE_ASSERT (this != NULL);
93982 : if (getVariant() != OmpForClauseTag)
93983 : {
93984 : printf ("Error in SgOmpForClause::error(): SgOmpForClause object has a %s variant \n",
93985 : Cxx_GrammarTerminalNames[getVariant()].name);
93986 : // printf ("Error in SgOmpForClause::error() \n");
93987 : ROSE_ABORT();
93988 : }
93989 :
93990 : ROSE_ASSERT (getVariant() == OmpForClauseTag);
93991 : return SgOmpClause::error();
93992 : }
93993 : #endif
93994 :
93995 :
93996 :
93997 : // End of memberFunctionString
93998 :
93999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
94000 :
94001 0 : SgOmpForClause* isSgOmpForClause ( SgNode* inputDerivedClassPointer )
94002 : {
94003 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94004 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94005 : // So to fix this we return NULL directly when the input is NULL and avoid the
94006 : // dynamic_cast in this case. This is likely a performance improvement as well.
94007 : // return dynamic_cast<SgOmpForClause*>(inputDerivedClassPointer);
94008 : // Milind Chabbi (8/28/2013): isSgOmpForClause uses table-driven castability instead of c++ default dynamic_cast
94009 : // this improves the running time performance by 10-20%.
94010 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpForClause*>(inputDerivedClassPointer);
94011 0 : return IS_SgOmpForClause_FAST_MACRO(inputDerivedClassPointer);
94012 : }
94013 :
94014 : // DQ (11/8/2003): Added version of functions taking const pointer
94015 0 : const SgOmpForClause* isSgOmpForClause ( const SgNode* inputDerivedClassPointer )
94016 : {
94017 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94018 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94019 : // So to fix this we return NULL directly when the input is NULL and avoid the
94020 : // dynamic_cast in this case. This is likely a performance improvement as well.
94021 : // return dynamic_cast<const SgOmpForClause*>(inputDerivedClassPointer);
94022 : // Milind Chabbi (8/28/2013): isSgOmpForClause uses table-driven castability instead of c++ default dynamic_cast
94023 : // this improves the running time performance by 10-20%.
94024 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpForClause*>(inputDerivedClassPointer);
94025 0 : return IS_SgOmpForClause_FAST_MACRO(inputDerivedClassPointer);
94026 : }
94027 :
94028 :
94029 :
94030 : /* #line 94031 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94031 :
94032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94033 :
94034 : /**
94035 : \brief Generated destructor
94036 :
94037 : This destructor is automatically generated (by ROSETTA). This destructor
94038 : only frees memory of data members associated with the parts of the current IR node which
94039 : are NOT traversed. Those data members that are part of a traversal can be freed using
94040 : a traversal (calling this destructor on all children in a post-order traversal). Such
94041 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
94042 :
94043 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
94044 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
94045 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
94046 :
94047 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
94048 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
94049 : pointers are not yet implemented to call delete on eash pointer in the container.
94050 : (This could be done by derivation from the STL containers to define containers that
94051 : automatically deleted their members.)
94052 :
94053 : */
94054 0 : SgOmpForClause::~SgOmpForClause () {
94055 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
94056 :
94057 :
94058 :
94059 : }
94060 :
94061 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94062 0 : }
94063 :
94064 :
94065 : /* #line 94066 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94066 :
94067 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
94068 :
94069 : // Generated constructor
94070 0 : SgOmpForClause::SgOmpForClause ( Sg_File_Info* startOfConstruct )
94071 0 : : SgOmpClause(startOfConstruct)
94072 : {
94073 : #ifdef DEBUG
94074 : // printf ("In SgOmpForClause::SgOmpForClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
94075 : #endif
94076 : #if 0
94077 : // debugging information!
94078 : printf ("In SgOmpForClause::SgOmpForClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
94079 : #endif
94080 :
94081 :
94082 :
94083 : #if 0
94084 : // DQ (7/30/2014): Call a virtual function.
94085 : std::string s = this->class_name();
94086 : #endif
94087 :
94088 : // Test the variant virtual function
94089 : // assert(OmpForClauseTag == variant());
94090 0 : assert(OmpForClauseTag == this->variant());
94091 0 : ROSE_ASSERT(OmpForClauseTag == (int)(this->variantT()));
94092 0 : post_construction_initialization();
94093 :
94094 : // Test the isSgOmpForClause() function since it has been problematic
94095 0 : assert(isSgOmpForClause(this) != NULL);
94096 0 : }
94097 :
94098 : // Generated constructor (all data members)
94099 :
94100 : /* #line 94101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94101 :
94102 :
94103 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94104 :
94105 :
94106 : // ********************************************************
94107 : // member functions common across all array grammar objects
94108 : // ********************************************************
94109 :
94110 :
94111 :
94112 : /* #line 94113 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94113 :
94114 :
94115 :
94116 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94117 :
94118 : // ********************************************************
94119 : // member functions specific to each node in the grammar
94120 : // ********************************************************
94121 :
94122 :
94123 : /* #line 94124 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94124 :
94125 : // Start of memberFunctionString
94126 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
94127 :
94128 : // *** COMMON CODE SECTION BEGINS HERE ***
94129 :
94130 : #if 0
94131 : int
94132 : SgOmpTaskgroupClause::getVariant() const
94133 : {
94134 : // This function is used in ROSE while "variant()" is used in SAGE
94135 : assert(this != NULL);
94136 : return variant();
94137 : }
94138 : #endif
94139 :
94140 : // This function is used in ROSE in treeTraversal code
94141 : // eventually replaces getVariant() and variant()
94142 : // though after variant() has been removed for a while we will
94143 : // want to change the name of variantT() back to variant()
94144 : // (since the "T" was ment to stand for temporary).
94145 : // When this happens the variantT() will be depricated.
94146 : VariantT
94147 0 : SgOmpTaskgroupClause::variantT() const
94148 : {
94149 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
94150 0 : ROSE_ASSERT(this != NULL);
94151 0 : return V_SgOmpTaskgroupClause;
94152 : }
94153 :
94154 : #if 0
94155 : int
94156 : SgOmpTaskgroupClause::variant() const
94157 : {
94158 : // This function is used in SAGE
94159 : ROSE_ASSERT(this != NULL);
94160 : return OmpTaskgroupClauseTag;
94161 : }
94162 : #endif
94163 :
94164 : ROSE_DLL_API const char*
94165 0 : SgOmpTaskgroupClause::sage_class_name() const
94166 : {
94167 0 : ROSE_ASSERT(this != NULL);
94168 0 : return "SgOmpTaskgroupClause";
94169 : }
94170 :
94171 : std::string
94172 0 : SgOmpTaskgroupClause::class_name() const
94173 : {
94174 0 : ROSE_ASSERT(this != NULL);
94175 0 : return "SgOmpTaskgroupClause";
94176 : }
94177 :
94178 : // DQ (11/26/2005): Support for visitor pattern mechanims
94179 : // (inferior to ROSE traversal mechanism, experimental).
94180 : void
94181 0 : SgOmpTaskgroupClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
94182 : {
94183 0 : ROSE_ASSERT(this != NULL);
94184 0 : visitor.visit(this);
94185 0 : }
94186 :
94187 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
94188 0 : void SgOmpTaskgroupClause::accept (ROSE_VisitorPattern & visitor) {
94189 0 : ROSE_ASSERT(this != NULL);
94190 0 : visitor.visit(this);
94191 0 : }
94192 :
94193 : SgOmpTaskgroupClause*
94194 0 : SgOmpTaskgroupClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
94195 : {
94196 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
94197 : // This function is currently only supported for the AST used the represent Binary executables.
94198 : if (0 /* isSgAsmNode(this) != NULL */)
94199 : {
94200 : // Support for regex specification.
94201 : std::string prefixCode = "REGEX:";
94202 : addNewAttribute(prefixCode + s,a);
94203 : }
94204 : #endif
94205 :
94206 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
94207 0 : return this;
94208 : }
94209 :
94210 : // *** COMMON CODE SECTION ENDS HERE ***
94211 :
94212 :
94213 : // End of memberFunctionString
94214 : // Start of memberFunctionString
94215 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
94216 :
94217 :
94218 : #if 0
94219 : //! Error checking support
94220 : /*! Verifies the following:
94221 : - working getVariant() member function
94222 : - calls base class's error() member function
94223 : Every class has one of these functions.
94224 : */
94225 : bool
94226 : SgOmpTaskgroupClause::error()
94227 : {
94228 : // Put error checking here
94229 :
94230 : ROSE_ASSERT (this != NULL);
94231 : if (getVariant() != OmpTaskgroupClauseTag)
94232 : {
94233 : printf ("Error in SgOmpTaskgroupClause::error(): SgOmpTaskgroupClause object has a %s variant \n",
94234 : Cxx_GrammarTerminalNames[getVariant()].name);
94235 : // printf ("Error in SgOmpTaskgroupClause::error() \n");
94236 : ROSE_ABORT();
94237 : }
94238 :
94239 : ROSE_ASSERT (getVariant() == OmpTaskgroupClauseTag);
94240 : return SgOmpClause::error();
94241 : }
94242 : #endif
94243 :
94244 :
94245 :
94246 : // End of memberFunctionString
94247 :
94248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
94249 :
94250 0 : SgOmpTaskgroupClause* isSgOmpTaskgroupClause ( SgNode* inputDerivedClassPointer )
94251 : {
94252 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94253 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94254 : // So to fix this we return NULL directly when the input is NULL and avoid the
94255 : // dynamic_cast in this case. This is likely a performance improvement as well.
94256 : // return dynamic_cast<SgOmpTaskgroupClause*>(inputDerivedClassPointer);
94257 : // Milind Chabbi (8/28/2013): isSgOmpTaskgroupClause uses table-driven castability instead of c++ default dynamic_cast
94258 : // this improves the running time performance by 10-20%.
94259 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskgroupClause*>(inputDerivedClassPointer);
94260 0 : return IS_SgOmpTaskgroupClause_FAST_MACRO(inputDerivedClassPointer);
94261 : }
94262 :
94263 : // DQ (11/8/2003): Added version of functions taking const pointer
94264 0 : const SgOmpTaskgroupClause* isSgOmpTaskgroupClause ( const SgNode* inputDerivedClassPointer )
94265 : {
94266 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94267 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94268 : // So to fix this we return NULL directly when the input is NULL and avoid the
94269 : // dynamic_cast in this case. This is likely a performance improvement as well.
94270 : // return dynamic_cast<const SgOmpTaskgroupClause*>(inputDerivedClassPointer);
94271 : // Milind Chabbi (8/28/2013): isSgOmpTaskgroupClause uses table-driven castability instead of c++ default dynamic_cast
94272 : // this improves the running time performance by 10-20%.
94273 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskgroupClause*>(inputDerivedClassPointer);
94274 0 : return IS_SgOmpTaskgroupClause_FAST_MACRO(inputDerivedClassPointer);
94275 : }
94276 :
94277 :
94278 :
94279 : /* #line 94280 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94280 :
94281 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94282 :
94283 : /**
94284 : \brief Generated destructor
94285 :
94286 : This destructor is automatically generated (by ROSETTA). This destructor
94287 : only frees memory of data members associated with the parts of the current IR node which
94288 : are NOT traversed. Those data members that are part of a traversal can be freed using
94289 : a traversal (calling this destructor on all children in a post-order traversal). Such
94290 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
94291 :
94292 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
94293 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
94294 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
94295 :
94296 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
94297 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
94298 : pointers are not yet implemented to call delete on eash pointer in the container.
94299 : (This could be done by derivation from the STL containers to define containers that
94300 : automatically deleted their members.)
94301 :
94302 : */
94303 0 : SgOmpTaskgroupClause::~SgOmpTaskgroupClause () {
94304 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
94305 :
94306 :
94307 :
94308 : }
94309 :
94310 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94311 0 : }
94312 :
94313 :
94314 : /* #line 94315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94315 :
94316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
94317 :
94318 : // Generated constructor
94319 0 : SgOmpTaskgroupClause::SgOmpTaskgroupClause ( Sg_File_Info* startOfConstruct )
94320 0 : : SgOmpClause(startOfConstruct)
94321 : {
94322 : #ifdef DEBUG
94323 : // printf ("In SgOmpTaskgroupClause::SgOmpTaskgroupClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
94324 : #endif
94325 : #if 0
94326 : // debugging information!
94327 : printf ("In SgOmpTaskgroupClause::SgOmpTaskgroupClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
94328 : #endif
94329 :
94330 :
94331 :
94332 : #if 0
94333 : // DQ (7/30/2014): Call a virtual function.
94334 : std::string s = this->class_name();
94335 : #endif
94336 :
94337 : // Test the variant virtual function
94338 : // assert(OmpTaskgroupClauseTag == variant());
94339 0 : assert(OmpTaskgroupClauseTag == this->variant());
94340 0 : ROSE_ASSERT(OmpTaskgroupClauseTag == (int)(this->variantT()));
94341 0 : post_construction_initialization();
94342 :
94343 : // Test the isSgOmpTaskgroupClause() function since it has been problematic
94344 0 : assert(isSgOmpTaskgroupClause(this) != NULL);
94345 0 : }
94346 :
94347 : // Generated constructor (all data members)
94348 :
94349 : /* #line 94350 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94350 :
94351 :
94352 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94353 :
94354 :
94355 : // ********************************************************
94356 : // member functions common across all array grammar objects
94357 : // ********************************************************
94358 :
94359 :
94360 :
94361 : /* #line 94362 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94362 :
94363 :
94364 :
94365 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94366 :
94367 : // ********************************************************
94368 : // member functions specific to each node in the grammar
94369 : // ********************************************************
94370 :
94371 :
94372 : /* #line 94373 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94373 :
94374 : // Start of memberFunctionString
94375 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
94376 :
94377 : // *** COMMON CODE SECTION BEGINS HERE ***
94378 :
94379 : #if 0
94380 : int
94381 : SgOmpNogroupClause::getVariant() const
94382 : {
94383 : // This function is used in ROSE while "variant()" is used in SAGE
94384 : assert(this != NULL);
94385 : return variant();
94386 : }
94387 : #endif
94388 :
94389 : // This function is used in ROSE in treeTraversal code
94390 : // eventually replaces getVariant() and variant()
94391 : // though after variant() has been removed for a while we will
94392 : // want to change the name of variantT() back to variant()
94393 : // (since the "T" was ment to stand for temporary).
94394 : // When this happens the variantT() will be depricated.
94395 : VariantT
94396 52 : SgOmpNogroupClause::variantT() const
94397 : {
94398 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
94399 52 : ROSE_ASSERT(this != NULL);
94400 52 : return V_SgOmpNogroupClause;
94401 : }
94402 :
94403 : #if 0
94404 : int
94405 : SgOmpNogroupClause::variant() const
94406 : {
94407 : // This function is used in SAGE
94408 : ROSE_ASSERT(this != NULL);
94409 : return OmpNogroupClauseTag;
94410 : }
94411 : #endif
94412 :
94413 : ROSE_DLL_API const char*
94414 0 : SgOmpNogroupClause::sage_class_name() const
94415 : {
94416 0 : ROSE_ASSERT(this != NULL);
94417 0 : return "SgOmpNogroupClause";
94418 : }
94419 :
94420 : std::string
94421 1 : SgOmpNogroupClause::class_name() const
94422 : {
94423 1 : ROSE_ASSERT(this != NULL);
94424 1 : return "SgOmpNogroupClause";
94425 : }
94426 :
94427 : // DQ (11/26/2005): Support for visitor pattern mechanims
94428 : // (inferior to ROSE traversal mechanism, experimental).
94429 : void
94430 0 : SgOmpNogroupClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
94431 : {
94432 0 : ROSE_ASSERT(this != NULL);
94433 0 : visitor.visit(this);
94434 0 : }
94435 :
94436 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
94437 0 : void SgOmpNogroupClause::accept (ROSE_VisitorPattern & visitor) {
94438 0 : ROSE_ASSERT(this != NULL);
94439 0 : visitor.visit(this);
94440 0 : }
94441 :
94442 : SgOmpNogroupClause*
94443 0 : SgOmpNogroupClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
94444 : {
94445 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
94446 : // This function is currently only supported for the AST used the represent Binary executables.
94447 : if (0 /* isSgAsmNode(this) != NULL */)
94448 : {
94449 : // Support for regex specification.
94450 : std::string prefixCode = "REGEX:";
94451 : addNewAttribute(prefixCode + s,a);
94452 : }
94453 : #endif
94454 :
94455 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
94456 0 : return this;
94457 : }
94458 :
94459 : // *** COMMON CODE SECTION ENDS HERE ***
94460 :
94461 :
94462 : // End of memberFunctionString
94463 : // Start of memberFunctionString
94464 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
94465 :
94466 :
94467 : #if 0
94468 : //! Error checking support
94469 : /*! Verifies the following:
94470 : - working getVariant() member function
94471 : - calls base class's error() member function
94472 : Every class has one of these functions.
94473 : */
94474 : bool
94475 : SgOmpNogroupClause::error()
94476 : {
94477 : // Put error checking here
94478 :
94479 : ROSE_ASSERT (this != NULL);
94480 : if (getVariant() != OmpNogroupClauseTag)
94481 : {
94482 : printf ("Error in SgOmpNogroupClause::error(): SgOmpNogroupClause object has a %s variant \n",
94483 : Cxx_GrammarTerminalNames[getVariant()].name);
94484 : // printf ("Error in SgOmpNogroupClause::error() \n");
94485 : ROSE_ABORT();
94486 : }
94487 :
94488 : ROSE_ASSERT (getVariant() == OmpNogroupClauseTag);
94489 : return SgOmpClause::error();
94490 : }
94491 : #endif
94492 :
94493 :
94494 :
94495 : // End of memberFunctionString
94496 :
94497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
94498 :
94499 1 : SgOmpNogroupClause* isSgOmpNogroupClause ( SgNode* inputDerivedClassPointer )
94500 : {
94501 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94502 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94503 : // So to fix this we return NULL directly when the input is NULL and avoid the
94504 : // dynamic_cast in this case. This is likely a performance improvement as well.
94505 : // return dynamic_cast<SgOmpNogroupClause*>(inputDerivedClassPointer);
94506 : // Milind Chabbi (8/28/2013): isSgOmpNogroupClause uses table-driven castability instead of c++ default dynamic_cast
94507 : // this improves the running time performance by 10-20%.
94508 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpNogroupClause*>(inputDerivedClassPointer);
94509 1 : return IS_SgOmpNogroupClause_FAST_MACRO(inputDerivedClassPointer);
94510 : }
94511 :
94512 : // DQ (11/8/2003): Added version of functions taking const pointer
94513 0 : const SgOmpNogroupClause* isSgOmpNogroupClause ( const SgNode* inputDerivedClassPointer )
94514 : {
94515 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94516 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94517 : // So to fix this we return NULL directly when the input is NULL and avoid the
94518 : // dynamic_cast in this case. This is likely a performance improvement as well.
94519 : // return dynamic_cast<const SgOmpNogroupClause*>(inputDerivedClassPointer);
94520 : // Milind Chabbi (8/28/2013): isSgOmpNogroupClause uses table-driven castability instead of c++ default dynamic_cast
94521 : // this improves the running time performance by 10-20%.
94522 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpNogroupClause*>(inputDerivedClassPointer);
94523 0 : return IS_SgOmpNogroupClause_FAST_MACRO(inputDerivedClassPointer);
94524 : }
94525 :
94526 :
94527 :
94528 : /* #line 94529 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94529 :
94530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94531 :
94532 : /**
94533 : \brief Generated destructor
94534 :
94535 : This destructor is automatically generated (by ROSETTA). This destructor
94536 : only frees memory of data members associated with the parts of the current IR node which
94537 : are NOT traversed. Those data members that are part of a traversal can be freed using
94538 : a traversal (calling this destructor on all children in a post-order traversal). Such
94539 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
94540 :
94541 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
94542 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
94543 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
94544 :
94545 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
94546 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
94547 : pointers are not yet implemented to call delete on eash pointer in the container.
94548 : (This could be done by derivation from the STL containers to define containers that
94549 : automatically deleted their members.)
94550 :
94551 : */
94552 0 : SgOmpNogroupClause::~SgOmpNogroupClause () {
94553 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
94554 :
94555 :
94556 :
94557 : }
94558 :
94559 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94560 0 : }
94561 :
94562 :
94563 : /* #line 94564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94564 :
94565 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
94566 :
94567 : // Generated constructor
94568 0 : SgOmpNogroupClause::SgOmpNogroupClause ( Sg_File_Info* startOfConstruct )
94569 0 : : SgOmpClause(startOfConstruct)
94570 : {
94571 : #ifdef DEBUG
94572 : // printf ("In SgOmpNogroupClause::SgOmpNogroupClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
94573 : #endif
94574 : #if 0
94575 : // debugging information!
94576 : printf ("In SgOmpNogroupClause::SgOmpNogroupClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
94577 : #endif
94578 :
94579 :
94580 :
94581 : #if 0
94582 : // DQ (7/30/2014): Call a virtual function.
94583 : std::string s = this->class_name();
94584 : #endif
94585 :
94586 : // Test the variant virtual function
94587 : // assert(OmpNogroupClauseTag == variant());
94588 0 : assert(OmpNogroupClauseTag == this->variant());
94589 0 : ROSE_ASSERT(OmpNogroupClauseTag == (int)(this->variantT()));
94590 0 : post_construction_initialization();
94591 :
94592 : // Test the isSgOmpNogroupClause() function since it has been problematic
94593 0 : assert(isSgOmpNogroupClause(this) != NULL);
94594 0 : }
94595 :
94596 : // Generated constructor (all data members)
94597 :
94598 : /* #line 94599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94599 :
94600 :
94601 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94602 :
94603 :
94604 : // ********************************************************
94605 : // member functions common across all array grammar objects
94606 : // ********************************************************
94607 :
94608 :
94609 :
94610 : /* #line 94611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94611 :
94612 :
94613 :
94614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94615 :
94616 : // ********************************************************
94617 : // member functions specific to each node in the grammar
94618 : // ********************************************************
94619 :
94620 :
94621 : /* #line 94622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94622 :
94623 : // Start of memberFunctionString
94624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
94625 :
94626 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
94627 :
94628 : SgOmpClause::omp_default_option_enum
94629 5 : SgOmpDefaultClause::get_data_sharing () const
94630 : {
94631 5 : ROSE_ASSERT (this != NULL);
94632 :
94633 : #if 0
94634 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
94635 : // used to trigger marking transformations for the token-based unparsing.
94636 : printf ("SgOmpDefaultClause::get_data_sharing = %p = %s \n",this,this->class_name().c_str());
94637 : #endif
94638 :
94639 5 : return p_data_sharing;
94640 : }
94641 :
94642 : void
94643 0 : SgOmpDefaultClause::set_data_sharing ( SgOmpClause::omp_default_option_enum data_sharing )
94644 : {
94645 0 : ROSE_ASSERT (this != NULL);
94646 :
94647 : #if 0
94648 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
94649 : // used to trigger marking transformations for the token-based unparsing.
94650 : printf ("SgOmpDefaultClause::set_data_sharing = %p = %s \n",this,this->class_name().c_str());
94651 : #endif
94652 :
94653 0 : set_isModified(true);
94654 :
94655 0 : p_data_sharing = data_sharing;
94656 0 : }
94657 :
94658 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
94659 :
94660 :
94661 : // End of memberFunctionString
94662 : // Start of memberFunctionString
94663 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
94664 :
94665 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
94666 :
94667 : SgStatement*
94668 0 : SgOmpDefaultClause::get_variant_directive () const
94669 : {
94670 0 : ROSE_ASSERT (this != NULL);
94671 :
94672 : #if 0
94673 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
94674 : // used to trigger marking transformations for the token-based unparsing.
94675 : printf ("SgOmpDefaultClause::get_variant_directive = %p = %s \n",this,this->class_name().c_str());
94676 : #endif
94677 :
94678 0 : return p_variant_directive;
94679 : }
94680 :
94681 : void
94682 0 : SgOmpDefaultClause::set_variant_directive ( SgStatement* variant_directive )
94683 : {
94684 0 : ROSE_ASSERT (this != NULL);
94685 :
94686 : #if 0
94687 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
94688 : // used to trigger marking transformations for the token-based unparsing.
94689 : printf ("SgOmpDefaultClause::set_variant_directive = %p = %s \n",this,this->class_name().c_str());
94690 : #endif
94691 :
94692 0 : set_isModified(true);
94693 :
94694 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
94695 : if (p_variant_directive != NULL && variant_directive != NULL && p_variant_directive != variant_directive)
94696 : {
94697 : printf ("Warning: variant_directive = %p overwriting valid pointer p_variant_directive = %p \n",variant_directive,p_variant_directive);
94698 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
94699 : printf ("Error fails assertion (p_variant_directive != NULL && variant_directive != NULL && p_variant_directive != variant_directive) is false\n");
94700 : ROSE_ASSERT(false);
94701 : #endif
94702 : }
94703 : #endif
94704 0 : p_variant_directive = variant_directive;
94705 0 : }
94706 :
94707 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
94708 :
94709 :
94710 : // End of memberFunctionString
94711 : // Start of memberFunctionString
94712 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
94713 :
94714 : // *** COMMON CODE SECTION BEGINS HERE ***
94715 :
94716 : #if 0
94717 : int
94718 : SgOmpDefaultClause::getVariant() const
94719 : {
94720 : // This function is used in ROSE while "variant()" is used in SAGE
94721 : assert(this != NULL);
94722 : return variant();
94723 : }
94724 : #endif
94725 :
94726 : // This function is used in ROSE in treeTraversal code
94727 : // eventually replaces getVariant() and variant()
94728 : // though after variant() has been removed for a while we will
94729 : // want to change the name of variantT() back to variant()
94730 : // (since the "T" was ment to stand for temporary).
94731 : // When this happens the variantT() will be depricated.
94732 : VariantT
94733 273 : SgOmpDefaultClause::variantT() const
94734 : {
94735 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
94736 273 : ROSE_ASSERT(this != NULL);
94737 273 : return V_SgOmpDefaultClause;
94738 : }
94739 :
94740 : #if 0
94741 : int
94742 : SgOmpDefaultClause::variant() const
94743 : {
94744 : // This function is used in SAGE
94745 : ROSE_ASSERT(this != NULL);
94746 : return OmpDefaultClauseTag;
94747 : }
94748 : #endif
94749 :
94750 : ROSE_DLL_API const char*
94751 0 : SgOmpDefaultClause::sage_class_name() const
94752 : {
94753 0 : ROSE_ASSERT(this != NULL);
94754 0 : return "SgOmpDefaultClause";
94755 : }
94756 :
94757 : std::string
94758 5 : SgOmpDefaultClause::class_name() const
94759 : {
94760 5 : ROSE_ASSERT(this != NULL);
94761 5 : return "SgOmpDefaultClause";
94762 : }
94763 :
94764 : // DQ (11/26/2005): Support for visitor pattern mechanims
94765 : // (inferior to ROSE traversal mechanism, experimental).
94766 : void
94767 0 : SgOmpDefaultClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
94768 : {
94769 0 : ROSE_ASSERT(this != NULL);
94770 0 : visitor.visit(this);
94771 0 : }
94772 :
94773 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
94774 0 : void SgOmpDefaultClause::accept (ROSE_VisitorPattern & visitor) {
94775 0 : ROSE_ASSERT(this != NULL);
94776 0 : visitor.visit(this);
94777 0 : }
94778 :
94779 : SgOmpDefaultClause*
94780 0 : SgOmpDefaultClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
94781 : {
94782 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
94783 : // This function is currently only supported for the AST used the represent Binary executables.
94784 : if (0 /* isSgAsmNode(this) != NULL */)
94785 : {
94786 : // Support for regex specification.
94787 : std::string prefixCode = "REGEX:";
94788 : addNewAttribute(prefixCode + s,a);
94789 : }
94790 : #endif
94791 :
94792 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
94793 0 : return this;
94794 : }
94795 :
94796 : // *** COMMON CODE SECTION ENDS HERE ***
94797 :
94798 :
94799 : // End of memberFunctionString
94800 : // Start of memberFunctionString
94801 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
94802 :
94803 :
94804 : #if 0
94805 : //! Error checking support
94806 : /*! Verifies the following:
94807 : - working getVariant() member function
94808 : - calls base class's error() member function
94809 : Every class has one of these functions.
94810 : */
94811 : bool
94812 : SgOmpDefaultClause::error()
94813 : {
94814 : // Put error checking here
94815 :
94816 : ROSE_ASSERT (this != NULL);
94817 : if (getVariant() != OmpDefaultClauseTag)
94818 : {
94819 : printf ("Error in SgOmpDefaultClause::error(): SgOmpDefaultClause object has a %s variant \n",
94820 : Cxx_GrammarTerminalNames[getVariant()].name);
94821 : // printf ("Error in SgOmpDefaultClause::error() \n");
94822 : ROSE_ABORT();
94823 : }
94824 :
94825 : ROSE_ASSERT (getVariant() == OmpDefaultClauseTag);
94826 : return SgOmpClause::error();
94827 : }
94828 : #endif
94829 :
94830 :
94831 :
94832 : // End of memberFunctionString
94833 :
94834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
94835 :
94836 15 : SgOmpDefaultClause* isSgOmpDefaultClause ( SgNode* inputDerivedClassPointer )
94837 : {
94838 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94839 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94840 : // So to fix this we return NULL directly when the input is NULL and avoid the
94841 : // dynamic_cast in this case. This is likely a performance improvement as well.
94842 : // return dynamic_cast<SgOmpDefaultClause*>(inputDerivedClassPointer);
94843 : // Milind Chabbi (8/28/2013): isSgOmpDefaultClause uses table-driven castability instead of c++ default dynamic_cast
94844 : // this improves the running time performance by 10-20%.
94845 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDefaultClause*>(inputDerivedClassPointer);
94846 15 : return IS_SgOmpDefaultClause_FAST_MACRO(inputDerivedClassPointer);
94847 : }
94848 :
94849 : // DQ (11/8/2003): Added version of functions taking const pointer
94850 0 : const SgOmpDefaultClause* isSgOmpDefaultClause ( const SgNode* inputDerivedClassPointer )
94851 : {
94852 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
94853 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
94854 : // So to fix this we return NULL directly when the input is NULL and avoid the
94855 : // dynamic_cast in this case. This is likely a performance improvement as well.
94856 : // return dynamic_cast<const SgOmpDefaultClause*>(inputDerivedClassPointer);
94857 : // Milind Chabbi (8/28/2013): isSgOmpDefaultClause uses table-driven castability instead of c++ default dynamic_cast
94858 : // this improves the running time performance by 10-20%.
94859 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDefaultClause*>(inputDerivedClassPointer);
94860 0 : return IS_SgOmpDefaultClause_FAST_MACRO(inputDerivedClassPointer);
94861 : }
94862 :
94863 :
94864 :
94865 : /* #line 94866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94866 :
94867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94868 :
94869 : /**
94870 : \brief Generated destructor
94871 :
94872 : This destructor is automatically generated (by ROSETTA). This destructor
94873 : only frees memory of data members associated with the parts of the current IR node which
94874 : are NOT traversed. Those data members that are part of a traversal can be freed using
94875 : a traversal (calling this destructor on all children in a post-order traversal). Such
94876 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
94877 :
94878 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
94879 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
94880 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
94881 :
94882 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
94883 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
94884 : pointers are not yet implemented to call delete on eash pointer in the container.
94885 : (This could be done by derivation from the STL containers to define containers that
94886 : automatically deleted their members.)
94887 :
94888 : */
94889 0 : SgOmpDefaultClause::~SgOmpDefaultClause () {
94890 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
94891 :
94892 :
94893 : // case: not a listType for data_sharing
94894 0 : p_data_sharing =e_omp_default_unknown; // non list case
94895 : // case: not a listType for variant_directive
94896 0 : p_variant_directive = NULL; // non list case
94897 :
94898 : }
94899 :
94900 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
94901 0 : }
94902 :
94903 :
94904 : /* #line 94905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94905 :
94906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
94907 :
94908 : // Generated constructor
94909 0 : SgOmpDefaultClause::SgOmpDefaultClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_default_option_enum data_sharing, SgStatement* variant_directive )
94910 0 : : SgOmpClause(startOfConstruct)
94911 : {
94912 : #ifdef DEBUG
94913 : // printf ("In SgOmpDefaultClause::SgOmpDefaultClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_default_option_enum data_sharing, SgStatement* variant_directive) sage_class_name() = %s \n",sage_class_name());
94914 : #endif
94915 : #if 0
94916 : // debugging information!
94917 : printf ("In SgOmpDefaultClause::SgOmpDefaultClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_default_option_enum data_sharing, SgStatement* variant_directive): this = %p = %s \n",this,this->class_name().c_str());
94918 : #endif
94919 :
94920 0 : p_data_sharing = data_sharing;
94921 0 : p_variant_directive = variant_directive;
94922 :
94923 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
94924 :
94925 : #if 0
94926 : // DQ (7/30/2014): Call a virtual function.
94927 : std::string s = this->class_name();
94928 : #endif
94929 :
94930 : // Test the variant virtual function
94931 : // assert(OmpDefaultClauseTag == variant());
94932 0 : assert(OmpDefaultClauseTag == this->variant());
94933 0 : ROSE_ASSERT(OmpDefaultClauseTag == (int)(this->variantT()));
94934 0 : post_construction_initialization();
94935 :
94936 : // Test the isSgOmpDefaultClause() function since it has been problematic
94937 0 : assert(isSgOmpDefaultClause(this) != NULL);
94938 0 : }
94939 :
94940 : // Generated constructor (all data members)
94941 :
94942 : /* #line 94943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94943 :
94944 :
94945 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94946 :
94947 :
94948 : // ********************************************************
94949 : // member functions common across all array grammar objects
94950 : // ********************************************************
94951 :
94952 :
94953 :
94954 : /* #line 94955 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94955 :
94956 :
94957 :
94958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
94959 :
94960 : // ********************************************************
94961 : // member functions specific to each node in the grammar
94962 : // ********************************************************
94963 :
94964 :
94965 : /* #line 94966 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
94966 :
94967 : // Start of memberFunctionString
94968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
94969 :
94970 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
94971 :
94972 : SgOmpClause::omp_allocator_modifier_enum
94973 1 : SgOmpAllocatorClause::get_modifier () const
94974 : {
94975 1 : ROSE_ASSERT (this != NULL);
94976 :
94977 : #if 0
94978 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
94979 : // used to trigger marking transformations for the token-based unparsing.
94980 : printf ("SgOmpAllocatorClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
94981 : #endif
94982 :
94983 1 : return p_modifier;
94984 : }
94985 :
94986 : void
94987 0 : SgOmpAllocatorClause::set_modifier ( SgOmpClause::omp_allocator_modifier_enum modifier )
94988 : {
94989 0 : ROSE_ASSERT (this != NULL);
94990 :
94991 : #if 0
94992 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
94993 : // used to trigger marking transformations for the token-based unparsing.
94994 : printf ("SgOmpAllocatorClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
94995 : #endif
94996 :
94997 0 : set_isModified(true);
94998 :
94999 0 : p_modifier = modifier;
95000 0 : }
95001 :
95002 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
95003 :
95004 :
95005 : // End of memberFunctionString
95006 : // Start of memberFunctionString
95007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
95008 :
95009 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
95010 :
95011 : SgExpression*
95012 1 : SgOmpAllocatorClause::get_user_defined_modifier () const
95013 : {
95014 1 : ROSE_ASSERT (this != NULL);
95015 :
95016 : #if 0
95017 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95018 : // used to trigger marking transformations for the token-based unparsing.
95019 : printf ("SgOmpAllocatorClause::get_user_defined_modifier = %p = %s \n",this,this->class_name().c_str());
95020 : #endif
95021 :
95022 1 : return p_user_defined_modifier;
95023 : }
95024 :
95025 : void
95026 0 : SgOmpAllocatorClause::set_user_defined_modifier ( SgExpression* user_defined_modifier )
95027 : {
95028 0 : ROSE_ASSERT (this != NULL);
95029 :
95030 : #if 0
95031 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95032 : // used to trigger marking transformations for the token-based unparsing.
95033 : printf ("SgOmpAllocatorClause::set_user_defined_modifier = %p = %s \n",this,this->class_name().c_str());
95034 : #endif
95035 :
95036 0 : set_isModified(true);
95037 :
95038 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
95039 : if (p_user_defined_modifier != NULL && user_defined_modifier != NULL && p_user_defined_modifier != user_defined_modifier)
95040 : {
95041 : printf ("Warning: user_defined_modifier = %p overwriting valid pointer p_user_defined_modifier = %p \n",user_defined_modifier,p_user_defined_modifier);
95042 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
95043 : printf ("Error fails assertion (p_user_defined_modifier != NULL && user_defined_modifier != NULL && p_user_defined_modifier != user_defined_modifier) is false\n");
95044 : ROSE_ASSERT(false);
95045 : #endif
95046 : }
95047 : #endif
95048 0 : p_user_defined_modifier = user_defined_modifier;
95049 0 : }
95050 :
95051 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
95052 :
95053 :
95054 : // End of memberFunctionString
95055 : // Start of memberFunctionString
95056 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
95057 :
95058 : // *** COMMON CODE SECTION BEGINS HERE ***
95059 :
95060 : #if 0
95061 : int
95062 : SgOmpAllocatorClause::getVariant() const
95063 : {
95064 : // This function is used in ROSE while "variant()" is used in SAGE
95065 : assert(this != NULL);
95066 : return variant();
95067 : }
95068 : #endif
95069 :
95070 : // This function is used in ROSE in treeTraversal code
95071 : // eventually replaces getVariant() and variant()
95072 : // though after variant() has been removed for a while we will
95073 : // want to change the name of variantT() back to variant()
95074 : // (since the "T" was ment to stand for temporary).
95075 : // When this happens the variantT() will be depricated.
95076 : VariantT
95077 29 : SgOmpAllocatorClause::variantT() const
95078 : {
95079 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
95080 29 : ROSE_ASSERT(this != NULL);
95081 29 : return V_SgOmpAllocatorClause;
95082 : }
95083 :
95084 : #if 0
95085 : int
95086 : SgOmpAllocatorClause::variant() const
95087 : {
95088 : // This function is used in SAGE
95089 : ROSE_ASSERT(this != NULL);
95090 : return OmpAllocatorClauseTag;
95091 : }
95092 : #endif
95093 :
95094 : ROSE_DLL_API const char*
95095 0 : SgOmpAllocatorClause::sage_class_name() const
95096 : {
95097 0 : ROSE_ASSERT(this != NULL);
95098 0 : return "SgOmpAllocatorClause";
95099 : }
95100 :
95101 : std::string
95102 1 : SgOmpAllocatorClause::class_name() const
95103 : {
95104 1 : ROSE_ASSERT(this != NULL);
95105 1 : return "SgOmpAllocatorClause";
95106 : }
95107 :
95108 : // DQ (11/26/2005): Support for visitor pattern mechanims
95109 : // (inferior to ROSE traversal mechanism, experimental).
95110 : void
95111 0 : SgOmpAllocatorClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
95112 : {
95113 0 : ROSE_ASSERT(this != NULL);
95114 0 : visitor.visit(this);
95115 0 : }
95116 :
95117 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
95118 0 : void SgOmpAllocatorClause::accept (ROSE_VisitorPattern & visitor) {
95119 0 : ROSE_ASSERT(this != NULL);
95120 0 : visitor.visit(this);
95121 0 : }
95122 :
95123 : SgOmpAllocatorClause*
95124 0 : SgOmpAllocatorClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
95125 : {
95126 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
95127 : // This function is currently only supported for the AST used the represent Binary executables.
95128 : if (0 /* isSgAsmNode(this) != NULL */)
95129 : {
95130 : // Support for regex specification.
95131 : std::string prefixCode = "REGEX:";
95132 : addNewAttribute(prefixCode + s,a);
95133 : }
95134 : #endif
95135 :
95136 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
95137 0 : return this;
95138 : }
95139 :
95140 : // *** COMMON CODE SECTION ENDS HERE ***
95141 :
95142 :
95143 : // End of memberFunctionString
95144 : // Start of memberFunctionString
95145 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
95146 :
95147 :
95148 : #if 0
95149 : //! Error checking support
95150 : /*! Verifies the following:
95151 : - working getVariant() member function
95152 : - calls base class's error() member function
95153 : Every class has one of these functions.
95154 : */
95155 : bool
95156 : SgOmpAllocatorClause::error()
95157 : {
95158 : // Put error checking here
95159 :
95160 : ROSE_ASSERT (this != NULL);
95161 : if (getVariant() != OmpAllocatorClauseTag)
95162 : {
95163 : printf ("Error in SgOmpAllocatorClause::error(): SgOmpAllocatorClause object has a %s variant \n",
95164 : Cxx_GrammarTerminalNames[getVariant()].name);
95165 : // printf ("Error in SgOmpAllocatorClause::error() \n");
95166 : ROSE_ABORT();
95167 : }
95168 :
95169 : ROSE_ASSERT (getVariant() == OmpAllocatorClauseTag);
95170 : return SgOmpClause::error();
95171 : }
95172 : #endif
95173 :
95174 :
95175 :
95176 : // End of memberFunctionString
95177 :
95178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
95179 :
95180 4 : SgOmpAllocatorClause* isSgOmpAllocatorClause ( SgNode* inputDerivedClassPointer )
95181 : {
95182 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
95183 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
95184 : // So to fix this we return NULL directly when the input is NULL and avoid the
95185 : // dynamic_cast in this case. This is likely a performance improvement as well.
95186 : // return dynamic_cast<SgOmpAllocatorClause*>(inputDerivedClassPointer);
95187 : // Milind Chabbi (8/28/2013): isSgOmpAllocatorClause uses table-driven castability instead of c++ default dynamic_cast
95188 : // this improves the running time performance by 10-20%.
95189 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAllocatorClause*>(inputDerivedClassPointer);
95190 4 : return IS_SgOmpAllocatorClause_FAST_MACRO(inputDerivedClassPointer);
95191 : }
95192 :
95193 : // DQ (11/8/2003): Added version of functions taking const pointer
95194 0 : const SgOmpAllocatorClause* isSgOmpAllocatorClause ( const SgNode* inputDerivedClassPointer )
95195 : {
95196 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
95197 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
95198 : // So to fix this we return NULL directly when the input is NULL and avoid the
95199 : // dynamic_cast in this case. This is likely a performance improvement as well.
95200 : // return dynamic_cast<const SgOmpAllocatorClause*>(inputDerivedClassPointer);
95201 : // Milind Chabbi (8/28/2013): isSgOmpAllocatorClause uses table-driven castability instead of c++ default dynamic_cast
95202 : // this improves the running time performance by 10-20%.
95203 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAllocatorClause*>(inputDerivedClassPointer);
95204 0 : return IS_SgOmpAllocatorClause_FAST_MACRO(inputDerivedClassPointer);
95205 : }
95206 :
95207 :
95208 :
95209 : /* #line 95210 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95210 :
95211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
95212 :
95213 : /**
95214 : \brief Generated destructor
95215 :
95216 : This destructor is automatically generated (by ROSETTA). This destructor
95217 : only frees memory of data members associated with the parts of the current IR node which
95218 : are NOT traversed. Those data members that are part of a traversal can be freed using
95219 : a traversal (calling this destructor on all children in a post-order traversal). Such
95220 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
95221 :
95222 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
95223 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
95224 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
95225 :
95226 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
95227 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
95228 : pointers are not yet implemented to call delete on eash pointer in the container.
95229 : (This could be done by derivation from the STL containers to define containers that
95230 : automatically deleted their members.)
95231 :
95232 : */
95233 0 : SgOmpAllocatorClause::~SgOmpAllocatorClause () {
95234 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
95235 :
95236 :
95237 : // case: not a listType for modifier
95238 0 : p_modifier =e_omp_allocator_modifier_unknown; // non list case
95239 : // case: not a listType for user_defined_modifier
95240 0 : p_user_defined_modifier = NULL; // non list case
95241 :
95242 : }
95243 :
95244 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
95245 0 : }
95246 :
95247 :
95248 : /* #line 95249 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95249 :
95250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
95251 :
95252 : // Generated constructor
95253 0 : SgOmpAllocatorClause::SgOmpAllocatorClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_allocator_modifier_enum modifier, SgExpression* user_defined_modifier )
95254 0 : : SgOmpClause(startOfConstruct)
95255 : {
95256 : #ifdef DEBUG
95257 : // printf ("In SgOmpAllocatorClause::SgOmpAllocatorClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_allocator_modifier_enum modifier, SgExpression* user_defined_modifier) sage_class_name() = %s \n",sage_class_name());
95258 : #endif
95259 : #if 0
95260 : // debugging information!
95261 : printf ("In SgOmpAllocatorClause::SgOmpAllocatorClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_allocator_modifier_enum modifier, SgExpression* user_defined_modifier): this = %p = %s \n",this,this->class_name().c_str());
95262 : #endif
95263 :
95264 0 : p_modifier = modifier;
95265 0 : p_user_defined_modifier = user_defined_modifier;
95266 :
95267 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
95268 :
95269 : #if 0
95270 : // DQ (7/30/2014): Call a virtual function.
95271 : std::string s = this->class_name();
95272 : #endif
95273 :
95274 : // Test the variant virtual function
95275 : // assert(OmpAllocatorClauseTag == variant());
95276 0 : assert(OmpAllocatorClauseTag == this->variant());
95277 0 : ROSE_ASSERT(OmpAllocatorClauseTag == (int)(this->variantT()));
95278 0 : post_construction_initialization();
95279 :
95280 : // Test the isSgOmpAllocatorClause() function since it has been problematic
95281 0 : assert(isSgOmpAllocatorClause(this) != NULL);
95282 0 : }
95283 :
95284 : // Generated constructor (all data members)
95285 :
95286 : /* #line 95287 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95287 :
95288 :
95289 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
95290 :
95291 :
95292 : // ********************************************************
95293 : // member functions common across all array grammar objects
95294 : // ********************************************************
95295 :
95296 :
95297 :
95298 : /* #line 95299 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95299 :
95300 :
95301 :
95302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
95303 :
95304 : // ********************************************************
95305 : // member functions specific to each node in the grammar
95306 : // ********************************************************
95307 :
95308 :
95309 : /* #line 95310 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95310 :
95311 : // Start of memberFunctionString
95312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
95313 :
95314 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
95315 :
95316 : SgOmpClause::omp_atomic_clause_enum
95317 0 : SgOmpAtomicClause::get_atomicity () const
95318 : {
95319 0 : ROSE_ASSERT (this != NULL);
95320 :
95321 : #if 0
95322 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95323 : // used to trigger marking transformations for the token-based unparsing.
95324 : printf ("SgOmpAtomicClause::get_atomicity = %p = %s \n",this,this->class_name().c_str());
95325 : #endif
95326 :
95327 0 : return p_atomicity;
95328 : }
95329 :
95330 : void
95331 0 : SgOmpAtomicClause::set_atomicity ( SgOmpClause::omp_atomic_clause_enum atomicity )
95332 : {
95333 0 : ROSE_ASSERT (this != NULL);
95334 :
95335 : #if 0
95336 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95337 : // used to trigger marking transformations for the token-based unparsing.
95338 : printf ("SgOmpAtomicClause::set_atomicity = %p = %s \n",this,this->class_name().c_str());
95339 : #endif
95340 :
95341 0 : set_isModified(true);
95342 :
95343 0 : p_atomicity = atomicity;
95344 0 : }
95345 :
95346 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
95347 :
95348 :
95349 : // End of memberFunctionString
95350 : // Start of memberFunctionString
95351 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
95352 :
95353 : // *** COMMON CODE SECTION BEGINS HERE ***
95354 :
95355 : #if 0
95356 : int
95357 : SgOmpAtomicClause::getVariant() const
95358 : {
95359 : // This function is used in ROSE while "variant()" is used in SAGE
95360 : assert(this != NULL);
95361 : return variant();
95362 : }
95363 : #endif
95364 :
95365 : // This function is used in ROSE in treeTraversal code
95366 : // eventually replaces getVariant() and variant()
95367 : // though after variant() has been removed for a while we will
95368 : // want to change the name of variantT() back to variant()
95369 : // (since the "T" was ment to stand for temporary).
95370 : // When this happens the variantT() will be depricated.
95371 : VariantT
95372 0 : SgOmpAtomicClause::variantT() const
95373 : {
95374 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
95375 0 : ROSE_ASSERT(this != NULL);
95376 0 : return V_SgOmpAtomicClause;
95377 : }
95378 :
95379 : #if 0
95380 : int
95381 : SgOmpAtomicClause::variant() const
95382 : {
95383 : // This function is used in SAGE
95384 : ROSE_ASSERT(this != NULL);
95385 : return OmpAtomicClauseTag;
95386 : }
95387 : #endif
95388 :
95389 : ROSE_DLL_API const char*
95390 0 : SgOmpAtomicClause::sage_class_name() const
95391 : {
95392 0 : ROSE_ASSERT(this != NULL);
95393 0 : return "SgOmpAtomicClause";
95394 : }
95395 :
95396 : std::string
95397 0 : SgOmpAtomicClause::class_name() const
95398 : {
95399 0 : ROSE_ASSERT(this != NULL);
95400 0 : return "SgOmpAtomicClause";
95401 : }
95402 :
95403 : // DQ (11/26/2005): Support for visitor pattern mechanims
95404 : // (inferior to ROSE traversal mechanism, experimental).
95405 : void
95406 0 : SgOmpAtomicClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
95407 : {
95408 0 : ROSE_ASSERT(this != NULL);
95409 0 : visitor.visit(this);
95410 0 : }
95411 :
95412 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
95413 0 : void SgOmpAtomicClause::accept (ROSE_VisitorPattern & visitor) {
95414 0 : ROSE_ASSERT(this != NULL);
95415 0 : visitor.visit(this);
95416 0 : }
95417 :
95418 : SgOmpAtomicClause*
95419 0 : SgOmpAtomicClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
95420 : {
95421 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
95422 : // This function is currently only supported for the AST used the represent Binary executables.
95423 : if (0 /* isSgAsmNode(this) != NULL */)
95424 : {
95425 : // Support for regex specification.
95426 : std::string prefixCode = "REGEX:";
95427 : addNewAttribute(prefixCode + s,a);
95428 : }
95429 : #endif
95430 :
95431 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
95432 0 : return this;
95433 : }
95434 :
95435 : // *** COMMON CODE SECTION ENDS HERE ***
95436 :
95437 :
95438 : // End of memberFunctionString
95439 : // Start of memberFunctionString
95440 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
95441 :
95442 :
95443 : #if 0
95444 : //! Error checking support
95445 : /*! Verifies the following:
95446 : - working getVariant() member function
95447 : - calls base class's error() member function
95448 : Every class has one of these functions.
95449 : */
95450 : bool
95451 : SgOmpAtomicClause::error()
95452 : {
95453 : // Put error checking here
95454 :
95455 : ROSE_ASSERT (this != NULL);
95456 : if (getVariant() != OmpAtomicClauseTag)
95457 : {
95458 : printf ("Error in SgOmpAtomicClause::error(): SgOmpAtomicClause object has a %s variant \n",
95459 : Cxx_GrammarTerminalNames[getVariant()].name);
95460 : // printf ("Error in SgOmpAtomicClause::error() \n");
95461 : ROSE_ABORT();
95462 : }
95463 :
95464 : ROSE_ASSERT (getVariant() == OmpAtomicClauseTag);
95465 : return SgOmpClause::error();
95466 : }
95467 : #endif
95468 :
95469 :
95470 :
95471 : // End of memberFunctionString
95472 :
95473 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
95474 :
95475 0 : SgOmpAtomicClause* isSgOmpAtomicClause ( SgNode* inputDerivedClassPointer )
95476 : {
95477 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
95478 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
95479 : // So to fix this we return NULL directly when the input is NULL and avoid the
95480 : // dynamic_cast in this case. This is likely a performance improvement as well.
95481 : // return dynamic_cast<SgOmpAtomicClause*>(inputDerivedClassPointer);
95482 : // Milind Chabbi (8/28/2013): isSgOmpAtomicClause uses table-driven castability instead of c++ default dynamic_cast
95483 : // this improves the running time performance by 10-20%.
95484 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAtomicClause*>(inputDerivedClassPointer);
95485 0 : return IS_SgOmpAtomicClause_FAST_MACRO(inputDerivedClassPointer);
95486 : }
95487 :
95488 : // DQ (11/8/2003): Added version of functions taking const pointer
95489 0 : const SgOmpAtomicClause* isSgOmpAtomicClause ( const SgNode* inputDerivedClassPointer )
95490 : {
95491 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
95492 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
95493 : // So to fix this we return NULL directly when the input is NULL and avoid the
95494 : // dynamic_cast in this case. This is likely a performance improvement as well.
95495 : // return dynamic_cast<const SgOmpAtomicClause*>(inputDerivedClassPointer);
95496 : // Milind Chabbi (8/28/2013): isSgOmpAtomicClause uses table-driven castability instead of c++ default dynamic_cast
95497 : // this improves the running time performance by 10-20%.
95498 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAtomicClause*>(inputDerivedClassPointer);
95499 0 : return IS_SgOmpAtomicClause_FAST_MACRO(inputDerivedClassPointer);
95500 : }
95501 :
95502 :
95503 :
95504 : /* #line 95505 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95505 :
95506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
95507 :
95508 : /**
95509 : \brief Generated destructor
95510 :
95511 : This destructor is automatically generated (by ROSETTA). This destructor
95512 : only frees memory of data members associated with the parts of the current IR node which
95513 : are NOT traversed. Those data members that are part of a traversal can be freed using
95514 : a traversal (calling this destructor on all children in a post-order traversal). Such
95515 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
95516 :
95517 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
95518 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
95519 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
95520 :
95521 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
95522 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
95523 : pointers are not yet implemented to call delete on eash pointer in the container.
95524 : (This could be done by derivation from the STL containers to define containers that
95525 : automatically deleted their members.)
95526 :
95527 : */
95528 0 : SgOmpAtomicClause::~SgOmpAtomicClause () {
95529 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
95530 :
95531 :
95532 : // case: not a listType for atomicity
95533 0 : p_atomicity =e_omp_atomic_clause_unknown; // non list case
95534 :
95535 : }
95536 :
95537 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
95538 0 : }
95539 :
95540 :
95541 : /* #line 95542 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95542 :
95543 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
95544 :
95545 : // Generated constructor
95546 0 : SgOmpAtomicClause::SgOmpAtomicClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_atomic_clause_enum atomicity )
95547 0 : : SgOmpClause(startOfConstruct)
95548 : {
95549 : #ifdef DEBUG
95550 : // printf ("In SgOmpAtomicClause::SgOmpAtomicClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_atomic_clause_enum atomicity) sage_class_name() = %s \n",sage_class_name());
95551 : #endif
95552 : #if 0
95553 : // debugging information!
95554 : printf ("In SgOmpAtomicClause::SgOmpAtomicClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_atomic_clause_enum atomicity): this = %p = %s \n",this,this->class_name().c_str());
95555 : #endif
95556 :
95557 0 : p_atomicity = atomicity;
95558 :
95559 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
95560 :
95561 : #if 0
95562 : // DQ (7/30/2014): Call a virtual function.
95563 : std::string s = this->class_name();
95564 : #endif
95565 :
95566 : // Test the variant virtual function
95567 : // assert(OmpAtomicClauseTag == variant());
95568 0 : assert(OmpAtomicClauseTag == this->variant());
95569 0 : ROSE_ASSERT(OmpAtomicClauseTag == (int)(this->variantT()));
95570 0 : post_construction_initialization();
95571 :
95572 : // Test the isSgOmpAtomicClause() function since it has been problematic
95573 0 : assert(isSgOmpAtomicClause(this) != NULL);
95574 0 : }
95575 :
95576 : // Generated constructor (all data members)
95577 :
95578 : /* #line 95579 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95579 :
95580 :
95581 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
95582 :
95583 :
95584 : // ********************************************************
95585 : // member functions common across all array grammar objects
95586 : // ********************************************************
95587 :
95588 :
95589 :
95590 : /* #line 95591 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95591 :
95592 :
95593 :
95594 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
95595 :
95596 : // ********************************************************
95597 : // member functions specific to each node in the grammar
95598 : // ********************************************************
95599 :
95600 :
95601 : /* #line 95602 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95602 :
95603 : // Start of memberFunctionString
95604 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
95605 :
95606 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
95607 :
95608 : SgOmpClause::omp_proc_bind_policy_enum
95609 3 : SgOmpProcBindClause::get_policy () const
95610 : {
95611 3 : ROSE_ASSERT (this != NULL);
95612 :
95613 : #if 0
95614 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95615 : // used to trigger marking transformations for the token-based unparsing.
95616 : printf ("SgOmpProcBindClause::get_policy = %p = %s \n",this,this->class_name().c_str());
95617 : #endif
95618 :
95619 3 : return p_policy;
95620 : }
95621 :
95622 : void
95623 0 : SgOmpProcBindClause::set_policy ( SgOmpClause::omp_proc_bind_policy_enum policy )
95624 : {
95625 0 : ROSE_ASSERT (this != NULL);
95626 :
95627 : #if 0
95628 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95629 : // used to trigger marking transformations for the token-based unparsing.
95630 : printf ("SgOmpProcBindClause::set_policy = %p = %s \n",this,this->class_name().c_str());
95631 : #endif
95632 :
95633 0 : set_isModified(true);
95634 :
95635 0 : p_policy = policy;
95636 0 : }
95637 :
95638 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
95639 :
95640 :
95641 : // End of memberFunctionString
95642 : // Start of memberFunctionString
95643 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
95644 :
95645 : // *** COMMON CODE SECTION BEGINS HERE ***
95646 :
95647 : #if 0
95648 : int
95649 : SgOmpProcBindClause::getVariant() const
95650 : {
95651 : // This function is used in ROSE while "variant()" is used in SAGE
95652 : assert(this != NULL);
95653 : return variant();
95654 : }
95655 : #endif
95656 :
95657 : // This function is used in ROSE in treeTraversal code
95658 : // eventually replaces getVariant() and variant()
95659 : // though after variant() has been removed for a while we will
95660 : // want to change the name of variantT() back to variant()
95661 : // (since the "T" was ment to stand for temporary).
95662 : // When this happens the variantT() will be depricated.
95663 : VariantT
95664 159 : SgOmpProcBindClause::variantT() const
95665 : {
95666 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
95667 159 : ROSE_ASSERT(this != NULL);
95668 159 : return V_SgOmpProcBindClause;
95669 : }
95670 :
95671 : #if 0
95672 : int
95673 : SgOmpProcBindClause::variant() const
95674 : {
95675 : // This function is used in SAGE
95676 : ROSE_ASSERT(this != NULL);
95677 : return OmpProcBindClauseTag;
95678 : }
95679 : #endif
95680 :
95681 : ROSE_DLL_API const char*
95682 0 : SgOmpProcBindClause::sage_class_name() const
95683 : {
95684 0 : ROSE_ASSERT(this != NULL);
95685 0 : return "SgOmpProcBindClause";
95686 : }
95687 :
95688 : std::string
95689 3 : SgOmpProcBindClause::class_name() const
95690 : {
95691 3 : ROSE_ASSERT(this != NULL);
95692 3 : return "SgOmpProcBindClause";
95693 : }
95694 :
95695 : // DQ (11/26/2005): Support for visitor pattern mechanims
95696 : // (inferior to ROSE traversal mechanism, experimental).
95697 : void
95698 0 : SgOmpProcBindClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
95699 : {
95700 0 : ROSE_ASSERT(this != NULL);
95701 0 : visitor.visit(this);
95702 0 : }
95703 :
95704 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
95705 0 : void SgOmpProcBindClause::accept (ROSE_VisitorPattern & visitor) {
95706 0 : ROSE_ASSERT(this != NULL);
95707 0 : visitor.visit(this);
95708 0 : }
95709 :
95710 : SgOmpProcBindClause*
95711 0 : SgOmpProcBindClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
95712 : {
95713 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
95714 : // This function is currently only supported for the AST used the represent Binary executables.
95715 : if (0 /* isSgAsmNode(this) != NULL */)
95716 : {
95717 : // Support for regex specification.
95718 : std::string prefixCode = "REGEX:";
95719 : addNewAttribute(prefixCode + s,a);
95720 : }
95721 : #endif
95722 :
95723 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
95724 0 : return this;
95725 : }
95726 :
95727 : // *** COMMON CODE SECTION ENDS HERE ***
95728 :
95729 :
95730 : // End of memberFunctionString
95731 : // Start of memberFunctionString
95732 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
95733 :
95734 :
95735 : #if 0
95736 : //! Error checking support
95737 : /*! Verifies the following:
95738 : - working getVariant() member function
95739 : - calls base class's error() member function
95740 : Every class has one of these functions.
95741 : */
95742 : bool
95743 : SgOmpProcBindClause::error()
95744 : {
95745 : // Put error checking here
95746 :
95747 : ROSE_ASSERT (this != NULL);
95748 : if (getVariant() != OmpProcBindClauseTag)
95749 : {
95750 : printf ("Error in SgOmpProcBindClause::error(): SgOmpProcBindClause object has a %s variant \n",
95751 : Cxx_GrammarTerminalNames[getVariant()].name);
95752 : // printf ("Error in SgOmpProcBindClause::error() \n");
95753 : ROSE_ABORT();
95754 : }
95755 :
95756 : ROSE_ASSERT (getVariant() == OmpProcBindClauseTag);
95757 : return SgOmpClause::error();
95758 : }
95759 : #endif
95760 :
95761 :
95762 :
95763 : // End of memberFunctionString
95764 :
95765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
95766 :
95767 9 : SgOmpProcBindClause* isSgOmpProcBindClause ( SgNode* inputDerivedClassPointer )
95768 : {
95769 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
95770 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
95771 : // So to fix this we return NULL directly when the input is NULL and avoid the
95772 : // dynamic_cast in this case. This is likely a performance improvement as well.
95773 : // return dynamic_cast<SgOmpProcBindClause*>(inputDerivedClassPointer);
95774 : // Milind Chabbi (8/28/2013): isSgOmpProcBindClause uses table-driven castability instead of c++ default dynamic_cast
95775 : // this improves the running time performance by 10-20%.
95776 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpProcBindClause*>(inputDerivedClassPointer);
95777 9 : return IS_SgOmpProcBindClause_FAST_MACRO(inputDerivedClassPointer);
95778 : }
95779 :
95780 : // DQ (11/8/2003): Added version of functions taking const pointer
95781 0 : const SgOmpProcBindClause* isSgOmpProcBindClause ( const SgNode* inputDerivedClassPointer )
95782 : {
95783 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
95784 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
95785 : // So to fix this we return NULL directly when the input is NULL and avoid the
95786 : // dynamic_cast in this case. This is likely a performance improvement as well.
95787 : // return dynamic_cast<const SgOmpProcBindClause*>(inputDerivedClassPointer);
95788 : // Milind Chabbi (8/28/2013): isSgOmpProcBindClause uses table-driven castability instead of c++ default dynamic_cast
95789 : // this improves the running time performance by 10-20%.
95790 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpProcBindClause*>(inputDerivedClassPointer);
95791 0 : return IS_SgOmpProcBindClause_FAST_MACRO(inputDerivedClassPointer);
95792 : }
95793 :
95794 :
95795 :
95796 : /* #line 95797 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95797 :
95798 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
95799 :
95800 : /**
95801 : \brief Generated destructor
95802 :
95803 : This destructor is automatically generated (by ROSETTA). This destructor
95804 : only frees memory of data members associated with the parts of the current IR node which
95805 : are NOT traversed. Those data members that are part of a traversal can be freed using
95806 : a traversal (calling this destructor on all children in a post-order traversal). Such
95807 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
95808 :
95809 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
95810 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
95811 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
95812 :
95813 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
95814 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
95815 : pointers are not yet implemented to call delete on eash pointer in the container.
95816 : (This could be done by derivation from the STL containers to define containers that
95817 : automatically deleted their members.)
95818 :
95819 : */
95820 0 : SgOmpProcBindClause::~SgOmpProcBindClause () {
95821 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
95822 :
95823 :
95824 : // case: not a listType for policy
95825 0 : p_policy =e_omp_proc_bind_policy_unknown; // non list case
95826 :
95827 : }
95828 :
95829 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
95830 0 : }
95831 :
95832 :
95833 : /* #line 95834 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95834 :
95835 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
95836 :
95837 : // Generated constructor
95838 0 : SgOmpProcBindClause::SgOmpProcBindClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_proc_bind_policy_enum policy )
95839 0 : : SgOmpClause(startOfConstruct)
95840 : {
95841 : #ifdef DEBUG
95842 : // printf ("In SgOmpProcBindClause::SgOmpProcBindClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_proc_bind_policy_enum policy) sage_class_name() = %s \n",sage_class_name());
95843 : #endif
95844 : #if 0
95845 : // debugging information!
95846 : printf ("In SgOmpProcBindClause::SgOmpProcBindClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_proc_bind_policy_enum policy): this = %p = %s \n",this,this->class_name().c_str());
95847 : #endif
95848 :
95849 0 : p_policy = policy;
95850 :
95851 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
95852 :
95853 : #if 0
95854 : // DQ (7/30/2014): Call a virtual function.
95855 : std::string s = this->class_name();
95856 : #endif
95857 :
95858 : // Test the variant virtual function
95859 : // assert(OmpProcBindClauseTag == variant());
95860 0 : assert(OmpProcBindClauseTag == this->variant());
95861 0 : ROSE_ASSERT(OmpProcBindClauseTag == (int)(this->variantT()));
95862 0 : post_construction_initialization();
95863 :
95864 : // Test the isSgOmpProcBindClause() function since it has been problematic
95865 0 : assert(isSgOmpProcBindClause(this) != NULL);
95866 0 : }
95867 :
95868 : // Generated constructor (all data members)
95869 :
95870 : /* #line 95871 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95871 :
95872 :
95873 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
95874 :
95875 :
95876 : // ********************************************************
95877 : // member functions common across all array grammar objects
95878 : // ********************************************************
95879 :
95880 :
95881 :
95882 : /* #line 95883 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95883 :
95884 :
95885 :
95886 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
95887 :
95888 : // ********************************************************
95889 : // member functions specific to each node in the grammar
95890 : // ********************************************************
95891 :
95892 :
95893 : /* #line 95894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
95894 :
95895 : // Start of memberFunctionString
95896 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
95897 :
95898 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
95899 :
95900 : SgOmpClause::omp_bind_binding_enum
95901 1 : SgOmpBindClause::get_binding () const
95902 : {
95903 1 : ROSE_ASSERT (this != NULL);
95904 :
95905 : #if 0
95906 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95907 : // used to trigger marking transformations for the token-based unparsing.
95908 : printf ("SgOmpBindClause::get_binding = %p = %s \n",this,this->class_name().c_str());
95909 : #endif
95910 :
95911 1 : return p_binding;
95912 : }
95913 :
95914 : void
95915 0 : SgOmpBindClause::set_binding ( SgOmpClause::omp_bind_binding_enum binding )
95916 : {
95917 0 : ROSE_ASSERT (this != NULL);
95918 :
95919 : #if 0
95920 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
95921 : // used to trigger marking transformations for the token-based unparsing.
95922 : printf ("SgOmpBindClause::set_binding = %p = %s \n",this,this->class_name().c_str());
95923 : #endif
95924 :
95925 0 : set_isModified(true);
95926 :
95927 0 : p_binding = binding;
95928 0 : }
95929 :
95930 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
95931 :
95932 :
95933 : // End of memberFunctionString
95934 : // Start of memberFunctionString
95935 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
95936 :
95937 : // *** COMMON CODE SECTION BEGINS HERE ***
95938 :
95939 : #if 0
95940 : int
95941 : SgOmpBindClause::getVariant() const
95942 : {
95943 : // This function is used in ROSE while "variant()" is used in SAGE
95944 : assert(this != NULL);
95945 : return variant();
95946 : }
95947 : #endif
95948 :
95949 : // This function is used in ROSE in treeTraversal code
95950 : // eventually replaces getVariant() and variant()
95951 : // though after variant() has been removed for a while we will
95952 : // want to change the name of variantT() back to variant()
95953 : // (since the "T" was ment to stand for temporary).
95954 : // When this happens the variantT() will be depricated.
95955 : VariantT
95956 54 : SgOmpBindClause::variantT() const
95957 : {
95958 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
95959 54 : ROSE_ASSERT(this != NULL);
95960 54 : return V_SgOmpBindClause;
95961 : }
95962 :
95963 : #if 0
95964 : int
95965 : SgOmpBindClause::variant() const
95966 : {
95967 : // This function is used in SAGE
95968 : ROSE_ASSERT(this != NULL);
95969 : return OmpBindClauseTag;
95970 : }
95971 : #endif
95972 :
95973 : ROSE_DLL_API const char*
95974 0 : SgOmpBindClause::sage_class_name() const
95975 : {
95976 0 : ROSE_ASSERT(this != NULL);
95977 0 : return "SgOmpBindClause";
95978 : }
95979 :
95980 : std::string
95981 1 : SgOmpBindClause::class_name() const
95982 : {
95983 1 : ROSE_ASSERT(this != NULL);
95984 1 : return "SgOmpBindClause";
95985 : }
95986 :
95987 : // DQ (11/26/2005): Support for visitor pattern mechanims
95988 : // (inferior to ROSE traversal mechanism, experimental).
95989 : void
95990 0 : SgOmpBindClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
95991 : {
95992 0 : ROSE_ASSERT(this != NULL);
95993 0 : visitor.visit(this);
95994 0 : }
95995 :
95996 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
95997 0 : void SgOmpBindClause::accept (ROSE_VisitorPattern & visitor) {
95998 0 : ROSE_ASSERT(this != NULL);
95999 0 : visitor.visit(this);
96000 0 : }
96001 :
96002 : SgOmpBindClause*
96003 0 : SgOmpBindClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
96004 : {
96005 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
96006 : // This function is currently only supported for the AST used the represent Binary executables.
96007 : if (0 /* isSgAsmNode(this) != NULL */)
96008 : {
96009 : // Support for regex specification.
96010 : std::string prefixCode = "REGEX:";
96011 : addNewAttribute(prefixCode + s,a);
96012 : }
96013 : #endif
96014 :
96015 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
96016 0 : return this;
96017 : }
96018 :
96019 : // *** COMMON CODE SECTION ENDS HERE ***
96020 :
96021 :
96022 : // End of memberFunctionString
96023 : // Start of memberFunctionString
96024 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
96025 :
96026 :
96027 : #if 0
96028 : //! Error checking support
96029 : /*! Verifies the following:
96030 : - working getVariant() member function
96031 : - calls base class's error() member function
96032 : Every class has one of these functions.
96033 : */
96034 : bool
96035 : SgOmpBindClause::error()
96036 : {
96037 : // Put error checking here
96038 :
96039 : ROSE_ASSERT (this != NULL);
96040 : if (getVariant() != OmpBindClauseTag)
96041 : {
96042 : printf ("Error in SgOmpBindClause::error(): SgOmpBindClause object has a %s variant \n",
96043 : Cxx_GrammarTerminalNames[getVariant()].name);
96044 : // printf ("Error in SgOmpBindClause::error() \n");
96045 : ROSE_ABORT();
96046 : }
96047 :
96048 : ROSE_ASSERT (getVariant() == OmpBindClauseTag);
96049 : return SgOmpClause::error();
96050 : }
96051 : #endif
96052 :
96053 :
96054 :
96055 : // End of memberFunctionString
96056 :
96057 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
96058 :
96059 3 : SgOmpBindClause* isSgOmpBindClause ( SgNode* inputDerivedClassPointer )
96060 : {
96061 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
96062 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
96063 : // So to fix this we return NULL directly when the input is NULL and avoid the
96064 : // dynamic_cast in this case. This is likely a performance improvement as well.
96065 : // return dynamic_cast<SgOmpBindClause*>(inputDerivedClassPointer);
96066 : // Milind Chabbi (8/28/2013): isSgOmpBindClause uses table-driven castability instead of c++ default dynamic_cast
96067 : // this improves the running time performance by 10-20%.
96068 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpBindClause*>(inputDerivedClassPointer);
96069 3 : return IS_SgOmpBindClause_FAST_MACRO(inputDerivedClassPointer);
96070 : }
96071 :
96072 : // DQ (11/8/2003): Added version of functions taking const pointer
96073 0 : const SgOmpBindClause* isSgOmpBindClause ( const SgNode* inputDerivedClassPointer )
96074 : {
96075 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
96076 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
96077 : // So to fix this we return NULL directly when the input is NULL and avoid the
96078 : // dynamic_cast in this case. This is likely a performance improvement as well.
96079 : // return dynamic_cast<const SgOmpBindClause*>(inputDerivedClassPointer);
96080 : // Milind Chabbi (8/28/2013): isSgOmpBindClause uses table-driven castability instead of c++ default dynamic_cast
96081 : // this improves the running time performance by 10-20%.
96082 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpBindClause*>(inputDerivedClassPointer);
96083 0 : return IS_SgOmpBindClause_FAST_MACRO(inputDerivedClassPointer);
96084 : }
96085 :
96086 :
96087 :
96088 : /* #line 96089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96089 :
96090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
96091 :
96092 : /**
96093 : \brief Generated destructor
96094 :
96095 : This destructor is automatically generated (by ROSETTA). This destructor
96096 : only frees memory of data members associated with the parts of the current IR node which
96097 : are NOT traversed. Those data members that are part of a traversal can be freed using
96098 : a traversal (calling this destructor on all children in a post-order traversal). Such
96099 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
96100 :
96101 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
96102 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
96103 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
96104 :
96105 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
96106 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
96107 : pointers are not yet implemented to call delete on eash pointer in the container.
96108 : (This could be done by derivation from the STL containers to define containers that
96109 : automatically deleted their members.)
96110 :
96111 : */
96112 0 : SgOmpBindClause::~SgOmpBindClause () {
96113 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
96114 :
96115 :
96116 : // case: not a listType for binding
96117 0 : p_binding =e_omp_bind_binding_unspecified; // non list case
96118 :
96119 : }
96120 :
96121 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
96122 0 : }
96123 :
96124 :
96125 : /* #line 96126 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96126 :
96127 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
96128 :
96129 : // Generated constructor
96130 0 : SgOmpBindClause::SgOmpBindClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_bind_binding_enum binding )
96131 0 : : SgOmpClause(startOfConstruct)
96132 : {
96133 : #ifdef DEBUG
96134 : // printf ("In SgOmpBindClause::SgOmpBindClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_bind_binding_enum binding) sage_class_name() = %s \n",sage_class_name());
96135 : #endif
96136 : #if 0
96137 : // debugging information!
96138 : printf ("In SgOmpBindClause::SgOmpBindClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_bind_binding_enum binding): this = %p = %s \n",this,this->class_name().c_str());
96139 : #endif
96140 :
96141 0 : p_binding = binding;
96142 :
96143 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
96144 :
96145 : #if 0
96146 : // DQ (7/30/2014): Call a virtual function.
96147 : std::string s = this->class_name();
96148 : #endif
96149 :
96150 : // Test the variant virtual function
96151 : // assert(OmpBindClauseTag == variant());
96152 0 : assert(OmpBindClauseTag == this->variant());
96153 0 : ROSE_ASSERT(OmpBindClauseTag == (int)(this->variantT()));
96154 0 : post_construction_initialization();
96155 :
96156 : // Test the isSgOmpBindClause() function since it has been problematic
96157 0 : assert(isSgOmpBindClause(this) != NULL);
96158 0 : }
96159 :
96160 : // Generated constructor (all data members)
96161 :
96162 : /* #line 96163 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96163 :
96164 :
96165 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
96166 :
96167 :
96168 : // ********************************************************
96169 : // member functions common across all array grammar objects
96170 : // ********************************************************
96171 :
96172 :
96173 :
96174 : /* #line 96175 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96175 :
96176 :
96177 :
96178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
96179 :
96180 : // ********************************************************
96181 : // member functions specific to each node in the grammar
96182 : // ********************************************************
96183 :
96184 :
96185 : /* #line 96186 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96186 :
96187 : // Start of memberFunctionString
96188 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
96189 :
96190 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
96191 :
96192 : SgOmpClause::omp_order_kind_enum
96193 1 : SgOmpOrderClause::get_kind () const
96194 : {
96195 1 : ROSE_ASSERT (this != NULL);
96196 :
96197 : #if 0
96198 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96199 : // used to trigger marking transformations for the token-based unparsing.
96200 : printf ("SgOmpOrderClause::get_kind = %p = %s \n",this,this->class_name().c_str());
96201 : #endif
96202 :
96203 1 : return p_kind;
96204 : }
96205 :
96206 : void
96207 0 : SgOmpOrderClause::set_kind ( SgOmpClause::omp_order_kind_enum kind )
96208 : {
96209 0 : ROSE_ASSERT (this != NULL);
96210 :
96211 : #if 0
96212 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96213 : // used to trigger marking transformations for the token-based unparsing.
96214 : printf ("SgOmpOrderClause::set_kind = %p = %s \n",this,this->class_name().c_str());
96215 : #endif
96216 :
96217 0 : set_isModified(true);
96218 :
96219 0 : p_kind = kind;
96220 0 : }
96221 :
96222 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
96223 :
96224 :
96225 : // End of memberFunctionString
96226 : // Start of memberFunctionString
96227 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
96228 :
96229 : // *** COMMON CODE SECTION BEGINS HERE ***
96230 :
96231 : #if 0
96232 : int
96233 : SgOmpOrderClause::getVariant() const
96234 : {
96235 : // This function is used in ROSE while "variant()" is used in SAGE
96236 : assert(this != NULL);
96237 : return variant();
96238 : }
96239 : #endif
96240 :
96241 : // This function is used in ROSE in treeTraversal code
96242 : // eventually replaces getVariant() and variant()
96243 : // though after variant() has been removed for a while we will
96244 : // want to change the name of variantT() back to variant()
96245 : // (since the "T" was ment to stand for temporary).
96246 : // When this happens the variantT() will be depricated.
96247 : VariantT
96248 28 : SgOmpOrderClause::variantT() const
96249 : {
96250 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
96251 28 : ROSE_ASSERT(this != NULL);
96252 28 : return V_SgOmpOrderClause;
96253 : }
96254 :
96255 : #if 0
96256 : int
96257 : SgOmpOrderClause::variant() const
96258 : {
96259 : // This function is used in SAGE
96260 : ROSE_ASSERT(this != NULL);
96261 : return OmpOrderClauseTag;
96262 : }
96263 : #endif
96264 :
96265 : ROSE_DLL_API const char*
96266 0 : SgOmpOrderClause::sage_class_name() const
96267 : {
96268 0 : ROSE_ASSERT(this != NULL);
96269 0 : return "SgOmpOrderClause";
96270 : }
96271 :
96272 : std::string
96273 1 : SgOmpOrderClause::class_name() const
96274 : {
96275 1 : ROSE_ASSERT(this != NULL);
96276 1 : return "SgOmpOrderClause";
96277 : }
96278 :
96279 : // DQ (11/26/2005): Support for visitor pattern mechanims
96280 : // (inferior to ROSE traversal mechanism, experimental).
96281 : void
96282 0 : SgOmpOrderClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
96283 : {
96284 0 : ROSE_ASSERT(this != NULL);
96285 0 : visitor.visit(this);
96286 0 : }
96287 :
96288 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
96289 0 : void SgOmpOrderClause::accept (ROSE_VisitorPattern & visitor) {
96290 0 : ROSE_ASSERT(this != NULL);
96291 0 : visitor.visit(this);
96292 0 : }
96293 :
96294 : SgOmpOrderClause*
96295 0 : SgOmpOrderClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
96296 : {
96297 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
96298 : // This function is currently only supported for the AST used the represent Binary executables.
96299 : if (0 /* isSgAsmNode(this) != NULL */)
96300 : {
96301 : // Support for regex specification.
96302 : std::string prefixCode = "REGEX:";
96303 : addNewAttribute(prefixCode + s,a);
96304 : }
96305 : #endif
96306 :
96307 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
96308 0 : return this;
96309 : }
96310 :
96311 : // *** COMMON CODE SECTION ENDS HERE ***
96312 :
96313 :
96314 : // End of memberFunctionString
96315 : // Start of memberFunctionString
96316 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
96317 :
96318 :
96319 : #if 0
96320 : //! Error checking support
96321 : /*! Verifies the following:
96322 : - working getVariant() member function
96323 : - calls base class's error() member function
96324 : Every class has one of these functions.
96325 : */
96326 : bool
96327 : SgOmpOrderClause::error()
96328 : {
96329 : // Put error checking here
96330 :
96331 : ROSE_ASSERT (this != NULL);
96332 : if (getVariant() != OmpOrderClauseTag)
96333 : {
96334 : printf ("Error in SgOmpOrderClause::error(): SgOmpOrderClause object has a %s variant \n",
96335 : Cxx_GrammarTerminalNames[getVariant()].name);
96336 : // printf ("Error in SgOmpOrderClause::error() \n");
96337 : ROSE_ABORT();
96338 : }
96339 :
96340 : ROSE_ASSERT (getVariant() == OmpOrderClauseTag);
96341 : return SgOmpClause::error();
96342 : }
96343 : #endif
96344 :
96345 :
96346 :
96347 : // End of memberFunctionString
96348 :
96349 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
96350 :
96351 3 : SgOmpOrderClause* isSgOmpOrderClause ( SgNode* inputDerivedClassPointer )
96352 : {
96353 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
96354 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
96355 : // So to fix this we return NULL directly when the input is NULL and avoid the
96356 : // dynamic_cast in this case. This is likely a performance improvement as well.
96357 : // return dynamic_cast<SgOmpOrderClause*>(inputDerivedClassPointer);
96358 : // Milind Chabbi (8/28/2013): isSgOmpOrderClause uses table-driven castability instead of c++ default dynamic_cast
96359 : // this improves the running time performance by 10-20%.
96360 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpOrderClause*>(inputDerivedClassPointer);
96361 3 : return IS_SgOmpOrderClause_FAST_MACRO(inputDerivedClassPointer);
96362 : }
96363 :
96364 : // DQ (11/8/2003): Added version of functions taking const pointer
96365 0 : const SgOmpOrderClause* isSgOmpOrderClause ( const SgNode* inputDerivedClassPointer )
96366 : {
96367 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
96368 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
96369 : // So to fix this we return NULL directly when the input is NULL and avoid the
96370 : // dynamic_cast in this case. This is likely a performance improvement as well.
96371 : // return dynamic_cast<const SgOmpOrderClause*>(inputDerivedClassPointer);
96372 : // Milind Chabbi (8/28/2013): isSgOmpOrderClause uses table-driven castability instead of c++ default dynamic_cast
96373 : // this improves the running time performance by 10-20%.
96374 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpOrderClause*>(inputDerivedClassPointer);
96375 0 : return IS_SgOmpOrderClause_FAST_MACRO(inputDerivedClassPointer);
96376 : }
96377 :
96378 :
96379 :
96380 : /* #line 96381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96381 :
96382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
96383 :
96384 : /**
96385 : \brief Generated destructor
96386 :
96387 : This destructor is automatically generated (by ROSETTA). This destructor
96388 : only frees memory of data members associated with the parts of the current IR node which
96389 : are NOT traversed. Those data members that are part of a traversal can be freed using
96390 : a traversal (calling this destructor on all children in a post-order traversal). Such
96391 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
96392 :
96393 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
96394 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
96395 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
96396 :
96397 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
96398 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
96399 : pointers are not yet implemented to call delete on eash pointer in the container.
96400 : (This could be done by derivation from the STL containers to define containers that
96401 : automatically deleted their members.)
96402 :
96403 : */
96404 0 : SgOmpOrderClause::~SgOmpOrderClause () {
96405 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
96406 :
96407 :
96408 : // case: not a listType for kind
96409 0 : p_kind =e_omp_order_kind_unspecified; // non list case
96410 :
96411 : }
96412 :
96413 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
96414 0 : }
96415 :
96416 :
96417 : /* #line 96418 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96418 :
96419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
96420 :
96421 : // Generated constructor
96422 0 : SgOmpOrderClause::SgOmpOrderClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_order_kind_enum kind )
96423 0 : : SgOmpClause(startOfConstruct)
96424 : {
96425 : #ifdef DEBUG
96426 : // printf ("In SgOmpOrderClause::SgOmpOrderClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_order_kind_enum kind) sage_class_name() = %s \n",sage_class_name());
96427 : #endif
96428 : #if 0
96429 : // debugging information!
96430 : printf ("In SgOmpOrderClause::SgOmpOrderClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_order_kind_enum kind): this = %p = %s \n",this,this->class_name().c_str());
96431 : #endif
96432 :
96433 0 : p_kind = kind;
96434 :
96435 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
96436 :
96437 : #if 0
96438 : // DQ (7/30/2014): Call a virtual function.
96439 : std::string s = this->class_name();
96440 : #endif
96441 :
96442 : // Test the variant virtual function
96443 : // assert(OmpOrderClauseTag == variant());
96444 0 : assert(OmpOrderClauseTag == this->variant());
96445 0 : ROSE_ASSERT(OmpOrderClauseTag == (int)(this->variantT()));
96446 0 : post_construction_initialization();
96447 :
96448 : // Test the isSgOmpOrderClause() function since it has been problematic
96449 0 : assert(isSgOmpOrderClause(this) != NULL);
96450 0 : }
96451 :
96452 : // Generated constructor (all data members)
96453 :
96454 : /* #line 96455 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96455 :
96456 :
96457 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
96458 :
96459 :
96460 : // ********************************************************
96461 : // member functions common across all array grammar objects
96462 : // ********************************************************
96463 :
96464 :
96465 :
96466 : /* #line 96467 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96467 :
96468 :
96469 :
96470 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
96471 :
96472 : // ********************************************************
96473 : // member functions specific to each node in the grammar
96474 : // ********************************************************
96475 :
96476 :
96477 : /* #line 96478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96478 :
96479 : // Start of memberFunctionString
96480 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
96481 :
96482 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
96483 :
96484 : SgOmpClause::omp_dist_schedule_kind_enum
96485 1 : SgOmpDistScheduleClause::get_kind () const
96486 : {
96487 1 : ROSE_ASSERT (this != NULL);
96488 :
96489 : #if 0
96490 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96491 : // used to trigger marking transformations for the token-based unparsing.
96492 : printf ("SgOmpDistScheduleClause::get_kind = %p = %s \n",this,this->class_name().c_str());
96493 : #endif
96494 :
96495 1 : return p_kind;
96496 : }
96497 :
96498 : void
96499 0 : SgOmpDistScheduleClause::set_kind ( SgOmpClause::omp_dist_schedule_kind_enum kind )
96500 : {
96501 0 : ROSE_ASSERT (this != NULL);
96502 :
96503 : #if 0
96504 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96505 : // used to trigger marking transformations for the token-based unparsing.
96506 : printf ("SgOmpDistScheduleClause::set_kind = %p = %s \n",this,this->class_name().c_str());
96507 : #endif
96508 :
96509 0 : set_isModified(true);
96510 :
96511 0 : p_kind = kind;
96512 0 : }
96513 :
96514 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
96515 :
96516 :
96517 : // End of memberFunctionString
96518 : // Start of memberFunctionString
96519 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
96520 :
96521 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
96522 :
96523 : SgExpression*
96524 2 : SgOmpDistScheduleClause::get_chunk_size () const
96525 : {
96526 2 : ROSE_ASSERT (this != NULL);
96527 :
96528 : #if 0
96529 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96530 : // used to trigger marking transformations for the token-based unparsing.
96531 : printf ("SgOmpDistScheduleClause::get_chunk_size = %p = %s \n",this,this->class_name().c_str());
96532 : #endif
96533 :
96534 2 : return p_chunk_size;
96535 : }
96536 :
96537 : void
96538 0 : SgOmpDistScheduleClause::set_chunk_size ( SgExpression* chunk_size )
96539 : {
96540 0 : ROSE_ASSERT (this != NULL);
96541 :
96542 : #if 0
96543 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96544 : // used to trigger marking transformations for the token-based unparsing.
96545 : printf ("SgOmpDistScheduleClause::set_chunk_size = %p = %s \n",this,this->class_name().c_str());
96546 : #endif
96547 :
96548 0 : set_isModified(true);
96549 :
96550 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
96551 : if (p_chunk_size != NULL && chunk_size != NULL && p_chunk_size != chunk_size)
96552 : {
96553 : printf ("Warning: chunk_size = %p overwriting valid pointer p_chunk_size = %p \n",chunk_size,p_chunk_size);
96554 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
96555 : printf ("Error fails assertion (p_chunk_size != NULL && chunk_size != NULL && p_chunk_size != chunk_size) is false\n");
96556 : ROSE_ASSERT(false);
96557 : #endif
96558 : }
96559 : #endif
96560 0 : p_chunk_size = chunk_size;
96561 0 : }
96562 :
96563 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
96564 :
96565 :
96566 : // End of memberFunctionString
96567 : // Start of memberFunctionString
96568 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
96569 :
96570 : // *** COMMON CODE SECTION BEGINS HERE ***
96571 :
96572 : #if 0
96573 : int
96574 : SgOmpDistScheduleClause::getVariant() const
96575 : {
96576 : // This function is used in ROSE while "variant()" is used in SAGE
96577 : assert(this != NULL);
96578 : return variant();
96579 : }
96580 : #endif
96581 :
96582 : // This function is used in ROSE in treeTraversal code
96583 : // eventually replaces getVariant() and variant()
96584 : // though after variant() has been removed for a while we will
96585 : // want to change the name of variantT() back to variant()
96586 : // (since the "T" was ment to stand for temporary).
96587 : // When this happens the variantT() will be depricated.
96588 : VariantT
96589 54 : SgOmpDistScheduleClause::variantT() const
96590 : {
96591 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
96592 54 : ROSE_ASSERT(this != NULL);
96593 54 : return V_SgOmpDistScheduleClause;
96594 : }
96595 :
96596 : #if 0
96597 : int
96598 : SgOmpDistScheduleClause::variant() const
96599 : {
96600 : // This function is used in SAGE
96601 : ROSE_ASSERT(this != NULL);
96602 : return OmpDistScheduleClauseTag;
96603 : }
96604 : #endif
96605 :
96606 : ROSE_DLL_API const char*
96607 0 : SgOmpDistScheduleClause::sage_class_name() const
96608 : {
96609 0 : ROSE_ASSERT(this != NULL);
96610 0 : return "SgOmpDistScheduleClause";
96611 : }
96612 :
96613 : std::string
96614 1 : SgOmpDistScheduleClause::class_name() const
96615 : {
96616 1 : ROSE_ASSERT(this != NULL);
96617 1 : return "SgOmpDistScheduleClause";
96618 : }
96619 :
96620 : // DQ (11/26/2005): Support for visitor pattern mechanims
96621 : // (inferior to ROSE traversal mechanism, experimental).
96622 : void
96623 0 : SgOmpDistScheduleClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
96624 : {
96625 0 : ROSE_ASSERT(this != NULL);
96626 0 : visitor.visit(this);
96627 0 : }
96628 :
96629 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
96630 0 : void SgOmpDistScheduleClause::accept (ROSE_VisitorPattern & visitor) {
96631 0 : ROSE_ASSERT(this != NULL);
96632 0 : visitor.visit(this);
96633 0 : }
96634 :
96635 : SgOmpDistScheduleClause*
96636 0 : SgOmpDistScheduleClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
96637 : {
96638 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
96639 : // This function is currently only supported for the AST used the represent Binary executables.
96640 : if (0 /* isSgAsmNode(this) != NULL */)
96641 : {
96642 : // Support for regex specification.
96643 : std::string prefixCode = "REGEX:";
96644 : addNewAttribute(prefixCode + s,a);
96645 : }
96646 : #endif
96647 :
96648 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
96649 0 : return this;
96650 : }
96651 :
96652 : // *** COMMON CODE SECTION ENDS HERE ***
96653 :
96654 :
96655 : // End of memberFunctionString
96656 : // Start of memberFunctionString
96657 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
96658 :
96659 :
96660 : #if 0
96661 : //! Error checking support
96662 : /*! Verifies the following:
96663 : - working getVariant() member function
96664 : - calls base class's error() member function
96665 : Every class has one of these functions.
96666 : */
96667 : bool
96668 : SgOmpDistScheduleClause::error()
96669 : {
96670 : // Put error checking here
96671 :
96672 : ROSE_ASSERT (this != NULL);
96673 : if (getVariant() != OmpDistScheduleClauseTag)
96674 : {
96675 : printf ("Error in SgOmpDistScheduleClause::error(): SgOmpDistScheduleClause object has a %s variant \n",
96676 : Cxx_GrammarTerminalNames[getVariant()].name);
96677 : // printf ("Error in SgOmpDistScheduleClause::error() \n");
96678 : ROSE_ABORT();
96679 : }
96680 :
96681 : ROSE_ASSERT (getVariant() == OmpDistScheduleClauseTag);
96682 : return SgOmpClause::error();
96683 : }
96684 : #endif
96685 :
96686 :
96687 :
96688 : // End of memberFunctionString
96689 :
96690 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
96691 :
96692 3 : SgOmpDistScheduleClause* isSgOmpDistScheduleClause ( SgNode* inputDerivedClassPointer )
96693 : {
96694 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
96695 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
96696 : // So to fix this we return NULL directly when the input is NULL and avoid the
96697 : // dynamic_cast in this case. This is likely a performance improvement as well.
96698 : // return dynamic_cast<SgOmpDistScheduleClause*>(inputDerivedClassPointer);
96699 : // Milind Chabbi (8/28/2013): isSgOmpDistScheduleClause uses table-driven castability instead of c++ default dynamic_cast
96700 : // this improves the running time performance by 10-20%.
96701 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDistScheduleClause*>(inputDerivedClassPointer);
96702 3 : return IS_SgOmpDistScheduleClause_FAST_MACRO(inputDerivedClassPointer);
96703 : }
96704 :
96705 : // DQ (11/8/2003): Added version of functions taking const pointer
96706 0 : const SgOmpDistScheduleClause* isSgOmpDistScheduleClause ( const SgNode* inputDerivedClassPointer )
96707 : {
96708 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
96709 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
96710 : // So to fix this we return NULL directly when the input is NULL and avoid the
96711 : // dynamic_cast in this case. This is likely a performance improvement as well.
96712 : // return dynamic_cast<const SgOmpDistScheduleClause*>(inputDerivedClassPointer);
96713 : // Milind Chabbi (8/28/2013): isSgOmpDistScheduleClause uses table-driven castability instead of c++ default dynamic_cast
96714 : // this improves the running time performance by 10-20%.
96715 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDistScheduleClause*>(inputDerivedClassPointer);
96716 0 : return IS_SgOmpDistScheduleClause_FAST_MACRO(inputDerivedClassPointer);
96717 : }
96718 :
96719 :
96720 :
96721 : /* #line 96722 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96722 :
96723 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
96724 :
96725 : /**
96726 : \brief Generated destructor
96727 :
96728 : This destructor is automatically generated (by ROSETTA). This destructor
96729 : only frees memory of data members associated with the parts of the current IR node which
96730 : are NOT traversed. Those data members that are part of a traversal can be freed using
96731 : a traversal (calling this destructor on all children in a post-order traversal). Such
96732 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
96733 :
96734 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
96735 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
96736 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
96737 :
96738 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
96739 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
96740 : pointers are not yet implemented to call delete on eash pointer in the container.
96741 : (This could be done by derivation from the STL containers to define containers that
96742 : automatically deleted their members.)
96743 :
96744 : */
96745 0 : SgOmpDistScheduleClause::~SgOmpDistScheduleClause () {
96746 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
96747 :
96748 :
96749 : // case: not a listType for kind
96750 0 : p_kind =e_omp_dist_schedule_kind_unspecified; // non list case
96751 : // case: not a listType for chunk_size
96752 0 : p_chunk_size = NULL; // non list case
96753 :
96754 : }
96755 :
96756 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
96757 0 : }
96758 :
96759 :
96760 : /* #line 96761 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96761 :
96762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
96763 :
96764 : // Generated constructor
96765 0 : SgOmpDistScheduleClause::SgOmpDistScheduleClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_dist_schedule_kind_enum kind, SgExpression* chunk_size )
96766 0 : : SgOmpClause(startOfConstruct)
96767 : {
96768 : #ifdef DEBUG
96769 : // printf ("In SgOmpDistScheduleClause::SgOmpDistScheduleClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_dist_schedule_kind_enum kind, SgExpression* chunk_size) sage_class_name() = %s \n",sage_class_name());
96770 : #endif
96771 : #if 0
96772 : // debugging information!
96773 : printf ("In SgOmpDistScheduleClause::SgOmpDistScheduleClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_dist_schedule_kind_enum kind, SgExpression* chunk_size): this = %p = %s \n",this,this->class_name().c_str());
96774 : #endif
96775 :
96776 0 : p_kind = kind;
96777 0 : p_chunk_size = chunk_size;
96778 :
96779 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
96780 :
96781 : #if 0
96782 : // DQ (7/30/2014): Call a virtual function.
96783 : std::string s = this->class_name();
96784 : #endif
96785 :
96786 : // Test the variant virtual function
96787 : // assert(OmpDistScheduleClauseTag == variant());
96788 0 : assert(OmpDistScheduleClauseTag == this->variant());
96789 0 : ROSE_ASSERT(OmpDistScheduleClauseTag == (int)(this->variantT()));
96790 0 : post_construction_initialization();
96791 :
96792 : // Test the isSgOmpDistScheduleClause() function since it has been problematic
96793 0 : assert(isSgOmpDistScheduleClause(this) != NULL);
96794 0 : }
96795 :
96796 : // Generated constructor (all data members)
96797 :
96798 : /* #line 96799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96799 :
96800 :
96801 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
96802 :
96803 :
96804 : // ********************************************************
96805 : // member functions common across all array grammar objects
96806 : // ********************************************************
96807 :
96808 :
96809 :
96810 : /* #line 96811 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96811 :
96812 :
96813 :
96814 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
96815 :
96816 : // ********************************************************
96817 : // member functions specific to each node in the grammar
96818 : // ********************************************************
96819 :
96820 :
96821 : /* #line 96822 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
96822 :
96823 : // Start of memberFunctionString
96824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
96825 :
96826 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
96827 :
96828 : SgExpression*
96829 213 : SgOmpExpressionClause::get_expression () const
96830 : {
96831 213 : ROSE_ASSERT (this != NULL);
96832 :
96833 : #if 0
96834 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96835 : // used to trigger marking transformations for the token-based unparsing.
96836 : printf ("SgOmpExpressionClause::get_expression = %p = %s \n",this,this->class_name().c_str());
96837 : #endif
96838 :
96839 213 : return p_expression;
96840 : }
96841 :
96842 : void
96843 0 : SgOmpExpressionClause::set_expression ( SgExpression* expression )
96844 : {
96845 0 : ROSE_ASSERT (this != NULL);
96846 :
96847 : #if 0
96848 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
96849 : // used to trigger marking transformations for the token-based unparsing.
96850 : printf ("SgOmpExpressionClause::set_expression = %p = %s \n",this,this->class_name().c_str());
96851 : #endif
96852 :
96853 0 : set_isModified(true);
96854 :
96855 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
96856 : if (p_expression != NULL && expression != NULL && p_expression != expression)
96857 : {
96858 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
96859 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
96860 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
96861 : ROSE_ASSERT(false);
96862 : #endif
96863 : }
96864 : #endif
96865 0 : p_expression = expression;
96866 0 : }
96867 :
96868 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
96869 :
96870 :
96871 : // End of memberFunctionString
96872 : // Start of memberFunctionString
96873 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
96874 :
96875 : // *** COMMON CODE SECTION BEGINS HERE ***
96876 :
96877 : #if 0
96878 : int
96879 : SgOmpExpressionClause::getVariant() const
96880 : {
96881 : // This function is used in ROSE while "variant()" is used in SAGE
96882 : assert(this != NULL);
96883 : return variant();
96884 : }
96885 : #endif
96886 :
96887 : // This function is used in ROSE in treeTraversal code
96888 : // eventually replaces getVariant() and variant()
96889 : // though after variant() has been removed for a while we will
96890 : // want to change the name of variantT() back to variant()
96891 : // (since the "T" was ment to stand for temporary).
96892 : // When this happens the variantT() will be depricated.
96893 : VariantT
96894 327 : SgOmpExpressionClause::variantT() const
96895 : {
96896 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
96897 327 : ROSE_ASSERT(this != NULL);
96898 327 : return V_SgOmpExpressionClause;
96899 : }
96900 :
96901 : #if 0
96902 : int
96903 : SgOmpExpressionClause::variant() const
96904 : {
96905 : // This function is used in SAGE
96906 : ROSE_ASSERT(this != NULL);
96907 : return OmpExpressionClauseTag;
96908 : }
96909 : #endif
96910 :
96911 : ROSE_DLL_API const char*
96912 0 : SgOmpExpressionClause::sage_class_name() const
96913 : {
96914 0 : ROSE_ASSERT(this != NULL);
96915 0 : return "SgOmpExpressionClause";
96916 : }
96917 :
96918 : std::string
96919 0 : SgOmpExpressionClause::class_name() const
96920 : {
96921 0 : ROSE_ASSERT(this != NULL);
96922 0 : return "SgOmpExpressionClause";
96923 : }
96924 :
96925 : // DQ (11/26/2005): Support for visitor pattern mechanims
96926 : // (inferior to ROSE traversal mechanism, experimental).
96927 : void
96928 0 : SgOmpExpressionClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
96929 : {
96930 0 : ROSE_ASSERT(this != NULL);
96931 0 : visitor.visit(this);
96932 0 : }
96933 :
96934 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
96935 0 : void SgOmpExpressionClause::accept (ROSE_VisitorPattern & visitor) {
96936 0 : ROSE_ASSERT(this != NULL);
96937 0 : visitor.visit(this);
96938 0 : }
96939 :
96940 : SgOmpExpressionClause*
96941 0 : SgOmpExpressionClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
96942 : {
96943 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
96944 : // This function is currently only supported for the AST used the represent Binary executables.
96945 : if (0 /* isSgAsmNode(this) != NULL */)
96946 : {
96947 : // Support for regex specification.
96948 : std::string prefixCode = "REGEX:";
96949 : addNewAttribute(prefixCode + s,a);
96950 : }
96951 : #endif
96952 :
96953 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
96954 0 : return this;
96955 : }
96956 :
96957 : // *** COMMON CODE SECTION ENDS HERE ***
96958 :
96959 :
96960 : // End of memberFunctionString
96961 : // Start of memberFunctionString
96962 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
96963 :
96964 :
96965 : #if 0
96966 : //! Error checking support
96967 : /*! Verifies the following:
96968 : - working getVariant() member function
96969 : - calls base class's error() member function
96970 : Every class has one of these functions.
96971 : */
96972 : bool
96973 : SgOmpExpressionClause::error()
96974 : {
96975 : // Put error checking here
96976 :
96977 : ROSE_ASSERT (this != NULL);
96978 : if (getVariant() != OmpExpressionClauseTag)
96979 : {
96980 : printf ("Error in SgOmpExpressionClause::error(): SgOmpExpressionClause object has a %s variant \n",
96981 : Cxx_GrammarTerminalNames[getVariant()].name);
96982 : // printf ("Error in SgOmpExpressionClause::error() \n");
96983 : ROSE_ABORT();
96984 : }
96985 :
96986 : ROSE_ASSERT (getVariant() == OmpExpressionClauseTag);
96987 : return SgOmpClause::error();
96988 : }
96989 : #endif
96990 :
96991 :
96992 :
96993 : // End of memberFunctionString
96994 :
96995 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
96996 :
96997 436 : SgOmpExpressionClause* isSgOmpExpressionClause ( SgNode* inputDerivedClassPointer )
96998 : {
96999 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97000 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97001 : // So to fix this we return NULL directly when the input is NULL and avoid the
97002 : // dynamic_cast in this case. This is likely a performance improvement as well.
97003 : // return dynamic_cast<SgOmpExpressionClause*>(inputDerivedClassPointer);
97004 : // Milind Chabbi (8/28/2013): isSgOmpExpressionClause uses table-driven castability instead of c++ default dynamic_cast
97005 : // this improves the running time performance by 10-20%.
97006 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpExpressionClause*>(inputDerivedClassPointer);
97007 436 : return IS_SgOmpExpressionClause_FAST_MACRO(inputDerivedClassPointer);
97008 : }
97009 :
97010 : // DQ (11/8/2003): Added version of functions taking const pointer
97011 0 : const SgOmpExpressionClause* isSgOmpExpressionClause ( const SgNode* inputDerivedClassPointer )
97012 : {
97013 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97014 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97015 : // So to fix this we return NULL directly when the input is NULL and avoid the
97016 : // dynamic_cast in this case. This is likely a performance improvement as well.
97017 : // return dynamic_cast<const SgOmpExpressionClause*>(inputDerivedClassPointer);
97018 : // Milind Chabbi (8/28/2013): isSgOmpExpressionClause uses table-driven castability instead of c++ default dynamic_cast
97019 : // this improves the running time performance by 10-20%.
97020 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpExpressionClause*>(inputDerivedClassPointer);
97021 0 : return IS_SgOmpExpressionClause_FAST_MACRO(inputDerivedClassPointer);
97022 : }
97023 :
97024 :
97025 :
97026 : /* #line 97027 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97027 :
97028 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97029 :
97030 : /**
97031 : \brief Generated destructor
97032 :
97033 : This destructor is automatically generated (by ROSETTA). This destructor
97034 : only frees memory of data members associated with the parts of the current IR node which
97035 : are NOT traversed. Those data members that are part of a traversal can be freed using
97036 : a traversal (calling this destructor on all children in a post-order traversal). Such
97037 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
97038 :
97039 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
97040 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
97041 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
97042 :
97043 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
97044 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
97045 : pointers are not yet implemented to call delete on eash pointer in the container.
97046 : (This could be done by derivation from the STL containers to define containers that
97047 : automatically deleted their members.)
97048 :
97049 : */
97050 0 : SgOmpExpressionClause::~SgOmpExpressionClause () {
97051 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
97052 :
97053 :
97054 : // case: not a listType for expression
97055 0 : p_expression = NULL; // non list case
97056 :
97057 : }
97058 :
97059 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97060 0 : }
97061 :
97062 :
97063 : /* #line 97064 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97064 :
97065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
97066 :
97067 : // Generated constructor
97068 0 : SgOmpExpressionClause::SgOmpExpressionClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
97069 0 : : SgOmpClause(startOfConstruct)
97070 : {
97071 : #ifdef DEBUG
97072 : // printf ("In SgOmpExpressionClause::SgOmpExpressionClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
97073 : #endif
97074 : #if 0
97075 : // debugging information!
97076 : printf ("In SgOmpExpressionClause::SgOmpExpressionClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
97077 : #endif
97078 :
97079 0 : p_expression = expression;
97080 :
97081 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
97082 :
97083 : #if 0
97084 : // DQ (7/30/2014): Call a virtual function.
97085 : std::string s = this->class_name();
97086 : #endif
97087 :
97088 : // Test the variant virtual function
97089 : // assert(OmpExpressionClauseTag == variant());
97090 0 : assert(OmpExpressionClauseTag == this->variant());
97091 0 : ROSE_ASSERT(OmpExpressionClauseTag == (int)(this->variantT()));
97092 0 : post_construction_initialization();
97093 :
97094 : // Test the isSgOmpExpressionClause() function since it has been problematic
97095 0 : assert(isSgOmpExpressionClause(this) != NULL);
97096 0 : }
97097 :
97098 : // Generated constructor (all data members)
97099 :
97100 : /* #line 97101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97101 :
97102 :
97103 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97104 :
97105 :
97106 : // ********************************************************
97107 : // member functions common across all array grammar objects
97108 : // ********************************************************
97109 :
97110 :
97111 :
97112 : /* #line 97113 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97113 :
97114 :
97115 :
97116 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97117 :
97118 : // ********************************************************
97119 : // member functions specific to each node in the grammar
97120 : // ********************************************************
97121 :
97122 :
97123 : /* #line 97124 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97124 :
97125 : // Start of memberFunctionString
97126 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
97127 :
97128 : // *** COMMON CODE SECTION BEGINS HERE ***
97129 :
97130 : #if 0
97131 : int
97132 : SgOmpOrderedClause::getVariant() const
97133 : {
97134 : // This function is used in ROSE while "variant()" is used in SAGE
97135 : assert(this != NULL);
97136 : return variant();
97137 : }
97138 : #endif
97139 :
97140 : // This function is used in ROSE in treeTraversal code
97141 : // eventually replaces getVariant() and variant()
97142 : // though after variant() has been removed for a while we will
97143 : // want to change the name of variantT() back to variant()
97144 : // (since the "T" was ment to stand for temporary).
97145 : // When this happens the variantT() will be depricated.
97146 : VariantT
97147 406 : SgOmpOrderedClause::variantT() const
97148 : {
97149 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
97150 406 : ROSE_ASSERT(this != NULL);
97151 406 : return V_SgOmpOrderedClause;
97152 : }
97153 :
97154 : #if 0
97155 : int
97156 : SgOmpOrderedClause::variant() const
97157 : {
97158 : // This function is used in SAGE
97159 : ROSE_ASSERT(this != NULL);
97160 : return OmpOrderedClauseTag;
97161 : }
97162 : #endif
97163 :
97164 : ROSE_DLL_API const char*
97165 0 : SgOmpOrderedClause::sage_class_name() const
97166 : {
97167 0 : ROSE_ASSERT(this != NULL);
97168 0 : return "SgOmpOrderedClause";
97169 : }
97170 :
97171 : std::string
97172 13 : SgOmpOrderedClause::class_name() const
97173 : {
97174 13 : ROSE_ASSERT(this != NULL);
97175 13 : return "SgOmpOrderedClause";
97176 : }
97177 :
97178 : // DQ (11/26/2005): Support for visitor pattern mechanims
97179 : // (inferior to ROSE traversal mechanism, experimental).
97180 : void
97181 0 : SgOmpOrderedClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
97182 : {
97183 0 : ROSE_ASSERT(this != NULL);
97184 0 : visitor.visit(this);
97185 0 : }
97186 :
97187 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
97188 0 : void SgOmpOrderedClause::accept (ROSE_VisitorPattern & visitor) {
97189 0 : ROSE_ASSERT(this != NULL);
97190 0 : visitor.visit(this);
97191 0 : }
97192 :
97193 : SgOmpOrderedClause*
97194 0 : SgOmpOrderedClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
97195 : {
97196 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
97197 : // This function is currently only supported for the AST used the represent Binary executables.
97198 : if (0 /* isSgAsmNode(this) != NULL */)
97199 : {
97200 : // Support for regex specification.
97201 : std::string prefixCode = "REGEX:";
97202 : addNewAttribute(prefixCode + s,a);
97203 : }
97204 : #endif
97205 :
97206 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
97207 0 : return this;
97208 : }
97209 :
97210 : // *** COMMON CODE SECTION ENDS HERE ***
97211 :
97212 :
97213 : // End of memberFunctionString
97214 : // Start of memberFunctionString
97215 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
97216 :
97217 :
97218 : #if 0
97219 : //! Error checking support
97220 : /*! Verifies the following:
97221 : - working getVariant() member function
97222 : - calls base class's error() member function
97223 : Every class has one of these functions.
97224 : */
97225 : bool
97226 : SgOmpOrderedClause::error()
97227 : {
97228 : // Put error checking here
97229 :
97230 : ROSE_ASSERT (this != NULL);
97231 : if (getVariant() != OmpOrderedClauseTag)
97232 : {
97233 : printf ("Error in SgOmpOrderedClause::error(): SgOmpOrderedClause object has a %s variant \n",
97234 : Cxx_GrammarTerminalNames[getVariant()].name);
97235 : // printf ("Error in SgOmpOrderedClause::error() \n");
97236 : ROSE_ABORT();
97237 : }
97238 :
97239 : ROSE_ASSERT (getVariant() == OmpOrderedClauseTag);
97240 : return SgOmpExpressionClause::error();
97241 : }
97242 : #endif
97243 :
97244 :
97245 :
97246 : // End of memberFunctionString
97247 :
97248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
97249 :
97250 165 : SgOmpOrderedClause* isSgOmpOrderedClause ( SgNode* inputDerivedClassPointer )
97251 : {
97252 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97253 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97254 : // So to fix this we return NULL directly when the input is NULL and avoid the
97255 : // dynamic_cast in this case. This is likely a performance improvement as well.
97256 : // return dynamic_cast<SgOmpOrderedClause*>(inputDerivedClassPointer);
97257 : // Milind Chabbi (8/28/2013): isSgOmpOrderedClause uses table-driven castability instead of c++ default dynamic_cast
97258 : // this improves the running time performance by 10-20%.
97259 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpOrderedClause*>(inputDerivedClassPointer);
97260 165 : return IS_SgOmpOrderedClause_FAST_MACRO(inputDerivedClassPointer);
97261 : }
97262 :
97263 : // DQ (11/8/2003): Added version of functions taking const pointer
97264 0 : const SgOmpOrderedClause* isSgOmpOrderedClause ( const SgNode* inputDerivedClassPointer )
97265 : {
97266 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97267 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97268 : // So to fix this we return NULL directly when the input is NULL and avoid the
97269 : // dynamic_cast in this case. This is likely a performance improvement as well.
97270 : // return dynamic_cast<const SgOmpOrderedClause*>(inputDerivedClassPointer);
97271 : // Milind Chabbi (8/28/2013): isSgOmpOrderedClause uses table-driven castability instead of c++ default dynamic_cast
97272 : // this improves the running time performance by 10-20%.
97273 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpOrderedClause*>(inputDerivedClassPointer);
97274 0 : return IS_SgOmpOrderedClause_FAST_MACRO(inputDerivedClassPointer);
97275 : }
97276 :
97277 :
97278 :
97279 : /* #line 97280 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97280 :
97281 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97282 :
97283 : /**
97284 : \brief Generated destructor
97285 :
97286 : This destructor is automatically generated (by ROSETTA). This destructor
97287 : only frees memory of data members associated with the parts of the current IR node which
97288 : are NOT traversed. Those data members that are part of a traversal can be freed using
97289 : a traversal (calling this destructor on all children in a post-order traversal). Such
97290 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
97291 :
97292 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
97293 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
97294 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
97295 :
97296 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
97297 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
97298 : pointers are not yet implemented to call delete on eash pointer in the container.
97299 : (This could be done by derivation from the STL containers to define containers that
97300 : automatically deleted their members.)
97301 :
97302 : */
97303 0 : SgOmpOrderedClause::~SgOmpOrderedClause () {
97304 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
97305 :
97306 :
97307 :
97308 : }
97309 :
97310 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97311 0 : }
97312 :
97313 :
97314 : /* #line 97315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97315 :
97316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
97317 :
97318 : // Generated constructor
97319 0 : SgOmpOrderedClause::SgOmpOrderedClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
97320 0 : : SgOmpExpressionClause(startOfConstruct, expression)
97321 : {
97322 : #ifdef DEBUG
97323 : // printf ("In SgOmpOrderedClause::SgOmpOrderedClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
97324 : #endif
97325 : #if 0
97326 : // debugging information!
97327 : printf ("In SgOmpOrderedClause::SgOmpOrderedClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
97328 : #endif
97329 :
97330 :
97331 :
97332 : #if 0
97333 : // DQ (7/30/2014): Call a virtual function.
97334 : std::string s = this->class_name();
97335 : #endif
97336 :
97337 : // Test the variant virtual function
97338 : // assert(OmpOrderedClauseTag == variant());
97339 0 : assert(OmpOrderedClauseTag == this->variant());
97340 0 : ROSE_ASSERT(OmpOrderedClauseTag == (int)(this->variantT()));
97341 0 : post_construction_initialization();
97342 :
97343 : // Test the isSgOmpOrderedClause() function since it has been problematic
97344 0 : assert(isSgOmpOrderedClause(this) != NULL);
97345 0 : }
97346 :
97347 : // Generated constructor (all data members)
97348 :
97349 : /* #line 97350 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97350 :
97351 :
97352 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97353 :
97354 :
97355 : // ********************************************************
97356 : // member functions common across all array grammar objects
97357 : // ********************************************************
97358 :
97359 :
97360 :
97361 : /* #line 97362 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97362 :
97363 :
97364 :
97365 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97366 :
97367 : // ********************************************************
97368 : // member functions specific to each node in the grammar
97369 : // ********************************************************
97370 :
97371 :
97372 : /* #line 97373 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97373 :
97374 : // Start of memberFunctionString
97375 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
97376 :
97377 : // *** COMMON CODE SECTION BEGINS HERE ***
97378 :
97379 : #if 0
97380 : int
97381 : SgOmpCollapseClause::getVariant() const
97382 : {
97383 : // This function is used in ROSE while "variant()" is used in SAGE
97384 : assert(this != NULL);
97385 : return variant();
97386 : }
97387 : #endif
97388 :
97389 : // This function is used in ROSE in treeTraversal code
97390 : // eventually replaces getVariant() and variant()
97391 : // though after variant() has been removed for a while we will
97392 : // want to change the name of variantT() back to variant()
97393 : // (since the "T" was ment to stand for temporary).
97394 : // When this happens the variantT() will be depricated.
97395 : VariantT
97396 393 : SgOmpCollapseClause::variantT() const
97397 : {
97398 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
97399 393 : ROSE_ASSERT(this != NULL);
97400 393 : return V_SgOmpCollapseClause;
97401 : }
97402 :
97403 : #if 0
97404 : int
97405 : SgOmpCollapseClause::variant() const
97406 : {
97407 : // This function is used in SAGE
97408 : ROSE_ASSERT(this != NULL);
97409 : return OmpCollapseClauseTag;
97410 : }
97411 : #endif
97412 :
97413 : ROSE_DLL_API const char*
97414 0 : SgOmpCollapseClause::sage_class_name() const
97415 : {
97416 0 : ROSE_ASSERT(this != NULL);
97417 0 : return "SgOmpCollapseClause";
97418 : }
97419 :
97420 : std::string
97421 11 : SgOmpCollapseClause::class_name() const
97422 : {
97423 11 : ROSE_ASSERT(this != NULL);
97424 11 : return "SgOmpCollapseClause";
97425 : }
97426 :
97427 : // DQ (11/26/2005): Support for visitor pattern mechanims
97428 : // (inferior to ROSE traversal mechanism, experimental).
97429 : void
97430 0 : SgOmpCollapseClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
97431 : {
97432 0 : ROSE_ASSERT(this != NULL);
97433 0 : visitor.visit(this);
97434 0 : }
97435 :
97436 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
97437 0 : void SgOmpCollapseClause::accept (ROSE_VisitorPattern & visitor) {
97438 0 : ROSE_ASSERT(this != NULL);
97439 0 : visitor.visit(this);
97440 0 : }
97441 :
97442 : SgOmpCollapseClause*
97443 0 : SgOmpCollapseClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
97444 : {
97445 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
97446 : // This function is currently only supported for the AST used the represent Binary executables.
97447 : if (0 /* isSgAsmNode(this) != NULL */)
97448 : {
97449 : // Support for regex specification.
97450 : std::string prefixCode = "REGEX:";
97451 : addNewAttribute(prefixCode + s,a);
97452 : }
97453 : #endif
97454 :
97455 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
97456 0 : return this;
97457 : }
97458 :
97459 : // *** COMMON CODE SECTION ENDS HERE ***
97460 :
97461 :
97462 : // End of memberFunctionString
97463 : // Start of memberFunctionString
97464 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
97465 :
97466 :
97467 : #if 0
97468 : //! Error checking support
97469 : /*! Verifies the following:
97470 : - working getVariant() member function
97471 : - calls base class's error() member function
97472 : Every class has one of these functions.
97473 : */
97474 : bool
97475 : SgOmpCollapseClause::error()
97476 : {
97477 : // Put error checking here
97478 :
97479 : ROSE_ASSERT (this != NULL);
97480 : if (getVariant() != OmpCollapseClauseTag)
97481 : {
97482 : printf ("Error in SgOmpCollapseClause::error(): SgOmpCollapseClause object has a %s variant \n",
97483 : Cxx_GrammarTerminalNames[getVariant()].name);
97484 : // printf ("Error in SgOmpCollapseClause::error() \n");
97485 : ROSE_ABORT();
97486 : }
97487 :
97488 : ROSE_ASSERT (getVariant() == OmpCollapseClauseTag);
97489 : return SgOmpExpressionClause::error();
97490 : }
97491 : #endif
97492 :
97493 :
97494 :
97495 : // End of memberFunctionString
97496 :
97497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
97498 :
97499 111 : SgOmpCollapseClause* isSgOmpCollapseClause ( SgNode* inputDerivedClassPointer )
97500 : {
97501 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97502 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97503 : // So to fix this we return NULL directly when the input is NULL and avoid the
97504 : // dynamic_cast in this case. This is likely a performance improvement as well.
97505 : // return dynamic_cast<SgOmpCollapseClause*>(inputDerivedClassPointer);
97506 : // Milind Chabbi (8/28/2013): isSgOmpCollapseClause uses table-driven castability instead of c++ default dynamic_cast
97507 : // this improves the running time performance by 10-20%.
97508 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCollapseClause*>(inputDerivedClassPointer);
97509 111 : return IS_SgOmpCollapseClause_FAST_MACRO(inputDerivedClassPointer);
97510 : }
97511 :
97512 : // DQ (11/8/2003): Added version of functions taking const pointer
97513 0 : const SgOmpCollapseClause* isSgOmpCollapseClause ( const SgNode* inputDerivedClassPointer )
97514 : {
97515 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97516 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97517 : // So to fix this we return NULL directly when the input is NULL and avoid the
97518 : // dynamic_cast in this case. This is likely a performance improvement as well.
97519 : // return dynamic_cast<const SgOmpCollapseClause*>(inputDerivedClassPointer);
97520 : // Milind Chabbi (8/28/2013): isSgOmpCollapseClause uses table-driven castability instead of c++ default dynamic_cast
97521 : // this improves the running time performance by 10-20%.
97522 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCollapseClause*>(inputDerivedClassPointer);
97523 0 : return IS_SgOmpCollapseClause_FAST_MACRO(inputDerivedClassPointer);
97524 : }
97525 :
97526 :
97527 :
97528 : /* #line 97529 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97529 :
97530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97531 :
97532 : /**
97533 : \brief Generated destructor
97534 :
97535 : This destructor is automatically generated (by ROSETTA). This destructor
97536 : only frees memory of data members associated with the parts of the current IR node which
97537 : are NOT traversed. Those data members that are part of a traversal can be freed using
97538 : a traversal (calling this destructor on all children in a post-order traversal). Such
97539 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
97540 :
97541 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
97542 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
97543 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
97544 :
97545 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
97546 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
97547 : pointers are not yet implemented to call delete on eash pointer in the container.
97548 : (This could be done by derivation from the STL containers to define containers that
97549 : automatically deleted their members.)
97550 :
97551 : */
97552 0 : SgOmpCollapseClause::~SgOmpCollapseClause () {
97553 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
97554 :
97555 :
97556 :
97557 : }
97558 :
97559 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97560 0 : }
97561 :
97562 :
97563 : /* #line 97564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97564 :
97565 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
97566 :
97567 : // Generated constructor
97568 0 : SgOmpCollapseClause::SgOmpCollapseClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
97569 0 : : SgOmpExpressionClause(startOfConstruct, expression)
97570 : {
97571 : #ifdef DEBUG
97572 : // printf ("In SgOmpCollapseClause::SgOmpCollapseClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
97573 : #endif
97574 : #if 0
97575 : // debugging information!
97576 : printf ("In SgOmpCollapseClause::SgOmpCollapseClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
97577 : #endif
97578 :
97579 :
97580 :
97581 : #if 0
97582 : // DQ (7/30/2014): Call a virtual function.
97583 : std::string s = this->class_name();
97584 : #endif
97585 :
97586 : // Test the variant virtual function
97587 : // assert(OmpCollapseClauseTag == variant());
97588 0 : assert(OmpCollapseClauseTag == this->variant());
97589 0 : ROSE_ASSERT(OmpCollapseClauseTag == (int)(this->variantT()));
97590 0 : post_construction_initialization();
97591 :
97592 : // Test the isSgOmpCollapseClause() function since it has been problematic
97593 0 : assert(isSgOmpCollapseClause(this) != NULL);
97594 0 : }
97595 :
97596 : // Generated constructor (all data members)
97597 :
97598 : /* #line 97599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97599 :
97600 :
97601 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97602 :
97603 :
97604 : // ********************************************************
97605 : // member functions common across all array grammar objects
97606 : // ********************************************************
97607 :
97608 :
97609 :
97610 : /* #line 97611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97611 :
97612 :
97613 :
97614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97615 :
97616 : // ********************************************************
97617 : // member functions specific to each node in the grammar
97618 : // ********************************************************
97619 :
97620 :
97621 : /* #line 97622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97622 :
97623 : // Start of memberFunctionString
97624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
97625 :
97626 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
97627 :
97628 : SgOmpClause::omp_if_modifier_enum
97629 370 : SgOmpIfClause::get_modifier () const
97630 : {
97631 370 : ROSE_ASSERT (this != NULL);
97632 :
97633 : #if 0
97634 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
97635 : // used to trigger marking transformations for the token-based unparsing.
97636 : printf ("SgOmpIfClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
97637 : #endif
97638 :
97639 370 : return p_modifier;
97640 : }
97641 :
97642 : void
97643 0 : SgOmpIfClause::set_modifier ( SgOmpClause::omp_if_modifier_enum modifier )
97644 : {
97645 0 : ROSE_ASSERT (this != NULL);
97646 :
97647 : #if 0
97648 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
97649 : // used to trigger marking transformations for the token-based unparsing.
97650 : printf ("SgOmpIfClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
97651 : #endif
97652 :
97653 0 : set_isModified(true);
97654 :
97655 0 : p_modifier = modifier;
97656 0 : }
97657 :
97658 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
97659 :
97660 :
97661 : // End of memberFunctionString
97662 : // Start of memberFunctionString
97663 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
97664 :
97665 : // *** COMMON CODE SECTION BEGINS HERE ***
97666 :
97667 : #if 0
97668 : int
97669 : SgOmpIfClause::getVariant() const
97670 : {
97671 : // This function is used in ROSE while "variant()" is used in SAGE
97672 : assert(this != NULL);
97673 : return variant();
97674 : }
97675 : #endif
97676 :
97677 : // This function is used in ROSE in treeTraversal code
97678 : // eventually replaces getVariant() and variant()
97679 : // though after variant() has been removed for a while we will
97680 : // want to change the name of variantT() back to variant()
97681 : // (since the "T" was ment to stand for temporary).
97682 : // When this happens the variantT() will be depricated.
97683 : VariantT
97684 2444 : SgOmpIfClause::variantT() const
97685 : {
97686 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
97687 2444 : ROSE_ASSERT(this != NULL);
97688 2444 : return V_SgOmpIfClause;
97689 : }
97690 :
97691 : #if 0
97692 : int
97693 : SgOmpIfClause::variant() const
97694 : {
97695 : // This function is used in SAGE
97696 : ROSE_ASSERT(this != NULL);
97697 : return OmpIfClauseTag;
97698 : }
97699 : #endif
97700 :
97701 : ROSE_DLL_API const char*
97702 0 : SgOmpIfClause::sage_class_name() const
97703 : {
97704 0 : ROSE_ASSERT(this != NULL);
97705 0 : return "SgOmpIfClause";
97706 : }
97707 :
97708 : std::string
97709 37 : SgOmpIfClause::class_name() const
97710 : {
97711 37 : ROSE_ASSERT(this != NULL);
97712 37 : return "SgOmpIfClause";
97713 : }
97714 :
97715 : // DQ (11/26/2005): Support for visitor pattern mechanims
97716 : // (inferior to ROSE traversal mechanism, experimental).
97717 : void
97718 0 : SgOmpIfClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
97719 : {
97720 0 : ROSE_ASSERT(this != NULL);
97721 0 : visitor.visit(this);
97722 0 : }
97723 :
97724 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
97725 0 : void SgOmpIfClause::accept (ROSE_VisitorPattern & visitor) {
97726 0 : ROSE_ASSERT(this != NULL);
97727 0 : visitor.visit(this);
97728 0 : }
97729 :
97730 : SgOmpIfClause*
97731 0 : SgOmpIfClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
97732 : {
97733 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
97734 : // This function is currently only supported for the AST used the represent Binary executables.
97735 : if (0 /* isSgAsmNode(this) != NULL */)
97736 : {
97737 : // Support for regex specification.
97738 : std::string prefixCode = "REGEX:";
97739 : addNewAttribute(prefixCode + s,a);
97740 : }
97741 : #endif
97742 :
97743 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
97744 0 : return this;
97745 : }
97746 :
97747 : // *** COMMON CODE SECTION ENDS HERE ***
97748 :
97749 :
97750 : // End of memberFunctionString
97751 : // Start of memberFunctionString
97752 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
97753 :
97754 :
97755 : #if 0
97756 : //! Error checking support
97757 : /*! Verifies the following:
97758 : - working getVariant() member function
97759 : - calls base class's error() member function
97760 : Every class has one of these functions.
97761 : */
97762 : bool
97763 : SgOmpIfClause::error()
97764 : {
97765 : // Put error checking here
97766 :
97767 : ROSE_ASSERT (this != NULL);
97768 : if (getVariant() != OmpIfClauseTag)
97769 : {
97770 : printf ("Error in SgOmpIfClause::error(): SgOmpIfClause object has a %s variant \n",
97771 : Cxx_GrammarTerminalNames[getVariant()].name);
97772 : // printf ("Error in SgOmpIfClause::error() \n");
97773 : ROSE_ABORT();
97774 : }
97775 :
97776 : ROSE_ASSERT (getVariant() == OmpIfClauseTag);
97777 : return SgOmpExpressionClause::error();
97778 : }
97779 : #endif
97780 :
97781 :
97782 :
97783 : // End of memberFunctionString
97784 :
97785 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
97786 :
97787 496 : SgOmpIfClause* isSgOmpIfClause ( SgNode* inputDerivedClassPointer )
97788 : {
97789 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97790 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97791 : // So to fix this we return NULL directly when the input is NULL and avoid the
97792 : // dynamic_cast in this case. This is likely a performance improvement as well.
97793 : // return dynamic_cast<SgOmpIfClause*>(inputDerivedClassPointer);
97794 : // Milind Chabbi (8/28/2013): isSgOmpIfClause uses table-driven castability instead of c++ default dynamic_cast
97795 : // this improves the running time performance by 10-20%.
97796 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpIfClause*>(inputDerivedClassPointer);
97797 496 : return IS_SgOmpIfClause_FAST_MACRO(inputDerivedClassPointer);
97798 : }
97799 :
97800 : // DQ (11/8/2003): Added version of functions taking const pointer
97801 0 : const SgOmpIfClause* isSgOmpIfClause ( const SgNode* inputDerivedClassPointer )
97802 : {
97803 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
97804 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
97805 : // So to fix this we return NULL directly when the input is NULL and avoid the
97806 : // dynamic_cast in this case. This is likely a performance improvement as well.
97807 : // return dynamic_cast<const SgOmpIfClause*>(inputDerivedClassPointer);
97808 : // Milind Chabbi (8/28/2013): isSgOmpIfClause uses table-driven castability instead of c++ default dynamic_cast
97809 : // this improves the running time performance by 10-20%.
97810 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpIfClause*>(inputDerivedClassPointer);
97811 0 : return IS_SgOmpIfClause_FAST_MACRO(inputDerivedClassPointer);
97812 : }
97813 :
97814 :
97815 :
97816 : /* #line 97817 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97817 :
97818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97819 :
97820 : /**
97821 : \brief Generated destructor
97822 :
97823 : This destructor is automatically generated (by ROSETTA). This destructor
97824 : only frees memory of data members associated with the parts of the current IR node which
97825 : are NOT traversed. Those data members that are part of a traversal can be freed using
97826 : a traversal (calling this destructor on all children in a post-order traversal). Such
97827 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
97828 :
97829 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
97830 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
97831 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
97832 :
97833 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
97834 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
97835 : pointers are not yet implemented to call delete on eash pointer in the container.
97836 : (This could be done by derivation from the STL containers to define containers that
97837 : automatically deleted their members.)
97838 :
97839 : */
97840 0 : SgOmpIfClause::~SgOmpIfClause () {
97841 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
97842 :
97843 :
97844 : // case: not a listType for modifier
97845 0 : p_modifier =e_omp_if_modifier_unknown; // non list case
97846 :
97847 : }
97848 :
97849 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
97850 0 : }
97851 :
97852 :
97853 : /* #line 97854 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97854 :
97855 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
97856 :
97857 : // Generated constructor
97858 0 : SgOmpIfClause::SgOmpIfClause ( Sg_File_Info* startOfConstruct, SgExpression* expression, SgOmpClause::omp_if_modifier_enum modifier )
97859 0 : : SgOmpExpressionClause(startOfConstruct, expression)
97860 : {
97861 : #ifdef DEBUG
97862 : // printf ("In SgOmpIfClause::SgOmpIfClause (Sg_File_Info* startOfConstruct, SgExpression* expression, SgOmpClause::omp_if_modifier_enum modifier) sage_class_name() = %s \n",sage_class_name());
97863 : #endif
97864 : #if 0
97865 : // debugging information!
97866 : printf ("In SgOmpIfClause::SgOmpIfClause (Sg_File_Info* startOfConstruct, SgExpression* expression, SgOmpClause::omp_if_modifier_enum modifier): this = %p = %s \n",this,this->class_name().c_str());
97867 : #endif
97868 :
97869 0 : p_modifier = modifier;
97870 :
97871 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
97872 :
97873 : #if 0
97874 : // DQ (7/30/2014): Call a virtual function.
97875 : std::string s = this->class_name();
97876 : #endif
97877 :
97878 : // Test the variant virtual function
97879 : // assert(OmpIfClauseTag == variant());
97880 0 : assert(OmpIfClauseTag == this->variant());
97881 0 : ROSE_ASSERT(OmpIfClauseTag == (int)(this->variantT()));
97882 0 : post_construction_initialization();
97883 :
97884 : // Test the isSgOmpIfClause() function since it has been problematic
97885 0 : assert(isSgOmpIfClause(this) != NULL);
97886 0 : }
97887 :
97888 : // Generated constructor (all data members)
97889 :
97890 : /* #line 97891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97891 :
97892 :
97893 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97894 :
97895 :
97896 : // ********************************************************
97897 : // member functions common across all array grammar objects
97898 : // ********************************************************
97899 :
97900 :
97901 :
97902 : /* #line 97903 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97903 :
97904 :
97905 :
97906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
97907 :
97908 : // ********************************************************
97909 : // member functions specific to each node in the grammar
97910 : // ********************************************************
97911 :
97912 :
97913 : /* #line 97914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
97914 :
97915 : // Start of memberFunctionString
97916 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
97917 :
97918 : // *** COMMON CODE SECTION BEGINS HERE ***
97919 :
97920 : #if 0
97921 : int
97922 : SgUpirNumUnitsField::getVariant() const
97923 : {
97924 : // This function is used in ROSE while "variant()" is used in SAGE
97925 : assert(this != NULL);
97926 : return variant();
97927 : }
97928 : #endif
97929 :
97930 : // This function is used in ROSE in treeTraversal code
97931 : // eventually replaces getVariant() and variant()
97932 : // though after variant() has been removed for a while we will
97933 : // want to change the name of variantT() back to variant()
97934 : // (since the "T" was ment to stand for temporary).
97935 : // When this happens the variantT() will be depricated.
97936 : VariantT
97937 1304 : SgUpirNumUnitsField::variantT() const
97938 : {
97939 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
97940 1304 : ROSE_ASSERT(this != NULL);
97941 1304 : return V_SgUpirNumUnitsField;
97942 : }
97943 :
97944 : #if 0
97945 : int
97946 : SgUpirNumUnitsField::variant() const
97947 : {
97948 : // This function is used in SAGE
97949 : ROSE_ASSERT(this != NULL);
97950 : return UpirNumUnitsFieldTag;
97951 : }
97952 : #endif
97953 :
97954 : ROSE_DLL_API const char*
97955 0 : SgUpirNumUnitsField::sage_class_name() const
97956 : {
97957 0 : ROSE_ASSERT(this != NULL);
97958 0 : return "SgUpirNumUnitsField";
97959 : }
97960 :
97961 : std::string
97962 18 : SgUpirNumUnitsField::class_name() const
97963 : {
97964 18 : ROSE_ASSERT(this != NULL);
97965 18 : return "SgUpirNumUnitsField";
97966 : }
97967 :
97968 : // DQ (11/26/2005): Support for visitor pattern mechanims
97969 : // (inferior to ROSE traversal mechanism, experimental).
97970 : void
97971 0 : SgUpirNumUnitsField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
97972 : {
97973 0 : ROSE_ASSERT(this != NULL);
97974 0 : visitor.visit(this);
97975 0 : }
97976 :
97977 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
97978 0 : void SgUpirNumUnitsField::accept (ROSE_VisitorPattern & visitor) {
97979 0 : ROSE_ASSERT(this != NULL);
97980 0 : visitor.visit(this);
97981 0 : }
97982 :
97983 : SgUpirNumUnitsField*
97984 0 : SgUpirNumUnitsField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
97985 : {
97986 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
97987 : // This function is currently only supported for the AST used the represent Binary executables.
97988 : if (0 /* isSgAsmNode(this) != NULL */)
97989 : {
97990 : // Support for regex specification.
97991 : std::string prefixCode = "REGEX:";
97992 : addNewAttribute(prefixCode + s,a);
97993 : }
97994 : #endif
97995 :
97996 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
97997 0 : return this;
97998 : }
97999 :
98000 : // *** COMMON CODE SECTION ENDS HERE ***
98001 :
98002 :
98003 : // End of memberFunctionString
98004 : // Start of memberFunctionString
98005 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
98006 :
98007 :
98008 : #if 0
98009 : //! Error checking support
98010 : /*! Verifies the following:
98011 : - working getVariant() member function
98012 : - calls base class's error() member function
98013 : Every class has one of these functions.
98014 : */
98015 : bool
98016 : SgUpirNumUnitsField::error()
98017 : {
98018 : // Put error checking here
98019 :
98020 : ROSE_ASSERT (this != NULL);
98021 : if (getVariant() != UpirNumUnitsFieldTag)
98022 : {
98023 : printf ("Error in SgUpirNumUnitsField::error(): SgUpirNumUnitsField object has a %s variant \n",
98024 : Cxx_GrammarTerminalNames[getVariant()].name);
98025 : // printf ("Error in SgUpirNumUnitsField::error() \n");
98026 : ROSE_ABORT();
98027 : }
98028 :
98029 : ROSE_ASSERT (getVariant() == UpirNumUnitsFieldTag);
98030 : return SgOmpExpressionClause::error();
98031 : }
98032 : #endif
98033 :
98034 :
98035 :
98036 : // End of memberFunctionString
98037 :
98038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
98039 :
98040 53 : SgUpirNumUnitsField* isSgUpirNumUnitsField ( SgNode* inputDerivedClassPointer )
98041 : {
98042 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98043 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98044 : // So to fix this we return NULL directly when the input is NULL and avoid the
98045 : // dynamic_cast in this case. This is likely a performance improvement as well.
98046 : // return dynamic_cast<SgUpirNumUnitsField*>(inputDerivedClassPointer);
98047 : // Milind Chabbi (8/28/2013): isSgUpirNumUnitsField uses table-driven castability instead of c++ default dynamic_cast
98048 : // this improves the running time performance by 10-20%.
98049 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirNumUnitsField*>(inputDerivedClassPointer);
98050 53 : return IS_SgUpirNumUnitsField_FAST_MACRO(inputDerivedClassPointer);
98051 : }
98052 :
98053 : // DQ (11/8/2003): Added version of functions taking const pointer
98054 0 : const SgUpirNumUnitsField* isSgUpirNumUnitsField ( const SgNode* inputDerivedClassPointer )
98055 : {
98056 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98057 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98058 : // So to fix this we return NULL directly when the input is NULL and avoid the
98059 : // dynamic_cast in this case. This is likely a performance improvement as well.
98060 : // return dynamic_cast<const SgUpirNumUnitsField*>(inputDerivedClassPointer);
98061 : // Milind Chabbi (8/28/2013): isSgUpirNumUnitsField uses table-driven castability instead of c++ default dynamic_cast
98062 : // this improves the running time performance by 10-20%.
98063 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirNumUnitsField*>(inputDerivedClassPointer);
98064 0 : return IS_SgUpirNumUnitsField_FAST_MACRO(inputDerivedClassPointer);
98065 : }
98066 :
98067 :
98068 :
98069 : /* #line 98070 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98070 :
98071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98072 :
98073 : /**
98074 : \brief Generated destructor
98075 :
98076 : This destructor is automatically generated (by ROSETTA). This destructor
98077 : only frees memory of data members associated with the parts of the current IR node which
98078 : are NOT traversed. Those data members that are part of a traversal can be freed using
98079 : a traversal (calling this destructor on all children in a post-order traversal). Such
98080 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
98081 :
98082 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
98083 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
98084 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
98085 :
98086 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
98087 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
98088 : pointers are not yet implemented to call delete on eash pointer in the container.
98089 : (This could be done by derivation from the STL containers to define containers that
98090 : automatically deleted their members.)
98091 :
98092 : */
98093 0 : SgUpirNumUnitsField::~SgUpirNumUnitsField () {
98094 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
98095 :
98096 :
98097 :
98098 : }
98099 :
98100 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98101 0 : }
98102 :
98103 :
98104 : /* #line 98105 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98105 :
98106 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
98107 :
98108 : // Generated constructor
98109 0 : SgUpirNumUnitsField::SgUpirNumUnitsField ( Sg_File_Info* startOfConstruct, SgExpression* expression )
98110 0 : : SgOmpExpressionClause(startOfConstruct, expression)
98111 : {
98112 : #ifdef DEBUG
98113 : // printf ("In SgUpirNumUnitsField::SgUpirNumUnitsField (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
98114 : #endif
98115 : #if 0
98116 : // debugging information!
98117 : printf ("In SgUpirNumUnitsField::SgUpirNumUnitsField (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
98118 : #endif
98119 :
98120 :
98121 :
98122 : #if 0
98123 : // DQ (7/30/2014): Call a virtual function.
98124 : std::string s = this->class_name();
98125 : #endif
98126 :
98127 : // Test the variant virtual function
98128 : // assert(UpirNumUnitsFieldTag == variant());
98129 0 : assert(UpirNumUnitsFieldTag == this->variant());
98130 0 : ROSE_ASSERT(UpirNumUnitsFieldTag == (int)(this->variantT()));
98131 0 : post_construction_initialization();
98132 :
98133 : // Test the isSgUpirNumUnitsField() function since it has been problematic
98134 0 : assert(isSgUpirNumUnitsField(this) != NULL);
98135 0 : }
98136 :
98137 : // Generated constructor (all data members)
98138 :
98139 : /* #line 98140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98140 :
98141 :
98142 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98143 :
98144 :
98145 : // ********************************************************
98146 : // member functions common across all array grammar objects
98147 : // ********************************************************
98148 :
98149 :
98150 :
98151 : /* #line 98152 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98152 :
98153 :
98154 :
98155 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98156 :
98157 : // ********************************************************
98158 : // member functions specific to each node in the grammar
98159 : // ********************************************************
98160 :
98161 :
98162 : /* #line 98163 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98163 :
98164 : // Start of memberFunctionString
98165 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
98166 :
98167 : // *** COMMON CODE SECTION BEGINS HERE ***
98168 :
98169 : #if 0
98170 : int
98171 : SgOmpNumTeamsClause::getVariant() const
98172 : {
98173 : // This function is used in ROSE while "variant()" is used in SAGE
98174 : assert(this != NULL);
98175 : return variant();
98176 : }
98177 : #endif
98178 :
98179 : // This function is used in ROSE in treeTraversal code
98180 : // eventually replaces getVariant() and variant()
98181 : // though after variant() has been removed for a while we will
98182 : // want to change the name of variantT() back to variant()
98183 : // (since the "T" was ment to stand for temporary).
98184 : // When this happens the variantT() will be depricated.
98185 : VariantT
98186 512 : SgOmpNumTeamsClause::variantT() const
98187 : {
98188 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
98189 512 : ROSE_ASSERT(this != NULL);
98190 512 : return V_SgOmpNumTeamsClause;
98191 : }
98192 :
98193 : #if 0
98194 : int
98195 : SgOmpNumTeamsClause::variant() const
98196 : {
98197 : // This function is used in SAGE
98198 : ROSE_ASSERT(this != NULL);
98199 : return OmpNumTeamsClauseTag;
98200 : }
98201 : #endif
98202 :
98203 : ROSE_DLL_API const char*
98204 0 : SgOmpNumTeamsClause::sage_class_name() const
98205 : {
98206 0 : ROSE_ASSERT(this != NULL);
98207 0 : return "SgOmpNumTeamsClause";
98208 : }
98209 :
98210 : std::string
98211 8 : SgOmpNumTeamsClause::class_name() const
98212 : {
98213 8 : ROSE_ASSERT(this != NULL);
98214 8 : return "SgOmpNumTeamsClause";
98215 : }
98216 :
98217 : // DQ (11/26/2005): Support for visitor pattern mechanims
98218 : // (inferior to ROSE traversal mechanism, experimental).
98219 : void
98220 0 : SgOmpNumTeamsClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
98221 : {
98222 0 : ROSE_ASSERT(this != NULL);
98223 0 : visitor.visit(this);
98224 0 : }
98225 :
98226 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
98227 0 : void SgOmpNumTeamsClause::accept (ROSE_VisitorPattern & visitor) {
98228 0 : ROSE_ASSERT(this != NULL);
98229 0 : visitor.visit(this);
98230 0 : }
98231 :
98232 : SgOmpNumTeamsClause*
98233 0 : SgOmpNumTeamsClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
98234 : {
98235 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
98236 : // This function is currently only supported for the AST used the represent Binary executables.
98237 : if (0 /* isSgAsmNode(this) != NULL */)
98238 : {
98239 : // Support for regex specification.
98240 : std::string prefixCode = "REGEX:";
98241 : addNewAttribute(prefixCode + s,a);
98242 : }
98243 : #endif
98244 :
98245 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
98246 0 : return this;
98247 : }
98248 :
98249 : // *** COMMON CODE SECTION ENDS HERE ***
98250 :
98251 :
98252 : // End of memberFunctionString
98253 : // Start of memberFunctionString
98254 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
98255 :
98256 :
98257 : #if 0
98258 : //! Error checking support
98259 : /*! Verifies the following:
98260 : - working getVariant() member function
98261 : - calls base class's error() member function
98262 : Every class has one of these functions.
98263 : */
98264 : bool
98265 : SgOmpNumTeamsClause::error()
98266 : {
98267 : // Put error checking here
98268 :
98269 : ROSE_ASSERT (this != NULL);
98270 : if (getVariant() != OmpNumTeamsClauseTag)
98271 : {
98272 : printf ("Error in SgOmpNumTeamsClause::error(): SgOmpNumTeamsClause object has a %s variant \n",
98273 : Cxx_GrammarTerminalNames[getVariant()].name);
98274 : // printf ("Error in SgOmpNumTeamsClause::error() \n");
98275 : ROSE_ABORT();
98276 : }
98277 :
98278 : ROSE_ASSERT (getVariant() == OmpNumTeamsClauseTag);
98279 : return SgOmpExpressionClause::error();
98280 : }
98281 : #endif
98282 :
98283 :
98284 :
98285 : // End of memberFunctionString
98286 :
98287 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
98288 :
98289 25 : SgOmpNumTeamsClause* isSgOmpNumTeamsClause ( SgNode* inputDerivedClassPointer )
98290 : {
98291 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98292 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98293 : // So to fix this we return NULL directly when the input is NULL and avoid the
98294 : // dynamic_cast in this case. This is likely a performance improvement as well.
98295 : // return dynamic_cast<SgOmpNumTeamsClause*>(inputDerivedClassPointer);
98296 : // Milind Chabbi (8/28/2013): isSgOmpNumTeamsClause uses table-driven castability instead of c++ default dynamic_cast
98297 : // this improves the running time performance by 10-20%.
98298 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpNumTeamsClause*>(inputDerivedClassPointer);
98299 25 : return IS_SgOmpNumTeamsClause_FAST_MACRO(inputDerivedClassPointer);
98300 : }
98301 :
98302 : // DQ (11/8/2003): Added version of functions taking const pointer
98303 0 : const SgOmpNumTeamsClause* isSgOmpNumTeamsClause ( const SgNode* inputDerivedClassPointer )
98304 : {
98305 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98306 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98307 : // So to fix this we return NULL directly when the input is NULL and avoid the
98308 : // dynamic_cast in this case. This is likely a performance improvement as well.
98309 : // return dynamic_cast<const SgOmpNumTeamsClause*>(inputDerivedClassPointer);
98310 : // Milind Chabbi (8/28/2013): isSgOmpNumTeamsClause uses table-driven castability instead of c++ default dynamic_cast
98311 : // this improves the running time performance by 10-20%.
98312 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpNumTeamsClause*>(inputDerivedClassPointer);
98313 0 : return IS_SgOmpNumTeamsClause_FAST_MACRO(inputDerivedClassPointer);
98314 : }
98315 :
98316 :
98317 :
98318 : /* #line 98319 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98319 :
98320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98321 :
98322 : /**
98323 : \brief Generated destructor
98324 :
98325 : This destructor is automatically generated (by ROSETTA). This destructor
98326 : only frees memory of data members associated with the parts of the current IR node which
98327 : are NOT traversed. Those data members that are part of a traversal can be freed using
98328 : a traversal (calling this destructor on all children in a post-order traversal). Such
98329 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
98330 :
98331 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
98332 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
98333 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
98334 :
98335 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
98336 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
98337 : pointers are not yet implemented to call delete on eash pointer in the container.
98338 : (This could be done by derivation from the STL containers to define containers that
98339 : automatically deleted their members.)
98340 :
98341 : */
98342 0 : SgOmpNumTeamsClause::~SgOmpNumTeamsClause () {
98343 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
98344 :
98345 :
98346 :
98347 : }
98348 :
98349 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98350 0 : }
98351 :
98352 :
98353 : /* #line 98354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98354 :
98355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
98356 :
98357 : // Generated constructor
98358 0 : SgOmpNumTeamsClause::SgOmpNumTeamsClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
98359 0 : : SgOmpExpressionClause(startOfConstruct, expression)
98360 : {
98361 : #ifdef DEBUG
98362 : // printf ("In SgOmpNumTeamsClause::SgOmpNumTeamsClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
98363 : #endif
98364 : #if 0
98365 : // debugging information!
98366 : printf ("In SgOmpNumTeamsClause::SgOmpNumTeamsClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
98367 : #endif
98368 :
98369 :
98370 :
98371 : #if 0
98372 : // DQ (7/30/2014): Call a virtual function.
98373 : std::string s = this->class_name();
98374 : #endif
98375 :
98376 : // Test the variant virtual function
98377 : // assert(OmpNumTeamsClauseTag == variant());
98378 0 : assert(OmpNumTeamsClauseTag == this->variant());
98379 0 : ROSE_ASSERT(OmpNumTeamsClauseTag == (int)(this->variantT()));
98380 0 : post_construction_initialization();
98381 :
98382 : // Test the isSgOmpNumTeamsClause() function since it has been problematic
98383 0 : assert(isSgOmpNumTeamsClause(this) != NULL);
98384 0 : }
98385 :
98386 : // Generated constructor (all data members)
98387 :
98388 : /* #line 98389 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98389 :
98390 :
98391 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98392 :
98393 :
98394 : // ********************************************************
98395 : // member functions common across all array grammar objects
98396 : // ********************************************************
98397 :
98398 :
98399 :
98400 : /* #line 98401 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98401 :
98402 :
98403 :
98404 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98405 :
98406 : // ********************************************************
98407 : // member functions specific to each node in the grammar
98408 : // ********************************************************
98409 :
98410 :
98411 : /* #line 98412 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98412 :
98413 : // Start of memberFunctionString
98414 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
98415 :
98416 : // *** COMMON CODE SECTION BEGINS HERE ***
98417 :
98418 : #if 0
98419 : int
98420 : SgOmpThreadLimitClause::getVariant() const
98421 : {
98422 : // This function is used in ROSE while "variant()" is used in SAGE
98423 : assert(this != NULL);
98424 : return variant();
98425 : }
98426 : #endif
98427 :
98428 : // This function is used in ROSE in treeTraversal code
98429 : // eventually replaces getVariant() and variant()
98430 : // though after variant() has been removed for a while we will
98431 : // want to change the name of variantT() back to variant()
98432 : // (since the "T" was ment to stand for temporary).
98433 : // When this happens the variantT() will be depricated.
98434 : VariantT
98435 136 : SgOmpThreadLimitClause::variantT() const
98436 : {
98437 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
98438 136 : ROSE_ASSERT(this != NULL);
98439 136 : return V_SgOmpThreadLimitClause;
98440 : }
98441 :
98442 : #if 0
98443 : int
98444 : SgOmpThreadLimitClause::variant() const
98445 : {
98446 : // This function is used in SAGE
98447 : ROSE_ASSERT(this != NULL);
98448 : return OmpThreadLimitClauseTag;
98449 : }
98450 : #endif
98451 :
98452 : ROSE_DLL_API const char*
98453 0 : SgOmpThreadLimitClause::sage_class_name() const
98454 : {
98455 0 : ROSE_ASSERT(this != NULL);
98456 0 : return "SgOmpThreadLimitClause";
98457 : }
98458 :
98459 : std::string
98460 2 : SgOmpThreadLimitClause::class_name() const
98461 : {
98462 2 : ROSE_ASSERT(this != NULL);
98463 2 : return "SgOmpThreadLimitClause";
98464 : }
98465 :
98466 : // DQ (11/26/2005): Support for visitor pattern mechanims
98467 : // (inferior to ROSE traversal mechanism, experimental).
98468 : void
98469 0 : SgOmpThreadLimitClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
98470 : {
98471 0 : ROSE_ASSERT(this != NULL);
98472 0 : visitor.visit(this);
98473 0 : }
98474 :
98475 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
98476 0 : void SgOmpThreadLimitClause::accept (ROSE_VisitorPattern & visitor) {
98477 0 : ROSE_ASSERT(this != NULL);
98478 0 : visitor.visit(this);
98479 0 : }
98480 :
98481 : SgOmpThreadLimitClause*
98482 0 : SgOmpThreadLimitClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
98483 : {
98484 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
98485 : // This function is currently only supported for the AST used the represent Binary executables.
98486 : if (0 /* isSgAsmNode(this) != NULL */)
98487 : {
98488 : // Support for regex specification.
98489 : std::string prefixCode = "REGEX:";
98490 : addNewAttribute(prefixCode + s,a);
98491 : }
98492 : #endif
98493 :
98494 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
98495 0 : return this;
98496 : }
98497 :
98498 : // *** COMMON CODE SECTION ENDS HERE ***
98499 :
98500 :
98501 : // End of memberFunctionString
98502 : // Start of memberFunctionString
98503 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
98504 :
98505 :
98506 : #if 0
98507 : //! Error checking support
98508 : /*! Verifies the following:
98509 : - working getVariant() member function
98510 : - calls base class's error() member function
98511 : Every class has one of these functions.
98512 : */
98513 : bool
98514 : SgOmpThreadLimitClause::error()
98515 : {
98516 : // Put error checking here
98517 :
98518 : ROSE_ASSERT (this != NULL);
98519 : if (getVariant() != OmpThreadLimitClauseTag)
98520 : {
98521 : printf ("Error in SgOmpThreadLimitClause::error(): SgOmpThreadLimitClause object has a %s variant \n",
98522 : Cxx_GrammarTerminalNames[getVariant()].name);
98523 : // printf ("Error in SgOmpThreadLimitClause::error() \n");
98524 : ROSE_ABORT();
98525 : }
98526 :
98527 : ROSE_ASSERT (getVariant() == OmpThreadLimitClauseTag);
98528 : return SgOmpExpressionClause::error();
98529 : }
98530 : #endif
98531 :
98532 :
98533 :
98534 : // End of memberFunctionString
98535 :
98536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
98537 :
98538 11 : SgOmpThreadLimitClause* isSgOmpThreadLimitClause ( SgNode* inputDerivedClassPointer )
98539 : {
98540 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98541 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98542 : // So to fix this we return NULL directly when the input is NULL and avoid the
98543 : // dynamic_cast in this case. This is likely a performance improvement as well.
98544 : // return dynamic_cast<SgOmpThreadLimitClause*>(inputDerivedClassPointer);
98545 : // Milind Chabbi (8/28/2013): isSgOmpThreadLimitClause uses table-driven castability instead of c++ default dynamic_cast
98546 : // this improves the running time performance by 10-20%.
98547 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpThreadLimitClause*>(inputDerivedClassPointer);
98548 11 : return IS_SgOmpThreadLimitClause_FAST_MACRO(inputDerivedClassPointer);
98549 : }
98550 :
98551 : // DQ (11/8/2003): Added version of functions taking const pointer
98552 0 : const SgOmpThreadLimitClause* isSgOmpThreadLimitClause ( const SgNode* inputDerivedClassPointer )
98553 : {
98554 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98555 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98556 : // So to fix this we return NULL directly when the input is NULL and avoid the
98557 : // dynamic_cast in this case. This is likely a performance improvement as well.
98558 : // return dynamic_cast<const SgOmpThreadLimitClause*>(inputDerivedClassPointer);
98559 : // Milind Chabbi (8/28/2013): isSgOmpThreadLimitClause uses table-driven castability instead of c++ default dynamic_cast
98560 : // this improves the running time performance by 10-20%.
98561 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpThreadLimitClause*>(inputDerivedClassPointer);
98562 0 : return IS_SgOmpThreadLimitClause_FAST_MACRO(inputDerivedClassPointer);
98563 : }
98564 :
98565 :
98566 :
98567 : /* #line 98568 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98568 :
98569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98570 :
98571 : /**
98572 : \brief Generated destructor
98573 :
98574 : This destructor is automatically generated (by ROSETTA). This destructor
98575 : only frees memory of data members associated with the parts of the current IR node which
98576 : are NOT traversed. Those data members that are part of a traversal can be freed using
98577 : a traversal (calling this destructor on all children in a post-order traversal). Such
98578 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
98579 :
98580 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
98581 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
98582 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
98583 :
98584 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
98585 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
98586 : pointers are not yet implemented to call delete on eash pointer in the container.
98587 : (This could be done by derivation from the STL containers to define containers that
98588 : automatically deleted their members.)
98589 :
98590 : */
98591 0 : SgOmpThreadLimitClause::~SgOmpThreadLimitClause () {
98592 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
98593 :
98594 :
98595 :
98596 : }
98597 :
98598 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98599 0 : }
98600 :
98601 :
98602 : /* #line 98603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98603 :
98604 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
98605 :
98606 : // Generated constructor
98607 0 : SgOmpThreadLimitClause::SgOmpThreadLimitClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
98608 0 : : SgOmpExpressionClause(startOfConstruct, expression)
98609 : {
98610 : #ifdef DEBUG
98611 : // printf ("In SgOmpThreadLimitClause::SgOmpThreadLimitClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
98612 : #endif
98613 : #if 0
98614 : // debugging information!
98615 : printf ("In SgOmpThreadLimitClause::SgOmpThreadLimitClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
98616 : #endif
98617 :
98618 :
98619 :
98620 : #if 0
98621 : // DQ (7/30/2014): Call a virtual function.
98622 : std::string s = this->class_name();
98623 : #endif
98624 :
98625 : // Test the variant virtual function
98626 : // assert(OmpThreadLimitClauseTag == variant());
98627 0 : assert(OmpThreadLimitClauseTag == this->variant());
98628 0 : ROSE_ASSERT(OmpThreadLimitClauseTag == (int)(this->variantT()));
98629 0 : post_construction_initialization();
98630 :
98631 : // Test the isSgOmpThreadLimitClause() function since it has been problematic
98632 0 : assert(isSgOmpThreadLimitClause(this) != NULL);
98633 0 : }
98634 :
98635 : // Generated constructor (all data members)
98636 :
98637 : /* #line 98638 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98638 :
98639 :
98640 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98641 :
98642 :
98643 : // ********************************************************
98644 : // member functions common across all array grammar objects
98645 : // ********************************************************
98646 :
98647 :
98648 :
98649 : /* #line 98650 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98650 :
98651 :
98652 :
98653 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98654 :
98655 : // ********************************************************
98656 : // member functions specific to each node in the grammar
98657 : // ********************************************************
98658 :
98659 :
98660 : /* #line 98661 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98661 :
98662 : // Start of memberFunctionString
98663 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
98664 :
98665 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
98666 :
98667 : SgOmpClause::omp_device_modifier_enum
98668 27 : SgOmpDeviceClause::get_modifier () const
98669 : {
98670 27 : ROSE_ASSERT (this != NULL);
98671 :
98672 : #if 0
98673 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
98674 : // used to trigger marking transformations for the token-based unparsing.
98675 : printf ("SgOmpDeviceClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
98676 : #endif
98677 :
98678 27 : return p_modifier;
98679 : }
98680 :
98681 : void
98682 0 : SgOmpDeviceClause::set_modifier ( SgOmpClause::omp_device_modifier_enum modifier )
98683 : {
98684 0 : ROSE_ASSERT (this != NULL);
98685 :
98686 : #if 0
98687 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
98688 : // used to trigger marking transformations for the token-based unparsing.
98689 : printf ("SgOmpDeviceClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
98690 : #endif
98691 :
98692 0 : set_isModified(true);
98693 :
98694 0 : p_modifier = modifier;
98695 0 : }
98696 :
98697 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
98698 :
98699 :
98700 : // End of memberFunctionString
98701 : // Start of memberFunctionString
98702 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
98703 :
98704 : // *** COMMON CODE SECTION BEGINS HERE ***
98705 :
98706 : #if 0
98707 : int
98708 : SgOmpDeviceClause::getVariant() const
98709 : {
98710 : // This function is used in ROSE while "variant()" is used in SAGE
98711 : assert(this != NULL);
98712 : return variant();
98713 : }
98714 : #endif
98715 :
98716 : // This function is used in ROSE in treeTraversal code
98717 : // eventually replaces getVariant() and variant()
98718 : // though after variant() has been removed for a while we will
98719 : // want to change the name of variantT() back to variant()
98720 : // (since the "T" was ment to stand for temporary).
98721 : // When this happens the variantT() will be depricated.
98722 : VariantT
98723 539 : SgOmpDeviceClause::variantT() const
98724 : {
98725 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
98726 539 : ROSE_ASSERT(this != NULL);
98727 539 : return V_SgOmpDeviceClause;
98728 : }
98729 :
98730 : #if 0
98731 : int
98732 : SgOmpDeviceClause::variant() const
98733 : {
98734 : // This function is used in SAGE
98735 : ROSE_ASSERT(this != NULL);
98736 : return OmpIfDeviceTag;
98737 : }
98738 : #endif
98739 :
98740 : ROSE_DLL_API const char*
98741 0 : SgOmpDeviceClause::sage_class_name() const
98742 : {
98743 0 : ROSE_ASSERT(this != NULL);
98744 0 : return "SgOmpDeviceClause";
98745 : }
98746 :
98747 : std::string
98748 9 : SgOmpDeviceClause::class_name() const
98749 : {
98750 9 : ROSE_ASSERT(this != NULL);
98751 9 : return "SgOmpDeviceClause";
98752 : }
98753 :
98754 : // DQ (11/26/2005): Support for visitor pattern mechanims
98755 : // (inferior to ROSE traversal mechanism, experimental).
98756 : void
98757 0 : SgOmpDeviceClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
98758 : {
98759 0 : ROSE_ASSERT(this != NULL);
98760 0 : visitor.visit(this);
98761 0 : }
98762 :
98763 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
98764 0 : void SgOmpDeviceClause::accept (ROSE_VisitorPattern & visitor) {
98765 0 : ROSE_ASSERT(this != NULL);
98766 0 : visitor.visit(this);
98767 0 : }
98768 :
98769 : SgOmpDeviceClause*
98770 0 : SgOmpDeviceClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
98771 : {
98772 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
98773 : // This function is currently only supported for the AST used the represent Binary executables.
98774 : if (0 /* isSgAsmNode(this) != NULL */)
98775 : {
98776 : // Support for regex specification.
98777 : std::string prefixCode = "REGEX:";
98778 : addNewAttribute(prefixCode + s,a);
98779 : }
98780 : #endif
98781 :
98782 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
98783 0 : return this;
98784 : }
98785 :
98786 : // *** COMMON CODE SECTION ENDS HERE ***
98787 :
98788 :
98789 : // End of memberFunctionString
98790 : // Start of memberFunctionString
98791 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
98792 :
98793 :
98794 : #if 0
98795 : //! Error checking support
98796 : /*! Verifies the following:
98797 : - working getVariant() member function
98798 : - calls base class's error() member function
98799 : Every class has one of these functions.
98800 : */
98801 : bool
98802 : SgOmpDeviceClause::error()
98803 : {
98804 : // Put error checking here
98805 :
98806 : ROSE_ASSERT (this != NULL);
98807 : if (getVariant() != OmpIfDeviceTag)
98808 : {
98809 : printf ("Error in SgOmpDeviceClause::error(): SgOmpDeviceClause object has a %s variant \n",
98810 : Cxx_GrammarTerminalNames[getVariant()].name);
98811 : // printf ("Error in SgOmpDeviceClause::error() \n");
98812 : ROSE_ABORT();
98813 : }
98814 :
98815 : ROSE_ASSERT (getVariant() == OmpIfDeviceTag);
98816 : return SgOmpExpressionClause::error();
98817 : }
98818 : #endif
98819 :
98820 :
98821 :
98822 : // End of memberFunctionString
98823 :
98824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
98825 :
98826 92 : SgOmpDeviceClause* isSgOmpDeviceClause ( SgNode* inputDerivedClassPointer )
98827 : {
98828 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98829 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98830 : // So to fix this we return NULL directly when the input is NULL and avoid the
98831 : // dynamic_cast in this case. This is likely a performance improvement as well.
98832 : // return dynamic_cast<SgOmpDeviceClause*>(inputDerivedClassPointer);
98833 : // Milind Chabbi (8/28/2013): isSgOmpDeviceClause uses table-driven castability instead of c++ default dynamic_cast
98834 : // this improves the running time performance by 10-20%.
98835 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDeviceClause*>(inputDerivedClassPointer);
98836 92 : return IS_SgOmpDeviceClause_FAST_MACRO(inputDerivedClassPointer);
98837 : }
98838 :
98839 : // DQ (11/8/2003): Added version of functions taking const pointer
98840 0 : const SgOmpDeviceClause* isSgOmpDeviceClause ( const SgNode* inputDerivedClassPointer )
98841 : {
98842 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
98843 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
98844 : // So to fix this we return NULL directly when the input is NULL and avoid the
98845 : // dynamic_cast in this case. This is likely a performance improvement as well.
98846 : // return dynamic_cast<const SgOmpDeviceClause*>(inputDerivedClassPointer);
98847 : // Milind Chabbi (8/28/2013): isSgOmpDeviceClause uses table-driven castability instead of c++ default dynamic_cast
98848 : // this improves the running time performance by 10-20%.
98849 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDeviceClause*>(inputDerivedClassPointer);
98850 0 : return IS_SgOmpDeviceClause_FAST_MACRO(inputDerivedClassPointer);
98851 : }
98852 :
98853 :
98854 :
98855 : /* #line 98856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98856 :
98857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98858 :
98859 : /**
98860 : \brief Generated destructor
98861 :
98862 : This destructor is automatically generated (by ROSETTA). This destructor
98863 : only frees memory of data members associated with the parts of the current IR node which
98864 : are NOT traversed. Those data members that are part of a traversal can be freed using
98865 : a traversal (calling this destructor on all children in a post-order traversal). Such
98866 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
98867 :
98868 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
98869 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
98870 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
98871 :
98872 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
98873 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
98874 : pointers are not yet implemented to call delete on eash pointer in the container.
98875 : (This could be done by derivation from the STL containers to define containers that
98876 : automatically deleted their members.)
98877 :
98878 : */
98879 0 : SgOmpDeviceClause::~SgOmpDeviceClause () {
98880 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
98881 :
98882 :
98883 : // case: not a listType for modifier
98884 0 : p_modifier =e_omp_device_modifier_unspecified; // non list case
98885 :
98886 : }
98887 :
98888 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
98889 0 : }
98890 :
98891 :
98892 : /* #line 98893 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98893 :
98894 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
98895 :
98896 : // Generated constructor
98897 0 : SgOmpDeviceClause::SgOmpDeviceClause ( Sg_File_Info* startOfConstruct, SgExpression* expression, SgOmpClause::omp_device_modifier_enum modifier )
98898 0 : : SgOmpExpressionClause(startOfConstruct, expression)
98899 : {
98900 : #ifdef DEBUG
98901 : // printf ("In SgOmpDeviceClause::SgOmpDeviceClause (Sg_File_Info* startOfConstruct, SgExpression* expression, SgOmpClause::omp_device_modifier_enum modifier) sage_class_name() = %s \n",sage_class_name());
98902 : #endif
98903 : #if 0
98904 : // debugging information!
98905 : printf ("In SgOmpDeviceClause::SgOmpDeviceClause (Sg_File_Info* startOfConstruct, SgExpression* expression, SgOmpClause::omp_device_modifier_enum modifier): this = %p = %s \n",this,this->class_name().c_str());
98906 : #endif
98907 :
98908 0 : p_modifier = modifier;
98909 :
98910 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
98911 :
98912 : #if 0
98913 : // DQ (7/30/2014): Call a virtual function.
98914 : std::string s = this->class_name();
98915 : #endif
98916 :
98917 : // Test the variant virtual function
98918 : // assert(OmpIfDeviceTag == variant());
98919 0 : assert(OmpIfDeviceTag == this->variant());
98920 0 : ROSE_ASSERT(OmpIfDeviceTag == (int)(this->variantT()));
98921 0 : post_construction_initialization();
98922 :
98923 : // Test the isSgOmpDeviceClause() function since it has been problematic
98924 0 : assert(isSgOmpDeviceClause(this) != NULL);
98925 0 : }
98926 :
98927 : // Generated constructor (all data members)
98928 :
98929 : /* #line 98930 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98930 :
98931 :
98932 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98933 :
98934 :
98935 : // ********************************************************
98936 : // member functions common across all array grammar objects
98937 : // ********************************************************
98938 :
98939 :
98940 :
98941 : /* #line 98942 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98942 :
98943 :
98944 :
98945 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
98946 :
98947 : // ********************************************************
98948 : // member functions specific to each node in the grammar
98949 : // ********************************************************
98950 :
98951 :
98952 : /* #line 98953 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
98953 :
98954 : // Start of memberFunctionString
98955 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
98956 :
98957 : // *** COMMON CODE SECTION BEGINS HERE ***
98958 :
98959 : #if 0
98960 : int
98961 : SgOmpHintClause::getVariant() const
98962 : {
98963 : // This function is used in ROSE while "variant()" is used in SAGE
98964 : assert(this != NULL);
98965 : return variant();
98966 : }
98967 : #endif
98968 :
98969 : // This function is used in ROSE in treeTraversal code
98970 : // eventually replaces getVariant() and variant()
98971 : // though after variant() has been removed for a while we will
98972 : // want to change the name of variantT() back to variant()
98973 : // (since the "T" was ment to stand for temporary).
98974 : // When this happens the variantT() will be depricated.
98975 : VariantT
98976 207 : SgOmpHintClause::variantT() const
98977 : {
98978 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
98979 207 : ROSE_ASSERT(this != NULL);
98980 207 : return V_SgOmpHintClause;
98981 : }
98982 :
98983 : #if 0
98984 : int
98985 : SgOmpHintClause::variant() const
98986 : {
98987 : // This function is used in SAGE
98988 : ROSE_ASSERT(this != NULL);
98989 : return OmpHintClauseTag;
98990 : }
98991 : #endif
98992 :
98993 : ROSE_DLL_API const char*
98994 0 : SgOmpHintClause::sage_class_name() const
98995 : {
98996 0 : ROSE_ASSERT(this != NULL);
98997 0 : return "SgOmpHintClause";
98998 : }
98999 :
99000 : std::string
99001 3 : SgOmpHintClause::class_name() const
99002 : {
99003 3 : ROSE_ASSERT(this != NULL);
99004 3 : return "SgOmpHintClause";
99005 : }
99006 :
99007 : // DQ (11/26/2005): Support for visitor pattern mechanims
99008 : // (inferior to ROSE traversal mechanism, experimental).
99009 : void
99010 0 : SgOmpHintClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
99011 : {
99012 0 : ROSE_ASSERT(this != NULL);
99013 0 : visitor.visit(this);
99014 0 : }
99015 :
99016 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
99017 0 : void SgOmpHintClause::accept (ROSE_VisitorPattern & visitor) {
99018 0 : ROSE_ASSERT(this != NULL);
99019 0 : visitor.visit(this);
99020 0 : }
99021 :
99022 : SgOmpHintClause*
99023 0 : SgOmpHintClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
99024 : {
99025 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
99026 : // This function is currently only supported for the AST used the represent Binary executables.
99027 : if (0 /* isSgAsmNode(this) != NULL */)
99028 : {
99029 : // Support for regex specification.
99030 : std::string prefixCode = "REGEX:";
99031 : addNewAttribute(prefixCode + s,a);
99032 : }
99033 : #endif
99034 :
99035 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
99036 0 : return this;
99037 : }
99038 :
99039 : // *** COMMON CODE SECTION ENDS HERE ***
99040 :
99041 :
99042 : // End of memberFunctionString
99043 : // Start of memberFunctionString
99044 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
99045 :
99046 :
99047 : #if 0
99048 : //! Error checking support
99049 : /*! Verifies the following:
99050 : - working getVariant() member function
99051 : - calls base class's error() member function
99052 : Every class has one of these functions.
99053 : */
99054 : bool
99055 : SgOmpHintClause::error()
99056 : {
99057 : // Put error checking here
99058 :
99059 : ROSE_ASSERT (this != NULL);
99060 : if (getVariant() != OmpHintClauseTag)
99061 : {
99062 : printf ("Error in SgOmpHintClause::error(): SgOmpHintClause object has a %s variant \n",
99063 : Cxx_GrammarTerminalNames[getVariant()].name);
99064 : // printf ("Error in SgOmpHintClause::error() \n");
99065 : ROSE_ABORT();
99066 : }
99067 :
99068 : ROSE_ASSERT (getVariant() == OmpHintClauseTag);
99069 : return SgOmpExpressionClause::error();
99070 : }
99071 : #endif
99072 :
99073 :
99074 :
99075 : // End of memberFunctionString
99076 :
99077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
99078 :
99079 10 : SgOmpHintClause* isSgOmpHintClause ( SgNode* inputDerivedClassPointer )
99080 : {
99081 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99082 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99083 : // So to fix this we return NULL directly when the input is NULL and avoid the
99084 : // dynamic_cast in this case. This is likely a performance improvement as well.
99085 : // return dynamic_cast<SgOmpHintClause*>(inputDerivedClassPointer);
99086 : // Milind Chabbi (8/28/2013): isSgOmpHintClause uses table-driven castability instead of c++ default dynamic_cast
99087 : // this improves the running time performance by 10-20%.
99088 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpHintClause*>(inputDerivedClassPointer);
99089 10 : return IS_SgOmpHintClause_FAST_MACRO(inputDerivedClassPointer);
99090 : }
99091 :
99092 : // DQ (11/8/2003): Added version of functions taking const pointer
99093 0 : const SgOmpHintClause* isSgOmpHintClause ( const SgNode* inputDerivedClassPointer )
99094 : {
99095 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99096 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99097 : // So to fix this we return NULL directly when the input is NULL and avoid the
99098 : // dynamic_cast in this case. This is likely a performance improvement as well.
99099 : // return dynamic_cast<const SgOmpHintClause*>(inputDerivedClassPointer);
99100 : // Milind Chabbi (8/28/2013): isSgOmpHintClause uses table-driven castability instead of c++ default dynamic_cast
99101 : // this improves the running time performance by 10-20%.
99102 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpHintClause*>(inputDerivedClassPointer);
99103 0 : return IS_SgOmpHintClause_FAST_MACRO(inputDerivedClassPointer);
99104 : }
99105 :
99106 :
99107 :
99108 : /* #line 99109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99109 :
99110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99111 :
99112 : /**
99113 : \brief Generated destructor
99114 :
99115 : This destructor is automatically generated (by ROSETTA). This destructor
99116 : only frees memory of data members associated with the parts of the current IR node which
99117 : are NOT traversed. Those data members that are part of a traversal can be freed using
99118 : a traversal (calling this destructor on all children in a post-order traversal). Such
99119 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
99120 :
99121 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
99122 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
99123 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
99124 :
99125 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
99126 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
99127 : pointers are not yet implemented to call delete on eash pointer in the container.
99128 : (This could be done by derivation from the STL containers to define containers that
99129 : automatically deleted their members.)
99130 :
99131 : */
99132 0 : SgOmpHintClause::~SgOmpHintClause () {
99133 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
99134 :
99135 :
99136 :
99137 : }
99138 :
99139 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99140 0 : }
99141 :
99142 :
99143 : /* #line 99144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99144 :
99145 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
99146 :
99147 : // Generated constructor
99148 0 : SgOmpHintClause::SgOmpHintClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
99149 0 : : SgOmpExpressionClause(startOfConstruct, expression)
99150 : {
99151 : #ifdef DEBUG
99152 : // printf ("In SgOmpHintClause::SgOmpHintClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
99153 : #endif
99154 : #if 0
99155 : // debugging information!
99156 : printf ("In SgOmpHintClause::SgOmpHintClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
99157 : #endif
99158 :
99159 :
99160 :
99161 : #if 0
99162 : // DQ (7/30/2014): Call a virtual function.
99163 : std::string s = this->class_name();
99164 : #endif
99165 :
99166 : // Test the variant virtual function
99167 : // assert(OmpHintClauseTag == variant());
99168 0 : assert(OmpHintClauseTag == this->variant());
99169 0 : ROSE_ASSERT(OmpHintClauseTag == (int)(this->variantT()));
99170 0 : post_construction_initialization();
99171 :
99172 : // Test the isSgOmpHintClause() function since it has been problematic
99173 0 : assert(isSgOmpHintClause(this) != NULL);
99174 0 : }
99175 :
99176 : // Generated constructor (all data members)
99177 :
99178 : /* #line 99179 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99179 :
99180 :
99181 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99182 :
99183 :
99184 : // ********************************************************
99185 : // member functions common across all array grammar objects
99186 : // ********************************************************
99187 :
99188 :
99189 :
99190 : /* #line 99191 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99191 :
99192 :
99193 :
99194 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99195 :
99196 : // ********************************************************
99197 : // member functions specific to each node in the grammar
99198 : // ********************************************************
99199 :
99200 :
99201 : /* #line 99202 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99202 :
99203 : // Start of memberFunctionString
99204 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
99205 :
99206 : // *** COMMON CODE SECTION BEGINS HERE ***
99207 :
99208 : #if 0
99209 : int
99210 : SgOmpGrainsizeClause::getVariant() const
99211 : {
99212 : // This function is used in ROSE while "variant()" is used in SAGE
99213 : assert(this != NULL);
99214 : return variant();
99215 : }
99216 : #endif
99217 :
99218 : // This function is used in ROSE in treeTraversal code
99219 : // eventually replaces getVariant() and variant()
99220 : // though after variant() has been removed for a while we will
99221 : // want to change the name of variantT() back to variant()
99222 : // (since the "T" was ment to stand for temporary).
99223 : // When this happens the variantT() will be depricated.
99224 : VariantT
99225 0 : SgOmpGrainsizeClause::variantT() const
99226 : {
99227 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
99228 0 : ROSE_ASSERT(this != NULL);
99229 0 : return V_SgOmpGrainsizeClause;
99230 : }
99231 :
99232 : #if 0
99233 : int
99234 : SgOmpGrainsizeClause::variant() const
99235 : {
99236 : // This function is used in SAGE
99237 : ROSE_ASSERT(this != NULL);
99238 : return OmpGrainsizeClauseTag;
99239 : }
99240 : #endif
99241 :
99242 : ROSE_DLL_API const char*
99243 0 : SgOmpGrainsizeClause::sage_class_name() const
99244 : {
99245 0 : ROSE_ASSERT(this != NULL);
99246 0 : return "SgOmpGrainsizeClause";
99247 : }
99248 :
99249 : std::string
99250 0 : SgOmpGrainsizeClause::class_name() const
99251 : {
99252 0 : ROSE_ASSERT(this != NULL);
99253 0 : return "SgOmpGrainsizeClause";
99254 : }
99255 :
99256 : // DQ (11/26/2005): Support for visitor pattern mechanims
99257 : // (inferior to ROSE traversal mechanism, experimental).
99258 : void
99259 0 : SgOmpGrainsizeClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
99260 : {
99261 0 : ROSE_ASSERT(this != NULL);
99262 0 : visitor.visit(this);
99263 0 : }
99264 :
99265 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
99266 0 : void SgOmpGrainsizeClause::accept (ROSE_VisitorPattern & visitor) {
99267 0 : ROSE_ASSERT(this != NULL);
99268 0 : visitor.visit(this);
99269 0 : }
99270 :
99271 : SgOmpGrainsizeClause*
99272 0 : SgOmpGrainsizeClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
99273 : {
99274 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
99275 : // This function is currently only supported for the AST used the represent Binary executables.
99276 : if (0 /* isSgAsmNode(this) != NULL */)
99277 : {
99278 : // Support for regex specification.
99279 : std::string prefixCode = "REGEX:";
99280 : addNewAttribute(prefixCode + s,a);
99281 : }
99282 : #endif
99283 :
99284 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
99285 0 : return this;
99286 : }
99287 :
99288 : // *** COMMON CODE SECTION ENDS HERE ***
99289 :
99290 :
99291 : // End of memberFunctionString
99292 : // Start of memberFunctionString
99293 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
99294 :
99295 :
99296 : #if 0
99297 : //! Error checking support
99298 : /*! Verifies the following:
99299 : - working getVariant() member function
99300 : - calls base class's error() member function
99301 : Every class has one of these functions.
99302 : */
99303 : bool
99304 : SgOmpGrainsizeClause::error()
99305 : {
99306 : // Put error checking here
99307 :
99308 : ROSE_ASSERT (this != NULL);
99309 : if (getVariant() != OmpGrainsizeClauseTag)
99310 : {
99311 : printf ("Error in SgOmpGrainsizeClause::error(): SgOmpGrainsizeClause object has a %s variant \n",
99312 : Cxx_GrammarTerminalNames[getVariant()].name);
99313 : // printf ("Error in SgOmpGrainsizeClause::error() \n");
99314 : ROSE_ABORT();
99315 : }
99316 :
99317 : ROSE_ASSERT (getVariant() == OmpGrainsizeClauseTag);
99318 : return SgOmpExpressionClause::error();
99319 : }
99320 : #endif
99321 :
99322 :
99323 :
99324 : // End of memberFunctionString
99325 :
99326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
99327 :
99328 9 : SgOmpGrainsizeClause* isSgOmpGrainsizeClause ( SgNode* inputDerivedClassPointer )
99329 : {
99330 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99331 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99332 : // So to fix this we return NULL directly when the input is NULL and avoid the
99333 : // dynamic_cast in this case. This is likely a performance improvement as well.
99334 : // return dynamic_cast<SgOmpGrainsizeClause*>(inputDerivedClassPointer);
99335 : // Milind Chabbi (8/28/2013): isSgOmpGrainsizeClause uses table-driven castability instead of c++ default dynamic_cast
99336 : // this improves the running time performance by 10-20%.
99337 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpGrainsizeClause*>(inputDerivedClassPointer);
99338 9 : return IS_SgOmpGrainsizeClause_FAST_MACRO(inputDerivedClassPointer);
99339 : }
99340 :
99341 : // DQ (11/8/2003): Added version of functions taking const pointer
99342 0 : const SgOmpGrainsizeClause* isSgOmpGrainsizeClause ( const SgNode* inputDerivedClassPointer )
99343 : {
99344 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99345 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99346 : // So to fix this we return NULL directly when the input is NULL and avoid the
99347 : // dynamic_cast in this case. This is likely a performance improvement as well.
99348 : // return dynamic_cast<const SgOmpGrainsizeClause*>(inputDerivedClassPointer);
99349 : // Milind Chabbi (8/28/2013): isSgOmpGrainsizeClause uses table-driven castability instead of c++ default dynamic_cast
99350 : // this improves the running time performance by 10-20%.
99351 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpGrainsizeClause*>(inputDerivedClassPointer);
99352 0 : return IS_SgOmpGrainsizeClause_FAST_MACRO(inputDerivedClassPointer);
99353 : }
99354 :
99355 :
99356 :
99357 : /* #line 99358 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99358 :
99359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99360 :
99361 : /**
99362 : \brief Generated destructor
99363 :
99364 : This destructor is automatically generated (by ROSETTA). This destructor
99365 : only frees memory of data members associated with the parts of the current IR node which
99366 : are NOT traversed. Those data members that are part of a traversal can be freed using
99367 : a traversal (calling this destructor on all children in a post-order traversal). Such
99368 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
99369 :
99370 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
99371 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
99372 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
99373 :
99374 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
99375 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
99376 : pointers are not yet implemented to call delete on eash pointer in the container.
99377 : (This could be done by derivation from the STL containers to define containers that
99378 : automatically deleted their members.)
99379 :
99380 : */
99381 0 : SgOmpGrainsizeClause::~SgOmpGrainsizeClause () {
99382 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
99383 :
99384 :
99385 :
99386 : }
99387 :
99388 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99389 0 : }
99390 :
99391 :
99392 : /* #line 99393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99393 :
99394 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
99395 :
99396 : // Generated constructor
99397 0 : SgOmpGrainsizeClause::SgOmpGrainsizeClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
99398 0 : : SgOmpExpressionClause(startOfConstruct, expression)
99399 : {
99400 : #ifdef DEBUG
99401 : // printf ("In SgOmpGrainsizeClause::SgOmpGrainsizeClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
99402 : #endif
99403 : #if 0
99404 : // debugging information!
99405 : printf ("In SgOmpGrainsizeClause::SgOmpGrainsizeClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
99406 : #endif
99407 :
99408 :
99409 :
99410 : #if 0
99411 : // DQ (7/30/2014): Call a virtual function.
99412 : std::string s = this->class_name();
99413 : #endif
99414 :
99415 : // Test the variant virtual function
99416 : // assert(OmpGrainsizeClauseTag == variant());
99417 0 : assert(OmpGrainsizeClauseTag == this->variant());
99418 0 : ROSE_ASSERT(OmpGrainsizeClauseTag == (int)(this->variantT()));
99419 0 : post_construction_initialization();
99420 :
99421 : // Test the isSgOmpGrainsizeClause() function since it has been problematic
99422 0 : assert(isSgOmpGrainsizeClause(this) != NULL);
99423 0 : }
99424 :
99425 : // Generated constructor (all data members)
99426 :
99427 : /* #line 99428 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99428 :
99429 :
99430 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99431 :
99432 :
99433 : // ********************************************************
99434 : // member functions common across all array grammar objects
99435 : // ********************************************************
99436 :
99437 :
99438 :
99439 : /* #line 99440 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99440 :
99441 :
99442 :
99443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99444 :
99445 : // ********************************************************
99446 : // member functions specific to each node in the grammar
99447 : // ********************************************************
99448 :
99449 :
99450 : /* #line 99451 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99451 :
99452 : // Start of memberFunctionString
99453 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
99454 :
99455 : // *** COMMON CODE SECTION BEGINS HERE ***
99456 :
99457 : #if 0
99458 : int
99459 : SgOmpNumTasksClause::getVariant() const
99460 : {
99461 : // This function is used in ROSE while "variant()" is used in SAGE
99462 : assert(this != NULL);
99463 : return variant();
99464 : }
99465 : #endif
99466 :
99467 : // This function is used in ROSE in treeTraversal code
99468 : // eventually replaces getVariant() and variant()
99469 : // though after variant() has been removed for a while we will
99470 : // want to change the name of variantT() back to variant()
99471 : // (since the "T" was ment to stand for temporary).
99472 : // When this happens the variantT() will be depricated.
99473 : VariantT
99474 0 : SgOmpNumTasksClause::variantT() const
99475 : {
99476 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
99477 0 : ROSE_ASSERT(this != NULL);
99478 0 : return V_SgOmpNumTasksClause;
99479 : }
99480 :
99481 : #if 0
99482 : int
99483 : SgOmpNumTasksClause::variant() const
99484 : {
99485 : // This function is used in SAGE
99486 : ROSE_ASSERT(this != NULL);
99487 : return OmpNumTasksClauseTag;
99488 : }
99489 : #endif
99490 :
99491 : ROSE_DLL_API const char*
99492 0 : SgOmpNumTasksClause::sage_class_name() const
99493 : {
99494 0 : ROSE_ASSERT(this != NULL);
99495 0 : return "SgOmpNumTasksClause";
99496 : }
99497 :
99498 : std::string
99499 0 : SgOmpNumTasksClause::class_name() const
99500 : {
99501 0 : ROSE_ASSERT(this != NULL);
99502 0 : return "SgOmpNumTasksClause";
99503 : }
99504 :
99505 : // DQ (11/26/2005): Support for visitor pattern mechanims
99506 : // (inferior to ROSE traversal mechanism, experimental).
99507 : void
99508 0 : SgOmpNumTasksClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
99509 : {
99510 0 : ROSE_ASSERT(this != NULL);
99511 0 : visitor.visit(this);
99512 0 : }
99513 :
99514 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
99515 0 : void SgOmpNumTasksClause::accept (ROSE_VisitorPattern & visitor) {
99516 0 : ROSE_ASSERT(this != NULL);
99517 0 : visitor.visit(this);
99518 0 : }
99519 :
99520 : SgOmpNumTasksClause*
99521 0 : SgOmpNumTasksClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
99522 : {
99523 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
99524 : // This function is currently only supported for the AST used the represent Binary executables.
99525 : if (0 /* isSgAsmNode(this) != NULL */)
99526 : {
99527 : // Support for regex specification.
99528 : std::string prefixCode = "REGEX:";
99529 : addNewAttribute(prefixCode + s,a);
99530 : }
99531 : #endif
99532 :
99533 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
99534 0 : return this;
99535 : }
99536 :
99537 : // *** COMMON CODE SECTION ENDS HERE ***
99538 :
99539 :
99540 : // End of memberFunctionString
99541 : // Start of memberFunctionString
99542 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
99543 :
99544 :
99545 : #if 0
99546 : //! Error checking support
99547 : /*! Verifies the following:
99548 : - working getVariant() member function
99549 : - calls base class's error() member function
99550 : Every class has one of these functions.
99551 : */
99552 : bool
99553 : SgOmpNumTasksClause::error()
99554 : {
99555 : // Put error checking here
99556 :
99557 : ROSE_ASSERT (this != NULL);
99558 : if (getVariant() != OmpNumTasksClauseTag)
99559 : {
99560 : printf ("Error in SgOmpNumTasksClause::error(): SgOmpNumTasksClause object has a %s variant \n",
99561 : Cxx_GrammarTerminalNames[getVariant()].name);
99562 : // printf ("Error in SgOmpNumTasksClause::error() \n");
99563 : ROSE_ABORT();
99564 : }
99565 :
99566 : ROSE_ASSERT (getVariant() == OmpNumTasksClauseTag);
99567 : return SgOmpExpressionClause::error();
99568 : }
99569 : #endif
99570 :
99571 :
99572 :
99573 : // End of memberFunctionString
99574 :
99575 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
99576 :
99577 9 : SgOmpNumTasksClause* isSgOmpNumTasksClause ( SgNode* inputDerivedClassPointer )
99578 : {
99579 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99580 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99581 : // So to fix this we return NULL directly when the input is NULL and avoid the
99582 : // dynamic_cast in this case. This is likely a performance improvement as well.
99583 : // return dynamic_cast<SgOmpNumTasksClause*>(inputDerivedClassPointer);
99584 : // Milind Chabbi (8/28/2013): isSgOmpNumTasksClause uses table-driven castability instead of c++ default dynamic_cast
99585 : // this improves the running time performance by 10-20%.
99586 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpNumTasksClause*>(inputDerivedClassPointer);
99587 9 : return IS_SgOmpNumTasksClause_FAST_MACRO(inputDerivedClassPointer);
99588 : }
99589 :
99590 : // DQ (11/8/2003): Added version of functions taking const pointer
99591 0 : const SgOmpNumTasksClause* isSgOmpNumTasksClause ( const SgNode* inputDerivedClassPointer )
99592 : {
99593 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99594 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99595 : // So to fix this we return NULL directly when the input is NULL and avoid the
99596 : // dynamic_cast in this case. This is likely a performance improvement as well.
99597 : // return dynamic_cast<const SgOmpNumTasksClause*>(inputDerivedClassPointer);
99598 : // Milind Chabbi (8/28/2013): isSgOmpNumTasksClause uses table-driven castability instead of c++ default dynamic_cast
99599 : // this improves the running time performance by 10-20%.
99600 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpNumTasksClause*>(inputDerivedClassPointer);
99601 0 : return IS_SgOmpNumTasksClause_FAST_MACRO(inputDerivedClassPointer);
99602 : }
99603 :
99604 :
99605 :
99606 : /* #line 99607 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99607 :
99608 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99609 :
99610 : /**
99611 : \brief Generated destructor
99612 :
99613 : This destructor is automatically generated (by ROSETTA). This destructor
99614 : only frees memory of data members associated with the parts of the current IR node which
99615 : are NOT traversed. Those data members that are part of a traversal can be freed using
99616 : a traversal (calling this destructor on all children in a post-order traversal). Such
99617 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
99618 :
99619 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
99620 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
99621 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
99622 :
99623 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
99624 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
99625 : pointers are not yet implemented to call delete on eash pointer in the container.
99626 : (This could be done by derivation from the STL containers to define containers that
99627 : automatically deleted their members.)
99628 :
99629 : */
99630 0 : SgOmpNumTasksClause::~SgOmpNumTasksClause () {
99631 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
99632 :
99633 :
99634 :
99635 : }
99636 :
99637 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99638 0 : }
99639 :
99640 :
99641 : /* #line 99642 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99642 :
99643 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
99644 :
99645 : // Generated constructor
99646 0 : SgOmpNumTasksClause::SgOmpNumTasksClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
99647 0 : : SgOmpExpressionClause(startOfConstruct, expression)
99648 : {
99649 : #ifdef DEBUG
99650 : // printf ("In SgOmpNumTasksClause::SgOmpNumTasksClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
99651 : #endif
99652 : #if 0
99653 : // debugging information!
99654 : printf ("In SgOmpNumTasksClause::SgOmpNumTasksClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
99655 : #endif
99656 :
99657 :
99658 :
99659 : #if 0
99660 : // DQ (7/30/2014): Call a virtual function.
99661 : std::string s = this->class_name();
99662 : #endif
99663 :
99664 : // Test the variant virtual function
99665 : // assert(OmpNumTasksClauseTag == variant());
99666 0 : assert(OmpNumTasksClauseTag == this->variant());
99667 0 : ROSE_ASSERT(OmpNumTasksClauseTag == (int)(this->variantT()));
99668 0 : post_construction_initialization();
99669 :
99670 : // Test the isSgOmpNumTasksClause() function since it has been problematic
99671 0 : assert(isSgOmpNumTasksClause(this) != NULL);
99672 0 : }
99673 :
99674 : // Generated constructor (all data members)
99675 :
99676 : /* #line 99677 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99677 :
99678 :
99679 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99680 :
99681 :
99682 : // ********************************************************
99683 : // member functions common across all array grammar objects
99684 : // ********************************************************
99685 :
99686 :
99687 :
99688 : /* #line 99689 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99689 :
99690 :
99691 :
99692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99693 :
99694 : // ********************************************************
99695 : // member functions specific to each node in the grammar
99696 : // ********************************************************
99697 :
99698 :
99699 : /* #line 99700 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99700 :
99701 : // Start of memberFunctionString
99702 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
99703 :
99704 : // *** COMMON CODE SECTION BEGINS HERE ***
99705 :
99706 : #if 0
99707 : int
99708 : SgOmpDetachClause::getVariant() const
99709 : {
99710 : // This function is used in ROSE while "variant()" is used in SAGE
99711 : assert(this != NULL);
99712 : return variant();
99713 : }
99714 : #endif
99715 :
99716 : // This function is used in ROSE in treeTraversal code
99717 : // eventually replaces getVariant() and variant()
99718 : // though after variant() has been removed for a while we will
99719 : // want to change the name of variantT() back to variant()
99720 : // (since the "T" was ment to stand for temporary).
99721 : // When this happens the variantT() will be depricated.
99722 : VariantT
99723 0 : SgOmpDetachClause::variantT() const
99724 : {
99725 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
99726 0 : ROSE_ASSERT(this != NULL);
99727 0 : return V_SgOmpDetachClause;
99728 : }
99729 :
99730 : #if 0
99731 : int
99732 : SgOmpDetachClause::variant() const
99733 : {
99734 : // This function is used in SAGE
99735 : ROSE_ASSERT(this != NULL);
99736 : return OmpDetachClauseTag;
99737 : }
99738 : #endif
99739 :
99740 : ROSE_DLL_API const char*
99741 0 : SgOmpDetachClause::sage_class_name() const
99742 : {
99743 0 : ROSE_ASSERT(this != NULL);
99744 0 : return "SgOmpDetachClause";
99745 : }
99746 :
99747 : std::string
99748 0 : SgOmpDetachClause::class_name() const
99749 : {
99750 0 : ROSE_ASSERT(this != NULL);
99751 0 : return "SgOmpDetachClause";
99752 : }
99753 :
99754 : // DQ (11/26/2005): Support for visitor pattern mechanims
99755 : // (inferior to ROSE traversal mechanism, experimental).
99756 : void
99757 0 : SgOmpDetachClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
99758 : {
99759 0 : ROSE_ASSERT(this != NULL);
99760 0 : visitor.visit(this);
99761 0 : }
99762 :
99763 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
99764 0 : void SgOmpDetachClause::accept (ROSE_VisitorPattern & visitor) {
99765 0 : ROSE_ASSERT(this != NULL);
99766 0 : visitor.visit(this);
99767 0 : }
99768 :
99769 : SgOmpDetachClause*
99770 0 : SgOmpDetachClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
99771 : {
99772 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
99773 : // This function is currently only supported for the AST used the represent Binary executables.
99774 : if (0 /* isSgAsmNode(this) != NULL */)
99775 : {
99776 : // Support for regex specification.
99777 : std::string prefixCode = "REGEX:";
99778 : addNewAttribute(prefixCode + s,a);
99779 : }
99780 : #endif
99781 :
99782 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
99783 0 : return this;
99784 : }
99785 :
99786 : // *** COMMON CODE SECTION ENDS HERE ***
99787 :
99788 :
99789 : // End of memberFunctionString
99790 : // Start of memberFunctionString
99791 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
99792 :
99793 :
99794 : #if 0
99795 : //! Error checking support
99796 : /*! Verifies the following:
99797 : - working getVariant() member function
99798 : - calls base class's error() member function
99799 : Every class has one of these functions.
99800 : */
99801 : bool
99802 : SgOmpDetachClause::error()
99803 : {
99804 : // Put error checking here
99805 :
99806 : ROSE_ASSERT (this != NULL);
99807 : if (getVariant() != OmpDetachClauseTag)
99808 : {
99809 : printf ("Error in SgOmpDetachClause::error(): SgOmpDetachClause object has a %s variant \n",
99810 : Cxx_GrammarTerminalNames[getVariant()].name);
99811 : // printf ("Error in SgOmpDetachClause::error() \n");
99812 : ROSE_ABORT();
99813 : }
99814 :
99815 : ROSE_ASSERT (getVariant() == OmpDetachClauseTag);
99816 : return SgOmpExpressionClause::error();
99817 : }
99818 : #endif
99819 :
99820 :
99821 :
99822 : // End of memberFunctionString
99823 :
99824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
99825 :
99826 9 : SgOmpDetachClause* isSgOmpDetachClause ( SgNode* inputDerivedClassPointer )
99827 : {
99828 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99829 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99830 : // So to fix this we return NULL directly when the input is NULL and avoid the
99831 : // dynamic_cast in this case. This is likely a performance improvement as well.
99832 : // return dynamic_cast<SgOmpDetachClause*>(inputDerivedClassPointer);
99833 : // Milind Chabbi (8/28/2013): isSgOmpDetachClause uses table-driven castability instead of c++ default dynamic_cast
99834 : // this improves the running time performance by 10-20%.
99835 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDetachClause*>(inputDerivedClassPointer);
99836 9 : return IS_SgOmpDetachClause_FAST_MACRO(inputDerivedClassPointer);
99837 : }
99838 :
99839 : // DQ (11/8/2003): Added version of functions taking const pointer
99840 0 : const SgOmpDetachClause* isSgOmpDetachClause ( const SgNode* inputDerivedClassPointer )
99841 : {
99842 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
99843 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
99844 : // So to fix this we return NULL directly when the input is NULL and avoid the
99845 : // dynamic_cast in this case. This is likely a performance improvement as well.
99846 : // return dynamic_cast<const SgOmpDetachClause*>(inputDerivedClassPointer);
99847 : // Milind Chabbi (8/28/2013): isSgOmpDetachClause uses table-driven castability instead of c++ default dynamic_cast
99848 : // this improves the running time performance by 10-20%.
99849 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDetachClause*>(inputDerivedClassPointer);
99850 0 : return IS_SgOmpDetachClause_FAST_MACRO(inputDerivedClassPointer);
99851 : }
99852 :
99853 :
99854 :
99855 : /* #line 99856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99856 :
99857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99858 :
99859 : /**
99860 : \brief Generated destructor
99861 :
99862 : This destructor is automatically generated (by ROSETTA). This destructor
99863 : only frees memory of data members associated with the parts of the current IR node which
99864 : are NOT traversed. Those data members that are part of a traversal can be freed using
99865 : a traversal (calling this destructor on all children in a post-order traversal). Such
99866 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
99867 :
99868 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
99869 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
99870 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
99871 :
99872 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
99873 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
99874 : pointers are not yet implemented to call delete on eash pointer in the container.
99875 : (This could be done by derivation from the STL containers to define containers that
99876 : automatically deleted their members.)
99877 :
99878 : */
99879 0 : SgOmpDetachClause::~SgOmpDetachClause () {
99880 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
99881 :
99882 :
99883 :
99884 : }
99885 :
99886 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
99887 0 : }
99888 :
99889 :
99890 : /* #line 99891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99891 :
99892 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
99893 :
99894 : // Generated constructor
99895 0 : SgOmpDetachClause::SgOmpDetachClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
99896 0 : : SgOmpExpressionClause(startOfConstruct, expression)
99897 : {
99898 : #ifdef DEBUG
99899 : // printf ("In SgOmpDetachClause::SgOmpDetachClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
99900 : #endif
99901 : #if 0
99902 : // debugging information!
99903 : printf ("In SgOmpDetachClause::SgOmpDetachClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
99904 : #endif
99905 :
99906 :
99907 :
99908 : #if 0
99909 : // DQ (7/30/2014): Call a virtual function.
99910 : std::string s = this->class_name();
99911 : #endif
99912 :
99913 : // Test the variant virtual function
99914 : // assert(OmpDetachClauseTag == variant());
99915 0 : assert(OmpDetachClauseTag == this->variant());
99916 0 : ROSE_ASSERT(OmpDetachClauseTag == (int)(this->variantT()));
99917 0 : post_construction_initialization();
99918 :
99919 : // Test the isSgOmpDetachClause() function since it has been problematic
99920 0 : assert(isSgOmpDetachClause(this) != NULL);
99921 0 : }
99922 :
99923 : // Generated constructor (all data members)
99924 :
99925 : /* #line 99926 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99926 :
99927 :
99928 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99929 :
99930 :
99931 : // ********************************************************
99932 : // member functions common across all array grammar objects
99933 : // ********************************************************
99934 :
99935 :
99936 :
99937 : /* #line 99938 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99938 :
99939 :
99940 :
99941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
99942 :
99943 : // ********************************************************
99944 : // member functions specific to each node in the grammar
99945 : // ********************************************************
99946 :
99947 :
99948 : /* #line 99949 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
99949 :
99950 : // Start of memberFunctionString
99951 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
99952 :
99953 : // *** COMMON CODE SECTION BEGINS HERE ***
99954 :
99955 : #if 0
99956 : int
99957 : SgOmpSafelenClause::getVariant() const
99958 : {
99959 : // This function is used in ROSE while "variant()" is used in SAGE
99960 : assert(this != NULL);
99961 : return variant();
99962 : }
99963 : #endif
99964 :
99965 : // This function is used in ROSE in treeTraversal code
99966 : // eventually replaces getVariant() and variant()
99967 : // though after variant() has been removed for a while we will
99968 : // want to change the name of variantT() back to variant()
99969 : // (since the "T" was ment to stand for temporary).
99970 : // When this happens the variantT() will be depricated.
99971 : VariantT
99972 90 : SgOmpSafelenClause::variantT() const
99973 : {
99974 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
99975 90 : ROSE_ASSERT(this != NULL);
99976 90 : return V_SgOmpSafelenClause;
99977 : }
99978 :
99979 : #if 0
99980 : int
99981 : SgOmpSafelenClause::variant() const
99982 : {
99983 : // This function is used in SAGE
99984 : ROSE_ASSERT(this != NULL);
99985 : return OmpSafelenTag;
99986 : }
99987 : #endif
99988 :
99989 : ROSE_DLL_API const char*
99990 0 : SgOmpSafelenClause::sage_class_name() const
99991 : {
99992 0 : ROSE_ASSERT(this != NULL);
99993 0 : return "SgOmpSafelenClause";
99994 : }
99995 :
99996 : std::string
99997 2 : SgOmpSafelenClause::class_name() const
99998 : {
99999 2 : ROSE_ASSERT(this != NULL);
100000 2 : return "SgOmpSafelenClause";
100001 : }
100002 :
100003 : // DQ (11/26/2005): Support for visitor pattern mechanims
100004 : // (inferior to ROSE traversal mechanism, experimental).
100005 : void
100006 0 : SgOmpSafelenClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
100007 : {
100008 0 : ROSE_ASSERT(this != NULL);
100009 0 : visitor.visit(this);
100010 0 : }
100011 :
100012 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
100013 0 : void SgOmpSafelenClause::accept (ROSE_VisitorPattern & visitor) {
100014 0 : ROSE_ASSERT(this != NULL);
100015 0 : visitor.visit(this);
100016 0 : }
100017 :
100018 : SgOmpSafelenClause*
100019 0 : SgOmpSafelenClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
100020 : {
100021 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
100022 : // This function is currently only supported for the AST used the represent Binary executables.
100023 : if (0 /* isSgAsmNode(this) != NULL */)
100024 : {
100025 : // Support for regex specification.
100026 : std::string prefixCode = "REGEX:";
100027 : addNewAttribute(prefixCode + s,a);
100028 : }
100029 : #endif
100030 :
100031 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
100032 0 : return this;
100033 : }
100034 :
100035 : // *** COMMON CODE SECTION ENDS HERE ***
100036 :
100037 :
100038 : // End of memberFunctionString
100039 : // Start of memberFunctionString
100040 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
100041 :
100042 :
100043 : #if 0
100044 : //! Error checking support
100045 : /*! Verifies the following:
100046 : - working getVariant() member function
100047 : - calls base class's error() member function
100048 : Every class has one of these functions.
100049 : */
100050 : bool
100051 : SgOmpSafelenClause::error()
100052 : {
100053 : // Put error checking here
100054 :
100055 : ROSE_ASSERT (this != NULL);
100056 : if (getVariant() != OmpSafelenTag)
100057 : {
100058 : printf ("Error in SgOmpSafelenClause::error(): SgOmpSafelenClause object has a %s variant \n",
100059 : Cxx_GrammarTerminalNames[getVariant()].name);
100060 : // printf ("Error in SgOmpSafelenClause::error() \n");
100061 : ROSE_ABORT();
100062 : }
100063 :
100064 : ROSE_ASSERT (getVariant() == OmpSafelenTag);
100065 : return SgOmpExpressionClause::error();
100066 : }
100067 : #endif
100068 :
100069 :
100070 :
100071 : // End of memberFunctionString
100072 :
100073 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
100074 :
100075 6 : SgOmpSafelenClause* isSgOmpSafelenClause ( SgNode* inputDerivedClassPointer )
100076 : {
100077 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100078 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100079 : // So to fix this we return NULL directly when the input is NULL and avoid the
100080 : // dynamic_cast in this case. This is likely a performance improvement as well.
100081 : // return dynamic_cast<SgOmpSafelenClause*>(inputDerivedClassPointer);
100082 : // Milind Chabbi (8/28/2013): isSgOmpSafelenClause uses table-driven castability instead of c++ default dynamic_cast
100083 : // this improves the running time performance by 10-20%.
100084 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSafelenClause*>(inputDerivedClassPointer);
100085 6 : return IS_SgOmpSafelenClause_FAST_MACRO(inputDerivedClassPointer);
100086 : }
100087 :
100088 : // DQ (11/8/2003): Added version of functions taking const pointer
100089 0 : const SgOmpSafelenClause* isSgOmpSafelenClause ( const SgNode* inputDerivedClassPointer )
100090 : {
100091 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100092 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100093 : // So to fix this we return NULL directly when the input is NULL and avoid the
100094 : // dynamic_cast in this case. This is likely a performance improvement as well.
100095 : // return dynamic_cast<const SgOmpSafelenClause*>(inputDerivedClassPointer);
100096 : // Milind Chabbi (8/28/2013): isSgOmpSafelenClause uses table-driven castability instead of c++ default dynamic_cast
100097 : // this improves the running time performance by 10-20%.
100098 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSafelenClause*>(inputDerivedClassPointer);
100099 0 : return IS_SgOmpSafelenClause_FAST_MACRO(inputDerivedClassPointer);
100100 : }
100101 :
100102 :
100103 :
100104 : /* #line 100105 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100105 :
100106 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100107 :
100108 : /**
100109 : \brief Generated destructor
100110 :
100111 : This destructor is automatically generated (by ROSETTA). This destructor
100112 : only frees memory of data members associated with the parts of the current IR node which
100113 : are NOT traversed. Those data members that are part of a traversal can be freed using
100114 : a traversal (calling this destructor on all children in a post-order traversal). Such
100115 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
100116 :
100117 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
100118 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
100119 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
100120 :
100121 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
100122 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
100123 : pointers are not yet implemented to call delete on eash pointer in the container.
100124 : (This could be done by derivation from the STL containers to define containers that
100125 : automatically deleted their members.)
100126 :
100127 : */
100128 0 : SgOmpSafelenClause::~SgOmpSafelenClause () {
100129 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
100130 :
100131 :
100132 :
100133 : }
100134 :
100135 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100136 0 : }
100137 :
100138 :
100139 : /* #line 100140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100140 :
100141 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
100142 :
100143 : // Generated constructor
100144 0 : SgOmpSafelenClause::SgOmpSafelenClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
100145 0 : : SgOmpExpressionClause(startOfConstruct, expression)
100146 : {
100147 : #ifdef DEBUG
100148 : // printf ("In SgOmpSafelenClause::SgOmpSafelenClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
100149 : #endif
100150 : #if 0
100151 : // debugging information!
100152 : printf ("In SgOmpSafelenClause::SgOmpSafelenClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
100153 : #endif
100154 :
100155 :
100156 :
100157 : #if 0
100158 : // DQ (7/30/2014): Call a virtual function.
100159 : std::string s = this->class_name();
100160 : #endif
100161 :
100162 : // Test the variant virtual function
100163 : // assert(OmpSafelenTag == variant());
100164 0 : assert(OmpSafelenTag == this->variant());
100165 0 : ROSE_ASSERT(OmpSafelenTag == (int)(this->variantT()));
100166 0 : post_construction_initialization();
100167 :
100168 : // Test the isSgOmpSafelenClause() function since it has been problematic
100169 0 : assert(isSgOmpSafelenClause(this) != NULL);
100170 0 : }
100171 :
100172 : // Generated constructor (all data members)
100173 :
100174 : /* #line 100175 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100175 :
100176 :
100177 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100178 :
100179 :
100180 : // ********************************************************
100181 : // member functions common across all array grammar objects
100182 : // ********************************************************
100183 :
100184 :
100185 :
100186 : /* #line 100187 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100187 :
100188 :
100189 :
100190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100191 :
100192 : // ********************************************************
100193 : // member functions specific to each node in the grammar
100194 : // ********************************************************
100195 :
100196 :
100197 : /* #line 100198 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100198 :
100199 : // Start of memberFunctionString
100200 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
100201 :
100202 : // *** COMMON CODE SECTION BEGINS HERE ***
100203 :
100204 : #if 0
100205 : int
100206 : SgOmpSimdlenClause::getVariant() const
100207 : {
100208 : // This function is used in ROSE while "variant()" is used in SAGE
100209 : assert(this != NULL);
100210 : return variant();
100211 : }
100212 : #endif
100213 :
100214 : // This function is used in ROSE in treeTraversal code
100215 : // eventually replaces getVariant() and variant()
100216 : // though after variant() has been removed for a while we will
100217 : // want to change the name of variantT() back to variant()
100218 : // (since the "T" was ment to stand for temporary).
100219 : // When this happens the variantT() will be depricated.
100220 : VariantT
100221 92 : SgOmpSimdlenClause::variantT() const
100222 : {
100223 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
100224 92 : ROSE_ASSERT(this != NULL);
100225 92 : return V_SgOmpSimdlenClause;
100226 : }
100227 :
100228 : #if 0
100229 : int
100230 : SgOmpSimdlenClause::variant() const
100231 : {
100232 : // This function is used in SAGE
100233 : ROSE_ASSERT(this != NULL);
100234 : return OmpSimdlenTag;
100235 : }
100236 : #endif
100237 :
100238 : ROSE_DLL_API const char*
100239 0 : SgOmpSimdlenClause::sage_class_name() const
100240 : {
100241 0 : ROSE_ASSERT(this != NULL);
100242 0 : return "SgOmpSimdlenClause";
100243 : }
100244 :
100245 : std::string
100246 2 : SgOmpSimdlenClause::class_name() const
100247 : {
100248 2 : ROSE_ASSERT(this != NULL);
100249 2 : return "SgOmpSimdlenClause";
100250 : }
100251 :
100252 : // DQ (11/26/2005): Support for visitor pattern mechanims
100253 : // (inferior to ROSE traversal mechanism, experimental).
100254 : void
100255 0 : SgOmpSimdlenClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
100256 : {
100257 0 : ROSE_ASSERT(this != NULL);
100258 0 : visitor.visit(this);
100259 0 : }
100260 :
100261 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
100262 0 : void SgOmpSimdlenClause::accept (ROSE_VisitorPattern & visitor) {
100263 0 : ROSE_ASSERT(this != NULL);
100264 0 : visitor.visit(this);
100265 0 : }
100266 :
100267 : SgOmpSimdlenClause*
100268 0 : SgOmpSimdlenClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
100269 : {
100270 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
100271 : // This function is currently only supported for the AST used the represent Binary executables.
100272 : if (0 /* isSgAsmNode(this) != NULL */)
100273 : {
100274 : // Support for regex specification.
100275 : std::string prefixCode = "REGEX:";
100276 : addNewAttribute(prefixCode + s,a);
100277 : }
100278 : #endif
100279 :
100280 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
100281 0 : return this;
100282 : }
100283 :
100284 : // *** COMMON CODE SECTION ENDS HERE ***
100285 :
100286 :
100287 : // End of memberFunctionString
100288 : // Start of memberFunctionString
100289 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
100290 :
100291 :
100292 : #if 0
100293 : //! Error checking support
100294 : /*! Verifies the following:
100295 : - working getVariant() member function
100296 : - calls base class's error() member function
100297 : Every class has one of these functions.
100298 : */
100299 : bool
100300 : SgOmpSimdlenClause::error()
100301 : {
100302 : // Put error checking here
100303 :
100304 : ROSE_ASSERT (this != NULL);
100305 : if (getVariant() != OmpSimdlenTag)
100306 : {
100307 : printf ("Error in SgOmpSimdlenClause::error(): SgOmpSimdlenClause object has a %s variant \n",
100308 : Cxx_GrammarTerminalNames[getVariant()].name);
100309 : // printf ("Error in SgOmpSimdlenClause::error() \n");
100310 : ROSE_ABORT();
100311 : }
100312 :
100313 : ROSE_ASSERT (getVariant() == OmpSimdlenTag);
100314 : return SgOmpExpressionClause::error();
100315 : }
100316 : #endif
100317 :
100318 :
100319 :
100320 : // End of memberFunctionString
100321 :
100322 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
100323 :
100324 4 : SgOmpSimdlenClause* isSgOmpSimdlenClause ( SgNode* inputDerivedClassPointer )
100325 : {
100326 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100327 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100328 : // So to fix this we return NULL directly when the input is NULL and avoid the
100329 : // dynamic_cast in this case. This is likely a performance improvement as well.
100330 : // return dynamic_cast<SgOmpSimdlenClause*>(inputDerivedClassPointer);
100331 : // Milind Chabbi (8/28/2013): isSgOmpSimdlenClause uses table-driven castability instead of c++ default dynamic_cast
100332 : // this improves the running time performance by 10-20%.
100333 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSimdlenClause*>(inputDerivedClassPointer);
100334 4 : return IS_SgOmpSimdlenClause_FAST_MACRO(inputDerivedClassPointer);
100335 : }
100336 :
100337 : // DQ (11/8/2003): Added version of functions taking const pointer
100338 0 : const SgOmpSimdlenClause* isSgOmpSimdlenClause ( const SgNode* inputDerivedClassPointer )
100339 : {
100340 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100341 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100342 : // So to fix this we return NULL directly when the input is NULL and avoid the
100343 : // dynamic_cast in this case. This is likely a performance improvement as well.
100344 : // return dynamic_cast<const SgOmpSimdlenClause*>(inputDerivedClassPointer);
100345 : // Milind Chabbi (8/28/2013): isSgOmpSimdlenClause uses table-driven castability instead of c++ default dynamic_cast
100346 : // this improves the running time performance by 10-20%.
100347 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSimdlenClause*>(inputDerivedClassPointer);
100348 0 : return IS_SgOmpSimdlenClause_FAST_MACRO(inputDerivedClassPointer);
100349 : }
100350 :
100351 :
100352 :
100353 : /* #line 100354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100354 :
100355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100356 :
100357 : /**
100358 : \brief Generated destructor
100359 :
100360 : This destructor is automatically generated (by ROSETTA). This destructor
100361 : only frees memory of data members associated with the parts of the current IR node which
100362 : are NOT traversed. Those data members that are part of a traversal can be freed using
100363 : a traversal (calling this destructor on all children in a post-order traversal). Such
100364 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
100365 :
100366 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
100367 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
100368 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
100369 :
100370 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
100371 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
100372 : pointers are not yet implemented to call delete on eash pointer in the container.
100373 : (This could be done by derivation from the STL containers to define containers that
100374 : automatically deleted their members.)
100375 :
100376 : */
100377 0 : SgOmpSimdlenClause::~SgOmpSimdlenClause () {
100378 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
100379 :
100380 :
100381 :
100382 : }
100383 :
100384 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100385 0 : }
100386 :
100387 :
100388 : /* #line 100389 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100389 :
100390 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
100391 :
100392 : // Generated constructor
100393 0 : SgOmpSimdlenClause::SgOmpSimdlenClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
100394 0 : : SgOmpExpressionClause(startOfConstruct, expression)
100395 : {
100396 : #ifdef DEBUG
100397 : // printf ("In SgOmpSimdlenClause::SgOmpSimdlenClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
100398 : #endif
100399 : #if 0
100400 : // debugging information!
100401 : printf ("In SgOmpSimdlenClause::SgOmpSimdlenClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
100402 : #endif
100403 :
100404 :
100405 :
100406 : #if 0
100407 : // DQ (7/30/2014): Call a virtual function.
100408 : std::string s = this->class_name();
100409 : #endif
100410 :
100411 : // Test the variant virtual function
100412 : // assert(OmpSimdlenTag == variant());
100413 0 : assert(OmpSimdlenTag == this->variant());
100414 0 : ROSE_ASSERT(OmpSimdlenTag == (int)(this->variantT()));
100415 0 : post_construction_initialization();
100416 :
100417 : // Test the isSgOmpSimdlenClause() function since it has been problematic
100418 0 : assert(isSgOmpSimdlenClause(this) != NULL);
100419 0 : }
100420 :
100421 : // Generated constructor (all data members)
100422 :
100423 : /* #line 100424 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100424 :
100425 :
100426 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100427 :
100428 :
100429 : // ********************************************************
100430 : // member functions common across all array grammar objects
100431 : // ********************************************************
100432 :
100433 :
100434 :
100435 : /* #line 100436 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100436 :
100437 :
100438 :
100439 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100440 :
100441 : // ********************************************************
100442 : // member functions specific to each node in the grammar
100443 : // ********************************************************
100444 :
100445 :
100446 : /* #line 100447 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100447 :
100448 : // Start of memberFunctionString
100449 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
100450 :
100451 : // *** COMMON CODE SECTION BEGINS HERE ***
100452 :
100453 : #if 0
100454 : int
100455 : SgOmpFinalClause::getVariant() const
100456 : {
100457 : // This function is used in ROSE while "variant()" is used in SAGE
100458 : assert(this != NULL);
100459 : return variant();
100460 : }
100461 : #endif
100462 :
100463 : // This function is used in ROSE in treeTraversal code
100464 : // eventually replaces getVariant() and variant()
100465 : // though after variant() has been removed for a while we will
100466 : // want to change the name of variantT() back to variant()
100467 : // (since the "T" was ment to stand for temporary).
100468 : // When this happens the variantT() will be depricated.
100469 : VariantT
100470 182 : SgOmpFinalClause::variantT() const
100471 : {
100472 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
100473 182 : ROSE_ASSERT(this != NULL);
100474 182 : return V_SgOmpFinalClause;
100475 : }
100476 :
100477 : #if 0
100478 : int
100479 : SgOmpFinalClause::variant() const
100480 : {
100481 : // This function is used in SAGE
100482 : ROSE_ASSERT(this != NULL);
100483 : return OmpFinalClauseTag;
100484 : }
100485 : #endif
100486 :
100487 : ROSE_DLL_API const char*
100488 0 : SgOmpFinalClause::sage_class_name() const
100489 : {
100490 0 : ROSE_ASSERT(this != NULL);
100491 0 : return "SgOmpFinalClause";
100492 : }
100493 :
100494 : std::string
100495 3 : SgOmpFinalClause::class_name() const
100496 : {
100497 3 : ROSE_ASSERT(this != NULL);
100498 3 : return "SgOmpFinalClause";
100499 : }
100500 :
100501 : // DQ (11/26/2005): Support for visitor pattern mechanims
100502 : // (inferior to ROSE traversal mechanism, experimental).
100503 : void
100504 0 : SgOmpFinalClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
100505 : {
100506 0 : ROSE_ASSERT(this != NULL);
100507 0 : visitor.visit(this);
100508 0 : }
100509 :
100510 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
100511 0 : void SgOmpFinalClause::accept (ROSE_VisitorPattern & visitor) {
100512 0 : ROSE_ASSERT(this != NULL);
100513 0 : visitor.visit(this);
100514 0 : }
100515 :
100516 : SgOmpFinalClause*
100517 0 : SgOmpFinalClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
100518 : {
100519 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
100520 : // This function is currently only supported for the AST used the represent Binary executables.
100521 : if (0 /* isSgAsmNode(this) != NULL */)
100522 : {
100523 : // Support for regex specification.
100524 : std::string prefixCode = "REGEX:";
100525 : addNewAttribute(prefixCode + s,a);
100526 : }
100527 : #endif
100528 :
100529 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
100530 0 : return this;
100531 : }
100532 :
100533 : // *** COMMON CODE SECTION ENDS HERE ***
100534 :
100535 :
100536 : // End of memberFunctionString
100537 : // Start of memberFunctionString
100538 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
100539 :
100540 :
100541 : #if 0
100542 : //! Error checking support
100543 : /*! Verifies the following:
100544 : - working getVariant() member function
100545 : - calls base class's error() member function
100546 : Every class has one of these functions.
100547 : */
100548 : bool
100549 : SgOmpFinalClause::error()
100550 : {
100551 : // Put error checking here
100552 :
100553 : ROSE_ASSERT (this != NULL);
100554 : if (getVariant() != OmpFinalClauseTag)
100555 : {
100556 : printf ("Error in SgOmpFinalClause::error(): SgOmpFinalClause object has a %s variant \n",
100557 : Cxx_GrammarTerminalNames[getVariant()].name);
100558 : // printf ("Error in SgOmpFinalClause::error() \n");
100559 : ROSE_ABORT();
100560 : }
100561 :
100562 : ROSE_ASSERT (getVariant() == OmpFinalClauseTag);
100563 : return SgOmpExpressionClause::error();
100564 : }
100565 : #endif
100566 :
100567 :
100568 :
100569 : // End of memberFunctionString
100570 :
100571 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
100572 :
100573 42 : SgOmpFinalClause* isSgOmpFinalClause ( SgNode* inputDerivedClassPointer )
100574 : {
100575 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100576 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100577 : // So to fix this we return NULL directly when the input is NULL and avoid the
100578 : // dynamic_cast in this case. This is likely a performance improvement as well.
100579 : // return dynamic_cast<SgOmpFinalClause*>(inputDerivedClassPointer);
100580 : // Milind Chabbi (8/28/2013): isSgOmpFinalClause uses table-driven castability instead of c++ default dynamic_cast
100581 : // this improves the running time performance by 10-20%.
100582 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpFinalClause*>(inputDerivedClassPointer);
100583 42 : return IS_SgOmpFinalClause_FAST_MACRO(inputDerivedClassPointer);
100584 : }
100585 :
100586 : // DQ (11/8/2003): Added version of functions taking const pointer
100587 0 : const SgOmpFinalClause* isSgOmpFinalClause ( const SgNode* inputDerivedClassPointer )
100588 : {
100589 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100590 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100591 : // So to fix this we return NULL directly when the input is NULL and avoid the
100592 : // dynamic_cast in this case. This is likely a performance improvement as well.
100593 : // return dynamic_cast<const SgOmpFinalClause*>(inputDerivedClassPointer);
100594 : // Milind Chabbi (8/28/2013): isSgOmpFinalClause uses table-driven castability instead of c++ default dynamic_cast
100595 : // this improves the running time performance by 10-20%.
100596 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpFinalClause*>(inputDerivedClassPointer);
100597 0 : return IS_SgOmpFinalClause_FAST_MACRO(inputDerivedClassPointer);
100598 : }
100599 :
100600 :
100601 :
100602 : /* #line 100603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100603 :
100604 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100605 :
100606 : /**
100607 : \brief Generated destructor
100608 :
100609 : This destructor is automatically generated (by ROSETTA). This destructor
100610 : only frees memory of data members associated with the parts of the current IR node which
100611 : are NOT traversed. Those data members that are part of a traversal can be freed using
100612 : a traversal (calling this destructor on all children in a post-order traversal). Such
100613 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
100614 :
100615 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
100616 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
100617 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
100618 :
100619 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
100620 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
100621 : pointers are not yet implemented to call delete on eash pointer in the container.
100622 : (This could be done by derivation from the STL containers to define containers that
100623 : automatically deleted their members.)
100624 :
100625 : */
100626 0 : SgOmpFinalClause::~SgOmpFinalClause () {
100627 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
100628 :
100629 :
100630 :
100631 : }
100632 :
100633 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100634 0 : }
100635 :
100636 :
100637 : /* #line 100638 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100638 :
100639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
100640 :
100641 : // Generated constructor
100642 0 : SgOmpFinalClause::SgOmpFinalClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
100643 0 : : SgOmpExpressionClause(startOfConstruct, expression)
100644 : {
100645 : #ifdef DEBUG
100646 : // printf ("In SgOmpFinalClause::SgOmpFinalClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
100647 : #endif
100648 : #if 0
100649 : // debugging information!
100650 : printf ("In SgOmpFinalClause::SgOmpFinalClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
100651 : #endif
100652 :
100653 :
100654 :
100655 : #if 0
100656 : // DQ (7/30/2014): Call a virtual function.
100657 : std::string s = this->class_name();
100658 : #endif
100659 :
100660 : // Test the variant virtual function
100661 : // assert(OmpFinalClauseTag == variant());
100662 0 : assert(OmpFinalClauseTag == this->variant());
100663 0 : ROSE_ASSERT(OmpFinalClauseTag == (int)(this->variantT()));
100664 0 : post_construction_initialization();
100665 :
100666 : // Test the isSgOmpFinalClause() function since it has been problematic
100667 0 : assert(isSgOmpFinalClause(this) != NULL);
100668 0 : }
100669 :
100670 : // Generated constructor (all data members)
100671 :
100672 : /* #line 100673 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100673 :
100674 :
100675 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100676 :
100677 :
100678 : // ********************************************************
100679 : // member functions common across all array grammar objects
100680 : // ********************************************************
100681 :
100682 :
100683 :
100684 : /* #line 100685 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100685 :
100686 :
100687 :
100688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100689 :
100690 : // ********************************************************
100691 : // member functions specific to each node in the grammar
100692 : // ********************************************************
100693 :
100694 :
100695 : /* #line 100696 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100696 :
100697 : // Start of memberFunctionString
100698 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
100699 :
100700 : // *** COMMON CODE SECTION BEGINS HERE ***
100701 :
100702 : #if 0
100703 : int
100704 : SgOmpPriorityClause::getVariant() const
100705 : {
100706 : // This function is used in ROSE while "variant()" is used in SAGE
100707 : assert(this != NULL);
100708 : return variant();
100709 : }
100710 : #endif
100711 :
100712 : // This function is used in ROSE in treeTraversal code
100713 : // eventually replaces getVariant() and variant()
100714 : // though after variant() has been removed for a while we will
100715 : // want to change the name of variantT() back to variant()
100716 : // (since the "T" was ment to stand for temporary).
100717 : // When this happens the variantT() will be depricated.
100718 : VariantT
100719 62 : SgOmpPriorityClause::variantT() const
100720 : {
100721 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
100722 62 : ROSE_ASSERT(this != NULL);
100723 62 : return V_SgOmpPriorityClause;
100724 : }
100725 :
100726 : #if 0
100727 : int
100728 : SgOmpPriorityClause::variant() const
100729 : {
100730 : // This function is used in SAGE
100731 : ROSE_ASSERT(this != NULL);
100732 : return OmpPriorityClauseTag;
100733 : }
100734 : #endif
100735 :
100736 : ROSE_DLL_API const char*
100737 0 : SgOmpPriorityClause::sage_class_name() const
100738 : {
100739 0 : ROSE_ASSERT(this != NULL);
100740 0 : return "SgOmpPriorityClause";
100741 : }
100742 :
100743 : std::string
100744 1 : SgOmpPriorityClause::class_name() const
100745 : {
100746 1 : ROSE_ASSERT(this != NULL);
100747 1 : return "SgOmpPriorityClause";
100748 : }
100749 :
100750 : // DQ (11/26/2005): Support for visitor pattern mechanims
100751 : // (inferior to ROSE traversal mechanism, experimental).
100752 : void
100753 0 : SgOmpPriorityClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
100754 : {
100755 0 : ROSE_ASSERT(this != NULL);
100756 0 : visitor.visit(this);
100757 0 : }
100758 :
100759 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
100760 0 : void SgOmpPriorityClause::accept (ROSE_VisitorPattern & visitor) {
100761 0 : ROSE_ASSERT(this != NULL);
100762 0 : visitor.visit(this);
100763 0 : }
100764 :
100765 : SgOmpPriorityClause*
100766 0 : SgOmpPriorityClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
100767 : {
100768 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
100769 : // This function is currently only supported for the AST used the represent Binary executables.
100770 : if (0 /* isSgAsmNode(this) != NULL */)
100771 : {
100772 : // Support for regex specification.
100773 : std::string prefixCode = "REGEX:";
100774 : addNewAttribute(prefixCode + s,a);
100775 : }
100776 : #endif
100777 :
100778 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
100779 0 : return this;
100780 : }
100781 :
100782 : // *** COMMON CODE SECTION ENDS HERE ***
100783 :
100784 :
100785 : // End of memberFunctionString
100786 : // Start of memberFunctionString
100787 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
100788 :
100789 :
100790 : #if 0
100791 : //! Error checking support
100792 : /*! Verifies the following:
100793 : - working getVariant() member function
100794 : - calls base class's error() member function
100795 : Every class has one of these functions.
100796 : */
100797 : bool
100798 : SgOmpPriorityClause::error()
100799 : {
100800 : // Put error checking here
100801 :
100802 : ROSE_ASSERT (this != NULL);
100803 : if (getVariant() != OmpPriorityClauseTag)
100804 : {
100805 : printf ("Error in SgOmpPriorityClause::error(): SgOmpPriorityClause object has a %s variant \n",
100806 : Cxx_GrammarTerminalNames[getVariant()].name);
100807 : // printf ("Error in SgOmpPriorityClause::error() \n");
100808 : ROSE_ABORT();
100809 : }
100810 :
100811 : ROSE_ASSERT (getVariant() == OmpPriorityClauseTag);
100812 : return SgOmpExpressionClause::error();
100813 : }
100814 : #endif
100815 :
100816 :
100817 :
100818 : // End of memberFunctionString
100819 :
100820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
100821 :
100822 37 : SgOmpPriorityClause* isSgOmpPriorityClause ( SgNode* inputDerivedClassPointer )
100823 : {
100824 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100825 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100826 : // So to fix this we return NULL directly when the input is NULL and avoid the
100827 : // dynamic_cast in this case. This is likely a performance improvement as well.
100828 : // return dynamic_cast<SgOmpPriorityClause*>(inputDerivedClassPointer);
100829 : // Milind Chabbi (8/28/2013): isSgOmpPriorityClause uses table-driven castability instead of c++ default dynamic_cast
100830 : // this improves the running time performance by 10-20%.
100831 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpPriorityClause*>(inputDerivedClassPointer);
100832 37 : return IS_SgOmpPriorityClause_FAST_MACRO(inputDerivedClassPointer);
100833 : }
100834 :
100835 : // DQ (11/8/2003): Added version of functions taking const pointer
100836 0 : const SgOmpPriorityClause* isSgOmpPriorityClause ( const SgNode* inputDerivedClassPointer )
100837 : {
100838 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
100839 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
100840 : // So to fix this we return NULL directly when the input is NULL and avoid the
100841 : // dynamic_cast in this case. This is likely a performance improvement as well.
100842 : // return dynamic_cast<const SgOmpPriorityClause*>(inputDerivedClassPointer);
100843 : // Milind Chabbi (8/28/2013): isSgOmpPriorityClause uses table-driven castability instead of c++ default dynamic_cast
100844 : // this improves the running time performance by 10-20%.
100845 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpPriorityClause*>(inputDerivedClassPointer);
100846 0 : return IS_SgOmpPriorityClause_FAST_MACRO(inputDerivedClassPointer);
100847 : }
100848 :
100849 :
100850 :
100851 : /* #line 100852 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100852 :
100853 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100854 :
100855 : /**
100856 : \brief Generated destructor
100857 :
100858 : This destructor is automatically generated (by ROSETTA). This destructor
100859 : only frees memory of data members associated with the parts of the current IR node which
100860 : are NOT traversed. Those data members that are part of a traversal can be freed using
100861 : a traversal (calling this destructor on all children in a post-order traversal). Such
100862 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
100863 :
100864 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
100865 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
100866 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
100867 :
100868 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
100869 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
100870 : pointers are not yet implemented to call delete on eash pointer in the container.
100871 : (This could be done by derivation from the STL containers to define containers that
100872 : automatically deleted their members.)
100873 :
100874 : */
100875 0 : SgOmpPriorityClause::~SgOmpPriorityClause () {
100876 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
100877 :
100878 :
100879 :
100880 : }
100881 :
100882 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
100883 0 : }
100884 :
100885 :
100886 : /* #line 100887 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100887 :
100888 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
100889 :
100890 : // Generated constructor
100891 0 : SgOmpPriorityClause::SgOmpPriorityClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
100892 0 : : SgOmpExpressionClause(startOfConstruct, expression)
100893 : {
100894 : #ifdef DEBUG
100895 : // printf ("In SgOmpPriorityClause::SgOmpPriorityClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
100896 : #endif
100897 : #if 0
100898 : // debugging information!
100899 : printf ("In SgOmpPriorityClause::SgOmpPriorityClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
100900 : #endif
100901 :
100902 :
100903 :
100904 : #if 0
100905 : // DQ (7/30/2014): Call a virtual function.
100906 : std::string s = this->class_name();
100907 : #endif
100908 :
100909 : // Test the variant virtual function
100910 : // assert(OmpPriorityClauseTag == variant());
100911 0 : assert(OmpPriorityClauseTag == this->variant());
100912 0 : ROSE_ASSERT(OmpPriorityClauseTag == (int)(this->variantT()));
100913 0 : post_construction_initialization();
100914 :
100915 : // Test the isSgOmpPriorityClause() function since it has been problematic
100916 0 : assert(isSgOmpPriorityClause(this) != NULL);
100917 0 : }
100918 :
100919 : // Generated constructor (all data members)
100920 :
100921 : /* #line 100922 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100922 :
100923 :
100924 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100925 :
100926 :
100927 : // ********************************************************
100928 : // member functions common across all array grammar objects
100929 : // ********************************************************
100930 :
100931 :
100932 :
100933 : /* #line 100934 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100934 :
100935 :
100936 :
100937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
100938 :
100939 : // ********************************************************
100940 : // member functions specific to each node in the grammar
100941 : // ********************************************************
100942 :
100943 :
100944 : /* #line 100945 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
100945 :
100946 : // Start of memberFunctionString
100947 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
100948 :
100949 : // *** COMMON CODE SECTION BEGINS HERE ***
100950 :
100951 : #if 0
100952 : int
100953 : SgOmpPartialClause::getVariant() const
100954 : {
100955 : // This function is used in ROSE while "variant()" is used in SAGE
100956 : assert(this != NULL);
100957 : return variant();
100958 : }
100959 : #endif
100960 :
100961 : // This function is used in ROSE in treeTraversal code
100962 : // eventually replaces getVariant() and variant()
100963 : // though after variant() has been removed for a while we will
100964 : // want to change the name of variantT() back to variant()
100965 : // (since the "T" was ment to stand for temporary).
100966 : // When this happens the variantT() will be depricated.
100967 : VariantT
100968 0 : SgOmpPartialClause::variantT() const
100969 : {
100970 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
100971 0 : ROSE_ASSERT(this != NULL);
100972 0 : return V_SgOmpPartialClause;
100973 : }
100974 :
100975 : #if 0
100976 : int
100977 : SgOmpPartialClause::variant() const
100978 : {
100979 : // This function is used in SAGE
100980 : ROSE_ASSERT(this != NULL);
100981 : return OmpPartialTag;
100982 : }
100983 : #endif
100984 :
100985 : ROSE_DLL_API const char*
100986 0 : SgOmpPartialClause::sage_class_name() const
100987 : {
100988 0 : ROSE_ASSERT(this != NULL);
100989 0 : return "SgOmpPartialClause";
100990 : }
100991 :
100992 : std::string
100993 0 : SgOmpPartialClause::class_name() const
100994 : {
100995 0 : ROSE_ASSERT(this != NULL);
100996 0 : return "SgOmpPartialClause";
100997 : }
100998 :
100999 : // DQ (11/26/2005): Support for visitor pattern mechanims
101000 : // (inferior to ROSE traversal mechanism, experimental).
101001 : void
101002 0 : SgOmpPartialClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
101003 : {
101004 0 : ROSE_ASSERT(this != NULL);
101005 0 : visitor.visit(this);
101006 0 : }
101007 :
101008 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
101009 0 : void SgOmpPartialClause::accept (ROSE_VisitorPattern & visitor) {
101010 0 : ROSE_ASSERT(this != NULL);
101011 0 : visitor.visit(this);
101012 0 : }
101013 :
101014 : SgOmpPartialClause*
101015 0 : SgOmpPartialClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
101016 : {
101017 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
101018 : // This function is currently only supported for the AST used the represent Binary executables.
101019 : if (0 /* isSgAsmNode(this) != NULL */)
101020 : {
101021 : // Support for regex specification.
101022 : std::string prefixCode = "REGEX:";
101023 : addNewAttribute(prefixCode + s,a);
101024 : }
101025 : #endif
101026 :
101027 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
101028 0 : return this;
101029 : }
101030 :
101031 : // *** COMMON CODE SECTION ENDS HERE ***
101032 :
101033 :
101034 : // End of memberFunctionString
101035 : // Start of memberFunctionString
101036 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
101037 :
101038 :
101039 : #if 0
101040 : //! Error checking support
101041 : /*! Verifies the following:
101042 : - working getVariant() member function
101043 : - calls base class's error() member function
101044 : Every class has one of these functions.
101045 : */
101046 : bool
101047 : SgOmpPartialClause::error()
101048 : {
101049 : // Put error checking here
101050 :
101051 : ROSE_ASSERT (this != NULL);
101052 : if (getVariant() != OmpPartialTag)
101053 : {
101054 : printf ("Error in SgOmpPartialClause::error(): SgOmpPartialClause object has a %s variant \n",
101055 : Cxx_GrammarTerminalNames[getVariant()].name);
101056 : // printf ("Error in SgOmpPartialClause::error() \n");
101057 : ROSE_ABORT();
101058 : }
101059 :
101060 : ROSE_ASSERT (getVariant() == OmpPartialTag);
101061 : return SgOmpExpressionClause::error();
101062 : }
101063 : #endif
101064 :
101065 :
101066 :
101067 : // End of memberFunctionString
101068 :
101069 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
101070 :
101071 0 : SgOmpPartialClause* isSgOmpPartialClause ( SgNode* inputDerivedClassPointer )
101072 : {
101073 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101074 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101075 : // So to fix this we return NULL directly when the input is NULL and avoid the
101076 : // dynamic_cast in this case. This is likely a performance improvement as well.
101077 : // return dynamic_cast<SgOmpPartialClause*>(inputDerivedClassPointer);
101078 : // Milind Chabbi (8/28/2013): isSgOmpPartialClause uses table-driven castability instead of c++ default dynamic_cast
101079 : // this improves the running time performance by 10-20%.
101080 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpPartialClause*>(inputDerivedClassPointer);
101081 0 : return IS_SgOmpPartialClause_FAST_MACRO(inputDerivedClassPointer);
101082 : }
101083 :
101084 : // DQ (11/8/2003): Added version of functions taking const pointer
101085 0 : const SgOmpPartialClause* isSgOmpPartialClause ( const SgNode* inputDerivedClassPointer )
101086 : {
101087 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101088 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101089 : // So to fix this we return NULL directly when the input is NULL and avoid the
101090 : // dynamic_cast in this case. This is likely a performance improvement as well.
101091 : // return dynamic_cast<const SgOmpPartialClause*>(inputDerivedClassPointer);
101092 : // Milind Chabbi (8/28/2013): isSgOmpPartialClause uses table-driven castability instead of c++ default dynamic_cast
101093 : // this improves the running time performance by 10-20%.
101094 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpPartialClause*>(inputDerivedClassPointer);
101095 0 : return IS_SgOmpPartialClause_FAST_MACRO(inputDerivedClassPointer);
101096 : }
101097 :
101098 :
101099 :
101100 : /* #line 101101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101101 :
101102 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101103 :
101104 : /**
101105 : \brief Generated destructor
101106 :
101107 : This destructor is automatically generated (by ROSETTA). This destructor
101108 : only frees memory of data members associated with the parts of the current IR node which
101109 : are NOT traversed. Those data members that are part of a traversal can be freed using
101110 : a traversal (calling this destructor on all children in a post-order traversal). Such
101111 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
101112 :
101113 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
101114 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
101115 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
101116 :
101117 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
101118 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
101119 : pointers are not yet implemented to call delete on eash pointer in the container.
101120 : (This could be done by derivation from the STL containers to define containers that
101121 : automatically deleted their members.)
101122 :
101123 : */
101124 0 : SgOmpPartialClause::~SgOmpPartialClause () {
101125 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
101126 :
101127 :
101128 :
101129 : }
101130 :
101131 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101132 0 : }
101133 :
101134 :
101135 : /* #line 101136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101136 :
101137 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
101138 :
101139 : // Generated constructor
101140 0 : SgOmpPartialClause::SgOmpPartialClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
101141 0 : : SgOmpExpressionClause(startOfConstruct, expression)
101142 : {
101143 : #ifdef DEBUG
101144 : // printf ("In SgOmpPartialClause::SgOmpPartialClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
101145 : #endif
101146 : #if 0
101147 : // debugging information!
101148 : printf ("In SgOmpPartialClause::SgOmpPartialClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
101149 : #endif
101150 :
101151 :
101152 :
101153 : #if 0
101154 : // DQ (7/30/2014): Call a virtual function.
101155 : std::string s = this->class_name();
101156 : #endif
101157 :
101158 : // Test the variant virtual function
101159 : // assert(OmpPartialTag == variant());
101160 0 : assert(OmpPartialTag == this->variant());
101161 0 : ROSE_ASSERT(OmpPartialTag == (int)(this->variantT()));
101162 0 : post_construction_initialization();
101163 :
101164 : // Test the isSgOmpPartialClause() function since it has been problematic
101165 0 : assert(isSgOmpPartialClause(this) != NULL);
101166 0 : }
101167 :
101168 : // Generated constructor (all data members)
101169 :
101170 : /* #line 101171 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101171 :
101172 :
101173 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101174 :
101175 :
101176 : // ********************************************************
101177 : // member functions common across all array grammar objects
101178 : // ********************************************************
101179 :
101180 :
101181 :
101182 : /* #line 101183 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101183 :
101184 :
101185 :
101186 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101187 :
101188 : // ********************************************************
101189 : // member functions specific to each node in the grammar
101190 : // ********************************************************
101191 :
101192 :
101193 : /* #line 101194 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101194 :
101195 : // Start of memberFunctionString
101196 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
101197 :
101198 : // *** COMMON CODE SECTION BEGINS HERE ***
101199 :
101200 : #if 0
101201 : int
101202 : SgOmpSizesClause::getVariant() const
101203 : {
101204 : // This function is used in ROSE while "variant()" is used in SAGE
101205 : assert(this != NULL);
101206 : return variant();
101207 : }
101208 : #endif
101209 :
101210 : // This function is used in ROSE in treeTraversal code
101211 : // eventually replaces getVariant() and variant()
101212 : // though after variant() has been removed for a while we will
101213 : // want to change the name of variantT() back to variant()
101214 : // (since the "T" was ment to stand for temporary).
101215 : // When this happens the variantT() will be depricated.
101216 : VariantT
101217 0 : SgOmpSizesClause::variantT() const
101218 : {
101219 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
101220 0 : ROSE_ASSERT(this != NULL);
101221 0 : return V_SgOmpSizesClause;
101222 : }
101223 :
101224 : #if 0
101225 : int
101226 : SgOmpSizesClause::variant() const
101227 : {
101228 : // This function is used in SAGE
101229 : ROSE_ASSERT(this != NULL);
101230 : return OmpSizesTag;
101231 : }
101232 : #endif
101233 :
101234 : ROSE_DLL_API const char*
101235 0 : SgOmpSizesClause::sage_class_name() const
101236 : {
101237 0 : ROSE_ASSERT(this != NULL);
101238 0 : return "SgOmpSizesClause";
101239 : }
101240 :
101241 : std::string
101242 0 : SgOmpSizesClause::class_name() const
101243 : {
101244 0 : ROSE_ASSERT(this != NULL);
101245 0 : return "SgOmpSizesClause";
101246 : }
101247 :
101248 : // DQ (11/26/2005): Support for visitor pattern mechanims
101249 : // (inferior to ROSE traversal mechanism, experimental).
101250 : void
101251 0 : SgOmpSizesClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
101252 : {
101253 0 : ROSE_ASSERT(this != NULL);
101254 0 : visitor.visit(this);
101255 0 : }
101256 :
101257 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
101258 0 : void SgOmpSizesClause::accept (ROSE_VisitorPattern & visitor) {
101259 0 : ROSE_ASSERT(this != NULL);
101260 0 : visitor.visit(this);
101261 0 : }
101262 :
101263 : SgOmpSizesClause*
101264 0 : SgOmpSizesClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
101265 : {
101266 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
101267 : // This function is currently only supported for the AST used the represent Binary executables.
101268 : if (0 /* isSgAsmNode(this) != NULL */)
101269 : {
101270 : // Support for regex specification.
101271 : std::string prefixCode = "REGEX:";
101272 : addNewAttribute(prefixCode + s,a);
101273 : }
101274 : #endif
101275 :
101276 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
101277 0 : return this;
101278 : }
101279 :
101280 : // *** COMMON CODE SECTION ENDS HERE ***
101281 :
101282 :
101283 : // End of memberFunctionString
101284 : // Start of memberFunctionString
101285 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
101286 :
101287 :
101288 : #if 0
101289 : //! Error checking support
101290 : /*! Verifies the following:
101291 : - working getVariant() member function
101292 : - calls base class's error() member function
101293 : Every class has one of these functions.
101294 : */
101295 : bool
101296 : SgOmpSizesClause::error()
101297 : {
101298 : // Put error checking here
101299 :
101300 : ROSE_ASSERT (this != NULL);
101301 : if (getVariant() != OmpSizesTag)
101302 : {
101303 : printf ("Error in SgOmpSizesClause::error(): SgOmpSizesClause object has a %s variant \n",
101304 : Cxx_GrammarTerminalNames[getVariant()].name);
101305 : // printf ("Error in SgOmpSizesClause::error() \n");
101306 : ROSE_ABORT();
101307 : }
101308 :
101309 : ROSE_ASSERT (getVariant() == OmpSizesTag);
101310 : return SgOmpExpressionClause::error();
101311 : }
101312 : #endif
101313 :
101314 :
101315 :
101316 : // End of memberFunctionString
101317 :
101318 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
101319 :
101320 0 : SgOmpSizesClause* isSgOmpSizesClause ( SgNode* inputDerivedClassPointer )
101321 : {
101322 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101323 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101324 : // So to fix this we return NULL directly when the input is NULL and avoid the
101325 : // dynamic_cast in this case. This is likely a performance improvement as well.
101326 : // return dynamic_cast<SgOmpSizesClause*>(inputDerivedClassPointer);
101327 : // Milind Chabbi (8/28/2013): isSgOmpSizesClause uses table-driven castability instead of c++ default dynamic_cast
101328 : // this improves the running time performance by 10-20%.
101329 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSizesClause*>(inputDerivedClassPointer);
101330 0 : return IS_SgOmpSizesClause_FAST_MACRO(inputDerivedClassPointer);
101331 : }
101332 :
101333 : // DQ (11/8/2003): Added version of functions taking const pointer
101334 0 : const SgOmpSizesClause* isSgOmpSizesClause ( const SgNode* inputDerivedClassPointer )
101335 : {
101336 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101337 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101338 : // So to fix this we return NULL directly when the input is NULL and avoid the
101339 : // dynamic_cast in this case. This is likely a performance improvement as well.
101340 : // return dynamic_cast<const SgOmpSizesClause*>(inputDerivedClassPointer);
101341 : // Milind Chabbi (8/28/2013): isSgOmpSizesClause uses table-driven castability instead of c++ default dynamic_cast
101342 : // this improves the running time performance by 10-20%.
101343 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSizesClause*>(inputDerivedClassPointer);
101344 0 : return IS_SgOmpSizesClause_FAST_MACRO(inputDerivedClassPointer);
101345 : }
101346 :
101347 :
101348 :
101349 : /* #line 101350 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101350 :
101351 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101352 :
101353 : /**
101354 : \brief Generated destructor
101355 :
101356 : This destructor is automatically generated (by ROSETTA). This destructor
101357 : only frees memory of data members associated with the parts of the current IR node which
101358 : are NOT traversed. Those data members that are part of a traversal can be freed using
101359 : a traversal (calling this destructor on all children in a post-order traversal). Such
101360 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
101361 :
101362 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
101363 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
101364 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
101365 :
101366 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
101367 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
101368 : pointers are not yet implemented to call delete on eash pointer in the container.
101369 : (This could be done by derivation from the STL containers to define containers that
101370 : automatically deleted their members.)
101371 :
101372 : */
101373 0 : SgOmpSizesClause::~SgOmpSizesClause () {
101374 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
101375 :
101376 :
101377 :
101378 : }
101379 :
101380 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101381 0 : }
101382 :
101383 :
101384 : /* #line 101385 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101385 :
101386 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
101387 :
101388 : // Generated constructor
101389 0 : SgOmpSizesClause::SgOmpSizesClause ( Sg_File_Info* startOfConstruct, SgExpression* expression )
101390 0 : : SgOmpExpressionClause(startOfConstruct, expression)
101391 : {
101392 : #ifdef DEBUG
101393 : // printf ("In SgOmpSizesClause::SgOmpSizesClause (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
101394 : #endif
101395 : #if 0
101396 : // debugging information!
101397 : printf ("In SgOmpSizesClause::SgOmpSizesClause (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
101398 : #endif
101399 :
101400 :
101401 :
101402 : #if 0
101403 : // DQ (7/30/2014): Call a virtual function.
101404 : std::string s = this->class_name();
101405 : #endif
101406 :
101407 : // Test the variant virtual function
101408 : // assert(OmpSizesTag == variant());
101409 0 : assert(OmpSizesTag == this->variant());
101410 0 : ROSE_ASSERT(OmpSizesTag == (int)(this->variantT()));
101411 0 : post_construction_initialization();
101412 :
101413 : // Test the isSgOmpSizesClause() function since it has been problematic
101414 0 : assert(isSgOmpSizesClause(this) != NULL);
101415 0 : }
101416 :
101417 : // Generated constructor (all data members)
101418 :
101419 : /* #line 101420 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101420 :
101421 :
101422 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101423 :
101424 :
101425 : // ********************************************************
101426 : // member functions common across all array grammar objects
101427 : // ********************************************************
101428 :
101429 :
101430 :
101431 : /* #line 101432 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101432 :
101433 :
101434 :
101435 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101436 :
101437 : // ********************************************************
101438 : // member functions specific to each node in the grammar
101439 : // ********************************************************
101440 :
101441 :
101442 : /* #line 101443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101443 :
101444 : // Start of memberFunctionString
101445 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
101446 :
101447 : // *** COMMON CODE SECTION BEGINS HERE ***
101448 :
101449 : #if 0
101450 : int
101451 : SgOmpInbranchClause::getVariant() const
101452 : {
101453 : // This function is used in ROSE while "variant()" is used in SAGE
101454 : assert(this != NULL);
101455 : return variant();
101456 : }
101457 : #endif
101458 :
101459 : // This function is used in ROSE in treeTraversal code
101460 : // eventually replaces getVariant() and variant()
101461 : // though after variant() has been removed for a while we will
101462 : // want to change the name of variantT() back to variant()
101463 : // (since the "T" was ment to stand for temporary).
101464 : // When this happens the variantT() will be depricated.
101465 : VariantT
101466 0 : SgOmpInbranchClause::variantT() const
101467 : {
101468 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
101469 0 : ROSE_ASSERT(this != NULL);
101470 0 : return V_SgOmpInbranchClause;
101471 : }
101472 :
101473 : #if 0
101474 : int
101475 : SgOmpInbranchClause::variant() const
101476 : {
101477 : // This function is used in SAGE
101478 : ROSE_ASSERT(this != NULL);
101479 : return OmpInbranchClauseTag;
101480 : }
101481 : #endif
101482 :
101483 : ROSE_DLL_API const char*
101484 0 : SgOmpInbranchClause::sage_class_name() const
101485 : {
101486 0 : ROSE_ASSERT(this != NULL);
101487 0 : return "SgOmpInbranchClause";
101488 : }
101489 :
101490 : std::string
101491 0 : SgOmpInbranchClause::class_name() const
101492 : {
101493 0 : ROSE_ASSERT(this != NULL);
101494 0 : return "SgOmpInbranchClause";
101495 : }
101496 :
101497 : // DQ (11/26/2005): Support for visitor pattern mechanims
101498 : // (inferior to ROSE traversal mechanism, experimental).
101499 : void
101500 0 : SgOmpInbranchClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
101501 : {
101502 0 : ROSE_ASSERT(this != NULL);
101503 0 : visitor.visit(this);
101504 0 : }
101505 :
101506 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
101507 0 : void SgOmpInbranchClause::accept (ROSE_VisitorPattern & visitor) {
101508 0 : ROSE_ASSERT(this != NULL);
101509 0 : visitor.visit(this);
101510 0 : }
101511 :
101512 : SgOmpInbranchClause*
101513 0 : SgOmpInbranchClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
101514 : {
101515 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
101516 : // This function is currently only supported for the AST used the represent Binary executables.
101517 : if (0 /* isSgAsmNode(this) != NULL */)
101518 : {
101519 : // Support for regex specification.
101520 : std::string prefixCode = "REGEX:";
101521 : addNewAttribute(prefixCode + s,a);
101522 : }
101523 : #endif
101524 :
101525 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
101526 0 : return this;
101527 : }
101528 :
101529 : // *** COMMON CODE SECTION ENDS HERE ***
101530 :
101531 :
101532 : // End of memberFunctionString
101533 : // Start of memberFunctionString
101534 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
101535 :
101536 :
101537 : #if 0
101538 : //! Error checking support
101539 : /*! Verifies the following:
101540 : - working getVariant() member function
101541 : - calls base class's error() member function
101542 : Every class has one of these functions.
101543 : */
101544 : bool
101545 : SgOmpInbranchClause::error()
101546 : {
101547 : // Put error checking here
101548 :
101549 : ROSE_ASSERT (this != NULL);
101550 : if (getVariant() != OmpInbranchClauseTag)
101551 : {
101552 : printf ("Error in SgOmpInbranchClause::error(): SgOmpInbranchClause object has a %s variant \n",
101553 : Cxx_GrammarTerminalNames[getVariant()].name);
101554 : // printf ("Error in SgOmpInbranchClause::error() \n");
101555 : ROSE_ABORT();
101556 : }
101557 :
101558 : ROSE_ASSERT (getVariant() == OmpInbranchClauseTag);
101559 : return SgOmpClause::error();
101560 : }
101561 : #endif
101562 :
101563 :
101564 :
101565 : // End of memberFunctionString
101566 :
101567 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
101568 :
101569 0 : SgOmpInbranchClause* isSgOmpInbranchClause ( SgNode* inputDerivedClassPointer )
101570 : {
101571 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101572 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101573 : // So to fix this we return NULL directly when the input is NULL and avoid the
101574 : // dynamic_cast in this case. This is likely a performance improvement as well.
101575 : // return dynamic_cast<SgOmpInbranchClause*>(inputDerivedClassPointer);
101576 : // Milind Chabbi (8/28/2013): isSgOmpInbranchClause uses table-driven castability instead of c++ default dynamic_cast
101577 : // this improves the running time performance by 10-20%.
101578 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpInbranchClause*>(inputDerivedClassPointer);
101579 0 : return IS_SgOmpInbranchClause_FAST_MACRO(inputDerivedClassPointer);
101580 : }
101581 :
101582 : // DQ (11/8/2003): Added version of functions taking const pointer
101583 0 : const SgOmpInbranchClause* isSgOmpInbranchClause ( const SgNode* inputDerivedClassPointer )
101584 : {
101585 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101586 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101587 : // So to fix this we return NULL directly when the input is NULL and avoid the
101588 : // dynamic_cast in this case. This is likely a performance improvement as well.
101589 : // return dynamic_cast<const SgOmpInbranchClause*>(inputDerivedClassPointer);
101590 : // Milind Chabbi (8/28/2013): isSgOmpInbranchClause uses table-driven castability instead of c++ default dynamic_cast
101591 : // this improves the running time performance by 10-20%.
101592 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpInbranchClause*>(inputDerivedClassPointer);
101593 0 : return IS_SgOmpInbranchClause_FAST_MACRO(inputDerivedClassPointer);
101594 : }
101595 :
101596 :
101597 :
101598 : /* #line 101599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101599 :
101600 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101601 :
101602 : /**
101603 : \brief Generated destructor
101604 :
101605 : This destructor is automatically generated (by ROSETTA). This destructor
101606 : only frees memory of data members associated with the parts of the current IR node which
101607 : are NOT traversed. Those data members that are part of a traversal can be freed using
101608 : a traversal (calling this destructor on all children in a post-order traversal). Such
101609 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
101610 :
101611 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
101612 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
101613 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
101614 :
101615 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
101616 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
101617 : pointers are not yet implemented to call delete on eash pointer in the container.
101618 : (This could be done by derivation from the STL containers to define containers that
101619 : automatically deleted their members.)
101620 :
101621 : */
101622 0 : SgOmpInbranchClause::~SgOmpInbranchClause () {
101623 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
101624 :
101625 :
101626 :
101627 : }
101628 :
101629 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101630 0 : }
101631 :
101632 :
101633 : /* #line 101634 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101634 :
101635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
101636 :
101637 : // Generated constructor
101638 0 : SgOmpInbranchClause::SgOmpInbranchClause ( Sg_File_Info* startOfConstruct )
101639 0 : : SgOmpClause(startOfConstruct)
101640 : {
101641 : #ifdef DEBUG
101642 : // printf ("In SgOmpInbranchClause::SgOmpInbranchClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
101643 : #endif
101644 : #if 0
101645 : // debugging information!
101646 : printf ("In SgOmpInbranchClause::SgOmpInbranchClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
101647 : #endif
101648 :
101649 :
101650 :
101651 : #if 0
101652 : // DQ (7/30/2014): Call a virtual function.
101653 : std::string s = this->class_name();
101654 : #endif
101655 :
101656 : // Test the variant virtual function
101657 : // assert(OmpInbranchClauseTag == variant());
101658 0 : assert(OmpInbranchClauseTag == this->variant());
101659 0 : ROSE_ASSERT(OmpInbranchClauseTag == (int)(this->variantT()));
101660 0 : post_construction_initialization();
101661 :
101662 : // Test the isSgOmpInbranchClause() function since it has been problematic
101663 0 : assert(isSgOmpInbranchClause(this) != NULL);
101664 0 : }
101665 :
101666 : // Generated constructor (all data members)
101667 :
101668 : /* #line 101669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101669 :
101670 :
101671 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101672 :
101673 :
101674 : // ********************************************************
101675 : // member functions common across all array grammar objects
101676 : // ********************************************************
101677 :
101678 :
101679 :
101680 : /* #line 101681 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101681 :
101682 :
101683 :
101684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101685 :
101686 : // ********************************************************
101687 : // member functions specific to each node in the grammar
101688 : // ********************************************************
101689 :
101690 :
101691 : /* #line 101692 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101692 :
101693 : // Start of memberFunctionString
101694 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
101695 :
101696 : // *** COMMON CODE SECTION BEGINS HERE ***
101697 :
101698 : #if 0
101699 : int
101700 : SgOmpNotinbranchClause::getVariant() const
101701 : {
101702 : // This function is used in ROSE while "variant()" is used in SAGE
101703 : assert(this != NULL);
101704 : return variant();
101705 : }
101706 : #endif
101707 :
101708 : // This function is used in ROSE in treeTraversal code
101709 : // eventually replaces getVariant() and variant()
101710 : // though after variant() has been removed for a while we will
101711 : // want to change the name of variantT() back to variant()
101712 : // (since the "T" was ment to stand for temporary).
101713 : // When this happens the variantT() will be depricated.
101714 : VariantT
101715 0 : SgOmpNotinbranchClause::variantT() const
101716 : {
101717 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
101718 0 : ROSE_ASSERT(this != NULL);
101719 0 : return V_SgOmpNotinbranchClause;
101720 : }
101721 :
101722 : #if 0
101723 : int
101724 : SgOmpNotinbranchClause::variant() const
101725 : {
101726 : // This function is used in SAGE
101727 : ROSE_ASSERT(this != NULL);
101728 : return OmpNotinbranchClauseTag;
101729 : }
101730 : #endif
101731 :
101732 : ROSE_DLL_API const char*
101733 0 : SgOmpNotinbranchClause::sage_class_name() const
101734 : {
101735 0 : ROSE_ASSERT(this != NULL);
101736 0 : return "SgOmpNotinbranchClause";
101737 : }
101738 :
101739 : std::string
101740 0 : SgOmpNotinbranchClause::class_name() const
101741 : {
101742 0 : ROSE_ASSERT(this != NULL);
101743 0 : return "SgOmpNotinbranchClause";
101744 : }
101745 :
101746 : // DQ (11/26/2005): Support for visitor pattern mechanims
101747 : // (inferior to ROSE traversal mechanism, experimental).
101748 : void
101749 0 : SgOmpNotinbranchClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
101750 : {
101751 0 : ROSE_ASSERT(this != NULL);
101752 0 : visitor.visit(this);
101753 0 : }
101754 :
101755 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
101756 0 : void SgOmpNotinbranchClause::accept (ROSE_VisitorPattern & visitor) {
101757 0 : ROSE_ASSERT(this != NULL);
101758 0 : visitor.visit(this);
101759 0 : }
101760 :
101761 : SgOmpNotinbranchClause*
101762 0 : SgOmpNotinbranchClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
101763 : {
101764 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
101765 : // This function is currently only supported for the AST used the represent Binary executables.
101766 : if (0 /* isSgAsmNode(this) != NULL */)
101767 : {
101768 : // Support for regex specification.
101769 : std::string prefixCode = "REGEX:";
101770 : addNewAttribute(prefixCode + s,a);
101771 : }
101772 : #endif
101773 :
101774 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
101775 0 : return this;
101776 : }
101777 :
101778 : // *** COMMON CODE SECTION ENDS HERE ***
101779 :
101780 :
101781 : // End of memberFunctionString
101782 : // Start of memberFunctionString
101783 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
101784 :
101785 :
101786 : #if 0
101787 : //! Error checking support
101788 : /*! Verifies the following:
101789 : - working getVariant() member function
101790 : - calls base class's error() member function
101791 : Every class has one of these functions.
101792 : */
101793 : bool
101794 : SgOmpNotinbranchClause::error()
101795 : {
101796 : // Put error checking here
101797 :
101798 : ROSE_ASSERT (this != NULL);
101799 : if (getVariant() != OmpNotinbranchClauseTag)
101800 : {
101801 : printf ("Error in SgOmpNotinbranchClause::error(): SgOmpNotinbranchClause object has a %s variant \n",
101802 : Cxx_GrammarTerminalNames[getVariant()].name);
101803 : // printf ("Error in SgOmpNotinbranchClause::error() \n");
101804 : ROSE_ABORT();
101805 : }
101806 :
101807 : ROSE_ASSERT (getVariant() == OmpNotinbranchClauseTag);
101808 : return SgOmpClause::error();
101809 : }
101810 : #endif
101811 :
101812 :
101813 :
101814 : // End of memberFunctionString
101815 :
101816 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
101817 :
101818 0 : SgOmpNotinbranchClause* isSgOmpNotinbranchClause ( SgNode* inputDerivedClassPointer )
101819 : {
101820 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101821 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101822 : // So to fix this we return NULL directly when the input is NULL and avoid the
101823 : // dynamic_cast in this case. This is likely a performance improvement as well.
101824 : // return dynamic_cast<SgOmpNotinbranchClause*>(inputDerivedClassPointer);
101825 : // Milind Chabbi (8/28/2013): isSgOmpNotinbranchClause uses table-driven castability instead of c++ default dynamic_cast
101826 : // this improves the running time performance by 10-20%.
101827 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpNotinbranchClause*>(inputDerivedClassPointer);
101828 0 : return IS_SgOmpNotinbranchClause_FAST_MACRO(inputDerivedClassPointer);
101829 : }
101830 :
101831 : // DQ (11/8/2003): Added version of functions taking const pointer
101832 0 : const SgOmpNotinbranchClause* isSgOmpNotinbranchClause ( const SgNode* inputDerivedClassPointer )
101833 : {
101834 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
101835 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
101836 : // So to fix this we return NULL directly when the input is NULL and avoid the
101837 : // dynamic_cast in this case. This is likely a performance improvement as well.
101838 : // return dynamic_cast<const SgOmpNotinbranchClause*>(inputDerivedClassPointer);
101839 : // Milind Chabbi (8/28/2013): isSgOmpNotinbranchClause uses table-driven castability instead of c++ default dynamic_cast
101840 : // this improves the running time performance by 10-20%.
101841 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpNotinbranchClause*>(inputDerivedClassPointer);
101842 0 : return IS_SgOmpNotinbranchClause_FAST_MACRO(inputDerivedClassPointer);
101843 : }
101844 :
101845 :
101846 :
101847 : /* #line 101848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101848 :
101849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101850 :
101851 : /**
101852 : \brief Generated destructor
101853 :
101854 : This destructor is automatically generated (by ROSETTA). This destructor
101855 : only frees memory of data members associated with the parts of the current IR node which
101856 : are NOT traversed. Those data members that are part of a traversal can be freed using
101857 : a traversal (calling this destructor on all children in a post-order traversal). Such
101858 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
101859 :
101860 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
101861 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
101862 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
101863 :
101864 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
101865 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
101866 : pointers are not yet implemented to call delete on eash pointer in the container.
101867 : (This could be done by derivation from the STL containers to define containers that
101868 : automatically deleted their members.)
101869 :
101870 : */
101871 0 : SgOmpNotinbranchClause::~SgOmpNotinbranchClause () {
101872 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
101873 :
101874 :
101875 :
101876 : }
101877 :
101878 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
101879 0 : }
101880 :
101881 :
101882 : /* #line 101883 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101883 :
101884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
101885 :
101886 : // Generated constructor
101887 0 : SgOmpNotinbranchClause::SgOmpNotinbranchClause ( Sg_File_Info* startOfConstruct )
101888 0 : : SgOmpClause(startOfConstruct)
101889 : {
101890 : #ifdef DEBUG
101891 : // printf ("In SgOmpNotinbranchClause::SgOmpNotinbranchClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
101892 : #endif
101893 : #if 0
101894 : // debugging information!
101895 : printf ("In SgOmpNotinbranchClause::SgOmpNotinbranchClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
101896 : #endif
101897 :
101898 :
101899 :
101900 : #if 0
101901 : // DQ (7/30/2014): Call a virtual function.
101902 : std::string s = this->class_name();
101903 : #endif
101904 :
101905 : // Test the variant virtual function
101906 : // assert(OmpNotinbranchClauseTag == variant());
101907 0 : assert(OmpNotinbranchClauseTag == this->variant());
101908 0 : ROSE_ASSERT(OmpNotinbranchClauseTag == (int)(this->variantT()));
101909 0 : post_construction_initialization();
101910 :
101911 : // Test the isSgOmpNotinbranchClause() function since it has been problematic
101912 0 : assert(isSgOmpNotinbranchClause(this) != NULL);
101913 0 : }
101914 :
101915 : // Generated constructor (all data members)
101916 :
101917 : /* #line 101918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101918 :
101919 :
101920 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101921 :
101922 :
101923 : // ********************************************************
101924 : // member functions common across all array grammar objects
101925 : // ********************************************************
101926 :
101927 :
101928 :
101929 : /* #line 101930 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101930 :
101931 :
101932 :
101933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
101934 :
101935 : // ********************************************************
101936 : // member functions specific to each node in the grammar
101937 : // ********************************************************
101938 :
101939 :
101940 : /* #line 101941 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
101941 :
101942 : // Start of memberFunctionString
101943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
101944 :
101945 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
101946 :
101947 : SgOmpClause::omp_defaultmap_behavior_enum
101948 1 : SgOmpDefaultmapClause::get_behavior () const
101949 : {
101950 1 : ROSE_ASSERT (this != NULL);
101951 :
101952 : #if 0
101953 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
101954 : // used to trigger marking transformations for the token-based unparsing.
101955 : printf ("SgOmpDefaultmapClause::get_behavior = %p = %s \n",this,this->class_name().c_str());
101956 : #endif
101957 :
101958 1 : return p_behavior;
101959 : }
101960 :
101961 : void
101962 0 : SgOmpDefaultmapClause::set_behavior ( SgOmpClause::omp_defaultmap_behavior_enum behavior )
101963 : {
101964 0 : ROSE_ASSERT (this != NULL);
101965 :
101966 : #if 0
101967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
101968 : // used to trigger marking transformations for the token-based unparsing.
101969 : printf ("SgOmpDefaultmapClause::set_behavior = %p = %s \n",this,this->class_name().c_str());
101970 : #endif
101971 :
101972 0 : set_isModified(true);
101973 :
101974 0 : p_behavior = behavior;
101975 0 : }
101976 :
101977 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
101978 :
101979 :
101980 : // End of memberFunctionString
101981 : // Start of memberFunctionString
101982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
101983 :
101984 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
101985 :
101986 : SgOmpClause::omp_defaultmap_category_enum
101987 1 : SgOmpDefaultmapClause::get_category () const
101988 : {
101989 1 : ROSE_ASSERT (this != NULL);
101990 :
101991 : #if 0
101992 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
101993 : // used to trigger marking transformations for the token-based unparsing.
101994 : printf ("SgOmpDefaultmapClause::get_category = %p = %s \n",this,this->class_name().c_str());
101995 : #endif
101996 :
101997 1 : return p_category;
101998 : }
101999 :
102000 : void
102001 0 : SgOmpDefaultmapClause::set_category ( SgOmpClause::omp_defaultmap_category_enum category )
102002 : {
102003 0 : ROSE_ASSERT (this != NULL);
102004 :
102005 : #if 0
102006 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102007 : // used to trigger marking transformations for the token-based unparsing.
102008 : printf ("SgOmpDefaultmapClause::set_category = %p = %s \n",this,this->class_name().c_str());
102009 : #endif
102010 :
102011 0 : set_isModified(true);
102012 :
102013 0 : p_category = category;
102014 0 : }
102015 :
102016 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
102017 :
102018 :
102019 : // End of memberFunctionString
102020 : // Start of memberFunctionString
102021 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
102022 :
102023 : // *** COMMON CODE SECTION BEGINS HERE ***
102024 :
102025 : #if 0
102026 : int
102027 : SgOmpDefaultmapClause::getVariant() const
102028 : {
102029 : // This function is used in ROSE while "variant()" is used in SAGE
102030 : assert(this != NULL);
102031 : return variant();
102032 : }
102033 : #endif
102034 :
102035 : // This function is used in ROSE in treeTraversal code
102036 : // eventually replaces getVariant() and variant()
102037 : // though after variant() has been removed for a while we will
102038 : // want to change the name of variantT() back to variant()
102039 : // (since the "T" was ment to stand for temporary).
102040 : // When this happens the variantT() will be depricated.
102041 : VariantT
102042 54 : SgOmpDefaultmapClause::variantT() const
102043 : {
102044 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
102045 54 : ROSE_ASSERT(this != NULL);
102046 54 : return V_SgOmpDefaultmapClause;
102047 : }
102048 :
102049 : #if 0
102050 : int
102051 : SgOmpDefaultmapClause::variant() const
102052 : {
102053 : // This function is used in SAGE
102054 : ROSE_ASSERT(this != NULL);
102055 : return OmpDefaultmapClauseTag;
102056 : }
102057 : #endif
102058 :
102059 : ROSE_DLL_API const char*
102060 0 : SgOmpDefaultmapClause::sage_class_name() const
102061 : {
102062 0 : ROSE_ASSERT(this != NULL);
102063 0 : return "SgOmpDefaultmapClause";
102064 : }
102065 :
102066 : std::string
102067 1 : SgOmpDefaultmapClause::class_name() const
102068 : {
102069 1 : ROSE_ASSERT(this != NULL);
102070 1 : return "SgOmpDefaultmapClause";
102071 : }
102072 :
102073 : // DQ (11/26/2005): Support for visitor pattern mechanims
102074 : // (inferior to ROSE traversal mechanism, experimental).
102075 : void
102076 0 : SgOmpDefaultmapClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
102077 : {
102078 0 : ROSE_ASSERT(this != NULL);
102079 0 : visitor.visit(this);
102080 0 : }
102081 :
102082 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
102083 0 : void SgOmpDefaultmapClause::accept (ROSE_VisitorPattern & visitor) {
102084 0 : ROSE_ASSERT(this != NULL);
102085 0 : visitor.visit(this);
102086 0 : }
102087 :
102088 : SgOmpDefaultmapClause*
102089 0 : SgOmpDefaultmapClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
102090 : {
102091 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
102092 : // This function is currently only supported for the AST used the represent Binary executables.
102093 : if (0 /* isSgAsmNode(this) != NULL */)
102094 : {
102095 : // Support for regex specification.
102096 : std::string prefixCode = "REGEX:";
102097 : addNewAttribute(prefixCode + s,a);
102098 : }
102099 : #endif
102100 :
102101 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
102102 0 : return this;
102103 : }
102104 :
102105 : // *** COMMON CODE SECTION ENDS HERE ***
102106 :
102107 :
102108 : // End of memberFunctionString
102109 : // Start of memberFunctionString
102110 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
102111 :
102112 :
102113 : #if 0
102114 : //! Error checking support
102115 : /*! Verifies the following:
102116 : - working getVariant() member function
102117 : - calls base class's error() member function
102118 : Every class has one of these functions.
102119 : */
102120 : bool
102121 : SgOmpDefaultmapClause::error()
102122 : {
102123 : // Put error checking here
102124 :
102125 : ROSE_ASSERT (this != NULL);
102126 : if (getVariant() != OmpDefaultmapClauseTag)
102127 : {
102128 : printf ("Error in SgOmpDefaultmapClause::error(): SgOmpDefaultmapClause object has a %s variant \n",
102129 : Cxx_GrammarTerminalNames[getVariant()].name);
102130 : // printf ("Error in SgOmpDefaultmapClause::error() \n");
102131 : ROSE_ABORT();
102132 : }
102133 :
102134 : ROSE_ASSERT (getVariant() == OmpDefaultmapClauseTag);
102135 : return SgOmpClause::error();
102136 : }
102137 : #endif
102138 :
102139 :
102140 :
102141 : // End of memberFunctionString
102142 :
102143 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
102144 :
102145 3 : SgOmpDefaultmapClause* isSgOmpDefaultmapClause ( SgNode* inputDerivedClassPointer )
102146 : {
102147 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
102148 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
102149 : // So to fix this we return NULL directly when the input is NULL and avoid the
102150 : // dynamic_cast in this case. This is likely a performance improvement as well.
102151 : // return dynamic_cast<SgOmpDefaultmapClause*>(inputDerivedClassPointer);
102152 : // Milind Chabbi (8/28/2013): isSgOmpDefaultmapClause uses table-driven castability instead of c++ default dynamic_cast
102153 : // this improves the running time performance by 10-20%.
102154 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDefaultmapClause*>(inputDerivedClassPointer);
102155 3 : return IS_SgOmpDefaultmapClause_FAST_MACRO(inputDerivedClassPointer);
102156 : }
102157 :
102158 : // DQ (11/8/2003): Added version of functions taking const pointer
102159 0 : const SgOmpDefaultmapClause* isSgOmpDefaultmapClause ( const SgNode* inputDerivedClassPointer )
102160 : {
102161 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
102162 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
102163 : // So to fix this we return NULL directly when the input is NULL and avoid the
102164 : // dynamic_cast in this case. This is likely a performance improvement as well.
102165 : // return dynamic_cast<const SgOmpDefaultmapClause*>(inputDerivedClassPointer);
102166 : // Milind Chabbi (8/28/2013): isSgOmpDefaultmapClause uses table-driven castability instead of c++ default dynamic_cast
102167 : // this improves the running time performance by 10-20%.
102168 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDefaultmapClause*>(inputDerivedClassPointer);
102169 0 : return IS_SgOmpDefaultmapClause_FAST_MACRO(inputDerivedClassPointer);
102170 : }
102171 :
102172 :
102173 :
102174 : /* #line 102175 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102175 :
102176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
102177 :
102178 : /**
102179 : \brief Generated destructor
102180 :
102181 : This destructor is automatically generated (by ROSETTA). This destructor
102182 : only frees memory of data members associated with the parts of the current IR node which
102183 : are NOT traversed. Those data members that are part of a traversal can be freed using
102184 : a traversal (calling this destructor on all children in a post-order traversal). Such
102185 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
102186 :
102187 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
102188 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
102189 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
102190 :
102191 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
102192 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
102193 : pointers are not yet implemented to call delete on eash pointer in the container.
102194 : (This could be done by derivation from the STL containers to define containers that
102195 : automatically deleted their members.)
102196 :
102197 : */
102198 0 : SgOmpDefaultmapClause::~SgOmpDefaultmapClause () {
102199 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
102200 :
102201 :
102202 : // case: not a listType for behavior
102203 0 : p_behavior =e_omp_defaultmap_behavior_unspecified; // non list case
102204 : // case: not a listType for category
102205 0 : p_category =e_omp_defaultmap_category_unspecified; // non list case
102206 :
102207 : }
102208 :
102209 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
102210 0 : }
102211 :
102212 :
102213 : /* #line 102214 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102214 :
102215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
102216 :
102217 : // Generated constructor
102218 0 : SgOmpDefaultmapClause::SgOmpDefaultmapClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_defaultmap_behavior_enum behavior, SgOmpClause::omp_defaultmap_category_enum category )
102219 0 : : SgOmpClause(startOfConstruct)
102220 : {
102221 : #ifdef DEBUG
102222 : // printf ("In SgOmpDefaultmapClause::SgOmpDefaultmapClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_defaultmap_behavior_enum behavior, SgOmpClause::omp_defaultmap_category_enum category) sage_class_name() = %s \n",sage_class_name());
102223 : #endif
102224 : #if 0
102225 : // debugging information!
102226 : printf ("In SgOmpDefaultmapClause::SgOmpDefaultmapClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_defaultmap_behavior_enum behavior, SgOmpClause::omp_defaultmap_category_enum category): this = %p = %s \n",this,this->class_name().c_str());
102227 : #endif
102228 :
102229 0 : p_behavior = behavior;
102230 0 : p_category = category;
102231 :
102232 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
102233 :
102234 : #if 0
102235 : // DQ (7/30/2014): Call a virtual function.
102236 : std::string s = this->class_name();
102237 : #endif
102238 :
102239 : // Test the variant virtual function
102240 : // assert(OmpDefaultmapClauseTag == variant());
102241 0 : assert(OmpDefaultmapClauseTag == this->variant());
102242 0 : ROSE_ASSERT(OmpDefaultmapClauseTag == (int)(this->variantT()));
102243 0 : post_construction_initialization();
102244 :
102245 : // Test the isSgOmpDefaultmapClause() function since it has been problematic
102246 0 : assert(isSgOmpDefaultmapClause(this) != NULL);
102247 0 : }
102248 :
102249 : // Generated constructor (all data members)
102250 :
102251 : /* #line 102252 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102252 :
102253 :
102254 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
102255 :
102256 :
102257 : // ********************************************************
102258 : // member functions common across all array grammar objects
102259 : // ********************************************************
102260 :
102261 :
102262 :
102263 : /* #line 102264 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102264 :
102265 :
102266 :
102267 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
102268 :
102269 : // ********************************************************
102270 : // member functions specific to each node in the grammar
102271 : // ********************************************************
102272 :
102273 :
102274 : /* #line 102275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102275 :
102276 : // Start of memberFunctionString
102277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
102278 :
102279 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
102280 :
102281 : SgOmpClause::omp_atomic_default_mem_order_kind_enum
102282 1 : SgOmpAtomicDefaultMemOrderClause::get_kind () const
102283 : {
102284 1 : ROSE_ASSERT (this != NULL);
102285 :
102286 : #if 0
102287 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102288 : // used to trigger marking transformations for the token-based unparsing.
102289 : printf ("SgOmpAtomicDefaultMemOrderClause::get_kind = %p = %s \n",this,this->class_name().c_str());
102290 : #endif
102291 :
102292 1 : return p_kind;
102293 : }
102294 :
102295 : void
102296 0 : SgOmpAtomicDefaultMemOrderClause::set_kind ( SgOmpClause::omp_atomic_default_mem_order_kind_enum kind )
102297 : {
102298 0 : ROSE_ASSERT (this != NULL);
102299 :
102300 : #if 0
102301 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102302 : // used to trigger marking transformations for the token-based unparsing.
102303 : printf ("SgOmpAtomicDefaultMemOrderClause::set_kind = %p = %s \n",this,this->class_name().c_str());
102304 : #endif
102305 :
102306 0 : set_isModified(true);
102307 :
102308 0 : p_kind = kind;
102309 0 : }
102310 :
102311 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
102312 :
102313 :
102314 : // End of memberFunctionString
102315 : // Start of memberFunctionString
102316 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
102317 :
102318 : // *** COMMON CODE SECTION BEGINS HERE ***
102319 :
102320 : #if 0
102321 : int
102322 : SgOmpAtomicDefaultMemOrderClause::getVariant() const
102323 : {
102324 : // This function is used in ROSE while "variant()" is used in SAGE
102325 : assert(this != NULL);
102326 : return variant();
102327 : }
102328 : #endif
102329 :
102330 : // This function is used in ROSE in treeTraversal code
102331 : // eventually replaces getVariant() and variant()
102332 : // though after variant() has been removed for a while we will
102333 : // want to change the name of variantT() back to variant()
102334 : // (since the "T" was ment to stand for temporary).
102335 : // When this happens the variantT() will be depricated.
102336 : VariantT
102337 53 : SgOmpAtomicDefaultMemOrderClause::variantT() const
102338 : {
102339 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
102340 53 : ROSE_ASSERT(this != NULL);
102341 53 : return V_SgOmpAtomicDefaultMemOrderClause;
102342 : }
102343 :
102344 : #if 0
102345 : int
102346 : SgOmpAtomicDefaultMemOrderClause::variant() const
102347 : {
102348 : // This function is used in SAGE
102349 : ROSE_ASSERT(this != NULL);
102350 : return OmpAtomicDefaultMemOrderClauseTag;
102351 : }
102352 : #endif
102353 :
102354 : ROSE_DLL_API const char*
102355 0 : SgOmpAtomicDefaultMemOrderClause::sage_class_name() const
102356 : {
102357 0 : ROSE_ASSERT(this != NULL);
102358 0 : return "SgOmpAtomicDefaultMemOrderClause";
102359 : }
102360 :
102361 : std::string
102362 1 : SgOmpAtomicDefaultMemOrderClause::class_name() const
102363 : {
102364 1 : ROSE_ASSERT(this != NULL);
102365 1 : return "SgOmpAtomicDefaultMemOrderClause";
102366 : }
102367 :
102368 : // DQ (11/26/2005): Support for visitor pattern mechanims
102369 : // (inferior to ROSE traversal mechanism, experimental).
102370 : void
102371 0 : SgOmpAtomicDefaultMemOrderClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
102372 : {
102373 0 : ROSE_ASSERT(this != NULL);
102374 0 : visitor.visit(this);
102375 0 : }
102376 :
102377 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
102378 0 : void SgOmpAtomicDefaultMemOrderClause::accept (ROSE_VisitorPattern & visitor) {
102379 0 : ROSE_ASSERT(this != NULL);
102380 0 : visitor.visit(this);
102381 0 : }
102382 :
102383 : SgOmpAtomicDefaultMemOrderClause*
102384 0 : SgOmpAtomicDefaultMemOrderClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
102385 : {
102386 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
102387 : // This function is currently only supported for the AST used the represent Binary executables.
102388 : if (0 /* isSgAsmNode(this) != NULL */)
102389 : {
102390 : // Support for regex specification.
102391 : std::string prefixCode = "REGEX:";
102392 : addNewAttribute(prefixCode + s,a);
102393 : }
102394 : #endif
102395 :
102396 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
102397 0 : return this;
102398 : }
102399 :
102400 : // *** COMMON CODE SECTION ENDS HERE ***
102401 :
102402 :
102403 : // End of memberFunctionString
102404 : // Start of memberFunctionString
102405 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
102406 :
102407 :
102408 : #if 0
102409 : //! Error checking support
102410 : /*! Verifies the following:
102411 : - working getVariant() member function
102412 : - calls base class's error() member function
102413 : Every class has one of these functions.
102414 : */
102415 : bool
102416 : SgOmpAtomicDefaultMemOrderClause::error()
102417 : {
102418 : // Put error checking here
102419 :
102420 : ROSE_ASSERT (this != NULL);
102421 : if (getVariant() != OmpAtomicDefaultMemOrderClauseTag)
102422 : {
102423 : printf ("Error in SgOmpAtomicDefaultMemOrderClause::error(): SgOmpAtomicDefaultMemOrderClause object has a %s variant \n",
102424 : Cxx_GrammarTerminalNames[getVariant()].name);
102425 : // printf ("Error in SgOmpAtomicDefaultMemOrderClause::error() \n");
102426 : ROSE_ABORT();
102427 : }
102428 :
102429 : ROSE_ASSERT (getVariant() == OmpAtomicDefaultMemOrderClauseTag);
102430 : return SgOmpClause::error();
102431 : }
102432 : #endif
102433 :
102434 :
102435 :
102436 : // End of memberFunctionString
102437 :
102438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
102439 :
102440 3 : SgOmpAtomicDefaultMemOrderClause* isSgOmpAtomicDefaultMemOrderClause ( SgNode* inputDerivedClassPointer )
102441 : {
102442 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
102443 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
102444 : // So to fix this we return NULL directly when the input is NULL and avoid the
102445 : // dynamic_cast in this case. This is likely a performance improvement as well.
102446 : // return dynamic_cast<SgOmpAtomicDefaultMemOrderClause*>(inputDerivedClassPointer);
102447 : // Milind Chabbi (8/28/2013): isSgOmpAtomicDefaultMemOrderClause uses table-driven castability instead of c++ default dynamic_cast
102448 : // this improves the running time performance by 10-20%.
102449 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAtomicDefaultMemOrderClause*>(inputDerivedClassPointer);
102450 3 : return IS_SgOmpAtomicDefaultMemOrderClause_FAST_MACRO(inputDerivedClassPointer);
102451 : }
102452 :
102453 : // DQ (11/8/2003): Added version of functions taking const pointer
102454 0 : const SgOmpAtomicDefaultMemOrderClause* isSgOmpAtomicDefaultMemOrderClause ( const SgNode* inputDerivedClassPointer )
102455 : {
102456 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
102457 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
102458 : // So to fix this we return NULL directly when the input is NULL and avoid the
102459 : // dynamic_cast in this case. This is likely a performance improvement as well.
102460 : // return dynamic_cast<const SgOmpAtomicDefaultMemOrderClause*>(inputDerivedClassPointer);
102461 : // Milind Chabbi (8/28/2013): isSgOmpAtomicDefaultMemOrderClause uses table-driven castability instead of c++ default dynamic_cast
102462 : // this improves the running time performance by 10-20%.
102463 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAtomicDefaultMemOrderClause*>(inputDerivedClassPointer);
102464 0 : return IS_SgOmpAtomicDefaultMemOrderClause_FAST_MACRO(inputDerivedClassPointer);
102465 : }
102466 :
102467 :
102468 :
102469 : /* #line 102470 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102470 :
102471 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
102472 :
102473 : /**
102474 : \brief Generated destructor
102475 :
102476 : This destructor is automatically generated (by ROSETTA). This destructor
102477 : only frees memory of data members associated with the parts of the current IR node which
102478 : are NOT traversed. Those data members that are part of a traversal can be freed using
102479 : a traversal (calling this destructor on all children in a post-order traversal). Such
102480 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
102481 :
102482 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
102483 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
102484 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
102485 :
102486 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
102487 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
102488 : pointers are not yet implemented to call delete on eash pointer in the container.
102489 : (This could be done by derivation from the STL containers to define containers that
102490 : automatically deleted their members.)
102491 :
102492 : */
102493 0 : SgOmpAtomicDefaultMemOrderClause::~SgOmpAtomicDefaultMemOrderClause () {
102494 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
102495 :
102496 :
102497 : // case: not a listType for kind
102498 0 : p_kind =e_omp_atomic_default_mem_order_kind_unspecified; // non list case
102499 :
102500 : }
102501 :
102502 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
102503 0 : }
102504 :
102505 :
102506 : /* #line 102507 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102507 :
102508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
102509 :
102510 : // Generated constructor
102511 0 : SgOmpAtomicDefaultMemOrderClause::SgOmpAtomicDefaultMemOrderClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_atomic_default_mem_order_kind_enum kind )
102512 0 : : SgOmpClause(startOfConstruct)
102513 : {
102514 : #ifdef DEBUG
102515 : // printf ("In SgOmpAtomicDefaultMemOrderClause::SgOmpAtomicDefaultMemOrderClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_atomic_default_mem_order_kind_enum kind) sage_class_name() = %s \n",sage_class_name());
102516 : #endif
102517 : #if 0
102518 : // debugging information!
102519 : printf ("In SgOmpAtomicDefaultMemOrderClause::SgOmpAtomicDefaultMemOrderClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_atomic_default_mem_order_kind_enum kind): this = %p = %s \n",this,this->class_name().c_str());
102520 : #endif
102521 :
102522 0 : p_kind = kind;
102523 :
102524 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
102525 :
102526 : #if 0
102527 : // DQ (7/30/2014): Call a virtual function.
102528 : std::string s = this->class_name();
102529 : #endif
102530 :
102531 : // Test the variant virtual function
102532 : // assert(OmpAtomicDefaultMemOrderClauseTag == variant());
102533 0 : assert(OmpAtomicDefaultMemOrderClauseTag == this->variant());
102534 0 : ROSE_ASSERT(OmpAtomicDefaultMemOrderClauseTag == (int)(this->variantT()));
102535 0 : post_construction_initialization();
102536 :
102537 : // Test the isSgOmpAtomicDefaultMemOrderClause() function since it has been problematic
102538 0 : assert(isSgOmpAtomicDefaultMemOrderClause(this) != NULL);
102539 0 : }
102540 :
102541 : // Generated constructor (all data members)
102542 :
102543 : /* #line 102544 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102544 :
102545 :
102546 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
102547 :
102548 :
102549 : // ********************************************************
102550 : // member functions common across all array grammar objects
102551 : // ********************************************************
102552 :
102553 :
102554 :
102555 : /* #line 102556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102556 :
102557 :
102558 :
102559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
102560 :
102561 : // ********************************************************
102562 : // member functions specific to each node in the grammar
102563 : // ********************************************************
102564 :
102565 :
102566 : /* #line 102567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102567 :
102568 : // Start of memberFunctionString
102569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
102570 :
102571 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
102572 :
102573 : SgExpression*
102574 2 : SgOmpExtImplementationDefinedRequirementClause::get_implementation_defined_requirement () const
102575 : {
102576 2 : ROSE_ASSERT (this != NULL);
102577 :
102578 : #if 0
102579 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102580 : // used to trigger marking transformations for the token-based unparsing.
102581 : printf ("SgOmpExtImplementationDefinedRequirementClause::get_implementation_defined_requirement = %p = %s \n",this,this->class_name().c_str());
102582 : #endif
102583 :
102584 2 : return p_implementation_defined_requirement;
102585 : }
102586 :
102587 : void
102588 0 : SgOmpExtImplementationDefinedRequirementClause::set_implementation_defined_requirement ( SgExpression* implementation_defined_requirement )
102589 : {
102590 0 : ROSE_ASSERT (this != NULL);
102591 :
102592 : #if 0
102593 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102594 : // used to trigger marking transformations for the token-based unparsing.
102595 : printf ("SgOmpExtImplementationDefinedRequirementClause::set_implementation_defined_requirement = %p = %s \n",this,this->class_name().c_str());
102596 : #endif
102597 :
102598 0 : set_isModified(true);
102599 :
102600 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
102601 : if (p_implementation_defined_requirement != NULL && implementation_defined_requirement != NULL && p_implementation_defined_requirement != implementation_defined_requirement)
102602 : {
102603 : printf ("Warning: implementation_defined_requirement = %p overwriting valid pointer p_implementation_defined_requirement = %p \n",implementation_defined_requirement,p_implementation_defined_requirement);
102604 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
102605 : printf ("Error fails assertion (p_implementation_defined_requirement != NULL && implementation_defined_requirement != NULL && p_implementation_defined_requirement != implementation_defined_requirement) is false\n");
102606 : ROSE_ASSERT(false);
102607 : #endif
102608 : }
102609 : #endif
102610 0 : p_implementation_defined_requirement = implementation_defined_requirement;
102611 0 : }
102612 :
102613 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
102614 :
102615 :
102616 : // End of memberFunctionString
102617 : // Start of memberFunctionString
102618 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
102619 :
102620 : // *** COMMON CODE SECTION BEGINS HERE ***
102621 :
102622 : #if 0
102623 : int
102624 : SgOmpExtImplementationDefinedRequirementClause::getVariant() const
102625 : {
102626 : // This function is used in ROSE while "variant()" is used in SAGE
102627 : assert(this != NULL);
102628 : return variant();
102629 : }
102630 : #endif
102631 :
102632 : // This function is used in ROSE in treeTraversal code
102633 : // eventually replaces getVariant() and variant()
102634 : // though after variant() has been removed for a while we will
102635 : // want to change the name of variantT() back to variant()
102636 : // (since the "T" was ment to stand for temporary).
102637 : // When this happens the variantT() will be depricated.
102638 : VariantT
102639 104 : SgOmpExtImplementationDefinedRequirementClause::variantT() const
102640 : {
102641 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
102642 104 : ROSE_ASSERT(this != NULL);
102643 104 : return V_SgOmpExtImplementationDefinedRequirementClause;
102644 : }
102645 :
102646 : #if 0
102647 : int
102648 : SgOmpExtImplementationDefinedRequirementClause::variant() const
102649 : {
102650 : // This function is used in SAGE
102651 : ROSE_ASSERT(this != NULL);
102652 : return OmpExtImplementationDefinedRequirementClauseTag;
102653 : }
102654 : #endif
102655 :
102656 : ROSE_DLL_API const char*
102657 0 : SgOmpExtImplementationDefinedRequirementClause::sage_class_name() const
102658 : {
102659 0 : ROSE_ASSERT(this != NULL);
102660 0 : return "SgOmpExtImplementationDefinedRequirementClause";
102661 : }
102662 :
102663 : std::string
102664 2 : SgOmpExtImplementationDefinedRequirementClause::class_name() const
102665 : {
102666 2 : ROSE_ASSERT(this != NULL);
102667 2 : return "SgOmpExtImplementationDefinedRequirementClause";
102668 : }
102669 :
102670 : // DQ (11/26/2005): Support for visitor pattern mechanims
102671 : // (inferior to ROSE traversal mechanism, experimental).
102672 : void
102673 0 : SgOmpExtImplementationDefinedRequirementClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
102674 : {
102675 0 : ROSE_ASSERT(this != NULL);
102676 0 : visitor.visit(this);
102677 0 : }
102678 :
102679 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
102680 0 : void SgOmpExtImplementationDefinedRequirementClause::accept (ROSE_VisitorPattern & visitor) {
102681 0 : ROSE_ASSERT(this != NULL);
102682 0 : visitor.visit(this);
102683 0 : }
102684 :
102685 : SgOmpExtImplementationDefinedRequirementClause*
102686 0 : SgOmpExtImplementationDefinedRequirementClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
102687 : {
102688 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
102689 : // This function is currently only supported for the AST used the represent Binary executables.
102690 : if (0 /* isSgAsmNode(this) != NULL */)
102691 : {
102692 : // Support for regex specification.
102693 : std::string prefixCode = "REGEX:";
102694 : addNewAttribute(prefixCode + s,a);
102695 : }
102696 : #endif
102697 :
102698 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
102699 0 : return this;
102700 : }
102701 :
102702 : // *** COMMON CODE SECTION ENDS HERE ***
102703 :
102704 :
102705 : // End of memberFunctionString
102706 : // Start of memberFunctionString
102707 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
102708 :
102709 :
102710 : #if 0
102711 : //! Error checking support
102712 : /*! Verifies the following:
102713 : - working getVariant() member function
102714 : - calls base class's error() member function
102715 : Every class has one of these functions.
102716 : */
102717 : bool
102718 : SgOmpExtImplementationDefinedRequirementClause::error()
102719 : {
102720 : // Put error checking here
102721 :
102722 : ROSE_ASSERT (this != NULL);
102723 : if (getVariant() != OmpExtImplementationDefinedRequirementClauseTag)
102724 : {
102725 : printf ("Error in SgOmpExtImplementationDefinedRequirementClause::error(): SgOmpExtImplementationDefinedRequirementClause object has a %s variant \n",
102726 : Cxx_GrammarTerminalNames[getVariant()].name);
102727 : // printf ("Error in SgOmpExtImplementationDefinedRequirementClause::error() \n");
102728 : ROSE_ABORT();
102729 : }
102730 :
102731 : ROSE_ASSERT (getVariant() == OmpExtImplementationDefinedRequirementClauseTag);
102732 : return SgOmpClause::error();
102733 : }
102734 : #endif
102735 :
102736 :
102737 :
102738 : // End of memberFunctionString
102739 :
102740 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
102741 :
102742 4 : SgOmpExtImplementationDefinedRequirementClause* isSgOmpExtImplementationDefinedRequirementClause ( SgNode* inputDerivedClassPointer )
102743 : {
102744 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
102745 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
102746 : // So to fix this we return NULL directly when the input is NULL and avoid the
102747 : // dynamic_cast in this case. This is likely a performance improvement as well.
102748 : // return dynamic_cast<SgOmpExtImplementationDefinedRequirementClause*>(inputDerivedClassPointer);
102749 : // Milind Chabbi (8/28/2013): isSgOmpExtImplementationDefinedRequirementClause uses table-driven castability instead of c++ default dynamic_cast
102750 : // this improves the running time performance by 10-20%.
102751 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpExtImplementationDefinedRequirementClause*>(inputDerivedClassPointer);
102752 4 : return IS_SgOmpExtImplementationDefinedRequirementClause_FAST_MACRO(inputDerivedClassPointer);
102753 : }
102754 :
102755 : // DQ (11/8/2003): Added version of functions taking const pointer
102756 0 : const SgOmpExtImplementationDefinedRequirementClause* isSgOmpExtImplementationDefinedRequirementClause ( const SgNode* inputDerivedClassPointer )
102757 : {
102758 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
102759 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
102760 : // So to fix this we return NULL directly when the input is NULL and avoid the
102761 : // dynamic_cast in this case. This is likely a performance improvement as well.
102762 : // return dynamic_cast<const SgOmpExtImplementationDefinedRequirementClause*>(inputDerivedClassPointer);
102763 : // Milind Chabbi (8/28/2013): isSgOmpExtImplementationDefinedRequirementClause uses table-driven castability instead of c++ default dynamic_cast
102764 : // this improves the running time performance by 10-20%.
102765 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpExtImplementationDefinedRequirementClause*>(inputDerivedClassPointer);
102766 0 : return IS_SgOmpExtImplementationDefinedRequirementClause_FAST_MACRO(inputDerivedClassPointer);
102767 : }
102768 :
102769 :
102770 :
102771 : /* #line 102772 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102772 :
102773 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
102774 :
102775 : /**
102776 : \brief Generated destructor
102777 :
102778 : This destructor is automatically generated (by ROSETTA). This destructor
102779 : only frees memory of data members associated with the parts of the current IR node which
102780 : are NOT traversed. Those data members that are part of a traversal can be freed using
102781 : a traversal (calling this destructor on all children in a post-order traversal). Such
102782 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
102783 :
102784 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
102785 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
102786 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
102787 :
102788 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
102789 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
102790 : pointers are not yet implemented to call delete on eash pointer in the container.
102791 : (This could be done by derivation from the STL containers to define containers that
102792 : automatically deleted their members.)
102793 :
102794 : */
102795 0 : SgOmpExtImplementationDefinedRequirementClause::~SgOmpExtImplementationDefinedRequirementClause () {
102796 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
102797 :
102798 :
102799 : // case: not a listType for implementation_defined_requirement
102800 0 : p_implementation_defined_requirement = NULL; // non list case
102801 :
102802 : }
102803 :
102804 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
102805 0 : }
102806 :
102807 :
102808 : /* #line 102809 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102809 :
102810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
102811 :
102812 : // Generated constructor
102813 0 : SgOmpExtImplementationDefinedRequirementClause::SgOmpExtImplementationDefinedRequirementClause ( Sg_File_Info* startOfConstruct, SgExpression* implementation_defined_requirement )
102814 0 : : SgOmpClause(startOfConstruct)
102815 : {
102816 : #ifdef DEBUG
102817 : // printf ("In SgOmpExtImplementationDefinedRequirementClause::SgOmpExtImplementationDefinedRequirementClause (Sg_File_Info* startOfConstruct, SgExpression* implementation_defined_requirement) sage_class_name() = %s \n",sage_class_name());
102818 : #endif
102819 : #if 0
102820 : // debugging information!
102821 : printf ("In SgOmpExtImplementationDefinedRequirementClause::SgOmpExtImplementationDefinedRequirementClause (Sg_File_Info* startOfConstruct, SgExpression* implementation_defined_requirement): this = %p = %s \n",this,this->class_name().c_str());
102822 : #endif
102823 :
102824 0 : p_implementation_defined_requirement = implementation_defined_requirement;
102825 :
102826 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
102827 :
102828 : #if 0
102829 : // DQ (7/30/2014): Call a virtual function.
102830 : std::string s = this->class_name();
102831 : #endif
102832 :
102833 : // Test the variant virtual function
102834 : // assert(OmpExtImplementationDefinedRequirementClauseTag == variant());
102835 0 : assert(OmpExtImplementationDefinedRequirementClauseTag == this->variant());
102836 0 : ROSE_ASSERT(OmpExtImplementationDefinedRequirementClauseTag == (int)(this->variantT()));
102837 0 : post_construction_initialization();
102838 :
102839 : // Test the isSgOmpExtImplementationDefinedRequirementClause() function since it has been problematic
102840 0 : assert(isSgOmpExtImplementationDefinedRequirementClause(this) != NULL);
102841 0 : }
102842 :
102843 : // Generated constructor (all data members)
102844 :
102845 : /* #line 102846 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102846 :
102847 :
102848 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
102849 :
102850 :
102851 : // ********************************************************
102852 : // member functions common across all array grammar objects
102853 : // ********************************************************
102854 :
102855 :
102856 :
102857 : /* #line 102858 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102858 :
102859 :
102860 :
102861 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
102862 :
102863 : // ********************************************************
102864 : // member functions specific to each node in the grammar
102865 : // ********************************************************
102866 :
102867 :
102868 : /* #line 102869 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
102869 :
102870 : // Start of memberFunctionString
102871 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
102872 :
102873 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
102874 :
102875 : SgOmpClause::omp_uses_allocators_allocator_enum
102876 2 : SgOmpUsesAllocatorsDefination::get_allocator () const
102877 : {
102878 2 : ROSE_ASSERT (this != NULL);
102879 :
102880 : #if 0
102881 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102882 : // used to trigger marking transformations for the token-based unparsing.
102883 : printf ("SgOmpUsesAllocatorsDefination::get_allocator = %p = %s \n",this,this->class_name().c_str());
102884 : #endif
102885 :
102886 2 : return p_allocator;
102887 : }
102888 :
102889 : void
102890 2 : SgOmpUsesAllocatorsDefination::set_allocator ( SgOmpClause::omp_uses_allocators_allocator_enum allocator )
102891 : {
102892 2 : ROSE_ASSERT (this != NULL);
102893 :
102894 : #if 0
102895 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102896 : // used to trigger marking transformations for the token-based unparsing.
102897 : printf ("SgOmpUsesAllocatorsDefination::set_allocator = %p = %s \n",this,this->class_name().c_str());
102898 : #endif
102899 :
102900 2 : set_isModified(true);
102901 :
102902 2 : p_allocator = allocator;
102903 2 : }
102904 :
102905 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
102906 :
102907 :
102908 : // End of memberFunctionString
102909 : // Start of memberFunctionString
102910 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
102911 :
102912 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
102913 :
102914 : SgExpression*
102915 0 : SgOmpUsesAllocatorsDefination::get_user_defined_allocator () const
102916 : {
102917 0 : ROSE_ASSERT (this != NULL);
102918 :
102919 : #if 0
102920 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102921 : // used to trigger marking transformations for the token-based unparsing.
102922 : printf ("SgOmpUsesAllocatorsDefination::get_user_defined_allocator = %p = %s \n",this,this->class_name().c_str());
102923 : #endif
102924 :
102925 0 : return p_user_defined_allocator;
102926 : }
102927 :
102928 : void
102929 2 : SgOmpUsesAllocatorsDefination::set_user_defined_allocator ( SgExpression* user_defined_allocator )
102930 : {
102931 2 : ROSE_ASSERT (this != NULL);
102932 :
102933 : #if 0
102934 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102935 : // used to trigger marking transformations for the token-based unparsing.
102936 : printf ("SgOmpUsesAllocatorsDefination::set_user_defined_allocator = %p = %s \n",this,this->class_name().c_str());
102937 : #endif
102938 :
102939 2 : set_isModified(true);
102940 :
102941 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
102942 : if (p_user_defined_allocator != NULL && user_defined_allocator != NULL && p_user_defined_allocator != user_defined_allocator)
102943 : {
102944 : printf ("Warning: user_defined_allocator = %p overwriting valid pointer p_user_defined_allocator = %p \n",user_defined_allocator,p_user_defined_allocator);
102945 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
102946 : printf ("Error fails assertion (p_user_defined_allocator != NULL && user_defined_allocator != NULL && p_user_defined_allocator != user_defined_allocator) is false\n");
102947 : ROSE_ASSERT(false);
102948 : #endif
102949 : }
102950 : #endif
102951 2 : p_user_defined_allocator = user_defined_allocator;
102952 2 : }
102953 :
102954 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
102955 :
102956 :
102957 : // End of memberFunctionString
102958 : // Start of memberFunctionString
102959 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
102960 :
102961 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
102962 :
102963 : SgExpression*
102964 4 : SgOmpUsesAllocatorsDefination::get_allocator_traits_array () const
102965 : {
102966 4 : ROSE_ASSERT (this != NULL);
102967 :
102968 : #if 0
102969 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102970 : // used to trigger marking transformations for the token-based unparsing.
102971 : printf ("SgOmpUsesAllocatorsDefination::get_allocator_traits_array = %p = %s \n",this,this->class_name().c_str());
102972 : #endif
102973 :
102974 4 : return p_allocator_traits_array;
102975 : }
102976 :
102977 : void
102978 2 : SgOmpUsesAllocatorsDefination::set_allocator_traits_array ( SgExpression* allocator_traits_array )
102979 : {
102980 2 : ROSE_ASSERT (this != NULL);
102981 :
102982 : #if 0
102983 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
102984 : // used to trigger marking transformations for the token-based unparsing.
102985 : printf ("SgOmpUsesAllocatorsDefination::set_allocator_traits_array = %p = %s \n",this,this->class_name().c_str());
102986 : #endif
102987 :
102988 2 : set_isModified(true);
102989 :
102990 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
102991 : if (p_allocator_traits_array != NULL && allocator_traits_array != NULL && p_allocator_traits_array != allocator_traits_array)
102992 : {
102993 : printf ("Warning: allocator_traits_array = %p overwriting valid pointer p_allocator_traits_array = %p \n",allocator_traits_array,p_allocator_traits_array);
102994 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
102995 : printf ("Error fails assertion (p_allocator_traits_array != NULL && allocator_traits_array != NULL && p_allocator_traits_array != allocator_traits_array) is false\n");
102996 : ROSE_ASSERT(false);
102997 : #endif
102998 : }
102999 : #endif
103000 2 : p_allocator_traits_array = allocator_traits_array;
103001 2 : }
103002 :
103003 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
103004 :
103005 :
103006 : // End of memberFunctionString
103007 : // Start of memberFunctionString
103008 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
103009 :
103010 : // *** COMMON CODE SECTION BEGINS HERE ***
103011 :
103012 : #if 0
103013 : int
103014 : SgOmpUsesAllocatorsDefination::getVariant() const
103015 : {
103016 : // This function is used in ROSE while "variant()" is used in SAGE
103017 : assert(this != NULL);
103018 : return variant();
103019 : }
103020 : #endif
103021 :
103022 : // This function is used in ROSE in treeTraversal code
103023 : // eventually replaces getVariant() and variant()
103024 : // though after variant() has been removed for a while we will
103025 : // want to change the name of variantT() back to variant()
103026 : // (since the "T" was ment to stand for temporary).
103027 : // When this happens the variantT() will be depricated.
103028 : VariantT
103029 34 : SgOmpUsesAllocatorsDefination::variantT() const
103030 : {
103031 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
103032 34 : ROSE_ASSERT(this != NULL);
103033 34 : return V_SgOmpUsesAllocatorsDefination;
103034 : }
103035 :
103036 : #if 0
103037 : int
103038 : SgOmpUsesAllocatorsDefination::variant() const
103039 : {
103040 : // This function is used in SAGE
103041 : ROSE_ASSERT(this != NULL);
103042 : return OmpUsesAllocatorsDefinationTag;
103043 : }
103044 : #endif
103045 :
103046 : ROSE_DLL_API const char*
103047 0 : SgOmpUsesAllocatorsDefination::sage_class_name() const
103048 : {
103049 0 : ROSE_ASSERT(this != NULL);
103050 0 : return "SgOmpUsesAllocatorsDefination";
103051 : }
103052 :
103053 : std::string
103054 2 : SgOmpUsesAllocatorsDefination::class_name() const
103055 : {
103056 2 : ROSE_ASSERT(this != NULL);
103057 2 : return "SgOmpUsesAllocatorsDefination";
103058 : }
103059 :
103060 : // DQ (11/26/2005): Support for visitor pattern mechanims
103061 : // (inferior to ROSE traversal mechanism, experimental).
103062 : void
103063 0 : SgOmpUsesAllocatorsDefination::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
103064 : {
103065 0 : ROSE_ASSERT(this != NULL);
103066 0 : visitor.visit(this);
103067 0 : }
103068 :
103069 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
103070 0 : void SgOmpUsesAllocatorsDefination::accept (ROSE_VisitorPattern & visitor) {
103071 0 : ROSE_ASSERT(this != NULL);
103072 0 : visitor.visit(this);
103073 0 : }
103074 :
103075 : SgOmpUsesAllocatorsDefination*
103076 0 : SgOmpUsesAllocatorsDefination::addRegExpAttribute(std::string s, AstRegExAttribute* a)
103077 : {
103078 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
103079 : // This function is currently only supported for the AST used the represent Binary executables.
103080 : if (0 /* isSgAsmNode(this) != NULL */)
103081 : {
103082 : // Support for regex specification.
103083 : std::string prefixCode = "REGEX:";
103084 : addNewAttribute(prefixCode + s,a);
103085 : }
103086 : #endif
103087 :
103088 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
103089 0 : return this;
103090 : }
103091 :
103092 : // *** COMMON CODE SECTION ENDS HERE ***
103093 :
103094 :
103095 : // End of memberFunctionString
103096 : // Start of memberFunctionString
103097 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
103098 :
103099 :
103100 : #if 0
103101 : //! Error checking support
103102 : /*! Verifies the following:
103103 : - working getVariant() member function
103104 : - calls base class's error() member function
103105 : Every class has one of these functions.
103106 : */
103107 : bool
103108 : SgOmpUsesAllocatorsDefination::error()
103109 : {
103110 : // Put error checking here
103111 :
103112 : ROSE_ASSERT (this != NULL);
103113 : if (getVariant() != OmpUsesAllocatorsDefinationTag)
103114 : {
103115 : printf ("Error in SgOmpUsesAllocatorsDefination::error(): SgOmpUsesAllocatorsDefination object has a %s variant \n",
103116 : Cxx_GrammarTerminalNames[getVariant()].name);
103117 : // printf ("Error in SgOmpUsesAllocatorsDefination::error() \n");
103118 : ROSE_ABORT();
103119 : }
103120 :
103121 : ROSE_ASSERT (getVariant() == OmpUsesAllocatorsDefinationTag);
103122 : return SgOmpClause::error();
103123 : }
103124 : #endif
103125 :
103126 :
103127 :
103128 : // End of memberFunctionString
103129 :
103130 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
103131 :
103132 2 : SgOmpUsesAllocatorsDefination* isSgOmpUsesAllocatorsDefination ( SgNode* inputDerivedClassPointer )
103133 : {
103134 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103135 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103136 : // So to fix this we return NULL directly when the input is NULL and avoid the
103137 : // dynamic_cast in this case. This is likely a performance improvement as well.
103138 : // return dynamic_cast<SgOmpUsesAllocatorsDefination*>(inputDerivedClassPointer);
103139 : // Milind Chabbi (8/28/2013): isSgOmpUsesAllocatorsDefination uses table-driven castability instead of c++ default dynamic_cast
103140 : // this improves the running time performance by 10-20%.
103141 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUsesAllocatorsDefination*>(inputDerivedClassPointer);
103142 2 : return IS_SgOmpUsesAllocatorsDefination_FAST_MACRO(inputDerivedClassPointer);
103143 : }
103144 :
103145 : // DQ (11/8/2003): Added version of functions taking const pointer
103146 0 : const SgOmpUsesAllocatorsDefination* isSgOmpUsesAllocatorsDefination ( const SgNode* inputDerivedClassPointer )
103147 : {
103148 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103149 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103150 : // So to fix this we return NULL directly when the input is NULL and avoid the
103151 : // dynamic_cast in this case. This is likely a performance improvement as well.
103152 : // return dynamic_cast<const SgOmpUsesAllocatorsDefination*>(inputDerivedClassPointer);
103153 : // Milind Chabbi (8/28/2013): isSgOmpUsesAllocatorsDefination uses table-driven castability instead of c++ default dynamic_cast
103154 : // this improves the running time performance by 10-20%.
103155 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUsesAllocatorsDefination*>(inputDerivedClassPointer);
103156 0 : return IS_SgOmpUsesAllocatorsDefination_FAST_MACRO(inputDerivedClassPointer);
103157 : }
103158 :
103159 :
103160 :
103161 : /* #line 103162 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103162 :
103163 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103164 :
103165 : /**
103166 : \brief Generated destructor
103167 :
103168 : This destructor is automatically generated (by ROSETTA). This destructor
103169 : only frees memory of data members associated with the parts of the current IR node which
103170 : are NOT traversed. Those data members that are part of a traversal can be freed using
103171 : a traversal (calling this destructor on all children in a post-order traversal). Such
103172 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
103173 :
103174 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
103175 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
103176 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
103177 :
103178 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
103179 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
103180 : pointers are not yet implemented to call delete on eash pointer in the container.
103181 : (This could be done by derivation from the STL containers to define containers that
103182 : automatically deleted their members.)
103183 :
103184 : */
103185 0 : SgOmpUsesAllocatorsDefination::~SgOmpUsesAllocatorsDefination () {
103186 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
103187 :
103188 :
103189 : // case: not a listType for allocator
103190 0 : p_allocator =e_omp_uses_allocators_allocator_unknown; // non list case
103191 : // case: not a listType for user_defined_allocator
103192 0 : p_user_defined_allocator = NULL; // non list case
103193 :
103194 : }
103195 :
103196 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103197 0 : }
103198 :
103199 :
103200 : /* #line 103201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103201 :
103202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
103203 :
103204 : // Generated constructor
103205 0 : SgOmpUsesAllocatorsDefination::SgOmpUsesAllocatorsDefination ( Sg_File_Info* startOfConstruct )
103206 0 : : SgOmpClause(startOfConstruct)
103207 : {
103208 : #ifdef DEBUG
103209 : // printf ("In SgOmpUsesAllocatorsDefination::SgOmpUsesAllocatorsDefination (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
103210 : #endif
103211 : #if 0
103212 : // debugging information!
103213 : printf ("In SgOmpUsesAllocatorsDefination::SgOmpUsesAllocatorsDefination (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
103214 : #endif
103215 :
103216 0 : p_allocator =e_omp_uses_allocators_allocator_unknown;
103217 0 : p_user_defined_allocator = NULL;
103218 :
103219 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
103220 :
103221 : #if 0
103222 : // DQ (7/30/2014): Call a virtual function.
103223 : std::string s = this->class_name();
103224 : #endif
103225 :
103226 : // Test the variant virtual function
103227 : // assert(OmpUsesAllocatorsDefinationTag == variant());
103228 0 : assert(OmpUsesAllocatorsDefinationTag == this->variant());
103229 0 : ROSE_ASSERT(OmpUsesAllocatorsDefinationTag == (int)(this->variantT()));
103230 0 : post_construction_initialization();
103231 :
103232 : // Test the isSgOmpUsesAllocatorsDefination() function since it has been problematic
103233 0 : assert(isSgOmpUsesAllocatorsDefination(this) != NULL);
103234 0 : }
103235 :
103236 : // Generated constructor (all data members)
103237 :
103238 : /* #line 103239 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103239 :
103240 :
103241 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
103242 :
103243 :
103244 : // ********************************************************
103245 : // member functions common across all array grammar objects
103246 : // ********************************************************
103247 :
103248 :
103249 :
103250 : /* #line 103251 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103251 :
103252 :
103253 :
103254 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
103255 :
103256 : // ********************************************************
103257 : // member functions specific to each node in the grammar
103258 : // ********************************************************
103259 :
103260 :
103261 : /* #line 103262 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103262 :
103263 : // Start of memberFunctionString
103264 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
103265 :
103266 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
103267 :
103268 : SgExprListExp*
103269 2989 : SgOmpVariablesClause::get_variables () const
103270 : {
103271 2989 : ROSE_ASSERT (this != NULL);
103272 :
103273 : #if 0
103274 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
103275 : // used to trigger marking transformations for the token-based unparsing.
103276 : printf ("SgOmpVariablesClause::get_variables = %p = %s \n",this,this->class_name().c_str());
103277 : #endif
103278 :
103279 2989 : return p_variables;
103280 : }
103281 :
103282 : void
103283 0 : SgOmpVariablesClause::set_variables ( SgExprListExp* variables )
103284 : {
103285 0 : ROSE_ASSERT (this != NULL);
103286 :
103287 : #if 0
103288 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
103289 : // used to trigger marking transformations for the token-based unparsing.
103290 : printf ("SgOmpVariablesClause::set_variables = %p = %s \n",this,this->class_name().c_str());
103291 : #endif
103292 :
103293 0 : set_isModified(true);
103294 :
103295 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
103296 : if (p_variables != NULL && variables != NULL && p_variables != variables)
103297 : {
103298 : printf ("Warning: variables = %p overwriting valid pointer p_variables = %p \n",variables,p_variables);
103299 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
103300 : printf ("Error fails assertion (p_variables != NULL && variables != NULL && p_variables != variables) is false\n");
103301 : ROSE_ASSERT(false);
103302 : #endif
103303 : }
103304 : #endif
103305 0 : p_variables = variables;
103306 0 : }
103307 :
103308 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
103309 :
103310 :
103311 : // End of memberFunctionString
103312 : // Start of memberFunctionString
103313 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
103314 :
103315 : // *** COMMON CODE SECTION BEGINS HERE ***
103316 :
103317 : #if 0
103318 : int
103319 : SgOmpVariablesClause::getVariant() const
103320 : {
103321 : // This function is used in ROSE while "variant()" is used in SAGE
103322 : assert(this != NULL);
103323 : return variant();
103324 : }
103325 : #endif
103326 :
103327 : // This function is used in ROSE in treeTraversal code
103328 : // eventually replaces getVariant() and variant()
103329 : // though after variant() has been removed for a while we will
103330 : // want to change the name of variantT() back to variant()
103331 : // (since the "T" was ment to stand for temporary).
103332 : // When this happens the variantT() will be depricated.
103333 : VariantT
103334 1266 : SgOmpVariablesClause::variantT() const
103335 : {
103336 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
103337 1266 : ROSE_ASSERT(this != NULL);
103338 1266 : return V_SgOmpVariablesClause;
103339 : }
103340 :
103341 : #if 0
103342 : int
103343 : SgOmpVariablesClause::variant() const
103344 : {
103345 : // This function is used in SAGE
103346 : ROSE_ASSERT(this != NULL);
103347 : return OmpVariablesClauseTag;
103348 : }
103349 : #endif
103350 :
103351 : ROSE_DLL_API const char*
103352 0 : SgOmpVariablesClause::sage_class_name() const
103353 : {
103354 0 : ROSE_ASSERT(this != NULL);
103355 0 : return "SgOmpVariablesClause";
103356 : }
103357 :
103358 : std::string
103359 0 : SgOmpVariablesClause::class_name() const
103360 : {
103361 0 : ROSE_ASSERT(this != NULL);
103362 0 : return "SgOmpVariablesClause";
103363 : }
103364 :
103365 : // DQ (11/26/2005): Support for visitor pattern mechanims
103366 : // (inferior to ROSE traversal mechanism, experimental).
103367 : void
103368 0 : SgOmpVariablesClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
103369 : {
103370 0 : ROSE_ASSERT(this != NULL);
103371 0 : visitor.visit(this);
103372 0 : }
103373 :
103374 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
103375 0 : void SgOmpVariablesClause::accept (ROSE_VisitorPattern & visitor) {
103376 0 : ROSE_ASSERT(this != NULL);
103377 0 : visitor.visit(this);
103378 0 : }
103379 :
103380 : SgOmpVariablesClause*
103381 0 : SgOmpVariablesClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
103382 : {
103383 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
103384 : // This function is currently only supported for the AST used the represent Binary executables.
103385 : if (0 /* isSgAsmNode(this) != NULL */)
103386 : {
103387 : // Support for regex specification.
103388 : std::string prefixCode = "REGEX:";
103389 : addNewAttribute(prefixCode + s,a);
103390 : }
103391 : #endif
103392 :
103393 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
103394 0 : return this;
103395 : }
103396 :
103397 : // *** COMMON CODE SECTION ENDS HERE ***
103398 :
103399 :
103400 : // End of memberFunctionString
103401 : // Start of memberFunctionString
103402 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
103403 :
103404 :
103405 : #if 0
103406 : //! Error checking support
103407 : /*! Verifies the following:
103408 : - working getVariant() member function
103409 : - calls base class's error() member function
103410 : Every class has one of these functions.
103411 : */
103412 : bool
103413 : SgOmpVariablesClause::error()
103414 : {
103415 : // Put error checking here
103416 :
103417 : ROSE_ASSERT (this != NULL);
103418 : if (getVariant() != OmpVariablesClauseTag)
103419 : {
103420 : printf ("Error in SgOmpVariablesClause::error(): SgOmpVariablesClause object has a %s variant \n",
103421 : Cxx_GrammarTerminalNames[getVariant()].name);
103422 : // printf ("Error in SgOmpVariablesClause::error() \n");
103423 : ROSE_ABORT();
103424 : }
103425 :
103426 : ROSE_ASSERT (getVariant() == OmpVariablesClauseTag);
103427 : return SgOmpClause::error();
103428 : }
103429 : #endif
103430 :
103431 :
103432 :
103433 : // End of memberFunctionString
103434 :
103435 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
103436 :
103437 1266 : SgOmpVariablesClause* isSgOmpVariablesClause ( SgNode* inputDerivedClassPointer )
103438 : {
103439 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103440 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103441 : // So to fix this we return NULL directly when the input is NULL and avoid the
103442 : // dynamic_cast in this case. This is likely a performance improvement as well.
103443 : // return dynamic_cast<SgOmpVariablesClause*>(inputDerivedClassPointer);
103444 : // Milind Chabbi (8/28/2013): isSgOmpVariablesClause uses table-driven castability instead of c++ default dynamic_cast
103445 : // this improves the running time performance by 10-20%.
103446 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpVariablesClause*>(inputDerivedClassPointer);
103447 1266 : return IS_SgOmpVariablesClause_FAST_MACRO(inputDerivedClassPointer);
103448 : }
103449 :
103450 : // DQ (11/8/2003): Added version of functions taking const pointer
103451 0 : const SgOmpVariablesClause* isSgOmpVariablesClause ( const SgNode* inputDerivedClassPointer )
103452 : {
103453 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103454 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103455 : // So to fix this we return NULL directly when the input is NULL and avoid the
103456 : // dynamic_cast in this case. This is likely a performance improvement as well.
103457 : // return dynamic_cast<const SgOmpVariablesClause*>(inputDerivedClassPointer);
103458 : // Milind Chabbi (8/28/2013): isSgOmpVariablesClause uses table-driven castability instead of c++ default dynamic_cast
103459 : // this improves the running time performance by 10-20%.
103460 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpVariablesClause*>(inputDerivedClassPointer);
103461 0 : return IS_SgOmpVariablesClause_FAST_MACRO(inputDerivedClassPointer);
103462 : }
103463 :
103464 :
103465 :
103466 : /* #line 103467 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103467 :
103468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103469 :
103470 : /**
103471 : \brief Generated destructor
103472 :
103473 : This destructor is automatically generated (by ROSETTA). This destructor
103474 : only frees memory of data members associated with the parts of the current IR node which
103475 : are NOT traversed. Those data members that are part of a traversal can be freed using
103476 : a traversal (calling this destructor on all children in a post-order traversal). Such
103477 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
103478 :
103479 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
103480 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
103481 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
103482 :
103483 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
103484 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
103485 : pointers are not yet implemented to call delete on eash pointer in the container.
103486 : (This could be done by derivation from the STL containers to define containers that
103487 : automatically deleted their members.)
103488 :
103489 : */
103490 0 : SgOmpVariablesClause::~SgOmpVariablesClause () {
103491 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
103492 :
103493 :
103494 : // case: not a listType for variables
103495 0 : p_variables = NULL; // non list case
103496 :
103497 : }
103498 :
103499 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103500 0 : }
103501 :
103502 :
103503 : /* #line 103504 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103504 :
103505 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
103506 :
103507 : // Generated constructor
103508 0 : SgOmpVariablesClause::SgOmpVariablesClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
103509 0 : : SgOmpClause(startOfConstruct)
103510 : {
103511 : #ifdef DEBUG
103512 : // printf ("In SgOmpVariablesClause::SgOmpVariablesClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
103513 : #endif
103514 : #if 0
103515 : // debugging information!
103516 : printf ("In SgOmpVariablesClause::SgOmpVariablesClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
103517 : #endif
103518 :
103519 0 : p_variables = variables;
103520 :
103521 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
103522 :
103523 : #if 0
103524 : // DQ (7/30/2014): Call a virtual function.
103525 : std::string s = this->class_name();
103526 : #endif
103527 :
103528 : // Test the variant virtual function
103529 : // assert(OmpVariablesClauseTag == variant());
103530 0 : assert(OmpVariablesClauseTag == this->variant());
103531 0 : ROSE_ASSERT(OmpVariablesClauseTag == (int)(this->variantT()));
103532 0 : post_construction_initialization();
103533 :
103534 : // Test the isSgOmpVariablesClause() function since it has been problematic
103535 0 : assert(isSgOmpVariablesClause(this) != NULL);
103536 0 : }
103537 :
103538 : // Generated constructor (all data members)
103539 :
103540 : /* #line 103541 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103541 :
103542 :
103543 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
103544 :
103545 :
103546 : // ********************************************************
103547 : // member functions common across all array grammar objects
103548 : // ********************************************************
103549 :
103550 :
103551 :
103552 : /* #line 103553 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103553 :
103554 :
103555 :
103556 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
103557 :
103558 : // ********************************************************
103559 : // member functions specific to each node in the grammar
103560 : // ********************************************************
103561 :
103562 :
103563 : /* #line 103564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103564 :
103565 : // Start of memberFunctionString
103566 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
103567 :
103568 : // *** COMMON CODE SECTION BEGINS HERE ***
103569 :
103570 : #if 0
103571 : int
103572 : SgOmpCopyprivateClause::getVariant() const
103573 : {
103574 : // This function is used in ROSE while "variant()" is used in SAGE
103575 : assert(this != NULL);
103576 : return variant();
103577 : }
103578 : #endif
103579 :
103580 : // This function is used in ROSE in treeTraversal code
103581 : // eventually replaces getVariant() and variant()
103582 : // though after variant() has been removed for a while we will
103583 : // want to change the name of variantT() back to variant()
103584 : // (since the "T" was ment to stand for temporary).
103585 : // When this happens the variantT() will be depricated.
103586 : VariantT
103587 356 : SgOmpCopyprivateClause::variantT() const
103588 : {
103589 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
103590 356 : ROSE_ASSERT(this != NULL);
103591 356 : return V_SgOmpCopyprivateClause;
103592 : }
103593 :
103594 : #if 0
103595 : int
103596 : SgOmpCopyprivateClause::variant() const
103597 : {
103598 : // This function is used in SAGE
103599 : ROSE_ASSERT(this != NULL);
103600 : return OmpCopyprivateClauseTag;
103601 : }
103602 : #endif
103603 :
103604 : ROSE_DLL_API const char*
103605 0 : SgOmpCopyprivateClause::sage_class_name() const
103606 : {
103607 0 : ROSE_ASSERT(this != NULL);
103608 0 : return "SgOmpCopyprivateClause";
103609 : }
103610 :
103611 : std::string
103612 6 : SgOmpCopyprivateClause::class_name() const
103613 : {
103614 6 : ROSE_ASSERT(this != NULL);
103615 6 : return "SgOmpCopyprivateClause";
103616 : }
103617 :
103618 : // DQ (11/26/2005): Support for visitor pattern mechanims
103619 : // (inferior to ROSE traversal mechanism, experimental).
103620 : void
103621 0 : SgOmpCopyprivateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
103622 : {
103623 0 : ROSE_ASSERT(this != NULL);
103624 0 : visitor.visit(this);
103625 0 : }
103626 :
103627 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
103628 0 : void SgOmpCopyprivateClause::accept (ROSE_VisitorPattern & visitor) {
103629 0 : ROSE_ASSERT(this != NULL);
103630 0 : visitor.visit(this);
103631 0 : }
103632 :
103633 : SgOmpCopyprivateClause*
103634 0 : SgOmpCopyprivateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
103635 : {
103636 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
103637 : // This function is currently only supported for the AST used the represent Binary executables.
103638 : if (0 /* isSgAsmNode(this) != NULL */)
103639 : {
103640 : // Support for regex specification.
103641 : std::string prefixCode = "REGEX:";
103642 : addNewAttribute(prefixCode + s,a);
103643 : }
103644 : #endif
103645 :
103646 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
103647 0 : return this;
103648 : }
103649 :
103650 : // *** COMMON CODE SECTION ENDS HERE ***
103651 :
103652 :
103653 : // End of memberFunctionString
103654 : // Start of memberFunctionString
103655 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
103656 :
103657 :
103658 : #if 0
103659 : //! Error checking support
103660 : /*! Verifies the following:
103661 : - working getVariant() member function
103662 : - calls base class's error() member function
103663 : Every class has one of these functions.
103664 : */
103665 : bool
103666 : SgOmpCopyprivateClause::error()
103667 : {
103668 : // Put error checking here
103669 :
103670 : ROSE_ASSERT (this != NULL);
103671 : if (getVariant() != OmpCopyprivateClauseTag)
103672 : {
103673 : printf ("Error in SgOmpCopyprivateClause::error(): SgOmpCopyprivateClause object has a %s variant \n",
103674 : Cxx_GrammarTerminalNames[getVariant()].name);
103675 : // printf ("Error in SgOmpCopyprivateClause::error() \n");
103676 : ROSE_ABORT();
103677 : }
103678 :
103679 : ROSE_ASSERT (getVariant() == OmpCopyprivateClauseTag);
103680 : return SgOmpVariablesClause::error();
103681 : }
103682 : #endif
103683 :
103684 :
103685 :
103686 : // End of memberFunctionString
103687 :
103688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
103689 :
103690 84 : SgOmpCopyprivateClause* isSgOmpCopyprivateClause ( SgNode* inputDerivedClassPointer )
103691 : {
103692 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103693 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103694 : // So to fix this we return NULL directly when the input is NULL and avoid the
103695 : // dynamic_cast in this case. This is likely a performance improvement as well.
103696 : // return dynamic_cast<SgOmpCopyprivateClause*>(inputDerivedClassPointer);
103697 : // Milind Chabbi (8/28/2013): isSgOmpCopyprivateClause uses table-driven castability instead of c++ default dynamic_cast
103698 : // this improves the running time performance by 10-20%.
103699 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCopyprivateClause*>(inputDerivedClassPointer);
103700 84 : return IS_SgOmpCopyprivateClause_FAST_MACRO(inputDerivedClassPointer);
103701 : }
103702 :
103703 : // DQ (11/8/2003): Added version of functions taking const pointer
103704 0 : const SgOmpCopyprivateClause* isSgOmpCopyprivateClause ( const SgNode* inputDerivedClassPointer )
103705 : {
103706 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103707 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103708 : // So to fix this we return NULL directly when the input is NULL and avoid the
103709 : // dynamic_cast in this case. This is likely a performance improvement as well.
103710 : // return dynamic_cast<const SgOmpCopyprivateClause*>(inputDerivedClassPointer);
103711 : // Milind Chabbi (8/28/2013): isSgOmpCopyprivateClause uses table-driven castability instead of c++ default dynamic_cast
103712 : // this improves the running time performance by 10-20%.
103713 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCopyprivateClause*>(inputDerivedClassPointer);
103714 0 : return IS_SgOmpCopyprivateClause_FAST_MACRO(inputDerivedClassPointer);
103715 : }
103716 :
103717 :
103718 :
103719 : /* #line 103720 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103720 :
103721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103722 :
103723 : /**
103724 : \brief Generated destructor
103725 :
103726 : This destructor is automatically generated (by ROSETTA). This destructor
103727 : only frees memory of data members associated with the parts of the current IR node which
103728 : are NOT traversed. Those data members that are part of a traversal can be freed using
103729 : a traversal (calling this destructor on all children in a post-order traversal). Such
103730 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
103731 :
103732 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
103733 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
103734 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
103735 :
103736 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
103737 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
103738 : pointers are not yet implemented to call delete on eash pointer in the container.
103739 : (This could be done by derivation from the STL containers to define containers that
103740 : automatically deleted their members.)
103741 :
103742 : */
103743 0 : SgOmpCopyprivateClause::~SgOmpCopyprivateClause () {
103744 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
103745 :
103746 :
103747 :
103748 : }
103749 :
103750 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103751 0 : }
103752 :
103753 :
103754 : /* #line 103755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103755 :
103756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
103757 :
103758 : // Generated constructor
103759 0 : SgOmpCopyprivateClause::SgOmpCopyprivateClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
103760 0 : : SgOmpVariablesClause(startOfConstruct, variables)
103761 : {
103762 : #ifdef DEBUG
103763 : // printf ("In SgOmpCopyprivateClause::SgOmpCopyprivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
103764 : #endif
103765 : #if 0
103766 : // debugging information!
103767 : printf ("In SgOmpCopyprivateClause::SgOmpCopyprivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
103768 : #endif
103769 :
103770 :
103771 :
103772 : #if 0
103773 : // DQ (7/30/2014): Call a virtual function.
103774 : std::string s = this->class_name();
103775 : #endif
103776 :
103777 : // Test the variant virtual function
103778 : // assert(OmpCopyprivateClauseTag == variant());
103779 0 : assert(OmpCopyprivateClauseTag == this->variant());
103780 0 : ROSE_ASSERT(OmpCopyprivateClauseTag == (int)(this->variantT()));
103781 0 : post_construction_initialization();
103782 :
103783 : // Test the isSgOmpCopyprivateClause() function since it has been problematic
103784 0 : assert(isSgOmpCopyprivateClause(this) != NULL);
103785 0 : }
103786 :
103787 : // Generated constructor (all data members)
103788 :
103789 : /* #line 103790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103790 :
103791 :
103792 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
103793 :
103794 :
103795 : // ********************************************************
103796 : // member functions common across all array grammar objects
103797 : // ********************************************************
103798 :
103799 :
103800 :
103801 : /* #line 103802 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103802 :
103803 :
103804 :
103805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
103806 :
103807 : // ********************************************************
103808 : // member functions specific to each node in the grammar
103809 : // ********************************************************
103810 :
103811 :
103812 : /* #line 103813 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103813 :
103814 : // Start of memberFunctionString
103815 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
103816 :
103817 : // *** COMMON CODE SECTION BEGINS HERE ***
103818 :
103819 : #if 0
103820 : int
103821 : SgOmpPrivateClause::getVariant() const
103822 : {
103823 : // This function is used in ROSE while "variant()" is used in SAGE
103824 : assert(this != NULL);
103825 : return variant();
103826 : }
103827 : #endif
103828 :
103829 : // This function is used in ROSE in treeTraversal code
103830 : // eventually replaces getVariant() and variant()
103831 : // though after variant() has been removed for a while we will
103832 : // want to change the name of variantT() back to variant()
103833 : // (since the "T" was ment to stand for temporary).
103834 : // When this happens the variantT() will be depricated.
103835 : VariantT
103836 5015 : SgOmpPrivateClause::variantT() const
103837 : {
103838 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
103839 5015 : ROSE_ASSERT(this != NULL);
103840 5015 : return V_SgOmpPrivateClause;
103841 : }
103842 :
103843 : #if 0
103844 : int
103845 : SgOmpPrivateClause::variant() const
103846 : {
103847 : // This function is used in SAGE
103848 : ROSE_ASSERT(this != NULL);
103849 : return OmpPrivateClauseTag;
103850 : }
103851 : #endif
103852 :
103853 : ROSE_DLL_API const char*
103854 0 : SgOmpPrivateClause::sage_class_name() const
103855 : {
103856 0 : ROSE_ASSERT(this != NULL);
103857 0 : return "SgOmpPrivateClause";
103858 : }
103859 :
103860 : std::string
103861 103 : SgOmpPrivateClause::class_name() const
103862 : {
103863 103 : ROSE_ASSERT(this != NULL);
103864 103 : return "SgOmpPrivateClause";
103865 : }
103866 :
103867 : // DQ (11/26/2005): Support for visitor pattern mechanims
103868 : // (inferior to ROSE traversal mechanism, experimental).
103869 : void
103870 0 : SgOmpPrivateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
103871 : {
103872 0 : ROSE_ASSERT(this != NULL);
103873 0 : visitor.visit(this);
103874 0 : }
103875 :
103876 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
103877 0 : void SgOmpPrivateClause::accept (ROSE_VisitorPattern & visitor) {
103878 0 : ROSE_ASSERT(this != NULL);
103879 0 : visitor.visit(this);
103880 0 : }
103881 :
103882 : SgOmpPrivateClause*
103883 0 : SgOmpPrivateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
103884 : {
103885 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
103886 : // This function is currently only supported for the AST used the represent Binary executables.
103887 : if (0 /* isSgAsmNode(this) != NULL */)
103888 : {
103889 : // Support for regex specification.
103890 : std::string prefixCode = "REGEX:";
103891 : addNewAttribute(prefixCode + s,a);
103892 : }
103893 : #endif
103894 :
103895 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
103896 0 : return this;
103897 : }
103898 :
103899 : // *** COMMON CODE SECTION ENDS HERE ***
103900 :
103901 :
103902 : // End of memberFunctionString
103903 : // Start of memberFunctionString
103904 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
103905 :
103906 :
103907 : #if 0
103908 : //! Error checking support
103909 : /*! Verifies the following:
103910 : - working getVariant() member function
103911 : - calls base class's error() member function
103912 : Every class has one of these functions.
103913 : */
103914 : bool
103915 : SgOmpPrivateClause::error()
103916 : {
103917 : // Put error checking here
103918 :
103919 : ROSE_ASSERT (this != NULL);
103920 : if (getVariant() != OmpPrivateClauseTag)
103921 : {
103922 : printf ("Error in SgOmpPrivateClause::error(): SgOmpPrivateClause object has a %s variant \n",
103923 : Cxx_GrammarTerminalNames[getVariant()].name);
103924 : // printf ("Error in SgOmpPrivateClause::error() \n");
103925 : ROSE_ABORT();
103926 : }
103927 :
103928 : ROSE_ASSERT (getVariant() == OmpPrivateClauseTag);
103929 : return SgOmpVariablesClause::error();
103930 : }
103931 : #endif
103932 :
103933 :
103934 :
103935 : // End of memberFunctionString
103936 :
103937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
103938 :
103939 103 : SgOmpPrivateClause* isSgOmpPrivateClause ( SgNode* inputDerivedClassPointer )
103940 : {
103941 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103942 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103943 : // So to fix this we return NULL directly when the input is NULL and avoid the
103944 : // dynamic_cast in this case. This is likely a performance improvement as well.
103945 : // return dynamic_cast<SgOmpPrivateClause*>(inputDerivedClassPointer);
103946 : // Milind Chabbi (8/28/2013): isSgOmpPrivateClause uses table-driven castability instead of c++ default dynamic_cast
103947 : // this improves the running time performance by 10-20%.
103948 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpPrivateClause*>(inputDerivedClassPointer);
103949 103 : return IS_SgOmpPrivateClause_FAST_MACRO(inputDerivedClassPointer);
103950 : }
103951 :
103952 : // DQ (11/8/2003): Added version of functions taking const pointer
103953 0 : const SgOmpPrivateClause* isSgOmpPrivateClause ( const SgNode* inputDerivedClassPointer )
103954 : {
103955 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
103956 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
103957 : // So to fix this we return NULL directly when the input is NULL and avoid the
103958 : // dynamic_cast in this case. This is likely a performance improvement as well.
103959 : // return dynamic_cast<const SgOmpPrivateClause*>(inputDerivedClassPointer);
103960 : // Milind Chabbi (8/28/2013): isSgOmpPrivateClause uses table-driven castability instead of c++ default dynamic_cast
103961 : // this improves the running time performance by 10-20%.
103962 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpPrivateClause*>(inputDerivedClassPointer);
103963 0 : return IS_SgOmpPrivateClause_FAST_MACRO(inputDerivedClassPointer);
103964 : }
103965 :
103966 :
103967 :
103968 : /* #line 103969 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
103969 :
103970 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
103971 :
103972 : /**
103973 : \brief Generated destructor
103974 :
103975 : This destructor is automatically generated (by ROSETTA). This destructor
103976 : only frees memory of data members associated with the parts of the current IR node which
103977 : are NOT traversed. Those data members that are part of a traversal can be freed using
103978 : a traversal (calling this destructor on all children in a post-order traversal). Such
103979 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
103980 :
103981 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
103982 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
103983 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
103984 :
103985 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
103986 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
103987 : pointers are not yet implemented to call delete on eash pointer in the container.
103988 : (This could be done by derivation from the STL containers to define containers that
103989 : automatically deleted their members.)
103990 :
103991 : */
103992 0 : SgOmpPrivateClause::~SgOmpPrivateClause () {
103993 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
103994 :
103995 :
103996 :
103997 : }
103998 :
103999 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104000 0 : }
104001 :
104002 :
104003 : /* #line 104004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104004 :
104005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
104006 :
104007 : // Generated constructor
104008 0 : SgOmpPrivateClause::SgOmpPrivateClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
104009 0 : : SgOmpVariablesClause(startOfConstruct, variables)
104010 : {
104011 : #ifdef DEBUG
104012 : // printf ("In SgOmpPrivateClause::SgOmpPrivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
104013 : #endif
104014 : #if 0
104015 : // debugging information!
104016 : printf ("In SgOmpPrivateClause::SgOmpPrivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
104017 : #endif
104018 :
104019 :
104020 :
104021 : #if 0
104022 : // DQ (7/30/2014): Call a virtual function.
104023 : std::string s = this->class_name();
104024 : #endif
104025 :
104026 : // Test the variant virtual function
104027 : // assert(OmpPrivateClauseTag == variant());
104028 0 : assert(OmpPrivateClauseTag == this->variant());
104029 0 : ROSE_ASSERT(OmpPrivateClauseTag == (int)(this->variantT()));
104030 0 : post_construction_initialization();
104031 :
104032 : // Test the isSgOmpPrivateClause() function since it has been problematic
104033 0 : assert(isSgOmpPrivateClause(this) != NULL);
104034 0 : }
104035 :
104036 : // Generated constructor (all data members)
104037 :
104038 : /* #line 104039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104039 :
104040 :
104041 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104042 :
104043 :
104044 : // ********************************************************
104045 : // member functions common across all array grammar objects
104046 : // ********************************************************
104047 :
104048 :
104049 :
104050 : /* #line 104051 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104051 :
104052 :
104053 :
104054 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104055 :
104056 : // ********************************************************
104057 : // member functions specific to each node in the grammar
104058 : // ********************************************************
104059 :
104060 :
104061 : /* #line 104062 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104062 :
104063 : // Start of memberFunctionString
104064 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
104065 :
104066 : // *** COMMON CODE SECTION BEGINS HERE ***
104067 :
104068 : #if 0
104069 : int
104070 : SgOmpFirstprivateClause::getVariant() const
104071 : {
104072 : // This function is used in ROSE while "variant()" is used in SAGE
104073 : assert(this != NULL);
104074 : return variant();
104075 : }
104076 : #endif
104077 :
104078 : // This function is used in ROSE in treeTraversal code
104079 : // eventually replaces getVariant() and variant()
104080 : // though after variant() has been removed for a while we will
104081 : // want to change the name of variantT() back to variant()
104082 : // (since the "T" was ment to stand for temporary).
104083 : // When this happens the variantT() will be depricated.
104084 : VariantT
104085 2063 : SgOmpFirstprivateClause::variantT() const
104086 : {
104087 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
104088 2063 : ROSE_ASSERT(this != NULL);
104089 2063 : return V_SgOmpFirstprivateClause;
104090 : }
104091 :
104092 : #if 0
104093 : int
104094 : SgOmpFirstprivateClause::variant() const
104095 : {
104096 : // This function is used in SAGE
104097 : ROSE_ASSERT(this != NULL);
104098 : return OmpFirstprivateClauseTag;
104099 : }
104100 : #endif
104101 :
104102 : ROSE_DLL_API const char*
104103 0 : SgOmpFirstprivateClause::sage_class_name() const
104104 : {
104105 0 : ROSE_ASSERT(this != NULL);
104106 0 : return "SgOmpFirstprivateClause";
104107 : }
104108 :
104109 : std::string
104110 37 : SgOmpFirstprivateClause::class_name() const
104111 : {
104112 37 : ROSE_ASSERT(this != NULL);
104113 37 : return "SgOmpFirstprivateClause";
104114 : }
104115 :
104116 : // DQ (11/26/2005): Support for visitor pattern mechanims
104117 : // (inferior to ROSE traversal mechanism, experimental).
104118 : void
104119 0 : SgOmpFirstprivateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
104120 : {
104121 0 : ROSE_ASSERT(this != NULL);
104122 0 : visitor.visit(this);
104123 0 : }
104124 :
104125 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
104126 0 : void SgOmpFirstprivateClause::accept (ROSE_VisitorPattern & visitor) {
104127 0 : ROSE_ASSERT(this != NULL);
104128 0 : visitor.visit(this);
104129 0 : }
104130 :
104131 : SgOmpFirstprivateClause*
104132 0 : SgOmpFirstprivateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
104133 : {
104134 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
104135 : // This function is currently only supported for the AST used the represent Binary executables.
104136 : if (0 /* isSgAsmNode(this) != NULL */)
104137 : {
104138 : // Support for regex specification.
104139 : std::string prefixCode = "REGEX:";
104140 : addNewAttribute(prefixCode + s,a);
104141 : }
104142 : #endif
104143 :
104144 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
104145 0 : return this;
104146 : }
104147 :
104148 : // *** COMMON CODE SECTION ENDS HERE ***
104149 :
104150 :
104151 : // End of memberFunctionString
104152 : // Start of memberFunctionString
104153 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
104154 :
104155 :
104156 : #if 0
104157 : //! Error checking support
104158 : /*! Verifies the following:
104159 : - working getVariant() member function
104160 : - calls base class's error() member function
104161 : Every class has one of these functions.
104162 : */
104163 : bool
104164 : SgOmpFirstprivateClause::error()
104165 : {
104166 : // Put error checking here
104167 :
104168 : ROSE_ASSERT (this != NULL);
104169 : if (getVariant() != OmpFirstprivateClauseTag)
104170 : {
104171 : printf ("Error in SgOmpFirstprivateClause::error(): SgOmpFirstprivateClause object has a %s variant \n",
104172 : Cxx_GrammarTerminalNames[getVariant()].name);
104173 : // printf ("Error in SgOmpFirstprivateClause::error() \n");
104174 : ROSE_ABORT();
104175 : }
104176 :
104177 : ROSE_ASSERT (getVariant() == OmpFirstprivateClauseTag);
104178 : return SgOmpVariablesClause::error();
104179 : }
104180 : #endif
104181 :
104182 :
104183 :
104184 : // End of memberFunctionString
104185 :
104186 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
104187 :
104188 37 : SgOmpFirstprivateClause* isSgOmpFirstprivateClause ( SgNode* inputDerivedClassPointer )
104189 : {
104190 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104191 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104192 : // So to fix this we return NULL directly when the input is NULL and avoid the
104193 : // dynamic_cast in this case. This is likely a performance improvement as well.
104194 : // return dynamic_cast<SgOmpFirstprivateClause*>(inputDerivedClassPointer);
104195 : // Milind Chabbi (8/28/2013): isSgOmpFirstprivateClause uses table-driven castability instead of c++ default dynamic_cast
104196 : // this improves the running time performance by 10-20%.
104197 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpFirstprivateClause*>(inputDerivedClassPointer);
104198 37 : return IS_SgOmpFirstprivateClause_FAST_MACRO(inputDerivedClassPointer);
104199 : }
104200 :
104201 : // DQ (11/8/2003): Added version of functions taking const pointer
104202 0 : const SgOmpFirstprivateClause* isSgOmpFirstprivateClause ( const SgNode* inputDerivedClassPointer )
104203 : {
104204 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104205 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104206 : // So to fix this we return NULL directly when the input is NULL and avoid the
104207 : // dynamic_cast in this case. This is likely a performance improvement as well.
104208 : // return dynamic_cast<const SgOmpFirstprivateClause*>(inputDerivedClassPointer);
104209 : // Milind Chabbi (8/28/2013): isSgOmpFirstprivateClause uses table-driven castability instead of c++ default dynamic_cast
104210 : // this improves the running time performance by 10-20%.
104211 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpFirstprivateClause*>(inputDerivedClassPointer);
104212 0 : return IS_SgOmpFirstprivateClause_FAST_MACRO(inputDerivedClassPointer);
104213 : }
104214 :
104215 :
104216 :
104217 : /* #line 104218 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104218 :
104219 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104220 :
104221 : /**
104222 : \brief Generated destructor
104223 :
104224 : This destructor is automatically generated (by ROSETTA). This destructor
104225 : only frees memory of data members associated with the parts of the current IR node which
104226 : are NOT traversed. Those data members that are part of a traversal can be freed using
104227 : a traversal (calling this destructor on all children in a post-order traversal). Such
104228 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
104229 :
104230 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
104231 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
104232 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
104233 :
104234 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
104235 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
104236 : pointers are not yet implemented to call delete on eash pointer in the container.
104237 : (This could be done by derivation from the STL containers to define containers that
104238 : automatically deleted their members.)
104239 :
104240 : */
104241 0 : SgOmpFirstprivateClause::~SgOmpFirstprivateClause () {
104242 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
104243 :
104244 :
104245 :
104246 : }
104247 :
104248 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104249 0 : }
104250 :
104251 :
104252 : /* #line 104253 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104253 :
104254 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
104255 :
104256 : // Generated constructor
104257 0 : SgOmpFirstprivateClause::SgOmpFirstprivateClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
104258 0 : : SgOmpVariablesClause(startOfConstruct, variables)
104259 : {
104260 : #ifdef DEBUG
104261 : // printf ("In SgOmpFirstprivateClause::SgOmpFirstprivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
104262 : #endif
104263 : #if 0
104264 : // debugging information!
104265 : printf ("In SgOmpFirstprivateClause::SgOmpFirstprivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
104266 : #endif
104267 :
104268 :
104269 :
104270 : #if 0
104271 : // DQ (7/30/2014): Call a virtual function.
104272 : std::string s = this->class_name();
104273 : #endif
104274 :
104275 : // Test the variant virtual function
104276 : // assert(OmpFirstprivateClauseTag == variant());
104277 0 : assert(OmpFirstprivateClauseTag == this->variant());
104278 0 : ROSE_ASSERT(OmpFirstprivateClauseTag == (int)(this->variantT()));
104279 0 : post_construction_initialization();
104280 :
104281 : // Test the isSgOmpFirstprivateClause() function since it has been problematic
104282 0 : assert(isSgOmpFirstprivateClause(this) != NULL);
104283 0 : }
104284 :
104285 : // Generated constructor (all data members)
104286 :
104287 : /* #line 104288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104288 :
104289 :
104290 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104291 :
104292 :
104293 : // ********************************************************
104294 : // member functions common across all array grammar objects
104295 : // ********************************************************
104296 :
104297 :
104298 :
104299 : /* #line 104300 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104300 :
104301 :
104302 :
104303 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104304 :
104305 : // ********************************************************
104306 : // member functions specific to each node in the grammar
104307 : // ********************************************************
104308 :
104309 :
104310 : /* #line 104311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104311 :
104312 : // Start of memberFunctionString
104313 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
104314 :
104315 : // *** COMMON CODE SECTION BEGINS HERE ***
104316 :
104317 : #if 0
104318 : int
104319 : SgOmpNontemporalClause::getVariant() const
104320 : {
104321 : // This function is used in ROSE while "variant()" is used in SAGE
104322 : assert(this != NULL);
104323 : return variant();
104324 : }
104325 : #endif
104326 :
104327 : // This function is used in ROSE in treeTraversal code
104328 : // eventually replaces getVariant() and variant()
104329 : // though after variant() has been removed for a while we will
104330 : // want to change the name of variantT() back to variant()
104331 : // (since the "T" was ment to stand for temporary).
104332 : // When this happens the variantT() will be depricated.
104333 : VariantT
104334 0 : SgOmpNontemporalClause::variantT() const
104335 : {
104336 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
104337 0 : ROSE_ASSERT(this != NULL);
104338 0 : return V_SgOmpNontemporalClause;
104339 : }
104340 :
104341 : #if 0
104342 : int
104343 : SgOmpNontemporalClause::variant() const
104344 : {
104345 : // This function is used in SAGE
104346 : ROSE_ASSERT(this != NULL);
104347 : return OmpNontemporalClauseTag;
104348 : }
104349 : #endif
104350 :
104351 : ROSE_DLL_API const char*
104352 0 : SgOmpNontemporalClause::sage_class_name() const
104353 : {
104354 0 : ROSE_ASSERT(this != NULL);
104355 0 : return "SgOmpNontemporalClause";
104356 : }
104357 :
104358 : std::string
104359 0 : SgOmpNontemporalClause::class_name() const
104360 : {
104361 0 : ROSE_ASSERT(this != NULL);
104362 0 : return "SgOmpNontemporalClause";
104363 : }
104364 :
104365 : // DQ (11/26/2005): Support for visitor pattern mechanims
104366 : // (inferior to ROSE traversal mechanism, experimental).
104367 : void
104368 0 : SgOmpNontemporalClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
104369 : {
104370 0 : ROSE_ASSERT(this != NULL);
104371 0 : visitor.visit(this);
104372 0 : }
104373 :
104374 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
104375 0 : void SgOmpNontemporalClause::accept (ROSE_VisitorPattern & visitor) {
104376 0 : ROSE_ASSERT(this != NULL);
104377 0 : visitor.visit(this);
104378 0 : }
104379 :
104380 : SgOmpNontemporalClause*
104381 0 : SgOmpNontemporalClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
104382 : {
104383 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
104384 : // This function is currently only supported for the AST used the represent Binary executables.
104385 : if (0 /* isSgAsmNode(this) != NULL */)
104386 : {
104387 : // Support for regex specification.
104388 : std::string prefixCode = "REGEX:";
104389 : addNewAttribute(prefixCode + s,a);
104390 : }
104391 : #endif
104392 :
104393 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
104394 0 : return this;
104395 : }
104396 :
104397 : // *** COMMON CODE SECTION ENDS HERE ***
104398 :
104399 :
104400 : // End of memberFunctionString
104401 : // Start of memberFunctionString
104402 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
104403 :
104404 :
104405 : #if 0
104406 : //! Error checking support
104407 : /*! Verifies the following:
104408 : - working getVariant() member function
104409 : - calls base class's error() member function
104410 : Every class has one of these functions.
104411 : */
104412 : bool
104413 : SgOmpNontemporalClause::error()
104414 : {
104415 : // Put error checking here
104416 :
104417 : ROSE_ASSERT (this != NULL);
104418 : if (getVariant() != OmpNontemporalClauseTag)
104419 : {
104420 : printf ("Error in SgOmpNontemporalClause::error(): SgOmpNontemporalClause object has a %s variant \n",
104421 : Cxx_GrammarTerminalNames[getVariant()].name);
104422 : // printf ("Error in SgOmpNontemporalClause::error() \n");
104423 : ROSE_ABORT();
104424 : }
104425 :
104426 : ROSE_ASSERT (getVariant() == OmpNontemporalClauseTag);
104427 : return SgOmpVariablesClause::error();
104428 : }
104429 : #endif
104430 :
104431 :
104432 :
104433 : // End of memberFunctionString
104434 :
104435 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
104436 :
104437 0 : SgOmpNontemporalClause* isSgOmpNontemporalClause ( SgNode* inputDerivedClassPointer )
104438 : {
104439 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104440 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104441 : // So to fix this we return NULL directly when the input is NULL and avoid the
104442 : // dynamic_cast in this case. This is likely a performance improvement as well.
104443 : // return dynamic_cast<SgOmpNontemporalClause*>(inputDerivedClassPointer);
104444 : // Milind Chabbi (8/28/2013): isSgOmpNontemporalClause uses table-driven castability instead of c++ default dynamic_cast
104445 : // this improves the running time performance by 10-20%.
104446 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpNontemporalClause*>(inputDerivedClassPointer);
104447 0 : return IS_SgOmpNontemporalClause_FAST_MACRO(inputDerivedClassPointer);
104448 : }
104449 :
104450 : // DQ (11/8/2003): Added version of functions taking const pointer
104451 0 : const SgOmpNontemporalClause* isSgOmpNontemporalClause ( const SgNode* inputDerivedClassPointer )
104452 : {
104453 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104454 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104455 : // So to fix this we return NULL directly when the input is NULL and avoid the
104456 : // dynamic_cast in this case. This is likely a performance improvement as well.
104457 : // return dynamic_cast<const SgOmpNontemporalClause*>(inputDerivedClassPointer);
104458 : // Milind Chabbi (8/28/2013): isSgOmpNontemporalClause uses table-driven castability instead of c++ default dynamic_cast
104459 : // this improves the running time performance by 10-20%.
104460 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpNontemporalClause*>(inputDerivedClassPointer);
104461 0 : return IS_SgOmpNontemporalClause_FAST_MACRO(inputDerivedClassPointer);
104462 : }
104463 :
104464 :
104465 :
104466 : /* #line 104467 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104467 :
104468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104469 :
104470 : /**
104471 : \brief Generated destructor
104472 :
104473 : This destructor is automatically generated (by ROSETTA). This destructor
104474 : only frees memory of data members associated with the parts of the current IR node which
104475 : are NOT traversed. Those data members that are part of a traversal can be freed using
104476 : a traversal (calling this destructor on all children in a post-order traversal). Such
104477 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
104478 :
104479 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
104480 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
104481 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
104482 :
104483 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
104484 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
104485 : pointers are not yet implemented to call delete on eash pointer in the container.
104486 : (This could be done by derivation from the STL containers to define containers that
104487 : automatically deleted their members.)
104488 :
104489 : */
104490 0 : SgOmpNontemporalClause::~SgOmpNontemporalClause () {
104491 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
104492 :
104493 :
104494 :
104495 : }
104496 :
104497 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104498 0 : }
104499 :
104500 :
104501 : /* #line 104502 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104502 :
104503 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
104504 :
104505 : // Generated constructor
104506 0 : SgOmpNontemporalClause::SgOmpNontemporalClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
104507 0 : : SgOmpVariablesClause(startOfConstruct, variables)
104508 : {
104509 : #ifdef DEBUG
104510 : // printf ("In SgOmpNontemporalClause::SgOmpNontemporalClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
104511 : #endif
104512 : #if 0
104513 : // debugging information!
104514 : printf ("In SgOmpNontemporalClause::SgOmpNontemporalClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
104515 : #endif
104516 :
104517 :
104518 :
104519 : #if 0
104520 : // DQ (7/30/2014): Call a virtual function.
104521 : std::string s = this->class_name();
104522 : #endif
104523 :
104524 : // Test the variant virtual function
104525 : // assert(OmpNontemporalClauseTag == variant());
104526 0 : assert(OmpNontemporalClauseTag == this->variant());
104527 0 : ROSE_ASSERT(OmpNontemporalClauseTag == (int)(this->variantT()));
104528 0 : post_construction_initialization();
104529 :
104530 : // Test the isSgOmpNontemporalClause() function since it has been problematic
104531 0 : assert(isSgOmpNontemporalClause(this) != NULL);
104532 0 : }
104533 :
104534 : // Generated constructor (all data members)
104535 :
104536 : /* #line 104537 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104537 :
104538 :
104539 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104540 :
104541 :
104542 : // ********************************************************
104543 : // member functions common across all array grammar objects
104544 : // ********************************************************
104545 :
104546 :
104547 :
104548 : /* #line 104549 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104549 :
104550 :
104551 :
104552 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104553 :
104554 : // ********************************************************
104555 : // member functions specific to each node in the grammar
104556 : // ********************************************************
104557 :
104558 :
104559 : /* #line 104560 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104560 :
104561 : // Start of memberFunctionString
104562 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
104563 :
104564 : // *** COMMON CODE SECTION BEGINS HERE ***
104565 :
104566 : #if 0
104567 : int
104568 : SgOmpInclusiveClause::getVariant() const
104569 : {
104570 : // This function is used in ROSE while "variant()" is used in SAGE
104571 : assert(this != NULL);
104572 : return variant();
104573 : }
104574 : #endif
104575 :
104576 : // This function is used in ROSE in treeTraversal code
104577 : // eventually replaces getVariant() and variant()
104578 : // though after variant() has been removed for a while we will
104579 : // want to change the name of variantT() back to variant()
104580 : // (since the "T" was ment to stand for temporary).
104581 : // When this happens the variantT() will be depricated.
104582 : VariantT
104583 0 : SgOmpInclusiveClause::variantT() const
104584 : {
104585 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
104586 0 : ROSE_ASSERT(this != NULL);
104587 0 : return V_SgOmpInclusiveClause;
104588 : }
104589 :
104590 : #if 0
104591 : int
104592 : SgOmpInclusiveClause::variant() const
104593 : {
104594 : // This function is used in SAGE
104595 : ROSE_ASSERT(this != NULL);
104596 : return OmpInclusiveClauseTag;
104597 : }
104598 : #endif
104599 :
104600 : ROSE_DLL_API const char*
104601 0 : SgOmpInclusiveClause::sage_class_name() const
104602 : {
104603 0 : ROSE_ASSERT(this != NULL);
104604 0 : return "SgOmpInclusiveClause";
104605 : }
104606 :
104607 : std::string
104608 0 : SgOmpInclusiveClause::class_name() const
104609 : {
104610 0 : ROSE_ASSERT(this != NULL);
104611 0 : return "SgOmpInclusiveClause";
104612 : }
104613 :
104614 : // DQ (11/26/2005): Support for visitor pattern mechanims
104615 : // (inferior to ROSE traversal mechanism, experimental).
104616 : void
104617 0 : SgOmpInclusiveClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
104618 : {
104619 0 : ROSE_ASSERT(this != NULL);
104620 0 : visitor.visit(this);
104621 0 : }
104622 :
104623 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
104624 0 : void SgOmpInclusiveClause::accept (ROSE_VisitorPattern & visitor) {
104625 0 : ROSE_ASSERT(this != NULL);
104626 0 : visitor.visit(this);
104627 0 : }
104628 :
104629 : SgOmpInclusiveClause*
104630 0 : SgOmpInclusiveClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
104631 : {
104632 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
104633 : // This function is currently only supported for the AST used the represent Binary executables.
104634 : if (0 /* isSgAsmNode(this) != NULL */)
104635 : {
104636 : // Support for regex specification.
104637 : std::string prefixCode = "REGEX:";
104638 : addNewAttribute(prefixCode + s,a);
104639 : }
104640 : #endif
104641 :
104642 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
104643 0 : return this;
104644 : }
104645 :
104646 : // *** COMMON CODE SECTION ENDS HERE ***
104647 :
104648 :
104649 : // End of memberFunctionString
104650 : // Start of memberFunctionString
104651 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
104652 :
104653 :
104654 : #if 0
104655 : //! Error checking support
104656 : /*! Verifies the following:
104657 : - working getVariant() member function
104658 : - calls base class's error() member function
104659 : Every class has one of these functions.
104660 : */
104661 : bool
104662 : SgOmpInclusiveClause::error()
104663 : {
104664 : // Put error checking here
104665 :
104666 : ROSE_ASSERT (this != NULL);
104667 : if (getVariant() != OmpInclusiveClauseTag)
104668 : {
104669 : printf ("Error in SgOmpInclusiveClause::error(): SgOmpInclusiveClause object has a %s variant \n",
104670 : Cxx_GrammarTerminalNames[getVariant()].name);
104671 : // printf ("Error in SgOmpInclusiveClause::error() \n");
104672 : ROSE_ABORT();
104673 : }
104674 :
104675 : ROSE_ASSERT (getVariant() == OmpInclusiveClauseTag);
104676 : return SgOmpVariablesClause::error();
104677 : }
104678 : #endif
104679 :
104680 :
104681 :
104682 : // End of memberFunctionString
104683 :
104684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
104685 :
104686 0 : SgOmpInclusiveClause* isSgOmpInclusiveClause ( SgNode* inputDerivedClassPointer )
104687 : {
104688 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104689 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104690 : // So to fix this we return NULL directly when the input is NULL and avoid the
104691 : // dynamic_cast in this case. This is likely a performance improvement as well.
104692 : // return dynamic_cast<SgOmpInclusiveClause*>(inputDerivedClassPointer);
104693 : // Milind Chabbi (8/28/2013): isSgOmpInclusiveClause uses table-driven castability instead of c++ default dynamic_cast
104694 : // this improves the running time performance by 10-20%.
104695 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpInclusiveClause*>(inputDerivedClassPointer);
104696 0 : return IS_SgOmpInclusiveClause_FAST_MACRO(inputDerivedClassPointer);
104697 : }
104698 :
104699 : // DQ (11/8/2003): Added version of functions taking const pointer
104700 0 : const SgOmpInclusiveClause* isSgOmpInclusiveClause ( const SgNode* inputDerivedClassPointer )
104701 : {
104702 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104703 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104704 : // So to fix this we return NULL directly when the input is NULL and avoid the
104705 : // dynamic_cast in this case. This is likely a performance improvement as well.
104706 : // return dynamic_cast<const SgOmpInclusiveClause*>(inputDerivedClassPointer);
104707 : // Milind Chabbi (8/28/2013): isSgOmpInclusiveClause uses table-driven castability instead of c++ default dynamic_cast
104708 : // this improves the running time performance by 10-20%.
104709 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpInclusiveClause*>(inputDerivedClassPointer);
104710 0 : return IS_SgOmpInclusiveClause_FAST_MACRO(inputDerivedClassPointer);
104711 : }
104712 :
104713 :
104714 :
104715 : /* #line 104716 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104716 :
104717 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104718 :
104719 : /**
104720 : \brief Generated destructor
104721 :
104722 : This destructor is automatically generated (by ROSETTA). This destructor
104723 : only frees memory of data members associated with the parts of the current IR node which
104724 : are NOT traversed. Those data members that are part of a traversal can be freed using
104725 : a traversal (calling this destructor on all children in a post-order traversal). Such
104726 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
104727 :
104728 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
104729 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
104730 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
104731 :
104732 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
104733 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
104734 : pointers are not yet implemented to call delete on eash pointer in the container.
104735 : (This could be done by derivation from the STL containers to define containers that
104736 : automatically deleted their members.)
104737 :
104738 : */
104739 0 : SgOmpInclusiveClause::~SgOmpInclusiveClause () {
104740 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
104741 :
104742 :
104743 :
104744 : }
104745 :
104746 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104747 0 : }
104748 :
104749 :
104750 : /* #line 104751 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104751 :
104752 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
104753 :
104754 : // Generated constructor
104755 0 : SgOmpInclusiveClause::SgOmpInclusiveClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
104756 0 : : SgOmpVariablesClause(startOfConstruct, variables)
104757 : {
104758 : #ifdef DEBUG
104759 : // printf ("In SgOmpInclusiveClause::SgOmpInclusiveClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
104760 : #endif
104761 : #if 0
104762 : // debugging information!
104763 : printf ("In SgOmpInclusiveClause::SgOmpInclusiveClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
104764 : #endif
104765 :
104766 :
104767 :
104768 : #if 0
104769 : // DQ (7/30/2014): Call a virtual function.
104770 : std::string s = this->class_name();
104771 : #endif
104772 :
104773 : // Test the variant virtual function
104774 : // assert(OmpInclusiveClauseTag == variant());
104775 0 : assert(OmpInclusiveClauseTag == this->variant());
104776 0 : ROSE_ASSERT(OmpInclusiveClauseTag == (int)(this->variantT()));
104777 0 : post_construction_initialization();
104778 :
104779 : // Test the isSgOmpInclusiveClause() function since it has been problematic
104780 0 : assert(isSgOmpInclusiveClause(this) != NULL);
104781 0 : }
104782 :
104783 : // Generated constructor (all data members)
104784 :
104785 : /* #line 104786 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104786 :
104787 :
104788 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104789 :
104790 :
104791 : // ********************************************************
104792 : // member functions common across all array grammar objects
104793 : // ********************************************************
104794 :
104795 :
104796 :
104797 : /* #line 104798 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104798 :
104799 :
104800 :
104801 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
104802 :
104803 : // ********************************************************
104804 : // member functions specific to each node in the grammar
104805 : // ********************************************************
104806 :
104807 :
104808 : /* #line 104809 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104809 :
104810 : // Start of memberFunctionString
104811 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
104812 :
104813 : // *** COMMON CODE SECTION BEGINS HERE ***
104814 :
104815 : #if 0
104816 : int
104817 : SgOmpExclusiveClause::getVariant() const
104818 : {
104819 : // This function is used in ROSE while "variant()" is used in SAGE
104820 : assert(this != NULL);
104821 : return variant();
104822 : }
104823 : #endif
104824 :
104825 : // This function is used in ROSE in treeTraversal code
104826 : // eventually replaces getVariant() and variant()
104827 : // though after variant() has been removed for a while we will
104828 : // want to change the name of variantT() back to variant()
104829 : // (since the "T" was ment to stand for temporary).
104830 : // When this happens the variantT() will be depricated.
104831 : VariantT
104832 33 : SgOmpExclusiveClause::variantT() const
104833 : {
104834 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
104835 33 : ROSE_ASSERT(this != NULL);
104836 33 : return V_SgOmpExclusiveClause;
104837 : }
104838 :
104839 : #if 0
104840 : int
104841 : SgOmpExclusiveClause::variant() const
104842 : {
104843 : // This function is used in SAGE
104844 : ROSE_ASSERT(this != NULL);
104845 : return OmpExclusiveClauseTag;
104846 : }
104847 : #endif
104848 :
104849 : ROSE_DLL_API const char*
104850 0 : SgOmpExclusiveClause::sage_class_name() const
104851 : {
104852 0 : ROSE_ASSERT(this != NULL);
104853 0 : return "SgOmpExclusiveClause";
104854 : }
104855 :
104856 : std::string
104857 1 : SgOmpExclusiveClause::class_name() const
104858 : {
104859 1 : ROSE_ASSERT(this != NULL);
104860 1 : return "SgOmpExclusiveClause";
104861 : }
104862 :
104863 : // DQ (11/26/2005): Support for visitor pattern mechanims
104864 : // (inferior to ROSE traversal mechanism, experimental).
104865 : void
104866 0 : SgOmpExclusiveClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
104867 : {
104868 0 : ROSE_ASSERT(this != NULL);
104869 0 : visitor.visit(this);
104870 0 : }
104871 :
104872 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
104873 0 : void SgOmpExclusiveClause::accept (ROSE_VisitorPattern & visitor) {
104874 0 : ROSE_ASSERT(this != NULL);
104875 0 : visitor.visit(this);
104876 0 : }
104877 :
104878 : SgOmpExclusiveClause*
104879 0 : SgOmpExclusiveClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
104880 : {
104881 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
104882 : // This function is currently only supported for the AST used the represent Binary executables.
104883 : if (0 /* isSgAsmNode(this) != NULL */)
104884 : {
104885 : // Support for regex specification.
104886 : std::string prefixCode = "REGEX:";
104887 : addNewAttribute(prefixCode + s,a);
104888 : }
104889 : #endif
104890 :
104891 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
104892 0 : return this;
104893 : }
104894 :
104895 : // *** COMMON CODE SECTION ENDS HERE ***
104896 :
104897 :
104898 : // End of memberFunctionString
104899 : // Start of memberFunctionString
104900 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
104901 :
104902 :
104903 : #if 0
104904 : //! Error checking support
104905 : /*! Verifies the following:
104906 : - working getVariant() member function
104907 : - calls base class's error() member function
104908 : Every class has one of these functions.
104909 : */
104910 : bool
104911 : SgOmpExclusiveClause::error()
104912 : {
104913 : // Put error checking here
104914 :
104915 : ROSE_ASSERT (this != NULL);
104916 : if (getVariant() != OmpExclusiveClauseTag)
104917 : {
104918 : printf ("Error in SgOmpExclusiveClause::error(): SgOmpExclusiveClause object has a %s variant \n",
104919 : Cxx_GrammarTerminalNames[getVariant()].name);
104920 : // printf ("Error in SgOmpExclusiveClause::error() \n");
104921 : ROSE_ABORT();
104922 : }
104923 :
104924 : ROSE_ASSERT (getVariant() == OmpExclusiveClauseTag);
104925 : return SgOmpVariablesClause::error();
104926 : }
104927 : #endif
104928 :
104929 :
104930 :
104931 : // End of memberFunctionString
104932 :
104933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
104934 :
104935 1 : SgOmpExclusiveClause* isSgOmpExclusiveClause ( SgNode* inputDerivedClassPointer )
104936 : {
104937 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104938 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104939 : // So to fix this we return NULL directly when the input is NULL and avoid the
104940 : // dynamic_cast in this case. This is likely a performance improvement as well.
104941 : // return dynamic_cast<SgOmpExclusiveClause*>(inputDerivedClassPointer);
104942 : // Milind Chabbi (8/28/2013): isSgOmpExclusiveClause uses table-driven castability instead of c++ default dynamic_cast
104943 : // this improves the running time performance by 10-20%.
104944 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpExclusiveClause*>(inputDerivedClassPointer);
104945 1 : return IS_SgOmpExclusiveClause_FAST_MACRO(inputDerivedClassPointer);
104946 : }
104947 :
104948 : // DQ (11/8/2003): Added version of functions taking const pointer
104949 0 : const SgOmpExclusiveClause* isSgOmpExclusiveClause ( const SgNode* inputDerivedClassPointer )
104950 : {
104951 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
104952 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
104953 : // So to fix this we return NULL directly when the input is NULL and avoid the
104954 : // dynamic_cast in this case. This is likely a performance improvement as well.
104955 : // return dynamic_cast<const SgOmpExclusiveClause*>(inputDerivedClassPointer);
104956 : // Milind Chabbi (8/28/2013): isSgOmpExclusiveClause uses table-driven castability instead of c++ default dynamic_cast
104957 : // this improves the running time performance by 10-20%.
104958 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpExclusiveClause*>(inputDerivedClassPointer);
104959 0 : return IS_SgOmpExclusiveClause_FAST_MACRO(inputDerivedClassPointer);
104960 : }
104961 :
104962 :
104963 :
104964 : /* #line 104965 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
104965 :
104966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104967 :
104968 : /**
104969 : \brief Generated destructor
104970 :
104971 : This destructor is automatically generated (by ROSETTA). This destructor
104972 : only frees memory of data members associated with the parts of the current IR node which
104973 : are NOT traversed. Those data members that are part of a traversal can be freed using
104974 : a traversal (calling this destructor on all children in a post-order traversal). Such
104975 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
104976 :
104977 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
104978 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
104979 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
104980 :
104981 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
104982 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
104983 : pointers are not yet implemented to call delete on eash pointer in the container.
104984 : (This could be done by derivation from the STL containers to define containers that
104985 : automatically deleted their members.)
104986 :
104987 : */
104988 0 : SgOmpExclusiveClause::~SgOmpExclusiveClause () {
104989 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
104990 :
104991 :
104992 :
104993 : }
104994 :
104995 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
104996 0 : }
104997 :
104998 :
104999 : /* #line 105000 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105000 :
105001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
105002 :
105003 : // Generated constructor
105004 0 : SgOmpExclusiveClause::SgOmpExclusiveClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
105005 0 : : SgOmpVariablesClause(startOfConstruct, variables)
105006 : {
105007 : #ifdef DEBUG
105008 : // printf ("In SgOmpExclusiveClause::SgOmpExclusiveClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
105009 : #endif
105010 : #if 0
105011 : // debugging information!
105012 : printf ("In SgOmpExclusiveClause::SgOmpExclusiveClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
105013 : #endif
105014 :
105015 :
105016 :
105017 : #if 0
105018 : // DQ (7/30/2014): Call a virtual function.
105019 : std::string s = this->class_name();
105020 : #endif
105021 :
105022 : // Test the variant virtual function
105023 : // assert(OmpExclusiveClauseTag == variant());
105024 0 : assert(OmpExclusiveClauseTag == this->variant());
105025 0 : ROSE_ASSERT(OmpExclusiveClauseTag == (int)(this->variantT()));
105026 0 : post_construction_initialization();
105027 :
105028 : // Test the isSgOmpExclusiveClause() function since it has been problematic
105029 0 : assert(isSgOmpExclusiveClause(this) != NULL);
105030 0 : }
105031 :
105032 : // Generated constructor (all data members)
105033 :
105034 : /* #line 105035 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105035 :
105036 :
105037 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105038 :
105039 :
105040 : // ********************************************************
105041 : // member functions common across all array grammar objects
105042 : // ********************************************************
105043 :
105044 :
105045 :
105046 : /* #line 105047 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105047 :
105048 :
105049 :
105050 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105051 :
105052 : // ********************************************************
105053 : // member functions specific to each node in the grammar
105054 : // ********************************************************
105055 :
105056 :
105057 : /* #line 105058 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105058 :
105059 : // Start of memberFunctionString
105060 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
105061 :
105062 : // *** COMMON CODE SECTION BEGINS HERE ***
105063 :
105064 : #if 0
105065 : int
105066 : SgOmpIsDevicePtrClause::getVariant() const
105067 : {
105068 : // This function is used in ROSE while "variant()" is used in SAGE
105069 : assert(this != NULL);
105070 : return variant();
105071 : }
105072 : #endif
105073 :
105074 : // This function is used in ROSE in treeTraversal code
105075 : // eventually replaces getVariant() and variant()
105076 : // though after variant() has been removed for a while we will
105077 : // want to change the name of variantT() back to variant()
105078 : // (since the "T" was ment to stand for temporary).
105079 : // When this happens the variantT() will be depricated.
105080 : VariantT
105081 0 : SgOmpIsDevicePtrClause::variantT() const
105082 : {
105083 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
105084 0 : ROSE_ASSERT(this != NULL);
105085 0 : return V_SgOmpIsDevicePtrClause;
105086 : }
105087 :
105088 : #if 0
105089 : int
105090 : SgOmpIsDevicePtrClause::variant() const
105091 : {
105092 : // This function is used in SAGE
105093 : ROSE_ASSERT(this != NULL);
105094 : return OmpIsDevicePtrClauseTag;
105095 : }
105096 : #endif
105097 :
105098 : ROSE_DLL_API const char*
105099 0 : SgOmpIsDevicePtrClause::sage_class_name() const
105100 : {
105101 0 : ROSE_ASSERT(this != NULL);
105102 0 : return "SgOmpIsDevicePtrClause";
105103 : }
105104 :
105105 : std::string
105106 0 : SgOmpIsDevicePtrClause::class_name() const
105107 : {
105108 0 : ROSE_ASSERT(this != NULL);
105109 0 : return "SgOmpIsDevicePtrClause";
105110 : }
105111 :
105112 : // DQ (11/26/2005): Support for visitor pattern mechanims
105113 : // (inferior to ROSE traversal mechanism, experimental).
105114 : void
105115 0 : SgOmpIsDevicePtrClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
105116 : {
105117 0 : ROSE_ASSERT(this != NULL);
105118 0 : visitor.visit(this);
105119 0 : }
105120 :
105121 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
105122 0 : void SgOmpIsDevicePtrClause::accept (ROSE_VisitorPattern & visitor) {
105123 0 : ROSE_ASSERT(this != NULL);
105124 0 : visitor.visit(this);
105125 0 : }
105126 :
105127 : SgOmpIsDevicePtrClause*
105128 0 : SgOmpIsDevicePtrClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
105129 : {
105130 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
105131 : // This function is currently only supported for the AST used the represent Binary executables.
105132 : if (0 /* isSgAsmNode(this) != NULL */)
105133 : {
105134 : // Support for regex specification.
105135 : std::string prefixCode = "REGEX:";
105136 : addNewAttribute(prefixCode + s,a);
105137 : }
105138 : #endif
105139 :
105140 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
105141 0 : return this;
105142 : }
105143 :
105144 : // *** COMMON CODE SECTION ENDS HERE ***
105145 :
105146 :
105147 : // End of memberFunctionString
105148 : // Start of memberFunctionString
105149 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
105150 :
105151 :
105152 : #if 0
105153 : //! Error checking support
105154 : /*! Verifies the following:
105155 : - working getVariant() member function
105156 : - calls base class's error() member function
105157 : Every class has one of these functions.
105158 : */
105159 : bool
105160 : SgOmpIsDevicePtrClause::error()
105161 : {
105162 : // Put error checking here
105163 :
105164 : ROSE_ASSERT (this != NULL);
105165 : if (getVariant() != OmpIsDevicePtrClauseTag)
105166 : {
105167 : printf ("Error in SgOmpIsDevicePtrClause::error(): SgOmpIsDevicePtrClause object has a %s variant \n",
105168 : Cxx_GrammarTerminalNames[getVariant()].name);
105169 : // printf ("Error in SgOmpIsDevicePtrClause::error() \n");
105170 : ROSE_ABORT();
105171 : }
105172 :
105173 : ROSE_ASSERT (getVariant() == OmpIsDevicePtrClauseTag);
105174 : return SgOmpVariablesClause::error();
105175 : }
105176 : #endif
105177 :
105178 :
105179 :
105180 : // End of memberFunctionString
105181 :
105182 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
105183 :
105184 0 : SgOmpIsDevicePtrClause* isSgOmpIsDevicePtrClause ( SgNode* inputDerivedClassPointer )
105185 : {
105186 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105187 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105188 : // So to fix this we return NULL directly when the input is NULL and avoid the
105189 : // dynamic_cast in this case. This is likely a performance improvement as well.
105190 : // return dynamic_cast<SgOmpIsDevicePtrClause*>(inputDerivedClassPointer);
105191 : // Milind Chabbi (8/28/2013): isSgOmpIsDevicePtrClause uses table-driven castability instead of c++ default dynamic_cast
105192 : // this improves the running time performance by 10-20%.
105193 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpIsDevicePtrClause*>(inputDerivedClassPointer);
105194 0 : return IS_SgOmpIsDevicePtrClause_FAST_MACRO(inputDerivedClassPointer);
105195 : }
105196 :
105197 : // DQ (11/8/2003): Added version of functions taking const pointer
105198 0 : const SgOmpIsDevicePtrClause* isSgOmpIsDevicePtrClause ( const SgNode* inputDerivedClassPointer )
105199 : {
105200 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105201 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105202 : // So to fix this we return NULL directly when the input is NULL and avoid the
105203 : // dynamic_cast in this case. This is likely a performance improvement as well.
105204 : // return dynamic_cast<const SgOmpIsDevicePtrClause*>(inputDerivedClassPointer);
105205 : // Milind Chabbi (8/28/2013): isSgOmpIsDevicePtrClause uses table-driven castability instead of c++ default dynamic_cast
105206 : // this improves the running time performance by 10-20%.
105207 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpIsDevicePtrClause*>(inputDerivedClassPointer);
105208 0 : return IS_SgOmpIsDevicePtrClause_FAST_MACRO(inputDerivedClassPointer);
105209 : }
105210 :
105211 :
105212 :
105213 : /* #line 105214 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105214 :
105215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105216 :
105217 : /**
105218 : \brief Generated destructor
105219 :
105220 : This destructor is automatically generated (by ROSETTA). This destructor
105221 : only frees memory of data members associated with the parts of the current IR node which
105222 : are NOT traversed. Those data members that are part of a traversal can be freed using
105223 : a traversal (calling this destructor on all children in a post-order traversal). Such
105224 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
105225 :
105226 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
105227 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
105228 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
105229 :
105230 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
105231 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
105232 : pointers are not yet implemented to call delete on eash pointer in the container.
105233 : (This could be done by derivation from the STL containers to define containers that
105234 : automatically deleted their members.)
105235 :
105236 : */
105237 0 : SgOmpIsDevicePtrClause::~SgOmpIsDevicePtrClause () {
105238 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
105239 :
105240 :
105241 :
105242 : }
105243 :
105244 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105245 0 : }
105246 :
105247 :
105248 : /* #line 105249 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105249 :
105250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
105251 :
105252 : // Generated constructor
105253 0 : SgOmpIsDevicePtrClause::SgOmpIsDevicePtrClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
105254 0 : : SgOmpVariablesClause(startOfConstruct, variables)
105255 : {
105256 : #ifdef DEBUG
105257 : // printf ("In SgOmpIsDevicePtrClause::SgOmpIsDevicePtrClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
105258 : #endif
105259 : #if 0
105260 : // debugging information!
105261 : printf ("In SgOmpIsDevicePtrClause::SgOmpIsDevicePtrClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
105262 : #endif
105263 :
105264 :
105265 :
105266 : #if 0
105267 : // DQ (7/30/2014): Call a virtual function.
105268 : std::string s = this->class_name();
105269 : #endif
105270 :
105271 : // Test the variant virtual function
105272 : // assert(OmpIsDevicePtrClauseTag == variant());
105273 0 : assert(OmpIsDevicePtrClauseTag == this->variant());
105274 0 : ROSE_ASSERT(OmpIsDevicePtrClauseTag == (int)(this->variantT()));
105275 0 : post_construction_initialization();
105276 :
105277 : // Test the isSgOmpIsDevicePtrClause() function since it has been problematic
105278 0 : assert(isSgOmpIsDevicePtrClause(this) != NULL);
105279 0 : }
105280 :
105281 : // Generated constructor (all data members)
105282 :
105283 : /* #line 105284 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105284 :
105285 :
105286 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105287 :
105288 :
105289 : // ********************************************************
105290 : // member functions common across all array grammar objects
105291 : // ********************************************************
105292 :
105293 :
105294 :
105295 : /* #line 105296 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105296 :
105297 :
105298 :
105299 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105300 :
105301 : // ********************************************************
105302 : // member functions specific to each node in the grammar
105303 : // ********************************************************
105304 :
105305 :
105306 : /* #line 105307 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105307 :
105308 : // Start of memberFunctionString
105309 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
105310 :
105311 : // *** COMMON CODE SECTION BEGINS HERE ***
105312 :
105313 : #if 0
105314 : int
105315 : SgOmpUseDevicePtrClause::getVariant() const
105316 : {
105317 : // This function is used in ROSE while "variant()" is used in SAGE
105318 : assert(this != NULL);
105319 : return variant();
105320 : }
105321 : #endif
105322 :
105323 : // This function is used in ROSE in treeTraversal code
105324 : // eventually replaces getVariant() and variant()
105325 : // though after variant() has been removed for a while we will
105326 : // want to change the name of variantT() back to variant()
105327 : // (since the "T" was ment to stand for temporary).
105328 : // When this happens the variantT() will be depricated.
105329 : VariantT
105330 0 : SgOmpUseDevicePtrClause::variantT() const
105331 : {
105332 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
105333 0 : ROSE_ASSERT(this != NULL);
105334 0 : return V_SgOmpUseDevicePtrClause;
105335 : }
105336 :
105337 : #if 0
105338 : int
105339 : SgOmpUseDevicePtrClause::variant() const
105340 : {
105341 : // This function is used in SAGE
105342 : ROSE_ASSERT(this != NULL);
105343 : return OmpUseDevicePtrClauseTag;
105344 : }
105345 : #endif
105346 :
105347 : ROSE_DLL_API const char*
105348 0 : SgOmpUseDevicePtrClause::sage_class_name() const
105349 : {
105350 0 : ROSE_ASSERT(this != NULL);
105351 0 : return "SgOmpUseDevicePtrClause";
105352 : }
105353 :
105354 : std::string
105355 0 : SgOmpUseDevicePtrClause::class_name() const
105356 : {
105357 0 : ROSE_ASSERT(this != NULL);
105358 0 : return "SgOmpUseDevicePtrClause";
105359 : }
105360 :
105361 : // DQ (11/26/2005): Support for visitor pattern mechanims
105362 : // (inferior to ROSE traversal mechanism, experimental).
105363 : void
105364 0 : SgOmpUseDevicePtrClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
105365 : {
105366 0 : ROSE_ASSERT(this != NULL);
105367 0 : visitor.visit(this);
105368 0 : }
105369 :
105370 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
105371 0 : void SgOmpUseDevicePtrClause::accept (ROSE_VisitorPattern & visitor) {
105372 0 : ROSE_ASSERT(this != NULL);
105373 0 : visitor.visit(this);
105374 0 : }
105375 :
105376 : SgOmpUseDevicePtrClause*
105377 0 : SgOmpUseDevicePtrClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
105378 : {
105379 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
105380 : // This function is currently only supported for the AST used the represent Binary executables.
105381 : if (0 /* isSgAsmNode(this) != NULL */)
105382 : {
105383 : // Support for regex specification.
105384 : std::string prefixCode = "REGEX:";
105385 : addNewAttribute(prefixCode + s,a);
105386 : }
105387 : #endif
105388 :
105389 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
105390 0 : return this;
105391 : }
105392 :
105393 : // *** COMMON CODE SECTION ENDS HERE ***
105394 :
105395 :
105396 : // End of memberFunctionString
105397 : // Start of memberFunctionString
105398 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
105399 :
105400 :
105401 : #if 0
105402 : //! Error checking support
105403 : /*! Verifies the following:
105404 : - working getVariant() member function
105405 : - calls base class's error() member function
105406 : Every class has one of these functions.
105407 : */
105408 : bool
105409 : SgOmpUseDevicePtrClause::error()
105410 : {
105411 : // Put error checking here
105412 :
105413 : ROSE_ASSERT (this != NULL);
105414 : if (getVariant() != OmpUseDevicePtrClauseTag)
105415 : {
105416 : printf ("Error in SgOmpUseDevicePtrClause::error(): SgOmpUseDevicePtrClause object has a %s variant \n",
105417 : Cxx_GrammarTerminalNames[getVariant()].name);
105418 : // printf ("Error in SgOmpUseDevicePtrClause::error() \n");
105419 : ROSE_ABORT();
105420 : }
105421 :
105422 : ROSE_ASSERT (getVariant() == OmpUseDevicePtrClauseTag);
105423 : return SgOmpVariablesClause::error();
105424 : }
105425 : #endif
105426 :
105427 :
105428 :
105429 : // End of memberFunctionString
105430 :
105431 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
105432 :
105433 0 : SgOmpUseDevicePtrClause* isSgOmpUseDevicePtrClause ( SgNode* inputDerivedClassPointer )
105434 : {
105435 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105436 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105437 : // So to fix this we return NULL directly when the input is NULL and avoid the
105438 : // dynamic_cast in this case. This is likely a performance improvement as well.
105439 : // return dynamic_cast<SgOmpUseDevicePtrClause*>(inputDerivedClassPointer);
105440 : // Milind Chabbi (8/28/2013): isSgOmpUseDevicePtrClause uses table-driven castability instead of c++ default dynamic_cast
105441 : // this improves the running time performance by 10-20%.
105442 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUseDevicePtrClause*>(inputDerivedClassPointer);
105443 0 : return IS_SgOmpUseDevicePtrClause_FAST_MACRO(inputDerivedClassPointer);
105444 : }
105445 :
105446 : // DQ (11/8/2003): Added version of functions taking const pointer
105447 0 : const SgOmpUseDevicePtrClause* isSgOmpUseDevicePtrClause ( const SgNode* inputDerivedClassPointer )
105448 : {
105449 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105450 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105451 : // So to fix this we return NULL directly when the input is NULL and avoid the
105452 : // dynamic_cast in this case. This is likely a performance improvement as well.
105453 : // return dynamic_cast<const SgOmpUseDevicePtrClause*>(inputDerivedClassPointer);
105454 : // Milind Chabbi (8/28/2013): isSgOmpUseDevicePtrClause uses table-driven castability instead of c++ default dynamic_cast
105455 : // this improves the running time performance by 10-20%.
105456 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUseDevicePtrClause*>(inputDerivedClassPointer);
105457 0 : return IS_SgOmpUseDevicePtrClause_FAST_MACRO(inputDerivedClassPointer);
105458 : }
105459 :
105460 :
105461 :
105462 : /* #line 105463 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105463 :
105464 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105465 :
105466 : /**
105467 : \brief Generated destructor
105468 :
105469 : This destructor is automatically generated (by ROSETTA). This destructor
105470 : only frees memory of data members associated with the parts of the current IR node which
105471 : are NOT traversed. Those data members that are part of a traversal can be freed using
105472 : a traversal (calling this destructor on all children in a post-order traversal). Such
105473 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
105474 :
105475 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
105476 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
105477 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
105478 :
105479 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
105480 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
105481 : pointers are not yet implemented to call delete on eash pointer in the container.
105482 : (This could be done by derivation from the STL containers to define containers that
105483 : automatically deleted their members.)
105484 :
105485 : */
105486 0 : SgOmpUseDevicePtrClause::~SgOmpUseDevicePtrClause () {
105487 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
105488 :
105489 :
105490 :
105491 : }
105492 :
105493 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105494 0 : }
105495 :
105496 :
105497 : /* #line 105498 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105498 :
105499 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
105500 :
105501 : // Generated constructor
105502 0 : SgOmpUseDevicePtrClause::SgOmpUseDevicePtrClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
105503 0 : : SgOmpVariablesClause(startOfConstruct, variables)
105504 : {
105505 : #ifdef DEBUG
105506 : // printf ("In SgOmpUseDevicePtrClause::SgOmpUseDevicePtrClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
105507 : #endif
105508 : #if 0
105509 : // debugging information!
105510 : printf ("In SgOmpUseDevicePtrClause::SgOmpUseDevicePtrClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
105511 : #endif
105512 :
105513 :
105514 :
105515 : #if 0
105516 : // DQ (7/30/2014): Call a virtual function.
105517 : std::string s = this->class_name();
105518 : #endif
105519 :
105520 : // Test the variant virtual function
105521 : // assert(OmpUseDevicePtrClauseTag == variant());
105522 0 : assert(OmpUseDevicePtrClauseTag == this->variant());
105523 0 : ROSE_ASSERT(OmpUseDevicePtrClauseTag == (int)(this->variantT()));
105524 0 : post_construction_initialization();
105525 :
105526 : // Test the isSgOmpUseDevicePtrClause() function since it has been problematic
105527 0 : assert(isSgOmpUseDevicePtrClause(this) != NULL);
105528 0 : }
105529 :
105530 : // Generated constructor (all data members)
105531 :
105532 : /* #line 105533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105533 :
105534 :
105535 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105536 :
105537 :
105538 : // ********************************************************
105539 : // member functions common across all array grammar objects
105540 : // ********************************************************
105541 :
105542 :
105543 :
105544 : /* #line 105545 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105545 :
105546 :
105547 :
105548 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105549 :
105550 : // ********************************************************
105551 : // member functions specific to each node in the grammar
105552 : // ********************************************************
105553 :
105554 :
105555 : /* #line 105556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105556 :
105557 : // Start of memberFunctionString
105558 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
105559 :
105560 : // *** COMMON CODE SECTION BEGINS HERE ***
105561 :
105562 : #if 0
105563 : int
105564 : SgOmpUseDeviceAddrClause::getVariant() const
105565 : {
105566 : // This function is used in ROSE while "variant()" is used in SAGE
105567 : assert(this != NULL);
105568 : return variant();
105569 : }
105570 : #endif
105571 :
105572 : // This function is used in ROSE in treeTraversal code
105573 : // eventually replaces getVariant() and variant()
105574 : // though after variant() has been removed for a while we will
105575 : // want to change the name of variantT() back to variant()
105576 : // (since the "T" was ment to stand for temporary).
105577 : // When this happens the variantT() will be depricated.
105578 : VariantT
105579 0 : SgOmpUseDeviceAddrClause::variantT() const
105580 : {
105581 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
105582 0 : ROSE_ASSERT(this != NULL);
105583 0 : return V_SgOmpUseDeviceAddrClause;
105584 : }
105585 :
105586 : #if 0
105587 : int
105588 : SgOmpUseDeviceAddrClause::variant() const
105589 : {
105590 : // This function is used in SAGE
105591 : ROSE_ASSERT(this != NULL);
105592 : return OmpUseDeviceAddrClauseTag;
105593 : }
105594 : #endif
105595 :
105596 : ROSE_DLL_API const char*
105597 0 : SgOmpUseDeviceAddrClause::sage_class_name() const
105598 : {
105599 0 : ROSE_ASSERT(this != NULL);
105600 0 : return "SgOmpUseDeviceAddrClause";
105601 : }
105602 :
105603 : std::string
105604 0 : SgOmpUseDeviceAddrClause::class_name() const
105605 : {
105606 0 : ROSE_ASSERT(this != NULL);
105607 0 : return "SgOmpUseDeviceAddrClause";
105608 : }
105609 :
105610 : // DQ (11/26/2005): Support for visitor pattern mechanims
105611 : // (inferior to ROSE traversal mechanism, experimental).
105612 : void
105613 0 : SgOmpUseDeviceAddrClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
105614 : {
105615 0 : ROSE_ASSERT(this != NULL);
105616 0 : visitor.visit(this);
105617 0 : }
105618 :
105619 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
105620 0 : void SgOmpUseDeviceAddrClause::accept (ROSE_VisitorPattern & visitor) {
105621 0 : ROSE_ASSERT(this != NULL);
105622 0 : visitor.visit(this);
105623 0 : }
105624 :
105625 : SgOmpUseDeviceAddrClause*
105626 0 : SgOmpUseDeviceAddrClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
105627 : {
105628 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
105629 : // This function is currently only supported for the AST used the represent Binary executables.
105630 : if (0 /* isSgAsmNode(this) != NULL */)
105631 : {
105632 : // Support for regex specification.
105633 : std::string prefixCode = "REGEX:";
105634 : addNewAttribute(prefixCode + s,a);
105635 : }
105636 : #endif
105637 :
105638 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
105639 0 : return this;
105640 : }
105641 :
105642 : // *** COMMON CODE SECTION ENDS HERE ***
105643 :
105644 :
105645 : // End of memberFunctionString
105646 : // Start of memberFunctionString
105647 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
105648 :
105649 :
105650 : #if 0
105651 : //! Error checking support
105652 : /*! Verifies the following:
105653 : - working getVariant() member function
105654 : - calls base class's error() member function
105655 : Every class has one of these functions.
105656 : */
105657 : bool
105658 : SgOmpUseDeviceAddrClause::error()
105659 : {
105660 : // Put error checking here
105661 :
105662 : ROSE_ASSERT (this != NULL);
105663 : if (getVariant() != OmpUseDeviceAddrClauseTag)
105664 : {
105665 : printf ("Error in SgOmpUseDeviceAddrClause::error(): SgOmpUseDeviceAddrClause object has a %s variant \n",
105666 : Cxx_GrammarTerminalNames[getVariant()].name);
105667 : // printf ("Error in SgOmpUseDeviceAddrClause::error() \n");
105668 : ROSE_ABORT();
105669 : }
105670 :
105671 : ROSE_ASSERT (getVariant() == OmpUseDeviceAddrClauseTag);
105672 : return SgOmpVariablesClause::error();
105673 : }
105674 : #endif
105675 :
105676 :
105677 :
105678 : // End of memberFunctionString
105679 :
105680 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
105681 :
105682 0 : SgOmpUseDeviceAddrClause* isSgOmpUseDeviceAddrClause ( SgNode* inputDerivedClassPointer )
105683 : {
105684 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105685 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105686 : // So to fix this we return NULL directly when the input is NULL and avoid the
105687 : // dynamic_cast in this case. This is likely a performance improvement as well.
105688 : // return dynamic_cast<SgOmpUseDeviceAddrClause*>(inputDerivedClassPointer);
105689 : // Milind Chabbi (8/28/2013): isSgOmpUseDeviceAddrClause uses table-driven castability instead of c++ default dynamic_cast
105690 : // this improves the running time performance by 10-20%.
105691 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUseDeviceAddrClause*>(inputDerivedClassPointer);
105692 0 : return IS_SgOmpUseDeviceAddrClause_FAST_MACRO(inputDerivedClassPointer);
105693 : }
105694 :
105695 : // DQ (11/8/2003): Added version of functions taking const pointer
105696 0 : const SgOmpUseDeviceAddrClause* isSgOmpUseDeviceAddrClause ( const SgNode* inputDerivedClassPointer )
105697 : {
105698 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105699 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105700 : // So to fix this we return NULL directly when the input is NULL and avoid the
105701 : // dynamic_cast in this case. This is likely a performance improvement as well.
105702 : // return dynamic_cast<const SgOmpUseDeviceAddrClause*>(inputDerivedClassPointer);
105703 : // Milind Chabbi (8/28/2013): isSgOmpUseDeviceAddrClause uses table-driven castability instead of c++ default dynamic_cast
105704 : // this improves the running time performance by 10-20%.
105705 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUseDeviceAddrClause*>(inputDerivedClassPointer);
105706 0 : return IS_SgOmpUseDeviceAddrClause_FAST_MACRO(inputDerivedClassPointer);
105707 : }
105708 :
105709 :
105710 :
105711 : /* #line 105712 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105712 :
105713 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105714 :
105715 : /**
105716 : \brief Generated destructor
105717 :
105718 : This destructor is automatically generated (by ROSETTA). This destructor
105719 : only frees memory of data members associated with the parts of the current IR node which
105720 : are NOT traversed. Those data members that are part of a traversal can be freed using
105721 : a traversal (calling this destructor on all children in a post-order traversal). Such
105722 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
105723 :
105724 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
105725 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
105726 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
105727 :
105728 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
105729 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
105730 : pointers are not yet implemented to call delete on eash pointer in the container.
105731 : (This could be done by derivation from the STL containers to define containers that
105732 : automatically deleted their members.)
105733 :
105734 : */
105735 0 : SgOmpUseDeviceAddrClause::~SgOmpUseDeviceAddrClause () {
105736 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
105737 :
105738 :
105739 :
105740 : }
105741 :
105742 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105743 0 : }
105744 :
105745 :
105746 : /* #line 105747 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105747 :
105748 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
105749 :
105750 : // Generated constructor
105751 0 : SgOmpUseDeviceAddrClause::SgOmpUseDeviceAddrClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
105752 0 : : SgOmpVariablesClause(startOfConstruct, variables)
105753 : {
105754 : #ifdef DEBUG
105755 : // printf ("In SgOmpUseDeviceAddrClause::SgOmpUseDeviceAddrClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
105756 : #endif
105757 : #if 0
105758 : // debugging information!
105759 : printf ("In SgOmpUseDeviceAddrClause::SgOmpUseDeviceAddrClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
105760 : #endif
105761 :
105762 :
105763 :
105764 : #if 0
105765 : // DQ (7/30/2014): Call a virtual function.
105766 : std::string s = this->class_name();
105767 : #endif
105768 :
105769 : // Test the variant virtual function
105770 : // assert(OmpUseDeviceAddrClauseTag == variant());
105771 0 : assert(OmpUseDeviceAddrClauseTag == this->variant());
105772 0 : ROSE_ASSERT(OmpUseDeviceAddrClauseTag == (int)(this->variantT()));
105773 0 : post_construction_initialization();
105774 :
105775 : // Test the isSgOmpUseDeviceAddrClause() function since it has been problematic
105776 0 : assert(isSgOmpUseDeviceAddrClause(this) != NULL);
105777 0 : }
105778 :
105779 : // Generated constructor (all data members)
105780 :
105781 : /* #line 105782 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105782 :
105783 :
105784 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105785 :
105786 :
105787 : // ********************************************************
105788 : // member functions common across all array grammar objects
105789 : // ********************************************************
105790 :
105791 :
105792 :
105793 : /* #line 105794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105794 :
105795 :
105796 :
105797 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
105798 :
105799 : // ********************************************************
105800 : // member functions specific to each node in the grammar
105801 : // ********************************************************
105802 :
105803 :
105804 : /* #line 105805 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105805 :
105806 : // Start of memberFunctionString
105807 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
105808 :
105809 : // *** COMMON CODE SECTION BEGINS HERE ***
105810 :
105811 : #if 0
105812 : int
105813 : SgOmpSharedClause::getVariant() const
105814 : {
105815 : // This function is used in ROSE while "variant()" is used in SAGE
105816 : assert(this != NULL);
105817 : return variant();
105818 : }
105819 : #endif
105820 :
105821 : // This function is used in ROSE in treeTraversal code
105822 : // eventually replaces getVariant() and variant()
105823 : // though after variant() has been removed for a while we will
105824 : // want to change the name of variantT() back to variant()
105825 : // (since the "T" was ment to stand for temporary).
105826 : // When this happens the variantT() will be depricated.
105827 : VariantT
105828 3014 : SgOmpSharedClause::variantT() const
105829 : {
105830 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
105831 3014 : ROSE_ASSERT(this != NULL);
105832 3014 : return V_SgOmpSharedClause;
105833 : }
105834 :
105835 : #if 0
105836 : int
105837 : SgOmpSharedClause::variant() const
105838 : {
105839 : // This function is used in SAGE
105840 : ROSE_ASSERT(this != NULL);
105841 : return OmpSharedClauseTag;
105842 : }
105843 : #endif
105844 :
105845 : ROSE_DLL_API const char*
105846 0 : SgOmpSharedClause::sage_class_name() const
105847 : {
105848 0 : ROSE_ASSERT(this != NULL);
105849 0 : return "SgOmpSharedClause";
105850 : }
105851 :
105852 : std::string
105853 51 : SgOmpSharedClause::class_name() const
105854 : {
105855 51 : ROSE_ASSERT(this != NULL);
105856 51 : return "SgOmpSharedClause";
105857 : }
105858 :
105859 : // DQ (11/26/2005): Support for visitor pattern mechanims
105860 : // (inferior to ROSE traversal mechanism, experimental).
105861 : void
105862 0 : SgOmpSharedClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
105863 : {
105864 0 : ROSE_ASSERT(this != NULL);
105865 0 : visitor.visit(this);
105866 0 : }
105867 :
105868 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
105869 0 : void SgOmpSharedClause::accept (ROSE_VisitorPattern & visitor) {
105870 0 : ROSE_ASSERT(this != NULL);
105871 0 : visitor.visit(this);
105872 0 : }
105873 :
105874 : SgOmpSharedClause*
105875 0 : SgOmpSharedClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
105876 : {
105877 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
105878 : // This function is currently only supported for the AST used the represent Binary executables.
105879 : if (0 /* isSgAsmNode(this) != NULL */)
105880 : {
105881 : // Support for regex specification.
105882 : std::string prefixCode = "REGEX:";
105883 : addNewAttribute(prefixCode + s,a);
105884 : }
105885 : #endif
105886 :
105887 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
105888 0 : return this;
105889 : }
105890 :
105891 : // *** COMMON CODE SECTION ENDS HERE ***
105892 :
105893 :
105894 : // End of memberFunctionString
105895 : // Start of memberFunctionString
105896 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
105897 :
105898 :
105899 : #if 0
105900 : //! Error checking support
105901 : /*! Verifies the following:
105902 : - working getVariant() member function
105903 : - calls base class's error() member function
105904 : Every class has one of these functions.
105905 : */
105906 : bool
105907 : SgOmpSharedClause::error()
105908 : {
105909 : // Put error checking here
105910 :
105911 : ROSE_ASSERT (this != NULL);
105912 : if (getVariant() != OmpSharedClauseTag)
105913 : {
105914 : printf ("Error in SgOmpSharedClause::error(): SgOmpSharedClause object has a %s variant \n",
105915 : Cxx_GrammarTerminalNames[getVariant()].name);
105916 : // printf ("Error in SgOmpSharedClause::error() \n");
105917 : ROSE_ABORT();
105918 : }
105919 :
105920 : ROSE_ASSERT (getVariant() == OmpSharedClauseTag);
105921 : return SgOmpVariablesClause::error();
105922 : }
105923 : #endif
105924 :
105925 :
105926 :
105927 : // End of memberFunctionString
105928 :
105929 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
105930 :
105931 51 : SgOmpSharedClause* isSgOmpSharedClause ( SgNode* inputDerivedClassPointer )
105932 : {
105933 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105934 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105935 : // So to fix this we return NULL directly when the input is NULL and avoid the
105936 : // dynamic_cast in this case. This is likely a performance improvement as well.
105937 : // return dynamic_cast<SgOmpSharedClause*>(inputDerivedClassPointer);
105938 : // Milind Chabbi (8/28/2013): isSgOmpSharedClause uses table-driven castability instead of c++ default dynamic_cast
105939 : // this improves the running time performance by 10-20%.
105940 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSharedClause*>(inputDerivedClassPointer);
105941 51 : return IS_SgOmpSharedClause_FAST_MACRO(inputDerivedClassPointer);
105942 : }
105943 :
105944 : // DQ (11/8/2003): Added version of functions taking const pointer
105945 0 : const SgOmpSharedClause* isSgOmpSharedClause ( const SgNode* inputDerivedClassPointer )
105946 : {
105947 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
105948 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
105949 : // So to fix this we return NULL directly when the input is NULL and avoid the
105950 : // dynamic_cast in this case. This is likely a performance improvement as well.
105951 : // return dynamic_cast<const SgOmpSharedClause*>(inputDerivedClassPointer);
105952 : // Milind Chabbi (8/28/2013): isSgOmpSharedClause uses table-driven castability instead of c++ default dynamic_cast
105953 : // this improves the running time performance by 10-20%.
105954 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSharedClause*>(inputDerivedClassPointer);
105955 0 : return IS_SgOmpSharedClause_FAST_MACRO(inputDerivedClassPointer);
105956 : }
105957 :
105958 :
105959 :
105960 : /* #line 105961 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105961 :
105962 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105963 :
105964 : /**
105965 : \brief Generated destructor
105966 :
105967 : This destructor is automatically generated (by ROSETTA). This destructor
105968 : only frees memory of data members associated with the parts of the current IR node which
105969 : are NOT traversed. Those data members that are part of a traversal can be freed using
105970 : a traversal (calling this destructor on all children in a post-order traversal). Such
105971 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
105972 :
105973 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
105974 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
105975 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
105976 :
105977 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
105978 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
105979 : pointers are not yet implemented to call delete on eash pointer in the container.
105980 : (This could be done by derivation from the STL containers to define containers that
105981 : automatically deleted their members.)
105982 :
105983 : */
105984 0 : SgOmpSharedClause::~SgOmpSharedClause () {
105985 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
105986 :
105987 :
105988 :
105989 : }
105990 :
105991 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
105992 0 : }
105993 :
105994 :
105995 : /* #line 105996 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
105996 :
105997 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
105998 :
105999 : // Generated constructor
106000 0 : SgOmpSharedClause::SgOmpSharedClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
106001 0 : : SgOmpVariablesClause(startOfConstruct, variables)
106002 : {
106003 : #ifdef DEBUG
106004 : // printf ("In SgOmpSharedClause::SgOmpSharedClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
106005 : #endif
106006 : #if 0
106007 : // debugging information!
106008 : printf ("In SgOmpSharedClause::SgOmpSharedClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
106009 : #endif
106010 :
106011 :
106012 :
106013 : #if 0
106014 : // DQ (7/30/2014): Call a virtual function.
106015 : std::string s = this->class_name();
106016 : #endif
106017 :
106018 : // Test the variant virtual function
106019 : // assert(OmpSharedClauseTag == variant());
106020 0 : assert(OmpSharedClauseTag == this->variant());
106021 0 : ROSE_ASSERT(OmpSharedClauseTag == (int)(this->variantT()));
106022 0 : post_construction_initialization();
106023 :
106024 : // Test the isSgOmpSharedClause() function since it has been problematic
106025 0 : assert(isSgOmpSharedClause(this) != NULL);
106026 0 : }
106027 :
106028 : // Generated constructor (all data members)
106029 :
106030 : /* #line 106031 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106031 :
106032 :
106033 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106034 :
106035 :
106036 : // ********************************************************
106037 : // member functions common across all array grammar objects
106038 : // ********************************************************
106039 :
106040 :
106041 :
106042 : /* #line 106043 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106043 :
106044 :
106045 :
106046 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106047 :
106048 : // ********************************************************
106049 : // member functions specific to each node in the grammar
106050 : // ********************************************************
106051 :
106052 :
106053 : /* #line 106054 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106054 :
106055 : // Start of memberFunctionString
106056 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
106057 :
106058 : // *** COMMON CODE SECTION BEGINS HERE ***
106059 :
106060 : #if 0
106061 : int
106062 : SgOmpCopyinClause::getVariant() const
106063 : {
106064 : // This function is used in ROSE while "variant()" is used in SAGE
106065 : assert(this != NULL);
106066 : return variant();
106067 : }
106068 : #endif
106069 :
106070 : // This function is used in ROSE in treeTraversal code
106071 : // eventually replaces getVariant() and variant()
106072 : // though after variant() has been removed for a while we will
106073 : // want to change the name of variantT() back to variant()
106074 : // (since the "T" was ment to stand for temporary).
106075 : // When this happens the variantT() will be depricated.
106076 : VariantT
106077 58 : SgOmpCopyinClause::variantT() const
106078 : {
106079 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
106080 58 : ROSE_ASSERT(this != NULL);
106081 58 : return V_SgOmpCopyinClause;
106082 : }
106083 :
106084 : #if 0
106085 : int
106086 : SgOmpCopyinClause::variant() const
106087 : {
106088 : // This function is used in SAGE
106089 : ROSE_ASSERT(this != NULL);
106090 : return OmpCopyinClauseTag;
106091 : }
106092 : #endif
106093 :
106094 : ROSE_DLL_API const char*
106095 0 : SgOmpCopyinClause::sage_class_name() const
106096 : {
106097 0 : ROSE_ASSERT(this != NULL);
106098 0 : return "SgOmpCopyinClause";
106099 : }
106100 :
106101 : std::string
106102 1 : SgOmpCopyinClause::class_name() const
106103 : {
106104 1 : ROSE_ASSERT(this != NULL);
106105 1 : return "SgOmpCopyinClause";
106106 : }
106107 :
106108 : // DQ (11/26/2005): Support for visitor pattern mechanims
106109 : // (inferior to ROSE traversal mechanism, experimental).
106110 : void
106111 0 : SgOmpCopyinClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
106112 : {
106113 0 : ROSE_ASSERT(this != NULL);
106114 0 : visitor.visit(this);
106115 0 : }
106116 :
106117 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
106118 0 : void SgOmpCopyinClause::accept (ROSE_VisitorPattern & visitor) {
106119 0 : ROSE_ASSERT(this != NULL);
106120 0 : visitor.visit(this);
106121 0 : }
106122 :
106123 : SgOmpCopyinClause*
106124 0 : SgOmpCopyinClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
106125 : {
106126 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
106127 : // This function is currently only supported for the AST used the represent Binary executables.
106128 : if (0 /* isSgAsmNode(this) != NULL */)
106129 : {
106130 : // Support for regex specification.
106131 : std::string prefixCode = "REGEX:";
106132 : addNewAttribute(prefixCode + s,a);
106133 : }
106134 : #endif
106135 :
106136 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
106137 0 : return this;
106138 : }
106139 :
106140 : // *** COMMON CODE SECTION ENDS HERE ***
106141 :
106142 :
106143 : // End of memberFunctionString
106144 : // Start of memberFunctionString
106145 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
106146 :
106147 :
106148 : #if 0
106149 : //! Error checking support
106150 : /*! Verifies the following:
106151 : - working getVariant() member function
106152 : - calls base class's error() member function
106153 : Every class has one of these functions.
106154 : */
106155 : bool
106156 : SgOmpCopyinClause::error()
106157 : {
106158 : // Put error checking here
106159 :
106160 : ROSE_ASSERT (this != NULL);
106161 : if (getVariant() != OmpCopyinClauseTag)
106162 : {
106163 : printf ("Error in SgOmpCopyinClause::error(): SgOmpCopyinClause object has a %s variant \n",
106164 : Cxx_GrammarTerminalNames[getVariant()].name);
106165 : // printf ("Error in SgOmpCopyinClause::error() \n");
106166 : ROSE_ABORT();
106167 : }
106168 :
106169 : ROSE_ASSERT (getVariant() == OmpCopyinClauseTag);
106170 : return SgOmpVariablesClause::error();
106171 : }
106172 : #endif
106173 :
106174 :
106175 :
106176 : // End of memberFunctionString
106177 :
106178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
106179 :
106180 1 : SgOmpCopyinClause* isSgOmpCopyinClause ( SgNode* inputDerivedClassPointer )
106181 : {
106182 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
106183 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
106184 : // So to fix this we return NULL directly when the input is NULL and avoid the
106185 : // dynamic_cast in this case. This is likely a performance improvement as well.
106186 : // return dynamic_cast<SgOmpCopyinClause*>(inputDerivedClassPointer);
106187 : // Milind Chabbi (8/28/2013): isSgOmpCopyinClause uses table-driven castability instead of c++ default dynamic_cast
106188 : // this improves the running time performance by 10-20%.
106189 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCopyinClause*>(inputDerivedClassPointer);
106190 1 : return IS_SgOmpCopyinClause_FAST_MACRO(inputDerivedClassPointer);
106191 : }
106192 :
106193 : // DQ (11/8/2003): Added version of functions taking const pointer
106194 0 : const SgOmpCopyinClause* isSgOmpCopyinClause ( const SgNode* inputDerivedClassPointer )
106195 : {
106196 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
106197 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
106198 : // So to fix this we return NULL directly when the input is NULL and avoid the
106199 : // dynamic_cast in this case. This is likely a performance improvement as well.
106200 : // return dynamic_cast<const SgOmpCopyinClause*>(inputDerivedClassPointer);
106201 : // Milind Chabbi (8/28/2013): isSgOmpCopyinClause uses table-driven castability instead of c++ default dynamic_cast
106202 : // this improves the running time performance by 10-20%.
106203 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCopyinClause*>(inputDerivedClassPointer);
106204 0 : return IS_SgOmpCopyinClause_FAST_MACRO(inputDerivedClassPointer);
106205 : }
106206 :
106207 :
106208 :
106209 : /* #line 106210 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106210 :
106211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
106212 :
106213 : /**
106214 : \brief Generated destructor
106215 :
106216 : This destructor is automatically generated (by ROSETTA). This destructor
106217 : only frees memory of data members associated with the parts of the current IR node which
106218 : are NOT traversed. Those data members that are part of a traversal can be freed using
106219 : a traversal (calling this destructor on all children in a post-order traversal). Such
106220 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
106221 :
106222 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
106223 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
106224 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
106225 :
106226 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
106227 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
106228 : pointers are not yet implemented to call delete on eash pointer in the container.
106229 : (This could be done by derivation from the STL containers to define containers that
106230 : automatically deleted their members.)
106231 :
106232 : */
106233 0 : SgOmpCopyinClause::~SgOmpCopyinClause () {
106234 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
106235 :
106236 :
106237 :
106238 : }
106239 :
106240 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
106241 0 : }
106242 :
106243 :
106244 : /* #line 106245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106245 :
106246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
106247 :
106248 : // Generated constructor
106249 0 : SgOmpCopyinClause::SgOmpCopyinClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
106250 0 : : SgOmpVariablesClause(startOfConstruct, variables)
106251 : {
106252 : #ifdef DEBUG
106253 : // printf ("In SgOmpCopyinClause::SgOmpCopyinClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
106254 : #endif
106255 : #if 0
106256 : // debugging information!
106257 : printf ("In SgOmpCopyinClause::SgOmpCopyinClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
106258 : #endif
106259 :
106260 :
106261 :
106262 : #if 0
106263 : // DQ (7/30/2014): Call a virtual function.
106264 : std::string s = this->class_name();
106265 : #endif
106266 :
106267 : // Test the variant virtual function
106268 : // assert(OmpCopyinClauseTag == variant());
106269 0 : assert(OmpCopyinClauseTag == this->variant());
106270 0 : ROSE_ASSERT(OmpCopyinClauseTag == (int)(this->variantT()));
106271 0 : post_construction_initialization();
106272 :
106273 : // Test the isSgOmpCopyinClause() function since it has been problematic
106274 0 : assert(isSgOmpCopyinClause(this) != NULL);
106275 0 : }
106276 :
106277 : // Generated constructor (all data members)
106278 :
106279 : /* #line 106280 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106280 :
106281 :
106282 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106283 :
106284 :
106285 : // ********************************************************
106286 : // member functions common across all array grammar objects
106287 : // ********************************************************
106288 :
106289 :
106290 :
106291 : /* #line 106292 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106292 :
106293 :
106294 :
106295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106296 :
106297 : // ********************************************************
106298 : // member functions specific to each node in the grammar
106299 : // ********************************************************
106300 :
106301 :
106302 : /* #line 106303 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106303 :
106304 : // Start of memberFunctionString
106305 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
106306 :
106307 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
106308 :
106309 : SgOmpClause::omp_lastprivate_modifier_enum
106310 14 : SgOmpLastprivateClause::get_modifier () const
106311 : {
106312 14 : ROSE_ASSERT (this != NULL);
106313 :
106314 : #if 0
106315 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106316 : // used to trigger marking transformations for the token-based unparsing.
106317 : printf ("SgOmpLastprivateClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
106318 : #endif
106319 :
106320 14 : return p_modifier;
106321 : }
106322 :
106323 : void
106324 0 : SgOmpLastprivateClause::set_modifier ( SgOmpClause::omp_lastprivate_modifier_enum modifier )
106325 : {
106326 0 : ROSE_ASSERT (this != NULL);
106327 :
106328 : #if 0
106329 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106330 : // used to trigger marking transformations for the token-based unparsing.
106331 : printf ("SgOmpLastprivateClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
106332 : #endif
106333 :
106334 0 : set_isModified(true);
106335 :
106336 0 : p_modifier = modifier;
106337 0 : }
106338 :
106339 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
106340 :
106341 :
106342 : // End of memberFunctionString
106343 : // Start of memberFunctionString
106344 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
106345 :
106346 : // *** COMMON CODE SECTION BEGINS HERE ***
106347 :
106348 : #if 0
106349 : int
106350 : SgOmpLastprivateClause::getVariant() const
106351 : {
106352 : // This function is used in ROSE while "variant()" is used in SAGE
106353 : assert(this != NULL);
106354 : return variant();
106355 : }
106356 : #endif
106357 :
106358 : // This function is used in ROSE in treeTraversal code
106359 : // eventually replaces getVariant() and variant()
106360 : // though after variant() has been removed for a while we will
106361 : // want to change the name of variantT() back to variant()
106362 : // (since the "T" was ment to stand for temporary).
106363 : // When this happens the variantT() will be depricated.
106364 : VariantT
106365 580 : SgOmpLastprivateClause::variantT() const
106366 : {
106367 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
106368 580 : ROSE_ASSERT(this != NULL);
106369 580 : return V_SgOmpLastprivateClause;
106370 : }
106371 :
106372 : #if 0
106373 : int
106374 : SgOmpLastprivateClause::variant() const
106375 : {
106376 : // This function is used in SAGE
106377 : ROSE_ASSERT(this != NULL);
106378 : return OmpLastprivateClauseTag;
106379 : }
106380 : #endif
106381 :
106382 : ROSE_DLL_API const char*
106383 0 : SgOmpLastprivateClause::sage_class_name() const
106384 : {
106385 0 : ROSE_ASSERT(this != NULL);
106386 0 : return "SgOmpLastprivateClause";
106387 : }
106388 :
106389 : std::string
106390 14 : SgOmpLastprivateClause::class_name() const
106391 : {
106392 14 : ROSE_ASSERT(this != NULL);
106393 14 : return "SgOmpLastprivateClause";
106394 : }
106395 :
106396 : // DQ (11/26/2005): Support for visitor pattern mechanims
106397 : // (inferior to ROSE traversal mechanism, experimental).
106398 : void
106399 0 : SgOmpLastprivateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
106400 : {
106401 0 : ROSE_ASSERT(this != NULL);
106402 0 : visitor.visit(this);
106403 0 : }
106404 :
106405 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
106406 0 : void SgOmpLastprivateClause::accept (ROSE_VisitorPattern & visitor) {
106407 0 : ROSE_ASSERT(this != NULL);
106408 0 : visitor.visit(this);
106409 0 : }
106410 :
106411 : SgOmpLastprivateClause*
106412 0 : SgOmpLastprivateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
106413 : {
106414 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
106415 : // This function is currently only supported for the AST used the represent Binary executables.
106416 : if (0 /* isSgAsmNode(this) != NULL */)
106417 : {
106418 : // Support for regex specification.
106419 : std::string prefixCode = "REGEX:";
106420 : addNewAttribute(prefixCode + s,a);
106421 : }
106422 : #endif
106423 :
106424 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
106425 0 : return this;
106426 : }
106427 :
106428 : // *** COMMON CODE SECTION ENDS HERE ***
106429 :
106430 :
106431 : // End of memberFunctionString
106432 : // Start of memberFunctionString
106433 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
106434 :
106435 :
106436 : #if 0
106437 : //! Error checking support
106438 : /*! Verifies the following:
106439 : - working getVariant() member function
106440 : - calls base class's error() member function
106441 : Every class has one of these functions.
106442 : */
106443 : bool
106444 : SgOmpLastprivateClause::error()
106445 : {
106446 : // Put error checking here
106447 :
106448 : ROSE_ASSERT (this != NULL);
106449 : if (getVariant() != OmpLastprivateClauseTag)
106450 : {
106451 : printf ("Error in SgOmpLastprivateClause::error(): SgOmpLastprivateClause object has a %s variant \n",
106452 : Cxx_GrammarTerminalNames[getVariant()].name);
106453 : // printf ("Error in SgOmpLastprivateClause::error() \n");
106454 : ROSE_ABORT();
106455 : }
106456 :
106457 : ROSE_ASSERT (getVariant() == OmpLastprivateClauseTag);
106458 : return SgOmpVariablesClause::error();
106459 : }
106460 : #endif
106461 :
106462 :
106463 :
106464 : // End of memberFunctionString
106465 :
106466 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
106467 :
106468 28 : SgOmpLastprivateClause* isSgOmpLastprivateClause ( SgNode* inputDerivedClassPointer )
106469 : {
106470 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
106471 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
106472 : // So to fix this we return NULL directly when the input is NULL and avoid the
106473 : // dynamic_cast in this case. This is likely a performance improvement as well.
106474 : // return dynamic_cast<SgOmpLastprivateClause*>(inputDerivedClassPointer);
106475 : // Milind Chabbi (8/28/2013): isSgOmpLastprivateClause uses table-driven castability instead of c++ default dynamic_cast
106476 : // this improves the running time performance by 10-20%.
106477 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpLastprivateClause*>(inputDerivedClassPointer);
106478 28 : return IS_SgOmpLastprivateClause_FAST_MACRO(inputDerivedClassPointer);
106479 : }
106480 :
106481 : // DQ (11/8/2003): Added version of functions taking const pointer
106482 0 : const SgOmpLastprivateClause* isSgOmpLastprivateClause ( const SgNode* inputDerivedClassPointer )
106483 : {
106484 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
106485 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
106486 : // So to fix this we return NULL directly when the input is NULL and avoid the
106487 : // dynamic_cast in this case. This is likely a performance improvement as well.
106488 : // return dynamic_cast<const SgOmpLastprivateClause*>(inputDerivedClassPointer);
106489 : // Milind Chabbi (8/28/2013): isSgOmpLastprivateClause uses table-driven castability instead of c++ default dynamic_cast
106490 : // this improves the running time performance by 10-20%.
106491 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpLastprivateClause*>(inputDerivedClassPointer);
106492 0 : return IS_SgOmpLastprivateClause_FAST_MACRO(inputDerivedClassPointer);
106493 : }
106494 :
106495 :
106496 :
106497 : /* #line 106498 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106498 :
106499 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
106500 :
106501 : /**
106502 : \brief Generated destructor
106503 :
106504 : This destructor is automatically generated (by ROSETTA). This destructor
106505 : only frees memory of data members associated with the parts of the current IR node which
106506 : are NOT traversed. Those data members that are part of a traversal can be freed using
106507 : a traversal (calling this destructor on all children in a post-order traversal). Such
106508 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
106509 :
106510 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
106511 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
106512 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
106513 :
106514 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
106515 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
106516 : pointers are not yet implemented to call delete on eash pointer in the container.
106517 : (This could be done by derivation from the STL containers to define containers that
106518 : automatically deleted their members.)
106519 :
106520 : */
106521 0 : SgOmpLastprivateClause::~SgOmpLastprivateClause () {
106522 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
106523 :
106524 :
106525 : // case: not a listType for modifier
106526 0 : p_modifier =e_omp_lastprivate_modifier_unspecified; // non list case
106527 :
106528 : }
106529 :
106530 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
106531 0 : }
106532 :
106533 :
106534 : /* #line 106535 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106535 :
106536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
106537 :
106538 : // Generated constructor
106539 0 : SgOmpLastprivateClause::SgOmpLastprivateClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_lastprivate_modifier_enum modifier )
106540 0 : : SgOmpVariablesClause(startOfConstruct, variables)
106541 : {
106542 : #ifdef DEBUG
106543 : // printf ("In SgOmpLastprivateClause::SgOmpLastprivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_lastprivate_modifier_enum modifier) sage_class_name() = %s \n",sage_class_name());
106544 : #endif
106545 : #if 0
106546 : // debugging information!
106547 : printf ("In SgOmpLastprivateClause::SgOmpLastprivateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_lastprivate_modifier_enum modifier): this = %p = %s \n",this,this->class_name().c_str());
106548 : #endif
106549 :
106550 0 : p_modifier = modifier;
106551 :
106552 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
106553 :
106554 : #if 0
106555 : // DQ (7/30/2014): Call a virtual function.
106556 : std::string s = this->class_name();
106557 : #endif
106558 :
106559 : // Test the variant virtual function
106560 : // assert(OmpLastprivateClauseTag == variant());
106561 0 : assert(OmpLastprivateClauseTag == this->variant());
106562 0 : ROSE_ASSERT(OmpLastprivateClauseTag == (int)(this->variantT()));
106563 0 : post_construction_initialization();
106564 :
106565 : // Test the isSgOmpLastprivateClause() function since it has been problematic
106566 0 : assert(isSgOmpLastprivateClause(this) != NULL);
106567 0 : }
106568 :
106569 : // Generated constructor (all data members)
106570 :
106571 : /* #line 106572 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106572 :
106573 :
106574 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106575 :
106576 :
106577 : // ********************************************************
106578 : // member functions common across all array grammar objects
106579 : // ********************************************************
106580 :
106581 :
106582 :
106583 : /* #line 106584 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106584 :
106585 :
106586 :
106587 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106588 :
106589 : // ********************************************************
106590 : // member functions specific to each node in the grammar
106591 : // ********************************************************
106592 :
106593 :
106594 : /* #line 106595 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106595 :
106596 : // Start of memberFunctionString
106597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
106598 :
106599 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
106600 :
106601 : SgOmpClause::omp_reduction_modifier_enum
106602 89 : SgOmpReductionClause::get_modifier () const
106603 : {
106604 89 : ROSE_ASSERT (this != NULL);
106605 :
106606 : #if 0
106607 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106608 : // used to trigger marking transformations for the token-based unparsing.
106609 : printf ("SgOmpReductionClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
106610 : #endif
106611 :
106612 89 : return p_modifier;
106613 : }
106614 :
106615 : void
106616 0 : SgOmpReductionClause::set_modifier ( SgOmpClause::omp_reduction_modifier_enum modifier )
106617 : {
106618 0 : ROSE_ASSERT (this != NULL);
106619 :
106620 : #if 0
106621 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106622 : // used to trigger marking transformations for the token-based unparsing.
106623 : printf ("SgOmpReductionClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
106624 : #endif
106625 :
106626 0 : set_isModified(true);
106627 :
106628 0 : p_modifier = modifier;
106629 0 : }
106630 :
106631 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
106632 :
106633 :
106634 : // End of memberFunctionString
106635 : // Start of memberFunctionString
106636 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
106637 :
106638 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
106639 :
106640 : SgOmpClause::omp_reduction_identifier_enum
106641 89 : SgOmpReductionClause::get_identifier () const
106642 : {
106643 89 : ROSE_ASSERT (this != NULL);
106644 :
106645 : #if 0
106646 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106647 : // used to trigger marking transformations for the token-based unparsing.
106648 : printf ("SgOmpReductionClause::get_identifier = %p = %s \n",this,this->class_name().c_str());
106649 : #endif
106650 :
106651 89 : return p_identifier;
106652 : }
106653 :
106654 : void
106655 0 : SgOmpReductionClause::set_identifier ( SgOmpClause::omp_reduction_identifier_enum identifier )
106656 : {
106657 0 : ROSE_ASSERT (this != NULL);
106658 :
106659 : #if 0
106660 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106661 : // used to trigger marking transformations for the token-based unparsing.
106662 : printf ("SgOmpReductionClause::set_identifier = %p = %s \n",this,this->class_name().c_str());
106663 : #endif
106664 :
106665 0 : set_isModified(true);
106666 :
106667 0 : p_identifier = identifier;
106668 0 : }
106669 :
106670 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
106671 :
106672 :
106673 : // End of memberFunctionString
106674 : // Start of memberFunctionString
106675 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
106676 :
106677 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
106678 :
106679 : SgExpression*
106680 3 : SgOmpReductionClause::get_user_defined_identifier () const
106681 : {
106682 3 : ROSE_ASSERT (this != NULL);
106683 :
106684 : #if 0
106685 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106686 : // used to trigger marking transformations for the token-based unparsing.
106687 : printf ("SgOmpReductionClause::get_user_defined_identifier = %p = %s \n",this,this->class_name().c_str());
106688 : #endif
106689 :
106690 3 : return p_user_defined_identifier;
106691 : }
106692 :
106693 : void
106694 0 : SgOmpReductionClause::set_user_defined_identifier ( SgExpression* user_defined_identifier )
106695 : {
106696 0 : ROSE_ASSERT (this != NULL);
106697 :
106698 : #if 0
106699 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106700 : // used to trigger marking transformations for the token-based unparsing.
106701 : printf ("SgOmpReductionClause::set_user_defined_identifier = %p = %s \n",this,this->class_name().c_str());
106702 : #endif
106703 :
106704 0 : set_isModified(true);
106705 :
106706 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
106707 : if (p_user_defined_identifier != NULL && user_defined_identifier != NULL && p_user_defined_identifier != user_defined_identifier)
106708 : {
106709 : printf ("Warning: user_defined_identifier = %p overwriting valid pointer p_user_defined_identifier = %p \n",user_defined_identifier,p_user_defined_identifier);
106710 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
106711 : printf ("Error fails assertion (p_user_defined_identifier != NULL && user_defined_identifier != NULL && p_user_defined_identifier != user_defined_identifier) is false\n");
106712 : ROSE_ASSERT(false);
106713 : #endif
106714 : }
106715 : #endif
106716 0 : p_user_defined_identifier = user_defined_identifier;
106717 0 : }
106718 :
106719 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
106720 :
106721 :
106722 : // End of memberFunctionString
106723 : // Start of memberFunctionString
106724 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
106725 :
106726 : // *** COMMON CODE SECTION BEGINS HERE ***
106727 :
106728 : #if 0
106729 : int
106730 : SgOmpReductionClause::getVariant() const
106731 : {
106732 : // This function is used in ROSE while "variant()" is used in SAGE
106733 : assert(this != NULL);
106734 : return variant();
106735 : }
106736 : #endif
106737 :
106738 : // This function is used in ROSE in treeTraversal code
106739 : // eventually replaces getVariant() and variant()
106740 : // though after variant() has been removed for a while we will
106741 : // want to change the name of variantT() back to variant()
106742 : // (since the "T" was ment to stand for temporary).
106743 : // When this happens the variantT() will be depricated.
106744 : VariantT
106745 3904 : SgOmpReductionClause::variantT() const
106746 : {
106747 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
106748 3904 : ROSE_ASSERT(this != NULL);
106749 3904 : return V_SgOmpReductionClause;
106750 : }
106751 :
106752 : #if 0
106753 : int
106754 : SgOmpReductionClause::variant() const
106755 : {
106756 : // This function is used in SAGE
106757 : ROSE_ASSERT(this != NULL);
106758 : return OmpReductionClauseTag;
106759 : }
106760 : #endif
106761 :
106762 : ROSE_DLL_API const char*
106763 0 : SgOmpReductionClause::sage_class_name() const
106764 : {
106765 0 : ROSE_ASSERT(this != NULL);
106766 0 : return "SgOmpReductionClause";
106767 : }
106768 :
106769 : std::string
106770 89 : SgOmpReductionClause::class_name() const
106771 : {
106772 89 : ROSE_ASSERT(this != NULL);
106773 89 : return "SgOmpReductionClause";
106774 : }
106775 :
106776 : // DQ (11/26/2005): Support for visitor pattern mechanims
106777 : // (inferior to ROSE traversal mechanism, experimental).
106778 : void
106779 0 : SgOmpReductionClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
106780 : {
106781 0 : ROSE_ASSERT(this != NULL);
106782 0 : visitor.visit(this);
106783 0 : }
106784 :
106785 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
106786 0 : void SgOmpReductionClause::accept (ROSE_VisitorPattern & visitor) {
106787 0 : ROSE_ASSERT(this != NULL);
106788 0 : visitor.visit(this);
106789 0 : }
106790 :
106791 : SgOmpReductionClause*
106792 0 : SgOmpReductionClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
106793 : {
106794 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
106795 : // This function is currently only supported for the AST used the represent Binary executables.
106796 : if (0 /* isSgAsmNode(this) != NULL */)
106797 : {
106798 : // Support for regex specification.
106799 : std::string prefixCode = "REGEX:";
106800 : addNewAttribute(prefixCode + s,a);
106801 : }
106802 : #endif
106803 :
106804 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
106805 0 : return this;
106806 : }
106807 :
106808 : // *** COMMON CODE SECTION ENDS HERE ***
106809 :
106810 :
106811 : // End of memberFunctionString
106812 : // Start of memberFunctionString
106813 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
106814 :
106815 :
106816 : #if 0
106817 : //! Error checking support
106818 : /*! Verifies the following:
106819 : - working getVariant() member function
106820 : - calls base class's error() member function
106821 : Every class has one of these functions.
106822 : */
106823 : bool
106824 : SgOmpReductionClause::error()
106825 : {
106826 : // Put error checking here
106827 :
106828 : ROSE_ASSERT (this != NULL);
106829 : if (getVariant() != OmpReductionClauseTag)
106830 : {
106831 : printf ("Error in SgOmpReductionClause::error(): SgOmpReductionClause object has a %s variant \n",
106832 : Cxx_GrammarTerminalNames[getVariant()].name);
106833 : // printf ("Error in SgOmpReductionClause::error() \n");
106834 : ROSE_ABORT();
106835 : }
106836 :
106837 : ROSE_ASSERT (getVariant() == OmpReductionClauseTag);
106838 : return SgOmpVariablesClause::error();
106839 : }
106840 : #endif
106841 :
106842 :
106843 :
106844 : // End of memberFunctionString
106845 :
106846 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
106847 :
106848 270 : SgOmpReductionClause* isSgOmpReductionClause ( SgNode* inputDerivedClassPointer )
106849 : {
106850 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
106851 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
106852 : // So to fix this we return NULL directly when the input is NULL and avoid the
106853 : // dynamic_cast in this case. This is likely a performance improvement as well.
106854 : // return dynamic_cast<SgOmpReductionClause*>(inputDerivedClassPointer);
106855 : // Milind Chabbi (8/28/2013): isSgOmpReductionClause uses table-driven castability instead of c++ default dynamic_cast
106856 : // this improves the running time performance by 10-20%.
106857 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpReductionClause*>(inputDerivedClassPointer);
106858 270 : return IS_SgOmpReductionClause_FAST_MACRO(inputDerivedClassPointer);
106859 : }
106860 :
106861 : // DQ (11/8/2003): Added version of functions taking const pointer
106862 0 : const SgOmpReductionClause* isSgOmpReductionClause ( const SgNode* inputDerivedClassPointer )
106863 : {
106864 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
106865 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
106866 : // So to fix this we return NULL directly when the input is NULL and avoid the
106867 : // dynamic_cast in this case. This is likely a performance improvement as well.
106868 : // return dynamic_cast<const SgOmpReductionClause*>(inputDerivedClassPointer);
106869 : // Milind Chabbi (8/28/2013): isSgOmpReductionClause uses table-driven castability instead of c++ default dynamic_cast
106870 : // this improves the running time performance by 10-20%.
106871 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpReductionClause*>(inputDerivedClassPointer);
106872 0 : return IS_SgOmpReductionClause_FAST_MACRO(inputDerivedClassPointer);
106873 : }
106874 :
106875 :
106876 :
106877 : /* #line 106878 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106878 :
106879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
106880 :
106881 : /**
106882 : \brief Generated destructor
106883 :
106884 : This destructor is automatically generated (by ROSETTA). This destructor
106885 : only frees memory of data members associated with the parts of the current IR node which
106886 : are NOT traversed. Those data members that are part of a traversal can be freed using
106887 : a traversal (calling this destructor on all children in a post-order traversal). Such
106888 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
106889 :
106890 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
106891 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
106892 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
106893 :
106894 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
106895 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
106896 : pointers are not yet implemented to call delete on eash pointer in the container.
106897 : (This could be done by derivation from the STL containers to define containers that
106898 : automatically deleted their members.)
106899 :
106900 : */
106901 0 : SgOmpReductionClause::~SgOmpReductionClause () {
106902 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
106903 :
106904 :
106905 : // case: not a listType for modifier
106906 0 : p_modifier =e_omp_reduction_modifier_unknown; // non list case
106907 : // case: not a listType for identifier
106908 0 : p_identifier =e_omp_reduction_unknown; // non list case
106909 : // case: not a listType for user_defined_identifier
106910 0 : p_user_defined_identifier = NULL; // non list case
106911 :
106912 : }
106913 :
106914 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
106915 0 : }
106916 :
106917 :
106918 : /* #line 106919 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106919 :
106920 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
106921 :
106922 : // Generated constructor
106923 0 : SgOmpReductionClause::SgOmpReductionClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_reduction_modifier_enum modifier, SgOmpClause::omp_reduction_identifier_enum identifier, SgExpression* user_defined_identifier )
106924 0 : : SgOmpVariablesClause(startOfConstruct, variables)
106925 : {
106926 : #ifdef DEBUG
106927 : // printf ("In SgOmpReductionClause::SgOmpReductionClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_reduction_modifier_enum modifier, SgOmpClause::omp_reduction_identifier_enum identifier, SgExpression* user_defined_identifier) sage_class_name() = %s \n",sage_class_name());
106928 : #endif
106929 : #if 0
106930 : // debugging information!
106931 : printf ("In SgOmpReductionClause::SgOmpReductionClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_reduction_modifier_enum modifier, SgOmpClause::omp_reduction_identifier_enum identifier, SgExpression* user_defined_identifier): this = %p = %s \n",this,this->class_name().c_str());
106932 : #endif
106933 :
106934 0 : p_modifier = modifier;
106935 0 : p_identifier = identifier;
106936 0 : p_user_defined_identifier = user_defined_identifier;
106937 :
106938 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
106939 :
106940 : #if 0
106941 : // DQ (7/30/2014): Call a virtual function.
106942 : std::string s = this->class_name();
106943 : #endif
106944 :
106945 : // Test the variant virtual function
106946 : // assert(OmpReductionClauseTag == variant());
106947 0 : assert(OmpReductionClauseTag == this->variant());
106948 0 : ROSE_ASSERT(OmpReductionClauseTag == (int)(this->variantT()));
106949 0 : post_construction_initialization();
106950 :
106951 : // Test the isSgOmpReductionClause() function since it has been problematic
106952 0 : assert(isSgOmpReductionClause(this) != NULL);
106953 0 : }
106954 :
106955 : // Generated constructor (all data members)
106956 :
106957 : /* #line 106958 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106958 :
106959 :
106960 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106961 :
106962 :
106963 : // ********************************************************
106964 : // member functions common across all array grammar objects
106965 : // ********************************************************
106966 :
106967 :
106968 :
106969 : /* #line 106970 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106970 :
106971 :
106972 :
106973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
106974 :
106975 : // ********************************************************
106976 : // member functions specific to each node in the grammar
106977 : // ********************************************************
106978 :
106979 :
106980 : /* #line 106981 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
106981 :
106982 : // Start of memberFunctionString
106983 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
106984 :
106985 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
106986 :
106987 : SgOmpClause::omp_in_reduction_identifier_enum
106988 6 : SgOmpInReductionClause::get_identifier () const
106989 : {
106990 6 : ROSE_ASSERT (this != NULL);
106991 :
106992 : #if 0
106993 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
106994 : // used to trigger marking transformations for the token-based unparsing.
106995 : printf ("SgOmpInReductionClause::get_identifier = %p = %s \n",this,this->class_name().c_str());
106996 : #endif
106997 :
106998 6 : return p_identifier;
106999 : }
107000 :
107001 : void
107002 0 : SgOmpInReductionClause::set_identifier ( SgOmpClause::omp_in_reduction_identifier_enum identifier )
107003 : {
107004 0 : ROSE_ASSERT (this != NULL);
107005 :
107006 : #if 0
107007 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107008 : // used to trigger marking transformations for the token-based unparsing.
107009 : printf ("SgOmpInReductionClause::set_identifier = %p = %s \n",this,this->class_name().c_str());
107010 : #endif
107011 :
107012 0 : set_isModified(true);
107013 :
107014 0 : p_identifier = identifier;
107015 0 : }
107016 :
107017 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107018 :
107019 :
107020 : // End of memberFunctionString
107021 : // Start of memberFunctionString
107022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
107023 :
107024 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
107025 :
107026 : SgExpression*
107027 0 : SgOmpInReductionClause::get_user_defined_identifier () const
107028 : {
107029 0 : ROSE_ASSERT (this != NULL);
107030 :
107031 : #if 0
107032 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107033 : // used to trigger marking transformations for the token-based unparsing.
107034 : printf ("SgOmpInReductionClause::get_user_defined_identifier = %p = %s \n",this,this->class_name().c_str());
107035 : #endif
107036 :
107037 0 : return p_user_defined_identifier;
107038 : }
107039 :
107040 : void
107041 0 : SgOmpInReductionClause::set_user_defined_identifier ( SgExpression* user_defined_identifier )
107042 : {
107043 0 : ROSE_ASSERT (this != NULL);
107044 :
107045 : #if 0
107046 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107047 : // used to trigger marking transformations for the token-based unparsing.
107048 : printf ("SgOmpInReductionClause::set_user_defined_identifier = %p = %s \n",this,this->class_name().c_str());
107049 : #endif
107050 :
107051 0 : set_isModified(true);
107052 :
107053 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
107054 : if (p_user_defined_identifier != NULL && user_defined_identifier != NULL && p_user_defined_identifier != user_defined_identifier)
107055 : {
107056 : printf ("Warning: user_defined_identifier = %p overwriting valid pointer p_user_defined_identifier = %p \n",user_defined_identifier,p_user_defined_identifier);
107057 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
107058 : printf ("Error fails assertion (p_user_defined_identifier != NULL && user_defined_identifier != NULL && p_user_defined_identifier != user_defined_identifier) is false\n");
107059 : ROSE_ASSERT(false);
107060 : #endif
107061 : }
107062 : #endif
107063 0 : p_user_defined_identifier = user_defined_identifier;
107064 0 : }
107065 :
107066 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107067 :
107068 :
107069 : // End of memberFunctionString
107070 : // Start of memberFunctionString
107071 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
107072 :
107073 : // *** COMMON CODE SECTION BEGINS HERE ***
107074 :
107075 : #if 0
107076 : int
107077 : SgOmpInReductionClause::getVariant() const
107078 : {
107079 : // This function is used in ROSE while "variant()" is used in SAGE
107080 : assert(this != NULL);
107081 : return variant();
107082 : }
107083 : #endif
107084 :
107085 : // This function is used in ROSE in treeTraversal code
107086 : // eventually replaces getVariant() and variant()
107087 : // though after variant() has been removed for a while we will
107088 : // want to change the name of variantT() back to variant()
107089 : // (since the "T" was ment to stand for temporary).
107090 : // When this happens the variantT() will be depricated.
107091 : VariantT
107092 360 : SgOmpInReductionClause::variantT() const
107093 : {
107094 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
107095 360 : ROSE_ASSERT(this != NULL);
107096 360 : return V_SgOmpInReductionClause;
107097 : }
107098 :
107099 : #if 0
107100 : int
107101 : SgOmpInReductionClause::variant() const
107102 : {
107103 : // This function is used in SAGE
107104 : ROSE_ASSERT(this != NULL);
107105 : return OmpInReductionClauseTag;
107106 : }
107107 : #endif
107108 :
107109 : ROSE_DLL_API const char*
107110 0 : SgOmpInReductionClause::sage_class_name() const
107111 : {
107112 0 : ROSE_ASSERT(this != NULL);
107113 0 : return "SgOmpInReductionClause";
107114 : }
107115 :
107116 : std::string
107117 6 : SgOmpInReductionClause::class_name() const
107118 : {
107119 6 : ROSE_ASSERT(this != NULL);
107120 6 : return "SgOmpInReductionClause";
107121 : }
107122 :
107123 : // DQ (11/26/2005): Support for visitor pattern mechanims
107124 : // (inferior to ROSE traversal mechanism, experimental).
107125 : void
107126 0 : SgOmpInReductionClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
107127 : {
107128 0 : ROSE_ASSERT(this != NULL);
107129 0 : visitor.visit(this);
107130 0 : }
107131 :
107132 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
107133 0 : void SgOmpInReductionClause::accept (ROSE_VisitorPattern & visitor) {
107134 0 : ROSE_ASSERT(this != NULL);
107135 0 : visitor.visit(this);
107136 0 : }
107137 :
107138 : SgOmpInReductionClause*
107139 0 : SgOmpInReductionClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
107140 : {
107141 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
107142 : // This function is currently only supported for the AST used the represent Binary executables.
107143 : if (0 /* isSgAsmNode(this) != NULL */)
107144 : {
107145 : // Support for regex specification.
107146 : std::string prefixCode = "REGEX:";
107147 : addNewAttribute(prefixCode + s,a);
107148 : }
107149 : #endif
107150 :
107151 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
107152 0 : return this;
107153 : }
107154 :
107155 : // *** COMMON CODE SECTION ENDS HERE ***
107156 :
107157 :
107158 : // End of memberFunctionString
107159 : // Start of memberFunctionString
107160 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
107161 :
107162 :
107163 : #if 0
107164 : //! Error checking support
107165 : /*! Verifies the following:
107166 : - working getVariant() member function
107167 : - calls base class's error() member function
107168 : Every class has one of these functions.
107169 : */
107170 : bool
107171 : SgOmpInReductionClause::error()
107172 : {
107173 : // Put error checking here
107174 :
107175 : ROSE_ASSERT (this != NULL);
107176 : if (getVariant() != OmpInReductionClauseTag)
107177 : {
107178 : printf ("Error in SgOmpInReductionClause::error(): SgOmpInReductionClause object has a %s variant \n",
107179 : Cxx_GrammarTerminalNames[getVariant()].name);
107180 : // printf ("Error in SgOmpInReductionClause::error() \n");
107181 : ROSE_ABORT();
107182 : }
107183 :
107184 : ROSE_ASSERT (getVariant() == OmpInReductionClauseTag);
107185 : return SgOmpVariablesClause::error();
107186 : }
107187 : #endif
107188 :
107189 :
107190 :
107191 : // End of memberFunctionString
107192 :
107193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
107194 :
107195 12 : SgOmpInReductionClause* isSgOmpInReductionClause ( SgNode* inputDerivedClassPointer )
107196 : {
107197 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
107198 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
107199 : // So to fix this we return NULL directly when the input is NULL and avoid the
107200 : // dynamic_cast in this case. This is likely a performance improvement as well.
107201 : // return dynamic_cast<SgOmpInReductionClause*>(inputDerivedClassPointer);
107202 : // Milind Chabbi (8/28/2013): isSgOmpInReductionClause uses table-driven castability instead of c++ default dynamic_cast
107203 : // this improves the running time performance by 10-20%.
107204 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpInReductionClause*>(inputDerivedClassPointer);
107205 12 : return IS_SgOmpInReductionClause_FAST_MACRO(inputDerivedClassPointer);
107206 : }
107207 :
107208 : // DQ (11/8/2003): Added version of functions taking const pointer
107209 0 : const SgOmpInReductionClause* isSgOmpInReductionClause ( const SgNode* inputDerivedClassPointer )
107210 : {
107211 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
107212 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
107213 : // So to fix this we return NULL directly when the input is NULL and avoid the
107214 : // dynamic_cast in this case. This is likely a performance improvement as well.
107215 : // return dynamic_cast<const SgOmpInReductionClause*>(inputDerivedClassPointer);
107216 : // Milind Chabbi (8/28/2013): isSgOmpInReductionClause uses table-driven castability instead of c++ default dynamic_cast
107217 : // this improves the running time performance by 10-20%.
107218 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpInReductionClause*>(inputDerivedClassPointer);
107219 0 : return IS_SgOmpInReductionClause_FAST_MACRO(inputDerivedClassPointer);
107220 : }
107221 :
107222 :
107223 :
107224 : /* #line 107225 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107225 :
107226 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
107227 :
107228 : /**
107229 : \brief Generated destructor
107230 :
107231 : This destructor is automatically generated (by ROSETTA). This destructor
107232 : only frees memory of data members associated with the parts of the current IR node which
107233 : are NOT traversed. Those data members that are part of a traversal can be freed using
107234 : a traversal (calling this destructor on all children in a post-order traversal). Such
107235 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
107236 :
107237 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
107238 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
107239 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
107240 :
107241 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
107242 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
107243 : pointers are not yet implemented to call delete on eash pointer in the container.
107244 : (This could be done by derivation from the STL containers to define containers that
107245 : automatically deleted their members.)
107246 :
107247 : */
107248 0 : SgOmpInReductionClause::~SgOmpInReductionClause () {
107249 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
107250 :
107251 :
107252 : // case: not a listType for identifier
107253 0 : p_identifier =e_omp_in_reduction_identifier_unspecified; // non list case
107254 : // case: not a listType for user_defined_identifier
107255 0 : p_user_defined_identifier = NULL; // non list case
107256 :
107257 : }
107258 :
107259 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
107260 0 : }
107261 :
107262 :
107263 : /* #line 107264 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107264 :
107265 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
107266 :
107267 : // Generated constructor
107268 0 : SgOmpInReductionClause::SgOmpInReductionClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_in_reduction_identifier_enum identifier, SgExpression* user_defined_identifier )
107269 0 : : SgOmpVariablesClause(startOfConstruct, variables)
107270 : {
107271 : #ifdef DEBUG
107272 : // printf ("In SgOmpInReductionClause::SgOmpInReductionClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_in_reduction_identifier_enum identifier, SgExpression* user_defined_identifier) sage_class_name() = %s \n",sage_class_name());
107273 : #endif
107274 : #if 0
107275 : // debugging information!
107276 : printf ("In SgOmpInReductionClause::SgOmpInReductionClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_in_reduction_identifier_enum identifier, SgExpression* user_defined_identifier): this = %p = %s \n",this,this->class_name().c_str());
107277 : #endif
107278 :
107279 0 : p_identifier = identifier;
107280 0 : p_user_defined_identifier = user_defined_identifier;
107281 :
107282 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
107283 :
107284 : #if 0
107285 : // DQ (7/30/2014): Call a virtual function.
107286 : std::string s = this->class_name();
107287 : #endif
107288 :
107289 : // Test the variant virtual function
107290 : // assert(OmpInReductionClauseTag == variant());
107291 0 : assert(OmpInReductionClauseTag == this->variant());
107292 0 : ROSE_ASSERT(OmpInReductionClauseTag == (int)(this->variantT()));
107293 0 : post_construction_initialization();
107294 :
107295 : // Test the isSgOmpInReductionClause() function since it has been problematic
107296 0 : assert(isSgOmpInReductionClause(this) != NULL);
107297 0 : }
107298 :
107299 : // Generated constructor (all data members)
107300 :
107301 : /* #line 107302 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107302 :
107303 :
107304 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
107305 :
107306 :
107307 : // ********************************************************
107308 : // member functions common across all array grammar objects
107309 : // ********************************************************
107310 :
107311 :
107312 :
107313 : /* #line 107314 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107314 :
107315 :
107316 :
107317 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
107318 :
107319 : // ********************************************************
107320 : // member functions specific to each node in the grammar
107321 : // ********************************************************
107322 :
107323 :
107324 : /* #line 107325 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107325 :
107326 : // Start of memberFunctionString
107327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
107328 :
107329 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
107330 :
107331 : SgOmpClause::omp_task_reduction_identifier_enum
107332 0 : SgOmpTaskReductionClause::get_identifier () const
107333 : {
107334 0 : ROSE_ASSERT (this != NULL);
107335 :
107336 : #if 0
107337 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107338 : // used to trigger marking transformations for the token-based unparsing.
107339 : printf ("SgOmpTaskReductionClause::get_identifier = %p = %s \n",this,this->class_name().c_str());
107340 : #endif
107341 :
107342 0 : return p_identifier;
107343 : }
107344 :
107345 : void
107346 0 : SgOmpTaskReductionClause::set_identifier ( SgOmpClause::omp_task_reduction_identifier_enum identifier )
107347 : {
107348 0 : ROSE_ASSERT (this != NULL);
107349 :
107350 : #if 0
107351 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107352 : // used to trigger marking transformations for the token-based unparsing.
107353 : printf ("SgOmpTaskReductionClause::set_identifier = %p = %s \n",this,this->class_name().c_str());
107354 : #endif
107355 :
107356 0 : set_isModified(true);
107357 :
107358 0 : p_identifier = identifier;
107359 0 : }
107360 :
107361 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107362 :
107363 :
107364 : // End of memberFunctionString
107365 : // Start of memberFunctionString
107366 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
107367 :
107368 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
107369 :
107370 : SgExpression*
107371 0 : SgOmpTaskReductionClause::get_user_defined_identifier () const
107372 : {
107373 0 : ROSE_ASSERT (this != NULL);
107374 :
107375 : #if 0
107376 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107377 : // used to trigger marking transformations for the token-based unparsing.
107378 : printf ("SgOmpTaskReductionClause::get_user_defined_identifier = %p = %s \n",this,this->class_name().c_str());
107379 : #endif
107380 :
107381 0 : return p_user_defined_identifier;
107382 : }
107383 :
107384 : void
107385 0 : SgOmpTaskReductionClause::set_user_defined_identifier ( SgExpression* user_defined_identifier )
107386 : {
107387 0 : ROSE_ASSERT (this != NULL);
107388 :
107389 : #if 0
107390 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107391 : // used to trigger marking transformations for the token-based unparsing.
107392 : printf ("SgOmpTaskReductionClause::set_user_defined_identifier = %p = %s \n",this,this->class_name().c_str());
107393 : #endif
107394 :
107395 0 : set_isModified(true);
107396 :
107397 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
107398 : if (p_user_defined_identifier != NULL && user_defined_identifier != NULL && p_user_defined_identifier != user_defined_identifier)
107399 : {
107400 : printf ("Warning: user_defined_identifier = %p overwriting valid pointer p_user_defined_identifier = %p \n",user_defined_identifier,p_user_defined_identifier);
107401 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
107402 : printf ("Error fails assertion (p_user_defined_identifier != NULL && user_defined_identifier != NULL && p_user_defined_identifier != user_defined_identifier) is false\n");
107403 : ROSE_ASSERT(false);
107404 : #endif
107405 : }
107406 : #endif
107407 0 : p_user_defined_identifier = user_defined_identifier;
107408 0 : }
107409 :
107410 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107411 :
107412 :
107413 : // End of memberFunctionString
107414 : // Start of memberFunctionString
107415 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
107416 :
107417 : // *** COMMON CODE SECTION BEGINS HERE ***
107418 :
107419 : #if 0
107420 : int
107421 : SgOmpTaskReductionClause::getVariant() const
107422 : {
107423 : // This function is used in ROSE while "variant()" is used in SAGE
107424 : assert(this != NULL);
107425 : return variant();
107426 : }
107427 : #endif
107428 :
107429 : // This function is used in ROSE in treeTraversal code
107430 : // eventually replaces getVariant() and variant()
107431 : // though after variant() has been removed for a while we will
107432 : // want to change the name of variantT() back to variant()
107433 : // (since the "T" was ment to stand for temporary).
107434 : // When this happens the variantT() will be depricated.
107435 : VariantT
107436 0 : SgOmpTaskReductionClause::variantT() const
107437 : {
107438 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
107439 0 : ROSE_ASSERT(this != NULL);
107440 0 : return V_SgOmpTaskReductionClause;
107441 : }
107442 :
107443 : #if 0
107444 : int
107445 : SgOmpTaskReductionClause::variant() const
107446 : {
107447 : // This function is used in SAGE
107448 : ROSE_ASSERT(this != NULL);
107449 : return OmpTaskReductionClauseTag;
107450 : }
107451 : #endif
107452 :
107453 : ROSE_DLL_API const char*
107454 0 : SgOmpTaskReductionClause::sage_class_name() const
107455 : {
107456 0 : ROSE_ASSERT(this != NULL);
107457 0 : return "SgOmpTaskReductionClause";
107458 : }
107459 :
107460 : std::string
107461 0 : SgOmpTaskReductionClause::class_name() const
107462 : {
107463 0 : ROSE_ASSERT(this != NULL);
107464 0 : return "SgOmpTaskReductionClause";
107465 : }
107466 :
107467 : // DQ (11/26/2005): Support for visitor pattern mechanims
107468 : // (inferior to ROSE traversal mechanism, experimental).
107469 : void
107470 0 : SgOmpTaskReductionClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
107471 : {
107472 0 : ROSE_ASSERT(this != NULL);
107473 0 : visitor.visit(this);
107474 0 : }
107475 :
107476 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
107477 0 : void SgOmpTaskReductionClause::accept (ROSE_VisitorPattern & visitor) {
107478 0 : ROSE_ASSERT(this != NULL);
107479 0 : visitor.visit(this);
107480 0 : }
107481 :
107482 : SgOmpTaskReductionClause*
107483 0 : SgOmpTaskReductionClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
107484 : {
107485 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
107486 : // This function is currently only supported for the AST used the represent Binary executables.
107487 : if (0 /* isSgAsmNode(this) != NULL */)
107488 : {
107489 : // Support for regex specification.
107490 : std::string prefixCode = "REGEX:";
107491 : addNewAttribute(prefixCode + s,a);
107492 : }
107493 : #endif
107494 :
107495 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
107496 0 : return this;
107497 : }
107498 :
107499 : // *** COMMON CODE SECTION ENDS HERE ***
107500 :
107501 :
107502 : // End of memberFunctionString
107503 : // Start of memberFunctionString
107504 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
107505 :
107506 :
107507 : #if 0
107508 : //! Error checking support
107509 : /*! Verifies the following:
107510 : - working getVariant() member function
107511 : - calls base class's error() member function
107512 : Every class has one of these functions.
107513 : */
107514 : bool
107515 : SgOmpTaskReductionClause::error()
107516 : {
107517 : // Put error checking here
107518 :
107519 : ROSE_ASSERT (this != NULL);
107520 : if (getVariant() != OmpTaskReductionClauseTag)
107521 : {
107522 : printf ("Error in SgOmpTaskReductionClause::error(): SgOmpTaskReductionClause object has a %s variant \n",
107523 : Cxx_GrammarTerminalNames[getVariant()].name);
107524 : // printf ("Error in SgOmpTaskReductionClause::error() \n");
107525 : ROSE_ABORT();
107526 : }
107527 :
107528 : ROSE_ASSERT (getVariant() == OmpTaskReductionClauseTag);
107529 : return SgOmpVariablesClause::error();
107530 : }
107531 : #endif
107532 :
107533 :
107534 :
107535 : // End of memberFunctionString
107536 :
107537 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
107538 :
107539 0 : SgOmpTaskReductionClause* isSgOmpTaskReductionClause ( SgNode* inputDerivedClassPointer )
107540 : {
107541 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
107542 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
107543 : // So to fix this we return NULL directly when the input is NULL and avoid the
107544 : // dynamic_cast in this case. This is likely a performance improvement as well.
107545 : // return dynamic_cast<SgOmpTaskReductionClause*>(inputDerivedClassPointer);
107546 : // Milind Chabbi (8/28/2013): isSgOmpTaskReductionClause uses table-driven castability instead of c++ default dynamic_cast
107547 : // this improves the running time performance by 10-20%.
107548 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskReductionClause*>(inputDerivedClassPointer);
107549 0 : return IS_SgOmpTaskReductionClause_FAST_MACRO(inputDerivedClassPointer);
107550 : }
107551 :
107552 : // DQ (11/8/2003): Added version of functions taking const pointer
107553 0 : const SgOmpTaskReductionClause* isSgOmpTaskReductionClause ( const SgNode* inputDerivedClassPointer )
107554 : {
107555 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
107556 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
107557 : // So to fix this we return NULL directly when the input is NULL and avoid the
107558 : // dynamic_cast in this case. This is likely a performance improvement as well.
107559 : // return dynamic_cast<const SgOmpTaskReductionClause*>(inputDerivedClassPointer);
107560 : // Milind Chabbi (8/28/2013): isSgOmpTaskReductionClause uses table-driven castability instead of c++ default dynamic_cast
107561 : // this improves the running time performance by 10-20%.
107562 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskReductionClause*>(inputDerivedClassPointer);
107563 0 : return IS_SgOmpTaskReductionClause_FAST_MACRO(inputDerivedClassPointer);
107564 : }
107565 :
107566 :
107567 :
107568 : /* #line 107569 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107569 :
107570 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
107571 :
107572 : /**
107573 : \brief Generated destructor
107574 :
107575 : This destructor is automatically generated (by ROSETTA). This destructor
107576 : only frees memory of data members associated with the parts of the current IR node which
107577 : are NOT traversed. Those data members that are part of a traversal can be freed using
107578 : a traversal (calling this destructor on all children in a post-order traversal). Such
107579 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
107580 :
107581 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
107582 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
107583 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
107584 :
107585 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
107586 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
107587 : pointers are not yet implemented to call delete on eash pointer in the container.
107588 : (This could be done by derivation from the STL containers to define containers that
107589 : automatically deleted their members.)
107590 :
107591 : */
107592 0 : SgOmpTaskReductionClause::~SgOmpTaskReductionClause () {
107593 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
107594 :
107595 :
107596 : // case: not a listType for identifier
107597 0 : p_identifier =e_omp_task_reduction_identifier_unspecified; // non list case
107598 : // case: not a listType for user_defined_identifier
107599 0 : p_user_defined_identifier = NULL; // non list case
107600 :
107601 : }
107602 :
107603 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
107604 0 : }
107605 :
107606 :
107607 : /* #line 107608 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107608 :
107609 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
107610 :
107611 : // Generated constructor
107612 0 : SgOmpTaskReductionClause::SgOmpTaskReductionClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_task_reduction_identifier_enum identifier, SgExpression* user_defined_identifier )
107613 0 : : SgOmpVariablesClause(startOfConstruct, variables)
107614 : {
107615 : #ifdef DEBUG
107616 : // printf ("In SgOmpTaskReductionClause::SgOmpTaskReductionClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_task_reduction_identifier_enum identifier, SgExpression* user_defined_identifier) sage_class_name() = %s \n",sage_class_name());
107617 : #endif
107618 : #if 0
107619 : // debugging information!
107620 : printf ("In SgOmpTaskReductionClause::SgOmpTaskReductionClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_task_reduction_identifier_enum identifier, SgExpression* user_defined_identifier): this = %p = %s \n",this,this->class_name().c_str());
107621 : #endif
107622 :
107623 0 : p_identifier = identifier;
107624 0 : p_user_defined_identifier = user_defined_identifier;
107625 :
107626 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
107627 :
107628 : #if 0
107629 : // DQ (7/30/2014): Call a virtual function.
107630 : std::string s = this->class_name();
107631 : #endif
107632 :
107633 : // Test the variant virtual function
107634 : // assert(OmpTaskReductionClauseTag == variant());
107635 0 : assert(OmpTaskReductionClauseTag == this->variant());
107636 0 : ROSE_ASSERT(OmpTaskReductionClauseTag == (int)(this->variantT()));
107637 0 : post_construction_initialization();
107638 :
107639 : // Test the isSgOmpTaskReductionClause() function since it has been problematic
107640 0 : assert(isSgOmpTaskReductionClause(this) != NULL);
107641 0 : }
107642 :
107643 : // Generated constructor (all data members)
107644 :
107645 : /* #line 107646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107646 :
107647 :
107648 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
107649 :
107650 :
107651 : // ********************************************************
107652 : // member functions common across all array grammar objects
107653 : // ********************************************************
107654 :
107655 :
107656 :
107657 : /* #line 107658 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107658 :
107659 :
107660 :
107661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
107662 :
107663 : // ********************************************************
107664 : // member functions specific to each node in the grammar
107665 : // ********************************************************
107666 :
107667 :
107668 : /* #line 107669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107669 :
107670 : // Start of memberFunctionString
107671 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
107672 :
107673 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
107674 :
107675 : SgOmpClause::omp_map_operator_enum
107676 43 : SgOmpMapClause::get_operation () const
107677 : {
107678 43 : ROSE_ASSERT (this != NULL);
107679 :
107680 : #if 0
107681 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107682 : // used to trigger marking transformations for the token-based unparsing.
107683 : printf ("SgOmpMapClause::get_operation = %p = %s \n",this,this->class_name().c_str());
107684 : #endif
107685 :
107686 43 : return p_operation;
107687 : }
107688 :
107689 : void
107690 0 : SgOmpMapClause::set_operation ( SgOmpClause::omp_map_operator_enum operation )
107691 : {
107692 0 : ROSE_ASSERT (this != NULL);
107693 :
107694 : #if 0
107695 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107696 : // used to trigger marking transformations for the token-based unparsing.
107697 : printf ("SgOmpMapClause::set_operation = %p = %s \n",this,this->class_name().c_str());
107698 : #endif
107699 :
107700 0 : set_isModified(true);
107701 :
107702 0 : p_operation = operation;
107703 0 : }
107704 :
107705 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107706 :
107707 :
107708 : // End of memberFunctionString
107709 : // Start of memberFunctionString
107710 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
107711 :
107712 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
107713 :
107714 : std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >
107715 43 : SgOmpMapClause::get_array_dimensions () const
107716 : {
107717 43 : ROSE_ASSERT (this != NULL);
107718 :
107719 : #if 0
107720 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107721 : // used to trigger marking transformations for the token-based unparsing.
107722 : printf ("SgOmpMapClause::get_array_dimensions = %p = %s \n",this,this->class_name().c_str());
107723 : #endif
107724 :
107725 43 : return p_array_dimensions;
107726 : }
107727 :
107728 : void
107729 43 : SgOmpMapClause::set_array_dimensions ( std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > array_dimensions )
107730 : {
107731 43 : ROSE_ASSERT (this != NULL);
107732 :
107733 : #if 0
107734 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107735 : // used to trigger marking transformations for the token-based unparsing.
107736 : printf ("SgOmpMapClause::set_array_dimensions = %p = %s \n",this,this->class_name().c_str());
107737 : #endif
107738 :
107739 43 : set_isModified(true);
107740 :
107741 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
107742 : if (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions)
107743 : {
107744 : printf ("Warning: array_dimensions = %p overwriting valid pointer p_array_dimensions = %p \n",array_dimensions,p_array_dimensions);
107745 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
107746 : printf ("Error fails assertion (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions) is false\n");
107747 : ROSE_ASSERT(false);
107748 : #endif
107749 : }
107750 : #endif
107751 43 : p_array_dimensions = array_dimensions;
107752 43 : }
107753 :
107754 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107755 :
107756 :
107757 : // End of memberFunctionString
107758 : // Start of memberFunctionString
107759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
107760 :
107761 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
107762 :
107763 : std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > >
107764 43 : SgOmpMapClause::get_dist_data_policies () const
107765 : {
107766 43 : ROSE_ASSERT (this != NULL);
107767 :
107768 : #if 0
107769 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107770 : // used to trigger marking transformations for the token-based unparsing.
107771 : printf ("SgOmpMapClause::get_dist_data_policies = %p = %s \n",this,this->class_name().c_str());
107772 : #endif
107773 :
107774 43 : return p_dist_data_policies;
107775 : }
107776 :
107777 : void
107778 0 : SgOmpMapClause::set_dist_data_policies ( std::map<SgSymbol*, std::vector < std::pair <SgOmpClause::omp_map_dist_data_enum, SgExpression*> > > dist_data_policies )
107779 : {
107780 0 : ROSE_ASSERT (this != NULL);
107781 :
107782 : #if 0
107783 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
107784 : // used to trigger marking transformations for the token-based unparsing.
107785 : printf ("SgOmpMapClause::set_dist_data_policies = %p = %s \n",this,this->class_name().c_str());
107786 : #endif
107787 :
107788 0 : set_isModified(true);
107789 :
107790 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
107791 : if (p_dist_data_policies != NULL && dist_data_policies != NULL && p_dist_data_policies != dist_data_policies)
107792 : {
107793 : printf ("Warning: dist_data_policies = %p overwriting valid pointer p_dist_data_policies = %p \n",dist_data_policies,p_dist_data_policies);
107794 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
107795 : printf ("Error fails assertion (p_dist_data_policies != NULL && dist_data_policies != NULL && p_dist_data_policies != dist_data_policies) is false\n");
107796 : ROSE_ASSERT(false);
107797 : #endif
107798 : }
107799 : #endif
107800 0 : p_dist_data_policies = dist_data_policies;
107801 0 : }
107802 :
107803 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
107804 :
107805 :
107806 : // End of memberFunctionString
107807 : // Start of memberFunctionString
107808 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
107809 :
107810 : // *** COMMON CODE SECTION BEGINS HERE ***
107811 :
107812 : #if 0
107813 : int
107814 : SgOmpMapClause::getVariant() const
107815 : {
107816 : // This function is used in ROSE while "variant()" is used in SAGE
107817 : assert(this != NULL);
107818 : return variant();
107819 : }
107820 : #endif
107821 :
107822 : // This function is used in ROSE in treeTraversal code
107823 : // eventually replaces getVariant() and variant()
107824 : // though after variant() has been removed for a while we will
107825 : // want to change the name of variantT() back to variant()
107826 : // (since the "T" was ment to stand for temporary).
107827 : // When this happens the variantT() will be depricated.
107828 : VariantT
107829 2655 : SgOmpMapClause::variantT() const
107830 : {
107831 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
107832 2655 : ROSE_ASSERT(this != NULL);
107833 2655 : return V_SgOmpMapClause;
107834 : }
107835 :
107836 : #if 0
107837 : int
107838 : SgOmpMapClause::variant() const
107839 : {
107840 : // This function is used in SAGE
107841 : ROSE_ASSERT(this != NULL);
107842 : return OmpMapClauseTag;
107843 : }
107844 : #endif
107845 :
107846 : ROSE_DLL_API const char*
107847 0 : SgOmpMapClause::sage_class_name() const
107848 : {
107849 0 : ROSE_ASSERT(this != NULL);
107850 0 : return "SgOmpMapClause";
107851 : }
107852 :
107853 : std::string
107854 43 : SgOmpMapClause::class_name() const
107855 : {
107856 43 : ROSE_ASSERT(this != NULL);
107857 43 : return "SgOmpMapClause";
107858 : }
107859 :
107860 : // DQ (11/26/2005): Support for visitor pattern mechanims
107861 : // (inferior to ROSE traversal mechanism, experimental).
107862 : void
107863 0 : SgOmpMapClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
107864 : {
107865 0 : ROSE_ASSERT(this != NULL);
107866 0 : visitor.visit(this);
107867 0 : }
107868 :
107869 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
107870 0 : void SgOmpMapClause::accept (ROSE_VisitorPattern & visitor) {
107871 0 : ROSE_ASSERT(this != NULL);
107872 0 : visitor.visit(this);
107873 0 : }
107874 :
107875 : SgOmpMapClause*
107876 0 : SgOmpMapClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
107877 : {
107878 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
107879 : // This function is currently only supported for the AST used the represent Binary executables.
107880 : if (0 /* isSgAsmNode(this) != NULL */)
107881 : {
107882 : // Support for regex specification.
107883 : std::string prefixCode = "REGEX:";
107884 : addNewAttribute(prefixCode + s,a);
107885 : }
107886 : #endif
107887 :
107888 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
107889 0 : return this;
107890 : }
107891 :
107892 : // *** COMMON CODE SECTION ENDS HERE ***
107893 :
107894 :
107895 : // End of memberFunctionString
107896 : // Start of memberFunctionString
107897 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
107898 :
107899 :
107900 : #if 0
107901 : //! Error checking support
107902 : /*! Verifies the following:
107903 : - working getVariant() member function
107904 : - calls base class's error() member function
107905 : Every class has one of these functions.
107906 : */
107907 : bool
107908 : SgOmpMapClause::error()
107909 : {
107910 : // Put error checking here
107911 :
107912 : ROSE_ASSERT (this != NULL);
107913 : if (getVariant() != OmpMapClauseTag)
107914 : {
107915 : printf ("Error in SgOmpMapClause::error(): SgOmpMapClause object has a %s variant \n",
107916 : Cxx_GrammarTerminalNames[getVariant()].name);
107917 : // printf ("Error in SgOmpMapClause::error() \n");
107918 : ROSE_ABORT();
107919 : }
107920 :
107921 : ROSE_ASSERT (getVariant() == OmpMapClauseTag);
107922 : return SgOmpVariablesClause::error();
107923 : }
107924 : #endif
107925 :
107926 :
107927 :
107928 : // End of memberFunctionString
107929 :
107930 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
107931 :
107932 129 : SgOmpMapClause* isSgOmpMapClause ( SgNode* inputDerivedClassPointer )
107933 : {
107934 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
107935 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
107936 : // So to fix this we return NULL directly when the input is NULL and avoid the
107937 : // dynamic_cast in this case. This is likely a performance improvement as well.
107938 : // return dynamic_cast<SgOmpMapClause*>(inputDerivedClassPointer);
107939 : // Milind Chabbi (8/28/2013): isSgOmpMapClause uses table-driven castability instead of c++ default dynamic_cast
107940 : // this improves the running time performance by 10-20%.
107941 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpMapClause*>(inputDerivedClassPointer);
107942 129 : return IS_SgOmpMapClause_FAST_MACRO(inputDerivedClassPointer);
107943 : }
107944 :
107945 : // DQ (11/8/2003): Added version of functions taking const pointer
107946 0 : const SgOmpMapClause* isSgOmpMapClause ( const SgNode* inputDerivedClassPointer )
107947 : {
107948 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
107949 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
107950 : // So to fix this we return NULL directly when the input is NULL and avoid the
107951 : // dynamic_cast in this case. This is likely a performance improvement as well.
107952 : // return dynamic_cast<const SgOmpMapClause*>(inputDerivedClassPointer);
107953 : // Milind Chabbi (8/28/2013): isSgOmpMapClause uses table-driven castability instead of c++ default dynamic_cast
107954 : // this improves the running time performance by 10-20%.
107955 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpMapClause*>(inputDerivedClassPointer);
107956 0 : return IS_SgOmpMapClause_FAST_MACRO(inputDerivedClassPointer);
107957 : }
107958 :
107959 :
107960 :
107961 : /* #line 107962 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107962 :
107963 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
107964 :
107965 : /**
107966 : \brief Generated destructor
107967 :
107968 : This destructor is automatically generated (by ROSETTA). This destructor
107969 : only frees memory of data members associated with the parts of the current IR node which
107970 : are NOT traversed. Those data members that are part of a traversal can be freed using
107971 : a traversal (calling this destructor on all children in a post-order traversal). Such
107972 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
107973 :
107974 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
107975 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
107976 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
107977 :
107978 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
107979 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
107980 : pointers are not yet implemented to call delete on eash pointer in the container.
107981 : (This could be done by derivation from the STL containers to define containers that
107982 : automatically deleted their members.)
107983 :
107984 : */
107985 0 : SgOmpMapClause::~SgOmpMapClause () {
107986 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
107987 :
107988 :
107989 : // case: not a listType for operation
107990 0 : p_operation =e_omp_map_unknown; // non list case
107991 :
107992 : }
107993 :
107994 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
107995 0 : }
107996 :
107997 :
107998 : /* #line 107999 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
107999 :
108000 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108001 :
108002 : // Generated constructor
108003 0 : SgOmpMapClause::SgOmpMapClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_map_operator_enum operation )
108004 0 : : SgOmpVariablesClause(startOfConstruct, variables)
108005 : {
108006 : #ifdef DEBUG
108007 : // printf ("In SgOmpMapClause::SgOmpMapClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_map_operator_enum operation) sage_class_name() = %s \n",sage_class_name());
108008 : #endif
108009 : #if 0
108010 : // debugging information!
108011 : printf ("In SgOmpMapClause::SgOmpMapClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_map_operator_enum operation): this = %p = %s \n",this,this->class_name().c_str());
108012 : #endif
108013 :
108014 0 : p_operation = operation;
108015 :
108016 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108017 :
108018 : #if 0
108019 : // DQ (7/30/2014): Call a virtual function.
108020 : std::string s = this->class_name();
108021 : #endif
108022 :
108023 : // Test the variant virtual function
108024 : // assert(OmpMapClauseTag == variant());
108025 0 : assert(OmpMapClauseTag == this->variant());
108026 0 : ROSE_ASSERT(OmpMapClauseTag == (int)(this->variantT()));
108027 0 : post_construction_initialization();
108028 :
108029 : // Test the isSgOmpMapClause() function since it has been problematic
108030 0 : assert(isSgOmpMapClause(this) != NULL);
108031 0 : }
108032 :
108033 : // Generated constructor (all data members)
108034 :
108035 : /* #line 108036 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108036 :
108037 :
108038 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108039 :
108040 :
108041 : // ********************************************************
108042 : // member functions common across all array grammar objects
108043 : // ********************************************************
108044 :
108045 :
108046 :
108047 : /* #line 108048 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108048 :
108049 :
108050 :
108051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108052 :
108053 : // ********************************************************
108054 : // member functions specific to each node in the grammar
108055 : // ********************************************************
108056 :
108057 :
108058 : /* #line 108059 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108059 :
108060 : // Start of memberFunctionString
108061 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
108062 :
108063 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
108064 :
108065 : SgOmpClause::omp_allocate_modifier_enum
108066 34 : SgOmpAllocateClause::get_modifier () const
108067 : {
108068 34 : ROSE_ASSERT (this != NULL);
108069 :
108070 : #if 0
108071 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108072 : // used to trigger marking transformations for the token-based unparsing.
108073 : printf ("SgOmpAllocateClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
108074 : #endif
108075 :
108076 34 : return p_modifier;
108077 : }
108078 :
108079 : void
108080 0 : SgOmpAllocateClause::set_modifier ( SgOmpClause::omp_allocate_modifier_enum modifier )
108081 : {
108082 0 : ROSE_ASSERT (this != NULL);
108083 :
108084 : #if 0
108085 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108086 : // used to trigger marking transformations for the token-based unparsing.
108087 : printf ("SgOmpAllocateClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
108088 : #endif
108089 :
108090 0 : set_isModified(true);
108091 :
108092 0 : p_modifier = modifier;
108093 0 : }
108094 :
108095 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
108096 :
108097 :
108098 : // End of memberFunctionString
108099 : // Start of memberFunctionString
108100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
108101 :
108102 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
108103 :
108104 : SgExpression*
108105 2 : SgOmpAllocateClause::get_user_defined_modifier () const
108106 : {
108107 2 : ROSE_ASSERT (this != NULL);
108108 :
108109 : #if 0
108110 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108111 : // used to trigger marking transformations for the token-based unparsing.
108112 : printf ("SgOmpAllocateClause::get_user_defined_modifier = %p = %s \n",this,this->class_name().c_str());
108113 : #endif
108114 :
108115 2 : return p_user_defined_modifier;
108116 : }
108117 :
108118 : void
108119 0 : SgOmpAllocateClause::set_user_defined_modifier ( SgExpression* user_defined_modifier )
108120 : {
108121 0 : ROSE_ASSERT (this != NULL);
108122 :
108123 : #if 0
108124 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108125 : // used to trigger marking transformations for the token-based unparsing.
108126 : printf ("SgOmpAllocateClause::set_user_defined_modifier = %p = %s \n",this,this->class_name().c_str());
108127 : #endif
108128 :
108129 0 : set_isModified(true);
108130 :
108131 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
108132 : if (p_user_defined_modifier != NULL && user_defined_modifier != NULL && p_user_defined_modifier != user_defined_modifier)
108133 : {
108134 : printf ("Warning: user_defined_modifier = %p overwriting valid pointer p_user_defined_modifier = %p \n",user_defined_modifier,p_user_defined_modifier);
108135 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
108136 : printf ("Error fails assertion (p_user_defined_modifier != NULL && user_defined_modifier != NULL && p_user_defined_modifier != user_defined_modifier) is false\n");
108137 : ROSE_ASSERT(false);
108138 : #endif
108139 : }
108140 : #endif
108141 0 : p_user_defined_modifier = user_defined_modifier;
108142 0 : }
108143 :
108144 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
108145 :
108146 :
108147 : // End of memberFunctionString
108148 : // Start of memberFunctionString
108149 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
108150 :
108151 : // *** COMMON CODE SECTION BEGINS HERE ***
108152 :
108153 : #if 0
108154 : int
108155 : SgOmpAllocateClause::getVariant() const
108156 : {
108157 : // This function is used in ROSE while "variant()" is used in SAGE
108158 : assert(this != NULL);
108159 : return variant();
108160 : }
108161 : #endif
108162 :
108163 : // This function is used in ROSE in treeTraversal code
108164 : // eventually replaces getVariant() and variant()
108165 : // though after variant() has been removed for a while we will
108166 : // want to change the name of variantT() back to variant()
108167 : // (since the "T" was ment to stand for temporary).
108168 : // When this happens the variantT() will be depricated.
108169 : VariantT
108170 2025 : SgOmpAllocateClause::variantT() const
108171 : {
108172 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
108173 2025 : ROSE_ASSERT(this != NULL);
108174 2025 : return V_SgOmpAllocateClause;
108175 : }
108176 :
108177 : #if 0
108178 : int
108179 : SgOmpAllocateClause::variant() const
108180 : {
108181 : // This function is used in SAGE
108182 : ROSE_ASSERT(this != NULL);
108183 : return OmpAllocateClauseTag;
108184 : }
108185 : #endif
108186 :
108187 : ROSE_DLL_API const char*
108188 0 : SgOmpAllocateClause::sage_class_name() const
108189 : {
108190 0 : ROSE_ASSERT(this != NULL);
108191 0 : return "SgOmpAllocateClause";
108192 : }
108193 :
108194 : std::string
108195 34 : SgOmpAllocateClause::class_name() const
108196 : {
108197 34 : ROSE_ASSERT(this != NULL);
108198 34 : return "SgOmpAllocateClause";
108199 : }
108200 :
108201 : // DQ (11/26/2005): Support for visitor pattern mechanims
108202 : // (inferior to ROSE traversal mechanism, experimental).
108203 : void
108204 0 : SgOmpAllocateClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
108205 : {
108206 0 : ROSE_ASSERT(this != NULL);
108207 0 : visitor.visit(this);
108208 0 : }
108209 :
108210 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
108211 0 : void SgOmpAllocateClause::accept (ROSE_VisitorPattern & visitor) {
108212 0 : ROSE_ASSERT(this != NULL);
108213 0 : visitor.visit(this);
108214 0 : }
108215 :
108216 : SgOmpAllocateClause*
108217 0 : SgOmpAllocateClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
108218 : {
108219 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
108220 : // This function is currently only supported for the AST used the represent Binary executables.
108221 : if (0 /* isSgAsmNode(this) != NULL */)
108222 : {
108223 : // Support for regex specification.
108224 : std::string prefixCode = "REGEX:";
108225 : addNewAttribute(prefixCode + s,a);
108226 : }
108227 : #endif
108228 :
108229 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
108230 0 : return this;
108231 : }
108232 :
108233 : // *** COMMON CODE SECTION ENDS HERE ***
108234 :
108235 :
108236 : // End of memberFunctionString
108237 : // Start of memberFunctionString
108238 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
108239 :
108240 :
108241 : #if 0
108242 : //! Error checking support
108243 : /*! Verifies the following:
108244 : - working getVariant() member function
108245 : - calls base class's error() member function
108246 : Every class has one of these functions.
108247 : */
108248 : bool
108249 : SgOmpAllocateClause::error()
108250 : {
108251 : // Put error checking here
108252 :
108253 : ROSE_ASSERT (this != NULL);
108254 : if (getVariant() != OmpAllocateClauseTag)
108255 : {
108256 : printf ("Error in SgOmpAllocateClause::error(): SgOmpAllocateClause object has a %s variant \n",
108257 : Cxx_GrammarTerminalNames[getVariant()].name);
108258 : // printf ("Error in SgOmpAllocateClause::error() \n");
108259 : ROSE_ABORT();
108260 : }
108261 :
108262 : ROSE_ASSERT (getVariant() == OmpAllocateClauseTag);
108263 : return SgOmpVariablesClause::error();
108264 : }
108265 : #endif
108266 :
108267 :
108268 :
108269 : // End of memberFunctionString
108270 :
108271 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
108272 :
108273 70 : SgOmpAllocateClause* isSgOmpAllocateClause ( SgNode* inputDerivedClassPointer )
108274 : {
108275 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
108276 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
108277 : // So to fix this we return NULL directly when the input is NULL and avoid the
108278 : // dynamic_cast in this case. This is likely a performance improvement as well.
108279 : // return dynamic_cast<SgOmpAllocateClause*>(inputDerivedClassPointer);
108280 : // Milind Chabbi (8/28/2013): isSgOmpAllocateClause uses table-driven castability instead of c++ default dynamic_cast
108281 : // this improves the running time performance by 10-20%.
108282 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAllocateClause*>(inputDerivedClassPointer);
108283 70 : return IS_SgOmpAllocateClause_FAST_MACRO(inputDerivedClassPointer);
108284 : }
108285 :
108286 : // DQ (11/8/2003): Added version of functions taking const pointer
108287 0 : const SgOmpAllocateClause* isSgOmpAllocateClause ( const SgNode* inputDerivedClassPointer )
108288 : {
108289 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
108290 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
108291 : // So to fix this we return NULL directly when the input is NULL and avoid the
108292 : // dynamic_cast in this case. This is likely a performance improvement as well.
108293 : // return dynamic_cast<const SgOmpAllocateClause*>(inputDerivedClassPointer);
108294 : // Milind Chabbi (8/28/2013): isSgOmpAllocateClause uses table-driven castability instead of c++ default dynamic_cast
108295 : // this improves the running time performance by 10-20%.
108296 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAllocateClause*>(inputDerivedClassPointer);
108297 0 : return IS_SgOmpAllocateClause_FAST_MACRO(inputDerivedClassPointer);
108298 : }
108299 :
108300 :
108301 :
108302 : /* #line 108303 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108303 :
108304 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
108305 :
108306 : /**
108307 : \brief Generated destructor
108308 :
108309 : This destructor is automatically generated (by ROSETTA). This destructor
108310 : only frees memory of data members associated with the parts of the current IR node which
108311 : are NOT traversed. Those data members that are part of a traversal can be freed using
108312 : a traversal (calling this destructor on all children in a post-order traversal). Such
108313 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
108314 :
108315 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
108316 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
108317 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
108318 :
108319 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
108320 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
108321 : pointers are not yet implemented to call delete on eash pointer in the container.
108322 : (This could be done by derivation from the STL containers to define containers that
108323 : automatically deleted their members.)
108324 :
108325 : */
108326 0 : SgOmpAllocateClause::~SgOmpAllocateClause () {
108327 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
108328 :
108329 :
108330 : // case: not a listType for modifier
108331 0 : p_modifier =e_omp_allocate_modifier_unknown; // non list case
108332 : // case: not a listType for user_defined_modifier
108333 0 : p_user_defined_modifier = NULL; // non list case
108334 :
108335 : }
108336 :
108337 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
108338 0 : }
108339 :
108340 :
108341 : /* #line 108342 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108342 :
108343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108344 :
108345 : // Generated constructor
108346 0 : SgOmpAllocateClause::SgOmpAllocateClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_allocate_modifier_enum modifier, SgExpression* user_defined_modifier )
108347 0 : : SgOmpVariablesClause(startOfConstruct, variables)
108348 : {
108349 : #ifdef DEBUG
108350 : // printf ("In SgOmpAllocateClause::SgOmpAllocateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_allocate_modifier_enum modifier, SgExpression* user_defined_modifier) sage_class_name() = %s \n",sage_class_name());
108351 : #endif
108352 : #if 0
108353 : // debugging information!
108354 : printf ("In SgOmpAllocateClause::SgOmpAllocateClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_allocate_modifier_enum modifier, SgExpression* user_defined_modifier): this = %p = %s \n",this,this->class_name().c_str());
108355 : #endif
108356 :
108357 0 : p_modifier = modifier;
108358 0 : p_user_defined_modifier = user_defined_modifier;
108359 :
108360 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108361 :
108362 : #if 0
108363 : // DQ (7/30/2014): Call a virtual function.
108364 : std::string s = this->class_name();
108365 : #endif
108366 :
108367 : // Test the variant virtual function
108368 : // assert(OmpAllocateClauseTag == variant());
108369 0 : assert(OmpAllocateClauseTag == this->variant());
108370 0 : ROSE_ASSERT(OmpAllocateClauseTag == (int)(this->variantT()));
108371 0 : post_construction_initialization();
108372 :
108373 : // Test the isSgOmpAllocateClause() function since it has been problematic
108374 0 : assert(isSgOmpAllocateClause(this) != NULL);
108375 0 : }
108376 :
108377 : // Generated constructor (all data members)
108378 :
108379 : /* #line 108380 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108380 :
108381 :
108382 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108383 :
108384 :
108385 : // ********************************************************
108386 : // member functions common across all array grammar objects
108387 : // ********************************************************
108388 :
108389 :
108390 :
108391 : /* #line 108392 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108392 :
108393 :
108394 :
108395 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108396 :
108397 : // ********************************************************
108398 : // member functions specific to each node in the grammar
108399 : // ********************************************************
108400 :
108401 :
108402 : /* #line 108403 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108403 :
108404 : // Start of memberFunctionString
108405 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
108406 :
108407 : // *** COMMON CODE SECTION BEGINS HERE ***
108408 :
108409 : #if 0
108410 : int
108411 : SgOmpUniformClause::getVariant() const
108412 : {
108413 : // This function is used in ROSE while "variant()" is used in SAGE
108414 : assert(this != NULL);
108415 : return variant();
108416 : }
108417 : #endif
108418 :
108419 : // This function is used in ROSE in treeTraversal code
108420 : // eventually replaces getVariant() and variant()
108421 : // though after variant() has been removed for a while we will
108422 : // want to change the name of variantT() back to variant()
108423 : // (since the "T" was ment to stand for temporary).
108424 : // When this happens the variantT() will be depricated.
108425 : VariantT
108426 174 : SgOmpUniformClause::variantT() const
108427 : {
108428 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
108429 174 : ROSE_ASSERT(this != NULL);
108430 174 : return V_SgOmpUniformClause;
108431 : }
108432 :
108433 : #if 0
108434 : int
108435 : SgOmpUniformClause::variant() const
108436 : {
108437 : // This function is used in SAGE
108438 : ROSE_ASSERT(this != NULL);
108439 : return OmpUniformClauseTag;
108440 : }
108441 : #endif
108442 :
108443 : ROSE_DLL_API const char*
108444 0 : SgOmpUniformClause::sage_class_name() const
108445 : {
108446 0 : ROSE_ASSERT(this != NULL);
108447 0 : return "SgOmpUniformClause";
108448 : }
108449 :
108450 : std::string
108451 3 : SgOmpUniformClause::class_name() const
108452 : {
108453 3 : ROSE_ASSERT(this != NULL);
108454 3 : return "SgOmpUniformClause";
108455 : }
108456 :
108457 : // DQ (11/26/2005): Support for visitor pattern mechanims
108458 : // (inferior to ROSE traversal mechanism, experimental).
108459 : void
108460 0 : SgOmpUniformClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
108461 : {
108462 0 : ROSE_ASSERT(this != NULL);
108463 0 : visitor.visit(this);
108464 0 : }
108465 :
108466 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
108467 0 : void SgOmpUniformClause::accept (ROSE_VisitorPattern & visitor) {
108468 0 : ROSE_ASSERT(this != NULL);
108469 0 : visitor.visit(this);
108470 0 : }
108471 :
108472 : SgOmpUniformClause*
108473 0 : SgOmpUniformClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
108474 : {
108475 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
108476 : // This function is currently only supported for the AST used the represent Binary executables.
108477 : if (0 /* isSgAsmNode(this) != NULL */)
108478 : {
108479 : // Support for regex specification.
108480 : std::string prefixCode = "REGEX:";
108481 : addNewAttribute(prefixCode + s,a);
108482 : }
108483 : #endif
108484 :
108485 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
108486 0 : return this;
108487 : }
108488 :
108489 : // *** COMMON CODE SECTION ENDS HERE ***
108490 :
108491 :
108492 : // End of memberFunctionString
108493 : // Start of memberFunctionString
108494 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
108495 :
108496 :
108497 : #if 0
108498 : //! Error checking support
108499 : /*! Verifies the following:
108500 : - working getVariant() member function
108501 : - calls base class's error() member function
108502 : Every class has one of these functions.
108503 : */
108504 : bool
108505 : SgOmpUniformClause::error()
108506 : {
108507 : // Put error checking here
108508 :
108509 : ROSE_ASSERT (this != NULL);
108510 : if (getVariant() != OmpUniformClauseTag)
108511 : {
108512 : printf ("Error in SgOmpUniformClause::error(): SgOmpUniformClause object has a %s variant \n",
108513 : Cxx_GrammarTerminalNames[getVariant()].name);
108514 : // printf ("Error in SgOmpUniformClause::error() \n");
108515 : ROSE_ABORT();
108516 : }
108517 :
108518 : ROSE_ASSERT (getVariant() == OmpUniformClauseTag);
108519 : return SgOmpVariablesClause::error();
108520 : }
108521 : #endif
108522 :
108523 :
108524 :
108525 : // End of memberFunctionString
108526 :
108527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
108528 :
108529 3 : SgOmpUniformClause* isSgOmpUniformClause ( SgNode* inputDerivedClassPointer )
108530 : {
108531 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
108532 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
108533 : // So to fix this we return NULL directly when the input is NULL and avoid the
108534 : // dynamic_cast in this case. This is likely a performance improvement as well.
108535 : // return dynamic_cast<SgOmpUniformClause*>(inputDerivedClassPointer);
108536 : // Milind Chabbi (8/28/2013): isSgOmpUniformClause uses table-driven castability instead of c++ default dynamic_cast
108537 : // this improves the running time performance by 10-20%.
108538 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUniformClause*>(inputDerivedClassPointer);
108539 3 : return IS_SgOmpUniformClause_FAST_MACRO(inputDerivedClassPointer);
108540 : }
108541 :
108542 : // DQ (11/8/2003): Added version of functions taking const pointer
108543 0 : const SgOmpUniformClause* isSgOmpUniformClause ( const SgNode* inputDerivedClassPointer )
108544 : {
108545 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
108546 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
108547 : // So to fix this we return NULL directly when the input is NULL and avoid the
108548 : // dynamic_cast in this case. This is likely a performance improvement as well.
108549 : // return dynamic_cast<const SgOmpUniformClause*>(inputDerivedClassPointer);
108550 : // Milind Chabbi (8/28/2013): isSgOmpUniformClause uses table-driven castability instead of c++ default dynamic_cast
108551 : // this improves the running time performance by 10-20%.
108552 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUniformClause*>(inputDerivedClassPointer);
108553 0 : return IS_SgOmpUniformClause_FAST_MACRO(inputDerivedClassPointer);
108554 : }
108555 :
108556 :
108557 :
108558 : /* #line 108559 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108559 :
108560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
108561 :
108562 : /**
108563 : \brief Generated destructor
108564 :
108565 : This destructor is automatically generated (by ROSETTA). This destructor
108566 : only frees memory of data members associated with the parts of the current IR node which
108567 : are NOT traversed. Those data members that are part of a traversal can be freed using
108568 : a traversal (calling this destructor on all children in a post-order traversal). Such
108569 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
108570 :
108571 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
108572 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
108573 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
108574 :
108575 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
108576 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
108577 : pointers are not yet implemented to call delete on eash pointer in the container.
108578 : (This could be done by derivation from the STL containers to define containers that
108579 : automatically deleted their members.)
108580 :
108581 : */
108582 0 : SgOmpUniformClause::~SgOmpUniformClause () {
108583 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
108584 :
108585 :
108586 :
108587 : }
108588 :
108589 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
108590 0 : }
108591 :
108592 :
108593 : /* #line 108594 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108594 :
108595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108596 :
108597 : // Generated constructor
108598 0 : SgOmpUniformClause::SgOmpUniformClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables )
108599 0 : : SgOmpVariablesClause(startOfConstruct, variables)
108600 : {
108601 : #ifdef DEBUG
108602 : // printf ("In SgOmpUniformClause::SgOmpUniformClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables) sage_class_name() = %s \n",sage_class_name());
108603 : #endif
108604 : #if 0
108605 : // debugging information!
108606 : printf ("In SgOmpUniformClause::SgOmpUniformClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables): this = %p = %s \n",this,this->class_name().c_str());
108607 : #endif
108608 :
108609 :
108610 :
108611 : #if 0
108612 : // DQ (7/30/2014): Call a virtual function.
108613 : std::string s = this->class_name();
108614 : #endif
108615 :
108616 : // Test the variant virtual function
108617 : // assert(OmpUniformClauseTag == variant());
108618 0 : assert(OmpUniformClauseTag == this->variant());
108619 0 : ROSE_ASSERT(OmpUniformClauseTag == (int)(this->variantT()));
108620 0 : post_construction_initialization();
108621 :
108622 : // Test the isSgOmpUniformClause() function since it has been problematic
108623 0 : assert(isSgOmpUniformClause(this) != NULL);
108624 0 : }
108625 :
108626 : // Generated constructor (all data members)
108627 :
108628 : /* #line 108629 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108629 :
108630 :
108631 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108632 :
108633 :
108634 : // ********************************************************
108635 : // member functions common across all array grammar objects
108636 : // ********************************************************
108637 :
108638 :
108639 :
108640 : /* #line 108641 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108641 :
108642 :
108643 :
108644 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108645 :
108646 : // ********************************************************
108647 : // member functions specific to each node in the grammar
108648 : // ********************************************************
108649 :
108650 :
108651 : /* #line 108652 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108652 :
108653 : // Start of memberFunctionString
108654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
108655 :
108656 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
108657 :
108658 : SgExpression*
108659 3 : SgOmpAlignedClause::get_alignment () const
108660 : {
108661 3 : ROSE_ASSERT (this != NULL);
108662 :
108663 : #if 0
108664 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108665 : // used to trigger marking transformations for the token-based unparsing.
108666 : printf ("SgOmpAlignedClause::get_alignment = %p = %s \n",this,this->class_name().c_str());
108667 : #endif
108668 :
108669 3 : return p_alignment;
108670 : }
108671 :
108672 : void
108673 0 : SgOmpAlignedClause::set_alignment ( SgExpression* alignment )
108674 : {
108675 0 : ROSE_ASSERT (this != NULL);
108676 :
108677 : #if 0
108678 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108679 : // used to trigger marking transformations for the token-based unparsing.
108680 : printf ("SgOmpAlignedClause::set_alignment = %p = %s \n",this,this->class_name().c_str());
108681 : #endif
108682 :
108683 0 : set_isModified(true);
108684 :
108685 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
108686 : if (p_alignment != NULL && alignment != NULL && p_alignment != alignment)
108687 : {
108688 : printf ("Warning: alignment = %p overwriting valid pointer p_alignment = %p \n",alignment,p_alignment);
108689 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
108690 : printf ("Error fails assertion (p_alignment != NULL && alignment != NULL && p_alignment != alignment) is false\n");
108691 : ROSE_ASSERT(false);
108692 : #endif
108693 : }
108694 : #endif
108695 0 : p_alignment = alignment;
108696 0 : }
108697 :
108698 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
108699 :
108700 :
108701 : // End of memberFunctionString
108702 : // Start of memberFunctionString
108703 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
108704 :
108705 : // *** COMMON CODE SECTION BEGINS HERE ***
108706 :
108707 : #if 0
108708 : int
108709 : SgOmpAlignedClause::getVariant() const
108710 : {
108711 : // This function is used in ROSE while "variant()" is used in SAGE
108712 : assert(this != NULL);
108713 : return variant();
108714 : }
108715 : #endif
108716 :
108717 : // This function is used in ROSE in treeTraversal code
108718 : // eventually replaces getVariant() and variant()
108719 : // though after variant() has been removed for a while we will
108720 : // want to change the name of variantT() back to variant()
108721 : // (since the "T" was ment to stand for temporary).
108722 : // When this happens the variantT() will be depricated.
108723 : VariantT
108724 69 : SgOmpAlignedClause::variantT() const
108725 : {
108726 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
108727 69 : ROSE_ASSERT(this != NULL);
108728 69 : return V_SgOmpAlignedClause;
108729 : }
108730 :
108731 : #if 0
108732 : int
108733 : SgOmpAlignedClause::variant() const
108734 : {
108735 : // This function is used in SAGE
108736 : ROSE_ASSERT(this != NULL);
108737 : return OmpAlignedClauseTag;
108738 : }
108739 : #endif
108740 :
108741 : ROSE_DLL_API const char*
108742 0 : SgOmpAlignedClause::sage_class_name() const
108743 : {
108744 0 : ROSE_ASSERT(this != NULL);
108745 0 : return "SgOmpAlignedClause";
108746 : }
108747 :
108748 : std::string
108749 2 : SgOmpAlignedClause::class_name() const
108750 : {
108751 2 : ROSE_ASSERT(this != NULL);
108752 2 : return "SgOmpAlignedClause";
108753 : }
108754 :
108755 : // DQ (11/26/2005): Support for visitor pattern mechanims
108756 : // (inferior to ROSE traversal mechanism, experimental).
108757 : void
108758 0 : SgOmpAlignedClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
108759 : {
108760 0 : ROSE_ASSERT(this != NULL);
108761 0 : visitor.visit(this);
108762 0 : }
108763 :
108764 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
108765 0 : void SgOmpAlignedClause::accept (ROSE_VisitorPattern & visitor) {
108766 0 : ROSE_ASSERT(this != NULL);
108767 0 : visitor.visit(this);
108768 0 : }
108769 :
108770 : SgOmpAlignedClause*
108771 0 : SgOmpAlignedClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
108772 : {
108773 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
108774 : // This function is currently only supported for the AST used the represent Binary executables.
108775 : if (0 /* isSgAsmNode(this) != NULL */)
108776 : {
108777 : // Support for regex specification.
108778 : std::string prefixCode = "REGEX:";
108779 : addNewAttribute(prefixCode + s,a);
108780 : }
108781 : #endif
108782 :
108783 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
108784 0 : return this;
108785 : }
108786 :
108787 : // *** COMMON CODE SECTION ENDS HERE ***
108788 :
108789 :
108790 : // End of memberFunctionString
108791 : // Start of memberFunctionString
108792 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
108793 :
108794 :
108795 : #if 0
108796 : //! Error checking support
108797 : /*! Verifies the following:
108798 : - working getVariant() member function
108799 : - calls base class's error() member function
108800 : Every class has one of these functions.
108801 : */
108802 : bool
108803 : SgOmpAlignedClause::error()
108804 : {
108805 : // Put error checking here
108806 :
108807 : ROSE_ASSERT (this != NULL);
108808 : if (getVariant() != OmpAlignedClauseTag)
108809 : {
108810 : printf ("Error in SgOmpAlignedClause::error(): SgOmpAlignedClause object has a %s variant \n",
108811 : Cxx_GrammarTerminalNames[getVariant()].name);
108812 : // printf ("Error in SgOmpAlignedClause::error() \n");
108813 : ROSE_ABORT();
108814 : }
108815 :
108816 : ROSE_ASSERT (getVariant() == OmpAlignedClauseTag);
108817 : return SgOmpVariablesClause::error();
108818 : }
108819 : #endif
108820 :
108821 :
108822 :
108823 : // End of memberFunctionString
108824 :
108825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
108826 :
108827 427 : SgOmpAlignedClause* isSgOmpAlignedClause ( SgNode* inputDerivedClassPointer )
108828 : {
108829 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
108830 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
108831 : // So to fix this we return NULL directly when the input is NULL and avoid the
108832 : // dynamic_cast in this case. This is likely a performance improvement as well.
108833 : // return dynamic_cast<SgOmpAlignedClause*>(inputDerivedClassPointer);
108834 : // Milind Chabbi (8/28/2013): isSgOmpAlignedClause uses table-driven castability instead of c++ default dynamic_cast
108835 : // this improves the running time performance by 10-20%.
108836 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAlignedClause*>(inputDerivedClassPointer);
108837 427 : return IS_SgOmpAlignedClause_FAST_MACRO(inputDerivedClassPointer);
108838 : }
108839 :
108840 : // DQ (11/8/2003): Added version of functions taking const pointer
108841 0 : const SgOmpAlignedClause* isSgOmpAlignedClause ( const SgNode* inputDerivedClassPointer )
108842 : {
108843 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
108844 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
108845 : // So to fix this we return NULL directly when the input is NULL and avoid the
108846 : // dynamic_cast in this case. This is likely a performance improvement as well.
108847 : // return dynamic_cast<const SgOmpAlignedClause*>(inputDerivedClassPointer);
108848 : // Milind Chabbi (8/28/2013): isSgOmpAlignedClause uses table-driven castability instead of c++ default dynamic_cast
108849 : // this improves the running time performance by 10-20%.
108850 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAlignedClause*>(inputDerivedClassPointer);
108851 0 : return IS_SgOmpAlignedClause_FAST_MACRO(inputDerivedClassPointer);
108852 : }
108853 :
108854 :
108855 :
108856 : /* #line 108857 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108857 :
108858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
108859 :
108860 : /**
108861 : \brief Generated destructor
108862 :
108863 : This destructor is automatically generated (by ROSETTA). This destructor
108864 : only frees memory of data members associated with the parts of the current IR node which
108865 : are NOT traversed. Those data members that are part of a traversal can be freed using
108866 : a traversal (calling this destructor on all children in a post-order traversal). Such
108867 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
108868 :
108869 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
108870 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
108871 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
108872 :
108873 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
108874 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
108875 : pointers are not yet implemented to call delete on eash pointer in the container.
108876 : (This could be done by derivation from the STL containers to define containers that
108877 : automatically deleted their members.)
108878 :
108879 : */
108880 0 : SgOmpAlignedClause::~SgOmpAlignedClause () {
108881 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
108882 :
108883 :
108884 : // case: not a listType for alignment
108885 0 : p_alignment = NULL; // non list case
108886 :
108887 : }
108888 :
108889 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
108890 0 : }
108891 :
108892 :
108893 : /* #line 108894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108894 :
108895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108896 :
108897 : // Generated constructor
108898 0 : SgOmpAlignedClause::SgOmpAlignedClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgExpression* alignment )
108899 0 : : SgOmpVariablesClause(startOfConstruct, variables)
108900 : {
108901 : #ifdef DEBUG
108902 : // printf ("In SgOmpAlignedClause::SgOmpAlignedClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgExpression* alignment) sage_class_name() = %s \n",sage_class_name());
108903 : #endif
108904 : #if 0
108905 : // debugging information!
108906 : printf ("In SgOmpAlignedClause::SgOmpAlignedClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgExpression* alignment): this = %p = %s \n",this,this->class_name().c_str());
108907 : #endif
108908 :
108909 0 : p_alignment = alignment;
108910 :
108911 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
108912 :
108913 : #if 0
108914 : // DQ (7/30/2014): Call a virtual function.
108915 : std::string s = this->class_name();
108916 : #endif
108917 :
108918 : // Test the variant virtual function
108919 : // assert(OmpAlignedClauseTag == variant());
108920 0 : assert(OmpAlignedClauseTag == this->variant());
108921 0 : ROSE_ASSERT(OmpAlignedClauseTag == (int)(this->variantT()));
108922 0 : post_construction_initialization();
108923 :
108924 : // Test the isSgOmpAlignedClause() function since it has been problematic
108925 0 : assert(isSgOmpAlignedClause(this) != NULL);
108926 0 : }
108927 :
108928 : // Generated constructor (all data members)
108929 :
108930 : /* #line 108931 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108931 :
108932 :
108933 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108934 :
108935 :
108936 : // ********************************************************
108937 : // member functions common across all array grammar objects
108938 : // ********************************************************
108939 :
108940 :
108941 :
108942 : /* #line 108943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108943 :
108944 :
108945 :
108946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
108947 :
108948 : // ********************************************************
108949 : // member functions specific to each node in the grammar
108950 : // ********************************************************
108951 :
108952 :
108953 : /* #line 108954 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
108954 :
108955 : // Start of memberFunctionString
108956 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
108957 :
108958 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
108959 :
108960 : SgExpression*
108961 10 : SgOmpLinearClause::get_step () const
108962 : {
108963 10 : ROSE_ASSERT (this != NULL);
108964 :
108965 : #if 0
108966 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108967 : // used to trigger marking transformations for the token-based unparsing.
108968 : printf ("SgOmpLinearClause::get_step = %p = %s \n",this,this->class_name().c_str());
108969 : #endif
108970 :
108971 10 : return p_step;
108972 : }
108973 :
108974 : void
108975 0 : SgOmpLinearClause::set_step ( SgExpression* step )
108976 : {
108977 0 : ROSE_ASSERT (this != NULL);
108978 :
108979 : #if 0
108980 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
108981 : // used to trigger marking transformations for the token-based unparsing.
108982 : printf ("SgOmpLinearClause::set_step = %p = %s \n",this,this->class_name().c_str());
108983 : #endif
108984 :
108985 0 : set_isModified(true);
108986 :
108987 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
108988 : if (p_step != NULL && step != NULL && p_step != step)
108989 : {
108990 : printf ("Warning: step = %p overwriting valid pointer p_step = %p \n",step,p_step);
108991 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
108992 : printf ("Error fails assertion (p_step != NULL && step != NULL && p_step != step) is false\n");
108993 : ROSE_ASSERT(false);
108994 : #endif
108995 : }
108996 : #endif
108997 0 : p_step = step;
108998 0 : }
108999 :
109000 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109001 :
109002 :
109003 : // End of memberFunctionString
109004 : // Start of memberFunctionString
109005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109006 :
109007 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109008 :
109009 : SgOmpClause::omp_linear_modifier_enum
109010 12 : SgOmpLinearClause::get_modifier () const
109011 : {
109012 12 : ROSE_ASSERT (this != NULL);
109013 :
109014 : #if 0
109015 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109016 : // used to trigger marking transformations for the token-based unparsing.
109017 : printf ("SgOmpLinearClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
109018 : #endif
109019 :
109020 12 : return p_modifier;
109021 : }
109022 :
109023 : void
109024 0 : SgOmpLinearClause::set_modifier ( SgOmpClause::omp_linear_modifier_enum modifier )
109025 : {
109026 0 : ROSE_ASSERT (this != NULL);
109027 :
109028 : #if 0
109029 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109030 : // used to trigger marking transformations for the token-based unparsing.
109031 : printf ("SgOmpLinearClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
109032 : #endif
109033 :
109034 0 : set_isModified(true);
109035 :
109036 0 : p_modifier = modifier;
109037 0 : }
109038 :
109039 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109040 :
109041 :
109042 : // End of memberFunctionString
109043 : // Start of memberFunctionString
109044 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
109045 :
109046 : // *** COMMON CODE SECTION BEGINS HERE ***
109047 :
109048 : #if 0
109049 : int
109050 : SgOmpLinearClause::getVariant() const
109051 : {
109052 : // This function is used in ROSE while "variant()" is used in SAGE
109053 : assert(this != NULL);
109054 : return variant();
109055 : }
109056 : #endif
109057 :
109058 : // This function is used in ROSE in treeTraversal code
109059 : // eventually replaces getVariant() and variant()
109060 : // though after variant() has been removed for a while we will
109061 : // want to change the name of variantT() back to variant()
109062 : // (since the "T" was ment to stand for temporary).
109063 : // When this happens the variantT() will be depricated.
109064 : VariantT
109065 270 : SgOmpLinearClause::variantT() const
109066 : {
109067 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
109068 270 : ROSE_ASSERT(this != NULL);
109069 270 : return V_SgOmpLinearClause;
109070 : }
109071 :
109072 : #if 0
109073 : int
109074 : SgOmpLinearClause::variant() const
109075 : {
109076 : // This function is used in SAGE
109077 : ROSE_ASSERT(this != NULL);
109078 : return OmpLinearClauseTag;
109079 : }
109080 : #endif
109081 :
109082 : ROSE_DLL_API const char*
109083 0 : SgOmpLinearClause::sage_class_name() const
109084 : {
109085 0 : ROSE_ASSERT(this != NULL);
109086 0 : return "SgOmpLinearClause";
109087 : }
109088 :
109089 : std::string
109090 6 : SgOmpLinearClause::class_name() const
109091 : {
109092 6 : ROSE_ASSERT(this != NULL);
109093 6 : return "SgOmpLinearClause";
109094 : }
109095 :
109096 : // DQ (11/26/2005): Support for visitor pattern mechanims
109097 : // (inferior to ROSE traversal mechanism, experimental).
109098 : void
109099 0 : SgOmpLinearClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
109100 : {
109101 0 : ROSE_ASSERT(this != NULL);
109102 0 : visitor.visit(this);
109103 0 : }
109104 :
109105 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
109106 0 : void SgOmpLinearClause::accept (ROSE_VisitorPattern & visitor) {
109107 0 : ROSE_ASSERT(this != NULL);
109108 0 : visitor.visit(this);
109109 0 : }
109110 :
109111 : SgOmpLinearClause*
109112 0 : SgOmpLinearClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
109113 : {
109114 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
109115 : // This function is currently only supported for the AST used the represent Binary executables.
109116 : if (0 /* isSgAsmNode(this) != NULL */)
109117 : {
109118 : // Support for regex specification.
109119 : std::string prefixCode = "REGEX:";
109120 : addNewAttribute(prefixCode + s,a);
109121 : }
109122 : #endif
109123 :
109124 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
109125 0 : return this;
109126 : }
109127 :
109128 : // *** COMMON CODE SECTION ENDS HERE ***
109129 :
109130 :
109131 : // End of memberFunctionString
109132 : // Start of memberFunctionString
109133 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
109134 :
109135 :
109136 : #if 0
109137 : //! Error checking support
109138 : /*! Verifies the following:
109139 : - working getVariant() member function
109140 : - calls base class's error() member function
109141 : Every class has one of these functions.
109142 : */
109143 : bool
109144 : SgOmpLinearClause::error()
109145 : {
109146 : // Put error checking here
109147 :
109148 : ROSE_ASSERT (this != NULL);
109149 : if (getVariant() != OmpLinearClauseTag)
109150 : {
109151 : printf ("Error in SgOmpLinearClause::error(): SgOmpLinearClause object has a %s variant \n",
109152 : Cxx_GrammarTerminalNames[getVariant()].name);
109153 : // printf ("Error in SgOmpLinearClause::error() \n");
109154 : ROSE_ABORT();
109155 : }
109156 :
109157 : ROSE_ASSERT (getVariant() == OmpLinearClauseTag);
109158 : return SgOmpVariablesClause::error();
109159 : }
109160 : #endif
109161 :
109162 :
109163 :
109164 : // End of memberFunctionString
109165 :
109166 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
109167 :
109168 838 : SgOmpLinearClause* isSgOmpLinearClause ( SgNode* inputDerivedClassPointer )
109169 : {
109170 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
109171 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
109172 : // So to fix this we return NULL directly when the input is NULL and avoid the
109173 : // dynamic_cast in this case. This is likely a performance improvement as well.
109174 : // return dynamic_cast<SgOmpLinearClause*>(inputDerivedClassPointer);
109175 : // Milind Chabbi (8/28/2013): isSgOmpLinearClause uses table-driven castability instead of c++ default dynamic_cast
109176 : // this improves the running time performance by 10-20%.
109177 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpLinearClause*>(inputDerivedClassPointer);
109178 838 : return IS_SgOmpLinearClause_FAST_MACRO(inputDerivedClassPointer);
109179 : }
109180 :
109181 : // DQ (11/8/2003): Added version of functions taking const pointer
109182 0 : const SgOmpLinearClause* isSgOmpLinearClause ( const SgNode* inputDerivedClassPointer )
109183 : {
109184 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
109185 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
109186 : // So to fix this we return NULL directly when the input is NULL and avoid the
109187 : // dynamic_cast in this case. This is likely a performance improvement as well.
109188 : // return dynamic_cast<const SgOmpLinearClause*>(inputDerivedClassPointer);
109189 : // Milind Chabbi (8/28/2013): isSgOmpLinearClause uses table-driven castability instead of c++ default dynamic_cast
109190 : // this improves the running time performance by 10-20%.
109191 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpLinearClause*>(inputDerivedClassPointer);
109192 0 : return IS_SgOmpLinearClause_FAST_MACRO(inputDerivedClassPointer);
109193 : }
109194 :
109195 :
109196 :
109197 : /* #line 109198 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109198 :
109199 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
109200 :
109201 : /**
109202 : \brief Generated destructor
109203 :
109204 : This destructor is automatically generated (by ROSETTA). This destructor
109205 : only frees memory of data members associated with the parts of the current IR node which
109206 : are NOT traversed. Those data members that are part of a traversal can be freed using
109207 : a traversal (calling this destructor on all children in a post-order traversal). Such
109208 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
109209 :
109210 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
109211 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
109212 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
109213 :
109214 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
109215 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
109216 : pointers are not yet implemented to call delete on eash pointer in the container.
109217 : (This could be done by derivation from the STL containers to define containers that
109218 : automatically deleted their members.)
109219 :
109220 : */
109221 0 : SgOmpLinearClause::~SgOmpLinearClause () {
109222 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
109223 :
109224 :
109225 : // case: not a listType for step
109226 0 : p_step = NULL; // non list case
109227 : // case: not a listType for modifier
109228 0 : p_modifier =e_omp_linear_modifier_unspecified; // non list case
109229 :
109230 : }
109231 :
109232 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
109233 0 : }
109234 :
109235 :
109236 : /* #line 109237 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109237 :
109238 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
109239 :
109240 : // Generated constructor
109241 0 : SgOmpLinearClause::SgOmpLinearClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgExpression* step, SgOmpClause::omp_linear_modifier_enum modifier )
109242 0 : : SgOmpVariablesClause(startOfConstruct, variables)
109243 : {
109244 : #ifdef DEBUG
109245 : // printf ("In SgOmpLinearClause::SgOmpLinearClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgExpression* step, SgOmpClause::omp_linear_modifier_enum modifier) sage_class_name() = %s \n",sage_class_name());
109246 : #endif
109247 : #if 0
109248 : // debugging information!
109249 : printf ("In SgOmpLinearClause::SgOmpLinearClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgExpression* step, SgOmpClause::omp_linear_modifier_enum modifier): this = %p = %s \n",this,this->class_name().c_str());
109250 : #endif
109251 :
109252 0 : p_step = step;
109253 0 : p_modifier = modifier;
109254 :
109255 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
109256 :
109257 : #if 0
109258 : // DQ (7/30/2014): Call a virtual function.
109259 : std::string s = this->class_name();
109260 : #endif
109261 :
109262 : // Test the variant virtual function
109263 : // assert(OmpLinearClauseTag == variant());
109264 0 : assert(OmpLinearClauseTag == this->variant());
109265 0 : ROSE_ASSERT(OmpLinearClauseTag == (int)(this->variantT()));
109266 0 : post_construction_initialization();
109267 :
109268 : // Test the isSgOmpLinearClause() function since it has been problematic
109269 0 : assert(isSgOmpLinearClause(this) != NULL);
109270 0 : }
109271 :
109272 : // Generated constructor (all data members)
109273 :
109274 : /* #line 109275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109275 :
109276 :
109277 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
109278 :
109279 :
109280 : // ********************************************************
109281 : // member functions common across all array grammar objects
109282 : // ********************************************************
109283 :
109284 :
109285 :
109286 : /* #line 109287 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109287 :
109288 :
109289 :
109290 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
109291 :
109292 : // ********************************************************
109293 : // member functions specific to each node in the grammar
109294 : // ********************************************************
109295 :
109296 :
109297 : /* #line 109298 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109298 :
109299 : // Start of memberFunctionString
109300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109301 :
109302 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109303 :
109304 : SgOmpClause::omp_depend_modifier_enum
109305 21 : SgOmpDependClause::get_depend_modifier () const
109306 : {
109307 21 : ROSE_ASSERT (this != NULL);
109308 :
109309 : #if 0
109310 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109311 : // used to trigger marking transformations for the token-based unparsing.
109312 : printf ("SgOmpDependClause::get_depend_modifier = %p = %s \n",this,this->class_name().c_str());
109313 : #endif
109314 :
109315 21 : return p_depend_modifier;
109316 : }
109317 :
109318 : void
109319 0 : SgOmpDependClause::set_depend_modifier ( SgOmpClause::omp_depend_modifier_enum depend_modifier )
109320 : {
109321 0 : ROSE_ASSERT (this != NULL);
109322 :
109323 : #if 0
109324 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109325 : // used to trigger marking transformations for the token-based unparsing.
109326 : printf ("SgOmpDependClause::set_depend_modifier = %p = %s \n",this,this->class_name().c_str());
109327 : #endif
109328 :
109329 0 : set_isModified(true);
109330 :
109331 0 : p_depend_modifier = depend_modifier;
109332 0 : }
109333 :
109334 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109335 :
109336 :
109337 : // End of memberFunctionString
109338 : // Start of memberFunctionString
109339 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109340 :
109341 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109342 :
109343 : SgOmpClause::omp_dependence_type_enum
109344 57 : SgOmpDependClause::get_dependence_type () const
109345 : {
109346 57 : ROSE_ASSERT (this != NULL);
109347 :
109348 : #if 0
109349 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109350 : // used to trigger marking transformations for the token-based unparsing.
109351 : printf ("SgOmpDependClause::get_dependence_type = %p = %s \n",this,this->class_name().c_str());
109352 : #endif
109353 :
109354 57 : return p_dependence_type;
109355 : }
109356 :
109357 : void
109358 0 : SgOmpDependClause::set_dependence_type ( SgOmpClause::omp_dependence_type_enum dependence_type )
109359 : {
109360 0 : ROSE_ASSERT (this != NULL);
109361 :
109362 : #if 0
109363 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109364 : // used to trigger marking transformations for the token-based unparsing.
109365 : printf ("SgOmpDependClause::set_dependence_type = %p = %s \n",this,this->class_name().c_str());
109366 : #endif
109367 :
109368 0 : set_isModified(true);
109369 :
109370 0 : p_dependence_type = dependence_type;
109371 0 : }
109372 :
109373 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109374 :
109375 :
109376 : // End of memberFunctionString
109377 : // Start of memberFunctionString
109378 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109379 :
109380 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109381 :
109382 : std::list<std::list<SgExpression*> >
109383 2 : SgOmpDependClause::get_iterator () const
109384 : {
109385 2 : ROSE_ASSERT (this != NULL);
109386 :
109387 : #if 0
109388 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109389 : // used to trigger marking transformations for the token-based unparsing.
109390 : printf ("SgOmpDependClause::get_iterator = %p = %s \n",this,this->class_name().c_str());
109391 : #endif
109392 :
109393 2 : return p_iterator;
109394 : }
109395 :
109396 : void
109397 19 : SgOmpDependClause::set_iterator ( std::list<std::list<SgExpression*> > iterator )
109398 : {
109399 19 : ROSE_ASSERT (this != NULL);
109400 :
109401 : #if 0
109402 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109403 : // used to trigger marking transformations for the token-based unparsing.
109404 : printf ("SgOmpDependClause::set_iterator = %p = %s \n",this,this->class_name().c_str());
109405 : #endif
109406 :
109407 19 : set_isModified(true);
109408 :
109409 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
109410 : if (p_iterator != NULL && iterator != NULL && p_iterator != iterator)
109411 : {
109412 : printf ("Warning: iterator = %p overwriting valid pointer p_iterator = %p \n",iterator,p_iterator);
109413 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
109414 : printf ("Error fails assertion (p_iterator != NULL && iterator != NULL && p_iterator != iterator) is false\n");
109415 : ROSE_ASSERT(false);
109416 : #endif
109417 : }
109418 : #endif
109419 19 : p_iterator = iterator;
109420 19 : }
109421 :
109422 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109423 :
109424 :
109425 : // End of memberFunctionString
109426 : // Start of memberFunctionString
109427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109428 :
109429 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109430 :
109431 : std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >
109432 19 : SgOmpDependClause::get_array_dimensions () const
109433 : {
109434 19 : ROSE_ASSERT (this != NULL);
109435 :
109436 : #if 0
109437 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109438 : // used to trigger marking transformations for the token-based unparsing.
109439 : printf ("SgOmpDependClause::get_array_dimensions = %p = %s \n",this,this->class_name().c_str());
109440 : #endif
109441 :
109442 19 : return p_array_dimensions;
109443 : }
109444 :
109445 : void
109446 19 : SgOmpDependClause::set_array_dimensions ( std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > array_dimensions )
109447 : {
109448 19 : ROSE_ASSERT (this != NULL);
109449 :
109450 : #if 0
109451 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109452 : // used to trigger marking transformations for the token-based unparsing.
109453 : printf ("SgOmpDependClause::set_array_dimensions = %p = %s \n",this,this->class_name().c_str());
109454 : #endif
109455 :
109456 19 : set_isModified(true);
109457 :
109458 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
109459 : if (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions)
109460 : {
109461 : printf ("Warning: array_dimensions = %p overwriting valid pointer p_array_dimensions = %p \n",array_dimensions,p_array_dimensions);
109462 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
109463 : printf ("Error fails assertion (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions) is false\n");
109464 : ROSE_ASSERT(false);
109465 : #endif
109466 : }
109467 : #endif
109468 19 : p_array_dimensions = array_dimensions;
109469 19 : }
109470 :
109471 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109472 :
109473 :
109474 : // End of memberFunctionString
109475 : // Start of memberFunctionString
109476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109477 :
109478 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109479 :
109480 : std::list<SgExpression*>
109481 1 : SgOmpDependClause::get_vec () const
109482 : {
109483 1 : ROSE_ASSERT (this != NULL);
109484 :
109485 : #if 0
109486 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109487 : // used to trigger marking transformations for the token-based unparsing.
109488 : printf ("SgOmpDependClause::get_vec = %p = %s \n",this,this->class_name().c_str());
109489 : #endif
109490 :
109491 1 : return p_vec;
109492 : }
109493 :
109494 : void
109495 19 : SgOmpDependClause::set_vec ( std::list<SgExpression*> vec )
109496 : {
109497 19 : ROSE_ASSERT (this != NULL);
109498 :
109499 : #if 0
109500 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109501 : // used to trigger marking transformations for the token-based unparsing.
109502 : printf ("SgOmpDependClause::set_vec = %p = %s \n",this,this->class_name().c_str());
109503 : #endif
109504 :
109505 19 : set_isModified(true);
109506 :
109507 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
109508 : if (p_vec != NULL && vec != NULL && p_vec != vec)
109509 : {
109510 : printf ("Warning: vec = %p overwriting valid pointer p_vec = %p \n",vec,p_vec);
109511 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
109512 : printf ("Error fails assertion (p_vec != NULL && vec != NULL && p_vec != vec) is false\n");
109513 : ROSE_ASSERT(false);
109514 : #endif
109515 : }
109516 : #endif
109517 19 : p_vec = vec;
109518 19 : }
109519 :
109520 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109521 :
109522 :
109523 : // End of memberFunctionString
109524 : // Start of memberFunctionString
109525 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
109526 :
109527 : // *** COMMON CODE SECTION BEGINS HERE ***
109528 :
109529 : #if 0
109530 : int
109531 : SgOmpDependClause::getVariant() const
109532 : {
109533 : // This function is used in ROSE while "variant()" is used in SAGE
109534 : assert(this != NULL);
109535 : return variant();
109536 : }
109537 : #endif
109538 :
109539 : // This function is used in ROSE in treeTraversal code
109540 : // eventually replaces getVariant() and variant()
109541 : // though after variant() has been removed for a while we will
109542 : // want to change the name of variantT() back to variant()
109543 : // (since the "T" was ment to stand for temporary).
109544 : // When this happens the variantT() will be depricated.
109545 : VariantT
109546 1174 : SgOmpDependClause::variantT() const
109547 : {
109548 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
109549 1174 : ROSE_ASSERT(this != NULL);
109550 1174 : return V_SgOmpDependClause;
109551 : }
109552 :
109553 : #if 0
109554 : int
109555 : SgOmpDependClause::variant() const
109556 : {
109557 : // This function is used in SAGE
109558 : ROSE_ASSERT(this != NULL);
109559 : return OmpDependClauseTag;
109560 : }
109561 : #endif
109562 :
109563 : ROSE_DLL_API const char*
109564 0 : SgOmpDependClause::sage_class_name() const
109565 : {
109566 0 : ROSE_ASSERT(this != NULL);
109567 0 : return "SgOmpDependClause";
109568 : }
109569 :
109570 : std::string
109571 19 : SgOmpDependClause::class_name() const
109572 : {
109573 19 : ROSE_ASSERT(this != NULL);
109574 19 : return "SgOmpDependClause";
109575 : }
109576 :
109577 : // DQ (11/26/2005): Support for visitor pattern mechanims
109578 : // (inferior to ROSE traversal mechanism, experimental).
109579 : void
109580 0 : SgOmpDependClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
109581 : {
109582 0 : ROSE_ASSERT(this != NULL);
109583 0 : visitor.visit(this);
109584 0 : }
109585 :
109586 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
109587 0 : void SgOmpDependClause::accept (ROSE_VisitorPattern & visitor) {
109588 0 : ROSE_ASSERT(this != NULL);
109589 0 : visitor.visit(this);
109590 0 : }
109591 :
109592 : SgOmpDependClause*
109593 0 : SgOmpDependClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
109594 : {
109595 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
109596 : // This function is currently only supported for the AST used the represent Binary executables.
109597 : if (0 /* isSgAsmNode(this) != NULL */)
109598 : {
109599 : // Support for regex specification.
109600 : std::string prefixCode = "REGEX:";
109601 : addNewAttribute(prefixCode + s,a);
109602 : }
109603 : #endif
109604 :
109605 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
109606 0 : return this;
109607 : }
109608 :
109609 : // *** COMMON CODE SECTION ENDS HERE ***
109610 :
109611 :
109612 : // End of memberFunctionString
109613 : // Start of memberFunctionString
109614 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
109615 :
109616 :
109617 : #if 0
109618 : //! Error checking support
109619 : /*! Verifies the following:
109620 : - working getVariant() member function
109621 : - calls base class's error() member function
109622 : Every class has one of these functions.
109623 : */
109624 : bool
109625 : SgOmpDependClause::error()
109626 : {
109627 : // Put error checking here
109628 :
109629 : ROSE_ASSERT (this != NULL);
109630 : if (getVariant() != OmpDependClauseTag)
109631 : {
109632 : printf ("Error in SgOmpDependClause::error(): SgOmpDependClause object has a %s variant \n",
109633 : Cxx_GrammarTerminalNames[getVariant()].name);
109634 : // printf ("Error in SgOmpDependClause::error() \n");
109635 : ROSE_ABORT();
109636 : }
109637 :
109638 : ROSE_ASSERT (getVariant() == OmpDependClauseTag);
109639 : return SgOmpVariablesClause::error();
109640 : }
109641 : #endif
109642 :
109643 :
109644 :
109645 : // End of memberFunctionString
109646 :
109647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
109648 :
109649 507 : SgOmpDependClause* isSgOmpDependClause ( SgNode* inputDerivedClassPointer )
109650 : {
109651 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
109652 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
109653 : // So to fix this we return NULL directly when the input is NULL and avoid the
109654 : // dynamic_cast in this case. This is likely a performance improvement as well.
109655 : // return dynamic_cast<SgOmpDependClause*>(inputDerivedClassPointer);
109656 : // Milind Chabbi (8/28/2013): isSgOmpDependClause uses table-driven castability instead of c++ default dynamic_cast
109657 : // this improves the running time performance by 10-20%.
109658 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDependClause*>(inputDerivedClassPointer);
109659 507 : return IS_SgOmpDependClause_FAST_MACRO(inputDerivedClassPointer);
109660 : }
109661 :
109662 : // DQ (11/8/2003): Added version of functions taking const pointer
109663 0 : const SgOmpDependClause* isSgOmpDependClause ( const SgNode* inputDerivedClassPointer )
109664 : {
109665 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
109666 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
109667 : // So to fix this we return NULL directly when the input is NULL and avoid the
109668 : // dynamic_cast in this case. This is likely a performance improvement as well.
109669 : // return dynamic_cast<const SgOmpDependClause*>(inputDerivedClassPointer);
109670 : // Milind Chabbi (8/28/2013): isSgOmpDependClause uses table-driven castability instead of c++ default dynamic_cast
109671 : // this improves the running time performance by 10-20%.
109672 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDependClause*>(inputDerivedClassPointer);
109673 0 : return IS_SgOmpDependClause_FAST_MACRO(inputDerivedClassPointer);
109674 : }
109675 :
109676 :
109677 :
109678 : /* #line 109679 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109679 :
109680 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
109681 :
109682 : /**
109683 : \brief Generated destructor
109684 :
109685 : This destructor is automatically generated (by ROSETTA). This destructor
109686 : only frees memory of data members associated with the parts of the current IR node which
109687 : are NOT traversed. Those data members that are part of a traversal can be freed using
109688 : a traversal (calling this destructor on all children in a post-order traversal). Such
109689 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
109690 :
109691 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
109692 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
109693 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
109694 :
109695 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
109696 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
109697 : pointers are not yet implemented to call delete on eash pointer in the container.
109698 : (This could be done by derivation from the STL containers to define containers that
109699 : automatically deleted their members.)
109700 :
109701 : */
109702 0 : SgOmpDependClause::~SgOmpDependClause () {
109703 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
109704 :
109705 :
109706 : // case: not a listType for depend_modifier
109707 0 : p_depend_modifier =e_omp_depend_modifier_unspecified; // non list case
109708 : // case: not a listType for dependence_type
109709 0 : p_dependence_type =e_omp_depend_unspecified; // non list case
109710 :
109711 : }
109712 :
109713 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
109714 0 : }
109715 :
109716 :
109717 : /* #line 109718 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109718 :
109719 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
109720 :
109721 : // Generated constructor
109722 0 : SgOmpDependClause::SgOmpDependClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_depend_modifier_enum depend_modifier, SgOmpClause::omp_dependence_type_enum dependence_type )
109723 0 : : SgOmpVariablesClause(startOfConstruct, variables)
109724 : {
109725 : #ifdef DEBUG
109726 : // printf ("In SgOmpDependClause::SgOmpDependClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_depend_modifier_enum depend_modifier, SgOmpClause::omp_dependence_type_enum dependence_type) sage_class_name() = %s \n",sage_class_name());
109727 : #endif
109728 : #if 0
109729 : // debugging information!
109730 : printf ("In SgOmpDependClause::SgOmpDependClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_depend_modifier_enum depend_modifier, SgOmpClause::omp_dependence_type_enum dependence_type): this = %p = %s \n",this,this->class_name().c_str());
109731 : #endif
109732 :
109733 0 : p_depend_modifier = depend_modifier;
109734 0 : p_dependence_type = dependence_type;
109735 :
109736 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
109737 :
109738 : #if 0
109739 : // DQ (7/30/2014): Call a virtual function.
109740 : std::string s = this->class_name();
109741 : #endif
109742 :
109743 : // Test the variant virtual function
109744 : // assert(OmpDependClauseTag == variant());
109745 0 : assert(OmpDependClauseTag == this->variant());
109746 0 : ROSE_ASSERT(OmpDependClauseTag == (int)(this->variantT()));
109747 0 : post_construction_initialization();
109748 :
109749 : // Test the isSgOmpDependClause() function since it has been problematic
109750 0 : assert(isSgOmpDependClause(this) != NULL);
109751 0 : }
109752 :
109753 : // Generated constructor (all data members)
109754 :
109755 : /* #line 109756 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109756 :
109757 :
109758 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
109759 :
109760 :
109761 : // ********************************************************
109762 : // member functions common across all array grammar objects
109763 : // ********************************************************
109764 :
109765 :
109766 :
109767 : /* #line 109768 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109768 :
109769 :
109770 :
109771 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
109772 :
109773 : // ********************************************************
109774 : // member functions specific to each node in the grammar
109775 : // ********************************************************
109776 :
109777 :
109778 : /* #line 109779 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
109779 :
109780 : // Start of memberFunctionString
109781 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109782 :
109783 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109784 :
109785 : SgOmpClause::omp_affinity_modifier_enum
109786 5 : SgOmpAffinityClause::get_affinity_modifier () const
109787 : {
109788 5 : ROSE_ASSERT (this != NULL);
109789 :
109790 : #if 0
109791 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109792 : // used to trigger marking transformations for the token-based unparsing.
109793 : printf ("SgOmpAffinityClause::get_affinity_modifier = %p = %s \n",this,this->class_name().c_str());
109794 : #endif
109795 :
109796 5 : return p_affinity_modifier;
109797 : }
109798 :
109799 : void
109800 0 : SgOmpAffinityClause::set_affinity_modifier ( SgOmpClause::omp_affinity_modifier_enum affinity_modifier )
109801 : {
109802 0 : ROSE_ASSERT (this != NULL);
109803 :
109804 : #if 0
109805 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109806 : // used to trigger marking transformations for the token-based unparsing.
109807 : printf ("SgOmpAffinityClause::set_affinity_modifier = %p = %s \n",this,this->class_name().c_str());
109808 : #endif
109809 :
109810 0 : set_isModified(true);
109811 :
109812 0 : p_affinity_modifier = affinity_modifier;
109813 0 : }
109814 :
109815 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109816 :
109817 :
109818 : // End of memberFunctionString
109819 : // Start of memberFunctionString
109820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109821 :
109822 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109823 :
109824 : std::list<std::list<SgExpression*> >
109825 1 : SgOmpAffinityClause::get_iterator () const
109826 : {
109827 1 : ROSE_ASSERT (this != NULL);
109828 :
109829 : #if 0
109830 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109831 : // used to trigger marking transformations for the token-based unparsing.
109832 : printf ("SgOmpAffinityClause::get_iterator = %p = %s \n",this,this->class_name().c_str());
109833 : #endif
109834 :
109835 1 : return p_iterator;
109836 : }
109837 :
109838 : void
109839 4 : SgOmpAffinityClause::set_iterator ( std::list<std::list<SgExpression*> > iterator )
109840 : {
109841 4 : ROSE_ASSERT (this != NULL);
109842 :
109843 : #if 0
109844 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109845 : // used to trigger marking transformations for the token-based unparsing.
109846 : printf ("SgOmpAffinityClause::set_iterator = %p = %s \n",this,this->class_name().c_str());
109847 : #endif
109848 :
109849 4 : set_isModified(true);
109850 :
109851 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
109852 : if (p_iterator != NULL && iterator != NULL && p_iterator != iterator)
109853 : {
109854 : printf ("Warning: iterator = %p overwriting valid pointer p_iterator = %p \n",iterator,p_iterator);
109855 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
109856 : printf ("Error fails assertion (p_iterator != NULL && iterator != NULL && p_iterator != iterator) is false\n");
109857 : ROSE_ASSERT(false);
109858 : #endif
109859 : }
109860 : #endif
109861 4 : p_iterator = iterator;
109862 4 : }
109863 :
109864 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109865 :
109866 :
109867 : // End of memberFunctionString
109868 : // Start of memberFunctionString
109869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
109870 :
109871 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
109872 :
109873 : std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >
109874 4 : SgOmpAffinityClause::get_array_dimensions () const
109875 : {
109876 4 : ROSE_ASSERT (this != NULL);
109877 :
109878 : #if 0
109879 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109880 : // used to trigger marking transformations for the token-based unparsing.
109881 : printf ("SgOmpAffinityClause::get_array_dimensions = %p = %s \n",this,this->class_name().c_str());
109882 : #endif
109883 :
109884 4 : return p_array_dimensions;
109885 : }
109886 :
109887 : void
109888 4 : SgOmpAffinityClause::set_array_dimensions ( std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > array_dimensions )
109889 : {
109890 4 : ROSE_ASSERT (this != NULL);
109891 :
109892 : #if 0
109893 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
109894 : // used to trigger marking transformations for the token-based unparsing.
109895 : printf ("SgOmpAffinityClause::set_array_dimensions = %p = %s \n",this,this->class_name().c_str());
109896 : #endif
109897 :
109898 4 : set_isModified(true);
109899 :
109900 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
109901 : if (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions)
109902 : {
109903 : printf ("Warning: array_dimensions = %p overwriting valid pointer p_array_dimensions = %p \n",array_dimensions,p_array_dimensions);
109904 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
109905 : printf ("Error fails assertion (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions) is false\n");
109906 : ROSE_ASSERT(false);
109907 : #endif
109908 : }
109909 : #endif
109910 4 : p_array_dimensions = array_dimensions;
109911 4 : }
109912 :
109913 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
109914 :
109915 :
109916 : // End of memberFunctionString
109917 : // Start of memberFunctionString
109918 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
109919 :
109920 : // *** COMMON CODE SECTION BEGINS HERE ***
109921 :
109922 : #if 0
109923 : int
109924 : SgOmpAffinityClause::getVariant() const
109925 : {
109926 : // This function is used in ROSE while "variant()" is used in SAGE
109927 : assert(this != NULL);
109928 : return variant();
109929 : }
109930 : #endif
109931 :
109932 : // This function is used in ROSE in treeTraversal code
109933 : // eventually replaces getVariant() and variant()
109934 : // though after variant() has been removed for a while we will
109935 : // want to change the name of variantT() back to variant()
109936 : // (since the "T" was ment to stand for temporary).
109937 : // When this happens the variantT() will be depricated.
109938 : VariantT
109939 246 : SgOmpAffinityClause::variantT() const
109940 : {
109941 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
109942 246 : ROSE_ASSERT(this != NULL);
109943 246 : return V_SgOmpAffinityClause;
109944 : }
109945 :
109946 : #if 0
109947 : int
109948 : SgOmpAffinityClause::variant() const
109949 : {
109950 : // This function is used in SAGE
109951 : ROSE_ASSERT(this != NULL);
109952 : return OmpAffinityClauseTag;
109953 : }
109954 : #endif
109955 :
109956 : ROSE_DLL_API const char*
109957 0 : SgOmpAffinityClause::sage_class_name() const
109958 : {
109959 0 : ROSE_ASSERT(this != NULL);
109960 0 : return "SgOmpAffinityClause";
109961 : }
109962 :
109963 : std::string
109964 4 : SgOmpAffinityClause::class_name() const
109965 : {
109966 4 : ROSE_ASSERT(this != NULL);
109967 4 : return "SgOmpAffinityClause";
109968 : }
109969 :
109970 : // DQ (11/26/2005): Support for visitor pattern mechanims
109971 : // (inferior to ROSE traversal mechanism, experimental).
109972 : void
109973 0 : SgOmpAffinityClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
109974 : {
109975 0 : ROSE_ASSERT(this != NULL);
109976 0 : visitor.visit(this);
109977 0 : }
109978 :
109979 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
109980 0 : void SgOmpAffinityClause::accept (ROSE_VisitorPattern & visitor) {
109981 0 : ROSE_ASSERT(this != NULL);
109982 0 : visitor.visit(this);
109983 0 : }
109984 :
109985 : SgOmpAffinityClause*
109986 0 : SgOmpAffinityClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
109987 : {
109988 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
109989 : // This function is currently only supported for the AST used the represent Binary executables.
109990 : if (0 /* isSgAsmNode(this) != NULL */)
109991 : {
109992 : // Support for regex specification.
109993 : std::string prefixCode = "REGEX:";
109994 : addNewAttribute(prefixCode + s,a);
109995 : }
109996 : #endif
109997 :
109998 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
109999 0 : return this;
110000 : }
110001 :
110002 : // *** COMMON CODE SECTION ENDS HERE ***
110003 :
110004 :
110005 : // End of memberFunctionString
110006 : // Start of memberFunctionString
110007 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
110008 :
110009 :
110010 : #if 0
110011 : //! Error checking support
110012 : /*! Verifies the following:
110013 : - working getVariant() member function
110014 : - calls base class's error() member function
110015 : Every class has one of these functions.
110016 : */
110017 : bool
110018 : SgOmpAffinityClause::error()
110019 : {
110020 : // Put error checking here
110021 :
110022 : ROSE_ASSERT (this != NULL);
110023 : if (getVariant() != OmpAffinityClauseTag)
110024 : {
110025 : printf ("Error in SgOmpAffinityClause::error(): SgOmpAffinityClause object has a %s variant \n",
110026 : Cxx_GrammarTerminalNames[getVariant()].name);
110027 : // printf ("Error in SgOmpAffinityClause::error() \n");
110028 : ROSE_ABORT();
110029 : }
110030 :
110031 : ROSE_ASSERT (getVariant() == OmpAffinityClauseTag);
110032 : return SgOmpVariablesClause::error();
110033 : }
110034 : #endif
110035 :
110036 :
110037 :
110038 : // End of memberFunctionString
110039 :
110040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
110041 :
110042 14 : SgOmpAffinityClause* isSgOmpAffinityClause ( SgNode* inputDerivedClassPointer )
110043 : {
110044 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
110045 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
110046 : // So to fix this we return NULL directly when the input is NULL and avoid the
110047 : // dynamic_cast in this case. This is likely a performance improvement as well.
110048 : // return dynamic_cast<SgOmpAffinityClause*>(inputDerivedClassPointer);
110049 : // Milind Chabbi (8/28/2013): isSgOmpAffinityClause uses table-driven castability instead of c++ default dynamic_cast
110050 : // this improves the running time performance by 10-20%.
110051 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAffinityClause*>(inputDerivedClassPointer);
110052 14 : return IS_SgOmpAffinityClause_FAST_MACRO(inputDerivedClassPointer);
110053 : }
110054 :
110055 : // DQ (11/8/2003): Added version of functions taking const pointer
110056 0 : const SgOmpAffinityClause* isSgOmpAffinityClause ( const SgNode* inputDerivedClassPointer )
110057 : {
110058 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
110059 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
110060 : // So to fix this we return NULL directly when the input is NULL and avoid the
110061 : // dynamic_cast in this case. This is likely a performance improvement as well.
110062 : // return dynamic_cast<const SgOmpAffinityClause*>(inputDerivedClassPointer);
110063 : // Milind Chabbi (8/28/2013): isSgOmpAffinityClause uses table-driven castability instead of c++ default dynamic_cast
110064 : // this improves the running time performance by 10-20%.
110065 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAffinityClause*>(inputDerivedClassPointer);
110066 0 : return IS_SgOmpAffinityClause_FAST_MACRO(inputDerivedClassPointer);
110067 : }
110068 :
110069 :
110070 :
110071 : /* #line 110072 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110072 :
110073 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
110074 :
110075 : /**
110076 : \brief Generated destructor
110077 :
110078 : This destructor is automatically generated (by ROSETTA). This destructor
110079 : only frees memory of data members associated with the parts of the current IR node which
110080 : are NOT traversed. Those data members that are part of a traversal can be freed using
110081 : a traversal (calling this destructor on all children in a post-order traversal). Such
110082 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
110083 :
110084 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
110085 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
110086 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
110087 :
110088 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
110089 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
110090 : pointers are not yet implemented to call delete on eash pointer in the container.
110091 : (This could be done by derivation from the STL containers to define containers that
110092 : automatically deleted their members.)
110093 :
110094 : */
110095 0 : SgOmpAffinityClause::~SgOmpAffinityClause () {
110096 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
110097 :
110098 :
110099 : // case: not a listType for affinity_modifier
110100 0 : p_affinity_modifier =e_omp_affinity_modifier_unspecified; // non list case
110101 :
110102 : }
110103 :
110104 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
110105 0 : }
110106 :
110107 :
110108 : /* #line 110109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110109 :
110110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
110111 :
110112 : // Generated constructor
110113 0 : SgOmpAffinityClause::SgOmpAffinityClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_affinity_modifier_enum affinity_modifier )
110114 0 : : SgOmpVariablesClause(startOfConstruct, variables)
110115 : {
110116 : #ifdef DEBUG
110117 : // printf ("In SgOmpAffinityClause::SgOmpAffinityClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_affinity_modifier_enum affinity_modifier) sage_class_name() = %s \n",sage_class_name());
110118 : #endif
110119 : #if 0
110120 : // debugging information!
110121 : printf ("In SgOmpAffinityClause::SgOmpAffinityClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_affinity_modifier_enum affinity_modifier): this = %p = %s \n",this,this->class_name().c_str());
110122 : #endif
110123 :
110124 0 : p_affinity_modifier = affinity_modifier;
110125 :
110126 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
110127 :
110128 : #if 0
110129 : // DQ (7/30/2014): Call a virtual function.
110130 : std::string s = this->class_name();
110131 : #endif
110132 :
110133 : // Test the variant virtual function
110134 : // assert(OmpAffinityClauseTag == variant());
110135 0 : assert(OmpAffinityClauseTag == this->variant());
110136 0 : ROSE_ASSERT(OmpAffinityClauseTag == (int)(this->variantT()));
110137 0 : post_construction_initialization();
110138 :
110139 : // Test the isSgOmpAffinityClause() function since it has been problematic
110140 0 : assert(isSgOmpAffinityClause(this) != NULL);
110141 0 : }
110142 :
110143 : // Generated constructor (all data members)
110144 :
110145 : /* #line 110146 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110146 :
110147 :
110148 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
110149 :
110150 :
110151 : // ********************************************************
110152 : // member functions common across all array grammar objects
110153 : // ********************************************************
110154 :
110155 :
110156 :
110157 : /* #line 110158 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110158 :
110159 :
110160 :
110161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
110162 :
110163 : // ********************************************************
110164 : // member functions specific to each node in the grammar
110165 : // ********************************************************
110166 :
110167 :
110168 : /* #line 110169 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110169 :
110170 : // Start of memberFunctionString
110171 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110172 :
110173 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110174 :
110175 : SgOmpClause::omp_to_kind_enum
110176 2 : SgOmpToClause::get_kind () const
110177 : {
110178 2 : ROSE_ASSERT (this != NULL);
110179 :
110180 : #if 0
110181 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110182 : // used to trigger marking transformations for the token-based unparsing.
110183 : printf ("SgOmpToClause::get_kind = %p = %s \n",this,this->class_name().c_str());
110184 : #endif
110185 :
110186 2 : return p_kind;
110187 : }
110188 :
110189 : void
110190 0 : SgOmpToClause::set_kind ( SgOmpClause::omp_to_kind_enum kind )
110191 : {
110192 0 : ROSE_ASSERT (this != NULL);
110193 :
110194 : #if 0
110195 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110196 : // used to trigger marking transformations for the token-based unparsing.
110197 : printf ("SgOmpToClause::set_kind = %p = %s \n",this,this->class_name().c_str());
110198 : #endif
110199 :
110200 0 : set_isModified(true);
110201 :
110202 0 : p_kind = kind;
110203 0 : }
110204 :
110205 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110206 :
110207 :
110208 : // End of memberFunctionString
110209 : // Start of memberFunctionString
110210 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110211 :
110212 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110213 :
110214 : SgExpression*
110215 1 : SgOmpToClause::get_mapper_identifier () const
110216 : {
110217 1 : ROSE_ASSERT (this != NULL);
110218 :
110219 : #if 0
110220 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110221 : // used to trigger marking transformations for the token-based unparsing.
110222 : printf ("SgOmpToClause::get_mapper_identifier = %p = %s \n",this,this->class_name().c_str());
110223 : #endif
110224 :
110225 1 : return p_mapper_identifier;
110226 : }
110227 :
110228 : void
110229 2 : SgOmpToClause::set_mapper_identifier ( SgExpression* mapper_identifier )
110230 : {
110231 2 : ROSE_ASSERT (this != NULL);
110232 :
110233 : #if 0
110234 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110235 : // used to trigger marking transformations for the token-based unparsing.
110236 : printf ("SgOmpToClause::set_mapper_identifier = %p = %s \n",this,this->class_name().c_str());
110237 : #endif
110238 :
110239 2 : set_isModified(true);
110240 :
110241 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
110242 : if (p_mapper_identifier != NULL && mapper_identifier != NULL && p_mapper_identifier != mapper_identifier)
110243 : {
110244 : printf ("Warning: mapper_identifier = %p overwriting valid pointer p_mapper_identifier = %p \n",mapper_identifier,p_mapper_identifier);
110245 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
110246 : printf ("Error fails assertion (p_mapper_identifier != NULL && mapper_identifier != NULL && p_mapper_identifier != mapper_identifier) is false\n");
110247 : ROSE_ASSERT(false);
110248 : #endif
110249 : }
110250 : #endif
110251 2 : p_mapper_identifier = mapper_identifier;
110252 2 : }
110253 :
110254 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110255 :
110256 :
110257 : // End of memberFunctionString
110258 : // Start of memberFunctionString
110259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110260 :
110261 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110262 :
110263 : std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >
110264 2 : SgOmpToClause::get_array_dimensions () const
110265 : {
110266 2 : ROSE_ASSERT (this != NULL);
110267 :
110268 : #if 0
110269 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110270 : // used to trigger marking transformations for the token-based unparsing.
110271 : printf ("SgOmpToClause::get_array_dimensions = %p = %s \n",this,this->class_name().c_str());
110272 : #endif
110273 :
110274 2 : return p_array_dimensions;
110275 : }
110276 :
110277 : void
110278 2 : SgOmpToClause::set_array_dimensions ( std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > array_dimensions )
110279 : {
110280 2 : ROSE_ASSERT (this != NULL);
110281 :
110282 : #if 0
110283 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110284 : // used to trigger marking transformations for the token-based unparsing.
110285 : printf ("SgOmpToClause::set_array_dimensions = %p = %s \n",this,this->class_name().c_str());
110286 : #endif
110287 :
110288 2 : set_isModified(true);
110289 :
110290 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
110291 : if (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions)
110292 : {
110293 : printf ("Warning: array_dimensions = %p overwriting valid pointer p_array_dimensions = %p \n",array_dimensions,p_array_dimensions);
110294 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
110295 : printf ("Error fails assertion (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions) is false\n");
110296 : ROSE_ASSERT(false);
110297 : #endif
110298 : }
110299 : #endif
110300 2 : p_array_dimensions = array_dimensions;
110301 2 : }
110302 :
110303 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110304 :
110305 :
110306 : // End of memberFunctionString
110307 : // Start of memberFunctionString
110308 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
110309 :
110310 : // *** COMMON CODE SECTION BEGINS HERE ***
110311 :
110312 : #if 0
110313 : int
110314 : SgOmpToClause::getVariant() const
110315 : {
110316 : // This function is used in ROSE while "variant()" is used in SAGE
110317 : assert(this != NULL);
110318 : return variant();
110319 : }
110320 : #endif
110321 :
110322 : // This function is used in ROSE in treeTraversal code
110323 : // eventually replaces getVariant() and variant()
110324 : // though after variant() has been removed for a while we will
110325 : // want to change the name of variantT() back to variant()
110326 : // (since the "T" was ment to stand for temporary).
110327 : // When this happens the variantT() will be depricated.
110328 : VariantT
110329 71 : SgOmpToClause::variantT() const
110330 : {
110331 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
110332 71 : ROSE_ASSERT(this != NULL);
110333 71 : return V_SgOmpToClause;
110334 : }
110335 :
110336 : #if 0
110337 : int
110338 : SgOmpToClause::variant() const
110339 : {
110340 : // This function is used in SAGE
110341 : ROSE_ASSERT(this != NULL);
110342 : return OmpToClauseTag;
110343 : }
110344 : #endif
110345 :
110346 : ROSE_DLL_API const char*
110347 0 : SgOmpToClause::sage_class_name() const
110348 : {
110349 0 : ROSE_ASSERT(this != NULL);
110350 0 : return "SgOmpToClause";
110351 : }
110352 :
110353 : std::string
110354 2 : SgOmpToClause::class_name() const
110355 : {
110356 2 : ROSE_ASSERT(this != NULL);
110357 2 : return "SgOmpToClause";
110358 : }
110359 :
110360 : // DQ (11/26/2005): Support for visitor pattern mechanims
110361 : // (inferior to ROSE traversal mechanism, experimental).
110362 : void
110363 0 : SgOmpToClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
110364 : {
110365 0 : ROSE_ASSERT(this != NULL);
110366 0 : visitor.visit(this);
110367 0 : }
110368 :
110369 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
110370 0 : void SgOmpToClause::accept (ROSE_VisitorPattern & visitor) {
110371 0 : ROSE_ASSERT(this != NULL);
110372 0 : visitor.visit(this);
110373 0 : }
110374 :
110375 : SgOmpToClause*
110376 0 : SgOmpToClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
110377 : {
110378 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
110379 : // This function is currently only supported for the AST used the represent Binary executables.
110380 : if (0 /* isSgAsmNode(this) != NULL */)
110381 : {
110382 : // Support for regex specification.
110383 : std::string prefixCode = "REGEX:";
110384 : addNewAttribute(prefixCode + s,a);
110385 : }
110386 : #endif
110387 :
110388 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
110389 0 : return this;
110390 : }
110391 :
110392 : // *** COMMON CODE SECTION ENDS HERE ***
110393 :
110394 :
110395 : // End of memberFunctionString
110396 : // Start of memberFunctionString
110397 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
110398 :
110399 :
110400 : #if 0
110401 : //! Error checking support
110402 : /*! Verifies the following:
110403 : - working getVariant() member function
110404 : - calls base class's error() member function
110405 : Every class has one of these functions.
110406 : */
110407 : bool
110408 : SgOmpToClause::error()
110409 : {
110410 : // Put error checking here
110411 :
110412 : ROSE_ASSERT (this != NULL);
110413 : if (getVariant() != OmpToClauseTag)
110414 : {
110415 : printf ("Error in SgOmpToClause::error(): SgOmpToClause object has a %s variant \n",
110416 : Cxx_GrammarTerminalNames[getVariant()].name);
110417 : // printf ("Error in SgOmpToClause::error() \n");
110418 : ROSE_ABORT();
110419 : }
110420 :
110421 : ROSE_ASSERT (getVariant() == OmpToClauseTag);
110422 : return SgOmpVariablesClause::error();
110423 : }
110424 : #endif
110425 :
110426 :
110427 :
110428 : // End of memberFunctionString
110429 :
110430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
110431 :
110432 7 : SgOmpToClause* isSgOmpToClause ( SgNode* inputDerivedClassPointer )
110433 : {
110434 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
110435 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
110436 : // So to fix this we return NULL directly when the input is NULL and avoid the
110437 : // dynamic_cast in this case. This is likely a performance improvement as well.
110438 : // return dynamic_cast<SgOmpToClause*>(inputDerivedClassPointer);
110439 : // Milind Chabbi (8/28/2013): isSgOmpToClause uses table-driven castability instead of c++ default dynamic_cast
110440 : // this improves the running time performance by 10-20%.
110441 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpToClause*>(inputDerivedClassPointer);
110442 7 : return IS_SgOmpToClause_FAST_MACRO(inputDerivedClassPointer);
110443 : }
110444 :
110445 : // DQ (11/8/2003): Added version of functions taking const pointer
110446 0 : const SgOmpToClause* isSgOmpToClause ( const SgNode* inputDerivedClassPointer )
110447 : {
110448 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
110449 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
110450 : // So to fix this we return NULL directly when the input is NULL and avoid the
110451 : // dynamic_cast in this case. This is likely a performance improvement as well.
110452 : // return dynamic_cast<const SgOmpToClause*>(inputDerivedClassPointer);
110453 : // Milind Chabbi (8/28/2013): isSgOmpToClause uses table-driven castability instead of c++ default dynamic_cast
110454 : // this improves the running time performance by 10-20%.
110455 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpToClause*>(inputDerivedClassPointer);
110456 0 : return IS_SgOmpToClause_FAST_MACRO(inputDerivedClassPointer);
110457 : }
110458 :
110459 :
110460 :
110461 : /* #line 110462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110462 :
110463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
110464 :
110465 : /**
110466 : \brief Generated destructor
110467 :
110468 : This destructor is automatically generated (by ROSETTA). This destructor
110469 : only frees memory of data members associated with the parts of the current IR node which
110470 : are NOT traversed. Those data members that are part of a traversal can be freed using
110471 : a traversal (calling this destructor on all children in a post-order traversal). Such
110472 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
110473 :
110474 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
110475 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
110476 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
110477 :
110478 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
110479 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
110480 : pointers are not yet implemented to call delete on eash pointer in the container.
110481 : (This could be done by derivation from the STL containers to define containers that
110482 : automatically deleted their members.)
110483 :
110484 : */
110485 0 : SgOmpToClause::~SgOmpToClause () {
110486 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
110487 :
110488 :
110489 : // case: not a listType for kind
110490 0 : p_kind =e_omp_to_kind_unknown; // non list case
110491 : // case: not a listType for mapper_identifier
110492 0 : p_mapper_identifier = NULL; // non list case
110493 :
110494 : }
110495 :
110496 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
110497 0 : }
110498 :
110499 :
110500 : /* #line 110501 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110501 :
110502 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
110503 :
110504 : // Generated constructor
110505 0 : SgOmpToClause::SgOmpToClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_to_kind_enum kind )
110506 0 : : SgOmpVariablesClause(startOfConstruct, variables)
110507 : {
110508 : #ifdef DEBUG
110509 : // printf ("In SgOmpToClause::SgOmpToClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_to_kind_enum kind) sage_class_name() = %s \n",sage_class_name());
110510 : #endif
110511 : #if 0
110512 : // debugging information!
110513 : printf ("In SgOmpToClause::SgOmpToClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_to_kind_enum kind): this = %p = %s \n",this,this->class_name().c_str());
110514 : #endif
110515 :
110516 0 : p_kind = kind;
110517 0 : p_mapper_identifier = NULL;
110518 :
110519 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
110520 :
110521 : #if 0
110522 : // DQ (7/30/2014): Call a virtual function.
110523 : std::string s = this->class_name();
110524 : #endif
110525 :
110526 : // Test the variant virtual function
110527 : // assert(OmpToClauseTag == variant());
110528 0 : assert(OmpToClauseTag == this->variant());
110529 0 : ROSE_ASSERT(OmpToClauseTag == (int)(this->variantT()));
110530 0 : post_construction_initialization();
110531 :
110532 : // Test the isSgOmpToClause() function since it has been problematic
110533 0 : assert(isSgOmpToClause(this) != NULL);
110534 0 : }
110535 :
110536 : // Generated constructor (all data members)
110537 :
110538 : /* #line 110539 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110539 :
110540 :
110541 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
110542 :
110543 :
110544 : // ********************************************************
110545 : // member functions common across all array grammar objects
110546 : // ********************************************************
110547 :
110548 :
110549 :
110550 : /* #line 110551 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110551 :
110552 :
110553 :
110554 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
110555 :
110556 : // ********************************************************
110557 : // member functions specific to each node in the grammar
110558 : // ********************************************************
110559 :
110560 :
110561 : /* #line 110562 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110562 :
110563 : // Start of memberFunctionString
110564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110565 :
110566 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110567 :
110568 : SgOmpClause::omp_from_kind_enum
110569 1 : SgOmpFromClause::get_kind () const
110570 : {
110571 1 : ROSE_ASSERT (this != NULL);
110572 :
110573 : #if 0
110574 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110575 : // used to trigger marking transformations for the token-based unparsing.
110576 : printf ("SgOmpFromClause::get_kind = %p = %s \n",this,this->class_name().c_str());
110577 : #endif
110578 :
110579 1 : return p_kind;
110580 : }
110581 :
110582 : void
110583 0 : SgOmpFromClause::set_kind ( SgOmpClause::omp_from_kind_enum kind )
110584 : {
110585 0 : ROSE_ASSERT (this != NULL);
110586 :
110587 : #if 0
110588 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110589 : // used to trigger marking transformations for the token-based unparsing.
110590 : printf ("SgOmpFromClause::set_kind = %p = %s \n",this,this->class_name().c_str());
110591 : #endif
110592 :
110593 0 : set_isModified(true);
110594 :
110595 0 : p_kind = kind;
110596 0 : }
110597 :
110598 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110599 :
110600 :
110601 : // End of memberFunctionString
110602 : // Start of memberFunctionString
110603 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110604 :
110605 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110606 :
110607 : SgExpression*
110608 1 : SgOmpFromClause::get_mapper_identifier () const
110609 : {
110610 1 : ROSE_ASSERT (this != NULL);
110611 :
110612 : #if 0
110613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110614 : // used to trigger marking transformations for the token-based unparsing.
110615 : printf ("SgOmpFromClause::get_mapper_identifier = %p = %s \n",this,this->class_name().c_str());
110616 : #endif
110617 :
110618 1 : return p_mapper_identifier;
110619 : }
110620 :
110621 : void
110622 1 : SgOmpFromClause::set_mapper_identifier ( SgExpression* mapper_identifier )
110623 : {
110624 1 : ROSE_ASSERT (this != NULL);
110625 :
110626 : #if 0
110627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110628 : // used to trigger marking transformations for the token-based unparsing.
110629 : printf ("SgOmpFromClause::set_mapper_identifier = %p = %s \n",this,this->class_name().c_str());
110630 : #endif
110631 :
110632 1 : set_isModified(true);
110633 :
110634 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
110635 : if (p_mapper_identifier != NULL && mapper_identifier != NULL && p_mapper_identifier != mapper_identifier)
110636 : {
110637 : printf ("Warning: mapper_identifier = %p overwriting valid pointer p_mapper_identifier = %p \n",mapper_identifier,p_mapper_identifier);
110638 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
110639 : printf ("Error fails assertion (p_mapper_identifier != NULL && mapper_identifier != NULL && p_mapper_identifier != mapper_identifier) is false\n");
110640 : ROSE_ASSERT(false);
110641 : #endif
110642 : }
110643 : #endif
110644 1 : p_mapper_identifier = mapper_identifier;
110645 1 : }
110646 :
110647 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110648 :
110649 :
110650 : // End of memberFunctionString
110651 : // Start of memberFunctionString
110652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110653 :
110654 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110655 :
110656 : std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > >
110657 1 : SgOmpFromClause::get_array_dimensions () const
110658 : {
110659 1 : ROSE_ASSERT (this != NULL);
110660 :
110661 : #if 0
110662 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110663 : // used to trigger marking transformations for the token-based unparsing.
110664 : printf ("SgOmpFromClause::get_array_dimensions = %p = %s \n",this,this->class_name().c_str());
110665 : #endif
110666 :
110667 1 : return p_array_dimensions;
110668 : }
110669 :
110670 : void
110671 1 : SgOmpFromClause::set_array_dimensions ( std::map<SgSymbol*, std::vector < std::pair <SgExpression*, SgExpression*> > > array_dimensions )
110672 : {
110673 1 : ROSE_ASSERT (this != NULL);
110674 :
110675 : #if 0
110676 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110677 : // used to trigger marking transformations for the token-based unparsing.
110678 : printf ("SgOmpFromClause::set_array_dimensions = %p = %s \n",this,this->class_name().c_str());
110679 : #endif
110680 :
110681 1 : set_isModified(true);
110682 :
110683 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
110684 : if (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions)
110685 : {
110686 : printf ("Warning: array_dimensions = %p overwriting valid pointer p_array_dimensions = %p \n",array_dimensions,p_array_dimensions);
110687 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
110688 : printf ("Error fails assertion (p_array_dimensions != NULL && array_dimensions != NULL && p_array_dimensions != array_dimensions) is false\n");
110689 : ROSE_ASSERT(false);
110690 : #endif
110691 : }
110692 : #endif
110693 1 : p_array_dimensions = array_dimensions;
110694 1 : }
110695 :
110696 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110697 :
110698 :
110699 : // End of memberFunctionString
110700 : // Start of memberFunctionString
110701 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
110702 :
110703 : // *** COMMON CODE SECTION BEGINS HERE ***
110704 :
110705 : #if 0
110706 : int
110707 : SgOmpFromClause::getVariant() const
110708 : {
110709 : // This function is used in ROSE while "variant()" is used in SAGE
110710 : assert(this != NULL);
110711 : return variant();
110712 : }
110713 : #endif
110714 :
110715 : // This function is used in ROSE in treeTraversal code
110716 : // eventually replaces getVariant() and variant()
110717 : // though after variant() has been removed for a while we will
110718 : // want to change the name of variantT() back to variant()
110719 : // (since the "T" was ment to stand for temporary).
110720 : // When this happens the variantT() will be depricated.
110721 : VariantT
110722 36 : SgOmpFromClause::variantT() const
110723 : {
110724 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
110725 36 : ROSE_ASSERT(this != NULL);
110726 36 : return V_SgOmpFromClause;
110727 : }
110728 :
110729 : #if 0
110730 : int
110731 : SgOmpFromClause::variant() const
110732 : {
110733 : // This function is used in SAGE
110734 : ROSE_ASSERT(this != NULL);
110735 : return OmpFromClauseTag;
110736 : }
110737 : #endif
110738 :
110739 : ROSE_DLL_API const char*
110740 0 : SgOmpFromClause::sage_class_name() const
110741 : {
110742 0 : ROSE_ASSERT(this != NULL);
110743 0 : return "SgOmpFromClause";
110744 : }
110745 :
110746 : std::string
110747 1 : SgOmpFromClause::class_name() const
110748 : {
110749 1 : ROSE_ASSERT(this != NULL);
110750 1 : return "SgOmpFromClause";
110751 : }
110752 :
110753 : // DQ (11/26/2005): Support for visitor pattern mechanims
110754 : // (inferior to ROSE traversal mechanism, experimental).
110755 : void
110756 0 : SgOmpFromClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
110757 : {
110758 0 : ROSE_ASSERT(this != NULL);
110759 0 : visitor.visit(this);
110760 0 : }
110761 :
110762 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
110763 0 : void SgOmpFromClause::accept (ROSE_VisitorPattern & visitor) {
110764 0 : ROSE_ASSERT(this != NULL);
110765 0 : visitor.visit(this);
110766 0 : }
110767 :
110768 : SgOmpFromClause*
110769 0 : SgOmpFromClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
110770 : {
110771 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
110772 : // This function is currently only supported for the AST used the represent Binary executables.
110773 : if (0 /* isSgAsmNode(this) != NULL */)
110774 : {
110775 : // Support for regex specification.
110776 : std::string prefixCode = "REGEX:";
110777 : addNewAttribute(prefixCode + s,a);
110778 : }
110779 : #endif
110780 :
110781 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
110782 0 : return this;
110783 : }
110784 :
110785 : // *** COMMON CODE SECTION ENDS HERE ***
110786 :
110787 :
110788 : // End of memberFunctionString
110789 : // Start of memberFunctionString
110790 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
110791 :
110792 :
110793 : #if 0
110794 : //! Error checking support
110795 : /*! Verifies the following:
110796 : - working getVariant() member function
110797 : - calls base class's error() member function
110798 : Every class has one of these functions.
110799 : */
110800 : bool
110801 : SgOmpFromClause::error()
110802 : {
110803 : // Put error checking here
110804 :
110805 : ROSE_ASSERT (this != NULL);
110806 : if (getVariant() != OmpFromClauseTag)
110807 : {
110808 : printf ("Error in SgOmpFromClause::error(): SgOmpFromClause object has a %s variant \n",
110809 : Cxx_GrammarTerminalNames[getVariant()].name);
110810 : // printf ("Error in SgOmpFromClause::error() \n");
110811 : ROSE_ABORT();
110812 : }
110813 :
110814 : ROSE_ASSERT (getVariant() == OmpFromClauseTag);
110815 : return SgOmpVariablesClause::error();
110816 : }
110817 : #endif
110818 :
110819 :
110820 :
110821 : // End of memberFunctionString
110822 :
110823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
110824 :
110825 4 : SgOmpFromClause* isSgOmpFromClause ( SgNode* inputDerivedClassPointer )
110826 : {
110827 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
110828 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
110829 : // So to fix this we return NULL directly when the input is NULL and avoid the
110830 : // dynamic_cast in this case. This is likely a performance improvement as well.
110831 : // return dynamic_cast<SgOmpFromClause*>(inputDerivedClassPointer);
110832 : // Milind Chabbi (8/28/2013): isSgOmpFromClause uses table-driven castability instead of c++ default dynamic_cast
110833 : // this improves the running time performance by 10-20%.
110834 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpFromClause*>(inputDerivedClassPointer);
110835 4 : return IS_SgOmpFromClause_FAST_MACRO(inputDerivedClassPointer);
110836 : }
110837 :
110838 : // DQ (11/8/2003): Added version of functions taking const pointer
110839 0 : const SgOmpFromClause* isSgOmpFromClause ( const SgNode* inputDerivedClassPointer )
110840 : {
110841 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
110842 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
110843 : // So to fix this we return NULL directly when the input is NULL and avoid the
110844 : // dynamic_cast in this case. This is likely a performance improvement as well.
110845 : // return dynamic_cast<const SgOmpFromClause*>(inputDerivedClassPointer);
110846 : // Milind Chabbi (8/28/2013): isSgOmpFromClause uses table-driven castability instead of c++ default dynamic_cast
110847 : // this improves the running time performance by 10-20%.
110848 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpFromClause*>(inputDerivedClassPointer);
110849 0 : return IS_SgOmpFromClause_FAST_MACRO(inputDerivedClassPointer);
110850 : }
110851 :
110852 :
110853 :
110854 : /* #line 110855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110855 :
110856 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
110857 :
110858 : /**
110859 : \brief Generated destructor
110860 :
110861 : This destructor is automatically generated (by ROSETTA). This destructor
110862 : only frees memory of data members associated with the parts of the current IR node which
110863 : are NOT traversed. Those data members that are part of a traversal can be freed using
110864 : a traversal (calling this destructor on all children in a post-order traversal). Such
110865 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
110866 :
110867 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
110868 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
110869 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
110870 :
110871 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
110872 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
110873 : pointers are not yet implemented to call delete on eash pointer in the container.
110874 : (This could be done by derivation from the STL containers to define containers that
110875 : automatically deleted their members.)
110876 :
110877 : */
110878 0 : SgOmpFromClause::~SgOmpFromClause () {
110879 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
110880 :
110881 :
110882 : // case: not a listType for kind
110883 0 : p_kind =e_omp_from_kind_unknown; // non list case
110884 : // case: not a listType for mapper_identifier
110885 0 : p_mapper_identifier = NULL; // non list case
110886 :
110887 : }
110888 :
110889 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
110890 0 : }
110891 :
110892 :
110893 : /* #line 110894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110894 :
110895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
110896 :
110897 : // Generated constructor
110898 0 : SgOmpFromClause::SgOmpFromClause ( Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_from_kind_enum kind )
110899 0 : : SgOmpVariablesClause(startOfConstruct, variables)
110900 : {
110901 : #ifdef DEBUG
110902 : // printf ("In SgOmpFromClause::SgOmpFromClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_from_kind_enum kind) sage_class_name() = %s \n",sage_class_name());
110903 : #endif
110904 : #if 0
110905 : // debugging information!
110906 : printf ("In SgOmpFromClause::SgOmpFromClause (Sg_File_Info* startOfConstruct, SgExprListExp* variables, SgOmpClause::omp_from_kind_enum kind): this = %p = %s \n",this,this->class_name().c_str());
110907 : #endif
110908 :
110909 0 : p_kind = kind;
110910 0 : p_mapper_identifier = NULL;
110911 :
110912 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
110913 :
110914 : #if 0
110915 : // DQ (7/30/2014): Call a virtual function.
110916 : std::string s = this->class_name();
110917 : #endif
110918 :
110919 : // Test the variant virtual function
110920 : // assert(OmpFromClauseTag == variant());
110921 0 : assert(OmpFromClauseTag == this->variant());
110922 0 : ROSE_ASSERT(OmpFromClauseTag == (int)(this->variantT()));
110923 0 : post_construction_initialization();
110924 :
110925 : // Test the isSgOmpFromClause() function since it has been problematic
110926 0 : assert(isSgOmpFromClause(this) != NULL);
110927 0 : }
110928 :
110929 : // Generated constructor (all data members)
110930 :
110931 : /* #line 110932 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110932 :
110933 :
110934 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
110935 :
110936 :
110937 : // ********************************************************
110938 : // member functions common across all array grammar objects
110939 : // ********************************************************
110940 :
110941 :
110942 :
110943 : /* #line 110944 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110944 :
110945 :
110946 :
110947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
110948 :
110949 : // ********************************************************
110950 : // member functions specific to each node in the grammar
110951 : // ********************************************************
110952 :
110953 :
110954 : /* #line 110955 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
110955 :
110956 : // Start of memberFunctionString
110957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110958 :
110959 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110960 :
110961 : SgOmpClause::omp_schedule_modifier_enum
110962 95 : SgOmpScheduleClause::get_modifier () const
110963 : {
110964 95 : ROSE_ASSERT (this != NULL);
110965 :
110966 : #if 0
110967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110968 : // used to trigger marking transformations for the token-based unparsing.
110969 : printf ("SgOmpScheduleClause::get_modifier = %p = %s \n",this,this->class_name().c_str());
110970 : #endif
110971 :
110972 95 : return p_modifier;
110973 : }
110974 :
110975 : void
110976 0 : SgOmpScheduleClause::set_modifier ( SgOmpClause::omp_schedule_modifier_enum modifier )
110977 : {
110978 0 : ROSE_ASSERT (this != NULL);
110979 :
110980 : #if 0
110981 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
110982 : // used to trigger marking transformations for the token-based unparsing.
110983 : printf ("SgOmpScheduleClause::set_modifier = %p = %s \n",this,this->class_name().c_str());
110984 : #endif
110985 :
110986 0 : set_isModified(true);
110987 :
110988 0 : p_modifier = modifier;
110989 0 : }
110990 :
110991 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
110992 :
110993 :
110994 : // End of memberFunctionString
110995 : // Start of memberFunctionString
110996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
110997 :
110998 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
110999 :
111000 : SgOmpClause::omp_schedule_modifier_enum
111001 95 : SgOmpScheduleClause::get_modifier1 () const
111002 : {
111003 95 : ROSE_ASSERT (this != NULL);
111004 :
111005 : #if 0
111006 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111007 : // used to trigger marking transformations for the token-based unparsing.
111008 : printf ("SgOmpScheduleClause::get_modifier1 = %p = %s \n",this,this->class_name().c_str());
111009 : #endif
111010 :
111011 95 : return p_modifier1;
111012 : }
111013 :
111014 : void
111015 0 : SgOmpScheduleClause::set_modifier1 ( SgOmpClause::omp_schedule_modifier_enum modifier1 )
111016 : {
111017 0 : ROSE_ASSERT (this != NULL);
111018 :
111019 : #if 0
111020 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111021 : // used to trigger marking transformations for the token-based unparsing.
111022 : printf ("SgOmpScheduleClause::set_modifier1 = %p = %s \n",this,this->class_name().c_str());
111023 : #endif
111024 :
111025 0 : set_isModified(true);
111026 :
111027 0 : p_modifier1 = modifier1;
111028 0 : }
111029 :
111030 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111031 :
111032 :
111033 : // End of memberFunctionString
111034 : // Start of memberFunctionString
111035 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111036 :
111037 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111038 :
111039 : SgOmpClause::omp_schedule_kind_enum
111040 95 : SgOmpScheduleClause::get_kind () const
111041 : {
111042 95 : ROSE_ASSERT (this != NULL);
111043 :
111044 : #if 0
111045 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111046 : // used to trigger marking transformations for the token-based unparsing.
111047 : printf ("SgOmpScheduleClause::get_kind = %p = %s \n",this,this->class_name().c_str());
111048 : #endif
111049 :
111050 95 : return p_kind;
111051 : }
111052 :
111053 : void
111054 0 : SgOmpScheduleClause::set_kind ( SgOmpClause::omp_schedule_kind_enum kind )
111055 : {
111056 0 : ROSE_ASSERT (this != NULL);
111057 :
111058 : #if 0
111059 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111060 : // used to trigger marking transformations for the token-based unparsing.
111061 : printf ("SgOmpScheduleClause::set_kind = %p = %s \n",this,this->class_name().c_str());
111062 : #endif
111063 :
111064 0 : set_isModified(true);
111065 :
111066 0 : p_kind = kind;
111067 0 : }
111068 :
111069 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111070 :
111071 :
111072 : // End of memberFunctionString
111073 : // Start of memberFunctionString
111074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111075 :
111076 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111077 :
111078 : SgExpression*
111079 175 : SgOmpScheduleClause::get_chunk_size () const
111080 : {
111081 175 : ROSE_ASSERT (this != NULL);
111082 :
111083 : #if 0
111084 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111085 : // used to trigger marking transformations for the token-based unparsing.
111086 : printf ("SgOmpScheduleClause::get_chunk_size = %p = %s \n",this,this->class_name().c_str());
111087 : #endif
111088 :
111089 175 : return p_chunk_size;
111090 : }
111091 :
111092 : void
111093 0 : SgOmpScheduleClause::set_chunk_size ( SgExpression* chunk_size )
111094 : {
111095 0 : ROSE_ASSERT (this != NULL);
111096 :
111097 : #if 0
111098 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111099 : // used to trigger marking transformations for the token-based unparsing.
111100 : printf ("SgOmpScheduleClause::set_chunk_size = %p = %s \n",this,this->class_name().c_str());
111101 : #endif
111102 :
111103 0 : set_isModified(true);
111104 :
111105 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111106 : if (p_chunk_size != NULL && chunk_size != NULL && p_chunk_size != chunk_size)
111107 : {
111108 : printf ("Warning: chunk_size = %p overwriting valid pointer p_chunk_size = %p \n",chunk_size,p_chunk_size);
111109 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111110 : printf ("Error fails assertion (p_chunk_size != NULL && chunk_size != NULL && p_chunk_size != chunk_size) is false\n");
111111 : ROSE_ASSERT(false);
111112 : #endif
111113 : }
111114 : #endif
111115 0 : p_chunk_size = chunk_size;
111116 0 : }
111117 :
111118 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111119 :
111120 :
111121 : // End of memberFunctionString
111122 : // Start of memberFunctionString
111123 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
111124 :
111125 : // *** COMMON CODE SECTION BEGINS HERE ***
111126 :
111127 : #if 0
111128 : int
111129 : SgOmpScheduleClause::getVariant() const
111130 : {
111131 : // This function is used in ROSE while "variant()" is used in SAGE
111132 : assert(this != NULL);
111133 : return variant();
111134 : }
111135 : #endif
111136 :
111137 : // This function is used in ROSE in treeTraversal code
111138 : // eventually replaces getVariant() and variant()
111139 : // though after variant() has been removed for a while we will
111140 : // want to change the name of variantT() back to variant()
111141 : // (since the "T" was ment to stand for temporary).
111142 : // When this happens the variantT() will be depricated.
111143 : VariantT
111144 2834 : SgOmpScheduleClause::variantT() const
111145 : {
111146 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
111147 2834 : ROSE_ASSERT(this != NULL);
111148 2834 : return V_SgOmpScheduleClause;
111149 : }
111150 :
111151 : #if 0
111152 : int
111153 : SgOmpScheduleClause::variant() const
111154 : {
111155 : // This function is used in SAGE
111156 : ROSE_ASSERT(this != NULL);
111157 : return OmpScheduleClauseTag;
111158 : }
111159 : #endif
111160 :
111161 : ROSE_DLL_API const char*
111162 0 : SgOmpScheduleClause::sage_class_name() const
111163 : {
111164 0 : ROSE_ASSERT(this != NULL);
111165 0 : return "SgOmpScheduleClause";
111166 : }
111167 :
111168 : std::string
111169 95 : SgOmpScheduleClause::class_name() const
111170 : {
111171 95 : ROSE_ASSERT(this != NULL);
111172 95 : return "SgOmpScheduleClause";
111173 : }
111174 :
111175 : // DQ (11/26/2005): Support for visitor pattern mechanims
111176 : // (inferior to ROSE traversal mechanism, experimental).
111177 : void
111178 0 : SgOmpScheduleClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
111179 : {
111180 0 : ROSE_ASSERT(this != NULL);
111181 0 : visitor.visit(this);
111182 0 : }
111183 :
111184 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
111185 0 : void SgOmpScheduleClause::accept (ROSE_VisitorPattern & visitor) {
111186 0 : ROSE_ASSERT(this != NULL);
111187 0 : visitor.visit(this);
111188 0 : }
111189 :
111190 : SgOmpScheduleClause*
111191 0 : SgOmpScheduleClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
111192 : {
111193 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
111194 : // This function is currently only supported for the AST used the represent Binary executables.
111195 : if (0 /* isSgAsmNode(this) != NULL */)
111196 : {
111197 : // Support for regex specification.
111198 : std::string prefixCode = "REGEX:";
111199 : addNewAttribute(prefixCode + s,a);
111200 : }
111201 : #endif
111202 :
111203 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
111204 0 : return this;
111205 : }
111206 :
111207 : // *** COMMON CODE SECTION ENDS HERE ***
111208 :
111209 :
111210 : // End of memberFunctionString
111211 : // Start of memberFunctionString
111212 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
111213 :
111214 :
111215 : #if 0
111216 : //! Error checking support
111217 : /*! Verifies the following:
111218 : - working getVariant() member function
111219 : - calls base class's error() member function
111220 : Every class has one of these functions.
111221 : */
111222 : bool
111223 : SgOmpScheduleClause::error()
111224 : {
111225 : // Put error checking here
111226 :
111227 : ROSE_ASSERT (this != NULL);
111228 : if (getVariant() != OmpScheduleClauseTag)
111229 : {
111230 : printf ("Error in SgOmpScheduleClause::error(): SgOmpScheduleClause object has a %s variant \n",
111231 : Cxx_GrammarTerminalNames[getVariant()].name);
111232 : // printf ("Error in SgOmpScheduleClause::error() \n");
111233 : ROSE_ABORT();
111234 : }
111235 :
111236 : ROSE_ASSERT (getVariant() == OmpScheduleClauseTag);
111237 : return SgOmpClause::error();
111238 : }
111239 : #endif
111240 :
111241 :
111242 :
111243 : // End of memberFunctionString
111244 :
111245 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
111246 :
111247 285 : SgOmpScheduleClause* isSgOmpScheduleClause ( SgNode* inputDerivedClassPointer )
111248 : {
111249 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
111250 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
111251 : // So to fix this we return NULL directly when the input is NULL and avoid the
111252 : // dynamic_cast in this case. This is likely a performance improvement as well.
111253 : // return dynamic_cast<SgOmpScheduleClause*>(inputDerivedClassPointer);
111254 : // Milind Chabbi (8/28/2013): isSgOmpScheduleClause uses table-driven castability instead of c++ default dynamic_cast
111255 : // this improves the running time performance by 10-20%.
111256 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpScheduleClause*>(inputDerivedClassPointer);
111257 285 : return IS_SgOmpScheduleClause_FAST_MACRO(inputDerivedClassPointer);
111258 : }
111259 :
111260 : // DQ (11/8/2003): Added version of functions taking const pointer
111261 0 : const SgOmpScheduleClause* isSgOmpScheduleClause ( const SgNode* inputDerivedClassPointer )
111262 : {
111263 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
111264 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
111265 : // So to fix this we return NULL directly when the input is NULL and avoid the
111266 : // dynamic_cast in this case. This is likely a performance improvement as well.
111267 : // return dynamic_cast<const SgOmpScheduleClause*>(inputDerivedClassPointer);
111268 : // Milind Chabbi (8/28/2013): isSgOmpScheduleClause uses table-driven castability instead of c++ default dynamic_cast
111269 : // this improves the running time performance by 10-20%.
111270 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpScheduleClause*>(inputDerivedClassPointer);
111271 0 : return IS_SgOmpScheduleClause_FAST_MACRO(inputDerivedClassPointer);
111272 : }
111273 :
111274 :
111275 :
111276 : /* #line 111277 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111277 :
111278 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
111279 :
111280 : /**
111281 : \brief Generated destructor
111282 :
111283 : This destructor is automatically generated (by ROSETTA). This destructor
111284 : only frees memory of data members associated with the parts of the current IR node which
111285 : are NOT traversed. Those data members that are part of a traversal can be freed using
111286 : a traversal (calling this destructor on all children in a post-order traversal). Such
111287 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
111288 :
111289 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
111290 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
111291 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
111292 :
111293 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
111294 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
111295 : pointers are not yet implemented to call delete on eash pointer in the container.
111296 : (This could be done by derivation from the STL containers to define containers that
111297 : automatically deleted their members.)
111298 :
111299 : */
111300 0 : SgOmpScheduleClause::~SgOmpScheduleClause () {
111301 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
111302 :
111303 :
111304 : // case: not a listType for modifier
111305 0 : p_modifier =e_omp_schedule_modifier_unspecified; // non list case
111306 : // case: not a listType for modifier1
111307 0 : p_modifier1 =e_omp_schedule_modifier_unspecified; // non list case
111308 : // case: not a listType for kind
111309 0 : p_kind =e_omp_schedule_kind_unspecified; // non list case
111310 : // case: not a listType for chunk_size
111311 0 : p_chunk_size = NULL; // non list case
111312 :
111313 : }
111314 :
111315 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
111316 0 : }
111317 :
111318 :
111319 : /* #line 111320 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111320 :
111321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
111322 :
111323 : // Generated constructor
111324 0 : SgOmpScheduleClause::SgOmpScheduleClause ( Sg_File_Info* startOfConstruct, SgOmpClause::omp_schedule_modifier_enum modifier, SgOmpClause::omp_schedule_modifier_enum modifier1, SgOmpClause::omp_schedule_kind_enum kind, SgExpression* chunk_size )
111325 0 : : SgOmpClause(startOfConstruct)
111326 : {
111327 : #ifdef DEBUG
111328 : // printf ("In SgOmpScheduleClause::SgOmpScheduleClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_schedule_modifier_enum modifier, SgOmpClause::omp_schedule_modifier_enum modifier1, SgOmpClause::omp_schedule_kind_enum kind, SgExpression* chunk_size) sage_class_name() = %s \n",sage_class_name());
111329 : #endif
111330 : #if 0
111331 : // debugging information!
111332 : printf ("In SgOmpScheduleClause::SgOmpScheduleClause (Sg_File_Info* startOfConstruct, SgOmpClause::omp_schedule_modifier_enum modifier, SgOmpClause::omp_schedule_modifier_enum modifier1, SgOmpClause::omp_schedule_kind_enum kind, SgExpression* chunk_size): this = %p = %s \n",this,this->class_name().c_str());
111333 : #endif
111334 :
111335 0 : p_modifier = modifier;
111336 0 : p_modifier1 = modifier1;
111337 0 : p_kind = kind;
111338 0 : p_chunk_size = chunk_size;
111339 :
111340 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
111341 :
111342 : #if 0
111343 : // DQ (7/30/2014): Call a virtual function.
111344 : std::string s = this->class_name();
111345 : #endif
111346 :
111347 : // Test the variant virtual function
111348 : // assert(OmpScheduleClauseTag == variant());
111349 0 : assert(OmpScheduleClauseTag == this->variant());
111350 0 : ROSE_ASSERT(OmpScheduleClauseTag == (int)(this->variantT()));
111351 0 : post_construction_initialization();
111352 :
111353 : // Test the isSgOmpScheduleClause() function since it has been problematic
111354 0 : assert(isSgOmpScheduleClause(this) != NULL);
111355 0 : }
111356 :
111357 : // Generated constructor (all data members)
111358 :
111359 : /* #line 111360 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111360 :
111361 :
111362 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
111363 :
111364 :
111365 : // ********************************************************
111366 : // member functions common across all array grammar objects
111367 : // ********************************************************
111368 :
111369 :
111370 :
111371 : /* #line 111372 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111372 :
111373 :
111374 :
111375 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
111376 :
111377 : // ********************************************************
111378 : // member functions specific to each node in the grammar
111379 : // ********************************************************
111380 :
111381 :
111382 : /* #line 111383 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111383 :
111384 : // Start of memberFunctionString
111385 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
111386 :
111387 : // *** COMMON CODE SECTION BEGINS HERE ***
111388 :
111389 : #if 0
111390 : int
111391 : SgOmpMergeableClause::getVariant() const
111392 : {
111393 : // This function is used in ROSE while "variant()" is used in SAGE
111394 : assert(this != NULL);
111395 : return variant();
111396 : }
111397 : #endif
111398 :
111399 : // This function is used in ROSE in treeTraversal code
111400 : // eventually replaces getVariant() and variant()
111401 : // though after variant() has been removed for a while we will
111402 : // want to change the name of variantT() back to variant()
111403 : // (since the "T" was ment to stand for temporary).
111404 : // When this happens the variantT() will be depricated.
111405 : VariantT
111406 206 : SgOmpMergeableClause::variantT() const
111407 : {
111408 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
111409 206 : ROSE_ASSERT(this != NULL);
111410 206 : return V_SgOmpMergeableClause;
111411 : }
111412 :
111413 : #if 0
111414 : int
111415 : SgOmpMergeableClause::variant() const
111416 : {
111417 : // This function is used in SAGE
111418 : ROSE_ASSERT(this != NULL);
111419 : return OmpMergeableClauseTag;
111420 : }
111421 : #endif
111422 :
111423 : ROSE_DLL_API const char*
111424 0 : SgOmpMergeableClause::sage_class_name() const
111425 : {
111426 0 : ROSE_ASSERT(this != NULL);
111427 0 : return "SgOmpMergeableClause";
111428 : }
111429 :
111430 : std::string
111431 4 : SgOmpMergeableClause::class_name() const
111432 : {
111433 4 : ROSE_ASSERT(this != NULL);
111434 4 : return "SgOmpMergeableClause";
111435 : }
111436 :
111437 : // DQ (11/26/2005): Support for visitor pattern mechanims
111438 : // (inferior to ROSE traversal mechanism, experimental).
111439 : void
111440 0 : SgOmpMergeableClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
111441 : {
111442 0 : ROSE_ASSERT(this != NULL);
111443 0 : visitor.visit(this);
111444 0 : }
111445 :
111446 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
111447 0 : void SgOmpMergeableClause::accept (ROSE_VisitorPattern & visitor) {
111448 0 : ROSE_ASSERT(this != NULL);
111449 0 : visitor.visit(this);
111450 0 : }
111451 :
111452 : SgOmpMergeableClause*
111453 0 : SgOmpMergeableClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
111454 : {
111455 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
111456 : // This function is currently only supported for the AST used the represent Binary executables.
111457 : if (0 /* isSgAsmNode(this) != NULL */)
111458 : {
111459 : // Support for regex specification.
111460 : std::string prefixCode = "REGEX:";
111461 : addNewAttribute(prefixCode + s,a);
111462 : }
111463 : #endif
111464 :
111465 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
111466 0 : return this;
111467 : }
111468 :
111469 : // *** COMMON CODE SECTION ENDS HERE ***
111470 :
111471 :
111472 : // End of memberFunctionString
111473 : // Start of memberFunctionString
111474 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
111475 :
111476 :
111477 : #if 0
111478 : //! Error checking support
111479 : /*! Verifies the following:
111480 : - working getVariant() member function
111481 : - calls base class's error() member function
111482 : Every class has one of these functions.
111483 : */
111484 : bool
111485 : SgOmpMergeableClause::error()
111486 : {
111487 : // Put error checking here
111488 :
111489 : ROSE_ASSERT (this != NULL);
111490 : if (getVariant() != OmpMergeableClauseTag)
111491 : {
111492 : printf ("Error in SgOmpMergeableClause::error(): SgOmpMergeableClause object has a %s variant \n",
111493 : Cxx_GrammarTerminalNames[getVariant()].name);
111494 : // printf ("Error in SgOmpMergeableClause::error() \n");
111495 : ROSE_ABORT();
111496 : }
111497 :
111498 : ROSE_ASSERT (getVariant() == OmpMergeableClauseTag);
111499 : return SgOmpClause::error();
111500 : }
111501 : #endif
111502 :
111503 :
111504 :
111505 : // End of memberFunctionString
111506 :
111507 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
111508 :
111509 4 : SgOmpMergeableClause* isSgOmpMergeableClause ( SgNode* inputDerivedClassPointer )
111510 : {
111511 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
111512 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
111513 : // So to fix this we return NULL directly when the input is NULL and avoid the
111514 : // dynamic_cast in this case. This is likely a performance improvement as well.
111515 : // return dynamic_cast<SgOmpMergeableClause*>(inputDerivedClassPointer);
111516 : // Milind Chabbi (8/28/2013): isSgOmpMergeableClause uses table-driven castability instead of c++ default dynamic_cast
111517 : // this improves the running time performance by 10-20%.
111518 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpMergeableClause*>(inputDerivedClassPointer);
111519 4 : return IS_SgOmpMergeableClause_FAST_MACRO(inputDerivedClassPointer);
111520 : }
111521 :
111522 : // DQ (11/8/2003): Added version of functions taking const pointer
111523 0 : const SgOmpMergeableClause* isSgOmpMergeableClause ( const SgNode* inputDerivedClassPointer )
111524 : {
111525 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
111526 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
111527 : // So to fix this we return NULL directly when the input is NULL and avoid the
111528 : // dynamic_cast in this case. This is likely a performance improvement as well.
111529 : // return dynamic_cast<const SgOmpMergeableClause*>(inputDerivedClassPointer);
111530 : // Milind Chabbi (8/28/2013): isSgOmpMergeableClause uses table-driven castability instead of c++ default dynamic_cast
111531 : // this improves the running time performance by 10-20%.
111532 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpMergeableClause*>(inputDerivedClassPointer);
111533 0 : return IS_SgOmpMergeableClause_FAST_MACRO(inputDerivedClassPointer);
111534 : }
111535 :
111536 :
111537 :
111538 : /* #line 111539 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111539 :
111540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
111541 :
111542 : /**
111543 : \brief Generated destructor
111544 :
111545 : This destructor is automatically generated (by ROSETTA). This destructor
111546 : only frees memory of data members associated with the parts of the current IR node which
111547 : are NOT traversed. Those data members that are part of a traversal can be freed using
111548 : a traversal (calling this destructor on all children in a post-order traversal). Such
111549 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
111550 :
111551 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
111552 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
111553 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
111554 :
111555 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
111556 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
111557 : pointers are not yet implemented to call delete on eash pointer in the container.
111558 : (This could be done by derivation from the STL containers to define containers that
111559 : automatically deleted their members.)
111560 :
111561 : */
111562 0 : SgOmpMergeableClause::~SgOmpMergeableClause () {
111563 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
111564 :
111565 :
111566 :
111567 : }
111568 :
111569 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
111570 0 : }
111571 :
111572 :
111573 : /* #line 111574 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111574 :
111575 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
111576 :
111577 : // Generated constructor
111578 0 : SgOmpMergeableClause::SgOmpMergeableClause ( Sg_File_Info* startOfConstruct )
111579 0 : : SgOmpClause(startOfConstruct)
111580 : {
111581 : #ifdef DEBUG
111582 : // printf ("In SgOmpMergeableClause::SgOmpMergeableClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
111583 : #endif
111584 : #if 0
111585 : // debugging information!
111586 : printf ("In SgOmpMergeableClause::SgOmpMergeableClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
111587 : #endif
111588 :
111589 :
111590 :
111591 : #if 0
111592 : // DQ (7/30/2014): Call a virtual function.
111593 : std::string s = this->class_name();
111594 : #endif
111595 :
111596 : // Test the variant virtual function
111597 : // assert(OmpMergeableClauseTag == variant());
111598 0 : assert(OmpMergeableClauseTag == this->variant());
111599 0 : ROSE_ASSERT(OmpMergeableClauseTag == (int)(this->variantT()));
111600 0 : post_construction_initialization();
111601 :
111602 : // Test the isSgOmpMergeableClause() function since it has been problematic
111603 0 : assert(isSgOmpMergeableClause(this) != NULL);
111604 0 : }
111605 :
111606 : // Generated constructor (all data members)
111607 :
111608 : /* #line 111609 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111609 :
111610 :
111611 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
111612 :
111613 :
111614 : // ********************************************************
111615 : // member functions common across all array grammar objects
111616 : // ********************************************************
111617 :
111618 :
111619 :
111620 : /* #line 111621 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111621 :
111622 :
111623 :
111624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
111625 :
111626 : // ********************************************************
111627 : // member functions specific to each node in the grammar
111628 : // ********************************************************
111629 :
111630 :
111631 : /* #line 111632 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
111632 :
111633 : // Start of memberFunctionString
111634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111635 :
111636 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111637 :
111638 : SgExpression*
111639 0 : SgOmpWhenClause::get_user_condition () const
111640 : {
111641 0 : ROSE_ASSERT (this != NULL);
111642 :
111643 : #if 0
111644 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111645 : // used to trigger marking transformations for the token-based unparsing.
111646 : printf ("SgOmpWhenClause::get_user_condition = %p = %s \n",this,this->class_name().c_str());
111647 : #endif
111648 :
111649 0 : return p_user_condition;
111650 : }
111651 :
111652 : void
111653 0 : SgOmpWhenClause::set_user_condition ( SgExpression* user_condition )
111654 : {
111655 0 : ROSE_ASSERT (this != NULL);
111656 :
111657 : #if 0
111658 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111659 : // used to trigger marking transformations for the token-based unparsing.
111660 : printf ("SgOmpWhenClause::set_user_condition = %p = %s \n",this,this->class_name().c_str());
111661 : #endif
111662 :
111663 0 : set_isModified(true);
111664 :
111665 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111666 : if (p_user_condition != NULL && user_condition != NULL && p_user_condition != user_condition)
111667 : {
111668 : printf ("Warning: user_condition = %p overwriting valid pointer p_user_condition = %p \n",user_condition,p_user_condition);
111669 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111670 : printf ("Error fails assertion (p_user_condition != NULL && user_condition != NULL && p_user_condition != user_condition) is false\n");
111671 : ROSE_ASSERT(false);
111672 : #endif
111673 : }
111674 : #endif
111675 0 : p_user_condition = user_condition;
111676 0 : }
111677 :
111678 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111679 :
111680 :
111681 : // End of memberFunctionString
111682 : // Start of memberFunctionString
111683 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111684 :
111685 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111686 :
111687 : SgExpression*
111688 0 : SgOmpWhenClause::get_user_condition_score () const
111689 : {
111690 0 : ROSE_ASSERT (this != NULL);
111691 :
111692 : #if 0
111693 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111694 : // used to trigger marking transformations for the token-based unparsing.
111695 : printf ("SgOmpWhenClause::get_user_condition_score = %p = %s \n",this,this->class_name().c_str());
111696 : #endif
111697 :
111698 0 : return p_user_condition_score;
111699 : }
111700 :
111701 : void
111702 0 : SgOmpWhenClause::set_user_condition_score ( SgExpression* user_condition_score )
111703 : {
111704 0 : ROSE_ASSERT (this != NULL);
111705 :
111706 : #if 0
111707 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111708 : // used to trigger marking transformations for the token-based unparsing.
111709 : printf ("SgOmpWhenClause::set_user_condition_score = %p = %s \n",this,this->class_name().c_str());
111710 : #endif
111711 :
111712 0 : set_isModified(true);
111713 :
111714 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111715 : if (p_user_condition_score != NULL && user_condition_score != NULL && p_user_condition_score != user_condition_score)
111716 : {
111717 : printf ("Warning: user_condition_score = %p overwriting valid pointer p_user_condition_score = %p \n",user_condition_score,p_user_condition_score);
111718 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111719 : printf ("Error fails assertion (p_user_condition_score != NULL && user_condition_score != NULL && p_user_condition_score != user_condition_score) is false\n");
111720 : ROSE_ASSERT(false);
111721 : #endif
111722 : }
111723 : #endif
111724 0 : p_user_condition_score = user_condition_score;
111725 0 : }
111726 :
111727 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111728 :
111729 :
111730 : // End of memberFunctionString
111731 : // Start of memberFunctionString
111732 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111733 :
111734 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111735 :
111736 : std::list<SgStatement*>
111737 0 : SgOmpWhenClause::get_construct_directives () const
111738 : {
111739 0 : ROSE_ASSERT (this != NULL);
111740 :
111741 : #if 0
111742 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111743 : // used to trigger marking transformations for the token-based unparsing.
111744 : printf ("SgOmpWhenClause::get_construct_directives = %p = %s \n",this,this->class_name().c_str());
111745 : #endif
111746 :
111747 0 : return p_construct_directives;
111748 : }
111749 :
111750 : void
111751 0 : SgOmpWhenClause::set_construct_directives ( std::list<SgStatement*> construct_directives )
111752 : {
111753 0 : ROSE_ASSERT (this != NULL);
111754 :
111755 : #if 0
111756 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111757 : // used to trigger marking transformations for the token-based unparsing.
111758 : printf ("SgOmpWhenClause::set_construct_directives = %p = %s \n",this,this->class_name().c_str());
111759 : #endif
111760 :
111761 0 : set_isModified(true);
111762 :
111763 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111764 : if (p_construct_directives != NULL && construct_directives != NULL && p_construct_directives != construct_directives)
111765 : {
111766 : printf ("Warning: construct_directives = %p overwriting valid pointer p_construct_directives = %p \n",construct_directives,p_construct_directives);
111767 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111768 : printf ("Error fails assertion (p_construct_directives != NULL && construct_directives != NULL && p_construct_directives != construct_directives) is false\n");
111769 : ROSE_ASSERT(false);
111770 : #endif
111771 : }
111772 : #endif
111773 0 : p_construct_directives = construct_directives;
111774 0 : }
111775 :
111776 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111777 :
111778 :
111779 : // End of memberFunctionString
111780 : // Start of memberFunctionString
111781 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111782 :
111783 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111784 :
111785 : SgExpression*
111786 0 : SgOmpWhenClause::get_device_arch () const
111787 : {
111788 0 : ROSE_ASSERT (this != NULL);
111789 :
111790 : #if 0
111791 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111792 : // used to trigger marking transformations for the token-based unparsing.
111793 : printf ("SgOmpWhenClause::get_device_arch = %p = %s \n",this,this->class_name().c_str());
111794 : #endif
111795 :
111796 0 : return p_device_arch;
111797 : }
111798 :
111799 : void
111800 0 : SgOmpWhenClause::set_device_arch ( SgExpression* device_arch )
111801 : {
111802 0 : ROSE_ASSERT (this != NULL);
111803 :
111804 : #if 0
111805 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111806 : // used to trigger marking transformations for the token-based unparsing.
111807 : printf ("SgOmpWhenClause::set_device_arch = %p = %s \n",this,this->class_name().c_str());
111808 : #endif
111809 :
111810 0 : set_isModified(true);
111811 :
111812 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111813 : if (p_device_arch != NULL && device_arch != NULL && p_device_arch != device_arch)
111814 : {
111815 : printf ("Warning: device_arch = %p overwriting valid pointer p_device_arch = %p \n",device_arch,p_device_arch);
111816 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111817 : printf ("Error fails assertion (p_device_arch != NULL && device_arch != NULL && p_device_arch != device_arch) is false\n");
111818 : ROSE_ASSERT(false);
111819 : #endif
111820 : }
111821 : #endif
111822 0 : p_device_arch = device_arch;
111823 0 : }
111824 :
111825 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111826 :
111827 :
111828 : // End of memberFunctionString
111829 : // Start of memberFunctionString
111830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111831 :
111832 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111833 :
111834 : SgExpression*
111835 0 : SgOmpWhenClause::get_device_isa () const
111836 : {
111837 0 : ROSE_ASSERT (this != NULL);
111838 :
111839 : #if 0
111840 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111841 : // used to trigger marking transformations for the token-based unparsing.
111842 : printf ("SgOmpWhenClause::get_device_isa = %p = %s \n",this,this->class_name().c_str());
111843 : #endif
111844 :
111845 0 : return p_device_isa;
111846 : }
111847 :
111848 : void
111849 0 : SgOmpWhenClause::set_device_isa ( SgExpression* device_isa )
111850 : {
111851 0 : ROSE_ASSERT (this != NULL);
111852 :
111853 : #if 0
111854 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111855 : // used to trigger marking transformations for the token-based unparsing.
111856 : printf ("SgOmpWhenClause::set_device_isa = %p = %s \n",this,this->class_name().c_str());
111857 : #endif
111858 :
111859 0 : set_isModified(true);
111860 :
111861 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111862 : if (p_device_isa != NULL && device_isa != NULL && p_device_isa != device_isa)
111863 : {
111864 : printf ("Warning: device_isa = %p overwriting valid pointer p_device_isa = %p \n",device_isa,p_device_isa);
111865 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111866 : printf ("Error fails assertion (p_device_isa != NULL && device_isa != NULL && p_device_isa != device_isa) is false\n");
111867 : ROSE_ASSERT(false);
111868 : #endif
111869 : }
111870 : #endif
111871 0 : p_device_isa = device_isa;
111872 0 : }
111873 :
111874 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111875 :
111876 :
111877 : // End of memberFunctionString
111878 : // Start of memberFunctionString
111879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111880 :
111881 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111882 :
111883 : SgOmpClause::omp_when_context_kind_enum
111884 0 : SgOmpWhenClause::get_device_kind () const
111885 : {
111886 0 : ROSE_ASSERT (this != NULL);
111887 :
111888 : #if 0
111889 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111890 : // used to trigger marking transformations for the token-based unparsing.
111891 : printf ("SgOmpWhenClause::get_device_kind = %p = %s \n",this,this->class_name().c_str());
111892 : #endif
111893 :
111894 0 : return p_device_kind;
111895 : }
111896 :
111897 : void
111898 0 : SgOmpWhenClause::set_device_kind ( SgOmpClause::omp_when_context_kind_enum device_kind )
111899 : {
111900 0 : ROSE_ASSERT (this != NULL);
111901 :
111902 : #if 0
111903 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111904 : // used to trigger marking transformations for the token-based unparsing.
111905 : printf ("SgOmpWhenClause::set_device_kind = %p = %s \n",this,this->class_name().c_str());
111906 : #endif
111907 :
111908 0 : set_isModified(true);
111909 :
111910 0 : p_device_kind = device_kind;
111911 0 : }
111912 :
111913 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111914 :
111915 :
111916 : // End of memberFunctionString
111917 : // Start of memberFunctionString
111918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111919 :
111920 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111921 :
111922 : SgOmpClause::omp_when_context_vendor_enum
111923 0 : SgOmpWhenClause::get_implementation_vendor () const
111924 : {
111925 0 : ROSE_ASSERT (this != NULL);
111926 :
111927 : #if 0
111928 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111929 : // used to trigger marking transformations for the token-based unparsing.
111930 : printf ("SgOmpWhenClause::get_implementation_vendor = %p = %s \n",this,this->class_name().c_str());
111931 : #endif
111932 :
111933 0 : return p_implementation_vendor;
111934 : }
111935 :
111936 : void
111937 0 : SgOmpWhenClause::set_implementation_vendor ( SgOmpClause::omp_when_context_vendor_enum implementation_vendor )
111938 : {
111939 0 : ROSE_ASSERT (this != NULL);
111940 :
111941 : #if 0
111942 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111943 : // used to trigger marking transformations for the token-based unparsing.
111944 : printf ("SgOmpWhenClause::set_implementation_vendor = %p = %s \n",this,this->class_name().c_str());
111945 : #endif
111946 :
111947 0 : set_isModified(true);
111948 :
111949 0 : p_implementation_vendor = implementation_vendor;
111950 0 : }
111951 :
111952 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
111953 :
111954 :
111955 : // End of memberFunctionString
111956 : // Start of memberFunctionString
111957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
111958 :
111959 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
111960 :
111961 : SgExpression*
111962 0 : SgOmpWhenClause::get_implementation_user_defined () const
111963 : {
111964 0 : ROSE_ASSERT (this != NULL);
111965 :
111966 : #if 0
111967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111968 : // used to trigger marking transformations for the token-based unparsing.
111969 : printf ("SgOmpWhenClause::get_implementation_user_defined = %p = %s \n",this,this->class_name().c_str());
111970 : #endif
111971 :
111972 0 : return p_implementation_user_defined;
111973 : }
111974 :
111975 : void
111976 0 : SgOmpWhenClause::set_implementation_user_defined ( SgExpression* implementation_user_defined )
111977 : {
111978 0 : ROSE_ASSERT (this != NULL);
111979 :
111980 : #if 0
111981 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
111982 : // used to trigger marking transformations for the token-based unparsing.
111983 : printf ("SgOmpWhenClause::set_implementation_user_defined = %p = %s \n",this,this->class_name().c_str());
111984 : #endif
111985 :
111986 0 : set_isModified(true);
111987 :
111988 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
111989 : if (p_implementation_user_defined != NULL && implementation_user_defined != NULL && p_implementation_user_defined != implementation_user_defined)
111990 : {
111991 : printf ("Warning: implementation_user_defined = %p overwriting valid pointer p_implementation_user_defined = %p \n",implementation_user_defined,p_implementation_user_defined);
111992 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
111993 : printf ("Error fails assertion (p_implementation_user_defined != NULL && implementation_user_defined != NULL && p_implementation_user_defined != implementation_user_defined) is false\n");
111994 : ROSE_ASSERT(false);
111995 : #endif
111996 : }
111997 : #endif
111998 0 : p_implementation_user_defined = implementation_user_defined;
111999 0 : }
112000 :
112001 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
112002 :
112003 :
112004 : // End of memberFunctionString
112005 : // Start of memberFunctionString
112006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
112007 :
112008 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
112009 :
112010 : SgExpression*
112011 0 : SgOmpWhenClause::get_implementation_extension () const
112012 : {
112013 0 : ROSE_ASSERT (this != NULL);
112014 :
112015 : #if 0
112016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112017 : // used to trigger marking transformations for the token-based unparsing.
112018 : printf ("SgOmpWhenClause::get_implementation_extension = %p = %s \n",this,this->class_name().c_str());
112019 : #endif
112020 :
112021 0 : return p_implementation_extension;
112022 : }
112023 :
112024 : void
112025 0 : SgOmpWhenClause::set_implementation_extension ( SgExpression* implementation_extension )
112026 : {
112027 0 : ROSE_ASSERT (this != NULL);
112028 :
112029 : #if 0
112030 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112031 : // used to trigger marking transformations for the token-based unparsing.
112032 : printf ("SgOmpWhenClause::set_implementation_extension = %p = %s \n",this,this->class_name().c_str());
112033 : #endif
112034 :
112035 0 : set_isModified(true);
112036 :
112037 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
112038 : if (p_implementation_extension != NULL && implementation_extension != NULL && p_implementation_extension != implementation_extension)
112039 : {
112040 : printf ("Warning: implementation_extension = %p overwriting valid pointer p_implementation_extension = %p \n",implementation_extension,p_implementation_extension);
112041 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
112042 : printf ("Error fails assertion (p_implementation_extension != NULL && implementation_extension != NULL && p_implementation_extension != implementation_extension) is false\n");
112043 : ROSE_ASSERT(false);
112044 : #endif
112045 : }
112046 : #endif
112047 0 : p_implementation_extension = implementation_extension;
112048 0 : }
112049 :
112050 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
112051 :
112052 :
112053 : // End of memberFunctionString
112054 : // Start of memberFunctionString
112055 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
112056 :
112057 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
112058 :
112059 : SgStatement*
112060 0 : SgOmpWhenClause::get_variant_directive () const
112061 : {
112062 0 : ROSE_ASSERT (this != NULL);
112063 :
112064 : #if 0
112065 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112066 : // used to trigger marking transformations for the token-based unparsing.
112067 : printf ("SgOmpWhenClause::get_variant_directive = %p = %s \n",this,this->class_name().c_str());
112068 : #endif
112069 :
112070 0 : return p_variant_directive;
112071 : }
112072 :
112073 : void
112074 0 : SgOmpWhenClause::set_variant_directive ( SgStatement* variant_directive )
112075 : {
112076 0 : ROSE_ASSERT (this != NULL);
112077 :
112078 : #if 0
112079 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112080 : // used to trigger marking transformations for the token-based unparsing.
112081 : printf ("SgOmpWhenClause::set_variant_directive = %p = %s \n",this,this->class_name().c_str());
112082 : #endif
112083 :
112084 0 : set_isModified(true);
112085 :
112086 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
112087 : if (p_variant_directive != NULL && variant_directive != NULL && p_variant_directive != variant_directive)
112088 : {
112089 : printf ("Warning: variant_directive = %p overwriting valid pointer p_variant_directive = %p \n",variant_directive,p_variant_directive);
112090 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
112091 : printf ("Error fails assertion (p_variant_directive != NULL && variant_directive != NULL && p_variant_directive != variant_directive) is false\n");
112092 : ROSE_ASSERT(false);
112093 : #endif
112094 : }
112095 : #endif
112096 0 : p_variant_directive = variant_directive;
112097 0 : }
112098 :
112099 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
112100 :
112101 :
112102 : // End of memberFunctionString
112103 : // Start of memberFunctionString
112104 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
112105 :
112106 : // *** COMMON CODE SECTION BEGINS HERE ***
112107 :
112108 : #if 0
112109 : int
112110 : SgOmpWhenClause::getVariant() const
112111 : {
112112 : // This function is used in ROSE while "variant()" is used in SAGE
112113 : assert(this != NULL);
112114 : return variant();
112115 : }
112116 : #endif
112117 :
112118 : // This function is used in ROSE in treeTraversal code
112119 : // eventually replaces getVariant() and variant()
112120 : // though after variant() has been removed for a while we will
112121 : // want to change the name of variantT() back to variant()
112122 : // (since the "T" was ment to stand for temporary).
112123 : // When this happens the variantT() will be depricated.
112124 : VariantT
112125 0 : SgOmpWhenClause::variantT() const
112126 : {
112127 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
112128 0 : ROSE_ASSERT(this != NULL);
112129 0 : return V_SgOmpWhenClause;
112130 : }
112131 :
112132 : #if 0
112133 : int
112134 : SgOmpWhenClause::variant() const
112135 : {
112136 : // This function is used in SAGE
112137 : ROSE_ASSERT(this != NULL);
112138 : return OmpWhenClauseTag;
112139 : }
112140 : #endif
112141 :
112142 : ROSE_DLL_API const char*
112143 0 : SgOmpWhenClause::sage_class_name() const
112144 : {
112145 0 : ROSE_ASSERT(this != NULL);
112146 0 : return "SgOmpWhenClause";
112147 : }
112148 :
112149 : std::string
112150 0 : SgOmpWhenClause::class_name() const
112151 : {
112152 0 : ROSE_ASSERT(this != NULL);
112153 0 : return "SgOmpWhenClause";
112154 : }
112155 :
112156 : // DQ (11/26/2005): Support for visitor pattern mechanims
112157 : // (inferior to ROSE traversal mechanism, experimental).
112158 : void
112159 0 : SgOmpWhenClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
112160 : {
112161 0 : ROSE_ASSERT(this != NULL);
112162 0 : visitor.visit(this);
112163 0 : }
112164 :
112165 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
112166 0 : void SgOmpWhenClause::accept (ROSE_VisitorPattern & visitor) {
112167 0 : ROSE_ASSERT(this != NULL);
112168 0 : visitor.visit(this);
112169 0 : }
112170 :
112171 : SgOmpWhenClause*
112172 0 : SgOmpWhenClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
112173 : {
112174 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
112175 : // This function is currently only supported for the AST used the represent Binary executables.
112176 : if (0 /* isSgAsmNode(this) != NULL */)
112177 : {
112178 : // Support for regex specification.
112179 : std::string prefixCode = "REGEX:";
112180 : addNewAttribute(prefixCode + s,a);
112181 : }
112182 : #endif
112183 :
112184 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
112185 0 : return this;
112186 : }
112187 :
112188 : // *** COMMON CODE SECTION ENDS HERE ***
112189 :
112190 :
112191 : // End of memberFunctionString
112192 : // Start of memberFunctionString
112193 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
112194 :
112195 :
112196 : #if 0
112197 : //! Error checking support
112198 : /*! Verifies the following:
112199 : - working getVariant() member function
112200 : - calls base class's error() member function
112201 : Every class has one of these functions.
112202 : */
112203 : bool
112204 : SgOmpWhenClause::error()
112205 : {
112206 : // Put error checking here
112207 :
112208 : ROSE_ASSERT (this != NULL);
112209 : if (getVariant() != OmpWhenClauseTag)
112210 : {
112211 : printf ("Error in SgOmpWhenClause::error(): SgOmpWhenClause object has a %s variant \n",
112212 : Cxx_GrammarTerminalNames[getVariant()].name);
112213 : // printf ("Error in SgOmpWhenClause::error() \n");
112214 : ROSE_ABORT();
112215 : }
112216 :
112217 : ROSE_ASSERT (getVariant() == OmpWhenClauseTag);
112218 : return SgOmpClause::error();
112219 : }
112220 : #endif
112221 :
112222 :
112223 :
112224 : // End of memberFunctionString
112225 :
112226 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
112227 :
112228 0 : SgOmpWhenClause* isSgOmpWhenClause ( SgNode* inputDerivedClassPointer )
112229 : {
112230 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
112231 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
112232 : // So to fix this we return NULL directly when the input is NULL and avoid the
112233 : // dynamic_cast in this case. This is likely a performance improvement as well.
112234 : // return dynamic_cast<SgOmpWhenClause*>(inputDerivedClassPointer);
112235 : // Milind Chabbi (8/28/2013): isSgOmpWhenClause uses table-driven castability instead of c++ default dynamic_cast
112236 : // this improves the running time performance by 10-20%.
112237 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpWhenClause*>(inputDerivedClassPointer);
112238 0 : return IS_SgOmpWhenClause_FAST_MACRO(inputDerivedClassPointer);
112239 : }
112240 :
112241 : // DQ (11/8/2003): Added version of functions taking const pointer
112242 0 : const SgOmpWhenClause* isSgOmpWhenClause ( const SgNode* inputDerivedClassPointer )
112243 : {
112244 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
112245 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
112246 : // So to fix this we return NULL directly when the input is NULL and avoid the
112247 : // dynamic_cast in this case. This is likely a performance improvement as well.
112248 : // return dynamic_cast<const SgOmpWhenClause*>(inputDerivedClassPointer);
112249 : // Milind Chabbi (8/28/2013): isSgOmpWhenClause uses table-driven castability instead of c++ default dynamic_cast
112250 : // this improves the running time performance by 10-20%.
112251 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpWhenClause*>(inputDerivedClassPointer);
112252 0 : return IS_SgOmpWhenClause_FAST_MACRO(inputDerivedClassPointer);
112253 : }
112254 :
112255 :
112256 :
112257 : /* #line 112258 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112258 :
112259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
112260 :
112261 : /**
112262 : \brief Generated destructor
112263 :
112264 : This destructor is automatically generated (by ROSETTA). This destructor
112265 : only frees memory of data members associated with the parts of the current IR node which
112266 : are NOT traversed. Those data members that are part of a traversal can be freed using
112267 : a traversal (calling this destructor on all children in a post-order traversal). Such
112268 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
112269 :
112270 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
112271 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
112272 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
112273 :
112274 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
112275 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
112276 : pointers are not yet implemented to call delete on eash pointer in the container.
112277 : (This could be done by derivation from the STL containers to define containers that
112278 : automatically deleted their members.)
112279 :
112280 : */
112281 0 : SgOmpWhenClause::~SgOmpWhenClause () {
112282 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
112283 :
112284 :
112285 : // case: not a listType for user_condition
112286 0 : p_user_condition = NULL; // non list case
112287 : // case: not a listType for user_condition_score
112288 0 : p_user_condition_score = NULL; // non list case
112289 : // case: not a listType for device_arch
112290 0 : p_device_arch = NULL; // non list case
112291 : // case: not a listType for device_isa
112292 0 : p_device_isa = NULL; // non list case
112293 : // case: not a listType for device_kind
112294 0 : p_device_kind = e_omp_when_context_kind_unknown; // non list case
112295 : // case: not a listType for implementation_vendor
112296 0 : p_implementation_vendor = e_omp_when_context_vendor_unspecified; // non list case
112297 : // case: not a listType for implementation_user_defined
112298 0 : p_implementation_user_defined = NULL; // non list case
112299 : // case: not a listType for implementation_extension
112300 0 : p_implementation_extension = NULL; // non list case
112301 : // case: not a listType for variant_directive
112302 0 : p_variant_directive = NULL; // non list case
112303 :
112304 : }
112305 :
112306 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
112307 0 : }
112308 :
112309 :
112310 : /* #line 112311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112311 :
112312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
112313 :
112314 : // Generated constructor
112315 0 : SgOmpWhenClause::SgOmpWhenClause ( Sg_File_Info* startOfConstruct, SgExpression* user_condition, SgExpression* user_condition_score, SgExpression* device_arch, SgExpression* device_isa, SgOmpClause::omp_when_context_kind_enum device_kind, SgOmpClause::omp_when_context_vendor_enum implementation_vendor, SgExpression* implementation_user_defined, SgExpression* implementation_extension, SgStatement* variant_directive )
112316 0 : : SgOmpClause(startOfConstruct)
112317 : {
112318 : #ifdef DEBUG
112319 : // printf ("In SgOmpWhenClause::SgOmpWhenClause (Sg_File_Info* startOfConstruct, SgExpression* user_condition, SgExpression* user_condition_score, SgExpression* device_arch, SgExpression* device_isa, SgOmpClause::omp_when_context_kind_enum device_kind, SgOmpClause::omp_when_context_vendor_enum implementation_vendor, SgExpression* implementation_user_defined, SgExpression* implementation_extension, SgStatement* variant_directive) sage_class_name() = %s \n",sage_class_name());
112320 : #endif
112321 : #if 0
112322 : // debugging information!
112323 : printf ("In SgOmpWhenClause::SgOmpWhenClause (Sg_File_Info* startOfConstruct, SgExpression* user_condition, SgExpression* user_condition_score, SgExpression* device_arch, SgExpression* device_isa, SgOmpClause::omp_when_context_kind_enum device_kind, SgOmpClause::omp_when_context_vendor_enum implementation_vendor, SgExpression* implementation_user_defined, SgExpression* implementation_extension, SgStatement* variant_directive): this = %p = %s \n",this,this->class_name().c_str());
112324 : #endif
112325 :
112326 0 : p_user_condition = user_condition;
112327 0 : p_user_condition_score = user_condition_score;
112328 0 : p_device_arch = device_arch;
112329 0 : p_device_isa = device_isa;
112330 0 : p_device_kind = device_kind;
112331 0 : p_implementation_vendor = implementation_vendor;
112332 0 : p_implementation_user_defined = implementation_user_defined;
112333 0 : p_implementation_extension = implementation_extension;
112334 0 : p_variant_directive = variant_directive;
112335 :
112336 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
112337 :
112338 : #if 0
112339 : // DQ (7/30/2014): Call a virtual function.
112340 : std::string s = this->class_name();
112341 : #endif
112342 :
112343 : // Test the variant virtual function
112344 : // assert(OmpWhenClauseTag == variant());
112345 0 : assert(OmpWhenClauseTag == this->variant());
112346 0 : ROSE_ASSERT(OmpWhenClauseTag == (int)(this->variantT()));
112347 0 : post_construction_initialization();
112348 :
112349 : // Test the isSgOmpWhenClause() function since it has been problematic
112350 0 : assert(isSgOmpWhenClause(this) != NULL);
112351 0 : }
112352 :
112353 : // Generated constructor (all data members)
112354 :
112355 : /* #line 112356 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112356 :
112357 :
112358 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
112359 :
112360 :
112361 : // ********************************************************
112362 : // member functions common across all array grammar objects
112363 : // ********************************************************
112364 :
112365 :
112366 :
112367 : /* #line 112368 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112368 :
112369 :
112370 :
112371 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
112372 :
112373 : // ********************************************************
112374 : // member functions specific to each node in the grammar
112375 : // ********************************************************
112376 :
112377 :
112378 : /* #line 112379 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112379 :
112380 : // Start of memberFunctionString
112381 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
112382 :
112383 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
112384 :
112385 : std::list<SgOmpUsesAllocatorsDefination*>
112386 1 : SgOmpUsesAllocatorsClause::get_uses_allocators_defination () const
112387 : {
112388 1 : ROSE_ASSERT (this != NULL);
112389 :
112390 : #if 0
112391 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112392 : // used to trigger marking transformations for the token-based unparsing.
112393 : printf ("SgOmpUsesAllocatorsClause::get_uses_allocators_defination = %p = %s \n",this,this->class_name().c_str());
112394 : #endif
112395 :
112396 1 : return p_uses_allocators_defination;
112397 : }
112398 :
112399 : void
112400 1 : SgOmpUsesAllocatorsClause::set_uses_allocators_defination ( std::list<SgOmpUsesAllocatorsDefination*> uses_allocators_defination )
112401 : {
112402 1 : ROSE_ASSERT (this != NULL);
112403 :
112404 : #if 0
112405 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112406 : // used to trigger marking transformations for the token-based unparsing.
112407 : printf ("SgOmpUsesAllocatorsClause::set_uses_allocators_defination = %p = %s \n",this,this->class_name().c_str());
112408 : #endif
112409 :
112410 1 : set_isModified(true);
112411 :
112412 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
112413 : if (p_uses_allocators_defination != NULL && uses_allocators_defination != NULL && p_uses_allocators_defination != uses_allocators_defination)
112414 : {
112415 : printf ("Warning: uses_allocators_defination = %p overwriting valid pointer p_uses_allocators_defination = %p \n",uses_allocators_defination,p_uses_allocators_defination);
112416 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
112417 : printf ("Error fails assertion (p_uses_allocators_defination != NULL && uses_allocators_defination != NULL && p_uses_allocators_defination != uses_allocators_defination) is false\n");
112418 : ROSE_ASSERT(false);
112419 : #endif
112420 : }
112421 : #endif
112422 1 : p_uses_allocators_defination = uses_allocators_defination;
112423 1 : }
112424 :
112425 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
112426 :
112427 :
112428 : // End of memberFunctionString
112429 : // Start of memberFunctionString
112430 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
112431 :
112432 : // *** COMMON CODE SECTION BEGINS HERE ***
112433 :
112434 : #if 0
112435 : int
112436 : SgOmpUsesAllocatorsClause::getVariant() const
112437 : {
112438 : // This function is used in ROSE while "variant()" is used in SAGE
112439 : assert(this != NULL);
112440 : return variant();
112441 : }
112442 : #endif
112443 :
112444 : // This function is used in ROSE in treeTraversal code
112445 : // eventually replaces getVariant() and variant()
112446 : // though after variant() has been removed for a while we will
112447 : // want to change the name of variantT() back to variant()
112448 : // (since the "T" was ment to stand for temporary).
112449 : // When this happens the variantT() will be depricated.
112450 : VariantT
112451 54 : SgOmpUsesAllocatorsClause::variantT() const
112452 : {
112453 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
112454 54 : ROSE_ASSERT(this != NULL);
112455 54 : return V_SgOmpUsesAllocatorsClause;
112456 : }
112457 :
112458 : #if 0
112459 : int
112460 : SgOmpUsesAllocatorsClause::variant() const
112461 : {
112462 : // This function is used in SAGE
112463 : ROSE_ASSERT(this != NULL);
112464 : return OmpUsesAllocatorsClauseTag;
112465 : }
112466 : #endif
112467 :
112468 : ROSE_DLL_API const char*
112469 0 : SgOmpUsesAllocatorsClause::sage_class_name() const
112470 : {
112471 0 : ROSE_ASSERT(this != NULL);
112472 0 : return "SgOmpUsesAllocatorsClause";
112473 : }
112474 :
112475 : std::string
112476 1 : SgOmpUsesAllocatorsClause::class_name() const
112477 : {
112478 1 : ROSE_ASSERT(this != NULL);
112479 1 : return "SgOmpUsesAllocatorsClause";
112480 : }
112481 :
112482 : // DQ (11/26/2005): Support for visitor pattern mechanims
112483 : // (inferior to ROSE traversal mechanism, experimental).
112484 : void
112485 0 : SgOmpUsesAllocatorsClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
112486 : {
112487 0 : ROSE_ASSERT(this != NULL);
112488 0 : visitor.visit(this);
112489 0 : }
112490 :
112491 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
112492 0 : void SgOmpUsesAllocatorsClause::accept (ROSE_VisitorPattern & visitor) {
112493 0 : ROSE_ASSERT(this != NULL);
112494 0 : visitor.visit(this);
112495 0 : }
112496 :
112497 : SgOmpUsesAllocatorsClause*
112498 0 : SgOmpUsesAllocatorsClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
112499 : {
112500 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
112501 : // This function is currently only supported for the AST used the represent Binary executables.
112502 : if (0 /* isSgAsmNode(this) != NULL */)
112503 : {
112504 : // Support for regex specification.
112505 : std::string prefixCode = "REGEX:";
112506 : addNewAttribute(prefixCode + s,a);
112507 : }
112508 : #endif
112509 :
112510 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
112511 0 : return this;
112512 : }
112513 :
112514 : // *** COMMON CODE SECTION ENDS HERE ***
112515 :
112516 :
112517 : // End of memberFunctionString
112518 : // Start of memberFunctionString
112519 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
112520 :
112521 :
112522 : #if 0
112523 : //! Error checking support
112524 : /*! Verifies the following:
112525 : - working getVariant() member function
112526 : - calls base class's error() member function
112527 : Every class has one of these functions.
112528 : */
112529 : bool
112530 : SgOmpUsesAllocatorsClause::error()
112531 : {
112532 : // Put error checking here
112533 :
112534 : ROSE_ASSERT (this != NULL);
112535 : if (getVariant() != OmpUsesAllocatorsClauseTag)
112536 : {
112537 : printf ("Error in SgOmpUsesAllocatorsClause::error(): SgOmpUsesAllocatorsClause object has a %s variant \n",
112538 : Cxx_GrammarTerminalNames[getVariant()].name);
112539 : // printf ("Error in SgOmpUsesAllocatorsClause::error() \n");
112540 : ROSE_ABORT();
112541 : }
112542 :
112543 : ROSE_ASSERT (getVariant() == OmpUsesAllocatorsClauseTag);
112544 : return SgOmpClause::error();
112545 : }
112546 : #endif
112547 :
112548 :
112549 :
112550 : // End of memberFunctionString
112551 :
112552 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
112553 :
112554 3 : SgOmpUsesAllocatorsClause* isSgOmpUsesAllocatorsClause ( SgNode* inputDerivedClassPointer )
112555 : {
112556 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
112557 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
112558 : // So to fix this we return NULL directly when the input is NULL and avoid the
112559 : // dynamic_cast in this case. This is likely a performance improvement as well.
112560 : // return dynamic_cast<SgOmpUsesAllocatorsClause*>(inputDerivedClassPointer);
112561 : // Milind Chabbi (8/28/2013): isSgOmpUsesAllocatorsClause uses table-driven castability instead of c++ default dynamic_cast
112562 : // this improves the running time performance by 10-20%.
112563 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUsesAllocatorsClause*>(inputDerivedClassPointer);
112564 3 : return IS_SgOmpUsesAllocatorsClause_FAST_MACRO(inputDerivedClassPointer);
112565 : }
112566 :
112567 : // DQ (11/8/2003): Added version of functions taking const pointer
112568 0 : const SgOmpUsesAllocatorsClause* isSgOmpUsesAllocatorsClause ( const SgNode* inputDerivedClassPointer )
112569 : {
112570 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
112571 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
112572 : // So to fix this we return NULL directly when the input is NULL and avoid the
112573 : // dynamic_cast in this case. This is likely a performance improvement as well.
112574 : // return dynamic_cast<const SgOmpUsesAllocatorsClause*>(inputDerivedClassPointer);
112575 : // Milind Chabbi (8/28/2013): isSgOmpUsesAllocatorsClause uses table-driven castability instead of c++ default dynamic_cast
112576 : // this improves the running time performance by 10-20%.
112577 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUsesAllocatorsClause*>(inputDerivedClassPointer);
112578 0 : return IS_SgOmpUsesAllocatorsClause_FAST_MACRO(inputDerivedClassPointer);
112579 : }
112580 :
112581 :
112582 :
112583 : /* #line 112584 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112584 :
112585 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
112586 :
112587 : /**
112588 : \brief Generated destructor
112589 :
112590 : This destructor is automatically generated (by ROSETTA). This destructor
112591 : only frees memory of data members associated with the parts of the current IR node which
112592 : are NOT traversed. Those data members that are part of a traversal can be freed using
112593 : a traversal (calling this destructor on all children in a post-order traversal). Such
112594 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
112595 :
112596 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
112597 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
112598 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
112599 :
112600 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
112601 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
112602 : pointers are not yet implemented to call delete on eash pointer in the container.
112603 : (This could be done by derivation from the STL containers to define containers that
112604 : automatically deleted their members.)
112605 :
112606 : */
112607 0 : SgOmpUsesAllocatorsClause::~SgOmpUsesAllocatorsClause () {
112608 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
112609 :
112610 :
112611 :
112612 : }
112613 :
112614 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
112615 0 : }
112616 :
112617 :
112618 : /* #line 112619 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112619 :
112620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
112621 :
112622 : // Generated constructor
112623 0 : SgOmpUsesAllocatorsClause::SgOmpUsesAllocatorsClause ( Sg_File_Info* startOfConstruct )
112624 0 : : SgOmpClause(startOfConstruct)
112625 : {
112626 : #ifdef DEBUG
112627 : // printf ("In SgOmpUsesAllocatorsClause::SgOmpUsesAllocatorsClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
112628 : #endif
112629 : #if 0
112630 : // debugging information!
112631 : printf ("In SgOmpUsesAllocatorsClause::SgOmpUsesAllocatorsClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
112632 : #endif
112633 :
112634 :
112635 :
112636 : #if 0
112637 : // DQ (7/30/2014): Call a virtual function.
112638 : std::string s = this->class_name();
112639 : #endif
112640 :
112641 : // Test the variant virtual function
112642 : // assert(OmpUsesAllocatorsClauseTag == variant());
112643 0 : assert(OmpUsesAllocatorsClauseTag == this->variant());
112644 0 : ROSE_ASSERT(OmpUsesAllocatorsClauseTag == (int)(this->variantT()));
112645 0 : post_construction_initialization();
112646 :
112647 : // Test the isSgOmpUsesAllocatorsClause() function since it has been problematic
112648 0 : assert(isSgOmpUsesAllocatorsClause(this) != NULL);
112649 0 : }
112650 :
112651 : // Generated constructor (all data members)
112652 :
112653 : /* #line 112654 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112654 :
112655 :
112656 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
112657 :
112658 :
112659 : // ********************************************************
112660 : // member functions common across all array grammar objects
112661 : // ********************************************************
112662 :
112663 :
112664 :
112665 : /* #line 112666 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112666 :
112667 :
112668 :
112669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
112670 :
112671 : // ********************************************************
112672 : // member functions specific to each node in the grammar
112673 : // ********************************************************
112674 :
112675 :
112676 : /* #line 112677 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112677 :
112678 : // Start of memberFunctionString
112679 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
112680 :
112681 : // *** COMMON CODE SECTION BEGINS HERE ***
112682 :
112683 : #if 0
112684 : int
112685 : SgOmpFullClause::getVariant() const
112686 : {
112687 : // This function is used in ROSE while "variant()" is used in SAGE
112688 : assert(this != NULL);
112689 : return variant();
112690 : }
112691 : #endif
112692 :
112693 : // This function is used in ROSE in treeTraversal code
112694 : // eventually replaces getVariant() and variant()
112695 : // though after variant() has been removed for a while we will
112696 : // want to change the name of variantT() back to variant()
112697 : // (since the "T" was ment to stand for temporary).
112698 : // When this happens the variantT() will be depricated.
112699 : VariantT
112700 0 : SgOmpFullClause::variantT() const
112701 : {
112702 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
112703 0 : ROSE_ASSERT(this != NULL);
112704 0 : return V_SgOmpFullClause;
112705 : }
112706 :
112707 : #if 0
112708 : int
112709 : SgOmpFullClause::variant() const
112710 : {
112711 : // This function is used in SAGE
112712 : ROSE_ASSERT(this != NULL);
112713 : return OmpFullTag;
112714 : }
112715 : #endif
112716 :
112717 : ROSE_DLL_API const char*
112718 0 : SgOmpFullClause::sage_class_name() const
112719 : {
112720 0 : ROSE_ASSERT(this != NULL);
112721 0 : return "SgOmpFullClause";
112722 : }
112723 :
112724 : std::string
112725 0 : SgOmpFullClause::class_name() const
112726 : {
112727 0 : ROSE_ASSERT(this != NULL);
112728 0 : return "SgOmpFullClause";
112729 : }
112730 :
112731 : // DQ (11/26/2005): Support for visitor pattern mechanims
112732 : // (inferior to ROSE traversal mechanism, experimental).
112733 : void
112734 0 : SgOmpFullClause::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
112735 : {
112736 0 : ROSE_ASSERT(this != NULL);
112737 0 : visitor.visit(this);
112738 0 : }
112739 :
112740 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
112741 0 : void SgOmpFullClause::accept (ROSE_VisitorPattern & visitor) {
112742 0 : ROSE_ASSERT(this != NULL);
112743 0 : visitor.visit(this);
112744 0 : }
112745 :
112746 : SgOmpFullClause*
112747 0 : SgOmpFullClause::addRegExpAttribute(std::string s, AstRegExAttribute* a)
112748 : {
112749 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
112750 : // This function is currently only supported for the AST used the represent Binary executables.
112751 : if (0 /* isSgAsmNode(this) != NULL */)
112752 : {
112753 : // Support for regex specification.
112754 : std::string prefixCode = "REGEX:";
112755 : addNewAttribute(prefixCode + s,a);
112756 : }
112757 : #endif
112758 :
112759 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
112760 0 : return this;
112761 : }
112762 :
112763 : // *** COMMON CODE SECTION ENDS HERE ***
112764 :
112765 :
112766 : // End of memberFunctionString
112767 : // Start of memberFunctionString
112768 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
112769 :
112770 :
112771 : #if 0
112772 : //! Error checking support
112773 : /*! Verifies the following:
112774 : - working getVariant() member function
112775 : - calls base class's error() member function
112776 : Every class has one of these functions.
112777 : */
112778 : bool
112779 : SgOmpFullClause::error()
112780 : {
112781 : // Put error checking here
112782 :
112783 : ROSE_ASSERT (this != NULL);
112784 : if (getVariant() != OmpFullTag)
112785 : {
112786 : printf ("Error in SgOmpFullClause::error(): SgOmpFullClause object has a %s variant \n",
112787 : Cxx_GrammarTerminalNames[getVariant()].name);
112788 : // printf ("Error in SgOmpFullClause::error() \n");
112789 : ROSE_ABORT();
112790 : }
112791 :
112792 : ROSE_ASSERT (getVariant() == OmpFullTag);
112793 : return SgOmpClause::error();
112794 : }
112795 : #endif
112796 :
112797 :
112798 :
112799 : // End of memberFunctionString
112800 :
112801 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
112802 :
112803 0 : SgOmpFullClause* isSgOmpFullClause ( SgNode* inputDerivedClassPointer )
112804 : {
112805 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
112806 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
112807 : // So to fix this we return NULL directly when the input is NULL and avoid the
112808 : // dynamic_cast in this case. This is likely a performance improvement as well.
112809 : // return dynamic_cast<SgOmpFullClause*>(inputDerivedClassPointer);
112810 : // Milind Chabbi (8/28/2013): isSgOmpFullClause uses table-driven castability instead of c++ default dynamic_cast
112811 : // this improves the running time performance by 10-20%.
112812 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpFullClause*>(inputDerivedClassPointer);
112813 0 : return IS_SgOmpFullClause_FAST_MACRO(inputDerivedClassPointer);
112814 : }
112815 :
112816 : // DQ (11/8/2003): Added version of functions taking const pointer
112817 0 : const SgOmpFullClause* isSgOmpFullClause ( const SgNode* inputDerivedClassPointer )
112818 : {
112819 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
112820 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
112821 : // So to fix this we return NULL directly when the input is NULL and avoid the
112822 : // dynamic_cast in this case. This is likely a performance improvement as well.
112823 : // return dynamic_cast<const SgOmpFullClause*>(inputDerivedClassPointer);
112824 : // Milind Chabbi (8/28/2013): isSgOmpFullClause uses table-driven castability instead of c++ default dynamic_cast
112825 : // this improves the running time performance by 10-20%.
112826 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpFullClause*>(inputDerivedClassPointer);
112827 0 : return IS_SgOmpFullClause_FAST_MACRO(inputDerivedClassPointer);
112828 : }
112829 :
112830 :
112831 :
112832 : /* #line 112833 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112833 :
112834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
112835 :
112836 : /**
112837 : \brief Generated destructor
112838 :
112839 : This destructor is automatically generated (by ROSETTA). This destructor
112840 : only frees memory of data members associated with the parts of the current IR node which
112841 : are NOT traversed. Those data members that are part of a traversal can be freed using
112842 : a traversal (calling this destructor on all children in a post-order traversal). Such
112843 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
112844 :
112845 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
112846 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
112847 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
112848 :
112849 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
112850 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
112851 : pointers are not yet implemented to call delete on eash pointer in the container.
112852 : (This could be done by derivation from the STL containers to define containers that
112853 : automatically deleted their members.)
112854 :
112855 : */
112856 0 : SgOmpFullClause::~SgOmpFullClause () {
112857 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
112858 :
112859 :
112860 :
112861 : }
112862 :
112863 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
112864 0 : }
112865 :
112866 :
112867 : /* #line 112868 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112868 :
112869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
112870 :
112871 : // Generated constructor
112872 0 : SgOmpFullClause::SgOmpFullClause ( Sg_File_Info* startOfConstruct )
112873 0 : : SgOmpClause(startOfConstruct)
112874 : {
112875 : #ifdef DEBUG
112876 : // printf ("In SgOmpFullClause::SgOmpFullClause (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
112877 : #endif
112878 : #if 0
112879 : // debugging information!
112880 : printf ("In SgOmpFullClause::SgOmpFullClause (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
112881 : #endif
112882 :
112883 :
112884 :
112885 : #if 0
112886 : // DQ (7/30/2014): Call a virtual function.
112887 : std::string s = this->class_name();
112888 : #endif
112889 :
112890 : // Test the variant virtual function
112891 : // assert(OmpFullTag == variant());
112892 0 : assert(OmpFullTag == this->variant());
112893 0 : ROSE_ASSERT(OmpFullTag == (int)(this->variantT()));
112894 0 : post_construction_initialization();
112895 :
112896 : // Test the isSgOmpFullClause() function since it has been problematic
112897 0 : assert(isSgOmpFullClause(this) != NULL);
112898 0 : }
112899 :
112900 : // Generated constructor (all data members)
112901 :
112902 : /* #line 112903 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112903 :
112904 :
112905 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
112906 :
112907 :
112908 : // ********************************************************
112909 : // member functions common across all array grammar objects
112910 : // ********************************************************
112911 :
112912 :
112913 :
112914 : /* #line 112915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112915 :
112916 :
112917 :
112918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
112919 :
112920 : // ********************************************************
112921 : // member functions specific to each node in the grammar
112922 : // ********************************************************
112923 :
112924 :
112925 : /* #line 112926 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
112926 :
112927 : // Start of memberFunctionString
112928 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
112929 :
112930 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
112931 :
112932 : std::list<std::list<SgStatement*> >
112933 0 : SgUpirBranchField::get_branches () const
112934 : {
112935 0 : ROSE_ASSERT (this != NULL);
112936 :
112937 : #if 0
112938 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112939 : // used to trigger marking transformations for the token-based unparsing.
112940 : printf ("SgUpirBranchField::get_branches = %p = %s \n",this,this->class_name().c_str());
112941 : #endif
112942 :
112943 0 : return p_branches;
112944 : }
112945 :
112946 : void
112947 0 : SgUpirBranchField::set_branches ( std::list<std::list<SgStatement*> > branches )
112948 : {
112949 0 : ROSE_ASSERT (this != NULL);
112950 :
112951 : #if 0
112952 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
112953 : // used to trigger marking transformations for the token-based unparsing.
112954 : printf ("SgUpirBranchField::set_branches = %p = %s \n",this,this->class_name().c_str());
112955 : #endif
112956 :
112957 0 : set_isModified(true);
112958 :
112959 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
112960 : if (p_branches != NULL && branches != NULL && p_branches != branches)
112961 : {
112962 : printf ("Warning: branches = %p overwriting valid pointer p_branches = %p \n",branches,p_branches);
112963 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
112964 : printf ("Error fails assertion (p_branches != NULL && branches != NULL && p_branches != branches) is false\n");
112965 : ROSE_ASSERT(false);
112966 : #endif
112967 : }
112968 : #endif
112969 0 : p_branches = branches;
112970 0 : }
112971 :
112972 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
112973 :
112974 :
112975 : // End of memberFunctionString
112976 : // Start of memberFunctionString
112977 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
112978 :
112979 : // *** COMMON CODE SECTION BEGINS HERE ***
112980 :
112981 : #if 0
112982 : int
112983 : SgUpirBranchField::getVariant() const
112984 : {
112985 : // This function is used in ROSE while "variant()" is used in SAGE
112986 : assert(this != NULL);
112987 : return variant();
112988 : }
112989 : #endif
112990 :
112991 : // This function is used in ROSE in treeTraversal code
112992 : // eventually replaces getVariant() and variant()
112993 : // though after variant() has been removed for a while we will
112994 : // want to change the name of variantT() back to variant()
112995 : // (since the "T" was ment to stand for temporary).
112996 : // When this happens the variantT() will be depricated.
112997 : VariantT
112998 0 : SgUpirBranchField::variantT() const
112999 : {
113000 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
113001 0 : ROSE_ASSERT(this != NULL);
113002 0 : return V_SgUpirBranchField;
113003 : }
113004 :
113005 : #if 0
113006 : int
113007 : SgUpirBranchField::variant() const
113008 : {
113009 : // This function is used in SAGE
113010 : ROSE_ASSERT(this != NULL);
113011 : return UpirBranchFieldTag;
113012 : }
113013 : #endif
113014 :
113015 : ROSE_DLL_API const char*
113016 0 : SgUpirBranchField::sage_class_name() const
113017 : {
113018 0 : ROSE_ASSERT(this != NULL);
113019 0 : return "SgUpirBranchField";
113020 : }
113021 :
113022 : std::string
113023 0 : SgUpirBranchField::class_name() const
113024 : {
113025 0 : ROSE_ASSERT(this != NULL);
113026 0 : return "SgUpirBranchField";
113027 : }
113028 :
113029 : // DQ (11/26/2005): Support for visitor pattern mechanims
113030 : // (inferior to ROSE traversal mechanism, experimental).
113031 : void
113032 0 : SgUpirBranchField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
113033 : {
113034 0 : ROSE_ASSERT(this != NULL);
113035 0 : visitor.visit(this);
113036 0 : }
113037 :
113038 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
113039 0 : void SgUpirBranchField::accept (ROSE_VisitorPattern & visitor) {
113040 0 : ROSE_ASSERT(this != NULL);
113041 0 : visitor.visit(this);
113042 0 : }
113043 :
113044 : SgUpirBranchField*
113045 0 : SgUpirBranchField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
113046 : {
113047 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
113048 : // This function is currently only supported for the AST used the represent Binary executables.
113049 : if (0 /* isSgAsmNode(this) != NULL */)
113050 : {
113051 : // Support for regex specification.
113052 : std::string prefixCode = "REGEX:";
113053 : addNewAttribute(prefixCode + s,a);
113054 : }
113055 : #endif
113056 :
113057 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
113058 0 : return this;
113059 : }
113060 :
113061 : // *** COMMON CODE SECTION ENDS HERE ***
113062 :
113063 :
113064 : // End of memberFunctionString
113065 : // Start of memberFunctionString
113066 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
113067 :
113068 :
113069 : #if 0
113070 : //! Error checking support
113071 : /*! Verifies the following:
113072 : - working getVariant() member function
113073 : - calls base class's error() member function
113074 : Every class has one of these functions.
113075 : */
113076 : bool
113077 : SgUpirBranchField::error()
113078 : {
113079 : // Put error checking here
113080 :
113081 : ROSE_ASSERT (this != NULL);
113082 : if (getVariant() != UpirBranchFieldTag)
113083 : {
113084 : printf ("Error in SgUpirBranchField::error(): SgUpirBranchField object has a %s variant \n",
113085 : Cxx_GrammarTerminalNames[getVariant()].name);
113086 : // printf ("Error in SgUpirBranchField::error() \n");
113087 : ROSE_ABORT();
113088 : }
113089 :
113090 : ROSE_ASSERT (getVariant() == UpirBranchFieldTag);
113091 : return SgOmpClause::error();
113092 : }
113093 : #endif
113094 :
113095 :
113096 :
113097 : // End of memberFunctionString
113098 :
113099 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
113100 :
113101 0 : SgUpirBranchField* isSgUpirBranchField ( SgNode* inputDerivedClassPointer )
113102 : {
113103 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113104 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113105 : // So to fix this we return NULL directly when the input is NULL and avoid the
113106 : // dynamic_cast in this case. This is likely a performance improvement as well.
113107 : // return dynamic_cast<SgUpirBranchField*>(inputDerivedClassPointer);
113108 : // Milind Chabbi (8/28/2013): isSgUpirBranchField uses table-driven castability instead of c++ default dynamic_cast
113109 : // this improves the running time performance by 10-20%.
113110 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirBranchField*>(inputDerivedClassPointer);
113111 0 : return IS_SgUpirBranchField_FAST_MACRO(inputDerivedClassPointer);
113112 : }
113113 :
113114 : // DQ (11/8/2003): Added version of functions taking const pointer
113115 0 : const SgUpirBranchField* isSgUpirBranchField ( const SgNode* inputDerivedClassPointer )
113116 : {
113117 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113118 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113119 : // So to fix this we return NULL directly when the input is NULL and avoid the
113120 : // dynamic_cast in this case. This is likely a performance improvement as well.
113121 : // return dynamic_cast<const SgUpirBranchField*>(inputDerivedClassPointer);
113122 : // Milind Chabbi (8/28/2013): isSgUpirBranchField uses table-driven castability instead of c++ default dynamic_cast
113123 : // this improves the running time performance by 10-20%.
113124 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirBranchField*>(inputDerivedClassPointer);
113125 0 : return IS_SgUpirBranchField_FAST_MACRO(inputDerivedClassPointer);
113126 : }
113127 :
113128 :
113129 :
113130 : /* #line 113131 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113131 :
113132 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
113133 :
113134 : /**
113135 : \brief Generated destructor
113136 :
113137 : This destructor is automatically generated (by ROSETTA). This destructor
113138 : only frees memory of data members associated with the parts of the current IR node which
113139 : are NOT traversed. Those data members that are part of a traversal can be freed using
113140 : a traversal (calling this destructor on all children in a post-order traversal). Such
113141 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
113142 :
113143 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
113144 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
113145 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
113146 :
113147 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
113148 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
113149 : pointers are not yet implemented to call delete on eash pointer in the container.
113150 : (This could be done by derivation from the STL containers to define containers that
113151 : automatically deleted their members.)
113152 :
113153 : */
113154 0 : SgUpirBranchField::~SgUpirBranchField () {
113155 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
113156 :
113157 :
113158 :
113159 : }
113160 :
113161 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
113162 0 : }
113163 :
113164 :
113165 : /* #line 113166 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113166 :
113167 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
113168 :
113169 : // Generated constructor
113170 0 : SgUpirBranchField::SgUpirBranchField ( Sg_File_Info* startOfConstruct )
113171 0 : : SgOmpClause(startOfConstruct)
113172 : {
113173 : #ifdef DEBUG
113174 : // printf ("In SgUpirBranchField::SgUpirBranchField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
113175 : #endif
113176 : #if 0
113177 : // debugging information!
113178 : printf ("In SgUpirBranchField::SgUpirBranchField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
113179 : #endif
113180 :
113181 :
113182 :
113183 : #if 0
113184 : // DQ (7/30/2014): Call a virtual function.
113185 : std::string s = this->class_name();
113186 : #endif
113187 :
113188 : // Test the variant virtual function
113189 : // assert(UpirBranchFieldTag == variant());
113190 0 : assert(UpirBranchFieldTag == this->variant());
113191 0 : ROSE_ASSERT(UpirBranchFieldTag == (int)(this->variantT()));
113192 0 : post_construction_initialization();
113193 :
113194 : // Test the isSgUpirBranchField() function since it has been problematic
113195 0 : assert(isSgUpirBranchField(this) != NULL);
113196 0 : }
113197 :
113198 : // Generated constructor (all data members)
113199 :
113200 : /* #line 113201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113201 :
113202 :
113203 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
113204 :
113205 :
113206 : // ********************************************************
113207 : // member functions common across all array grammar objects
113208 : // ********************************************************
113209 :
113210 :
113211 :
113212 : /* #line 113213 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113213 :
113214 :
113215 :
113216 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
113217 :
113218 : // ********************************************************
113219 : // member functions specific to each node in the grammar
113220 : // ********************************************************
113221 :
113222 :
113223 : /* #line 113224 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113224 :
113225 : // Start of memberFunctionString
113226 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
113227 :
113228 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
113229 :
113230 : int
113231 0 : SgUpirNestedLevelField::get_nested_level () const
113232 : {
113233 0 : ROSE_ASSERT (this != NULL);
113234 :
113235 : #if 0
113236 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
113237 : // used to trigger marking transformations for the token-based unparsing.
113238 : printf ("SgUpirNestedLevelField::get_nested_level = %p = %s \n",this,this->class_name().c_str());
113239 : #endif
113240 :
113241 0 : return p_nested_level;
113242 : }
113243 :
113244 : void
113245 0 : SgUpirNestedLevelField::set_nested_level ( int nested_level )
113246 : {
113247 0 : ROSE_ASSERT (this != NULL);
113248 :
113249 : #if 0
113250 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
113251 : // used to trigger marking transformations for the token-based unparsing.
113252 : printf ("SgUpirNestedLevelField::set_nested_level = %p = %s \n",this,this->class_name().c_str());
113253 : #endif
113254 :
113255 0 : set_isModified(true);
113256 :
113257 0 : p_nested_level = nested_level;
113258 0 : }
113259 :
113260 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
113261 :
113262 :
113263 : // End of memberFunctionString
113264 : // Start of memberFunctionString
113265 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
113266 :
113267 : // *** COMMON CODE SECTION BEGINS HERE ***
113268 :
113269 : #if 0
113270 : int
113271 : SgUpirNestedLevelField::getVariant() const
113272 : {
113273 : // This function is used in ROSE while "variant()" is used in SAGE
113274 : assert(this != NULL);
113275 : return variant();
113276 : }
113277 : #endif
113278 :
113279 : // This function is used in ROSE in treeTraversal code
113280 : // eventually replaces getVariant() and variant()
113281 : // though after variant() has been removed for a while we will
113282 : // want to change the name of variantT() back to variant()
113283 : // (since the "T" was ment to stand for temporary).
113284 : // When this happens the variantT() will be depricated.
113285 : VariantT
113286 0 : SgUpirNestedLevelField::variantT() const
113287 : {
113288 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
113289 0 : ROSE_ASSERT(this != NULL);
113290 0 : return V_SgUpirNestedLevelField;
113291 : }
113292 :
113293 : #if 0
113294 : int
113295 : SgUpirNestedLevelField::variant() const
113296 : {
113297 : // This function is used in SAGE
113298 : ROSE_ASSERT(this != NULL);
113299 : return UpirNestedLevelFieldTag;
113300 : }
113301 : #endif
113302 :
113303 : ROSE_DLL_API const char*
113304 0 : SgUpirNestedLevelField::sage_class_name() const
113305 : {
113306 0 : ROSE_ASSERT(this != NULL);
113307 0 : return "SgUpirNestedLevelField";
113308 : }
113309 :
113310 : std::string
113311 0 : SgUpirNestedLevelField::class_name() const
113312 : {
113313 0 : ROSE_ASSERT(this != NULL);
113314 0 : return "SgUpirNestedLevelField";
113315 : }
113316 :
113317 : // DQ (11/26/2005): Support for visitor pattern mechanims
113318 : // (inferior to ROSE traversal mechanism, experimental).
113319 : void
113320 0 : SgUpirNestedLevelField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
113321 : {
113322 0 : ROSE_ASSERT(this != NULL);
113323 0 : visitor.visit(this);
113324 0 : }
113325 :
113326 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
113327 0 : void SgUpirNestedLevelField::accept (ROSE_VisitorPattern & visitor) {
113328 0 : ROSE_ASSERT(this != NULL);
113329 0 : visitor.visit(this);
113330 0 : }
113331 :
113332 : SgUpirNestedLevelField*
113333 0 : SgUpirNestedLevelField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
113334 : {
113335 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
113336 : // This function is currently only supported for the AST used the represent Binary executables.
113337 : if (0 /* isSgAsmNode(this) != NULL */)
113338 : {
113339 : // Support for regex specification.
113340 : std::string prefixCode = "REGEX:";
113341 : addNewAttribute(prefixCode + s,a);
113342 : }
113343 : #endif
113344 :
113345 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
113346 0 : return this;
113347 : }
113348 :
113349 : // *** COMMON CODE SECTION ENDS HERE ***
113350 :
113351 :
113352 : // End of memberFunctionString
113353 : // Start of memberFunctionString
113354 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
113355 :
113356 :
113357 : #if 0
113358 : //! Error checking support
113359 : /*! Verifies the following:
113360 : - working getVariant() member function
113361 : - calls base class's error() member function
113362 : Every class has one of these functions.
113363 : */
113364 : bool
113365 : SgUpirNestedLevelField::error()
113366 : {
113367 : // Put error checking here
113368 :
113369 : ROSE_ASSERT (this != NULL);
113370 : if (getVariant() != UpirNestedLevelFieldTag)
113371 : {
113372 : printf ("Error in SgUpirNestedLevelField::error(): SgUpirNestedLevelField object has a %s variant \n",
113373 : Cxx_GrammarTerminalNames[getVariant()].name);
113374 : // printf ("Error in SgUpirNestedLevelField::error() \n");
113375 : ROSE_ABORT();
113376 : }
113377 :
113378 : ROSE_ASSERT (getVariant() == UpirNestedLevelFieldTag);
113379 : return SgOmpClause::error();
113380 : }
113381 : #endif
113382 :
113383 :
113384 :
113385 : // End of memberFunctionString
113386 :
113387 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
113388 :
113389 0 : SgUpirNestedLevelField* isSgUpirNestedLevelField ( SgNode* inputDerivedClassPointer )
113390 : {
113391 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113392 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113393 : // So to fix this we return NULL directly when the input is NULL and avoid the
113394 : // dynamic_cast in this case. This is likely a performance improvement as well.
113395 : // return dynamic_cast<SgUpirNestedLevelField*>(inputDerivedClassPointer);
113396 : // Milind Chabbi (8/28/2013): isSgUpirNestedLevelField uses table-driven castability instead of c++ default dynamic_cast
113397 : // this improves the running time performance by 10-20%.
113398 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirNestedLevelField*>(inputDerivedClassPointer);
113399 0 : return IS_SgUpirNestedLevelField_FAST_MACRO(inputDerivedClassPointer);
113400 : }
113401 :
113402 : // DQ (11/8/2003): Added version of functions taking const pointer
113403 0 : const SgUpirNestedLevelField* isSgUpirNestedLevelField ( const SgNode* inputDerivedClassPointer )
113404 : {
113405 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113406 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113407 : // So to fix this we return NULL directly when the input is NULL and avoid the
113408 : // dynamic_cast in this case. This is likely a performance improvement as well.
113409 : // return dynamic_cast<const SgUpirNestedLevelField*>(inputDerivedClassPointer);
113410 : // Milind Chabbi (8/28/2013): isSgUpirNestedLevelField uses table-driven castability instead of c++ default dynamic_cast
113411 : // this improves the running time performance by 10-20%.
113412 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirNestedLevelField*>(inputDerivedClassPointer);
113413 0 : return IS_SgUpirNestedLevelField_FAST_MACRO(inputDerivedClassPointer);
113414 : }
113415 :
113416 :
113417 :
113418 : /* #line 113419 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113419 :
113420 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
113421 :
113422 : /**
113423 : \brief Generated destructor
113424 :
113425 : This destructor is automatically generated (by ROSETTA). This destructor
113426 : only frees memory of data members associated with the parts of the current IR node which
113427 : are NOT traversed. Those data members that are part of a traversal can be freed using
113428 : a traversal (calling this destructor on all children in a post-order traversal). Such
113429 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
113430 :
113431 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
113432 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
113433 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
113434 :
113435 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
113436 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
113437 : pointers are not yet implemented to call delete on eash pointer in the container.
113438 : (This could be done by derivation from the STL containers to define containers that
113439 : automatically deleted their members.)
113440 :
113441 : */
113442 0 : SgUpirNestedLevelField::~SgUpirNestedLevelField () {
113443 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
113444 :
113445 :
113446 : // case: not a listType for nested_level
113447 0 : p_nested_level = 0; // non list case
113448 :
113449 : }
113450 :
113451 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
113452 0 : }
113453 :
113454 :
113455 : /* #line 113456 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113456 :
113457 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
113458 :
113459 : // Generated constructor
113460 0 : SgUpirNestedLevelField::SgUpirNestedLevelField ( Sg_File_Info* startOfConstruct )
113461 0 : : SgOmpClause(startOfConstruct)
113462 : {
113463 : #ifdef DEBUG
113464 : // printf ("In SgUpirNestedLevelField::SgUpirNestedLevelField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
113465 : #endif
113466 : #if 0
113467 : // debugging information!
113468 : printf ("In SgUpirNestedLevelField::SgUpirNestedLevelField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
113469 : #endif
113470 :
113471 0 : p_nested_level = 0;
113472 :
113473 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
113474 :
113475 : #if 0
113476 : // DQ (7/30/2014): Call a virtual function.
113477 : std::string s = this->class_name();
113478 : #endif
113479 :
113480 : // Test the variant virtual function
113481 : // assert(UpirNestedLevelFieldTag == variant());
113482 0 : assert(UpirNestedLevelFieldTag == this->variant());
113483 0 : ROSE_ASSERT(UpirNestedLevelFieldTag == (int)(this->variantT()));
113484 0 : post_construction_initialization();
113485 :
113486 : // Test the isSgUpirNestedLevelField() function since it has been problematic
113487 0 : assert(isSgUpirNestedLevelField(this) != NULL);
113488 0 : }
113489 :
113490 : // Generated constructor (all data members)
113491 :
113492 : /* #line 113493 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113493 :
113494 :
113495 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
113496 :
113497 :
113498 : // ********************************************************
113499 : // member functions common across all array grammar objects
113500 : // ********************************************************
113501 :
113502 :
113503 :
113504 : /* #line 113505 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113505 :
113506 :
113507 :
113508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
113509 :
113510 : // ********************************************************
113511 : // member functions specific to each node in the grammar
113512 : // ********************************************************
113513 :
113514 :
113515 : /* #line 113516 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113516 :
113517 : // Start of memberFunctionString
113518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
113519 :
113520 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
113521 :
113522 : SgStatement*
113523 0 : SgUpirNestedParentField::get_nested_parent () const
113524 : {
113525 0 : ROSE_ASSERT (this != NULL);
113526 :
113527 : #if 0
113528 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
113529 : // used to trigger marking transformations for the token-based unparsing.
113530 : printf ("SgUpirNestedParentField::get_nested_parent = %p = %s \n",this,this->class_name().c_str());
113531 : #endif
113532 :
113533 0 : return p_nested_parent;
113534 : }
113535 :
113536 : void
113537 0 : SgUpirNestedParentField::set_nested_parent ( SgStatement* nested_parent )
113538 : {
113539 0 : ROSE_ASSERT (this != NULL);
113540 :
113541 : #if 0
113542 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
113543 : // used to trigger marking transformations for the token-based unparsing.
113544 : printf ("SgUpirNestedParentField::set_nested_parent = %p = %s \n",this,this->class_name().c_str());
113545 : #endif
113546 :
113547 0 : set_isModified(true);
113548 :
113549 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
113550 : if (p_nested_parent != NULL && nested_parent != NULL && p_nested_parent != nested_parent)
113551 : {
113552 : printf ("Warning: nested_parent = %p overwriting valid pointer p_nested_parent = %p \n",nested_parent,p_nested_parent);
113553 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
113554 : printf ("Error fails assertion (p_nested_parent != NULL && nested_parent != NULL && p_nested_parent != nested_parent) is false\n");
113555 : ROSE_ASSERT(false);
113556 : #endif
113557 : }
113558 : #endif
113559 0 : p_nested_parent = nested_parent;
113560 0 : }
113561 :
113562 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
113563 :
113564 :
113565 : // End of memberFunctionString
113566 : // Start of memberFunctionString
113567 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
113568 :
113569 : // *** COMMON CODE SECTION BEGINS HERE ***
113570 :
113571 : #if 0
113572 : int
113573 : SgUpirNestedParentField::getVariant() const
113574 : {
113575 : // This function is used in ROSE while "variant()" is used in SAGE
113576 : assert(this != NULL);
113577 : return variant();
113578 : }
113579 : #endif
113580 :
113581 : // This function is used in ROSE in treeTraversal code
113582 : // eventually replaces getVariant() and variant()
113583 : // though after variant() has been removed for a while we will
113584 : // want to change the name of variantT() back to variant()
113585 : // (since the "T" was ment to stand for temporary).
113586 : // When this happens the variantT() will be depricated.
113587 : VariantT
113588 0 : SgUpirNestedParentField::variantT() const
113589 : {
113590 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
113591 0 : ROSE_ASSERT(this != NULL);
113592 0 : return V_SgUpirNestedParentField;
113593 : }
113594 :
113595 : #if 0
113596 : int
113597 : SgUpirNestedParentField::variant() const
113598 : {
113599 : // This function is used in SAGE
113600 : ROSE_ASSERT(this != NULL);
113601 : return UpirNestedParentFieldTag;
113602 : }
113603 : #endif
113604 :
113605 : ROSE_DLL_API const char*
113606 0 : SgUpirNestedParentField::sage_class_name() const
113607 : {
113608 0 : ROSE_ASSERT(this != NULL);
113609 0 : return "SgUpirNestedParentField";
113610 : }
113611 :
113612 : std::string
113613 0 : SgUpirNestedParentField::class_name() const
113614 : {
113615 0 : ROSE_ASSERT(this != NULL);
113616 0 : return "SgUpirNestedParentField";
113617 : }
113618 :
113619 : // DQ (11/26/2005): Support for visitor pattern mechanims
113620 : // (inferior to ROSE traversal mechanism, experimental).
113621 : void
113622 0 : SgUpirNestedParentField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
113623 : {
113624 0 : ROSE_ASSERT(this != NULL);
113625 0 : visitor.visit(this);
113626 0 : }
113627 :
113628 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
113629 0 : void SgUpirNestedParentField::accept (ROSE_VisitorPattern & visitor) {
113630 0 : ROSE_ASSERT(this != NULL);
113631 0 : visitor.visit(this);
113632 0 : }
113633 :
113634 : SgUpirNestedParentField*
113635 0 : SgUpirNestedParentField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
113636 : {
113637 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
113638 : // This function is currently only supported for the AST used the represent Binary executables.
113639 : if (0 /* isSgAsmNode(this) != NULL */)
113640 : {
113641 : // Support for regex specification.
113642 : std::string prefixCode = "REGEX:";
113643 : addNewAttribute(prefixCode + s,a);
113644 : }
113645 : #endif
113646 :
113647 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
113648 0 : return this;
113649 : }
113650 :
113651 : // *** COMMON CODE SECTION ENDS HERE ***
113652 :
113653 :
113654 : // End of memberFunctionString
113655 : // Start of memberFunctionString
113656 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
113657 :
113658 :
113659 : #if 0
113660 : //! Error checking support
113661 : /*! Verifies the following:
113662 : - working getVariant() member function
113663 : - calls base class's error() member function
113664 : Every class has one of these functions.
113665 : */
113666 : bool
113667 : SgUpirNestedParentField::error()
113668 : {
113669 : // Put error checking here
113670 :
113671 : ROSE_ASSERT (this != NULL);
113672 : if (getVariant() != UpirNestedParentFieldTag)
113673 : {
113674 : printf ("Error in SgUpirNestedParentField::error(): SgUpirNestedParentField object has a %s variant \n",
113675 : Cxx_GrammarTerminalNames[getVariant()].name);
113676 : // printf ("Error in SgUpirNestedParentField::error() \n");
113677 : ROSE_ABORT();
113678 : }
113679 :
113680 : ROSE_ASSERT (getVariant() == UpirNestedParentFieldTag);
113681 : return SgOmpClause::error();
113682 : }
113683 : #endif
113684 :
113685 :
113686 :
113687 : // End of memberFunctionString
113688 :
113689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
113690 :
113691 0 : SgUpirNestedParentField* isSgUpirNestedParentField ( SgNode* inputDerivedClassPointer )
113692 : {
113693 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113694 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113695 : // So to fix this we return NULL directly when the input is NULL and avoid the
113696 : // dynamic_cast in this case. This is likely a performance improvement as well.
113697 : // return dynamic_cast<SgUpirNestedParentField*>(inputDerivedClassPointer);
113698 : // Milind Chabbi (8/28/2013): isSgUpirNestedParentField uses table-driven castability instead of c++ default dynamic_cast
113699 : // this improves the running time performance by 10-20%.
113700 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirNestedParentField*>(inputDerivedClassPointer);
113701 0 : return IS_SgUpirNestedParentField_FAST_MACRO(inputDerivedClassPointer);
113702 : }
113703 :
113704 : // DQ (11/8/2003): Added version of functions taking const pointer
113705 0 : const SgUpirNestedParentField* isSgUpirNestedParentField ( const SgNode* inputDerivedClassPointer )
113706 : {
113707 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113708 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113709 : // So to fix this we return NULL directly when the input is NULL and avoid the
113710 : // dynamic_cast in this case. This is likely a performance improvement as well.
113711 : // return dynamic_cast<const SgUpirNestedParentField*>(inputDerivedClassPointer);
113712 : // Milind Chabbi (8/28/2013): isSgUpirNestedParentField uses table-driven castability instead of c++ default dynamic_cast
113713 : // this improves the running time performance by 10-20%.
113714 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirNestedParentField*>(inputDerivedClassPointer);
113715 0 : return IS_SgUpirNestedParentField_FAST_MACRO(inputDerivedClassPointer);
113716 : }
113717 :
113718 :
113719 :
113720 : /* #line 113721 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113721 :
113722 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
113723 :
113724 : /**
113725 : \brief Generated destructor
113726 :
113727 : This destructor is automatically generated (by ROSETTA). This destructor
113728 : only frees memory of data members associated with the parts of the current IR node which
113729 : are NOT traversed. Those data members that are part of a traversal can be freed using
113730 : a traversal (calling this destructor on all children in a post-order traversal). Such
113731 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
113732 :
113733 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
113734 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
113735 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
113736 :
113737 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
113738 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
113739 : pointers are not yet implemented to call delete on eash pointer in the container.
113740 : (This could be done by derivation from the STL containers to define containers that
113741 : automatically deleted their members.)
113742 :
113743 : */
113744 0 : SgUpirNestedParentField::~SgUpirNestedParentField () {
113745 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
113746 :
113747 :
113748 : // case: not a listType for nested_parent
113749 0 : p_nested_parent = NULL; // non list case
113750 :
113751 : }
113752 :
113753 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
113754 0 : }
113755 :
113756 :
113757 : /* #line 113758 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113758 :
113759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
113760 :
113761 : // Generated constructor
113762 0 : SgUpirNestedParentField::SgUpirNestedParentField ( Sg_File_Info* startOfConstruct )
113763 0 : : SgOmpClause(startOfConstruct)
113764 : {
113765 : #ifdef DEBUG
113766 : // printf ("In SgUpirNestedParentField::SgUpirNestedParentField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
113767 : #endif
113768 : #if 0
113769 : // debugging information!
113770 : printf ("In SgUpirNestedParentField::SgUpirNestedParentField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
113771 : #endif
113772 :
113773 0 : p_nested_parent = NULL;
113774 :
113775 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
113776 :
113777 : #if 0
113778 : // DQ (7/30/2014): Call a virtual function.
113779 : std::string s = this->class_name();
113780 : #endif
113781 :
113782 : // Test the variant virtual function
113783 : // assert(UpirNestedParentFieldTag == variant());
113784 0 : assert(UpirNestedParentFieldTag == this->variant());
113785 0 : ROSE_ASSERT(UpirNestedParentFieldTag == (int)(this->variantT()));
113786 0 : post_construction_initialization();
113787 :
113788 : // Test the isSgUpirNestedParentField() function since it has been problematic
113789 0 : assert(isSgUpirNestedParentField(this) != NULL);
113790 0 : }
113791 :
113792 : // Generated constructor (all data members)
113793 :
113794 : /* #line 113795 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113795 :
113796 :
113797 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
113798 :
113799 :
113800 : // ********************************************************
113801 : // member functions common across all array grammar objects
113802 : // ********************************************************
113803 :
113804 :
113805 :
113806 : /* #line 113807 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113807 :
113808 :
113809 :
113810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
113811 :
113812 : // ********************************************************
113813 : // member functions specific to each node in the grammar
113814 : // ********************************************************
113815 :
113816 :
113817 : /* #line 113818 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
113818 :
113819 : // Start of memberFunctionString
113820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
113821 :
113822 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
113823 :
113824 : SgStatement*
113825 0 : SgUpirNestedChildField::get_nested_child () const
113826 : {
113827 0 : ROSE_ASSERT (this != NULL);
113828 :
113829 : #if 0
113830 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
113831 : // used to trigger marking transformations for the token-based unparsing.
113832 : printf ("SgUpirNestedChildField::get_nested_child = %p = %s \n",this,this->class_name().c_str());
113833 : #endif
113834 :
113835 0 : return p_nested_child;
113836 : }
113837 :
113838 : void
113839 0 : SgUpirNestedChildField::set_nested_child ( SgStatement* nested_child )
113840 : {
113841 0 : ROSE_ASSERT (this != NULL);
113842 :
113843 : #if 0
113844 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
113845 : // used to trigger marking transformations for the token-based unparsing.
113846 : printf ("SgUpirNestedChildField::set_nested_child = %p = %s \n",this,this->class_name().c_str());
113847 : #endif
113848 :
113849 0 : set_isModified(true);
113850 :
113851 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
113852 : if (p_nested_child != NULL && nested_child != NULL && p_nested_child != nested_child)
113853 : {
113854 : printf ("Warning: nested_child = %p overwriting valid pointer p_nested_child = %p \n",nested_child,p_nested_child);
113855 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
113856 : printf ("Error fails assertion (p_nested_child != NULL && nested_child != NULL && p_nested_child != nested_child) is false\n");
113857 : ROSE_ASSERT(false);
113858 : #endif
113859 : }
113860 : #endif
113861 0 : p_nested_child = nested_child;
113862 0 : }
113863 :
113864 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
113865 :
113866 :
113867 : // End of memberFunctionString
113868 : // Start of memberFunctionString
113869 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
113870 :
113871 : // *** COMMON CODE SECTION BEGINS HERE ***
113872 :
113873 : #if 0
113874 : int
113875 : SgUpirNestedChildField::getVariant() const
113876 : {
113877 : // This function is used in ROSE while "variant()" is used in SAGE
113878 : assert(this != NULL);
113879 : return variant();
113880 : }
113881 : #endif
113882 :
113883 : // This function is used in ROSE in treeTraversal code
113884 : // eventually replaces getVariant() and variant()
113885 : // though after variant() has been removed for a while we will
113886 : // want to change the name of variantT() back to variant()
113887 : // (since the "T" was ment to stand for temporary).
113888 : // When this happens the variantT() will be depricated.
113889 : VariantT
113890 0 : SgUpirNestedChildField::variantT() const
113891 : {
113892 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
113893 0 : ROSE_ASSERT(this != NULL);
113894 0 : return V_SgUpirNestedChildField;
113895 : }
113896 :
113897 : #if 0
113898 : int
113899 : SgUpirNestedChildField::variant() const
113900 : {
113901 : // This function is used in SAGE
113902 : ROSE_ASSERT(this != NULL);
113903 : return UpirNestedChildFieldTag;
113904 : }
113905 : #endif
113906 :
113907 : ROSE_DLL_API const char*
113908 0 : SgUpirNestedChildField::sage_class_name() const
113909 : {
113910 0 : ROSE_ASSERT(this != NULL);
113911 0 : return "SgUpirNestedChildField";
113912 : }
113913 :
113914 : std::string
113915 0 : SgUpirNestedChildField::class_name() const
113916 : {
113917 0 : ROSE_ASSERT(this != NULL);
113918 0 : return "SgUpirNestedChildField";
113919 : }
113920 :
113921 : // DQ (11/26/2005): Support for visitor pattern mechanims
113922 : // (inferior to ROSE traversal mechanism, experimental).
113923 : void
113924 0 : SgUpirNestedChildField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
113925 : {
113926 0 : ROSE_ASSERT(this != NULL);
113927 0 : visitor.visit(this);
113928 0 : }
113929 :
113930 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
113931 0 : void SgUpirNestedChildField::accept (ROSE_VisitorPattern & visitor) {
113932 0 : ROSE_ASSERT(this != NULL);
113933 0 : visitor.visit(this);
113934 0 : }
113935 :
113936 : SgUpirNestedChildField*
113937 0 : SgUpirNestedChildField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
113938 : {
113939 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
113940 : // This function is currently only supported for the AST used the represent Binary executables.
113941 : if (0 /* isSgAsmNode(this) != NULL */)
113942 : {
113943 : // Support for regex specification.
113944 : std::string prefixCode = "REGEX:";
113945 : addNewAttribute(prefixCode + s,a);
113946 : }
113947 : #endif
113948 :
113949 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
113950 0 : return this;
113951 : }
113952 :
113953 : // *** COMMON CODE SECTION ENDS HERE ***
113954 :
113955 :
113956 : // End of memberFunctionString
113957 : // Start of memberFunctionString
113958 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
113959 :
113960 :
113961 : #if 0
113962 : //! Error checking support
113963 : /*! Verifies the following:
113964 : - working getVariant() member function
113965 : - calls base class's error() member function
113966 : Every class has one of these functions.
113967 : */
113968 : bool
113969 : SgUpirNestedChildField::error()
113970 : {
113971 : // Put error checking here
113972 :
113973 : ROSE_ASSERT (this != NULL);
113974 : if (getVariant() != UpirNestedChildFieldTag)
113975 : {
113976 : printf ("Error in SgUpirNestedChildField::error(): SgUpirNestedChildField object has a %s variant \n",
113977 : Cxx_GrammarTerminalNames[getVariant()].name);
113978 : // printf ("Error in SgUpirNestedChildField::error() \n");
113979 : ROSE_ABORT();
113980 : }
113981 :
113982 : ROSE_ASSERT (getVariant() == UpirNestedChildFieldTag);
113983 : return SgOmpClause::error();
113984 : }
113985 : #endif
113986 :
113987 :
113988 :
113989 : // End of memberFunctionString
113990 :
113991 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
113992 :
113993 0 : SgUpirNestedChildField* isSgUpirNestedChildField ( SgNode* inputDerivedClassPointer )
113994 : {
113995 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
113996 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
113997 : // So to fix this we return NULL directly when the input is NULL and avoid the
113998 : // dynamic_cast in this case. This is likely a performance improvement as well.
113999 : // return dynamic_cast<SgUpirNestedChildField*>(inputDerivedClassPointer);
114000 : // Milind Chabbi (8/28/2013): isSgUpirNestedChildField uses table-driven castability instead of c++ default dynamic_cast
114001 : // this improves the running time performance by 10-20%.
114002 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirNestedChildField*>(inputDerivedClassPointer);
114003 0 : return IS_SgUpirNestedChildField_FAST_MACRO(inputDerivedClassPointer);
114004 : }
114005 :
114006 : // DQ (11/8/2003): Added version of functions taking const pointer
114007 0 : const SgUpirNestedChildField* isSgUpirNestedChildField ( const SgNode* inputDerivedClassPointer )
114008 : {
114009 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
114010 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
114011 : // So to fix this we return NULL directly when the input is NULL and avoid the
114012 : // dynamic_cast in this case. This is likely a performance improvement as well.
114013 : // return dynamic_cast<const SgUpirNestedChildField*>(inputDerivedClassPointer);
114014 : // Milind Chabbi (8/28/2013): isSgUpirNestedChildField uses table-driven castability instead of c++ default dynamic_cast
114015 : // this improves the running time performance by 10-20%.
114016 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirNestedChildField*>(inputDerivedClassPointer);
114017 0 : return IS_SgUpirNestedChildField_FAST_MACRO(inputDerivedClassPointer);
114018 : }
114019 :
114020 :
114021 :
114022 : /* #line 114023 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114023 :
114024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
114025 :
114026 : /**
114027 : \brief Generated destructor
114028 :
114029 : This destructor is automatically generated (by ROSETTA). This destructor
114030 : only frees memory of data members associated with the parts of the current IR node which
114031 : are NOT traversed. Those data members that are part of a traversal can be freed using
114032 : a traversal (calling this destructor on all children in a post-order traversal). Such
114033 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
114034 :
114035 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
114036 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
114037 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
114038 :
114039 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
114040 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
114041 : pointers are not yet implemented to call delete on eash pointer in the container.
114042 : (This could be done by derivation from the STL containers to define containers that
114043 : automatically deleted their members.)
114044 :
114045 : */
114046 0 : SgUpirNestedChildField::~SgUpirNestedChildField () {
114047 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
114048 :
114049 :
114050 : // case: not a listType for nested_child
114051 0 : p_nested_child = NULL; // non list case
114052 :
114053 : }
114054 :
114055 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
114056 0 : }
114057 :
114058 :
114059 : /* #line 114060 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114060 :
114061 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
114062 :
114063 : // Generated constructor
114064 0 : SgUpirNestedChildField::SgUpirNestedChildField ( Sg_File_Info* startOfConstruct )
114065 0 : : SgOmpClause(startOfConstruct)
114066 : {
114067 : #ifdef DEBUG
114068 : // printf ("In SgUpirNestedChildField::SgUpirNestedChildField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
114069 : #endif
114070 : #if 0
114071 : // debugging information!
114072 : printf ("In SgUpirNestedChildField::SgUpirNestedChildField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
114073 : #endif
114074 :
114075 0 : p_nested_child = NULL;
114076 :
114077 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
114078 :
114079 : #if 0
114080 : // DQ (7/30/2014): Call a virtual function.
114081 : std::string s = this->class_name();
114082 : #endif
114083 :
114084 : // Test the variant virtual function
114085 : // assert(UpirNestedChildFieldTag == variant());
114086 0 : assert(UpirNestedChildFieldTag == this->variant());
114087 0 : ROSE_ASSERT(UpirNestedChildFieldTag == (int)(this->variantT()));
114088 0 : post_construction_initialization();
114089 :
114090 : // Test the isSgUpirNestedChildField() function since it has been problematic
114091 0 : assert(isSgUpirNestedChildField(this) != NULL);
114092 0 : }
114093 :
114094 : // Generated constructor (all data members)
114095 :
114096 : /* #line 114097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114097 :
114098 :
114099 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
114100 :
114101 :
114102 : // ********************************************************
114103 : // member functions common across all array grammar objects
114104 : // ********************************************************
114105 :
114106 :
114107 :
114108 : /* #line 114109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114109 :
114110 :
114111 :
114112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
114113 :
114114 : // ********************************************************
114115 : // member functions specific to each node in the grammar
114116 : // ********************************************************
114117 :
114118 :
114119 : /* #line 114120 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114120 :
114121 : // Start of memberFunctionString
114122 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114123 :
114124 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114125 :
114126 : SgStatement*
114127 0 : SgUpirSyncField::get_sync () const
114128 : {
114129 0 : ROSE_ASSERT (this != NULL);
114130 :
114131 : #if 0
114132 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114133 : // used to trigger marking transformations for the token-based unparsing.
114134 : printf ("SgUpirSyncField::get_sync = %p = %s \n",this,this->class_name().c_str());
114135 : #endif
114136 :
114137 0 : return p_sync;
114138 : }
114139 :
114140 : void
114141 0 : SgUpirSyncField::set_sync ( SgStatement* sync )
114142 : {
114143 0 : ROSE_ASSERT (this != NULL);
114144 :
114145 : #if 0
114146 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114147 : // used to trigger marking transformations for the token-based unparsing.
114148 : printf ("SgUpirSyncField::set_sync = %p = %s \n",this,this->class_name().c_str());
114149 : #endif
114150 :
114151 0 : set_isModified(true);
114152 :
114153 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114154 : if (p_sync != NULL && sync != NULL && p_sync != sync)
114155 : {
114156 : printf ("Warning: sync = %p overwriting valid pointer p_sync = %p \n",sync,p_sync);
114157 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114158 : printf ("Error fails assertion (p_sync != NULL && sync != NULL && p_sync != sync) is false\n");
114159 : ROSE_ASSERT(false);
114160 : #endif
114161 : }
114162 : #endif
114163 0 : p_sync = sync;
114164 0 : }
114165 :
114166 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114167 :
114168 :
114169 : // End of memberFunctionString
114170 : // Start of memberFunctionString
114171 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
114172 :
114173 : // *** COMMON CODE SECTION BEGINS HERE ***
114174 :
114175 : #if 0
114176 : int
114177 : SgUpirSyncField::getVariant() const
114178 : {
114179 : // This function is used in ROSE while "variant()" is used in SAGE
114180 : assert(this != NULL);
114181 : return variant();
114182 : }
114183 : #endif
114184 :
114185 : // This function is used in ROSE in treeTraversal code
114186 : // eventually replaces getVariant() and variant()
114187 : // though after variant() has been removed for a while we will
114188 : // want to change the name of variantT() back to variant()
114189 : // (since the "T" was ment to stand for temporary).
114190 : // When this happens the variantT() will be depricated.
114191 : VariantT
114192 0 : SgUpirSyncField::variantT() const
114193 : {
114194 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
114195 0 : ROSE_ASSERT(this != NULL);
114196 0 : return V_SgUpirSyncField;
114197 : }
114198 :
114199 : #if 0
114200 : int
114201 : SgUpirSyncField::variant() const
114202 : {
114203 : // This function is used in SAGE
114204 : ROSE_ASSERT(this != NULL);
114205 : return UpirSyncFieldTag;
114206 : }
114207 : #endif
114208 :
114209 : ROSE_DLL_API const char*
114210 0 : SgUpirSyncField::sage_class_name() const
114211 : {
114212 0 : ROSE_ASSERT(this != NULL);
114213 0 : return "SgUpirSyncField";
114214 : }
114215 :
114216 : std::string
114217 0 : SgUpirSyncField::class_name() const
114218 : {
114219 0 : ROSE_ASSERT(this != NULL);
114220 0 : return "SgUpirSyncField";
114221 : }
114222 :
114223 : // DQ (11/26/2005): Support for visitor pattern mechanims
114224 : // (inferior to ROSE traversal mechanism, experimental).
114225 : void
114226 0 : SgUpirSyncField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
114227 : {
114228 0 : ROSE_ASSERT(this != NULL);
114229 0 : visitor.visit(this);
114230 0 : }
114231 :
114232 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
114233 0 : void SgUpirSyncField::accept (ROSE_VisitorPattern & visitor) {
114234 0 : ROSE_ASSERT(this != NULL);
114235 0 : visitor.visit(this);
114236 0 : }
114237 :
114238 : SgUpirSyncField*
114239 0 : SgUpirSyncField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
114240 : {
114241 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
114242 : // This function is currently only supported for the AST used the represent Binary executables.
114243 : if (0 /* isSgAsmNode(this) != NULL */)
114244 : {
114245 : // Support for regex specification.
114246 : std::string prefixCode = "REGEX:";
114247 : addNewAttribute(prefixCode + s,a);
114248 : }
114249 : #endif
114250 :
114251 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
114252 0 : return this;
114253 : }
114254 :
114255 : // *** COMMON CODE SECTION ENDS HERE ***
114256 :
114257 :
114258 : // End of memberFunctionString
114259 : // Start of memberFunctionString
114260 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
114261 :
114262 :
114263 : #if 0
114264 : //! Error checking support
114265 : /*! Verifies the following:
114266 : - working getVariant() member function
114267 : - calls base class's error() member function
114268 : Every class has one of these functions.
114269 : */
114270 : bool
114271 : SgUpirSyncField::error()
114272 : {
114273 : // Put error checking here
114274 :
114275 : ROSE_ASSERT (this != NULL);
114276 : if (getVariant() != UpirSyncFieldTag)
114277 : {
114278 : printf ("Error in SgUpirSyncField::error(): SgUpirSyncField object has a %s variant \n",
114279 : Cxx_GrammarTerminalNames[getVariant()].name);
114280 : // printf ("Error in SgUpirSyncField::error() \n");
114281 : ROSE_ABORT();
114282 : }
114283 :
114284 : ROSE_ASSERT (getVariant() == UpirSyncFieldTag);
114285 : return SgOmpClause::error();
114286 : }
114287 : #endif
114288 :
114289 :
114290 :
114291 : // End of memberFunctionString
114292 :
114293 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
114294 :
114295 0 : SgUpirSyncField* isSgUpirSyncField ( SgNode* inputDerivedClassPointer )
114296 : {
114297 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
114298 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
114299 : // So to fix this we return NULL directly when the input is NULL and avoid the
114300 : // dynamic_cast in this case. This is likely a performance improvement as well.
114301 : // return dynamic_cast<SgUpirSyncField*>(inputDerivedClassPointer);
114302 : // Milind Chabbi (8/28/2013): isSgUpirSyncField uses table-driven castability instead of c++ default dynamic_cast
114303 : // this improves the running time performance by 10-20%.
114304 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirSyncField*>(inputDerivedClassPointer);
114305 0 : return IS_SgUpirSyncField_FAST_MACRO(inputDerivedClassPointer);
114306 : }
114307 :
114308 : // DQ (11/8/2003): Added version of functions taking const pointer
114309 0 : const SgUpirSyncField* isSgUpirSyncField ( const SgNode* inputDerivedClassPointer )
114310 : {
114311 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
114312 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
114313 : // So to fix this we return NULL directly when the input is NULL and avoid the
114314 : // dynamic_cast in this case. This is likely a performance improvement as well.
114315 : // return dynamic_cast<const SgUpirSyncField*>(inputDerivedClassPointer);
114316 : // Milind Chabbi (8/28/2013): isSgUpirSyncField uses table-driven castability instead of c++ default dynamic_cast
114317 : // this improves the running time performance by 10-20%.
114318 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirSyncField*>(inputDerivedClassPointer);
114319 0 : return IS_SgUpirSyncField_FAST_MACRO(inputDerivedClassPointer);
114320 : }
114321 :
114322 :
114323 :
114324 : /* #line 114325 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114325 :
114326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
114327 :
114328 : /**
114329 : \brief Generated destructor
114330 :
114331 : This destructor is automatically generated (by ROSETTA). This destructor
114332 : only frees memory of data members associated with the parts of the current IR node which
114333 : are NOT traversed. Those data members that are part of a traversal can be freed using
114334 : a traversal (calling this destructor on all children in a post-order traversal). Such
114335 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
114336 :
114337 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
114338 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
114339 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
114340 :
114341 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
114342 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
114343 : pointers are not yet implemented to call delete on eash pointer in the container.
114344 : (This could be done by derivation from the STL containers to define containers that
114345 : automatically deleted their members.)
114346 :
114347 : */
114348 0 : SgUpirSyncField::~SgUpirSyncField () {
114349 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
114350 :
114351 :
114352 : // case: not a listType for sync
114353 0 : p_sync = NULL; // non list case
114354 :
114355 : }
114356 :
114357 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
114358 0 : }
114359 :
114360 :
114361 : /* #line 114362 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114362 :
114363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
114364 :
114365 : // Generated constructor
114366 0 : SgUpirSyncField::SgUpirSyncField ( Sg_File_Info* startOfConstruct )
114367 0 : : SgOmpClause(startOfConstruct)
114368 : {
114369 : #ifdef DEBUG
114370 : // printf ("In SgUpirSyncField::SgUpirSyncField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
114371 : #endif
114372 : #if 0
114373 : // debugging information!
114374 : printf ("In SgUpirSyncField::SgUpirSyncField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
114375 : #endif
114376 :
114377 0 : p_sync = NULL;
114378 :
114379 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
114380 :
114381 : #if 0
114382 : // DQ (7/30/2014): Call a virtual function.
114383 : std::string s = this->class_name();
114384 : #endif
114385 :
114386 : // Test the variant virtual function
114387 : // assert(UpirSyncFieldTag == variant());
114388 0 : assert(UpirSyncFieldTag == this->variant());
114389 0 : ROSE_ASSERT(UpirSyncFieldTag == (int)(this->variantT()));
114390 0 : post_construction_initialization();
114391 :
114392 : // Test the isSgUpirSyncField() function since it has been problematic
114393 0 : assert(isSgUpirSyncField(this) != NULL);
114394 0 : }
114395 :
114396 : // Generated constructor (all data members)
114397 :
114398 : /* #line 114399 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114399 :
114400 :
114401 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
114402 :
114403 :
114404 : // ********************************************************
114405 : // member functions common across all array grammar objects
114406 : // ********************************************************
114407 :
114408 :
114409 :
114410 : /* #line 114411 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114411 :
114412 :
114413 :
114414 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
114415 :
114416 : // ********************************************************
114417 : // member functions specific to each node in the grammar
114418 : // ********************************************************
114419 :
114420 :
114421 : /* #line 114422 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
114422 :
114423 : // Start of memberFunctionString
114424 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114425 :
114426 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114427 :
114428 : std::list<SgUpirDataItemField*>
114429 0 : SgUpirDataField::get_data () const
114430 : {
114431 0 : ROSE_ASSERT (this != NULL);
114432 :
114433 : #if 0
114434 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114435 : // used to trigger marking transformations for the token-based unparsing.
114436 : printf ("SgUpirDataField::get_data = %p = %s \n",this,this->class_name().c_str());
114437 : #endif
114438 :
114439 0 : return p_data;
114440 : }
114441 :
114442 : void
114443 0 : SgUpirDataField::set_data ( std::list<SgUpirDataItemField*> data )
114444 : {
114445 0 : ROSE_ASSERT (this != NULL);
114446 :
114447 : #if 0
114448 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114449 : // used to trigger marking transformations for the token-based unparsing.
114450 : printf ("SgUpirDataField::set_data = %p = %s \n",this,this->class_name().c_str());
114451 : #endif
114452 :
114453 0 : set_isModified(true);
114454 :
114455 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114456 : if (p_data != NULL && data != NULL && p_data != data)
114457 : {
114458 : printf ("Warning: data = %p overwriting valid pointer p_data = %p \n",data,p_data);
114459 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114460 : printf ("Error fails assertion (p_data != NULL && data != NULL && p_data != data) is false\n");
114461 : ROSE_ASSERT(false);
114462 : #endif
114463 : }
114464 : #endif
114465 0 : p_data = data;
114466 0 : }
114467 :
114468 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114469 :
114470 :
114471 : // End of memberFunctionString
114472 : // Start of memberFunctionString
114473 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114474 :
114475 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114476 :
114477 : std::list<SgUpirDataItemField*>
114478 0 : SgUpirDataField::get_shared_data () const
114479 : {
114480 0 : ROSE_ASSERT (this != NULL);
114481 :
114482 : #if 0
114483 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114484 : // used to trigger marking transformations for the token-based unparsing.
114485 : printf ("SgUpirDataField::get_shared_data = %p = %s \n",this,this->class_name().c_str());
114486 : #endif
114487 :
114488 0 : return p_shared_data;
114489 : }
114490 :
114491 : void
114492 0 : SgUpirDataField::set_shared_data ( std::list<SgUpirDataItemField*> shared_data )
114493 : {
114494 0 : ROSE_ASSERT (this != NULL);
114495 :
114496 : #if 0
114497 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114498 : // used to trigger marking transformations for the token-based unparsing.
114499 : printf ("SgUpirDataField::set_shared_data = %p = %s \n",this,this->class_name().c_str());
114500 : #endif
114501 :
114502 0 : set_isModified(true);
114503 :
114504 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114505 : if (p_shared_data != NULL && shared_data != NULL && p_shared_data != shared_data)
114506 : {
114507 : printf ("Warning: shared_data = %p overwriting valid pointer p_shared_data = %p \n",shared_data,p_shared_data);
114508 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114509 : printf ("Error fails assertion (p_shared_data != NULL && shared_data != NULL && p_shared_data != shared_data) is false\n");
114510 : ROSE_ASSERT(false);
114511 : #endif
114512 : }
114513 : #endif
114514 0 : p_shared_data = shared_data;
114515 0 : }
114516 :
114517 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114518 :
114519 :
114520 : // End of memberFunctionString
114521 : // Start of memberFunctionString
114522 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114523 :
114524 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114525 :
114526 : std::list<SgUpirDataItemField*>
114527 0 : SgUpirDataField::get_private_data () const
114528 : {
114529 0 : ROSE_ASSERT (this != NULL);
114530 :
114531 : #if 0
114532 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114533 : // used to trigger marking transformations for the token-based unparsing.
114534 : printf ("SgUpirDataField::get_private_data = %p = %s \n",this,this->class_name().c_str());
114535 : #endif
114536 :
114537 0 : return p_private_data;
114538 : }
114539 :
114540 : void
114541 0 : SgUpirDataField::set_private_data ( std::list<SgUpirDataItemField*> private_data )
114542 : {
114543 0 : ROSE_ASSERT (this != NULL);
114544 :
114545 : #if 0
114546 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114547 : // used to trigger marking transformations for the token-based unparsing.
114548 : printf ("SgUpirDataField::set_private_data = %p = %s \n",this,this->class_name().c_str());
114549 : #endif
114550 :
114551 0 : set_isModified(true);
114552 :
114553 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114554 : if (p_private_data != NULL && private_data != NULL && p_private_data != private_data)
114555 : {
114556 : printf ("Warning: private_data = %p overwriting valid pointer p_private_data = %p \n",private_data,p_private_data);
114557 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114558 : printf ("Error fails assertion (p_private_data != NULL && private_data != NULL && p_private_data != private_data) is false\n");
114559 : ROSE_ASSERT(false);
114560 : #endif
114561 : }
114562 : #endif
114563 0 : p_private_data = private_data;
114564 0 : }
114565 :
114566 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114567 :
114568 :
114569 : // End of memberFunctionString
114570 : // Start of memberFunctionString
114571 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114572 :
114573 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114574 :
114575 : std::list<SgUpirDataItemField*>
114576 0 : SgUpirDataField::get_firstprivate_data () const
114577 : {
114578 0 : ROSE_ASSERT (this != NULL);
114579 :
114580 : #if 0
114581 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114582 : // used to trigger marking transformations for the token-based unparsing.
114583 : printf ("SgUpirDataField::get_firstprivate_data = %p = %s \n",this,this->class_name().c_str());
114584 : #endif
114585 :
114586 0 : return p_firstprivate_data;
114587 : }
114588 :
114589 : void
114590 0 : SgUpirDataField::set_firstprivate_data ( std::list<SgUpirDataItemField*> firstprivate_data )
114591 : {
114592 0 : ROSE_ASSERT (this != NULL);
114593 :
114594 : #if 0
114595 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114596 : // used to trigger marking transformations for the token-based unparsing.
114597 : printf ("SgUpirDataField::set_firstprivate_data = %p = %s \n",this,this->class_name().c_str());
114598 : #endif
114599 :
114600 0 : set_isModified(true);
114601 :
114602 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114603 : if (p_firstprivate_data != NULL && firstprivate_data != NULL && p_firstprivate_data != firstprivate_data)
114604 : {
114605 : printf ("Warning: firstprivate_data = %p overwriting valid pointer p_firstprivate_data = %p \n",firstprivate_data,p_firstprivate_data);
114606 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114607 : printf ("Error fails assertion (p_firstprivate_data != NULL && firstprivate_data != NULL && p_firstprivate_data != firstprivate_data) is false\n");
114608 : ROSE_ASSERT(false);
114609 : #endif
114610 : }
114611 : #endif
114612 0 : p_firstprivate_data = firstprivate_data;
114613 0 : }
114614 :
114615 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114616 :
114617 :
114618 : // End of memberFunctionString
114619 : // Start of memberFunctionString
114620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114621 :
114622 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114623 :
114624 : std::list<SgUpirDataItemField*>
114625 0 : SgUpirDataField::get_lastprivate_data () const
114626 : {
114627 0 : ROSE_ASSERT (this != NULL);
114628 :
114629 : #if 0
114630 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114631 : // used to trigger marking transformations for the token-based unparsing.
114632 : printf ("SgUpirDataField::get_lastprivate_data = %p = %s \n",this,this->class_name().c_str());
114633 : #endif
114634 :
114635 0 : return p_lastprivate_data;
114636 : }
114637 :
114638 : void
114639 0 : SgUpirDataField::set_lastprivate_data ( std::list<SgUpirDataItemField*> lastprivate_data )
114640 : {
114641 0 : ROSE_ASSERT (this != NULL);
114642 :
114643 : #if 0
114644 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114645 : // used to trigger marking transformations for the token-based unparsing.
114646 : printf ("SgUpirDataField::set_lastprivate_data = %p = %s \n",this,this->class_name().c_str());
114647 : #endif
114648 :
114649 0 : set_isModified(true);
114650 :
114651 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114652 : if (p_lastprivate_data != NULL && lastprivate_data != NULL && p_lastprivate_data != lastprivate_data)
114653 : {
114654 : printf ("Warning: lastprivate_data = %p overwriting valid pointer p_lastprivate_data = %p \n",lastprivate_data,p_lastprivate_data);
114655 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114656 : printf ("Error fails assertion (p_lastprivate_data != NULL && lastprivate_data != NULL && p_lastprivate_data != lastprivate_data) is false\n");
114657 : ROSE_ASSERT(false);
114658 : #endif
114659 : }
114660 : #endif
114661 0 : p_lastprivate_data = lastprivate_data;
114662 0 : }
114663 :
114664 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114665 :
114666 :
114667 : // End of memberFunctionString
114668 : // Start of memberFunctionString
114669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114670 :
114671 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114672 :
114673 : std::list<SgUpirDataItemField*>
114674 0 : SgUpirDataField::get_reduction_data () const
114675 : {
114676 0 : ROSE_ASSERT (this != NULL);
114677 :
114678 : #if 0
114679 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114680 : // used to trigger marking transformations for the token-based unparsing.
114681 : printf ("SgUpirDataField::get_reduction_data = %p = %s \n",this,this->class_name().c_str());
114682 : #endif
114683 :
114684 0 : return p_reduction_data;
114685 : }
114686 :
114687 : void
114688 0 : SgUpirDataField::set_reduction_data ( std::list<SgUpirDataItemField*> reduction_data )
114689 : {
114690 0 : ROSE_ASSERT (this != NULL);
114691 :
114692 : #if 0
114693 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114694 : // used to trigger marking transformations for the token-based unparsing.
114695 : printf ("SgUpirDataField::set_reduction_data = %p = %s \n",this,this->class_name().c_str());
114696 : #endif
114697 :
114698 0 : set_isModified(true);
114699 :
114700 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114701 : if (p_reduction_data != NULL && reduction_data != NULL && p_reduction_data != reduction_data)
114702 : {
114703 : printf ("Warning: reduction_data = %p overwriting valid pointer p_reduction_data = %p \n",reduction_data,p_reduction_data);
114704 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114705 : printf ("Error fails assertion (p_reduction_data != NULL && reduction_data != NULL && p_reduction_data != reduction_data) is false\n");
114706 : ROSE_ASSERT(false);
114707 : #endif
114708 : }
114709 : #endif
114710 0 : p_reduction_data = reduction_data;
114711 0 : }
114712 :
114713 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114714 :
114715 :
114716 : // End of memberFunctionString
114717 : // Start of memberFunctionString
114718 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114719 :
114720 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114721 :
114722 : std::list<SgUpirDataItemField*>
114723 0 : SgUpirDataField::get_map_to_data () const
114724 : {
114725 0 : ROSE_ASSERT (this != NULL);
114726 :
114727 : #if 0
114728 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114729 : // used to trigger marking transformations for the token-based unparsing.
114730 : printf ("SgUpirDataField::get_map_to_data = %p = %s \n",this,this->class_name().c_str());
114731 : #endif
114732 :
114733 0 : return p_map_to_data;
114734 : }
114735 :
114736 : void
114737 0 : SgUpirDataField::set_map_to_data ( std::list<SgUpirDataItemField*> map_to_data )
114738 : {
114739 0 : ROSE_ASSERT (this != NULL);
114740 :
114741 : #if 0
114742 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114743 : // used to trigger marking transformations for the token-based unparsing.
114744 : printf ("SgUpirDataField::set_map_to_data = %p = %s \n",this,this->class_name().c_str());
114745 : #endif
114746 :
114747 0 : set_isModified(true);
114748 :
114749 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114750 : if (p_map_to_data != NULL && map_to_data != NULL && p_map_to_data != map_to_data)
114751 : {
114752 : printf ("Warning: map_to_data = %p overwriting valid pointer p_map_to_data = %p \n",map_to_data,p_map_to_data);
114753 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114754 : printf ("Error fails assertion (p_map_to_data != NULL && map_to_data != NULL && p_map_to_data != map_to_data) is false\n");
114755 : ROSE_ASSERT(false);
114756 : #endif
114757 : }
114758 : #endif
114759 0 : p_map_to_data = map_to_data;
114760 0 : }
114761 :
114762 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114763 :
114764 :
114765 : // End of memberFunctionString
114766 : // Start of memberFunctionString
114767 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114768 :
114769 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114770 :
114771 : std::list<SgUpirDataItemField*>
114772 0 : SgUpirDataField::get_map_from_data () const
114773 : {
114774 0 : ROSE_ASSERT (this != NULL);
114775 :
114776 : #if 0
114777 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114778 : // used to trigger marking transformations for the token-based unparsing.
114779 : printf ("SgUpirDataField::get_map_from_data = %p = %s \n",this,this->class_name().c_str());
114780 : #endif
114781 :
114782 0 : return p_map_from_data;
114783 : }
114784 :
114785 : void
114786 0 : SgUpirDataField::set_map_from_data ( std::list<SgUpirDataItemField*> map_from_data )
114787 : {
114788 0 : ROSE_ASSERT (this != NULL);
114789 :
114790 : #if 0
114791 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114792 : // used to trigger marking transformations for the token-based unparsing.
114793 : printf ("SgUpirDataField::set_map_from_data = %p = %s \n",this,this->class_name().c_str());
114794 : #endif
114795 :
114796 0 : set_isModified(true);
114797 :
114798 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114799 : if (p_map_from_data != NULL && map_from_data != NULL && p_map_from_data != map_from_data)
114800 : {
114801 : printf ("Warning: map_from_data = %p overwriting valid pointer p_map_from_data = %p \n",map_from_data,p_map_from_data);
114802 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114803 : printf ("Error fails assertion (p_map_from_data != NULL && map_from_data != NULL && p_map_from_data != map_from_data) is false\n");
114804 : ROSE_ASSERT(false);
114805 : #endif
114806 : }
114807 : #endif
114808 0 : p_map_from_data = map_from_data;
114809 0 : }
114810 :
114811 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114812 :
114813 :
114814 : // End of memberFunctionString
114815 : // Start of memberFunctionString
114816 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114817 :
114818 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114819 :
114820 : std::list<SgUpirDataItemField*>
114821 0 : SgUpirDataField::get_map_tofrom_data () const
114822 : {
114823 0 : ROSE_ASSERT (this != NULL);
114824 :
114825 : #if 0
114826 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114827 : // used to trigger marking transformations for the token-based unparsing.
114828 : printf ("SgUpirDataField::get_map_tofrom_data = %p = %s \n",this,this->class_name().c_str());
114829 : #endif
114830 :
114831 0 : return p_map_tofrom_data;
114832 : }
114833 :
114834 : void
114835 0 : SgUpirDataField::set_map_tofrom_data ( std::list<SgUpirDataItemField*> map_tofrom_data )
114836 : {
114837 0 : ROSE_ASSERT (this != NULL);
114838 :
114839 : #if 0
114840 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114841 : // used to trigger marking transformations for the token-based unparsing.
114842 : printf ("SgUpirDataField::set_map_tofrom_data = %p = %s \n",this,this->class_name().c_str());
114843 : #endif
114844 :
114845 0 : set_isModified(true);
114846 :
114847 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114848 : if (p_map_tofrom_data != NULL && map_tofrom_data != NULL && p_map_tofrom_data != map_tofrom_data)
114849 : {
114850 : printf ("Warning: map_tofrom_data = %p overwriting valid pointer p_map_tofrom_data = %p \n",map_tofrom_data,p_map_tofrom_data);
114851 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114852 : printf ("Error fails assertion (p_map_tofrom_data != NULL && map_tofrom_data != NULL && p_map_tofrom_data != map_tofrom_data) is false\n");
114853 : ROSE_ASSERT(false);
114854 : #endif
114855 : }
114856 : #endif
114857 0 : p_map_tofrom_data = map_tofrom_data;
114858 0 : }
114859 :
114860 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114861 :
114862 :
114863 : // End of memberFunctionString
114864 : // Start of memberFunctionString
114865 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
114866 :
114867 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
114868 :
114869 : std::list<SgUpirDataItemField*>
114870 0 : SgUpirDataField::get_map_alloc_data () const
114871 : {
114872 0 : ROSE_ASSERT (this != NULL);
114873 :
114874 : #if 0
114875 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114876 : // used to trigger marking transformations for the token-based unparsing.
114877 : printf ("SgUpirDataField::get_map_alloc_data = %p = %s \n",this,this->class_name().c_str());
114878 : #endif
114879 :
114880 0 : return p_map_alloc_data;
114881 : }
114882 :
114883 : void
114884 0 : SgUpirDataField::set_map_alloc_data ( std::list<SgUpirDataItemField*> map_alloc_data )
114885 : {
114886 0 : ROSE_ASSERT (this != NULL);
114887 :
114888 : #if 0
114889 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
114890 : // used to trigger marking transformations for the token-based unparsing.
114891 : printf ("SgUpirDataField::set_map_alloc_data = %p = %s \n",this,this->class_name().c_str());
114892 : #endif
114893 :
114894 0 : set_isModified(true);
114895 :
114896 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
114897 : if (p_map_alloc_data != NULL && map_alloc_data != NULL && p_map_alloc_data != map_alloc_data)
114898 : {
114899 : printf ("Warning: map_alloc_data = %p overwriting valid pointer p_map_alloc_data = %p \n",map_alloc_data,p_map_alloc_data);
114900 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
114901 : printf ("Error fails assertion (p_map_alloc_data != NULL && map_alloc_data != NULL && p_map_alloc_data != map_alloc_data) is false\n");
114902 : ROSE_ASSERT(false);
114903 : #endif
114904 : }
114905 : #endif
114906 0 : p_map_alloc_data = map_alloc_data;
114907 0 : }
114908 :
114909 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
114910 :
114911 :
114912 : // End of memberFunctionString
114913 : // Start of memberFunctionString
114914 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
114915 :
114916 : // *** COMMON CODE SECTION BEGINS HERE ***
114917 :
114918 : #if 0
114919 : int
114920 : SgUpirDataField::getVariant() const
114921 : {
114922 : // This function is used in ROSE while "variant()" is used in SAGE
114923 : assert(this != NULL);
114924 : return variant();
114925 : }
114926 : #endif
114927 :
114928 : // This function is used in ROSE in treeTraversal code
114929 : // eventually replaces getVariant() and variant()
114930 : // though after variant() has been removed for a while we will
114931 : // want to change the name of variantT() back to variant()
114932 : // (since the "T" was ment to stand for temporary).
114933 : // When this happens the variantT() will be depricated.
114934 : VariantT
114935 0 : SgUpirDataField::variantT() const
114936 : {
114937 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
114938 0 : ROSE_ASSERT(this != NULL);
114939 0 : return V_SgUpirDataField;
114940 : }
114941 :
114942 : #if 0
114943 : int
114944 : SgUpirDataField::variant() const
114945 : {
114946 : // This function is used in SAGE
114947 : ROSE_ASSERT(this != NULL);
114948 : return UpirDataFieldTag;
114949 : }
114950 : #endif
114951 :
114952 : ROSE_DLL_API const char*
114953 0 : SgUpirDataField::sage_class_name() const
114954 : {
114955 0 : ROSE_ASSERT(this != NULL);
114956 0 : return "SgUpirDataField";
114957 : }
114958 :
114959 : std::string
114960 0 : SgUpirDataField::class_name() const
114961 : {
114962 0 : ROSE_ASSERT(this != NULL);
114963 0 : return "SgUpirDataField";
114964 : }
114965 :
114966 : // DQ (11/26/2005): Support for visitor pattern mechanims
114967 : // (inferior to ROSE traversal mechanism, experimental).
114968 : void
114969 0 : SgUpirDataField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
114970 : {
114971 0 : ROSE_ASSERT(this != NULL);
114972 0 : visitor.visit(this);
114973 0 : }
114974 :
114975 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
114976 0 : void SgUpirDataField::accept (ROSE_VisitorPattern & visitor) {
114977 0 : ROSE_ASSERT(this != NULL);
114978 0 : visitor.visit(this);
114979 0 : }
114980 :
114981 : SgUpirDataField*
114982 0 : SgUpirDataField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
114983 : {
114984 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
114985 : // This function is currently only supported for the AST used the represent Binary executables.
114986 : if (0 /* isSgAsmNode(this) != NULL */)
114987 : {
114988 : // Support for regex specification.
114989 : std::string prefixCode = "REGEX:";
114990 : addNewAttribute(prefixCode + s,a);
114991 : }
114992 : #endif
114993 :
114994 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
114995 0 : return this;
114996 : }
114997 :
114998 : // *** COMMON CODE SECTION ENDS HERE ***
114999 :
115000 :
115001 : // End of memberFunctionString
115002 : // Start of memberFunctionString
115003 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
115004 :
115005 :
115006 : #if 0
115007 : //! Error checking support
115008 : /*! Verifies the following:
115009 : - working getVariant() member function
115010 : - calls base class's error() member function
115011 : Every class has one of these functions.
115012 : */
115013 : bool
115014 : SgUpirDataField::error()
115015 : {
115016 : // Put error checking here
115017 :
115018 : ROSE_ASSERT (this != NULL);
115019 : if (getVariant() != UpirDataFieldTag)
115020 : {
115021 : printf ("Error in SgUpirDataField::error(): SgUpirDataField object has a %s variant \n",
115022 : Cxx_GrammarTerminalNames[getVariant()].name);
115023 : // printf ("Error in SgUpirDataField::error() \n");
115024 : ROSE_ABORT();
115025 : }
115026 :
115027 : ROSE_ASSERT (getVariant() == UpirDataFieldTag);
115028 : return SgOmpClause::error();
115029 : }
115030 : #endif
115031 :
115032 :
115033 :
115034 : // End of memberFunctionString
115035 :
115036 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
115037 :
115038 0 : SgUpirDataField* isSgUpirDataField ( SgNode* inputDerivedClassPointer )
115039 : {
115040 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
115041 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
115042 : // So to fix this we return NULL directly when the input is NULL and avoid the
115043 : // dynamic_cast in this case. This is likely a performance improvement as well.
115044 : // return dynamic_cast<SgUpirDataField*>(inputDerivedClassPointer);
115045 : // Milind Chabbi (8/28/2013): isSgUpirDataField uses table-driven castability instead of c++ default dynamic_cast
115046 : // this improves the running time performance by 10-20%.
115047 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirDataField*>(inputDerivedClassPointer);
115048 0 : return IS_SgUpirDataField_FAST_MACRO(inputDerivedClassPointer);
115049 : }
115050 :
115051 : // DQ (11/8/2003): Added version of functions taking const pointer
115052 0 : const SgUpirDataField* isSgUpirDataField ( const SgNode* inputDerivedClassPointer )
115053 : {
115054 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
115055 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
115056 : // So to fix this we return NULL directly when the input is NULL and avoid the
115057 : // dynamic_cast in this case. This is likely a performance improvement as well.
115058 : // return dynamic_cast<const SgUpirDataField*>(inputDerivedClassPointer);
115059 : // Milind Chabbi (8/28/2013): isSgUpirDataField uses table-driven castability instead of c++ default dynamic_cast
115060 : // this improves the running time performance by 10-20%.
115061 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirDataField*>(inputDerivedClassPointer);
115062 0 : return IS_SgUpirDataField_FAST_MACRO(inputDerivedClassPointer);
115063 : }
115064 :
115065 :
115066 :
115067 : /* #line 115068 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115068 :
115069 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
115070 :
115071 : /**
115072 : \brief Generated destructor
115073 :
115074 : This destructor is automatically generated (by ROSETTA). This destructor
115075 : only frees memory of data members associated with the parts of the current IR node which
115076 : are NOT traversed. Those data members that are part of a traversal can be freed using
115077 : a traversal (calling this destructor on all children in a post-order traversal). Such
115078 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
115079 :
115080 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
115081 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
115082 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
115083 :
115084 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
115085 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
115086 : pointers are not yet implemented to call delete on eash pointer in the container.
115087 : (This could be done by derivation from the STL containers to define containers that
115088 : automatically deleted their members.)
115089 :
115090 : */
115091 0 : SgUpirDataField::~SgUpirDataField () {
115092 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
115093 :
115094 :
115095 :
115096 : }
115097 :
115098 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
115099 0 : }
115100 :
115101 :
115102 : /* #line 115103 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115103 :
115104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
115105 :
115106 : // Generated constructor
115107 0 : SgUpirDataField::SgUpirDataField ( Sg_File_Info* startOfConstruct )
115108 0 : : SgOmpClause(startOfConstruct)
115109 : {
115110 : #ifdef DEBUG
115111 : // printf ("In SgUpirDataField::SgUpirDataField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
115112 : #endif
115113 : #if 0
115114 : // debugging information!
115115 : printf ("In SgUpirDataField::SgUpirDataField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
115116 : #endif
115117 :
115118 :
115119 :
115120 : #if 0
115121 : // DQ (7/30/2014): Call a virtual function.
115122 : std::string s = this->class_name();
115123 : #endif
115124 :
115125 : // Test the variant virtual function
115126 : // assert(UpirDataFieldTag == variant());
115127 0 : assert(UpirDataFieldTag == this->variant());
115128 0 : ROSE_ASSERT(UpirDataFieldTag == (int)(this->variantT()));
115129 0 : post_construction_initialization();
115130 :
115131 : // Test the isSgUpirDataField() function since it has been problematic
115132 0 : assert(isSgUpirDataField(this) != NULL);
115133 0 : }
115134 :
115135 : // Generated constructor (all data members)
115136 :
115137 : /* #line 115138 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115138 :
115139 :
115140 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
115141 :
115142 :
115143 : // ********************************************************
115144 : // member functions common across all array grammar objects
115145 : // ********************************************************
115146 :
115147 :
115148 :
115149 : /* #line 115150 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115150 :
115151 :
115152 :
115153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
115154 :
115155 : // ********************************************************
115156 : // member functions specific to each node in the grammar
115157 : // ********************************************************
115158 :
115159 :
115160 : /* #line 115161 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115161 :
115162 : // Start of memberFunctionString
115163 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115164 :
115165 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115166 :
115167 : std::set<SgOmpClause::upir_target_type_enum>
115168 0 : SgUpirTargetField::get_target_type () const
115169 : {
115170 0 : ROSE_ASSERT (this != NULL);
115171 :
115172 : #if 0
115173 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115174 : // used to trigger marking transformations for the token-based unparsing.
115175 : printf ("SgUpirTargetField::get_target_type = %p = %s \n",this,this->class_name().c_str());
115176 : #endif
115177 :
115178 0 : return p_target_type;
115179 : }
115180 :
115181 : void
115182 0 : SgUpirTargetField::set_target_type ( std::set<SgOmpClause::upir_target_type_enum> target_type )
115183 : {
115184 0 : ROSE_ASSERT (this != NULL);
115185 :
115186 : #if 0
115187 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115188 : // used to trigger marking transformations for the token-based unparsing.
115189 : printf ("SgUpirTargetField::set_target_type = %p = %s \n",this,this->class_name().c_str());
115190 : #endif
115191 :
115192 0 : set_isModified(true);
115193 :
115194 0 : p_target_type = target_type;
115195 0 : }
115196 :
115197 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115198 :
115199 :
115200 : // End of memberFunctionString
115201 : // Start of memberFunctionString
115202 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
115203 :
115204 : // *** COMMON CODE SECTION BEGINS HERE ***
115205 :
115206 : #if 0
115207 : int
115208 : SgUpirTargetField::getVariant() const
115209 : {
115210 : // This function is used in ROSE while "variant()" is used in SAGE
115211 : assert(this != NULL);
115212 : return variant();
115213 : }
115214 : #endif
115215 :
115216 : // This function is used in ROSE in treeTraversal code
115217 : // eventually replaces getVariant() and variant()
115218 : // though after variant() has been removed for a while we will
115219 : // want to change the name of variantT() back to variant()
115220 : // (since the "T" was ment to stand for temporary).
115221 : // When this happens the variantT() will be depricated.
115222 : VariantT
115223 0 : SgUpirTargetField::variantT() const
115224 : {
115225 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
115226 0 : ROSE_ASSERT(this != NULL);
115227 0 : return V_SgUpirTargetField;
115228 : }
115229 :
115230 : #if 0
115231 : int
115232 : SgUpirTargetField::variant() const
115233 : {
115234 : // This function is used in SAGE
115235 : ROSE_ASSERT(this != NULL);
115236 : return UpirTargetFieldTag;
115237 : }
115238 : #endif
115239 :
115240 : ROSE_DLL_API const char*
115241 0 : SgUpirTargetField::sage_class_name() const
115242 : {
115243 0 : ROSE_ASSERT(this != NULL);
115244 0 : return "SgUpirTargetField";
115245 : }
115246 :
115247 : std::string
115248 0 : SgUpirTargetField::class_name() const
115249 : {
115250 0 : ROSE_ASSERT(this != NULL);
115251 0 : return "SgUpirTargetField";
115252 : }
115253 :
115254 : // DQ (11/26/2005): Support for visitor pattern mechanims
115255 : // (inferior to ROSE traversal mechanism, experimental).
115256 : void
115257 0 : SgUpirTargetField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
115258 : {
115259 0 : ROSE_ASSERT(this != NULL);
115260 0 : visitor.visit(this);
115261 0 : }
115262 :
115263 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
115264 0 : void SgUpirTargetField::accept (ROSE_VisitorPattern & visitor) {
115265 0 : ROSE_ASSERT(this != NULL);
115266 0 : visitor.visit(this);
115267 0 : }
115268 :
115269 : SgUpirTargetField*
115270 0 : SgUpirTargetField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
115271 : {
115272 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
115273 : // This function is currently only supported for the AST used the represent Binary executables.
115274 : if (0 /* isSgAsmNode(this) != NULL */)
115275 : {
115276 : // Support for regex specification.
115277 : std::string prefixCode = "REGEX:";
115278 : addNewAttribute(prefixCode + s,a);
115279 : }
115280 : #endif
115281 :
115282 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
115283 0 : return this;
115284 : }
115285 :
115286 : // *** COMMON CODE SECTION ENDS HERE ***
115287 :
115288 :
115289 : // End of memberFunctionString
115290 : // Start of memberFunctionString
115291 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
115292 :
115293 :
115294 : #if 0
115295 : //! Error checking support
115296 : /*! Verifies the following:
115297 : - working getVariant() member function
115298 : - calls base class's error() member function
115299 : Every class has one of these functions.
115300 : */
115301 : bool
115302 : SgUpirTargetField::error()
115303 : {
115304 : // Put error checking here
115305 :
115306 : ROSE_ASSERT (this != NULL);
115307 : if (getVariant() != UpirTargetFieldTag)
115308 : {
115309 : printf ("Error in SgUpirTargetField::error(): SgUpirTargetField object has a %s variant \n",
115310 : Cxx_GrammarTerminalNames[getVariant()].name);
115311 : // printf ("Error in SgUpirTargetField::error() \n");
115312 : ROSE_ABORT();
115313 : }
115314 :
115315 : ROSE_ASSERT (getVariant() == UpirTargetFieldTag);
115316 : return SgOmpClause::error();
115317 : }
115318 : #endif
115319 :
115320 :
115321 :
115322 : // End of memberFunctionString
115323 :
115324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
115325 :
115326 0 : SgUpirTargetField* isSgUpirTargetField ( SgNode* inputDerivedClassPointer )
115327 : {
115328 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
115329 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
115330 : // So to fix this we return NULL directly when the input is NULL and avoid the
115331 : // dynamic_cast in this case. This is likely a performance improvement as well.
115332 : // return dynamic_cast<SgUpirTargetField*>(inputDerivedClassPointer);
115333 : // Milind Chabbi (8/28/2013): isSgUpirTargetField uses table-driven castability instead of c++ default dynamic_cast
115334 : // this improves the running time performance by 10-20%.
115335 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirTargetField*>(inputDerivedClassPointer);
115336 0 : return IS_SgUpirTargetField_FAST_MACRO(inputDerivedClassPointer);
115337 : }
115338 :
115339 : // DQ (11/8/2003): Added version of functions taking const pointer
115340 0 : const SgUpirTargetField* isSgUpirTargetField ( const SgNode* inputDerivedClassPointer )
115341 : {
115342 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
115343 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
115344 : // So to fix this we return NULL directly when the input is NULL and avoid the
115345 : // dynamic_cast in this case. This is likely a performance improvement as well.
115346 : // return dynamic_cast<const SgUpirTargetField*>(inputDerivedClassPointer);
115347 : // Milind Chabbi (8/28/2013): isSgUpirTargetField uses table-driven castability instead of c++ default dynamic_cast
115348 : // this improves the running time performance by 10-20%.
115349 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirTargetField*>(inputDerivedClassPointer);
115350 0 : return IS_SgUpirTargetField_FAST_MACRO(inputDerivedClassPointer);
115351 : }
115352 :
115353 :
115354 :
115355 : /* #line 115356 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115356 :
115357 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
115358 :
115359 : /**
115360 : \brief Generated destructor
115361 :
115362 : This destructor is automatically generated (by ROSETTA). This destructor
115363 : only frees memory of data members associated with the parts of the current IR node which
115364 : are NOT traversed. Those data members that are part of a traversal can be freed using
115365 : a traversal (calling this destructor on all children in a post-order traversal). Such
115366 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
115367 :
115368 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
115369 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
115370 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
115371 :
115372 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
115373 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
115374 : pointers are not yet implemented to call delete on eash pointer in the container.
115375 : (This could be done by derivation from the STL containers to define containers that
115376 : automatically deleted their members.)
115377 :
115378 : */
115379 0 : SgUpirTargetField::~SgUpirTargetField () {
115380 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
115381 :
115382 :
115383 :
115384 : }
115385 :
115386 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
115387 0 : }
115388 :
115389 :
115390 : /* #line 115391 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115391 :
115392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
115393 :
115394 : // Generated constructor
115395 0 : SgUpirTargetField::SgUpirTargetField ( Sg_File_Info* startOfConstruct )
115396 0 : : SgOmpClause(startOfConstruct)
115397 : {
115398 : #ifdef DEBUG
115399 : // printf ("In SgUpirTargetField::SgUpirTargetField (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
115400 : #endif
115401 : #if 0
115402 : // debugging information!
115403 : printf ("In SgUpirTargetField::SgUpirTargetField (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
115404 : #endif
115405 :
115406 :
115407 :
115408 : #if 0
115409 : // DQ (7/30/2014): Call a virtual function.
115410 : std::string s = this->class_name();
115411 : #endif
115412 :
115413 : // Test the variant virtual function
115414 : // assert(UpirTargetFieldTag == variant());
115415 0 : assert(UpirTargetFieldTag == this->variant());
115416 0 : ROSE_ASSERT(UpirTargetFieldTag == (int)(this->variantT()));
115417 0 : post_construction_initialization();
115418 :
115419 : // Test the isSgUpirTargetField() function since it has been problematic
115420 0 : assert(isSgUpirTargetField(this) != NULL);
115421 0 : }
115422 :
115423 : // Generated constructor (all data members)
115424 :
115425 : /* #line 115426 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115426 :
115427 :
115428 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
115429 :
115430 :
115431 : // ********************************************************
115432 : // member functions common across all array grammar objects
115433 : // ********************************************************
115434 :
115435 :
115436 :
115437 : /* #line 115438 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115438 :
115439 :
115440 :
115441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
115442 :
115443 : // ********************************************************
115444 : // member functions specific to each node in the grammar
115445 : // ********************************************************
115446 :
115447 :
115448 : /* #line 115449 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
115449 :
115450 : // Start of memberFunctionString
115451 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115452 :
115453 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115454 :
115455 : SgSymbol*
115456 0 : SgUpirDataItemField::get_symbol () const
115457 : {
115458 0 : ROSE_ASSERT (this != NULL);
115459 :
115460 : #if 0
115461 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115462 : // used to trigger marking transformations for the token-based unparsing.
115463 : printf ("SgUpirDataItemField::get_symbol = %p = %s \n",this,this->class_name().c_str());
115464 : #endif
115465 :
115466 0 : return p_symbol;
115467 : }
115468 :
115469 : void
115470 0 : SgUpirDataItemField::set_symbol ( SgSymbol* symbol )
115471 : {
115472 0 : ROSE_ASSERT (this != NULL);
115473 :
115474 : #if 0
115475 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115476 : // used to trigger marking transformations for the token-based unparsing.
115477 : printf ("SgUpirDataItemField::set_symbol = %p = %s \n",this,this->class_name().c_str());
115478 : #endif
115479 :
115480 0 : set_isModified(true);
115481 :
115482 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
115483 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
115484 : {
115485 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
115486 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
115487 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
115488 : ROSE_ASSERT(false);
115489 : #endif
115490 : }
115491 : #endif
115492 0 : p_symbol = symbol;
115493 0 : }
115494 :
115495 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115496 :
115497 :
115498 : // End of memberFunctionString
115499 : // Start of memberFunctionString
115500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115501 :
115502 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115503 :
115504 : SgOmpClause::upir_data_sharing_enum
115505 0 : SgUpirDataItemField::get_sharing_property () const
115506 : {
115507 0 : ROSE_ASSERT (this != NULL);
115508 :
115509 : #if 0
115510 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115511 : // used to trigger marking transformations for the token-based unparsing.
115512 : printf ("SgUpirDataItemField::get_sharing_property = %p = %s \n",this,this->class_name().c_str());
115513 : #endif
115514 :
115515 0 : return p_sharing_property;
115516 : }
115517 :
115518 : void
115519 0 : SgUpirDataItemField::set_sharing_property ( SgOmpClause::upir_data_sharing_enum sharing_property )
115520 : {
115521 0 : ROSE_ASSERT (this != NULL);
115522 :
115523 : #if 0
115524 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115525 : // used to trigger marking transformations for the token-based unparsing.
115526 : printf ("SgUpirDataItemField::set_sharing_property = %p = %s \n",this,this->class_name().c_str());
115527 : #endif
115528 :
115529 0 : set_isModified(true);
115530 :
115531 0 : p_sharing_property = sharing_property;
115532 0 : }
115533 :
115534 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115535 :
115536 :
115537 : // End of memberFunctionString
115538 : // Start of memberFunctionString
115539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115540 :
115541 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115542 :
115543 : SgOmpClause::upir_property_visibility_enum
115544 0 : SgUpirDataItemField::get_sharing_visibility () const
115545 : {
115546 0 : ROSE_ASSERT (this != NULL);
115547 :
115548 : #if 0
115549 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115550 : // used to trigger marking transformations for the token-based unparsing.
115551 : printf ("SgUpirDataItemField::get_sharing_visibility = %p = %s \n",this,this->class_name().c_str());
115552 : #endif
115553 :
115554 0 : return p_sharing_visibility;
115555 : }
115556 :
115557 : void
115558 0 : SgUpirDataItemField::set_sharing_visibility ( SgOmpClause::upir_property_visibility_enum sharing_visibility )
115559 : {
115560 0 : ROSE_ASSERT (this != NULL);
115561 :
115562 : #if 0
115563 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115564 : // used to trigger marking transformations for the token-based unparsing.
115565 : printf ("SgUpirDataItemField::set_sharing_visibility = %p = %s \n",this,this->class_name().c_str());
115566 : #endif
115567 :
115568 0 : set_isModified(true);
115569 :
115570 0 : p_sharing_visibility = sharing_visibility;
115571 0 : }
115572 :
115573 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115574 :
115575 :
115576 : // End of memberFunctionString
115577 : // Start of memberFunctionString
115578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115579 :
115580 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115581 :
115582 : SgOmpClause::upir_data_mapping_enum
115583 0 : SgUpirDataItemField::get_mapping_property () const
115584 : {
115585 0 : ROSE_ASSERT (this != NULL);
115586 :
115587 : #if 0
115588 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115589 : // used to trigger marking transformations for the token-based unparsing.
115590 : printf ("SgUpirDataItemField::get_mapping_property = %p = %s \n",this,this->class_name().c_str());
115591 : #endif
115592 :
115593 0 : return p_mapping_property;
115594 : }
115595 :
115596 : void
115597 0 : SgUpirDataItemField::set_mapping_property ( SgOmpClause::upir_data_mapping_enum mapping_property )
115598 : {
115599 0 : ROSE_ASSERT (this != NULL);
115600 :
115601 : #if 0
115602 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115603 : // used to trigger marking transformations for the token-based unparsing.
115604 : printf ("SgUpirDataItemField::set_mapping_property = %p = %s \n",this,this->class_name().c_str());
115605 : #endif
115606 :
115607 0 : set_isModified(true);
115608 :
115609 0 : p_mapping_property = mapping_property;
115610 0 : }
115611 :
115612 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115613 :
115614 :
115615 : // End of memberFunctionString
115616 : // Start of memberFunctionString
115617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115618 :
115619 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115620 :
115621 : SgOmpClause::upir_property_visibility_enum
115622 0 : SgUpirDataItemField::get_mapping_visibility () const
115623 : {
115624 0 : ROSE_ASSERT (this != NULL);
115625 :
115626 : #if 0
115627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115628 : // used to trigger marking transformations for the token-based unparsing.
115629 : printf ("SgUpirDataItemField::get_mapping_visibility = %p = %s \n",this,this->class_name().c_str());
115630 : #endif
115631 :
115632 0 : return p_mapping_visibility;
115633 : }
115634 :
115635 : void
115636 0 : SgUpirDataItemField::set_mapping_visibility ( SgOmpClause::upir_property_visibility_enum mapping_visibility )
115637 : {
115638 0 : ROSE_ASSERT (this != NULL);
115639 :
115640 : #if 0
115641 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115642 : // used to trigger marking transformations for the token-based unparsing.
115643 : printf ("SgUpirDataItemField::set_mapping_visibility = %p = %s \n",this,this->class_name().c_str());
115644 : #endif
115645 :
115646 0 : set_isModified(true);
115647 :
115648 0 : p_mapping_visibility = mapping_visibility;
115649 0 : }
115650 :
115651 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115652 :
115653 :
115654 : // End of memberFunctionString
115655 : // Start of memberFunctionString
115656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115657 :
115658 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115659 :
115660 : SgExpression*
115661 0 : SgUpirDataItemField::get_mapper () const
115662 : {
115663 0 : ROSE_ASSERT (this != NULL);
115664 :
115665 : #if 0
115666 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115667 : // used to trigger marking transformations for the token-based unparsing.
115668 : printf ("SgUpirDataItemField::get_mapper = %p = %s \n",this,this->class_name().c_str());
115669 : #endif
115670 :
115671 0 : return p_mapper;
115672 : }
115673 :
115674 : void
115675 0 : SgUpirDataItemField::set_mapper ( SgExpression* mapper )
115676 : {
115677 0 : ROSE_ASSERT (this != NULL);
115678 :
115679 : #if 0
115680 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115681 : // used to trigger marking transformations for the token-based unparsing.
115682 : printf ("SgUpirDataItemField::set_mapper = %p = %s \n",this,this->class_name().c_str());
115683 : #endif
115684 :
115685 0 : set_isModified(true);
115686 :
115687 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
115688 : if (p_mapper != NULL && mapper != NULL && p_mapper != mapper)
115689 : {
115690 : printf ("Warning: mapper = %p overwriting valid pointer p_mapper = %p \n",mapper,p_mapper);
115691 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
115692 : printf ("Error fails assertion (p_mapper != NULL && mapper != NULL && p_mapper != mapper) is false\n");
115693 : ROSE_ASSERT(false);
115694 : #endif
115695 : }
115696 : #endif
115697 0 : p_mapper = mapper;
115698 0 : }
115699 :
115700 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115701 :
115702 :
115703 : // End of memberFunctionString
115704 : // Start of memberFunctionString
115705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115706 :
115707 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115708 :
115709 : SgOmpClause::upir_data_access_enum
115710 0 : SgUpirDataItemField::get_access_property () const
115711 : {
115712 0 : ROSE_ASSERT (this != NULL);
115713 :
115714 : #if 0
115715 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115716 : // used to trigger marking transformations for the token-based unparsing.
115717 : printf ("SgUpirDataItemField::get_access_property = %p = %s \n",this,this->class_name().c_str());
115718 : #endif
115719 :
115720 0 : return p_access_property;
115721 : }
115722 :
115723 : void
115724 0 : SgUpirDataItemField::set_access_property ( SgOmpClause::upir_data_access_enum access_property )
115725 : {
115726 0 : ROSE_ASSERT (this != NULL);
115727 :
115728 : #if 0
115729 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115730 : // used to trigger marking transformations for the token-based unparsing.
115731 : printf ("SgUpirDataItemField::set_access_property = %p = %s \n",this,this->class_name().c_str());
115732 : #endif
115733 :
115734 0 : set_isModified(true);
115735 :
115736 0 : p_access_property = access_property;
115737 0 : }
115738 :
115739 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115740 :
115741 :
115742 : // End of memberFunctionString
115743 : // Start of memberFunctionString
115744 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115745 :
115746 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115747 :
115748 : SgExpression*
115749 0 : SgUpirDataItemField::get_unit_id () const
115750 : {
115751 0 : ROSE_ASSERT (this != NULL);
115752 :
115753 : #if 0
115754 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115755 : // used to trigger marking transformations for the token-based unparsing.
115756 : printf ("SgUpirDataItemField::get_unit_id = %p = %s \n",this,this->class_name().c_str());
115757 : #endif
115758 :
115759 0 : return p_unit_id;
115760 : }
115761 :
115762 : void
115763 0 : SgUpirDataItemField::set_unit_id ( SgExpression* unit_id )
115764 : {
115765 0 : ROSE_ASSERT (this != NULL);
115766 :
115767 : #if 0
115768 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115769 : // used to trigger marking transformations for the token-based unparsing.
115770 : printf ("SgUpirDataItemField::set_unit_id = %p = %s \n",this,this->class_name().c_str());
115771 : #endif
115772 :
115773 0 : set_isModified(true);
115774 :
115775 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
115776 : if (p_unit_id != NULL && unit_id != NULL && p_unit_id != unit_id)
115777 : {
115778 : printf ("Warning: unit_id = %p overwriting valid pointer p_unit_id = %p \n",unit_id,p_unit_id);
115779 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
115780 : printf ("Error fails assertion (p_unit_id != NULL && unit_id != NULL && p_unit_id != unit_id) is false\n");
115781 : ROSE_ASSERT(false);
115782 : #endif
115783 : }
115784 : #endif
115785 0 : p_unit_id = unit_id;
115786 0 : }
115787 :
115788 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115789 :
115790 :
115791 : // End of memberFunctionString
115792 : // Start of memberFunctionString
115793 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115794 :
115795 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115796 :
115797 : SgOmpClause::upir_data_distribution_pattern_enum
115798 0 : SgUpirDataItemField::get_distribution_pattern () const
115799 : {
115800 0 : ROSE_ASSERT (this != NULL);
115801 :
115802 : #if 0
115803 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115804 : // used to trigger marking transformations for the token-based unparsing.
115805 : printf ("SgUpirDataItemField::get_distribution_pattern = %p = %s \n",this,this->class_name().c_str());
115806 : #endif
115807 :
115808 0 : return p_distribution_pattern;
115809 : }
115810 :
115811 : void
115812 0 : SgUpirDataItemField::set_distribution_pattern ( SgOmpClause::upir_data_distribution_pattern_enum distribution_pattern )
115813 : {
115814 0 : ROSE_ASSERT (this != NULL);
115815 :
115816 : #if 0
115817 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115818 : // used to trigger marking transformations for the token-based unparsing.
115819 : printf ("SgUpirDataItemField::set_distribution_pattern = %p = %s \n",this,this->class_name().c_str());
115820 : #endif
115821 :
115822 0 : set_isModified(true);
115823 :
115824 0 : p_distribution_pattern = distribution_pattern;
115825 0 : }
115826 :
115827 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115828 :
115829 :
115830 : // End of memberFunctionString
115831 : // Start of memberFunctionString
115832 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115833 :
115834 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115835 :
115836 : std::list<std::list<SgExpression*>>
115837 0 : SgUpirDataItemField::get_section () const
115838 : {
115839 0 : ROSE_ASSERT (this != NULL);
115840 :
115841 : #if 0
115842 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115843 : // used to trigger marking transformations for the token-based unparsing.
115844 : printf ("SgUpirDataItemField::get_section = %p = %s \n",this,this->class_name().c_str());
115845 : #endif
115846 :
115847 0 : return p_section;
115848 : }
115849 :
115850 : void
115851 0 : SgUpirDataItemField::set_section ( std::list<std::list<SgExpression*>> section )
115852 : {
115853 0 : ROSE_ASSERT (this != NULL);
115854 :
115855 : #if 0
115856 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115857 : // used to trigger marking transformations for the token-based unparsing.
115858 : printf ("SgUpirDataItemField::set_section = %p = %s \n",this,this->class_name().c_str());
115859 : #endif
115860 :
115861 0 : set_isModified(true);
115862 :
115863 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
115864 : if (p_section != NULL && section != NULL && p_section != section)
115865 : {
115866 : printf ("Warning: section = %p overwriting valid pointer p_section = %p \n",section,p_section);
115867 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
115868 : printf ("Error fails assertion (p_section != NULL && section != NULL && p_section != section) is false\n");
115869 : ROSE_ASSERT(false);
115870 : #endif
115871 : }
115872 : #endif
115873 0 : p_section = section;
115874 0 : }
115875 :
115876 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115877 :
115878 :
115879 : // End of memberFunctionString
115880 : // Start of memberFunctionString
115881 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115882 :
115883 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115884 :
115885 : SgOmpClause::upir_data_allocator_enum
115886 0 : SgUpirDataItemField::get_allocator () const
115887 : {
115888 0 : ROSE_ASSERT (this != NULL);
115889 :
115890 : #if 0
115891 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115892 : // used to trigger marking transformations for the token-based unparsing.
115893 : printf ("SgUpirDataItemField::get_allocator = %p = %s \n",this,this->class_name().c_str());
115894 : #endif
115895 :
115896 0 : return p_allocator;
115897 : }
115898 :
115899 : void
115900 0 : SgUpirDataItemField::set_allocator ( SgOmpClause::upir_data_allocator_enum allocator )
115901 : {
115902 0 : ROSE_ASSERT (this != NULL);
115903 :
115904 : #if 0
115905 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115906 : // used to trigger marking transformations for the token-based unparsing.
115907 : printf ("SgUpirDataItemField::set_allocator = %p = %s \n",this,this->class_name().c_str());
115908 : #endif
115909 :
115910 0 : set_isModified(true);
115911 :
115912 0 : p_allocator = allocator;
115913 0 : }
115914 :
115915 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115916 :
115917 :
115918 : // End of memberFunctionString
115919 : // Start of memberFunctionString
115920 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115921 :
115922 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115923 :
115924 : SgExpression*
115925 0 : SgUpirDataItemField::get_user_defined_allocator () const
115926 : {
115927 0 : ROSE_ASSERT (this != NULL);
115928 :
115929 : #if 0
115930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115931 : // used to trigger marking transformations for the token-based unparsing.
115932 : printf ("SgUpirDataItemField::get_user_defined_allocator = %p = %s \n",this,this->class_name().c_str());
115933 : #endif
115934 :
115935 0 : return p_user_defined_allocator;
115936 : }
115937 :
115938 : void
115939 0 : SgUpirDataItemField::set_user_defined_allocator ( SgExpression* user_defined_allocator )
115940 : {
115941 0 : ROSE_ASSERT (this != NULL);
115942 :
115943 : #if 0
115944 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115945 : // used to trigger marking transformations for the token-based unparsing.
115946 : printf ("SgUpirDataItemField::set_user_defined_allocator = %p = %s \n",this,this->class_name().c_str());
115947 : #endif
115948 :
115949 0 : set_isModified(true);
115950 :
115951 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
115952 : if (p_user_defined_allocator != NULL && user_defined_allocator != NULL && p_user_defined_allocator != user_defined_allocator)
115953 : {
115954 : printf ("Warning: user_defined_allocator = %p overwriting valid pointer p_user_defined_allocator = %p \n",user_defined_allocator,p_user_defined_allocator);
115955 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
115956 : printf ("Error fails assertion (p_user_defined_allocator != NULL && user_defined_allocator != NULL && p_user_defined_allocator != user_defined_allocator) is false\n");
115957 : ROSE_ASSERT(false);
115958 : #endif
115959 : }
115960 : #endif
115961 0 : p_user_defined_allocator = user_defined_allocator;
115962 0 : }
115963 :
115964 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
115965 :
115966 :
115967 : // End of memberFunctionString
115968 : // Start of memberFunctionString
115969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
115970 :
115971 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
115972 :
115973 : SgOmpClause::upir_data_deallocator_enum
115974 0 : SgUpirDataItemField::get_deallocator () const
115975 : {
115976 0 : ROSE_ASSERT (this != NULL);
115977 :
115978 : #if 0
115979 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115980 : // used to trigger marking transformations for the token-based unparsing.
115981 : printf ("SgUpirDataItemField::get_deallocator = %p = %s \n",this,this->class_name().c_str());
115982 : #endif
115983 :
115984 0 : return p_deallocator;
115985 : }
115986 :
115987 : void
115988 0 : SgUpirDataItemField::set_deallocator ( SgOmpClause::upir_data_deallocator_enum deallocator )
115989 : {
115990 0 : ROSE_ASSERT (this != NULL);
115991 :
115992 : #if 0
115993 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
115994 : // used to trigger marking transformations for the token-based unparsing.
115995 : printf ("SgUpirDataItemField::set_deallocator = %p = %s \n",this,this->class_name().c_str());
115996 : #endif
115997 :
115998 0 : set_isModified(true);
115999 :
116000 0 : p_deallocator = deallocator;
116001 0 : }
116002 :
116003 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116004 :
116005 :
116006 : // End of memberFunctionString
116007 : // Start of memberFunctionString
116008 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116009 :
116010 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116011 :
116012 : SgExpression*
116013 0 : SgUpirDataItemField::get_user_defined_deallocator () const
116014 : {
116015 0 : ROSE_ASSERT (this != NULL);
116016 :
116017 : #if 0
116018 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116019 : // used to trigger marking transformations for the token-based unparsing.
116020 : printf ("SgUpirDataItemField::get_user_defined_deallocator = %p = %s \n",this,this->class_name().c_str());
116021 : #endif
116022 :
116023 0 : return p_user_defined_deallocator;
116024 : }
116025 :
116026 : void
116027 0 : SgUpirDataItemField::set_user_defined_deallocator ( SgExpression* user_defined_deallocator )
116028 : {
116029 0 : ROSE_ASSERT (this != NULL);
116030 :
116031 : #if 0
116032 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116033 : // used to trigger marking transformations for the token-based unparsing.
116034 : printf ("SgUpirDataItemField::set_user_defined_deallocator = %p = %s \n",this,this->class_name().c_str());
116035 : #endif
116036 :
116037 0 : set_isModified(true);
116038 :
116039 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
116040 : if (p_user_defined_deallocator != NULL && user_defined_deallocator != NULL && p_user_defined_deallocator != user_defined_deallocator)
116041 : {
116042 : printf ("Warning: user_defined_deallocator = %p overwriting valid pointer p_user_defined_deallocator = %p \n",user_defined_deallocator,p_user_defined_deallocator);
116043 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
116044 : printf ("Error fails assertion (p_user_defined_deallocator != NULL && user_defined_deallocator != NULL && p_user_defined_deallocator != user_defined_deallocator) is false\n");
116045 : ROSE_ASSERT(false);
116046 : #endif
116047 : }
116048 : #endif
116049 0 : p_user_defined_deallocator = user_defined_deallocator;
116050 0 : }
116051 :
116052 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116053 :
116054 :
116055 : // End of memberFunctionString
116056 : // Start of memberFunctionString
116057 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116058 :
116059 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116060 :
116061 : SgExpression*
116062 0 : SgUpirDataItemField::get_memcpy_helper () const
116063 : {
116064 0 : ROSE_ASSERT (this != NULL);
116065 :
116066 : #if 0
116067 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116068 : // used to trigger marking transformations for the token-based unparsing.
116069 : printf ("SgUpirDataItemField::get_memcpy_helper = %p = %s \n",this,this->class_name().c_str());
116070 : #endif
116071 :
116072 0 : return p_memcpy_helper;
116073 : }
116074 :
116075 : void
116076 0 : SgUpirDataItemField::set_memcpy_helper ( SgExpression* memcpy_helper )
116077 : {
116078 0 : ROSE_ASSERT (this != NULL);
116079 :
116080 : #if 0
116081 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116082 : // used to trigger marking transformations for the token-based unparsing.
116083 : printf ("SgUpirDataItemField::set_memcpy_helper = %p = %s \n",this,this->class_name().c_str());
116084 : #endif
116085 :
116086 0 : set_isModified(true);
116087 :
116088 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
116089 : if (p_memcpy_helper != NULL && memcpy_helper != NULL && p_memcpy_helper != memcpy_helper)
116090 : {
116091 : printf ("Warning: memcpy_helper = %p overwriting valid pointer p_memcpy_helper = %p \n",memcpy_helper,p_memcpy_helper);
116092 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
116093 : printf ("Error fails assertion (p_memcpy_helper != NULL && memcpy_helper != NULL && p_memcpy_helper != memcpy_helper) is false\n");
116094 : ROSE_ASSERT(false);
116095 : #endif
116096 : }
116097 : #endif
116098 0 : p_memcpy_helper = memcpy_helper;
116099 0 : }
116100 :
116101 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116102 :
116103 :
116104 : // End of memberFunctionString
116105 : // Start of memberFunctionString
116106 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
116107 :
116108 : // *** COMMON CODE SECTION BEGINS HERE ***
116109 :
116110 : #if 0
116111 : int
116112 : SgUpirDataItemField::getVariant() const
116113 : {
116114 : // This function is used in ROSE while "variant()" is used in SAGE
116115 : assert(this != NULL);
116116 : return variant();
116117 : }
116118 : #endif
116119 :
116120 : // This function is used in ROSE in treeTraversal code
116121 : // eventually replaces getVariant() and variant()
116122 : // though after variant() has been removed for a while we will
116123 : // want to change the name of variantT() back to variant()
116124 : // (since the "T" was ment to stand for temporary).
116125 : // When this happens the variantT() will be depricated.
116126 : VariantT
116127 0 : SgUpirDataItemField::variantT() const
116128 : {
116129 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
116130 0 : ROSE_ASSERT(this != NULL);
116131 0 : return V_SgUpirDataItemField;
116132 : }
116133 :
116134 : #if 0
116135 : int
116136 : SgUpirDataItemField::variant() const
116137 : {
116138 : // This function is used in SAGE
116139 : ROSE_ASSERT(this != NULL);
116140 : return UpirDataItemFieldTag;
116141 : }
116142 : #endif
116143 :
116144 : ROSE_DLL_API const char*
116145 0 : SgUpirDataItemField::sage_class_name() const
116146 : {
116147 0 : ROSE_ASSERT(this != NULL);
116148 0 : return "SgUpirDataItemField";
116149 : }
116150 :
116151 : std::string
116152 0 : SgUpirDataItemField::class_name() const
116153 : {
116154 0 : ROSE_ASSERT(this != NULL);
116155 0 : return "SgUpirDataItemField";
116156 : }
116157 :
116158 : // DQ (11/26/2005): Support for visitor pattern mechanims
116159 : // (inferior to ROSE traversal mechanism, experimental).
116160 : void
116161 0 : SgUpirDataItemField::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
116162 : {
116163 0 : ROSE_ASSERT(this != NULL);
116164 0 : visitor.visit(this);
116165 0 : }
116166 :
116167 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
116168 0 : void SgUpirDataItemField::accept (ROSE_VisitorPattern & visitor) {
116169 0 : ROSE_ASSERT(this != NULL);
116170 0 : visitor.visit(this);
116171 0 : }
116172 :
116173 : SgUpirDataItemField*
116174 0 : SgUpirDataItemField::addRegExpAttribute(std::string s, AstRegExAttribute* a)
116175 : {
116176 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
116177 : // This function is currently only supported for the AST used the represent Binary executables.
116178 : if (0 /* isSgAsmNode(this) != NULL */)
116179 : {
116180 : // Support for regex specification.
116181 : std::string prefixCode = "REGEX:";
116182 : addNewAttribute(prefixCode + s,a);
116183 : }
116184 : #endif
116185 :
116186 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
116187 0 : return this;
116188 : }
116189 :
116190 : // *** COMMON CODE SECTION ENDS HERE ***
116191 :
116192 :
116193 : // End of memberFunctionString
116194 : // Start of memberFunctionString
116195 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
116196 :
116197 :
116198 : #if 0
116199 : //! Error checking support
116200 : /*! Verifies the following:
116201 : - working getVariant() member function
116202 : - calls base class's error() member function
116203 : Every class has one of these functions.
116204 : */
116205 : bool
116206 : SgUpirDataItemField::error()
116207 : {
116208 : // Put error checking here
116209 :
116210 : ROSE_ASSERT (this != NULL);
116211 : if (getVariant() != UpirDataItemFieldTag)
116212 : {
116213 : printf ("Error in SgUpirDataItemField::error(): SgUpirDataItemField object has a %s variant \n",
116214 : Cxx_GrammarTerminalNames[getVariant()].name);
116215 : // printf ("Error in SgUpirDataItemField::error() \n");
116216 : ROSE_ABORT();
116217 : }
116218 :
116219 : ROSE_ASSERT (getVariant() == UpirDataItemFieldTag);
116220 : return SgOmpClause::error();
116221 : }
116222 : #endif
116223 :
116224 :
116225 :
116226 : // End of memberFunctionString
116227 :
116228 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
116229 :
116230 0 : SgUpirDataItemField* isSgUpirDataItemField ( SgNode* inputDerivedClassPointer )
116231 : {
116232 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
116233 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
116234 : // So to fix this we return NULL directly when the input is NULL and avoid the
116235 : // dynamic_cast in this case. This is likely a performance improvement as well.
116236 : // return dynamic_cast<SgUpirDataItemField*>(inputDerivedClassPointer);
116237 : // Milind Chabbi (8/28/2013): isSgUpirDataItemField uses table-driven castability instead of c++ default dynamic_cast
116238 : // this improves the running time performance by 10-20%.
116239 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirDataItemField*>(inputDerivedClassPointer);
116240 0 : return IS_SgUpirDataItemField_FAST_MACRO(inputDerivedClassPointer);
116241 : }
116242 :
116243 : // DQ (11/8/2003): Added version of functions taking const pointer
116244 0 : const SgUpirDataItemField* isSgUpirDataItemField ( const SgNode* inputDerivedClassPointer )
116245 : {
116246 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
116247 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
116248 : // So to fix this we return NULL directly when the input is NULL and avoid the
116249 : // dynamic_cast in this case. This is likely a performance improvement as well.
116250 : // return dynamic_cast<const SgUpirDataItemField*>(inputDerivedClassPointer);
116251 : // Milind Chabbi (8/28/2013): isSgUpirDataItemField uses table-driven castability instead of c++ default dynamic_cast
116252 : // this improves the running time performance by 10-20%.
116253 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirDataItemField*>(inputDerivedClassPointer);
116254 0 : return IS_SgUpirDataItemField_FAST_MACRO(inputDerivedClassPointer);
116255 : }
116256 :
116257 :
116258 :
116259 : /* #line 116260 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116260 :
116261 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
116262 :
116263 : /**
116264 : \brief Generated destructor
116265 :
116266 : This destructor is automatically generated (by ROSETTA). This destructor
116267 : only frees memory of data members associated with the parts of the current IR node which
116268 : are NOT traversed. Those data members that are part of a traversal can be freed using
116269 : a traversal (calling this destructor on all children in a post-order traversal). Such
116270 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
116271 :
116272 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
116273 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
116274 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
116275 :
116276 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
116277 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
116278 : pointers are not yet implemented to call delete on eash pointer in the container.
116279 : (This could be done by derivation from the STL containers to define containers that
116280 : automatically deleted their members.)
116281 :
116282 : */
116283 0 : SgUpirDataItemField::~SgUpirDataItemField () {
116284 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
116285 :
116286 :
116287 : // case: not a listType for symbol
116288 0 : p_symbol = NULL; // non list case
116289 : // case: not a listType for sharing_property
116290 0 : p_sharing_property = e_upir_data_sharing_unspecified; // non list case
116291 : // case: not a listType for sharing_visibility
116292 0 : p_sharing_visibility = e_upir_property_visibility_unspecified; // non list case
116293 : // case: not a listType for mapping_property
116294 0 : p_mapping_property = e_upir_data_mapping_unspecified; // non list case
116295 : // case: not a listType for mapping_visibility
116296 0 : p_mapping_visibility = e_upir_property_visibility_unspecified; // non list case
116297 : // case: not a listType for mapper
116298 0 : p_mapper = NULL; // non list case
116299 : // case: not a listType for access_property
116300 0 : p_access_property = e_upir_data_access_unspecified; // non list case
116301 : // case: not a listType for unit_id
116302 0 : p_unit_id = NULL; // non list case
116303 : // case: not a listType for distribution_pattern
116304 0 : p_distribution_pattern = e_upir_data_distribution_pattern_unspecified; // non list case
116305 : // case: not a listType for allocator
116306 0 : p_allocator = e_upir_data_allocator_unspecified; // non list case
116307 : // case: not a listType for user_defined_allocator
116308 0 : p_user_defined_allocator = NULL; // non list case
116309 : // case: not a listType for deallocator
116310 0 : p_deallocator = e_upir_data_deallocator_unspecified; // non list case
116311 : // case: not a listType for user_defined_deallocator
116312 0 : p_user_defined_deallocator = NULL; // non list case
116313 : // case: not a listType for memcpy_helper
116314 0 : p_memcpy_helper = NULL; // non list case
116315 :
116316 : }
116317 :
116318 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
116319 0 : }
116320 :
116321 :
116322 : /* #line 116323 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116323 :
116324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
116325 :
116326 : // Generated constructor
116327 0 : SgUpirDataItemField::SgUpirDataItemField ( Sg_File_Info* startOfConstruct, SgSymbol* symbol )
116328 0 : : SgOmpClause(startOfConstruct)
116329 : {
116330 : #ifdef DEBUG
116331 : // printf ("In SgUpirDataItemField::SgUpirDataItemField (Sg_File_Info* startOfConstruct, SgSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
116332 : #endif
116333 : #if 0
116334 : // debugging information!
116335 : printf ("In SgUpirDataItemField::SgUpirDataItemField (Sg_File_Info* startOfConstruct, SgSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
116336 : #endif
116337 :
116338 0 : p_symbol = symbol;
116339 0 : p_sharing_property = e_upir_data_sharing_unspecified;
116340 0 : p_sharing_visibility = e_upir_property_visibility_unspecified;
116341 0 : p_mapping_property = e_upir_data_mapping_unspecified;
116342 0 : p_mapping_visibility = e_upir_property_visibility_unspecified;
116343 0 : p_mapper = NULL;
116344 0 : p_access_property = e_upir_data_access_unspecified;
116345 0 : p_unit_id = NULL;
116346 0 : p_distribution_pattern = e_upir_data_distribution_pattern_unspecified;
116347 0 : p_allocator = e_upir_data_allocator_unspecified;
116348 0 : p_user_defined_allocator = NULL;
116349 0 : p_deallocator = e_upir_data_deallocator_unspecified;
116350 0 : p_user_defined_deallocator = NULL;
116351 0 : p_memcpy_helper = NULL;
116352 :
116353 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
116354 :
116355 : #if 0
116356 : // DQ (7/30/2014): Call a virtual function.
116357 : std::string s = this->class_name();
116358 : #endif
116359 :
116360 : // Test the variant virtual function
116361 : // assert(UpirDataItemFieldTag == variant());
116362 0 : assert(UpirDataItemFieldTag == this->variant());
116363 0 : ROSE_ASSERT(UpirDataItemFieldTag == (int)(this->variantT()));
116364 0 : post_construction_initialization();
116365 :
116366 : // Test the isSgUpirDataItemField() function since it has been problematic
116367 0 : assert(isSgUpirDataItemField(this) != NULL);
116368 0 : }
116369 :
116370 : // Generated constructor (all data members)
116371 :
116372 : /* #line 116373 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116373 :
116374 :
116375 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
116376 :
116377 :
116378 : // ********************************************************
116379 : // member functions common across all array grammar objects
116380 : // ********************************************************
116381 :
116382 :
116383 :
116384 : /* #line 116385 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116385 :
116386 :
116387 :
116388 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
116389 :
116390 : // ********************************************************
116391 : // member functions specific to each node in the grammar
116392 : // ********************************************************
116393 :
116394 :
116395 : /* #line 116396 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116396 :
116397 : // Start of memberFunctionString
116398 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116399 :
116400 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116401 :
116402 : SgExpression*
116403 0 : SgLambdaCapture::get_capture_variable () const
116404 : {
116405 0 : ROSE_ASSERT (this != NULL);
116406 :
116407 : #if 0
116408 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116409 : // used to trigger marking transformations for the token-based unparsing.
116410 : printf ("SgLambdaCapture::get_capture_variable = %p = %s \n",this,this->class_name().c_str());
116411 : #endif
116412 :
116413 0 : return p_capture_variable;
116414 : }
116415 :
116416 : void
116417 0 : SgLambdaCapture::set_capture_variable ( SgExpression* capture_variable )
116418 : {
116419 0 : ROSE_ASSERT (this != NULL);
116420 :
116421 : #if 0
116422 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116423 : // used to trigger marking transformations for the token-based unparsing.
116424 : printf ("SgLambdaCapture::set_capture_variable = %p = %s \n",this,this->class_name().c_str());
116425 : #endif
116426 :
116427 0 : set_isModified(true);
116428 :
116429 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
116430 : if (p_capture_variable != NULL && capture_variable != NULL && p_capture_variable != capture_variable)
116431 : {
116432 : printf ("Warning: capture_variable = %p overwriting valid pointer p_capture_variable = %p \n",capture_variable,p_capture_variable);
116433 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
116434 : printf ("Error fails assertion (p_capture_variable != NULL && capture_variable != NULL && p_capture_variable != capture_variable) is false\n");
116435 : ROSE_ASSERT(false);
116436 : #endif
116437 : }
116438 : #endif
116439 0 : p_capture_variable = capture_variable;
116440 0 : }
116441 :
116442 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116443 :
116444 :
116445 : // End of memberFunctionString
116446 : // Start of memberFunctionString
116447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116448 :
116449 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116450 :
116451 : SgExpression*
116452 0 : SgLambdaCapture::get_source_closure_variable () const
116453 : {
116454 0 : ROSE_ASSERT (this != NULL);
116455 :
116456 : #if 0
116457 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116458 : // used to trigger marking transformations for the token-based unparsing.
116459 : printf ("SgLambdaCapture::get_source_closure_variable = %p = %s \n",this,this->class_name().c_str());
116460 : #endif
116461 :
116462 0 : return p_source_closure_variable;
116463 : }
116464 :
116465 : void
116466 0 : SgLambdaCapture::set_source_closure_variable ( SgExpression* source_closure_variable )
116467 : {
116468 0 : ROSE_ASSERT (this != NULL);
116469 :
116470 : #if 0
116471 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116472 : // used to trigger marking transformations for the token-based unparsing.
116473 : printf ("SgLambdaCapture::set_source_closure_variable = %p = %s \n",this,this->class_name().c_str());
116474 : #endif
116475 :
116476 0 : set_isModified(true);
116477 :
116478 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
116479 : if (p_source_closure_variable != NULL && source_closure_variable != NULL && p_source_closure_variable != source_closure_variable)
116480 : {
116481 : printf ("Warning: source_closure_variable = %p overwriting valid pointer p_source_closure_variable = %p \n",source_closure_variable,p_source_closure_variable);
116482 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
116483 : printf ("Error fails assertion (p_source_closure_variable != NULL && source_closure_variable != NULL && p_source_closure_variable != source_closure_variable) is false\n");
116484 : ROSE_ASSERT(false);
116485 : #endif
116486 : }
116487 : #endif
116488 0 : p_source_closure_variable = source_closure_variable;
116489 0 : }
116490 :
116491 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116492 :
116493 :
116494 : // End of memberFunctionString
116495 : // Start of memberFunctionString
116496 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116497 :
116498 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116499 :
116500 : SgExpression*
116501 0 : SgLambdaCapture::get_closure_variable () const
116502 : {
116503 0 : ROSE_ASSERT (this != NULL);
116504 :
116505 : #if 0
116506 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116507 : // used to trigger marking transformations for the token-based unparsing.
116508 : printf ("SgLambdaCapture::get_closure_variable = %p = %s \n",this,this->class_name().c_str());
116509 : #endif
116510 :
116511 0 : return p_closure_variable;
116512 : }
116513 :
116514 : void
116515 0 : SgLambdaCapture::set_closure_variable ( SgExpression* closure_variable )
116516 : {
116517 0 : ROSE_ASSERT (this != NULL);
116518 :
116519 : #if 0
116520 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116521 : // used to trigger marking transformations for the token-based unparsing.
116522 : printf ("SgLambdaCapture::set_closure_variable = %p = %s \n",this,this->class_name().c_str());
116523 : #endif
116524 :
116525 0 : set_isModified(true);
116526 :
116527 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
116528 : if (p_closure_variable != NULL && closure_variable != NULL && p_closure_variable != closure_variable)
116529 : {
116530 : printf ("Warning: closure_variable = %p overwriting valid pointer p_closure_variable = %p \n",closure_variable,p_closure_variable);
116531 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
116532 : printf ("Error fails assertion (p_closure_variable != NULL && closure_variable != NULL && p_closure_variable != closure_variable) is false\n");
116533 : ROSE_ASSERT(false);
116534 : #endif
116535 : }
116536 : #endif
116537 0 : p_closure_variable = closure_variable;
116538 0 : }
116539 :
116540 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116541 :
116542 :
116543 : // End of memberFunctionString
116544 : // Start of memberFunctionString
116545 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116546 :
116547 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116548 :
116549 : bool
116550 0 : SgLambdaCapture::get_capture_by_reference () const
116551 : {
116552 0 : ROSE_ASSERT (this != NULL);
116553 :
116554 : #if 0
116555 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116556 : // used to trigger marking transformations for the token-based unparsing.
116557 : printf ("SgLambdaCapture::get_capture_by_reference = %p = %s \n",this,this->class_name().c_str());
116558 : #endif
116559 :
116560 0 : return p_capture_by_reference;
116561 : }
116562 :
116563 : void
116564 0 : SgLambdaCapture::set_capture_by_reference ( bool capture_by_reference )
116565 : {
116566 0 : ROSE_ASSERT (this != NULL);
116567 :
116568 : #if 0
116569 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116570 : // used to trigger marking transformations for the token-based unparsing.
116571 : printf ("SgLambdaCapture::set_capture_by_reference = %p = %s \n",this,this->class_name().c_str());
116572 : #endif
116573 :
116574 0 : set_isModified(true);
116575 :
116576 0 : p_capture_by_reference = capture_by_reference;
116577 0 : }
116578 :
116579 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116580 :
116581 :
116582 : // End of memberFunctionString
116583 : // Start of memberFunctionString
116584 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116585 :
116586 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116587 :
116588 : bool
116589 0 : SgLambdaCapture::get_implicit () const
116590 : {
116591 0 : ROSE_ASSERT (this != NULL);
116592 :
116593 : #if 0
116594 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116595 : // used to trigger marking transformations for the token-based unparsing.
116596 : printf ("SgLambdaCapture::get_implicit = %p = %s \n",this,this->class_name().c_str());
116597 : #endif
116598 :
116599 0 : return p_implicit;
116600 : }
116601 :
116602 : void
116603 0 : SgLambdaCapture::set_implicit ( bool implicit )
116604 : {
116605 0 : ROSE_ASSERT (this != NULL);
116606 :
116607 : #if 0
116608 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116609 : // used to trigger marking transformations for the token-based unparsing.
116610 : printf ("SgLambdaCapture::set_implicit = %p = %s \n",this,this->class_name().c_str());
116611 : #endif
116612 :
116613 0 : set_isModified(true);
116614 :
116615 0 : p_implicit = implicit;
116616 0 : }
116617 :
116618 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116619 :
116620 :
116621 : // End of memberFunctionString
116622 : // Start of memberFunctionString
116623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
116624 :
116625 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116626 :
116627 : bool
116628 0 : SgLambdaCapture::get_pack_expansion () const
116629 : {
116630 0 : ROSE_ASSERT (this != NULL);
116631 :
116632 : #if 0
116633 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116634 : // used to trigger marking transformations for the token-based unparsing.
116635 : printf ("SgLambdaCapture::get_pack_expansion = %p = %s \n",this,this->class_name().c_str());
116636 : #endif
116637 :
116638 0 : return p_pack_expansion;
116639 : }
116640 :
116641 : void
116642 0 : SgLambdaCapture::set_pack_expansion ( bool pack_expansion )
116643 : {
116644 0 : ROSE_ASSERT (this != NULL);
116645 :
116646 : #if 0
116647 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
116648 : // used to trigger marking transformations for the token-based unparsing.
116649 : printf ("SgLambdaCapture::set_pack_expansion = %p = %s \n",this,this->class_name().c_str());
116650 : #endif
116651 :
116652 0 : set_isModified(true);
116653 :
116654 0 : p_pack_expansion = pack_expansion;
116655 0 : }
116656 :
116657 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116658 :
116659 :
116660 : // End of memberFunctionString
116661 : // Start of memberFunctionString
116662 : /* #line 1624 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
116663 :
116664 : // DQ (9/3/2014): Adding support for C++11 lambda expresions.
116665 :
116666 :
116667 : // End of memberFunctionString
116668 : // Start of memberFunctionString
116669 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
116670 :
116671 : // *** COMMON CODE SECTION BEGINS HERE ***
116672 :
116673 : #if 0
116674 : int
116675 : SgLambdaCapture::getVariant() const
116676 : {
116677 : // This function is used in ROSE while "variant()" is used in SAGE
116678 : assert(this != NULL);
116679 : return variant();
116680 : }
116681 : #endif
116682 :
116683 : // This function is used in ROSE in treeTraversal code
116684 : // eventually replaces getVariant() and variant()
116685 : // though after variant() has been removed for a while we will
116686 : // want to change the name of variantT() back to variant()
116687 : // (since the "T" was ment to stand for temporary).
116688 : // When this happens the variantT() will be depricated.
116689 : VariantT
116690 0 : SgLambdaCapture::variantT() const
116691 : {
116692 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
116693 0 : ROSE_ASSERT(this != NULL);
116694 0 : return V_SgLambdaCapture;
116695 : }
116696 :
116697 : #if 0
116698 : int
116699 : SgLambdaCapture::variant() const
116700 : {
116701 : // This function is used in SAGE
116702 : ROSE_ASSERT(this != NULL);
116703 : return LambdaCaptureTag;
116704 : }
116705 : #endif
116706 :
116707 : ROSE_DLL_API const char*
116708 0 : SgLambdaCapture::sage_class_name() const
116709 : {
116710 0 : ROSE_ASSERT(this != NULL);
116711 0 : return "SgLambdaCapture";
116712 : }
116713 :
116714 : std::string
116715 0 : SgLambdaCapture::class_name() const
116716 : {
116717 0 : ROSE_ASSERT(this != NULL);
116718 0 : return "SgLambdaCapture";
116719 : }
116720 :
116721 : // DQ (11/26/2005): Support for visitor pattern mechanims
116722 : // (inferior to ROSE traversal mechanism, experimental).
116723 : void
116724 0 : SgLambdaCapture::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
116725 : {
116726 0 : ROSE_ASSERT(this != NULL);
116727 0 : visitor.visit(this);
116728 0 : }
116729 :
116730 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
116731 0 : void SgLambdaCapture::accept (ROSE_VisitorPattern & visitor) {
116732 0 : ROSE_ASSERT(this != NULL);
116733 0 : visitor.visit(this);
116734 0 : }
116735 :
116736 : SgLambdaCapture*
116737 0 : SgLambdaCapture::addRegExpAttribute(std::string s, AstRegExAttribute* a)
116738 : {
116739 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
116740 : // This function is currently only supported for the AST used the represent Binary executables.
116741 : if (0 /* isSgAsmNode(this) != NULL */)
116742 : {
116743 : // Support for regex specification.
116744 : std::string prefixCode = "REGEX:";
116745 : addNewAttribute(prefixCode + s,a);
116746 : }
116747 : #endif
116748 :
116749 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
116750 0 : return this;
116751 : }
116752 :
116753 : // *** COMMON CODE SECTION ENDS HERE ***
116754 :
116755 :
116756 : // End of memberFunctionString
116757 : // Start of memberFunctionString
116758 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
116759 :
116760 :
116761 : #if 0
116762 : //! Error checking support
116763 : /*! Verifies the following:
116764 : - working getVariant() member function
116765 : - calls base class's error() member function
116766 : Every class has one of these functions.
116767 : */
116768 : bool
116769 : SgLambdaCapture::error()
116770 : {
116771 : // Put error checking here
116772 :
116773 : ROSE_ASSERT (this != NULL);
116774 : if (getVariant() != LambdaCaptureTag)
116775 : {
116776 : printf ("Error in SgLambdaCapture::error(): SgLambdaCapture object has a %s variant \n",
116777 : Cxx_GrammarTerminalNames[getVariant()].name);
116778 : // printf ("Error in SgLambdaCapture::error() \n");
116779 : ROSE_ABORT();
116780 : }
116781 :
116782 : ROSE_ASSERT (getVariant() == LambdaCaptureTag);
116783 : return SgLocatedNodeSupport::error();
116784 : }
116785 : #endif
116786 :
116787 :
116788 :
116789 : // End of memberFunctionString
116790 :
116791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
116792 :
116793 0 : SgLambdaCapture* isSgLambdaCapture ( SgNode* inputDerivedClassPointer )
116794 : {
116795 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
116796 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
116797 : // So to fix this we return NULL directly when the input is NULL and avoid the
116798 : // dynamic_cast in this case. This is likely a performance improvement as well.
116799 : // return dynamic_cast<SgLambdaCapture*>(inputDerivedClassPointer);
116800 : // Milind Chabbi (8/28/2013): isSgLambdaCapture uses table-driven castability instead of c++ default dynamic_cast
116801 : // this improves the running time performance by 10-20%.
116802 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLambdaCapture*>(inputDerivedClassPointer);
116803 0 : return IS_SgLambdaCapture_FAST_MACRO(inputDerivedClassPointer);
116804 : }
116805 :
116806 : // DQ (11/8/2003): Added version of functions taking const pointer
116807 0 : const SgLambdaCapture* isSgLambdaCapture ( const SgNode* inputDerivedClassPointer )
116808 : {
116809 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
116810 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
116811 : // So to fix this we return NULL directly when the input is NULL and avoid the
116812 : // dynamic_cast in this case. This is likely a performance improvement as well.
116813 : // return dynamic_cast<const SgLambdaCapture*>(inputDerivedClassPointer);
116814 : // Milind Chabbi (8/28/2013): isSgLambdaCapture uses table-driven castability instead of c++ default dynamic_cast
116815 : // this improves the running time performance by 10-20%.
116816 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLambdaCapture*>(inputDerivedClassPointer);
116817 0 : return IS_SgLambdaCapture_FAST_MACRO(inputDerivedClassPointer);
116818 : }
116819 :
116820 :
116821 :
116822 : /* #line 116823 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116823 :
116824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
116825 :
116826 : /**
116827 : \brief Generated destructor
116828 :
116829 : This destructor is automatically generated (by ROSETTA). This destructor
116830 : only frees memory of data members associated with the parts of the current IR node which
116831 : are NOT traversed. Those data members that are part of a traversal can be freed using
116832 : a traversal (calling this destructor on all children in a post-order traversal). Such
116833 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
116834 :
116835 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
116836 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
116837 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
116838 :
116839 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
116840 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
116841 : pointers are not yet implemented to call delete on eash pointer in the container.
116842 : (This could be done by derivation from the STL containers to define containers that
116843 : automatically deleted their members.)
116844 :
116845 : */
116846 0 : SgLambdaCapture::~SgLambdaCapture () {
116847 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
116848 :
116849 :
116850 : // case: not a listType for capture_variable
116851 0 : p_capture_variable = NULL; // non list case
116852 : // case: not a listType for source_closure_variable
116853 0 : p_source_closure_variable = NULL; // non list case
116854 : // case: not a listType for closure_variable
116855 0 : p_closure_variable = NULL; // non list case
116856 : // case: not a listType for capture_by_reference
116857 0 : p_capture_by_reference = false; // non list case
116858 : // case: not a listType for implicit
116859 0 : p_implicit = false; // non list case
116860 : // case: not a listType for pack_expansion
116861 0 : p_pack_expansion = false; // non list case
116862 :
116863 : }
116864 :
116865 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
116866 0 : }
116867 :
116868 :
116869 : /* #line 116870 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116870 :
116871 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
116872 :
116873 : // Generated constructor
116874 0 : SgLambdaCapture::SgLambdaCapture ( Sg_File_Info* startOfConstruct, SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable, bool capture_by_reference, bool implicit, bool pack_expansion )
116875 0 : : SgLocatedNodeSupport(startOfConstruct)
116876 : {
116877 : #ifdef DEBUG
116878 : // printf ("In SgLambdaCapture::SgLambdaCapture (Sg_File_Info* startOfConstruct, SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable, bool capture_by_reference, bool implicit, bool pack_expansion) sage_class_name() = %s \n",sage_class_name());
116879 : #endif
116880 : #if 0
116881 : // debugging information!
116882 : printf ("In SgLambdaCapture::SgLambdaCapture (Sg_File_Info* startOfConstruct, SgExpression* capture_variable, SgExpression* source_closure_variable, SgExpression* closure_variable, bool capture_by_reference, bool implicit, bool pack_expansion): this = %p = %s \n",this,this->class_name().c_str());
116883 : #endif
116884 :
116885 0 : p_capture_variable = capture_variable;
116886 0 : p_source_closure_variable = source_closure_variable;
116887 0 : p_closure_variable = closure_variable;
116888 0 : p_capture_by_reference = capture_by_reference;
116889 0 : p_implicit = implicit;
116890 0 : p_pack_expansion = pack_expansion;
116891 :
116892 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
116893 :
116894 : #if 0
116895 : // DQ (7/30/2014): Call a virtual function.
116896 : std::string s = this->class_name();
116897 : #endif
116898 :
116899 : // Test the variant virtual function
116900 : // assert(LambdaCaptureTag == variant());
116901 0 : assert(LambdaCaptureTag == this->variant());
116902 0 : ROSE_ASSERT(LambdaCaptureTag == (int)(this->variantT()));
116903 0 : post_construction_initialization();
116904 :
116905 : // Test the isSgLambdaCapture() function since it has been problematic
116906 0 : assert(isSgLambdaCapture(this) != NULL);
116907 0 : }
116908 :
116909 : // Generated constructor (all data members)
116910 :
116911 : /* #line 116912 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116912 :
116913 :
116914 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
116915 :
116916 :
116917 : // ********************************************************
116918 : // member functions common across all array grammar objects
116919 : // ********************************************************
116920 :
116921 :
116922 :
116923 : /* #line 116924 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116924 :
116925 :
116926 :
116927 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
116928 :
116929 : // ********************************************************
116930 : // member functions specific to each node in the grammar
116931 : // ********************************************************
116932 :
116933 :
116934 : /* #line 116935 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
116935 :
116936 : // Start of memberFunctionString
116937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
116938 :
116939 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
116940 :
116941 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
116942 : const SgLambdaCapturePtrList &
116943 0 : SgLambdaCaptureList::get_capture_list () const
116944 : {
116945 0 : assert (this != NULL);
116946 0 : return p_capture_list;
116947 : }
116948 :
116949 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
116950 : SgLambdaCapturePtrList &
116951 0 : SgLambdaCaptureList::get_capture_list ()
116952 : {
116953 0 : assert (this != NULL);
116954 :
116955 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
116956 : // As a rule only set_ access functions can set the isModified flag.
116957 : // set_isModified(true);
116958 :
116959 0 : return p_capture_list;
116960 : }
116961 :
116962 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
116963 :
116964 :
116965 : // End of memberFunctionString
116966 : // Start of memberFunctionString
116967 : /* #line 1629 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/LocatedNode.code" */
116968 :
116969 : // DQ (9/3/2014): Adding support for C++11 lambda expresions.
116970 :
116971 :
116972 : // End of memberFunctionString
116973 : // Start of memberFunctionString
116974 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
116975 :
116976 : // *** COMMON CODE SECTION BEGINS HERE ***
116977 :
116978 : #if 0
116979 : int
116980 : SgLambdaCaptureList::getVariant() const
116981 : {
116982 : // This function is used in ROSE while "variant()" is used in SAGE
116983 : assert(this != NULL);
116984 : return variant();
116985 : }
116986 : #endif
116987 :
116988 : // This function is used in ROSE in treeTraversal code
116989 : // eventually replaces getVariant() and variant()
116990 : // though after variant() has been removed for a while we will
116991 : // want to change the name of variantT() back to variant()
116992 : // (since the "T" was ment to stand for temporary).
116993 : // When this happens the variantT() will be depricated.
116994 : VariantT
116995 0 : SgLambdaCaptureList::variantT() const
116996 : {
116997 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
116998 0 : ROSE_ASSERT(this != NULL);
116999 0 : return V_SgLambdaCaptureList;
117000 : }
117001 :
117002 : #if 0
117003 : int
117004 : SgLambdaCaptureList::variant() const
117005 : {
117006 : // This function is used in SAGE
117007 : ROSE_ASSERT(this != NULL);
117008 : return LambdaCaptureListTag;
117009 : }
117010 : #endif
117011 :
117012 : ROSE_DLL_API const char*
117013 0 : SgLambdaCaptureList::sage_class_name() const
117014 : {
117015 0 : ROSE_ASSERT(this != NULL);
117016 0 : return "SgLambdaCaptureList";
117017 : }
117018 :
117019 : std::string
117020 0 : SgLambdaCaptureList::class_name() const
117021 : {
117022 0 : ROSE_ASSERT(this != NULL);
117023 0 : return "SgLambdaCaptureList";
117024 : }
117025 :
117026 : // DQ (11/26/2005): Support for visitor pattern mechanims
117027 : // (inferior to ROSE traversal mechanism, experimental).
117028 : void
117029 0 : SgLambdaCaptureList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
117030 : {
117031 0 : ROSE_ASSERT(this != NULL);
117032 0 : visitor.visit(this);
117033 0 : }
117034 :
117035 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
117036 0 : void SgLambdaCaptureList::accept (ROSE_VisitorPattern & visitor) {
117037 0 : ROSE_ASSERT(this != NULL);
117038 0 : visitor.visit(this);
117039 0 : }
117040 :
117041 : SgLambdaCaptureList*
117042 0 : SgLambdaCaptureList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
117043 : {
117044 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
117045 : // This function is currently only supported for the AST used the represent Binary executables.
117046 : if (0 /* isSgAsmNode(this) != NULL */)
117047 : {
117048 : // Support for regex specification.
117049 : std::string prefixCode = "REGEX:";
117050 : addNewAttribute(prefixCode + s,a);
117051 : }
117052 : #endif
117053 :
117054 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
117055 0 : return this;
117056 : }
117057 :
117058 : // *** COMMON CODE SECTION ENDS HERE ***
117059 :
117060 :
117061 : // End of memberFunctionString
117062 : // Start of memberFunctionString
117063 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
117064 :
117065 :
117066 : #if 0
117067 : //! Error checking support
117068 : /*! Verifies the following:
117069 : - working getVariant() member function
117070 : - calls base class's error() member function
117071 : Every class has one of these functions.
117072 : */
117073 : bool
117074 : SgLambdaCaptureList::error()
117075 : {
117076 : // Put error checking here
117077 :
117078 : ROSE_ASSERT (this != NULL);
117079 : if (getVariant() != LambdaCaptureListTag)
117080 : {
117081 : printf ("Error in SgLambdaCaptureList::error(): SgLambdaCaptureList object has a %s variant \n",
117082 : Cxx_GrammarTerminalNames[getVariant()].name);
117083 : // printf ("Error in SgLambdaCaptureList::error() \n");
117084 : ROSE_ABORT();
117085 : }
117086 :
117087 : ROSE_ASSERT (getVariant() == LambdaCaptureListTag);
117088 : return SgLocatedNodeSupport::error();
117089 : }
117090 : #endif
117091 :
117092 :
117093 :
117094 : // End of memberFunctionString
117095 :
117096 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
117097 :
117098 0 : SgLambdaCaptureList* isSgLambdaCaptureList ( SgNode* inputDerivedClassPointer )
117099 : {
117100 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
117101 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
117102 : // So to fix this we return NULL directly when the input is NULL and avoid the
117103 : // dynamic_cast in this case. This is likely a performance improvement as well.
117104 : // return dynamic_cast<SgLambdaCaptureList*>(inputDerivedClassPointer);
117105 : // Milind Chabbi (8/28/2013): isSgLambdaCaptureList uses table-driven castability instead of c++ default dynamic_cast
117106 : // this improves the running time performance by 10-20%.
117107 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLambdaCaptureList*>(inputDerivedClassPointer);
117108 0 : return IS_SgLambdaCaptureList_FAST_MACRO(inputDerivedClassPointer);
117109 : }
117110 :
117111 : // DQ (11/8/2003): Added version of functions taking const pointer
117112 0 : const SgLambdaCaptureList* isSgLambdaCaptureList ( const SgNode* inputDerivedClassPointer )
117113 : {
117114 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
117115 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
117116 : // So to fix this we return NULL directly when the input is NULL and avoid the
117117 : // dynamic_cast in this case. This is likely a performance improvement as well.
117118 : // return dynamic_cast<const SgLambdaCaptureList*>(inputDerivedClassPointer);
117119 : // Milind Chabbi (8/28/2013): isSgLambdaCaptureList uses table-driven castability instead of c++ default dynamic_cast
117120 : // this improves the running time performance by 10-20%.
117121 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLambdaCaptureList*>(inputDerivedClassPointer);
117122 0 : return IS_SgLambdaCaptureList_FAST_MACRO(inputDerivedClassPointer);
117123 : }
117124 :
117125 :
117126 :
117127 : /* #line 117128 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
117128 :
117129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
117130 :
117131 : /**
117132 : \brief Generated destructor
117133 :
117134 : This destructor is automatically generated (by ROSETTA). This destructor
117135 : only frees memory of data members associated with the parts of the current IR node which
117136 : are NOT traversed. Those data members that are part of a traversal can be freed using
117137 : a traversal (calling this destructor on all children in a post-order traversal). Such
117138 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
117139 :
117140 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
117141 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
117142 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
117143 :
117144 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
117145 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
117146 : pointers are not yet implemented to call delete on eash pointer in the container.
117147 : (This could be done by derivation from the STL containers to define containers that
117148 : automatically deleted their members.)
117149 :
117150 : */
117151 0 : SgLambdaCaptureList::~SgLambdaCaptureList () {
117152 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
117153 :
117154 :
117155 :
117156 : }
117157 :
117158 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
117159 0 : }
117160 :
117161 :
117162 : /* #line 117163 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
117163 :
117164 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
117165 :
117166 : // Generated constructor
117167 0 : SgLambdaCaptureList::SgLambdaCaptureList ( Sg_File_Info* startOfConstruct )
117168 0 : : SgLocatedNodeSupport(startOfConstruct)
117169 : {
117170 : #ifdef DEBUG
117171 : // printf ("In SgLambdaCaptureList::SgLambdaCaptureList (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
117172 : #endif
117173 : #if 0
117174 : // debugging information!
117175 : printf ("In SgLambdaCaptureList::SgLambdaCaptureList (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
117176 : #endif
117177 :
117178 :
117179 :
117180 : #if 0
117181 : // DQ (7/30/2014): Call a virtual function.
117182 : std::string s = this->class_name();
117183 : #endif
117184 :
117185 : // Test the variant virtual function
117186 : // assert(LambdaCaptureListTag == variant());
117187 0 : assert(LambdaCaptureListTag == this->variant());
117188 0 : ROSE_ASSERT(LambdaCaptureListTag == (int)(this->variantT()));
117189 0 : post_construction_initialization();
117190 :
117191 : // Test the isSgLambdaCaptureList() function since it has been problematic
117192 0 : assert(isSgLambdaCaptureList(this) != NULL);
117193 0 : }
117194 :
117195 : // Generated constructor (all data members)
117196 :
117197 : /* #line 117198 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
117198 :
117199 :
117200 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
117201 :
117202 :
117203 : // ********************************************************
117204 : // member functions common across all array grammar objects
117205 : // ********************************************************
117206 :
117207 :
117208 :
117209 : /* #line 117210 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
117210 :
117211 :
117212 :
117213 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
117214 :
117215 : // ********************************************************
117216 : // member functions specific to each node in the grammar
117217 : // ********************************************************
117218 :
117219 :
117220 : /* #line 117221 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
117221 :
117222 : // Start of memberFunctionString
117223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
117224 :
117225 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
117226 :
117227 : SgLabelRefExp*
117228 77797 : SgStatement::get_numeric_label () const
117229 : {
117230 77797 : ROSE_ASSERT (this != NULL);
117231 :
117232 : #if 0
117233 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
117234 : // used to trigger marking transformations for the token-based unparsing.
117235 : printf ("SgStatement::get_numeric_label = %p = %s \n",this,this->class_name().c_str());
117236 : #endif
117237 :
117238 77797 : return p_numeric_label;
117239 : }
117240 :
117241 : void
117242 7 : SgStatement::set_numeric_label ( SgLabelRefExp* numeric_label )
117243 : {
117244 7 : ROSE_ASSERT (this != NULL);
117245 :
117246 : #if 0
117247 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
117248 : // used to trigger marking transformations for the token-based unparsing.
117249 : printf ("SgStatement::set_numeric_label = %p = %s \n",this,this->class_name().c_str());
117250 : #endif
117251 :
117252 7 : set_isModified(true);
117253 :
117254 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
117255 : if (p_numeric_label != NULL && numeric_label != NULL && p_numeric_label != numeric_label)
117256 : {
117257 : printf ("Warning: numeric_label = %p overwriting valid pointer p_numeric_label = %p \n",numeric_label,p_numeric_label);
117258 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
117259 : printf ("Error fails assertion (p_numeric_label != NULL && numeric_label != NULL && p_numeric_label != numeric_label) is false\n");
117260 : ROSE_ASSERT(false);
117261 : #endif
117262 : }
117263 : #endif
117264 7 : p_numeric_label = numeric_label;
117265 7 : }
117266 :
117267 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
117268 :
117269 :
117270 : // End of memberFunctionString
117271 : // Start of memberFunctionString
117272 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
117273 :
117274 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
117275 :
117276 : int
117277 0 : SgStatement::get_source_sequence_value () const
117278 : {
117279 0 : ROSE_ASSERT (this != NULL);
117280 :
117281 : #if 0
117282 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
117283 : // used to trigger marking transformations for the token-based unparsing.
117284 : printf ("SgStatement::get_source_sequence_value = %p = %s \n",this,this->class_name().c_str());
117285 : #endif
117286 :
117287 0 : return p_source_sequence_value;
117288 : }
117289 :
117290 : void
117291 1348 : SgStatement::set_source_sequence_value ( int source_sequence_value )
117292 : {
117293 1348 : ROSE_ASSERT (this != NULL);
117294 :
117295 : #if 0
117296 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
117297 : // used to trigger marking transformations for the token-based unparsing.
117298 : printf ("SgStatement::set_source_sequence_value = %p = %s \n",this,this->class_name().c_str());
117299 : #endif
117300 :
117301 1348 : set_isModified(true);
117302 :
117303 1348 : p_source_sequence_value = source_sequence_value;
117304 1348 : }
117305 :
117306 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
117307 :
117308 :
117309 : // End of memberFunctionString
117310 : // Start of memberFunctionString
117311 : /* #line 3936 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
117312 :
117313 :
117314 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
117315 : SgSymbol*
117316 0 : SgStatement::get_symbol_from_symbol_table() const
117317 : {
117318 0 : printf ("Error: virtual function SgStatement::get_symbol_from_symbol_table() called on base class SgStatement = %p = %s \n",this,this->class_name().c_str());
117319 0 : ROSE_ASSERT(false);
117320 : // tps (12/9/2009) : MSC requires a return value
117321 : return NULL;
117322 : }
117323 :
117324 : void
117325 945 : SgStatement::remove_statement(SgStatement *target)
117326 : {
117327 945 : bool r = replace_child(target, 0);
117328 945 : assert(r);
117329 945 : }
117330 :
117331 : //! Insert newstmt before or after the target statement, which should be a child statement of this statement
117332 : void
117333 1279970 : SgStatement::insert_statement(SgStatement* target, SgStatement* newstmt, bool inFront)
117334 : {
117335 : #if 0
117336 : printf ("In SgStatement::insert_statement(): insert newstmt = %p = %s before/after target = %p = %s \n",newstmt,newstmt->class_name().c_str(),target,target->class_name().c_str());
117337 : #endif
117338 :
117339 1279970 : bool r = insert_child( target, newstmt, inFront, false);
117340 1279970 : assert(r);
117341 1279970 : }
117342 :
117343 : void
117344 0 : SgStatement::insert_statement(SgStatement* target, const SgStatementPtrList& newstmtList, bool inFront)
117345 : {
117346 : #if 0
117347 : printf ("In SgStatement::insert_statement(): insert newstmtList.size() = %" PRIuPTR " before/after target = %p = %s \n",newstmtList.size(),target,target->class_name().c_str());
117348 : #endif
117349 :
117350 0 : SgBasicBlock* tmp = new SgBasicBlock();
117351 0 : tmp->get_statements() = newstmtList;
117352 0 : bool r = insert_child( target, tmp, inFront, true);
117353 0 : assert(r);
117354 0 : }
117355 :
117356 : void
117357 1597 : SgStatement::replace_statement(SgStatement* target, SgStatement* newstmt)
117358 : {
117359 : // DQ (6/24/2006): Allow structurally oriented operations to set the parent (now that we store the scope explicitly this is OK).
117360 1597 : ROSE_ASSERT(newstmt != NULL);
117361 1597 : ROSE_ASSERT(target != NULL);
117362 1597 : ROSE_ASSERT(target->get_parent() != NULL);
117363 : // ROSE_ASSERT(target->get_parent() != newstmt);
117364 1597 : if (newstmt->get_parent() == NULL)
117365 1592 : newstmt->set_parent(target->get_parent());
117366 1597 : bool r = replace_child(target, newstmt, false);
117367 1597 : assert(r);
117368 1597 : }
117369 :
117370 : void
117371 0 : SgStatement::replace_statement(SgStatement* target, const SgStatementPtrList& newstmtList)
117372 : {
117373 0 : SgBasicBlock* tmp = new SgBasicBlock();
117374 0 : tmp->get_statements() = newstmtList;
117375 0 : bool r = replace_child( target, tmp, true);
117376 0 : assert(r);
117377 0 : }
117378 :
117379 : // if newstmt is a basicBlock, statements inside newstmt are extracted and then inserted
117380 : void
117381 0 : SgStatement::insert_statement_from_basicBlock(SgStatement* target, SgStatement* newstmt, bool inFront)
117382 : {
117383 : #if 0
117384 : printf ("In SgStatement::insert_statement_from_basicBlock(): insert newstmt = %p = %s before/after target = %p = %s \n",newstmt,newstmt->class_name().c_str(),target,target->class_name().c_str());
117385 : #endif
117386 :
117387 0 : bool r = insert_child( target, newstmt, inFront, true);
117388 0 : assert(r);
117389 0 : }
117390 :
117391 : void
117392 0 : SgStatement::replace_statement_from_basicBlock(SgStatement* target, SgStatement* newstmt)
117393 : {
117394 0 : bool r = replace_child( target, newstmt, true);
117395 0 : assert(r);
117396 0 : }
117397 :
117398 : void
117399 5127400 : SgStatement::post_construction_initialization()
117400 : {
117401 : #if 0
117402 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
117403 : printf ("In SgStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
117404 : #endif
117405 5127400 : }
117406 :
117407 : // DQ (12/5/2004): Support for setting scopes (only meaningful on IR statements that store the scope explicitly)
117408 : void
117409 0 : SgStatement::set_scope ( SgScopeStatement* newScope )
117410 : {
117411 0 : ROSE_ASSERT(this != NULL);
117412 0 : printf ("Warning: It is meaningless to set the scope in this %s IR node, the scope is not explicitly stored on this IR node! \n",class_name().c_str());
117413 0 : ROSE_ASSERT(false);
117414 : }
117415 :
117416 : bool
117417 1281570 : SgStatement::hasExplicitScope() const
117418 : {
117419 : // This function reports that this IR node (by default) does NOT store its scope explicitly.
117420 :
117421 1281570 : return false;
117422 : }
117423 :
117424 : void
117425 0 : SgStatement::setExtern()
117426 : {
117427 0 : ROSE_ASSERT(this != NULL);
117428 0 : printf ("Error: SgStatement::setExtern() is deprecated (it is now an error to call this) \n");
117429 0 : ROSE_ASSERT(false);
117430 : }
117431 :
117432 : void
117433 0 : SgStatement::setStatic()
117434 : {
117435 0 : ROSE_ASSERT(this != NULL);
117436 0 : printf ("Error: SgStatement::setStatic() is deprecated (it is now an error to call this) \n");
117437 0 : ROSE_ASSERT(false);
117438 : }
117439 :
117440 : #if 0
117441 : void
117442 : SgStatement::set_pragma()
117443 : {
117444 : // if(found_pragma_cnt)
117445 : // {
117446 : // add_pragma(found_pragma_cnt,found_pragma_list);
117447 : // found_pragma_cnt=0;
117448 : // }
117449 : }
117450 : #endif
117451 :
117452 : bool
117453 0 : SgStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractListFromBasicBlock)
117454 : {
117455 0 : printf ("SgStatement::replace_child(): ERROR: virtual function called in base class by mistake in %s (exiting at ...) \n",this->class_name().c_str());
117456 :
117457 : // DQ (6/15/2019): Output more information when this error occures.
117458 0 : ROSE_ASSERT(target != NULL);
117459 0 : printf (" --- target = %p = %s \n",target,target->class_name().c_str());
117460 0 : ROSE_ASSERT(newstmt != NULL);
117461 0 : printf (" --- newstmt = %p = %s \n",newstmt,newstmt->class_name().c_str());
117462 0 : printf (" --- extractListFromBasicBlock = %s \n",extractListFromBasicBlock ? "true" : "false");
117463 :
117464 0 : ROSE_ASSERT(newstmt->get_file_info() != NULL);
117465 0 : newstmt->get_file_info()->display("called from SgStatement::replace_child()");
117466 0 : ROSE_ASSERT(false);
117467 :
117468 : return false;
117469 : }
117470 :
117471 : bool
117472 0 : SgStatement::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractListFromBasicBlock)
117473 : {
117474 0 : printf ("SgStatement::insert_child(): ERROR: virtual function called in base class by mistake in %s (exiting at ...) \n",this->class_name().c_str());
117475 :
117476 : // DQ (6/15/2019): Output more information when this error occurs.
117477 0 : ROSE_ASSERT(target != NULL);
117478 0 : printf (" --- target = %p = %s \n",target,target->class_name().c_str());
117479 0 : SgNode* target_parent = target->get_parent();
117480 0 : printf (" --- target_parent = %p \n",target_parent);
117481 0 : if (target_parent != NULL)
117482 : {
117483 0 : printf (" --- target_parent = %p = %s \n",target_parent,target_parent->class_name().c_str());
117484 : }
117485 0 : ROSE_ASSERT(newstmt != NULL);
117486 0 : printf (" --- newstmt = %p = %s \n",newstmt,newstmt->class_name().c_str());
117487 0 : printf (" --- inFront = %s extractListFromBasicBlock = %s \n",inFront ? "true" : "false",extractListFromBasicBlock ? "true" : "false");
117488 :
117489 0 : ROSE_ASSERT(newstmt->get_file_info() != NULL);
117490 0 : newstmt->get_file_info()->display("called from SgStatement::insert_child()");
117491 0 : ROSE_ASSERT(false);
117492 :
117493 : return false;
117494 : }
117495 :
117496 :
117497 : // DQ (12/6/2006): We need this sort of function now that we have removed the expression root node!
117498 : // The requirement of not being able to do operations uniformly on expressions may be the disadvantage
117499 : // of not having used the SgExpressionRoot IR node as a concept.
117500 : int
117501 0 : SgStatement::replace_expression(SgExpression * original_expression, SgExpression * new_expression )
117502 : {
117503 0 : printf ("Error: base class of virtual SgStatement::replace_expression called by mistake for statement: %s \n",class_name().c_str());
117504 :
117505 : // DQ (6/15/2019): Output more information when this error occures.
117506 0 : ROSE_ASSERT(original_expression != NULL);
117507 0 : printf (" --- original_expression = %p = %s \n",original_expression,original_expression->class_name().c_str());
117508 0 : ROSE_ASSERT(new_expression != NULL);
117509 0 : printf (" --- new_expression = %p = %s \n",new_expression,new_expression->class_name().c_str());
117510 :
117511 0 : ROSE_ASSERT(original_expression->get_file_info() != NULL);
117512 0 : original_expression->get_file_info()->display("called from SgStatement::replace_expression()");
117513 0 : ROSE_ASSERT(new_expression->get_file_info() != NULL);
117514 0 : new_expression->get_file_info()->display("called from SgStatement::replace_expression()");
117515 :
117516 0 : ROSE_ASSERT(false);
117517 :
117518 : return 0;
117519 : }
117520 :
117521 : SgScopeStatement*
117522 17458000 : SgStatement::get_scope(void) const
117523 : {
117524 17458000 : ROSE_ASSERT(this != NULL);
117525 :
117526 : // This is a function called after the parents have been set. It is not called by the
117527 : // EDG/SAGE interface and is only called after the SAGE AST has been built and the parent
117528 : // pointers set within a separate phase.
117529 :
117530 : // Important exception: The SgFunctionParameterList should have as it's scope the
117531 : // SgFunctionDefinition, but it is a sibling of the SgFunctionDefinition (both the
117532 : // SgFunctionParameterList and the SgFunctionDefinition have the SgFunctionDeclaration
117533 : // as a parent. Thus the scope of the SgFunctionParameterList is computed to be the
117534 : // SgGlobal (global scope) most often; which is an error). So we handle this case
117535 : // explicitly.
117536 :
117537 17458000 : SgStatement *stmt = const_cast<SgStatement*>(this);
117538 17458000 : ROSE_ASSERT (stmt != NULL);
117539 :
117540 : // Make sure that parents have been set already (assume this means that all parents have been set)
117541 : #define WARN_NULL_PARENT_IN_GET_SCOPE 0
117542 : #if WARN_NULL_PARENT_IN_GET_SCOPE
117543 : if (get_parent() == NULL)
117544 : {
117545 : printf ("Note: found IR node where parent was not set = %p = %s (may not be required) \n",this,class_name().c_str());
117546 : // ROSE_ASSERT(get_file_info() != NULL);
117547 : if (get_file_info() != NULL)
117548 : {
117549 : get_file_info()->display("Location of problematic IR node");
117550 : }
117551 : }
117552 : #endif
117553 :
117554 : // ROSE_ASSERT (get_parent() != NULL);
117555 :
117556 : #if 0
117557 : printf ("In SgStatement::get_scope(): this = %s \n",class_name().c_str());
117558 : #endif
117559 :
117560 17458000 : SgScopeStatement *returnScope = NULL;
117561 17458000 : switch (variantT())
117562 : {
117563 : // DQ (11/7/03) : If we are a SgGlobal then return NULL (is this the best return value???)
117564 : // DQ (11/25/03): If we are a SgGlobal then return "this" (I think it's more useful)
117565 : // So the scope of global scope is now the global scope (hope this does not cause
117566 : // any loops to never terminate!).
117567 :
117568 2443770 : case V_SgGlobal:
117569 2443770 : {
117570 : // returnScope = NULL;
117571 2443770 : returnScope = isSgScopeStatement(stmt);
117572 2443770 : ROSE_ASSERT (returnScope != NULL);
117573 2443770 : break;
117574 : }
117575 :
117576 : // DQ (9/24/2005): This should be handled the same as SgFunctionParameterList
117577 11776200 : case V_SgCtorInitializerList:
117578 :
117579 : // DQ (11/21/2003): Handle special case of SgFunctionParameterList (attached to the
117580 : // SgFunctionDeclaration instead of the SgFunctionDefinition)
117581 11776200 : case V_SgFunctionParameterList:
117582 11776200 : {
117583 : // Handle case of SgFunctionDeclaration or SgMemberFunctionDeclaration
117584 11776200 : if (stmt->get_parent() == NULL)
117585 : {
117586 : // DQ (9/16/2019): Adding debugging support.
117587 0 : ROSE_ASSERT (stmt != NULL);
117588 0 : printf ("Error: SgStatement::get_scope(): stmt->get_parent() == NULL: stmt = %p = %s \n",stmt,stmt->class_name().c_str());
117589 : }
117590 11776200 : ROSE_ASSERT (stmt->get_parent() != NULL);
117591 :
117592 11776200 : SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(stmt->get_parent());
117593 11776200 : if (functionDeclaration != NULL)
117594 : {
117595 : // DQ (2/12/2006): provide a consistent definition of the scope for SgFunctionParameterList
117596 : // instead of a definition that depends on if it is a defining or non-defining declaration.
117597 11776200 : returnScope = functionDeclaration->get_scope();
117598 : }
117599 : else
117600 : {
117601 : // DQ (11/25/2011): Added support for SgTemplateFunctionDeclaration (and SgTemplateMemberFunctionDeclaration)
117602 : // which uses a SgFunctionParameterList internally.
117603 0 : SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(stmt->get_parent());
117604 0 : ROSE_ASSERT(templateFunctionDeclaration != NULL);
117605 0 : returnScope = templateFunctionDeclaration->get_scope();
117606 : }
117607 :
117608 11776200 : ROSE_ASSERT (returnScope != NULL);
117609 11776200 : break;
117610 : }
117611 :
117612 : // TV (05/28/2018): It can happen for SgDeclarationScope created to hold non-real declarations to be missing their parent...
117613 63592 : case V_SgDeclarationScope:
117614 63592 : {
117615 63592 : SgStatement * pstmt = isSgStatement(get_parent());
117616 63592 : returnScope = isSgScopeStatement(pstmt);
117617 63592 : if (returnScope == NULL && pstmt != NULL) {
117618 63262 : returnScope = pstmt->get_scope();
117619 : }
117620 : return returnScope; // Skipping assert at the end
117621 3174450 : break;
117622 : }
117623 : // DQ (11/7/03): If we are a ScopeStatment then reset the starting point for the search
117624 : // for the scopeStatement to the parent of the current node.
117625 3174450 : default:
117626 3174450 : {
117627 3174450 : ROSE_ASSERT(stmt != NULL);
117628 : #if 0
117629 : printf ("In SgScopeStatement::get_scope() default case: stmt = %s \n",stmt->sage_class_name());
117630 : ROSE_ASSERT(stmt->get_parent() != NULL);
117631 : printf ("In SgScopeStatement::get_scope() default case: stmt->get_parent() = %s \n",stmt->get_parent()->sage_class_name());
117632 : #endif
117633 :
117634 : // DQ (11/3/2007): Added comment to existing code. If the input node is a scope then move up one using
117635 : // the parent (since scopes are not explicitly stored in SgScopeStatement objects).
117636 3174450 : if (isSgScopeStatement(stmt) != NULL)
117637 : {
117638 1605250 : if (stmt->get_parent() == NULL)
117639 : {
117640 0 : printf ("Error: SgStatement has NULL parent at node = %p = %s \n",stmt,stmt->class_name().c_str());
117641 0 : if (stmt->get_file_info() != NULL)
117642 : {
117643 0 : stmt->get_file_info()->display("Error: SgStatement has NULL parent");
117644 : }
117645 : }
117646 1605250 : ROSE_ASSERT(stmt->get_parent() != NULL);
117647 :
117648 : // DQ (2/17/2014): We need to account for when we now can ask for the scope of a GNU statement expression
117649 : // inside of an array bound defining an array type.
117650 : // JJW (10/10/2007) -- the non-NULL parent of a statement may not be a statement in the case of a statement
117651 : // expression (test case is tests/nonsmoke/functional/CompileTests/Cxx_tests/test2006_148.C), so we need to skip over non-statements
117652 1605250 : SgNode* stmtTemp = stmt;
117653 1605250 : do {
117654 : #if 0
117655 : printf ("In SgStatement::get_scope(): (do-while loop) stmtTemp = %p = %s \n",stmtTemp,stmtTemp->class_name().c_str());
117656 : #endif
117657 1605250 : stmtTemp = stmtTemp->get_parent();
117658 : }
117659 : // while (stmtTemp && !isSgStatement(stmtTemp));
117660 : // while ((stmtTemp != NULL) && !isSgStatement(stmtTemp));
117661 : // while ((stmtTemp != NULL) && (isSgStatement(stmtTemp) == NULL) && (isSgArrayType(stmtTemp) == NULL));
117662 1605250 : while ((stmtTemp != NULL) && (isSgStatement(stmtTemp) == NULL) && (isSgArrayType(stmtTemp) == NULL) && (isSgTypeOfType(stmtTemp) == NULL) );
117663 :
117664 : // DQ (5/13/2015): Added debugging support.
117665 1605250 : if (stmtTemp == NULL)
117666 : {
117667 0 : printf ("Error: stmtTemp == NULL: in loop over parents from stmt = %p = %s \n",stmt,stmt->class_name().c_str());
117668 0 : ROSE_ASSERT(stmt->get_file_info() != NULL);
117669 0 : stmt->get_file_info()->display("Error: SgStatement has NULL parent");
117670 : }
117671 1605250 : ROSE_ASSERT (stmtTemp != NULL);
117672 1605250 : stmt = isSgStatement(stmtTemp);
117673 :
117674 : // DQ (2/17/2014): Handle the case where the scope is queried on a statement appearing in array type bound expression.
117675 1605250 : if (stmt != NULL)
117676 : {
117677 : // DQ (11/3/2007): Here is the fix for the case of calling the get_scope from a class definition.
117678 : // Because the definition of a class could be in an alternative location (structurally) from its
117679 : // initial declaration, we have to be careful if the parent of the initial input node to this function
117680 : // is a declaration which has an explicitly stored scope (since we will just use the parents and not
117681 : // the explicitly stored scope in the code below. The fix is to check if the value of "stmt" is a
117682 : // declaration with an explicitly stored scope (and if so use that value). Note that we can only
117683 : // return the explicitly stored scope, else we have to use parents to track backwards up the tree.
117684 : // This problem is demonstrated by test2005_153.C and test2005_172.C (smaller test code).
117685 1605250 : if (stmt->hasExplicitScope() == true)
117686 : {
117687 659661 : ROSE_ASSERT(isSgScopeStatement(stmt) == NULL);
117688 659661 : return stmt->get_scope();
117689 : }
117690 : }
117691 : else
117692 : {
117693 : // DQ (5/16/2015): This can also be the SgTypeOf operator.
117694 : // DQ (2/17/2014): This must be the case of an SgArrayType (not clear what to do here, return NULL).
117695 0 : SgArrayType* arrayType = isSgArrayType(stmtTemp);
117696 0 : SgTypeOfType* typeOfType = isSgTypeOfType(stmtTemp);
117697 : // ROSE_ASSERT(arrayType != NULL);
117698 0 : ROSE_ASSERT(arrayType != NULL || typeOfType != NULL);
117699 : #if 0
117700 : printf ("In get_scope(): identified input node to be part of SgArrayType: returning NULL \n");
117701 : #endif
117702 0 : return NULL;
117703 : }
117704 : }
117705 2514790 : ROSE_ASSERT(stmt != NULL);
117706 :
117707 2514790 : int counter = 0;
117708 4787510 : while(stmt && !(returnScope = isSgScopeStatement(stmt)))
117709 : {
117710 : #if 0
117711 : printf ("stmt->sage_class_name() = %s \n",stmt->sage_class_name());
117712 : #endif
117713 :
117714 2272720 : if (isSgNonrealDecl(stmt) != NULL && isSgStatement(stmt->get_parent()) == NULL) {
117715 0 : printf("WARNING: In SgStatement::get_scope(): case of a non-real declaration with a parent which is not a SgStatement!!!\n");
117716 0 : printf(" - stmt = %p (%s)\n", stmt, stmt ? stmt->class_name().c_str() : "");
117717 0 : printf(" - stmt->get_parent() = %p (%s)\n", stmt->get_parent(), stmt->get_parent() ? stmt->get_parent()->class_name().c_str() : "");
117718 0 : return NULL;
117719 : }
117720 :
117721 2272720 : if (stmt->get_parent() == NULL)
117722 : {
117723 0 : if (isSgEmptyDeclaration(stmt)) return NULL; // TODO dangling SgJovialCompoolStatement without parent AND SgEmptyDeclaration generate in "collect" phase of the translator but files are created later leading to pool traversal in post-processing.
117724 :
117725 0 : printf ("Error: NULL parent pointer not allowed for statement = %p = %s = %s \n",stmt,stmt->class_name().c_str(),SageInterface::get_name(stmt).c_str());
117726 0 : ROSE_ASSERT(stmt->get_file_info() != NULL);
117727 0 : stmt->get_file_info()->display("Error: NULL parent pointer not allowed for statement");
117728 : }
117729 2272720 : ROSE_ASSERT (stmt->get_parent() != NULL);
117730 : #if 0
117731 : printf ("stmt->get_parent()->sage_class_name() = %s \n",stmt->get_parent()->sage_class_name());
117732 : #endif
117733 :
117734 : // stmt = isSgStatement(stmt->get_parent());
117735 2272720 : SgInitializedName* initializedName = isSgInitializedName(stmt->get_parent());
117736 2272720 : if (initializedName != NULL)
117737 : {
117738 : #if 0
117739 : printf ("Get the stmt pointer from the initializedName->get_parent() = %p = %s \n",initializedName->get_parent(),initializedName->get_parent()->class_name().c_str());
117740 : #endif
117741 : // DQ (12/16/2007): Added error handling (reporting)
117742 126834 : if (isSgStatement(initializedName->get_parent()) == NULL)
117743 : {
117744 0 : printf ("Error: isSgStatement(initializedName->get_parent()) == NULL (initializedName = %p = %s) \n",initializedName,initializedName->get_name().str());
117745 : }
117746 126834 : ROSE_ASSERT(initializedName->get_parent() != NULL);
117747 126834 : stmt = isSgStatement(initializedName->get_parent());
117748 126834 : ROSE_ASSERT(stmt != NULL);
117749 : }
117750 : else
117751 : {
117752 : // DQ (12/16/2007): Added error handling (reporting)
117753 2145890 : if (isSgStatement(stmt->get_parent()) == NULL)
117754 : {
117755 0 : printf ("Error: isSgStatement(stmt ->get_parent()) == NULL (statement = %p = %s) (numeric_label = %p) \n",stmt,stmt->class_name().c_str(),stmt->get_numeric_label());
117756 : }
117757 2145890 : ROSE_ASSERT(stmt->get_parent() != NULL);
117758 2145890 : stmt = isSgStatement(stmt->get_parent());
117759 2145890 : ROSE_ASSERT(stmt != NULL);
117760 : }
117761 2272720 : ROSE_ASSERT(stmt != NULL);
117762 :
117763 : // DQ (9/23/2004): Avoid infinite loops, break out (abort) after some reasonable scope depth!
117764 2272720 : counter++;
117765 2272720 : if (counter > 1000)
117766 : {
117767 0 : printf ("Error max nesting depth exceeded, this is likely an error of some sort for a %s \n",sage_class_name());
117768 0 : printf ("\"this\" IR node %p = %s \n",this,sage_class_name());
117769 0 : get_file_info()->display("Error max nesting depth exceeded");
117770 0 : printf (" stmt is %p = %s \n",stmt,stmt->sage_class_name());
117771 0 : stmt->get_file_info()->display("Error max nesting depth exceeded");
117772 :
117773 : // DQ (3/19/2016): Klocworks reports ths as an issue, since the value of stmt->get_parent() is dereferenced below. Adding an assertion.
117774 0 : ROSE_ASSERT(stmt->get_parent() != NULL);
117775 :
117776 0 : printf (" has a parent %p = %s \n",stmt->get_parent(),stmt->get_parent()->sage_class_name());
117777 0 : ROSE_ASSERT(false);
117778 : }
117779 : }
117780 : break;
117781 : }
117782 : }
117783 :
117784 : // DQ (11/25/2003): I think we can now assert this to be true!
117785 : // DQ (11/27/2003): SgFunctionParameterList in a function prototype will cause
117786 : // returnScope == NULL. So we can't assert this.
117787 : // DQ (11/27/2003): Force SgFunctionParameterList case to use scope of the
117788 : // function declaration
117789 16734800 : ROSE_ASSERT (returnScope != NULL);
117790 :
117791 : // Error checking!
117792 16734800 : SgTemplateInstantiationDefn* defn = isSgTemplateInstantiationDefn(returnScope);
117793 16734800 : if (defn != NULL)
117794 : {
117795 401916 : SgTemplateInstantiationDecl * decl = isSgTemplateInstantiationDecl(defn->get_declaration());
117796 401916 : ROSE_ASSERT(decl != NULL);
117797 401916 : if (decl->get_nameResetFromMangledForm() == false)
117798 : {
117799 : #if PRINT_DEVELOPER_WARNINGS
117800 : printf ("In get_scope(): Found template definition containing template declaration (%s) with nameResetFromMangledForm == false \n",decl->get_name().str());
117801 : #endif
117802 : #if 0
117803 : // Uncomment this to find out where this construct is located in teh source code
117804 : decl->get_file_info()->display("In SgStatement::get_scope(): debug");
117805 : #endif
117806 : }
117807 : }
117808 :
117809 :
117810 : #if 0
117811 : printf ("In SgStatement::get_scope(): returnScope->sage_class_name() = %s \n",returnScope->sage_class_name());
117812 : #endif
117813 :
117814 : return returnScope;
117815 : }
117816 :
117817 : // DQ (12/16/2007): Added virtual function so that we could set the end_numeric_label on all relevant Fortran constructs
117818 : // void SgStatement::set_end_numeric_label(SgLabelSymbol* end_numeric_label)
117819 : void
117820 0 : SgStatement::set_end_numeric_label(SgLabelRefExp* end_numeric_label)
117821 : {
117822 0 : printf ("Error: base class implementation SgStatement::set_end_numeric_label(%p) should not be called \n",end_numeric_label);
117823 0 : ROSE_ASSERT(false);
117824 : }
117825 :
117826 :
117827 : // Report if a construct has a concept of end_numeric_label
117828 : bool
117829 279 : SgStatement::has_end_numeric_label() const
117830 : {
117831 279 : bool returnValue = false;
117832 :
117833 279 : switch(variantT())
117834 : {
117835 : // List of statements that contain an end_numeric_label concept
117836 48 : case V_SgIfStmt:
117837 48 : case V_SgWhileStmt:
117838 48 : case V_SgSwitchStatement:
117839 48 : case V_SgProgramHeaderStatement:
117840 48 : case V_SgProcedureHeaderStatement:
117841 48 : case V_SgInterfaceStatement:
117842 48 : case V_SgModuleStatement:
117843 48 : case V_SgFortranDo:
117844 48 : case V_SgWhereStatement:
117845 48 : case V_SgDerivedTypeStatement:
117846 48 : {
117847 48 : returnValue = true;
117848 48 : break;
117849 : }
117850 :
117851 279 : default:
117852 279 : {
117853 : // Nothing to do here
117854 : }
117855 : }
117856 :
117857 279 : return returnValue;
117858 : }
117859 :
117860 : bool
117861 0 : SgStatement::hasExplicitType()
117862 : {
117863 : // DQ (3/7/2014): This could be implemented as a virtual function but would require multiple functions to be
117864 : // implemented. I have thus instead implemented it as a single function on the SgStatement instead. We
117865 : // can review this if it is important.
117866 :
117867 : // This function returns true only if this is a SgTypedefDeclaration.
117868 :
117869 0 : bool returnValue = false;
117870 :
117871 0 : if ( isSgTypedefDeclaration(this) != NULL )
117872 : {
117873 0 : returnValue = true;
117874 : }
117875 :
117876 0 : return returnValue;
117877 : }
117878 :
117879 :
117880 :
117881 :
117882 : // End of memberFunctionString
117883 : // Start of memberFunctionString
117884 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
117885 :
117886 : // *** COMMON CODE SECTION BEGINS HERE ***
117887 :
117888 : #if 0
117889 : int
117890 : SgStatement::getVariant() const
117891 : {
117892 : // This function is used in ROSE while "variant()" is used in SAGE
117893 : assert(this != NULL);
117894 : return variant();
117895 : }
117896 : #endif
117897 :
117898 : // This function is used in ROSE in treeTraversal code
117899 : // eventually replaces getVariant() and variant()
117900 : // though after variant() has been removed for a while we will
117901 : // want to change the name of variantT() back to variant()
117902 : // (since the "T" was ment to stand for temporary).
117903 : // When this happens the variantT() will be depricated.
117904 : VariantT
117905 15382200 : SgStatement::variantT() const
117906 : {
117907 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
117908 15382200 : ROSE_ASSERT(this != NULL);
117909 15382200 : return V_SgStatement;
117910 : }
117911 :
117912 : #if 0
117913 : int
117914 : SgStatement::variant() const
117915 : {
117916 : // This function is used in SAGE
117917 : ROSE_ASSERT(this != NULL);
117918 : return StatementTag;
117919 : }
117920 : #endif
117921 :
117922 : ROSE_DLL_API const char*
117923 0 : SgStatement::sage_class_name() const
117924 : {
117925 0 : ROSE_ASSERT(this != NULL);
117926 0 : return "SgStatement";
117927 : }
117928 :
117929 : std::string
117930 0 : SgStatement::class_name() const
117931 : {
117932 0 : ROSE_ASSERT(this != NULL);
117933 0 : return "SgStatement";
117934 : }
117935 :
117936 : // DQ (11/26/2005): Support for visitor pattern mechanims
117937 : // (inferior to ROSE traversal mechanism, experimental).
117938 : void
117939 0 : SgStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
117940 : {
117941 0 : ROSE_ASSERT(this != NULL);
117942 0 : visitor.visit(this);
117943 0 : }
117944 :
117945 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
117946 0 : void SgStatement::accept (ROSE_VisitorPattern & visitor) {
117947 0 : ROSE_ASSERT(this != NULL);
117948 0 : visitor.visit(this);
117949 0 : }
117950 :
117951 : SgStatement*
117952 0 : SgStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
117953 : {
117954 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
117955 : // This function is currently only supported for the AST used the represent Binary executables.
117956 : if (0 /* isSgAsmNode(this) != NULL */)
117957 : {
117958 : // Support for regex specification.
117959 : std::string prefixCode = "REGEX:";
117960 : addNewAttribute(prefixCode + s,a);
117961 : }
117962 : #endif
117963 :
117964 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
117965 0 : return this;
117966 : }
117967 :
117968 : // *** COMMON CODE SECTION ENDS HERE ***
117969 :
117970 :
117971 : // End of memberFunctionString
117972 : // Start of memberFunctionString
117973 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
117974 :
117975 :
117976 : #if 0
117977 : //! Error checking support
117978 : /*! Verifies the following:
117979 : - working getVariant() member function
117980 : - calls base class's error() member function
117981 : Every class has one of these functions.
117982 : */
117983 : bool
117984 : SgStatement::error()
117985 : {
117986 : // Put error checking here
117987 :
117988 : ROSE_ASSERT (this != NULL);
117989 : if (getVariant() != StatementTag)
117990 : {
117991 : printf ("Error in SgStatement::error(): SgStatement object has a %s variant \n",
117992 : Cxx_GrammarTerminalNames[getVariant()].name);
117993 : // printf ("Error in SgStatement::error() \n");
117994 : ROSE_ABORT();
117995 : }
117996 :
117997 : ROSE_ASSERT (getVariant() == StatementTag);
117998 : return SgLocatedNode::error();
117999 : }
118000 : #endif
118001 :
118002 :
118003 :
118004 : // End of memberFunctionString
118005 :
118006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
118007 :
118008 136065000 : SgStatement* isSgStatement ( SgNode* inputDerivedClassPointer )
118009 : {
118010 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
118011 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
118012 : // So to fix this we return NULL directly when the input is NULL and avoid the
118013 : // dynamic_cast in this case. This is likely a performance improvement as well.
118014 : // return dynamic_cast<SgStatement*>(inputDerivedClassPointer);
118015 : // Milind Chabbi (8/28/2013): isSgStatement uses table-driven castability instead of c++ default dynamic_cast
118016 : // this improves the running time performance by 10-20%.
118017 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStatement*>(inputDerivedClassPointer);
118018 136065000 : return IS_SgStatement_FAST_MACRO(inputDerivedClassPointer);
118019 : }
118020 :
118021 : // DQ (11/8/2003): Added version of functions taking const pointer
118022 30551700 : const SgStatement* isSgStatement ( const SgNode* inputDerivedClassPointer )
118023 : {
118024 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
118025 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
118026 : // So to fix this we return NULL directly when the input is NULL and avoid the
118027 : // dynamic_cast in this case. This is likely a performance improvement as well.
118028 : // return dynamic_cast<const SgStatement*>(inputDerivedClassPointer);
118029 : // Milind Chabbi (8/28/2013): isSgStatement uses table-driven castability instead of c++ default dynamic_cast
118030 : // this improves the running time performance by 10-20%.
118031 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStatement*>(inputDerivedClassPointer);
118032 30551700 : return IS_SgStatement_FAST_MACRO(inputDerivedClassPointer);
118033 : }
118034 :
118035 :
118036 :
118037 : /* #line 118038 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
118038 :
118039 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
118040 :
118041 : /**
118042 : \brief Generated destructor
118043 :
118044 : This destructor is automatically generated (by ROSETTA). This destructor
118045 : only frees memory of data members associated with the parts of the current IR node which
118046 : are NOT traversed. Those data members that are part of a traversal can be freed using
118047 : a traversal (calling this destructor on all children in a post-order traversal). Such
118048 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
118049 :
118050 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
118051 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
118052 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
118053 :
118054 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
118055 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
118056 : pointers are not yet implemented to call delete on eash pointer in the container.
118057 : (This could be done by derivation from the STL containers to define containers that
118058 : automatically deleted their members.)
118059 :
118060 : */
118061 1323960 : SgStatement::~SgStatement () {
118062 1323960 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
118063 :
118064 :
118065 : // case: not a listType for numeric_label
118066 1323960 : p_numeric_label = NULL; // non list case
118067 : // case: not a listType for source_sequence_value
118068 1323960 : p_source_sequence_value = -1; // non list case
118069 :
118070 : }
118071 :
118072 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
118073 1323960 : }
118074 :
118075 :
118076 : /* #line 118077 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
118077 :
118078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
118079 :
118080 : // Generated constructor
118081 140946 : SgStatement::SgStatement ( Sg_File_Info* startOfConstruct )
118082 140946 : : SgLocatedNode(startOfConstruct)
118083 : {
118084 : #ifdef DEBUG
118085 : // printf ("In SgStatement::SgStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
118086 : #endif
118087 : #if 0
118088 : // debugging information!
118089 : printf ("In SgStatement::SgStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
118090 : #endif
118091 :
118092 140946 : p_numeric_label = NULL;
118093 140946 : p_source_sequence_value = -1;
118094 :
118095 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
118096 :
118097 : #if 0
118098 : // DQ (7/30/2014): Call a virtual function.
118099 : std::string s = this->class_name();
118100 : #endif
118101 :
118102 : // Test the variant virtual function
118103 : // assert(StatementTag == variant());
118104 140946 : assert(StatementTag == this->variant());
118105 140946 : ROSE_ASSERT(StatementTag == (int)(this->variantT()));
118106 140946 : post_construction_initialization();
118107 :
118108 : // Test the isSgStatement() function since it has been problematic
118109 140946 : assert(isSgStatement(this) != NULL);
118110 140946 : }
118111 :
118112 : // Generated constructor (all data members)
118113 :
118114 : /* #line 118115 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
118115 :
118116 :
118117 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
118118 :
118119 :
118120 : // ********************************************************
118121 : // member functions common across all array grammar objects
118122 : // ********************************************************
118123 :
118124 :
118125 :
118126 : /* #line 118127 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
118127 :
118128 :
118129 :
118130 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
118131 :
118132 : // ********************************************************
118133 : // member functions specific to each node in the grammar
118134 : // ********************************************************
118135 :
118136 :
118137 : /* #line 118138 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
118138 :
118139 : // Start of memberFunctionString
118140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
118141 :
118142 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
118143 :
118144 : SgTypeTable*
118145 147288 : SgScopeStatement::get_type_table () const
118146 : {
118147 147288 : ROSE_ASSERT (this != NULL);
118148 :
118149 : #if 0
118150 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
118151 : // used to trigger marking transformations for the token-based unparsing.
118152 : printf ("SgScopeStatement::get_type_table = %p = %s \n",this,this->class_name().c_str());
118153 : #endif
118154 :
118155 147288 : return p_type_table;
118156 : }
118157 :
118158 : void
118159 0 : SgScopeStatement::set_type_table ( SgTypeTable* type_table )
118160 : {
118161 0 : ROSE_ASSERT (this != NULL);
118162 :
118163 : #if 0
118164 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
118165 : // used to trigger marking transformations for the token-based unparsing.
118166 : printf ("SgScopeStatement::set_type_table = %p = %s \n",this,this->class_name().c_str());
118167 : #endif
118168 :
118169 0 : set_isModified(true);
118170 :
118171 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
118172 : if (p_type_table != NULL && type_table != NULL && p_type_table != type_table)
118173 : {
118174 : printf ("Warning: type_table = %p overwriting valid pointer p_type_table = %p \n",type_table,p_type_table);
118175 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
118176 : printf ("Error fails assertion (p_type_table != NULL && type_table != NULL && p_type_table != type_table) is false\n");
118177 : ROSE_ASSERT(false);
118178 : #endif
118179 : }
118180 : #endif
118181 0 : p_type_table = type_table;
118182 0 : }
118183 :
118184 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
118185 :
118186 :
118187 : // End of memberFunctionString
118188 : // Start of memberFunctionString
118189 :
118190 :
118191 : // End of memberFunctionString
118192 : // Start of memberFunctionString
118193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
118194 :
118195 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
118196 :
118197 : SgPragma*
118198 819 : SgScopeStatement::get_pragma () const
118199 : {
118200 819 : ROSE_ASSERT (this != NULL);
118201 :
118202 : #if 0
118203 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
118204 : // used to trigger marking transformations for the token-based unparsing.
118205 : printf ("SgScopeStatement::get_pragma = %p = %s \n",this,this->class_name().c_str());
118206 : #endif
118207 :
118208 819 : return p_pragma;
118209 : }
118210 :
118211 : void
118212 0 : SgScopeStatement::set_pragma ( SgPragma* pragma )
118213 : {
118214 0 : ROSE_ASSERT (this != NULL);
118215 :
118216 : #if 0
118217 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
118218 : // used to trigger marking transformations for the token-based unparsing.
118219 : printf ("SgScopeStatement::set_pragma = %p = %s \n",this,this->class_name().c_str());
118220 : #endif
118221 :
118222 0 : set_isModified(true);
118223 :
118224 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
118225 : if (p_pragma != NULL && pragma != NULL && p_pragma != pragma)
118226 : {
118227 : printf ("Warning: pragma = %p overwriting valid pointer p_pragma = %p \n",pragma,p_pragma);
118228 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
118229 : printf ("Error fails assertion (p_pragma != NULL && pragma != NULL && p_pragma != pragma) is false\n");
118230 : ROSE_ASSERT(false);
118231 : #endif
118232 : }
118233 : #endif
118234 0 : p_pragma = pragma;
118235 0 : }
118236 :
118237 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
118238 :
118239 :
118240 : // End of memberFunctionString
118241 : // Start of memberFunctionString
118242 : /* #line 4534 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
118243 :
118244 :
118245 :
118246 : // DQ (6/14/2007): Added to support simpler handling of general scopes (used in EDG/Sage translation).
118247 : void
118248 0 : SgScopeStatement::prepend_statement ( SgStatement* stmt )
118249 : {
118250 : // Higher level function to handle statements and declarations is scopes.
118251 :
118252 0 : ROSE_ASSERT(stmt != NULL);
118253 0 : if (containsOnlyDeclarations() == true)
118254 : {
118255 0 : SgDeclarationStatement* declaration = isSgDeclarationStatement(stmt);
118256 0 : if (declaration == NULL)
118257 : {
118258 0 : printf ("Error: SgScopeStatement::append in a scope such as %s must provide a SgDeclarationStatement = %s \n",class_name().c_str(),stmt->class_name().c_str());
118259 : }
118260 0 : ROSE_ASSERT(declaration != NULL);
118261 :
118262 : // Access the STL list directly
118263 0 : getDeclarationList().insert(getDeclarationList().begin(),declaration);
118264 :
118265 : // Set the parent (to have uniform semantics as with the other insert functions defined in SgStatement.
118266 0 : declaration->set_parent(this);
118267 0 : ROSE_ASSERT(declaration->get_parent() != NULL);
118268 : }
118269 : else
118270 : {
118271 : // Access the STL list directly
118272 0 : getStatementList().insert(getStatementList().begin(),stmt);
118273 :
118274 : // Set the parent (to have uniform semantics as with the other insert functions defined in SgStatement.
118275 0 : stmt->set_parent(this);
118276 0 : ROSE_ASSERT(stmt->get_parent() != NULL);
118277 : }
118278 0 : }
118279 :
118280 : // DQ (6/14/2007): Added to support simpler handling of general scopes (used in EDG/Sage translation).
118281 : void
118282 1175 : SgScopeStatement::append_statement ( SgStatement* stmt )
118283 : {
118284 : // Higher level function to handle statements and declarations is scopes.
118285 :
118286 1175 : ROSE_ASSERT(stmt != NULL);
118287 1175 : if (containsOnlyDeclarations() == true)
118288 : {
118289 47 : SgDeclarationStatement* declaration = isSgDeclarationStatement(stmt);
118290 47 : if (declaration == NULL)
118291 : {
118292 0 : printf ("Error: SgScopeStatement::append in a scope such as %s must provide a SgDeclarationStatement = %s \n",class_name().c_str(),stmt->class_name().c_str());
118293 : }
118294 47 : ROSE_ASSERT(declaration != NULL);
118295 :
118296 : // Access the STL list directly
118297 47 : getDeclarationList().insert(getDeclarationList().end(),declaration);
118298 :
118299 : // Set the parent (to have uniform semantics as with the other insert functions defined in SgStatement.
118300 47 : declaration->set_parent(this);
118301 47 : ROSE_ASSERT(declaration->get_parent() != NULL);
118302 : }
118303 : else
118304 : {
118305 : // Access the STL list directly
118306 1128 : getStatementList().insert(getStatementList().end(),stmt);
118307 :
118308 : // Set the parent (to have uniform semantics as with the other insert functions defined in SgStatement.
118309 1128 : stmt->set_parent(this);
118310 1128 : ROSE_ASSERT(stmt->get_parent() != NULL);
118311 : }
118312 1175 : }
118313 :
118314 : // DQ (6/5/2007): Build special operator to return by reference
118315 : std::set<SgSymbol*> &
118316 65740 : SgScopeStatement::get_type_elaboration_list ()
118317 : {
118318 65740 : assert (this != NULL);
118319 65740 : return p_type_elaboration_list;
118320 : }
118321 :
118322 : void
118323 0 : SgScopeStatement::set_type_elaboration_list ( const std::set<SgSymbol*> & type_elaboration_list )
118324 : {
118325 0 : assert (this != NULL);
118326 :
118327 : #if 1
118328 : // DQ (6/12/2015): Need to evluate if this is used, if it is part of the API that must not set the isModified, etc.
118329 0 : printf ("Inside of SgScopeStatement::set_type_elaboration_list(): we need to know if this is called! \n");
118330 0 : ROSE_ASSERT(false);
118331 : #endif
118332 :
118333 : set_isModified(true);
118334 : p_type_elaboration_list = type_elaboration_list;
118335 : }
118336 :
118337 : // DQ (6/5/2007): Build special operator to return by reference
118338 : std::set<SgSymbol*> &
118339 65740 : SgScopeStatement::get_hidden_type_list ()
118340 : {
118341 65740 : assert (this != NULL);
118342 65740 : return p_hidden_type_list;
118343 : }
118344 :
118345 : void
118346 0 : SgScopeStatement::set_hidden_type_list ( const std::set<SgSymbol*> & hidden_type_list )
118347 : {
118348 0 : assert (this != NULL);
118349 :
118350 : #if 1
118351 : // DQ (6/12/2015): Need to evluate if this is used, if it is part of the API that must not set the isModified, etc.
118352 0 : printf ("Inside of SgScopeStatement::set_type_elaboration_list(): we need to know if this is called! \n");
118353 0 : ROSE_ASSERT(false);
118354 : #endif
118355 :
118356 : set_isModified(true);
118357 : p_hidden_type_list = hidden_type_list;
118358 : }
118359 :
118360 : // DQ (6/5/2007): Build special operator to return by reference
118361 : std::set<SgSymbol*> &
118362 65740 : SgScopeStatement::get_hidden_declaration_list ()
118363 : {
118364 65740 : assert (this != NULL);
118365 65740 : return p_hidden_declaration_list;
118366 : }
118367 :
118368 : void
118369 0 : SgScopeStatement::set_hidden_declaration_list ( const std::set<SgSymbol*> & hidden_declaration_list )
118370 : {
118371 0 : assert (this != NULL);
118372 :
118373 : #if 1
118374 : // DQ (6/12/2015): Need to evluate if this is used, if it is part of the API that must not set the isModified, etc.
118375 0 : printf ("Inside of SgScopeStatement::set_type_elaboration_list(): we need to know if this is called! \n");
118376 0 : ROSE_ASSERT(false);
118377 : #endif
118378 :
118379 : set_isModified(true);
118380 : p_hidden_declaration_list = hidden_declaration_list;
118381 : }
118382 :
118383 :
118384 0 : std::ostream & operator<< ( std::ostream & os, const std::set<SgSymbol*> & l )
118385 : {
118386 0 : os << "output operator for std::set<SgSymbol*> not implemented";
118387 0 : return os;
118388 : }
118389 :
118390 138247 : SgScopeStatement::SgScopeStatement ( Sg_File_Info* file_info )
118391 138247 : : SgStatement(file_info)
118392 : {
118393 : // Make the global scope hash multimap larger since it typically supports more symbols.
118394 : // Use a prime number (better!)
118395 138247 : if (variantT() == V_SgGlobal || variantT() == V_SgNamespaceDefinitionStatement)
118396 : {
118397 0 : p_symbol_table = new SgSymbolTable(101);
118398 : }
118399 : else
118400 : {
118401 138247 : if (variantT() == V_SgClassDefinition || variantT() == V_SgTemplateInstantiationDefn)
118402 : {
118403 0 : p_symbol_table = new SgSymbolTable(51);
118404 : }
118405 : else
118406 : {
118407 : // Use the default size of hash_multimap
118408 276494 : p_symbol_table = new SgSymbolTable();
118409 : }
118410 : }
118411 :
118412 138247 : ROSE_ASSERT(p_symbol_table != NULL);
118413 :
118414 : // DQ (2/16/2006): Set this parent directly (now tested)
118415 138247 : p_symbol_table->set_parent(this);
118416 :
118417 : // DQ (7/23/2010): Build the local type table.
118418 138247 : p_type_table = new SgTypeTable();
118419 138247 : p_type_table->set_parent(this);
118420 :
118421 : // DQ (9/23/2020): Add a pointer to hold a SgPragma that can be attached to a log of scope IR nodes.
118422 138247 : p_pragma = NULL;
118423 138247 : }
118424 :
118425 : void
118426 0 : SgScopeStatement::post_construction_initialization()
118427 : {
118428 : #if 0
118429 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
118430 : printf ("In SgScopeStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
118431 : #endif
118432 0 : }
118433 :
118434 : // DQ (9/8/2004): Added to support qualified name generation
118435 : // RV (1/31/2006): Modified to return a fully qualified name by recursion.
118436 : SgName
118437 0 : SgScopeStatement::get_qualified_name() const
118438 : {
118439 : // Compute name of this scope -- by default, an unnamed (or empty) string.
118440 0 : SgName local_qual_name;
118441 :
118442 : // Compute parent scope's qualified name
118443 0 : SgName par_qual_name;
118444 0 : const SgScopeStatement* parent_scope = get_scope();
118445 0 : if (parent_scope)
118446 0 : par_qual_name = parent_scope->get_qualified_name();
118447 :
118448 0 : return SgName::assembleQualifiedName (par_qual_name, local_qual_name);
118449 : }
118450 :
118451 : SgName
118452 0 : SgScopeStatement::get_mangled_name(void) const
118453 : {
118454 0 : printf ("Error: this is a virtual function call on a base class implementation! scope = %p = %s \n",this,this->class_name().c_str());
118455 0 : ROSE_ASSERT(false);
118456 :
118457 : return SgName ("__error__");
118458 : }
118459 :
118460 : size_t
118461 91948 : SgScopeStatement::count_symbol(const SgName& n)
118462 : {
118463 : // DQ (2/10/2007): Added function to count entries in symbol table with same name!
118464 : // This can be more than 1, e.g. "typedef struct X{} X;"
118465 91948 : assert (p_symbol_table != NULL);
118466 91948 : return p_symbol_table->count(n);
118467 : }
118468 :
118469 : size_t
118470 157097 : SgScopeStatement::count_alias_symbol(const SgName& n)
118471 : {
118472 : // DQ (5/14/2011): Added support to count just the alias symbols that match the input name (key).
118473 157097 : assert (p_symbol_table != NULL);
118474 157097 : return p_symbol_table->count_aliases(n);
118475 : }
118476 :
118477 : //! Return the size of the symbol table.
118478 : size_t
118479 2424140 : SgScopeStatement::symbol_table_size()
118480 : {
118481 2424140 : assert (p_symbol_table != NULL);
118482 2424140 : return p_symbol_table->size();
118483 : }
118484 :
118485 :
118486 :
118487 : // DQ (2/10/2007): Added test function for existence of symbols
118488 : bool
118489 10305 : SgScopeStatement::symbol_exists ( const SgName & nm , SgSymbol *sp ) const
118490 : {
118491 10305 : assert (p_symbol_table != NULL);
118492 10305 : return p_symbol_table->exists(nm,sp);
118493 : }
118494 :
118495 : // DQ (2/10/2007): Added test function for existence of symbols
118496 : bool
118497 55258 : SgScopeStatement::symbol_exists ( const SgName & nm ) const
118498 : {
118499 55258 : assert (p_symbol_table != NULL);
118500 55258 : return p_symbol_table->exists(nm);
118501 : }
118502 :
118503 : // DQ (2/10/2007): Added test function for existence of symbols
118504 : bool
118505 45070 : SgScopeStatement::symbol_exists ( const SgSymbol *sp ) const
118506 : {
118507 45070 : assert (p_symbol_table != NULL);
118508 45070 : return p_symbol_table->exists(sp);
118509 : }
118510 :
118511 : // DQ (5/21/2013): This function is removed from the SgScopeStatement API as a public member function.
118512 : // It is replaced in the SgScopeStatement as a soon to be private member function. This is done to
118513 : // support hiding the namespace symbol table handling behind the SgScopeStatement level of support.
118514 : // There is no reason for the symbol table to be directly accessible to users, if there is a problem
118515 : // then the SgScopeStatement class API should be extended with the required functionality.
118516 : SgSymbolTable*
118517 13270000 : SgScopeStatement::get_symbol_table () const
118518 : {
118519 13270000 : ROSE_ASSERT (this != NULL);
118520 13270000 : return p_symbol_table;
118521 : }
118522 :
118523 : // DQ (5/21/2013): This function is removed from the SgScopeStatement API as a public member function (see comment above).
118524 : void
118525 0 : SgScopeStatement::set_symbol_table ( SgSymbolTable* symbol_table )
118526 : {
118527 0 : ROSE_ASSERT (this != NULL);
118528 0 : set_isModified(true);
118529 0 : p_symbol_table = symbol_table;
118530 0 : }
118531 :
118532 : #define DEBUG__SGSCOPESTATEMENT__INSERT_SYMBOL 0
118533 :
118534 : void
118535 1126880 : SgScopeStatement::insert_symbol ( const SgName& n, SgSymbol* s )
118536 : {
118537 : #if DEBUG__SGSCOPESTATEMENT__INSERT_SYMBOL
118538 : printf("SgScopeStatement::insert_symbol\n");
118539 : printf(" -- n = %s\n", n.getString().c_str());
118540 : printf(" -- s = %p (%s)\n", s, s ? s->class_name().c_str() : "");
118541 : #endif
118542 1126880 : assert (p_symbol_table != NULL);
118543 :
118544 1126880 : SgNode * symbol_basis = s->get_symbol_basis();
118545 1126880 : ROSE_ASSERT(symbol_basis != NULL);
118546 : #if DEBUG__SGSCOPESTATEMENT__INSERT_SYMBOL
118547 : printf(" -- symbol_basis = %p (%s)\n", symbol_basis, symbol_basis->class_name().c_str());
118548 : #endif
118549 1126880 : SgDeclarationStatement * declstmt = isSgDeclarationStatement(symbol_basis);
118550 1126880 : SgInitializedName * iname = isSgInitializedName(symbol_basis);
118551 1126880 : if (iname != NULL) {
118552 78443 : declstmt = isSgVariableDeclaration(iname->get_declaration());
118553 : }
118554 : #if DEBUG__SGSCOPESTATEMENT__INSERT_SYMBOL
118555 : printf(" -- declstmt = %p (%s)\n", declstmt, declstmt ? declstmt->class_name().c_str() : "");
118556 : #endif
118557 1126880 : bool is_static_decl = false;
118558 1126880 : if (declstmt != NULL) {
118559 1089230 : const SgDeclarationModifier & decl_mod = declstmt->get_declarationModifier();
118560 1089230 : const SgStorageModifier & storage_mod = decl_mod.get_storageModifier();
118561 1089230 : is_static_decl = storage_mod.isStatic();
118562 : }
118563 : #if DEBUG__SGSCOPESTATEMENT__INSERT_SYMBOL
118564 : printf(" -- is_static_decl = %s\n", is_static_decl ? "true" : "false");
118565 : #endif
118566 :
118567 1126880 : const SgNamespaceDefinitionStatement * namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118568 1126880 : if (namespaceDefinitionStatement != NULL && !is_static_decl)
118569 : {
118570 26865 : SgAliasSymbol* aliasSymbol = new SgAliasSymbol(s);
118571 :
118572 26865 : SgNamespaceDefinitionStatement * gnds = namespaceDefinitionStatement->get_global_definition();
118573 26865 : if (gnds != NULL && namespaceDefinitionStatement != gnds) {
118574 26865 : gnds->get_symbol_table()->insert(n,aliasSymbol);
118575 : }
118576 : }
118577 :
118578 1126880 : SgGlobal * global_scope = isSgGlobal(this);
118579 1126880 : if (global_scope != NULL && !is_static_decl) {
118580 890669 : SgProject * project = SageInterface::getProject(global_scope);
118581 890669 : if (project != NULL) {
118582 890669 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118583 890669 : assert(globalScopeAcrossFiles != NULL);
118584 :
118585 : // DQ (2/28/2015): they can be the same for snippet injection and for some java support.
118586 890669 : if (global_scope != globalScopeAcrossFiles) {
118587 890669 : SgSymbolTable * symtab = globalScopeAcrossFiles->get_symbol_table();
118588 890669 : ROSE_ASSERT(symtab != NULL);
118589 890669 : SgAliasSymbol * asym = symtab->find_aliased_symbol(n,s);
118590 890669 : if (asym == NULL) {
118591 883258 : asym = isSgAliasSymbol(s);
118592 883258 : if (asym != NULL) {
118593 9379 : asym = new SgAliasSymbol(*asym);
118594 : } else {
118595 873879 : asym = new SgAliasSymbol(s);
118596 : }
118597 883258 : ROSE_ASSERT(asym != NULL);
118598 : #if DEBUG__SGSCOPESTATEMENT__INSERT_SYMBOL
118599 : printf(" -- asym = %p (%s)\n", asym, asym->class_name().c_str());
118600 : #endif
118601 883258 : globalScopeAcrossFiles->get_symbol_table()->insert(n, asym);
118602 : }
118603 : } else {
118604 0 : mprintf ("Warning: In SgScopeStatement::insert_symbol(): global_scope == globalScopeAcrossFiles: skip insertion of redundant SgAliasSymbol \n");
118605 : }
118606 : } else {
118607 0 : mprintf ("In SgScopeStatement::insert_symbol(): project == NULL \n");
118608 : }
118609 : }
118610 :
118611 : // Make sure that this specific symbol and name combination don't already exist in the AST.
118612 1126880 : bool symbolAlreadyPresentLookupName = p_symbol_table->exists(n,s);
118613 1126880 : if (symbolAlreadyPresentLookupName == true)
118614 : {
118615 0 : printf ("Error in insert_symbol(n=%s,s=%p): (exists(n,s) == true) symbol = %p = %s = %s already present in symbol table = %p in scope = %p = %s \n",
118616 0 : n.str(),s,s,s->class_name().c_str(),SageInterface::get_name(s).c_str(),p_symbol_table,this,this->class_name().c_str());
118617 0 : printf (" s->get_symbol_basis() = %p = %s \n",s->get_symbol_basis(),s->get_symbol_basis()->class_name().c_str());
118618 0 : s->get_symbol_basis()->get_file_info()->display("Error in insert_symbol(n,s)");
118619 : }
118620 1126880 : ROSE_ASSERT(symbolAlreadyPresentLookupName == false);
118621 :
118622 : #if SYMBOL_TABLE_ERROR_CHECKING
118623 : // Also test the symbol directly (this is an expensive test, linear in complexity)
118624 : // We don't want to do this except for testing!
118625 : bool symbolAlreadyPresent = p_symbol_table->exists(s);
118626 : if (symbolAlreadyPresent == true)
118627 : {
118628 : printf ("Error: (exists(s) == true) symbol = %p = %s = %s already present in symbol table = %p in scope = %p = %s \n",
118629 : s,s->class_name().c_str(),SageInterface::get_name(s).c_str(),p_symbol_table,this,this->class_name().c_str());
118630 : }
118631 : ROSE_ASSERT(symbolAlreadyPresent == false);
118632 : #endif
118633 :
118634 : #if 1
118635 : // DQ (11/21/2013): Adding test as a result of debugging with Philippe.
118636 : // This test is not a test for a bug, since we require that symbols in base classes be aliased in the derived classes.
118637 1126880 : SgClassSymbol* class_symbol = isSgClassSymbol(s);
118638 1126880 : if (class_symbol != NULL)
118639 : {
118640 25043 : SgClassDeclaration* class_declaration = isSgClassDeclaration(class_symbol->get_declaration());
118641 25043 : ROSE_ASSERT(class_declaration != NULL);
118642 :
118643 : // DQ (10/22/2016): If this is a namespace definition then only compare to the global_definition.
118644 25043 : SgScopeStatement* classScope = class_declaration->get_scope();
118645 25043 : SgScopeStatement* thisScope = this;
118646 :
118647 25043 : SgNamespaceDefinitionStatement* namespaceDefinition_class = isSgNamespaceDefinitionStatement(classScope);
118648 25043 : SgNamespaceDefinitionStatement* namespaceDefinition_this = isSgNamespaceDefinitionStatement(this);
118649 25043 : if (namespaceDefinition_class != NULL && namespaceDefinition_this != NULL)
118650 : {
118651 17205 : classScope = namespaceDefinition_class->get_global_definition();
118652 17205 : thisScope = namespaceDefinition_this->get_global_definition();
118653 :
118654 : // printf ("In SgScopeStatement::insert_symbol(): classScope = %p thisScope = %p \n",classScope,thisScope);
118655 : }
118656 :
118657 : // DQ (10/22/2016): If this is global scope then suppress the output below (this is only an issue for the astMerge option (feature) in ROSE.
118658 25043 : SgGlobal* globalScope_class = isSgGlobal(classScope);
118659 25043 : SgGlobal* globalScope_this = isSgGlobal(this);
118660 25043 : if (globalScope_class != NULL && globalScope_this != NULL)
118661 : {
118662 6411 : classScope = globalScope_this;
118663 :
118664 : // printf ("In SgScopeStatement::insert_symbol(): classScope = %p thisScope = %p \n",classScope,thisScope);
118665 : }
118666 :
118667 25043 : if (classScope != thisScope)
118668 : {
118669 : // DQ (3/6/2017): Added support for message logging to control output from ROSE tools.
118670 0 : mprintf ("Warning: SgScopeStatement::insert_symbol(): class_declaration->get_scope() != this \n");
118671 0 : mprintf (" --- scope = %p = %s \n",this,this->class_name().c_str());
118672 0 : mprintf (" --- class_declaration = %p = %s \n",class_declaration,class_declaration->class_name().c_str());
118673 0 : mprintf (" --- class_declaration->get_scope() = %p = %s \n",class_declaration->get_scope(),class_declaration->get_scope()->class_name().c_str());
118674 : // class_declaration->get_file_info()->display("class_declaration: debug");
118675 : }
118676 : // ROSE_ASSERT(class_declaration->get_scope() == this);
118677 : }
118678 : #endif
118679 :
118680 : #if 0
118681 : printf ("In SgScopeStatement::insert_symbol(%s,%p) into scope = %p = %s symbol = %p = %s \n",n.str(),s,this,this->class_name().c_str(),s,s->class_name().c_str());
118682 : #endif
118683 :
118684 1126880 : p_symbol_table->insert(n,s);
118685 :
118686 : #if 0
118687 : printf ("Leaving SgScopeStatement::insert_symbol() \n");
118688 : #endif
118689 1126880 : }
118690 :
118691 : void
118692 19371 : SgScopeStatement::remove_symbol ( SgSymbol* s )
118693 : {
118694 19371 : assert (p_symbol_table != NULL);
118695 :
118696 : #if SYMBOL_TABLE_ERROR_CHECKING
118697 : // Make sure that the symbol exists before we try to remove it
118698 : ROSE_ASSERT(p_symbol_table->exists(s) == true);
118699 : #endif
118700 :
118701 19371 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118702 19371 : if (namespaceDefinitionStatement != NULL) {
118703 6919 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118704 6919 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118705 6919 : ROSE_ASSERT(globalNamespaceDefinitionStatement != NULL);
118706 6919 : ROSE_ASSERT(namespaceDefinitionStatement != globalNamespaceDefinitionStatement);
118707 :
118708 13838 : SgName n = s->get_name();
118709 :
118710 6919 : SgSymbol* aliasSymbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_aliased_symbol(n,s);
118711 6919 : if (aliasSymbol != NULL) {
118712 6919 : globalNamespaceDefinitionStatement->get_symbol_table()->remove(aliasSymbol);
118713 : }
118714 : }
118715 :
118716 19371 : const SgGlobal * global_scope = isSgGlobal(this);
118717 19371 : if (global_scope != NULL) {
118718 14 : SgProject * project = SageInterface::getProject(global_scope);
118719 14 : if (project != NULL) {
118720 14 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118721 14 : assert(globalScopeAcrossFiles != NULL);
118722 :
118723 28 : SgName n = s->get_name();
118724 :
118725 14 : SgSymbol * aliasSymbol = globalScopeAcrossFiles->get_symbol_table()->find_aliased_symbol(n,s);
118726 14 : if (aliasSymbol != NULL)
118727 14 : globalScopeAcrossFiles->get_symbol_table()->remove(aliasSymbol);
118728 : }
118729 : }
118730 :
118731 19371 : p_symbol_table->remove(s);
118732 19371 : }
118733 :
118734 0 : int SgScopeStatement::lookup_symbol(const SgName& n, SgSymbol *s) const
118735 : {
118736 0 : ROSE_ASSERT (this != NULL);
118737 0 : ROSE_ASSERT (p_symbol_table != NULL);
118738 :
118739 0 : if (p_symbol_table->find(n,s)) return true;
118740 :
118741 0 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118742 0 : if (namespaceDefinitionStatement != NULL)
118743 : {
118744 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118745 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118746 :
118747 0 : return globalNamespaceDefinitionStatement->get_symbol_table()->find(n,s);
118748 : }
118749 :
118750 0 : const SgGlobal * global_scope = isSgGlobal(this);
118751 0 : if (global_scope != NULL) {
118752 0 : SgProject * project = SageInterface::getProject(global_scope);
118753 0 : if (project != NULL) {
118754 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118755 0 : assert(globalScopeAcrossFiles != NULL);
118756 0 : return globalScopeAcrossFiles->get_symbol_table()->find(n,s);
118757 : }
118758 : }
118759 :
118760 : return false;
118761 : }
118762 :
118763 : SgSymbol*
118764 2272510 : SgScopeStatement::lookup_symbol(const SgName& n, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentList) const
118765 : {
118766 2272510 : ROSE_ASSERT (this != NULL);
118767 2272510 : ROSE_ASSERT (p_symbol_table != NULL);
118768 :
118769 2272510 : SgSymbol * symbol = p_symbol_table->find_any(n,templateParameterList,templateArgumentList);
118770 :
118771 2272510 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118772 2272510 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118773 : {
118774 222848 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118775 222848 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118776 222848 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_any(n,templateParameterList,templateArgumentList);
118777 : }
118778 :
118779 2272510 : const SgGlobal * global_scope = isSgGlobal(this);
118780 2272510 : if (symbol == NULL && global_scope != NULL) {
118781 135942 : SgProject * project = SageInterface::getProject(global_scope);
118782 135942 : if (project != NULL) {
118783 135942 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118784 135942 : assert(globalScopeAcrossFiles != NULL);
118785 135942 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_any(n,templateParameterList,templateArgumentList);
118786 : }
118787 : }
118788 :
118789 2272510 : return symbol;
118790 : }
118791 :
118792 : SgTypedefSymbol*
118793 20442 : SgScopeStatement::lookup_typedef_symbol(const SgName& n) const
118794 : {
118795 20442 : ROSE_ASSERT (this != NULL);
118796 20442 : ROSE_ASSERT (p_symbol_table != NULL);
118797 :
118798 20442 : SgTypedefSymbol * symbol = p_symbol_table->find_typedef(n);
118799 :
118800 20442 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118801 20442 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118802 : {
118803 1339 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118804 1339 : const SgNamespaceDefinitionStatement * globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118805 1339 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_typedef(n);
118806 : }
118807 :
118808 20442 : const SgGlobal * global_scope = isSgGlobal(this);
118809 20442 : if (symbol == NULL && global_scope != NULL) {
118810 527 : SgProject * project = SageInterface::getProject(global_scope);
118811 527 : if (project != NULL) {
118812 527 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118813 527 : assert(globalScopeAcrossFiles != NULL);
118814 527 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_typedef(n);
118815 : }
118816 : }
118817 :
118818 20442 : return symbol;
118819 : }
118820 :
118821 : SgEnumSymbol*
118822 9084 : SgScopeStatement::lookup_enum_symbol(const SgName& n) const
118823 : {
118824 9084 : ROSE_ASSERT (this != NULL);
118825 9084 : ROSE_ASSERT (p_symbol_table != NULL);
118826 :
118827 9084 : SgEnumSymbol * symbol = p_symbol_table->find_enum(n);
118828 :
118829 9084 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118830 9084 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118831 : {
118832 204 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118833 204 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118834 204 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_enum(n);
118835 : }
118836 :
118837 9084 : const SgGlobal * global_scope = isSgGlobal(this);
118838 9084 : if (symbol == NULL && global_scope != NULL) {
118839 3204 : SgProject * project = SageInterface::getProject(global_scope);
118840 3204 : if (project != NULL) {
118841 3204 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118842 3204 : assert(globalScopeAcrossFiles != NULL);
118843 3204 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_enum(n);
118844 : }
118845 : }
118846 :
118847 9084 : return symbol;
118848 : }
118849 :
118850 : SgEnumFieldSymbol*
118851 12192 : SgScopeStatement::lookup_enum_field_symbol(const SgName& n) const
118852 : {
118853 12192 : ROSE_ASSERT (this != NULL);
118854 12192 : ROSE_ASSERT (p_symbol_table != NULL);
118855 :
118856 12192 : SgEnumFieldSymbol * symbol = p_symbol_table->find_enum_field(n);
118857 :
118858 12192 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118859 12192 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118860 : {
118861 3221 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118862 3221 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118863 3221 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_enum_field(n);
118864 : }
118865 :
118866 12192 : const SgGlobal * global_scope = isSgGlobal(this);
118867 12192 : if (symbol == NULL && global_scope != NULL) {
118868 5253 : SgProject * project = SageInterface::getProject(global_scope);
118869 5253 : if (project != NULL) {
118870 5253 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118871 5253 : assert(globalScopeAcrossFiles != NULL);
118872 5253 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_enum_field(n);
118873 : }
118874 : }
118875 :
118876 12192 : return symbol;
118877 : }
118878 :
118879 : SgVariableSymbol*
118880 42475 : SgScopeStatement::lookup_var_symbol(const SgName& n) const
118881 : {
118882 : // DQ (2/4/2007): This function is part of an older interface which is deprecated.
118883 42475 : return lookup_variable_symbol(n);
118884 : }
118885 :
118886 : SgVariableSymbol*
118887 187911 : SgScopeStatement::lookup_variable_symbol(const SgName& n) const
118888 : {
118889 187911 : ROSE_ASSERT (this != NULL);
118890 187911 : ROSE_ASSERT (p_symbol_table != NULL);
118891 :
118892 187911 : SgVariableSymbol * symbol = p_symbol_table->find_variable(n);
118893 :
118894 187911 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118895 187911 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118896 : {
118897 510 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118898 510 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118899 510 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_variable(n);
118900 : }
118901 :
118902 187911 : const SgGlobal * global_scope = isSgGlobal(this);
118903 187911 : if (symbol == NULL && global_scope != NULL) {
118904 4698 : SgProject * project = SageInterface::getProject(global_scope);
118905 4698 : if (project != NULL) {
118906 4698 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118907 4698 : assert(globalScopeAcrossFiles != NULL);
118908 4698 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_variable(n);
118909 : }
118910 : }
118911 :
118912 187911 : return symbol;
118913 : }
118914 :
118915 : SgClassSymbol*
118916 45575 : SgScopeStatement::lookup_class_symbol(const SgName& n, SgTemplateArgumentPtrList* templateArgumentsList) const
118917 : {
118918 45575 : ROSE_ASSERT (this != NULL);
118919 45575 : ROSE_ASSERT (p_symbol_table != NULL);
118920 :
118921 45575 : SgClassSymbol * symbol = p_symbol_table->find_class(n,templateArgumentsList);
118922 :
118923 45575 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118924 45575 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118925 : {
118926 8066 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118927 8066 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118928 8066 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_class(n,templateArgumentsList);
118929 : }
118930 :
118931 45575 : const SgGlobal * global_scope = isSgGlobal(this);
118932 45575 : if (symbol == NULL && global_scope != NULL) {
118933 11807 : SgProject * project = SageInterface::getProject(global_scope);
118934 11807 : if (project != NULL) {
118935 11807 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118936 11807 : assert(globalScopeAcrossFiles != NULL);
118937 11807 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_class(n,templateArgumentsList);
118938 : }
118939 : }
118940 :
118941 45575 : return symbol;
118942 : }
118943 :
118944 : SgNonrealSymbol*
118945 20034 : SgScopeStatement::lookup_nonreal_symbol(const SgName& n, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentsList) const
118946 : {
118947 20034 : ROSE_ASSERT (this != NULL);
118948 20034 : ROSE_ASSERT (p_symbol_table != NULL);
118949 :
118950 20034 : SgNonrealSymbol * symbol = p_symbol_table->find_nonreal(n,templateParameterList,templateArgumentsList);
118951 :
118952 20034 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118953 20034 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118954 : {
118955 4125 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118956 4125 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118957 4125 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_nonreal(n,templateParameterList,templateArgumentsList);
118958 : }
118959 :
118960 20034 : const SgGlobal * global_scope = isSgGlobal(this);
118961 20034 : if (symbol == NULL && global_scope != NULL) {
118962 3743 : SgProject * project = SageInterface::getProject(global_scope);
118963 3743 : if (project != NULL) {
118964 3743 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118965 3743 : assert(globalScopeAcrossFiles != NULL);
118966 3743 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_nonreal(n,templateParameterList,templateArgumentsList);
118967 : }
118968 : }
118969 :
118970 20034 : return symbol;
118971 : }
118972 :
118973 : SgLabelSymbol*
118974 20 : SgScopeStatement::lookup_label_symbol(const SgName& n) const
118975 : {
118976 20 : ROSE_ASSERT (this != NULL);
118977 20 : ROSE_ASSERT (p_symbol_table != NULL);
118978 :
118979 20 : SgLabelSymbol * symbol = p_symbol_table->find_label(n);
118980 :
118981 20 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
118982 20 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
118983 : {
118984 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
118985 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
118986 0 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_label(n);
118987 : }
118988 :
118989 20 : const SgGlobal * global_scope = isSgGlobal(this);
118990 20 : if (symbol == NULL && global_scope != NULL) {
118991 0 : SgProject * project = SageInterface::getProject(global_scope);
118992 0 : if (project != NULL) {
118993 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
118994 0 : assert(globalScopeAcrossFiles != NULL);
118995 0 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_label(n);
118996 : }
118997 : }
118998 :
118999 20 : return symbol;
119000 : }
119001 :
119002 : SgFunctionSymbol*
119003 1154030 : SgScopeStatement::lookup_function_symbol(const SgName& n, const SgType* t, SgTemplateArgumentPtrList* templateArgumentsList) const
119004 : {
119005 1154030 : ROSE_ASSERT (this != NULL);
119006 1154030 : ROSE_ASSERT (p_symbol_table != NULL);
119007 :
119008 1154030 : SgFunctionSymbol * symbol = p_symbol_table->find_function(n,t,templateArgumentsList);
119009 :
119010 1154030 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119011 1154030 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119012 : {
119013 5338 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119014 5338 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119015 5338 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_function(n,t,templateArgumentsList);
119016 : }
119017 :
119018 1154030 : const SgGlobal * global_scope = isSgGlobal(this);
119019 1154030 : if (symbol == NULL && global_scope != NULL) {
119020 5841 : SgProject * project = SageInterface::getProject(global_scope);
119021 5841 : if (project != NULL) {
119022 5841 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119023 5841 : ROSE_ASSERT(globalScopeAcrossFiles != NULL);
119024 5841 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_function(n,t,templateArgumentsList);
119025 : }
119026 : }
119027 :
119028 1154030 : return symbol;
119029 : }
119030 :
119031 : SgFunctionSymbol*
119032 900058 : SgScopeStatement::lookup_function_symbol(const SgName& n) const
119033 : {
119034 900058 : ROSE_ASSERT (this != NULL);
119035 900058 : ROSE_ASSERT (p_symbol_table != NULL);
119036 :
119037 900058 : SgFunctionSymbol * symbol = p_symbol_table->find_function(n);
119038 :
119039 900058 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119040 900058 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119041 : {
119042 955 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119043 955 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119044 955 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_function(n);
119045 : }
119046 :
119047 900058 : const SgGlobal * global_scope = isSgGlobal(this);
119048 900058 : if (symbol == NULL && global_scope != NULL) {
119049 1004 : SgProject * project = SageInterface::getProject(global_scope);
119050 1004 : if (project != NULL) {
119051 1004 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119052 1004 : assert(globalScopeAcrossFiles != NULL);
119053 1004 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_function(n);
119054 : }
119055 : }
119056 :
119057 900058 : return symbol;
119058 : }
119059 :
119060 : SgNamespaceSymbol*
119061 2294 : SgScopeStatement::lookup_namespace_symbol ( const SgName & n ) const
119062 : {
119063 2294 : ROSE_ASSERT (this != NULL);
119064 2294 : ROSE_ASSERT (p_symbol_table != NULL);
119065 :
119066 2294 : SgNamespaceSymbol * symbol = p_symbol_table->find_namespace(n);
119067 :
119068 2294 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119069 2294 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119070 : {
119071 188 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119072 188 : const SgNamespaceDefinitionStatement * globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119073 188 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_namespace(n);
119074 : }
119075 :
119076 2294 : const SgGlobal * global_scope = isSgGlobal(this);
119077 2294 : if (symbol == NULL && global_scope != NULL) {
119078 49 : SgProject * project = SageInterface::getProject(global_scope);
119079 49 : if (project != NULL) {
119080 49 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119081 49 : assert(globalScopeAcrossFiles != NULL);
119082 49 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_namespace(n);
119083 : }
119084 : }
119085 :
119086 2294 : return symbol;
119087 : }
119088 :
119089 : SgTemplateClassSymbol*
119090 14427 : SgScopeStatement::lookup_template_class_symbol (const SgName& n, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateSpecializationArgumentList ) const
119091 : {
119092 14427 : ROSE_ASSERT (this != NULL);
119093 14427 : ROSE_ASSERT (p_symbol_table != NULL);
119094 :
119095 14427 : SgTemplateClassSymbol * symbol = p_symbol_table->find_template_class(n, templateParameterList, templateSpecializationArgumentList);
119096 :
119097 14427 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119098 14427 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119099 : {
119100 5863 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119101 5863 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119102 5863 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_template_class(n, templateParameterList, templateSpecializationArgumentList);
119103 : }
119104 :
119105 14427 : const SgGlobal * global_scope = isSgGlobal(this);
119106 14427 : if (symbol == NULL && global_scope != NULL) {
119107 6 : SgProject * project = SageInterface::getProject(global_scope);
119108 6 : if (project != NULL) {
119109 6 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119110 6 : assert(globalScopeAcrossFiles != NULL);
119111 6 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_template_class(n, templateParameterList, templateSpecializationArgumentList);
119112 : }
119113 : }
119114 :
119115 14427 : return symbol;
119116 : }
119117 :
119118 : SgTemplateTypedefSymbol*
119119 5544 : SgScopeStatement::lookup_template_typedef_symbol (const SgName& n) const
119120 : {
119121 5544 : ROSE_ASSERT (this != NULL);
119122 5544 : ROSE_ASSERT (p_symbol_table != NULL);
119123 :
119124 5544 : SgTemplateTypedefSymbol * symbol = p_symbol_table->find_template_typedef(n);
119125 :
119126 5544 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119127 5544 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119128 : {
119129 3096 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119130 3096 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119131 3096 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_template_typedef(n);
119132 : }
119133 :
119134 5544 : const SgGlobal * global_scope = isSgGlobal(this);
119135 5544 : if (symbol == NULL && global_scope != NULL) {
119136 0 : SgProject * project = SageInterface::getProject(global_scope);
119137 0 : if (project != NULL) {
119138 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119139 0 : assert(globalScopeAcrossFiles != NULL);
119140 0 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_template_typedef(n);
119141 : }
119142 : }
119143 :
119144 5544 : return symbol;
119145 : }
119146 :
119147 : // DQ (8/22/2012): If we have template arguments then we have a chance to disambiguate SgTemplateInstantiationDecl IR nodes based on the
119148 : // arguments which would otherwise require qulified names (which are difficult to robustly support using as the AST is being constructed).
119149 : SgClassSymbol*
119150 77889 : SgScopeStatement::lookup_nontemplate_class_symbol (const SgName& n, SgTemplateArgumentPtrList* templateArgumentsList) const
119151 : {
119152 77889 : ROSE_ASSERT (this != NULL);
119153 77889 : ROSE_ASSERT (p_symbol_table != NULL);
119154 :
119155 77889 : SgClassSymbol * symbol = p_symbol_table->find_nontemplate_class(n,templateArgumentsList);
119156 :
119157 77889 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119158 77889 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119159 : {
119160 6635 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119161 6635 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119162 6635 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_nontemplate_class(n,templateArgumentsList);
119163 : }
119164 :
119165 77889 : const SgGlobal * global_scope = isSgGlobal(this);
119166 77889 : if (symbol == NULL && global_scope != NULL) {
119167 13627 : SgProject * project = SageInterface::getProject(global_scope);
119168 13627 : if (project != NULL) {
119169 13627 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119170 13627 : assert(globalScopeAcrossFiles != NULL);
119171 13627 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_nontemplate_class(n,templateArgumentsList);
119172 : }
119173 : }
119174 :
119175 77889 : return symbol;
119176 : }
119177 :
119178 : SgTemplateFunctionSymbol*
119179 14250 : SgScopeStatement::lookup_template_function_symbol (const SgName& n, const SgType* t, SgTemplateParameterPtrList* templateParameterList) const
119180 : {
119181 14250 : ROSE_ASSERT (this != NULL);
119182 14250 : ROSE_ASSERT (p_symbol_table != NULL);
119183 :
119184 14250 : SgTemplateFunctionSymbol * symbol = p_symbol_table->find_template_function(n,t,templateParameterList);
119185 :
119186 14250 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119187 14250 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119188 : {
119189 3411 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119190 3411 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119191 3411 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_template_function(n,t,templateParameterList);
119192 : }
119193 :
119194 14250 : const SgGlobal * global_scope = isSgGlobal(this);
119195 14250 : if (symbol == NULL && global_scope != NULL) {
119196 4 : SgProject * project = SageInterface::getProject(global_scope);
119197 4 : if (project != NULL) {
119198 4 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119199 4 : assert(globalScopeAcrossFiles != NULL);
119200 4 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_template_function(n,t,templateParameterList);
119201 : }
119202 : }
119203 :
119204 14250 : return symbol;
119205 : }
119206 :
119207 : SgTemplateVariableSymbol*
119208 0 : SgScopeStatement::lookup_template_variable_symbol(const SgName& n, SgTemplateParameterPtrList* templateParameterList, SgTemplateArgumentPtrList* templateArgumentsList) const
119209 : {
119210 0 : ROSE_ASSERT (this != NULL);
119211 0 : ROSE_ASSERT (p_symbol_table != NULL);
119212 :
119213 0 : SgTemplateVariableSymbol * symbol = p_symbol_table->find_template_variable(n, templateParameterList, templateArgumentsList);
119214 :
119215 0 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119216 0 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119217 : {
119218 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119219 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119220 0 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_template_variable(n, templateParameterList, templateArgumentsList);
119221 : }
119222 :
119223 0 : const SgGlobal * global_scope = isSgGlobal(this);
119224 0 : if (symbol == NULL && global_scope != NULL) {
119225 0 : SgProject * project = SageInterface::getProject(global_scope);
119226 0 : if (project != NULL) {
119227 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119228 0 : assert(globalScopeAcrossFiles != NULL);
119229 0 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_template_variable(n, templateParameterList, templateArgumentsList);
119230 : }
119231 : }
119232 :
119233 0 : return symbol;
119234 : }
119235 :
119236 : SgFunctionSymbol*
119237 1436480 : SgScopeStatement::lookup_nontemplate_function_symbol (const SgName& n, const SgType* t, SgTemplateArgumentPtrList* templateArgumentsList) const
119238 : {
119239 1436480 : ROSE_ASSERT (this != NULL);
119240 1436480 : ROSE_ASSERT (p_symbol_table != NULL);
119241 :
119242 1436480 : SgFunctionSymbol * symbol = p_symbol_table->find_nontemplate_function(n,t,templateArgumentsList);
119243 :
119244 1436480 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119245 1436480 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119246 : {
119247 3106 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119248 3106 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119249 3106 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_nontemplate_function(n,t,templateArgumentsList);
119250 : }
119251 :
119252 1436480 : const SgGlobal * global_scope = isSgGlobal(this);
119253 1436480 : if (symbol == NULL && global_scope != NULL) {
119254 825515 : SgProject * project = SageInterface::getProject(global_scope);
119255 825515 : if (project != NULL) {
119256 825515 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119257 825515 : assert(globalScopeAcrossFiles != NULL);
119258 825515 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_nontemplate_function(n,t,templateArgumentsList);
119259 : }
119260 : }
119261 :
119262 1436480 : return symbol;
119263 : }
119264 :
119265 : SgTemplateMemberFunctionSymbol*
119266 82842 : SgScopeStatement::lookup_template_member_function_symbol (const SgName& n, const SgType* t, SgTemplateParameterPtrList* templateParameterList) const
119267 : {
119268 82842 : ROSE_ASSERT (this != NULL);
119269 82842 : ROSE_ASSERT (p_symbol_table != NULL);
119270 :
119271 82842 : SgTemplateMemberFunctionSymbol * symbol = p_symbol_table->find_template_member_function(n,t,templateParameterList);
119272 :
119273 82842 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119274 82842 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119275 : {
119276 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119277 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119278 0 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_template_member_function(n,t,templateParameterList);
119279 : }
119280 :
119281 82842 : const SgGlobal * global_scope = isSgGlobal(this);
119282 82842 : if (symbol == NULL && global_scope != NULL) {
119283 0 : SgProject * project = SageInterface::getProject(global_scope);
119284 0 : if (project != NULL) {
119285 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119286 0 : assert(globalScopeAcrossFiles != NULL);
119287 0 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_template_member_function(n,t,templateParameterList);
119288 : }
119289 : }
119290 :
119291 82842 : return symbol;
119292 : }
119293 :
119294 :
119295 : // SgMemberFunctionSymbol* SgScopeStatement::lookup_nontemplate_member_function_symbol (const SgName& n, const SgType* t) const
119296 : SgMemberFunctionSymbol*
119297 51331 : SgScopeStatement::lookup_nontemplate_member_function_symbol (const SgName& n, const SgType* t, SgTemplateArgumentPtrList* templateArgumentsList) const
119298 : {
119299 51331 : ROSE_ASSERT (this != NULL);
119300 51331 : ROSE_ASSERT (p_symbol_table != NULL);
119301 :
119302 51331 : SgMemberFunctionSymbol * symbol = p_symbol_table->find_nontemplate_member_function(n,t,templateArgumentsList);
119303 :
119304 51331 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119305 51331 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119306 : {
119307 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119308 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119309 0 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_nontemplate_member_function(n,t,templateArgumentsList);
119310 : }
119311 :
119312 51331 : const SgGlobal * global_scope = isSgGlobal(this);
119313 51331 : if (symbol == NULL && global_scope != NULL) {
119314 0 : SgProject * project = SageInterface::getProject(global_scope);
119315 0 : if (project != NULL) {
119316 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119317 0 : assert(globalScopeAcrossFiles != NULL);
119318 0 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_nontemplate_member_function(n,t,templateArgumentsList);
119319 : }
119320 : }
119321 :
119322 51331 : return symbol;
119323 : }
119324 :
119325 : SgAliasSymbol*
119326 17153 : SgScopeStatement::lookup_alias_symbol(const SgName& n, SgSymbol* sp) const
119327 : {
119328 17153 : ROSE_ASSERT (this != NULL);
119329 17153 : ROSE_ASSERT (p_symbol_table != NULL);
119330 :
119331 17153 : SgAliasSymbol * symbol = p_symbol_table->find_aliased_symbol(n,sp);
119332 :
119333 17153 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119334 17153 : if (symbol == NULL && namespaceDefinitionStatement != NULL)
119335 : {
119336 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119337 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119338 0 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find_aliased_symbol(n,sp);
119339 : }
119340 :
119341 17153 : const SgGlobal * global_scope = isSgGlobal(this);
119342 17153 : if (symbol == NULL && global_scope != NULL) {
119343 0 : SgProject * project = SageInterface::getProject(global_scope);
119344 0 : if (project != NULL) {
119345 0 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119346 0 : assert(globalScopeAcrossFiles != NULL);
119347 0 : symbol = globalScopeAcrossFiles->get_symbol_table()->find_aliased_symbol(n,sp);
119348 : }
119349 : }
119350 :
119351 17153 : return symbol;
119352 : }
119353 :
119354 : template<class T>
119355 18622753 : SgSymbol * SgScopeStatement::find_symbol_from_declaration(const T* node) const {
119356 18622753 : assert (p_symbol_table != NULL);
119357 :
119358 18622753 : SgSymbol * symbol = p_symbol_table->find(node);
119359 :
119360 18622753 : const SgNamespaceDefinitionStatement * namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119361 18622753 : if (symbol == NULL && namespaceDefinitionStatement != NULL) {
119362 191380 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119363 191380 : ROSE_ASSERT(globalNamespaceDefinitionStatement != nullptr);
119364 191380 : symbol = globalNamespaceDefinitionStatement->get_symbol_table()->find(node);
119365 : }
119366 :
119367 18622753 : const SgGlobal * global_scope = isSgGlobal(this);
119368 18622753 : if (symbol == NULL && global_scope != NULL) {
119369 4736520 : SgProject * project = SageInterface::getProject(global_scope);
119370 4736520 : if (project != NULL) {
119371 4736520 : SgGlobal * globalScopeAcrossFiles = project->get_globalScopeAcrossFiles();
119372 4736520 : assert(globalScopeAcrossFiles != NULL);
119373 4736520 : symbol = globalScopeAcrossFiles->get_symbol_table()->find(node);
119374 : }
119375 : }
119376 :
119377 18622753 : SgAliasSymbol * alias = isSgAliasSymbol(symbol);
119378 18622753 : if (alias != NULL) {
119379 0 : symbol = alias->get_alias();
119380 0 : ROSE_ASSERT(!isSgAliasSymbol(symbol));
119381 : }
119382 :
119383 18622753 : return symbol;
119384 : }
119385 :
119386 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
119387 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119388 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119389 : SgSymbol*
119390 0 : SgScopeStatement::first_any_symbol() const
119391 : {
119392 0 : assert (p_symbol_table != NULL);
119393 0 : return p_symbol_table->find_any();
119394 : }
119395 :
119396 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
119397 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119398 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119399 : SgVariableSymbol*
119400 0 : SgScopeStatement::first_variable_symbol() const
119401 : {
119402 0 : assert (p_symbol_table != NULL);
119403 0 : return p_symbol_table->find_variable();
119404 : }
119405 :
119406 : // DQ (1/30/2007): Added these back into ROSE.
119407 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119408 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119409 : SgClassSymbol*
119410 0 : SgScopeStatement::first_class_symbol() const
119411 : {
119412 0 : assert (p_symbol_table != NULL);
119413 0 : return p_symbol_table->find_class();
119414 : }
119415 : // DQ (1/30/2007): Added these back into ROSE.
119416 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119417 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119418 : SgFunctionSymbol*
119419 0 : SgScopeStatement::first_function_symbol() const
119420 : {
119421 0 : assert (p_symbol_table != NULL);
119422 0 : return p_symbol_table->find_function();
119423 : }
119424 :
119425 : // DQ (2/1/2007): Added to ROSE to make the interface consistent.
119426 : SgTypedefSymbol*
119427 0 : SgScopeStatement::first_typedef_symbol() const
119428 : {
119429 0 : ROSE_ASSERT (p_symbol_table != NULL);
119430 0 : return p_symbol_table->find_typedef();
119431 : }
119432 :
119433 : // DQ (2/1/2007): Added to ROSE to make the interface consistent.
119434 : SgEnumSymbol*
119435 0 : SgScopeStatement::first_enum_symbol() const
119436 : {
119437 0 : ROSE_ASSERT (p_symbol_table != NULL);
119438 0 : return p_symbol_table->find_enum();
119439 : }
119440 :
119441 : // DQ (2/1/2007): Added to ROSE to make the interface consistent.
119442 : SgEnumFieldSymbol*
119443 0 : SgScopeStatement::first_enum_field_symbol() const
119444 : {
119445 0 : ROSE_ASSERT (p_symbol_table != NULL);
119446 0 : return p_symbol_table->find_enum_field();
119447 : }
119448 :
119449 : // DQ (2/1/2007): Added to ROSE to make the interface consistent.
119450 : SgLabelSymbol*
119451 0 : SgScopeStatement::first_label_symbol() const
119452 : {
119453 0 : ROSE_ASSERT (p_symbol_table != NULL);
119454 0 : return p_symbol_table->find_label();
119455 : }
119456 :
119457 : // DQ (2/1/2007): Added to ROSE to make the interface consistent.
119458 : SgNamespaceSymbol*
119459 0 : SgScopeStatement::first_namespace_symbol() const
119460 : {
119461 0 : ROSE_ASSERT (p_symbol_table != NULL);
119462 0 : return p_symbol_table->find_namespace();
119463 : }
119464 :
119465 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
119466 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119467 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119468 : SgSymbol*
119469 0 : SgScopeStatement::next_any_symbol() const
119470 : {
119471 0 : assert (p_symbol_table != NULL);
119472 0 : return p_symbol_table->next_any();
119473 : }
119474 :
119475 : // DQ (9/7/2006): Previously removed functionality, restored by request from Beata at ANL.
119476 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119477 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119478 : SgVariableSymbol*
119479 0 : SgScopeStatement::next_variable_symbol() const
119480 : {
119481 : // use this function after lookup_XXX_symbol(const SgName&) or after first_XXX_symbol()
119482 0 : assert (p_symbol_table != NULL);
119483 0 : return p_symbol_table->next_variable();
119484 : }
119485 :
119486 : // DQ (1/30/2007): Added these back into ROSE.
119487 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119488 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119489 : SgClassSymbol*
119490 0 : SgScopeStatement::next_class_symbol() const
119491 : {
119492 0 : assert (p_symbol_table != NULL);
119493 0 : return p_symbol_table->next_class();
119494 : }
119495 :
119496 : // DQ (1/30/2007): Added these back into ROSE.
119497 : // DQ (5/22/2006): I would like to restrict support of a number of functions that I
119498 : // think are redundant with the simple lookup_symbol(const SgName& n) (above).
119499 : SgFunctionSymbol*
119500 0 : SgScopeStatement::next_function_symbol() const
119501 : {
119502 0 : assert (p_symbol_table != NULL);
119503 0 : return p_symbol_table->next_function();
119504 : }
119505 :
119506 : // DQ (2/1/2007): Added new member function to ROSE.
119507 : SgTypedefSymbol*
119508 0 : SgScopeStatement::next_typedef_symbol() const
119509 : {
119510 0 : assert (p_symbol_table != NULL);
119511 0 : return p_symbol_table->next_typedef();
119512 : }
119513 :
119514 : // DQ (2/1/2007): Added new member function to ROSE.
119515 : SgEnumSymbol*
119516 0 : SgScopeStatement::next_enum_symbol() const
119517 : {
119518 0 : assert (p_symbol_table != NULL);
119519 0 : return p_symbol_table->next_enum();
119520 : }
119521 :
119522 : // DQ (2/1/2007): Added new member function to ROSE.
119523 : SgEnumFieldSymbol*
119524 0 : SgScopeStatement::next_enum_field_symbol() const
119525 : {
119526 0 : assert (p_symbol_table != NULL);
119527 0 : return p_symbol_table->next_enum_field();
119528 : }
119529 :
119530 : // DQ (2/1/2007): Added new member function to ROSE.
119531 : SgLabelSymbol*
119532 0 : SgScopeStatement::next_label_symbol() const
119533 : {
119534 0 : assert (p_symbol_table != NULL);
119535 0 : return p_symbol_table->next_label();
119536 : }
119537 :
119538 : // DQ (2/1/2007): Added new member function to ROSE.
119539 : SgNamespaceSymbol*
119540 0 : SgScopeStatement::next_namespace_symbol() const
119541 : {
119542 0 : assert (p_symbol_table != NULL);
119543 0 : return p_symbol_table->next_namespace();
119544 : }
119545 :
119546 : // DQ (2/4/2007): Added new member function to ROSE.
119547 : SgTemplateSymbol*
119548 0 : SgScopeStatement::next_template_symbol() const
119549 : {
119550 0 : assert (p_symbol_table != NULL);
119551 0 : return p_symbol_table->next_template();
119552 : }
119553 :
119554 :
119555 :
119556 :
119557 : void
119558 0 : SgScopeStatement::print_symboltable( const std::string& str, ostream& os )
119559 : {
119560 0 : os << endl << "...SymTbl(" << str << ")... " << endl;
119561 : // printf ("ERROR: not supported in SAGE 3 \n");
119562 : // abort();
119563 : // p_symbol_table->print(os);
119564 0 : ROSE_ASSERT (p_symbol_table != NULL);
119565 0 : p_symbol_table->print("Called from SgScopeStatement::print_symboltable",V_SgSymbol);
119566 0 : }
119567 :
119568 :
119569 : void
119570 0 : SgScopeStatement::print_symboltable( const std::string& str, VariantT nodeType )
119571 : {
119572 0 : printf ("In SgScopeStatement::print_symboltable(label = %s): \n",str.c_str());
119573 0 : ROSE_ASSERT (p_symbol_table != NULL);
119574 0 : p_symbol_table->print("Called from SgScopeStatement::print_symboltable",nodeType);
119575 0 : }
119576 :
119577 :
119578 : void
119579 2 : SgScopeStatement::print_symboltable( const std::string& str )
119580 : {
119581 2 : printf ("In SgScopeStatement::print_symboltable(label = %s): \n",str.c_str());
119582 2 : ROSE_ASSERT (p_symbol_table != NULL);
119583 :
119584 : #if 0
119585 : p_symbol_table->print("Called from SgScopeStatement::print_symboltable",V_SgSymbol);
119586 : #else
119587 : // DQ (3/5/2018): If this is a namespace then test to make sure we are inserting the symbol into the correct scope.
119588 2 : const SgNamespaceDefinitionStatement* namespaceDefinitionStatement = isSgNamespaceDefinitionStatement(this);
119589 :
119590 2 : if (namespaceDefinitionStatement != NULL)
119591 : {
119592 0 : printf ("In SgScopeStatement::print_symboltable(): \n");
119593 0 : printf (" --- namespaceDefinitionStatement->get_symbol_table()->size() = %d \n",namespaceDefinitionStatement->get_symbol_table()->size());
119594 0 : printf (" --- namespaceDefinitionStatement->get_global_definition()->get_symbol_table()->size() = %d \n",namespaceDefinitionStatement->get_global_definition()->get_symbol_table()->size());
119595 0 : printf ("Symbols: \n");
119596 :
119597 0 : ROSE_ASSERT(namespaceDefinitionStatement->get_global_definition() != NULL);
119598 0 : const SgNamespaceDefinitionStatement* globalNamespaceDefinitionStatement = namespaceDefinitionStatement->get_global_definition();
119599 :
119600 0 : ROSE_ASSERT(namespaceDefinitionStatement != globalNamespaceDefinitionStatement);
119601 :
119602 0 : globalNamespaceDefinitionStatement->get_symbol_table()->print("Called from SgScopeStatement::print_symboltable",V_SgSymbol);
119603 : }
119604 : else
119605 : {
119606 : // Case of not a SgNamespaceDefinitionStatement.
119607 4 : p_symbol_table->print("Called from SgScopeStatement::print_symboltable",V_SgSymbol);
119608 : }
119609 : #endif
119610 :
119611 2 : }
119612 :
119613 : // DQ (7/17/2002) Added to support rewrite mechanism some scopes can only contain
119614 : // SgDeclarationStmt while others can contain any kind of SgStatement
119615 : bool
119616 1453430 : SgScopeStatement::containsOnlyDeclarations() const
119617 : {
119618 : // DQ (9/25/2009): This was a problem in an example reported by Keasler.
119619 1453430 : ROSE_ASSERT(this != NULL);
119620 :
119621 : // All but two of the derived classes contain one or more list of SgStatements while two of them
119622 : // contain a list of SgDeclarationStmt which complicates the design of a simple implementation of
119623 : // functions that operate on scopes generally.
119624 1453430 : bool returnValue = false;
119625 1453430 : switch ( variantT() )
119626 : {
119627 : // DQ (11/30/2007): Added more Fortran support.
119628 : case V_SgAssociateStatement:
119629 :
119630 : case V_SgBasicBlock:
119631 : case V_SgCatchOptionStmt:
119632 : case V_SgDoWhileStmt:
119633 : case V_SgForStatement:
119634 :
119635 : // DQ (3/26/2018): Added support for new C++11 IR node.
119636 : case V_SgRangeBasedForStatement:
119637 :
119638 : // Liao, 6/17/2008, upc_forall
119639 : case V_SgUpcForAllStatement:
119640 :
119641 : case V_SgFunctionDefinition:
119642 :
119643 : // DQ (11/27/2011): Adding more support for template declarations in the AST.
119644 : case V_SgTemplateFunctionDefinition:
119645 :
119646 : case V_SgIfStmt:
119647 : case V_SgSwitchStatement:
119648 : case V_SgWhileStmt:
119649 : case V_SgFortranDo:
119650 : case V_SgForAllStatement:
119651 : case V_SgCAFWithTeamStatement: //FMZ (2/18/2009)
119652 : returnValue = false;
119653 : break;
119654 :
119655 : // DQ (6/11/2011): Added support for new Template IR nodes.
119656 1368480 : case V_SgTemplateClassDefinition:
119657 :
119658 1368480 : case V_SgClassDefinition:
119659 1368480 : case V_SgTemplateInstantiationDefn:
119660 1368480 : case V_SgNamespaceDefinitionStatement:
119661 1368480 : case V_SgGlobal:
119662 1368480 : case V_SgFunctionParameterScope: // Rasmussen (09/24/2020): finishing implementation for Jovial
119663 1368480 : case V_SgModuleStatement:
119664 1368480 : case V_SgDeclarationScope:
119665 1368480 : returnValue = true;
119666 1368480 : break;
119667 :
119668 0 : default:
119669 0 : printf ("ERROR: default reached in switch (SgScopeStatement::containsOnlyDeclarations() is called from a %s) \n",class_name().c_str());
119670 0 : ROSE_ASSERT(false);
119671 : break;
119672 : }
119673 :
119674 1453430 : return returnValue;
119675 : }
119676 :
119677 :
119678 : bool
119679 0 : SgScopeStatement::supportsDefiningFunctionDeclaration()
119680 : {
119681 : // DQ (10/18/2006): Not all scopes permit function declarations. Any function prototype in a
119682 : // scope appropriate for a function definition triggers requirements for name qualification.
119683 : // This function returns true if the scope is appropriate for the definition of a function
119684 : // or member function (i.e. is a SgGlobal, SgClassDefinition, or SgNamespaceDefinitionStatement).
119685 :
119686 : // This is equivalent to the test for if the scope only permits declarations.
119687 0 : return containsOnlyDeclarations();
119688 : }
119689 :
119690 :
119691 : bool
119692 18371 : SgScopeStatement::statementExistsInScope ( SgStatement* statement )
119693 : {
119694 : // DQ (6/26/2013): Added test for if this statement already exists in the current scope.
119695 18371 : ROSE_ASSERT(statement != NULL);
119696 :
119697 18371 : bool result = false;
119698 18371 : if (containsOnlyDeclarations() == true)
119699 : {
119700 18371 : SgDeclarationStatementPtrList & declarationList = getDeclarationList();
119701 18371 : SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(statement);
119702 18371 : ROSE_ASSERT(declarationStatement != NULL);
119703 18371 : result = (find(declarationList.begin(),declarationList.end(),declarationStatement) != declarationList.end());
119704 : }
119705 : else
119706 : {
119707 0 : SgStatementPtrList & statementList = getStatementList();
119708 0 : result = (find(statementList.begin(),statementList.end(),statement) != statementList.end());
119709 : }
119710 :
119711 18371 : return result;
119712 : }
119713 :
119714 :
119715 : // DQ (7/17/2002) Added to support rewrite mechanism some scopes can only contain
119716 : // SgDeclarationStmt while others can contain any kind of SgStatement
119717 : void
119718 1319350 : SgScopeStatement::insertStatementInScope ( SgStatement* newTransformationStatement, bool atTop )
119719 : {
119720 : // Put the new statement at the front (without regard to any dependencies on declared types)
119721 :
119722 : // We have only debugged this case so far
119723 : // ROSE_ASSERT (atTop == true);
119724 :
119725 : #if 0
119726 : printf ("SgScopeStatement::insertStatementInScope(): newTransformationStatement = %p = %s atTop = %s \n",
119727 : newTransformationStatement,newTransformationStatement->class_name().c_str(),atTop ? "true" : "false");
119728 : #endif
119729 :
119730 1319350 : bool inFront = (atTop == true);
119731 1319350 : SgScopeStatement* currentScope = this;
119732 1319350 : if (atTop == true)
119733 : {
119734 94 : if (currentScope->containsOnlyDeclarations() == true)
119735 : {
119736 48 : SgDeclarationStatementPtrList & declarationList = currentScope->getDeclarationList();
119737 48 : SgDeclarationStatementPtrList::iterator declaration = declarationList.begin();
119738 48 : ROSE_ASSERT ( isSgDeclarationStatement(newTransformationStatement) != NULL );
119739 48 : SgDeclarationStatement* newDeclarationStatement = isSgDeclarationStatement(newTransformationStatement);
119740 :
119741 48 : ROSE_ASSERT(newDeclarationStatement != NULL);
119742 :
119743 : // DQ (6/26/2013): Added test for if this statement already exists in the current scope (declaration list).
119744 48 : ROSE_ASSERT(find(declarationList.begin(),declarationList.end(),newDeclarationStatement) == declarationList.end());
119745 :
119746 48 : unsigned oldSize = declarationList.size();
119747 : // if (declarationList.size() == 0)
119748 48 : if (declarationList.empty() == true)
119749 : {
119750 : // append_declaration(newTransformationStatement);
119751 : #ifndef REMOVE_SET_PARENT_FUNCTION
119752 : newDeclarationStatement->set_parent(currentScope);
119753 : #endif
119754 : // printf ("Case declarationList.size() == 0: parent of newDeclarationStatement may not be set properly (same for scope) \n");
119755 0 : declarationList.push_back(newDeclarationStatement);
119756 :
119757 : // DQ (6/24/2006): We have to handle this case explicitly
119758 0 : newDeclarationStatement->set_parent(currentScope);
119759 0 : ROSE_ASSERT(newDeclarationStatement->get_parent() != NULL);
119760 : }
119761 : else
119762 : {
119763 48 : ROSE_ASSERT ( *declaration != NULL );
119764 48 : insert_statement (*declaration,newTransformationStatement,inFront);
119765 :
119766 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119767 48 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119768 : }
119769 48 : ROSE_ASSERT (declarationList.size() == oldSize+1);
119770 :
119771 : #if 0
119772 : printf ("Exiting after call to insert_statement in SgScopeStatement::insertStatementInScope() \n");
119773 : ROSE_ASSERT(false);
119774 : #endif
119775 : }
119776 : else
119777 : {
119778 46 : SgStatementPtrList & statementList = currentScope->getStatementList();
119779 46 : SgStatementPtrList::iterator statement = statementList.begin();
119780 :
119781 : // DQ (12/29/2015): Added more debugging info.
119782 46 : if (find(statementList.begin(),statementList.end(),newTransformationStatement) != statementList.end())
119783 : {
119784 0 : printf ("ERROR: already present in scope: newTransformationStatement = %p = %s \n",newTransformationStatement,newTransformationStatement->class_name().c_str());
119785 : }
119786 :
119787 : // DQ (6/26/2013): Added test for if this statement already exists in the current scope (declaration list).
119788 46 : ROSE_ASSERT(find(statementList.begin(),statementList.end(),newTransformationStatement) == statementList.end());
119789 :
119790 : // if (statementList.size() == 0)
119791 46 : if (statementList.empty() == true)
119792 : {
119793 : #ifndef REMOVE_SET_PARENT_FUNCTION
119794 : newTransformationStatement->set_parent(currentScope);
119795 : #endif
119796 : // printf ("Case statementList.size() == 0: parent of newTransformationStatement may not be set properly (same for scope) \n");
119797 4 : statementList.push_back(newTransformationStatement);
119798 :
119799 : // DQ (6/24/2006): We have to handle this case explicitly
119800 4 : newTransformationStatement->set_parent(currentScope);
119801 4 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119802 : }
119803 : else
119804 : {
119805 42 : ROSE_ASSERT ( *statement != NULL );
119806 42 : insert_statement (*statement,newTransformationStatement,inFront);
119807 :
119808 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119809 42 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119810 : }
119811 : }
119812 :
119813 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119814 94 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119815 : }
119816 : else
119817 : {
119818 1319260 : if (currentScope->containsOnlyDeclarations() == true)
119819 : {
119820 1272790 : SgDeclarationStatementPtrList & declarationList = currentScope->getDeclarationList();
119821 1272790 : SgDeclarationStatementPtrList::reverse_iterator declaration = declarationList.rbegin();
119822 1272790 : ROSE_ASSERT ( isSgDeclarationStatement(newTransformationStatement) != NULL );
119823 1272790 : SgDeclarationStatement* newDeclarationStatement = isSgDeclarationStatement(newTransformationStatement);
119824 :
119825 1272790 : ROSE_ASSERT(newDeclarationStatement != NULL);
119826 :
119827 : // DQ (6/26/2013): Added test for if this statement already exists in the current scope (declaration list).
119828 1272790 : ROSE_ASSERT(find(declarationList.begin(),declarationList.end(),newDeclarationStatement) == declarationList.end());
119829 :
119830 1272790 : unsigned oldSize = declarationList.size();
119831 : // if (declarationList.size() == 0)
119832 1272790 : if (declarationList.empty() == true)
119833 : {
119834 : // append_declaration(newTransformationStatement);
119835 : #ifndef REMOVE_SET_PARENT_FUNCTION
119836 : newDeclarationStatement->set_parent(currentScope);
119837 : #endif
119838 : // printf ("Case declarationList.size() == 0: parent of newDeclarationStatement may not be set properly (same for scope) \n");
119839 14217 : declarationList.push_back(newDeclarationStatement);
119840 :
119841 : // DQ (6/24/2006): We have to handle this case explicitly
119842 14217 : newDeclarationStatement->set_parent(currentScope);
119843 14217 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119844 : }
119845 : else
119846 : {
119847 1258570 : ROSE_ASSERT ( *declaration != NULL );
119848 1258570 : insert_statement (*declaration,newTransformationStatement,inFront);
119849 :
119850 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119851 1258570 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119852 : }
119853 1272790 : ROSE_ASSERT (declarationList.size() == oldSize+1);
119854 :
119855 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119856 1272790 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119857 : #if 0
119858 : printf ("Exiting after call to insert_statement in SgScopeStatement::insertStatementInScope() \n");
119859 : ROSE_ASSERT(false);
119860 : #endif
119861 : }
119862 : else
119863 : {
119864 46469 : SgStatementPtrList & statementList = currentScope->getStatementList();
119865 46469 : SgStatementPtrList::reverse_iterator statement = statementList.rbegin();
119866 :
119867 : // DQ (12/29/2015): Added more debugging info.
119868 46469 : if (find(statementList.begin(),statementList.end(),newTransformationStatement) != statementList.end())
119869 : {
119870 0 : printf ("ERROR: already present in scope: newTransformationStatement = %p = %s \n",newTransformationStatement,newTransformationStatement->class_name().c_str());
119871 : }
119872 :
119873 : // DQ (6/26/2013): Added test for if this statement already exists in the current scope (declaration list).
119874 46469 : ROSE_ASSERT(find(statementList.begin(),statementList.end(),newTransformationStatement) == statementList.end());
119875 :
119876 : // if (statementList.size() == 0)
119877 46469 : if (statementList.empty() == true)
119878 : {
119879 : #ifndef REMOVE_SET_PARENT_FUNCTION
119880 : newTransformationStatement->set_parent(currentScope);
119881 : #endif
119882 : // printf ("Case statementList.size() == 0: parent of newTransformationStatement may not be set properly (same for scope) \n");
119883 26063 : statementList.push_back(newTransformationStatement);
119884 :
119885 : // DQ (6/24/2006): We have to handle this case explicitly
119886 26063 : newTransformationStatement->set_parent(currentScope);
119887 26063 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119888 : }
119889 : else
119890 : {
119891 20406 : ROSE_ASSERT ( *statement != NULL );
119892 : #if 0
119893 : printf ("In SgScopeStatement::insertStatementInScope(): calling insert_statement(): this = %p = %s \n",this,this->class_name().c_str());
119894 : SgFunctionDefinition* functionDefinition = isSgFunctionDefinition(this);
119895 : if (functionDefinition != NULL)
119896 : {
119897 : printf (" --- functionDefinition->get_body() = %p \n",functionDefinition->get_body());
119898 : }
119899 :
119900 : printf (" --- *statement = %p = %s \n",*statement,(*statement)->class_name().c_str());
119901 : printf (" --- newTransformationStatement = %p = %s \n",newTransformationStatement,newTransformationStatement->class_name().c_str());
119902 : printf (" --- inFront = %s \n",inFront ? "true" : "false");
119903 : #endif
119904 : #if 1
119905 : // DQ (3/27/2021): The base class implementation of insert_statement is being called by mistake, use the this poitner explicitly.
119906 20406 : insert_statement (*statement,newTransformationStatement,inFront);
119907 : #else
119908 : // this->insert_statement (*statement,newTransformationStatement,inFront);
119909 : if (functionDefinition != NULL)
119910 : {
119911 : #if 1
119912 : printf ("Found functionDefinition, so insert new statement into the function body \n");
119913 : #endif
119914 : SgBasicBlock* body = functionDefinition->get_body();
119915 : ROSE_ASSERT(body != NULL);
119916 : #if 1
119917 : printf ("Skipping call to body->insert_statement \n");
119918 : #endif
119919 : // body->insert_statement (*statement,newTransformationStatement,inFront);
119920 :
119921 : // DQ (3/28/2021): Set the parent to pass the assertion below.
119922 : newTransformationStatement->set_parent(body);
119923 : }
119924 : else
119925 : {
119926 : this->insert_statement (*statement,newTransformationStatement,inFront);
119927 : }
119928 : #endif
119929 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119930 20406 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119931 : }
119932 : }
119933 : }
119934 :
119935 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
119936 1319350 : ROSE_ASSERT(newTransformationStatement->get_parent() != NULL);
119937 1319350 : }
119938 :
119939 :
119940 : // DQ (7/17/2002) Added to support rewrite mechanism some scopes can only contain
119941 : // SgDeclarationStmt while others can contain any kind of SgStatement
119942 : SgDeclarationStatementPtrList &
119943 1305380 : SgScopeStatement::getDeclarationList ()
119944 : // SgScopeStatement::getDeclarationList ( SgScopeStatement* currentScope )
119945 : {
119946 : // Supporting function for SynthesizedAttributeBaseClassType::insertAtTopOfScope(). This should
119947 : // perhaps be moved to the SgScopeStatement object at some point.
119948 :
119949 1305380 : SgScopeStatement* currentScope = this;
119950 1305380 : ROSE_ASSERT (currentScope != NULL);
119951 :
119952 1305380 : SgDeclarationStatementPtrList* currentStatementList = NULL;
119953 1305380 : switch ( currentScope->variantT() )
119954 : {
119955 : // DQ (6/11/2011): Added support for new template IR nodes.
119956 43263 : case V_SgTemplateClassDefinition:
119957 43263 : case V_SgClassDefinition:
119958 43263 : {
119959 43263 : SgClassDefinition* classDefinitionScope = isSgClassDefinition(currentScope);
119960 43263 : ROSE_ASSERT (classDefinitionScope != NULL);
119961 43263 : currentStatementList = &(classDefinitionScope->get_members());
119962 43263 : break;
119963 : }
119964 :
119965 26749 : case V_SgTemplateInstantiationDefn:
119966 26749 : {
119967 26749 : SgTemplateInstantiationDefn* templateInstantiationDefinitionScope = isSgTemplateInstantiationDefn(currentScope);
119968 26749 : ROSE_ASSERT (templateInstantiationDefinitionScope != NULL);
119969 26749 : currentStatementList = &(templateInstantiationDefinitionScope->get_members());
119970 26749 : break;
119971 : }
119972 :
119973 1196290 : case V_SgGlobal:
119974 1196290 : {
119975 1196290 : SgGlobal* globalScope = isSgGlobal(currentScope);
119976 1196290 : ROSE_ASSERT (globalScope != NULL);
119977 1196290 : currentStatementList = &(globalScope->get_declarations());
119978 1196290 : break;
119979 : }
119980 :
119981 0 : case V_SgFunctionParameterScope:
119982 0 : {
119983 0 : SgFunctionParameterScope* paramScope = isSgFunctionParameterScope(currentScope);
119984 0 : ROSE_ASSERT (paramScope != NULL);
119985 0 : currentStatementList = &(paramScope->get_declarations());
119986 0 : break;
119987 : }
119988 :
119989 39083 : case V_SgNamespaceDefinitionStatement:
119990 39083 : {
119991 39083 : SgNamespaceDefinitionStatement* namespaceScope = isSgNamespaceDefinitionStatement(currentScope);
119992 39083 : ROSE_ASSERT (namespaceScope != NULL);
119993 39083 : currentStatementList = &(namespaceScope->get_declarations());
119994 39083 : break;
119995 : }
119996 : #if 1
119997 0 : case V_SgNonrealDecl:
119998 0 : case V_SgDeclarationScope:
119999 0 : {
120000 : // TV (09/16/2018): (ROSE-1378) TODO
120001 0 : ROSE_ASSERT(!"ROSE-1378");
120002 : break;
120003 : }
120004 : #endif
120005 0 : default:
120006 0 : printf ("ERROR: default reached in switch (getDeclarationList()) currentScope = %s \n",currentScope->sage_class_name());
120007 0 : printf ("Note: this function is not defined for all IR nodes derived from SgScopeStatement (use SgScopeStatement::containsOnlyDeclarations() to check)\n");
120008 0 : ROSE_ASSERT(false);
120009 : break;
120010 : }
120011 :
120012 1305380 : return *currentStatementList;
120013 : }
120014 :
120015 : const SgDeclarationStatementPtrList &
120016 14779 : SgScopeStatement::getDeclarationList () const
120017 : // SgScopeStatement::getDeclarationList ( SgScopeStatement* currentScope )
120018 : {
120019 : // Supporting function for SynthesizedAttributeBaseClassType::insertAtTopOfScope(). This should
120020 : // perhaps be moved to the SgScopeStatement object at some point.
120021 :
120022 14779 : const SgScopeStatement* currentScope = this;
120023 14779 : ROSE_ASSERT (currentScope != NULL);
120024 :
120025 : // SgDeclarationStatementPtrList* currentStatementList = NULL;
120026 14779 : switch ( currentScope->variantT() )
120027 : {
120028 : // DQ (6/11/2011): Added support for new template IR nodes.
120029 9786 : case V_SgTemplateClassDefinition:
120030 9786 : case V_SgClassDefinition:
120031 9786 : {
120032 9786 : const SgClassDefinition* classDefinitionScope = isSgClassDefinition(currentScope);
120033 9786 : ROSE_ASSERT (classDefinitionScope != NULL);
120034 : // currentStatementList = &(classDefinitionScope->get_members());
120035 9786 : return classDefinitionScope->get_members();
120036 3812 : break;
120037 : }
120038 :
120039 3812 : case V_SgTemplateInstantiationDefn:
120040 3812 : {
120041 3812 : const SgTemplateInstantiationDefn* templateInstantiationDefinitionScope = isSgTemplateInstantiationDefn(currentScope);
120042 3812 : ROSE_ASSERT (templateInstantiationDefinitionScope != NULL);
120043 : // currentStatementList = &(templateInstantiationDefinitionScope->get_members());
120044 3812 : return templateInstantiationDefinitionScope->get_members();
120045 366 : break;
120046 : }
120047 :
120048 366 : case V_SgGlobal:
120049 366 : {
120050 366 : const SgGlobal* globalScope = isSgGlobal(currentScope);
120051 366 : ROSE_ASSERT (globalScope != NULL);
120052 366 : return globalScope->get_declarations();
120053 0 : break;
120054 : }
120055 :
120056 0 : case V_SgFunctionParameterScope:
120057 0 : {
120058 0 : const SgFunctionParameterScope* paramScope = isSgFunctionParameterScope(currentScope);
120059 0 : ROSE_ASSERT (paramScope != NULL);
120060 0 : return paramScope->get_declarations();
120061 815 : break;
120062 : }
120063 :
120064 815 : case V_SgNamespaceDefinitionStatement:
120065 815 : {
120066 815 : const SgNamespaceDefinitionStatement* namespaceScope = isSgNamespaceDefinitionStatement(currentScope);
120067 815 : ROSE_ASSERT (namespaceScope != NULL);
120068 : // currentStatementList = &(namespaceScope->get_declarations());
120069 815 : return namespaceScope->get_declarations();
120070 0 : break;
120071 : }
120072 :
120073 0 : case V_SgNonrealDecl:
120074 0 : case V_SgDeclarationScope:
120075 0 : {
120076 : // TV (09/16/2018): (ROSE-1378) TODO
120077 0 : ROSE_ASSERT(!"ROSE-1378");
120078 : break;
120079 : }
120080 :
120081 0 : default:
120082 0 : printf ("ERROR: default reached in switch (getDeclarationList() const) currentScope = %s \n",currentScope->sage_class_name());
120083 0 : printf ("Note: this function is not defined for all IR nodes derived from SgScopeStatement (use SgScopeStatement::containsOnlyDeclarations() to check)\n");
120084 0 : ROSE_ASSERT(false);
120085 : break;
120086 : }
120087 :
120088 : printf ("This should be unreachable code! \n");
120089 : ROSE_ASSERT(false);
120090 : // return *currentStatementList;
120091 : static SgDeclarationStatementPtrList defaultList;
120092 : return defaultList;
120093 : }
120094 :
120095 : // DQ (7/17/2002) Added to support rewrite mechanism some scopes can only contain
120096 : // SgDeclarationStmt while others can contain any kind of SgStatement
120097 : SgStatementPtrList &
120098 66702 : SgScopeStatement::getStatementList ()
120099 : {
120100 : // Supporting function for SynthesizedAttributeBaseClassType::insertAtTopOfScope(). This should
120101 : // perhaps be moved to the SgScopeStatement object at some point.
120102 :
120103 : // If this were a virtual member function then this would be far simpler :-).
120104 :
120105 66702 : SgScopeStatement* currentScope = this;
120106 66702 : ROSE_ASSERT (currentScope != NULL);
120107 :
120108 66702 : SgStatementPtrList* currentStatementList = NULL;
120109 66702 : switch ( currentScope->variantT() )
120110 : {
120111 66698 : case V_SgBasicBlock:
120112 66698 : {
120113 66698 : SgBasicBlock* basicBlock = isSgBasicBlock(currentScope);
120114 66698 : ROSE_ASSERT (basicBlock != NULL);
120115 66698 : currentStatementList = &(basicBlock->get_statements());
120116 66698 : break;
120117 : }
120118 :
120119 0 : case V_SgCatchOptionStmt:
120120 0 : {
120121 0 : SgCatchOptionStmt* catchOptionScope = isSgCatchOptionStmt(currentScope);
120122 0 : ROSE_ASSERT (catchOptionScope != NULL);
120123 0 : ROSE_ASSERT (catchOptionScope->get_body() != NULL);
120124 0 : currentStatementList = &(SageInterface::ensureBasicBlockAsBodyOfCatch(catchOptionScope)->getStatementList());
120125 0 : break;
120126 : }
120127 :
120128 : // DQ (6/11/2011): Added support for new template IR nodes.
120129 0 : case V_SgTemplateClassDefinition:
120130 : // DQ (1/30/2007): Added this case!
120131 0 : case V_SgClassDefinition:
120132 0 : {
120133 0 : printf ("case SgClassDefinition in SgScopeStatement::getStatementList() called by mistake, use SgScopeStatement::getDeclarationList() instead. \n");
120134 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120135 0 : ROSE_ASSERT(false);
120136 : break;
120137 : }
120138 :
120139 0 : case V_SgDoWhileStmt:
120140 0 : {
120141 0 : SgDoWhileStmt* doWhileScope = isSgDoWhileStmt(currentScope);
120142 0 : ROSE_ASSERT (doWhileScope != NULL);
120143 0 : ROSE_ASSERT (doWhileScope->get_body() != NULL);
120144 0 : currentStatementList = &(SageInterface::ensureBasicBlockAsBodyOfDoWhile(doWhileScope)->getStatementList());
120145 0 : break;
120146 : }
120147 :
120148 0 : case V_SgForStatement:
120149 0 : {
120150 0 : SgForStatement* forScope = isSgForStatement(currentScope);
120151 0 : ROSE_ASSERT (forScope != NULL);
120152 : // Liao, 9/29/2008, This function could be called during parsing and
120153 : // the loop body is not yet filled up
120154 : // ROSE_ASSERT (forScope->get_loop_body() != NULL);
120155 : // Should this be defined given that there are two SgBasicBlock objects in a SgForStatement
120156 : // currentStatementList = forScope->get_init_stmt();
120157 0 : currentStatementList = &(SageInterface::ensureBasicBlockAsBodyOfFor(forScope)->getStatementList());
120158 0 : break;
120159 : }
120160 :
120161 : // DQ (11/27/2011): Adding more support for template declarations in the AST.
120162 0 : case V_SgTemplateFunctionDefinition:
120163 0 : case V_SgFunctionDefinition:
120164 0 : {
120165 0 : SgFunctionDefinition* functionScope = isSgFunctionDefinition(currentScope);
120166 0 : ROSE_ASSERT (functionScope != NULL);
120167 0 : ROSE_ASSERT (functionScope->get_body() != NULL);
120168 0 : currentStatementList = &(functionScope->get_body()->getStatementList());
120169 0 : break;
120170 : }
120171 :
120172 : // DQ (1/30/2007): Added this case!
120173 0 : case V_SgTemplateInstantiationDefn:
120174 0 : {
120175 0 : printf ("case SgTemplateInstantiationDefn in SgScopeStatement::getStatementList() called by mistake, use SgScopeStatement::getDeclarationList() instead. \n");
120176 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120177 0 : ROSE_ASSERT(false);
120178 : break;
120179 : }
120180 :
120181 : // DQ (1/30/2007): Added this case!
120182 0 : case V_SgGlobal:
120183 0 : {
120184 0 : printf ("case SgGlobal in SgScopeStatement::getStatementList() called by mistake, use SgScopeStatement::getDeclarationList() instead. \n");
120185 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120186 :
120187 0 : ROSE_ASSERT(false);
120188 : break;
120189 : }
120190 :
120191 0 : case V_SgIfStmt:
120192 0 : {
120193 0 : SgIfStmt* ifStatement = isSgIfStmt(currentScope);
120194 0 : ROSE_ASSERT (ifStatement != NULL);
120195 :
120196 : #if 0
120197 : // Merge the different lists from the true and false blocks (this might not
120198 : // provide the correct semantics for some uses of the final list).
120199 : ROSE_ASSERT (ifStatement->true_body() != NULL);
120200 : currentStatementList = new SgStatementPtrList (ifStatement->true_body()->getStatementList());
120201 : ROSE_ASSERT (ifStatement->false_body() != NULL);
120202 : currentStatementList->merge(ifStatement->false_body()->getStatementList());
120203 : #endif
120204 :
120205 0 : printf ("getStatementList() return value not defined for SgIfStmt containing true and false bodies (use generateStatementList() to form copy of merges lists) \n");
120206 0 : printf ("NOTE: This error has been generated when C99 code was incorrectly assumed to be C89 (e.g. compiled without the correct flag) code (see test2012_104.c on edg4x branch)\n");
120207 0 : ROSE_ASSERT(false);
120208 : break;
120209 : }
120210 :
120211 : // DQ (1/30/2007): Added this case!
120212 0 : case V_SgNamespaceDefinitionStatement:
120213 0 : {
120214 0 : printf ("case SgNamespaceDefinitionStatement in SgScopeStatement::getStatementList() called by mistake, use SgScopeStatement::getDeclarationList() instead. \n");
120215 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120216 0 : ROSE_ASSERT(false);
120217 : break;
120218 : }
120219 :
120220 0 : case V_SgSwitchStatement:
120221 0 : {
120222 0 : SgSwitchStatement* switchStatement = isSgSwitchStatement(currentScope);
120223 0 : ROSE_ASSERT (switchStatement != NULL);
120224 0 : ROSE_ASSERT (switchStatement->get_body() != NULL);
120225 0 : currentStatementList = &(SageInterface::ensureBasicBlockAsBodyOfSwitch(switchStatement)->getStatementList());
120226 0 : break;
120227 : }
120228 :
120229 0 : case V_SgWhileStmt:
120230 0 : {
120231 0 : SgWhileStmt* whileStatement = isSgWhileStmt(currentScope);
120232 0 : ROSE_ASSERT (whileStatement != NULL);
120233 0 : ROSE_ASSERT (whileStatement->get_body() != NULL);
120234 0 : currentStatementList = &(SageInterface::ensureBasicBlockAsBodyOfWhile(whileStatement)->getStatementList());
120235 0 : break;
120236 : }
120237 :
120238 4 : case V_SgFortranDo:
120239 4 : {
120240 4 : SgFortranDo* doStatement = isSgFortranDo(currentScope);
120241 4 : ROSE_ASSERT (doStatement != NULL);
120242 4 : ROSE_ASSERT (doStatement->get_body() != NULL);
120243 4 : currentStatementList = &(doStatement->get_body()->getStatementList());
120244 4 : break;
120245 : }
120246 :
120247 0 : default:
120248 0 : printf ("ERROR: default reached in switch (getStatementList()) currentScope = %s \n",currentScope->sage_class_name());
120249 0 : printf ("Note: this function is not defined for all IR nodes derived from SgScopeStatement (use SgScopeStatement::containsOnlyDeclarations() to check)\n");
120250 0 : ROSE_ASSERT(false);
120251 : break;
120252 : }
120253 :
120254 66702 : return *currentStatementList;
120255 : }
120256 :
120257 :
120258 : // DQ (10/6/2007): Added const version of this function to support const version of generateStatementList()
120259 : const SgStatementPtrList &
120260 34427 : SgScopeStatement::getStatementList () const
120261 : {
120262 : // Supporting function for SynthesizedAttributeBaseClassType::insertAtTopOfScope(). This should
120263 : // perhaps be moved to the SgScopeStatement object at some point.
120264 :
120265 : // If this were a virtual member function then this would be far simpler :-).
120266 :
120267 34427 : const SgScopeStatement* currentScope = this;
120268 34427 : ROSE_ASSERT (currentScope != NULL);
120269 :
120270 34427 : static const SgStatementPtrList emptyStatementList;
120271 :
120272 : // SgStatementPtrList* currentStatementList = NULL;
120273 34427 : switch ( currentScope->variantT() )
120274 : {
120275 18987 : case V_SgBasicBlock:
120276 18987 : {
120277 18987 : const SgBasicBlock* basicBlock = isSgBasicBlock(currentScope);
120278 18987 : ROSE_ASSERT (basicBlock != NULL);
120279 : // currentStatementList = &(basicBlock->get_statements());
120280 18987 : return basicBlock->get_statements();
120281 568 : break;
120282 : }
120283 :
120284 568 : case V_SgCatchOptionStmt:
120285 568 : {
120286 568 : const SgCatchOptionStmt* catchOptionScope = isSgCatchOptionStmt(currentScope);
120287 568 : ROSE_ASSERT (catchOptionScope != NULL);
120288 568 : ROSE_ASSERT (catchOptionScope->get_body() != NULL);
120289 : // currentStatementList = &(catchOptionScope->get_body()->getStatementList());
120290 568 : return isSgBasicBlock(catchOptionScope->get_body()) ? isSgBasicBlock(catchOptionScope->get_body())->getStatementList() : emptyStatementList;
120291 0 : break;
120292 : }
120293 :
120294 : // DQ (6/11/2011): Added support for new template IR nodes.
120295 0 : case V_SgTemplateClassDefinition:
120296 : // DQ (1/30/2007): Added this case!
120297 0 : case V_SgClassDefinition:
120298 0 : {
120299 0 : printf ("case SgClassDefinition in SgScopeStatement::getStatementList() const called by mistake, use SgScopeStatement::getDeclarationList() const instead. \n");
120300 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120301 0 : ROSE_ASSERT(false);
120302 : break;
120303 : }
120304 :
120305 43 : case V_SgDoWhileStmt:
120306 43 : {
120307 43 : const SgDoWhileStmt* doWhileScope = isSgDoWhileStmt(currentScope);
120308 43 : ROSE_ASSERT (doWhileScope != NULL);
120309 43 : ROSE_ASSERT (doWhileScope->get_body() != NULL);
120310 : // currentStatementList = &(doWhileScope->get_body()->getStatementList());
120311 43 : return isSgBasicBlock(doWhileScope->get_body()) ? isSgBasicBlock(doWhileScope->get_body())->getStatementList() : emptyStatementList;
120312 541 : break;
120313 : }
120314 :
120315 541 : case V_SgForStatement:
120316 541 : {
120317 541 : const SgForStatement* forScope = isSgForStatement(currentScope);
120318 541 : ROSE_ASSERT (forScope != NULL);
120319 541 : ROSE_ASSERT (forScope->get_loop_body() != NULL);
120320 : // Should this be defined given that there are two SgBasicBlock objects in a SgForStatement
120321 : // currentStatementList = forScope->get_init_stmt();
120322 : // currentStatementList = &(forScope->get_loop_body()->getStatementList());
120323 541 : return isSgBasicBlock(forScope->get_loop_body()) ? isSgBasicBlock(forScope->get_loop_body())->getStatementList() : emptyStatementList;
120324 0 : break;
120325 : }
120326 :
120327 : // DQ (3/26/2018): Added support for new C++11 IR node.
120328 0 : case V_SgRangeBasedForStatement:
120329 0 : {
120330 0 : const SgRangeBasedForStatement* forScope = isSgRangeBasedForStatement(currentScope);
120331 0 : ROSE_ASSERT (forScope != NULL);
120332 0 : ROSE_ASSERT (forScope->get_loop_body() != NULL);
120333 : // Should this be defined given that there are two SgBasicBlock objects in a SgForStatement
120334 : // currentStatementList = forScope->get_init_stmt();
120335 : // currentStatementList = &(forScope->get_loop_body()->getStatementList());
120336 0 : return isSgBasicBlock(forScope->get_loop_body()) ? isSgBasicBlock(forScope->get_loop_body())->getStatementList() : emptyStatementList;
120337 0 : break;
120338 : }
120339 :
120340 : // Liao, 6/17/2008, upc_forall statement
120341 0 : case V_SgUpcForAllStatement:
120342 0 : {
120343 0 : const SgUpcForAllStatement* forScope = isSgUpcForAllStatement(currentScope);
120344 0 : ROSE_ASSERT (forScope != NULL);
120345 0 : ROSE_ASSERT (forScope->get_loop_body() != NULL);
120346 : // Should this be defined given that there are two SgBasicBlock objects in a SgForStatement
120347 : // currentStatementList = forScope->get_init_stmt();
120348 : // currentStatementList = &(forScope->get_loop_body()->getStatementList());
120349 0 : return isSgBasicBlock(forScope->get_loop_body()) ? isSgBasicBlock(forScope->get_loop_body())->getStatementList() : emptyStatementList;
120350 13958 : break;
120351 : }
120352 :
120353 : // DQ (11/27/2011): Adding more support for template declarations in the AST.
120354 13958 : case V_SgTemplateFunctionDefinition:
120355 13958 : case V_SgFunctionDefinition:
120356 13958 : {
120357 13958 : const SgFunctionDefinition* functionScope = isSgFunctionDefinition(currentScope);
120358 13958 : ROSE_ASSERT (functionScope != NULL);
120359 13958 : ROSE_ASSERT (functionScope->get_body() != NULL);
120360 : // currentStatementList = &(functionScope->get_body()->getStatementList());
120361 13958 : return functionScope->get_body()->getStatementList();
120362 0 : break;
120363 : }
120364 :
120365 : // DQ (1/30/2007): Added this case!
120366 0 : case V_SgTemplateInstantiationDefn:
120367 0 : {
120368 0 : printf ("case SgTemplateInstantiationDefn in SgScopeStatement::getStatementList() const called by mistake, use SgScopeStatement::getDeclarationList() const instead. \n");
120369 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120370 0 : ROSE_ASSERT(false);
120371 : break;
120372 : }
120373 :
120374 : // DQ (1/30/2007): Added this case!
120375 0 : case V_SgGlobal:
120376 0 : {
120377 0 : printf ("case SgGlobal in SgScopeStatement::getStatementList() const called by mistake, use SgScopeStatement::getDeclarationList() const instead. \n");
120378 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120379 :
120380 0 : ROSE_ASSERT(false);
120381 : break;
120382 : }
120383 :
120384 0 : case V_SgIfStmt:
120385 0 : {
120386 0 : const SgIfStmt* ifStatement = isSgIfStmt(currentScope);
120387 0 : ROSE_ASSERT (ifStatement != NULL);
120388 :
120389 : #if 0
120390 : // Merge the different lists from the true and false blocks (this might not
120391 : // provide the correct semantics for some uses of the final list).
120392 : ROSE_ASSERT (ifStatement->true_body() != NULL);
120393 : currentStatementList = new SgStatementPtrList (ifStatement->true_body()->getStatementList());
120394 : ROSE_ASSERT (ifStatement->false_body() != NULL);
120395 : currentStatementList->merge(ifStatement->false_body()->getStatementList());
120396 : #endif
120397 :
120398 0 : printf ("getStatementList() const return value not defined for SgIfStmt containing true and false bodies (use generateStatementList() const to form copy of merges lists) \n");
120399 0 : ROSE_ASSERT(false);
120400 : break;
120401 : }
120402 :
120403 : // DQ (1/30/2007): Added this case!
120404 0 : case V_SgNamespaceDefinitionStatement:
120405 0 : {
120406 0 : printf ("case SgNamespaceDefinitionStatement in SgScopeStatement::getStatementList() const called by mistake, use SgScopeStatement::getDeclarationList() const instead. \n");
120407 0 : printf (" this scope contains a list of SgDeclarationStatement objects not a list of SgStatement objects (critical difference since we return a reference to the internal list \n");
120408 0 : ROSE_ASSERT(false);
120409 : break;
120410 : }
120411 :
120412 0 : case V_SgSwitchStatement:
120413 0 : {
120414 0 : const SgSwitchStatement* switchStatement = isSgSwitchStatement(currentScope);
120415 0 : ROSE_ASSERT (switchStatement != NULL);
120416 0 : ROSE_ASSERT (switchStatement->get_body() != NULL);
120417 : // currentStatementList = &(switchStatement->get_body()->getStatementList());
120418 0 : return (isSgBasicBlock(switchStatement->get_body()) != NULL) ? isSgBasicBlock(switchStatement->get_body())->getStatementList() : emptyStatementList;
120419 309 : break;
120420 : }
120421 :
120422 309 : case V_SgWhileStmt:
120423 309 : {
120424 309 : const SgWhileStmt* whileStatement = isSgWhileStmt(currentScope);
120425 309 : ROSE_ASSERT (whileStatement != NULL);
120426 309 : ROSE_ASSERT (whileStatement->get_body() != NULL);
120427 : // currentStatementList = &(whileStatement->get_body()->getStatementList());
120428 309 : return (isSgBasicBlock(whileStatement->get_body()) != NULL) ? isSgBasicBlock(whileStatement->get_body())->getStatementList() : emptyStatementList;
120429 0 : break;
120430 : }
120431 :
120432 0 : case V_SgAssociateStatement:
120433 0 : {
120434 : // Not clear if we should include the list of SgVariableDeclarations in this list or not!
120435 0 : const SgAssociateStatement* associateStatement = isSgAssociateStatement(currentScope);
120436 0 : ROSE_ASSERT (associateStatement != NULL);
120437 0 : ROSE_ASSERT (associateStatement->get_body() != NULL);
120438 0 : return associateStatement->get_body()->getStatementList();
120439 21 : break;
120440 : }
120441 :
120442 21 : case V_SgFortranDo:
120443 21 : {
120444 21 : const SgFortranDo* doStatement = isSgFortranDo(currentScope);
120445 21 : ROSE_ASSERT (doStatement != NULL);
120446 21 : ROSE_ASSERT (doStatement->get_body() != NULL);
120447 21 : return doStatement->get_body()->getStatementList();
120448 0 : break;
120449 : }
120450 :
120451 0 : case V_SgForAllStatement:
120452 0 : {
120453 0 : const SgForAllStatement* forAllScope = isSgForAllStatement(currentScope);
120454 0 : ROSE_ASSERT (forAllScope != NULL);
120455 0 : ROSE_ASSERT (forAllScope->get_body() != NULL);
120456 : // Should this be defined given that there are two SgBasicBlock objects in a SgForStatement
120457 : // currentStatementList = forScope->get_init_stmt();
120458 : // currentStatementList = &(forScope->get_loop_body()->getStatementList());
120459 0 : return forAllScope->get_body()->getStatementList();
120460 0 : break;
120461 : }
120462 :
120463 : // FMZ (CoArray with team)
120464 0 : case V_SgCAFWithTeamStatement:
120465 0 : {
120466 0 : const SgCAFWithTeamStatement* teamScope = isSgCAFWithTeamStatement(currentScope);
120467 0 : ROSE_ASSERT (teamScope != NULL);
120468 0 : ROSE_ASSERT (teamScope->get_body() != NULL);
120469 0 : return isSgBasicBlock(teamScope->get_body()) ? isSgBasicBlock(teamScope->get_body())->getStatementList() : emptyStatementList;
120470 0 : break;
120471 : }
120472 :
120473 0 : default:
120474 0 : printf ("ERROR: default reached in switch (getStatementList() const) currentScope = %s \n",currentScope->sage_class_name());
120475 0 : printf ("Note: this function is not defined for all IR nodes derived from SgScopeStatement (use SgScopeStatement::containsOnlyDeclarations() to check)\n");
120476 0 : ROSE_ASSERT(false);
120477 : break;
120478 : }
120479 :
120480 : printf ("This should be unreachable code! \n");
120481 : ROSE_ASSERT(false);
120482 : // return *currentStatementList;
120483 : // return SgStatementPtrList();
120484 : static SgStatementPtrList defaultList;
120485 : return defaultList;
120486 : }
120487 :
120488 :
120489 : const SgStatementPtrList
120490 49000 : SgScopeStatement::generateStatementList() const
120491 : {
120492 : // This function permits access to the statements or declarations as a list of statements
120493 : // since declarations are derived from statements. This function generates a copy of the
120494 : // list in both cases (symmetrically for both types).
120495 :
120496 : #if 0
120497 : printf ("In SgScopeStatement::generateStatementList() containsOnlyDeclarations() = %s \n",
120498 : containsOnlyDeclarations() ? "true" : "false");
120499 : #endif
120500 :
120501 :
120502 49000 : SgStatementPtrList returnList;
120503 49000 : if (containsOnlyDeclarations() == true)
120504 : {
120505 14742 : const SgDeclarationStatementPtrList & declarationList = getDeclarationList();
120506 14742 : SgDeclarationStatementPtrList::const_iterator i = declarationList.begin();
120507 1165890 : for (i = declarationList.begin(); i != declarationList.end(); i++)
120508 1151150 : returnList.push_back(*i);
120509 :
120510 14742 : ROSE_ASSERT (returnList.size() == declarationList.size());
120511 :
120512 : #if 0
120513 : // error checking
120514 : const SgStatementPtrList::const_iterator j = returnList.begin();
120515 : for (i = declarationList.begin(); i != declarationList.end(); i++)
120516 : {
120517 : ROSE_ASSERT ( (*i) == (*j) );
120518 : printf (" declaration = %s \n",(*i)->unparseToString().c_str());
120519 : j++;
120520 : }
120521 : #endif
120522 : }
120523 : else
120524 : {
120525 : // Handle special case of two lists in a single statement (just append the 2nd list to the 1st list)
120526 34258 : const SgIfStmt* ifStatement = isSgIfStmt(this);
120527 34258 : if (ifStatement != NULL)
120528 : {
120529 0 : if (isSgScopeStatement(ifStatement->get_true_body()))
120530 : {
120531 0 : returnList = isSgScopeStatement(ifStatement->get_true_body())->getStatementList();
120532 : }
120533 0 : if (isSgScopeStatement(ifStatement->get_false_body()))
120534 : {
120535 0 : const SgStatementPtrList& falseList = isSgScopeStatement(ifStatement->get_false_body())->getStatementList();
120536 0 : returnList.insert(returnList.end(), falseList.begin(), falseList.end());
120537 : }
120538 : }
120539 : else
120540 : {
120541 34258 : returnList = getStatementList();
120542 : }
120543 : }
120544 :
120545 : // printf ("In generateStatementList(): returnList.size() = %" PRIuPTR " \n",returnList.size());
120546 :
120547 49000 : return returnList;
120548 : }
120549 :
120550 : unsigned int
120551 0 : SgScopeStatement::generateUniqueStatementNumberForScope( SgStatement* statement )
120552 : {
120553 0 : unsigned int counter = 0;
120554 0 : bool found = this->generateUniqueStatementNumberForScopeHelper(counter, statement);
120555 0 : ROSE_ASSERT (found);
120556 0 : return counter;
120557 : }
120558 :
120559 : bool
120560 0 : SgScopeStatement::generateUniqueStatementNumberForScopeHelper(unsigned int& counter, SgStatement* statement)
120561 : {
120562 : // DQ (2/20/2007): This function supports the AST merge mechanism, but is general
120563 : // and may be useful for the mangled name generation in the future.
120564 :
120565 : // This function generates a unique number for each statement in the scope by returning
120566 : // its position value countered from the top of the list of statements of declarations.
120567 : // It is used in the AST merge within the mechanism to generate unique names for both
120568 : // un-named enums and class declarations and template declarations of overloaded
120569 : // functions in a templated class (since at the point of instantiation of the outer class
120570 : // the names of any overloaded functions are all the same). The value of returned
120571 : // by this function should only be relied upon to be unique for the given scope (nothing more).
120572 : // This function may be useful for naming unnamed scopes such as though in loop constructs.
120573 :
120574 : #if 0
120575 : printf ("In SgScopeStatement::generateUniqueStatementNumberForScope() containsOnlyDeclarations() = %s \n",
120576 : containsOnlyDeclarations() ? "true" : "false");
120577 : #endif
120578 :
120579 0 : if (containsOnlyDeclarations() == true)
120580 : {
120581 0 : const SgDeclarationStatement* declaration = isSgDeclarationStatement(statement);
120582 0 : ROSE_ASSERT(declaration != NULL);
120583 :
120584 0 : const SgDeclarationStatementPtrList & declarationList = getDeclarationList();
120585 0 : SgDeclarationStatementPtrList::const_iterator i = declarationList.begin();
120586 0 : while ( (i != declarationList.end()) && ( (*i)->get_definingDeclaration() != declaration->get_definingDeclaration()) )
120587 : {
120588 0 : printf ("counter = %d *i = %p = %s defining declaration = %p statement = %p = %s statement defining declaration = %p \n",
120589 0 : counter,*i,(*i)->class_name().c_str(),(*i)->get_definingDeclaration(),statement,statement->class_name().c_str(),declaration->get_definingDeclaration());
120590 0 : counter++;
120591 0 : i++;
120592 : }
120593 :
120594 0 : if (i == declarationList.end())
120595 : {
120596 0 : printf ("statement = %p = %s not found in scope (declaration list) = %p = %s \n",statement,statement->class_name().c_str(),this,this->class_name().c_str());
120597 0 : return false;
120598 : }
120599 : else
120600 : {
120601 0 : printf ("END: counter = %d *i = %p = %s defining declaration = %p statement = %p = %s statement defining declaration = %p \n",
120602 0 : counter,*i,(*i)->class_name().c_str(),(*i)->get_definingDeclaration(),statement,statement->class_name().c_str(),declaration->get_definingDeclaration());
120603 0 : return true;
120604 : }
120605 :
120606 : }
120607 : else
120608 : {
120609 : // Handle special case of two lists in a single statement (just add the 2nd list to the 1st result)
120610 0 : SgIfStmt* ifStatement = isSgIfStmt(this);
120611 0 : if (ifStatement != NULL)
120612 : {
120613 : // The calls to generateUniqueStatementNumberForScopeHelper both
120614 : // increment the counter for the number of nested statements
120615 : // found in their respective regions of the program.
120616 : // Note that the condition of the if is not checked -- this
120617 : // matches the previous behavior, but may not be correct.
120618 0 : bool foundTrue = false;
120619 0 : if (isSgBasicBlock(ifStatement->get_true_body())) {
120620 0 : foundTrue = isSgBasicBlock(ifStatement->get_true_body())->generateUniqueStatementNumberForScopeHelper(counter, statement);
120621 : } else {
120622 0 : foundTrue = (statement == ifStatement->get_true_body());
120623 0 : if (!foundTrue) ++counter;
120624 : }
120625 0 : if (foundTrue) {
120626 : return true;
120627 : } else {
120628 0 : bool foundFalse = false;
120629 0 : if (isSgBasicBlock(ifStatement->get_false_body())) {
120630 0 : foundFalse = isSgBasicBlock(ifStatement->get_false_body())->generateUniqueStatementNumberForScopeHelper(counter, statement);
120631 : } else {
120632 0 : foundFalse = (statement != NULL && statement == ifStatement->get_false_body());
120633 0 : if (!foundFalse) ++counter;
120634 : }
120635 0 : if (foundFalse) {
120636 : return true;
120637 : } else {
120638 0 : return false;
120639 : }
120640 : }
120641 : }
120642 : else
120643 : {
120644 0 : const SgStatementPtrList & statementList = getStatementList();
120645 0 : SgStatementPtrList::const_iterator i = statementList.begin();
120646 0 : while ( (i != statementList.end()) && (*i != statement) )
120647 : {
120648 0 : counter++;
120649 0 : i++;
120650 : }
120651 :
120652 0 : if (i == statementList.end())
120653 : {
120654 0 : printf ("statement = %p = %s not found in scope (statement list) = %p = %s \n",statement,statement->class_name().c_str(),this,this->class_name().c_str());
120655 0 : ROSE_ASSERT(counter == statementList.size());
120656 : }
120657 : }
120658 : }
120659 :
120660 0 : printf ("In generateUniqueStatementNumberForScope(): counter = %u \n",counter);
120661 :
120662 0 : return counter;
120663 : }
120664 :
120665 : SgStatement*
120666 0 : SgScopeStatement::firstStatement() const
120667 : {
120668 0 : SgStatement* first = NULL;
120669 :
120670 : #if 0
120671 : // DQ (5/27/2019): Need to handle the case where this is a scope containing declaration statements, this code does not do this.
120672 : const SgStatementPtrList & statementList = getStatementList();
120673 :
120674 : if (statementList.empty() == false)
120675 : first = *(statementList.begin());
120676 : #else
120677 : // DQ (5/27/2019): This code handles the case where this is a scope containing declaration statements.
120678 0 : if (containsOnlyDeclarations() == true)
120679 : {
120680 0 : const SgDeclarationStatementPtrList & declarationList = getDeclarationList();
120681 0 : if (declarationList.empty() == false)
120682 0 : first = *(declarationList.begin());
120683 : }
120684 : else
120685 : {
120686 0 : const SgStatementPtrList & statementList = getStatementList();
120687 :
120688 0 : if (statementList.empty() == false)
120689 0 : first = *(statementList.begin());
120690 : }
120691 : #endif
120692 :
120693 0 : return first;
120694 : }
120695 :
120696 : SgStatement*
120697 115 : SgScopeStatement::lastStatement() const
120698 : {
120699 115 : SgStatement* last = NULL;
120700 :
120701 : #if 0
120702 : const SgStatementPtrList & statementList = getStatementList();
120703 : if (statementList.empty() == false)
120704 : last = *(statementList.rbegin());
120705 : #else
120706 : // This function has to handle the details of looking for the last statement dependent
120707 : // upon if the scope contains a list of SgDeclarationStatement or SgStatement.
120708 230 : SgStatementPtrList returnList;
120709 115 : if (containsOnlyDeclarations() == true)
120710 : {
120711 37 : const SgDeclarationStatementPtrList & declarationList = getDeclarationList();
120712 37 : if (declarationList.empty() == false)
120713 34 : last = *(declarationList.rbegin());
120714 : }
120715 : else
120716 : {
120717 : // Handle special case of two lists in a single statement (just append the 2nd list to the 1st list)
120718 78 : const SgIfStmt* ifStatement = isSgIfStmt(this);
120719 78 : if (ifStatement != NULL)
120720 : {
120721 : // Both the true and false bodies can be either a SgBasicBlock or any SgStatement.
120722 : // NOTE: If the false body is empty then use the last statement of the true body.
120723 : // Having an empty false body is a common normalization within the IR, though less
120724 : // so for C/C++ recently and more for Fortrna (as I recall).
120725 1 : SgScopeStatement* ifScopeFalseBody = isSgScopeStatement(ifStatement->get_false_body());
120726 1 : if (ifScopeFalseBody != NULL && ifScopeFalseBody->getStatementList().empty() == false)
120727 : {
120728 : // const SgStatementPtrList& falseList = isSgScopeStatement(ifStatement->get_false_body())->getStatementList();
120729 : // returnList.insert(returnList.end(), falseList.begin(), falseList.end());
120730 0 : const SgStatementPtrList & statementList = ifScopeFalseBody->getStatementList();
120731 : #if 1
120732 0 : ROSE_ASSERT (statementList.empty() == false);
120733 0 : last = *(statementList.rbegin());
120734 : #else
120735 : if (statementList.empty() == false)
120736 : {
120737 : last = *(statementList.rbegin());
120738 : }
120739 : else
120740 : {
120741 : // I think that this path should not be possible!
120742 : printf ("ERROR: false branch statementList.empty() == true \n");
120743 : ROSE_ASSERT(false);
120744 : }
120745 : #endif
120746 : }
120747 : else
120748 : {
120749 1 : SgStatement* falseStatement = ifStatement->get_false_body();
120750 1 : if (falseStatement != NULL)
120751 : {
120752 : last = falseStatement;
120753 : }
120754 : else
120755 : {
120756 : // If there is no false body then we have to look at the bottom of the true body.
120757 : // Both the true and false bodies can be either a SgBasicBlock or any SgStatement.
120758 1 : if (isSgScopeStatement(ifStatement->get_true_body()) != NULL)
120759 : {
120760 : // returnList = isSgScopeStatement(ifStatement->get_true_body())->getStatementList();
120761 1 : const SgStatementPtrList & statementList = isSgScopeStatement(ifStatement->get_true_body())->getStatementList();
120762 1 : if (statementList.empty() == false)
120763 : {
120764 1 : last = *(statementList.rbegin());
120765 : }
120766 : else
120767 : {
120768 0 : printf ("ERROR: true branch statementList.empty() == true \n");
120769 0 : ROSE_ASSERT(false);
120770 : }
120771 : }
120772 : else
120773 : {
120774 0 : SgStatement* trueStatement = ifStatement->get_true_body();
120775 : last = trueStatement;
120776 : }
120777 :
120778 1 : ROSE_ASSERT(last != NULL);
120779 : }
120780 :
120781 1 : ROSE_ASSERT(last != NULL);
120782 : }
120783 :
120784 1 : ROSE_ASSERT(last != NULL);
120785 : }
120786 : else
120787 : {
120788 : // returnList = getStatementList();
120789 77 : const SgStatementPtrList & statementList = getStatementList();
120790 77 : if (statementList.empty() == false)
120791 76 : last = *(statementList.rbegin());
120792 : }
120793 : }
120794 : #endif
120795 :
120796 115 : return last;
120797 : }
120798 :
120799 : bool
120800 154140 : SgScopeStatement::isCaseInsensitive() const
120801 : {
120802 : // Case sensitive scopes are for C/C++ and case insensitive scopes are for Fortran.
120803 : // The case sensitive behavior is property of the symbol table only, but it represented
120804 : // in the scope API to be consistatn with the symbol table handling API being presented
120805 : // at the scope level (SgScopeStatment).
120806 :
120807 154140 : ROSE_ASSERT(p_symbol_table != NULL);
120808 154140 : return p_symbol_table->isCaseInsensitive();
120809 : }
120810 :
120811 : void
120812 229 : SgScopeStatement::setCaseInsensitive(bool b)
120813 : {
120814 : // Case sensitive scopes are for C/C++ and case insensitive scopes are for Fortran.
120815 : // The case sensitive behavior is property of the symbol table only, but it represented
120816 : // in the scope API to be consistatn with the symbol table handling API being presented
120817 : // at the scope level (SgScopeStatment).
120818 :
120819 229 : ROSE_ASSERT(p_symbol_table != NULL);
120820 229 : p_symbol_table->setCaseInsensitive(b);
120821 229 : }
120822 :
120823 :
120824 : bool
120825 889 : SgScopeStatement::isNamedScope()
120826 : {
120827 : // DQ (5/11/2011): Added support for new name qualification. If this is associated with
120828 : // a scope that has a name then return true, else false. This is used to support the name
120829 : // qualification.
120830 :
120831 889 : bool result = false;
120832 889 : switch (this->variantT())
120833 : {
120834 : // Though it might seem incorrect, since functions have names, the SgFunctionDefinition
120835 : // is not a named scope for purposes of name qualification.
120836 : // case SgFunctionDefinition:
120837 :
120838 0 : case V_SgBasicBlock:
120839 0 : {
120840 : // A SgBasicBlock is used inside of a few declarations to define a new scope.
120841 : // This for this case, the enum can't nest other scopes. But field values can
120842 : // be qualified, so this is a named scope when it is used in an SgEnumDeclaration.
120843 0 : SgEnumDeclaration* enumDeclaration = isSgEnumDeclaration(this->get_parent());
120844 0 : if (enumDeclaration != NULL)
120845 : {
120846 0 : result = true;
120847 : }
120848 : break;
120849 : }
120850 :
120851 : // case V_SgGlobal: // global has the name "::" but it does not have an associated declaration.
120852 :
120853 : // DQ (11/27/2011): Adding more support for template declarations in the AST.
120854 : case V_SgTemplateClassDefinition:
120855 :
120856 : case V_SgClassDefinition:
120857 : case V_SgTemplateInstantiationDefn:
120858 : case V_SgNamespaceDefinitionStatement:
120859 : {
120860 : result = true;
120861 : break;
120862 : }
120863 :
120864 : case V_SgDeclarationScope:
120865 : {
120866 : result = true;
120867 : break;
120868 : }
120869 :
120870 0 : default:
120871 0 : {
120872 0 : printf ("Default reached in SgScopeStatement::isNamedScope(): scope = %s \n",this->class_name().c_str());
120873 : #if 0
120874 : ROSE_ASSERT(false);
120875 : #endif
120876 : }
120877 : }
120878 :
120879 889 : return result;
120880 : }
120881 :
120882 : // DQ (5/11/2011): Added support for new name qualification implementation.
120883 : //! Some scopes have associated names for purposed of name qualification. This generates the associated name.
120884 : SgName
120885 0 : SgScopeStatement::associatedScopeName()
120886 : {
120887 0 : SgName name;
120888 0 : if (isNamedScope() == true)
120889 : {
120890 0 : SgDeclarationStatement* declaration = isSgDeclarationStatement(this->get_parent());
120891 0 : ROSE_ASSERT(declaration != NULL);
120892 0 : switch (declaration->variantT())
120893 : {
120894 0 : case V_SgTemplateClassDeclaration:
120895 0 : {
120896 : // DQ (6/11/2011): Since we don't handle the case of SgTemplateDeclaration, I don't think we have to handle this case.
120897 0 : printf ("ERROR: I think this should be an error for now at least...\n");
120898 0 : ROSE_ASSERT(false);
120899 : break;
120900 : }
120901 :
120902 0 : case V_SgClassDeclaration:
120903 0 : {
120904 0 : SgClassDeclaration* namedDeclaration = isSgClassDeclaration(declaration);
120905 0 : name = namedDeclaration->get_name();
120906 0 : break;
120907 : }
120908 :
120909 : // The name stored in a SgTemplateInstantiationDecl is different from that in the SgClassDeclaration base class, as I recall.
120910 0 : case V_SgTemplateInstantiationDecl:
120911 0 : {
120912 0 : SgTemplateInstantiationDecl* namedDeclaration = isSgTemplateInstantiationDecl(declaration);
120913 0 : name = namedDeclaration->get_name();
120914 0 : break;
120915 : }
120916 :
120917 0 : case V_SgNamespaceDeclarationStatement:
120918 0 : {
120919 0 : SgNamespaceDeclarationStatement* namedDeclaration = isSgNamespaceDeclarationStatement(declaration);
120920 0 : name = namedDeclaration->get_name();
120921 0 : break;
120922 : }
120923 :
120924 0 : case V_SgEnumDeclaration:
120925 0 : {
120926 0 : SgEnumDeclaration* namedDeclaration = isSgEnumDeclaration(declaration);
120927 0 : name = namedDeclaration->get_name();
120928 0 : break;
120929 : }
120930 : #if 0
120931 : case V_SgGlobal:
120932 : {
120933 : // The name of global scope (as used for name qualification).
120934 : name = "::";
120935 : break;
120936 : }
120937 : #endif
120938 0 : default:
120939 0 : {
120940 0 : printf ("Default reached in SgScopeStatement::associatedScopeName(): scope = %s \n",this->class_name().c_str());
120941 0 : ROSE_ASSERT(false);
120942 : }
120943 : }
120944 : }
120945 : #if 0
120946 : else
120947 : {
120948 : if (isSgGlobal(this) != NULL)
120949 : {
120950 : name = "::";
120951 : }
120952 : }
120953 : #endif
120954 :
120955 0 : return name;
120956 : }
120957 :
120958 :
120959 : bool
120960 21523 : SgScopeStatement::isEquivalentScope( SgScopeStatement* scope1, SgScopeStatement* scope2)
120961 : {
120962 : // DQ (1/21/2013): Test for equivcalant scopes. The only example I can think of for equivalent scopes
120963 : // when the pointers are not equal is a SgNamespaceDefinition. Since namespaces can be reintrant, a
120964 : // declaration can be in two more more scope that would have different pointers, yet still be considered
120965 : // to be in the same namespace. This test is used in the name qualification generation.
120966 :
120967 : #if 0
120968 : printf ("currentScope = %p = %s \n",currentScope,currentScope->class_name().c_str());
120969 : printf ("classDeclaration->get_scope() = %p = %s \n",classDeclaration->get_scope(),classDeclaration->get_scope()->class_name().c_str());
120970 : #endif
120971 : // DQ (1/21/2013): If these are both namespace scopes then do a more sophisticated test for equivalent namespace.
120972 : // Note that over qualification of generated code can be an error.
120973 21523 : SgNamespaceDefinitionStatement* scope1_NamespaceDefinition = isSgNamespaceDefinitionStatement(scope1);
120974 21523 : SgNamespaceDefinitionStatement* scope2_NamespaceDefinition = isSgNamespaceDefinitionStatement(scope2);
120975 21523 : bool isSameNamespace = false;
120976 21523 : if (scope1_NamespaceDefinition != NULL && scope2_NamespaceDefinition != NULL)
120977 : {
120978 : #if 0
120979 : printf ("These are both in namespaces and we need to check if it is the same namespace (instead of just matching scope pointers) \n");
120980 : #endif
120981 18794 : SgNamespaceDeclarationStatement* scope1_NamespaceDeclaration = isSgNamespaceDeclarationStatement(scope1_NamespaceDefinition->get_namespaceDeclaration());
120982 18794 : SgNamespaceDeclarationStatement* scope2_NamespaceDeclaration = isSgNamespaceDeclarationStatement(scope2_NamespaceDefinition->get_namespaceDeclaration());
120983 :
120984 18794 : ROSE_ASSERT(scope1_NamespaceDeclaration != NULL);
120985 18794 : ROSE_ASSERT(scope2_NamespaceDeclaration != NULL);
120986 :
120987 : // Test for equivalent namespaces.
120988 18794 : if (scope1_NamespaceDeclaration->get_firstNondefiningDeclaration() == scope2_NamespaceDeclaration->get_firstNondefiningDeclaration())
120989 : {
120990 17639 : isSameNamespace = true;
120991 : }
120992 : else
120993 : {
120994 : #if 0
120995 : printf ("These namespaces are different \n");
120996 : #endif
120997 : }
120998 :
120999 : #if 0
121000 : printf ("SgClassDeclaration: (detected equivalent namespaces) isSameNamespace = %s \n",isSameNamespace ? "true" : "false");
121001 : #endif
121002 : }
121003 :
121004 21523 : return isSameNamespace;
121005 : }
121006 :
121007 :
121008 :
121009 : // End of memberFunctionString
121010 : // Start of memberFunctionString
121011 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
121012 :
121013 : // *** COMMON CODE SECTION BEGINS HERE ***
121014 :
121015 : #if 0
121016 : int
121017 : SgScopeStatement::getVariant() const
121018 : {
121019 : // This function is used in ROSE while "variant()" is used in SAGE
121020 : assert(this != NULL);
121021 : return variant();
121022 : }
121023 : #endif
121024 :
121025 : // This function is used in ROSE in treeTraversal code
121026 : // eventually replaces getVariant() and variant()
121027 : // though after variant() has been removed for a while we will
121028 : // want to change the name of variantT() back to variant()
121029 : // (since the "T" was ment to stand for temporary).
121030 : // When this happens the variantT() will be depricated.
121031 : VariantT
121032 552988 : SgScopeStatement::variantT() const
121033 : {
121034 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
121035 552988 : ROSE_ASSERT(this != NULL);
121036 552988 : return V_SgScopeStatement;
121037 : }
121038 :
121039 : #if 0
121040 : int
121041 : SgScopeStatement::variant() const
121042 : {
121043 : // This function is used in SAGE
121044 : ROSE_ASSERT(this != NULL);
121045 : return SCOPE_STMT;
121046 : }
121047 : #endif
121048 :
121049 : ROSE_DLL_API const char*
121050 0 : SgScopeStatement::sage_class_name() const
121051 : {
121052 0 : ROSE_ASSERT(this != NULL);
121053 0 : return "SgScopeStatement";
121054 : }
121055 :
121056 : std::string
121057 0 : SgScopeStatement::class_name() const
121058 : {
121059 0 : ROSE_ASSERT(this != NULL);
121060 0 : return "SgScopeStatement";
121061 : }
121062 :
121063 : // DQ (11/26/2005): Support for visitor pattern mechanims
121064 : // (inferior to ROSE traversal mechanism, experimental).
121065 : void
121066 0 : SgScopeStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
121067 : {
121068 0 : ROSE_ASSERT(this != NULL);
121069 0 : visitor.visit(this);
121070 0 : }
121071 :
121072 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
121073 0 : void SgScopeStatement::accept (ROSE_VisitorPattern & visitor) {
121074 0 : ROSE_ASSERT(this != NULL);
121075 0 : visitor.visit(this);
121076 0 : }
121077 :
121078 : SgScopeStatement*
121079 0 : SgScopeStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
121080 : {
121081 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
121082 : // This function is currently only supported for the AST used the represent Binary executables.
121083 : if (0 /* isSgAsmNode(this) != NULL */)
121084 : {
121085 : // Support for regex specification.
121086 : std::string prefixCode = "REGEX:";
121087 : addNewAttribute(prefixCode + s,a);
121088 : }
121089 : #endif
121090 :
121091 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
121092 0 : return this;
121093 : }
121094 :
121095 : // *** COMMON CODE SECTION ENDS HERE ***
121096 :
121097 :
121098 : // End of memberFunctionString
121099 : // Start of memberFunctionString
121100 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
121101 :
121102 :
121103 : #if 0
121104 : //! Error checking support
121105 : /*! Verifies the following:
121106 : - working getVariant() member function
121107 : - calls base class's error() member function
121108 : Every class has one of these functions.
121109 : */
121110 : bool
121111 : SgScopeStatement::error()
121112 : {
121113 : // Put error checking here
121114 :
121115 : ROSE_ASSERT (this != NULL);
121116 : if (getVariant() != SCOPE_STMT)
121117 : {
121118 : printf ("Error in SgScopeStatement::error(): SgScopeStatement object has a %s variant \n",
121119 : Cxx_GrammarTerminalNames[getVariant()].name);
121120 : // printf ("Error in SgScopeStatement::error() \n");
121121 : ROSE_ABORT();
121122 : }
121123 :
121124 : ROSE_ASSERT (getVariant() == SCOPE_STMT);
121125 : return SgStatement::error();
121126 : }
121127 : #endif
121128 :
121129 :
121130 :
121131 : // End of memberFunctionString
121132 :
121133 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
121134 :
121135 45616000 : SgScopeStatement* isSgScopeStatement ( SgNode* inputDerivedClassPointer )
121136 : {
121137 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
121138 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
121139 : // So to fix this we return NULL directly when the input is NULL and avoid the
121140 : // dynamic_cast in this case. This is likely a performance improvement as well.
121141 : // return dynamic_cast<SgScopeStatement*>(inputDerivedClassPointer);
121142 : // Milind Chabbi (8/28/2013): isSgScopeStatement uses table-driven castability instead of c++ default dynamic_cast
121143 : // this improves the running time performance by 10-20%.
121144 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgScopeStatement*>(inputDerivedClassPointer);
121145 45616000 : return IS_SgScopeStatement_FAST_MACRO(inputDerivedClassPointer);
121146 : }
121147 :
121148 : // DQ (11/8/2003): Added version of functions taking const pointer
121149 299246 : const SgScopeStatement* isSgScopeStatement ( const SgNode* inputDerivedClassPointer )
121150 : {
121151 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
121152 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
121153 : // So to fix this we return NULL directly when the input is NULL and avoid the
121154 : // dynamic_cast in this case. This is likely a performance improvement as well.
121155 : // return dynamic_cast<const SgScopeStatement*>(inputDerivedClassPointer);
121156 : // Milind Chabbi (8/28/2013): isSgScopeStatement uses table-driven castability instead of c++ default dynamic_cast
121157 : // this improves the running time performance by 10-20%.
121158 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgScopeStatement*>(inputDerivedClassPointer);
121159 299246 : return IS_SgScopeStatement_FAST_MACRO(inputDerivedClassPointer);
121160 : }
121161 :
121162 :
121163 :
121164 : /* #line 121165 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121165 :
121166 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
121167 :
121168 : /**
121169 : \brief Generated destructor
121170 :
121171 : This destructor is automatically generated (by ROSETTA). This destructor
121172 : only frees memory of data members associated with the parts of the current IR node which
121173 : are NOT traversed. Those data members that are part of a traversal can be freed using
121174 : a traversal (calling this destructor on all children in a post-order traversal). Such
121175 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
121176 :
121177 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
121178 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
121179 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
121180 :
121181 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
121182 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
121183 : pointers are not yet implemented to call delete on eash pointer in the container.
121184 : (This could be done by derivation from the STL containers to define containers that
121185 : automatically deleted their members.)
121186 :
121187 : */
121188 27222 : SgScopeStatement::~SgScopeStatement () {
121189 27222 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
121190 :
121191 27222 : if (p_symbol_table && p_symbol_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_symbol_table; }
121192 27222 : if (p_type_table && p_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_type_table; }
121193 27222 : if (p_pragma && p_pragma->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_pragma; }
121194 :
121195 : // case: not a listType for symbol_table
121196 27222 : p_symbol_table = NULL; // non list case
121197 : // case: not a listType for type_table
121198 27222 : p_type_table = NULL; // non list case
121199 : // case: not a listType for pragma
121200 27222 : p_pragma = NULL; // non list case
121201 :
121202 : }
121203 :
121204 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
121205 27222 : }
121206 :
121207 :
121208 : /* #line 121209 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121209 :
121210 :
121211 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
121212 :
121213 :
121214 : // ********************************************************
121215 : // member functions common across all array grammar objects
121216 : // ********************************************************
121217 :
121218 :
121219 :
121220 : /* #line 121221 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121221 :
121222 :
121223 :
121224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
121225 :
121226 : // ********************************************************
121227 : // member functions specific to each node in the grammar
121228 : // ********************************************************
121229 :
121230 :
121231 : /* #line 121232 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121232 :
121233 : // Start of memberFunctionString
121234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
121235 :
121236 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
121237 :
121238 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
121239 : const SgDeclarationStatementPtrList &
121240 366 : SgGlobal::get_declarations () const
121241 : {
121242 366 : assert (this != NULL);
121243 366 : return p_declarations;
121244 : }
121245 :
121246 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
121247 : SgDeclarationStatementPtrList &
121248 2381190 : SgGlobal::get_declarations ()
121249 : {
121250 2381190 : assert (this != NULL);
121251 :
121252 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
121253 : // As a rule only set_ access functions can set the isModified flag.
121254 : // set_isModified(true);
121255 :
121256 2381190 : return p_declarations;
121257 : }
121258 :
121259 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
121260 :
121261 :
121262 : // End of memberFunctionString
121263 : // Start of memberFunctionString
121264 : /* #line 7420 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
121265 :
121266 :
121267 :
121268 : // DQ (9/8/2004): Added to support qualified name generation
121269 : SgName
121270 160969 : SgGlobal::get_qualified_name() const
121271 : {
121272 : // DQ (8/25/2005): This is the case where we previously names the global scope as "::"
121273 : // within name qualification. This was done to handle test2005_144.C but it broke
121274 : // test2004_80.C So we have moved to an explicit marking of IR nodes using global scope
121275 : // qualification (since it clearly seems to be required).
121276 : // DQ (8/22/2005): Added global scope qualifier (see test2005_144.C) it is sometimes
121277 : // required to prevent base class types from being used instead of globally defined types.
121278 : // Note that this will still evaluate so that "returnName.is_null()" will be true
121279 :
121280 : // DQ (10/11/2006): Under the new name qualification, we must traverse all the way
121281 : // to global scope, and include global scope to get test2006_157.C correct.
121282 : // return SgName ("");
121283 :
121284 160969 : std::string globalScopeDelimiter;
121285 160969 : globalScopeDelimiter = "::";
121286 321938 : return SgName (globalScopeDelimiter);
121287 : }
121288 :
121289 : SgName
121290 2138570 : SgGlobal::get_mangled_name(void) const
121291 : {
121292 : // DQ (2/22/2007): This function is added to prevent "::" substrings in mangled names of other declarations.
121293 : // DQ (3/12/2007): This is likely faster than using the mangled name map
121294 2138570 : return SgName ("__global__");
121295 : }
121296 :
121297 : void
121298 714 : SgGlobal::post_construction_initialization()
121299 : {
121300 : #if 0
121301 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
121302 : printf ("In SgGlobal::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
121303 : #endif
121304 714 : }
121305 :
121306 : void
121307 0 : SgGlobal::append_declaration(SgDeclarationStatement * what)
121308 : {
121309 : // DQ (3/10/2007): Make sure that the statement does not already exist in the scope
121310 : // It may be OK if is is marked explicitly as shared. Note that this is a linear time test.
121311 : #if 0
121312 : // printf ("In SgGlobal::append_declaration(): what = %p = %s \n",what,what->class_name().c_str());
121313 : if (find(get_declarations().begin(),get_declarations().end(),what) != get_declarations().end() && what->get_file_info()->isShared() == false)
121314 : {
121315 : printf ("Error: SgGlobal::append_declaration(): what = %p = %s \n",what,what->class_name().c_str());
121316 : what->get_startOfConstruct()->display("statement does not already exists: debug");
121317 : }
121318 :
121319 : // Since we have later error checking we don't require this here as it introduces a performance problem.
121320 : ROSE_ASSERT(find(get_declarations().begin(),get_declarations().end(),what) == get_declarations().end() || what->get_file_info()->isShared() == true);
121321 : #endif
121322 :
121323 0 : get_declarations().push_back(what);
121324 0 : what->set_parent(this);
121325 :
121326 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121327 0 : ROSE_ASSERT(what->get_parent() != NULL);
121328 0 : }
121329 :
121330 : #if 1
121331 : void
121332 0 : SgGlobal::prepend_declaration(SgDeclarationStatement * what)
121333 : {
121334 0 : get_declarations().insert(get_declarations().begin(), what);
121335 0 : what->set_parent(this);
121336 :
121337 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121338 0 : ROSE_ASSERT(what->get_parent() != NULL);
121339 0 : }
121340 :
121341 : #if 0
121342 : void
121343 : SgGlobal::insert_declaration ( const SgDeclarationStatementPtrList::iterator& where, SgDeclarationStatement* what)
121344 : {
121345 : #ifndef REMOVE_SET_PARENT_FUNCTION
121346 : #error "DEAD CODE"
121347 : what->set_parent(this);
121348 : #endif
121349 : what->set_parent(this);
121350 :
121351 : get_declarations().insert(where,what);
121352 :
121353 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121354 : ROSE_ASSERT(what->get_parent() != NULL);
121355 : }
121356 : #endif
121357 : #endif
121358 :
121359 : bool
121360 1184120 : SgGlobal::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractBasicBlock)
121361 : {
121362 1184120 : return StatementListInsertChild( this, get_declarations(), target, newstmt, inFront, extractBasicBlock, false);
121363 : }
121364 :
121365 : bool
121366 17 : SgGlobal:: replace_child(SgStatement *target ,SgStatement * newstmt, bool extractBasicBlock)
121367 : {
121368 17 : return StatementListInsertChild( this, get_declarations(), target, newstmt, true, extractBasicBlock, true);
121369 : }
121370 :
121371 : #if 0
121372 : std::map<SgNode*,std::string> &
121373 : SgGlobal:: get_mangledNameCache()
121374 : {
121375 : return p_mangledNameCache;
121376 : }
121377 :
121378 : std::map<std::string, int> &
121379 : SgGlobal:: get_shortMangledNameCache()
121380 : {
121381 : return p_shortMangledNameCache;
121382 : }
121383 : #endif
121384 :
121385 0 : std::ostream & operator<< ( std::ostream & os, std::map<SgNode*,std::string> & x )
121386 : {
121387 : // printf ("Error: Not implemented, operator<< ( std::ostream & os, std::map<SgNode*,std::string> & x ) \n");
121388 : // os << " pair (" << (*x).first.str() << "," << ((*x).second) << ")";
121389 :
121390 0 : os << "output operator for std::map<SgNode*,std::string> not implemented";
121391 0 : return os;
121392 : }
121393 :
121394 :
121395 :
121396 : // End of memberFunctionString
121397 : // Start of memberFunctionString
121398 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
121399 :
121400 : // *** COMMON CODE SECTION BEGINS HERE ***
121401 :
121402 : #if 0
121403 : int
121404 : SgGlobal::getVariant() const
121405 : {
121406 : // This function is used in ROSE while "variant()" is used in SAGE
121407 : assert(this != NULL);
121408 : return variant();
121409 : }
121410 : #endif
121411 :
121412 : // This function is used in ROSE in treeTraversal code
121413 : // eventually replaces getVariant() and variant()
121414 : // though after variant() has been removed for a while we will
121415 : // want to change the name of variantT() back to variant()
121416 : // (since the "T" was ment to stand for temporary).
121417 : // When this happens the variantT() will be depricated.
121418 : VariantT
121419 149932000 : SgGlobal::variantT() const
121420 : {
121421 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
121422 149932000 : ROSE_ASSERT(this != NULL);
121423 149932000 : return V_SgGlobal;
121424 : }
121425 :
121426 : #if 0
121427 : int
121428 : SgGlobal::variant() const
121429 : {
121430 : // This function is used in SAGE
121431 : ROSE_ASSERT(this != NULL);
121432 : return GLOBAL_STMT;
121433 : }
121434 : #endif
121435 :
121436 : ROSE_DLL_API const char*
121437 3170 : SgGlobal::sage_class_name() const
121438 : {
121439 3170 : ROSE_ASSERT(this != NULL);
121440 3170 : return "SgGlobal";
121441 : }
121442 :
121443 : std::string
121444 27518800 : SgGlobal::class_name() const
121445 : {
121446 27518800 : ROSE_ASSERT(this != NULL);
121447 27518800 : return "SgGlobal";
121448 : }
121449 :
121450 : // DQ (11/26/2005): Support for visitor pattern mechanims
121451 : // (inferior to ROSE traversal mechanism, experimental).
121452 : void
121453 388 : SgGlobal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
121454 : {
121455 388 : ROSE_ASSERT(this != NULL);
121456 388 : visitor.visit(this);
121457 388 : }
121458 :
121459 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
121460 0 : void SgGlobal::accept (ROSE_VisitorPattern & visitor) {
121461 0 : ROSE_ASSERT(this != NULL);
121462 0 : visitor.visit(this);
121463 0 : }
121464 :
121465 : SgGlobal*
121466 0 : SgGlobal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
121467 : {
121468 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
121469 : // This function is currently only supported for the AST used the represent Binary executables.
121470 : if (0 /* isSgAsmNode(this) != NULL */)
121471 : {
121472 : // Support for regex specification.
121473 : std::string prefixCode = "REGEX:";
121474 : addNewAttribute(prefixCode + s,a);
121475 : }
121476 : #endif
121477 :
121478 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
121479 0 : return this;
121480 : }
121481 :
121482 : // *** COMMON CODE SECTION ENDS HERE ***
121483 :
121484 :
121485 : // End of memberFunctionString
121486 : // Start of memberFunctionString
121487 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
121488 :
121489 :
121490 : #if 0
121491 : //! Error checking support
121492 : /*! Verifies the following:
121493 : - working getVariant() member function
121494 : - calls base class's error() member function
121495 : Every class has one of these functions.
121496 : */
121497 : bool
121498 : SgGlobal::error()
121499 : {
121500 : // Put error checking here
121501 :
121502 : ROSE_ASSERT (this != NULL);
121503 : if (getVariant() != GLOBAL_STMT)
121504 : {
121505 : printf ("Error in SgGlobal::error(): SgGlobal object has a %s variant \n",
121506 : Cxx_GrammarTerminalNames[getVariant()].name);
121507 : // printf ("Error in SgGlobal::error() \n");
121508 : ROSE_ABORT();
121509 : }
121510 :
121511 : ROSE_ASSERT (getVariant() == GLOBAL_STMT);
121512 : return SgScopeStatement::error();
121513 : }
121514 : #endif
121515 :
121516 :
121517 :
121518 : // End of memberFunctionString
121519 :
121520 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
121521 :
121522 11019200 : SgGlobal* isSgGlobal ( SgNode* inputDerivedClassPointer )
121523 : {
121524 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
121525 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
121526 : // So to fix this we return NULL directly when the input is NULL and avoid the
121527 : // dynamic_cast in this case. This is likely a performance improvement as well.
121528 : // return dynamic_cast<SgGlobal*>(inputDerivedClassPointer);
121529 : // Milind Chabbi (8/28/2013): isSgGlobal uses table-driven castability instead of c++ default dynamic_cast
121530 : // this improves the running time performance by 10-20%.
121531 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGlobal*>(inputDerivedClassPointer);
121532 11019200 : return IS_SgGlobal_FAST_MACRO(inputDerivedClassPointer);
121533 : }
121534 :
121535 : // DQ (11/8/2003): Added version of functions taking const pointer
121536 25172000 : const SgGlobal* isSgGlobal ( const SgNode* inputDerivedClassPointer )
121537 : {
121538 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
121539 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
121540 : // So to fix this we return NULL directly when the input is NULL and avoid the
121541 : // dynamic_cast in this case. This is likely a performance improvement as well.
121542 : // return dynamic_cast<const SgGlobal*>(inputDerivedClassPointer);
121543 : // Milind Chabbi (8/28/2013): isSgGlobal uses table-driven castability instead of c++ default dynamic_cast
121544 : // this improves the running time performance by 10-20%.
121545 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGlobal*>(inputDerivedClassPointer);
121546 25172000 : return IS_SgGlobal_FAST_MACRO(inputDerivedClassPointer);
121547 : }
121548 :
121549 :
121550 :
121551 : /* #line 121552 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121552 :
121553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
121554 :
121555 : /**
121556 : \brief Generated destructor
121557 :
121558 : This destructor is automatically generated (by ROSETTA). This destructor
121559 : only frees memory of data members associated with the parts of the current IR node which
121560 : are NOT traversed. Those data members that are part of a traversal can be freed using
121561 : a traversal (calling this destructor on all children in a post-order traversal). Such
121562 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
121563 :
121564 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
121565 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
121566 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
121567 :
121568 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
121569 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
121570 : pointers are not yet implemented to call delete on eash pointer in the container.
121571 : (This could be done by derivation from the STL containers to define containers that
121572 : automatically deleted their members.)
121573 :
121574 : */
121575 29 : SgGlobal::~SgGlobal () {
121576 12 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
121577 :
121578 :
121579 :
121580 : }
121581 :
121582 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
121583 24 : }
121584 :
121585 :
121586 : /* #line 121587 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121587 :
121588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
121589 :
121590 : // Generated constructor
121591 714 : SgGlobal::SgGlobal ( Sg_File_Info* startOfConstruct )
121592 714 : : SgScopeStatement(startOfConstruct)
121593 : {
121594 : #ifdef DEBUG
121595 : // printf ("In SgGlobal::SgGlobal (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
121596 : #endif
121597 : #if 0
121598 : // debugging information!
121599 : printf ("In SgGlobal::SgGlobal (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
121600 : #endif
121601 :
121602 :
121603 :
121604 : #if 0
121605 : // DQ (7/30/2014): Call a virtual function.
121606 : std::string s = this->class_name();
121607 : #endif
121608 :
121609 : // Test the variant virtual function
121610 : // assert(GLOBAL_STMT == variant());
121611 714 : assert(GLOBAL_STMT == this->variant());
121612 714 : ROSE_ASSERT(GLOBAL_STMT == (int)(this->variantT()));
121613 714 : post_construction_initialization();
121614 :
121615 : // Test the isSgGlobal() function since it has been problematic
121616 714 : assert(isSgGlobal(this) != NULL);
121617 714 : }
121618 :
121619 : // Generated constructor (all data members)
121620 :
121621 : /* #line 121622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121622 :
121623 :
121624 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
121625 :
121626 :
121627 : // ********************************************************
121628 : // member functions common across all array grammar objects
121629 : // ********************************************************
121630 :
121631 :
121632 :
121633 : /* #line 121634 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121634 :
121635 :
121636 :
121637 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
121638 :
121639 : // ********************************************************
121640 : // member functions specific to each node in the grammar
121641 : // ********************************************************
121642 :
121643 :
121644 : /* #line 121645 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
121645 :
121646 : // Start of memberFunctionString
121647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
121648 :
121649 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
121650 :
121651 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
121652 : const SgStatementPtrList &
121653 20148 : SgBasicBlock::get_statements () const
121654 : {
121655 20148 : assert (this != NULL);
121656 20148 : return p_statements;
121657 : }
121658 :
121659 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
121660 : SgStatementPtrList &
121661 110767 : SgBasicBlock::get_statements ()
121662 : {
121663 110767 : assert (this != NULL);
121664 :
121665 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
121666 : // As a rule only set_ access functions can set the isModified flag.
121667 : // set_isModified(true);
121668 :
121669 110767 : return p_statements;
121670 : }
121671 :
121672 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
121673 :
121674 :
121675 : // End of memberFunctionString
121676 : // Start of memberFunctionString
121677 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
121678 :
121679 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
121680 :
121681 : std::string
121682 1685 : SgBasicBlock::get_asm_function_body () const
121683 : {
121684 1685 : ROSE_ASSERT (this != NULL);
121685 :
121686 : #if 0
121687 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
121688 : // used to trigger marking transformations for the token-based unparsing.
121689 : printf ("SgBasicBlock::get_asm_function_body = %p = %s \n",this,this->class_name().c_str());
121690 : #endif
121691 :
121692 1685 : return p_asm_function_body;
121693 : }
121694 :
121695 : void
121696 0 : SgBasicBlock::set_asm_function_body ( std::string asm_function_body )
121697 : {
121698 0 : ROSE_ASSERT (this != NULL);
121699 :
121700 : #if 0
121701 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
121702 : // used to trigger marking transformations for the token-based unparsing.
121703 : printf ("SgBasicBlock::set_asm_function_body = %p = %s \n",this,this->class_name().c_str());
121704 : #endif
121705 :
121706 0 : set_isModified(true);
121707 :
121708 0 : p_asm_function_body = asm_function_body;
121709 0 : }
121710 :
121711 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
121712 :
121713 :
121714 : // End of memberFunctionString
121715 : // Start of memberFunctionString
121716 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
121717 :
121718 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
121719 :
121720 : std::string
121721 0 : SgBasicBlock::get_string_label () const
121722 : {
121723 0 : ROSE_ASSERT (this != NULL);
121724 :
121725 : #if 0
121726 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
121727 : // used to trigger marking transformations for the token-based unparsing.
121728 : printf ("SgBasicBlock::get_string_label = %p = %s \n",this,this->class_name().c_str());
121729 : #endif
121730 :
121731 0 : return p_string_label;
121732 : }
121733 :
121734 : void
121735 0 : SgBasicBlock::set_string_label ( std::string string_label )
121736 : {
121737 0 : ROSE_ASSERT (this != NULL);
121738 :
121739 : #if 0
121740 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
121741 : // used to trigger marking transformations for the token-based unparsing.
121742 : printf ("SgBasicBlock::set_string_label = %p = %s \n",this,this->class_name().c_str());
121743 : #endif
121744 :
121745 0 : set_isModified(true);
121746 :
121747 0 : p_string_label = string_label;
121748 0 : }
121749 :
121750 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
121751 :
121752 :
121753 : // End of memberFunctionString
121754 : // Start of memberFunctionString
121755 : /* #line 9748 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
121756 :
121757 :
121758 28903 : SgBasicBlock::SgBasicBlock(Sg_File_Info* info, SgStatement* stmt)
121759 28903 : :SgScopeStatement(info)
121760 : {
121761 : /* now a call to the user defined initialization function */
121762 28903 : post_construction_initialization();
121763 28903 : if (stmt != NULL)
121764 : {
121765 0 : append_statement(stmt);
121766 :
121767 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121768 0 : ROSE_ASSERT(stmt->get_parent() != NULL);
121769 : }
121770 28903 : }
121771 :
121772 0 : SgBasicBlock::SgBasicBlock( SgStatement* stmt )
121773 0 : :SgScopeStatement()
121774 : {
121775 : /* now a call to the user defined initialization function */
121776 0 : post_construction_initialization();
121777 0 : if (stmt != NULL)
121778 : {
121779 0 : append_statement(stmt);
121780 :
121781 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121782 0 : ROSE_ASSERT(stmt->get_parent() != NULL);
121783 : }
121784 0 : }
121785 :
121786 : // DQ (9/8/2004): Added to support qualified name generation
121787 : SgName
121788 305 : SgBasicBlock::get_qualified_name() const
121789 : {
121790 : // DQ (8/28/2005): This is where we might name blocks if we select to do so at some point
121791 : // as a way of building unique names for qualified named declarations.
121792 :
121793 : // Note that this will still evaluate so that "returnName.is_null()" will be true
121794 305 : SgName returnName = "";
121795 305 : return returnName;
121796 : }
121797 :
121798 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
121799 : SgName
121800 11186 : SgBasicBlock::get_mangled_name(void) const
121801 : {
121802 11186 : return SgName ("");
121803 : }
121804 :
121805 : void
121806 28903 : SgBasicBlock::post_construction_initialization()
121807 : {
121808 : // Call the base class post_construction_initialization() member function
121809 : // SgScopeStatement::post_construction_initialization();
121810 :
121811 : #if 0
121812 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
121813 : printf ("In SgBasicBlock::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
121814 : #endif
121815 28903 : }
121816 :
121817 : void
121818 0 : SgBasicBlock::append_statement(SgStatement * what)
121819 : {
121820 : // printf ("In SgBasicBlock::append_statement(): Call to insert_statement() commented out \n");
121821 : // ROSE_ASSERT(false);
121822 :
121823 0 : get_statements().push_back(what);
121824 0 : what->set_parent(this);
121825 :
121826 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121827 0 : ROSE_ASSERT(what->get_parent() != NULL);
121828 0 : }
121829 :
121830 : #if 1
121831 : void
121832 0 : SgBasicBlock::prepend_statement(SgStatement *what)
121833 : {
121834 0 : get_statements().insert(get_statements().begin(), what);
121835 0 : what->set_parent(this);
121836 :
121837 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121838 0 : ROSE_ASSERT(what->get_parent() != NULL);
121839 0 : }
121840 : #endif
121841 :
121842 : #if 0
121843 : void
121844 : SgBasicBlock::append_statement(const SgStatementPtrList::iterator& where, SgStatement * what)
121845 : {
121846 : // Alternative that allows for appending after any statement in the list
121847 : // insert_statement(where,what);
121848 :
121849 : SgStatementPtrList::iterator tempIterator = where;
121850 : tempIterator++;
121851 : // Handle the case of appending at the end of the list
121852 : if ( tempIterator == get_statements().end() )
121853 : {
121854 : append_statement (what);
121855 : }
121856 : else
121857 : {
121858 : insert_statement (tempIterator,what);
121859 : }
121860 :
121861 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121862 : ROSE_ASSERT(what->get_parent() != NULL);
121863 : }
121864 : #endif
121865 :
121866 : #if 0
121867 : void
121868 : SgBasicBlock::prepend_statement(const SgStatementPtrList::iterator& where, SgStatement *what)
121869 : {
121870 : // Alternative that allows for prepending before any statement in the list
121871 : insert_statement(where, what);
121872 :
121873 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
121874 : ROSE_ASSERT(what->get_parent() != NULL);
121875 : }
121876 : #endif
121877 :
121878 : #if 0
121879 : void
121880 : SgBasicBlock::insert_statement(const SgStatementPtrList::iterator& where, SgStatement * what)
121881 : {
121882 : #ifndef REMOVE_SET_PARENT_FUNCTION
121883 : what->set_parent(this);
121884 : #endif
121885 :
121886 : #if PRINT_SIDE_EFFECT_WARNINGS
121887 : printf ("Warning Side-Effect: Calling set_parent on %p = %s (set to %p = %s) \n",what,what->sage_class_name(),this,sage_class_name());
121888 : #endif
121889 : what->set_parent(this);
121890 :
121891 : get_statements().insert(where,what);
121892 : }
121893 : #endif
121894 :
121895 : bool
121896 1821 : SgBasicBlock::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
121897 : {
121898 1821 : return StatementListInsertChild( this, p_statements, target, newstmt, true, extractBasicBlock, true);
121899 : }
121900 : //! insert newstmt before or after target. If extractBasicBlock is true AND newstmt is a basic
121901 : //block, insert statements from newstmt instead of inserting newstmt.
121902 : //target should be a child statement within this SgBasicBlock.
121903 : bool
121904 21347 : SgBasicBlock::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractBasicBlock)
121905 : {
121906 21347 : return StatementListInsertChild( this, p_statements, target, newstmt, inFront, extractBasicBlock, false);
121907 : }
121908 :
121909 :
121910 :
121911 : // End of memberFunctionString
121912 : // Start of memberFunctionString
121913 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
121914 :
121915 : // *** COMMON CODE SECTION BEGINS HERE ***
121916 :
121917 : #if 0
121918 : int
121919 : SgBasicBlock::getVariant() const
121920 : {
121921 : // This function is used in ROSE while "variant()" is used in SAGE
121922 : assert(this != NULL);
121923 : return variant();
121924 : }
121925 : #endif
121926 :
121927 : // This function is used in ROSE in treeTraversal code
121928 : // eventually replaces getVariant() and variant()
121929 : // though after variant() has been removed for a while we will
121930 : // want to change the name of variantT() back to variant()
121931 : // (since the "T" was ment to stand for temporary).
121932 : // When this happens the variantT() will be depricated.
121933 : VariantT
121934 24219400 : SgBasicBlock::variantT() const
121935 : {
121936 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
121937 24219400 : ROSE_ASSERT(this != NULL);
121938 24219400 : return V_SgBasicBlock;
121939 : }
121940 :
121941 : #if 0
121942 : int
121943 : SgBasicBlock::variant() const
121944 : {
121945 : // This function is used in SAGE
121946 : ROSE_ASSERT(this != NULL);
121947 : return BASIC_BLOCK_STMT;
121948 : }
121949 : #endif
121950 :
121951 : ROSE_DLL_API const char*
121952 2301 : SgBasicBlock::sage_class_name() const
121953 : {
121954 2301 : ROSE_ASSERT(this != NULL);
121955 2301 : return "SgBasicBlock";
121956 : }
121957 :
121958 : std::string
121959 177945 : SgBasicBlock::class_name() const
121960 : {
121961 177945 : ROSE_ASSERT(this != NULL);
121962 177945 : return "SgBasicBlock";
121963 : }
121964 :
121965 : // DQ (11/26/2005): Support for visitor pattern mechanims
121966 : // (inferior to ROSE traversal mechanism, experimental).
121967 : void
121968 403228 : SgBasicBlock::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
121969 : {
121970 403228 : ROSE_ASSERT(this != NULL);
121971 403228 : visitor.visit(this);
121972 403228 : }
121973 :
121974 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
121975 0 : void SgBasicBlock::accept (ROSE_VisitorPattern & visitor) {
121976 0 : ROSE_ASSERT(this != NULL);
121977 0 : visitor.visit(this);
121978 0 : }
121979 :
121980 : SgBasicBlock*
121981 0 : SgBasicBlock::addRegExpAttribute(std::string s, AstRegExAttribute* a)
121982 : {
121983 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
121984 : // This function is currently only supported for the AST used the represent Binary executables.
121985 : if (0 /* isSgAsmNode(this) != NULL */)
121986 : {
121987 : // Support for regex specification.
121988 : std::string prefixCode = "REGEX:";
121989 : addNewAttribute(prefixCode + s,a);
121990 : }
121991 : #endif
121992 :
121993 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
121994 0 : return this;
121995 : }
121996 :
121997 : // *** COMMON CODE SECTION ENDS HERE ***
121998 :
121999 :
122000 : // End of memberFunctionString
122001 : // Start of memberFunctionString
122002 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
122003 :
122004 :
122005 : #if 0
122006 : //! Error checking support
122007 : /*! Verifies the following:
122008 : - working getVariant() member function
122009 : - calls base class's error() member function
122010 : Every class has one of these functions.
122011 : */
122012 : bool
122013 : SgBasicBlock::error()
122014 : {
122015 : // Put error checking here
122016 :
122017 : ROSE_ASSERT (this != NULL);
122018 : if (getVariant() != BASIC_BLOCK_STMT)
122019 : {
122020 : printf ("Error in SgBasicBlock::error(): SgBasicBlock object has a %s variant \n",
122021 : Cxx_GrammarTerminalNames[getVariant()].name);
122022 : // printf ("Error in SgBasicBlock::error() \n");
122023 : ROSE_ABORT();
122024 : }
122025 :
122026 : ROSE_ASSERT (getVariant() == BASIC_BLOCK_STMT);
122027 : return SgScopeStatement::error();
122028 : }
122029 : #endif
122030 :
122031 :
122032 :
122033 : // End of memberFunctionString
122034 :
122035 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
122036 :
122037 171817 : SgBasicBlock* isSgBasicBlock ( SgNode* inputDerivedClassPointer )
122038 : {
122039 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
122040 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
122041 : // So to fix this we return NULL directly when the input is NULL and avoid the
122042 : // dynamic_cast in this case. This is likely a performance improvement as well.
122043 : // return dynamic_cast<SgBasicBlock*>(inputDerivedClassPointer);
122044 : // Milind Chabbi (8/28/2013): isSgBasicBlock uses table-driven castability instead of c++ default dynamic_cast
122045 : // this improves the running time performance by 10-20%.
122046 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBasicBlock*>(inputDerivedClassPointer);
122047 171817 : return IS_SgBasicBlock_FAST_MACRO(inputDerivedClassPointer);
122048 : }
122049 :
122050 : // DQ (11/8/2003): Added version of functions taking const pointer
122051 18987 : const SgBasicBlock* isSgBasicBlock ( const SgNode* inputDerivedClassPointer )
122052 : {
122053 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
122054 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
122055 : // So to fix this we return NULL directly when the input is NULL and avoid the
122056 : // dynamic_cast in this case. This is likely a performance improvement as well.
122057 : // return dynamic_cast<const SgBasicBlock*>(inputDerivedClassPointer);
122058 : // Milind Chabbi (8/28/2013): isSgBasicBlock uses table-driven castability instead of c++ default dynamic_cast
122059 : // this improves the running time performance by 10-20%.
122060 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBasicBlock*>(inputDerivedClassPointer);
122061 18987 : return IS_SgBasicBlock_FAST_MACRO(inputDerivedClassPointer);
122062 : }
122063 :
122064 :
122065 :
122066 : /* #line 122067 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122067 :
122068 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
122069 :
122070 : /**
122071 : \brief Generated destructor
122072 :
122073 : This destructor is automatically generated (by ROSETTA). This destructor
122074 : only frees memory of data members associated with the parts of the current IR node which
122075 : are NOT traversed. Those data members that are part of a traversal can be freed using
122076 : a traversal (calling this destructor on all children in a post-order traversal). Such
122077 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
122078 :
122079 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
122080 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
122081 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
122082 :
122083 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
122084 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
122085 : pointers are not yet implemented to call delete on eash pointer in the container.
122086 : (This could be done by derivation from the STL containers to define containers that
122087 : automatically deleted their members.)
122088 :
122089 : */
122090 16601 : SgBasicBlock::~SgBasicBlock () {
122091 5731 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
122092 :
122093 :
122094 : // case: not a listType for asm_function_body
122095 5731 : p_asm_function_body = ""; // non list case
122096 : // case: not a listType for string_label
122097 5731 : p_string_label = ""; // non list case
122098 :
122099 : }
122100 :
122101 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
122102 11462 : }
122103 :
122104 :
122105 : /* #line 122106 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122106 :
122107 :
122108 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
122109 :
122110 :
122111 : // ********************************************************
122112 : // member functions common across all array grammar objects
122113 : // ********************************************************
122114 :
122115 :
122116 :
122117 : /* #line 122118 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122118 :
122119 :
122120 :
122121 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
122122 :
122123 : // ********************************************************
122124 : // member functions specific to each node in the grammar
122125 : // ********************************************************
122126 :
122127 :
122128 : /* #line 122129 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122129 :
122130 : // Start of memberFunctionString
122131 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122132 :
122133 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122134 :
122135 : SgStatement*
122136 11672 : SgIfStmt::get_conditional () const
122137 : {
122138 11672 : ROSE_ASSERT (this != NULL);
122139 :
122140 : #if 0
122141 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122142 : // used to trigger marking transformations for the token-based unparsing.
122143 : printf ("SgIfStmt::get_conditional = %p = %s \n",this,this->class_name().c_str());
122144 : #endif
122145 :
122146 11672 : return p_conditional;
122147 : }
122148 :
122149 : void
122150 5314 : SgIfStmt::set_conditional ( SgStatement* conditional )
122151 : {
122152 5314 : ROSE_ASSERT (this != NULL);
122153 :
122154 : #if 0
122155 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122156 : // used to trigger marking transformations for the token-based unparsing.
122157 : printf ("SgIfStmt::set_conditional = %p = %s \n",this,this->class_name().c_str());
122158 : #endif
122159 :
122160 5314 : set_isModified(true);
122161 :
122162 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
122163 : if (p_conditional != NULL && conditional != NULL && p_conditional != conditional)
122164 : {
122165 : printf ("Warning: conditional = %p overwriting valid pointer p_conditional = %p \n",conditional,p_conditional);
122166 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
122167 : printf ("Error fails assertion (p_conditional != NULL && conditional != NULL && p_conditional != conditional) is false\n");
122168 : ROSE_ASSERT(false);
122169 : #endif
122170 : }
122171 : #endif
122172 5314 : p_conditional = conditional;
122173 5314 : }
122174 :
122175 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122176 :
122177 :
122178 : // End of memberFunctionString
122179 : // Start of memberFunctionString
122180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122181 :
122182 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122183 :
122184 : SgStatement*
122185 18845 : SgIfStmt::get_true_body () const
122186 : {
122187 18845 : ROSE_ASSERT (this != NULL);
122188 :
122189 : #if 0
122190 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122191 : // used to trigger marking transformations for the token-based unparsing.
122192 : printf ("SgIfStmt::get_true_body = %p = %s \n",this,this->class_name().c_str());
122193 : #endif
122194 :
122195 18845 : return p_true_body;
122196 : }
122197 :
122198 : void
122199 5318 : SgIfStmt::set_true_body ( SgStatement* true_body )
122200 : {
122201 5318 : ROSE_ASSERT (this != NULL);
122202 :
122203 : #if 0
122204 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122205 : // used to trigger marking transformations for the token-based unparsing.
122206 : printf ("SgIfStmt::set_true_body = %p = %s \n",this,this->class_name().c_str());
122207 : #endif
122208 :
122209 5318 : set_isModified(true);
122210 :
122211 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
122212 : if (p_true_body != NULL && true_body != NULL && p_true_body != true_body)
122213 : {
122214 : printf ("Warning: true_body = %p overwriting valid pointer p_true_body = %p \n",true_body,p_true_body);
122215 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
122216 : printf ("Error fails assertion (p_true_body != NULL && true_body != NULL && p_true_body != true_body) is false\n");
122217 : ROSE_ASSERT(false);
122218 : #endif
122219 : }
122220 : #endif
122221 5318 : p_true_body = true_body;
122222 5318 : }
122223 :
122224 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122225 :
122226 :
122227 : // End of memberFunctionString
122228 : // Start of memberFunctionString
122229 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122230 :
122231 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122232 :
122233 : SgStatement*
122234 19769 : SgIfStmt::get_false_body () const
122235 : {
122236 19769 : ROSE_ASSERT (this != NULL);
122237 :
122238 : #if 0
122239 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122240 : // used to trigger marking transformations for the token-based unparsing.
122241 : printf ("SgIfStmt::get_false_body = %p = %s \n",this,this->class_name().c_str());
122242 : #endif
122243 :
122244 19769 : return p_false_body;
122245 : }
122246 :
122247 : void
122248 5376 : SgIfStmt::set_false_body ( SgStatement* false_body )
122249 : {
122250 5376 : ROSE_ASSERT (this != NULL);
122251 :
122252 : #if 0
122253 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122254 : // used to trigger marking transformations for the token-based unparsing.
122255 : printf ("SgIfStmt::set_false_body = %p = %s \n",this,this->class_name().c_str());
122256 : #endif
122257 :
122258 5376 : set_isModified(true);
122259 :
122260 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
122261 : if (p_false_body != NULL && false_body != NULL && p_false_body != false_body)
122262 : {
122263 : printf ("Warning: false_body = %p overwriting valid pointer p_false_body = %p \n",false_body,p_false_body);
122264 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
122265 : printf ("Error fails assertion (p_false_body != NULL && false_body != NULL && p_false_body != false_body) is false\n");
122266 : ROSE_ASSERT(false);
122267 : #endif
122268 : }
122269 : #endif
122270 5376 : p_false_body = false_body;
122271 5376 : }
122272 :
122273 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122274 :
122275 :
122276 : // End of memberFunctionString
122277 : // Start of memberFunctionString
122278 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122279 :
122280 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122281 :
122282 : bool
122283 0 : SgIfStmt::get_is_if_constexpr_statement () const
122284 : {
122285 0 : ROSE_ASSERT (this != NULL);
122286 :
122287 : #if 0
122288 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122289 : // used to trigger marking transformations for the token-based unparsing.
122290 : printf ("SgIfStmt::get_is_if_constexpr_statement = %p = %s \n",this,this->class_name().c_str());
122291 : #endif
122292 :
122293 0 : return p_is_if_constexpr_statement;
122294 : }
122295 :
122296 : void
122297 0 : SgIfStmt::set_is_if_constexpr_statement ( bool is_if_constexpr_statement )
122298 : {
122299 0 : ROSE_ASSERT (this != NULL);
122300 :
122301 : #if 0
122302 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122303 : // used to trigger marking transformations for the token-based unparsing.
122304 : printf ("SgIfStmt::set_is_if_constexpr_statement = %p = %s \n",this,this->class_name().c_str());
122305 : #endif
122306 :
122307 0 : set_isModified(true);
122308 :
122309 0 : p_is_if_constexpr_statement = is_if_constexpr_statement;
122310 0 : }
122311 :
122312 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122313 :
122314 :
122315 : // End of memberFunctionString
122316 : // Start of memberFunctionString
122317 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122318 :
122319 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122320 :
122321 : bool
122322 0 : SgIfStmt::get_if_constexpr_value_known () const
122323 : {
122324 0 : ROSE_ASSERT (this != NULL);
122325 :
122326 : #if 0
122327 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122328 : // used to trigger marking transformations for the token-based unparsing.
122329 : printf ("SgIfStmt::get_if_constexpr_value_known = %p = %s \n",this,this->class_name().c_str());
122330 : #endif
122331 :
122332 0 : return p_if_constexpr_value_known;
122333 : }
122334 :
122335 : void
122336 0 : SgIfStmt::set_if_constexpr_value_known ( bool if_constexpr_value_known )
122337 : {
122338 0 : ROSE_ASSERT (this != NULL);
122339 :
122340 : #if 0
122341 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122342 : // used to trigger marking transformations for the token-based unparsing.
122343 : printf ("SgIfStmt::set_if_constexpr_value_known = %p = %s \n",this,this->class_name().c_str());
122344 : #endif
122345 :
122346 0 : set_isModified(true);
122347 :
122348 0 : p_if_constexpr_value_known = if_constexpr_value_known;
122349 0 : }
122350 :
122351 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122352 :
122353 :
122354 : // End of memberFunctionString
122355 : // Start of memberFunctionString
122356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122357 :
122358 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122359 :
122360 : bool
122361 0 : SgIfStmt::get_if_constexpr_value () const
122362 : {
122363 0 : ROSE_ASSERT (this != NULL);
122364 :
122365 : #if 0
122366 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122367 : // used to trigger marking transformations for the token-based unparsing.
122368 : printf ("SgIfStmt::get_if_constexpr_value = %p = %s \n",this,this->class_name().c_str());
122369 : #endif
122370 :
122371 0 : return p_if_constexpr_value;
122372 : }
122373 :
122374 : void
122375 0 : SgIfStmt::set_if_constexpr_value ( bool if_constexpr_value )
122376 : {
122377 0 : ROSE_ASSERT (this != NULL);
122378 :
122379 : #if 0
122380 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122381 : // used to trigger marking transformations for the token-based unparsing.
122382 : printf ("SgIfStmt::set_if_constexpr_value = %p = %s \n",this,this->class_name().c_str());
122383 : #endif
122384 :
122385 0 : set_isModified(true);
122386 :
122387 0 : p_if_constexpr_value = if_constexpr_value;
122388 0 : }
122389 :
122390 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122391 :
122392 :
122393 : // End of memberFunctionString
122394 : // Start of memberFunctionString
122395 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122396 :
122397 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122398 :
122399 : SgLabelRefExp*
122400 1 : SgIfStmt::get_else_numeric_label () const
122401 : {
122402 1 : ROSE_ASSERT (this != NULL);
122403 :
122404 : #if 0
122405 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122406 : // used to trigger marking transformations for the token-based unparsing.
122407 : printf ("SgIfStmt::get_else_numeric_label = %p = %s \n",this,this->class_name().c_str());
122408 : #endif
122409 :
122410 1 : return p_else_numeric_label;
122411 : }
122412 :
122413 : void
122414 0 : SgIfStmt::set_else_numeric_label ( SgLabelRefExp* else_numeric_label )
122415 : {
122416 0 : ROSE_ASSERT (this != NULL);
122417 :
122418 : #if 0
122419 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122420 : // used to trigger marking transformations for the token-based unparsing.
122421 : printf ("SgIfStmt::set_else_numeric_label = %p = %s \n",this,this->class_name().c_str());
122422 : #endif
122423 :
122424 0 : set_isModified(true);
122425 :
122426 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
122427 : if (p_else_numeric_label != NULL && else_numeric_label != NULL && p_else_numeric_label != else_numeric_label)
122428 : {
122429 : printf ("Warning: else_numeric_label = %p overwriting valid pointer p_else_numeric_label = %p \n",else_numeric_label,p_else_numeric_label);
122430 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
122431 : printf ("Error fails assertion (p_else_numeric_label != NULL && else_numeric_label != NULL && p_else_numeric_label != else_numeric_label) is false\n");
122432 : ROSE_ASSERT(false);
122433 : #endif
122434 : }
122435 : #endif
122436 0 : p_else_numeric_label = else_numeric_label;
122437 0 : }
122438 :
122439 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122440 :
122441 :
122442 : // End of memberFunctionString
122443 : // Start of memberFunctionString
122444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122445 :
122446 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122447 :
122448 : std::string
122449 3 : SgIfStmt::get_string_label () const
122450 : {
122451 3 : ROSE_ASSERT (this != NULL);
122452 :
122453 : #if 0
122454 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122455 : // used to trigger marking transformations for the token-based unparsing.
122456 : printf ("SgIfStmt::get_string_label = %p = %s \n",this,this->class_name().c_str());
122457 : #endif
122458 :
122459 3 : return p_string_label;
122460 : }
122461 :
122462 : void
122463 0 : SgIfStmt::set_string_label ( std::string string_label )
122464 : {
122465 0 : ROSE_ASSERT (this != NULL);
122466 :
122467 : #if 0
122468 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122469 : // used to trigger marking transformations for the token-based unparsing.
122470 : printf ("SgIfStmt::set_string_label = %p = %s \n",this,this->class_name().c_str());
122471 : #endif
122472 :
122473 0 : set_isModified(true);
122474 :
122475 0 : p_string_label = string_label;
122476 0 : }
122477 :
122478 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122479 :
122480 :
122481 : // End of memberFunctionString
122482 : // Start of memberFunctionString
122483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122484 :
122485 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122486 :
122487 : SgLabelRefExp*
122488 1 : SgIfStmt::get_end_numeric_label () const
122489 : {
122490 1 : ROSE_ASSERT (this != NULL);
122491 :
122492 : #if 0
122493 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122494 : // used to trigger marking transformations for the token-based unparsing.
122495 : printf ("SgIfStmt::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
122496 : #endif
122497 :
122498 1 : return p_end_numeric_label;
122499 : }
122500 :
122501 : void
122502 0 : SgIfStmt::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
122503 : {
122504 0 : ROSE_ASSERT (this != NULL);
122505 :
122506 : #if 0
122507 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122508 : // used to trigger marking transformations for the token-based unparsing.
122509 : printf ("SgIfStmt::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
122510 : #endif
122511 :
122512 0 : set_isModified(true);
122513 :
122514 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
122515 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
122516 : {
122517 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
122518 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
122519 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
122520 : ROSE_ASSERT(false);
122521 : #endif
122522 : }
122523 : #endif
122524 0 : p_end_numeric_label = end_numeric_label;
122525 0 : }
122526 :
122527 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122528 :
122529 :
122530 : // End of memberFunctionString
122531 : // Start of memberFunctionString
122532 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122533 :
122534 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122535 :
122536 : bool
122537 3 : SgIfStmt::get_has_end_statement () const
122538 : {
122539 3 : ROSE_ASSERT (this != NULL);
122540 :
122541 : #if 0
122542 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122543 : // used to trigger marking transformations for the token-based unparsing.
122544 : printf ("SgIfStmt::get_has_end_statement = %p = %s \n",this,this->class_name().c_str());
122545 : #endif
122546 :
122547 3 : return p_has_end_statement;
122548 : }
122549 :
122550 : void
122551 1 : SgIfStmt::set_has_end_statement ( bool has_end_statement )
122552 : {
122553 1 : ROSE_ASSERT (this != NULL);
122554 :
122555 : #if 0
122556 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122557 : // used to trigger marking transformations for the token-based unparsing.
122558 : printf ("SgIfStmt::set_has_end_statement = %p = %s \n",this,this->class_name().c_str());
122559 : #endif
122560 :
122561 1 : set_isModified(true);
122562 :
122563 1 : p_has_end_statement = has_end_statement;
122564 1 : }
122565 :
122566 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122567 :
122568 :
122569 : // End of memberFunctionString
122570 : // Start of memberFunctionString
122571 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122572 :
122573 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122574 :
122575 : bool
122576 2 : SgIfStmt::get_use_then_keyword () const
122577 : {
122578 2 : ROSE_ASSERT (this != NULL);
122579 :
122580 : #if 0
122581 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122582 : // used to trigger marking transformations for the token-based unparsing.
122583 : printf ("SgIfStmt::get_use_then_keyword = %p = %s \n",this,this->class_name().c_str());
122584 : #endif
122585 :
122586 2 : return p_use_then_keyword;
122587 : }
122588 :
122589 : void
122590 2 : SgIfStmt::set_use_then_keyword ( bool use_then_keyword )
122591 : {
122592 2 : ROSE_ASSERT (this != NULL);
122593 :
122594 : #if 0
122595 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122596 : // used to trigger marking transformations for the token-based unparsing.
122597 : printf ("SgIfStmt::set_use_then_keyword = %p = %s \n",this,this->class_name().c_str());
122598 : #endif
122599 :
122600 2 : set_isModified(true);
122601 :
122602 2 : p_use_then_keyword = use_then_keyword;
122603 2 : }
122604 :
122605 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122606 :
122607 :
122608 : // End of memberFunctionString
122609 : // Start of memberFunctionString
122610 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122611 :
122612 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122613 :
122614 : bool
122615 0 : SgIfStmt::get_is_else_if_statement () const
122616 : {
122617 0 : ROSE_ASSERT (this != NULL);
122618 :
122619 : #if 0
122620 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122621 : // used to trigger marking transformations for the token-based unparsing.
122622 : printf ("SgIfStmt::get_is_else_if_statement = %p = %s \n",this,this->class_name().c_str());
122623 : #endif
122624 :
122625 0 : return p_is_else_if_statement;
122626 : }
122627 :
122628 : void
122629 0 : SgIfStmt::set_is_else_if_statement ( bool is_else_if_statement )
122630 : {
122631 0 : ROSE_ASSERT (this != NULL);
122632 :
122633 : #if 0
122634 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
122635 : // used to trigger marking transformations for the token-based unparsing.
122636 : printf ("SgIfStmt::set_is_else_if_statement = %p = %s \n",this,this->class_name().c_str());
122637 : #endif
122638 :
122639 0 : set_isModified(true);
122640 :
122641 0 : p_is_else_if_statement = is_else_if_statement;
122642 0 : }
122643 :
122644 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
122645 :
122646 :
122647 : // End of memberFunctionString
122648 : // Start of memberFunctionString
122649 : /* #line 9904 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
122650 :
122651 : void
122652 5317 : SgIfStmt::post_construction_initialization()
122653 : {
122654 : // DQ (12/17/2006): This function should have the semantics that it will represent a
122655 : // structural change to the AST, thus it is free to set the parent of the new expression.
122656 :
122657 : // printf ("Note: modified SgIfStmt::post_construction_initialization() to set parents of conditional, true_body, and false_body \n");
122658 :
122659 : // #ifndef REMOVE_SET_PARENT_FUNCTION
122660 5317 : if (get_conditional() != NULL) get_conditional()->set_parent(this);
122661 5317 : if (get_true_body() != NULL) get_true_body ()->set_parent(this);
122662 5317 : if (get_false_body() != NULL) get_false_body ()->set_parent(this);
122663 : // #endif
122664 :
122665 : #if 0
122666 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
122667 : printf ("In SgIfStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
122668 : #endif
122669 5317 : }
122670 :
122671 : bool
122672 687 : SgIfStmt::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
122673 : {
122674 687 : if (StatementReplace(this, p_conditional, target, newstmt) == true)
122675 : {
122676 687 : return true;
122677 : }
122678 : else
122679 : {
122680 0 : if (StatementReplace(this, p_true_body, target, newstmt) == true)
122681 : {
122682 0 : return true;
122683 : }
122684 : else
122685 : {
122686 0 : if (StatementReplace(this, p_false_body, target, newstmt) == true)
122687 : {
122688 0 : return true;
122689 : }
122690 : else
122691 : {
122692 : return false;
122693 : }
122694 : }
122695 : }
122696 : }
122697 :
122698 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
122699 : SgName
122700 79 : SgIfStmt::get_mangled_name(void) const
122701 : {
122702 79 : return SgName ("");
122703 : }
122704 :
122705 :
122706 :
122707 : // End of memberFunctionString
122708 : // Start of memberFunctionString
122709 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
122710 :
122711 : // *** COMMON CODE SECTION BEGINS HERE ***
122712 :
122713 : #if 0
122714 : int
122715 : SgIfStmt::getVariant() const
122716 : {
122717 : // This function is used in ROSE while "variant()" is used in SAGE
122718 : assert(this != NULL);
122719 : return variant();
122720 : }
122721 : #endif
122722 :
122723 : // This function is used in ROSE in treeTraversal code
122724 : // eventually replaces getVariant() and variant()
122725 : // though after variant() has been removed for a while we will
122726 : // want to change the name of variantT() back to variant()
122727 : // (since the "T" was ment to stand for temporary).
122728 : // When this happens the variantT() will be depricated.
122729 : VariantT
122730 2186060 : SgIfStmt::variantT() const
122731 : {
122732 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
122733 2186060 : ROSE_ASSERT(this != NULL);
122734 2186060 : return V_SgIfStmt;
122735 : }
122736 :
122737 : #if 0
122738 : int
122739 : SgIfStmt::variant() const
122740 : {
122741 : // This function is used in SAGE
122742 : ROSE_ASSERT(this != NULL);
122743 : return IF_STMT;
122744 : }
122745 : #endif
122746 :
122747 : ROSE_DLL_API const char*
122748 239 : SgIfStmt::sage_class_name() const
122749 : {
122750 239 : ROSE_ASSERT(this != NULL);
122751 239 : return "SgIfStmt";
122752 : }
122753 :
122754 : std::string
122755 17214 : SgIfStmt::class_name() const
122756 : {
122757 17214 : ROSE_ASSERT(this != NULL);
122758 17214 : return "SgIfStmt";
122759 : }
122760 :
122761 : // DQ (11/26/2005): Support for visitor pattern mechanims
122762 : // (inferior to ROSE traversal mechanism, experimental).
122763 : void
122764 82870 : SgIfStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
122765 : {
122766 82870 : ROSE_ASSERT(this != NULL);
122767 82870 : visitor.visit(this);
122768 82870 : }
122769 :
122770 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
122771 0 : void SgIfStmt::accept (ROSE_VisitorPattern & visitor) {
122772 0 : ROSE_ASSERT(this != NULL);
122773 0 : visitor.visit(this);
122774 0 : }
122775 :
122776 : SgIfStmt*
122777 0 : SgIfStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
122778 : {
122779 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
122780 : // This function is currently only supported for the AST used the represent Binary executables.
122781 : if (0 /* isSgAsmNode(this) != NULL */)
122782 : {
122783 : // Support for regex specification.
122784 : std::string prefixCode = "REGEX:";
122785 : addNewAttribute(prefixCode + s,a);
122786 : }
122787 : #endif
122788 :
122789 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
122790 0 : return this;
122791 : }
122792 :
122793 : // *** COMMON CODE SECTION ENDS HERE ***
122794 :
122795 :
122796 : // End of memberFunctionString
122797 : // Start of memberFunctionString
122798 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
122799 :
122800 :
122801 : #if 0
122802 : //! Error checking support
122803 : /*! Verifies the following:
122804 : - working getVariant() member function
122805 : - calls base class's error() member function
122806 : Every class has one of these functions.
122807 : */
122808 : bool
122809 : SgIfStmt::error()
122810 : {
122811 : // Put error checking here
122812 :
122813 : ROSE_ASSERT (this != NULL);
122814 : if (getVariant() != IF_STMT)
122815 : {
122816 : printf ("Error in SgIfStmt::error(): SgIfStmt object has a %s variant \n",
122817 : Cxx_GrammarTerminalNames[getVariant()].name);
122818 : // printf ("Error in SgIfStmt::error() \n");
122819 : ROSE_ABORT();
122820 : }
122821 :
122822 : ROSE_ASSERT (getVariant() == IF_STMT);
122823 : return SgScopeStatement::error();
122824 : }
122825 : #endif
122826 :
122827 :
122828 :
122829 : // End of memberFunctionString
122830 :
122831 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
122832 :
122833 982579 : SgIfStmt* isSgIfStmt ( SgNode* inputDerivedClassPointer )
122834 : {
122835 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
122836 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
122837 : // So to fix this we return NULL directly when the input is NULL and avoid the
122838 : // dynamic_cast in this case. This is likely a performance improvement as well.
122839 : // return dynamic_cast<SgIfStmt*>(inputDerivedClassPointer);
122840 : // Milind Chabbi (8/28/2013): isSgIfStmt uses table-driven castability instead of c++ default dynamic_cast
122841 : // this improves the running time performance by 10-20%.
122842 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIfStmt*>(inputDerivedClassPointer);
122843 982579 : return IS_SgIfStmt_FAST_MACRO(inputDerivedClassPointer);
122844 : }
122845 :
122846 : // DQ (11/8/2003): Added version of functions taking const pointer
122847 34336 : const SgIfStmt* isSgIfStmt ( const SgNode* inputDerivedClassPointer )
122848 : {
122849 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
122850 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
122851 : // So to fix this we return NULL directly when the input is NULL and avoid the
122852 : // dynamic_cast in this case. This is likely a performance improvement as well.
122853 : // return dynamic_cast<const SgIfStmt*>(inputDerivedClassPointer);
122854 : // Milind Chabbi (8/28/2013): isSgIfStmt uses table-driven castability instead of c++ default dynamic_cast
122855 : // this improves the running time performance by 10-20%.
122856 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIfStmt*>(inputDerivedClassPointer);
122857 34336 : return IS_SgIfStmt_FAST_MACRO(inputDerivedClassPointer);
122858 : }
122859 :
122860 :
122861 :
122862 : /* #line 122863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122863 :
122864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
122865 :
122866 : /**
122867 : \brief Generated destructor
122868 :
122869 : This destructor is automatically generated (by ROSETTA). This destructor
122870 : only frees memory of data members associated with the parts of the current IR node which
122871 : are NOT traversed. Those data members that are part of a traversal can be freed using
122872 : a traversal (calling this destructor on all children in a post-order traversal). Such
122873 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
122874 :
122875 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
122876 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
122877 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
122878 :
122879 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
122880 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
122881 : pointers are not yet implemented to call delete on eash pointer in the container.
122882 : (This could be done by derivation from the STL containers to define containers that
122883 : automatically deleted their members.)
122884 :
122885 : */
122886 2368 : SgIfStmt::~SgIfStmt () {
122887 1184 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
122888 :
122889 :
122890 : // case: not a listType for conditional
122891 1184 : p_conditional = NULL; // non list case
122892 : // case: not a listType for true_body
122893 1184 : p_true_body = NULL; // non list case
122894 : // case: not a listType for false_body
122895 1184 : p_false_body = NULL; // non list case
122896 : // case: not a listType for is_if_constexpr_statement
122897 1184 : p_is_if_constexpr_statement = false; // non list case
122898 : // case: not a listType for if_constexpr_value_known
122899 1184 : p_if_constexpr_value_known = false; // non list case
122900 : // case: not a listType for if_constexpr_value
122901 1184 : p_if_constexpr_value = false; // non list case
122902 : // case: not a listType for else_numeric_label
122903 1184 : p_else_numeric_label = NULL; // non list case
122904 : // case: not a listType for string_label
122905 1184 : p_string_label = ""; // non list case
122906 : // case: not a listType for end_numeric_label
122907 1184 : p_end_numeric_label = NULL; // non list case
122908 : // case: not a listType for has_end_statement
122909 1184 : p_has_end_statement = false; // non list case
122910 : // case: not a listType for use_then_keyword
122911 1184 : p_use_then_keyword = false; // non list case
122912 : // case: not a listType for is_else_if_statement
122913 1184 : p_is_else_if_statement = false; // non list case
122914 :
122915 : }
122916 :
122917 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
122918 2368 : }
122919 :
122920 :
122921 : /* #line 122922 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122922 :
122923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
122924 :
122925 : // Generated constructor
122926 0 : SgIfStmt::SgIfStmt ( Sg_File_Info* startOfConstruct, SgStatement* conditional, SgStatement* true_body, SgStatement* false_body )
122927 0 : : SgScopeStatement(startOfConstruct)
122928 : {
122929 : #ifdef DEBUG
122930 : // printf ("In SgIfStmt::SgIfStmt (Sg_File_Info* startOfConstruct, SgStatement* conditional, SgStatement* true_body, SgStatement* false_body) sage_class_name() = %s \n",sage_class_name());
122931 : #endif
122932 : #if 0
122933 : // debugging information!
122934 : printf ("In SgIfStmt::SgIfStmt (Sg_File_Info* startOfConstruct, SgStatement* conditional, SgStatement* true_body, SgStatement* false_body): this = %p = %s \n",this,this->class_name().c_str());
122935 : #endif
122936 :
122937 0 : p_conditional = conditional;
122938 0 : p_true_body = true_body;
122939 0 : p_false_body = false_body;
122940 0 : p_is_if_constexpr_statement = false;
122941 0 : p_if_constexpr_value_known = false;
122942 0 : p_if_constexpr_value = false;
122943 0 : p_else_numeric_label = NULL;
122944 0 : p_string_label = "";
122945 0 : p_end_numeric_label = NULL;
122946 0 : p_has_end_statement = false;
122947 0 : p_use_then_keyword = false;
122948 0 : p_is_else_if_statement = false;
122949 :
122950 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
122951 :
122952 : #if 0
122953 : // DQ (7/30/2014): Call a virtual function.
122954 : std::string s = this->class_name();
122955 : #endif
122956 :
122957 : // Test the variant virtual function
122958 : // assert(IF_STMT == variant());
122959 0 : assert(IF_STMT == this->variant());
122960 0 : ROSE_ASSERT(IF_STMT == (int)(this->variantT()));
122961 0 : post_construction_initialization();
122962 :
122963 : // Test the isSgIfStmt() function since it has been problematic
122964 0 : assert(isSgIfStmt(this) != NULL);
122965 0 : }
122966 :
122967 : // Generated constructor (all data members)
122968 :
122969 : /* #line 122970 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122970 :
122971 :
122972 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
122973 :
122974 :
122975 : // ********************************************************
122976 : // member functions common across all array grammar objects
122977 : // ********************************************************
122978 :
122979 :
122980 :
122981 : /* #line 122982 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122982 :
122983 :
122984 :
122985 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
122986 :
122987 : // ********************************************************
122988 : // member functions specific to each node in the grammar
122989 : // ********************************************************
122990 :
122991 :
122992 : /* #line 122993 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
122993 :
122994 : // Start of memberFunctionString
122995 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
122996 :
122997 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
122998 :
122999 : SgForInitStatement*
123000 6636 : SgForStatement::get_for_init_stmt () const
123001 : {
123002 6636 : ROSE_ASSERT (this != NULL);
123003 :
123004 : #if 0
123005 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123006 : // used to trigger marking transformations for the token-based unparsing.
123007 : printf ("SgForStatement::get_for_init_stmt = %p = %s \n",this,this->class_name().c_str());
123008 : #endif
123009 :
123010 6636 : return p_for_init_stmt;
123011 : }
123012 :
123013 : void
123014 2907 : SgForStatement::set_for_init_stmt ( SgForInitStatement* for_init_stmt )
123015 : {
123016 2907 : ROSE_ASSERT (this != NULL);
123017 :
123018 : #if 0
123019 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123020 : // used to trigger marking transformations for the token-based unparsing.
123021 : printf ("SgForStatement::set_for_init_stmt = %p = %s \n",this,this->class_name().c_str());
123022 : #endif
123023 :
123024 2907 : set_isModified(true);
123025 :
123026 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
123027 : if (p_for_init_stmt != NULL && for_init_stmt != NULL && p_for_init_stmt != for_init_stmt)
123028 : {
123029 : printf ("Warning: for_init_stmt = %p overwriting valid pointer p_for_init_stmt = %p \n",for_init_stmt,p_for_init_stmt);
123030 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
123031 : printf ("Error fails assertion (p_for_init_stmt != NULL && for_init_stmt != NULL && p_for_init_stmt != for_init_stmt) is false\n");
123032 : ROSE_ASSERT(false);
123033 : #endif
123034 : }
123035 : #endif
123036 2907 : p_for_init_stmt = for_init_stmt;
123037 2907 : }
123038 :
123039 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123040 :
123041 :
123042 : // End of memberFunctionString
123043 : // Start of memberFunctionString
123044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
123045 :
123046 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
123047 :
123048 : SgStatement*
123049 3639 : SgForStatement::get_test () const
123050 : {
123051 3639 : ROSE_ASSERT (this != NULL);
123052 :
123053 : #if 0
123054 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123055 : // used to trigger marking transformations for the token-based unparsing.
123056 : printf ("SgForStatement::get_test = %p = %s \n",this,this->class_name().c_str());
123057 : #endif
123058 :
123059 3639 : return p_test;
123060 : }
123061 :
123062 : void
123063 960 : SgForStatement::set_test ( SgStatement* test )
123064 : {
123065 960 : ROSE_ASSERT (this != NULL);
123066 :
123067 : #if 0
123068 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123069 : // used to trigger marking transformations for the token-based unparsing.
123070 : printf ("SgForStatement::set_test = %p = %s \n",this,this->class_name().c_str());
123071 : #endif
123072 :
123073 960 : set_isModified(true);
123074 :
123075 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
123076 : if (p_test != NULL && test != NULL && p_test != test)
123077 : {
123078 : printf ("Warning: test = %p overwriting valid pointer p_test = %p \n",test,p_test);
123079 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
123080 : printf ("Error fails assertion (p_test != NULL && test != NULL && p_test != test) is false\n");
123081 : ROSE_ASSERT(false);
123082 : #endif
123083 : }
123084 : #endif
123085 960 : p_test = test;
123086 960 : }
123087 :
123088 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123089 :
123090 :
123091 : // End of memberFunctionString
123092 : // Start of memberFunctionString
123093 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
123094 :
123095 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
123096 :
123097 : SgExpression*
123098 3595 : SgForStatement::get_increment () const
123099 : {
123100 3595 : ROSE_ASSERT (this != NULL);
123101 :
123102 : #if 0
123103 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123104 : // used to trigger marking transformations for the token-based unparsing.
123105 : printf ("SgForStatement::get_increment = %p = %s \n",this,this->class_name().c_str());
123106 : #endif
123107 :
123108 3595 : return p_increment;
123109 : }
123110 :
123111 : void
123112 966 : SgForStatement::set_increment ( SgExpression* increment )
123113 : {
123114 966 : ROSE_ASSERT (this != NULL);
123115 :
123116 : #if 0
123117 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123118 : // used to trigger marking transformations for the token-based unparsing.
123119 : printf ("SgForStatement::set_increment = %p = %s \n",this,this->class_name().c_str());
123120 : #endif
123121 :
123122 966 : set_isModified(true);
123123 :
123124 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
123125 : if (p_increment != NULL && increment != NULL && p_increment != increment)
123126 : {
123127 : printf ("Warning: increment = %p overwriting valid pointer p_increment = %p \n",increment,p_increment);
123128 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
123129 : printf ("Error fails assertion (p_increment != NULL && increment != NULL && p_increment != increment) is false\n");
123130 : ROSE_ASSERT(false);
123131 : #endif
123132 : }
123133 : #endif
123134 966 : p_increment = increment;
123135 966 : }
123136 :
123137 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123138 :
123139 :
123140 : // End of memberFunctionString
123141 : // Start of memberFunctionString
123142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
123143 :
123144 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
123145 :
123146 : SgStatement*
123147 4952 : SgForStatement::get_loop_body () const
123148 : {
123149 4952 : ROSE_ASSERT (this != NULL);
123150 :
123151 : #if 0
123152 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123153 : // used to trigger marking transformations for the token-based unparsing.
123154 : printf ("SgForStatement::get_loop_body = %p = %s \n",this,this->class_name().c_str());
123155 : #endif
123156 :
123157 4952 : return p_loop_body;
123158 : }
123159 :
123160 : void
123161 977 : SgForStatement::set_loop_body ( SgStatement* loop_body )
123162 : {
123163 977 : ROSE_ASSERT (this != NULL);
123164 :
123165 : #if 0
123166 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123167 : // used to trigger marking transformations for the token-based unparsing.
123168 : printf ("SgForStatement::set_loop_body = %p = %s \n",this,this->class_name().c_str());
123169 : #endif
123170 :
123171 977 : set_isModified(true);
123172 :
123173 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
123174 : if (p_loop_body != NULL && loop_body != NULL && p_loop_body != loop_body)
123175 : {
123176 : printf ("Warning: loop_body = %p overwriting valid pointer p_loop_body = %p \n",loop_body,p_loop_body);
123177 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
123178 : printf ("Error fails assertion (p_loop_body != NULL && loop_body != NULL && p_loop_body != loop_body) is false\n");
123179 : ROSE_ASSERT(false);
123180 : #endif
123181 : }
123182 : #endif
123183 977 : p_loop_body = loop_body;
123184 977 : }
123185 :
123186 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123187 :
123188 :
123189 : // End of memberFunctionString
123190 : // Start of memberFunctionString
123191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
123192 :
123193 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
123194 :
123195 : SgStatement*
123196 960 : SgForStatement::get_else_body () const
123197 : {
123198 960 : ROSE_ASSERT (this != NULL);
123199 :
123200 : #if 0
123201 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123202 : // used to trigger marking transformations for the token-based unparsing.
123203 : printf ("SgForStatement::get_else_body = %p = %s \n",this,this->class_name().c_str());
123204 : #endif
123205 :
123206 960 : return p_else_body;
123207 : }
123208 :
123209 : void
123210 967 : SgForStatement::set_else_body ( SgStatement* else_body )
123211 : {
123212 967 : ROSE_ASSERT (this != NULL);
123213 :
123214 : #if 0
123215 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123216 : // used to trigger marking transformations for the token-based unparsing.
123217 : printf ("SgForStatement::set_else_body = %p = %s \n",this,this->class_name().c_str());
123218 : #endif
123219 :
123220 967 : set_isModified(true);
123221 :
123222 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
123223 : if (p_else_body != NULL && else_body != NULL && p_else_body != else_body)
123224 : {
123225 : printf ("Warning: else_body = %p overwriting valid pointer p_else_body = %p \n",else_body,p_else_body);
123226 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
123227 : printf ("Error fails assertion (p_else_body != NULL && else_body != NULL && p_else_body != else_body) is false\n");
123228 : ROSE_ASSERT(false);
123229 : #endif
123230 : }
123231 : #endif
123232 967 : p_else_body = else_body;
123233 967 : }
123234 :
123235 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123236 :
123237 :
123238 : // End of memberFunctionString
123239 : // Start of memberFunctionString
123240 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
123241 :
123242 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
123243 :
123244 : std::string
123245 0 : SgForStatement::get_string_label () const
123246 : {
123247 0 : ROSE_ASSERT (this != NULL);
123248 :
123249 : #if 0
123250 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123251 : // used to trigger marking transformations for the token-based unparsing.
123252 : printf ("SgForStatement::get_string_label = %p = %s \n",this,this->class_name().c_str());
123253 : #endif
123254 :
123255 0 : return p_string_label;
123256 : }
123257 :
123258 : void
123259 0 : SgForStatement::set_string_label ( std::string string_label )
123260 : {
123261 0 : ROSE_ASSERT (this != NULL);
123262 :
123263 : #if 0
123264 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123265 : // used to trigger marking transformations for the token-based unparsing.
123266 : printf ("SgForStatement::set_string_label = %p = %s \n",this,this->class_name().c_str());
123267 : #endif
123268 :
123269 0 : set_isModified(true);
123270 :
123271 0 : p_string_label = string_label;
123272 0 : }
123273 :
123274 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123275 :
123276 :
123277 : // End of memberFunctionString
123278 : // Start of memberFunctionString
123279 : /* #line 10016 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
123280 :
123281 :
123282 0 : SgForStatement::SgForStatement(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgStatement * loop_body) :
123283 : SgScopeStatement(),
123284 : p_for_init_stmt(init_stmt),
123285 : p_test(test),
123286 : p_increment(increment),
123287 0 : p_loop_body(loop_body)
123288 : {
123289 0 : post_construction_initialization();
123290 0 : }
123291 :
123292 : void
123293 969 : SgForStatement::post_construction_initialization()
123294 : {
123295 : // DQ (6/24/2006): Refactored this code to build the SgForInitStatement
123296 : // for all SgForStatement as part of constructor.
123297 969 : if (p_for_init_stmt == NULL) {
123298 : // SgForInitStatement* forInitStatement = new SgForInitStatement(New_File_Info(this));
123299 969 : SgForInitStatement* forInitStatement = NULL;
123300 969 : if (get_startOfConstruct() != NULL)
123301 : {
123302 2 : forInitStatement = new SgForInitStatement(New_File_Info(this));
123303 :
123304 : // DQ (10/27/2006): This will have to be updated after construction,
123305 : // since we don't know the ending position at this point!
123306 2 : forInitStatement->set_endOfConstruct(New_File_Info(this));
123307 :
123308 : // DQ (12/17/2006): Fixup the parents of Sg_File_Info objects
123309 2 : forInitStatement->get_startOfConstruct()->set_parent(forInitStatement);
123310 2 : forInitStatement->get_endOfConstruct()->set_parent(forInitStatement);
123311 : }
123312 : else
123313 : {
123314 967 : forInitStatement = new SgForInitStatement();
123315 : }
123316 :
123317 969 : ROSE_ASSERT(forInitStatement != NULL);
123318 :
123319 : // All SgForStatement IR nodes should have a valid SgForInitStatement (even if it is an empty list!).
123320 969 : set_for_init_stmt(forInitStatement);
123321 : }
123322 :
123323 969 : p_for_init_stmt->set_parent(this);
123324 :
123325 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
123326 969 : if (p_test != NULL)
123327 : {
123328 11 : p_test->set_parent(this);
123329 : }
123330 :
123331 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
123332 969 : if (p_increment != NULL)
123333 : {
123334 11 : p_increment->set_parent(this);
123335 : }
123336 :
123337 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
123338 969 : if (p_loop_body != NULL)
123339 : {
123340 11 : p_loop_body->set_parent(this);
123341 : }
123342 :
123343 : #if 0
123344 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
123345 : printf ("In SgForStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
123346 : #endif
123347 969 : }
123348 :
123349 : // MS: moved StatementPtrList to ForInitStatement. Therefore the call is simply forwarded and the same interface
123350 : SgStatementPtrList &
123351 50 : SgForStatement::get_init_stmt()
123352 : {
123353 : // DQ (6/24/2006): If this is always true then we can simplify this function.
123354 50 : ROSE_ASSERT(p_for_init_stmt != NULL);
123355 50 : return get_for_init_stmt()->get_init_stmt();
123356 : }
123357 :
123358 : const SgStatementPtrList &
123359 0 : SgForStatement::get_init_stmt() const
123360 : {
123361 : // DQ (6/24/2006): When we later simplify the append, prepend, insert functions this will be important.
123362 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
123363 :
123364 0 : return get_for_init_stmt()->get_init_stmt();
123365 : }
123366 :
123367 : void
123368 0 : SgForStatement::append_init_stmt(SgStatement * what)
123369 : {
123370 : // DQ (6/24/2006): If this is always true then we can simplify this function.
123371 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
123372 0 : get_for_init_stmt()->append_init_stmt(what);
123373 0 : }
123374 :
123375 : void
123376 0 : SgForStatement::prepend_init_stmt(SgStatement * what)
123377 : {
123378 : // DQ (6/24/2006): If this is always true then we can simplify this function.
123379 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
123380 0 : get_for_init_stmt()->prepend_init_stmt(what);
123381 0 : }
123382 :
123383 : bool
123384 0 : SgForStatement::replace_child(SgStatement *target,SgStatement *newstmt,
123385 : bool extractBasicBlock)
123386 : {
123387 0 : if ( StatementReplace(this, p_loop_body, target, newstmt) == true )
123388 0 : return true;
123389 0 : else if ( StatementReplace(this, p_for_init_stmt, target, newstmt) == true )
123390 : return true;
123391 0 : else if ( StatementReplace(this, p_test, target, newstmt) == true )
123392 0 : return true;
123393 : else
123394 : return false;
123395 : }
123396 :
123397 : // DQ (11/25/2005): preserve the previous interface so that
123398 : // the most common case of where a test is an expression can
123399 : // be handled as before. We can deprecate this function later.
123400 : // Currently the test has been modified to allow it to be a SgStatement
123401 : // and in the case of an expression, it is just a SgExprStatement.
123402 : // This is required for C and C++ which allows declarations to be
123403 : // placed where the test is evaluated in a for loop (note that this
123404 : // is part of uniform changes to the IR to fixup such details).
123405 : SgExpression*
123406 66 : SgForStatement::get_test_expr () const
123407 : {
123408 66 : ROSE_ASSERT (this != NULL);
123409 66 : ROSE_ASSERT(p_test != NULL);
123410 66 : ROSE_ASSERT(isSgStatement(p_test) != NULL);
123411 :
123412 66 : SgExpression* testExpression = NULL;
123413 66 : SgExprStatement* exprStatement = isSgExprStatement(p_test);
123414 66 : if (exprStatement != NULL)
123415 : {
123416 : // testExpression = exprStatement->get_the_expr();
123417 66 : testExpression = exprStatement->get_expression();
123418 66 : ROSE_ASSERT(testExpression != NULL);
123419 : }
123420 : else
123421 : {
123422 0 : printf ("test in SgForStatement is a %s \n",p_test->class_name().c_str());
123423 0 : ROSE_ASSERT(false);
123424 : }
123425 :
123426 66 : ROSE_ASSERT(testExpression != NULL);
123427 66 : return testExpression;
123428 : }
123429 :
123430 : void
123431 0 : SgForStatement::set_test_expr (SgExpression* expr )
123432 : {
123433 : // DQ (11/25/2005): preserve the previous interface. This function
123434 : // sets the SgStatement using a SgExpressionRoot IR node.
123435 0 : ROSE_ASSERT (this != NULL);
123436 0 : ROSE_ASSERT (expr != NULL);
123437 :
123438 0 : Sg_File_Info* fileInfo = New_File_Info(expr);
123439 0 : SgExprStatement* expressionStatement = new SgExprStatement(fileInfo,expr);
123440 0 : ROSE_ASSERT(expressionStatement != NULL);
123441 :
123442 : // DQ (10/27/2006): This might have to be reset later,
123443 : // since at this point we might not know the exact size.
123444 0 : expressionStatement->set_endOfConstruct(New_File_Info(expr));
123445 :
123446 0 : expressionStatement->get_startOfConstruct()->set_parent(expressionStatement);
123447 0 : expressionStatement->get_endOfConstruct()->set_parent(expressionStatement);
123448 :
123449 0 : if (get_test() != NULL)
123450 : {
123451 0 : printf ("Warning SgForStatement::set_test_expr is clobbering the existing test statement \n");
123452 : }
123453 0 : set_test(expressionStatement);
123454 :
123455 : // DQ (4/7/2006): Set the parents
123456 0 : expressionStatement->set_parent(this);
123457 :
123458 0 : ROSE_ASSERT(isSgStatement(p_test) != NULL);
123459 0 : }
123460 :
123461 : // DQ (12/6/2006): We need this sort of function now that we have removed the expression root node!
123462 : // The requirement of not being able to do operations uniformly on expressions may be the disadvantage
123463 : // of not having used the SgExpressionRoot IR node as a concept.
123464 : int
123465 0 : SgForStatement::replace_expression(SgExpression * original_expression, SgExpression * new_expression )
123466 : {
123467 : // DQ (12/17/2006): This function should have the semantics that it will represent a
123468 : // structural change to the AST, thus it is free to set the parent of the new expression.
123469 :
123470 0 : ROSE_ASSERT(original_expression != NULL);
123471 0 : ROSE_ASSERT(new_expression != NULL);
123472 :
123473 0 : ROSE_ASSERT(original_expression == p_increment);
123474 :
123475 0 : set_increment(new_expression);
123476 :
123477 0 : new_expression->set_parent(this);
123478 :
123479 : // DQ: Let this be a memory leak for now to avoid initial problems.
123480 0 : ROSE_ASSERT(original_expression != NULL);
123481 : // delete original_expression;
123482 :
123483 0 : return 0;
123484 : }
123485 :
123486 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
123487 : SgName
123488 331 : SgForStatement::get_mangled_name(void) const
123489 : {
123490 331 : return SgName ("");
123491 : }
123492 :
123493 :
123494 :
123495 : // End of memberFunctionString
123496 : // Start of memberFunctionString
123497 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
123498 :
123499 : // *** COMMON CODE SECTION BEGINS HERE ***
123500 :
123501 : #if 0
123502 : int
123503 : SgForStatement::getVariant() const
123504 : {
123505 : // This function is used in ROSE while "variant()" is used in SAGE
123506 : assert(this != NULL);
123507 : return variant();
123508 : }
123509 : #endif
123510 :
123511 : // This function is used in ROSE in treeTraversal code
123512 : // eventually replaces getVariant() and variant()
123513 : // though after variant() has been removed for a while we will
123514 : // want to change the name of variantT() back to variant()
123515 : // (since the "T" was ment to stand for temporary).
123516 : // When this happens the variantT() will be depricated.
123517 : VariantT
123518 484067 : SgForStatement::variantT() const
123519 : {
123520 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
123521 484067 : ROSE_ASSERT(this != NULL);
123522 484067 : return V_SgForStatement;
123523 : }
123524 :
123525 : #if 0
123526 : int
123527 : SgForStatement::variant() const
123528 : {
123529 : // This function is used in SAGE
123530 : ROSE_ASSERT(this != NULL);
123531 : return FOR_STMT;
123532 : }
123533 : #endif
123534 :
123535 : ROSE_DLL_API const char*
123536 616 : SgForStatement::sage_class_name() const
123537 : {
123538 616 : ROSE_ASSERT(this != NULL);
123539 616 : return "SgForStatement";
123540 : }
123541 :
123542 : std::string
123543 5582 : SgForStatement::class_name() const
123544 : {
123545 5582 : ROSE_ASSERT(this != NULL);
123546 5582 : return "SgForStatement";
123547 : }
123548 :
123549 : // DQ (11/26/2005): Support for visitor pattern mechanims
123550 : // (inferior to ROSE traversal mechanism, experimental).
123551 : void
123552 6160 : SgForStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
123553 : {
123554 6160 : ROSE_ASSERT(this != NULL);
123555 6160 : visitor.visit(this);
123556 6160 : }
123557 :
123558 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
123559 0 : void SgForStatement::accept (ROSE_VisitorPattern & visitor) {
123560 0 : ROSE_ASSERT(this != NULL);
123561 0 : visitor.visit(this);
123562 0 : }
123563 :
123564 : SgForStatement*
123565 0 : SgForStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
123566 : {
123567 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
123568 : // This function is currently only supported for the AST used the represent Binary executables.
123569 : if (0 /* isSgAsmNode(this) != NULL */)
123570 : {
123571 : // Support for regex specification.
123572 : std::string prefixCode = "REGEX:";
123573 : addNewAttribute(prefixCode + s,a);
123574 : }
123575 : #endif
123576 :
123577 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
123578 0 : return this;
123579 : }
123580 :
123581 : // *** COMMON CODE SECTION ENDS HERE ***
123582 :
123583 :
123584 : // End of memberFunctionString
123585 : // Start of memberFunctionString
123586 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
123587 :
123588 :
123589 : #if 0
123590 : //! Error checking support
123591 : /*! Verifies the following:
123592 : - working getVariant() member function
123593 : - calls base class's error() member function
123594 : Every class has one of these functions.
123595 : */
123596 : bool
123597 : SgForStatement::error()
123598 : {
123599 : // Put error checking here
123600 :
123601 : ROSE_ASSERT (this != NULL);
123602 : if (getVariant() != FOR_STMT)
123603 : {
123604 : printf ("Error in SgForStatement::error(): SgForStatement object has a %s variant \n",
123605 : Cxx_GrammarTerminalNames[getVariant()].name);
123606 : // printf ("Error in SgForStatement::error() \n");
123607 : ROSE_ABORT();
123608 : }
123609 :
123610 : ROSE_ASSERT (getVariant() == FOR_STMT);
123611 : return SgScopeStatement::error();
123612 : }
123613 : #endif
123614 :
123615 :
123616 :
123617 : // End of memberFunctionString
123618 :
123619 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
123620 :
123621 4687 : SgForStatement* isSgForStatement ( SgNode* inputDerivedClassPointer )
123622 : {
123623 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
123624 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
123625 : // So to fix this we return NULL directly when the input is NULL and avoid the
123626 : // dynamic_cast in this case. This is likely a performance improvement as well.
123627 : // return dynamic_cast<SgForStatement*>(inputDerivedClassPointer);
123628 : // Milind Chabbi (8/28/2013): isSgForStatement uses table-driven castability instead of c++ default dynamic_cast
123629 : // this improves the running time performance by 10-20%.
123630 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgForStatement*>(inputDerivedClassPointer);
123631 4687 : return IS_SgForStatement_FAST_MACRO(inputDerivedClassPointer);
123632 : }
123633 :
123634 : // DQ (11/8/2003): Added version of functions taking const pointer
123635 541 : const SgForStatement* isSgForStatement ( const SgNode* inputDerivedClassPointer )
123636 : {
123637 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
123638 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
123639 : // So to fix this we return NULL directly when the input is NULL and avoid the
123640 : // dynamic_cast in this case. This is likely a performance improvement as well.
123641 : // return dynamic_cast<const SgForStatement*>(inputDerivedClassPointer);
123642 : // Milind Chabbi (8/28/2013): isSgForStatement uses table-driven castability instead of c++ default dynamic_cast
123643 : // this improves the running time performance by 10-20%.
123644 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgForStatement*>(inputDerivedClassPointer);
123645 541 : return IS_SgForStatement_FAST_MACRO(inputDerivedClassPointer);
123646 : }
123647 :
123648 :
123649 :
123650 : /* #line 123651 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
123651 :
123652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
123653 :
123654 : /**
123655 : \brief Generated destructor
123656 :
123657 : This destructor is automatically generated (by ROSETTA). This destructor
123658 : only frees memory of data members associated with the parts of the current IR node which
123659 : are NOT traversed. Those data members that are part of a traversal can be freed using
123660 : a traversal (calling this destructor on all children in a post-order traversal). Such
123661 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
123662 :
123663 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
123664 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
123665 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
123666 :
123667 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
123668 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
123669 : pointers are not yet implemented to call delete on eash pointer in the container.
123670 : (This could be done by derivation from the STL containers to define containers that
123671 : automatically deleted their members.)
123672 :
123673 : */
123674 160 : SgForStatement::~SgForStatement () {
123675 80 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
123676 :
123677 :
123678 : // case: not a listType for for_init_stmt
123679 80 : p_for_init_stmt = NULL; // non list case
123680 : // case: not a listType for test
123681 80 : p_test = NULL; // non list case
123682 : // case: not a listType for increment
123683 80 : p_increment = NULL; // non list case
123684 : // case: not a listType for loop_body
123685 80 : p_loop_body = NULL; // non list case
123686 : // case: not a listType for else_body
123687 80 : p_else_body = NULL; // non list case
123688 : // case: not a listType for string_label
123689 80 : p_string_label = ""; // non list case
123690 :
123691 : }
123692 :
123693 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
123694 160 : }
123695 :
123696 :
123697 : /* #line 123698 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
123698 :
123699 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
123700 :
123701 : // Generated constructor
123702 2 : SgForStatement::SgForStatement ( Sg_File_Info* startOfConstruct, SgStatement* test, SgExpression* increment, SgStatement* loop_body )
123703 2 : : SgScopeStatement(startOfConstruct)
123704 : {
123705 : #ifdef DEBUG
123706 : // printf ("In SgForStatement::SgForStatement (Sg_File_Info* startOfConstruct, SgStatement* test, SgExpression* increment, SgStatement* loop_body) sage_class_name() = %s \n",sage_class_name());
123707 : #endif
123708 : #if 0
123709 : // debugging information!
123710 : printf ("In SgForStatement::SgForStatement (Sg_File_Info* startOfConstruct, SgStatement* test, SgExpression* increment, SgStatement* loop_body): this = %p = %s \n",this,this->class_name().c_str());
123711 : #endif
123712 :
123713 2 : p_for_init_stmt = NULL;
123714 2 : p_test = test;
123715 2 : p_increment = increment;
123716 2 : p_loop_body = loop_body;
123717 2 : p_else_body = NULL;
123718 2 : p_string_label = "";
123719 :
123720 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
123721 :
123722 : #if 0
123723 : // DQ (7/30/2014): Call a virtual function.
123724 : std::string s = this->class_name();
123725 : #endif
123726 :
123727 : // Test the variant virtual function
123728 : // assert(FOR_STMT == variant());
123729 2 : assert(FOR_STMT == this->variant());
123730 2 : ROSE_ASSERT(FOR_STMT == (int)(this->variantT()));
123731 2 : post_construction_initialization();
123732 :
123733 : // Test the isSgForStatement() function since it has been problematic
123734 2 : assert(isSgForStatement(this) != NULL);
123735 2 : }
123736 :
123737 : // Generated constructor (all data members)
123738 :
123739 : /* #line 123740 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
123740 :
123741 :
123742 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
123743 :
123744 :
123745 : // ********************************************************
123746 : // member functions common across all array grammar objects
123747 : // ********************************************************
123748 :
123749 :
123750 :
123751 : /* #line 123752 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
123752 :
123753 :
123754 :
123755 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
123756 :
123757 : // ********************************************************
123758 : // member functions specific to each node in the grammar
123759 : // ********************************************************
123760 :
123761 :
123762 : /* #line 123763 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
123763 :
123764 : // Start of memberFunctionString
123765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
123766 :
123767 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
123768 :
123769 : SgBasicBlock*
123770 223252 : SgFunctionDefinition::get_body () const
123771 : {
123772 223252 : ROSE_ASSERT (this != NULL);
123773 :
123774 : #if 0
123775 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123776 : // used to trigger marking transformations for the token-based unparsing.
123777 : printf ("SgFunctionDefinition::get_body = %p = %s \n",this,this->class_name().c_str());
123778 : #endif
123779 :
123780 223252 : return p_body;
123781 : }
123782 :
123783 : void
123784 19243 : SgFunctionDefinition::set_body ( SgBasicBlock* body )
123785 : {
123786 19243 : ROSE_ASSERT (this != NULL);
123787 :
123788 : #if 0
123789 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
123790 : // used to trigger marking transformations for the token-based unparsing.
123791 : printf ("SgFunctionDefinition::set_body = %p = %s \n",this,this->class_name().c_str());
123792 : #endif
123793 :
123794 19243 : set_isModified(true);
123795 :
123796 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
123797 : if (p_body != NULL && body != NULL && p_body != body)
123798 : {
123799 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
123800 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
123801 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
123802 : ROSE_ASSERT(false);
123803 : #endif
123804 : }
123805 : #endif
123806 19243 : p_body = body;
123807 19243 : }
123808 :
123809 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
123810 :
123811 :
123812 : // End of memberFunctionString
123813 : // Start of memberFunctionString
123814 :
123815 :
123816 : // End of memberFunctionString
123817 : // Start of memberFunctionString
123818 : /* #line 11696 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
123819 :
123820 :
123821 : // DQ (10/4/2006): Support for static map of SgBasicBlock IR nodes to integers.
123822 : // std::map<SgBasicBlockPtr, int> SgFunctionDefinition::p_block_number_map;
123823 :
123824 : void
123825 2 : SgFunctionDefinition::post_construction_initialization()
123826 : {
123827 : #if 0
123828 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
123829 : printf ("In SgFunctionDefinition::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
123830 : #endif
123831 2 : }
123832 :
123833 0 : SgFunctionDefinition::SgFunctionDefinition(Sg_File_Info* f, SgFunctionDeclaration* d, SgBasicBlock* body)
123834 0 : : SgScopeStatement(f), p_body(body)
123835 : {
123836 0 : set_declaration(d);
123837 0 : if (d!=NULL) // Liao, 4/14/2009. Support bottom-up AST building: definition is built first, declaration may be still NULL
123838 0 : d->set_definition(this);
123839 0 : }
123840 :
123841 19283 : SgFunctionDefinition::SgFunctionDefinition( SgFunctionDeclaration* d, SgBasicBlock* body)
123842 19283 : : SgScopeStatement(), p_body(body)
123843 : {
123844 19283 : set_declaration(d);
123845 19283 : if (d!=NULL)
123846 16084 : d->set_definition(this);
123847 19283 : }
123848 :
123849 : SgFunctionDeclaration*
123850 51580 : SgFunctionDefinition::get_declaration() const
123851 : {
123852 51580 : SgNode* res = get_parent();
123853 51580 : SgFunctionDeclaration* res1 = isSgFunctionDeclaration(res);
123854 51580 : assert( res == 0 || res1 != 0);
123855 51580 : return res1;
123856 : }
123857 :
123858 : void
123859 19283 : SgFunctionDefinition::set_declaration(SgFunctionDeclaration* new_val)
123860 : {
123861 19283 : set_parent(new_val);
123862 19283 : }
123863 :
123864 : bool
123865 0 : SgFunctionDefinition::replace_child(SgStatement *target,SgStatement *newstmt,
123866 : bool extractBasicBlock)
123867 : {
123868 0 : return ( StatementReplace(this, p_body, target, newstmt) == true );
123869 : }
123870 :
123871 : void
123872 0 : SgFunctionDefinition::append_statement(SgStatement * what)
123873 : {
123874 0 : assert(this != NULL);
123875 0 : if (!get_body())
123876 : {
123877 0 : set_body(new SgBasicBlock(New_File_Info(this)));
123878 : }
123879 0 : get_body()->append_statement(what);
123880 :
123881 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
123882 0 : ROSE_ASSERT(what->get_parent() != NULL);
123883 0 : }
123884 :
123885 : void
123886 0 : SgFunctionDefinition::prepend_statement(SgStatement *what)
123887 : {
123888 0 : assert(this != NULL);
123889 0 : if(!get_body()) {
123890 0 : set_body(new SgBasicBlock(New_File_Info(this)));
123891 : }
123892 0 : get_body()->prepend_statement(what);
123893 :
123894 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
123895 0 : ROSE_ASSERT(what->get_parent() != NULL);
123896 0 : }
123897 :
123898 : // RV (2/5/2006): Added name mangling for function definitions
123899 : SgName
123900 31870 : SgFunctionDefinition::get_mangled_name (void) const
123901 : {
123902 31870 : const SgFunctionDeclaration* decl = get_declaration ();
123903 31870 : ROSE_ASSERT (decl);
123904 31870 : return decl->get_mangled_name ();
123905 : }
123906 :
123907 : // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
123908 : // labels for scopes in a function (as required for name mangling).
123909 : std::map<SgNode*,int> &
123910 19760 : SgFunctionDefinition::get_scope_number_list()
123911 : {
123912 19760 : return p_scope_number_list;
123913 : }
123914 :
123915 : // DQ (10/5/2006): Added support for faster (non-quadratic) computation of unique
123916 : // labels for scopes in a function (as required for name mangling).
123917 : int
123918 43845 : SgFunctionDefinition::get_scope_number ( const SgNode* scope ) const
123919 : {
123920 43845 : SgFunctionDefinition* modifiableThis = const_cast<SgFunctionDefinition*>(this);
123921 43845 : SgNode* modifiableScope = const_cast<SgNode*>(scope);
123922 43845 : if (p_scope_number_list.empty() == true)
123923 : {
123924 : // Build a local reference that can be modified (cast cost from this cost function to get access).
123925 2783 : modifiableThis->resetScopeNumbers();
123926 : }
123927 :
123928 43845 : ROSE_ASSERT (p_scope_number_list.empty() == false);
123929 :
123930 : // int uniqueScopeNumber = p_scope_number_list[scope];
123931 :
123932 : // Make sure that the required entry is in the map!
123933 43845 : std::map<SgNode*, int>::const_iterator iter = this->p_scope_number_list.find(modifiableScope);
123934 43845 : if (iter == this->p_scope_number_list.end())
123935 : {
123936 : #if 0
123937 : printf ("In Function = %p = %s = %s \n",get_declaration(),get_declaration()->class_name().c_str(),SageInterface::get_name(get_declaration()).c_str());
123938 : printf ("Looking for scope = %p = %s \n",scope,scope->class_name().c_str());
123939 : scope->get_startOfConstruct()->display("Error: SgFunctionDefinition::get_scope_number: input scope debug");
123940 : get_startOfConstruct()->display("Error: SgFunctionDefinition::get_scope_number: debug");
123941 : for (std::map<SgNode*,int>::const_iterator i = p_scope_number_list.begin(); i != p_scope_number_list.end(); i++)
123942 : {
123943 : printf ("i->first = %p = %s i->second = %d \n",i->first,i->first->class_name().c_str(),i->second);
123944 : }
123945 : #else
123946 632 : int n = (int)modifiableThis->p_scope_number_list.size() + 1;
123947 632 : modifiableThis->p_scope_number_list[modifiableScope] = n;
123948 632 : iter = this->p_scope_number_list.find(modifiableScope);
123949 : #endif
123950 : }
123951 43845 : ROSE_ASSERT(iter != this->p_scope_number_list.end());
123952 :
123953 43845 : int uniqueScopeNumber = iter->second;
123954 :
123955 : #if 0
123956 : printf ("uniqueScopeNumber = %d for scope = %p = %s of function = %s \n",
123957 : uniqueScopeNumber,scope,scope->class_name().c_str(),get_declaration()->get_name().str());
123958 : #endif
123959 :
123960 43845 : ROSE_ASSERT(uniqueScopeNumber > 0);
123961 :
123962 43845 : return uniqueScopeNumber;
123963 : }
123964 :
123965 : void
123966 0 : SgFunctionDefinition::clearScopeNumbers()
123967 : {
123968 : // std::map<SgNode*,int> & scopeMap = get_scope_number_list();
123969 : // ROSE_ASSERT(scopeMap.empty() == true);
123970 :
123971 : // This functionality is moved out of the IR node to were it can be more easily developed (initially at least).
123972 0 : SageInterface::clearScopeNumbers(this);
123973 0 : }
123974 :
123975 : void
123976 2783 : SgFunctionDefinition::resetScopeNumbers()
123977 : {
123978 : // This function will be called automatically when get_scope_number() is call if the p_scope_number_list is empty.
123979 :
123980 : // std::map<SgNode*,int> & scopeMap = get_scope_number_list();
123981 : // ROSE_ASSERT(scopeMap.empty() == true);
123982 :
123983 : // This functionality is moved out of the IR node to were it can be more easily developed (initially at least).
123984 2783 : SageInterface::resetScopeNumbers(this);
123985 2783 : }
123986 :
123987 0 : std::ostream & operator<< ( std::ostream & os, std::map<SgNode*,int> & x )
123988 : {
123989 : // printf ("Error: Not implemented, operator<< ( std::ostream & os, std::map<SgNode*,int> & x ) \n");
123990 : // os << " pair (" << (*x).first.str() << "," << ((*x).second) << ")";
123991 :
123992 0 : os << "output operator for std::map<SgNode*,int> not implemented";
123993 0 : return os;
123994 : }
123995 :
123996 : // DQ (1/8/2007): Added to support qualified name generation (this forces
123997 : // function parameters to have the correct qualified name, same as local
123998 : // variables declared in the scope of the function more directly (which
123999 : // is handled by having a special implementation of "SgBasicBlock::get_qualified_name() const"
124000 : SgName
124001 0 : SgFunctionDefinition::get_qualified_name() const
124002 : {
124003 : // DQ (8/28/2005): This is where we might name blocks if we select to do so at some point
124004 : // as a way of building unique names for qualified named declarations.
124005 :
124006 : // Note that this will still evaluate so that "returnName.is_null()" will be true
124007 0 : SgName returnName = "";
124008 0 : return returnName;
124009 : }
124010 :
124011 :
124012 : // MD (09/20/2010): Accessor for preinitialization lists associated with
124013 : // this (constructor) definition. NULL if this has no such list.
124014 : SgCtorInitializerList*
124015 16 : SgFunctionDefinition::get_CtorInitializerList() const {
124016 16 : SgMemberFunctionDeclaration* memDecl = NULL;
124017 16 : SgCtorInitializerList* ctorList = NULL;
124018 16 : if ((memDecl = isSgMemberFunctionDeclaration(get_declaration())) != NULL &&
124019 0 : (ctorList = memDecl->get_CtorInitializerList()) != NULL)
124020 : return ctorList;
124021 : else
124022 16 : return NULL;
124023 : }
124024 :
124025 :
124026 :
124027 : // End of memberFunctionString
124028 : // Start of memberFunctionString
124029 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
124030 :
124031 : // *** COMMON CODE SECTION BEGINS HERE ***
124032 :
124033 : #if 0
124034 : int
124035 : SgFunctionDefinition::getVariant() const
124036 : {
124037 : // This function is used in ROSE while "variant()" is used in SAGE
124038 : assert(this != NULL);
124039 : return variant();
124040 : }
124041 : #endif
124042 :
124043 : // This function is used in ROSE in treeTraversal code
124044 : // eventually replaces getVariant() and variant()
124045 : // though after variant() has been removed for a while we will
124046 : // want to change the name of variantT() back to variant()
124047 : // (since the "T" was ment to stand for temporary).
124048 : // When this happens the variantT() will be depricated.
124049 : VariantT
124050 17980700 : SgFunctionDefinition::variantT() const
124051 : {
124052 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
124053 17980700 : ROSE_ASSERT(this != NULL);
124054 17980700 : return V_SgFunctionDefinition;
124055 : }
124056 :
124057 : #if 0
124058 : int
124059 : SgFunctionDefinition::variant() const
124060 : {
124061 : // This function is used in SAGE
124062 : ROSE_ASSERT(this != NULL);
124063 : return FUNC_DEFN_STMT;
124064 : }
124065 : #endif
124066 :
124067 : ROSE_DLL_API const char*
124068 1828 : SgFunctionDefinition::sage_class_name() const
124069 : {
124070 1828 : ROSE_ASSERT(this != NULL);
124071 1828 : return "SgFunctionDefinition";
124072 : }
124073 :
124074 : std::string
124075 43029 : SgFunctionDefinition::class_name() const
124076 : {
124077 43029 : ROSE_ASSERT(this != NULL);
124078 43029 : return "SgFunctionDefinition";
124079 : }
124080 :
124081 : // DQ (11/26/2005): Support for visitor pattern mechanims
124082 : // (inferior to ROSE traversal mechanism, experimental).
124083 : void
124084 222609 : SgFunctionDefinition::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
124085 : {
124086 222609 : ROSE_ASSERT(this != NULL);
124087 222609 : visitor.visit(this);
124088 222609 : }
124089 :
124090 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
124091 0 : void SgFunctionDefinition::accept (ROSE_VisitorPattern & visitor) {
124092 0 : ROSE_ASSERT(this != NULL);
124093 0 : visitor.visit(this);
124094 0 : }
124095 :
124096 : SgFunctionDefinition*
124097 0 : SgFunctionDefinition::addRegExpAttribute(std::string s, AstRegExAttribute* a)
124098 : {
124099 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
124100 : // This function is currently only supported for the AST used the represent Binary executables.
124101 : if (0 /* isSgAsmNode(this) != NULL */)
124102 : {
124103 : // Support for regex specification.
124104 : std::string prefixCode = "REGEX:";
124105 : addNewAttribute(prefixCode + s,a);
124106 : }
124107 : #endif
124108 :
124109 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
124110 0 : return this;
124111 : }
124112 :
124113 : // *** COMMON CODE SECTION ENDS HERE ***
124114 :
124115 :
124116 : // End of memberFunctionString
124117 : // Start of memberFunctionString
124118 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
124119 :
124120 :
124121 : #if 0
124122 : //! Error checking support
124123 : /*! Verifies the following:
124124 : - working getVariant() member function
124125 : - calls base class's error() member function
124126 : Every class has one of these functions.
124127 : */
124128 : bool
124129 : SgFunctionDefinition::error()
124130 : {
124131 : // Put error checking here
124132 :
124133 : ROSE_ASSERT (this != NULL);
124134 : if (getVariant() != FUNC_DEFN_STMT)
124135 : {
124136 : printf ("Error in SgFunctionDefinition::error(): SgFunctionDefinition object has a %s variant \n",
124137 : Cxx_GrammarTerminalNames[getVariant()].name);
124138 : // printf ("Error in SgFunctionDefinition::error() \n");
124139 : ROSE_ABORT();
124140 : }
124141 :
124142 : ROSE_ASSERT (getVariant() == FUNC_DEFN_STMT);
124143 : return SgScopeStatement::error();
124144 : }
124145 : #endif
124146 :
124147 :
124148 :
124149 : // End of memberFunctionString
124150 :
124151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
124152 :
124153 62676900 : SgFunctionDefinition* isSgFunctionDefinition ( SgNode* inputDerivedClassPointer )
124154 : {
124155 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
124156 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
124157 : // So to fix this we return NULL directly when the input is NULL and avoid the
124158 : // dynamic_cast in this case. This is likely a performance improvement as well.
124159 : // return dynamic_cast<SgFunctionDefinition*>(inputDerivedClassPointer);
124160 : // Milind Chabbi (8/28/2013): isSgFunctionDefinition uses table-driven castability instead of c++ default dynamic_cast
124161 : // this improves the running time performance by 10-20%.
124162 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionDefinition*>(inputDerivedClassPointer);
124163 62676900 : return IS_SgFunctionDefinition_FAST_MACRO(inputDerivedClassPointer);
124164 : }
124165 :
124166 : // DQ (11/8/2003): Added version of functions taking const pointer
124167 73949 : const SgFunctionDefinition* isSgFunctionDefinition ( const SgNode* inputDerivedClassPointer )
124168 : {
124169 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
124170 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
124171 : // So to fix this we return NULL directly when the input is NULL and avoid the
124172 : // dynamic_cast in this case. This is likely a performance improvement as well.
124173 : // return dynamic_cast<const SgFunctionDefinition*>(inputDerivedClassPointer);
124174 : // Milind Chabbi (8/28/2013): isSgFunctionDefinition uses table-driven castability instead of c++ default dynamic_cast
124175 : // this improves the running time performance by 10-20%.
124176 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionDefinition*>(inputDerivedClassPointer);
124177 73949 : return IS_SgFunctionDefinition_FAST_MACRO(inputDerivedClassPointer);
124178 : }
124179 :
124180 :
124181 :
124182 : /* #line 124183 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124183 :
124184 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
124185 :
124186 : /**
124187 : \brief Generated destructor
124188 :
124189 : This destructor is automatically generated (by ROSETTA). This destructor
124190 : only frees memory of data members associated with the parts of the current IR node which
124191 : are NOT traversed. Those data members that are part of a traversal can be freed using
124192 : a traversal (calling this destructor on all children in a post-order traversal). Such
124193 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
124194 :
124195 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
124196 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
124197 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
124198 :
124199 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
124200 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
124201 : pointers are not yet implemented to call delete on eash pointer in the container.
124202 : (This could be done by derivation from the STL containers to define containers that
124203 : automatically deleted their members.)
124204 :
124205 : */
124206 6960 : SgFunctionDefinition::~SgFunctionDefinition () {
124207 3795 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
124208 :
124209 :
124210 : // case: not a listType for body
124211 3795 : p_body = NULL; // non list case
124212 :
124213 : }
124214 :
124215 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
124216 6960 : }
124217 :
124218 :
124219 : /* #line 124220 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124220 :
124221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
124222 :
124223 : // Generated constructor
124224 2 : SgFunctionDefinition::SgFunctionDefinition ( Sg_File_Info* startOfConstruct, SgBasicBlock* body )
124225 2 : : SgScopeStatement(startOfConstruct)
124226 : {
124227 : #ifdef DEBUG
124228 : // printf ("In SgFunctionDefinition::SgFunctionDefinition (Sg_File_Info* startOfConstruct, SgBasicBlock* body) sage_class_name() = %s \n",sage_class_name());
124229 : #endif
124230 : #if 0
124231 : // debugging information!
124232 : printf ("In SgFunctionDefinition::SgFunctionDefinition (Sg_File_Info* startOfConstruct, SgBasicBlock* body): this = %p = %s \n",this,this->class_name().c_str());
124233 : #endif
124234 :
124235 2 : p_body = body;
124236 :
124237 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
124238 :
124239 : #if 0
124240 : // DQ (7/30/2014): Call a virtual function.
124241 : std::string s = this->class_name();
124242 : #endif
124243 :
124244 : // Test the variant virtual function
124245 : // assert(FUNC_DEFN_STMT == variant());
124246 2 : assert(FUNC_DEFN_STMT == this->variant());
124247 2 : ROSE_ASSERT(FUNC_DEFN_STMT == (int)(this->variantT()));
124248 2 : post_construction_initialization();
124249 :
124250 : // Test the isSgFunctionDefinition() function since it has been problematic
124251 2 : assert(isSgFunctionDefinition(this) != NULL);
124252 2 : }
124253 :
124254 : // Generated constructor (all data members)
124255 :
124256 : /* #line 124257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124257 :
124258 :
124259 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
124260 :
124261 :
124262 : // ********************************************************
124263 : // member functions common across all array grammar objects
124264 : // ********************************************************
124265 :
124266 :
124267 :
124268 : /* #line 124269 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124269 :
124270 :
124271 :
124272 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
124273 :
124274 : // ********************************************************
124275 : // member functions specific to each node in the grammar
124276 : // ********************************************************
124277 :
124278 :
124279 : /* #line 124280 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124280 :
124281 : // Start of memberFunctionString
124282 : /* #line 17205 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
124283 :
124284 : void
124285 0 : SgTemplateFunctionDefinition::post_construction_initialization()
124286 : {
124287 0 : }
124288 :
124289 : // DQ (12/1/2011): Added support for template declarations in the AST.
124290 0 : SgTemplateFunctionDefinition::SgTemplateFunctionDefinition(Sg_File_Info* f, SgTemplateFunctionDeclaration* d, SgBasicBlock* body)
124291 : // : SgScopeStatement(f), p_body(body)
124292 0 : : SgFunctionDefinition(f,NULL,body)
124293 : {
124294 0 : set_declaration(d);
124295 0 : if (d!=NULL) // Liao, 4/14/2009. Support bottom-up AST building: definition is built first, declaration may be still NULL
124296 0 : d->set_definition(this);
124297 0 : }
124298 :
124299 : // DQ (12/1/2011): Added support for template declarations in the AST.
124300 3199 : SgTemplateFunctionDefinition::SgTemplateFunctionDefinition( SgTemplateFunctionDeclaration* d, SgBasicBlock* body)
124301 : // : SgScopeStatement(), p_body(body)
124302 3199 : : SgFunctionDefinition((SgFunctionDeclaration*)NULL,body)
124303 : {
124304 3199 : set_declaration(d);
124305 3199 : if (d!=NULL)
124306 3199 : d->set_definition(this);
124307 3199 : }
124308 :
124309 :
124310 : SgTemplateFunctionDeclaration*
124311 6929 : SgTemplateFunctionDefinition::get_declaration() const
124312 : {
124313 : // This is copied and modified from the similar function for SgFunctionDefinition::get_declaration()
124314 6929 : SgNode* res = get_parent();
124315 6929 : SgTemplateFunctionDeclaration* res1 = isSgTemplateFunctionDeclaration(res);
124316 :
124317 6929 : assert( res == 0 || res1 != 0);
124318 :
124319 6929 : return res1;
124320 : }
124321 :
124322 : void
124323 3199 : SgTemplateFunctionDefinition::set_declaration(SgTemplateFunctionDeclaration* new_val)
124324 : {
124325 : // This is copied from the similar function for SgFunctionDefinition::set_declaration()
124326 3199 : set_parent(new_val);
124327 3199 : }
124328 :
124329 : SgName
124330 6929 : SgTemplateFunctionDefinition::get_mangled_name (void) const
124331 : {
124332 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
124333 : // return get_declaration()->get_mangled_name();
124334 6929 : SgTemplateFunctionDeclaration* templateFunctionDeclaration = get_declaration();
124335 6929 : ROSE_ASSERT(templateFunctionDeclaration != NULL);
124336 6929 : return templateFunctionDeclaration->get_mangled_name();
124337 : }
124338 :
124339 :
124340 :
124341 : // End of memberFunctionString
124342 : // Start of memberFunctionString
124343 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
124344 :
124345 : // *** COMMON CODE SECTION BEGINS HERE ***
124346 :
124347 : #if 0
124348 : int
124349 : SgTemplateFunctionDefinition::getVariant() const
124350 : {
124351 : // This function is used in ROSE while "variant()" is used in SAGE
124352 : assert(this != NULL);
124353 : return variant();
124354 : }
124355 : #endif
124356 :
124357 : // This function is used in ROSE in treeTraversal code
124358 : // eventually replaces getVariant() and variant()
124359 : // though after variant() has been removed for a while we will
124360 : // want to change the name of variantT() back to variant()
124361 : // (since the "T" was ment to stand for temporary).
124362 : // When this happens the variantT() will be depricated.
124363 : VariantT
124364 4247540 : SgTemplateFunctionDefinition::variantT() const
124365 : {
124366 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
124367 4247540 : ROSE_ASSERT(this != NULL);
124368 4247540 : return V_SgTemplateFunctionDefinition;
124369 : }
124370 :
124371 : #if 0
124372 : int
124373 : SgTemplateFunctionDefinition::variant() const
124374 : {
124375 : // This function is used in SAGE
124376 : ROSE_ASSERT(this != NULL);
124377 : return TEMPLATE_FUNCTION_DEF_STMT;
124378 : }
124379 : #endif
124380 :
124381 : ROSE_DLL_API const char*
124382 14 : SgTemplateFunctionDefinition::sage_class_name() const
124383 : {
124384 14 : ROSE_ASSERT(this != NULL);
124385 14 : return "SgTemplateFunctionDefinition";
124386 : }
124387 :
124388 : std::string
124389 9785 : SgTemplateFunctionDefinition::class_name() const
124390 : {
124391 9785 : ROSE_ASSERT(this != NULL);
124392 9785 : return "SgTemplateFunctionDefinition";
124393 : }
124394 :
124395 : // DQ (11/26/2005): Support for visitor pattern mechanims
124396 : // (inferior to ROSE traversal mechanism, experimental).
124397 : void
124398 44001 : SgTemplateFunctionDefinition::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
124399 : {
124400 44001 : ROSE_ASSERT(this != NULL);
124401 44001 : visitor.visit(this);
124402 44001 : }
124403 :
124404 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
124405 0 : void SgTemplateFunctionDefinition::accept (ROSE_VisitorPattern & visitor) {
124406 0 : ROSE_ASSERT(this != NULL);
124407 0 : visitor.visit(this);
124408 0 : }
124409 :
124410 : SgTemplateFunctionDefinition*
124411 0 : SgTemplateFunctionDefinition::addRegExpAttribute(std::string s, AstRegExAttribute* a)
124412 : {
124413 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
124414 : // This function is currently only supported for the AST used the represent Binary executables.
124415 : if (0 /* isSgAsmNode(this) != NULL */)
124416 : {
124417 : // Support for regex specification.
124418 : std::string prefixCode = "REGEX:";
124419 : addNewAttribute(prefixCode + s,a);
124420 : }
124421 : #endif
124422 :
124423 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
124424 0 : return this;
124425 : }
124426 :
124427 : // *** COMMON CODE SECTION ENDS HERE ***
124428 :
124429 :
124430 : // End of memberFunctionString
124431 : // Start of memberFunctionString
124432 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
124433 :
124434 :
124435 : #if 0
124436 : //! Error checking support
124437 : /*! Verifies the following:
124438 : - working getVariant() member function
124439 : - calls base class's error() member function
124440 : Every class has one of these functions.
124441 : */
124442 : bool
124443 : SgTemplateFunctionDefinition::error()
124444 : {
124445 : // Put error checking here
124446 :
124447 : ROSE_ASSERT (this != NULL);
124448 : if (getVariant() != TEMPLATE_FUNCTION_DEF_STMT)
124449 : {
124450 : printf ("Error in SgTemplateFunctionDefinition::error(): SgTemplateFunctionDefinition object has a %s variant \n",
124451 : Cxx_GrammarTerminalNames[getVariant()].name);
124452 : // printf ("Error in SgTemplateFunctionDefinition::error() \n");
124453 : ROSE_ABORT();
124454 : }
124455 :
124456 : ROSE_ASSERT (getVariant() == TEMPLATE_FUNCTION_DEF_STMT);
124457 : return SgFunctionDefinition::error();
124458 : }
124459 : #endif
124460 :
124461 :
124462 :
124463 : // End of memberFunctionString
124464 :
124465 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
124466 :
124467 13962 : SgTemplateFunctionDefinition* isSgTemplateFunctionDefinition ( SgNode* inputDerivedClassPointer )
124468 : {
124469 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
124470 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
124471 : // So to fix this we return NULL directly when the input is NULL and avoid the
124472 : // dynamic_cast in this case. This is likely a performance improvement as well.
124473 : // return dynamic_cast<SgTemplateFunctionDefinition*>(inputDerivedClassPointer);
124474 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionDefinition uses table-driven castability instead of c++ default dynamic_cast
124475 : // this improves the running time performance by 10-20%.
124476 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateFunctionDefinition*>(inputDerivedClassPointer);
124477 13962 : return IS_SgTemplateFunctionDefinition_FAST_MACRO(inputDerivedClassPointer);
124478 : }
124479 :
124480 : // DQ (11/8/2003): Added version of functions taking const pointer
124481 8709 : const SgTemplateFunctionDefinition* isSgTemplateFunctionDefinition ( const SgNode* inputDerivedClassPointer )
124482 : {
124483 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
124484 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
124485 : // So to fix this we return NULL directly when the input is NULL and avoid the
124486 : // dynamic_cast in this case. This is likely a performance improvement as well.
124487 : // return dynamic_cast<const SgTemplateFunctionDefinition*>(inputDerivedClassPointer);
124488 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionDefinition uses table-driven castability instead of c++ default dynamic_cast
124489 : // this improves the running time performance by 10-20%.
124490 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateFunctionDefinition*>(inputDerivedClassPointer);
124491 8709 : return IS_SgTemplateFunctionDefinition_FAST_MACRO(inputDerivedClassPointer);
124492 : }
124493 :
124494 :
124495 :
124496 : /* #line 124497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124497 :
124498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
124499 :
124500 : /**
124501 : \brief Generated destructor
124502 :
124503 : This destructor is automatically generated (by ROSETTA). This destructor
124504 : only frees memory of data members associated with the parts of the current IR node which
124505 : are NOT traversed. Those data members that are part of a traversal can be freed using
124506 : a traversal (calling this destructor on all children in a post-order traversal). Such
124507 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
124508 :
124509 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
124510 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
124511 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
124512 :
124513 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
124514 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
124515 : pointers are not yet implemented to call delete on eash pointer in the container.
124516 : (This could be done by derivation from the STL containers to define containers that
124517 : automatically deleted their members.)
124518 :
124519 : */
124520 1260 : SgTemplateFunctionDefinition::~SgTemplateFunctionDefinition () {
124521 630 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
124522 :
124523 :
124524 :
124525 : }
124526 :
124527 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
124528 1260 : }
124529 :
124530 :
124531 : /* #line 124532 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124532 :
124533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
124534 :
124535 : // Generated constructor
124536 0 : SgTemplateFunctionDefinition::SgTemplateFunctionDefinition ( Sg_File_Info* startOfConstruct, SgBasicBlock* body )
124537 0 : : SgFunctionDefinition(startOfConstruct, body)
124538 : {
124539 : #ifdef DEBUG
124540 : // printf ("In SgTemplateFunctionDefinition::SgTemplateFunctionDefinition (Sg_File_Info* startOfConstruct, SgBasicBlock* body) sage_class_name() = %s \n",sage_class_name());
124541 : #endif
124542 : #if 0
124543 : // debugging information!
124544 : printf ("In SgTemplateFunctionDefinition::SgTemplateFunctionDefinition (Sg_File_Info* startOfConstruct, SgBasicBlock* body): this = %p = %s \n",this,this->class_name().c_str());
124545 : #endif
124546 :
124547 :
124548 :
124549 : #if 0
124550 : // DQ (7/30/2014): Call a virtual function.
124551 : std::string s = this->class_name();
124552 : #endif
124553 :
124554 : // Test the variant virtual function
124555 : // assert(TEMPLATE_FUNCTION_DEF_STMT == variant());
124556 0 : assert(TEMPLATE_FUNCTION_DEF_STMT == this->variant());
124557 0 : ROSE_ASSERT(TEMPLATE_FUNCTION_DEF_STMT == (int)(this->variantT()));
124558 0 : post_construction_initialization();
124559 :
124560 : // Test the isSgTemplateFunctionDefinition() function since it has been problematic
124561 0 : assert(isSgTemplateFunctionDefinition(this) != NULL);
124562 0 : }
124563 :
124564 : // Generated constructor (all data members)
124565 :
124566 : /* #line 124567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124567 :
124568 :
124569 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
124570 :
124571 :
124572 : // ********************************************************
124573 : // member functions common across all array grammar objects
124574 : // ********************************************************
124575 :
124576 :
124577 :
124578 : /* #line 124579 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124579 :
124580 :
124581 :
124582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
124583 :
124584 : // ********************************************************
124585 : // member functions specific to each node in the grammar
124586 : // ********************************************************
124587 :
124588 :
124589 : /* #line 124590 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
124590 :
124591 : // Start of memberFunctionString
124592 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
124593 :
124594 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
124595 :
124596 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
124597 : const SgDeclarationStatementPtrList &
124598 13598 : SgClassDefinition::get_members () const
124599 : {
124600 13598 : assert (this != NULL);
124601 13598 : return p_members;
124602 : }
124603 :
124604 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
124605 : SgDeclarationStatementPtrList &
124606 218635 : SgClassDefinition::get_members ()
124607 : {
124608 218635 : assert (this != NULL);
124609 :
124610 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
124611 : // As a rule only set_ access functions can set the isModified flag.
124612 : // set_isModified(true);
124613 :
124614 218635 : return p_members;
124615 : }
124616 :
124617 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
124618 :
124619 :
124620 : // End of memberFunctionString
124621 : // Start of memberFunctionString
124622 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
124623 :
124624 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
124625 :
124626 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
124627 : const SgBaseClassPtrList &
124628 0 : SgClassDefinition::get_inheritances () const
124629 : {
124630 0 : assert (this != NULL);
124631 0 : return p_inheritances;
124632 : }
124633 :
124634 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
124635 : SgBaseClassPtrList &
124636 60431 : SgClassDefinition::get_inheritances ()
124637 : {
124638 60431 : assert (this != NULL);
124639 :
124640 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
124641 : // As a rule only set_ access functions can set the isModified flag.
124642 : // set_isModified(true);
124643 :
124644 60431 : return p_inheritances;
124645 : }
124646 :
124647 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
124648 :
124649 :
124650 : // End of memberFunctionString
124651 : // Start of memberFunctionString
124652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
124653 :
124654 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
124655 :
124656 : unsigned int
124657 628 : SgClassDefinition::get_packingAlignment () const
124658 : {
124659 628 : ROSE_ASSERT (this != NULL);
124660 :
124661 : #if 0
124662 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124663 : // used to trigger marking transformations for the token-based unparsing.
124664 : printf ("SgClassDefinition::get_packingAlignment = %p = %s \n",this,this->class_name().c_str());
124665 : #endif
124666 :
124667 628 : return p_packingAlignment;
124668 : }
124669 :
124670 : void
124671 0 : SgClassDefinition::set_packingAlignment ( unsigned int packingAlignment )
124672 : {
124673 0 : ROSE_ASSERT (this != NULL);
124674 :
124675 : #if 0
124676 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124677 : // used to trigger marking transformations for the token-based unparsing.
124678 : printf ("SgClassDefinition::set_packingAlignment = %p = %s \n",this,this->class_name().c_str());
124679 : #endif
124680 :
124681 0 : set_isModified(true);
124682 :
124683 0 : p_packingAlignment = packingAlignment;
124684 0 : }
124685 :
124686 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
124687 :
124688 :
124689 : // End of memberFunctionString
124690 : // Start of memberFunctionString
124691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
124692 :
124693 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
124694 :
124695 : bool
124696 0 : SgClassDefinition::get_isSequence () const
124697 : {
124698 0 : ROSE_ASSERT (this != NULL);
124699 :
124700 : #if 0
124701 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124702 : // used to trigger marking transformations for the token-based unparsing.
124703 : printf ("SgClassDefinition::get_isSequence = %p = %s \n",this,this->class_name().c_str());
124704 : #endif
124705 :
124706 0 : return p_isSequence;
124707 : }
124708 :
124709 : void
124710 0 : SgClassDefinition::set_isSequence ( bool isSequence )
124711 : {
124712 0 : ROSE_ASSERT (this != NULL);
124713 :
124714 : #if 0
124715 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124716 : // used to trigger marking transformations for the token-based unparsing.
124717 : printf ("SgClassDefinition::set_isSequence = %p = %s \n",this,this->class_name().c_str());
124718 : #endif
124719 :
124720 0 : set_isModified(true);
124721 :
124722 0 : p_isSequence = isSequence;
124723 0 : }
124724 :
124725 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
124726 :
124727 :
124728 : // End of memberFunctionString
124729 : // Start of memberFunctionString
124730 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
124731 :
124732 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
124733 :
124734 : bool
124735 0 : SgClassDefinition::get_isPrivate () const
124736 : {
124737 0 : ROSE_ASSERT (this != NULL);
124738 :
124739 : #if 0
124740 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124741 : // used to trigger marking transformations for the token-based unparsing.
124742 : printf ("SgClassDefinition::get_isPrivate = %p = %s \n",this,this->class_name().c_str());
124743 : #endif
124744 :
124745 0 : return p_isPrivate;
124746 : }
124747 :
124748 : void
124749 0 : SgClassDefinition::set_isPrivate ( bool isPrivate )
124750 : {
124751 0 : ROSE_ASSERT (this != NULL);
124752 :
124753 : #if 0
124754 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124755 : // used to trigger marking transformations for the token-based unparsing.
124756 : printf ("SgClassDefinition::set_isPrivate = %p = %s \n",this,this->class_name().c_str());
124757 : #endif
124758 :
124759 0 : set_isModified(true);
124760 :
124761 0 : p_isPrivate = isPrivate;
124762 0 : }
124763 :
124764 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
124765 :
124766 :
124767 : // End of memberFunctionString
124768 : // Start of memberFunctionString
124769 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
124770 :
124771 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
124772 :
124773 : bool
124774 0 : SgClassDefinition::get_isAbstract () const
124775 : {
124776 0 : ROSE_ASSERT (this != NULL);
124777 :
124778 : #if 0
124779 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124780 : // used to trigger marking transformations for the token-based unparsing.
124781 : printf ("SgClassDefinition::get_isAbstract = %p = %s \n",this,this->class_name().c_str());
124782 : #endif
124783 :
124784 0 : return p_isAbstract;
124785 : }
124786 :
124787 : void
124788 0 : SgClassDefinition::set_isAbstract ( bool isAbstract )
124789 : {
124790 0 : ROSE_ASSERT (this != NULL);
124791 :
124792 : #if 0
124793 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
124794 : // used to trigger marking transformations for the token-based unparsing.
124795 : printf ("SgClassDefinition::set_isAbstract = %p = %s \n",this,this->class_name().c_str());
124796 : #endif
124797 :
124798 0 : set_isModified(true);
124799 :
124800 0 : p_isAbstract = isAbstract;
124801 0 : }
124802 :
124803 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
124804 :
124805 :
124806 : // End of memberFunctionString
124807 : // Start of memberFunctionString
124808 : /* #line 14702 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
124809 :
124810 :
124811 : void
124812 17131 : SgClassDefinition::post_construction_initialization()
124813 : {
124814 : // DQ (9/5/2006): I don't think that this is called, but if it is then packingAlignment initialization is required.
124815 17131 : p_packingAlignment = 0;
124816 :
124817 : #if 0
124818 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
124819 : printf ("In SgClassDefinition::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
124820 : #endif
124821 17131 : }
124822 :
124823 : void
124824 12209 : SgClassDefinition::set_declaration(SgClassDeclaration* new_val)
124825 : {
124826 : // QY: 10-4-04 removed declaration pointer. use parent pointer instead
124827 12209 : ROSE_ASSERT(this != NULL);
124828 12209 : set_parent(new_val);
124829 12209 : }
124830 :
124831 : SgClassDeclaration*
124832 1182680 : SgClassDefinition::get_declaration() const
124833 : {
124834 : // QY: 10-4-04 removed declaration pointer. use parent pointer instead
124835 1182680 : ROSE_ASSERT(this != NULL);
124836 :
124837 1182680 : ROSE_ASSERT(get_parent() != NULL);
124838 : // printf ("In SgClassDefinition::get_declaration(): get_parent() = %p = %s \n",get_parent(),get_parent()->class_name().c_str());
124839 :
124840 1182680 : SgClassDeclaration *decl = isSgClassDeclaration(get_parent());
124841 1182680 : assert( get_parent() == NULL || decl != NULL );
124842 1182680 : return decl;
124843 : }
124844 :
124845 0 : SgClassDefinition::SgClassDefinition( Sg_File_Info *f, SgClassDeclaration *decl)
124846 0 : : SgScopeStatement(f)
124847 : {
124848 0 : set_declaration(decl);
124849 0 : decl->set_definition(this);
124850 :
124851 : // DQ (9/5/2006): Added initialization of packingAlignment (required to be explicit in this constructor)
124852 0 : p_packingAlignment = 0;
124853 0 : }
124854 :
124855 0 : SgClassDefinition::SgClassDefinition( SgClassDeclaration *decl)
124856 0 : : SgScopeStatement()
124857 : {
124858 0 : set_declaration(decl);
124859 0 : decl->set_definition(this);
124860 :
124861 : // DQ (9/5/2006): Added initialization of packingAlignment (required to be explicit in this constructor)
124862 0 : p_packingAlignment = 0;
124863 0 : }
124864 :
124865 : #if 0
124866 : void
124867 : SgClassDefinition::insert_member(const SgDeclarationStatementPtrList::iterator& where, SgDeclarationStatement * what)
124868 : {
124869 : #ifndef REMOVE_SET_PARENT_FUNCTION
124870 : what->set_parent(this);
124871 : #endif
124872 : get_members().insert(where,what);
124873 : }
124874 : #endif
124875 :
124876 : void
124877 0 : SgClassDefinition::append_member(SgDeclarationStatement * what)
124878 : {
124879 0 : get_members().push_back(what);
124880 0 : what->set_parent(this);
124881 0 : }
124882 :
124883 : void
124884 0 : SgClassDefinition::prepend_member(SgDeclarationStatement * what)
124885 : {
124886 0 : get_members().insert(get_members().begin(), what);
124887 0 : what->set_parent(this);
124888 0 : }
124889 :
124890 : void
124891 : // SgClassDefinition::append_inheritance(const SgBaseClass & what)
124892 5725 : SgClassDefinition::append_inheritance(SgBaseClass* what)
124893 : {
124894 5725 : get_inheritances().push_back(what);
124895 5725 : what->set_parent(this);
124896 5725 : }
124897 :
124898 : void
124899 : // SgClassDefinition::prepend_inheritance(const SgBaseClass & what)
124900 0 : SgClassDefinition::prepend_inheritance(SgBaseClass* what)
124901 : {
124902 0 : get_inheritances().insert(get_inheritances().begin(), what);
124903 0 : }
124904 :
124905 : #if 0
124906 : void
124907 : // SgClassDefinition::insert_inheritance(const SgBaseClassList::iterator & where, const SgBaseClass & what)
124908 : SgClassDefinition::insert_inheritance(const SgBaseClassPtrList::iterator & where, SgBaseClass* what)
124909 : {
124910 : get_inheritances().insert(where,what);
124911 : }
124912 : #endif
124913 :
124914 : SgName
124915 2267 : SgClassDefinition::get_qualified_name() const
124916 : {
124917 : // printf ("In SgClassDefinition::get_qualified_name() \n");
124918 :
124919 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
124920 : // return get_declaration()->get_qualified_name();
124921 2267 : SgClassDeclaration* classDeclaration = get_declaration();
124922 2267 : ROSE_ASSERT(classDeclaration != NULL);
124923 2267 : return classDeclaration->get_qualified_name();
124924 : }
124925 :
124926 : // DQ (2/7/2006): code added by Rich Vuduc
124927 : SgName
124928 132125 : SgClassDefinition::get_mangled_name (void) const
124929 : {
124930 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
124931 : // return get_declaration()->get_mangled_name();
124932 132125 : SgClassDeclaration* classDeclaration = get_declaration();
124933 132125 : ROSE_ASSERT(classDeclaration != NULL);
124934 132125 : return classDeclaration->get_mangled_name();
124935 : }
124936 :
124937 : SgName
124938 0 : SgClassDefinition::get_mangled_qualified_name (int& i)
124939 : {
124940 : // printf ("In SgClassDefinition::get_mangled_qualified_name(%d): Calling get_declaration()->get_mangled_qualified_name(%d) \n",i,i);
124941 :
124942 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
124943 : // return get_declaration()->get_mangled_qualified_name(i);
124944 0 : SgClassDeclaration* classDeclaration = get_declaration();
124945 0 : ROSE_ASSERT(classDeclaration != NULL);
124946 0 : return classDeclaration->get_mangled_qualified_name(i);
124947 : }
124948 :
124949 : bool
124950 0 : SgClassDefinition::replace_child(SgStatement *target,SgStatement *newstmt,
124951 : bool extractBasicBlock)
124952 : {
124953 0 : return StatementListInsertChild(this, get_members(), target, newstmt, true, extractBasicBlock, true);
124954 : }
124955 :
124956 : bool
124957 50542 : SgClassDefinition::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront,
124958 : bool extractBasicBlock)
124959 : {
124960 50542 : return StatementListInsertChild( this, get_members(), target, newstmt, inFront, extractBasicBlock, false);
124961 : }
124962 :
124963 : #if 0
124964 : // DQ (8/18/2004): removing this older pragma mechanism
124965 : /****** SgClassDeclaration ******/
124966 : int
124967 : get_suppress_global(SgClassDeclaration *node)
124968 : {
124969 : SgClassDecl_attr *attr= (SgClassDecl_attr *) Sgget_user_attribute(node->get_uattributes(),"SgClassDecl_attr");
124970 : if(attr)
124971 : return attr->get_suppress_global();
124972 :
124973 : return 0;
124974 : }
124975 : #endif
124976 :
124977 :
124978 :
124979 : // End of memberFunctionString
124980 : // Start of memberFunctionString
124981 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
124982 :
124983 : // *** COMMON CODE SECTION BEGINS HERE ***
124984 :
124985 : #if 0
124986 : int
124987 : SgClassDefinition::getVariant() const
124988 : {
124989 : // This function is used in ROSE while "variant()" is used in SAGE
124990 : assert(this != NULL);
124991 : return variant();
124992 : }
124993 : #endif
124994 :
124995 : // This function is used in ROSE in treeTraversal code
124996 : // eventually replaces getVariant() and variant()
124997 : // though after variant() has been removed for a while we will
124998 : // want to change the name of variantT() back to variant()
124999 : // (since the "T" was ment to stand for temporary).
125000 : // When this happens the variantT() will be depricated.
125001 : VariantT
125002 4861990 : SgClassDefinition::variantT() const
125003 : {
125004 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
125005 4861990 : ROSE_ASSERT(this != NULL);
125006 4861990 : return V_SgClassDefinition;
125007 : }
125008 :
125009 : #if 0
125010 : int
125011 : SgClassDefinition::variant() const
125012 : {
125013 : // This function is used in SAGE
125014 : ROSE_ASSERT(this != NULL);
125015 : return CLASS_DEFN_STMT;
125016 : }
125017 : #endif
125018 :
125019 : ROSE_DLL_API const char*
125020 165 : SgClassDefinition::sage_class_name() const
125021 : {
125022 165 : ROSE_ASSERT(this != NULL);
125023 165 : return "SgClassDefinition";
125024 : }
125025 :
125026 : std::string
125027 402298 : SgClassDefinition::class_name() const
125028 : {
125029 402298 : ROSE_ASSERT(this != NULL);
125030 402298 : return "SgClassDefinition";
125031 : }
125032 :
125033 : // DQ (11/26/2005): Support for visitor pattern mechanims
125034 : // (inferior to ROSE traversal mechanism, experimental).
125035 : void
125036 22423 : SgClassDefinition::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
125037 : {
125038 22423 : ROSE_ASSERT(this != NULL);
125039 22423 : visitor.visit(this);
125040 22423 : }
125041 :
125042 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
125043 0 : void SgClassDefinition::accept (ROSE_VisitorPattern & visitor) {
125044 0 : ROSE_ASSERT(this != NULL);
125045 0 : visitor.visit(this);
125046 0 : }
125047 :
125048 : SgClassDefinition*
125049 0 : SgClassDefinition::addRegExpAttribute(std::string s, AstRegExAttribute* a)
125050 : {
125051 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
125052 : // This function is currently only supported for the AST used the represent Binary executables.
125053 : if (0 /* isSgAsmNode(this) != NULL */)
125054 : {
125055 : // Support for regex specification.
125056 : std::string prefixCode = "REGEX:";
125057 : addNewAttribute(prefixCode + s,a);
125058 : }
125059 : #endif
125060 :
125061 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
125062 0 : return this;
125063 : }
125064 :
125065 : // *** COMMON CODE SECTION ENDS HERE ***
125066 :
125067 :
125068 : // End of memberFunctionString
125069 : // Start of memberFunctionString
125070 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
125071 :
125072 :
125073 : #if 0
125074 : //! Error checking support
125075 : /*! Verifies the following:
125076 : - working getVariant() member function
125077 : - calls base class's error() member function
125078 : Every class has one of these functions.
125079 : */
125080 : bool
125081 : SgClassDefinition::error()
125082 : {
125083 : // Put error checking here
125084 :
125085 : ROSE_ASSERT (this != NULL);
125086 : if (getVariant() != CLASS_DEFN_STMT)
125087 : {
125088 : printf ("Error in SgClassDefinition::error(): SgClassDefinition object has a %s variant \n",
125089 : Cxx_GrammarTerminalNames[getVariant()].name);
125090 : // printf ("Error in SgClassDefinition::error() \n");
125091 : ROSE_ABORT();
125092 : }
125093 :
125094 : ROSE_ASSERT (getVariant() == CLASS_DEFN_STMT);
125095 : return SgScopeStatement::error();
125096 : }
125097 : #endif
125098 :
125099 :
125100 :
125101 : // End of memberFunctionString
125102 :
125103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
125104 :
125105 72500100 : SgClassDefinition* isSgClassDefinition ( SgNode* inputDerivedClassPointer )
125106 : {
125107 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
125108 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
125109 : // So to fix this we return NULL directly when the input is NULL and avoid the
125110 : // dynamic_cast in this case. This is likely a performance improvement as well.
125111 : // return dynamic_cast<SgClassDefinition*>(inputDerivedClassPointer);
125112 : // Milind Chabbi (8/28/2013): isSgClassDefinition uses table-driven castability instead of c++ default dynamic_cast
125113 : // this improves the running time performance by 10-20%.
125114 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassDefinition*>(inputDerivedClassPointer);
125115 72500100 : return IS_SgClassDefinition_FAST_MACRO(inputDerivedClassPointer);
125116 : }
125117 :
125118 : // DQ (11/8/2003): Added version of functions taking const pointer
125119 180503 : const SgClassDefinition* isSgClassDefinition ( const SgNode* inputDerivedClassPointer )
125120 : {
125121 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
125122 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
125123 : // So to fix this we return NULL directly when the input is NULL and avoid the
125124 : // dynamic_cast in this case. This is likely a performance improvement as well.
125125 : // return dynamic_cast<const SgClassDefinition*>(inputDerivedClassPointer);
125126 : // Milind Chabbi (8/28/2013): isSgClassDefinition uses table-driven castability instead of c++ default dynamic_cast
125127 : // this improves the running time performance by 10-20%.
125128 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassDefinition*>(inputDerivedClassPointer);
125129 180503 : return IS_SgClassDefinition_FAST_MACRO(inputDerivedClassPointer);
125130 : }
125131 :
125132 :
125133 :
125134 : /* #line 125135 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125135 :
125136 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
125137 :
125138 : /**
125139 : \brief Generated destructor
125140 :
125141 : This destructor is automatically generated (by ROSETTA). This destructor
125142 : only frees memory of data members associated with the parts of the current IR node which
125143 : are NOT traversed. Those data members that are part of a traversal can be freed using
125144 : a traversal (calling this destructor on all children in a post-order traversal). Such
125145 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
125146 :
125147 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
125148 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
125149 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
125150 :
125151 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
125152 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
125153 : pointers are not yet implemented to call delete on eash pointer in the container.
125154 : (This could be done by derivation from the STL containers to define containers that
125155 : automatically deleted their members.)
125156 :
125157 : */
125158 5742 : SgClassDefinition::~SgClassDefinition () {
125159 2550 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
125160 :
125161 :
125162 : // case: not a listType for packingAlignment
125163 2550 : p_packingAlignment = 0; // non list case
125164 : // case: not a listType for isSequence
125165 2550 : p_isSequence = false; // non list case
125166 : // case: not a listType for isPrivate
125167 2550 : p_isPrivate = false; // non list case
125168 : // case: not a listType for isAbstract
125169 2550 : p_isAbstract = false; // non list case
125170 :
125171 : }
125172 :
125173 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
125174 2886 : }
125175 :
125176 :
125177 : /* #line 125178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125178 :
125179 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
125180 :
125181 : // Generated constructor
125182 0 : SgClassDefinition::SgClassDefinition ( Sg_File_Info* startOfConstruct )
125183 0 : : SgScopeStatement(startOfConstruct)
125184 : {
125185 : #ifdef DEBUG
125186 : // printf ("In SgClassDefinition::SgClassDefinition (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
125187 : #endif
125188 : #if 0
125189 : // debugging information!
125190 : printf ("In SgClassDefinition::SgClassDefinition (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
125191 : #endif
125192 :
125193 0 : p_packingAlignment = 0;
125194 0 : p_isSequence = false;
125195 0 : p_isPrivate = false;
125196 0 : p_isAbstract = false;
125197 :
125198 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
125199 :
125200 : #if 0
125201 : // DQ (7/30/2014): Call a virtual function.
125202 : std::string s = this->class_name();
125203 : #endif
125204 :
125205 : // Test the variant virtual function
125206 : // assert(CLASS_DEFN_STMT == variant());
125207 0 : assert(CLASS_DEFN_STMT == this->variant());
125208 0 : ROSE_ASSERT(CLASS_DEFN_STMT == (int)(this->variantT()));
125209 0 : post_construction_initialization();
125210 :
125211 : // Test the isSgClassDefinition() function since it has been problematic
125212 0 : assert(isSgClassDefinition(this) != NULL);
125213 0 : }
125214 :
125215 : // Generated constructor (all data members)
125216 :
125217 : /* #line 125218 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125218 :
125219 :
125220 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
125221 :
125222 :
125223 : // ********************************************************
125224 : // member functions common across all array grammar objects
125225 : // ********************************************************
125226 :
125227 :
125228 :
125229 : /* #line 125230 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125230 :
125231 :
125232 :
125233 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
125234 :
125235 : // ********************************************************
125236 : // member functions specific to each node in the grammar
125237 : // ********************************************************
125238 :
125239 :
125240 : /* #line 125241 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125241 :
125242 : // Start of memberFunctionString
125243 : /* #line 14607 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
125244 :
125245 :
125246 : void
125247 5417 : SgTemplateInstantiationDefn::post_construction_initialization()
125248 : {
125249 : #if 0
125250 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
125251 : printf ("In SgTemplateInstantiationDefn::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
125252 : #endif
125253 5417 : }
125254 :
125255 :
125256 : // DQ (9/8/2004): overrides base class implementation
125257 : SgName
125258 13483 : SgTemplateInstantiationDefn::get_qualified_name() const
125259 : {
125260 : // printf ("In SgTemplateInstantiationDefn::get_qualified_name() \n");
125261 :
125262 : // It is a little less trivial to obtain the SgTemplateInstatiationDecl from the SgTemplateInstatiationDefn
125263 : // since get_declaration() returns a SgClassDeclaration pointer and not a SgTemplateInstantiationDecl pointer.
125264 13483 : SgClassDeclaration* classDeclaration = get_declaration();
125265 13483 : ROSE_ASSERT(classDeclaration != NULL);
125266 13483 : SgTemplateInstantiationDecl* templateInstantiationDeclaration = isSgTemplateInstantiationDecl(classDeclaration);
125267 13483 : ROSE_ASSERT(templateInstantiationDeclaration != NULL);
125268 :
125269 : // DQ (10/16/2004): Not sure why this is not set!
125270 : // ROSE_ASSERT (get_parent() != NULL);
125271 13483 : if (templateInstantiationDeclaration->get_parent() == NULL)
125272 : {
125273 : // DQ (3/6/2012): Commented out this code since the name qulification uses the scope and not the parent.
125274 : // printf ("templateInstantiationDeclaration->get_parent() == NULL SgTemplateInstantiationDecl = %p SgClassDefinition = %p \n",templateInstantiationDeclaration,this);
125275 : // get_file_info()->display("SgTemplateInstantiationDefn");
125276 : // templateInstantiationDeclaration->get_file_info()->display("templateInstantiationDeclaration");
125277 : }
125278 :
125279 : // DQ (3/5/2012): Allow the parent to be unset (since I thing it might not be required any more because we use the scope).
125280 : // ROSE_ASSERT (templateInstantiationDeclaration->get_parent() != NULL);
125281 : // printf ("Note: In SgTemplateInstantiationDefn::get_qualified_name(): we no longer assert that templateInstantiationDeclaration->get_parent() != NULL \n");
125282 :
125283 13483 : return templateInstantiationDeclaration->get_qualified_name();
125284 : }
125285 :
125286 0 : SgTemplateInstantiationDefn::SgTemplateInstantiationDefn( Sg_File_Info *f, SgTemplateInstantiationDecl *decl)
125287 0 : : SgClassDefinition(f,decl)
125288 : {
125289 0 : }
125290 :
125291 0 : SgTemplateInstantiationDefn::SgTemplateInstantiationDefn( SgTemplateInstantiationDecl *decl)
125292 0 : : SgClassDefinition(decl)
125293 : {
125294 0 : }
125295 :
125296 :
125297 : // DQ (5/31/2012): Added to support the generation of mangled names and permit testing for template syntax.
125298 : SgName
125299 81793 : SgTemplateInstantiationDefn::get_mangled_name(void) const
125300 : {
125301 : #if 0
125302 : printf ("In SgTemplateInstantiationDefn::get_mangled_name(): this = %p = %s \n",this,this->class_name().c_str());
125303 : #endif
125304 :
125305 : // DQ (10/31/2015): This the actual detection in this function is commented out so that we can
125306 : // use the mechanism to avoid template class instantiations from be processed recursively.
125307 : // testForCycleInTemplateArgumentsOfTemplateDeclaration(this);
125308 :
125309 : #if 0
125310 : printf ("PASSED: In SgTemplateInstantiationDefn::get_mangled_name(): this = %p = %s \n",this,this->class_name().c_str());
125311 : #endif
125312 :
125313 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
125314 : // SgName mangledName = get_declaration()->get_mangled_name();
125315 81793 : SgClassDeclaration* classDeclaration = get_declaration();
125316 81793 : ROSE_ASSERT(classDeclaration != NULL);
125317 81793 : SgName mangledName = classDeclaration->get_mangled_name();
125318 :
125319 : #if 0
125320 : printf ("In SgTemplateInstantiationDefn::get_mangled_name(): mangleName = %s \n",mangledName.str());
125321 : #endif
125322 :
125323 : // DQ (5/31/2012): Added test for template brackets that are caught later in AstConsistencyTests.
125324 : // Make sure that there is no template specific syntax included in the mangled name
125325 81793 : string mangled_name = mangledName;
125326 81793 : if ( mangled_name.find('<') != string::npos )
125327 : {
125328 0 : printf ("In mangleQualifiersToString(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
125329 : }
125330 81793 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
125331 :
125332 81908 : return mangledName;
125333 : }
125334 :
125335 :
125336 :
125337 :
125338 :
125339 : // End of memberFunctionString
125340 : // Start of memberFunctionString
125341 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
125342 :
125343 : // *** COMMON CODE SECTION BEGINS HERE ***
125344 :
125345 : #if 0
125346 : int
125347 : SgTemplateInstantiationDefn::getVariant() const
125348 : {
125349 : // This function is used in ROSE while "variant()" is used in SAGE
125350 : assert(this != NULL);
125351 : return variant();
125352 : }
125353 : #endif
125354 :
125355 : // This function is used in ROSE in treeTraversal code
125356 : // eventually replaces getVariant() and variant()
125357 : // though after variant() has been removed for a while we will
125358 : // want to change the name of variantT() back to variant()
125359 : // (since the "T" was ment to stand for temporary).
125360 : // When this happens the variantT() will be depricated.
125361 : VariantT
125362 7620540 : SgTemplateInstantiationDefn::variantT() const
125363 : {
125364 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
125365 7620540 : ROSE_ASSERT(this != NULL);
125366 7620540 : return V_SgTemplateInstantiationDefn;
125367 : }
125368 :
125369 : #if 0
125370 : int
125371 : SgTemplateInstantiationDefn::variant() const
125372 : {
125373 : // This function is used in SAGE
125374 : ROSE_ASSERT(this != NULL);
125375 : return TEMPLATE_INST_DEFN_STMT;
125376 : }
125377 : #endif
125378 :
125379 : ROSE_DLL_API const char*
125380 1251 : SgTemplateInstantiationDefn::sage_class_name() const
125381 : {
125382 1251 : ROSE_ASSERT(this != NULL);
125383 1251 : return "SgTemplateInstantiationDefn";
125384 : }
125385 :
125386 : std::string
125387 297786 : SgTemplateInstantiationDefn::class_name() const
125388 : {
125389 297786 : ROSE_ASSERT(this != NULL);
125390 297786 : return "SgTemplateInstantiationDefn";
125391 : }
125392 :
125393 : // DQ (11/26/2005): Support for visitor pattern mechanims
125394 : // (inferior to ROSE traversal mechanism, experimental).
125395 : void
125396 83252 : SgTemplateInstantiationDefn::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
125397 : {
125398 83252 : ROSE_ASSERT(this != NULL);
125399 83252 : visitor.visit(this);
125400 83252 : }
125401 :
125402 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
125403 0 : void SgTemplateInstantiationDefn::accept (ROSE_VisitorPattern & visitor) {
125404 0 : ROSE_ASSERT(this != NULL);
125405 0 : visitor.visit(this);
125406 0 : }
125407 :
125408 : SgTemplateInstantiationDefn*
125409 0 : SgTemplateInstantiationDefn::addRegExpAttribute(std::string s, AstRegExAttribute* a)
125410 : {
125411 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
125412 : // This function is currently only supported for the AST used the represent Binary executables.
125413 : if (0 /* isSgAsmNode(this) != NULL */)
125414 : {
125415 : // Support for regex specification.
125416 : std::string prefixCode = "REGEX:";
125417 : addNewAttribute(prefixCode + s,a);
125418 : }
125419 : #endif
125420 :
125421 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
125422 0 : return this;
125423 : }
125424 :
125425 : // *** COMMON CODE SECTION ENDS HERE ***
125426 :
125427 :
125428 : // End of memberFunctionString
125429 : // Start of memberFunctionString
125430 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
125431 :
125432 :
125433 : #if 0
125434 : //! Error checking support
125435 : /*! Verifies the following:
125436 : - working getVariant() member function
125437 : - calls base class's error() member function
125438 : Every class has one of these functions.
125439 : */
125440 : bool
125441 : SgTemplateInstantiationDefn::error()
125442 : {
125443 : // Put error checking here
125444 :
125445 : ROSE_ASSERT (this != NULL);
125446 : if (getVariant() != TEMPLATE_INST_DEFN_STMT)
125447 : {
125448 : printf ("Error in SgTemplateInstantiationDefn::error(): SgTemplateInstantiationDefn object has a %s variant \n",
125449 : Cxx_GrammarTerminalNames[getVariant()].name);
125450 : // printf ("Error in SgTemplateInstantiationDefn::error() \n");
125451 : ROSE_ABORT();
125452 : }
125453 :
125454 : ROSE_ASSERT (getVariant() == TEMPLATE_INST_DEFN_STMT);
125455 : return SgClassDefinition::error();
125456 : }
125457 : #endif
125458 :
125459 :
125460 :
125461 : // End of memberFunctionString
125462 :
125463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
125464 :
125465 25117900 : SgTemplateInstantiationDefn* isSgTemplateInstantiationDefn ( SgNode* inputDerivedClassPointer )
125466 : {
125467 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
125468 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
125469 : // So to fix this we return NULL directly when the input is NULL and avoid the
125470 : // dynamic_cast in this case. This is likely a performance improvement as well.
125471 : // return dynamic_cast<SgTemplateInstantiationDefn*>(inputDerivedClassPointer);
125472 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationDefn uses table-driven castability instead of c++ default dynamic_cast
125473 : // this improves the running time performance by 10-20%.
125474 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateInstantiationDefn*>(inputDerivedClassPointer);
125475 25117900 : return IS_SgTemplateInstantiationDefn_FAST_MACRO(inputDerivedClassPointer);
125476 : }
125477 :
125478 : // DQ (11/8/2003): Added version of functions taking const pointer
125479 97128 : const SgTemplateInstantiationDefn* isSgTemplateInstantiationDefn ( const SgNode* inputDerivedClassPointer )
125480 : {
125481 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
125482 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
125483 : // So to fix this we return NULL directly when the input is NULL and avoid the
125484 : // dynamic_cast in this case. This is likely a performance improvement as well.
125485 : // return dynamic_cast<const SgTemplateInstantiationDefn*>(inputDerivedClassPointer);
125486 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationDefn uses table-driven castability instead of c++ default dynamic_cast
125487 : // this improves the running time performance by 10-20%.
125488 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateInstantiationDefn*>(inputDerivedClassPointer);
125489 97128 : return IS_SgTemplateInstantiationDefn_FAST_MACRO(inputDerivedClassPointer);
125490 : }
125491 :
125492 :
125493 :
125494 : /* #line 125495 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125495 :
125496 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
125497 :
125498 : /**
125499 : \brief Generated destructor
125500 :
125501 : This destructor is automatically generated (by ROSETTA). This destructor
125502 : only frees memory of data members associated with the parts of the current IR node which
125503 : are NOT traversed. Those data members that are part of a traversal can be freed using
125504 : a traversal (calling this destructor on all children in a post-order traversal). Such
125505 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
125506 :
125507 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
125508 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
125509 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
125510 :
125511 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
125512 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
125513 : pointers are not yet implemented to call delete on eash pointer in the container.
125514 : (This could be done by derivation from the STL containers to define containers that
125515 : automatically deleted their members.)
125516 :
125517 : */
125518 2404 : SgTemplateInstantiationDefn::~SgTemplateInstantiationDefn () {
125519 1202 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
125520 :
125521 :
125522 :
125523 : }
125524 :
125525 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
125526 2404 : }
125527 :
125528 :
125529 : /* #line 125530 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125530 :
125531 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
125532 :
125533 : // Generated constructor
125534 0 : SgTemplateInstantiationDefn::SgTemplateInstantiationDefn ( Sg_File_Info* startOfConstruct )
125535 0 : : SgClassDefinition(startOfConstruct)
125536 : {
125537 : #ifdef DEBUG
125538 : // printf ("In SgTemplateInstantiationDefn::SgTemplateInstantiationDefn (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
125539 : #endif
125540 : #if 0
125541 : // debugging information!
125542 : printf ("In SgTemplateInstantiationDefn::SgTemplateInstantiationDefn (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
125543 : #endif
125544 :
125545 :
125546 :
125547 : #if 0
125548 : // DQ (7/30/2014): Call a virtual function.
125549 : std::string s = this->class_name();
125550 : #endif
125551 :
125552 : // Test the variant virtual function
125553 : // assert(TEMPLATE_INST_DEFN_STMT == variant());
125554 0 : assert(TEMPLATE_INST_DEFN_STMT == this->variant());
125555 0 : ROSE_ASSERT(TEMPLATE_INST_DEFN_STMT == (int)(this->variantT()));
125556 0 : post_construction_initialization();
125557 :
125558 : // Test the isSgTemplateInstantiationDefn() function since it has been problematic
125559 0 : assert(isSgTemplateInstantiationDefn(this) != NULL);
125560 0 : }
125561 :
125562 : // Generated constructor (all data members)
125563 :
125564 : /* #line 125565 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125565 :
125566 :
125567 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
125568 :
125569 :
125570 : // ********************************************************
125571 : // member functions common across all array grammar objects
125572 : // ********************************************************
125573 :
125574 :
125575 :
125576 : /* #line 125577 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125577 :
125578 :
125579 :
125580 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
125581 :
125582 : // ********************************************************
125583 : // member functions specific to each node in the grammar
125584 : // ********************************************************
125585 :
125586 :
125587 : /* #line 125588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125588 :
125589 : // Start of memberFunctionString
125590 : /* #line 17129 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
125591 :
125592 : void
125593 4922 : SgTemplateClassDefinition::post_construction_initialization()
125594 : {
125595 4922 : }
125596 :
125597 : // DQ (6/11/2011): Added support for new template IR nodes.
125598 : void
125599 4922 : SgTemplateClassDefinition::set_declaration(SgTemplateClassDeclaration* new_val)
125600 : {
125601 : // QY: 10-4-04 removed declaration pointer. use parent pointer instead
125602 4922 : ROSE_ASSERT(this != NULL);
125603 4922 : set_parent(new_val);
125604 4922 : }
125605 :
125606 : // DQ (6/11/2011): Added support for new template IR nodes.
125607 : SgTemplateClassDeclaration*
125608 106076 : SgTemplateClassDefinition::get_declaration() const
125609 : {
125610 : // QY: 10-4-04 removed declaration pointer. use parent pointer instead
125611 106076 : ROSE_ASSERT(this != NULL);
125612 :
125613 106076 : ROSE_ASSERT(get_parent() != NULL);
125614 :
125615 : #if 0
125616 : printf ("In SgTemplateClassDefinition::get_declaration(): get_parent() = %p = %s \n",get_parent(),get_parent()->class_name().c_str());
125617 : #endif
125618 :
125619 106076 : SgTemplateClassDeclaration *decl = isSgTemplateClassDeclaration(get_parent());
125620 106076 : assert( get_parent() == NULL || decl != NULL );
125621 106076 : return decl;
125622 : }
125623 :
125624 : SgName
125625 4089 : SgTemplateClassDefinition::get_qualified_name() const
125626 : {
125627 : // printf ("In SgClassDefinition::get_qualified_name() \n");
125628 :
125629 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
125630 : // return get_declaration()->get_qualified_name();
125631 4089 : SgTemplateClassDeclaration* templateClassDeclaration = get_declaration();
125632 4089 : ROSE_ASSERT(templateClassDeclaration != NULL);
125633 4089 : return templateClassDeclaration->get_qualified_name();
125634 : }
125635 :
125636 : // DQ (2/7/2006): code added by Rich Vuduc
125637 : SgName
125638 50874 : SgTemplateClassDefinition::get_mangled_name (void) const
125639 : {
125640 : // DQ (3/19/2016): Klocworks reports this as an issue, since get_declaration() might be NULL.
125641 : // return get_declaration()->get_mangled_name ();
125642 50874 : SgTemplateClassDeclaration* templateClassDeclaration = get_declaration();
125643 50874 : ROSE_ASSERT(templateClassDeclaration != NULL);
125644 50874 : return templateClassDeclaration->get_mangled_name ();
125645 : }
125646 :
125647 : SgName
125648 0 : SgTemplateClassDefinition::get_mangled_qualified_name (int& i)
125649 : {
125650 : // printf ("In SgClassDefinition::get_mangled_qualified_name(%d): Calling get_declaration()->get_mangled_qualified_name(%d) \n",i,i);
125651 :
125652 0 : printf ("Sorry, SgTemplateClassDefinition::get_mangled_qualified_name(int) not implemented! \n");
125653 0 : ROSE_ASSERT(false);
125654 :
125655 : return "error_no_name";
125656 : }
125657 :
125658 0 : SgTemplateClassDefinition::SgTemplateClassDefinition( SgTemplateClassDeclaration *decl)
125659 0 : : SgClassDefinition()
125660 : {
125661 0 : set_declaration(decl);
125662 0 : decl->set_definition(this);
125663 0 : }
125664 :
125665 :
125666 :
125667 : // End of memberFunctionString
125668 : // Start of memberFunctionString
125669 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
125670 :
125671 : // *** COMMON CODE SECTION BEGINS HERE ***
125672 :
125673 : #if 0
125674 : int
125675 : SgTemplateClassDefinition::getVariant() const
125676 : {
125677 : // This function is used in ROSE while "variant()" is used in SAGE
125678 : assert(this != NULL);
125679 : return variant();
125680 : }
125681 : #endif
125682 :
125683 : // This function is used in ROSE in treeTraversal code
125684 : // eventually replaces getVariant() and variant()
125685 : // though after variant() has been removed for a while we will
125686 : // want to change the name of variantT() back to variant()
125687 : // (since the "T" was ment to stand for temporary).
125688 : // When this happens the variantT() will be depricated.
125689 : VariantT
125690 5205980 : SgTemplateClassDefinition::variantT() const
125691 : {
125692 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
125693 5205980 : ROSE_ASSERT(this != NULL);
125694 5205980 : return V_SgTemplateClassDefinition;
125695 : }
125696 :
125697 : #if 0
125698 : int
125699 : SgTemplateClassDefinition::variant() const
125700 : {
125701 : // This function is used in SAGE
125702 : ROSE_ASSERT(this != NULL);
125703 : return TEMPLATE_CLASS_DEF_STMT;
125704 : }
125705 : #endif
125706 :
125707 : ROSE_DLL_API const char*
125708 116 : SgTemplateClassDefinition::sage_class_name() const
125709 : {
125710 116 : ROSE_ASSERT(this != NULL);
125711 116 : return "SgTemplateClassDefinition";
125712 : }
125713 :
125714 : std::string
125715 225471 : SgTemplateClassDefinition::class_name() const
125716 : {
125717 225471 : ROSE_ASSERT(this != NULL);
125718 225471 : return "SgTemplateClassDefinition";
125719 : }
125720 :
125721 : // DQ (11/26/2005): Support for visitor pattern mechanims
125722 : // (inferior to ROSE traversal mechanism, experimental).
125723 : void
125724 69700 : SgTemplateClassDefinition::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
125725 : {
125726 69700 : ROSE_ASSERT(this != NULL);
125727 69700 : visitor.visit(this);
125728 69700 : }
125729 :
125730 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
125731 0 : void SgTemplateClassDefinition::accept (ROSE_VisitorPattern & visitor) {
125732 0 : ROSE_ASSERT(this != NULL);
125733 0 : visitor.visit(this);
125734 0 : }
125735 :
125736 : SgTemplateClassDefinition*
125737 0 : SgTemplateClassDefinition::addRegExpAttribute(std::string s, AstRegExAttribute* a)
125738 : {
125739 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
125740 : // This function is currently only supported for the AST used the represent Binary executables.
125741 : if (0 /* isSgAsmNode(this) != NULL */)
125742 : {
125743 : // Support for regex specification.
125744 : std::string prefixCode = "REGEX:";
125745 : addNewAttribute(prefixCode + s,a);
125746 : }
125747 : #endif
125748 :
125749 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
125750 0 : return this;
125751 : }
125752 :
125753 : // *** COMMON CODE SECTION ENDS HERE ***
125754 :
125755 :
125756 : // End of memberFunctionString
125757 : // Start of memberFunctionString
125758 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
125759 :
125760 :
125761 : #if 0
125762 : //! Error checking support
125763 : /*! Verifies the following:
125764 : - working getVariant() member function
125765 : - calls base class's error() member function
125766 : Every class has one of these functions.
125767 : */
125768 : bool
125769 : SgTemplateClassDefinition::error()
125770 : {
125771 : // Put error checking here
125772 :
125773 : ROSE_ASSERT (this != NULL);
125774 : if (getVariant() != TEMPLATE_CLASS_DEF_STMT)
125775 : {
125776 : printf ("Error in SgTemplateClassDefinition::error(): SgTemplateClassDefinition object has a %s variant \n",
125777 : Cxx_GrammarTerminalNames[getVariant()].name);
125778 : // printf ("Error in SgTemplateClassDefinition::error() \n");
125779 : ROSE_ABORT();
125780 : }
125781 :
125782 : ROSE_ASSERT (getVariant() == TEMPLATE_CLASS_DEF_STMT);
125783 : return SgClassDefinition::error();
125784 : }
125785 : #endif
125786 :
125787 :
125788 :
125789 : // End of memberFunctionString
125790 :
125791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
125792 :
125793 5480230 : SgTemplateClassDefinition* isSgTemplateClassDefinition ( SgNode* inputDerivedClassPointer )
125794 : {
125795 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
125796 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
125797 : // So to fix this we return NULL directly when the input is NULL and avoid the
125798 : // dynamic_cast in this case. This is likely a performance improvement as well.
125799 : // return dynamic_cast<SgTemplateClassDefinition*>(inputDerivedClassPointer);
125800 : // Milind Chabbi (8/28/2013): isSgTemplateClassDefinition uses table-driven castability instead of c++ default dynamic_cast
125801 : // this improves the running time performance by 10-20%.
125802 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateClassDefinition*>(inputDerivedClassPointer);
125803 5480230 : return IS_SgTemplateClassDefinition_FAST_MACRO(inputDerivedClassPointer);
125804 : }
125805 :
125806 : // DQ (11/8/2003): Added version of functions taking const pointer
125807 20716 : const SgTemplateClassDefinition* isSgTemplateClassDefinition ( const SgNode* inputDerivedClassPointer )
125808 : {
125809 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
125810 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
125811 : // So to fix this we return NULL directly when the input is NULL and avoid the
125812 : // dynamic_cast in this case. This is likely a performance improvement as well.
125813 : // return dynamic_cast<const SgTemplateClassDefinition*>(inputDerivedClassPointer);
125814 : // Milind Chabbi (8/28/2013): isSgTemplateClassDefinition uses table-driven castability instead of c++ default dynamic_cast
125815 : // this improves the running time performance by 10-20%.
125816 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateClassDefinition*>(inputDerivedClassPointer);
125817 20716 : return IS_SgTemplateClassDefinition_FAST_MACRO(inputDerivedClassPointer);
125818 : }
125819 :
125820 :
125821 :
125822 : /* #line 125823 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125823 :
125824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
125825 :
125826 : /**
125827 : \brief Generated destructor
125828 :
125829 : This destructor is automatically generated (by ROSETTA). This destructor
125830 : only frees memory of data members associated with the parts of the current IR node which
125831 : are NOT traversed. Those data members that are part of a traversal can be freed using
125832 : a traversal (calling this destructor on all children in a post-order traversal). Such
125833 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
125834 :
125835 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
125836 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
125837 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
125838 :
125839 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
125840 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
125841 : pointers are not yet implemented to call delete on eash pointer in the container.
125842 : (This could be done by derivation from the STL containers to define containers that
125843 : automatically deleted their members.)
125844 :
125845 : */
125846 2024 : SgTemplateClassDefinition::~SgTemplateClassDefinition () {
125847 1012 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
125848 :
125849 :
125850 :
125851 : }
125852 :
125853 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
125854 2024 : }
125855 :
125856 :
125857 : /* #line 125858 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125858 :
125859 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
125860 :
125861 : // Generated constructor
125862 0 : SgTemplateClassDefinition::SgTemplateClassDefinition ( Sg_File_Info* startOfConstruct )
125863 0 : : SgClassDefinition(startOfConstruct)
125864 : {
125865 : #ifdef DEBUG
125866 : // printf ("In SgTemplateClassDefinition::SgTemplateClassDefinition (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
125867 : #endif
125868 : #if 0
125869 : // debugging information!
125870 : printf ("In SgTemplateClassDefinition::SgTemplateClassDefinition (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
125871 : #endif
125872 :
125873 :
125874 :
125875 : #if 0
125876 : // DQ (7/30/2014): Call a virtual function.
125877 : std::string s = this->class_name();
125878 : #endif
125879 :
125880 : // Test the variant virtual function
125881 : // assert(TEMPLATE_CLASS_DEF_STMT == variant());
125882 0 : assert(TEMPLATE_CLASS_DEF_STMT == this->variant());
125883 0 : ROSE_ASSERT(TEMPLATE_CLASS_DEF_STMT == (int)(this->variantT()));
125884 0 : post_construction_initialization();
125885 :
125886 : // Test the isSgTemplateClassDefinition() function since it has been problematic
125887 0 : assert(isSgTemplateClassDefinition(this) != NULL);
125888 0 : }
125889 :
125890 : // Generated constructor (all data members)
125891 :
125892 : /* #line 125893 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125893 :
125894 :
125895 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
125896 :
125897 :
125898 : // ********************************************************
125899 : // member functions common across all array grammar objects
125900 : // ********************************************************
125901 :
125902 :
125903 :
125904 : /* #line 125905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125905 :
125906 :
125907 :
125908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
125909 :
125910 : // ********************************************************
125911 : // member functions specific to each node in the grammar
125912 : // ********************************************************
125913 :
125914 :
125915 : /* #line 125916 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
125916 :
125917 : // Start of memberFunctionString
125918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
125919 :
125920 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
125921 :
125922 : SgStatement*
125923 430 : SgWhileStmt::get_condition () const
125924 : {
125925 430 : ROSE_ASSERT (this != NULL);
125926 :
125927 : #if 0
125928 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
125929 : // used to trigger marking transformations for the token-based unparsing.
125930 : printf ("SgWhileStmt::get_condition = %p = %s \n",this,this->class_name().c_str());
125931 : #endif
125932 :
125933 430 : return p_condition;
125934 : }
125935 :
125936 : void
125937 414 : SgWhileStmt::set_condition ( SgStatement* condition )
125938 : {
125939 414 : ROSE_ASSERT (this != NULL);
125940 :
125941 : #if 0
125942 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
125943 : // used to trigger marking transformations for the token-based unparsing.
125944 : printf ("SgWhileStmt::set_condition = %p = %s \n",this,this->class_name().c_str());
125945 : #endif
125946 :
125947 414 : set_isModified(true);
125948 :
125949 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
125950 : if (p_condition != NULL && condition != NULL && p_condition != condition)
125951 : {
125952 : printf ("Warning: condition = %p overwriting valid pointer p_condition = %p \n",condition,p_condition);
125953 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
125954 : printf ("Error fails assertion (p_condition != NULL && condition != NULL && p_condition != condition) is false\n");
125955 : ROSE_ASSERT(false);
125956 : #endif
125957 : }
125958 : #endif
125959 414 : p_condition = condition;
125960 414 : }
125961 :
125962 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
125963 :
125964 :
125965 : // End of memberFunctionString
125966 : // Start of memberFunctionString
125967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
125968 :
125969 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
125970 :
125971 : SgStatement*
125972 1315 : SgWhileStmt::get_body () const
125973 : {
125974 1315 : ROSE_ASSERT (this != NULL);
125975 :
125976 : #if 0
125977 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
125978 : // used to trigger marking transformations for the token-based unparsing.
125979 : printf ("SgWhileStmt::get_body = %p = %s \n",this,this->class_name().c_str());
125980 : #endif
125981 :
125982 1315 : return p_body;
125983 : }
125984 :
125985 : void
125986 414 : SgWhileStmt::set_body ( SgStatement* body )
125987 : {
125988 414 : ROSE_ASSERT (this != NULL);
125989 :
125990 : #if 0
125991 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
125992 : // used to trigger marking transformations for the token-based unparsing.
125993 : printf ("SgWhileStmt::set_body = %p = %s \n",this,this->class_name().c_str());
125994 : #endif
125995 :
125996 414 : set_isModified(true);
125997 :
125998 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
125999 : if (p_body != NULL && body != NULL && p_body != body)
126000 : {
126001 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
126002 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126003 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
126004 : ROSE_ASSERT(false);
126005 : #endif
126006 : }
126007 : #endif
126008 414 : p_body = body;
126009 414 : }
126010 :
126011 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126012 :
126013 :
126014 : // End of memberFunctionString
126015 : // Start of memberFunctionString
126016 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126017 :
126018 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126019 :
126020 : SgStatement*
126021 414 : SgWhileStmt::get_else_body () const
126022 : {
126023 414 : ROSE_ASSERT (this != NULL);
126024 :
126025 : #if 0
126026 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126027 : // used to trigger marking transformations for the token-based unparsing.
126028 : printf ("SgWhileStmt::get_else_body = %p = %s \n",this,this->class_name().c_str());
126029 : #endif
126030 :
126031 414 : return p_else_body;
126032 : }
126033 :
126034 : void
126035 414 : SgWhileStmt::set_else_body ( SgStatement* else_body )
126036 : {
126037 414 : ROSE_ASSERT (this != NULL);
126038 :
126039 : #if 0
126040 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126041 : // used to trigger marking transformations for the token-based unparsing.
126042 : printf ("SgWhileStmt::set_else_body = %p = %s \n",this,this->class_name().c_str());
126043 : #endif
126044 :
126045 414 : set_isModified(true);
126046 :
126047 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
126048 : if (p_else_body != NULL && else_body != NULL && p_else_body != else_body)
126049 : {
126050 : printf ("Warning: else_body = %p overwriting valid pointer p_else_body = %p \n",else_body,p_else_body);
126051 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126052 : printf ("Error fails assertion (p_else_body != NULL && else_body != NULL && p_else_body != else_body) is false\n");
126053 : ROSE_ASSERT(false);
126054 : #endif
126055 : }
126056 : #endif
126057 414 : p_else_body = else_body;
126058 414 : }
126059 :
126060 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126061 :
126062 :
126063 : // End of memberFunctionString
126064 : // Start of memberFunctionString
126065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126066 :
126067 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126068 :
126069 : SgLabelRefExp*
126070 0 : SgWhileStmt::get_end_numeric_label () const
126071 : {
126072 0 : ROSE_ASSERT (this != NULL);
126073 :
126074 : #if 0
126075 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126076 : // used to trigger marking transformations for the token-based unparsing.
126077 : printf ("SgWhileStmt::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
126078 : #endif
126079 :
126080 0 : return p_end_numeric_label;
126081 : }
126082 :
126083 : void
126084 0 : SgWhileStmt::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
126085 : {
126086 0 : ROSE_ASSERT (this != NULL);
126087 :
126088 : #if 0
126089 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126090 : // used to trigger marking transformations for the token-based unparsing.
126091 : printf ("SgWhileStmt::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
126092 : #endif
126093 :
126094 0 : set_isModified(true);
126095 :
126096 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
126097 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
126098 : {
126099 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
126100 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126101 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
126102 : ROSE_ASSERT(false);
126103 : #endif
126104 : }
126105 : #endif
126106 0 : p_end_numeric_label = end_numeric_label;
126107 0 : }
126108 :
126109 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126110 :
126111 :
126112 : // End of memberFunctionString
126113 : // Start of memberFunctionString
126114 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126115 :
126116 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126117 :
126118 : std::string
126119 0 : SgWhileStmt::get_string_label () const
126120 : {
126121 0 : ROSE_ASSERT (this != NULL);
126122 :
126123 : #if 0
126124 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126125 : // used to trigger marking transformations for the token-based unparsing.
126126 : printf ("SgWhileStmt::get_string_label = %p = %s \n",this,this->class_name().c_str());
126127 : #endif
126128 :
126129 0 : return p_string_label;
126130 : }
126131 :
126132 : void
126133 0 : SgWhileStmt::set_string_label ( std::string string_label )
126134 : {
126135 0 : ROSE_ASSERT (this != NULL);
126136 :
126137 : #if 0
126138 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126139 : // used to trigger marking transformations for the token-based unparsing.
126140 : printf ("SgWhileStmt::set_string_label = %p = %s \n",this,this->class_name().c_str());
126141 : #endif
126142 :
126143 0 : set_isModified(true);
126144 :
126145 0 : p_string_label = string_label;
126146 0 : }
126147 :
126148 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126149 :
126150 :
126151 : // End of memberFunctionString
126152 : // Start of memberFunctionString
126153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126154 :
126155 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126156 :
126157 : bool
126158 0 : SgWhileStmt::get_has_end_statement () const
126159 : {
126160 0 : ROSE_ASSERT (this != NULL);
126161 :
126162 : #if 0
126163 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126164 : // used to trigger marking transformations for the token-based unparsing.
126165 : printf ("SgWhileStmt::get_has_end_statement = %p = %s \n",this,this->class_name().c_str());
126166 : #endif
126167 :
126168 0 : return p_has_end_statement;
126169 : }
126170 :
126171 : void
126172 0 : SgWhileStmt::set_has_end_statement ( bool has_end_statement )
126173 : {
126174 0 : ROSE_ASSERT (this != NULL);
126175 :
126176 : #if 0
126177 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126178 : // used to trigger marking transformations for the token-based unparsing.
126179 : printf ("SgWhileStmt::set_has_end_statement = %p = %s \n",this,this->class_name().c_str());
126180 : #endif
126181 :
126182 0 : set_isModified(true);
126183 :
126184 0 : p_has_end_statement = has_end_statement;
126185 0 : }
126186 :
126187 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126188 :
126189 :
126190 : // End of memberFunctionString
126191 : // Start of memberFunctionString
126192 : /* #line 15365 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
126193 :
126194 : void
126195 415 : SgWhileStmt::post_construction_initialization()
126196 : {
126197 : #ifndef REMOVE_SET_PARENT_FUNCTION
126198 : if(get_condition()) get_condition()->set_parent(this);
126199 : if(get_body()) get_body()->set_parent(this);
126200 : #endif
126201 415 : }
126202 :
126203 : bool
126204 0 : SgWhileStmt::replace_child(SgStatement *target,SgStatement *newstmt,
126205 : bool extractBasicBlock)
126206 : {
126207 0 : if ( StatementReplace(this, p_condition, target, newstmt) == true )
126208 0 : return true;
126209 0 : else return ( StatementReplace(this, p_body, target, newstmt) == true );
126210 : }
126211 :
126212 : #if 0
126213 : SgStatement*
126214 : SgWhileStmt::get_next(int& n) const
126215 : {
126216 : if(n==0)
126217 : {
126218 : n++;
126219 : return get_condition();
126220 : }
126221 : else
126222 : if(n==1)
126223 : {
126224 : n++;
126225 : return get_body();
126226 : }
126227 : return 0;
126228 : }
126229 : #endif
126230 :
126231 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
126232 : SgName
126233 0 : SgWhileStmt::get_mangled_name(void) const
126234 : {
126235 0 : return SgName ("");
126236 : }
126237 :
126238 :
126239 :
126240 : // End of memberFunctionString
126241 : // Start of memberFunctionString
126242 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
126243 :
126244 : // *** COMMON CODE SECTION BEGINS HERE ***
126245 :
126246 : #if 0
126247 : int
126248 : SgWhileStmt::getVariant() const
126249 : {
126250 : // This function is used in ROSE while "variant()" is used in SAGE
126251 : assert(this != NULL);
126252 : return variant();
126253 : }
126254 : #endif
126255 :
126256 : // This function is used in ROSE in treeTraversal code
126257 : // eventually replaces getVariant() and variant()
126258 : // though after variant() has been removed for a while we will
126259 : // want to change the name of variantT() back to variant()
126260 : // (since the "T" was ment to stand for temporary).
126261 : // When this happens the variantT() will be depricated.
126262 : VariantT
126263 191986 : SgWhileStmt::variantT() const
126264 : {
126265 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
126266 191986 : ROSE_ASSERT(this != NULL);
126267 191986 : return V_SgWhileStmt;
126268 : }
126269 :
126270 : #if 0
126271 : int
126272 : SgWhileStmt::variant() const
126273 : {
126274 : // This function is used in SAGE
126275 : ROSE_ASSERT(this != NULL);
126276 : return WHILE_STMT;
126277 : }
126278 : #endif
126279 :
126280 : ROSE_DLL_API const char*
126281 196 : SgWhileStmt::sage_class_name() const
126282 : {
126283 196 : ROSE_ASSERT(this != NULL);
126284 196 : return "SgWhileStmt";
126285 : }
126286 :
126287 : std::string
126288 848 : SgWhileStmt::class_name() const
126289 : {
126290 848 : ROSE_ASSERT(this != NULL);
126291 848 : return "SgWhileStmt";
126292 : }
126293 :
126294 : // DQ (11/26/2005): Support for visitor pattern mechanims
126295 : // (inferior to ROSE traversal mechanism, experimental).
126296 : void
126297 6457 : SgWhileStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
126298 : {
126299 6457 : ROSE_ASSERT(this != NULL);
126300 6457 : visitor.visit(this);
126301 6457 : }
126302 :
126303 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
126304 0 : void SgWhileStmt::accept (ROSE_VisitorPattern & visitor) {
126305 0 : ROSE_ASSERT(this != NULL);
126306 0 : visitor.visit(this);
126307 0 : }
126308 :
126309 : SgWhileStmt*
126310 0 : SgWhileStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
126311 : {
126312 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
126313 : // This function is currently only supported for the AST used the represent Binary executables.
126314 : if (0 /* isSgAsmNode(this) != NULL */)
126315 : {
126316 : // Support for regex specification.
126317 : std::string prefixCode = "REGEX:";
126318 : addNewAttribute(prefixCode + s,a);
126319 : }
126320 : #endif
126321 :
126322 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
126323 0 : return this;
126324 : }
126325 :
126326 : // *** COMMON CODE SECTION ENDS HERE ***
126327 :
126328 :
126329 : // End of memberFunctionString
126330 : // Start of memberFunctionString
126331 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
126332 :
126333 :
126334 : #if 0
126335 : //! Error checking support
126336 : /*! Verifies the following:
126337 : - working getVariant() member function
126338 : - calls base class's error() member function
126339 : Every class has one of these functions.
126340 : */
126341 : bool
126342 : SgWhileStmt::error()
126343 : {
126344 : // Put error checking here
126345 :
126346 : ROSE_ASSERT (this != NULL);
126347 : if (getVariant() != WHILE_STMT)
126348 : {
126349 : printf ("Error in SgWhileStmt::error(): SgWhileStmt object has a %s variant \n",
126350 : Cxx_GrammarTerminalNames[getVariant()].name);
126351 : // printf ("Error in SgWhileStmt::error() \n");
126352 : ROSE_ABORT();
126353 : }
126354 :
126355 : ROSE_ASSERT (getVariant() == WHILE_STMT);
126356 : return SgScopeStatement::error();
126357 : }
126358 : #endif
126359 :
126360 :
126361 :
126362 : // End of memberFunctionString
126363 :
126364 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
126365 :
126366 1809 : SgWhileStmt* isSgWhileStmt ( SgNode* inputDerivedClassPointer )
126367 : {
126368 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
126369 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
126370 : // So to fix this we return NULL directly when the input is NULL and avoid the
126371 : // dynamic_cast in this case. This is likely a performance improvement as well.
126372 : // return dynamic_cast<SgWhileStmt*>(inputDerivedClassPointer);
126373 : // Milind Chabbi (8/28/2013): isSgWhileStmt uses table-driven castability instead of c++ default dynamic_cast
126374 : // this improves the running time performance by 10-20%.
126375 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWhileStmt*>(inputDerivedClassPointer);
126376 1809 : return IS_SgWhileStmt_FAST_MACRO(inputDerivedClassPointer);
126377 : }
126378 :
126379 : // DQ (11/8/2003): Added version of functions taking const pointer
126380 309 : const SgWhileStmt* isSgWhileStmt ( const SgNode* inputDerivedClassPointer )
126381 : {
126382 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
126383 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
126384 : // So to fix this we return NULL directly when the input is NULL and avoid the
126385 : // dynamic_cast in this case. This is likely a performance improvement as well.
126386 : // return dynamic_cast<const SgWhileStmt*>(inputDerivedClassPointer);
126387 : // Milind Chabbi (8/28/2013): isSgWhileStmt uses table-driven castability instead of c++ default dynamic_cast
126388 : // this improves the running time performance by 10-20%.
126389 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWhileStmt*>(inputDerivedClassPointer);
126390 309 : return IS_SgWhileStmt_FAST_MACRO(inputDerivedClassPointer);
126391 : }
126392 :
126393 :
126394 :
126395 : /* #line 126396 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126396 :
126397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
126398 :
126399 : /**
126400 : \brief Generated destructor
126401 :
126402 : This destructor is automatically generated (by ROSETTA). This destructor
126403 : only frees memory of data members associated with the parts of the current IR node which
126404 : are NOT traversed. Those data members that are part of a traversal can be freed using
126405 : a traversal (calling this destructor on all children in a post-order traversal). Such
126406 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
126407 :
126408 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
126409 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
126410 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
126411 :
126412 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
126413 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
126414 : pointers are not yet implemented to call delete on eash pointer in the container.
126415 : (This could be done by derivation from the STL containers to define containers that
126416 : automatically deleted their members.)
126417 :
126418 : */
126419 188 : SgWhileStmt::~SgWhileStmt () {
126420 94 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
126421 :
126422 :
126423 : // case: not a listType for condition
126424 94 : p_condition = NULL; // non list case
126425 : // case: not a listType for body
126426 94 : p_body = NULL; // non list case
126427 : // case: not a listType for else_body
126428 94 : p_else_body = NULL; // non list case
126429 : // case: not a listType for end_numeric_label
126430 94 : p_end_numeric_label = NULL; // non list case
126431 : // case: not a listType for string_label
126432 94 : p_string_label = ""; // non list case
126433 : // case: not a listType for has_end_statement
126434 94 : p_has_end_statement = false; // non list case
126435 :
126436 : }
126437 :
126438 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
126439 188 : }
126440 :
126441 :
126442 : /* #line 126443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126443 :
126444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
126445 :
126446 : // Generated constructor
126447 0 : SgWhileStmt::SgWhileStmt ( Sg_File_Info* startOfConstruct, SgStatement* condition, SgStatement* body )
126448 0 : : SgScopeStatement(startOfConstruct)
126449 : {
126450 : #ifdef DEBUG
126451 : // printf ("In SgWhileStmt::SgWhileStmt (Sg_File_Info* startOfConstruct, SgStatement* condition, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
126452 : #endif
126453 : #if 0
126454 : // debugging information!
126455 : printf ("In SgWhileStmt::SgWhileStmt (Sg_File_Info* startOfConstruct, SgStatement* condition, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
126456 : #endif
126457 :
126458 0 : p_condition = condition;
126459 0 : p_body = body;
126460 0 : p_else_body = NULL;
126461 0 : p_end_numeric_label = NULL;
126462 0 : p_string_label = "";
126463 0 : p_has_end_statement = false;
126464 :
126465 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
126466 :
126467 : #if 0
126468 : // DQ (7/30/2014): Call a virtual function.
126469 : std::string s = this->class_name();
126470 : #endif
126471 :
126472 : // Test the variant virtual function
126473 : // assert(WHILE_STMT == variant());
126474 0 : assert(WHILE_STMT == this->variant());
126475 0 : ROSE_ASSERT(WHILE_STMT == (int)(this->variantT()));
126476 0 : post_construction_initialization();
126477 :
126478 : // Test the isSgWhileStmt() function since it has been problematic
126479 0 : assert(isSgWhileStmt(this) != NULL);
126480 0 : }
126481 :
126482 : // Generated constructor (all data members)
126483 :
126484 : /* #line 126485 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126485 :
126486 :
126487 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
126488 :
126489 :
126490 : // ********************************************************
126491 : // member functions common across all array grammar objects
126492 : // ********************************************************
126493 :
126494 :
126495 :
126496 : /* #line 126497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126497 :
126498 :
126499 :
126500 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
126501 :
126502 : // ********************************************************
126503 : // member functions specific to each node in the grammar
126504 : // ********************************************************
126505 :
126506 :
126507 : /* #line 126508 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126508 :
126509 : // Start of memberFunctionString
126510 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126511 :
126512 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126513 :
126514 : SgStatement*
126515 305 : SgDoWhileStmt::get_body () const
126516 : {
126517 305 : ROSE_ASSERT (this != NULL);
126518 :
126519 : #if 0
126520 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126521 : // used to trigger marking transformations for the token-based unparsing.
126522 : printf ("SgDoWhileStmt::get_body = %p = %s \n",this,this->class_name().c_str());
126523 : #endif
126524 :
126525 305 : return p_body;
126526 : }
126527 :
126528 : void
126529 57 : SgDoWhileStmt::set_body ( SgStatement* body )
126530 : {
126531 57 : ROSE_ASSERT (this != NULL);
126532 :
126533 : #if 0
126534 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126535 : // used to trigger marking transformations for the token-based unparsing.
126536 : printf ("SgDoWhileStmt::set_body = %p = %s \n",this,this->class_name().c_str());
126537 : #endif
126538 :
126539 57 : set_isModified(true);
126540 :
126541 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
126542 : if (p_body != NULL && body != NULL && p_body != body)
126543 : {
126544 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
126545 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126546 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
126547 : ROSE_ASSERT(false);
126548 : #endif
126549 : }
126550 : #endif
126551 57 : p_body = body;
126552 57 : }
126553 :
126554 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126555 :
126556 :
126557 : // End of memberFunctionString
126558 : // Start of memberFunctionString
126559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126560 :
126561 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126562 :
126563 : SgStatement*
126564 173 : SgDoWhileStmt::get_condition () const
126565 : {
126566 173 : ROSE_ASSERT (this != NULL);
126567 :
126568 : #if 0
126569 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126570 : // used to trigger marking transformations for the token-based unparsing.
126571 : printf ("SgDoWhileStmt::get_condition = %p = %s \n",this,this->class_name().c_str());
126572 : #endif
126573 :
126574 173 : return p_condition;
126575 : }
126576 :
126577 : void
126578 57 : SgDoWhileStmt::set_condition ( SgStatement* condition )
126579 : {
126580 57 : ROSE_ASSERT (this != NULL);
126581 :
126582 : #if 0
126583 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126584 : // used to trigger marking transformations for the token-based unparsing.
126585 : printf ("SgDoWhileStmt::set_condition = %p = %s \n",this,this->class_name().c_str());
126586 : #endif
126587 :
126588 57 : set_isModified(true);
126589 :
126590 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
126591 : if (p_condition != NULL && condition != NULL && p_condition != condition)
126592 : {
126593 : printf ("Warning: condition = %p overwriting valid pointer p_condition = %p \n",condition,p_condition);
126594 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126595 : printf ("Error fails assertion (p_condition != NULL && condition != NULL && p_condition != condition) is false\n");
126596 : ROSE_ASSERT(false);
126597 : #endif
126598 : }
126599 : #endif
126600 57 : p_condition = condition;
126601 57 : }
126602 :
126603 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126604 :
126605 :
126606 : // End of memberFunctionString
126607 : // Start of memberFunctionString
126608 : /* #line 15415 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
126609 :
126610 : void
126611 58 : SgDoWhileStmt::post_construction_initialization()
126612 : {
126613 : #ifndef REMOVE_SET_PARENT_FUNCTION
126614 : if(get_condition()) get_condition()->set_parent(this);
126615 : if(get_body()) get_body()->set_parent(this);
126616 : #endif
126617 58 : }
126618 :
126619 : bool
126620 0 : SgDoWhileStmt::replace_child(SgStatement *target,SgStatement *newstmt,
126621 : bool extractBasicBlock)
126622 : {
126623 0 : if ( StatementReplace(this, p_condition, target, newstmt) == true )
126624 0 : return true;
126625 0 : else return ( StatementReplace(this, p_body, target, newstmt) == true );
126626 : }
126627 :
126628 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
126629 : SgName
126630 0 : SgDoWhileStmt::get_mangled_name(void) const
126631 : {
126632 0 : return SgName ("");
126633 : }
126634 :
126635 :
126636 :
126637 : // End of memberFunctionString
126638 : // Start of memberFunctionString
126639 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
126640 :
126641 : // *** COMMON CODE SECTION BEGINS HERE ***
126642 :
126643 : #if 0
126644 : int
126645 : SgDoWhileStmt::getVariant() const
126646 : {
126647 : // This function is used in ROSE while "variant()" is used in SAGE
126648 : assert(this != NULL);
126649 : return variant();
126650 : }
126651 : #endif
126652 :
126653 : // This function is used in ROSE in treeTraversal code
126654 : // eventually replaces getVariant() and variant()
126655 : // though after variant() has been removed for a while we will
126656 : // want to change the name of variantT() back to variant()
126657 : // (since the "T" was ment to stand for temporary).
126658 : // When this happens the variantT() will be depricated.
126659 : VariantT
126660 13533 : SgDoWhileStmt::variantT() const
126661 : {
126662 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
126663 13533 : ROSE_ASSERT(this != NULL);
126664 13533 : return V_SgDoWhileStmt;
126665 : }
126666 :
126667 : #if 0
126668 : int
126669 : SgDoWhileStmt::variant() const
126670 : {
126671 : // This function is used in SAGE
126672 : ROSE_ASSERT(this != NULL);
126673 : return DO_WHILE_STMT;
126674 : }
126675 : #endif
126676 :
126677 : ROSE_DLL_API const char*
126678 2 : SgDoWhileStmt::sage_class_name() const
126679 : {
126680 2 : ROSE_ASSERT(this != NULL);
126681 2 : return "SgDoWhileStmt";
126682 : }
126683 :
126684 : std::string
126685 100 : SgDoWhileStmt::class_name() const
126686 : {
126687 100 : ROSE_ASSERT(this != NULL);
126688 100 : return "SgDoWhileStmt";
126689 : }
126690 :
126691 : // DQ (11/26/2005): Support for visitor pattern mechanims
126692 : // (inferior to ROSE traversal mechanism, experimental).
126693 : void
126694 977 : SgDoWhileStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
126695 : {
126696 977 : ROSE_ASSERT(this != NULL);
126697 977 : visitor.visit(this);
126698 977 : }
126699 :
126700 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
126701 0 : void SgDoWhileStmt::accept (ROSE_VisitorPattern & visitor) {
126702 0 : ROSE_ASSERT(this != NULL);
126703 0 : visitor.visit(this);
126704 0 : }
126705 :
126706 : SgDoWhileStmt*
126707 0 : SgDoWhileStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
126708 : {
126709 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
126710 : // This function is currently only supported for the AST used the represent Binary executables.
126711 : if (0 /* isSgAsmNode(this) != NULL */)
126712 : {
126713 : // Support for regex specification.
126714 : std::string prefixCode = "REGEX:";
126715 : addNewAttribute(prefixCode + s,a);
126716 : }
126717 : #endif
126718 :
126719 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
126720 0 : return this;
126721 : }
126722 :
126723 : // *** COMMON CODE SECTION ENDS HERE ***
126724 :
126725 :
126726 : // End of memberFunctionString
126727 : // Start of memberFunctionString
126728 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
126729 :
126730 :
126731 : #if 0
126732 : //! Error checking support
126733 : /*! Verifies the following:
126734 : - working getVariant() member function
126735 : - calls base class's error() member function
126736 : Every class has one of these functions.
126737 : */
126738 : bool
126739 : SgDoWhileStmt::error()
126740 : {
126741 : // Put error checking here
126742 :
126743 : ROSE_ASSERT (this != NULL);
126744 : if (getVariant() != DO_WHILE_STMT)
126745 : {
126746 : printf ("Error in SgDoWhileStmt::error(): SgDoWhileStmt object has a %s variant \n",
126747 : Cxx_GrammarTerminalNames[getVariant()].name);
126748 : // printf ("Error in SgDoWhileStmt::error() \n");
126749 : ROSE_ABORT();
126750 : }
126751 :
126752 : ROSE_ASSERT (getVariant() == DO_WHILE_STMT);
126753 : return SgScopeStatement::error();
126754 : }
126755 : #endif
126756 :
126757 :
126758 :
126759 : // End of memberFunctionString
126760 :
126761 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
126762 :
126763 1414 : SgDoWhileStmt* isSgDoWhileStmt ( SgNode* inputDerivedClassPointer )
126764 : {
126765 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
126766 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
126767 : // So to fix this we return NULL directly when the input is NULL and avoid the
126768 : // dynamic_cast in this case. This is likely a performance improvement as well.
126769 : // return dynamic_cast<SgDoWhileStmt*>(inputDerivedClassPointer);
126770 : // Milind Chabbi (8/28/2013): isSgDoWhileStmt uses table-driven castability instead of c++ default dynamic_cast
126771 : // this improves the running time performance by 10-20%.
126772 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDoWhileStmt*>(inputDerivedClassPointer);
126773 1414 : return IS_SgDoWhileStmt_FAST_MACRO(inputDerivedClassPointer);
126774 : }
126775 :
126776 : // DQ (11/8/2003): Added version of functions taking const pointer
126777 43 : const SgDoWhileStmt* isSgDoWhileStmt ( const SgNode* inputDerivedClassPointer )
126778 : {
126779 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
126780 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
126781 : // So to fix this we return NULL directly when the input is NULL and avoid the
126782 : // dynamic_cast in this case. This is likely a performance improvement as well.
126783 : // return dynamic_cast<const SgDoWhileStmt*>(inputDerivedClassPointer);
126784 : // Milind Chabbi (8/28/2013): isSgDoWhileStmt uses table-driven castability instead of c++ default dynamic_cast
126785 : // this improves the running time performance by 10-20%.
126786 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDoWhileStmt*>(inputDerivedClassPointer);
126787 43 : return IS_SgDoWhileStmt_FAST_MACRO(inputDerivedClassPointer);
126788 : }
126789 :
126790 :
126791 :
126792 : /* #line 126793 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126793 :
126794 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
126795 :
126796 : /**
126797 : \brief Generated destructor
126798 :
126799 : This destructor is automatically generated (by ROSETTA). This destructor
126800 : only frees memory of data members associated with the parts of the current IR node which
126801 : are NOT traversed. Those data members that are part of a traversal can be freed using
126802 : a traversal (calling this destructor on all children in a post-order traversal). Such
126803 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
126804 :
126805 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
126806 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
126807 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
126808 :
126809 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
126810 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
126811 : pointers are not yet implemented to call delete on eash pointer in the container.
126812 : (This could be done by derivation from the STL containers to define containers that
126813 : automatically deleted their members.)
126814 :
126815 : */
126816 28 : SgDoWhileStmt::~SgDoWhileStmt () {
126817 14 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
126818 :
126819 :
126820 : // case: not a listType for body
126821 14 : p_body = NULL; // non list case
126822 : // case: not a listType for condition
126823 14 : p_condition = NULL; // non list case
126824 :
126825 : }
126826 :
126827 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
126828 28 : }
126829 :
126830 :
126831 : /* #line 126832 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126832 :
126833 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
126834 :
126835 : // Generated constructor
126836 0 : SgDoWhileStmt::SgDoWhileStmt ( Sg_File_Info* startOfConstruct, SgStatement* body, SgStatement* condition )
126837 0 : : SgScopeStatement(startOfConstruct)
126838 : {
126839 : #ifdef DEBUG
126840 : // printf ("In SgDoWhileStmt::SgDoWhileStmt (Sg_File_Info* startOfConstruct, SgStatement* body, SgStatement* condition) sage_class_name() = %s \n",sage_class_name());
126841 : #endif
126842 : #if 0
126843 : // debugging information!
126844 : printf ("In SgDoWhileStmt::SgDoWhileStmt (Sg_File_Info* startOfConstruct, SgStatement* body, SgStatement* condition): this = %p = %s \n",this,this->class_name().c_str());
126845 : #endif
126846 :
126847 0 : p_body = body;
126848 0 : p_condition = condition;
126849 :
126850 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
126851 :
126852 : #if 0
126853 : // DQ (7/30/2014): Call a virtual function.
126854 : std::string s = this->class_name();
126855 : #endif
126856 :
126857 : // Test the variant virtual function
126858 : // assert(DO_WHILE_STMT == variant());
126859 0 : assert(DO_WHILE_STMT == this->variant());
126860 0 : ROSE_ASSERT(DO_WHILE_STMT == (int)(this->variantT()));
126861 0 : post_construction_initialization();
126862 :
126863 : // Test the isSgDoWhileStmt() function since it has been problematic
126864 0 : assert(isSgDoWhileStmt(this) != NULL);
126865 0 : }
126866 :
126867 : // Generated constructor (all data members)
126868 :
126869 : /* #line 126870 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126870 :
126871 :
126872 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
126873 :
126874 :
126875 : // ********************************************************
126876 : // member functions common across all array grammar objects
126877 : // ********************************************************
126878 :
126879 :
126880 :
126881 : /* #line 126882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126882 :
126883 :
126884 :
126885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
126886 :
126887 : // ********************************************************
126888 : // member functions specific to each node in the grammar
126889 : // ********************************************************
126890 :
126891 :
126892 : /* #line 126893 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
126893 :
126894 : // Start of memberFunctionString
126895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126896 :
126897 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126898 :
126899 : SgStatement*
126900 3 : SgSwitchStatement::get_item_selector () const
126901 : {
126902 3 : ROSE_ASSERT (this != NULL);
126903 :
126904 : #if 0
126905 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126906 : // used to trigger marking transformations for the token-based unparsing.
126907 : printf ("SgSwitchStatement::get_item_selector = %p = %s \n",this,this->class_name().c_str());
126908 : #endif
126909 :
126910 3 : return p_item_selector;
126911 : }
126912 :
126913 : void
126914 1 : SgSwitchStatement::set_item_selector ( SgStatement* item_selector )
126915 : {
126916 1 : ROSE_ASSERT (this != NULL);
126917 :
126918 : #if 0
126919 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126920 : // used to trigger marking transformations for the token-based unparsing.
126921 : printf ("SgSwitchStatement::set_item_selector = %p = %s \n",this,this->class_name().c_str());
126922 : #endif
126923 :
126924 1 : set_isModified(true);
126925 :
126926 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
126927 : if (p_item_selector != NULL && item_selector != NULL && p_item_selector != item_selector)
126928 : {
126929 : printf ("Warning: item_selector = %p overwriting valid pointer p_item_selector = %p \n",item_selector,p_item_selector);
126930 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126931 : printf ("Error fails assertion (p_item_selector != NULL && item_selector != NULL && p_item_selector != item_selector) is false\n");
126932 : ROSE_ASSERT(false);
126933 : #endif
126934 : }
126935 : #endif
126936 1 : p_item_selector = item_selector;
126937 1 : }
126938 :
126939 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126940 :
126941 :
126942 : // End of memberFunctionString
126943 : // Start of memberFunctionString
126944 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126945 :
126946 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126947 :
126948 : SgStatement*
126949 3 : SgSwitchStatement::get_body () const
126950 : {
126951 3 : ROSE_ASSERT (this != NULL);
126952 :
126953 : #if 0
126954 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126955 : // used to trigger marking transformations for the token-based unparsing.
126956 : printf ("SgSwitchStatement::get_body = %p = %s \n",this,this->class_name().c_str());
126957 : #endif
126958 :
126959 3 : return p_body;
126960 : }
126961 :
126962 : void
126963 1 : SgSwitchStatement::set_body ( SgStatement* body )
126964 : {
126965 1 : ROSE_ASSERT (this != NULL);
126966 :
126967 : #if 0
126968 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
126969 : // used to trigger marking transformations for the token-based unparsing.
126970 : printf ("SgSwitchStatement::set_body = %p = %s \n",this,this->class_name().c_str());
126971 : #endif
126972 :
126973 1 : set_isModified(true);
126974 :
126975 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
126976 : if (p_body != NULL && body != NULL && p_body != body)
126977 : {
126978 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
126979 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
126980 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
126981 : ROSE_ASSERT(false);
126982 : #endif
126983 : }
126984 : #endif
126985 1 : p_body = body;
126986 1 : }
126987 :
126988 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
126989 :
126990 :
126991 : // End of memberFunctionString
126992 : // Start of memberFunctionString
126993 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
126994 :
126995 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
126996 :
126997 : SgLabelRefExp*
126998 0 : SgSwitchStatement::get_end_numeric_label () const
126999 : {
127000 0 : ROSE_ASSERT (this != NULL);
127001 :
127002 : #if 0
127003 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127004 : // used to trigger marking transformations for the token-based unparsing.
127005 : printf ("SgSwitchStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
127006 : #endif
127007 :
127008 0 : return p_end_numeric_label;
127009 : }
127010 :
127011 : void
127012 0 : SgSwitchStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
127013 : {
127014 0 : ROSE_ASSERT (this != NULL);
127015 :
127016 : #if 0
127017 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127018 : // used to trigger marking transformations for the token-based unparsing.
127019 : printf ("SgSwitchStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
127020 : #endif
127021 :
127022 0 : set_isModified(true);
127023 :
127024 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
127025 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
127026 : {
127027 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
127028 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
127029 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
127030 : ROSE_ASSERT(false);
127031 : #endif
127032 : }
127033 : #endif
127034 0 : p_end_numeric_label = end_numeric_label;
127035 0 : }
127036 :
127037 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
127038 :
127039 :
127040 : // End of memberFunctionString
127041 : // Start of memberFunctionString
127042 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
127043 :
127044 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
127045 :
127046 : std::string
127047 0 : SgSwitchStatement::get_string_label () const
127048 : {
127049 0 : ROSE_ASSERT (this != NULL);
127050 :
127051 : #if 0
127052 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127053 : // used to trigger marking transformations for the token-based unparsing.
127054 : printf ("SgSwitchStatement::get_string_label = %p = %s \n",this,this->class_name().c_str());
127055 : #endif
127056 :
127057 0 : return p_string_label;
127058 : }
127059 :
127060 : void
127061 0 : SgSwitchStatement::set_string_label ( std::string string_label )
127062 : {
127063 0 : ROSE_ASSERT (this != NULL);
127064 :
127065 : #if 0
127066 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127067 : // used to trigger marking transformations for the token-based unparsing.
127068 : printf ("SgSwitchStatement::set_string_label = %p = %s \n",this,this->class_name().c_str());
127069 : #endif
127070 :
127071 0 : set_isModified(true);
127072 :
127073 0 : p_string_label = string_label;
127074 0 : }
127075 :
127076 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
127077 :
127078 :
127079 : // End of memberFunctionString
127080 : // Start of memberFunctionString
127081 : /* #line 15444 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
127082 :
127083 : void
127084 1 : SgSwitchStatement::post_construction_initialization()
127085 : {
127086 : // if (get_item_selector_root() != 0)
127087 : // get_item_selector_root()->set_parent(this);
127088 1 : if (get_item_selector() != NULL)
127089 0 : get_item_selector()->set_parent(this);
127090 :
127091 : // DQ (11/2/2007): Reset the scope of any variables declared in the item_selector
127092 1 : SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(get_item_selector());
127093 1 : if (variableDeclaration != NULL)
127094 : {
127095 : // Check the scopes of the SgInitializedName objects
127096 0 : SgInitializedNamePtrList & variableList = variableDeclaration->get_variables();
127097 0 : SgInitializedNamePtrList::iterator i = variableList.begin();
127098 0 : while ( i != variableList.end() )
127099 : {
127100 0 : SgInitializedName* variable = *i;
127101 0 : ROSE_ASSERT(variable != NULL);
127102 :
127103 0 : if (variable->get_scope() != this)
127104 : {
127105 : // printf ("In SgSwitchStatement::post_construction_initialization() variable = %p not placed into SgSwitchStatement scope = %p (correcting by moving the symbol) \n",variable,this);
127106 :
127107 : // Remove the SgVariableSymbol from the switch body and put it into the SgSwitchStatement scope!
127108 0 : SgVariableSymbol* variableSymbol = isSgVariableSymbol(variable->get_symbol_from_symbol_table());
127109 :
127110 : // The AST copy mechanism can cause this to fail because the scope has not been reset at this point.
127111 : // ROSE_ASSERT(variableSymbol != NULL);
127112 :
127113 0 : if (variableSymbol != NULL)
127114 : {
127115 : // Reset the scope in the variable (only do this if variableSymbol != NULL so that it is not
127116 : // set prematurely in the AST copy mechanism (else the pointer to the SgVariableDefinition
127117 : // will not be copied properly).
127118 0 : variable->set_scope(this);
127119 :
127120 0 : this->insert_symbol(variable->get_name(),variableSymbol);
127121 : }
127122 : }
127123 :
127124 0 : i++;
127125 : }
127126 :
127127 : }
127128 1 : }
127129 :
127130 : bool
127131 0 : SgSwitchStatement::replace_child(SgStatement *target,SgStatement *newstmt,
127132 : bool extractBasicBlock)
127133 : {
127134 :
127135 0 : if ( StatementReplace(this, p_body, target, newstmt) )
127136 0 : return true;
127137 0 : if ( StatementReplace(this, p_item_selector, target, newstmt) )
127138 0 : return true;
127139 : return false;
127140 : }
127141 :
127142 : #include "sageBuilder.h"
127143 :
127144 : void
127145 0 : SgSwitchStatement::prepend_append_normalization() {
127146 0 : if(!get_body()) {
127147 0 : SgBasicBlock* newBlock = new SgBasicBlock ( this->get_file_info() );
127148 0 : assert(newBlock != NULL);
127149 0 : set_body(newBlock);
127150 : }
127151 0 : if (!isSgBasicBlock(get_body())) {
127152 0 : set_body(SageBuilder::buildBasicBlock(get_body()));
127153 0 : get_body()->set_parent(this);
127154 : }
127155 0 : }
127156 :
127157 : void
127158 0 : SgSwitchStatement::prepend_case(SgCaseOptionStmt *& what)
127159 : {
127160 0 : assert(this != NULL);
127161 0 : prepend_append_normalization();
127162 0 : ROSE_ASSERT (isSgBasicBlock(get_body()));
127163 0 : SageInterface::prependStatement(what, isSgBasicBlock(get_body()));
127164 :
127165 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
127166 0 : ROSE_ASSERT(what->get_parent() != NULL);
127167 0 : }
127168 :
127169 : void
127170 0 : SgSwitchStatement::append_case(SgCaseOptionStmt *& what)
127171 : {
127172 0 : assert(this != NULL);
127173 0 : prepend_append_normalization();
127174 0 : ROSE_ASSERT (isSgBasicBlock(get_body()));
127175 0 : SageInterface::appendStatement(what, isSgBasicBlock(get_body()));
127176 :
127177 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
127178 0 : ROSE_ASSERT(what->get_parent() != NULL);
127179 0 : }
127180 :
127181 : void
127182 0 : SgSwitchStatement::prepend_default(SgDefaultOptionStmt *& what)
127183 : {
127184 0 : assert(this != NULL);
127185 0 : prepend_append_normalization();
127186 0 : ROSE_ASSERT (isSgBasicBlock(get_body()));
127187 0 : SageInterface::prependStatement(what, isSgBasicBlock(get_body()));
127188 :
127189 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
127190 0 : ROSE_ASSERT(what->get_parent() != NULL);
127191 0 : }
127192 :
127193 : void
127194 0 : SgSwitchStatement::append_default(SgDefaultOptionStmt *& what)
127195 : {
127196 0 : assert(this != NULL);
127197 0 : prepend_append_normalization();
127198 0 : ROSE_ASSERT (isSgBasicBlock(get_body()));
127199 0 : SageInterface::appendStatement(what, isSgBasicBlock(get_body()));
127200 :
127201 : // DQ (6/24/2006): This should be set by the lower level insert_statement member function, verify this!
127202 0 : ROSE_ASSERT(what->get_parent() != NULL);
127203 0 : }
127204 :
127205 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
127206 : SgName
127207 0 : SgSwitchStatement::get_mangled_name(void) const
127208 : {
127209 0 : return SgName ("");
127210 : }
127211 :
127212 :
127213 :
127214 : // End of memberFunctionString
127215 : // Start of memberFunctionString
127216 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
127217 :
127218 : // *** COMMON CODE SECTION BEGINS HERE ***
127219 :
127220 : #if 0
127221 : int
127222 : SgSwitchStatement::getVariant() const
127223 : {
127224 : // This function is used in ROSE while "variant()" is used in SAGE
127225 : assert(this != NULL);
127226 : return variant();
127227 : }
127228 : #endif
127229 :
127230 : // This function is used in ROSE in treeTraversal code
127231 : // eventually replaces getVariant() and variant()
127232 : // though after variant() has been removed for a while we will
127233 : // want to change the name of variantT() back to variant()
127234 : // (since the "T" was ment to stand for temporary).
127235 : // When this happens the variantT() will be depricated.
127236 : VariantT
127237 300 : SgSwitchStatement::variantT() const
127238 : {
127239 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
127240 300 : ROSE_ASSERT(this != NULL);
127241 300 : return V_SgSwitchStatement;
127242 : }
127243 :
127244 : #if 0
127245 : int
127246 : SgSwitchStatement::variant() const
127247 : {
127248 : // This function is used in SAGE
127249 : ROSE_ASSERT(this != NULL);
127250 : return SWITCH_STMT;
127251 : }
127252 : #endif
127253 :
127254 : ROSE_DLL_API const char*
127255 3 : SgSwitchStatement::sage_class_name() const
127256 : {
127257 3 : ROSE_ASSERT(this != NULL);
127258 3 : return "SgSwitchStatement";
127259 : }
127260 :
127261 : std::string
127262 2 : SgSwitchStatement::class_name() const
127263 : {
127264 2 : ROSE_ASSERT(this != NULL);
127265 2 : return "SgSwitchStatement";
127266 : }
127267 :
127268 : // DQ (11/26/2005): Support for visitor pattern mechanims
127269 : // (inferior to ROSE traversal mechanism, experimental).
127270 : void
127271 18 : SgSwitchStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
127272 : {
127273 18 : ROSE_ASSERT(this != NULL);
127274 18 : visitor.visit(this);
127275 18 : }
127276 :
127277 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
127278 0 : void SgSwitchStatement::accept (ROSE_VisitorPattern & visitor) {
127279 0 : ROSE_ASSERT(this != NULL);
127280 0 : visitor.visit(this);
127281 0 : }
127282 :
127283 : SgSwitchStatement*
127284 0 : SgSwitchStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
127285 : {
127286 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
127287 : // This function is currently only supported for the AST used the represent Binary executables.
127288 : if (0 /* isSgAsmNode(this) != NULL */)
127289 : {
127290 : // Support for regex specification.
127291 : std::string prefixCode = "REGEX:";
127292 : addNewAttribute(prefixCode + s,a);
127293 : }
127294 : #endif
127295 :
127296 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
127297 0 : return this;
127298 : }
127299 :
127300 : // *** COMMON CODE SECTION ENDS HERE ***
127301 :
127302 :
127303 : // End of memberFunctionString
127304 : // Start of memberFunctionString
127305 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
127306 :
127307 :
127308 : #if 0
127309 : //! Error checking support
127310 : /*! Verifies the following:
127311 : - working getVariant() member function
127312 : - calls base class's error() member function
127313 : Every class has one of these functions.
127314 : */
127315 : bool
127316 : SgSwitchStatement::error()
127317 : {
127318 : // Put error checking here
127319 :
127320 : ROSE_ASSERT (this != NULL);
127321 : if (getVariant() != SWITCH_STMT)
127322 : {
127323 : printf ("Error in SgSwitchStatement::error(): SgSwitchStatement object has a %s variant \n",
127324 : Cxx_GrammarTerminalNames[getVariant()].name);
127325 : // printf ("Error in SgSwitchStatement::error() \n");
127326 : ROSE_ABORT();
127327 : }
127328 :
127329 : ROSE_ASSERT (getVariant() == SWITCH_STMT);
127330 : return SgScopeStatement::error();
127331 : }
127332 : #endif
127333 :
127334 :
127335 :
127336 : // End of memberFunctionString
127337 :
127338 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
127339 :
127340 967549 : SgSwitchStatement* isSgSwitchStatement ( SgNode* inputDerivedClassPointer )
127341 : {
127342 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
127343 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
127344 : // So to fix this we return NULL directly when the input is NULL and avoid the
127345 : // dynamic_cast in this case. This is likely a performance improvement as well.
127346 : // return dynamic_cast<SgSwitchStatement*>(inputDerivedClassPointer);
127347 : // Milind Chabbi (8/28/2013): isSgSwitchStatement uses table-driven castability instead of c++ default dynamic_cast
127348 : // this improves the running time performance by 10-20%.
127349 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSwitchStatement*>(inputDerivedClassPointer);
127350 967549 : return IS_SgSwitchStatement_FAST_MACRO(inputDerivedClassPointer);
127351 : }
127352 :
127353 : // DQ (11/8/2003): Added version of functions taking const pointer
127354 0 : const SgSwitchStatement* isSgSwitchStatement ( const SgNode* inputDerivedClassPointer )
127355 : {
127356 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
127357 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
127358 : // So to fix this we return NULL directly when the input is NULL and avoid the
127359 : // dynamic_cast in this case. This is likely a performance improvement as well.
127360 : // return dynamic_cast<const SgSwitchStatement*>(inputDerivedClassPointer);
127361 : // Milind Chabbi (8/28/2013): isSgSwitchStatement uses table-driven castability instead of c++ default dynamic_cast
127362 : // this improves the running time performance by 10-20%.
127363 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSwitchStatement*>(inputDerivedClassPointer);
127364 0 : return IS_SgSwitchStatement_FAST_MACRO(inputDerivedClassPointer);
127365 : }
127366 :
127367 :
127368 :
127369 : /* #line 127370 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127370 :
127371 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
127372 :
127373 : /**
127374 : \brief Generated destructor
127375 :
127376 : This destructor is automatically generated (by ROSETTA). This destructor
127377 : only frees memory of data members associated with the parts of the current IR node which
127378 : are NOT traversed. Those data members that are part of a traversal can be freed using
127379 : a traversal (calling this destructor on all children in a post-order traversal). Such
127380 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
127381 :
127382 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
127383 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
127384 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
127385 :
127386 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
127387 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
127388 : pointers are not yet implemented to call delete on eash pointer in the container.
127389 : (This could be done by derivation from the STL containers to define containers that
127390 : automatically deleted their members.)
127391 :
127392 : */
127393 0 : SgSwitchStatement::~SgSwitchStatement () {
127394 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
127395 :
127396 :
127397 : // case: not a listType for item_selector
127398 0 : p_item_selector = NULL; // non list case
127399 : // case: not a listType for body
127400 0 : p_body = NULL; // non list case
127401 : // case: not a listType for end_numeric_label
127402 0 : p_end_numeric_label = NULL; // non list case
127403 : // case: not a listType for string_label
127404 0 : p_string_label = ""; // non list case
127405 :
127406 : }
127407 :
127408 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
127409 0 : }
127410 :
127411 :
127412 : /* #line 127413 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127413 :
127414 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
127415 :
127416 : // Generated constructor
127417 0 : SgSwitchStatement::SgSwitchStatement ( Sg_File_Info* startOfConstruct, SgStatement* item_selector, SgStatement* body )
127418 0 : : SgScopeStatement(startOfConstruct)
127419 : {
127420 : #ifdef DEBUG
127421 : // printf ("In SgSwitchStatement::SgSwitchStatement (Sg_File_Info* startOfConstruct, SgStatement* item_selector, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
127422 : #endif
127423 : #if 0
127424 : // debugging information!
127425 : printf ("In SgSwitchStatement::SgSwitchStatement (Sg_File_Info* startOfConstruct, SgStatement* item_selector, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
127426 : #endif
127427 :
127428 0 : p_item_selector = item_selector;
127429 0 : p_body = body;
127430 0 : p_end_numeric_label = NULL;
127431 0 : p_string_label = "";
127432 :
127433 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
127434 :
127435 : #if 0
127436 : // DQ (7/30/2014): Call a virtual function.
127437 : std::string s = this->class_name();
127438 : #endif
127439 :
127440 : // Test the variant virtual function
127441 : // assert(SWITCH_STMT == variant());
127442 0 : assert(SWITCH_STMT == this->variant());
127443 0 : ROSE_ASSERT(SWITCH_STMT == (int)(this->variantT()));
127444 0 : post_construction_initialization();
127445 :
127446 : // Test the isSgSwitchStatement() function since it has been problematic
127447 0 : assert(isSgSwitchStatement(this) != NULL);
127448 0 : }
127449 :
127450 : // Generated constructor (all data members)
127451 :
127452 : /* #line 127453 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127453 :
127454 :
127455 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
127456 :
127457 :
127458 : // ********************************************************
127459 : // member functions common across all array grammar objects
127460 : // ********************************************************
127461 :
127462 :
127463 :
127464 : /* #line 127465 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127465 :
127466 :
127467 :
127468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
127469 :
127470 : // ********************************************************
127471 : // member functions specific to each node in the grammar
127472 : // ********************************************************
127473 :
127474 :
127475 : /* #line 127476 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127476 :
127477 : // Start of memberFunctionString
127478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
127479 :
127480 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
127481 :
127482 : SgVariableDeclaration*
127483 0 : SgCatchOptionStmt::get_condition () const
127484 : {
127485 0 : ROSE_ASSERT (this != NULL);
127486 :
127487 : #if 0
127488 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127489 : // used to trigger marking transformations for the token-based unparsing.
127490 : printf ("SgCatchOptionStmt::get_condition = %p = %s \n",this,this->class_name().c_str());
127491 : #endif
127492 :
127493 0 : return p_condition;
127494 : }
127495 :
127496 : void
127497 802 : SgCatchOptionStmt::set_condition ( SgVariableDeclaration* condition )
127498 : {
127499 802 : ROSE_ASSERT (this != NULL);
127500 :
127501 : #if 0
127502 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127503 : // used to trigger marking transformations for the token-based unparsing.
127504 : printf ("SgCatchOptionStmt::set_condition = %p = %s \n",this,this->class_name().c_str());
127505 : #endif
127506 :
127507 802 : set_isModified(true);
127508 :
127509 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
127510 : if (p_condition != NULL && condition != NULL && p_condition != condition)
127511 : {
127512 : printf ("Warning: condition = %p overwriting valid pointer p_condition = %p \n",condition,p_condition);
127513 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
127514 : printf ("Error fails assertion (p_condition != NULL && condition != NULL && p_condition != condition) is false\n");
127515 : ROSE_ASSERT(false);
127516 : #endif
127517 : }
127518 : #endif
127519 802 : p_condition = condition;
127520 802 : }
127521 :
127522 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
127523 :
127524 :
127525 : // End of memberFunctionString
127526 : // Start of memberFunctionString
127527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
127528 :
127529 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
127530 :
127531 : SgStatement*
127532 1704 : SgCatchOptionStmt::get_body () const
127533 : {
127534 1704 : ROSE_ASSERT (this != NULL);
127535 :
127536 : #if 0
127537 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127538 : // used to trigger marking transformations for the token-based unparsing.
127539 : printf ("SgCatchOptionStmt::get_body = %p = %s \n",this,this->class_name().c_str());
127540 : #endif
127541 :
127542 1704 : return p_body;
127543 : }
127544 :
127545 : void
127546 802 : SgCatchOptionStmt::set_body ( SgStatement* body )
127547 : {
127548 802 : ROSE_ASSERT (this != NULL);
127549 :
127550 : #if 0
127551 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127552 : // used to trigger marking transformations for the token-based unparsing.
127553 : printf ("SgCatchOptionStmt::set_body = %p = %s \n",this,this->class_name().c_str());
127554 : #endif
127555 :
127556 802 : set_isModified(true);
127557 :
127558 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
127559 : if (p_body != NULL && body != NULL && p_body != body)
127560 : {
127561 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
127562 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
127563 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
127564 : ROSE_ASSERT(false);
127565 : #endif
127566 : }
127567 : #endif
127568 802 : p_body = body;
127569 802 : }
127570 :
127571 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
127572 :
127573 :
127574 : // End of memberFunctionString
127575 : // Start of memberFunctionString
127576 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
127577 :
127578 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
127579 :
127580 : SgTryStmt*
127581 0 : SgCatchOptionStmt::get_trystmt () const
127582 : {
127583 0 : ROSE_ASSERT (this != NULL);
127584 :
127585 : #if 0
127586 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127587 : // used to trigger marking transformations for the token-based unparsing.
127588 : printf ("SgCatchOptionStmt::get_trystmt = %p = %s \n",this,this->class_name().c_str());
127589 : #endif
127590 :
127591 0 : return p_trystmt;
127592 : }
127593 :
127594 : void
127595 0 : SgCatchOptionStmt::set_trystmt ( SgTryStmt* trystmt )
127596 : {
127597 0 : ROSE_ASSERT (this != NULL);
127598 :
127599 : #if 0
127600 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127601 : // used to trigger marking transformations for the token-based unparsing.
127602 : printf ("SgCatchOptionStmt::set_trystmt = %p = %s \n",this,this->class_name().c_str());
127603 : #endif
127604 :
127605 0 : set_isModified(true);
127606 :
127607 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
127608 : if (p_trystmt != NULL && trystmt != NULL && p_trystmt != trystmt)
127609 : {
127610 : printf ("Warning: trystmt = %p overwriting valid pointer p_trystmt = %p \n",trystmt,p_trystmt);
127611 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
127612 : printf ("Error fails assertion (p_trystmt != NULL && trystmt != NULL && p_trystmt != trystmt) is false\n");
127613 : ROSE_ASSERT(false);
127614 : #endif
127615 : }
127616 : #endif
127617 0 : p_trystmt = trystmt;
127618 0 : }
127619 :
127620 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
127621 :
127622 :
127623 : // End of memberFunctionString
127624 : // Start of memberFunctionString
127625 : /* #line 15754 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
127626 :
127627 :
127628 : void
127629 802 : SgCatchOptionStmt::post_construction_initialization()
127630 : {
127631 : #ifndef REMOVE_SET_PARENT_FUNCTION
127632 : if(get_condition()) get_condition()->set_parent(this);
127633 : if(get_body()) get_body()->set_parent(this);
127634 : #endif
127635 802 : }
127636 :
127637 : // SgStatement* get_next(int&) const;
127638 :
127639 : bool
127640 0 : SgCatchOptionStmt::replace_child(SgStatement *target,SgStatement *newstmt,
127641 : bool extractBasicBlock)
127642 : {
127643 0 : if ( StatementReplace(this, p_condition, target, newstmt) == true )
127644 : return true;
127645 0 : else if ( StatementReplace(this, p_body, target, newstmt) == true )
127646 0 : return true;
127647 : else
127648 : return false;
127649 : }
127650 :
127651 : #if 0
127652 : SgStatement*
127653 : SgCatchOptionStmt::get_next(int& n) const
127654 : {
127655 : if(n==0)
127656 : {
127657 : n++;
127658 : if(get_condition())
127659 : return get_condition();
127660 : else
127661 : {
127662 : n++;
127663 : return get_body();
127664 : }
127665 : }
127666 : else
127667 : if(n==1)
127668 : {
127669 : n++;
127670 : get_body();
127671 : }
127672 : return 0;
127673 : }
127674 : #endif
127675 :
127676 : SgName
127677 1232 : SgCatchOptionStmt::get_mangled_name(void) const
127678 : {
127679 : // DQ (2/22/2007): This function is added to prevent "::" substrings in mangled names of other declarations.
127680 1232 : return SgName("");
127681 : }
127682 :
127683 :
127684 :
127685 : // End of memberFunctionString
127686 : // Start of memberFunctionString
127687 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
127688 :
127689 : // *** COMMON CODE SECTION BEGINS HERE ***
127690 :
127691 : #if 0
127692 : int
127693 : SgCatchOptionStmt::getVariant() const
127694 : {
127695 : // This function is used in ROSE while "variant()" is used in SAGE
127696 : assert(this != NULL);
127697 : return variant();
127698 : }
127699 : #endif
127700 :
127701 : // This function is used in ROSE in treeTraversal code
127702 : // eventually replaces getVariant() and variant()
127703 : // though after variant() has been removed for a while we will
127704 : // want to change the name of variantT() back to variant()
127705 : // (since the "T" was ment to stand for temporary).
127706 : // When this happens the variantT() will be depricated.
127707 : VariantT
127708 363648 : SgCatchOptionStmt::variantT() const
127709 : {
127710 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
127711 363648 : ROSE_ASSERT(this != NULL);
127712 363648 : return V_SgCatchOptionStmt;
127713 : }
127714 :
127715 : #if 0
127716 : int
127717 : SgCatchOptionStmt::variant() const
127718 : {
127719 : // This function is used in SAGE
127720 : ROSE_ASSERT(this != NULL);
127721 : return CATCH_STMT;
127722 : }
127723 : #endif
127724 :
127725 : ROSE_DLL_API const char*
127726 12 : SgCatchOptionStmt::sage_class_name() const
127727 : {
127728 12 : ROSE_ASSERT(this != NULL);
127729 12 : return "SgCatchOptionStmt";
127730 : }
127731 :
127732 : std::string
127733 7430 : SgCatchOptionStmt::class_name() const
127734 : {
127735 7430 : ROSE_ASSERT(this != NULL);
127736 7430 : return "SgCatchOptionStmt";
127737 : }
127738 :
127739 : // DQ (11/26/2005): Support for visitor pattern mechanims
127740 : // (inferior to ROSE traversal mechanism, experimental).
127741 : void
127742 12798 : SgCatchOptionStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
127743 : {
127744 12798 : ROSE_ASSERT(this != NULL);
127745 12798 : visitor.visit(this);
127746 12798 : }
127747 :
127748 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
127749 0 : void SgCatchOptionStmt::accept (ROSE_VisitorPattern & visitor) {
127750 0 : ROSE_ASSERT(this != NULL);
127751 0 : visitor.visit(this);
127752 0 : }
127753 :
127754 : SgCatchOptionStmt*
127755 0 : SgCatchOptionStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
127756 : {
127757 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
127758 : // This function is currently only supported for the AST used the represent Binary executables.
127759 : if (0 /* isSgAsmNode(this) != NULL */)
127760 : {
127761 : // Support for regex specification.
127762 : std::string prefixCode = "REGEX:";
127763 : addNewAttribute(prefixCode + s,a);
127764 : }
127765 : #endif
127766 :
127767 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
127768 0 : return this;
127769 : }
127770 :
127771 : // *** COMMON CODE SECTION ENDS HERE ***
127772 :
127773 :
127774 : // End of memberFunctionString
127775 : // Start of memberFunctionString
127776 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
127777 :
127778 :
127779 : #if 0
127780 : //! Error checking support
127781 : /*! Verifies the following:
127782 : - working getVariant() member function
127783 : - calls base class's error() member function
127784 : Every class has one of these functions.
127785 : */
127786 : bool
127787 : SgCatchOptionStmt::error()
127788 : {
127789 : // Put error checking here
127790 :
127791 : ROSE_ASSERT (this != NULL);
127792 : if (getVariant() != CATCH_STMT)
127793 : {
127794 : printf ("Error in SgCatchOptionStmt::error(): SgCatchOptionStmt object has a %s variant \n",
127795 : Cxx_GrammarTerminalNames[getVariant()].name);
127796 : // printf ("Error in SgCatchOptionStmt::error() \n");
127797 : ROSE_ABORT();
127798 : }
127799 :
127800 : ROSE_ASSERT (getVariant() == CATCH_STMT);
127801 : return SgScopeStatement::error();
127802 : }
127803 : #endif
127804 :
127805 :
127806 :
127807 : // End of memberFunctionString
127808 :
127809 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
127810 :
127811 2915 : SgCatchOptionStmt* isSgCatchOptionStmt ( SgNode* inputDerivedClassPointer )
127812 : {
127813 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
127814 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
127815 : // So to fix this we return NULL directly when the input is NULL and avoid the
127816 : // dynamic_cast in this case. This is likely a performance improvement as well.
127817 : // return dynamic_cast<SgCatchOptionStmt*>(inputDerivedClassPointer);
127818 : // Milind Chabbi (8/28/2013): isSgCatchOptionStmt uses table-driven castability instead of c++ default dynamic_cast
127819 : // this improves the running time performance by 10-20%.
127820 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCatchOptionStmt*>(inputDerivedClassPointer);
127821 2915 : return IS_SgCatchOptionStmt_FAST_MACRO(inputDerivedClassPointer);
127822 : }
127823 :
127824 : // DQ (11/8/2003): Added version of functions taking const pointer
127825 568 : const SgCatchOptionStmt* isSgCatchOptionStmt ( const SgNode* inputDerivedClassPointer )
127826 : {
127827 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
127828 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
127829 : // So to fix this we return NULL directly when the input is NULL and avoid the
127830 : // dynamic_cast in this case. This is likely a performance improvement as well.
127831 : // return dynamic_cast<const SgCatchOptionStmt*>(inputDerivedClassPointer);
127832 : // Milind Chabbi (8/28/2013): isSgCatchOptionStmt uses table-driven castability instead of c++ default dynamic_cast
127833 : // this improves the running time performance by 10-20%.
127834 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCatchOptionStmt*>(inputDerivedClassPointer);
127835 568 : return IS_SgCatchOptionStmt_FAST_MACRO(inputDerivedClassPointer);
127836 : }
127837 :
127838 :
127839 :
127840 : /* #line 127841 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127841 :
127842 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
127843 :
127844 : /**
127845 : \brief Generated destructor
127846 :
127847 : This destructor is automatically generated (by ROSETTA). This destructor
127848 : only frees memory of data members associated with the parts of the current IR node which
127849 : are NOT traversed. Those data members that are part of a traversal can be freed using
127850 : a traversal (calling this destructor on all children in a post-order traversal). Such
127851 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
127852 :
127853 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
127854 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
127855 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
127856 :
127857 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
127858 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
127859 : pointers are not yet implemented to call delete on eash pointer in the container.
127860 : (This could be done by derivation from the STL containers to define containers that
127861 : automatically deleted their members.)
127862 :
127863 : */
127864 360 : SgCatchOptionStmt::~SgCatchOptionStmt () {
127865 180 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
127866 :
127867 :
127868 : // case: not a listType for condition
127869 180 : p_condition = NULL; // non list case
127870 : // case: not a listType for body
127871 180 : p_body = NULL; // non list case
127872 : // case: not a listType for trystmt
127873 180 : p_trystmt = NULL; // non list case
127874 :
127875 : }
127876 :
127877 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
127878 360 : }
127879 :
127880 :
127881 : /* #line 127882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127882 :
127883 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
127884 :
127885 : // Generated constructor
127886 0 : SgCatchOptionStmt::SgCatchOptionStmt ( Sg_File_Info* startOfConstruct, SgVariableDeclaration* condition, SgStatement* body, SgTryStmt* trystmt )
127887 0 : : SgScopeStatement(startOfConstruct)
127888 : {
127889 : #ifdef DEBUG
127890 : // printf ("In SgCatchOptionStmt::SgCatchOptionStmt (Sg_File_Info* startOfConstruct, SgVariableDeclaration* condition, SgStatement* body, SgTryStmt* trystmt) sage_class_name() = %s \n",sage_class_name());
127891 : #endif
127892 : #if 0
127893 : // debugging information!
127894 : printf ("In SgCatchOptionStmt::SgCatchOptionStmt (Sg_File_Info* startOfConstruct, SgVariableDeclaration* condition, SgStatement* body, SgTryStmt* trystmt): this = %p = %s \n",this,this->class_name().c_str());
127895 : #endif
127896 :
127897 0 : p_condition = condition;
127898 0 : p_body = body;
127899 0 : p_trystmt = trystmt;
127900 :
127901 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
127902 :
127903 : #if 0
127904 : // DQ (7/30/2014): Call a virtual function.
127905 : std::string s = this->class_name();
127906 : #endif
127907 :
127908 : // Test the variant virtual function
127909 : // assert(CATCH_STMT == variant());
127910 0 : assert(CATCH_STMT == this->variant());
127911 0 : ROSE_ASSERT(CATCH_STMT == (int)(this->variantT()));
127912 0 : post_construction_initialization();
127913 :
127914 : // Test the isSgCatchOptionStmt() function since it has been problematic
127915 0 : assert(isSgCatchOptionStmt(this) != NULL);
127916 0 : }
127917 :
127918 : // Generated constructor (all data members)
127919 :
127920 : /* #line 127921 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127921 :
127922 :
127923 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
127924 :
127925 :
127926 : // ********************************************************
127927 : // member functions common across all array grammar objects
127928 : // ********************************************************
127929 :
127930 :
127931 :
127932 : /* #line 127933 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127933 :
127934 :
127935 :
127936 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
127937 :
127938 : // ********************************************************
127939 : // member functions specific to each node in the grammar
127940 : // ********************************************************
127941 :
127942 :
127943 : /* #line 127944 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
127944 :
127945 : // Start of memberFunctionString
127946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
127947 :
127948 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
127949 :
127950 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
127951 : const SgDeclarationStatementPtrList &
127952 815 : SgNamespaceDefinitionStatement::get_declarations () const
127953 : {
127954 815 : assert (this != NULL);
127955 815 : return p_declarations;
127956 : }
127957 :
127958 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
127959 : SgDeclarationStatementPtrList &
127960 64177 : SgNamespaceDefinitionStatement::get_declarations ()
127961 : {
127962 64177 : assert (this != NULL);
127963 :
127964 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
127965 : // As a rule only set_ access functions can set the isModified flag.
127966 : // set_isModified(true);
127967 :
127968 64177 : return p_declarations;
127969 : }
127970 :
127971 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
127972 :
127973 :
127974 : // End of memberFunctionString
127975 : // Start of memberFunctionString
127976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
127977 :
127978 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
127979 :
127980 : SgNamespaceDeclarationStatement*
127981 703727 : SgNamespaceDefinitionStatement::get_namespaceDeclaration () const
127982 : {
127983 703727 : ROSE_ASSERT (this != NULL);
127984 :
127985 : #if 0
127986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
127987 : // used to trigger marking transformations for the token-based unparsing.
127988 : printf ("SgNamespaceDefinitionStatement::get_namespaceDeclaration = %p = %s \n",this,this->class_name().c_str());
127989 : #endif
127990 :
127991 703727 : return p_namespaceDeclaration;
127992 : }
127993 :
127994 : void
127995 1425 : SgNamespaceDefinitionStatement::set_namespaceDeclaration ( SgNamespaceDeclarationStatement* namespaceDeclaration )
127996 : {
127997 1425 : ROSE_ASSERT (this != NULL);
127998 :
127999 : #if 0
128000 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128001 : // used to trigger marking transformations for the token-based unparsing.
128002 : printf ("SgNamespaceDefinitionStatement::set_namespaceDeclaration = %p = %s \n",this,this->class_name().c_str());
128003 : #endif
128004 :
128005 1425 : set_isModified(true);
128006 :
128007 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
128008 : if (p_namespaceDeclaration != NULL && namespaceDeclaration != NULL && p_namespaceDeclaration != namespaceDeclaration)
128009 : {
128010 : printf ("Warning: namespaceDeclaration = %p overwriting valid pointer p_namespaceDeclaration = %p \n",namespaceDeclaration,p_namespaceDeclaration);
128011 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
128012 : printf ("Error fails assertion (p_namespaceDeclaration != NULL && namespaceDeclaration != NULL && p_namespaceDeclaration != namespaceDeclaration) is false\n");
128013 : ROSE_ASSERT(false);
128014 : #endif
128015 : }
128016 : #endif
128017 1425 : p_namespaceDeclaration = namespaceDeclaration;
128018 1425 : }
128019 :
128020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128021 :
128022 :
128023 : // End of memberFunctionString
128024 : // Start of memberFunctionString
128025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
128026 :
128027 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128028 :
128029 : SgNamespaceDefinitionStatement*
128030 155935 : SgNamespaceDefinitionStatement::get_previousNamespaceDefinition () const
128031 : {
128032 155935 : ROSE_ASSERT (this != NULL);
128033 :
128034 : #if 0
128035 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128036 : // used to trigger marking transformations for the token-based unparsing.
128037 : printf ("SgNamespaceDefinitionStatement::get_previousNamespaceDefinition = %p = %s \n",this,this->class_name().c_str());
128038 : #endif
128039 :
128040 155935 : return p_previousNamespaceDefinition;
128041 : }
128042 :
128043 : void
128044 978 : SgNamespaceDefinitionStatement::set_previousNamespaceDefinition ( SgNamespaceDefinitionStatement* previousNamespaceDefinition )
128045 : {
128046 978 : ROSE_ASSERT (this != NULL);
128047 :
128048 : #if 0
128049 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128050 : // used to trigger marking transformations for the token-based unparsing.
128051 : printf ("SgNamespaceDefinitionStatement::set_previousNamespaceDefinition = %p = %s \n",this,this->class_name().c_str());
128052 : #endif
128053 :
128054 978 : set_isModified(true);
128055 :
128056 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
128057 : if (p_previousNamespaceDefinition != NULL && previousNamespaceDefinition != NULL && p_previousNamespaceDefinition != previousNamespaceDefinition)
128058 : {
128059 : printf ("Warning: previousNamespaceDefinition = %p overwriting valid pointer p_previousNamespaceDefinition = %p \n",previousNamespaceDefinition,p_previousNamespaceDefinition);
128060 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
128061 : printf ("Error fails assertion (p_previousNamespaceDefinition != NULL && previousNamespaceDefinition != NULL && p_previousNamespaceDefinition != previousNamespaceDefinition) is false\n");
128062 : ROSE_ASSERT(false);
128063 : #endif
128064 : }
128065 : #endif
128066 978 : p_previousNamespaceDefinition = previousNamespaceDefinition;
128067 978 : }
128068 :
128069 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128070 :
128071 :
128072 : // End of memberFunctionString
128073 : // Start of memberFunctionString
128074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
128075 :
128076 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128077 :
128078 : SgNamespaceDefinitionStatement*
128079 57351 : SgNamespaceDefinitionStatement::get_nextNamespaceDefinition () const
128080 : {
128081 57351 : ROSE_ASSERT (this != NULL);
128082 :
128083 : #if 0
128084 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128085 : // used to trigger marking transformations for the token-based unparsing.
128086 : printf ("SgNamespaceDefinitionStatement::get_nextNamespaceDefinition = %p = %s \n",this,this->class_name().c_str());
128087 : #endif
128088 :
128089 57351 : return p_nextNamespaceDefinition;
128090 : }
128091 :
128092 : void
128093 978 : SgNamespaceDefinitionStatement::set_nextNamespaceDefinition ( SgNamespaceDefinitionStatement* nextNamespaceDefinition )
128094 : {
128095 978 : ROSE_ASSERT (this != NULL);
128096 :
128097 : #if 0
128098 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128099 : // used to trigger marking transformations for the token-based unparsing.
128100 : printf ("SgNamespaceDefinitionStatement::set_nextNamespaceDefinition = %p = %s \n",this,this->class_name().c_str());
128101 : #endif
128102 :
128103 978 : set_isModified(true);
128104 :
128105 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
128106 : if (p_nextNamespaceDefinition != NULL && nextNamespaceDefinition != NULL && p_nextNamespaceDefinition != nextNamespaceDefinition)
128107 : {
128108 : printf ("Warning: nextNamespaceDefinition = %p overwriting valid pointer p_nextNamespaceDefinition = %p \n",nextNamespaceDefinition,p_nextNamespaceDefinition);
128109 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
128110 : printf ("Error fails assertion (p_nextNamespaceDefinition != NULL && nextNamespaceDefinition != NULL && p_nextNamespaceDefinition != nextNamespaceDefinition) is false\n");
128111 : ROSE_ASSERT(false);
128112 : #endif
128113 : }
128114 : #endif
128115 978 : p_nextNamespaceDefinition = nextNamespaceDefinition;
128116 978 : }
128117 :
128118 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128119 :
128120 :
128121 : // End of memberFunctionString
128122 : // Start of memberFunctionString
128123 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
128124 :
128125 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128126 :
128127 : SgNamespaceDefinitionStatement*
128128 849006 : SgNamespaceDefinitionStatement::get_global_definition () const
128129 : {
128130 849006 : ROSE_ASSERT (this != NULL);
128131 :
128132 : #if 0
128133 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128134 : // used to trigger marking transformations for the token-based unparsing.
128135 : printf ("SgNamespaceDefinitionStatement::get_global_definition = %p = %s \n",this,this->class_name().c_str());
128136 : #endif
128137 :
128138 849006 : return p_global_definition;
128139 : }
128140 :
128141 : void
128142 1276 : SgNamespaceDefinitionStatement::set_global_definition ( SgNamespaceDefinitionStatement* global_definition )
128143 : {
128144 1276 : ROSE_ASSERT (this != NULL);
128145 :
128146 : #if 0
128147 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128148 : // used to trigger marking transformations for the token-based unparsing.
128149 : printf ("SgNamespaceDefinitionStatement::set_global_definition = %p = %s \n",this,this->class_name().c_str());
128150 : #endif
128151 :
128152 1276 : set_isModified(true);
128153 :
128154 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
128155 : if (p_global_definition != NULL && global_definition != NULL && p_global_definition != global_definition)
128156 : {
128157 : printf ("Warning: global_definition = %p overwriting valid pointer p_global_definition = %p \n",global_definition,p_global_definition);
128158 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
128159 : printf ("Error fails assertion (p_global_definition != NULL && global_definition != NULL && p_global_definition != global_definition) is false\n");
128160 : ROSE_ASSERT(false);
128161 : #endif
128162 : }
128163 : #endif
128164 1276 : p_global_definition = global_definition;
128165 1276 : }
128166 :
128167 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128168 :
128169 :
128170 : // End of memberFunctionString
128171 : // Start of memberFunctionString
128172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
128173 :
128174 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128175 :
128176 : bool
128177 0 : SgNamespaceDefinitionStatement::get_isUnionOfReentrantNamespaceDefinitions () const
128178 : {
128179 0 : ROSE_ASSERT (this != NULL);
128180 :
128181 : #if 0
128182 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128183 : // used to trigger marking transformations for the token-based unparsing.
128184 : printf ("SgNamespaceDefinitionStatement::get_isUnionOfReentrantNamespaceDefinitions = %p = %s \n",this,this->class_name().c_str());
128185 : #endif
128186 :
128187 0 : return p_isUnionOfReentrantNamespaceDefinitions;
128188 : }
128189 :
128190 : void
128191 149 : SgNamespaceDefinitionStatement::set_isUnionOfReentrantNamespaceDefinitions ( bool isUnionOfReentrantNamespaceDefinitions )
128192 : {
128193 149 : ROSE_ASSERT (this != NULL);
128194 :
128195 : #if 0
128196 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128197 : // used to trigger marking transformations for the token-based unparsing.
128198 : printf ("SgNamespaceDefinitionStatement::set_isUnionOfReentrantNamespaceDefinitions = %p = %s \n",this,this->class_name().c_str());
128199 : #endif
128200 :
128201 149 : set_isModified(true);
128202 :
128203 149 : p_isUnionOfReentrantNamespaceDefinitions = isUnionOfReentrantNamespaceDefinitions;
128204 149 : }
128205 :
128206 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128207 :
128208 :
128209 : // End of memberFunctionString
128210 : // Start of memberFunctionString
128211 : /* #line 17534 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
128212 :
128213 :
128214 : bool
128215 0 : SgNamespaceDefinitionStatement::isSameNamespace(const SgNamespaceDefinitionStatement* n ) const
128216 : {
128217 0 : ROSE_ASSERT(this != NULL);
128218 0 : ROSE_ASSERT(n != NULL);
128219 0 : ROSE_ASSERT(this->get_namespaceDeclaration() != NULL);
128220 0 : ROSE_ASSERT(n->get_namespaceDeclaration() != NULL);
128221 :
128222 0 : return this->get_namespaceDeclaration()->isSameNamespace(n->get_namespaceDeclaration());
128223 : }
128224 :
128225 : void
128226 0 : SgNamespaceDefinitionStatement::append_declaration(SgDeclarationStatement * what)
128227 : {
128228 0 : get_declarations().push_back(what);
128229 0 : what->set_parent(this);
128230 0 : }
128231 :
128232 : void
128233 0 : SgNamespaceDefinitionStatement::prepend_declaration(SgDeclarationStatement * what)
128234 : {
128235 0 : get_declarations().insert(get_declarations().begin(), what);
128236 0 : what->set_parent(this);
128237 0 : }
128238 :
128239 : #if 0
128240 : void
128241 : SgNamespaceDefinitionStatement::insert_declaration ( const SgDeclarationStatementPtrList::iterator& where,
128242 : SgDeclarationStatement* what)
128243 : {
128244 : #ifndef REMOVE_SET_PARENT_FUNCTION
128245 : what->set_parent(this);
128246 : #endif
128247 : get_declarations().insert(where,what);
128248 : }
128249 : #endif
128250 :
128251 : // DQ (8/27/2004): Turn this back on!
128252 : #if 1
128253 : bool
128254 23961 : SgNamespaceDefinitionStatement::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractBasicBlock)
128255 : {
128256 23961 : return StatementListInsertChild( this, get_declarations(), target, newstmt, inFront, extractBasicBlock, false);
128257 : }
128258 :
128259 : bool
128260 0 : SgNamespaceDefinitionStatement::replace_child(SgStatement *target ,SgStatement * newstmt, bool extractBasicBlock)
128261 : {
128262 0 : return StatementListInsertChild( this, get_declarations(), target, newstmt, true, extractBasicBlock, true);
128263 : }
128264 : #endif
128265 :
128266 : // DQ (9/8/2004): Added to support qualified name generation
128267 : SgName
128268 58236 : SgNamespaceDefinitionStatement::get_qualified_name() const
128269 : {
128270 : // printf ("In SgNamespaceDefinitionStatement::get_qualified_name() \n");
128271 :
128272 58236 : ROSE_ASSERT(get_namespaceDeclaration() != NULL);
128273 58236 : return get_namespaceDeclaration()->get_qualified_name();
128274 : }
128275 :
128276 : // RV (2/1/2006): Added mangler for namespace definitions.
128277 : SgName
128278 87198 : SgNamespaceDefinitionStatement::get_mangled_name (void) const
128279 : {
128280 87198 : if (get_namespaceDeclaration() == NULL)
128281 : {
128282 0 : printf ("In SgNamespaceDefinitionStatement::get_mangled_name(): get_namespaceDeclaration() == NULL: this = %p \n",this);
128283 : }
128284 :
128285 87198 : ROSE_ASSERT(get_namespaceDeclaration() != NULL);
128286 87198 : return get_namespaceDeclaration()->get_mangled_name ();
128287 : }
128288 :
128289 : void
128290 1276 : SgNamespaceDefinitionStatement::post_construction_initialization()
128291 : {
128292 1276 : }
128293 :
128294 : #if 0
128295 : // DQ (5/9/2013): This is an older version of the code.
128296 : void
128297 : SgNamespaceDefinitionStatement::append_declaration(SgDeclarationStatement * what)
128298 : {
128299 : insert_declaration(get_declarations().end(),what);
128300 : }
128301 :
128302 : // DQ (5/9/2013): This is an older version of the code.
128303 : void
128304 : SgNamespaceDefinitionStatement::prepend_declaration(SgDeclarationStatement * what)
128305 : {
128306 : insert_declaration(get_declarations().begin(),what);
128307 : }
128308 : #endif
128309 :
128310 : size_t
128311 0 : SgNamespaceDefinitionStatement::namespaceIndex() const
128312 : {
128313 0 : size_t result = 0;
128314 0 : SgNamespaceDefinitionStatement* i = const_cast<SgNamespaceDefinitionStatement*>(this);
128315 0 : while (i->get_previousNamespaceDefinition() != NULL)
128316 : {
128317 0 : result++;
128318 0 : i = i->get_previousNamespaceDefinition();
128319 : }
128320 :
128321 0 : return result;
128322 : }
128323 :
128324 : size_t
128325 0 : SgNamespaceDefinitionStatement::numberOfNamespaceDefinitions() const
128326 : {
128327 0 : size_t result = 0;
128328 :
128329 0 : SgNamespaceDefinitionStatement* i = const_cast<SgNamespaceDefinitionStatement*>(this);
128330 :
128331 0 : if (this == this->get_global_definition())
128332 : {
128333 : // If this is the namespace definiton used to accumulate all of the symbols in the namespace then find the name space defintion associated with the first non-defining declaration.
128334 0 : ROSE_ASSERT(this->get_namespaceDeclaration() == this->get_namespaceDeclaration()->get_firstNondefiningDeclaration());
128335 :
128336 : // DQ (5/19/2013): Added assertion.
128337 0 : ROSE_ASSERT(this->get_isUnionOfReentrantNamespaceDefinitions() == true);
128338 :
128339 0 : i = this->get_namespaceDeclaration()->get_definition();
128340 : }
128341 : else
128342 : {
128343 : // DQ (5/19/2013): Added assertion.
128344 0 : ROSE_ASSERT(this->get_isUnionOfReentrantNamespaceDefinitions() == false);
128345 : }
128346 :
128347 0 : while (i->get_nextNamespaceDefinition() != NULL)
128348 : {
128349 0 : result++;
128350 0 : i = i->get_nextNamespaceDefinition();
128351 : }
128352 :
128353 0 : result += namespaceIndex() + 1;
128354 :
128355 0 : return result;
128356 : }
128357 :
128358 : #if 0
128359 : // DQ (5/16/2013): This is now a seperate data member access function (to a specially constructed
128360 : // SgNamespaceDefinitionStatement used to hold the SgAliasSymbols that are the union of those across
128361 : // all of the many re-entrant namespace definitions.
128362 : SgNamespaceDefinitionStatement*
128363 : SgNamespaceDefinitionStatement::get_global_definition() const
128364 : {
128365 : // DQ (5/9/2013): Traverse back through the scopes to the first one. Later
128366 : // we might want to return an especially constructed SgNamespaceDefinitionStatement
128367 : // for this purpose.
128368 : SgNamespaceDefinitionStatement* i = const_cast<SgNamespaceDefinitionStatement*>(this);
128369 : while (i->get_previousNamespaceDefinition() != NULL)
128370 : {
128371 : i = i->get_previousNamespaceDefinition();
128372 : }
128373 :
128374 : return i;
128375 : }
128376 : #endif
128377 :
128378 :
128379 :
128380 : // End of memberFunctionString
128381 : // Start of memberFunctionString
128382 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
128383 :
128384 : // *** COMMON CODE SECTION BEGINS HERE ***
128385 :
128386 : #if 0
128387 : int
128388 : SgNamespaceDefinitionStatement::getVariant() const
128389 : {
128390 : // This function is used in ROSE while "variant()" is used in SAGE
128391 : assert(this != NULL);
128392 : return variant();
128393 : }
128394 : #endif
128395 :
128396 : // This function is used in ROSE in treeTraversal code
128397 : // eventually replaces getVariant() and variant()
128398 : // though after variant() has been removed for a while we will
128399 : // want to change the name of variantT() back to variant()
128400 : // (since the "T" was ment to stand for temporary).
128401 : // When this happens the variantT() will be depricated.
128402 : VariantT
128403 8725280 : SgNamespaceDefinitionStatement::variantT() const
128404 : {
128405 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
128406 8725280 : ROSE_ASSERT(this != NULL);
128407 8725280 : return V_SgNamespaceDefinitionStatement;
128408 : }
128409 :
128410 : #if 0
128411 : int
128412 : SgNamespaceDefinitionStatement::variant() const
128413 : {
128414 : // This function is used in SAGE
128415 : ROSE_ASSERT(this != NULL);
128416 : return NAMESPACE_DEFINITION_STMT;
128417 : }
128418 : #endif
128419 :
128420 : ROSE_DLL_API const char*
128421 815 : SgNamespaceDefinitionStatement::sage_class_name() const
128422 : {
128423 815 : ROSE_ASSERT(this != NULL);
128424 815 : return "SgNamespaceDefinitionStatement";
128425 : }
128426 :
128427 : std::string
128428 282902 : SgNamespaceDefinitionStatement::class_name() const
128429 : {
128430 282902 : ROSE_ASSERT(this != NULL);
128431 282902 : return "SgNamespaceDefinitionStatement";
128432 : }
128433 :
128434 : // DQ (11/26/2005): Support for visitor pattern mechanims
128435 : // (inferior to ROSE traversal mechanism, experimental).
128436 : void
128437 18639 : SgNamespaceDefinitionStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
128438 : {
128439 18639 : ROSE_ASSERT(this != NULL);
128440 18639 : visitor.visit(this);
128441 18639 : }
128442 :
128443 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
128444 0 : void SgNamespaceDefinitionStatement::accept (ROSE_VisitorPattern & visitor) {
128445 0 : ROSE_ASSERT(this != NULL);
128446 0 : visitor.visit(this);
128447 0 : }
128448 :
128449 : SgNamespaceDefinitionStatement*
128450 0 : SgNamespaceDefinitionStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
128451 : {
128452 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
128453 : // This function is currently only supported for the AST used the represent Binary executables.
128454 : if (0 /* isSgAsmNode(this) != NULL */)
128455 : {
128456 : // Support for regex specification.
128457 : std::string prefixCode = "REGEX:";
128458 : addNewAttribute(prefixCode + s,a);
128459 : }
128460 : #endif
128461 :
128462 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
128463 0 : return this;
128464 : }
128465 :
128466 : // *** COMMON CODE SECTION ENDS HERE ***
128467 :
128468 :
128469 : // End of memberFunctionString
128470 : // Start of memberFunctionString
128471 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
128472 :
128473 :
128474 : #if 0
128475 : //! Error checking support
128476 : /*! Verifies the following:
128477 : - working getVariant() member function
128478 : - calls base class's error() member function
128479 : Every class has one of these functions.
128480 : */
128481 : bool
128482 : SgNamespaceDefinitionStatement::error()
128483 : {
128484 : // Put error checking here
128485 :
128486 : ROSE_ASSERT (this != NULL);
128487 : if (getVariant() != NAMESPACE_DEFINITION_STMT)
128488 : {
128489 : printf ("Error in SgNamespaceDefinitionStatement::error(): SgNamespaceDefinitionStatement object has a %s variant \n",
128490 : Cxx_GrammarTerminalNames[getVariant()].name);
128491 : // printf ("Error in SgNamespaceDefinitionStatement::error() \n");
128492 : ROSE_ABORT();
128493 : }
128494 :
128495 : ROSE_ASSERT (getVariant() == NAMESPACE_DEFINITION_STMT);
128496 : return SgScopeStatement::error();
128497 : }
128498 : #endif
128499 :
128500 :
128501 :
128502 : // End of memberFunctionString
128503 :
128504 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
128505 :
128506 59145600 : SgNamespaceDefinitionStatement* isSgNamespaceDefinitionStatement ( SgNode* inputDerivedClassPointer )
128507 : {
128508 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
128509 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
128510 : // So to fix this we return NULL directly when the input is NULL and avoid the
128511 : // dynamic_cast in this case. This is likely a performance improvement as well.
128512 : // return dynamic_cast<SgNamespaceDefinitionStatement*>(inputDerivedClassPointer);
128513 : // Milind Chabbi (8/28/2013): isSgNamespaceDefinitionStatement uses table-driven castability instead of c++ default dynamic_cast
128514 : // this improves the running time performance by 10-20%.
128515 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNamespaceDefinitionStatement*>(inputDerivedClassPointer);
128516 59145600 : return IS_SgNamespaceDefinitionStatement_FAST_MACRO(inputDerivedClassPointer);
128517 : }
128518 :
128519 : // DQ (11/8/2003): Added version of functions taking const pointer
128520 25101900 : const SgNamespaceDefinitionStatement* isSgNamespaceDefinitionStatement ( const SgNode* inputDerivedClassPointer )
128521 : {
128522 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
128523 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
128524 : // So to fix this we return NULL directly when the input is NULL and avoid the
128525 : // dynamic_cast in this case. This is likely a performance improvement as well.
128526 : // return dynamic_cast<const SgNamespaceDefinitionStatement*>(inputDerivedClassPointer);
128527 : // Milind Chabbi (8/28/2013): isSgNamespaceDefinitionStatement uses table-driven castability instead of c++ default dynamic_cast
128528 : // this improves the running time performance by 10-20%.
128529 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNamespaceDefinitionStatement*>(inputDerivedClassPointer);
128530 25101900 : return IS_SgNamespaceDefinitionStatement_FAST_MACRO(inputDerivedClassPointer);
128531 : }
128532 :
128533 :
128534 :
128535 : /* #line 128536 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128536 :
128537 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
128538 :
128539 : /**
128540 : \brief Generated destructor
128541 :
128542 : This destructor is automatically generated (by ROSETTA). This destructor
128543 : only frees memory of data members associated with the parts of the current IR node which
128544 : are NOT traversed. Those data members that are part of a traversal can be freed using
128545 : a traversal (calling this destructor on all children in a post-order traversal). Such
128546 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
128547 :
128548 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
128549 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
128550 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
128551 :
128552 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
128553 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
128554 : pointers are not yet implemented to call delete on eash pointer in the container.
128555 : (This could be done by derivation from the STL containers to define containers that
128556 : automatically deleted their members.)
128557 :
128558 : */
128559 774 : SgNamespaceDefinitionStatement::~SgNamespaceDefinitionStatement () {
128560 270 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
128561 :
128562 :
128563 : // case: not a listType for namespaceDeclaration
128564 270 : p_namespaceDeclaration = NULL; // non list case
128565 : // case: not a listType for previousNamespaceDefinition
128566 270 : p_previousNamespaceDefinition = NULL; // non list case
128567 : // case: not a listType for nextNamespaceDefinition
128568 270 : p_nextNamespaceDefinition = NULL; // non list case
128569 : // case: not a listType for global_definition
128570 270 : p_global_definition = NULL; // non list case
128571 : // case: not a listType for isUnionOfReentrantNamespaceDefinitions
128572 270 : p_isUnionOfReentrantNamespaceDefinitions = false; // non list case
128573 :
128574 : }
128575 :
128576 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
128577 540 : }
128578 :
128579 :
128580 : /* #line 128581 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128581 :
128582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
128583 :
128584 : // Generated constructor
128585 0 : SgNamespaceDefinitionStatement::SgNamespaceDefinitionStatement ( Sg_File_Info* startOfConstruct, SgNamespaceDeclarationStatement* namespaceDeclaration )
128586 0 : : SgScopeStatement(startOfConstruct)
128587 : {
128588 : #ifdef DEBUG
128589 : // printf ("In SgNamespaceDefinitionStatement::SgNamespaceDefinitionStatement (Sg_File_Info* startOfConstruct, SgNamespaceDeclarationStatement* namespaceDeclaration) sage_class_name() = %s \n",sage_class_name());
128590 : #endif
128591 : #if 0
128592 : // debugging information!
128593 : printf ("In SgNamespaceDefinitionStatement::SgNamespaceDefinitionStatement (Sg_File_Info* startOfConstruct, SgNamespaceDeclarationStatement* namespaceDeclaration): this = %p = %s \n",this,this->class_name().c_str());
128594 : #endif
128595 :
128596 0 : p_namespaceDeclaration = namespaceDeclaration;
128597 0 : p_previousNamespaceDefinition = NULL;
128598 0 : p_nextNamespaceDefinition = NULL;
128599 0 : p_global_definition = NULL;
128600 0 : p_isUnionOfReentrantNamespaceDefinitions = false;
128601 :
128602 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
128603 :
128604 : #if 0
128605 : // DQ (7/30/2014): Call a virtual function.
128606 : std::string s = this->class_name();
128607 : #endif
128608 :
128609 : // Test the variant virtual function
128610 : // assert(NAMESPACE_DEFINITION_STMT == variant());
128611 0 : assert(NAMESPACE_DEFINITION_STMT == this->variant());
128612 0 : ROSE_ASSERT(NAMESPACE_DEFINITION_STMT == (int)(this->variantT()));
128613 0 : post_construction_initialization();
128614 :
128615 : // Test the isSgNamespaceDefinitionStatement() function since it has been problematic
128616 0 : assert(isSgNamespaceDefinitionStatement(this) != NULL);
128617 0 : }
128618 :
128619 : // Generated constructor (all data members)
128620 :
128621 : /* #line 128622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128622 :
128623 :
128624 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
128625 :
128626 :
128627 : // ********************************************************
128628 : // member functions common across all array grammar objects
128629 : // ********************************************************
128630 :
128631 :
128632 :
128633 : /* #line 128634 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128634 :
128635 :
128636 :
128637 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
128638 :
128639 : // ********************************************************
128640 : // member functions specific to each node in the grammar
128641 : // ********************************************************
128642 :
128643 :
128644 : /* #line 128645 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128645 :
128646 : // Start of memberFunctionString
128647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
128648 :
128649 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128650 :
128651 : SgBasicBlock*
128652 0 : SgBlockDataStatement::get_body () const
128653 : {
128654 0 : ROSE_ASSERT (this != NULL);
128655 :
128656 : #if 0
128657 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128658 : // used to trigger marking transformations for the token-based unparsing.
128659 : printf ("SgBlockDataStatement::get_body = %p = %s \n",this,this->class_name().c_str());
128660 : #endif
128661 :
128662 0 : return p_body;
128663 : }
128664 :
128665 : void
128666 0 : SgBlockDataStatement::set_body ( SgBasicBlock* body )
128667 : {
128668 0 : ROSE_ASSERT (this != NULL);
128669 :
128670 : #if 0
128671 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128672 : // used to trigger marking transformations for the token-based unparsing.
128673 : printf ("SgBlockDataStatement::set_body = %p = %s \n",this,this->class_name().c_str());
128674 : #endif
128675 :
128676 0 : set_isModified(true);
128677 :
128678 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
128679 : if (p_body != NULL && body != NULL && p_body != body)
128680 : {
128681 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
128682 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
128683 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
128684 : ROSE_ASSERT(false);
128685 : #endif
128686 : }
128687 : #endif
128688 0 : p_body = body;
128689 0 : }
128690 :
128691 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128692 :
128693 :
128694 : // End of memberFunctionString
128695 : // Start of memberFunctionString
128696 : /* #line 18524 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
128697 :
128698 : void
128699 0 : SgBlockDataStatement::post_construction_initialization()
128700 0 : {}
128701 :
128702 :
128703 : // End of memberFunctionString
128704 : // Start of memberFunctionString
128705 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
128706 :
128707 : // *** COMMON CODE SECTION BEGINS HERE ***
128708 :
128709 : #if 0
128710 : int
128711 : SgBlockDataStatement::getVariant() const
128712 : {
128713 : // This function is used in ROSE while "variant()" is used in SAGE
128714 : assert(this != NULL);
128715 : return variant();
128716 : }
128717 : #endif
128718 :
128719 : // This function is used in ROSE in treeTraversal code
128720 : // eventually replaces getVariant() and variant()
128721 : // though after variant() has been removed for a while we will
128722 : // want to change the name of variantT() back to variant()
128723 : // (since the "T" was ment to stand for temporary).
128724 : // When this happens the variantT() will be depricated.
128725 : VariantT
128726 0 : SgBlockDataStatement::variantT() const
128727 : {
128728 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
128729 0 : ROSE_ASSERT(this != NULL);
128730 0 : return V_SgBlockDataStatement;
128731 : }
128732 :
128733 : #if 0
128734 : int
128735 : SgBlockDataStatement::variant() const
128736 : {
128737 : // This function is used in SAGE
128738 : ROSE_ASSERT(this != NULL);
128739 : return TEMP_Block_Data_Statement;
128740 : }
128741 : #endif
128742 :
128743 : ROSE_DLL_API const char*
128744 0 : SgBlockDataStatement::sage_class_name() const
128745 : {
128746 0 : ROSE_ASSERT(this != NULL);
128747 0 : return "SgBlockDataStatement";
128748 : }
128749 :
128750 : std::string
128751 0 : SgBlockDataStatement::class_name() const
128752 : {
128753 0 : ROSE_ASSERT(this != NULL);
128754 0 : return "SgBlockDataStatement";
128755 : }
128756 :
128757 : // DQ (11/26/2005): Support for visitor pattern mechanims
128758 : // (inferior to ROSE traversal mechanism, experimental).
128759 : void
128760 0 : SgBlockDataStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
128761 : {
128762 0 : ROSE_ASSERT(this != NULL);
128763 0 : visitor.visit(this);
128764 0 : }
128765 :
128766 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
128767 0 : void SgBlockDataStatement::accept (ROSE_VisitorPattern & visitor) {
128768 0 : ROSE_ASSERT(this != NULL);
128769 0 : visitor.visit(this);
128770 0 : }
128771 :
128772 : SgBlockDataStatement*
128773 0 : SgBlockDataStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
128774 : {
128775 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
128776 : // This function is currently only supported for the AST used the represent Binary executables.
128777 : if (0 /* isSgAsmNode(this) != NULL */)
128778 : {
128779 : // Support for regex specification.
128780 : std::string prefixCode = "REGEX:";
128781 : addNewAttribute(prefixCode + s,a);
128782 : }
128783 : #endif
128784 :
128785 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
128786 0 : return this;
128787 : }
128788 :
128789 : // *** COMMON CODE SECTION ENDS HERE ***
128790 :
128791 :
128792 : // End of memberFunctionString
128793 : // Start of memberFunctionString
128794 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
128795 :
128796 :
128797 : #if 0
128798 : //! Error checking support
128799 : /*! Verifies the following:
128800 : - working getVariant() member function
128801 : - calls base class's error() member function
128802 : Every class has one of these functions.
128803 : */
128804 : bool
128805 : SgBlockDataStatement::error()
128806 : {
128807 : // Put error checking here
128808 :
128809 : ROSE_ASSERT (this != NULL);
128810 : if (getVariant() != TEMP_Block_Data_Statement)
128811 : {
128812 : printf ("Error in SgBlockDataStatement::error(): SgBlockDataStatement object has a %s variant \n",
128813 : Cxx_GrammarTerminalNames[getVariant()].name);
128814 : // printf ("Error in SgBlockDataStatement::error() \n");
128815 : ROSE_ABORT();
128816 : }
128817 :
128818 : ROSE_ASSERT (getVariant() == TEMP_Block_Data_Statement);
128819 : return SgScopeStatement::error();
128820 : }
128821 : #endif
128822 :
128823 :
128824 :
128825 : // End of memberFunctionString
128826 :
128827 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
128828 :
128829 0 : SgBlockDataStatement* isSgBlockDataStatement ( SgNode* inputDerivedClassPointer )
128830 : {
128831 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
128832 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
128833 : // So to fix this we return NULL directly when the input is NULL and avoid the
128834 : // dynamic_cast in this case. This is likely a performance improvement as well.
128835 : // return dynamic_cast<SgBlockDataStatement*>(inputDerivedClassPointer);
128836 : // Milind Chabbi (8/28/2013): isSgBlockDataStatement uses table-driven castability instead of c++ default dynamic_cast
128837 : // this improves the running time performance by 10-20%.
128838 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBlockDataStatement*>(inputDerivedClassPointer);
128839 0 : return IS_SgBlockDataStatement_FAST_MACRO(inputDerivedClassPointer);
128840 : }
128841 :
128842 : // DQ (11/8/2003): Added version of functions taking const pointer
128843 0 : const SgBlockDataStatement* isSgBlockDataStatement ( const SgNode* inputDerivedClassPointer )
128844 : {
128845 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
128846 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
128847 : // So to fix this we return NULL directly when the input is NULL and avoid the
128848 : // dynamic_cast in this case. This is likely a performance improvement as well.
128849 : // return dynamic_cast<const SgBlockDataStatement*>(inputDerivedClassPointer);
128850 : // Milind Chabbi (8/28/2013): isSgBlockDataStatement uses table-driven castability instead of c++ default dynamic_cast
128851 : // this improves the running time performance by 10-20%.
128852 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBlockDataStatement*>(inputDerivedClassPointer);
128853 0 : return IS_SgBlockDataStatement_FAST_MACRO(inputDerivedClassPointer);
128854 : }
128855 :
128856 :
128857 :
128858 : /* #line 128859 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128859 :
128860 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
128861 :
128862 : /**
128863 : \brief Generated destructor
128864 :
128865 : This destructor is automatically generated (by ROSETTA). This destructor
128866 : only frees memory of data members associated with the parts of the current IR node which
128867 : are NOT traversed. Those data members that are part of a traversal can be freed using
128868 : a traversal (calling this destructor on all children in a post-order traversal). Such
128869 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
128870 :
128871 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
128872 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
128873 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
128874 :
128875 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
128876 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
128877 : pointers are not yet implemented to call delete on eash pointer in the container.
128878 : (This could be done by derivation from the STL containers to define containers that
128879 : automatically deleted their members.)
128880 :
128881 : */
128882 0 : SgBlockDataStatement::~SgBlockDataStatement () {
128883 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
128884 :
128885 :
128886 : // case: not a listType for body
128887 0 : p_body = NULL; // non list case
128888 :
128889 : }
128890 :
128891 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
128892 0 : }
128893 :
128894 :
128895 : /* #line 128896 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128896 :
128897 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
128898 :
128899 : // Generated constructor
128900 0 : SgBlockDataStatement::SgBlockDataStatement ( Sg_File_Info* startOfConstruct )
128901 0 : : SgScopeStatement(startOfConstruct)
128902 : {
128903 : #ifdef DEBUG
128904 : // printf ("In SgBlockDataStatement::SgBlockDataStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
128905 : #endif
128906 : #if 0
128907 : // debugging information!
128908 : printf ("In SgBlockDataStatement::SgBlockDataStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
128909 : #endif
128910 :
128911 0 : p_body = NULL;
128912 :
128913 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
128914 :
128915 : #if 0
128916 : // DQ (7/30/2014): Call a virtual function.
128917 : std::string s = this->class_name();
128918 : #endif
128919 :
128920 : // Test the variant virtual function
128921 : // assert(TEMP_Block_Data_Statement == variant());
128922 0 : assert(TEMP_Block_Data_Statement == this->variant());
128923 0 : ROSE_ASSERT(TEMP_Block_Data_Statement == (int)(this->variantT()));
128924 0 : post_construction_initialization();
128925 :
128926 : // Test the isSgBlockDataStatement() function since it has been problematic
128927 0 : assert(isSgBlockDataStatement(this) != NULL);
128928 0 : }
128929 :
128930 : // Generated constructor (all data members)
128931 :
128932 : /* #line 128933 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128933 :
128934 :
128935 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
128936 :
128937 :
128938 : // ********************************************************
128939 : // member functions common across all array grammar objects
128940 : // ********************************************************
128941 :
128942 :
128943 :
128944 : /* #line 128945 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128945 :
128946 :
128947 :
128948 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
128949 :
128950 : // ********************************************************
128951 : // member functions specific to each node in the grammar
128952 : // ********************************************************
128953 :
128954 :
128955 : /* #line 128956 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
128956 :
128957 : // Start of memberFunctionString
128958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
128959 :
128960 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128961 :
128962 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
128963 : const SgDeclarationStatementPtrList &
128964 0 : SgAssociateStatement::get_associates () const
128965 : {
128966 0 : assert (this != NULL);
128967 0 : return p_associates;
128968 : }
128969 :
128970 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
128971 : SgDeclarationStatementPtrList &
128972 0 : SgAssociateStatement::get_associates ()
128973 : {
128974 0 : assert (this != NULL);
128975 :
128976 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
128977 : // As a rule only set_ access functions can set the isModified flag.
128978 : // set_isModified(true);
128979 :
128980 0 : return p_associates;
128981 : }
128982 :
128983 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
128984 :
128985 :
128986 : // End of memberFunctionString
128987 : // Start of memberFunctionString
128988 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
128989 :
128990 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
128991 :
128992 : SgBasicBlock*
128993 0 : SgAssociateStatement::get_body () const
128994 : {
128995 0 : ROSE_ASSERT (this != NULL);
128996 :
128997 : #if 0
128998 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
128999 : // used to trigger marking transformations for the token-based unparsing.
129000 : printf ("SgAssociateStatement::get_body = %p = %s \n",this,this->class_name().c_str());
129001 : #endif
129002 :
129003 0 : return p_body;
129004 : }
129005 :
129006 : void
129007 0 : SgAssociateStatement::set_body ( SgBasicBlock* body )
129008 : {
129009 0 : ROSE_ASSERT (this != NULL);
129010 :
129011 : #if 0
129012 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129013 : // used to trigger marking transformations for the token-based unparsing.
129014 : printf ("SgAssociateStatement::set_body = %p = %s \n",this,this->class_name().c_str());
129015 : #endif
129016 :
129017 0 : set_isModified(true);
129018 :
129019 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
129020 : if (p_body != NULL && body != NULL && p_body != body)
129021 : {
129022 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
129023 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
129024 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
129025 : ROSE_ASSERT(false);
129026 : #endif
129027 : }
129028 : #endif
129029 0 : p_body = body;
129030 0 : }
129031 :
129032 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129033 :
129034 :
129035 : // End of memberFunctionString
129036 : // Start of memberFunctionString
129037 : /* #line 18871 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
129038 :
129039 :
129040 : void
129041 0 : SgAssociateStatement::post_construction_initialization()
129042 0 : {}
129043 :
129044 : SgName
129045 0 : SgAssociateStatement::get_mangled_name(void) const
129046 : {
129047 0 : return SgName ("__associate__");
129048 : }
129049 :
129050 : void
129051 0 : SgAssociateStatement::prepend_associate(SgDeclarationStatement *what)
129052 : {
129053 0 : get_associates().insert(get_associates().begin(), what);
129054 0 : what->set_parent(this);
129055 0 : ROSE_ASSERT(what->get_parent() != NULL);
129056 0 : }
129057 :
129058 : void
129059 0 : SgAssociateStatement::append_associate(SgDeclarationStatement *what)
129060 : {
129061 0 : get_associates().push_back(what);
129062 0 : what->set_parent(this);
129063 0 : ROSE_ASSERT(what->get_parent() != NULL);
129064 0 : }
129065 :
129066 :
129067 : // End of memberFunctionString
129068 : // Start of memberFunctionString
129069 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
129070 :
129071 : // *** COMMON CODE SECTION BEGINS HERE ***
129072 :
129073 : #if 0
129074 : int
129075 : SgAssociateStatement::getVariant() const
129076 : {
129077 : // This function is used in ROSE while "variant()" is used in SAGE
129078 : assert(this != NULL);
129079 : return variant();
129080 : }
129081 : #endif
129082 :
129083 : // This function is used in ROSE in treeTraversal code
129084 : // eventually replaces getVariant() and variant()
129085 : // though after variant() has been removed for a while we will
129086 : // want to change the name of variantT() back to variant()
129087 : // (since the "T" was ment to stand for temporary).
129088 : // When this happens the variantT() will be depricated.
129089 : VariantT
129090 0 : SgAssociateStatement::variantT() const
129091 : {
129092 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
129093 0 : ROSE_ASSERT(this != NULL);
129094 0 : return V_SgAssociateStatement;
129095 : }
129096 :
129097 : #if 0
129098 : int
129099 : SgAssociateStatement::variant() const
129100 : {
129101 : // This function is used in SAGE
129102 : ROSE_ASSERT(this != NULL);
129103 : return TEMP_Associate_Statement;
129104 : }
129105 : #endif
129106 :
129107 : ROSE_DLL_API const char*
129108 0 : SgAssociateStatement::sage_class_name() const
129109 : {
129110 0 : ROSE_ASSERT(this != NULL);
129111 0 : return "SgAssociateStatement";
129112 : }
129113 :
129114 : std::string
129115 0 : SgAssociateStatement::class_name() const
129116 : {
129117 0 : ROSE_ASSERT(this != NULL);
129118 0 : return "SgAssociateStatement";
129119 : }
129120 :
129121 : // DQ (11/26/2005): Support for visitor pattern mechanims
129122 : // (inferior to ROSE traversal mechanism, experimental).
129123 : void
129124 0 : SgAssociateStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
129125 : {
129126 0 : ROSE_ASSERT(this != NULL);
129127 0 : visitor.visit(this);
129128 0 : }
129129 :
129130 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
129131 0 : void SgAssociateStatement::accept (ROSE_VisitorPattern & visitor) {
129132 0 : ROSE_ASSERT(this != NULL);
129133 0 : visitor.visit(this);
129134 0 : }
129135 :
129136 : SgAssociateStatement*
129137 0 : SgAssociateStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
129138 : {
129139 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
129140 : // This function is currently only supported for the AST used the represent Binary executables.
129141 : if (0 /* isSgAsmNode(this) != NULL */)
129142 : {
129143 : // Support for regex specification.
129144 : std::string prefixCode = "REGEX:";
129145 : addNewAttribute(prefixCode + s,a);
129146 : }
129147 : #endif
129148 :
129149 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
129150 0 : return this;
129151 : }
129152 :
129153 : // *** COMMON CODE SECTION ENDS HERE ***
129154 :
129155 :
129156 : // End of memberFunctionString
129157 : // Start of memberFunctionString
129158 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
129159 :
129160 :
129161 : #if 0
129162 : //! Error checking support
129163 : /*! Verifies the following:
129164 : - working getVariant() member function
129165 : - calls base class's error() member function
129166 : Every class has one of these functions.
129167 : */
129168 : bool
129169 : SgAssociateStatement::error()
129170 : {
129171 : // Put error checking here
129172 :
129173 : ROSE_ASSERT (this != NULL);
129174 : if (getVariant() != TEMP_Associate_Statement)
129175 : {
129176 : printf ("Error in SgAssociateStatement::error(): SgAssociateStatement object has a %s variant \n",
129177 : Cxx_GrammarTerminalNames[getVariant()].name);
129178 : // printf ("Error in SgAssociateStatement::error() \n");
129179 : ROSE_ABORT();
129180 : }
129181 :
129182 : ROSE_ASSERT (getVariant() == TEMP_Associate_Statement);
129183 : return SgScopeStatement::error();
129184 : }
129185 : #endif
129186 :
129187 :
129188 :
129189 : // End of memberFunctionString
129190 :
129191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
129192 :
129193 0 : SgAssociateStatement* isSgAssociateStatement ( SgNode* inputDerivedClassPointer )
129194 : {
129195 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
129196 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
129197 : // So to fix this we return NULL directly when the input is NULL and avoid the
129198 : // dynamic_cast in this case. This is likely a performance improvement as well.
129199 : // return dynamic_cast<SgAssociateStatement*>(inputDerivedClassPointer);
129200 : // Milind Chabbi (8/28/2013): isSgAssociateStatement uses table-driven castability instead of c++ default dynamic_cast
129201 : // this improves the running time performance by 10-20%.
129202 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAssociateStatement*>(inputDerivedClassPointer);
129203 0 : return IS_SgAssociateStatement_FAST_MACRO(inputDerivedClassPointer);
129204 : }
129205 :
129206 : // DQ (11/8/2003): Added version of functions taking const pointer
129207 0 : const SgAssociateStatement* isSgAssociateStatement ( const SgNode* inputDerivedClassPointer )
129208 : {
129209 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
129210 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
129211 : // So to fix this we return NULL directly when the input is NULL and avoid the
129212 : // dynamic_cast in this case. This is likely a performance improvement as well.
129213 : // return dynamic_cast<const SgAssociateStatement*>(inputDerivedClassPointer);
129214 : // Milind Chabbi (8/28/2013): isSgAssociateStatement uses table-driven castability instead of c++ default dynamic_cast
129215 : // this improves the running time performance by 10-20%.
129216 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAssociateStatement*>(inputDerivedClassPointer);
129217 0 : return IS_SgAssociateStatement_FAST_MACRO(inputDerivedClassPointer);
129218 : }
129219 :
129220 :
129221 :
129222 : /* #line 129223 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129223 :
129224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
129225 :
129226 : /**
129227 : \brief Generated destructor
129228 :
129229 : This destructor is automatically generated (by ROSETTA). This destructor
129230 : only frees memory of data members associated with the parts of the current IR node which
129231 : are NOT traversed. Those data members that are part of a traversal can be freed using
129232 : a traversal (calling this destructor on all children in a post-order traversal). Such
129233 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
129234 :
129235 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
129236 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
129237 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
129238 :
129239 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
129240 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
129241 : pointers are not yet implemented to call delete on eash pointer in the container.
129242 : (This could be done by derivation from the STL containers to define containers that
129243 : automatically deleted their members.)
129244 :
129245 : */
129246 0 : SgAssociateStatement::~SgAssociateStatement () {
129247 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
129248 :
129249 :
129250 : // case: not a listType for body
129251 0 : p_body = NULL; // non list case
129252 :
129253 : }
129254 :
129255 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
129256 0 : }
129257 :
129258 :
129259 : /* #line 129260 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129260 :
129261 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
129262 :
129263 : // Generated constructor
129264 0 : SgAssociateStatement::SgAssociateStatement ( Sg_File_Info* startOfConstruct )
129265 0 : : SgScopeStatement(startOfConstruct)
129266 : {
129267 : #ifdef DEBUG
129268 : // printf ("In SgAssociateStatement::SgAssociateStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
129269 : #endif
129270 : #if 0
129271 : // debugging information!
129272 : printf ("In SgAssociateStatement::SgAssociateStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
129273 : #endif
129274 :
129275 0 : p_body = NULL;
129276 :
129277 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
129278 :
129279 : #if 0
129280 : // DQ (7/30/2014): Call a virtual function.
129281 : std::string s = this->class_name();
129282 : #endif
129283 :
129284 : // Test the variant virtual function
129285 : // assert(TEMP_Associate_Statement == variant());
129286 0 : assert(TEMP_Associate_Statement == this->variant());
129287 0 : ROSE_ASSERT(TEMP_Associate_Statement == (int)(this->variantT()));
129288 0 : post_construction_initialization();
129289 :
129290 : // Test the isSgAssociateStatement() function since it has been problematic
129291 0 : assert(isSgAssociateStatement(this) != NULL);
129292 0 : }
129293 :
129294 : // Generated constructor (all data members)
129295 :
129296 : /* #line 129297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129297 :
129298 :
129299 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
129300 :
129301 :
129302 : // ********************************************************
129303 : // member functions common across all array grammar objects
129304 : // ********************************************************
129305 :
129306 :
129307 :
129308 : /* #line 129309 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129309 :
129310 :
129311 :
129312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
129313 :
129314 : // ********************************************************
129315 : // member functions specific to each node in the grammar
129316 : // ********************************************************
129317 :
129318 :
129319 : /* #line 129320 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129320 :
129321 : // Start of memberFunctionString
129322 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129323 :
129324 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129325 :
129326 : SgExpression*
129327 21 : SgFortranDo::get_initialization () const
129328 : {
129329 21 : ROSE_ASSERT (this != NULL);
129330 :
129331 : #if 0
129332 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129333 : // used to trigger marking transformations for the token-based unparsing.
129334 : printf ("SgFortranDo::get_initialization = %p = %s \n",this,this->class_name().c_str());
129335 : #endif
129336 :
129337 21 : return p_initialization;
129338 : }
129339 :
129340 : void
129341 0 : SgFortranDo::set_initialization ( SgExpression* initialization )
129342 : {
129343 0 : ROSE_ASSERT (this != NULL);
129344 :
129345 : #if 0
129346 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129347 : // used to trigger marking transformations for the token-based unparsing.
129348 : printf ("SgFortranDo::set_initialization = %p = %s \n",this,this->class_name().c_str());
129349 : #endif
129350 :
129351 0 : set_isModified(true);
129352 :
129353 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
129354 : if (p_initialization != NULL && initialization != NULL && p_initialization != initialization)
129355 : {
129356 : printf ("Warning: initialization = %p overwriting valid pointer p_initialization = %p \n",initialization,p_initialization);
129357 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
129358 : printf ("Error fails assertion (p_initialization != NULL && initialization != NULL && p_initialization != initialization) is false\n");
129359 : ROSE_ASSERT(false);
129360 : #endif
129361 : }
129362 : #endif
129363 0 : p_initialization = initialization;
129364 0 : }
129365 :
129366 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129367 :
129368 :
129369 : // End of memberFunctionString
129370 : // Start of memberFunctionString
129371 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129372 :
129373 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129374 :
129375 : SgExpression*
129376 21 : SgFortranDo::get_bound () const
129377 : {
129378 21 : ROSE_ASSERT (this != NULL);
129379 :
129380 : #if 0
129381 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129382 : // used to trigger marking transformations for the token-based unparsing.
129383 : printf ("SgFortranDo::get_bound = %p = %s \n",this,this->class_name().c_str());
129384 : #endif
129385 :
129386 21 : return p_bound;
129387 : }
129388 :
129389 : void
129390 0 : SgFortranDo::set_bound ( SgExpression* bound )
129391 : {
129392 0 : ROSE_ASSERT (this != NULL);
129393 :
129394 : #if 0
129395 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129396 : // used to trigger marking transformations for the token-based unparsing.
129397 : printf ("SgFortranDo::set_bound = %p = %s \n",this,this->class_name().c_str());
129398 : #endif
129399 :
129400 0 : set_isModified(true);
129401 :
129402 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
129403 : if (p_bound != NULL && bound != NULL && p_bound != bound)
129404 : {
129405 : printf ("Warning: bound = %p overwriting valid pointer p_bound = %p \n",bound,p_bound);
129406 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
129407 : printf ("Error fails assertion (p_bound != NULL && bound != NULL && p_bound != bound) is false\n");
129408 : ROSE_ASSERT(false);
129409 : #endif
129410 : }
129411 : #endif
129412 0 : p_bound = bound;
129413 0 : }
129414 :
129415 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129416 :
129417 :
129418 : // End of memberFunctionString
129419 : // Start of memberFunctionString
129420 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129421 :
129422 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129423 :
129424 : SgExpression*
129425 24 : SgFortranDo::get_increment () const
129426 : {
129427 24 : ROSE_ASSERT (this != NULL);
129428 :
129429 : #if 0
129430 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129431 : // used to trigger marking transformations for the token-based unparsing.
129432 : printf ("SgFortranDo::get_increment = %p = %s \n",this,this->class_name().c_str());
129433 : #endif
129434 :
129435 24 : return p_increment;
129436 : }
129437 :
129438 : void
129439 2 : SgFortranDo::set_increment ( SgExpression* increment )
129440 : {
129441 2 : ROSE_ASSERT (this != NULL);
129442 :
129443 : #if 0
129444 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129445 : // used to trigger marking transformations for the token-based unparsing.
129446 : printf ("SgFortranDo::set_increment = %p = %s \n",this,this->class_name().c_str());
129447 : #endif
129448 :
129449 2 : set_isModified(true);
129450 :
129451 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
129452 : if (p_increment != NULL && increment != NULL && p_increment != increment)
129453 : {
129454 : printf ("Warning: increment = %p overwriting valid pointer p_increment = %p \n",increment,p_increment);
129455 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
129456 : printf ("Error fails assertion (p_increment != NULL && increment != NULL && p_increment != increment) is false\n");
129457 : ROSE_ASSERT(false);
129458 : #endif
129459 : }
129460 : #endif
129461 2 : p_increment = increment;
129462 2 : }
129463 :
129464 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129465 :
129466 :
129467 : // End of memberFunctionString
129468 : // Start of memberFunctionString
129469 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129470 :
129471 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129472 :
129473 : SgBasicBlock*
129474 94 : SgFortranDo::get_body () const
129475 : {
129476 94 : ROSE_ASSERT (this != NULL);
129477 :
129478 : #if 0
129479 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129480 : // used to trigger marking transformations for the token-based unparsing.
129481 : printf ("SgFortranDo::get_body = %p = %s \n",this,this->class_name().c_str());
129482 : #endif
129483 :
129484 94 : return p_body;
129485 : }
129486 :
129487 : void
129488 0 : SgFortranDo::set_body ( SgBasicBlock* body )
129489 : {
129490 0 : ROSE_ASSERT (this != NULL);
129491 :
129492 : #if 0
129493 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129494 : // used to trigger marking transformations for the token-based unparsing.
129495 : printf ("SgFortranDo::set_body = %p = %s \n",this,this->class_name().c_str());
129496 : #endif
129497 :
129498 0 : set_isModified(true);
129499 :
129500 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
129501 : if (p_body != NULL && body != NULL && p_body != body)
129502 : {
129503 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
129504 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
129505 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
129506 : ROSE_ASSERT(false);
129507 : #endif
129508 : }
129509 : #endif
129510 0 : p_body = body;
129511 0 : }
129512 :
129513 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129514 :
129515 :
129516 : // End of memberFunctionString
129517 : // Start of memberFunctionString
129518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129519 :
129520 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129521 :
129522 : SgLabelRefExp*
129523 42 : SgFortranDo::get_end_numeric_label () const
129524 : {
129525 42 : ROSE_ASSERT (this != NULL);
129526 :
129527 : #if 0
129528 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129529 : // used to trigger marking transformations for the token-based unparsing.
129530 : printf ("SgFortranDo::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
129531 : #endif
129532 :
129533 42 : return p_end_numeric_label;
129534 : }
129535 :
129536 : void
129537 2 : SgFortranDo::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
129538 : {
129539 2 : ROSE_ASSERT (this != NULL);
129540 :
129541 : #if 0
129542 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129543 : // used to trigger marking transformations for the token-based unparsing.
129544 : printf ("SgFortranDo::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
129545 : #endif
129546 :
129547 2 : set_isModified(true);
129548 :
129549 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
129550 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
129551 : {
129552 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
129553 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
129554 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
129555 : ROSE_ASSERT(false);
129556 : #endif
129557 : }
129558 : #endif
129559 2 : p_end_numeric_label = end_numeric_label;
129560 2 : }
129561 :
129562 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129563 :
129564 :
129565 : // End of memberFunctionString
129566 : // Start of memberFunctionString
129567 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129568 :
129569 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129570 :
129571 : std::string
129572 40 : SgFortranDo::get_string_label () const
129573 : {
129574 40 : ROSE_ASSERT (this != NULL);
129575 :
129576 : #if 0
129577 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129578 : // used to trigger marking transformations for the token-based unparsing.
129579 : printf ("SgFortranDo::get_string_label = %p = %s \n",this,this->class_name().c_str());
129580 : #endif
129581 :
129582 40 : return p_string_label;
129583 : }
129584 :
129585 : void
129586 0 : SgFortranDo::set_string_label ( std::string string_label )
129587 : {
129588 0 : ROSE_ASSERT (this != NULL);
129589 :
129590 : #if 0
129591 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129592 : // used to trigger marking transformations for the token-based unparsing.
129593 : printf ("SgFortranDo::set_string_label = %p = %s \n",this,this->class_name().c_str());
129594 : #endif
129595 :
129596 0 : set_isModified(true);
129597 :
129598 0 : p_string_label = string_label;
129599 0 : }
129600 :
129601 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129602 :
129603 :
129604 : // End of memberFunctionString
129605 : // Start of memberFunctionString
129606 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129607 :
129608 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129609 :
129610 : bool
129611 0 : SgFortranDo::get_old_style () const
129612 : {
129613 0 : ROSE_ASSERT (this != NULL);
129614 :
129615 : #if 0
129616 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129617 : // used to trigger marking transformations for the token-based unparsing.
129618 : printf ("SgFortranDo::get_old_style = %p = %s \n",this,this->class_name().c_str());
129619 : #endif
129620 :
129621 0 : return p_old_style;
129622 : }
129623 :
129624 : void
129625 0 : SgFortranDo::set_old_style ( bool old_style )
129626 : {
129627 0 : ROSE_ASSERT (this != NULL);
129628 :
129629 : #if 0
129630 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129631 : // used to trigger marking transformations for the token-based unparsing.
129632 : printf ("SgFortranDo::set_old_style = %p = %s \n",this,this->class_name().c_str());
129633 : #endif
129634 :
129635 0 : set_isModified(true);
129636 :
129637 0 : p_old_style = old_style;
129638 0 : }
129639 :
129640 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129641 :
129642 :
129643 : // End of memberFunctionString
129644 : // Start of memberFunctionString
129645 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129646 :
129647 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129648 :
129649 : bool
129650 21 : SgFortranDo::get_has_end_statement () const
129651 : {
129652 21 : ROSE_ASSERT (this != NULL);
129653 :
129654 : #if 0
129655 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129656 : // used to trigger marking transformations for the token-based unparsing.
129657 : printf ("SgFortranDo::get_has_end_statement = %p = %s \n",this,this->class_name().c_str());
129658 : #endif
129659 :
129660 21 : return p_has_end_statement;
129661 : }
129662 :
129663 : void
129664 19 : SgFortranDo::set_has_end_statement ( bool has_end_statement )
129665 : {
129666 19 : ROSE_ASSERT (this != NULL);
129667 :
129668 : #if 0
129669 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129670 : // used to trigger marking transformations for the token-based unparsing.
129671 : printf ("SgFortranDo::set_has_end_statement = %p = %s \n",this,this->class_name().c_str());
129672 : #endif
129673 :
129674 19 : set_isModified(true);
129675 :
129676 19 : p_has_end_statement = has_end_statement;
129677 19 : }
129678 :
129679 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
129680 :
129681 :
129682 : // End of memberFunctionString
129683 : // Start of memberFunctionString
129684 : /* #line 18468 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
129685 :
129686 : void
129687 21 : SgFortranDo::post_construction_initialization()
129688 : {
129689 21 : }
129690 :
129691 : // Liao (3/11/2009): Added to provide uniform support of mangle names for all scopes
129692 : SgName
129693 0 : SgFortranDo::get_mangled_name(void) const
129694 : {
129695 0 : return SgName ("");
129696 : }
129697 :
129698 :
129699 :
129700 : // End of memberFunctionString
129701 : // Start of memberFunctionString
129702 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
129703 :
129704 : // *** COMMON CODE SECTION BEGINS HERE ***
129705 :
129706 : #if 0
129707 : int
129708 : SgFortranDo::getVariant() const
129709 : {
129710 : // This function is used in ROSE while "variant()" is used in SAGE
129711 : assert(this != NULL);
129712 : return variant();
129713 : }
129714 : #endif
129715 :
129716 : // This function is used in ROSE in treeTraversal code
129717 : // eventually replaces getVariant() and variant()
129718 : // though after variant() has been removed for a while we will
129719 : // want to change the name of variantT() back to variant()
129720 : // (since the "T" was ment to stand for temporary).
129721 : // When this happens the variantT() will be depricated.
129722 : VariantT
129723 15474 : SgFortranDo::variantT() const
129724 : {
129725 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
129726 15474 : ROSE_ASSERT(this != NULL);
129727 15474 : return V_SgFortranDo;
129728 : }
129729 :
129730 : #if 0
129731 : int
129732 : SgFortranDo::variant() const
129733 : {
129734 : // This function is used in SAGE
129735 : ROSE_ASSERT(this != NULL);
129736 : return FORTRAN_DO;
129737 : }
129738 : #endif
129739 :
129740 : ROSE_DLL_API const char*
129741 42 : SgFortranDo::sage_class_name() const
129742 : {
129743 42 : ROSE_ASSERT(this != NULL);
129744 42 : return "SgFortranDo";
129745 : }
129746 :
129747 : std::string
129748 21 : SgFortranDo::class_name() const
129749 : {
129750 21 : ROSE_ASSERT(this != NULL);
129751 21 : return "SgFortranDo";
129752 : }
129753 :
129754 : // DQ (11/26/2005): Support for visitor pattern mechanims
129755 : // (inferior to ROSE traversal mechanism, experimental).
129756 : void
129757 0 : SgFortranDo::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
129758 : {
129759 0 : ROSE_ASSERT(this != NULL);
129760 0 : visitor.visit(this);
129761 0 : }
129762 :
129763 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
129764 0 : void SgFortranDo::accept (ROSE_VisitorPattern & visitor) {
129765 0 : ROSE_ASSERT(this != NULL);
129766 0 : visitor.visit(this);
129767 0 : }
129768 :
129769 : SgFortranDo*
129770 0 : SgFortranDo::addRegExpAttribute(std::string s, AstRegExAttribute* a)
129771 : {
129772 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
129773 : // This function is currently only supported for the AST used the represent Binary executables.
129774 : if (0 /* isSgAsmNode(this) != NULL */)
129775 : {
129776 : // Support for regex specification.
129777 : std::string prefixCode = "REGEX:";
129778 : addNewAttribute(prefixCode + s,a);
129779 : }
129780 : #endif
129781 :
129782 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
129783 0 : return this;
129784 : }
129785 :
129786 : // *** COMMON CODE SECTION ENDS HERE ***
129787 :
129788 :
129789 : // End of memberFunctionString
129790 : // Start of memberFunctionString
129791 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
129792 :
129793 :
129794 : #if 0
129795 : //! Error checking support
129796 : /*! Verifies the following:
129797 : - working getVariant() member function
129798 : - calls base class's error() member function
129799 : Every class has one of these functions.
129800 : */
129801 : bool
129802 : SgFortranDo::error()
129803 : {
129804 : // Put error checking here
129805 :
129806 : ROSE_ASSERT (this != NULL);
129807 : if (getVariant() != FORTRAN_DO)
129808 : {
129809 : printf ("Error in SgFortranDo::error(): SgFortranDo object has a %s variant \n",
129810 : Cxx_GrammarTerminalNames[getVariant()].name);
129811 : // printf ("Error in SgFortranDo::error() \n");
129812 : ROSE_ABORT();
129813 : }
129814 :
129815 : ROSE_ASSERT (getVariant() == FORTRAN_DO);
129816 : return SgScopeStatement::error();
129817 : }
129818 : #endif
129819 :
129820 :
129821 :
129822 : // End of memberFunctionString
129823 :
129824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
129825 :
129826 158 : SgFortranDo* isSgFortranDo ( SgNode* inputDerivedClassPointer )
129827 : {
129828 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
129829 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
129830 : // So to fix this we return NULL directly when the input is NULL and avoid the
129831 : // dynamic_cast in this case. This is likely a performance improvement as well.
129832 : // return dynamic_cast<SgFortranDo*>(inputDerivedClassPointer);
129833 : // Milind Chabbi (8/28/2013): isSgFortranDo uses table-driven castability instead of c++ default dynamic_cast
129834 : // this improves the running time performance by 10-20%.
129835 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFortranDo*>(inputDerivedClassPointer);
129836 158 : return IS_SgFortranDo_FAST_MACRO(inputDerivedClassPointer);
129837 : }
129838 :
129839 : // DQ (11/8/2003): Added version of functions taking const pointer
129840 21 : const SgFortranDo* isSgFortranDo ( const SgNode* inputDerivedClassPointer )
129841 : {
129842 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
129843 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
129844 : // So to fix this we return NULL directly when the input is NULL and avoid the
129845 : // dynamic_cast in this case. This is likely a performance improvement as well.
129846 : // return dynamic_cast<const SgFortranDo*>(inputDerivedClassPointer);
129847 : // Milind Chabbi (8/28/2013): isSgFortranDo uses table-driven castability instead of c++ default dynamic_cast
129848 : // this improves the running time performance by 10-20%.
129849 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFortranDo*>(inputDerivedClassPointer);
129850 21 : return IS_SgFortranDo_FAST_MACRO(inputDerivedClassPointer);
129851 : }
129852 :
129853 :
129854 :
129855 : /* #line 129856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129856 :
129857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
129858 :
129859 : /**
129860 : \brief Generated destructor
129861 :
129862 : This destructor is automatically generated (by ROSETTA). This destructor
129863 : only frees memory of data members associated with the parts of the current IR node which
129864 : are NOT traversed. Those data members that are part of a traversal can be freed using
129865 : a traversal (calling this destructor on all children in a post-order traversal). Such
129866 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
129867 :
129868 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
129869 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
129870 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
129871 :
129872 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
129873 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
129874 : pointers are not yet implemented to call delete on eash pointer in the container.
129875 : (This could be done by derivation from the STL containers to define containers that
129876 : automatically deleted their members.)
129877 :
129878 : */
129879 0 : SgFortranDo::~SgFortranDo () {
129880 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
129881 :
129882 :
129883 : // case: not a listType for initialization
129884 0 : p_initialization = NULL; // non list case
129885 : // case: not a listType for bound
129886 0 : p_bound = NULL; // non list case
129887 : // case: not a listType for increment
129888 0 : p_increment = NULL; // non list case
129889 : // case: not a listType for body
129890 0 : p_body = NULL; // non list case
129891 : // case: not a listType for end_numeric_label
129892 0 : p_end_numeric_label = NULL; // non list case
129893 : // case: not a listType for string_label
129894 0 : p_string_label = ""; // non list case
129895 : // case: not a listType for old_style
129896 0 : p_old_style = false; // non list case
129897 : // case: not a listType for has_end_statement
129898 0 : p_has_end_statement = false; // non list case
129899 :
129900 : }
129901 :
129902 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
129903 0 : }
129904 :
129905 :
129906 : /* #line 129907 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129907 :
129908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
129909 :
129910 : // Generated constructor
129911 0 : SgFortranDo::SgFortranDo ( Sg_File_Info* startOfConstruct, SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* body )
129912 0 : : SgScopeStatement(startOfConstruct)
129913 : {
129914 : #ifdef DEBUG
129915 : // printf ("In SgFortranDo::SgFortranDo (Sg_File_Info* startOfConstruct, SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* body) sage_class_name() = %s \n",sage_class_name());
129916 : #endif
129917 : #if 0
129918 : // debugging information!
129919 : printf ("In SgFortranDo::SgFortranDo (Sg_File_Info* startOfConstruct, SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* body): this = %p = %s \n",this,this->class_name().c_str());
129920 : #endif
129921 :
129922 0 : p_initialization = initialization;
129923 0 : p_bound = bound;
129924 0 : p_increment = increment;
129925 0 : p_body = body;
129926 0 : p_end_numeric_label = NULL;
129927 0 : p_string_label = "";
129928 0 : p_old_style = false;
129929 0 : p_has_end_statement = false;
129930 :
129931 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
129932 :
129933 : #if 0
129934 : // DQ (7/30/2014): Call a virtual function.
129935 : std::string s = this->class_name();
129936 : #endif
129937 :
129938 : // Test the variant virtual function
129939 : // assert(FORTRAN_DO == variant());
129940 0 : assert(FORTRAN_DO == this->variant());
129941 0 : ROSE_ASSERT(FORTRAN_DO == (int)(this->variantT()));
129942 0 : post_construction_initialization();
129943 :
129944 : // Test the isSgFortranDo() function since it has been problematic
129945 0 : assert(isSgFortranDo(this) != NULL);
129946 0 : }
129947 :
129948 : // Generated constructor (all data members)
129949 :
129950 : /* #line 129951 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129951 :
129952 :
129953 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
129954 :
129955 :
129956 : // ********************************************************
129957 : // member functions common across all array grammar objects
129958 : // ********************************************************
129959 :
129960 :
129961 :
129962 : /* #line 129963 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129963 :
129964 :
129965 :
129966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
129967 :
129968 : // ********************************************************
129969 : // member functions specific to each node in the grammar
129970 : // ********************************************************
129971 :
129972 :
129973 : /* #line 129974 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
129974 :
129975 : // Start of memberFunctionString
129976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
129977 :
129978 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
129979 :
129980 : SgStatement*
129981 0 : SgFortranNonblockedDo::get_end_statement () const
129982 : {
129983 0 : ROSE_ASSERT (this != NULL);
129984 :
129985 : #if 0
129986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
129987 : // used to trigger marking transformations for the token-based unparsing.
129988 : printf ("SgFortranNonblockedDo::get_end_statement = %p = %s \n",this,this->class_name().c_str());
129989 : #endif
129990 :
129991 0 : return p_end_statement;
129992 : }
129993 :
129994 : void
129995 0 : SgFortranNonblockedDo::set_end_statement ( SgStatement* end_statement )
129996 : {
129997 0 : ROSE_ASSERT (this != NULL);
129998 :
129999 : #if 0
130000 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130001 : // used to trigger marking transformations for the token-based unparsing.
130002 : printf ("SgFortranNonblockedDo::set_end_statement = %p = %s \n",this,this->class_name().c_str());
130003 : #endif
130004 :
130005 0 : set_isModified(true);
130006 :
130007 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130008 : if (p_end_statement != NULL && end_statement != NULL && p_end_statement != end_statement)
130009 : {
130010 : printf ("Warning: end_statement = %p overwriting valid pointer p_end_statement = %p \n",end_statement,p_end_statement);
130011 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130012 : printf ("Error fails assertion (p_end_statement != NULL && end_statement != NULL && p_end_statement != end_statement) is false\n");
130013 : ROSE_ASSERT(false);
130014 : #endif
130015 : }
130016 : #endif
130017 0 : p_end_statement = end_statement;
130018 0 : }
130019 :
130020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130021 :
130022 :
130023 : // End of memberFunctionString
130024 : // Start of memberFunctionString
130025 : /* #line 18484 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
130026 :
130027 : void
130028 0 : SgFortranNonblockedDo::post_construction_initialization()
130029 : {
130030 0 : }
130031 :
130032 :
130033 :
130034 : // End of memberFunctionString
130035 : // Start of memberFunctionString
130036 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
130037 :
130038 : // *** COMMON CODE SECTION BEGINS HERE ***
130039 :
130040 : #if 0
130041 : int
130042 : SgFortranNonblockedDo::getVariant() const
130043 : {
130044 : // This function is used in ROSE while "variant()" is used in SAGE
130045 : assert(this != NULL);
130046 : return variant();
130047 : }
130048 : #endif
130049 :
130050 : // This function is used in ROSE in treeTraversal code
130051 : // eventually replaces getVariant() and variant()
130052 : // though after variant() has been removed for a while we will
130053 : // want to change the name of variantT() back to variant()
130054 : // (since the "T" was ment to stand for temporary).
130055 : // When this happens the variantT() will be depricated.
130056 : VariantT
130057 0 : SgFortranNonblockedDo::variantT() const
130058 : {
130059 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
130060 0 : ROSE_ASSERT(this != NULL);
130061 0 : return V_SgFortranNonblockedDo;
130062 : }
130063 :
130064 : #if 0
130065 : int
130066 : SgFortranNonblockedDo::variant() const
130067 : {
130068 : // This function is used in SAGE
130069 : ROSE_ASSERT(this != NULL);
130070 : return FORTRAN_NONBLOCKED_DO;
130071 : }
130072 : #endif
130073 :
130074 : ROSE_DLL_API const char*
130075 0 : SgFortranNonblockedDo::sage_class_name() const
130076 : {
130077 0 : ROSE_ASSERT(this != NULL);
130078 0 : return "SgFortranNonblockedDo";
130079 : }
130080 :
130081 : std::string
130082 0 : SgFortranNonblockedDo::class_name() const
130083 : {
130084 0 : ROSE_ASSERT(this != NULL);
130085 0 : return "SgFortranNonblockedDo";
130086 : }
130087 :
130088 : // DQ (11/26/2005): Support for visitor pattern mechanims
130089 : // (inferior to ROSE traversal mechanism, experimental).
130090 : void
130091 0 : SgFortranNonblockedDo::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
130092 : {
130093 0 : ROSE_ASSERT(this != NULL);
130094 0 : visitor.visit(this);
130095 0 : }
130096 :
130097 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
130098 0 : void SgFortranNonblockedDo::accept (ROSE_VisitorPattern & visitor) {
130099 0 : ROSE_ASSERT(this != NULL);
130100 0 : visitor.visit(this);
130101 0 : }
130102 :
130103 : SgFortranNonblockedDo*
130104 0 : SgFortranNonblockedDo::addRegExpAttribute(std::string s, AstRegExAttribute* a)
130105 : {
130106 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
130107 : // This function is currently only supported for the AST used the represent Binary executables.
130108 : if (0 /* isSgAsmNode(this) != NULL */)
130109 : {
130110 : // Support for regex specification.
130111 : std::string prefixCode = "REGEX:";
130112 : addNewAttribute(prefixCode + s,a);
130113 : }
130114 : #endif
130115 :
130116 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
130117 0 : return this;
130118 : }
130119 :
130120 : // *** COMMON CODE SECTION ENDS HERE ***
130121 :
130122 :
130123 : // End of memberFunctionString
130124 : // Start of memberFunctionString
130125 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
130126 :
130127 :
130128 : #if 0
130129 : //! Error checking support
130130 : /*! Verifies the following:
130131 : - working getVariant() member function
130132 : - calls base class's error() member function
130133 : Every class has one of these functions.
130134 : */
130135 : bool
130136 : SgFortranNonblockedDo::error()
130137 : {
130138 : // Put error checking here
130139 :
130140 : ROSE_ASSERT (this != NULL);
130141 : if (getVariant() != FORTRAN_NONBLOCKED_DO)
130142 : {
130143 : printf ("Error in SgFortranNonblockedDo::error(): SgFortranNonblockedDo object has a %s variant \n",
130144 : Cxx_GrammarTerminalNames[getVariant()].name);
130145 : // printf ("Error in SgFortranNonblockedDo::error() \n");
130146 : ROSE_ABORT();
130147 : }
130148 :
130149 : ROSE_ASSERT (getVariant() == FORTRAN_NONBLOCKED_DO);
130150 : return SgFortranDo::error();
130151 : }
130152 : #endif
130153 :
130154 :
130155 :
130156 : // End of memberFunctionString
130157 :
130158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
130159 :
130160 0 : SgFortranNonblockedDo* isSgFortranNonblockedDo ( SgNode* inputDerivedClassPointer )
130161 : {
130162 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
130163 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
130164 : // So to fix this we return NULL directly when the input is NULL and avoid the
130165 : // dynamic_cast in this case. This is likely a performance improvement as well.
130166 : // return dynamic_cast<SgFortranNonblockedDo*>(inputDerivedClassPointer);
130167 : // Milind Chabbi (8/28/2013): isSgFortranNonblockedDo uses table-driven castability instead of c++ default dynamic_cast
130168 : // this improves the running time performance by 10-20%.
130169 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFortranNonblockedDo*>(inputDerivedClassPointer);
130170 0 : return IS_SgFortranNonblockedDo_FAST_MACRO(inputDerivedClassPointer);
130171 : }
130172 :
130173 : // DQ (11/8/2003): Added version of functions taking const pointer
130174 0 : const SgFortranNonblockedDo* isSgFortranNonblockedDo ( const SgNode* inputDerivedClassPointer )
130175 : {
130176 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
130177 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
130178 : // So to fix this we return NULL directly when the input is NULL and avoid the
130179 : // dynamic_cast in this case. This is likely a performance improvement as well.
130180 : // return dynamic_cast<const SgFortranNonblockedDo*>(inputDerivedClassPointer);
130181 : // Milind Chabbi (8/28/2013): isSgFortranNonblockedDo uses table-driven castability instead of c++ default dynamic_cast
130182 : // this improves the running time performance by 10-20%.
130183 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFortranNonblockedDo*>(inputDerivedClassPointer);
130184 0 : return IS_SgFortranNonblockedDo_FAST_MACRO(inputDerivedClassPointer);
130185 : }
130186 :
130187 :
130188 :
130189 : /* #line 130190 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130190 :
130191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
130192 :
130193 : /**
130194 : \brief Generated destructor
130195 :
130196 : This destructor is automatically generated (by ROSETTA). This destructor
130197 : only frees memory of data members associated with the parts of the current IR node which
130198 : are NOT traversed. Those data members that are part of a traversal can be freed using
130199 : a traversal (calling this destructor on all children in a post-order traversal). Such
130200 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
130201 :
130202 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
130203 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
130204 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
130205 :
130206 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
130207 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
130208 : pointers are not yet implemented to call delete on eash pointer in the container.
130209 : (This could be done by derivation from the STL containers to define containers that
130210 : automatically deleted their members.)
130211 :
130212 : */
130213 0 : SgFortranNonblockedDo::~SgFortranNonblockedDo () {
130214 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
130215 :
130216 :
130217 : // case: not a listType for end_statement
130218 0 : p_end_statement = NULL; // non list case
130219 :
130220 : }
130221 :
130222 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
130223 0 : }
130224 :
130225 :
130226 : /* #line 130227 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130227 :
130228 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
130229 :
130230 : // Generated constructor
130231 0 : SgFortranNonblockedDo::SgFortranNonblockedDo ( Sg_File_Info* startOfConstruct, SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* body, SgStatement* end_statement )
130232 0 : : SgFortranDo(startOfConstruct, initialization, bound, increment, body)
130233 : {
130234 : #ifdef DEBUG
130235 : // printf ("In SgFortranNonblockedDo::SgFortranNonblockedDo (Sg_File_Info* startOfConstruct, SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* body, SgStatement* end_statement) sage_class_name() = %s \n",sage_class_name());
130236 : #endif
130237 : #if 0
130238 : // debugging information!
130239 : printf ("In SgFortranNonblockedDo::SgFortranNonblockedDo (Sg_File_Info* startOfConstruct, SgExpression* initialization, SgExpression* bound, SgExpression* increment, SgBasicBlock* body, SgStatement* end_statement): this = %p = %s \n",this,this->class_name().c_str());
130240 : #endif
130241 :
130242 0 : p_end_statement = end_statement;
130243 :
130244 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
130245 :
130246 : #if 0
130247 : // DQ (7/30/2014): Call a virtual function.
130248 : std::string s = this->class_name();
130249 : #endif
130250 :
130251 : // Test the variant virtual function
130252 : // assert(FORTRAN_NONBLOCKED_DO == variant());
130253 0 : assert(FORTRAN_NONBLOCKED_DO == this->variant());
130254 0 : ROSE_ASSERT(FORTRAN_NONBLOCKED_DO == (int)(this->variantT()));
130255 0 : post_construction_initialization();
130256 :
130257 : // Test the isSgFortranNonblockedDo() function since it has been problematic
130258 0 : assert(isSgFortranNonblockedDo(this) != NULL);
130259 0 : }
130260 :
130261 : // Generated constructor (all data members)
130262 :
130263 : /* #line 130264 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130264 :
130265 :
130266 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
130267 :
130268 :
130269 : // ********************************************************
130270 : // member functions common across all array grammar objects
130271 : // ********************************************************
130272 :
130273 :
130274 :
130275 : /* #line 130276 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130276 :
130277 :
130278 :
130279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
130280 :
130281 : // ********************************************************
130282 : // member functions specific to each node in the grammar
130283 : // ********************************************************
130284 :
130285 :
130286 : /* #line 130287 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130287 :
130288 : // Start of memberFunctionString
130289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130290 :
130291 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130292 :
130293 : SgExprListExp*
130294 0 : SgForAllStatement::get_forall_header () const
130295 : {
130296 0 : ROSE_ASSERT (this != NULL);
130297 :
130298 : #if 0
130299 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130300 : // used to trigger marking transformations for the token-based unparsing.
130301 : printf ("SgForAllStatement::get_forall_header = %p = %s \n",this,this->class_name().c_str());
130302 : #endif
130303 :
130304 0 : return p_forall_header;
130305 : }
130306 :
130307 : void
130308 0 : SgForAllStatement::set_forall_header ( SgExprListExp* forall_header )
130309 : {
130310 0 : ROSE_ASSERT (this != NULL);
130311 :
130312 : #if 0
130313 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130314 : // used to trigger marking transformations for the token-based unparsing.
130315 : printf ("SgForAllStatement::set_forall_header = %p = %s \n",this,this->class_name().c_str());
130316 : #endif
130317 :
130318 0 : set_isModified(true);
130319 :
130320 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130321 : if (p_forall_header != NULL && forall_header != NULL && p_forall_header != forall_header)
130322 : {
130323 : printf ("Warning: forall_header = %p overwriting valid pointer p_forall_header = %p \n",forall_header,p_forall_header);
130324 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130325 : printf ("Error fails assertion (p_forall_header != NULL && forall_header != NULL && p_forall_header != forall_header) is false\n");
130326 : ROSE_ASSERT(false);
130327 : #endif
130328 : }
130329 : #endif
130330 0 : p_forall_header = forall_header;
130331 0 : }
130332 :
130333 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130334 :
130335 :
130336 : // End of memberFunctionString
130337 : // Start of memberFunctionString
130338 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130339 :
130340 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130341 :
130342 : SgBasicBlock*
130343 0 : SgForAllStatement::get_body () const
130344 : {
130345 0 : ROSE_ASSERT (this != NULL);
130346 :
130347 : #if 0
130348 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130349 : // used to trigger marking transformations for the token-based unparsing.
130350 : printf ("SgForAllStatement::get_body = %p = %s \n",this,this->class_name().c_str());
130351 : #endif
130352 :
130353 0 : return p_body;
130354 : }
130355 :
130356 : void
130357 0 : SgForAllStatement::set_body ( SgBasicBlock* body )
130358 : {
130359 0 : ROSE_ASSERT (this != NULL);
130360 :
130361 : #if 0
130362 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130363 : // used to trigger marking transformations for the token-based unparsing.
130364 : printf ("SgForAllStatement::set_body = %p = %s \n",this,this->class_name().c_str());
130365 : #endif
130366 :
130367 0 : set_isModified(true);
130368 :
130369 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130370 : if (p_body != NULL && body != NULL && p_body != body)
130371 : {
130372 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
130373 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130374 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
130375 : ROSE_ASSERT(false);
130376 : #endif
130377 : }
130378 : #endif
130379 0 : p_body = body;
130380 0 : }
130381 :
130382 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130383 :
130384 :
130385 : // End of memberFunctionString
130386 : // Start of memberFunctionString
130387 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130388 :
130389 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130390 :
130391 : bool
130392 0 : SgForAllStatement::get_has_end_statement () const
130393 : {
130394 0 : ROSE_ASSERT (this != NULL);
130395 :
130396 : #if 0
130397 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130398 : // used to trigger marking transformations for the token-based unparsing.
130399 : printf ("SgForAllStatement::get_has_end_statement = %p = %s \n",this,this->class_name().c_str());
130400 : #endif
130401 :
130402 0 : return p_has_end_statement;
130403 : }
130404 :
130405 : void
130406 0 : SgForAllStatement::set_has_end_statement ( bool has_end_statement )
130407 : {
130408 0 : ROSE_ASSERT (this != NULL);
130409 :
130410 : #if 0
130411 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130412 : // used to trigger marking transformations for the token-based unparsing.
130413 : printf ("SgForAllStatement::set_has_end_statement = %p = %s \n",this,this->class_name().c_str());
130414 : #endif
130415 :
130416 0 : set_isModified(true);
130417 :
130418 0 : p_has_end_statement = has_end_statement;
130419 0 : }
130420 :
130421 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130422 :
130423 :
130424 : // End of memberFunctionString
130425 : // Start of memberFunctionString
130426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130427 :
130428 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130429 :
130430 : std::string
130431 0 : SgForAllStatement::get_string_label () const
130432 : {
130433 0 : ROSE_ASSERT (this != NULL);
130434 :
130435 : #if 0
130436 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130437 : // used to trigger marking transformations for the token-based unparsing.
130438 : printf ("SgForAllStatement::get_string_label = %p = %s \n",this,this->class_name().c_str());
130439 : #endif
130440 :
130441 0 : return p_string_label;
130442 : }
130443 :
130444 : void
130445 0 : SgForAllStatement::set_string_label ( std::string string_label )
130446 : {
130447 0 : ROSE_ASSERT (this != NULL);
130448 :
130449 : #if 0
130450 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130451 : // used to trigger marking transformations for the token-based unparsing.
130452 : printf ("SgForAllStatement::set_string_label = %p = %s \n",this,this->class_name().c_str());
130453 : #endif
130454 :
130455 0 : set_isModified(true);
130456 :
130457 0 : p_string_label = string_label;
130458 0 : }
130459 :
130460 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130461 :
130462 :
130463 : // End of memberFunctionString
130464 : // Start of memberFunctionString
130465 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130466 :
130467 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130468 :
130469 : SgLabelRefExp*
130470 0 : SgForAllStatement::get_end_numeric_label () const
130471 : {
130472 0 : ROSE_ASSERT (this != NULL);
130473 :
130474 : #if 0
130475 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130476 : // used to trigger marking transformations for the token-based unparsing.
130477 : printf ("SgForAllStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
130478 : #endif
130479 :
130480 0 : return p_end_numeric_label;
130481 : }
130482 :
130483 : void
130484 0 : SgForAllStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
130485 : {
130486 0 : ROSE_ASSERT (this != NULL);
130487 :
130488 : #if 0
130489 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130490 : // used to trigger marking transformations for the token-based unparsing.
130491 : printf ("SgForAllStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
130492 : #endif
130493 :
130494 0 : set_isModified(true);
130495 :
130496 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130497 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
130498 : {
130499 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
130500 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130501 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
130502 : ROSE_ASSERT(false);
130503 : #endif
130504 : }
130505 : #endif
130506 0 : p_end_numeric_label = end_numeric_label;
130507 0 : }
130508 :
130509 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130510 :
130511 :
130512 : // End of memberFunctionString
130513 : // Start of memberFunctionString
130514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130515 :
130516 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130517 :
130518 : SgForAllStatement::forall_statement_kind_enum
130519 0 : SgForAllStatement::get_forall_statement_kind () const
130520 : {
130521 0 : ROSE_ASSERT (this != NULL);
130522 :
130523 : #if 0
130524 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130525 : // used to trigger marking transformations for the token-based unparsing.
130526 : printf ("SgForAllStatement::get_forall_statement_kind = %p = %s \n",this,this->class_name().c_str());
130527 : #endif
130528 :
130529 0 : return p_forall_statement_kind;
130530 : }
130531 :
130532 : void
130533 0 : SgForAllStatement::set_forall_statement_kind ( SgForAllStatement::forall_statement_kind_enum forall_statement_kind )
130534 : {
130535 0 : ROSE_ASSERT (this != NULL);
130536 :
130537 : #if 0
130538 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130539 : // used to trigger marking transformations for the token-based unparsing.
130540 : printf ("SgForAllStatement::set_forall_statement_kind = %p = %s \n",this,this->class_name().c_str());
130541 : #endif
130542 :
130543 0 : set_isModified(true);
130544 :
130545 0 : p_forall_statement_kind = forall_statement_kind;
130546 0 : }
130547 :
130548 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130549 :
130550 :
130551 : // End of memberFunctionString
130552 : // Start of memberFunctionString
130553 : /* #line 10231 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
130554 :
130555 :
130556 : void
130557 0 : SgForAllStatement::post_construction_initialization()
130558 : {
130559 : #if 0
130560 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
130561 : printf ("In SgForAllStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
130562 : #endif
130563 0 : }
130564 :
130565 :
130566 :
130567 : // End of memberFunctionString
130568 : // Start of memberFunctionString
130569 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
130570 :
130571 : // *** COMMON CODE SECTION BEGINS HERE ***
130572 :
130573 : #if 0
130574 : int
130575 : SgForAllStatement::getVariant() const
130576 : {
130577 : // This function is used in ROSE while "variant()" is used in SAGE
130578 : assert(this != NULL);
130579 : return variant();
130580 : }
130581 : #endif
130582 :
130583 : // This function is used in ROSE in treeTraversal code
130584 : // eventually replaces getVariant() and variant()
130585 : // though after variant() has been removed for a while we will
130586 : // want to change the name of variantT() back to variant()
130587 : // (since the "T" was ment to stand for temporary).
130588 : // When this happens the variantT() will be depricated.
130589 : VariantT
130590 0 : SgForAllStatement::variantT() const
130591 : {
130592 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
130593 0 : ROSE_ASSERT(this != NULL);
130594 0 : return V_SgForAllStatement;
130595 : }
130596 :
130597 : #if 0
130598 : int
130599 : SgForAllStatement::variant() const
130600 : {
130601 : // This function is used in SAGE
130602 : ROSE_ASSERT(this != NULL);
130603 : return FOR_ALL_STMT;
130604 : }
130605 : #endif
130606 :
130607 : ROSE_DLL_API const char*
130608 0 : SgForAllStatement::sage_class_name() const
130609 : {
130610 0 : ROSE_ASSERT(this != NULL);
130611 0 : return "SgForAllStatement";
130612 : }
130613 :
130614 : std::string
130615 0 : SgForAllStatement::class_name() const
130616 : {
130617 0 : ROSE_ASSERT(this != NULL);
130618 0 : return "SgForAllStatement";
130619 : }
130620 :
130621 : // DQ (11/26/2005): Support for visitor pattern mechanims
130622 : // (inferior to ROSE traversal mechanism, experimental).
130623 : void
130624 0 : SgForAllStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
130625 : {
130626 0 : ROSE_ASSERT(this != NULL);
130627 0 : visitor.visit(this);
130628 0 : }
130629 :
130630 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
130631 0 : void SgForAllStatement::accept (ROSE_VisitorPattern & visitor) {
130632 0 : ROSE_ASSERT(this != NULL);
130633 0 : visitor.visit(this);
130634 0 : }
130635 :
130636 : SgForAllStatement*
130637 0 : SgForAllStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
130638 : {
130639 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
130640 : // This function is currently only supported for the AST used the represent Binary executables.
130641 : if (0 /* isSgAsmNode(this) != NULL */)
130642 : {
130643 : // Support for regex specification.
130644 : std::string prefixCode = "REGEX:";
130645 : addNewAttribute(prefixCode + s,a);
130646 : }
130647 : #endif
130648 :
130649 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
130650 0 : return this;
130651 : }
130652 :
130653 : // *** COMMON CODE SECTION ENDS HERE ***
130654 :
130655 :
130656 : // End of memberFunctionString
130657 : // Start of memberFunctionString
130658 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
130659 :
130660 :
130661 : #if 0
130662 : //! Error checking support
130663 : /*! Verifies the following:
130664 : - working getVariant() member function
130665 : - calls base class's error() member function
130666 : Every class has one of these functions.
130667 : */
130668 : bool
130669 : SgForAllStatement::error()
130670 : {
130671 : // Put error checking here
130672 :
130673 : ROSE_ASSERT (this != NULL);
130674 : if (getVariant() != FOR_ALL_STMT)
130675 : {
130676 : printf ("Error in SgForAllStatement::error(): SgForAllStatement object has a %s variant \n",
130677 : Cxx_GrammarTerminalNames[getVariant()].name);
130678 : // printf ("Error in SgForAllStatement::error() \n");
130679 : ROSE_ABORT();
130680 : }
130681 :
130682 : ROSE_ASSERT (getVariant() == FOR_ALL_STMT);
130683 : return SgScopeStatement::error();
130684 : }
130685 : #endif
130686 :
130687 :
130688 :
130689 : // End of memberFunctionString
130690 :
130691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
130692 :
130693 19 : SgForAllStatement* isSgForAllStatement ( SgNode* inputDerivedClassPointer )
130694 : {
130695 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
130696 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
130697 : // So to fix this we return NULL directly when the input is NULL and avoid the
130698 : // dynamic_cast in this case. This is likely a performance improvement as well.
130699 : // return dynamic_cast<SgForAllStatement*>(inputDerivedClassPointer);
130700 : // Milind Chabbi (8/28/2013): isSgForAllStatement uses table-driven castability instead of c++ default dynamic_cast
130701 : // this improves the running time performance by 10-20%.
130702 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgForAllStatement*>(inputDerivedClassPointer);
130703 19 : return IS_SgForAllStatement_FAST_MACRO(inputDerivedClassPointer);
130704 : }
130705 :
130706 : // DQ (11/8/2003): Added version of functions taking const pointer
130707 0 : const SgForAllStatement* isSgForAllStatement ( const SgNode* inputDerivedClassPointer )
130708 : {
130709 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
130710 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
130711 : // So to fix this we return NULL directly when the input is NULL and avoid the
130712 : // dynamic_cast in this case. This is likely a performance improvement as well.
130713 : // return dynamic_cast<const SgForAllStatement*>(inputDerivedClassPointer);
130714 : // Milind Chabbi (8/28/2013): isSgForAllStatement uses table-driven castability instead of c++ default dynamic_cast
130715 : // this improves the running time performance by 10-20%.
130716 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgForAllStatement*>(inputDerivedClassPointer);
130717 0 : return IS_SgForAllStatement_FAST_MACRO(inputDerivedClassPointer);
130718 : }
130719 :
130720 :
130721 :
130722 : /* #line 130723 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130723 :
130724 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
130725 :
130726 : /**
130727 : \brief Generated destructor
130728 :
130729 : This destructor is automatically generated (by ROSETTA). This destructor
130730 : only frees memory of data members associated with the parts of the current IR node which
130731 : are NOT traversed. Those data members that are part of a traversal can be freed using
130732 : a traversal (calling this destructor on all children in a post-order traversal). Such
130733 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
130734 :
130735 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
130736 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
130737 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
130738 :
130739 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
130740 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
130741 : pointers are not yet implemented to call delete on eash pointer in the container.
130742 : (This could be done by derivation from the STL containers to define containers that
130743 : automatically deleted their members.)
130744 :
130745 : */
130746 0 : SgForAllStatement::~SgForAllStatement () {
130747 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
130748 :
130749 :
130750 : // case: not a listType for forall_header
130751 0 : p_forall_header = NULL; // non list case
130752 : // case: not a listType for body
130753 0 : p_body = NULL; // non list case
130754 : // case: not a listType for has_end_statement
130755 0 : p_has_end_statement = false; // non list case
130756 : // case: not a listType for string_label
130757 0 : p_string_label = ""; // non list case
130758 : // case: not a listType for end_numeric_label
130759 0 : p_end_numeric_label = NULL; // non list case
130760 : // case: not a listType for forall_statement_kind
130761 0 : p_forall_statement_kind = SgForAllStatement::e_forall_statement; // non list case
130762 :
130763 : }
130764 :
130765 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
130766 0 : }
130767 :
130768 :
130769 : /* #line 130770 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130770 :
130771 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
130772 :
130773 : // Generated constructor
130774 0 : SgForAllStatement::SgForAllStatement ( Sg_File_Info* startOfConstruct, SgExprListExp* forall_header, SgBasicBlock* body )
130775 0 : : SgScopeStatement(startOfConstruct)
130776 : {
130777 : #ifdef DEBUG
130778 : // printf ("In SgForAllStatement::SgForAllStatement (Sg_File_Info* startOfConstruct, SgExprListExp* forall_header, SgBasicBlock* body) sage_class_name() = %s \n",sage_class_name());
130779 : #endif
130780 : #if 0
130781 : // debugging information!
130782 : printf ("In SgForAllStatement::SgForAllStatement (Sg_File_Info* startOfConstruct, SgExprListExp* forall_header, SgBasicBlock* body): this = %p = %s \n",this,this->class_name().c_str());
130783 : #endif
130784 :
130785 0 : p_forall_header = forall_header;
130786 0 : p_body = body;
130787 0 : p_has_end_statement = false;
130788 0 : p_string_label = "";
130789 0 : p_end_numeric_label = NULL;
130790 0 : p_forall_statement_kind = SgForAllStatement::e_forall_statement;
130791 :
130792 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
130793 :
130794 : #if 0
130795 : // DQ (7/30/2014): Call a virtual function.
130796 : std::string s = this->class_name();
130797 : #endif
130798 :
130799 : // Test the variant virtual function
130800 : // assert(FOR_ALL_STMT == variant());
130801 0 : assert(FOR_ALL_STMT == this->variant());
130802 0 : ROSE_ASSERT(FOR_ALL_STMT == (int)(this->variantT()));
130803 0 : post_construction_initialization();
130804 :
130805 : // Test the isSgForAllStatement() function since it has been problematic
130806 0 : assert(isSgForAllStatement(this) != NULL);
130807 0 : }
130808 :
130809 : // Generated constructor (all data members)
130810 :
130811 : /* #line 130812 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130812 :
130813 :
130814 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
130815 :
130816 :
130817 : // ********************************************************
130818 : // member functions common across all array grammar objects
130819 : // ********************************************************
130820 :
130821 :
130822 :
130823 : /* #line 130824 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130824 :
130825 :
130826 :
130827 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
130828 :
130829 : // ********************************************************
130830 : // member functions specific to each node in the grammar
130831 : // ********************************************************
130832 :
130833 :
130834 : /* #line 130835 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
130835 :
130836 : // Start of memberFunctionString
130837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130838 :
130839 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130840 :
130841 : SgForInitStatement*
130842 0 : SgUpcForAllStatement::get_for_init_stmt () const
130843 : {
130844 0 : ROSE_ASSERT (this != NULL);
130845 :
130846 : #if 0
130847 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130848 : // used to trigger marking transformations for the token-based unparsing.
130849 : printf ("SgUpcForAllStatement::get_for_init_stmt = %p = %s \n",this,this->class_name().c_str());
130850 : #endif
130851 :
130852 0 : return p_for_init_stmt;
130853 : }
130854 :
130855 : void
130856 0 : SgUpcForAllStatement::set_for_init_stmt ( SgForInitStatement* for_init_stmt )
130857 : {
130858 0 : ROSE_ASSERT (this != NULL);
130859 :
130860 : #if 0
130861 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130862 : // used to trigger marking transformations for the token-based unparsing.
130863 : printf ("SgUpcForAllStatement::set_for_init_stmt = %p = %s \n",this,this->class_name().c_str());
130864 : #endif
130865 :
130866 0 : set_isModified(true);
130867 :
130868 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130869 : if (p_for_init_stmt != NULL && for_init_stmt != NULL && p_for_init_stmt != for_init_stmt)
130870 : {
130871 : printf ("Warning: for_init_stmt = %p overwriting valid pointer p_for_init_stmt = %p \n",for_init_stmt,p_for_init_stmt);
130872 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130873 : printf ("Error fails assertion (p_for_init_stmt != NULL && for_init_stmt != NULL && p_for_init_stmt != for_init_stmt) is false\n");
130874 : ROSE_ASSERT(false);
130875 : #endif
130876 : }
130877 : #endif
130878 0 : p_for_init_stmt = for_init_stmt;
130879 0 : }
130880 :
130881 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130882 :
130883 :
130884 : // End of memberFunctionString
130885 : // Start of memberFunctionString
130886 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130887 :
130888 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130889 :
130890 : SgStatement*
130891 0 : SgUpcForAllStatement::get_test () const
130892 : {
130893 0 : ROSE_ASSERT (this != NULL);
130894 :
130895 : #if 0
130896 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130897 : // used to trigger marking transformations for the token-based unparsing.
130898 : printf ("SgUpcForAllStatement::get_test = %p = %s \n",this,this->class_name().c_str());
130899 : #endif
130900 :
130901 0 : return p_test;
130902 : }
130903 :
130904 : void
130905 0 : SgUpcForAllStatement::set_test ( SgStatement* test )
130906 : {
130907 0 : ROSE_ASSERT (this != NULL);
130908 :
130909 : #if 0
130910 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130911 : // used to trigger marking transformations for the token-based unparsing.
130912 : printf ("SgUpcForAllStatement::set_test = %p = %s \n",this,this->class_name().c_str());
130913 : #endif
130914 :
130915 0 : set_isModified(true);
130916 :
130917 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130918 : if (p_test != NULL && test != NULL && p_test != test)
130919 : {
130920 : printf ("Warning: test = %p overwriting valid pointer p_test = %p \n",test,p_test);
130921 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130922 : printf ("Error fails assertion (p_test != NULL && test != NULL && p_test != test) is false\n");
130923 : ROSE_ASSERT(false);
130924 : #endif
130925 : }
130926 : #endif
130927 0 : p_test = test;
130928 0 : }
130929 :
130930 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130931 :
130932 :
130933 : // End of memberFunctionString
130934 : // Start of memberFunctionString
130935 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130936 :
130937 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130938 :
130939 : SgExpression*
130940 0 : SgUpcForAllStatement::get_increment () const
130941 : {
130942 0 : ROSE_ASSERT (this != NULL);
130943 :
130944 : #if 0
130945 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130946 : // used to trigger marking transformations for the token-based unparsing.
130947 : printf ("SgUpcForAllStatement::get_increment = %p = %s \n",this,this->class_name().c_str());
130948 : #endif
130949 :
130950 0 : return p_increment;
130951 : }
130952 :
130953 : void
130954 0 : SgUpcForAllStatement::set_increment ( SgExpression* increment )
130955 : {
130956 0 : ROSE_ASSERT (this != NULL);
130957 :
130958 : #if 0
130959 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130960 : // used to trigger marking transformations for the token-based unparsing.
130961 : printf ("SgUpcForAllStatement::set_increment = %p = %s \n",this,this->class_name().c_str());
130962 : #endif
130963 :
130964 0 : set_isModified(true);
130965 :
130966 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
130967 : if (p_increment != NULL && increment != NULL && p_increment != increment)
130968 : {
130969 : printf ("Warning: increment = %p overwriting valid pointer p_increment = %p \n",increment,p_increment);
130970 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
130971 : printf ("Error fails assertion (p_increment != NULL && increment != NULL && p_increment != increment) is false\n");
130972 : ROSE_ASSERT(false);
130973 : #endif
130974 : }
130975 : #endif
130976 0 : p_increment = increment;
130977 0 : }
130978 :
130979 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
130980 :
130981 :
130982 : // End of memberFunctionString
130983 : // Start of memberFunctionString
130984 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
130985 :
130986 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
130987 :
130988 : SgExpression*
130989 0 : SgUpcForAllStatement::get_affinity () const
130990 : {
130991 0 : ROSE_ASSERT (this != NULL);
130992 :
130993 : #if 0
130994 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
130995 : // used to trigger marking transformations for the token-based unparsing.
130996 : printf ("SgUpcForAllStatement::get_affinity = %p = %s \n",this,this->class_name().c_str());
130997 : #endif
130998 :
130999 0 : return p_affinity;
131000 : }
131001 :
131002 : void
131003 0 : SgUpcForAllStatement::set_affinity ( SgExpression* affinity )
131004 : {
131005 0 : ROSE_ASSERT (this != NULL);
131006 :
131007 : #if 0
131008 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131009 : // used to trigger marking transformations for the token-based unparsing.
131010 : printf ("SgUpcForAllStatement::set_affinity = %p = %s \n",this,this->class_name().c_str());
131011 : #endif
131012 :
131013 0 : set_isModified(true);
131014 :
131015 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
131016 : if (p_affinity != NULL && affinity != NULL && p_affinity != affinity)
131017 : {
131018 : printf ("Warning: affinity = %p overwriting valid pointer p_affinity = %p \n",affinity,p_affinity);
131019 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
131020 : printf ("Error fails assertion (p_affinity != NULL && affinity != NULL && p_affinity != affinity) is false\n");
131021 : ROSE_ASSERT(false);
131022 : #endif
131023 : }
131024 : #endif
131025 0 : p_affinity = affinity;
131026 0 : }
131027 :
131028 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
131029 :
131030 :
131031 : // End of memberFunctionString
131032 : // Start of memberFunctionString
131033 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
131034 :
131035 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
131036 :
131037 : SgStatement*
131038 0 : SgUpcForAllStatement::get_loop_body () const
131039 : {
131040 0 : ROSE_ASSERT (this != NULL);
131041 :
131042 : #if 0
131043 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131044 : // used to trigger marking transformations for the token-based unparsing.
131045 : printf ("SgUpcForAllStatement::get_loop_body = %p = %s \n",this,this->class_name().c_str());
131046 : #endif
131047 :
131048 0 : return p_loop_body;
131049 : }
131050 :
131051 : void
131052 0 : SgUpcForAllStatement::set_loop_body ( SgStatement* loop_body )
131053 : {
131054 0 : ROSE_ASSERT (this != NULL);
131055 :
131056 : #if 0
131057 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131058 : // used to trigger marking transformations for the token-based unparsing.
131059 : printf ("SgUpcForAllStatement::set_loop_body = %p = %s \n",this,this->class_name().c_str());
131060 : #endif
131061 :
131062 0 : set_isModified(true);
131063 :
131064 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
131065 : if (p_loop_body != NULL && loop_body != NULL && p_loop_body != loop_body)
131066 : {
131067 : printf ("Warning: loop_body = %p overwriting valid pointer p_loop_body = %p \n",loop_body,p_loop_body);
131068 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
131069 : printf ("Error fails assertion (p_loop_body != NULL && loop_body != NULL && p_loop_body != loop_body) is false\n");
131070 : ROSE_ASSERT(false);
131071 : #endif
131072 : }
131073 : #endif
131074 0 : p_loop_body = loop_body;
131075 0 : }
131076 :
131077 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
131078 :
131079 :
131080 : // End of memberFunctionString
131081 : // Start of memberFunctionString
131082 : /* #line 10391 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
131083 :
131084 :
131085 0 : SgUpcForAllStatement::SgUpcForAllStatement(SgForInitStatement * init_stmt, SgStatement * test, SgExpression * increment, SgExpression * affinity, SgStatement * loop_body) :
131086 : SgScopeStatement(),
131087 : p_for_init_stmt(init_stmt),
131088 : p_test(test),
131089 : p_increment(increment),
131090 : p_affinity(affinity),
131091 0 : p_loop_body(loop_body)
131092 : {
131093 0 : post_construction_initialization();
131094 0 : }
131095 :
131096 : // Liao, we have to duplicate most code from SgForStatement since
131097 : // SgUpcForAllStatement and SgForStatement are not related
131098 : // Copy the member functions from SgForStatement below:
131099 : void
131100 0 : SgUpcForAllStatement::post_construction_initialization()
131101 : {
131102 0 : if (p_for_init_stmt == NULL) {
131103 : // SgForInitStatement* forInitStatement = new SgForInitStatement(New_File_Info(this));
131104 0 : SgForInitStatement* forInitStatement = NULL;
131105 0 : if (get_startOfConstruct() != NULL)
131106 : {
131107 0 : forInitStatement = new SgForInitStatement(New_File_Info(this));
131108 :
131109 : // DQ (10/27/2006): This will have to be updated after construction,
131110 : // since we don't know the ending position at this point!
131111 0 : forInitStatement->set_endOfConstruct(New_File_Info(this));
131112 :
131113 : // DQ (12/17/2006): Fixup the parents of Sg_File_Info objects
131114 0 : forInitStatement->get_startOfConstruct()->set_parent(forInitStatement);
131115 0 : forInitStatement->get_endOfConstruct()->set_parent(forInitStatement);
131116 : }
131117 : else
131118 : {
131119 0 : forInitStatement = new SgForInitStatement();
131120 : }
131121 :
131122 0 : ROSE_ASSERT(forInitStatement != NULL);
131123 :
131124 : // All SgUpcForAllStatement IR nodes should have a valid SgForInitStatement (even if it is an empty list!).
131125 0 : set_for_init_stmt(forInitStatement);
131126 : }
131127 :
131128 0 : p_for_init_stmt->set_parent(this);
131129 :
131130 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
131131 0 : if (p_test != NULL)
131132 : {
131133 0 : p_test->set_parent(this);
131134 : }
131135 :
131136 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
131137 0 : if (p_increment != NULL)
131138 : {
131139 0 : p_increment->set_parent(this);
131140 : }
131141 :
131142 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
131143 0 : if (p_affinity != NULL)
131144 : {
131145 0 : p_affinity->set_parent(this);
131146 : }
131147 :
131148 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
131149 0 : if (p_loop_body != NULL)
131150 : {
131151 0 : p_loop_body->set_parent(this);
131152 : }
131153 0 : }
131154 :
131155 : // MS: moved StatementPtrList to ForInitStatement. Therefore the call is simply forwarded and the same interface
131156 : SgStatementPtrList &
131157 0 : SgUpcForAllStatement::get_init_stmt()
131158 : {
131159 : // DQ (6/24/2006): If this is always true then we can simplify this function.
131160 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
131161 0 : return get_for_init_stmt()->get_init_stmt();
131162 : }
131163 :
131164 : const SgStatementPtrList &
131165 0 : SgUpcForAllStatement::get_init_stmt() const
131166 : {
131167 : // DQ (6/24/2006): When we later simplify the append, prepend, insert functions this will be important.
131168 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
131169 :
131170 0 : return get_for_init_stmt()->get_init_stmt();
131171 : }
131172 :
131173 : void
131174 0 : SgUpcForAllStatement::append_init_stmt(SgStatement * what)
131175 : {
131176 : // DQ (6/24/2006): If this is always true then we can simplify this function.
131177 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
131178 0 : get_for_init_stmt()->append_init_stmt(what);
131179 0 : }
131180 :
131181 : void
131182 0 : SgUpcForAllStatement::prepend_init_stmt(SgStatement * what)
131183 : {
131184 : // DQ (6/24/2006): If this is always true then we can simplify this function.
131185 0 : ROSE_ASSERT(p_for_init_stmt != NULL);
131186 0 : get_for_init_stmt()->prepend_init_stmt(what);
131187 0 : }
131188 : bool
131189 0 : SgUpcForAllStatement::replace_child(SgStatement *target,SgStatement *newstmt,
131190 : bool extractBasicBlock)
131191 : {
131192 0 : if ( StatementReplace(this, p_loop_body, target, newstmt) == true )
131193 0 : return true;
131194 : else
131195 0 : if ( StatementReplace(this, p_for_init_stmt, target, newstmt) == true )
131196 : return true;
131197 : else
131198 0 : return false;
131199 : }
131200 :
131201 : SgExpression*
131202 0 : SgUpcForAllStatement::get_test_expr () const
131203 : {
131204 0 : ROSE_ASSERT (this != NULL);
131205 0 : ROSE_ASSERT(p_test != NULL);
131206 0 : ROSE_ASSERT(isSgStatement(p_test) != NULL);
131207 :
131208 0 : SgExpression* testExpression = NULL;
131209 0 : SgExprStatement* exprStatement = isSgExprStatement(p_test);
131210 0 : if (exprStatement != NULL)
131211 : {
131212 : // testExpression = exprStatement->get_the_expr();
131213 0 : testExpression = exprStatement->get_expression();
131214 0 : ROSE_ASSERT(testExpression != NULL);
131215 : }
131216 : else
131217 : {
131218 0 : printf ("test in SgUpcForAllStatement is a %s \n",p_test->class_name().c_str());
131219 0 : ROSE_ASSERT(false);
131220 : }
131221 :
131222 0 : ROSE_ASSERT(testExpression != NULL);
131223 0 : return testExpression;
131224 : }
131225 : void
131226 0 : SgUpcForAllStatement::set_test_expr (SgExpression* expr )
131227 : {
131228 : // DQ (11/25/2005): preserve the previous interface. This function
131229 : // sets the SgStatement using a SgExpressionRoot IR node.
131230 0 : ROSE_ASSERT (this != NULL);
131231 0 : ROSE_ASSERT (expr != NULL);
131232 :
131233 0 : Sg_File_Info* fileInfo = New_File_Info(expr);
131234 0 : SgExprStatement* expressionStatement = new SgExprStatement(fileInfo,expr);
131235 0 : ROSE_ASSERT(expressionStatement != NULL);
131236 :
131237 : // DQ (10/27/2006): This might have to be reset later,
131238 : // since at this point we might not know the exact size.
131239 0 : expressionStatement->set_endOfConstruct(New_File_Info(expr));
131240 :
131241 0 : expressionStatement->get_startOfConstruct()->set_parent(expressionStatement);
131242 0 : expressionStatement->get_endOfConstruct()->set_parent(expressionStatement);
131243 :
131244 0 : if (get_test() != NULL)
131245 : {
131246 0 : printf ("Warning SgUpcForAllStatement::set_test_expr is clobbering the existing test statement \n");
131247 : }
131248 0 : set_test(expressionStatement);
131249 :
131250 : // DQ (4/7/2006): Set the parents
131251 0 : expressionStatement->set_parent(this);
131252 :
131253 0 : ROSE_ASSERT(isSgStatement(p_test) != NULL);
131254 0 : }
131255 : int
131256 0 : SgUpcForAllStatement::replace_expression(SgExpression * original_expression, SgExpression * new_expression )
131257 : {
131258 : // DQ (12/17/2006): This function should have the semantics that it will represent a
131259 : // structural change to the AST, thus it is free to set the parent of the new expression.
131260 :
131261 0 : ROSE_ASSERT(original_expression != NULL);
131262 0 : ROSE_ASSERT(new_expression != NULL);
131263 :
131264 0 : ROSE_ASSERT(original_expression == p_increment);
131265 :
131266 0 : set_increment(new_expression);
131267 :
131268 0 : new_expression->set_parent(this);
131269 :
131270 : // DQ: Let this be a memory leak for now to avoid initial problems.
131271 0 : ROSE_ASSERT(original_expression != NULL);
131272 : // delete original_expression;
131273 :
131274 0 : return 0;
131275 : }
131276 :
131277 : // DQ (2/22/2007): Added to provide uniform support of mangle names for all scopes
131278 : SgName
131279 0 : SgUpcForAllStatement::get_mangled_name(void) const
131280 : {
131281 0 : return SgName ("");
131282 : }
131283 :
131284 :
131285 :
131286 : // End of memberFunctionString
131287 : // Start of memberFunctionString
131288 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
131289 :
131290 : // *** COMMON CODE SECTION BEGINS HERE ***
131291 :
131292 : #if 0
131293 : int
131294 : SgUpcForAllStatement::getVariant() const
131295 : {
131296 : // This function is used in ROSE while "variant()" is used in SAGE
131297 : assert(this != NULL);
131298 : return variant();
131299 : }
131300 : #endif
131301 :
131302 : // This function is used in ROSE in treeTraversal code
131303 : // eventually replaces getVariant() and variant()
131304 : // though after variant() has been removed for a while we will
131305 : // want to change the name of variantT() back to variant()
131306 : // (since the "T" was ment to stand for temporary).
131307 : // When this happens the variantT() will be depricated.
131308 : VariantT
131309 0 : SgUpcForAllStatement::variantT() const
131310 : {
131311 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
131312 0 : ROSE_ASSERT(this != NULL);
131313 0 : return V_SgUpcForAllStatement;
131314 : }
131315 :
131316 : #if 0
131317 : int
131318 : SgUpcForAllStatement::variant() const
131319 : {
131320 : // This function is used in SAGE
131321 : ROSE_ASSERT(this != NULL);
131322 : return UPC_FORALL_STMT;
131323 : }
131324 : #endif
131325 :
131326 : ROSE_DLL_API const char*
131327 0 : SgUpcForAllStatement::sage_class_name() const
131328 : {
131329 0 : ROSE_ASSERT(this != NULL);
131330 0 : return "SgUpcForAllStatement";
131331 : }
131332 :
131333 : std::string
131334 0 : SgUpcForAllStatement::class_name() const
131335 : {
131336 0 : ROSE_ASSERT(this != NULL);
131337 0 : return "SgUpcForAllStatement";
131338 : }
131339 :
131340 : // DQ (11/26/2005): Support for visitor pattern mechanims
131341 : // (inferior to ROSE traversal mechanism, experimental).
131342 : void
131343 0 : SgUpcForAllStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
131344 : {
131345 0 : ROSE_ASSERT(this != NULL);
131346 0 : visitor.visit(this);
131347 0 : }
131348 :
131349 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
131350 0 : void SgUpcForAllStatement::accept (ROSE_VisitorPattern & visitor) {
131351 0 : ROSE_ASSERT(this != NULL);
131352 0 : visitor.visit(this);
131353 0 : }
131354 :
131355 : SgUpcForAllStatement*
131356 0 : SgUpcForAllStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
131357 : {
131358 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
131359 : // This function is currently only supported for the AST used the represent Binary executables.
131360 : if (0 /* isSgAsmNode(this) != NULL */)
131361 : {
131362 : // Support for regex specification.
131363 : std::string prefixCode = "REGEX:";
131364 : addNewAttribute(prefixCode + s,a);
131365 : }
131366 : #endif
131367 :
131368 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
131369 0 : return this;
131370 : }
131371 :
131372 : // *** COMMON CODE SECTION ENDS HERE ***
131373 :
131374 :
131375 : // End of memberFunctionString
131376 : // Start of memberFunctionString
131377 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
131378 :
131379 :
131380 : #if 0
131381 : //! Error checking support
131382 : /*! Verifies the following:
131383 : - working getVariant() member function
131384 : - calls base class's error() member function
131385 : Every class has one of these functions.
131386 : */
131387 : bool
131388 : SgUpcForAllStatement::error()
131389 : {
131390 : // Put error checking here
131391 :
131392 : ROSE_ASSERT (this != NULL);
131393 : if (getVariant() != UPC_FORALL_STMT)
131394 : {
131395 : printf ("Error in SgUpcForAllStatement::error(): SgUpcForAllStatement object has a %s variant \n",
131396 : Cxx_GrammarTerminalNames[getVariant()].name);
131397 : // printf ("Error in SgUpcForAllStatement::error() \n");
131398 : ROSE_ABORT();
131399 : }
131400 :
131401 : ROSE_ASSERT (getVariant() == UPC_FORALL_STMT);
131402 : return SgScopeStatement::error();
131403 : }
131404 : #endif
131405 :
131406 :
131407 :
131408 : // End of memberFunctionString
131409 :
131410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
131411 :
131412 903 : SgUpcForAllStatement* isSgUpcForAllStatement ( SgNode* inputDerivedClassPointer )
131413 : {
131414 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
131415 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
131416 : // So to fix this we return NULL directly when the input is NULL and avoid the
131417 : // dynamic_cast in this case. This is likely a performance improvement as well.
131418 : // return dynamic_cast<SgUpcForAllStatement*>(inputDerivedClassPointer);
131419 : // Milind Chabbi (8/28/2013): isSgUpcForAllStatement uses table-driven castability instead of c++ default dynamic_cast
131420 : // this improves the running time performance by 10-20%.
131421 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcForAllStatement*>(inputDerivedClassPointer);
131422 903 : return IS_SgUpcForAllStatement_FAST_MACRO(inputDerivedClassPointer);
131423 : }
131424 :
131425 : // DQ (11/8/2003): Added version of functions taking const pointer
131426 0 : const SgUpcForAllStatement* isSgUpcForAllStatement ( const SgNode* inputDerivedClassPointer )
131427 : {
131428 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
131429 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
131430 : // So to fix this we return NULL directly when the input is NULL and avoid the
131431 : // dynamic_cast in this case. This is likely a performance improvement as well.
131432 : // return dynamic_cast<const SgUpcForAllStatement*>(inputDerivedClassPointer);
131433 : // Milind Chabbi (8/28/2013): isSgUpcForAllStatement uses table-driven castability instead of c++ default dynamic_cast
131434 : // this improves the running time performance by 10-20%.
131435 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcForAllStatement*>(inputDerivedClassPointer);
131436 0 : return IS_SgUpcForAllStatement_FAST_MACRO(inputDerivedClassPointer);
131437 : }
131438 :
131439 :
131440 :
131441 : /* #line 131442 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131442 :
131443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
131444 :
131445 : /**
131446 : \brief Generated destructor
131447 :
131448 : This destructor is automatically generated (by ROSETTA). This destructor
131449 : only frees memory of data members associated with the parts of the current IR node which
131450 : are NOT traversed. Those data members that are part of a traversal can be freed using
131451 : a traversal (calling this destructor on all children in a post-order traversal). Such
131452 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
131453 :
131454 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
131455 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
131456 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
131457 :
131458 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
131459 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
131460 : pointers are not yet implemented to call delete on eash pointer in the container.
131461 : (This could be done by derivation from the STL containers to define containers that
131462 : automatically deleted their members.)
131463 :
131464 : */
131465 0 : SgUpcForAllStatement::~SgUpcForAllStatement () {
131466 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
131467 :
131468 :
131469 : // case: not a listType for for_init_stmt
131470 0 : p_for_init_stmt = NULL; // non list case
131471 : // case: not a listType for test
131472 0 : p_test = NULL; // non list case
131473 : // case: not a listType for increment
131474 0 : p_increment = NULL; // non list case
131475 : // case: not a listType for affinity
131476 0 : p_affinity = NULL; // non list case
131477 : // case: not a listType for loop_body
131478 0 : p_loop_body = NULL; // non list case
131479 :
131480 : }
131481 :
131482 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
131483 0 : }
131484 :
131485 :
131486 : /* #line 131487 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131487 :
131488 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
131489 :
131490 : // Generated constructor
131491 0 : SgUpcForAllStatement::SgUpcForAllStatement ( Sg_File_Info* startOfConstruct, SgStatement* test, SgExpression* increment, SgExpression* affinity, SgStatement* loop_body )
131492 0 : : SgScopeStatement(startOfConstruct)
131493 : {
131494 : #ifdef DEBUG
131495 : // printf ("In SgUpcForAllStatement::SgUpcForAllStatement (Sg_File_Info* startOfConstruct, SgStatement* test, SgExpression* increment, SgExpression* affinity, SgStatement* loop_body) sage_class_name() = %s \n",sage_class_name());
131496 : #endif
131497 : #if 0
131498 : // debugging information!
131499 : printf ("In SgUpcForAllStatement::SgUpcForAllStatement (Sg_File_Info* startOfConstruct, SgStatement* test, SgExpression* increment, SgExpression* affinity, SgStatement* loop_body): this = %p = %s \n",this,this->class_name().c_str());
131500 : #endif
131501 :
131502 0 : p_for_init_stmt = NULL;
131503 0 : p_test = test;
131504 0 : p_increment = increment;
131505 0 : p_affinity = affinity;
131506 0 : p_loop_body = loop_body;
131507 :
131508 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
131509 :
131510 : #if 0
131511 : // DQ (7/30/2014): Call a virtual function.
131512 : std::string s = this->class_name();
131513 : #endif
131514 :
131515 : // Test the variant virtual function
131516 : // assert(UPC_FORALL_STMT == variant());
131517 0 : assert(UPC_FORALL_STMT == this->variant());
131518 0 : ROSE_ASSERT(UPC_FORALL_STMT == (int)(this->variantT()));
131519 0 : post_construction_initialization();
131520 :
131521 : // Test the isSgUpcForAllStatement() function since it has been problematic
131522 0 : assert(isSgUpcForAllStatement(this) != NULL);
131523 0 : }
131524 :
131525 : // Generated constructor (all data members)
131526 :
131527 : /* #line 131528 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131528 :
131529 :
131530 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
131531 :
131532 :
131533 : // ********************************************************
131534 : // member functions common across all array grammar objects
131535 : // ********************************************************
131536 :
131537 :
131538 :
131539 : /* #line 131540 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131540 :
131541 :
131542 :
131543 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
131544 :
131545 : // ********************************************************
131546 : // member functions specific to each node in the grammar
131547 : // ********************************************************
131548 :
131549 :
131550 : /* #line 131551 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131551 :
131552 : // Start of memberFunctionString
131553 : /* #line 19565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
131554 :
131555 : void
131556 0 : SgCAFWithTeamStatement::post_construction_initialization()
131557 : {
131558 0 : }
131559 :
131560 :
131561 :
131562 : // End of memberFunctionString
131563 : // Start of memberFunctionString
131564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
131565 :
131566 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
131567 :
131568 : SgVarRefExp*
131569 0 : SgCAFWithTeamStatement::get_teamId () const
131570 : {
131571 0 : ROSE_ASSERT (this != NULL);
131572 :
131573 : #if 0
131574 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131575 : // used to trigger marking transformations for the token-based unparsing.
131576 : printf ("SgCAFWithTeamStatement::get_teamId = %p = %s \n",this,this->class_name().c_str());
131577 : #endif
131578 :
131579 0 : return p_teamId;
131580 : }
131581 :
131582 : void
131583 0 : SgCAFWithTeamStatement::set_teamId ( SgVarRefExp* teamId )
131584 : {
131585 0 : ROSE_ASSERT (this != NULL);
131586 :
131587 : #if 0
131588 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131589 : // used to trigger marking transformations for the token-based unparsing.
131590 : printf ("SgCAFWithTeamStatement::set_teamId = %p = %s \n",this,this->class_name().c_str());
131591 : #endif
131592 :
131593 0 : set_isModified(true);
131594 :
131595 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
131596 : if (p_teamId != NULL && teamId != NULL && p_teamId != teamId)
131597 : {
131598 : printf ("Warning: teamId = %p overwriting valid pointer p_teamId = %p \n",teamId,p_teamId);
131599 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
131600 : printf ("Error fails assertion (p_teamId != NULL && teamId != NULL && p_teamId != teamId) is false\n");
131601 : ROSE_ASSERT(false);
131602 : #endif
131603 : }
131604 : #endif
131605 0 : p_teamId = teamId;
131606 0 : }
131607 :
131608 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
131609 :
131610 :
131611 : // End of memberFunctionString
131612 : // Start of memberFunctionString
131613 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
131614 :
131615 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
131616 :
131617 : SgBasicBlock*
131618 0 : SgCAFWithTeamStatement::get_body () const
131619 : {
131620 0 : ROSE_ASSERT (this != NULL);
131621 :
131622 : #if 0
131623 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131624 : // used to trigger marking transformations for the token-based unparsing.
131625 : printf ("SgCAFWithTeamStatement::get_body = %p = %s \n",this,this->class_name().c_str());
131626 : #endif
131627 :
131628 0 : return p_body;
131629 : }
131630 :
131631 : void
131632 0 : SgCAFWithTeamStatement::set_body ( SgBasicBlock* body )
131633 : {
131634 0 : ROSE_ASSERT (this != NULL);
131635 :
131636 : #if 0
131637 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131638 : // used to trigger marking transformations for the token-based unparsing.
131639 : printf ("SgCAFWithTeamStatement::set_body = %p = %s \n",this,this->class_name().c_str());
131640 : #endif
131641 :
131642 0 : set_isModified(true);
131643 :
131644 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
131645 : if (p_body != NULL && body != NULL && p_body != body)
131646 : {
131647 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
131648 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
131649 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
131650 : ROSE_ASSERT(false);
131651 : #endif
131652 : }
131653 : #endif
131654 0 : p_body = body;
131655 0 : }
131656 :
131657 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
131658 :
131659 :
131660 : // End of memberFunctionString
131661 : // Start of memberFunctionString
131662 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
131663 :
131664 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
131665 :
131666 : bool
131667 0 : SgCAFWithTeamStatement::get_endHasTeamId () const
131668 : {
131669 0 : ROSE_ASSERT (this != NULL);
131670 :
131671 : #if 0
131672 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131673 : // used to trigger marking transformations for the token-based unparsing.
131674 : printf ("SgCAFWithTeamStatement::get_endHasTeamId = %p = %s \n",this,this->class_name().c_str());
131675 : #endif
131676 :
131677 0 : return p_endHasTeamId;
131678 : }
131679 :
131680 : void
131681 0 : SgCAFWithTeamStatement::set_endHasTeamId ( bool endHasTeamId )
131682 : {
131683 0 : ROSE_ASSERT (this != NULL);
131684 :
131685 : #if 0
131686 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
131687 : // used to trigger marking transformations for the token-based unparsing.
131688 : printf ("SgCAFWithTeamStatement::set_endHasTeamId = %p = %s \n",this,this->class_name().c_str());
131689 : #endif
131690 :
131691 0 : set_isModified(true);
131692 :
131693 0 : p_endHasTeamId = endHasTeamId;
131694 0 : }
131695 :
131696 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
131697 :
131698 :
131699 : // End of memberFunctionString
131700 : // Start of memberFunctionString
131701 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
131702 :
131703 : // *** COMMON CODE SECTION BEGINS HERE ***
131704 :
131705 : #if 0
131706 : int
131707 : SgCAFWithTeamStatement::getVariant() const
131708 : {
131709 : // This function is used in ROSE while "variant()" is used in SAGE
131710 : assert(this != NULL);
131711 : return variant();
131712 : }
131713 : #endif
131714 :
131715 : // This function is used in ROSE in treeTraversal code
131716 : // eventually replaces getVariant() and variant()
131717 : // though after variant() has been removed for a while we will
131718 : // want to change the name of variantT() back to variant()
131719 : // (since the "T" was ment to stand for temporary).
131720 : // When this happens the variantT() will be depricated.
131721 : VariantT
131722 0 : SgCAFWithTeamStatement::variantT() const
131723 : {
131724 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
131725 0 : ROSE_ASSERT(this != NULL);
131726 0 : return V_SgCAFWithTeamStatement;
131727 : }
131728 :
131729 : #if 0
131730 : int
131731 : SgCAFWithTeamStatement::variant() const
131732 : {
131733 : // This function is used in SAGE
131734 : ROSE_ASSERT(this != NULL);
131735 : return WITHTEAM_STMT;
131736 : }
131737 : #endif
131738 :
131739 : ROSE_DLL_API const char*
131740 0 : SgCAFWithTeamStatement::sage_class_name() const
131741 : {
131742 0 : ROSE_ASSERT(this != NULL);
131743 0 : return "SgCAFWithTeamStatement";
131744 : }
131745 :
131746 : std::string
131747 0 : SgCAFWithTeamStatement::class_name() const
131748 : {
131749 0 : ROSE_ASSERT(this != NULL);
131750 0 : return "SgCAFWithTeamStatement";
131751 : }
131752 :
131753 : // DQ (11/26/2005): Support for visitor pattern mechanims
131754 : // (inferior to ROSE traversal mechanism, experimental).
131755 : void
131756 0 : SgCAFWithTeamStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
131757 : {
131758 0 : ROSE_ASSERT(this != NULL);
131759 0 : visitor.visit(this);
131760 0 : }
131761 :
131762 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
131763 0 : void SgCAFWithTeamStatement::accept (ROSE_VisitorPattern & visitor) {
131764 0 : ROSE_ASSERT(this != NULL);
131765 0 : visitor.visit(this);
131766 0 : }
131767 :
131768 : SgCAFWithTeamStatement*
131769 0 : SgCAFWithTeamStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
131770 : {
131771 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
131772 : // This function is currently only supported for the AST used the represent Binary executables.
131773 : if (0 /* isSgAsmNode(this) != NULL */)
131774 : {
131775 : // Support for regex specification.
131776 : std::string prefixCode = "REGEX:";
131777 : addNewAttribute(prefixCode + s,a);
131778 : }
131779 : #endif
131780 :
131781 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
131782 0 : return this;
131783 : }
131784 :
131785 : // *** COMMON CODE SECTION ENDS HERE ***
131786 :
131787 :
131788 : // End of memberFunctionString
131789 : // Start of memberFunctionString
131790 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
131791 :
131792 :
131793 : #if 0
131794 : //! Error checking support
131795 : /*! Verifies the following:
131796 : - working getVariant() member function
131797 : - calls base class's error() member function
131798 : Every class has one of these functions.
131799 : */
131800 : bool
131801 : SgCAFWithTeamStatement::error()
131802 : {
131803 : // Put error checking here
131804 :
131805 : ROSE_ASSERT (this != NULL);
131806 : if (getVariant() != WITHTEAM_STMT)
131807 : {
131808 : printf ("Error in SgCAFWithTeamStatement::error(): SgCAFWithTeamStatement object has a %s variant \n",
131809 : Cxx_GrammarTerminalNames[getVariant()].name);
131810 : // printf ("Error in SgCAFWithTeamStatement::error() \n");
131811 : ROSE_ABORT();
131812 : }
131813 :
131814 : ROSE_ASSERT (getVariant() == WITHTEAM_STMT);
131815 : return SgScopeStatement::error();
131816 : }
131817 : #endif
131818 :
131819 :
131820 :
131821 : // End of memberFunctionString
131822 :
131823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
131824 :
131825 0 : SgCAFWithTeamStatement* isSgCAFWithTeamStatement ( SgNode* inputDerivedClassPointer )
131826 : {
131827 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
131828 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
131829 : // So to fix this we return NULL directly when the input is NULL and avoid the
131830 : // dynamic_cast in this case. This is likely a performance improvement as well.
131831 : // return dynamic_cast<SgCAFWithTeamStatement*>(inputDerivedClassPointer);
131832 : // Milind Chabbi (8/28/2013): isSgCAFWithTeamStatement uses table-driven castability instead of c++ default dynamic_cast
131833 : // this improves the running time performance by 10-20%.
131834 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCAFWithTeamStatement*>(inputDerivedClassPointer);
131835 0 : return IS_SgCAFWithTeamStatement_FAST_MACRO(inputDerivedClassPointer);
131836 : }
131837 :
131838 : // DQ (11/8/2003): Added version of functions taking const pointer
131839 0 : const SgCAFWithTeamStatement* isSgCAFWithTeamStatement ( const SgNode* inputDerivedClassPointer )
131840 : {
131841 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
131842 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
131843 : // So to fix this we return NULL directly when the input is NULL and avoid the
131844 : // dynamic_cast in this case. This is likely a performance improvement as well.
131845 : // return dynamic_cast<const SgCAFWithTeamStatement*>(inputDerivedClassPointer);
131846 : // Milind Chabbi (8/28/2013): isSgCAFWithTeamStatement uses table-driven castability instead of c++ default dynamic_cast
131847 : // this improves the running time performance by 10-20%.
131848 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCAFWithTeamStatement*>(inputDerivedClassPointer);
131849 0 : return IS_SgCAFWithTeamStatement_FAST_MACRO(inputDerivedClassPointer);
131850 : }
131851 :
131852 :
131853 :
131854 : /* #line 131855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131855 :
131856 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
131857 :
131858 : /**
131859 : \brief Generated destructor
131860 :
131861 : This destructor is automatically generated (by ROSETTA). This destructor
131862 : only frees memory of data members associated with the parts of the current IR node which
131863 : are NOT traversed. Those data members that are part of a traversal can be freed using
131864 : a traversal (calling this destructor on all children in a post-order traversal). Such
131865 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
131866 :
131867 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
131868 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
131869 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
131870 :
131871 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
131872 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
131873 : pointers are not yet implemented to call delete on eash pointer in the container.
131874 : (This could be done by derivation from the STL containers to define containers that
131875 : automatically deleted their members.)
131876 :
131877 : */
131878 0 : SgCAFWithTeamStatement::~SgCAFWithTeamStatement () {
131879 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
131880 :
131881 :
131882 : // case: not a listType for teamId
131883 0 : p_teamId = NULL; // non list case
131884 : // case: not a listType for body
131885 0 : p_body = NULL; // non list case
131886 : // case: not a listType for endHasTeamId
131887 0 : p_endHasTeamId = false; // non list case
131888 :
131889 : }
131890 :
131891 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
131892 0 : }
131893 :
131894 :
131895 : /* #line 131896 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131896 :
131897 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
131898 :
131899 : // Generated constructor
131900 0 : SgCAFWithTeamStatement::SgCAFWithTeamStatement ( Sg_File_Info* startOfConstruct, SgVarRefExp* teamId, SgBasicBlock* body )
131901 0 : : SgScopeStatement(startOfConstruct)
131902 : {
131903 : #ifdef DEBUG
131904 : // printf ("In SgCAFWithTeamStatement::SgCAFWithTeamStatement (Sg_File_Info* startOfConstruct, SgVarRefExp* teamId, SgBasicBlock* body) sage_class_name() = %s \n",sage_class_name());
131905 : #endif
131906 : #if 0
131907 : // debugging information!
131908 : printf ("In SgCAFWithTeamStatement::SgCAFWithTeamStatement (Sg_File_Info* startOfConstruct, SgVarRefExp* teamId, SgBasicBlock* body): this = %p = %s \n",this,this->class_name().c_str());
131909 : #endif
131910 :
131911 0 : p_teamId = teamId;
131912 0 : p_body = body;
131913 0 : p_endHasTeamId = false;
131914 :
131915 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
131916 :
131917 : #if 0
131918 : // DQ (7/30/2014): Call a virtual function.
131919 : std::string s = this->class_name();
131920 : #endif
131921 :
131922 : // Test the variant virtual function
131923 : // assert(WITHTEAM_STMT == variant());
131924 0 : assert(WITHTEAM_STMT == this->variant());
131925 0 : ROSE_ASSERT(WITHTEAM_STMT == (int)(this->variantT()));
131926 0 : post_construction_initialization();
131927 :
131928 : // Test the isSgCAFWithTeamStatement() function since it has been problematic
131929 0 : assert(isSgCAFWithTeamStatement(this) != NULL);
131930 0 : }
131931 :
131932 : // Generated constructor (all data members)
131933 :
131934 : /* #line 131935 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131935 :
131936 :
131937 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
131938 :
131939 :
131940 : // ********************************************************
131941 : // member functions common across all array grammar objects
131942 : // ********************************************************
131943 :
131944 :
131945 :
131946 : /* #line 131947 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131947 :
131948 :
131949 :
131950 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
131951 :
131952 : // ********************************************************
131953 : // member functions specific to each node in the grammar
131954 : // ********************************************************
131955 :
131956 :
131957 : /* #line 131958 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
131958 :
131959 : // Start of memberFunctionString
131960 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
131961 :
131962 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
131963 :
131964 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
131965 : const SgDeclarationStatementPtrList &
131966 0 : SgFunctionParameterScope::get_declarations () const
131967 : {
131968 0 : assert (this != NULL);
131969 0 : return p_declarations;
131970 : }
131971 :
131972 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
131973 : SgDeclarationStatementPtrList &
131974 0 : SgFunctionParameterScope::get_declarations ()
131975 : {
131976 0 : assert (this != NULL);
131977 :
131978 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
131979 : // As a rule only set_ access functions can set the isModified flag.
131980 : // set_isModified(true);
131981 :
131982 0 : return p_declarations;
131983 : }
131984 :
131985 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
131986 :
131987 :
131988 : // End of memberFunctionString
131989 : // Start of memberFunctionString
131990 : /* #line 10660 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
131991 :
131992 :
131993 : void
131994 0 : SgFunctionParameterScope::post_construction_initialization()
131995 : {
131996 : // Nothing to do here, but we need this function to be defined.
131997 0 : }
131998 :
131999 : // Rasmussen (09/24/2020): Finishing implementation of SgParameterScope for Jovial
132000 : SgName
132001 0 : SgFunctionParameterScope::get_mangled_name(void) const
132002 : {
132003 : // PP (06/01/20) - just return some name
132004 : // (or should the name be composed form the parent declaration?)
132005 0 : return SgName("__function_parameter_scope__");
132006 : }
132007 :
132008 : void
132009 0 : SgFunctionParameterScope::append_declaration(SgDeclarationStatement * what)
132010 : {
132011 0 : get_declarations().push_back(what);
132012 0 : what->set_parent(this);
132013 0 : }
132014 :
132015 : void
132016 0 : SgFunctionParameterScope::prepend_declaration(SgDeclarationStatement * what)
132017 : {
132018 0 : get_declarations().insert(get_declarations().begin(), what);
132019 0 : what->set_parent(this);
132020 0 : }
132021 :
132022 : bool
132023 0 : SgFunctionParameterScope::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractBasicBlock)
132024 : {
132025 0 : return StatementListInsertChild( this, get_declarations(), target, newstmt, inFront, extractBasicBlock, false);
132026 : }
132027 :
132028 : bool
132029 0 : SgFunctionParameterScope::replace_child(SgStatement *target ,SgStatement * newstmt, bool extractBasicBlock)
132030 : {
132031 0 : return StatementListInsertChild( this, get_declarations(), target, newstmt, true, extractBasicBlock, true);
132032 : }
132033 :
132034 :
132035 :
132036 : // End of memberFunctionString
132037 : // Start of memberFunctionString
132038 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
132039 :
132040 : // *** COMMON CODE SECTION BEGINS HERE ***
132041 :
132042 : #if 0
132043 : int
132044 : SgFunctionParameterScope::getVariant() const
132045 : {
132046 : // This function is used in ROSE while "variant()" is used in SAGE
132047 : assert(this != NULL);
132048 : return variant();
132049 : }
132050 : #endif
132051 :
132052 : // This function is used in ROSE in treeTraversal code
132053 : // eventually replaces getVariant() and variant()
132054 : // though after variant() has been removed for a while we will
132055 : // want to change the name of variantT() back to variant()
132056 : // (since the "T" was ment to stand for temporary).
132057 : // When this happens the variantT() will be depricated.
132058 : VariantT
132059 0 : SgFunctionParameterScope::variantT() const
132060 : {
132061 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
132062 0 : ROSE_ASSERT(this != NULL);
132063 0 : return V_SgFunctionParameterScope;
132064 : }
132065 :
132066 : #if 0
132067 : int
132068 : SgFunctionParameterScope::variant() const
132069 : {
132070 : // This function is used in SAGE
132071 : ROSE_ASSERT(this != NULL);
132072 : return FUNCTION_PARAMETER_SCOPE;
132073 : }
132074 : #endif
132075 :
132076 : ROSE_DLL_API const char*
132077 0 : SgFunctionParameterScope::sage_class_name() const
132078 : {
132079 0 : ROSE_ASSERT(this != NULL);
132080 0 : return "SgFunctionParameterScope";
132081 : }
132082 :
132083 : std::string
132084 0 : SgFunctionParameterScope::class_name() const
132085 : {
132086 0 : ROSE_ASSERT(this != NULL);
132087 0 : return "SgFunctionParameterScope";
132088 : }
132089 :
132090 : // DQ (11/26/2005): Support for visitor pattern mechanims
132091 : // (inferior to ROSE traversal mechanism, experimental).
132092 : void
132093 0 : SgFunctionParameterScope::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
132094 : {
132095 0 : ROSE_ASSERT(this != NULL);
132096 0 : visitor.visit(this);
132097 0 : }
132098 :
132099 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
132100 0 : void SgFunctionParameterScope::accept (ROSE_VisitorPattern & visitor) {
132101 0 : ROSE_ASSERT(this != NULL);
132102 0 : visitor.visit(this);
132103 0 : }
132104 :
132105 : SgFunctionParameterScope*
132106 0 : SgFunctionParameterScope::addRegExpAttribute(std::string s, AstRegExAttribute* a)
132107 : {
132108 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
132109 : // This function is currently only supported for the AST used the represent Binary executables.
132110 : if (0 /* isSgAsmNode(this) != NULL */)
132111 : {
132112 : // Support for regex specification.
132113 : std::string prefixCode = "REGEX:";
132114 : addNewAttribute(prefixCode + s,a);
132115 : }
132116 : #endif
132117 :
132118 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
132119 0 : return this;
132120 : }
132121 :
132122 : // *** COMMON CODE SECTION ENDS HERE ***
132123 :
132124 :
132125 : // End of memberFunctionString
132126 : // Start of memberFunctionString
132127 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
132128 :
132129 :
132130 : #if 0
132131 : //! Error checking support
132132 : /*! Verifies the following:
132133 : - working getVariant() member function
132134 : - calls base class's error() member function
132135 : Every class has one of these functions.
132136 : */
132137 : bool
132138 : SgFunctionParameterScope::error()
132139 : {
132140 : // Put error checking here
132141 :
132142 : ROSE_ASSERT (this != NULL);
132143 : if (getVariant() != FUNCTION_PARAMETER_SCOPE)
132144 : {
132145 : printf ("Error in SgFunctionParameterScope::error(): SgFunctionParameterScope object has a %s variant \n",
132146 : Cxx_GrammarTerminalNames[getVariant()].name);
132147 : // printf ("Error in SgFunctionParameterScope::error() \n");
132148 : ROSE_ABORT();
132149 : }
132150 :
132151 : ROSE_ASSERT (getVariant() == FUNCTION_PARAMETER_SCOPE);
132152 : return SgScopeStatement::error();
132153 : }
132154 : #endif
132155 :
132156 :
132157 :
132158 : // End of memberFunctionString
132159 :
132160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
132161 :
132162 0 : SgFunctionParameterScope* isSgFunctionParameterScope ( SgNode* inputDerivedClassPointer )
132163 : {
132164 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
132165 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
132166 : // So to fix this we return NULL directly when the input is NULL and avoid the
132167 : // dynamic_cast in this case. This is likely a performance improvement as well.
132168 : // return dynamic_cast<SgFunctionParameterScope*>(inputDerivedClassPointer);
132169 : // Milind Chabbi (8/28/2013): isSgFunctionParameterScope uses table-driven castability instead of c++ default dynamic_cast
132170 : // this improves the running time performance by 10-20%.
132171 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionParameterScope*>(inputDerivedClassPointer);
132172 0 : return IS_SgFunctionParameterScope_FAST_MACRO(inputDerivedClassPointer);
132173 : }
132174 :
132175 : // DQ (11/8/2003): Added version of functions taking const pointer
132176 0 : const SgFunctionParameterScope* isSgFunctionParameterScope ( const SgNode* inputDerivedClassPointer )
132177 : {
132178 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
132179 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
132180 : // So to fix this we return NULL directly when the input is NULL and avoid the
132181 : // dynamic_cast in this case. This is likely a performance improvement as well.
132182 : // return dynamic_cast<const SgFunctionParameterScope*>(inputDerivedClassPointer);
132183 : // Milind Chabbi (8/28/2013): isSgFunctionParameterScope uses table-driven castability instead of c++ default dynamic_cast
132184 : // this improves the running time performance by 10-20%.
132185 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionParameterScope*>(inputDerivedClassPointer);
132186 0 : return IS_SgFunctionParameterScope_FAST_MACRO(inputDerivedClassPointer);
132187 : }
132188 :
132189 :
132190 :
132191 : /* #line 132192 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132192 :
132193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
132194 :
132195 : /**
132196 : \brief Generated destructor
132197 :
132198 : This destructor is automatically generated (by ROSETTA). This destructor
132199 : only frees memory of data members associated with the parts of the current IR node which
132200 : are NOT traversed. Those data members that are part of a traversal can be freed using
132201 : a traversal (calling this destructor on all children in a post-order traversal). Such
132202 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
132203 :
132204 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
132205 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
132206 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
132207 :
132208 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
132209 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
132210 : pointers are not yet implemented to call delete on eash pointer in the container.
132211 : (This could be done by derivation from the STL containers to define containers that
132212 : automatically deleted their members.)
132213 :
132214 : */
132215 0 : SgFunctionParameterScope::~SgFunctionParameterScope () {
132216 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
132217 :
132218 :
132219 :
132220 : }
132221 :
132222 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
132223 0 : }
132224 :
132225 :
132226 : /* #line 132227 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132227 :
132228 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
132229 :
132230 : // Generated constructor
132231 0 : SgFunctionParameterScope::SgFunctionParameterScope ( Sg_File_Info* startOfConstruct )
132232 0 : : SgScopeStatement(startOfConstruct)
132233 : {
132234 : #ifdef DEBUG
132235 : // printf ("In SgFunctionParameterScope::SgFunctionParameterScope (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
132236 : #endif
132237 : #if 0
132238 : // debugging information!
132239 : printf ("In SgFunctionParameterScope::SgFunctionParameterScope (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
132240 : #endif
132241 :
132242 :
132243 :
132244 : #if 0
132245 : // DQ (7/30/2014): Call a virtual function.
132246 : std::string s = this->class_name();
132247 : #endif
132248 :
132249 : // Test the variant virtual function
132250 : // assert(FUNCTION_PARAMETER_SCOPE == variant());
132251 0 : assert(FUNCTION_PARAMETER_SCOPE == this->variant());
132252 0 : ROSE_ASSERT(FUNCTION_PARAMETER_SCOPE == (int)(this->variantT()));
132253 0 : post_construction_initialization();
132254 :
132255 : // Test the isSgFunctionParameterScope() function since it has been problematic
132256 0 : assert(isSgFunctionParameterScope(this) != NULL);
132257 0 : }
132258 :
132259 : // Generated constructor (all data members)
132260 :
132261 : /* #line 132262 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132262 :
132263 :
132264 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
132265 :
132266 :
132267 : // ********************************************************
132268 : // member functions common across all array grammar objects
132269 : // ********************************************************
132270 :
132271 :
132272 :
132273 : /* #line 132274 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132274 :
132275 :
132276 :
132277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
132278 :
132279 : // ********************************************************
132280 : // member functions specific to each node in the grammar
132281 : // ********************************************************
132282 :
132283 :
132284 : /* #line 132285 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132285 :
132286 : // Start of memberFunctionString
132287 : /* #line 10706 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
132288 :
132289 :
132290 : void
132291 63355 : SgDeclarationScope::post_construction_initialization()
132292 : {
132293 : // Nothing to do here, but we need this function to be defined.
132294 63355 : }
132295 :
132296 : // DQ (7/20/2017): I think that the mangled name support requires the definition of this function.
132297 : SgName
132298 3688 : SgDeclarationScope::get_mangled_name(void) const
132299 : {
132300 : // I think that for this scope we need not return anything.
132301 3688 : return SgName ("__declaration_scope__");
132302 : }
132303 :
132304 : // DQ (7/19/2017): Added to support qualified name generation
132305 : SgName
132306 521 : SgDeclarationScope::get_qualified_name() const
132307 : {
132308 521 : std::string globalScopeDelimiter;
132309 :
132310 : // globalScopeDelimiter = "/* declaration scope */";
132311 521 : globalScopeDelimiter = "";
132312 :
132313 1042 : return SgName (globalScopeDelimiter);
132314 : }
132315 :
132316 :
132317 :
132318 : // End of memberFunctionString
132319 : // Start of memberFunctionString
132320 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
132321 :
132322 : // *** COMMON CODE SECTION BEGINS HERE ***
132323 :
132324 : #if 0
132325 : int
132326 : SgDeclarationScope::getVariant() const
132327 : {
132328 : // This function is used in ROSE while "variant()" is used in SAGE
132329 : assert(this != NULL);
132330 : return variant();
132331 : }
132332 : #endif
132333 :
132334 : // This function is used in ROSE in treeTraversal code
132335 : // eventually replaces getVariant() and variant()
132336 : // though after variant() has been removed for a while we will
132337 : // want to change the name of variantT() back to variant()
132338 : // (since the "T" was ment to stand for temporary).
132339 : // When this happens the variantT() will be depricated.
132340 : VariantT
132341 9660610 : SgDeclarationScope::variantT() const
132342 : {
132343 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
132344 9660610 : ROSE_ASSERT(this != NULL);
132345 9660610 : return V_SgDeclarationScope;
132346 : }
132347 :
132348 : #if 0
132349 : int
132350 : SgDeclarationScope::variant() const
132351 : {
132352 : // This function is used in SAGE
132353 : ROSE_ASSERT(this != NULL);
132354 : return DECLARATION_SCOPE;
132355 : }
132356 : #endif
132357 :
132358 : ROSE_DLL_API const char*
132359 0 : SgDeclarationScope::sage_class_name() const
132360 : {
132361 0 : ROSE_ASSERT(this != NULL);
132362 0 : return "SgDeclarationScope";
132363 : }
132364 :
132365 : std::string
132366 108919 : SgDeclarationScope::class_name() const
132367 : {
132368 108919 : ROSE_ASSERT(this != NULL);
132369 108919 : return "SgDeclarationScope";
132370 : }
132371 :
132372 : // DQ (11/26/2005): Support for visitor pattern mechanims
132373 : // (inferior to ROSE traversal mechanism, experimental).
132374 : void
132375 901454 : SgDeclarationScope::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
132376 : {
132377 901454 : ROSE_ASSERT(this != NULL);
132378 901454 : visitor.visit(this);
132379 901454 : }
132380 :
132381 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
132382 0 : void SgDeclarationScope::accept (ROSE_VisitorPattern & visitor) {
132383 0 : ROSE_ASSERT(this != NULL);
132384 0 : visitor.visit(this);
132385 0 : }
132386 :
132387 : SgDeclarationScope*
132388 0 : SgDeclarationScope::addRegExpAttribute(std::string s, AstRegExAttribute* a)
132389 : {
132390 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
132391 : // This function is currently only supported for the AST used the represent Binary executables.
132392 : if (0 /* isSgAsmNode(this) != NULL */)
132393 : {
132394 : // Support for regex specification.
132395 : std::string prefixCode = "REGEX:";
132396 : addNewAttribute(prefixCode + s,a);
132397 : }
132398 : #endif
132399 :
132400 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
132401 0 : return this;
132402 : }
132403 :
132404 : // *** COMMON CODE SECTION ENDS HERE ***
132405 :
132406 :
132407 : // End of memberFunctionString
132408 : // Start of memberFunctionString
132409 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
132410 :
132411 :
132412 : #if 0
132413 : //! Error checking support
132414 : /*! Verifies the following:
132415 : - working getVariant() member function
132416 : - calls base class's error() member function
132417 : Every class has one of these functions.
132418 : */
132419 : bool
132420 : SgDeclarationScope::error()
132421 : {
132422 : // Put error checking here
132423 :
132424 : ROSE_ASSERT (this != NULL);
132425 : if (getVariant() != DECLARATION_SCOPE)
132426 : {
132427 : printf ("Error in SgDeclarationScope::error(): SgDeclarationScope object has a %s variant \n",
132428 : Cxx_GrammarTerminalNames[getVariant()].name);
132429 : // printf ("Error in SgDeclarationScope::error() \n");
132430 : ROSE_ABORT();
132431 : }
132432 :
132433 : ROSE_ASSERT (getVariant() == DECLARATION_SCOPE);
132434 : return SgScopeStatement::error();
132435 : }
132436 : #endif
132437 :
132438 :
132439 :
132440 : // End of memberFunctionString
132441 :
132442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
132443 :
132444 1222880 : SgDeclarationScope* isSgDeclarationScope ( SgNode* inputDerivedClassPointer )
132445 : {
132446 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
132447 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
132448 : // So to fix this we return NULL directly when the input is NULL and avoid the
132449 : // dynamic_cast in this case. This is likely a performance improvement as well.
132450 : // return dynamic_cast<SgDeclarationScope*>(inputDerivedClassPointer);
132451 : // Milind Chabbi (8/28/2013): isSgDeclarationScope uses table-driven castability instead of c++ default dynamic_cast
132452 : // this improves the running time performance by 10-20%.
132453 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeclarationScope*>(inputDerivedClassPointer);
132454 1222880 : return IS_SgDeclarationScope_FAST_MACRO(inputDerivedClassPointer);
132455 : }
132456 :
132457 : // DQ (11/8/2003): Added version of functions taking const pointer
132458 0 : const SgDeclarationScope* isSgDeclarationScope ( const SgNode* inputDerivedClassPointer )
132459 : {
132460 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
132461 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
132462 : // So to fix this we return NULL directly when the input is NULL and avoid the
132463 : // dynamic_cast in this case. This is likely a performance improvement as well.
132464 : // return dynamic_cast<const SgDeclarationScope*>(inputDerivedClassPointer);
132465 : // Milind Chabbi (8/28/2013): isSgDeclarationScope uses table-driven castability instead of c++ default dynamic_cast
132466 : // this improves the running time performance by 10-20%.
132467 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeclarationScope*>(inputDerivedClassPointer);
132468 0 : return IS_SgDeclarationScope_FAST_MACRO(inputDerivedClassPointer);
132469 : }
132470 :
132471 :
132472 :
132473 : /* #line 132474 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132474 :
132475 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
132476 :
132477 : /**
132478 : \brief Generated destructor
132479 :
132480 : This destructor is automatically generated (by ROSETTA). This destructor
132481 : only frees memory of data members associated with the parts of the current IR node which
132482 : are NOT traversed. Those data members that are part of a traversal can be freed using
132483 : a traversal (calling this destructor on all children in a post-order traversal). Such
132484 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
132485 :
132486 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
132487 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
132488 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
132489 :
132490 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
132491 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
132492 : pointers are not yet implemented to call delete on eash pointer in the container.
132493 : (This could be done by derivation from the STL containers to define containers that
132494 : automatically deleted their members.)
132495 :
132496 : */
132497 26624 : SgDeclarationScope::~SgDeclarationScope () {
132498 13312 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
132499 :
132500 :
132501 :
132502 : }
132503 :
132504 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
132505 26624 : }
132506 :
132507 :
132508 : /* #line 132509 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132509 :
132510 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
132511 :
132512 : // Generated constructor
132513 336 : SgDeclarationScope::SgDeclarationScope ( Sg_File_Info* startOfConstruct )
132514 336 : : SgScopeStatement(startOfConstruct)
132515 : {
132516 : #ifdef DEBUG
132517 : // printf ("In SgDeclarationScope::SgDeclarationScope (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
132518 : #endif
132519 : #if 0
132520 : // debugging information!
132521 : printf ("In SgDeclarationScope::SgDeclarationScope (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
132522 : #endif
132523 :
132524 :
132525 :
132526 : #if 0
132527 : // DQ (7/30/2014): Call a virtual function.
132528 : std::string s = this->class_name();
132529 : #endif
132530 :
132531 : // Test the variant virtual function
132532 : // assert(DECLARATION_SCOPE == variant());
132533 336 : assert(DECLARATION_SCOPE == this->variant());
132534 336 : ROSE_ASSERT(DECLARATION_SCOPE == (int)(this->variantT()));
132535 336 : post_construction_initialization();
132536 :
132537 : // Test the isSgDeclarationScope() function since it has been problematic
132538 336 : assert(isSgDeclarationScope(this) != NULL);
132539 336 : }
132540 :
132541 : // Generated constructor (all data members)
132542 :
132543 : /* #line 132544 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132544 :
132545 :
132546 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
132547 :
132548 :
132549 : // ********************************************************
132550 : // member functions common across all array grammar objects
132551 : // ********************************************************
132552 :
132553 :
132554 :
132555 : /* #line 132556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132556 :
132557 :
132558 :
132559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
132560 :
132561 : // ********************************************************
132562 : // member functions specific to each node in the grammar
132563 : // ********************************************************
132564 :
132565 :
132566 : /* #line 132567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
132567 :
132568 : // Start of memberFunctionString
132569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132570 :
132571 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132572 :
132573 : SgVariableDeclaration*
132574 0 : SgRangeBasedForStatement::get_iterator_declaration () const
132575 : {
132576 0 : ROSE_ASSERT (this != NULL);
132577 :
132578 : #if 0
132579 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132580 : // used to trigger marking transformations for the token-based unparsing.
132581 : printf ("SgRangeBasedForStatement::get_iterator_declaration = %p = %s \n",this,this->class_name().c_str());
132582 : #endif
132583 :
132584 0 : return p_iterator_declaration;
132585 : }
132586 :
132587 : void
132588 0 : SgRangeBasedForStatement::set_iterator_declaration ( SgVariableDeclaration* iterator_declaration )
132589 : {
132590 0 : ROSE_ASSERT (this != NULL);
132591 :
132592 : #if 0
132593 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132594 : // used to trigger marking transformations for the token-based unparsing.
132595 : printf ("SgRangeBasedForStatement::set_iterator_declaration = %p = %s \n",this,this->class_name().c_str());
132596 : #endif
132597 :
132598 0 : set_isModified(true);
132599 :
132600 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132601 : if (p_iterator_declaration != NULL && iterator_declaration != NULL && p_iterator_declaration != iterator_declaration)
132602 : {
132603 : printf ("Warning: iterator_declaration = %p overwriting valid pointer p_iterator_declaration = %p \n",iterator_declaration,p_iterator_declaration);
132604 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132605 : printf ("Error fails assertion (p_iterator_declaration != NULL && iterator_declaration != NULL && p_iterator_declaration != iterator_declaration) is false\n");
132606 : ROSE_ASSERT(false);
132607 : #endif
132608 : }
132609 : #endif
132610 0 : p_iterator_declaration = iterator_declaration;
132611 0 : }
132612 :
132613 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132614 :
132615 :
132616 : // End of memberFunctionString
132617 : // Start of memberFunctionString
132618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132619 :
132620 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132621 :
132622 : SgVariableDeclaration*
132623 0 : SgRangeBasedForStatement::get_range_declaration () const
132624 : {
132625 0 : ROSE_ASSERT (this != NULL);
132626 :
132627 : #if 0
132628 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132629 : // used to trigger marking transformations for the token-based unparsing.
132630 : printf ("SgRangeBasedForStatement::get_range_declaration = %p = %s \n",this,this->class_name().c_str());
132631 : #endif
132632 :
132633 0 : return p_range_declaration;
132634 : }
132635 :
132636 : void
132637 0 : SgRangeBasedForStatement::set_range_declaration ( SgVariableDeclaration* range_declaration )
132638 : {
132639 0 : ROSE_ASSERT (this != NULL);
132640 :
132641 : #if 0
132642 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132643 : // used to trigger marking transformations for the token-based unparsing.
132644 : printf ("SgRangeBasedForStatement::set_range_declaration = %p = %s \n",this,this->class_name().c_str());
132645 : #endif
132646 :
132647 0 : set_isModified(true);
132648 :
132649 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132650 : if (p_range_declaration != NULL && range_declaration != NULL && p_range_declaration != range_declaration)
132651 : {
132652 : printf ("Warning: range_declaration = %p overwriting valid pointer p_range_declaration = %p \n",range_declaration,p_range_declaration);
132653 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132654 : printf ("Error fails assertion (p_range_declaration != NULL && range_declaration != NULL && p_range_declaration != range_declaration) is false\n");
132655 : ROSE_ASSERT(false);
132656 : #endif
132657 : }
132658 : #endif
132659 0 : p_range_declaration = range_declaration;
132660 0 : }
132661 :
132662 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132663 :
132664 :
132665 : // End of memberFunctionString
132666 : // Start of memberFunctionString
132667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132668 :
132669 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132670 :
132671 : SgVariableDeclaration*
132672 0 : SgRangeBasedForStatement::get_begin_declaration () const
132673 : {
132674 0 : ROSE_ASSERT (this != NULL);
132675 :
132676 : #if 0
132677 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132678 : // used to trigger marking transformations for the token-based unparsing.
132679 : printf ("SgRangeBasedForStatement::get_begin_declaration = %p = %s \n",this,this->class_name().c_str());
132680 : #endif
132681 :
132682 0 : return p_begin_declaration;
132683 : }
132684 :
132685 : void
132686 0 : SgRangeBasedForStatement::set_begin_declaration ( SgVariableDeclaration* begin_declaration )
132687 : {
132688 0 : ROSE_ASSERT (this != NULL);
132689 :
132690 : #if 0
132691 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132692 : // used to trigger marking transformations for the token-based unparsing.
132693 : printf ("SgRangeBasedForStatement::set_begin_declaration = %p = %s \n",this,this->class_name().c_str());
132694 : #endif
132695 :
132696 0 : set_isModified(true);
132697 :
132698 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132699 : if (p_begin_declaration != NULL && begin_declaration != NULL && p_begin_declaration != begin_declaration)
132700 : {
132701 : printf ("Warning: begin_declaration = %p overwriting valid pointer p_begin_declaration = %p \n",begin_declaration,p_begin_declaration);
132702 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132703 : printf ("Error fails assertion (p_begin_declaration != NULL && begin_declaration != NULL && p_begin_declaration != begin_declaration) is false\n");
132704 : ROSE_ASSERT(false);
132705 : #endif
132706 : }
132707 : #endif
132708 0 : p_begin_declaration = begin_declaration;
132709 0 : }
132710 :
132711 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132712 :
132713 :
132714 : // End of memberFunctionString
132715 : // Start of memberFunctionString
132716 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132717 :
132718 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132719 :
132720 : SgVariableDeclaration*
132721 0 : SgRangeBasedForStatement::get_end_declaration () const
132722 : {
132723 0 : ROSE_ASSERT (this != NULL);
132724 :
132725 : #if 0
132726 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132727 : // used to trigger marking transformations for the token-based unparsing.
132728 : printf ("SgRangeBasedForStatement::get_end_declaration = %p = %s \n",this,this->class_name().c_str());
132729 : #endif
132730 :
132731 0 : return p_end_declaration;
132732 : }
132733 :
132734 : void
132735 0 : SgRangeBasedForStatement::set_end_declaration ( SgVariableDeclaration* end_declaration )
132736 : {
132737 0 : ROSE_ASSERT (this != NULL);
132738 :
132739 : #if 0
132740 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132741 : // used to trigger marking transformations for the token-based unparsing.
132742 : printf ("SgRangeBasedForStatement::set_end_declaration = %p = %s \n",this,this->class_name().c_str());
132743 : #endif
132744 :
132745 0 : set_isModified(true);
132746 :
132747 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132748 : if (p_end_declaration != NULL && end_declaration != NULL && p_end_declaration != end_declaration)
132749 : {
132750 : printf ("Warning: end_declaration = %p overwriting valid pointer p_end_declaration = %p \n",end_declaration,p_end_declaration);
132751 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132752 : printf ("Error fails assertion (p_end_declaration != NULL && end_declaration != NULL && p_end_declaration != end_declaration) is false\n");
132753 : ROSE_ASSERT(false);
132754 : #endif
132755 : }
132756 : #endif
132757 0 : p_end_declaration = end_declaration;
132758 0 : }
132759 :
132760 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132761 :
132762 :
132763 : // End of memberFunctionString
132764 : // Start of memberFunctionString
132765 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132766 :
132767 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132768 :
132769 : SgExpression*
132770 0 : SgRangeBasedForStatement::get_not_equal_expression () const
132771 : {
132772 0 : ROSE_ASSERT (this != NULL);
132773 :
132774 : #if 0
132775 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132776 : // used to trigger marking transformations for the token-based unparsing.
132777 : printf ("SgRangeBasedForStatement::get_not_equal_expression = %p = %s \n",this,this->class_name().c_str());
132778 : #endif
132779 :
132780 0 : return p_not_equal_expression;
132781 : }
132782 :
132783 : void
132784 0 : SgRangeBasedForStatement::set_not_equal_expression ( SgExpression* not_equal_expression )
132785 : {
132786 0 : ROSE_ASSERT (this != NULL);
132787 :
132788 : #if 0
132789 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132790 : // used to trigger marking transformations for the token-based unparsing.
132791 : printf ("SgRangeBasedForStatement::set_not_equal_expression = %p = %s \n",this,this->class_name().c_str());
132792 : #endif
132793 :
132794 0 : set_isModified(true);
132795 :
132796 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132797 : if (p_not_equal_expression != NULL && not_equal_expression != NULL && p_not_equal_expression != not_equal_expression)
132798 : {
132799 : printf ("Warning: not_equal_expression = %p overwriting valid pointer p_not_equal_expression = %p \n",not_equal_expression,p_not_equal_expression);
132800 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132801 : printf ("Error fails assertion (p_not_equal_expression != NULL && not_equal_expression != NULL && p_not_equal_expression != not_equal_expression) is false\n");
132802 : ROSE_ASSERT(false);
132803 : #endif
132804 : }
132805 : #endif
132806 0 : p_not_equal_expression = not_equal_expression;
132807 0 : }
132808 :
132809 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132810 :
132811 :
132812 : // End of memberFunctionString
132813 : // Start of memberFunctionString
132814 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132815 :
132816 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132817 :
132818 : SgExpression*
132819 0 : SgRangeBasedForStatement::get_increment_expression () const
132820 : {
132821 0 : ROSE_ASSERT (this != NULL);
132822 :
132823 : #if 0
132824 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132825 : // used to trigger marking transformations for the token-based unparsing.
132826 : printf ("SgRangeBasedForStatement::get_increment_expression = %p = %s \n",this,this->class_name().c_str());
132827 : #endif
132828 :
132829 0 : return p_increment_expression;
132830 : }
132831 :
132832 : void
132833 0 : SgRangeBasedForStatement::set_increment_expression ( SgExpression* increment_expression )
132834 : {
132835 0 : ROSE_ASSERT (this != NULL);
132836 :
132837 : #if 0
132838 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132839 : // used to trigger marking transformations for the token-based unparsing.
132840 : printf ("SgRangeBasedForStatement::set_increment_expression = %p = %s \n",this,this->class_name().c_str());
132841 : #endif
132842 :
132843 0 : set_isModified(true);
132844 :
132845 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132846 : if (p_increment_expression != NULL && increment_expression != NULL && p_increment_expression != increment_expression)
132847 : {
132848 : printf ("Warning: increment_expression = %p overwriting valid pointer p_increment_expression = %p \n",increment_expression,p_increment_expression);
132849 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132850 : printf ("Error fails assertion (p_increment_expression != NULL && increment_expression != NULL && p_increment_expression != increment_expression) is false\n");
132851 : ROSE_ASSERT(false);
132852 : #endif
132853 : }
132854 : #endif
132855 0 : p_increment_expression = increment_expression;
132856 0 : }
132857 :
132858 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132859 :
132860 :
132861 : // End of memberFunctionString
132862 : // Start of memberFunctionString
132863 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
132864 :
132865 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
132866 :
132867 : SgStatement*
132868 0 : SgRangeBasedForStatement::get_loop_body () const
132869 : {
132870 0 : ROSE_ASSERT (this != NULL);
132871 :
132872 : #if 0
132873 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132874 : // used to trigger marking transformations for the token-based unparsing.
132875 : printf ("SgRangeBasedForStatement::get_loop_body = %p = %s \n",this,this->class_name().c_str());
132876 : #endif
132877 :
132878 0 : return p_loop_body;
132879 : }
132880 :
132881 : void
132882 0 : SgRangeBasedForStatement::set_loop_body ( SgStatement* loop_body )
132883 : {
132884 0 : ROSE_ASSERT (this != NULL);
132885 :
132886 : #if 0
132887 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
132888 : // used to trigger marking transformations for the token-based unparsing.
132889 : printf ("SgRangeBasedForStatement::set_loop_body = %p = %s \n",this,this->class_name().c_str());
132890 : #endif
132891 :
132892 0 : set_isModified(true);
132893 :
132894 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
132895 : if (p_loop_body != NULL && loop_body != NULL && p_loop_body != loop_body)
132896 : {
132897 : printf ("Warning: loop_body = %p overwriting valid pointer p_loop_body = %p \n",loop_body,p_loop_body);
132898 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
132899 : printf ("Error fails assertion (p_loop_body != NULL && loop_body != NULL && p_loop_body != loop_body) is false\n");
132900 : ROSE_ASSERT(false);
132901 : #endif
132902 : }
132903 : #endif
132904 0 : p_loop_body = loop_body;
132905 0 : }
132906 :
132907 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
132908 :
132909 :
132910 : // End of memberFunctionString
132911 : // Start of memberFunctionString
132912 : /* #line 10244 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
132913 :
132914 :
132915 : void
132916 0 : SgRangeBasedForStatement::post_construction_initialization()
132917 : {
132918 : #if 0
132919 : printf ("In SgRangeBasedForStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
132920 : #endif
132921 :
132922 : // DQ (3/24/2018): Uses the same semantics as for the normal for loop IR node.
132923 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
132924 0 : if (p_iterator_declaration != NULL)
132925 : {
132926 0 : p_iterator_declaration->set_parent(this);
132927 : }
132928 :
132929 0 : if (p_range_declaration != NULL)
132930 : {
132931 0 : p_range_declaration->set_parent(this);
132932 : }
132933 :
132934 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
132935 0 : if (p_begin_declaration != NULL)
132936 : {
132937 0 : p_begin_declaration->set_parent(this);
132938 : }
132939 :
132940 0 : if (p_end_declaration != NULL)
132941 : {
132942 0 : p_end_declaration->set_parent(this);
132943 : }
132944 :
132945 0 : if (p_not_equal_expression != NULL)
132946 : {
132947 0 : p_not_equal_expression->set_parent(this);
132948 : }
132949 :
132950 0 : if (p_increment_expression != NULL)
132951 : {
132952 0 : p_increment_expression->set_parent(this);
132953 : }
132954 :
132955 : // DQ (12/17/2006): If these are available, then set their parents as well (ok, since this is a structural issue).
132956 0 : if (p_loop_body != NULL)
132957 : {
132958 0 : p_loop_body->set_parent(this);
132959 : }
132960 0 : }
132961 :
132962 :
132963 : bool
132964 0 : SgRangeBasedForStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
132965 : {
132966 0 : if ( StatementReplace(this, p_loop_body, target, newstmt) == true )
132967 0 : return true;
132968 0 : else if ( StatementReplace(this, p_iterator_declaration, target, newstmt) == true )
132969 : return true;
132970 0 : else if ( StatementReplace(this, p_range_declaration, target, newstmt) == true )
132971 : return true;
132972 0 : else if ( StatementReplace(this, p_begin_declaration, target, newstmt) == true )
132973 : return true;
132974 0 : else if ( StatementReplace(this, p_end_declaration, target, newstmt) == true )
132975 : return true;
132976 : else
132977 0 : return false;
132978 : }
132979 :
132980 :
132981 : int
132982 0 : SgRangeBasedForStatement::replace_expression(SgExpression * original_expression, SgExpression * new_expression )
132983 : {
132984 : // DQ (3/25/2018): This function should have the semantics that it will represent a
132985 : // structural change to the AST, thus it is free to set the parent of the new expression.
132986 :
132987 0 : ROSE_ASSERT(original_expression != NULL);
132988 0 : ROSE_ASSERT(new_expression != NULL);
132989 :
132990 : // DQ (3/26/2018): I think we need to test for each case of an SgExpression IR date member in this class (similar to statements).
132991 : // ROSE_ASSERT(original_expression == p_range_expression);
132992 : // set_range_expression(new_expression);
132993 :
132994 0 : printf ("ERROR: Semantics of SgRangeBasedForStatement::replace_expression() not implemented! \n");
132995 :
132996 0 : new_expression->set_parent(this);
132997 :
132998 : // DQ: Let this be a memory leak for now to avoid initial problems.
132999 0 : ROSE_ASSERT(original_expression != NULL);
133000 : // delete original_expression;
133001 :
133002 0 : return 0;
133003 : }
133004 :
133005 : // DQ (3/25/2018): Added to provide uniform support of mangle names for all scopes
133006 : SgName
133007 0 : SgRangeBasedForStatement::get_mangled_name(void) const
133008 : {
133009 0 : return SgName ("");
133010 : }
133011 :
133012 :
133013 : // SgVarRefExp* SgRangeBasedForStatement::range_variable_reference()
133014 : SgExpression*
133015 0 : SgRangeBasedForStatement::range_expression()
133016 : {
133017 : // DQ (3/28/2018): Get the range variable (target container, name used for unparser).
133018 :
133019 : // Note: The container being iterated upon by the range-based for loop is reference through the initializer to the range_declaration.
133020 :
133021 0 : SgVariableDeclaration* local_range_declaration = get_range_declaration();
133022 0 : ROSE_ASSERT(local_range_declaration != NULL);
133023 :
133024 0 : SgInitializedName* local_range_variable = SageInterface::getFirstInitializedName(local_range_declaration);
133025 0 : ROSE_ASSERT(local_range_variable != NULL);
133026 :
133027 0 : SgInitializer* initializer = local_range_variable->get_initializer();
133028 0 : ROSE_ASSERT(initializer != NULL);
133029 :
133030 : #if 1
133031 : // It would be general to support just returning the initializer, since there can be different kinds
133032 : // of initializers used (see test2018_61.C, test2018_63.C, and test2018_64.C).
133033 0 : return initializer;
133034 : #else
133035 : SgAssignInitializer* assign_initializer = isSgAssignInitializer(initializer);
133036 : if (assign_initializer == NULL)
133037 : {
133038 : printf ("In SgRangeBasedForStatement::range_variable_reference(): initializer = %p = %s \n",initializer,initializer->class_name().c_str());
133039 : }
133040 : ROSE_ASSERT(assign_initializer != NULL);
133041 :
133042 : SgExpression* range_expression = assign_initializer->get_operand();
133043 : ROSE_ASSERT(range_expression != NULL);
133044 :
133045 : SgVarRefExp* range_reference = isSgVarRefExp(range_expression);
133046 : if (range_reference == NULL)
133047 : {
133048 : printf ("In SgRangeBasedForStatement::range_variable_reference(): range_expression = %p = %s \n",range_expression,range_expression->class_name().c_str());
133049 : }
133050 : ROSE_ASSERT(range_reference != NULL);
133051 :
133052 : return range_reference;
133053 : #endif
133054 : }
133055 :
133056 :
133057 :
133058 : // End of memberFunctionString
133059 : // Start of memberFunctionString
133060 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
133061 :
133062 : // *** COMMON CODE SECTION BEGINS HERE ***
133063 :
133064 : #if 0
133065 : int
133066 : SgRangeBasedForStatement::getVariant() const
133067 : {
133068 : // This function is used in ROSE while "variant()" is used in SAGE
133069 : assert(this != NULL);
133070 : return variant();
133071 : }
133072 : #endif
133073 :
133074 : // This function is used in ROSE in treeTraversal code
133075 : // eventually replaces getVariant() and variant()
133076 : // though after variant() has been removed for a while we will
133077 : // want to change the name of variantT() back to variant()
133078 : // (since the "T" was ment to stand for temporary).
133079 : // When this happens the variantT() will be depricated.
133080 : VariantT
133081 0 : SgRangeBasedForStatement::variantT() const
133082 : {
133083 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
133084 0 : ROSE_ASSERT(this != NULL);
133085 0 : return V_SgRangeBasedForStatement;
133086 : }
133087 :
133088 : #if 0
133089 : int
133090 : SgRangeBasedForStatement::variant() const
133091 : {
133092 : // This function is used in SAGE
133093 : ROSE_ASSERT(this != NULL);
133094 : return RANGE_BASED_FOR_STMT;
133095 : }
133096 : #endif
133097 :
133098 : ROSE_DLL_API const char*
133099 0 : SgRangeBasedForStatement::sage_class_name() const
133100 : {
133101 0 : ROSE_ASSERT(this != NULL);
133102 0 : return "SgRangeBasedForStatement";
133103 : }
133104 :
133105 : std::string
133106 0 : SgRangeBasedForStatement::class_name() const
133107 : {
133108 0 : ROSE_ASSERT(this != NULL);
133109 0 : return "SgRangeBasedForStatement";
133110 : }
133111 :
133112 : // DQ (11/26/2005): Support for visitor pattern mechanims
133113 : // (inferior to ROSE traversal mechanism, experimental).
133114 : void
133115 0 : SgRangeBasedForStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
133116 : {
133117 0 : ROSE_ASSERT(this != NULL);
133118 0 : visitor.visit(this);
133119 0 : }
133120 :
133121 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
133122 0 : void SgRangeBasedForStatement::accept (ROSE_VisitorPattern & visitor) {
133123 0 : ROSE_ASSERT(this != NULL);
133124 0 : visitor.visit(this);
133125 0 : }
133126 :
133127 : SgRangeBasedForStatement*
133128 0 : SgRangeBasedForStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
133129 : {
133130 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
133131 : // This function is currently only supported for the AST used the represent Binary executables.
133132 : if (0 /* isSgAsmNode(this) != NULL */)
133133 : {
133134 : // Support for regex specification.
133135 : std::string prefixCode = "REGEX:";
133136 : addNewAttribute(prefixCode + s,a);
133137 : }
133138 : #endif
133139 :
133140 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
133141 0 : return this;
133142 : }
133143 :
133144 : // *** COMMON CODE SECTION ENDS HERE ***
133145 :
133146 :
133147 : // End of memberFunctionString
133148 : // Start of memberFunctionString
133149 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
133150 :
133151 :
133152 : #if 0
133153 : //! Error checking support
133154 : /*! Verifies the following:
133155 : - working getVariant() member function
133156 : - calls base class's error() member function
133157 : Every class has one of these functions.
133158 : */
133159 : bool
133160 : SgRangeBasedForStatement::error()
133161 : {
133162 : // Put error checking here
133163 :
133164 : ROSE_ASSERT (this != NULL);
133165 : if (getVariant() != RANGE_BASED_FOR_STMT)
133166 : {
133167 : printf ("Error in SgRangeBasedForStatement::error(): SgRangeBasedForStatement object has a %s variant \n",
133168 : Cxx_GrammarTerminalNames[getVariant()].name);
133169 : // printf ("Error in SgRangeBasedForStatement::error() \n");
133170 : ROSE_ABORT();
133171 : }
133172 :
133173 : ROSE_ASSERT (getVariant() == RANGE_BASED_FOR_STMT);
133174 : return SgScopeStatement::error();
133175 : }
133176 : #endif
133177 :
133178 :
133179 :
133180 : // End of memberFunctionString
133181 :
133182 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
133183 :
133184 1706 : SgRangeBasedForStatement* isSgRangeBasedForStatement ( SgNode* inputDerivedClassPointer )
133185 : {
133186 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
133187 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
133188 : // So to fix this we return NULL directly when the input is NULL and avoid the
133189 : // dynamic_cast in this case. This is likely a performance improvement as well.
133190 : // return dynamic_cast<SgRangeBasedForStatement*>(inputDerivedClassPointer);
133191 : // Milind Chabbi (8/28/2013): isSgRangeBasedForStatement uses table-driven castability instead of c++ default dynamic_cast
133192 : // this improves the running time performance by 10-20%.
133193 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRangeBasedForStatement*>(inputDerivedClassPointer);
133194 1706 : return IS_SgRangeBasedForStatement_FAST_MACRO(inputDerivedClassPointer);
133195 : }
133196 :
133197 : // DQ (11/8/2003): Added version of functions taking const pointer
133198 0 : const SgRangeBasedForStatement* isSgRangeBasedForStatement ( const SgNode* inputDerivedClassPointer )
133199 : {
133200 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
133201 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
133202 : // So to fix this we return NULL directly when the input is NULL and avoid the
133203 : // dynamic_cast in this case. This is likely a performance improvement as well.
133204 : // return dynamic_cast<const SgRangeBasedForStatement*>(inputDerivedClassPointer);
133205 : // Milind Chabbi (8/28/2013): isSgRangeBasedForStatement uses table-driven castability instead of c++ default dynamic_cast
133206 : // this improves the running time performance by 10-20%.
133207 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRangeBasedForStatement*>(inputDerivedClassPointer);
133208 0 : return IS_SgRangeBasedForStatement_FAST_MACRO(inputDerivedClassPointer);
133209 : }
133210 :
133211 :
133212 :
133213 : /* #line 133214 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133214 :
133215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
133216 :
133217 : /**
133218 : \brief Generated destructor
133219 :
133220 : This destructor is automatically generated (by ROSETTA). This destructor
133221 : only frees memory of data members associated with the parts of the current IR node which
133222 : are NOT traversed. Those data members that are part of a traversal can be freed using
133223 : a traversal (calling this destructor on all children in a post-order traversal). Such
133224 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
133225 :
133226 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
133227 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
133228 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
133229 :
133230 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
133231 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
133232 : pointers are not yet implemented to call delete on eash pointer in the container.
133233 : (This could be done by derivation from the STL containers to define containers that
133234 : automatically deleted their members.)
133235 :
133236 : */
133237 0 : SgRangeBasedForStatement::~SgRangeBasedForStatement () {
133238 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
133239 :
133240 :
133241 : // case: not a listType for iterator_declaration
133242 0 : p_iterator_declaration = NULL; // non list case
133243 : // case: not a listType for range_declaration
133244 0 : p_range_declaration = NULL; // non list case
133245 : // case: not a listType for begin_declaration
133246 0 : p_begin_declaration = NULL; // non list case
133247 : // case: not a listType for end_declaration
133248 0 : p_end_declaration = NULL; // non list case
133249 : // case: not a listType for not_equal_expression
133250 0 : p_not_equal_expression = NULL; // non list case
133251 : // case: not a listType for increment_expression
133252 0 : p_increment_expression = NULL; // non list case
133253 : // case: not a listType for loop_body
133254 0 : p_loop_body = NULL; // non list case
133255 :
133256 : }
133257 :
133258 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
133259 0 : }
133260 :
133261 :
133262 : /* #line 133263 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133263 :
133264 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
133265 :
133266 : // Generated constructor
133267 0 : SgRangeBasedForStatement::SgRangeBasedForStatement ( Sg_File_Info* startOfConstruct, SgVariableDeclaration* iterator_declaration, SgVariableDeclaration* range_declaration, SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration, SgExpression* not_equal_expression, SgExpression* increment_expression, SgStatement* loop_body )
133268 0 : : SgScopeStatement(startOfConstruct)
133269 : {
133270 : #ifdef DEBUG
133271 : // printf ("In SgRangeBasedForStatement::SgRangeBasedForStatement (Sg_File_Info* startOfConstruct, SgVariableDeclaration* iterator_declaration, SgVariableDeclaration* range_declaration, SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration, SgExpression* not_equal_expression, SgExpression* increment_expression, SgStatement* loop_body) sage_class_name() = %s \n",sage_class_name());
133272 : #endif
133273 : #if 0
133274 : // debugging information!
133275 : printf ("In SgRangeBasedForStatement::SgRangeBasedForStatement (Sg_File_Info* startOfConstruct, SgVariableDeclaration* iterator_declaration, SgVariableDeclaration* range_declaration, SgVariableDeclaration* begin_declaration, SgVariableDeclaration* end_declaration, SgExpression* not_equal_expression, SgExpression* increment_expression, SgStatement* loop_body): this = %p = %s \n",this,this->class_name().c_str());
133276 : #endif
133277 :
133278 0 : p_iterator_declaration = iterator_declaration;
133279 0 : p_range_declaration = range_declaration;
133280 0 : p_begin_declaration = begin_declaration;
133281 0 : p_end_declaration = end_declaration;
133282 0 : p_not_equal_expression = not_equal_expression;
133283 0 : p_increment_expression = increment_expression;
133284 0 : p_loop_body = loop_body;
133285 :
133286 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
133287 :
133288 : #if 0
133289 : // DQ (7/30/2014): Call a virtual function.
133290 : std::string s = this->class_name();
133291 : #endif
133292 :
133293 : // Test the variant virtual function
133294 : // assert(RANGE_BASED_FOR_STMT == variant());
133295 0 : assert(RANGE_BASED_FOR_STMT == this->variant());
133296 0 : ROSE_ASSERT(RANGE_BASED_FOR_STMT == (int)(this->variantT()));
133297 0 : post_construction_initialization();
133298 :
133299 : // Test the isSgRangeBasedForStatement() function since it has been problematic
133300 0 : assert(isSgRangeBasedForStatement(this) != NULL);
133301 0 : }
133302 :
133303 : // Generated constructor (all data members)
133304 :
133305 : /* #line 133306 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133306 :
133307 :
133308 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
133309 :
133310 :
133311 : // ********************************************************
133312 : // member functions common across all array grammar objects
133313 : // ********************************************************
133314 :
133315 :
133316 :
133317 : /* #line 133318 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133318 :
133319 :
133320 :
133321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
133322 :
133323 : // ********************************************************
133324 : // member functions specific to each node in the grammar
133325 : // ********************************************************
133326 :
133327 :
133328 : /* #line 133329 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133329 :
133330 : // Start of memberFunctionString
133331 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133332 :
133333 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133334 :
133335 : SgSymbolTable*
133336 4 : SgFunctionTypeTable::get_function_type_table () const
133337 : {
133338 4 : ROSE_ASSERT (this != NULL);
133339 :
133340 : #if 0
133341 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133342 : // used to trigger marking transformations for the token-based unparsing.
133343 : printf ("SgFunctionTypeTable::get_function_type_table = %p = %s \n",this,this->class_name().c_str());
133344 : #endif
133345 :
133346 4 : return p_function_type_table;
133347 : }
133348 :
133349 : void
133350 0 : SgFunctionTypeTable::set_function_type_table ( SgSymbolTable* function_type_table )
133351 : {
133352 0 : ROSE_ASSERT (this != NULL);
133353 :
133354 : #if 0
133355 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133356 : // used to trigger marking transformations for the token-based unparsing.
133357 : printf ("SgFunctionTypeTable::set_function_type_table = %p = %s \n",this,this->class_name().c_str());
133358 : #endif
133359 :
133360 0 : set_isModified(true);
133361 :
133362 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
133363 : if (p_function_type_table != NULL && function_type_table != NULL && p_function_type_table != function_type_table)
133364 : {
133365 : printf ("Warning: function_type_table = %p overwriting valid pointer p_function_type_table = %p \n",function_type_table,p_function_type_table);
133366 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
133367 : printf ("Error fails assertion (p_function_type_table != NULL && function_type_table != NULL && p_function_type_table != function_type_table) is false\n");
133368 : ROSE_ASSERT(false);
133369 : #endif
133370 : }
133371 : #endif
133372 0 : p_function_type_table = function_type_table;
133373 0 : }
133374 :
133375 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133376 :
133377 :
133378 : // End of memberFunctionString
133379 : // Start of memberFunctionString
133380 : /* #line 7301 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
133381 :
133382 :
133383 : /* \brief Hash table of function types (table is stored on global scope).
133384 :
133385 : Hash table of function types (table is stored on global scope and includes data
133386 : from all scopes). Function types are placed into and retrieved from this data
133387 : base (simple hash table) of function types.
133388 : */
133389 : // DQ (1/31/2006): Modified to build all types in the memory pools
133390 : // SgFunctionTypeTable Sgfunc_type_table;
133391 :
133392 : // SgFunctionTypeTable::SgFunctionTypeTable( bool case_insensitive )
133393 354 : SgFunctionTypeTable::SgFunctionTypeTable()
133394 : // DQ (12/17/2012): Set the source position as compiler generated to avoid a filename of "" in the static filename tables.
133395 354 : : SgStatement( Sg_File_Info::generateDefaultFileInfoForCompilerGeneratedNode ())
133396 : {
133397 : // DQ (11/27/2010): Added support for case sensitive and insensitive matching (for C/C++ and Fortran, respectively).
133398 : // DQ (2/19/2007): Use a much larger size symbol table for the function types (the input value is the hash table size, which should be a prime number)!
133399 : // p_function_type_table = new SgSymbolTable();
133400 : // p_function_type_table = new SgSymbolTable(1001,case_insensitive);
133401 354 : p_function_type_table = new SgSymbolTable();
133402 354 : ROSE_ASSERT(p_function_type_table != NULL);
133403 :
133404 : // DQ (2/16/2006): Set this parent directly (now tested)
133405 354 : p_function_type_table->set_parent(this);
133406 :
133407 : // Set the parent of the Sg_File_Info object
133408 : // ROSE_ASSERT(get_file_info() != NULL);
133409 354 : ROSE_ASSERT(get_startOfConstruct() != NULL);
133410 : // get_file_info()->set_parent(this);
133411 : // p_startOfConstruct->set_parent(this);
133412 354 : this->get_startOfConstruct()->set_parent(this);
133413 :
133414 : // DQ (12/17/2012): Set the source position as compiler generated.
133415 354 : ROSE_ASSERT(get_endOfConstruct() == NULL);
133416 354 : this->set_endOfConstruct(Sg_File_Info::generateDefaultFileInfoForCompilerGeneratedNode());
133417 354 : this->get_endOfConstruct()->set_parent(this);
133418 :
133419 : // DQ (11/27/2010): In retrospect I think that should should always be false!
133420 : // Note that the function type table is global and could include translation
133421 : // units from both C/C++ and Fortran.
133422 : // ROSE_ASSERT(case_insensitive == false);
133423 354 : }
133424 :
133425 : // DQ (2/19/2007): This appears to not be called but is here because
133426 : // the ROSETTA code requires it (I think).
133427 : void
133428 0 : SgFunctionTypeTable::post_construction_initialization()
133429 : {
133430 : #if 0
133431 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
133432 : printf ("In SgFunctionTypeTable::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
133433 : #endif
133434 0 : }
133435 :
133436 : void
133437 1 : SgFunctionTypeTable::print_functypetable(std::ostream& os)
133438 : {
133439 : // printf ("ERROR: Sage SgFunctionTypeTable::print_functypetable function called! \n");
133440 : // abort();
133441 :
133442 1 : os << endl << "...FuncTypeTbl..." << endl;
133443 : // p_function_type_table.print(os);
133444 :
133445 1 : ROSE_ASSERT(p_function_type_table != NULL);
133446 : // p_function_type_table->print(os);
133447 1 : p_function_type_table->print("Called from SgFunctionTypeTable::print_functypetable");
133448 1 : }
133449 :
133450 : void
133451 249949 : SgFunctionTypeTable::insert_function_type(const SgName& n, SgType *t)
133452 : {
133453 249949 : ROSE_ASSERT (p_function_type_table != NULL);
133454 249949 : ROSE_ASSERT (t != NULL);
133455 :
133456 249949 : SgFunctionTypeSymbol* newSymbol = new SgFunctionTypeSymbol(n,t);
133457 249949 : ROSE_ASSERT (newSymbol != NULL);
133458 : #if 0
133459 : printf ("Inside of SgFunctionTypeTable::insert_function_type(SgName,SgType*): n = %s type = %s = %s \n",
133460 : n.str(),t->sage_class_name(),t->unparseToString().c_str());
133461 : #endif
133462 : // printf ("Is the qualified name being used! \n");
133463 : // ROSE_ASSERT(false);
133464 :
133465 249949 : p_function_type_table->insert(n, newSymbol);
133466 : // p_function_type_table->insert(n, new SgFunctionTypeSymbol(n,t));
133467 249949 : }
133468 :
133469 : // DQ (1/31/2007): Added support for removing function type symbols (used in AST merge)
133470 : void
133471 0 : SgFunctionTypeTable::remove_function_type(const SgName& n)
133472 : {
133473 0 : ROSE_ASSERT (p_function_type_table != NULL);
133474 0 : p_function_type_table->remove_function_type(n);
133475 0 : }
133476 :
133477 : SgType*
133478 2577710 : SgFunctionTypeTable::lookup_function_type(const SgName& n)
133479 : {
133480 : // printf ("In SgFunctionTypeTable::lookup_function_type: Looking for %s \n",n.str());
133481 2577710 : ROSE_ASSERT (p_function_type_table != NULL);
133482 : // SgFunctionTypeSymbol *fsymb = isSgFunctionTypeSymbol(p_function_type_table->findfunctype(n));
133483 2577710 : SgSymbol *symbol = p_function_type_table->find_function_type(n);
133484 2577710 : SgFunctionTypeSymbol *fsymb = isSgFunctionTypeSymbol(symbol);
133485 2577710 : SgType* returnType = NULL;
133486 :
133487 2577710 : if (fsymb != NULL)
133488 : {
133489 2327760 : returnType = fsymb->get_type();
133490 2327760 : ROSE_ASSERT(returnType != NULL);
133491 : // printf ("In SgFunctionTypeTable::lookup_function_type(): found function type %s \n",returnType->class_name().c_str());
133492 : }
133493 :
133494 2577710 : return returnType;
133495 : }
133496 :
133497 :
133498 :
133499 : // End of memberFunctionString
133500 : // Start of memberFunctionString
133501 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
133502 :
133503 : // *** COMMON CODE SECTION BEGINS HERE ***
133504 :
133505 : #if 0
133506 : int
133507 : SgFunctionTypeTable::getVariant() const
133508 : {
133509 : // This function is used in ROSE while "variant()" is used in SAGE
133510 : assert(this != NULL);
133511 : return variant();
133512 : }
133513 : #endif
133514 :
133515 : // This function is used in ROSE in treeTraversal code
133516 : // eventually replaces getVariant() and variant()
133517 : // though after variant() has been removed for a while we will
133518 : // want to change the name of variantT() back to variant()
133519 : // (since the "T" was ment to stand for temporary).
133520 : // When this happens the variantT() will be depricated.
133521 : VariantT
133522 12880 : SgFunctionTypeTable::variantT() const
133523 : {
133524 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
133525 12880 : ROSE_ASSERT(this != NULL);
133526 12880 : return V_SgFunctionTypeTable;
133527 : }
133528 :
133529 : #if 0
133530 : int
133531 : SgFunctionTypeTable::variant() const
133532 : {
133533 : // This function is used in SAGE
133534 : ROSE_ASSERT(this != NULL);
133535 : return FUNC_TBL_STMT;
133536 : }
133537 : #endif
133538 :
133539 : ROSE_DLL_API const char*
133540 0 : SgFunctionTypeTable::sage_class_name() const
133541 : {
133542 0 : ROSE_ASSERT(this != NULL);
133543 0 : return "SgFunctionTypeTable";
133544 : }
133545 :
133546 : std::string
133547 328 : SgFunctionTypeTable::class_name() const
133548 : {
133549 328 : ROSE_ASSERT(this != NULL);
133550 328 : return "SgFunctionTypeTable";
133551 : }
133552 :
133553 : // DQ (11/26/2005): Support for visitor pattern mechanims
133554 : // (inferior to ROSE traversal mechanism, experimental).
133555 : void
133556 194 : SgFunctionTypeTable::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
133557 : {
133558 194 : ROSE_ASSERT(this != NULL);
133559 194 : visitor.visit(this);
133560 194 : }
133561 :
133562 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
133563 0 : void SgFunctionTypeTable::accept (ROSE_VisitorPattern & visitor) {
133564 0 : ROSE_ASSERT(this != NULL);
133565 0 : visitor.visit(this);
133566 0 : }
133567 :
133568 : SgFunctionTypeTable*
133569 0 : SgFunctionTypeTable::addRegExpAttribute(std::string s, AstRegExAttribute* a)
133570 : {
133571 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
133572 : // This function is currently only supported for the AST used the represent Binary executables.
133573 : if (0 /* isSgAsmNode(this) != NULL */)
133574 : {
133575 : // Support for regex specification.
133576 : std::string prefixCode = "REGEX:";
133577 : addNewAttribute(prefixCode + s,a);
133578 : }
133579 : #endif
133580 :
133581 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
133582 0 : return this;
133583 : }
133584 :
133585 : // *** COMMON CODE SECTION ENDS HERE ***
133586 :
133587 :
133588 : // End of memberFunctionString
133589 : // Start of memberFunctionString
133590 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
133591 :
133592 :
133593 : #if 0
133594 : //! Error checking support
133595 : /*! Verifies the following:
133596 : - working getVariant() member function
133597 : - calls base class's error() member function
133598 : Every class has one of these functions.
133599 : */
133600 : bool
133601 : SgFunctionTypeTable::error()
133602 : {
133603 : // Put error checking here
133604 :
133605 : ROSE_ASSERT (this != NULL);
133606 : if (getVariant() != FUNC_TBL_STMT)
133607 : {
133608 : printf ("Error in SgFunctionTypeTable::error(): SgFunctionTypeTable object has a %s variant \n",
133609 : Cxx_GrammarTerminalNames[getVariant()].name);
133610 : // printf ("Error in SgFunctionTypeTable::error() \n");
133611 : ROSE_ABORT();
133612 : }
133613 :
133614 : ROSE_ASSERT (getVariant() == FUNC_TBL_STMT);
133615 : return SgStatement::error();
133616 : }
133617 : #endif
133618 :
133619 :
133620 :
133621 : // End of memberFunctionString
133622 :
133623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
133624 :
133625 0 : SgFunctionTypeTable* isSgFunctionTypeTable ( SgNode* inputDerivedClassPointer )
133626 : {
133627 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
133628 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
133629 : // So to fix this we return NULL directly when the input is NULL and avoid the
133630 : // dynamic_cast in this case. This is likely a performance improvement as well.
133631 : // return dynamic_cast<SgFunctionTypeTable*>(inputDerivedClassPointer);
133632 : // Milind Chabbi (8/28/2013): isSgFunctionTypeTable uses table-driven castability instead of c++ default dynamic_cast
133633 : // this improves the running time performance by 10-20%.
133634 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionTypeTable*>(inputDerivedClassPointer);
133635 0 : return IS_SgFunctionTypeTable_FAST_MACRO(inputDerivedClassPointer);
133636 : }
133637 :
133638 : // DQ (11/8/2003): Added version of functions taking const pointer
133639 2 : const SgFunctionTypeTable* isSgFunctionTypeTable ( const SgNode* inputDerivedClassPointer )
133640 : {
133641 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
133642 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
133643 : // So to fix this we return NULL directly when the input is NULL and avoid the
133644 : // dynamic_cast in this case. This is likely a performance improvement as well.
133645 : // return dynamic_cast<const SgFunctionTypeTable*>(inputDerivedClassPointer);
133646 : // Milind Chabbi (8/28/2013): isSgFunctionTypeTable uses table-driven castability instead of c++ default dynamic_cast
133647 : // this improves the running time performance by 10-20%.
133648 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionTypeTable*>(inputDerivedClassPointer);
133649 2 : return IS_SgFunctionTypeTable_FAST_MACRO(inputDerivedClassPointer);
133650 : }
133651 :
133652 :
133653 :
133654 : /* #line 133655 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133655 :
133656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
133657 :
133658 : /**
133659 : \brief Generated destructor
133660 :
133661 : This destructor is automatically generated (by ROSETTA). This destructor
133662 : only frees memory of data members associated with the parts of the current IR node which
133663 : are NOT traversed. Those data members that are part of a traversal can be freed using
133664 : a traversal (calling this destructor on all children in a post-order traversal). Such
133665 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
133666 :
133667 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
133668 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
133669 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
133670 :
133671 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
133672 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
133673 : pointers are not yet implemented to call delete on eash pointer in the container.
133674 : (This could be done by derivation from the STL containers to define containers that
133675 : automatically deleted their members.)
133676 :
133677 : */
133678 14 : SgFunctionTypeTable::~SgFunctionTypeTable () {
133679 7 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
133680 :
133681 7 : if (p_function_type_table && p_function_type_table->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_function_type_table; }
133682 :
133683 : // case: not a listType for function_type_table
133684 7 : p_function_type_table = NULL; // non list case
133685 :
133686 : }
133687 :
133688 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
133689 14 : }
133690 :
133691 :
133692 : /* #line 133693 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133693 :
133694 :
133695 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
133696 :
133697 :
133698 : // ********************************************************
133699 : // member functions common across all array grammar objects
133700 : // ********************************************************
133701 :
133702 :
133703 :
133704 : /* #line 133705 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133705 :
133706 :
133707 :
133708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
133709 :
133710 : // ********************************************************
133711 : // member functions specific to each node in the grammar
133712 : // ********************************************************
133713 :
133714 :
133715 : /* #line 133716 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
133716 :
133717 : // Start of memberFunctionString
133718 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133719 :
133720 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133721 :
133722 : unsigned int
133723 0 : SgDeclarationStatement::get_decl_attributes () const
133724 : {
133725 0 : ROSE_ASSERT (this != NULL);
133726 :
133727 : #if 0
133728 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133729 : // used to trigger marking transformations for the token-based unparsing.
133730 : printf ("SgDeclarationStatement::get_decl_attributes = %p = %s \n",this,this->class_name().c_str());
133731 : #endif
133732 :
133733 0 : return p_decl_attributes;
133734 : }
133735 :
133736 : void
133737 0 : SgDeclarationStatement::set_decl_attributes ( unsigned int decl_attributes )
133738 : {
133739 0 : ROSE_ASSERT (this != NULL);
133740 :
133741 : #if 0
133742 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133743 : // used to trigger marking transformations for the token-based unparsing.
133744 : printf ("SgDeclarationStatement::set_decl_attributes = %p = %s \n",this,this->class_name().c_str());
133745 : #endif
133746 :
133747 0 : set_isModified(true);
133748 :
133749 0 : p_decl_attributes = decl_attributes;
133750 0 : }
133751 :
133752 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133753 :
133754 :
133755 : // End of memberFunctionString
133756 : // Start of memberFunctionString
133757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133758 :
133759 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133760 :
133761 : std::string
133762 63 : SgDeclarationStatement::get_linkage () const
133763 : {
133764 63 : ROSE_ASSERT (this != NULL);
133765 :
133766 : #if 0
133767 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133768 : // used to trigger marking transformations for the token-based unparsing.
133769 : printf ("SgDeclarationStatement::get_linkage = %p = %s \n",this,this->class_name().c_str());
133770 : #endif
133771 :
133772 63 : return p_linkage;
133773 : }
133774 :
133775 : void
133776 9114 : SgDeclarationStatement::set_linkage ( std::string linkage )
133777 : {
133778 9114 : ROSE_ASSERT (this != NULL);
133779 :
133780 : #if 0
133781 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133782 : // used to trigger marking transformations for the token-based unparsing.
133783 : printf ("SgDeclarationStatement::set_linkage = %p = %s \n",this,this->class_name().c_str());
133784 : #endif
133785 :
133786 9114 : set_isModified(true);
133787 :
133788 9114 : p_linkage = linkage;
133789 9114 : }
133790 :
133791 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133792 :
133793 :
133794 : // End of memberFunctionString
133795 : // Start of memberFunctionString
133796 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
133797 :
133798 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133799 :
133800 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
133801 : const SgDeclarationModifier &
133802 1100300 : SgDeclarationStatement::get_declarationModifier () const
133803 : {
133804 1100300 : assert (this != NULL);
133805 1100300 : return p_declarationModifier;
133806 : }
133807 :
133808 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
133809 : SgDeclarationModifier &
133810 28539600 : SgDeclarationStatement::get_declarationModifier ()
133811 : {
133812 28539600 : assert (this != NULL);
133813 :
133814 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
133815 : // As a rule only set_ access functions can set the isModified flag.
133816 : // set_isModified(true);
133817 :
133818 28539600 : return p_declarationModifier;
133819 : }
133820 :
133821 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133822 :
133823 :
133824 : // End of memberFunctionString
133825 : // Start of memberFunctionString
133826 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133827 :
133828 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133829 :
133830 : bool
133831 0 : SgDeclarationStatement::get_nameOnly () const
133832 : {
133833 0 : ROSE_ASSERT (this != NULL);
133834 :
133835 : #if 0
133836 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133837 : // used to trigger marking transformations for the token-based unparsing.
133838 : printf ("SgDeclarationStatement::get_nameOnly = %p = %s \n",this,this->class_name().c_str());
133839 : #endif
133840 :
133841 0 : return p_nameOnly;
133842 : }
133843 :
133844 : void
133845 33412 : SgDeclarationStatement::set_nameOnly ( bool nameOnly )
133846 : {
133847 33412 : ROSE_ASSERT (this != NULL);
133848 :
133849 : #if 0
133850 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133851 : // used to trigger marking transformations for the token-based unparsing.
133852 : printf ("SgDeclarationStatement::set_nameOnly = %p = %s \n",this,this->class_name().c_str());
133853 : #endif
133854 :
133855 33412 : set_isModified(true);
133856 :
133857 33412 : p_nameOnly = nameOnly;
133858 33412 : }
133859 :
133860 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133861 :
133862 :
133863 : // End of memberFunctionString
133864 : // Start of memberFunctionString
133865 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133866 :
133867 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133868 :
133869 : bool
133870 2443060 : SgDeclarationStatement::get_forward () const
133871 : {
133872 2443060 : ROSE_ASSERT (this != NULL);
133873 :
133874 : #if 0
133875 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133876 : // used to trigger marking transformations for the token-based unparsing.
133877 : printf ("SgDeclarationStatement::get_forward = %p = %s \n",this,this->class_name().c_str());
133878 : #endif
133879 :
133880 2443060 : return p_forward;
133881 : }
133882 :
133883 : void
133884 1241790 : SgDeclarationStatement::set_forward ( bool forward )
133885 : {
133886 1241790 : ROSE_ASSERT (this != NULL);
133887 :
133888 : #if 0
133889 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133890 : // used to trigger marking transformations for the token-based unparsing.
133891 : printf ("SgDeclarationStatement::set_forward = %p = %s \n",this,this->class_name().c_str());
133892 : #endif
133893 :
133894 1241790 : set_isModified(true);
133895 :
133896 1241790 : p_forward = forward;
133897 1241790 : }
133898 :
133899 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133900 :
133901 :
133902 : // End of memberFunctionString
133903 : // Start of memberFunctionString
133904 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133905 :
133906 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133907 :
133908 : bool
133909 1345 : SgDeclarationStatement::get_externBrace () const
133910 : {
133911 1345 : ROSE_ASSERT (this != NULL);
133912 :
133913 : #if 0
133914 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133915 : // used to trigger marking transformations for the token-based unparsing.
133916 : printf ("SgDeclarationStatement::get_externBrace = %p = %s \n",this,this->class_name().c_str());
133917 : #endif
133918 :
133919 1345 : return p_externBrace;
133920 : }
133921 :
133922 : void
133923 1082630 : SgDeclarationStatement::set_externBrace ( bool externBrace )
133924 : {
133925 1082630 : ROSE_ASSERT (this != NULL);
133926 :
133927 : #if 0
133928 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133929 : // used to trigger marking transformations for the token-based unparsing.
133930 : printf ("SgDeclarationStatement::set_externBrace = %p = %s \n",this,this->class_name().c_str());
133931 : #endif
133932 :
133933 1082630 : set_isModified(true);
133934 :
133935 1082630 : p_externBrace = externBrace;
133936 1082630 : }
133937 :
133938 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133939 :
133940 :
133941 : // End of memberFunctionString
133942 : // Start of memberFunctionString
133943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133944 :
133945 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133946 :
133947 : bool
133948 3560 : SgDeclarationStatement::get_skipElaborateType () const
133949 : {
133950 3560 : ROSE_ASSERT (this != NULL);
133951 :
133952 : #if 0
133953 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133954 : // used to trigger marking transformations for the token-based unparsing.
133955 : printf ("SgDeclarationStatement::get_skipElaborateType = %p = %s \n",this,this->class_name().c_str());
133956 : #endif
133957 :
133958 3560 : return p_skipElaborateType;
133959 : }
133960 :
133961 : void
133962 0 : SgDeclarationStatement::set_skipElaborateType ( bool skipElaborateType )
133963 : {
133964 0 : ROSE_ASSERT (this != NULL);
133965 :
133966 : #if 0
133967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133968 : // used to trigger marking transformations for the token-based unparsing.
133969 : printf ("SgDeclarationStatement::set_skipElaborateType = %p = %s \n",this,this->class_name().c_str());
133970 : #endif
133971 :
133972 0 : set_isModified(true);
133973 :
133974 0 : p_skipElaborateType = skipElaborateType;
133975 0 : }
133976 :
133977 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
133978 :
133979 :
133980 : // End of memberFunctionString
133981 : // Start of memberFunctionString
133982 :
133983 :
133984 : // End of memberFunctionString
133985 : // Start of memberFunctionString
133986 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
133987 :
133988 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
133989 :
133990 : std::string
133991 0 : SgDeclarationStatement::get_binding_label () const
133992 : {
133993 0 : ROSE_ASSERT (this != NULL);
133994 :
133995 : #if 0
133996 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
133997 : // used to trigger marking transformations for the token-based unparsing.
133998 : printf ("SgDeclarationStatement::get_binding_label = %p = %s \n",this,this->class_name().c_str());
133999 : #endif
134000 :
134001 0 : return p_binding_label;
134002 : }
134003 :
134004 : void
134005 0 : SgDeclarationStatement::set_binding_label ( std::string binding_label )
134006 : {
134007 0 : ROSE_ASSERT (this != NULL);
134008 :
134009 : #if 0
134010 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
134011 : // used to trigger marking transformations for the token-based unparsing.
134012 : printf ("SgDeclarationStatement::set_binding_label = %p = %s \n",this,this->class_name().c_str());
134013 : #endif
134014 :
134015 0 : set_isModified(true);
134016 :
134017 0 : p_binding_label = binding_label;
134018 0 : }
134019 :
134020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
134021 :
134022 :
134023 : // End of memberFunctionString
134024 : // Start of memberFunctionString
134025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
134026 :
134027 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
134028 :
134029 : SgDeclarationScope*
134030 1176720 : SgDeclarationStatement::get_declarationScope () const
134031 : {
134032 1176720 : ROSE_ASSERT (this != NULL);
134033 :
134034 : #if 0
134035 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
134036 : // used to trigger marking transformations for the token-based unparsing.
134037 : printf ("SgDeclarationStatement::get_declarationScope = %p = %s \n",this,this->class_name().c_str());
134038 : #endif
134039 :
134040 1176720 : return p_declarationScope;
134041 : }
134042 :
134043 : void
134044 16 : SgDeclarationStatement::set_declarationScope ( SgDeclarationScope* declarationScope )
134045 : {
134046 16 : ROSE_ASSERT (this != NULL);
134047 :
134048 : #if 0
134049 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
134050 : // used to trigger marking transformations for the token-based unparsing.
134051 : printf ("SgDeclarationStatement::set_declarationScope = %p = %s \n",this,this->class_name().c_str());
134052 : #endif
134053 :
134054 16 : set_isModified(true);
134055 :
134056 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
134057 : if (p_declarationScope != NULL && declarationScope != NULL && p_declarationScope != declarationScope)
134058 : {
134059 : printf ("Warning: declarationScope = %p overwriting valid pointer p_declarationScope = %p \n",declarationScope,p_declarationScope);
134060 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
134061 : printf ("Error fails assertion (p_declarationScope != NULL && declarationScope != NULL && p_declarationScope != declarationScope) is false\n");
134062 : ROSE_ASSERT(false);
134063 : #endif
134064 : }
134065 : #endif
134066 16 : p_declarationScope = declarationScope;
134067 16 : }
134068 :
134069 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
134070 :
134071 :
134072 : // End of memberFunctionString
134073 : // Start of memberFunctionString
134074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
134075 :
134076 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
134077 :
134078 : bool
134079 4247 : SgDeclarationStatement::get_unparse_template_ast () const
134080 : {
134081 4247 : ROSE_ASSERT (this != NULL);
134082 :
134083 : #if 0
134084 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
134085 : // used to trigger marking transformations for the token-based unparsing.
134086 : printf ("SgDeclarationStatement::get_unparse_template_ast = %p = %s \n",this,this->class_name().c_str());
134087 : #endif
134088 :
134089 4247 : return p_unparse_template_ast;
134090 : }
134091 :
134092 : void
134093 0 : SgDeclarationStatement::set_unparse_template_ast ( bool unparse_template_ast )
134094 : {
134095 0 : ROSE_ASSERT (this != NULL);
134096 :
134097 : #if 0
134098 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
134099 : // used to trigger marking transformations for the token-based unparsing.
134100 : printf ("SgDeclarationStatement::set_unparse_template_ast = %p = %s \n",this,this->class_name().c_str());
134101 : #endif
134102 :
134103 0 : set_isModified(true);
134104 :
134105 0 : p_unparse_template_ast = unparse_template_ast;
134106 0 : }
134107 :
134108 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
134109 :
134110 :
134111 : // End of memberFunctionString
134112 : // Start of memberFunctionString
134113 : /* #line 7644 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
134114 :
134115 :
134116 : // DQ (12/21/2005): Build the static empty list to use as a default argument for the SgQualifiedNameType constructor
134117 : // SgQualifiedNamePtrList SgDeclarationStatement::p_defaultQualifiedNamePtrList;
134118 :
134119 : SgQualifiedNamePtrList &
134120 0 : SgDeclarationStatement::get_qualifiedNameList()
134121 : {
134122 0 : return p_qualifiedNameList;
134123 : }
134124 :
134125 : const SgQualifiedNamePtrList &
134126 0 : SgDeclarationStatement::get_qualifiedNameList() const
134127 : {
134128 0 : return p_qualifiedNameList;
134129 : }
134130 :
134131 : void
134132 0 : SgDeclarationStatement::set_qualifiedNameList( const SgQualifiedNamePtrList & x )
134133 : {
134134 0 : p_qualifiedNameList = x;
134135 0 : }
134136 :
134137 : SgName
134138 5594 : SgDeclarationStatement::get_qualified_name_prefix() const
134139 : {
134140 : // DQ (5/29/2011): Added to support for new qualified name generation.
134141 : // This only applies to specific IR nodes:
134142 : // SgFunctionDeclaration (for the function name)
134143 : // SgFunctionDeclaration (for the return type)
134144 : // SgUsingDeclarationStatement (for references to a declaration (e.g. namespace or class))
134145 : // SgUsingDeclarationStatement (for references to a SgInitializedName)
134146 : // SgUsingDirectiveStatement
134147 : // SgVariableDeclaration
134148 : // SgTypedefDeclaration
134149 :
134150 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
134151 : // different and so it depends upon where the type is referenced. Thus the qualified name is
134152 : // stored in a map to the IR node that references the type.
134153 5594 : SgName nameQualifier;
134154 5594 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgDeclarationStatement*>(this));
134155 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
134156 :
134157 5594 : if (i != SgNode::get_globalQualifiedNameMapForNames().end())
134158 : {
134159 2999 : nameQualifier = i->second;
134160 : // printf ("Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
134161 : }
134162 :
134163 : // printf ("nameQualifier for SgDeclarationStatement = %s = %s \n",class_name().c_str(),nameQualifier.str());
134164 :
134165 5594 : return nameQualifier;
134166 : }
134167 :
134168 : void
134169 4945330 : SgDeclarationStatement::post_construction_initialization()
134170 : {
134171 : #if 0
134172 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
134173 : printf ("In SgDeclarationStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
134174 : #endif
134175 4945330 : }
134176 :
134177 : // DQ (11/28/2009): Changed return type from "int" to "bool"
134178 : bool
134179 2443060 : SgDeclarationStatement::isForward() const
134180 2443060 : { return get_forward(); }
134181 :
134182 : void
134183 1206460 : SgDeclarationStatement::setForward()
134184 1206460 : { set_forward(true); }
134185 :
134186 : void
134187 17016 : SgDeclarationStatement::unsetForward()
134188 17016 : { set_forward(false); }
134189 :
134190 : // DQ (11/28/2009): Changed return type from "int" to "bool"
134191 : bool
134192 0 : SgDeclarationStatement::isNameOnly() const
134193 0 : { return get_nameOnly(); }
134194 :
134195 : void
134196 33412 : SgDeclarationStatement::setNameOnly()
134197 33412 : { set_nameOnly(true); }
134198 :
134199 : void
134200 0 : SgDeclarationStatement::unsetNameOnly()
134201 0 : { set_nameOnly(false); }
134202 :
134203 : // DQ (11/28/2009): Changed return type from "int" to "bool"
134204 : bool
134205 1345 : SgDeclarationStatement::isExternBrace() const
134206 1345 : { return get_externBrace(); }
134207 :
134208 : void
134209 9114 : SgDeclarationStatement::setExternBrace()
134210 9114 : { set_externBrace(true); }
134211 :
134212 : void
134213 1073520 : SgDeclarationStatement::unsetExternBrace()
134214 1073520 : { set_externBrace(false); }
134215 :
134216 : // DQ (11/28/2009): Changed return type from "int" to "bool"
134217 : bool
134218 3560 : SgDeclarationStatement::skipElaborateType() const
134219 3560 : { return get_skipElaborateType(); }
134220 :
134221 : void
134222 0 : SgDeclarationStatement::setSkipElaborateType()
134223 0 : { set_skipElaborateType(true); }
134224 :
134225 : void
134226 0 : SgDeclarationStatement::unsetSkipElaborateType()
134227 0 : { set_skipElaborateType(false); }
134228 :
134229 :
134230 : void
134231 100770 : SgDeclarationStatement::testForBadGenerateTemplateName( const std::string & name )
134232 : {
134233 : // DQ (2/20/2005): Error checking on existence of substrings that can be common
134234 : // in building template name and which are a source of errors in generated code.
134235 200584 : if ( (name.find("<<") != string::npos) || (name.find(">>") != string::npos) )
134236 : {
134237 : // This could just be the input or output operators so make sure this is not that case!
134238 2684 : if ( (name.find("operator<<") == string::npos) && (name.find("operator>>") == string::npos) )
134239 : {
134240 : #if 0
134241 : // OK, we have some sort of error to report!
134242 : printf ("\n\n");
134243 : printf ("Error: \"<<\" or \">>\" found in generated name, this could lead to an error in compiling the generated code later \n");
134244 : printf ("..... name generated in processing a %s IR node \n",sage_class_name());
134245 : printf ("..... generated name = %s \n",name.c_str());
134246 : printf ("\n\n");
134247 : #endif
134248 : // DQ (7/27/2012): Modify this to handle a wide range of function names.
134249 0 : if (name.find("operator") != string::npos)
134250 : {
134251 : #if 0
134252 : printf ("This is an operator and so can have names that can violate our test for template names (but still not template arguments; these are rare). \n");
134253 : #endif
134254 : }
134255 : else
134256 : {
134257 0 : printf ("This is a rule violation and also not an operator, so this is an error in ROSE \n");
134258 0 : ROSE_ASSERT (false);
134259 : }
134260 : // ROSE_ASSERT (returnName.find("<<") == string::npos);
134261 : // ROSE_ASSERT (returnName.find(">>") == string::npos);
134262 : }
134263 : }
134264 :
134265 : // Search for common substring of unconverted EDG generated typenames...
134266 100770 : if ( name.find("____") != string::npos )
134267 : {
134268 0 : printf ("Error: \"____\" found in ROSE generated type name = %s (likely and unconverted EDG name) \n",name.c_str());
134269 0 : printf ("Error: SgDeclarationStatement (this) = %p = %s = %s \n",this,this->class_name().c_str(),SageInterface::get_name(this).c_str());
134270 0 : get_file_info()->display("Error: likely and unconverted EDG name");
134271 0 : ROSE_ASSERT (false);
134272 : }
134273 100770 : }
134274 :
134275 :
134276 : bool
134277 16659 : SgDeclarationStatement::skipEmptyTemplateArgumentListTest ( SgFunctionDeclaration* functionDeclaration )
134278 : {
134279 : // DQ (4/13/2005): Avoid output of empty lists of template arguments in function names
134280 : // as in "endl<>" (which is a bug in g++ version 3.4, see test2005_55.C). This
134281 : // should only apply to function and member functions since they alone can skip the output of "<>".
134282 : // What we do below is skip the "<" and ">" when the list of template arguments would be empty.
134283 : // It would be empty when either there are no arguments or non were explicitly specified in the
134284 : // source code.
134285 :
134286 : // Note that this function can only be applied to functions (since only they are explicitly
134287 : // mark with if there template arguments are specified or not!)
134288 :
134289 16659 : ROSE_ASSERT(functionDeclaration != NULL);
134290 :
134291 : // default is true, so empty lists are not output (could this be an error?)
134292 16659 : bool skipEmptyTemplateArgumentList = true;
134293 :
134294 16659 : string functionName;
134295 16659 : SgTemplateArgumentPtrListPtr templateArgListPtr = NULL;
134296 :
134297 : // One or the other of these are valid pointers, but not both!
134298 16659 : SgTemplateInstantiationFunctionDecl *templateInstantiationFunctionDeclaration =
134299 16659 : isSgTemplateInstantiationFunctionDecl(functionDeclaration);
134300 16659 : SgTemplateInstantiationMemberFunctionDecl *templateInstantiationMemberFunctionDeclaration =
134301 16659 : isSgTemplateInstantiationMemberFunctionDecl(functionDeclaration);
134302 :
134303 16659 : if (templateInstantiationFunctionDeclaration != NULL)
134304 : {
134305 2272 : functionName = templateInstantiationFunctionDeclaration->get_templateName().str();
134306 2272 : templateArgListPtr = &templateInstantiationFunctionDeclaration->get_templateArguments();
134307 : }
134308 : else
134309 : {
134310 14387 : ROSE_ASSERT(templateInstantiationMemberFunctionDeclaration != NULL);
134311 14387 : functionName = templateInstantiationMemberFunctionDeclaration->get_templateName().str();
134312 14387 : templateArgListPtr = &templateInstantiationMemberFunctionDeclaration->get_templateArguments();
134313 : }
134314 :
134315 : #if 0
134316 : printf ("In skipEmptyTemplateArgumentListTest: Handling function name = %s \n",functionName.c_str());
134317 : #endif
134318 :
134319 16659 : ROSE_ASSERT(templateArgListPtr != NULL);
134320 :
134321 16659 : SgTemplateArgumentPtrList::const_iterator i = templateArgListPtr->begin();
134322 21855 : while (i != templateArgListPtr->end())
134323 : {
134324 : #if 0
134325 : printf ("templateArgList element *i = %s \n",(*i)->sage_class_name());
134326 : #endif
134327 :
134328 : // DQ (2/27/2005): Added support for output of only template arguments
134329 : // that were explicit in the source code. Only meaningful for function
134330 : // and member function template arguments.
134331 5196 : bool templateArgumentWasExplicitlySpecified = (*i)->get_explicitlySpecified();
134332 : // bool outputTemplateArgument = false;
134333 5196 : if ( templateArgumentWasExplicitlySpecified == true )
134334 : {
134335 : // outputTemplateArgument = true;
134336 5036 : skipEmptyTemplateArgumentList = false;
134337 : }
134338 :
134339 : #if 0
134340 : printf ("outputTemplateArgument = %s \n",(outputTemplateArgument == true) ? "true" : "false");
134341 : #endif
134342 :
134343 5196 : i++;
134344 : }
134345 :
134346 : #if 0
134347 : printf ("skipEmptyTemplateArgumentList = %s \n",(skipEmptyTemplateArgumentList == true) ? "true" : "false");
134348 : #endif
134349 :
134350 17987 : return skipEmptyTemplateArgumentList;
134351 : }
134352 :
134353 :
134354 : void
134355 28755 : resetTemplateNamesInScope ( SgScopeStatement* scope )
134356 : {
134357 : // DQ (8/11/2005): This function loops over all parent scopes to reset
134358 : // any possibly unset names in instantiated templated classes.
134359 :
134360 : // DQ (2/10/2007): I hope we can assert this!
134361 28755 : ROSE_ASSERT(scope != NULL);
134362 :
134363 : #if 0
134364 : printf ("In resetTemplateNamesInScope: traversing through parent scopes (scope = %p = %s) \n",scope,scope->class_name().c_str());
134365 : #endif
134366 :
134367 : #if 0
134368 : // DQ (6/30/2018): Returning from top of function to test infinit loop over declarations in typedef base types.
134369 : printf ("In resetTemplateNamesInScope: Skipping body of function, return \n");
134370 : return;
134371 : #endif
134372 :
134373 : // DQ (7/24/2017): Allow both SgGlobal and SgDeclarationScope to be stoping criteria for this iteration.
134374 : // Unless this causes name collissions because we truncated the scope names.
134375 : // while ( scope != NULL && isSgGlobal(scope) == NULL )
134376 80227 : while ( scope != NULL && isSgGlobal(scope) == NULL && isSgDeclarationScope(scope) == NULL )
134377 : {
134378 : #if 0
134379 : printf ("In resetTemplateNamesInScope(%s) \n",scope->class_name().c_str());
134380 : #endif
134381 51472 : switch(scope->variantT())
134382 : {
134383 : case V_SgTemplateFunctionDefinition: // Liao, 11/2/2012
134384 : case V_SgFunctionDefinition:
134385 : {
134386 : // Nothing to do here, I think, unless we have to reset template function names
134387 : break;
134388 : }
134389 :
134390 : case V_SgGlobal:
134391 : case V_SgBasicBlock:
134392 : case V_SgCatchOptionStmt:
134393 : case V_SgSwitchStatement:
134394 : case V_SgIfStmt:
134395 : case V_SgWhileStmt:
134396 : case V_SgDoWhileStmt:
134397 : case V_SgForStatement:
134398 : {
134399 : // Nothing to do here, I think, unless we have to reset template function names
134400 : break;
134401 : }
134402 :
134403 : // DQ (2/12/2012): Adding support for SgTemplateClassDefinition (not previously used).
134404 348 : case V_SgTemplateClassDefinition:
134405 348 : case V_SgClassDefinition:
134406 348 : {
134407 348 : SgDeclarationStatement* parentDeclaration = NULL;
134408 348 : parentDeclaration = isSgClassDefinition(scope)->get_declaration();
134409 348 : ROSE_ASSERT(parentDeclaration != NULL);
134410 : // Nothing to do here!
134411 348 : break;
134412 : }
134413 :
134414 : // This turns out to be the only important case!
134415 14963 : case V_SgTemplateInstantiationDefn:
134416 14963 : {
134417 14963 : SgTemplateInstantiationDefn* defn = isSgTemplateInstantiationDefn(scope);
134418 14963 : ROSE_ASSERT(defn != NULL);
134419 14963 : ROSE_ASSERT(defn->get_declaration() != NULL);
134420 14963 : SgTemplateInstantiationDecl *decl = isSgTemplateInstantiationDecl(defn->get_declaration());
134421 14963 : ROSE_ASSERT(decl != NULL);
134422 :
134423 : // DQ (10/24/2015): Make sure that the class declaration is not recorded as existing in the scope represented by it's class definition (that would be BAD).
134424 14963 : ROSE_ASSERT(decl->get_scope() != defn);
134425 :
134426 14963 : decl->resetTemplateName();
134427 14963 : break;
134428 : }
134429 :
134430 36161 : case V_SgNamespaceDefinitionStatement:
134431 36161 : {
134432 36161 : SgDeclarationStatement* parentDeclaration = NULL;
134433 36161 : parentDeclaration = isSgNamespaceDefinitionStatement(scope)->get_namespaceDeclaration();
134434 36161 : ROSE_ASSERT(parentDeclaration != NULL);
134435 : // Nothing to do here!
134436 36161 : break;
134437 : }
134438 :
134439 : // DQ (7/20/2017): I don't think we have anything to do here, since there can only be class declarations in this scope, where it exists.
134440 : case V_SgDeclarationScope:
134441 : {
134442 : // Nothing to do here!
134443 : break;
134444 : }
134445 :
134446 0 : default:
134447 0 : {
134448 0 : printf ("Error: default reached in evaluation of scope within resetTemplateNamesInScope scope = %s \n",scope->sage_class_name());
134449 0 : ROSE_ASSERT(false);
134450 : break;
134451 : }
134452 : }
134453 :
134454 : // DQ (10/24/2015): Break this up so that we can enforce that we are making progress through the scopes.
134455 : // scope = scope->get_scope();
134456 51472 : ROSE_ASSERT(scope != NULL);
134457 51472 : SgScopeStatement* next_scope = scope->get_scope();
134458 : #if 0
134459 : printf ("In resetTemplateNamesInScope(): next_scope = %p \n",next_scope);
134460 : if (next_scope != NULL)
134461 : {
134462 : printf ("In resetTemplateNamesInScope(): next_scope = %p = %s \n",next_scope,next_scope->class_name().c_str());
134463 : }
134464 : #endif
134465 51472 : ROSE_ASSERT(scope != next_scope);
134466 51472 : scope = next_scope;
134467 : }
134468 :
134469 : #if 0
134470 : printf ("Leaving resetTemplateNamesInScope: after traversing through parent scopes \n");
134471 : #endif
134472 28755 : }
134473 :
134474 :
134475 :
134476 : // DQ (2/15/2005): This is the former SgTemplateInstantitionDecl::resetTemplateName()
134477 : // member function. It has been moved to a global supporting function so that similar
134478 : // support can be added to the SgTemplateInstantiationFunctionDecl and the
134479 : // SgTemplateInstantiationMemberFunctionDecl IR nodes. With this design function names
134480 : // are not known, except through their mangled names, until after the AST fixup phase.
134481 : // I think that this will not be an issue within ROSE.
134482 : // Several input parameters are passed, these are the private variables within the
134483 : // IR nodes.
134484 : // void SgDeclarationStatement::resetTemplateName ()
134485 : void
134486 49770 : SgDeclarationStatement::resetTemplateNameSupport ( bool & nameResetFromMangledForm, SgName & name )
134487 : {
134488 : // This function generates the full template name (e.g. "ABC<int>") instead of the mangled name
134489 : // stored in the p_name variable. Note that the templateArguments must be defined, we can't
134490 : // seem to just set this in the EDG interface since not all the pieces are in place as SAGE III
134491 : // IR nodes. It resets the mangled name in p_name to the full template name.
134492 :
134493 : // DQ (7/23/2012): This is one of three locations where the template arguments are assembled and where
134494 : // the name generated idically (in each case) is critical. Not clear how to best refactor this code.
134495 : // The other two are:
134496 : // SgName SageBuilder::appendTemplateArgumentsToName( const SgName & name, const SgTemplateArgumentPtrList & templateArgumentsList)
134497 : // and in:
134498 : // void SgDeclarationStatement::resetTemplateNameSupport ( bool & nameResetFromMangledForm, SgName & name )
134499 : // It is less clear how to refactor this code.
134500 :
134501 : // DQ (9/27/2004) Note: This is the only place within the construction of the Sage III AST (from EDG)
134502 : // where the unparser is called. It is in general unsafe to do this and it may be that this should
134503 : // be reserved for after the Sage III AST is fully constructed and all post processing fixup
134504 : // (currently limited to setting all parent pointers) is complete.
134505 :
134506 : // DQ (3/1/2018): Note: the name generated here can contain extra spaces between template arguments,
134507 : // different from the name generated by the SageBuilder::appendTemplateArgumentsToName() function.
134508 : // So this function should not be called in the initial construction of the AST (and serves a different
134509 : // purpose) than the function in SageBuilder. This function is intended to be called as part of the
134510 : // postprocessing normalization of name. Still it would be good to refactor this code so that the names
134511 : // generated would be identical (and tested to be identical).
134512 :
134513 : #if 0
134514 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): CRITICAL FUNCTION TO BE REFACTORED \n");
134515 : #endif
134516 :
134517 49770 : ROSE_ASSERT (this != NULL);
134518 49770 : string returnName;
134519 :
134520 : #if 0
134521 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134522 : printf ("$$$$$$$$$$$$$$ In resetTemplateNameSupport(): this = %p = %s name = %s \n",this,this->class_name().c_str(),name.str());
134523 : #endif
134524 :
134525 : #if 0
134526 : // DQ (9/25/2007): Old test, no longer valid.
134527 : // DQ (10/11/2004): Error checking for infinite recursion (just in case it could happen)
134528 : static int counter = 0;
134529 : if (counter > 10000)
134530 : {
134531 : printf ("resetTemplateNameSupport could be in endless recursion ... \n");
134532 : ROSE_ASSERT(false);
134533 : }
134534 : #endif
134535 :
134536 : // DQ (11/23/2004): Check any possible template declarations in higher-level scopes
134537 : // (in which this declaration may be nested). Such unreset names show up in qualified
134538 : // names that may be generated. Note that this should be an explicit loop over all
134539 : // parent scopes since any non-template parent scope would break the handling of all
134540 : // templates between here and the global scope! Handle this case after we debug the
134541 : // current simpler case!
134542 : #if 0
134543 : printf ("Implementation of resetTemplateNameSupport() requires loop over parent scopes!!! \n");
134544 : #endif
134545 :
134546 49770 : SgScopeStatement* parentScope = get_scope();
134547 :
134548 : #if 0
134549 : printf ("In resetTemplateNameSupport(): At %s parentScope = %s \n",class_name().c_str(),parentScope->class_name().c_str());
134550 : #endif
134551 :
134552 : // DQ (2/10/2007): I hope we can assert this!
134553 49770 : ROSE_ASSERT(parentScope != NULL);
134554 :
134555 : // DQ (10/26/2015): Moved into the conditional test below.
134556 : // This function loops over all parent scopes
134557 : // resetTemplateNamesInScope(parentScope);
134558 :
134559 : #if 0
134560 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): nameResetFromMangledForm = %s \n",nameResetFromMangledForm ? "true" : "false");
134561 : #endif
134562 :
134563 : // If the name has not been reset to the form "ABC<int>" then reset it now!
134564 : // DQ (2/15/2005): Modified to reference input parameters
134565 : // if (get_nameResetFromMangledForm() == false)
134566 49770 : if (nameResetFromMangledForm == false)
134567 : {
134568 : // DQ (10/26/2015): Moved from the end of the loop to avoid infinite
134569 : // recursive calls from the evaluation of the template arguments.
134570 28502 : nameResetFromMangledForm = true;
134571 :
134572 : #if 0
134573 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134574 : printf ("In resetTemplateNameSupport(): Calling resetTemplateNamesInScope(): parentScope = %p = %s \n",parentScope,parentScope->class_name().c_str());
134575 : #endif
134576 :
134577 : // DQ (10/26/2015): Moved to after the conditional test to avoid resetting the template name again on this declaration.
134578 : // This function loops over all parent scopes
134579 28502 : resetTemplateNamesInScope(parentScope);
134580 :
134581 : #if 0
134582 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134583 : printf ("DONE: In resetTemplateNameSupport(): Calling resetTemplateNamesInScope(): parentScope = %p = %s \n",parentScope,parentScope->class_name().c_str());
134584 : #endif
134585 :
134586 : // returnName = get_templateName().str();
134587 : // SgTemplateArgumentPtrListPtr templateArgListPtr = get_templateArguments();
134588 :
134589 28502 : bool appendTemplateArguments = true;
134590 :
134591 28502 : bool skipEmptyTemplateArgumentList = false;
134592 :
134593 : // DQ (2/28/2005): function templates need to be separated out since for them the marker of being explicit make sense.
134594 28502 : bool functionTemplateArguments = false;
134595 28502 : SgTemplateArgumentPtrListPtr templateArgListPtr = NULL;
134596 28502 : switch(variantT())
134597 : {
134598 11843 : case V_SgTemplateInstantiationDecl:
134599 11843 : {
134600 11843 : SgTemplateInstantiationDecl* node = isSgTemplateInstantiationDecl(this);
134601 11843 : ROSE_ASSERT(node != NULL);
134602 11843 : returnName = node->get_templateName().str();
134603 11843 : templateArgListPtr = &node->get_templateArguments();
134604 : #if 0
134605 : printf ("In resetTemplateNameSupport(): case V_SgTemplateInstantiationDecl: node = %p templateName = %s name = %s \n",node,node->get_templateName().str(),node->get_name().str());
134606 : #endif
134607 : // DQ (2/21/2005): Error checking on existence of substrings that can be common
134608 : // in building template name and which are a source of errors in generated code.
134609 11843 : testForBadGenerateTemplateName(returnName);
134610 : break;
134611 : }
134612 :
134613 : // DQ (4/13/2005): Combine these two cases since they are identical (error: both cases must be separate!)
134614 2272 : case V_SgTemplateInstantiationFunctionDecl:
134615 : // case V_SgTemplateInstantiationMemberFunctionDecl:
134616 2272 : {
134617 2272 : SgTemplateInstantiationFunctionDecl* node = isSgTemplateInstantiationFunctionDecl(this);
134618 2272 : ROSE_ASSERT(node != NULL);
134619 2272 : returnName = node->get_templateName().str();
134620 2272 : templateArgListPtr = &node->get_templateArguments();
134621 :
134622 : // DQ (2/28/2005): function templates need to be separated out since for them the marker of being explicit make sense.
134623 2272 : functionTemplateArguments = true;
134624 :
134625 : // DQ (2/17/2005): We can't translate "operator+" into "operator+<int>" since it will become "+<int>"
134626 : // in the unparser so make sure that this is not a name of an overloaded operator function.
134627 : // printf ("function name = %s \n",returnName.c_str());
134628 : // if (TransformationSupport::classifyOverloadedOperator(returnName) != TransformationSupport::FUNCTION_CALL_OPERATOR_CODE)
134629 2272 : if (node->get_specialFunctionModifier().isOperator() == true)
134630 : {
134631 : // printf ("Skipping appending the templates arguments to this overloaded operator \n");
134632 431 : appendTemplateArguments = false;
134633 : }
134634 :
134635 : // DQ (4/13/2005): Avoid output of empty template lists where not required (e.g. "std::endl<>" ).
134636 2272 : skipEmptyTemplateArgumentList = skipEmptyTemplateArgumentListTest(node);
134637 :
134638 : // DQ (2/21/2005): Error checking on existence of substrings that can be common
134639 : // in building template name and which are a source of errors in generated code.
134640 2272 : testForBadGenerateTemplateName(returnName);
134641 : break;
134642 : }
134643 : #if 1
134644 14387 : case V_SgTemplateInstantiationMemberFunctionDecl:
134645 14387 : {
134646 14387 : SgTemplateInstantiationMemberFunctionDecl* node = isSgTemplateInstantiationMemberFunctionDecl(this);
134647 14387 : ROSE_ASSERT(node != NULL);
134648 : #if 0
134649 : printf ("node = %p = (templateName) %s = (name) %s \n",node,node->get_templateName().str(),node->get_name().str());
134650 : #endif
134651 14387 : returnName = node->get_templateName().str();
134652 14387 : templateArgListPtr = &node->get_templateArguments();
134653 :
134654 : // DQ (2/28/2005): function templates need to be separated out since for them the marker of being explicit make sense.
134655 14387 : functionTemplateArguments = true;
134656 :
134657 : // DQ (2/17/2005): We can't translate "operator+" into "operator+<int>" since it will become "+<int>"
134658 : // in the unparser so make sure that this is not a name of an overloaded operator function.
134659 : #if 0
134660 : printf ("member function name = %s \n",returnName.c_str());
134661 : #endif
134662 : // if (TransformationSupport::classifyOverloadedOperator(returnName) != TransformationSupport::FUNCTION_CALL_OPERATOR_CODE)
134663 14387 : if (node->get_specialFunctionModifier().isOperator() == true)
134664 : {
134665 : #if 0
134666 : printf ("Skipping appending the templates arguments to this overloaded operator \n");
134667 : #endif
134668 2099 : appendTemplateArguments = false;
134669 : }
134670 :
134671 : // DQ (4/13/2005): Avoid output of empty template lists where not required (e.g. "std::endl<>" ).
134672 14387 : skipEmptyTemplateArgumentList = skipEmptyTemplateArgumentListTest(node);
134673 :
134674 : // DQ (2/21/2005): Error checking on existence of substrings that can be common
134675 : // in building template name and which are a source of errors in generated code.
134676 14387 : testForBadGenerateTemplateName(returnName);
134677 : break;
134678 : }
134679 : #endif
134680 :
134681 : // DQ (2/26/2018): Added support for the template instantiation typedef declaration.
134682 0 : case V_SgTemplateInstantiationTypedefDeclaration:
134683 0 : {
134684 0 : SgTemplateInstantiationTypedefDeclaration* node = isSgTemplateInstantiationTypedefDeclaration(this);
134685 0 : ROSE_ASSERT(node != NULL);
134686 : #if 0
134687 : printf ("In resetTemplateNameSupport(): case V_SgTemplateInstantiationTypedefDeclaration:node = %p = (templateName) %s = (name) %s \n",
134688 : node,node->get_templateName().str(),node->get_name().str());
134689 : #endif
134690 0 : returnName = node->get_templateName().str();
134691 0 : templateArgListPtr = &node->get_templateArguments();
134692 :
134693 : // DQ (2/21/2005): Error checking on existence of substrings that can be common
134694 : // in building template name and which are a source of errors in generated code.
134695 0 : testForBadGenerateTemplateName(returnName);
134696 : break;
134697 : }
134698 :
134699 28502 : default:
134700 28502 : {
134701 : // ... nothing to do here
134702 : }
134703 : }
134704 :
134705 28502 : ROSE_ASSERT(templateArgListPtr != NULL);
134706 :
134707 : #if 0
134708 : printf ("In resetTemplateNameSupport(): Handle the template arguments (where available) \n");
134709 : #endif
134710 :
134711 : // DQ (4/13/2005): Sometimes template parameters are present but were not specified in the source code and if so we
134712 : // should also not output "<>". This is a stronger test than that implemented previously (fixes output of "std::endl<>" as well).
134713 : // DQ (2/17/2005): We want to avoid "<>" appearing where template arguments are meant to be used (e.g. in function names)
134714 : // if (templateArgListPtr != NULL)
134715 : // if ( (appendTemplateArguments == true) && (templateArgListPtr->size() > 0) )
134716 28502 : if ( ( (appendTemplateArguments == true) && (templateArgListPtr->size() > 0) ) && (skipEmptyTemplateArgumentList == false) )
134717 : {
134718 : #if 0
134719 : printf ("In SgDeclarationStatement::resetTemplateName(): templateArgListPtr->size() = %" PRIuPTR " \n",templateArgListPtr->size());
134720 : #endif
134721 :
134722 14578 : returnName += " < ";
134723 14578 : SgTemplateArgumentPtrList::const_iterator i = templateArgListPtr->begin();
134724 37607 : while (i != templateArgListPtr->end())
134725 : {
134726 : #if 0
134727 : printf ("templateArgList element *i = %p = %s \n",*i,(*i)->sage_class_name());
134728 : #endif
134729 :
134730 23029 : if ((*i)->get_argumentType() == SgTemplateArgument::start_of_pack_expansion_argument) {
134731 986 : i++;
134732 986 : continue;
134733 : }
134734 :
134735 : // DQ (2/27/2005): Added support for output of only template arguments
134736 : // that were explicit in the source code. Only meaningful for function
134737 : // and member function template arguments.
134738 22043 : bool templateArgumentWasExplicitlySpecified = (*i)->get_explicitlySpecified();
134739 22043 : bool outputTemplateArgument = false;
134740 22043 : if ( ( (*i)->get_argumentType() != SgTemplateArgument::start_of_pack_expansion_argument) &&
134741 : ( (functionTemplateArguments == false) ||
134742 4109 : ( (functionTemplateArguments == true) && (templateArgumentWasExplicitlySpecified == true) ) ) )
134743 : {
134744 21883 : outputTemplateArgument = true;
134745 : }
134746 : #if 0
134747 : printf ("functionTemplateArguments = %s \n",(functionTemplateArguments == true) ? "true" : "false");
134748 : printf ("outputTemplateArgument = %s \n",(outputTemplateArgument == true) ? "true" : "false");
134749 : #endif
134750 21883 : if (outputTemplateArgument == true)
134751 : {
134752 21883 : ROSE_ASSERT( *i != NULL);
134753 : #if 0
134754 : printf ("In SgDeclarationStatement::resetTemplateName(): (*i)->get_argumentType() = %d \n",(*i)->get_argumentType());
134755 : #endif
134756 21883 : switch((*i)->get_argumentType())
134757 : {
134758 0 : case SgTemplateArgument::argument_undefined:
134759 0 : {
134760 0 : printf ("Error: SgTemplateArgument::argument_undefined not allowed \n");
134761 0 : ROSE_ASSERT(false);
134762 : break;
134763 : }
134764 :
134765 19568 : case SgTemplateArgument::type_argument:
134766 19568 : {
134767 19568 : ROSE_ASSERT((*i)->get_type() != NULL);
134768 19568 : SgType* argumentType = (*i)->get_type();
134769 : #if 0
134770 : printf ("SgTemplateArgument::type_argument: argumentType = %p = %s \n",argumentType,argumentType->sage_class_name());
134771 : #endif
134772 19568 : switch(argumentType->variantT())
134773 : {
134774 5314 : case V_SgClassType:
134775 5314 : {
134776 : // DQ (10/13/2004): If this is a template declaration then we might have to reset its name
134777 5314 : SgClassType* classType = isSgClassType(argumentType);
134778 : // printf ("Found a class declaration ... \n");
134779 5314 : SgDeclarationStatement* declaration = classType->get_declaration();
134780 5314 : ROSE_ASSERT(declaration != NULL);
134781 5314 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(declaration);
134782 5314 : ROSE_ASSERT(classDeclaration != NULL);
134783 5314 : SgTemplateInstantiationDecl* templateClassDeclaration = isSgTemplateInstantiationDecl(classDeclaration);
134784 5314 : if (templateClassDeclaration != NULL)
134785 : {
134786 : // printf ("Found a template instantiation declaration (call resetTemplateName) ... \n");
134787 4435 : templateClassDeclaration->resetTemplateName();
134788 : }
134789 : break;
134790 : }
134791 :
134792 2815 : case V_SgTypedefType:
134793 2815 : {
134794 2815 : SgTypedefType* typedefType = isSgTypedefType(argumentType);
134795 : // printf ("Found a typedef declaration ... \n");
134796 2815 : SgDeclarationStatement* declaration = typedefType->get_declaration();
134797 2815 : ROSE_ASSERT(declaration != NULL);
134798 2815 : SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(declaration);
134799 2815 : ROSE_ASSERT(typedefDeclaration != NULL);
134800 2815 : SgTemplateInstantiationDefn* defn = isSgTemplateInstantiationDefn(typedefDeclaration->get_scope());
134801 2815 : if (defn != NULL)
134802 : {
134803 : // If we start the resetTemplateName() function here in the parent scope of the typedef
134804 : // type's declaration then it should continue to call resetTemplateName() through the
134805 : // rest of the scopes to the root (global scope). Unless there is a non-template in the
134806 : // chain! So I guess the code above must be an explicit loop over all parent scopes
134807 : // until we reach global scope!
134808 1239 : SgTemplateInstantiationDecl* decl = isSgTemplateInstantiationDecl(defn->get_declaration());
134809 1239 : ROSE_ASSERT(decl != NULL);
134810 1239 : decl->resetTemplateName();
134811 : }
134812 : break;
134813 : }
134814 :
134815 : // DQ (9/11/2005): Handle these cases together
134816 : case V_SgPointerType:
134817 : case V_SgModifierType:
134818 : case V_SgReferenceType:
134819 : {
134820 : // Need to reach in and see if this is a template instantiation of a class type and then reset its name
134821 : // SgModifierType* modifierType = isSgModifierType(argumentType);
134822 : // ROSE_ASSERT(modifierType != NULL);
134823 : // SgType* strippedType = modifierType->stripType();
134824 : #if 0
134825 : printf ("Case of SgPointerType, SgModifierType, SgReferenceType \n");
134826 : #endif
134827 : #if 0
134828 : // This passes by too many places where (within typedefs for example) template names could be reset
134829 : SgType* strippedType = argumentType->stripType()
134830 : #error "DEAD CODE!"
134831 :
134832 : #else
134833 : // Handle this explicitly so that we can see the full type chain (in case there is a unset template name in the chain!)
134834 : SgType* currentType = argumentType;
134835 :
134836 6381 : SgModifierType* modType = NULL;
134837 6381 : SgPointerType* pointType = NULL;
134838 6381 : SgReferenceType* refType = NULL;
134839 6381 : SgArrayType* arrayType = NULL;
134840 : SgTypedefType* typedefType = NULL;
134841 :
134842 : // Loop through the chain of types (modifiers, references, pointers, array types, and typedefs
134843 10098 : while (true)
134844 : {
134845 : #if 0
134846 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134847 : printf ("In while(true) loop over all modifiers: currentType = %p = %s \n",currentType,currentType->class_name().c_str());
134848 : #endif
134849 6381 : if ( (modType = isSgModifierType(currentType)) )
134850 : {
134851 1803 : currentType = modType->get_base_type();
134852 : #if 0
134853 : // DQ (10/26/2015): Added test to detect simple cycle in types.
134854 : ROSE_ASSERT( isSgModifierType(currentType) != NULL &&
134855 : isSgTypedefType(isSgModifierType(currentType)->get_base_type()) != NULL &&
134856 : isSgTypedefType(isSgModifierType(currentType)->get_base_type())->get_base_type() != currentType);
134857 : #endif
134858 : #if 0
134859 : // DQ (10/26/2015): Added test to detect simple cycle in types.
134860 : SgType* baseType = currentType;
134861 : SgTypedefType* tmp_typedefType = isSgTypedefType(baseType);
134862 : if (tmp_typedefType != NULL)
134863 : {
134864 : ROSE_ASSERT(modType != tmp_typedefType->get_base_type());
134865 : }
134866 : #endif
134867 : }
134868 : else
134869 : {
134870 4578 : if ( (refType = isSgReferenceType(currentType)) )
134871 : {
134872 558 : currentType = refType->get_base_type();
134873 : }
134874 : else
134875 : {
134876 4020 : if ( (pointType = isSgPointerType(currentType)) )
134877 : {
134878 1086 : currentType = pointType->get_base_type();
134879 : }
134880 : else
134881 : {
134882 2934 : if ( (arrayType = isSgArrayType(currentType)) )
134883 : {
134884 17 : currentType = arrayType->get_base_type();
134885 : }
134886 : else
134887 : {
134888 : // DQ (6/21/2005): Added support for typedef types to be uncovered by findBaseType()
134889 2917 : if ( (typedefType = isSgTypedefType(currentType)) )
134890 : {
134891 : // DQ (10/27/2015): Added test for specific cycle in typedef types.
134892 1186 : ROSE_ASSERT( (isSgModifierType(isSgTypedefType(currentType)->get_base_type()) == NULL) ||
134893 : ( (isSgModifierType(isSgTypedefType(currentType)->get_base_type()) != NULL) &&
134894 : (isSgModifierType(isSgTypedefType(currentType)->get_base_type())->get_base_type() != currentType) ) );
134895 :
134896 : // DQ (10/26/2015): This should be true, I think. Debugging infinite loop problem (test2015_97.C).
134897 1186 : ROSE_ASSERT(currentType != typedefType->get_base_type());
134898 :
134899 1186 : currentType = typedefType->get_base_type();
134900 : #if 0
134901 : printf ("typedefType->get_base_type(): currentType = %p = %s \n",currentType,currentType->class_name().c_str());
134902 : #endif
134903 : }
134904 : else
134905 : {
134906 : // Exit the while(true){} loop!
134907 : break;
134908 : }
134909 : }
134910 : }
134911 : }
134912 : }
134913 :
134914 : // printf ("In resetTemplateName: stripping type - currentType = %s hidden behind this = %s \n",
134915 : // currentType->sage_class_name(),argumentType->sage_class_name());
134916 :
134917 : // Check all typedefs that we find along the way (in this while loop through the modifiers)!
134918 1186 : if (typedefType != NULL)
134919 : {
134920 : #if 1
134921 1186 : SgDeclarationStatement* likelyTypedefDeclaration = typedefType->get_declaration();
134922 1186 : ROSE_ASSERT( likelyTypedefDeclaration != NULL);
134923 1186 : SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(likelyTypedefDeclaration);
134924 1186 : ROSE_ASSERT( typedefDeclaration != NULL);
134925 : #endif
134926 : #if 0
134927 : printf ("In resetTemplateName: In loop over typedefs, modifiers, etc. found a typedef = %s \n",typedefDeclaration->get_name().str());
134928 : #endif
134929 : #if 0
134930 : typedefDeclaration->get_file_info()->display("In resetTemplateName: typedefDeclaration: debug");
134931 : #endif
134932 1186 : SgType* baseType = typedefType->get_base_type();
134933 1186 : ROSE_ASSERT(currentType == baseType);
134934 1186 : ROSE_ASSERT(baseType != NULL);
134935 1186 : SgClassType* classType = isSgClassType(baseType);
134936 1186 : if (classType != NULL)
134937 : {
134938 : // printf ("In loop over typedefs, modifiers, etc. found a class type \n");
134939 224 : SgDeclarationStatement* declaration = classType->get_declaration();
134940 224 : ROSE_ASSERT(declaration != NULL);
134941 224 : SgTemplateInstantiationDecl* classTemplateInstantiation = isSgTemplateInstantiationDecl(declaration);
134942 224 : if (classTemplateInstantiation != NULL)
134943 : {
134944 : // printf ("Found a instantiated class template inside the class type (resetting name = %s) \n",
134945 : // classTemplateInstantiation->get_name().str());
134946 224 : classTemplateInstantiation->resetTemplateName();
134947 : }
134948 : }
134949 :
134950 : // ROSE_ASSERT(typedefType->get_declaration() != NULL);
134951 : // ROSE_ASSERT(isSgTypedefDeclaration(typedefType->get_declaration()) != NULL);
134952 : // SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(typedefType->get_declaration());
134953 1186 : SgScopeStatement* typedefScope = typedefDeclaration->get_scope();
134954 1186 : ROSE_ASSERT(typedefScope != NULL);
134955 : #if 0
134956 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134957 : printf ("In resetTemplateName: traversing through parent scopes to reset any instantiated template names: typedefScope = %p = %s \n",
134958 : typedefScope,typedefScope->class_name().c_str());
134959 : #endif
134960 :
134961 : // DQ (6/30/2018): Detect an break cycles in typedefs (debugging test2018_118.C).
134962 : // resetTemplateNamesInScope(typedefScope);
134963 1186 : static std::set<SgScopeStatement*> scopeSet;
134964 2372 : if (scopeSet.find(typedefScope) == scopeSet.end())
134965 : {
134966 253 : scopeSet.insert(typedefScope);
134967 253 : resetTemplateNamesInScope(typedefScope);
134968 : }
134969 : else
134970 : {
134971 : #if 0
134972 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134973 : printf ("In resetTemplateName: scope was previously seen: typedefScope = %p = %s \n",typedefScope,typedefScope->class_name().c_str());
134974 : #endif
134975 : // Exit the while(true){} loop!
134976 : break;
134977 : }
134978 : #if 0
134979 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134980 : // DQ (10/24/2015): When we are in an infinite loop (current bug) we never get to this location in the code (I think).
134981 : printf ("DONE: In resetTemplateName: traversing through parent scopes to reset any instantiated template names: typedefScope = %p = %s \n",
134982 : typedefScope,typedefScope->class_name().c_str());
134983 : #endif
134984 : }
134985 :
134986 : // reset these to NULL (to avoid saving a history, this allows the typedefType to be checked)
134987 3717 : modType = NULL;
134988 3717 : refType = NULL;
134989 3717 : pointType = NULL;
134990 3717 : arrayType = NULL;
134991 3717 : typedefType = NULL;
134992 :
134993 3717 : ROSE_ASSERT(currentType != NULL);
134994 : #if 0
134995 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
134996 : printf ("END OF WHILE LOOP: currentType = %p = %s \n",currentType,currentType->class_name().c_str());
134997 : #endif
134998 3717 : }
134999 :
135000 2664 : SgType* strippedType = currentType;
135001 : #endif
135002 : #if 0
135003 : printf ("In resetTemplateName: process the strippedType = %p = %s \n",strippedType,strippedType->class_name().c_str());
135004 : #endif
135005 2664 : ROSE_ASSERT(strippedType != NULL);
135006 2664 : SgClassType* classType = isSgClassType(strippedType);
135007 2664 : if (classType != NULL)
135008 : {
135009 : // printf ("Found a class type \n");
135010 503 : SgDeclarationStatement* declaration = classType->get_declaration();
135011 503 : ROSE_ASSERT(declaration != NULL);
135012 503 : SgTemplateInstantiationDecl* classTemplateInstantiation = isSgTemplateInstantiationDecl(declaration);
135013 503 : if (classTemplateInstantiation != NULL)
135014 : {
135015 : // printf ("Found a instantiated class template inside the class type (resetting name = %s) \n",
135016 : // classTemplateInstantiation->get_name().str());
135017 407 : classTemplateInstantiation->resetTemplateName();
135018 : }
135019 : }
135020 : break;
135021 : }
135022 :
135023 :
135024 : // DQ (7/23/2012): This appears to be a missing case.
135025 : case V_SgTemplateType:
135026 : {
135027 : // DQ (10/13/2004): If this is a template declaration then we might have to reset its name
135028 : // SgTemplateType* templateType = isSgTemplateType(argumentType);
135029 : #if 1
135030 : // DQ (8/26/2012): Decrease the volume of warnings from this part of the code.
135031 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
135032 : static int count = 0;
135033 :
135034 : // DQ (6/30/2018): Debuging infinite loop in test2018_117.C.
135035 : // if (count++ % 1 == 0)
135036 : if (count++ % 100 == 0)
135037 : {
135038 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): case SgTemplateArgument::type_argument: Found a SgTemplateType ... (nothing done in this case) \n");
135039 : }
135040 : #endif
135041 : #else
135042 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): case SgTemplateArgument::type_argument: Found a SgTemplateType ... (nothing done in this case) \n");
135043 : #endif
135044 : // SgDeclarationStatement* declaration = templateType->get_declaration();
135045 : // ROSE_ASSERT(declaration != NULL);
135046 : // printf ("In SgDeclarationStatement::resetTemplateNameSupport(): case SgTemplateArgument::type_argument: declaration = %p = %s \n",declaration,declaration->class_name().c_str());
135047 : #if 1
135048 : // Not clear if we have to reset the name of a template (unles it uses partial specialization,
135049 : // but then it would be a partial template instantiation, I think. We might also have to explicitly
135050 : // handle each of the different types of template declarations directly (if resetTemplateName()
135051 : // is not a virtual function).
135052 : // printf ("In SgDeclarationStatement::resetTemplateNameSupport(): case SgTemplateArgument::type_argument: Found a template instantiation declaration (SKIP calling resetTemplateName) ... (do we need this?) \n");
135053 : // declaration->resetTemplateName();
135054 : #else
135055 : // OLD CODE...
135056 : SgClassDeclaration* classDeclaration = isSgClassDeclaration(declaration);
135057 : ROSE_ASSERT(classDeclaration != NULL);
135058 : SgTemplateInstantiationDecl* templateClassDeclaration = isSgTemplateInstantiationDecl(classDeclaration);
135059 : if (templateClassDeclaration != NULL)
135060 : {
135061 : // printf ("Found a template instantiation declaration (call resetTemplateName) ... \n");
135062 : templateClassDeclaration->resetTemplateName();
135063 : }
135064 : #endif
135065 : break;
135066 : }
135067 :
135068 : // DQ (8/29/2009): Added SgArrayType to eliminate error message about
135069 : // default being reached (missed including this type previously).
135070 : case V_SgArrayType:
135071 :
135072 : // Rasmussen (2/18/2020): Added SgTypeFixed (primitive type in Jovial)
135073 : case V_SgTypeFixed:
135074 :
135075 : // DQ (2/28/2005): List of types used in compiling Kull
135076 : case V_SgTypeChar:
135077 : case V_SgTypeWchar:
135078 : case V_SgTypeBool:
135079 : case V_SgTypeSignedChar:
135080 : case V_SgTypeUnsignedChar:
135081 : case V_SgTypeShort:
135082 : case V_SgTypeUnsignedShort:
135083 : case V_SgTypeUnsignedInt:
135084 : case V_SgTypeLong:
135085 : case V_SgTypeUnsignedLong:
135086 : case V_SgTypeLongLong:
135087 : case V_SgTypeUnsignedLongLong:
135088 : case V_SgTypeFloat:
135089 : case V_SgTypeDouble:
135090 : case V_SgTypeLongDouble:
135091 : case V_SgTypeVoid:
135092 : case V_SgTypeInt:
135093 : case V_SgEnumType:
135094 : {
135095 : // Nothing to do here with these primitive types (listed explicitly to avoid compiler warnings)
135096 : break;
135097 : }
135098 :
135099 : default:
135100 : {
135101 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
135102 : printf ("Default reached in switch over SgTemplateArgument::type_argument (argumentType = %p = %s) \n",argumentType,argumentType->class_name().c_str());
135103 : #endif
135104 : // ROSE_ASSERT(false);
135105 : }
135106 : }
135107 : break;
135108 : }
135109 :
135110 2315 : case SgTemplateArgument::nontype_argument:
135111 2315 : {
135112 : // These can be boolean or integer values, for example.
135113 : // ROSE_ASSERT((*i)->get_expression() != NULL);
135114 2315 : ROSE_ASSERT((*i)->get_expression() != NULL || (*i)->get_initializedName() != NULL);
135115 2315 : ROSE_ASSERT((*i)->get_expression() == NULL || (*i)->get_initializedName() == NULL);
135116 :
135117 2315 : if ((*i)->get_expression() != NULL)
135118 : {
135119 : #if 0
135120 : SgExpression* argumentExpression = (*i)->get_expression();
135121 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): case SgTemplateArgument::nontype_argument: argumentExpression = %p = %s \n",argumentExpression,argumentExpression->class_name().c_str());
135122 : #endif
135123 : }
135124 : else
135125 : {
135126 : #if 0
135127 : SgInitializedName* argumentInitializedName = (*i)->get_initializedName();
135128 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): case SgTemplateArgument::nontype_argument: argumentInitializedName = %p = %s \n",argumentInitializedName,argumentInitializedName->get_name().str());
135129 : #endif
135130 : }
135131 :
135132 : break;
135133 : }
135134 :
135135 0 : case SgTemplateArgument::template_template_argument:
135136 0 : {
135137 : // DQ (8/24/2006): This is not a name that needs to be reset, so I think there is nothing to do here!
135138 0 : ROSE_ASSERT((*i)->get_templateDeclaration() != NULL);
135139 :
135140 : // printf ("Warning: SgTemplateArgument::template_template_argument not implemented \n");
135141 : // ROSE_ASSERT(false);
135142 0 : break;
135143 : }
135144 :
135145 : case SgTemplateArgument::start_of_pack_expansion_argument:
135146 : {
135147 : // DQ (5/19/2014): This is not a name that needs to be reset, so I think there is nothing to do here!
135148 : // ROSE_ASSERT((*i)->get_templateDeclaration() != NULL);
135149 : #if 0
135150 : printf ("Warning: In SgDeclarationStatement::resetTemplateNameSupport(): SgTemplateArgument::start_of_pack_expansion_argument (no reset of name required) \n");
135151 : // ROSE_ASSERT(false);
135152 : #endif
135153 : break;
135154 : }
135155 :
135156 0 : default:
135157 0 : {
135158 0 : printf ("Default reached in switch over (*i)->get_argumentType() = %d \n",(*i)->get_argumentType());
135159 0 : ROSE_ASSERT(false);
135160 : }
135161 : }
135162 :
135163 : // DQ (2/21/2005): Error checking on existence of substrings that can be common
135164 : // in building template name and which are a source of errors in generated code.
135165 21883 : testForBadGenerateTemplateName(returnName);
135166 :
135167 : // DQ (2/28/2005): Pass in an explicit unparse info object to control (and turn off) the
135168 : // unparsing of definitions within the unparsing of types used as template arguments.
135169 : // This avoids generation of bad code like "x6.foo<const enum values {zero,nonzero}>();"
135170 : // (see test2005_13.C for details on this bug).
135171 43766 : SgUnparse_Info unparseInfo;
135172 21883 : unparseInfo.set_SkipDefinition();
135173 21883 : ROSE_ASSERT (unparseInfo.SkipDefinition() == true);
135174 :
135175 : // DQ (2/28/2005): Set these to be consistent with unparseToString
135176 : // Skip all comments in unparsing
135177 21883 : unparseInfo.set_SkipComments();
135178 21883 : ROSE_ASSERT (unparseInfo.SkipComments() == true);
135179 : // Skip all whitespace in unparsing (removed in generated string)
135180 21883 : unparseInfo.set_SkipWhitespaces();
135181 21883 : ROSE_ASSERT (unparseInfo.SkipWhitespaces() == true);
135182 :
135183 : // Skip all directives (macros are already substituted by the front-end, so this has no effect on those)
135184 21883 : unparseInfo.set_SkipCPPDirectives();
135185 21883 : ROSE_ASSERT (unparseInfo.SkipCPPDirectives() == true);
135186 :
135187 : // DQ (6/9/2007): Set the scope from which the name qualification for the template arguments should be computed!
135188 21883 : ROSE_ASSERT(*i != NULL);
135189 21883 : SgScopeStatement* localScope = (*i)->get_scope();
135190 21883 : unparseInfo.set_current_scope(localScope);
135191 :
135192 : // DQ (2/28/2005): Call globalUnparseToString() so tht we can specify
135193 : // greater control over unparsing.
135194 : // DQ (10/12/2004): This can be called now the this function is called after the
135195 : // post-processing fixup of the parent nodes in the AST (after the EDG/Sage III translation).
135196 : // This simplifies the implementation and permits the unparser to call the functions
135197 : // required to generate qualified names (which require that the parent pointers be set).
135198 : // returnName += (*i)->unparseToString(unparseInfo);
135199 : #if 0
135200 : printf ("Before globalUnparseToString: returnName = %s \n",returnName.c_str());
135201 : #endif
135202 43766 : returnName += globalUnparseToString(*i,&unparseInfo);
135203 : #if 0
135204 : printf ("After globalUnparseToString: returnName = %s \n",returnName.c_str());
135205 : #endif
135206 : // DQ (2/21/2005): Error checking on existence of substrings that can be common
135207 : // in building template name and which are a source of errors in generated code.
135208 21883 : testForBadGenerateTemplateName(returnName);
135209 : }
135210 : #if 0
135211 : printf ("Increment the template argument iterator! \n");
135212 : #endif
135213 : // DQ (2/27/2005): Added support for output of only template arguments
135214 : // that were explicit in the source code.
135215 : // if (templateArgumentWasExplicitlySpecified == true)
135216 22043 : if (outputTemplateArgument == true)
135217 : {
135218 : // Increment to next template argument
135219 21883 : i++;
135220 :
135221 21883 : if (i != templateArgListPtr->end())
135222 45250 : returnName += " , ";
135223 : }
135224 : else
135225 : {
135226 : // Increment to next template argument
135227 160 : i++;
135228 : }
135229 : }
135230 :
135231 : // Close off the template argument list
135232 14578 : returnName += " > ";
135233 :
135234 : #if 0
135235 : // DQ (2/20/2005): Error checking on existence of substrings that can be common
135236 : // in building template name and which are a source of errors in generated code.
135237 : if ( (returnName.find("<<") != string::npos) || (returnName.find(">>") != string::npos) )
135238 : {
135239 : printf ("returnName = %s \n",returnName.c_str());
135240 : }
135241 : ROSE_ASSERT (returnName.find("<<") == string::npos);
135242 : ROSE_ASSERT (returnName.find(">>") == string::npos);
135243 : #endif
135244 : }
135245 : else
135246 : {
135247 : // DQ (2/17/2005): This can be the case of a member function of a templated class which
135248 : // would of course not have any template arguments specific to it as a function.
135249 : // printf ("Error in resetTemplateName(): No valid template argument list \n");
135250 : // ROSE_ASSERT(false);
135251 : }
135252 :
135253 : // printf ("In SgDeclarationStatement::resetTemplateNameSupport(): Output the symbol table for scope = %p = %s: \n",parentScope,parentScope->class_name().c_str());
135254 : // SageInterface::outputLocalSymbolTables(parentScope);
135255 :
135256 : #if 0
135257 : printf ("In resetTemplateNameSupport(): Handle the symbol support \n");
135258 : #endif
135259 :
135260 : #if 0
135261 : // DQ (2/10/2007): Unload the associated symbol using the old name and reload it into the symbol table using the new name!
135262 : printf ("\n\nCalling this->get_symbol_from_symbol_table() on %s parentScope = %p = %s name = %s count = %ld \n",
135263 : this->class_name().c_str(),parentScope,parentScope->class_name().c_str(),name.str(),parentScope->count_symbol(name));
135264 : printf (" this = %p = %s definingDeclaration = %p \n",this,this->class_name().c_str(),this->get_definingDeclaration());
135265 : printf (" this = %p = %s firstNondefiningDeclaration = %p \n",this,this->class_name().c_str(),this->get_firstNondefiningDeclaration());
135266 : const SgTemplateInstantiationDecl* templateInstantiation = isSgTemplateInstantiationDecl(this);
135267 : if (templateInstantiation != NULL)
135268 : {
135269 : printf ("templateInstantiation->get_name() = %s get_templateName() = %s \n",templateInstantiation->get_name().str(),templateInstantiation->get_templateName().str());
135270 : printf ("templateInstantiation->get_scope() = %p = %s \n",templateInstantiation->get_scope(),templateInstantiation->get_scope()->class_name().c_str());
135271 : }
135272 : const SgTemplateInstantiationFunctionDecl* templateInstantiationFunction = isSgTemplateInstantiationFunctionDecl(this);
135273 : if (templateInstantiationFunction != NULL)
135274 : {
135275 : printf ("templateInstantiationFunction->get_name() = %s get_templateName() = %s \n",templateInstantiationFunction->get_name().str(),templateInstantiationFunction->get_templateName().str());
135276 : printf ("templateInstantiationFunction->get_scope() = %p = %s \n",templateInstantiationFunction->get_scope(),templateInstantiationFunction->get_scope()->class_name().c_str());
135277 : }
135278 : const SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(this);
135279 : if (templateInstantiationMemberFunction != NULL)
135280 : {
135281 : printf ("templateInstantiationMemberFunction->get_name() = %s get_templateName() = %s \n",templateInstantiationMemberFunction->get_name().str(),templateInstantiationMemberFunction->get_templateName().str());
135282 : printf ("templateInstantiationMemberFunction->get_scope() = %p = %s \n",templateInstantiationMemberFunction->get_scope(),templateInstantiationMemberFunction->get_scope()->class_name().c_str());
135283 : }
135284 : #endif
135285 :
135286 28502 : SgSymbol* symbol = this->get_symbol_from_symbol_table();
135287 28502 : if (symbol == NULL)
135288 : {
135289 : // If searching for the old name returned a null symbol pointer then make sure that there is an entry for the new name
135290 : #if 0
135291 : printf ("Searching for returnName = %s \n",returnName.c_str());
135292 : #endif
135293 : #if 0
135294 : if (parentScope->count_symbol(returnName) >= 1)
135295 : {
135296 : printf ("Warning: symbol for returnName = %s is already in the symbol table but not associated with this = %p = %s count = %ld \n",
135297 : returnName.c_str(),this,this->class_name().c_str(),parentScope->count_symbol(returnName));
135298 : printf (" (count too large) this = %p = %s this->get_definingDeclaration() = %p \n",this,this->class_name().c_str(),this->get_definingDeclaration());
135299 : printf (" (count too large) this = %p = %s this->get_firstNondefiningDeclaration() = %p \n",this,this->class_name().c_str(),this->get_firstNondefiningDeclaration());
135300 : }
135301 : #endif
135302 : // ROSE_ASSERT(parentScope->count_symbol(returnName) >= 1);
135303 : #if 0
135304 : printf ("There are a number of reasons why we could not have a valid symbol at this point: (parentScope = %p = %s = %s) \n",
135305 : parentScope,parentScope->class_name().c_str(),SageInterface::get_name(parentScope).c_str());
135306 : printf (" 1) template used as base class in SgCtorInitializerList \n");
135307 : printf (" 2) template used as in a type \n");
135308 : printf (" 3) Either the processing of the defining or non-defining declaration already removed the symbol using the old name \n");
135309 : printf ("******************** START **********************\n");
135310 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): Output the symbol table for scope = %p = %s: \n",parentScope,parentScope->class_name().c_str());
135311 : SageInterface::outputLocalSymbolTables(parentScope);
135312 : printf ("******************** DONE ***********************\n");
135313 : #endif
135314 : #if 0
135315 : printf ("Exiting as a test in resetTemplateNameSupport(): symbol = %p returnName = %s \n",symbol,returnName.c_str());
135316 : ROSE_ASSERT(false);
135317 : #endif
135318 : }
135319 : else
135320 : {
135321 : // Remove the symbol (previously inserted under the old name and hashed accordingly)
135322 : // so that we can reinsert it into the symbol table after we change the name.
135323 : #if 0
135324 : printf ("Removing the symbol = %p = %s name = %s from scope %p = %s \n",symbol,symbol->class_name().c_str(),name.str(),parentScope,parentScope->class_name().c_str());
135325 : SgClassSymbol* classSymbol = isSgClassSymbol(symbol);
135326 : if (classSymbol != NULL)
135327 : {
135328 : printf ("classSymbol->get_declaration() = %p = %s name = %s \n",classSymbol->get_declaration(),classSymbol->get_declaration()->class_name().c_str(),classSymbol->get_declaration()->get_name().str());
135329 : }
135330 : SgFunctionSymbol* functionSymbol = isSgFunctionSymbol(symbol);
135331 : if (functionSymbol != NULL)
135332 : {
135333 : printf ("functionSymbol->get_declaration() = %p = %s name = %s \n",functionSymbol->get_declaration(),functionSymbol->get_declaration()->class_name().c_str(),functionSymbol->get_declaration()->get_name().str());
135334 : }
135335 : SgMemberFunctionSymbol* memberFunctionSymbol = isSgMemberFunctionSymbol(symbol);
135336 : if (memberFunctionSymbol != NULL)
135337 : {
135338 : printf ("memberFunctionSymbol->get_declaration() = %p = %s name = %s \n",memberFunctionSymbol->get_declaration(),memberFunctionSymbol->get_declaration()->class_name().c_str(),memberFunctionSymbol->get_declaration()->get_name().str());
135339 : }
135340 : #endif
135341 : #if 0
135342 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): removing symbol = %p = %s for symbol_basis = %p = %s \n",
135343 : symbol,symbol->class_name().c_str(),symbol->get_symbol_basis(),symbol->get_symbol_basis()->class_name().c_str());
135344 : #endif
135345 : // ROSE_ASSERT(false);
135346 :
135347 19349 : parentScope->remove_symbol(symbol);
135348 : }
135349 :
135350 : // DQ (2/15/2005): Modified to reference input parameters ("name" is an input parameter to this function!)
135351 : // set_name( returnName.c_str());
135352 28502 : name = returnName.c_str();
135353 : // DQ (2/10/2007): If we have a symbol then reinsert it into the symbol table using the new name
135354 28502 : if (symbol != NULL)
135355 : {
135356 : // printf ("Inserting the symbol = %p = %s name = %s from scope %p = %s \n",symbol,symbol->class_name().c_str(),name.str(),parentScope,parentScope->class_name().c_str());
135357 19349 : parentScope->insert_symbol(name,symbol);
135358 : #if 0
135359 : printf ("In SgDeclarationStatement::resetTemplateNameSupport(): Output the symbol table: \n");
135360 : SageInterface::outputLocalSymbolTables(parentScope);
135361 : #endif
135362 : }
135363 :
135364 : // DQ (2/15/2005): Modified to reference input parameters
135365 : // DQ (10/11/2004): Removed call to unparser since it often requires that the parents
135366 : // be set. Now we have to mark this template as no longer containing a mangled name
135367 : // set_nameResetFromMangledForm(true);
135368 : // nameResetFromMangledForm = true;
135369 28502 : ROSE_ASSERT(nameResetFromMangledForm == true);
135370 :
135371 : // DQ (2/20/2005): Error checking on existence of substrings that can be common
135372 : // in building template name and which are a source of errors in generated code.
135373 28502 : testForBadGenerateTemplateName(returnName);
135374 : }
135375 :
135376 : #if 0
135377 : // DQ (6/30/2018): This is helpful in tracing through typedef circular dependences possible with templates (see test2018_118.C).
135378 : printf ("$$$$$$$$$$$$$$ Leaving SgDeclarationStatement::resetTemplateNameSupport(): name = %s \n",name.str());
135379 : #endif
135380 49770 : }
135381 :
135382 :
135383 : // This is a local file scope (support) function
135384 : static void
135385 0 : stringSupport ( string & sourceString, const string & targetString, const string & replacementString )
135386 : {
135387 0 : if (sourceString.find(targetString) != string::npos)
135388 : {
135389 0 : sourceString.replace(sourceString.find(targetString),targetString.size(),replacementString);
135390 : }
135391 0 : }
135392 :
135393 : // SgName SgDeclarationStatement::fixupTemplateNameForMangledNameSupport( const SgName & name) const
135394 : // static SgName fixupTemplateNameForMangledNameSupport( const SgName & name)
135395 : SgName
135396 0 : SgDeclarationStatement::fixupTemplateNameForMangledNameSupport( const SgName & name) const
135397 : {
135398 : // Where template names are reset to the form "foo < int >" we can look for just
135399 : // the " < " and " > " substrings which are guaranteed to exist by construction!
135400 0 : string s = name.str();
135401 :
135402 : // printf ("In fixupTemplateNameForMangledNameSupport(): Before filtering s = %s \n",s.c_str());
135403 :
135404 : // Now remove any spaces (since we can't have spaces in mangled names)
135405 0 : while (s.find(" ") != string::npos)
135406 : {
135407 0 : s.replace(s.find(" "),1,"");
135408 : }
135409 :
135410 : // To safely fixup all template syntax (e.g. "<x>") to remove the "<" and ">" we have to take care to not
135411 : // change the name of any operator (such as "operator<<", "operator>>", "operator<", "operator>",
135412 : // "operator<=", and "operator>="
135413 : // Note that this is a current bug for:
135414 : // __copy_backward_dispatch<std::vector <int,std::allocator<int>>::value_type*,std::vector<int,std::allocator<int>>::value_type*,__type_traits<int>::has_trivial_assignment_operator>
135415 :
135416 : #if 0
135417 : if (s.find("_operator>") != string::npos)
135418 : {
135419 : printf ("This name constains the substring \"_operator>\" which will not be translated into a mangled name correctly! \n");
135420 : printf (" Original name = %s \n",s.c_str());
135421 : // ROSE_ASSERT(false);
135422 : }
135423 : #endif
135424 :
135425 : // DQ (6/22/2005): Special case handling for substring "_operator>"
135426 0 : stringSupport (s,"_operator>","_operator?");
135427 :
135428 0 : stringSupport (s,"operator>>","operator??");
135429 0 : stringSupport (s,"operator<<","operator$$");
135430 0 : stringSupport (s,"operator>","operator?");
135431 0 : stringSupport (s,"operator<","operator$");
135432 0 : stringSupport (s,"operator*","operator@");
135433 :
135434 0 : string templateMarkerStart = "<";
135435 0 : int length = templateMarkerStart.size();
135436 0 : while (s.find(templateMarkerStart) != string::npos)
135437 : {
135438 : // s.replace(s.find(templateMarkerStart),3,"__templateArgs__");
135439 0 : s.replace(s.find(templateMarkerStart),length,"__tas__"); // Template Arguments Start (TAS)
135440 : }
135441 :
135442 0 : string templateMarkerEnd = ">";
135443 0 : length = templateMarkerEnd.size();
135444 0 : while (s.find(templateMarkerEnd) != string::npos)
135445 : {
135446 : // s.replace(s.find(templateMarkerEnd),3,"__");
135447 0 : s.replace(s.find(templateMarkerEnd),length,"__tae__"); // Template Arguments End (TAE)
135448 : }
135449 :
135450 0 : string scopeOperator = "::";
135451 0 : length = scopeOperator.size();
135452 0 : while (s.find(scopeOperator) != string::npos)
135453 : {
135454 0 : s.replace(s.find(scopeOperator),length,"__scope__"); // replace scope operator in qualified names
135455 : }
135456 :
135457 0 : string commaSeparator = ",";
135458 0 : length = commaSeparator.size();
135459 0 : while (s.find(commaSeparator) != string::npos)
135460 : {
135461 0 : s.replace(s.find(commaSeparator),length,"__comma__"); // replace the comma separator between template arguments
135462 : }
135463 :
135464 0 : string referenceMarker = "&";
135465 0 : length = referenceMarker.size();
135466 0 : while (s.find(referenceMarker) != string::npos)
135467 : {
135468 0 : s.replace(s.find(referenceMarker),length,"__ref__"); // replace the comma separator between template arguments
135469 : }
135470 :
135471 0 : string pointerMarker = "*";
135472 0 : length = pointerMarker.size();
135473 0 : while (s.find(pointerMarker) != string::npos)
135474 : {
135475 0 : s.replace(s.find(pointerMarker),length,"__ptr__"); // replace the comma separator between template arguments
135476 : }
135477 :
135478 : // DQ (8/10/2005): This is a fix for a bug where a "-" shows up in some template
135479 : // arguments within names generated from compiling boost (boost/mpl/if.hpp).
135480 : // I think that is shows up with "-1" is passed as an argument to a template.
135481 0 : string minusMarker = "_-";
135482 0 : length = minusMarker.size();
135483 0 : while (s.find(minusMarker) != string::npos)
135484 : {
135485 0 : s.replace(s.find(minusMarker),length,"__minus__"); // replace the minus operator between template arguments
135486 : }
135487 :
135488 : // DQ (6/22/2005): Special case handling for substring "_operator>"
135489 0 : stringSupport (s,"_operator?","_operator__tae__");
135490 :
135491 0 : stringSupport (s,"operator??","operator>>");
135492 0 : stringSupport (s,"operator$$","operator<<");
135493 0 : stringSupport (s,"operator?","operator>");
135494 0 : stringSupport (s,"operator$","operator<");
135495 0 : stringSupport (s,"operator@","operator*");
135496 :
135497 : // Now remove any spaces (since we can't have spaces in mangled names)
135498 0 : while (s.find(" ") != string::npos)
135499 : {
135500 0 : s.replace(s.find(" "),1,"");
135501 : }
135502 :
135503 : // printf ("In fixupTemplateNameForMangledNameSupport(): after filtering s = %s \n",s.c_str());
135504 :
135505 0 : ROSE_ASSERT (s.find("::") == string::npos);
135506 0 : if (s.find(":") != string::npos)
135507 : {
135508 : // sleep(2);
135509 0 : printf ("Error: failed test for embedded \":\" in template name = %s \n",s.c_str());
135510 : }
135511 0 : ROSE_ASSERT (s.find(":") == string::npos);
135512 0 : ROSE_ASSERT (s.find(",") == string::npos);
135513 :
135514 0 : return s;
135515 : }
135516 :
135517 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
135518 : SgName
135519 0 : SgDeclarationStatement::get_mangled_name(void) const
135520 : {
135521 : // printf ("In SgDeclarationStatement::get_mangled_name() name = %s \n",SageInterface::get_name(this).c_str());
135522 :
135523 0 : SgName returnName;
135524 :
135525 0 : returnName = "Not_yet_defined_mangled_name";
135526 :
135527 0 : printf ("Warning: mangled name for %s not yet defined, base class SgDeclarationStatement::get_mangled_name called \n",class_name().c_str());
135528 0 : ROSE_ASSERT(false);
135529 :
135530 : return returnName;
135531 : }
135532 :
135533 : SgName
135534 0 : SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration_in_scope ( SgScopeStatement* scope ) const
135535 : {
135536 0 : SgName name;
135537 :
135538 0 : ROSE_ASSERT(scope != NULL);
135539 :
135540 : // First setup the prefix for the generated name
135541 0 : switch (scope->variantT())
135542 : {
135543 0 : case V_SgGlobal:
135544 0 : {
135545 : // Some unnamed declarations can appear in global scope and we have to figure out how
135546 : // to assign them unique names. See the examples for each case below.
135547 : // SgGlobal* definition = isSgGlobal(parent);
135548 :
135549 0 : name = string("unnamed_class_declaration_in_global_definition_");
135550 0 : break;
135551 : }
135552 :
135553 0 : case V_SgClassDefinition:
135554 0 : {
135555 0 : name = string("unnamed_class_declaration_in_class_definition_");
135556 0 : break;
135557 : }
135558 :
135559 0 : case V_SgTemplateInstantiationDefn:
135560 0 : {
135561 0 : name = string("unnamed_class_declaration_in_class_template_definition_");
135562 0 : break;
135563 : }
135564 :
135565 0 : case V_SgBasicBlock:
135566 0 : {
135567 0 : name = string("unnamed_class_declaration_in_basic_block_");
135568 0 : break;
135569 : }
135570 :
135571 0 : case V_SgNamespaceDefinitionStatement:
135572 0 : {
135573 0 : SgNamespaceDefinitionStatement* definition = isSgNamespaceDefinitionStatement(scope);
135574 :
135575 : // DQ (3/19/2016): Klocworks reports an issue because "definition" might be NULL.
135576 0 : ROSE_ASSERT(definition != NULL);
135577 :
135578 : // It might be overkill to us the mangled name here
135579 0 : name = string("unnamed_declaration_in_namespace_definition_") + definition->get_mangled_name();
135580 : #if 0
135581 : printf ("This case should be implemented the same as for the SgGlobal case above \n");
135582 : ROSE_ASSERT(false);
135583 : #endif
135584 0 : break;
135585 : }
135586 :
135587 0 : default:
135588 0 : {
135589 0 : printf ("Default reached in unnamed declaration within parent = %p = %s \n",scope,scope->class_name().c_str());
135590 0 : get_file_info()->display("Error: location of problem unnamed SgClassDeclaration");
135591 0 : ROSE_ASSERT(scope->get_file_info() != NULL);
135592 0 : scope->get_file_info()->display("Error: location of problem unnamed SgClassDeclaration");
135593 0 : ROSE_ASSERT(false);
135594 : }
135595 :
135596 : }
135597 :
135598 : // Now generate the unique string for the declaration (use the data/enum members where possible)
135599 0 : switch(variantT())
135600 : {
135601 0 : case V_SgTemplateClassDeclaration:
135602 0 : {
135603 0 : printf ("ERROR: case not handled for SgTemplateClassDeclaration \n");
135604 0 : ROSE_ASSERT(false);
135605 : break;
135606 : }
135607 :
135608 0 : case V_SgClassDeclaration:
135609 0 : {
135610 : // case of "class { int x; }; in global scope
135611 0 : const SgClassDeclaration* classDeclaration = isSgClassDeclaration(this);
135612 0 : ROSE_ASSERT(classDeclaration != NULL);
135613 0 : const SgClassDefinition* classDefinition = isSgClassDefinition(this);
135614 : // ROSE_ASSERT(classDefinition != NULL);
135615 0 : if (classDefinition != NULL)
135616 : {
135617 0 : name = name + "defining_declaration";
135618 0 : const SgDeclarationStatementPtrList & l = classDefinition->get_members();
135619 0 : SgDeclarationStatementPtrList::const_iterator i = l.begin();
135620 0 : while (i != l.end())
135621 : {
135622 : // name += (*i)->get_name() + "_class_member_";
135623 0 : name += (*i)->get_mangled_name() + "_class_member_";
135624 0 : i++;
135625 : }
135626 : }
135627 : else
135628 : {
135629 0 : name = name + "nondefining_declaration";
135630 : }
135631 : break;
135632 : }
135633 :
135634 0 : case V_SgEnumDeclaration:
135635 0 : {
135636 : // case of "enum { x,y,z; }; in global scope
135637 0 : name = string("unnamed_enum_declaration_in_global_definition_");
135638 :
135639 0 : const SgEnumDeclaration* enumDeclaration = isSgEnumDeclaration(this);
135640 0 : ROSE_ASSERT(enumDeclaration != NULL);
135641 0 : const SgInitializedNamePtrList & l = enumDeclaration->get_enumerators();
135642 0 : SgInitializedNamePtrList::const_iterator i = l.begin();
135643 0 : while (i != l.end())
135644 : {
135645 0 : name += (*i)->get_name() + "_enum_field_";
135646 0 : i++;
135647 : }
135648 : break;
135649 : }
135650 :
135651 0 : default:
135652 0 : {
135653 0 : printf ("Default reached in SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration_in_scope (this = %p = %s) \n",
135654 0 : this,class_name().c_str());
135655 0 : break;
135656 : }
135657 : }
135658 :
135659 : // printf ("SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration_in_scope() returning name = %s \n",name.str());
135660 :
135661 0 : return name;
135662 : }
135663 :
135664 : SgName
135665 0 : SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration ( SgNode* parent ) const
135666 : {
135667 : // This function generates a name for a class, enum, or typedef (maybe) where the declaration
135668 : // is not provided a name in the source code. Examples include:
135669 : // typedef struct { int state;} my_struct_typedef;
135670 : // typedef enum { zero_enum_in_typedef } mynumbers_typedef;
135671 : // class { int x } variable_from_anonymous_class_declaration;
135672 : // enum { zero_enum_field } mynumbers_enum;
135673 : // Without this feature different classes can be mangled to the same (empty) names.
135674 :
135675 0 : ROSE_ASSERT(parent != NULL);
135676 :
135677 0 : SgName name;
135678 :
135679 0 : switch (parent->variantT())
135680 : {
135681 0 : case V_SgVariableDeclaration:
135682 0 : {
135683 : // SgVariableDeclaration::p_variableDeclarationContainsBaseTypeDefiningDeclaration should also be true, I think.
135684 0 : SgVariableDeclaration* declaration = isSgVariableDeclaration(parent);
135685 : // It might be overkill to us the mangled name here
135686 :
135687 : // DQ (3/19/2016): Klocworks reports an issue because "declaration" might be NULL.
135688 0 : ROSE_ASSERT(declaration != NULL);
135689 :
135690 0 : name = string("unnamed_declaration_in_variable_declaration_") + declaration->get_mangled_name();
135691 0 : break;
135692 : }
135693 :
135694 0 : case V_SgTypedefDeclaration:
135695 0 : {
135696 : // SgTypedefDeclaration::p_typedefBaseTypeContainsDefiningDeclaration should also be true, I think.
135697 0 : SgTypedefDeclaration* declaration = isSgTypedefDeclaration(parent);
135698 : // It might be overkill to us the mangled name here
135699 :
135700 : // DQ (3/19/2016): Klocworks reports an issue because "declaration" might be NULL.
135701 0 : ROSE_ASSERT(declaration != NULL);
135702 :
135703 0 : name = string("unnamed_declaration_in_typedef_declaration_") + declaration->get_mangled_name();
135704 0 : break;
135705 : }
135706 :
135707 0 : case V_SgGlobal:
135708 0 : case V_SgBasicBlock:
135709 0 : case V_SgClassDefinition:
135710 0 : case V_SgTemplateInstantiationDefn:
135711 0 : case V_SgNamespaceDefinitionStatement:
135712 0 : {
135713 : // Some unnamed declarations can appear in global scope and we have to figure out how
135714 : // to assign them unique names. See the examples for each case below.
135715 : // printf ("Unnamed declaration appears in a scope (instead of another declaration) \n");
135716 0 : SgScopeStatement* scope = isSgScopeStatement(parent);
135717 0 : ROSE_ASSERT(scope != NULL);
135718 0 : name = SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration_in_scope(scope);
135719 0 : break;
135720 : }
135721 :
135722 0 : default:
135723 0 : {
135724 0 : printf ("Default reached in un-named declaration within parent = %p = %s \n",parent,parent->class_name().c_str());
135725 0 : get_file_info()->display("Error: location of problem un-named SgClassDeclaration");
135726 0 : ROSE_ASSERT(parent->get_file_info() != NULL);
135727 0 : parent->get_file_info()->display("Error: location of problem un-named SgClassDeclaration");
135728 0 : ROSE_ASSERT(false);
135729 : }
135730 : }
135731 :
135732 : // printf ("SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration() returning name = %s \n",name.str());
135733 :
135734 0 : return name;
135735 : }
135736 :
135737 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
135738 : SgSymbol*
135739 0 : SgDeclarationStatement::get_symbol_from_symbol_table() const
135740 : {
135741 0 : printf ("Error: virtual function SgDeclarationStatement::get_symbol_from_symbol_table() called on base class SgDeclarationStatement this = %p = %s \n",this,this->class_name().c_str());
135742 0 : ROSE_ASSERT(false);
135743 : return NULL;
135744 : }
135745 :
135746 : SgSymbol*
135747 57864 : SgDeclarationStatement::search_for_symbol_from_symbol_table() const
135748 : {
135749 57864 : SgDeclarationStatement* declaration = get_declaration_associated_with_symbol();
135750 57864 : if (declaration == NULL)
135751 : {
135752 0 : printf ("Error: in SgDeclarationStatement::search_for_symbol_from_symbol_table(): declaration == NULL \n");
135753 0 : printf (" this = %p = %s = %s \n",this,this->class_name().c_str(),SageInterface::get_name(this).c_str());
135754 : }
135755 57864 : ROSE_ASSERT(declaration != NULL);
135756 57864 : SgSymbol* symbol = declaration->get_symbol_from_symbol_table();
135757 57864 : ROSE_ASSERT(symbol != NULL);
135758 57864 : return symbol;
135759 : }
135760 :
135761 : #define DEBUG_SgDeclarationStatement_get_declaration_associated_with_symbol 1
135762 :
135763 : // DQ (7/4/2007): Search for the declaration that would identify the associated symbol
135764 : SgDeclarationStatement*
135765 67814 : SgDeclarationStatement::get_declaration_associated_with_symbol() const
135766 : {
135767 67814 : ROSE_ASSERT(this != NULL);
135768 :
135769 : // First try: the 1st non-defining declaration
135770 67814 : SgDeclarationStatement * declstmt = this->get_firstNondefiningDeclaration();
135771 67814 : SgSymbol * sym = declstmt ? declstmt->get_symbol_from_symbol_table() : NULL;
135772 67814 : if (sym == NULL) {
135773 0 : declstmt = this->get_definingDeclaration();
135774 : }
135775 : // Second try: the defining declaration
135776 67814 : sym = declstmt ? declstmt->get_symbol_from_symbol_table() : NULL;
135777 67814 : if (sym == NULL) {
135778 : declstmt = const_cast<SgDeclarationStatement*>(this);
135779 : }
135780 : // Finally try: the current declaration: DQ (6/25/2007): As a special case the friend function in test2005_06.C is defined in the class and has a forward declaration outside of the class in global scope.
135781 67814 : sym = declstmt ? declstmt->get_symbol_from_symbol_table() : NULL;
135782 67814 : if (sym == NULL) {
135783 : declstmt = NULL;
135784 : }
135785 67814 : return declstmt;
135786 : }
135787 :
135788 : // DQ (7/22/2007): This should be a member function of SgDeclarationStatement
135789 : bool
135790 3464300 : SgDeclarationStatement::hasAssociatedSymbol() const
135791 : {
135792 3464300 : bool returnValue = true;
135793 :
135794 : // SgFunctionParameterList should likely not even be a declaration, but at least it has
135795 : // not associated symbol in the symbol table. SgVariableDeclaration contain a list of
135796 : // SgInitializedName objects and those have associated symbols, the SgVariableDeclaration
135797 : // does not have an associated symbol.
135798 4770060 : if (isSgFunctionParameterList(this) != NULL ||
135799 2583330 : isSgCtorInitializerList(this) != NULL ||
135800 2553570 : isSgPragmaDeclaration(this) != NULL ||
135801 5986300 : isSgVariableDeclaration(this) != NULL ||
135802 1246010 : isSgVariableDefinition(this) != NULL )
135803 : {
135804 : returnValue = false;
135805 : }
135806 :
135807 3464300 : return returnValue;
135808 : }
135809 :
135810 :
135811 : SgName
135812 0 : SgDeclarationStatement::get_template_name() const
135813 : {
135814 : // DQ (12/22/2011): This is an ugly aspect of supporting template declarations as derived from that which they are associated.
135815 : // (e.g. SgTemplateClassDeclaration derived from a SgClassDeclaration).
135816 :
135817 : // But at least it is now islolated to a single function.
135818 :
135819 0 : SgName templateDeclarationName;
135820 : // switch (templateDeclaration->variantT())
135821 0 : switch (this->variantT())
135822 : {
135823 0 : case V_SgNonrealDecl:
135824 0 : {
135825 0 : templateDeclarationName = isSgNonrealDecl(this)->get_name();
135826 0 : break;
135827 : }
135828 0 : case V_SgTemplateClassDeclaration:
135829 0 : {
135830 0 : templateDeclarationName = isSgTemplateClassDeclaration(this)->get_name();
135831 0 : break;
135832 : }
135833 :
135834 0 : case V_SgTemplateFunctionDeclaration:
135835 0 : {
135836 0 : templateDeclarationName = isSgTemplateFunctionDeclaration(this)->get_name();
135837 0 : break;
135838 : }
135839 :
135840 0 : case V_SgTemplateMemberFunctionDeclaration:
135841 0 : {
135842 0 : templateDeclarationName = isSgTemplateMemberFunctionDeclaration(this)->get_name();
135843 0 : break;
135844 : }
135845 :
135846 0 : case V_SgTemplateVariableDeclaration:
135847 0 : {
135848 0 : const SgTemplateVariableDeclaration* templateVariableDeclaration = isSgTemplateVariableDeclaration(this);
135849 0 : ROSE_ASSERT(templateVariableDeclaration->get_variables().empty() == false);
135850 0 : SgInitializedName* initializedName = templateVariableDeclaration->get_variables()[0];
135851 0 : templateDeclarationName = initializedName->get_name();
135852 0 : break;
135853 : }
135854 :
135855 : // DQ (1/21/2013): This is a rarely used IR node in the new template support (but needs to be included).
135856 : // See testRoseHeaders_01_combined.C for an example of where this is generated.
135857 0 : case V_SgTemplateDeclaration:
135858 0 : {
135859 0 : templateDeclarationName = isSgTemplateDeclaration(this)->get_name();
135860 0 : break;
135861 : }
135862 :
135863 : // DQ (11/22/2016): Added case to support C++11 specific SgTemplateTypedefDeclaration IR node.
135864 0 : case V_SgTemplateTypedefDeclaration:
135865 0 : {
135866 0 : templateDeclarationName = isSgTemplateTypedefDeclaration(this)->get_name();
135867 0 : break;
135868 : }
135869 :
135870 0 : default:
135871 0 : {
135872 0 : printf ("Error: default reached templateDeclaration = %p = %s (not a template declaration for class, function, member function, or variable) \n",this,this->class_name().c_str());
135873 0 : ROSE_ASSERT(false);
135874 : }
135875 : }
135876 :
135877 0 : return templateDeclarationName;
135878 : }
135879 :
135880 :
135881 : SgDeclarationStatement*
135882 26458800 : SgDeclarationStatement::get_definingDeclaration () const
135883 : {
135884 : // DQ (1/26/2013): Added non-automatically generated versions of this function so that we could implement more testing.
135885 26458800 : ROSE_ASSERT (this != NULL);
135886 26458800 : return p_definingDeclaration;
135887 : }
135888 :
135889 : void
135890 3801000 : SgDeclarationStatement::set_definingDeclaration ( SgDeclarationStatement* definingDeclaration )
135891 : {
135892 : // DQ (1/26/2013): Added non-automatically generated versions of this function so that we could implement more testing.
135893 :
135894 3801000 : ROSE_ASSERT (this != NULL);
135895 3801000 : set_isModified(true);
135896 :
135897 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
135898 : if (p_definingDeclaration != NULL && definingDeclaration != NULL && p_definingDeclaration != definingDeclaration)
135899 : {
135900 : printf ("Warning: definingDeclaration = %p overwriting valid pointer p_definingDeclaration = %p \n",definingDeclaration,p_definingDeclaration);
135901 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
135902 : printf ("Error fails assertion (p_definingDeclaration != NULL && definingDeclaration != NULL && p_definingDeclaration != definingDeclaration) is false\n");
135903 : ROSE_ASSERT(false);
135904 : #endif
135905 : }
135906 : #endif
135907 3801000 : p_definingDeclaration = definingDeclaration;
135908 :
135909 : // DQ (5/21/2013): Added debugging code.
135910 3801000 : if (definingDeclaration != NULL)
135911 : {
135912 245529 : if (this->variantT() != definingDeclaration->variantT())
135913 : {
135914 0 : printf ("ERROR: this = %p = %s and definingDeclaration = %p = %s \n",this,this->class_name().c_str(),definingDeclaration,definingDeclaration->class_name().c_str());
135915 : }
135916 : }
135917 :
135918 : // DQ (10/11/2015): Added debugging output.
135919 : // DQ (1/24/2013): Added test to make sure that we always set defining declaration to be the same type or IR node.
135920 3801000 : if (definingDeclaration != NULL && this->variantT() != definingDeclaration->variantT())
135921 : {
135922 0 : printf ("ERROR: this = %p = %s \n",this,this->class_name().c_str());
135923 0 : printf ("ERROR: definingDeclaration = %p = %s \n",definingDeclaration,definingDeclaration->class_name().c_str());
135924 : }
135925 3801000 : ROSE_ASSERT(definingDeclaration == NULL || this->variantT() == definingDeclaration->variantT());
135926 3801000 : }
135927 :
135928 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
135929 :
135930 :
135931 : // End of memberFunctionString
135932 : // Start of memberFunctionString
135933 : /* #line 1 "/home/dquinlan/ROSE/git-dq-edg4x-rc/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
135934 :
135935 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
135936 :
135937 : SgDeclarationStatement*
135938 56599600 : SgDeclarationStatement::get_firstNondefiningDeclaration () const
135939 : {
135940 : // DQ (1/26/2013): Added non-automatically generated versions of this function so that we could implement more testing.
135941 56599600 : ROSE_ASSERT (this != NULL);
135942 56599600 : return p_firstNondefiningDeclaration;
135943 : }
135944 :
135945 : void
135946 5030840 : SgDeclarationStatement::set_firstNondefiningDeclaration ( SgDeclarationStatement* firstNondefiningDeclaration )
135947 : {
135948 : // DQ (1/26/2013): Added non-automatically generated versions of this function so that we could implement more testing.
135949 5030840 : ROSE_ASSERT (this != NULL);
135950 5030840 : set_isModified(true);
135951 :
135952 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
135953 : if (p_firstNondefiningDeclaration != NULL && firstNondefiningDeclaration != NULL && p_firstNondefiningDeclaration != firstNondefiningDeclaration)
135954 : {
135955 : printf ("Warning: firstNondefiningDeclaration = %p overwriting valid pointer p_firstNondefiningDeclaration = %p \n",firstNondefiningDeclaration,p_firstNondefiningDeclaration);
135956 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
135957 : printf ("Error fails assertion (p_firstNondefiningDeclaration != NULL && firstNondefiningDeclaration != NULL && p_firstNondefiningDeclaration != firstNondefiningDeclaration) is false\n");
135958 : ROSE_ASSERT(false);
135959 : #endif
135960 : }
135961 : #endif
135962 5030840 : p_firstNondefiningDeclaration = firstNondefiningDeclaration;
135963 :
135964 : // DQ (5/21/2013): Added debugging code.
135965 5030840 : if (firstNondefiningDeclaration != NULL)
135966 : {
135967 5030390 : if (this->variantT() != firstNondefiningDeclaration->variantT())
135968 : {
135969 0 : printf ("ERROR: this = %p = %s and firstNondefiningDeclaration = %p = %s \n",this,this->class_name().c_str(),firstNondefiningDeclaration,firstNondefiningDeclaration->class_name().c_str());
135970 : }
135971 : }
135972 :
135973 : // DQ (5/17/2014): Added debugging code.
135974 5030840 : if (firstNondefiningDeclaration != NULL && this->variantT() != firstNondefiningDeclaration->variantT())
135975 : {
135976 0 : printf ("ERROR: In SgDeclarationStatement::set_firstNondefiningDeclaration(): this = %p = %s IS NOT THE SAME AS firstNondefiningDeclaration = %p = %s \n",
135977 0 : this,this->class_name().c_str(),firstNondefiningDeclaration,firstNondefiningDeclaration->class_name().c_str());
135978 :
135979 : // DQ (11/23/2015): When this is called from the frontend, the source position may not have been set yet.
135980 : // ROSE_ASSERT(this->get_file_info() != NULL);
135981 0 : if (this->get_file_info() != NULL)
135982 : {
135983 0 : this->get_file_info()->display("ERROR: In SgDeclarationStatement::set_firstNondefiningDeclaration(): this: debug");
135984 : }
135985 : // ROSE_ASSERT(firstNondefiningDeclaration->get_file_info() != NULL);
135986 0 : if (firstNondefiningDeclaration->get_file_info() != NULL)
135987 : {
135988 0 : firstNondefiningDeclaration->get_file_info()->display("ERROR: In SgDeclarationStatement::set_firstNondefiningDeclaration(): firstNondefiningDeclaration: debug");
135989 : }
135990 : }
135991 :
135992 : // DQ (10/11/2015): Added debugging output.
135993 : // DQ (1/24/2013): Added test to make sure that we always set defining declaration to be the same type or IR node.
135994 5030840 : if (firstNondefiningDeclaration != NULL && this->variantT() != firstNondefiningDeclaration->variantT())
135995 : {
135996 0 : printf ("ERROR: this = %p = %s \n",this,this->class_name().c_str());
135997 0 : printf ("ERROR: firstNondefiningDeclaration = %p = %s \n",firstNondefiningDeclaration,firstNondefiningDeclaration->class_name().c_str());
135998 : }
135999 5030840 : ROSE_ASSERT(firstNondefiningDeclaration == NULL || this->variantT() == firstNondefiningDeclaration->variantT());
136000 5030840 : }
136001 :
136002 : SgType*
136003 0 : SgDeclarationStatement::get_type() const
136004 : {
136005 : // DQ (8/21/2013): Added function to support calling get_type() from a SgDeclarationStatement so that the
136006 : // template low-level symbol table support function would compile cleanly. Note that it is an error to
136007 : // call this function and it is not a virtual function that will cause derived class versions to be called
136008 : // where appropriate (and it is not always appropriate, e.g a SgNamespaceDeclaration has no assocated SgType).
136009 :
136010 : // DQ (3/15/2014): Added warning since we don't want to be calling this function (unless we make it virtual).
136011 0 : printf ("WARNING: Non-virtual base class SgDeclarationStatement::get_type() called: this = %p = %s \n",this,this->class_name().c_str());
136012 :
136013 : #if 1
136014 0 : printf ("Exiting as a test! \n");
136015 0 : ROSE_ASSERT(false);
136016 : #endif
136017 :
136018 : return NULL;
136019 : }
136020 :
136021 :
136022 : // DQ (3/10/2018): Adding support to output the name, useful for debugging template instantiations which have more complex name using template arguments.
136023 : std::string
136024 0 : SgDeclarationStatement::unparseNameToString()
136025 : {
136026 : // DQ (3/10/2018): I think tis IR node is no longer being used, so I need to move this support to the declarations.
136027 : // DQ (3/10/2018): Adding debugging support.
136028 :
136029 : // DQ (9/24/2012): Don't add "< >" if there are no template arguments (see test2012_221.C).
136030 : // SgName returnName = name + " < ";
136031 0 : string returnName;
136032 :
136033 0 : SgTemplateArgumentPtrList* templateArgumentsList = NULL;
136034 :
136035 0 : switch(this->variantT())
136036 : {
136037 : // DQ (8/17/2013): These cases do not use templates.
136038 : // This function has to handle these cases because it is called in a general context
136039 : // on many types of declarations as part of the name qualification support.
136040 : case V_SgNamespaceDeclarationStatement:
136041 : case V_SgEnumDeclaration:
136042 : case V_SgVariableDeclaration:
136043 : case V_SgTypedefDeclaration:
136044 : {
136045 : templateArgumentsList = NULL;
136046 : break;
136047 : }
136048 :
136049 : // DQ (8/11/2013): Added cases for SgFunctionDeclaration and SgMemberFunctionDeclaration
136050 : // I forget why we needed this case...
136051 : case V_SgFunctionDeclaration:
136052 : case V_SgMemberFunctionDeclaration:
136053 : case V_SgClassDeclaration:
136054 : {
136055 : templateArgumentsList = NULL;
136056 : break;
136057 : }
136058 :
136059 0 : case V_SgTemplateInstantiationDecl:
136060 0 : {
136061 0 : SgTemplateInstantiationDecl* templateInstantiation = isSgTemplateInstantiationDecl(this);
136062 :
136063 0 : returnName = templateInstantiation->get_templateName();
136064 :
136065 0 : templateArgumentsList = &(templateInstantiation->get_templateArguments());
136066 : break;
136067 : }
136068 :
136069 0 : case V_SgTemplateClassDeclaration:
136070 0 : {
136071 0 : templateArgumentsList = &(isSgTemplateClassDeclaration(this)->get_templateSpecializationArguments());
136072 : break;
136073 : }
136074 :
136075 0 : case V_SgTemplateInstantiationFunctionDecl:
136076 0 : {
136077 0 : SgTemplateInstantiationFunctionDecl* templateInstantiation = isSgTemplateInstantiationFunctionDecl(this);
136078 0 : templateArgumentsList = &(isSgTemplateInstantiationFunctionDecl(this)->get_templateArguments());
136079 0 : returnName = templateInstantiation->get_templateName();
136080 0 : break;
136081 : }
136082 :
136083 0 : case V_SgTemplateFunctionDeclaration:
136084 0 : {
136085 0 : templateArgumentsList = &(isSgTemplateFunctionDeclaration(this)->get_templateSpecializationArguments());
136086 : break;
136087 : }
136088 :
136089 0 : case V_SgTemplateInstantiationMemberFunctionDecl:
136090 0 : {
136091 0 : SgTemplateInstantiationMemberFunctionDecl* templateInstantiation = isSgTemplateInstantiationMemberFunctionDecl(this);
136092 0 : templateArgumentsList = &(isSgTemplateInstantiationMemberFunctionDecl(this)->get_templateArguments());
136093 0 : returnName = templateInstantiation->get_templateName();
136094 0 : break;
136095 : }
136096 :
136097 0 : case V_SgTemplateMemberFunctionDeclaration:
136098 0 : {
136099 0 : templateArgumentsList = &(isSgTemplateMemberFunctionDeclaration(this)->get_templateSpecializationArguments());
136100 : break;
136101 : }
136102 :
136103 0 : case V_SgTemplateVariableDeclaration:
136104 0 : {
136105 0 : templateArgumentsList = &(isSgTemplateVariableDeclaration(this)->get_templateSpecializationArguments());
136106 : break;
136107 : }
136108 :
136109 : // DQ (11/10/2014): Added support for template typedef declarations.
136110 0 : case V_SgTemplateTypedefDeclaration:
136111 0 : {
136112 0 : templateArgumentsList = &(isSgTemplateTypedefDeclaration(this)->get_templateSpecializationArguments());
136113 : break;
136114 : }
136115 :
136116 : // DQ (11/10/2014): Added support for template typedef declarations.
136117 0 : case V_SgTemplateInstantiationTypedefDeclaration:
136118 0 : {
136119 0 : SgTemplateInstantiationTypedefDeclaration* templateInstantiation = isSgTemplateInstantiationTypedefDeclaration(this);
136120 0 : templateArgumentsList = &(isSgTemplateInstantiationTypedefDeclaration(this)->get_templateArguments());
136121 0 : returnName = templateInstantiation->get_templateName();
136122 0 : break;
136123 : }
136124 : #if 0
136125 : // DQ (12/14/2016): Added new case
136126 : case V_SgFunctionDeclaration:
136127 : {
136128 : SgFunctionDeclaration* function_declaration = isSgFunctionDeclaration(this);
136129 : printf ("In SageBuilder::getTemplateArgumentList(): function name = %s \n",function_declaration->get_name().str());
136130 :
136131 : function_declaration->get_file_info()->display("Not clear that we should need this case since there would not be any template arguments: debug");
136132 :
136133 : printf ("Error: Not clear that we should need this case since there would not be any template arguments \n");
136134 : ROSE_ASSERT(false);
136135 : break;
136136 : }
136137 : #endif
136138 0 : default:
136139 0 : {
136140 0 : printf ("In SgDeclarationStatement::unparseNameToString(): Default reched in switch: decl = %p = %s \n",this,this->class_name().c_str());
136141 0 : ROSE_ASSERT(false);
136142 : }
136143 : }
136144 :
136145 0 : bool emptyArgumentList = true;
136146 0 : if (templateArgumentsList != NULL)
136147 : {
136148 0 : emptyArgumentList = templateArgumentsList->empty();
136149 :
136150 0 : if (emptyArgumentList == false)
136151 0 : returnName += " < ";
136152 :
136153 : #define DEBUG_UNPARSE_DECLARATION_NAME 0
136154 :
136155 : #if 1
136156 0 : SgTemplateArgumentPtrList::const_iterator i = templateArgumentsList->begin();
136157 0 : while (i != templateArgumentsList->end())
136158 : {
136159 : #if DEBUG_UNPARSE_DECLARATION_NAME
136160 : printf ("In SgDeclarationStatement::unparseNameToString(): label = %s \n",label.c_str());
136161 : #endif
136162 :
136163 0 : returnName += (*i)->unparseToStringSupport();
136164 :
136165 0 : i++;
136166 :
136167 : // If there are more arguments then we need a "," to seperate them.
136168 0 : if (i != templateArgumentsList->end())
136169 : {
136170 : // Since we have a few places were these names are generated the code is sensative to names being
136171 : // generated exactly the same. So the space on both sides of the "," is critical. This will be fixed
136172 : // and all locations where this is done are marked with "CRITICAL FUNCTION TO BE REFACTORED".
136173 : // returnName += ",";
136174 0 : returnName += " , ";
136175 : }
136176 :
136177 : #if DEBUG_UNPARSE_DECLARATION_NAME
136178 : printf ("In SgDeclarationStatement::unparseNameToString(): (bottom of loop) returnName = %s \n",returnName.str());
136179 : #endif
136180 : }
136181 : #endif
136182 :
136183 : // DQ (9/24/2012): Don't add "< >" if there are no tempalte arguments.
136184 0 : if (emptyArgumentList == false)
136185 : {
136186 0 : returnName += " > ";
136187 : }
136188 : }
136189 :
136190 0 : return returnName;
136191 : }
136192 :
136193 :
136194 :
136195 :
136196 :
136197 : // End of memberFunctionString
136198 : // Start of memberFunctionString
136199 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
136200 :
136201 : // *** COMMON CODE SECTION BEGINS HERE ***
136202 :
136203 : #if 0
136204 : int
136205 : SgDeclarationStatement::getVariant() const
136206 : {
136207 : // This function is used in ROSE while "variant()" is used in SAGE
136208 : assert(this != NULL);
136209 : return variant();
136210 : }
136211 : #endif
136212 :
136213 : // This function is used in ROSE in treeTraversal code
136214 : // eventually replaces getVariant() and variant()
136215 : // though after variant() has been removed for a while we will
136216 : // want to change the name of variantT() back to variant()
136217 : // (since the "T" was ment to stand for temporary).
136218 : // When this happens the variantT() will be depricated.
136219 : VariantT
136220 14836000 : SgDeclarationStatement::variantT() const
136221 : {
136222 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
136223 14836000 : ROSE_ASSERT(this != NULL);
136224 14836000 : return V_SgDeclarationStatement;
136225 : }
136226 :
136227 : #if 0
136228 : int
136229 : SgDeclarationStatement::variant() const
136230 : {
136231 : // This function is used in SAGE
136232 : ROSE_ASSERT(this != NULL);
136233 : return DECL_STMT;
136234 : }
136235 : #endif
136236 :
136237 : ROSE_DLL_API const char*
136238 0 : SgDeclarationStatement::sage_class_name() const
136239 : {
136240 0 : ROSE_ASSERT(this != NULL);
136241 0 : return "SgDeclarationStatement";
136242 : }
136243 :
136244 : std::string
136245 0 : SgDeclarationStatement::class_name() const
136246 : {
136247 0 : ROSE_ASSERT(this != NULL);
136248 0 : return "SgDeclarationStatement";
136249 : }
136250 :
136251 : // DQ (11/26/2005): Support for visitor pattern mechanims
136252 : // (inferior to ROSE traversal mechanism, experimental).
136253 : void
136254 0 : SgDeclarationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
136255 : {
136256 0 : ROSE_ASSERT(this != NULL);
136257 0 : visitor.visit(this);
136258 0 : }
136259 :
136260 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
136261 0 : void SgDeclarationStatement::accept (ROSE_VisitorPattern & visitor) {
136262 0 : ROSE_ASSERT(this != NULL);
136263 0 : visitor.visit(this);
136264 0 : }
136265 :
136266 : SgDeclarationStatement*
136267 0 : SgDeclarationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
136268 : {
136269 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
136270 : // This function is currently only supported for the AST used the represent Binary executables.
136271 : if (0 /* isSgAsmNode(this) != NULL */)
136272 : {
136273 : // Support for regex specification.
136274 : std::string prefixCode = "REGEX:";
136275 : addNewAttribute(prefixCode + s,a);
136276 : }
136277 : #endif
136278 :
136279 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
136280 0 : return this;
136281 : }
136282 :
136283 : // *** COMMON CODE SECTION ENDS HERE ***
136284 :
136285 :
136286 : // End of memberFunctionString
136287 : // Start of memberFunctionString
136288 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
136289 :
136290 :
136291 : #if 0
136292 : //! Error checking support
136293 : /*! Verifies the following:
136294 : - working getVariant() member function
136295 : - calls base class's error() member function
136296 : Every class has one of these functions.
136297 : */
136298 : bool
136299 : SgDeclarationStatement::error()
136300 : {
136301 : // Put error checking here
136302 :
136303 : ROSE_ASSERT (this != NULL);
136304 : if (getVariant() != DECL_STMT)
136305 : {
136306 : printf ("Error in SgDeclarationStatement::error(): SgDeclarationStatement object has a %s variant \n",
136307 : Cxx_GrammarTerminalNames[getVariant()].name);
136308 : // printf ("Error in SgDeclarationStatement::error() \n");
136309 : ROSE_ABORT();
136310 : }
136311 :
136312 : ROSE_ASSERT (getVariant() == DECL_STMT);
136313 : return SgStatement::error();
136314 : }
136315 : #endif
136316 :
136317 :
136318 :
136319 : // End of memberFunctionString
136320 :
136321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
136322 :
136323 319666000 : SgDeclarationStatement* isSgDeclarationStatement ( SgNode* inputDerivedClassPointer )
136324 : {
136325 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
136326 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
136327 : // So to fix this we return NULL directly when the input is NULL and avoid the
136328 : // dynamic_cast in this case. This is likely a performance improvement as well.
136329 : // return dynamic_cast<SgDeclarationStatement*>(inputDerivedClassPointer);
136330 : // Milind Chabbi (8/28/2013): isSgDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
136331 : // this improves the running time performance by 10-20%.
136332 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeclarationStatement*>(inputDerivedClassPointer);
136333 319666000 : return IS_SgDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
136334 : }
136335 :
136336 : // DQ (11/8/2003): Added version of functions taking const pointer
136337 13261 : const SgDeclarationStatement* isSgDeclarationStatement ( const SgNode* inputDerivedClassPointer )
136338 : {
136339 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
136340 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
136341 : // So to fix this we return NULL directly when the input is NULL and avoid the
136342 : // dynamic_cast in this case. This is likely a performance improvement as well.
136343 : // return dynamic_cast<const SgDeclarationStatement*>(inputDerivedClassPointer);
136344 : // Milind Chabbi (8/28/2013): isSgDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
136345 : // this improves the running time performance by 10-20%.
136346 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeclarationStatement*>(inputDerivedClassPointer);
136347 13261 : return IS_SgDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
136348 : }
136349 :
136350 :
136351 :
136352 : /* #line 136353 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136353 :
136354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
136355 :
136356 : /**
136357 : \brief Generated destructor
136358 :
136359 : This destructor is automatically generated (by ROSETTA). This destructor
136360 : only frees memory of data members associated with the parts of the current IR node which
136361 : are NOT traversed. Those data members that are part of a traversal can be freed using
136362 : a traversal (calling this destructor on all children in a post-order traversal). Such
136363 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
136364 :
136365 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
136366 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
136367 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
136368 :
136369 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
136370 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
136371 : pointers are not yet implemented to call delete on eash pointer in the container.
136372 : (This could be done by derivation from the STL containers to define containers that
136373 : automatically deleted their members.)
136374 :
136375 : */
136376 1288130 : SgDeclarationStatement::~SgDeclarationStatement () {
136377 1288130 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
136378 :
136379 :
136380 : // case: not a listType for decl_attributes
136381 1288130 : p_decl_attributes = 0; // non list case
136382 : // case: not a listType for linkage
136383 1288130 : p_linkage = ""; // non list case
136384 : // case: not a listType for nameOnly
136385 1288130 : p_nameOnly = false; // non list case
136386 : // case: not a listType for forward
136387 1288130 : p_forward = false; // non list case
136388 : // case: not a listType for externBrace
136389 1288130 : p_externBrace = false; // non list case
136390 : // case: not a listType for skipElaborateType
136391 1288130 : p_skipElaborateType = false; // non list case
136392 : // case: not a listType for definingDeclaration
136393 1288130 : p_definingDeclaration = NULL; // non list case
136394 : // case: not a listType for firstNondefiningDeclaration
136395 1288130 : p_firstNondefiningDeclaration = NULL; // non list case
136396 : // case: not a listType for binding_label
136397 1288130 : p_binding_label =""; // non list case
136398 : // case: not a listType for declarationScope
136399 1288130 : p_declarationScope = NULL; // non list case
136400 : // case: not a listType for unparse_template_ast
136401 1288130 : p_unparse_template_ast = false; // non list case
136402 :
136403 : }
136404 :
136405 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
136406 1288130 : }
136407 :
136408 :
136409 : /* #line 136410 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136410 :
136411 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
136412 :
136413 : // Generated constructor
136414 994 : SgDeclarationStatement::SgDeclarationStatement ( Sg_File_Info* startOfConstruct )
136415 994 : : SgStatement(startOfConstruct)
136416 : {
136417 : #ifdef DEBUG
136418 : // printf ("In SgDeclarationStatement::SgDeclarationStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
136419 : #endif
136420 : #if 0
136421 : // debugging information!
136422 : printf ("In SgDeclarationStatement::SgDeclarationStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
136423 : #endif
136424 :
136425 994 : p_decl_attributes = 0;
136426 994 : p_linkage = "";
136427 994 : p_nameOnly = false;
136428 994 : p_forward = false;
136429 994 : p_externBrace = false;
136430 994 : p_skipElaborateType = false;
136431 994 : p_definingDeclaration = NULL;
136432 994 : p_firstNondefiningDeclaration = NULL;
136433 994 : p_binding_label ="";
136434 994 : p_declarationScope = NULL;
136435 994 : p_unparse_template_ast = false;
136436 :
136437 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
136438 :
136439 : #if 0
136440 : // DQ (7/30/2014): Call a virtual function.
136441 : std::string s = this->class_name();
136442 : #endif
136443 :
136444 : // Test the variant virtual function
136445 : // assert(DECL_STMT == variant());
136446 994 : assert(DECL_STMT == this->variant());
136447 994 : ROSE_ASSERT(DECL_STMT == (int)(this->variantT()));
136448 994 : post_construction_initialization();
136449 :
136450 : // Test the isSgDeclarationStatement() function since it has been problematic
136451 994 : assert(isSgDeclarationStatement(this) != NULL);
136452 994 : }
136453 :
136454 : // Generated constructor (all data members)
136455 :
136456 : /* #line 136457 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136457 :
136458 :
136459 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
136460 :
136461 :
136462 : // ********************************************************
136463 : // member functions common across all array grammar objects
136464 : // ********************************************************
136465 :
136466 :
136467 :
136468 : /* #line 136469 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136469 :
136470 :
136471 :
136472 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
136473 :
136474 : // ********************************************************
136475 : // member functions specific to each node in the grammar
136476 : // ********************************************************
136477 :
136478 :
136479 : /* #line 136480 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136480 :
136481 : // Start of memberFunctionString
136482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
136483 :
136484 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
136485 :
136486 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
136487 : const SgInitializedNamePtrList &
136488 22367400 : SgFunctionParameterList::get_args () const
136489 : {
136490 22367400 : assert (this != NULL);
136491 22367400 : return p_args;
136492 : }
136493 :
136494 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
136495 : SgInitializedNamePtrList &
136496 24547400 : SgFunctionParameterList::get_args ()
136497 : {
136498 24547400 : assert (this != NULL);
136499 :
136500 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
136501 : // As a rule only set_ access functions can set the isModified flag.
136502 : // set_isModified(true);
136503 :
136504 24547400 : return p_args;
136505 : }
136506 :
136507 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
136508 :
136509 :
136510 : // End of memberFunctionString
136511 : // Start of memberFunctionString
136512 : /* #line 11464 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
136513 :
136514 :
136515 : void
136516 3502610 : SgFunctionParameterList::post_construction_initialization()
136517 : {
136518 3502610 : if (get_file_info() != NULL)
136519 : {
136520 15 : Sg_File_Info* endingPosition = new Sg_File_Info(*(get_file_info()));
136521 15 : ROSE_ASSERT (endingPosition != NULL);
136522 :
136523 : // DQ (12/18/2006): Fixup parents of Sg_File_Info objects.
136524 15 : endingPosition->set_parent(this);
136525 :
136526 15 : set_endOfConstruct(endingPosition);
136527 : }
136528 :
136529 : #if 0
136530 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
136531 : printf ("In SgFunctionParameterList::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
136532 : #endif
136533 3502610 : }
136534 :
136535 : #if 0
136536 : SgInitializedNamePtrList::iterator
136537 : SgFunctionParameterList::insert_arg(const SgInitializedNamePtrList::iterator& where, SgInitializedName* what)
136538 : {
136539 : // DQ (9/24/2004): this should be true but verify it!
136540 : ROSE_ASSERT(what != NULL);
136541 :
136542 : SgInitializedNamePtrList::iterator new_item = get_args().insert(where, what);
136543 :
136544 : // DQ (9/24/2004): This code requires that parent pointers be set in the AST
136545 : // (which we would like to defer to post-processing AST Fixup). See if we can
136546 : // eliminate this code. The declaration in the InitializedName should have
136547 : // already been set anyway, so I don't think it should be reset! Though it
136548 : // could be that it is not set to the function declaration!
136549 : #ifndef REMOVE_SET_PARENT_FUNCTION
136550 : SgFunctionDeclaration* declStmt = dynamic_cast<SgFunctionDeclaration*>(get_parent());
136551 : ROSE_ASSERT(declStmt!=0);
136552 : (*new_item)->set_declaration(declStmt); // MS: 'get_parent' instead of 'this'
136553 : #else
136554 : // Verify that the declaration of all function parameters have been set to the function declaration!
136555 : // ROSE_ASSERT((*new_item)->get_declaration() != NULL);
136556 : // ROSE_ASSERT ( isSgFunctionDeclaration( (*new_item)->get_declaration() ) != NULL );
136557 :
136558 : // if ( (*new_item)->get_declaration()->variantT() != V_SgFunctionDeclaration &&
136559 : // (*new_item)->get_declaration()->variantT() != V_SgMemberFunctionDeclaration )
136560 : // {
136561 : // printf ("Error: function parameter declaration (not SgFunctionDeclaration or SgMemberFunctionDeclaration) set to %s \n",(*new_item)->get_declaration()->sage_class_name());
136562 : // }
136563 : // ROSE_ASSERT ( (*new_item)->get_declaration()->variantT() == V_SgFunctionDeclaration ||
136564 : // (*new_item)->get_declaration()->variantT() == V_SgMemberFunctionDeclaration );
136565 : #endif
136566 : return new_item;
136567 : }
136568 : #endif
136569 :
136570 : void
136571 6327980 : SgFunctionParameterList::append_arg( SgInitializedName* what)
136572 : {
136573 6327980 : get_args().push_back(what);
136574 6327980 : what->set_parent(this);
136575 : // SgFunctionDeclaration* declStmt = isSgFunctionDeclaration(this->get_parent());
136576 6327980 : }
136577 :
136578 : void
136579 0 : SgFunctionParameterList::prepend_arg( SgInitializedName* what)
136580 : {
136581 0 : get_args().insert(get_args().begin(), what);
136582 0 : what->set_parent(this);
136583 : // SgFunctionDeclaration* declStmt = isSgFunctionDeclaration(this->get_parent());
136584 0 : }
136585 :
136586 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
136587 : SgName
136588 3255620 : SgFunctionParameterList::get_mangled_name(void) const
136589 : {
136590 : #if 0
136591 : // printf ("In SgFunctionParameterList::get_mangled_name() name = %s \n",SageInterface::get_name(this).c_str());
136592 :
136593 : SgName returnName;
136594 :
136595 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
136596 : SgScopeStatement* scope = get_scope();
136597 : ROSE_ASSERT(scope != NULL);
136598 :
136599 : SgName variableNames = "_args_";
136600 : SgInitializedNamePtrList::const_iterator p = get_args().begin();
136601 : while ( p != get_args().end() )
136602 : {
136603 : // DQ (2/22/2007): Added type to generated mangled name for each variable (supports AST merge generation of name for un-named classes)
136604 : // variableNames += SgName("_variable_name_") + (*p)->get_mangled_name();
136605 : variableNames += SgName("_variable_type_") + (*p)->get_type()->get_mangled() + SgName("_variable_name_") + (*p)->get_mangled_name();
136606 :
136607 : p++;
136608 : }
136609 :
136610 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
136611 : // This is a poor way to handle the generation of a mangled name (will be improved)
136612 : // returnName = scope->get_qualified_name() + SgName("_function_parameter_list_") + variableNames;
136613 : returnName = scope->get_mangled_name() + SgName("_function_parameter_list_") + variableNames;
136614 :
136615 : // printf ("Warning: mangled name for %s not yet defined (SgFunctionParameterList::get_mangled_name() called) \n",class_name().c_str());
136616 :
136617 : return returnName;
136618 : #else
136619 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
136620 : // SgFunctionParameterList* declaration = const_cast<SgFunctionParameterList*>(this);
136621 : // std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
136622 : // if (i != p_globalMangledNameMap.end())
136623 6511250 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgFunctionParameterList*>(this));
136624 3255620 : if (mangledNameString.empty() == false)
136625 : {
136626 : // return i->second.c_str();
136627 1060560 : return mangledNameString;
136628 : }
136629 : else
136630 : {
136631 4390130 : SgName variableNames = "_args_";
136632 2195070 : SgInitializedNamePtrList::const_iterator p = get_args().begin();
136633 8183690 : while ( p != get_args().end() )
136634 : {
136635 : // DQ (2/22/2007): Added type to generated mangled name for each variable (supports AST merge generation of name for un-named classes)
136636 5988620 : variableNames += SgName("_variable_type_") + (*p)->get_type()->get_mangled() + SgName("_variable_name_") + (*p)->get_mangled_name();
136637 :
136638 5988620 : p++;
136639 : }
136640 :
136641 : // DQ (6/22/2010): Better to use the function name instead of the scopes mangled name. This helps disambiguate
136642 : // code such as:
136643 : // typedef struct Domain_s { } Domain_t;
136644 : // int foo ( Domain_s *domain);
136645 : // int foo ( Domain_t *domain);
136646 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
136647 : // This is a poor way to handle the generation of a mangled name (will be improved)
136648 6585200 : SgName mangledName = get_scope()->get_mangled_name() + SgName("_function_parameter_list_") + variableNames;
136649 : // SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(get_parent());
136650 : // ROSE_ASSERT(functionDeclaration != NULL);
136651 : // SgName mangledName = functionDeclaration->get_mangled_name() + SgName("_function_parameter_list_") + variableNames;
136652 : #if 0
136653 : printf ("Inside of SgFunctionParameterList::get_mangled_name(void): mangledName = %s \n",mangledName.str());
136654 : #endif
136655 : // p_globalMangledNameMap[declaration] = mangledName;
136656 2204170 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgFunctionParameterList*>(this),mangledName);
136657 : // printf ("RETURN: Inside of SgFunctionParameterList::get_mangled_name(void): mangledName = %s \n",mangledName.str());
136658 :
136659 2195070 : return mangledName;
136660 : }
136661 : #endif
136662 : }
136663 :
136664 :
136665 :
136666 : // End of memberFunctionString
136667 : // Start of memberFunctionString
136668 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
136669 :
136670 : // *** COMMON CODE SECTION BEGINS HERE ***
136671 :
136672 : #if 0
136673 : int
136674 : SgFunctionParameterList::getVariant() const
136675 : {
136676 : // This function is used in ROSE while "variant()" is used in SAGE
136677 : assert(this != NULL);
136678 : return variant();
136679 : }
136680 : #endif
136681 :
136682 : // This function is used in ROSE in treeTraversal code
136683 : // eventually replaces getVariant() and variant()
136684 : // though after variant() has been removed for a while we will
136685 : // want to change the name of variantT() back to variant()
136686 : // (since the "T" was ment to stand for temporary).
136687 : // When this happens the variantT() will be depricated.
136688 : VariantT
136689 1162210000 : SgFunctionParameterList::variantT() const
136690 : {
136691 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
136692 1162210000 : ROSE_ASSERT(this != NULL);
136693 1162210000 : return V_SgFunctionParameterList;
136694 : }
136695 :
136696 : #if 0
136697 : int
136698 : SgFunctionParameterList::variant() const
136699 : {
136700 : // This function is used in SAGE
136701 : ROSE_ASSERT(this != NULL);
136702 : return FUNCTION_PARAMETER_LIST;
136703 : }
136704 : #endif
136705 :
136706 : ROSE_DLL_API const char*
136707 1672 : SgFunctionParameterList::sage_class_name() const
136708 : {
136709 1672 : ROSE_ASSERT(this != NULL);
136710 1672 : return "SgFunctionParameterList";
136711 : }
136712 :
136713 : std::string
136714 2189520 : SgFunctionParameterList::class_name() const
136715 : {
136716 2189520 : ROSE_ASSERT(this != NULL);
136717 2189520 : return "SgFunctionParameterList";
136718 : }
136719 :
136720 : // DQ (11/26/2005): Support for visitor pattern mechanims
136721 : // (inferior to ROSE traversal mechanism, experimental).
136722 : void
136723 2614510 : SgFunctionParameterList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
136724 : {
136725 2614510 : ROSE_ASSERT(this != NULL);
136726 2614510 : visitor.visit(this);
136727 2614510 : }
136728 :
136729 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
136730 0 : void SgFunctionParameterList::accept (ROSE_VisitorPattern & visitor) {
136731 0 : ROSE_ASSERT(this != NULL);
136732 0 : visitor.visit(this);
136733 0 : }
136734 :
136735 : SgFunctionParameterList*
136736 0 : SgFunctionParameterList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
136737 : {
136738 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
136739 : // This function is currently only supported for the AST used the represent Binary executables.
136740 : if (0 /* isSgAsmNode(this) != NULL */)
136741 : {
136742 : // Support for regex specification.
136743 : std::string prefixCode = "REGEX:";
136744 : addNewAttribute(prefixCode + s,a);
136745 : }
136746 : #endif
136747 :
136748 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
136749 0 : return this;
136750 : }
136751 :
136752 : // *** COMMON CODE SECTION ENDS HERE ***
136753 :
136754 :
136755 : // End of memberFunctionString
136756 : // Start of memberFunctionString
136757 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
136758 :
136759 :
136760 : #if 0
136761 : //! Error checking support
136762 : /*! Verifies the following:
136763 : - working getVariant() member function
136764 : - calls base class's error() member function
136765 : Every class has one of these functions.
136766 : */
136767 : bool
136768 : SgFunctionParameterList::error()
136769 : {
136770 : // Put error checking here
136771 :
136772 : ROSE_ASSERT (this != NULL);
136773 : if (getVariant() != FUNCTION_PARAMETER_LIST)
136774 : {
136775 : printf ("Error in SgFunctionParameterList::error(): SgFunctionParameterList object has a %s variant \n",
136776 : Cxx_GrammarTerminalNames[getVariant()].name);
136777 : // printf ("Error in SgFunctionParameterList::error() \n");
136778 : ROSE_ABORT();
136779 : }
136780 :
136781 : ROSE_ASSERT (getVariant() == FUNCTION_PARAMETER_LIST);
136782 : return SgDeclarationStatement::error();
136783 : }
136784 : #endif
136785 :
136786 :
136787 :
136788 : // End of memberFunctionString
136789 :
136790 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
136791 :
136792 71149400 : SgFunctionParameterList* isSgFunctionParameterList ( SgNode* inputDerivedClassPointer )
136793 : {
136794 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
136795 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
136796 : // So to fix this we return NULL directly when the input is NULL and avoid the
136797 : // dynamic_cast in this case. This is likely a performance improvement as well.
136798 : // return dynamic_cast<SgFunctionParameterList*>(inputDerivedClassPointer);
136799 : // Milind Chabbi (8/28/2013): isSgFunctionParameterList uses table-driven castability instead of c++ default dynamic_cast
136800 : // this improves the running time performance by 10-20%.
136801 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionParameterList*>(inputDerivedClassPointer);
136802 71149400 : return IS_SgFunctionParameterList_FAST_MACRO(inputDerivedClassPointer);
136803 : }
136804 :
136805 : // DQ (11/8/2003): Added version of functions taking const pointer
136806 3495260 : const SgFunctionParameterList* isSgFunctionParameterList ( const SgNode* inputDerivedClassPointer )
136807 : {
136808 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
136809 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
136810 : // So to fix this we return NULL directly when the input is NULL and avoid the
136811 : // dynamic_cast in this case. This is likely a performance improvement as well.
136812 : // return dynamic_cast<const SgFunctionParameterList*>(inputDerivedClassPointer);
136813 : // Milind Chabbi (8/28/2013): isSgFunctionParameterList uses table-driven castability instead of c++ default dynamic_cast
136814 : // this improves the running time performance by 10-20%.
136815 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionParameterList*>(inputDerivedClassPointer);
136816 3495260 : return IS_SgFunctionParameterList_FAST_MACRO(inputDerivedClassPointer);
136817 : }
136818 :
136819 :
136820 :
136821 : /* #line 136822 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136822 :
136823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
136824 :
136825 : /**
136826 : \brief Generated destructor
136827 :
136828 : This destructor is automatically generated (by ROSETTA). This destructor
136829 : only frees memory of data members associated with the parts of the current IR node which
136830 : are NOT traversed. Those data members that are part of a traversal can be freed using
136831 : a traversal (calling this destructor on all children in a post-order traversal). Such
136832 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
136833 :
136834 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
136835 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
136836 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
136837 :
136838 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
136839 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
136840 : pointers are not yet implemented to call delete on eash pointer in the container.
136841 : (This could be done by derivation from the STL containers to define containers that
136842 : automatically deleted their members.)
136843 :
136844 : */
136845 2493850 : SgFunctionParameterList::~SgFunctionParameterList () {
136846 1225990 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
136847 :
136848 :
136849 :
136850 : }
136851 :
136852 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
136853 2451980 : }
136854 :
136855 :
136856 : /* #line 136857 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136857 :
136858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
136859 :
136860 : // Generated constructor
136861 15 : SgFunctionParameterList::SgFunctionParameterList ( Sg_File_Info* startOfConstruct )
136862 15 : : SgDeclarationStatement(startOfConstruct)
136863 : {
136864 : #ifdef DEBUG
136865 : // printf ("In SgFunctionParameterList::SgFunctionParameterList (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
136866 : #endif
136867 : #if 0
136868 : // debugging information!
136869 : printf ("In SgFunctionParameterList::SgFunctionParameterList (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
136870 : #endif
136871 :
136872 :
136873 :
136874 : #if 0
136875 : // DQ (7/30/2014): Call a virtual function.
136876 : std::string s = this->class_name();
136877 : #endif
136878 :
136879 : // Test the variant virtual function
136880 : // assert(FUNCTION_PARAMETER_LIST == variant());
136881 15 : assert(FUNCTION_PARAMETER_LIST == this->variant());
136882 15 : ROSE_ASSERT(FUNCTION_PARAMETER_LIST == (int)(this->variantT()));
136883 15 : post_construction_initialization();
136884 :
136885 : // Test the isSgFunctionParameterList() function since it has been problematic
136886 15 : assert(isSgFunctionParameterList(this) != NULL);
136887 15 : }
136888 :
136889 : // Generated constructor (all data members)
136890 :
136891 : /* #line 136892 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136892 :
136893 :
136894 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
136895 :
136896 :
136897 : // ********************************************************
136898 : // member functions common across all array grammar objects
136899 : // ********************************************************
136900 :
136901 :
136902 :
136903 : /* #line 136904 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136904 :
136905 :
136906 :
136907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
136908 :
136909 : // ********************************************************
136910 : // member functions specific to each node in the grammar
136911 : // ********************************************************
136912 :
136913 :
136914 : /* #line 136915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
136915 :
136916 : // Start of memberFunctionString
136917 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
136918 :
136919 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
136920 :
136921 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
136922 : const SgInitializedNamePtrList &
136923 138165 : SgVariableDeclaration::get_variables () const
136924 : {
136925 138165 : assert (this != NULL);
136926 138165 : return p_variables;
136927 : }
136928 :
136929 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
136930 : SgInitializedNamePtrList &
136931 546870 : SgVariableDeclaration::get_variables ()
136932 : {
136933 546870 : assert (this != NULL);
136934 :
136935 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
136936 : // As a rule only set_ access functions can set the isModified flag.
136937 : // set_isModified(true);
136938 :
136939 546870 : return p_variables;
136940 : }
136941 :
136942 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
136943 :
136944 :
136945 : // End of memberFunctionString
136946 : // Start of memberFunctionString
136947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
136948 :
136949 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
136950 :
136951 : bool
136952 12165 : SgVariableDeclaration::get_variableDeclarationContainsBaseTypeDefiningDeclaration () const
136953 : {
136954 12165 : ROSE_ASSERT (this != NULL);
136955 :
136956 : #if 0
136957 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
136958 : // used to trigger marking transformations for the token-based unparsing.
136959 : printf ("SgVariableDeclaration::get_variableDeclarationContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
136960 : #endif
136961 :
136962 12165 : return p_variableDeclarationContainsBaseTypeDefiningDeclaration;
136963 : }
136964 :
136965 : void
136966 1277 : SgVariableDeclaration::set_variableDeclarationContainsBaseTypeDefiningDeclaration ( bool variableDeclarationContainsBaseTypeDefiningDeclaration )
136967 : {
136968 1277 : ROSE_ASSERT (this != NULL);
136969 :
136970 : #if 0
136971 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
136972 : // used to trigger marking transformations for the token-based unparsing.
136973 : printf ("SgVariableDeclaration::set_variableDeclarationContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
136974 : #endif
136975 :
136976 1277 : set_isModified(true);
136977 :
136978 1277 : p_variableDeclarationContainsBaseTypeDefiningDeclaration = variableDeclarationContainsBaseTypeDefiningDeclaration;
136979 1277 : }
136980 :
136981 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
136982 :
136983 :
136984 : // End of memberFunctionString
136985 : // Start of memberFunctionString
136986 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
136987 :
136988 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
136989 :
136990 : SgDeclarationStatement::template_specialization_enum
136991 20941 : SgVariableDeclaration::get_specialization () const
136992 : {
136993 20941 : ROSE_ASSERT (this != NULL);
136994 :
136995 : #if 0
136996 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
136997 : // used to trigger marking transformations for the token-based unparsing.
136998 : printf ("SgVariableDeclaration::get_specialization = %p = %s \n",this,this->class_name().c_str());
136999 : #endif
137000 :
137001 20941 : return p_specialization;
137002 : }
137003 :
137004 : void
137005 0 : SgVariableDeclaration::set_specialization ( SgDeclarationStatement::template_specialization_enum specialization )
137006 : {
137007 0 : ROSE_ASSERT (this != NULL);
137008 :
137009 : #if 0
137010 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137011 : // used to trigger marking transformations for the token-based unparsing.
137012 : printf ("SgVariableDeclaration::set_specialization = %p = %s \n",this,this->class_name().c_str());
137013 : #endif
137014 :
137015 0 : set_isModified(true);
137016 :
137017 0 : p_specialization = specialization;
137018 0 : }
137019 :
137020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137021 :
137022 :
137023 : // End of memberFunctionString
137024 : // Start of memberFunctionString
137025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137026 :
137027 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137028 :
137029 : std::string
137030 0 : SgVariableDeclaration::get_gnu_extension_section () const
137031 : {
137032 0 : ROSE_ASSERT (this != NULL);
137033 :
137034 : #if 0
137035 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137036 : // used to trigger marking transformations for the token-based unparsing.
137037 : printf ("SgVariableDeclaration::get_gnu_extension_section = %p = %s \n",this,this->class_name().c_str());
137038 : #endif
137039 :
137040 0 : return p_gnu_extension_section;
137041 : }
137042 :
137043 : void
137044 0 : SgVariableDeclaration::set_gnu_extension_section ( std::string gnu_extension_section )
137045 : {
137046 0 : ROSE_ASSERT (this != NULL);
137047 :
137048 : #if 0
137049 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137050 : // used to trigger marking transformations for the token-based unparsing.
137051 : printf ("SgVariableDeclaration::set_gnu_extension_section = %p = %s \n",this,this->class_name().c_str());
137052 : #endif
137053 :
137054 0 : set_isModified(true);
137055 :
137056 0 : p_gnu_extension_section = gnu_extension_section;
137057 0 : }
137058 :
137059 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137060 :
137061 :
137062 : // End of memberFunctionString
137063 : // Start of memberFunctionString
137064 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137065 :
137066 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137067 :
137068 : std::string
137069 0 : SgVariableDeclaration::get_gnu_extension_alias () const
137070 : {
137071 0 : ROSE_ASSERT (this != NULL);
137072 :
137073 : #if 0
137074 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137075 : // used to trigger marking transformations for the token-based unparsing.
137076 : printf ("SgVariableDeclaration::get_gnu_extension_alias = %p = %s \n",this,this->class_name().c_str());
137077 : #endif
137078 :
137079 0 : return p_gnu_extension_alias;
137080 : }
137081 :
137082 : void
137083 0 : SgVariableDeclaration::set_gnu_extension_alias ( std::string gnu_extension_alias )
137084 : {
137085 0 : ROSE_ASSERT (this != NULL);
137086 :
137087 : #if 0
137088 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137089 : // used to trigger marking transformations for the token-based unparsing.
137090 : printf ("SgVariableDeclaration::set_gnu_extension_alias = %p = %s \n",this,this->class_name().c_str());
137091 : #endif
137092 :
137093 0 : set_isModified(true);
137094 :
137095 0 : p_gnu_extension_alias = gnu_extension_alias;
137096 0 : }
137097 :
137098 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137099 :
137100 :
137101 : // End of memberFunctionString
137102 : // Start of memberFunctionString
137103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137104 :
137105 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137106 :
137107 : unsigned short
137108 0 : SgVariableDeclaration::get_gnu_extension_initialization_priority () const
137109 : {
137110 0 : ROSE_ASSERT (this != NULL);
137111 :
137112 : #if 0
137113 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137114 : // used to trigger marking transformations for the token-based unparsing.
137115 : printf ("SgVariableDeclaration::get_gnu_extension_initialization_priority = %p = %s \n",this,this->class_name().c_str());
137116 : #endif
137117 :
137118 0 : return p_gnu_extension_initialization_priority;
137119 : }
137120 :
137121 : void
137122 0 : SgVariableDeclaration::set_gnu_extension_initialization_priority ( unsigned short gnu_extension_initialization_priority )
137123 : {
137124 0 : ROSE_ASSERT (this != NULL);
137125 :
137126 : #if 0
137127 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137128 : // used to trigger marking transformations for the token-based unparsing.
137129 : printf ("SgVariableDeclaration::set_gnu_extension_initialization_priority = %p = %s \n",this,this->class_name().c_str());
137130 : #endif
137131 :
137132 0 : set_isModified(true);
137133 :
137134 0 : p_gnu_extension_initialization_priority = gnu_extension_initialization_priority;
137135 0 : }
137136 :
137137 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137138 :
137139 :
137140 : // End of memberFunctionString
137141 : // Start of memberFunctionString
137142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137143 :
137144 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137145 :
137146 : SgDeclarationStatement::gnu_extension_visability_attribute_enum
137147 0 : SgVariableDeclaration::get_gnu_extension_visability () const
137148 : {
137149 0 : ROSE_ASSERT (this != NULL);
137150 :
137151 : #if 0
137152 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137153 : // used to trigger marking transformations for the token-based unparsing.
137154 : printf ("SgVariableDeclaration::get_gnu_extension_visability = %p = %s \n",this,this->class_name().c_str());
137155 : #endif
137156 :
137157 0 : return p_gnu_extension_visability;
137158 : }
137159 :
137160 : void
137161 0 : SgVariableDeclaration::set_gnu_extension_visability ( SgDeclarationStatement::gnu_extension_visability_attribute_enum gnu_extension_visability )
137162 : {
137163 0 : ROSE_ASSERT (this != NULL);
137164 :
137165 : #if 0
137166 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137167 : // used to trigger marking transformations for the token-based unparsing.
137168 : printf ("SgVariableDeclaration::set_gnu_extension_visability = %p = %s \n",this,this->class_name().c_str());
137169 : #endif
137170 :
137171 0 : set_isModified(true);
137172 :
137173 0 : p_gnu_extension_visability = gnu_extension_visability;
137174 0 : }
137175 :
137176 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137177 :
137178 :
137179 : // End of memberFunctionString
137180 : // Start of memberFunctionString
137181 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137182 :
137183 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137184 :
137185 : SgVariableDeclaration::gnu_extension_declaration_attributes_enum
137186 0 : SgVariableDeclaration::get_gnu_extension_declaration_attribute () const
137187 : {
137188 0 : ROSE_ASSERT (this != NULL);
137189 :
137190 : #if 0
137191 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137192 : // used to trigger marking transformations for the token-based unparsing.
137193 : printf ("SgVariableDeclaration::get_gnu_extension_declaration_attribute = %p = %s \n",this,this->class_name().c_str());
137194 : #endif
137195 :
137196 0 : return p_gnu_extension_declaration_attribute;
137197 : }
137198 :
137199 : void
137200 0 : SgVariableDeclaration::set_gnu_extension_declaration_attribute ( SgVariableDeclaration::gnu_extension_declaration_attributes_enum gnu_extension_declaration_attribute )
137201 : {
137202 0 : ROSE_ASSERT (this != NULL);
137203 :
137204 : #if 0
137205 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137206 : // used to trigger marking transformations for the token-based unparsing.
137207 : printf ("SgVariableDeclaration::set_gnu_extension_declaration_attribute = %p = %s \n",this,this->class_name().c_str());
137208 : #endif
137209 :
137210 0 : set_isModified(true);
137211 :
137212 0 : p_gnu_extension_declaration_attribute = gnu_extension_declaration_attribute;
137213 0 : }
137214 :
137215 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137216 :
137217 :
137218 : // End of memberFunctionString
137219 : // Start of memberFunctionString
137220 :
137221 :
137222 : // End of memberFunctionString
137223 : // Start of memberFunctionString
137224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137225 :
137226 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137227 :
137228 : bool
137229 3568 : SgVariableDeclaration::get_isAssociatedWithDeclarationList () const
137230 : {
137231 3568 : ROSE_ASSERT (this != NULL);
137232 :
137233 : #if 0
137234 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137235 : // used to trigger marking transformations for the token-based unparsing.
137236 : printf ("SgVariableDeclaration::get_isAssociatedWithDeclarationList = %p = %s \n",this,this->class_name().c_str());
137237 : #endif
137238 :
137239 3568 : return p_isAssociatedWithDeclarationList;
137240 : }
137241 :
137242 : void
137243 1356 : SgVariableDeclaration::set_isAssociatedWithDeclarationList ( bool isAssociatedWithDeclarationList )
137244 : {
137245 1356 : ROSE_ASSERT (this != NULL);
137246 :
137247 : #if 0
137248 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137249 : // used to trigger marking transformations for the token-based unparsing.
137250 : printf ("SgVariableDeclaration::set_isAssociatedWithDeclarationList = %p = %s \n",this,this->class_name().c_str());
137251 : #endif
137252 :
137253 1356 : set_isModified(true);
137254 :
137255 1356 : p_isAssociatedWithDeclarationList = isAssociatedWithDeclarationList;
137256 1356 : }
137257 :
137258 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137259 :
137260 :
137261 : // End of memberFunctionString
137262 : // Start of memberFunctionString
137263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137264 :
137265 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137266 :
137267 : bool
137268 0 : SgVariableDeclaration::get_isFirstDeclarationOfDeclarationList () const
137269 : {
137270 0 : ROSE_ASSERT (this != NULL);
137271 :
137272 : #if 0
137273 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137274 : // used to trigger marking transformations for the token-based unparsing.
137275 : printf ("SgVariableDeclaration::get_isFirstDeclarationOfDeclarationList = %p = %s \n",this,this->class_name().c_str());
137276 : #endif
137277 :
137278 0 : return p_isFirstDeclarationOfDeclarationList;
137279 : }
137280 :
137281 : void
137282 0 : SgVariableDeclaration::set_isFirstDeclarationOfDeclarationList ( bool isFirstDeclarationOfDeclarationList )
137283 : {
137284 0 : ROSE_ASSERT (this != NULL);
137285 :
137286 : #if 0
137287 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137288 : // used to trigger marking transformations for the token-based unparsing.
137289 : printf ("SgVariableDeclaration::set_isFirstDeclarationOfDeclarationList = %p = %s \n",this,this->class_name().c_str());
137290 : #endif
137291 :
137292 0 : set_isModified(true);
137293 :
137294 0 : p_isFirstDeclarationOfDeclarationList = isFirstDeclarationOfDeclarationList;
137295 0 : }
137296 :
137297 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137298 :
137299 :
137300 : // End of memberFunctionString
137301 : // Start of memberFunctionString
137302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137303 :
137304 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137305 :
137306 : bool
137307 1232 : SgVariableDeclaration::get_is_thread_local () const
137308 : {
137309 1232 : ROSE_ASSERT (this != NULL);
137310 :
137311 : #if 0
137312 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137313 : // used to trigger marking transformations for the token-based unparsing.
137314 : printf ("SgVariableDeclaration::get_is_thread_local = %p = %s \n",this,this->class_name().c_str());
137315 : #endif
137316 :
137317 1232 : return p_is_thread_local;
137318 : }
137319 :
137320 : void
137321 0 : SgVariableDeclaration::set_is_thread_local ( bool is_thread_local )
137322 : {
137323 0 : ROSE_ASSERT (this != NULL);
137324 :
137325 : #if 0
137326 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137327 : // used to trigger marking transformations for the token-based unparsing.
137328 : printf ("SgVariableDeclaration::set_is_thread_local = %p = %s \n",this,this->class_name().c_str());
137329 : #endif
137330 :
137331 0 : set_isModified(true);
137332 :
137333 0 : p_is_thread_local = is_thread_local;
137334 0 : }
137335 :
137336 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137337 :
137338 :
137339 : // End of memberFunctionString
137340 : // Start of memberFunctionString
137341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137342 :
137343 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137344 :
137345 : bool
137346 3560 : SgVariableDeclaration::get_is_constexpr () const
137347 : {
137348 3560 : ROSE_ASSERT (this != NULL);
137349 :
137350 : #if 0
137351 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137352 : // used to trigger marking transformations for the token-based unparsing.
137353 : printf ("SgVariableDeclaration::get_is_constexpr = %p = %s \n",this,this->class_name().c_str());
137354 : #endif
137355 :
137356 3560 : return p_is_constexpr;
137357 : }
137358 :
137359 : void
137360 172 : SgVariableDeclaration::set_is_constexpr ( bool is_constexpr )
137361 : {
137362 172 : ROSE_ASSERT (this != NULL);
137363 :
137364 : #if 0
137365 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137366 : // used to trigger marking transformations for the token-based unparsing.
137367 : printf ("SgVariableDeclaration::set_is_constexpr = %p = %s \n",this,this->class_name().c_str());
137368 : #endif
137369 :
137370 172 : set_isModified(true);
137371 :
137372 172 : p_is_constexpr = is_constexpr;
137373 172 : }
137374 :
137375 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137376 :
137377 :
137378 : // End of memberFunctionString
137379 : // Start of memberFunctionString
137380 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
137381 :
137382 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
137383 :
137384 : bool
137385 393 : SgVariableDeclaration::get_builtFromUseOnly () const
137386 : {
137387 393 : ROSE_ASSERT (this != NULL);
137388 :
137389 : #if 0
137390 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137391 : // used to trigger marking transformations for the token-based unparsing.
137392 : printf ("SgVariableDeclaration::get_builtFromUseOnly = %p = %s \n",this,this->class_name().c_str());
137393 : #endif
137394 :
137395 393 : return p_builtFromUseOnly;
137396 : }
137397 :
137398 : void
137399 602 : SgVariableDeclaration::set_builtFromUseOnly ( bool builtFromUseOnly )
137400 : {
137401 602 : ROSE_ASSERT (this != NULL);
137402 :
137403 : #if 0
137404 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
137405 : // used to trigger marking transformations for the token-based unparsing.
137406 : printf ("SgVariableDeclaration::set_builtFromUseOnly = %p = %s \n",this,this->class_name().c_str());
137407 : #endif
137408 :
137409 602 : set_isModified(true);
137410 :
137411 602 : p_builtFromUseOnly = builtFromUseOnly;
137412 602 : }
137413 :
137414 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
137415 :
137416 :
137417 : // End of memberFunctionString
137418 : // Start of memberFunctionString
137419 : /* #line 12372 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
137420 :
137421 :
137422 0 : SgVariableDeclaration::SgVariableDeclaration(Sg_File_Info *info, const SgName& var_name, SgType *type, SgInitializer *initializer)
137423 0 : : SgDeclarationStatement(info)
137424 : {
137425 : // DQ (11/10/2006): Ultimately, i think this constructor should be eliminated since it will be
137426 : // redundant with a higher level interface which is planned and it is not automatically generated.
137427 0 : ROSE_ASSERT (this != NULL);
137428 :
137429 : // printf ("Inside of SgVariableDeclaration constructor taking all parameters \n");
137430 0 : initializeData (info,var_name,type,initializer);
137431 0 : }
137432 :
137433 33310 : SgVariableDeclaration::SgVariableDeclaration( const SgName& var_name, SgType *type, SgInitializer *initializer)
137434 : {
137435 : // DQ (11/10/2006): Ultimately, i think this constructor should be eliminated since it will be
137436 : // redundant with a higher level interface which is planned and it is not automatically generated.
137437 33310 : ROSE_ASSERT (this != NULL);
137438 :
137439 : // printf ("Inside of SgVariableDeclaration constructor taking all parameters \n");
137440 33310 : initializeData (NULL,var_name,type,initializer);
137441 33310 : }
137442 :
137443 0 : SgVariableDeclaration::SgVariableDeclaration( Sg_File_Info *info, SgInitializedName* c_item )
137444 : {
137445 0 : ROSE_ASSERT (this != NULL);
137446 0 : initializeData (info,c_item);
137447 0 : }
137448 :
137449 102 : SgVariableDeclaration::SgVariableDeclaration( SgInitializedName* c_item )
137450 : {
137451 102 : ROSE_ASSERT (this != NULL);
137452 102 : initializeData (NULL,c_item);
137453 102 : }
137454 :
137455 : void
137456 33310 : SgVariableDeclaration::initializeData(Sg_File_Info *info, const SgName& var_name, SgType *type, SgInitializer *initializer)
137457 : {
137458 33310 : ROSE_ASSERT (this != NULL);
137459 :
137460 : // DQ (7/20/2006): Suggested by Peter to so that the initializer will be used.
137461 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137462 : // SgInitializedName c_item(var_name, type, 0, this);
137463 : // SgInitializedName* c_item = new SgInitializedName(var_name, type, NULL, this);
137464 33310 : SgInitializedName* c_item = new SgInitializedName(var_name, type, initializer, this);
137465 33310 : ROSE_ASSERT (c_item != NULL);
137466 :
137467 33310 : initializeData (info, c_item);
137468 33310 : }
137469 :
137470 :
137471 : // DQ (7/18/2012): Add to the API so that we can build a SgVariableDeclaration from an existing SgInitializedName.
137472 : // void SgVariableDeclaration::initializeData(Sg_File_Info *info, const SgName& var_name, SgType *type, SgInitializer *initializer)
137473 : void
137474 33412 : SgVariableDeclaration::initializeData(Sg_File_Info *info, SgInitializedName* c_item)
137475 : {
137476 33412 : ROSE_ASSERT (this != NULL);
137477 :
137478 : // DQ (7/20/2006): Suggested by Peter to so that the initializer will be used.
137479 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137480 : // SgInitializedName c_item(var_name, type, 0, this);
137481 : // SgInitializedName* c_item = new SgInitializedName(var_name, type, NULL, this);
137482 : // SgInitializedName* c_item = new SgInitializedName(var_name, type, initializer, this);
137483 33412 : ROSE_ASSERT (c_item != NULL);
137484 :
137485 33412 : SgInitializer *initializer = c_item->get_initptr();
137486 :
137487 : // DQ (10/10/2007): Added fix for Liao, this is required when using the alternative constructors.
137488 : // DQ (10/10/2007): fixed the segmentation fault occurred in liaOutliner for class ::A this__ptr__
137489 33412 : p_variableDeclarationContainsBaseTypeDefiningDeclaration = false;
137490 :
137491 : // DQ(10/10/2007): Added initialization of another data member.
137492 33412 : p_baseTypeDefiningDeclaration = NULL; // non list case
137493 :
137494 : // DQ(10/10/2007): Added initialization of another data member.
137495 33412 : p_specialization = SgDeclarationStatement::e_no_specialization;
137496 :
137497 : // DQ(10/10/2007): Added initialization of another data member.
137498 33412 : p_requiresGlobalNameQualificationOnType = false;
137499 :
137500 : #if 0
137501 : // DQ (9/11/2020): These data members are not set (p_builtFromUseOnly was identified using valgrind).
137502 : // Unclear if this should go into the post_construction_initialization() function (better).
137503 : // p_gnu_extension_section = "";
137504 : // p_gnu_extension_alias = "";
137505 : p_gnu_extension_initialization_priority = 0;
137506 : p_gnu_extension_visability = SgDeclarationStatement::e_gnu_attribute_visability_unspecified;
137507 : p_gnu_extension_declaration_attribute = SgVariableDeclaration::e_gnu_attribute_unspecified;
137508 : p_name_qualification_length = 0;
137509 : p_type_elaboration_required = false;
137510 : p_global_qualification_required = false;
137511 : p_isAssociatedWithDeclarationList = false;
137512 : p_isFirstDeclarationOfDeclarationList = true;
137513 : p_is_thread_local = false;
137514 : p_is_constexpr = false;
137515 : p_builtFromUseOnly = false;
137516 : #endif
137517 :
137518 : #if PRINT_DEVELOPER_WARNINGS
137519 : printf ("Inside of SgVariableDeclaration::initializeData for constructor taking all parameters c_item = %p = %s \n",c_item,c_item->get_name().str());
137520 : #endif
137521 :
137522 : // DQ (6/8/2006): Need to set parent and scope of internally built variable
137523 33412 : c_item->set_parent(this);
137524 : // c_item->set_scope();
137525 : // ROSE_ASSERT(c_item->get_scope() != NULL);
137526 :
137527 : #if 1
137528 : // PC (7/14/2006): Set initializer's parent, as expected by inliner
137529 : // DQ (7/20/2006): this would be better handled by the code calling this
137530 : // constructor since this is now a side-effect on "initializer".
137531 33412 : if (initializer != NULL)
137532 : {
137533 1589 : initializer->set_parent(c_item);
137534 : }
137535 : #endif
137536 :
137537 : // DQ (11/10/2006): Added support for null file info pointer so that this could could be used by both constructors.
137538 33412 : if (info != NULL)
137539 : {
137540 : // DQ (8/3/2004): Need to set the file info on this SgInitializedName object (use a copy)
137541 0 : Sg_File_Info* copyOfFileInfo = new Sg_File_Info(*info);
137542 0 : ROSE_ASSERT (copyOfFileInfo != NULL);
137543 :
137544 : // DQ (12/18/2006): Added to set all parents of Sg_File_Info objects.
137545 0 : copyOfFileInfo->set_parent(c_item);
137546 :
137547 : // DQ (1/18/2006): Changed name to be consistent with SgNode::get_file_info()
137548 : // c_item->set_fileInfo(copyOfFileInfo);
137549 : // c_item->set_file_info(copyOfFileInfo);
137550 0 : c_item->set_startOfConstruct(copyOfFileInfo);
137551 :
137552 : }
137553 :
137554 : // DQ (12/15/2006): We are using the initializer in both the SgInitializedName and the
137555 : // SgVariableDefinition. We have to pass the initializer to append_variable() because
137556 : // the SgVariableDefinition is built there and we we have removed the code below that
137557 : // used to reset it. This implementation is better because we don't reset the initializer
137558 : // and the SgVariableDefinition, however that means we have to set it correctly the first time!
137559 : // So we pass the initializer into the append_variable() member function.
137560 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137561 : // SgInitializedName *decl_item=&(*(this->append_variable(c_item,0)));
137562 : // SgInitializedName *decl_item = *(this->append_variable(c_item,NULL));
137563 33412 : /* SgInitializedName *decl_item = */ this->append_variable(c_item,initializer);
137564 :
137565 : // DQ (6/1/2004): Can we enforce this?
137566 : // ROSE_ASSERT (decl_item == c_item);
137567 :
137568 : // DQ (10/6/2004): Adding documentation - this is to support the unparser and is always set to be true (so it seems).
137569 : // A newer mechanism explicitly marks the variable declaration if it contains a class definition which must be output
137570 : // when unparsing.
137571 : // Older comment: for class-P var, the definition part of class-P won't get printed
137572 33412 : this->setNameOnly();
137573 :
137574 : // DQ (11/18/2007): This should have been called anyway, but this adds support for Fortran declaration attributes.
137575 33412 : post_construction_initialization();
137576 33412 : }
137577 :
137578 : void
137579 34356 : SgVariableDeclaration::post_construction_initialization()
137580 : {
137581 : // DQ (11/18/2007): Added support for Fortran declaration attributes
137582 : // p_fortran_attribute_spec = SgBitVector(SgAttributeSpecificationStatement::e_last_attribute_spec,false);
137583 :
137584 : #if 0
137585 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
137586 : printf ("In SgVariableDeclaration::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
137587 : #endif
137588 :
137589 : // DQ (4/21/2014): Try to set this so that we can avoid a possible valgrind waring about this being sometimes unitialized.
137590 : // ==2562== 113 errors in context 34 of 34:
137591 : // ==2562== Conditional jump or move depends on uninitialised value(s)
137592 : // ==2562== at 0x69758FB: Unparse_ExprStmt::unparseVarDeclStmt(SgStatement*, SgUnparse_Info&) (unparseCxx_statements.C:4421)
137593 34356 : p_isAssociatedWithDeclarationList = false; // non list case
137594 :
137595 : // DQ (8/15/2014): These were not previously set by default.
137596 34356 : p_isFirstDeclarationOfDeclarationList = true;
137597 34356 : p_is_thread_local = false;
137598 : #if 0
137599 : // Moved these to SgInitializedName
137600 : p_using_C11_Alignas_keyword = false;
137601 : p_constant_or_type_argument_for_Alignas_keyword = false;
137602 : #endif
137603 34356 : p_is_constexpr = false;
137604 :
137605 : #if 1
137606 : // DQ (9/11/2020): I think this is a better place to do a centralized initialization.
137607 : // DQ (9/11/2020): These data members are not set (p_builtFromUseOnly was identified using valgrind).
137608 : // Unclear if this should go into the post_construction_initialization() function (better).
137609 : // We don't need to initialize strings, which have a default constructor.
137610 : // p_gnu_extension_section = "";
137611 : // p_gnu_extension_alias = "";
137612 34356 : p_gnu_extension_initialization_priority = 0;
137613 34356 : p_gnu_extension_visability = SgDeclarationStatement::e_gnu_attribute_visability_unspecified;
137614 34356 : p_gnu_extension_declaration_attribute = SgVariableDeclaration::e_gnu_attribute_unspecified;
137615 34356 : p_name_qualification_length = 0;
137616 34356 : p_type_elaboration_required = false;
137617 34356 : p_global_qualification_required = false;
137618 :
137619 : // DQ (9/11/2020): These are initialized above.
137620 : // p_isAssociatedWithDeclarationList = false;
137621 : // p_isFirstDeclarationOfDeclarationList = true;
137622 : // p_is_thread_local = false;
137623 : // p_is_constexpr = false;
137624 34356 : p_builtFromUseOnly = false;
137625 : #endif
137626 34356 : }
137627 :
137628 :
137629 : #if 0
137630 : // This is now stored in the type modifier (I think this is a better implementation)
137631 :
137632 : bool SgVariableDeclaration::isDefault() const { return checkBit(e_default,p_fortran_attribute_spec); }
137633 : void SgVariableDeclaration::setDefault() { setBit(e_default,p_fortran_attribute_spec); }
137634 : void SgVariableDeclaration::unsetDefault() { unsetBit(e_default,p_fortran_attribute_spec); }
137635 :
137636 : // Fortran specific declaration attribute support
137637 : bool testAccess_private_Attribute() const { return checkBit(e_default,p_fortran_attribute_spec); }
137638 : void setAccess_private_Attribute() { setBit(e_default,p_fortran_attribute_spec); }
137639 : void unsetAccess_private_Attribute() { unsetBit(e_default,p_fortran_attribute_spec); }
137640 :
137641 : bool testAccess_protected_Attribute() const;
137642 : void setAccess_protected_Attribute();
137643 : void unsetAccess_protected_Attribute();
137644 :
137645 : bool testAccess_public_Attribute() const;
137646 : void setAccess_public_Attribute();
137647 : void unsetAccess_public_Attribute();
137648 :
137649 : bool testAllocatableAttribute() const;
137650 : void setAllocatableAttribute();
137651 : void unsetAllocatableAttribute();
137652 :
137653 : bool testAsynchronousAttribute() const;
137654 : void setAsynchronousAttribute();
137655 : void unsetAsynchronousAttribute();
137656 :
137657 : bool testBindAttribute() const;
137658 : void setBindAttribute();
137659 : void unsetBindAttribute();
137660 :
137661 : bool testDataAttribute() const;
137662 : void setDataAttribute();
137663 : void unsetDataAttribute();
137664 :
137665 : bool testDimensionAttribute() const;
137666 : void setDimensionAttribute();
137667 : void unsetDimensionAttribute();
137668 :
137669 : bool testExternalAttribute() const;
137670 : void setExternalAttribute();
137671 : void unsetExternalAttribute();
137672 :
137673 : bool testIntent_in_Attribute() const;
137674 : void setIntent_in_Attribute();
137675 : void unsetIntent_in_Attribute();
137676 :
137677 : bool testIntent_out_Attribute() const;
137678 : void setIntent_out_Attribute();
137679 : void unsetIntent_out_Attribute();
137680 :
137681 : bool testIntent_inout_Attribute() const;
137682 : void setIntent_inout_Attribute();
137683 : void unsetIntent_inout_Attribute();
137684 :
137685 : bool testIntrinsicAttribute() const;
137686 : void setIntrinsicAttribute();
137687 : void unsetIntrinsicAttribute();
137688 :
137689 : bool testOptionalAttribute() const;
137690 : void setOptionalAttribute();
137691 : void unsetOptionalAttribute();
137692 :
137693 : bool testParameterAttribute() const;
137694 : void setParameterAttribute();
137695 : void unsetParameterAttribute();
137696 :
137697 : bool testPointerAttribute() const;
137698 : void setPointerAttribute();
137699 : void unsetPointerAttribute();
137700 :
137701 : bool testProtectedAttribute() const;
137702 : void setProtectedAttribute();
137703 : void unsetProtectedAttribute();
137704 :
137705 : bool testSaveAttribute() const;
137706 : void setSaveAttribute();
137707 : void unsetSaveAttribute();
137708 :
137709 : bool testTargetAttribute() const;
137710 : void setTargetAttribute();
137711 : void unsetTargetAttribute();
137712 :
137713 : bool testValueAttribute() const;
137714 : void setValueAttribute();
137715 : void unsetValueAttribute();
137716 :
137717 : bool testVolatileAttribute() const;
137718 : void setVolatileAttribute();
137719 : void unsetVolatileAttribute();
137720 :
137721 : #endif
137722 :
137723 :
137724 : // given a decl_item
137725 : SgVariableDefinition*
137726 86402 : SgVariableDeclaration::get_definition(SgInitializedName *ditem)
137727 : {
137728 86402 : SgVariableDefinition *defn_stmt = NULL;
137729 86402 : SgInitializedName *defn_item = NULL;
137730 : #if 0
137731 : printf ("In SgVariableDeclaration::get_definition(): ditem = %p \n",ditem);
137732 : #endif
137733 86402 : SgInitializedNamePtrList::iterator p = get_variables().begin();
137734 86402 : while ( p != get_variables().end() && ditem )
137735 : {
137736 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137737 0 : ROSE_ASSERT ((*p) != NULL);
137738 : #if 0
137739 : printf ("In SgVariableDeclaration::get_definition(): loop through variables *p = %p \n",*p);
137740 : #endif
137741 0 : if (ditem == (*p))
137742 : {
137743 : // QY 11/2/04 set defn_item = *p
137744 : // defn_item = (*p)->get_named_item();
137745 86402 : defn_item = (*p);
137746 : break;
137747 : }
137748 0 : p++;
137749 : }
137750 :
137751 86402 : if (ditem == NULL)
137752 : {
137753 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137754 : // defn_item=(*p).get_named_item();
137755 86402 : ROSE_ASSERT ((*p) != NULL);
137756 : // QY 11/2/04 set defn_item = *p
137757 : // defn_item=(*p)->get_named_item();
137758 86402 : defn_item = *p;
137759 : }
137760 : else
137761 : {
137762 : return NULL;
137763 : }
137764 : #if 0
137765 : printf ("In SgVariableDeclaration::get_definition(): defn_item = %p \n",defn_item);
137766 : #endif
137767 :
137768 : // if (defn_item)
137769 86402 : if (defn_item != NULL)
137770 : {
137771 : #if 0
137772 : printf ("In SgVariableDeclaration::get_definition(): defn_item->get_definition() = %p \n",defn_item->get_definition());
137773 : if (defn_item->get_definition() != NULL)
137774 : printf ("In SgVariableDeclaration::get_definition(): defn_item->get_definition() = %s \n",defn_item->get_definition()->class_name().c_str());
137775 : #endif
137776 : // DQ (9/9/2007): I think we can assert this for any SgInitializedName found in a SgVariableDeclaration,
137777 : // else perhaps we should have this function return a SgDeclarationStatement instead of a SgVariableDefinition.
137778 : /* MS (9/22/2020): removed ROSE_ASSERT(defn_item->get_definition() == NULL || isSgVariableDefinition(defn_item->get_definition()) );
137779 : because the SageBuilder:::buildVariableDeclaration calls 'new SgVariableDeclaration(name, type, varInit);'
137780 : which initializes SgInitializedName::p_declptr with a SgVariableDeclaration pointer and then this assertion is not correct */
137781 :
137782 : // can be 0 when SageBuilder:::buildVariableDeclaration is used
137783 86402 : defn_stmt = isSgVariableDefinition(defn_item->get_definition());
137784 : }
137785 :
137786 : return defn_stmt;
137787 : }
137788 :
137789 : // DQ (1/20/2014): This must be a SgValueExp, it is a constant expression ROSE uses a SgValueExp for this).
137790 : // SgUnsignedLongVal* SgVariableDeclaration::get_bitfield()
137791 : SgExpression*
137792 23098 : SgVariableDeclaration::get_bitfield()
137793 : {
137794 :
137795 : /* MS (9/22/2020): in case a bitfield is not present, get_definition
137796 : returns 0. Since this function is also used to determine
137797 : whether a bitfield is present, returning 0 is necessary. */
137798 23098 : if(get_definition()==0)
137799 : return 0;
137800 23098 : return get_definition()->get_bitfield();
137801 : }
137802 :
137803 : // DQ (1/20/2014): This must be a SgValueExp, it is a constant expression ROSE uses a SgValueExp for this).
137804 : // void SgVariableDeclaration::set_bitfield (SgUnsignedLongVal *bfield)
137805 : void
137806 88 : SgVariableDeclaration::set_bitfield (SgExpression* bfield)
137807 : {
137808 88 : assert(get_definition() != 0);
137809 88 : get_definition()->set_bitfield(bfield);
137810 88 : }
137811 :
137812 : void
137813 0 : SgVariableDeclaration::setStatic()
137814 : {
137815 0 : SgDeclarationStatement::setStatic();
137816 : // if it is a static member data
137817 :
137818 0 : printf ("Error: SgVariableDeclaration::setStatic() is deprecated \n");
137819 :
137820 : // SgStatement* parentPointer = get_parent();
137821 0 : SgStatement* parentPointer = isSgStatement(get_parent());
137822 : // assert(parentPointer != NULL);
137823 0 : bool isStaticDeclaration = (isSgClassDefinition(parentPointer) != NULL);
137824 :
137825 0 : if(isStaticDeclaration == true)
137826 0 : setDeclarationOnly();
137827 : // if(isSgClassDefinition(get_parent())) setDeclarationOnly();
137828 0 : }
137829 :
137830 : void
137831 0 : SgVariableDeclaration::setExtern()
137832 : {
137833 0 : printf ("Error: SgVariableDeclaration::setExtern() is deprecated \n");
137834 :
137835 0 : SgDeclarationStatement::setExtern();
137836 0 : setDeclarationOnly();
137837 0 : }
137838 :
137839 : int
137840 0 : SgVariableDeclaration::reset_initializer(SgInitializer *initializer)
137841 : {
137842 : /*
137843 : SgVariableDefinition *vdefn = get_definition();
137844 : if ( vdefn != NULL )
137845 : {
137846 : vdefn->set_initializer(initializer); // reset
137847 : return true;
137848 : }
137849 : return false;
137850 : */
137851 : // QY 11/5/04
137852 0 : if (get_variables().size()) {
137853 0 : get_variables().front()->set_initializer(initializer);
137854 0 : return true;
137855 : }
137856 : return false;
137857 : }
137858 :
137859 : // setForward in class variable declaration
137860 : void
137861 0 : SgVariableDeclaration::setDeclarationOnly()
137862 : {
137863 0 : SgInitializedName *defn_item = NULL;
137864 :
137865 0 : SgInitializedNamePtrList::iterator p = get_variables().begin();
137866 0 : while ( p != get_variables().end() )
137867 : {
137868 : // QY:11/3/04 removed get_named_item
137869 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137870 0 : ROSE_ASSERT ((*p) != NULL);
137871 : // defn_item = (*p)->get_named_item();
137872 0 : defn_item = (*p);
137873 0 : if (defn_item->get_definition())
137874 : {
137875 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137876 : // (*p).set_named_item(NULL);
137877 : // (*p)->set_named_item(NULL);
137878 0 : (*p)->set_definition(NULL);
137879 : }
137880 0 : p++;
137881 : }
137882 0 : setForward();
137883 0 : }
137884 :
137885 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137886 : void
137887 34354 : SgVariableDeclaration::append_variable( SgInitializedName* what, SgInitializer *initializer )
137888 : {
137889 34354 : ROSE_ASSERT (what != NULL);
137890 :
137891 34354 : get_variables().push_back(what);
137892 34354 : what->set_parent(this);
137893 :
137894 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137895 : // SgInitializedName *decl_item = &(*new_item);
137896 : // SgInitializedName *decl_item = *new_item;
137897 :
137898 : // printf ("Inside of SgVariableDeclaration::append_variable what = %p \n",what);
137899 : // printf ("Inside of SgVariableDeclaration::append_variable decl_item = %p \n",decl_item);
137900 :
137901 : // DQ (6/1/2004): Can we assert this
137902 : // ROSE_ASSERT (decl_item == what);
137903 :
137904 34354 : assert(this != NULL);
137905 34354 : ROSE_ASSERT (what != NULL);
137906 :
137907 34354 : SageBuilder::buildVariableDefinition_nfi (this, what, initializer);
137908 : #if 0
137909 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137910 : // if (!isSgFunctionType(what.get_type()))
137911 : if (!isSgFunctionType(what->get_type()))
137912 : {
137913 : #if 0
137914 : // DQ (5/20/2006): Avoid sharing the Sg_File_Info object from the SgVariableDeclaration
137915 : Sg_File_Info* copyOfFileInfo = new Sg_File_Info(*(this->get_file_info()));
137916 : ROSE_ASSERT (copyOfFileInfo != NULL);
137917 : // SgVariableDefinition *defn_stmt = new SgVariableDefinition(this->get_file_info(),decl_item,initializer);
137918 : SgVariableDefinition *defn_stmt = new SgVariableDefinition(copyOfFileInfo,decl_item,initializer);
137919 : assert (defn_stmt != NULL);
137920 : copyOfFileInfo->set_parent(defn_stmt);
137921 : #endif
137922 : // DQ (11/24/2006): This function is called from initializeData() which is required to work with or without a valid Sg_File_Info object.
137923 : Sg_File_Info* copyOfFileInfo = NULL;
137924 : SgVariableDefinition *defn_stmt = NULL;
137925 : if (this->get_file_info() != NULL)
137926 : {
137927 : copyOfFileInfo = new Sg_File_Info(*(this->get_file_info()));
137928 : ROSE_ASSERT (copyOfFileInfo != NULL);
137929 :
137930 : // Note that the SgVariableDefinition will connect the new IR node into the AST.
137931 : defn_stmt = new SgVariableDefinition(copyOfFileInfo,get_variables().back(),initializer);
137932 : assert (defn_stmt != NULL);
137933 :
137934 : copyOfFileInfo->set_parent(defn_stmt);
137935 :
137936 : // DQ (3/13/2007): We can't enforce that the endOfConstruct is set (if the interface using the startOfConstruct is used.
137937 : // DQ (2/3/2007): Need to build the endOfConstruct position as well.
137938 : // ROSE_ASSERT(this->get_endOfConstruct() != NULL);
137939 : if (this->get_endOfConstruct() != NULL)
137940 : {
137941 : Sg_File_Info* copyOfEndOfConstruct = new Sg_File_Info(*(this->get_endOfConstruct()));
137942 : defn_stmt->set_endOfConstruct(copyOfEndOfConstruct);
137943 : copyOfEndOfConstruct->set_parent(defn_stmt);
137944 : }
137945 : }
137946 : else
137947 : {
137948 : // Note that the SgVariableDefinition will connect the new IR node into the AST.
137949 : defn_stmt = new SgVariableDefinition(get_variables().back(),initializer);
137950 : }
137951 :
137952 : ROSE_ASSERT(defn_stmt != NULL);
137953 : // printf ("In SgVariableDeclaration::append_variable(): SgVariableDefinition *defn_stmt = %p \n",defn_stmt);
137954 : }
137955 : #endif
137956 34354 : }
137957 :
137958 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137959 : void
137960 10 : SgVariableDeclaration::prepend_variable( SgInitializedName* what, SgInitializer *initializer )
137961 : {
137962 10 : ROSE_ASSERT (what != NULL);
137963 :
137964 10 : get_variables().insert(get_variables().begin(),what);
137965 10 : what->set_parent(this);
137966 :
137967 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137968 : // SgInitializedName *decl_item = &(*new_item);
137969 : // SgInitializedName *decl_item = *new_item;
137970 :
137971 : // DQ (6/1/2004): Can we assert this
137972 : // ROSE_ASSERT (decl_item == what);
137973 10 : SageBuilder::buildVariableDefinition_nfi (this, what, initializer);
137974 : #if 0
137975 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
137976 : // if (!isSgFunctionType(what.get_type()))
137977 : if (!isSgFunctionType(what->get_type()))
137978 : {
137979 : #if 0
137980 : // DQ (5/20/2006): Avoid sharing the Sg_File_Info object from the SgVariableDeclaration
137981 : Sg_File_Info* copyOfFileInfo = new Sg_File_Info(*(this->get_file_info()));
137982 : ROSE_ASSERT (copyOfFileInfo != NULL);
137983 : // SgVariableDefinition *defn_stmt = new SgVariableDefinition(this->get_file_info(),decl_item,initializer);
137984 : SgVariableDefinition *defn_stmt = new SgVariableDefinition(copyOfFileInfo,decl_item,initializer);
137985 : assert (defn_stmt != NULL);
137986 : copyOfFileInfo->set_parent(defn_stmt);
137987 : #endif
137988 : // DQ (11/24/2006): This function is called from initializeData() which is required to work with or without a valid Sg_File_Info object.
137989 : Sg_File_Info* copyOfFileInfo = NULL;
137990 : SgVariableDefinition *defn_stmt = NULL;
137991 : if (this->get_file_info() != NULL)
137992 : {
137993 : copyOfFileInfo = new Sg_File_Info(*(this->get_file_info()));
137994 : ROSE_ASSERT (copyOfFileInfo != NULL);
137995 :
137996 : // Note that the SgVariableDefinition will connect the new IR node into the AST.
137997 : defn_stmt = new SgVariableDefinition(copyOfFileInfo,get_variables().front(),initializer);
137998 :
137999 : assert (defn_stmt != NULL);
138000 : copyOfFileInfo->set_parent(defn_stmt);
138001 :
138002 : // DQ (2/3/2007): Need to build the endOfConstruct position as well.
138003 : ROSE_ASSERT(this->get_endOfConstruct() != NULL);
138004 : Sg_File_Info* copyOfEndOfConstruct = new Sg_File_Info(*(this->get_endOfConstruct()));
138005 : copyOfEndOfConstruct->set_parent(defn_stmt);
138006 : defn_stmt->set_endOfConstruct(copyOfEndOfConstruct);
138007 : }
138008 : else
138009 : {
138010 : // Note that the SgVariableDefinition will connect the new IR node into the AST.
138011 : defn_stmt = new SgVariableDefinition(get_variables().front(),initializer);
138012 : }
138013 :
138014 : ROSE_ASSERT(defn_stmt != NULL);
138015 : // printf ("In SgVariableDeclaration::prepend_variable(): SgVariableDefinition *defn_stmt = %p \n",defn_stmt);
138016 : }
138017 : #endif
138018 10 : }
138019 :
138020 : #if 0
138021 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
138022 : SgInitializedNamePtrList::iterator
138023 : SgVariableDeclaration::insert_variable( const SgInitializedNamePtrList::iterator& where, SgInitializedName* what)
138024 : {
138025 : // DQ (9/27/2004): This function contains a side-effect on its input. For now just output a warning message.
138026 :
138027 : ROSE_ASSERT (what != NULL);
138028 : // if (what->get_declaration()) // set parent() of definition's declaration
138029 : // what->get_declaration()->set_parent(this);
138030 : // QY (11/3/04)
138031 : what->set_parent(this);
138032 :
138033 : SgInitializedNamePtrList::iterator new_item = get_variables().insert(where,what);
138034 :
138035 : // DQ (6/1/2004): Can we assert this
138036 : ROSE_ASSERT (*new_item == what);
138037 :
138038 : // this->setNameOnly();
138039 : return new_item;
138040 : }
138041 : #endif
138042 :
138043 : //QY 11/5/04 not needed any more since removed named_item in SgInitializedName
138044 : #if 0
138045 : SgInitializedName*
138046 : SgVariableDeclaration::get_defn_item(const SgName& nm)
138047 : {
138048 : SgInitializedName *decl_item = NULL;
138049 :
138050 : SgInitializedNamePtrList::iterator p = get_variables().begin();
138051 : while ( p != get_variables().end() )
138052 : {
138053 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
138054 : // if (nm.is_null() || (*p).get_name()==nm)
138055 : if (nm.is_null() || (*p)->get_name() == nm)
138056 : {
138057 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
138058 : // decl_item=&(*p);
138059 : decl_item = (*p);
138060 : break;
138061 : }
138062 : p++;
138063 : }
138064 :
138065 : // QY : 11/2/04 removed p_named_item
138066 : //if (decl_item && decl_item->get_named_item())
138067 : // return decl_item->get_named_item();
138068 : if (decl_item && decl_item->get_definition())
138069 : return decl_item;
138070 : else
138071 : return NULL;
138072 : }
138073 : #endif
138074 :
138075 : SgInitializedName*
138076 33703 : SgVariableDeclaration::get_decl_item(const SgName& nm)
138077 : {
138078 33703 : SgInitializedName *decl_item = NULL;
138079 :
138080 33703 : SgInitializedNamePtrList::iterator p = get_variables().begin();
138081 33703 : while ( p != get_variables().end() )
138082 : {
138083 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
138084 : // if (nm.is_null() || (*p).get_name()==nm)
138085 33703 : if (nm.is_null() || (*p)->get_name() == nm)
138086 : {
138087 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
138088 : // decl_item = &(*p);
138089 33703 : decl_item = *p;
138090 33703 : break;
138091 : }
138092 0 : p++;
138093 : }
138094 33703 : return decl_item;
138095 : }
138096 :
138097 : SgStatement*
138098 0 : SgVariableDeclaration::get_next(int & n) const
138099 : {
138100 0 : if (isNameOnly()) return 0;
138101 0 : if (n == 0)
138102 : {
138103 0 : n++;
138104 : // special case if type of variable declaration pt to a tag Reference which
138105 : // maybe a statement of some sort
138106 : // only need to worry about first variable's decl
138107 0 : SgInitializedNamePtrList::const_iterator p = get_variables().begin();
138108 :
138109 : // DQ (6/1/2004): Changed list to contain pointers to SgInitializedName elements
138110 : // SgType *tmp_type = (*p).get_type();
138111 0 : ROSE_ASSERT ((*p) != NULL);
138112 0 : SgType *tmp_type = (*p)->get_type();
138113 :
138114 0 : SgNamedType *ntype = isSgNamedType(tmp_type->findBaseType());
138115 0 : SgDeclarationStatement* declStmt =
138116 0 : (ntype) ? ntype->get_declaration() : (SgDeclarationStatement*)0L;
138117 0 : if ( declStmt && !declStmt->isForward() &&
138118 0 : (isSgClassDeclaration(declStmt) || isSgEnumDeclaration(declStmt) ) )
138119 : {
138120 0 : return declStmt;
138121 : }
138122 : else
138123 0 : return 0;
138124 : }
138125 : else
138126 : return 0;
138127 : }
138128 :
138129 : #if 0
138130 : // DQ (7/19/2005): SgVariableDeclaration should have a structural definition of its scope (based on position in
138131 : // source code) while the variables declared should (and do) have a posible different scope (via name qualification).
138132 : // DQ (7/4/2005): implement get_scope to query the initialized names in the initialized name list (SgInitializedNamePtrList)
138133 : // without this function we evaluate the scope using a traversal of the parents!
138134 : SgScopeStatement*
138135 : SgVariableDeclaration::get_scope(void) const
138136 : {
138137 : ROSE_ASSERT(this != NULL);
138138 :
138139 : // This function looks at the first SgInitializedName for file the scope which is stored there explicitly
138140 : const SgInitializedNamePtrList & variableList = get_variables();
138141 : ROSE_ASSERT(variableList.size() > 0);
138142 : const SgInitializedName* firstVariable = *(variableList.begin());
138143 : ROSE_ASSERT(firstVariable != NULL);
138144 :
138145 : // Note that if this function is called before the SgInitializedName's explicitly stored scope is set the result may be NULL
138146 : SgScopeStatement* scope = firstVariable->get_scope();
138147 : // ROSE_ASSERT(scope != NULL);
138148 :
138149 : return scope;
138150 : }
138151 : #endif
138152 :
138153 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
138154 : SgName
138155 31524 : SgVariableDeclaration::get_mangled_name(void) const
138156 : {
138157 31524 : SgName returnName;
138158 :
138159 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
138160 31524 : SgScopeStatement* scope = get_scope();
138161 31524 : ROSE_ASSERT(scope != NULL);
138162 :
138163 31524 : SgName variableNames;
138164 31524 : SgInitializedNamePtrList::const_iterator p = get_variables().begin();
138165 63078 : while ( p != get_variables().end() )
138166 : {
138167 : // DQ (2/22/2007): Added type to generated mangled name for each variable (supports AST merge generation of name for un-named classes)
138168 : // variableNames += SgName("_variable_name_") + (*p)->get_mangled_name();
138169 31554 : variableNames += SgName("_variable_type_") + (*p)->get_type()->get_mangled() + SgName("_variable_name_") + (*p)->get_mangled_name();
138170 :
138171 31554 : p++;
138172 : }
138173 :
138174 : #if 0
138175 : printf ("In SgVariableDeclaration::get_mangled_name(void): scope = %p = %s scope->get_qualified_name() = %s \n",
138176 : scope,scope->class_name().c_str(),scope->get_qualified_name().str());
138177 : #endif
138178 :
138179 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
138180 : // This is a poor way to handle the generation of a mangled name (will be improved)
138181 : // returnName = scope->get_qualified_name() + SgName("_variable_declaration_") + variableNames;
138182 31524 : returnName = scope->get_mangled_name() + SgName("_variable_declaration_") + variableNames;
138183 :
138184 31524 : return returnName;
138185 : }
138186 :
138187 : // GB (09/25/2007): Added this function as part of the traversal island fix. If this variable declaration contains the
138188 : // definition of its base type, that defining declaration is returned (computed via the type of the first initialized
138189 : // name in the list).
138190 : SgDeclarationStatement *
138191 1992800 : SgVariableDeclaration::compute_baseTypeDefiningDeclaration() const
138192 : {
138193 : // DQ (10/17/2007): It is likely that this function could be replaced with just:
138194 : // return p_baseTypeDefiningDeclaration;
138195 : // in the future.
138196 :
138197 1992800 : if (p_variableDeclarationContainsBaseTypeDefiningDeclaration == true)
138198 : {
138199 : #if 0
138200 : ROSE_ASSERT(!p_variables.empty());
138201 : SgInitializedName *var = p_variables.front();
138202 : SgNamedType *baseType = isSgNamedType(var->get_type()->findBaseType());
138203 : // GB (09/25/2007): Can we assert this? The flag above seems to tell us that we can.
138204 : ROSE_ASSERT(baseType != NULL);
138205 : return baseType->get_declaration()->get_definingDeclaration();
138206 : #else
138207 : // DQ (10/17/2007): Modified to permit the declaration to be stored and accessed so that the AST COPY mechanism
138208 : // would not have to lookup the declaration through the type (which is a problem because types are shared and
138209 : // so the declaration in the original AST is returned instead of the declaration form the copy of the AST).
138210 29864 : ROSE_ASSERT(p_baseTypeDefiningDeclaration != NULL);
138211 29864 : return p_baseTypeDefiningDeclaration;
138212 : #endif
138213 : }
138214 : else
138215 : {
138216 : // DQ (7/15/2012): This fails for test2012_120.C
138217 : // ROSE_ASSERT(p_baseTypeDefiningDeclaration == NULL);
138218 : if (p_baseTypeDefiningDeclaration != NULL)
138219 : {
138220 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
138221 : printf ("Warning: In SgVariableDeclaration::compute_baseTypeDefiningDeclaration(): p_baseTypeDefiningDeclaration != NULL but returning NULL \n");
138222 : #endif
138223 : }
138224 :
138225 : return NULL;
138226 : }
138227 : }
138228 :
138229 : SgDeclarationStatement *
138230 43828 : SgVariableDeclaration::get_baseTypeDefiningDeclaration() const
138231 : {
138232 : // DQ (10/14/2007): This provides an public (compute_baseTypeDefiningDeclaration() is private)
138233 : // interface similar to that for SgVariableDeclaration and for the same purpose (types defined
138234 : // in the typedef or variable declaration).
138235 :
138236 43828 : return compute_baseTypeDefiningDeclaration();
138237 : }
138238 :
138239 : void
138240 634 : SgVariableDeclaration::set_baseTypeDefiningDeclaration(SgDeclarationStatement* d)
138241 : {
138242 : // DQ (10/17/2007): This is a non ROSETTA generated function so that the get_baseTypeDefiningDeclaration()
138243 : // version can be written to use the compute_baseTypeDefiningDeclaration() member function. However, we
138244 : // are changing the compute_baseTypeDefiningDeclaration() member function to return the explicitly stored
138245 : // defining declaration in a SgVariableDeclaration (if such a thing is defined). An example of where this
138246 : // happens is in: "struct { int x; } y;", here the structure declaration is in the variable declaration for "y".
138247 :
138248 : // DQ (10/11/2014): We need to handle the case where the input in NULL, required for more general processing
138249 : // for ROSETTA generated ATerm support.
138250 : // ROSE_ASSERT(d != NULL);
138251 634 : if (d != NULL)
138252 : {
138253 634 : p_baseTypeDefiningDeclaration = d;
138254 634 : ROSE_ASSERT(p_baseTypeDefiningDeclaration != NULL);
138255 :
138256 : // Mark the p_variableDeclarationContainsBaseTypeDefiningDeclaration as true so that the p_baseTypeDefiningDeclaration
138257 : // declaration will be used (by compute_baseTypeDefiningDeclaration()).
138258 634 : set_variableDeclarationContainsBaseTypeDefiningDeclaration(true);
138259 : }
138260 : else
138261 : {
138262 0 : p_baseTypeDefiningDeclaration = NULL;
138263 0 : set_variableDeclarationContainsBaseTypeDefiningDeclaration(false);
138264 : }
138265 634 : }
138266 :
138267 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
138268 : // so that we could avoid them setting the isModified flag which is a problem in the
138269 : // name qualification support for C++ (interfering with the token-based unparsing).
138270 : int
138271 2328 : SgVariableDeclaration::get_name_qualification_length () const
138272 : {
138273 2328 : ROSE_ASSERT (this != NULL);
138274 2328 : return p_name_qualification_length;
138275 : }
138276 :
138277 : void
138278 0 : SgVariableDeclaration::set_name_qualification_length ( int name_qualification_length )
138279 : {
138280 0 : ROSE_ASSERT (this != NULL);
138281 : // This can't be called by the name qualification API (see test2015_26.C).
138282 : // set_isModified(true);
138283 :
138284 0 : p_name_qualification_length = name_qualification_length;
138285 0 : }
138286 :
138287 : bool
138288 2328 : SgVariableDeclaration::get_type_elaboration_required () const
138289 : {
138290 2328 : ROSE_ASSERT (this != NULL);
138291 2328 : return p_type_elaboration_required;
138292 : }
138293 :
138294 : void
138295 0 : SgVariableDeclaration::set_type_elaboration_required ( bool type_elaboration_required )
138296 : {
138297 0 : ROSE_ASSERT (this != NULL);
138298 : // This can't be called by the name qualification API (see test2015_26.C).
138299 : // set_isModified(true);
138300 :
138301 0 : p_type_elaboration_required = type_elaboration_required;
138302 0 : }
138303 :
138304 : bool
138305 2328 : SgVariableDeclaration::get_global_qualification_required () const
138306 : {
138307 2328 : ROSE_ASSERT (this != NULL);
138308 2328 : return p_global_qualification_required;
138309 : }
138310 :
138311 : void
138312 0 : SgVariableDeclaration::set_global_qualification_required ( bool global_qualification_required )
138313 : {
138314 0 : ROSE_ASSERT (this != NULL);
138315 :
138316 : // This can't be called by the name qualification API (see test2015_26.C).
138317 : // set_isModified(true);
138318 :
138319 0 : p_global_qualification_required = global_qualification_required;
138320 0 : }
138321 :
138322 : bool
138323 3560 : SgVariableDeclaration::get_requiresGlobalNameQualificationOnType () const
138324 : {
138325 3560 : ROSE_ASSERT (this != NULL);
138326 3560 : return p_requiresGlobalNameQualificationOnType;
138327 : }
138328 :
138329 : void
138330 0 : SgVariableDeclaration::set_requiresGlobalNameQualificationOnType ( bool requiresGlobalNameQualificationOnType )
138331 : {
138332 0 : ROSE_ASSERT (this != NULL);
138333 : // This can't be called by the name qualification API (see test2015_26.C).
138334 : // set_isModified(true);
138335 :
138336 0 : p_requiresGlobalNameQualificationOnType = requiresGlobalNameQualificationOnType;
138337 0 : }
138338 :
138339 :
138340 :
138341 : // End of memberFunctionString
138342 : // Start of memberFunctionString
138343 : /* #line 9727 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
138344 :
138345 :
138346 : bool
138347 0 : SgVariableDeclaration::isSpecialization() const
138348 : {
138349 0 : bool returnValue = false;
138350 0 : returnValue = (p_specialization == SgDeclarationStatement::e_specialization);
138351 0 : return returnValue;
138352 : }
138353 :
138354 : bool
138355 0 : SgVariableDeclaration::isPartialSpecialization() const
138356 : {
138357 0 : bool returnValue = false;
138358 0 : returnValue = (p_specialization == SgDeclarationStatement::e_partial_specialization);
138359 0 : return returnValue;
138360 : }
138361 :
138362 :
138363 :
138364 : // End of memberFunctionString
138365 : // Start of memberFunctionString
138366 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
138367 :
138368 : // *** COMMON CODE SECTION BEGINS HERE ***
138369 :
138370 : #if 0
138371 : int
138372 : SgVariableDeclaration::getVariant() const
138373 : {
138374 : // This function is used in ROSE while "variant()" is used in SAGE
138375 : assert(this != NULL);
138376 : return variant();
138377 : }
138378 : #endif
138379 :
138380 : // This function is used in ROSE in treeTraversal code
138381 : // eventually replaces getVariant() and variant()
138382 : // though after variant() has been removed for a while we will
138383 : // want to change the name of variantT() back to variant()
138384 : // (since the "T" was ment to stand for temporary).
138385 : // When this happens the variantT() will be depricated.
138386 : VariantT
138387 10784000 : SgVariableDeclaration::variantT() const
138388 : {
138389 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
138390 10784000 : ROSE_ASSERT(this != NULL);
138391 10784000 : return V_SgVariableDeclaration;
138392 : }
138393 :
138394 : #if 0
138395 : int
138396 : SgVariableDeclaration::variant() const
138397 : {
138398 : // This function is used in SAGE
138399 : ROSE_ASSERT(this != NULL);
138400 : return VAR_DECL_STMT;
138401 : }
138402 : #endif
138403 :
138404 : ROSE_DLL_API const char*
138405 1202 : SgVariableDeclaration::sage_class_name() const
138406 : {
138407 1202 : ROSE_ASSERT(this != NULL);
138408 1202 : return "SgVariableDeclaration";
138409 : }
138410 :
138411 : std::string
138412 31498 : SgVariableDeclaration::class_name() const
138413 : {
138414 31498 : ROSE_ASSERT(this != NULL);
138415 31498 : return "SgVariableDeclaration";
138416 : }
138417 :
138418 : // DQ (11/26/2005): Support for visitor pattern mechanims
138419 : // (inferior to ROSE traversal mechanism, experimental).
138420 : void
138421 176933 : SgVariableDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
138422 : {
138423 176933 : ROSE_ASSERT(this != NULL);
138424 176933 : visitor.visit(this);
138425 176933 : }
138426 :
138427 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
138428 0 : void SgVariableDeclaration::accept (ROSE_VisitorPattern & visitor) {
138429 0 : ROSE_ASSERT(this != NULL);
138430 0 : visitor.visit(this);
138431 0 : }
138432 :
138433 : SgVariableDeclaration*
138434 0 : SgVariableDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
138435 : {
138436 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
138437 : // This function is currently only supported for the AST used the represent Binary executables.
138438 : if (0 /* isSgAsmNode(this) != NULL */)
138439 : {
138440 : // Support for regex specification.
138441 : std::string prefixCode = "REGEX:";
138442 : addNewAttribute(prefixCode + s,a);
138443 : }
138444 : #endif
138445 :
138446 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
138447 0 : return this;
138448 : }
138449 :
138450 : // *** COMMON CODE SECTION ENDS HERE ***
138451 :
138452 :
138453 : // End of memberFunctionString
138454 : // Start of memberFunctionString
138455 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
138456 :
138457 :
138458 : #if 0
138459 : //! Error checking support
138460 : /*! Verifies the following:
138461 : - working getVariant() member function
138462 : - calls base class's error() member function
138463 : Every class has one of these functions.
138464 : */
138465 : bool
138466 : SgVariableDeclaration::error()
138467 : {
138468 : // Put error checking here
138469 :
138470 : ROSE_ASSERT (this != NULL);
138471 : if (getVariant() != VAR_DECL_STMT)
138472 : {
138473 : printf ("Error in SgVariableDeclaration::error(): SgVariableDeclaration object has a %s variant \n",
138474 : Cxx_GrammarTerminalNames[getVariant()].name);
138475 : // printf ("Error in SgVariableDeclaration::error() \n");
138476 : ROSE_ABORT();
138477 : }
138478 :
138479 : ROSE_ASSERT (getVariant() == VAR_DECL_STMT);
138480 : return SgDeclarationStatement::error();
138481 : }
138482 : #endif
138483 :
138484 :
138485 :
138486 : // End of memberFunctionString
138487 :
138488 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
138489 :
138490 21277200 : SgVariableDeclaration* isSgVariableDeclaration ( SgNode* inputDerivedClassPointer )
138491 : {
138492 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
138493 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
138494 : // So to fix this we return NULL directly when the input is NULL and avoid the
138495 : // dynamic_cast in this case. This is likely a performance improvement as well.
138496 : // return dynamic_cast<SgVariableDeclaration*>(inputDerivedClassPointer);
138497 : // Milind Chabbi (8/28/2013): isSgVariableDeclaration uses table-driven castability instead of c++ default dynamic_cast
138498 : // this improves the running time performance by 10-20%.
138499 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVariableDeclaration*>(inputDerivedClassPointer);
138500 21277200 : return IS_SgVariableDeclaration_FAST_MACRO(inputDerivedClassPointer);
138501 : }
138502 :
138503 : // DQ (11/8/2003): Added version of functions taking const pointer
138504 1276000 : const SgVariableDeclaration* isSgVariableDeclaration ( const SgNode* inputDerivedClassPointer )
138505 : {
138506 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
138507 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
138508 : // So to fix this we return NULL directly when the input is NULL and avoid the
138509 : // dynamic_cast in this case. This is likely a performance improvement as well.
138510 : // return dynamic_cast<const SgVariableDeclaration*>(inputDerivedClassPointer);
138511 : // Milind Chabbi (8/28/2013): isSgVariableDeclaration uses table-driven castability instead of c++ default dynamic_cast
138512 : // this improves the running time performance by 10-20%.
138513 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVariableDeclaration*>(inputDerivedClassPointer);
138514 1276000 : return IS_SgVariableDeclaration_FAST_MACRO(inputDerivedClassPointer);
138515 : }
138516 :
138517 :
138518 :
138519 : /* #line 138520 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
138520 :
138521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
138522 :
138523 : /**
138524 : \brief Generated destructor
138525 :
138526 : This destructor is automatically generated (by ROSETTA). This destructor
138527 : only frees memory of data members associated with the parts of the current IR node which
138528 : are NOT traversed. Those data members that are part of a traversal can be freed using
138529 : a traversal (calling this destructor on all children in a post-order traversal). Such
138530 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
138531 :
138532 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
138533 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
138534 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
138535 :
138536 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
138537 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
138538 : pointers are not yet implemented to call delete on eash pointer in the container.
138539 : (This could be done by derivation from the STL containers to define containers that
138540 : automatically deleted their members.)
138541 :
138542 : */
138543 8175 : SgVariableDeclaration::~SgVariableDeclaration () {
138544 2793 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
138545 :
138546 :
138547 : // case: not a listType for baseTypeDefiningDeclaration
138548 2793 : p_baseTypeDefiningDeclaration = NULL; // non list case
138549 : // case: not a listType for variableDeclarationContainsBaseTypeDefiningDeclaration
138550 2793 : p_variableDeclarationContainsBaseTypeDefiningDeclaration = false; // non list case
138551 : // case: not a listType for specialization
138552 2793 : p_specialization = SgDeclarationStatement::e_no_specialization; // non list case
138553 : // case: not a listType for requiresGlobalNameQualificationOnType
138554 2793 : p_requiresGlobalNameQualificationOnType = false; // non list case
138555 : // case: not a listType for gnu_extension_section
138556 2793 : p_gnu_extension_section = ""; // non list case
138557 : // case: not a listType for gnu_extension_alias
138558 2793 : p_gnu_extension_alias = ""; // non list case
138559 : // case: not a listType for gnu_extension_initialization_priority
138560 2793 : p_gnu_extension_initialization_priority = 0; // non list case
138561 : // case: not a listType for gnu_extension_visability
138562 2793 : p_gnu_extension_visability = SgDeclarationStatement::e_gnu_attribute_visability_unspecified; // non list case
138563 : // case: not a listType for gnu_extension_declaration_attribute
138564 2793 : p_gnu_extension_declaration_attribute = SgVariableDeclaration::e_gnu_attribute_unspecified; // non list case
138565 : // case: not a listType for name_qualification_length
138566 2793 : p_name_qualification_length = 0; // non list case
138567 : // case: not a listType for type_elaboration_required
138568 2793 : p_type_elaboration_required = false; // non list case
138569 : // case: not a listType for global_qualification_required
138570 2793 : p_global_qualification_required = false; // non list case
138571 : // case: not a listType for isAssociatedWithDeclarationList
138572 2793 : p_isAssociatedWithDeclarationList = false; // non list case
138573 : // case: not a listType for isFirstDeclarationOfDeclarationList
138574 2793 : p_isFirstDeclarationOfDeclarationList = true; // non list case
138575 : // case: not a listType for is_thread_local
138576 2793 : p_is_thread_local = false; // non list case
138577 : // case: not a listType for is_constexpr
138578 2793 : p_is_constexpr = false; // non list case
138579 : // case: not a listType for builtFromUseOnly
138580 2793 : p_builtFromUseOnly = false; // non list case
138581 :
138582 : }
138583 :
138584 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
138585 5382 : }
138586 :
138587 :
138588 : /* #line 138589 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
138589 :
138590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
138591 :
138592 : // Generated constructor
138593 22 : SgVariableDeclaration::SgVariableDeclaration ( Sg_File_Info* startOfConstruct )
138594 22 : : SgDeclarationStatement(startOfConstruct)
138595 : {
138596 : #ifdef DEBUG
138597 : // printf ("In SgVariableDeclaration::SgVariableDeclaration (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
138598 : #endif
138599 : #if 0
138600 : // debugging information!
138601 : printf ("In SgVariableDeclaration::SgVariableDeclaration (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
138602 : #endif
138603 :
138604 22 : p_baseTypeDefiningDeclaration = NULL;
138605 22 : p_variableDeclarationContainsBaseTypeDefiningDeclaration = false;
138606 22 : p_specialization = SgDeclarationStatement::e_no_specialization;
138607 22 : p_requiresGlobalNameQualificationOnType = false;
138608 22 : p_gnu_extension_section = "";
138609 22 : p_gnu_extension_alias = "";
138610 22 : p_gnu_extension_initialization_priority = 0;
138611 22 : p_gnu_extension_visability = SgDeclarationStatement::e_gnu_attribute_visability_unspecified;
138612 22 : p_gnu_extension_declaration_attribute = SgVariableDeclaration::e_gnu_attribute_unspecified;
138613 22 : p_name_qualification_length = 0;
138614 22 : p_type_elaboration_required = false;
138615 22 : p_global_qualification_required = false;
138616 22 : p_isAssociatedWithDeclarationList = false;
138617 22 : p_isFirstDeclarationOfDeclarationList = true;
138618 22 : p_is_thread_local = false;
138619 22 : p_is_constexpr = false;
138620 22 : p_builtFromUseOnly = false;
138621 :
138622 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
138623 :
138624 : #if 0
138625 : // DQ (7/30/2014): Call a virtual function.
138626 : std::string s = this->class_name();
138627 : #endif
138628 :
138629 : // Test the variant virtual function
138630 : // assert(VAR_DECL_STMT == variant());
138631 22 : assert(VAR_DECL_STMT == this->variant());
138632 22 : ROSE_ASSERT(VAR_DECL_STMT == (int)(this->variantT()));
138633 22 : post_construction_initialization();
138634 :
138635 : // Test the isSgVariableDeclaration() function since it has been problematic
138636 22 : assert(isSgVariableDeclaration(this) != NULL);
138637 22 : }
138638 :
138639 : // Generated constructor (all data members)
138640 :
138641 : /* #line 138642 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
138642 :
138643 :
138644 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
138645 :
138646 :
138647 : // ********************************************************
138648 : // member functions common across all array grammar objects
138649 : // ********************************************************
138650 :
138651 :
138652 :
138653 : /* #line 138654 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
138654 :
138655 :
138656 :
138657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
138658 :
138659 : // ********************************************************
138660 : // member functions specific to each node in the grammar
138661 : // ********************************************************
138662 :
138663 :
138664 : /* #line 138665 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
138665 :
138666 : // Start of memberFunctionString
138667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
138668 :
138669 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
138670 :
138671 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
138672 : const SgTemplateParameterPtrList &
138673 0 : SgTemplateVariableDeclaration::get_templateParameters () const
138674 : {
138675 0 : assert (this != NULL);
138676 0 : return p_templateParameters;
138677 : }
138678 :
138679 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
138680 : SgTemplateParameterPtrList &
138681 1820 : SgTemplateVariableDeclaration::get_templateParameters ()
138682 : {
138683 1820 : assert (this != NULL);
138684 :
138685 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
138686 : // As a rule only set_ access functions can set the isModified flag.
138687 : // set_isModified(true);
138688 :
138689 1820 : return p_templateParameters;
138690 : }
138691 :
138692 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
138693 :
138694 :
138695 : // End of memberFunctionString
138696 : // Start of memberFunctionString
138697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
138698 :
138699 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
138700 :
138701 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
138702 : const SgTemplateArgumentPtrList &
138703 0 : SgTemplateVariableDeclaration::get_templateSpecializationArguments () const
138704 : {
138705 0 : assert (this != NULL);
138706 0 : return p_templateSpecializationArguments;
138707 : }
138708 :
138709 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
138710 : SgTemplateArgumentPtrList &
138711 1143 : SgTemplateVariableDeclaration::get_templateSpecializationArguments ()
138712 : {
138713 1143 : assert (this != NULL);
138714 :
138715 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
138716 : // As a rule only set_ access functions can set the isModified flag.
138717 : // set_isModified(true);
138718 :
138719 1143 : return p_templateSpecializationArguments;
138720 : }
138721 :
138722 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
138723 :
138724 :
138725 : // End of memberFunctionString
138726 : // Start of memberFunctionString
138727 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
138728 :
138729 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
138730 :
138731 : SgName
138732 289 : SgTemplateVariableDeclaration::get_string () const
138733 : {
138734 289 : ROSE_ASSERT (this != NULL);
138735 :
138736 : #if 0
138737 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
138738 : // used to trigger marking transformations for the token-based unparsing.
138739 : printf ("SgTemplateVariableDeclaration::get_string = %p = %s \n",this,this->class_name().c_str());
138740 : #endif
138741 :
138742 289 : return p_string;
138743 : }
138744 :
138745 : void
138746 188 : SgTemplateVariableDeclaration::set_string ( SgName string )
138747 : {
138748 188 : ROSE_ASSERT (this != NULL);
138749 :
138750 : #if 0
138751 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
138752 : // used to trigger marking transformations for the token-based unparsing.
138753 : printf ("SgTemplateVariableDeclaration::set_string = %p = %s \n",this,this->class_name().c_str());
138754 : #endif
138755 :
138756 188 : set_isModified(true);
138757 :
138758 188 : p_string = string;
138759 188 : }
138760 :
138761 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
138762 :
138763 :
138764 : // End of memberFunctionString
138765 : // Start of memberFunctionString
138766 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
138767 :
138768 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
138769 :
138770 : SgDeclarationScope*
138771 0 : SgTemplateVariableDeclaration::get_nonreal_decl_scope () const
138772 : {
138773 0 : ROSE_ASSERT (this != NULL);
138774 :
138775 : #if 0
138776 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
138777 : // used to trigger marking transformations for the token-based unparsing.
138778 : printf ("SgTemplateVariableDeclaration::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
138779 : #endif
138780 :
138781 0 : return p_nonreal_decl_scope;
138782 : }
138783 :
138784 : void
138785 188 : SgTemplateVariableDeclaration::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
138786 : {
138787 188 : ROSE_ASSERT (this != NULL);
138788 :
138789 : #if 0
138790 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
138791 : // used to trigger marking transformations for the token-based unparsing.
138792 : printf ("SgTemplateVariableDeclaration::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
138793 : #endif
138794 :
138795 188 : set_isModified(true);
138796 :
138797 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
138798 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
138799 : {
138800 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
138801 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
138802 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
138803 : ROSE_ASSERT(false);
138804 : #endif
138805 : }
138806 : #endif
138807 188 : p_nonreal_decl_scope = nonreal_decl_scope;
138808 188 : }
138809 :
138810 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
138811 :
138812 :
138813 : // End of memberFunctionString
138814 : // Start of memberFunctionString
138815 : /* #line 16902 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
138816 :
138817 :
138818 : void
138819 0 : SgTemplateVariableDeclaration::post_construction_initialization()
138820 : {
138821 : // DQ (12/21/2011): This is not what we want for the newer design with SgTemplateVariableDeclaration derived from SgVariableDeclaration.
138822 : // this->set_template_kind(e_template_m_data);
138823 0 : }
138824 :
138825 :
138826 909 : SgTemplateVariableDeclaration::SgTemplateVariableDeclaration( const SgName& var_name, SgType *type, SgInitializer *initializer)
138827 909 : : SgVariableDeclaration(var_name,type,initializer), p_nonreal_decl_scope(NULL)
138828 : {
138829 : // DQ (11/10/2006): Ultimately, i think this constructor should be eliminated since it will be
138830 : // redundant with a higher level interface which is planned and it is not automatically generated.
138831 909 : ROSE_ASSERT (this != NULL);
138832 :
138833 : // printf ("Inside of SgTemplateVariableDeclaration constructor taking all parameters \n");
138834 : // initializeData (NULL,var_name,type,initializer);
138835 909 : }
138836 :
138837 : // DQ (12/29/2011): The generate Cxx_Grammar.h header file will see the prototype for this function (even though I tried to make it NOT visible).
138838 : // As a result we need a function definition (but we need only call the base class version of the function).
138839 : SgDeclarationStatement *
138840 87943 : SgTemplateVariableDeclaration::compute_baseTypeDefiningDeclaration() const
138841 : {
138842 87943 : return SgVariableDeclaration::compute_baseTypeDefiningDeclaration();
138843 : }
138844 :
138845 :
138846 :
138847 : // End of memberFunctionString
138848 : // Start of memberFunctionString
138849 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
138850 :
138851 : // *** COMMON CODE SECTION BEGINS HERE ***
138852 :
138853 : #if 0
138854 : int
138855 : SgTemplateVariableDeclaration::getVariant() const
138856 : {
138857 : // This function is used in ROSE while "variant()" is used in SAGE
138858 : assert(this != NULL);
138859 : return variant();
138860 : }
138861 : #endif
138862 :
138863 : // This function is used in ROSE in treeTraversal code
138864 : // eventually replaces getVariant() and variant()
138865 : // though after variant() has been removed for a while we will
138866 : // want to change the name of variantT() back to variant()
138867 : // (since the "T" was ment to stand for temporary).
138868 : // When this happens the variantT() will be depricated.
138869 : VariantT
138870 425074 : SgTemplateVariableDeclaration::variantT() const
138871 : {
138872 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
138873 425074 : ROSE_ASSERT(this != NULL);
138874 425074 : return V_SgTemplateVariableDeclaration;
138875 : }
138876 :
138877 : #if 0
138878 : int
138879 : SgTemplateVariableDeclaration::variant() const
138880 : {
138881 : // This function is used in SAGE
138882 : ROSE_ASSERT(this != NULL);
138883 : return TEMPLATE_VARIABLE_DECL_STMT;
138884 : }
138885 : #endif
138886 :
138887 : ROSE_DLL_API const char*
138888 2 : SgTemplateVariableDeclaration::sage_class_name() const
138889 : {
138890 2 : ROSE_ASSERT(this != NULL);
138891 2 : return "SgTemplateVariableDeclaration";
138892 : }
138893 :
138894 : std::string
138895 762 : SgTemplateVariableDeclaration::class_name() const
138896 : {
138897 762 : ROSE_ASSERT(this != NULL);
138898 762 : return "SgTemplateVariableDeclaration";
138899 : }
138900 :
138901 : // DQ (11/26/2005): Support for visitor pattern mechanims
138902 : // (inferior to ROSE traversal mechanism, experimental).
138903 : void
138904 13957 : SgTemplateVariableDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
138905 : {
138906 13957 : ROSE_ASSERT(this != NULL);
138907 13957 : visitor.visit(this);
138908 13957 : }
138909 :
138910 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
138911 0 : void SgTemplateVariableDeclaration::accept (ROSE_VisitorPattern & visitor) {
138912 0 : ROSE_ASSERT(this != NULL);
138913 0 : visitor.visit(this);
138914 0 : }
138915 :
138916 : SgTemplateVariableDeclaration*
138917 0 : SgTemplateVariableDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
138918 : {
138919 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
138920 : // This function is currently only supported for the AST used the represent Binary executables.
138921 : if (0 /* isSgAsmNode(this) != NULL */)
138922 : {
138923 : // Support for regex specification.
138924 : std::string prefixCode = "REGEX:";
138925 : addNewAttribute(prefixCode + s,a);
138926 : }
138927 : #endif
138928 :
138929 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
138930 0 : return this;
138931 : }
138932 :
138933 : // *** COMMON CODE SECTION ENDS HERE ***
138934 :
138935 :
138936 : // End of memberFunctionString
138937 : // Start of memberFunctionString
138938 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
138939 :
138940 :
138941 : #if 0
138942 : //! Error checking support
138943 : /*! Verifies the following:
138944 : - working getVariant() member function
138945 : - calls base class's error() member function
138946 : Every class has one of these functions.
138947 : */
138948 : bool
138949 : SgTemplateVariableDeclaration::error()
138950 : {
138951 : // Put error checking here
138952 :
138953 : ROSE_ASSERT (this != NULL);
138954 : if (getVariant() != TEMPLATE_VARIABLE_DECL_STMT)
138955 : {
138956 : printf ("Error in SgTemplateVariableDeclaration::error(): SgTemplateVariableDeclaration object has a %s variant \n",
138957 : Cxx_GrammarTerminalNames[getVariant()].name);
138958 : // printf ("Error in SgTemplateVariableDeclaration::error() \n");
138959 : ROSE_ABORT();
138960 : }
138961 :
138962 : ROSE_ASSERT (getVariant() == TEMPLATE_VARIABLE_DECL_STMT);
138963 : return SgVariableDeclaration::error();
138964 : }
138965 : #endif
138966 :
138967 :
138968 :
138969 : // End of memberFunctionString
138970 :
138971 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
138972 :
138973 14950300 : SgTemplateVariableDeclaration* isSgTemplateVariableDeclaration ( SgNode* inputDerivedClassPointer )
138974 : {
138975 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
138976 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
138977 : // So to fix this we return NULL directly when the input is NULL and avoid the
138978 : // dynamic_cast in this case. This is likely a performance improvement as well.
138979 : // return dynamic_cast<SgTemplateVariableDeclaration*>(inputDerivedClassPointer);
138980 : // Milind Chabbi (8/28/2013): isSgTemplateVariableDeclaration uses table-driven castability instead of c++ default dynamic_cast
138981 : // this improves the running time performance by 10-20%.
138982 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateVariableDeclaration*>(inputDerivedClassPointer);
138983 14950300 : return IS_SgTemplateVariableDeclaration_FAST_MACRO(inputDerivedClassPointer);
138984 : }
138985 :
138986 : // DQ (11/8/2003): Added version of functions taking const pointer
138987 0 : const SgTemplateVariableDeclaration* isSgTemplateVariableDeclaration ( const SgNode* inputDerivedClassPointer )
138988 : {
138989 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
138990 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
138991 : // So to fix this we return NULL directly when the input is NULL and avoid the
138992 : // dynamic_cast in this case. This is likely a performance improvement as well.
138993 : // return dynamic_cast<const SgTemplateVariableDeclaration*>(inputDerivedClassPointer);
138994 : // Milind Chabbi (8/28/2013): isSgTemplateVariableDeclaration uses table-driven castability instead of c++ default dynamic_cast
138995 : // this improves the running time performance by 10-20%.
138996 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateVariableDeclaration*>(inputDerivedClassPointer);
138997 0 : return IS_SgTemplateVariableDeclaration_FAST_MACRO(inputDerivedClassPointer);
138998 : }
138999 :
139000 :
139001 :
139002 : /* #line 139003 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139003 :
139004 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
139005 :
139006 : /**
139007 : \brief Generated destructor
139008 :
139009 : This destructor is automatically generated (by ROSETTA). This destructor
139010 : only frees memory of data members associated with the parts of the current IR node which
139011 : are NOT traversed. Those data members that are part of a traversal can be freed using
139012 : a traversal (calling this destructor on all children in a post-order traversal). Such
139013 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
139014 :
139015 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
139016 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
139017 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
139018 :
139019 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
139020 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
139021 : pointers are not yet implemented to call delete on eash pointer in the container.
139022 : (This could be done by derivation from the STL containers to define containers that
139023 : automatically deleted their members.)
139024 :
139025 : */
139026 448 : SgTemplateVariableDeclaration::~SgTemplateVariableDeclaration () {
139027 204 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
139028 :
139029 204 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
139030 :
139031 : // case: listType for templateParameters
139032 : // case: listType (typeIsPointerToList == false) for templateParameters
139033 204 : p_templateParameters.erase(p_templateParameters.begin(),p_templateParameters.end());
139034 : // case: listType for templateSpecializationArguments
139035 : // case: listType (typeIsPointerToList == false) for templateSpecializationArguments
139036 204 : p_templateSpecializationArguments.erase(p_templateSpecializationArguments.begin(),p_templateSpecializationArguments.end());
139037 : // case: not a listType for string
139038 204 : p_string = ""; // non list case
139039 : // case: not a listType for nonreal_decl_scope
139040 204 : p_nonreal_decl_scope = NULL; // non list case
139041 :
139042 : }
139043 :
139044 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
139045 408 : }
139046 :
139047 :
139048 : /* #line 139049 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139049 :
139050 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
139051 :
139052 : // Generated constructor
139053 0 : SgTemplateVariableDeclaration::SgTemplateVariableDeclaration ( Sg_File_Info* startOfConstruct )
139054 0 : : SgVariableDeclaration(startOfConstruct)
139055 : {
139056 : #ifdef DEBUG
139057 : // printf ("In SgTemplateVariableDeclaration::SgTemplateVariableDeclaration (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
139058 : #endif
139059 : #if 0
139060 : // debugging information!
139061 : printf ("In SgTemplateVariableDeclaration::SgTemplateVariableDeclaration (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
139062 : #endif
139063 :
139064 0 : p_templateParameters = SgTemplateParameterPtrList();
139065 0 : p_templateSpecializationArguments = SgTemplateArgumentPtrList();
139066 0 : p_string = "";
139067 0 : p_nonreal_decl_scope = NULL;
139068 :
139069 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
139070 :
139071 : #if 0
139072 : // DQ (7/30/2014): Call a virtual function.
139073 : std::string s = this->class_name();
139074 : #endif
139075 :
139076 : // Test the variant virtual function
139077 : // assert(TEMPLATE_VARIABLE_DECL_STMT == variant());
139078 0 : assert(TEMPLATE_VARIABLE_DECL_STMT == this->variant());
139079 0 : ROSE_ASSERT(TEMPLATE_VARIABLE_DECL_STMT == (int)(this->variantT()));
139080 0 : post_construction_initialization();
139081 :
139082 : // Test the isSgTemplateVariableDeclaration() function since it has been problematic
139083 0 : assert(isSgTemplateVariableDeclaration(this) != NULL);
139084 0 : }
139085 :
139086 : // Generated constructor (all data members)
139087 :
139088 : /* #line 139089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139089 :
139090 :
139091 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
139092 :
139093 :
139094 : // ********************************************************
139095 : // member functions common across all array grammar objects
139096 : // ********************************************************
139097 :
139098 :
139099 :
139100 : /* #line 139101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139101 :
139102 :
139103 :
139104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
139105 :
139106 : // ********************************************************
139107 : // member functions specific to each node in the grammar
139108 : // ********************************************************
139109 :
139110 :
139111 : /* #line 139112 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139112 :
139113 : // Start of memberFunctionString
139114 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
139115 :
139116 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
139117 :
139118 : SgInitializedName*
139119 98746 : SgVariableDefinition::get_vardefn () const
139120 : {
139121 98746 : ROSE_ASSERT (this != NULL);
139122 :
139123 : #if 0
139124 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
139125 : // used to trigger marking transformations for the token-based unparsing.
139126 : printf ("SgVariableDefinition::get_vardefn = %p = %s \n",this,this->class_name().c_str());
139127 : #endif
139128 :
139129 98746 : return p_vardefn;
139130 : }
139131 :
139132 : void
139133 0 : SgVariableDefinition::set_vardefn ( SgInitializedName* vardefn )
139134 : {
139135 0 : ROSE_ASSERT (this != NULL);
139136 :
139137 : #if 0
139138 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
139139 : // used to trigger marking transformations for the token-based unparsing.
139140 : printf ("SgVariableDefinition::set_vardefn = %p = %s \n",this,this->class_name().c_str());
139141 : #endif
139142 :
139143 0 : set_isModified(true);
139144 :
139145 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
139146 : if (p_vardefn != NULL && vardefn != NULL && p_vardefn != vardefn)
139147 : {
139148 : printf ("Warning: vardefn = %p overwriting valid pointer p_vardefn = %p \n",vardefn,p_vardefn);
139149 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
139150 : printf ("Error fails assertion (p_vardefn != NULL && vardefn != NULL && p_vardefn != vardefn) is false\n");
139151 : ROSE_ASSERT(false);
139152 : #endif
139153 : }
139154 : #endif
139155 0 : p_vardefn = vardefn;
139156 0 : }
139157 :
139158 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
139159 :
139160 :
139161 : // End of memberFunctionString
139162 : // Start of memberFunctionString
139163 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
139164 :
139165 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
139166 :
139167 : SgExpression*
139168 41241 : SgVariableDefinition::get_bitfield () const
139169 : {
139170 41241 : ROSE_ASSERT (this != NULL);
139171 :
139172 : #if 0
139173 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
139174 : // used to trigger marking transformations for the token-based unparsing.
139175 : printf ("SgVariableDefinition::get_bitfield = %p = %s \n",this,this->class_name().c_str());
139176 : #endif
139177 :
139178 41241 : return p_bitfield;
139179 : }
139180 :
139181 : void
139182 88 : SgVariableDefinition::set_bitfield ( SgExpression* bitfield )
139183 : {
139184 88 : ROSE_ASSERT (this != NULL);
139185 :
139186 : #if 0
139187 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
139188 : // used to trigger marking transformations for the token-based unparsing.
139189 : printf ("SgVariableDefinition::set_bitfield = %p = %s \n",this,this->class_name().c_str());
139190 : #endif
139191 :
139192 88 : set_isModified(true);
139193 :
139194 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
139195 : if (p_bitfield != NULL && bitfield != NULL && p_bitfield != bitfield)
139196 : {
139197 : printf ("Warning: bitfield = %p overwriting valid pointer p_bitfield = %p \n",bitfield,p_bitfield);
139198 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
139199 : printf ("Error fails assertion (p_bitfield != NULL && bitfield != NULL && p_bitfield != bitfield) is false\n");
139200 : ROSE_ASSERT(false);
139201 : #endif
139202 : }
139203 : #endif
139204 88 : p_bitfield = bitfield;
139205 88 : }
139206 :
139207 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
139208 :
139209 :
139210 : // End of memberFunctionString
139211 : // Start of memberFunctionString
139212 : /* #line 13294 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
139213 :
139214 : void
139215 22 : SgVariableDefinition::post_construction_initialization()
139216 : {
139217 : #if 0
139218 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
139219 : printf ("In SgVariableDefinition::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
139220 : #endif
139221 22 : }
139222 :
139223 : SgVariableDeclaration*
139224 0 : SgVariableDefinition::get_declaration()
139225 : {
139226 0 : assert(get_vardefn() != NULL);
139227 :
139228 0 : SgVariableDeclaration *rdecl = isSgVariableDeclaration(get_vardefn()->get_declaration());
139229 0 : return rdecl;
139230 : }
139231 :
139232 952 : SgVariableDefinition::
139233 952 : SgVariableDefinition(Sg_File_Info *info, SgInitializedName *decl_item, SgInitializer *initializer)
139234 : : SgDeclarationStatement(info),
139235 : // DQ (11/20/2004): Reordered pre-initialization list to avoid compiler warnings.
139236 : // p_initializer_expr_root(new SgExpressionRoot(initializer == 0?New_File_Info(this) : new Sg_File_Info(*initializer->get_file_info()), initializer)),
139237 : // QY:11/2/04 remove redundant coupled SgInitializedName nodes.
139238 : // p_vardefn ( new SgInitializedName(decl_item->get_name(),NULL,initializer,this,NULL,NULL))
139239 : p_vardefn(decl_item),
139240 952 : p_bitfield(0)
139241 :
139242 : {
139243 : // In many places this constructor is called (via the new operator) with the resulting
139244 : // pointer returned by operator::new UNUSED. The reason why this works is because the
139245 : // call to "set_parent()" at the base of the constructor attaches this object to the
139246 : // program tree (I think this is inelegant (since it is the only class that works this
139247 : // way in SAGE), but I will leave it as is for now).
139248 :
139249 952 : ROSE_ASSERT(decl_item != NULL);
139250 :
139251 : #if 0
139252 : // DQ (10/29/2006): This only resets the file info in the SgInitilaizedName object (a memory
139253 : // leak at least if it were not also an error, since now we set the source position more
139254 : // precisely and this overwrites the correct value!)
139255 :
139256 : // DQ (8/3/2004): Need to set the file info on this SgInitializedName object (use a copy)
139257 : Sg_File_Info* copyOfFileInfo = new Sg_File_Info(*info);
139258 : ROSE_ASSERT (copyOfFileInfo != NULL);
139259 :
139260 : // DQ (1/18/2006): Changed name to be consistent with SgNode::get_file_info()
139261 : // get_vardefn()->set_fileInfo(copyOfFileInfo);
139262 : get_vardefn()->set_file_info(copyOfFileInfo);
139263 :
139264 : // This should be NULL to to avoid a cycle (set to NULL in call to constructor, above)
139265 : // ROSE_ASSERT (get_vardefn()->get_itemptr() == NULL);
139266 :
139267 : // printf ("In SgVariableDefinition constructor: defn_item = %p \n",defn_item);
139268 : #endif
139269 :
139270 : // QY:11/2/04 do not create a new SgInitializedName. set p_vardefn = decl_item, then set the initializer in decl_item instead
139271 : // This resets the itemptr pointer in the declaration to the SgInitializedName object
139272 : // decl_item->set_named_item(get_vardefn());
139273 952 : set_parent(decl_item);
139274 952 : get_vardefn()->set_initializer(initializer);
139275 952 : get_vardefn()->set_definition(this);
139276 :
139277 : // Sage 2 includes this code (the body of post_construction_initialization()
139278 : // instead of calling post_construction_initialization() directly) (?)
139279 952 : ROSE_ASSERT(decl_item != NULL);
139280 : //ROSE_ASSERT(decl_item->get_declaration() != NULL);
139281 : //ROSE_ASSERT(isSgVariableDeclaration(decl_item->get_declaration()) != NULL);
139282 952 : }
139283 :
139284 33412 : SgVariableDefinition::
139285 33412 : SgVariableDefinition( SgInitializedName *decl_item, SgInitializer *initializer)
139286 : : p_vardefn(decl_item),
139287 33412 : p_bitfield(0)
139288 : {
139289 : // DQ (11/10/2006): This is a version of the constructor that is separated from the source position initialization.
139290 33412 : ROSE_ASSERT(decl_item != NULL);
139291 :
139292 33412 : set_parent(decl_item);
139293 33412 : get_vardefn()->set_initializer(initializer);
139294 33412 : get_vardefn()->set_definition(this);
139295 :
139296 33412 : ROSE_ASSERT(decl_item != NULL);
139297 33412 : }
139298 :
139299 : SgType*
139300 0 : SgVariableDefinition::get_type()
139301 : {
139302 0 : return get_vardefn()->get_type();
139303 : }
139304 :
139305 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
139306 : SgName
139307 30018 : SgVariableDefinition::get_mangled_name(void) const
139308 : {
139309 30018 : SgName returnName;
139310 :
139311 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
139312 30018 : SgScopeStatement* scope = get_scope();
139313 30018 : ROSE_ASSERT(scope != NULL);
139314 :
139315 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
139316 : // This is a poor way to handle the generation of a mangled name (will be improved)
139317 : // returnName = scope->get_qualified_name() + SgName("_variable_definition_") + get_vardefn()->get_mangled_name();
139318 30018 : returnName = scope->get_mangled_name() + SgName("_variable_definition_") + get_vardefn()->get_mangled_name();
139319 :
139320 30018 : return returnName;
139321 : }
139322 :
139323 :
139324 :
139325 : // End of memberFunctionString
139326 : // Start of memberFunctionString
139327 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
139328 :
139329 : // *** COMMON CODE SECTION BEGINS HERE ***
139330 :
139331 : #if 0
139332 : int
139333 : SgVariableDefinition::getVariant() const
139334 : {
139335 : // This function is used in ROSE while "variant()" is used in SAGE
139336 : assert(this != NULL);
139337 : return variant();
139338 : }
139339 : #endif
139340 :
139341 : // This function is used in ROSE in treeTraversal code
139342 : // eventually replaces getVariant() and variant()
139343 : // though after variant() has been removed for a while we will
139344 : // want to change the name of variantT() back to variant()
139345 : // (since the "T" was ment to stand for temporary).
139346 : // When this happens the variantT() will be depricated.
139347 : VariantT
139348 2361830 : SgVariableDefinition::variantT() const
139349 : {
139350 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
139351 2361830 : ROSE_ASSERT(this != NULL);
139352 2361830 : return V_SgVariableDefinition;
139353 : }
139354 :
139355 : #if 0
139356 : int
139357 : SgVariableDefinition::variant() const
139358 : {
139359 : // This function is used in SAGE
139360 : ROSE_ASSERT(this != NULL);
139361 : return VAR_DEFN_STMT;
139362 : }
139363 : #endif
139364 :
139365 : ROSE_DLL_API const char*
139366 0 : SgVariableDefinition::sage_class_name() const
139367 : {
139368 0 : ROSE_ASSERT(this != NULL);
139369 0 : return "SgVariableDefinition";
139370 : }
139371 :
139372 : std::string
139373 32282 : SgVariableDefinition::class_name() const
139374 : {
139375 32282 : ROSE_ASSERT(this != NULL);
139376 32282 : return "SgVariableDefinition";
139377 : }
139378 :
139379 : // DQ (11/26/2005): Support for visitor pattern mechanims
139380 : // (inferior to ROSE traversal mechanism, experimental).
139381 : void
139382 190890 : SgVariableDefinition::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
139383 : {
139384 190890 : ROSE_ASSERT(this != NULL);
139385 190890 : visitor.visit(this);
139386 190890 : }
139387 :
139388 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
139389 0 : void SgVariableDefinition::accept (ROSE_VisitorPattern & visitor) {
139390 0 : ROSE_ASSERT(this != NULL);
139391 0 : visitor.visit(this);
139392 0 : }
139393 :
139394 : SgVariableDefinition*
139395 0 : SgVariableDefinition::addRegExpAttribute(std::string s, AstRegExAttribute* a)
139396 : {
139397 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
139398 : // This function is currently only supported for the AST used the represent Binary executables.
139399 : if (0 /* isSgAsmNode(this) != NULL */)
139400 : {
139401 : // Support for regex specification.
139402 : std::string prefixCode = "REGEX:";
139403 : addNewAttribute(prefixCode + s,a);
139404 : }
139405 : #endif
139406 :
139407 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
139408 0 : return this;
139409 : }
139410 :
139411 : // *** COMMON CODE SECTION ENDS HERE ***
139412 :
139413 :
139414 : // End of memberFunctionString
139415 : // Start of memberFunctionString
139416 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
139417 :
139418 :
139419 : #if 0
139420 : //! Error checking support
139421 : /*! Verifies the following:
139422 : - working getVariant() member function
139423 : - calls base class's error() member function
139424 : Every class has one of these functions.
139425 : */
139426 : bool
139427 : SgVariableDefinition::error()
139428 : {
139429 : // Put error checking here
139430 :
139431 : ROSE_ASSERT (this != NULL);
139432 : if (getVariant() != VAR_DEFN_STMT)
139433 : {
139434 : printf ("Error in SgVariableDefinition::error(): SgVariableDefinition object has a %s variant \n",
139435 : Cxx_GrammarTerminalNames[getVariant()].name);
139436 : // printf ("Error in SgVariableDefinition::error() \n");
139437 : ROSE_ABORT();
139438 : }
139439 :
139440 : ROSE_ASSERT (getVariant() == VAR_DEFN_STMT);
139441 : return SgDeclarationStatement::error();
139442 : }
139443 : #endif
139444 :
139445 :
139446 :
139447 : // End of memberFunctionString
139448 :
139449 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
139450 :
139451 43843200 : SgVariableDefinition* isSgVariableDefinition ( SgNode* inputDerivedClassPointer )
139452 : {
139453 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
139454 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
139455 : // So to fix this we return NULL directly when the input is NULL and avoid the
139456 : // dynamic_cast in this case. This is likely a performance improvement as well.
139457 : // return dynamic_cast<SgVariableDefinition*>(inputDerivedClassPointer);
139458 : // Milind Chabbi (8/28/2013): isSgVariableDefinition uses table-driven castability instead of c++ default dynamic_cast
139459 : // this improves the running time performance by 10-20%.
139460 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVariableDefinition*>(inputDerivedClassPointer);
139461 43843200 : return IS_SgVariableDefinition_FAST_MACRO(inputDerivedClassPointer);
139462 : }
139463 :
139464 : // DQ (11/8/2003): Added version of functions taking const pointer
139465 1246010 : const SgVariableDefinition* isSgVariableDefinition ( const SgNode* inputDerivedClassPointer )
139466 : {
139467 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
139468 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
139469 : // So to fix this we return NULL directly when the input is NULL and avoid the
139470 : // dynamic_cast in this case. This is likely a performance improvement as well.
139471 : // return dynamic_cast<const SgVariableDefinition*>(inputDerivedClassPointer);
139472 : // Milind Chabbi (8/28/2013): isSgVariableDefinition uses table-driven castability instead of c++ default dynamic_cast
139473 : // this improves the running time performance by 10-20%.
139474 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVariableDefinition*>(inputDerivedClassPointer);
139475 1246010 : return IS_SgVariableDefinition_FAST_MACRO(inputDerivedClassPointer);
139476 : }
139477 :
139478 :
139479 :
139480 : /* #line 139481 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139481 :
139482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
139483 :
139484 : /**
139485 : \brief Generated destructor
139486 :
139487 : This destructor is automatically generated (by ROSETTA). This destructor
139488 : only frees memory of data members associated with the parts of the current IR node which
139489 : are NOT traversed. Those data members that are part of a traversal can be freed using
139490 : a traversal (calling this destructor on all children in a post-order traversal). Such
139491 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
139492 :
139493 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
139494 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
139495 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
139496 :
139497 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
139498 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
139499 : pointers are not yet implemented to call delete on eash pointer in the container.
139500 : (This could be done by derivation from the STL containers to define containers that
139501 : automatically deleted their members.)
139502 :
139503 : */
139504 5586 : SgVariableDefinition::~SgVariableDefinition () {
139505 2793 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
139506 :
139507 :
139508 : // case: not a listType for vardefn
139509 2793 : p_vardefn = NULL; // non list case
139510 : // case: not a listType for bitfield
139511 2793 : p_bitfield = NULL; // non list case
139512 :
139513 : }
139514 :
139515 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
139516 5586 : }
139517 :
139518 :
139519 : /* #line 139520 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139520 :
139521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
139522 :
139523 : // Generated constructor
139524 0 : SgVariableDefinition::SgVariableDefinition ( Sg_File_Info* startOfConstruct, SgInitializedName* vardefn, SgExpression* bitfield )
139525 0 : : SgDeclarationStatement(startOfConstruct)
139526 : {
139527 : #ifdef DEBUG
139528 : // printf ("In SgVariableDefinition::SgVariableDefinition (Sg_File_Info* startOfConstruct, SgInitializedName* vardefn, SgExpression* bitfield) sage_class_name() = %s \n",sage_class_name());
139529 : #endif
139530 : #if 0
139531 : // debugging information!
139532 : printf ("In SgVariableDefinition::SgVariableDefinition (Sg_File_Info* startOfConstruct, SgInitializedName* vardefn, SgExpression* bitfield): this = %p = %s \n",this,this->class_name().c_str());
139533 : #endif
139534 :
139535 0 : p_vardefn = vardefn;
139536 0 : p_bitfield = bitfield;
139537 :
139538 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
139539 :
139540 : #if 0
139541 : // DQ (7/30/2014): Call a virtual function.
139542 : std::string s = this->class_name();
139543 : #endif
139544 :
139545 : // Test the variant virtual function
139546 : // assert(VAR_DEFN_STMT == variant());
139547 0 : assert(VAR_DEFN_STMT == this->variant());
139548 0 : ROSE_ASSERT(VAR_DEFN_STMT == (int)(this->variantT()));
139549 0 : post_construction_initialization();
139550 :
139551 : // Test the isSgVariableDefinition() function since it has been problematic
139552 0 : assert(isSgVariableDefinition(this) != NULL);
139553 0 : }
139554 :
139555 : // Generated constructor (all data members)
139556 :
139557 : /* #line 139558 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139558 :
139559 :
139560 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
139561 :
139562 :
139563 : // ********************************************************
139564 : // member functions common across all array grammar objects
139565 : // ********************************************************
139566 :
139567 :
139568 :
139569 : /* #line 139570 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139570 :
139571 :
139572 :
139573 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
139574 :
139575 : // ********************************************************
139576 : // member functions specific to each node in the grammar
139577 : // ********************************************************
139578 :
139579 :
139580 : /* #line 139581 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139581 :
139582 : // Start of memberFunctionString
139583 :
139584 :
139585 : // End of memberFunctionString
139586 : // Start of memberFunctionString
139587 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
139588 :
139589 : void
139590 0 : SgClinkageDeclarationStatement::post_construction_initialization()
139591 : {
139592 0 : }
139593 :
139594 :
139595 :
139596 : // End of memberFunctionString
139597 : // Start of memberFunctionString
139598 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
139599 :
139600 : // *** COMMON CODE SECTION BEGINS HERE ***
139601 :
139602 : #if 0
139603 : int
139604 : SgClinkageDeclarationStatement::getVariant() const
139605 : {
139606 : // This function is used in ROSE while "variant()" is used in SAGE
139607 : assert(this != NULL);
139608 : return variant();
139609 : }
139610 : #endif
139611 :
139612 : // This function is used in ROSE in treeTraversal code
139613 : // eventually replaces getVariant() and variant()
139614 : // though after variant() has been removed for a while we will
139615 : // want to change the name of variantT() back to variant()
139616 : // (since the "T" was ment to stand for temporary).
139617 : // When this happens the variantT() will be depricated.
139618 : VariantT
139619 0 : SgClinkageDeclarationStatement::variantT() const
139620 : {
139621 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
139622 0 : ROSE_ASSERT(this != NULL);
139623 0 : return V_SgClinkageDeclarationStatement;
139624 : }
139625 :
139626 : #if 0
139627 : int
139628 : SgClinkageDeclarationStatement::variant() const
139629 : {
139630 : // This function is used in SAGE
139631 : ROSE_ASSERT(this != NULL);
139632 : return C_LINKAGE_DECLARATION_STMT;
139633 : }
139634 : #endif
139635 :
139636 : ROSE_DLL_API const char*
139637 0 : SgClinkageDeclarationStatement::sage_class_name() const
139638 : {
139639 0 : ROSE_ASSERT(this != NULL);
139640 0 : return "SgClinkageDeclarationStatement";
139641 : }
139642 :
139643 : std::string
139644 0 : SgClinkageDeclarationStatement::class_name() const
139645 : {
139646 0 : ROSE_ASSERT(this != NULL);
139647 0 : return "SgClinkageDeclarationStatement";
139648 : }
139649 :
139650 : // DQ (11/26/2005): Support for visitor pattern mechanims
139651 : // (inferior to ROSE traversal mechanism, experimental).
139652 : void
139653 0 : SgClinkageDeclarationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
139654 : {
139655 0 : ROSE_ASSERT(this != NULL);
139656 0 : visitor.visit(this);
139657 0 : }
139658 :
139659 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
139660 0 : void SgClinkageDeclarationStatement::accept (ROSE_VisitorPattern & visitor) {
139661 0 : ROSE_ASSERT(this != NULL);
139662 0 : visitor.visit(this);
139663 0 : }
139664 :
139665 : SgClinkageDeclarationStatement*
139666 0 : SgClinkageDeclarationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
139667 : {
139668 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
139669 : // This function is currently only supported for the AST used the represent Binary executables.
139670 : if (0 /* isSgAsmNode(this) != NULL */)
139671 : {
139672 : // Support for regex specification.
139673 : std::string prefixCode = "REGEX:";
139674 : addNewAttribute(prefixCode + s,a);
139675 : }
139676 : #endif
139677 :
139678 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
139679 0 : return this;
139680 : }
139681 :
139682 : // *** COMMON CODE SECTION ENDS HERE ***
139683 :
139684 :
139685 : // End of memberFunctionString
139686 : // Start of memberFunctionString
139687 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
139688 :
139689 :
139690 : #if 0
139691 : //! Error checking support
139692 : /*! Verifies the following:
139693 : - working getVariant() member function
139694 : - calls base class's error() member function
139695 : Every class has one of these functions.
139696 : */
139697 : bool
139698 : SgClinkageDeclarationStatement::error()
139699 : {
139700 : // Put error checking here
139701 :
139702 : ROSE_ASSERT (this != NULL);
139703 : if (getVariant() != C_LINKAGE_DECLARATION_STMT)
139704 : {
139705 : printf ("Error in SgClinkageDeclarationStatement::error(): SgClinkageDeclarationStatement object has a %s variant \n",
139706 : Cxx_GrammarTerminalNames[getVariant()].name);
139707 : // printf ("Error in SgClinkageDeclarationStatement::error() \n");
139708 : ROSE_ABORT();
139709 : }
139710 :
139711 : ROSE_ASSERT (getVariant() == C_LINKAGE_DECLARATION_STMT);
139712 : return SgDeclarationStatement::error();
139713 : }
139714 : #endif
139715 :
139716 :
139717 :
139718 : // End of memberFunctionString
139719 :
139720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
139721 :
139722 0 : SgClinkageDeclarationStatement* isSgClinkageDeclarationStatement ( SgNode* inputDerivedClassPointer )
139723 : {
139724 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
139725 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
139726 : // So to fix this we return NULL directly when the input is NULL and avoid the
139727 : // dynamic_cast in this case. This is likely a performance improvement as well.
139728 : // return dynamic_cast<SgClinkageDeclarationStatement*>(inputDerivedClassPointer);
139729 : // Milind Chabbi (8/28/2013): isSgClinkageDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
139730 : // this improves the running time performance by 10-20%.
139731 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClinkageDeclarationStatement*>(inputDerivedClassPointer);
139732 0 : return IS_SgClinkageDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
139733 : }
139734 :
139735 : // DQ (11/8/2003): Added version of functions taking const pointer
139736 0 : const SgClinkageDeclarationStatement* isSgClinkageDeclarationStatement ( const SgNode* inputDerivedClassPointer )
139737 : {
139738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
139739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
139740 : // So to fix this we return NULL directly when the input is NULL and avoid the
139741 : // dynamic_cast in this case. This is likely a performance improvement as well.
139742 : // return dynamic_cast<const SgClinkageDeclarationStatement*>(inputDerivedClassPointer);
139743 : // Milind Chabbi (8/28/2013): isSgClinkageDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
139744 : // this improves the running time performance by 10-20%.
139745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClinkageDeclarationStatement*>(inputDerivedClassPointer);
139746 0 : return IS_SgClinkageDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
139747 : }
139748 :
139749 :
139750 :
139751 : /* #line 139752 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139752 :
139753 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
139754 :
139755 : /**
139756 : \brief Generated destructor
139757 :
139758 : This destructor is automatically generated (by ROSETTA). This destructor
139759 : only frees memory of data members associated with the parts of the current IR node which
139760 : are NOT traversed. Those data members that are part of a traversal can be freed using
139761 : a traversal (calling this destructor on all children in a post-order traversal). Such
139762 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
139763 :
139764 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
139765 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
139766 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
139767 :
139768 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
139769 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
139770 : pointers are not yet implemented to call delete on eash pointer in the container.
139771 : (This could be done by derivation from the STL containers to define containers that
139772 : automatically deleted their members.)
139773 :
139774 : */
139775 0 : SgClinkageDeclarationStatement::~SgClinkageDeclarationStatement () {
139776 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
139777 :
139778 :
139779 : // case: not a listType for languageSpecifier
139780 0 : p_languageSpecifier = ""; // non list case
139781 :
139782 : }
139783 :
139784 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
139785 0 : }
139786 :
139787 :
139788 : /* #line 139789 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139789 :
139790 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
139791 :
139792 : // Generated constructor
139793 0 : SgClinkageDeclarationStatement::SgClinkageDeclarationStatement ( Sg_File_Info* startOfConstruct )
139794 0 : : SgDeclarationStatement(startOfConstruct)
139795 : {
139796 : #ifdef DEBUG
139797 : // printf ("In SgClinkageDeclarationStatement::SgClinkageDeclarationStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
139798 : #endif
139799 : #if 0
139800 : // debugging information!
139801 : printf ("In SgClinkageDeclarationStatement::SgClinkageDeclarationStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
139802 : #endif
139803 :
139804 0 : p_languageSpecifier = "";
139805 :
139806 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
139807 :
139808 : #if 0
139809 : // DQ (7/30/2014): Call a virtual function.
139810 : std::string s = this->class_name();
139811 : #endif
139812 :
139813 : // Test the variant virtual function
139814 : // assert(C_LINKAGE_DECLARATION_STMT == variant());
139815 0 : assert(C_LINKAGE_DECLARATION_STMT == this->variant());
139816 0 : ROSE_ASSERT(C_LINKAGE_DECLARATION_STMT == (int)(this->variantT()));
139817 0 : post_construction_initialization();
139818 :
139819 : // Test the isSgClinkageDeclarationStatement() function since it has been problematic
139820 0 : assert(isSgClinkageDeclarationStatement(this) != NULL);
139821 0 : }
139822 :
139823 : // Generated constructor (all data members)
139824 :
139825 : /* #line 139826 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139826 :
139827 :
139828 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
139829 :
139830 :
139831 : // ********************************************************
139832 : // member functions common across all array grammar objects
139833 : // ********************************************************
139834 :
139835 :
139836 :
139837 : /* #line 139838 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139838 :
139839 :
139840 :
139841 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
139842 :
139843 : // ********************************************************
139844 : // member functions specific to each node in the grammar
139845 : // ********************************************************
139846 :
139847 :
139848 : /* #line 139849 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
139849 :
139850 : // Start of memberFunctionString
139851 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
139852 :
139853 : void
139854 0 : SgClinkageStartStatement::post_construction_initialization()
139855 : {
139856 0 : }
139857 :
139858 :
139859 :
139860 : // End of memberFunctionString
139861 : // Start of memberFunctionString
139862 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
139863 :
139864 : // *** COMMON CODE SECTION BEGINS HERE ***
139865 :
139866 : #if 0
139867 : int
139868 : SgClinkageStartStatement::getVariant() const
139869 : {
139870 : // This function is used in ROSE while "variant()" is used in SAGE
139871 : assert(this != NULL);
139872 : return variant();
139873 : }
139874 : #endif
139875 :
139876 : // This function is used in ROSE in treeTraversal code
139877 : // eventually replaces getVariant() and variant()
139878 : // though after variant() has been removed for a while we will
139879 : // want to change the name of variantT() back to variant()
139880 : // (since the "T" was ment to stand for temporary).
139881 : // When this happens the variantT() will be depricated.
139882 : VariantT
139883 0 : SgClinkageStartStatement::variantT() const
139884 : {
139885 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
139886 0 : ROSE_ASSERT(this != NULL);
139887 0 : return V_SgClinkageStartStatement;
139888 : }
139889 :
139890 : #if 0
139891 : int
139892 : SgClinkageStartStatement::variant() const
139893 : {
139894 : // This function is used in SAGE
139895 : ROSE_ASSERT(this != NULL);
139896 : return C_LINKAGE_START_STMT;
139897 : }
139898 : #endif
139899 :
139900 : ROSE_DLL_API const char*
139901 0 : SgClinkageStartStatement::sage_class_name() const
139902 : {
139903 0 : ROSE_ASSERT(this != NULL);
139904 0 : return "SgClinkageStartStatement";
139905 : }
139906 :
139907 : std::string
139908 0 : SgClinkageStartStatement::class_name() const
139909 : {
139910 0 : ROSE_ASSERT(this != NULL);
139911 0 : return "SgClinkageStartStatement";
139912 : }
139913 :
139914 : // DQ (11/26/2005): Support for visitor pattern mechanims
139915 : // (inferior to ROSE traversal mechanism, experimental).
139916 : void
139917 0 : SgClinkageStartStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
139918 : {
139919 0 : ROSE_ASSERT(this != NULL);
139920 0 : visitor.visit(this);
139921 0 : }
139922 :
139923 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
139924 0 : void SgClinkageStartStatement::accept (ROSE_VisitorPattern & visitor) {
139925 0 : ROSE_ASSERT(this != NULL);
139926 0 : visitor.visit(this);
139927 0 : }
139928 :
139929 : SgClinkageStartStatement*
139930 0 : SgClinkageStartStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
139931 : {
139932 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
139933 : // This function is currently only supported for the AST used the represent Binary executables.
139934 : if (0 /* isSgAsmNode(this) != NULL */)
139935 : {
139936 : // Support for regex specification.
139937 : std::string prefixCode = "REGEX:";
139938 : addNewAttribute(prefixCode + s,a);
139939 : }
139940 : #endif
139941 :
139942 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
139943 0 : return this;
139944 : }
139945 :
139946 : // *** COMMON CODE SECTION ENDS HERE ***
139947 :
139948 :
139949 : // End of memberFunctionString
139950 : // Start of memberFunctionString
139951 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
139952 :
139953 :
139954 : #if 0
139955 : //! Error checking support
139956 : /*! Verifies the following:
139957 : - working getVariant() member function
139958 : - calls base class's error() member function
139959 : Every class has one of these functions.
139960 : */
139961 : bool
139962 : SgClinkageStartStatement::error()
139963 : {
139964 : // Put error checking here
139965 :
139966 : ROSE_ASSERT (this != NULL);
139967 : if (getVariant() != C_LINKAGE_START_STMT)
139968 : {
139969 : printf ("Error in SgClinkageStartStatement::error(): SgClinkageStartStatement object has a %s variant \n",
139970 : Cxx_GrammarTerminalNames[getVariant()].name);
139971 : // printf ("Error in SgClinkageStartStatement::error() \n");
139972 : ROSE_ABORT();
139973 : }
139974 :
139975 : ROSE_ASSERT (getVariant() == C_LINKAGE_START_STMT);
139976 : return SgClinkageDeclarationStatement::error();
139977 : }
139978 : #endif
139979 :
139980 :
139981 :
139982 : // End of memberFunctionString
139983 :
139984 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
139985 :
139986 0 : SgClinkageStartStatement* isSgClinkageStartStatement ( SgNode* inputDerivedClassPointer )
139987 : {
139988 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
139989 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
139990 : // So to fix this we return NULL directly when the input is NULL and avoid the
139991 : // dynamic_cast in this case. This is likely a performance improvement as well.
139992 : // return dynamic_cast<SgClinkageStartStatement*>(inputDerivedClassPointer);
139993 : // Milind Chabbi (8/28/2013): isSgClinkageStartStatement uses table-driven castability instead of c++ default dynamic_cast
139994 : // this improves the running time performance by 10-20%.
139995 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClinkageStartStatement*>(inputDerivedClassPointer);
139996 0 : return IS_SgClinkageStartStatement_FAST_MACRO(inputDerivedClassPointer);
139997 : }
139998 :
139999 : // DQ (11/8/2003): Added version of functions taking const pointer
140000 0 : const SgClinkageStartStatement* isSgClinkageStartStatement ( const SgNode* inputDerivedClassPointer )
140001 : {
140002 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
140003 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
140004 : // So to fix this we return NULL directly when the input is NULL and avoid the
140005 : // dynamic_cast in this case. This is likely a performance improvement as well.
140006 : // return dynamic_cast<const SgClinkageStartStatement*>(inputDerivedClassPointer);
140007 : // Milind Chabbi (8/28/2013): isSgClinkageStartStatement uses table-driven castability instead of c++ default dynamic_cast
140008 : // this improves the running time performance by 10-20%.
140009 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClinkageStartStatement*>(inputDerivedClassPointer);
140010 0 : return IS_SgClinkageStartStatement_FAST_MACRO(inputDerivedClassPointer);
140011 : }
140012 :
140013 :
140014 :
140015 : /* #line 140016 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140016 :
140017 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
140018 :
140019 : /**
140020 : \brief Generated destructor
140021 :
140022 : This destructor is automatically generated (by ROSETTA). This destructor
140023 : only frees memory of data members associated with the parts of the current IR node which
140024 : are NOT traversed. Those data members that are part of a traversal can be freed using
140025 : a traversal (calling this destructor on all children in a post-order traversal). Such
140026 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
140027 :
140028 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
140029 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
140030 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
140031 :
140032 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
140033 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
140034 : pointers are not yet implemented to call delete on eash pointer in the container.
140035 : (This could be done by derivation from the STL containers to define containers that
140036 : automatically deleted their members.)
140037 :
140038 : */
140039 0 : SgClinkageStartStatement::~SgClinkageStartStatement () {
140040 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
140041 :
140042 :
140043 :
140044 : }
140045 :
140046 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
140047 0 : }
140048 :
140049 :
140050 : /* #line 140051 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140051 :
140052 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
140053 :
140054 : // Generated constructor
140055 0 : SgClinkageStartStatement::SgClinkageStartStatement ( Sg_File_Info* startOfConstruct )
140056 0 : : SgClinkageDeclarationStatement(startOfConstruct)
140057 : {
140058 : #ifdef DEBUG
140059 : // printf ("In SgClinkageStartStatement::SgClinkageStartStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
140060 : #endif
140061 : #if 0
140062 : // debugging information!
140063 : printf ("In SgClinkageStartStatement::SgClinkageStartStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
140064 : #endif
140065 :
140066 :
140067 :
140068 : #if 0
140069 : // DQ (7/30/2014): Call a virtual function.
140070 : std::string s = this->class_name();
140071 : #endif
140072 :
140073 : // Test the variant virtual function
140074 : // assert(C_LINKAGE_START_STMT == variant());
140075 0 : assert(C_LINKAGE_START_STMT == this->variant());
140076 0 : ROSE_ASSERT(C_LINKAGE_START_STMT == (int)(this->variantT()));
140077 0 : post_construction_initialization();
140078 :
140079 : // Test the isSgClinkageStartStatement() function since it has been problematic
140080 0 : assert(isSgClinkageStartStatement(this) != NULL);
140081 0 : }
140082 :
140083 : // Generated constructor (all data members)
140084 :
140085 : /* #line 140086 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140086 :
140087 :
140088 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
140089 :
140090 :
140091 : // ********************************************************
140092 : // member functions common across all array grammar objects
140093 : // ********************************************************
140094 :
140095 :
140096 :
140097 : /* #line 140098 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140098 :
140099 :
140100 :
140101 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
140102 :
140103 : // ********************************************************
140104 : // member functions specific to each node in the grammar
140105 : // ********************************************************
140106 :
140107 :
140108 : /* #line 140109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140109 :
140110 : // Start of memberFunctionString
140111 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
140112 :
140113 : void
140114 0 : SgClinkageEndStatement::post_construction_initialization()
140115 : {
140116 0 : }
140117 :
140118 :
140119 :
140120 : // End of memberFunctionString
140121 : // Start of memberFunctionString
140122 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
140123 :
140124 : // *** COMMON CODE SECTION BEGINS HERE ***
140125 :
140126 : #if 0
140127 : int
140128 : SgClinkageEndStatement::getVariant() const
140129 : {
140130 : // This function is used in ROSE while "variant()" is used in SAGE
140131 : assert(this != NULL);
140132 : return variant();
140133 : }
140134 : #endif
140135 :
140136 : // This function is used in ROSE in treeTraversal code
140137 : // eventually replaces getVariant() and variant()
140138 : // though after variant() has been removed for a while we will
140139 : // want to change the name of variantT() back to variant()
140140 : // (since the "T" was ment to stand for temporary).
140141 : // When this happens the variantT() will be depricated.
140142 : VariantT
140143 0 : SgClinkageEndStatement::variantT() const
140144 : {
140145 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
140146 0 : ROSE_ASSERT(this != NULL);
140147 0 : return V_SgClinkageEndStatement;
140148 : }
140149 :
140150 : #if 0
140151 : int
140152 : SgClinkageEndStatement::variant() const
140153 : {
140154 : // This function is used in SAGE
140155 : ROSE_ASSERT(this != NULL);
140156 : return C_LINKAGE_END_STMT;
140157 : }
140158 : #endif
140159 :
140160 : ROSE_DLL_API const char*
140161 0 : SgClinkageEndStatement::sage_class_name() const
140162 : {
140163 0 : ROSE_ASSERT(this != NULL);
140164 0 : return "SgClinkageEndStatement";
140165 : }
140166 :
140167 : std::string
140168 0 : SgClinkageEndStatement::class_name() const
140169 : {
140170 0 : ROSE_ASSERT(this != NULL);
140171 0 : return "SgClinkageEndStatement";
140172 : }
140173 :
140174 : // DQ (11/26/2005): Support for visitor pattern mechanims
140175 : // (inferior to ROSE traversal mechanism, experimental).
140176 : void
140177 0 : SgClinkageEndStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
140178 : {
140179 0 : ROSE_ASSERT(this != NULL);
140180 0 : visitor.visit(this);
140181 0 : }
140182 :
140183 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
140184 0 : void SgClinkageEndStatement::accept (ROSE_VisitorPattern & visitor) {
140185 0 : ROSE_ASSERT(this != NULL);
140186 0 : visitor.visit(this);
140187 0 : }
140188 :
140189 : SgClinkageEndStatement*
140190 0 : SgClinkageEndStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
140191 : {
140192 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
140193 : // This function is currently only supported for the AST used the represent Binary executables.
140194 : if (0 /* isSgAsmNode(this) != NULL */)
140195 : {
140196 : // Support for regex specification.
140197 : std::string prefixCode = "REGEX:";
140198 : addNewAttribute(prefixCode + s,a);
140199 : }
140200 : #endif
140201 :
140202 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
140203 0 : return this;
140204 : }
140205 :
140206 : // *** COMMON CODE SECTION ENDS HERE ***
140207 :
140208 :
140209 : // End of memberFunctionString
140210 : // Start of memberFunctionString
140211 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
140212 :
140213 :
140214 : #if 0
140215 : //! Error checking support
140216 : /*! Verifies the following:
140217 : - working getVariant() member function
140218 : - calls base class's error() member function
140219 : Every class has one of these functions.
140220 : */
140221 : bool
140222 : SgClinkageEndStatement::error()
140223 : {
140224 : // Put error checking here
140225 :
140226 : ROSE_ASSERT (this != NULL);
140227 : if (getVariant() != C_LINKAGE_END_STMT)
140228 : {
140229 : printf ("Error in SgClinkageEndStatement::error(): SgClinkageEndStatement object has a %s variant \n",
140230 : Cxx_GrammarTerminalNames[getVariant()].name);
140231 : // printf ("Error in SgClinkageEndStatement::error() \n");
140232 : ROSE_ABORT();
140233 : }
140234 :
140235 : ROSE_ASSERT (getVariant() == C_LINKAGE_END_STMT);
140236 : return SgClinkageDeclarationStatement::error();
140237 : }
140238 : #endif
140239 :
140240 :
140241 :
140242 : // End of memberFunctionString
140243 :
140244 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
140245 :
140246 0 : SgClinkageEndStatement* isSgClinkageEndStatement ( SgNode* inputDerivedClassPointer )
140247 : {
140248 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
140249 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
140250 : // So to fix this we return NULL directly when the input is NULL and avoid the
140251 : // dynamic_cast in this case. This is likely a performance improvement as well.
140252 : // return dynamic_cast<SgClinkageEndStatement*>(inputDerivedClassPointer);
140253 : // Milind Chabbi (8/28/2013): isSgClinkageEndStatement uses table-driven castability instead of c++ default dynamic_cast
140254 : // this improves the running time performance by 10-20%.
140255 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClinkageEndStatement*>(inputDerivedClassPointer);
140256 0 : return IS_SgClinkageEndStatement_FAST_MACRO(inputDerivedClassPointer);
140257 : }
140258 :
140259 : // DQ (11/8/2003): Added version of functions taking const pointer
140260 0 : const SgClinkageEndStatement* isSgClinkageEndStatement ( const SgNode* inputDerivedClassPointer )
140261 : {
140262 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
140263 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
140264 : // So to fix this we return NULL directly when the input is NULL and avoid the
140265 : // dynamic_cast in this case. This is likely a performance improvement as well.
140266 : // return dynamic_cast<const SgClinkageEndStatement*>(inputDerivedClassPointer);
140267 : // Milind Chabbi (8/28/2013): isSgClinkageEndStatement uses table-driven castability instead of c++ default dynamic_cast
140268 : // this improves the running time performance by 10-20%.
140269 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClinkageEndStatement*>(inputDerivedClassPointer);
140270 0 : return IS_SgClinkageEndStatement_FAST_MACRO(inputDerivedClassPointer);
140271 : }
140272 :
140273 :
140274 :
140275 : /* #line 140276 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140276 :
140277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
140278 :
140279 : /**
140280 : \brief Generated destructor
140281 :
140282 : This destructor is automatically generated (by ROSETTA). This destructor
140283 : only frees memory of data members associated with the parts of the current IR node which
140284 : are NOT traversed. Those data members that are part of a traversal can be freed using
140285 : a traversal (calling this destructor on all children in a post-order traversal). Such
140286 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
140287 :
140288 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
140289 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
140290 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
140291 :
140292 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
140293 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
140294 : pointers are not yet implemented to call delete on eash pointer in the container.
140295 : (This could be done by derivation from the STL containers to define containers that
140296 : automatically deleted their members.)
140297 :
140298 : */
140299 0 : SgClinkageEndStatement::~SgClinkageEndStatement () {
140300 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
140301 :
140302 :
140303 :
140304 : }
140305 :
140306 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
140307 0 : }
140308 :
140309 :
140310 : /* #line 140311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140311 :
140312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
140313 :
140314 : // Generated constructor
140315 0 : SgClinkageEndStatement::SgClinkageEndStatement ( Sg_File_Info* startOfConstruct )
140316 0 : : SgClinkageDeclarationStatement(startOfConstruct)
140317 : {
140318 : #ifdef DEBUG
140319 : // printf ("In SgClinkageEndStatement::SgClinkageEndStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
140320 : #endif
140321 : #if 0
140322 : // debugging information!
140323 : printf ("In SgClinkageEndStatement::SgClinkageEndStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
140324 : #endif
140325 :
140326 :
140327 :
140328 : #if 0
140329 : // DQ (7/30/2014): Call a virtual function.
140330 : std::string s = this->class_name();
140331 : #endif
140332 :
140333 : // Test the variant virtual function
140334 : // assert(C_LINKAGE_END_STMT == variant());
140335 0 : assert(C_LINKAGE_END_STMT == this->variant());
140336 0 : ROSE_ASSERT(C_LINKAGE_END_STMT == (int)(this->variantT()));
140337 0 : post_construction_initialization();
140338 :
140339 : // Test the isSgClinkageEndStatement() function since it has been problematic
140340 0 : assert(isSgClinkageEndStatement(this) != NULL);
140341 0 : }
140342 :
140343 : // Generated constructor (all data members)
140344 :
140345 : /* #line 140346 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140346 :
140347 :
140348 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
140349 :
140350 :
140351 : // ********************************************************
140352 : // member functions common across all array grammar objects
140353 : // ********************************************************
140354 :
140355 :
140356 :
140357 : /* #line 140358 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140358 :
140359 :
140360 :
140361 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
140362 :
140363 : // ********************************************************
140364 : // member functions specific to each node in the grammar
140365 : // ********************************************************
140366 :
140367 :
140368 : /* #line 140369 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
140369 :
140370 : // Start of memberFunctionString
140371 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140372 :
140373 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140374 :
140375 : SgName
140376 20266 : SgEnumDeclaration::get_name () const
140377 : {
140378 20266 : ROSE_ASSERT (this != NULL);
140379 :
140380 : #if 0
140381 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140382 : // used to trigger marking transformations for the token-based unparsing.
140383 : printf ("SgEnumDeclaration::get_name = %p = %s \n",this,this->class_name().c_str());
140384 : #endif
140385 :
140386 20266 : return p_name;
140387 : }
140388 :
140389 : void
140390 0 : SgEnumDeclaration::set_name ( SgName name )
140391 : {
140392 0 : ROSE_ASSERT (this != NULL);
140393 :
140394 : #if 0
140395 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140396 : // used to trigger marking transformations for the token-based unparsing.
140397 : printf ("SgEnumDeclaration::set_name = %p = %s \n",this,this->class_name().c_str());
140398 : #endif
140399 :
140400 0 : set_isModified(true);
140401 :
140402 0 : p_name = name;
140403 0 : }
140404 :
140405 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140406 :
140407 :
140408 : // End of memberFunctionString
140409 : // Start of memberFunctionString
140410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140411 :
140412 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140413 :
140414 : bool
140415 294 : SgEnumDeclaration::get_embedded () const
140416 : {
140417 294 : ROSE_ASSERT (this != NULL);
140418 :
140419 : #if 0
140420 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140421 : // used to trigger marking transformations for the token-based unparsing.
140422 : printf ("SgEnumDeclaration::get_embedded = %p = %s \n",this,this->class_name().c_str());
140423 : #endif
140424 :
140425 294 : return p_embedded;
140426 : }
140427 :
140428 : void
140429 294 : SgEnumDeclaration::set_embedded ( bool embedded )
140430 : {
140431 294 : ROSE_ASSERT (this != NULL);
140432 :
140433 : #if 0
140434 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140435 : // used to trigger marking transformations for the token-based unparsing.
140436 : printf ("SgEnumDeclaration::set_embedded = %p = %s \n",this,this->class_name().c_str());
140437 : #endif
140438 :
140439 294 : set_isModified(true);
140440 :
140441 294 : p_embedded = embedded;
140442 294 : }
140443 :
140444 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140445 :
140446 :
140447 : // End of memberFunctionString
140448 : // Start of memberFunctionString
140449 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140450 :
140451 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140452 :
140453 : SgEnumType*
140454 46582 : SgEnumDeclaration::get_type () const
140455 : {
140456 46582 : ROSE_ASSERT (this != NULL);
140457 :
140458 : #if 0
140459 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140460 : // used to trigger marking transformations for the token-based unparsing.
140461 : printf ("SgEnumDeclaration::get_type = %p = %s \n",this,this->class_name().c_str());
140462 : #endif
140463 :
140464 46582 : return p_type;
140465 : }
140466 :
140467 : void
140468 2932 : SgEnumDeclaration::set_type ( SgEnumType* type )
140469 : {
140470 2932 : ROSE_ASSERT (this != NULL);
140471 :
140472 : #if 0
140473 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140474 : // used to trigger marking transformations for the token-based unparsing.
140475 : printf ("SgEnumDeclaration::set_type = %p = %s \n",this,this->class_name().c_str());
140476 : #endif
140477 :
140478 2932 : set_isModified(true);
140479 :
140480 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
140481 : if (p_type != NULL && type != NULL && p_type != type)
140482 : {
140483 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
140484 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
140485 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
140486 : ROSE_ASSERT(false);
140487 : #endif
140488 : }
140489 : #endif
140490 2932 : p_type = type;
140491 2932 : }
140492 :
140493 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140494 :
140495 :
140496 : // End of memberFunctionString
140497 : // Start of memberFunctionString
140498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140499 :
140500 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140501 :
140502 : SgType*
140503 0 : SgEnumDeclaration::get_adaParentType () const
140504 : {
140505 0 : ROSE_ASSERT (this != NULL);
140506 :
140507 : #if 0
140508 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140509 : // used to trigger marking transformations for the token-based unparsing.
140510 : printf ("SgEnumDeclaration::get_adaParentType = %p = %s \n",this,this->class_name().c_str());
140511 : #endif
140512 :
140513 0 : return p_adaParentType;
140514 : }
140515 :
140516 : void
140517 0 : SgEnumDeclaration::set_adaParentType ( SgType* adaParentType )
140518 : {
140519 0 : ROSE_ASSERT (this != NULL);
140520 :
140521 : #if 0
140522 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140523 : // used to trigger marking transformations for the token-based unparsing.
140524 : printf ("SgEnumDeclaration::set_adaParentType = %p = %s \n",this,this->class_name().c_str());
140525 : #endif
140526 :
140527 0 : set_isModified(true);
140528 :
140529 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
140530 : if (p_adaParentType != NULL && adaParentType != NULL && p_adaParentType != adaParentType)
140531 : {
140532 : printf ("Warning: adaParentType = %p overwriting valid pointer p_adaParentType = %p \n",adaParentType,p_adaParentType);
140533 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
140534 : printf ("Error fails assertion (p_adaParentType != NULL && adaParentType != NULL && p_adaParentType != adaParentType) is false\n");
140535 : ROSE_ASSERT(false);
140536 : #endif
140537 : }
140538 : #endif
140539 0 : p_adaParentType = adaParentType;
140540 0 : }
140541 :
140542 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140543 :
140544 :
140545 : // End of memberFunctionString
140546 : // Start of memberFunctionString
140547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
140548 :
140549 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140550 :
140551 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
140552 : const SgInitializedNamePtrList &
140553 0 : SgEnumDeclaration::get_enumerators () const
140554 : {
140555 0 : assert (this != NULL);
140556 0 : return p_enumerators;
140557 : }
140558 :
140559 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
140560 : SgInitializedNamePtrList &
140561 8539 : SgEnumDeclaration::get_enumerators ()
140562 : {
140563 8539 : assert (this != NULL);
140564 :
140565 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
140566 : // As a rule only set_ access functions can set the isModified flag.
140567 : // set_isModified(true);
140568 :
140569 8539 : return p_enumerators;
140570 : }
140571 :
140572 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140573 :
140574 :
140575 : // End of memberFunctionString
140576 : // Start of memberFunctionString
140577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140578 :
140579 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140580 :
140581 : SgScopeStatement*
140582 118252 : SgEnumDeclaration::get_scope () const
140583 : {
140584 118252 : ROSE_ASSERT (this != NULL);
140585 :
140586 : #if 0
140587 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140588 : // used to trigger marking transformations for the token-based unparsing.
140589 : printf ("SgEnumDeclaration::get_scope = %p = %s \n",this,this->class_name().c_str());
140590 : #endif
140591 :
140592 118252 : return p_scope;
140593 : }
140594 :
140595 : void
140596 4470 : SgEnumDeclaration::set_scope ( SgScopeStatement* scope )
140597 : {
140598 4470 : ROSE_ASSERT (this != NULL);
140599 :
140600 : #if 0
140601 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140602 : // used to trigger marking transformations for the token-based unparsing.
140603 : printf ("SgEnumDeclaration::set_scope = %p = %s \n",this,this->class_name().c_str());
140604 : #endif
140605 :
140606 4470 : set_isModified(true);
140607 :
140608 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
140609 : if (p_scope != NULL && scope != NULL && p_scope != scope)
140610 : {
140611 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
140612 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
140613 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
140614 : ROSE_ASSERT(false);
140615 : #endif
140616 : }
140617 : #endif
140618 4470 : p_scope = scope;
140619 4470 : }
140620 :
140621 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140622 :
140623 :
140624 : // End of memberFunctionString
140625 : // Start of memberFunctionString
140626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140627 :
140628 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140629 :
140630 : bool
140631 14227 : SgEnumDeclaration::get_isUnNamed () const
140632 : {
140633 14227 : ROSE_ASSERT (this != NULL);
140634 :
140635 : #if 0
140636 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140637 : // used to trigger marking transformations for the token-based unparsing.
140638 : printf ("SgEnumDeclaration::get_isUnNamed = %p = %s \n",this,this->class_name().c_str());
140639 : #endif
140640 :
140641 14227 : return p_isUnNamed;
140642 : }
140643 :
140644 : void
140645 2931 : SgEnumDeclaration::set_isUnNamed ( bool isUnNamed )
140646 : {
140647 2931 : ROSE_ASSERT (this != NULL);
140648 :
140649 : #if 0
140650 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140651 : // used to trigger marking transformations for the token-based unparsing.
140652 : printf ("SgEnumDeclaration::set_isUnNamed = %p = %s \n",this,this->class_name().c_str());
140653 : #endif
140654 :
140655 2931 : set_isModified(true);
140656 :
140657 2931 : p_isUnNamed = isUnNamed;
140658 2931 : }
140659 :
140660 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140661 :
140662 :
140663 : // End of memberFunctionString
140664 : // Start of memberFunctionString
140665 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140666 :
140667 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140668 :
140669 : bool
140670 1947 : SgEnumDeclaration::get_isAutonomousDeclaration () const
140671 : {
140672 1947 : ROSE_ASSERT (this != NULL);
140673 :
140674 : #if 0
140675 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140676 : // used to trigger marking transformations for the token-based unparsing.
140677 : printf ("SgEnumDeclaration::get_isAutonomousDeclaration = %p = %s \n",this,this->class_name().c_str());
140678 : #endif
140679 :
140680 1947 : return p_isAutonomousDeclaration;
140681 : }
140682 :
140683 : void
140684 1490 : SgEnumDeclaration::set_isAutonomousDeclaration ( bool isAutonomousDeclaration )
140685 : {
140686 1490 : ROSE_ASSERT (this != NULL);
140687 :
140688 : #if 0
140689 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140690 : // used to trigger marking transformations for the token-based unparsing.
140691 : printf ("SgEnumDeclaration::set_isAutonomousDeclaration = %p = %s \n",this,this->class_name().c_str());
140692 : #endif
140693 :
140694 1490 : set_isModified(true);
140695 :
140696 1490 : p_isAutonomousDeclaration = isAutonomousDeclaration;
140697 1490 : }
140698 :
140699 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140700 :
140701 :
140702 : // End of memberFunctionString
140703 : // Start of memberFunctionString
140704 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140705 :
140706 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140707 :
140708 : SgType*
140709 2010 : SgEnumDeclaration::get_field_type () const
140710 : {
140711 2010 : ROSE_ASSERT (this != NULL);
140712 :
140713 : #if 0
140714 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140715 : // used to trigger marking transformations for the token-based unparsing.
140716 : printf ("SgEnumDeclaration::get_field_type = %p = %s \n",this,this->class_name().c_str());
140717 : #endif
140718 :
140719 2010 : return p_field_type;
140720 : }
140721 :
140722 : void
140723 0 : SgEnumDeclaration::set_field_type ( SgType* field_type )
140724 : {
140725 0 : ROSE_ASSERT (this != NULL);
140726 :
140727 : #if 0
140728 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140729 : // used to trigger marking transformations for the token-based unparsing.
140730 : printf ("SgEnumDeclaration::set_field_type = %p = %s \n",this,this->class_name().c_str());
140731 : #endif
140732 :
140733 0 : set_isModified(true);
140734 :
140735 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
140736 : if (p_field_type != NULL && field_type != NULL && p_field_type != field_type)
140737 : {
140738 : printf ("Warning: field_type = %p overwriting valid pointer p_field_type = %p \n",field_type,p_field_type);
140739 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
140740 : printf ("Error fails assertion (p_field_type != NULL && field_type != NULL && p_field_type != field_type) is false\n");
140741 : ROSE_ASSERT(false);
140742 : #endif
140743 : }
140744 : #endif
140745 0 : p_field_type = field_type;
140746 0 : }
140747 :
140748 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140749 :
140750 :
140751 : // End of memberFunctionString
140752 : // Start of memberFunctionString
140753 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
140754 :
140755 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
140756 :
140757 : bool
140758 2440 : SgEnumDeclaration::get_isScopedEnum () const
140759 : {
140760 2440 : ROSE_ASSERT (this != NULL);
140761 :
140762 : #if 0
140763 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140764 : // used to trigger marking transformations for the token-based unparsing.
140765 : printf ("SgEnumDeclaration::get_isScopedEnum = %p = %s \n",this,this->class_name().c_str());
140766 : #endif
140767 :
140768 2440 : return p_isScopedEnum;
140769 : }
140770 :
140771 : void
140772 32 : SgEnumDeclaration::set_isScopedEnum ( bool isScopedEnum )
140773 : {
140774 32 : ROSE_ASSERT (this != NULL);
140775 :
140776 : #if 0
140777 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
140778 : // used to trigger marking transformations for the token-based unparsing.
140779 : printf ("SgEnumDeclaration::set_isScopedEnum = %p = %s \n",this,this->class_name().c_str());
140780 : #endif
140781 :
140782 32 : set_isModified(true);
140783 :
140784 32 : p_isScopedEnum = isScopedEnum;
140785 32 : }
140786 :
140787 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
140788 :
140789 :
140790 : // End of memberFunctionString
140791 : // Start of memberFunctionString
140792 :
140793 :
140794 : // End of memberFunctionString
140795 : // Start of memberFunctionString
140796 : /* #line 14875 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
140797 :
140798 :
140799 : void
140800 2980 : SgEnumDeclaration::post_construction_initialization()
140801 : {
140802 : // DQ (9/27/2004): This should be conditional upon if the SgType was provided
140803 : // in the constructor argument list (as in SgClassDeclaration).
140804 : // set_type(SgEnumType::createType(this));
140805 2980 : if (get_type() == NULL)
140806 : {
140807 : #if 0
140808 : #if PRINT_DEVELOPER_WARNINGS
140809 : printf ("In SgEnumDeclaration::post_construction_initialization(): setting the SgEnumType type internally (using the declaration) \n");
140810 : #endif
140811 : #endif
140812 : // DQ (2/27/2018): It is an inconsistancy that this class's semantics sets the type here (not done for other declaration IR nodes).
140813 : // Note: that this is now the only IR node that constrcuts its type within its constructor (or post_construction_initialization() function).
140814 2932 : set_type(SgEnumType::createType(this));
140815 : }
140816 :
140817 : #if 0
140818 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
140819 : printf ("In SgEnumDeclaration::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
140820 : #endif
140821 2980 : }
140822 :
140823 : void
140824 : // SgEnumDeclaration::append_enumerator(const SgInitializedName & what)
140825 0 : SgEnumDeclaration::append_enumerator( SgInitializedName* what)
140826 : {
140827 0 : get_enumerators().push_back(what);
140828 0 : what->set_parent(this);
140829 0 : }
140830 :
140831 : void
140832 : // SgEnumDeclaration::prepend_enumerator(const SgInitializedName & what)
140833 0 : SgEnumDeclaration::prepend_enumerator( SgInitializedName* what)
140834 : {
140835 0 : get_enumerators().insert(get_enumerators().begin(), what);
140836 0 : what->set_parent(this);
140837 0 : }
140838 :
140839 : #if 0
140840 : SgInitializedNamePtrList::iterator
140841 : // SgEnumDeclaration::insert_enumerator(const SgInitializedNamePtrList::iterator& where, const SgInitializedName & what)
140842 : SgEnumDeclaration::insert_enumerator(const SgInitializedNamePtrList::iterator& where, SgInitializedName* what)
140843 : {
140844 : // DQ (9/27/2004): This function appears to have a side-effect on its input, not clear if this is appropriate.
140845 : SgInitializedNamePtrList::iterator new_item = get_enumerators().insert(where,what);
140846 : (*new_item)->set_parent(this);
140847 : return new_item;
140848 : }
140849 : #endif
140850 :
140851 : SgName
140852 0 : SgEnumDeclaration::get_qualified_name() const
140853 : {
140854 : // DQ (10/15/2004): This function is similar to the one for SgClassDeclaration.
140855 : // This function calls get_scope() which uses the parent pointers, thus
140856 : // it should not be called before the parent pointers are set (within the AST fixup after
140857 : // the Sage III AST is fully constructed).
140858 :
140859 : // printf ("In SgEnumDeclaration::get_qualified_name() name = %s \n",get_name().str());
140860 :
140861 0 : SgName returnName;
140862 :
140863 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
140864 0 : SgScopeStatement* scope = get_scope();
140865 0 : ROSE_ASSERT(scope != NULL);
140866 :
140867 0 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
140868 :
140869 : // printf ("In SgEnumDeclaration::get_qualified_name() returnName = %s \n",returnName.str());
140870 :
140871 0 : return returnName;
140872 : }
140873 :
140874 : // RV (2/1/2006): Added mangler for enum declarations.
140875 : SgName
140876 10976 : SgEnumDeclaration::get_mangled_name (void) const
140877 : {
140878 : #if 0
140879 : SgName mangled_name;
140880 : SgName name = get_name();
140881 :
140882 : #if 1
140883 : // DQ (6/1/2006): Added special handling for case where the class name is empty as in an
140884 : // printf ("In SgEnumDeclaration::get_mangled_name(void): get_scope() = %p = %s \n",get_scope(),get_scope()->class_name().c_str());
140885 :
140886 : // If this was originally a un-named enum then the astPostProcessing/fixupNames.C updated the name to reflect
140887 : // a compiler generated tag name that could be references (and would be required) when multiple variables
140888 : // might be used and the normalization of the AST (EDG) is done to reflect the separation into indivual
140889 : // variable declarations. This was a bug fix in response to a bug report from IBM (Fall 2006).
140890 : // However the compiler generated names are inappropriate for the AST merge since they are not unique
140891 : // (by design) and so they don't share properly. So we now detect the ROSE compiler generated name
140892 : // and proceed as though the enum had never need assigneda tag and generate a unique name that will
140893 : // match appropriately to allow sharing (when ODR is not violated). Basicaly we use the compiler generated
140894 : // name to trigger this mechanism which used to be triggered when no name was available (specifically when
140895 : // case: name.is_null() == true).
140896 : bool specialCaseNameHandling = (name.getString().find("__rose_generated_enum_tag_name_") != std::string::npos);
140897 :
140898 : // DQ (3/10/2007): If the enum is un-named in a typedef (as the base type) then it should not be given another name by ROSE.
140899 : // This is because the declaration can only be referred to once (handling multiple references is why we sometimes have to
140900 : // provide a generated name (e.g. a variable declaration which has multiple variables).
140901 : // Now that we reset empty name this should be true (unless fixup had not been called)
140902 : // ROSE_ASSERT (name.is_null() == false);
140903 :
140904 : // DQ (8/20/2006): This will be a valid name for all C++ programs, but not for C programs (see Cxx_tests/math.C).
140905 : // if (name.is_null() == true)
140906 :
140907 : // DQ (2/22/2007): I think that we don't use this sort of name internally any more!
140908 : // We generate more comlex names approporate to support the AST merge mechanism.
140909 : ROSE_ASSERT(specialCaseNameHandling == false);
140910 :
140911 : if (specialCaseNameHandling == true)
140912 : {
140913 : // DQ (8/20/2006): Using the parent can cause endless recursion for the code "typedef enum { enum_field } enum_typedef_type;"
140914 : // so we have to assemble a unique name without resorting to the parent.
140915 : // name = SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration(parent);
140916 : // It the enum is unnamed then use the name of the first enum field (since it can't be redefied in the same scope, it is unique)
140917 : // printf ("Using the parent of the enum to generate a name: parent = %p = %s \n",parent,parent->class_name().c_str());
140918 : // This should be true for C but maybe not for C++!
140919 : // name = SgDeclarationStatement::generate_alternative_name_for_unnamed_declaration(parent);
140920 : const SgInitializedNamePtrList & fieldList = p_enumerators;
140921 : // printf ("In SgEnumDeclaration::get_mangled_name(): fieldList.size() = %ld \n",fieldList.size());
140922 : // ROSE_ASSERT(fieldList.empty() == false);
140923 : if (fieldList.empty() == true)
140924 : {
140925 : printf ("WARNING in SgEnumDeclaration::get_mangled_name(): fieldList.empty() == true \n");
140926 : }
140927 : SgInitializedNamePtrList::const_iterator i = fieldList.begin();
140928 : name = "__unnamed_enum__";
140929 : while(i != fieldList.end())
140930 : {
140931 : name += (*i)->get_name();
140932 : i++;
140933 : if (i != fieldList.end())
140934 : {
140935 : name += "__COMMA__";
140936 : }
140937 : }
140938 : }
140939 :
140940 : // DQ (3/10/2007): Modified to let this pass. mangled names for enums would not be
140941 : // used in so critial a situation as class declarations which are more complex.
140942 : // ROSE_ASSERT(name.is_null() == false);
140943 : mangled_name = joinMangledQualifiers (mangleQualifiers(get_scope()),name);
140944 : #else
140945 : if (name.get_length () == 0) // Is an anonymous enum in C
140946 : mangled_name = SgName ("i"); // Treat like an integer
140947 : else // Return a fully qualified mangled type name
140948 : mangled_name = joinMangledQualifiers (mangleQualifiers(get_scope()),name);
140949 : #endif
140950 :
140951 : return mangled_name;
140952 : #else
140953 : #if 0
140954 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
140955 : SgEnumDeclaration* declaration = const_cast<SgEnumDeclaration*>(this);
140956 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
140957 : if (i != p_globalMangledNameMap.end())
140958 : {
140959 : return i->second.c_str();
140960 : }
140961 : #endif
140962 21952 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgEnumDeclaration*>(this));
140963 10976 : if (mangledNameString.empty() == false)
140964 : {
140965 : #if 0
140966 : printf ("In SgEnumDeclaration::get_mangled_name(void): name from getMangledNameFromCache: mangledNameString = %s \n",mangledNameString.c_str());
140967 : #endif
140968 : // return i->second.c_str();
140969 5240 : return mangledNameString;
140970 : }
140971 : else
140972 : {
140973 : // DQ (5/11/2007): If this is an enum type in a function definition then the mangled name for the type will
140974 : // atempt to include the mangled name of the function definition (the scope of the function parameter) which
140975 : // will cause infinit recursion in the evaluation of the mangled name of the function declaration which must
140976 : // include the function parameter, and so on. However, this only appears to be a problem for C and not C++.
140977 : #if 0
140978 : printf ("In SgEnumDeclaration::get_mangled_name(void): get_scope() = %p = %s \n",get_scope(),get_scope()->class_name().c_str());
140979 :
140980 : static int counter = 0;
140981 : counter++;
140982 : ROSE_ASSERT(counter < 10);
140983 : #endif
140984 :
140985 11472 : string mangleQualifiersString;
140986 5736 : if (isSgFunctionDefinition(get_scope()) != NULL)
140987 : {
140988 : // printf ("This is a parameter to a function and will cause infinite recursion in its evaluation \n");
140989 0 : mangleQualifiersString = "_function_parameter_";
140990 : }
140991 : else
140992 : {
140993 : // DQ (3/14/2012): We want to have a valid scope so that we can build a properly
140994 : // mangled name but the scope is not yet available unless we modify the constructor
140995 : // (which would break some code). So allow this to be built for now and we will
140996 : // see if it is an issue. Make it a warning to not have a valid scope. Note
140997 : // that this is only an issue for C++. We also might not want to add the name
140998 : // to the cache if the scope was NULL.
140999 : // mangleQualifiersString = mangleQualifiers(get_scope());
141000 5736 : if (get_scope() == NULL)
141001 : {
141002 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
141003 : printf ("WARNING: SgEnumDeclaration::get_mangled_name(): get_scope() == NULL, mangleQualifiers will be incomplete (empty) \n");
141004 : #endif
141005 : }
141006 : else
141007 : {
141008 : // DQ (1/12/13): Assert that this is not a previously deleted IR node (which will have the name = "SgNode").
141009 5608 : ROSE_ASSERT(get_scope()->class_name() != "SgNode");
141010 :
141011 : // DQ (1/12/13): Added assertion (only makes sense for non SgGlobal scopes).
141012 2804 : if (isSgGlobal(get_scope()) == NULL)
141013 : {
141014 1240 : ROSE_ASSERT(get_scope()->get_scope() != NULL);
141015 : }
141016 :
141017 2804 : mangleQualifiersString = mangleQualifiers(get_scope());
141018 : }
141019 : }
141020 :
141021 : // DQ (9/6/2016): We require a prefix to the name to avoid name collisions (see test2005_199.C and simplified test (but non-failing) in test2016_60.C).
141022 : // SgName mangledName = joinMangledQualifiers (mangleQualifiers(get_scope()),get_name());
141023 : // SgName mangledName = joinMangledQualifiers (mangleQualifiersString,get_name());
141024 17208 : SgName prefixed_name = "enum_" + get_name();
141025 11472 : SgName mangledName = joinMangledQualifiers(mangleQualifiersString,prefixed_name);
141026 : #if 0
141027 : printf ("In SgEnumDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
141028 : #endif
141029 : // DQ (4/23/2013): If the scope is not available, then don't put this into the MangleNameToCache.
141030 : // It can be added later when the scope is available and at a point where the name will be more meanningful.
141031 : // p_globalMangledNameMap[declaration] = mangledName;
141032 : // mangledName = SageInterface::addMangledNameToCache(const_cast<SgEnumDeclaration*>(this),mangledName);
141033 5736 : if (get_scope() != NULL)
141034 : {
141035 : #if 0
141036 : printf ("In SgEnumDeclaration::get_mangled_name(void): PUT name into MangleNameToCache: mangledName = %s \n",mangledName.str());
141037 : #endif
141038 7380 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgEnumDeclaration*>(this),mangledName);
141039 : }
141040 : else
141041 : {
141042 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
141043 : printf ("In SgEnumDeclaration::get_mangled_name(void): SKIP putting name into MangleNameToCache: mangledName = %s \n",mangledName.str());
141044 : #endif
141045 : }
141046 : #if 0
141047 : printf ("In SgEnumDeclaration::get_mangled_name(void): generated name: mangledName = %s \n",mangledName.str());
141048 : #endif
141049 5736 : return mangledName;
141050 : }
141051 : #endif
141052 : }
141053 :
141054 : bool
141055 866 : SgEnumDeclaration::hasExplicitScope() const
141056 : {
141057 : // This function reports that this IR node stores its scope explicitly.
141058 :
141059 866 : return true;
141060 : }
141061 :
141062 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
141063 : SgSymbol*
141064 1434 : SgEnumDeclaration::get_symbol_from_symbol_table() const
141065 : {
141066 1434 : ROSE_ASSERT(get_scope() != NULL);
141067 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
141068 : #if 0
141069 : // DQ (5/30/2007): We might want to look for either the symbol for the defining or the non-defining declaration.
141070 : // SgSymbol* returnSymbol = get_scope()->get_symbol_table()->find(this);
141071 : SgSymbol* returnSymbol = NULL;
141072 : if (returnSymbol == NULL)
141073 : {
141074 : // The symbol appears to be typically associated with the defining declaration (perhaps because forward enums are non-standard).
141075 : // Though it might be that we should treat enums uniformly with other declarations now that we have recently added forward
141076 : // enum declarations as a supported non-standard feature (because most frontends do (except for GNU curiously enough)).
141077 : if (this->get_definingDeclaration() != NULL)
141078 : {
141079 : returnSymbol = get_scope()->get_symbol_table()->find(this->get_definingDeclaration());
141080 : }
141081 : else
141082 : {
141083 : if (this->get_firstNondefiningDeclaration() != NULL)
141084 : {
141085 : returnSymbol = get_scope()->get_symbol_table()->find(this->get_firstNondefiningDeclaration());
141086 : }
141087 : else
141088 : {
141089 : // This is an error!
141090 : ROSE_ASSERT(false);
141091 : }
141092 : }
141093 : }
141094 :
141095 : return returnSymbol;
141096 : #else
141097 : // DQ (5/31/2007): This is the version that we want, it is consistent with the implementation elsewhere
141098 : // and the correct fix was to handle the case where this is NULL (in src/frontend/SageIII/astMerge/collectAssocitateNodes.C).
141099 : // return get_scope()->get_symbol_table()->find(this);
141100 1434 : return get_scope()->find_symbol_from_declaration(this);
141101 : #endif
141102 : }
141103 :
141104 :
141105 : // DQ (2/14/2019): Added C++11 support for enum prototypes, which mens that name
141106 : // qualification can be required for the defining declarations.
141107 : int
141108 294 : SgEnumDeclaration::get_name_qualification_length () const
141109 : {
141110 294 : ROSE_ASSERT (this != NULL);
141111 294 : return p_name_qualification_length;
141112 : }
141113 :
141114 : void
141115 852 : SgEnumDeclaration::set_name_qualification_length ( int name_qualification_length )
141116 : {
141117 852 : ROSE_ASSERT (this != NULL);
141118 : // This can't be called by the name qualification API (see test2015_26.C).
141119 : // set_isModified(true);
141120 :
141121 852 : p_name_qualification_length = name_qualification_length;
141122 852 : }
141123 :
141124 : bool
141125 0 : SgEnumDeclaration::get_type_elaboration_required () const
141126 : {
141127 0 : ROSE_ASSERT (this != NULL);
141128 0 : return p_type_elaboration_required;
141129 : }
141130 :
141131 : void
141132 852 : SgEnumDeclaration::set_type_elaboration_required ( bool type_elaboration_required )
141133 : {
141134 852 : ROSE_ASSERT (this != NULL);
141135 : // This can't be called by the name qualification API (see test2015_26.C).
141136 : // set_isModified(true);
141137 :
141138 852 : p_type_elaboration_required = type_elaboration_required;
141139 852 : }
141140 :
141141 : bool
141142 294 : SgEnumDeclaration::get_global_qualification_required () const
141143 : {
141144 294 : ROSE_ASSERT (this != NULL);
141145 294 : return p_global_qualification_required;
141146 : }
141147 :
141148 : void
141149 852 : SgEnumDeclaration::set_global_qualification_required ( bool global_qualification_required )
141150 : {
141151 852 : ROSE_ASSERT (this != NULL);
141152 :
141153 : // This can't be called by the name qualification API (see test2015_26.C).
141154 : // set_isModified(true);
141155 :
141156 852 : p_global_qualification_required = global_qualification_required;
141157 852 : }
141158 :
141159 :
141160 :
141161 :
141162 :
141163 : // End of memberFunctionString
141164 : // Start of memberFunctionString
141165 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
141166 :
141167 : // *** COMMON CODE SECTION BEGINS HERE ***
141168 :
141169 : #if 0
141170 : int
141171 : SgEnumDeclaration::getVariant() const
141172 : {
141173 : // This function is used in ROSE while "variant()" is used in SAGE
141174 : assert(this != NULL);
141175 : return variant();
141176 : }
141177 : #endif
141178 :
141179 : // This function is used in ROSE in treeTraversal code
141180 : // eventually replaces getVariant() and variant()
141181 : // though after variant() has been removed for a while we will
141182 : // want to change the name of variantT() back to variant()
141183 : // (since the "T" was ment to stand for temporary).
141184 : // When this happens the variantT() will be depricated.
141185 : VariantT
141186 1026480 : SgEnumDeclaration::variantT() const
141187 : {
141188 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
141189 1026480 : ROSE_ASSERT(this != NULL);
141190 1026480 : return V_SgEnumDeclaration;
141191 : }
141192 :
141193 : #if 0
141194 : int
141195 : SgEnumDeclaration::variant() const
141196 : {
141197 : // This function is used in SAGE
141198 : ROSE_ASSERT(this != NULL);
141199 : return ENUM_DECL_STMT;
141200 : }
141201 : #endif
141202 :
141203 : ROSE_DLL_API const char*
141204 12 : SgEnumDeclaration::sage_class_name() const
141205 : {
141206 12 : ROSE_ASSERT(this != NULL);
141207 12 : return "SgEnumDeclaration";
141208 : }
141209 :
141210 : std::string
141211 4073 : SgEnumDeclaration::class_name() const
141212 : {
141213 4073 : ROSE_ASSERT(this != NULL);
141214 4073 : return "SgEnumDeclaration";
141215 : }
141216 :
141217 : // DQ (11/26/2005): Support for visitor pattern mechanims
141218 : // (inferior to ROSE traversal mechanism, experimental).
141219 : void
141220 24284 : SgEnumDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
141221 : {
141222 24284 : ROSE_ASSERT(this != NULL);
141223 24284 : visitor.visit(this);
141224 24284 : }
141225 :
141226 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
141227 0 : void SgEnumDeclaration::accept (ROSE_VisitorPattern & visitor) {
141228 0 : ROSE_ASSERT(this != NULL);
141229 0 : visitor.visit(this);
141230 0 : }
141231 :
141232 : SgEnumDeclaration*
141233 0 : SgEnumDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
141234 : {
141235 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
141236 : // This function is currently only supported for the AST used the represent Binary executables.
141237 : if (0 /* isSgAsmNode(this) != NULL */)
141238 : {
141239 : // Support for regex specification.
141240 : std::string prefixCode = "REGEX:";
141241 : addNewAttribute(prefixCode + s,a);
141242 : }
141243 : #endif
141244 :
141245 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
141246 0 : return this;
141247 : }
141248 :
141249 : // *** COMMON CODE SECTION ENDS HERE ***
141250 :
141251 :
141252 : // End of memberFunctionString
141253 : // Start of memberFunctionString
141254 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
141255 :
141256 :
141257 : #if 0
141258 : //! Error checking support
141259 : /*! Verifies the following:
141260 : - working getVariant() member function
141261 : - calls base class's error() member function
141262 : Every class has one of these functions.
141263 : */
141264 : bool
141265 : SgEnumDeclaration::error()
141266 : {
141267 : // Put error checking here
141268 :
141269 : ROSE_ASSERT (this != NULL);
141270 : if (getVariant() != ENUM_DECL_STMT)
141271 : {
141272 : printf ("Error in SgEnumDeclaration::error(): SgEnumDeclaration object has a %s variant \n",
141273 : Cxx_GrammarTerminalNames[getVariant()].name);
141274 : // printf ("Error in SgEnumDeclaration::error() \n");
141275 : ROSE_ABORT();
141276 : }
141277 :
141278 : ROSE_ASSERT (getVariant() == ENUM_DECL_STMT);
141279 : return SgDeclarationStatement::error();
141280 : }
141281 : #endif
141282 :
141283 :
141284 :
141285 : // End of memberFunctionString
141286 :
141287 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
141288 :
141289 8468590 : SgEnumDeclaration* isSgEnumDeclaration ( SgNode* inputDerivedClassPointer )
141290 : {
141291 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
141292 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
141293 : // So to fix this we return NULL directly when the input is NULL and avoid the
141294 : // dynamic_cast in this case. This is likely a performance improvement as well.
141295 : // return dynamic_cast<SgEnumDeclaration*>(inputDerivedClassPointer);
141296 : // Milind Chabbi (8/28/2013): isSgEnumDeclaration uses table-driven castability instead of c++ default dynamic_cast
141297 : // this improves the running time performance by 10-20%.
141298 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEnumDeclaration*>(inputDerivedClassPointer);
141299 8468590 : return IS_SgEnumDeclaration_FAST_MACRO(inputDerivedClassPointer);
141300 : }
141301 :
141302 : // DQ (11/8/2003): Added version of functions taking const pointer
141303 1435 : const SgEnumDeclaration* isSgEnumDeclaration ( const SgNode* inputDerivedClassPointer )
141304 : {
141305 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
141306 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
141307 : // So to fix this we return NULL directly when the input is NULL and avoid the
141308 : // dynamic_cast in this case. This is likely a performance improvement as well.
141309 : // return dynamic_cast<const SgEnumDeclaration*>(inputDerivedClassPointer);
141310 : // Milind Chabbi (8/28/2013): isSgEnumDeclaration uses table-driven castability instead of c++ default dynamic_cast
141311 : // this improves the running time performance by 10-20%.
141312 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEnumDeclaration*>(inputDerivedClassPointer);
141313 1435 : return IS_SgEnumDeclaration_FAST_MACRO(inputDerivedClassPointer);
141314 : }
141315 :
141316 :
141317 :
141318 : /* #line 141319 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141319 :
141320 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
141321 :
141322 : /**
141323 : \brief Generated destructor
141324 :
141325 : This destructor is automatically generated (by ROSETTA). This destructor
141326 : only frees memory of data members associated with the parts of the current IR node which
141327 : are NOT traversed. Those data members that are part of a traversal can be freed using
141328 : a traversal (calling this destructor on all children in a post-order traversal). Such
141329 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
141330 :
141331 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
141332 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
141333 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
141334 :
141335 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
141336 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
141337 : pointers are not yet implemented to call delete on eash pointer in the container.
141338 : (This could be done by derivation from the STL containers to define containers that
141339 : automatically deleted their members.)
141340 :
141341 : */
141342 892 : SgEnumDeclaration::~SgEnumDeclaration () {
141343 352 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
141344 :
141345 :
141346 : // case: not a listType for name
141347 352 : p_name = ""; // non list case
141348 : // case: not a listType for embedded
141349 352 : p_embedded =false; // non list case
141350 : // case: not a listType for type
141351 352 : p_type = NULL; // non list case
141352 : // case: not a listType for adaParentType
141353 352 : p_adaParentType = NULL; // non list case
141354 : // case: not a listType for scope
141355 352 : p_scope = NULL; // non list case
141356 : // case: not a listType for isUnNamed
141357 352 : p_isUnNamed = false; // non list case
141358 : // case: not a listType for isAutonomousDeclaration
141359 352 : p_isAutonomousDeclaration = true; // non list case
141360 : // case: not a listType for field_type
141361 352 : p_field_type = NULL; // non list case
141362 : // case: not a listType for isScopedEnum
141363 352 : p_isScopedEnum = false; // non list case
141364 : // case: not a listType for name_qualification_length
141365 352 : p_name_qualification_length = 0; // non list case
141366 : // case: not a listType for type_elaboration_required
141367 352 : p_type_elaboration_required = false; // non list case
141368 : // case: not a listType for global_qualification_required
141369 352 : p_global_qualification_required = false; // non list case
141370 :
141371 : }
141372 :
141373 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
141374 704 : }
141375 :
141376 :
141377 : /* #line 141378 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141378 :
141379 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
141380 :
141381 : // Generated constructor
141382 0 : SgEnumDeclaration::SgEnumDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgEnumType* type )
141383 0 : : SgDeclarationStatement(startOfConstruct)
141384 : {
141385 : #ifdef DEBUG
141386 : // printf ("In SgEnumDeclaration::SgEnumDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgEnumType* type) sage_class_name() = %s \n",sage_class_name());
141387 : #endif
141388 : #if 0
141389 : // debugging information!
141390 : printf ("In SgEnumDeclaration::SgEnumDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgEnumType* type): this = %p = %s \n",this,this->class_name().c_str());
141391 : #endif
141392 :
141393 0 : p_name = name;
141394 0 : p_embedded =false;
141395 0 : p_type = type;
141396 0 : p_adaParentType = NULL;
141397 0 : p_scope = NULL;
141398 0 : p_isUnNamed = false;
141399 0 : p_isAutonomousDeclaration = true;
141400 0 : p_field_type = NULL;
141401 0 : p_isScopedEnum = false;
141402 0 : p_name_qualification_length = 0;
141403 0 : p_type_elaboration_required = false;
141404 0 : p_global_qualification_required = false;
141405 :
141406 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
141407 :
141408 : #if 0
141409 : // DQ (7/30/2014): Call a virtual function.
141410 : std::string s = this->class_name();
141411 : #endif
141412 :
141413 : // Test the variant virtual function
141414 : // assert(ENUM_DECL_STMT == variant());
141415 0 : assert(ENUM_DECL_STMT == this->variant());
141416 0 : ROSE_ASSERT(ENUM_DECL_STMT == (int)(this->variantT()));
141417 0 : post_construction_initialization();
141418 :
141419 : // Test the isSgEnumDeclaration() function since it has been problematic
141420 0 : assert(isSgEnumDeclaration(this) != NULL);
141421 0 : }
141422 :
141423 : // Generated constructor (all data members)
141424 :
141425 : /* #line 141426 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141426 :
141427 :
141428 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
141429 :
141430 :
141431 : // ********************************************************
141432 : // member functions common across all array grammar objects
141433 : // ********************************************************
141434 :
141435 :
141436 :
141437 : /* #line 141438 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141438 :
141439 :
141440 :
141441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
141442 :
141443 : // ********************************************************
141444 : // member functions specific to each node in the grammar
141445 : // ********************************************************
141446 :
141447 :
141448 : /* #line 141449 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141449 :
141450 : // Start of memberFunctionString
141451 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
141452 :
141453 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
141454 :
141455 : std::string
141456 0 : SgAsmStmt::get_assemblyCode () const
141457 : {
141458 0 : ROSE_ASSERT (this != NULL);
141459 :
141460 : #if 0
141461 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141462 : // used to trigger marking transformations for the token-based unparsing.
141463 : printf ("SgAsmStmt::get_assemblyCode = %p = %s \n",this,this->class_name().c_str());
141464 : #endif
141465 :
141466 0 : return p_assemblyCode;
141467 : }
141468 :
141469 : void
141470 0 : SgAsmStmt::set_assemblyCode ( std::string assemblyCode )
141471 : {
141472 0 : ROSE_ASSERT (this != NULL);
141473 :
141474 : #if 0
141475 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141476 : // used to trigger marking transformations for the token-based unparsing.
141477 : printf ("SgAsmStmt::set_assemblyCode = %p = %s \n",this,this->class_name().c_str());
141478 : #endif
141479 :
141480 0 : set_isModified(true);
141481 :
141482 0 : p_assemblyCode = assemblyCode;
141483 0 : }
141484 :
141485 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
141486 :
141487 :
141488 : // End of memberFunctionString
141489 : // Start of memberFunctionString
141490 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
141491 :
141492 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
141493 :
141494 : bool
141495 0 : SgAsmStmt::get_useGnuExtendedFormat () const
141496 : {
141497 0 : ROSE_ASSERT (this != NULL);
141498 :
141499 : #if 0
141500 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141501 : // used to trigger marking transformations for the token-based unparsing.
141502 : printf ("SgAsmStmt::get_useGnuExtendedFormat = %p = %s \n",this,this->class_name().c_str());
141503 : #endif
141504 :
141505 0 : return p_useGnuExtendedFormat;
141506 : }
141507 :
141508 : void
141509 0 : SgAsmStmt::set_useGnuExtendedFormat ( bool useGnuExtendedFormat )
141510 : {
141511 0 : ROSE_ASSERT (this != NULL);
141512 :
141513 : #if 0
141514 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141515 : // used to trigger marking transformations for the token-based unparsing.
141516 : printf ("SgAsmStmt::set_useGnuExtendedFormat = %p = %s \n",this,this->class_name().c_str());
141517 : #endif
141518 :
141519 0 : set_isModified(true);
141520 :
141521 0 : p_useGnuExtendedFormat = useGnuExtendedFormat;
141522 0 : }
141523 :
141524 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
141525 :
141526 :
141527 : // End of memberFunctionString
141528 : // Start of memberFunctionString
141529 :
141530 :
141531 : // End of memberFunctionString
141532 : // Start of memberFunctionString
141533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
141534 :
141535 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
141536 :
141537 : bool
141538 0 : SgAsmStmt::get_isVolatile () const
141539 : {
141540 0 : ROSE_ASSERT (this != NULL);
141541 :
141542 : #if 0
141543 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141544 : // used to trigger marking transformations for the token-based unparsing.
141545 : printf ("SgAsmStmt::get_isVolatile = %p = %s \n",this,this->class_name().c_str());
141546 : #endif
141547 :
141548 0 : return p_isVolatile;
141549 : }
141550 :
141551 : void
141552 0 : SgAsmStmt::set_isVolatile ( bool isVolatile )
141553 : {
141554 0 : ROSE_ASSERT (this != NULL);
141555 :
141556 : #if 0
141557 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141558 : // used to trigger marking transformations for the token-based unparsing.
141559 : printf ("SgAsmStmt::set_isVolatile = %p = %s \n",this,this->class_name().c_str());
141560 : #endif
141561 :
141562 0 : set_isModified(true);
141563 :
141564 0 : p_isVolatile = isVolatile;
141565 0 : }
141566 :
141567 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
141568 :
141569 :
141570 : // End of memberFunctionString
141571 : // Start of memberFunctionString
141572 : /* #line 15928 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
141573 :
141574 :
141575 : void
141576 0 : SgAsmStmt::post_construction_initialization()
141577 0 : {}
141578 :
141579 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
141580 : SgName
141581 0 : SgAsmStmt::get_mangled_name(void) const
141582 : {
141583 : #if 0
141584 : SgName returnName;
141585 :
141586 : // This is a poor way to handle the generation of unique strings (it also
141587 : // connects the unparser to the fronend handling which is not a great idea).
141588 : // returnName = get_expr_root()->unparseToString();
141589 :
141590 : // DQ (7/22/2006): This IR node has been changed to have a list of SgAsmOp IR nodes
141591 : SgExpressionPtrList::const_iterator i = p_operands.begin();
141592 : while (i != p_operands.end())
141593 : {
141594 : returnName += (*i)->get_type()->get_mangled();
141595 : i++;
141596 : }
141597 :
141598 : return returnName;
141599 : #else
141600 : #if 0
141601 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
141602 : SgAsmStmt* declaration = const_cast<SgAsmStmt*>(this);
141603 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
141604 : if (i != p_globalMangledNameMap.end())
141605 : {
141606 : return i->second.c_str();
141607 : }
141608 : #endif
141609 0 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgAsmStmt*>(this));
141610 0 : if (mangledNameString.empty() == false)
141611 : {
141612 : // return i->second.c_str();
141613 0 : return mangledNameString;
141614 : }
141615 : else
141616 : {
141617 0 : SgName mangledName;
141618 :
141619 : // This is a poor way to handle the generation of unique strings (it also
141620 : // connects the unparser to the frontend handling which is not a great idea).
141621 : // returnName = get_expr_root()->unparseToString();
141622 :
141623 : // DQ (7/22/2006): This IR node has been changed to have a list of SgAsmOp IR nodes
141624 0 : SgExpressionPtrList::const_iterator i = p_operands.begin();
141625 0 : while (i != p_operands.end())
141626 : {
141627 0 : mangledName += (*i)->get_type()->get_mangled();
141628 0 : i++;
141629 : }
141630 : #if 0
141631 : printf ("In SgAsmStmt::get_mangled_name(): mangledName = %s \n",mangledName.str());
141632 : #endif
141633 :
141634 : // p_globalMangledNameMap[declaration] = mangledName;
141635 0 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgAsmStmt*>(this),mangledName);
141636 0 : return mangledName;
141637 : }
141638 : #endif
141639 : }
141640 :
141641 : // DQ (7/22/2006): We need these to be explicit since we can't support reference parameter passing within ROSETTA.
141642 : SgExpressionPtrList &
141643 0 : SgAsmStmt::get_operands()
141644 0 : { return p_operands; }
141645 :
141646 : const SgExpressionPtrList &
141647 0 : SgAsmStmt::get_operands() const
141648 0 : { return p_operands; }
141649 :
141650 : // DQ (7/27/2006): We need these to be explicit since we can't support reference parameter passing within ROSETTA.
141651 : SgAsmStmt::AsmRegisterNameList &
141652 0 : SgAsmStmt::get_clobberRegisterList()
141653 0 : { return p_clobberRegisterList; }
141654 :
141655 : const SgAsmStmt::AsmRegisterNameList &
141656 0 : SgAsmStmt::get_clobberRegisterList() const
141657 0 : { return p_clobberRegisterList; }
141658 :
141659 :
141660 :
141661 : // End of memberFunctionString
141662 : // Start of memberFunctionString
141663 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
141664 :
141665 : // *** COMMON CODE SECTION BEGINS HERE ***
141666 :
141667 : #if 0
141668 : int
141669 : SgAsmStmt::getVariant() const
141670 : {
141671 : // This function is used in ROSE while "variant()" is used in SAGE
141672 : assert(this != NULL);
141673 : return variant();
141674 : }
141675 : #endif
141676 :
141677 : // This function is used in ROSE in treeTraversal code
141678 : // eventually replaces getVariant() and variant()
141679 : // though after variant() has been removed for a while we will
141680 : // want to change the name of variantT() back to variant()
141681 : // (since the "T" was ment to stand for temporary).
141682 : // When this happens the variantT() will be depricated.
141683 : VariantT
141684 0 : SgAsmStmt::variantT() const
141685 : {
141686 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
141687 0 : ROSE_ASSERT(this != NULL);
141688 0 : return V_SgAsmStmt;
141689 : }
141690 :
141691 : #if 0
141692 : int
141693 : SgAsmStmt::variant() const
141694 : {
141695 : // This function is used in SAGE
141696 : ROSE_ASSERT(this != NULL);
141697 : return ASM_STMT;
141698 : }
141699 : #endif
141700 :
141701 : ROSE_DLL_API const char*
141702 0 : SgAsmStmt::sage_class_name() const
141703 : {
141704 0 : ROSE_ASSERT(this != NULL);
141705 0 : return "SgAsmStmt";
141706 : }
141707 :
141708 : std::string
141709 0 : SgAsmStmt::class_name() const
141710 : {
141711 0 : ROSE_ASSERT(this != NULL);
141712 0 : return "SgAsmStmt";
141713 : }
141714 :
141715 : // DQ (11/26/2005): Support for visitor pattern mechanims
141716 : // (inferior to ROSE traversal mechanism, experimental).
141717 : void
141718 0 : SgAsmStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
141719 : {
141720 0 : ROSE_ASSERT(this != NULL);
141721 0 : visitor.visit(this);
141722 0 : }
141723 :
141724 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
141725 0 : void SgAsmStmt::accept (ROSE_VisitorPattern & visitor) {
141726 0 : ROSE_ASSERT(this != NULL);
141727 0 : visitor.visit(this);
141728 0 : }
141729 :
141730 : SgAsmStmt*
141731 0 : SgAsmStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
141732 : {
141733 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
141734 : // This function is currently only supported for the AST used the represent Binary executables.
141735 : if (0 /* isSgAsmNode(this) != NULL */)
141736 : {
141737 : // Support for regex specification.
141738 : std::string prefixCode = "REGEX:";
141739 : addNewAttribute(prefixCode + s,a);
141740 : }
141741 : #endif
141742 :
141743 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
141744 0 : return this;
141745 : }
141746 :
141747 : // *** COMMON CODE SECTION ENDS HERE ***
141748 :
141749 :
141750 : // End of memberFunctionString
141751 : // Start of memberFunctionString
141752 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
141753 :
141754 :
141755 : #if 0
141756 : //! Error checking support
141757 : /*! Verifies the following:
141758 : - working getVariant() member function
141759 : - calls base class's error() member function
141760 : Every class has one of these functions.
141761 : */
141762 : bool
141763 : SgAsmStmt::error()
141764 : {
141765 : // Put error checking here
141766 :
141767 : ROSE_ASSERT (this != NULL);
141768 : if (getVariant() != ASM_STMT)
141769 : {
141770 : printf ("Error in SgAsmStmt::error(): SgAsmStmt object has a %s variant \n",
141771 : Cxx_GrammarTerminalNames[getVariant()].name);
141772 : // printf ("Error in SgAsmStmt::error() \n");
141773 : ROSE_ABORT();
141774 : }
141775 :
141776 : ROSE_ASSERT (getVariant() == ASM_STMT);
141777 : return SgDeclarationStatement::error();
141778 : }
141779 : #endif
141780 :
141781 :
141782 :
141783 : // End of memberFunctionString
141784 :
141785 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
141786 :
141787 0 : SgAsmStmt* isSgAsmStmt ( SgNode* inputDerivedClassPointer )
141788 : {
141789 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
141790 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
141791 : // So to fix this we return NULL directly when the input is NULL and avoid the
141792 : // dynamic_cast in this case. This is likely a performance improvement as well.
141793 : // return dynamic_cast<SgAsmStmt*>(inputDerivedClassPointer);
141794 : // Milind Chabbi (8/28/2013): isSgAsmStmt uses table-driven castability instead of c++ default dynamic_cast
141795 : // this improves the running time performance by 10-20%.
141796 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAsmStmt*>(inputDerivedClassPointer);
141797 0 : return IS_SgAsmStmt_FAST_MACRO(inputDerivedClassPointer);
141798 : }
141799 :
141800 : // DQ (11/8/2003): Added version of functions taking const pointer
141801 0 : const SgAsmStmt* isSgAsmStmt ( const SgNode* inputDerivedClassPointer )
141802 : {
141803 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
141804 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
141805 : // So to fix this we return NULL directly when the input is NULL and avoid the
141806 : // dynamic_cast in this case. This is likely a performance improvement as well.
141807 : // return dynamic_cast<const SgAsmStmt*>(inputDerivedClassPointer);
141808 : // Milind Chabbi (8/28/2013): isSgAsmStmt uses table-driven castability instead of c++ default dynamic_cast
141809 : // this improves the running time performance by 10-20%.
141810 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAsmStmt*>(inputDerivedClassPointer);
141811 0 : return IS_SgAsmStmt_FAST_MACRO(inputDerivedClassPointer);
141812 : }
141813 :
141814 :
141815 :
141816 : /* #line 141817 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141817 :
141818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
141819 :
141820 : /**
141821 : \brief Generated destructor
141822 :
141823 : This destructor is automatically generated (by ROSETTA). This destructor
141824 : only frees memory of data members associated with the parts of the current IR node which
141825 : are NOT traversed. Those data members that are part of a traversal can be freed using
141826 : a traversal (calling this destructor on all children in a post-order traversal). Such
141827 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
141828 :
141829 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
141830 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
141831 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
141832 :
141833 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
141834 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
141835 : pointers are not yet implemented to call delete on eash pointer in the container.
141836 : (This could be done by derivation from the STL containers to define containers that
141837 : automatically deleted their members.)
141838 :
141839 : */
141840 0 : SgAsmStmt::~SgAsmStmt () {
141841 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
141842 :
141843 :
141844 : // case: not a listType for assemblyCode
141845 0 : p_assemblyCode = ""; // non list case
141846 : // case: not a listType for useGnuExtendedFormat
141847 0 : p_useGnuExtendedFormat = false; // non list case
141848 : // case: not a listType for isVolatile
141849 0 : p_isVolatile = false; // non list case
141850 :
141851 : }
141852 :
141853 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
141854 0 : }
141855 :
141856 :
141857 : /* #line 141858 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141858 :
141859 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
141860 :
141861 : // Generated constructor
141862 0 : SgAsmStmt::SgAsmStmt ( Sg_File_Info* startOfConstruct )
141863 0 : : SgDeclarationStatement(startOfConstruct)
141864 : {
141865 : #ifdef DEBUG
141866 : // printf ("In SgAsmStmt::SgAsmStmt (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
141867 : #endif
141868 : #if 0
141869 : // debugging information!
141870 : printf ("In SgAsmStmt::SgAsmStmt (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
141871 : #endif
141872 :
141873 0 : p_assemblyCode = "";
141874 0 : p_useGnuExtendedFormat = false;
141875 0 : p_isVolatile = false;
141876 :
141877 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
141878 :
141879 : #if 0
141880 : // DQ (7/30/2014): Call a virtual function.
141881 : std::string s = this->class_name();
141882 : #endif
141883 :
141884 : // Test the variant virtual function
141885 : // assert(ASM_STMT == variant());
141886 0 : assert(ASM_STMT == this->variant());
141887 0 : ROSE_ASSERT(ASM_STMT == (int)(this->variantT()));
141888 0 : post_construction_initialization();
141889 :
141890 : // Test the isSgAsmStmt() function since it has been problematic
141891 0 : assert(isSgAsmStmt(this) != NULL);
141892 0 : }
141893 :
141894 : // Generated constructor (all data members)
141895 :
141896 : /* #line 141897 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141897 :
141898 :
141899 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
141900 :
141901 :
141902 : // ********************************************************
141903 : // member functions common across all array grammar objects
141904 : // ********************************************************
141905 :
141906 :
141907 :
141908 : /* #line 141909 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141909 :
141910 :
141911 :
141912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
141913 :
141914 : // ********************************************************
141915 : // member functions specific to each node in the grammar
141916 : // ********************************************************
141917 :
141918 :
141919 : /* #line 141920 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
141920 :
141921 : // Start of memberFunctionString
141922 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
141923 :
141924 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
141925 :
141926 : SgAttributeSpecificationStatement::attribute_spec_enum
141927 67 : SgAttributeSpecificationStatement::get_attribute_kind () const
141928 : {
141929 67 : ROSE_ASSERT (this != NULL);
141930 :
141931 : #if 0
141932 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141933 : // used to trigger marking transformations for the token-based unparsing.
141934 : printf ("SgAttributeSpecificationStatement::get_attribute_kind = %p = %s \n",this,this->class_name().c_str());
141935 : #endif
141936 :
141937 67 : return p_attribute_kind;
141938 : }
141939 :
141940 : void
141941 551 : SgAttributeSpecificationStatement::set_attribute_kind ( SgAttributeSpecificationStatement::attribute_spec_enum attribute_kind )
141942 : {
141943 551 : ROSE_ASSERT (this != NULL);
141944 :
141945 : #if 0
141946 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141947 : // used to trigger marking transformations for the token-based unparsing.
141948 : printf ("SgAttributeSpecificationStatement::set_attribute_kind = %p = %s \n",this,this->class_name().c_str());
141949 : #endif
141950 :
141951 551 : set_isModified(true);
141952 :
141953 551 : p_attribute_kind = attribute_kind;
141954 551 : }
141955 :
141956 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
141957 :
141958 :
141959 : // End of memberFunctionString
141960 : // Start of memberFunctionString
141961 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
141962 :
141963 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
141964 :
141965 : int
141966 0 : SgAttributeSpecificationStatement::get_intent () const
141967 : {
141968 0 : ROSE_ASSERT (this != NULL);
141969 :
141970 : #if 0
141971 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141972 : // used to trigger marking transformations for the token-based unparsing.
141973 : printf ("SgAttributeSpecificationStatement::get_intent = %p = %s \n",this,this->class_name().c_str());
141974 : #endif
141975 :
141976 0 : return p_intent;
141977 : }
141978 :
141979 : void
141980 0 : SgAttributeSpecificationStatement::set_intent ( int intent )
141981 : {
141982 0 : ROSE_ASSERT (this != NULL);
141983 :
141984 : #if 0
141985 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
141986 : // used to trigger marking transformations for the token-based unparsing.
141987 : printf ("SgAttributeSpecificationStatement::set_intent = %p = %s \n",this,this->class_name().c_str());
141988 : #endif
141989 :
141990 0 : set_isModified(true);
141991 :
141992 0 : p_intent = intent;
141993 0 : }
141994 :
141995 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
141996 :
141997 :
141998 : // End of memberFunctionString
141999 : // Start of memberFunctionString
142000 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142001 :
142002 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142003 :
142004 : SgExprListExp*
142005 1116 : SgAttributeSpecificationStatement::get_parameter_list () const
142006 : {
142007 1116 : ROSE_ASSERT (this != NULL);
142008 :
142009 : #if 0
142010 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142011 : // used to trigger marking transformations for the token-based unparsing.
142012 : printf ("SgAttributeSpecificationStatement::get_parameter_list = %p = %s \n",this,this->class_name().c_str());
142013 : #endif
142014 :
142015 1116 : return p_parameter_list;
142016 : }
142017 :
142018 : void
142019 551 : SgAttributeSpecificationStatement::set_parameter_list ( SgExprListExp* parameter_list )
142020 : {
142021 551 : ROSE_ASSERT (this != NULL);
142022 :
142023 : #if 0
142024 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142025 : // used to trigger marking transformations for the token-based unparsing.
142026 : printf ("SgAttributeSpecificationStatement::set_parameter_list = %p = %s \n",this,this->class_name().c_str());
142027 : #endif
142028 :
142029 551 : set_isModified(true);
142030 :
142031 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
142032 : if (p_parameter_list != NULL && parameter_list != NULL && p_parameter_list != parameter_list)
142033 : {
142034 : printf ("Warning: parameter_list = %p overwriting valid pointer p_parameter_list = %p \n",parameter_list,p_parameter_list);
142035 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
142036 : printf ("Error fails assertion (p_parameter_list != NULL && parameter_list != NULL && p_parameter_list != parameter_list) is false\n");
142037 : ROSE_ASSERT(false);
142038 : #endif
142039 : }
142040 : #endif
142041 551 : p_parameter_list = parameter_list;
142042 551 : }
142043 :
142044 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142045 :
142046 :
142047 : // End of memberFunctionString
142048 : // Start of memberFunctionString
142049 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142050 :
142051 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142052 :
142053 : SgExprListExp*
142054 0 : SgAttributeSpecificationStatement::get_bind_list () const
142055 : {
142056 0 : ROSE_ASSERT (this != NULL);
142057 :
142058 : #if 0
142059 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142060 : // used to trigger marking transformations for the token-based unparsing.
142061 : printf ("SgAttributeSpecificationStatement::get_bind_list = %p = %s \n",this,this->class_name().c_str());
142062 : #endif
142063 :
142064 0 : return p_bind_list;
142065 : }
142066 :
142067 : void
142068 0 : SgAttributeSpecificationStatement::set_bind_list ( SgExprListExp* bind_list )
142069 : {
142070 0 : ROSE_ASSERT (this != NULL);
142071 :
142072 : #if 0
142073 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142074 : // used to trigger marking transformations for the token-based unparsing.
142075 : printf ("SgAttributeSpecificationStatement::set_bind_list = %p = %s \n",this,this->class_name().c_str());
142076 : #endif
142077 :
142078 0 : set_isModified(true);
142079 :
142080 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
142081 : if (p_bind_list != NULL && bind_list != NULL && p_bind_list != bind_list)
142082 : {
142083 : printf ("Warning: bind_list = %p overwriting valid pointer p_bind_list = %p \n",bind_list,p_bind_list);
142084 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
142085 : printf ("Error fails assertion (p_bind_list != NULL && bind_list != NULL && p_bind_list != bind_list) is false\n");
142086 : ROSE_ASSERT(false);
142087 : #endif
142088 : }
142089 : #endif
142090 0 : p_bind_list = bind_list;
142091 0 : }
142092 :
142093 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142094 :
142095 :
142096 : // End of memberFunctionString
142097 : // Start of memberFunctionString
142098 :
142099 :
142100 : // End of memberFunctionString
142101 : // Start of memberFunctionString
142102 : /* #line 18646 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
142103 :
142104 : void
142105 551 : SgAttributeSpecificationStatement::post_construction_initialization()
142106 551 : {}
142107 :
142108 : SgName
142109 551 : SgAttributeSpecificationStatement::get_mangled_name(void) const
142110 : {
142111 : // printf ("Sorry, SgAttributeSpecificationStatement::get_mangled_name() not implemented! \n");
142112 551 : return SgName ("__attribute_specification_statement__");
142113 : }
142114 :
142115 : const SgStringList &
142116 0 : SgAttributeSpecificationStatement::get_name_list() const
142117 : {
142118 0 : return p_name_list;
142119 : }
142120 :
142121 : SgStringList &
142122 5 : SgAttributeSpecificationStatement::get_name_list()
142123 : {
142124 5 : return p_name_list;
142125 : }
142126 :
142127 : const SgDataStatementGroupPtrList &
142128 0 : SgAttributeSpecificationStatement::get_data_statement_group_list() const
142129 : {
142130 0 : return p_data_statement_group_list;
142131 : }
142132 :
142133 : SgDataStatementGroupPtrList &
142134 0 : SgAttributeSpecificationStatement::get_data_statement_group_list()
142135 : {
142136 0 : return p_data_statement_group_list;
142137 : }
142138 :
142139 : const SgDimensionObjectPtrList &
142140 0 : SgAttributeSpecificationStatement::get_dimension_object_list() const
142141 : {
142142 0 : return p_dimension_object_list;
142143 : }
142144 :
142145 : SgDimensionObjectPtrList &
142146 0 : SgAttributeSpecificationStatement::get_dimension_object_list()
142147 : {
142148 0 : return p_dimension_object_list;
142149 : }
142150 :
142151 : SgSymbol*
142152 0 : SgAttributeSpecificationStatement::search_for_symbol_from_symbol_table() const
142153 : {
142154 : #if 0
142155 : SgDeclarationStatement* declaration = get_declaration_associated_with_symbol();
142156 : if (declaration == NULL)
142157 : {
142158 : printf ("Error: in SgDeclarationStatement::search_for_symbol_from_symbol_table(): declaration == NULL \n");
142159 : printf (" this = %p = %s = %s \n",this,this->class_name().c_str(),SageInterface::get_name(this).c_str());
142160 : }
142161 : ROSE_ASSERT(declaration != NULL);
142162 : SgSymbol* symbol = declaration->get_symbol_from_symbol_table();
142163 : ROSE_ASSERT(symbol != NULL);
142164 : return symbol;
142165 : #else
142166 : // If we are searching for a symbol associated with this declaration, then it could only be a numeric label
142167 : // in which case we have to search for it in the function scope (SgFunctionDefinition).
142168 :
142169 0 : SgScopeStatement* tempScope = get_scope();
142170 0 : ROSE_ASSERT(tempScope != NULL);
142171 0 : while (tempScope != NULL && isSgFunctionDefinition(tempScope) == NULL)
142172 : {
142173 0 : tempScope = tempScope->get_scope();
142174 : }
142175 :
142176 0 : SgFunctionDefinition* functionDefinition = isSgFunctionDefinition(tempScope);
142177 0 : if (functionDefinition == NULL)
142178 : {
142179 0 : printf ("Labels are stored in the SgFunctionDefinition (function scope), could not locate associated function scope \n");
142180 : }
142181 0 : ROSE_ASSERT(functionDefinition != NULL);
142182 : // return functionDefinition->get_symbol_table()->find(this);
142183 0 : return functionDefinition->find_symbol_from_declaration(this);
142184 :
142185 : // printf ("In SgAttributeSpecificationStatement::search_for_symbol_from_symbol_table(): returning NULL \n");
142186 : // return NULL;
142187 : #endif
142188 : }
142189 :
142190 :
142191 :
142192 : // End of memberFunctionString
142193 : // Start of memberFunctionString
142194 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
142195 :
142196 : // *** COMMON CODE SECTION BEGINS HERE ***
142197 :
142198 : #if 0
142199 : int
142200 : SgAttributeSpecificationStatement::getVariant() const
142201 : {
142202 : // This function is used in ROSE while "variant()" is used in SAGE
142203 : assert(this != NULL);
142204 : return variant();
142205 : }
142206 : #endif
142207 :
142208 : // This function is used in ROSE in treeTraversal code
142209 : // eventually replaces getVariant() and variant()
142210 : // though after variant() has been removed for a while we will
142211 : // want to change the name of variantT() back to variant()
142212 : // (since the "T" was ment to stand for temporary).
142213 : // When this happens the variantT() will be depricated.
142214 : VariantT
142215 443697 : SgAttributeSpecificationStatement::variantT() const
142216 : {
142217 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
142218 443697 : ROSE_ASSERT(this != NULL);
142219 443697 : return V_SgAttributeSpecificationStatement;
142220 : }
142221 :
142222 : #if 0
142223 : int
142224 : SgAttributeSpecificationStatement::variant() const
142225 : {
142226 : // This function is used in SAGE
142227 : ROSE_ASSERT(this != NULL);
142228 : return TEMP_Attribute_Specification_Statement;
142229 : }
142230 : #endif
142231 :
142232 : ROSE_DLL_API const char*
142233 1098 : SgAttributeSpecificationStatement::sage_class_name() const
142234 : {
142235 1098 : ROSE_ASSERT(this != NULL);
142236 1098 : return "SgAttributeSpecificationStatement";
142237 : }
142238 :
142239 : std::string
142240 551 : SgAttributeSpecificationStatement::class_name() const
142241 : {
142242 551 : ROSE_ASSERT(this != NULL);
142243 551 : return "SgAttributeSpecificationStatement";
142244 : }
142245 :
142246 : // DQ (11/26/2005): Support for visitor pattern mechanims
142247 : // (inferior to ROSE traversal mechanism, experimental).
142248 : void
142249 0 : SgAttributeSpecificationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
142250 : {
142251 0 : ROSE_ASSERT(this != NULL);
142252 0 : visitor.visit(this);
142253 0 : }
142254 :
142255 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
142256 0 : void SgAttributeSpecificationStatement::accept (ROSE_VisitorPattern & visitor) {
142257 0 : ROSE_ASSERT(this != NULL);
142258 0 : visitor.visit(this);
142259 0 : }
142260 :
142261 : SgAttributeSpecificationStatement*
142262 0 : SgAttributeSpecificationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
142263 : {
142264 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
142265 : // This function is currently only supported for the AST used the represent Binary executables.
142266 : if (0 /* isSgAsmNode(this) != NULL */)
142267 : {
142268 : // Support for regex specification.
142269 : std::string prefixCode = "REGEX:";
142270 : addNewAttribute(prefixCode + s,a);
142271 : }
142272 : #endif
142273 :
142274 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
142275 0 : return this;
142276 : }
142277 :
142278 : // *** COMMON CODE SECTION ENDS HERE ***
142279 :
142280 :
142281 : // End of memberFunctionString
142282 : // Start of memberFunctionString
142283 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
142284 :
142285 :
142286 : #if 0
142287 : //! Error checking support
142288 : /*! Verifies the following:
142289 : - working getVariant() member function
142290 : - calls base class's error() member function
142291 : Every class has one of these functions.
142292 : */
142293 : bool
142294 : SgAttributeSpecificationStatement::error()
142295 : {
142296 : // Put error checking here
142297 :
142298 : ROSE_ASSERT (this != NULL);
142299 : if (getVariant() != TEMP_Attribute_Specification_Statement)
142300 : {
142301 : printf ("Error in SgAttributeSpecificationStatement::error(): SgAttributeSpecificationStatement object has a %s variant \n",
142302 : Cxx_GrammarTerminalNames[getVariant()].name);
142303 : // printf ("Error in SgAttributeSpecificationStatement::error() \n");
142304 : ROSE_ABORT();
142305 : }
142306 :
142307 : ROSE_ASSERT (getVariant() == TEMP_Attribute_Specification_Statement);
142308 : return SgDeclarationStatement::error();
142309 : }
142310 : #endif
142311 :
142312 :
142313 :
142314 : // End of memberFunctionString
142315 :
142316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
142317 :
142318 556 : SgAttributeSpecificationStatement* isSgAttributeSpecificationStatement ( SgNode* inputDerivedClassPointer )
142319 : {
142320 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
142321 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
142322 : // So to fix this we return NULL directly when the input is NULL and avoid the
142323 : // dynamic_cast in this case. This is likely a performance improvement as well.
142324 : // return dynamic_cast<SgAttributeSpecificationStatement*>(inputDerivedClassPointer);
142325 : // Milind Chabbi (8/28/2013): isSgAttributeSpecificationStatement uses table-driven castability instead of c++ default dynamic_cast
142326 : // this improves the running time performance by 10-20%.
142327 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAttributeSpecificationStatement*>(inputDerivedClassPointer);
142328 556 : return IS_SgAttributeSpecificationStatement_FAST_MACRO(inputDerivedClassPointer);
142329 : }
142330 :
142331 : // DQ (11/8/2003): Added version of functions taking const pointer
142332 0 : const SgAttributeSpecificationStatement* isSgAttributeSpecificationStatement ( const SgNode* inputDerivedClassPointer )
142333 : {
142334 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
142335 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
142336 : // So to fix this we return NULL directly when the input is NULL and avoid the
142337 : // dynamic_cast in this case. This is likely a performance improvement as well.
142338 : // return dynamic_cast<const SgAttributeSpecificationStatement*>(inputDerivedClassPointer);
142339 : // Milind Chabbi (8/28/2013): isSgAttributeSpecificationStatement uses table-driven castability instead of c++ default dynamic_cast
142340 : // this improves the running time performance by 10-20%.
142341 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAttributeSpecificationStatement*>(inputDerivedClassPointer);
142342 0 : return IS_SgAttributeSpecificationStatement_FAST_MACRO(inputDerivedClassPointer);
142343 : }
142344 :
142345 :
142346 :
142347 : /* #line 142348 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142348 :
142349 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
142350 :
142351 : /**
142352 : \brief Generated destructor
142353 :
142354 : This destructor is automatically generated (by ROSETTA). This destructor
142355 : only frees memory of data members associated with the parts of the current IR node which
142356 : are NOT traversed. Those data members that are part of a traversal can be freed using
142357 : a traversal (calling this destructor on all children in a post-order traversal). Such
142358 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
142359 :
142360 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
142361 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
142362 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
142363 :
142364 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
142365 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
142366 : pointers are not yet implemented to call delete on eash pointer in the container.
142367 : (This could be done by derivation from the STL containers to define containers that
142368 : automatically deleted their members.)
142369 :
142370 : */
142371 0 : SgAttributeSpecificationStatement::~SgAttributeSpecificationStatement () {
142372 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
142373 :
142374 :
142375 : // case: not a listType for attribute_kind
142376 0 : p_attribute_kind = SgAttributeSpecificationStatement::e_unknown_attribute_spec; // non list case
142377 : // case: not a listType for intent
142378 0 : p_intent = 0; // non list case
142379 : // case: not a listType for parameter_list
142380 0 : p_parameter_list = NULL; // non list case
142381 : // case: not a listType for bind_list
142382 0 : p_bind_list = NULL; // non list case
142383 :
142384 : }
142385 :
142386 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
142387 0 : }
142388 :
142389 :
142390 : /* #line 142391 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142391 :
142392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
142393 :
142394 : // Generated constructor
142395 0 : SgAttributeSpecificationStatement::SgAttributeSpecificationStatement ( Sg_File_Info* startOfConstruct )
142396 0 : : SgDeclarationStatement(startOfConstruct)
142397 : {
142398 : #ifdef DEBUG
142399 : // printf ("In SgAttributeSpecificationStatement::SgAttributeSpecificationStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
142400 : #endif
142401 : #if 0
142402 : // debugging information!
142403 : printf ("In SgAttributeSpecificationStatement::SgAttributeSpecificationStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
142404 : #endif
142405 :
142406 0 : p_attribute_kind = SgAttributeSpecificationStatement::e_unknown_attribute_spec;
142407 0 : p_intent = 0;
142408 0 : p_parameter_list = NULL;
142409 0 : p_bind_list = NULL;
142410 :
142411 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
142412 :
142413 : #if 0
142414 : // DQ (7/30/2014): Call a virtual function.
142415 : std::string s = this->class_name();
142416 : #endif
142417 :
142418 : // Test the variant virtual function
142419 : // assert(TEMP_Attribute_Specification_Statement == variant());
142420 0 : assert(TEMP_Attribute_Specification_Statement == this->variant());
142421 0 : ROSE_ASSERT(TEMP_Attribute_Specification_Statement == (int)(this->variantT()));
142422 0 : post_construction_initialization();
142423 :
142424 : // Test the isSgAttributeSpecificationStatement() function since it has been problematic
142425 0 : assert(isSgAttributeSpecificationStatement(this) != NULL);
142426 0 : }
142427 :
142428 : // Generated constructor (all data members)
142429 :
142430 : /* #line 142431 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142431 :
142432 :
142433 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
142434 :
142435 :
142436 : // ********************************************************
142437 : // member functions common across all array grammar objects
142438 : // ********************************************************
142439 :
142440 :
142441 :
142442 : /* #line 142443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142443 :
142444 :
142445 :
142446 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
142447 :
142448 : // ********************************************************
142449 : // member functions specific to each node in the grammar
142450 : // ********************************************************
142451 :
142452 :
142453 : /* #line 142454 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142454 :
142455 : // Start of memberFunctionString
142456 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142457 :
142458 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142459 :
142460 : SgFormatItemList*
142461 0 : SgFormatStatement::get_format_item_list () const
142462 : {
142463 0 : ROSE_ASSERT (this != NULL);
142464 :
142465 : #if 0
142466 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142467 : // used to trigger marking transformations for the token-based unparsing.
142468 : printf ("SgFormatStatement::get_format_item_list = %p = %s \n",this,this->class_name().c_str());
142469 : #endif
142470 :
142471 0 : return p_format_item_list;
142472 : }
142473 :
142474 : void
142475 0 : SgFormatStatement::set_format_item_list ( SgFormatItemList* format_item_list )
142476 : {
142477 0 : ROSE_ASSERT (this != NULL);
142478 :
142479 : #if 0
142480 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142481 : // used to trigger marking transformations for the token-based unparsing.
142482 : printf ("SgFormatStatement::set_format_item_list = %p = %s \n",this,this->class_name().c_str());
142483 : #endif
142484 :
142485 0 : set_isModified(true);
142486 :
142487 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
142488 : if (p_format_item_list != NULL && format_item_list != NULL && p_format_item_list != format_item_list)
142489 : {
142490 : printf ("Warning: format_item_list = %p overwriting valid pointer p_format_item_list = %p \n",format_item_list,p_format_item_list);
142491 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
142492 : printf ("Error fails assertion (p_format_item_list != NULL && format_item_list != NULL && p_format_item_list != format_item_list) is false\n");
142493 : ROSE_ASSERT(false);
142494 : #endif
142495 : }
142496 : #endif
142497 0 : p_format_item_list = format_item_list;
142498 0 : }
142499 :
142500 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142501 :
142502 :
142503 : // End of memberFunctionString
142504 : // Start of memberFunctionString
142505 : /* #line 18901 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
142506 :
142507 :
142508 : void
142509 0 : SgFormatStatement::post_construction_initialization()
142510 0 : {}
142511 :
142512 : SgName
142513 0 : SgFormatStatement::get_mangled_name(void) const
142514 : {
142515 : // printf ("Sorry, SgFormatStatement::get_mangled_name() not implemented! \n");
142516 0 : return SgName ("__format__");
142517 : }
142518 :
142519 : #if 0
142520 : const SgFormatItemPtrList &
142521 : SgFormatStatement::get_format_item_list() const
142522 : {
142523 : return p_format_item_list;
142524 : }
142525 :
142526 : SgFormatItemPtrList &
142527 : SgFormatStatement::get_format_item_list()
142528 : {
142529 : return p_format_item_list;
142530 : }
142531 :
142532 : void
142533 : SgFormatStatement::set_format_item_list(const SgFormatItemPtrList & format_item_list)
142534 : {
142535 : p_format_item_list = format_item_list;
142536 : }
142537 : #endif
142538 :
142539 :
142540 :
142541 : // End of memberFunctionString
142542 : // Start of memberFunctionString
142543 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
142544 :
142545 : // *** COMMON CODE SECTION BEGINS HERE ***
142546 :
142547 : #if 0
142548 : int
142549 : SgFormatStatement::getVariant() const
142550 : {
142551 : // This function is used in ROSE while "variant()" is used in SAGE
142552 : assert(this != NULL);
142553 : return variant();
142554 : }
142555 : #endif
142556 :
142557 : // This function is used in ROSE in treeTraversal code
142558 : // eventually replaces getVariant() and variant()
142559 : // though after variant() has been removed for a while we will
142560 : // want to change the name of variantT() back to variant()
142561 : // (since the "T" was ment to stand for temporary).
142562 : // When this happens the variantT() will be depricated.
142563 : VariantT
142564 0 : SgFormatStatement::variantT() const
142565 : {
142566 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
142567 0 : ROSE_ASSERT(this != NULL);
142568 0 : return V_SgFormatStatement;
142569 : }
142570 :
142571 : #if 0
142572 : int
142573 : SgFormatStatement::variant() const
142574 : {
142575 : // This function is used in SAGE
142576 : ROSE_ASSERT(this != NULL);
142577 : return FORMAT_STATEMENT;
142578 : }
142579 : #endif
142580 :
142581 : ROSE_DLL_API const char*
142582 0 : SgFormatStatement::sage_class_name() const
142583 : {
142584 0 : ROSE_ASSERT(this != NULL);
142585 0 : return "SgFormatStatement";
142586 : }
142587 :
142588 : std::string
142589 0 : SgFormatStatement::class_name() const
142590 : {
142591 0 : ROSE_ASSERT(this != NULL);
142592 0 : return "SgFormatStatement";
142593 : }
142594 :
142595 : // DQ (11/26/2005): Support for visitor pattern mechanims
142596 : // (inferior to ROSE traversal mechanism, experimental).
142597 : void
142598 0 : SgFormatStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
142599 : {
142600 0 : ROSE_ASSERT(this != NULL);
142601 0 : visitor.visit(this);
142602 0 : }
142603 :
142604 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
142605 0 : void SgFormatStatement::accept (ROSE_VisitorPattern & visitor) {
142606 0 : ROSE_ASSERT(this != NULL);
142607 0 : visitor.visit(this);
142608 0 : }
142609 :
142610 : SgFormatStatement*
142611 0 : SgFormatStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
142612 : {
142613 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
142614 : // This function is currently only supported for the AST used the represent Binary executables.
142615 : if (0 /* isSgAsmNode(this) != NULL */)
142616 : {
142617 : // Support for regex specification.
142618 : std::string prefixCode = "REGEX:";
142619 : addNewAttribute(prefixCode + s,a);
142620 : }
142621 : #endif
142622 :
142623 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
142624 0 : return this;
142625 : }
142626 :
142627 : // *** COMMON CODE SECTION ENDS HERE ***
142628 :
142629 :
142630 : // End of memberFunctionString
142631 : // Start of memberFunctionString
142632 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
142633 :
142634 :
142635 : #if 0
142636 : //! Error checking support
142637 : /*! Verifies the following:
142638 : - working getVariant() member function
142639 : - calls base class's error() member function
142640 : Every class has one of these functions.
142641 : */
142642 : bool
142643 : SgFormatStatement::error()
142644 : {
142645 : // Put error checking here
142646 :
142647 : ROSE_ASSERT (this != NULL);
142648 : if (getVariant() != FORMAT_STATEMENT)
142649 : {
142650 : printf ("Error in SgFormatStatement::error(): SgFormatStatement object has a %s variant \n",
142651 : Cxx_GrammarTerminalNames[getVariant()].name);
142652 : // printf ("Error in SgFormatStatement::error() \n");
142653 : ROSE_ABORT();
142654 : }
142655 :
142656 : ROSE_ASSERT (getVariant() == FORMAT_STATEMENT);
142657 : return SgDeclarationStatement::error();
142658 : }
142659 : #endif
142660 :
142661 :
142662 :
142663 : // End of memberFunctionString
142664 :
142665 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
142666 :
142667 0 : SgFormatStatement* isSgFormatStatement ( SgNode* inputDerivedClassPointer )
142668 : {
142669 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
142670 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
142671 : // So to fix this we return NULL directly when the input is NULL and avoid the
142672 : // dynamic_cast in this case. This is likely a performance improvement as well.
142673 : // return dynamic_cast<SgFormatStatement*>(inputDerivedClassPointer);
142674 : // Milind Chabbi (8/28/2013): isSgFormatStatement uses table-driven castability instead of c++ default dynamic_cast
142675 : // this improves the running time performance by 10-20%.
142676 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFormatStatement*>(inputDerivedClassPointer);
142677 0 : return IS_SgFormatStatement_FAST_MACRO(inputDerivedClassPointer);
142678 : }
142679 :
142680 : // DQ (11/8/2003): Added version of functions taking const pointer
142681 0 : const SgFormatStatement* isSgFormatStatement ( const SgNode* inputDerivedClassPointer )
142682 : {
142683 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
142684 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
142685 : // So to fix this we return NULL directly when the input is NULL and avoid the
142686 : // dynamic_cast in this case. This is likely a performance improvement as well.
142687 : // return dynamic_cast<const SgFormatStatement*>(inputDerivedClassPointer);
142688 : // Milind Chabbi (8/28/2013): isSgFormatStatement uses table-driven castability instead of c++ default dynamic_cast
142689 : // this improves the running time performance by 10-20%.
142690 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFormatStatement*>(inputDerivedClassPointer);
142691 0 : return IS_SgFormatStatement_FAST_MACRO(inputDerivedClassPointer);
142692 : }
142693 :
142694 :
142695 :
142696 : /* #line 142697 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142697 :
142698 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
142699 :
142700 : /**
142701 : \brief Generated destructor
142702 :
142703 : This destructor is automatically generated (by ROSETTA). This destructor
142704 : only frees memory of data members associated with the parts of the current IR node which
142705 : are NOT traversed. Those data members that are part of a traversal can be freed using
142706 : a traversal (calling this destructor on all children in a post-order traversal). Such
142707 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
142708 :
142709 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
142710 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
142711 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
142712 :
142713 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
142714 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
142715 : pointers are not yet implemented to call delete on eash pointer in the container.
142716 : (This could be done by derivation from the STL containers to define containers that
142717 : automatically deleted their members.)
142718 :
142719 : */
142720 0 : SgFormatStatement::~SgFormatStatement () {
142721 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
142722 :
142723 :
142724 : // case: not a listType for format_item_list
142725 0 : p_format_item_list = NULL; // non list case
142726 :
142727 : }
142728 :
142729 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
142730 0 : }
142731 :
142732 :
142733 : /* #line 142734 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142734 :
142735 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
142736 :
142737 : // Generated constructor
142738 0 : SgFormatStatement::SgFormatStatement ( Sg_File_Info* startOfConstruct, SgFormatItemList* format_item_list )
142739 0 : : SgDeclarationStatement(startOfConstruct)
142740 : {
142741 : #ifdef DEBUG
142742 : // printf ("In SgFormatStatement::SgFormatStatement (Sg_File_Info* startOfConstruct, SgFormatItemList* format_item_list) sage_class_name() = %s \n",sage_class_name());
142743 : #endif
142744 : #if 0
142745 : // debugging information!
142746 : printf ("In SgFormatStatement::SgFormatStatement (Sg_File_Info* startOfConstruct, SgFormatItemList* format_item_list): this = %p = %s \n",this,this->class_name().c_str());
142747 : #endif
142748 :
142749 0 : p_format_item_list = format_item_list;
142750 :
142751 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
142752 :
142753 : #if 0
142754 : // DQ (7/30/2014): Call a virtual function.
142755 : std::string s = this->class_name();
142756 : #endif
142757 :
142758 : // Test the variant virtual function
142759 : // assert(FORMAT_STATEMENT == variant());
142760 0 : assert(FORMAT_STATEMENT == this->variant());
142761 0 : ROSE_ASSERT(FORMAT_STATEMENT == (int)(this->variantT()));
142762 0 : post_construction_initialization();
142763 :
142764 : // Test the isSgFormatStatement() function since it has been problematic
142765 0 : assert(isSgFormatStatement(this) != NULL);
142766 0 : }
142767 :
142768 : // Generated constructor (all data members)
142769 :
142770 : /* #line 142771 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142771 :
142772 :
142773 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
142774 :
142775 :
142776 : // ********************************************************
142777 : // member functions common across all array grammar objects
142778 : // ********************************************************
142779 :
142780 :
142781 :
142782 : /* #line 142783 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142783 :
142784 :
142785 :
142786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
142787 :
142788 : // ********************************************************
142789 : // member functions specific to each node in the grammar
142790 : // ********************************************************
142791 :
142792 :
142793 : /* #line 142794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
142794 :
142795 : // Start of memberFunctionString
142796 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142797 :
142798 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142799 :
142800 : SgName
142801 0 : SgTemplateDeclaration::get_name () const
142802 : {
142803 0 : ROSE_ASSERT (this != NULL);
142804 :
142805 : #if 0
142806 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142807 : // used to trigger marking transformations for the token-based unparsing.
142808 : printf ("SgTemplateDeclaration::get_name = %p = %s \n",this,this->class_name().c_str());
142809 : #endif
142810 :
142811 0 : return p_name;
142812 : }
142813 :
142814 : void
142815 0 : SgTemplateDeclaration::set_name ( SgName name )
142816 : {
142817 0 : ROSE_ASSERT (this != NULL);
142818 :
142819 : #if 0
142820 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142821 : // used to trigger marking transformations for the token-based unparsing.
142822 : printf ("SgTemplateDeclaration::set_name = %p = %s \n",this,this->class_name().c_str());
142823 : #endif
142824 :
142825 0 : set_isModified(true);
142826 :
142827 0 : p_name = name;
142828 0 : }
142829 :
142830 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142831 :
142832 :
142833 : // End of memberFunctionString
142834 : // Start of memberFunctionString
142835 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142836 :
142837 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142838 :
142839 : SgName
142840 0 : SgTemplateDeclaration::get_string () const
142841 : {
142842 0 : ROSE_ASSERT (this != NULL);
142843 :
142844 : #if 0
142845 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142846 : // used to trigger marking transformations for the token-based unparsing.
142847 : printf ("SgTemplateDeclaration::get_string = %p = %s \n",this,this->class_name().c_str());
142848 : #endif
142849 :
142850 0 : return p_string;
142851 : }
142852 :
142853 : void
142854 0 : SgTemplateDeclaration::set_string ( SgName string )
142855 : {
142856 0 : ROSE_ASSERT (this != NULL);
142857 :
142858 : #if 0
142859 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142860 : // used to trigger marking transformations for the token-based unparsing.
142861 : printf ("SgTemplateDeclaration::set_string = %p = %s \n",this,this->class_name().c_str());
142862 : #endif
142863 :
142864 0 : set_isModified(true);
142865 :
142866 0 : p_string = string;
142867 0 : }
142868 :
142869 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142870 :
142871 :
142872 : // End of memberFunctionString
142873 : // Start of memberFunctionString
142874 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142875 :
142876 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142877 :
142878 : SgTemplateDeclaration::template_type_enum
142879 0 : SgTemplateDeclaration::get_template_kind () const
142880 : {
142881 0 : ROSE_ASSERT (this != NULL);
142882 :
142883 : #if 0
142884 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142885 : // used to trigger marking transformations for the token-based unparsing.
142886 : printf ("SgTemplateDeclaration::get_template_kind = %p = %s \n",this,this->class_name().c_str());
142887 : #endif
142888 :
142889 0 : return p_template_kind;
142890 : }
142891 :
142892 : void
142893 0 : SgTemplateDeclaration::set_template_kind ( SgTemplateDeclaration::template_type_enum template_kind )
142894 : {
142895 0 : ROSE_ASSERT (this != NULL);
142896 :
142897 : #if 0
142898 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142899 : // used to trigger marking transformations for the token-based unparsing.
142900 : printf ("SgTemplateDeclaration::set_template_kind = %p = %s \n",this,this->class_name().c_str());
142901 : #endif
142902 :
142903 0 : set_isModified(true);
142904 :
142905 0 : p_template_kind = template_kind;
142906 0 : }
142907 :
142908 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142909 :
142910 :
142911 : // End of memberFunctionString
142912 : // Start of memberFunctionString
142913 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
142914 :
142915 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142916 :
142917 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
142918 : const SgTemplateParameterPtrList &
142919 0 : SgTemplateDeclaration::get_templateParameters () const
142920 : {
142921 0 : assert (this != NULL);
142922 0 : return p_templateParameters;
142923 : }
142924 :
142925 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
142926 : SgTemplateParameterPtrList &
142927 0 : SgTemplateDeclaration::get_templateParameters ()
142928 : {
142929 0 : assert (this != NULL);
142930 :
142931 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
142932 : // As a rule only set_ access functions can set the isModified flag.
142933 : // set_isModified(true);
142934 :
142935 0 : return p_templateParameters;
142936 : }
142937 :
142938 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142939 :
142940 :
142941 : // End of memberFunctionString
142942 : // Start of memberFunctionString
142943 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142944 :
142945 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142946 :
142947 : SgScopeStatement*
142948 0 : SgTemplateDeclaration::get_scope () const
142949 : {
142950 0 : ROSE_ASSERT (this != NULL);
142951 :
142952 : #if 0
142953 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142954 : // used to trigger marking transformations for the token-based unparsing.
142955 : printf ("SgTemplateDeclaration::get_scope = %p = %s \n",this,this->class_name().c_str());
142956 : #endif
142957 :
142958 0 : return p_scope;
142959 : }
142960 :
142961 : void
142962 0 : SgTemplateDeclaration::set_scope ( SgScopeStatement* scope )
142963 : {
142964 0 : ROSE_ASSERT (this != NULL);
142965 :
142966 : #if 0
142967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
142968 : // used to trigger marking transformations for the token-based unparsing.
142969 : printf ("SgTemplateDeclaration::set_scope = %p = %s \n",this,this->class_name().c_str());
142970 : #endif
142971 :
142972 0 : set_isModified(true);
142973 :
142974 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
142975 : if (p_scope != NULL && scope != NULL && p_scope != scope)
142976 : {
142977 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
142978 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
142979 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
142980 : ROSE_ASSERT(false);
142981 : #endif
142982 : }
142983 : #endif
142984 0 : p_scope = scope;
142985 0 : }
142986 :
142987 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
142988 :
142989 :
142990 : // End of memberFunctionString
142991 : // Start of memberFunctionString
142992 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
142993 :
142994 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
142995 :
142996 : SgDeclarationScope*
142997 0 : SgTemplateDeclaration::get_nonreal_decl_scope () const
142998 : {
142999 0 : ROSE_ASSERT (this != NULL);
143000 :
143001 : #if 0
143002 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143003 : // used to trigger marking transformations for the token-based unparsing.
143004 : printf ("SgTemplateDeclaration::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
143005 : #endif
143006 :
143007 0 : return p_nonreal_decl_scope;
143008 : }
143009 :
143010 : void
143011 0 : SgTemplateDeclaration::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
143012 : {
143013 0 : ROSE_ASSERT (this != NULL);
143014 :
143015 : #if 0
143016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143017 : // used to trigger marking transformations for the token-based unparsing.
143018 : printf ("SgTemplateDeclaration::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
143019 : #endif
143020 :
143021 0 : set_isModified(true);
143022 :
143023 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
143024 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
143025 : {
143026 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
143027 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
143028 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
143029 : ROSE_ASSERT(false);
143030 : #endif
143031 : }
143032 : #endif
143033 0 : p_nonreal_decl_scope = nonreal_decl_scope;
143034 0 : }
143035 :
143036 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
143037 :
143038 :
143039 : // End of memberFunctionString
143040 : // Start of memberFunctionString
143041 : /* #line 16502 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
143042 :
143043 : void
143044 0 : SgTemplateDeclaration::post_construction_initialization()
143045 : {
143046 : // Nothing to do here.
143047 0 : }
143048 :
143049 : // DQ (9/8/2004): added support for qualified names
143050 : SgName
143051 0 : SgTemplateDeclaration::get_qualified_name() const
143052 : {
143053 : // DQ (8/28/2005): Modified to make this function consistent other get_qualified_name functions
143054 : // It previously only returned the name of the scope.
143055 : #if 0
143056 : // printf ("In SgTemplateDeclaration::get_qualified_name() name = %s \n",get_name().str());
143057 :
143058 : SgName returnName;
143059 : string returnNameString;
143060 :
143061 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
143062 : SgScopeStatement* scope = get_scope();
143063 : ROSE_ASSERT(scope != NULL);
143064 :
143065 : // DQ (9/8/2004): Don't use the template name as is stored (which is a mangled name from EDG)
143066 : // returnName = scope->get_qualified_name() << "::" << get_name().str();
143067 : returnName = scope->get_qualified_name();
143068 : // printf ("In SgTemplateDeclaration::get_qualified_name() returnName = %s \n",returnName.str());
143069 :
143070 : return returnName;
143071 : #else
143072 : // printf ("In SgTemplateDeclaration::get_qualified_name() name = %s \n",get_name().str());
143073 :
143074 0 : SgName returnName;
143075 :
143076 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
143077 0 : SgScopeStatement* scope = get_scope();
143078 0 : ROSE_ASSERT(scope != NULL);
143079 :
143080 0 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
143081 :
143082 : // printf ("In SgTemplateDeclaration::get_qualified_name() returnName = %s \n",returnName.str());
143083 :
143084 0 : return returnName;
143085 : #endif
143086 : }
143087 :
143088 : bool
143089 0 : SgTemplateDeclaration::hasExplicitScope() const
143090 : {
143091 : // This function reports that this IR node stores its scope explicitly.
143092 :
143093 0 : return true;
143094 : }
143095 :
143096 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
143097 : SgName
143098 0 : SgTemplateDeclaration::get_mangled_name(void) const
143099 : {
143100 : #if 0
143101 : SgName returnName;
143102 :
143103 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
143104 : SgScopeStatement* scope = get_scope();
143105 : ROSE_ASSERT(scope != NULL);
143106 :
143107 : // This is a poor way to handle the generation of a mangled name (will be improved)
143108 : // returnName = get_qualified_name() + SgName("_template_declaration_") + get_name();
143109 : returnName = scope->get_mangled_name() + SgName("_template_declaration_") + get_name();
143110 :
143111 : return returnName;
143112 : #else
143113 : #if 0
143114 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
143115 : SgTemplateDeclaration* declaration = const_cast<SgTemplateDeclaration*>(this);
143116 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
143117 : if (i != p_globalMangledNameMap.end())
143118 : {
143119 : return i->second.c_str();
143120 : }
143121 : #endif
143122 0 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgTemplateDeclaration*>(this));
143123 0 : if (mangledNameString.empty() == false)
143124 : {
143125 : #if 0
143126 : printf ("In SgTemplateDeclaration::get_mangled_name(): (FOUND in MangledNameFromCache): returning mangledNameString = %s \n",mangledNameString.c_str());
143127 : #endif
143128 : // return i->second.c_str();
143129 0 : return mangledNameString;
143130 : }
143131 : else
143132 : {
143133 : // SgName mangledName = get_scope()->get_mangled_name() + SgName("_template_declaration_") + get_name();
143134 0 : SgScopeStatement* scope = get_scope();
143135 0 : ROSE_ASSERT(scope != NULL);
143136 0 : SgName mangledName = scope->get_mangled_name() + SgName("_template_declaration_") + get_name();
143137 : #if 0
143138 : printf ("In SgTemplateDeclaration::get_mangled_name(): (NOT found in MangledNameFromCache): returning mangledName = %s \n",mangledName.str());
143139 : #endif
143140 : // p_globalMangledNameMap[declaration] = mangledName;
143141 0 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgTemplateDeclaration*>(this),mangledName);
143142 0 : return mangledName;
143143 : }
143144 : #endif
143145 : }
143146 :
143147 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
143148 : SgSymbol*
143149 0 : SgTemplateDeclaration::get_symbol_from_symbol_table() const
143150 : {
143151 0 : ROSE_ASSERT(get_scope() != NULL);
143152 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
143153 : // return get_scope()->get_symbol_table()->find(this);
143154 0 : return get_scope()->find_symbol_from_declaration(this);
143155 : }
143156 :
143157 :
143158 : SgType*
143159 0 : SgTemplateDeclaration::get_type()
143160 : {
143161 : // DQ (12/12/2011): Added function to support "get_type()" on the derived IR nodes. Maybe
143162 : // this should be a virtual function, but no, because the return types at the derived classes
143163 : // are different and some compilers (MS Visual Studio) do not support covariant return types.
143164 :
143165 0 : SgType* returnType = NULL;
143166 :
143167 : #if 0
143168 : switch (variantT())
143169 : {
143170 : case V_SgTemplateClassDeclaration:
143171 : {
143172 : SgTemplateClassDeclaration* decl = isSgTemplateClassDeclaration(this);
143173 : returnType = decl->get_type();
143174 : break;
143175 : }
143176 :
143177 : case V_SgTemplateFunctionDeclaration:
143178 : {
143179 : SgTemplateFunctionDeclaration* decl = isSgTemplateFunctionDeclaration(this);
143180 : returnType = decl->get_type();
143181 : break;
143182 : }
143183 :
143184 : case V_SgTemplateMemberFunctionDeclaration:
143185 : {
143186 : SgTemplateMemberFunctionDeclaration* decl = isSgTemplateMemberFunctionDeclaration(this);
143187 : returnType = decl->get_type();
143188 : break;
143189 : }
143190 :
143191 : case V_SgTemplateVariableDeclaration:
143192 : {
143193 : SgTemplateVariableDeclaration* decl = isSgTemplateVariableDeclaration(this);
143194 : returnType = decl->get_type();
143195 : break;
143196 : }
143197 :
143198 : default:
143199 : {
143200 : printf ("Default reached in SgTemplateDeclaration::get_type() variant = %d \n",variantT());
143201 : ROSE_ASSERT(false);
143202 : }
143203 : }
143204 : #else
143205 0 : printf ("This is a part of the new design for ROSE to have the SgTemplateClassDeclaration derived from the SgClassDeclaration (same for functions, member functions, and varaiable declarations). \n");
143206 0 : ROSE_ASSERT(false);
143207 : #endif
143208 :
143209 : ROSE_ASSERT(returnType != NULL);
143210 : return returnType;
143211 : }
143212 :
143213 :
143214 :
143215 : // End of memberFunctionString
143216 : // Start of memberFunctionString
143217 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
143218 :
143219 : // *** COMMON CODE SECTION BEGINS HERE ***
143220 :
143221 : #if 0
143222 : int
143223 : SgTemplateDeclaration::getVariant() const
143224 : {
143225 : // This function is used in ROSE while "variant()" is used in SAGE
143226 : assert(this != NULL);
143227 : return variant();
143228 : }
143229 : #endif
143230 :
143231 : // This function is used in ROSE in treeTraversal code
143232 : // eventually replaces getVariant() and variant()
143233 : // though after variant() has been removed for a while we will
143234 : // want to change the name of variantT() back to variant()
143235 : // (since the "T" was ment to stand for temporary).
143236 : // When this happens the variantT() will be depricated.
143237 : VariantT
143238 0 : SgTemplateDeclaration::variantT() const
143239 : {
143240 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
143241 0 : ROSE_ASSERT(this != NULL);
143242 0 : return V_SgTemplateDeclaration;
143243 : }
143244 :
143245 : #if 0
143246 : int
143247 : SgTemplateDeclaration::variant() const
143248 : {
143249 : // This function is used in SAGE
143250 : ROSE_ASSERT(this != NULL);
143251 : return TEMPLATE_DECL_STMT;
143252 : }
143253 : #endif
143254 :
143255 : ROSE_DLL_API const char*
143256 0 : SgTemplateDeclaration::sage_class_name() const
143257 : {
143258 0 : ROSE_ASSERT(this != NULL);
143259 0 : return "SgTemplateDeclaration";
143260 : }
143261 :
143262 : std::string
143263 0 : SgTemplateDeclaration::class_name() const
143264 : {
143265 0 : ROSE_ASSERT(this != NULL);
143266 0 : return "SgTemplateDeclaration";
143267 : }
143268 :
143269 : // DQ (11/26/2005): Support for visitor pattern mechanims
143270 : // (inferior to ROSE traversal mechanism, experimental).
143271 : void
143272 0 : SgTemplateDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
143273 : {
143274 0 : ROSE_ASSERT(this != NULL);
143275 0 : visitor.visit(this);
143276 0 : }
143277 :
143278 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
143279 0 : void SgTemplateDeclaration::accept (ROSE_VisitorPattern & visitor) {
143280 0 : ROSE_ASSERT(this != NULL);
143281 0 : visitor.visit(this);
143282 0 : }
143283 :
143284 : SgTemplateDeclaration*
143285 0 : SgTemplateDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
143286 : {
143287 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
143288 : // This function is currently only supported for the AST used the represent Binary executables.
143289 : if (0 /* isSgAsmNode(this) != NULL */)
143290 : {
143291 : // Support for regex specification.
143292 : std::string prefixCode = "REGEX:";
143293 : addNewAttribute(prefixCode + s,a);
143294 : }
143295 : #endif
143296 :
143297 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
143298 0 : return this;
143299 : }
143300 :
143301 : // *** COMMON CODE SECTION ENDS HERE ***
143302 :
143303 :
143304 : // End of memberFunctionString
143305 : // Start of memberFunctionString
143306 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
143307 :
143308 :
143309 : #if 0
143310 : //! Error checking support
143311 : /*! Verifies the following:
143312 : - working getVariant() member function
143313 : - calls base class's error() member function
143314 : Every class has one of these functions.
143315 : */
143316 : bool
143317 : SgTemplateDeclaration::error()
143318 : {
143319 : // Put error checking here
143320 :
143321 : ROSE_ASSERT (this != NULL);
143322 : if (getVariant() != TEMPLATE_DECL_STMT)
143323 : {
143324 : printf ("Error in SgTemplateDeclaration::error(): SgTemplateDeclaration object has a %s variant \n",
143325 : Cxx_GrammarTerminalNames[getVariant()].name);
143326 : // printf ("Error in SgTemplateDeclaration::error() \n");
143327 : ROSE_ABORT();
143328 : }
143329 :
143330 : ROSE_ASSERT (getVariant() == TEMPLATE_DECL_STMT);
143331 : return SgDeclarationStatement::error();
143332 : }
143333 : #endif
143334 :
143335 :
143336 :
143337 : // End of memberFunctionString
143338 :
143339 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
143340 :
143341 4447730 : SgTemplateDeclaration* isSgTemplateDeclaration ( SgNode* inputDerivedClassPointer )
143342 : {
143343 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
143344 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
143345 : // So to fix this we return NULL directly when the input is NULL and avoid the
143346 : // dynamic_cast in this case. This is likely a performance improvement as well.
143347 : // return dynamic_cast<SgTemplateDeclaration*>(inputDerivedClassPointer);
143348 : // Milind Chabbi (8/28/2013): isSgTemplateDeclaration uses table-driven castability instead of c++ default dynamic_cast
143349 : // this improves the running time performance by 10-20%.
143350 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateDeclaration*>(inputDerivedClassPointer);
143351 4447730 : return IS_SgTemplateDeclaration_FAST_MACRO(inputDerivedClassPointer);
143352 : }
143353 :
143354 : // DQ (11/8/2003): Added version of functions taking const pointer
143355 0 : const SgTemplateDeclaration* isSgTemplateDeclaration ( const SgNode* inputDerivedClassPointer )
143356 : {
143357 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
143358 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
143359 : // So to fix this we return NULL directly when the input is NULL and avoid the
143360 : // dynamic_cast in this case. This is likely a performance improvement as well.
143361 : // return dynamic_cast<const SgTemplateDeclaration*>(inputDerivedClassPointer);
143362 : // Milind Chabbi (8/28/2013): isSgTemplateDeclaration uses table-driven castability instead of c++ default dynamic_cast
143363 : // this improves the running time performance by 10-20%.
143364 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateDeclaration*>(inputDerivedClassPointer);
143365 0 : return IS_SgTemplateDeclaration_FAST_MACRO(inputDerivedClassPointer);
143366 : }
143367 :
143368 :
143369 :
143370 : /* #line 143371 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143371 :
143372 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
143373 :
143374 : /**
143375 : \brief Generated destructor
143376 :
143377 : This destructor is automatically generated (by ROSETTA). This destructor
143378 : only frees memory of data members associated with the parts of the current IR node which
143379 : are NOT traversed. Those data members that are part of a traversal can be freed using
143380 : a traversal (calling this destructor on all children in a post-order traversal). Such
143381 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
143382 :
143383 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
143384 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
143385 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
143386 :
143387 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
143388 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
143389 : pointers are not yet implemented to call delete on eash pointer in the container.
143390 : (This could be done by derivation from the STL containers to define containers that
143391 : automatically deleted their members.)
143392 :
143393 : */
143394 0 : SgTemplateDeclaration::~SgTemplateDeclaration () {
143395 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
143396 :
143397 0 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
143398 :
143399 : // case: not a listType for name
143400 0 : p_name = ""; // non list case
143401 : // case: not a listType for string
143402 0 : p_string = ""; // non list case
143403 : // case: not a listType for template_kind
143404 0 : p_template_kind = SgTemplateDeclaration::e_template_none; // non list case
143405 : // case: listType for templateParameters
143406 : // case: listType (typeIsPointerToList == false) for templateParameters
143407 0 : p_templateParameters.erase(p_templateParameters.begin(),p_templateParameters.end());
143408 : // case: not a listType for scope
143409 0 : p_scope = NULL; // non list case
143410 : // case: not a listType for nonreal_decl_scope
143411 0 : p_nonreal_decl_scope = NULL; // non list case
143412 :
143413 : }
143414 :
143415 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
143416 0 : }
143417 :
143418 :
143419 : /* #line 143420 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143420 :
143421 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
143422 :
143423 : // Generated constructor
143424 0 : SgTemplateDeclaration::SgTemplateDeclaration ( Sg_File_Info* startOfConstruct, SgName name )
143425 0 : : SgDeclarationStatement(startOfConstruct)
143426 : {
143427 : #ifdef DEBUG
143428 : // printf ("In SgTemplateDeclaration::SgTemplateDeclaration (Sg_File_Info* startOfConstruct, SgName name) sage_class_name() = %s \n",sage_class_name());
143429 : #endif
143430 : #if 0
143431 : // debugging information!
143432 : printf ("In SgTemplateDeclaration::SgTemplateDeclaration (Sg_File_Info* startOfConstruct, SgName name): this = %p = %s \n",this,this->class_name().c_str());
143433 : #endif
143434 :
143435 0 : p_name = name;
143436 0 : p_string = "";
143437 0 : p_template_kind = SgTemplateDeclaration::e_template_none;
143438 0 : p_templateParameters = SgTemplateParameterPtrList();
143439 0 : p_scope = NULL;
143440 0 : p_nonreal_decl_scope = NULL;
143441 :
143442 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
143443 :
143444 : #if 0
143445 : // DQ (7/30/2014): Call a virtual function.
143446 : std::string s = this->class_name();
143447 : #endif
143448 :
143449 : // Test the variant virtual function
143450 : // assert(TEMPLATE_DECL_STMT == variant());
143451 0 : assert(TEMPLATE_DECL_STMT == this->variant());
143452 0 : ROSE_ASSERT(TEMPLATE_DECL_STMT == (int)(this->variantT()));
143453 0 : post_construction_initialization();
143454 :
143455 : // Test the isSgTemplateDeclaration() function since it has been problematic
143456 0 : assert(isSgTemplateDeclaration(this) != NULL);
143457 0 : }
143458 :
143459 : // Generated constructor (all data members)
143460 :
143461 : /* #line 143462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143462 :
143463 :
143464 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
143465 :
143466 :
143467 : // ********************************************************
143468 : // member functions common across all array grammar objects
143469 : // ********************************************************
143470 :
143471 :
143472 :
143473 : /* #line 143474 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143474 :
143475 :
143476 :
143477 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
143478 :
143479 : // ********************************************************
143480 : // member functions specific to each node in the grammar
143481 : // ********************************************************
143482 :
143483 :
143484 : /* #line 143485 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143485 :
143486 : // Start of memberFunctionString
143487 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
143488 :
143489 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
143490 :
143491 : SgDeclarationStatement*
143492 2612 : SgTemplateInstantiationDirectiveStatement::get_declaration () const
143493 : {
143494 2612 : ROSE_ASSERT (this != NULL);
143495 :
143496 : #if 0
143497 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143498 : // used to trigger marking transformations for the token-based unparsing.
143499 : printf ("SgTemplateInstantiationDirectiveStatement::get_declaration = %p = %s \n",this,this->class_name().c_str());
143500 : #endif
143501 :
143502 2612 : return p_declaration;
143503 : }
143504 :
143505 : void
143506 0 : SgTemplateInstantiationDirectiveStatement::set_declaration ( SgDeclarationStatement* declaration )
143507 : {
143508 0 : ROSE_ASSERT (this != NULL);
143509 :
143510 : #if 0
143511 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143512 : // used to trigger marking transformations for the token-based unparsing.
143513 : printf ("SgTemplateInstantiationDirectiveStatement::set_declaration = %p = %s \n",this,this->class_name().c_str());
143514 : #endif
143515 :
143516 0 : set_isModified(true);
143517 :
143518 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
143519 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
143520 : {
143521 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
143522 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
143523 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
143524 : ROSE_ASSERT(false);
143525 : #endif
143526 : }
143527 : #endif
143528 0 : p_declaration = declaration;
143529 0 : }
143530 :
143531 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
143532 :
143533 :
143534 : // End of memberFunctionString
143535 : // Start of memberFunctionString
143536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
143537 :
143538 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
143539 :
143540 : bool
143541 0 : SgTemplateInstantiationDirectiveStatement::get_do_not_instantiate () const
143542 : {
143543 0 : ROSE_ASSERT (this != NULL);
143544 :
143545 : #if 0
143546 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143547 : // used to trigger marking transformations for the token-based unparsing.
143548 : printf ("SgTemplateInstantiationDirectiveStatement::get_do_not_instantiate = %p = %s \n",this,this->class_name().c_str());
143549 : #endif
143550 :
143551 0 : return p_do_not_instantiate;
143552 : }
143553 :
143554 : void
143555 996 : SgTemplateInstantiationDirectiveStatement::set_do_not_instantiate ( bool do_not_instantiate )
143556 : {
143557 996 : ROSE_ASSERT (this != NULL);
143558 :
143559 : #if 0
143560 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143561 : // used to trigger marking transformations for the token-based unparsing.
143562 : printf ("SgTemplateInstantiationDirectiveStatement::set_do_not_instantiate = %p = %s \n",this,this->class_name().c_str());
143563 : #endif
143564 :
143565 996 : set_isModified(true);
143566 :
143567 996 : p_do_not_instantiate = do_not_instantiate;
143568 996 : }
143569 :
143570 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
143571 :
143572 :
143573 : // End of memberFunctionString
143574 : // Start of memberFunctionString
143575 : /* #line 17866 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
143576 :
143577 :
143578 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
143579 : SgName
143580 870 : SgTemplateInstantiationDirectiveStatement::get_mangled_name(void) const
143581 : {
143582 870 : SgName returnName;
143583 :
143584 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
143585 870 : SgScopeStatement* scope = get_scope();
143586 870 : ROSE_ASSERT(scope != NULL);
143587 :
143588 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
143589 : // This is a poor way to handle the generation of a mangled name (will be improved)
143590 : // returnName = scope->get_qualified_name() + SgName("_template_instantiation_directive_") + get_declaration()->get_mangled_name();
143591 870 : returnName = scope->get_mangled_name() + SgName("_template_instantiation_directive_") + get_declaration()->get_mangled_name();
143592 :
143593 870 : return returnName;
143594 : }
143595 :
143596 :
143597 :
143598 : // End of memberFunctionString
143599 : // Start of memberFunctionString
143600 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
143601 :
143602 : void
143603 996 : SgTemplateInstantiationDirectiveStatement::post_construction_initialization()
143604 : {
143605 996 : }
143606 :
143607 :
143608 :
143609 : // End of memberFunctionString
143610 : // Start of memberFunctionString
143611 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
143612 :
143613 : // *** COMMON CODE SECTION BEGINS HERE ***
143614 :
143615 : #if 0
143616 : int
143617 : SgTemplateInstantiationDirectiveStatement::getVariant() const
143618 : {
143619 : // This function is used in ROSE while "variant()" is used in SAGE
143620 : assert(this != NULL);
143621 : return variant();
143622 : }
143623 : #endif
143624 :
143625 : // This function is used in ROSE in treeTraversal code
143626 : // eventually replaces getVariant() and variant()
143627 : // though after variant() has been removed for a while we will
143628 : // want to change the name of variantT() back to variant()
143629 : // (since the "T" was ment to stand for temporary).
143630 : // When this happens the variantT() will be depricated.
143631 : VariantT
143632 254376 : SgTemplateInstantiationDirectiveStatement::variantT() const
143633 : {
143634 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
143635 254376 : ROSE_ASSERT(this != NULL);
143636 254376 : return V_SgTemplateInstantiationDirectiveStatement;
143637 : }
143638 :
143639 : #if 0
143640 : int
143641 : SgTemplateInstantiationDirectiveStatement::variant() const
143642 : {
143643 : // This function is used in SAGE
143644 : ROSE_ASSERT(this != NULL);
143645 : return TEMPLATE_INST_DIRECTIVE_STMT;
143646 : }
143647 : #endif
143648 :
143649 : ROSE_DLL_API const char*
143650 0 : SgTemplateInstantiationDirectiveStatement::sage_class_name() const
143651 : {
143652 0 : ROSE_ASSERT(this != NULL);
143653 0 : return "SgTemplateInstantiationDirectiveStatement";
143654 : }
143655 :
143656 : std::string
143657 870 : SgTemplateInstantiationDirectiveStatement::class_name() const
143658 : {
143659 870 : ROSE_ASSERT(this != NULL);
143660 870 : return "SgTemplateInstantiationDirectiveStatement";
143661 : }
143662 :
143663 : // DQ (11/26/2005): Support for visitor pattern mechanims
143664 : // (inferior to ROSE traversal mechanism, experimental).
143665 : void
143666 16988 : SgTemplateInstantiationDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
143667 : {
143668 16988 : ROSE_ASSERT(this != NULL);
143669 16988 : visitor.visit(this);
143670 16988 : }
143671 :
143672 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
143673 0 : void SgTemplateInstantiationDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
143674 0 : ROSE_ASSERT(this != NULL);
143675 0 : visitor.visit(this);
143676 0 : }
143677 :
143678 : SgTemplateInstantiationDirectiveStatement*
143679 0 : SgTemplateInstantiationDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
143680 : {
143681 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
143682 : // This function is currently only supported for the AST used the represent Binary executables.
143683 : if (0 /* isSgAsmNode(this) != NULL */)
143684 : {
143685 : // Support for regex specification.
143686 : std::string prefixCode = "REGEX:";
143687 : addNewAttribute(prefixCode + s,a);
143688 : }
143689 : #endif
143690 :
143691 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
143692 0 : return this;
143693 : }
143694 :
143695 : // *** COMMON CODE SECTION ENDS HERE ***
143696 :
143697 :
143698 : // End of memberFunctionString
143699 : // Start of memberFunctionString
143700 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
143701 :
143702 :
143703 : #if 0
143704 : //! Error checking support
143705 : /*! Verifies the following:
143706 : - working getVariant() member function
143707 : - calls base class's error() member function
143708 : Every class has one of these functions.
143709 : */
143710 : bool
143711 : SgTemplateInstantiationDirectiveStatement::error()
143712 : {
143713 : // Put error checking here
143714 :
143715 : ROSE_ASSERT (this != NULL);
143716 : if (getVariant() != TEMPLATE_INST_DIRECTIVE_STMT)
143717 : {
143718 : printf ("Error in SgTemplateInstantiationDirectiveStatement::error(): SgTemplateInstantiationDirectiveStatement object has a %s variant \n",
143719 : Cxx_GrammarTerminalNames[getVariant()].name);
143720 : // printf ("Error in SgTemplateInstantiationDirectiveStatement::error() \n");
143721 : ROSE_ABORT();
143722 : }
143723 :
143724 : ROSE_ASSERT (getVariant() == TEMPLATE_INST_DIRECTIVE_STMT);
143725 : return SgDeclarationStatement::error();
143726 : }
143727 : #endif
143728 :
143729 :
143730 :
143731 : // End of memberFunctionString
143732 :
143733 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
143734 :
143735 5251350 : SgTemplateInstantiationDirectiveStatement* isSgTemplateInstantiationDirectiveStatement ( SgNode* inputDerivedClassPointer )
143736 : {
143737 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
143738 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
143739 : // So to fix this we return NULL directly when the input is NULL and avoid the
143740 : // dynamic_cast in this case. This is likely a performance improvement as well.
143741 : // return dynamic_cast<SgTemplateInstantiationDirectiveStatement*>(inputDerivedClassPointer);
143742 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
143743 : // this improves the running time performance by 10-20%.
143744 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateInstantiationDirectiveStatement*>(inputDerivedClassPointer);
143745 5251350 : return IS_SgTemplateInstantiationDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
143746 : }
143747 :
143748 : // DQ (11/8/2003): Added version of functions taking const pointer
143749 0 : const SgTemplateInstantiationDirectiveStatement* isSgTemplateInstantiationDirectiveStatement ( const SgNode* inputDerivedClassPointer )
143750 : {
143751 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
143752 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
143753 : // So to fix this we return NULL directly when the input is NULL and avoid the
143754 : // dynamic_cast in this case. This is likely a performance improvement as well.
143755 : // return dynamic_cast<const SgTemplateInstantiationDirectiveStatement*>(inputDerivedClassPointer);
143756 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
143757 : // this improves the running time performance by 10-20%.
143758 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateInstantiationDirectiveStatement*>(inputDerivedClassPointer);
143759 0 : return IS_SgTemplateInstantiationDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
143760 : }
143761 :
143762 :
143763 :
143764 : /* #line 143765 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143765 :
143766 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
143767 :
143768 : /**
143769 : \brief Generated destructor
143770 :
143771 : This destructor is automatically generated (by ROSETTA). This destructor
143772 : only frees memory of data members associated with the parts of the current IR node which
143773 : are NOT traversed. Those data members that are part of a traversal can be freed using
143774 : a traversal (calling this destructor on all children in a post-order traversal). Such
143775 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
143776 :
143777 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
143778 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
143779 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
143780 :
143781 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
143782 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
143783 : pointers are not yet implemented to call delete on eash pointer in the container.
143784 : (This could be done by derivation from the STL containers to define containers that
143785 : automatically deleted their members.)
143786 :
143787 : */
143788 496 : SgTemplateInstantiationDirectiveStatement::~SgTemplateInstantiationDirectiveStatement () {
143789 248 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
143790 :
143791 :
143792 : // case: not a listType for declaration
143793 248 : p_declaration = NULL; // non list case
143794 : // case: not a listType for do_not_instantiate
143795 248 : p_do_not_instantiate = false; // non list case
143796 :
143797 : }
143798 :
143799 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
143800 496 : }
143801 :
143802 :
143803 : /* #line 143804 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143804 :
143805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
143806 :
143807 : // Generated constructor
143808 0 : SgTemplateInstantiationDirectiveStatement::SgTemplateInstantiationDirectiveStatement ( Sg_File_Info* startOfConstruct, SgDeclarationStatement* declaration )
143809 0 : : SgDeclarationStatement(startOfConstruct)
143810 : {
143811 : #ifdef DEBUG
143812 : // printf ("In SgTemplateInstantiationDirectiveStatement::SgTemplateInstantiationDirectiveStatement (Sg_File_Info* startOfConstruct, SgDeclarationStatement* declaration) sage_class_name() = %s \n",sage_class_name());
143813 : #endif
143814 : #if 0
143815 : // debugging information!
143816 : printf ("In SgTemplateInstantiationDirectiveStatement::SgTemplateInstantiationDirectiveStatement (Sg_File_Info* startOfConstruct, SgDeclarationStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
143817 : #endif
143818 :
143819 0 : p_declaration = declaration;
143820 0 : p_do_not_instantiate = false;
143821 :
143822 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
143823 :
143824 : #if 0
143825 : // DQ (7/30/2014): Call a virtual function.
143826 : std::string s = this->class_name();
143827 : #endif
143828 :
143829 : // Test the variant virtual function
143830 : // assert(TEMPLATE_INST_DIRECTIVE_STMT == variant());
143831 0 : assert(TEMPLATE_INST_DIRECTIVE_STMT == this->variant());
143832 0 : ROSE_ASSERT(TEMPLATE_INST_DIRECTIVE_STMT == (int)(this->variantT()));
143833 0 : post_construction_initialization();
143834 :
143835 : // Test the isSgTemplateInstantiationDirectiveStatement() function since it has been problematic
143836 0 : assert(isSgTemplateInstantiationDirectiveStatement(this) != NULL);
143837 0 : }
143838 :
143839 : // Generated constructor (all data members)
143840 :
143841 : /* #line 143842 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143842 :
143843 :
143844 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
143845 :
143846 :
143847 : // ********************************************************
143848 : // member functions common across all array grammar objects
143849 : // ********************************************************
143850 :
143851 :
143852 :
143853 : /* #line 143854 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143854 :
143855 :
143856 :
143857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
143858 :
143859 : // ********************************************************
143860 : // member functions specific to each node in the grammar
143861 : // ********************************************************
143862 :
143863 :
143864 : /* #line 143865 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
143865 :
143866 : // Start of memberFunctionString
143867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
143868 :
143869 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
143870 :
143871 : SgName
143872 0 : SgUseStatement::get_name () const
143873 : {
143874 0 : ROSE_ASSERT (this != NULL);
143875 :
143876 : #if 0
143877 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143878 : // used to trigger marking transformations for the token-based unparsing.
143879 : printf ("SgUseStatement::get_name = %p = %s \n",this,this->class_name().c_str());
143880 : #endif
143881 :
143882 0 : return p_name;
143883 : }
143884 :
143885 : void
143886 0 : SgUseStatement::set_name ( SgName name )
143887 : {
143888 0 : ROSE_ASSERT (this != NULL);
143889 :
143890 : #if 0
143891 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143892 : // used to trigger marking transformations for the token-based unparsing.
143893 : printf ("SgUseStatement::set_name = %p = %s \n",this,this->class_name().c_str());
143894 : #endif
143895 :
143896 0 : set_isModified(true);
143897 :
143898 0 : p_name = name;
143899 0 : }
143900 :
143901 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
143902 :
143903 :
143904 : // End of memberFunctionString
143905 : // Start of memberFunctionString
143906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
143907 :
143908 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
143909 :
143910 : bool
143911 0 : SgUseStatement::get_only_option () const
143912 : {
143913 0 : ROSE_ASSERT (this != NULL);
143914 :
143915 : #if 0
143916 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143917 : // used to trigger marking transformations for the token-based unparsing.
143918 : printf ("SgUseStatement::get_only_option = %p = %s \n",this,this->class_name().c_str());
143919 : #endif
143920 :
143921 0 : return p_only_option;
143922 : }
143923 :
143924 : void
143925 0 : SgUseStatement::set_only_option ( bool only_option )
143926 : {
143927 0 : ROSE_ASSERT (this != NULL);
143928 :
143929 : #if 0
143930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143931 : // used to trigger marking transformations for the token-based unparsing.
143932 : printf ("SgUseStatement::set_only_option = %p = %s \n",this,this->class_name().c_str());
143933 : #endif
143934 :
143935 0 : set_isModified(true);
143936 :
143937 0 : p_only_option = only_option;
143938 0 : }
143939 :
143940 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
143941 :
143942 :
143943 : // End of memberFunctionString
143944 : // Start of memberFunctionString
143945 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
143946 :
143947 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
143948 :
143949 : std::string
143950 0 : SgUseStatement::get_module_nature () const
143951 : {
143952 0 : ROSE_ASSERT (this != NULL);
143953 :
143954 : #if 0
143955 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143956 : // used to trigger marking transformations for the token-based unparsing.
143957 : printf ("SgUseStatement::get_module_nature = %p = %s \n",this,this->class_name().c_str());
143958 : #endif
143959 :
143960 0 : return p_module_nature;
143961 : }
143962 :
143963 : void
143964 0 : SgUseStatement::set_module_nature ( std::string module_nature )
143965 : {
143966 0 : ROSE_ASSERT (this != NULL);
143967 :
143968 : #if 0
143969 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
143970 : // used to trigger marking transformations for the token-based unparsing.
143971 : printf ("SgUseStatement::set_module_nature = %p = %s \n",this,this->class_name().c_str());
143972 : #endif
143973 :
143974 0 : set_isModified(true);
143975 :
143976 0 : p_module_nature = module_nature;
143977 0 : }
143978 :
143979 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
143980 :
143981 :
143982 : // End of memberFunctionString
143983 : // Start of memberFunctionString
143984 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
143985 :
143986 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
143987 :
143988 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
143989 : const SgRenamePairPtrList &
143990 0 : SgUseStatement::get_rename_list () const
143991 : {
143992 0 : assert (this != NULL);
143993 0 : return p_rename_list;
143994 : }
143995 :
143996 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
143997 : SgRenamePairPtrList &
143998 0 : SgUseStatement::get_rename_list ()
143999 : {
144000 0 : assert (this != NULL);
144001 :
144002 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
144003 : // As a rule only set_ access functions can set the isModified flag.
144004 : // set_isModified(true);
144005 :
144006 0 : return p_rename_list;
144007 : }
144008 :
144009 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
144010 :
144011 :
144012 : // End of memberFunctionString
144013 : // Start of memberFunctionString
144014 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
144015 :
144016 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
144017 :
144018 : SgModuleStatement*
144019 0 : SgUseStatement::get_module () const
144020 : {
144021 0 : ROSE_ASSERT (this != NULL);
144022 :
144023 : #if 0
144024 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144025 : // used to trigger marking transformations for the token-based unparsing.
144026 : printf ("SgUseStatement::get_module = %p = %s \n",this,this->class_name().c_str());
144027 : #endif
144028 :
144029 0 : return p_module;
144030 : }
144031 :
144032 : void
144033 0 : SgUseStatement::set_module ( SgModuleStatement* module )
144034 : {
144035 0 : ROSE_ASSERT (this != NULL);
144036 :
144037 : #if 0
144038 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144039 : // used to trigger marking transformations for the token-based unparsing.
144040 : printf ("SgUseStatement::set_module = %p = %s \n",this,this->class_name().c_str());
144041 : #endif
144042 :
144043 0 : set_isModified(true);
144044 :
144045 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
144046 : if (p_module != NULL && module != NULL && p_module != module)
144047 : {
144048 : printf ("Warning: module = %p overwriting valid pointer p_module = %p \n",module,p_module);
144049 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
144050 : printf ("Error fails assertion (p_module != NULL && module != NULL && p_module != module) is false\n");
144051 : ROSE_ASSERT(false);
144052 : #endif
144053 : }
144054 : #endif
144055 0 : p_module = module;
144056 0 : }
144057 :
144058 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
144059 :
144060 :
144061 : // End of memberFunctionString
144062 : // Start of memberFunctionString
144063 : /* #line 18273 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
144064 :
144065 :
144066 : void
144067 0 : SgUseStatement::post_construction_initialization()
144068 0 : {}
144069 :
144070 : SgName
144071 0 : SgUseStatement::get_mangled_name() const
144072 : {
144073 : // printf ("Sorry, SgUseStatement::get_mangled_name() not implemented! \n");
144074 0 : return SgName("_use_");
144075 : }
144076 :
144077 :
144078 :
144079 : // End of memberFunctionString
144080 : // Start of memberFunctionString
144081 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
144082 :
144083 : // *** COMMON CODE SECTION BEGINS HERE ***
144084 :
144085 : #if 0
144086 : int
144087 : SgUseStatement::getVariant() const
144088 : {
144089 : // This function is used in ROSE while "variant()" is used in SAGE
144090 : assert(this != NULL);
144091 : return variant();
144092 : }
144093 : #endif
144094 :
144095 : // This function is used in ROSE in treeTraversal code
144096 : // eventually replaces getVariant() and variant()
144097 : // though after variant() has been removed for a while we will
144098 : // want to change the name of variantT() back to variant()
144099 : // (since the "T" was ment to stand for temporary).
144100 : // When this happens the variantT() will be depricated.
144101 : VariantT
144102 0 : SgUseStatement::variantT() const
144103 : {
144104 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
144105 0 : ROSE_ASSERT(this != NULL);
144106 0 : return V_SgUseStatement;
144107 : }
144108 :
144109 : #if 0
144110 : int
144111 : SgUseStatement::variant() const
144112 : {
144113 : // This function is used in SAGE
144114 : ROSE_ASSERT(this != NULL);
144115 : return USE_STATEMENT;
144116 : }
144117 : #endif
144118 :
144119 : ROSE_DLL_API const char*
144120 0 : SgUseStatement::sage_class_name() const
144121 : {
144122 0 : ROSE_ASSERT(this != NULL);
144123 0 : return "SgUseStatement";
144124 : }
144125 :
144126 : std::string
144127 0 : SgUseStatement::class_name() const
144128 : {
144129 0 : ROSE_ASSERT(this != NULL);
144130 0 : return "SgUseStatement";
144131 : }
144132 :
144133 : // DQ (11/26/2005): Support for visitor pattern mechanims
144134 : // (inferior to ROSE traversal mechanism, experimental).
144135 : void
144136 0 : SgUseStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
144137 : {
144138 0 : ROSE_ASSERT(this != NULL);
144139 0 : visitor.visit(this);
144140 0 : }
144141 :
144142 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
144143 0 : void SgUseStatement::accept (ROSE_VisitorPattern & visitor) {
144144 0 : ROSE_ASSERT(this != NULL);
144145 0 : visitor.visit(this);
144146 0 : }
144147 :
144148 : SgUseStatement*
144149 0 : SgUseStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
144150 : {
144151 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
144152 : // This function is currently only supported for the AST used the represent Binary executables.
144153 : if (0 /* isSgAsmNode(this) != NULL */)
144154 : {
144155 : // Support for regex specification.
144156 : std::string prefixCode = "REGEX:";
144157 : addNewAttribute(prefixCode + s,a);
144158 : }
144159 : #endif
144160 :
144161 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
144162 0 : return this;
144163 : }
144164 :
144165 : // *** COMMON CODE SECTION ENDS HERE ***
144166 :
144167 :
144168 : // End of memberFunctionString
144169 : // Start of memberFunctionString
144170 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
144171 :
144172 :
144173 : #if 0
144174 : //! Error checking support
144175 : /*! Verifies the following:
144176 : - working getVariant() member function
144177 : - calls base class's error() member function
144178 : Every class has one of these functions.
144179 : */
144180 : bool
144181 : SgUseStatement::error()
144182 : {
144183 : // Put error checking here
144184 :
144185 : ROSE_ASSERT (this != NULL);
144186 : if (getVariant() != USE_STATEMENT)
144187 : {
144188 : printf ("Error in SgUseStatement::error(): SgUseStatement object has a %s variant \n",
144189 : Cxx_GrammarTerminalNames[getVariant()].name);
144190 : // printf ("Error in SgUseStatement::error() \n");
144191 : ROSE_ABORT();
144192 : }
144193 :
144194 : ROSE_ASSERT (getVariant() == USE_STATEMENT);
144195 : return SgDeclarationStatement::error();
144196 : }
144197 : #endif
144198 :
144199 :
144200 :
144201 : // End of memberFunctionString
144202 :
144203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
144204 :
144205 6124480 : SgUseStatement* isSgUseStatement ( SgNode* inputDerivedClassPointer )
144206 : {
144207 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
144208 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
144209 : // So to fix this we return NULL directly when the input is NULL and avoid the
144210 : // dynamic_cast in this case. This is likely a performance improvement as well.
144211 : // return dynamic_cast<SgUseStatement*>(inputDerivedClassPointer);
144212 : // Milind Chabbi (8/28/2013): isSgUseStatement uses table-driven castability instead of c++ default dynamic_cast
144213 : // this improves the running time performance by 10-20%.
144214 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUseStatement*>(inputDerivedClassPointer);
144215 6124480 : return IS_SgUseStatement_FAST_MACRO(inputDerivedClassPointer);
144216 : }
144217 :
144218 : // DQ (11/8/2003): Added version of functions taking const pointer
144219 0 : const SgUseStatement* isSgUseStatement ( const SgNode* inputDerivedClassPointer )
144220 : {
144221 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
144222 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
144223 : // So to fix this we return NULL directly when the input is NULL and avoid the
144224 : // dynamic_cast in this case. This is likely a performance improvement as well.
144225 : // return dynamic_cast<const SgUseStatement*>(inputDerivedClassPointer);
144226 : // Milind Chabbi (8/28/2013): isSgUseStatement uses table-driven castability instead of c++ default dynamic_cast
144227 : // this improves the running time performance by 10-20%.
144228 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUseStatement*>(inputDerivedClassPointer);
144229 0 : return IS_SgUseStatement_FAST_MACRO(inputDerivedClassPointer);
144230 : }
144231 :
144232 :
144233 :
144234 : /* #line 144235 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144235 :
144236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
144237 :
144238 : /**
144239 : \brief Generated destructor
144240 :
144241 : This destructor is automatically generated (by ROSETTA). This destructor
144242 : only frees memory of data members associated with the parts of the current IR node which
144243 : are NOT traversed. Those data members that are part of a traversal can be freed using
144244 : a traversal (calling this destructor on all children in a post-order traversal). Such
144245 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
144246 :
144247 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
144248 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
144249 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
144250 :
144251 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
144252 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
144253 : pointers are not yet implemented to call delete on eash pointer in the container.
144254 : (This could be done by derivation from the STL containers to define containers that
144255 : automatically deleted their members.)
144256 :
144257 : */
144258 0 : SgUseStatement::~SgUseStatement () {
144259 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
144260 :
144261 :
144262 : // case: not a listType for name
144263 0 : p_name = ""; // non list case
144264 : // case: not a listType for only_option
144265 0 : p_only_option = false; // non list case
144266 : // case: not a listType for module_nature
144267 0 : p_module_nature = ""; // non list case
144268 : // case: not a listType for module
144269 0 : p_module = NULL; // non list case
144270 :
144271 : }
144272 :
144273 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
144274 0 : }
144275 :
144276 :
144277 : /* #line 144278 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144278 :
144279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
144280 :
144281 : // Generated constructor
144282 0 : SgUseStatement::SgUseStatement ( Sg_File_Info* startOfConstruct, SgName name, bool only_option, std::string module_nature )
144283 0 : : SgDeclarationStatement(startOfConstruct)
144284 : {
144285 : #ifdef DEBUG
144286 : // printf ("In SgUseStatement::SgUseStatement (Sg_File_Info* startOfConstruct, SgName name, bool only_option, std::string module_nature) sage_class_name() = %s \n",sage_class_name());
144287 : #endif
144288 : #if 0
144289 : // debugging information!
144290 : printf ("In SgUseStatement::SgUseStatement (Sg_File_Info* startOfConstruct, SgName name, bool only_option, std::string module_nature): this = %p = %s \n",this,this->class_name().c_str());
144291 : #endif
144292 :
144293 0 : p_name = name;
144294 0 : p_only_option = only_option;
144295 0 : p_module_nature = module_nature;
144296 0 : p_module = NULL;
144297 :
144298 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
144299 :
144300 : #if 0
144301 : // DQ (7/30/2014): Call a virtual function.
144302 : std::string s = this->class_name();
144303 : #endif
144304 :
144305 : // Test the variant virtual function
144306 : // assert(USE_STATEMENT == variant());
144307 0 : assert(USE_STATEMENT == this->variant());
144308 0 : ROSE_ASSERT(USE_STATEMENT == (int)(this->variantT()));
144309 0 : post_construction_initialization();
144310 :
144311 : // Test the isSgUseStatement() function since it has been problematic
144312 0 : assert(isSgUseStatement(this) != NULL);
144313 0 : }
144314 :
144315 : // Generated constructor (all data members)
144316 :
144317 : /* #line 144318 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144318 :
144319 :
144320 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
144321 :
144322 :
144323 : // ********************************************************
144324 : // member functions common across all array grammar objects
144325 : // ********************************************************
144326 :
144327 :
144328 :
144329 : /* #line 144330 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144330 :
144331 :
144332 :
144333 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
144334 :
144335 : // ********************************************************
144336 : // member functions specific to each node in the grammar
144337 : // ********************************************************
144338 :
144339 :
144340 : /* #line 144341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144341 :
144342 : // Start of memberFunctionString
144343 : /* #line 18515 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
144344 :
144345 : void
144346 0 : SgParameterStatement::post_construction_initialization()
144347 : {
144348 0 : }
144349 :
144350 :
144351 :
144352 : // End of memberFunctionString
144353 : // Start of memberFunctionString
144354 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
144355 :
144356 : // *** COMMON CODE SECTION BEGINS HERE ***
144357 :
144358 : #if 0
144359 : int
144360 : SgParameterStatement::getVariant() const
144361 : {
144362 : // This function is used in ROSE while "variant()" is used in SAGE
144363 : assert(this != NULL);
144364 : return variant();
144365 : }
144366 : #endif
144367 :
144368 : // This function is used in ROSE in treeTraversal code
144369 : // eventually replaces getVariant() and variant()
144370 : // though after variant() has been removed for a while we will
144371 : // want to change the name of variantT() back to variant()
144372 : // (since the "T" was ment to stand for temporary).
144373 : // When this happens the variantT() will be depricated.
144374 : VariantT
144375 0 : SgParameterStatement::variantT() const
144376 : {
144377 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
144378 0 : ROSE_ASSERT(this != NULL);
144379 0 : return V_SgParameterStatement;
144380 : }
144381 :
144382 : #if 0
144383 : int
144384 : SgParameterStatement::variant() const
144385 : {
144386 : // This function is used in SAGE
144387 : ROSE_ASSERT(this != NULL);
144388 : return PARAMETER_STATEMENT;
144389 : }
144390 : #endif
144391 :
144392 : ROSE_DLL_API const char*
144393 0 : SgParameterStatement::sage_class_name() const
144394 : {
144395 0 : ROSE_ASSERT(this != NULL);
144396 0 : return "SgParameterStatement";
144397 : }
144398 :
144399 : std::string
144400 0 : SgParameterStatement::class_name() const
144401 : {
144402 0 : ROSE_ASSERT(this != NULL);
144403 0 : return "SgParameterStatement";
144404 : }
144405 :
144406 : // DQ (11/26/2005): Support for visitor pattern mechanims
144407 : // (inferior to ROSE traversal mechanism, experimental).
144408 : void
144409 0 : SgParameterStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
144410 : {
144411 0 : ROSE_ASSERT(this != NULL);
144412 0 : visitor.visit(this);
144413 0 : }
144414 :
144415 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
144416 0 : void SgParameterStatement::accept (ROSE_VisitorPattern & visitor) {
144417 0 : ROSE_ASSERT(this != NULL);
144418 0 : visitor.visit(this);
144419 0 : }
144420 :
144421 : SgParameterStatement*
144422 0 : SgParameterStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
144423 : {
144424 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
144425 : // This function is currently only supported for the AST used the represent Binary executables.
144426 : if (0 /* isSgAsmNode(this) != NULL */)
144427 : {
144428 : // Support for regex specification.
144429 : std::string prefixCode = "REGEX:";
144430 : addNewAttribute(prefixCode + s,a);
144431 : }
144432 : #endif
144433 :
144434 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
144435 0 : return this;
144436 : }
144437 :
144438 : // *** COMMON CODE SECTION ENDS HERE ***
144439 :
144440 :
144441 : // End of memberFunctionString
144442 : // Start of memberFunctionString
144443 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
144444 :
144445 :
144446 : #if 0
144447 : //! Error checking support
144448 : /*! Verifies the following:
144449 : - working getVariant() member function
144450 : - calls base class's error() member function
144451 : Every class has one of these functions.
144452 : */
144453 : bool
144454 : SgParameterStatement::error()
144455 : {
144456 : // Put error checking here
144457 :
144458 : ROSE_ASSERT (this != NULL);
144459 : if (getVariant() != PARAMETER_STATEMENT)
144460 : {
144461 : printf ("Error in SgParameterStatement::error(): SgParameterStatement object has a %s variant \n",
144462 : Cxx_GrammarTerminalNames[getVariant()].name);
144463 : // printf ("Error in SgParameterStatement::error() \n");
144464 : ROSE_ABORT();
144465 : }
144466 :
144467 : ROSE_ASSERT (getVariant() == PARAMETER_STATEMENT);
144468 : return SgDeclarationStatement::error();
144469 : }
144470 : #endif
144471 :
144472 :
144473 :
144474 : // End of memberFunctionString
144475 :
144476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
144477 :
144478 0 : SgParameterStatement* isSgParameterStatement ( SgNode* inputDerivedClassPointer )
144479 : {
144480 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
144481 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
144482 : // So to fix this we return NULL directly when the input is NULL and avoid the
144483 : // dynamic_cast in this case. This is likely a performance improvement as well.
144484 : // return dynamic_cast<SgParameterStatement*>(inputDerivedClassPointer);
144485 : // Milind Chabbi (8/28/2013): isSgParameterStatement uses table-driven castability instead of c++ default dynamic_cast
144486 : // this improves the running time performance by 10-20%.
144487 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgParameterStatement*>(inputDerivedClassPointer);
144488 0 : return IS_SgParameterStatement_FAST_MACRO(inputDerivedClassPointer);
144489 : }
144490 :
144491 : // DQ (11/8/2003): Added version of functions taking const pointer
144492 0 : const SgParameterStatement* isSgParameterStatement ( const SgNode* inputDerivedClassPointer )
144493 : {
144494 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
144495 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
144496 : // So to fix this we return NULL directly when the input is NULL and avoid the
144497 : // dynamic_cast in this case. This is likely a performance improvement as well.
144498 : // return dynamic_cast<const SgParameterStatement*>(inputDerivedClassPointer);
144499 : // Milind Chabbi (8/28/2013): isSgParameterStatement uses table-driven castability instead of c++ default dynamic_cast
144500 : // this improves the running time performance by 10-20%.
144501 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgParameterStatement*>(inputDerivedClassPointer);
144502 0 : return IS_SgParameterStatement_FAST_MACRO(inputDerivedClassPointer);
144503 : }
144504 :
144505 :
144506 :
144507 : /* #line 144508 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144508 :
144509 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
144510 :
144511 : /**
144512 : \brief Generated destructor
144513 :
144514 : This destructor is automatically generated (by ROSETTA). This destructor
144515 : only frees memory of data members associated with the parts of the current IR node which
144516 : are NOT traversed. Those data members that are part of a traversal can be freed using
144517 : a traversal (calling this destructor on all children in a post-order traversal). Such
144518 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
144519 :
144520 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
144521 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
144522 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
144523 :
144524 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
144525 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
144526 : pointers are not yet implemented to call delete on eash pointer in the container.
144527 : (This could be done by derivation from the STL containers to define containers that
144528 : automatically deleted their members.)
144529 :
144530 : */
144531 0 : SgParameterStatement::~SgParameterStatement () {
144532 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
144533 :
144534 :
144535 :
144536 : }
144537 :
144538 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
144539 0 : }
144540 :
144541 :
144542 : /* #line 144543 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144543 :
144544 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
144545 :
144546 : // Generated constructor
144547 0 : SgParameterStatement::SgParameterStatement ( Sg_File_Info* startOfConstruct )
144548 0 : : SgDeclarationStatement(startOfConstruct)
144549 : {
144550 : #ifdef DEBUG
144551 : // printf ("In SgParameterStatement::SgParameterStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
144552 : #endif
144553 : #if 0
144554 : // debugging information!
144555 : printf ("In SgParameterStatement::SgParameterStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
144556 : #endif
144557 :
144558 :
144559 :
144560 : #if 0
144561 : // DQ (7/30/2014): Call a virtual function.
144562 : std::string s = this->class_name();
144563 : #endif
144564 :
144565 : // Test the variant virtual function
144566 : // assert(PARAMETER_STATEMENT == variant());
144567 0 : assert(PARAMETER_STATEMENT == this->variant());
144568 0 : ROSE_ASSERT(PARAMETER_STATEMENT == (int)(this->variantT()));
144569 0 : post_construction_initialization();
144570 :
144571 : // Test the isSgParameterStatement() function since it has been problematic
144572 0 : assert(isSgParameterStatement(this) != NULL);
144573 0 : }
144574 :
144575 : // Generated constructor (all data members)
144576 :
144577 : /* #line 144578 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144578 :
144579 :
144580 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
144581 :
144582 :
144583 : // ********************************************************
144584 : // member functions common across all array grammar objects
144585 : // ********************************************************
144586 :
144587 :
144588 :
144589 : /* #line 144590 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144590 :
144591 :
144592 :
144593 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
144594 :
144595 : // ********************************************************
144596 : // member functions specific to each node in the grammar
144597 : // ********************************************************
144598 :
144599 :
144600 : /* #line 144601 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
144601 :
144602 : // Start of memberFunctionString
144603 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
144604 :
144605 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
144606 :
144607 : SgName
144608 302328 : SgNamespaceDeclarationStatement::get_name () const
144609 : {
144610 302328 : ROSE_ASSERT (this != NULL);
144611 :
144612 : #if 0
144613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144614 : // used to trigger marking transformations for the token-based unparsing.
144615 : printf ("SgNamespaceDeclarationStatement::get_name = %p = %s \n",this,this->class_name().c_str());
144616 : #endif
144617 :
144618 302328 : return p_name;
144619 : }
144620 :
144621 : void
144622 0 : SgNamespaceDeclarationStatement::set_name ( SgName name )
144623 : {
144624 0 : ROSE_ASSERT (this != NULL);
144625 :
144626 : #if 0
144627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144628 : // used to trigger marking transformations for the token-based unparsing.
144629 : printf ("SgNamespaceDeclarationStatement::set_name = %p = %s \n",this,this->class_name().c_str());
144630 : #endif
144631 :
144632 0 : set_isModified(true);
144633 :
144634 0 : p_name = name;
144635 0 : }
144636 :
144637 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
144638 :
144639 :
144640 : // End of memberFunctionString
144641 : // Start of memberFunctionString
144642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
144643 :
144644 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
144645 :
144646 : SgNamespaceDefinitionStatement*
144647 12488 : SgNamespaceDeclarationStatement::get_definition () const
144648 : {
144649 12488 : ROSE_ASSERT (this != NULL);
144650 :
144651 : #if 0
144652 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144653 : // used to trigger marking transformations for the token-based unparsing.
144654 : printf ("SgNamespaceDeclarationStatement::get_definition = %p = %s \n",this,this->class_name().c_str());
144655 : #endif
144656 :
144657 12488 : return p_definition;
144658 : }
144659 :
144660 : void
144661 0 : SgNamespaceDeclarationStatement::set_definition ( SgNamespaceDefinitionStatement* definition )
144662 : {
144663 0 : ROSE_ASSERT (this != NULL);
144664 :
144665 : #if 0
144666 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144667 : // used to trigger marking transformations for the token-based unparsing.
144668 : printf ("SgNamespaceDeclarationStatement::set_definition = %p = %s \n",this,this->class_name().c_str());
144669 : #endif
144670 :
144671 0 : set_isModified(true);
144672 :
144673 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
144674 : if (p_definition != NULL && definition != NULL && p_definition != definition)
144675 : {
144676 : printf ("Warning: definition = %p overwriting valid pointer p_definition = %p \n",definition,p_definition);
144677 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
144678 : printf ("Error fails assertion (p_definition != NULL && definition != NULL && p_definition != definition) is false\n");
144679 : ROSE_ASSERT(false);
144680 : #endif
144681 : }
144682 : #endif
144683 0 : p_definition = definition;
144684 0 : }
144685 :
144686 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
144687 :
144688 :
144689 : // End of memberFunctionString
144690 : // Start of memberFunctionString
144691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
144692 :
144693 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
144694 :
144695 : bool
144696 76891 : SgNamespaceDeclarationStatement::get_isUnnamedNamespace () const
144697 : {
144698 76891 : ROSE_ASSERT (this != NULL);
144699 :
144700 : #if 0
144701 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144702 : // used to trigger marking transformations for the token-based unparsing.
144703 : printf ("SgNamespaceDeclarationStatement::get_isUnnamedNamespace = %p = %s \n",this,this->class_name().c_str());
144704 : #endif
144705 :
144706 76891 : return p_isUnnamedNamespace;
144707 : }
144708 :
144709 : void
144710 0 : SgNamespaceDeclarationStatement::set_isUnnamedNamespace ( bool isUnnamedNamespace )
144711 : {
144712 0 : ROSE_ASSERT (this != NULL);
144713 :
144714 : #if 0
144715 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144716 : // used to trigger marking transformations for the token-based unparsing.
144717 : printf ("SgNamespaceDeclarationStatement::set_isUnnamedNamespace = %p = %s \n",this,this->class_name().c_str());
144718 : #endif
144719 :
144720 0 : set_isModified(true);
144721 :
144722 0 : p_isUnnamedNamespace = isUnnamedNamespace;
144723 0 : }
144724 :
144725 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
144726 :
144727 :
144728 : // End of memberFunctionString
144729 : // Start of memberFunctionString
144730 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
144731 :
144732 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
144733 :
144734 : bool
144735 6 : SgNamespaceDeclarationStatement::get_isInlinedNamespace () const
144736 : {
144737 6 : ROSE_ASSERT (this != NULL);
144738 :
144739 : #if 0
144740 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144741 : // used to trigger marking transformations for the token-based unparsing.
144742 : printf ("SgNamespaceDeclarationStatement::get_isInlinedNamespace = %p = %s \n",this,this->class_name().c_str());
144743 : #endif
144744 :
144745 6 : return p_isInlinedNamespace;
144746 : }
144747 :
144748 : void
144749 50 : SgNamespaceDeclarationStatement::set_isInlinedNamespace ( bool isInlinedNamespace )
144750 : {
144751 50 : ROSE_ASSERT (this != NULL);
144752 :
144753 : #if 0
144754 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
144755 : // used to trigger marking transformations for the token-based unparsing.
144756 : printf ("SgNamespaceDeclarationStatement::set_isInlinedNamespace = %p = %s \n",this,this->class_name().c_str());
144757 : #endif
144758 :
144759 50 : set_isModified(true);
144760 :
144761 50 : p_isInlinedNamespace = isInlinedNamespace;
144762 50 : }
144763 :
144764 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
144765 :
144766 :
144767 : // End of memberFunctionString
144768 : // Start of memberFunctionString
144769 : /* #line 17332 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
144770 :
144771 :
144772 : bool
144773 0 : SgNamespaceDeclarationStatement::isSameNamespace( const SgNamespaceDeclarationStatement* n ) const
144774 : {
144775 : // DQ (6/5/2007): Since namespaces are re-entrant we define a simple function to test if two namespaces
144776 : // are the same (not the same SgNamespaceDeclarationStatement, but the same namespace).
144777 0 : ROSE_ASSERT(get_firstNondefiningDeclaration() != NULL);
144778 0 : ROSE_ASSERT(n != NULL);
144779 0 : ROSE_ASSERT(n->get_firstNondefiningDeclaration() != NULL);
144780 :
144781 0 : return ( get_firstNondefiningDeclaration() == n->get_firstNondefiningDeclaration() );
144782 : }
144783 :
144784 : // DQ (9/8/2004): Added to support qualified name generation
144785 : SgName
144786 58236 : SgNamespaceDeclarationStatement::get_qualified_name() const
144787 : {
144788 58236 : SgName returnName;
144789 :
144790 : // printf ("In SgNamespaceDeclarationStatement::get_qualified_name() name = %s \n",get_name().str());
144791 :
144792 58236 : SgScopeStatement* scope = get_scope();
144793 58236 : ROSE_ASSERT(scope!= NULL);
144794 :
144795 : // DQ (8/24/2006): Need to test for unnamed namespaces since we have to ignore the extra "::" that would be generated in this case!
144796 : // returnName = scope->get_qualified_name() << "::" << get_name().str();
144797 : // returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
144798 58236 : if (get_name().is_null() == true)
144799 : {
144800 : // DQ (10/12/2006): Return and empty name instead of the qualified name
144801 : // of the current scope (see test2004_33.C using un-named namespaces).
144802 :
144803 : // Ignore the namespace name if it is a unnamed namespace
144804 : // returnName = scope->get_qualified_name();
144805 :
144806 : // DQ (10/14/2006): Correction for un-named namespaces in nested scopes!
144807 0 : if (isSgGlobal(scope) != NULL)
144808 : {
144809 : // If this is an un-named namespace in global scope then we are finished and the qualifier is empty.
144810 0 : returnName = "";
144811 : }
144812 : else
144813 : {
144814 : // If we are not yet in global scope then go further!
144815 0 : returnName = scope->get_qualified_name();
144816 : }
144817 : }
144818 : else
144819 : {
144820 58236 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
144821 : }
144822 :
144823 : // printf ("In SgNamespaceDeclarationStatement::get_qualified_name() : get_name().is_null == %s for name '%s'\n",get_name().is_null() ? "true" : "false", get_name().str());
144824 :
144825 58236 : return returnName;
144826 : }
144827 :
144828 : // RV (2/1/2006): Added mangler for namespace declarations.
144829 : SgName
144830 88033 : SgNamespaceDeclarationStatement::get_mangled_name (void) const
144831 : {
144832 : #if 0
144833 : return joinMangledQualifiers (mangleQualifiers(get_scope()), get_name());
144834 : #else
144835 : #if 0
144836 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
144837 : SgNamespaceDeclarationStatement* declaration = const_cast<SgNamespaceDeclarationStatement*>(this);
144838 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
144839 : if (i != p_globalMangledNameMap.end())
144840 : {
144841 : return i->second.c_str();
144842 : }
144843 : #endif
144844 176066 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgNamespaceDeclarationStatement*>(this));
144845 88033 : if (mangledNameString.empty() == false)
144846 : {
144847 : // return i->second.c_str();
144848 86607 : return mangledNameString;
144849 : }
144850 : else
144851 : {
144852 4278 : SgName mangledName = joinMangledQualifiers (mangleQualifiers(get_scope()), get_name());
144853 : #if 0
144854 : printf ("In SgNamespaceDeclarationStatement::get_mangled_name(): mangledName = %s \n",mangledName.str());
144855 : #endif
144856 : // p_globalMangledNameMap[declaration] = mangledName;
144857 1672 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgNamespaceDeclarationStatement*>(this),mangledName);
144858 1426 : return mangledName;
144859 : }
144860 : #endif
144861 : }
144862 :
144863 : #if 0
144864 : // DQ (2/19/2006): Added to handle case destribed in the header file.
144865 : bool
144866 : SgNamespaceDeclarationStatement::hasExplicitScope() const
144867 : {
144868 : // This function reports that this IR node stores its scope explicitly.
144869 :
144870 : return true;
144871 : }
144872 : #endif
144873 :
144874 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
144875 : SgSymbol*
144876 9609 : SgNamespaceDeclarationStatement::get_symbol_from_symbol_table() const
144877 : {
144878 9609 : ROSE_ASSERT(get_scope() != NULL);
144879 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
144880 : // return get_scope()->get_symbol_table()->find(this);
144881 9609 : return get_scope()->find_symbol_from_declaration(this);
144882 : }
144883 :
144884 :
144885 :
144886 : // End of memberFunctionString
144887 : // Start of memberFunctionString
144888 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
144889 :
144890 : void
144891 1127 : SgNamespaceDeclarationStatement::post_construction_initialization()
144892 : {
144893 1127 : }
144894 :
144895 :
144896 :
144897 : // End of memberFunctionString
144898 : // Start of memberFunctionString
144899 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
144900 :
144901 : // *** COMMON CODE SECTION BEGINS HERE ***
144902 :
144903 : #if 0
144904 : int
144905 : SgNamespaceDeclarationStatement::getVariant() const
144906 : {
144907 : // This function is used in ROSE while "variant()" is used in SAGE
144908 : assert(this != NULL);
144909 : return variant();
144910 : }
144911 : #endif
144912 :
144913 : // This function is used in ROSE in treeTraversal code
144914 : // eventually replaces getVariant() and variant()
144915 : // though after variant() has been removed for a while we will
144916 : // want to change the name of variantT() back to variant()
144917 : // (since the "T" was ment to stand for temporary).
144918 : // When this happens the variantT() will be depricated.
144919 : VariantT
144920 4798420 : SgNamespaceDeclarationStatement::variantT() const
144921 : {
144922 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
144923 4798420 : ROSE_ASSERT(this != NULL);
144924 4798420 : return V_SgNamespaceDeclarationStatement;
144925 : }
144926 :
144927 : #if 0
144928 : int
144929 : SgNamespaceDeclarationStatement::variant() const
144930 : {
144931 : // This function is used in SAGE
144932 : ROSE_ASSERT(this != NULL);
144933 : return NAMESPACE_DECLARATION_STMT;
144934 : }
144935 : #endif
144936 :
144937 : ROSE_DLL_API const char*
144938 0 : SgNamespaceDeclarationStatement::sage_class_name() const
144939 : {
144940 0 : ROSE_ASSERT(this != NULL);
144941 0 : return "SgNamespaceDeclarationStatement";
144942 : }
144943 :
144944 : std::string
144945 1343 : SgNamespaceDeclarationStatement::class_name() const
144946 : {
144947 1343 : ROSE_ASSERT(this != NULL);
144948 1343 : return "SgNamespaceDeclarationStatement";
144949 : }
144950 :
144951 : // DQ (11/26/2005): Support for visitor pattern mechanims
144952 : // (inferior to ROSE traversal mechanism, experimental).
144953 : void
144954 16721 : SgNamespaceDeclarationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
144955 : {
144956 16721 : ROSE_ASSERT(this != NULL);
144957 16721 : visitor.visit(this);
144958 16721 : }
144959 :
144960 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
144961 0 : void SgNamespaceDeclarationStatement::accept (ROSE_VisitorPattern & visitor) {
144962 0 : ROSE_ASSERT(this != NULL);
144963 0 : visitor.visit(this);
144964 0 : }
144965 :
144966 : SgNamespaceDeclarationStatement*
144967 0 : SgNamespaceDeclarationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
144968 : {
144969 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
144970 : // This function is currently only supported for the AST used the represent Binary executables.
144971 : if (0 /* isSgAsmNode(this) != NULL */)
144972 : {
144973 : // Support for regex specification.
144974 : std::string prefixCode = "REGEX:";
144975 : addNewAttribute(prefixCode + s,a);
144976 : }
144977 : #endif
144978 :
144979 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
144980 0 : return this;
144981 : }
144982 :
144983 : // *** COMMON CODE SECTION ENDS HERE ***
144984 :
144985 :
144986 : // End of memberFunctionString
144987 : // Start of memberFunctionString
144988 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
144989 :
144990 :
144991 : #if 0
144992 : //! Error checking support
144993 : /*! Verifies the following:
144994 : - working getVariant() member function
144995 : - calls base class's error() member function
144996 : Every class has one of these functions.
144997 : */
144998 : bool
144999 : SgNamespaceDeclarationStatement::error()
145000 : {
145001 : // Put error checking here
145002 :
145003 : ROSE_ASSERT (this != NULL);
145004 : if (getVariant() != NAMESPACE_DECLARATION_STMT)
145005 : {
145006 : printf ("Error in SgNamespaceDeclarationStatement::error(): SgNamespaceDeclarationStatement object has a %s variant \n",
145007 : Cxx_GrammarTerminalNames[getVariant()].name);
145008 : // printf ("Error in SgNamespaceDeclarationStatement::error() \n");
145009 : ROSE_ABORT();
145010 : }
145011 :
145012 : ROSE_ASSERT (getVariant() == NAMESPACE_DECLARATION_STMT);
145013 : return SgDeclarationStatement::error();
145014 : }
145015 : #endif
145016 :
145017 :
145018 :
145019 : // End of memberFunctionString
145020 :
145021 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
145022 :
145023 6582090 : SgNamespaceDeclarationStatement* isSgNamespaceDeclarationStatement ( SgNode* inputDerivedClassPointer )
145024 : {
145025 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
145026 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
145027 : // So to fix this we return NULL directly when the input is NULL and avoid the
145028 : // dynamic_cast in this case. This is likely a performance improvement as well.
145029 : // return dynamic_cast<SgNamespaceDeclarationStatement*>(inputDerivedClassPointer);
145030 : // Milind Chabbi (8/28/2013): isSgNamespaceDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
145031 : // this improves the running time performance by 10-20%.
145032 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNamespaceDeclarationStatement*>(inputDerivedClassPointer);
145033 6582090 : return IS_SgNamespaceDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
145034 : }
145035 :
145036 : // DQ (11/8/2003): Added version of functions taking const pointer
145037 1161460 : const SgNamespaceDeclarationStatement* isSgNamespaceDeclarationStatement ( const SgNode* inputDerivedClassPointer )
145038 : {
145039 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
145040 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
145041 : // So to fix this we return NULL directly when the input is NULL and avoid the
145042 : // dynamic_cast in this case. This is likely a performance improvement as well.
145043 : // return dynamic_cast<const SgNamespaceDeclarationStatement*>(inputDerivedClassPointer);
145044 : // Milind Chabbi (8/28/2013): isSgNamespaceDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
145045 : // this improves the running time performance by 10-20%.
145046 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNamespaceDeclarationStatement*>(inputDerivedClassPointer);
145047 1161460 : return IS_SgNamespaceDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
145048 : }
145049 :
145050 :
145051 :
145052 : /* #line 145053 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145053 :
145054 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
145055 :
145056 : /**
145057 : \brief Generated destructor
145058 :
145059 : This destructor is automatically generated (by ROSETTA). This destructor
145060 : only frees memory of data members associated with the parts of the current IR node which
145061 : are NOT traversed. Those data members that are part of a traversal can be freed using
145062 : a traversal (calling this destructor on all children in a post-order traversal). Such
145063 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
145064 :
145065 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
145066 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
145067 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
145068 :
145069 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
145070 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
145071 : pointers are not yet implemented to call delete on eash pointer in the container.
145072 : (This could be done by derivation from the STL containers to define containers that
145073 : automatically deleted their members.)
145074 :
145075 : */
145076 484 : SgNamespaceDeclarationStatement::~SgNamespaceDeclarationStatement () {
145077 242 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
145078 :
145079 :
145080 : // case: not a listType for name
145081 242 : p_name = ""; // non list case
145082 : // case: not a listType for definition
145083 242 : p_definition = NULL; // non list case
145084 : // case: not a listType for isUnnamedNamespace
145085 242 : p_isUnnamedNamespace = false; // non list case
145086 : // case: not a listType for isInlinedNamespace
145087 242 : p_isInlinedNamespace = false; // non list case
145088 :
145089 : }
145090 :
145091 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
145092 484 : }
145093 :
145094 :
145095 : /* #line 145096 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145096 :
145097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
145098 :
145099 : // Generated constructor
145100 0 : SgNamespaceDeclarationStatement::SgNamespaceDeclarationStatement ( Sg_File_Info* startOfConstruct, SgName name, SgNamespaceDefinitionStatement* definition, bool isUnnamedNamespace )
145101 0 : : SgDeclarationStatement(startOfConstruct)
145102 : {
145103 : #ifdef DEBUG
145104 : // printf ("In SgNamespaceDeclarationStatement::SgNamespaceDeclarationStatement (Sg_File_Info* startOfConstruct, SgName name, SgNamespaceDefinitionStatement* definition, bool isUnnamedNamespace) sage_class_name() = %s \n",sage_class_name());
145105 : #endif
145106 : #if 0
145107 : // debugging information!
145108 : printf ("In SgNamespaceDeclarationStatement::SgNamespaceDeclarationStatement (Sg_File_Info* startOfConstruct, SgName name, SgNamespaceDefinitionStatement* definition, bool isUnnamedNamespace): this = %p = %s \n",this,this->class_name().c_str());
145109 : #endif
145110 :
145111 0 : p_name = name;
145112 0 : p_definition = definition;
145113 0 : p_isUnnamedNamespace = isUnnamedNamespace;
145114 0 : p_isInlinedNamespace = false;
145115 :
145116 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
145117 :
145118 : #if 0
145119 : // DQ (7/30/2014): Call a virtual function.
145120 : std::string s = this->class_name();
145121 : #endif
145122 :
145123 : // Test the variant virtual function
145124 : // assert(NAMESPACE_DECLARATION_STMT == variant());
145125 0 : assert(NAMESPACE_DECLARATION_STMT == this->variant());
145126 0 : ROSE_ASSERT(NAMESPACE_DECLARATION_STMT == (int)(this->variantT()));
145127 0 : post_construction_initialization();
145128 :
145129 : // Test the isSgNamespaceDeclarationStatement() function since it has been problematic
145130 0 : assert(isSgNamespaceDeclarationStatement(this) != NULL);
145131 0 : }
145132 :
145133 : // Generated constructor (all data members)
145134 :
145135 : /* #line 145136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145136 :
145137 :
145138 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
145139 :
145140 :
145141 : // ********************************************************
145142 : // member functions common across all array grammar objects
145143 : // ********************************************************
145144 :
145145 :
145146 :
145147 : /* #line 145148 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145148 :
145149 :
145150 :
145151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
145152 :
145153 : // ********************************************************
145154 : // member functions specific to each node in the grammar
145155 : // ********************************************************
145156 :
145157 :
145158 : /* #line 145159 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145159 :
145160 : // Start of memberFunctionString
145161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
145162 :
145163 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145164 :
145165 : SgExprListExp*
145166 0 : SgEquivalenceStatement::get_equivalence_set_list () const
145167 : {
145168 0 : ROSE_ASSERT (this != NULL);
145169 :
145170 : #if 0
145171 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145172 : // used to trigger marking transformations for the token-based unparsing.
145173 : printf ("SgEquivalenceStatement::get_equivalence_set_list = %p = %s \n",this,this->class_name().c_str());
145174 : #endif
145175 :
145176 0 : return p_equivalence_set_list;
145177 : }
145178 :
145179 : void
145180 0 : SgEquivalenceStatement::set_equivalence_set_list ( SgExprListExp* equivalence_set_list )
145181 : {
145182 0 : ROSE_ASSERT (this != NULL);
145183 :
145184 : #if 0
145185 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145186 : // used to trigger marking transformations for the token-based unparsing.
145187 : printf ("SgEquivalenceStatement::set_equivalence_set_list = %p = %s \n",this,this->class_name().c_str());
145188 : #endif
145189 :
145190 0 : set_isModified(true);
145191 :
145192 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
145193 : if (p_equivalence_set_list != NULL && equivalence_set_list != NULL && p_equivalence_set_list != equivalence_set_list)
145194 : {
145195 : printf ("Warning: equivalence_set_list = %p overwriting valid pointer p_equivalence_set_list = %p \n",equivalence_set_list,p_equivalence_set_list);
145196 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
145197 : printf ("Error fails assertion (p_equivalence_set_list != NULL && equivalence_set_list != NULL && p_equivalence_set_list != equivalence_set_list) is false\n");
145198 : ROSE_ASSERT(false);
145199 : #endif
145200 : }
145201 : #endif
145202 0 : p_equivalence_set_list = equivalence_set_list;
145203 0 : }
145204 :
145205 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
145206 :
145207 :
145208 : // End of memberFunctionString
145209 : // Start of memberFunctionString
145210 : /* #line 18580 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
145211 :
145212 :
145213 : void
145214 0 : SgEquivalenceStatement::post_construction_initialization()
145215 0 : {}
145216 :
145217 : SgName
145218 0 : SgEquivalenceStatement::get_mangled_name() const
145219 : {
145220 : // printf ("Sorry, SgEquivalenceStatement::get_mangled_name() not implemented! \n");
145221 0 : return SgName("");
145222 : }
145223 :
145224 :
145225 : // End of memberFunctionString
145226 : // Start of memberFunctionString
145227 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
145228 :
145229 : // *** COMMON CODE SECTION BEGINS HERE ***
145230 :
145231 : #if 0
145232 : int
145233 : SgEquivalenceStatement::getVariant() const
145234 : {
145235 : // This function is used in ROSE while "variant()" is used in SAGE
145236 : assert(this != NULL);
145237 : return variant();
145238 : }
145239 : #endif
145240 :
145241 : // This function is used in ROSE in treeTraversal code
145242 : // eventually replaces getVariant() and variant()
145243 : // though after variant() has been removed for a while we will
145244 : // want to change the name of variantT() back to variant()
145245 : // (since the "T" was ment to stand for temporary).
145246 : // When this happens the variantT() will be depricated.
145247 : VariantT
145248 0 : SgEquivalenceStatement::variantT() const
145249 : {
145250 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
145251 0 : ROSE_ASSERT(this != NULL);
145252 0 : return V_SgEquivalenceStatement;
145253 : }
145254 :
145255 : #if 0
145256 : int
145257 : SgEquivalenceStatement::variant() const
145258 : {
145259 : // This function is used in SAGE
145260 : ROSE_ASSERT(this != NULL);
145261 : return TEMP_Equivalence_Statement;
145262 : }
145263 : #endif
145264 :
145265 : ROSE_DLL_API const char*
145266 0 : SgEquivalenceStatement::sage_class_name() const
145267 : {
145268 0 : ROSE_ASSERT(this != NULL);
145269 0 : return "SgEquivalenceStatement";
145270 : }
145271 :
145272 : std::string
145273 0 : SgEquivalenceStatement::class_name() const
145274 : {
145275 0 : ROSE_ASSERT(this != NULL);
145276 0 : return "SgEquivalenceStatement";
145277 : }
145278 :
145279 : // DQ (11/26/2005): Support for visitor pattern mechanims
145280 : // (inferior to ROSE traversal mechanism, experimental).
145281 : void
145282 0 : SgEquivalenceStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
145283 : {
145284 0 : ROSE_ASSERT(this != NULL);
145285 0 : visitor.visit(this);
145286 0 : }
145287 :
145288 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
145289 0 : void SgEquivalenceStatement::accept (ROSE_VisitorPattern & visitor) {
145290 0 : ROSE_ASSERT(this != NULL);
145291 0 : visitor.visit(this);
145292 0 : }
145293 :
145294 : SgEquivalenceStatement*
145295 0 : SgEquivalenceStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
145296 : {
145297 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
145298 : // This function is currently only supported for the AST used the represent Binary executables.
145299 : if (0 /* isSgAsmNode(this) != NULL */)
145300 : {
145301 : // Support for regex specification.
145302 : std::string prefixCode = "REGEX:";
145303 : addNewAttribute(prefixCode + s,a);
145304 : }
145305 : #endif
145306 :
145307 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
145308 0 : return this;
145309 : }
145310 :
145311 : // *** COMMON CODE SECTION ENDS HERE ***
145312 :
145313 :
145314 : // End of memberFunctionString
145315 : // Start of memberFunctionString
145316 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
145317 :
145318 :
145319 : #if 0
145320 : //! Error checking support
145321 : /*! Verifies the following:
145322 : - working getVariant() member function
145323 : - calls base class's error() member function
145324 : Every class has one of these functions.
145325 : */
145326 : bool
145327 : SgEquivalenceStatement::error()
145328 : {
145329 : // Put error checking here
145330 :
145331 : ROSE_ASSERT (this != NULL);
145332 : if (getVariant() != TEMP_Equivalence_Statement)
145333 : {
145334 : printf ("Error in SgEquivalenceStatement::error(): SgEquivalenceStatement object has a %s variant \n",
145335 : Cxx_GrammarTerminalNames[getVariant()].name);
145336 : // printf ("Error in SgEquivalenceStatement::error() \n");
145337 : ROSE_ABORT();
145338 : }
145339 :
145340 : ROSE_ASSERT (getVariant() == TEMP_Equivalence_Statement);
145341 : return SgDeclarationStatement::error();
145342 : }
145343 : #endif
145344 :
145345 :
145346 :
145347 : // End of memberFunctionString
145348 :
145349 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
145350 :
145351 0 : SgEquivalenceStatement* isSgEquivalenceStatement ( SgNode* inputDerivedClassPointer )
145352 : {
145353 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
145354 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
145355 : // So to fix this we return NULL directly when the input is NULL and avoid the
145356 : // dynamic_cast in this case. This is likely a performance improvement as well.
145357 : // return dynamic_cast<SgEquivalenceStatement*>(inputDerivedClassPointer);
145358 : // Milind Chabbi (8/28/2013): isSgEquivalenceStatement uses table-driven castability instead of c++ default dynamic_cast
145359 : // this improves the running time performance by 10-20%.
145360 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEquivalenceStatement*>(inputDerivedClassPointer);
145361 0 : return IS_SgEquivalenceStatement_FAST_MACRO(inputDerivedClassPointer);
145362 : }
145363 :
145364 : // DQ (11/8/2003): Added version of functions taking const pointer
145365 0 : const SgEquivalenceStatement* isSgEquivalenceStatement ( const SgNode* inputDerivedClassPointer )
145366 : {
145367 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
145368 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
145369 : // So to fix this we return NULL directly when the input is NULL and avoid the
145370 : // dynamic_cast in this case. This is likely a performance improvement as well.
145371 : // return dynamic_cast<const SgEquivalenceStatement*>(inputDerivedClassPointer);
145372 : // Milind Chabbi (8/28/2013): isSgEquivalenceStatement uses table-driven castability instead of c++ default dynamic_cast
145373 : // this improves the running time performance by 10-20%.
145374 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEquivalenceStatement*>(inputDerivedClassPointer);
145375 0 : return IS_SgEquivalenceStatement_FAST_MACRO(inputDerivedClassPointer);
145376 : }
145377 :
145378 :
145379 :
145380 : /* #line 145381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145381 :
145382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
145383 :
145384 : /**
145385 : \brief Generated destructor
145386 :
145387 : This destructor is automatically generated (by ROSETTA). This destructor
145388 : only frees memory of data members associated with the parts of the current IR node which
145389 : are NOT traversed. Those data members that are part of a traversal can be freed using
145390 : a traversal (calling this destructor on all children in a post-order traversal). Such
145391 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
145392 :
145393 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
145394 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
145395 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
145396 :
145397 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
145398 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
145399 : pointers are not yet implemented to call delete on eash pointer in the container.
145400 : (This could be done by derivation from the STL containers to define containers that
145401 : automatically deleted their members.)
145402 :
145403 : */
145404 0 : SgEquivalenceStatement::~SgEquivalenceStatement () {
145405 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
145406 :
145407 :
145408 : // case: not a listType for equivalence_set_list
145409 0 : p_equivalence_set_list = NULL; // non list case
145410 :
145411 : }
145412 :
145413 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
145414 0 : }
145415 :
145416 :
145417 : /* #line 145418 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145418 :
145419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
145420 :
145421 : // Generated constructor
145422 0 : SgEquivalenceStatement::SgEquivalenceStatement ( Sg_File_Info* startOfConstruct )
145423 0 : : SgDeclarationStatement(startOfConstruct)
145424 : {
145425 : #ifdef DEBUG
145426 : // printf ("In SgEquivalenceStatement::SgEquivalenceStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
145427 : #endif
145428 : #if 0
145429 : // debugging information!
145430 : printf ("In SgEquivalenceStatement::SgEquivalenceStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
145431 : #endif
145432 :
145433 0 : p_equivalence_set_list = NULL;
145434 :
145435 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
145436 :
145437 : #if 0
145438 : // DQ (7/30/2014): Call a virtual function.
145439 : std::string s = this->class_name();
145440 : #endif
145441 :
145442 : // Test the variant virtual function
145443 : // assert(TEMP_Equivalence_Statement == variant());
145444 0 : assert(TEMP_Equivalence_Statement == this->variant());
145445 0 : ROSE_ASSERT(TEMP_Equivalence_Statement == (int)(this->variantT()));
145446 0 : post_construction_initialization();
145447 :
145448 : // Test the isSgEquivalenceStatement() function since it has been problematic
145449 0 : assert(isSgEquivalenceStatement(this) != NULL);
145450 0 : }
145451 :
145452 : // Generated constructor (all data members)
145453 :
145454 : /* #line 145455 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145455 :
145456 :
145457 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
145458 :
145459 :
145460 : // ********************************************************
145461 : // member functions common across all array grammar objects
145462 : // ********************************************************
145463 :
145464 :
145465 :
145466 : /* #line 145467 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145467 :
145468 :
145469 :
145470 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
145471 :
145472 : // ********************************************************
145473 : // member functions specific to each node in the grammar
145474 : // ********************************************************
145475 :
145476 :
145477 : /* #line 145478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145478 :
145479 : // Start of memberFunctionString
145480 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
145481 :
145482 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145483 :
145484 : SgName
145485 0 : SgInterfaceStatement::get_name () const
145486 : {
145487 0 : ROSE_ASSERT (this != NULL);
145488 :
145489 : #if 0
145490 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145491 : // used to trigger marking transformations for the token-based unparsing.
145492 : printf ("SgInterfaceStatement::get_name = %p = %s \n",this,this->class_name().c_str());
145493 : #endif
145494 :
145495 0 : return p_name;
145496 : }
145497 :
145498 : void
145499 0 : SgInterfaceStatement::set_name ( SgName name )
145500 : {
145501 0 : ROSE_ASSERT (this != NULL);
145502 :
145503 : #if 0
145504 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145505 : // used to trigger marking transformations for the token-based unparsing.
145506 : printf ("SgInterfaceStatement::set_name = %p = %s \n",this,this->class_name().c_str());
145507 : #endif
145508 :
145509 0 : set_isModified(true);
145510 :
145511 0 : p_name = name;
145512 0 : }
145513 :
145514 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
145515 :
145516 :
145517 : // End of memberFunctionString
145518 : // Start of memberFunctionString
145519 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
145520 :
145521 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145522 :
145523 : SgInterfaceStatement::generic_spec_enum
145524 0 : SgInterfaceStatement::get_generic_spec () const
145525 : {
145526 0 : ROSE_ASSERT (this != NULL);
145527 :
145528 : #if 0
145529 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145530 : // used to trigger marking transformations for the token-based unparsing.
145531 : printf ("SgInterfaceStatement::get_generic_spec = %p = %s \n",this,this->class_name().c_str());
145532 : #endif
145533 :
145534 0 : return p_generic_spec;
145535 : }
145536 :
145537 : void
145538 0 : SgInterfaceStatement::set_generic_spec ( SgInterfaceStatement::generic_spec_enum generic_spec )
145539 : {
145540 0 : ROSE_ASSERT (this != NULL);
145541 :
145542 : #if 0
145543 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145544 : // used to trigger marking transformations for the token-based unparsing.
145545 : printf ("SgInterfaceStatement::set_generic_spec = %p = %s \n",this,this->class_name().c_str());
145546 : #endif
145547 :
145548 0 : set_isModified(true);
145549 :
145550 0 : p_generic_spec = generic_spec;
145551 0 : }
145552 :
145553 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
145554 :
145555 :
145556 : // End of memberFunctionString
145557 : // Start of memberFunctionString
145558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
145559 :
145560 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145561 :
145562 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
145563 : const SgInterfaceBodyPtrList &
145564 0 : SgInterfaceStatement::get_interface_body_list () const
145565 : {
145566 0 : assert (this != NULL);
145567 0 : return p_interface_body_list;
145568 : }
145569 :
145570 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
145571 : SgInterfaceBodyPtrList &
145572 0 : SgInterfaceStatement::get_interface_body_list ()
145573 : {
145574 0 : assert (this != NULL);
145575 :
145576 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
145577 : // As a rule only set_ access functions can set the isModified flag.
145578 : // set_isModified(true);
145579 :
145580 0 : return p_interface_body_list;
145581 : }
145582 :
145583 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
145584 :
145585 :
145586 : // End of memberFunctionString
145587 : // Start of memberFunctionString
145588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
145589 :
145590 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145591 :
145592 : SgLabelRefExp*
145593 0 : SgInterfaceStatement::get_end_numeric_label () const
145594 : {
145595 0 : ROSE_ASSERT (this != NULL);
145596 :
145597 : #if 0
145598 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145599 : // used to trigger marking transformations for the token-based unparsing.
145600 : printf ("SgInterfaceStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
145601 : #endif
145602 :
145603 0 : return p_end_numeric_label;
145604 : }
145605 :
145606 : void
145607 0 : SgInterfaceStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
145608 : {
145609 0 : ROSE_ASSERT (this != NULL);
145610 :
145611 : #if 0
145612 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145613 : // used to trigger marking transformations for the token-based unparsing.
145614 : printf ("SgInterfaceStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
145615 : #endif
145616 :
145617 0 : set_isModified(true);
145618 :
145619 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
145620 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
145621 : {
145622 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
145623 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
145624 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
145625 : ROSE_ASSERT(false);
145626 : #endif
145627 : }
145628 : #endif
145629 0 : p_end_numeric_label = end_numeric_label;
145630 0 : }
145631 :
145632 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
145633 :
145634 :
145635 : // End of memberFunctionString
145636 : // Start of memberFunctionString
145637 : /* #line 18493 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
145638 :
145639 : void
145640 0 : SgInterfaceStatement::post_construction_initialization()
145641 : {
145642 : #if 0
145643 : if (p_function != NULL)
145644 : {
145645 : p_function->set_parent(this);
145646 : }
145647 : #endif
145648 0 : }
145649 :
145650 : SgName
145651 0 : SgInterfaceStatement::get_mangled_name() const
145652 : {
145653 : // printf ("Sorry, SgInterfaceStatement::get_mangled_name() not implemented! \n");
145654 0 : return SgName("_interface_");
145655 : }
145656 :
145657 :
145658 :
145659 : // End of memberFunctionString
145660 : // Start of memberFunctionString
145661 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
145662 :
145663 : // *** COMMON CODE SECTION BEGINS HERE ***
145664 :
145665 : #if 0
145666 : int
145667 : SgInterfaceStatement::getVariant() const
145668 : {
145669 : // This function is used in ROSE while "variant()" is used in SAGE
145670 : assert(this != NULL);
145671 : return variant();
145672 : }
145673 : #endif
145674 :
145675 : // This function is used in ROSE in treeTraversal code
145676 : // eventually replaces getVariant() and variant()
145677 : // though after variant() has been removed for a while we will
145678 : // want to change the name of variantT() back to variant()
145679 : // (since the "T" was ment to stand for temporary).
145680 : // When this happens the variantT() will be depricated.
145681 : VariantT
145682 0 : SgInterfaceStatement::variantT() const
145683 : {
145684 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
145685 0 : ROSE_ASSERT(this != NULL);
145686 0 : return V_SgInterfaceStatement;
145687 : }
145688 :
145689 : #if 0
145690 : int
145691 : SgInterfaceStatement::variant() const
145692 : {
145693 : // This function is used in SAGE
145694 : ROSE_ASSERT(this != NULL);
145695 : return INTERFACE_STATEMENT;
145696 : }
145697 : #endif
145698 :
145699 : ROSE_DLL_API const char*
145700 0 : SgInterfaceStatement::sage_class_name() const
145701 : {
145702 0 : ROSE_ASSERT(this != NULL);
145703 0 : return "SgInterfaceStatement";
145704 : }
145705 :
145706 : std::string
145707 0 : SgInterfaceStatement::class_name() const
145708 : {
145709 0 : ROSE_ASSERT(this != NULL);
145710 0 : return "SgInterfaceStatement";
145711 : }
145712 :
145713 : // DQ (11/26/2005): Support for visitor pattern mechanims
145714 : // (inferior to ROSE traversal mechanism, experimental).
145715 : void
145716 0 : SgInterfaceStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
145717 : {
145718 0 : ROSE_ASSERT(this != NULL);
145719 0 : visitor.visit(this);
145720 0 : }
145721 :
145722 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
145723 0 : void SgInterfaceStatement::accept (ROSE_VisitorPattern & visitor) {
145724 0 : ROSE_ASSERT(this != NULL);
145725 0 : visitor.visit(this);
145726 0 : }
145727 :
145728 : SgInterfaceStatement*
145729 0 : SgInterfaceStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
145730 : {
145731 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
145732 : // This function is currently only supported for the AST used the represent Binary executables.
145733 : if (0 /* isSgAsmNode(this) != NULL */)
145734 : {
145735 : // Support for regex specification.
145736 : std::string prefixCode = "REGEX:";
145737 : addNewAttribute(prefixCode + s,a);
145738 : }
145739 : #endif
145740 :
145741 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
145742 0 : return this;
145743 : }
145744 :
145745 : // *** COMMON CODE SECTION ENDS HERE ***
145746 :
145747 :
145748 : // End of memberFunctionString
145749 : // Start of memberFunctionString
145750 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
145751 :
145752 :
145753 : #if 0
145754 : //! Error checking support
145755 : /*! Verifies the following:
145756 : - working getVariant() member function
145757 : - calls base class's error() member function
145758 : Every class has one of these functions.
145759 : */
145760 : bool
145761 : SgInterfaceStatement::error()
145762 : {
145763 : // Put error checking here
145764 :
145765 : ROSE_ASSERT (this != NULL);
145766 : if (getVariant() != INTERFACE_STATEMENT)
145767 : {
145768 : printf ("Error in SgInterfaceStatement::error(): SgInterfaceStatement object has a %s variant \n",
145769 : Cxx_GrammarTerminalNames[getVariant()].name);
145770 : // printf ("Error in SgInterfaceStatement::error() \n");
145771 : ROSE_ABORT();
145772 : }
145773 :
145774 : ROSE_ASSERT (getVariant() == INTERFACE_STATEMENT);
145775 : return SgDeclarationStatement::error();
145776 : }
145777 : #endif
145778 :
145779 :
145780 :
145781 : // End of memberFunctionString
145782 :
145783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
145784 :
145785 1342 : SgInterfaceStatement* isSgInterfaceStatement ( SgNode* inputDerivedClassPointer )
145786 : {
145787 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
145788 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
145789 : // So to fix this we return NULL directly when the input is NULL and avoid the
145790 : // dynamic_cast in this case. This is likely a performance improvement as well.
145791 : // return dynamic_cast<SgInterfaceStatement*>(inputDerivedClassPointer);
145792 : // Milind Chabbi (8/28/2013): isSgInterfaceStatement uses table-driven castability instead of c++ default dynamic_cast
145793 : // this improves the running time performance by 10-20%.
145794 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgInterfaceStatement*>(inputDerivedClassPointer);
145795 1342 : return IS_SgInterfaceStatement_FAST_MACRO(inputDerivedClassPointer);
145796 : }
145797 :
145798 : // DQ (11/8/2003): Added version of functions taking const pointer
145799 0 : const SgInterfaceStatement* isSgInterfaceStatement ( const SgNode* inputDerivedClassPointer )
145800 : {
145801 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
145802 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
145803 : // So to fix this we return NULL directly when the input is NULL and avoid the
145804 : // dynamic_cast in this case. This is likely a performance improvement as well.
145805 : // return dynamic_cast<const SgInterfaceStatement*>(inputDerivedClassPointer);
145806 : // Milind Chabbi (8/28/2013): isSgInterfaceStatement uses table-driven castability instead of c++ default dynamic_cast
145807 : // this improves the running time performance by 10-20%.
145808 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgInterfaceStatement*>(inputDerivedClassPointer);
145809 0 : return IS_SgInterfaceStatement_FAST_MACRO(inputDerivedClassPointer);
145810 : }
145811 :
145812 :
145813 :
145814 : /* #line 145815 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145815 :
145816 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
145817 :
145818 : /**
145819 : \brief Generated destructor
145820 :
145821 : This destructor is automatically generated (by ROSETTA). This destructor
145822 : only frees memory of data members associated with the parts of the current IR node which
145823 : are NOT traversed. Those data members that are part of a traversal can be freed using
145824 : a traversal (calling this destructor on all children in a post-order traversal). Such
145825 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
145826 :
145827 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
145828 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
145829 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
145830 :
145831 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
145832 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
145833 : pointers are not yet implemented to call delete on eash pointer in the container.
145834 : (This could be done by derivation from the STL containers to define containers that
145835 : automatically deleted their members.)
145836 :
145837 : */
145838 0 : SgInterfaceStatement::~SgInterfaceStatement () {
145839 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
145840 :
145841 :
145842 : // case: not a listType for name
145843 0 : p_name = ""; // non list case
145844 : // case: not a listType for generic_spec
145845 0 : p_generic_spec = SgInterfaceStatement::e_default_interface_type; // non list case
145846 : // case: not a listType for end_numeric_label
145847 0 : p_end_numeric_label = NULL; // non list case
145848 :
145849 : }
145850 :
145851 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
145852 0 : }
145853 :
145854 :
145855 : /* #line 145856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145856 :
145857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
145858 :
145859 : // Generated constructor
145860 0 : SgInterfaceStatement::SgInterfaceStatement ( Sg_File_Info* startOfConstruct, SgName name, SgInterfaceStatement::generic_spec_enum generic_spec )
145861 0 : : SgDeclarationStatement(startOfConstruct)
145862 : {
145863 : #ifdef DEBUG
145864 : // printf ("In SgInterfaceStatement::SgInterfaceStatement (Sg_File_Info* startOfConstruct, SgName name, SgInterfaceStatement::generic_spec_enum generic_spec) sage_class_name() = %s \n",sage_class_name());
145865 : #endif
145866 : #if 0
145867 : // debugging information!
145868 : printf ("In SgInterfaceStatement::SgInterfaceStatement (Sg_File_Info* startOfConstruct, SgName name, SgInterfaceStatement::generic_spec_enum generic_spec): this = %p = %s \n",this,this->class_name().c_str());
145869 : #endif
145870 :
145871 0 : p_name = name;
145872 0 : p_generic_spec = generic_spec;
145873 0 : p_end_numeric_label = NULL;
145874 :
145875 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
145876 :
145877 : #if 0
145878 : // DQ (7/30/2014): Call a virtual function.
145879 : std::string s = this->class_name();
145880 : #endif
145881 :
145882 : // Test the variant virtual function
145883 : // assert(INTERFACE_STATEMENT == variant());
145884 0 : assert(INTERFACE_STATEMENT == this->variant());
145885 0 : ROSE_ASSERT(INTERFACE_STATEMENT == (int)(this->variantT()));
145886 0 : post_construction_initialization();
145887 :
145888 : // Test the isSgInterfaceStatement() function since it has been problematic
145889 0 : assert(isSgInterfaceStatement(this) != NULL);
145890 0 : }
145891 :
145892 : // Generated constructor (all data members)
145893 :
145894 : /* #line 145895 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145895 :
145896 :
145897 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
145898 :
145899 :
145900 : // ********************************************************
145901 : // member functions common across all array grammar objects
145902 : // ********************************************************
145903 :
145904 :
145905 :
145906 : /* #line 145907 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145907 :
145908 :
145909 :
145910 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
145911 :
145912 : // ********************************************************
145913 : // member functions specific to each node in the grammar
145914 : // ********************************************************
145915 :
145916 :
145917 : /* #line 145918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
145918 :
145919 : // Start of memberFunctionString
145920 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
145921 :
145922 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145923 :
145924 : SgName
145925 0 : SgNamespaceAliasDeclarationStatement::get_name () const
145926 : {
145927 0 : ROSE_ASSERT (this != NULL);
145928 :
145929 : #if 0
145930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145931 : // used to trigger marking transformations for the token-based unparsing.
145932 : printf ("SgNamespaceAliasDeclarationStatement::get_name = %p = %s \n",this,this->class_name().c_str());
145933 : #endif
145934 :
145935 0 : return p_name;
145936 : }
145937 :
145938 : void
145939 0 : SgNamespaceAliasDeclarationStatement::set_name ( SgName name )
145940 : {
145941 0 : ROSE_ASSERT (this != NULL);
145942 :
145943 : #if 0
145944 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145945 : // used to trigger marking transformations for the token-based unparsing.
145946 : printf ("SgNamespaceAliasDeclarationStatement::set_name = %p = %s \n",this,this->class_name().c_str());
145947 : #endif
145948 :
145949 0 : set_isModified(true);
145950 :
145951 0 : p_name = name;
145952 0 : }
145953 :
145954 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
145955 :
145956 :
145957 : // End of memberFunctionString
145958 : // Start of memberFunctionString
145959 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
145960 :
145961 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
145962 :
145963 : SgNamespaceDeclarationStatement*
145964 0 : SgNamespaceAliasDeclarationStatement::get_namespaceDeclaration () const
145965 : {
145966 0 : ROSE_ASSERT (this != NULL);
145967 :
145968 : #if 0
145969 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145970 : // used to trigger marking transformations for the token-based unparsing.
145971 : printf ("SgNamespaceAliasDeclarationStatement::get_namespaceDeclaration = %p = %s \n",this,this->class_name().c_str());
145972 : #endif
145973 :
145974 0 : return p_namespaceDeclaration;
145975 : }
145976 :
145977 : void
145978 0 : SgNamespaceAliasDeclarationStatement::set_namespaceDeclaration ( SgNamespaceDeclarationStatement* namespaceDeclaration )
145979 : {
145980 0 : ROSE_ASSERT (this != NULL);
145981 :
145982 : #if 0
145983 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
145984 : // used to trigger marking transformations for the token-based unparsing.
145985 : printf ("SgNamespaceAliasDeclarationStatement::set_namespaceDeclaration = %p = %s \n",this,this->class_name().c_str());
145986 : #endif
145987 :
145988 0 : set_isModified(true);
145989 :
145990 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
145991 : if (p_namespaceDeclaration != NULL && namespaceDeclaration != NULL && p_namespaceDeclaration != namespaceDeclaration)
145992 : {
145993 : printf ("Warning: namespaceDeclaration = %p overwriting valid pointer p_namespaceDeclaration = %p \n",namespaceDeclaration,p_namespaceDeclaration);
145994 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
145995 : printf ("Error fails assertion (p_namespaceDeclaration != NULL && namespaceDeclaration != NULL && p_namespaceDeclaration != namespaceDeclaration) is false\n");
145996 : ROSE_ASSERT(false);
145997 : #endif
145998 : }
145999 : #endif
146000 0 : p_namespaceDeclaration = namespaceDeclaration;
146001 0 : }
146002 :
146003 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146004 :
146005 :
146006 : // End of memberFunctionString
146007 : // Start of memberFunctionString
146008 :
146009 :
146010 : // End of memberFunctionString
146011 : // Start of memberFunctionString
146012 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146013 :
146014 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146015 :
146016 : bool
146017 0 : SgNamespaceAliasDeclarationStatement::get_is_alias_for_another_namespace_alias () const
146018 : {
146019 0 : ROSE_ASSERT (this != NULL);
146020 :
146021 : #if 0
146022 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146023 : // used to trigger marking transformations for the token-based unparsing.
146024 : printf ("SgNamespaceAliasDeclarationStatement::get_is_alias_for_another_namespace_alias = %p = %s \n",this,this->class_name().c_str());
146025 : #endif
146026 :
146027 0 : return p_is_alias_for_another_namespace_alias;
146028 : }
146029 :
146030 : void
146031 0 : SgNamespaceAliasDeclarationStatement::set_is_alias_for_another_namespace_alias ( bool is_alias_for_another_namespace_alias )
146032 : {
146033 0 : ROSE_ASSERT (this != NULL);
146034 :
146035 : #if 0
146036 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146037 : // used to trigger marking transformations for the token-based unparsing.
146038 : printf ("SgNamespaceAliasDeclarationStatement::set_is_alias_for_another_namespace_alias = %p = %s \n",this,this->class_name().c_str());
146039 : #endif
146040 :
146041 0 : set_isModified(true);
146042 :
146043 0 : p_is_alias_for_another_namespace_alias = is_alias_for_another_namespace_alias;
146044 0 : }
146045 :
146046 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146047 :
146048 :
146049 : // End of memberFunctionString
146050 : // Start of memberFunctionString
146051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146052 :
146053 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146054 :
146055 : SgNamespaceAliasDeclarationStatement*
146056 0 : SgNamespaceAliasDeclarationStatement::get_namespaceAliasDeclaration () const
146057 : {
146058 0 : ROSE_ASSERT (this != NULL);
146059 :
146060 : #if 0
146061 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146062 : // used to trigger marking transformations for the token-based unparsing.
146063 : printf ("SgNamespaceAliasDeclarationStatement::get_namespaceAliasDeclaration = %p = %s \n",this,this->class_name().c_str());
146064 : #endif
146065 :
146066 0 : return p_namespaceAliasDeclaration;
146067 : }
146068 :
146069 : void
146070 0 : SgNamespaceAliasDeclarationStatement::set_namespaceAliasDeclaration ( SgNamespaceAliasDeclarationStatement* namespaceAliasDeclaration )
146071 : {
146072 0 : ROSE_ASSERT (this != NULL);
146073 :
146074 : #if 0
146075 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146076 : // used to trigger marking transformations for the token-based unparsing.
146077 : printf ("SgNamespaceAliasDeclarationStatement::set_namespaceAliasDeclaration = %p = %s \n",this,this->class_name().c_str());
146078 : #endif
146079 :
146080 0 : set_isModified(true);
146081 :
146082 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
146083 : if (p_namespaceAliasDeclaration != NULL && namespaceAliasDeclaration != NULL && p_namespaceAliasDeclaration != namespaceAliasDeclaration)
146084 : {
146085 : printf ("Warning: namespaceAliasDeclaration = %p overwriting valid pointer p_namespaceAliasDeclaration = %p \n",namespaceAliasDeclaration,p_namespaceAliasDeclaration);
146086 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
146087 : printf ("Error fails assertion (p_namespaceAliasDeclaration != NULL && namespaceAliasDeclaration != NULL && p_namespaceAliasDeclaration != namespaceAliasDeclaration) is false\n");
146088 : ROSE_ASSERT(false);
146089 : #endif
146090 : }
146091 : #endif
146092 0 : p_namespaceAliasDeclaration = namespaceAliasDeclaration;
146093 0 : }
146094 :
146095 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146096 :
146097 :
146098 : // End of memberFunctionString
146099 : // Start of memberFunctionString
146100 : /* #line 17448 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
146101 :
146102 :
146103 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
146104 : SgName
146105 0 : SgNamespaceAliasDeclarationStatement::get_mangled_name(void) const
146106 : {
146107 0 : SgName returnName;
146108 :
146109 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
146110 0 : SgScopeStatement* scope = get_scope();
146111 0 : ROSE_ASSERT(scope != NULL);
146112 :
146113 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
146114 : // This is a poor way to handle the generation of a mangled name (will be improved)
146115 : // returnName = scope->get_qualified_name() + SgName("_namespace_alias_") + get_name();
146116 0 : returnName = scope->get_mangled_name() + SgName("_namespace_alias_") + get_name();
146117 :
146118 0 : return returnName;
146119 : }
146120 :
146121 : SgSymbol*
146122 0 : SgNamespaceAliasDeclarationStatement::get_symbol_from_symbol_table() const
146123 : {
146124 0 : ROSE_ASSERT(get_scope() != NULL);
146125 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
146126 : // return get_scope()->get_symbol_table()->find(this);
146127 0 : return get_scope()->find_symbol_from_declaration(this);
146128 : }
146129 :
146130 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
146131 : // so that we could avoid them setting the isModified flag which is a problem in the
146132 : // name qualification support for C++ (interfering with the token-based unparsing).
146133 : int
146134 0 : SgNamespaceAliasDeclarationStatement::get_name_qualification_length () const
146135 : {
146136 0 : ROSE_ASSERT (this != NULL);
146137 0 : return p_name_qualification_length;
146138 : }
146139 :
146140 : void
146141 0 : SgNamespaceAliasDeclarationStatement::set_name_qualification_length ( int name_qualification_length )
146142 : {
146143 0 : ROSE_ASSERT (this != NULL);
146144 : // This can't be called by the name qualification API (see test2015_26.C).
146145 : // set_isModified(true);
146146 :
146147 0 : p_name_qualification_length = name_qualification_length;
146148 0 : }
146149 :
146150 : bool
146151 0 : SgNamespaceAliasDeclarationStatement::get_type_elaboration_required () const
146152 : {
146153 0 : ROSE_ASSERT (this != NULL);
146154 0 : return p_type_elaboration_required;
146155 : }
146156 :
146157 : void
146158 0 : SgNamespaceAliasDeclarationStatement::set_type_elaboration_required ( bool type_elaboration_required )
146159 : {
146160 0 : ROSE_ASSERT (this != NULL);
146161 : // This can't be called by the name qualification API (see test2015_26.C).
146162 : // set_isModified(true);
146163 :
146164 0 : p_type_elaboration_required = type_elaboration_required;
146165 0 : }
146166 :
146167 : bool
146168 0 : SgNamespaceAliasDeclarationStatement::get_global_qualification_required () const
146169 : {
146170 0 : ROSE_ASSERT (this != NULL);
146171 0 : return p_global_qualification_required;
146172 : }
146173 :
146174 : void
146175 0 : SgNamespaceAliasDeclarationStatement::set_global_qualification_required ( bool global_qualification_required )
146176 : {
146177 0 : ROSE_ASSERT (this != NULL);
146178 :
146179 : // This can't be called by the name qualification API (see test2015_26.C).
146180 : // set_isModified(true);
146181 :
146182 0 : p_global_qualification_required = global_qualification_required;
146183 0 : }
146184 :
146185 :
146186 :
146187 : // End of memberFunctionString
146188 : // Start of memberFunctionString
146189 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
146190 :
146191 : void
146192 0 : SgNamespaceAliasDeclarationStatement::post_construction_initialization()
146193 : {
146194 0 : }
146195 :
146196 :
146197 :
146198 : // End of memberFunctionString
146199 : // Start of memberFunctionString
146200 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
146201 :
146202 : // *** COMMON CODE SECTION BEGINS HERE ***
146203 :
146204 : #if 0
146205 : int
146206 : SgNamespaceAliasDeclarationStatement::getVariant() const
146207 : {
146208 : // This function is used in ROSE while "variant()" is used in SAGE
146209 : assert(this != NULL);
146210 : return variant();
146211 : }
146212 : #endif
146213 :
146214 : // This function is used in ROSE in treeTraversal code
146215 : // eventually replaces getVariant() and variant()
146216 : // though after variant() has been removed for a while we will
146217 : // want to change the name of variantT() back to variant()
146218 : // (since the "T" was ment to stand for temporary).
146219 : // When this happens the variantT() will be depricated.
146220 : VariantT
146221 0 : SgNamespaceAliasDeclarationStatement::variantT() const
146222 : {
146223 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
146224 0 : ROSE_ASSERT(this != NULL);
146225 0 : return V_SgNamespaceAliasDeclarationStatement;
146226 : }
146227 :
146228 : #if 0
146229 : int
146230 : SgNamespaceAliasDeclarationStatement::variant() const
146231 : {
146232 : // This function is used in SAGE
146233 : ROSE_ASSERT(this != NULL);
146234 : return NAMESPACE_ALIAS_DECLARATION_STMT;
146235 : }
146236 : #endif
146237 :
146238 : ROSE_DLL_API const char*
146239 0 : SgNamespaceAliasDeclarationStatement::sage_class_name() const
146240 : {
146241 0 : ROSE_ASSERT(this != NULL);
146242 0 : return "SgNamespaceAliasDeclarationStatement";
146243 : }
146244 :
146245 : std::string
146246 0 : SgNamespaceAliasDeclarationStatement::class_name() const
146247 : {
146248 0 : ROSE_ASSERT(this != NULL);
146249 0 : return "SgNamespaceAliasDeclarationStatement";
146250 : }
146251 :
146252 : // DQ (11/26/2005): Support for visitor pattern mechanims
146253 : // (inferior to ROSE traversal mechanism, experimental).
146254 : void
146255 0 : SgNamespaceAliasDeclarationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
146256 : {
146257 0 : ROSE_ASSERT(this != NULL);
146258 0 : visitor.visit(this);
146259 0 : }
146260 :
146261 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
146262 0 : void SgNamespaceAliasDeclarationStatement::accept (ROSE_VisitorPattern & visitor) {
146263 0 : ROSE_ASSERT(this != NULL);
146264 0 : visitor.visit(this);
146265 0 : }
146266 :
146267 : SgNamespaceAliasDeclarationStatement*
146268 0 : SgNamespaceAliasDeclarationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
146269 : {
146270 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
146271 : // This function is currently only supported for the AST used the represent Binary executables.
146272 : if (0 /* isSgAsmNode(this) != NULL */)
146273 : {
146274 : // Support for regex specification.
146275 : std::string prefixCode = "REGEX:";
146276 : addNewAttribute(prefixCode + s,a);
146277 : }
146278 : #endif
146279 :
146280 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
146281 0 : return this;
146282 : }
146283 :
146284 : // *** COMMON CODE SECTION ENDS HERE ***
146285 :
146286 :
146287 : // End of memberFunctionString
146288 : // Start of memberFunctionString
146289 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
146290 :
146291 :
146292 : #if 0
146293 : //! Error checking support
146294 : /*! Verifies the following:
146295 : - working getVariant() member function
146296 : - calls base class's error() member function
146297 : Every class has one of these functions.
146298 : */
146299 : bool
146300 : SgNamespaceAliasDeclarationStatement::error()
146301 : {
146302 : // Put error checking here
146303 :
146304 : ROSE_ASSERT (this != NULL);
146305 : if (getVariant() != NAMESPACE_ALIAS_DECLARATION_STMT)
146306 : {
146307 : printf ("Error in SgNamespaceAliasDeclarationStatement::error(): SgNamespaceAliasDeclarationStatement object has a %s variant \n",
146308 : Cxx_GrammarTerminalNames[getVariant()].name);
146309 : // printf ("Error in SgNamespaceAliasDeclarationStatement::error() \n");
146310 : ROSE_ABORT();
146311 : }
146312 :
146313 : ROSE_ASSERT (getVariant() == NAMESPACE_ALIAS_DECLARATION_STMT);
146314 : return SgDeclarationStatement::error();
146315 : }
146316 : #endif
146317 :
146318 :
146319 :
146320 : // End of memberFunctionString
146321 :
146322 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
146323 :
146324 8272150 : SgNamespaceAliasDeclarationStatement* isSgNamespaceAliasDeclarationStatement ( SgNode* inputDerivedClassPointer )
146325 : {
146326 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
146327 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
146328 : // So to fix this we return NULL directly when the input is NULL and avoid the
146329 : // dynamic_cast in this case. This is likely a performance improvement as well.
146330 : // return dynamic_cast<SgNamespaceAliasDeclarationStatement*>(inputDerivedClassPointer);
146331 : // Milind Chabbi (8/28/2013): isSgNamespaceAliasDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
146332 : // this improves the running time performance by 10-20%.
146333 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNamespaceAliasDeclarationStatement*>(inputDerivedClassPointer);
146334 8272150 : return IS_SgNamespaceAliasDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
146335 : }
146336 :
146337 : // DQ (11/8/2003): Added version of functions taking const pointer
146338 0 : const SgNamespaceAliasDeclarationStatement* isSgNamespaceAliasDeclarationStatement ( const SgNode* inputDerivedClassPointer )
146339 : {
146340 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
146341 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
146342 : // So to fix this we return NULL directly when the input is NULL and avoid the
146343 : // dynamic_cast in this case. This is likely a performance improvement as well.
146344 : // return dynamic_cast<const SgNamespaceAliasDeclarationStatement*>(inputDerivedClassPointer);
146345 : // Milind Chabbi (8/28/2013): isSgNamespaceAliasDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
146346 : // this improves the running time performance by 10-20%.
146347 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNamespaceAliasDeclarationStatement*>(inputDerivedClassPointer);
146348 0 : return IS_SgNamespaceAliasDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
146349 : }
146350 :
146351 :
146352 :
146353 : /* #line 146354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146354 :
146355 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
146356 :
146357 : /**
146358 : \brief Generated destructor
146359 :
146360 : This destructor is automatically generated (by ROSETTA). This destructor
146361 : only frees memory of data members associated with the parts of the current IR node which
146362 : are NOT traversed. Those data members that are part of a traversal can be freed using
146363 : a traversal (calling this destructor on all children in a post-order traversal). Such
146364 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
146365 :
146366 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
146367 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
146368 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
146369 :
146370 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
146371 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
146372 : pointers are not yet implemented to call delete on eash pointer in the container.
146373 : (This could be done by derivation from the STL containers to define containers that
146374 : automatically deleted their members.)
146375 :
146376 : */
146377 0 : SgNamespaceAliasDeclarationStatement::~SgNamespaceAliasDeclarationStatement () {
146378 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
146379 :
146380 :
146381 : // case: not a listType for name
146382 0 : p_name = ""; // non list case
146383 : // case: not a listType for namespaceDeclaration
146384 0 : p_namespaceDeclaration = NULL; // non list case
146385 : // case: not a listType for name_qualification_length
146386 0 : p_name_qualification_length = 0; // non list case
146387 : // case: not a listType for type_elaboration_required
146388 0 : p_type_elaboration_required = false; // non list case
146389 : // case: not a listType for global_qualification_required
146390 0 : p_global_qualification_required = false; // non list case
146391 : // case: not a listType for is_alias_for_another_namespace_alias
146392 0 : p_is_alias_for_another_namespace_alias = false; // non list case
146393 : // case: not a listType for namespaceAliasDeclaration
146394 0 : p_namespaceAliasDeclaration = NULL; // non list case
146395 :
146396 : }
146397 :
146398 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
146399 0 : }
146400 :
146401 :
146402 : /* #line 146403 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146403 :
146404 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
146405 :
146406 : // Generated constructor
146407 0 : SgNamespaceAliasDeclarationStatement::SgNamespaceAliasDeclarationStatement ( Sg_File_Info* startOfConstruct, SgName name, SgNamespaceDeclarationStatement* namespaceDeclaration )
146408 0 : : SgDeclarationStatement(startOfConstruct)
146409 : {
146410 : #ifdef DEBUG
146411 : // printf ("In SgNamespaceAliasDeclarationStatement::SgNamespaceAliasDeclarationStatement (Sg_File_Info* startOfConstruct, SgName name, SgNamespaceDeclarationStatement* namespaceDeclaration) sage_class_name() = %s \n",sage_class_name());
146412 : #endif
146413 : #if 0
146414 : // debugging information!
146415 : printf ("In SgNamespaceAliasDeclarationStatement::SgNamespaceAliasDeclarationStatement (Sg_File_Info* startOfConstruct, SgName name, SgNamespaceDeclarationStatement* namespaceDeclaration): this = %p = %s \n",this,this->class_name().c_str());
146416 : #endif
146417 :
146418 0 : p_name = name;
146419 0 : p_namespaceDeclaration = namespaceDeclaration;
146420 0 : p_name_qualification_length = 0;
146421 0 : p_type_elaboration_required = false;
146422 0 : p_global_qualification_required = false;
146423 0 : p_is_alias_for_another_namespace_alias = false;
146424 0 : p_namespaceAliasDeclaration = NULL;
146425 :
146426 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
146427 :
146428 : #if 0
146429 : // DQ (7/30/2014): Call a virtual function.
146430 : std::string s = this->class_name();
146431 : #endif
146432 :
146433 : // Test the variant virtual function
146434 : // assert(NAMESPACE_ALIAS_DECLARATION_STMT == variant());
146435 0 : assert(NAMESPACE_ALIAS_DECLARATION_STMT == this->variant());
146436 0 : ROSE_ASSERT(NAMESPACE_ALIAS_DECLARATION_STMT == (int)(this->variantT()));
146437 0 : post_construction_initialization();
146438 :
146439 : // Test the isSgNamespaceAliasDeclarationStatement() function since it has been problematic
146440 0 : assert(isSgNamespaceAliasDeclarationStatement(this) != NULL);
146441 0 : }
146442 :
146443 : // Generated constructor (all data members)
146444 :
146445 : /* #line 146446 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146446 :
146447 :
146448 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
146449 :
146450 :
146451 : // ********************************************************
146452 : // member functions common across all array grammar objects
146453 : // ********************************************************
146454 :
146455 :
146456 :
146457 : /* #line 146458 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146458 :
146459 :
146460 :
146461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
146462 :
146463 : // ********************************************************
146464 : // member functions specific to each node in the grammar
146465 : // ********************************************************
146466 :
146467 :
146468 : /* #line 146469 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146469 :
146470 : // Start of memberFunctionString
146471 :
146472 :
146473 : // End of memberFunctionString
146474 : // Start of memberFunctionString
146475 : /* #line 18164 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
146476 :
146477 :
146478 : void
146479 6 : SgCommonBlock::post_construction_initialization()
146480 : {
146481 6 : }
146482 :
146483 : SgName
146484 6 : SgCommonBlock::get_mangled_name() const
146485 : {
146486 : // printf ("Sorry, SgCommonBlock::get_mangled_name() not implemented! \n");
146487 6 : return SgName("");
146488 : }
146489 :
146490 : const SgCommonBlockObjectPtrList &
146491 0 : SgCommonBlock::get_block_list() const
146492 : {
146493 0 : return p_block_list;
146494 : }
146495 :
146496 : SgCommonBlockObjectPtrList &
146497 18 : SgCommonBlock::get_block_list()
146498 : {
146499 18 : return p_block_list;
146500 : }
146501 :
146502 :
146503 :
146504 : // End of memberFunctionString
146505 : // Start of memberFunctionString
146506 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
146507 :
146508 : // *** COMMON CODE SECTION BEGINS HERE ***
146509 :
146510 : #if 0
146511 : int
146512 : SgCommonBlock::getVariant() const
146513 : {
146514 : // This function is used in ROSE while "variant()" is used in SAGE
146515 : assert(this != NULL);
146516 : return variant();
146517 : }
146518 : #endif
146519 :
146520 : // This function is used in ROSE in treeTraversal code
146521 : // eventually replaces getVariant() and variant()
146522 : // though after variant() has been removed for a while we will
146523 : // want to change the name of variantT() back to variant()
146524 : // (since the "T" was ment to stand for temporary).
146525 : // When this happens the variantT() will be depricated.
146526 : VariantT
146527 4787 : SgCommonBlock::variantT() const
146528 : {
146529 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
146530 4787 : ROSE_ASSERT(this != NULL);
146531 4787 : return V_SgCommonBlock;
146532 : }
146533 :
146534 : #if 0
146535 : int
146536 : SgCommonBlock::variant() const
146537 : {
146538 : // This function is used in SAGE
146539 : ROSE_ASSERT(this != NULL);
146540 : return COMMON_BLOCK;
146541 : }
146542 : #endif
146543 :
146544 : ROSE_DLL_API const char*
146545 10 : SgCommonBlock::sage_class_name() const
146546 : {
146547 10 : ROSE_ASSERT(this != NULL);
146548 10 : return "SgCommonBlock";
146549 : }
146550 :
146551 : std::string
146552 6 : SgCommonBlock::class_name() const
146553 : {
146554 6 : ROSE_ASSERT(this != NULL);
146555 6 : return "SgCommonBlock";
146556 : }
146557 :
146558 : // DQ (11/26/2005): Support for visitor pattern mechanims
146559 : // (inferior to ROSE traversal mechanism, experimental).
146560 : void
146561 0 : SgCommonBlock::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
146562 : {
146563 0 : ROSE_ASSERT(this != NULL);
146564 0 : visitor.visit(this);
146565 0 : }
146566 :
146567 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
146568 0 : void SgCommonBlock::accept (ROSE_VisitorPattern & visitor) {
146569 0 : ROSE_ASSERT(this != NULL);
146570 0 : visitor.visit(this);
146571 0 : }
146572 :
146573 : SgCommonBlock*
146574 0 : SgCommonBlock::addRegExpAttribute(std::string s, AstRegExAttribute* a)
146575 : {
146576 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
146577 : // This function is currently only supported for the AST used the represent Binary executables.
146578 : if (0 /* isSgAsmNode(this) != NULL */)
146579 : {
146580 : // Support for regex specification.
146581 : std::string prefixCode = "REGEX:";
146582 : addNewAttribute(prefixCode + s,a);
146583 : }
146584 : #endif
146585 :
146586 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
146587 0 : return this;
146588 : }
146589 :
146590 : // *** COMMON CODE SECTION ENDS HERE ***
146591 :
146592 :
146593 : // End of memberFunctionString
146594 : // Start of memberFunctionString
146595 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
146596 :
146597 :
146598 : #if 0
146599 : //! Error checking support
146600 : /*! Verifies the following:
146601 : - working getVariant() member function
146602 : - calls base class's error() member function
146603 : Every class has one of these functions.
146604 : */
146605 : bool
146606 : SgCommonBlock::error()
146607 : {
146608 : // Put error checking here
146609 :
146610 : ROSE_ASSERT (this != NULL);
146611 : if (getVariant() != COMMON_BLOCK)
146612 : {
146613 : printf ("Error in SgCommonBlock::error(): SgCommonBlock object has a %s variant \n",
146614 : Cxx_GrammarTerminalNames[getVariant()].name);
146615 : // printf ("Error in SgCommonBlock::error() \n");
146616 : ROSE_ABORT();
146617 : }
146618 :
146619 : ROSE_ASSERT (getVariant() == COMMON_BLOCK);
146620 : return SgDeclarationStatement::error();
146621 : }
146622 : #endif
146623 :
146624 :
146625 :
146626 : // End of memberFunctionString
146627 :
146628 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
146629 :
146630 12 : SgCommonBlock* isSgCommonBlock ( SgNode* inputDerivedClassPointer )
146631 : {
146632 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
146633 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
146634 : // So to fix this we return NULL directly when the input is NULL and avoid the
146635 : // dynamic_cast in this case. This is likely a performance improvement as well.
146636 : // return dynamic_cast<SgCommonBlock*>(inputDerivedClassPointer);
146637 : // Milind Chabbi (8/28/2013): isSgCommonBlock uses table-driven castability instead of c++ default dynamic_cast
146638 : // this improves the running time performance by 10-20%.
146639 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCommonBlock*>(inputDerivedClassPointer);
146640 12 : return IS_SgCommonBlock_FAST_MACRO(inputDerivedClassPointer);
146641 : }
146642 :
146643 : // DQ (11/8/2003): Added version of functions taking const pointer
146644 0 : const SgCommonBlock* isSgCommonBlock ( const SgNode* inputDerivedClassPointer )
146645 : {
146646 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
146647 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
146648 : // So to fix this we return NULL directly when the input is NULL and avoid the
146649 : // dynamic_cast in this case. This is likely a performance improvement as well.
146650 : // return dynamic_cast<const SgCommonBlock*>(inputDerivedClassPointer);
146651 : // Milind Chabbi (8/28/2013): isSgCommonBlock uses table-driven castability instead of c++ default dynamic_cast
146652 : // this improves the running time performance by 10-20%.
146653 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCommonBlock*>(inputDerivedClassPointer);
146654 0 : return IS_SgCommonBlock_FAST_MACRO(inputDerivedClassPointer);
146655 : }
146656 :
146657 :
146658 :
146659 : /* #line 146660 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146660 :
146661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
146662 :
146663 : // Generated constructor
146664 0 : SgCommonBlock::SgCommonBlock ( Sg_File_Info* startOfConstruct )
146665 0 : : SgDeclarationStatement(startOfConstruct)
146666 : {
146667 : #ifdef DEBUG
146668 : // printf ("In SgCommonBlock::SgCommonBlock (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
146669 : #endif
146670 : #if 0
146671 : // debugging information!
146672 : printf ("In SgCommonBlock::SgCommonBlock (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
146673 : #endif
146674 :
146675 :
146676 :
146677 : #if 0
146678 : // DQ (7/30/2014): Call a virtual function.
146679 : std::string s = this->class_name();
146680 : #endif
146681 :
146682 : // Test the variant virtual function
146683 : // assert(COMMON_BLOCK == variant());
146684 0 : assert(COMMON_BLOCK == this->variant());
146685 0 : ROSE_ASSERT(COMMON_BLOCK == (int)(this->variantT()));
146686 0 : post_construction_initialization();
146687 :
146688 : // Test the isSgCommonBlock() function since it has been problematic
146689 0 : assert(isSgCommonBlock(this) != NULL);
146690 0 : }
146691 :
146692 : // Generated constructor (all data members)
146693 :
146694 : /* #line 146695 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146695 :
146696 :
146697 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
146698 :
146699 :
146700 : // ********************************************************
146701 : // member functions common across all array grammar objects
146702 : // ********************************************************
146703 :
146704 :
146705 :
146706 : /* #line 146707 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146707 :
146708 :
146709 :
146710 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
146711 :
146712 : // ********************************************************
146713 : // member functions specific to each node in the grammar
146714 : // ********************************************************
146715 :
146716 :
146717 : /* #line 146718 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
146718 :
146719 : // Start of memberFunctionString
146720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146721 :
146722 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146723 :
146724 : SgName
146725 3792280 : SgTypedefDeclaration::get_name () const
146726 : {
146727 3792280 : ROSE_ASSERT (this != NULL);
146728 :
146729 : #if 0
146730 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146731 : // used to trigger marking transformations for the token-based unparsing.
146732 : printf ("SgTypedefDeclaration::get_name = %p = %s \n",this,this->class_name().c_str());
146733 : #endif
146734 :
146735 3792280 : return p_name;
146736 : }
146737 :
146738 : void
146739 0 : SgTypedefDeclaration::set_name ( SgName name )
146740 : {
146741 0 : ROSE_ASSERT (this != NULL);
146742 :
146743 : #if 0
146744 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146745 : // used to trigger marking transformations for the token-based unparsing.
146746 : printf ("SgTypedefDeclaration::set_name = %p = %s \n",this,this->class_name().c_str());
146747 : #endif
146748 :
146749 0 : set_isModified(true);
146750 :
146751 0 : p_name = name;
146752 0 : }
146753 :
146754 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146755 :
146756 :
146757 : // End of memberFunctionString
146758 : // Start of memberFunctionString
146759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146760 :
146761 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146762 :
146763 : SgType*
146764 55091700 : SgTypedefDeclaration::get_base_type () const
146765 : {
146766 55091700 : ROSE_ASSERT (this != NULL);
146767 :
146768 : #if 0
146769 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146770 : // used to trigger marking transformations for the token-based unparsing.
146771 : printf ("SgTypedefDeclaration::get_base_type = %p = %s \n",this,this->class_name().c_str());
146772 : #endif
146773 :
146774 55091700 : return p_base_type;
146775 : }
146776 :
146777 : void
146778 0 : SgTypedefDeclaration::set_base_type ( SgType* base_type )
146779 : {
146780 0 : ROSE_ASSERT (this != NULL);
146781 :
146782 : #if 0
146783 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146784 : // used to trigger marking transformations for the token-based unparsing.
146785 : printf ("SgTypedefDeclaration::set_base_type = %p = %s \n",this,this->class_name().c_str());
146786 : #endif
146787 :
146788 0 : set_isModified(true);
146789 :
146790 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
146791 : if (p_base_type != NULL && base_type != NULL && p_base_type != base_type)
146792 : {
146793 : printf ("Warning: base_type = %p overwriting valid pointer p_base_type = %p \n",base_type,p_base_type);
146794 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
146795 : printf ("Error fails assertion (p_base_type != NULL && base_type != NULL && p_base_type != base_type) is false\n");
146796 : ROSE_ASSERT(false);
146797 : #endif
146798 : }
146799 : #endif
146800 0 : p_base_type = base_type;
146801 0 : }
146802 :
146803 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146804 :
146805 :
146806 : // End of memberFunctionString
146807 : // Start of memberFunctionString
146808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146809 :
146810 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146811 :
146812 : SgTypedefType*
146813 617312 : SgTypedefDeclaration::get_type () const
146814 : {
146815 617312 : ROSE_ASSERT (this != NULL);
146816 :
146817 : #if 0
146818 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146819 : // used to trigger marking transformations for the token-based unparsing.
146820 : printf ("SgTypedefDeclaration::get_type = %p = %s \n",this,this->class_name().c_str());
146821 : #endif
146822 :
146823 617312 : return p_type;
146824 : }
146825 :
146826 : void
146827 109059 : SgTypedefDeclaration::set_type ( SgTypedefType* type )
146828 : {
146829 109059 : ROSE_ASSERT (this != NULL);
146830 :
146831 : #if 0
146832 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146833 : // used to trigger marking transformations for the token-based unparsing.
146834 : printf ("SgTypedefDeclaration::set_type = %p = %s \n",this,this->class_name().c_str());
146835 : #endif
146836 :
146837 109059 : set_isModified(true);
146838 :
146839 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
146840 : if (p_type != NULL && type != NULL && p_type != type)
146841 : {
146842 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
146843 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
146844 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
146845 : ROSE_ASSERT(false);
146846 : #endif
146847 : }
146848 : #endif
146849 109059 : p_type = type;
146850 109059 : }
146851 :
146852 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146853 :
146854 :
146855 : // End of memberFunctionString
146856 : // Start of memberFunctionString
146857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146858 :
146859 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146860 :
146861 : SgDeclarationStatement*
146862 133346 : SgTypedefDeclaration::get_declaration () const
146863 : {
146864 133346 : ROSE_ASSERT (this != NULL);
146865 :
146866 : #if 0
146867 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146868 : // used to trigger marking transformations for the token-based unparsing.
146869 : printf ("SgTypedefDeclaration::get_declaration = %p = %s \n",this,this->class_name().c_str());
146870 : #endif
146871 :
146872 133346 : return p_declaration;
146873 : }
146874 :
146875 : void
146876 3874 : SgTypedefDeclaration::set_declaration ( SgDeclarationStatement* declaration )
146877 : {
146878 3874 : ROSE_ASSERT (this != NULL);
146879 :
146880 : #if 0
146881 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146882 : // used to trigger marking transformations for the token-based unparsing.
146883 : printf ("SgTypedefDeclaration::set_declaration = %p = %s \n",this,this->class_name().c_str());
146884 : #endif
146885 :
146886 3874 : set_isModified(true);
146887 :
146888 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
146889 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
146890 : {
146891 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
146892 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
146893 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
146894 : ROSE_ASSERT(false);
146895 : #endif
146896 : }
146897 : #endif
146898 3874 : p_declaration = declaration;
146899 3874 : }
146900 :
146901 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146902 :
146903 :
146904 : // End of memberFunctionString
146905 : // Start of memberFunctionString
146906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146907 :
146908 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146909 :
146910 : SgSymbol*
146911 81443 : SgTypedefDeclaration::get_parent_scope () const
146912 : {
146913 81443 : ROSE_ASSERT (this != NULL);
146914 :
146915 : #if 0
146916 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146917 : // used to trigger marking transformations for the token-based unparsing.
146918 : printf ("SgTypedefDeclaration::get_parent_scope = %p = %s \n",this,this->class_name().c_str());
146919 : #endif
146920 :
146921 81443 : return p_parent_scope;
146922 : }
146923 :
146924 : void
146925 0 : SgTypedefDeclaration::set_parent_scope ( SgSymbol* parent_scope )
146926 : {
146927 0 : ROSE_ASSERT (this != NULL);
146928 :
146929 : #if 0
146930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146931 : // used to trigger marking transformations for the token-based unparsing.
146932 : printf ("SgTypedefDeclaration::set_parent_scope = %p = %s \n",this,this->class_name().c_str());
146933 : #endif
146934 :
146935 0 : set_isModified(true);
146936 :
146937 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
146938 : if (p_parent_scope != NULL && parent_scope != NULL && p_parent_scope != parent_scope)
146939 : {
146940 : printf ("Warning: parent_scope = %p overwriting valid pointer p_parent_scope = %p \n",parent_scope,p_parent_scope);
146941 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
146942 : printf ("Error fails assertion (p_parent_scope != NULL && parent_scope != NULL && p_parent_scope != parent_scope) is false\n");
146943 : ROSE_ASSERT(false);
146944 : #endif
146945 : }
146946 : #endif
146947 0 : p_parent_scope = parent_scope;
146948 0 : }
146949 :
146950 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146951 :
146952 :
146953 : // End of memberFunctionString
146954 : // Start of memberFunctionString
146955 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146956 :
146957 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146958 :
146959 : bool
146960 39340 : SgTypedefDeclaration::get_typedefBaseTypeContainsDefiningDeclaration () const
146961 : {
146962 39340 : ROSE_ASSERT (this != NULL);
146963 :
146964 : #if 0
146965 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146966 : // used to trigger marking transformations for the token-based unparsing.
146967 : printf ("SgTypedefDeclaration::get_typedefBaseTypeContainsDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
146968 : #endif
146969 :
146970 39340 : return p_typedefBaseTypeContainsDefiningDeclaration;
146971 : }
146972 :
146973 : void
146974 58632 : SgTypedefDeclaration::set_typedefBaseTypeContainsDefiningDeclaration ( bool typedefBaseTypeContainsDefiningDeclaration )
146975 : {
146976 58632 : ROSE_ASSERT (this != NULL);
146977 :
146978 : #if 0
146979 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
146980 : // used to trigger marking transformations for the token-based unparsing.
146981 : printf ("SgTypedefDeclaration::set_typedefBaseTypeContainsDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
146982 : #endif
146983 :
146984 58632 : set_isModified(true);
146985 :
146986 58632 : p_typedefBaseTypeContainsDefiningDeclaration = typedefBaseTypeContainsDefiningDeclaration;
146987 58632 : }
146988 :
146989 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
146990 :
146991 :
146992 : // End of memberFunctionString
146993 : // Start of memberFunctionString
146994 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
146995 :
146996 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
146997 :
146998 : SgScopeStatement*
146999 4081710 : SgTypedefDeclaration::get_scope () const
147000 : {
147001 4081710 : ROSE_ASSERT (this != NULL);
147002 :
147003 : #if 0
147004 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147005 : // used to trigger marking transformations for the token-based unparsing.
147006 : printf ("SgTypedefDeclaration::get_scope = %p = %s \n",this,this->class_name().c_str());
147007 : #endif
147008 :
147009 4081710 : return p_scope;
147010 : }
147011 :
147012 : void
147013 57176 : SgTypedefDeclaration::set_scope ( SgScopeStatement* scope )
147014 : {
147015 57176 : ROSE_ASSERT (this != NULL);
147016 :
147017 : #if 0
147018 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147019 : // used to trigger marking transformations for the token-based unparsing.
147020 : printf ("SgTypedefDeclaration::set_scope = %p = %s \n",this,this->class_name().c_str());
147021 : #endif
147022 :
147023 57176 : set_isModified(true);
147024 :
147025 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
147026 : if (p_scope != NULL && scope != NULL && p_scope != scope)
147027 : {
147028 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
147029 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
147030 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
147031 : ROSE_ASSERT(false);
147032 : #endif
147033 : }
147034 : #endif
147035 57176 : p_scope = scope;
147036 57176 : }
147037 :
147038 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
147039 :
147040 :
147041 : // End of memberFunctionString
147042 : // Start of memberFunctionString
147043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
147044 :
147045 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
147046 :
147047 : bool
147048 0 : SgTypedefDeclaration::get_isAutonomousDeclaration () const
147049 : {
147050 0 : ROSE_ASSERT (this != NULL);
147051 :
147052 : #if 0
147053 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147054 : // used to trigger marking transformations for the token-based unparsing.
147055 : printf ("SgTypedefDeclaration::get_isAutonomousDeclaration = %p = %s \n",this,this->class_name().c_str());
147056 : #endif
147057 :
147058 0 : return p_isAutonomousDeclaration;
147059 : }
147060 :
147061 : void
147062 0 : SgTypedefDeclaration::set_isAutonomousDeclaration ( bool isAutonomousDeclaration )
147063 : {
147064 0 : ROSE_ASSERT (this != NULL);
147065 :
147066 : #if 0
147067 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147068 : // used to trigger marking transformations for the token-based unparsing.
147069 : printf ("SgTypedefDeclaration::set_isAutonomousDeclaration = %p = %s \n",this,this->class_name().c_str());
147070 : #endif
147071 :
147072 0 : set_isModified(true);
147073 :
147074 0 : p_isAutonomousDeclaration = isAutonomousDeclaration;
147075 0 : }
147076 :
147077 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
147078 :
147079 :
147080 : // End of memberFunctionString
147081 : // Start of memberFunctionString
147082 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
147083 :
147084 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
147085 :
147086 : bool
147087 5191 : SgTypedefDeclaration::get_isAssociatedWithDeclarationList () const
147088 : {
147089 5191 : ROSE_ASSERT (this != NULL);
147090 :
147091 : #if 0
147092 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147093 : // used to trigger marking transformations for the token-based unparsing.
147094 : printf ("SgTypedefDeclaration::get_isAssociatedWithDeclarationList = %p = %s \n",this,this->class_name().c_str());
147095 : #endif
147096 :
147097 5191 : return p_isAssociatedWithDeclarationList;
147098 : }
147099 :
147100 : void
147101 100 : SgTypedefDeclaration::set_isAssociatedWithDeclarationList ( bool isAssociatedWithDeclarationList )
147102 : {
147103 100 : ROSE_ASSERT (this != NULL);
147104 :
147105 : #if 0
147106 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147107 : // used to trigger marking transformations for the token-based unparsing.
147108 : printf ("SgTypedefDeclaration::set_isAssociatedWithDeclarationList = %p = %s \n",this,this->class_name().c_str());
147109 : #endif
147110 :
147111 100 : set_isModified(true);
147112 :
147113 100 : p_isAssociatedWithDeclarationList = isAssociatedWithDeclarationList;
147114 100 : }
147115 :
147116 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
147117 :
147118 :
147119 : // End of memberFunctionString
147120 : // Start of memberFunctionString
147121 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
147122 :
147123 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
147124 :
147125 : bool
147126 0 : SgTypedefDeclaration::get_isFirstDeclarationOfDeclarationList () const
147127 : {
147128 0 : ROSE_ASSERT (this != NULL);
147129 :
147130 : #if 0
147131 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147132 : // used to trigger marking transformations for the token-based unparsing.
147133 : printf ("SgTypedefDeclaration::get_isFirstDeclarationOfDeclarationList = %p = %s \n",this,this->class_name().c_str());
147134 : #endif
147135 :
147136 0 : return p_isFirstDeclarationOfDeclarationList;
147137 : }
147138 :
147139 : void
147140 0 : SgTypedefDeclaration::set_isFirstDeclarationOfDeclarationList ( bool isFirstDeclarationOfDeclarationList )
147141 : {
147142 0 : ROSE_ASSERT (this != NULL);
147143 :
147144 : #if 0
147145 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147146 : // used to trigger marking transformations for the token-based unparsing.
147147 : printf ("SgTypedefDeclaration::set_isFirstDeclarationOfDeclarationList = %p = %s \n",this,this->class_name().c_str());
147148 : #endif
147149 :
147150 0 : set_isModified(true);
147151 :
147152 0 : p_isFirstDeclarationOfDeclarationList = isFirstDeclarationOfDeclarationList;
147153 0 : }
147154 :
147155 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
147156 :
147157 :
147158 : // End of memberFunctionString
147159 : // Start of memberFunctionString
147160 :
147161 :
147162 : // End of memberFunctionString
147163 : // Start of memberFunctionString
147164 : /* #line 16062 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
147165 :
147166 :
147167 : void
147168 56574 : SgTypedefDeclaration::post_construction_initialization()
147169 : {
147170 : // DQ (10/6/2004): I think this should be dependent upon if the type was provided as an input in
147171 : // the constructor parameter list (else why bother specifying it in the constructor parameter list!)
147172 : #if 0
147173 : #if PRINT_DEVELOPER_WARNINGS
147174 : printf ("In SgTypedefDeclaration::post_construction_initialization(): generating SgTypedefType internally! \n");
147175 : #endif
147176 : #endif
147177 :
147178 : #if 0
147179 : // DQ (3/20/2012): We would like to assert this, but I don't think it is always possible. For example, test2001_19.C fails for this test.
147180 : // ROSE_ASSERT(this->get_parent_scope() != NULL);
147181 : if (this->get_parent_scope() == NULL)
147182 : {
147183 : printf ("WARNING: In SgTypedefDeclaration::post_construction_initialization(): this->get_parent_scope() == NULL \n");
147184 : }
147185 : #endif
147186 :
147187 : #if 0
147188 : printf ("In SgTypedefDeclaration::post_construction_initialization(): NO LONGER calling SgTypedefType::createType() using this = %p = %s \n",this,this->class_name().c_str());
147189 : #endif
147190 :
147191 : // DQ (2/27/2018): It is an inconsistancy for the type to be set here.
147192 : // set_type(SgTypedefType::createType(this));
147193 :
147194 : #if 0
147195 : // printf ("In SgTypedefDeclaration::post_construction_initialization(): DONE calling SgTypedefType::createType() using this = %p = %s \n",this,this->class_name().c_str());
147196 : #endif
147197 :
147198 56574 : ROSE_ASSERT (get_base_type() != NULL);
147199 56574 : ROSE_ASSERT (get_base_type()->get_typedefs() != NULL);
147200 :
147201 : // DQ (2/27/2018): Since we don't build the typedef type here, we have to modify this assertion.
147202 : // ROSE_ASSERT (get_base_type()->get_typedefs()->get_typedefs().size() > 0);
147203 56574 : ROSE_ASSERT (get_base_type()->get_typedefs()->get_typedefs().size() >= 0);
147204 56574 : }
147205 :
147206 : // SgStatement *get_next(int&) const;
147207 :
147208 : bool
147209 0 : SgTypedefDeclaration::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
147210 : {
147211 0 : return ( StatementReplace(this, p_declaration, target, newstmt) == true );
147212 : }
147213 :
147214 : #if 0
147215 : SgStatement*
147216 : SgTypedefDeclaration::get_next(int& n) const
147217 : {
147218 : if(n)
147219 : return 0;
147220 : else
147221 : {
147222 : n++;
147223 : return get_declaration();
147224 : }
147225 : }
147226 : #endif
147227 :
147228 : SgName
147229 0 : SgTypedefDeclaration::get_qualified_name() const
147230 : {
147231 : // DQ (10/15/2004): This function is similar to the one for SgClassDeclaration.
147232 : // This function calls get_scope() which uses the parent pointers, thus
147233 : // it should not be called before the parent pointers are set (within the AST fixup after
147234 : // the Sage III AST is fully constructed).
147235 :
147236 : // printf ("In SgTypedefDeclaration::get_qualified_name() name = %s \n",get_name().str());
147237 :
147238 0 : SgName returnName;
147239 :
147240 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
147241 0 : SgScopeStatement* scope = get_scope();
147242 0 : ROSE_ASSERT(scope != NULL);
147243 :
147244 0 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
147245 :
147246 : // printf ("In SgTypedefDeclaration::get_qualified_name() returnName = %s \n",returnName.str());
147247 :
147248 0 : return returnName;
147249 : }
147250 :
147251 : SgName
147252 15018 : SgTypedefDeclaration::get_qualified_name_prefix_for_base_type() const
147253 : {
147254 : // DQ (2/14/2019): this feature to support name qualification on typedef base type
147255 : // declarations appears to not be used, though the design for it is in place.
147256 :
147257 : // DQ (5/29/2011): Added to support for new qualified name generation.
147258 : // this function has a different name from the base class since it requires
147259 : // a different definition to support using the SgNode::get_globalQualifiedNameMapForTypes()
147260 : // function instead of the SgNode::get_globalQualifiedNameMapForNames() function.
147261 : // This function generates the qualified name prefix to be used with
147262 : // the base type of the typedef declaration.
147263 :
147264 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
147265 : // different and so it depends upon where the type is referenced. Thus the qualified name is
147266 : // stored in a map to the IR node that references the type.
147267 15018 : SgName nameQualifier;
147268 15018 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgTypedefDeclaration*>(this));
147269 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
147270 :
147271 : #if 0
147272 : printf ("In SgTypedefDeclaration::get_qualified_name_prefix_for_base_type(): SgNode::get_globalQualifiedNameMapForTypes().size() = %zu \n",SgNode::get_globalQualifiedNameMapForTypes().size());
147273 : #endif
147274 :
147275 15018 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
147276 : {
147277 10052 : nameQualifier = i->second;
147278 : #if 0
147279 : printf ("FOUND a valid name qualification: nameQualifier %s \n",nameQualifier.str());
147280 : #endif
147281 : }
147282 : else
147283 : {
147284 : #if 0
147285 : printf ("COULD NOT find a valid name qualification \n");
147286 : #endif
147287 : }
147288 :
147289 : #if 0
147290 : printf ("nameQualifier for SgFunctionDeclaration = %s = %s \n",class_name().c_str(),nameQualifier.str());
147291 : #endif
147292 :
147293 15018 : return nameQualifier;
147294 : }
147295 :
147296 : #define DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME 0
147297 :
147298 : // RV (1/30/2006): Revised to follow typedef chains to their base types.
147299 17459500 : SgName SgTypedefDeclaration::get_mangled_name (void) const {
147300 34919100 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgTypedefDeclaration*>(this));
147301 17459500 : if (mangledNameString.empty() == false)
147302 : {
147303 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147304 : printf ("In SgTypedefDeclaration::get_mangled_name(): (from cache) %s \n", mangledNameString.c_str() );
147305 : #endif
147306 17335000 : return mangledNameString;
147307 : }
147308 : else
147309 : {
147310 124551 : SgName mangledName;
147311 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147312 : printf ("In SgTypedefDeclaration::get_mangled_name(): before calling get_base_type() \n");
147313 : #endif
147314 124551 : SgType* baseType = get_base_type();
147315 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147316 : // DQ (5/23/2018): Added assertion prior to the debug statement below.
147317 : ROSE_ASSERT(baseType != NULL);
147318 : printf ("In SgTypedefDeclaration::get_mangled_name(): after calling get_base_type(): baseType = %p = %s \n",baseType,baseType->class_name().c_str());
147319 : if (get_file_info() != NULL)
147320 : {
147321 : printf (" --- typedef source position: line = %d \n",get_file_info()->get_line());
147322 : }
147323 : else
147324 : {
147325 : printf (" --- typedef source position: line = (unknown) \n");
147326 : }
147327 : #endif
147328 :
147329 : // DQ (6/3/2006): I think this is a better implementation of name mangling for a typedef
147330 : // (need to include the name and the type) but I'm not clear if we want the scope.
147331 124551 : ROSE_ASSERT(baseType != NULL);
147332 :
147333 : // DQ (3/14/2012): We want to have a valid scope so that we can build a properly
147334 : // mangled name but the scope is not yet available unless we modify the constructor
147335 : // (which would break some code). So allow this to be built for now and we will
147336 : // see if it is an issue. Make it a warning to not have a valid scope. Note
147337 : // that this is only an issue for C++. We also might not want to add the name
147338 : // to the cache if the scope was NULL.
147339 : // mangledName = joinMangledQualifiers (mangleQualifiers(get_scope()), get_name()) + baseType->get_mangled();
147340 :
147341 249102 : string mangleQualifiersString;
147342 : // mangleQualifiersString = mangleQualifiers(get_scope());
147343 :
147344 124551 : SgScopeStatement* scope = get_scope();
147345 124551 : if (scope == NULL)
147346 : {
147347 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147348 : printf ("ERROR: SgTypedefDeclaration::get_mangled_name(): get_scope() == NULL, mangleQualifiers would be invalid\n");
147349 : printf (" -- this = %p (%s) = %s\n", this, this->class_name().c_str(), this->get_name().getString().c_str());
147350 : SgNode * parent = get_parent();
147351 : printf (" -- parent = %p (%s)\n", parent, parent ? parent->class_name().c_str() : "");
147352 : ROSE_ASSERT(false);
147353 : #endif
147354 : // DQ (3/20/2012): Added for debugging.
147355 : // ROSE_ASSERT(false);
147356 : }
147357 : else
147358 : {
147359 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147360 : printf ("In SgTypedefDeclaration::get_mangled_name(): scope = %p = %s (calling mangleQualifiers()) \n",scope,scope->class_name().c_str());
147361 : #endif
147362 124551 : mangleQualifiersString = mangleQualifiers(scope);
147363 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147364 : printf ("DONE: In SgTypedefDeclaration::get_mangled_name(): mangleQualifiersString = %s scope = %p = %s (calling mangleQualifiers()) \n",mangleQualifiersString.c_str(),scope,scope->class_name().c_str());
147365 : #endif
147366 : }
147367 :
147368 : // DQ (9/6/2016): We require a prefix to the name to avoid name collisions (see test2005_199.C and simplified test (but non-failing) in test2016_60.C).
147369 : // mangledName = joinMangledQualifiers (mangleQualifiersString,get_name()) + baseType->get_mangled();
147370 373653 : SgName prefixed_name = "typedef_" + get_name();
147371 :
147372 : #if 0
147373 : printf ("In SgTypedefDeclaration::get_mangled_name(): prefixed_name = %s \n",prefixed_name.str());
147374 : #endif
147375 : #define ADD_MANGLED_NAME_OF_BASE_TYPE 0
147376 : #if ADD_MANGLED_NAME_OF_BASE_TYPE
147377 : // DQ (6/30/2018): I think the call to the baseType->get_mangled() is the cause of the infinite loop in test2018_118.C.
147378 : // mangledName = joinMangledQualifiers(mangleQualifiersString,prefixed_name) + baseType->get_mangled();
147379 : // SgName baseTypeMangleName = baseType->get_mangled();
147380 :
147381 : static std::set<SgType*> baseTypeSet;
147382 :
147383 : SgName baseTypeMangleName;
147384 : if (baseTypeSet.find(baseType) == baseTypeSet.end())
147385 : {
147386 : baseTypeSet.insert(baseType);
147387 : baseTypeMangleName = baseType->get_mangled();
147388 : }
147389 : else
147390 : {
147391 : // Avoid infinite recursion in computation of mangled names.
147392 : baseTypeMangleName = "_previously_seen_baseType_" + Rose::StringUtility::numberToString(baseType);
147393 : }
147394 :
147395 : #if 0
147396 : static int base_type_counter = 0;
147397 : printf ("In SgTypedefDeclaration::get_mangled_name(): calling baseType->get_mangled(): base_type_counter = %d baseType = %p = %s \n",base_type_counter++,baseType,baseType->class_name().c_str());
147398 : #endif
147399 :
147400 : #if 0
147401 : printf ("DONE: In SgTypedefDeclaration::get_mangled_name(): calling baseType->get_mangled(): baseType = %p = %s \n",baseType,baseType->class_name().c_str());
147402 : #endif
147403 : #if 0
147404 : printf ("In SgTypedefDeclaration::get_mangled_name(): baseTypeMangleName = %s \n",baseTypeMangleName.str());
147405 : #endif
147406 : mangledName = joinMangledQualifiers(mangleQualifiersString,prefixed_name) + baseTypeMangleName;
147407 : #else
147408 124551 : mangledName = joinMangledQualifiers(mangleQualifiersString,prefixed_name);
147409 : #endif
147410 : // DQ (1/29/2007): We need to make this more specific to this IR nodes so that a typedef of an unnamed struct does not be mangled to be the same name
147411 124551 : mangledName += "__typedef_declaration";
147412 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147413 : printf ("In SgTypedefDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
147414 : #endif
147415 124551 : ROSE_ASSERT (mangledName.get_length() > 0);
147416 : #if 0
147417 : printf ("In SgTypedefDeclaration::get_mangled_name(): calling SageInterface::addMangledNameToCache(): mangledName = %s \n",mangledName.str());
147418 : #endif
147419 :
147420 : // p_globalMangledNameMap[declaration] = mangledName;
147421 204790 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgTypedefDeclaration*>(this),mangledName);
147422 : #if DEBUG_TYPEDEF_DECLARATION_GET_MANGLED_NAME
147423 : printf ("In SgTypedefDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
147424 : #endif
147425 124551 : return mangledName;
147426 : }
147427 : }
147428 :
147429 : bool
147430 56832 : SgTypedefDeclaration::hasExplicitScope() const
147431 : {
147432 : // This function reports that this IR node stores its scope explicitly.
147433 :
147434 56832 : return true;
147435 : }
147436 :
147437 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
147438 : SgSymbol*
147439 56661 : SgTypedefDeclaration::get_symbol_from_symbol_table() const
147440 : {
147441 56661 : ROSE_ASSERT(get_scope() != NULL);
147442 :
147443 : #if 0
147444 : printf ("In SgTypedefDeclaration::get_symbol_from_symbol_table(): calling get_scope()->find_symbol_from_declaration(this) \n");
147445 : #endif
147446 :
147447 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
147448 : // return get_scope()->get_symbol_table()->find(this);
147449 56661 : return get_scope()->find_symbol_from_declaration(this);
147450 : }
147451 :
147452 : // GB (09/25/2007): Added this function as part of the traversal island fix. It returns the p_declaration data member,
147453 : // but only if this typedef statement is actually the place where the base type is defined.
147454 : SgDeclarationStatement *
147455 3256800 : SgTypedefDeclaration::compute_baseTypeDefiningDeclaration() const
147456 : {
147457 3256800 : if (p_typedefBaseTypeContainsDefiningDeclaration == true)
147458 : {
147459 176031 : return p_declaration;
147460 : }
147461 : else
147462 : {
147463 : return NULL;
147464 : }
147465 : }
147466 :
147467 : SgDeclarationStatement *
147468 5 : SgTypedefDeclaration::get_baseTypeDefiningDeclaration() const
147469 : {
147470 : // DQ (10/14/2007): This provides an public (compute_baseTypeDefiningDeclaration() is private)
147471 : // interface similar to that for SgVariableDeclaration and for the same purpose (types defined
147472 : // in the typedef or variable declaration).
147473 :
147474 5 : return compute_baseTypeDefiningDeclaration();
147475 : }
147476 :
147477 : bool
147478 5191 : SgTypedefDeclaration::get_requiresGlobalNameQualificationOnType () const
147479 : {
147480 5191 : ROSE_ASSERT (this != NULL);
147481 5191 : return p_requiresGlobalNameQualificationOnType;
147482 : }
147483 :
147484 : void
147485 0 : SgTypedefDeclaration::set_requiresGlobalNameQualificationOnType ( bool requiresGlobalNameQualificationOnType )
147486 : {
147487 0 : ROSE_ASSERT (this != NULL);
147488 : // This can't be called by the name qualification API (see test2015_26.C).
147489 : // set_isModified(true);
147490 :
147491 0 : p_requiresGlobalNameQualificationOnType = requiresGlobalNameQualificationOnType;
147492 0 : }
147493 :
147494 : int
147495 5191 : SgTypedefDeclaration::get_name_qualification_length_for_base_type () const
147496 : {
147497 5191 : ROSE_ASSERT (this != NULL);
147498 5191 : return p_name_qualification_length_for_base_type;
147499 : }
147500 :
147501 : void
147502 13024 : SgTypedefDeclaration::set_name_qualification_length_for_base_type ( int name_qualification_length_for_base_type )
147503 : {
147504 13024 : ROSE_ASSERT (this != NULL);
147505 : // This can't be called by the name qualification API (see test2015_26.C).
147506 : // set_isModified(true);
147507 :
147508 13024 : p_name_qualification_length_for_base_type = name_qualification_length_for_base_type;
147509 13024 : }
147510 :
147511 : bool
147512 5191 : SgTypedefDeclaration::get_type_elaboration_required_for_base_type () const
147513 : {
147514 5191 : ROSE_ASSERT (this != NULL);
147515 5191 : return p_type_elaboration_required_for_base_type;
147516 : }
147517 :
147518 : void
147519 13024 : SgTypedefDeclaration::set_type_elaboration_required_for_base_type ( bool type_elaboration_required_for_base_type )
147520 : {
147521 13024 : ROSE_ASSERT (this != NULL);
147522 : // This can't be called by the name qualification API (see test2015_26.C).
147523 : // set_isModified(true);
147524 :
147525 13024 : p_type_elaboration_required_for_base_type = type_elaboration_required_for_base_type;
147526 13024 : }
147527 :
147528 : bool
147529 5191 : SgTypedefDeclaration::get_global_qualification_required_for_base_type () const
147530 : {
147531 5191 : ROSE_ASSERT (this != NULL);
147532 5191 : return p_global_qualification_required_for_base_type;
147533 : }
147534 :
147535 : void
147536 13024 : SgTypedefDeclaration::set_global_qualification_required_for_base_type ( bool global_qualification_required_for_base_type )
147537 : {
147538 13024 : ROSE_ASSERT (this != NULL);
147539 : // This can't be called by the name qualification API (see test2015_26.C).
147540 : // set_isModified(true);
147541 :
147542 13024 : p_global_qualification_required_for_base_type = global_qualification_required_for_base_type;
147543 13024 : }
147544 :
147545 : // DQ (4/10/2019): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
147546 : int
147547 0 : SgTypedefDeclaration::get_name_qualification_length () const
147548 : {
147549 0 : ROSE_ASSERT (this != NULL);
147550 0 : return p_name_qualification_length;
147551 : }
147552 :
147553 : // DQ (4/10/2019): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
147554 : void
147555 0 : SgTypedefDeclaration::set_name_qualification_length ( int name_qualification_length )
147556 : {
147557 0 : ROSE_ASSERT (this != NULL);
147558 : // This can't be called by the name qualification API (see test2015_26.C).
147559 : // set_isModified(true);
147560 :
147561 0 : p_name_qualification_length = name_qualification_length;
147562 0 : }
147563 :
147564 : // DQ (4/10/2019): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
147565 : bool
147566 0 : SgTypedefDeclaration::get_type_elaboration_required () const
147567 : {
147568 0 : ROSE_ASSERT (this != NULL);
147569 0 : return p_type_elaboration_required;
147570 : }
147571 :
147572 : // DQ (4/10/2019): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
147573 : void
147574 0 : SgTypedefDeclaration::set_type_elaboration_required ( bool type_elaboration_required )
147575 : {
147576 0 : ROSE_ASSERT (this != NULL);
147577 : // This can't be called by the name qualification API (see test2015_26.C).
147578 : // set_isModified(true);
147579 :
147580 0 : p_type_elaboration_required = type_elaboration_required;
147581 0 : }
147582 :
147583 : // DQ (4/10/2019): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
147584 : bool
147585 0 : SgTypedefDeclaration::get_global_qualification_required () const
147586 : {
147587 0 : ROSE_ASSERT (this != NULL);
147588 0 : return p_global_qualification_required;
147589 : }
147590 :
147591 : // DQ (4/10/2019): Added support for none ROSETTA generated access functions to avoid isModified flag setting semantics.
147592 : void
147593 0 : SgTypedefDeclaration::set_global_qualification_required ( bool global_qualification_required )
147594 : {
147595 0 : ROSE_ASSERT (this != NULL);
147596 : // This can't be called by the name qualification API (see test2015_26.C).
147597 : // set_isModified(true);
147598 :
147599 0 : p_global_qualification_required = global_qualification_required;
147600 0 : }
147601 :
147602 :
147603 :
147604 : // End of memberFunctionString
147605 : // Start of memberFunctionString
147606 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
147607 :
147608 : // *** COMMON CODE SECTION BEGINS HERE ***
147609 :
147610 : #if 0
147611 : int
147612 : SgTypedefDeclaration::getVariant() const
147613 : {
147614 : // This function is used in ROSE while "variant()" is used in SAGE
147615 : assert(this != NULL);
147616 : return variant();
147617 : }
147618 : #endif
147619 :
147620 : // This function is used in ROSE in treeTraversal code
147621 : // eventually replaces getVariant() and variant()
147622 : // though after variant() has been removed for a while we will
147623 : // want to change the name of variantT() back to variant()
147624 : // (since the "T" was ment to stand for temporary).
147625 : // When this happens the variantT() will be depricated.
147626 : VariantT
147627 177382000 : SgTypedefDeclaration::variantT() const
147628 : {
147629 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
147630 177382000 : ROSE_ASSERT(this != NULL);
147631 177382000 : return V_SgTypedefDeclaration;
147632 : }
147633 :
147634 : #if 0
147635 : int
147636 : SgTypedefDeclaration::variant() const
147637 : {
147638 : // This function is used in SAGE
147639 : ROSE_ASSERT(this != NULL);
147640 : return TYPEDEF_STMT;
147641 : }
147642 : #endif
147643 :
147644 : ROSE_DLL_API const char*
147645 579 : SgTypedefDeclaration::sage_class_name() const
147646 : {
147647 579 : ROSE_ASSERT(this != NULL);
147648 579 : return "SgTypedefDeclaration";
147649 : }
147650 :
147651 : std::string
147652 248878 : SgTypedefDeclaration::class_name() const
147653 : {
147654 248878 : ROSE_ASSERT(this != NULL);
147655 248878 : return "SgTypedefDeclaration";
147656 : }
147657 :
147658 : // DQ (11/26/2005): Support for visitor pattern mechanims
147659 : // (inferior to ROSE traversal mechanism, experimental).
147660 : void
147661 223774 : SgTypedefDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
147662 : {
147663 223774 : ROSE_ASSERT(this != NULL);
147664 223774 : visitor.visit(this);
147665 223774 : }
147666 :
147667 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
147668 0 : void SgTypedefDeclaration::accept (ROSE_VisitorPattern & visitor) {
147669 0 : ROSE_ASSERT(this != NULL);
147670 0 : visitor.visit(this);
147671 0 : }
147672 :
147673 : SgTypedefDeclaration*
147674 0 : SgTypedefDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
147675 : {
147676 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
147677 : // This function is currently only supported for the AST used the represent Binary executables.
147678 : if (0 /* isSgAsmNode(this) != NULL */)
147679 : {
147680 : // Support for regex specification.
147681 : std::string prefixCode = "REGEX:";
147682 : addNewAttribute(prefixCode + s,a);
147683 : }
147684 : #endif
147685 :
147686 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
147687 0 : return this;
147688 : }
147689 :
147690 : // *** COMMON CODE SECTION ENDS HERE ***
147691 :
147692 :
147693 : // End of memberFunctionString
147694 : // Start of memberFunctionString
147695 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
147696 :
147697 :
147698 : #if 0
147699 : //! Error checking support
147700 : /*! Verifies the following:
147701 : - working getVariant() member function
147702 : - calls base class's error() member function
147703 : Every class has one of these functions.
147704 : */
147705 : bool
147706 : SgTypedefDeclaration::error()
147707 : {
147708 : // Put error checking here
147709 :
147710 : ROSE_ASSERT (this != NULL);
147711 : if (getVariant() != TYPEDEF_STMT)
147712 : {
147713 : printf ("Error in SgTypedefDeclaration::error(): SgTypedefDeclaration object has a %s variant \n",
147714 : Cxx_GrammarTerminalNames[getVariant()].name);
147715 : // printf ("Error in SgTypedefDeclaration::error() \n");
147716 : ROSE_ABORT();
147717 : }
147718 :
147719 : ROSE_ASSERT (getVariant() == TYPEDEF_STMT);
147720 : return SgDeclarationStatement::error();
147721 : }
147722 : #endif
147723 :
147724 :
147725 :
147726 : // End of memberFunctionString
147727 :
147728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
147729 :
147730 140819000 : SgTypedefDeclaration* isSgTypedefDeclaration ( SgNode* inputDerivedClassPointer )
147731 : {
147732 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
147733 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
147734 : // So to fix this we return NULL directly when the input is NULL and avoid the
147735 : // dynamic_cast in this case. This is likely a performance improvement as well.
147736 : // return dynamic_cast<SgTypedefDeclaration*>(inputDerivedClassPointer);
147737 : // Milind Chabbi (8/28/2013): isSgTypedefDeclaration uses table-driven castability instead of c++ default dynamic_cast
147738 : // this improves the running time performance by 10-20%.
147739 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypedefDeclaration*>(inputDerivedClassPointer);
147740 140819000 : return IS_SgTypedefDeclaration_FAST_MACRO(inputDerivedClassPointer);
147741 : }
147742 :
147743 : // DQ (11/8/2003): Added version of functions taking const pointer
147744 56060 : const SgTypedefDeclaration* isSgTypedefDeclaration ( const SgNode* inputDerivedClassPointer )
147745 : {
147746 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
147747 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
147748 : // So to fix this we return NULL directly when the input is NULL and avoid the
147749 : // dynamic_cast in this case. This is likely a performance improvement as well.
147750 : // return dynamic_cast<const SgTypedefDeclaration*>(inputDerivedClassPointer);
147751 : // Milind Chabbi (8/28/2013): isSgTypedefDeclaration uses table-driven castability instead of c++ default dynamic_cast
147752 : // this improves the running time performance by 10-20%.
147753 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypedefDeclaration*>(inputDerivedClassPointer);
147754 56060 : return IS_SgTypedefDeclaration_FAST_MACRO(inputDerivedClassPointer);
147755 : }
147756 :
147757 :
147758 :
147759 : /* #line 147760 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
147760 :
147761 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
147762 :
147763 : /**
147764 : \brief Generated destructor
147765 :
147766 : This destructor is automatically generated (by ROSETTA). This destructor
147767 : only frees memory of data members associated with the parts of the current IR node which
147768 : are NOT traversed. Those data members that are part of a traversal can be freed using
147769 : a traversal (calling this destructor on all children in a post-order traversal). Such
147770 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
147771 :
147772 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
147773 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
147774 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
147775 :
147776 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
147777 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
147778 : pointers are not yet implemented to call delete on eash pointer in the container.
147779 : (This could be done by derivation from the STL containers to define containers that
147780 : automatically deleted their members.)
147781 :
147782 : */
147783 7196 : SgTypedefDeclaration::~SgTypedefDeclaration () {
147784 3758 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
147785 :
147786 :
147787 : // case: not a listType for name
147788 3758 : p_name = ""; // non list case
147789 : // case: not a listType for base_type
147790 3758 : p_base_type = NULL; // non list case
147791 : // case: not a listType for type
147792 3758 : p_type = NULL; // non list case
147793 : // case: not a listType for declaration
147794 3758 : p_declaration = NULL; // non list case
147795 : // case: not a listType for parent_scope
147796 3758 : p_parent_scope = NULL; // non list case
147797 : // case: not a listType for typedefBaseTypeContainsDefiningDeclaration
147798 3758 : p_typedefBaseTypeContainsDefiningDeclaration = false; // non list case
147799 : // case: not a listType for scope
147800 3758 : p_scope = NULL; // non list case
147801 : // case: not a listType for requiresGlobalNameQualificationOnType
147802 3758 : p_requiresGlobalNameQualificationOnType = false; // non list case
147803 : // case: not a listType for name_qualification_length_for_base_type
147804 3758 : p_name_qualification_length_for_base_type = 0; // non list case
147805 : // case: not a listType for type_elaboration_required_for_base_type
147806 3758 : p_type_elaboration_required_for_base_type = false; // non list case
147807 : // case: not a listType for global_qualification_required_for_base_type
147808 3758 : p_global_qualification_required_for_base_type = false; // non list case
147809 : // case: not a listType for isAutonomousDeclaration
147810 3758 : p_isAutonomousDeclaration = true; // non list case
147811 : // case: not a listType for isAssociatedWithDeclarationList
147812 3758 : p_isAssociatedWithDeclarationList = false; // non list case
147813 : // case: not a listType for isFirstDeclarationOfDeclarationList
147814 3758 : p_isFirstDeclarationOfDeclarationList = true; // non list case
147815 : // case: not a listType for name_qualification_length
147816 3758 : p_name_qualification_length = 0; // non list case
147817 : // case: not a listType for type_elaboration_required
147818 3758 : p_type_elaboration_required = false; // non list case
147819 : // case: not a listType for global_qualification_required
147820 3758 : p_global_qualification_required = false; // non list case
147821 :
147822 : }
147823 :
147824 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
147825 7196 : }
147826 :
147827 :
147828 : /* #line 147829 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
147829 :
147830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
147831 :
147832 : // Generated constructor
147833 0 : SgTypedefDeclaration::SgTypedefDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope )
147834 0 : : SgDeclarationStatement(startOfConstruct)
147835 : {
147836 : #ifdef DEBUG
147837 : // printf ("In SgTypedefDeclaration::SgTypedefDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope) sage_class_name() = %s \n",sage_class_name());
147838 : #endif
147839 : #if 0
147840 : // debugging information!
147841 : printf ("In SgTypedefDeclaration::SgTypedefDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope): this = %p = %s \n",this,this->class_name().c_str());
147842 : #endif
147843 :
147844 0 : p_name = name;
147845 0 : p_base_type = base_type;
147846 0 : p_type = type;
147847 0 : p_declaration = declaration;
147848 0 : p_parent_scope = parent_scope;
147849 0 : p_typedefBaseTypeContainsDefiningDeclaration = false;
147850 0 : p_scope = NULL;
147851 0 : p_requiresGlobalNameQualificationOnType = false;
147852 0 : p_name_qualification_length_for_base_type = 0;
147853 0 : p_type_elaboration_required_for_base_type = false;
147854 0 : p_global_qualification_required_for_base_type = false;
147855 0 : p_isAutonomousDeclaration = true;
147856 0 : p_isAssociatedWithDeclarationList = false;
147857 0 : p_isFirstDeclarationOfDeclarationList = true;
147858 0 : p_name_qualification_length = 0;
147859 0 : p_type_elaboration_required = false;
147860 0 : p_global_qualification_required = false;
147861 :
147862 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
147863 :
147864 : #if 0
147865 : // DQ (7/30/2014): Call a virtual function.
147866 : std::string s = this->class_name();
147867 : #endif
147868 :
147869 : // Test the variant virtual function
147870 : // assert(TYPEDEF_STMT == variant());
147871 0 : assert(TYPEDEF_STMT == this->variant());
147872 0 : ROSE_ASSERT(TYPEDEF_STMT == (int)(this->variantT()));
147873 0 : post_construction_initialization();
147874 :
147875 : // Test the isSgTypedefDeclaration() function since it has been problematic
147876 0 : assert(isSgTypedefDeclaration(this) != NULL);
147877 0 : }
147878 :
147879 : // Generated constructor (all data members)
147880 :
147881 : /* #line 147882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
147882 :
147883 :
147884 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
147885 :
147886 :
147887 : // ********************************************************
147888 : // member functions common across all array grammar objects
147889 : // ********************************************************
147890 :
147891 :
147892 :
147893 : /* #line 147894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
147894 :
147895 :
147896 :
147897 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
147898 :
147899 : // ********************************************************
147900 : // member functions specific to each node in the grammar
147901 : // ********************************************************
147902 :
147903 :
147904 : /* #line 147905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
147905 :
147906 : // Start of memberFunctionString
147907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
147908 :
147909 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
147910 :
147911 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
147912 : const SgTemplateParameterPtrList &
147913 0 : SgTemplateTypedefDeclaration::get_templateParameters () const
147914 : {
147915 0 : assert (this != NULL);
147916 0 : return p_templateParameters;
147917 : }
147918 :
147919 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
147920 : SgTemplateParameterPtrList &
147921 1194 : SgTemplateTypedefDeclaration::get_templateParameters ()
147922 : {
147923 1194 : assert (this != NULL);
147924 :
147925 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
147926 : // As a rule only set_ access functions can set the isModified flag.
147927 : // set_isModified(true);
147928 :
147929 1194 : return p_templateParameters;
147930 : }
147931 :
147932 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
147933 :
147934 :
147935 : // End of memberFunctionString
147936 : // Start of memberFunctionString
147937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
147938 :
147939 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
147940 :
147941 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
147942 : const SgTemplateArgumentPtrList &
147943 0 : SgTemplateTypedefDeclaration::get_templateSpecializationArguments () const
147944 : {
147945 0 : assert (this != NULL);
147946 0 : return p_templateSpecializationArguments;
147947 : }
147948 :
147949 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
147950 : SgTemplateArgumentPtrList &
147951 302 : SgTemplateTypedefDeclaration::get_templateSpecializationArguments ()
147952 : {
147953 302 : assert (this != NULL);
147954 :
147955 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
147956 : // As a rule only set_ access functions can set the isModified flag.
147957 : // set_isModified(true);
147958 :
147959 302 : return p_templateSpecializationArguments;
147960 : }
147961 :
147962 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
147963 :
147964 :
147965 : // End of memberFunctionString
147966 : // Start of memberFunctionString
147967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
147968 :
147969 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
147970 :
147971 : SgName
147972 0 : SgTemplateTypedefDeclaration::get_string () const
147973 : {
147974 0 : ROSE_ASSERT (this != NULL);
147975 :
147976 : #if 0
147977 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147978 : // used to trigger marking transformations for the token-based unparsing.
147979 : printf ("SgTemplateTypedefDeclaration::get_string = %p = %s \n",this,this->class_name().c_str());
147980 : #endif
147981 :
147982 0 : return p_string;
147983 : }
147984 :
147985 : void
147986 860 : SgTemplateTypedefDeclaration::set_string ( SgName string )
147987 : {
147988 860 : ROSE_ASSERT (this != NULL);
147989 :
147990 : #if 0
147991 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
147992 : // used to trigger marking transformations for the token-based unparsing.
147993 : printf ("SgTemplateTypedefDeclaration::set_string = %p = %s \n",this,this->class_name().c_str());
147994 : #endif
147995 :
147996 860 : set_isModified(true);
147997 :
147998 860 : p_string = string;
147999 860 : }
148000 :
148001 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148002 :
148003 :
148004 : // End of memberFunctionString
148005 : // Start of memberFunctionString
148006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
148007 :
148008 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148009 :
148010 : SgDeclarationScope*
148011 0 : SgTemplateTypedefDeclaration::get_nonreal_decl_scope () const
148012 : {
148013 0 : ROSE_ASSERT (this != NULL);
148014 :
148015 : #if 0
148016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148017 : // used to trigger marking transformations for the token-based unparsing.
148018 : printf ("SgTemplateTypedefDeclaration::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
148019 : #endif
148020 :
148021 0 : return p_nonreal_decl_scope;
148022 : }
148023 :
148024 : void
148025 892 : SgTemplateTypedefDeclaration::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
148026 : {
148027 892 : ROSE_ASSERT (this != NULL);
148028 :
148029 : #if 0
148030 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148031 : // used to trigger marking transformations for the token-based unparsing.
148032 : printf ("SgTemplateTypedefDeclaration::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
148033 : #endif
148034 :
148035 892 : set_isModified(true);
148036 :
148037 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
148038 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
148039 : {
148040 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
148041 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
148042 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
148043 : ROSE_ASSERT(false);
148044 : #endif
148045 : }
148046 : #endif
148047 892 : p_nonreal_decl_scope = nonreal_decl_scope;
148048 892 : }
148049 :
148050 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148051 :
148052 :
148053 : // End of memberFunctionString
148054 : // Start of memberFunctionString
148055 : /* #line 16934 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
148056 :
148057 :
148058 : #if 0
148059 : // DQ (2/25/2018): This function is more correctly represented below.
148060 : void
148061 : SgTemplateTypedefDeclaration::post_construction_initialization()
148062 : {
148063 : // DQ (12/21/2011): This is not what we want for the newer design with SgTemplateVariableDeclaration derived from SgVariableDeclaration.
148064 : // this->set_template_kind(e_template_m_data);
148065 : }
148066 : #endif
148067 :
148068 :
148069 :
148070 : // DQ (12/29/2011): The generate Cxx_Grammar.h header file will see the prototype for this function (even though I tried to make it NOT visible).
148071 : // As a result we need a function definition (but we need only call the base class version of the function).
148072 : SgDeclarationStatement *
148073 0 : SgTemplateTypedefDeclaration::compute_baseTypeDefiningDeclaration() const
148074 : {
148075 : // DQ (10/14/2014): We need to skip the call to SgTypedefDeclaration::compute_baseTypeDefiningDeclaration() because it is a private function.
148076 : // Not clear why this is not symetric to the case of SgTemplateVariableDeclaration.
148077 : // return SgTypedefDeclaration::compute_baseTypeDefiningDeclaration();
148078 0 : return NULL;
148079 : }
148080 :
148081 : void
148082 892 : SgTemplateTypedefDeclaration::post_construction_initialization()
148083 : {
148084 : // DQ (2/25/2018): Added this is new support to allos the SgTypedefType::createType() to be called with the
148085 : // SgTemplateTypedefDeclaration's "this" pointer instead of the SgTypedefDeclaration's "this" pointer.
148086 :
148087 : // DQ (10/6/2004): I think this should be dependent upon if the type was provided as an input in
148088 : // the constructor parameter list (else why bother specifying it in the constructor parameter list!)
148089 : #if 0
148090 : #if PRINT_DEVELOPER_WARNINGS
148091 : printf ("In SgTemplateTypedefDeclaration::post_construction_initialization(): generating SgTypedefType internally! \n");
148092 : #endif
148093 : #endif
148094 :
148095 : #if 0
148096 : // DQ (3/20/2012): We would like to assert this, but I don't think it is always possible. For example, test2001_19.C fails for this test.
148097 : // ROSE_ASSERT(this->get_parent_scope() != NULL);
148098 : if (this->get_parent_scope() == NULL)
148099 : {
148100 : printf ("WARNING: In SgTypedefDeclaration::post_construction_initialization(): this->get_parent_scope() == NULL \n");
148101 : }
148102 : #endif
148103 :
148104 : // Liao 2020/8/6: This is not always true: AST copy of SgTemplateTypedefDeclaration will pass the original type.
148105 : // DQ (2/27/2018): This should be null, since we just changed the semantics to defer the construction of the type (now consistant with other IR nodes).
148106 : // DQ (2/25/2018): This should be non-null, but we might hae to make sure it is not overwritten.
148107 : // ROSE_ASSERT(p_type != NULL);
148108 : // p_type = NULL;
148109 : // ROSE_ASSERT(p_type == NULL);
148110 :
148111 : #if 0
148112 : // DQ (2/25/2018): Added debugging support.
148113 : printf ("In SgTemplateTypedefDeclaration::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
148114 : #endif
148115 :
148116 : // DQ (2/25/2018): Built the type seperately so that we can insert debugging.
148117 : // set_type(SgTypedefType::createType(this));
148118 : // SgTypedefType* typedefType = SgTypedefType::createType(this);
148119 : // ROSE_ASSERT(typedefType != NULL);
148120 :
148121 : // DQ (2/27/2018): It is an inconsistancy for the type to be set here.
148122 : // set_type(typedefType);
148123 :
148124 : // DQ (2/25/2018): This should be non-null, since we just built the new type.
148125 : // ROSE_ASSERT(p_type != NULL);
148126 : // ROSE_ASSERT(p_type == NULL);
148127 :
148128 892 : ROSE_ASSERT (get_base_type() != NULL);
148129 892 : ROSE_ASSERT (get_base_type()->get_typedefs() != NULL);
148130 :
148131 : // DQ (2/27/2018): Modified to reflect that we no longer build the type in the constructor
148132 : // call (or the post_construction_initialization() function called by the constructor).
148133 : // ROSE_ASSERT (get_base_type()->get_typedefs()->get_typedefs().size() > 0);
148134 892 : ROSE_ASSERT (get_base_type()->get_typedefs()->get_typedefs().size() >= 0);
148135 892 : }
148136 :
148137 :
148138 :
148139 : // End of memberFunctionString
148140 : // Start of memberFunctionString
148141 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
148142 :
148143 : // *** COMMON CODE SECTION BEGINS HERE ***
148144 :
148145 : #if 0
148146 : int
148147 : SgTemplateTypedefDeclaration::getVariant() const
148148 : {
148149 : // This function is used in ROSE while "variant()" is used in SAGE
148150 : assert(this != NULL);
148151 : return variant();
148152 : }
148153 : #endif
148154 :
148155 : // This function is used in ROSE in treeTraversal code
148156 : // eventually replaces getVariant() and variant()
148157 : // though after variant() has been removed for a while we will
148158 : // want to change the name of variantT() back to variant()
148159 : // (since the "T" was ment to stand for temporary).
148160 : // When this happens the variantT() will be depricated.
148161 : VariantT
148162 473202 : SgTemplateTypedefDeclaration::variantT() const
148163 : {
148164 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
148165 473202 : ROSE_ASSERT(this != NULL);
148166 473202 : return V_SgTemplateTypedefDeclaration;
148167 : }
148168 :
148169 : #if 0
148170 : int
148171 : SgTemplateTypedefDeclaration::variant() const
148172 : {
148173 : // This function is used in SAGE
148174 : ROSE_ASSERT(this != NULL);
148175 : return TEMPLATE_TYPEDEF_DECL_STMT;
148176 : }
148177 : #endif
148178 :
148179 : ROSE_DLL_API const char*
148180 25 : SgTemplateTypedefDeclaration::sage_class_name() const
148181 : {
148182 25 : ROSE_ASSERT(this != NULL);
148183 25 : return "SgTemplateTypedefDeclaration";
148184 : }
148185 :
148186 : std::string
148187 1367 : SgTemplateTypedefDeclaration::class_name() const
148188 : {
148189 1367 : ROSE_ASSERT(this != NULL);
148190 1367 : return "SgTemplateTypedefDeclaration";
148191 : }
148192 :
148193 : // DQ (11/26/2005): Support for visitor pattern mechanims
148194 : // (inferior to ROSE traversal mechanism, experimental).
148195 : void
148196 13015 : SgTemplateTypedefDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
148197 : {
148198 13015 : ROSE_ASSERT(this != NULL);
148199 13015 : visitor.visit(this);
148200 13015 : }
148201 :
148202 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
148203 0 : void SgTemplateTypedefDeclaration::accept (ROSE_VisitorPattern & visitor) {
148204 0 : ROSE_ASSERT(this != NULL);
148205 0 : visitor.visit(this);
148206 0 : }
148207 :
148208 : SgTemplateTypedefDeclaration*
148209 0 : SgTemplateTypedefDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
148210 : {
148211 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
148212 : // This function is currently only supported for the AST used the represent Binary executables.
148213 : if (0 /* isSgAsmNode(this) != NULL */)
148214 : {
148215 : // Support for regex specification.
148216 : std::string prefixCode = "REGEX:";
148217 : addNewAttribute(prefixCode + s,a);
148218 : }
148219 : #endif
148220 :
148221 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
148222 0 : return this;
148223 : }
148224 :
148225 : // *** COMMON CODE SECTION ENDS HERE ***
148226 :
148227 :
148228 : // End of memberFunctionString
148229 : // Start of memberFunctionString
148230 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
148231 :
148232 :
148233 : #if 0
148234 : //! Error checking support
148235 : /*! Verifies the following:
148236 : - working getVariant() member function
148237 : - calls base class's error() member function
148238 : Every class has one of these functions.
148239 : */
148240 : bool
148241 : SgTemplateTypedefDeclaration::error()
148242 : {
148243 : // Put error checking here
148244 :
148245 : ROSE_ASSERT (this != NULL);
148246 : if (getVariant() != TEMPLATE_TYPEDEF_DECL_STMT)
148247 : {
148248 : printf ("Error in SgTemplateTypedefDeclaration::error(): SgTemplateTypedefDeclaration object has a %s variant \n",
148249 : Cxx_GrammarTerminalNames[getVariant()].name);
148250 : // printf ("Error in SgTemplateTypedefDeclaration::error() \n");
148251 : ROSE_ABORT();
148252 : }
148253 :
148254 : ROSE_ASSERT (getVariant() == TEMPLATE_TYPEDEF_DECL_STMT);
148255 : return SgTypedefDeclaration::error();
148256 : }
148257 : #endif
148258 :
148259 :
148260 :
148261 : // End of memberFunctionString
148262 :
148263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
148264 :
148265 51477 : SgTemplateTypedefDeclaration* isSgTemplateTypedefDeclaration ( SgNode* inputDerivedClassPointer )
148266 : {
148267 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
148268 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
148269 : // So to fix this we return NULL directly when the input is NULL and avoid the
148270 : // dynamic_cast in this case. This is likely a performance improvement as well.
148271 : // return dynamic_cast<SgTemplateTypedefDeclaration*>(inputDerivedClassPointer);
148272 : // Milind Chabbi (8/28/2013): isSgTemplateTypedefDeclaration uses table-driven castability instead of c++ default dynamic_cast
148273 : // this improves the running time performance by 10-20%.
148274 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateTypedefDeclaration*>(inputDerivedClassPointer);
148275 51477 : return IS_SgTemplateTypedefDeclaration_FAST_MACRO(inputDerivedClassPointer);
148276 : }
148277 :
148278 : // DQ (11/8/2003): Added version of functions taking const pointer
148279 742 : const SgTemplateTypedefDeclaration* isSgTemplateTypedefDeclaration ( const SgNode* inputDerivedClassPointer )
148280 : {
148281 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
148282 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
148283 : // So to fix this we return NULL directly when the input is NULL and avoid the
148284 : // dynamic_cast in this case. This is likely a performance improvement as well.
148285 : // return dynamic_cast<const SgTemplateTypedefDeclaration*>(inputDerivedClassPointer);
148286 : // Milind Chabbi (8/28/2013): isSgTemplateTypedefDeclaration uses table-driven castability instead of c++ default dynamic_cast
148287 : // this improves the running time performance by 10-20%.
148288 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateTypedefDeclaration*>(inputDerivedClassPointer);
148289 742 : return IS_SgTemplateTypedefDeclaration_FAST_MACRO(inputDerivedClassPointer);
148290 : }
148291 :
148292 :
148293 :
148294 : /* #line 148295 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148295 :
148296 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
148297 :
148298 : /**
148299 : \brief Generated destructor
148300 :
148301 : This destructor is automatically generated (by ROSETTA). This destructor
148302 : only frees memory of data members associated with the parts of the current IR node which
148303 : are NOT traversed. Those data members that are part of a traversal can be freed using
148304 : a traversal (calling this destructor on all children in a post-order traversal). Such
148305 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
148306 :
148307 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
148308 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
148309 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
148310 :
148311 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
148312 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
148313 : pointers are not yet implemented to call delete on eash pointer in the container.
148314 : (This could be done by derivation from the STL containers to define containers that
148315 : automatically deleted their members.)
148316 :
148317 : */
148318 570 : SgTemplateTypedefDeclaration::~SgTemplateTypedefDeclaration () {
148319 190 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
148320 :
148321 190 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
148322 :
148323 : // case: listType for templateParameters
148324 : // case: listType (typeIsPointerToList == false) for templateParameters
148325 190 : p_templateParameters.erase(p_templateParameters.begin(),p_templateParameters.end());
148326 : // case: listType for templateSpecializationArguments
148327 : // case: listType (typeIsPointerToList == false) for templateSpecializationArguments
148328 190 : p_templateSpecializationArguments.erase(p_templateSpecializationArguments.begin(),p_templateSpecializationArguments.end());
148329 : // case: not a listType for string
148330 190 : p_string = ""; // non list case
148331 : // case: not a listType for nonreal_decl_scope
148332 190 : p_nonreal_decl_scope = NULL; // non list case
148333 :
148334 : }
148335 :
148336 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
148337 380 : }
148338 :
148339 :
148340 : /* #line 148341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148341 :
148342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
148343 :
148344 : // Generated constructor
148345 0 : SgTemplateTypedefDeclaration::SgTemplateTypedefDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope )
148346 0 : : SgTypedefDeclaration(startOfConstruct, name, base_type, type, declaration, parent_scope)
148347 : {
148348 : #ifdef DEBUG
148349 : // printf ("In SgTemplateTypedefDeclaration::SgTemplateTypedefDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope) sage_class_name() = %s \n",sage_class_name());
148350 : #endif
148351 : #if 0
148352 : // debugging information!
148353 : printf ("In SgTemplateTypedefDeclaration::SgTemplateTypedefDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope): this = %p = %s \n",this,this->class_name().c_str());
148354 : #endif
148355 :
148356 0 : p_templateParameters = SgTemplateParameterPtrList();
148357 0 : p_templateSpecializationArguments = SgTemplateArgumentPtrList();
148358 0 : p_string = "";
148359 0 : p_nonreal_decl_scope = NULL;
148360 :
148361 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
148362 :
148363 : #if 0
148364 : // DQ (7/30/2014): Call a virtual function.
148365 : std::string s = this->class_name();
148366 : #endif
148367 :
148368 : // Test the variant virtual function
148369 : // assert(TEMPLATE_TYPEDEF_DECL_STMT == variant());
148370 0 : assert(TEMPLATE_TYPEDEF_DECL_STMT == this->variant());
148371 0 : ROSE_ASSERT(TEMPLATE_TYPEDEF_DECL_STMT == (int)(this->variantT()));
148372 0 : post_construction_initialization();
148373 :
148374 : // Test the isSgTemplateTypedefDeclaration() function since it has been problematic
148375 0 : assert(isSgTemplateTypedefDeclaration(this) != NULL);
148376 0 : }
148377 :
148378 : // Generated constructor (all data members)
148379 :
148380 : /* #line 148381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148381 :
148382 :
148383 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
148384 :
148385 :
148386 : // ********************************************************
148387 : // member functions common across all array grammar objects
148388 : // ********************************************************
148389 :
148390 :
148391 :
148392 : /* #line 148393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148393 :
148394 :
148395 :
148396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
148397 :
148398 : // ********************************************************
148399 : // member functions specific to each node in the grammar
148400 : // ********************************************************
148401 :
148402 :
148403 : /* #line 148404 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148404 :
148405 : // Start of memberFunctionString
148406 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
148407 :
148408 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148409 :
148410 : SgName
148411 1636 : SgTemplateInstantiationTypedefDeclaration::get_templateName () const
148412 : {
148413 1636 : ROSE_ASSERT (this != NULL);
148414 :
148415 : #if 0
148416 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148417 : // used to trigger marking transformations for the token-based unparsing.
148418 : printf ("SgTemplateInstantiationTypedefDeclaration::get_templateName = %p = %s \n",this,this->class_name().c_str());
148419 : #endif
148420 :
148421 1636 : return p_templateName;
148422 : }
148423 :
148424 : void
148425 602 : SgTemplateInstantiationTypedefDeclaration::set_templateName ( SgName templateName )
148426 : {
148427 602 : ROSE_ASSERT (this != NULL);
148428 :
148429 : #if 0
148430 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148431 : // used to trigger marking transformations for the token-based unparsing.
148432 : printf ("SgTemplateInstantiationTypedefDeclaration::set_templateName = %p = %s \n",this,this->class_name().c_str());
148433 : #endif
148434 :
148435 602 : set_isModified(true);
148436 :
148437 602 : p_templateName = templateName;
148438 602 : }
148439 :
148440 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148441 :
148442 :
148443 : // End of memberFunctionString
148444 : // Start of memberFunctionString
148445 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
148446 :
148447 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148448 :
148449 : SgName
148450 0 : SgTemplateInstantiationTypedefDeclaration::get_templateHeader () const
148451 : {
148452 0 : ROSE_ASSERT (this != NULL);
148453 :
148454 : #if 0
148455 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148456 : // used to trigger marking transformations for the token-based unparsing.
148457 : printf ("SgTemplateInstantiationTypedefDeclaration::get_templateHeader = %p = %s \n",this,this->class_name().c_str());
148458 : #endif
148459 :
148460 0 : return p_templateHeader;
148461 : }
148462 :
148463 : void
148464 0 : SgTemplateInstantiationTypedefDeclaration::set_templateHeader ( SgName templateHeader )
148465 : {
148466 0 : ROSE_ASSERT (this != NULL);
148467 :
148468 : #if 0
148469 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148470 : // used to trigger marking transformations for the token-based unparsing.
148471 : printf ("SgTemplateInstantiationTypedefDeclaration::set_templateHeader = %p = %s \n",this,this->class_name().c_str());
148472 : #endif
148473 :
148474 0 : set_isModified(true);
148475 :
148476 0 : p_templateHeader = templateHeader;
148477 0 : }
148478 :
148479 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148480 :
148481 :
148482 : // End of memberFunctionString
148483 : // Start of memberFunctionString
148484 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
148485 :
148486 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148487 :
148488 : SgTemplateTypedefDeclaration*
148489 0 : SgTemplateInstantiationTypedefDeclaration::get_templateDeclaration () const
148490 : {
148491 0 : ROSE_ASSERT (this != NULL);
148492 :
148493 : #if 0
148494 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148495 : // used to trigger marking transformations for the token-based unparsing.
148496 : printf ("SgTemplateInstantiationTypedefDeclaration::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
148497 : #endif
148498 :
148499 0 : return p_templateDeclaration;
148500 : }
148501 :
148502 : void
148503 0 : SgTemplateInstantiationTypedefDeclaration::set_templateDeclaration ( SgTemplateTypedefDeclaration* templateDeclaration )
148504 : {
148505 0 : ROSE_ASSERT (this != NULL);
148506 :
148507 : #if 0
148508 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148509 : // used to trigger marking transformations for the token-based unparsing.
148510 : printf ("SgTemplateInstantiationTypedefDeclaration::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
148511 : #endif
148512 :
148513 0 : set_isModified(true);
148514 :
148515 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
148516 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
148517 : {
148518 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
148519 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
148520 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
148521 : ROSE_ASSERT(false);
148522 : #endif
148523 : }
148524 : #endif
148525 0 : p_templateDeclaration = templateDeclaration;
148526 0 : }
148527 :
148528 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148529 :
148530 :
148531 : // End of memberFunctionString
148532 : // Start of memberFunctionString
148533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
148534 :
148535 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148536 :
148537 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
148538 : const SgTemplateArgumentPtrList &
148539 0 : SgTemplateInstantiationTypedefDeclaration::get_templateArguments () const
148540 : {
148541 0 : assert (this != NULL);
148542 0 : return p_templateArguments;
148543 : }
148544 :
148545 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
148546 : SgTemplateArgumentPtrList &
148547 8986 : SgTemplateInstantiationTypedefDeclaration::get_templateArguments ()
148548 : {
148549 8986 : assert (this != NULL);
148550 :
148551 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
148552 : // As a rule only set_ access functions can set the isModified flag.
148553 : // set_isModified(true);
148554 :
148555 8986 : return p_templateArguments;
148556 : }
148557 :
148558 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148559 :
148560 :
148561 : // End of memberFunctionString
148562 : // Start of memberFunctionString
148563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
148564 :
148565 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148566 :
148567 : bool
148568 0 : SgTemplateInstantiationTypedefDeclaration::get_nameResetFromMangledForm () const
148569 : {
148570 0 : ROSE_ASSERT (this != NULL);
148571 :
148572 : #if 0
148573 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148574 : // used to trigger marking transformations for the token-based unparsing.
148575 : printf ("SgTemplateInstantiationTypedefDeclaration::get_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
148576 : #endif
148577 :
148578 0 : return p_nameResetFromMangledForm;
148579 : }
148580 :
148581 : void
148582 0 : SgTemplateInstantiationTypedefDeclaration::set_nameResetFromMangledForm ( bool nameResetFromMangledForm )
148583 : {
148584 0 : ROSE_ASSERT (this != NULL);
148585 :
148586 : #if 0
148587 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148588 : // used to trigger marking transformations for the token-based unparsing.
148589 : printf ("SgTemplateInstantiationTypedefDeclaration::set_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
148590 : #endif
148591 :
148592 0 : set_isModified(true);
148593 :
148594 0 : p_nameResetFromMangledForm = nameResetFromMangledForm;
148595 0 : }
148596 :
148597 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
148598 :
148599 :
148600 : // End of memberFunctionString
148601 : // Start of memberFunctionString
148602 : /* #line 17018 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
148603 :
148604 :
148605 : #if 0
148606 : // DQ (2/25/2018): This function is more correctly represented below.
148607 : void
148608 : SgTemplateInstantiationTypedefDeclaration::post_construction_initialization()
148609 : {
148610 : // DQ (11/4/2014): I don't think we need to do anything here.
148611 : }
148612 : #endif
148613 :
148614 : void
148615 602 : SgTemplateInstantiationTypedefDeclaration::post_construction_initialization()
148616 : {
148617 : // DQ (2/25/2018): Added this is new support to allos the SgTypedefType::createType() to be called with the
148618 : // SgTemplateInstantiationTypedefDeclaration's "this" pointer instead of the SgTypedefDeclaration's "this" pointer.
148619 :
148620 : // DQ (10/6/2004): I think this should be dependent upon if the type was provided as an input in
148621 : // the constructor parameter list (else why bother specifying it in the constructor parameter list!)
148622 : #if 0
148623 : #if PRINT_DEVELOPER_WARNINGS
148624 : printf ("In SgTemplateInstantiationTypedefDeclaration::post_construction_initialization(): generating SgTypedefType internally! \n");
148625 : #endif
148626 : #endif
148627 :
148628 : #if 0
148629 : // DQ (3/20/2012): We would like to assert this, but I don't think it is always possible. For example, test2001_19.C fails for this test.
148630 : // ROSE_ASSERT(this->get_parent_scope() != NULL);
148631 : if (this->get_parent_scope() == NULL)
148632 : {
148633 : printf ("WARNING: In SgTemplateInstantiationTypedefDeclaration::post_construction_initialization(): this->get_parent_scope() == NULL \n");
148634 : }
148635 : #endif
148636 :
148637 : // DQ (2/25/2018): This should be non-null, but we might hae to make sure it is not overwritten.
148638 : // ROSE_ASSERT(p_type != NULL);
148639 : // p_type = NULL;
148640 602 : ROSE_ASSERT(p_type == NULL);
148641 :
148642 : #if 0
148643 : // DQ (2/25/2018): Added debugging support.
148644 : printf ("In SgTemplateInstantiationTypedefDeclaration::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
148645 : #endif
148646 :
148647 : // DQ (2/26/2018): We need to set the p_templateName, is this a reasonable place to do this?
148648 : // The support to resetting the template name requires the parent to be set and this is only
148649 : // done after the constructor, and post_construction_initialization() function, are called.
148650 : // resetTemplateName();
148651 :
148652 : #if 0
148653 : // printf ("In SgTemplateInstantiationTypedefDeclaration::post_construction_initialization(): calling SgTypedefType::createType(this) \n");
148654 : #endif
148655 :
148656 : #if 0
148657 : // DQ (2/25/2018): Built the type seperately so that we can insert debugging.
148658 : // set_type(SgTypedefType::createType(this));
148659 : SgTypedefType* typedefType = SgTypedefType::createType(this);
148660 : ROSE_ASSERT(typedefType != NULL);
148661 :
148662 : // DQ (2/27/2018): It is an inconsistancy for the type to be set here.
148663 : set_type(typedefType);
148664 :
148665 : // DQ (2/25/2018): This should be non-null, since we just built the new type.
148666 : ROSE_ASSERT(p_type != NULL);
148667 : #else
148668 : // printf ("In SgTemplateInstantiationTypedefDeclaration::post_construction_initialization(): we have to defer the construction of the template instantiation name in the type to after the template name is reset \n");
148669 : #endif
148670 :
148671 602 : ROSE_ASSERT (get_base_type() != NULL);
148672 602 : ROSE_ASSERT (get_base_type()->get_typedefs() != NULL);
148673 :
148674 : // DQ (3/1/2018): Since we no longer set the type in this function (to be uniformally consistant
148675 : // in where types are set accross all declarations), we have to modify this assertion.
148676 : // ROSE_ASSERT (get_base_type()->get_typedefs()->get_typedefs().size() > 0);
148677 602 : ROSE_ASSERT (get_base_type()->get_typedefs()->get_typedefs().size() >= 0);
148678 602 : }
148679 :
148680 : void
148681 0 : SgTemplateInstantiationTypedefDeclaration::resetTemplateName()
148682 : {
148683 : // DQ (2/26/2018): Added support for resetting the template name.
148684 :
148685 : // local version of function to support generation of template names
148686 :
148687 : #if 0
148688 : printf ("In SgTemplateInstantiationTypedefDeclaration::resetTemplateName(): p_name = %s \n",p_name.str());
148689 : #endif
148690 :
148691 0 : resetTemplateNameSupport (p_nameResetFromMangledForm,p_name);
148692 :
148693 : #if 0
148694 : printf ("Leaving SgTemplateInstantiationTypedefDeclaration::resetTemplateName(): p_name = %s p_templateName = %s \n",p_name.str(),p_templateName.str());
148695 : #endif
148696 :
148697 : // ROSE_ASSERT(p_templateName != "");
148698 0 : }
148699 :
148700 : // DQ (2/28/2018): Added support for getting the symbol from the declaration.
148701 : SgSymbol*
148702 454 : SgTemplateInstantiationTypedefDeclaration::get_symbol_from_symbol_table() const
148703 : {
148704 454 : ROSE_ASSERT(get_scope() != NULL);
148705 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
148706 : // return get_scope()->get_symbol_table()->find(this);
148707 454 : return get_scope()->find_symbol_from_declaration(this);
148708 : }
148709 :
148710 :
148711 :
148712 :
148713 : // End of memberFunctionString
148714 : // Start of memberFunctionString
148715 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
148716 :
148717 : // *** COMMON CODE SECTION BEGINS HERE ***
148718 :
148719 : #if 0
148720 : int
148721 : SgTemplateInstantiationTypedefDeclaration::getVariant() const
148722 : {
148723 : // This function is used in ROSE while "variant()" is used in SAGE
148724 : assert(this != NULL);
148725 : return variant();
148726 : }
148727 : #endif
148728 :
148729 : // This function is used in ROSE in treeTraversal code
148730 : // eventually replaces getVariant() and variant()
148731 : // though after variant() has been removed for a while we will
148732 : // want to change the name of variantT() back to variant()
148733 : // (since the "T" was ment to stand for temporary).
148734 : // When this happens the variantT() will be depricated.
148735 : VariantT
148736 232411 : SgTemplateInstantiationTypedefDeclaration::variantT() const
148737 : {
148738 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
148739 232411 : ROSE_ASSERT(this != NULL);
148740 232411 : return V_SgTemplateInstantiationTypedefDeclaration;
148741 : }
148742 :
148743 : #if 0
148744 : int
148745 : SgTemplateInstantiationTypedefDeclaration::variant() const
148746 : {
148747 : // This function is used in SAGE
148748 : ROSE_ASSERT(this != NULL);
148749 : return TEMPLATE_INST_TYPEDEF_DECL_STMT;
148750 : }
148751 : #endif
148752 :
148753 : ROSE_DLL_API const char*
148754 0 : SgTemplateInstantiationTypedefDeclaration::sage_class_name() const
148755 : {
148756 0 : ROSE_ASSERT(this != NULL);
148757 0 : return "SgTemplateInstantiationTypedefDeclaration";
148758 : }
148759 :
148760 : std::string
148761 1127 : SgTemplateInstantiationTypedefDeclaration::class_name() const
148762 : {
148763 1127 : ROSE_ASSERT(this != NULL);
148764 1127 : return "SgTemplateInstantiationTypedefDeclaration";
148765 : }
148766 :
148767 : // DQ (11/26/2005): Support for visitor pattern mechanims
148768 : // (inferior to ROSE traversal mechanism, experimental).
148769 : void
148770 8942 : SgTemplateInstantiationTypedefDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
148771 : {
148772 8942 : ROSE_ASSERT(this != NULL);
148773 8942 : visitor.visit(this);
148774 8942 : }
148775 :
148776 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
148777 0 : void SgTemplateInstantiationTypedefDeclaration::accept (ROSE_VisitorPattern & visitor) {
148778 0 : ROSE_ASSERT(this != NULL);
148779 0 : visitor.visit(this);
148780 0 : }
148781 :
148782 : SgTemplateInstantiationTypedefDeclaration*
148783 0 : SgTemplateInstantiationTypedefDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
148784 : {
148785 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
148786 : // This function is currently only supported for the AST used the represent Binary executables.
148787 : if (0 /* isSgAsmNode(this) != NULL */)
148788 : {
148789 : // Support for regex specification.
148790 : std::string prefixCode = "REGEX:";
148791 : addNewAttribute(prefixCode + s,a);
148792 : }
148793 : #endif
148794 :
148795 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
148796 0 : return this;
148797 : }
148798 :
148799 : // *** COMMON CODE SECTION ENDS HERE ***
148800 :
148801 :
148802 : // End of memberFunctionString
148803 : // Start of memberFunctionString
148804 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
148805 :
148806 :
148807 : #if 0
148808 : //! Error checking support
148809 : /*! Verifies the following:
148810 : - working getVariant() member function
148811 : - calls base class's error() member function
148812 : Every class has one of these functions.
148813 : */
148814 : bool
148815 : SgTemplateInstantiationTypedefDeclaration::error()
148816 : {
148817 : // Put error checking here
148818 :
148819 : ROSE_ASSERT (this != NULL);
148820 : if (getVariant() != TEMPLATE_INST_TYPEDEF_DECL_STMT)
148821 : {
148822 : printf ("Error in SgTemplateInstantiationTypedefDeclaration::error(): SgTemplateInstantiationTypedefDeclaration object has a %s variant \n",
148823 : Cxx_GrammarTerminalNames[getVariant()].name);
148824 : // printf ("Error in SgTemplateInstantiationTypedefDeclaration::error() \n");
148825 : ROSE_ABORT();
148826 : }
148827 :
148828 : ROSE_ASSERT (getVariant() == TEMPLATE_INST_TYPEDEF_DECL_STMT);
148829 : return SgTypedefDeclaration::error();
148830 : }
148831 : #endif
148832 :
148833 :
148834 :
148835 : // End of memberFunctionString
148836 :
148837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
148838 :
148839 2624410 : SgTemplateInstantiationTypedefDeclaration* isSgTemplateInstantiationTypedefDeclaration ( SgNode* inputDerivedClassPointer )
148840 : {
148841 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
148842 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
148843 : // So to fix this we return NULL directly when the input is NULL and avoid the
148844 : // dynamic_cast in this case. This is likely a performance improvement as well.
148845 : // return dynamic_cast<SgTemplateInstantiationTypedefDeclaration*>(inputDerivedClassPointer);
148846 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationTypedefDeclaration uses table-driven castability instead of c++ default dynamic_cast
148847 : // this improves the running time performance by 10-20%.
148848 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateInstantiationTypedefDeclaration*>(inputDerivedClassPointer);
148849 2624410 : return IS_SgTemplateInstantiationTypedefDeclaration_FAST_MACRO(inputDerivedClassPointer);
148850 : }
148851 :
148852 : // DQ (11/8/2003): Added version of functions taking const pointer
148853 454 : const SgTemplateInstantiationTypedefDeclaration* isSgTemplateInstantiationTypedefDeclaration ( const SgNode* inputDerivedClassPointer )
148854 : {
148855 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
148856 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
148857 : // So to fix this we return NULL directly when the input is NULL and avoid the
148858 : // dynamic_cast in this case. This is likely a performance improvement as well.
148859 : // return dynamic_cast<const SgTemplateInstantiationTypedefDeclaration*>(inputDerivedClassPointer);
148860 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationTypedefDeclaration uses table-driven castability instead of c++ default dynamic_cast
148861 : // this improves the running time performance by 10-20%.
148862 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateInstantiationTypedefDeclaration*>(inputDerivedClassPointer);
148863 454 : return IS_SgTemplateInstantiationTypedefDeclaration_FAST_MACRO(inputDerivedClassPointer);
148864 : }
148865 :
148866 :
148867 :
148868 : /* #line 148869 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148869 :
148870 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
148871 :
148872 : /**
148873 : \brief Generated destructor
148874 :
148875 : This destructor is automatically generated (by ROSETTA). This destructor
148876 : only frees memory of data members associated with the parts of the current IR node which
148877 : are NOT traversed. Those data members that are part of a traversal can be freed using
148878 : a traversal (calling this destructor on all children in a post-order traversal). Such
148879 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
148880 :
148881 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
148882 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
148883 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
148884 :
148885 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
148886 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
148887 : pointers are not yet implemented to call delete on eash pointer in the container.
148888 : (This could be done by derivation from the STL containers to define containers that
148889 : automatically deleted their members.)
148890 :
148891 : */
148892 390 : SgTemplateInstantiationTypedefDeclaration::~SgTemplateInstantiationTypedefDeclaration () {
148893 130 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
148894 :
148895 :
148896 : // case: not a listType for templateName
148897 130 : p_templateName = ""; // non list case
148898 : // case: not a listType for templateHeader
148899 130 : p_templateHeader = ""; // non list case
148900 : // case: not a listType for templateDeclaration
148901 130 : p_templateDeclaration = NULL; // non list case
148902 : // case: listType for templateArguments
148903 : // case: listType (typeIsPointerToList == false) for templateArguments
148904 130 : p_templateArguments.erase(p_templateArguments.begin(),p_templateArguments.end());
148905 : // case: not a listType for nameResetFromMangledForm
148906 130 : p_nameResetFromMangledForm = false; // non list case
148907 :
148908 : }
148909 :
148910 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
148911 260 : }
148912 :
148913 :
148914 : /* #line 148915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148915 :
148916 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
148917 :
148918 : // Generated constructor
148919 0 : SgTemplateInstantiationTypedefDeclaration::SgTemplateInstantiationTypedefDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope, SgTemplateTypedefDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments )
148920 0 : : SgTypedefDeclaration(startOfConstruct, name, base_type, type, declaration, parent_scope)
148921 : {
148922 : #ifdef DEBUG
148923 : // printf ("In SgTemplateInstantiationTypedefDeclaration::SgTemplateInstantiationTypedefDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope, SgTemplateTypedefDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments) sage_class_name() = %s \n",sage_class_name());
148924 : #endif
148925 : #if 0
148926 : // debugging information!
148927 : printf ("In SgTemplateInstantiationTypedefDeclaration::SgTemplateInstantiationTypedefDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope, SgTemplateTypedefDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments): this = %p = %s \n",this,this->class_name().c_str());
148928 : #endif
148929 :
148930 0 : p_templateName = "";
148931 0 : p_templateHeader = "";
148932 0 : p_templateDeclaration = templateDeclaration;
148933 0 : p_templateArguments = templateArguments;
148934 0 : p_nameResetFromMangledForm = false;
148935 :
148936 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
148937 :
148938 : #if 0
148939 : // DQ (7/30/2014): Call a virtual function.
148940 : std::string s = this->class_name();
148941 : #endif
148942 :
148943 : // Test the variant virtual function
148944 : // assert(TEMPLATE_INST_TYPEDEF_DECL_STMT == variant());
148945 0 : assert(TEMPLATE_INST_TYPEDEF_DECL_STMT == this->variant());
148946 0 : ROSE_ASSERT(TEMPLATE_INST_TYPEDEF_DECL_STMT == (int)(this->variantT()));
148947 0 : post_construction_initialization();
148948 :
148949 : // Test the isSgTemplateInstantiationTypedefDeclaration() function since it has been problematic
148950 0 : assert(isSgTemplateInstantiationTypedefDeclaration(this) != NULL);
148951 0 : }
148952 :
148953 : // Generated constructor (all data members)
148954 :
148955 : /* #line 148956 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148956 :
148957 :
148958 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
148959 :
148960 :
148961 : // ********************************************************
148962 : // member functions common across all array grammar objects
148963 : // ********************************************************
148964 :
148965 :
148966 :
148967 : /* #line 148968 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148968 :
148969 :
148970 :
148971 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
148972 :
148973 : // ********************************************************
148974 : // member functions specific to each node in the grammar
148975 : // ********************************************************
148976 :
148977 :
148978 : /* #line 148979 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
148979 :
148980 : // Start of memberFunctionString
148981 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
148982 :
148983 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
148984 :
148985 : SgFunctionDeclaration*
148986 0 : SgStatementFunctionStatement::get_function () const
148987 : {
148988 0 : ROSE_ASSERT (this != NULL);
148989 :
148990 : #if 0
148991 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
148992 : // used to trigger marking transformations for the token-based unparsing.
148993 : printf ("SgStatementFunctionStatement::get_function = %p = %s \n",this,this->class_name().c_str());
148994 : #endif
148995 :
148996 0 : return p_function;
148997 : }
148998 :
148999 : void
149000 0 : SgStatementFunctionStatement::set_function ( SgFunctionDeclaration* function )
149001 : {
149002 0 : ROSE_ASSERT (this != NULL);
149003 :
149004 : #if 0
149005 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
149006 : // used to trigger marking transformations for the token-based unparsing.
149007 : printf ("SgStatementFunctionStatement::set_function = %p = %s \n",this,this->class_name().c_str());
149008 : #endif
149009 :
149010 0 : set_isModified(true);
149011 :
149012 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
149013 : if (p_function != NULL && function != NULL && p_function != function)
149014 : {
149015 : printf ("Warning: function = %p overwriting valid pointer p_function = %p \n",function,p_function);
149016 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
149017 : printf ("Error fails assertion (p_function != NULL && function != NULL && p_function != function) is false\n");
149018 : ROSE_ASSERT(false);
149019 : #endif
149020 : }
149021 : #endif
149022 0 : p_function = function;
149023 0 : }
149024 :
149025 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
149026 :
149027 :
149028 : // End of memberFunctionString
149029 : // Start of memberFunctionString
149030 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
149031 :
149032 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
149033 :
149034 : SgExpression*
149035 0 : SgStatementFunctionStatement::get_expression () const
149036 : {
149037 0 : ROSE_ASSERT (this != NULL);
149038 :
149039 : #if 0
149040 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
149041 : // used to trigger marking transformations for the token-based unparsing.
149042 : printf ("SgStatementFunctionStatement::get_expression = %p = %s \n",this,this->class_name().c_str());
149043 : #endif
149044 :
149045 0 : return p_expression;
149046 : }
149047 :
149048 : void
149049 0 : SgStatementFunctionStatement::set_expression ( SgExpression* expression )
149050 : {
149051 0 : ROSE_ASSERT (this != NULL);
149052 :
149053 : #if 0
149054 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
149055 : // used to trigger marking transformations for the token-based unparsing.
149056 : printf ("SgStatementFunctionStatement::set_expression = %p = %s \n",this,this->class_name().c_str());
149057 : #endif
149058 :
149059 0 : set_isModified(true);
149060 :
149061 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
149062 : if (p_expression != NULL && expression != NULL && p_expression != expression)
149063 : {
149064 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
149065 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
149066 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
149067 : ROSE_ASSERT(false);
149068 : #endif
149069 : }
149070 : #endif
149071 0 : p_expression = expression;
149072 0 : }
149073 :
149074 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
149075 :
149076 :
149077 : // End of memberFunctionString
149078 : // Start of memberFunctionString
149079 : /* #line 18545 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
149080 :
149081 : void
149082 0 : SgStatementFunctionStatement::post_construction_initialization()
149083 0 : {}
149084 :
149085 : SgName
149086 0 : SgStatementFunctionStatement::get_mangled_name() const
149087 : {
149088 : // printf ("Sorry, SgStatementFunctionStatement::get_mangled_name() not implemented! \n");
149089 0 : return SgName("");
149090 : }
149091 :
149092 :
149093 : // End of memberFunctionString
149094 : // Start of memberFunctionString
149095 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
149096 :
149097 : // *** COMMON CODE SECTION BEGINS HERE ***
149098 :
149099 : #if 0
149100 : int
149101 : SgStatementFunctionStatement::getVariant() const
149102 : {
149103 : // This function is used in ROSE while "variant()" is used in SAGE
149104 : assert(this != NULL);
149105 : return variant();
149106 : }
149107 : #endif
149108 :
149109 : // This function is used in ROSE in treeTraversal code
149110 : // eventually replaces getVariant() and variant()
149111 : // though after variant() has been removed for a while we will
149112 : // want to change the name of variantT() back to variant()
149113 : // (since the "T" was ment to stand for temporary).
149114 : // When this happens the variantT() will be depricated.
149115 : VariantT
149116 0 : SgStatementFunctionStatement::variantT() const
149117 : {
149118 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
149119 0 : ROSE_ASSERT(this != NULL);
149120 0 : return V_SgStatementFunctionStatement;
149121 : }
149122 :
149123 : #if 0
149124 : int
149125 : SgStatementFunctionStatement::variant() const
149126 : {
149127 : // This function is used in SAGE
149128 : ROSE_ASSERT(this != NULL);
149129 : return TEMP_Statement_Function_Statement;
149130 : }
149131 : #endif
149132 :
149133 : ROSE_DLL_API const char*
149134 0 : SgStatementFunctionStatement::sage_class_name() const
149135 : {
149136 0 : ROSE_ASSERT(this != NULL);
149137 0 : return "SgStatementFunctionStatement";
149138 : }
149139 :
149140 : std::string
149141 0 : SgStatementFunctionStatement::class_name() const
149142 : {
149143 0 : ROSE_ASSERT(this != NULL);
149144 0 : return "SgStatementFunctionStatement";
149145 : }
149146 :
149147 : // DQ (11/26/2005): Support for visitor pattern mechanims
149148 : // (inferior to ROSE traversal mechanism, experimental).
149149 : void
149150 0 : SgStatementFunctionStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
149151 : {
149152 0 : ROSE_ASSERT(this != NULL);
149153 0 : visitor.visit(this);
149154 0 : }
149155 :
149156 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
149157 0 : void SgStatementFunctionStatement::accept (ROSE_VisitorPattern & visitor) {
149158 0 : ROSE_ASSERT(this != NULL);
149159 0 : visitor.visit(this);
149160 0 : }
149161 :
149162 : SgStatementFunctionStatement*
149163 0 : SgStatementFunctionStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
149164 : {
149165 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
149166 : // This function is currently only supported for the AST used the represent Binary executables.
149167 : if (0 /* isSgAsmNode(this) != NULL */)
149168 : {
149169 : // Support for regex specification.
149170 : std::string prefixCode = "REGEX:";
149171 : addNewAttribute(prefixCode + s,a);
149172 : }
149173 : #endif
149174 :
149175 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
149176 0 : return this;
149177 : }
149178 :
149179 : // *** COMMON CODE SECTION ENDS HERE ***
149180 :
149181 :
149182 : // End of memberFunctionString
149183 : // Start of memberFunctionString
149184 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
149185 :
149186 :
149187 : #if 0
149188 : //! Error checking support
149189 : /*! Verifies the following:
149190 : - working getVariant() member function
149191 : - calls base class's error() member function
149192 : Every class has one of these functions.
149193 : */
149194 : bool
149195 : SgStatementFunctionStatement::error()
149196 : {
149197 : // Put error checking here
149198 :
149199 : ROSE_ASSERT (this != NULL);
149200 : if (getVariant() != TEMP_Statement_Function_Statement)
149201 : {
149202 : printf ("Error in SgStatementFunctionStatement::error(): SgStatementFunctionStatement object has a %s variant \n",
149203 : Cxx_GrammarTerminalNames[getVariant()].name);
149204 : // printf ("Error in SgStatementFunctionStatement::error() \n");
149205 : ROSE_ABORT();
149206 : }
149207 :
149208 : ROSE_ASSERT (getVariant() == TEMP_Statement_Function_Statement);
149209 : return SgDeclarationStatement::error();
149210 : }
149211 : #endif
149212 :
149213 :
149214 :
149215 : // End of memberFunctionString
149216 :
149217 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
149218 :
149219 0 : SgStatementFunctionStatement* isSgStatementFunctionStatement ( SgNode* inputDerivedClassPointer )
149220 : {
149221 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
149222 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
149223 : // So to fix this we return NULL directly when the input is NULL and avoid the
149224 : // dynamic_cast in this case. This is likely a performance improvement as well.
149225 : // return dynamic_cast<SgStatementFunctionStatement*>(inputDerivedClassPointer);
149226 : // Milind Chabbi (8/28/2013): isSgStatementFunctionStatement uses table-driven castability instead of c++ default dynamic_cast
149227 : // this improves the running time performance by 10-20%.
149228 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStatementFunctionStatement*>(inputDerivedClassPointer);
149229 0 : return IS_SgStatementFunctionStatement_FAST_MACRO(inputDerivedClassPointer);
149230 : }
149231 :
149232 : // DQ (11/8/2003): Added version of functions taking const pointer
149233 0 : const SgStatementFunctionStatement* isSgStatementFunctionStatement ( const SgNode* inputDerivedClassPointer )
149234 : {
149235 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
149236 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
149237 : // So to fix this we return NULL directly when the input is NULL and avoid the
149238 : // dynamic_cast in this case. This is likely a performance improvement as well.
149239 : // return dynamic_cast<const SgStatementFunctionStatement*>(inputDerivedClassPointer);
149240 : // Milind Chabbi (8/28/2013): isSgStatementFunctionStatement uses table-driven castability instead of c++ default dynamic_cast
149241 : // this improves the running time performance by 10-20%.
149242 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStatementFunctionStatement*>(inputDerivedClassPointer);
149243 0 : return IS_SgStatementFunctionStatement_FAST_MACRO(inputDerivedClassPointer);
149244 : }
149245 :
149246 :
149247 :
149248 : /* #line 149249 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149249 :
149250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
149251 :
149252 : /**
149253 : \brief Generated destructor
149254 :
149255 : This destructor is automatically generated (by ROSETTA). This destructor
149256 : only frees memory of data members associated with the parts of the current IR node which
149257 : are NOT traversed. Those data members that are part of a traversal can be freed using
149258 : a traversal (calling this destructor on all children in a post-order traversal). Such
149259 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
149260 :
149261 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
149262 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
149263 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
149264 :
149265 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
149266 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
149267 : pointers are not yet implemented to call delete on eash pointer in the container.
149268 : (This could be done by derivation from the STL containers to define containers that
149269 : automatically deleted their members.)
149270 :
149271 : */
149272 0 : SgStatementFunctionStatement::~SgStatementFunctionStatement () {
149273 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
149274 :
149275 :
149276 : // case: not a listType for function
149277 0 : p_function = NULL; // non list case
149278 : // case: not a listType for expression
149279 0 : p_expression = NULL; // non list case
149280 :
149281 : }
149282 :
149283 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
149284 0 : }
149285 :
149286 :
149287 : /* #line 149288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149288 :
149289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
149290 :
149291 : // Generated constructor
149292 0 : SgStatementFunctionStatement::SgStatementFunctionStatement ( Sg_File_Info* startOfConstruct, SgFunctionDeclaration* function, SgExpression* expression )
149293 0 : : SgDeclarationStatement(startOfConstruct)
149294 : {
149295 : #ifdef DEBUG
149296 : // printf ("In SgStatementFunctionStatement::SgStatementFunctionStatement (Sg_File_Info* startOfConstruct, SgFunctionDeclaration* function, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
149297 : #endif
149298 : #if 0
149299 : // debugging information!
149300 : printf ("In SgStatementFunctionStatement::SgStatementFunctionStatement (Sg_File_Info* startOfConstruct, SgFunctionDeclaration* function, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
149301 : #endif
149302 :
149303 0 : p_function = function;
149304 0 : p_expression = expression;
149305 :
149306 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
149307 :
149308 : #if 0
149309 : // DQ (7/30/2014): Call a virtual function.
149310 : std::string s = this->class_name();
149311 : #endif
149312 :
149313 : // Test the variant virtual function
149314 : // assert(TEMP_Statement_Function_Statement == variant());
149315 0 : assert(TEMP_Statement_Function_Statement == this->variant());
149316 0 : ROSE_ASSERT(TEMP_Statement_Function_Statement == (int)(this->variantT()));
149317 0 : post_construction_initialization();
149318 :
149319 : // Test the isSgStatementFunctionStatement() function since it has been problematic
149320 0 : assert(isSgStatementFunctionStatement(this) != NULL);
149321 0 : }
149322 :
149323 : // Generated constructor (all data members)
149324 :
149325 : /* #line 149326 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149326 :
149327 :
149328 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
149329 :
149330 :
149331 : // ********************************************************
149332 : // member functions common across all array grammar objects
149333 : // ********************************************************
149334 :
149335 :
149336 :
149337 : /* #line 149338 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149338 :
149339 :
149340 :
149341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
149342 :
149343 : // ********************************************************
149344 : // member functions specific to each node in the grammar
149345 : // ********************************************************
149346 :
149347 :
149348 : /* #line 149349 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149349 :
149350 : // Start of memberFunctionString
149351 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
149352 :
149353 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
149354 :
149355 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
149356 : const SgInitializedNamePtrList &
149357 59277 : SgCtorInitializerList::get_ctors () const
149358 : {
149359 59277 : assert (this != NULL);
149360 59277 : return p_ctors;
149361 : }
149362 :
149363 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
149364 : SgInitializedNamePtrList &
149365 3062 : SgCtorInitializerList::get_ctors ()
149366 : {
149367 3062 : assert (this != NULL);
149368 :
149369 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
149370 : // As a rule only set_ access functions can set the isModified flag.
149371 : // set_isModified(true);
149372 :
149373 3062 : return p_ctors;
149374 : }
149375 :
149376 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
149377 :
149378 :
149379 : // End of memberFunctionString
149380 : // Start of memberFunctionString
149381 : /* #line 12297 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
149382 :
149383 :
149384 : void
149385 39274 : SgCtorInitializerList::post_construction_initialization()
149386 : {
149387 39274 : if (get_file_info() != NULL)
149388 : {
149389 0 : Sg_File_Info* endingPosition = new Sg_File_Info(*(get_file_info()));
149390 0 : ROSE_ASSERT (endingPosition != NULL);
149391 :
149392 : // DQ (12/18/2006): Added to set all parents of Sg_File_Info objects.
149393 0 : endingPosition->set_parent(this);
149394 :
149395 0 : set_endOfConstruct(endingPosition);
149396 : }
149397 :
149398 : // Liao, 2020/4/29, borrow these two steps from SageBuilder::buildNondefiningMemberFunctionDeclaration() here
149399 : // This is necessary to fix AST copy of member function declarations. The copy does not set defining declaration.
149400 39274 : this->set_definingDeclaration(this);
149401 39274 : this->set_firstNondefiningDeclaration(this);
149402 : #if 0
149403 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
149404 : printf ("In SgCtorInitializerList::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
149405 : #endif
149406 39274 : }
149407 :
149408 : /* SgInitializedName tuple: (SgName, type, Initializer) */
149409 : void
149410 0 : SgCtorInitializerList::append_ctor_initializer( SgInitializedName* iName)
149411 : {
149412 0 : get_ctors().insert(get_ctors().end(), iName);
149413 0 : }
149414 :
149415 : void
149416 0 : SgCtorInitializerList::prepend_ctor_initializer( SgInitializedName* iName)
149417 : {
149418 0 : get_ctors().insert(get_ctors().begin(), iName);
149419 0 : }
149420 :
149421 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
149422 : SgName
149423 28756 : SgCtorInitializerList::get_mangled_name(void) const
149424 : {
149425 : // printf ("In SgCtorInitializerList::get_mangled_name() name = %s \n",SageInterface::get_name(this).c_str());
149426 :
149427 28756 : SgName returnName;
149428 :
149429 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
149430 28756 : SgScopeStatement* scope = get_scope();
149431 28756 : ROSE_ASSERT(scope != NULL);
149432 :
149433 28756 : SgName memberNames;
149434 28756 : SgInitializedNamePtrList::const_iterator p = get_ctors().begin();
149435 30521 : while ( p != get_ctors().end() )
149436 : {
149437 : // DQ (2/22/2007): Added type to generated mangled name for each variable (supports AST merge generation of name for un-named classes)
149438 : // memberNames += SgName("_variable_name_") + (*p)->get_mangled_name();
149439 1765 : memberNames += SgName("_variable_type_") + (*p)->get_type()->get_mangled() + SgName("_variable_name_") + (*p)->get_mangled_name();
149440 :
149441 1765 : p++;
149442 : }
149443 :
149444 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
149445 : // This is a poor way to handle the generation of a mangled name (will be improved)
149446 : // returnName = scope->get_qualified_name() + SgName("_constructor_initialization_list_") + memberNames;
149447 28756 : returnName = scope->get_mangled_name() + SgName("_constructor_initialization_list_") + memberNames;
149448 :
149449 : // printf ("Warning: mangled name for %s not yet defined (SgFunctionParameterList::get_mangled_name() called) \n",class_name().c_str());
149450 :
149451 28756 : return returnName;
149452 : }
149453 :
149454 :
149455 :
149456 : // End of memberFunctionString
149457 : // Start of memberFunctionString
149458 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
149459 :
149460 : // *** COMMON CODE SECTION BEGINS HERE ***
149461 :
149462 : #if 0
149463 : int
149464 : SgCtorInitializerList::getVariant() const
149465 : {
149466 : // This function is used in ROSE while "variant()" is used in SAGE
149467 : assert(this != NULL);
149468 : return variant();
149469 : }
149470 : #endif
149471 :
149472 : // This function is used in ROSE in treeTraversal code
149473 : // eventually replaces getVariant() and variant()
149474 : // though after variant() has been removed for a while we will
149475 : // want to change the name of variantT() back to variant()
149476 : // (since the "T" was ment to stand for temporary).
149477 : // When this happens the variantT() will be depricated.
149478 : VariantT
149479 38096600 : SgCtorInitializerList::variantT() const
149480 : {
149481 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
149482 38096600 : ROSE_ASSERT(this != NULL);
149483 38096600 : return V_SgCtorInitializerList;
149484 : }
149485 :
149486 : #if 0
149487 : int
149488 : SgCtorInitializerList::variant() const
149489 : {
149490 : // This function is used in SAGE
149491 : ROSE_ASSERT(this != NULL);
149492 : return CTOR_INITIALIZER_LIST;
149493 : }
149494 : #endif
149495 :
149496 : ROSE_DLL_API const char*
149497 1332 : SgCtorInitializerList::sage_class_name() const
149498 : {
149499 1332 : ROSE_ASSERT(this != NULL);
149500 1332 : return "SgCtorInitializerList";
149501 : }
149502 :
149503 : std::string
149504 33303 : SgCtorInitializerList::class_name() const
149505 : {
149506 33303 : ROSE_ASSERT(this != NULL);
149507 33303 : return "SgCtorInitializerList";
149508 : }
149509 :
149510 : // DQ (11/26/2005): Support for visitor pattern mechanims
149511 : // (inferior to ROSE traversal mechanism, experimental).
149512 : void
149513 619556 : SgCtorInitializerList::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
149514 : {
149515 619556 : ROSE_ASSERT(this != NULL);
149516 619556 : visitor.visit(this);
149517 619556 : }
149518 :
149519 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
149520 0 : void SgCtorInitializerList::accept (ROSE_VisitorPattern & visitor) {
149521 0 : ROSE_ASSERT(this != NULL);
149522 0 : visitor.visit(this);
149523 0 : }
149524 :
149525 : SgCtorInitializerList*
149526 0 : SgCtorInitializerList::addRegExpAttribute(std::string s, AstRegExAttribute* a)
149527 : {
149528 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
149529 : // This function is currently only supported for the AST used the represent Binary executables.
149530 : if (0 /* isSgAsmNode(this) != NULL */)
149531 : {
149532 : // Support for regex specification.
149533 : std::string prefixCode = "REGEX:";
149534 : addNewAttribute(prefixCode + s,a);
149535 : }
149536 : #endif
149537 :
149538 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
149539 0 : return this;
149540 : }
149541 :
149542 : // *** COMMON CODE SECTION ENDS HERE ***
149543 :
149544 :
149545 : // End of memberFunctionString
149546 : // Start of memberFunctionString
149547 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
149548 :
149549 :
149550 : #if 0
149551 : //! Error checking support
149552 : /*! Verifies the following:
149553 : - working getVariant() member function
149554 : - calls base class's error() member function
149555 : Every class has one of these functions.
149556 : */
149557 : bool
149558 : SgCtorInitializerList::error()
149559 : {
149560 : // Put error checking here
149561 :
149562 : ROSE_ASSERT (this != NULL);
149563 : if (getVariant() != CTOR_INITIALIZER_LIST)
149564 : {
149565 : printf ("Error in SgCtorInitializerList::error(): SgCtorInitializerList object has a %s variant \n",
149566 : Cxx_GrammarTerminalNames[getVariant()].name);
149567 : // printf ("Error in SgCtorInitializerList::error() \n");
149568 : ROSE_ABORT();
149569 : }
149570 :
149571 : ROSE_ASSERT (getVariant() == CTOR_INITIALIZER_LIST);
149572 : return SgDeclarationStatement::error();
149573 : }
149574 : #endif
149575 :
149576 :
149577 :
149578 : // End of memberFunctionString
149579 :
149580 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
149581 :
149582 2714390 : SgCtorInitializerList* isSgCtorInitializerList ( SgNode* inputDerivedClassPointer )
149583 : {
149584 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
149585 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
149586 : // So to fix this we return NULL directly when the input is NULL and avoid the
149587 : // dynamic_cast in this case. This is likely a performance improvement as well.
149588 : // return dynamic_cast<SgCtorInitializerList*>(inputDerivedClassPointer);
149589 : // Milind Chabbi (8/28/2013): isSgCtorInitializerList uses table-driven castability instead of c++ default dynamic_cast
149590 : // this improves the running time performance by 10-20%.
149591 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCtorInitializerList*>(inputDerivedClassPointer);
149592 2714390 : return IS_SgCtorInitializerList_FAST_MACRO(inputDerivedClassPointer);
149593 : }
149594 :
149595 : // DQ (11/8/2003): Added version of functions taking const pointer
149596 1329490 : const SgCtorInitializerList* isSgCtorInitializerList ( const SgNode* inputDerivedClassPointer )
149597 : {
149598 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
149599 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
149600 : // So to fix this we return NULL directly when the input is NULL and avoid the
149601 : // dynamic_cast in this case. This is likely a performance improvement as well.
149602 : // return dynamic_cast<const SgCtorInitializerList*>(inputDerivedClassPointer);
149603 : // Milind Chabbi (8/28/2013): isSgCtorInitializerList uses table-driven castability instead of c++ default dynamic_cast
149604 : // this improves the running time performance by 10-20%.
149605 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCtorInitializerList*>(inputDerivedClassPointer);
149606 1329490 : return IS_SgCtorInitializerList_FAST_MACRO(inputDerivedClassPointer);
149607 : }
149608 :
149609 :
149610 :
149611 : /* #line 149612 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149612 :
149613 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
149614 :
149615 : /**
149616 : \brief Generated destructor
149617 :
149618 : This destructor is automatically generated (by ROSETTA). This destructor
149619 : only frees memory of data members associated with the parts of the current IR node which
149620 : are NOT traversed. Those data members that are part of a traversal can be freed using
149621 : a traversal (calling this destructor on all children in a post-order traversal). Such
149622 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
149623 :
149624 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
149625 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
149626 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
149627 :
149628 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
149629 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
149630 : pointers are not yet implemented to call delete on eash pointer in the container.
149631 : (This could be done by derivation from the STL containers to define containers that
149632 : automatically deleted their members.)
149633 :
149634 : */
149635 18052 : SgCtorInitializerList::~SgCtorInitializerList () {
149636 8856 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
149637 :
149638 :
149639 :
149640 : }
149641 :
149642 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
149643 17712 : }
149644 :
149645 :
149646 : /* #line 149647 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149647 :
149648 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
149649 :
149650 : // Generated constructor
149651 0 : SgCtorInitializerList::SgCtorInitializerList ( Sg_File_Info* startOfConstruct )
149652 0 : : SgDeclarationStatement(startOfConstruct)
149653 : {
149654 : #ifdef DEBUG
149655 : // printf ("In SgCtorInitializerList::SgCtorInitializerList (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
149656 : #endif
149657 : #if 0
149658 : // debugging information!
149659 : printf ("In SgCtorInitializerList::SgCtorInitializerList (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
149660 : #endif
149661 :
149662 :
149663 :
149664 : #if 0
149665 : // DQ (7/30/2014): Call a virtual function.
149666 : std::string s = this->class_name();
149667 : #endif
149668 :
149669 : // Test the variant virtual function
149670 : // assert(CTOR_INITIALIZER_LIST == variant());
149671 0 : assert(CTOR_INITIALIZER_LIST == this->variant());
149672 0 : ROSE_ASSERT(CTOR_INITIALIZER_LIST == (int)(this->variantT()));
149673 0 : post_construction_initialization();
149674 :
149675 : // Test the isSgCtorInitializerList() function since it has been problematic
149676 0 : assert(isSgCtorInitializerList(this) != NULL);
149677 0 : }
149678 :
149679 : // Generated constructor (all data members)
149680 :
149681 : /* #line 149682 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149682 :
149683 :
149684 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
149685 :
149686 :
149687 : // ********************************************************
149688 : // member functions common across all array grammar objects
149689 : // ********************************************************
149690 :
149691 :
149692 :
149693 : /* #line 149694 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149694 :
149695 :
149696 :
149697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
149698 :
149699 : // ********************************************************
149700 : // member functions specific to each node in the grammar
149701 : // ********************************************************
149702 :
149703 :
149704 : /* #line 149705 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149705 :
149706 : // Start of memberFunctionString
149707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
149708 :
149709 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
149710 :
149711 : SgPragma*
149712 3006 : SgPragmaDeclaration::get_pragma () const
149713 : {
149714 3006 : ROSE_ASSERT (this != NULL);
149715 :
149716 : #if 0
149717 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
149718 : // used to trigger marking transformations for the token-based unparsing.
149719 : printf ("SgPragmaDeclaration::get_pragma = %p = %s \n",this,this->class_name().c_str());
149720 : #endif
149721 :
149722 3006 : return p_pragma;
149723 : }
149724 :
149725 : void
149726 0 : SgPragmaDeclaration::set_pragma ( SgPragma* pragma )
149727 : {
149728 0 : ROSE_ASSERT (this != NULL);
149729 :
149730 : #if 0
149731 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
149732 : // used to trigger marking transformations for the token-based unparsing.
149733 : printf ("SgPragmaDeclaration::set_pragma = %p = %s \n",this,this->class_name().c_str());
149734 : #endif
149735 :
149736 0 : set_isModified(true);
149737 :
149738 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
149739 : if (p_pragma != NULL && pragma != NULL && p_pragma != pragma)
149740 : {
149741 : printf ("Warning: pragma = %p overwriting valid pointer p_pragma = %p \n",pragma,p_pragma);
149742 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
149743 : printf ("Error fails assertion (p_pragma != NULL && pragma != NULL && p_pragma != pragma) is false\n");
149744 : ROSE_ASSERT(false);
149745 : #endif
149746 : }
149747 : #endif
149748 0 : p_pragma = pragma;
149749 0 : }
149750 :
149751 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
149752 :
149753 :
149754 : // End of memberFunctionString
149755 : // Start of memberFunctionString
149756 : /* #line 17264 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
149757 :
149758 : void
149759 1829 : SgPragmaDeclaration::post_construction_initialization()
149760 : {
149761 1829 : }
149762 :
149763 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
149764 : SgName
149765 1690 : SgPragmaDeclaration::get_mangled_name(void) const
149766 : {
149767 1690 : SgName returnName;
149768 :
149769 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
149770 : // SgScopeStatement* scope = get_scope();
149771 : // ROSE_ASSERT(scope != NULL);
149772 :
149773 : // This is a poor way to handle the generation of a mangled name (will be improved)
149774 1690 : returnName = "pragma_statement";
149775 :
149776 1690 : return returnName;
149777 : }
149778 :
149779 :
149780 :
149781 : // End of memberFunctionString
149782 : // Start of memberFunctionString
149783 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
149784 :
149785 : // *** COMMON CODE SECTION BEGINS HERE ***
149786 :
149787 : #if 0
149788 : int
149789 : SgPragmaDeclaration::getVariant() const
149790 : {
149791 : // This function is used in ROSE while "variant()" is used in SAGE
149792 : assert(this != NULL);
149793 : return variant();
149794 : }
149795 : #endif
149796 :
149797 : // This function is used in ROSE in treeTraversal code
149798 : // eventually replaces getVariant() and variant()
149799 : // though after variant() has been removed for a while we will
149800 : // want to change the name of variantT() back to variant()
149801 : // (since the "T" was ment to stand for temporary).
149802 : // When this happens the variantT() will be depricated.
149803 : VariantT
149804 875719 : SgPragmaDeclaration::variantT() const
149805 : {
149806 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
149807 875719 : ROSE_ASSERT(this != NULL);
149808 875719 : return V_SgPragmaDeclaration;
149809 : }
149810 :
149811 : #if 0
149812 : int
149813 : SgPragmaDeclaration::variant() const
149814 : {
149815 : // This function is used in SAGE
149816 : ROSE_ASSERT(this != NULL);
149817 : return PRAGMA_DECL;
149818 : }
149819 : #endif
149820 :
149821 : ROSE_DLL_API const char*
149822 15 : SgPragmaDeclaration::sage_class_name() const
149823 : {
149824 15 : ROSE_ASSERT(this != NULL);
149825 15 : return "SgPragmaDeclaration";
149826 : }
149827 :
149828 : std::string
149829 1687 : SgPragmaDeclaration::class_name() const
149830 : {
149831 1687 : ROSE_ASSERT(this != NULL);
149832 1687 : return "SgPragmaDeclaration";
149833 : }
149834 :
149835 : // DQ (11/26/2005): Support for visitor pattern mechanims
149836 : // (inferior to ROSE traversal mechanism, experimental).
149837 : void
149838 13512 : SgPragmaDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
149839 : {
149840 13512 : ROSE_ASSERT(this != NULL);
149841 13512 : visitor.visit(this);
149842 13512 : }
149843 :
149844 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
149845 0 : void SgPragmaDeclaration::accept (ROSE_VisitorPattern & visitor) {
149846 0 : ROSE_ASSERT(this != NULL);
149847 0 : visitor.visit(this);
149848 0 : }
149849 :
149850 : SgPragmaDeclaration*
149851 0 : SgPragmaDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
149852 : {
149853 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
149854 : // This function is currently only supported for the AST used the represent Binary executables.
149855 : if (0 /* isSgAsmNode(this) != NULL */)
149856 : {
149857 : // Support for regex specification.
149858 : std::string prefixCode = "REGEX:";
149859 : addNewAttribute(prefixCode + s,a);
149860 : }
149861 : #endif
149862 :
149863 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
149864 0 : return this;
149865 : }
149866 :
149867 : // *** COMMON CODE SECTION ENDS HERE ***
149868 :
149869 :
149870 : // End of memberFunctionString
149871 : // Start of memberFunctionString
149872 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
149873 :
149874 :
149875 : #if 0
149876 : //! Error checking support
149877 : /*! Verifies the following:
149878 : - working getVariant() member function
149879 : - calls base class's error() member function
149880 : Every class has one of these functions.
149881 : */
149882 : bool
149883 : SgPragmaDeclaration::error()
149884 : {
149885 : // Put error checking here
149886 :
149887 : ROSE_ASSERT (this != NULL);
149888 : if (getVariant() != PRAGMA_DECL)
149889 : {
149890 : printf ("Error in SgPragmaDeclaration::error(): SgPragmaDeclaration object has a %s variant \n",
149891 : Cxx_GrammarTerminalNames[getVariant()].name);
149892 : // printf ("Error in SgPragmaDeclaration::error() \n");
149893 : ROSE_ABORT();
149894 : }
149895 :
149896 : ROSE_ASSERT (getVariant() == PRAGMA_DECL);
149897 : return SgDeclarationStatement::error();
149898 : }
149899 : #endif
149900 :
149901 :
149902 :
149903 : // End of memberFunctionString
149904 :
149905 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
149906 :
149907 3303 : SgPragmaDeclaration* isSgPragmaDeclaration ( SgNode* inputDerivedClassPointer )
149908 : {
149909 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
149910 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
149911 : // So to fix this we return NULL directly when the input is NULL and avoid the
149912 : // dynamic_cast in this case. This is likely a performance improvement as well.
149913 : // return dynamic_cast<SgPragmaDeclaration*>(inputDerivedClassPointer);
149914 : // Milind Chabbi (8/28/2013): isSgPragmaDeclaration uses table-driven castability instead of c++ default dynamic_cast
149915 : // this improves the running time performance by 10-20%.
149916 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPragmaDeclaration*>(inputDerivedClassPointer);
149917 3303 : return IS_SgPragmaDeclaration_FAST_MACRO(inputDerivedClassPointer);
149918 : }
149919 :
149920 : // DQ (11/8/2003): Added version of functions taking const pointer
149921 1277580 : const SgPragmaDeclaration* isSgPragmaDeclaration ( const SgNode* inputDerivedClassPointer )
149922 : {
149923 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
149924 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
149925 : // So to fix this we return NULL directly when the input is NULL and avoid the
149926 : // dynamic_cast in this case. This is likely a performance improvement as well.
149927 : // return dynamic_cast<const SgPragmaDeclaration*>(inputDerivedClassPointer);
149928 : // Milind Chabbi (8/28/2013): isSgPragmaDeclaration uses table-driven castability instead of c++ default dynamic_cast
149929 : // this improves the running time performance by 10-20%.
149930 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPragmaDeclaration*>(inputDerivedClassPointer);
149931 1277580 : return IS_SgPragmaDeclaration_FAST_MACRO(inputDerivedClassPointer);
149932 : }
149933 :
149934 :
149935 :
149936 : /* #line 149937 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149937 :
149938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
149939 :
149940 : /**
149941 : \brief Generated destructor
149942 :
149943 : This destructor is automatically generated (by ROSETTA). This destructor
149944 : only frees memory of data members associated with the parts of the current IR node which
149945 : are NOT traversed. Those data members that are part of a traversal can be freed using
149946 : a traversal (calling this destructor on all children in a post-order traversal). Such
149947 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
149948 :
149949 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
149950 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
149951 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
149952 :
149953 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
149954 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
149955 : pointers are not yet implemented to call delete on eash pointer in the container.
149956 : (This could be done by derivation from the STL containers to define containers that
149957 : automatically deleted their members.)
149958 :
149959 : */
149960 388 : SgPragmaDeclaration::~SgPragmaDeclaration () {
149961 194 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
149962 :
149963 :
149964 : // case: not a listType for pragma
149965 194 : p_pragma = NULL; // non list case
149966 :
149967 : }
149968 :
149969 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
149970 388 : }
149971 :
149972 :
149973 : /* #line 149974 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
149974 :
149975 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
149976 :
149977 : // Generated constructor
149978 0 : SgPragmaDeclaration::SgPragmaDeclaration ( Sg_File_Info* startOfConstruct, SgPragma* pragma )
149979 0 : : SgDeclarationStatement(startOfConstruct)
149980 : {
149981 : #ifdef DEBUG
149982 : // printf ("In SgPragmaDeclaration::SgPragmaDeclaration (Sg_File_Info* startOfConstruct, SgPragma* pragma) sage_class_name() = %s \n",sage_class_name());
149983 : #endif
149984 : #if 0
149985 : // debugging information!
149986 : printf ("In SgPragmaDeclaration::SgPragmaDeclaration (Sg_File_Info* startOfConstruct, SgPragma* pragma): this = %p = %s \n",this,this->class_name().c_str());
149987 : #endif
149988 :
149989 0 : p_pragma = pragma;
149990 :
149991 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
149992 :
149993 : #if 0
149994 : // DQ (7/30/2014): Call a virtual function.
149995 : std::string s = this->class_name();
149996 : #endif
149997 :
149998 : // Test the variant virtual function
149999 : // assert(PRAGMA_DECL == variant());
150000 0 : assert(PRAGMA_DECL == this->variant());
150001 0 : ROSE_ASSERT(PRAGMA_DECL == (int)(this->variantT()));
150002 0 : post_construction_initialization();
150003 :
150004 : // Test the isSgPragmaDeclaration() function since it has been problematic
150005 0 : assert(isSgPragmaDeclaration(this) != NULL);
150006 0 : }
150007 :
150008 : // Generated constructor (all data members)
150009 :
150010 : /* #line 150011 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150011 :
150012 :
150013 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
150014 :
150015 :
150016 : // ********************************************************
150017 : // member functions common across all array grammar objects
150018 : // ********************************************************
150019 :
150020 :
150021 :
150022 : /* #line 150023 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150023 :
150024 :
150025 :
150026 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
150027 :
150028 : // ********************************************************
150029 : // member functions specific to each node in the grammar
150030 : // ********************************************************
150031 :
150032 :
150033 : /* #line 150034 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150034 :
150035 : // Start of memberFunctionString
150036 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150037 :
150038 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150039 :
150040 : SgNamespaceDeclarationStatement*
150041 59 : SgUsingDirectiveStatement::get_namespaceDeclaration () const
150042 : {
150043 59 : ROSE_ASSERT (this != NULL);
150044 :
150045 : #if 0
150046 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150047 : // used to trigger marking transformations for the token-based unparsing.
150048 : printf ("SgUsingDirectiveStatement::get_namespaceDeclaration = %p = %s \n",this,this->class_name().c_str());
150049 : #endif
150050 :
150051 59 : return p_namespaceDeclaration;
150052 : }
150053 :
150054 : void
150055 0 : SgUsingDirectiveStatement::set_namespaceDeclaration ( SgNamespaceDeclarationStatement* namespaceDeclaration )
150056 : {
150057 0 : ROSE_ASSERT (this != NULL);
150058 :
150059 : #if 0
150060 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150061 : // used to trigger marking transformations for the token-based unparsing.
150062 : printf ("SgUsingDirectiveStatement::set_namespaceDeclaration = %p = %s \n",this,this->class_name().c_str());
150063 : #endif
150064 :
150065 0 : set_isModified(true);
150066 :
150067 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
150068 : if (p_namespaceDeclaration != NULL && namespaceDeclaration != NULL && p_namespaceDeclaration != namespaceDeclaration)
150069 : {
150070 : printf ("Warning: namespaceDeclaration = %p overwriting valid pointer p_namespaceDeclaration = %p \n",namespaceDeclaration,p_namespaceDeclaration);
150071 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
150072 : printf ("Error fails assertion (p_namespaceDeclaration != NULL && namespaceDeclaration != NULL && p_namespaceDeclaration != namespaceDeclaration) is false\n");
150073 : ROSE_ASSERT(false);
150074 : #endif
150075 : }
150076 : #endif
150077 0 : p_namespaceDeclaration = namespaceDeclaration;
150078 0 : }
150079 :
150080 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150081 :
150082 :
150083 : // End of memberFunctionString
150084 : // Start of memberFunctionString
150085 :
150086 :
150087 : // End of memberFunctionString
150088 : // Start of memberFunctionString
150089 : /* #line 17702 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
150090 :
150091 :
150092 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
150093 : SgName
150094 14 : SgUsingDirectiveStatement::get_mangled_name(void) const
150095 : {
150096 14 : SgName returnName;
150097 :
150098 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
150099 14 : SgScopeStatement* scope = get_scope();
150100 14 : ROSE_ASSERT(scope != NULL);
150101 :
150102 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
150103 : // This is a poor way to handle the generation of a mangled name (will be improved)
150104 : // returnName = scope->get_qualified_name() + SgName("_using_directive_") + get_namespaceDeclaration()->get_mangled_name();
150105 14 : returnName = scope->get_mangled_name() + SgName("_using_directive_") + get_namespaceDeclaration()->get_mangled_name();
150106 :
150107 14 : return returnName;
150108 : }
150109 :
150110 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
150111 : // so that we could avoid them setting the isModified flag which is a problem in the
150112 : // name qualification support for C++ (interfering with the token-based unparsing).
150113 : int
150114 6 : SgUsingDirectiveStatement::get_name_qualification_length () const
150115 : {
150116 6 : ROSE_ASSERT (this != NULL);
150117 6 : return p_name_qualification_length;
150118 : }
150119 :
150120 : void
150121 17 : SgUsingDirectiveStatement::set_name_qualification_length ( int name_qualification_length )
150122 : {
150123 17 : ROSE_ASSERT (this != NULL);
150124 : // This can't be called by the name qualification API (see test2015_26.C).
150125 : // set_isModified(true);
150126 :
150127 17 : p_name_qualification_length = name_qualification_length;
150128 17 : }
150129 :
150130 : bool
150131 0 : SgUsingDirectiveStatement::get_type_elaboration_required () const
150132 : {
150133 0 : ROSE_ASSERT (this != NULL);
150134 0 : return p_type_elaboration_required;
150135 : }
150136 :
150137 : void
150138 17 : SgUsingDirectiveStatement::set_type_elaboration_required ( bool type_elaboration_required )
150139 : {
150140 17 : ROSE_ASSERT (this != NULL);
150141 : // This can't be called by the name qualification API (see test2015_26.C).
150142 : // set_isModified(true);
150143 :
150144 17 : p_type_elaboration_required = type_elaboration_required;
150145 17 : }
150146 :
150147 : bool
150148 6 : SgUsingDirectiveStatement::get_global_qualification_required () const
150149 : {
150150 6 : ROSE_ASSERT (this != NULL);
150151 6 : return p_global_qualification_required;
150152 : }
150153 :
150154 : void
150155 17 : SgUsingDirectiveStatement::set_global_qualification_required ( bool global_qualification_required )
150156 : {
150157 17 : ROSE_ASSERT (this != NULL);
150158 :
150159 : // This can't be called by the name qualification API (see test2015_26.C).
150160 : // set_isModified(true);
150161 :
150162 17 : p_global_qualification_required = global_qualification_required;
150163 17 : }
150164 :
150165 :
150166 :
150167 : // End of memberFunctionString
150168 : // Start of memberFunctionString
150169 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
150170 :
150171 : void
150172 16 : SgUsingDirectiveStatement::post_construction_initialization()
150173 : {
150174 16 : }
150175 :
150176 :
150177 :
150178 : // End of memberFunctionString
150179 : // Start of memberFunctionString
150180 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
150181 :
150182 : // *** COMMON CODE SECTION BEGINS HERE ***
150183 :
150184 : #if 0
150185 : int
150186 : SgUsingDirectiveStatement::getVariant() const
150187 : {
150188 : // This function is used in ROSE while "variant()" is used in SAGE
150189 : assert(this != NULL);
150190 : return variant();
150191 : }
150192 : #endif
150193 :
150194 : // This function is used in ROSE in treeTraversal code
150195 : // eventually replaces getVariant() and variant()
150196 : // though after variant() has been removed for a while we will
150197 : // want to change the name of variantT() back to variant()
150198 : // (since the "T" was ment to stand for temporary).
150199 : // When this happens the variantT() will be depricated.
150200 : VariantT
150201 21030 : SgUsingDirectiveStatement::variantT() const
150202 : {
150203 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
150204 21030 : ROSE_ASSERT(this != NULL);
150205 21030 : return V_SgUsingDirectiveStatement;
150206 : }
150207 :
150208 : #if 0
150209 : int
150210 : SgUsingDirectiveStatement::variant() const
150211 : {
150212 : // This function is used in SAGE
150213 : ROSE_ASSERT(this != NULL);
150214 : return USING_DIRECTIVE_STMT;
150215 : }
150216 : #endif
150217 :
150218 : ROSE_DLL_API const char*
150219 2 : SgUsingDirectiveStatement::sage_class_name() const
150220 : {
150221 2 : ROSE_ASSERT(this != NULL);
150222 2 : return "SgUsingDirectiveStatement";
150223 : }
150224 :
150225 : std::string
150226 14 : SgUsingDirectiveStatement::class_name() const
150227 : {
150228 14 : ROSE_ASSERT(this != NULL);
150229 14 : return "SgUsingDirectiveStatement";
150230 : }
150231 :
150232 : // DQ (11/26/2005): Support for visitor pattern mechanims
150233 : // (inferior to ROSE traversal mechanism, experimental).
150234 : void
150235 240 : SgUsingDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
150236 : {
150237 240 : ROSE_ASSERT(this != NULL);
150238 240 : visitor.visit(this);
150239 240 : }
150240 :
150241 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
150242 0 : void SgUsingDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
150243 0 : ROSE_ASSERT(this != NULL);
150244 0 : visitor.visit(this);
150245 0 : }
150246 :
150247 : SgUsingDirectiveStatement*
150248 0 : SgUsingDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
150249 : {
150250 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
150251 : // This function is currently only supported for the AST used the represent Binary executables.
150252 : if (0 /* isSgAsmNode(this) != NULL */)
150253 : {
150254 : // Support for regex specification.
150255 : std::string prefixCode = "REGEX:";
150256 : addNewAttribute(prefixCode + s,a);
150257 : }
150258 : #endif
150259 :
150260 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
150261 0 : return this;
150262 : }
150263 :
150264 : // *** COMMON CODE SECTION ENDS HERE ***
150265 :
150266 :
150267 : // End of memberFunctionString
150268 : // Start of memberFunctionString
150269 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
150270 :
150271 :
150272 : #if 0
150273 : //! Error checking support
150274 : /*! Verifies the following:
150275 : - working getVariant() member function
150276 : - calls base class's error() member function
150277 : Every class has one of these functions.
150278 : */
150279 : bool
150280 : SgUsingDirectiveStatement::error()
150281 : {
150282 : // Put error checking here
150283 :
150284 : ROSE_ASSERT (this != NULL);
150285 : if (getVariant() != USING_DIRECTIVE_STMT)
150286 : {
150287 : printf ("Error in SgUsingDirectiveStatement::error(): SgUsingDirectiveStatement object has a %s variant \n",
150288 : Cxx_GrammarTerminalNames[getVariant()].name);
150289 : // printf ("Error in SgUsingDirectiveStatement::error() \n");
150290 : ROSE_ABORT();
150291 : }
150292 :
150293 : ROSE_ASSERT (getVariant() == USING_DIRECTIVE_STMT);
150294 : return SgDeclarationStatement::error();
150295 : }
150296 : #endif
150297 :
150298 :
150299 :
150300 : // End of memberFunctionString
150301 :
150302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
150303 :
150304 11745400 : SgUsingDirectiveStatement* isSgUsingDirectiveStatement ( SgNode* inputDerivedClassPointer )
150305 : {
150306 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
150307 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
150308 : // So to fix this we return NULL directly when the input is NULL and avoid the
150309 : // dynamic_cast in this case. This is likely a performance improvement as well.
150310 : // return dynamic_cast<SgUsingDirectiveStatement*>(inputDerivedClassPointer);
150311 : // Milind Chabbi (8/28/2013): isSgUsingDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
150312 : // this improves the running time performance by 10-20%.
150313 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUsingDirectiveStatement*>(inputDerivedClassPointer);
150314 11745400 : return IS_SgUsingDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
150315 : }
150316 :
150317 : // DQ (11/8/2003): Added version of functions taking const pointer
150318 0 : const SgUsingDirectiveStatement* isSgUsingDirectiveStatement ( const SgNode* inputDerivedClassPointer )
150319 : {
150320 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
150321 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
150322 : // So to fix this we return NULL directly when the input is NULL and avoid the
150323 : // dynamic_cast in this case. This is likely a performance improvement as well.
150324 : // return dynamic_cast<const SgUsingDirectiveStatement*>(inputDerivedClassPointer);
150325 : // Milind Chabbi (8/28/2013): isSgUsingDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
150326 : // this improves the running time performance by 10-20%.
150327 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUsingDirectiveStatement*>(inputDerivedClassPointer);
150328 0 : return IS_SgUsingDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
150329 : }
150330 :
150331 :
150332 :
150333 : /* #line 150334 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150334 :
150335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
150336 :
150337 : /**
150338 : \brief Generated destructor
150339 :
150340 : This destructor is automatically generated (by ROSETTA). This destructor
150341 : only frees memory of data members associated with the parts of the current IR node which
150342 : are NOT traversed. Those data members that are part of a traversal can be freed using
150343 : a traversal (calling this destructor on all children in a post-order traversal). Such
150344 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
150345 :
150346 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
150347 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
150348 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
150349 :
150350 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
150351 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
150352 : pointers are not yet implemented to call delete on eash pointer in the container.
150353 : (This could be done by derivation from the STL containers to define containers that
150354 : automatically deleted their members.)
150355 :
150356 : */
150357 4 : SgUsingDirectiveStatement::~SgUsingDirectiveStatement () {
150358 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
150359 :
150360 :
150361 : // case: not a listType for namespaceDeclaration
150362 2 : p_namespaceDeclaration = NULL; // non list case
150363 : // case: not a listType for name_qualification_length
150364 2 : p_name_qualification_length = 0; // non list case
150365 : // case: not a listType for type_elaboration_required
150366 2 : p_type_elaboration_required = false; // non list case
150367 : // case: not a listType for global_qualification_required
150368 2 : p_global_qualification_required = false; // non list case
150369 :
150370 : }
150371 :
150372 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
150373 4 : }
150374 :
150375 :
150376 : /* #line 150377 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150377 :
150378 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
150379 :
150380 : // Generated constructor
150381 0 : SgUsingDirectiveStatement::SgUsingDirectiveStatement ( Sg_File_Info* startOfConstruct, SgNamespaceDeclarationStatement* namespaceDeclaration )
150382 0 : : SgDeclarationStatement(startOfConstruct)
150383 : {
150384 : #ifdef DEBUG
150385 : // printf ("In SgUsingDirectiveStatement::SgUsingDirectiveStatement (Sg_File_Info* startOfConstruct, SgNamespaceDeclarationStatement* namespaceDeclaration) sage_class_name() = %s \n",sage_class_name());
150386 : #endif
150387 : #if 0
150388 : // debugging information!
150389 : printf ("In SgUsingDirectiveStatement::SgUsingDirectiveStatement (Sg_File_Info* startOfConstruct, SgNamespaceDeclarationStatement* namespaceDeclaration): this = %p = %s \n",this,this->class_name().c_str());
150390 : #endif
150391 :
150392 0 : p_namespaceDeclaration = namespaceDeclaration;
150393 0 : p_name_qualification_length = 0;
150394 0 : p_type_elaboration_required = false;
150395 0 : p_global_qualification_required = false;
150396 :
150397 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
150398 :
150399 : #if 0
150400 : // DQ (7/30/2014): Call a virtual function.
150401 : std::string s = this->class_name();
150402 : #endif
150403 :
150404 : // Test the variant virtual function
150405 : // assert(USING_DIRECTIVE_STMT == variant());
150406 0 : assert(USING_DIRECTIVE_STMT == this->variant());
150407 0 : ROSE_ASSERT(USING_DIRECTIVE_STMT == (int)(this->variantT()));
150408 0 : post_construction_initialization();
150409 :
150410 : // Test the isSgUsingDirectiveStatement() function since it has been problematic
150411 0 : assert(isSgUsingDirectiveStatement(this) != NULL);
150412 0 : }
150413 :
150414 : // Generated constructor (all data members)
150415 :
150416 : /* #line 150417 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150417 :
150418 :
150419 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
150420 :
150421 :
150422 : // ********************************************************
150423 : // member functions common across all array grammar objects
150424 : // ********************************************************
150425 :
150426 :
150427 :
150428 : /* #line 150429 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150429 :
150430 :
150431 :
150432 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
150433 :
150434 : // ********************************************************
150435 : // member functions specific to each node in the grammar
150436 : // ********************************************************
150437 :
150438 :
150439 : /* #line 150440 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
150440 :
150441 : // Start of memberFunctionString
150442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150443 :
150444 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150445 :
150446 : SgName
150447 1213700 : SgClassDeclaration::get_name () const
150448 : {
150449 1213700 : ROSE_ASSERT (this != NULL);
150450 :
150451 : #if 0
150452 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150453 : // used to trigger marking transformations for the token-based unparsing.
150454 : printf ("SgClassDeclaration::get_name = %p = %s \n",this,this->class_name().c_str());
150455 : #endif
150456 :
150457 1213700 : return p_name;
150458 : }
150459 :
150460 : void
150461 2 : SgClassDeclaration::set_name ( SgName name )
150462 : {
150463 2 : ROSE_ASSERT (this != NULL);
150464 :
150465 : #if 0
150466 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150467 : // used to trigger marking transformations for the token-based unparsing.
150468 : printf ("SgClassDeclaration::set_name = %p = %s \n",this,this->class_name().c_str());
150469 : #endif
150470 :
150471 2 : set_isModified(true);
150472 :
150473 2 : p_name = name;
150474 2 : }
150475 :
150476 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150477 :
150478 :
150479 : // End of memberFunctionString
150480 : // Start of memberFunctionString
150481 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150482 :
150483 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150484 :
150485 : SgClassDeclaration::class_types
150486 60420 : SgClassDeclaration::get_class_type () const
150487 : {
150488 60420 : ROSE_ASSERT (this != NULL);
150489 :
150490 : #if 0
150491 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150492 : // used to trigger marking transformations for the token-based unparsing.
150493 : printf ("SgClassDeclaration::get_class_type = %p = %s \n",this,this->class_name().c_str());
150494 : #endif
150495 :
150496 60420 : return p_class_type;
150497 : }
150498 :
150499 : void
150500 0 : SgClassDeclaration::set_class_type ( SgClassDeclaration::class_types class_type )
150501 : {
150502 0 : ROSE_ASSERT (this != NULL);
150503 :
150504 : #if 0
150505 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150506 : // used to trigger marking transformations for the token-based unparsing.
150507 : printf ("SgClassDeclaration::set_class_type = %p = %s \n",this,this->class_name().c_str());
150508 : #endif
150509 :
150510 0 : set_isModified(true);
150511 :
150512 0 : p_class_type = class_type;
150513 0 : }
150514 :
150515 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150516 :
150517 :
150518 : // End of memberFunctionString
150519 : // Start of memberFunctionString
150520 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150521 :
150522 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150523 :
150524 : SgClassType*
150525 1503820 : SgClassDeclaration::get_type () const
150526 : {
150527 1503820 : ROSE_ASSERT (this != NULL);
150528 :
150529 : #if 0
150530 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150531 : // used to trigger marking transformations for the token-based unparsing.
150532 : printf ("SgClassDeclaration::get_type = %p = %s \n",this,this->class_name().c_str());
150533 : #endif
150534 :
150535 1503820 : return p_type;
150536 : }
150537 :
150538 : void
150539 68344 : SgClassDeclaration::set_type ( SgClassType* type )
150540 : {
150541 68344 : ROSE_ASSERT (this != NULL);
150542 :
150543 : #if 0
150544 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150545 : // used to trigger marking transformations for the token-based unparsing.
150546 : printf ("SgClassDeclaration::set_type = %p = %s \n",this,this->class_name().c_str());
150547 : #endif
150548 :
150549 68344 : set_isModified(true);
150550 :
150551 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
150552 : if (p_type != NULL && type != NULL && p_type != type)
150553 : {
150554 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
150555 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
150556 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
150557 : ROSE_ASSERT(false);
150558 : #endif
150559 : }
150560 : #endif
150561 68344 : p_type = type;
150562 68344 : }
150563 :
150564 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150565 :
150566 :
150567 : // End of memberFunctionString
150568 : // Start of memberFunctionString
150569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150570 :
150571 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150572 :
150573 : SgClassDefinition*
150574 711046 : SgClassDeclaration::get_definition () const
150575 : {
150576 711046 : ROSE_ASSERT (this != NULL);
150577 :
150578 : #if 0
150579 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150580 : // used to trigger marking transformations for the token-based unparsing.
150581 : printf ("SgClassDeclaration::get_definition = %p = %s \n",this,this->class_name().c_str());
150582 : #endif
150583 :
150584 711046 : return p_definition;
150585 : }
150586 :
150587 : void
150588 0 : SgClassDeclaration::set_definition ( SgClassDefinition* definition )
150589 : {
150590 0 : ROSE_ASSERT (this != NULL);
150591 :
150592 : #if 0
150593 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150594 : // used to trigger marking transformations for the token-based unparsing.
150595 : printf ("SgClassDeclaration::set_definition = %p = %s \n",this,this->class_name().c_str());
150596 : #endif
150597 :
150598 0 : set_isModified(true);
150599 :
150600 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
150601 : if (p_definition != NULL && definition != NULL && p_definition != definition)
150602 : {
150603 : printf ("Warning: definition = %p overwriting valid pointer p_definition = %p \n",definition,p_definition);
150604 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
150605 : printf ("Error fails assertion (p_definition != NULL && definition != NULL && p_definition != definition) is false\n");
150606 : ROSE_ASSERT(false);
150607 : #endif
150608 : }
150609 : #endif
150610 0 : p_definition = definition;
150611 0 : }
150612 :
150613 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150614 :
150615 :
150616 : // End of memberFunctionString
150617 : // Start of memberFunctionString
150618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150619 :
150620 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150621 :
150622 : SgScopeStatement*
150623 2604130 : SgClassDeclaration::get_scope () const
150624 : {
150625 2604130 : ROSE_ASSERT (this != NULL);
150626 :
150627 : #if 0
150628 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150629 : // used to trigger marking transformations for the token-based unparsing.
150630 : printf ("SgClassDeclaration::get_scope = %p = %s \n",this,this->class_name().c_str());
150631 : #endif
150632 :
150633 2604130 : return p_scope;
150634 : }
150635 :
150636 : void
150637 41972 : SgClassDeclaration::set_scope ( SgScopeStatement* scope )
150638 : {
150639 41972 : ROSE_ASSERT (this != NULL);
150640 :
150641 : #if 0
150642 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150643 : // used to trigger marking transformations for the token-based unparsing.
150644 : printf ("SgClassDeclaration::set_scope = %p = %s \n",this,this->class_name().c_str());
150645 : #endif
150646 :
150647 41972 : set_isModified(true);
150648 :
150649 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
150650 : if (p_scope != NULL && scope != NULL && p_scope != scope)
150651 : {
150652 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
150653 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
150654 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
150655 : ROSE_ASSERT(false);
150656 : #endif
150657 : }
150658 : #endif
150659 41972 : p_scope = scope;
150660 41972 : }
150661 :
150662 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150663 :
150664 :
150665 : // End of memberFunctionString
150666 : // Start of memberFunctionString
150667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150668 :
150669 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150670 :
150671 : SgDeclarationStatement::template_specialization_enum
150672 40710 : SgClassDeclaration::get_specialization () const
150673 : {
150674 40710 : ROSE_ASSERT (this != NULL);
150675 :
150676 : #if 0
150677 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150678 : // used to trigger marking transformations for the token-based unparsing.
150679 : printf ("SgClassDeclaration::get_specialization = %p = %s \n",this,this->class_name().c_str());
150680 : #endif
150681 :
150682 40710 : return p_specialization;
150683 : }
150684 :
150685 : void
150686 2998 : SgClassDeclaration::set_specialization ( SgDeclarationStatement::template_specialization_enum specialization )
150687 : {
150688 2998 : ROSE_ASSERT (this != NULL);
150689 :
150690 : #if 0
150691 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150692 : // used to trigger marking transformations for the token-based unparsing.
150693 : printf ("SgClassDeclaration::set_specialization = %p = %s \n",this,this->class_name().c_str());
150694 : #endif
150695 :
150696 2998 : set_isModified(true);
150697 :
150698 2998 : p_specialization = specialization;
150699 2998 : }
150700 :
150701 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150702 :
150703 :
150704 : // End of memberFunctionString
150705 : // Start of memberFunctionString
150706 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150707 :
150708 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150709 :
150710 : bool
150711 0 : SgClassDeclaration::get_from_template () const
150712 : {
150713 0 : ROSE_ASSERT (this != NULL);
150714 :
150715 : #if 0
150716 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150717 : // used to trigger marking transformations for the token-based unparsing.
150718 : printf ("SgClassDeclaration::get_from_template = %p = %s \n",this,this->class_name().c_str());
150719 : #endif
150720 :
150721 0 : return p_from_template;
150722 : }
150723 :
150724 : void
150725 32 : SgClassDeclaration::set_from_template ( bool from_template )
150726 : {
150727 32 : ROSE_ASSERT (this != NULL);
150728 :
150729 : #if 0
150730 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150731 : // used to trigger marking transformations for the token-based unparsing.
150732 : printf ("SgClassDeclaration::set_from_template = %p = %s \n",this,this->class_name().c_str());
150733 : #endif
150734 :
150735 32 : set_isModified(true);
150736 :
150737 32 : p_from_template = from_template;
150738 32 : }
150739 :
150740 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150741 :
150742 :
150743 : // End of memberFunctionString
150744 : // Start of memberFunctionString
150745 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150746 :
150747 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150748 :
150749 : bool
150750 146511 : SgClassDeclaration::get_fixupScope () const
150751 : {
150752 146511 : ROSE_ASSERT (this != NULL);
150753 :
150754 : #if 0
150755 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150756 : // used to trigger marking transformations for the token-based unparsing.
150757 : printf ("SgClassDeclaration::get_fixupScope = %p = %s \n",this,this->class_name().c_str());
150758 : #endif
150759 :
150760 146511 : return p_fixupScope;
150761 : }
150762 :
150763 : void
150764 0 : SgClassDeclaration::set_fixupScope ( bool fixupScope )
150765 : {
150766 0 : ROSE_ASSERT (this != NULL);
150767 :
150768 : #if 0
150769 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150770 : // used to trigger marking transformations for the token-based unparsing.
150771 : printf ("SgClassDeclaration::set_fixupScope = %p = %s \n",this,this->class_name().c_str());
150772 : #endif
150773 :
150774 0 : set_isModified(true);
150775 :
150776 0 : p_fixupScope = fixupScope;
150777 0 : }
150778 :
150779 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150780 :
150781 :
150782 : // End of memberFunctionString
150783 : // Start of memberFunctionString
150784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150785 :
150786 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150787 :
150788 : bool
150789 144615 : SgClassDeclaration::get_isUnNamed () const
150790 : {
150791 144615 : ROSE_ASSERT (this != NULL);
150792 :
150793 : #if 0
150794 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150795 : // used to trigger marking transformations for the token-based unparsing.
150796 : printf ("SgClassDeclaration::get_isUnNamed = %p = %s \n",this,this->class_name().c_str());
150797 : #endif
150798 :
150799 144615 : return p_isUnNamed;
150800 : }
150801 :
150802 : void
150803 31386 : SgClassDeclaration::set_isUnNamed ( bool isUnNamed )
150804 : {
150805 31386 : ROSE_ASSERT (this != NULL);
150806 :
150807 : #if 0
150808 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150809 : // used to trigger marking transformations for the token-based unparsing.
150810 : printf ("SgClassDeclaration::set_isUnNamed = %p = %s \n",this,this->class_name().c_str());
150811 : #endif
150812 :
150813 31386 : set_isModified(true);
150814 :
150815 31386 : p_isUnNamed = isUnNamed;
150816 31386 : }
150817 :
150818 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150819 :
150820 :
150821 : // End of memberFunctionString
150822 : // Start of memberFunctionString
150823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150824 :
150825 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150826 :
150827 : bool
150828 0 : SgClassDeclaration::get_explicit_annotation_interface () const
150829 : {
150830 0 : ROSE_ASSERT (this != NULL);
150831 :
150832 : #if 0
150833 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150834 : // used to trigger marking transformations for the token-based unparsing.
150835 : printf ("SgClassDeclaration::get_explicit_annotation_interface = %p = %s \n",this,this->class_name().c_str());
150836 : #endif
150837 :
150838 0 : return p_explicit_annotation_interface;
150839 : }
150840 :
150841 : void
150842 0 : SgClassDeclaration::set_explicit_annotation_interface ( bool explicit_annotation_interface )
150843 : {
150844 0 : ROSE_ASSERT (this != NULL);
150845 :
150846 : #if 0
150847 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150848 : // used to trigger marking transformations for the token-based unparsing.
150849 : printf ("SgClassDeclaration::set_explicit_annotation_interface = %p = %s \n",this,this->class_name().c_str());
150850 : #endif
150851 :
150852 0 : set_isModified(true);
150853 :
150854 0 : p_explicit_annotation_interface = explicit_annotation_interface;
150855 0 : }
150856 :
150857 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150858 :
150859 :
150860 : // End of memberFunctionString
150861 : // Start of memberFunctionString
150862 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150863 :
150864 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150865 :
150866 : bool
150867 0 : SgClassDeclaration::get_explicit_interface () const
150868 : {
150869 0 : ROSE_ASSERT (this != NULL);
150870 :
150871 : #if 0
150872 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150873 : // used to trigger marking transformations for the token-based unparsing.
150874 : printf ("SgClassDeclaration::get_explicit_interface = %p = %s \n",this,this->class_name().c_str());
150875 : #endif
150876 :
150877 0 : return p_explicit_interface;
150878 : }
150879 :
150880 : void
150881 0 : SgClassDeclaration::set_explicit_interface ( bool explicit_interface )
150882 : {
150883 0 : ROSE_ASSERT (this != NULL);
150884 :
150885 : #if 0
150886 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150887 : // used to trigger marking transformations for the token-based unparsing.
150888 : printf ("SgClassDeclaration::set_explicit_interface = %p = %s \n",this,this->class_name().c_str());
150889 : #endif
150890 :
150891 0 : set_isModified(true);
150892 :
150893 0 : p_explicit_interface = explicit_interface;
150894 0 : }
150895 :
150896 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150897 :
150898 :
150899 : // End of memberFunctionString
150900 : // Start of memberFunctionString
150901 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150902 :
150903 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150904 :
150905 : bool
150906 0 : SgClassDeclaration::get_explicit_enum () const
150907 : {
150908 0 : ROSE_ASSERT (this != NULL);
150909 :
150910 : #if 0
150911 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150912 : // used to trigger marking transformations for the token-based unparsing.
150913 : printf ("SgClassDeclaration::get_explicit_enum = %p = %s \n",this,this->class_name().c_str());
150914 : #endif
150915 :
150916 0 : return p_explicit_enum;
150917 : }
150918 :
150919 : void
150920 0 : SgClassDeclaration::set_explicit_enum ( bool explicit_enum )
150921 : {
150922 0 : ROSE_ASSERT (this != NULL);
150923 :
150924 : #if 0
150925 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150926 : // used to trigger marking transformations for the token-based unparsing.
150927 : printf ("SgClassDeclaration::set_explicit_enum = %p = %s \n",this,this->class_name().c_str());
150928 : #endif
150929 :
150930 0 : set_isModified(true);
150931 :
150932 0 : p_explicit_enum = explicit_enum;
150933 0 : }
150934 :
150935 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150936 :
150937 :
150938 : // End of memberFunctionString
150939 : // Start of memberFunctionString
150940 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150941 :
150942 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150943 :
150944 : bool
150945 0 : SgClassDeclaration::get_explicit_anonymous () const
150946 : {
150947 0 : ROSE_ASSERT (this != NULL);
150948 :
150949 : #if 0
150950 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150951 : // used to trigger marking transformations for the token-based unparsing.
150952 : printf ("SgClassDeclaration::get_explicit_anonymous = %p = %s \n",this,this->class_name().c_str());
150953 : #endif
150954 :
150955 0 : return p_explicit_anonymous;
150956 : }
150957 :
150958 : void
150959 0 : SgClassDeclaration::set_explicit_anonymous ( bool explicit_anonymous )
150960 : {
150961 0 : ROSE_ASSERT (this != NULL);
150962 :
150963 : #if 0
150964 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150965 : // used to trigger marking transformations for the token-based unparsing.
150966 : printf ("SgClassDeclaration::set_explicit_anonymous = %p = %s \n",this,this->class_name().c_str());
150967 : #endif
150968 :
150969 0 : set_isModified(true);
150970 :
150971 0 : p_explicit_anonymous = explicit_anonymous;
150972 0 : }
150973 :
150974 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
150975 :
150976 :
150977 : // End of memberFunctionString
150978 : // Start of memberFunctionString
150979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
150980 :
150981 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
150982 :
150983 : SgExprListExp*
150984 0 : SgClassDeclaration::get_decoratorList () const
150985 : {
150986 0 : ROSE_ASSERT (this != NULL);
150987 :
150988 : #if 0
150989 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
150990 : // used to trigger marking transformations for the token-based unparsing.
150991 : printf ("SgClassDeclaration::get_decoratorList = %p = %s \n",this,this->class_name().c_str());
150992 : #endif
150993 :
150994 0 : return p_decoratorList;
150995 : }
150996 :
150997 : void
150998 0 : SgClassDeclaration::set_decoratorList ( SgExprListExp* decoratorList )
150999 : {
151000 0 : ROSE_ASSERT (this != NULL);
151001 :
151002 : #if 0
151003 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151004 : // used to trigger marking transformations for the token-based unparsing.
151005 : printf ("SgClassDeclaration::set_decoratorList = %p = %s \n",this,this->class_name().c_str());
151006 : #endif
151007 :
151008 0 : set_isModified(true);
151009 :
151010 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
151011 : if (p_decoratorList != NULL && decoratorList != NULL && p_decoratorList != decoratorList)
151012 : {
151013 : printf ("Warning: decoratorList = %p overwriting valid pointer p_decoratorList = %p \n",decoratorList,p_decoratorList);
151014 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
151015 : printf ("Error fails assertion (p_decoratorList != NULL && decoratorList != NULL && p_decoratorList != decoratorList) is false\n");
151016 : ROSE_ASSERT(false);
151017 : #endif
151018 : }
151019 : #endif
151020 0 : p_decoratorList = decoratorList;
151021 0 : }
151022 :
151023 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151024 :
151025 :
151026 : // End of memberFunctionString
151027 : // Start of memberFunctionString
151028 :
151029 :
151030 : // End of memberFunctionString
151031 : // Start of memberFunctionString
151032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
151033 :
151034 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151035 :
151036 : bool
151037 84707 : SgClassDeclaration::get_isAutonomousDeclaration () const
151038 : {
151039 84707 : ROSE_ASSERT (this != NULL);
151040 :
151041 : #if 0
151042 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151043 : // used to trigger marking transformations for the token-based unparsing.
151044 : printf ("SgClassDeclaration::get_isAutonomousDeclaration = %p = %s \n",this,this->class_name().c_str());
151045 : #endif
151046 :
151047 84707 : return p_isAutonomousDeclaration;
151048 : }
151049 :
151050 : void
151051 29284 : SgClassDeclaration::set_isAutonomousDeclaration ( bool isAutonomousDeclaration )
151052 : {
151053 29284 : ROSE_ASSERT (this != NULL);
151054 :
151055 : #if 0
151056 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151057 : // used to trigger marking transformations for the token-based unparsing.
151058 : printf ("SgClassDeclaration::set_isAutonomousDeclaration = %p = %s \n",this,this->class_name().c_str());
151059 : #endif
151060 :
151061 29284 : set_isModified(true);
151062 :
151063 29284 : p_isAutonomousDeclaration = isAutonomousDeclaration;
151064 29284 : }
151065 :
151066 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151067 :
151068 :
151069 : // End of memberFunctionString
151070 : // Start of memberFunctionString
151071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
151072 :
151073 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151074 :
151075 : bool
151076 0 : SgClassDeclaration::get_isRepresentingTemplateParameterInTemplateDeclaration () const
151077 : {
151078 0 : ROSE_ASSERT (this != NULL);
151079 :
151080 : #if 0
151081 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151082 : // used to trigger marking transformations for the token-based unparsing.
151083 : printf ("SgClassDeclaration::get_isRepresentingTemplateParameterInTemplateDeclaration = %p = %s \n",this,this->class_name().c_str());
151084 : #endif
151085 :
151086 0 : return p_isRepresentingTemplateParameterInTemplateDeclaration;
151087 : }
151088 :
151089 : void
151090 0 : SgClassDeclaration::set_isRepresentingTemplateParameterInTemplateDeclaration ( bool isRepresentingTemplateParameterInTemplateDeclaration )
151091 : {
151092 0 : ROSE_ASSERT (this != NULL);
151093 :
151094 : #if 0
151095 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151096 : // used to trigger marking transformations for the token-based unparsing.
151097 : printf ("SgClassDeclaration::set_isRepresentingTemplateParameterInTemplateDeclaration = %p = %s \n",this,this->class_name().c_str());
151098 : #endif
151099 :
151100 0 : set_isModified(true);
151101 :
151102 0 : p_isRepresentingTemplateParameterInTemplateDeclaration = isRepresentingTemplateParameterInTemplateDeclaration;
151103 0 : }
151104 :
151105 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151106 :
151107 :
151108 : // End of memberFunctionString
151109 : // Start of memberFunctionString
151110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
151111 :
151112 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151113 :
151114 : SgBaseClass*
151115 0 : SgClassDeclaration::get_adaParentType () const
151116 : {
151117 0 : ROSE_ASSERT (this != NULL);
151118 :
151119 : #if 0
151120 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151121 : // used to trigger marking transformations for the token-based unparsing.
151122 : printf ("SgClassDeclaration::get_adaParentType = %p = %s \n",this,this->class_name().c_str());
151123 : #endif
151124 :
151125 0 : return p_adaParentType;
151126 : }
151127 :
151128 : void
151129 0 : SgClassDeclaration::set_adaParentType ( SgBaseClass* adaParentType )
151130 : {
151131 0 : ROSE_ASSERT (this != NULL);
151132 :
151133 : #if 0
151134 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151135 : // used to trigger marking transformations for the token-based unparsing.
151136 : printf ("SgClassDeclaration::set_adaParentType = %p = %s \n",this,this->class_name().c_str());
151137 : #endif
151138 :
151139 0 : set_isModified(true);
151140 :
151141 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
151142 : if (p_adaParentType != NULL && adaParentType != NULL && p_adaParentType != adaParentType)
151143 : {
151144 : printf ("Warning: adaParentType = %p overwriting valid pointer p_adaParentType = %p \n",adaParentType,p_adaParentType);
151145 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
151146 : printf ("Error fails assertion (p_adaParentType != NULL && adaParentType != NULL && p_adaParentType != adaParentType) is false\n");
151147 : ROSE_ASSERT(false);
151148 : #endif
151149 : }
151150 : #endif
151151 0 : p_adaParentType = adaParentType;
151152 0 : }
151153 :
151154 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151155 :
151156 :
151157 : // End of memberFunctionString
151158 : // Start of memberFunctionString
151159 : /* #line 13407 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
151160 :
151161 :
151162 : void
151163 37159 : SgClassDeclaration::post_construction_initialization()
151164 : {
151165 : // DQ (9/27/2004): This function should not modify the existing SgType which
151166 : // in some cases is shared with other IR nodes within Sage III. This is a bug
151167 : // which effects the handling of defining vs. non-defining declarations.
151168 : #if 0
151169 : if (get_type())
151170 : get_type()->set_declaration(this);
151171 : else
151172 : set_type(SgClassType::createType(this));
151173 : #else
151174 : // Only build a type if one does not exist
151175 : // Liao, 10/30/2009. We should not create SgClassType during constructing
151176 : // Since only the first nondefining class declaration should have a dedicated SgClassType node
151177 : // the defining class declaration (and other nondefining declaration) just shared that SgClassType.
151178 : // The constructor does not know if a defining or nondefining declaration is being built
151179 : // so we have to let users to create SgClassType by themselves after calling the constructor
151180 : // This will ultimately avoid duplicated SgClassType nodes in the AST
151181 : #if 0
151182 : if (get_type() == NULL)
151183 : {
151184 : #if 0
151185 : #if PRINT_DEVELOPER_WARNINGS
151186 : printf ("In SgClassDeclaration::post_construction_initialization(): generating the SgClassType internally (from the declaration) \n");
151187 : #endif
151188 : #endif
151189 : set_type(SgClassType::createType(this));
151190 : }
151191 : #endif
151192 :
151193 : #endif
151194 :
151195 : #if 0
151196 : // DQ (3/4/2018): relax this requirement for SgTemplateInstantiationClassDeclaration.
151197 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
151198 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
151199 : if (p_type != NULL)
151200 : {
151201 : printf ("Note: SgClassDeclaration::post_construction_initialization(): p_type != NULL: name = %s \n",p_name.str());
151202 : }
151203 : // ROSE_ASSERT(p_type == NULL);
151204 : #endif
151205 :
151206 : #if 0
151207 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
151208 : printf ("In SgClassDeclaration::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
151209 : #endif
151210 37159 : }
151211 :
151212 : // SgStatement *get_first() const;
151213 :
151214 : bool
151215 0 : SgClassDeclaration::replace_child(SgStatement *target,SgStatement *newstmt,
151216 : bool extractBasicBlock)
151217 : {
151218 0 : return false;
151219 : }
151220 :
151221 : SgName
151222 6356 : SgClassDeclaration::get_qualified_name() const
151223 : {
151224 : //! \todo Find out why qualified name generation requires a special case for unions.
151225 :
151226 : // DQ (9/27/2004): This function calls get_scope() which uses the parent pointers, thus
151227 : // it should not be called before the parent pointers are set (within the AST fixup after
151228 : // the Sage III AST is fully constructed).
151229 :
151230 : // printf ("In SgClassDeclaration::get_qualified_name() name = %s isUnion = %s \n",get_name().str(),(isUnion == true) ? "true" : "false") ;
151231 :
151232 6356 : SgName returnName;
151233 :
151234 : #if 1
151235 : // DQ (6/3/2006): I think we should handle unions uniformly with structs and classes.
151236 6356 : SgScopeStatement* scope = get_scope();
151237 6356 : ROSE_ASSERT(scope != NULL);
151238 6356 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
151239 : #else
151240 : // Ignore case of a union (why?)
151241 : bool isUnion = (get_class_type() == SgClassDeclaration::e_union);
151242 :
151243 : if (isUnion == true)
151244 : {
151245 : // DQ (8/28/2005): I'm not clear on why this is handles as a special case!
151246 : printf ("In SgClassDeclaration::get_qualified_name(): Special case of union, does not include scope information! \n");
151247 : returnName = get_name();
151248 : }
151249 : else
151250 : {
151251 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
151252 : SgScopeStatement* scope = get_scope();
151253 : ROSE_ASSERT(scope != NULL);
151254 :
151255 : // ROSE_ASSERT(get_name().is_null() == false);
151256 :
151257 : // returnName = scope->get_qualified_name() << "::" << get_name().str();
151258 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
151259 : }
151260 : #endif
151261 :
151262 : // printf ("In SgClassDeclaration::get_qualified_name() returnName = %s \n",returnName.str());
151263 :
151264 : // ROSE_ASSERT(returnName.is_null() == false);
151265 :
151266 6356 : return returnName;
151267 : }
151268 :
151269 : #define DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME 0
151270 :
151271 : // RV (1/31/2006): Added mangler for class declarations.
151272 : SgName
151273 253427 : SgClassDeclaration::get_mangled_name(void) const
151274 : {
151275 : #if 0
151276 : // return joinMangledQualifiers (mangleQualifiers(get_scope()),get_name());
151277 :
151278 : SgName name = get_name();
151279 :
151280 : // DQ (2/8/2007): See the note in the SgEnumDeclaration::get_mangled_name() function.
151281 : bool specialCaseNameHandling = (name.getString().find("__rose_generated_structure_tag_name_") != std::string::npos);
151282 :
151283 : // Now that we reset empty name this should be true (unless fixup had not been called)
151284 : // ROSE_ASSERT (name.is_null() == false);
151285 :
151286 : // DQ (6/1/2006): Added special handling for case where the class name is empty as in an
151287 : // printf ("In SgClassDeclaration::get_mangled_name(void): get_scope() = %p = %s \n",get_scope(),get_scope()->class_name().c_str());
151288 : // if (name.is_null() == true)
151289 :
151290 : // DQ (2/22/2007): I think that we don't use this sort of name internally any more!
151291 : // We generate more comlex names approporate to support the AST merge mechanism.
151292 : ROSE_ASSERT(specialCaseNameHandling == false);
151293 :
151294 : return joinMangledQualifiers (mangleQualifiers(get_scope()),name);
151295 : #else
151296 : #if 0
151297 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
151298 : SgClassDeclaration* classDeclaration = const_cast<SgClassDeclaration*>(this);
151299 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(classDeclaration);
151300 : if (i != p_globalMangledNameMap.end())
151301 : {
151302 : return i->second.c_str();
151303 : }
151304 : #endif
151305 :
151306 506854 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgClassDeclaration*>(this));
151307 253427 : if (mangledNameString.empty() == false)
151308 : {
151309 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151310 : printf ("In SgClassDeclaration::get_mangled_name(): (FOUND in cache) mangledNameString = %s \n",mangledNameString.c_str());
151311 : #endif
151312 229611 : return mangledNameString;
151313 : }
151314 : else
151315 : {
151316 : // DQ (3/14/2012): Make sure that this is a valid pointer else it might explain why qualification is not being use to generate the mangled names.
151317 23816 : ROSE_ASSERT(get_scope() != NULL);
151318 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151319 : printf ("In SgClassDeclaration::get_mangled_name(): calling joinMangledQualifiers(mangleQualifiers(get_scope()),get_name()) --- get_name() = %s \n",get_name().str());
151320 : #endif
151321 : // DQ (3/14/2012): Seperating the steps to computing the mangled name (which should include some qualification via non empty mangledScopeName)
151322 : // SgName mangledName = joinMangledQualifiers(mangleQualifiers(get_scope()),get_name());
151323 47632 : SgName mangledScopeName = mangleQualifiers(get_scope());
151324 :
151325 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151326 : printf ("In SgClassDeclaration::get_mangled_name(): mangleQualifiers(get_scope()) mangledScopeName = %s \n",mangledScopeName.str());
151327 : #endif
151328 : // DQ (3/14/2012): I think that we can assert this. No, if the scope is SgGlobal (for example) then the mangledName is empty.
151329 : // ROSE_ASSERT(mangledScopeName.is_null() == false);
151330 :
151331 : // DQ (9/6/2016): We require a prefix to the name to avoid name collisions (see test2005_199.C and simplified test (but non-failing) in test2016_60.C).
151332 : // SgName mangledName = joinMangledQualifiers(mangledScopeName,get_name());
151333 71448 : SgName prefixed_name = "class_" + get_name();
151334 23816 : SgName mangledName = joinMangledQualifiers(mangledScopeName,prefixed_name);
151335 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151336 : printf ("In SgClassDeclaration::get_mangled_name(): (NOT found in cache) mangledName = %s \n",mangledName.str());
151337 : #endif
151338 23816 : if (mangledName.is_null() == true)
151339 : {
151340 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151341 : printf ("In SgClassDeclaration::get_mangled_name(): (NOT found in cache) mangledName = %s get_name() = %s \n",mangledName.str(),get_name().str());
151342 : #endif
151343 0 : mangledName = "unknown_scope_and_name";
151344 : }
151345 23816 : ROSE_ASSERT(mangledName.is_null() == false);
151346 :
151347 : #if 0
151348 : // DQ (6/23/2010): Added support to make classes with the same name different when they are
151349 : // different classes containing different members.
151350 : SgName memberNames = "_class_members_";
151351 : if (get_definition() != NULL)
151352 : {
151353 : SgDeclarationStatementPtrList::const_iterator p = get_definition()->get_members().begin();
151354 : while ( p != get_definition()->get_members().end() )
151355 : {
151356 : // DQ (2/22/2007): Added type to generated mangled name for each variable (supports AST merge generation of name for un-named classes)
151357 : // memberNames += SgName("_member_type_") + (*p)->get_type()->get_mangled() + SgName("_member_name_") + (*p)->get_mangled_name();
151358 : memberNames += SgName("_member_name_") + SageInterface::get_name(*p);
151359 :
151360 : p++;
151361 : }
151362 : }
151363 :
151364 : mangledName += memberNames;
151365 : #endif
151366 : // p_globalMangledNameMap[classDeclaration] = mangledName;
151367 42030 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgClassDeclaration*>(this),mangledName);
151368 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151369 : printf ("In SgClassDeclaration::get_mangled_name(): (AFTER adding to cache) mangledName = %s \n",mangledName.str());
151370 : #endif
151371 : // DQ (5/31/2012): Added test for template brackets that are caught later in AstConsistencyTests.
151372 : // Make sure that there is no template specific syntax included in the mangled name
151373 47632 : string mangled_name = mangledName;
151374 23816 : if ( mangled_name.find('<') != string::npos )
151375 : {
151376 0 : printf ("In mangleQualifiersToString(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
151377 : }
151378 23816 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
151379 :
151380 : #if DEBUG_CLASS_DECLARATION_GET_MANGLED_NAME
151381 : // DQ (7/24/2012): Output the mangled name being generated for debugging.
151382 : printf ("In SgClassDeclaration::get_mangled_name(): returning mangledName = %s \n",mangledName.str());
151383 : #endif
151384 :
151385 23816 : return mangledName;
151386 : }
151387 : #endif
151388 : }
151389 :
151390 : SgName
151391 0 : SgClassDeclaration::get_mangled_qualified_name ( int & cnt )
151392 : {
151393 : // This function is called during the construction of the SAGE AST. As a result
151394 : // it currently represents a dependence of the parent pointer.
151395 :
151396 : // Make sure that parents have been set already
151397 : // (assume this means that all parents have been set)
151398 : // ROSE_ASSERT (get_parent() != NULL);
151399 : // ROSE_ASSERT (get_parent() == NULL);
151400 :
151401 0 : SgName nm;
151402 :
151403 : // if(isSgClassDefinition(get_parent()))
151404 0 : SgNode* parentNode = get_parent();
151405 0 : SgClassDefinition* parentDefinition = isSgClassDefinition(parentNode);
151406 0 : if (parentDefinition != NULL)
151407 : {
151408 : // nm = (isSgClassDefinition(get_parent())->get_mangled_qualified_name(cnt));
151409 0 : nm = (parentDefinition->get_mangled_qualified_name(cnt));
151410 : // printf ("In SgClassDeclaration::get_mangled_qualified_name(): nm = %s \n",nm.str());
151411 : }
151412 0 : cnt++;
151413 :
151414 : // DQ (4/28/2005):
151415 : // nm << strlen(get_name().str());
151416 : // nm << get_name().str();
151417 :
151418 0 : const SgTemplateInstantiationDecl* templateClassDeclaration = isSgTemplateInstantiationDecl(this);
151419 0 : if (templateClassDeclaration != NULL)
151420 : {
151421 : // Need to remove " < " and " > " from template name so that can support name mangling
151422 : // SgName className = "_"; // Avoid leading character being a number
151423 0 : SgName className;
151424 0 : className << get_name().getString().size();
151425 0 : className += get_name();
151426 0 : nm << fixupTemplateNameForMangledNameSupport(className).str();
151427 : }
151428 : else
151429 : {
151430 0 : nm << get_name().getString().size();
151431 0 : nm << get_name().str();
151432 : }
151433 :
151434 : #if 0
151435 : if (parentDefinition != NULL)
151436 : {
151437 : // printf ("In SgClassDeclaration::get_mangled_qualified_name(cnt = %d) nm = %s \n",cnt-1,nm.str());
151438 : // get_file_info()->display("Called from SgClassDeclaration::get_mangled_qualified_name()");
151439 : }
151440 : #endif
151441 :
151442 0 : return nm;
151443 : }
151444 :
151445 : bool
151446 593526 : SgClassDeclaration::hasExplicitScope() const
151447 : {
151448 : // This function reports that this IR node stores its scope explicitly.
151449 :
151450 593526 : return true;
151451 : }
151452 :
151453 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
151454 : SgSymbol*
151455 64226 : SgClassDeclaration::get_symbol_from_symbol_table() const
151456 : {
151457 64226 : ROSE_ASSERT(get_scope() != NULL);
151458 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
151459 : // return get_scope()->get_symbol_table()->find(this);
151460 64226 : return get_scope()->find_symbol_from_declaration(this);
151461 : }
151462 :
151463 : // GB (09/26/2007): Added this function as part of the move to index-based traversals: We only want the definition to be
151464 : // a traversal successor if isForward is false. This used to be handled in the AstSuccessorsSelectors code, but now it
151465 : // is isolated in this function (which is used by the traversal code generated by ROSETTA).
151466 : SgClassDefinition *
151467 1250800 : SgClassDeclaration::compute_classDefinition() const
151468 : {
151469 1250800 : if (isForward())
151470 : {
151471 : return NULL;
151472 : }
151473 : else
151474 : {
151475 913663 : return p_definition;
151476 : }
151477 : }
151478 :
151479 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
151480 : // so that we could avoid them setting the isModified flag which is a problem in the
151481 : // name qualification support for C++ (interfering with the token-based unparsing).
151482 : int
151483 0 : SgClassDeclaration::get_name_qualification_length () const
151484 : {
151485 0 : ROSE_ASSERT (this != NULL);
151486 0 : return p_name_qualification_length;
151487 : }
151488 :
151489 : void
151490 17597 : SgClassDeclaration::set_name_qualification_length ( int name_qualification_length )
151491 : {
151492 17597 : ROSE_ASSERT (this != NULL);
151493 : // This can't be called by the name qualification API (see test2015_26.C).
151494 : // set_isModified(true);
151495 :
151496 17597 : p_name_qualification_length = name_qualification_length;
151497 17597 : }
151498 :
151499 : bool
151500 0 : SgClassDeclaration::get_type_elaboration_required () const
151501 : {
151502 0 : ROSE_ASSERT (this != NULL);
151503 0 : return p_type_elaboration_required;
151504 : }
151505 :
151506 : void
151507 17597 : SgClassDeclaration::set_type_elaboration_required ( bool type_elaboration_required )
151508 : {
151509 17597 : ROSE_ASSERT (this != NULL);
151510 : // This can't be called by the name qualification API (see test2015_26.C).
151511 : // set_isModified(true);
151512 :
151513 17597 : p_type_elaboration_required = type_elaboration_required;
151514 17597 : }
151515 :
151516 : bool
151517 0 : SgClassDeclaration::get_global_qualification_required () const
151518 : {
151519 0 : ROSE_ASSERT (this != NULL);
151520 0 : return p_global_qualification_required;
151521 : }
151522 :
151523 : void
151524 17597 : SgClassDeclaration::set_global_qualification_required ( bool global_qualification_required )
151525 : {
151526 17597 : ROSE_ASSERT (this != NULL);
151527 :
151528 : // This can't be called by the name qualification API (see test2015_26.C).
151529 : // set_isModified(true);
151530 :
151531 17597 : p_global_qualification_required = global_qualification_required;
151532 17597 : }
151533 :
151534 :
151535 :
151536 : // End of memberFunctionString
151537 : // Start of memberFunctionString
151538 : /* #line 9727 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
151539 :
151540 :
151541 : bool
151542 0 : SgClassDeclaration::isSpecialization() const
151543 : {
151544 0 : bool returnValue = false;
151545 0 : returnValue = (p_specialization == SgDeclarationStatement::e_specialization);
151546 0 : return returnValue;
151547 : }
151548 :
151549 : bool
151550 0 : SgClassDeclaration::isPartialSpecialization() const
151551 : {
151552 0 : bool returnValue = false;
151553 0 : returnValue = (p_specialization == SgDeclarationStatement::e_partial_specialization);
151554 0 : return returnValue;
151555 : }
151556 :
151557 :
151558 :
151559 : // End of memberFunctionString
151560 : // Start of memberFunctionString
151561 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
151562 :
151563 : // *** COMMON CODE SECTION BEGINS HERE ***
151564 :
151565 : #if 0
151566 : int
151567 : SgClassDeclaration::getVariant() const
151568 : {
151569 : // This function is used in ROSE while "variant()" is used in SAGE
151570 : assert(this != NULL);
151571 : return variant();
151572 : }
151573 : #endif
151574 :
151575 : // This function is used in ROSE in treeTraversal code
151576 : // eventually replaces getVariant() and variant()
151577 : // though after variant() has been removed for a while we will
151578 : // want to change the name of variantT() back to variant()
151579 : // (since the "T" was ment to stand for temporary).
151580 : // When this happens the variantT() will be depricated.
151581 : VariantT
151582 5921050 : SgClassDeclaration::variantT() const
151583 : {
151584 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
151585 5921050 : ROSE_ASSERT(this != NULL);
151586 5921050 : return V_SgClassDeclaration;
151587 : }
151588 :
151589 : #if 0
151590 : int
151591 : SgClassDeclaration::variant() const
151592 : {
151593 : // This function is used in SAGE
151594 : ROSE_ASSERT(this != NULL);
151595 : return CLASS_DECL_STMT;
151596 : }
151597 : #endif
151598 :
151599 : ROSE_DLL_API const char*
151600 72 : SgClassDeclaration::sage_class_name() const
151601 : {
151602 72 : ROSE_ASSERT(this != NULL);
151603 72 : return "SgClassDeclaration";
151604 : }
151605 :
151606 : std::string
151607 25797 : SgClassDeclaration::class_name() const
151608 : {
151609 25797 : ROSE_ASSERT(this != NULL);
151610 25797 : return "SgClassDeclaration";
151611 : }
151612 :
151613 : // DQ (11/26/2005): Support for visitor pattern mechanims
151614 : // (inferior to ROSE traversal mechanism, experimental).
151615 : void
151616 48819 : SgClassDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
151617 : {
151618 48819 : ROSE_ASSERT(this != NULL);
151619 48819 : visitor.visit(this);
151620 48819 : }
151621 :
151622 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
151623 0 : void SgClassDeclaration::accept (ROSE_VisitorPattern & visitor) {
151624 0 : ROSE_ASSERT(this != NULL);
151625 0 : visitor.visit(this);
151626 0 : }
151627 :
151628 : SgClassDeclaration*
151629 0 : SgClassDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
151630 : {
151631 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
151632 : // This function is currently only supported for the AST used the represent Binary executables.
151633 : if (0 /* isSgAsmNode(this) != NULL */)
151634 : {
151635 : // Support for regex specification.
151636 : std::string prefixCode = "REGEX:";
151637 : addNewAttribute(prefixCode + s,a);
151638 : }
151639 : #endif
151640 :
151641 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
151642 0 : return this;
151643 : }
151644 :
151645 : // *** COMMON CODE SECTION ENDS HERE ***
151646 :
151647 :
151648 : // End of memberFunctionString
151649 : // Start of memberFunctionString
151650 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
151651 :
151652 :
151653 : #if 0
151654 : //! Error checking support
151655 : /*! Verifies the following:
151656 : - working getVariant() member function
151657 : - calls base class's error() member function
151658 : Every class has one of these functions.
151659 : */
151660 : bool
151661 : SgClassDeclaration::error()
151662 : {
151663 : // Put error checking here
151664 :
151665 : ROSE_ASSERT (this != NULL);
151666 : if (getVariant() != CLASS_DECL_STMT)
151667 : {
151668 : printf ("Error in SgClassDeclaration::error(): SgClassDeclaration object has a %s variant \n",
151669 : Cxx_GrammarTerminalNames[getVariant()].name);
151670 : // printf ("Error in SgClassDeclaration::error() \n");
151671 : ROSE_ABORT();
151672 : }
151673 :
151674 : ROSE_ASSERT (getVariant() == CLASS_DECL_STMT);
151675 : return SgDeclarationStatement::error();
151676 : }
151677 : #endif
151678 :
151679 :
151680 :
151681 : // End of memberFunctionString
151682 :
151683 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
151684 :
151685 34297400 : SgClassDeclaration* isSgClassDeclaration ( SgNode* inputDerivedClassPointer )
151686 : {
151687 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
151688 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
151689 : // So to fix this we return NULL directly when the input is NULL and avoid the
151690 : // dynamic_cast in this case. This is likely a performance improvement as well.
151691 : // return dynamic_cast<SgClassDeclaration*>(inputDerivedClassPointer);
151692 : // Milind Chabbi (8/28/2013): isSgClassDeclaration uses table-driven castability instead of c++ default dynamic_cast
151693 : // this improves the running time performance by 10-20%.
151694 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassDeclaration*>(inputDerivedClassPointer);
151695 34297400 : return IS_SgClassDeclaration_FAST_MACRO(inputDerivedClassPointer);
151696 : }
151697 :
151698 : // DQ (11/8/2003): Added version of functions taking const pointer
151699 39470 : const SgClassDeclaration* isSgClassDeclaration ( const SgNode* inputDerivedClassPointer )
151700 : {
151701 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
151702 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
151703 : // So to fix this we return NULL directly when the input is NULL and avoid the
151704 : // dynamic_cast in this case. This is likely a performance improvement as well.
151705 : // return dynamic_cast<const SgClassDeclaration*>(inputDerivedClassPointer);
151706 : // Milind Chabbi (8/28/2013): isSgClassDeclaration uses table-driven castability instead of c++ default dynamic_cast
151707 : // this improves the running time performance by 10-20%.
151708 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassDeclaration*>(inputDerivedClassPointer);
151709 39470 : return IS_SgClassDeclaration_FAST_MACRO(inputDerivedClassPointer);
151710 : }
151711 :
151712 :
151713 :
151714 : /* #line 151715 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
151715 :
151716 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
151717 :
151718 : /**
151719 : \brief Generated destructor
151720 :
151721 : This destructor is automatically generated (by ROSETTA). This destructor
151722 : only frees memory of data members associated with the parts of the current IR node which
151723 : are NOT traversed. Those data members that are part of a traversal can be freed using
151724 : a traversal (calling this destructor on all children in a post-order traversal). Such
151725 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
151726 :
151727 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
151728 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
151729 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
151730 :
151731 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
151732 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
151733 : pointers are not yet implemented to call delete on eash pointer in the container.
151734 : (This could be done by derivation from the STL containers to define containers that
151735 : automatically deleted their members.)
151736 :
151737 : */
151738 6302 : SgClassDeclaration::~SgClassDeclaration () {
151739 5560 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
151740 :
151741 :
151742 : // case: not a listType for name
151743 5560 : p_name = ""; // non list case
151744 : // case: not a listType for class_type
151745 5560 : p_class_type = SgClassDeclaration::e_class; // non list case
151746 : // case: not a listType for type
151747 5560 : p_type = NULL; // non list case
151748 : // case: not a listType for definition
151749 5560 : p_definition = NULL; // non list case
151750 : // case: not a listType for scope
151751 5560 : p_scope = NULL; // non list case
151752 : // case: not a listType for specialization
151753 5560 : p_specialization = SgDeclarationStatement::e_no_specialization; // non list case
151754 : // case: not a listType for from_template
151755 5560 : p_from_template = false; // non list case
151756 : // case: not a listType for fixupScope
151757 5560 : p_fixupScope = false; // non list case
151758 : // case: not a listType for isUnNamed
151759 5560 : p_isUnNamed = false; // non list case
151760 : // case: not a listType for explicit_annotation_interface
151761 5560 : p_explicit_annotation_interface = false; // non list case
151762 : // case: not a listType for explicit_interface
151763 5560 : p_explicit_interface = false; // non list case
151764 : // case: not a listType for explicit_enum
151765 5560 : p_explicit_enum = false; // non list case
151766 : // case: not a listType for explicit_anonymous
151767 5560 : p_explicit_anonymous = false; // non list case
151768 : // case: not a listType for decoratorList
151769 5560 : p_decoratorList = NULL; // non list case
151770 : // case: not a listType for name_qualification_length
151771 5560 : p_name_qualification_length = 0; // non list case
151772 : // case: not a listType for type_elaboration_required
151773 5560 : p_type_elaboration_required = false; // non list case
151774 : // case: not a listType for global_qualification_required
151775 5560 : p_global_qualification_required = false; // non list case
151776 : // case: not a listType for isAutonomousDeclaration
151777 5560 : p_isAutonomousDeclaration = true; // non list case
151778 : // case: not a listType for isRepresentingTemplateParameterInTemplateDeclaration
151779 5560 : p_isRepresentingTemplateParameterInTemplateDeclaration = false; // non list case
151780 : // case: not a listType for adaParentType
151781 5560 : p_adaParentType = NULL; // non list case
151782 :
151783 : }
151784 :
151785 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
151786 6302 : }
151787 :
151788 :
151789 : /* #line 151790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
151790 :
151791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
151792 :
151793 : // Generated constructor
151794 0 : SgClassDeclaration::SgClassDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition )
151795 0 : : SgDeclarationStatement(startOfConstruct)
151796 : {
151797 : #ifdef DEBUG
151798 : // printf ("In SgClassDeclaration::SgClassDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition) sage_class_name() = %s \n",sage_class_name());
151799 : #endif
151800 : #if 0
151801 : // debugging information!
151802 : printf ("In SgClassDeclaration::SgClassDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
151803 : #endif
151804 :
151805 0 : p_name = name;
151806 0 : p_class_type = class_type;
151807 0 : p_type = type;
151808 0 : p_definition = definition;
151809 0 : p_scope = NULL;
151810 0 : p_specialization = SgDeclarationStatement::e_no_specialization;
151811 0 : p_from_template = false;
151812 0 : p_fixupScope = false;
151813 0 : p_isUnNamed = false;
151814 0 : p_explicit_annotation_interface = false;
151815 0 : p_explicit_interface = false;
151816 0 : p_explicit_enum = false;
151817 0 : p_explicit_anonymous = false;
151818 0 : p_decoratorList = NULL;
151819 0 : p_name_qualification_length = 0;
151820 0 : p_type_elaboration_required = false;
151821 0 : p_global_qualification_required = false;
151822 0 : p_isAutonomousDeclaration = true;
151823 0 : p_isRepresentingTemplateParameterInTemplateDeclaration = false;
151824 0 : p_adaParentType = NULL;
151825 :
151826 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
151827 :
151828 : #if 0
151829 : // DQ (7/30/2014): Call a virtual function.
151830 : std::string s = this->class_name();
151831 : #endif
151832 :
151833 : // Test the variant virtual function
151834 : // assert(CLASS_DECL_STMT == variant());
151835 0 : assert(CLASS_DECL_STMT == this->variant());
151836 0 : ROSE_ASSERT(CLASS_DECL_STMT == (int)(this->variantT()));
151837 0 : post_construction_initialization();
151838 :
151839 : // Test the isSgClassDeclaration() function since it has been problematic
151840 0 : assert(isSgClassDeclaration(this) != NULL);
151841 0 : }
151842 :
151843 : // Generated constructor (all data members)
151844 :
151845 : /* #line 151846 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
151846 :
151847 :
151848 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
151849 :
151850 :
151851 : // ********************************************************
151852 : // member functions common across all array grammar objects
151853 : // ********************************************************
151854 :
151855 :
151856 :
151857 : /* #line 151858 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
151858 :
151859 :
151860 :
151861 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
151862 :
151863 : // ********************************************************
151864 : // member functions specific to each node in the grammar
151865 : // ********************************************************
151866 :
151867 :
151868 : /* #line 151869 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
151869 :
151870 : // Start of memberFunctionString
151871 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
151872 :
151873 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151874 :
151875 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
151876 : const SgTemplateParameterPtrList &
151877 0 : SgTemplateClassDeclaration::get_templateParameters () const
151878 : {
151879 0 : assert (this != NULL);
151880 0 : return p_templateParameters;
151881 : }
151882 :
151883 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
151884 : SgTemplateParameterPtrList &
151885 151571 : SgTemplateClassDeclaration::get_templateParameters ()
151886 : {
151887 151571 : assert (this != NULL);
151888 :
151889 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
151890 : // As a rule only set_ access functions can set the isModified flag.
151891 : // set_isModified(true);
151892 :
151893 151571 : return p_templateParameters;
151894 : }
151895 :
151896 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151897 :
151898 :
151899 : // End of memberFunctionString
151900 : // Start of memberFunctionString
151901 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
151902 :
151903 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151904 :
151905 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
151906 : const SgTemplateArgumentPtrList &
151907 16525 : SgTemplateClassDeclaration::get_templateSpecializationArguments () const
151908 : {
151909 16525 : assert (this != NULL);
151910 16525 : return p_templateSpecializationArguments;
151911 : }
151912 :
151913 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
151914 : SgTemplateArgumentPtrList &
151915 134420 : SgTemplateClassDeclaration::get_templateSpecializationArguments ()
151916 : {
151917 134420 : assert (this != NULL);
151918 :
151919 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
151920 : // As a rule only set_ access functions can set the isModified flag.
151921 : // set_isModified(true);
151922 :
151923 134420 : return p_templateSpecializationArguments;
151924 : }
151925 :
151926 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151927 :
151928 :
151929 : // End of memberFunctionString
151930 : // Start of memberFunctionString
151931 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
151932 :
151933 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151934 :
151935 : SgName
151936 326 : SgTemplateClassDeclaration::get_string () const
151937 : {
151938 326 : ROSE_ASSERT (this != NULL);
151939 :
151940 : #if 0
151941 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151942 : // used to trigger marking transformations for the token-based unparsing.
151943 : printf ("SgTemplateClassDeclaration::get_string = %p = %s \n",this,this->class_name().c_str());
151944 : #endif
151945 :
151946 326 : return p_string;
151947 : }
151948 :
151949 : void
151950 5976 : SgTemplateClassDeclaration::set_string ( SgName string )
151951 : {
151952 5976 : ROSE_ASSERT (this != NULL);
151953 :
151954 : #if 0
151955 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151956 : // used to trigger marking transformations for the token-based unparsing.
151957 : printf ("SgTemplateClassDeclaration::set_string = %p = %s \n",this,this->class_name().c_str());
151958 : #endif
151959 :
151960 5976 : set_isModified(true);
151961 :
151962 5976 : p_string = string;
151963 5976 : }
151964 :
151965 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
151966 :
151967 :
151968 : // End of memberFunctionString
151969 : // Start of memberFunctionString
151970 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
151971 :
151972 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
151973 :
151974 : SgName
151975 44319 : SgTemplateClassDeclaration::get_templateName () const
151976 : {
151977 44319 : ROSE_ASSERT (this != NULL);
151978 :
151979 : #if 0
151980 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151981 : // used to trigger marking transformations for the token-based unparsing.
151982 : printf ("SgTemplateClassDeclaration::get_templateName = %p = %s \n",this,this->class_name().c_str());
151983 : #endif
151984 :
151985 44319 : return p_templateName;
151986 : }
151987 :
151988 : void
151989 10558 : SgTemplateClassDeclaration::set_templateName ( SgName templateName )
151990 : {
151991 10558 : ROSE_ASSERT (this != NULL);
151992 :
151993 : #if 0
151994 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
151995 : // used to trigger marking transformations for the token-based unparsing.
151996 : printf ("SgTemplateClassDeclaration::set_templateName = %p = %s \n",this,this->class_name().c_str());
151997 : #endif
151998 :
151999 10558 : set_isModified(true);
152000 :
152001 10558 : p_templateName = templateName;
152002 10558 : }
152003 :
152004 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152005 :
152006 :
152007 : // End of memberFunctionString
152008 : // Start of memberFunctionString
152009 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
152010 :
152011 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
152012 :
152013 : SgDeclarationScope*
152014 6988 : SgTemplateClassDeclaration::get_nonreal_decl_scope () const
152015 : {
152016 6988 : ROSE_ASSERT (this != NULL);
152017 :
152018 : #if 0
152019 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152020 : // used to trigger marking transformations for the token-based unparsing.
152021 : printf ("SgTemplateClassDeclaration::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
152022 : #endif
152023 :
152024 6988 : return p_nonreal_decl_scope;
152025 : }
152026 :
152027 : void
152028 20696 : SgTemplateClassDeclaration::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
152029 : {
152030 20696 : ROSE_ASSERT (this != NULL);
152031 :
152032 : #if 0
152033 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152034 : // used to trigger marking transformations for the token-based unparsing.
152035 : printf ("SgTemplateClassDeclaration::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
152036 : #endif
152037 :
152038 20696 : set_isModified(true);
152039 :
152040 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
152041 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
152042 : {
152043 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
152044 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
152045 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
152046 : ROSE_ASSERT(false);
152047 : #endif
152048 : }
152049 : #endif
152050 20696 : p_nonreal_decl_scope = nonreal_decl_scope;
152051 20696 : }
152052 :
152053 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152054 :
152055 :
152056 : // End of memberFunctionString
152057 : // Start of memberFunctionString
152058 : /* #line 16676 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
152059 :
152060 : void
152061 10558 : SgTemplateClassDeclaration::post_construction_initialization()
152062 : {
152063 : // DQ (12/21/2011): This is not what we want for the newer design with SgTemplateVariableDeclaration derived from SgVariableDeclaration.
152064 : // this->set_template_kind(e_template_class);
152065 :
152066 : #if 0
152067 : // DQ (3/4/2018): relax this requirement for SgTemplateInstantiationClassDeclaration.
152068 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
152069 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
152070 : if (p_type != NULL)
152071 : {
152072 : printf ("Note: SgTemplateClassDeclaration::post_construction_initialization(): p_type != NULL: name = %s \n",p_name.str());
152073 : }
152074 : // ROSE_ASSERT(p_type == NULL);
152075 : #endif
152076 10558 : }
152077 :
152078 : // DQ (9/10/2012): Added general name mangling for new template class declaration IR node.
152079 : SgName
152080 123680 : SgTemplateClassDeclaration::get_mangled_name(void) const
152081 : {
152082 247360 : string mangled_name;
152083 :
152084 : // DQ (2/13/2015): Fixing bug specific to adding mangle name of the scope of the template class to avoid collisions with other types
152085 : // with the same name in different scopes when used as in function types. The bud demonstrating this problem is in test2015_09.C and
152086 : // test2015_10.C. This problem was caught in the range.h header file for the GNU g++ version 4.8.1 header file system. This was
152087 : // an issue to the processing of the newest version of the LBL DSL specification.
152088 247360 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgTemplateClassDeclaration*>(this));
152089 123680 : if (mangledNameString.empty() == false)
152090 : {
152091 : #if 0
152092 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): (FOUND in cache) mangledNameString = %s \n",mangledNameString.c_str());
152093 : #endif
152094 107155 : return mangledNameString;
152095 : }
152096 : else
152097 : {
152098 : // DQ (3/14/2012): Make sure that this is a valid pointer else it might explain why qualification is not being use to generate the mangled names.
152099 16525 : ROSE_ASSERT(get_scope() != NULL);
152100 : #if 0
152101 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): calling joinMangledQualifiers(mangleQualifiers(get_scope()),get_name()) --- get_name() = %s \n",get_name().str());
152102 : #endif
152103 : // DQ (3/14/2012): Seperating the steps to computing the mangled name (which should include some qualification via non empty mangledScopeName)
152104 : // SgName mangledName = joinMangledQualifiers(mangleQualifiers(get_scope()),get_name());
152105 33050 : SgName mangledScopeName = mangleQualifiers(get_scope());
152106 : #if 0
152107 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): mangleQualifiers(get_scope()) mangledScopeName = %s \n",mangledScopeName.str());
152108 : #endif
152109 : // DQ (3/14/2012): I think that we can assert this. No, if the scope is SgGlobal (for example) then the mangledName is empty.
152110 : // ROSE_ASSERT(mangledScopeName.is_null() == false);
152111 :
152112 : // DQ (2/13/2015): Changed this to use the templateName which excludes the template arguments, I think this is enough to be unique.
152113 : // SgName mangledName = joinMangledQualifiers(mangledScopeName,get_name());
152114 33050 : SgName mangledName = joinMangledQualifiers(mangledScopeName,get_templateName());
152115 : #if 0
152116 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): (NOT found in cache) mangledName = %s \n",mangledName.str());
152117 : #endif
152118 16525 : if (mangledName.is_null() == true)
152119 : {
152120 : #if 0
152121 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): (NOT found in cache) mangledName = %s get_name() = %s \n",mangledName.str(),get_name().str());
152122 : #endif
152123 0 : mangledName = "unknown_scope_and_name";
152124 : }
152125 16525 : ROSE_ASSERT(mangledName.is_null() == false);
152126 :
152127 : // TODO add mangled template specialization arguments
152128 16525 : mangledName = mangleTemplate(mangledName,get_templateSpecializationArguments(),get_scope());
152129 :
152130 : // p_globalMangledNameMap[classDeclaration] = mangledName;
152131 16531 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgTemplateClassDeclaration*>(this),mangledName);
152132 : #if 0
152133 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): (AFTER adding to cache) mangledName = %s \n",mangledName.str());
152134 : #endif
152135 : // DQ (5/31/2012): Added test for template brackets that are caught later in AstConsistencyTests.
152136 : // Make sure that there is no template specific syntax included in the mangled name
152137 : // string mangled_name = mangledName;
152138 16525 : mangled_name = mangledName;
152139 16525 : if ( mangled_name.find('<') != string::npos )
152140 : {
152141 0 : printf ("In SgTemplateClassDeclaration::get_mangled_name(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
152142 : }
152143 16525 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
152144 : }
152145 : #if 0
152146 : // DQ (7/24/2012): Output the mangled name being generated for debugging.
152147 : printf (">>>>>>>>>> SgTemplateClassDeclaration::get_mangled_name(): returning mangled_name = %s \n",mangled_name.c_str());
152148 : #endif
152149 :
152150 16525 : return mangled_name;
152151 : }
152152 :
152153 :
152154 :
152155 : // End of memberFunctionString
152156 : // Start of memberFunctionString
152157 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
152158 :
152159 : // *** COMMON CODE SECTION BEGINS HERE ***
152160 :
152161 : #if 0
152162 : int
152163 : SgTemplateClassDeclaration::getVariant() const
152164 : {
152165 : // This function is used in ROSE while "variant()" is used in SAGE
152166 : assert(this != NULL);
152167 : return variant();
152168 : }
152169 : #endif
152170 :
152171 : // This function is used in ROSE in treeTraversal code
152172 : // eventually replaces getVariant() and variant()
152173 : // though after variant() has been removed for a while we will
152174 : // want to change the name of variantT() back to variant()
152175 : // (since the "T" was ment to stand for temporary).
152176 : // When this happens the variantT() will be depricated.
152177 : VariantT
152178 6403870 : SgTemplateClassDeclaration::variantT() const
152179 : {
152180 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
152181 6403870 : ROSE_ASSERT(this != NULL);
152182 6403870 : return V_SgTemplateClassDeclaration;
152183 : }
152184 :
152185 : #if 0
152186 : int
152187 : SgTemplateClassDeclaration::variant() const
152188 : {
152189 : // This function is used in SAGE
152190 : ROSE_ASSERT(this != NULL);
152191 : return TEMPLATE_CLASS_DECL_STMT;
152192 : }
152193 : #endif
152194 :
152195 : ROSE_DLL_API const char*
152196 11 : SgTemplateClassDeclaration::sage_class_name() const
152197 : {
152198 11 : ROSE_ASSERT(this != NULL);
152199 11 : return "SgTemplateClassDeclaration";
152200 : }
152201 :
152202 : std::string
152203 16093 : SgTemplateClassDeclaration::class_name() const
152204 : {
152205 16093 : ROSE_ASSERT(this != NULL);
152206 16093 : return "SgTemplateClassDeclaration";
152207 : }
152208 :
152209 : // DQ (11/26/2005): Support for visitor pattern mechanims
152210 : // (inferior to ROSE traversal mechanism, experimental).
152211 : void
152212 150086 : SgTemplateClassDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
152213 : {
152214 150086 : ROSE_ASSERT(this != NULL);
152215 150086 : visitor.visit(this);
152216 150086 : }
152217 :
152218 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
152219 0 : void SgTemplateClassDeclaration::accept (ROSE_VisitorPattern & visitor) {
152220 0 : ROSE_ASSERT(this != NULL);
152221 0 : visitor.visit(this);
152222 0 : }
152223 :
152224 : SgTemplateClassDeclaration*
152225 0 : SgTemplateClassDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
152226 : {
152227 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
152228 : // This function is currently only supported for the AST used the represent Binary executables.
152229 : if (0 /* isSgAsmNode(this) != NULL */)
152230 : {
152231 : // Support for regex specification.
152232 : std::string prefixCode = "REGEX:";
152233 : addNewAttribute(prefixCode + s,a);
152234 : }
152235 : #endif
152236 :
152237 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
152238 0 : return this;
152239 : }
152240 :
152241 : // *** COMMON CODE SECTION ENDS HERE ***
152242 :
152243 :
152244 : // End of memberFunctionString
152245 : // Start of memberFunctionString
152246 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
152247 :
152248 :
152249 : #if 0
152250 : //! Error checking support
152251 : /*! Verifies the following:
152252 : - working getVariant() member function
152253 : - calls base class's error() member function
152254 : Every class has one of these functions.
152255 : */
152256 : bool
152257 : SgTemplateClassDeclaration::error()
152258 : {
152259 : // Put error checking here
152260 :
152261 : ROSE_ASSERT (this != NULL);
152262 : if (getVariant() != TEMPLATE_CLASS_DECL_STMT)
152263 : {
152264 : printf ("Error in SgTemplateClassDeclaration::error(): SgTemplateClassDeclaration object has a %s variant \n",
152265 : Cxx_GrammarTerminalNames[getVariant()].name);
152266 : // printf ("Error in SgTemplateClassDeclaration::error() \n");
152267 : ROSE_ABORT();
152268 : }
152269 :
152270 : ROSE_ASSERT (getVariant() == TEMPLATE_CLASS_DECL_STMT);
152271 : return SgClassDeclaration::error();
152272 : }
152273 : #endif
152274 :
152275 :
152276 :
152277 : // End of memberFunctionString
152278 :
152279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
152280 :
152281 13392900 : SgTemplateClassDeclaration* isSgTemplateClassDeclaration ( SgNode* inputDerivedClassPointer )
152282 : {
152283 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
152284 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
152285 : // So to fix this we return NULL directly when the input is NULL and avoid the
152286 : // dynamic_cast in this case. This is likely a performance improvement as well.
152287 : // return dynamic_cast<SgTemplateClassDeclaration*>(inputDerivedClassPointer);
152288 : // Milind Chabbi (8/28/2013): isSgTemplateClassDeclaration uses table-driven castability instead of c++ default dynamic_cast
152289 : // this improves the running time performance by 10-20%.
152290 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateClassDeclaration*>(inputDerivedClassPointer);
152291 13392900 : return IS_SgTemplateClassDeclaration_FAST_MACRO(inputDerivedClassPointer);
152292 : }
152293 :
152294 : // DQ (11/8/2003): Added version of functions taking const pointer
152295 57556 : const SgTemplateClassDeclaration* isSgTemplateClassDeclaration ( const SgNode* inputDerivedClassPointer )
152296 : {
152297 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
152298 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
152299 : // So to fix this we return NULL directly when the input is NULL and avoid the
152300 : // dynamic_cast in this case. This is likely a performance improvement as well.
152301 : // return dynamic_cast<const SgTemplateClassDeclaration*>(inputDerivedClassPointer);
152302 : // Milind Chabbi (8/28/2013): isSgTemplateClassDeclaration uses table-driven castability instead of c++ default dynamic_cast
152303 : // this improves the running time performance by 10-20%.
152304 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateClassDeclaration*>(inputDerivedClassPointer);
152305 57556 : return IS_SgTemplateClassDeclaration_FAST_MACRO(inputDerivedClassPointer);
152306 : }
152307 :
152308 :
152309 :
152310 : /* #line 152311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
152311 :
152312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
152313 :
152314 : /**
152315 : \brief Generated destructor
152316 :
152317 : This destructor is automatically generated (by ROSETTA). This destructor
152318 : only frees memory of data members associated with the parts of the current IR node which
152319 : are NOT traversed. Those data members that are part of a traversal can be freed using
152320 : a traversal (calling this destructor on all children in a post-order traversal). Such
152321 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
152322 :
152323 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
152324 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
152325 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
152326 :
152327 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
152328 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
152329 : pointers are not yet implemented to call delete on eash pointer in the container.
152330 : (This could be done by derivation from the STL containers to define containers that
152331 : automatically deleted their members.)
152332 :
152333 : */
152334 7252 : SgTemplateClassDeclaration::~SgTemplateClassDeclaration () {
152335 2180 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
152336 :
152337 2180 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
152338 :
152339 : // case: listType for templateParameters
152340 : // case: listType (typeIsPointerToList == false) for templateParameters
152341 2180 : p_templateParameters.erase(p_templateParameters.begin(),p_templateParameters.end());
152342 : // case: listType for templateSpecializationArguments
152343 : // case: listType (typeIsPointerToList == false) for templateSpecializationArguments
152344 2180 : p_templateSpecializationArguments.erase(p_templateSpecializationArguments.begin(),p_templateSpecializationArguments.end());
152345 : // case: not a listType for string
152346 2180 : p_string = ""; // non list case
152347 : // case: not a listType for templateName
152348 2180 : p_templateName = ""; // non list case
152349 : // case: not a listType for nonreal_decl_scope
152350 2180 : p_nonreal_decl_scope = NULL; // non list case
152351 :
152352 : }
152353 :
152354 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
152355 4360 : }
152356 :
152357 :
152358 : /* #line 152359 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
152359 :
152360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
152361 :
152362 : // Generated constructor
152363 0 : SgTemplateClassDeclaration::SgTemplateClassDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition )
152364 0 : : SgClassDeclaration(startOfConstruct, name, class_type, type, definition)
152365 : {
152366 : #ifdef DEBUG
152367 : // printf ("In SgTemplateClassDeclaration::SgTemplateClassDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition) sage_class_name() = %s \n",sage_class_name());
152368 : #endif
152369 : #if 0
152370 : // debugging information!
152371 : printf ("In SgTemplateClassDeclaration::SgTemplateClassDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
152372 : #endif
152373 :
152374 0 : p_templateParameters = SgTemplateParameterPtrList();
152375 0 : p_templateSpecializationArguments = SgTemplateArgumentPtrList();
152376 0 : p_string = "";
152377 0 : p_templateName = "";
152378 0 : p_nonreal_decl_scope = NULL;
152379 :
152380 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
152381 :
152382 : #if 0
152383 : // DQ (7/30/2014): Call a virtual function.
152384 : std::string s = this->class_name();
152385 : #endif
152386 :
152387 : // Test the variant virtual function
152388 : // assert(TEMPLATE_CLASS_DECL_STMT == variant());
152389 0 : assert(TEMPLATE_CLASS_DECL_STMT == this->variant());
152390 0 : ROSE_ASSERT(TEMPLATE_CLASS_DECL_STMT == (int)(this->variantT()));
152391 0 : post_construction_initialization();
152392 :
152393 : // Test the isSgTemplateClassDeclaration() function since it has been problematic
152394 0 : assert(isSgTemplateClassDeclaration(this) != NULL);
152395 0 : }
152396 :
152397 : // Generated constructor (all data members)
152398 :
152399 : /* #line 152400 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
152400 :
152401 :
152402 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
152403 :
152404 :
152405 : // ********************************************************
152406 : // member functions common across all array grammar objects
152407 : // ********************************************************
152408 :
152409 :
152410 :
152411 : /* #line 152412 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
152412 :
152413 :
152414 :
152415 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
152416 :
152417 : // ********************************************************
152418 : // member functions specific to each node in the grammar
152419 : // ********************************************************
152420 :
152421 :
152422 : /* #line 152423 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
152423 :
152424 : // Start of memberFunctionString
152425 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
152426 :
152427 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
152428 :
152429 : SgName
152430 239842 : SgTemplateInstantiationDecl::get_templateName () const
152431 : {
152432 239842 : ROSE_ASSERT (this != NULL);
152433 :
152434 : #if 0
152435 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152436 : // used to trigger marking transformations for the token-based unparsing.
152437 : printf ("SgTemplateInstantiationDecl::get_templateName = %p = %s \n",this,this->class_name().c_str());
152438 : #endif
152439 :
152440 239842 : return p_templateName;
152441 : }
152442 :
152443 : void
152444 25902 : SgTemplateInstantiationDecl::set_templateName ( SgName templateName )
152445 : {
152446 25902 : ROSE_ASSERT (this != NULL);
152447 :
152448 : #if 0
152449 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152450 : // used to trigger marking transformations for the token-based unparsing.
152451 : printf ("SgTemplateInstantiationDecl::set_templateName = %p = %s \n",this,this->class_name().c_str());
152452 : #endif
152453 :
152454 25902 : set_isModified(true);
152455 :
152456 25902 : p_templateName = templateName;
152457 25902 : }
152458 :
152459 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152460 :
152461 :
152462 : // End of memberFunctionString
152463 : // Start of memberFunctionString
152464 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
152465 :
152466 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
152467 :
152468 : SgName
152469 0 : SgTemplateInstantiationDecl::get_templateHeader () const
152470 : {
152471 0 : ROSE_ASSERT (this != NULL);
152472 :
152473 : #if 0
152474 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152475 : // used to trigger marking transformations for the token-based unparsing.
152476 : printf ("SgTemplateInstantiationDecl::get_templateHeader = %p = %s \n",this,this->class_name().c_str());
152477 : #endif
152478 :
152479 0 : return p_templateHeader;
152480 : }
152481 :
152482 : void
152483 0 : SgTemplateInstantiationDecl::set_templateHeader ( SgName templateHeader )
152484 : {
152485 0 : ROSE_ASSERT (this != NULL);
152486 :
152487 : #if 0
152488 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152489 : // used to trigger marking transformations for the token-based unparsing.
152490 : printf ("SgTemplateInstantiationDecl::set_templateHeader = %p = %s \n",this,this->class_name().c_str());
152491 : #endif
152492 :
152493 0 : set_isModified(true);
152494 :
152495 0 : p_templateHeader = templateHeader;
152496 0 : }
152497 :
152498 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152499 :
152500 :
152501 : // End of memberFunctionString
152502 : // Start of memberFunctionString
152503 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
152504 :
152505 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
152506 :
152507 : SgTemplateClassDeclaration*
152508 62635 : SgTemplateInstantiationDecl::get_templateDeclaration () const
152509 : {
152510 62635 : ROSE_ASSERT (this != NULL);
152511 :
152512 : #if 0
152513 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152514 : // used to trigger marking transformations for the token-based unparsing.
152515 : printf ("SgTemplateInstantiationDecl::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
152516 : #endif
152517 :
152518 62635 : return p_templateDeclaration;
152519 : }
152520 :
152521 : void
152522 11843 : SgTemplateInstantiationDecl::set_templateDeclaration ( SgTemplateClassDeclaration* templateDeclaration )
152523 : {
152524 11843 : ROSE_ASSERT (this != NULL);
152525 :
152526 : #if 0
152527 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152528 : // used to trigger marking transformations for the token-based unparsing.
152529 : printf ("SgTemplateInstantiationDecl::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
152530 : #endif
152531 :
152532 11843 : set_isModified(true);
152533 :
152534 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
152535 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
152536 : {
152537 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
152538 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
152539 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
152540 : ROSE_ASSERT(false);
152541 : #endif
152542 : }
152543 : #endif
152544 11843 : p_templateDeclaration = templateDeclaration;
152545 11843 : }
152546 :
152547 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152548 :
152549 :
152550 : // End of memberFunctionString
152551 : // Start of memberFunctionString
152552 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
152553 :
152554 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
152555 :
152556 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
152557 : const SgTemplateArgumentPtrList &
152558 21080 : SgTemplateInstantiationDecl::get_templateArguments () const
152559 : {
152560 21080 : assert (this != NULL);
152561 21080 : return p_templateArguments;
152562 : }
152563 :
152564 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
152565 : SgTemplateArgumentPtrList &
152566 819120 : SgTemplateInstantiationDecl::get_templateArguments ()
152567 : {
152568 819120 : assert (this != NULL);
152569 :
152570 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
152571 : // As a rule only set_ access functions can set the isModified flag.
152572 : // set_isModified(true);
152573 :
152574 819120 : return p_templateArguments;
152575 : }
152576 :
152577 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152578 :
152579 :
152580 : // End of memberFunctionString
152581 : // Start of memberFunctionString
152582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
152583 :
152584 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
152585 :
152586 : bool
152587 422954 : SgTemplateInstantiationDecl::get_nameResetFromMangledForm () const
152588 : {
152589 422954 : ROSE_ASSERT (this != NULL);
152590 :
152591 : #if 0
152592 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152593 : // used to trigger marking transformations for the token-based unparsing.
152594 : printf ("SgTemplateInstantiationDecl::get_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
152595 : #endif
152596 :
152597 422954 : return p_nameResetFromMangledForm;
152598 : }
152599 :
152600 : void
152601 0 : SgTemplateInstantiationDecl::set_nameResetFromMangledForm ( bool nameResetFromMangledForm )
152602 : {
152603 0 : ROSE_ASSERT (this != NULL);
152604 :
152605 : #if 0
152606 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
152607 : // used to trigger marking transformations for the token-based unparsing.
152608 : printf ("SgTemplateInstantiationDecl::set_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
152609 : #endif
152610 :
152611 0 : set_isModified(true);
152612 :
152613 0 : p_nameResetFromMangledForm = nameResetFromMangledForm;
152614 0 : }
152615 :
152616 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
152617 :
152618 :
152619 : // End of memberFunctionString
152620 : // Start of memberFunctionString
152621 : /* #line 13998 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
152622 :
152623 : void
152624 11843 : SgTemplateInstantiationDecl::post_construction_initialization()
152625 : {
152626 : // DQ (9/27/2004): This function should not modify the existing SgType which
152627 : // in some cases is shared with other IR nodes within Sage III. This is a bug
152628 : // which effects the handling of defining vs. non-defining declarations.
152629 :
152630 : // printf ("p_templateArguments.size() = %" PRIuPTR " \n",p_templateArguments.size());
152631 :
152632 : // DQ (2/17/2007): Set the parents of all template arguments to the template instantiation
152633 : // JJW (8/6/2008): p_templateArguments is not a pointer anymore
152634 11843 : SgTemplateArgumentPtrList::iterator i = p_templateArguments.begin();
152635 11843 : while (i != p_templateArguments.end())
152636 : {
152637 0 : (*i)->set_parent(this);
152638 0 : i++;
152639 : }
152640 :
152641 : #if 0
152642 : // DQ (3/22/2012): Don't build the type here since we want it to share the type associated
152643 : // with the first nondefining declaration and we don't know which this is yet.
152644 : // defering the construction of the type makes this class's semantics the same as that for
152645 : // the SgClassDeclaration.
152646 :
152647 : // DQ (7/29/2010): Build the type after setting the template aruments.
152648 : if (get_type() == NULL)
152649 : {
152650 : set_type(SgClassType::createType(this));
152651 : }
152652 : #endif
152653 :
152654 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
152655 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
152656 : // ROSE_ASSERT(p_type == NULL);
152657 :
152658 : #if 0
152659 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
152660 : printf ("In SgTemplateInstantiationDecl::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
152661 : #endif
152662 11843 : }
152663 :
152664 : SgName
152665 13483 : SgTemplateInstantiationDecl::get_qualified_name() const
152666 : {
152667 : // This is a function called after the parents have been set. It is not called by the
152668 : // EDG/SAGE interface and is only called after the SAGE AST has been built and the parent
152669 : // pointers set within a separate phase.
152670 :
152671 : // Some error checking!
152672 :
152673 : // DQ (2/29/2012): Commented out because I think we use the scope pointer now, instead of the parent pointer.
152674 : // printf ("In SgTemplateInstantiationDecl::get_qualified_name(): Commented out test of parent this->get_parent() = %p \n",this->get_parent());
152675 : // ROSE_ASSERT (get_parent() != NULL);
152676 :
152677 : // DQ (11/23/2004): This name should have been reset already (before it is used here)
152678 13483 : if (get_nameResetFromMangledForm() == false)
152679 : {
152680 : // DQ (6/26/2005): It is OK for the EDG/Sage III translation to reference the qualified names
152681 : // even before the names are properly set! As long as we consistently return EDG uniquely generated
152682 : // names. This will allow the symbols to be built and shared, but afterward the symbols will have
152683 : // be in the wrong position in the hash table since the names used to place them will have changed.
152684 :
152685 : // printf ("Warning: In SgTemplateInstantiationDecl::get_qualified_name() (at %p) get_qualified_name() (get_nameResetFromMangledForm() == false) name = %s (skipping call to reset) \n",this,get_name().str());
152686 : }
152687 : // ROSE_ASSERT(get_nameResetFromMangledForm() == true);
152688 :
152689 : // DQ (8/28/2005): This function previously used the template declaration as a basis for
152690 : // its qualified name generation. I think this is a mistake and that the templates scope
152691 : // should be used instead (same as for where qualified names are generated elsewhere).
152692 :
152693 : #if 0
152694 : // printf ("In SgTemplateInstantiationDecl::get_qualified_name() name = %s \n",get_name().str());
152695 :
152696 : // Make sure that parents have been set already
152697 : // (assume this means that all parents have been set)
152698 : if (get_parent() == NULL)
152699 : {
152700 : printf ("In SgTemplateInstantiationDecl::get_qualified_name() this = %p at: \n",this);
152701 : get_file_info()->display("Error at this location in source code!");
152702 : }
152703 : ROSE_ASSERT (get_parent() != NULL);
152704 :
152705 : SgName returnName;
152706 :
152707 : SgTemplateDeclaration* templateDeclaration = get_templateDeclaration();
152708 : ROSE_ASSERT(templateDeclaration != NULL);
152709 :
152710 : returnName = SgName::assembleQualifiedName(templateDeclaration->get_qualified_name(),get_name());
152711 :
152712 : return returnName;
152713 : #else
152714 : // printf ("In SgTemplateInstantiationDecl::get_qualified_name() name = %s \n",get_name().str());
152715 :
152716 13483 : SgName returnName;
152717 :
152718 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
152719 13483 : SgScopeStatement* scope = get_scope();
152720 13483 : ROSE_ASSERT(scope != NULL);
152721 :
152722 13483 : returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
152723 :
152724 : // printf ("In SgTemplateInstantiationDecl::get_qualified_name() returnName = %s \n",returnName.str());
152725 :
152726 13483 : return returnName;
152727 : #endif
152728 : }
152729 :
152730 :
152731 : #define DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME 0
152732 :
152733 : // RV (2/1/2006): Added mangler for template instantiations.
152734 : SgName
152735 218398 : SgTemplateInstantiationDecl::get_mangled_name (void) const
152736 : {
152737 : #if 0
152738 : return mangleTemplate (get_templateName(),
152739 : get_templateArguments (),
152740 : get_scope ());
152741 : #else
152742 : #if 0
152743 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
152744 : SgTemplateInstantiationDecl* declaration = const_cast<SgTemplateInstantiationDecl*>(this);
152745 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
152746 : if (i != p_globalMangledNameMap.end())
152747 : {
152748 : return i->second.c_str();
152749 : }
152750 : #endif
152751 436796 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgTemplateInstantiationDecl*>(this));
152752 :
152753 : #if 0
152754 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): this = %p name = %s mangledNameString.empty() = %s \n",this,get_name().str(),mangledNameString.empty() ? "true" : "false");
152755 : // printf ("In SgTemplateInstantiationDecl::get_mangled_name(): associated definition = %p = %s \n",get_definition(),get_definition()->class_name().c_str());
152756 : if (get_definition() != NULL)
152757 : {
152758 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): associated definition = %p = %s \n",get_definition(),get_definition()->class_name().c_str());
152759 : }
152760 : else
152761 : {
152762 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): (non-defining declaration): associated definition = %p \n",get_definition());
152763 : }
152764 :
152765 : // DQ (10/29/2015): We need to check this since as the AST is being build the source position may not yet be set.
152766 : // This function is called in the construction of types to insert new types into the global type tables, and to
152767 : // check for existing types to support sharing of types in the AST (from the global type table).
152768 : if (this->get_file_info() != NULL)
152769 : {
152770 : ROSE_ASSERT(this->get_file_info() != NULL);
152771 : ROSE_ASSERT(this->get_startOfConstruct() != NULL);
152772 : ROSE_ASSERT(this->get_endOfConstruct() != NULL);
152773 :
152774 : // this->get_file_info()->display("In SgTemplateInstantiationDecl::get_mangled_name(): debug");
152775 : this->get_startOfConstruct()->display("START: In SgTemplateInstantiationDecl::get_mangled_name(): debug");
152776 : this->get_endOfConstruct ()->display("END: In SgTemplateInstantiationDecl::get_mangled_name(): debug");
152777 : }
152778 : #endif
152779 :
152780 218398 : if (mangledNameString.empty() == false)
152781 : {
152782 : // return i->second.c_str();
152783 : #if DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME
152784 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): (FOUND in cache) mangledNameString = %s get_name() = %s \n",mangledNameString.c_str(),get_name().str());
152785 : #endif
152786 197318 : return mangledNameString;
152787 : }
152788 : else
152789 : {
152790 : // DQ (7/24/2010): Added to support type tables (at an early stage in AST construction, the get_templateName() might not be known yet.
152791 : // ROSE_ASSERT(get_templateName().is_null() == false);
152792 21080 : SgName template_name = get_templateName();
152793 21080 : if (template_name.is_null() == true)
152794 : {
152795 : // Use the name of the template (as defined by EDG) so that we can generate a unique string
152796 : // (later this is reset to excluse EDG geneated strings that don't map to the original source code).
152797 0 : printf ("ERROR: In SgTemplateInstantiationDecl::get_mangled_name(): template_name.is_null() == true, using get_name() \n");
152798 0 : template_name = get_name();
152799 :
152800 : // DQ (6/1/2012): Make this an error.
152801 0 : printf ("SgTemplateInstantiationDecl::get_mangled_name(): Make this an error! \n");
152802 0 : ROSE_ASSERT(false);
152803 : }
152804 21080 : ROSE_ASSERT(template_name.is_null() == false);
152805 :
152806 : #if DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME
152807 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): template_name = %s get_templateArguments().size() = %" PRIuPTR " get_scope() = %p \n",template_name.str(),get_templateArguments().size(),get_scope());
152808 : #endif
152809 :
152810 : // DQ (5/31/2012): Added test for template brackets that are caught later in AstConsistencyTests.
152811 : // Make sure that there is no template specific syntax included in the mangled name
152812 42160 : string mangled_name_1 = template_name;
152813 21080 : if ( mangled_name_1.find('<') != string::npos )
152814 : {
152815 0 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name_1.c_str());
152816 : }
152817 : // ROSE_ASSERT(mangled_name_1.find('<') == string::npos);
152818 :
152819 : // DQ (3/22/2012): Added assertion to detect bad (default) names being used.
152820 21080 : ROSE_ASSERT(template_name != "SETME_NONDEFINING_DECL<>");
152821 : #if DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME
152822 : printf ("Before mangleTemplate(): template_name = %s \n",template_name.str());
152823 : #endif
152824 : #if 0
152825 : // DQ (6/1/2012): Turn this test on!
152826 : if (get_templateArguments().size() == 0)
152827 : {
152828 : // DQ (6/1/2012): We are still in the process of building this type and the arguments have not been attached yet. So use the declaration's name from "get_name()".
152829 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): get_templateArguments().size() == 0, using get_name() \n");
152830 : template_name = get_name();
152831 :
152832 : ROSE_ASSERT(template_name.getString().find('<') != string::npos);
152833 : }
152834 :
152835 : // DQ (6/1/2012): We need the template arguments in order to generate the mangled name for the type! This is the current problem.
152836 : // If the instantiated template name has tmeplate argument syntax, then we need to be able to see the list of template arguments.
152837 : // In some cases these template argument are not yet attached to the declaration, and so the wrong mangled name for the type will be generated.
152838 : // If we use the template name from "get_name()", then we will generate unique names, but then we will fail the test to make sure
152839 : // that there is no template argument syntax in the mangled names (AST Consistency tests).
152840 : if (get_name().getString().find('<') != string::npos)
152841 : {
152842 : printf ("WARNING: In SgTemplateInstantiationDecl::get_mangled_name(): Skipping test for: get_templateArguments().size() > 0 \n");
152843 : // ROSE_ASSERT(get_templateArguments().size() > 0);
152844 : }
152845 :
152846 : #endif
152847 :
152848 : // SgName mangledName = mangleTemplate (get_templateName(),get_templateArguments(),get_scope());
152849 42160 : SgName mangledName = mangleTemplate(template_name,get_templateArguments(),get_scope());
152850 : #if DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME
152851 : printf ("After mangleTemplate(): get_templateArguments().size() = %" PRIuPTR " mangledName = %s \n",get_templateArguments().size(),mangledName.str());
152852 : #endif
152853 21080 : ROSE_ASSERT(get_firstNondefiningDeclaration() != NULL);
152854 : #if 0
152855 : printf ("After mangleTemplate(): get_firstNondefiningDeclaration()->get_templateArguments().size() = %" PRIuPTR " \n",isSgTemplateInstantiationDecl(get_firstNondefiningDeclaration())->get_templateArguments().size());
152856 : if (get_definingDeclaration() != NULL)
152857 : printf ("After mangleTemplate(): get_definingDeclaration()->get_templateArguments().size() = %" PRIuPTR " \n",isSgTemplateInstantiationDecl(get_definingDeclaration())->get_templateArguments().size());
152858 : #endif
152859 : #if 0
152860 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): (NOT found in cache) mangledName = %s get_name() = %s get_templateName() = %s \n",mangledName.c_str(),get_name().str(),get_templateName().str());
152861 : #endif
152862 : // DQ (7/24/2010): Added to support type tables.
152863 21080 : ROSE_ASSERT(mangledName.is_null() == false);
152864 :
152865 : // p_globalMangledNameMap[declaration] = mangledName;
152866 21168 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgTemplateInstantiationDecl*>(this),mangledName);
152867 : #if DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME
152868 : printf ("After SageInterface::addMangledNameToCache(): mangledName = %s \n",mangledName.str());
152869 : #endif
152870 : // DQ (5/31/2012): Added test for template brackets that are caught later in AstConsistencyTests.
152871 : // Make sure that there is no template specific syntax included in the mangled name
152872 42160 : string mangled_name = mangledName;
152873 21080 : if ( mangled_name.find('<') != string::npos )
152874 : {
152875 0 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
152876 : }
152877 21080 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
152878 :
152879 : #if DEBUG_TEMPLATE_INSTANTIATION_DECL_GET_MANGLED_NAME
152880 : // DQ (7/24/2012): Output the mangled name being generated for debugging.
152881 : printf ("In SgTemplateInstantiationDecl::get_mangled_name(): returning mangledName = %s \n",mangledName.str());
152882 : #endif
152883 :
152884 21080 : return mangledName;
152885 : }
152886 : #endif
152887 : }
152888 :
152889 : void
152890 0 : SgTemplateInstantiationDecl::set_definition( SgTemplateInstantiationDefn* definition )
152891 : {
152892 : // DQ (9/23/2004): Implement this function to hide the base class one so that the interface
152893 : // to set_definition takes a SgTemplateInstantiationDefn instead of a SgClassDefinition.
152894 : // Implement using explicit call to the base class set_definition function.
152895 0 : SgClassDeclaration::set_definition(definition);
152896 0 : }
152897 :
152898 : void
152899 0 : SgTemplateInstantiationDecl::set_definition( SgClassDefinition* definition )
152900 : {
152901 : // DQ (10/10/2014): Implemented to support Aterm constructor functions.
152902 : // We need a way for the automatically generated code to set the
152903 : // definition data member in the base class.
152904 :
152905 : // DQ (10/10/2014): Make sure that this is a SgTemplateInstantiationDefn (or NULL).
152906 0 : ROSE_ASSERT(definition == NULL || isSgTemplateInstantiationDefn(definition) != NULL);
152907 :
152908 0 : SgClassDeclaration::set_definition(definition);
152909 0 : }
152910 :
152911 : void
152912 33111 : SgTemplateInstantiationDecl::resetTemplateName ()
152913 : {
152914 : #if 0
152915 : // DQ (6/30/2018): Adding debugging for infinite loop in test2018_117.C.
152916 : printf ("In SgTemplateInstantiationDecl::resetTemplateName(): calling resetTemplateNameSupport(): p_nameResetFromMangledForm = %s p_name = %s \n",p_nameResetFromMangledForm ? "true" : "false",p_name.str());
152917 : #endif
152918 :
152919 : // local version of function to support generation of template names
152920 33111 : resetTemplateNameSupport (p_nameResetFromMangledForm,p_name);
152921 33111 : }
152922 :
152923 : // DQ (2/11/2007): Get the associated symbol from the symbol table in the stored scope
152924 : SgSymbol*
152925 69033 : SgTemplateInstantiationDecl::get_symbol_from_symbol_table() const
152926 : {
152927 69033 : ROSE_ASSERT(get_scope() != NULL);
152928 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
152929 : // return get_scope()->get_symbol_table()->find(this);
152930 69033 : return get_scope()->find_symbol_from_declaration(this);
152931 : }
152932 :
152933 :
152934 :
152935 : // End of memberFunctionString
152936 : // Start of memberFunctionString
152937 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
152938 :
152939 : // *** COMMON CODE SECTION BEGINS HERE ***
152940 :
152941 : #if 0
152942 : int
152943 : SgTemplateInstantiationDecl::getVariant() const
152944 : {
152945 : // This function is used in ROSE while "variant()" is used in SAGE
152946 : assert(this != NULL);
152947 : return variant();
152948 : }
152949 : #endif
152950 :
152951 : // This function is used in ROSE in treeTraversal code
152952 : // eventually replaces getVariant() and variant()
152953 : // though after variant() has been removed for a while we will
152954 : // want to change the name of variantT() back to variant()
152955 : // (since the "T" was ment to stand for temporary).
152956 : // When this happens the variantT() will be depricated.
152957 : VariantT
152958 12275800 : SgTemplateInstantiationDecl::variantT() const
152959 : {
152960 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
152961 12275800 : ROSE_ASSERT(this != NULL);
152962 12275800 : return V_SgTemplateInstantiationDecl;
152963 : }
152964 :
152965 : #if 0
152966 : int
152967 : SgTemplateInstantiationDecl::variant() const
152968 : {
152969 : // This function is used in SAGE
152970 : ROSE_ASSERT(this != NULL);
152971 : return TEMPLATE_INST_DECL_STMT;
152972 : }
152973 : #endif
152974 :
152975 : ROSE_DLL_API const char*
152976 524 : SgTemplateInstantiationDecl::sage_class_name() const
152977 : {
152978 524 : ROSE_ASSERT(this != NULL);
152979 524 : return "SgTemplateInstantiationDecl";
152980 : }
152981 :
152982 : std::string
152983 28494 : SgTemplateInstantiationDecl::class_name() const
152984 : {
152985 28494 : ROSE_ASSERT(this != NULL);
152986 28494 : return "SgTemplateInstantiationDecl";
152987 : }
152988 :
152989 : // DQ (11/26/2005): Support for visitor pattern mechanims
152990 : // (inferior to ROSE traversal mechanism, experimental).
152991 : void
152992 183029 : SgTemplateInstantiationDecl::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
152993 : {
152994 183029 : ROSE_ASSERT(this != NULL);
152995 183029 : visitor.visit(this);
152996 183029 : }
152997 :
152998 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
152999 0 : void SgTemplateInstantiationDecl::accept (ROSE_VisitorPattern & visitor) {
153000 0 : ROSE_ASSERT(this != NULL);
153001 0 : visitor.visit(this);
153002 0 : }
153003 :
153004 : SgTemplateInstantiationDecl*
153005 0 : SgTemplateInstantiationDecl::addRegExpAttribute(std::string s, AstRegExAttribute* a)
153006 : {
153007 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
153008 : // This function is currently only supported for the AST used the represent Binary executables.
153009 : if (0 /* isSgAsmNode(this) != NULL */)
153010 : {
153011 : // Support for regex specification.
153012 : std::string prefixCode = "REGEX:";
153013 : addNewAttribute(prefixCode + s,a);
153014 : }
153015 : #endif
153016 :
153017 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
153018 0 : return this;
153019 : }
153020 :
153021 : // *** COMMON CODE SECTION ENDS HERE ***
153022 :
153023 :
153024 : // End of memberFunctionString
153025 : // Start of memberFunctionString
153026 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
153027 :
153028 :
153029 : #if 0
153030 : //! Error checking support
153031 : /*! Verifies the following:
153032 : - working getVariant() member function
153033 : - calls base class's error() member function
153034 : Every class has one of these functions.
153035 : */
153036 : bool
153037 : SgTemplateInstantiationDecl::error()
153038 : {
153039 : // Put error checking here
153040 :
153041 : ROSE_ASSERT (this != NULL);
153042 : if (getVariant() != TEMPLATE_INST_DECL_STMT)
153043 : {
153044 : printf ("Error in SgTemplateInstantiationDecl::error(): SgTemplateInstantiationDecl object has a %s variant \n",
153045 : Cxx_GrammarTerminalNames[getVariant()].name);
153046 : // printf ("Error in SgTemplateInstantiationDecl::error() \n");
153047 : ROSE_ABORT();
153048 : }
153049 :
153050 : ROSE_ASSERT (getVariant() == TEMPLATE_INST_DECL_STMT);
153051 : return SgClassDeclaration::error();
153052 : }
153053 : #endif
153054 :
153055 :
153056 :
153057 : // End of memberFunctionString
153058 :
153059 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
153060 :
153061 23934400 : SgTemplateInstantiationDecl* isSgTemplateInstantiationDecl ( SgNode* inputDerivedClassPointer )
153062 : {
153063 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
153064 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
153065 : // So to fix this we return NULL directly when the input is NULL and avoid the
153066 : // dynamic_cast in this case. This is likely a performance improvement as well.
153067 : // return dynamic_cast<SgTemplateInstantiationDecl*>(inputDerivedClassPointer);
153068 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationDecl uses table-driven castability instead of c++ default dynamic_cast
153069 : // this improves the running time performance by 10-20%.
153070 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateInstantiationDecl*>(inputDerivedClassPointer);
153071 23934400 : return IS_SgTemplateInstantiationDecl_FAST_MACRO(inputDerivedClassPointer);
153072 : }
153073 :
153074 : // DQ (11/8/2003): Added version of functions taking const pointer
153075 86528 : const SgTemplateInstantiationDecl* isSgTemplateInstantiationDecl ( const SgNode* inputDerivedClassPointer )
153076 : {
153077 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
153078 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
153079 : // So to fix this we return NULL directly when the input is NULL and avoid the
153080 : // dynamic_cast in this case. This is likely a performance improvement as well.
153081 : // return dynamic_cast<const SgTemplateInstantiationDecl*>(inputDerivedClassPointer);
153082 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationDecl uses table-driven castability instead of c++ default dynamic_cast
153083 : // this improves the running time performance by 10-20%.
153084 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateInstantiationDecl*>(inputDerivedClassPointer);
153085 86528 : return IS_SgTemplateInstantiationDecl_FAST_MACRO(inputDerivedClassPointer);
153086 : }
153087 :
153088 :
153089 :
153090 : /* #line 153091 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153091 :
153092 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
153093 :
153094 : /**
153095 : \brief Generated destructor
153096 :
153097 : This destructor is automatically generated (by ROSETTA). This destructor
153098 : only frees memory of data members associated with the parts of the current IR node which
153099 : are NOT traversed. Those data members that are part of a traversal can be freed using
153100 : a traversal (calling this destructor on all children in a post-order traversal). Such
153101 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
153102 :
153103 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
153104 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
153105 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
153106 :
153107 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
153108 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
153109 : pointers are not yet implemented to call delete on eash pointer in the container.
153110 : (This could be done by derivation from the STL containers to define containers that
153111 : automatically deleted their members.)
153112 :
153113 : */
153114 7874 : SgTemplateInstantiationDecl::~SgTemplateInstantiationDecl () {
153115 2638 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
153116 :
153117 :
153118 : // case: not a listType for templateName
153119 2638 : p_templateName = ""; // non list case
153120 : // case: not a listType for templateHeader
153121 2638 : p_templateHeader = ""; // non list case
153122 : // case: not a listType for templateDeclaration
153123 2638 : p_templateDeclaration = NULL; // non list case
153124 : // case: listType for templateArguments
153125 : // case: listType (typeIsPointerToList == false) for templateArguments
153126 2638 : p_templateArguments.erase(p_templateArguments.begin(),p_templateArguments.end());
153127 : // case: not a listType for nameResetFromMangledForm
153128 2638 : p_nameResetFromMangledForm = false; // non list case
153129 :
153130 : }
153131 :
153132 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
153133 5276 : }
153134 :
153135 :
153136 : /* #line 153137 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153137 :
153138 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
153139 :
153140 : // Generated constructor
153141 0 : SgTemplateInstantiationDecl::SgTemplateInstantiationDecl ( Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition, SgTemplateClassDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments )
153142 0 : : SgClassDeclaration(startOfConstruct, name, class_type, type, definition)
153143 : {
153144 : #ifdef DEBUG
153145 : // printf ("In SgTemplateInstantiationDecl::SgTemplateInstantiationDecl (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition, SgTemplateClassDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments) sage_class_name() = %s \n",sage_class_name());
153146 : #endif
153147 : #if 0
153148 : // debugging information!
153149 : printf ("In SgTemplateInstantiationDecl::SgTemplateInstantiationDecl (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition, SgTemplateClassDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments): this = %p = %s \n",this,this->class_name().c_str());
153150 : #endif
153151 :
153152 0 : p_templateName = "";
153153 0 : p_templateHeader = "";
153154 0 : p_templateDeclaration = templateDeclaration;
153155 0 : p_templateArguments = templateArguments;
153156 0 : p_nameResetFromMangledForm = false;
153157 :
153158 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
153159 :
153160 : #if 0
153161 : // DQ (7/30/2014): Call a virtual function.
153162 : std::string s = this->class_name();
153163 : #endif
153164 :
153165 : // Test the variant virtual function
153166 : // assert(TEMPLATE_INST_DECL_STMT == variant());
153167 0 : assert(TEMPLATE_INST_DECL_STMT == this->variant());
153168 0 : ROSE_ASSERT(TEMPLATE_INST_DECL_STMT == (int)(this->variantT()));
153169 0 : post_construction_initialization();
153170 :
153171 : // Test the isSgTemplateInstantiationDecl() function since it has been problematic
153172 0 : assert(isSgTemplateInstantiationDecl(this) != NULL);
153173 0 : }
153174 :
153175 : // Generated constructor (all data members)
153176 :
153177 : /* #line 153178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153178 :
153179 :
153180 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
153181 :
153182 :
153183 : // ********************************************************
153184 : // member functions common across all array grammar objects
153185 : // ********************************************************
153186 :
153187 :
153188 :
153189 : /* #line 153190 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153190 :
153191 :
153192 :
153193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
153194 :
153195 : // ********************************************************
153196 : // member functions specific to each node in the grammar
153197 : // ********************************************************
153198 :
153199 :
153200 : /* #line 153201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153201 :
153202 : // Start of memberFunctionString
153203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
153204 :
153205 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
153206 :
153207 : SgLabelRefExp*
153208 0 : SgDerivedTypeStatement::get_end_numeric_label () const
153209 : {
153210 0 : ROSE_ASSERT (this != NULL);
153211 :
153212 : #if 0
153213 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153214 : // used to trigger marking transformations for the token-based unparsing.
153215 : printf ("SgDerivedTypeStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
153216 : #endif
153217 :
153218 0 : return p_end_numeric_label;
153219 : }
153220 :
153221 : void
153222 0 : SgDerivedTypeStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
153223 : {
153224 0 : ROSE_ASSERT (this != NULL);
153225 :
153226 : #if 0
153227 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153228 : // used to trigger marking transformations for the token-based unparsing.
153229 : printf ("SgDerivedTypeStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
153230 : #endif
153231 :
153232 0 : set_isModified(true);
153233 :
153234 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
153235 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
153236 : {
153237 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
153238 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
153239 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
153240 : ROSE_ASSERT(false);
153241 : #endif
153242 : }
153243 : #endif
153244 0 : p_end_numeric_label = end_numeric_label;
153245 0 : }
153246 :
153247 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
153248 :
153249 :
153250 : // End of memberFunctionString
153251 : // Start of memberFunctionString
153252 : /* #line 18595 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
153253 :
153254 : void
153255 0 : SgDerivedTypeStatement::post_construction_initialization()
153256 0 : {}
153257 :
153258 : SgName
153259 0 : SgDerivedTypeStatement::get_mangled_name() const
153260 : {
153261 : // DQ (12/27/2010): This causes endless recursion when the type is defined locally to the
153262 : // function and the function uses the type as a return type (which seems like a language
153263 : // design mistake). Testcode test2010_179.f90 demonstrates this and it is actually a part
153264 : // of the gfortran test suite, so I gather it is legal code.
153265 : // To address this complexity I will make the fix in this IR node (which is fortran specific)
153266 : // to use only the name plus the function and qualified name of the function's scope instead
153267 : // of the generated function definition's mangled name which causes the endless recursion.
153268 : // This will be done only for the case were we detect that the type is used as the return type of
153269 : // the function. I don't think that modules can be defined in functions, so I think this is OK.
153270 : // return SgClassDeclaration::get_mangled_name();
153271 0 : SgName mangleName;
153272 0 : ROSE_ASSERT(this->get_parent() != NULL);
153273 0 : SgFunctionDeclaration* functionDeclaration = TransformationSupport::getFunctionDeclaration(this->get_parent());
153274 :
153275 0 : bool defineShorterName = false;
153276 0 : if (functionDeclaration != NULL)
153277 : {
153278 0 : SgFunctionType* functionType = isSgFunctionType(functionDeclaration->get_type());
153279 0 : ROSE_ASSERT(functionType != NULL);
153280 : // printf ("functionType = %p = %s \n",functionType,functionType->class_name().c_str());
153281 :
153282 0 : SgType* returnType = functionType->get_return_type();
153283 0 : ROSE_ASSERT(returnType != NULL);
153284 0 : if (returnType == this->get_type())
153285 : {
153286 0 : defineShorterName = true;
153287 : }
153288 : }
153289 :
153290 0 : if (defineShorterName == true)
153291 : {
153292 : // This defines a short (none endlessly recursive name) for the derived type mangled name.
153293 0 : mangleName = "__NESTED_TYPE_USED_IN_FUNCTION_RETURN_TYPE_" + functionDeclaration->get_name() + "__" + this->get_name() + "__";
153294 : }
153295 : else
153296 : {
153297 0 : mangleName = SgClassDeclaration::get_mangled_name();
153298 : }
153299 :
153300 0 : return mangleName;
153301 : }
153302 :
153303 :
153304 : // End of memberFunctionString
153305 : // Start of memberFunctionString
153306 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
153307 :
153308 : // *** COMMON CODE SECTION BEGINS HERE ***
153309 :
153310 : #if 0
153311 : int
153312 : SgDerivedTypeStatement::getVariant() const
153313 : {
153314 : // This function is used in ROSE while "variant()" is used in SAGE
153315 : assert(this != NULL);
153316 : return variant();
153317 : }
153318 : #endif
153319 :
153320 : // This function is used in ROSE in treeTraversal code
153321 : // eventually replaces getVariant() and variant()
153322 : // though after variant() has been removed for a while we will
153323 : // want to change the name of variantT() back to variant()
153324 : // (since the "T" was ment to stand for temporary).
153325 : // When this happens the variantT() will be depricated.
153326 : VariantT
153327 0 : SgDerivedTypeStatement::variantT() const
153328 : {
153329 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
153330 0 : ROSE_ASSERT(this != NULL);
153331 0 : return V_SgDerivedTypeStatement;
153332 : }
153333 :
153334 : #if 0
153335 : int
153336 : SgDerivedTypeStatement::variant() const
153337 : {
153338 : // This function is used in SAGE
153339 : ROSE_ASSERT(this != NULL);
153340 : return TEMP_Derived_Type_Statement;
153341 : }
153342 : #endif
153343 :
153344 : ROSE_DLL_API const char*
153345 0 : SgDerivedTypeStatement::sage_class_name() const
153346 : {
153347 0 : ROSE_ASSERT(this != NULL);
153348 0 : return "SgDerivedTypeStatement";
153349 : }
153350 :
153351 : std::string
153352 0 : SgDerivedTypeStatement::class_name() const
153353 : {
153354 0 : ROSE_ASSERT(this != NULL);
153355 0 : return "SgDerivedTypeStatement";
153356 : }
153357 :
153358 : // DQ (11/26/2005): Support for visitor pattern mechanims
153359 : // (inferior to ROSE traversal mechanism, experimental).
153360 : void
153361 0 : SgDerivedTypeStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
153362 : {
153363 0 : ROSE_ASSERT(this != NULL);
153364 0 : visitor.visit(this);
153365 0 : }
153366 :
153367 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
153368 0 : void SgDerivedTypeStatement::accept (ROSE_VisitorPattern & visitor) {
153369 0 : ROSE_ASSERT(this != NULL);
153370 0 : visitor.visit(this);
153371 0 : }
153372 :
153373 : SgDerivedTypeStatement*
153374 0 : SgDerivedTypeStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
153375 : {
153376 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
153377 : // This function is currently only supported for the AST used the represent Binary executables.
153378 : if (0 /* isSgAsmNode(this) != NULL */)
153379 : {
153380 : // Support for regex specification.
153381 : std::string prefixCode = "REGEX:";
153382 : addNewAttribute(prefixCode + s,a);
153383 : }
153384 : #endif
153385 :
153386 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
153387 0 : return this;
153388 : }
153389 :
153390 : // *** COMMON CODE SECTION ENDS HERE ***
153391 :
153392 :
153393 : // End of memberFunctionString
153394 : // Start of memberFunctionString
153395 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
153396 :
153397 :
153398 : #if 0
153399 : //! Error checking support
153400 : /*! Verifies the following:
153401 : - working getVariant() member function
153402 : - calls base class's error() member function
153403 : Every class has one of these functions.
153404 : */
153405 : bool
153406 : SgDerivedTypeStatement::error()
153407 : {
153408 : // Put error checking here
153409 :
153410 : ROSE_ASSERT (this != NULL);
153411 : if (getVariant() != TEMP_Derived_Type_Statement)
153412 : {
153413 : printf ("Error in SgDerivedTypeStatement::error(): SgDerivedTypeStatement object has a %s variant \n",
153414 : Cxx_GrammarTerminalNames[getVariant()].name);
153415 : // printf ("Error in SgDerivedTypeStatement::error() \n");
153416 : ROSE_ABORT();
153417 : }
153418 :
153419 : ROSE_ASSERT (getVariant() == TEMP_Derived_Type_Statement);
153420 : return SgClassDeclaration::error();
153421 : }
153422 : #endif
153423 :
153424 :
153425 :
153426 : // End of memberFunctionString
153427 :
153428 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
153429 :
153430 27 : SgDerivedTypeStatement* isSgDerivedTypeStatement ( SgNode* inputDerivedClassPointer )
153431 : {
153432 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
153433 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
153434 : // So to fix this we return NULL directly when the input is NULL and avoid the
153435 : // dynamic_cast in this case. This is likely a performance improvement as well.
153436 : // return dynamic_cast<SgDerivedTypeStatement*>(inputDerivedClassPointer);
153437 : // Milind Chabbi (8/28/2013): isSgDerivedTypeStatement uses table-driven castability instead of c++ default dynamic_cast
153438 : // this improves the running time performance by 10-20%.
153439 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDerivedTypeStatement*>(inputDerivedClassPointer);
153440 27 : return IS_SgDerivedTypeStatement_FAST_MACRO(inputDerivedClassPointer);
153441 : }
153442 :
153443 : // DQ (11/8/2003): Added version of functions taking const pointer
153444 0 : const SgDerivedTypeStatement* isSgDerivedTypeStatement ( const SgNode* inputDerivedClassPointer )
153445 : {
153446 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
153447 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
153448 : // So to fix this we return NULL directly when the input is NULL and avoid the
153449 : // dynamic_cast in this case. This is likely a performance improvement as well.
153450 : // return dynamic_cast<const SgDerivedTypeStatement*>(inputDerivedClassPointer);
153451 : // Milind Chabbi (8/28/2013): isSgDerivedTypeStatement uses table-driven castability instead of c++ default dynamic_cast
153452 : // this improves the running time performance by 10-20%.
153453 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDerivedTypeStatement*>(inputDerivedClassPointer);
153454 0 : return IS_SgDerivedTypeStatement_FAST_MACRO(inputDerivedClassPointer);
153455 : }
153456 :
153457 :
153458 :
153459 : /* #line 153460 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153460 :
153461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
153462 :
153463 : /**
153464 : \brief Generated destructor
153465 :
153466 : This destructor is automatically generated (by ROSETTA). This destructor
153467 : only frees memory of data members associated with the parts of the current IR node which
153468 : are NOT traversed. Those data members that are part of a traversal can be freed using
153469 : a traversal (calling this destructor on all children in a post-order traversal). Such
153470 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
153471 :
153472 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
153473 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
153474 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
153475 :
153476 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
153477 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
153478 : pointers are not yet implemented to call delete on eash pointer in the container.
153479 : (This could be done by derivation from the STL containers to define containers that
153480 : automatically deleted their members.)
153481 :
153482 : */
153483 0 : SgDerivedTypeStatement::~SgDerivedTypeStatement () {
153484 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
153485 :
153486 :
153487 : // case: not a listType for end_numeric_label
153488 0 : p_end_numeric_label = NULL; // non list case
153489 :
153490 : }
153491 :
153492 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
153493 0 : }
153494 :
153495 :
153496 : /* #line 153497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153497 :
153498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
153499 :
153500 : // Generated constructor
153501 0 : SgDerivedTypeStatement::SgDerivedTypeStatement ( Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition )
153502 0 : : SgClassDeclaration(startOfConstruct, name, class_type, type, definition)
153503 : {
153504 : #ifdef DEBUG
153505 : // printf ("In SgDerivedTypeStatement::SgDerivedTypeStatement (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition) sage_class_name() = %s \n",sage_class_name());
153506 : #endif
153507 : #if 0
153508 : // debugging information!
153509 : printf ("In SgDerivedTypeStatement::SgDerivedTypeStatement (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
153510 : #endif
153511 :
153512 0 : p_end_numeric_label = NULL;
153513 :
153514 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
153515 :
153516 : #if 0
153517 : // DQ (7/30/2014): Call a virtual function.
153518 : std::string s = this->class_name();
153519 : #endif
153520 :
153521 : // Test the variant virtual function
153522 : // assert(TEMP_Derived_Type_Statement == variant());
153523 0 : assert(TEMP_Derived_Type_Statement == this->variant());
153524 0 : ROSE_ASSERT(TEMP_Derived_Type_Statement == (int)(this->variantT()));
153525 0 : post_construction_initialization();
153526 :
153527 : // Test the isSgDerivedTypeStatement() function since it has been problematic
153528 0 : assert(isSgDerivedTypeStatement(this) != NULL);
153529 0 : }
153530 :
153531 : // Generated constructor (all data members)
153532 :
153533 : /* #line 153534 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153534 :
153535 :
153536 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
153537 :
153538 :
153539 : // ********************************************************
153540 : // member functions common across all array grammar objects
153541 : // ********************************************************
153542 :
153543 :
153544 :
153545 : /* #line 153546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153546 :
153547 :
153548 :
153549 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
153550 :
153551 : // ********************************************************
153552 : // member functions specific to each node in the grammar
153553 : // ********************************************************
153554 :
153555 :
153556 : /* #line 153557 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153557 :
153558 : // Start of memberFunctionString
153559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
153560 :
153561 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
153562 :
153563 : SgLabelRefExp*
153564 0 : SgModuleStatement::get_end_numeric_label () const
153565 : {
153566 0 : ROSE_ASSERT (this != NULL);
153567 :
153568 : #if 0
153569 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153570 : // used to trigger marking transformations for the token-based unparsing.
153571 : printf ("SgModuleStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
153572 : #endif
153573 :
153574 0 : return p_end_numeric_label;
153575 : }
153576 :
153577 : void
153578 0 : SgModuleStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
153579 : {
153580 0 : ROSE_ASSERT (this != NULL);
153581 :
153582 : #if 0
153583 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153584 : // used to trigger marking transformations for the token-based unparsing.
153585 : printf ("SgModuleStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
153586 : #endif
153587 :
153588 0 : set_isModified(true);
153589 :
153590 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
153591 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
153592 : {
153593 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
153594 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
153595 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
153596 : ROSE_ASSERT(false);
153597 : #endif
153598 : }
153599 : #endif
153600 0 : p_end_numeric_label = end_numeric_label;
153601 0 : }
153602 :
153603 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
153604 :
153605 :
153606 : // End of memberFunctionString
153607 : // Start of memberFunctionString
153608 : /* #line 18192 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
153609 :
153610 :
153611 : void
153612 0 : SgModuleStatement::post_construction_initialization()
153613 0 : {}
153614 :
153615 : SgName
153616 0 : SgModuleStatement::get_mangled_name() const
153617 : {
153618 : // printf ("Sorry, SgModuleStatement::get_mangled_name() not implemented! \n");
153619 0 : return SgName("_module_");
153620 : }
153621 :
153622 : #if 0
153623 : const SgDeclarationStatementPtrList &
153624 : SgModuleStatement::get_members() const
153625 : {
153626 : return p_members;
153627 : }
153628 :
153629 : SgDeclarationStatementPtrList &
153630 : SgModuleStatement::get_members()
153631 : {
153632 : return p_members;
153633 : }
153634 :
153635 : void
153636 : SgModuleStatement::append_declaration(SgDeclarationStatement * what)
153637 : {
153638 : insert_declaration(get_declarations().end(),what);
153639 : }
153640 :
153641 : void
153642 : SgModuleStatement::prepend_declaration(SgDeclarationStatement * what)
153643 : {
153644 : insert_declaration(get_declarations().begin(),what);
153645 : }
153646 :
153647 : void
153648 : SgModuleStatement::insert_declaration ( const SgDeclarationStatementPtrList::iterator& where,
153649 : SgDeclarationStatement* what)
153650 : {
153651 : #ifndef REMOVE_SET_PARENT_FUNCTION
153652 : what->set_parent(this);
153653 : #endif
153654 : get_declarations().insert(where,what);
153655 : }
153656 :
153657 : // DQ (8/27/2004): Turn this back on!
153658 : #if 1
153659 : bool
153660 : SgModuleStatement::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractBasicBlock)
153661 : {
153662 : return StatementListInsertChild( this, get_declarations(), target, newstmt, inFront, extractBasicBlock, false);
153663 : }
153664 :
153665 : bool
153666 : SgModuleStatement::replace_child(SgStatement *target ,SgStatement * newstmt, bool extractBasicBlock)
153667 : {
153668 : return StatementListInsertChild( this, get_declarations(), target, newstmt, true, extractBasicBlock, true);
153669 : }
153670 : #endif
153671 : #endif
153672 :
153673 :
153674 :
153675 : // End of memberFunctionString
153676 : // Start of memberFunctionString
153677 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
153678 :
153679 : // *** COMMON CODE SECTION BEGINS HERE ***
153680 :
153681 : #if 0
153682 : int
153683 : SgModuleStatement::getVariant() const
153684 : {
153685 : // This function is used in ROSE while "variant()" is used in SAGE
153686 : assert(this != NULL);
153687 : return variant();
153688 : }
153689 : #endif
153690 :
153691 : // This function is used in ROSE in treeTraversal code
153692 : // eventually replaces getVariant() and variant()
153693 : // though after variant() has been removed for a while we will
153694 : // want to change the name of variantT() back to variant()
153695 : // (since the "T" was ment to stand for temporary).
153696 : // When this happens the variantT() will be depricated.
153697 : VariantT
153698 0 : SgModuleStatement::variantT() const
153699 : {
153700 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
153701 0 : ROSE_ASSERT(this != NULL);
153702 0 : return V_SgModuleStatement;
153703 : }
153704 :
153705 : #if 0
153706 : int
153707 : SgModuleStatement::variant() const
153708 : {
153709 : // This function is used in SAGE
153710 : ROSE_ASSERT(this != NULL);
153711 : return MODULE_STATEMENT;
153712 : }
153713 : #endif
153714 :
153715 : ROSE_DLL_API const char*
153716 0 : SgModuleStatement::sage_class_name() const
153717 : {
153718 0 : ROSE_ASSERT(this != NULL);
153719 0 : return "SgModuleStatement";
153720 : }
153721 :
153722 : std::string
153723 0 : SgModuleStatement::class_name() const
153724 : {
153725 0 : ROSE_ASSERT(this != NULL);
153726 0 : return "SgModuleStatement";
153727 : }
153728 :
153729 : // DQ (11/26/2005): Support for visitor pattern mechanims
153730 : // (inferior to ROSE traversal mechanism, experimental).
153731 : void
153732 0 : SgModuleStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
153733 : {
153734 0 : ROSE_ASSERT(this != NULL);
153735 0 : visitor.visit(this);
153736 0 : }
153737 :
153738 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
153739 0 : void SgModuleStatement::accept (ROSE_VisitorPattern & visitor) {
153740 0 : ROSE_ASSERT(this != NULL);
153741 0 : visitor.visit(this);
153742 0 : }
153743 :
153744 : SgModuleStatement*
153745 0 : SgModuleStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
153746 : {
153747 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
153748 : // This function is currently only supported for the AST used the represent Binary executables.
153749 : if (0 /* isSgAsmNode(this) != NULL */)
153750 : {
153751 : // Support for regex specification.
153752 : std::string prefixCode = "REGEX:";
153753 : addNewAttribute(prefixCode + s,a);
153754 : }
153755 : #endif
153756 :
153757 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
153758 0 : return this;
153759 : }
153760 :
153761 : // *** COMMON CODE SECTION ENDS HERE ***
153762 :
153763 :
153764 : // End of memberFunctionString
153765 : // Start of memberFunctionString
153766 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
153767 :
153768 :
153769 : #if 0
153770 : //! Error checking support
153771 : /*! Verifies the following:
153772 : - working getVariant() member function
153773 : - calls base class's error() member function
153774 : Every class has one of these functions.
153775 : */
153776 : bool
153777 : SgModuleStatement::error()
153778 : {
153779 : // Put error checking here
153780 :
153781 : ROSE_ASSERT (this != NULL);
153782 : if (getVariant() != MODULE_STATEMENT)
153783 : {
153784 : printf ("Error in SgModuleStatement::error(): SgModuleStatement object has a %s variant \n",
153785 : Cxx_GrammarTerminalNames[getVariant()].name);
153786 : // printf ("Error in SgModuleStatement::error() \n");
153787 : ROSE_ABORT();
153788 : }
153789 :
153790 : ROSE_ASSERT (getVariant() == MODULE_STATEMENT);
153791 : return SgClassDeclaration::error();
153792 : }
153793 : #endif
153794 :
153795 :
153796 :
153797 : // End of memberFunctionString
153798 :
153799 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
153800 :
153801 1342 : SgModuleStatement* isSgModuleStatement ( SgNode* inputDerivedClassPointer )
153802 : {
153803 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
153804 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
153805 : // So to fix this we return NULL directly when the input is NULL and avoid the
153806 : // dynamic_cast in this case. This is likely a performance improvement as well.
153807 : // return dynamic_cast<SgModuleStatement*>(inputDerivedClassPointer);
153808 : // Milind Chabbi (8/28/2013): isSgModuleStatement uses table-driven castability instead of c++ default dynamic_cast
153809 : // this improves the running time performance by 10-20%.
153810 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModuleStatement*>(inputDerivedClassPointer);
153811 1342 : return IS_SgModuleStatement_FAST_MACRO(inputDerivedClassPointer);
153812 : }
153813 :
153814 : // DQ (11/8/2003): Added version of functions taking const pointer
153815 0 : const SgModuleStatement* isSgModuleStatement ( const SgNode* inputDerivedClassPointer )
153816 : {
153817 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
153818 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
153819 : // So to fix this we return NULL directly when the input is NULL and avoid the
153820 : // dynamic_cast in this case. This is likely a performance improvement as well.
153821 : // return dynamic_cast<const SgModuleStatement*>(inputDerivedClassPointer);
153822 : // Milind Chabbi (8/28/2013): isSgModuleStatement uses table-driven castability instead of c++ default dynamic_cast
153823 : // this improves the running time performance by 10-20%.
153824 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModuleStatement*>(inputDerivedClassPointer);
153825 0 : return IS_SgModuleStatement_FAST_MACRO(inputDerivedClassPointer);
153826 : }
153827 :
153828 :
153829 :
153830 : /* #line 153831 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153831 :
153832 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
153833 :
153834 : /**
153835 : \brief Generated destructor
153836 :
153837 : This destructor is automatically generated (by ROSETTA). This destructor
153838 : only frees memory of data members associated with the parts of the current IR node which
153839 : are NOT traversed. Those data members that are part of a traversal can be freed using
153840 : a traversal (calling this destructor on all children in a post-order traversal). Such
153841 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
153842 :
153843 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
153844 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
153845 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
153846 :
153847 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
153848 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
153849 : pointers are not yet implemented to call delete on eash pointer in the container.
153850 : (This could be done by derivation from the STL containers to define containers that
153851 : automatically deleted their members.)
153852 :
153853 : */
153854 0 : SgModuleStatement::~SgModuleStatement () {
153855 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
153856 :
153857 :
153858 : // case: not a listType for end_numeric_label
153859 0 : p_end_numeric_label = NULL; // non list case
153860 :
153861 : }
153862 :
153863 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
153864 0 : }
153865 :
153866 :
153867 : /* #line 153868 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153868 :
153869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
153870 :
153871 : // Generated constructor
153872 0 : SgModuleStatement::SgModuleStatement ( Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition )
153873 0 : : SgClassDeclaration(startOfConstruct, name, class_type, type, definition)
153874 : {
153875 : #ifdef DEBUG
153876 : // printf ("In SgModuleStatement::SgModuleStatement (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition) sage_class_name() = %s \n",sage_class_name());
153877 : #endif
153878 : #if 0
153879 : // debugging information!
153880 : printf ("In SgModuleStatement::SgModuleStatement (Sg_File_Info* startOfConstruct, SgName name, SgClassDeclaration::class_types class_type, SgClassType* type, SgClassDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
153881 : #endif
153882 :
153883 0 : p_end_numeric_label = NULL;
153884 :
153885 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
153886 :
153887 : #if 0
153888 : // DQ (7/30/2014): Call a virtual function.
153889 : std::string s = this->class_name();
153890 : #endif
153891 :
153892 : // Test the variant virtual function
153893 : // assert(MODULE_STATEMENT == variant());
153894 0 : assert(MODULE_STATEMENT == this->variant());
153895 0 : ROSE_ASSERT(MODULE_STATEMENT == (int)(this->variantT()));
153896 0 : post_construction_initialization();
153897 :
153898 : // Test the isSgModuleStatement() function since it has been problematic
153899 0 : assert(isSgModuleStatement(this) != NULL);
153900 0 : }
153901 :
153902 : // Generated constructor (all data members)
153903 :
153904 : /* #line 153905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153905 :
153906 :
153907 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
153908 :
153909 :
153910 : // ********************************************************
153911 : // member functions common across all array grammar objects
153912 : // ********************************************************
153913 :
153914 :
153915 :
153916 : /* #line 153917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153917 :
153918 :
153919 :
153920 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
153921 :
153922 : // ********************************************************
153923 : // member functions specific to each node in the grammar
153924 : // ********************************************************
153925 :
153926 :
153927 : /* #line 153928 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
153928 :
153929 : // Start of memberFunctionString
153930 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
153931 :
153932 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
153933 :
153934 : bool
153935 6 : SgImplicitStatement::get_implicit_none () const
153936 : {
153937 6 : ROSE_ASSERT (this != NULL);
153938 :
153939 : #if 0
153940 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153941 : // used to trigger marking transformations for the token-based unparsing.
153942 : printf ("SgImplicitStatement::get_implicit_none = %p = %s \n",this,this->class_name().c_str());
153943 : #endif
153944 :
153945 6 : return p_implicit_none;
153946 : }
153947 :
153948 : void
153949 0 : SgImplicitStatement::set_implicit_none ( bool implicit_none )
153950 : {
153951 0 : ROSE_ASSERT (this != NULL);
153952 :
153953 : #if 0
153954 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153955 : // used to trigger marking transformations for the token-based unparsing.
153956 : printf ("SgImplicitStatement::set_implicit_none = %p = %s \n",this,this->class_name().c_str());
153957 : #endif
153958 :
153959 0 : set_isModified(true);
153960 :
153961 0 : p_implicit_none = implicit_none;
153962 0 : }
153963 :
153964 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
153965 :
153966 :
153967 : // End of memberFunctionString
153968 : // Start of memberFunctionString
153969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
153970 :
153971 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
153972 :
153973 : SgImplicitStatement::implicit_spec_enum
153974 6 : SgImplicitStatement::get_implicit_spec () const
153975 : {
153976 6 : ROSE_ASSERT (this != NULL);
153977 :
153978 : #if 0
153979 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153980 : // used to trigger marking transformations for the token-based unparsing.
153981 : printf ("SgImplicitStatement::get_implicit_spec = %p = %s \n",this,this->class_name().c_str());
153982 : #endif
153983 :
153984 6 : return p_implicit_spec;
153985 : }
153986 :
153987 : void
153988 0 : SgImplicitStatement::set_implicit_spec ( SgImplicitStatement::implicit_spec_enum implicit_spec )
153989 : {
153990 0 : ROSE_ASSERT (this != NULL);
153991 :
153992 : #if 0
153993 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
153994 : // used to trigger marking transformations for the token-based unparsing.
153995 : printf ("SgImplicitStatement::set_implicit_spec = %p = %s \n",this,this->class_name().c_str());
153996 : #endif
153997 :
153998 0 : set_isModified(true);
153999 :
154000 0 : p_implicit_spec = implicit_spec;
154001 0 : }
154002 :
154003 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
154004 :
154005 :
154006 : // End of memberFunctionString
154007 : // Start of memberFunctionString
154008 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
154009 :
154010 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
154011 :
154012 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
154013 : const SgInitializedNamePtrList &
154014 0 : SgImplicitStatement::get_variables () const
154015 : {
154016 0 : assert (this != NULL);
154017 0 : return p_variables;
154018 : }
154019 :
154020 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
154021 : SgInitializedNamePtrList &
154022 0 : SgImplicitStatement::get_variables ()
154023 : {
154024 0 : assert (this != NULL);
154025 :
154026 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
154027 : // As a rule only set_ access functions can set the isModified flag.
154028 : // set_isModified(true);
154029 :
154030 0 : return p_variables;
154031 : }
154032 :
154033 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
154034 :
154035 :
154036 : // End of memberFunctionString
154037 : // Start of memberFunctionString
154038 : /* #line 18531 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
154039 :
154040 : void
154041 6 : SgImplicitStatement::post_construction_initialization()
154042 6 : {}
154043 :
154044 : SgName
154045 6 : SgImplicitStatement::get_mangled_name() const
154046 : {
154047 : // printf ("Sorry, SgImplicitStatement::get_mangled_name() not implemented! \n");
154048 6 : return SgName("");
154049 : }
154050 :
154051 :
154052 : // End of memberFunctionString
154053 : // Start of memberFunctionString
154054 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
154055 :
154056 : // *** COMMON CODE SECTION BEGINS HERE ***
154057 :
154058 : #if 0
154059 : int
154060 : SgImplicitStatement::getVariant() const
154061 : {
154062 : // This function is used in ROSE while "variant()" is used in SAGE
154063 : assert(this != NULL);
154064 : return variant();
154065 : }
154066 : #endif
154067 :
154068 : // This function is used in ROSE in treeTraversal code
154069 : // eventually replaces getVariant() and variant()
154070 : // though after variant() has been removed for a while we will
154071 : // want to change the name of variantT() back to variant()
154072 : // (since the "T" was ment to stand for temporary).
154073 : // When this happens the variantT() will be depricated.
154074 : VariantT
154075 4722 : SgImplicitStatement::variantT() const
154076 : {
154077 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
154078 4722 : ROSE_ASSERT(this != NULL);
154079 4722 : return V_SgImplicitStatement;
154080 : }
154081 :
154082 : #if 0
154083 : int
154084 : SgImplicitStatement::variant() const
154085 : {
154086 : // This function is used in SAGE
154087 : ROSE_ASSERT(this != NULL);
154088 : return TEMP_Implicit_Statement;
154089 : }
154090 : #endif
154091 :
154092 : ROSE_DLL_API const char*
154093 12 : SgImplicitStatement::sage_class_name() const
154094 : {
154095 12 : ROSE_ASSERT(this != NULL);
154096 12 : return "SgImplicitStatement";
154097 : }
154098 :
154099 : std::string
154100 6 : SgImplicitStatement::class_name() const
154101 : {
154102 6 : ROSE_ASSERT(this != NULL);
154103 6 : return "SgImplicitStatement";
154104 : }
154105 :
154106 : // DQ (11/26/2005): Support for visitor pattern mechanims
154107 : // (inferior to ROSE traversal mechanism, experimental).
154108 : void
154109 0 : SgImplicitStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
154110 : {
154111 0 : ROSE_ASSERT(this != NULL);
154112 0 : visitor.visit(this);
154113 0 : }
154114 :
154115 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
154116 0 : void SgImplicitStatement::accept (ROSE_VisitorPattern & visitor) {
154117 0 : ROSE_ASSERT(this != NULL);
154118 0 : visitor.visit(this);
154119 0 : }
154120 :
154121 : SgImplicitStatement*
154122 0 : SgImplicitStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
154123 : {
154124 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
154125 : // This function is currently only supported for the AST used the represent Binary executables.
154126 : if (0 /* isSgAsmNode(this) != NULL */)
154127 : {
154128 : // Support for regex specification.
154129 : std::string prefixCode = "REGEX:";
154130 : addNewAttribute(prefixCode + s,a);
154131 : }
154132 : #endif
154133 :
154134 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
154135 0 : return this;
154136 : }
154137 :
154138 : // *** COMMON CODE SECTION ENDS HERE ***
154139 :
154140 :
154141 : // End of memberFunctionString
154142 : // Start of memberFunctionString
154143 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
154144 :
154145 :
154146 : #if 0
154147 : //! Error checking support
154148 : /*! Verifies the following:
154149 : - working getVariant() member function
154150 : - calls base class's error() member function
154151 : Every class has one of these functions.
154152 : */
154153 : bool
154154 : SgImplicitStatement::error()
154155 : {
154156 : // Put error checking here
154157 :
154158 : ROSE_ASSERT (this != NULL);
154159 : if (getVariant() != TEMP_Implicit_Statement)
154160 : {
154161 : printf ("Error in SgImplicitStatement::error(): SgImplicitStatement object has a %s variant \n",
154162 : Cxx_GrammarTerminalNames[getVariant()].name);
154163 : // printf ("Error in SgImplicitStatement::error() \n");
154164 : ROSE_ABORT();
154165 : }
154166 :
154167 : ROSE_ASSERT (getVariant() == TEMP_Implicit_Statement);
154168 : return SgDeclarationStatement::error();
154169 : }
154170 : #endif
154171 :
154172 :
154173 :
154174 : // End of memberFunctionString
154175 :
154176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
154177 :
154178 172 : SgImplicitStatement* isSgImplicitStatement ( SgNode* inputDerivedClassPointer )
154179 : {
154180 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
154181 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
154182 : // So to fix this we return NULL directly when the input is NULL and avoid the
154183 : // dynamic_cast in this case. This is likely a performance improvement as well.
154184 : // return dynamic_cast<SgImplicitStatement*>(inputDerivedClassPointer);
154185 : // Milind Chabbi (8/28/2013): isSgImplicitStatement uses table-driven castability instead of c++ default dynamic_cast
154186 : // this improves the running time performance by 10-20%.
154187 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgImplicitStatement*>(inputDerivedClassPointer);
154188 172 : return IS_SgImplicitStatement_FAST_MACRO(inputDerivedClassPointer);
154189 : }
154190 :
154191 : // DQ (11/8/2003): Added version of functions taking const pointer
154192 0 : const SgImplicitStatement* isSgImplicitStatement ( const SgNode* inputDerivedClassPointer )
154193 : {
154194 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
154195 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
154196 : // So to fix this we return NULL directly when the input is NULL and avoid the
154197 : // dynamic_cast in this case. This is likely a performance improvement as well.
154198 : // return dynamic_cast<const SgImplicitStatement*>(inputDerivedClassPointer);
154199 : // Milind Chabbi (8/28/2013): isSgImplicitStatement uses table-driven castability instead of c++ default dynamic_cast
154200 : // this improves the running time performance by 10-20%.
154201 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgImplicitStatement*>(inputDerivedClassPointer);
154202 0 : return IS_SgImplicitStatement_FAST_MACRO(inputDerivedClassPointer);
154203 : }
154204 :
154205 :
154206 :
154207 : /* #line 154208 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154208 :
154209 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
154210 :
154211 : /**
154212 : \brief Generated destructor
154213 :
154214 : This destructor is automatically generated (by ROSETTA). This destructor
154215 : only frees memory of data members associated with the parts of the current IR node which
154216 : are NOT traversed. Those data members that are part of a traversal can be freed using
154217 : a traversal (calling this destructor on all children in a post-order traversal). Such
154218 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
154219 :
154220 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
154221 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
154222 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
154223 :
154224 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
154225 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
154226 : pointers are not yet implemented to call delete on eash pointer in the container.
154227 : (This could be done by derivation from the STL containers to define containers that
154228 : automatically deleted their members.)
154229 :
154230 : */
154231 0 : SgImplicitStatement::~SgImplicitStatement () {
154232 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
154233 :
154234 :
154235 : // case: not a listType for implicit_none
154236 0 : p_implicit_none = false; // non list case
154237 : // case: not a listType for implicit_spec
154238 0 : p_implicit_spec = SgImplicitStatement::e_unknown_implicit_spec; // non list case
154239 :
154240 : }
154241 :
154242 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
154243 0 : }
154244 :
154245 :
154246 : /* #line 154247 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154247 :
154248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
154249 :
154250 : // Generated constructor
154251 0 : SgImplicitStatement::SgImplicitStatement ( Sg_File_Info* startOfConstruct, bool implicit_none )
154252 0 : : SgDeclarationStatement(startOfConstruct)
154253 : {
154254 : #ifdef DEBUG
154255 : // printf ("In SgImplicitStatement::SgImplicitStatement (Sg_File_Info* startOfConstruct, bool implicit_none) sage_class_name() = %s \n",sage_class_name());
154256 : #endif
154257 : #if 0
154258 : // debugging information!
154259 : printf ("In SgImplicitStatement::SgImplicitStatement (Sg_File_Info* startOfConstruct, bool implicit_none): this = %p = %s \n",this,this->class_name().c_str());
154260 : #endif
154261 :
154262 0 : p_implicit_none = implicit_none;
154263 0 : p_implicit_spec = SgImplicitStatement::e_unknown_implicit_spec;
154264 :
154265 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
154266 :
154267 : #if 0
154268 : // DQ (7/30/2014): Call a virtual function.
154269 : std::string s = this->class_name();
154270 : #endif
154271 :
154272 : // Test the variant virtual function
154273 : // assert(TEMP_Implicit_Statement == variant());
154274 0 : assert(TEMP_Implicit_Statement == this->variant());
154275 0 : ROSE_ASSERT(TEMP_Implicit_Statement == (int)(this->variantT()));
154276 0 : post_construction_initialization();
154277 :
154278 : // Test the isSgImplicitStatement() function since it has been problematic
154279 0 : assert(isSgImplicitStatement(this) != NULL);
154280 0 : }
154281 :
154282 : // Generated constructor (all data members)
154283 :
154284 : /* #line 154285 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154285 :
154286 :
154287 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
154288 :
154289 :
154290 : // ********************************************************
154291 : // member functions common across all array grammar objects
154292 : // ********************************************************
154293 :
154294 :
154295 :
154296 : /* #line 154297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154297 :
154298 :
154299 :
154300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
154301 :
154302 : // ********************************************************
154303 : // member functions specific to each node in the grammar
154304 : // ********************************************************
154305 :
154306 :
154307 : /* #line 154308 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154308 :
154309 : // Start of memberFunctionString
154310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
154311 :
154312 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
154313 :
154314 : SgDeclarationStatement*
154315 15864 : SgUsingDeclarationStatement::get_declaration () const
154316 : {
154317 15864 : ROSE_ASSERT (this != NULL);
154318 :
154319 : #if 0
154320 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
154321 : // used to trigger marking transformations for the token-based unparsing.
154322 : printf ("SgUsingDeclarationStatement::get_declaration = %p = %s \n",this,this->class_name().c_str());
154323 : #endif
154324 :
154325 15864 : return p_declaration;
154326 : }
154327 :
154328 : void
154329 0 : SgUsingDeclarationStatement::set_declaration ( SgDeclarationStatement* declaration )
154330 : {
154331 0 : ROSE_ASSERT (this != NULL);
154332 :
154333 : #if 0
154334 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
154335 : // used to trigger marking transformations for the token-based unparsing.
154336 : printf ("SgUsingDeclarationStatement::set_declaration = %p = %s \n",this,this->class_name().c_str());
154337 : #endif
154338 :
154339 0 : set_isModified(true);
154340 :
154341 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
154342 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
154343 : {
154344 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
154345 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
154346 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
154347 : ROSE_ASSERT(false);
154348 : #endif
154349 : }
154350 : #endif
154351 0 : p_declaration = declaration;
154352 0 : }
154353 :
154354 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
154355 :
154356 :
154357 : // End of memberFunctionString
154358 : // Start of memberFunctionString
154359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
154360 :
154361 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
154362 :
154363 : SgInitializedName*
154364 6509 : SgUsingDeclarationStatement::get_initializedName () const
154365 : {
154366 6509 : ROSE_ASSERT (this != NULL);
154367 :
154368 : #if 0
154369 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
154370 : // used to trigger marking transformations for the token-based unparsing.
154371 : printf ("SgUsingDeclarationStatement::get_initializedName = %p = %s \n",this,this->class_name().c_str());
154372 : #endif
154373 :
154374 6509 : return p_initializedName;
154375 : }
154376 :
154377 : void
154378 0 : SgUsingDeclarationStatement::set_initializedName ( SgInitializedName* initializedName )
154379 : {
154380 0 : ROSE_ASSERT (this != NULL);
154381 :
154382 : #if 0
154383 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
154384 : // used to trigger marking transformations for the token-based unparsing.
154385 : printf ("SgUsingDeclarationStatement::set_initializedName = %p = %s \n",this,this->class_name().c_str());
154386 : #endif
154387 :
154388 0 : set_isModified(true);
154389 :
154390 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
154391 : if (p_initializedName != NULL && initializedName != NULL && p_initializedName != initializedName)
154392 : {
154393 : printf ("Warning: initializedName = %p overwriting valid pointer p_initializedName = %p \n",initializedName,p_initializedName);
154394 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
154395 : printf ("Error fails assertion (p_initializedName != NULL && initializedName != NULL && p_initializedName != initializedName) is false\n");
154396 : ROSE_ASSERT(false);
154397 : #endif
154398 : }
154399 : #endif
154400 0 : p_initializedName = initializedName;
154401 0 : }
154402 :
154403 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
154404 :
154405 :
154406 : // End of memberFunctionString
154407 : // Start of memberFunctionString
154408 :
154409 :
154410 : // End of memberFunctionString
154411 : // Start of memberFunctionString
154412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
154413 :
154414 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
154415 :
154416 : bool
154417 3263 : SgUsingDeclarationStatement::get_is_inheriting_constructor () const
154418 : {
154419 3263 : ROSE_ASSERT (this != NULL);
154420 :
154421 : #if 0
154422 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
154423 : // used to trigger marking transformations for the token-based unparsing.
154424 : printf ("SgUsingDeclarationStatement::get_is_inheriting_constructor = %p = %s \n",this,this->class_name().c_str());
154425 : #endif
154426 :
154427 3263 : return p_is_inheriting_constructor;
154428 : }
154429 :
154430 : void
154431 0 : SgUsingDeclarationStatement::set_is_inheriting_constructor ( bool is_inheriting_constructor )
154432 : {
154433 0 : ROSE_ASSERT (this != NULL);
154434 :
154435 : #if 0
154436 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
154437 : // used to trigger marking transformations for the token-based unparsing.
154438 : printf ("SgUsingDeclarationStatement::set_is_inheriting_constructor = %p = %s \n",this,this->class_name().c_str());
154439 : #endif
154440 :
154441 0 : set_isModified(true);
154442 :
154443 0 : p_is_inheriting_constructor = is_inheriting_constructor;
154444 0 : }
154445 :
154446 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
154447 :
154448 :
154449 : // End of memberFunctionString
154450 : // Start of memberFunctionString
154451 : /* #line 17779 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
154452 :
154453 :
154454 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
154455 : SgName
154456 2525 : SgUsingDeclarationStatement::get_mangled_name(void) const
154457 : {
154458 2525 : SgName returnName;
154459 :
154460 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
154461 2525 : SgScopeStatement* scope = get_scope();
154462 2525 : ROSE_ASSERT(scope != NULL);
154463 :
154464 2525 : SgName name;
154465 2525 : if (get_declaration() != NULL)
154466 2488 : name = get_declaration()->get_mangled_name();
154467 : else
154468 : {
154469 37 : ROSE_ASSERT(get_initializedName() != NULL);
154470 37 : name = get_initializedName()->get_mangled_name();
154471 : }
154472 :
154473 : // DQ (2/22/2007): Use mangled name support in scopes instead of the qualified name (to avoid "::" substrings in mangled names).
154474 : // This is a poor way to handle the generation of a mangled name (will be improved)
154475 : // returnName = scope->get_qualified_name() + SgName("_using_declaration_") + name;
154476 2525 : returnName = scope->get_mangled_name() + SgName("_using_declaration_") + name;
154477 :
154478 2525 : return returnName;
154479 : }
154480 :
154481 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
154482 : // so that we could avoid them setting the isModified flag which is a problem in the
154483 : // name qualification support for C++ (interfering with the token-based unparsing).
154484 : int
154485 20 : SgUsingDeclarationStatement::get_name_qualification_length () const
154486 : {
154487 20 : ROSE_ASSERT (this != NULL);
154488 20 : return p_name_qualification_length;
154489 : }
154490 :
154491 : void
154492 3313 : SgUsingDeclarationStatement::set_name_qualification_length ( int name_qualification_length )
154493 : {
154494 3313 : ROSE_ASSERT (this != NULL);
154495 : // This can't be called by the name qualification API (see test2015_26.C).
154496 : // set_isModified(true);
154497 :
154498 3313 : p_name_qualification_length = name_qualification_length;
154499 3313 : }
154500 :
154501 : bool
154502 0 : SgUsingDeclarationStatement::get_type_elaboration_required () const
154503 : {
154504 0 : ROSE_ASSERT (this != NULL);
154505 0 : return p_type_elaboration_required;
154506 : }
154507 :
154508 : void
154509 3313 : SgUsingDeclarationStatement::set_type_elaboration_required ( bool type_elaboration_required )
154510 : {
154511 3313 : ROSE_ASSERT (this != NULL);
154512 : // This can't be called by the name qualification API (see test2015_26.C).
154513 : // set_isModified(true);
154514 :
154515 3313 : p_type_elaboration_required = type_elaboration_required;
154516 3313 : }
154517 :
154518 : bool
154519 20 : SgUsingDeclarationStatement::get_global_qualification_required () const
154520 : {
154521 20 : ROSE_ASSERT (this != NULL);
154522 20 : return p_global_qualification_required;
154523 : }
154524 :
154525 : void
154526 3313 : SgUsingDeclarationStatement::set_global_qualification_required ( bool global_qualification_required )
154527 : {
154528 3313 : ROSE_ASSERT (this != NULL);
154529 :
154530 : // This can't be called by the name qualification API (see test2015_26.C).
154531 : // set_isModified(true);
154532 :
154533 3313 : p_global_qualification_required = global_qualification_required;
154534 3313 : }
154535 :
154536 :
154537 :
154538 : // End of memberFunctionString
154539 : // Start of memberFunctionString
154540 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
154541 :
154542 : void
154543 3038 : SgUsingDeclarationStatement::post_construction_initialization()
154544 : {
154545 3038 : }
154546 :
154547 :
154548 :
154549 : // End of memberFunctionString
154550 : // Start of memberFunctionString
154551 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
154552 :
154553 : // *** COMMON CODE SECTION BEGINS HERE ***
154554 :
154555 : #if 0
154556 : int
154557 : SgUsingDeclarationStatement::getVariant() const
154558 : {
154559 : // This function is used in ROSE while "variant()" is used in SAGE
154560 : assert(this != NULL);
154561 : return variant();
154562 : }
154563 : #endif
154564 :
154565 : // This function is used in ROSE in treeTraversal code
154566 : // eventually replaces getVariant() and variant()
154567 : // though after variant() has been removed for a while we will
154568 : // want to change the name of variantT() back to variant()
154569 : // (since the "T" was ment to stand for temporary).
154570 : // When this happens the variantT() will be depricated.
154571 : VariantT
154572 1657360 : SgUsingDeclarationStatement::variantT() const
154573 : {
154574 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
154575 1657360 : ROSE_ASSERT(this != NULL);
154576 1657360 : return V_SgUsingDeclarationStatement;
154577 : }
154578 :
154579 : #if 0
154580 : int
154581 : SgUsingDeclarationStatement::variant() const
154582 : {
154583 : // This function is used in SAGE
154584 : ROSE_ASSERT(this != NULL);
154585 : return USING_DECLARATION_STMT;
154586 : }
154587 : #endif
154588 :
154589 : ROSE_DLL_API const char*
154590 30 : SgUsingDeclarationStatement::sage_class_name() const
154591 : {
154592 30 : ROSE_ASSERT(this != NULL);
154593 30 : return "SgUsingDeclarationStatement";
154594 : }
154595 :
154596 : std::string
154597 2526 : SgUsingDeclarationStatement::class_name() const
154598 : {
154599 2526 : ROSE_ASSERT(this != NULL);
154600 2526 : return "SgUsingDeclarationStatement";
154601 : }
154602 :
154603 : // DQ (11/26/2005): Support for visitor pattern mechanims
154604 : // (inferior to ROSE traversal mechanism, experimental).
154605 : void
154606 38383 : SgUsingDeclarationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
154607 : {
154608 38383 : ROSE_ASSERT(this != NULL);
154609 38383 : visitor.visit(this);
154610 38383 : }
154611 :
154612 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
154613 0 : void SgUsingDeclarationStatement::accept (ROSE_VisitorPattern & visitor) {
154614 0 : ROSE_ASSERT(this != NULL);
154615 0 : visitor.visit(this);
154616 0 : }
154617 :
154618 : SgUsingDeclarationStatement*
154619 0 : SgUsingDeclarationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
154620 : {
154621 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
154622 : // This function is currently only supported for the AST used the represent Binary executables.
154623 : if (0 /* isSgAsmNode(this) != NULL */)
154624 : {
154625 : // Support for regex specification.
154626 : std::string prefixCode = "REGEX:";
154627 : addNewAttribute(prefixCode + s,a);
154628 : }
154629 : #endif
154630 :
154631 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
154632 0 : return this;
154633 : }
154634 :
154635 : // *** COMMON CODE SECTION ENDS HERE ***
154636 :
154637 :
154638 : // End of memberFunctionString
154639 : // Start of memberFunctionString
154640 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
154641 :
154642 :
154643 : #if 0
154644 : //! Error checking support
154645 : /*! Verifies the following:
154646 : - working getVariant() member function
154647 : - calls base class's error() member function
154648 : Every class has one of these functions.
154649 : */
154650 : bool
154651 : SgUsingDeclarationStatement::error()
154652 : {
154653 : // Put error checking here
154654 :
154655 : ROSE_ASSERT (this != NULL);
154656 : if (getVariant() != USING_DECLARATION_STMT)
154657 : {
154658 : printf ("Error in SgUsingDeclarationStatement::error(): SgUsingDeclarationStatement object has a %s variant \n",
154659 : Cxx_GrammarTerminalNames[getVariant()].name);
154660 : // printf ("Error in SgUsingDeclarationStatement::error() \n");
154661 : ROSE_ABORT();
154662 : }
154663 :
154664 : ROSE_ASSERT (getVariant() == USING_DECLARATION_STMT);
154665 : return SgDeclarationStatement::error();
154666 : }
154667 : #endif
154668 :
154669 :
154670 :
154671 : // End of memberFunctionString
154672 :
154673 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
154674 :
154675 11753700 : SgUsingDeclarationStatement* isSgUsingDeclarationStatement ( SgNode* inputDerivedClassPointer )
154676 : {
154677 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
154678 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
154679 : // So to fix this we return NULL directly when the input is NULL and avoid the
154680 : // dynamic_cast in this case. This is likely a performance improvement as well.
154681 : // return dynamic_cast<SgUsingDeclarationStatement*>(inputDerivedClassPointer);
154682 : // Milind Chabbi (8/28/2013): isSgUsingDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
154683 : // this improves the running time performance by 10-20%.
154684 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUsingDeclarationStatement*>(inputDerivedClassPointer);
154685 11753700 : return IS_SgUsingDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
154686 : }
154687 :
154688 : // DQ (11/8/2003): Added version of functions taking const pointer
154689 0 : const SgUsingDeclarationStatement* isSgUsingDeclarationStatement ( const SgNode* inputDerivedClassPointer )
154690 : {
154691 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
154692 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
154693 : // So to fix this we return NULL directly when the input is NULL and avoid the
154694 : // dynamic_cast in this case. This is likely a performance improvement as well.
154695 : // return dynamic_cast<const SgUsingDeclarationStatement*>(inputDerivedClassPointer);
154696 : // Milind Chabbi (8/28/2013): isSgUsingDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
154697 : // this improves the running time performance by 10-20%.
154698 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUsingDeclarationStatement*>(inputDerivedClassPointer);
154699 0 : return IS_SgUsingDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
154700 : }
154701 :
154702 :
154703 :
154704 : /* #line 154705 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154705 :
154706 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
154707 :
154708 : /**
154709 : \brief Generated destructor
154710 :
154711 : This destructor is automatically generated (by ROSETTA). This destructor
154712 : only frees memory of data members associated with the parts of the current IR node which
154713 : are NOT traversed. Those data members that are part of a traversal can be freed using
154714 : a traversal (calling this destructor on all children in a post-order traversal). Such
154715 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
154716 :
154717 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
154718 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
154719 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
154720 :
154721 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
154722 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
154723 : pointers are not yet implemented to call delete on eash pointer in the container.
154724 : (This could be done by derivation from the STL containers to define containers that
154725 : automatically deleted their members.)
154726 :
154727 : */
154728 1100 : SgUsingDeclarationStatement::~SgUsingDeclarationStatement () {
154729 550 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
154730 :
154731 :
154732 : // case: not a listType for declaration
154733 550 : p_declaration = NULL; // non list case
154734 : // case: not a listType for initializedName
154735 550 : p_initializedName = NULL; // non list case
154736 : // case: not a listType for name_qualification_length
154737 550 : p_name_qualification_length = 0; // non list case
154738 : // case: not a listType for type_elaboration_required
154739 550 : p_type_elaboration_required = false; // non list case
154740 : // case: not a listType for global_qualification_required
154741 550 : p_global_qualification_required = false; // non list case
154742 : // case: not a listType for is_inheriting_constructor
154743 550 : p_is_inheriting_constructor = false; // non list case
154744 :
154745 : }
154746 :
154747 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
154748 1100 : }
154749 :
154750 :
154751 : /* #line 154752 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154752 :
154753 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
154754 :
154755 : // Generated constructor
154756 0 : SgUsingDeclarationStatement::SgUsingDeclarationStatement ( Sg_File_Info* startOfConstruct, SgDeclarationStatement* declaration, SgInitializedName* initializedName )
154757 0 : : SgDeclarationStatement(startOfConstruct)
154758 : {
154759 : #ifdef DEBUG
154760 : // printf ("In SgUsingDeclarationStatement::SgUsingDeclarationStatement (Sg_File_Info* startOfConstruct, SgDeclarationStatement* declaration, SgInitializedName* initializedName) sage_class_name() = %s \n",sage_class_name());
154761 : #endif
154762 : #if 0
154763 : // debugging information!
154764 : printf ("In SgUsingDeclarationStatement::SgUsingDeclarationStatement (Sg_File_Info* startOfConstruct, SgDeclarationStatement* declaration, SgInitializedName* initializedName): this = %p = %s \n",this,this->class_name().c_str());
154765 : #endif
154766 :
154767 0 : p_declaration = declaration;
154768 0 : p_initializedName = initializedName;
154769 0 : p_name_qualification_length = 0;
154770 0 : p_type_elaboration_required = false;
154771 0 : p_global_qualification_required = false;
154772 0 : p_is_inheriting_constructor = false;
154773 :
154774 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
154775 :
154776 : #if 0
154777 : // DQ (7/30/2014): Call a virtual function.
154778 : std::string s = this->class_name();
154779 : #endif
154780 :
154781 : // Test the variant virtual function
154782 : // assert(USING_DECLARATION_STMT == variant());
154783 0 : assert(USING_DECLARATION_STMT == this->variant());
154784 0 : ROSE_ASSERT(USING_DECLARATION_STMT == (int)(this->variantT()));
154785 0 : post_construction_initialization();
154786 :
154787 : // Test the isSgUsingDeclarationStatement() function since it has been problematic
154788 0 : assert(isSgUsingDeclarationStatement(this) != NULL);
154789 0 : }
154790 :
154791 : // Generated constructor (all data members)
154792 :
154793 : /* #line 154794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154794 :
154795 :
154796 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
154797 :
154798 :
154799 : // ********************************************************
154800 : // member functions common across all array grammar objects
154801 : // ********************************************************
154802 :
154803 :
154804 :
154805 : /* #line 154806 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154806 :
154807 :
154808 :
154809 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
154810 :
154811 : // ********************************************************
154812 : // member functions specific to each node in the grammar
154813 : // ********************************************************
154814 :
154815 :
154816 : /* #line 154817 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
154817 :
154818 : // Start of memberFunctionString
154819 :
154820 :
154821 : // End of memberFunctionString
154822 : // Start of memberFunctionString
154823 : /* #line 18817 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
154824 :
154825 : void
154826 0 : SgNamelistStatement::post_construction_initialization()
154827 0 : {}
154828 :
154829 : SgName
154830 0 : SgNamelistStatement::get_mangled_name(void) const
154831 : {
154832 : // printf ("Sorry, SgNamelistStatement::get_mangled_name() not implemented! \n");
154833 0 : return SgName ("__namelist__");
154834 : }
154835 :
154836 : const SgNameGroupPtrList &
154837 0 : SgNamelistStatement::get_group_list() const
154838 : {
154839 0 : return p_group_list;
154840 : }
154841 :
154842 : SgNameGroupPtrList &
154843 0 : SgNamelistStatement::get_group_list()
154844 : {
154845 0 : return p_group_list;
154846 : }
154847 :
154848 :
154849 :
154850 : // End of memberFunctionString
154851 : // Start of memberFunctionString
154852 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
154853 :
154854 : // *** COMMON CODE SECTION BEGINS HERE ***
154855 :
154856 : #if 0
154857 : int
154858 : SgNamelistStatement::getVariant() const
154859 : {
154860 : // This function is used in ROSE while "variant()" is used in SAGE
154861 : assert(this != NULL);
154862 : return variant();
154863 : }
154864 : #endif
154865 :
154866 : // This function is used in ROSE in treeTraversal code
154867 : // eventually replaces getVariant() and variant()
154868 : // though after variant() has been removed for a while we will
154869 : // want to change the name of variantT() back to variant()
154870 : // (since the "T" was ment to stand for temporary).
154871 : // When this happens the variantT() will be depricated.
154872 : VariantT
154873 0 : SgNamelistStatement::variantT() const
154874 : {
154875 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
154876 0 : ROSE_ASSERT(this != NULL);
154877 0 : return V_SgNamelistStatement;
154878 : }
154879 :
154880 : #if 0
154881 : int
154882 : SgNamelistStatement::variant() const
154883 : {
154884 : // This function is used in SAGE
154885 : ROSE_ASSERT(this != NULL);
154886 : return TEMP_Namelist_Statement;
154887 : }
154888 : #endif
154889 :
154890 : ROSE_DLL_API const char*
154891 0 : SgNamelistStatement::sage_class_name() const
154892 : {
154893 0 : ROSE_ASSERT(this != NULL);
154894 0 : return "SgNamelistStatement";
154895 : }
154896 :
154897 : std::string
154898 0 : SgNamelistStatement::class_name() const
154899 : {
154900 0 : ROSE_ASSERT(this != NULL);
154901 0 : return "SgNamelistStatement";
154902 : }
154903 :
154904 : // DQ (11/26/2005): Support for visitor pattern mechanims
154905 : // (inferior to ROSE traversal mechanism, experimental).
154906 : void
154907 0 : SgNamelistStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
154908 : {
154909 0 : ROSE_ASSERT(this != NULL);
154910 0 : visitor.visit(this);
154911 0 : }
154912 :
154913 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
154914 0 : void SgNamelistStatement::accept (ROSE_VisitorPattern & visitor) {
154915 0 : ROSE_ASSERT(this != NULL);
154916 0 : visitor.visit(this);
154917 0 : }
154918 :
154919 : SgNamelistStatement*
154920 0 : SgNamelistStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
154921 : {
154922 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
154923 : // This function is currently only supported for the AST used the represent Binary executables.
154924 : if (0 /* isSgAsmNode(this) != NULL */)
154925 : {
154926 : // Support for regex specification.
154927 : std::string prefixCode = "REGEX:";
154928 : addNewAttribute(prefixCode + s,a);
154929 : }
154930 : #endif
154931 :
154932 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
154933 0 : return this;
154934 : }
154935 :
154936 : // *** COMMON CODE SECTION ENDS HERE ***
154937 :
154938 :
154939 : // End of memberFunctionString
154940 : // Start of memberFunctionString
154941 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
154942 :
154943 :
154944 : #if 0
154945 : //! Error checking support
154946 : /*! Verifies the following:
154947 : - working getVariant() member function
154948 : - calls base class's error() member function
154949 : Every class has one of these functions.
154950 : */
154951 : bool
154952 : SgNamelistStatement::error()
154953 : {
154954 : // Put error checking here
154955 :
154956 : ROSE_ASSERT (this != NULL);
154957 : if (getVariant() != TEMP_Namelist_Statement)
154958 : {
154959 : printf ("Error in SgNamelistStatement::error(): SgNamelistStatement object has a %s variant \n",
154960 : Cxx_GrammarTerminalNames[getVariant()].name);
154961 : // printf ("Error in SgNamelistStatement::error() \n");
154962 : ROSE_ABORT();
154963 : }
154964 :
154965 : ROSE_ASSERT (getVariant() == TEMP_Namelist_Statement);
154966 : return SgDeclarationStatement::error();
154967 : }
154968 : #endif
154969 :
154970 :
154971 :
154972 : // End of memberFunctionString
154973 :
154974 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
154975 :
154976 0 : SgNamelistStatement* isSgNamelistStatement ( SgNode* inputDerivedClassPointer )
154977 : {
154978 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
154979 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
154980 : // So to fix this we return NULL directly when the input is NULL and avoid the
154981 : // dynamic_cast in this case. This is likely a performance improvement as well.
154982 : // return dynamic_cast<SgNamelistStatement*>(inputDerivedClassPointer);
154983 : // Milind Chabbi (8/28/2013): isSgNamelistStatement uses table-driven castability instead of c++ default dynamic_cast
154984 : // this improves the running time performance by 10-20%.
154985 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNamelistStatement*>(inputDerivedClassPointer);
154986 0 : return IS_SgNamelistStatement_FAST_MACRO(inputDerivedClassPointer);
154987 : }
154988 :
154989 : // DQ (11/8/2003): Added version of functions taking const pointer
154990 0 : const SgNamelistStatement* isSgNamelistStatement ( const SgNode* inputDerivedClassPointer )
154991 : {
154992 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
154993 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
154994 : // So to fix this we return NULL directly when the input is NULL and avoid the
154995 : // dynamic_cast in this case. This is likely a performance improvement as well.
154996 : // return dynamic_cast<const SgNamelistStatement*>(inputDerivedClassPointer);
154997 : // Milind Chabbi (8/28/2013): isSgNamelistStatement uses table-driven castability instead of c++ default dynamic_cast
154998 : // this improves the running time performance by 10-20%.
154999 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNamelistStatement*>(inputDerivedClassPointer);
155000 0 : return IS_SgNamelistStatement_FAST_MACRO(inputDerivedClassPointer);
155001 : }
155002 :
155003 :
155004 :
155005 : /* #line 155006 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155006 :
155007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
155008 :
155009 : /**
155010 : \brief Generated destructor
155011 :
155012 : This destructor is automatically generated (by ROSETTA). This destructor
155013 : only frees memory of data members associated with the parts of the current IR node which
155014 : are NOT traversed. Those data members that are part of a traversal can be freed using
155015 : a traversal (calling this destructor on all children in a post-order traversal). Such
155016 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
155017 :
155018 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
155019 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
155020 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
155021 :
155022 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
155023 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
155024 : pointers are not yet implemented to call delete on eash pointer in the container.
155025 : (This could be done by derivation from the STL containers to define containers that
155026 : automatically deleted their members.)
155027 :
155028 : */
155029 0 : SgNamelistStatement::~SgNamelistStatement () {
155030 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
155031 :
155032 :
155033 :
155034 : }
155035 :
155036 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
155037 0 : }
155038 :
155039 :
155040 : /* #line 155041 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155041 :
155042 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
155043 :
155044 : // Generated constructor
155045 0 : SgNamelistStatement::SgNamelistStatement ( Sg_File_Info* startOfConstruct )
155046 0 : : SgDeclarationStatement(startOfConstruct)
155047 : {
155048 : #ifdef DEBUG
155049 : // printf ("In SgNamelistStatement::SgNamelistStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
155050 : #endif
155051 : #if 0
155052 : // debugging information!
155053 : printf ("In SgNamelistStatement::SgNamelistStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
155054 : #endif
155055 :
155056 :
155057 :
155058 : #if 0
155059 : // DQ (7/30/2014): Call a virtual function.
155060 : std::string s = this->class_name();
155061 : #endif
155062 :
155063 : // Test the variant virtual function
155064 : // assert(TEMP_Namelist_Statement == variant());
155065 0 : assert(TEMP_Namelist_Statement == this->variant());
155066 0 : ROSE_ASSERT(TEMP_Namelist_Statement == (int)(this->variantT()));
155067 0 : post_construction_initialization();
155068 :
155069 : // Test the isSgNamelistStatement() function since it has been problematic
155070 0 : assert(isSgNamelistStatement(this) != NULL);
155071 0 : }
155072 :
155073 : // Generated constructor (all data members)
155074 :
155075 : /* #line 155076 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155076 :
155077 :
155078 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
155079 :
155080 :
155081 : // ********************************************************
155082 : // member functions common across all array grammar objects
155083 : // ********************************************************
155084 :
155085 :
155086 :
155087 : /* #line 155088 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155088 :
155089 :
155090 :
155091 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
155092 :
155093 : // ********************************************************
155094 : // member functions specific to each node in the grammar
155095 : // ********************************************************
155096 :
155097 :
155098 : /* #line 155099 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155099 :
155100 : // Start of memberFunctionString
155101 :
155102 :
155103 : // End of memberFunctionString
155104 : // Start of memberFunctionString
155105 : /* #line 18845 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
155106 :
155107 : void
155108 0 : SgImportStatement::post_construction_initialization()
155109 0 : {}
155110 :
155111 : SgName
155112 0 : SgImportStatement::get_mangled_name(void) const
155113 : {
155114 : // printf ("Sorry, SgImportStatement::get_mangled_name() not implemented! \n");
155115 0 : return SgName ("__import__");
155116 : }
155117 :
155118 : const SgExpressionPtrList &
155119 0 : SgImportStatement::get_import_list() const
155120 : {
155121 0 : return p_import_list;
155122 : }
155123 :
155124 : SgExpressionPtrList &
155125 0 : SgImportStatement::get_import_list()
155126 : {
155127 0 : return p_import_list;
155128 : }
155129 :
155130 :
155131 :
155132 : // End of memberFunctionString
155133 : // Start of memberFunctionString
155134 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
155135 :
155136 : // *** COMMON CODE SECTION BEGINS HERE ***
155137 :
155138 : #if 0
155139 : int
155140 : SgImportStatement::getVariant() const
155141 : {
155142 : // This function is used in ROSE while "variant()" is used in SAGE
155143 : assert(this != NULL);
155144 : return variant();
155145 : }
155146 : #endif
155147 :
155148 : // This function is used in ROSE in treeTraversal code
155149 : // eventually replaces getVariant() and variant()
155150 : // though after variant() has been removed for a while we will
155151 : // want to change the name of variantT() back to variant()
155152 : // (since the "T" was ment to stand for temporary).
155153 : // When this happens the variantT() will be depricated.
155154 : VariantT
155155 0 : SgImportStatement::variantT() const
155156 : {
155157 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
155158 0 : ROSE_ASSERT(this != NULL);
155159 0 : return V_SgImportStatement;
155160 : }
155161 :
155162 : #if 0
155163 : int
155164 : SgImportStatement::variant() const
155165 : {
155166 : // This function is used in SAGE
155167 : ROSE_ASSERT(this != NULL);
155168 : return TEMP_Import_Statement;
155169 : }
155170 : #endif
155171 :
155172 : ROSE_DLL_API const char*
155173 0 : SgImportStatement::sage_class_name() const
155174 : {
155175 0 : ROSE_ASSERT(this != NULL);
155176 0 : return "SgImportStatement";
155177 : }
155178 :
155179 : std::string
155180 0 : SgImportStatement::class_name() const
155181 : {
155182 0 : ROSE_ASSERT(this != NULL);
155183 0 : return "SgImportStatement";
155184 : }
155185 :
155186 : // DQ (11/26/2005): Support for visitor pattern mechanims
155187 : // (inferior to ROSE traversal mechanism, experimental).
155188 : void
155189 0 : SgImportStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
155190 : {
155191 0 : ROSE_ASSERT(this != NULL);
155192 0 : visitor.visit(this);
155193 0 : }
155194 :
155195 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
155196 0 : void SgImportStatement::accept (ROSE_VisitorPattern & visitor) {
155197 0 : ROSE_ASSERT(this != NULL);
155198 0 : visitor.visit(this);
155199 0 : }
155200 :
155201 : SgImportStatement*
155202 0 : SgImportStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
155203 : {
155204 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
155205 : // This function is currently only supported for the AST used the represent Binary executables.
155206 : if (0 /* isSgAsmNode(this) != NULL */)
155207 : {
155208 : // Support for regex specification.
155209 : std::string prefixCode = "REGEX:";
155210 : addNewAttribute(prefixCode + s,a);
155211 : }
155212 : #endif
155213 :
155214 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
155215 0 : return this;
155216 : }
155217 :
155218 : // *** COMMON CODE SECTION ENDS HERE ***
155219 :
155220 :
155221 : // End of memberFunctionString
155222 : // Start of memberFunctionString
155223 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
155224 :
155225 :
155226 : #if 0
155227 : //! Error checking support
155228 : /*! Verifies the following:
155229 : - working getVariant() member function
155230 : - calls base class's error() member function
155231 : Every class has one of these functions.
155232 : */
155233 : bool
155234 : SgImportStatement::error()
155235 : {
155236 : // Put error checking here
155237 :
155238 : ROSE_ASSERT (this != NULL);
155239 : if (getVariant() != TEMP_Import_Statement)
155240 : {
155241 : printf ("Error in SgImportStatement::error(): SgImportStatement object has a %s variant \n",
155242 : Cxx_GrammarTerminalNames[getVariant()].name);
155243 : // printf ("Error in SgImportStatement::error() \n");
155244 : ROSE_ABORT();
155245 : }
155246 :
155247 : ROSE_ASSERT (getVariant() == TEMP_Import_Statement);
155248 : return SgDeclarationStatement::error();
155249 : }
155250 : #endif
155251 :
155252 :
155253 :
155254 : // End of memberFunctionString
155255 :
155256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
155257 :
155258 0 : SgImportStatement* isSgImportStatement ( SgNode* inputDerivedClassPointer )
155259 : {
155260 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
155261 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
155262 : // So to fix this we return NULL directly when the input is NULL and avoid the
155263 : // dynamic_cast in this case. This is likely a performance improvement as well.
155264 : // return dynamic_cast<SgImportStatement*>(inputDerivedClassPointer);
155265 : // Milind Chabbi (8/28/2013): isSgImportStatement uses table-driven castability instead of c++ default dynamic_cast
155266 : // this improves the running time performance by 10-20%.
155267 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgImportStatement*>(inputDerivedClassPointer);
155268 0 : return IS_SgImportStatement_FAST_MACRO(inputDerivedClassPointer);
155269 : }
155270 :
155271 : // DQ (11/8/2003): Added version of functions taking const pointer
155272 0 : const SgImportStatement* isSgImportStatement ( const SgNode* inputDerivedClassPointer )
155273 : {
155274 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
155275 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
155276 : // So to fix this we return NULL directly when the input is NULL and avoid the
155277 : // dynamic_cast in this case. This is likely a performance improvement as well.
155278 : // return dynamic_cast<const SgImportStatement*>(inputDerivedClassPointer);
155279 : // Milind Chabbi (8/28/2013): isSgImportStatement uses table-driven castability instead of c++ default dynamic_cast
155280 : // this improves the running time performance by 10-20%.
155281 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgImportStatement*>(inputDerivedClassPointer);
155282 0 : return IS_SgImportStatement_FAST_MACRO(inputDerivedClassPointer);
155283 : }
155284 :
155285 :
155286 :
155287 : /* #line 155288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155288 :
155289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
155290 :
155291 : /**
155292 : \brief Generated destructor
155293 :
155294 : This destructor is automatically generated (by ROSETTA). This destructor
155295 : only frees memory of data members associated with the parts of the current IR node which
155296 : are NOT traversed. Those data members that are part of a traversal can be freed using
155297 : a traversal (calling this destructor on all children in a post-order traversal). Such
155298 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
155299 :
155300 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
155301 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
155302 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
155303 :
155304 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
155305 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
155306 : pointers are not yet implemented to call delete on eash pointer in the container.
155307 : (This could be done by derivation from the STL containers to define containers that
155308 : automatically deleted their members.)
155309 :
155310 : */
155311 0 : SgImportStatement::~SgImportStatement () {
155312 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
155313 :
155314 :
155315 :
155316 : }
155317 :
155318 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
155319 0 : }
155320 :
155321 :
155322 : /* #line 155323 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155323 :
155324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
155325 :
155326 : // Generated constructor
155327 0 : SgImportStatement::SgImportStatement ( Sg_File_Info* startOfConstruct )
155328 0 : : SgDeclarationStatement(startOfConstruct)
155329 : {
155330 : #ifdef DEBUG
155331 : // printf ("In SgImportStatement::SgImportStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
155332 : #endif
155333 : #if 0
155334 : // debugging information!
155335 : printf ("In SgImportStatement::SgImportStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
155336 : #endif
155337 :
155338 :
155339 :
155340 : #if 0
155341 : // DQ (7/30/2014): Call a virtual function.
155342 : std::string s = this->class_name();
155343 : #endif
155344 :
155345 : // Test the variant virtual function
155346 : // assert(TEMP_Import_Statement == variant());
155347 0 : assert(TEMP_Import_Statement == this->variant());
155348 0 : ROSE_ASSERT(TEMP_Import_Statement == (int)(this->variantT()));
155349 0 : post_construction_initialization();
155350 :
155351 : // Test the isSgImportStatement() function since it has been problematic
155352 0 : assert(isSgImportStatement(this) != NULL);
155353 0 : }
155354 :
155355 : // Generated constructor (all data members)
155356 :
155357 : /* #line 155358 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155358 :
155359 :
155360 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
155361 :
155362 :
155363 : // ********************************************************
155364 : // member functions common across all array grammar objects
155365 : // ********************************************************
155366 :
155367 :
155368 :
155369 : /* #line 155370 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155370 :
155371 :
155372 :
155373 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
155374 :
155375 : // ********************************************************
155376 : // member functions specific to each node in the grammar
155377 : // ********************************************************
155378 :
155379 :
155380 : /* #line 155381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
155381 :
155382 : // Start of memberFunctionString
155383 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155384 :
155385 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155386 :
155387 : SgName
155388 19240000 : SgFunctionDeclaration::get_name () const
155389 : {
155390 19240000 : ROSE_ASSERT (this != NULL);
155391 :
155392 : #if 0
155393 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155394 : // used to trigger marking transformations for the token-based unparsing.
155395 : printf ("SgFunctionDeclaration::get_name = %p = %s \n",this,this->class_name().c_str());
155396 : #endif
155397 :
155398 19240000 : return p_name;
155399 : }
155400 :
155401 : void
155402 28 : SgFunctionDeclaration::set_name ( SgName name )
155403 : {
155404 28 : ROSE_ASSERT (this != NULL);
155405 :
155406 : #if 0
155407 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155408 : // used to trigger marking transformations for the token-based unparsing.
155409 : printf ("SgFunctionDeclaration::set_name = %p = %s \n",this,this->class_name().c_str());
155410 : #endif
155411 :
155412 28 : set_isModified(true);
155413 :
155414 28 : p_name = name;
155415 28 : }
155416 :
155417 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155418 :
155419 :
155420 : // End of memberFunctionString
155421 : // Start of memberFunctionString
155422 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155423 :
155424 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155425 :
155426 : SgFunctionParameterList*
155427 15480900 : SgFunctionDeclaration::get_parameterList () const
155428 : {
155429 15480900 : ROSE_ASSERT (this != NULL);
155430 :
155431 : #if 0
155432 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155433 : // used to trigger marking transformations for the token-based unparsing.
155434 : printf ("SgFunctionDeclaration::get_parameterList = %p = %s \n",this,this->class_name().c_str());
155435 : #endif
155436 :
155437 15480900 : return p_parameterList;
155438 : }
155439 :
155440 : void
155441 3522520 : SgFunctionDeclaration::set_parameterList ( SgFunctionParameterList* parameterList )
155442 : {
155443 3522520 : ROSE_ASSERT (this != NULL);
155444 :
155445 : #if 0
155446 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155447 : // used to trigger marking transformations for the token-based unparsing.
155448 : printf ("SgFunctionDeclaration::set_parameterList = %p = %s \n",this,this->class_name().c_str());
155449 : #endif
155450 :
155451 3522520 : set_isModified(true);
155452 :
155453 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
155454 : if (p_parameterList != NULL && parameterList != NULL && p_parameterList != parameterList)
155455 : {
155456 : printf ("Warning: parameterList = %p overwriting valid pointer p_parameterList = %p \n",parameterList,p_parameterList);
155457 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
155458 : printf ("Error fails assertion (p_parameterList != NULL && parameterList != NULL && p_parameterList != parameterList) is false\n");
155459 : ROSE_ASSERT(false);
155460 : #endif
155461 : }
155462 : #endif
155463 3522520 : p_parameterList = parameterList;
155464 3522520 : }
155465 :
155466 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155467 :
155468 :
155469 : // End of memberFunctionString
155470 : // Start of memberFunctionString
155471 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
155472 :
155473 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155474 :
155475 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
155476 : const SgFunctionModifier &
155477 1071060 : SgFunctionDeclaration::get_functionModifier () const
155478 : {
155479 1071060 : assert (this != NULL);
155480 1071060 : return p_functionModifier;
155481 : }
155482 :
155483 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
155484 : SgFunctionModifier &
155485 1395420 : SgFunctionDeclaration::get_functionModifier ()
155486 : {
155487 1395420 : assert (this != NULL);
155488 :
155489 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
155490 : // As a rule only set_ access functions can set the isModified flag.
155491 : // set_isModified(true);
155492 :
155493 1395420 : return p_functionModifier;
155494 : }
155495 :
155496 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155497 :
155498 :
155499 : // End of memberFunctionString
155500 : // Start of memberFunctionString
155501 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
155502 :
155503 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155504 :
155505 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
155506 : const SgSpecialFunctionModifier &
155507 0 : SgFunctionDeclaration::get_specialFunctionModifier () const
155508 : {
155509 0 : assert (this != NULL);
155510 0 : return p_specialFunctionModifier;
155511 : }
155512 :
155513 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
155514 : SgSpecialFunctionModifier &
155515 1541330 : SgFunctionDeclaration::get_specialFunctionModifier ()
155516 : {
155517 1541330 : assert (this != NULL);
155518 :
155519 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
155520 : // As a rule only set_ access functions can set the isModified flag.
155521 : // set_isModified(true);
155522 :
155523 1541330 : return p_specialFunctionModifier;
155524 : }
155525 :
155526 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155527 :
155528 :
155529 : // End of memberFunctionString
155530 : // Start of memberFunctionString
155531 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155532 :
155533 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155534 :
155535 : SgTypePtrList
155536 8 : SgFunctionDeclaration::get_exceptionSpecification () const
155537 : {
155538 8 : ROSE_ASSERT (this != NULL);
155539 :
155540 : #if 0
155541 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155542 : // used to trigger marking transformations for the token-based unparsing.
155543 : printf ("SgFunctionDeclaration::get_exceptionSpecification = %p = %s \n",this,this->class_name().c_str());
155544 : #endif
155545 :
155546 8 : return p_exceptionSpecification;
155547 : }
155548 :
155549 : void
155550 0 : SgFunctionDeclaration::set_exceptionSpecification ( SgTypePtrList exceptionSpecification )
155551 : {
155552 0 : ROSE_ASSERT (this != NULL);
155553 :
155554 : #if 0
155555 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155556 : // used to trigger marking transformations for the token-based unparsing.
155557 : printf ("SgFunctionDeclaration::set_exceptionSpecification = %p = %s \n",this,this->class_name().c_str());
155558 : #endif
155559 :
155560 0 : set_isModified(true);
155561 :
155562 0 : p_exceptionSpecification = exceptionSpecification;
155563 0 : }
155564 :
155565 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155566 :
155567 :
155568 : // End of memberFunctionString
155569 : // Start of memberFunctionString
155570 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155571 :
155572 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155573 :
155574 : bool
155575 45 : SgFunctionDeclaration::get_named_in_end_statement () const
155576 : {
155577 45 : ROSE_ASSERT (this != NULL);
155578 :
155579 : #if 0
155580 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155581 : // used to trigger marking transformations for the token-based unparsing.
155582 : printf ("SgFunctionDeclaration::get_named_in_end_statement = %p = %s \n",this,this->class_name().c_str());
155583 : #endif
155584 :
155585 45 : return p_named_in_end_statement;
155586 : }
155587 :
155588 : void
155589 13 : SgFunctionDeclaration::set_named_in_end_statement ( bool named_in_end_statement )
155590 : {
155591 13 : ROSE_ASSERT (this != NULL);
155592 :
155593 : #if 0
155594 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155595 : // used to trigger marking transformations for the token-based unparsing.
155596 : printf ("SgFunctionDeclaration::set_named_in_end_statement = %p = %s \n",this,this->class_name().c_str());
155597 : #endif
155598 :
155599 13 : set_isModified(true);
155600 :
155601 13 : p_named_in_end_statement = named_in_end_statement;
155602 13 : }
155603 :
155604 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155605 :
155606 :
155607 : // End of memberFunctionString
155608 : // Start of memberFunctionString
155609 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155610 :
155611 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155612 :
155613 : std::string
155614 653 : SgFunctionDeclaration::get_asm_name () const
155615 : {
155616 653 : ROSE_ASSERT (this != NULL);
155617 :
155618 : #if 0
155619 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155620 : // used to trigger marking transformations for the token-based unparsing.
155621 : printf ("SgFunctionDeclaration::get_asm_name = %p = %s \n",this,this->class_name().c_str());
155622 : #endif
155623 :
155624 653 : return p_asm_name;
155625 : }
155626 :
155627 : void
155628 2107 : SgFunctionDeclaration::set_asm_name ( std::string asm_name )
155629 : {
155630 2107 : ROSE_ASSERT (this != NULL);
155631 :
155632 : #if 0
155633 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155634 : // used to trigger marking transformations for the token-based unparsing.
155635 : printf ("SgFunctionDeclaration::set_asm_name = %p = %s \n",this,this->class_name().c_str());
155636 : #endif
155637 :
155638 2107 : set_isModified(true);
155639 :
155640 2107 : p_asm_name = asm_name;
155641 2107 : }
155642 :
155643 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155644 :
155645 :
155646 : // End of memberFunctionString
155647 : // Start of memberFunctionString
155648 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155649 :
155650 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155651 :
155652 : SgExprListExp*
155653 5 : SgFunctionDeclaration::get_decoratorList () const
155654 : {
155655 5 : ROSE_ASSERT (this != NULL);
155656 :
155657 : #if 0
155658 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155659 : // used to trigger marking transformations for the token-based unparsing.
155660 : printf ("SgFunctionDeclaration::get_decoratorList = %p = %s \n",this,this->class_name().c_str());
155661 : #endif
155662 :
155663 5 : return p_decoratorList;
155664 : }
155665 :
155666 : void
155667 0 : SgFunctionDeclaration::set_decoratorList ( SgExprListExp* decoratorList )
155668 : {
155669 0 : ROSE_ASSERT (this != NULL);
155670 :
155671 : #if 0
155672 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155673 : // used to trigger marking transformations for the token-based unparsing.
155674 : printf ("SgFunctionDeclaration::set_decoratorList = %p = %s \n",this,this->class_name().c_str());
155675 : #endif
155676 :
155677 0 : set_isModified(true);
155678 :
155679 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
155680 : if (p_decoratorList != NULL && decoratorList != NULL && p_decoratorList != decoratorList)
155681 : {
155682 : printf ("Warning: decoratorList = %p overwriting valid pointer p_decoratorList = %p \n",decoratorList,p_decoratorList);
155683 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
155684 : printf ("Error fails assertion (p_decoratorList != NULL && decoratorList != NULL && p_decoratorList != decoratorList) is false\n");
155685 : ROSE_ASSERT(false);
155686 : #endif
155687 : }
155688 : #endif
155689 0 : p_decoratorList = decoratorList;
155690 0 : }
155691 :
155692 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155693 :
155694 :
155695 : // End of memberFunctionString
155696 : // Start of memberFunctionString
155697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155698 :
155699 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155700 :
155701 : bool
155702 0 : SgFunctionDeclaration::get_ada_formal_subprogram_decl () const
155703 : {
155704 0 : ROSE_ASSERT (this != NULL);
155705 :
155706 : #if 0
155707 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155708 : // used to trigger marking transformations for the token-based unparsing.
155709 : printf ("SgFunctionDeclaration::get_ada_formal_subprogram_decl = %p = %s \n",this,this->class_name().c_str());
155710 : #endif
155711 :
155712 0 : return p_ada_formal_subprogram_decl;
155713 : }
155714 :
155715 : void
155716 0 : SgFunctionDeclaration::set_ada_formal_subprogram_decl ( bool ada_formal_subprogram_decl )
155717 : {
155718 0 : ROSE_ASSERT (this != NULL);
155719 :
155720 : #if 0
155721 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155722 : // used to trigger marking transformations for the token-based unparsing.
155723 : printf ("SgFunctionDeclaration::set_ada_formal_subprogram_decl = %p = %s \n",this,this->class_name().c_str());
155724 : #endif
155725 :
155726 0 : set_isModified(true);
155727 :
155728 0 : p_ada_formal_subprogram_decl = ada_formal_subprogram_decl;
155729 0 : }
155730 :
155731 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155732 :
155733 :
155734 : // End of memberFunctionString
155735 : // Start of memberFunctionString
155736 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155737 :
155738 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155739 :
155740 : SgFunctionType*
155741 15334500 : SgFunctionDeclaration::get_type () const
155742 : {
155743 15334500 : ROSE_ASSERT (this != NULL);
155744 :
155745 : #if 0
155746 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155747 : // used to trigger marking transformations for the token-based unparsing.
155748 : printf ("SgFunctionDeclaration::get_type = %p = %s \n",this,this->class_name().c_str());
155749 : #endif
155750 :
155751 15334500 : return p_type;
155752 : }
155753 :
155754 : void
155755 0 : SgFunctionDeclaration::set_type ( SgFunctionType* type )
155756 : {
155757 0 : ROSE_ASSERT (this != NULL);
155758 :
155759 : #if 0
155760 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155761 : // used to trigger marking transformations for the token-based unparsing.
155762 : printf ("SgFunctionDeclaration::set_type = %p = %s \n",this,this->class_name().c_str());
155763 : #endif
155764 :
155765 0 : set_isModified(true);
155766 :
155767 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
155768 : if (p_type != NULL && type != NULL && p_type != type)
155769 : {
155770 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
155771 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
155772 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
155773 : ROSE_ASSERT(false);
155774 : #endif
155775 : }
155776 : #endif
155777 0 : p_type = type;
155778 0 : }
155779 :
155780 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155781 :
155782 :
155783 : // End of memberFunctionString
155784 : // Start of memberFunctionString
155785 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155786 :
155787 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155788 :
155789 : SgFunctionDefinition*
155790 3590580 : SgFunctionDeclaration::get_definition () const
155791 : {
155792 3590580 : ROSE_ASSERT (this != NULL);
155793 :
155794 : #if 0
155795 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155796 : // used to trigger marking transformations for the token-based unparsing.
155797 : printf ("SgFunctionDeclaration::get_definition = %p = %s \n",this,this->class_name().c_str());
155798 : #endif
155799 :
155800 3590580 : return p_definition;
155801 : }
155802 :
155803 : void
155804 19283 : SgFunctionDeclaration::set_definition ( SgFunctionDefinition* definition )
155805 : {
155806 19283 : ROSE_ASSERT (this != NULL);
155807 :
155808 : #if 0
155809 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155810 : // used to trigger marking transformations for the token-based unparsing.
155811 : printf ("SgFunctionDeclaration::set_definition = %p = %s \n",this,this->class_name().c_str());
155812 : #endif
155813 :
155814 19283 : set_isModified(true);
155815 :
155816 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
155817 : if (p_definition != NULL && definition != NULL && p_definition != definition)
155818 : {
155819 : printf ("Warning: definition = %p overwriting valid pointer p_definition = %p \n",definition,p_definition);
155820 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
155821 : printf ("Error fails assertion (p_definition != NULL && definition != NULL && p_definition != definition) is false\n");
155822 : ROSE_ASSERT(false);
155823 : #endif
155824 : }
155825 : #endif
155826 19283 : p_definition = definition;
155827 19283 : }
155828 :
155829 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155830 :
155831 :
155832 : // End of memberFunctionString
155833 : // Start of memberFunctionString
155834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155835 :
155836 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155837 :
155838 : bool
155839 2590 : SgFunctionDeclaration::get_oldStyleDefinition () const
155840 : {
155841 2590 : ROSE_ASSERT (this != NULL);
155842 :
155843 : #if 0
155844 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155845 : // used to trigger marking transformations for the token-based unparsing.
155846 : printf ("SgFunctionDeclaration::get_oldStyleDefinition = %p = %s \n",this,this->class_name().c_str());
155847 : #endif
155848 :
155849 2590 : return p_oldStyleDefinition;
155850 : }
155851 :
155852 : void
155853 133 : SgFunctionDeclaration::set_oldStyleDefinition ( bool oldStyleDefinition )
155854 : {
155855 133 : ROSE_ASSERT (this != NULL);
155856 :
155857 : #if 0
155858 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155859 : // used to trigger marking transformations for the token-based unparsing.
155860 : printf ("SgFunctionDeclaration::set_oldStyleDefinition = %p = %s \n",this,this->class_name().c_str());
155861 : #endif
155862 :
155863 133 : set_isModified(true);
155864 :
155865 133 : p_oldStyleDefinition = oldStyleDefinition;
155866 133 : }
155867 :
155868 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155869 :
155870 :
155871 : // End of memberFunctionString
155872 : // Start of memberFunctionString
155873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155874 :
155875 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155876 :
155877 : SgScopeStatement*
155878 49028000 : SgFunctionDeclaration::get_scope () const
155879 : {
155880 49028000 : ROSE_ASSERT (this != NULL);
155881 :
155882 : #if 0
155883 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155884 : // used to trigger marking transformations for the token-based unparsing.
155885 : printf ("SgFunctionDeclaration::get_scope = %p = %s \n",this,this->class_name().c_str());
155886 : #endif
155887 :
155888 49028000 : return p_scope;
155889 : }
155890 :
155891 : void
155892 1180870 : SgFunctionDeclaration::set_scope ( SgScopeStatement* scope )
155893 : {
155894 1180870 : ROSE_ASSERT (this != NULL);
155895 :
155896 : #if 0
155897 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155898 : // used to trigger marking transformations for the token-based unparsing.
155899 : printf ("SgFunctionDeclaration::set_scope = %p = %s \n",this,this->class_name().c_str());
155900 : #endif
155901 :
155902 1180870 : set_isModified(true);
155903 :
155904 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
155905 : if (p_scope != NULL && scope != NULL && p_scope != scope)
155906 : {
155907 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
155908 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
155909 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
155910 : ROSE_ASSERT(false);
155911 : #endif
155912 : }
155913 : #endif
155914 1180870 : p_scope = scope;
155915 1180870 : }
155916 :
155917 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155918 :
155919 :
155920 : // End of memberFunctionString
155921 : // Start of memberFunctionString
155922 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155923 :
155924 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155925 :
155926 : SgDeclarationStatement::template_specialization_enum
155927 1049290 : SgFunctionDeclaration::get_specialization () const
155928 : {
155929 1049290 : ROSE_ASSERT (this != NULL);
155930 :
155931 : #if 0
155932 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155933 : // used to trigger marking transformations for the token-based unparsing.
155934 : printf ("SgFunctionDeclaration::get_specialization = %p = %s \n",this,this->class_name().c_str());
155935 : #endif
155936 :
155937 1049290 : return p_specialization;
155938 : }
155939 :
155940 : void
155941 472 : SgFunctionDeclaration::set_specialization ( SgDeclarationStatement::template_specialization_enum specialization )
155942 : {
155943 472 : ROSE_ASSERT (this != NULL);
155944 :
155945 : #if 0
155946 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155947 : // used to trigger marking transformations for the token-based unparsing.
155948 : printf ("SgFunctionDeclaration::set_specialization = %p = %s \n",this,this->class_name().c_str());
155949 : #endif
155950 :
155951 472 : set_isModified(true);
155952 :
155953 472 : p_specialization = specialization;
155954 472 : }
155955 :
155956 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155957 :
155958 :
155959 : // End of memberFunctionString
155960 : // Start of memberFunctionString
155961 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
155962 :
155963 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
155964 :
155965 : std::string
155966 0 : SgFunctionDeclaration::get_gnu_extension_section () const
155967 : {
155968 0 : ROSE_ASSERT (this != NULL);
155969 :
155970 : #if 0
155971 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155972 : // used to trigger marking transformations for the token-based unparsing.
155973 : printf ("SgFunctionDeclaration::get_gnu_extension_section = %p = %s \n",this,this->class_name().c_str());
155974 : #endif
155975 :
155976 0 : return p_gnu_extension_section;
155977 : }
155978 :
155979 : void
155980 0 : SgFunctionDeclaration::set_gnu_extension_section ( std::string gnu_extension_section )
155981 : {
155982 0 : ROSE_ASSERT (this != NULL);
155983 :
155984 : #if 0
155985 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
155986 : // used to trigger marking transformations for the token-based unparsing.
155987 : printf ("SgFunctionDeclaration::set_gnu_extension_section = %p = %s \n",this,this->class_name().c_str());
155988 : #endif
155989 :
155990 0 : set_isModified(true);
155991 :
155992 0 : p_gnu_extension_section = gnu_extension_section;
155993 0 : }
155994 :
155995 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
155996 :
155997 :
155998 : // End of memberFunctionString
155999 : // Start of memberFunctionString
156000 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156001 :
156002 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156003 :
156004 : std::string
156005 0 : SgFunctionDeclaration::get_gnu_extension_alias () const
156006 : {
156007 0 : ROSE_ASSERT (this != NULL);
156008 :
156009 : #if 0
156010 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156011 : // used to trigger marking transformations for the token-based unparsing.
156012 : printf ("SgFunctionDeclaration::get_gnu_extension_alias = %p = %s \n",this,this->class_name().c_str());
156013 : #endif
156014 :
156015 0 : return p_gnu_extension_alias;
156016 : }
156017 :
156018 : void
156019 0 : SgFunctionDeclaration::set_gnu_extension_alias ( std::string gnu_extension_alias )
156020 : {
156021 0 : ROSE_ASSERT (this != NULL);
156022 :
156023 : #if 0
156024 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156025 : // used to trigger marking transformations for the token-based unparsing.
156026 : printf ("SgFunctionDeclaration::set_gnu_extension_alias = %p = %s \n",this,this->class_name().c_str());
156027 : #endif
156028 :
156029 0 : set_isModified(true);
156030 :
156031 0 : p_gnu_extension_alias = gnu_extension_alias;
156032 0 : }
156033 :
156034 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156035 :
156036 :
156037 : // End of memberFunctionString
156038 : // Start of memberFunctionString
156039 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156040 :
156041 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156042 :
156043 : SgDeclarationStatement::gnu_extension_visability_attribute_enum
156044 0 : SgFunctionDeclaration::get_gnu_extension_visability () const
156045 : {
156046 0 : ROSE_ASSERT (this != NULL);
156047 :
156048 : #if 0
156049 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156050 : // used to trigger marking transformations for the token-based unparsing.
156051 : printf ("SgFunctionDeclaration::get_gnu_extension_visability = %p = %s \n",this,this->class_name().c_str());
156052 : #endif
156053 :
156054 0 : return p_gnu_extension_visability;
156055 : }
156056 :
156057 : void
156058 0 : SgFunctionDeclaration::set_gnu_extension_visability ( SgDeclarationStatement::gnu_extension_visability_attribute_enum gnu_extension_visability )
156059 : {
156060 0 : ROSE_ASSERT (this != NULL);
156061 :
156062 : #if 0
156063 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156064 : // used to trigger marking transformations for the token-based unparsing.
156065 : printf ("SgFunctionDeclaration::set_gnu_extension_visability = %p = %s \n",this,this->class_name().c_str());
156066 : #endif
156067 :
156068 0 : set_isModified(true);
156069 :
156070 0 : p_gnu_extension_visability = gnu_extension_visability;
156071 0 : }
156072 :
156073 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156074 :
156075 :
156076 : // End of memberFunctionString
156077 : // Start of memberFunctionString
156078 :
156079 :
156080 : // End of memberFunctionString
156081 : // Start of memberFunctionString
156082 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156083 :
156084 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156085 :
156086 : bool
156087 1010 : SgFunctionDeclaration::get_prototypeIsWithoutParameters () const
156088 : {
156089 1010 : ROSE_ASSERT (this != NULL);
156090 :
156091 : #if 0
156092 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156093 : // used to trigger marking transformations for the token-based unparsing.
156094 : printf ("SgFunctionDeclaration::get_prototypeIsWithoutParameters = %p = %s \n",this,this->class_name().c_str());
156095 : #endif
156096 :
156097 1010 : return p_prototypeIsWithoutParameters;
156098 : }
156099 :
156100 : void
156101 24990 : SgFunctionDeclaration::set_prototypeIsWithoutParameters ( bool prototypeIsWithoutParameters )
156102 : {
156103 24990 : ROSE_ASSERT (this != NULL);
156104 :
156105 : #if 0
156106 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156107 : // used to trigger marking transformations for the token-based unparsing.
156108 : printf ("SgFunctionDeclaration::set_prototypeIsWithoutParameters = %p = %s \n",this,this->class_name().c_str());
156109 : #endif
156110 :
156111 24990 : set_isModified(true);
156112 :
156113 24990 : p_prototypeIsWithoutParameters = prototypeIsWithoutParameters;
156114 24990 : }
156115 :
156116 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156117 :
156118 :
156119 : // End of memberFunctionString
156120 : // Start of memberFunctionString
156121 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156122 :
156123 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156124 :
156125 : int
156126 939 : SgFunctionDeclaration::get_gnu_regparm_attribute () const
156127 : {
156128 939 : ROSE_ASSERT (this != NULL);
156129 :
156130 : #if 0
156131 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156132 : // used to trigger marking transformations for the token-based unparsing.
156133 : printf ("SgFunctionDeclaration::get_gnu_regparm_attribute = %p = %s \n",this,this->class_name().c_str());
156134 : #endif
156135 :
156136 939 : return p_gnu_regparm_attribute;
156137 : }
156138 :
156139 : void
156140 0 : SgFunctionDeclaration::set_gnu_regparm_attribute ( int gnu_regparm_attribute )
156141 : {
156142 0 : ROSE_ASSERT (this != NULL);
156143 :
156144 : #if 0
156145 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156146 : // used to trigger marking transformations for the token-based unparsing.
156147 : printf ("SgFunctionDeclaration::set_gnu_regparm_attribute = %p = %s \n",this,this->class_name().c_str());
156148 : #endif
156149 :
156150 0 : set_isModified(true);
156151 :
156152 0 : p_gnu_regparm_attribute = gnu_regparm_attribute;
156153 0 : }
156154 :
156155 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156156 :
156157 :
156158 : // End of memberFunctionString
156159 : // Start of memberFunctionString
156160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156161 :
156162 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156163 :
156164 : SgFunctionType*
156165 1142070 : SgFunctionDeclaration::get_type_syntax () const
156166 : {
156167 1142070 : ROSE_ASSERT (this != NULL);
156168 :
156169 : #if 0
156170 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156171 : // used to trigger marking transformations for the token-based unparsing.
156172 : printf ("SgFunctionDeclaration::get_type_syntax = %p = %s \n",this,this->class_name().c_str());
156173 : #endif
156174 :
156175 1142070 : return p_type_syntax;
156176 : }
156177 :
156178 : void
156179 1141300 : SgFunctionDeclaration::set_type_syntax ( SgFunctionType* type_syntax )
156180 : {
156181 1141300 : ROSE_ASSERT (this != NULL);
156182 :
156183 : #if 0
156184 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156185 : // used to trigger marking transformations for the token-based unparsing.
156186 : printf ("SgFunctionDeclaration::set_type_syntax = %p = %s \n",this,this->class_name().c_str());
156187 : #endif
156188 :
156189 1141300 : set_isModified(true);
156190 :
156191 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
156192 : if (p_type_syntax != NULL && type_syntax != NULL && p_type_syntax != type_syntax)
156193 : {
156194 : printf ("Warning: type_syntax = %p overwriting valid pointer p_type_syntax = %p \n",type_syntax,p_type_syntax);
156195 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
156196 : printf ("Error fails assertion (p_type_syntax != NULL && type_syntax != NULL && p_type_syntax != type_syntax) is false\n");
156197 : ROSE_ASSERT(false);
156198 : #endif
156199 : }
156200 : #endif
156201 1141300 : p_type_syntax = type_syntax;
156202 1141300 : }
156203 :
156204 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156205 :
156206 :
156207 : // End of memberFunctionString
156208 : // Start of memberFunctionString
156209 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156210 :
156211 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156212 :
156213 : bool
156214 1434140 : SgFunctionDeclaration::get_type_syntax_is_available () const
156215 : {
156216 1434140 : ROSE_ASSERT (this != NULL);
156217 :
156218 : #if 0
156219 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156220 : // used to trigger marking transformations for the token-based unparsing.
156221 : printf ("SgFunctionDeclaration::get_type_syntax_is_available = %p = %s \n",this,this->class_name().c_str());
156222 : #endif
156223 :
156224 1434140 : return p_type_syntax_is_available;
156225 : }
156226 :
156227 : void
156228 1141300 : SgFunctionDeclaration::set_type_syntax_is_available ( bool type_syntax_is_available )
156229 : {
156230 1141300 : ROSE_ASSERT (this != NULL);
156231 :
156232 : #if 0
156233 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156234 : // used to trigger marking transformations for the token-based unparsing.
156235 : printf ("SgFunctionDeclaration::set_type_syntax_is_available = %p = %s \n",this,this->class_name().c_str());
156236 : #endif
156237 :
156238 1141300 : set_isModified(true);
156239 :
156240 1141300 : p_type_syntax_is_available = type_syntax_is_available;
156241 1141300 : }
156242 :
156243 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156244 :
156245 :
156246 : // End of memberFunctionString
156247 : // Start of memberFunctionString
156248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156249 :
156250 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156251 :
156252 : SgFunctionParameterList*
156253 519874 : SgFunctionDeclaration::get_parameterList_syntax () const
156254 : {
156255 519874 : ROSE_ASSERT (this != NULL);
156256 :
156257 : #if 0
156258 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156259 : // used to trigger marking transformations for the token-based unparsing.
156260 : printf ("SgFunctionDeclaration::get_parameterList_syntax = %p = %s \n",this,this->class_name().c_str());
156261 : #endif
156262 :
156263 519874 : return p_parameterList_syntax;
156264 : }
156265 :
156266 : void
156267 1141300 : SgFunctionDeclaration::set_parameterList_syntax ( SgFunctionParameterList* parameterList_syntax )
156268 : {
156269 1141300 : ROSE_ASSERT (this != NULL);
156270 :
156271 : #if 0
156272 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156273 : // used to trigger marking transformations for the token-based unparsing.
156274 : printf ("SgFunctionDeclaration::set_parameterList_syntax = %p = %s \n",this,this->class_name().c_str());
156275 : #endif
156276 :
156277 1141300 : set_isModified(true);
156278 :
156279 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
156280 : if (p_parameterList_syntax != NULL && parameterList_syntax != NULL && p_parameterList_syntax != parameterList_syntax)
156281 : {
156282 : printf ("Warning: parameterList_syntax = %p overwriting valid pointer p_parameterList_syntax = %p \n",parameterList_syntax,p_parameterList_syntax);
156283 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
156284 : printf ("Error fails assertion (p_parameterList_syntax != NULL && parameterList_syntax != NULL && p_parameterList_syntax != parameterList_syntax) is false\n");
156285 : ROSE_ASSERT(false);
156286 : #endif
156287 : }
156288 : #endif
156289 1141300 : p_parameterList_syntax = parameterList_syntax;
156290 1141300 : }
156291 :
156292 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156293 :
156294 :
156295 : // End of memberFunctionString
156296 : // Start of memberFunctionString
156297 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156298 :
156299 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156300 :
156301 : bool
156302 1007 : SgFunctionDeclaration::get_using_C11_Noreturn_keyword () const
156303 : {
156304 1007 : ROSE_ASSERT (this != NULL);
156305 :
156306 : #if 0
156307 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156308 : // used to trigger marking transformations for the token-based unparsing.
156309 : printf ("SgFunctionDeclaration::get_using_C11_Noreturn_keyword = %p = %s \n",this,this->class_name().c_str());
156310 : #endif
156311 :
156312 1007 : return p_using_C11_Noreturn_keyword;
156313 : }
156314 :
156315 : void
156316 0 : SgFunctionDeclaration::set_using_C11_Noreturn_keyword ( bool using_C11_Noreturn_keyword )
156317 : {
156318 0 : ROSE_ASSERT (this != NULL);
156319 :
156320 : #if 0
156321 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156322 : // used to trigger marking transformations for the token-based unparsing.
156323 : printf ("SgFunctionDeclaration::set_using_C11_Noreturn_keyword = %p = %s \n",this,this->class_name().c_str());
156324 : #endif
156325 :
156326 0 : set_isModified(true);
156327 :
156328 0 : p_using_C11_Noreturn_keyword = using_C11_Noreturn_keyword;
156329 0 : }
156330 :
156331 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156332 :
156333 :
156334 : // End of memberFunctionString
156335 : // Start of memberFunctionString
156336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156337 :
156338 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156339 :
156340 : bool
156341 1007 : SgFunctionDeclaration::get_is_constexpr () const
156342 : {
156343 1007 : ROSE_ASSERT (this != NULL);
156344 :
156345 : #if 0
156346 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156347 : // used to trigger marking transformations for the token-based unparsing.
156348 : printf ("SgFunctionDeclaration::get_is_constexpr = %p = %s \n",this,this->class_name().c_str());
156349 : #endif
156350 :
156351 1007 : return p_is_constexpr;
156352 : }
156353 :
156354 : void
156355 15304 : SgFunctionDeclaration::set_is_constexpr ( bool is_constexpr )
156356 : {
156357 15304 : ROSE_ASSERT (this != NULL);
156358 :
156359 : #if 0
156360 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156361 : // used to trigger marking transformations for the token-based unparsing.
156362 : printf ("SgFunctionDeclaration::set_is_constexpr = %p = %s \n",this,this->class_name().c_str());
156363 : #endif
156364 :
156365 15304 : set_isModified(true);
156366 :
156367 15304 : p_is_constexpr = is_constexpr;
156368 15304 : }
156369 :
156370 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156371 :
156372 :
156373 : // End of memberFunctionString
156374 : // Start of memberFunctionString
156375 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156376 :
156377 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156378 :
156379 : bool
156380 0 : SgFunctionDeclaration::get_using_new_function_return_type_syntax () const
156381 : {
156382 0 : ROSE_ASSERT (this != NULL);
156383 :
156384 : #if 0
156385 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156386 : // used to trigger marking transformations for the token-based unparsing.
156387 : printf ("SgFunctionDeclaration::get_using_new_function_return_type_syntax = %p = %s \n",this,this->class_name().c_str());
156388 : #endif
156389 :
156390 0 : return p_using_new_function_return_type_syntax;
156391 : }
156392 :
156393 : void
156394 443 : SgFunctionDeclaration::set_using_new_function_return_type_syntax ( bool using_new_function_return_type_syntax )
156395 : {
156396 443 : ROSE_ASSERT (this != NULL);
156397 :
156398 : #if 0
156399 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156400 : // used to trigger marking transformations for the token-based unparsing.
156401 : printf ("SgFunctionDeclaration::set_using_new_function_return_type_syntax = %p = %s \n",this,this->class_name().c_str());
156402 : #endif
156403 :
156404 443 : set_isModified(true);
156405 :
156406 443 : p_using_new_function_return_type_syntax = using_new_function_return_type_syntax;
156407 443 : }
156408 :
156409 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156410 :
156411 :
156412 : // End of memberFunctionString
156413 : // Start of memberFunctionString
156414 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156415 :
156416 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156417 :
156418 : SgFunctionParameterScope*
156419 0 : SgFunctionDeclaration::get_functionParameterScope () const
156420 : {
156421 0 : ROSE_ASSERT (this != NULL);
156422 :
156423 : #if 0
156424 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156425 : // used to trigger marking transformations for the token-based unparsing.
156426 : printf ("SgFunctionDeclaration::get_functionParameterScope = %p = %s \n",this,this->class_name().c_str());
156427 : #endif
156428 :
156429 0 : return p_functionParameterScope;
156430 : }
156431 :
156432 : void
156433 0 : SgFunctionDeclaration::set_functionParameterScope ( SgFunctionParameterScope* functionParameterScope )
156434 : {
156435 0 : ROSE_ASSERT (this != NULL);
156436 :
156437 : #if 0
156438 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156439 : // used to trigger marking transformations for the token-based unparsing.
156440 : printf ("SgFunctionDeclaration::set_functionParameterScope = %p = %s \n",this,this->class_name().c_str());
156441 : #endif
156442 :
156443 0 : set_isModified(true);
156444 :
156445 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
156446 : if (p_functionParameterScope != NULL && functionParameterScope != NULL && p_functionParameterScope != functionParameterScope)
156447 : {
156448 : printf ("Warning: functionParameterScope = %p overwriting valid pointer p_functionParameterScope = %p \n",functionParameterScope,p_functionParameterScope);
156449 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
156450 : printf ("Error fails assertion (p_functionParameterScope != NULL && functionParameterScope != NULL && p_functionParameterScope != functionParameterScope) is false\n");
156451 : ROSE_ASSERT(false);
156452 : #endif
156453 : }
156454 : #endif
156455 0 : p_functionParameterScope = functionParameterScope;
156456 0 : }
156457 :
156458 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156459 :
156460 :
156461 : // End of memberFunctionString
156462 : // Start of memberFunctionString
156463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156464 :
156465 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156466 :
156467 : bool
156468 0 : SgFunctionDeclaration::get_marked_as_edg_normalization () const
156469 : {
156470 0 : ROSE_ASSERT (this != NULL);
156471 :
156472 : #if 0
156473 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156474 : // used to trigger marking transformations for the token-based unparsing.
156475 : printf ("SgFunctionDeclaration::get_marked_as_edg_normalization = %p = %s \n",this,this->class_name().c_str());
156476 : #endif
156477 :
156478 0 : return p_marked_as_edg_normalization;
156479 : }
156480 :
156481 : void
156482 5426 : SgFunctionDeclaration::set_marked_as_edg_normalization ( bool marked_as_edg_normalization )
156483 : {
156484 5426 : ROSE_ASSERT (this != NULL);
156485 :
156486 : #if 0
156487 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156488 : // used to trigger marking transformations for the token-based unparsing.
156489 : printf ("SgFunctionDeclaration::set_marked_as_edg_normalization = %p = %s \n",this,this->class_name().c_str());
156490 : #endif
156491 :
156492 5426 : set_isModified(true);
156493 :
156494 5426 : p_marked_as_edg_normalization = marked_as_edg_normalization;
156495 5426 : }
156496 :
156497 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156498 :
156499 :
156500 : // End of memberFunctionString
156501 : // Start of memberFunctionString
156502 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
156503 :
156504 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
156505 :
156506 : bool
156507 9 : SgFunctionDeclaration::get_is_implicit_function () const
156508 : {
156509 9 : ROSE_ASSERT (this != NULL);
156510 :
156511 : #if 0
156512 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156513 : // used to trigger marking transformations for the token-based unparsing.
156514 : printf ("SgFunctionDeclaration::get_is_implicit_function = %p = %s \n",this,this->class_name().c_str());
156515 : #endif
156516 :
156517 9 : return p_is_implicit_function;
156518 : }
156519 :
156520 : void
156521 10 : SgFunctionDeclaration::set_is_implicit_function ( bool is_implicit_function )
156522 : {
156523 10 : ROSE_ASSERT (this != NULL);
156524 :
156525 : #if 0
156526 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
156527 : // used to trigger marking transformations for the token-based unparsing.
156528 : printf ("SgFunctionDeclaration::set_is_implicit_function = %p = %s \n",this,this->class_name().c_str());
156529 : #endif
156530 :
156531 10 : set_isModified(true);
156532 :
156533 10 : p_is_implicit_function = is_implicit_function;
156534 10 : }
156535 :
156536 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
156537 :
156538 :
156539 : // End of memberFunctionString
156540 : // Start of memberFunctionString
156541 : /* #line 10737 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
156542 :
156543 :
156544 : void
156545 1180870 : SgFunctionDeclaration::post_construction_initialization()
156546 : {
156547 : // Sg_File_Info* thisFileInfo = get_file_info();
156548 : // ROSE_ASSERT (thisFileInfo != NULL);
156549 :
156550 : // DQ (10/25/2004): Force generation of new file info object (all such objects should be unique)
156551 : // initialize the FunctionParameterList as an object that is referred to from FunctionDeclaration
156552 : // Sg_File_Info* fileInfo = new Sg_File_Info(*thisFileInfo);
156553 : // ROSE_ASSERT (fileInfo != NULL);
156554 :
156555 : // DQ (11/12/2006): Modified to permit being called by constructor without Sg_File_Info objects.
156556 : // DQ (7/19/2005): set parameter list on a single location (and independently of existence of function parameters)
156557 : // p_args = new SgFunctionParameterList(fileInfo);
156558 1180870 : SgFunctionParameterList* args = NULL;
156559 1180870 : if (get_startOfConstruct() != NULL)
156560 : {
156561 5 : args = new SgFunctionParameterList(New_File_Info(this));
156562 5 : args->get_startOfConstruct()->set_parent(args);
156563 : }
156564 : else
156565 : {
156566 : // DQ (11/12/2006): Use the new constructor.
156567 1180860 : args = new SgFunctionParameterList();
156568 : }
156569 1180870 : ROSE_ASSERT (args != NULL);
156570 1180870 : set_parameterList(args);
156571 :
156572 : // DQ (7/19/2005): set the parent explicitly
156573 1180870 : get_parameterList()->set_parent(this);
156574 :
156575 : // DQ (3/6/2007): Set the firstNondefiningDeclaration of args to itself (this is now required
156576 : // for the AST consistency tests after the AST merge). Likely because one where a member function
156577 : // is referenced before being declared in a class the member function was not previously visited by
156578 : // the AST traversal and so one of its defining or non-defining declarations was not set and after
156579 : // the merge this declaration is used (shared) and thus accessed where before it had been hidden.
156580 : // DQ (3/15/2006): Let this be NULL so that it will be fixed by the fixupDeclarations function
156581 : // within the post processing phase.
156582 : // DQ (9/6/2005): Since a SgFunctionParameterList is a SgDeclarationStatement we should set
156583 : // either its defining or non-defining declaration (I choose the non-defining declaration).
156584 : // args->set_definingDeclaration(args);
156585 : // args->set_firstNondefiningDeclaration(args);
156586 1180870 : args->set_firstNondefiningDeclaration(args);
156587 :
156588 : // DQ (10/25/2004): Add a ending file info object for completeness (though this is not yet
156589 : // initialized to the correct position, yet). Initially let's get them in place then we can
156590 : // work on the accuracy afterward!
156591 : // Sg_File_Info* endingPosition = new Sg_File_Info(*thisFileInfo);
156592 : // ROSE_ASSERT (endingPosition != NULL);
156593 : // p_args->set_endOfConstruct(endingPosition);
156594 :
156595 : // DQ (7/31/2006): Explicit initialization of this data member is required!
156596 : // JJW (8/6/2008): It probably isn't now that p_exceptionSpecification is a vector
156597 1180870 : p_exceptionSpecification.clear();
156598 :
156599 : // DQ (5/14/2011): Added to support name qualification on types referenced by template arguments.
156600 1180870 : p_name_qualification_length = 0;
156601 1180870 : p_type_elaboration_required = false;
156602 1180870 : p_global_qualification_required = false;
156603 :
156604 : // DQ (5/14/2011): Added to support name qualification on types referenced by template arguments.
156605 1180870 : p_name_qualification_length_for_return_type = 0;
156606 1180870 : p_type_elaboration_required_for_return_type = false;
156607 1180870 : p_global_qualification_required_for_return_type = false;
156608 :
156609 : #if 0 // awaiting resolution of abstract handle bug
156610 : // driscoll6 (6/15/11) Support for python function decorators.
156611 : SgExprListExp* decorators = SageBuilder::buildExprListExp();
156612 : set_decoratorList(decorators);
156613 : decorators->set_parent(this);
156614 : #endif
156615 1180870 : }
156616 :
156617 : SgType*
156618 1422490 : SgFunctionDeclaration::get_orig_return_type() const
156619 : {
156620 1422490 : return get_type()->get_orig_return_type();
156621 : }
156622 :
156623 : void
156624 0 : SgFunctionDeclaration::hasEllipses()
156625 : {
156626 : // Record as true!
156627 0 : get_type()->set_has_ellipses(1);
156628 0 : }
156629 :
156630 : #if 0
156631 : /* InitalizedName tuple : (SgName, DeclStmt, type, Initializer) */
156632 : SgInitializedNamePtrList::iterator
156633 : SgFunctionDeclaration::insert_arg(const SgInitializedNamePtrList::iterator& where, SgInitializedName* what)
156634 : {
156635 : // DQ (7/19/2005): This is now set in the post_construction_initialization()
156636 : ROSE_ASSERT(get_parameterList() != NULL);
156637 :
156638 : return get_parameterList()->insert_arg(where,what);
156639 : }
156640 : #endif
156641 :
156642 : void
156643 21 : SgFunctionDeclaration::append_arg( SgInitializedName* what)
156644 : {
156645 : // DQ (7/19/2005): This is now set in the post_construction_initialization()
156646 21 : ROSE_ASSERT(get_parameterList() != NULL);
156647 :
156648 21 : get_parameterList()->append_arg(what);
156649 21 : }
156650 :
156651 : void
156652 0 : SgFunctionDeclaration::prepend_arg( SgInitializedName* what)
156653 : {
156654 : // DQ (7/19/2005): This is now set in the post_construction_initialization()
156655 0 : ROSE_ASSERT(get_parameterList() != NULL);
156656 :
156657 0 : get_parameterList()->prepend_arg(what);
156658 0 : }
156659 :
156660 : SgInitializedNamePtrList &
156661 62182 : SgFunctionDeclaration::get_args()
156662 : {
156663 : // DQ (7/19/2005): This is now set in the post_construction_initialization()
156664 62182 : ROSE_ASSERT(get_parameterList() != NULL);
156665 :
156666 62182 : return get_parameterList()->get_args();
156667 : }
156668 :
156669 : const SgInitializedNamePtrList &
156670 28406 : SgFunctionDeclaration::get_args() const
156671 : {
156672 : // QY:11/2/04 should make sure get_parameterList() != 0
156673 28406 : assert(get_parameterList() != NULL);
156674 28406 : return get_parameterList()->get_args();
156675 : }
156676 :
156677 : // QY:11/2/04: Removed p_mangled_name member because it is always obtained from p_type anyway
156678 : // void SgFunctionDeclaration::set_mangled_name()
156679 : // {
156680 : // SgUnparse_Info info;
156681 : // info.set_decl_stmt((SgDeclarationStatement *)this);
156682 : // info.set_name(p_name);
156683 : // info.set_PrintName();
156684 : // if(p_type)
156685 : // p_mangled_name=p_type->get_mangled(info);
156686 : // }
156687 :
156688 : bool
156689 0 : SgFunctionDeclaration::isTemplateFunction() const
156690 : {
156691 : // DQ (4/28/2005): This function tests for a template function. It is non-trivial because
156692 : // we combine both non-template member functions in templated classes (or nested classes
156693 : // of templated classes) with member functions that are templated.
156694 :
156695 0 : bool returnValue = false;
156696 :
156697 0 : const SgTemplateInstantiationFunctionDecl *templateFunction = isSgTemplateInstantiationFunctionDecl(this);
156698 0 : if (templateFunction != NULL)
156699 : {
156700 0 : returnValue = true;
156701 :
156702 : // Error checking
156703 0 : ROSE_ASSERT(templateFunction->get_templateDeclaration() != NULL);
156704 :
156705 : // DQ (12/23/2011): With the new design we no long have this data member.
156706 : // ROSE_ASSERT(templateFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_function /* 3 */);
156707 : }
156708 : else
156709 : {
156710 0 : const SgTemplateInstantiationMemberFunctionDecl *templateMemberFunction = isSgTemplateInstantiationMemberFunctionDecl(this);
156711 0 : if (templateMemberFunction != NULL)
156712 : {
156713 : #if 0
156714 : // DQ (12/23/2011): With the new design we no long use a SgTemplateDeclaration as the return value for get_templateDeclaration().
156715 :
156716 : // This is a template member function but we need to know if it is a member
156717 : // function of a template class or a template function in a non template class.
156718 : SgTemplateDeclaration *templateDeclaration = templateMemberFunction->get_templateDeclaration();
156719 : ROSE_ASSERT(templateDeclaration != NULL);
156720 :
156721 : // printf ("type of template declaration = %d \n",templateDeclaration->get_template_kind());
156722 : #endif
156723 : #if 0
156724 : SgTemplateParameterPtrList *templateParameterList = templateDeclaration->get_templateParameters();
156725 : if (templateParameterList == NULL)
156726 : {
156727 : printf ("Null pointer to SgTemplateParameterPtrList in template declaration \n");
156728 : }
156729 : else
156730 : {
156731 : int numberOfTemplateParameters = templateParameterList->size();
156732 : printf ("Number of template parameters = %d \n",numberOfTemplateParameters);
156733 : }
156734 : // ROSE_ASSERT(templateParameterList != NULL);
156735 : #endif
156736 : // ROSE_ASSERT(templateMemberFunction->get_templateArguments() != NULL);
156737 0 : int numberOfTemplateArguments = templateMemberFunction->get_templateArguments().size();
156738 :
156739 : // printf ("Number of template arguments = %d \n",numberOfTemplateArguments);
156740 :
156741 0 : if (numberOfTemplateArguments == 0)
156742 : {
156743 : // This is the case of a non-template member function in a templated class or nested class of a templated class!
156744 : // printf ("This is the case of a non-template member function in a templated class or nested class of a templated class \n");
156745 0 : returnValue = false;
156746 :
156747 : // Error checking
156748 : // DQ (4/17/2016): We have to allow this in some more complex template instantiations (I think).
156749 : // It might be work some discussion and at some point. The case where this happens is in the
156750 : // instatiation of nexted template inside of outer templates and we only have a record of the
156751 : // outer template from the instantiation (in EDG).
156752 0 : if (templateMemberFunction->get_templateDeclaration() == NULL)
156753 : {
156754 : #if 0
156755 : printf ("Note that templateMemberFunction->get_templateDeclaration() == NULL: We have to allow this in some cases of nested templates \n");
156756 : #endif
156757 : }
156758 : // ROSE_ASSERT(templateMemberFunction->get_templateDeclaration() != NULL);
156759 : #if 0
156760 : // DQ (12/23/2011): With the new design we no long have this data member.
156761 :
156762 : // DQ (8/12/2005): This can also be a template declaration for a class (at least where the template declaration is stringified presently)
156763 : // if (templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_m_function /* 4 */)
156764 : if ( templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_m_function /* 4 */ &&
156765 : templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_class /* 1 */ &&
156766 : templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_m_class /* 2 */)
156767 : {
156768 : printf ("Error: templateMemberFunction->get_templateDeclaration()->get_template_kind() = %d != e_template_m_function || e_template_class \n",
156769 : templateMemberFunction->get_templateDeclaration()->get_template_kind());
156770 : // templateMemberFunction->get_file_info()->display("Error: templateMemberFunction->get_templateDeclaration()->get_template_kind()");
156771 : // templateMemberFunction->get_file_info()->display("debug");
156772 : }
156773 :
156774 : // DQ (12/14/2005): Added acceptable case of e_template_m_class.
156775 : // DQ (7/4/2005): Commented out so that we can compile KULL (substituted warning message)
156776 : // ROSE_ASSERT(templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_m_function /* 4 */);
156777 : ROSE_ASSERT( templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_m_function /* 4 */ ||
156778 : templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_class /* 1 */ ||
156779 : templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_m_class /* 2 */);
156780 : #endif
156781 : }
156782 : else
156783 : {
156784 : // printf ("This is a valid templated member function! numberOfTemplateArguments = %d \n",numberOfTemplateArguments);
156785 : returnValue = true;
156786 : #if 0
156787 : // DQ (12/23/2011): With the new design we no long have this data member.
156788 :
156789 : // Error checking
156790 : ROSE_ASSERT(templateMemberFunction->get_templateDeclaration() != NULL);
156791 : // if (templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_function /* 3 */)
156792 : if ( templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_function /* 3 */ &&
156793 : templateMemberFunction->get_templateDeclaration()->get_template_kind() != SgTemplateDeclaration::e_template_class /* 1 */)
156794 : {
156795 : printf ("Error: templateMemberFunction->get_templateDeclaration()->get_template_kind() = %d != e_template_function || e_template_class \n",
156796 : templateMemberFunction->get_templateDeclaration()->get_template_kind());
156797 : // templateMemberFunction->get_file_info()->display("Error: templateMemberFunction->get_templateDeclaration()->get_template_kind()");
156798 : // templateMemberFunction->get_file_info()->display("debug");
156799 : }
156800 : // DQ (7/4/2005): Commented out so that we can compile KULL (substituted warning message)
156801 : // ROSE_ASSERT(templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_function /* 3 */);
156802 : ROSE_ASSERT( templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_function /* 3 */ ||
156803 : templateMemberFunction->get_templateDeclaration()->get_template_kind() == SgTemplateDeclaration::e_template_class /* 1 */);
156804 : #endif
156805 : }
156806 :
156807 : // printf ("type of template declaration = %d returnValue = %s \n",templateDeclaration->get_template_kind(),returnValue ? "true" : "false");
156808 : }
156809 : }
156810 :
156811 0 : return returnValue;
156812 : }
156813 :
156814 :
156815 : // DQ (2/7/2006): New version added by Rich Vuduc
156816 : SgName
156817 14198700 : SgFunctionDeclaration::get_mangled_name() const
156818 : {
156819 : // RV (1/31/2006): Changed this routine to include the name
156820 : // qualification in the mangled name, to guarantee the returned
156821 : // string identifies a function uniquely. Moreover, the
156822 : // SgMemberFunctionDeclaration child class then automatically
156823 : // inherits the correct behavior.
156824 : //! \todo Update ROSE manual to document the revised mangling scheme.
156825 :
156826 : // DQ (4/27/2005): I have considered making this the qualified
156827 : // name, but decided against it. See notes in the ROSE manual
156828 : // appendix about mangled names and qualified names.
156829 :
156830 14198700 : ROSE_ASSERT(this != NULL);
156831 :
156832 : #if 0
156833 : printf ("In SgFunctionDeclaration::get_mangled_name() for this = %p = %s \n",this,this->class_name().c_str());
156834 : #endif
156835 :
156836 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
156837 : // SgFunctionDeclaration* function = const_cast<SgFunctionDeclaration*>(this);
156838 : // std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(function);
156839 : // if (i != p_globalMangledNameMap.end())
156840 28397300 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgFunctionDeclaration*>(this));
156841 :
156842 : #if 0
156843 : printf ("Inside of SgFunctionDeclaration::get_mangled_name(): mangledNameString.empty() = %s \n",mangledNameString.empty() ? "true" : "false");
156844 : #endif
156845 :
156846 14198700 : if (mangledNameString.empty() == false)
156847 : {
156848 : // return i->second.c_str();
156849 : #if 0
156850 : printf ("RETURN FROM CACHE: Inside of SgFunctionDeclaration::get_mangled_name(): mangledNameString = %s \n",mangledNameString.c_str());
156851 : #endif
156852 13106200 : return mangledNameString;
156853 : }
156854 : else
156855 : {
156856 2184890 : SgName mangledName;
156857 :
156858 : // DQ (6/23/2010): Added support to maintain seperate "main()" functions as unique (to avoid them being merged).
156859 1092450 : if (this->get_name() == "main")
156860 : {
156861 : // Append the pointer to the name to make this unique to avoid multiple function "main()" from being merged.
156862 3097 : mangledName = "main_";
156863 3097 : mangledName += Rose::StringUtility::numberToString(const_cast<SgFunctionDeclaration*>(this));
156864 : // printf ("RETURN FROM DETECTED MAIN: Inside of SgFunctionDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
156865 3097 : return mangledName;
156866 : }
156867 :
156868 : // Compute a mangled name from this function's type
156869 2178700 : SgName type_name;
156870 2178700 : SgName ret_type_name;
156871 1089350 : SgFunctionType const * func_type = get_type();
156872 1089350 : if (func_type != NULL)
156873 : {
156874 1089350 : type_name = func_type->get_mangled();
156875 1089350 : const SgType* ret_type = func_type->get_return_type();
156876 1089350 : if (ret_type)
156877 1089350 : ret_type_name = ret_type->get_mangled();
156878 : }
156879 : else
156880 : {
156881 0 : type_name = "defaultFunctionTypeName";
156882 : }
156883 :
156884 : // This function's name, transformed.
156885 2178700 : SgName func_name = mangleFunctionName (get_name(), ret_type_name);
156886 :
156887 : // Compute the name qualification, if any.
156888 1089350 : const SgScopeStatement* par_scope = get_scope();
156889 1089350 : SgName scope_name = mangleQualifiers(par_scope);
156890 :
156891 : // Compute the translation unit qualification, if any.
156892 2178700 : string xlation_unit_qual = mangleTranslationUnitQualifiers(this);
156893 :
156894 : // Compute the final mangled name.
156895 1089350 : mangledName = joinMangledQualifiers (scope_name, xlation_unit_qual + func_name + "__" + type_name);
156896 :
156897 : // DQ (6/22/2010): Better to use the function name with the paraleter list in the mangled name. This helps disambiguate
156898 : // code such as:
156899 : // typedef struct Domain_s { } Domain_t;
156900 : // int foo ( Domain_s *domain);
156901 : // int foo ( Domain_t *domain);
156902 : #if 0
156903 : printf ("Inside of SgFunctionDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
156904 : #endif
156905 : #if 1
156906 : // printf ("TEMP: Inside of SgFunctionDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
156907 1161910 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgFunctionDeclaration*>(this),mangledName);
156908 : // printf ("TEMP RETURN: Inside of SgFunctionDeclaration::get_mangled_name(): mangledName = %s \n",mangledName.str());
156909 :
156910 : // This results in infinite recursion in the evaluation.
156911 1089350 : SgFunctionParameterList* parameterList = this->get_parameterList();
156912 1089350 : ROSE_ASSERT(parameterList != NULL);
156913 2178700 : SgName mangledParameterList = parameterList->get_mangled_name();
156914 1089350 : mangledName += "__" + mangledParameterList;
156915 : // printf ("Inside of SgFunctionDeclaration::get_mangled_name(): after adding parameter list mangledName = %s \n",mangledName.str());
156916 : #endif
156917 :
156918 : // Reset the mangled name in the map.
156919 : // p_globalMangledNameMap[function] = mangledName;
156920 1089350 : SgNode::get_globalMangledNameMap()[const_cast<SgFunctionDeclaration*>(this)] = mangledName;
156921 :
156922 : // DQ (7/24/2012): Added test for template brackets that are caught later in AstConsistencyTests.
156923 : // Make sure that there is no template specific syntax included in the mangled name
156924 2178700 : string mangled_name = mangledName;
156925 1089350 : if ( mangled_name.find('<') != string::npos )
156926 : {
156927 0 : printf ("In get_mangled_name(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
156928 : }
156929 1089350 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
156930 :
156931 : #if 0
156932 : // DQ (7/24/2012): Output the mangled name being generated for debugging.
156933 : printf (">>>>>>>>>> SgFunctionDeclaration::get_mangled_name(): returning mangledName = %s \n",mangledName.str());
156934 : #endif
156935 :
156936 1089350 : return mangledName;
156937 : }
156938 : }
156939 :
156940 : // SgStatement* get_next(int&) const;
156941 :
156942 : bool
156943 0 : SgFunctionDeclaration::replace_child(SgStatement *target,SgStatement *newstmt,
156944 : bool extractBasicBlock)
156945 : {
156946 0 : if ( StatementReplace(this, p_definition, target, newstmt) == true )
156947 : return true;
156948 : else
156949 0 : return ( StatementReplace(this, p_parameterList, target, newstmt) == true );
156950 : }
156951 :
156952 : #if 0
156953 : // DQ (8/18/2004): Removing older attribute mechanism
156954 :
156955 : /****** SgFunctionDeclaration ******/
156956 : /* suppress the printing of atomic keyword */
156957 : int
156958 : get_suppress_atomic (SgFunctionDeclaration *node)
156959 : {
156960 : SgFuncDecl_attr *attr=
156961 : (SgFuncDecl_attr *) Sgget_user_attribute
156962 : (node->get_uattributes(),"SgFuncDecl_attr");
156963 : if(attr)
156964 : return attr->get_suppress_atomic();
156965 :
156966 : return 0;
156967 : }
156968 : #endif
156969 :
156970 : // DQ (10/20/2004): Since constructor names don't require their template arguments this has a far simpler solution!
156971 : // for example: "template <typename T> class X { X(); }; X<int>::X() {}"
156972 :
156973 : // DQ (10/20/2004): This function should be different from those that are automatically generated
156974 : // via ROSETTA. In the case of a constructor or destructor the class name should be used. This
156975 : // is particularly important in the case of constructors and destructors of templated classes since
156976 : // the mangled form or the template class should not be used since it will not allow the generated
156977 : // code to compile. Instead of names of the form "ABC____L8" we want names of the form "ABC<int>".
156978 : // These functions are now implemented explicitly instead of being automatically generated via ROSETTA.
156979 : // SgName get_name() const
156980 : // {
156981 : // SgName returnName = p_name;
156982 : // if ( get_specialFunctionModifier().isConstructor() ||
156983 : // get_specialFunctionModifier().isDestructor() ||
156984 : // get_specialFunctionModifier().isConversion() )
156985 : // {
156986 : // printf ("In SgFunctionDeclaration::get_name: case of a constructor, destructor or conversion operator \n");
156987 : // returnName = "Use the class Name";
156988 : // }
156989 : //
156990 : // return returnName;
156991 : // }
156992 :
156993 : // SgName SgFunctionDeclaration::get_qualified_name();
156994 : SgName
156995 108290 : SgFunctionDeclaration::get_qualified_name() const
156996 : {
156997 : // DQ (10/15/2004): This function is similar to the one for SgClassDeclaration.
156998 : // This function calls get_scope() which uses the parent pointers, thus
156999 : // it should not be called before the parent pointers are set (within the AST fixup after
157000 : // the Sage III AST is fully constructed).
157001 :
157002 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
157003 108290 : SgScopeStatement* scope = get_scope();
157004 108290 : ROSE_ASSERT(scope != NULL);
157005 :
157006 216580 : SgName returnName = SgName::assembleQualifiedName(scope->get_qualified_name(),get_name());
157007 108290 : return returnName;
157008 : }
157009 :
157010 :
157011 : bool
157012 1252700 : SgFunctionDeclaration::hasExplicitScope() const
157013 : {
157014 : // This function reports that this IR node stores its scope explicitly.
157015 :
157016 1252700 : return true;
157017 : }
157018 :
157019 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
157020 : SgSymbol*
157021 13011200 : SgFunctionDeclaration::get_symbol_from_symbol_table() const
157022 : {
157023 13011200 : SgScopeStatement* scope = get_scope();
157024 13011200 : ROSE_ASSERT(scope != NULL);
157025 :
157026 : // DQ (3/1/2014): This could be a scope from a deleted AST and if we would like to
157027 : // think that the SgFunctionDeclaration would have been deleted, but it could have
157028 : // been the first non-defining declaration constructed to support the symbol), and
157029 : // thus not strictly in the AST. In this case so we would like return NULL.
157030 : // The test for if this is a deletec IR node is if the variant is V_SgNode.
157031 13011200 : if (scope->variantT() == V_SgNode)
157032 : {
157033 0 : printf ("SgFunctionDeclaration::get_symbol_from_symbol_table(): This is a deleted IR node (returning NULL) \n");
157034 0 : return NULL;
157035 : }
157036 13011200 : ROSE_ASSERT(scope->variantT() != V_SgNode);
157037 :
157038 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
157039 : #if 0
157040 : printf ("In SgFunctionDeclaration::get_symbol_from_symbol_table(): this = %p = %s = %s scope = %p = %s scope->get_symbol_table() = %p \n",
157041 : this,this->class_name().c_str(),SageInterface::get_name(this).c_str(),scope,scope->class_name().c_str(),scope->get_symbol_table());
157042 : #endif
157043 : // return scope->get_symbol_table()->find(this);
157044 13011200 : return scope->find_symbol_from_declaration(this);
157045 :
157046 : // ROSE_ASSERT(get_scope() != NULL);
157047 : // return get_scope()->get_symbol_table()->find(this);
157048 : }
157049 :
157050 :
157051 : SgName
157052 203495 : SgFunctionDeclaration::get_qualified_name_prefix_for_return_type() const
157053 : {
157054 : // DQ (5/29/2011): Added to support for new qualified name generation.
157055 :
157056 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
157057 : // different and so it depends upon where the type is referenced. Thus the qualified name is
157058 : // stored in a map to the IR node that references the type.
157059 203495 : SgName nameQualifier;
157060 203495 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgFunctionDeclaration*>(this));
157061 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
157062 :
157063 203495 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
157064 : {
157065 203385 : nameQualifier = i->second;
157066 : // printf ("Found a valid name qualification: nameQualifier %s \n",nameQualifier.str());
157067 : }
157068 :
157069 : // printf ("nameQualifier for SgFunctionDeclaration = %s = %s \n",class_name().c_str(),nameQualifier.str());
157070 :
157071 203495 : return nameQualifier;
157072 : }
157073 :
157074 : SgName
157075 0 : SgFunctionDeclaration::get_template_header() const
157076 : {
157077 : // DQ (9/7/2014): Added to support template headers in template declarations (member and non-member function declarations).
157078 :
157079 0 : SgName template_header;
157080 0 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTemplateHeaders().find(const_cast<SgFunctionDeclaration*>(this));
157081 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
157082 :
157083 0 : if (i != SgNode::get_globalQualifiedNameMapForTemplateHeaders().end())
157084 : {
157085 0 : template_header = i->second;
157086 : #if 0
157087 : printf ("Found a valid template header : template_header %s \n",template_header.str());
157088 : #endif
157089 : }
157090 : #if 0
157091 : printf ("template_header for SgFunctionDeclaration = %p = %s = %s \n",this,class_name().c_str(),template_header.str());
157092 : #endif
157093 :
157094 0 : return template_header;
157095 : }
157096 :
157097 :
157098 : bool
157099 1185860 : SgFunctionDeclaration::isNormalizedTemplateFunction() const
157100 : {
157101 : // DQ (12/22/2014): Adding support for EDG normalized template member and non-member functions.
157102 : // EDG normalizes member and non-member function definitions defined in template classes.
157103 : // As a result we need to detect where this normalization is done in both the unparser and
157104 : // the token mapping. Where the normalization has been done the text string saved in EDG
157105 : // and used in ROSE is only representing the body of the function and so the unparser must
157106 : // know to generate the function prototype declaration to assemble with the function body
157107 : // held as text. In the future we will unparse the template declarations from the AST and/or
157108 : // the token stream, but that is a later step.
157109 :
157110 1185860 : bool string_represents_function_body = false;
157111 1185860 : const SgTemplateFunctionDeclaration* templateFunctionDeclaration = isSgTemplateFunctionDeclaration(this);
157112 1185860 : const SgTemplateMemberFunctionDeclaration* templateMemberFunctionDeclaration = isSgTemplateMemberFunctionDeclaration(this);
157113 1185860 : if (templateFunctionDeclaration != NULL)
157114 : {
157115 : // printf ("This is a SgTemplateFunctionDeclaration \n");
157116 28 : string_represents_function_body = templateFunctionDeclaration->get_string_represents_function_body();
157117 : }
157118 : else
157119 : {
157120 1185840 : if (templateMemberFunctionDeclaration != NULL)
157121 : {
157122 : // printf ("This is a SgTemplateMemberFunctionDeclaration \n");
157123 9934 : string_represents_function_body = templateMemberFunctionDeclaration->get_string_represents_function_body();
157124 : // template_function_name = templateMemberFunctionDeclaration->get_name();
157125 : }
157126 : else
157127 : {
157128 : #if 0
157129 : // This is likely a SgTemplateClassDeclaration
157130 : if (isSgTemplateClassDeclaration(this) == NULL)
157131 : {
157132 : printf ("Error: In SgFunctionDeclaration::isNormalizedTemplateFunction(): What is this if not a template function or template member function stmt = %p = %s \n",this,this->class_name().c_str());
157133 : }
157134 : #endif
157135 : }
157136 : }
157137 :
157138 1185860 : return string_represents_function_body;
157139 : }
157140 :
157141 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
157142 : // so that we could avoid them setting the isModified flag which is a problem in the
157143 : // name qualification support for C++ (interfering with the token-based unparsing).
157144 : int
157145 1010 : SgFunctionDeclaration::get_name_qualification_length () const
157146 : {
157147 1010 : ROSE_ASSERT (this != NULL);
157148 1010 : return p_name_qualification_length;
157149 : }
157150 :
157151 : void
157152 12060 : SgFunctionDeclaration::set_name_qualification_length ( int name_qualification_length )
157153 : {
157154 12060 : ROSE_ASSERT (this != NULL);
157155 : // This can't be called by the name qualification API (see test2015_26.C).
157156 : // set_isModified(true);
157157 :
157158 12060 : p_name_qualification_length = name_qualification_length;
157159 12060 : }
157160 :
157161 : bool
157162 0 : SgFunctionDeclaration::get_type_elaboration_required () const
157163 : {
157164 0 : ROSE_ASSERT (this != NULL);
157165 0 : return p_type_elaboration_required;
157166 : }
157167 :
157168 : void
157169 12060 : SgFunctionDeclaration::set_type_elaboration_required ( bool type_elaboration_required )
157170 : {
157171 12060 : ROSE_ASSERT (this != NULL);
157172 : // This can't be called by the name qualification API (see test2015_26.C).
157173 : // set_isModified(true);
157174 :
157175 12060 : p_type_elaboration_required = type_elaboration_required;
157176 12060 : }
157177 :
157178 : bool
157179 1010 : SgFunctionDeclaration::get_global_qualification_required () const
157180 : {
157181 1010 : ROSE_ASSERT (this != NULL);
157182 1010 : return p_global_qualification_required;
157183 : }
157184 :
157185 : void
157186 12060 : SgFunctionDeclaration::set_global_qualification_required ( bool global_qualification_required )
157187 : {
157188 12060 : ROSE_ASSERT (this != NULL);
157189 :
157190 : // This can't be called by the name qualification API (see test2015_26.C).
157191 : // set_isModified(true);
157192 :
157193 12060 : p_global_qualification_required = global_qualification_required;
157194 12060 : }
157195 :
157196 : bool
157197 855 : SgFunctionDeclaration::get_requiresNameQualificationOnReturnType () const
157198 : {
157199 855 : ROSE_ASSERT (this != NULL);
157200 855 : return p_requiresNameQualificationOnReturnType;
157201 : }
157202 :
157203 : void
157204 0 : SgFunctionDeclaration::set_requiresNameQualificationOnReturnType ( bool requiresNameQualificationOnReturnType )
157205 : {
157206 0 : ROSE_ASSERT (this != NULL);
157207 : // This can't be called by the name qualification API (see test2015_26.C).
157208 : // set_isModified(true);
157209 :
157210 0 : p_requiresNameQualificationOnReturnType = requiresNameQualificationOnReturnType;
157211 0 : }
157212 :
157213 :
157214 : int
157215 855 : SgFunctionDeclaration::get_name_qualification_length_for_return_type() const
157216 : {
157217 855 : ROSE_ASSERT (this != NULL);
157218 855 : return p_name_qualification_length_for_return_type;
157219 : }
157220 :
157221 : void
157222 205919 : SgFunctionDeclaration::set_name_qualification_length_for_return_type(int name_qualification_length_for_return_type)
157223 : {
157224 205919 : ROSE_ASSERT (this != NULL);
157225 : // This can't be called by the name qualification API (see test2015_26.C).
157226 : // set_isModified(true);
157227 :
157228 205919 : p_name_qualification_length_for_return_type = name_qualification_length_for_return_type;
157229 205919 : }
157230 :
157231 : bool
157232 855 : SgFunctionDeclaration::get_type_elaboration_required_for_return_type() const
157233 : {
157234 855 : ROSE_ASSERT (this != NULL);
157235 855 : return p_type_elaboration_required_for_return_type;
157236 : }
157237 :
157238 : void
157239 205919 : SgFunctionDeclaration::set_type_elaboration_required_for_return_type(bool type_elaboration_required_for_return_type)
157240 : {
157241 205919 : ROSE_ASSERT (this != NULL);
157242 : // This can't be called by the name qualification API (see test2015_26.C).
157243 : // set_isModified(true);
157244 :
157245 205919 : p_type_elaboration_required_for_return_type = type_elaboration_required_for_return_type;
157246 205919 : }
157247 :
157248 : bool
157249 855 : SgFunctionDeclaration::get_global_qualification_required_for_return_type() const
157250 : {
157251 855 : ROSE_ASSERT (this != NULL);
157252 855 : return p_global_qualification_required_for_return_type;
157253 : }
157254 :
157255 : void
157256 205919 : SgFunctionDeclaration::set_global_qualification_required_for_return_type(bool global_qualification_required_for_return_type)
157257 : {
157258 205919 : ROSE_ASSERT (this != NULL);
157259 : // This can't be called by the name qualification API (see test2015_26.C).
157260 : // set_isModified(true);
157261 :
157262 205919 : p_global_qualification_required_for_return_type = global_qualification_required_for_return_type;
157263 205919 : }
157264 :
157265 :
157266 :
157267 :
157268 : // End of memberFunctionString
157269 : // Start of memberFunctionString
157270 : /* #line 9727 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
157271 :
157272 :
157273 : bool
157274 35889 : SgFunctionDeclaration::isSpecialization() const
157275 : {
157276 35889 : bool returnValue = false;
157277 35889 : returnValue = (p_specialization == SgDeclarationStatement::e_specialization);
157278 35889 : return returnValue;
157279 : }
157280 :
157281 : bool
157282 10224 : SgFunctionDeclaration::isPartialSpecialization() const
157283 : {
157284 10224 : bool returnValue = false;
157285 10224 : returnValue = (p_specialization == SgDeclarationStatement::e_partial_specialization);
157286 10224 : return returnValue;
157287 : }
157288 :
157289 :
157290 :
157291 : // End of memberFunctionString
157292 : // Start of memberFunctionString
157293 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
157294 :
157295 : // *** COMMON CODE SECTION BEGINS HERE ***
157296 :
157297 : #if 0
157298 : int
157299 : SgFunctionDeclaration::getVariant() const
157300 : {
157301 : // This function is used in ROSE while "variant()" is used in SAGE
157302 : assert(this != NULL);
157303 : return variant();
157304 : }
157305 : #endif
157306 :
157307 : // This function is used in ROSE in treeTraversal code
157308 : // eventually replaces getVariant() and variant()
157309 : // though after variant() has been removed for a while we will
157310 : // want to change the name of variantT() back to variant()
157311 : // (since the "T" was ment to stand for temporary).
157312 : // When this happens the variantT() will be depricated.
157313 : VariantT
157314 1177660000 : SgFunctionDeclaration::variantT() const
157315 : {
157316 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
157317 1177660000 : ROSE_ASSERT(this != NULL);
157318 1177660000 : return V_SgFunctionDeclaration;
157319 : }
157320 :
157321 : #if 0
157322 : int
157323 : SgFunctionDeclaration::variant() const
157324 : {
157325 : // This function is used in SAGE
157326 : ROSE_ASSERT(this != NULL);
157327 : return FUNC_DECL_STMT;
157328 : }
157329 : #endif
157330 :
157331 : ROSE_DLL_API const char*
157332 271 : SgFunctionDeclaration::sage_class_name() const
157333 : {
157334 271 : ROSE_ASSERT(this != NULL);
157335 271 : return "SgFunctionDeclaration";
157336 : }
157337 :
157338 : std::string
157339 1085510 : SgFunctionDeclaration::class_name() const
157340 : {
157341 1085510 : ROSE_ASSERT(this != NULL);
157342 1085510 : return "SgFunctionDeclaration";
157343 : }
157344 :
157345 : // DQ (11/26/2005): Support for visitor pattern mechanims
157346 : // (inferior to ROSE traversal mechanism, experimental).
157347 : void
157348 824638 : SgFunctionDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
157349 : {
157350 824638 : ROSE_ASSERT(this != NULL);
157351 824638 : visitor.visit(this);
157352 824638 : }
157353 :
157354 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
157355 0 : void SgFunctionDeclaration::accept (ROSE_VisitorPattern & visitor) {
157356 0 : ROSE_ASSERT(this != NULL);
157357 0 : visitor.visit(this);
157358 0 : }
157359 :
157360 : SgFunctionDeclaration*
157361 0 : SgFunctionDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
157362 : {
157363 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
157364 : // This function is currently only supported for the AST used the represent Binary executables.
157365 : if (0 /* isSgAsmNode(this) != NULL */)
157366 : {
157367 : // Support for regex specification.
157368 : std::string prefixCode = "REGEX:";
157369 : addNewAttribute(prefixCode + s,a);
157370 : }
157371 : #endif
157372 :
157373 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
157374 0 : return this;
157375 : }
157376 :
157377 : // *** COMMON CODE SECTION ENDS HERE ***
157378 :
157379 :
157380 : // End of memberFunctionString
157381 : // Start of memberFunctionString
157382 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
157383 :
157384 :
157385 : #if 0
157386 : //! Error checking support
157387 : /*! Verifies the following:
157388 : - working getVariant() member function
157389 : - calls base class's error() member function
157390 : Every class has one of these functions.
157391 : */
157392 : bool
157393 : SgFunctionDeclaration::error()
157394 : {
157395 : // Put error checking here
157396 :
157397 : ROSE_ASSERT (this != NULL);
157398 : if (getVariant() != FUNC_DECL_STMT)
157399 : {
157400 : printf ("Error in SgFunctionDeclaration::error(): SgFunctionDeclaration object has a %s variant \n",
157401 : Cxx_GrammarTerminalNames[getVariant()].name);
157402 : // printf ("Error in SgFunctionDeclaration::error() \n");
157403 : ROSE_ABORT();
157404 : }
157405 :
157406 : ROSE_ASSERT (getVariant() == FUNC_DECL_STMT);
157407 : return SgDeclarationStatement::error();
157408 : }
157409 : #endif
157410 :
157411 :
157412 :
157413 : // End of memberFunctionString
157414 :
157415 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
157416 :
157417 96302900 : SgFunctionDeclaration* isSgFunctionDeclaration ( SgNode* inputDerivedClassPointer )
157418 : {
157419 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
157420 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
157421 : // So to fix this we return NULL directly when the input is NULL and avoid the
157422 : // dynamic_cast in this case. This is likely a performance improvement as well.
157423 : // return dynamic_cast<SgFunctionDeclaration*>(inputDerivedClassPointer);
157424 : // Milind Chabbi (8/28/2013): isSgFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
157425 : // this improves the running time performance by 10-20%.
157426 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionDeclaration*>(inputDerivedClassPointer);
157427 96302900 : return IS_SgFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
157428 : }
157429 :
157430 : // DQ (11/8/2003): Added version of functions taking const pointer
157431 16072200 : const SgFunctionDeclaration* isSgFunctionDeclaration ( const SgNode* inputDerivedClassPointer )
157432 : {
157433 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
157434 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
157435 : // So to fix this we return NULL directly when the input is NULL and avoid the
157436 : // dynamic_cast in this case. This is likely a performance improvement as well.
157437 : // return dynamic_cast<const SgFunctionDeclaration*>(inputDerivedClassPointer);
157438 : // Milind Chabbi (8/28/2013): isSgFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
157439 : // this improves the running time performance by 10-20%.
157440 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionDeclaration*>(inputDerivedClassPointer);
157441 16072200 : return IS_SgFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
157442 : }
157443 :
157444 :
157445 :
157446 : /* #line 157447 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
157447 :
157448 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
157449 :
157450 : /**
157451 : \brief Generated destructor
157452 :
157453 : This destructor is automatically generated (by ROSETTA). This destructor
157454 : only frees memory of data members associated with the parts of the current IR node which
157455 : are NOT traversed. Those data members that are part of a traversal can be freed using
157456 : a traversal (calling this destructor on all children in a post-order traversal). Such
157457 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
157458 :
157459 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
157460 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
157461 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
157462 :
157463 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
157464 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
157465 : pointers are not yet implemented to call delete on eash pointer in the container.
157466 : (This could be done by derivation from the STL containers to define containers that
157467 : automatically deleted their members.)
157468 :
157469 : */
157470 42475 : SgFunctionDeclaration::~SgFunctionDeclaration () {
157471 26607 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
157472 :
157473 :
157474 : // case: not a listType for name
157475 26607 : p_name = ""; // non list case
157476 : // case: not a listType for parameterList
157477 26607 : p_parameterList = NULL; // non list case
157478 : // case: not a listType for named_in_end_statement
157479 26607 : p_named_in_end_statement = false; // non list case
157480 : // case: not a listType for asm_name
157481 26607 : p_asm_name = ""; // non list case
157482 : // case: not a listType for decoratorList
157483 26607 : p_decoratorList = NULL; // non list case
157484 : // case: not a listType for ada_formal_subprogram_decl
157485 26607 : p_ada_formal_subprogram_decl = false; // non list case
157486 : // case: not a listType for type
157487 26607 : p_type = NULL; // non list case
157488 : // case: not a listType for definition
157489 26607 : p_definition = NULL; // non list case
157490 : // case: not a listType for oldStyleDefinition
157491 26607 : p_oldStyleDefinition = false; // non list case
157492 : // case: not a listType for scope
157493 26607 : p_scope = NULL; // non list case
157494 : // case: not a listType for specialization
157495 26607 : p_specialization = SgDeclarationStatement::e_no_specialization; // non list case
157496 : // case: not a listType for requiresNameQualificationOnReturnType
157497 26607 : p_requiresNameQualificationOnReturnType = false; // non list case
157498 : // case: not a listType for gnu_extension_section
157499 26607 : p_gnu_extension_section = ""; // non list case
157500 : // case: not a listType for gnu_extension_alias
157501 26607 : p_gnu_extension_alias = ""; // non list case
157502 : // case: not a listType for gnu_extension_visability
157503 26607 : p_gnu_extension_visability = SgDeclarationStatement::e_gnu_attribute_visability_unspecified; // non list case
157504 : // case: not a listType for name_qualification_length
157505 26607 : p_name_qualification_length = 0; // non list case
157506 : // case: not a listType for type_elaboration_required
157507 26607 : p_type_elaboration_required = false; // non list case
157508 : // case: not a listType for global_qualification_required
157509 26607 : p_global_qualification_required = false; // non list case
157510 : // case: not a listType for name_qualification_length_for_return_type
157511 26607 : p_name_qualification_length_for_return_type = 0; // non list case
157512 : // case: not a listType for type_elaboration_required_for_return_type
157513 26607 : p_type_elaboration_required_for_return_type = false; // non list case
157514 : // case: not a listType for global_qualification_required_for_return_type
157515 26607 : p_global_qualification_required_for_return_type = false; // non list case
157516 : // case: not a listType for prototypeIsWithoutParameters
157517 26607 : p_prototypeIsWithoutParameters = false; // non list case
157518 : // case: not a listType for gnu_regparm_attribute
157519 26607 : p_gnu_regparm_attribute = -1; // non list case
157520 : // case: not a listType for type_syntax
157521 26607 : p_type_syntax = NULL; // non list case
157522 : // case: not a listType for type_syntax_is_available
157523 26607 : p_type_syntax_is_available = false; // non list case
157524 : // case: not a listType for parameterList_syntax
157525 26607 : p_parameterList_syntax = NULL; // non list case
157526 : // case: not a listType for using_C11_Noreturn_keyword
157527 26607 : p_using_C11_Noreturn_keyword = false; // non list case
157528 : // case: not a listType for is_constexpr
157529 26607 : p_is_constexpr = false; // non list case
157530 : // case: not a listType for using_new_function_return_type_syntax
157531 26607 : p_using_new_function_return_type_syntax = false; // non list case
157532 : // case: not a listType for functionParameterScope
157533 26607 : p_functionParameterScope = NULL; // non list case
157534 : // case: not a listType for marked_as_edg_normalization
157535 26607 : p_marked_as_edg_normalization = false; // non list case
157536 : // case: not a listType for is_implicit_function
157537 26607 : p_is_implicit_function = false; // non list case
157538 :
157539 : }
157540 :
157541 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
157542 42439 : }
157543 :
157544 :
157545 : /* #line 157546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
157546 :
157547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
157548 :
157549 : // Generated constructor
157550 5 : SgFunctionDeclaration::SgFunctionDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
157551 5 : : SgDeclarationStatement(startOfConstruct)
157552 : {
157553 : #ifdef DEBUG
157554 : // printf ("In SgFunctionDeclaration::SgFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
157555 : #endif
157556 : #if 0
157557 : // debugging information!
157558 : printf ("In SgFunctionDeclaration::SgFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
157559 : #endif
157560 :
157561 5 : p_name = name;
157562 5 : p_parameterList = NULL;
157563 5 : p_named_in_end_statement = false;
157564 5 : p_asm_name = "";
157565 5 : p_decoratorList = NULL;
157566 5 : p_ada_formal_subprogram_decl = false;
157567 5 : p_type = type;
157568 5 : p_definition = definition;
157569 5 : p_oldStyleDefinition = false;
157570 5 : p_scope = NULL;
157571 5 : p_specialization = SgDeclarationStatement::e_no_specialization;
157572 5 : p_requiresNameQualificationOnReturnType = false;
157573 5 : p_gnu_extension_section = "";
157574 5 : p_gnu_extension_alias = "";
157575 5 : p_gnu_extension_visability = SgDeclarationStatement::e_gnu_attribute_visability_unspecified;
157576 5 : p_name_qualification_length = 0;
157577 5 : p_type_elaboration_required = false;
157578 5 : p_global_qualification_required = false;
157579 5 : p_name_qualification_length_for_return_type = 0;
157580 5 : p_type_elaboration_required_for_return_type = false;
157581 5 : p_global_qualification_required_for_return_type = false;
157582 5 : p_prototypeIsWithoutParameters = false;
157583 5 : p_gnu_regparm_attribute = -1;
157584 5 : p_type_syntax = NULL;
157585 5 : p_type_syntax_is_available = false;
157586 5 : p_parameterList_syntax = NULL;
157587 5 : p_using_C11_Noreturn_keyword = false;
157588 5 : p_is_constexpr = false;
157589 5 : p_using_new_function_return_type_syntax = false;
157590 5 : p_functionParameterScope = NULL;
157591 5 : p_marked_as_edg_normalization = false;
157592 5 : p_is_implicit_function = false;
157593 :
157594 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
157595 :
157596 : #if 0
157597 : // DQ (7/30/2014): Call a virtual function.
157598 : std::string s = this->class_name();
157599 : #endif
157600 :
157601 : // Test the variant virtual function
157602 : // assert(FUNC_DECL_STMT == variant());
157603 5 : assert(FUNC_DECL_STMT == this->variant());
157604 5 : ROSE_ASSERT(FUNC_DECL_STMT == (int)(this->variantT()));
157605 5 : post_construction_initialization();
157606 :
157607 : // Test the isSgFunctionDeclaration() function since it has been problematic
157608 5 : assert(isSgFunctionDeclaration(this) != NULL);
157609 5 : }
157610 :
157611 : // Generated constructor (all data members)
157612 :
157613 : /* #line 157614 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
157614 :
157615 :
157616 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
157617 :
157618 :
157619 : // ********************************************************
157620 : // member functions common across all array grammar objects
157621 : // ********************************************************
157622 :
157623 :
157624 :
157625 : /* #line 157626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
157626 :
157627 :
157628 :
157629 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
157630 :
157631 : // ********************************************************
157632 : // member functions specific to each node in the grammar
157633 : // ********************************************************
157634 :
157635 :
157636 : /* #line 157637 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
157637 :
157638 : // Start of memberFunctionString
157639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
157640 :
157641 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
157642 :
157643 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
157644 : const SgTemplateParameterPtrList &
157645 0 : SgTemplateFunctionDeclaration::get_templateParameters () const
157646 : {
157647 0 : assert (this != NULL);
157648 0 : return p_templateParameters;
157649 : }
157650 :
157651 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
157652 : SgTemplateParameterPtrList &
157653 109987 : SgTemplateFunctionDeclaration::get_templateParameters ()
157654 : {
157655 109987 : assert (this != NULL);
157656 :
157657 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
157658 : // As a rule only set_ access functions can set the isModified flag.
157659 : // set_isModified(true);
157660 :
157661 109987 : return p_templateParameters;
157662 : }
157663 :
157664 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
157665 :
157666 :
157667 : // End of memberFunctionString
157668 : // Start of memberFunctionString
157669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
157670 :
157671 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
157672 :
157673 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
157674 : const SgTemplateArgumentPtrList &
157675 0 : SgTemplateFunctionDeclaration::get_templateSpecializationArguments () const
157676 : {
157677 0 : assert (this != NULL);
157678 0 : return p_templateSpecializationArguments;
157679 : }
157680 :
157681 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
157682 : SgTemplateArgumentPtrList &
157683 4341 : SgTemplateFunctionDeclaration::get_templateSpecializationArguments ()
157684 : {
157685 4341 : assert (this != NULL);
157686 :
157687 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
157688 : // As a rule only set_ access functions can set the isModified flag.
157689 : // set_isModified(true);
157690 :
157691 4341 : return p_templateSpecializationArguments;
157692 : }
157693 :
157694 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
157695 :
157696 :
157697 : // End of memberFunctionString
157698 : // Start of memberFunctionString
157699 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
157700 :
157701 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
157702 :
157703 : SgName
157704 24 : SgTemplateFunctionDeclaration::get_string () const
157705 : {
157706 24 : ROSE_ASSERT (this != NULL);
157707 :
157708 : #if 0
157709 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
157710 : // used to trigger marking transformations for the token-based unparsing.
157711 : printf ("SgTemplateFunctionDeclaration::get_string = %p = %s \n",this,this->class_name().c_str());
157712 : #endif
157713 :
157714 24 : return p_string;
157715 : }
157716 :
157717 : void
157718 3977 : SgTemplateFunctionDeclaration::set_string ( SgName string )
157719 : {
157720 3977 : ROSE_ASSERT (this != NULL);
157721 :
157722 : #if 0
157723 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
157724 : // used to trigger marking transformations for the token-based unparsing.
157725 : printf ("SgTemplateFunctionDeclaration::set_string = %p = %s \n",this,this->class_name().c_str());
157726 : #endif
157727 :
157728 3977 : set_isModified(true);
157729 :
157730 3977 : p_string = string;
157731 3977 : }
157732 :
157733 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
157734 :
157735 :
157736 : // End of memberFunctionString
157737 : // Start of memberFunctionString
157738 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
157739 :
157740 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
157741 :
157742 : bool
157743 52 : SgTemplateFunctionDeclaration::get_string_represents_function_body () const
157744 : {
157745 52 : ROSE_ASSERT (this != NULL);
157746 :
157747 : #if 0
157748 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
157749 : // used to trigger marking transformations for the token-based unparsing.
157750 : printf ("SgTemplateFunctionDeclaration::get_string_represents_function_body = %p = %s \n",this,this->class_name().c_str());
157751 : #endif
157752 :
157753 52 : return p_string_represents_function_body;
157754 : }
157755 :
157756 : void
157757 0 : SgTemplateFunctionDeclaration::set_string_represents_function_body ( bool string_represents_function_body )
157758 : {
157759 0 : ROSE_ASSERT (this != NULL);
157760 :
157761 : #if 0
157762 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
157763 : // used to trigger marking transformations for the token-based unparsing.
157764 : printf ("SgTemplateFunctionDeclaration::set_string_represents_function_body = %p = %s \n",this,this->class_name().c_str());
157765 : #endif
157766 :
157767 0 : set_isModified(true);
157768 :
157769 0 : p_string_represents_function_body = string_represents_function_body;
157770 0 : }
157771 :
157772 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
157773 :
157774 :
157775 : // End of memberFunctionString
157776 : // Start of memberFunctionString
157777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
157778 :
157779 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
157780 :
157781 : SgDeclarationScope*
157782 0 : SgTemplateFunctionDeclaration::get_nonreal_decl_scope () const
157783 : {
157784 0 : ROSE_ASSERT (this != NULL);
157785 :
157786 : #if 0
157787 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
157788 : // used to trigger marking transformations for the token-based unparsing.
157789 : printf ("SgTemplateFunctionDeclaration::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
157790 : #endif
157791 :
157792 0 : return p_nonreal_decl_scope;
157793 : }
157794 :
157795 : void
157796 3977 : SgTemplateFunctionDeclaration::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
157797 : {
157798 3977 : ROSE_ASSERT (this != NULL);
157799 :
157800 : #if 0
157801 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
157802 : // used to trigger marking transformations for the token-based unparsing.
157803 : printf ("SgTemplateFunctionDeclaration::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
157804 : #endif
157805 :
157806 3977 : set_isModified(true);
157807 :
157808 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
157809 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
157810 : {
157811 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
157812 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
157813 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
157814 : ROSE_ASSERT(false);
157815 : #endif
157816 : }
157817 : #endif
157818 3977 : p_nonreal_decl_scope = nonreal_decl_scope;
157819 3977 : }
157820 :
157821 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
157822 :
157823 :
157824 : // End of memberFunctionString
157825 : // Start of memberFunctionString
157826 : /* #line 16772 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
157827 :
157828 : void
157829 6934 : SgTemplateFunctionDeclaration::post_construction_initialization()
157830 : {
157831 : // DQ (12/21/2011): This is not what we want for the newer design with SgTemplateVariableDeclaration derived from SgVariableDeclaration.
157832 : // this->set_template_kind(e_template_function);
157833 :
157834 : #if 0
157835 : // DQ (12/28/2011): This will overwrite the existing SgFunctionParameterList the base class.
157836 : // This code could be factored (copied from SgFunctionDeclaration::post_construction_initialization()).
157837 : SgFunctionParameterList* args = NULL;
157838 : if (get_startOfConstruct() != NULL)
157839 : {
157840 : args = new SgFunctionParameterList(New_File_Info(this));
157841 : args->get_startOfConstruct()->set_parent(args);
157842 : }
157843 : else
157844 : {
157845 : // DQ (11/12/2006): Use the new constructor.
157846 : args = new SgFunctionParameterList();
157847 : }
157848 :
157849 : ROSE_ASSERT (args != NULL);
157850 : set_parameterList(args);
157851 :
157852 : // DQ (7/19/2005): set the parent explicitly
157853 : get_parameterList()->set_parent(this);
157854 :
157855 : // DQ (3/6/2007): Set the firstNondefiningDeclaration of args to itself (this is now required
157856 : // for the AST consistency tests after the AST merge). Likely because one where a member function
157857 : // is referenced before being declared in a class the member function was not previously visited by
157858 : // the AST traversal and so one of its defining or non-defining declarations was not set and after
157859 : // the merge this declaration is used (shared) and thus accessed where before it had been hidden.
157860 : // DQ (3/15/2006): Let this be NULL so that it will be fixed by the fixupDeclarations function
157861 : // within the post processing phase.
157862 : // DQ (9/6/2005): Since a SgFunctionParameterList is a SgDeclarationStatement we should set
157863 : // either its defining or non-defining declaration (I choose the non-defining declaration).
157864 : // args->set_definingDeclaration(args);
157865 : // args->set_firstNondefiningDeclaration(args);
157866 : args->set_firstNondefiningDeclaration(args);
157867 : #else
157868 6934 : ROSE_ASSERT (get_parameterList() != NULL);
157869 :
157870 : // DQ (12/28/2011): set the parent explicitly
157871 6934 : get_parameterList()->set_parent(this);
157872 : #endif
157873 :
157874 :
157875 : #if 0
157876 : // This is already set in the constructor.
157877 :
157878 : // DQ (10/25/2004): Add a ending file info object for completeness (though this is not yet
157879 : // initialized to the correct position, yet). Initially let's get them in place then we can
157880 : // work on the accuracy afterward!
157881 : // Sg_File_Info* endingPosition = new Sg_File_Info(*thisFileInfo);
157882 : // ROSE_ASSERT (endingPosition != NULL);
157883 : // p_args->set_endOfConstruct(endingPosition);
157884 :
157885 : // DQ (7/31/2006): Explicit initialization of this data member is required!
157886 : // JJW (8/6/2008): It probably isn't now that p_exceptionSpecification is a vector
157887 : p_exceptionSpecification.clear();
157888 :
157889 : // DQ (5/14/2011): Added to support name qualification on types referenced by template arguments.
157890 : p_name_qualification_length = 0;
157891 : p_type_elaboration_required = false;
157892 : p_global_qualification_required = false;
157893 :
157894 : // DQ (5/14/2011): Added to support name qualification on types referenced by template arguments.
157895 : p_name_qualification_length_for_return_type = 0;
157896 : p_type_elaboration_required_for_return_type = false;
157897 : p_global_qualification_required_for_return_type = false;
157898 : #endif
157899 :
157900 : #if 0
157901 : // DQ (3/4/2018): relax this requirement for SgTemplateInstantiationClassDeclaration.
157902 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
157903 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
157904 : if (p_type != NULL)
157905 : {
157906 : printf ("Note: SgTemplateFunctionDeclaration::post_construction_initialization(): p_type != NULL: name = %s \n",p_name.str());
157907 : }
157908 : // ROSE_ASSERT(p_type == NULL);
157909 : #endif
157910 6934 : }
157911 :
157912 :
157913 :
157914 : // End of memberFunctionString
157915 : // Start of memberFunctionString
157916 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
157917 :
157918 : // *** COMMON CODE SECTION BEGINS HERE ***
157919 :
157920 : #if 0
157921 : int
157922 : SgTemplateFunctionDeclaration::getVariant() const
157923 : {
157924 : // This function is used in ROSE while "variant()" is used in SAGE
157925 : assert(this != NULL);
157926 : return variant();
157927 : }
157928 : #endif
157929 :
157930 : // This function is used in ROSE in treeTraversal code
157931 : // eventually replaces getVariant() and variant()
157932 : // though after variant() has been removed for a while we will
157933 : // want to change the name of variantT() back to variant()
157934 : // (since the "T" was ment to stand for temporary).
157935 : // When this happens the variantT() will be depricated.
157936 : VariantT
157937 8603430 : SgTemplateFunctionDeclaration::variantT() const
157938 : {
157939 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
157940 8603430 : ROSE_ASSERT(this != NULL);
157941 8603430 : return V_SgTemplateFunctionDeclaration;
157942 : }
157943 :
157944 : #if 0
157945 : int
157946 : SgTemplateFunctionDeclaration::variant() const
157947 : {
157948 : // This function is used in SAGE
157949 : ROSE_ASSERT(this != NULL);
157950 : return TEMPLATE_FUNCTION_DECL_STMT;
157951 : }
157952 : #endif
157953 :
157954 : ROSE_DLL_API const char*
157955 322 : SgTemplateFunctionDeclaration::sage_class_name() const
157956 : {
157957 322 : ROSE_ASSERT(this != NULL);
157958 322 : return "SgTemplateFunctionDeclaration";
157959 : }
157960 :
157961 : std::string
157962 5544 : SgTemplateFunctionDeclaration::class_name() const
157963 : {
157964 5544 : ROSE_ASSERT(this != NULL);
157965 5544 : return "SgTemplateFunctionDeclaration";
157966 : }
157967 :
157968 : // DQ (11/26/2005): Support for visitor pattern mechanims
157969 : // (inferior to ROSE traversal mechanism, experimental).
157970 : void
157971 94304 : SgTemplateFunctionDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
157972 : {
157973 94304 : ROSE_ASSERT(this != NULL);
157974 94304 : visitor.visit(this);
157975 94304 : }
157976 :
157977 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
157978 0 : void SgTemplateFunctionDeclaration::accept (ROSE_VisitorPattern & visitor) {
157979 0 : ROSE_ASSERT(this != NULL);
157980 0 : visitor.visit(this);
157981 0 : }
157982 :
157983 : SgTemplateFunctionDeclaration*
157984 0 : SgTemplateFunctionDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
157985 : {
157986 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
157987 : // This function is currently only supported for the AST used the represent Binary executables.
157988 : if (0 /* isSgAsmNode(this) != NULL */)
157989 : {
157990 : // Support for regex specification.
157991 : std::string prefixCode = "REGEX:";
157992 : addNewAttribute(prefixCode + s,a);
157993 : }
157994 : #endif
157995 :
157996 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
157997 0 : return this;
157998 : }
157999 :
158000 : // *** COMMON CODE SECTION ENDS HERE ***
158001 :
158002 :
158003 : // End of memberFunctionString
158004 : // Start of memberFunctionString
158005 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
158006 :
158007 :
158008 : #if 0
158009 : //! Error checking support
158010 : /*! Verifies the following:
158011 : - working getVariant() member function
158012 : - calls base class's error() member function
158013 : Every class has one of these functions.
158014 : */
158015 : bool
158016 : SgTemplateFunctionDeclaration::error()
158017 : {
158018 : // Put error checking here
158019 :
158020 : ROSE_ASSERT (this != NULL);
158021 : if (getVariant() != TEMPLATE_FUNCTION_DECL_STMT)
158022 : {
158023 : printf ("Error in SgTemplateFunctionDeclaration::error(): SgTemplateFunctionDeclaration object has a %s variant \n",
158024 : Cxx_GrammarTerminalNames[getVariant()].name);
158025 : // printf ("Error in SgTemplateFunctionDeclaration::error() \n");
158026 : ROSE_ABORT();
158027 : }
158028 :
158029 : ROSE_ASSERT (getVariant() == TEMPLATE_FUNCTION_DECL_STMT);
158030 : return SgFunctionDeclaration::error();
158031 : }
158032 : #endif
158033 :
158034 :
158035 :
158036 : // End of memberFunctionString
158037 :
158038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
158039 :
158040 16094800 : SgTemplateFunctionDeclaration* isSgTemplateFunctionDeclaration ( SgNode* inputDerivedClassPointer )
158041 : {
158042 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
158043 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
158044 : // So to fix this we return NULL directly when the input is NULL and avoid the
158045 : // dynamic_cast in this case. This is likely a performance improvement as well.
158046 : // return dynamic_cast<SgTemplateFunctionDeclaration*>(inputDerivedClassPointer);
158047 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
158048 : // this improves the running time performance by 10-20%.
158049 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateFunctionDeclaration*>(inputDerivedClassPointer);
158050 16094800 : return IS_SgTemplateFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
158051 : }
158052 :
158053 : // DQ (11/8/2003): Added version of functions taking const pointer
158054 1237750 : const SgTemplateFunctionDeclaration* isSgTemplateFunctionDeclaration ( const SgNode* inputDerivedClassPointer )
158055 : {
158056 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
158057 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
158058 : // So to fix this we return NULL directly when the input is NULL and avoid the
158059 : // dynamic_cast in this case. This is likely a performance improvement as well.
158060 : // return dynamic_cast<const SgTemplateFunctionDeclaration*>(inputDerivedClassPointer);
158061 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
158062 : // this improves the running time performance by 10-20%.
158063 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateFunctionDeclaration*>(inputDerivedClassPointer);
158064 1237750 : return IS_SgTemplateFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
158065 : }
158066 :
158067 :
158068 :
158069 : /* #line 158070 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158070 :
158071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
158072 :
158073 : /**
158074 : \brief Generated destructor
158075 :
158076 : This destructor is automatically generated (by ROSETTA). This destructor
158077 : only frees memory of data members associated with the parts of the current IR node which
158078 : are NOT traversed. Those data members that are part of a traversal can be freed using
158079 : a traversal (calling this destructor on all children in a post-order traversal). Such
158080 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
158081 :
158082 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
158083 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
158084 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
158085 :
158086 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
158087 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
158088 : pointers are not yet implemented to call delete on eash pointer in the container.
158089 : (This could be done by derivation from the STL containers to define containers that
158090 : automatically deleted their members.)
158091 :
158092 : */
158093 4042 : SgTemplateFunctionDeclaration::~SgTemplateFunctionDeclaration () {
158094 1352 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
158095 :
158096 1352 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
158097 :
158098 : // case: listType for templateParameters
158099 : // case: listType (typeIsPointerToList == false) for templateParameters
158100 1352 : p_templateParameters.erase(p_templateParameters.begin(),p_templateParameters.end());
158101 : // case: listType for templateSpecializationArguments
158102 : // case: listType (typeIsPointerToList == false) for templateSpecializationArguments
158103 1352 : p_templateSpecializationArguments.erase(p_templateSpecializationArguments.begin(),p_templateSpecializationArguments.end());
158104 : // case: not a listType for string
158105 1352 : p_string = ""; // non list case
158106 : // case: not a listType for string_represents_function_body
158107 1352 : p_string_represents_function_body = false; // non list case
158108 : // case: not a listType for nonreal_decl_scope
158109 1352 : p_nonreal_decl_scope = NULL; // non list case
158110 :
158111 : }
158112 :
158113 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
158114 2704 : }
158115 :
158116 :
158117 : /* #line 158118 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158118 :
158119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
158120 :
158121 : // Generated constructor
158122 0 : SgTemplateFunctionDeclaration::SgTemplateFunctionDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
158123 0 : : SgFunctionDeclaration(startOfConstruct, name, type, definition)
158124 : {
158125 : #ifdef DEBUG
158126 : // printf ("In SgTemplateFunctionDeclaration::SgTemplateFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
158127 : #endif
158128 : #if 0
158129 : // debugging information!
158130 : printf ("In SgTemplateFunctionDeclaration::SgTemplateFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
158131 : #endif
158132 :
158133 0 : p_templateParameters = SgTemplateParameterPtrList();
158134 0 : p_templateSpecializationArguments = SgTemplateArgumentPtrList();
158135 0 : p_string = "";
158136 0 : p_string_represents_function_body = false;
158137 0 : p_nonreal_decl_scope = NULL;
158138 :
158139 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
158140 :
158141 : #if 0
158142 : // DQ (7/30/2014): Call a virtual function.
158143 : std::string s = this->class_name();
158144 : #endif
158145 :
158146 : // Test the variant virtual function
158147 : // assert(TEMPLATE_FUNCTION_DECL_STMT == variant());
158148 0 : assert(TEMPLATE_FUNCTION_DECL_STMT == this->variant());
158149 0 : ROSE_ASSERT(TEMPLATE_FUNCTION_DECL_STMT == (int)(this->variantT()));
158150 0 : post_construction_initialization();
158151 :
158152 : // Test the isSgTemplateFunctionDeclaration() function since it has been problematic
158153 0 : assert(isSgTemplateFunctionDeclaration(this) != NULL);
158154 0 : }
158155 :
158156 : // Generated constructor (all data members)
158157 :
158158 : /* #line 158159 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158159 :
158160 :
158161 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
158162 :
158163 :
158164 : // ********************************************************
158165 : // member functions common across all array grammar objects
158166 : // ********************************************************
158167 :
158168 :
158169 :
158170 : /* #line 158171 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158171 :
158172 :
158173 :
158174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
158175 :
158176 : // ********************************************************
158177 : // member functions specific to each node in the grammar
158178 : // ********************************************************
158179 :
158180 :
158181 : /* #line 158182 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158182 :
158183 : // Start of memberFunctionString
158184 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
158185 :
158186 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
158187 :
158188 : SgCtorInitializerList*
158189 117204 : SgMemberFunctionDeclaration::get_CtorInitializerList () const
158190 : {
158191 117204 : ROSE_ASSERT (this != NULL);
158192 :
158193 : #if 0
158194 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158195 : // used to trigger marking transformations for the token-based unparsing.
158196 : printf ("SgMemberFunctionDeclaration::get_CtorInitializerList = %p = %s \n",this,this->class_name().c_str());
158197 : #endif
158198 :
158199 117204 : return p_CtorInitializerList;
158200 : }
158201 :
158202 : void
158203 0 : SgMemberFunctionDeclaration::set_CtorInitializerList ( SgCtorInitializerList* CtorInitializerList )
158204 : {
158205 0 : ROSE_ASSERT (this != NULL);
158206 :
158207 : #if 0
158208 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158209 : // used to trigger marking transformations for the token-based unparsing.
158210 : printf ("SgMemberFunctionDeclaration::set_CtorInitializerList = %p = %s \n",this,this->class_name().c_str());
158211 : #endif
158212 :
158213 0 : set_isModified(true);
158214 :
158215 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
158216 : if (p_CtorInitializerList != NULL && CtorInitializerList != NULL && p_CtorInitializerList != CtorInitializerList)
158217 : {
158218 : printf ("Warning: CtorInitializerList = %p overwriting valid pointer p_CtorInitializerList = %p \n",CtorInitializerList,p_CtorInitializerList);
158219 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
158220 : printf ("Error fails assertion (p_CtorInitializerList != NULL && CtorInitializerList != NULL && p_CtorInitializerList != CtorInitializerList) is false\n");
158221 : ROSE_ASSERT(false);
158222 : #endif
158223 : }
158224 : #endif
158225 0 : p_CtorInitializerList = CtorInitializerList;
158226 0 : }
158227 :
158228 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
158229 :
158230 :
158231 : // End of memberFunctionString
158232 : // Start of memberFunctionString
158233 :
158234 :
158235 : // End of memberFunctionString
158236 : // Start of memberFunctionString
158237 : /* #line 11968 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
158238 :
158239 :
158240 : bool
158241 8 : SgMemberFunctionDeclaration::isDefinedInClass() const
158242 : {
158243 8 : bool returnValue = false;
158244 :
158245 : // If the scopes are the same then the class is structurally defined in the class scope
158246 8 : bool isDefiningDeclaration = (get_definition() != NULL);
158247 8 : bool isDeclaredInClassScope = (get_parent() == get_scope());
158248 8 : if ( (isDefiningDeclaration == true) && (isDeclaredInClassScope == true) )
158249 0 : returnValue = true;
158250 :
158251 8 : return returnValue;
158252 : }
158253 :
158254 :
158255 : void
158256 39274 : SgMemberFunctionDeclaration::post_construction_initialization()
158257 : {
158258 : // DQ (9/15/2005): Remove side-effect from get_ctors() member function.
158259 : // This was a problem for the AST tests where the post processing saw a
158260 : // NULL pointer and then the unparser was called in the rewrite mechanism
158261 : // and then the AST tests failed because the pointer was non-NULL (and
158262 : // also the SgCtorInitializerList had not been properly setup).
158263 : // p_CtorInitializerList = new SgCtorInitializerList(New_File_Info(this));
158264 39274 : if (get_startOfConstruct() != NULL)
158265 : {
158266 0 : p_CtorInitializerList = new SgCtorInitializerList(New_File_Info(this));
158267 : }
158268 : else
158269 : {
158270 78548 : p_CtorInitializerList = new SgCtorInitializerList();
158271 : }
158272 39274 : ROSE_ASSERT(p_CtorInitializerList != NULL);
158273 :
158274 : // Like the "enum" declaration (SgEnumDeclaration) this can only be defined
158275 : // once, so it is its defining declaration. Well, not exactly. The uniform
158276 : // handling of the defining and non-defining declarations requires that this
158277 : // be set as the firstNondefining declaration. This might be an error and
158278 : // should be reviewed.
158279 :
158280 : // DQ (9/20/2005): Need to set the nondefining declaration instead of the defining declaration!
158281 : // p_CtorInitializerList->set_definingDeclaration(p_CtorInitializerList);
158282 39274 : p_CtorInitializerList->set_firstNondefiningDeclaration(p_CtorInitializerList);
158283 :
158284 : // DQ (9/21/2005): Added warning since this is an issue worth review!
158285 : // printf ("Warning: Set p_CtorInitializerList = %p firstNondefiningDeclaration to self, unclear if this is correct \n",p_CtorInitializerList);
158286 :
158287 : // DQ (9/21/2005): set the parent so that the scope will be computed correctly
158288 : // (scope is not stored explicitly on the SgCtorInitializerList IR node).
158289 39274 : p_CtorInitializerList->set_parent(this);
158290 :
158291 : #if 0
158292 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
158293 : printf ("In SgMemberFunctionDeclaration::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
158294 : #endif
158295 39274 : }
158296 :
158297 : void
158298 0 : SgMemberFunctionDeclaration::append_ctor_initializer( SgInitializedName* iName)
158299 : {
158300 0 : ROSE_ASSERT(p_CtorInitializerList != NULL);
158301 : // if (get_CtorInitializerList() == NULL)
158302 : // set_CtorInitializerList(new SgCtorInitializerList(New_File_Info(this)));
158303 0 : get_CtorInitializerList()->append_ctor_initializer(iName);
158304 0 : }
158305 :
158306 : void
158307 0 : SgMemberFunctionDeclaration::prepend_ctor_initializer( SgInitializedName* iName)
158308 : {
158309 0 : ROSE_ASSERT(p_CtorInitializerList != NULL);
158310 : // if (get_CtorInitializerList() == NULL)
158311 : // set_CtorInitializerList(new SgCtorInitializerList(New_File_Info(this)));
158312 0 : get_CtorInitializerList()->prepend_ctor_initializer(iName);
158313 0 : }
158314 :
158315 : SgInitializedNamePtrList &
158316 634 : SgMemberFunctionDeclaration::get_ctors()
158317 : {
158318 634 : ROSE_ASSERT(p_CtorInitializerList != NULL);
158319 : // if (get_CtorInitializerList() == NULL)
158320 : // set_CtorInitializerList(new SgCtorInitializerList(New_File_Info(this)));
158321 634 : return get_CtorInitializerList()->get_ctors();
158322 : }
158323 :
158324 : const SgInitializedNamePtrList &
158325 0 : SgMemberFunctionDeclaration::get_ctors() const
158326 : {
158327 0 : ROSE_ASSERT(get_CtorInitializerList() != NULL);
158328 0 : return get_CtorInitializerList()->get_ctors();
158329 : }
158330 :
158331 : // SgName SgMemberFunctionDeclaration::get_qualified_name();
158332 : SgName
158333 8595 : SgMemberFunctionDeclaration::get_qualified_name() const
158334 : {
158335 : // DQ (8/28/2005): Modified to make this function consistent other get_qualified_name functions
158336 : // It previously only returned the name of the class to which is was a member function!
158337 : // printf ("In SgMemberFunctionDeclaration::get_qualified_name() name = %s \n",get_name().str());
158338 :
158339 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
158340 8595 : SgScopeStatement* scope = get_scope();
158341 8595 : ROSE_ASSERT(scope != NULL);
158342 :
158343 17190 : SgName returnName = SgName::assembleQualifiedName (scope->get_qualified_name(), get_name ());
158344 :
158345 : // printf ("In SgMemberFunctionDeclaration::get_qualified_name() returnName = %s \n",returnName.str());
158346 :
158347 8595 : return returnName;
158348 : }
158349 :
158350 : void
158351 0 : SgMemberFunctionDeclaration::set_orig_return_type(SgType *t)
158352 : {
158353 : // QY: removed p_orig_return_type. reset p_type by making another member function type (the original p_type might be shared?)
158354 : // DQ (10/6/2004): Not sure why this works this way!
158355 0 : ROSE_ASSERT(t != NULL);
158356 :
158357 0 : SgMemberFunctionType *ntype = isSgMemberFunctionType(get_type())->mkAnotherType(t);
158358 0 : ROSE_ASSERT (ntype != NULL);
158359 0 : set_type(ntype); // reset function type if necessary
158360 0 : }
158361 :
158362 : bool
158363 0 : SgMemberFunctionDeclaration::replace_child(SgStatement *target,SgStatement *newstmt,
158364 : bool extractBasicBlock)
158365 : {
158366 0 : if ( SgFunctionDeclaration::replace_child(target, newstmt,extractBasicBlock) == true )
158367 : {
158368 : return true;
158369 : }
158370 : else
158371 : {
158372 : // Handle other possible replacements
158373 0 : if ( StatementReplace(this, p_scope, target, newstmt) == true )
158374 : {
158375 : return true;
158376 : }
158377 : else
158378 : {
158379 0 : return ( StatementReplace(this, p_CtorInitializerList, target, newstmt) == true );
158380 : }
158381 : }
158382 : }
158383 :
158384 : // DQ (10/12/2007): This is no longer a ROSETTA generated function, so that we can hide the get_associatedClassDeclaration
158385 : // member, making it private to only support the SgMemberFunctionDeclaration::get_class_scope() member function.
158386 : SgDeclarationStatement*
158387 141538 : SgMemberFunctionDeclaration::get_associatedClassDeclaration () const
158388 : {
158389 141538 : assert (this != NULL);
158390 : // return p_associatedClassDeclaration;
158391 :
158392 141538 : SgDeclarationStatement* returnValue = NULL;
158393 :
158394 : // The p_associatedClassDeclaration is only set when the class definition is unavailable (not defined in the current
158395 : // translation unit) and yet there is a class declared for there to be a member function declared. This is always
158396 : // the case of a pointer to a member function, since only in this case can the pointer to a member function be declared
158397 : // without a member function having been declared.
158398 141538 : if (p_associatedClassDeclaration != NULL)
158399 : {
158400 : // If this is a valid pointer then it is only because the class definition has not been seen (and this backup
158401 : // mechanism has been used to relate the member function to the class declaration).
158402 : returnValue = p_associatedClassDeclaration;
158403 : }
158404 : else
158405 : {
158406 : // When p_associatedClassDeclaration == NULL, it is because the class definition exists (and the backup mechanism
158407 : // of relating the member function to the class declaration was not required) and so the class declaration can be
158408 : // obtained directly from the class definition.
158409 124979 : SgScopeStatement* scope = get_class_scope();
158410 124979 : SgClassDefinition * cdefn = isSgClassDefinition(scope);
158411 124979 : SgDeclarationScope * nrscope = isSgDeclarationScope(scope);
158412 :
158413 124979 : if (cdefn != NULL) {
158414 124142 : returnValue = cdefn->get_declaration();
158415 837 : } else if (nrscope != NULL) {
158416 837 : SgNode * nrscope_parent = nrscope->get_parent();
158417 837 : ROSE_ASSERT(nrscope_parent != NULL);
158418 : #if 0
158419 : printf("nrscope_parent = %p (%s)\n", nrscope_parent, nrscope_parent ? nrscope_parent->class_name().c_str() : "");
158420 : #endif
158421 837 : SgTemplateClassDeclaration * tpldecl = isSgTemplateClassDeclaration(nrscope_parent);
158422 837 : SgNonrealDecl * nrdecl = isSgNonrealDecl(nrscope_parent);
158423 837 : if (tpldecl != NULL) {
158424 : returnValue = tpldecl;
158425 21 : } else if (nrdecl != NULL) {
158426 : #if 0
158427 : printf ("WARNING: retuning a non-real declaration from SgMemberFunctionDeclaration::get_associatedClassDeclaration \n");
158428 : #endif
158429 : returnValue = nrdecl;
158430 : } else {
158431 0 : ROSE_ASSERT(false);
158432 : }
158433 : } else {
158434 0 : printf ("ERROR: retuning NULL from SgMemberFunctionDeclaration::get_associatedClassDeclaration \n");
158435 0 : returnValue = NULL;
158436 : }
158437 : }
158438 :
158439 141538 : return returnValue;
158440 : }
158441 :
158442 : // DQ (10/12/2007): This is no longer a ROSETTA generated function, so that we can hide the get_associatedClassDeclaration
158443 : // member, making it private to only support the SgMemberFunctionDeclaration::get_class_scope() member function.
158444 : // This SgMemberFunctionDeclaration::set_associatedClassDeclaration() member function is public so that it can be set in
158445 : // construction of the AST.
158446 : void
158447 12217 : SgMemberFunctionDeclaration::set_associatedClassDeclaration ( SgDeclarationStatement* associatedClassDeclaration )
158448 : {
158449 12217 : assert (this != NULL);
158450 12217 : set_isModified(true);
158451 :
158452 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
158453 : if (p_associatedClassDeclaration != NULL && associatedClassDeclaration != NULL && p_associatedClassDeclaration != associatedClassDeclaration)
158454 : {
158455 : printf ("Warning: associatedClassDeclaration = %p overwriting valid pointer p_associatedClassDeclaration = %p \n",associatedClassDeclaration,p_associatedClassDeclaration);
158456 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
158457 : printf ("Error fails assertion (p_associatedClassDeclaration != NULL && associatedClassDeclaration != NULL && p_associatedClassDeclaration != associatedClassDeclaration) is false\n");
158458 : ROSE_ASSERT(false);
158459 : #endif
158460 : }
158461 : #endif
158462 12217 : p_associatedClassDeclaration = associatedClassDeclaration;
158463 12217 : }
158464 :
158465 : SgScopeStatement*
158466 137185 : SgMemberFunctionDeclaration::get_class_scope(void) const
158467 : {
158468 : // DQ (10/12/2007): It is OK for this to be NULL! If it is NULL, then the get_associatedClassDeclaration() has the class declaration!
158469 :
158470 : // DQ (12/5/2004): The scope is explicit and should be a valid pointer (if not it is an error!)
158471 : // ROSE_ASSERT(p_scope != NULL);
158472 :
158473 : // DQ (11/17/2004): Note that get_scope returns a SgScopeStatement, but member functions are always part
158474 : // of a SgClassDefinition and we want to reflect this and be as consistent as possible with the former
158475 : // get_scope() function which was only defined on the SgMemberFunctionDeclaration but is now defined on
158476 : // many different IR nodes (as a result of a major bug fix specific to scopes vs. parents handling).
158477 : // SgClassDefinition *parentScope = isSgClassDefinition(get_scope());
158478 137185 : SgScopeStatement* parentScope = NULL;
158479 :
158480 : // DQ (10/12/2007): Modified to access the p_associatedClassDeclaration data member directly because
158481 : // the get_associatedClassDeclaration() member function is more than an access function (no longer built be ROSETTA).
158482 : // DQ (7/26/2007): Member function pointers don't require a SgClassDefinition so we have no scope
158483 : // for such cases, to make up for this, we explicitly store the class declaration.
158484 : // SgClassDeclaration* classDeclaration = this->get_associatedClassDeclaration();
158485 137185 : SgDeclarationStatement* decl = this->p_associatedClassDeclaration;
158486 137185 : if (decl != NULL) {
158487 0 : decl = decl->get_definingDeclaration();
158488 0 : ROSE_ASSERT(decl != NULL);
158489 :
158490 0 : SgClassDeclaration* xdecl = isSgClassDeclaration(decl);
158491 0 : SgNonrealDecl* nrdecl = isSgNonrealDecl(decl);
158492 0 : if (xdecl != NULL) {
158493 0 : parentScope = xdecl->get_definition();
158494 0 : } else if (nrdecl != NULL) {
158495 0 : parentScope = nrdecl->get_nonreal_decl_scope();
158496 : } else {
158497 0 : ROSE_ASSERT(false);
158498 : }
158499 : } else {
158500 : // DQ (7/26/2007): Moved from top of function
158501 137185 : ROSE_ASSERT(p_scope != NULL);
158502 :
158503 : // DQ (10/15/2007): Added assertion.
158504 137185 : ROSE_ASSERT(this->get_parent() != NULL);
158505 :
158506 137185 : parentScope = get_scope();
158507 137185 : SgClassDefinition * cdefn = isSgClassDefinition(parentScope);
158508 137185 : SgDeclarationScope * nrscope = isSgDeclarationScope(parentScope);
158509 :
158510 : // The scope associated with a member function had better be a SgClassDefinition!
158511 : // if (this->get_associatedClassDeclaration() != NULL || parentScope == NULL)
158512 137185 : if (cdefn == NULL && nrscope == NULL)
158513 : {
158514 : // DQ (12/5/2004): Note that new member function declarations added from the rewrite system
158515 : // allow there scope to be derived from the parent node. This results in incorrect information
158516 : // which is later discovered in the unparser! Need to do a better job of setting the scope of
158517 : // all statements when introduced from the rewrite mechanism.
158518 :
158519 0 : ROSE_ASSERT(get_name().is_null() == false);
158520 0 : printf ("Error in SgMemberFunctionDeclaration::get_class_scope() member function name = %s (can be incorrect due to rewrite system) \n",get_name().str());
158521 :
158522 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by calling get_parent only once).
158523 : // printf (" get_parent() = %p = %s \n",get_parent(),(get_parent() != NULL) ? get_parent()->sage_class_name() : "NULL");
158524 0 : SgNode* parent = get_parent();
158525 0 : printf (" get_parent() = %p = %s \n",parent,(parent != NULL) ? parent->sage_class_name() : "NULL");
158526 :
158527 0 : printf (" p_scope = %p = %s \n",p_scope,p_scope->sage_class_name());
158528 : }
158529 : // ROSE_ASSERT(parentScope != NULL);
158530 : }
158531 :
158532 : // DQ (10/12/2007): It is OK for this to be NULL! If it is NULL, then the get_associatedClassDeclaration() has the class declaration!
158533 : // ROSE_ASSERT(parentScope != NULL);
158534 137185 : return parentScope;
158535 : }
158536 :
158537 :
158538 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
158539 : SgSymbol*
158540 183605 : SgMemberFunctionDeclaration::get_symbol_from_symbol_table() const
158541 : {
158542 : #if 0
158543 : printf ("In SgMemberFunctionDeclaration::get_symbol_from_symbol_table(): this = %p = %s = %s scope = %p = %s scope->get_symbol_table() = %p \n",
158544 : this,this->class_name().c_str(),SageInterface::get_name(this).c_str(),get_scope(),get_scope()->class_name().c_str(),get_scope()->get_symbol_table());
158545 : #endif
158546 :
158547 183605 : SgSymbol* symbol = NULL;
158548 183605 : if (get_scope() == NULL)
158549 : {
158550 0 : printf ("In SgMemberFunctionDeclaration::get_symbol_from_symbol_table(): get_scope() == NULL for %p = %s \n",this,this->class_name().c_str());
158551 0 : symbol = NULL;
158552 : }
158553 : else
158554 : {
158555 183605 : ROSE_ASSERT(get_scope() != NULL);
158556 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
158557 : // symbol = get_scope()->get_symbol_table()->find(this);
158558 183605 : symbol = get_scope()->find_symbol_from_declaration(this);
158559 : }
158560 :
158561 183605 : return symbol;
158562 : }
158563 :
158564 :
158565 :
158566 : // End of memberFunctionString
158567 : // Start of memberFunctionString
158568 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
158569 :
158570 : // *** COMMON CODE SECTION BEGINS HERE ***
158571 :
158572 : #if 0
158573 : int
158574 : SgMemberFunctionDeclaration::getVariant() const
158575 : {
158576 : // This function is used in ROSE while "variant()" is used in SAGE
158577 : assert(this != NULL);
158578 : return variant();
158579 : }
158580 : #endif
158581 :
158582 : // This function is used in ROSE in treeTraversal code
158583 : // eventually replaces getVariant() and variant()
158584 : // though after variant() has been removed for a while we will
158585 : // want to change the name of variantT() back to variant()
158586 : // (since the "T" was ment to stand for temporary).
158587 : // When this happens the variantT() will be depricated.
158588 : VariantT
158589 7746450 : SgMemberFunctionDeclaration::variantT() const
158590 : {
158591 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
158592 7746450 : ROSE_ASSERT(this != NULL);
158593 7746450 : return V_SgMemberFunctionDeclaration;
158594 : }
158595 :
158596 : #if 0
158597 : int
158598 : SgMemberFunctionDeclaration::variant() const
158599 : {
158600 : // This function is used in SAGE
158601 : ROSE_ASSERT(this != NULL);
158602 : return MFUNC_DECL_STMT;
158603 : }
158604 : #endif
158605 :
158606 : ROSE_DLL_API const char*
158607 257 : SgMemberFunctionDeclaration::sage_class_name() const
158608 : {
158609 257 : ROSE_ASSERT(this != NULL);
158610 257 : return "SgMemberFunctionDeclaration";
158611 : }
158612 :
158613 : std::string
158614 7486 : SgMemberFunctionDeclaration::class_name() const
158615 : {
158616 7486 : ROSE_ASSERT(this != NULL);
158617 7486 : return "SgMemberFunctionDeclaration";
158618 : }
158619 :
158620 : // DQ (11/26/2005): Support for visitor pattern mechanims
158621 : // (inferior to ROSE traversal mechanism, experimental).
158622 : void
158623 109848 : SgMemberFunctionDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
158624 : {
158625 109848 : ROSE_ASSERT(this != NULL);
158626 109848 : visitor.visit(this);
158627 109848 : }
158628 :
158629 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
158630 0 : void SgMemberFunctionDeclaration::accept (ROSE_VisitorPattern & visitor) {
158631 0 : ROSE_ASSERT(this != NULL);
158632 0 : visitor.visit(this);
158633 0 : }
158634 :
158635 : SgMemberFunctionDeclaration*
158636 0 : SgMemberFunctionDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
158637 : {
158638 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
158639 : // This function is currently only supported for the AST used the represent Binary executables.
158640 : if (0 /* isSgAsmNode(this) != NULL */)
158641 : {
158642 : // Support for regex specification.
158643 : std::string prefixCode = "REGEX:";
158644 : addNewAttribute(prefixCode + s,a);
158645 : }
158646 : #endif
158647 :
158648 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
158649 0 : return this;
158650 : }
158651 :
158652 : // *** COMMON CODE SECTION ENDS HERE ***
158653 :
158654 :
158655 : // End of memberFunctionString
158656 : // Start of memberFunctionString
158657 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
158658 :
158659 :
158660 : #if 0
158661 : //! Error checking support
158662 : /*! Verifies the following:
158663 : - working getVariant() member function
158664 : - calls base class's error() member function
158665 : Every class has one of these functions.
158666 : */
158667 : bool
158668 : SgMemberFunctionDeclaration::error()
158669 : {
158670 : // Put error checking here
158671 :
158672 : ROSE_ASSERT (this != NULL);
158673 : if (getVariant() != MFUNC_DECL_STMT)
158674 : {
158675 : printf ("Error in SgMemberFunctionDeclaration::error(): SgMemberFunctionDeclaration object has a %s variant \n",
158676 : Cxx_GrammarTerminalNames[getVariant()].name);
158677 : // printf ("Error in SgMemberFunctionDeclaration::error() \n");
158678 : ROSE_ABORT();
158679 : }
158680 :
158681 : ROSE_ASSERT (getVariant() == MFUNC_DECL_STMT);
158682 : return SgFunctionDeclaration::error();
158683 : }
158684 : #endif
158685 :
158686 :
158687 :
158688 : // End of memberFunctionString
158689 :
158690 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
158691 :
158692 15667500 : SgMemberFunctionDeclaration* isSgMemberFunctionDeclaration ( SgNode* inputDerivedClassPointer )
158693 : {
158694 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
158695 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
158696 : // So to fix this we return NULL directly when the input is NULL and avoid the
158697 : // dynamic_cast in this case. This is likely a performance improvement as well.
158698 : // return dynamic_cast<SgMemberFunctionDeclaration*>(inputDerivedClassPointer);
158699 : // Milind Chabbi (8/28/2013): isSgMemberFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
158700 : // this improves the running time performance by 10-20%.
158701 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMemberFunctionDeclaration*>(inputDerivedClassPointer);
158702 15667500 : return IS_SgMemberFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
158703 : }
158704 :
158705 : // DQ (11/8/2003): Added version of functions taking const pointer
158706 0 : const SgMemberFunctionDeclaration* isSgMemberFunctionDeclaration ( const SgNode* inputDerivedClassPointer )
158707 : {
158708 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
158709 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
158710 : // So to fix this we return NULL directly when the input is NULL and avoid the
158711 : // dynamic_cast in this case. This is likely a performance improvement as well.
158712 : // return dynamic_cast<const SgMemberFunctionDeclaration*>(inputDerivedClassPointer);
158713 : // Milind Chabbi (8/28/2013): isSgMemberFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
158714 : // this improves the running time performance by 10-20%.
158715 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMemberFunctionDeclaration*>(inputDerivedClassPointer);
158716 0 : return IS_SgMemberFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
158717 : }
158718 :
158719 :
158720 :
158721 : /* #line 158722 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158722 :
158723 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
158724 :
158725 : /**
158726 : \brief Generated destructor
158727 :
158728 : This destructor is automatically generated (by ROSETTA). This destructor
158729 : only frees memory of data members associated with the parts of the current IR node which
158730 : are NOT traversed. Those data members that are part of a traversal can be freed using
158731 : a traversal (calling this destructor on all children in a post-order traversal). Such
158732 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
158733 :
158734 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
158735 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
158736 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
158737 :
158738 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
158739 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
158740 : pointers are not yet implemented to call delete on eash pointer in the container.
158741 : (This could be done by derivation from the STL containers to define containers that
158742 : automatically deleted their members.)
158743 :
158744 : */
158745 10424 : SgMemberFunctionDeclaration::~SgMemberFunctionDeclaration () {
158746 8856 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
158747 :
158748 :
158749 : // case: not a listType for CtorInitializerList
158750 8856 : p_CtorInitializerList = NULL; // non list case
158751 : // case: not a listType for associatedClassDeclaration
158752 8856 : p_associatedClassDeclaration = NULL; // non list case
158753 :
158754 : }
158755 :
158756 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
158757 10424 : }
158758 :
158759 :
158760 : /* #line 158761 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158761 :
158762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
158763 :
158764 : // Generated constructor
158765 0 : SgMemberFunctionDeclaration::SgMemberFunctionDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
158766 0 : : SgFunctionDeclaration(startOfConstruct, name, type, definition)
158767 : {
158768 : #ifdef DEBUG
158769 : // printf ("In SgMemberFunctionDeclaration::SgMemberFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
158770 : #endif
158771 : #if 0
158772 : // debugging information!
158773 : printf ("In SgMemberFunctionDeclaration::SgMemberFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
158774 : #endif
158775 :
158776 0 : p_CtorInitializerList = NULL;
158777 0 : p_associatedClassDeclaration = NULL;
158778 :
158779 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
158780 :
158781 : #if 0
158782 : // DQ (7/30/2014): Call a virtual function.
158783 : std::string s = this->class_name();
158784 : #endif
158785 :
158786 : // Test the variant virtual function
158787 : // assert(MFUNC_DECL_STMT == variant());
158788 0 : assert(MFUNC_DECL_STMT == this->variant());
158789 0 : ROSE_ASSERT(MFUNC_DECL_STMT == (int)(this->variantT()));
158790 0 : post_construction_initialization();
158791 :
158792 : // Test the isSgMemberFunctionDeclaration() function since it has been problematic
158793 0 : assert(isSgMemberFunctionDeclaration(this) != NULL);
158794 0 : }
158795 :
158796 : // Generated constructor (all data members)
158797 :
158798 : /* #line 158799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158799 :
158800 :
158801 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
158802 :
158803 :
158804 : // ********************************************************
158805 : // member functions common across all array grammar objects
158806 : // ********************************************************
158807 :
158808 :
158809 :
158810 : /* #line 158811 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158811 :
158812 :
158813 :
158814 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
158815 :
158816 : // ********************************************************
158817 : // member functions specific to each node in the grammar
158818 : // ********************************************************
158819 :
158820 :
158821 : /* #line 158822 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
158822 :
158823 : // Start of memberFunctionString
158824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
158825 :
158826 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
158827 :
158828 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
158829 : const SgTemplateParameterPtrList &
158830 0 : SgTemplateMemberFunctionDeclaration::get_templateParameters () const
158831 : {
158832 0 : assert (this != NULL);
158833 0 : return p_templateParameters;
158834 : }
158835 :
158836 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
158837 : SgTemplateParameterPtrList &
158838 200786 : SgTemplateMemberFunctionDeclaration::get_templateParameters ()
158839 : {
158840 200786 : assert (this != NULL);
158841 :
158842 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
158843 : // As a rule only set_ access functions can set the isModified flag.
158844 : // set_isModified(true);
158845 :
158846 200786 : return p_templateParameters;
158847 : }
158848 :
158849 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
158850 :
158851 :
158852 : // End of memberFunctionString
158853 : // Start of memberFunctionString
158854 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
158855 :
158856 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
158857 :
158858 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
158859 : const SgTemplateArgumentPtrList &
158860 0 : SgTemplateMemberFunctionDeclaration::get_templateSpecializationArguments () const
158861 : {
158862 0 : assert (this != NULL);
158863 0 : return p_templateSpecializationArguments;
158864 : }
158865 :
158866 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
158867 : SgTemplateArgumentPtrList &
158868 13335 : SgTemplateMemberFunctionDeclaration::get_templateSpecializationArguments ()
158869 : {
158870 13335 : assert (this != NULL);
158871 :
158872 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
158873 : // As a rule only set_ access functions can set the isModified flag.
158874 : // set_isModified(true);
158875 :
158876 13335 : return p_templateSpecializationArguments;
158877 : }
158878 :
158879 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
158880 :
158881 :
158882 : // End of memberFunctionString
158883 : // Start of memberFunctionString
158884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
158885 :
158886 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
158887 :
158888 : SgName
158889 3927 : SgTemplateMemberFunctionDeclaration::get_string () const
158890 : {
158891 3927 : ROSE_ASSERT (this != NULL);
158892 :
158893 : #if 0
158894 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158895 : // used to trigger marking transformations for the token-based unparsing.
158896 : printf ("SgTemplateMemberFunctionDeclaration::get_string = %p = %s \n",this,this->class_name().c_str());
158897 : #endif
158898 :
158899 3927 : return p_string;
158900 : }
158901 :
158902 : void
158903 9154 : SgTemplateMemberFunctionDeclaration::set_string ( SgName string )
158904 : {
158905 9154 : ROSE_ASSERT (this != NULL);
158906 :
158907 : #if 0
158908 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158909 : // used to trigger marking transformations for the token-based unparsing.
158910 : printf ("SgTemplateMemberFunctionDeclaration::set_string = %p = %s \n",this,this->class_name().c_str());
158911 : #endif
158912 :
158913 9154 : set_isModified(true);
158914 :
158915 9154 : p_string = string;
158916 9154 : }
158917 :
158918 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
158919 :
158920 :
158921 : // End of memberFunctionString
158922 : // Start of memberFunctionString
158923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
158924 :
158925 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
158926 :
158927 : bool
158928 13861 : SgTemplateMemberFunctionDeclaration::get_string_represents_function_body () const
158929 : {
158930 13861 : ROSE_ASSERT (this != NULL);
158931 :
158932 : #if 0
158933 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158934 : // used to trigger marking transformations for the token-based unparsing.
158935 : printf ("SgTemplateMemberFunctionDeclaration::get_string_represents_function_body = %p = %s \n",this,this->class_name().c_str());
158936 : #endif
158937 :
158938 13861 : return p_string_represents_function_body;
158939 : }
158940 :
158941 : void
158942 5207 : SgTemplateMemberFunctionDeclaration::set_string_represents_function_body ( bool string_represents_function_body )
158943 : {
158944 5207 : ROSE_ASSERT (this != NULL);
158945 :
158946 : #if 0
158947 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158948 : // used to trigger marking transformations for the token-based unparsing.
158949 : printf ("SgTemplateMemberFunctionDeclaration::set_string_represents_function_body = %p = %s \n",this,this->class_name().c_str());
158950 : #endif
158951 :
158952 5207 : set_isModified(true);
158953 :
158954 5207 : p_string_represents_function_body = string_represents_function_body;
158955 5207 : }
158956 :
158957 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
158958 :
158959 :
158960 : // End of memberFunctionString
158961 : // Start of memberFunctionString
158962 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
158963 :
158964 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
158965 :
158966 : SgDeclarationScope*
158967 0 : SgTemplateMemberFunctionDeclaration::get_nonreal_decl_scope () const
158968 : {
158969 0 : ROSE_ASSERT (this != NULL);
158970 :
158971 : #if 0
158972 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158973 : // used to trigger marking transformations for the token-based unparsing.
158974 : printf ("SgTemplateMemberFunctionDeclaration::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
158975 : #endif
158976 :
158977 0 : return p_nonreal_decl_scope;
158978 : }
158979 :
158980 : void
158981 3947 : SgTemplateMemberFunctionDeclaration::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
158982 : {
158983 3947 : ROSE_ASSERT (this != NULL);
158984 :
158985 : #if 0
158986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
158987 : // used to trigger marking transformations for the token-based unparsing.
158988 : printf ("SgTemplateMemberFunctionDeclaration::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
158989 : #endif
158990 :
158991 3947 : set_isModified(true);
158992 :
158993 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
158994 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
158995 : {
158996 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
158997 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
158998 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
158999 : ROSE_ASSERT(false);
159000 : #endif
159001 : }
159002 : #endif
159003 3947 : p_nonreal_decl_scope = nonreal_decl_scope;
159004 3947 : }
159005 :
159006 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159007 :
159008 :
159009 : // End of memberFunctionString
159010 : // Start of memberFunctionString
159011 : /* #line 16859 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
159012 :
159013 : void
159014 17936 : SgTemplateMemberFunctionDeclaration::post_construction_initialization()
159015 : {
159016 : // DQ (12/21/2011): This is not what we want for the newer design with SgTemplateVariableDeclaration derived from SgVariableDeclaration.
159017 : // this->set_template_kind(e_template_m_function);
159018 :
159019 : #if 0
159020 : // DQ (12/28/2011): This will overwrite the existing SgCtorInitializerList in the base class.
159021 : // DQ (11/25/2011): This is copied from the SgMemberFunctionDeclaration (the semantics must match).
159022 : // There is however an opportunity to refactor some of this code (even though it is a small amount of code).
159023 : if (get_startOfConstruct() != NULL)
159024 : {
159025 : p_CtorInitializerList = new SgCtorInitializerList(New_File_Info(this));
159026 : }
159027 : else
159028 : {
159029 : p_CtorInitializerList = new SgCtorInitializerList();
159030 : }
159031 :
159032 : ROSE_ASSERT(p_CtorInitializerList != NULL);
159033 : p_CtorInitializerList->set_firstNondefiningDeclaration(p_CtorInitializerList);
159034 : #else
159035 17936 : ROSE_ASSERT(p_CtorInitializerList != NULL);
159036 : #endif
159037 :
159038 17936 : p_CtorInitializerList->set_parent(this);
159039 :
159040 : #if 0
159041 : // DQ (3/4/2018): relax this requirement for SgTemplateInstantiationClassDeclaration.
159042 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
159043 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
159044 : if (p_type != NULL)
159045 : {
159046 : printf ("Note: SgTemplateMemberFunctionDeclaration::post_construction_initialization(): p_type != NULL: name = %s \n",p_name.str());
159047 : }
159048 : // ROSE_ASSERT(p_type == NULL);
159049 : #endif
159050 17936 : }
159051 :
159052 :
159053 :
159054 : // End of memberFunctionString
159055 : // Start of memberFunctionString
159056 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
159057 :
159058 : // *** COMMON CODE SECTION BEGINS HERE ***
159059 :
159060 : #if 0
159061 : int
159062 : SgTemplateMemberFunctionDeclaration::getVariant() const
159063 : {
159064 : // This function is used in ROSE while "variant()" is used in SAGE
159065 : assert(this != NULL);
159066 : return variant();
159067 : }
159068 : #endif
159069 :
159070 : // This function is used in ROSE in treeTraversal code
159071 : // eventually replaces getVariant() and variant()
159072 : // though after variant() has been removed for a while we will
159073 : // want to change the name of variantT() back to variant()
159074 : // (since the "T" was ment to stand for temporary).
159075 : // When this happens the variantT() will be depricated.
159076 : VariantT
159077 26986100 : SgTemplateMemberFunctionDeclaration::variantT() const
159078 : {
159079 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
159080 26986100 : ROSE_ASSERT(this != NULL);
159081 26986100 : return V_SgTemplateMemberFunctionDeclaration;
159082 : }
159083 :
159084 : #if 0
159085 : int
159086 : SgTemplateMemberFunctionDeclaration::variant() const
159087 : {
159088 : // This function is used in SAGE
159089 : ROSE_ASSERT(this != NULL);
159090 : return TEMPLATE_MEMBER_FUNCTION_DECL_STMT;
159091 : }
159092 : #endif
159093 :
159094 : ROSE_DLL_API const char*
159095 594 : SgTemplateMemberFunctionDeclaration::sage_class_name() const
159096 : {
159097 594 : ROSE_ASSERT(this != NULL);
159098 594 : return "SgTemplateMemberFunctionDeclaration";
159099 : }
159100 :
159101 : std::string
159102 15015 : SgTemplateMemberFunctionDeclaration::class_name() const
159103 : {
159104 15015 : ROSE_ASSERT(this != NULL);
159105 15015 : return "SgTemplateMemberFunctionDeclaration";
159106 : }
159107 :
159108 : // DQ (11/26/2005): Support for visitor pattern mechanims
159109 : // (inferior to ROSE traversal mechanism, experimental).
159110 : void
159111 270741 : SgTemplateMemberFunctionDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
159112 : {
159113 270741 : ROSE_ASSERT(this != NULL);
159114 270741 : visitor.visit(this);
159115 270741 : }
159116 :
159117 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
159118 0 : void SgTemplateMemberFunctionDeclaration::accept (ROSE_VisitorPattern & visitor) {
159119 0 : ROSE_ASSERT(this != NULL);
159120 0 : visitor.visit(this);
159121 0 : }
159122 :
159123 : SgTemplateMemberFunctionDeclaration*
159124 0 : SgTemplateMemberFunctionDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
159125 : {
159126 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
159127 : // This function is currently only supported for the AST used the represent Binary executables.
159128 : if (0 /* isSgAsmNode(this) != NULL */)
159129 : {
159130 : // Support for regex specification.
159131 : std::string prefixCode = "REGEX:";
159132 : addNewAttribute(prefixCode + s,a);
159133 : }
159134 : #endif
159135 :
159136 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
159137 0 : return this;
159138 : }
159139 :
159140 : // *** COMMON CODE SECTION ENDS HERE ***
159141 :
159142 :
159143 : // End of memberFunctionString
159144 : // Start of memberFunctionString
159145 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
159146 :
159147 :
159148 : #if 0
159149 : //! Error checking support
159150 : /*! Verifies the following:
159151 : - working getVariant() member function
159152 : - calls base class's error() member function
159153 : Every class has one of these functions.
159154 : */
159155 : bool
159156 : SgTemplateMemberFunctionDeclaration::error()
159157 : {
159158 : // Put error checking here
159159 :
159160 : ROSE_ASSERT (this != NULL);
159161 : if (getVariant() != TEMPLATE_MEMBER_FUNCTION_DECL_STMT)
159162 : {
159163 : printf ("Error in SgTemplateMemberFunctionDeclaration::error(): SgTemplateMemberFunctionDeclaration object has a %s variant \n",
159164 : Cxx_GrammarTerminalNames[getVariant()].name);
159165 : // printf ("Error in SgTemplateMemberFunctionDeclaration::error() \n");
159166 : ROSE_ABORT();
159167 : }
159168 :
159169 : ROSE_ASSERT (getVariant() == TEMPLATE_MEMBER_FUNCTION_DECL_STMT);
159170 : return SgMemberFunctionDeclaration::error();
159171 : }
159172 : #endif
159173 :
159174 :
159175 :
159176 : // End of memberFunctionString
159177 :
159178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
159179 :
159180 13948000 : SgTemplateMemberFunctionDeclaration* isSgTemplateMemberFunctionDeclaration ( SgNode* inputDerivedClassPointer )
159181 : {
159182 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
159183 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
159184 : // So to fix this we return NULL directly when the input is NULL and avoid the
159185 : // dynamic_cast in this case. This is likely a performance improvement as well.
159186 : // return dynamic_cast<SgTemplateMemberFunctionDeclaration*>(inputDerivedClassPointer);
159187 : // Milind Chabbi (8/28/2013): isSgTemplateMemberFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
159188 : // this improves the running time performance by 10-20%.
159189 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateMemberFunctionDeclaration*>(inputDerivedClassPointer);
159190 13948000 : return IS_SgTemplateMemberFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
159191 : }
159192 :
159193 : // DQ (11/8/2003): Added version of functions taking const pointer
159194 1318590 : const SgTemplateMemberFunctionDeclaration* isSgTemplateMemberFunctionDeclaration ( const SgNode* inputDerivedClassPointer )
159195 : {
159196 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
159197 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
159198 : // So to fix this we return NULL directly when the input is NULL and avoid the
159199 : // dynamic_cast in this case. This is likely a performance improvement as well.
159200 : // return dynamic_cast<const SgTemplateMemberFunctionDeclaration*>(inputDerivedClassPointer);
159201 : // Milind Chabbi (8/28/2013): isSgTemplateMemberFunctionDeclaration uses table-driven castability instead of c++ default dynamic_cast
159202 : // this improves the running time performance by 10-20%.
159203 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateMemberFunctionDeclaration*>(inputDerivedClassPointer);
159204 1318590 : return IS_SgTemplateMemberFunctionDeclaration_FAST_MACRO(inputDerivedClassPointer);
159205 : }
159206 :
159207 :
159208 :
159209 : /* #line 159210 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159210 :
159211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
159212 :
159213 : /**
159214 : \brief Generated destructor
159215 :
159216 : This destructor is automatically generated (by ROSETTA). This destructor
159217 : only frees memory of data members associated with the parts of the current IR node which
159218 : are NOT traversed. Those data members that are part of a traversal can be freed using
159219 : a traversal (calling this destructor on all children in a post-order traversal). Such
159220 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
159221 :
159222 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
159223 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
159224 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
159225 :
159226 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
159227 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
159228 : pointers are not yet implemented to call delete on eash pointer in the container.
159229 : (This could be done by derivation from the STL containers to define containers that
159230 : automatically deleted their members.)
159231 :
159232 : */
159233 8550 : SgTemplateMemberFunctionDeclaration::~SgTemplateMemberFunctionDeclaration () {
159234 3810 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
159235 :
159236 3810 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
159237 :
159238 : // case: listType for templateParameters
159239 : // case: listType (typeIsPointerToList == false) for templateParameters
159240 3810 : p_templateParameters.erase(p_templateParameters.begin(),p_templateParameters.end());
159241 : // case: listType for templateSpecializationArguments
159242 : // case: listType (typeIsPointerToList == false) for templateSpecializationArguments
159243 3810 : p_templateSpecializationArguments.erase(p_templateSpecializationArguments.begin(),p_templateSpecializationArguments.end());
159244 : // case: not a listType for string
159245 3810 : p_string = ""; // non list case
159246 : // case: not a listType for string_represents_function_body
159247 3810 : p_string_represents_function_body = false; // non list case
159248 : // case: not a listType for nonreal_decl_scope
159249 3810 : p_nonreal_decl_scope = NULL; // non list case
159250 :
159251 : }
159252 :
159253 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
159254 7620 : }
159255 :
159256 :
159257 : /* #line 159258 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159258 :
159259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
159260 :
159261 : // Generated constructor
159262 0 : SgTemplateMemberFunctionDeclaration::SgTemplateMemberFunctionDeclaration ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
159263 0 : : SgMemberFunctionDeclaration(startOfConstruct, name, type, definition)
159264 : {
159265 : #ifdef DEBUG
159266 : // printf ("In SgTemplateMemberFunctionDeclaration::SgTemplateMemberFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
159267 : #endif
159268 : #if 0
159269 : // debugging information!
159270 : printf ("In SgTemplateMemberFunctionDeclaration::SgTemplateMemberFunctionDeclaration (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
159271 : #endif
159272 :
159273 0 : p_templateParameters = SgTemplateParameterPtrList();
159274 0 : p_templateSpecializationArguments = SgTemplateArgumentPtrList();
159275 0 : p_string = "";
159276 0 : p_string_represents_function_body = false;
159277 0 : p_nonreal_decl_scope = NULL;
159278 :
159279 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
159280 :
159281 : #if 0
159282 : // DQ (7/30/2014): Call a virtual function.
159283 : std::string s = this->class_name();
159284 : #endif
159285 :
159286 : // Test the variant virtual function
159287 : // assert(TEMPLATE_MEMBER_FUNCTION_DECL_STMT == variant());
159288 0 : assert(TEMPLATE_MEMBER_FUNCTION_DECL_STMT == this->variant());
159289 0 : ROSE_ASSERT(TEMPLATE_MEMBER_FUNCTION_DECL_STMT == (int)(this->variantT()));
159290 0 : post_construction_initialization();
159291 :
159292 : // Test the isSgTemplateMemberFunctionDeclaration() function since it has been problematic
159293 0 : assert(isSgTemplateMemberFunctionDeclaration(this) != NULL);
159294 0 : }
159295 :
159296 : // Generated constructor (all data members)
159297 :
159298 : /* #line 159299 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159299 :
159300 :
159301 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
159302 :
159303 :
159304 : // ********************************************************
159305 : // member functions common across all array grammar objects
159306 : // ********************************************************
159307 :
159308 :
159309 :
159310 : /* #line 159311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159311 :
159312 :
159313 :
159314 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
159315 :
159316 : // ********************************************************
159317 : // member functions specific to each node in the grammar
159318 : // ********************************************************
159319 :
159320 :
159321 : /* #line 159322 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159322 :
159323 : // Start of memberFunctionString
159324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
159325 :
159326 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159327 :
159328 : SgName
159329 124902 : SgTemplateInstantiationMemberFunctionDecl::get_templateName () const
159330 : {
159331 124902 : ROSE_ASSERT (this != NULL);
159332 :
159333 : #if 0
159334 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159335 : // used to trigger marking transformations for the token-based unparsing.
159336 : printf ("SgTemplateInstantiationMemberFunctionDecl::get_templateName = %p = %s \n",this,this->class_name().c_str());
159337 : #endif
159338 :
159339 124902 : return p_templateName;
159340 : }
159341 :
159342 : void
159343 14387 : SgTemplateInstantiationMemberFunctionDecl::set_templateName ( SgName templateName )
159344 : {
159345 14387 : ROSE_ASSERT (this != NULL);
159346 :
159347 : #if 0
159348 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159349 : // used to trigger marking transformations for the token-based unparsing.
159350 : printf ("SgTemplateInstantiationMemberFunctionDecl::set_templateName = %p = %s \n",this,this->class_name().c_str());
159351 : #endif
159352 :
159353 14387 : set_isModified(true);
159354 :
159355 14387 : p_templateName = templateName;
159356 14387 : }
159357 :
159358 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159359 :
159360 :
159361 : // End of memberFunctionString
159362 : // Start of memberFunctionString
159363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
159364 :
159365 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159366 :
159367 : SgTemplateMemberFunctionDeclaration*
159368 121490 : SgTemplateInstantiationMemberFunctionDecl::get_templateDeclaration () const
159369 : {
159370 121490 : ROSE_ASSERT (this != NULL);
159371 :
159372 : #if 0
159373 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159374 : // used to trigger marking transformations for the token-based unparsing.
159375 : printf ("SgTemplateInstantiationMemberFunctionDecl::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
159376 : #endif
159377 :
159378 121490 : return p_templateDeclaration;
159379 : }
159380 :
159381 : void
159382 14387 : SgTemplateInstantiationMemberFunctionDecl::set_templateDeclaration ( SgTemplateMemberFunctionDeclaration* templateDeclaration )
159383 : {
159384 14387 : ROSE_ASSERT (this != NULL);
159385 :
159386 : #if 0
159387 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159388 : // used to trigger marking transformations for the token-based unparsing.
159389 : printf ("SgTemplateInstantiationMemberFunctionDecl::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
159390 : #endif
159391 :
159392 14387 : set_isModified(true);
159393 :
159394 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
159395 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
159396 : {
159397 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
159398 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
159399 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
159400 : ROSE_ASSERT(false);
159401 : #endif
159402 : }
159403 : #endif
159404 14387 : p_templateDeclaration = templateDeclaration;
159405 14387 : }
159406 :
159407 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159408 :
159409 :
159410 : // End of memberFunctionString
159411 : // Start of memberFunctionString
159412 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
159413 :
159414 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159415 :
159416 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
159417 : const SgTemplateArgumentPtrList &
159418 12949 : SgTemplateInstantiationMemberFunctionDecl::get_templateArguments () const
159419 : {
159420 12949 : assert (this != NULL);
159421 12949 : return p_templateArguments;
159422 : }
159423 :
159424 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
159425 : SgTemplateArgumentPtrList &
159426 199691 : SgTemplateInstantiationMemberFunctionDecl::get_templateArguments ()
159427 : {
159428 199691 : assert (this != NULL);
159429 :
159430 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
159431 : // As a rule only set_ access functions can set the isModified flag.
159432 : // set_isModified(true);
159433 :
159434 199691 : return p_templateArguments;
159435 : }
159436 :
159437 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159438 :
159439 :
159440 : // End of memberFunctionString
159441 : // Start of memberFunctionString
159442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
159443 :
159444 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159445 :
159446 : bool
159447 0 : SgTemplateInstantiationMemberFunctionDecl::get_nameResetFromMangledForm () const
159448 : {
159449 0 : ROSE_ASSERT (this != NULL);
159450 :
159451 : #if 0
159452 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159453 : // used to trigger marking transformations for the token-based unparsing.
159454 : printf ("SgTemplateInstantiationMemberFunctionDecl::get_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
159455 : #endif
159456 :
159457 0 : return p_nameResetFromMangledForm;
159458 : }
159459 :
159460 : void
159461 0 : SgTemplateInstantiationMemberFunctionDecl::set_nameResetFromMangledForm ( bool nameResetFromMangledForm )
159462 : {
159463 0 : ROSE_ASSERT (this != NULL);
159464 :
159465 : #if 0
159466 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159467 : // used to trigger marking transformations for the token-based unparsing.
159468 : printf ("SgTemplateInstantiationMemberFunctionDecl::set_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
159469 : #endif
159470 :
159471 0 : set_isModified(true);
159472 :
159473 0 : p_nameResetFromMangledForm = nameResetFromMangledForm;
159474 0 : }
159475 :
159476 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159477 :
159478 :
159479 : // End of memberFunctionString
159480 : // Start of memberFunctionString
159481 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
159482 :
159483 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159484 :
159485 : bool
159486 2597 : SgTemplateInstantiationMemberFunctionDecl::get_template_argument_list_is_explicit () const
159487 : {
159488 2597 : ROSE_ASSERT (this != NULL);
159489 :
159490 : #if 0
159491 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159492 : // used to trigger marking transformations for the token-based unparsing.
159493 : printf ("SgTemplateInstantiationMemberFunctionDecl::get_template_argument_list_is_explicit = %p = %s \n",this,this->class_name().c_str());
159494 : #endif
159495 :
159496 2597 : return p_template_argument_list_is_explicit;
159497 : }
159498 :
159499 : void
159500 14387 : SgTemplateInstantiationMemberFunctionDecl::set_template_argument_list_is_explicit ( bool template_argument_list_is_explicit )
159501 : {
159502 14387 : ROSE_ASSERT (this != NULL);
159503 :
159504 : #if 0
159505 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159506 : // used to trigger marking transformations for the token-based unparsing.
159507 : printf ("SgTemplateInstantiationMemberFunctionDecl::set_template_argument_list_is_explicit = %p = %s \n",this,this->class_name().c_str());
159508 : #endif
159509 :
159510 14387 : set_isModified(true);
159511 :
159512 14387 : p_template_argument_list_is_explicit = template_argument_list_is_explicit;
159513 14387 : }
159514 :
159515 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159516 :
159517 :
159518 : // End of memberFunctionString
159519 : // Start of memberFunctionString
159520 : /* #line 14461 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
159521 :
159522 : void
159523 14387 : SgTemplateInstantiationMemberFunctionDecl::post_construction_initialization()
159524 : {
159525 : // DQ (4/19/2005): Removed since it is redundant with the define of the template support in ROSE
159526 : // set_from_template(true);
159527 :
159528 : // DQ (2/17/2007): Set the parents of all template arguments to the template instantiation
159529 : // JJW (8/6/2008): This is not a pointer anymore
159530 : #if 0
159531 : if (p_templateArguments != NULL)
159532 : {
159533 : #endif
159534 14387 : SgTemplateArgumentPtrList::iterator i = p_templateArguments.begin();
159535 14387 : while (i != p_templateArguments.end())
159536 : {
159537 0 : (*i)->set_parent(this);
159538 0 : i++;
159539 : }
159540 : #if 0
159541 : }
159542 : else
159543 : {
159544 : printf ("Warning (post_construction_initialization): p_templateArguments == NULL in SgTemplateInstantiationMemberFunctionDecl = %p \n",this);
159545 : }
159546 : #endif
159547 :
159548 : #if 0
159549 : // DQ (3/4/2018): relax this requirement for SgTemplateInstantiationClassDeclaration.
159550 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
159551 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
159552 : if (p_type != NULL)
159553 : {
159554 : printf ("Note: SgTemplateInstantiationMemberFunctionDecl::post_construction_initialization(): p_type != NULL: name = %s \n",p_name.str());
159555 : }
159556 : // ROSE_ASSERT(p_type == NULL);
159557 : #endif
159558 :
159559 : #if 0
159560 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
159561 : printf ("In SgTemplateInstantiationMemberFunctionDecl::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
159562 : #endif
159563 14387 : }
159564 :
159565 : void
159566 14387 : SgTemplateInstantiationMemberFunctionDecl::resetTemplateName ()
159567 : {
159568 : // local version of function to support generation of template names
159569 14387 : resetTemplateNameSupport (p_nameResetFromMangledForm,p_name);
159570 14387 : }
159571 :
159572 : // RV (2/1/2006): Added mangler for template member function instantiations.
159573 : SgName
159574 91339 : SgTemplateInstantiationMemberFunctionDecl::get_mangled_name (void) const
159575 : {
159576 : #if 0
159577 : return mangleTemplateFunction (get_templateName().getString(),get_templateArguments(),get_type(),get_scope());
159578 : #else
159579 : #if 0
159580 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
159581 : SgTemplateInstantiationMemberFunctionDecl* declaration = const_cast<SgTemplateInstantiationMemberFunctionDecl*>(this);
159582 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
159583 : if (i != p_globalMangledNameMap.end())
159584 : {
159585 : return i->second.c_str();
159586 : }
159587 : #endif
159588 182678 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgTemplateInstantiationMemberFunctionDecl*>(this));
159589 91339 : if (mangledNameString.empty() == false)
159590 : {
159591 : // return i->second.c_str();
159592 78390 : return mangledNameString;
159593 : }
159594 : else
159595 : {
159596 12949 : SgName mangledName = mangleTemplateFunction (get_templateName().getString(),get_templateArguments(),get_type(),get_scope());
159597 : #if 0
159598 : printf ("In SgTemplateInstantiationMemberFunctionDecl::get_mangled_name(): mangledName = %s \n",mangledName.str());
159599 : #endif
159600 : // p_globalMangledNameMap[declaration] = mangledName;
159601 12949 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgTemplateInstantiationMemberFunctionDecl*>(this),mangledName);
159602 :
159603 : // DQ (7/24/2012): Added test for template brackets that are caught later in AstConsistencyTests.
159604 : // Make sure that there is no template specific syntax included in the mangled name
159605 25898 : string mangled_name = mangledName;
159606 12949 : if ( mangled_name.find('<') != string::npos )
159607 : {
159608 0 : printf ("In get_mangled_name(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
159609 : }
159610 12949 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
159611 :
159612 : #if 0
159613 : // DQ (7/24/2012): Output the mangled name being generated for debugging.
159614 : printf (">>>>>>>>>> SgTemplateInstantiationMemberFunctionDecl::get_mangled_name(): returning mangledName = %s \n",mangledName.str());
159615 : #endif
159616 :
159617 12949 : return mangledName;
159618 : }
159619 : #endif
159620 : }
159621 :
159622 : // DQ (2/11/2007): Get the associated symbol from the symbol table in the stored scope
159623 : SgSymbol*
159624 179292 : SgTemplateInstantiationMemberFunctionDecl::get_symbol_from_symbol_table() const
159625 : {
159626 179292 : ROSE_ASSERT(get_scope() != NULL);
159627 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
159628 : // return get_scope()->get_symbol_table()->find(this);
159629 179292 : return get_scope()->find_symbol_from_declaration(this);
159630 : }
159631 :
159632 : // DQ (11/27/2011): Adding support to hold the template declarations in the AST.
159633 14387 : SgTemplateInstantiationMemberFunctionDecl::SgTemplateInstantiationMemberFunctionDecl ( SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
159634 : #if 0
159635 : // DQ (10/11/2014): Marking SgFunctionParameterList as a constructor parameter to support aterm to AST generation.
159636 : // : SgMemberFunctionDeclaration(name, NULL, type, definition)
159637 : #else
159638 14387 : : SgMemberFunctionDeclaration(name, type, definition)
159639 : #endif
159640 : {
159641 : // Custom constructor to support same interface and allow for a templated function to to build SgMemberFunctionDeclaration,
159642 : // SgTemplateInstantiationMemberFunctionDecl, SgFunctionDeclaration, and SgTemplateInstantiationFunctionDecl.
159643 :
159644 : // Only two lines of additional code to allow use of same code as in generated constructor (below).
159645 : // SgTemplateDeclaration* templateDeclaration = NULL;
159646 0 : SgTemplateArgumentPtrList templateArguments;
159647 :
159648 : // Same code as in generated constructor.
159649 14387 : p_templateName = "";
159650 : // p_templateDeclaration = templateDeclaration;
159651 14387 : p_templateDeclaration = NULL;
159652 14387 : p_templateArguments = templateArguments;
159653 14387 : p_nameResetFromMangledForm = false;
159654 :
159655 : // Test the variant virtual function
159656 14387 : assert(TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT == variant());
159657 14387 : post_construction_initialization();
159658 :
159659 : // Test the isSgTemplateInstantiationMemberFunctionDecl() function since it has been problematic
159660 14387 : assert(isSgTemplateInstantiationMemberFunctionDecl(this) != NULL);
159661 14387 : }
159662 :
159663 :
159664 :
159665 :
159666 :
159667 : // End of memberFunctionString
159668 : // Start of memberFunctionString
159669 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
159670 :
159671 : // *** COMMON CODE SECTION BEGINS HERE ***
159672 :
159673 : #if 0
159674 : int
159675 : SgTemplateInstantiationMemberFunctionDecl::getVariant() const
159676 : {
159677 : // This function is used in ROSE while "variant()" is used in SAGE
159678 : assert(this != NULL);
159679 : return variant();
159680 : }
159681 : #endif
159682 :
159683 : // This function is used in ROSE in treeTraversal code
159684 : // eventually replaces getVariant() and variant()
159685 : // though after variant() has been removed for a while we will
159686 : // want to change the name of variantT() back to variant()
159687 : // (since the "T" was ment to stand for temporary).
159688 : // When this happens the variantT() will be depricated.
159689 : VariantT
159690 20128000 : SgTemplateInstantiationMemberFunctionDecl::variantT() const
159691 : {
159692 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
159693 20128000 : ROSE_ASSERT(this != NULL);
159694 20128000 : return V_SgTemplateInstantiationMemberFunctionDecl;
159695 : }
159696 :
159697 : #if 0
159698 : int
159699 : SgTemplateInstantiationMemberFunctionDecl::variant() const
159700 : {
159701 : // This function is used in SAGE
159702 : ROSE_ASSERT(this != NULL);
159703 : return TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT;
159704 : }
159705 : #endif
159706 :
159707 : ROSE_DLL_API const char*
159708 1091 : SgTemplateInstantiationMemberFunctionDecl::sage_class_name() const
159709 : {
159710 1091 : ROSE_ASSERT(this != NULL);
159711 1091 : return "SgTemplateInstantiationMemberFunctionDecl";
159712 : }
159713 :
159714 : std::string
159715 15806 : SgTemplateInstantiationMemberFunctionDecl::class_name() const
159716 : {
159717 15806 : ROSE_ASSERT(this != NULL);
159718 15806 : return "SgTemplateInstantiationMemberFunctionDecl";
159719 : }
159720 :
159721 : // DQ (11/26/2005): Support for visitor pattern mechanims
159722 : // (inferior to ROSE traversal mechanism, experimental).
159723 : void
159724 238967 : SgTemplateInstantiationMemberFunctionDecl::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
159725 : {
159726 238967 : ROSE_ASSERT(this != NULL);
159727 238967 : visitor.visit(this);
159728 238967 : }
159729 :
159730 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
159731 0 : void SgTemplateInstantiationMemberFunctionDecl::accept (ROSE_VisitorPattern & visitor) {
159732 0 : ROSE_ASSERT(this != NULL);
159733 0 : visitor.visit(this);
159734 0 : }
159735 :
159736 : SgTemplateInstantiationMemberFunctionDecl*
159737 0 : SgTemplateInstantiationMemberFunctionDecl::addRegExpAttribute(std::string s, AstRegExAttribute* a)
159738 : {
159739 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
159740 : // This function is currently only supported for the AST used the represent Binary executables.
159741 : if (0 /* isSgAsmNode(this) != NULL */)
159742 : {
159743 : // Support for regex specification.
159744 : std::string prefixCode = "REGEX:";
159745 : addNewAttribute(prefixCode + s,a);
159746 : }
159747 : #endif
159748 :
159749 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
159750 0 : return this;
159751 : }
159752 :
159753 : // *** COMMON CODE SECTION ENDS HERE ***
159754 :
159755 :
159756 : // End of memberFunctionString
159757 : // Start of memberFunctionString
159758 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
159759 :
159760 :
159761 : #if 0
159762 : //! Error checking support
159763 : /*! Verifies the following:
159764 : - working getVariant() member function
159765 : - calls base class's error() member function
159766 : Every class has one of these functions.
159767 : */
159768 : bool
159769 : SgTemplateInstantiationMemberFunctionDecl::error()
159770 : {
159771 : // Put error checking here
159772 :
159773 : ROSE_ASSERT (this != NULL);
159774 : if (getVariant() != TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT)
159775 : {
159776 : printf ("Error in SgTemplateInstantiationMemberFunctionDecl::error(): SgTemplateInstantiationMemberFunctionDecl object has a %s variant \n",
159777 : Cxx_GrammarTerminalNames[getVariant()].name);
159778 : // printf ("Error in SgTemplateInstantiationMemberFunctionDecl::error() \n");
159779 : ROSE_ABORT();
159780 : }
159781 :
159782 : ROSE_ASSERT (getVariant() == TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT);
159783 : return SgMemberFunctionDeclaration::error();
159784 : }
159785 : #endif
159786 :
159787 :
159788 :
159789 : // End of memberFunctionString
159790 :
159791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
159792 :
159793 37755200 : SgTemplateInstantiationMemberFunctionDecl* isSgTemplateInstantiationMemberFunctionDecl ( SgNode* inputDerivedClassPointer )
159794 : {
159795 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
159796 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
159797 : // So to fix this we return NULL directly when the input is NULL and avoid the
159798 : // dynamic_cast in this case. This is likely a performance improvement as well.
159799 : // return dynamic_cast<SgTemplateInstantiationMemberFunctionDecl*>(inputDerivedClassPointer);
159800 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationMemberFunctionDecl uses table-driven castability instead of c++ default dynamic_cast
159801 : // this improves the running time performance by 10-20%.
159802 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateInstantiationMemberFunctionDecl*>(inputDerivedClassPointer);
159803 37755200 : return IS_SgTemplateInstantiationMemberFunctionDecl_FAST_MACRO(inputDerivedClassPointer);
159804 : }
159805 :
159806 : // DQ (11/8/2003): Added version of functions taking const pointer
159807 179292 : const SgTemplateInstantiationMemberFunctionDecl* isSgTemplateInstantiationMemberFunctionDecl ( const SgNode* inputDerivedClassPointer )
159808 : {
159809 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
159810 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
159811 : // So to fix this we return NULL directly when the input is NULL and avoid the
159812 : // dynamic_cast in this case. This is likely a performance improvement as well.
159813 : // return dynamic_cast<const SgTemplateInstantiationMemberFunctionDecl*>(inputDerivedClassPointer);
159814 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationMemberFunctionDecl uses table-driven castability instead of c++ default dynamic_cast
159815 : // this improves the running time performance by 10-20%.
159816 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateInstantiationMemberFunctionDecl*>(inputDerivedClassPointer);
159817 179292 : return IS_SgTemplateInstantiationMemberFunctionDecl_FAST_MACRO(inputDerivedClassPointer);
159818 : }
159819 :
159820 :
159821 :
159822 : /* #line 159823 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159823 :
159824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
159825 :
159826 : /**
159827 : \brief Generated destructor
159828 :
159829 : This destructor is automatically generated (by ROSETTA). This destructor
159830 : only frees memory of data members associated with the parts of the current IR node which
159831 : are NOT traversed. Those data members that are part of a traversal can be freed using
159832 : a traversal (calling this destructor on all children in a post-order traversal). Such
159833 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
159834 :
159835 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
159836 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
159837 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
159838 :
159839 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
159840 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
159841 : pointers are not yet implemented to call delete on eash pointer in the container.
159842 : (This could be done by derivation from the STL containers to define containers that
159843 : automatically deleted their members.)
159844 :
159845 : */
159846 7218 : SgTemplateInstantiationMemberFunctionDecl::~SgTemplateInstantiationMemberFunctionDecl () {
159847 3478 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
159848 :
159849 :
159850 : // case: not a listType for templateName
159851 3478 : p_templateName = ""; // non list case
159852 : // case: not a listType for templateDeclaration
159853 3478 : p_templateDeclaration = NULL; // non list case
159854 : // case: listType for templateArguments
159855 : // case: listType (typeIsPointerToList == false) for templateArguments
159856 3478 : p_templateArguments.erase(p_templateArguments.begin(),p_templateArguments.end());
159857 : // case: not a listType for nameResetFromMangledForm
159858 3478 : p_nameResetFromMangledForm = false; // non list case
159859 : // case: not a listType for template_argument_list_is_explicit
159860 3478 : p_template_argument_list_is_explicit = false; // non list case
159861 :
159862 : }
159863 :
159864 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
159865 6956 : }
159866 :
159867 :
159868 : /* #line 159869 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159869 :
159870 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
159871 :
159872 : // Generated constructor
159873 0 : SgTemplateInstantiationMemberFunctionDecl::SgTemplateInstantiationMemberFunctionDecl ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgTemplateMemberFunctionDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments )
159874 0 : : SgMemberFunctionDeclaration(startOfConstruct, name, type, definition)
159875 : {
159876 : #ifdef DEBUG
159877 : // printf ("In SgTemplateInstantiationMemberFunctionDecl::SgTemplateInstantiationMemberFunctionDecl (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgTemplateMemberFunctionDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments) sage_class_name() = %s \n",sage_class_name());
159878 : #endif
159879 : #if 0
159880 : // debugging information!
159881 : printf ("In SgTemplateInstantiationMemberFunctionDecl::SgTemplateInstantiationMemberFunctionDecl (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgTemplateMemberFunctionDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments): this = %p = %s \n",this,this->class_name().c_str());
159882 : #endif
159883 :
159884 0 : p_templateName = "";
159885 0 : p_templateDeclaration = templateDeclaration;
159886 0 : p_templateArguments = templateArguments;
159887 0 : p_nameResetFromMangledForm = false;
159888 0 : p_template_argument_list_is_explicit = false;
159889 :
159890 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
159891 :
159892 : #if 0
159893 : // DQ (7/30/2014): Call a virtual function.
159894 : std::string s = this->class_name();
159895 : #endif
159896 :
159897 : // Test the variant virtual function
159898 : // assert(TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT == variant());
159899 0 : assert(TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT == this->variant());
159900 0 : ROSE_ASSERT(TEMPLATE_INST_MEMBER_FUNCTION_DECL_STMT == (int)(this->variantT()));
159901 0 : post_construction_initialization();
159902 :
159903 : // Test the isSgTemplateInstantiationMemberFunctionDecl() function since it has been problematic
159904 0 : assert(isSgTemplateInstantiationMemberFunctionDecl(this) != NULL);
159905 0 : }
159906 :
159907 : // Generated constructor (all data members)
159908 :
159909 : /* #line 159910 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159910 :
159911 :
159912 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
159913 :
159914 :
159915 : // ********************************************************
159916 : // member functions common across all array grammar objects
159917 : // ********************************************************
159918 :
159919 :
159920 :
159921 : /* #line 159922 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159922 :
159923 :
159924 :
159925 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
159926 :
159927 : // ********************************************************
159928 : // member functions specific to each node in the grammar
159929 : // ********************************************************
159930 :
159931 :
159932 : /* #line 159933 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
159933 :
159934 : // Start of memberFunctionString
159935 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
159936 :
159937 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159938 :
159939 : SgName
159940 18269 : SgTemplateInstantiationFunctionDecl::get_templateName () const
159941 : {
159942 18269 : ROSE_ASSERT (this != NULL);
159943 :
159944 : #if 0
159945 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159946 : // used to trigger marking transformations for the token-based unparsing.
159947 : printf ("SgTemplateInstantiationFunctionDecl::get_templateName = %p = %s \n",this,this->class_name().c_str());
159948 : #endif
159949 :
159950 18269 : return p_templateName;
159951 : }
159952 :
159953 : void
159954 2272 : SgTemplateInstantiationFunctionDecl::set_templateName ( SgName templateName )
159955 : {
159956 2272 : ROSE_ASSERT (this != NULL);
159957 :
159958 : #if 0
159959 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159960 : // used to trigger marking transformations for the token-based unparsing.
159961 : printf ("SgTemplateInstantiationFunctionDecl::set_templateName = %p = %s \n",this,this->class_name().c_str());
159962 : #endif
159963 :
159964 2272 : set_isModified(true);
159965 :
159966 2272 : p_templateName = templateName;
159967 2272 : }
159968 :
159969 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
159970 :
159971 :
159972 : // End of memberFunctionString
159973 : // Start of memberFunctionString
159974 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
159975 :
159976 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
159977 :
159978 : SgTemplateFunctionDeclaration*
159979 12509 : SgTemplateInstantiationFunctionDecl::get_templateDeclaration () const
159980 : {
159981 12509 : ROSE_ASSERT (this != NULL);
159982 :
159983 : #if 0
159984 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159985 : // used to trigger marking transformations for the token-based unparsing.
159986 : printf ("SgTemplateInstantiationFunctionDecl::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
159987 : #endif
159988 :
159989 12509 : return p_templateDeclaration;
159990 : }
159991 :
159992 : void
159993 3703 : SgTemplateInstantiationFunctionDecl::set_templateDeclaration ( SgTemplateFunctionDeclaration* templateDeclaration )
159994 : {
159995 3703 : ROSE_ASSERT (this != NULL);
159996 :
159997 : #if 0
159998 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
159999 : // used to trigger marking transformations for the token-based unparsing.
160000 : printf ("SgTemplateInstantiationFunctionDecl::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
160001 : #endif
160002 :
160003 3703 : set_isModified(true);
160004 :
160005 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
160006 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
160007 : {
160008 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
160009 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
160010 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
160011 : ROSE_ASSERT(false);
160012 : #endif
160013 : }
160014 : #endif
160015 3703 : p_templateDeclaration = templateDeclaration;
160016 3703 : }
160017 :
160018 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160019 :
160020 :
160021 : // End of memberFunctionString
160022 : // Start of memberFunctionString
160023 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
160024 :
160025 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160026 :
160027 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
160028 : const SgTemplateArgumentPtrList &
160029 2556 : SgTemplateInstantiationFunctionDecl::get_templateArguments () const
160030 : {
160031 2556 : assert (this != NULL);
160032 2556 : return p_templateArguments;
160033 : }
160034 :
160035 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
160036 : SgTemplateArgumentPtrList &
160037 37382 : SgTemplateInstantiationFunctionDecl::get_templateArguments ()
160038 : {
160039 37382 : assert (this != NULL);
160040 :
160041 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
160042 : // As a rule only set_ access functions can set the isModified flag.
160043 : // set_isModified(true);
160044 :
160045 37382 : return p_templateArguments;
160046 : }
160047 :
160048 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160049 :
160050 :
160051 : // End of memberFunctionString
160052 : // Start of memberFunctionString
160053 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
160054 :
160055 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160056 :
160057 : bool
160058 0 : SgTemplateInstantiationFunctionDecl::get_nameResetFromMangledForm () const
160059 : {
160060 0 : ROSE_ASSERT (this != NULL);
160061 :
160062 : #if 0
160063 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160064 : // used to trigger marking transformations for the token-based unparsing.
160065 : printf ("SgTemplateInstantiationFunctionDecl::get_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
160066 : #endif
160067 :
160068 0 : return p_nameResetFromMangledForm;
160069 : }
160070 :
160071 : void
160072 0 : SgTemplateInstantiationFunctionDecl::set_nameResetFromMangledForm ( bool nameResetFromMangledForm )
160073 : {
160074 0 : ROSE_ASSERT (this != NULL);
160075 :
160076 : #if 0
160077 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160078 : // used to trigger marking transformations for the token-based unparsing.
160079 : printf ("SgTemplateInstantiationFunctionDecl::set_nameResetFromMangledForm = %p = %s \n",this,this->class_name().c_str());
160080 : #endif
160081 :
160082 0 : set_isModified(true);
160083 :
160084 0 : p_nameResetFromMangledForm = nameResetFromMangledForm;
160085 0 : }
160086 :
160087 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160088 :
160089 :
160090 : // End of memberFunctionString
160091 : // Start of memberFunctionString
160092 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
160093 :
160094 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160095 :
160096 : bool
160097 928 : SgTemplateInstantiationFunctionDecl::get_template_argument_list_is_explicit () const
160098 : {
160099 928 : ROSE_ASSERT (this != NULL);
160100 :
160101 : #if 0
160102 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160103 : // used to trigger marking transformations for the token-based unparsing.
160104 : printf ("SgTemplateInstantiationFunctionDecl::get_template_argument_list_is_explicit = %p = %s \n",this,this->class_name().c_str());
160105 : #endif
160106 :
160107 928 : return p_template_argument_list_is_explicit;
160108 : }
160109 :
160110 : void
160111 2272 : SgTemplateInstantiationFunctionDecl::set_template_argument_list_is_explicit ( bool template_argument_list_is_explicit )
160112 : {
160113 2272 : ROSE_ASSERT (this != NULL);
160114 :
160115 : #if 0
160116 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160117 : // used to trigger marking transformations for the token-based unparsing.
160118 : printf ("SgTemplateInstantiationFunctionDecl::set_template_argument_list_is_explicit = %p = %s \n",this,this->class_name().c_str());
160119 : #endif
160120 :
160121 2272 : set_isModified(true);
160122 :
160123 2272 : p_template_argument_list_is_explicit = template_argument_list_is_explicit;
160124 2272 : }
160125 :
160126 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160127 :
160128 :
160129 : // End of memberFunctionString
160130 : // Start of memberFunctionString
160131 : /* #line 14311 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
160132 :
160133 : void
160134 2272 : SgTemplateInstantiationFunctionDecl::post_construction_initialization()
160135 : {
160136 : // DQ (4/19/2005): Removed since it is redundant with the define of the template support in ROSE
160137 : // set_from_template(true);
160138 :
160139 : // DQ (2/17/2007): Set the parents of all template arguments to the template instantiation
160140 : // JJW (8/6/2008): This is not a pointer anymore
160141 : #if 0
160142 : if (p_templateArguments != NULL)
160143 : {
160144 : #endif
160145 2272 : SgTemplateArgumentPtrList::iterator i = p_templateArguments.begin();
160146 2272 : while (i != p_templateArguments.end())
160147 : {
160148 0 : (*i)->set_parent(this);
160149 0 : i++;
160150 : }
160151 : #if 0
160152 : }
160153 : else
160154 : {
160155 : printf ("Warning (post_construction_initialization): p_templateArguments == NULL in SgTemplateInstantiationFunctionDecl = %p \n",this);
160156 : }
160157 : #endif
160158 :
160159 : #if 0
160160 : // DQ (3/4/2018): relax this requirement for SgTemplateInstantiationClassDeclaration.
160161 : // DQ (2/27/2018): Enforce that this is not already set (should be set after the constructor to
160162 : // simplify how derived classes (e.g. SgTemplateInstantiationClassDeclaration statements) work.
160163 : if (p_type != NULL)
160164 : {
160165 : printf ("Note: SgTemplateInstantiationMemberFunctionDecl::post_construction_initialization(): p_type != NULL: name = %s \n",p_name.str());
160166 : }
160167 : // ROSE_ASSERT(p_type == NULL);
160168 : #endif
160169 :
160170 : #if 0
160171 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
160172 : printf ("In SgTemplateInstantiationFunctionDecl::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
160173 : #endif
160174 2272 : }
160175 :
160176 : void
160177 2272 : SgTemplateInstantiationFunctionDecl::resetTemplateName ()
160178 : {
160179 : // local version of function to support generation of template names
160180 2272 : resetTemplateNameSupport (p_nameResetFromMangledForm,p_name);
160181 2272 : }
160182 :
160183 : // RV (2/1/2006): Added mangler for template function instantiations.
160184 : SgName
160185 19277 : SgTemplateInstantiationFunctionDecl::get_mangled_name (void) const
160186 : {
160187 : #if 0
160188 : return mangleTemplateFunction (get_templateName().getString(),get_templateArguments(),get_type(),get_scope());
160189 : #else
160190 : #if 0
160191 : // DQ (3/12/2007): Experiment with mangled name map (caching for performance improvement)
160192 : SgTemplateInstantiationFunctionDecl* declaration = const_cast<SgTemplateInstantiationFunctionDecl*>(this);
160193 : std::map<SgNode*,std::string>::iterator i = p_globalMangledNameMap.find(declaration);
160194 : if (i != p_globalMangledNameMap.end())
160195 : {
160196 : return i->second.c_str();
160197 : }
160198 : #endif
160199 38554 : std::string mangledNameString = SageInterface::getMangledNameFromCache(const_cast<SgTemplateInstantiationFunctionDecl*>(this));
160200 19277 : if (mangledNameString.empty() == false)
160201 : {
160202 : // return i->second.c_str();
160203 16721 : return mangledNameString;
160204 : }
160205 : else
160206 : {
160207 : // DQ (5/31/2012): Check that this name is set.
160208 2556 : ROSE_ASSERT(get_templateName().is_null() == false);
160209 :
160210 2556 : SgName mangledName = mangleTemplateFunction (get_templateName().getString(),get_templateArguments(),get_type(),get_scope());
160211 : #if 0
160212 : printf ("In SgTemplateInstantiationFunctionDecl::get_mangled_name(): mangledName = %s \n",mangledName.str());
160213 : #endif
160214 : // p_globalMangledNameMap[declaration] = mangledName;
160215 2556 : mangledName = SageInterface::addMangledNameToCache(const_cast<SgTemplateInstantiationFunctionDecl*>(this),mangledName);
160216 :
160217 : // DQ (7/24/2012): Added test for template brackets that are caught later in AstConsistencyTests.
160218 : // Make sure that there is no template specific syntax included in the mangled name
160219 5112 : string mangled_name = mangledName;
160220 2556 : if ( mangled_name.find('<') != string::npos )
160221 : {
160222 0 : printf ("In get_mangled_name(): this = %p = %s check mangled class name = %s \n",this,this->class_name().c_str(),mangled_name.c_str());
160223 : }
160224 2556 : ROSE_ASSERT(mangled_name.find('<') == string::npos);
160225 :
160226 : #if 0
160227 : // DQ (7/24/2012): Output the mangled name being generated for debugging.
160228 : printf (">>>>>>>>>> SgTemplateInstantiationFunctionDecl::get_mangled_name(): returning mangledName = %s \n",mangledName.str());
160229 : #endif
160230 :
160231 2556 : return mangledName;
160232 : }
160233 : #endif
160234 : }
160235 :
160236 : // DQ (2/11/2007): Get the associated symbol from the symbol table in the stored scope
160237 : SgSymbol*
160238 26301 : SgTemplateInstantiationFunctionDecl::get_symbol_from_symbol_table() const
160239 : {
160240 26301 : ROSE_ASSERT(get_scope() != NULL);
160241 : // ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
160242 : // return get_scope()->get_symbol_table()->find(this);
160243 26301 : return get_scope()->find_symbol_from_declaration(this);
160244 : }
160245 :
160246 :
160247 : // DQ (11/27/2011): Adding support to hold the template declarations in the AST.
160248 2272 : SgTemplateInstantiationFunctionDecl::SgTemplateInstantiationFunctionDecl ( SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
160249 : #if 0
160250 : // DQ (10/11/2014): Marking SgFunctionParameterList as a constructor parameter to support aterm to AST generation.
160251 : // : SgFunctionDeclaration(name, NULL, type, definition)
160252 : #else
160253 2272 : : SgFunctionDeclaration(name, type, definition)
160254 : #endif
160255 : {
160256 : // Custom constructor to support same interface and allow for a templated function to to build SgFunctionDeclaration,
160257 : // SgTemplateInstantiationFunctionDecl, SgMemberFunctionDeclaration, and SgTemplateInstantiationMemberFunctionDecl.
160258 :
160259 : // Only two lines of additional code to allow use of same code as in generated constructor (below).
160260 : // SgTemplateDeclaration* templateDeclaration = NULL;
160261 0 : SgTemplateArgumentPtrList templateArguments;
160262 :
160263 : // Same code as in generated constructor.
160264 2272 : p_templateName = "";
160265 :
160266 : // p_templateDeclaration = templateDeclaration;
160267 2272 : p_templateDeclaration = NULL;
160268 :
160269 2272 : p_templateArguments = templateArguments;
160270 2272 : p_nameResetFromMangledForm = false;
160271 :
160272 : // Test the variant virtual function
160273 2272 : assert(TEMPLATE_INST_FUNCTION_DECL_STMT == variant());
160274 2272 : post_construction_initialization();
160275 :
160276 : // Test the isSgTemplateInstantiationFunctionDecl() function since it has been problematic
160277 2272 : assert(isSgTemplateInstantiationFunctionDecl(this) != NULL);
160278 2272 : }
160279 :
160280 :
160281 :
160282 : // End of memberFunctionString
160283 : // Start of memberFunctionString
160284 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
160285 :
160286 : // *** COMMON CODE SECTION BEGINS HERE ***
160287 :
160288 : #if 0
160289 : int
160290 : SgTemplateInstantiationFunctionDecl::getVariant() const
160291 : {
160292 : // This function is used in ROSE while "variant()" is used in SAGE
160293 : assert(this != NULL);
160294 : return variant();
160295 : }
160296 : #endif
160297 :
160298 : // This function is used in ROSE in treeTraversal code
160299 : // eventually replaces getVariant() and variant()
160300 : // though after variant() has been removed for a while we will
160301 : // want to change the name of variantT() back to variant()
160302 : // (since the "T" was ment to stand for temporary).
160303 : // When this happens the variantT() will be depricated.
160304 : VariantT
160305 2934060 : SgTemplateInstantiationFunctionDecl::variantT() const
160306 : {
160307 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
160308 2934060 : ROSE_ASSERT(this != NULL);
160309 2934060 : return V_SgTemplateInstantiationFunctionDecl;
160310 : }
160311 :
160312 : #if 0
160313 : int
160314 : SgTemplateInstantiationFunctionDecl::variant() const
160315 : {
160316 : // This function is used in SAGE
160317 : ROSE_ASSERT(this != NULL);
160318 : return TEMPLATE_INST_FUNCTION_DECL_STMT;
160319 : }
160320 : #endif
160321 :
160322 : ROSE_DLL_API const char*
160323 197 : SgTemplateInstantiationFunctionDecl::sage_class_name() const
160324 : {
160325 197 : ROSE_ASSERT(this != NULL);
160326 197 : return "SgTemplateInstantiationFunctionDecl";
160327 : }
160328 :
160329 : std::string
160330 2419 : SgTemplateInstantiationFunctionDecl::class_name() const
160331 : {
160332 2419 : ROSE_ASSERT(this != NULL);
160333 2419 : return "SgTemplateInstantiationFunctionDecl";
160334 : }
160335 :
160336 : // DQ (11/26/2005): Support for visitor pattern mechanims
160337 : // (inferior to ROSE traversal mechanism, experimental).
160338 : void
160339 38671 : SgTemplateInstantiationFunctionDecl::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
160340 : {
160341 38671 : ROSE_ASSERT(this != NULL);
160342 38671 : visitor.visit(this);
160343 38671 : }
160344 :
160345 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
160346 0 : void SgTemplateInstantiationFunctionDecl::accept (ROSE_VisitorPattern & visitor) {
160347 0 : ROSE_ASSERT(this != NULL);
160348 0 : visitor.visit(this);
160349 0 : }
160350 :
160351 : SgTemplateInstantiationFunctionDecl*
160352 0 : SgTemplateInstantiationFunctionDecl::addRegExpAttribute(std::string s, AstRegExAttribute* a)
160353 : {
160354 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
160355 : // This function is currently only supported for the AST used the represent Binary executables.
160356 : if (0 /* isSgAsmNode(this) != NULL */)
160357 : {
160358 : // Support for regex specification.
160359 : std::string prefixCode = "REGEX:";
160360 : addNewAttribute(prefixCode + s,a);
160361 : }
160362 : #endif
160363 :
160364 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
160365 0 : return this;
160366 : }
160367 :
160368 : // *** COMMON CODE SECTION ENDS HERE ***
160369 :
160370 :
160371 : // End of memberFunctionString
160372 : // Start of memberFunctionString
160373 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
160374 :
160375 :
160376 : #if 0
160377 : //! Error checking support
160378 : /*! Verifies the following:
160379 : - working getVariant() member function
160380 : - calls base class's error() member function
160381 : Every class has one of these functions.
160382 : */
160383 : bool
160384 : SgTemplateInstantiationFunctionDecl::error()
160385 : {
160386 : // Put error checking here
160387 :
160388 : ROSE_ASSERT (this != NULL);
160389 : if (getVariant() != TEMPLATE_INST_FUNCTION_DECL_STMT)
160390 : {
160391 : printf ("Error in SgTemplateInstantiationFunctionDecl::error(): SgTemplateInstantiationFunctionDecl object has a %s variant \n",
160392 : Cxx_GrammarTerminalNames[getVariant()].name);
160393 : // printf ("Error in SgTemplateInstantiationFunctionDecl::error() \n");
160394 : ROSE_ABORT();
160395 : }
160396 :
160397 : ROSE_ASSERT (getVariant() == TEMPLATE_INST_FUNCTION_DECL_STMT);
160398 : return SgFunctionDeclaration::error();
160399 : }
160400 : #endif
160401 :
160402 :
160403 :
160404 : // End of memberFunctionString
160405 :
160406 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
160407 :
160408 32067000 : SgTemplateInstantiationFunctionDecl* isSgTemplateInstantiationFunctionDecl ( SgNode* inputDerivedClassPointer )
160409 : {
160410 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
160411 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
160412 : // So to fix this we return NULL directly when the input is NULL and avoid the
160413 : // dynamic_cast in this case. This is likely a performance improvement as well.
160414 : // return dynamic_cast<SgTemplateInstantiationFunctionDecl*>(inputDerivedClassPointer);
160415 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationFunctionDecl uses table-driven castability instead of c++ default dynamic_cast
160416 : // this improves the running time performance by 10-20%.
160417 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateInstantiationFunctionDecl*>(inputDerivedClassPointer);
160418 32067000 : return IS_SgTemplateInstantiationFunctionDecl_FAST_MACRO(inputDerivedClassPointer);
160419 : }
160420 :
160421 : // DQ (11/8/2003): Added version of functions taking const pointer
160422 29478 : const SgTemplateInstantiationFunctionDecl* isSgTemplateInstantiationFunctionDecl ( const SgNode* inputDerivedClassPointer )
160423 : {
160424 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
160425 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
160426 : // So to fix this we return NULL directly when the input is NULL and avoid the
160427 : // dynamic_cast in this case. This is likely a performance improvement as well.
160428 : // return dynamic_cast<const SgTemplateInstantiationFunctionDecl*>(inputDerivedClassPointer);
160429 : // Milind Chabbi (8/28/2013): isSgTemplateInstantiationFunctionDecl uses table-driven castability instead of c++ default dynamic_cast
160430 : // this improves the running time performance by 10-20%.
160431 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateInstantiationFunctionDecl*>(inputDerivedClassPointer);
160432 29478 : return IS_SgTemplateInstantiationFunctionDecl_FAST_MACRO(inputDerivedClassPointer);
160433 : }
160434 :
160435 :
160436 :
160437 : /* #line 160438 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160438 :
160439 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
160440 :
160441 : /**
160442 : \brief Generated destructor
160443 :
160444 : This destructor is automatically generated (by ROSETTA). This destructor
160445 : only frees memory of data members associated with the parts of the current IR node which
160446 : are NOT traversed. Those data members that are part of a traversal can be freed using
160447 : a traversal (calling this destructor on all children in a post-order traversal). Such
160448 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
160449 :
160450 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
160451 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
160452 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
160453 :
160454 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
160455 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
160456 : pointers are not yet implemented to call delete on eash pointer in the container.
160457 : (This could be done by derivation from the STL containers to define containers that
160458 : automatically deleted their members.)
160459 :
160460 : */
160461 1698 : SgTemplateInstantiationFunctionDecl::~SgTemplateInstantiationFunctionDecl () {
160462 566 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
160463 :
160464 :
160465 : // case: not a listType for templateName
160466 566 : p_templateName = ""; // non list case
160467 : // case: not a listType for templateDeclaration
160468 566 : p_templateDeclaration = NULL; // non list case
160469 : // case: listType for templateArguments
160470 : // case: listType (typeIsPointerToList == false) for templateArguments
160471 566 : p_templateArguments.erase(p_templateArguments.begin(),p_templateArguments.end());
160472 : // case: not a listType for nameResetFromMangledForm
160473 566 : p_nameResetFromMangledForm = false; // non list case
160474 : // case: not a listType for template_argument_list_is_explicit
160475 566 : p_template_argument_list_is_explicit = false; // non list case
160476 :
160477 : }
160478 :
160479 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
160480 1132 : }
160481 :
160482 :
160483 : /* #line 160484 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160484 :
160485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
160486 :
160487 : // Generated constructor
160488 0 : SgTemplateInstantiationFunctionDecl::SgTemplateInstantiationFunctionDecl ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgTemplateFunctionDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments )
160489 0 : : SgFunctionDeclaration(startOfConstruct, name, type, definition)
160490 : {
160491 : #ifdef DEBUG
160492 : // printf ("In SgTemplateInstantiationFunctionDecl::SgTemplateInstantiationFunctionDecl (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgTemplateFunctionDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments) sage_class_name() = %s \n",sage_class_name());
160493 : #endif
160494 : #if 0
160495 : // debugging information!
160496 : printf ("In SgTemplateInstantiationFunctionDecl::SgTemplateInstantiationFunctionDecl (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgTemplateFunctionDeclaration* templateDeclaration, SgTemplateArgumentPtrList templateArguments): this = %p = %s \n",this,this->class_name().c_str());
160497 : #endif
160498 :
160499 0 : p_templateName = "";
160500 0 : p_templateDeclaration = templateDeclaration;
160501 0 : p_templateArguments = templateArguments;
160502 0 : p_nameResetFromMangledForm = false;
160503 0 : p_template_argument_list_is_explicit = false;
160504 :
160505 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
160506 :
160507 : #if 0
160508 : // DQ (7/30/2014): Call a virtual function.
160509 : std::string s = this->class_name();
160510 : #endif
160511 :
160512 : // Test the variant virtual function
160513 : // assert(TEMPLATE_INST_FUNCTION_DECL_STMT == variant());
160514 0 : assert(TEMPLATE_INST_FUNCTION_DECL_STMT == this->variant());
160515 0 : ROSE_ASSERT(TEMPLATE_INST_FUNCTION_DECL_STMT == (int)(this->variantT()));
160516 0 : post_construction_initialization();
160517 :
160518 : // Test the isSgTemplateInstantiationFunctionDecl() function since it has been problematic
160519 0 : assert(isSgTemplateInstantiationFunctionDecl(this) != NULL);
160520 0 : }
160521 :
160522 : // Generated constructor (all data members)
160523 :
160524 : /* #line 160525 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160525 :
160526 :
160527 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
160528 :
160529 :
160530 : // ********************************************************
160531 : // member functions common across all array grammar objects
160532 : // ********************************************************
160533 :
160534 :
160535 :
160536 : /* #line 160537 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160537 :
160538 :
160539 :
160540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
160541 :
160542 : // ********************************************************
160543 : // member functions specific to each node in the grammar
160544 : // ********************************************************
160545 :
160546 :
160547 : /* #line 160548 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160548 :
160549 : // Start of memberFunctionString
160550 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
160551 :
160552 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160553 :
160554 : bool
160555 27 : SgProgramHeaderStatement::get_program_statement_explicit () const
160556 : {
160557 27 : ROSE_ASSERT (this != NULL);
160558 :
160559 : #if 0
160560 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160561 : // used to trigger marking transformations for the token-based unparsing.
160562 : printf ("SgProgramHeaderStatement::get_program_statement_explicit = %p = %s \n",this,this->class_name().c_str());
160563 : #endif
160564 :
160565 27 : return p_program_statement_explicit;
160566 : }
160567 :
160568 : void
160569 0 : SgProgramHeaderStatement::set_program_statement_explicit ( bool program_statement_explicit )
160570 : {
160571 0 : ROSE_ASSERT (this != NULL);
160572 :
160573 : #if 0
160574 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160575 : // used to trigger marking transformations for the token-based unparsing.
160576 : printf ("SgProgramHeaderStatement::set_program_statement_explicit = %p = %s \n",this,this->class_name().c_str());
160577 : #endif
160578 :
160579 0 : set_isModified(true);
160580 :
160581 0 : p_program_statement_explicit = program_statement_explicit;
160582 0 : }
160583 :
160584 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160585 :
160586 :
160587 : // End of memberFunctionString
160588 : // Start of memberFunctionString
160589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
160590 :
160591 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160592 :
160593 : SgLabelRefExp*
160594 27 : SgProgramHeaderStatement::get_end_numeric_label () const
160595 : {
160596 27 : ROSE_ASSERT (this != NULL);
160597 :
160598 : #if 0
160599 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160600 : // used to trigger marking transformations for the token-based unparsing.
160601 : printf ("SgProgramHeaderStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
160602 : #endif
160603 :
160604 27 : return p_end_numeric_label;
160605 : }
160606 :
160607 : void
160608 0 : SgProgramHeaderStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
160609 : {
160610 0 : ROSE_ASSERT (this != NULL);
160611 :
160612 : #if 0
160613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160614 : // used to trigger marking transformations for the token-based unparsing.
160615 : printf ("SgProgramHeaderStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
160616 : #endif
160617 :
160618 0 : set_isModified(true);
160619 :
160620 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
160621 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
160622 : {
160623 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
160624 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
160625 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
160626 : ROSE_ASSERT(false);
160627 : #endif
160628 : }
160629 : #endif
160630 0 : p_end_numeric_label = end_numeric_label;
160631 0 : }
160632 :
160633 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160634 :
160635 :
160636 : // End of memberFunctionString
160637 : // Start of memberFunctionString
160638 : /* #line 17891 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
160639 :
160640 : void
160641 27 : SgProgramHeaderStatement::post_construction_initialization()
160642 : {
160643 27 : }
160644 :
160645 : SgName
160646 1028 : SgProgramHeaderStatement::get_mangled_name() const
160647 : {
160648 : // DQ (8/17/2007): This Fortran specific IR node can be as simple a mangled name as we like, I think.
160649 :
160650 : // printf ("SgProgramHeaderStatement::get_mangled_name() not implemented \n");
160651 : // ROSE_ASSERT(false);
160652 : // return get_name();
160653 1028 : return SgFunctionDeclaration::get_mangled_name();
160654 : }
160655 :
160656 :
160657 : bool
160658 0 : SgProgramHeaderStatement::replace_child(SgStatement *target, SgStatement *newstmt, bool extractBasicBlock)
160659 : {
160660 0 : if(StatementReplace(this, p_definition, target, newstmt))
160661 : return true;
160662 : else
160663 0 : return (StatementReplace(this, p_parameterList, target, newstmt));
160664 : }
160665 :
160666 :
160667 :
160668 : // End of memberFunctionString
160669 : // Start of memberFunctionString
160670 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
160671 :
160672 : // *** COMMON CODE SECTION BEGINS HERE ***
160673 :
160674 : #if 0
160675 : int
160676 : SgProgramHeaderStatement::getVariant() const
160677 : {
160678 : // This function is used in ROSE while "variant()" is used in SAGE
160679 : assert(this != NULL);
160680 : return variant();
160681 : }
160682 : #endif
160683 :
160684 : // This function is used in ROSE in treeTraversal code
160685 : // eventually replaces getVariant() and variant()
160686 : // though after variant() has been removed for a while we will
160687 : // want to change the name of variantT() back to variant()
160688 : // (since the "T" was ment to stand for temporary).
160689 : // When this happens the variantT() will be depricated.
160690 : VariantT
160691 24106 : SgProgramHeaderStatement::variantT() const
160692 : {
160693 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
160694 24106 : ROSE_ASSERT(this != NULL);
160695 24106 : return V_SgProgramHeaderStatement;
160696 : }
160697 :
160698 : #if 0
160699 : int
160700 : SgProgramHeaderStatement::variant() const
160701 : {
160702 : // This function is used in SAGE
160703 : ROSE_ASSERT(this != NULL);
160704 : return PROGRAM_HEADER_STMT;
160705 : }
160706 : #endif
160707 :
160708 : ROSE_DLL_API const char*
160709 54 : SgProgramHeaderStatement::sage_class_name() const
160710 : {
160711 54 : ROSE_ASSERT(this != NULL);
160712 54 : return "SgProgramHeaderStatement";
160713 : }
160714 :
160715 : std::string
160716 26 : SgProgramHeaderStatement::class_name() const
160717 : {
160718 26 : ROSE_ASSERT(this != NULL);
160719 26 : return "SgProgramHeaderStatement";
160720 : }
160721 :
160722 : // DQ (11/26/2005): Support for visitor pattern mechanims
160723 : // (inferior to ROSE traversal mechanism, experimental).
160724 : void
160725 0 : SgProgramHeaderStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
160726 : {
160727 0 : ROSE_ASSERT(this != NULL);
160728 0 : visitor.visit(this);
160729 0 : }
160730 :
160731 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
160732 0 : void SgProgramHeaderStatement::accept (ROSE_VisitorPattern & visitor) {
160733 0 : ROSE_ASSERT(this != NULL);
160734 0 : visitor.visit(this);
160735 0 : }
160736 :
160737 : SgProgramHeaderStatement*
160738 0 : SgProgramHeaderStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
160739 : {
160740 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
160741 : // This function is currently only supported for the AST used the represent Binary executables.
160742 : if (0 /* isSgAsmNode(this) != NULL */)
160743 : {
160744 : // Support for regex specification.
160745 : std::string prefixCode = "REGEX:";
160746 : addNewAttribute(prefixCode + s,a);
160747 : }
160748 : #endif
160749 :
160750 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
160751 0 : return this;
160752 : }
160753 :
160754 : // *** COMMON CODE SECTION ENDS HERE ***
160755 :
160756 :
160757 : // End of memberFunctionString
160758 : // Start of memberFunctionString
160759 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
160760 :
160761 :
160762 : #if 0
160763 : //! Error checking support
160764 : /*! Verifies the following:
160765 : - working getVariant() member function
160766 : - calls base class's error() member function
160767 : Every class has one of these functions.
160768 : */
160769 : bool
160770 : SgProgramHeaderStatement::error()
160771 : {
160772 : // Put error checking here
160773 :
160774 : ROSE_ASSERT (this != NULL);
160775 : if (getVariant() != PROGRAM_HEADER_STMT)
160776 : {
160777 : printf ("Error in SgProgramHeaderStatement::error(): SgProgramHeaderStatement object has a %s variant \n",
160778 : Cxx_GrammarTerminalNames[getVariant()].name);
160779 : // printf ("Error in SgProgramHeaderStatement::error() \n");
160780 : ROSE_ABORT();
160781 : }
160782 :
160783 : ROSE_ASSERT (getVariant() == PROGRAM_HEADER_STMT);
160784 : return SgFunctionDeclaration::error();
160785 : }
160786 : #endif
160787 :
160788 :
160789 :
160790 : // End of memberFunctionString
160791 :
160792 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
160793 :
160794 1169110 : SgProgramHeaderStatement* isSgProgramHeaderStatement ( SgNode* inputDerivedClassPointer )
160795 : {
160796 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
160797 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
160798 : // So to fix this we return NULL directly when the input is NULL and avoid the
160799 : // dynamic_cast in this case. This is likely a performance improvement as well.
160800 : // return dynamic_cast<SgProgramHeaderStatement*>(inputDerivedClassPointer);
160801 : // Milind Chabbi (8/28/2013): isSgProgramHeaderStatement uses table-driven castability instead of c++ default dynamic_cast
160802 : // this improves the running time performance by 10-20%.
160803 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgProgramHeaderStatement*>(inputDerivedClassPointer);
160804 1169110 : return IS_SgProgramHeaderStatement_FAST_MACRO(inputDerivedClassPointer);
160805 : }
160806 :
160807 : // DQ (11/8/2003): Added version of functions taking const pointer
160808 10 : const SgProgramHeaderStatement* isSgProgramHeaderStatement ( const SgNode* inputDerivedClassPointer )
160809 : {
160810 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
160811 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
160812 : // So to fix this we return NULL directly when the input is NULL and avoid the
160813 : // dynamic_cast in this case. This is likely a performance improvement as well.
160814 : // return dynamic_cast<const SgProgramHeaderStatement*>(inputDerivedClassPointer);
160815 : // Milind Chabbi (8/28/2013): isSgProgramHeaderStatement uses table-driven castability instead of c++ default dynamic_cast
160816 : // this improves the running time performance by 10-20%.
160817 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgProgramHeaderStatement*>(inputDerivedClassPointer);
160818 10 : return IS_SgProgramHeaderStatement_FAST_MACRO(inputDerivedClassPointer);
160819 : }
160820 :
160821 :
160822 :
160823 : /* #line 160824 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160824 :
160825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
160826 :
160827 : /**
160828 : \brief Generated destructor
160829 :
160830 : This destructor is automatically generated (by ROSETTA). This destructor
160831 : only frees memory of data members associated with the parts of the current IR node which
160832 : are NOT traversed. Those data members that are part of a traversal can be freed using
160833 : a traversal (calling this destructor on all children in a post-order traversal). Such
160834 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
160835 :
160836 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
160837 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
160838 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
160839 :
160840 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
160841 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
160842 : pointers are not yet implemented to call delete on eash pointer in the container.
160843 : (This could be done by derivation from the STL containers to define containers that
160844 : automatically deleted their members.)
160845 :
160846 : */
160847 2 : SgProgramHeaderStatement::~SgProgramHeaderStatement () {
160848 1 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
160849 :
160850 :
160851 : // case: not a listType for program_statement_explicit
160852 1 : p_program_statement_explicit = false; // non list case
160853 : // case: not a listType for end_numeric_label
160854 1 : p_end_numeric_label = NULL; // non list case
160855 :
160856 : }
160857 :
160858 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
160859 2 : }
160860 :
160861 :
160862 : /* #line 160863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160863 :
160864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
160865 :
160866 : // Generated constructor
160867 0 : SgProgramHeaderStatement::SgProgramHeaderStatement ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
160868 0 : : SgFunctionDeclaration(startOfConstruct, name, type, definition)
160869 : {
160870 : #ifdef DEBUG
160871 : // printf ("In SgProgramHeaderStatement::SgProgramHeaderStatement (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
160872 : #endif
160873 : #if 0
160874 : // debugging information!
160875 : printf ("In SgProgramHeaderStatement::SgProgramHeaderStatement (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
160876 : #endif
160877 :
160878 0 : p_program_statement_explicit = false;
160879 0 : p_end_numeric_label = NULL;
160880 :
160881 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
160882 :
160883 : #if 0
160884 : // DQ (7/30/2014): Call a virtual function.
160885 : std::string s = this->class_name();
160886 : #endif
160887 :
160888 : // Test the variant virtual function
160889 : // assert(PROGRAM_HEADER_STMT == variant());
160890 0 : assert(PROGRAM_HEADER_STMT == this->variant());
160891 0 : ROSE_ASSERT(PROGRAM_HEADER_STMT == (int)(this->variantT()));
160892 0 : post_construction_initialization();
160893 :
160894 : // Test the isSgProgramHeaderStatement() function since it has been problematic
160895 0 : assert(isSgProgramHeaderStatement(this) != NULL);
160896 0 : }
160897 :
160898 : // Generated constructor (all data members)
160899 :
160900 : /* #line 160901 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160901 :
160902 :
160903 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
160904 :
160905 :
160906 : // ********************************************************
160907 : // member functions common across all array grammar objects
160908 : // ********************************************************
160909 :
160910 :
160911 :
160912 : /* #line 160913 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160913 :
160914 :
160915 :
160916 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
160917 :
160918 : // ********************************************************
160919 : // member functions specific to each node in the grammar
160920 : // ********************************************************
160921 :
160922 :
160923 : /* #line 160924 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
160924 :
160925 : // Start of memberFunctionString
160926 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
160927 :
160928 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160929 :
160930 : SgProcedureHeaderStatement::subprogram_kind_enum
160931 27 : SgProcedureHeaderStatement::get_subprogram_kind () const
160932 : {
160933 27 : ROSE_ASSERT (this != NULL);
160934 :
160935 : #if 0
160936 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160937 : // used to trigger marking transformations for the token-based unparsing.
160938 : printf ("SgProcedureHeaderStatement::get_subprogram_kind = %p = %s \n",this,this->class_name().c_str());
160939 : #endif
160940 :
160941 27 : return p_subprogram_kind;
160942 : }
160943 :
160944 : void
160945 412 : SgProcedureHeaderStatement::set_subprogram_kind ( SgProcedureHeaderStatement::subprogram_kind_enum subprogram_kind )
160946 : {
160947 412 : ROSE_ASSERT (this != NULL);
160948 :
160949 : #if 0
160950 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160951 : // used to trigger marking transformations for the token-based unparsing.
160952 : printf ("SgProcedureHeaderStatement::set_subprogram_kind = %p = %s \n",this,this->class_name().c_str());
160953 : #endif
160954 :
160955 412 : set_isModified(true);
160956 :
160957 412 : p_subprogram_kind = subprogram_kind;
160958 412 : }
160959 :
160960 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
160961 :
160962 :
160963 : // End of memberFunctionString
160964 : // Start of memberFunctionString
160965 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
160966 :
160967 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
160968 :
160969 : SgLabelRefExp*
160970 18 : SgProcedureHeaderStatement::get_end_numeric_label () const
160971 : {
160972 18 : ROSE_ASSERT (this != NULL);
160973 :
160974 : #if 0
160975 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160976 : // used to trigger marking transformations for the token-based unparsing.
160977 : printf ("SgProcedureHeaderStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
160978 : #endif
160979 :
160980 18 : return p_end_numeric_label;
160981 : }
160982 :
160983 : void
160984 0 : SgProcedureHeaderStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
160985 : {
160986 0 : ROSE_ASSERT (this != NULL);
160987 :
160988 : #if 0
160989 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
160990 : // used to trigger marking transformations for the token-based unparsing.
160991 : printf ("SgProcedureHeaderStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
160992 : #endif
160993 :
160994 0 : set_isModified(true);
160995 :
160996 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
160997 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
160998 : {
160999 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
161000 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
161001 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
161002 : ROSE_ASSERT(false);
161003 : #endif
161004 : }
161005 : #endif
161006 0 : p_end_numeric_label = end_numeric_label;
161007 0 : }
161008 :
161009 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
161010 :
161011 :
161012 : // End of memberFunctionString
161013 : // Start of memberFunctionString
161014 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
161015 :
161016 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
161017 :
161018 : SgInitializedName*
161019 94 : SgProcedureHeaderStatement::get_result_name () const
161020 : {
161021 94 : ROSE_ASSERT (this != NULL);
161022 :
161023 : #if 0
161024 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
161025 : // used to trigger marking transformations for the token-based unparsing.
161026 : printf ("SgProcedureHeaderStatement::get_result_name = %p = %s \n",this,this->class_name().c_str());
161027 : #endif
161028 :
161029 94 : return p_result_name;
161030 : }
161031 :
161032 : void
161033 13 : SgProcedureHeaderStatement::set_result_name ( SgInitializedName* result_name )
161034 : {
161035 13 : ROSE_ASSERT (this != NULL);
161036 :
161037 : #if 0
161038 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
161039 : // used to trigger marking transformations for the token-based unparsing.
161040 : printf ("SgProcedureHeaderStatement::set_result_name = %p = %s \n",this,this->class_name().c_str());
161041 : #endif
161042 :
161043 13 : set_isModified(true);
161044 :
161045 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
161046 : if (p_result_name != NULL && result_name != NULL && p_result_name != result_name)
161047 : {
161048 : printf ("Warning: result_name = %p overwriting valid pointer p_result_name = %p \n",result_name,p_result_name);
161049 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
161050 : printf ("Error fails assertion (p_result_name != NULL && result_name != NULL && p_result_name != result_name) is false\n");
161051 : ROSE_ASSERT(false);
161052 : #endif
161053 : }
161054 : #endif
161055 13 : p_result_name = result_name;
161056 13 : }
161057 :
161058 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
161059 :
161060 :
161061 : // End of memberFunctionString
161062 : // Start of memberFunctionString
161063 : /* #line 17920 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
161064 :
161065 :
161066 : void
161067 402 : SgProcedureHeaderStatement::post_construction_initialization()
161068 : {
161069 402 : }
161070 :
161071 : SgName
161072 840 : SgProcedureHeaderStatement::get_mangled_name() const
161073 : {
161074 : // DQ (8/23/2007): Use the get_mangled_name() member function from the base class.
161075 : // printf ("SgProcedureHeaderStatement::get_mangled_name() not implemented \n");
161076 : // ROSE_ASSERT(false);
161077 840 : return SgFunctionDeclaration::get_mangled_name();
161078 : }
161079 :
161080 : bool
161081 56 : SgProcedureHeaderStatement::isFunction() const
161082 : {
161083 56 : bool result = false;
161084 56 : if (p_subprogram_kind == e_function_subprogram_kind)
161085 11 : result = true;
161086 :
161087 56 : return result;
161088 : }
161089 :
161090 : bool
161091 30 : SgProcedureHeaderStatement::isSubroutine() const
161092 : {
161093 30 : bool result = false;
161094 30 : if (p_subprogram_kind == e_subroutine_subprogram_kind)
161095 30 : result = true;
161096 :
161097 30 : return result;
161098 : }
161099 :
161100 : bool
161101 18 : SgProcedureHeaderStatement::isBlockData() const
161102 : {
161103 18 : bool result = false;
161104 18 : if (p_subprogram_kind == e_block_data_subprogram_kind)
161105 0 : result = true;
161106 :
161107 18 : return result;
161108 : }
161109 :
161110 :
161111 :
161112 : // End of memberFunctionString
161113 : // Start of memberFunctionString
161114 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
161115 :
161116 : // *** COMMON CODE SECTION BEGINS HERE ***
161117 :
161118 : #if 0
161119 : int
161120 : SgProcedureHeaderStatement::getVariant() const
161121 : {
161122 : // This function is used in ROSE while "variant()" is used in SAGE
161123 : assert(this != NULL);
161124 : return variant();
161125 : }
161126 : #endif
161127 :
161128 : // This function is used in ROSE in treeTraversal code
161129 : // eventually replaces getVariant() and variant()
161130 : // though after variant() has been removed for a while we will
161131 : // want to change the name of variantT() back to variant()
161132 : // (since the "T" was ment to stand for temporary).
161133 : // When this happens the variantT() will be depricated.
161134 : VariantT
161135 55528 : SgProcedureHeaderStatement::variantT() const
161136 : {
161137 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
161138 55528 : ROSE_ASSERT(this != NULL);
161139 55528 : return V_SgProcedureHeaderStatement;
161140 : }
161141 :
161142 : #if 0
161143 : int
161144 : SgProcedureHeaderStatement::variant() const
161145 : {
161146 : // This function is used in SAGE
161147 : ROSE_ASSERT(this != NULL);
161148 : return PROCEDURE_HEADER_STMT;
161149 : }
161150 : #endif
161151 :
161152 : ROSE_DLL_API const char*
161153 26 : SgProcedureHeaderStatement::sage_class_name() const
161154 : {
161155 26 : ROSE_ASSERT(this != NULL);
161156 26 : return "SgProcedureHeaderStatement";
161157 : }
161158 :
161159 : std::string
161160 402 : SgProcedureHeaderStatement::class_name() const
161161 : {
161162 402 : ROSE_ASSERT(this != NULL);
161163 402 : return "SgProcedureHeaderStatement";
161164 : }
161165 :
161166 : // DQ (11/26/2005): Support for visitor pattern mechanims
161167 : // (inferior to ROSE traversal mechanism, experimental).
161168 : void
161169 0 : SgProcedureHeaderStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
161170 : {
161171 0 : ROSE_ASSERT(this != NULL);
161172 0 : visitor.visit(this);
161173 0 : }
161174 :
161175 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
161176 0 : void SgProcedureHeaderStatement::accept (ROSE_VisitorPattern & visitor) {
161177 0 : ROSE_ASSERT(this != NULL);
161178 0 : visitor.visit(this);
161179 0 : }
161180 :
161181 : SgProcedureHeaderStatement*
161182 0 : SgProcedureHeaderStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
161183 : {
161184 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
161185 : // This function is currently only supported for the AST used the represent Binary executables.
161186 : if (0 /* isSgAsmNode(this) != NULL */)
161187 : {
161188 : // Support for regex specification.
161189 : std::string prefixCode = "REGEX:";
161190 : addNewAttribute(prefixCode + s,a);
161191 : }
161192 : #endif
161193 :
161194 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
161195 0 : return this;
161196 : }
161197 :
161198 : // *** COMMON CODE SECTION ENDS HERE ***
161199 :
161200 :
161201 : // End of memberFunctionString
161202 : // Start of memberFunctionString
161203 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
161204 :
161205 :
161206 : #if 0
161207 : //! Error checking support
161208 : /*! Verifies the following:
161209 : - working getVariant() member function
161210 : - calls base class's error() member function
161211 : Every class has one of these functions.
161212 : */
161213 : bool
161214 : SgProcedureHeaderStatement::error()
161215 : {
161216 : // Put error checking here
161217 :
161218 : ROSE_ASSERT (this != NULL);
161219 : if (getVariant() != PROCEDURE_HEADER_STMT)
161220 : {
161221 : printf ("Error in SgProcedureHeaderStatement::error(): SgProcedureHeaderStatement object has a %s variant \n",
161222 : Cxx_GrammarTerminalNames[getVariant()].name);
161223 : // printf ("Error in SgProcedureHeaderStatement::error() \n");
161224 : ROSE_ABORT();
161225 : }
161226 :
161227 : ROSE_ASSERT (getVariant() == PROCEDURE_HEADER_STMT);
161228 : return SgFunctionDeclaration::error();
161229 : }
161230 : #endif
161231 :
161232 :
161233 :
161234 : // End of memberFunctionString
161235 :
161236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
161237 :
161238 1169280 : SgProcedureHeaderStatement* isSgProcedureHeaderStatement ( SgNode* inputDerivedClassPointer )
161239 : {
161240 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
161241 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
161242 : // So to fix this we return NULL directly when the input is NULL and avoid the
161243 : // dynamic_cast in this case. This is likely a performance improvement as well.
161244 : // return dynamic_cast<SgProcedureHeaderStatement*>(inputDerivedClassPointer);
161245 : // Milind Chabbi (8/28/2013): isSgProcedureHeaderStatement uses table-driven castability instead of c++ default dynamic_cast
161246 : // this improves the running time performance by 10-20%.
161247 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgProcedureHeaderStatement*>(inputDerivedClassPointer);
161248 1169280 : return IS_SgProcedureHeaderStatement_FAST_MACRO(inputDerivedClassPointer);
161249 : }
161250 :
161251 : // DQ (11/8/2003): Added version of functions taking const pointer
161252 0 : const SgProcedureHeaderStatement* isSgProcedureHeaderStatement ( const SgNode* inputDerivedClassPointer )
161253 : {
161254 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
161255 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
161256 : // So to fix this we return NULL directly when the input is NULL and avoid the
161257 : // dynamic_cast in this case. This is likely a performance improvement as well.
161258 : // return dynamic_cast<const SgProcedureHeaderStatement*>(inputDerivedClassPointer);
161259 : // Milind Chabbi (8/28/2013): isSgProcedureHeaderStatement uses table-driven castability instead of c++ default dynamic_cast
161260 : // this improves the running time performance by 10-20%.
161261 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgProcedureHeaderStatement*>(inputDerivedClassPointer);
161262 0 : return IS_SgProcedureHeaderStatement_FAST_MACRO(inputDerivedClassPointer);
161263 : }
161264 :
161265 :
161266 :
161267 : /* #line 161268 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161268 :
161269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
161270 :
161271 : /**
161272 : \brief Generated destructor
161273 :
161274 : This destructor is automatically generated (by ROSETTA). This destructor
161275 : only frees memory of data members associated with the parts of the current IR node which
161276 : are NOT traversed. Those data members that are part of a traversal can be freed using
161277 : a traversal (calling this destructor on all children in a post-order traversal). Such
161278 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
161279 :
161280 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
161281 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
161282 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
161283 :
161284 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
161285 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
161286 : pointers are not yet implemented to call delete on eash pointer in the container.
161287 : (This could be done by derivation from the STL containers to define containers that
161288 : automatically deleted their members.)
161289 :
161290 : */
161291 0 : SgProcedureHeaderStatement::~SgProcedureHeaderStatement () {
161292 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
161293 :
161294 :
161295 : // case: not a listType for subprogram_kind
161296 0 : p_subprogram_kind = SgProcedureHeaderStatement::e_unknown_kind; // non list case
161297 : // case: not a listType for end_numeric_label
161298 0 : p_end_numeric_label = NULL; // non list case
161299 : // case: not a listType for result_name
161300 0 : p_result_name = NULL; // non list case
161301 :
161302 : }
161303 :
161304 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
161305 0 : }
161306 :
161307 :
161308 : /* #line 161309 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161309 :
161310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
161311 :
161312 : // Generated constructor
161313 0 : SgProcedureHeaderStatement::SgProcedureHeaderStatement ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
161314 0 : : SgFunctionDeclaration(startOfConstruct, name, type, definition)
161315 : {
161316 : #ifdef DEBUG
161317 : // printf ("In SgProcedureHeaderStatement::SgProcedureHeaderStatement (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
161318 : #endif
161319 : #if 0
161320 : // debugging information!
161321 : printf ("In SgProcedureHeaderStatement::SgProcedureHeaderStatement (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
161322 : #endif
161323 :
161324 0 : p_subprogram_kind = SgProcedureHeaderStatement::e_unknown_kind;
161325 0 : p_end_numeric_label = NULL;
161326 0 : p_result_name = NULL;
161327 :
161328 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
161329 :
161330 : #if 0
161331 : // DQ (7/30/2014): Call a virtual function.
161332 : std::string s = this->class_name();
161333 : #endif
161334 :
161335 : // Test the variant virtual function
161336 : // assert(PROCEDURE_HEADER_STMT == variant());
161337 0 : assert(PROCEDURE_HEADER_STMT == this->variant());
161338 0 : ROSE_ASSERT(PROCEDURE_HEADER_STMT == (int)(this->variantT()));
161339 0 : post_construction_initialization();
161340 :
161341 : // Test the isSgProcedureHeaderStatement() function since it has been problematic
161342 0 : assert(isSgProcedureHeaderStatement(this) != NULL);
161343 0 : }
161344 :
161345 : // Generated constructor (all data members)
161346 :
161347 : /* #line 161348 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161348 :
161349 :
161350 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
161351 :
161352 :
161353 : // ********************************************************
161354 : // member functions common across all array grammar objects
161355 : // ********************************************************
161356 :
161357 :
161358 :
161359 : /* #line 161360 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161360 :
161361 :
161362 :
161363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
161364 :
161365 : // ********************************************************
161366 : // member functions specific to each node in the grammar
161367 : // ********************************************************
161368 :
161369 :
161370 : /* #line 161371 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161371 :
161372 : // Start of memberFunctionString
161373 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
161374 :
161375 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
161376 :
161377 : SgInitializedName*
161378 0 : SgEntryStatement::get_result_name () const
161379 : {
161380 0 : ROSE_ASSERT (this != NULL);
161381 :
161382 : #if 0
161383 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
161384 : // used to trigger marking transformations for the token-based unparsing.
161385 : printf ("SgEntryStatement::get_result_name = %p = %s \n",this,this->class_name().c_str());
161386 : #endif
161387 :
161388 0 : return p_result_name;
161389 : }
161390 :
161391 : void
161392 0 : SgEntryStatement::set_result_name ( SgInitializedName* result_name )
161393 : {
161394 0 : ROSE_ASSERT (this != NULL);
161395 :
161396 : #if 0
161397 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
161398 : // used to trigger marking transformations for the token-based unparsing.
161399 : printf ("SgEntryStatement::set_result_name = %p = %s \n",this,this->class_name().c_str());
161400 : #endif
161401 :
161402 0 : set_isModified(true);
161403 :
161404 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
161405 : if (p_result_name != NULL && result_name != NULL && p_result_name != result_name)
161406 : {
161407 : printf ("Warning: result_name = %p overwriting valid pointer p_result_name = %p \n",result_name,p_result_name);
161408 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
161409 : printf ("Error fails assertion (p_result_name != NULL && result_name != NULL && p_result_name != result_name) is false\n");
161410 : ROSE_ASSERT(false);
161411 : #endif
161412 : }
161413 : #endif
161414 0 : p_result_name = result_name;
161415 0 : }
161416 :
161417 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
161418 :
161419 :
161420 : // End of memberFunctionString
161421 : // Start of memberFunctionString
161422 : /* #line 17969 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
161423 :
161424 :
161425 : void
161426 0 : SgEntryStatement::post_construction_initialization()
161427 : {
161428 0 : }
161429 :
161430 : SgName
161431 0 : SgEntryStatement::get_mangled_name() const
161432 : {
161433 0 : return SgFunctionDeclaration::get_mangled_name();
161434 : }
161435 :
161436 :
161437 :
161438 : // End of memberFunctionString
161439 : // Start of memberFunctionString
161440 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
161441 :
161442 : // *** COMMON CODE SECTION BEGINS HERE ***
161443 :
161444 : #if 0
161445 : int
161446 : SgEntryStatement::getVariant() const
161447 : {
161448 : // This function is used in ROSE while "variant()" is used in SAGE
161449 : assert(this != NULL);
161450 : return variant();
161451 : }
161452 : #endif
161453 :
161454 : // This function is used in ROSE in treeTraversal code
161455 : // eventually replaces getVariant() and variant()
161456 : // though after variant() has been removed for a while we will
161457 : // want to change the name of variantT() back to variant()
161458 : // (since the "T" was ment to stand for temporary).
161459 : // When this happens the variantT() will be depricated.
161460 : VariantT
161461 0 : SgEntryStatement::variantT() const
161462 : {
161463 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
161464 0 : ROSE_ASSERT(this != NULL);
161465 0 : return V_SgEntryStatement;
161466 : }
161467 :
161468 : #if 0
161469 : int
161470 : SgEntryStatement::variant() const
161471 : {
161472 : // This function is used in SAGE
161473 : ROSE_ASSERT(this != NULL);
161474 : return ENTRY_STMT;
161475 : }
161476 : #endif
161477 :
161478 : ROSE_DLL_API const char*
161479 0 : SgEntryStatement::sage_class_name() const
161480 : {
161481 0 : ROSE_ASSERT(this != NULL);
161482 0 : return "SgEntryStatement";
161483 : }
161484 :
161485 : std::string
161486 0 : SgEntryStatement::class_name() const
161487 : {
161488 0 : ROSE_ASSERT(this != NULL);
161489 0 : return "SgEntryStatement";
161490 : }
161491 :
161492 : // DQ (11/26/2005): Support for visitor pattern mechanims
161493 : // (inferior to ROSE traversal mechanism, experimental).
161494 : void
161495 0 : SgEntryStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
161496 : {
161497 0 : ROSE_ASSERT(this != NULL);
161498 0 : visitor.visit(this);
161499 0 : }
161500 :
161501 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
161502 0 : void SgEntryStatement::accept (ROSE_VisitorPattern & visitor) {
161503 0 : ROSE_ASSERT(this != NULL);
161504 0 : visitor.visit(this);
161505 0 : }
161506 :
161507 : SgEntryStatement*
161508 0 : SgEntryStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
161509 : {
161510 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
161511 : // This function is currently only supported for the AST used the represent Binary executables.
161512 : if (0 /* isSgAsmNode(this) != NULL */)
161513 : {
161514 : // Support for regex specification.
161515 : std::string prefixCode = "REGEX:";
161516 : addNewAttribute(prefixCode + s,a);
161517 : }
161518 : #endif
161519 :
161520 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
161521 0 : return this;
161522 : }
161523 :
161524 : // *** COMMON CODE SECTION ENDS HERE ***
161525 :
161526 :
161527 : // End of memberFunctionString
161528 : // Start of memberFunctionString
161529 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
161530 :
161531 :
161532 : #if 0
161533 : //! Error checking support
161534 : /*! Verifies the following:
161535 : - working getVariant() member function
161536 : - calls base class's error() member function
161537 : Every class has one of these functions.
161538 : */
161539 : bool
161540 : SgEntryStatement::error()
161541 : {
161542 : // Put error checking here
161543 :
161544 : ROSE_ASSERT (this != NULL);
161545 : if (getVariant() != ENTRY_STMT)
161546 : {
161547 : printf ("Error in SgEntryStatement::error(): SgEntryStatement object has a %s variant \n",
161548 : Cxx_GrammarTerminalNames[getVariant()].name);
161549 : // printf ("Error in SgEntryStatement::error() \n");
161550 : ROSE_ABORT();
161551 : }
161552 :
161553 : ROSE_ASSERT (getVariant() == ENTRY_STMT);
161554 : return SgFunctionDeclaration::error();
161555 : }
161556 : #endif
161557 :
161558 :
161559 :
161560 : // End of memberFunctionString
161561 :
161562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
161563 :
161564 0 : SgEntryStatement* isSgEntryStatement ( SgNode* inputDerivedClassPointer )
161565 : {
161566 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
161567 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
161568 : // So to fix this we return NULL directly when the input is NULL and avoid the
161569 : // dynamic_cast in this case. This is likely a performance improvement as well.
161570 : // return dynamic_cast<SgEntryStatement*>(inputDerivedClassPointer);
161571 : // Milind Chabbi (8/28/2013): isSgEntryStatement uses table-driven castability instead of c++ default dynamic_cast
161572 : // this improves the running time performance by 10-20%.
161573 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEntryStatement*>(inputDerivedClassPointer);
161574 0 : return IS_SgEntryStatement_FAST_MACRO(inputDerivedClassPointer);
161575 : }
161576 :
161577 : // DQ (11/8/2003): Added version of functions taking const pointer
161578 0 : const SgEntryStatement* isSgEntryStatement ( const SgNode* inputDerivedClassPointer )
161579 : {
161580 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
161581 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
161582 : // So to fix this we return NULL directly when the input is NULL and avoid the
161583 : // dynamic_cast in this case. This is likely a performance improvement as well.
161584 : // return dynamic_cast<const SgEntryStatement*>(inputDerivedClassPointer);
161585 : // Milind Chabbi (8/28/2013): isSgEntryStatement uses table-driven castability instead of c++ default dynamic_cast
161586 : // this improves the running time performance by 10-20%.
161587 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEntryStatement*>(inputDerivedClassPointer);
161588 0 : return IS_SgEntryStatement_FAST_MACRO(inputDerivedClassPointer);
161589 : }
161590 :
161591 :
161592 :
161593 : /* #line 161594 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161594 :
161595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
161596 :
161597 : /**
161598 : \brief Generated destructor
161599 :
161600 : This destructor is automatically generated (by ROSETTA). This destructor
161601 : only frees memory of data members associated with the parts of the current IR node which
161602 : are NOT traversed. Those data members that are part of a traversal can be freed using
161603 : a traversal (calling this destructor on all children in a post-order traversal). Such
161604 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
161605 :
161606 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
161607 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
161608 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
161609 :
161610 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
161611 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
161612 : pointers are not yet implemented to call delete on eash pointer in the container.
161613 : (This could be done by derivation from the STL containers to define containers that
161614 : automatically deleted their members.)
161615 :
161616 : */
161617 0 : SgEntryStatement::~SgEntryStatement () {
161618 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
161619 :
161620 :
161621 : // case: not a listType for result_name
161622 0 : p_result_name = NULL; // non list case
161623 :
161624 : }
161625 :
161626 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
161627 0 : }
161628 :
161629 :
161630 : /* #line 161631 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161631 :
161632 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
161633 :
161634 : // Generated constructor
161635 0 : SgEntryStatement::SgEntryStatement ( Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition )
161636 0 : : SgFunctionDeclaration(startOfConstruct, name, type, definition)
161637 : {
161638 : #ifdef DEBUG
161639 : // printf ("In SgEntryStatement::SgEntryStatement (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition) sage_class_name() = %s \n",sage_class_name());
161640 : #endif
161641 : #if 0
161642 : // debugging information!
161643 : printf ("In SgEntryStatement::SgEntryStatement (Sg_File_Info* startOfConstruct, SgName name, SgFunctionType* type, SgFunctionDefinition* definition): this = %p = %s \n",this,this->class_name().c_str());
161644 : #endif
161645 :
161646 0 : p_result_name = NULL;
161647 :
161648 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
161649 :
161650 : #if 0
161651 : // DQ (7/30/2014): Call a virtual function.
161652 : std::string s = this->class_name();
161653 : #endif
161654 :
161655 : // Test the variant virtual function
161656 : // assert(ENTRY_STMT == variant());
161657 0 : assert(ENTRY_STMT == this->variant());
161658 0 : ROSE_ASSERT(ENTRY_STMT == (int)(this->variantT()));
161659 0 : post_construction_initialization();
161660 :
161661 : // Test the isSgEntryStatement() function since it has been problematic
161662 0 : assert(isSgEntryStatement(this) != NULL);
161663 0 : }
161664 :
161665 : // Generated constructor (all data members)
161666 :
161667 : /* #line 161668 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161668 :
161669 :
161670 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
161671 :
161672 :
161673 : // ********************************************************
161674 : // member functions common across all array grammar objects
161675 : // ********************************************************
161676 :
161677 :
161678 :
161679 : /* #line 161680 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161680 :
161681 :
161682 :
161683 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
161684 :
161685 : // ********************************************************
161686 : // member functions specific to each node in the grammar
161687 : // ********************************************************
161688 :
161689 :
161690 : /* #line 161691 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161691 :
161692 : // Start of memberFunctionString
161693 : /* #line 18258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
161694 :
161695 :
161696 : void
161697 0 : SgContainsStatement::post_construction_initialization()
161698 : {
161699 0 : }
161700 :
161701 : SgName
161702 0 : SgContainsStatement::get_mangled_name() const
161703 : {
161704 0 : return SgName("_contains_");
161705 : }
161706 :
161707 :
161708 :
161709 : // End of memberFunctionString
161710 : // Start of memberFunctionString
161711 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
161712 :
161713 : // *** COMMON CODE SECTION BEGINS HERE ***
161714 :
161715 : #if 0
161716 : int
161717 : SgContainsStatement::getVariant() const
161718 : {
161719 : // This function is used in ROSE while "variant()" is used in SAGE
161720 : assert(this != NULL);
161721 : return variant();
161722 : }
161723 : #endif
161724 :
161725 : // This function is used in ROSE in treeTraversal code
161726 : // eventually replaces getVariant() and variant()
161727 : // though after variant() has been removed for a while we will
161728 : // want to change the name of variantT() back to variant()
161729 : // (since the "T" was ment to stand for temporary).
161730 : // When this happens the variantT() will be depricated.
161731 : VariantT
161732 0 : SgContainsStatement::variantT() const
161733 : {
161734 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
161735 0 : ROSE_ASSERT(this != NULL);
161736 0 : return V_SgContainsStatement;
161737 : }
161738 :
161739 : #if 0
161740 : int
161741 : SgContainsStatement::variant() const
161742 : {
161743 : // This function is used in SAGE
161744 : ROSE_ASSERT(this != NULL);
161745 : return TEMP_Contains_Statement;
161746 : }
161747 : #endif
161748 :
161749 : ROSE_DLL_API const char*
161750 0 : SgContainsStatement::sage_class_name() const
161751 : {
161752 0 : ROSE_ASSERT(this != NULL);
161753 0 : return "SgContainsStatement";
161754 : }
161755 :
161756 : std::string
161757 0 : SgContainsStatement::class_name() const
161758 : {
161759 0 : ROSE_ASSERT(this != NULL);
161760 0 : return "SgContainsStatement";
161761 : }
161762 :
161763 : // DQ (11/26/2005): Support for visitor pattern mechanims
161764 : // (inferior to ROSE traversal mechanism, experimental).
161765 : void
161766 0 : SgContainsStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
161767 : {
161768 0 : ROSE_ASSERT(this != NULL);
161769 0 : visitor.visit(this);
161770 0 : }
161771 :
161772 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
161773 0 : void SgContainsStatement::accept (ROSE_VisitorPattern & visitor) {
161774 0 : ROSE_ASSERT(this != NULL);
161775 0 : visitor.visit(this);
161776 0 : }
161777 :
161778 : SgContainsStatement*
161779 0 : SgContainsStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
161780 : {
161781 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
161782 : // This function is currently only supported for the AST used the represent Binary executables.
161783 : if (0 /* isSgAsmNode(this) != NULL */)
161784 : {
161785 : // Support for regex specification.
161786 : std::string prefixCode = "REGEX:";
161787 : addNewAttribute(prefixCode + s,a);
161788 : }
161789 : #endif
161790 :
161791 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
161792 0 : return this;
161793 : }
161794 :
161795 : // *** COMMON CODE SECTION ENDS HERE ***
161796 :
161797 :
161798 : // End of memberFunctionString
161799 : // Start of memberFunctionString
161800 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
161801 :
161802 :
161803 : #if 0
161804 : //! Error checking support
161805 : /*! Verifies the following:
161806 : - working getVariant() member function
161807 : - calls base class's error() member function
161808 : Every class has one of these functions.
161809 : */
161810 : bool
161811 : SgContainsStatement::error()
161812 : {
161813 : // Put error checking here
161814 :
161815 : ROSE_ASSERT (this != NULL);
161816 : if (getVariant() != TEMP_Contains_Statement)
161817 : {
161818 : printf ("Error in SgContainsStatement::error(): SgContainsStatement object has a %s variant \n",
161819 : Cxx_GrammarTerminalNames[getVariant()].name);
161820 : // printf ("Error in SgContainsStatement::error() \n");
161821 : ROSE_ABORT();
161822 : }
161823 :
161824 : ROSE_ASSERT (getVariant() == TEMP_Contains_Statement);
161825 : return SgDeclarationStatement::error();
161826 : }
161827 : #endif
161828 :
161829 :
161830 :
161831 : // End of memberFunctionString
161832 :
161833 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
161834 :
161835 0 : SgContainsStatement* isSgContainsStatement ( SgNode* inputDerivedClassPointer )
161836 : {
161837 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
161838 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
161839 : // So to fix this we return NULL directly when the input is NULL and avoid the
161840 : // dynamic_cast in this case. This is likely a performance improvement as well.
161841 : // return dynamic_cast<SgContainsStatement*>(inputDerivedClassPointer);
161842 : // Milind Chabbi (8/28/2013): isSgContainsStatement uses table-driven castability instead of c++ default dynamic_cast
161843 : // this improves the running time performance by 10-20%.
161844 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgContainsStatement*>(inputDerivedClassPointer);
161845 0 : return IS_SgContainsStatement_FAST_MACRO(inputDerivedClassPointer);
161846 : }
161847 :
161848 : // DQ (11/8/2003): Added version of functions taking const pointer
161849 0 : const SgContainsStatement* isSgContainsStatement ( const SgNode* inputDerivedClassPointer )
161850 : {
161851 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
161852 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
161853 : // So to fix this we return NULL directly when the input is NULL and avoid the
161854 : // dynamic_cast in this case. This is likely a performance improvement as well.
161855 : // return dynamic_cast<const SgContainsStatement*>(inputDerivedClassPointer);
161856 : // Milind Chabbi (8/28/2013): isSgContainsStatement uses table-driven castability instead of c++ default dynamic_cast
161857 : // this improves the running time performance by 10-20%.
161858 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgContainsStatement*>(inputDerivedClassPointer);
161859 0 : return IS_SgContainsStatement_FAST_MACRO(inputDerivedClassPointer);
161860 : }
161861 :
161862 :
161863 :
161864 : /* #line 161865 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161865 :
161866 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
161867 :
161868 : /**
161869 : \brief Generated destructor
161870 :
161871 : This destructor is automatically generated (by ROSETTA). This destructor
161872 : only frees memory of data members associated with the parts of the current IR node which
161873 : are NOT traversed. Those data members that are part of a traversal can be freed using
161874 : a traversal (calling this destructor on all children in a post-order traversal). Such
161875 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
161876 :
161877 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
161878 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
161879 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
161880 :
161881 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
161882 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
161883 : pointers are not yet implemented to call delete on eash pointer in the container.
161884 : (This could be done by derivation from the STL containers to define containers that
161885 : automatically deleted their members.)
161886 :
161887 : */
161888 0 : SgContainsStatement::~SgContainsStatement () {
161889 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
161890 :
161891 :
161892 :
161893 : }
161894 :
161895 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
161896 0 : }
161897 :
161898 :
161899 : /* #line 161900 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161900 :
161901 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
161902 :
161903 : // Generated constructor
161904 0 : SgContainsStatement::SgContainsStatement ( Sg_File_Info* startOfConstruct )
161905 0 : : SgDeclarationStatement(startOfConstruct)
161906 : {
161907 : #ifdef DEBUG
161908 : // printf ("In SgContainsStatement::SgContainsStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
161909 : #endif
161910 : #if 0
161911 : // debugging information!
161912 : printf ("In SgContainsStatement::SgContainsStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
161913 : #endif
161914 :
161915 :
161916 :
161917 : #if 0
161918 : // DQ (7/30/2014): Call a virtual function.
161919 : std::string s = this->class_name();
161920 : #endif
161921 :
161922 : // Test the variant virtual function
161923 : // assert(TEMP_Contains_Statement == variant());
161924 0 : assert(TEMP_Contains_Statement == this->variant());
161925 0 : ROSE_ASSERT(TEMP_Contains_Statement == (int)(this->variantT()));
161926 0 : post_construction_initialization();
161927 :
161928 : // Test the isSgContainsStatement() function since it has been problematic
161929 0 : assert(isSgContainsStatement(this) != NULL);
161930 0 : }
161931 :
161932 : // Generated constructor (all data members)
161933 :
161934 : /* #line 161935 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161935 :
161936 :
161937 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
161938 :
161939 :
161940 : // ********************************************************
161941 : // member functions common across all array grammar objects
161942 : // ********************************************************
161943 :
161944 :
161945 :
161946 : /* #line 161947 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161947 :
161948 :
161949 :
161950 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
161951 :
161952 : // ********************************************************
161953 : // member functions specific to each node in the grammar
161954 : // ********************************************************
161955 :
161956 :
161957 : /* #line 161958 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
161958 :
161959 : // Start of memberFunctionString
161960 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
161961 :
161962 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
161963 :
161964 : std::string
161965 0 : SgC_PreprocessorDirectiveStatement::get_directiveString () const
161966 : {
161967 0 : ROSE_ASSERT (this != NULL);
161968 :
161969 : #if 0
161970 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
161971 : // used to trigger marking transformations for the token-based unparsing.
161972 : printf ("SgC_PreprocessorDirectiveStatement::get_directiveString = %p = %s \n",this,this->class_name().c_str());
161973 : #endif
161974 :
161975 0 : return p_directiveString;
161976 : }
161977 :
161978 : void
161979 0 : SgC_PreprocessorDirectiveStatement::set_directiveString ( std::string directiveString )
161980 : {
161981 0 : ROSE_ASSERT (this != NULL);
161982 :
161983 : #if 0
161984 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
161985 : // used to trigger marking transformations for the token-based unparsing.
161986 : printf ("SgC_PreprocessorDirectiveStatement::set_directiveString = %p = %s \n",this,this->class_name().c_str());
161987 : #endif
161988 :
161989 0 : set_isModified(true);
161990 :
161991 0 : p_directiveString = directiveString;
161992 0 : }
161993 :
161994 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
161995 :
161996 :
161997 : // End of memberFunctionString
161998 : // Start of memberFunctionString
161999 : /* #line 18950 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
162000 :
162001 :
162002 : void
162003 0 : SgC_PreprocessorDirectiveStatement::post_construction_initialization()
162004 : {
162005 0 : }
162006 :
162007 : // DQ (11/29/2008): Added for uniform support of mangled names
162008 0 : SgName SgC_PreprocessorDirectiveStatement::get_mangled_name() const
162009 : {
162010 0 : return "__c_language_preprocessor_directive__";
162011 : }
162012 :
162013 :
162014 :
162015 : // End of memberFunctionString
162016 : // Start of memberFunctionString
162017 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
162018 :
162019 : // *** COMMON CODE SECTION BEGINS HERE ***
162020 :
162021 : #if 0
162022 : int
162023 : SgC_PreprocessorDirectiveStatement::getVariant() const
162024 : {
162025 : // This function is used in ROSE while "variant()" is used in SAGE
162026 : assert(this != NULL);
162027 : return variant();
162028 : }
162029 : #endif
162030 :
162031 : // This function is used in ROSE in treeTraversal code
162032 : // eventually replaces getVariant() and variant()
162033 : // though after variant() has been removed for a while we will
162034 : // want to change the name of variantT() back to variant()
162035 : // (since the "T" was ment to stand for temporary).
162036 : // When this happens the variantT() will be depricated.
162037 : VariantT
162038 0 : SgC_PreprocessorDirectiveStatement::variantT() const
162039 : {
162040 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
162041 0 : ROSE_ASSERT(this != NULL);
162042 0 : return V_SgC_PreprocessorDirectiveStatement;
162043 : }
162044 :
162045 : #if 0
162046 : int
162047 : SgC_PreprocessorDirectiveStatement::variant() const
162048 : {
162049 : // This function is used in SAGE
162050 : ROSE_ASSERT(this != NULL);
162051 : return CPP_DIRECTIVE_STMT;
162052 : }
162053 : #endif
162054 :
162055 : ROSE_DLL_API const char*
162056 0 : SgC_PreprocessorDirectiveStatement::sage_class_name() const
162057 : {
162058 0 : ROSE_ASSERT(this != NULL);
162059 0 : return "SgC_PreprocessorDirectiveStatement";
162060 : }
162061 :
162062 : std::string
162063 0 : SgC_PreprocessorDirectiveStatement::class_name() const
162064 : {
162065 0 : ROSE_ASSERT(this != NULL);
162066 0 : return "SgC_PreprocessorDirectiveStatement";
162067 : }
162068 :
162069 : // DQ (11/26/2005): Support for visitor pattern mechanims
162070 : // (inferior to ROSE traversal mechanism, experimental).
162071 : void
162072 0 : SgC_PreprocessorDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
162073 : {
162074 0 : ROSE_ASSERT(this != NULL);
162075 0 : visitor.visit(this);
162076 0 : }
162077 :
162078 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
162079 0 : void SgC_PreprocessorDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
162080 0 : ROSE_ASSERT(this != NULL);
162081 0 : visitor.visit(this);
162082 0 : }
162083 :
162084 : SgC_PreprocessorDirectiveStatement*
162085 0 : SgC_PreprocessorDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
162086 : {
162087 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
162088 : // This function is currently only supported for the AST used the represent Binary executables.
162089 : if (0 /* isSgAsmNode(this) != NULL */)
162090 : {
162091 : // Support for regex specification.
162092 : std::string prefixCode = "REGEX:";
162093 : addNewAttribute(prefixCode + s,a);
162094 : }
162095 : #endif
162096 :
162097 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
162098 0 : return this;
162099 : }
162100 :
162101 : // *** COMMON CODE SECTION ENDS HERE ***
162102 :
162103 :
162104 : // End of memberFunctionString
162105 : // Start of memberFunctionString
162106 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
162107 :
162108 :
162109 : #if 0
162110 : //! Error checking support
162111 : /*! Verifies the following:
162112 : - working getVariant() member function
162113 : - calls base class's error() member function
162114 : Every class has one of these functions.
162115 : */
162116 : bool
162117 : SgC_PreprocessorDirectiveStatement::error()
162118 : {
162119 : // Put error checking here
162120 :
162121 : ROSE_ASSERT (this != NULL);
162122 : if (getVariant() != CPP_DIRECTIVE_STMT)
162123 : {
162124 : printf ("Error in SgC_PreprocessorDirectiveStatement::error(): SgC_PreprocessorDirectiveStatement object has a %s variant \n",
162125 : Cxx_GrammarTerminalNames[getVariant()].name);
162126 : // printf ("Error in SgC_PreprocessorDirectiveStatement::error() \n");
162127 : ROSE_ABORT();
162128 : }
162129 :
162130 : ROSE_ASSERT (getVariant() == CPP_DIRECTIVE_STMT);
162131 : return SgDeclarationStatement::error();
162132 : }
162133 : #endif
162134 :
162135 :
162136 :
162137 : // End of memberFunctionString
162138 :
162139 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
162140 :
162141 997965 : SgC_PreprocessorDirectiveStatement* isSgC_PreprocessorDirectiveStatement ( SgNode* inputDerivedClassPointer )
162142 : {
162143 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
162144 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
162145 : // So to fix this we return NULL directly when the input is NULL and avoid the
162146 : // dynamic_cast in this case. This is likely a performance improvement as well.
162147 : // return dynamic_cast<SgC_PreprocessorDirectiveStatement*>(inputDerivedClassPointer);
162148 : // Milind Chabbi (8/28/2013): isSgC_PreprocessorDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
162149 : // this improves the running time performance by 10-20%.
162150 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgC_PreprocessorDirectiveStatement*>(inputDerivedClassPointer);
162151 997965 : return IS_SgC_PreprocessorDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
162152 : }
162153 :
162154 : // DQ (11/8/2003): Added version of functions taking const pointer
162155 130660 : const SgC_PreprocessorDirectiveStatement* isSgC_PreprocessorDirectiveStatement ( const SgNode* inputDerivedClassPointer )
162156 : {
162157 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
162158 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
162159 : // So to fix this we return NULL directly when the input is NULL and avoid the
162160 : // dynamic_cast in this case. This is likely a performance improvement as well.
162161 : // return dynamic_cast<const SgC_PreprocessorDirectiveStatement*>(inputDerivedClassPointer);
162162 : // Milind Chabbi (8/28/2013): isSgC_PreprocessorDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
162163 : // this improves the running time performance by 10-20%.
162164 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgC_PreprocessorDirectiveStatement*>(inputDerivedClassPointer);
162165 130660 : return IS_SgC_PreprocessorDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
162166 : }
162167 :
162168 :
162169 :
162170 : /* #line 162171 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162171 :
162172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
162173 :
162174 : /**
162175 : \brief Generated destructor
162176 :
162177 : This destructor is automatically generated (by ROSETTA). This destructor
162178 : only frees memory of data members associated with the parts of the current IR node which
162179 : are NOT traversed. Those data members that are part of a traversal can be freed using
162180 : a traversal (calling this destructor on all children in a post-order traversal). Such
162181 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
162182 :
162183 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
162184 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
162185 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
162186 :
162187 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
162188 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
162189 : pointers are not yet implemented to call delete on eash pointer in the container.
162190 : (This could be done by derivation from the STL containers to define containers that
162191 : automatically deleted their members.)
162192 :
162193 : */
162194 0 : SgC_PreprocessorDirectiveStatement::~SgC_PreprocessorDirectiveStatement () {
162195 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
162196 :
162197 :
162198 : // case: not a listType for directiveString
162199 0 : p_directiveString = ""; // non list case
162200 :
162201 : }
162202 :
162203 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
162204 0 : }
162205 :
162206 :
162207 : /* #line 162208 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162208 :
162209 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
162210 :
162211 : // Generated constructor
162212 0 : SgC_PreprocessorDirectiveStatement::SgC_PreprocessorDirectiveStatement ( Sg_File_Info* startOfConstruct )
162213 0 : : SgDeclarationStatement(startOfConstruct)
162214 : {
162215 : #ifdef DEBUG
162216 : // printf ("In SgC_PreprocessorDirectiveStatement::SgC_PreprocessorDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
162217 : #endif
162218 : #if 0
162219 : // debugging information!
162220 : printf ("In SgC_PreprocessorDirectiveStatement::SgC_PreprocessorDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
162221 : #endif
162222 :
162223 0 : p_directiveString = "";
162224 :
162225 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
162226 :
162227 : #if 0
162228 : // DQ (7/30/2014): Call a virtual function.
162229 : std::string s = this->class_name();
162230 : #endif
162231 :
162232 : // Test the variant virtual function
162233 : // assert(CPP_DIRECTIVE_STMT == variant());
162234 0 : assert(CPP_DIRECTIVE_STMT == this->variant());
162235 0 : ROSE_ASSERT(CPP_DIRECTIVE_STMT == (int)(this->variantT()));
162236 0 : post_construction_initialization();
162237 :
162238 : // Test the isSgC_PreprocessorDirectiveStatement() function since it has been problematic
162239 0 : assert(isSgC_PreprocessorDirectiveStatement(this) != NULL);
162240 0 : }
162241 :
162242 : // Generated constructor (all data members)
162243 :
162244 : /* #line 162245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162245 :
162246 :
162247 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
162248 :
162249 :
162250 : // ********************************************************
162251 : // member functions common across all array grammar objects
162252 : // ********************************************************
162253 :
162254 :
162255 :
162256 : /* #line 162257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162257 :
162258 :
162259 :
162260 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
162261 :
162262 : // ********************************************************
162263 : // member functions specific to each node in the grammar
162264 : // ********************************************************
162265 :
162266 :
162267 : /* #line 162268 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162268 :
162269 : // Start of memberFunctionString
162270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
162271 :
162272 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
162273 :
162274 : SgHeaderFileBody*
162275 0 : SgIncludeDirectiveStatement::get_headerFileBody () const
162276 : {
162277 0 : ROSE_ASSERT (this != NULL);
162278 :
162279 : #if 0
162280 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
162281 : // used to trigger marking transformations for the token-based unparsing.
162282 : printf ("SgIncludeDirectiveStatement::get_headerFileBody = %p = %s \n",this,this->class_name().c_str());
162283 : #endif
162284 :
162285 0 : return p_headerFileBody;
162286 : }
162287 :
162288 : void
162289 0 : SgIncludeDirectiveStatement::set_headerFileBody ( SgHeaderFileBody* headerFileBody )
162290 : {
162291 0 : ROSE_ASSERT (this != NULL);
162292 :
162293 : #if 0
162294 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
162295 : // used to trigger marking transformations for the token-based unparsing.
162296 : printf ("SgIncludeDirectiveStatement::set_headerFileBody = %p = %s \n",this,this->class_name().c_str());
162297 : #endif
162298 :
162299 0 : set_isModified(true);
162300 :
162301 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
162302 : if (p_headerFileBody != NULL && headerFileBody != NULL && p_headerFileBody != headerFileBody)
162303 : {
162304 : printf ("Warning: headerFileBody = %p overwriting valid pointer p_headerFileBody = %p \n",headerFileBody,p_headerFileBody);
162305 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
162306 : printf ("Error fails assertion (p_headerFileBody != NULL && headerFileBody != NULL && p_headerFileBody != headerFileBody) is false\n");
162307 : ROSE_ASSERT(false);
162308 : #endif
162309 : }
162310 : #endif
162311 0 : p_headerFileBody = headerFileBody;
162312 0 : }
162313 :
162314 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
162315 :
162316 :
162317 : // End of memberFunctionString
162318 : // Start of memberFunctionString
162319 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
162320 :
162321 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
162322 :
162323 : SgIncludeFile*
162324 0 : SgIncludeDirectiveStatement::get_include_file_heirarchy () const
162325 : {
162326 0 : ROSE_ASSERT (this != NULL);
162327 :
162328 : #if 0
162329 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
162330 : // used to trigger marking transformations for the token-based unparsing.
162331 : printf ("SgIncludeDirectiveStatement::get_include_file_heirarchy = %p = %s \n",this,this->class_name().c_str());
162332 : #endif
162333 :
162334 0 : return p_include_file_heirarchy;
162335 : }
162336 :
162337 : void
162338 0 : SgIncludeDirectiveStatement::set_include_file_heirarchy ( SgIncludeFile* include_file_heirarchy )
162339 : {
162340 0 : ROSE_ASSERT (this != NULL);
162341 :
162342 : #if 0
162343 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
162344 : // used to trigger marking transformations for the token-based unparsing.
162345 : printf ("SgIncludeDirectiveStatement::set_include_file_heirarchy = %p = %s \n",this,this->class_name().c_str());
162346 : #endif
162347 :
162348 0 : set_isModified(true);
162349 :
162350 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
162351 : if (p_include_file_heirarchy != NULL && include_file_heirarchy != NULL && p_include_file_heirarchy != include_file_heirarchy)
162352 : {
162353 : printf ("Warning: include_file_heirarchy = %p overwriting valid pointer p_include_file_heirarchy = %p \n",include_file_heirarchy,p_include_file_heirarchy);
162354 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
162355 : printf ("Error fails assertion (p_include_file_heirarchy != NULL && include_file_heirarchy != NULL && p_include_file_heirarchy != include_file_heirarchy) is false\n");
162356 : ROSE_ASSERT(false);
162357 : #endif
162358 : }
162359 : #endif
162360 0 : p_include_file_heirarchy = include_file_heirarchy;
162361 0 : }
162362 :
162363 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
162364 :
162365 :
162366 : // End of memberFunctionString
162367 : // Start of memberFunctionString
162368 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
162369 :
162370 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
162371 :
162372 : std::string
162373 0 : SgIncludeDirectiveStatement::get_name_used_in_include_directive () const
162374 : {
162375 0 : ROSE_ASSERT (this != NULL);
162376 :
162377 : #if 0
162378 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
162379 : // used to trigger marking transformations for the token-based unparsing.
162380 : printf ("SgIncludeDirectiveStatement::get_name_used_in_include_directive = %p = %s \n",this,this->class_name().c_str());
162381 : #endif
162382 :
162383 0 : return p_name_used_in_include_directive;
162384 : }
162385 :
162386 : void
162387 0 : SgIncludeDirectiveStatement::set_name_used_in_include_directive ( std::string name_used_in_include_directive )
162388 : {
162389 0 : ROSE_ASSERT (this != NULL);
162390 :
162391 : #if 0
162392 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
162393 : // used to trigger marking transformations for the token-based unparsing.
162394 : printf ("SgIncludeDirectiveStatement::set_name_used_in_include_directive = %p = %s \n",this,this->class_name().c_str());
162395 : #endif
162396 :
162397 0 : set_isModified(true);
162398 :
162399 0 : p_name_used_in_include_directive = name_used_in_include_directive;
162400 0 : }
162401 :
162402 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
162403 :
162404 :
162405 : // End of memberFunctionString
162406 : // Start of memberFunctionString
162407 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
162408 :
162409 : void
162410 0 : SgIncludeDirectiveStatement::post_construction_initialization()
162411 : {
162412 0 : }
162413 :
162414 :
162415 :
162416 : // End of memberFunctionString
162417 : // Start of memberFunctionString
162418 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
162419 :
162420 : // *** COMMON CODE SECTION BEGINS HERE ***
162421 :
162422 : #if 0
162423 : int
162424 : SgIncludeDirectiveStatement::getVariant() const
162425 : {
162426 : // This function is used in ROSE while "variant()" is used in SAGE
162427 : assert(this != NULL);
162428 : return variant();
162429 : }
162430 : #endif
162431 :
162432 : // This function is used in ROSE in treeTraversal code
162433 : // eventually replaces getVariant() and variant()
162434 : // though after variant() has been removed for a while we will
162435 : // want to change the name of variantT() back to variant()
162436 : // (since the "T" was ment to stand for temporary).
162437 : // When this happens the variantT() will be depricated.
162438 : VariantT
162439 0 : SgIncludeDirectiveStatement::variantT() const
162440 : {
162441 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
162442 0 : ROSE_ASSERT(this != NULL);
162443 0 : return V_SgIncludeDirectiveStatement;
162444 : }
162445 :
162446 : #if 0
162447 : int
162448 : SgIncludeDirectiveStatement::variant() const
162449 : {
162450 : // This function is used in SAGE
162451 : ROSE_ASSERT(this != NULL);
162452 : return INCLUDE_DIRECTIVE_STMT;
162453 : }
162454 : #endif
162455 :
162456 : ROSE_DLL_API const char*
162457 0 : SgIncludeDirectiveStatement::sage_class_name() const
162458 : {
162459 0 : ROSE_ASSERT(this != NULL);
162460 0 : return "SgIncludeDirectiveStatement";
162461 : }
162462 :
162463 : std::string
162464 0 : SgIncludeDirectiveStatement::class_name() const
162465 : {
162466 0 : ROSE_ASSERT(this != NULL);
162467 0 : return "SgIncludeDirectiveStatement";
162468 : }
162469 :
162470 : // DQ (11/26/2005): Support for visitor pattern mechanims
162471 : // (inferior to ROSE traversal mechanism, experimental).
162472 : void
162473 0 : SgIncludeDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
162474 : {
162475 0 : ROSE_ASSERT(this != NULL);
162476 0 : visitor.visit(this);
162477 0 : }
162478 :
162479 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
162480 0 : void SgIncludeDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
162481 0 : ROSE_ASSERT(this != NULL);
162482 0 : visitor.visit(this);
162483 0 : }
162484 :
162485 : SgIncludeDirectiveStatement*
162486 0 : SgIncludeDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
162487 : {
162488 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
162489 : // This function is currently only supported for the AST used the represent Binary executables.
162490 : if (0 /* isSgAsmNode(this) != NULL */)
162491 : {
162492 : // Support for regex specification.
162493 : std::string prefixCode = "REGEX:";
162494 : addNewAttribute(prefixCode + s,a);
162495 : }
162496 : #endif
162497 :
162498 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
162499 0 : return this;
162500 : }
162501 :
162502 : // *** COMMON CODE SECTION ENDS HERE ***
162503 :
162504 :
162505 : // End of memberFunctionString
162506 : // Start of memberFunctionString
162507 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
162508 :
162509 :
162510 : #if 0
162511 : //! Error checking support
162512 : /*! Verifies the following:
162513 : - working getVariant() member function
162514 : - calls base class's error() member function
162515 : Every class has one of these functions.
162516 : */
162517 : bool
162518 : SgIncludeDirectiveStatement::error()
162519 : {
162520 : // Put error checking here
162521 :
162522 : ROSE_ASSERT (this != NULL);
162523 : if (getVariant() != INCLUDE_DIRECTIVE_STMT)
162524 : {
162525 : printf ("Error in SgIncludeDirectiveStatement::error(): SgIncludeDirectiveStatement object has a %s variant \n",
162526 : Cxx_GrammarTerminalNames[getVariant()].name);
162527 : // printf ("Error in SgIncludeDirectiveStatement::error() \n");
162528 : ROSE_ABORT();
162529 : }
162530 :
162531 : ROSE_ASSERT (getVariant() == INCLUDE_DIRECTIVE_STMT);
162532 : return SgC_PreprocessorDirectiveStatement::error();
162533 : }
162534 : #endif
162535 :
162536 :
162537 :
162538 : // End of memberFunctionString
162539 :
162540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
162541 :
162542 2455840 : SgIncludeDirectiveStatement* isSgIncludeDirectiveStatement ( SgNode* inputDerivedClassPointer )
162543 : {
162544 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
162545 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
162546 : // So to fix this we return NULL directly when the input is NULL and avoid the
162547 : // dynamic_cast in this case. This is likely a performance improvement as well.
162548 : // return dynamic_cast<SgIncludeDirectiveStatement*>(inputDerivedClassPointer);
162549 : // Milind Chabbi (8/28/2013): isSgIncludeDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
162550 : // this improves the running time performance by 10-20%.
162551 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIncludeDirectiveStatement*>(inputDerivedClassPointer);
162552 2455840 : return IS_SgIncludeDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
162553 : }
162554 :
162555 : // DQ (11/8/2003): Added version of functions taking const pointer
162556 0 : const SgIncludeDirectiveStatement* isSgIncludeDirectiveStatement ( const SgNode* inputDerivedClassPointer )
162557 : {
162558 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
162559 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
162560 : // So to fix this we return NULL directly when the input is NULL and avoid the
162561 : // dynamic_cast in this case. This is likely a performance improvement as well.
162562 : // return dynamic_cast<const SgIncludeDirectiveStatement*>(inputDerivedClassPointer);
162563 : // Milind Chabbi (8/28/2013): isSgIncludeDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
162564 : // this improves the running time performance by 10-20%.
162565 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIncludeDirectiveStatement*>(inputDerivedClassPointer);
162566 0 : return IS_SgIncludeDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
162567 : }
162568 :
162569 :
162570 :
162571 : /* #line 162572 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162572 :
162573 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
162574 :
162575 : /**
162576 : \brief Generated destructor
162577 :
162578 : This destructor is automatically generated (by ROSETTA). This destructor
162579 : only frees memory of data members associated with the parts of the current IR node which
162580 : are NOT traversed. Those data members that are part of a traversal can be freed using
162581 : a traversal (calling this destructor on all children in a post-order traversal). Such
162582 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
162583 :
162584 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
162585 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
162586 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
162587 :
162588 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
162589 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
162590 : pointers are not yet implemented to call delete on eash pointer in the container.
162591 : (This could be done by derivation from the STL containers to define containers that
162592 : automatically deleted their members.)
162593 :
162594 : */
162595 0 : SgIncludeDirectiveStatement::~SgIncludeDirectiveStatement () {
162596 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
162597 :
162598 :
162599 : // case: not a listType for headerFileBody
162600 0 : p_headerFileBody = NULL; // non list case
162601 : // case: not a listType for include_file_heirarchy
162602 0 : p_include_file_heirarchy = NULL; // non list case
162603 : // case: not a listType for name_used_in_include_directive
162604 0 : p_name_used_in_include_directive = ""; // non list case
162605 :
162606 : }
162607 :
162608 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
162609 0 : }
162610 :
162611 :
162612 : /* #line 162613 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162613 :
162614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
162615 :
162616 : // Generated constructor
162617 0 : SgIncludeDirectiveStatement::SgIncludeDirectiveStatement ( Sg_File_Info* startOfConstruct )
162618 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
162619 : {
162620 : #ifdef DEBUG
162621 : // printf ("In SgIncludeDirectiveStatement::SgIncludeDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
162622 : #endif
162623 : #if 0
162624 : // debugging information!
162625 : printf ("In SgIncludeDirectiveStatement::SgIncludeDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
162626 : #endif
162627 :
162628 0 : p_headerFileBody = NULL;
162629 0 : p_include_file_heirarchy = NULL;
162630 0 : p_name_used_in_include_directive = "";
162631 :
162632 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
162633 :
162634 : #if 0
162635 : // DQ (7/30/2014): Call a virtual function.
162636 : std::string s = this->class_name();
162637 : #endif
162638 :
162639 : // Test the variant virtual function
162640 : // assert(INCLUDE_DIRECTIVE_STMT == variant());
162641 0 : assert(INCLUDE_DIRECTIVE_STMT == this->variant());
162642 0 : ROSE_ASSERT(INCLUDE_DIRECTIVE_STMT == (int)(this->variantT()));
162643 0 : post_construction_initialization();
162644 :
162645 : // Test the isSgIncludeDirectiveStatement() function since it has been problematic
162646 0 : assert(isSgIncludeDirectiveStatement(this) != NULL);
162647 0 : }
162648 :
162649 : // Generated constructor (all data members)
162650 :
162651 : /* #line 162652 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162652 :
162653 :
162654 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
162655 :
162656 :
162657 : // ********************************************************
162658 : // member functions common across all array grammar objects
162659 : // ********************************************************
162660 :
162661 :
162662 :
162663 : /* #line 162664 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162664 :
162665 :
162666 :
162667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
162668 :
162669 : // ********************************************************
162670 : // member functions specific to each node in the grammar
162671 : // ********************************************************
162672 :
162673 :
162674 : /* #line 162675 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162675 :
162676 : // Start of memberFunctionString
162677 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
162678 :
162679 : void
162680 0 : SgDefineDirectiveStatement::post_construction_initialization()
162681 : {
162682 0 : }
162683 :
162684 :
162685 :
162686 : // End of memberFunctionString
162687 : // Start of memberFunctionString
162688 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
162689 :
162690 : // *** COMMON CODE SECTION BEGINS HERE ***
162691 :
162692 : #if 0
162693 : int
162694 : SgDefineDirectiveStatement::getVariant() const
162695 : {
162696 : // This function is used in ROSE while "variant()" is used in SAGE
162697 : assert(this != NULL);
162698 : return variant();
162699 : }
162700 : #endif
162701 :
162702 : // This function is used in ROSE in treeTraversal code
162703 : // eventually replaces getVariant() and variant()
162704 : // though after variant() has been removed for a while we will
162705 : // want to change the name of variantT() back to variant()
162706 : // (since the "T" was ment to stand for temporary).
162707 : // When this happens the variantT() will be depricated.
162708 : VariantT
162709 0 : SgDefineDirectiveStatement::variantT() const
162710 : {
162711 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
162712 0 : ROSE_ASSERT(this != NULL);
162713 0 : return V_SgDefineDirectiveStatement;
162714 : }
162715 :
162716 : #if 0
162717 : int
162718 : SgDefineDirectiveStatement::variant() const
162719 : {
162720 : // This function is used in SAGE
162721 : ROSE_ASSERT(this != NULL);
162722 : return DEFINE_DIRECTIVE_STMT;
162723 : }
162724 : #endif
162725 :
162726 : ROSE_DLL_API const char*
162727 0 : SgDefineDirectiveStatement::sage_class_name() const
162728 : {
162729 0 : ROSE_ASSERT(this != NULL);
162730 0 : return "SgDefineDirectiveStatement";
162731 : }
162732 :
162733 : std::string
162734 0 : SgDefineDirectiveStatement::class_name() const
162735 : {
162736 0 : ROSE_ASSERT(this != NULL);
162737 0 : return "SgDefineDirectiveStatement";
162738 : }
162739 :
162740 : // DQ (11/26/2005): Support for visitor pattern mechanims
162741 : // (inferior to ROSE traversal mechanism, experimental).
162742 : void
162743 0 : SgDefineDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
162744 : {
162745 0 : ROSE_ASSERT(this != NULL);
162746 0 : visitor.visit(this);
162747 0 : }
162748 :
162749 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
162750 0 : void SgDefineDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
162751 0 : ROSE_ASSERT(this != NULL);
162752 0 : visitor.visit(this);
162753 0 : }
162754 :
162755 : SgDefineDirectiveStatement*
162756 0 : SgDefineDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
162757 : {
162758 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
162759 : // This function is currently only supported for the AST used the represent Binary executables.
162760 : if (0 /* isSgAsmNode(this) != NULL */)
162761 : {
162762 : // Support for regex specification.
162763 : std::string prefixCode = "REGEX:";
162764 : addNewAttribute(prefixCode + s,a);
162765 : }
162766 : #endif
162767 :
162768 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
162769 0 : return this;
162770 : }
162771 :
162772 : // *** COMMON CODE SECTION ENDS HERE ***
162773 :
162774 :
162775 : // End of memberFunctionString
162776 : // Start of memberFunctionString
162777 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
162778 :
162779 :
162780 : #if 0
162781 : //! Error checking support
162782 : /*! Verifies the following:
162783 : - working getVariant() member function
162784 : - calls base class's error() member function
162785 : Every class has one of these functions.
162786 : */
162787 : bool
162788 : SgDefineDirectiveStatement::error()
162789 : {
162790 : // Put error checking here
162791 :
162792 : ROSE_ASSERT (this != NULL);
162793 : if (getVariant() != DEFINE_DIRECTIVE_STMT)
162794 : {
162795 : printf ("Error in SgDefineDirectiveStatement::error(): SgDefineDirectiveStatement object has a %s variant \n",
162796 : Cxx_GrammarTerminalNames[getVariant()].name);
162797 : // printf ("Error in SgDefineDirectiveStatement::error() \n");
162798 : ROSE_ABORT();
162799 : }
162800 :
162801 : ROSE_ASSERT (getVariant() == DEFINE_DIRECTIVE_STMT);
162802 : return SgC_PreprocessorDirectiveStatement::error();
162803 : }
162804 : #endif
162805 :
162806 :
162807 :
162808 : // End of memberFunctionString
162809 :
162810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
162811 :
162812 0 : SgDefineDirectiveStatement* isSgDefineDirectiveStatement ( SgNode* inputDerivedClassPointer )
162813 : {
162814 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
162815 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
162816 : // So to fix this we return NULL directly when the input is NULL and avoid the
162817 : // dynamic_cast in this case. This is likely a performance improvement as well.
162818 : // return dynamic_cast<SgDefineDirectiveStatement*>(inputDerivedClassPointer);
162819 : // Milind Chabbi (8/28/2013): isSgDefineDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
162820 : // this improves the running time performance by 10-20%.
162821 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDefineDirectiveStatement*>(inputDerivedClassPointer);
162822 0 : return IS_SgDefineDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
162823 : }
162824 :
162825 : // DQ (11/8/2003): Added version of functions taking const pointer
162826 0 : const SgDefineDirectiveStatement* isSgDefineDirectiveStatement ( const SgNode* inputDerivedClassPointer )
162827 : {
162828 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
162829 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
162830 : // So to fix this we return NULL directly when the input is NULL and avoid the
162831 : // dynamic_cast in this case. This is likely a performance improvement as well.
162832 : // return dynamic_cast<const SgDefineDirectiveStatement*>(inputDerivedClassPointer);
162833 : // Milind Chabbi (8/28/2013): isSgDefineDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
162834 : // this improves the running time performance by 10-20%.
162835 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDefineDirectiveStatement*>(inputDerivedClassPointer);
162836 0 : return IS_SgDefineDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
162837 : }
162838 :
162839 :
162840 :
162841 : /* #line 162842 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162842 :
162843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
162844 :
162845 : /**
162846 : \brief Generated destructor
162847 :
162848 : This destructor is automatically generated (by ROSETTA). This destructor
162849 : only frees memory of data members associated with the parts of the current IR node which
162850 : are NOT traversed. Those data members that are part of a traversal can be freed using
162851 : a traversal (calling this destructor on all children in a post-order traversal). Such
162852 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
162853 :
162854 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
162855 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
162856 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
162857 :
162858 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
162859 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
162860 : pointers are not yet implemented to call delete on eash pointer in the container.
162861 : (This could be done by derivation from the STL containers to define containers that
162862 : automatically deleted their members.)
162863 :
162864 : */
162865 0 : SgDefineDirectiveStatement::~SgDefineDirectiveStatement () {
162866 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
162867 :
162868 :
162869 :
162870 : }
162871 :
162872 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
162873 0 : }
162874 :
162875 :
162876 : /* #line 162877 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162877 :
162878 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
162879 :
162880 : // Generated constructor
162881 0 : SgDefineDirectiveStatement::SgDefineDirectiveStatement ( Sg_File_Info* startOfConstruct )
162882 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
162883 : {
162884 : #ifdef DEBUG
162885 : // printf ("In SgDefineDirectiveStatement::SgDefineDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
162886 : #endif
162887 : #if 0
162888 : // debugging information!
162889 : printf ("In SgDefineDirectiveStatement::SgDefineDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
162890 : #endif
162891 :
162892 :
162893 :
162894 : #if 0
162895 : // DQ (7/30/2014): Call a virtual function.
162896 : std::string s = this->class_name();
162897 : #endif
162898 :
162899 : // Test the variant virtual function
162900 : // assert(DEFINE_DIRECTIVE_STMT == variant());
162901 0 : assert(DEFINE_DIRECTIVE_STMT == this->variant());
162902 0 : ROSE_ASSERT(DEFINE_DIRECTIVE_STMT == (int)(this->variantT()));
162903 0 : post_construction_initialization();
162904 :
162905 : // Test the isSgDefineDirectiveStatement() function since it has been problematic
162906 0 : assert(isSgDefineDirectiveStatement(this) != NULL);
162907 0 : }
162908 :
162909 : // Generated constructor (all data members)
162910 :
162911 : /* #line 162912 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162912 :
162913 :
162914 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
162915 :
162916 :
162917 : // ********************************************************
162918 : // member functions common across all array grammar objects
162919 : // ********************************************************
162920 :
162921 :
162922 :
162923 : /* #line 162924 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162924 :
162925 :
162926 :
162927 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
162928 :
162929 : // ********************************************************
162930 : // member functions specific to each node in the grammar
162931 : // ********************************************************
162932 :
162933 :
162934 : /* #line 162935 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
162935 :
162936 : // Start of memberFunctionString
162937 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
162938 :
162939 : void
162940 0 : SgUndefDirectiveStatement::post_construction_initialization()
162941 : {
162942 0 : }
162943 :
162944 :
162945 :
162946 : // End of memberFunctionString
162947 : // Start of memberFunctionString
162948 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
162949 :
162950 : // *** COMMON CODE SECTION BEGINS HERE ***
162951 :
162952 : #if 0
162953 : int
162954 : SgUndefDirectiveStatement::getVariant() const
162955 : {
162956 : // This function is used in ROSE while "variant()" is used in SAGE
162957 : assert(this != NULL);
162958 : return variant();
162959 : }
162960 : #endif
162961 :
162962 : // This function is used in ROSE in treeTraversal code
162963 : // eventually replaces getVariant() and variant()
162964 : // though after variant() has been removed for a while we will
162965 : // want to change the name of variantT() back to variant()
162966 : // (since the "T" was ment to stand for temporary).
162967 : // When this happens the variantT() will be depricated.
162968 : VariantT
162969 0 : SgUndefDirectiveStatement::variantT() const
162970 : {
162971 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
162972 0 : ROSE_ASSERT(this != NULL);
162973 0 : return V_SgUndefDirectiveStatement;
162974 : }
162975 :
162976 : #if 0
162977 : int
162978 : SgUndefDirectiveStatement::variant() const
162979 : {
162980 : // This function is used in SAGE
162981 : ROSE_ASSERT(this != NULL);
162982 : return UNDEF_DIRECTIVE_STMT;
162983 : }
162984 : #endif
162985 :
162986 : ROSE_DLL_API const char*
162987 0 : SgUndefDirectiveStatement::sage_class_name() const
162988 : {
162989 0 : ROSE_ASSERT(this != NULL);
162990 0 : return "SgUndefDirectiveStatement";
162991 : }
162992 :
162993 : std::string
162994 0 : SgUndefDirectiveStatement::class_name() const
162995 : {
162996 0 : ROSE_ASSERT(this != NULL);
162997 0 : return "SgUndefDirectiveStatement";
162998 : }
162999 :
163000 : // DQ (11/26/2005): Support for visitor pattern mechanims
163001 : // (inferior to ROSE traversal mechanism, experimental).
163002 : void
163003 0 : SgUndefDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
163004 : {
163005 0 : ROSE_ASSERT(this != NULL);
163006 0 : visitor.visit(this);
163007 0 : }
163008 :
163009 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
163010 0 : void SgUndefDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
163011 0 : ROSE_ASSERT(this != NULL);
163012 0 : visitor.visit(this);
163013 0 : }
163014 :
163015 : SgUndefDirectiveStatement*
163016 0 : SgUndefDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
163017 : {
163018 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
163019 : // This function is currently only supported for the AST used the represent Binary executables.
163020 : if (0 /* isSgAsmNode(this) != NULL */)
163021 : {
163022 : // Support for regex specification.
163023 : std::string prefixCode = "REGEX:";
163024 : addNewAttribute(prefixCode + s,a);
163025 : }
163026 : #endif
163027 :
163028 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
163029 0 : return this;
163030 : }
163031 :
163032 : // *** COMMON CODE SECTION ENDS HERE ***
163033 :
163034 :
163035 : // End of memberFunctionString
163036 : // Start of memberFunctionString
163037 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
163038 :
163039 :
163040 : #if 0
163041 : //! Error checking support
163042 : /*! Verifies the following:
163043 : - working getVariant() member function
163044 : - calls base class's error() member function
163045 : Every class has one of these functions.
163046 : */
163047 : bool
163048 : SgUndefDirectiveStatement::error()
163049 : {
163050 : // Put error checking here
163051 :
163052 : ROSE_ASSERT (this != NULL);
163053 : if (getVariant() != UNDEF_DIRECTIVE_STMT)
163054 : {
163055 : printf ("Error in SgUndefDirectiveStatement::error(): SgUndefDirectiveStatement object has a %s variant \n",
163056 : Cxx_GrammarTerminalNames[getVariant()].name);
163057 : // printf ("Error in SgUndefDirectiveStatement::error() \n");
163058 : ROSE_ABORT();
163059 : }
163060 :
163061 : ROSE_ASSERT (getVariant() == UNDEF_DIRECTIVE_STMT);
163062 : return SgC_PreprocessorDirectiveStatement::error();
163063 : }
163064 : #endif
163065 :
163066 :
163067 :
163068 : // End of memberFunctionString
163069 :
163070 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
163071 :
163072 0 : SgUndefDirectiveStatement* isSgUndefDirectiveStatement ( SgNode* inputDerivedClassPointer )
163073 : {
163074 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163075 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163076 : // So to fix this we return NULL directly when the input is NULL and avoid the
163077 : // dynamic_cast in this case. This is likely a performance improvement as well.
163078 : // return dynamic_cast<SgUndefDirectiveStatement*>(inputDerivedClassPointer);
163079 : // Milind Chabbi (8/28/2013): isSgUndefDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163080 : // this improves the running time performance by 10-20%.
163081 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUndefDirectiveStatement*>(inputDerivedClassPointer);
163082 0 : return IS_SgUndefDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163083 : }
163084 :
163085 : // DQ (11/8/2003): Added version of functions taking const pointer
163086 0 : const SgUndefDirectiveStatement* isSgUndefDirectiveStatement ( const SgNode* inputDerivedClassPointer )
163087 : {
163088 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163089 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163090 : // So to fix this we return NULL directly when the input is NULL and avoid the
163091 : // dynamic_cast in this case. This is likely a performance improvement as well.
163092 : // return dynamic_cast<const SgUndefDirectiveStatement*>(inputDerivedClassPointer);
163093 : // Milind Chabbi (8/28/2013): isSgUndefDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163094 : // this improves the running time performance by 10-20%.
163095 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUndefDirectiveStatement*>(inputDerivedClassPointer);
163096 0 : return IS_SgUndefDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163097 : }
163098 :
163099 :
163100 :
163101 : /* #line 163102 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163102 :
163103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163104 :
163105 : /**
163106 : \brief Generated destructor
163107 :
163108 : This destructor is automatically generated (by ROSETTA). This destructor
163109 : only frees memory of data members associated with the parts of the current IR node which
163110 : are NOT traversed. Those data members that are part of a traversal can be freed using
163111 : a traversal (calling this destructor on all children in a post-order traversal). Such
163112 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
163113 :
163114 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
163115 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
163116 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
163117 :
163118 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
163119 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
163120 : pointers are not yet implemented to call delete on eash pointer in the container.
163121 : (This could be done by derivation from the STL containers to define containers that
163122 : automatically deleted their members.)
163123 :
163124 : */
163125 0 : SgUndefDirectiveStatement::~SgUndefDirectiveStatement () {
163126 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
163127 :
163128 :
163129 :
163130 : }
163131 :
163132 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163133 0 : }
163134 :
163135 :
163136 : /* #line 163137 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163137 :
163138 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
163139 :
163140 : // Generated constructor
163141 0 : SgUndefDirectiveStatement::SgUndefDirectiveStatement ( Sg_File_Info* startOfConstruct )
163142 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
163143 : {
163144 : #ifdef DEBUG
163145 : // printf ("In SgUndefDirectiveStatement::SgUndefDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
163146 : #endif
163147 : #if 0
163148 : // debugging information!
163149 : printf ("In SgUndefDirectiveStatement::SgUndefDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
163150 : #endif
163151 :
163152 :
163153 :
163154 : #if 0
163155 : // DQ (7/30/2014): Call a virtual function.
163156 : std::string s = this->class_name();
163157 : #endif
163158 :
163159 : // Test the variant virtual function
163160 : // assert(UNDEF_DIRECTIVE_STMT == variant());
163161 0 : assert(UNDEF_DIRECTIVE_STMT == this->variant());
163162 0 : ROSE_ASSERT(UNDEF_DIRECTIVE_STMT == (int)(this->variantT()));
163163 0 : post_construction_initialization();
163164 :
163165 : // Test the isSgUndefDirectiveStatement() function since it has been problematic
163166 0 : assert(isSgUndefDirectiveStatement(this) != NULL);
163167 0 : }
163168 :
163169 : // Generated constructor (all data members)
163170 :
163171 : /* #line 163172 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163172 :
163173 :
163174 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163175 :
163176 :
163177 : // ********************************************************
163178 : // member functions common across all array grammar objects
163179 : // ********************************************************
163180 :
163181 :
163182 :
163183 : /* #line 163184 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163184 :
163185 :
163186 :
163187 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163188 :
163189 : // ********************************************************
163190 : // member functions specific to each node in the grammar
163191 : // ********************************************************
163192 :
163193 :
163194 : /* #line 163195 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163195 :
163196 : // Start of memberFunctionString
163197 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
163198 :
163199 : void
163200 0 : SgIfdefDirectiveStatement::post_construction_initialization()
163201 : {
163202 0 : }
163203 :
163204 :
163205 :
163206 : // End of memberFunctionString
163207 : // Start of memberFunctionString
163208 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
163209 :
163210 : // *** COMMON CODE SECTION BEGINS HERE ***
163211 :
163212 : #if 0
163213 : int
163214 : SgIfdefDirectiveStatement::getVariant() const
163215 : {
163216 : // This function is used in ROSE while "variant()" is used in SAGE
163217 : assert(this != NULL);
163218 : return variant();
163219 : }
163220 : #endif
163221 :
163222 : // This function is used in ROSE in treeTraversal code
163223 : // eventually replaces getVariant() and variant()
163224 : // though after variant() has been removed for a while we will
163225 : // want to change the name of variantT() back to variant()
163226 : // (since the "T" was ment to stand for temporary).
163227 : // When this happens the variantT() will be depricated.
163228 : VariantT
163229 0 : SgIfdefDirectiveStatement::variantT() const
163230 : {
163231 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
163232 0 : ROSE_ASSERT(this != NULL);
163233 0 : return V_SgIfdefDirectiveStatement;
163234 : }
163235 :
163236 : #if 0
163237 : int
163238 : SgIfdefDirectiveStatement::variant() const
163239 : {
163240 : // This function is used in SAGE
163241 : ROSE_ASSERT(this != NULL);
163242 : return IFDEF_DIRECTIVE_STMT;
163243 : }
163244 : #endif
163245 :
163246 : ROSE_DLL_API const char*
163247 0 : SgIfdefDirectiveStatement::sage_class_name() const
163248 : {
163249 0 : ROSE_ASSERT(this != NULL);
163250 0 : return "SgIfdefDirectiveStatement";
163251 : }
163252 :
163253 : std::string
163254 0 : SgIfdefDirectiveStatement::class_name() const
163255 : {
163256 0 : ROSE_ASSERT(this != NULL);
163257 0 : return "SgIfdefDirectiveStatement";
163258 : }
163259 :
163260 : // DQ (11/26/2005): Support for visitor pattern mechanims
163261 : // (inferior to ROSE traversal mechanism, experimental).
163262 : void
163263 0 : SgIfdefDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
163264 : {
163265 0 : ROSE_ASSERT(this != NULL);
163266 0 : visitor.visit(this);
163267 0 : }
163268 :
163269 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
163270 0 : void SgIfdefDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
163271 0 : ROSE_ASSERT(this != NULL);
163272 0 : visitor.visit(this);
163273 0 : }
163274 :
163275 : SgIfdefDirectiveStatement*
163276 0 : SgIfdefDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
163277 : {
163278 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
163279 : // This function is currently only supported for the AST used the represent Binary executables.
163280 : if (0 /* isSgAsmNode(this) != NULL */)
163281 : {
163282 : // Support for regex specification.
163283 : std::string prefixCode = "REGEX:";
163284 : addNewAttribute(prefixCode + s,a);
163285 : }
163286 : #endif
163287 :
163288 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
163289 0 : return this;
163290 : }
163291 :
163292 : // *** COMMON CODE SECTION ENDS HERE ***
163293 :
163294 :
163295 : // End of memberFunctionString
163296 : // Start of memberFunctionString
163297 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
163298 :
163299 :
163300 : #if 0
163301 : //! Error checking support
163302 : /*! Verifies the following:
163303 : - working getVariant() member function
163304 : - calls base class's error() member function
163305 : Every class has one of these functions.
163306 : */
163307 : bool
163308 : SgIfdefDirectiveStatement::error()
163309 : {
163310 : // Put error checking here
163311 :
163312 : ROSE_ASSERT (this != NULL);
163313 : if (getVariant() != IFDEF_DIRECTIVE_STMT)
163314 : {
163315 : printf ("Error in SgIfdefDirectiveStatement::error(): SgIfdefDirectiveStatement object has a %s variant \n",
163316 : Cxx_GrammarTerminalNames[getVariant()].name);
163317 : // printf ("Error in SgIfdefDirectiveStatement::error() \n");
163318 : ROSE_ABORT();
163319 : }
163320 :
163321 : ROSE_ASSERT (getVariant() == IFDEF_DIRECTIVE_STMT);
163322 : return SgC_PreprocessorDirectiveStatement::error();
163323 : }
163324 : #endif
163325 :
163326 :
163327 :
163328 : // End of memberFunctionString
163329 :
163330 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
163331 :
163332 0 : SgIfdefDirectiveStatement* isSgIfdefDirectiveStatement ( SgNode* inputDerivedClassPointer )
163333 : {
163334 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163335 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163336 : // So to fix this we return NULL directly when the input is NULL and avoid the
163337 : // dynamic_cast in this case. This is likely a performance improvement as well.
163338 : // return dynamic_cast<SgIfdefDirectiveStatement*>(inputDerivedClassPointer);
163339 : // Milind Chabbi (8/28/2013): isSgIfdefDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163340 : // this improves the running time performance by 10-20%.
163341 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIfdefDirectiveStatement*>(inputDerivedClassPointer);
163342 0 : return IS_SgIfdefDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163343 : }
163344 :
163345 : // DQ (11/8/2003): Added version of functions taking const pointer
163346 0 : const SgIfdefDirectiveStatement* isSgIfdefDirectiveStatement ( const SgNode* inputDerivedClassPointer )
163347 : {
163348 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163349 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163350 : // So to fix this we return NULL directly when the input is NULL and avoid the
163351 : // dynamic_cast in this case. This is likely a performance improvement as well.
163352 : // return dynamic_cast<const SgIfdefDirectiveStatement*>(inputDerivedClassPointer);
163353 : // Milind Chabbi (8/28/2013): isSgIfdefDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163354 : // this improves the running time performance by 10-20%.
163355 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIfdefDirectiveStatement*>(inputDerivedClassPointer);
163356 0 : return IS_SgIfdefDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163357 : }
163358 :
163359 :
163360 :
163361 : /* #line 163362 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163362 :
163363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163364 :
163365 : /**
163366 : \brief Generated destructor
163367 :
163368 : This destructor is automatically generated (by ROSETTA). This destructor
163369 : only frees memory of data members associated with the parts of the current IR node which
163370 : are NOT traversed. Those data members that are part of a traversal can be freed using
163371 : a traversal (calling this destructor on all children in a post-order traversal). Such
163372 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
163373 :
163374 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
163375 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
163376 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
163377 :
163378 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
163379 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
163380 : pointers are not yet implemented to call delete on eash pointer in the container.
163381 : (This could be done by derivation from the STL containers to define containers that
163382 : automatically deleted their members.)
163383 :
163384 : */
163385 0 : SgIfdefDirectiveStatement::~SgIfdefDirectiveStatement () {
163386 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
163387 :
163388 :
163389 :
163390 : }
163391 :
163392 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163393 0 : }
163394 :
163395 :
163396 : /* #line 163397 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163397 :
163398 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
163399 :
163400 : // Generated constructor
163401 0 : SgIfdefDirectiveStatement::SgIfdefDirectiveStatement ( Sg_File_Info* startOfConstruct )
163402 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
163403 : {
163404 : #ifdef DEBUG
163405 : // printf ("In SgIfdefDirectiveStatement::SgIfdefDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
163406 : #endif
163407 : #if 0
163408 : // debugging information!
163409 : printf ("In SgIfdefDirectiveStatement::SgIfdefDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
163410 : #endif
163411 :
163412 :
163413 :
163414 : #if 0
163415 : // DQ (7/30/2014): Call a virtual function.
163416 : std::string s = this->class_name();
163417 : #endif
163418 :
163419 : // Test the variant virtual function
163420 : // assert(IFDEF_DIRECTIVE_STMT == variant());
163421 0 : assert(IFDEF_DIRECTIVE_STMT == this->variant());
163422 0 : ROSE_ASSERT(IFDEF_DIRECTIVE_STMT == (int)(this->variantT()));
163423 0 : post_construction_initialization();
163424 :
163425 : // Test the isSgIfdefDirectiveStatement() function since it has been problematic
163426 0 : assert(isSgIfdefDirectiveStatement(this) != NULL);
163427 0 : }
163428 :
163429 : // Generated constructor (all data members)
163430 :
163431 : /* #line 163432 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163432 :
163433 :
163434 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163435 :
163436 :
163437 : // ********************************************************
163438 : // member functions common across all array grammar objects
163439 : // ********************************************************
163440 :
163441 :
163442 :
163443 : /* #line 163444 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163444 :
163445 :
163446 :
163447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163448 :
163449 : // ********************************************************
163450 : // member functions specific to each node in the grammar
163451 : // ********************************************************
163452 :
163453 :
163454 : /* #line 163455 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163455 :
163456 : // Start of memberFunctionString
163457 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
163458 :
163459 : void
163460 0 : SgIfndefDirectiveStatement::post_construction_initialization()
163461 : {
163462 0 : }
163463 :
163464 :
163465 :
163466 : // End of memberFunctionString
163467 : // Start of memberFunctionString
163468 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
163469 :
163470 : // *** COMMON CODE SECTION BEGINS HERE ***
163471 :
163472 : #if 0
163473 : int
163474 : SgIfndefDirectiveStatement::getVariant() const
163475 : {
163476 : // This function is used in ROSE while "variant()" is used in SAGE
163477 : assert(this != NULL);
163478 : return variant();
163479 : }
163480 : #endif
163481 :
163482 : // This function is used in ROSE in treeTraversal code
163483 : // eventually replaces getVariant() and variant()
163484 : // though after variant() has been removed for a while we will
163485 : // want to change the name of variantT() back to variant()
163486 : // (since the "T" was ment to stand for temporary).
163487 : // When this happens the variantT() will be depricated.
163488 : VariantT
163489 0 : SgIfndefDirectiveStatement::variantT() const
163490 : {
163491 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
163492 0 : ROSE_ASSERT(this != NULL);
163493 0 : return V_SgIfndefDirectiveStatement;
163494 : }
163495 :
163496 : #if 0
163497 : int
163498 : SgIfndefDirectiveStatement::variant() const
163499 : {
163500 : // This function is used in SAGE
163501 : ROSE_ASSERT(this != NULL);
163502 : return IFNDEF_DIRECTIVE_STMT;
163503 : }
163504 : #endif
163505 :
163506 : ROSE_DLL_API const char*
163507 0 : SgIfndefDirectiveStatement::sage_class_name() const
163508 : {
163509 0 : ROSE_ASSERT(this != NULL);
163510 0 : return "SgIfndefDirectiveStatement";
163511 : }
163512 :
163513 : std::string
163514 0 : SgIfndefDirectiveStatement::class_name() const
163515 : {
163516 0 : ROSE_ASSERT(this != NULL);
163517 0 : return "SgIfndefDirectiveStatement";
163518 : }
163519 :
163520 : // DQ (11/26/2005): Support for visitor pattern mechanims
163521 : // (inferior to ROSE traversal mechanism, experimental).
163522 : void
163523 0 : SgIfndefDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
163524 : {
163525 0 : ROSE_ASSERT(this != NULL);
163526 0 : visitor.visit(this);
163527 0 : }
163528 :
163529 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
163530 0 : void SgIfndefDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
163531 0 : ROSE_ASSERT(this != NULL);
163532 0 : visitor.visit(this);
163533 0 : }
163534 :
163535 : SgIfndefDirectiveStatement*
163536 0 : SgIfndefDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
163537 : {
163538 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
163539 : // This function is currently only supported for the AST used the represent Binary executables.
163540 : if (0 /* isSgAsmNode(this) != NULL */)
163541 : {
163542 : // Support for regex specification.
163543 : std::string prefixCode = "REGEX:";
163544 : addNewAttribute(prefixCode + s,a);
163545 : }
163546 : #endif
163547 :
163548 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
163549 0 : return this;
163550 : }
163551 :
163552 : // *** COMMON CODE SECTION ENDS HERE ***
163553 :
163554 :
163555 : // End of memberFunctionString
163556 : // Start of memberFunctionString
163557 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
163558 :
163559 :
163560 : #if 0
163561 : //! Error checking support
163562 : /*! Verifies the following:
163563 : - working getVariant() member function
163564 : - calls base class's error() member function
163565 : Every class has one of these functions.
163566 : */
163567 : bool
163568 : SgIfndefDirectiveStatement::error()
163569 : {
163570 : // Put error checking here
163571 :
163572 : ROSE_ASSERT (this != NULL);
163573 : if (getVariant() != IFNDEF_DIRECTIVE_STMT)
163574 : {
163575 : printf ("Error in SgIfndefDirectiveStatement::error(): SgIfndefDirectiveStatement object has a %s variant \n",
163576 : Cxx_GrammarTerminalNames[getVariant()].name);
163577 : // printf ("Error in SgIfndefDirectiveStatement::error() \n");
163578 : ROSE_ABORT();
163579 : }
163580 :
163581 : ROSE_ASSERT (getVariant() == IFNDEF_DIRECTIVE_STMT);
163582 : return SgC_PreprocessorDirectiveStatement::error();
163583 : }
163584 : #endif
163585 :
163586 :
163587 :
163588 : // End of memberFunctionString
163589 :
163590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
163591 :
163592 0 : SgIfndefDirectiveStatement* isSgIfndefDirectiveStatement ( SgNode* inputDerivedClassPointer )
163593 : {
163594 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163595 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163596 : // So to fix this we return NULL directly when the input is NULL and avoid the
163597 : // dynamic_cast in this case. This is likely a performance improvement as well.
163598 : // return dynamic_cast<SgIfndefDirectiveStatement*>(inputDerivedClassPointer);
163599 : // Milind Chabbi (8/28/2013): isSgIfndefDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163600 : // this improves the running time performance by 10-20%.
163601 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIfndefDirectiveStatement*>(inputDerivedClassPointer);
163602 0 : return IS_SgIfndefDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163603 : }
163604 :
163605 : // DQ (11/8/2003): Added version of functions taking const pointer
163606 0 : const SgIfndefDirectiveStatement* isSgIfndefDirectiveStatement ( const SgNode* inputDerivedClassPointer )
163607 : {
163608 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163609 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163610 : // So to fix this we return NULL directly when the input is NULL and avoid the
163611 : // dynamic_cast in this case. This is likely a performance improvement as well.
163612 : // return dynamic_cast<const SgIfndefDirectiveStatement*>(inputDerivedClassPointer);
163613 : // Milind Chabbi (8/28/2013): isSgIfndefDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163614 : // this improves the running time performance by 10-20%.
163615 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIfndefDirectiveStatement*>(inputDerivedClassPointer);
163616 0 : return IS_SgIfndefDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163617 : }
163618 :
163619 :
163620 :
163621 : /* #line 163622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163622 :
163623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163624 :
163625 : /**
163626 : \brief Generated destructor
163627 :
163628 : This destructor is automatically generated (by ROSETTA). This destructor
163629 : only frees memory of data members associated with the parts of the current IR node which
163630 : are NOT traversed. Those data members that are part of a traversal can be freed using
163631 : a traversal (calling this destructor on all children in a post-order traversal). Such
163632 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
163633 :
163634 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
163635 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
163636 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
163637 :
163638 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
163639 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
163640 : pointers are not yet implemented to call delete on eash pointer in the container.
163641 : (This could be done by derivation from the STL containers to define containers that
163642 : automatically deleted their members.)
163643 :
163644 : */
163645 0 : SgIfndefDirectiveStatement::~SgIfndefDirectiveStatement () {
163646 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
163647 :
163648 :
163649 :
163650 : }
163651 :
163652 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163653 0 : }
163654 :
163655 :
163656 : /* #line 163657 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163657 :
163658 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
163659 :
163660 : // Generated constructor
163661 0 : SgIfndefDirectiveStatement::SgIfndefDirectiveStatement ( Sg_File_Info* startOfConstruct )
163662 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
163663 : {
163664 : #ifdef DEBUG
163665 : // printf ("In SgIfndefDirectiveStatement::SgIfndefDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
163666 : #endif
163667 : #if 0
163668 : // debugging information!
163669 : printf ("In SgIfndefDirectiveStatement::SgIfndefDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
163670 : #endif
163671 :
163672 :
163673 :
163674 : #if 0
163675 : // DQ (7/30/2014): Call a virtual function.
163676 : std::string s = this->class_name();
163677 : #endif
163678 :
163679 : // Test the variant virtual function
163680 : // assert(IFNDEF_DIRECTIVE_STMT == variant());
163681 0 : assert(IFNDEF_DIRECTIVE_STMT == this->variant());
163682 0 : ROSE_ASSERT(IFNDEF_DIRECTIVE_STMT == (int)(this->variantT()));
163683 0 : post_construction_initialization();
163684 :
163685 : // Test the isSgIfndefDirectiveStatement() function since it has been problematic
163686 0 : assert(isSgIfndefDirectiveStatement(this) != NULL);
163687 0 : }
163688 :
163689 : // Generated constructor (all data members)
163690 :
163691 : /* #line 163692 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163692 :
163693 :
163694 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163695 :
163696 :
163697 : // ********************************************************
163698 : // member functions common across all array grammar objects
163699 : // ********************************************************
163700 :
163701 :
163702 :
163703 : /* #line 163704 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163704 :
163705 :
163706 :
163707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163708 :
163709 : // ********************************************************
163710 : // member functions specific to each node in the grammar
163711 : // ********************************************************
163712 :
163713 :
163714 : /* #line 163715 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163715 :
163716 : // Start of memberFunctionString
163717 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
163718 :
163719 : void
163720 0 : SgIfDirectiveStatement::post_construction_initialization()
163721 : {
163722 0 : }
163723 :
163724 :
163725 :
163726 : // End of memberFunctionString
163727 : // Start of memberFunctionString
163728 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
163729 :
163730 : // *** COMMON CODE SECTION BEGINS HERE ***
163731 :
163732 : #if 0
163733 : int
163734 : SgIfDirectiveStatement::getVariant() const
163735 : {
163736 : // This function is used in ROSE while "variant()" is used in SAGE
163737 : assert(this != NULL);
163738 : return variant();
163739 : }
163740 : #endif
163741 :
163742 : // This function is used in ROSE in treeTraversal code
163743 : // eventually replaces getVariant() and variant()
163744 : // though after variant() has been removed for a while we will
163745 : // want to change the name of variantT() back to variant()
163746 : // (since the "T" was ment to stand for temporary).
163747 : // When this happens the variantT() will be depricated.
163748 : VariantT
163749 0 : SgIfDirectiveStatement::variantT() const
163750 : {
163751 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
163752 0 : ROSE_ASSERT(this != NULL);
163753 0 : return V_SgIfDirectiveStatement;
163754 : }
163755 :
163756 : #if 0
163757 : int
163758 : SgIfDirectiveStatement::variant() const
163759 : {
163760 : // This function is used in SAGE
163761 : ROSE_ASSERT(this != NULL);
163762 : return IF_DIRECTIVE_STMT;
163763 : }
163764 : #endif
163765 :
163766 : ROSE_DLL_API const char*
163767 0 : SgIfDirectiveStatement::sage_class_name() const
163768 : {
163769 0 : ROSE_ASSERT(this != NULL);
163770 0 : return "SgIfDirectiveStatement";
163771 : }
163772 :
163773 : std::string
163774 0 : SgIfDirectiveStatement::class_name() const
163775 : {
163776 0 : ROSE_ASSERT(this != NULL);
163777 0 : return "SgIfDirectiveStatement";
163778 : }
163779 :
163780 : // DQ (11/26/2005): Support for visitor pattern mechanims
163781 : // (inferior to ROSE traversal mechanism, experimental).
163782 : void
163783 0 : SgIfDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
163784 : {
163785 0 : ROSE_ASSERT(this != NULL);
163786 0 : visitor.visit(this);
163787 0 : }
163788 :
163789 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
163790 0 : void SgIfDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
163791 0 : ROSE_ASSERT(this != NULL);
163792 0 : visitor.visit(this);
163793 0 : }
163794 :
163795 : SgIfDirectiveStatement*
163796 0 : SgIfDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
163797 : {
163798 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
163799 : // This function is currently only supported for the AST used the represent Binary executables.
163800 : if (0 /* isSgAsmNode(this) != NULL */)
163801 : {
163802 : // Support for regex specification.
163803 : std::string prefixCode = "REGEX:";
163804 : addNewAttribute(prefixCode + s,a);
163805 : }
163806 : #endif
163807 :
163808 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
163809 0 : return this;
163810 : }
163811 :
163812 : // *** COMMON CODE SECTION ENDS HERE ***
163813 :
163814 :
163815 : // End of memberFunctionString
163816 : // Start of memberFunctionString
163817 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
163818 :
163819 :
163820 : #if 0
163821 : //! Error checking support
163822 : /*! Verifies the following:
163823 : - working getVariant() member function
163824 : - calls base class's error() member function
163825 : Every class has one of these functions.
163826 : */
163827 : bool
163828 : SgIfDirectiveStatement::error()
163829 : {
163830 : // Put error checking here
163831 :
163832 : ROSE_ASSERT (this != NULL);
163833 : if (getVariant() != IF_DIRECTIVE_STMT)
163834 : {
163835 : printf ("Error in SgIfDirectiveStatement::error(): SgIfDirectiveStatement object has a %s variant \n",
163836 : Cxx_GrammarTerminalNames[getVariant()].name);
163837 : // printf ("Error in SgIfDirectiveStatement::error() \n");
163838 : ROSE_ABORT();
163839 : }
163840 :
163841 : ROSE_ASSERT (getVariant() == IF_DIRECTIVE_STMT);
163842 : return SgC_PreprocessorDirectiveStatement::error();
163843 : }
163844 : #endif
163845 :
163846 :
163847 :
163848 : // End of memberFunctionString
163849 :
163850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
163851 :
163852 0 : SgIfDirectiveStatement* isSgIfDirectiveStatement ( SgNode* inputDerivedClassPointer )
163853 : {
163854 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163855 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163856 : // So to fix this we return NULL directly when the input is NULL and avoid the
163857 : // dynamic_cast in this case. This is likely a performance improvement as well.
163858 : // return dynamic_cast<SgIfDirectiveStatement*>(inputDerivedClassPointer);
163859 : // Milind Chabbi (8/28/2013): isSgIfDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163860 : // this improves the running time performance by 10-20%.
163861 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIfDirectiveStatement*>(inputDerivedClassPointer);
163862 0 : return IS_SgIfDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163863 : }
163864 :
163865 : // DQ (11/8/2003): Added version of functions taking const pointer
163866 0 : const SgIfDirectiveStatement* isSgIfDirectiveStatement ( const SgNode* inputDerivedClassPointer )
163867 : {
163868 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
163869 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
163870 : // So to fix this we return NULL directly when the input is NULL and avoid the
163871 : // dynamic_cast in this case. This is likely a performance improvement as well.
163872 : // return dynamic_cast<const SgIfDirectiveStatement*>(inputDerivedClassPointer);
163873 : // Milind Chabbi (8/28/2013): isSgIfDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
163874 : // this improves the running time performance by 10-20%.
163875 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIfDirectiveStatement*>(inputDerivedClassPointer);
163876 0 : return IS_SgIfDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
163877 : }
163878 :
163879 :
163880 :
163881 : /* #line 163882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163882 :
163883 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163884 :
163885 : /**
163886 : \brief Generated destructor
163887 :
163888 : This destructor is automatically generated (by ROSETTA). This destructor
163889 : only frees memory of data members associated with the parts of the current IR node which
163890 : are NOT traversed. Those data members that are part of a traversal can be freed using
163891 : a traversal (calling this destructor on all children in a post-order traversal). Such
163892 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
163893 :
163894 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
163895 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
163896 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
163897 :
163898 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
163899 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
163900 : pointers are not yet implemented to call delete on eash pointer in the container.
163901 : (This could be done by derivation from the STL containers to define containers that
163902 : automatically deleted their members.)
163903 :
163904 : */
163905 0 : SgIfDirectiveStatement::~SgIfDirectiveStatement () {
163906 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
163907 :
163908 :
163909 :
163910 : }
163911 :
163912 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
163913 0 : }
163914 :
163915 :
163916 : /* #line 163917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163917 :
163918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
163919 :
163920 : // Generated constructor
163921 0 : SgIfDirectiveStatement::SgIfDirectiveStatement ( Sg_File_Info* startOfConstruct )
163922 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
163923 : {
163924 : #ifdef DEBUG
163925 : // printf ("In SgIfDirectiveStatement::SgIfDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
163926 : #endif
163927 : #if 0
163928 : // debugging information!
163929 : printf ("In SgIfDirectiveStatement::SgIfDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
163930 : #endif
163931 :
163932 :
163933 :
163934 : #if 0
163935 : // DQ (7/30/2014): Call a virtual function.
163936 : std::string s = this->class_name();
163937 : #endif
163938 :
163939 : // Test the variant virtual function
163940 : // assert(IF_DIRECTIVE_STMT == variant());
163941 0 : assert(IF_DIRECTIVE_STMT == this->variant());
163942 0 : ROSE_ASSERT(IF_DIRECTIVE_STMT == (int)(this->variantT()));
163943 0 : post_construction_initialization();
163944 :
163945 : // Test the isSgIfDirectiveStatement() function since it has been problematic
163946 0 : assert(isSgIfDirectiveStatement(this) != NULL);
163947 0 : }
163948 :
163949 : // Generated constructor (all data members)
163950 :
163951 : /* #line 163952 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163952 :
163953 :
163954 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163955 :
163956 :
163957 : // ********************************************************
163958 : // member functions common across all array grammar objects
163959 : // ********************************************************
163960 :
163961 :
163962 :
163963 : /* #line 163964 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163964 :
163965 :
163966 :
163967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
163968 :
163969 : // ********************************************************
163970 : // member functions specific to each node in the grammar
163971 : // ********************************************************
163972 :
163973 :
163974 : /* #line 163975 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
163975 :
163976 : // Start of memberFunctionString
163977 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
163978 :
163979 : void
163980 0 : SgDeadIfDirectiveStatement::post_construction_initialization()
163981 : {
163982 0 : }
163983 :
163984 :
163985 :
163986 : // End of memberFunctionString
163987 : // Start of memberFunctionString
163988 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
163989 :
163990 : // *** COMMON CODE SECTION BEGINS HERE ***
163991 :
163992 : #if 0
163993 : int
163994 : SgDeadIfDirectiveStatement::getVariant() const
163995 : {
163996 : // This function is used in ROSE while "variant()" is used in SAGE
163997 : assert(this != NULL);
163998 : return variant();
163999 : }
164000 : #endif
164001 :
164002 : // This function is used in ROSE in treeTraversal code
164003 : // eventually replaces getVariant() and variant()
164004 : // though after variant() has been removed for a while we will
164005 : // want to change the name of variantT() back to variant()
164006 : // (since the "T" was ment to stand for temporary).
164007 : // When this happens the variantT() will be depricated.
164008 : VariantT
164009 0 : SgDeadIfDirectiveStatement::variantT() const
164010 : {
164011 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
164012 0 : ROSE_ASSERT(this != NULL);
164013 0 : return V_SgDeadIfDirectiveStatement;
164014 : }
164015 :
164016 : #if 0
164017 : int
164018 : SgDeadIfDirectiveStatement::variant() const
164019 : {
164020 : // This function is used in SAGE
164021 : ROSE_ASSERT(this != NULL);
164022 : return DEAD_IF_DIRECTIVE_STMT;
164023 : }
164024 : #endif
164025 :
164026 : ROSE_DLL_API const char*
164027 0 : SgDeadIfDirectiveStatement::sage_class_name() const
164028 : {
164029 0 : ROSE_ASSERT(this != NULL);
164030 0 : return "SgDeadIfDirectiveStatement";
164031 : }
164032 :
164033 : std::string
164034 0 : SgDeadIfDirectiveStatement::class_name() const
164035 : {
164036 0 : ROSE_ASSERT(this != NULL);
164037 0 : return "SgDeadIfDirectiveStatement";
164038 : }
164039 :
164040 : // DQ (11/26/2005): Support for visitor pattern mechanims
164041 : // (inferior to ROSE traversal mechanism, experimental).
164042 : void
164043 0 : SgDeadIfDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
164044 : {
164045 0 : ROSE_ASSERT(this != NULL);
164046 0 : visitor.visit(this);
164047 0 : }
164048 :
164049 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
164050 0 : void SgDeadIfDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
164051 0 : ROSE_ASSERT(this != NULL);
164052 0 : visitor.visit(this);
164053 0 : }
164054 :
164055 : SgDeadIfDirectiveStatement*
164056 0 : SgDeadIfDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
164057 : {
164058 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
164059 : // This function is currently only supported for the AST used the represent Binary executables.
164060 : if (0 /* isSgAsmNode(this) != NULL */)
164061 : {
164062 : // Support for regex specification.
164063 : std::string prefixCode = "REGEX:";
164064 : addNewAttribute(prefixCode + s,a);
164065 : }
164066 : #endif
164067 :
164068 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
164069 0 : return this;
164070 : }
164071 :
164072 : // *** COMMON CODE SECTION ENDS HERE ***
164073 :
164074 :
164075 : // End of memberFunctionString
164076 : // Start of memberFunctionString
164077 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
164078 :
164079 :
164080 : #if 0
164081 : //! Error checking support
164082 : /*! Verifies the following:
164083 : - working getVariant() member function
164084 : - calls base class's error() member function
164085 : Every class has one of these functions.
164086 : */
164087 : bool
164088 : SgDeadIfDirectiveStatement::error()
164089 : {
164090 : // Put error checking here
164091 :
164092 : ROSE_ASSERT (this != NULL);
164093 : if (getVariant() != DEAD_IF_DIRECTIVE_STMT)
164094 : {
164095 : printf ("Error in SgDeadIfDirectiveStatement::error(): SgDeadIfDirectiveStatement object has a %s variant \n",
164096 : Cxx_GrammarTerminalNames[getVariant()].name);
164097 : // printf ("Error in SgDeadIfDirectiveStatement::error() \n");
164098 : ROSE_ABORT();
164099 : }
164100 :
164101 : ROSE_ASSERT (getVariant() == DEAD_IF_DIRECTIVE_STMT);
164102 : return SgC_PreprocessorDirectiveStatement::error();
164103 : }
164104 : #endif
164105 :
164106 :
164107 :
164108 : // End of memberFunctionString
164109 :
164110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
164111 :
164112 0 : SgDeadIfDirectiveStatement* isSgDeadIfDirectiveStatement ( SgNode* inputDerivedClassPointer )
164113 : {
164114 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164115 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164116 : // So to fix this we return NULL directly when the input is NULL and avoid the
164117 : // dynamic_cast in this case. This is likely a performance improvement as well.
164118 : // return dynamic_cast<SgDeadIfDirectiveStatement*>(inputDerivedClassPointer);
164119 : // Milind Chabbi (8/28/2013): isSgDeadIfDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164120 : // this improves the running time performance by 10-20%.
164121 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeadIfDirectiveStatement*>(inputDerivedClassPointer);
164122 0 : return IS_SgDeadIfDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164123 : }
164124 :
164125 : // DQ (11/8/2003): Added version of functions taking const pointer
164126 0 : const SgDeadIfDirectiveStatement* isSgDeadIfDirectiveStatement ( const SgNode* inputDerivedClassPointer )
164127 : {
164128 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164129 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164130 : // So to fix this we return NULL directly when the input is NULL and avoid the
164131 : // dynamic_cast in this case. This is likely a performance improvement as well.
164132 : // return dynamic_cast<const SgDeadIfDirectiveStatement*>(inputDerivedClassPointer);
164133 : // Milind Chabbi (8/28/2013): isSgDeadIfDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164134 : // this improves the running time performance by 10-20%.
164135 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeadIfDirectiveStatement*>(inputDerivedClassPointer);
164136 0 : return IS_SgDeadIfDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164137 : }
164138 :
164139 :
164140 :
164141 : /* #line 164142 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164142 :
164143 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164144 :
164145 : /**
164146 : \brief Generated destructor
164147 :
164148 : This destructor is automatically generated (by ROSETTA). This destructor
164149 : only frees memory of data members associated with the parts of the current IR node which
164150 : are NOT traversed. Those data members that are part of a traversal can be freed using
164151 : a traversal (calling this destructor on all children in a post-order traversal). Such
164152 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
164153 :
164154 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
164155 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
164156 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
164157 :
164158 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
164159 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
164160 : pointers are not yet implemented to call delete on eash pointer in the container.
164161 : (This could be done by derivation from the STL containers to define containers that
164162 : automatically deleted their members.)
164163 :
164164 : */
164165 0 : SgDeadIfDirectiveStatement::~SgDeadIfDirectiveStatement () {
164166 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
164167 :
164168 :
164169 :
164170 : }
164171 :
164172 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164173 0 : }
164174 :
164175 :
164176 : /* #line 164177 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164177 :
164178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
164179 :
164180 : // Generated constructor
164181 0 : SgDeadIfDirectiveStatement::SgDeadIfDirectiveStatement ( Sg_File_Info* startOfConstruct )
164182 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
164183 : {
164184 : #ifdef DEBUG
164185 : // printf ("In SgDeadIfDirectiveStatement::SgDeadIfDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
164186 : #endif
164187 : #if 0
164188 : // debugging information!
164189 : printf ("In SgDeadIfDirectiveStatement::SgDeadIfDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
164190 : #endif
164191 :
164192 :
164193 :
164194 : #if 0
164195 : // DQ (7/30/2014): Call a virtual function.
164196 : std::string s = this->class_name();
164197 : #endif
164198 :
164199 : // Test the variant virtual function
164200 : // assert(DEAD_IF_DIRECTIVE_STMT == variant());
164201 0 : assert(DEAD_IF_DIRECTIVE_STMT == this->variant());
164202 0 : ROSE_ASSERT(DEAD_IF_DIRECTIVE_STMT == (int)(this->variantT()));
164203 0 : post_construction_initialization();
164204 :
164205 : // Test the isSgDeadIfDirectiveStatement() function since it has been problematic
164206 0 : assert(isSgDeadIfDirectiveStatement(this) != NULL);
164207 0 : }
164208 :
164209 : // Generated constructor (all data members)
164210 :
164211 : /* #line 164212 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164212 :
164213 :
164214 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164215 :
164216 :
164217 : // ********************************************************
164218 : // member functions common across all array grammar objects
164219 : // ********************************************************
164220 :
164221 :
164222 :
164223 : /* #line 164224 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164224 :
164225 :
164226 :
164227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164228 :
164229 : // ********************************************************
164230 : // member functions specific to each node in the grammar
164231 : // ********************************************************
164232 :
164233 :
164234 : /* #line 164235 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164235 :
164236 : // Start of memberFunctionString
164237 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
164238 :
164239 : void
164240 0 : SgElseDirectiveStatement::post_construction_initialization()
164241 : {
164242 0 : }
164243 :
164244 :
164245 :
164246 : // End of memberFunctionString
164247 : // Start of memberFunctionString
164248 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
164249 :
164250 : // *** COMMON CODE SECTION BEGINS HERE ***
164251 :
164252 : #if 0
164253 : int
164254 : SgElseDirectiveStatement::getVariant() const
164255 : {
164256 : // This function is used in ROSE while "variant()" is used in SAGE
164257 : assert(this != NULL);
164258 : return variant();
164259 : }
164260 : #endif
164261 :
164262 : // This function is used in ROSE in treeTraversal code
164263 : // eventually replaces getVariant() and variant()
164264 : // though after variant() has been removed for a while we will
164265 : // want to change the name of variantT() back to variant()
164266 : // (since the "T" was ment to stand for temporary).
164267 : // When this happens the variantT() will be depricated.
164268 : VariantT
164269 0 : SgElseDirectiveStatement::variantT() const
164270 : {
164271 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
164272 0 : ROSE_ASSERT(this != NULL);
164273 0 : return V_SgElseDirectiveStatement;
164274 : }
164275 :
164276 : #if 0
164277 : int
164278 : SgElseDirectiveStatement::variant() const
164279 : {
164280 : // This function is used in SAGE
164281 : ROSE_ASSERT(this != NULL);
164282 : return ELSE_DIRECTIVE_STMT;
164283 : }
164284 : #endif
164285 :
164286 : ROSE_DLL_API const char*
164287 0 : SgElseDirectiveStatement::sage_class_name() const
164288 : {
164289 0 : ROSE_ASSERT(this != NULL);
164290 0 : return "SgElseDirectiveStatement";
164291 : }
164292 :
164293 : std::string
164294 0 : SgElseDirectiveStatement::class_name() const
164295 : {
164296 0 : ROSE_ASSERT(this != NULL);
164297 0 : return "SgElseDirectiveStatement";
164298 : }
164299 :
164300 : // DQ (11/26/2005): Support for visitor pattern mechanims
164301 : // (inferior to ROSE traversal mechanism, experimental).
164302 : void
164303 0 : SgElseDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
164304 : {
164305 0 : ROSE_ASSERT(this != NULL);
164306 0 : visitor.visit(this);
164307 0 : }
164308 :
164309 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
164310 0 : void SgElseDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
164311 0 : ROSE_ASSERT(this != NULL);
164312 0 : visitor.visit(this);
164313 0 : }
164314 :
164315 : SgElseDirectiveStatement*
164316 0 : SgElseDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
164317 : {
164318 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
164319 : // This function is currently only supported for the AST used the represent Binary executables.
164320 : if (0 /* isSgAsmNode(this) != NULL */)
164321 : {
164322 : // Support for regex specification.
164323 : std::string prefixCode = "REGEX:";
164324 : addNewAttribute(prefixCode + s,a);
164325 : }
164326 : #endif
164327 :
164328 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
164329 0 : return this;
164330 : }
164331 :
164332 : // *** COMMON CODE SECTION ENDS HERE ***
164333 :
164334 :
164335 : // End of memberFunctionString
164336 : // Start of memberFunctionString
164337 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
164338 :
164339 :
164340 : #if 0
164341 : //! Error checking support
164342 : /*! Verifies the following:
164343 : - working getVariant() member function
164344 : - calls base class's error() member function
164345 : Every class has one of these functions.
164346 : */
164347 : bool
164348 : SgElseDirectiveStatement::error()
164349 : {
164350 : // Put error checking here
164351 :
164352 : ROSE_ASSERT (this != NULL);
164353 : if (getVariant() != ELSE_DIRECTIVE_STMT)
164354 : {
164355 : printf ("Error in SgElseDirectiveStatement::error(): SgElseDirectiveStatement object has a %s variant \n",
164356 : Cxx_GrammarTerminalNames[getVariant()].name);
164357 : // printf ("Error in SgElseDirectiveStatement::error() \n");
164358 : ROSE_ABORT();
164359 : }
164360 :
164361 : ROSE_ASSERT (getVariant() == ELSE_DIRECTIVE_STMT);
164362 : return SgC_PreprocessorDirectiveStatement::error();
164363 : }
164364 : #endif
164365 :
164366 :
164367 :
164368 : // End of memberFunctionString
164369 :
164370 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
164371 :
164372 0 : SgElseDirectiveStatement* isSgElseDirectiveStatement ( SgNode* inputDerivedClassPointer )
164373 : {
164374 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164375 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164376 : // So to fix this we return NULL directly when the input is NULL and avoid the
164377 : // dynamic_cast in this case. This is likely a performance improvement as well.
164378 : // return dynamic_cast<SgElseDirectiveStatement*>(inputDerivedClassPointer);
164379 : // Milind Chabbi (8/28/2013): isSgElseDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164380 : // this improves the running time performance by 10-20%.
164381 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElseDirectiveStatement*>(inputDerivedClassPointer);
164382 0 : return IS_SgElseDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164383 : }
164384 :
164385 : // DQ (11/8/2003): Added version of functions taking const pointer
164386 0 : const SgElseDirectiveStatement* isSgElseDirectiveStatement ( const SgNode* inputDerivedClassPointer )
164387 : {
164388 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164389 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164390 : // So to fix this we return NULL directly when the input is NULL and avoid the
164391 : // dynamic_cast in this case. This is likely a performance improvement as well.
164392 : // return dynamic_cast<const SgElseDirectiveStatement*>(inputDerivedClassPointer);
164393 : // Milind Chabbi (8/28/2013): isSgElseDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164394 : // this improves the running time performance by 10-20%.
164395 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElseDirectiveStatement*>(inputDerivedClassPointer);
164396 0 : return IS_SgElseDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164397 : }
164398 :
164399 :
164400 :
164401 : /* #line 164402 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164402 :
164403 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164404 :
164405 : /**
164406 : \brief Generated destructor
164407 :
164408 : This destructor is automatically generated (by ROSETTA). This destructor
164409 : only frees memory of data members associated with the parts of the current IR node which
164410 : are NOT traversed. Those data members that are part of a traversal can be freed using
164411 : a traversal (calling this destructor on all children in a post-order traversal). Such
164412 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
164413 :
164414 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
164415 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
164416 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
164417 :
164418 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
164419 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
164420 : pointers are not yet implemented to call delete on eash pointer in the container.
164421 : (This could be done by derivation from the STL containers to define containers that
164422 : automatically deleted their members.)
164423 :
164424 : */
164425 0 : SgElseDirectiveStatement::~SgElseDirectiveStatement () {
164426 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
164427 :
164428 :
164429 :
164430 : }
164431 :
164432 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164433 0 : }
164434 :
164435 :
164436 : /* #line 164437 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164437 :
164438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
164439 :
164440 : // Generated constructor
164441 0 : SgElseDirectiveStatement::SgElseDirectiveStatement ( Sg_File_Info* startOfConstruct )
164442 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
164443 : {
164444 : #ifdef DEBUG
164445 : // printf ("In SgElseDirectiveStatement::SgElseDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
164446 : #endif
164447 : #if 0
164448 : // debugging information!
164449 : printf ("In SgElseDirectiveStatement::SgElseDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
164450 : #endif
164451 :
164452 :
164453 :
164454 : #if 0
164455 : // DQ (7/30/2014): Call a virtual function.
164456 : std::string s = this->class_name();
164457 : #endif
164458 :
164459 : // Test the variant virtual function
164460 : // assert(ELSE_DIRECTIVE_STMT == variant());
164461 0 : assert(ELSE_DIRECTIVE_STMT == this->variant());
164462 0 : ROSE_ASSERT(ELSE_DIRECTIVE_STMT == (int)(this->variantT()));
164463 0 : post_construction_initialization();
164464 :
164465 : // Test the isSgElseDirectiveStatement() function since it has been problematic
164466 0 : assert(isSgElseDirectiveStatement(this) != NULL);
164467 0 : }
164468 :
164469 : // Generated constructor (all data members)
164470 :
164471 : /* #line 164472 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164472 :
164473 :
164474 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164475 :
164476 :
164477 : // ********************************************************
164478 : // member functions common across all array grammar objects
164479 : // ********************************************************
164480 :
164481 :
164482 :
164483 : /* #line 164484 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164484 :
164485 :
164486 :
164487 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164488 :
164489 : // ********************************************************
164490 : // member functions specific to each node in the grammar
164491 : // ********************************************************
164492 :
164493 :
164494 : /* #line 164495 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164495 :
164496 : // Start of memberFunctionString
164497 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
164498 :
164499 : void
164500 0 : SgElseifDirectiveStatement::post_construction_initialization()
164501 : {
164502 0 : }
164503 :
164504 :
164505 :
164506 : // End of memberFunctionString
164507 : // Start of memberFunctionString
164508 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
164509 :
164510 : // *** COMMON CODE SECTION BEGINS HERE ***
164511 :
164512 : #if 0
164513 : int
164514 : SgElseifDirectiveStatement::getVariant() const
164515 : {
164516 : // This function is used in ROSE while "variant()" is used in SAGE
164517 : assert(this != NULL);
164518 : return variant();
164519 : }
164520 : #endif
164521 :
164522 : // This function is used in ROSE in treeTraversal code
164523 : // eventually replaces getVariant() and variant()
164524 : // though after variant() has been removed for a while we will
164525 : // want to change the name of variantT() back to variant()
164526 : // (since the "T" was ment to stand for temporary).
164527 : // When this happens the variantT() will be depricated.
164528 : VariantT
164529 0 : SgElseifDirectiveStatement::variantT() const
164530 : {
164531 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
164532 0 : ROSE_ASSERT(this != NULL);
164533 0 : return V_SgElseifDirectiveStatement;
164534 : }
164535 :
164536 : #if 0
164537 : int
164538 : SgElseifDirectiveStatement::variant() const
164539 : {
164540 : // This function is used in SAGE
164541 : ROSE_ASSERT(this != NULL);
164542 : return ELSEIF_DIRECTIVE_STMT;
164543 : }
164544 : #endif
164545 :
164546 : ROSE_DLL_API const char*
164547 0 : SgElseifDirectiveStatement::sage_class_name() const
164548 : {
164549 0 : ROSE_ASSERT(this != NULL);
164550 0 : return "SgElseifDirectiveStatement";
164551 : }
164552 :
164553 : std::string
164554 0 : SgElseifDirectiveStatement::class_name() const
164555 : {
164556 0 : ROSE_ASSERT(this != NULL);
164557 0 : return "SgElseifDirectiveStatement";
164558 : }
164559 :
164560 : // DQ (11/26/2005): Support for visitor pattern mechanims
164561 : // (inferior to ROSE traversal mechanism, experimental).
164562 : void
164563 0 : SgElseifDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
164564 : {
164565 0 : ROSE_ASSERT(this != NULL);
164566 0 : visitor.visit(this);
164567 0 : }
164568 :
164569 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
164570 0 : void SgElseifDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
164571 0 : ROSE_ASSERT(this != NULL);
164572 0 : visitor.visit(this);
164573 0 : }
164574 :
164575 : SgElseifDirectiveStatement*
164576 0 : SgElseifDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
164577 : {
164578 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
164579 : // This function is currently only supported for the AST used the represent Binary executables.
164580 : if (0 /* isSgAsmNode(this) != NULL */)
164581 : {
164582 : // Support for regex specification.
164583 : std::string prefixCode = "REGEX:";
164584 : addNewAttribute(prefixCode + s,a);
164585 : }
164586 : #endif
164587 :
164588 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
164589 0 : return this;
164590 : }
164591 :
164592 : // *** COMMON CODE SECTION ENDS HERE ***
164593 :
164594 :
164595 : // End of memberFunctionString
164596 : // Start of memberFunctionString
164597 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
164598 :
164599 :
164600 : #if 0
164601 : //! Error checking support
164602 : /*! Verifies the following:
164603 : - working getVariant() member function
164604 : - calls base class's error() member function
164605 : Every class has one of these functions.
164606 : */
164607 : bool
164608 : SgElseifDirectiveStatement::error()
164609 : {
164610 : // Put error checking here
164611 :
164612 : ROSE_ASSERT (this != NULL);
164613 : if (getVariant() != ELSEIF_DIRECTIVE_STMT)
164614 : {
164615 : printf ("Error in SgElseifDirectiveStatement::error(): SgElseifDirectiveStatement object has a %s variant \n",
164616 : Cxx_GrammarTerminalNames[getVariant()].name);
164617 : // printf ("Error in SgElseifDirectiveStatement::error() \n");
164618 : ROSE_ABORT();
164619 : }
164620 :
164621 : ROSE_ASSERT (getVariant() == ELSEIF_DIRECTIVE_STMT);
164622 : return SgC_PreprocessorDirectiveStatement::error();
164623 : }
164624 : #endif
164625 :
164626 :
164627 :
164628 : // End of memberFunctionString
164629 :
164630 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
164631 :
164632 0 : SgElseifDirectiveStatement* isSgElseifDirectiveStatement ( SgNode* inputDerivedClassPointer )
164633 : {
164634 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164635 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164636 : // So to fix this we return NULL directly when the input is NULL and avoid the
164637 : // dynamic_cast in this case. This is likely a performance improvement as well.
164638 : // return dynamic_cast<SgElseifDirectiveStatement*>(inputDerivedClassPointer);
164639 : // Milind Chabbi (8/28/2013): isSgElseifDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164640 : // this improves the running time performance by 10-20%.
164641 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElseifDirectiveStatement*>(inputDerivedClassPointer);
164642 0 : return IS_SgElseifDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164643 : }
164644 :
164645 : // DQ (11/8/2003): Added version of functions taking const pointer
164646 0 : const SgElseifDirectiveStatement* isSgElseifDirectiveStatement ( const SgNode* inputDerivedClassPointer )
164647 : {
164648 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164649 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164650 : // So to fix this we return NULL directly when the input is NULL and avoid the
164651 : // dynamic_cast in this case. This is likely a performance improvement as well.
164652 : // return dynamic_cast<const SgElseifDirectiveStatement*>(inputDerivedClassPointer);
164653 : // Milind Chabbi (8/28/2013): isSgElseifDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164654 : // this improves the running time performance by 10-20%.
164655 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElseifDirectiveStatement*>(inputDerivedClassPointer);
164656 0 : return IS_SgElseifDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164657 : }
164658 :
164659 :
164660 :
164661 : /* #line 164662 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164662 :
164663 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164664 :
164665 : /**
164666 : \brief Generated destructor
164667 :
164668 : This destructor is automatically generated (by ROSETTA). This destructor
164669 : only frees memory of data members associated with the parts of the current IR node which
164670 : are NOT traversed. Those data members that are part of a traversal can be freed using
164671 : a traversal (calling this destructor on all children in a post-order traversal). Such
164672 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
164673 :
164674 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
164675 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
164676 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
164677 :
164678 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
164679 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
164680 : pointers are not yet implemented to call delete on eash pointer in the container.
164681 : (This could be done by derivation from the STL containers to define containers that
164682 : automatically deleted their members.)
164683 :
164684 : */
164685 0 : SgElseifDirectiveStatement::~SgElseifDirectiveStatement () {
164686 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
164687 :
164688 :
164689 :
164690 : }
164691 :
164692 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164693 0 : }
164694 :
164695 :
164696 : /* #line 164697 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164697 :
164698 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
164699 :
164700 : // Generated constructor
164701 0 : SgElseifDirectiveStatement::SgElseifDirectiveStatement ( Sg_File_Info* startOfConstruct )
164702 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
164703 : {
164704 : #ifdef DEBUG
164705 : // printf ("In SgElseifDirectiveStatement::SgElseifDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
164706 : #endif
164707 : #if 0
164708 : // debugging information!
164709 : printf ("In SgElseifDirectiveStatement::SgElseifDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
164710 : #endif
164711 :
164712 :
164713 :
164714 : #if 0
164715 : // DQ (7/30/2014): Call a virtual function.
164716 : std::string s = this->class_name();
164717 : #endif
164718 :
164719 : // Test the variant virtual function
164720 : // assert(ELSEIF_DIRECTIVE_STMT == variant());
164721 0 : assert(ELSEIF_DIRECTIVE_STMT == this->variant());
164722 0 : ROSE_ASSERT(ELSEIF_DIRECTIVE_STMT == (int)(this->variantT()));
164723 0 : post_construction_initialization();
164724 :
164725 : // Test the isSgElseifDirectiveStatement() function since it has been problematic
164726 0 : assert(isSgElseifDirectiveStatement(this) != NULL);
164727 0 : }
164728 :
164729 : // Generated constructor (all data members)
164730 :
164731 : /* #line 164732 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164732 :
164733 :
164734 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164735 :
164736 :
164737 : // ********************************************************
164738 : // member functions common across all array grammar objects
164739 : // ********************************************************
164740 :
164741 :
164742 :
164743 : /* #line 164744 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164744 :
164745 :
164746 :
164747 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164748 :
164749 : // ********************************************************
164750 : // member functions specific to each node in the grammar
164751 : // ********************************************************
164752 :
164753 :
164754 : /* #line 164755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164755 :
164756 : // Start of memberFunctionString
164757 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
164758 :
164759 : void
164760 0 : SgEndifDirectiveStatement::post_construction_initialization()
164761 : {
164762 0 : }
164763 :
164764 :
164765 :
164766 : // End of memberFunctionString
164767 : // Start of memberFunctionString
164768 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
164769 :
164770 : // *** COMMON CODE SECTION BEGINS HERE ***
164771 :
164772 : #if 0
164773 : int
164774 : SgEndifDirectiveStatement::getVariant() const
164775 : {
164776 : // This function is used in ROSE while "variant()" is used in SAGE
164777 : assert(this != NULL);
164778 : return variant();
164779 : }
164780 : #endif
164781 :
164782 : // This function is used in ROSE in treeTraversal code
164783 : // eventually replaces getVariant() and variant()
164784 : // though after variant() has been removed for a while we will
164785 : // want to change the name of variantT() back to variant()
164786 : // (since the "T" was ment to stand for temporary).
164787 : // When this happens the variantT() will be depricated.
164788 : VariantT
164789 0 : SgEndifDirectiveStatement::variantT() const
164790 : {
164791 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
164792 0 : ROSE_ASSERT(this != NULL);
164793 0 : return V_SgEndifDirectiveStatement;
164794 : }
164795 :
164796 : #if 0
164797 : int
164798 : SgEndifDirectiveStatement::variant() const
164799 : {
164800 : // This function is used in SAGE
164801 : ROSE_ASSERT(this != NULL);
164802 : return ENDIF_DIRECTIVE_STMT;
164803 : }
164804 : #endif
164805 :
164806 : ROSE_DLL_API const char*
164807 0 : SgEndifDirectiveStatement::sage_class_name() const
164808 : {
164809 0 : ROSE_ASSERT(this != NULL);
164810 0 : return "SgEndifDirectiveStatement";
164811 : }
164812 :
164813 : std::string
164814 0 : SgEndifDirectiveStatement::class_name() const
164815 : {
164816 0 : ROSE_ASSERT(this != NULL);
164817 0 : return "SgEndifDirectiveStatement";
164818 : }
164819 :
164820 : // DQ (11/26/2005): Support for visitor pattern mechanims
164821 : // (inferior to ROSE traversal mechanism, experimental).
164822 : void
164823 0 : SgEndifDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
164824 : {
164825 0 : ROSE_ASSERT(this != NULL);
164826 0 : visitor.visit(this);
164827 0 : }
164828 :
164829 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
164830 0 : void SgEndifDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
164831 0 : ROSE_ASSERT(this != NULL);
164832 0 : visitor.visit(this);
164833 0 : }
164834 :
164835 : SgEndifDirectiveStatement*
164836 0 : SgEndifDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
164837 : {
164838 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
164839 : // This function is currently only supported for the AST used the represent Binary executables.
164840 : if (0 /* isSgAsmNode(this) != NULL */)
164841 : {
164842 : // Support for regex specification.
164843 : std::string prefixCode = "REGEX:";
164844 : addNewAttribute(prefixCode + s,a);
164845 : }
164846 : #endif
164847 :
164848 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
164849 0 : return this;
164850 : }
164851 :
164852 : // *** COMMON CODE SECTION ENDS HERE ***
164853 :
164854 :
164855 : // End of memberFunctionString
164856 : // Start of memberFunctionString
164857 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
164858 :
164859 :
164860 : #if 0
164861 : //! Error checking support
164862 : /*! Verifies the following:
164863 : - working getVariant() member function
164864 : - calls base class's error() member function
164865 : Every class has one of these functions.
164866 : */
164867 : bool
164868 : SgEndifDirectiveStatement::error()
164869 : {
164870 : // Put error checking here
164871 :
164872 : ROSE_ASSERT (this != NULL);
164873 : if (getVariant() != ENDIF_DIRECTIVE_STMT)
164874 : {
164875 : printf ("Error in SgEndifDirectiveStatement::error(): SgEndifDirectiveStatement object has a %s variant \n",
164876 : Cxx_GrammarTerminalNames[getVariant()].name);
164877 : // printf ("Error in SgEndifDirectiveStatement::error() \n");
164878 : ROSE_ABORT();
164879 : }
164880 :
164881 : ROSE_ASSERT (getVariant() == ENDIF_DIRECTIVE_STMT);
164882 : return SgC_PreprocessorDirectiveStatement::error();
164883 : }
164884 : #endif
164885 :
164886 :
164887 :
164888 : // End of memberFunctionString
164889 :
164890 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
164891 :
164892 0 : SgEndifDirectiveStatement* isSgEndifDirectiveStatement ( SgNode* inputDerivedClassPointer )
164893 : {
164894 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164895 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164896 : // So to fix this we return NULL directly when the input is NULL and avoid the
164897 : // dynamic_cast in this case. This is likely a performance improvement as well.
164898 : // return dynamic_cast<SgEndifDirectiveStatement*>(inputDerivedClassPointer);
164899 : // Milind Chabbi (8/28/2013): isSgEndifDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164900 : // this improves the running time performance by 10-20%.
164901 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEndifDirectiveStatement*>(inputDerivedClassPointer);
164902 0 : return IS_SgEndifDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164903 : }
164904 :
164905 : // DQ (11/8/2003): Added version of functions taking const pointer
164906 0 : const SgEndifDirectiveStatement* isSgEndifDirectiveStatement ( const SgNode* inputDerivedClassPointer )
164907 : {
164908 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
164909 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
164910 : // So to fix this we return NULL directly when the input is NULL and avoid the
164911 : // dynamic_cast in this case. This is likely a performance improvement as well.
164912 : // return dynamic_cast<const SgEndifDirectiveStatement*>(inputDerivedClassPointer);
164913 : // Milind Chabbi (8/28/2013): isSgEndifDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
164914 : // this improves the running time performance by 10-20%.
164915 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEndifDirectiveStatement*>(inputDerivedClassPointer);
164916 0 : return IS_SgEndifDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
164917 : }
164918 :
164919 :
164920 :
164921 : /* #line 164922 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164922 :
164923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164924 :
164925 : /**
164926 : \brief Generated destructor
164927 :
164928 : This destructor is automatically generated (by ROSETTA). This destructor
164929 : only frees memory of data members associated with the parts of the current IR node which
164930 : are NOT traversed. Those data members that are part of a traversal can be freed using
164931 : a traversal (calling this destructor on all children in a post-order traversal). Such
164932 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
164933 :
164934 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
164935 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
164936 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
164937 :
164938 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
164939 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
164940 : pointers are not yet implemented to call delete on eash pointer in the container.
164941 : (This could be done by derivation from the STL containers to define containers that
164942 : automatically deleted their members.)
164943 :
164944 : */
164945 0 : SgEndifDirectiveStatement::~SgEndifDirectiveStatement () {
164946 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
164947 :
164948 :
164949 :
164950 : }
164951 :
164952 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
164953 0 : }
164954 :
164955 :
164956 : /* #line 164957 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164957 :
164958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
164959 :
164960 : // Generated constructor
164961 0 : SgEndifDirectiveStatement::SgEndifDirectiveStatement ( Sg_File_Info* startOfConstruct )
164962 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
164963 : {
164964 : #ifdef DEBUG
164965 : // printf ("In SgEndifDirectiveStatement::SgEndifDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
164966 : #endif
164967 : #if 0
164968 : // debugging information!
164969 : printf ("In SgEndifDirectiveStatement::SgEndifDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
164970 : #endif
164971 :
164972 :
164973 :
164974 : #if 0
164975 : // DQ (7/30/2014): Call a virtual function.
164976 : std::string s = this->class_name();
164977 : #endif
164978 :
164979 : // Test the variant virtual function
164980 : // assert(ENDIF_DIRECTIVE_STMT == variant());
164981 0 : assert(ENDIF_DIRECTIVE_STMT == this->variant());
164982 0 : ROSE_ASSERT(ENDIF_DIRECTIVE_STMT == (int)(this->variantT()));
164983 0 : post_construction_initialization();
164984 :
164985 : // Test the isSgEndifDirectiveStatement() function since it has been problematic
164986 0 : assert(isSgEndifDirectiveStatement(this) != NULL);
164987 0 : }
164988 :
164989 : // Generated constructor (all data members)
164990 :
164991 : /* #line 164992 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
164992 :
164993 :
164994 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
164995 :
164996 :
164997 : // ********************************************************
164998 : // member functions common across all array grammar objects
164999 : // ********************************************************
165000 :
165001 :
165002 :
165003 : /* #line 165004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165004 :
165005 :
165006 :
165007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165008 :
165009 : // ********************************************************
165010 : // member functions specific to each node in the grammar
165011 : // ********************************************************
165012 :
165013 :
165014 : /* #line 165015 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165015 :
165016 : // Start of memberFunctionString
165017 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
165018 :
165019 : void
165020 0 : SgLineDirectiveStatement::post_construction_initialization()
165021 : {
165022 0 : }
165023 :
165024 :
165025 :
165026 : // End of memberFunctionString
165027 : // Start of memberFunctionString
165028 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
165029 :
165030 : // *** COMMON CODE SECTION BEGINS HERE ***
165031 :
165032 : #if 0
165033 : int
165034 : SgLineDirectiveStatement::getVariant() const
165035 : {
165036 : // This function is used in ROSE while "variant()" is used in SAGE
165037 : assert(this != NULL);
165038 : return variant();
165039 : }
165040 : #endif
165041 :
165042 : // This function is used in ROSE in treeTraversal code
165043 : // eventually replaces getVariant() and variant()
165044 : // though after variant() has been removed for a while we will
165045 : // want to change the name of variantT() back to variant()
165046 : // (since the "T" was ment to stand for temporary).
165047 : // When this happens the variantT() will be depricated.
165048 : VariantT
165049 0 : SgLineDirectiveStatement::variantT() const
165050 : {
165051 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
165052 0 : ROSE_ASSERT(this != NULL);
165053 0 : return V_SgLineDirectiveStatement;
165054 : }
165055 :
165056 : #if 0
165057 : int
165058 : SgLineDirectiveStatement::variant() const
165059 : {
165060 : // This function is used in SAGE
165061 : ROSE_ASSERT(this != NULL);
165062 : return LINE_DIRECTIVE_STMT;
165063 : }
165064 : #endif
165065 :
165066 : ROSE_DLL_API const char*
165067 0 : SgLineDirectiveStatement::sage_class_name() const
165068 : {
165069 0 : ROSE_ASSERT(this != NULL);
165070 0 : return "SgLineDirectiveStatement";
165071 : }
165072 :
165073 : std::string
165074 0 : SgLineDirectiveStatement::class_name() const
165075 : {
165076 0 : ROSE_ASSERT(this != NULL);
165077 0 : return "SgLineDirectiveStatement";
165078 : }
165079 :
165080 : // DQ (11/26/2005): Support for visitor pattern mechanims
165081 : // (inferior to ROSE traversal mechanism, experimental).
165082 : void
165083 0 : SgLineDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
165084 : {
165085 0 : ROSE_ASSERT(this != NULL);
165086 0 : visitor.visit(this);
165087 0 : }
165088 :
165089 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
165090 0 : void SgLineDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
165091 0 : ROSE_ASSERT(this != NULL);
165092 0 : visitor.visit(this);
165093 0 : }
165094 :
165095 : SgLineDirectiveStatement*
165096 0 : SgLineDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
165097 : {
165098 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
165099 : // This function is currently only supported for the AST used the represent Binary executables.
165100 : if (0 /* isSgAsmNode(this) != NULL */)
165101 : {
165102 : // Support for regex specification.
165103 : std::string prefixCode = "REGEX:";
165104 : addNewAttribute(prefixCode + s,a);
165105 : }
165106 : #endif
165107 :
165108 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
165109 0 : return this;
165110 : }
165111 :
165112 : // *** COMMON CODE SECTION ENDS HERE ***
165113 :
165114 :
165115 : // End of memberFunctionString
165116 : // Start of memberFunctionString
165117 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
165118 :
165119 :
165120 : #if 0
165121 : //! Error checking support
165122 : /*! Verifies the following:
165123 : - working getVariant() member function
165124 : - calls base class's error() member function
165125 : Every class has one of these functions.
165126 : */
165127 : bool
165128 : SgLineDirectiveStatement::error()
165129 : {
165130 : // Put error checking here
165131 :
165132 : ROSE_ASSERT (this != NULL);
165133 : if (getVariant() != LINE_DIRECTIVE_STMT)
165134 : {
165135 : printf ("Error in SgLineDirectiveStatement::error(): SgLineDirectiveStatement object has a %s variant \n",
165136 : Cxx_GrammarTerminalNames[getVariant()].name);
165137 : // printf ("Error in SgLineDirectiveStatement::error() \n");
165138 : ROSE_ABORT();
165139 : }
165140 :
165141 : ROSE_ASSERT (getVariant() == LINE_DIRECTIVE_STMT);
165142 : return SgC_PreprocessorDirectiveStatement::error();
165143 : }
165144 : #endif
165145 :
165146 :
165147 :
165148 : // End of memberFunctionString
165149 :
165150 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
165151 :
165152 0 : SgLineDirectiveStatement* isSgLineDirectiveStatement ( SgNode* inputDerivedClassPointer )
165153 : {
165154 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165155 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165156 : // So to fix this we return NULL directly when the input is NULL and avoid the
165157 : // dynamic_cast in this case. This is likely a performance improvement as well.
165158 : // return dynamic_cast<SgLineDirectiveStatement*>(inputDerivedClassPointer);
165159 : // Milind Chabbi (8/28/2013): isSgLineDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165160 : // this improves the running time performance by 10-20%.
165161 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLineDirectiveStatement*>(inputDerivedClassPointer);
165162 0 : return IS_SgLineDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165163 : }
165164 :
165165 : // DQ (11/8/2003): Added version of functions taking const pointer
165166 0 : const SgLineDirectiveStatement* isSgLineDirectiveStatement ( const SgNode* inputDerivedClassPointer )
165167 : {
165168 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165169 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165170 : // So to fix this we return NULL directly when the input is NULL and avoid the
165171 : // dynamic_cast in this case. This is likely a performance improvement as well.
165172 : // return dynamic_cast<const SgLineDirectiveStatement*>(inputDerivedClassPointer);
165173 : // Milind Chabbi (8/28/2013): isSgLineDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165174 : // this improves the running time performance by 10-20%.
165175 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLineDirectiveStatement*>(inputDerivedClassPointer);
165176 0 : return IS_SgLineDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165177 : }
165178 :
165179 :
165180 :
165181 : /* #line 165182 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165182 :
165183 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165184 :
165185 : /**
165186 : \brief Generated destructor
165187 :
165188 : This destructor is automatically generated (by ROSETTA). This destructor
165189 : only frees memory of data members associated with the parts of the current IR node which
165190 : are NOT traversed. Those data members that are part of a traversal can be freed using
165191 : a traversal (calling this destructor on all children in a post-order traversal). Such
165192 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
165193 :
165194 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
165195 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
165196 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
165197 :
165198 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
165199 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
165200 : pointers are not yet implemented to call delete on eash pointer in the container.
165201 : (This could be done by derivation from the STL containers to define containers that
165202 : automatically deleted their members.)
165203 :
165204 : */
165205 0 : SgLineDirectiveStatement::~SgLineDirectiveStatement () {
165206 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
165207 :
165208 :
165209 :
165210 : }
165211 :
165212 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165213 0 : }
165214 :
165215 :
165216 : /* #line 165217 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165217 :
165218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
165219 :
165220 : // Generated constructor
165221 0 : SgLineDirectiveStatement::SgLineDirectiveStatement ( Sg_File_Info* startOfConstruct )
165222 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
165223 : {
165224 : #ifdef DEBUG
165225 : // printf ("In SgLineDirectiveStatement::SgLineDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
165226 : #endif
165227 : #if 0
165228 : // debugging information!
165229 : printf ("In SgLineDirectiveStatement::SgLineDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
165230 : #endif
165231 :
165232 :
165233 :
165234 : #if 0
165235 : // DQ (7/30/2014): Call a virtual function.
165236 : std::string s = this->class_name();
165237 : #endif
165238 :
165239 : // Test the variant virtual function
165240 : // assert(LINE_DIRECTIVE_STMT == variant());
165241 0 : assert(LINE_DIRECTIVE_STMT == this->variant());
165242 0 : ROSE_ASSERT(LINE_DIRECTIVE_STMT == (int)(this->variantT()));
165243 0 : post_construction_initialization();
165244 :
165245 : // Test the isSgLineDirectiveStatement() function since it has been problematic
165246 0 : assert(isSgLineDirectiveStatement(this) != NULL);
165247 0 : }
165248 :
165249 : // Generated constructor (all data members)
165250 :
165251 : /* #line 165252 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165252 :
165253 :
165254 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165255 :
165256 :
165257 : // ********************************************************
165258 : // member functions common across all array grammar objects
165259 : // ********************************************************
165260 :
165261 :
165262 :
165263 : /* #line 165264 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165264 :
165265 :
165266 :
165267 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165268 :
165269 : // ********************************************************
165270 : // member functions specific to each node in the grammar
165271 : // ********************************************************
165272 :
165273 :
165274 : /* #line 165275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165275 :
165276 : // Start of memberFunctionString
165277 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
165278 :
165279 : void
165280 0 : SgWarningDirectiveStatement::post_construction_initialization()
165281 : {
165282 0 : }
165283 :
165284 :
165285 :
165286 : // End of memberFunctionString
165287 : // Start of memberFunctionString
165288 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
165289 :
165290 : // *** COMMON CODE SECTION BEGINS HERE ***
165291 :
165292 : #if 0
165293 : int
165294 : SgWarningDirectiveStatement::getVariant() const
165295 : {
165296 : // This function is used in ROSE while "variant()" is used in SAGE
165297 : assert(this != NULL);
165298 : return variant();
165299 : }
165300 : #endif
165301 :
165302 : // This function is used in ROSE in treeTraversal code
165303 : // eventually replaces getVariant() and variant()
165304 : // though after variant() has been removed for a while we will
165305 : // want to change the name of variantT() back to variant()
165306 : // (since the "T" was ment to stand for temporary).
165307 : // When this happens the variantT() will be depricated.
165308 : VariantT
165309 0 : SgWarningDirectiveStatement::variantT() const
165310 : {
165311 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
165312 0 : ROSE_ASSERT(this != NULL);
165313 0 : return V_SgWarningDirectiveStatement;
165314 : }
165315 :
165316 : #if 0
165317 : int
165318 : SgWarningDirectiveStatement::variant() const
165319 : {
165320 : // This function is used in SAGE
165321 : ROSE_ASSERT(this != NULL);
165322 : return WARNING_DIRECTIVE_STMT;
165323 : }
165324 : #endif
165325 :
165326 : ROSE_DLL_API const char*
165327 0 : SgWarningDirectiveStatement::sage_class_name() const
165328 : {
165329 0 : ROSE_ASSERT(this != NULL);
165330 0 : return "SgWarningDirectiveStatement";
165331 : }
165332 :
165333 : std::string
165334 0 : SgWarningDirectiveStatement::class_name() const
165335 : {
165336 0 : ROSE_ASSERT(this != NULL);
165337 0 : return "SgWarningDirectiveStatement";
165338 : }
165339 :
165340 : // DQ (11/26/2005): Support for visitor pattern mechanims
165341 : // (inferior to ROSE traversal mechanism, experimental).
165342 : void
165343 0 : SgWarningDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
165344 : {
165345 0 : ROSE_ASSERT(this != NULL);
165346 0 : visitor.visit(this);
165347 0 : }
165348 :
165349 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
165350 0 : void SgWarningDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
165351 0 : ROSE_ASSERT(this != NULL);
165352 0 : visitor.visit(this);
165353 0 : }
165354 :
165355 : SgWarningDirectiveStatement*
165356 0 : SgWarningDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
165357 : {
165358 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
165359 : // This function is currently only supported for the AST used the represent Binary executables.
165360 : if (0 /* isSgAsmNode(this) != NULL */)
165361 : {
165362 : // Support for regex specification.
165363 : std::string prefixCode = "REGEX:";
165364 : addNewAttribute(prefixCode + s,a);
165365 : }
165366 : #endif
165367 :
165368 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
165369 0 : return this;
165370 : }
165371 :
165372 : // *** COMMON CODE SECTION ENDS HERE ***
165373 :
165374 :
165375 : // End of memberFunctionString
165376 : // Start of memberFunctionString
165377 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
165378 :
165379 :
165380 : #if 0
165381 : //! Error checking support
165382 : /*! Verifies the following:
165383 : - working getVariant() member function
165384 : - calls base class's error() member function
165385 : Every class has one of these functions.
165386 : */
165387 : bool
165388 : SgWarningDirectiveStatement::error()
165389 : {
165390 : // Put error checking here
165391 :
165392 : ROSE_ASSERT (this != NULL);
165393 : if (getVariant() != WARNING_DIRECTIVE_STMT)
165394 : {
165395 : printf ("Error in SgWarningDirectiveStatement::error(): SgWarningDirectiveStatement object has a %s variant \n",
165396 : Cxx_GrammarTerminalNames[getVariant()].name);
165397 : // printf ("Error in SgWarningDirectiveStatement::error() \n");
165398 : ROSE_ABORT();
165399 : }
165400 :
165401 : ROSE_ASSERT (getVariant() == WARNING_DIRECTIVE_STMT);
165402 : return SgC_PreprocessorDirectiveStatement::error();
165403 : }
165404 : #endif
165405 :
165406 :
165407 :
165408 : // End of memberFunctionString
165409 :
165410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
165411 :
165412 0 : SgWarningDirectiveStatement* isSgWarningDirectiveStatement ( SgNode* inputDerivedClassPointer )
165413 : {
165414 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165415 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165416 : // So to fix this we return NULL directly when the input is NULL and avoid the
165417 : // dynamic_cast in this case. This is likely a performance improvement as well.
165418 : // return dynamic_cast<SgWarningDirectiveStatement*>(inputDerivedClassPointer);
165419 : // Milind Chabbi (8/28/2013): isSgWarningDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165420 : // this improves the running time performance by 10-20%.
165421 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWarningDirectiveStatement*>(inputDerivedClassPointer);
165422 0 : return IS_SgWarningDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165423 : }
165424 :
165425 : // DQ (11/8/2003): Added version of functions taking const pointer
165426 0 : const SgWarningDirectiveStatement* isSgWarningDirectiveStatement ( const SgNode* inputDerivedClassPointer )
165427 : {
165428 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165429 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165430 : // So to fix this we return NULL directly when the input is NULL and avoid the
165431 : // dynamic_cast in this case. This is likely a performance improvement as well.
165432 : // return dynamic_cast<const SgWarningDirectiveStatement*>(inputDerivedClassPointer);
165433 : // Milind Chabbi (8/28/2013): isSgWarningDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165434 : // this improves the running time performance by 10-20%.
165435 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWarningDirectiveStatement*>(inputDerivedClassPointer);
165436 0 : return IS_SgWarningDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165437 : }
165438 :
165439 :
165440 :
165441 : /* #line 165442 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165442 :
165443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165444 :
165445 : /**
165446 : \brief Generated destructor
165447 :
165448 : This destructor is automatically generated (by ROSETTA). This destructor
165449 : only frees memory of data members associated with the parts of the current IR node which
165450 : are NOT traversed. Those data members that are part of a traversal can be freed using
165451 : a traversal (calling this destructor on all children in a post-order traversal). Such
165452 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
165453 :
165454 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
165455 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
165456 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
165457 :
165458 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
165459 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
165460 : pointers are not yet implemented to call delete on eash pointer in the container.
165461 : (This could be done by derivation from the STL containers to define containers that
165462 : automatically deleted their members.)
165463 :
165464 : */
165465 0 : SgWarningDirectiveStatement::~SgWarningDirectiveStatement () {
165466 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
165467 :
165468 :
165469 :
165470 : }
165471 :
165472 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165473 0 : }
165474 :
165475 :
165476 : /* #line 165477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165477 :
165478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
165479 :
165480 : // Generated constructor
165481 0 : SgWarningDirectiveStatement::SgWarningDirectiveStatement ( Sg_File_Info* startOfConstruct )
165482 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
165483 : {
165484 : #ifdef DEBUG
165485 : // printf ("In SgWarningDirectiveStatement::SgWarningDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
165486 : #endif
165487 : #if 0
165488 : // debugging information!
165489 : printf ("In SgWarningDirectiveStatement::SgWarningDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
165490 : #endif
165491 :
165492 :
165493 :
165494 : #if 0
165495 : // DQ (7/30/2014): Call a virtual function.
165496 : std::string s = this->class_name();
165497 : #endif
165498 :
165499 : // Test the variant virtual function
165500 : // assert(WARNING_DIRECTIVE_STMT == variant());
165501 0 : assert(WARNING_DIRECTIVE_STMT == this->variant());
165502 0 : ROSE_ASSERT(WARNING_DIRECTIVE_STMT == (int)(this->variantT()));
165503 0 : post_construction_initialization();
165504 :
165505 : // Test the isSgWarningDirectiveStatement() function since it has been problematic
165506 0 : assert(isSgWarningDirectiveStatement(this) != NULL);
165507 0 : }
165508 :
165509 : // Generated constructor (all data members)
165510 :
165511 : /* #line 165512 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165512 :
165513 :
165514 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165515 :
165516 :
165517 : // ********************************************************
165518 : // member functions common across all array grammar objects
165519 : // ********************************************************
165520 :
165521 :
165522 :
165523 : /* #line 165524 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165524 :
165525 :
165526 :
165527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165528 :
165529 : // ********************************************************
165530 : // member functions specific to each node in the grammar
165531 : // ********************************************************
165532 :
165533 :
165534 : /* #line 165535 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165535 :
165536 : // Start of memberFunctionString
165537 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
165538 :
165539 : void
165540 0 : SgErrorDirectiveStatement::post_construction_initialization()
165541 : {
165542 0 : }
165543 :
165544 :
165545 :
165546 : // End of memberFunctionString
165547 : // Start of memberFunctionString
165548 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
165549 :
165550 : // *** COMMON CODE SECTION BEGINS HERE ***
165551 :
165552 : #if 0
165553 : int
165554 : SgErrorDirectiveStatement::getVariant() const
165555 : {
165556 : // This function is used in ROSE while "variant()" is used in SAGE
165557 : assert(this != NULL);
165558 : return variant();
165559 : }
165560 : #endif
165561 :
165562 : // This function is used in ROSE in treeTraversal code
165563 : // eventually replaces getVariant() and variant()
165564 : // though after variant() has been removed for a while we will
165565 : // want to change the name of variantT() back to variant()
165566 : // (since the "T" was ment to stand for temporary).
165567 : // When this happens the variantT() will be depricated.
165568 : VariantT
165569 0 : SgErrorDirectiveStatement::variantT() const
165570 : {
165571 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
165572 0 : ROSE_ASSERT(this != NULL);
165573 0 : return V_SgErrorDirectiveStatement;
165574 : }
165575 :
165576 : #if 0
165577 : int
165578 : SgErrorDirectiveStatement::variant() const
165579 : {
165580 : // This function is used in SAGE
165581 : ROSE_ASSERT(this != NULL);
165582 : return ERROR_DIRECTIVE_STMT;
165583 : }
165584 : #endif
165585 :
165586 : ROSE_DLL_API const char*
165587 0 : SgErrorDirectiveStatement::sage_class_name() const
165588 : {
165589 0 : ROSE_ASSERT(this != NULL);
165590 0 : return "SgErrorDirectiveStatement";
165591 : }
165592 :
165593 : std::string
165594 0 : SgErrorDirectiveStatement::class_name() const
165595 : {
165596 0 : ROSE_ASSERT(this != NULL);
165597 0 : return "SgErrorDirectiveStatement";
165598 : }
165599 :
165600 : // DQ (11/26/2005): Support for visitor pattern mechanims
165601 : // (inferior to ROSE traversal mechanism, experimental).
165602 : void
165603 0 : SgErrorDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
165604 : {
165605 0 : ROSE_ASSERT(this != NULL);
165606 0 : visitor.visit(this);
165607 0 : }
165608 :
165609 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
165610 0 : void SgErrorDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
165611 0 : ROSE_ASSERT(this != NULL);
165612 0 : visitor.visit(this);
165613 0 : }
165614 :
165615 : SgErrorDirectiveStatement*
165616 0 : SgErrorDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
165617 : {
165618 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
165619 : // This function is currently only supported for the AST used the represent Binary executables.
165620 : if (0 /* isSgAsmNode(this) != NULL */)
165621 : {
165622 : // Support for regex specification.
165623 : std::string prefixCode = "REGEX:";
165624 : addNewAttribute(prefixCode + s,a);
165625 : }
165626 : #endif
165627 :
165628 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
165629 0 : return this;
165630 : }
165631 :
165632 : // *** COMMON CODE SECTION ENDS HERE ***
165633 :
165634 :
165635 : // End of memberFunctionString
165636 : // Start of memberFunctionString
165637 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
165638 :
165639 :
165640 : #if 0
165641 : //! Error checking support
165642 : /*! Verifies the following:
165643 : - working getVariant() member function
165644 : - calls base class's error() member function
165645 : Every class has one of these functions.
165646 : */
165647 : bool
165648 : SgErrorDirectiveStatement::error()
165649 : {
165650 : // Put error checking here
165651 :
165652 : ROSE_ASSERT (this != NULL);
165653 : if (getVariant() != ERROR_DIRECTIVE_STMT)
165654 : {
165655 : printf ("Error in SgErrorDirectiveStatement::error(): SgErrorDirectiveStatement object has a %s variant \n",
165656 : Cxx_GrammarTerminalNames[getVariant()].name);
165657 : // printf ("Error in SgErrorDirectiveStatement::error() \n");
165658 : ROSE_ABORT();
165659 : }
165660 :
165661 : ROSE_ASSERT (getVariant() == ERROR_DIRECTIVE_STMT);
165662 : return SgC_PreprocessorDirectiveStatement::error();
165663 : }
165664 : #endif
165665 :
165666 :
165667 :
165668 : // End of memberFunctionString
165669 :
165670 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
165671 :
165672 0 : SgErrorDirectiveStatement* isSgErrorDirectiveStatement ( SgNode* inputDerivedClassPointer )
165673 : {
165674 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165675 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165676 : // So to fix this we return NULL directly when the input is NULL and avoid the
165677 : // dynamic_cast in this case. This is likely a performance improvement as well.
165678 : // return dynamic_cast<SgErrorDirectiveStatement*>(inputDerivedClassPointer);
165679 : // Milind Chabbi (8/28/2013): isSgErrorDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165680 : // this improves the running time performance by 10-20%.
165681 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgErrorDirectiveStatement*>(inputDerivedClassPointer);
165682 0 : return IS_SgErrorDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165683 : }
165684 :
165685 : // DQ (11/8/2003): Added version of functions taking const pointer
165686 0 : const SgErrorDirectiveStatement* isSgErrorDirectiveStatement ( const SgNode* inputDerivedClassPointer )
165687 : {
165688 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165689 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165690 : // So to fix this we return NULL directly when the input is NULL and avoid the
165691 : // dynamic_cast in this case. This is likely a performance improvement as well.
165692 : // return dynamic_cast<const SgErrorDirectiveStatement*>(inputDerivedClassPointer);
165693 : // Milind Chabbi (8/28/2013): isSgErrorDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165694 : // this improves the running time performance by 10-20%.
165695 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgErrorDirectiveStatement*>(inputDerivedClassPointer);
165696 0 : return IS_SgErrorDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165697 : }
165698 :
165699 :
165700 :
165701 : /* #line 165702 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165702 :
165703 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165704 :
165705 : /**
165706 : \brief Generated destructor
165707 :
165708 : This destructor is automatically generated (by ROSETTA). This destructor
165709 : only frees memory of data members associated with the parts of the current IR node which
165710 : are NOT traversed. Those data members that are part of a traversal can be freed using
165711 : a traversal (calling this destructor on all children in a post-order traversal). Such
165712 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
165713 :
165714 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
165715 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
165716 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
165717 :
165718 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
165719 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
165720 : pointers are not yet implemented to call delete on eash pointer in the container.
165721 : (This could be done by derivation from the STL containers to define containers that
165722 : automatically deleted their members.)
165723 :
165724 : */
165725 0 : SgErrorDirectiveStatement::~SgErrorDirectiveStatement () {
165726 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
165727 :
165728 :
165729 :
165730 : }
165731 :
165732 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165733 0 : }
165734 :
165735 :
165736 : /* #line 165737 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165737 :
165738 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
165739 :
165740 : // Generated constructor
165741 0 : SgErrorDirectiveStatement::SgErrorDirectiveStatement ( Sg_File_Info* startOfConstruct )
165742 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
165743 : {
165744 : #ifdef DEBUG
165745 : // printf ("In SgErrorDirectiveStatement::SgErrorDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
165746 : #endif
165747 : #if 0
165748 : // debugging information!
165749 : printf ("In SgErrorDirectiveStatement::SgErrorDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
165750 : #endif
165751 :
165752 :
165753 :
165754 : #if 0
165755 : // DQ (7/30/2014): Call a virtual function.
165756 : std::string s = this->class_name();
165757 : #endif
165758 :
165759 : // Test the variant virtual function
165760 : // assert(ERROR_DIRECTIVE_STMT == variant());
165761 0 : assert(ERROR_DIRECTIVE_STMT == this->variant());
165762 0 : ROSE_ASSERT(ERROR_DIRECTIVE_STMT == (int)(this->variantT()));
165763 0 : post_construction_initialization();
165764 :
165765 : // Test the isSgErrorDirectiveStatement() function since it has been problematic
165766 0 : assert(isSgErrorDirectiveStatement(this) != NULL);
165767 0 : }
165768 :
165769 : // Generated constructor (all data members)
165770 :
165771 : /* #line 165772 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165772 :
165773 :
165774 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165775 :
165776 :
165777 : // ********************************************************
165778 : // member functions common across all array grammar objects
165779 : // ********************************************************
165780 :
165781 :
165782 :
165783 : /* #line 165784 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165784 :
165785 :
165786 :
165787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
165788 :
165789 : // ********************************************************
165790 : // member functions specific to each node in the grammar
165791 : // ********************************************************
165792 :
165793 :
165794 : /* #line 165795 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165795 :
165796 : // Start of memberFunctionString
165797 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
165798 :
165799 : void
165800 0 : SgEmptyDirectiveStatement::post_construction_initialization()
165801 : {
165802 0 : }
165803 :
165804 :
165805 :
165806 : // End of memberFunctionString
165807 : // Start of memberFunctionString
165808 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
165809 :
165810 : // *** COMMON CODE SECTION BEGINS HERE ***
165811 :
165812 : #if 0
165813 : int
165814 : SgEmptyDirectiveStatement::getVariant() const
165815 : {
165816 : // This function is used in ROSE while "variant()" is used in SAGE
165817 : assert(this != NULL);
165818 : return variant();
165819 : }
165820 : #endif
165821 :
165822 : // This function is used in ROSE in treeTraversal code
165823 : // eventually replaces getVariant() and variant()
165824 : // though after variant() has been removed for a while we will
165825 : // want to change the name of variantT() back to variant()
165826 : // (since the "T" was ment to stand for temporary).
165827 : // When this happens the variantT() will be depricated.
165828 : VariantT
165829 0 : SgEmptyDirectiveStatement::variantT() const
165830 : {
165831 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
165832 0 : ROSE_ASSERT(this != NULL);
165833 0 : return V_SgEmptyDirectiveStatement;
165834 : }
165835 :
165836 : #if 0
165837 : int
165838 : SgEmptyDirectiveStatement::variant() const
165839 : {
165840 : // This function is used in SAGE
165841 : ROSE_ASSERT(this != NULL);
165842 : return EMPTY_DIRECTIVE_STMT;
165843 : }
165844 : #endif
165845 :
165846 : ROSE_DLL_API const char*
165847 0 : SgEmptyDirectiveStatement::sage_class_name() const
165848 : {
165849 0 : ROSE_ASSERT(this != NULL);
165850 0 : return "SgEmptyDirectiveStatement";
165851 : }
165852 :
165853 : std::string
165854 0 : SgEmptyDirectiveStatement::class_name() const
165855 : {
165856 0 : ROSE_ASSERT(this != NULL);
165857 0 : return "SgEmptyDirectiveStatement";
165858 : }
165859 :
165860 : // DQ (11/26/2005): Support for visitor pattern mechanims
165861 : // (inferior to ROSE traversal mechanism, experimental).
165862 : void
165863 0 : SgEmptyDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
165864 : {
165865 0 : ROSE_ASSERT(this != NULL);
165866 0 : visitor.visit(this);
165867 0 : }
165868 :
165869 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
165870 0 : void SgEmptyDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
165871 0 : ROSE_ASSERT(this != NULL);
165872 0 : visitor.visit(this);
165873 0 : }
165874 :
165875 : SgEmptyDirectiveStatement*
165876 0 : SgEmptyDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
165877 : {
165878 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
165879 : // This function is currently only supported for the AST used the represent Binary executables.
165880 : if (0 /* isSgAsmNode(this) != NULL */)
165881 : {
165882 : // Support for regex specification.
165883 : std::string prefixCode = "REGEX:";
165884 : addNewAttribute(prefixCode + s,a);
165885 : }
165886 : #endif
165887 :
165888 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
165889 0 : return this;
165890 : }
165891 :
165892 : // *** COMMON CODE SECTION ENDS HERE ***
165893 :
165894 :
165895 : // End of memberFunctionString
165896 : // Start of memberFunctionString
165897 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
165898 :
165899 :
165900 : #if 0
165901 : //! Error checking support
165902 : /*! Verifies the following:
165903 : - working getVariant() member function
165904 : - calls base class's error() member function
165905 : Every class has one of these functions.
165906 : */
165907 : bool
165908 : SgEmptyDirectiveStatement::error()
165909 : {
165910 : // Put error checking here
165911 :
165912 : ROSE_ASSERT (this != NULL);
165913 : if (getVariant() != EMPTY_DIRECTIVE_STMT)
165914 : {
165915 : printf ("Error in SgEmptyDirectiveStatement::error(): SgEmptyDirectiveStatement object has a %s variant \n",
165916 : Cxx_GrammarTerminalNames[getVariant()].name);
165917 : // printf ("Error in SgEmptyDirectiveStatement::error() \n");
165918 : ROSE_ABORT();
165919 : }
165920 :
165921 : ROSE_ASSERT (getVariant() == EMPTY_DIRECTIVE_STMT);
165922 : return SgC_PreprocessorDirectiveStatement::error();
165923 : }
165924 : #endif
165925 :
165926 :
165927 :
165928 : // End of memberFunctionString
165929 :
165930 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
165931 :
165932 0 : SgEmptyDirectiveStatement* isSgEmptyDirectiveStatement ( SgNode* inputDerivedClassPointer )
165933 : {
165934 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165935 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165936 : // So to fix this we return NULL directly when the input is NULL and avoid the
165937 : // dynamic_cast in this case. This is likely a performance improvement as well.
165938 : // return dynamic_cast<SgEmptyDirectiveStatement*>(inputDerivedClassPointer);
165939 : // Milind Chabbi (8/28/2013): isSgEmptyDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165940 : // this improves the running time performance by 10-20%.
165941 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEmptyDirectiveStatement*>(inputDerivedClassPointer);
165942 0 : return IS_SgEmptyDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165943 : }
165944 :
165945 : // DQ (11/8/2003): Added version of functions taking const pointer
165946 0 : const SgEmptyDirectiveStatement* isSgEmptyDirectiveStatement ( const SgNode* inputDerivedClassPointer )
165947 : {
165948 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
165949 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
165950 : // So to fix this we return NULL directly when the input is NULL and avoid the
165951 : // dynamic_cast in this case. This is likely a performance improvement as well.
165952 : // return dynamic_cast<const SgEmptyDirectiveStatement*>(inputDerivedClassPointer);
165953 : // Milind Chabbi (8/28/2013): isSgEmptyDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
165954 : // this improves the running time performance by 10-20%.
165955 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEmptyDirectiveStatement*>(inputDerivedClassPointer);
165956 0 : return IS_SgEmptyDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
165957 : }
165958 :
165959 :
165960 :
165961 : /* #line 165962 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165962 :
165963 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165964 :
165965 : /**
165966 : \brief Generated destructor
165967 :
165968 : This destructor is automatically generated (by ROSETTA). This destructor
165969 : only frees memory of data members associated with the parts of the current IR node which
165970 : are NOT traversed. Those data members that are part of a traversal can be freed using
165971 : a traversal (calling this destructor on all children in a post-order traversal). Such
165972 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
165973 :
165974 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
165975 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
165976 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
165977 :
165978 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
165979 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
165980 : pointers are not yet implemented to call delete on eash pointer in the container.
165981 : (This could be done by derivation from the STL containers to define containers that
165982 : automatically deleted their members.)
165983 :
165984 : */
165985 0 : SgEmptyDirectiveStatement::~SgEmptyDirectiveStatement () {
165986 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
165987 :
165988 :
165989 :
165990 : }
165991 :
165992 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
165993 0 : }
165994 :
165995 :
165996 : /* #line 165997 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
165997 :
165998 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
165999 :
166000 : // Generated constructor
166001 0 : SgEmptyDirectiveStatement::SgEmptyDirectiveStatement ( Sg_File_Info* startOfConstruct )
166002 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
166003 : {
166004 : #ifdef DEBUG
166005 : // printf ("In SgEmptyDirectiveStatement::SgEmptyDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
166006 : #endif
166007 : #if 0
166008 : // debugging information!
166009 : printf ("In SgEmptyDirectiveStatement::SgEmptyDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
166010 : #endif
166011 :
166012 :
166013 :
166014 : #if 0
166015 : // DQ (7/30/2014): Call a virtual function.
166016 : std::string s = this->class_name();
166017 : #endif
166018 :
166019 : // Test the variant virtual function
166020 : // assert(EMPTY_DIRECTIVE_STMT == variant());
166021 0 : assert(EMPTY_DIRECTIVE_STMT == this->variant());
166022 0 : ROSE_ASSERT(EMPTY_DIRECTIVE_STMT == (int)(this->variantT()));
166023 0 : post_construction_initialization();
166024 :
166025 : // Test the isSgEmptyDirectiveStatement() function since it has been problematic
166026 0 : assert(isSgEmptyDirectiveStatement(this) != NULL);
166027 0 : }
166028 :
166029 : // Generated constructor (all data members)
166030 :
166031 : /* #line 166032 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166032 :
166033 :
166034 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166035 :
166036 :
166037 : // ********************************************************
166038 : // member functions common across all array grammar objects
166039 : // ********************************************************
166040 :
166041 :
166042 :
166043 : /* #line 166044 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166044 :
166045 :
166046 :
166047 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166048 :
166049 : // ********************************************************
166050 : // member functions specific to each node in the grammar
166051 : // ********************************************************
166052 :
166053 :
166054 : /* #line 166055 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166055 :
166056 : // Start of memberFunctionString
166057 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
166058 :
166059 : void
166060 0 : SgIncludeNextDirectiveStatement::post_construction_initialization()
166061 : {
166062 0 : }
166063 :
166064 :
166065 :
166066 : // End of memberFunctionString
166067 : // Start of memberFunctionString
166068 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
166069 :
166070 : // *** COMMON CODE SECTION BEGINS HERE ***
166071 :
166072 : #if 0
166073 : int
166074 : SgIncludeNextDirectiveStatement::getVariant() const
166075 : {
166076 : // This function is used in ROSE while "variant()" is used in SAGE
166077 : assert(this != NULL);
166078 : return variant();
166079 : }
166080 : #endif
166081 :
166082 : // This function is used in ROSE in treeTraversal code
166083 : // eventually replaces getVariant() and variant()
166084 : // though after variant() has been removed for a while we will
166085 : // want to change the name of variantT() back to variant()
166086 : // (since the "T" was ment to stand for temporary).
166087 : // When this happens the variantT() will be depricated.
166088 : VariantT
166089 0 : SgIncludeNextDirectiveStatement::variantT() const
166090 : {
166091 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
166092 0 : ROSE_ASSERT(this != NULL);
166093 0 : return V_SgIncludeNextDirectiveStatement;
166094 : }
166095 :
166096 : #if 0
166097 : int
166098 : SgIncludeNextDirectiveStatement::variant() const
166099 : {
166100 : // This function is used in SAGE
166101 : ROSE_ASSERT(this != NULL);
166102 : return INCLUDE_NEXT_DIRECTIVE_STMT;
166103 : }
166104 : #endif
166105 :
166106 : ROSE_DLL_API const char*
166107 0 : SgIncludeNextDirectiveStatement::sage_class_name() const
166108 : {
166109 0 : ROSE_ASSERT(this != NULL);
166110 0 : return "SgIncludeNextDirectiveStatement";
166111 : }
166112 :
166113 : std::string
166114 0 : SgIncludeNextDirectiveStatement::class_name() const
166115 : {
166116 0 : ROSE_ASSERT(this != NULL);
166117 0 : return "SgIncludeNextDirectiveStatement";
166118 : }
166119 :
166120 : // DQ (11/26/2005): Support for visitor pattern mechanims
166121 : // (inferior to ROSE traversal mechanism, experimental).
166122 : void
166123 0 : SgIncludeNextDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
166124 : {
166125 0 : ROSE_ASSERT(this != NULL);
166126 0 : visitor.visit(this);
166127 0 : }
166128 :
166129 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
166130 0 : void SgIncludeNextDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
166131 0 : ROSE_ASSERT(this != NULL);
166132 0 : visitor.visit(this);
166133 0 : }
166134 :
166135 : SgIncludeNextDirectiveStatement*
166136 0 : SgIncludeNextDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
166137 : {
166138 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
166139 : // This function is currently only supported for the AST used the represent Binary executables.
166140 : if (0 /* isSgAsmNode(this) != NULL */)
166141 : {
166142 : // Support for regex specification.
166143 : std::string prefixCode = "REGEX:";
166144 : addNewAttribute(prefixCode + s,a);
166145 : }
166146 : #endif
166147 :
166148 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
166149 0 : return this;
166150 : }
166151 :
166152 : // *** COMMON CODE SECTION ENDS HERE ***
166153 :
166154 :
166155 : // End of memberFunctionString
166156 : // Start of memberFunctionString
166157 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
166158 :
166159 :
166160 : #if 0
166161 : //! Error checking support
166162 : /*! Verifies the following:
166163 : - working getVariant() member function
166164 : - calls base class's error() member function
166165 : Every class has one of these functions.
166166 : */
166167 : bool
166168 : SgIncludeNextDirectiveStatement::error()
166169 : {
166170 : // Put error checking here
166171 :
166172 : ROSE_ASSERT (this != NULL);
166173 : if (getVariant() != INCLUDE_NEXT_DIRECTIVE_STMT)
166174 : {
166175 : printf ("Error in SgIncludeNextDirectiveStatement::error(): SgIncludeNextDirectiveStatement object has a %s variant \n",
166176 : Cxx_GrammarTerminalNames[getVariant()].name);
166177 : // printf ("Error in SgIncludeNextDirectiveStatement::error() \n");
166178 : ROSE_ABORT();
166179 : }
166180 :
166181 : ROSE_ASSERT (getVariant() == INCLUDE_NEXT_DIRECTIVE_STMT);
166182 : return SgC_PreprocessorDirectiveStatement::error();
166183 : }
166184 : #endif
166185 :
166186 :
166187 :
166188 : // End of memberFunctionString
166189 :
166190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
166191 :
166192 0 : SgIncludeNextDirectiveStatement* isSgIncludeNextDirectiveStatement ( SgNode* inputDerivedClassPointer )
166193 : {
166194 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
166195 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
166196 : // So to fix this we return NULL directly when the input is NULL and avoid the
166197 : // dynamic_cast in this case. This is likely a performance improvement as well.
166198 : // return dynamic_cast<SgIncludeNextDirectiveStatement*>(inputDerivedClassPointer);
166199 : // Milind Chabbi (8/28/2013): isSgIncludeNextDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
166200 : // this improves the running time performance by 10-20%.
166201 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIncludeNextDirectiveStatement*>(inputDerivedClassPointer);
166202 0 : return IS_SgIncludeNextDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
166203 : }
166204 :
166205 : // DQ (11/8/2003): Added version of functions taking const pointer
166206 0 : const SgIncludeNextDirectiveStatement* isSgIncludeNextDirectiveStatement ( const SgNode* inputDerivedClassPointer )
166207 : {
166208 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
166209 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
166210 : // So to fix this we return NULL directly when the input is NULL and avoid the
166211 : // dynamic_cast in this case. This is likely a performance improvement as well.
166212 : // return dynamic_cast<const SgIncludeNextDirectiveStatement*>(inputDerivedClassPointer);
166213 : // Milind Chabbi (8/28/2013): isSgIncludeNextDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
166214 : // this improves the running time performance by 10-20%.
166215 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIncludeNextDirectiveStatement*>(inputDerivedClassPointer);
166216 0 : return IS_SgIncludeNextDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
166217 : }
166218 :
166219 :
166220 :
166221 : /* #line 166222 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166222 :
166223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
166224 :
166225 : /**
166226 : \brief Generated destructor
166227 :
166228 : This destructor is automatically generated (by ROSETTA). This destructor
166229 : only frees memory of data members associated with the parts of the current IR node which
166230 : are NOT traversed. Those data members that are part of a traversal can be freed using
166231 : a traversal (calling this destructor on all children in a post-order traversal). Such
166232 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
166233 :
166234 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
166235 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
166236 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
166237 :
166238 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
166239 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
166240 : pointers are not yet implemented to call delete on eash pointer in the container.
166241 : (This could be done by derivation from the STL containers to define containers that
166242 : automatically deleted their members.)
166243 :
166244 : */
166245 0 : SgIncludeNextDirectiveStatement::~SgIncludeNextDirectiveStatement () {
166246 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
166247 :
166248 :
166249 :
166250 : }
166251 :
166252 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
166253 0 : }
166254 :
166255 :
166256 : /* #line 166257 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166257 :
166258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
166259 :
166260 : // Generated constructor
166261 0 : SgIncludeNextDirectiveStatement::SgIncludeNextDirectiveStatement ( Sg_File_Info* startOfConstruct )
166262 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
166263 : {
166264 : #ifdef DEBUG
166265 : // printf ("In SgIncludeNextDirectiveStatement::SgIncludeNextDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
166266 : #endif
166267 : #if 0
166268 : // debugging information!
166269 : printf ("In SgIncludeNextDirectiveStatement::SgIncludeNextDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
166270 : #endif
166271 :
166272 :
166273 :
166274 : #if 0
166275 : // DQ (7/30/2014): Call a virtual function.
166276 : std::string s = this->class_name();
166277 : #endif
166278 :
166279 : // Test the variant virtual function
166280 : // assert(INCLUDE_NEXT_DIRECTIVE_STMT == variant());
166281 0 : assert(INCLUDE_NEXT_DIRECTIVE_STMT == this->variant());
166282 0 : ROSE_ASSERT(INCLUDE_NEXT_DIRECTIVE_STMT == (int)(this->variantT()));
166283 0 : post_construction_initialization();
166284 :
166285 : // Test the isSgIncludeNextDirectiveStatement() function since it has been problematic
166286 0 : assert(isSgIncludeNextDirectiveStatement(this) != NULL);
166287 0 : }
166288 :
166289 : // Generated constructor (all data members)
166290 :
166291 : /* #line 166292 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166292 :
166293 :
166294 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166295 :
166296 :
166297 : // ********************************************************
166298 : // member functions common across all array grammar objects
166299 : // ********************************************************
166300 :
166301 :
166302 :
166303 : /* #line 166304 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166304 :
166305 :
166306 :
166307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166308 :
166309 : // ********************************************************
166310 : // member functions specific to each node in the grammar
166311 : // ********************************************************
166312 :
166313 :
166314 : /* #line 166315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166315 :
166316 : // Start of memberFunctionString
166317 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
166318 :
166319 : void
166320 0 : SgIdentDirectiveStatement::post_construction_initialization()
166321 : {
166322 0 : }
166323 :
166324 :
166325 :
166326 : // End of memberFunctionString
166327 : // Start of memberFunctionString
166328 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
166329 :
166330 : // *** COMMON CODE SECTION BEGINS HERE ***
166331 :
166332 : #if 0
166333 : int
166334 : SgIdentDirectiveStatement::getVariant() const
166335 : {
166336 : // This function is used in ROSE while "variant()" is used in SAGE
166337 : assert(this != NULL);
166338 : return variant();
166339 : }
166340 : #endif
166341 :
166342 : // This function is used in ROSE in treeTraversal code
166343 : // eventually replaces getVariant() and variant()
166344 : // though after variant() has been removed for a while we will
166345 : // want to change the name of variantT() back to variant()
166346 : // (since the "T" was ment to stand for temporary).
166347 : // When this happens the variantT() will be depricated.
166348 : VariantT
166349 0 : SgIdentDirectiveStatement::variantT() const
166350 : {
166351 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
166352 0 : ROSE_ASSERT(this != NULL);
166353 0 : return V_SgIdentDirectiveStatement;
166354 : }
166355 :
166356 : #if 0
166357 : int
166358 : SgIdentDirectiveStatement::variant() const
166359 : {
166360 : // This function is used in SAGE
166361 : ROSE_ASSERT(this != NULL);
166362 : return IDENT_DIRECTIVE_STMT;
166363 : }
166364 : #endif
166365 :
166366 : ROSE_DLL_API const char*
166367 0 : SgIdentDirectiveStatement::sage_class_name() const
166368 : {
166369 0 : ROSE_ASSERT(this != NULL);
166370 0 : return "SgIdentDirectiveStatement";
166371 : }
166372 :
166373 : std::string
166374 0 : SgIdentDirectiveStatement::class_name() const
166375 : {
166376 0 : ROSE_ASSERT(this != NULL);
166377 0 : return "SgIdentDirectiveStatement";
166378 : }
166379 :
166380 : // DQ (11/26/2005): Support for visitor pattern mechanims
166381 : // (inferior to ROSE traversal mechanism, experimental).
166382 : void
166383 0 : SgIdentDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
166384 : {
166385 0 : ROSE_ASSERT(this != NULL);
166386 0 : visitor.visit(this);
166387 0 : }
166388 :
166389 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
166390 0 : void SgIdentDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
166391 0 : ROSE_ASSERT(this != NULL);
166392 0 : visitor.visit(this);
166393 0 : }
166394 :
166395 : SgIdentDirectiveStatement*
166396 0 : SgIdentDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
166397 : {
166398 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
166399 : // This function is currently only supported for the AST used the represent Binary executables.
166400 : if (0 /* isSgAsmNode(this) != NULL */)
166401 : {
166402 : // Support for regex specification.
166403 : std::string prefixCode = "REGEX:";
166404 : addNewAttribute(prefixCode + s,a);
166405 : }
166406 : #endif
166407 :
166408 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
166409 0 : return this;
166410 : }
166411 :
166412 : // *** COMMON CODE SECTION ENDS HERE ***
166413 :
166414 :
166415 : // End of memberFunctionString
166416 : // Start of memberFunctionString
166417 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
166418 :
166419 :
166420 : #if 0
166421 : //! Error checking support
166422 : /*! Verifies the following:
166423 : - working getVariant() member function
166424 : - calls base class's error() member function
166425 : Every class has one of these functions.
166426 : */
166427 : bool
166428 : SgIdentDirectiveStatement::error()
166429 : {
166430 : // Put error checking here
166431 :
166432 : ROSE_ASSERT (this != NULL);
166433 : if (getVariant() != IDENT_DIRECTIVE_STMT)
166434 : {
166435 : printf ("Error in SgIdentDirectiveStatement::error(): SgIdentDirectiveStatement object has a %s variant \n",
166436 : Cxx_GrammarTerminalNames[getVariant()].name);
166437 : // printf ("Error in SgIdentDirectiveStatement::error() \n");
166438 : ROSE_ABORT();
166439 : }
166440 :
166441 : ROSE_ASSERT (getVariant() == IDENT_DIRECTIVE_STMT);
166442 : return SgC_PreprocessorDirectiveStatement::error();
166443 : }
166444 : #endif
166445 :
166446 :
166447 :
166448 : // End of memberFunctionString
166449 :
166450 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
166451 :
166452 0 : SgIdentDirectiveStatement* isSgIdentDirectiveStatement ( SgNode* inputDerivedClassPointer )
166453 : {
166454 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
166455 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
166456 : // So to fix this we return NULL directly when the input is NULL and avoid the
166457 : // dynamic_cast in this case. This is likely a performance improvement as well.
166458 : // return dynamic_cast<SgIdentDirectiveStatement*>(inputDerivedClassPointer);
166459 : // Milind Chabbi (8/28/2013): isSgIdentDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
166460 : // this improves the running time performance by 10-20%.
166461 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIdentDirectiveStatement*>(inputDerivedClassPointer);
166462 0 : return IS_SgIdentDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
166463 : }
166464 :
166465 : // DQ (11/8/2003): Added version of functions taking const pointer
166466 0 : const SgIdentDirectiveStatement* isSgIdentDirectiveStatement ( const SgNode* inputDerivedClassPointer )
166467 : {
166468 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
166469 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
166470 : // So to fix this we return NULL directly when the input is NULL and avoid the
166471 : // dynamic_cast in this case. This is likely a performance improvement as well.
166472 : // return dynamic_cast<const SgIdentDirectiveStatement*>(inputDerivedClassPointer);
166473 : // Milind Chabbi (8/28/2013): isSgIdentDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
166474 : // this improves the running time performance by 10-20%.
166475 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIdentDirectiveStatement*>(inputDerivedClassPointer);
166476 0 : return IS_SgIdentDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
166477 : }
166478 :
166479 :
166480 :
166481 : /* #line 166482 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166482 :
166483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
166484 :
166485 : /**
166486 : \brief Generated destructor
166487 :
166488 : This destructor is automatically generated (by ROSETTA). This destructor
166489 : only frees memory of data members associated with the parts of the current IR node which
166490 : are NOT traversed. Those data members that are part of a traversal can be freed using
166491 : a traversal (calling this destructor on all children in a post-order traversal). Such
166492 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
166493 :
166494 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
166495 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
166496 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
166497 :
166498 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
166499 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
166500 : pointers are not yet implemented to call delete on eash pointer in the container.
166501 : (This could be done by derivation from the STL containers to define containers that
166502 : automatically deleted their members.)
166503 :
166504 : */
166505 0 : SgIdentDirectiveStatement::~SgIdentDirectiveStatement () {
166506 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
166507 :
166508 :
166509 :
166510 : }
166511 :
166512 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
166513 0 : }
166514 :
166515 :
166516 : /* #line 166517 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166517 :
166518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
166519 :
166520 : // Generated constructor
166521 0 : SgIdentDirectiveStatement::SgIdentDirectiveStatement ( Sg_File_Info* startOfConstruct )
166522 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
166523 : {
166524 : #ifdef DEBUG
166525 : // printf ("In SgIdentDirectiveStatement::SgIdentDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
166526 : #endif
166527 : #if 0
166528 : // debugging information!
166529 : printf ("In SgIdentDirectiveStatement::SgIdentDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
166530 : #endif
166531 :
166532 :
166533 :
166534 : #if 0
166535 : // DQ (7/30/2014): Call a virtual function.
166536 : std::string s = this->class_name();
166537 : #endif
166538 :
166539 : // Test the variant virtual function
166540 : // assert(IDENT_DIRECTIVE_STMT == variant());
166541 0 : assert(IDENT_DIRECTIVE_STMT == this->variant());
166542 0 : ROSE_ASSERT(IDENT_DIRECTIVE_STMT == (int)(this->variantT()));
166543 0 : post_construction_initialization();
166544 :
166545 : // Test the isSgIdentDirectiveStatement() function since it has been problematic
166546 0 : assert(isSgIdentDirectiveStatement(this) != NULL);
166547 0 : }
166548 :
166549 : // Generated constructor (all data members)
166550 :
166551 : /* #line 166552 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166552 :
166553 :
166554 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166555 :
166556 :
166557 : // ********************************************************
166558 : // member functions common across all array grammar objects
166559 : // ********************************************************
166560 :
166561 :
166562 :
166563 : /* #line 166564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166564 :
166565 :
166566 :
166567 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166568 :
166569 : // ********************************************************
166570 : // member functions specific to each node in the grammar
166571 : // ********************************************************
166572 :
166573 :
166574 : /* #line 166575 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166575 :
166576 : // Start of memberFunctionString
166577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
166578 :
166579 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
166580 :
166581 : int
166582 0 : SgLinemarkerDirectiveStatement::get_linenumber () const
166583 : {
166584 0 : ROSE_ASSERT (this != NULL);
166585 :
166586 : #if 0
166587 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
166588 : // used to trigger marking transformations for the token-based unparsing.
166589 : printf ("SgLinemarkerDirectiveStatement::get_linenumber = %p = %s \n",this,this->class_name().c_str());
166590 : #endif
166591 :
166592 0 : return p_linenumber;
166593 : }
166594 :
166595 : void
166596 0 : SgLinemarkerDirectiveStatement::set_linenumber ( int linenumber )
166597 : {
166598 0 : ROSE_ASSERT (this != NULL);
166599 :
166600 : #if 0
166601 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
166602 : // used to trigger marking transformations for the token-based unparsing.
166603 : printf ("SgLinemarkerDirectiveStatement::set_linenumber = %p = %s \n",this,this->class_name().c_str());
166604 : #endif
166605 :
166606 0 : set_isModified(true);
166607 :
166608 0 : p_linenumber = linenumber;
166609 0 : }
166610 :
166611 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
166612 :
166613 :
166614 : // End of memberFunctionString
166615 : // Start of memberFunctionString
166616 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
166617 :
166618 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
166619 :
166620 : std::string
166621 0 : SgLinemarkerDirectiveStatement::get_filename () const
166622 : {
166623 0 : ROSE_ASSERT (this != NULL);
166624 :
166625 : #if 0
166626 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
166627 : // used to trigger marking transformations for the token-based unparsing.
166628 : printf ("SgLinemarkerDirectiveStatement::get_filename = %p = %s \n",this,this->class_name().c_str());
166629 : #endif
166630 :
166631 0 : return p_filename;
166632 : }
166633 :
166634 : void
166635 0 : SgLinemarkerDirectiveStatement::set_filename ( std::string filename )
166636 : {
166637 0 : ROSE_ASSERT (this != NULL);
166638 :
166639 : #if 0
166640 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
166641 : // used to trigger marking transformations for the token-based unparsing.
166642 : printf ("SgLinemarkerDirectiveStatement::set_filename = %p = %s \n",this,this->class_name().c_str());
166643 : #endif
166644 :
166645 0 : set_isModified(true);
166646 :
166647 0 : p_filename = filename;
166648 0 : }
166649 :
166650 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
166651 :
166652 :
166653 : // End of memberFunctionString
166654 : // Start of memberFunctionString
166655 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
166656 :
166657 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
166658 :
166659 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
166660 : const SgUnsignedCharList &
166661 0 : SgLinemarkerDirectiveStatement::get_flaglist () const
166662 : {
166663 0 : assert (this != NULL);
166664 0 : return p_flaglist;
166665 : }
166666 :
166667 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
166668 : SgUnsignedCharList &
166669 0 : SgLinemarkerDirectiveStatement::get_flaglist ()
166670 : {
166671 0 : assert (this != NULL);
166672 :
166673 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
166674 : // As a rule only set_ access functions can set the isModified flag.
166675 : // set_isModified(true);
166676 :
166677 0 : return p_flaglist;
166678 : }
166679 :
166680 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
166681 :
166682 :
166683 : // End of memberFunctionString
166684 : // Start of memberFunctionString
166685 : /* #line 18966 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
166686 :
166687 :
166688 :
166689 : // End of memberFunctionString
166690 : // Start of memberFunctionString
166691 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
166692 :
166693 : void
166694 0 : SgLinemarkerDirectiveStatement::post_construction_initialization()
166695 : {
166696 0 : }
166697 :
166698 :
166699 :
166700 : // End of memberFunctionString
166701 : // Start of memberFunctionString
166702 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
166703 :
166704 : // *** COMMON CODE SECTION BEGINS HERE ***
166705 :
166706 : #if 0
166707 : int
166708 : SgLinemarkerDirectiveStatement::getVariant() const
166709 : {
166710 : // This function is used in ROSE while "variant()" is used in SAGE
166711 : assert(this != NULL);
166712 : return variant();
166713 : }
166714 : #endif
166715 :
166716 : // This function is used in ROSE in treeTraversal code
166717 : // eventually replaces getVariant() and variant()
166718 : // though after variant() has been removed for a while we will
166719 : // want to change the name of variantT() back to variant()
166720 : // (since the "T" was ment to stand for temporary).
166721 : // When this happens the variantT() will be depricated.
166722 : VariantT
166723 0 : SgLinemarkerDirectiveStatement::variantT() const
166724 : {
166725 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
166726 0 : ROSE_ASSERT(this != NULL);
166727 0 : return V_SgLinemarkerDirectiveStatement;
166728 : }
166729 :
166730 : #if 0
166731 : int
166732 : SgLinemarkerDirectiveStatement::variant() const
166733 : {
166734 : // This function is used in SAGE
166735 : ROSE_ASSERT(this != NULL);
166736 : return LINEMARKER_DIRECTIVE_STMT;
166737 : }
166738 : #endif
166739 :
166740 : ROSE_DLL_API const char*
166741 0 : SgLinemarkerDirectiveStatement::sage_class_name() const
166742 : {
166743 0 : ROSE_ASSERT(this != NULL);
166744 0 : return "SgLinemarkerDirectiveStatement";
166745 : }
166746 :
166747 : std::string
166748 0 : SgLinemarkerDirectiveStatement::class_name() const
166749 : {
166750 0 : ROSE_ASSERT(this != NULL);
166751 0 : return "SgLinemarkerDirectiveStatement";
166752 : }
166753 :
166754 : // DQ (11/26/2005): Support for visitor pattern mechanims
166755 : // (inferior to ROSE traversal mechanism, experimental).
166756 : void
166757 0 : SgLinemarkerDirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
166758 : {
166759 0 : ROSE_ASSERT(this != NULL);
166760 0 : visitor.visit(this);
166761 0 : }
166762 :
166763 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
166764 0 : void SgLinemarkerDirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
166765 0 : ROSE_ASSERT(this != NULL);
166766 0 : visitor.visit(this);
166767 0 : }
166768 :
166769 : SgLinemarkerDirectiveStatement*
166770 0 : SgLinemarkerDirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
166771 : {
166772 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
166773 : // This function is currently only supported for the AST used the represent Binary executables.
166774 : if (0 /* isSgAsmNode(this) != NULL */)
166775 : {
166776 : // Support for regex specification.
166777 : std::string prefixCode = "REGEX:";
166778 : addNewAttribute(prefixCode + s,a);
166779 : }
166780 : #endif
166781 :
166782 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
166783 0 : return this;
166784 : }
166785 :
166786 : // *** COMMON CODE SECTION ENDS HERE ***
166787 :
166788 :
166789 : // End of memberFunctionString
166790 : // Start of memberFunctionString
166791 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
166792 :
166793 :
166794 : #if 0
166795 : //! Error checking support
166796 : /*! Verifies the following:
166797 : - working getVariant() member function
166798 : - calls base class's error() member function
166799 : Every class has one of these functions.
166800 : */
166801 : bool
166802 : SgLinemarkerDirectiveStatement::error()
166803 : {
166804 : // Put error checking here
166805 :
166806 : ROSE_ASSERT (this != NULL);
166807 : if (getVariant() != LINEMARKER_DIRECTIVE_STMT)
166808 : {
166809 : printf ("Error in SgLinemarkerDirectiveStatement::error(): SgLinemarkerDirectiveStatement object has a %s variant \n",
166810 : Cxx_GrammarTerminalNames[getVariant()].name);
166811 : // printf ("Error in SgLinemarkerDirectiveStatement::error() \n");
166812 : ROSE_ABORT();
166813 : }
166814 :
166815 : ROSE_ASSERT (getVariant() == LINEMARKER_DIRECTIVE_STMT);
166816 : return SgC_PreprocessorDirectiveStatement::error();
166817 : }
166818 : #endif
166819 :
166820 :
166821 :
166822 : // End of memberFunctionString
166823 :
166824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
166825 :
166826 0 : SgLinemarkerDirectiveStatement* isSgLinemarkerDirectiveStatement ( SgNode* inputDerivedClassPointer )
166827 : {
166828 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
166829 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
166830 : // So to fix this we return NULL directly when the input is NULL and avoid the
166831 : // dynamic_cast in this case. This is likely a performance improvement as well.
166832 : // return dynamic_cast<SgLinemarkerDirectiveStatement*>(inputDerivedClassPointer);
166833 : // Milind Chabbi (8/28/2013): isSgLinemarkerDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
166834 : // this improves the running time performance by 10-20%.
166835 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLinemarkerDirectiveStatement*>(inputDerivedClassPointer);
166836 0 : return IS_SgLinemarkerDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
166837 : }
166838 :
166839 : // DQ (11/8/2003): Added version of functions taking const pointer
166840 0 : const SgLinemarkerDirectiveStatement* isSgLinemarkerDirectiveStatement ( const SgNode* inputDerivedClassPointer )
166841 : {
166842 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
166843 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
166844 : // So to fix this we return NULL directly when the input is NULL and avoid the
166845 : // dynamic_cast in this case. This is likely a performance improvement as well.
166846 : // return dynamic_cast<const SgLinemarkerDirectiveStatement*>(inputDerivedClassPointer);
166847 : // Milind Chabbi (8/28/2013): isSgLinemarkerDirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
166848 : // this improves the running time performance by 10-20%.
166849 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLinemarkerDirectiveStatement*>(inputDerivedClassPointer);
166850 0 : return IS_SgLinemarkerDirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
166851 : }
166852 :
166853 :
166854 :
166855 : /* #line 166856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166856 :
166857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
166858 :
166859 : /**
166860 : \brief Generated destructor
166861 :
166862 : This destructor is automatically generated (by ROSETTA). This destructor
166863 : only frees memory of data members associated with the parts of the current IR node which
166864 : are NOT traversed. Those data members that are part of a traversal can be freed using
166865 : a traversal (calling this destructor on all children in a post-order traversal). Such
166866 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
166867 :
166868 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
166869 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
166870 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
166871 :
166872 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
166873 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
166874 : pointers are not yet implemented to call delete on eash pointer in the container.
166875 : (This could be done by derivation from the STL containers to define containers that
166876 : automatically deleted their members.)
166877 :
166878 : */
166879 0 : SgLinemarkerDirectiveStatement::~SgLinemarkerDirectiveStatement () {
166880 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
166881 :
166882 :
166883 : // case: not a listType for linenumber
166884 0 : p_linenumber = -1; // non list case
166885 : // case: not a listType for filename
166886 0 : p_filename = ""; // non list case
166887 :
166888 : }
166889 :
166890 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
166891 0 : }
166892 :
166893 :
166894 : /* #line 166895 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166895 :
166896 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
166897 :
166898 : // Generated constructor
166899 0 : SgLinemarkerDirectiveStatement::SgLinemarkerDirectiveStatement ( Sg_File_Info* startOfConstruct )
166900 0 : : SgC_PreprocessorDirectiveStatement(startOfConstruct)
166901 : {
166902 : #ifdef DEBUG
166903 : // printf ("In SgLinemarkerDirectiveStatement::SgLinemarkerDirectiveStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
166904 : #endif
166905 : #if 0
166906 : // debugging information!
166907 : printf ("In SgLinemarkerDirectiveStatement::SgLinemarkerDirectiveStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
166908 : #endif
166909 :
166910 0 : p_linenumber = -1;
166911 0 : p_filename = "";
166912 :
166913 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
166914 :
166915 : #if 0
166916 : // DQ (7/30/2014): Call a virtual function.
166917 : std::string s = this->class_name();
166918 : #endif
166919 :
166920 : // Test the variant virtual function
166921 : // assert(LINEMARKER_DIRECTIVE_STMT == variant());
166922 0 : assert(LINEMARKER_DIRECTIVE_STMT == this->variant());
166923 0 : ROSE_ASSERT(LINEMARKER_DIRECTIVE_STMT == (int)(this->variantT()));
166924 0 : post_construction_initialization();
166925 :
166926 : // Test the isSgLinemarkerDirectiveStatement() function since it has been problematic
166927 0 : assert(isSgLinemarkerDirectiveStatement(this) != NULL);
166928 0 : }
166929 :
166930 : // Generated constructor (all data members)
166931 :
166932 : /* #line 166933 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166933 :
166934 :
166935 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166936 :
166937 :
166938 : // ********************************************************
166939 : // member functions common across all array grammar objects
166940 : // ********************************************************
166941 :
166942 :
166943 :
166944 : /* #line 166945 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166945 :
166946 :
166947 :
166948 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
166949 :
166950 : // ********************************************************
166951 : // member functions specific to each node in the grammar
166952 : // ********************************************************
166953 :
166954 :
166955 : /* #line 166956 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
166956 :
166957 : // Start of memberFunctionString
166958 : /* #line 19174 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
166959 :
166960 : void
166961 7 : SgOmpThreadprivateStatement::post_construction_initialization()
166962 7 : {}
166963 :
166964 : SgName
166965 7 : SgOmpThreadprivateStatement::get_mangled_name(void) const
166966 : {
166967 7 : SgName returnName;
166968 :
166969 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
166970 7 : SgScopeStatement* scope = get_scope();
166971 7 : ROSE_ASSERT(scope != NULL);
166972 :
166973 7 : SgName variableNames;
166974 7 : SgVarRefExpPtrList::const_iterator p = get_variables().begin();
166975 17 : while ( p != get_variables().end() )
166976 : {
166977 10 : ROSE_ASSERT ((*p)->get_symbol() != NULL);
166978 10 : SgVariableSymbol * sym = isSgVariableSymbol ((*p)->get_symbol());
166979 10 : ROSE_ASSERT (sym != NULL);
166980 10 : ROSE_ASSERT (sym->get_declaration() != NULL);
166981 20 : variableNames += SgName("_variable_type_") + (*p)->get_symbol()->get_type()->get_mangled() +
166982 30 : SgName("_variable_name_") + sym->get_declaration()->get_mangled_name();
166983 :
166984 10 : p++;
166985 : }
166986 7 : returnName = scope->get_mangled_name() + SgName("_omp_threadprivate_declaration_") + variableNames;
166987 :
166988 7 : return returnName;
166989 : }
166990 :
166991 :
166992 :
166993 : // End of memberFunctionString
166994 : // Start of memberFunctionString
166995 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
166996 :
166997 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
166998 :
166999 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
167000 : const SgVarRefExpPtrList &
167001 24 : SgOmpThreadprivateStatement::get_variables () const
167002 : {
167003 24 : assert (this != NULL);
167004 24 : return p_variables;
167005 : }
167006 :
167007 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
167008 : SgVarRefExpPtrList &
167009 44 : SgOmpThreadprivateStatement::get_variables ()
167010 : {
167011 44 : assert (this != NULL);
167012 :
167013 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
167014 : // As a rule only set_ access functions can set the isModified flag.
167015 : // set_isModified(true);
167016 :
167017 44 : return p_variables;
167018 : }
167019 :
167020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
167021 :
167022 :
167023 : // End of memberFunctionString
167024 : // Start of memberFunctionString
167025 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
167026 :
167027 : // *** COMMON CODE SECTION BEGINS HERE ***
167028 :
167029 : #if 0
167030 : int
167031 : SgOmpThreadprivateStatement::getVariant() const
167032 : {
167033 : // This function is used in ROSE while "variant()" is used in SAGE
167034 : assert(this != NULL);
167035 : return variant();
167036 : }
167037 : #endif
167038 :
167039 : // This function is used in ROSE in treeTraversal code
167040 : // eventually replaces getVariant() and variant()
167041 : // though after variant() has been removed for a while we will
167042 : // want to change the name of variantT() back to variant()
167043 : // (since the "T" was ment to stand for temporary).
167044 : // When this happens the variantT() will be depricated.
167045 : VariantT
167046 685 : SgOmpThreadprivateStatement::variantT() const
167047 : {
167048 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
167049 685 : ROSE_ASSERT(this != NULL);
167050 685 : return V_SgOmpThreadprivateStatement;
167051 : }
167052 :
167053 : #if 0
167054 : int
167055 : SgOmpThreadprivateStatement::variant() const
167056 : {
167057 : // This function is used in SAGE
167058 : ROSE_ASSERT(this != NULL);
167059 : return OMP_THREADPRIVATE_STMT;
167060 : }
167061 : #endif
167062 :
167063 : ROSE_DLL_API const char*
167064 0 : SgOmpThreadprivateStatement::sage_class_name() const
167065 : {
167066 0 : ROSE_ASSERT(this != NULL);
167067 0 : return "SgOmpThreadprivateStatement";
167068 : }
167069 :
167070 : std::string
167071 7 : SgOmpThreadprivateStatement::class_name() const
167072 : {
167073 7 : ROSE_ASSERT(this != NULL);
167074 7 : return "SgOmpThreadprivateStatement";
167075 : }
167076 :
167077 : // DQ (11/26/2005): Support for visitor pattern mechanims
167078 : // (inferior to ROSE traversal mechanism, experimental).
167079 : void
167080 0 : SgOmpThreadprivateStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
167081 : {
167082 0 : ROSE_ASSERT(this != NULL);
167083 0 : visitor.visit(this);
167084 0 : }
167085 :
167086 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
167087 0 : void SgOmpThreadprivateStatement::accept (ROSE_VisitorPattern & visitor) {
167088 0 : ROSE_ASSERT(this != NULL);
167089 0 : visitor.visit(this);
167090 0 : }
167091 :
167092 : SgOmpThreadprivateStatement*
167093 0 : SgOmpThreadprivateStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
167094 : {
167095 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
167096 : // This function is currently only supported for the AST used the represent Binary executables.
167097 : if (0 /* isSgAsmNode(this) != NULL */)
167098 : {
167099 : // Support for regex specification.
167100 : std::string prefixCode = "REGEX:";
167101 : addNewAttribute(prefixCode + s,a);
167102 : }
167103 : #endif
167104 :
167105 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
167106 0 : return this;
167107 : }
167108 :
167109 : // *** COMMON CODE SECTION ENDS HERE ***
167110 :
167111 :
167112 : // End of memberFunctionString
167113 : // Start of memberFunctionString
167114 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
167115 :
167116 :
167117 : #if 0
167118 : //! Error checking support
167119 : /*! Verifies the following:
167120 : - working getVariant() member function
167121 : - calls base class's error() member function
167122 : Every class has one of these functions.
167123 : */
167124 : bool
167125 : SgOmpThreadprivateStatement::error()
167126 : {
167127 : // Put error checking here
167128 :
167129 : ROSE_ASSERT (this != NULL);
167130 : if (getVariant() != OMP_THREADPRIVATE_STMT)
167131 : {
167132 : printf ("Error in SgOmpThreadprivateStatement::error(): SgOmpThreadprivateStatement object has a %s variant \n",
167133 : Cxx_GrammarTerminalNames[getVariant()].name);
167134 : // printf ("Error in SgOmpThreadprivateStatement::error() \n");
167135 : ROSE_ABORT();
167136 : }
167137 :
167138 : ROSE_ASSERT (getVariant() == OMP_THREADPRIVATE_STMT);
167139 : return SgDeclarationStatement::error();
167140 : }
167141 : #endif
167142 :
167143 :
167144 :
167145 : // End of memberFunctionString
167146 :
167147 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
167148 :
167149 14 : SgOmpThreadprivateStatement* isSgOmpThreadprivateStatement ( SgNode* inputDerivedClassPointer )
167150 : {
167151 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
167152 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
167153 : // So to fix this we return NULL directly when the input is NULL and avoid the
167154 : // dynamic_cast in this case. This is likely a performance improvement as well.
167155 : // return dynamic_cast<SgOmpThreadprivateStatement*>(inputDerivedClassPointer);
167156 : // Milind Chabbi (8/28/2013): isSgOmpThreadprivateStatement uses table-driven castability instead of c++ default dynamic_cast
167157 : // this improves the running time performance by 10-20%.
167158 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpThreadprivateStatement*>(inputDerivedClassPointer);
167159 14 : return IS_SgOmpThreadprivateStatement_FAST_MACRO(inputDerivedClassPointer);
167160 : }
167161 :
167162 : // DQ (11/8/2003): Added version of functions taking const pointer
167163 0 : const SgOmpThreadprivateStatement* isSgOmpThreadprivateStatement ( const SgNode* inputDerivedClassPointer )
167164 : {
167165 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
167166 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
167167 : // So to fix this we return NULL directly when the input is NULL and avoid the
167168 : // dynamic_cast in this case. This is likely a performance improvement as well.
167169 : // return dynamic_cast<const SgOmpThreadprivateStatement*>(inputDerivedClassPointer);
167170 : // Milind Chabbi (8/28/2013): isSgOmpThreadprivateStatement uses table-driven castability instead of c++ default dynamic_cast
167171 : // this improves the running time performance by 10-20%.
167172 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpThreadprivateStatement*>(inputDerivedClassPointer);
167173 0 : return IS_SgOmpThreadprivateStatement_FAST_MACRO(inputDerivedClassPointer);
167174 : }
167175 :
167176 :
167177 :
167178 : /* #line 167179 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167179 :
167180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
167181 :
167182 : /**
167183 : \brief Generated destructor
167184 :
167185 : This destructor is automatically generated (by ROSETTA). This destructor
167186 : only frees memory of data members associated with the parts of the current IR node which
167187 : are NOT traversed. Those data members that are part of a traversal can be freed using
167188 : a traversal (calling this destructor on all children in a post-order traversal). Such
167189 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
167190 :
167191 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
167192 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
167193 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
167194 :
167195 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
167196 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
167197 : pointers are not yet implemented to call delete on eash pointer in the container.
167198 : (This could be done by derivation from the STL containers to define containers that
167199 : automatically deleted their members.)
167200 :
167201 : */
167202 0 : SgOmpThreadprivateStatement::~SgOmpThreadprivateStatement () {
167203 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
167204 :
167205 :
167206 :
167207 : }
167208 :
167209 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
167210 0 : }
167211 :
167212 :
167213 : /* #line 167214 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167214 :
167215 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
167216 :
167217 : // Generated constructor
167218 0 : SgOmpThreadprivateStatement::SgOmpThreadprivateStatement ( Sg_File_Info* startOfConstruct )
167219 0 : : SgDeclarationStatement(startOfConstruct)
167220 : {
167221 : #ifdef DEBUG
167222 : // printf ("In SgOmpThreadprivateStatement::SgOmpThreadprivateStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
167223 : #endif
167224 : #if 0
167225 : // debugging information!
167226 : printf ("In SgOmpThreadprivateStatement::SgOmpThreadprivateStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
167227 : #endif
167228 :
167229 :
167230 :
167231 : #if 0
167232 : // DQ (7/30/2014): Call a virtual function.
167233 : std::string s = this->class_name();
167234 : #endif
167235 :
167236 : // Test the variant virtual function
167237 : // assert(OMP_THREADPRIVATE_STMT == variant());
167238 0 : assert(OMP_THREADPRIVATE_STMT == this->variant());
167239 0 : ROSE_ASSERT(OMP_THREADPRIVATE_STMT == (int)(this->variantT()));
167240 0 : post_construction_initialization();
167241 :
167242 : // Test the isSgOmpThreadprivateStatement() function since it has been problematic
167243 0 : assert(isSgOmpThreadprivateStatement(this) != NULL);
167244 0 : }
167245 :
167246 : // Generated constructor (all data members)
167247 :
167248 : /* #line 167249 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167249 :
167250 :
167251 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
167252 :
167253 :
167254 : // ********************************************************
167255 : // member functions common across all array grammar objects
167256 : // ********************************************************
167257 :
167258 :
167259 :
167260 : /* #line 167261 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167261 :
167262 :
167263 :
167264 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
167265 :
167266 : // ********************************************************
167267 : // member functions specific to each node in the grammar
167268 : // ********************************************************
167269 :
167270 :
167271 : /* #line 167272 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167272 :
167273 : // Start of memberFunctionString
167274 : /* #line 19257 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
167275 :
167276 : void
167277 7 : SgOmpRequiresStatement::post_construction_initialization()
167278 7 : {}
167279 :
167280 : SgName
167281 7 : SgOmpRequiresStatement::get_mangled_name(void) const
167282 : {
167283 7 : SgName returnName;
167284 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
167285 7 : SgScopeStatement* scope = get_scope();
167286 7 : ROSE_ASSERT(scope != NULL);
167287 :
167288 7 : returnName = scope->get_mangled_name() + SgName("_omp_requires_");
167289 : //TODO: need more unique name adding clauses, followed function, etc.
167290 7 : return returnName;
167291 : }
167292 :
167293 :
167294 :
167295 : // End of memberFunctionString
167296 : // Start of memberFunctionString
167297 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
167298 :
167299 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
167300 :
167301 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
167302 : const SgOmpClausePtrList &
167303 0 : SgOmpRequiresStatement::get_clauses () const
167304 : {
167305 0 : assert (this != NULL);
167306 0 : return p_clauses;
167307 : }
167308 :
167309 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
167310 : SgOmpClausePtrList &
167311 15 : SgOmpRequiresStatement::get_clauses ()
167312 : {
167313 15 : assert (this != NULL);
167314 :
167315 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
167316 : // As a rule only set_ access functions can set the isModified flag.
167317 : // set_isModified(true);
167318 :
167319 15 : return p_clauses;
167320 : }
167321 :
167322 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
167323 :
167324 :
167325 : // End of memberFunctionString
167326 : // Start of memberFunctionString
167327 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
167328 :
167329 : // *** COMMON CODE SECTION BEGINS HERE ***
167330 :
167331 : #if 0
167332 : int
167333 : SgOmpRequiresStatement::getVariant() const
167334 : {
167335 : // This function is used in ROSE while "variant()" is used in SAGE
167336 : assert(this != NULL);
167337 : return variant();
167338 : }
167339 : #endif
167340 :
167341 : // This function is used in ROSE in treeTraversal code
167342 : // eventually replaces getVariant() and variant()
167343 : // though after variant() has been removed for a while we will
167344 : // want to change the name of variantT() back to variant()
167345 : // (since the "T" was ment to stand for temporary).
167346 : // When this happens the variantT() will be depricated.
167347 : VariantT
167348 813 : SgOmpRequiresStatement::variantT() const
167349 : {
167350 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
167351 813 : ROSE_ASSERT(this != NULL);
167352 813 : return V_SgOmpRequiresStatement;
167353 : }
167354 :
167355 : #if 0
167356 : int
167357 : SgOmpRequiresStatement::variant() const
167358 : {
167359 : // This function is used in SAGE
167360 : ROSE_ASSERT(this != NULL);
167361 : return OMP_REQUIRES_STMT;
167362 : }
167363 : #endif
167364 :
167365 : ROSE_DLL_API const char*
167366 0 : SgOmpRequiresStatement::sage_class_name() const
167367 : {
167368 0 : ROSE_ASSERT(this != NULL);
167369 0 : return "SgOmpRequiresStatement";
167370 : }
167371 :
167372 : std::string
167373 7 : SgOmpRequiresStatement::class_name() const
167374 : {
167375 7 : ROSE_ASSERT(this != NULL);
167376 7 : return "SgOmpRequiresStatement";
167377 : }
167378 :
167379 : // DQ (11/26/2005): Support for visitor pattern mechanims
167380 : // (inferior to ROSE traversal mechanism, experimental).
167381 : void
167382 0 : SgOmpRequiresStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
167383 : {
167384 0 : ROSE_ASSERT(this != NULL);
167385 0 : visitor.visit(this);
167386 0 : }
167387 :
167388 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
167389 0 : void SgOmpRequiresStatement::accept (ROSE_VisitorPattern & visitor) {
167390 0 : ROSE_ASSERT(this != NULL);
167391 0 : visitor.visit(this);
167392 0 : }
167393 :
167394 : SgOmpRequiresStatement*
167395 0 : SgOmpRequiresStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
167396 : {
167397 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
167398 : // This function is currently only supported for the AST used the represent Binary executables.
167399 : if (0 /* isSgAsmNode(this) != NULL */)
167400 : {
167401 : // Support for regex specification.
167402 : std::string prefixCode = "REGEX:";
167403 : addNewAttribute(prefixCode + s,a);
167404 : }
167405 : #endif
167406 :
167407 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
167408 0 : return this;
167409 : }
167410 :
167411 : // *** COMMON CODE SECTION ENDS HERE ***
167412 :
167413 :
167414 : // End of memberFunctionString
167415 : // Start of memberFunctionString
167416 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
167417 :
167418 :
167419 : #if 0
167420 : //! Error checking support
167421 : /*! Verifies the following:
167422 : - working getVariant() member function
167423 : - calls base class's error() member function
167424 : Every class has one of these functions.
167425 : */
167426 : bool
167427 : SgOmpRequiresStatement::error()
167428 : {
167429 : // Put error checking here
167430 :
167431 : ROSE_ASSERT (this != NULL);
167432 : if (getVariant() != OMP_REQUIRES_STMT)
167433 : {
167434 : printf ("Error in SgOmpRequiresStatement::error(): SgOmpRequiresStatement object has a %s variant \n",
167435 : Cxx_GrammarTerminalNames[getVariant()].name);
167436 : // printf ("Error in SgOmpRequiresStatement::error() \n");
167437 : ROSE_ABORT();
167438 : }
167439 :
167440 : ROSE_ASSERT (getVariant() == OMP_REQUIRES_STMT);
167441 : return SgDeclarationStatement::error();
167442 : }
167443 : #endif
167444 :
167445 :
167446 :
167447 : // End of memberFunctionString
167448 :
167449 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
167450 :
167451 888 : SgOmpRequiresStatement* isSgOmpRequiresStatement ( SgNode* inputDerivedClassPointer )
167452 : {
167453 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
167454 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
167455 : // So to fix this we return NULL directly when the input is NULL and avoid the
167456 : // dynamic_cast in this case. This is likely a performance improvement as well.
167457 : // return dynamic_cast<SgOmpRequiresStatement*>(inputDerivedClassPointer);
167458 : // Milind Chabbi (8/28/2013): isSgOmpRequiresStatement uses table-driven castability instead of c++ default dynamic_cast
167459 : // this improves the running time performance by 10-20%.
167460 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpRequiresStatement*>(inputDerivedClassPointer);
167461 888 : return IS_SgOmpRequiresStatement_FAST_MACRO(inputDerivedClassPointer);
167462 : }
167463 :
167464 : // DQ (11/8/2003): Added version of functions taking const pointer
167465 0 : const SgOmpRequiresStatement* isSgOmpRequiresStatement ( const SgNode* inputDerivedClassPointer )
167466 : {
167467 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
167468 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
167469 : // So to fix this we return NULL directly when the input is NULL and avoid the
167470 : // dynamic_cast in this case. This is likely a performance improvement as well.
167471 : // return dynamic_cast<const SgOmpRequiresStatement*>(inputDerivedClassPointer);
167472 : // Milind Chabbi (8/28/2013): isSgOmpRequiresStatement uses table-driven castability instead of c++ default dynamic_cast
167473 : // this improves the running time performance by 10-20%.
167474 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpRequiresStatement*>(inputDerivedClassPointer);
167475 0 : return IS_SgOmpRequiresStatement_FAST_MACRO(inputDerivedClassPointer);
167476 : }
167477 :
167478 :
167479 :
167480 : /* #line 167481 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167481 :
167482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
167483 :
167484 : /**
167485 : \brief Generated destructor
167486 :
167487 : This destructor is automatically generated (by ROSETTA). This destructor
167488 : only frees memory of data members associated with the parts of the current IR node which
167489 : are NOT traversed. Those data members that are part of a traversal can be freed using
167490 : a traversal (calling this destructor on all children in a post-order traversal). Such
167491 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
167492 :
167493 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
167494 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
167495 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
167496 :
167497 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
167498 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
167499 : pointers are not yet implemented to call delete on eash pointer in the container.
167500 : (This could be done by derivation from the STL containers to define containers that
167501 : automatically deleted their members.)
167502 :
167503 : */
167504 0 : SgOmpRequiresStatement::~SgOmpRequiresStatement () {
167505 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
167506 :
167507 :
167508 :
167509 : }
167510 :
167511 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
167512 0 : }
167513 :
167514 :
167515 : /* #line 167516 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167516 :
167517 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
167518 :
167519 : // Generated constructor
167520 0 : SgOmpRequiresStatement::SgOmpRequiresStatement ( Sg_File_Info* startOfConstruct )
167521 0 : : SgDeclarationStatement(startOfConstruct)
167522 : {
167523 : #ifdef DEBUG
167524 : // printf ("In SgOmpRequiresStatement::SgOmpRequiresStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
167525 : #endif
167526 : #if 0
167527 : // debugging information!
167528 : printf ("In SgOmpRequiresStatement::SgOmpRequiresStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
167529 : #endif
167530 :
167531 :
167532 :
167533 : #if 0
167534 : // DQ (7/30/2014): Call a virtual function.
167535 : std::string s = this->class_name();
167536 : #endif
167537 :
167538 : // Test the variant virtual function
167539 : // assert(OMP_REQUIRES_STMT == variant());
167540 0 : assert(OMP_REQUIRES_STMT == this->variant());
167541 0 : ROSE_ASSERT(OMP_REQUIRES_STMT == (int)(this->variantT()));
167542 0 : post_construction_initialization();
167543 :
167544 : // Test the isSgOmpRequiresStatement() function since it has been problematic
167545 0 : assert(isSgOmpRequiresStatement(this) != NULL);
167546 0 : }
167547 :
167548 : // Generated constructor (all data members)
167549 :
167550 : /* #line 167551 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167551 :
167552 :
167553 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
167554 :
167555 :
167556 : // ********************************************************
167557 : // member functions common across all array grammar objects
167558 : // ********************************************************
167559 :
167560 :
167561 :
167562 : /* #line 167563 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167563 :
167564 :
167565 :
167566 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
167567 :
167568 : // ********************************************************
167569 : // member functions specific to each node in the grammar
167570 : // ********************************************************
167571 :
167572 :
167573 : /* #line 167574 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167574 :
167575 : // Start of memberFunctionString
167576 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
167577 :
167578 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
167579 :
167580 : std::string
167581 14 : SgFortranIncludeLine::get_filename () const
167582 : {
167583 14 : ROSE_ASSERT (this != NULL);
167584 :
167585 : #if 0
167586 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
167587 : // used to trigger marking transformations for the token-based unparsing.
167588 : printf ("SgFortranIncludeLine::get_filename = %p = %s \n",this,this->class_name().c_str());
167589 : #endif
167590 :
167591 14 : return p_filename;
167592 : }
167593 :
167594 : void
167595 0 : SgFortranIncludeLine::set_filename ( std::string filename )
167596 : {
167597 0 : ROSE_ASSERT (this != NULL);
167598 :
167599 : #if 0
167600 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
167601 : // used to trigger marking transformations for the token-based unparsing.
167602 : printf ("SgFortranIncludeLine::set_filename = %p = %s \n",this,this->class_name().c_str());
167603 : #endif
167604 :
167605 0 : set_isModified(true);
167606 :
167607 0 : p_filename = filename;
167608 0 : }
167609 :
167610 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
167611 :
167612 :
167613 : // End of memberFunctionString
167614 : // Start of memberFunctionString
167615 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
167616 :
167617 : void
167618 28 : SgFortranIncludeLine::post_construction_initialization()
167619 : {
167620 28 : }
167621 :
167622 :
167623 :
167624 : // End of memberFunctionString
167625 : // Start of memberFunctionString
167626 : /* #line 18937 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
167627 :
167628 : // Not sure if we need these...
167629 : // virtual unsigned int cfgIndexForEnd() const override;
167630 : // virtual std::vector<VirtualCFG::CFGEdge> cfgOutEdges(unsigned int index) override;
167631 : // virtual std::vector<VirtualCFG::CFGEdge> cfgInEdges(unsigned int index) override;
167632 :
167633 : SgName
167634 28 : SgFortranIncludeLine::get_mangled_name(void) const
167635 : {
167636 28 : return SgName ("__fortran_include_line__");
167637 : }
167638 :
167639 :
167640 : // End of memberFunctionString
167641 : // Start of memberFunctionString
167642 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
167643 :
167644 : // *** COMMON CODE SECTION BEGINS HERE ***
167645 :
167646 : #if 0
167647 : int
167648 : SgFortranIncludeLine::getVariant() const
167649 : {
167650 : // This function is used in ROSE while "variant()" is used in SAGE
167651 : assert(this != NULL);
167652 : return variant();
167653 : }
167654 : #endif
167655 :
167656 : // This function is used in ROSE in treeTraversal code
167657 : // eventually replaces getVariant() and variant()
167658 : // though after variant() has been removed for a while we will
167659 : // want to change the name of variantT() back to variant()
167660 : // (since the "T" was ment to stand for temporary).
167661 : // When this happens the variantT() will be depricated.
167662 : VariantT
167663 22834 : SgFortranIncludeLine::variantT() const
167664 : {
167665 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
167666 22834 : ROSE_ASSERT(this != NULL);
167667 22834 : return V_SgFortranIncludeLine;
167668 : }
167669 :
167670 : #if 0
167671 : int
167672 : SgFortranIncludeLine::variant() const
167673 : {
167674 : // This function is used in SAGE
167675 : ROSE_ASSERT(this != NULL);
167676 : return TEMP_Fortran_Include_Line;
167677 : }
167678 : #endif
167679 :
167680 : ROSE_DLL_API const char*
167681 56 : SgFortranIncludeLine::sage_class_name() const
167682 : {
167683 56 : ROSE_ASSERT(this != NULL);
167684 56 : return "SgFortranIncludeLine";
167685 : }
167686 :
167687 : std::string
167688 28 : SgFortranIncludeLine::class_name() const
167689 : {
167690 28 : ROSE_ASSERT(this != NULL);
167691 28 : return "SgFortranIncludeLine";
167692 : }
167693 :
167694 : // DQ (11/26/2005): Support for visitor pattern mechanims
167695 : // (inferior to ROSE traversal mechanism, experimental).
167696 : void
167697 0 : SgFortranIncludeLine::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
167698 : {
167699 0 : ROSE_ASSERT(this != NULL);
167700 0 : visitor.visit(this);
167701 0 : }
167702 :
167703 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
167704 0 : void SgFortranIncludeLine::accept (ROSE_VisitorPattern & visitor) {
167705 0 : ROSE_ASSERT(this != NULL);
167706 0 : visitor.visit(this);
167707 0 : }
167708 :
167709 : SgFortranIncludeLine*
167710 0 : SgFortranIncludeLine::addRegExpAttribute(std::string s, AstRegExAttribute* a)
167711 : {
167712 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
167713 : // This function is currently only supported for the AST used the represent Binary executables.
167714 : if (0 /* isSgAsmNode(this) != NULL */)
167715 : {
167716 : // Support for regex specification.
167717 : std::string prefixCode = "REGEX:";
167718 : addNewAttribute(prefixCode + s,a);
167719 : }
167720 : #endif
167721 :
167722 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
167723 0 : return this;
167724 : }
167725 :
167726 : // *** COMMON CODE SECTION ENDS HERE ***
167727 :
167728 :
167729 : // End of memberFunctionString
167730 : // Start of memberFunctionString
167731 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
167732 :
167733 :
167734 : #if 0
167735 : //! Error checking support
167736 : /*! Verifies the following:
167737 : - working getVariant() member function
167738 : - calls base class's error() member function
167739 : Every class has one of these functions.
167740 : */
167741 : bool
167742 : SgFortranIncludeLine::error()
167743 : {
167744 : // Put error checking here
167745 :
167746 : ROSE_ASSERT (this != NULL);
167747 : if (getVariant() != TEMP_Fortran_Include_Line)
167748 : {
167749 : printf ("Error in SgFortranIncludeLine::error(): SgFortranIncludeLine object has a %s variant \n",
167750 : Cxx_GrammarTerminalNames[getVariant()].name);
167751 : // printf ("Error in SgFortranIncludeLine::error() \n");
167752 : ROSE_ABORT();
167753 : }
167754 :
167755 : ROSE_ASSERT (getVariant() == TEMP_Fortran_Include_Line);
167756 : return SgDeclarationStatement::error();
167757 : }
167758 : #endif
167759 :
167760 :
167761 :
167762 : // End of memberFunctionString
167763 :
167764 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
167765 :
167766 42 : SgFortranIncludeLine* isSgFortranIncludeLine ( SgNode* inputDerivedClassPointer )
167767 : {
167768 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
167769 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
167770 : // So to fix this we return NULL directly when the input is NULL and avoid the
167771 : // dynamic_cast in this case. This is likely a performance improvement as well.
167772 : // return dynamic_cast<SgFortranIncludeLine*>(inputDerivedClassPointer);
167773 : // Milind Chabbi (8/28/2013): isSgFortranIncludeLine uses table-driven castability instead of c++ default dynamic_cast
167774 : // this improves the running time performance by 10-20%.
167775 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFortranIncludeLine*>(inputDerivedClassPointer);
167776 42 : return IS_SgFortranIncludeLine_FAST_MACRO(inputDerivedClassPointer);
167777 : }
167778 :
167779 : // DQ (11/8/2003): Added version of functions taking const pointer
167780 0 : const SgFortranIncludeLine* isSgFortranIncludeLine ( const SgNode* inputDerivedClassPointer )
167781 : {
167782 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
167783 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
167784 : // So to fix this we return NULL directly when the input is NULL and avoid the
167785 : // dynamic_cast in this case. This is likely a performance improvement as well.
167786 : // return dynamic_cast<const SgFortranIncludeLine*>(inputDerivedClassPointer);
167787 : // Milind Chabbi (8/28/2013): isSgFortranIncludeLine uses table-driven castability instead of c++ default dynamic_cast
167788 : // this improves the running time performance by 10-20%.
167789 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFortranIncludeLine*>(inputDerivedClassPointer);
167790 0 : return IS_SgFortranIncludeLine_FAST_MACRO(inputDerivedClassPointer);
167791 : }
167792 :
167793 :
167794 :
167795 : /* #line 167796 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167796 :
167797 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
167798 :
167799 : /**
167800 : \brief Generated destructor
167801 :
167802 : This destructor is automatically generated (by ROSETTA). This destructor
167803 : only frees memory of data members associated with the parts of the current IR node which
167804 : are NOT traversed. Those data members that are part of a traversal can be freed using
167805 : a traversal (calling this destructor on all children in a post-order traversal). Such
167806 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
167807 :
167808 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
167809 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
167810 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
167811 :
167812 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
167813 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
167814 : pointers are not yet implemented to call delete on eash pointer in the container.
167815 : (This could be done by derivation from the STL containers to define containers that
167816 : automatically deleted their members.)
167817 :
167818 : */
167819 0 : SgFortranIncludeLine::~SgFortranIncludeLine () {
167820 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
167821 :
167822 :
167823 : // case: not a listType for filename
167824 0 : p_filename = ""; // non list case
167825 :
167826 : }
167827 :
167828 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
167829 0 : }
167830 :
167831 :
167832 : /* #line 167833 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167833 :
167834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
167835 :
167836 : // Generated constructor
167837 0 : SgFortranIncludeLine::SgFortranIncludeLine ( Sg_File_Info* startOfConstruct, std::string filename )
167838 0 : : SgDeclarationStatement(startOfConstruct)
167839 : {
167840 : #ifdef DEBUG
167841 : // printf ("In SgFortranIncludeLine::SgFortranIncludeLine (Sg_File_Info* startOfConstruct, std::string filename) sage_class_name() = %s \n",sage_class_name());
167842 : #endif
167843 : #if 0
167844 : // debugging information!
167845 : printf ("In SgFortranIncludeLine::SgFortranIncludeLine (Sg_File_Info* startOfConstruct, std::string filename): this = %p = %s \n",this,this->class_name().c_str());
167846 : #endif
167847 :
167848 0 : p_filename = filename;
167849 :
167850 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
167851 :
167852 : #if 0
167853 : // DQ (7/30/2014): Call a virtual function.
167854 : std::string s = this->class_name();
167855 : #endif
167856 :
167857 : // Test the variant virtual function
167858 : // assert(TEMP_Fortran_Include_Line == variant());
167859 0 : assert(TEMP_Fortran_Include_Line == this->variant());
167860 0 : ROSE_ASSERT(TEMP_Fortran_Include_Line == (int)(this->variantT()));
167861 0 : post_construction_initialization();
167862 :
167863 : // Test the isSgFortranIncludeLine() function since it has been problematic
167864 0 : assert(isSgFortranIncludeLine(this) != NULL);
167865 0 : }
167866 :
167867 : // Generated constructor (all data members)
167868 :
167869 : /* #line 167870 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167870 :
167871 :
167872 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
167873 :
167874 :
167875 : // ********************************************************
167876 : // member functions common across all array grammar objects
167877 : // ********************************************************
167878 :
167879 :
167880 :
167881 : /* #line 167882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167882 :
167883 :
167884 :
167885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
167886 :
167887 : // ********************************************************
167888 : // member functions specific to each node in the grammar
167889 : // ********************************************************
167890 :
167891 :
167892 : /* #line 167893 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
167893 :
167894 : // Start of memberFunctionString
167895 : /* #line 19232 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
167896 :
167897 : void
167898 28 : SgOmpTaskwaitStatement::post_construction_initialization()
167899 28 : {}
167900 :
167901 : SgName
167902 28 : SgOmpTaskwaitStatement::get_mangled_name(void) const
167903 : {
167904 28 : SgName returnName;
167905 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
167906 28 : SgScopeStatement* scope = get_scope();
167907 28 : ROSE_ASSERT(scope != NULL);
167908 :
167909 28 : returnName = scope->get_mangled_name() + SgName("_omp_taskwait_");
167910 : //TODO: need more unique name adding clauses, followed function, etc.
167911 28 : return returnName;
167912 : }
167913 :
167914 :
167915 :
167916 : // End of memberFunctionString
167917 : // Start of memberFunctionString
167918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
167919 :
167920 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
167921 :
167922 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
167923 : const SgOmpClausePtrList &
167924 0 : SgOmpTaskwaitStatement::get_clauses () const
167925 : {
167926 0 : assert (this != NULL);
167927 0 : return p_clauses;
167928 : }
167929 :
167930 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
167931 : SgOmpClausePtrList &
167932 29 : SgOmpTaskwaitStatement::get_clauses ()
167933 : {
167934 29 : assert (this != NULL);
167935 :
167936 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
167937 : // As a rule only set_ access functions can set the isModified flag.
167938 : // set_isModified(true);
167939 :
167940 29 : return p_clauses;
167941 : }
167942 :
167943 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
167944 :
167945 :
167946 : // End of memberFunctionString
167947 : // Start of memberFunctionString
167948 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
167949 :
167950 : // *** COMMON CODE SECTION BEGINS HERE ***
167951 :
167952 : #if 0
167953 : int
167954 : SgOmpTaskwaitStatement::getVariant() const
167955 : {
167956 : // This function is used in ROSE while "variant()" is used in SAGE
167957 : assert(this != NULL);
167958 : return variant();
167959 : }
167960 : #endif
167961 :
167962 : // This function is used in ROSE in treeTraversal code
167963 : // eventually replaces getVariant() and variant()
167964 : // though after variant() has been removed for a while we will
167965 : // want to change the name of variantT() back to variant()
167966 : // (since the "T" was ment to stand for temporary).
167967 : // When this happens the variantT() will be depricated.
167968 : VariantT
167969 3003 : SgOmpTaskwaitStatement::variantT() const
167970 : {
167971 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
167972 3003 : ROSE_ASSERT(this != NULL);
167973 3003 : return V_SgOmpTaskwaitStatement;
167974 : }
167975 :
167976 : #if 0
167977 : int
167978 : SgOmpTaskwaitStatement::variant() const
167979 : {
167980 : // This function is used in SAGE
167981 : ROSE_ASSERT(this != NULL);
167982 : return OMP_TASKWAIT_STMT;
167983 : }
167984 : #endif
167985 :
167986 : ROSE_DLL_API const char*
167987 0 : SgOmpTaskwaitStatement::sage_class_name() const
167988 : {
167989 0 : ROSE_ASSERT(this != NULL);
167990 0 : return "SgOmpTaskwaitStatement";
167991 : }
167992 :
167993 : std::string
167994 28 : SgOmpTaskwaitStatement::class_name() const
167995 : {
167996 28 : ROSE_ASSERT(this != NULL);
167997 28 : return "SgOmpTaskwaitStatement";
167998 : }
167999 :
168000 : // DQ (11/26/2005): Support for visitor pattern mechanims
168001 : // (inferior to ROSE traversal mechanism, experimental).
168002 : void
168003 0 : SgOmpTaskwaitStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
168004 : {
168005 0 : ROSE_ASSERT(this != NULL);
168006 0 : visitor.visit(this);
168007 0 : }
168008 :
168009 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
168010 0 : void SgOmpTaskwaitStatement::accept (ROSE_VisitorPattern & visitor) {
168011 0 : ROSE_ASSERT(this != NULL);
168012 0 : visitor.visit(this);
168013 0 : }
168014 :
168015 : SgOmpTaskwaitStatement*
168016 0 : SgOmpTaskwaitStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
168017 : {
168018 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
168019 : // This function is currently only supported for the AST used the represent Binary executables.
168020 : if (0 /* isSgAsmNode(this) != NULL */)
168021 : {
168022 : // Support for regex specification.
168023 : std::string prefixCode = "REGEX:";
168024 : addNewAttribute(prefixCode + s,a);
168025 : }
168026 : #endif
168027 :
168028 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
168029 0 : return this;
168030 : }
168031 :
168032 : // *** COMMON CODE SECTION ENDS HERE ***
168033 :
168034 :
168035 : // End of memberFunctionString
168036 : // Start of memberFunctionString
168037 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
168038 :
168039 :
168040 : #if 0
168041 : //! Error checking support
168042 : /*! Verifies the following:
168043 : - working getVariant() member function
168044 : - calls base class's error() member function
168045 : Every class has one of these functions.
168046 : */
168047 : bool
168048 : SgOmpTaskwaitStatement::error()
168049 : {
168050 : // Put error checking here
168051 :
168052 : ROSE_ASSERT (this != NULL);
168053 : if (getVariant() != OMP_TASKWAIT_STMT)
168054 : {
168055 : printf ("Error in SgOmpTaskwaitStatement::error(): SgOmpTaskwaitStatement object has a %s variant \n",
168056 : Cxx_GrammarTerminalNames[getVariant()].name);
168057 : // printf ("Error in SgOmpTaskwaitStatement::error() \n");
168058 : ROSE_ABORT();
168059 : }
168060 :
168061 : ROSE_ASSERT (getVariant() == OMP_TASKWAIT_STMT);
168062 : return SgDeclarationStatement::error();
168063 : }
168064 : #endif
168065 :
168066 :
168067 :
168068 : // End of memberFunctionString
168069 :
168070 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
168071 :
168072 909 : SgOmpTaskwaitStatement* isSgOmpTaskwaitStatement ( SgNode* inputDerivedClassPointer )
168073 : {
168074 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
168075 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
168076 : // So to fix this we return NULL directly when the input is NULL and avoid the
168077 : // dynamic_cast in this case. This is likely a performance improvement as well.
168078 : // return dynamic_cast<SgOmpTaskwaitStatement*>(inputDerivedClassPointer);
168079 : // Milind Chabbi (8/28/2013): isSgOmpTaskwaitStatement uses table-driven castability instead of c++ default dynamic_cast
168080 : // this improves the running time performance by 10-20%.
168081 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskwaitStatement*>(inputDerivedClassPointer);
168082 909 : return IS_SgOmpTaskwaitStatement_FAST_MACRO(inputDerivedClassPointer);
168083 : }
168084 :
168085 : // DQ (11/8/2003): Added version of functions taking const pointer
168086 0 : const SgOmpTaskwaitStatement* isSgOmpTaskwaitStatement ( const SgNode* inputDerivedClassPointer )
168087 : {
168088 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
168089 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
168090 : // So to fix this we return NULL directly when the input is NULL and avoid the
168091 : // dynamic_cast in this case. This is likely a performance improvement as well.
168092 : // return dynamic_cast<const SgOmpTaskwaitStatement*>(inputDerivedClassPointer);
168093 : // Milind Chabbi (8/28/2013): isSgOmpTaskwaitStatement uses table-driven castability instead of c++ default dynamic_cast
168094 : // this improves the running time performance by 10-20%.
168095 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskwaitStatement*>(inputDerivedClassPointer);
168096 0 : return IS_SgOmpTaskwaitStatement_FAST_MACRO(inputDerivedClassPointer);
168097 : }
168098 :
168099 :
168100 :
168101 : /* #line 168102 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168102 :
168103 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
168104 :
168105 : /**
168106 : \brief Generated destructor
168107 :
168108 : This destructor is automatically generated (by ROSETTA). This destructor
168109 : only frees memory of data members associated with the parts of the current IR node which
168110 : are NOT traversed. Those data members that are part of a traversal can be freed using
168111 : a traversal (calling this destructor on all children in a post-order traversal). Such
168112 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
168113 :
168114 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
168115 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
168116 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
168117 :
168118 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
168119 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
168120 : pointers are not yet implemented to call delete on eash pointer in the container.
168121 : (This could be done by derivation from the STL containers to define containers that
168122 : automatically deleted their members.)
168123 :
168124 : */
168125 0 : SgOmpTaskwaitStatement::~SgOmpTaskwaitStatement () {
168126 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
168127 :
168128 :
168129 :
168130 : }
168131 :
168132 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
168133 0 : }
168134 :
168135 :
168136 : /* #line 168137 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168137 :
168138 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
168139 :
168140 : // Generated constructor
168141 0 : SgOmpTaskwaitStatement::SgOmpTaskwaitStatement ( Sg_File_Info* startOfConstruct )
168142 0 : : SgDeclarationStatement(startOfConstruct)
168143 : {
168144 : #ifdef DEBUG
168145 : // printf ("In SgOmpTaskwaitStatement::SgOmpTaskwaitStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
168146 : #endif
168147 : #if 0
168148 : // debugging information!
168149 : printf ("In SgOmpTaskwaitStatement::SgOmpTaskwaitStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
168150 : #endif
168151 :
168152 :
168153 :
168154 : #if 0
168155 : // DQ (7/30/2014): Call a virtual function.
168156 : std::string s = this->class_name();
168157 : #endif
168158 :
168159 : // Test the variant virtual function
168160 : // assert(OMP_TASKWAIT_STMT == variant());
168161 0 : assert(OMP_TASKWAIT_STMT == this->variant());
168162 0 : ROSE_ASSERT(OMP_TASKWAIT_STMT == (int)(this->variantT()));
168163 0 : post_construction_initialization();
168164 :
168165 : // Test the isSgOmpTaskwaitStatement() function since it has been problematic
168166 0 : assert(isSgOmpTaskwaitStatement(this) != NULL);
168167 0 : }
168168 :
168169 : // Generated constructor (all data members)
168170 :
168171 : /* #line 168172 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168172 :
168173 :
168174 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
168175 :
168176 :
168177 : // ********************************************************
168178 : // member functions common across all array grammar objects
168179 : // ********************************************************
168180 :
168181 :
168182 :
168183 : /* #line 168184 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168184 :
168185 :
168186 :
168187 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
168188 :
168189 : // ********************************************************
168190 : // member functions specific to each node in the grammar
168191 : // ********************************************************
168192 :
168193 :
168194 : /* #line 168195 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168195 :
168196 : // Start of memberFunctionString
168197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
168198 :
168199 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
168200 :
168201 : SgStatement*
168202 0 : SgStmtDeclarationStatement::get_statement () const
168203 : {
168204 0 : ROSE_ASSERT (this != NULL);
168205 :
168206 : #if 0
168207 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
168208 : // used to trigger marking transformations for the token-based unparsing.
168209 : printf ("SgStmtDeclarationStatement::get_statement = %p = %s \n",this,this->class_name().c_str());
168210 : #endif
168211 :
168212 0 : return p_statement;
168213 : }
168214 :
168215 : void
168216 0 : SgStmtDeclarationStatement::set_statement ( SgStatement* statement )
168217 : {
168218 0 : ROSE_ASSERT (this != NULL);
168219 :
168220 : #if 0
168221 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
168222 : // used to trigger marking transformations for the token-based unparsing.
168223 : printf ("SgStmtDeclarationStatement::set_statement = %p = %s \n",this,this->class_name().c_str());
168224 : #endif
168225 :
168226 0 : set_isModified(true);
168227 :
168228 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
168229 : if (p_statement != NULL && statement != NULL && p_statement != statement)
168230 : {
168231 : printf ("Warning: statement = %p overwriting valid pointer p_statement = %p \n",statement,p_statement);
168232 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
168233 : printf ("Error fails assertion (p_statement != NULL && statement != NULL && p_statement != statement) is false\n");
168234 : ROSE_ASSERT(false);
168235 : #endif
168236 : }
168237 : #endif
168238 0 : p_statement = statement;
168239 0 : }
168240 :
168241 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
168242 :
168243 :
168244 : // End of memberFunctionString
168245 : // Start of memberFunctionString
168246 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
168247 :
168248 : void
168249 0 : SgStmtDeclarationStatement::post_construction_initialization()
168250 : {
168251 0 : }
168252 :
168253 :
168254 :
168255 : // End of memberFunctionString
168256 : // Start of memberFunctionString
168257 : /* #line 13989 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
168258 :
168259 :
168260 : SgName
168261 0 : SgStmtDeclarationStatement::get_mangled_name (void) const {
168262 0 : return SgName("__stmt__decl__stmt__");
168263 : }
168264 :
168265 :
168266 :
168267 : // End of memberFunctionString
168268 : // Start of memberFunctionString
168269 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
168270 :
168271 : // *** COMMON CODE SECTION BEGINS HERE ***
168272 :
168273 : #if 0
168274 : int
168275 : SgStmtDeclarationStatement::getVariant() const
168276 : {
168277 : // This function is used in ROSE while "variant()" is used in SAGE
168278 : assert(this != NULL);
168279 : return variant();
168280 : }
168281 : #endif
168282 :
168283 : // This function is used in ROSE in treeTraversal code
168284 : // eventually replaces getVariant() and variant()
168285 : // though after variant() has been removed for a while we will
168286 : // want to change the name of variantT() back to variant()
168287 : // (since the "T" was ment to stand for temporary).
168288 : // When this happens the variantT() will be depricated.
168289 : VariantT
168290 0 : SgStmtDeclarationStatement::variantT() const
168291 : {
168292 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
168293 0 : ROSE_ASSERT(this != NULL);
168294 0 : return V_SgStmtDeclarationStatement;
168295 : }
168296 :
168297 : #if 0
168298 : int
168299 : SgStmtDeclarationStatement::variant() const
168300 : {
168301 : // This function is used in SAGE
168302 : ROSE_ASSERT(this != NULL);
168303 : return STMT_DECL_STMT;
168304 : }
168305 : #endif
168306 :
168307 : ROSE_DLL_API const char*
168308 0 : SgStmtDeclarationStatement::sage_class_name() const
168309 : {
168310 0 : ROSE_ASSERT(this != NULL);
168311 0 : return "SgStmtDeclarationStatement";
168312 : }
168313 :
168314 : std::string
168315 0 : SgStmtDeclarationStatement::class_name() const
168316 : {
168317 0 : ROSE_ASSERT(this != NULL);
168318 0 : return "SgStmtDeclarationStatement";
168319 : }
168320 :
168321 : // DQ (11/26/2005): Support for visitor pattern mechanims
168322 : // (inferior to ROSE traversal mechanism, experimental).
168323 : void
168324 0 : SgStmtDeclarationStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
168325 : {
168326 0 : ROSE_ASSERT(this != NULL);
168327 0 : visitor.visit(this);
168328 0 : }
168329 :
168330 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
168331 0 : void SgStmtDeclarationStatement::accept (ROSE_VisitorPattern & visitor) {
168332 0 : ROSE_ASSERT(this != NULL);
168333 0 : visitor.visit(this);
168334 0 : }
168335 :
168336 : SgStmtDeclarationStatement*
168337 0 : SgStmtDeclarationStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
168338 : {
168339 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
168340 : // This function is currently only supported for the AST used the represent Binary executables.
168341 : if (0 /* isSgAsmNode(this) != NULL */)
168342 : {
168343 : // Support for regex specification.
168344 : std::string prefixCode = "REGEX:";
168345 : addNewAttribute(prefixCode + s,a);
168346 : }
168347 : #endif
168348 :
168349 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
168350 0 : return this;
168351 : }
168352 :
168353 : // *** COMMON CODE SECTION ENDS HERE ***
168354 :
168355 :
168356 : // End of memberFunctionString
168357 : // Start of memberFunctionString
168358 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
168359 :
168360 :
168361 : #if 0
168362 : //! Error checking support
168363 : /*! Verifies the following:
168364 : - working getVariant() member function
168365 : - calls base class's error() member function
168366 : Every class has one of these functions.
168367 : */
168368 : bool
168369 : SgStmtDeclarationStatement::error()
168370 : {
168371 : // Put error checking here
168372 :
168373 : ROSE_ASSERT (this != NULL);
168374 : if (getVariant() != STMT_DECL_STMT)
168375 : {
168376 : printf ("Error in SgStmtDeclarationStatement::error(): SgStmtDeclarationStatement object has a %s variant \n",
168377 : Cxx_GrammarTerminalNames[getVariant()].name);
168378 : // printf ("Error in SgStmtDeclarationStatement::error() \n");
168379 : ROSE_ABORT();
168380 : }
168381 :
168382 : ROSE_ASSERT (getVariant() == STMT_DECL_STMT);
168383 : return SgDeclarationStatement::error();
168384 : }
168385 : #endif
168386 :
168387 :
168388 :
168389 : // End of memberFunctionString
168390 :
168391 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
168392 :
168393 0 : SgStmtDeclarationStatement* isSgStmtDeclarationStatement ( SgNode* inputDerivedClassPointer )
168394 : {
168395 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
168396 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
168397 : // So to fix this we return NULL directly when the input is NULL and avoid the
168398 : // dynamic_cast in this case. This is likely a performance improvement as well.
168399 : // return dynamic_cast<SgStmtDeclarationStatement*>(inputDerivedClassPointer);
168400 : // Milind Chabbi (8/28/2013): isSgStmtDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
168401 : // this improves the running time performance by 10-20%.
168402 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStmtDeclarationStatement*>(inputDerivedClassPointer);
168403 0 : return IS_SgStmtDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
168404 : }
168405 :
168406 : // DQ (11/8/2003): Added version of functions taking const pointer
168407 0 : const SgStmtDeclarationStatement* isSgStmtDeclarationStatement ( const SgNode* inputDerivedClassPointer )
168408 : {
168409 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
168410 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
168411 : // So to fix this we return NULL directly when the input is NULL and avoid the
168412 : // dynamic_cast in this case. This is likely a performance improvement as well.
168413 : // return dynamic_cast<const SgStmtDeclarationStatement*>(inputDerivedClassPointer);
168414 : // Milind Chabbi (8/28/2013): isSgStmtDeclarationStatement uses table-driven castability instead of c++ default dynamic_cast
168415 : // this improves the running time performance by 10-20%.
168416 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStmtDeclarationStatement*>(inputDerivedClassPointer);
168417 0 : return IS_SgStmtDeclarationStatement_FAST_MACRO(inputDerivedClassPointer);
168418 : }
168419 :
168420 :
168421 :
168422 : /* #line 168423 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168423 :
168424 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
168425 :
168426 : /**
168427 : \brief Generated destructor
168428 :
168429 : This destructor is automatically generated (by ROSETTA). This destructor
168430 : only frees memory of data members associated with the parts of the current IR node which
168431 : are NOT traversed. Those data members that are part of a traversal can be freed using
168432 : a traversal (calling this destructor on all children in a post-order traversal). Such
168433 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
168434 :
168435 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
168436 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
168437 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
168438 :
168439 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
168440 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
168441 : pointers are not yet implemented to call delete on eash pointer in the container.
168442 : (This could be done by derivation from the STL containers to define containers that
168443 : automatically deleted their members.)
168444 :
168445 : */
168446 0 : SgStmtDeclarationStatement::~SgStmtDeclarationStatement () {
168447 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
168448 :
168449 :
168450 : // case: not a listType for statement
168451 0 : p_statement = NULL; // non list case
168452 :
168453 : }
168454 :
168455 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
168456 0 : }
168457 :
168458 :
168459 : /* #line 168460 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168460 :
168461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
168462 :
168463 : // Generated constructor
168464 0 : SgStmtDeclarationStatement::SgStmtDeclarationStatement ( Sg_File_Info* startOfConstruct, SgStatement* statement )
168465 0 : : SgDeclarationStatement(startOfConstruct)
168466 : {
168467 : #ifdef DEBUG
168468 : // printf ("In SgStmtDeclarationStatement::SgStmtDeclarationStatement (Sg_File_Info* startOfConstruct, SgStatement* statement) sage_class_name() = %s \n",sage_class_name());
168469 : #endif
168470 : #if 0
168471 : // debugging information!
168472 : printf ("In SgStmtDeclarationStatement::SgStmtDeclarationStatement (Sg_File_Info* startOfConstruct, SgStatement* statement): this = %p = %s \n",this,this->class_name().c_str());
168473 : #endif
168474 :
168475 0 : p_statement = statement;
168476 :
168477 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
168478 :
168479 : #if 0
168480 : // DQ (7/30/2014): Call a virtual function.
168481 : std::string s = this->class_name();
168482 : #endif
168483 :
168484 : // Test the variant virtual function
168485 : // assert(STMT_DECL_STMT == variant());
168486 0 : assert(STMT_DECL_STMT == this->variant());
168487 0 : ROSE_ASSERT(STMT_DECL_STMT == (int)(this->variantT()));
168488 0 : post_construction_initialization();
168489 :
168490 : // Test the isSgStmtDeclarationStatement() function since it has been problematic
168491 0 : assert(isSgStmtDeclarationStatement(this) != NULL);
168492 0 : }
168493 :
168494 : // Generated constructor (all data members)
168495 :
168496 : /* #line 168497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168497 :
168498 :
168499 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
168500 :
168501 :
168502 : // ********************************************************
168503 : // member functions common across all array grammar objects
168504 : // ********************************************************
168505 :
168506 :
168507 :
168508 : /* #line 168509 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168509 :
168510 :
168511 :
168512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
168513 :
168514 : // ********************************************************
168515 : // member functions specific to each node in the grammar
168516 : // ********************************************************
168517 :
168518 :
168519 : /* #line 168520 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168520 :
168521 : // Start of memberFunctionString
168522 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
168523 :
168524 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
168525 :
168526 : SgExpression*
168527 4 : SgStaticAssertionDeclaration::get_condition () const
168528 : {
168529 4 : ROSE_ASSERT (this != NULL);
168530 :
168531 : #if 0
168532 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
168533 : // used to trigger marking transformations for the token-based unparsing.
168534 : printf ("SgStaticAssertionDeclaration::get_condition = %p = %s \n",this,this->class_name().c_str());
168535 : #endif
168536 :
168537 4 : return p_condition;
168538 : }
168539 :
168540 : void
168541 0 : SgStaticAssertionDeclaration::set_condition ( SgExpression* condition )
168542 : {
168543 0 : ROSE_ASSERT (this != NULL);
168544 :
168545 : #if 0
168546 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
168547 : // used to trigger marking transformations for the token-based unparsing.
168548 : printf ("SgStaticAssertionDeclaration::set_condition = %p = %s \n",this,this->class_name().c_str());
168549 : #endif
168550 :
168551 0 : set_isModified(true);
168552 :
168553 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
168554 : if (p_condition != NULL && condition != NULL && p_condition != condition)
168555 : {
168556 : printf ("Warning: condition = %p overwriting valid pointer p_condition = %p \n",condition,p_condition);
168557 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
168558 : printf ("Error fails assertion (p_condition != NULL && condition != NULL && p_condition != condition) is false\n");
168559 : ROSE_ASSERT(false);
168560 : #endif
168561 : }
168562 : #endif
168563 0 : p_condition = condition;
168564 0 : }
168565 :
168566 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
168567 :
168568 :
168569 : // End of memberFunctionString
168570 : // Start of memberFunctionString
168571 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
168572 :
168573 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
168574 :
168575 : SgName
168576 4 : SgStaticAssertionDeclaration::get_string_literal () const
168577 : {
168578 4 : ROSE_ASSERT (this != NULL);
168579 :
168580 : #if 0
168581 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
168582 : // used to trigger marking transformations for the token-based unparsing.
168583 : printf ("SgStaticAssertionDeclaration::get_string_literal = %p = %s \n",this,this->class_name().c_str());
168584 : #endif
168585 :
168586 4 : return p_string_literal;
168587 : }
168588 :
168589 : void
168590 0 : SgStaticAssertionDeclaration::set_string_literal ( SgName string_literal )
168591 : {
168592 0 : ROSE_ASSERT (this != NULL);
168593 :
168594 : #if 0
168595 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
168596 : // used to trigger marking transformations for the token-based unparsing.
168597 : printf ("SgStaticAssertionDeclaration::set_string_literal = %p = %s \n",this,this->class_name().c_str());
168598 : #endif
168599 :
168600 0 : set_isModified(true);
168601 :
168602 0 : p_string_literal = string_literal;
168603 0 : }
168604 :
168605 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
168606 :
168607 :
168608 : // End of memberFunctionString
168609 : // Start of memberFunctionString
168610 : /* #line 10627 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
168611 :
168612 :
168613 : void
168614 156 : SgStaticAssertionDeclaration::post_construction_initialization()
168615 : {
168616 : // Not sure we have to do anything here!
168617 156 : }
168618 :
168619 : // We need this to be defined to avoid calling the base class version (which is an error).
168620 : SgName
168621 104 : SgStaticAssertionDeclaration::get_mangled_name() const
168622 : {
168623 : // Not sure we have to do anything here!
168624 :
168625 : #if 0
168626 : printf ("Exiting as a test! (SgStaticAssertionDeclaration::get_mangled_name() not implemented) \n");
168627 : ROSE_ASSERT(false);
168628 : #endif
168629 :
168630 104 : return "static_assertion";
168631 : }
168632 :
168633 : bool
168634 235 : SgStaticAssertionDeclaration::hasExplicitScope() const
168635 : {
168636 : // This function reports that this IR node does NOT store its scope explicitly.
168637 235 : return false;
168638 : }
168639 :
168640 :
168641 :
168642 :
168643 : // End of memberFunctionString
168644 : // Start of memberFunctionString
168645 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
168646 :
168647 : // *** COMMON CODE SECTION BEGINS HERE ***
168648 :
168649 : #if 0
168650 : int
168651 : SgStaticAssertionDeclaration::getVariant() const
168652 : {
168653 : // This function is used in ROSE while "variant()" is used in SAGE
168654 : assert(this != NULL);
168655 : return variant();
168656 : }
168657 : #endif
168658 :
168659 : // This function is used in ROSE in treeTraversal code
168660 : // eventually replaces getVariant() and variant()
168661 : // though after variant() has been removed for a while we will
168662 : // want to change the name of variantT() back to variant()
168663 : // (since the "T" was ment to stand for temporary).
168664 : // When this happens the variantT() will be depricated.
168665 : VariantT
168666 84501 : SgStaticAssertionDeclaration::variantT() const
168667 : {
168668 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
168669 84501 : ROSE_ASSERT(this != NULL);
168670 84501 : return V_SgStaticAssertionDeclaration;
168671 : }
168672 :
168673 : #if 0
168674 : int
168675 : SgStaticAssertionDeclaration::variant() const
168676 : {
168677 : // This function is used in SAGE
168678 : ROSE_ASSERT(this != NULL);
168679 : return STATIC_ASSERTION_DECLARATION;
168680 : }
168681 : #endif
168682 :
168683 : ROSE_DLL_API const char*
168684 6 : SgStaticAssertionDeclaration::sage_class_name() const
168685 : {
168686 6 : ROSE_ASSERT(this != NULL);
168687 6 : return "SgStaticAssertionDeclaration";
168688 : }
168689 :
168690 : std::string
168691 123 : SgStaticAssertionDeclaration::class_name() const
168692 : {
168693 123 : ROSE_ASSERT(this != NULL);
168694 123 : return "SgStaticAssertionDeclaration";
168695 : }
168696 :
168697 : // DQ (11/26/2005): Support for visitor pattern mechanims
168698 : // (inferior to ROSE traversal mechanism, experimental).
168699 : void
168700 2044 : SgStaticAssertionDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
168701 : {
168702 2044 : ROSE_ASSERT(this != NULL);
168703 2044 : visitor.visit(this);
168704 2044 : }
168705 :
168706 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
168707 0 : void SgStaticAssertionDeclaration::accept (ROSE_VisitorPattern & visitor) {
168708 0 : ROSE_ASSERT(this != NULL);
168709 0 : visitor.visit(this);
168710 0 : }
168711 :
168712 : SgStaticAssertionDeclaration*
168713 0 : SgStaticAssertionDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
168714 : {
168715 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
168716 : // This function is currently only supported for the AST used the represent Binary executables.
168717 : if (0 /* isSgAsmNode(this) != NULL */)
168718 : {
168719 : // Support for regex specification.
168720 : std::string prefixCode = "REGEX:";
168721 : addNewAttribute(prefixCode + s,a);
168722 : }
168723 : #endif
168724 :
168725 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
168726 0 : return this;
168727 : }
168728 :
168729 : // *** COMMON CODE SECTION ENDS HERE ***
168730 :
168731 :
168732 : // End of memberFunctionString
168733 : // Start of memberFunctionString
168734 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
168735 :
168736 :
168737 : #if 0
168738 : //! Error checking support
168739 : /*! Verifies the following:
168740 : - working getVariant() member function
168741 : - calls base class's error() member function
168742 : Every class has one of these functions.
168743 : */
168744 : bool
168745 : SgStaticAssertionDeclaration::error()
168746 : {
168747 : // Put error checking here
168748 :
168749 : ROSE_ASSERT (this != NULL);
168750 : if (getVariant() != STATIC_ASSERTION_DECLARATION)
168751 : {
168752 : printf ("Error in SgStaticAssertionDeclaration::error(): SgStaticAssertionDeclaration object has a %s variant \n",
168753 : Cxx_GrammarTerminalNames[getVariant()].name);
168754 : // printf ("Error in SgStaticAssertionDeclaration::error() \n");
168755 : ROSE_ABORT();
168756 : }
168757 :
168758 : ROSE_ASSERT (getVariant() == STATIC_ASSERTION_DECLARATION);
168759 : return SgDeclarationStatement::error();
168760 : }
168761 : #endif
168762 :
168763 :
168764 :
168765 : // End of memberFunctionString
168766 :
168767 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
168768 :
168769 160 : SgStaticAssertionDeclaration* isSgStaticAssertionDeclaration ( SgNode* inputDerivedClassPointer )
168770 : {
168771 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
168772 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
168773 : // So to fix this we return NULL directly when the input is NULL and avoid the
168774 : // dynamic_cast in this case. This is likely a performance improvement as well.
168775 : // return dynamic_cast<SgStaticAssertionDeclaration*>(inputDerivedClassPointer);
168776 : // Milind Chabbi (8/28/2013): isSgStaticAssertionDeclaration uses table-driven castability instead of c++ default dynamic_cast
168777 : // this improves the running time performance by 10-20%.
168778 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStaticAssertionDeclaration*>(inputDerivedClassPointer);
168779 160 : return IS_SgStaticAssertionDeclaration_FAST_MACRO(inputDerivedClassPointer);
168780 : }
168781 :
168782 : // DQ (11/8/2003): Added version of functions taking const pointer
168783 0 : const SgStaticAssertionDeclaration* isSgStaticAssertionDeclaration ( const SgNode* inputDerivedClassPointer )
168784 : {
168785 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
168786 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
168787 : // So to fix this we return NULL directly when the input is NULL and avoid the
168788 : // dynamic_cast in this case. This is likely a performance improvement as well.
168789 : // return dynamic_cast<const SgStaticAssertionDeclaration*>(inputDerivedClassPointer);
168790 : // Milind Chabbi (8/28/2013): isSgStaticAssertionDeclaration uses table-driven castability instead of c++ default dynamic_cast
168791 : // this improves the running time performance by 10-20%.
168792 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStaticAssertionDeclaration*>(inputDerivedClassPointer);
168793 0 : return IS_SgStaticAssertionDeclaration_FAST_MACRO(inputDerivedClassPointer);
168794 : }
168795 :
168796 :
168797 :
168798 : /* #line 168799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168799 :
168800 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
168801 :
168802 : /**
168803 : \brief Generated destructor
168804 :
168805 : This destructor is automatically generated (by ROSETTA). This destructor
168806 : only frees memory of data members associated with the parts of the current IR node which
168807 : are NOT traversed. Those data members that are part of a traversal can be freed using
168808 : a traversal (calling this destructor on all children in a post-order traversal). Such
168809 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
168810 :
168811 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
168812 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
168813 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
168814 :
168815 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
168816 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
168817 : pointers are not yet implemented to call delete on eash pointer in the container.
168818 : (This could be done by derivation from the STL containers to define containers that
168819 : automatically deleted their members.)
168820 :
168821 : */
168822 56 : SgStaticAssertionDeclaration::~SgStaticAssertionDeclaration () {
168823 28 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
168824 :
168825 :
168826 : // case: not a listType for condition
168827 28 : p_condition = NULL; // non list case
168828 : // case: not a listType for string_literal
168829 28 : p_string_literal = ""; // non list case
168830 :
168831 : }
168832 :
168833 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
168834 56 : }
168835 :
168836 :
168837 : /* #line 168838 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168838 :
168839 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
168840 :
168841 : // Generated constructor
168842 0 : SgStaticAssertionDeclaration::SgStaticAssertionDeclaration ( Sg_File_Info* startOfConstruct, SgExpression* condition, SgName string_literal )
168843 0 : : SgDeclarationStatement(startOfConstruct)
168844 : {
168845 : #ifdef DEBUG
168846 : // printf ("In SgStaticAssertionDeclaration::SgStaticAssertionDeclaration (Sg_File_Info* startOfConstruct, SgExpression* condition, SgName string_literal) sage_class_name() = %s \n",sage_class_name());
168847 : #endif
168848 : #if 0
168849 : // debugging information!
168850 : printf ("In SgStaticAssertionDeclaration::SgStaticAssertionDeclaration (Sg_File_Info* startOfConstruct, SgExpression* condition, SgName string_literal): this = %p = %s \n",this,this->class_name().c_str());
168851 : #endif
168852 :
168853 0 : p_condition = condition;
168854 0 : p_string_literal = string_literal;
168855 :
168856 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
168857 :
168858 : #if 0
168859 : // DQ (7/30/2014): Call a virtual function.
168860 : std::string s = this->class_name();
168861 : #endif
168862 :
168863 : // Test the variant virtual function
168864 : // assert(STATIC_ASSERTION_DECLARATION == variant());
168865 0 : assert(STATIC_ASSERTION_DECLARATION == this->variant());
168866 0 : ROSE_ASSERT(STATIC_ASSERTION_DECLARATION == (int)(this->variantT()));
168867 0 : post_construction_initialization();
168868 :
168869 : // Test the isSgStaticAssertionDeclaration() function since it has been problematic
168870 0 : assert(isSgStaticAssertionDeclaration(this) != NULL);
168871 0 : }
168872 :
168873 : // Generated constructor (all data members)
168874 :
168875 : /* #line 168876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168876 :
168877 :
168878 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
168879 :
168880 :
168881 : // ********************************************************
168882 : // member functions common across all array grammar objects
168883 : // ********************************************************
168884 :
168885 :
168886 :
168887 : /* #line 168888 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168888 :
168889 :
168890 :
168891 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
168892 :
168893 : // ********************************************************
168894 : // member functions specific to each node in the grammar
168895 : // ********************************************************
168896 :
168897 :
168898 : /* #line 168899 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
168899 :
168900 : // Start of memberFunctionString
168901 : /* #line 19129 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
168902 :
168903 : void
168904 3 : SgOmpDeclareSimdStatement::post_construction_initialization()
168905 3 : {}
168906 :
168907 : SgName
168908 3 : SgOmpDeclareSimdStatement::get_mangled_name(void) const
168909 : {
168910 3 : SgName returnName;
168911 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
168912 3 : SgScopeStatement* scope = get_scope();
168913 3 : ROSE_ASSERT(scope != NULL);
168914 :
168915 3 : returnName = scope->get_mangled_name() + SgName("_omp_declaration_simd_");
168916 : //TODO: need more unique name adding clauses, followed function, etc.
168917 3 : return returnName;
168918 : }
168919 :
168920 :
168921 :
168922 : // End of memberFunctionString
168923 : // Start of memberFunctionString
168924 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
168925 :
168926 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
168927 :
168928 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
168929 : const SgOmpClausePtrList &
168930 0 : SgOmpDeclareSimdStatement::get_clauses () const
168931 : {
168932 0 : assert (this != NULL);
168933 0 : return p_clauses;
168934 : }
168935 :
168936 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
168937 : SgOmpClausePtrList &
168938 8 : SgOmpDeclareSimdStatement::get_clauses ()
168939 : {
168940 8 : assert (this != NULL);
168941 :
168942 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
168943 : // As a rule only set_ access functions can set the isModified flag.
168944 : // set_isModified(true);
168945 :
168946 8 : return p_clauses;
168947 : }
168948 :
168949 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
168950 :
168951 :
168952 : // End of memberFunctionString
168953 : // Start of memberFunctionString
168954 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
168955 :
168956 : // *** COMMON CODE SECTION BEGINS HERE ***
168957 :
168958 : #if 0
168959 : int
168960 : SgOmpDeclareSimdStatement::getVariant() const
168961 : {
168962 : // This function is used in ROSE while "variant()" is used in SAGE
168963 : assert(this != NULL);
168964 : return variant();
168965 : }
168966 : #endif
168967 :
168968 : // This function is used in ROSE in treeTraversal code
168969 : // eventually replaces getVariant() and variant()
168970 : // though after variant() has been removed for a while we will
168971 : // want to change the name of variantT() back to variant()
168972 : // (since the "T" was ment to stand for temporary).
168973 : // When this happens the variantT() will be depricated.
168974 : VariantT
168975 326 : SgOmpDeclareSimdStatement::variantT() const
168976 : {
168977 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
168978 326 : ROSE_ASSERT(this != NULL);
168979 326 : return V_SgOmpDeclareSimdStatement;
168980 : }
168981 :
168982 : #if 0
168983 : int
168984 : SgOmpDeclareSimdStatement::variant() const
168985 : {
168986 : // This function is used in SAGE
168987 : ROSE_ASSERT(this != NULL);
168988 : return OMP_DECLARE_SIMD_STMT;
168989 : }
168990 : #endif
168991 :
168992 : ROSE_DLL_API const char*
168993 0 : SgOmpDeclareSimdStatement::sage_class_name() const
168994 : {
168995 0 : ROSE_ASSERT(this != NULL);
168996 0 : return "SgOmpDeclareSimdStatement";
168997 : }
168998 :
168999 : std::string
169000 3 : SgOmpDeclareSimdStatement::class_name() const
169001 : {
169002 3 : ROSE_ASSERT(this != NULL);
169003 3 : return "SgOmpDeclareSimdStatement";
169004 : }
169005 :
169006 : // DQ (11/26/2005): Support for visitor pattern mechanims
169007 : // (inferior to ROSE traversal mechanism, experimental).
169008 : void
169009 0 : SgOmpDeclareSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
169010 : {
169011 0 : ROSE_ASSERT(this != NULL);
169012 0 : visitor.visit(this);
169013 0 : }
169014 :
169015 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
169016 0 : void SgOmpDeclareSimdStatement::accept (ROSE_VisitorPattern & visitor) {
169017 0 : ROSE_ASSERT(this != NULL);
169018 0 : visitor.visit(this);
169019 0 : }
169020 :
169021 : SgOmpDeclareSimdStatement*
169022 0 : SgOmpDeclareSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
169023 : {
169024 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
169025 : // This function is currently only supported for the AST used the represent Binary executables.
169026 : if (0 /* isSgAsmNode(this) != NULL */)
169027 : {
169028 : // Support for regex specification.
169029 : std::string prefixCode = "REGEX:";
169030 : addNewAttribute(prefixCode + s,a);
169031 : }
169032 : #endif
169033 :
169034 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
169035 0 : return this;
169036 : }
169037 :
169038 : // *** COMMON CODE SECTION ENDS HERE ***
169039 :
169040 :
169041 : // End of memberFunctionString
169042 : // Start of memberFunctionString
169043 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
169044 :
169045 :
169046 : #if 0
169047 : //! Error checking support
169048 : /*! Verifies the following:
169049 : - working getVariant() member function
169050 : - calls base class's error() member function
169051 : Every class has one of these functions.
169052 : */
169053 : bool
169054 : SgOmpDeclareSimdStatement::error()
169055 : {
169056 : // Put error checking here
169057 :
169058 : ROSE_ASSERT (this != NULL);
169059 : if (getVariant() != OMP_DECLARE_SIMD_STMT)
169060 : {
169061 : printf ("Error in SgOmpDeclareSimdStatement::error(): SgOmpDeclareSimdStatement object has a %s variant \n",
169062 : Cxx_GrammarTerminalNames[getVariant()].name);
169063 : // printf ("Error in SgOmpDeclareSimdStatement::error() \n");
169064 : ROSE_ABORT();
169065 : }
169066 :
169067 : ROSE_ASSERT (getVariant() == OMP_DECLARE_SIMD_STMT);
169068 : return SgDeclarationStatement::error();
169069 : }
169070 : #endif
169071 :
169072 :
169073 :
169074 : // End of memberFunctionString
169075 :
169076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
169077 :
169078 1245 : SgOmpDeclareSimdStatement* isSgOmpDeclareSimdStatement ( SgNode* inputDerivedClassPointer )
169079 : {
169080 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
169081 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
169082 : // So to fix this we return NULL directly when the input is NULL and avoid the
169083 : // dynamic_cast in this case. This is likely a performance improvement as well.
169084 : // return dynamic_cast<SgOmpDeclareSimdStatement*>(inputDerivedClassPointer);
169085 : // Milind Chabbi (8/28/2013): isSgOmpDeclareSimdStatement uses table-driven castability instead of c++ default dynamic_cast
169086 : // this improves the running time performance by 10-20%.
169087 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDeclareSimdStatement*>(inputDerivedClassPointer);
169088 1245 : return IS_SgOmpDeclareSimdStatement_FAST_MACRO(inputDerivedClassPointer);
169089 : }
169090 :
169091 : // DQ (11/8/2003): Added version of functions taking const pointer
169092 0 : const SgOmpDeclareSimdStatement* isSgOmpDeclareSimdStatement ( const SgNode* inputDerivedClassPointer )
169093 : {
169094 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
169095 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
169096 : // So to fix this we return NULL directly when the input is NULL and avoid the
169097 : // dynamic_cast in this case. This is likely a performance improvement as well.
169098 : // return dynamic_cast<const SgOmpDeclareSimdStatement*>(inputDerivedClassPointer);
169099 : // Milind Chabbi (8/28/2013): isSgOmpDeclareSimdStatement uses table-driven castability instead of c++ default dynamic_cast
169100 : // this improves the running time performance by 10-20%.
169101 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDeclareSimdStatement*>(inputDerivedClassPointer);
169102 0 : return IS_SgOmpDeclareSimdStatement_FAST_MACRO(inputDerivedClassPointer);
169103 : }
169104 :
169105 :
169106 :
169107 : /* #line 169108 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169108 :
169109 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
169110 :
169111 : /**
169112 : \brief Generated destructor
169113 :
169114 : This destructor is automatically generated (by ROSETTA). This destructor
169115 : only frees memory of data members associated with the parts of the current IR node which
169116 : are NOT traversed. Those data members that are part of a traversal can be freed using
169117 : a traversal (calling this destructor on all children in a post-order traversal). Such
169118 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
169119 :
169120 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
169121 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
169122 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
169123 :
169124 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
169125 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
169126 : pointers are not yet implemented to call delete on eash pointer in the container.
169127 : (This could be done by derivation from the STL containers to define containers that
169128 : automatically deleted their members.)
169129 :
169130 : */
169131 0 : SgOmpDeclareSimdStatement::~SgOmpDeclareSimdStatement () {
169132 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
169133 :
169134 :
169135 :
169136 : }
169137 :
169138 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
169139 0 : }
169140 :
169141 :
169142 : /* #line 169143 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169143 :
169144 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
169145 :
169146 : // Generated constructor
169147 0 : SgOmpDeclareSimdStatement::SgOmpDeclareSimdStatement ( Sg_File_Info* startOfConstruct )
169148 0 : : SgDeclarationStatement(startOfConstruct)
169149 : {
169150 : #ifdef DEBUG
169151 : // printf ("In SgOmpDeclareSimdStatement::SgOmpDeclareSimdStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
169152 : #endif
169153 : #if 0
169154 : // debugging information!
169155 : printf ("In SgOmpDeclareSimdStatement::SgOmpDeclareSimdStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
169156 : #endif
169157 :
169158 :
169159 :
169160 : #if 0
169161 : // DQ (7/30/2014): Call a virtual function.
169162 : std::string s = this->class_name();
169163 : #endif
169164 :
169165 : // Test the variant virtual function
169166 : // assert(OMP_DECLARE_SIMD_STMT == variant());
169167 0 : assert(OMP_DECLARE_SIMD_STMT == this->variant());
169168 0 : ROSE_ASSERT(OMP_DECLARE_SIMD_STMT == (int)(this->variantT()));
169169 0 : post_construction_initialization();
169170 :
169171 : // Test the isSgOmpDeclareSimdStatement() function since it has been problematic
169172 0 : assert(isSgOmpDeclareSimdStatement(this) != NULL);
169173 0 : }
169174 :
169175 : // Generated constructor (all data members)
169176 :
169177 : /* #line 169178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169178 :
169179 :
169180 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
169181 :
169182 :
169183 : // ********************************************************
169184 : // member functions common across all array grammar objects
169185 : // ********************************************************
169186 :
169187 :
169188 :
169189 : /* #line 169190 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169190 :
169191 :
169192 :
169193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
169194 :
169195 : // ********************************************************
169196 : // member functions specific to each node in the grammar
169197 : // ********************************************************
169198 :
169199 :
169200 : /* #line 169201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169201 :
169202 : // Start of memberFunctionString
169203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169204 :
169205 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169206 :
169207 : SgName
169208 0 : SgMicrosoftAttributeDeclaration::get_attribute_string () const
169209 : {
169210 0 : ROSE_ASSERT (this != NULL);
169211 :
169212 : #if 0
169213 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169214 : // used to trigger marking transformations for the token-based unparsing.
169215 : printf ("SgMicrosoftAttributeDeclaration::get_attribute_string = %p = %s \n",this,this->class_name().c_str());
169216 : #endif
169217 :
169218 0 : return p_attribute_string;
169219 : }
169220 :
169221 : void
169222 0 : SgMicrosoftAttributeDeclaration::set_attribute_string ( SgName attribute_string )
169223 : {
169224 0 : ROSE_ASSERT (this != NULL);
169225 :
169226 : #if 0
169227 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169228 : // used to trigger marking transformations for the token-based unparsing.
169229 : printf ("SgMicrosoftAttributeDeclaration::set_attribute_string = %p = %s \n",this,this->class_name().c_str());
169230 : #endif
169231 :
169232 0 : set_isModified(true);
169233 :
169234 0 : p_attribute_string = attribute_string;
169235 0 : }
169236 :
169237 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169238 :
169239 :
169240 : // End of memberFunctionString
169241 : // Start of memberFunctionString
169242 : /* #line 19580 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
169243 :
169244 :
169245 : void
169246 0 : SgMicrosoftAttributeDeclaration::post_construction_initialization()
169247 : {
169248 : // Not sure we have to do anything here!
169249 0 : }
169250 :
169251 : // We need this to be defined to avoid calling the base class version (which is an error).
169252 : SgName
169253 0 : SgMicrosoftAttributeDeclaration::get_mangled_name() const
169254 : {
169255 : // Not sure we have to do anything here!
169256 :
169257 : #if 0
169258 : printf ("Exiting as a test! (SgMicrosoftAttributeDeclaration::get_mangled_name() not implemented) \n");
169259 : ROSE_ASSERT(false);
169260 : #endif
169261 :
169262 0 : return "microsoft_attribute";
169263 : }
169264 :
169265 : bool
169266 0 : SgMicrosoftAttributeDeclaration::hasExplicitScope() const
169267 : {
169268 : // This function reports that this IR node does NOT store its scope explicitly.
169269 0 : return false;
169270 : }
169271 :
169272 :
169273 : // End of memberFunctionString
169274 : // Start of memberFunctionString
169275 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
169276 :
169277 : // *** COMMON CODE SECTION BEGINS HERE ***
169278 :
169279 : #if 0
169280 : int
169281 : SgMicrosoftAttributeDeclaration::getVariant() const
169282 : {
169283 : // This function is used in ROSE while "variant()" is used in SAGE
169284 : assert(this != NULL);
169285 : return variant();
169286 : }
169287 : #endif
169288 :
169289 : // This function is used in ROSE in treeTraversal code
169290 : // eventually replaces getVariant() and variant()
169291 : // though after variant() has been removed for a while we will
169292 : // want to change the name of variantT() back to variant()
169293 : // (since the "T" was ment to stand for temporary).
169294 : // When this happens the variantT() will be depricated.
169295 : VariantT
169296 0 : SgMicrosoftAttributeDeclaration::variantT() const
169297 : {
169298 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
169299 0 : ROSE_ASSERT(this != NULL);
169300 0 : return V_SgMicrosoftAttributeDeclaration;
169301 : }
169302 :
169303 : #if 0
169304 : int
169305 : SgMicrosoftAttributeDeclaration::variant() const
169306 : {
169307 : // This function is used in SAGE
169308 : ROSE_ASSERT(this != NULL);
169309 : return MS_ATTRIBUTE_DECL_STMT;
169310 : }
169311 : #endif
169312 :
169313 : ROSE_DLL_API const char*
169314 0 : SgMicrosoftAttributeDeclaration::sage_class_name() const
169315 : {
169316 0 : ROSE_ASSERT(this != NULL);
169317 0 : return "SgMicrosoftAttributeDeclaration";
169318 : }
169319 :
169320 : std::string
169321 0 : SgMicrosoftAttributeDeclaration::class_name() const
169322 : {
169323 0 : ROSE_ASSERT(this != NULL);
169324 0 : return "SgMicrosoftAttributeDeclaration";
169325 : }
169326 :
169327 : // DQ (11/26/2005): Support for visitor pattern mechanims
169328 : // (inferior to ROSE traversal mechanism, experimental).
169329 : void
169330 0 : SgMicrosoftAttributeDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
169331 : {
169332 0 : ROSE_ASSERT(this != NULL);
169333 0 : visitor.visit(this);
169334 0 : }
169335 :
169336 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
169337 0 : void SgMicrosoftAttributeDeclaration::accept (ROSE_VisitorPattern & visitor) {
169338 0 : ROSE_ASSERT(this != NULL);
169339 0 : visitor.visit(this);
169340 0 : }
169341 :
169342 : SgMicrosoftAttributeDeclaration*
169343 0 : SgMicrosoftAttributeDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
169344 : {
169345 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
169346 : // This function is currently only supported for the AST used the represent Binary executables.
169347 : if (0 /* isSgAsmNode(this) != NULL */)
169348 : {
169349 : // Support for regex specification.
169350 : std::string prefixCode = "REGEX:";
169351 : addNewAttribute(prefixCode + s,a);
169352 : }
169353 : #endif
169354 :
169355 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
169356 0 : return this;
169357 : }
169358 :
169359 : // *** COMMON CODE SECTION ENDS HERE ***
169360 :
169361 :
169362 : // End of memberFunctionString
169363 : // Start of memberFunctionString
169364 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
169365 :
169366 :
169367 : #if 0
169368 : //! Error checking support
169369 : /*! Verifies the following:
169370 : - working getVariant() member function
169371 : - calls base class's error() member function
169372 : Every class has one of these functions.
169373 : */
169374 : bool
169375 : SgMicrosoftAttributeDeclaration::error()
169376 : {
169377 : // Put error checking here
169378 :
169379 : ROSE_ASSERT (this != NULL);
169380 : if (getVariant() != MS_ATTRIBUTE_DECL_STMT)
169381 : {
169382 : printf ("Error in SgMicrosoftAttributeDeclaration::error(): SgMicrosoftAttributeDeclaration object has a %s variant \n",
169383 : Cxx_GrammarTerminalNames[getVariant()].name);
169384 : // printf ("Error in SgMicrosoftAttributeDeclaration::error() \n");
169385 : ROSE_ABORT();
169386 : }
169387 :
169388 : ROSE_ASSERT (getVariant() == MS_ATTRIBUTE_DECL_STMT);
169389 : return SgDeclarationStatement::error();
169390 : }
169391 : #endif
169392 :
169393 :
169394 :
169395 : // End of memberFunctionString
169396 :
169397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
169398 :
169399 0 : SgMicrosoftAttributeDeclaration* isSgMicrosoftAttributeDeclaration ( SgNode* inputDerivedClassPointer )
169400 : {
169401 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
169402 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
169403 : // So to fix this we return NULL directly when the input is NULL and avoid the
169404 : // dynamic_cast in this case. This is likely a performance improvement as well.
169405 : // return dynamic_cast<SgMicrosoftAttributeDeclaration*>(inputDerivedClassPointer);
169406 : // Milind Chabbi (8/28/2013): isSgMicrosoftAttributeDeclaration uses table-driven castability instead of c++ default dynamic_cast
169407 : // this improves the running time performance by 10-20%.
169408 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMicrosoftAttributeDeclaration*>(inputDerivedClassPointer);
169409 0 : return IS_SgMicrosoftAttributeDeclaration_FAST_MACRO(inputDerivedClassPointer);
169410 : }
169411 :
169412 : // DQ (11/8/2003): Added version of functions taking const pointer
169413 0 : const SgMicrosoftAttributeDeclaration* isSgMicrosoftAttributeDeclaration ( const SgNode* inputDerivedClassPointer )
169414 : {
169415 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
169416 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
169417 : // So to fix this we return NULL directly when the input is NULL and avoid the
169418 : // dynamic_cast in this case. This is likely a performance improvement as well.
169419 : // return dynamic_cast<const SgMicrosoftAttributeDeclaration*>(inputDerivedClassPointer);
169420 : // Milind Chabbi (8/28/2013): isSgMicrosoftAttributeDeclaration uses table-driven castability instead of c++ default dynamic_cast
169421 : // this improves the running time performance by 10-20%.
169422 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMicrosoftAttributeDeclaration*>(inputDerivedClassPointer);
169423 0 : return IS_SgMicrosoftAttributeDeclaration_FAST_MACRO(inputDerivedClassPointer);
169424 : }
169425 :
169426 :
169427 :
169428 : /* #line 169429 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169429 :
169430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
169431 :
169432 : /**
169433 : \brief Generated destructor
169434 :
169435 : This destructor is automatically generated (by ROSETTA). This destructor
169436 : only frees memory of data members associated with the parts of the current IR node which
169437 : are NOT traversed. Those data members that are part of a traversal can be freed using
169438 : a traversal (calling this destructor on all children in a post-order traversal). Such
169439 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
169440 :
169441 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
169442 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
169443 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
169444 :
169445 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
169446 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
169447 : pointers are not yet implemented to call delete on eash pointer in the container.
169448 : (This could be done by derivation from the STL containers to define containers that
169449 : automatically deleted their members.)
169450 :
169451 : */
169452 0 : SgMicrosoftAttributeDeclaration::~SgMicrosoftAttributeDeclaration () {
169453 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
169454 :
169455 :
169456 : // case: not a listType for attribute_string
169457 0 : p_attribute_string = ""; // non list case
169458 :
169459 : }
169460 :
169461 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
169462 0 : }
169463 :
169464 :
169465 : /* #line 169466 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169466 :
169467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
169468 :
169469 : // Generated constructor
169470 0 : SgMicrosoftAttributeDeclaration::SgMicrosoftAttributeDeclaration ( Sg_File_Info* startOfConstruct, SgName attribute_string )
169471 0 : : SgDeclarationStatement(startOfConstruct)
169472 : {
169473 : #ifdef DEBUG
169474 : // printf ("In SgMicrosoftAttributeDeclaration::SgMicrosoftAttributeDeclaration (Sg_File_Info* startOfConstruct, SgName attribute_string) sage_class_name() = %s \n",sage_class_name());
169475 : #endif
169476 : #if 0
169477 : // debugging information!
169478 : printf ("In SgMicrosoftAttributeDeclaration::SgMicrosoftAttributeDeclaration (Sg_File_Info* startOfConstruct, SgName attribute_string): this = %p = %s \n",this,this->class_name().c_str());
169479 : #endif
169480 :
169481 0 : p_attribute_string = attribute_string;
169482 :
169483 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
169484 :
169485 : #if 0
169486 : // DQ (7/30/2014): Call a virtual function.
169487 : std::string s = this->class_name();
169488 : #endif
169489 :
169490 : // Test the variant virtual function
169491 : // assert(MS_ATTRIBUTE_DECL_STMT == variant());
169492 0 : assert(MS_ATTRIBUTE_DECL_STMT == this->variant());
169493 0 : ROSE_ASSERT(MS_ATTRIBUTE_DECL_STMT == (int)(this->variantT()));
169494 0 : post_construction_initialization();
169495 :
169496 : // Test the isSgMicrosoftAttributeDeclaration() function since it has been problematic
169497 0 : assert(isSgMicrosoftAttributeDeclaration(this) != NULL);
169498 0 : }
169499 :
169500 : // Generated constructor (all data members)
169501 :
169502 : /* #line 169503 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169503 :
169504 :
169505 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
169506 :
169507 :
169508 : // ********************************************************
169509 : // member functions common across all array grammar objects
169510 : // ********************************************************
169511 :
169512 :
169513 :
169514 : /* #line 169515 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169515 :
169516 :
169517 :
169518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
169519 :
169520 : // ********************************************************
169521 : // member functions specific to each node in the grammar
169522 : // ********************************************************
169523 :
169524 :
169525 : /* #line 169526 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
169526 :
169527 : // Start of memberFunctionString
169528 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169529 :
169530 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169531 :
169532 : SgDeclarationScope*
169533 53852 : SgNonrealDecl::get_nonreal_decl_scope () const
169534 : {
169535 53852 : ROSE_ASSERT (this != NULL);
169536 :
169537 : #if 0
169538 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169539 : // used to trigger marking transformations for the token-based unparsing.
169540 : printf ("SgNonrealDecl::get_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
169541 : #endif
169542 :
169543 53852 : return p_nonreal_decl_scope;
169544 : }
169545 :
169546 : void
169547 49519 : SgNonrealDecl::set_nonreal_decl_scope ( SgDeclarationScope* nonreal_decl_scope )
169548 : {
169549 49519 : ROSE_ASSERT (this != NULL);
169550 :
169551 : #if 0
169552 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169553 : // used to trigger marking transformations for the token-based unparsing.
169554 : printf ("SgNonrealDecl::set_nonreal_decl_scope = %p = %s \n",this,this->class_name().c_str());
169555 : #endif
169556 :
169557 49519 : set_isModified(true);
169558 :
169559 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
169560 : if (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope)
169561 : {
169562 : printf ("Warning: nonreal_decl_scope = %p overwriting valid pointer p_nonreal_decl_scope = %p \n",nonreal_decl_scope,p_nonreal_decl_scope);
169563 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
169564 : printf ("Error fails assertion (p_nonreal_decl_scope != NULL && nonreal_decl_scope != NULL && p_nonreal_decl_scope != nonreal_decl_scope) is false\n");
169565 : ROSE_ASSERT(false);
169566 : #endif
169567 : }
169568 : #endif
169569 49519 : p_nonreal_decl_scope = nonreal_decl_scope;
169570 49519 : }
169571 :
169572 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169573 :
169574 :
169575 : // End of memberFunctionString
169576 : // Start of memberFunctionString
169577 :
169578 :
169579 : // End of memberFunctionString
169580 : // Start of memberFunctionString
169581 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169582 :
169583 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169584 :
169585 : int
169586 55852 : SgNonrealDecl::get_template_parameter_position () const
169587 : {
169588 55852 : ROSE_ASSERT (this != NULL);
169589 :
169590 : #if 0
169591 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169592 : // used to trigger marking transformations for the token-based unparsing.
169593 : printf ("SgNonrealDecl::get_template_parameter_position = %p = %s \n",this,this->class_name().c_str());
169594 : #endif
169595 :
169596 55852 : return p_template_parameter_position;
169597 : }
169598 :
169599 : void
169600 24590 : SgNonrealDecl::set_template_parameter_position ( int template_parameter_position )
169601 : {
169602 24590 : ROSE_ASSERT (this != NULL);
169603 :
169604 : #if 0
169605 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169606 : // used to trigger marking transformations for the token-based unparsing.
169607 : printf ("SgNonrealDecl::set_template_parameter_position = %p = %s \n",this,this->class_name().c_str());
169608 : #endif
169609 :
169610 24590 : set_isModified(true);
169611 :
169612 24590 : p_template_parameter_position = template_parameter_position;
169613 24590 : }
169614 :
169615 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169616 :
169617 :
169618 : // End of memberFunctionString
169619 : // Start of memberFunctionString
169620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169621 :
169622 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169623 :
169624 : int
169625 0 : SgNonrealDecl::get_template_parameter_depth () const
169626 : {
169627 0 : ROSE_ASSERT (this != NULL);
169628 :
169629 : #if 0
169630 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169631 : // used to trigger marking transformations for the token-based unparsing.
169632 : printf ("SgNonrealDecl::get_template_parameter_depth = %p = %s \n",this,this->class_name().c_str());
169633 : #endif
169634 :
169635 0 : return p_template_parameter_depth;
169636 : }
169637 :
169638 : void
169639 24590 : SgNonrealDecl::set_template_parameter_depth ( int template_parameter_depth )
169640 : {
169641 24590 : ROSE_ASSERT (this != NULL);
169642 :
169643 : #if 0
169644 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169645 : // used to trigger marking transformations for the token-based unparsing.
169646 : printf ("SgNonrealDecl::set_template_parameter_depth = %p = %s \n",this,this->class_name().c_str());
169647 : #endif
169648 :
169649 24590 : set_isModified(true);
169650 :
169651 24590 : p_template_parameter_depth = template_parameter_depth;
169652 24590 : }
169653 :
169654 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169655 :
169656 :
169657 : // End of memberFunctionString
169658 : // Start of memberFunctionString
169659 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169660 :
169661 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169662 :
169663 : SgDeclarationStatement*
169664 189688 : SgNonrealDecl::get_templateDeclaration () const
169665 : {
169666 189688 : ROSE_ASSERT (this != NULL);
169667 :
169668 : #if 0
169669 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169670 : // used to trigger marking transformations for the token-based unparsing.
169671 : printf ("SgNonrealDecl::get_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
169672 : #endif
169673 :
169674 189688 : return p_templateDeclaration;
169675 : }
169676 :
169677 : void
169678 16988 : SgNonrealDecl::set_templateDeclaration ( SgDeclarationStatement* templateDeclaration )
169679 : {
169680 16988 : ROSE_ASSERT (this != NULL);
169681 :
169682 : #if 0
169683 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169684 : // used to trigger marking transformations for the token-based unparsing.
169685 : printf ("SgNonrealDecl::set_templateDeclaration = %p = %s \n",this,this->class_name().c_str());
169686 : #endif
169687 :
169688 16988 : set_isModified(true);
169689 :
169690 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
169691 : if (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration)
169692 : {
169693 : printf ("Warning: templateDeclaration = %p overwriting valid pointer p_templateDeclaration = %p \n",templateDeclaration,p_templateDeclaration);
169694 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
169695 : printf ("Error fails assertion (p_templateDeclaration != NULL && templateDeclaration != NULL && p_templateDeclaration != templateDeclaration) is false\n");
169696 : ROSE_ASSERT(false);
169697 : #endif
169698 : }
169699 : #endif
169700 16988 : p_templateDeclaration = templateDeclaration;
169701 16988 : }
169702 :
169703 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169704 :
169705 :
169706 : // End of memberFunctionString
169707 : // Start of memberFunctionString
169708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
169709 :
169710 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169711 :
169712 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
169713 : const SgTemplateArgumentPtrList &
169714 580381 : SgNonrealDecl::get_tpl_args () const
169715 : {
169716 580381 : assert (this != NULL);
169717 580381 : return p_tpl_args;
169718 : }
169719 :
169720 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
169721 : SgTemplateArgumentPtrList &
169722 253131 : SgNonrealDecl::get_tpl_args ()
169723 : {
169724 253131 : assert (this != NULL);
169725 :
169726 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
169727 : // As a rule only set_ access functions can set the isModified flag.
169728 : // set_isModified(true);
169729 :
169730 253131 : return p_tpl_args;
169731 : }
169732 :
169733 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169734 :
169735 :
169736 : // End of memberFunctionString
169737 : // Start of memberFunctionString
169738 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
169739 :
169740 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169741 :
169742 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
169743 : const SgTemplateParameterPtrList &
169744 457704 : SgNonrealDecl::get_tpl_params () const
169745 : {
169746 457704 : assert (this != NULL);
169747 457704 : return p_tpl_params;
169748 : }
169749 :
169750 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
169751 : SgTemplateParameterPtrList &
169752 55348 : SgNonrealDecl::get_tpl_params ()
169753 : {
169754 55348 : assert (this != NULL);
169755 :
169756 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
169757 : // As a rule only set_ access functions can set the isModified flag.
169758 : // set_isModified(true);
169759 :
169760 55348 : return p_tpl_params;
169761 : }
169762 :
169763 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169764 :
169765 :
169766 : // End of memberFunctionString
169767 : // Start of memberFunctionString
169768 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169769 :
169770 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169771 :
169772 : bool
169773 464539 : SgNonrealDecl::get_is_class_member () const
169774 : {
169775 464539 : ROSE_ASSERT (this != NULL);
169776 :
169777 : #if 0
169778 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169779 : // used to trigger marking transformations for the token-based unparsing.
169780 : printf ("SgNonrealDecl::get_is_class_member = %p = %s \n",this,this->class_name().c_str());
169781 : #endif
169782 :
169783 464539 : return p_is_class_member;
169784 : }
169785 :
169786 : void
169787 14948 : SgNonrealDecl::set_is_class_member ( bool is_class_member )
169788 : {
169789 14948 : ROSE_ASSERT (this != NULL);
169790 :
169791 : #if 0
169792 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169793 : // used to trigger marking transformations for the token-based unparsing.
169794 : printf ("SgNonrealDecl::set_is_class_member = %p = %s \n",this,this->class_name().c_str());
169795 : #endif
169796 :
169797 14948 : set_isModified(true);
169798 :
169799 14948 : p_is_class_member = is_class_member;
169800 14948 : }
169801 :
169802 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169803 :
169804 :
169805 : // End of memberFunctionString
169806 : // Start of memberFunctionString
169807 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169808 :
169809 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169810 :
169811 : bool
169812 481636 : SgNonrealDecl::get_is_template_param () const
169813 : {
169814 481636 : ROSE_ASSERT (this != NULL);
169815 :
169816 : #if 0
169817 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169818 : // used to trigger marking transformations for the token-based unparsing.
169819 : printf ("SgNonrealDecl::get_is_template_param = %p = %s \n",this,this->class_name().c_str());
169820 : #endif
169821 :
169822 481636 : return p_is_template_param;
169823 : }
169824 :
169825 : void
169826 19720 : SgNonrealDecl::set_is_template_param ( bool is_template_param )
169827 : {
169828 19720 : ROSE_ASSERT (this != NULL);
169829 :
169830 : #if 0
169831 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169832 : // used to trigger marking transformations for the token-based unparsing.
169833 : printf ("SgNonrealDecl::set_is_template_param = %p = %s \n",this,this->class_name().c_str());
169834 : #endif
169835 :
169836 19720 : set_isModified(true);
169837 :
169838 19720 : p_is_template_param = is_template_param;
169839 19720 : }
169840 :
169841 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169842 :
169843 :
169844 : // End of memberFunctionString
169845 : // Start of memberFunctionString
169846 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169847 :
169848 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169849 :
169850 : bool
169851 0 : SgNonrealDecl::get_is_template_template_param () const
169852 : {
169853 0 : ROSE_ASSERT (this != NULL);
169854 :
169855 : #if 0
169856 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169857 : // used to trigger marking transformations for the token-based unparsing.
169858 : printf ("SgNonrealDecl::get_is_template_template_param = %p = %s \n",this,this->class_name().c_str());
169859 : #endif
169860 :
169861 0 : return p_is_template_template_param;
169862 : }
169863 :
169864 : void
169865 80 : SgNonrealDecl::set_is_template_template_param ( bool is_template_template_param )
169866 : {
169867 80 : ROSE_ASSERT (this != NULL);
169868 :
169869 : #if 0
169870 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169871 : // used to trigger marking transformations for the token-based unparsing.
169872 : printf ("SgNonrealDecl::set_is_template_template_param = %p = %s \n",this,this->class_name().c_str());
169873 : #endif
169874 :
169875 80 : set_isModified(true);
169876 :
169877 80 : p_is_template_template_param = is_template_template_param;
169878 80 : }
169879 :
169880 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169881 :
169882 :
169883 : // End of memberFunctionString
169884 : // Start of memberFunctionString
169885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169886 :
169887 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169888 :
169889 : bool
169890 18701 : SgNonrealDecl::get_is_nonreal_template () const
169891 : {
169892 18701 : ROSE_ASSERT (this != NULL);
169893 :
169894 : #if 0
169895 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169896 : // used to trigger marking transformations for the token-based unparsing.
169897 : printf ("SgNonrealDecl::get_is_nonreal_template = %p = %s \n",this,this->class_name().c_str());
169898 : #endif
169899 :
169900 18701 : return p_is_nonreal_template;
169901 : }
169902 :
169903 : void
169904 64 : SgNonrealDecl::set_is_nonreal_template ( bool is_nonreal_template )
169905 : {
169906 64 : ROSE_ASSERT (this != NULL);
169907 :
169908 : #if 0
169909 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169910 : // used to trigger marking transformations for the token-based unparsing.
169911 : printf ("SgNonrealDecl::set_is_nonreal_template = %p = %s \n",this,this->class_name().c_str());
169912 : #endif
169913 :
169914 64 : set_isModified(true);
169915 :
169916 64 : p_is_nonreal_template = is_nonreal_template;
169917 64 : }
169918 :
169919 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169920 :
169921 :
169922 : // End of memberFunctionString
169923 : // Start of memberFunctionString
169924 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
169925 :
169926 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
169927 :
169928 : bool
169929 445 : SgNonrealDecl::get_is_nonreal_function () const
169930 : {
169931 445 : ROSE_ASSERT (this != NULL);
169932 :
169933 : #if 0
169934 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169935 : // used to trigger marking transformations for the token-based unparsing.
169936 : printf ("SgNonrealDecl::get_is_nonreal_function = %p = %s \n",this,this->class_name().c_str());
169937 : #endif
169938 :
169939 445 : return p_is_nonreal_function;
169940 : }
169941 :
169942 : void
169943 2145 : SgNonrealDecl::set_is_nonreal_function ( bool is_nonreal_function )
169944 : {
169945 2145 : ROSE_ASSERT (this != NULL);
169946 :
169947 : #if 0
169948 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
169949 : // used to trigger marking transformations for the token-based unparsing.
169950 : printf ("SgNonrealDecl::set_is_nonreal_function = %p = %s \n",this,this->class_name().c_str());
169951 : #endif
169952 :
169953 2145 : set_isModified(true);
169954 :
169955 2145 : p_is_nonreal_function = is_nonreal_function;
169956 2145 : }
169957 :
169958 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
169959 :
169960 :
169961 : // End of memberFunctionString
169962 : // Start of memberFunctionString
169963 : /* #line 13783 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
169964 :
169965 :
169966 : void
169967 49325 : SgNonrealDecl::post_construction_initialization() {}
169968 :
169969 394075 : SgName SgNonrealDecl::get_name (void) const {
169970 394075 : return p_name;
169971 : }
169972 :
169973 0 : void SgNonrealDecl::set_name (SgName name) {
169974 0 : p_name = name;
169975 0 : }
169976 :
169977 122582 : SgNonrealType* SgNonrealDecl::get_type (void) const {
169978 122582 : return p_type;
169979 : }
169980 :
169981 49325 : void SgNonrealDecl::set_type (SgNonrealType* t) {
169982 49325 : p_type = t;
169983 49325 : }
169984 :
169985 : #define DEBUG_NONREAL_DECL_MANGLED 0
169986 : #define WARN_NONREAL_DECL_MANGLED 0
169987 :
169988 : SgName
169989 457452 : SgNonrealDecl::get_mangled_name (void) const {
169990 : #if DEBUG_NONREAL_DECL_MANGLED
169991 : printf("In SgNonrealDecl::get_mangled_name():\n");
169992 : printf(" - this = %p\n", this);
169993 : printf(" - name = %s\n", get_name().str());
169994 : #endif
169995 457452 : ostringstream mangled_name;
169996 :
169997 457452 : SgNode * parent_decl = NULL;
169998 457452 : SgScopeStatement * scope = get_scope();
169999 457452 : if (scope != NULL) {
170000 : #if DEBUG_NONREAL_DECL_MANGLED
170001 : printf(" - scope = %p (%s)\n", scope, scope ? scope->class_name().c_str() : "");
170002 : #endif
170003 :
170004 457452 : SgDeclarationScope * s_nrscope = isSgDeclarationScope(scope);
170005 457452 : if (s_nrscope == NULL) {
170006 0 : printf("[ROSE-1881] SgNonrealDecl::get_mangled_name:\n> Scope is not an instantiation scope (nonreal)!\n> First observed for test2007_41.C in copyAST_tests.\n> Please report to nersc-rose-public@lbl.gov\n");
170007 : }
170008 :
170009 457452 : parent_decl = scope->get_parent();
170010 : } else {
170011 0 : parent_decl = get_parent();
170012 :
170013 0 : SgNonrealBaseClass * nrbaseclass = isSgNonrealBaseClass(parent_decl);
170014 0 : if (nrbaseclass != NULL) {
170015 0 : printf("[ROSE-1881] SgNonrealDecl::get_mangled_name:\n> Scope is not set when parent is nonreal base class!\n> First observed for test2006_79.C in copyAST_tests.\n> Please report to nersc-rose-public@lbl.gov\n");
170016 :
170017 0 : SgClassDefinition * xdefn = isSgClassDefinition(nrbaseclass->get_parent());
170018 0 : ROSE_ASSERT(xdefn != NULL);
170019 0 : parent_decl = xdefn->get_parent();
170020 : } else {
170021 0 : ROSE_ASSERT(false);
170022 : }
170023 0 : ROSE_ASSERT(parent_decl != NULL);
170024 : }
170025 : #if DEBUG_NONREAL_DECL_MANGLED
170026 : printf(" - parent_decl = %p (%s)\n", parent_decl, parent_decl ? parent_decl->class_name().c_str() : "");
170027 : #endif
170028 :
170029 457452 : if (get_is_class_member()) {
170030 50165 : SgTemplateClassDeclaration * tplcdecl = isSgTemplateClassDeclaration(parent_decl);
170031 50165 : SgClassDeclaration * xdecl = isSgClassDeclaration(parent_decl);
170032 50165 : SgNonrealDecl * nrdecl = isSgNonrealDecl(parent_decl);
170033 50165 : if (tplcdecl != NULL) {
170034 5222 : SgDeclarationScope * nrscope = tplcdecl->get_nonreal_decl_scope();
170035 : #if DEBUG_NONREAL_DECL_MANGLED
170036 : printf(" - nrscope = %p\n", nrscope);
170037 : #endif
170038 5222 : if (nrscope != scope) {
170039 0 : mangled_name << tplcdecl->get_mangled_name().getString() << "___";
170040 : }
170041 44943 : } else if (xdecl != NULL) {
170042 0 : mangled_name << xdecl->get_mangled_name().getString() << "___";
170043 44943 : } else if (nrdecl != NULL) {
170044 : #if DEBUG_NONREAL_DECL_MANGLED
170045 : SgDeclarationScope * nrscope = nrdecl->get_nonreal_decl_scope();
170046 : printf(" - nrscope = %p\n", nrscope);
170047 : #endif
170048 44444 : mangled_name << nrdecl->get_mangled_name().getString() << "___";
170049 : }
170050 : }
170051 :
170052 457452 : if (get_is_template_param()) {
170053 : #if 0
170054 : ROSE_ASSERT(parent_decl != NULL);
170055 : SgDeclarationStatement * parent_declstmt = isSgDeclarationStatement(parent_decl);
170056 :
170057 : SgScopeStatement * parent_scope = parent_declstmt != NULL ? parent_declstmt->get_scope() : NULL;
170058 : #if DEBUG_NONREAL_DECL_MANGLED
170059 : printf(" - parent_scope = %p (%s)\n", parent_scope, parent_scope ? parent_scope->class_name().c_str() : "");
170060 : #endif
170061 :
170062 : SgDeclarationScope * parent_nrscope = isSgDeclarationScope(parent_scope);
170063 : #if DEBUG_NONREAL_DECL_MANGLED
170064 : printf(" - parent_nrscope = %p (%s)\n", parent_nrscope, parent_nrscope ? parent_nrscope->class_name().c_str() : "");
170065 : #endif
170066 :
170067 : parent_declstmt = parent_nrscope != NULL ? isSgDeclarationStatement(parent_nrscope->get_parent()) : NULL;
170068 : #if DEBUG_NONREAL_DECL_MANGLED
170069 : printf(" - parent_declstmt = %p\n", parent_declstmt);
170070 : #endif
170071 :
170072 : if (parent_declstmt != NULL) {
170073 : mangled_name << parent_declstmt->get_mangled_name().getString() << "___";
170074 : }
170075 : #endif
170076 286145 : if (p_template_parameter_depth > 1) {
170077 50513 : mangled_name << "__" << scope << "__";
170078 : }
170079 286145 : mangled_name << "__templ_param_" << p_template_parameter_depth << "_" << p_template_parameter_position << "__";
170080 : } else {
170081 171307 : mangled_name << get_name().getString();
170082 : }
170083 :
170084 457452 : SgName mangled(mangled_name.str());
170085 :
170086 457452 : if (get_tpl_params().size() > 0)
170087 252 : mangled = mangleTemplate(mangled,get_tpl_params(),get_scope());
170088 :
170089 457452 : if (get_tpl_args().size() > 0)
170090 122929 : mangled = mangleTemplate(mangled,get_tpl_args(),get_scope());
170091 :
170092 : #if DEBUG_NONREAL_DECL_MANGLED
170093 : printf(" >> mangled = %s\n", mangled.getString().c_str());
170094 : #endif
170095 :
170096 457452 : return mangled;
170097 : }
170098 :
170099 13091 : SgSymbol* SgNonrealDecl::get_symbol_from_symbol_table() const {
170100 : #if 0
170101 : printf("In SgNonrealDecl::get_symbol_from_symbol_table():\n");
170102 : #endif
170103 : #if 0
170104 : printf(" this = %p (%s) = %s\n", this, this ? this->class_name().c_str() : "", this ? this->get_name().str() : "");
170105 : #endif
170106 13091 : SgNode * parent = get_parent();
170107 13091 : ROSE_ASSERT(parent != NULL);
170108 : #if 0
170109 : printf(" parent = %p (%s)\n", parent, parent ? parent->class_name().c_str() : "");
170110 : #endif
170111 13091 : SgScopeStatement * scope = get_scope();
170112 13091 : ROSE_ASSERT(scope != NULL);
170113 :
170114 : #if 0
170115 : printf(" scope = %p (%s)\n", scope, scope ? scope->class_name().c_str() : "");
170116 : #endif
170117 :
170118 13091 : SgSymbol * res = scope->find_symbol_from_declaration(this);
170119 :
170120 13091 : if (res == NULL) {
170121 :
170122 0 : SgGlobal * gscope = isSgGlobal(scope);
170123 0 : if (gscope != NULL) {
170124 0 : ROSE_ASSERT(false);
170125 : } else {
170126 0 : SgDeclarationStatement * parent = isSgDeclarationStatement(scope->get_parent());
170127 0 : ROSE_ASSERT(parent != NULL);
170128 : #if 0
170129 : printf(" parent = %p (%s)\n", parent, parent ? parent->class_name().c_str() : "");
170130 : #endif
170131 0 : SgTemplateClassDeclaration * tplcdecl = isSgTemplateClassDeclaration(parent);
170132 0 : if (tplcdecl != NULL) {
170133 0 : scope = tplcdecl->get_nonreal_decl_scope();
170134 0 : ROSE_ASSERT(scope != NULL);
170135 : } else {
170136 0 : ROSE_ASSERT(false);
170137 : }
170138 : }
170139 : #if 0
170140 : printf(" scope = %p (%s)\n", scope, scope ? scope->class_name().c_str() : "");
170141 : #endif
170142 0 : res = scope->find_symbol_from_declaration(this);
170143 0 : ROSE_ASSERT(res != NULL);
170144 : }
170145 :
170146 13091 : return res;
170147 : }
170148 :
170149 : SgName
170150 0 : SgNonrealDecl::get_qualified_name() const
170151 : {
170152 0 : SgName returnName;
170153 0 : SgClassDeclaration * xdecl = isSgClassDeclaration(get_templateDeclaration());
170154 0 : SgFunctionDeclaration * fdecl = isSgFunctionDeclaration(get_templateDeclaration());
170155 0 : if (xdecl != NULL) {
170156 0 : returnName = xdecl->get_qualified_name();
170157 0 : } else if (fdecl != NULL) {
170158 0 : returnName = fdecl->get_qualified_name();
170159 : } else {
170160 0 : returnName = get_name();
170161 : }
170162 :
170163 : // TODO template argument
170164 :
170165 0 : return returnName;
170166 : }
170167 :
170168 :
170169 :
170170 : // End of memberFunctionString
170171 : // Start of memberFunctionString
170172 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
170173 :
170174 : // *** COMMON CODE SECTION BEGINS HERE ***
170175 :
170176 : #if 0
170177 : int
170178 : SgNonrealDecl::getVariant() const
170179 : {
170180 : // This function is used in ROSE while "variant()" is used in SAGE
170181 : assert(this != NULL);
170182 : return variant();
170183 : }
170184 : #endif
170185 :
170186 : // This function is used in ROSE in treeTraversal code
170187 : // eventually replaces getVariant() and variant()
170188 : // though after variant() has been removed for a while we will
170189 : // want to change the name of variantT() back to variant()
170190 : // (since the "T" was ment to stand for temporary).
170191 : // When this happens the variantT() will be depricated.
170192 : VariantT
170193 8640000 : SgNonrealDecl::variantT() const
170194 : {
170195 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
170196 8640000 : ROSE_ASSERT(this != NULL);
170197 8640000 : return V_SgNonrealDecl;
170198 : }
170199 :
170200 : #if 0
170201 : int
170202 : SgNonrealDecl::variant() const
170203 : {
170204 : // This function is used in SAGE
170205 : ROSE_ASSERT(this != NULL);
170206 : return NONREAL_DECL;
170207 : }
170208 : #endif
170209 :
170210 : ROSE_DLL_API const char*
170211 0 : SgNonrealDecl::sage_class_name() const
170212 : {
170213 0 : ROSE_ASSERT(this != NULL);
170214 0 : return "SgNonrealDecl";
170215 : }
170216 :
170217 : std::string
170218 83974 : SgNonrealDecl::class_name() const
170219 : {
170220 83974 : ROSE_ASSERT(this != NULL);
170221 83974 : return "SgNonrealDecl";
170222 : }
170223 :
170224 : // DQ (11/26/2005): Support for visitor pattern mechanims
170225 : // (inferior to ROSE traversal mechanism, experimental).
170226 : void
170227 704852 : SgNonrealDecl::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
170228 : {
170229 704852 : ROSE_ASSERT(this != NULL);
170230 704852 : visitor.visit(this);
170231 704852 : }
170232 :
170233 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
170234 0 : void SgNonrealDecl::accept (ROSE_VisitorPattern & visitor) {
170235 0 : ROSE_ASSERT(this != NULL);
170236 0 : visitor.visit(this);
170237 0 : }
170238 :
170239 : SgNonrealDecl*
170240 0 : SgNonrealDecl::addRegExpAttribute(std::string s, AstRegExAttribute* a)
170241 : {
170242 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
170243 : // This function is currently only supported for the AST used the represent Binary executables.
170244 : if (0 /* isSgAsmNode(this) != NULL */)
170245 : {
170246 : // Support for regex specification.
170247 : std::string prefixCode = "REGEX:";
170248 : addNewAttribute(prefixCode + s,a);
170249 : }
170250 : #endif
170251 :
170252 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
170253 0 : return this;
170254 : }
170255 :
170256 : // *** COMMON CODE SECTION ENDS HERE ***
170257 :
170258 :
170259 : // End of memberFunctionString
170260 : // Start of memberFunctionString
170261 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
170262 :
170263 :
170264 : #if 0
170265 : //! Error checking support
170266 : /*! Verifies the following:
170267 : - working getVariant() member function
170268 : - calls base class's error() member function
170269 : Every class has one of these functions.
170270 : */
170271 : bool
170272 : SgNonrealDecl::error()
170273 : {
170274 : // Put error checking here
170275 :
170276 : ROSE_ASSERT (this != NULL);
170277 : if (getVariant() != NONREAL_DECL)
170278 : {
170279 : printf ("Error in SgNonrealDecl::error(): SgNonrealDecl object has a %s variant \n",
170280 : Cxx_GrammarTerminalNames[getVariant()].name);
170281 : // printf ("Error in SgNonrealDecl::error() \n");
170282 : ROSE_ABORT();
170283 : }
170284 :
170285 : ROSE_ASSERT (getVariant() == NONREAL_DECL);
170286 : return SgDeclarationStatement::error();
170287 : }
170288 : #endif
170289 :
170290 :
170291 :
170292 : // End of memberFunctionString
170293 :
170294 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
170295 :
170296 65317100 : SgNonrealDecl* isSgNonrealDecl ( SgNode* inputDerivedClassPointer )
170297 : {
170298 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
170299 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
170300 : // So to fix this we return NULL directly when the input is NULL and avoid the
170301 : // dynamic_cast in this case. This is likely a performance improvement as well.
170302 : // return dynamic_cast<SgNonrealDecl*>(inputDerivedClassPointer);
170303 : // Milind Chabbi (8/28/2013): isSgNonrealDecl uses table-driven castability instead of c++ default dynamic_cast
170304 : // this improves the running time performance by 10-20%.
170305 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNonrealDecl*>(inputDerivedClassPointer);
170306 65317100 : return IS_SgNonrealDecl_FAST_MACRO(inputDerivedClassPointer);
170307 : }
170308 :
170309 : // DQ (11/8/2003): Added version of functions taking const pointer
170310 13091 : const SgNonrealDecl* isSgNonrealDecl ( const SgNode* inputDerivedClassPointer )
170311 : {
170312 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
170313 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
170314 : // So to fix this we return NULL directly when the input is NULL and avoid the
170315 : // dynamic_cast in this case. This is likely a performance improvement as well.
170316 : // return dynamic_cast<const SgNonrealDecl*>(inputDerivedClassPointer);
170317 : // Milind Chabbi (8/28/2013): isSgNonrealDecl uses table-driven castability instead of c++ default dynamic_cast
170318 : // this improves the running time performance by 10-20%.
170319 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNonrealDecl*>(inputDerivedClassPointer);
170320 13091 : return IS_SgNonrealDecl_FAST_MACRO(inputDerivedClassPointer);
170321 : }
170322 :
170323 :
170324 :
170325 : /* #line 170326 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170326 :
170327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
170328 :
170329 : /**
170330 : \brief Generated destructor
170331 :
170332 : This destructor is automatically generated (by ROSETTA). This destructor
170333 : only frees memory of data members associated with the parts of the current IR node which
170334 : are NOT traversed. Those data members that are part of a traversal can be freed using
170335 : a traversal (calling this destructor on all children in a post-order traversal). Such
170336 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
170337 :
170338 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
170339 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
170340 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
170341 :
170342 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
170343 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
170344 : pointers are not yet implemented to call delete on eash pointer in the container.
170345 : (This could be done by derivation from the STL containers to define containers that
170346 : automatically deleted their members.)
170347 :
170348 : */
170349 23834 : SgNonrealDecl::~SgNonrealDecl () {
170350 10160 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
170351 :
170352 10160 : if (p_nonreal_decl_scope && p_nonreal_decl_scope->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_nonreal_decl_scope; }
170353 :
170354 : // case: not a listType for name
170355 10160 : p_name = ""; // non list case
170356 : // case: not a listType for nonreal_decl_scope
170357 10160 : p_nonreal_decl_scope = NULL; // non list case
170358 : // case: not a listType for type
170359 10160 : p_type = NULL; // non list case
170360 : // case: not a listType for template_parameter_position
170361 10160 : p_template_parameter_position = -1; // non list case
170362 : // case: not a listType for template_parameter_depth
170363 10160 : p_template_parameter_depth = -1; // non list case
170364 : // case: not a listType for templateDeclaration
170365 10160 : p_templateDeclaration = NULL; // non list case
170366 : // case: listType for tpl_args
170367 : // case: listType (typeIsPointerToList == false) for tpl_args
170368 10160 : p_tpl_args.erase(p_tpl_args.begin(),p_tpl_args.end());
170369 : // case: listType for tpl_params
170370 : // case: listType (typeIsPointerToList == false) for tpl_params
170371 10160 : p_tpl_params.erase(p_tpl_params.begin(),p_tpl_params.end());
170372 : // case: not a listType for is_class_member
170373 10160 : p_is_class_member = false; // non list case
170374 : // case: not a listType for is_template_param
170375 10160 : p_is_template_param = false; // non list case
170376 : // case: not a listType for is_template_template_param
170377 10160 : p_is_template_template_param = false; // non list case
170378 : // case: not a listType for is_nonreal_template
170379 10160 : p_is_nonreal_template = false; // non list case
170380 : // case: not a listType for is_nonreal_function
170381 10160 : p_is_nonreal_function = false; // non list case
170382 :
170383 : }
170384 :
170385 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
170386 20320 : }
170387 :
170388 :
170389 : /* #line 170390 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170390 :
170391 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
170392 :
170393 : // Generated constructor
170394 0 : SgNonrealDecl::SgNonrealDecl ( Sg_File_Info* startOfConstruct, SgName name )
170395 0 : : SgDeclarationStatement(startOfConstruct)
170396 : {
170397 : #ifdef DEBUG
170398 : // printf ("In SgNonrealDecl::SgNonrealDecl (Sg_File_Info* startOfConstruct, SgName name) sage_class_name() = %s \n",sage_class_name());
170399 : #endif
170400 : #if 0
170401 : // debugging information!
170402 : printf ("In SgNonrealDecl::SgNonrealDecl (Sg_File_Info* startOfConstruct, SgName name): this = %p = %s \n",this,this->class_name().c_str());
170403 : #endif
170404 :
170405 0 : p_name = name;
170406 0 : p_nonreal_decl_scope = NULL;
170407 0 : p_type = NULL;
170408 0 : p_template_parameter_position = -1;
170409 0 : p_template_parameter_depth = -1;
170410 0 : p_templateDeclaration = NULL;
170411 0 : p_tpl_args = SgTemplateArgumentPtrList();
170412 0 : p_tpl_params = SgTemplateParameterPtrList();
170413 0 : p_is_class_member = false;
170414 0 : p_is_template_param = false;
170415 0 : p_is_template_template_param = false;
170416 0 : p_is_nonreal_template = false;
170417 0 : p_is_nonreal_function = false;
170418 :
170419 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
170420 :
170421 : #if 0
170422 : // DQ (7/30/2014): Call a virtual function.
170423 : std::string s = this->class_name();
170424 : #endif
170425 :
170426 : // Test the variant virtual function
170427 : // assert(NONREAL_DECL == variant());
170428 0 : assert(NONREAL_DECL == this->variant());
170429 0 : ROSE_ASSERT(NONREAL_DECL == (int)(this->variantT()));
170430 0 : post_construction_initialization();
170431 :
170432 : // Test the isSgNonrealDecl() function since it has been problematic
170433 0 : assert(isSgNonrealDecl(this) != NULL);
170434 0 : }
170435 :
170436 : // Generated constructor (all data members)
170437 :
170438 : /* #line 170439 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170439 :
170440 :
170441 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
170442 :
170443 :
170444 : // ********************************************************
170445 : // member functions common across all array grammar objects
170446 : // ********************************************************
170447 :
170448 :
170449 :
170450 : /* #line 170451 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170451 :
170452 :
170453 :
170454 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
170455 :
170456 : // ********************************************************
170457 : // member functions specific to each node in the grammar
170458 : // ********************************************************
170459 :
170460 :
170461 : /* #line 170462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170462 :
170463 : // Start of memberFunctionString
170464 : /* #line 17289 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
170465 :
170466 : void
170467 0 : SgEmptyDeclaration::post_construction_initialization()
170468 : {
170469 0 : }
170470 :
170471 : // DQ (2/18/2006): Added general name mangling for all declarations (and some other IR nodes).
170472 : SgName
170473 0 : SgEmptyDeclaration::get_mangled_name(void) const
170474 : {
170475 0 : SgName returnName;
170476 :
170477 : // The semantics of get_scope is that it can never be NULL (SgGlobal returns itself as its scope!)
170478 : // SgScopeStatement* scope = get_scope();
170479 : // ROSE_ASSERT(scope != NULL);
170480 :
170481 : // This is a poor way to handle the generation of a mangled name (will be improved)
170482 0 : returnName = "empty_declaration";
170483 :
170484 0 : return returnName;
170485 : }
170486 :
170487 : // DQ (11/24/2020): Adding support for explicit scope to be false.
170488 : bool
170489 0 : SgEmptyDeclaration::hasExplicitScope() const
170490 : {
170491 : // This function reports that this IR node does NOT store its scope explicitly.
170492 0 : return false;
170493 : }
170494 :
170495 :
170496 :
170497 : // End of memberFunctionString
170498 : // Start of memberFunctionString
170499 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
170500 :
170501 : // *** COMMON CODE SECTION BEGINS HERE ***
170502 :
170503 : #if 0
170504 : int
170505 : SgEmptyDeclaration::getVariant() const
170506 : {
170507 : // This function is used in ROSE while "variant()" is used in SAGE
170508 : assert(this != NULL);
170509 : return variant();
170510 : }
170511 : #endif
170512 :
170513 : // This function is used in ROSE in treeTraversal code
170514 : // eventually replaces getVariant() and variant()
170515 : // though after variant() has been removed for a while we will
170516 : // want to change the name of variantT() back to variant()
170517 : // (since the "T" was ment to stand for temporary).
170518 : // When this happens the variantT() will be depricated.
170519 : VariantT
170520 0 : SgEmptyDeclaration::variantT() const
170521 : {
170522 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
170523 0 : ROSE_ASSERT(this != NULL);
170524 0 : return V_SgEmptyDeclaration;
170525 : }
170526 :
170527 : #if 0
170528 : int
170529 : SgEmptyDeclaration::variant() const
170530 : {
170531 : // This function is used in SAGE
170532 : ROSE_ASSERT(this != NULL);
170533 : return EMPTY_DECLARATION_STMT;
170534 : }
170535 : #endif
170536 :
170537 : ROSE_DLL_API const char*
170538 0 : SgEmptyDeclaration::sage_class_name() const
170539 : {
170540 0 : ROSE_ASSERT(this != NULL);
170541 0 : return "SgEmptyDeclaration";
170542 : }
170543 :
170544 : std::string
170545 0 : SgEmptyDeclaration::class_name() const
170546 : {
170547 0 : ROSE_ASSERT(this != NULL);
170548 0 : return "SgEmptyDeclaration";
170549 : }
170550 :
170551 : // DQ (11/26/2005): Support for visitor pattern mechanims
170552 : // (inferior to ROSE traversal mechanism, experimental).
170553 : void
170554 0 : SgEmptyDeclaration::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
170555 : {
170556 0 : ROSE_ASSERT(this != NULL);
170557 0 : visitor.visit(this);
170558 0 : }
170559 :
170560 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
170561 0 : void SgEmptyDeclaration::accept (ROSE_VisitorPattern & visitor) {
170562 0 : ROSE_ASSERT(this != NULL);
170563 0 : visitor.visit(this);
170564 0 : }
170565 :
170566 : SgEmptyDeclaration*
170567 0 : SgEmptyDeclaration::addRegExpAttribute(std::string s, AstRegExAttribute* a)
170568 : {
170569 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
170570 : // This function is currently only supported for the AST used the represent Binary executables.
170571 : if (0 /* isSgAsmNode(this) != NULL */)
170572 : {
170573 : // Support for regex specification.
170574 : std::string prefixCode = "REGEX:";
170575 : addNewAttribute(prefixCode + s,a);
170576 : }
170577 : #endif
170578 :
170579 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
170580 0 : return this;
170581 : }
170582 :
170583 : // *** COMMON CODE SECTION ENDS HERE ***
170584 :
170585 :
170586 : // End of memberFunctionString
170587 : // Start of memberFunctionString
170588 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
170589 :
170590 :
170591 : #if 0
170592 : //! Error checking support
170593 : /*! Verifies the following:
170594 : - working getVariant() member function
170595 : - calls base class's error() member function
170596 : Every class has one of these functions.
170597 : */
170598 : bool
170599 : SgEmptyDeclaration::error()
170600 : {
170601 : // Put error checking here
170602 :
170603 : ROSE_ASSERT (this != NULL);
170604 : if (getVariant() != EMPTY_DECLARATION_STMT)
170605 : {
170606 : printf ("Error in SgEmptyDeclaration::error(): SgEmptyDeclaration object has a %s variant \n",
170607 : Cxx_GrammarTerminalNames[getVariant()].name);
170608 : // printf ("Error in SgEmptyDeclaration::error() \n");
170609 : ROSE_ABORT();
170610 : }
170611 :
170612 : ROSE_ASSERT (getVariant() == EMPTY_DECLARATION_STMT);
170613 : return SgDeclarationStatement::error();
170614 : }
170615 : #endif
170616 :
170617 :
170618 :
170619 : // End of memberFunctionString
170620 :
170621 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
170622 :
170623 0 : SgEmptyDeclaration* isSgEmptyDeclaration ( SgNode* inputDerivedClassPointer )
170624 : {
170625 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
170626 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
170627 : // So to fix this we return NULL directly when the input is NULL and avoid the
170628 : // dynamic_cast in this case. This is likely a performance improvement as well.
170629 : // return dynamic_cast<SgEmptyDeclaration*>(inputDerivedClassPointer);
170630 : // Milind Chabbi (8/28/2013): isSgEmptyDeclaration uses table-driven castability instead of c++ default dynamic_cast
170631 : // this improves the running time performance by 10-20%.
170632 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEmptyDeclaration*>(inputDerivedClassPointer);
170633 0 : return IS_SgEmptyDeclaration_FAST_MACRO(inputDerivedClassPointer);
170634 : }
170635 :
170636 : // DQ (11/8/2003): Added version of functions taking const pointer
170637 0 : const SgEmptyDeclaration* isSgEmptyDeclaration ( const SgNode* inputDerivedClassPointer )
170638 : {
170639 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
170640 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
170641 : // So to fix this we return NULL directly when the input is NULL and avoid the
170642 : // dynamic_cast in this case. This is likely a performance improvement as well.
170643 : // return dynamic_cast<const SgEmptyDeclaration*>(inputDerivedClassPointer);
170644 : // Milind Chabbi (8/28/2013): isSgEmptyDeclaration uses table-driven castability instead of c++ default dynamic_cast
170645 : // this improves the running time performance by 10-20%.
170646 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEmptyDeclaration*>(inputDerivedClassPointer);
170647 0 : return IS_SgEmptyDeclaration_FAST_MACRO(inputDerivedClassPointer);
170648 : }
170649 :
170650 :
170651 :
170652 : /* #line 170653 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170653 :
170654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
170655 :
170656 : /**
170657 : \brief Generated destructor
170658 :
170659 : This destructor is automatically generated (by ROSETTA). This destructor
170660 : only frees memory of data members associated with the parts of the current IR node which
170661 : are NOT traversed. Those data members that are part of a traversal can be freed using
170662 : a traversal (calling this destructor on all children in a post-order traversal). Such
170663 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
170664 :
170665 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
170666 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
170667 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
170668 :
170669 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
170670 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
170671 : pointers are not yet implemented to call delete on eash pointer in the container.
170672 : (This could be done by derivation from the STL containers to define containers that
170673 : automatically deleted their members.)
170674 :
170675 : */
170676 0 : SgEmptyDeclaration::~SgEmptyDeclaration () {
170677 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
170678 :
170679 :
170680 :
170681 : }
170682 :
170683 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
170684 0 : }
170685 :
170686 :
170687 : /* #line 170688 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170688 :
170689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
170690 :
170691 : // Generated constructor
170692 0 : SgEmptyDeclaration::SgEmptyDeclaration ( Sg_File_Info* startOfConstruct )
170693 0 : : SgDeclarationStatement(startOfConstruct)
170694 : {
170695 : #ifdef DEBUG
170696 : // printf ("In SgEmptyDeclaration::SgEmptyDeclaration (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
170697 : #endif
170698 : #if 0
170699 : // debugging information!
170700 : printf ("In SgEmptyDeclaration::SgEmptyDeclaration (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
170701 : #endif
170702 :
170703 :
170704 :
170705 : #if 0
170706 : // DQ (7/30/2014): Call a virtual function.
170707 : std::string s = this->class_name();
170708 : #endif
170709 :
170710 : // Test the variant virtual function
170711 : // assert(EMPTY_DECLARATION_STMT == variant());
170712 0 : assert(EMPTY_DECLARATION_STMT == this->variant());
170713 0 : ROSE_ASSERT(EMPTY_DECLARATION_STMT == (int)(this->variantT()));
170714 0 : post_construction_initialization();
170715 :
170716 : // Test the isSgEmptyDeclaration() function since it has been problematic
170717 0 : assert(isSgEmptyDeclaration(this) != NULL);
170718 0 : }
170719 :
170720 : // Generated constructor (all data members)
170721 :
170722 : /* #line 170723 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170723 :
170724 :
170725 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
170726 :
170727 :
170728 : // ********************************************************
170729 : // member functions common across all array grammar objects
170730 : // ********************************************************
170731 :
170732 :
170733 :
170734 : /* #line 170735 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170735 :
170736 :
170737 :
170738 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
170739 :
170740 : // ********************************************************
170741 : // member functions specific to each node in the grammar
170742 : // ********************************************************
170743 :
170744 :
170745 : /* #line 170746 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
170746 :
170747 : // Start of memberFunctionString
170748 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
170749 :
170750 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
170751 :
170752 : SgExpression*
170753 60688 : SgExprStatement::get_expression () const
170754 : {
170755 60688 : ROSE_ASSERT (this != NULL);
170756 :
170757 : #if 0
170758 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
170759 : // used to trigger marking transformations for the token-based unparsing.
170760 : printf ("SgExprStatement::get_expression = %p = %s \n",this,this->class_name().c_str());
170761 : #endif
170762 :
170763 60688 : return p_expression;
170764 : }
170765 :
170766 : void
170767 21 : SgExprStatement::set_expression ( SgExpression* expression )
170768 : {
170769 21 : ROSE_ASSERT (this != NULL);
170770 :
170771 : #if 0
170772 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
170773 : // used to trigger marking transformations for the token-based unparsing.
170774 : printf ("SgExprStatement::set_expression = %p = %s \n",this,this->class_name().c_str());
170775 : #endif
170776 :
170777 21 : set_isModified(true);
170778 :
170779 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
170780 : if (p_expression != NULL && expression != NULL && p_expression != expression)
170781 : {
170782 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
170783 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
170784 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
170785 : ROSE_ASSERT(false);
170786 : #endif
170787 : }
170788 : #endif
170789 21 : p_expression = expression;
170790 21 : }
170791 :
170792 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
170793 :
170794 :
170795 : // End of memberFunctionString
170796 : // Start of memberFunctionString
170797 : /* #line 15242 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
170798 :
170799 : // QY: 9/30/2004 removed the expr_i pointer in exprStatement. Use exprRoot directly as constructor parameter
170800 : void
170801 24229 : SgExprStatement::post_construction_initialization()
170802 : {
170803 : // DQ (11/7/2006): removed use of expression root
170804 : // if (get_expression_root() != NULL)
170805 : // get_expression_root()->set_statement(this);
170806 :
170807 : // DQ (12/17/2006): This function should have the semantics that it will represent a
170808 : // structural change to the AST, thus it is free to set the parent of the new expression.
170809 24229 : if (get_expression() != NULL)
170810 24229 : get_expression()->set_parent(this);
170811 :
170812 : #if 0
170813 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
170814 : printf ("In SgExprStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
170815 : #endif
170816 24229 : }
170817 :
170818 : // DQ (12/6/2006): We need this sort of function now that we have removed the expression root node!
170819 : // The requirement of not being able to do operations uniformly on expressions may be the disadvantage
170820 : // of not having used the SgExpressionRoot IR node as a concept.
170821 : int
170822 0 : SgExprStatement::replace_expression(SgExpression * original_expression, SgExpression * new_expression )
170823 : {
170824 : // DQ (12/17/2006): This function should have the semantics that it will represent a
170825 : // structural change to the AST, thus it is free to set the parent of the new expression.
170826 :
170827 0 : ROSE_ASSERT(original_expression != NULL);
170828 0 : ROSE_ASSERT(new_expression != NULL);
170829 :
170830 0 : ROSE_ASSERT(original_expression == p_expression);
170831 :
170832 0 : set_expression(new_expression);
170833 :
170834 0 : new_expression->set_parent(this);
170835 :
170836 : // DQ: Let this be a memory leak for now to avoid initial problems.
170837 0 : ROSE_ASSERT(original_expression != NULL);
170838 : // delete original_expression;
170839 :
170840 0 : return 0;
170841 : }
170842 :
170843 :
170844 :
170845 : // End of memberFunctionString
170846 : // Start of memberFunctionString
170847 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
170848 :
170849 : // *** COMMON CODE SECTION BEGINS HERE ***
170850 :
170851 : #if 0
170852 : int
170853 : SgExprStatement::getVariant() const
170854 : {
170855 : // This function is used in ROSE while "variant()" is used in SAGE
170856 : assert(this != NULL);
170857 : return variant();
170858 : }
170859 : #endif
170860 :
170861 : // This function is used in ROSE in treeTraversal code
170862 : // eventually replaces getVariant() and variant()
170863 : // though after variant() has been removed for a while we will
170864 : // want to change the name of variantT() back to variant()
170865 : // (since the "T" was ment to stand for temporary).
170866 : // When this happens the variantT() will be depricated.
170867 : VariantT
170868 6357920 : SgExprStatement::variantT() const
170869 : {
170870 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
170871 6357920 : ROSE_ASSERT(this != NULL);
170872 6357920 : return V_SgExprStatement;
170873 : }
170874 :
170875 : #if 0
170876 : int
170877 : SgExprStatement::variant() const
170878 : {
170879 : // This function is used in SAGE
170880 : ROSE_ASSERT(this != NULL);
170881 : return EXPR_STMT;
170882 : }
170883 : #endif
170884 :
170885 : ROSE_DLL_API const char*
170886 1121 : SgExprStatement::sage_class_name() const
170887 : {
170888 1121 : ROSE_ASSERT(this != NULL);
170889 1121 : return "SgExprStatement";
170890 : }
170891 :
170892 : std::string
170893 17466 : SgExprStatement::class_name() const
170894 : {
170895 17466 : ROSE_ASSERT(this != NULL);
170896 17466 : return "SgExprStatement";
170897 : }
170898 :
170899 : // DQ (11/26/2005): Support for visitor pattern mechanims
170900 : // (inferior to ROSE traversal mechanism, experimental).
170901 : void
170902 315706 : SgExprStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
170903 : {
170904 315706 : ROSE_ASSERT(this != NULL);
170905 315706 : visitor.visit(this);
170906 315706 : }
170907 :
170908 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
170909 0 : void SgExprStatement::accept (ROSE_VisitorPattern & visitor) {
170910 0 : ROSE_ASSERT(this != NULL);
170911 0 : visitor.visit(this);
170912 0 : }
170913 :
170914 : SgExprStatement*
170915 0 : SgExprStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
170916 : {
170917 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
170918 : // This function is currently only supported for the AST used the represent Binary executables.
170919 : if (0 /* isSgAsmNode(this) != NULL */)
170920 : {
170921 : // Support for regex specification.
170922 : std::string prefixCode = "REGEX:";
170923 : addNewAttribute(prefixCode + s,a);
170924 : }
170925 : #endif
170926 :
170927 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
170928 0 : return this;
170929 : }
170930 :
170931 : // *** COMMON CODE SECTION ENDS HERE ***
170932 :
170933 :
170934 : // End of memberFunctionString
170935 : // Start of memberFunctionString
170936 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
170937 :
170938 :
170939 : #if 0
170940 : //! Error checking support
170941 : /*! Verifies the following:
170942 : - working getVariant() member function
170943 : - calls base class's error() member function
170944 : Every class has one of these functions.
170945 : */
170946 : bool
170947 : SgExprStatement::error()
170948 : {
170949 : // Put error checking here
170950 :
170951 : ROSE_ASSERT (this != NULL);
170952 : if (getVariant() != EXPR_STMT)
170953 : {
170954 : printf ("Error in SgExprStatement::error(): SgExprStatement object has a %s variant \n",
170955 : Cxx_GrammarTerminalNames[getVariant()].name);
170956 : // printf ("Error in SgExprStatement::error() \n");
170957 : ROSE_ABORT();
170958 : }
170959 :
170960 : ROSE_ASSERT (getVariant() == EXPR_STMT);
170961 : return SgStatement::error();
170962 : }
170963 : #endif
170964 :
170965 :
170966 :
170967 : // End of memberFunctionString
170968 :
170969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
170970 :
170971 29673 : SgExprStatement* isSgExprStatement ( SgNode* inputDerivedClassPointer )
170972 : {
170973 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
170974 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
170975 : // So to fix this we return NULL directly when the input is NULL and avoid the
170976 : // dynamic_cast in this case. This is likely a performance improvement as well.
170977 : // return dynamic_cast<SgExprStatement*>(inputDerivedClassPointer);
170978 : // Milind Chabbi (8/28/2013): isSgExprStatement uses table-driven castability instead of c++ default dynamic_cast
170979 : // this improves the running time performance by 10-20%.
170980 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExprStatement*>(inputDerivedClassPointer);
170981 29673 : return IS_SgExprStatement_FAST_MACRO(inputDerivedClassPointer);
170982 : }
170983 :
170984 : // DQ (11/8/2003): Added version of functions taking const pointer
170985 130 : const SgExprStatement* isSgExprStatement ( const SgNode* inputDerivedClassPointer )
170986 : {
170987 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
170988 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
170989 : // So to fix this we return NULL directly when the input is NULL and avoid the
170990 : // dynamic_cast in this case. This is likely a performance improvement as well.
170991 : // return dynamic_cast<const SgExprStatement*>(inputDerivedClassPointer);
170992 : // Milind Chabbi (8/28/2013): isSgExprStatement uses table-driven castability instead of c++ default dynamic_cast
170993 : // this improves the running time performance by 10-20%.
170994 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExprStatement*>(inputDerivedClassPointer);
170995 130 : return IS_SgExprStatement_FAST_MACRO(inputDerivedClassPointer);
170996 : }
170997 :
170998 :
170999 :
171000 : /* #line 171001 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171001 :
171002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
171003 :
171004 : /**
171005 : \brief Generated destructor
171006 :
171007 : This destructor is automatically generated (by ROSETTA). This destructor
171008 : only frees memory of data members associated with the parts of the current IR node which
171009 : are NOT traversed. Those data members that are part of a traversal can be freed using
171010 : a traversal (calling this destructor on all children in a post-order traversal). Such
171011 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
171012 :
171013 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
171014 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
171015 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
171016 :
171017 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
171018 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
171019 : pointers are not yet implemented to call delete on eash pointer in the container.
171020 : (This could be done by derivation from the STL containers to define containers that
171021 : automatically deleted their members.)
171022 :
171023 : */
171024 8834 : SgExprStatement::~SgExprStatement () {
171025 4417 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
171026 :
171027 :
171028 : // case: not a listType for expression
171029 4417 : p_expression = NULL; // non list case
171030 :
171031 : }
171032 :
171033 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
171034 8834 : }
171035 :
171036 :
171037 : /* #line 171038 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171038 :
171039 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
171040 :
171041 : // Generated constructor
171042 19 : SgExprStatement::SgExprStatement ( Sg_File_Info* startOfConstruct, SgExpression* expression )
171043 19 : : SgStatement(startOfConstruct)
171044 : {
171045 : #ifdef DEBUG
171046 : // printf ("In SgExprStatement::SgExprStatement (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
171047 : #endif
171048 : #if 0
171049 : // debugging information!
171050 : printf ("In SgExprStatement::SgExprStatement (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
171051 : #endif
171052 :
171053 19 : p_expression = expression;
171054 :
171055 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
171056 :
171057 : #if 0
171058 : // DQ (7/30/2014): Call a virtual function.
171059 : std::string s = this->class_name();
171060 : #endif
171061 :
171062 : // Test the variant virtual function
171063 : // assert(EXPR_STMT == variant());
171064 19 : assert(EXPR_STMT == this->variant());
171065 19 : ROSE_ASSERT(EXPR_STMT == (int)(this->variantT()));
171066 19 : post_construction_initialization();
171067 :
171068 : // Test the isSgExprStatement() function since it has been problematic
171069 19 : assert(isSgExprStatement(this) != NULL);
171070 19 : }
171071 :
171072 : // Generated constructor (all data members)
171073 :
171074 : /* #line 171075 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171075 :
171076 :
171077 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
171078 :
171079 :
171080 : // ********************************************************
171081 : // member functions common across all array grammar objects
171082 : // ********************************************************
171083 :
171084 :
171085 :
171086 : /* #line 171087 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171087 :
171088 :
171089 :
171090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
171091 :
171092 : // ********************************************************
171093 : // member functions specific to each node in the grammar
171094 : // ********************************************************
171095 :
171096 :
171097 : /* #line 171098 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171098 :
171099 : // Start of memberFunctionString
171100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171101 :
171102 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171103 :
171104 : SgName
171105 39 : SgLabelStatement::get_label () const
171106 : {
171107 39 : ROSE_ASSERT (this != NULL);
171108 :
171109 : #if 0
171110 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171111 : // used to trigger marking transformations for the token-based unparsing.
171112 : printf ("SgLabelStatement::get_label = %p = %s \n",this,this->class_name().c_str());
171113 : #endif
171114 :
171115 39 : return p_label;
171116 : }
171117 :
171118 : void
171119 0 : SgLabelStatement::set_label ( SgName label )
171120 : {
171121 0 : ROSE_ASSERT (this != NULL);
171122 :
171123 : #if 0
171124 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171125 : // used to trigger marking transformations for the token-based unparsing.
171126 : printf ("SgLabelStatement::set_label = %p = %s \n",this,this->class_name().c_str());
171127 : #endif
171128 :
171129 0 : set_isModified(true);
171130 :
171131 0 : p_label = label;
171132 0 : }
171133 :
171134 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171135 :
171136 :
171137 : // End of memberFunctionString
171138 : // Start of memberFunctionString
171139 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171140 :
171141 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171142 :
171143 : SgScopeStatement*
171144 36 : SgLabelStatement::get_scope () const
171145 : {
171146 36 : ROSE_ASSERT (this != NULL);
171147 :
171148 : #if 0
171149 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171150 : // used to trigger marking transformations for the token-based unparsing.
171151 : printf ("SgLabelStatement::get_scope = %p = %s \n",this,this->class_name().c_str());
171152 : #endif
171153 :
171154 36 : return p_scope;
171155 : }
171156 :
171157 : void
171158 15 : SgLabelStatement::set_scope ( SgScopeStatement* scope )
171159 : {
171160 15 : ROSE_ASSERT (this != NULL);
171161 :
171162 : #if 0
171163 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171164 : // used to trigger marking transformations for the token-based unparsing.
171165 : printf ("SgLabelStatement::set_scope = %p = %s \n",this,this->class_name().c_str());
171166 : #endif
171167 :
171168 15 : set_isModified(true);
171169 :
171170 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
171171 : if (p_scope != NULL && scope != NULL && p_scope != scope)
171172 : {
171173 : printf ("Warning: scope = %p overwriting valid pointer p_scope = %p \n",scope,p_scope);
171174 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
171175 : printf ("Error fails assertion (p_scope != NULL && scope != NULL && p_scope != scope) is false\n");
171176 : ROSE_ASSERT(false);
171177 : #endif
171178 : }
171179 : #endif
171180 15 : p_scope = scope;
171181 15 : }
171182 :
171183 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171184 :
171185 :
171186 : // End of memberFunctionString
171187 : // Start of memberFunctionString
171188 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171189 :
171190 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171191 :
171192 : SgStatement*
171193 21 : SgLabelStatement::get_statement () const
171194 : {
171195 21 : ROSE_ASSERT (this != NULL);
171196 :
171197 : #if 0
171198 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171199 : // used to trigger marking transformations for the token-based unparsing.
171200 : printf ("SgLabelStatement::get_statement = %p = %s \n",this,this->class_name().c_str());
171201 : #endif
171202 :
171203 21 : return p_statement;
171204 : }
171205 :
171206 : void
171207 5 : SgLabelStatement::set_statement ( SgStatement* statement )
171208 : {
171209 5 : ROSE_ASSERT (this != NULL);
171210 :
171211 : #if 0
171212 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171213 : // used to trigger marking transformations for the token-based unparsing.
171214 : printf ("SgLabelStatement::set_statement = %p = %s \n",this,this->class_name().c_str());
171215 : #endif
171216 :
171217 5 : set_isModified(true);
171218 :
171219 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
171220 : if (p_statement != NULL && statement != NULL && p_statement != statement)
171221 : {
171222 : printf ("Warning: statement = %p overwriting valid pointer p_statement = %p \n",statement,p_statement);
171223 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
171224 : printf ("Error fails assertion (p_statement != NULL && statement != NULL && p_statement != statement) is false\n");
171225 : ROSE_ASSERT(false);
171226 : #endif
171227 : }
171228 : #endif
171229 5 : p_statement = statement;
171230 5 : }
171231 :
171232 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171233 :
171234 :
171235 : // End of memberFunctionString
171236 : // Start of memberFunctionString
171237 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171238 :
171239 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171240 :
171241 : bool
171242 0 : SgLabelStatement::get_gnu_extension_unused () const
171243 : {
171244 0 : ROSE_ASSERT (this != NULL);
171245 :
171246 : #if 0
171247 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171248 : // used to trigger marking transformations for the token-based unparsing.
171249 : printf ("SgLabelStatement::get_gnu_extension_unused = %p = %s \n",this,this->class_name().c_str());
171250 : #endif
171251 :
171252 0 : return p_gnu_extension_unused;
171253 : }
171254 :
171255 : void
171256 0 : SgLabelStatement::set_gnu_extension_unused ( bool gnu_extension_unused )
171257 : {
171258 0 : ROSE_ASSERT (this != NULL);
171259 :
171260 : #if 0
171261 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171262 : // used to trigger marking transformations for the token-based unparsing.
171263 : printf ("SgLabelStatement::set_gnu_extension_unused = %p = %s \n",this,this->class_name().c_str());
171264 : #endif
171265 :
171266 0 : set_isModified(true);
171267 :
171268 0 : p_gnu_extension_unused = gnu_extension_unused;
171269 0 : }
171270 :
171271 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171272 :
171273 :
171274 : // End of memberFunctionString
171275 : // Start of memberFunctionString
171276 : /* #line 15290 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
171277 :
171278 :
171279 : bool
171280 17 : SgLabelStatement::hasExplicitScope() const
171281 : {
171282 : // This function reports that this IR node stores its scope explicitly.
171283 :
171284 17 : return true;
171285 : }
171286 :
171287 : void
171288 11 : SgLabelStatement::post_construction_initialization()
171289 : {
171290 : #if 0
171291 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
171292 : printf ("In SgLabelStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
171293 : #endif
171294 11 : }
171295 :
171296 : SgName
171297 7 : SgLabelStatement::get_name() const
171298 : {
171299 7 : return get_label();
171300 : }
171301 :
171302 : // DQ (2/6/2007): Get the associated symbol from the symbol table in the stored scope
171303 : SgSymbol*
171304 7 : SgLabelStatement::get_symbol_from_symbol_table() const
171305 : {
171306 : #if 0
171307 : ROSE_ASSERT(get_scope() != NULL);
171308 : ROSE_ASSERT(get_scope()->get_symbol_table() != NULL);
171309 : return get_scope()->get_symbol_table()->find(this);
171310 : #else
171311 : // DQ (12/9/2007): The label's symbol is stored in the function definition, so we need to look for it there.
171312 : // printf ("What is the scope of a label:%s scope = %s \n",get_name().str(),get_scope()->class_name().c_str());
171313 : // SgFunctionDeclaration* functionDeclaration = TransformationSupport::getFunctionDeclaration(this);
171314 7 : SgScopeStatement* tempScope = get_scope();
171315 7 : ROSE_ASSERT(tempScope != NULL);
171316 7 : while (tempScope != NULL && isSgFunctionDefinition(tempScope) == NULL)
171317 : {
171318 0 : tempScope = tempScope->get_scope();
171319 : }
171320 :
171321 7 : SgFunctionDefinition* functionDefinition = isSgFunctionDefinition(tempScope);
171322 7 : if (functionDefinition == NULL)
171323 : {
171324 0 : printf ("Labels are stored in the SgFunctionDefinition (function scope), could not locate associated function scope \n");
171325 : }
171326 7 : ROSE_ASSERT(functionDefinition != NULL);
171327 : // return functionDefinition->get_symbol_table()->find(this);
171328 7 : return functionDefinition->find_symbol_from_declaration(this);
171329 : #endif
171330 : }
171331 :
171332 : SgType*
171333 0 : SgLabelStatement::get_type() const
171334 : {
171335 : // DQ (8/21/2013): Added function to support calling get_type() from a SgDeclarationStatement so that the
171336 : // template low-level symbol table support function would compile cleanly. Note that it is an error to
171337 : // call this function and it is not a virtual function that will cause derived class versions to be called
171338 : // where appropriate (and it is not always appropriate, e.g a SgNamespaceDeclaration has no assocated SgType).
171339 0 : return NULL;
171340 : }
171341 :
171342 : bool
171343 0 : SgLabelStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
171344 : {
171345 : // DQ (1/15/2018): Added support for the statement of the label to be traversed.
171346 0 : return ( StatementReplace(this, p_statement, target, newstmt) == true );
171347 : }
171348 :
171349 :
171350 :
171351 : // End of memberFunctionString
171352 : // Start of memberFunctionString
171353 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
171354 :
171355 : // *** COMMON CODE SECTION BEGINS HERE ***
171356 :
171357 : #if 0
171358 : int
171359 : SgLabelStatement::getVariant() const
171360 : {
171361 : // This function is used in ROSE while "variant()" is used in SAGE
171362 : assert(this != NULL);
171363 : return variant();
171364 : }
171365 : #endif
171366 :
171367 : // This function is used in ROSE in treeTraversal code
171368 : // eventually replaces getVariant() and variant()
171369 : // though after variant() has been removed for a while we will
171370 : // want to change the name of variantT() back to variant()
171371 : // (since the "T" was ment to stand for temporary).
171372 : // When this happens the variantT() will be depricated.
171373 : VariantT
171374 2210 : SgLabelStatement::variantT() const
171375 : {
171376 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
171377 2210 : ROSE_ASSERT(this != NULL);
171378 2210 : return V_SgLabelStatement;
171379 : }
171380 :
171381 : #if 0
171382 : int
171383 : SgLabelStatement::variant() const
171384 : {
171385 : // This function is used in SAGE
171386 : ROSE_ASSERT(this != NULL);
171387 : return LABEL_STMT;
171388 : }
171389 : #endif
171390 :
171391 : ROSE_DLL_API const char*
171392 10 : SgLabelStatement::sage_class_name() const
171393 : {
171394 10 : ROSE_ASSERT(this != NULL);
171395 10 : return "SgLabelStatement";
171396 : }
171397 :
171398 : std::string
171399 9 : SgLabelStatement::class_name() const
171400 : {
171401 9 : ROSE_ASSERT(this != NULL);
171402 9 : return "SgLabelStatement";
171403 : }
171404 :
171405 : // DQ (11/26/2005): Support for visitor pattern mechanims
171406 : // (inferior to ROSE traversal mechanism, experimental).
171407 : void
171408 36 : SgLabelStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
171409 : {
171410 36 : ROSE_ASSERT(this != NULL);
171411 36 : visitor.visit(this);
171412 36 : }
171413 :
171414 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
171415 0 : void SgLabelStatement::accept (ROSE_VisitorPattern & visitor) {
171416 0 : ROSE_ASSERT(this != NULL);
171417 0 : visitor.visit(this);
171418 0 : }
171419 :
171420 : SgLabelStatement*
171421 0 : SgLabelStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
171422 : {
171423 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
171424 : // This function is currently only supported for the AST used the represent Binary executables.
171425 : if (0 /* isSgAsmNode(this) != NULL */)
171426 : {
171427 : // Support for regex specification.
171428 : std::string prefixCode = "REGEX:";
171429 : addNewAttribute(prefixCode + s,a);
171430 : }
171431 : #endif
171432 :
171433 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
171434 0 : return this;
171435 : }
171436 :
171437 : // *** COMMON CODE SECTION ENDS HERE ***
171438 :
171439 :
171440 : // End of memberFunctionString
171441 : // Start of memberFunctionString
171442 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
171443 :
171444 :
171445 : #if 0
171446 : //! Error checking support
171447 : /*! Verifies the following:
171448 : - working getVariant() member function
171449 : - calls base class's error() member function
171450 : Every class has one of these functions.
171451 : */
171452 : bool
171453 : SgLabelStatement::error()
171454 : {
171455 : // Put error checking here
171456 :
171457 : ROSE_ASSERT (this != NULL);
171458 : if (getVariant() != LABEL_STMT)
171459 : {
171460 : printf ("Error in SgLabelStatement::error(): SgLabelStatement object has a %s variant \n",
171461 : Cxx_GrammarTerminalNames[getVariant()].name);
171462 : // printf ("Error in SgLabelStatement::error() \n");
171463 : ROSE_ABORT();
171464 : }
171465 :
171466 : ROSE_ASSERT (getVariant() == LABEL_STMT);
171467 : return SgStatement::error();
171468 : }
171469 : #endif
171470 :
171471 :
171472 :
171473 : // End of memberFunctionString
171474 :
171475 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
171476 :
171477 1322030 : SgLabelStatement* isSgLabelStatement ( SgNode* inputDerivedClassPointer )
171478 : {
171479 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
171480 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
171481 : // So to fix this we return NULL directly when the input is NULL and avoid the
171482 : // dynamic_cast in this case. This is likely a performance improvement as well.
171483 : // return dynamic_cast<SgLabelStatement*>(inputDerivedClassPointer);
171484 : // Milind Chabbi (8/28/2013): isSgLabelStatement uses table-driven castability instead of c++ default dynamic_cast
171485 : // this improves the running time performance by 10-20%.
171486 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLabelStatement*>(inputDerivedClassPointer);
171487 1322030 : return IS_SgLabelStatement_FAST_MACRO(inputDerivedClassPointer);
171488 : }
171489 :
171490 : // DQ (11/8/2003): Added version of functions taking const pointer
171491 7 : const SgLabelStatement* isSgLabelStatement ( const SgNode* inputDerivedClassPointer )
171492 : {
171493 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
171494 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
171495 : // So to fix this we return NULL directly when the input is NULL and avoid the
171496 : // dynamic_cast in this case. This is likely a performance improvement as well.
171497 : // return dynamic_cast<const SgLabelStatement*>(inputDerivedClassPointer);
171498 : // Milind Chabbi (8/28/2013): isSgLabelStatement uses table-driven castability instead of c++ default dynamic_cast
171499 : // this improves the running time performance by 10-20%.
171500 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLabelStatement*>(inputDerivedClassPointer);
171501 7 : return IS_SgLabelStatement_FAST_MACRO(inputDerivedClassPointer);
171502 : }
171503 :
171504 :
171505 :
171506 : /* #line 171507 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171507 :
171508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
171509 :
171510 : /**
171511 : \brief Generated destructor
171512 :
171513 : This destructor is automatically generated (by ROSETTA). This destructor
171514 : only frees memory of data members associated with the parts of the current IR node which
171515 : are NOT traversed. Those data members that are part of a traversal can be freed using
171516 : a traversal (calling this destructor on all children in a post-order traversal). Such
171517 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
171518 :
171519 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
171520 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
171521 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
171522 :
171523 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
171524 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
171525 : pointers are not yet implemented to call delete on eash pointer in the container.
171526 : (This could be done by derivation from the STL containers to define containers that
171527 : automatically deleted their members.)
171528 :
171529 : */
171530 0 : SgLabelStatement::~SgLabelStatement () {
171531 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
171532 :
171533 :
171534 : // case: not a listType for label
171535 0 : p_label = ""; // non list case
171536 : // case: not a listType for scope
171537 0 : p_scope = NULL; // non list case
171538 : // case: not a listType for statement
171539 0 : p_statement = NULL; // non list case
171540 : // case: not a listType for gnu_extension_unused
171541 0 : p_gnu_extension_unused = false; // non list case
171542 :
171543 : }
171544 :
171545 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
171546 0 : }
171547 :
171548 :
171549 : /* #line 171550 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171550 :
171551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
171552 :
171553 : // Generated constructor
171554 0 : SgLabelStatement::SgLabelStatement ( Sg_File_Info* startOfConstruct, SgName label, SgStatement* statement )
171555 0 : : SgStatement(startOfConstruct)
171556 : {
171557 : #ifdef DEBUG
171558 : // printf ("In SgLabelStatement::SgLabelStatement (Sg_File_Info* startOfConstruct, SgName label, SgStatement* statement) sage_class_name() = %s \n",sage_class_name());
171559 : #endif
171560 : #if 0
171561 : // debugging information!
171562 : printf ("In SgLabelStatement::SgLabelStatement (Sg_File_Info* startOfConstruct, SgName label, SgStatement* statement): this = %p = %s \n",this,this->class_name().c_str());
171563 : #endif
171564 :
171565 0 : p_label = label;
171566 0 : p_scope = NULL;
171567 0 : p_statement = statement;
171568 0 : p_gnu_extension_unused = false;
171569 :
171570 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
171571 :
171572 : #if 0
171573 : // DQ (7/30/2014): Call a virtual function.
171574 : std::string s = this->class_name();
171575 : #endif
171576 :
171577 : // Test the variant virtual function
171578 : // assert(LABEL_STMT == variant());
171579 0 : assert(LABEL_STMT == this->variant());
171580 0 : ROSE_ASSERT(LABEL_STMT == (int)(this->variantT()));
171581 0 : post_construction_initialization();
171582 :
171583 : // Test the isSgLabelStatement() function since it has been problematic
171584 0 : assert(isSgLabelStatement(this) != NULL);
171585 0 : }
171586 :
171587 : // Generated constructor (all data members)
171588 :
171589 : /* #line 171590 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171590 :
171591 :
171592 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
171593 :
171594 :
171595 : // ********************************************************
171596 : // member functions common across all array grammar objects
171597 : // ********************************************************
171598 :
171599 :
171600 :
171601 : /* #line 171602 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171602 :
171603 :
171604 :
171605 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
171606 :
171607 : // ********************************************************
171608 : // member functions specific to each node in the grammar
171609 : // ********************************************************
171610 :
171611 :
171612 : /* #line 171613 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171613 :
171614 : // Start of memberFunctionString
171615 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171616 :
171617 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171618 :
171619 : SgExpression*
171620 1 : SgCaseOptionStmt::get_key () const
171621 : {
171622 1 : ROSE_ASSERT (this != NULL);
171623 :
171624 : #if 0
171625 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171626 : // used to trigger marking transformations for the token-based unparsing.
171627 : printf ("SgCaseOptionStmt::get_key = %p = %s \n",this,this->class_name().c_str());
171628 : #endif
171629 :
171630 1 : return p_key;
171631 : }
171632 :
171633 : void
171634 0 : SgCaseOptionStmt::set_key ( SgExpression* key )
171635 : {
171636 0 : ROSE_ASSERT (this != NULL);
171637 :
171638 : #if 0
171639 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171640 : // used to trigger marking transformations for the token-based unparsing.
171641 : printf ("SgCaseOptionStmt::set_key = %p = %s \n",this,this->class_name().c_str());
171642 : #endif
171643 :
171644 0 : set_isModified(true);
171645 :
171646 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
171647 : if (p_key != NULL && key != NULL && p_key != key)
171648 : {
171649 : printf ("Warning: key = %p overwriting valid pointer p_key = %p \n",key,p_key);
171650 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
171651 : printf ("Error fails assertion (p_key != NULL && key != NULL && p_key != key) is false\n");
171652 : ROSE_ASSERT(false);
171653 : #endif
171654 : }
171655 : #endif
171656 0 : p_key = key;
171657 0 : }
171658 :
171659 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171660 :
171661 :
171662 : // End of memberFunctionString
171663 : // Start of memberFunctionString
171664 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171665 :
171666 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171667 :
171668 : SgStatement*
171669 2 : SgCaseOptionStmt::get_body () const
171670 : {
171671 2 : ROSE_ASSERT (this != NULL);
171672 :
171673 : #if 0
171674 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171675 : // used to trigger marking transformations for the token-based unparsing.
171676 : printf ("SgCaseOptionStmt::get_body = %p = %s \n",this,this->class_name().c_str());
171677 : #endif
171678 :
171679 2 : return p_body;
171680 : }
171681 :
171682 : void
171683 1 : SgCaseOptionStmt::set_body ( SgStatement* body )
171684 : {
171685 1 : ROSE_ASSERT (this != NULL);
171686 :
171687 : #if 0
171688 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171689 : // used to trigger marking transformations for the token-based unparsing.
171690 : printf ("SgCaseOptionStmt::set_body = %p = %s \n",this,this->class_name().c_str());
171691 : #endif
171692 :
171693 1 : set_isModified(true);
171694 :
171695 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
171696 : if (p_body != NULL && body != NULL && p_body != body)
171697 : {
171698 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
171699 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
171700 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
171701 : ROSE_ASSERT(false);
171702 : #endif
171703 : }
171704 : #endif
171705 1 : p_body = body;
171706 1 : }
171707 :
171708 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171709 :
171710 :
171711 : // End of memberFunctionString
171712 : // Start of memberFunctionString
171713 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171714 :
171715 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171716 :
171717 : SgExpression*
171718 1 : SgCaseOptionStmt::get_key_range_end () const
171719 : {
171720 1 : ROSE_ASSERT (this != NULL);
171721 :
171722 : #if 0
171723 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171724 : // used to trigger marking transformations for the token-based unparsing.
171725 : printf ("SgCaseOptionStmt::get_key_range_end = %p = %s \n",this,this->class_name().c_str());
171726 : #endif
171727 :
171728 1 : return p_key_range_end;
171729 : }
171730 :
171731 : void
171732 0 : SgCaseOptionStmt::set_key_range_end ( SgExpression* key_range_end )
171733 : {
171734 0 : ROSE_ASSERT (this != NULL);
171735 :
171736 : #if 0
171737 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171738 : // used to trigger marking transformations for the token-based unparsing.
171739 : printf ("SgCaseOptionStmt::set_key_range_end = %p = %s \n",this,this->class_name().c_str());
171740 : #endif
171741 :
171742 0 : set_isModified(true);
171743 :
171744 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
171745 : if (p_key_range_end != NULL && key_range_end != NULL && p_key_range_end != key_range_end)
171746 : {
171747 : printf ("Warning: key_range_end = %p overwriting valid pointer p_key_range_end = %p \n",key_range_end,p_key_range_end);
171748 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
171749 : printf ("Error fails assertion (p_key_range_end != NULL && key_range_end != NULL && p_key_range_end != key_range_end) is false\n");
171750 : ROSE_ASSERT(false);
171751 : #endif
171752 : }
171753 : #endif
171754 0 : p_key_range_end = key_range_end;
171755 0 : }
171756 :
171757 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171758 :
171759 :
171760 : // End of memberFunctionString
171761 : // Start of memberFunctionString
171762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
171763 :
171764 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
171765 :
171766 : std::string
171767 0 : SgCaseOptionStmt::get_case_construct_name () const
171768 : {
171769 0 : ROSE_ASSERT (this != NULL);
171770 :
171771 : #if 0
171772 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171773 : // used to trigger marking transformations for the token-based unparsing.
171774 : printf ("SgCaseOptionStmt::get_case_construct_name = %p = %s \n",this,this->class_name().c_str());
171775 : #endif
171776 :
171777 0 : return p_case_construct_name;
171778 : }
171779 :
171780 : void
171781 0 : SgCaseOptionStmt::set_case_construct_name ( std::string case_construct_name )
171782 : {
171783 0 : ROSE_ASSERT (this != NULL);
171784 :
171785 : #if 0
171786 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
171787 : // used to trigger marking transformations for the token-based unparsing.
171788 : printf ("SgCaseOptionStmt::set_case_construct_name = %p = %s \n",this,this->class_name().c_str());
171789 : #endif
171790 :
171791 0 : set_isModified(true);
171792 :
171793 0 : p_case_construct_name = case_construct_name;
171794 0 : }
171795 :
171796 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
171797 :
171798 :
171799 : // End of memberFunctionString
171800 : // Start of memberFunctionString
171801 : /* #line 15577 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
171802 :
171803 :
171804 : void
171805 1 : SgCaseOptionStmt::post_construction_initialization()
171806 : {
171807 : // if (get_key_root() != 0)
171808 : // get_key_root()->set_statement(this);
171809 1 : }
171810 :
171811 : bool
171812 0 : SgCaseOptionStmt::replace_child(SgStatement *target,SgStatement *newstmt,
171813 : bool extractBasicBlock)
171814 : {
171815 0 : return ( StatementReplace(this, p_body, target, newstmt) == true );
171816 : }
171817 :
171818 :
171819 :
171820 : // End of memberFunctionString
171821 : // Start of memberFunctionString
171822 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
171823 :
171824 : // *** COMMON CODE SECTION BEGINS HERE ***
171825 :
171826 : #if 0
171827 : int
171828 : SgCaseOptionStmt::getVariant() const
171829 : {
171830 : // This function is used in ROSE while "variant()" is used in SAGE
171831 : assert(this != NULL);
171832 : return variant();
171833 : }
171834 : #endif
171835 :
171836 : // This function is used in ROSE in treeTraversal code
171837 : // eventually replaces getVariant() and variant()
171838 : // though after variant() has been removed for a while we will
171839 : // want to change the name of variantT() back to variant()
171840 : // (since the "T" was ment to stand for temporary).
171841 : // When this happens the variantT() will be depricated.
171842 : VariantT
171843 234 : SgCaseOptionStmt::variantT() const
171844 : {
171845 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
171846 234 : ROSE_ASSERT(this != NULL);
171847 234 : return V_SgCaseOptionStmt;
171848 : }
171849 :
171850 : #if 0
171851 : int
171852 : SgCaseOptionStmt::variant() const
171853 : {
171854 : // This function is used in SAGE
171855 : ROSE_ASSERT(this != NULL);
171856 : return CASE_STMT;
171857 : }
171858 : #endif
171859 :
171860 : ROSE_DLL_API const char*
171861 2 : SgCaseOptionStmt::sage_class_name() const
171862 : {
171863 2 : ROSE_ASSERT(this != NULL);
171864 2 : return "SgCaseOptionStmt";
171865 : }
171866 :
171867 : std::string
171868 0 : SgCaseOptionStmt::class_name() const
171869 : {
171870 0 : ROSE_ASSERT(this != NULL);
171871 0 : return "SgCaseOptionStmt";
171872 : }
171873 :
171874 : // DQ (11/26/2005): Support for visitor pattern mechanims
171875 : // (inferior to ROSE traversal mechanism, experimental).
171876 : void
171877 18 : SgCaseOptionStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
171878 : {
171879 18 : ROSE_ASSERT(this != NULL);
171880 18 : visitor.visit(this);
171881 18 : }
171882 :
171883 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
171884 0 : void SgCaseOptionStmt::accept (ROSE_VisitorPattern & visitor) {
171885 0 : ROSE_ASSERT(this != NULL);
171886 0 : visitor.visit(this);
171887 0 : }
171888 :
171889 : SgCaseOptionStmt*
171890 0 : SgCaseOptionStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
171891 : {
171892 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
171893 : // This function is currently only supported for the AST used the represent Binary executables.
171894 : if (0 /* isSgAsmNode(this) != NULL */)
171895 : {
171896 : // Support for regex specification.
171897 : std::string prefixCode = "REGEX:";
171898 : addNewAttribute(prefixCode + s,a);
171899 : }
171900 : #endif
171901 :
171902 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
171903 0 : return this;
171904 : }
171905 :
171906 : // *** COMMON CODE SECTION ENDS HERE ***
171907 :
171908 :
171909 : // End of memberFunctionString
171910 : // Start of memberFunctionString
171911 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
171912 :
171913 :
171914 : #if 0
171915 : //! Error checking support
171916 : /*! Verifies the following:
171917 : - working getVariant() member function
171918 : - calls base class's error() member function
171919 : Every class has one of these functions.
171920 : */
171921 : bool
171922 : SgCaseOptionStmt::error()
171923 : {
171924 : // Put error checking here
171925 :
171926 : ROSE_ASSERT (this != NULL);
171927 : if (getVariant() != CASE_STMT)
171928 : {
171929 : printf ("Error in SgCaseOptionStmt::error(): SgCaseOptionStmt object has a %s variant \n",
171930 : Cxx_GrammarTerminalNames[getVariant()].name);
171931 : // printf ("Error in SgCaseOptionStmt::error() \n");
171932 : ROSE_ABORT();
171933 : }
171934 :
171935 : ROSE_ASSERT (getVariant() == CASE_STMT);
171936 : return SgStatement::error();
171937 : }
171938 : #endif
171939 :
171940 :
171941 :
171942 : // End of memberFunctionString
171943 :
171944 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
171945 :
171946 573 : SgCaseOptionStmt* isSgCaseOptionStmt ( SgNode* inputDerivedClassPointer )
171947 : {
171948 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
171949 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
171950 : // So to fix this we return NULL directly when the input is NULL and avoid the
171951 : // dynamic_cast in this case. This is likely a performance improvement as well.
171952 : // return dynamic_cast<SgCaseOptionStmt*>(inputDerivedClassPointer);
171953 : // Milind Chabbi (8/28/2013): isSgCaseOptionStmt uses table-driven castability instead of c++ default dynamic_cast
171954 : // this improves the running time performance by 10-20%.
171955 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCaseOptionStmt*>(inputDerivedClassPointer);
171956 573 : return IS_SgCaseOptionStmt_FAST_MACRO(inputDerivedClassPointer);
171957 : }
171958 :
171959 : // DQ (11/8/2003): Added version of functions taking const pointer
171960 0 : const SgCaseOptionStmt* isSgCaseOptionStmt ( const SgNode* inputDerivedClassPointer )
171961 : {
171962 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
171963 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
171964 : // So to fix this we return NULL directly when the input is NULL and avoid the
171965 : // dynamic_cast in this case. This is likely a performance improvement as well.
171966 : // return dynamic_cast<const SgCaseOptionStmt*>(inputDerivedClassPointer);
171967 : // Milind Chabbi (8/28/2013): isSgCaseOptionStmt uses table-driven castability instead of c++ default dynamic_cast
171968 : // this improves the running time performance by 10-20%.
171969 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCaseOptionStmt*>(inputDerivedClassPointer);
171970 0 : return IS_SgCaseOptionStmt_FAST_MACRO(inputDerivedClassPointer);
171971 : }
171972 :
171973 :
171974 :
171975 : /* #line 171976 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
171976 :
171977 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
171978 :
171979 : /**
171980 : \brief Generated destructor
171981 :
171982 : This destructor is automatically generated (by ROSETTA). This destructor
171983 : only frees memory of data members associated with the parts of the current IR node which
171984 : are NOT traversed. Those data members that are part of a traversal can be freed using
171985 : a traversal (calling this destructor on all children in a post-order traversal). Such
171986 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
171987 :
171988 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
171989 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
171990 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
171991 :
171992 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
171993 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
171994 : pointers are not yet implemented to call delete on eash pointer in the container.
171995 : (This could be done by derivation from the STL containers to define containers that
171996 : automatically deleted their members.)
171997 :
171998 : */
171999 0 : SgCaseOptionStmt::~SgCaseOptionStmt () {
172000 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
172001 :
172002 :
172003 : // case: not a listType for key
172004 0 : p_key = NULL; // non list case
172005 : // case: not a listType for body
172006 0 : p_body = NULL; // non list case
172007 : // case: not a listType for key_range_end
172008 0 : p_key_range_end = NULL; // non list case
172009 : // case: not a listType for case_construct_name
172010 0 : p_case_construct_name = ""; // non list case
172011 :
172012 : }
172013 :
172014 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
172015 0 : }
172016 :
172017 :
172018 : /* #line 172019 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172019 :
172020 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
172021 :
172022 : // Generated constructor
172023 0 : SgCaseOptionStmt::SgCaseOptionStmt ( Sg_File_Info* startOfConstruct, SgExpression* key, SgStatement* body )
172024 0 : : SgStatement(startOfConstruct)
172025 : {
172026 : #ifdef DEBUG
172027 : // printf ("In SgCaseOptionStmt::SgCaseOptionStmt (Sg_File_Info* startOfConstruct, SgExpression* key, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
172028 : #endif
172029 : #if 0
172030 : // debugging information!
172031 : printf ("In SgCaseOptionStmt::SgCaseOptionStmt (Sg_File_Info* startOfConstruct, SgExpression* key, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
172032 : #endif
172033 :
172034 0 : p_key = key;
172035 0 : p_body = body;
172036 0 : p_key_range_end = NULL;
172037 0 : p_case_construct_name = "";
172038 :
172039 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
172040 :
172041 : #if 0
172042 : // DQ (7/30/2014): Call a virtual function.
172043 : std::string s = this->class_name();
172044 : #endif
172045 :
172046 : // Test the variant virtual function
172047 : // assert(CASE_STMT == variant());
172048 0 : assert(CASE_STMT == this->variant());
172049 0 : ROSE_ASSERT(CASE_STMT == (int)(this->variantT()));
172050 0 : post_construction_initialization();
172051 :
172052 : // Test the isSgCaseOptionStmt() function since it has been problematic
172053 0 : assert(isSgCaseOptionStmt(this) != NULL);
172054 0 : }
172055 :
172056 : // Generated constructor (all data members)
172057 :
172058 : /* #line 172059 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172059 :
172060 :
172061 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
172062 :
172063 :
172064 : // ********************************************************
172065 : // member functions common across all array grammar objects
172066 : // ********************************************************
172067 :
172068 :
172069 :
172070 : /* #line 172071 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172071 :
172072 :
172073 :
172074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
172075 :
172076 : // ********************************************************
172077 : // member functions specific to each node in the grammar
172078 : // ********************************************************
172079 :
172080 :
172081 : /* #line 172082 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172082 :
172083 : // Start of memberFunctionString
172084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
172085 :
172086 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
172087 :
172088 : SgStatement*
172089 0 : SgTryStmt::get_body () const
172090 : {
172091 0 : ROSE_ASSERT (this != NULL);
172092 :
172093 : #if 0
172094 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172095 : // used to trigger marking transformations for the token-based unparsing.
172096 : printf ("SgTryStmt::get_body = %p = %s \n",this,this->class_name().c_str());
172097 : #endif
172098 :
172099 0 : return p_body;
172100 : }
172101 :
172102 : void
172103 0 : SgTryStmt::set_body ( SgStatement* body )
172104 : {
172105 0 : ROSE_ASSERT (this != NULL);
172106 :
172107 : #if 0
172108 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172109 : // used to trigger marking transformations for the token-based unparsing.
172110 : printf ("SgTryStmt::set_body = %p = %s \n",this,this->class_name().c_str());
172111 : #endif
172112 :
172113 0 : set_isModified(true);
172114 :
172115 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
172116 : if (p_body != NULL && body != NULL && p_body != body)
172117 : {
172118 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
172119 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
172120 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
172121 : ROSE_ASSERT(false);
172122 : #endif
172123 : }
172124 : #endif
172125 0 : p_body = body;
172126 0 : }
172127 :
172128 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
172129 :
172130 :
172131 : // End of memberFunctionString
172132 : // Start of memberFunctionString
172133 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
172134 :
172135 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
172136 :
172137 : SgCatchStatementSeq*
172138 4914 : SgTryStmt::get_catch_statement_seq_root () const
172139 : {
172140 4914 : ROSE_ASSERT (this != NULL);
172141 :
172142 : #if 0
172143 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172144 : // used to trigger marking transformations for the token-based unparsing.
172145 : printf ("SgTryStmt::get_catch_statement_seq_root = %p = %s \n",this,this->class_name().c_str());
172146 : #endif
172147 :
172148 4914 : return p_catch_statement_seq_root;
172149 : }
172150 :
172151 : void
172152 1028 : SgTryStmt::set_catch_statement_seq_root ( SgCatchStatementSeq* catch_statement_seq_root )
172153 : {
172154 1028 : ROSE_ASSERT (this != NULL);
172155 :
172156 : #if 0
172157 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172158 : // used to trigger marking transformations for the token-based unparsing.
172159 : printf ("SgTryStmt::set_catch_statement_seq_root = %p = %s \n",this,this->class_name().c_str());
172160 : #endif
172161 :
172162 1028 : set_isModified(true);
172163 :
172164 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
172165 : if (p_catch_statement_seq_root != NULL && catch_statement_seq_root != NULL && p_catch_statement_seq_root != catch_statement_seq_root)
172166 : {
172167 : printf ("Warning: catch_statement_seq_root = %p overwriting valid pointer p_catch_statement_seq_root = %p \n",catch_statement_seq_root,p_catch_statement_seq_root);
172168 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
172169 : printf ("Error fails assertion (p_catch_statement_seq_root != NULL && catch_statement_seq_root != NULL && p_catch_statement_seq_root != catch_statement_seq_root) is false\n");
172170 : ROSE_ASSERT(false);
172171 : #endif
172172 : }
172173 : #endif
172174 1028 : p_catch_statement_seq_root = catch_statement_seq_root;
172175 1028 : }
172176 :
172177 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
172178 :
172179 :
172180 : // End of memberFunctionString
172181 : // Start of memberFunctionString
172182 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
172183 :
172184 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
172185 :
172186 : SgStatement*
172187 0 : SgTryStmt::get_else_body () const
172188 : {
172189 0 : ROSE_ASSERT (this != NULL);
172190 :
172191 : #if 0
172192 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172193 : // used to trigger marking transformations for the token-based unparsing.
172194 : printf ("SgTryStmt::get_else_body = %p = %s \n",this,this->class_name().c_str());
172195 : #endif
172196 :
172197 0 : return p_else_body;
172198 : }
172199 :
172200 : void
172201 0 : SgTryStmt::set_else_body ( SgStatement* else_body )
172202 : {
172203 0 : ROSE_ASSERT (this != NULL);
172204 :
172205 : #if 0
172206 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172207 : // used to trigger marking transformations for the token-based unparsing.
172208 : printf ("SgTryStmt::set_else_body = %p = %s \n",this,this->class_name().c_str());
172209 : #endif
172210 :
172211 0 : set_isModified(true);
172212 :
172213 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
172214 : if (p_else_body != NULL && else_body != NULL && p_else_body != else_body)
172215 : {
172216 : printf ("Warning: else_body = %p overwriting valid pointer p_else_body = %p \n",else_body,p_else_body);
172217 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
172218 : printf ("Error fails assertion (p_else_body != NULL && else_body != NULL && p_else_body != else_body) is false\n");
172219 : ROSE_ASSERT(false);
172220 : #endif
172221 : }
172222 : #endif
172223 0 : p_else_body = else_body;
172224 0 : }
172225 :
172226 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
172227 :
172228 :
172229 : // End of memberFunctionString
172230 : // Start of memberFunctionString
172231 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
172232 :
172233 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
172234 :
172235 : SgStatement*
172236 0 : SgTryStmt::get_finally_body () const
172237 : {
172238 0 : ROSE_ASSERT (this != NULL);
172239 :
172240 : #if 0
172241 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172242 : // used to trigger marking transformations for the token-based unparsing.
172243 : printf ("SgTryStmt::get_finally_body = %p = %s \n",this,this->class_name().c_str());
172244 : #endif
172245 :
172246 0 : return p_finally_body;
172247 : }
172248 :
172249 : void
172250 0 : SgTryStmt::set_finally_body ( SgStatement* finally_body )
172251 : {
172252 0 : ROSE_ASSERT (this != NULL);
172253 :
172254 : #if 0
172255 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172256 : // used to trigger marking transformations for the token-based unparsing.
172257 : printf ("SgTryStmt::set_finally_body = %p = %s \n",this,this->class_name().c_str());
172258 : #endif
172259 :
172260 0 : set_isModified(true);
172261 :
172262 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
172263 : if (p_finally_body != NULL && finally_body != NULL && p_finally_body != finally_body)
172264 : {
172265 : printf ("Warning: finally_body = %p overwriting valid pointer p_finally_body = %p \n",finally_body,p_finally_body);
172266 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
172267 : printf ("Error fails assertion (p_finally_body != NULL && finally_body != NULL && p_finally_body != finally_body) is false\n");
172268 : ROSE_ASSERT(false);
172269 : #endif
172270 : }
172271 : #endif
172272 0 : p_finally_body = finally_body;
172273 0 : }
172274 :
172275 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
172276 :
172277 :
172278 : // End of memberFunctionString
172279 : // Start of memberFunctionString
172280 : /* #line 15595 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
172281 :
172282 :
172283 : void
172284 514 : SgTryStmt::post_construction_initialization()
172285 : {
172286 : // MS: C++98: compound-statement (SgBasicBlock in SAGE)
172287 : #ifndef REMOVE_SET_PARENT_FUNCTION
172288 : if(get_body())
172289 : get_body()->set_parent(this);
172290 : #endif
172291 :
172292 : // MS: moved catch_statement_seq to CatchStatementSeq, therefore we need to init it here now
172293 514 : if (get_catch_statement_seq_root() == NULL)
172294 : {
172295 514 : Sg_File_Info* fileInfo = NULL;
172296 514 : if (this->get_file_info() != NULL)
172297 : {
172298 : // Get a copy of this to avoid sharing!
172299 0 : fileInfo = new Sg_File_Info( *(this->get_file_info()) );
172300 : }
172301 : // assert (fileInfo != NULL);
172302 514 : SgCatchStatementSeq* catchStatement = NULL;
172303 514 : if (fileInfo != NULL)
172304 : {
172305 : // DQ (10/16/2007): This appears to be set to the wrong parent.
172306 : // DQ (12/18/2006): Added to set all parents of Sg_File_Info objects.
172307 0 : fileInfo->set_parent(this);
172308 :
172309 : // DQ (10/31/2006): Set the end of source for the SgCatchStatementSeq
172310 : // set_catch_statement_seq_root( new SgCatchStatementSeq(fileInfo));
172311 0 : catchStatement = new SgCatchStatementSeq(fileInfo);
172312 :
172313 : // DQ (10/16/2007): Set the parent of the fileInfo used for the SgCatchStatementSeq to the catchStatement
172314 0 : fileInfo->set_parent(catchStatement);
172315 :
172316 0 : catchStatement->set_endOfConstruct(New_File_Info(catchStatement));
172317 :
172318 : // DQ (10/16/2007): Set the parent
172319 0 : catchStatement->get_endOfConstruct()->set_parent(catchStatement);
172320 : }
172321 : else
172322 : {
172323 514 : catchStatement = new SgCatchStatementSeq();
172324 : }
172325 :
172326 514 : set_catch_statement_seq_root( catchStatement );
172327 : // Liao, 10/29/2009, missing parent pointer
172328 514 : catchStatement->set_parent(this);
172329 : }
172330 514 : }
172331 :
172332 : bool
172333 0 : SgTryStmt::replace_child(SgStatement *target,SgStatement *newstmt,
172334 : bool extractBasicBlock)
172335 : {
172336 0 : if ( StatementReplace(this, p_body, target, newstmt) == true )
172337 0 : return true;
172338 : else
172339 0 : return ( StatementReplace( this, p_catch_statement_seq_root, target, newstmt) == true );
172340 : }
172341 :
172342 :
172343 : // MS: C++98: handler_seq (catch_statement_seq in SAGE)
172344 : SgStatementPtrList &
172345 0 : SgTryStmt::get_catch_statement_seq() {
172346 0 : return get_catch_statement_seq_root()->get_catch_statement_seq();
172347 : }
172348 :
172349 : // MS: C++98: handler_seq (catch_statement_seq in SAGE)
172350 : const SgStatementPtrList &
172351 0 : SgTryStmt::get_catch_statement_seq() const {
172352 0 : return get_catch_statement_seq_root()->get_catch_statement_seq();
172353 : }
172354 :
172355 : // MS: C++98: handler (catch_statement in SAGE)
172356 : void
172357 802 : SgTryStmt::append_catch_statement(SgStatement * what)
172358 : {
172359 : // DQ (6/4/2008): The SgCatchOptionStmt should have a parent pointing to
172360 : // the SgCatchStatementSeq in order for the Virtual CFG to work properly.
172361 :
172362 : // get_catch_statement_seq_root()->append_catch_statement(what);
172363 : // what->set_parent(this);
172364 : // get_catch_statement_seq_root()->append_catch_statement(what);
172365 802 : SgCatchStatementSeq* catchStatementList = get_catch_statement_seq_root();
172366 802 : ROSE_ASSERT(catchStatementList != NULL);
172367 802 : catchStatementList->append_catch_statement(what);
172368 802 : what->set_parent(catchStatementList);
172369 802 : }
172370 :
172371 : // MS: C++98: handler (catch_statement in SAGE)
172372 : void
172373 0 : SgTryStmt::prepend_catch_statement(SgStatement * what)
172374 : {
172375 0 : get_catch_statement_seq_root()->prepend_catch_statement(what);
172376 0 : what->set_parent(this);
172377 0 : }
172378 :
172379 :
172380 : #if 0
172381 : // MS: C++98: handler (catch_statement in SAGE)
172382 : void
172383 : SgTryStmt::insert_catch_statement(const SgStatementPtrList::iterator& where, SgStatement * what)
172384 : {
172385 : #ifndef REMOVE_SET_PARENT_FUNCTION
172386 : what->set_parent(this);
172387 : #endif
172388 : get_catch_statement_seq_root()->insert_catch_statement(where,what);
172389 : }
172390 : #endif
172391 :
172392 :
172393 :
172394 : // End of memberFunctionString
172395 : // Start of memberFunctionString
172396 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
172397 :
172398 : // *** COMMON CODE SECTION BEGINS HERE ***
172399 :
172400 : #if 0
172401 : int
172402 : SgTryStmt::getVariant() const
172403 : {
172404 : // This function is used in ROSE while "variant()" is used in SAGE
172405 : assert(this != NULL);
172406 : return variant();
172407 : }
172408 : #endif
172409 :
172410 : // This function is used in ROSE in treeTraversal code
172411 : // eventually replaces getVariant() and variant()
172412 : // though after variant() has been removed for a while we will
172413 : // want to change the name of variantT() back to variant()
172414 : // (since the "T" was ment to stand for temporary).
172415 : // When this happens the variantT() will be depricated.
172416 : VariantT
172417 293790 : SgTryStmt::variantT() const
172418 : {
172419 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
172420 293790 : ROSE_ASSERT(this != NULL);
172421 293790 : return V_SgTryStmt;
172422 : }
172423 :
172424 : #if 0
172425 : int
172426 : SgTryStmt::variant() const
172427 : {
172428 : // This function is used in SAGE
172429 : ROSE_ASSERT(this != NULL);
172430 : return TRY_STMT;
172431 : }
172432 : #endif
172433 :
172434 : ROSE_DLL_API const char*
172435 12 : SgTryStmt::sage_class_name() const
172436 : {
172437 12 : ROSE_ASSERT(this != NULL);
172438 12 : return "SgTryStmt";
172439 : }
172440 :
172441 : std::string
172442 352 : SgTryStmt::class_name() const
172443 : {
172444 352 : ROSE_ASSERT(this != NULL);
172445 352 : return "SgTryStmt";
172446 : }
172447 :
172448 : // DQ (11/26/2005): Support for visitor pattern mechanims
172449 : // (inferior to ROSE traversal mechanism, experimental).
172450 : void
172451 7866 : SgTryStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
172452 : {
172453 7866 : ROSE_ASSERT(this != NULL);
172454 7866 : visitor.visit(this);
172455 7866 : }
172456 :
172457 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
172458 0 : void SgTryStmt::accept (ROSE_VisitorPattern & visitor) {
172459 0 : ROSE_ASSERT(this != NULL);
172460 0 : visitor.visit(this);
172461 0 : }
172462 :
172463 : SgTryStmt*
172464 0 : SgTryStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
172465 : {
172466 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
172467 : // This function is currently only supported for the AST used the represent Binary executables.
172468 : if (0 /* isSgAsmNode(this) != NULL */)
172469 : {
172470 : // Support for regex specification.
172471 : std::string prefixCode = "REGEX:";
172472 : addNewAttribute(prefixCode + s,a);
172473 : }
172474 : #endif
172475 :
172476 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
172477 0 : return this;
172478 : }
172479 :
172480 : // *** COMMON CODE SECTION ENDS HERE ***
172481 :
172482 :
172483 : // End of memberFunctionString
172484 : // Start of memberFunctionString
172485 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
172486 :
172487 :
172488 : #if 0
172489 : //! Error checking support
172490 : /*! Verifies the following:
172491 : - working getVariant() member function
172492 : - calls base class's error() member function
172493 : Every class has one of these functions.
172494 : */
172495 : bool
172496 : SgTryStmt::error()
172497 : {
172498 : // Put error checking here
172499 :
172500 : ROSE_ASSERT (this != NULL);
172501 : if (getVariant() != TRY_STMT)
172502 : {
172503 : printf ("Error in SgTryStmt::error(): SgTryStmt object has a %s variant \n",
172504 : Cxx_GrammarTerminalNames[getVariant()].name);
172505 : // printf ("Error in SgTryStmt::error() \n");
172506 : ROSE_ABORT();
172507 : }
172508 :
172509 : ROSE_ASSERT (getVariant() == TRY_STMT);
172510 : return SgStatement::error();
172511 : }
172512 : #endif
172513 :
172514 :
172515 :
172516 : // End of memberFunctionString
172517 :
172518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
172519 :
172520 514 : SgTryStmt* isSgTryStmt ( SgNode* inputDerivedClassPointer )
172521 : {
172522 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
172523 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
172524 : // So to fix this we return NULL directly when the input is NULL and avoid the
172525 : // dynamic_cast in this case. This is likely a performance improvement as well.
172526 : // return dynamic_cast<SgTryStmt*>(inputDerivedClassPointer);
172527 : // Milind Chabbi (8/28/2013): isSgTryStmt uses table-driven castability instead of c++ default dynamic_cast
172528 : // this improves the running time performance by 10-20%.
172529 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTryStmt*>(inputDerivedClassPointer);
172530 514 : return IS_SgTryStmt_FAST_MACRO(inputDerivedClassPointer);
172531 : }
172532 :
172533 : // DQ (11/8/2003): Added version of functions taking const pointer
172534 0 : const SgTryStmt* isSgTryStmt ( const SgNode* inputDerivedClassPointer )
172535 : {
172536 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
172537 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
172538 : // So to fix this we return NULL directly when the input is NULL and avoid the
172539 : // dynamic_cast in this case. This is likely a performance improvement as well.
172540 : // return dynamic_cast<const SgTryStmt*>(inputDerivedClassPointer);
172541 : // Milind Chabbi (8/28/2013): isSgTryStmt uses table-driven castability instead of c++ default dynamic_cast
172542 : // this improves the running time performance by 10-20%.
172543 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTryStmt*>(inputDerivedClassPointer);
172544 0 : return IS_SgTryStmt_FAST_MACRO(inputDerivedClassPointer);
172545 : }
172546 :
172547 :
172548 :
172549 : /* #line 172550 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172550 :
172551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
172552 :
172553 : /**
172554 : \brief Generated destructor
172555 :
172556 : This destructor is automatically generated (by ROSETTA). This destructor
172557 : only frees memory of data members associated with the parts of the current IR node which
172558 : are NOT traversed. Those data members that are part of a traversal can be freed using
172559 : a traversal (calling this destructor on all children in a post-order traversal). Such
172560 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
172561 :
172562 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
172563 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
172564 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
172565 :
172566 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
172567 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
172568 : pointers are not yet implemented to call delete on eash pointer in the container.
172569 : (This could be done by derivation from the STL containers to define containers that
172570 : automatically deleted their members.)
172571 :
172572 : */
172573 216 : SgTryStmt::~SgTryStmt () {
172574 108 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
172575 :
172576 :
172577 : // case: not a listType for body
172578 108 : p_body = NULL; // non list case
172579 : // case: not a listType for catch_statement_seq_root
172580 108 : p_catch_statement_seq_root = NULL; // non list case
172581 : // case: not a listType for else_body
172582 108 : p_else_body = NULL; // non list case
172583 : // case: not a listType for finally_body
172584 108 : p_finally_body = NULL; // non list case
172585 :
172586 : }
172587 :
172588 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
172589 216 : }
172590 :
172591 :
172592 : /* #line 172593 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172593 :
172594 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
172595 :
172596 : // Generated constructor
172597 0 : SgTryStmt::SgTryStmt ( Sg_File_Info* startOfConstruct, SgStatement* body )
172598 0 : : SgStatement(startOfConstruct)
172599 : {
172600 : #ifdef DEBUG
172601 : // printf ("In SgTryStmt::SgTryStmt (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
172602 : #endif
172603 : #if 0
172604 : // debugging information!
172605 : printf ("In SgTryStmt::SgTryStmt (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
172606 : #endif
172607 :
172608 0 : p_body = body;
172609 0 : p_catch_statement_seq_root = NULL;
172610 0 : p_else_body = NULL;
172611 0 : p_finally_body = NULL;
172612 :
172613 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
172614 :
172615 : #if 0
172616 : // DQ (7/30/2014): Call a virtual function.
172617 : std::string s = this->class_name();
172618 : #endif
172619 :
172620 : // Test the variant virtual function
172621 : // assert(TRY_STMT == variant());
172622 0 : assert(TRY_STMT == this->variant());
172623 0 : ROSE_ASSERT(TRY_STMT == (int)(this->variantT()));
172624 0 : post_construction_initialization();
172625 :
172626 : // Test the isSgTryStmt() function since it has been problematic
172627 0 : assert(isSgTryStmt(this) != NULL);
172628 0 : }
172629 :
172630 : // Generated constructor (all data members)
172631 :
172632 : /* #line 172633 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172633 :
172634 :
172635 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
172636 :
172637 :
172638 : // ********************************************************
172639 : // member functions common across all array grammar objects
172640 : // ********************************************************
172641 :
172642 :
172643 :
172644 : /* #line 172645 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172645 :
172646 :
172647 :
172648 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
172649 :
172650 : // ********************************************************
172651 : // member functions specific to each node in the grammar
172652 : // ********************************************************
172653 :
172654 :
172655 : /* #line 172656 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172656 :
172657 : // Start of memberFunctionString
172658 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
172659 :
172660 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
172661 :
172662 : SgStatement*
172663 2 : SgDefaultOptionStmt::get_body () const
172664 : {
172665 2 : ROSE_ASSERT (this != NULL);
172666 :
172667 : #if 0
172668 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172669 : // used to trigger marking transformations for the token-based unparsing.
172670 : printf ("SgDefaultOptionStmt::get_body = %p = %s \n",this,this->class_name().c_str());
172671 : #endif
172672 :
172673 2 : return p_body;
172674 : }
172675 :
172676 : void
172677 1 : SgDefaultOptionStmt::set_body ( SgStatement* body )
172678 : {
172679 1 : ROSE_ASSERT (this != NULL);
172680 :
172681 : #if 0
172682 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172683 : // used to trigger marking transformations for the token-based unparsing.
172684 : printf ("SgDefaultOptionStmt::set_body = %p = %s \n",this,this->class_name().c_str());
172685 : #endif
172686 :
172687 1 : set_isModified(true);
172688 :
172689 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
172690 : if (p_body != NULL && body != NULL && p_body != body)
172691 : {
172692 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
172693 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
172694 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
172695 : ROSE_ASSERT(false);
172696 : #endif
172697 : }
172698 : #endif
172699 1 : p_body = body;
172700 1 : }
172701 :
172702 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
172703 :
172704 :
172705 : // End of memberFunctionString
172706 : // Start of memberFunctionString
172707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
172708 :
172709 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
172710 :
172711 : std::string
172712 0 : SgDefaultOptionStmt::get_default_construct_name () const
172713 : {
172714 0 : ROSE_ASSERT (this != NULL);
172715 :
172716 : #if 0
172717 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172718 : // used to trigger marking transformations for the token-based unparsing.
172719 : printf ("SgDefaultOptionStmt::get_default_construct_name = %p = %s \n",this,this->class_name().c_str());
172720 : #endif
172721 :
172722 0 : return p_default_construct_name;
172723 : }
172724 :
172725 : void
172726 0 : SgDefaultOptionStmt::set_default_construct_name ( std::string default_construct_name )
172727 : {
172728 0 : ROSE_ASSERT (this != NULL);
172729 :
172730 : #if 0
172731 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
172732 : // used to trigger marking transformations for the token-based unparsing.
172733 : printf ("SgDefaultOptionStmt::set_default_construct_name = %p = %s \n",this,this->class_name().c_str());
172734 : #endif
172735 :
172736 0 : set_isModified(true);
172737 :
172738 0 : p_default_construct_name = default_construct_name;
172739 0 : }
172740 :
172741 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
172742 :
172743 :
172744 : // End of memberFunctionString
172745 : // Start of memberFunctionString
172746 : /* #line 15814 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
172747 :
172748 :
172749 : void
172750 1 : SgDefaultOptionStmt::post_construction_initialization()
172751 : {
172752 : #ifndef REMOVE_SET_PARENT_FUNCTION
172753 : if (get_body()) get_body()->set_parent(this);
172754 : #endif
172755 1 : }
172756 :
172757 : // SgStatement* get_next(int&) const;
172758 :
172759 : bool
172760 0 : SgDefaultOptionStmt::replace_child(SgStatement *target,SgStatement *newstmt,
172761 : bool extractBasicBlock)
172762 : {
172763 0 : return ( StatementReplace(this, p_body, target, newstmt) == true );
172764 : }
172765 :
172766 : #if 0
172767 : SgStatement*
172768 : SgDefaultOptionStmt::get_next(int& n) const
172769 : {
172770 : if(n)
172771 : return 0;
172772 : else
172773 : {
172774 : n++;
172775 : return get_body();
172776 : }
172777 : }
172778 : #endif
172779 :
172780 :
172781 :
172782 : // End of memberFunctionString
172783 : // Start of memberFunctionString
172784 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
172785 :
172786 : // *** COMMON CODE SECTION BEGINS HERE ***
172787 :
172788 : #if 0
172789 : int
172790 : SgDefaultOptionStmt::getVariant() const
172791 : {
172792 : // This function is used in ROSE while "variant()" is used in SAGE
172793 : assert(this != NULL);
172794 : return variant();
172795 : }
172796 : #endif
172797 :
172798 : // This function is used in ROSE in treeTraversal code
172799 : // eventually replaces getVariant() and variant()
172800 : // though after variant() has been removed for a while we will
172801 : // want to change the name of variantT() back to variant()
172802 : // (since the "T" was ment to stand for temporary).
172803 : // When this happens the variantT() will be depricated.
172804 : VariantT
172805 247 : SgDefaultOptionStmt::variantT() const
172806 : {
172807 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
172808 247 : ROSE_ASSERT(this != NULL);
172809 247 : return V_SgDefaultOptionStmt;
172810 : }
172811 :
172812 : #if 0
172813 : int
172814 : SgDefaultOptionStmt::variant() const
172815 : {
172816 : // This function is used in SAGE
172817 : ROSE_ASSERT(this != NULL);
172818 : return DEFAULT_STMT;
172819 : }
172820 : #endif
172821 :
172822 : ROSE_DLL_API const char*
172823 2 : SgDefaultOptionStmt::sage_class_name() const
172824 : {
172825 2 : ROSE_ASSERT(this != NULL);
172826 2 : return "SgDefaultOptionStmt";
172827 : }
172828 :
172829 : std::string
172830 0 : SgDefaultOptionStmt::class_name() const
172831 : {
172832 0 : ROSE_ASSERT(this != NULL);
172833 0 : return "SgDefaultOptionStmt";
172834 : }
172835 :
172836 : // DQ (11/26/2005): Support for visitor pattern mechanims
172837 : // (inferior to ROSE traversal mechanism, experimental).
172838 : void
172839 18 : SgDefaultOptionStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
172840 : {
172841 18 : ROSE_ASSERT(this != NULL);
172842 18 : visitor.visit(this);
172843 18 : }
172844 :
172845 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
172846 0 : void SgDefaultOptionStmt::accept (ROSE_VisitorPattern & visitor) {
172847 0 : ROSE_ASSERT(this != NULL);
172848 0 : visitor.visit(this);
172849 0 : }
172850 :
172851 : SgDefaultOptionStmt*
172852 0 : SgDefaultOptionStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
172853 : {
172854 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
172855 : // This function is currently only supported for the AST used the represent Binary executables.
172856 : if (0 /* isSgAsmNode(this) != NULL */)
172857 : {
172858 : // Support for regex specification.
172859 : std::string prefixCode = "REGEX:";
172860 : addNewAttribute(prefixCode + s,a);
172861 : }
172862 : #endif
172863 :
172864 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
172865 0 : return this;
172866 : }
172867 :
172868 : // *** COMMON CODE SECTION ENDS HERE ***
172869 :
172870 :
172871 : // End of memberFunctionString
172872 : // Start of memberFunctionString
172873 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
172874 :
172875 :
172876 : #if 0
172877 : //! Error checking support
172878 : /*! Verifies the following:
172879 : - working getVariant() member function
172880 : - calls base class's error() member function
172881 : Every class has one of these functions.
172882 : */
172883 : bool
172884 : SgDefaultOptionStmt::error()
172885 : {
172886 : // Put error checking here
172887 :
172888 : ROSE_ASSERT (this != NULL);
172889 : if (getVariant() != DEFAULT_STMT)
172890 : {
172891 : printf ("Error in SgDefaultOptionStmt::error(): SgDefaultOptionStmt object has a %s variant \n",
172892 : Cxx_GrammarTerminalNames[getVariant()].name);
172893 : // printf ("Error in SgDefaultOptionStmt::error() \n");
172894 : ROSE_ABORT();
172895 : }
172896 :
172897 : ROSE_ASSERT (getVariant() == DEFAULT_STMT);
172898 : return SgStatement::error();
172899 : }
172900 : #endif
172901 :
172902 :
172903 :
172904 : // End of memberFunctionString
172905 :
172906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
172907 :
172908 6 : SgDefaultOptionStmt* isSgDefaultOptionStmt ( SgNode* inputDerivedClassPointer )
172909 : {
172910 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
172911 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
172912 : // So to fix this we return NULL directly when the input is NULL and avoid the
172913 : // dynamic_cast in this case. This is likely a performance improvement as well.
172914 : // return dynamic_cast<SgDefaultOptionStmt*>(inputDerivedClassPointer);
172915 : // Milind Chabbi (8/28/2013): isSgDefaultOptionStmt uses table-driven castability instead of c++ default dynamic_cast
172916 : // this improves the running time performance by 10-20%.
172917 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDefaultOptionStmt*>(inputDerivedClassPointer);
172918 6 : return IS_SgDefaultOptionStmt_FAST_MACRO(inputDerivedClassPointer);
172919 : }
172920 :
172921 : // DQ (11/8/2003): Added version of functions taking const pointer
172922 0 : const SgDefaultOptionStmt* isSgDefaultOptionStmt ( const SgNode* inputDerivedClassPointer )
172923 : {
172924 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
172925 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
172926 : // So to fix this we return NULL directly when the input is NULL and avoid the
172927 : // dynamic_cast in this case. This is likely a performance improvement as well.
172928 : // return dynamic_cast<const SgDefaultOptionStmt*>(inputDerivedClassPointer);
172929 : // Milind Chabbi (8/28/2013): isSgDefaultOptionStmt uses table-driven castability instead of c++ default dynamic_cast
172930 : // this improves the running time performance by 10-20%.
172931 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDefaultOptionStmt*>(inputDerivedClassPointer);
172932 0 : return IS_SgDefaultOptionStmt_FAST_MACRO(inputDerivedClassPointer);
172933 : }
172934 :
172935 :
172936 :
172937 : /* #line 172938 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172938 :
172939 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
172940 :
172941 : /**
172942 : \brief Generated destructor
172943 :
172944 : This destructor is automatically generated (by ROSETTA). This destructor
172945 : only frees memory of data members associated with the parts of the current IR node which
172946 : are NOT traversed. Those data members that are part of a traversal can be freed using
172947 : a traversal (calling this destructor on all children in a post-order traversal). Such
172948 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
172949 :
172950 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
172951 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
172952 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
172953 :
172954 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
172955 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
172956 : pointers are not yet implemented to call delete on eash pointer in the container.
172957 : (This could be done by derivation from the STL containers to define containers that
172958 : automatically deleted their members.)
172959 :
172960 : */
172961 0 : SgDefaultOptionStmt::~SgDefaultOptionStmt () {
172962 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
172963 :
172964 :
172965 : // case: not a listType for body
172966 0 : p_body = NULL; // non list case
172967 : // case: not a listType for default_construct_name
172968 0 : p_default_construct_name = ""; // non list case
172969 :
172970 : }
172971 :
172972 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
172973 0 : }
172974 :
172975 :
172976 : /* #line 172977 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
172977 :
172978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
172979 :
172980 : // Generated constructor
172981 0 : SgDefaultOptionStmt::SgDefaultOptionStmt ( Sg_File_Info* startOfConstruct, SgStatement* body )
172982 0 : : SgStatement(startOfConstruct)
172983 : {
172984 : #ifdef DEBUG
172985 : // printf ("In SgDefaultOptionStmt::SgDefaultOptionStmt (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
172986 : #endif
172987 : #if 0
172988 : // debugging information!
172989 : printf ("In SgDefaultOptionStmt::SgDefaultOptionStmt (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
172990 : #endif
172991 :
172992 0 : p_body = body;
172993 0 : p_default_construct_name = "";
172994 :
172995 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
172996 :
172997 : #if 0
172998 : // DQ (7/30/2014): Call a virtual function.
172999 : std::string s = this->class_name();
173000 : #endif
173001 :
173002 : // Test the variant virtual function
173003 : // assert(DEFAULT_STMT == variant());
173004 0 : assert(DEFAULT_STMT == this->variant());
173005 0 : ROSE_ASSERT(DEFAULT_STMT == (int)(this->variantT()));
173006 0 : post_construction_initialization();
173007 :
173008 : // Test the isSgDefaultOptionStmt() function since it has been problematic
173009 0 : assert(isSgDefaultOptionStmt(this) != NULL);
173010 0 : }
173011 :
173012 : // Generated constructor (all data members)
173013 :
173014 : /* #line 173015 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173015 :
173016 :
173017 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173018 :
173019 :
173020 : // ********************************************************
173021 : // member functions common across all array grammar objects
173022 : // ********************************************************
173023 :
173024 :
173025 :
173026 : /* #line 173027 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173027 :
173028 :
173029 :
173030 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173031 :
173032 : // ********************************************************
173033 : // member functions specific to each node in the grammar
173034 : // ********************************************************
173035 :
173036 :
173037 : /* #line 173038 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173038 :
173039 : // Start of memberFunctionString
173040 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
173041 :
173042 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
173043 :
173044 : std::string
173045 0 : SgBreakStmt::get_do_string_label () const
173046 : {
173047 0 : ROSE_ASSERT (this != NULL);
173048 :
173049 : #if 0
173050 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
173051 : // used to trigger marking transformations for the token-based unparsing.
173052 : printf ("SgBreakStmt::get_do_string_label = %p = %s \n",this,this->class_name().c_str());
173053 : #endif
173054 :
173055 0 : return p_do_string_label;
173056 : }
173057 :
173058 : void
173059 0 : SgBreakStmt::set_do_string_label ( std::string do_string_label )
173060 : {
173061 0 : ROSE_ASSERT (this != NULL);
173062 :
173063 : #if 0
173064 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
173065 : // used to trigger marking transformations for the token-based unparsing.
173066 : printf ("SgBreakStmt::set_do_string_label = %p = %s \n",this,this->class_name().c_str());
173067 : #endif
173068 :
173069 0 : set_isModified(true);
173070 :
173071 0 : p_do_string_label = do_string_label;
173072 0 : }
173073 :
173074 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
173075 :
173076 :
173077 : // End of memberFunctionString
173078 : // Start of memberFunctionString
173079 : /* #line 15850 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
173080 :
173081 : void
173082 242 : SgBreakStmt::post_construction_initialization()
173083 : {
173084 242 : }
173085 :
173086 :
173087 :
173088 : // End of memberFunctionString
173089 : // Start of memberFunctionString
173090 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
173091 :
173092 : // *** COMMON CODE SECTION BEGINS HERE ***
173093 :
173094 : #if 0
173095 : int
173096 : SgBreakStmt::getVariant() const
173097 : {
173098 : // This function is used in ROSE while "variant()" is used in SAGE
173099 : assert(this != NULL);
173100 : return variant();
173101 : }
173102 : #endif
173103 :
173104 : // This function is used in ROSE in treeTraversal code
173105 : // eventually replaces getVariant() and variant()
173106 : // though after variant() has been removed for a while we will
173107 : // want to change the name of variantT() back to variant()
173108 : // (since the "T" was ment to stand for temporary).
173109 : // When this happens the variantT() will be depricated.
173110 : VariantT
173111 44733 : SgBreakStmt::variantT() const
173112 : {
173113 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
173114 44733 : ROSE_ASSERT(this != NULL);
173115 44733 : return V_SgBreakStmt;
173116 : }
173117 :
173118 : #if 0
173119 : int
173120 : SgBreakStmt::variant() const
173121 : {
173122 : // This function is used in SAGE
173123 : ROSE_ASSERT(this != NULL);
173124 : return BREAK_STMT;
173125 : }
173126 : #endif
173127 :
173128 : ROSE_DLL_API const char*
173129 4 : SgBreakStmt::sage_class_name() const
173130 : {
173131 4 : ROSE_ASSERT(this != NULL);
173132 4 : return "SgBreakStmt";
173133 : }
173134 :
173135 : std::string
173136 180 : SgBreakStmt::class_name() const
173137 : {
173138 180 : ROSE_ASSERT(this != NULL);
173139 180 : return "SgBreakStmt";
173140 : }
173141 :
173142 : // DQ (11/26/2005): Support for visitor pattern mechanims
173143 : // (inferior to ROSE traversal mechanism, experimental).
173144 : void
173145 4146 : SgBreakStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
173146 : {
173147 4146 : ROSE_ASSERT(this != NULL);
173148 4146 : visitor.visit(this);
173149 4146 : }
173150 :
173151 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
173152 0 : void SgBreakStmt::accept (ROSE_VisitorPattern & visitor) {
173153 0 : ROSE_ASSERT(this != NULL);
173154 0 : visitor.visit(this);
173155 0 : }
173156 :
173157 : SgBreakStmt*
173158 0 : SgBreakStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
173159 : {
173160 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
173161 : // This function is currently only supported for the AST used the represent Binary executables.
173162 : if (0 /* isSgAsmNode(this) != NULL */)
173163 : {
173164 : // Support for regex specification.
173165 : std::string prefixCode = "REGEX:";
173166 : addNewAttribute(prefixCode + s,a);
173167 : }
173168 : #endif
173169 :
173170 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
173171 0 : return this;
173172 : }
173173 :
173174 : // *** COMMON CODE SECTION ENDS HERE ***
173175 :
173176 :
173177 : // End of memberFunctionString
173178 : // Start of memberFunctionString
173179 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
173180 :
173181 :
173182 : #if 0
173183 : //! Error checking support
173184 : /*! Verifies the following:
173185 : - working getVariant() member function
173186 : - calls base class's error() member function
173187 : Every class has one of these functions.
173188 : */
173189 : bool
173190 : SgBreakStmt::error()
173191 : {
173192 : // Put error checking here
173193 :
173194 : ROSE_ASSERT (this != NULL);
173195 : if (getVariant() != BREAK_STMT)
173196 : {
173197 : printf ("Error in SgBreakStmt::error(): SgBreakStmt object has a %s variant \n",
173198 : Cxx_GrammarTerminalNames[getVariant()].name);
173199 : // printf ("Error in SgBreakStmt::error() \n");
173200 : ROSE_ABORT();
173201 : }
173202 :
173203 : ROSE_ASSERT (getVariant() == BREAK_STMT);
173204 : return SgStatement::error();
173205 : }
173206 : #endif
173207 :
173208 :
173209 :
173210 : // End of memberFunctionString
173211 :
173212 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
173213 :
173214 1578 : SgBreakStmt* isSgBreakStmt ( SgNode* inputDerivedClassPointer )
173215 : {
173216 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
173217 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
173218 : // So to fix this we return NULL directly when the input is NULL and avoid the
173219 : // dynamic_cast in this case. This is likely a performance improvement as well.
173220 : // return dynamic_cast<SgBreakStmt*>(inputDerivedClassPointer);
173221 : // Milind Chabbi (8/28/2013): isSgBreakStmt uses table-driven castability instead of c++ default dynamic_cast
173222 : // this improves the running time performance by 10-20%.
173223 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBreakStmt*>(inputDerivedClassPointer);
173224 1578 : return IS_SgBreakStmt_FAST_MACRO(inputDerivedClassPointer);
173225 : }
173226 :
173227 : // DQ (11/8/2003): Added version of functions taking const pointer
173228 0 : const SgBreakStmt* isSgBreakStmt ( const SgNode* inputDerivedClassPointer )
173229 : {
173230 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
173231 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
173232 : // So to fix this we return NULL directly when the input is NULL and avoid the
173233 : // dynamic_cast in this case. This is likely a performance improvement as well.
173234 : // return dynamic_cast<const SgBreakStmt*>(inputDerivedClassPointer);
173235 : // Milind Chabbi (8/28/2013): isSgBreakStmt uses table-driven castability instead of c++ default dynamic_cast
173236 : // this improves the running time performance by 10-20%.
173237 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBreakStmt*>(inputDerivedClassPointer);
173238 0 : return IS_SgBreakStmt_FAST_MACRO(inputDerivedClassPointer);
173239 : }
173240 :
173241 :
173242 :
173243 : /* #line 173244 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173244 :
173245 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
173246 :
173247 : /**
173248 : \brief Generated destructor
173249 :
173250 : This destructor is automatically generated (by ROSETTA). This destructor
173251 : only frees memory of data members associated with the parts of the current IR node which
173252 : are NOT traversed. Those data members that are part of a traversal can be freed using
173253 : a traversal (calling this destructor on all children in a post-order traversal). Such
173254 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
173255 :
173256 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
173257 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
173258 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
173259 :
173260 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
173261 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
173262 : pointers are not yet implemented to call delete on eash pointer in the container.
173263 : (This could be done by derivation from the STL containers to define containers that
173264 : automatically deleted their members.)
173265 :
173266 : */
173267 120 : SgBreakStmt::~SgBreakStmt () {
173268 60 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
173269 :
173270 :
173271 : // case: not a listType for do_string_label
173272 60 : p_do_string_label = ""; // non list case
173273 :
173274 : }
173275 :
173276 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
173277 120 : }
173278 :
173279 :
173280 : /* #line 173281 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173281 :
173282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
173283 :
173284 : // Generated constructor
173285 0 : SgBreakStmt::SgBreakStmt ( Sg_File_Info* startOfConstruct )
173286 0 : : SgStatement(startOfConstruct)
173287 : {
173288 : #ifdef DEBUG
173289 : // printf ("In SgBreakStmt::SgBreakStmt (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
173290 : #endif
173291 : #if 0
173292 : // debugging information!
173293 : printf ("In SgBreakStmt::SgBreakStmt (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
173294 : #endif
173295 :
173296 0 : p_do_string_label = "";
173297 :
173298 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
173299 :
173300 : #if 0
173301 : // DQ (7/30/2014): Call a virtual function.
173302 : std::string s = this->class_name();
173303 : #endif
173304 :
173305 : // Test the variant virtual function
173306 : // assert(BREAK_STMT == variant());
173307 0 : assert(BREAK_STMT == this->variant());
173308 0 : ROSE_ASSERT(BREAK_STMT == (int)(this->variantT()));
173309 0 : post_construction_initialization();
173310 :
173311 : // Test the isSgBreakStmt() function since it has been problematic
173312 0 : assert(isSgBreakStmt(this) != NULL);
173313 0 : }
173314 :
173315 : // Generated constructor (all data members)
173316 :
173317 : /* #line 173318 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173318 :
173319 :
173320 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173321 :
173322 :
173323 : // ********************************************************
173324 : // member functions common across all array grammar objects
173325 : // ********************************************************
173326 :
173327 :
173328 :
173329 : /* #line 173330 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173330 :
173331 :
173332 :
173333 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173334 :
173335 : // ********************************************************
173336 : // member functions specific to each node in the grammar
173337 : // ********************************************************
173338 :
173339 :
173340 : /* #line 173341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173341 :
173342 : // Start of memberFunctionString
173343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
173344 :
173345 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
173346 :
173347 : std::string
173348 0 : SgContinueStmt::get_do_string_label () const
173349 : {
173350 0 : ROSE_ASSERT (this != NULL);
173351 :
173352 : #if 0
173353 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
173354 : // used to trigger marking transformations for the token-based unparsing.
173355 : printf ("SgContinueStmt::get_do_string_label = %p = %s \n",this,this->class_name().c_str());
173356 : #endif
173357 :
173358 0 : return p_do_string_label;
173359 : }
173360 :
173361 : void
173362 0 : SgContinueStmt::set_do_string_label ( std::string do_string_label )
173363 : {
173364 0 : ROSE_ASSERT (this != NULL);
173365 :
173366 : #if 0
173367 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
173368 : // used to trigger marking transformations for the token-based unparsing.
173369 : printf ("SgContinueStmt::set_do_string_label = %p = %s \n",this,this->class_name().c_str());
173370 : #endif
173371 :
173372 0 : set_isModified(true);
173373 :
173374 0 : p_do_string_label = do_string_label;
173375 0 : }
173376 :
173377 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
173378 :
173379 :
173380 : // End of memberFunctionString
173381 : // Start of memberFunctionString
173382 : /* #line 15859 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
173383 :
173384 :
173385 : void
173386 16 : SgContinueStmt::post_construction_initialization()
173387 : {
173388 16 : }
173389 :
173390 :
173391 :
173392 : // End of memberFunctionString
173393 : // Start of memberFunctionString
173394 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
173395 :
173396 : // *** COMMON CODE SECTION BEGINS HERE ***
173397 :
173398 : #if 0
173399 : int
173400 : SgContinueStmt::getVariant() const
173401 : {
173402 : // This function is used in ROSE while "variant()" is used in SAGE
173403 : assert(this != NULL);
173404 : return variant();
173405 : }
173406 : #endif
173407 :
173408 : // This function is used in ROSE in treeTraversal code
173409 : // eventually replaces getVariant() and variant()
173410 : // though after variant() has been removed for a while we will
173411 : // want to change the name of variantT() back to variant()
173412 : // (since the "T" was ment to stand for temporary).
173413 : // When this happens the variantT() will be depricated.
173414 : VariantT
173415 3180 : SgContinueStmt::variantT() const
173416 : {
173417 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
173418 3180 : ROSE_ASSERT(this != NULL);
173419 3180 : return V_SgContinueStmt;
173420 : }
173421 :
173422 : #if 0
173423 : int
173424 : SgContinueStmt::variant() const
173425 : {
173426 : // This function is used in SAGE
173427 : ROSE_ASSERT(this != NULL);
173428 : return CONTINUE_STMT;
173429 : }
173430 : #endif
173431 :
173432 : ROSE_DLL_API const char*
173433 0 : SgContinueStmt::sage_class_name() const
173434 : {
173435 0 : ROSE_ASSERT(this != NULL);
173436 0 : return "SgContinueStmt";
173437 : }
173438 :
173439 : std::string
173440 12 : SgContinueStmt::class_name() const
173441 : {
173442 12 : ROSE_ASSERT(this != NULL);
173443 12 : return "SgContinueStmt";
173444 : }
173445 :
173446 : // DQ (11/26/2005): Support for visitor pattern mechanims
173447 : // (inferior to ROSE traversal mechanism, experimental).
173448 : void
173449 274 : SgContinueStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
173450 : {
173451 274 : ROSE_ASSERT(this != NULL);
173452 274 : visitor.visit(this);
173453 274 : }
173454 :
173455 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
173456 0 : void SgContinueStmt::accept (ROSE_VisitorPattern & visitor) {
173457 0 : ROSE_ASSERT(this != NULL);
173458 0 : visitor.visit(this);
173459 0 : }
173460 :
173461 : SgContinueStmt*
173462 0 : SgContinueStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
173463 : {
173464 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
173465 : // This function is currently only supported for the AST used the represent Binary executables.
173466 : if (0 /* isSgAsmNode(this) != NULL */)
173467 : {
173468 : // Support for regex specification.
173469 : std::string prefixCode = "REGEX:";
173470 : addNewAttribute(prefixCode + s,a);
173471 : }
173472 : #endif
173473 :
173474 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
173475 0 : return this;
173476 : }
173477 :
173478 : // *** COMMON CODE SECTION ENDS HERE ***
173479 :
173480 :
173481 : // End of memberFunctionString
173482 : // Start of memberFunctionString
173483 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
173484 :
173485 :
173486 : #if 0
173487 : //! Error checking support
173488 : /*! Verifies the following:
173489 : - working getVariant() member function
173490 : - calls base class's error() member function
173491 : Every class has one of these functions.
173492 : */
173493 : bool
173494 : SgContinueStmt::error()
173495 : {
173496 : // Put error checking here
173497 :
173498 : ROSE_ASSERT (this != NULL);
173499 : if (getVariant() != CONTINUE_STMT)
173500 : {
173501 : printf ("Error in SgContinueStmt::error(): SgContinueStmt object has a %s variant \n",
173502 : Cxx_GrammarTerminalNames[getVariant()].name);
173503 : // printf ("Error in SgContinueStmt::error() \n");
173504 : ROSE_ABORT();
173505 : }
173506 :
173507 : ROSE_ASSERT (getVariant() == CONTINUE_STMT);
173508 : return SgStatement::error();
173509 : }
173510 : #endif
173511 :
173512 :
173513 :
173514 : // End of memberFunctionString
173515 :
173516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
173517 :
173518 1146 : SgContinueStmt* isSgContinueStmt ( SgNode* inputDerivedClassPointer )
173519 : {
173520 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
173521 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
173522 : // So to fix this we return NULL directly when the input is NULL and avoid the
173523 : // dynamic_cast in this case. This is likely a performance improvement as well.
173524 : // return dynamic_cast<SgContinueStmt*>(inputDerivedClassPointer);
173525 : // Milind Chabbi (8/28/2013): isSgContinueStmt uses table-driven castability instead of c++ default dynamic_cast
173526 : // this improves the running time performance by 10-20%.
173527 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgContinueStmt*>(inputDerivedClassPointer);
173528 1146 : return IS_SgContinueStmt_FAST_MACRO(inputDerivedClassPointer);
173529 : }
173530 :
173531 : // DQ (11/8/2003): Added version of functions taking const pointer
173532 0 : const SgContinueStmt* isSgContinueStmt ( const SgNode* inputDerivedClassPointer )
173533 : {
173534 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
173535 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
173536 : // So to fix this we return NULL directly when the input is NULL and avoid the
173537 : // dynamic_cast in this case. This is likely a performance improvement as well.
173538 : // return dynamic_cast<const SgContinueStmt*>(inputDerivedClassPointer);
173539 : // Milind Chabbi (8/28/2013): isSgContinueStmt uses table-driven castability instead of c++ default dynamic_cast
173540 : // this improves the running time performance by 10-20%.
173541 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgContinueStmt*>(inputDerivedClassPointer);
173542 0 : return IS_SgContinueStmt_FAST_MACRO(inputDerivedClassPointer);
173543 : }
173544 :
173545 :
173546 :
173547 : /* #line 173548 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173548 :
173549 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
173550 :
173551 : /**
173552 : \brief Generated destructor
173553 :
173554 : This destructor is automatically generated (by ROSETTA). This destructor
173555 : only frees memory of data members associated with the parts of the current IR node which
173556 : are NOT traversed. Those data members that are part of a traversal can be freed using
173557 : a traversal (calling this destructor on all children in a post-order traversal). Such
173558 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
173559 :
173560 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
173561 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
173562 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
173563 :
173564 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
173565 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
173566 : pointers are not yet implemented to call delete on eash pointer in the container.
173567 : (This could be done by derivation from the STL containers to define containers that
173568 : automatically deleted their members.)
173569 :
173570 : */
173571 8 : SgContinueStmt::~SgContinueStmt () {
173572 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
173573 :
173574 :
173575 : // case: not a listType for do_string_label
173576 4 : p_do_string_label = ""; // non list case
173577 :
173578 : }
173579 :
173580 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
173581 8 : }
173582 :
173583 :
173584 : /* #line 173585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173585 :
173586 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
173587 :
173588 : // Generated constructor
173589 0 : SgContinueStmt::SgContinueStmt ( Sg_File_Info* startOfConstruct )
173590 0 : : SgStatement(startOfConstruct)
173591 : {
173592 : #ifdef DEBUG
173593 : // printf ("In SgContinueStmt::SgContinueStmt (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
173594 : #endif
173595 : #if 0
173596 : // debugging information!
173597 : printf ("In SgContinueStmt::SgContinueStmt (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
173598 : #endif
173599 :
173600 0 : p_do_string_label = "";
173601 :
173602 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
173603 :
173604 : #if 0
173605 : // DQ (7/30/2014): Call a virtual function.
173606 : std::string s = this->class_name();
173607 : #endif
173608 :
173609 : // Test the variant virtual function
173610 : // assert(CONTINUE_STMT == variant());
173611 0 : assert(CONTINUE_STMT == this->variant());
173612 0 : ROSE_ASSERT(CONTINUE_STMT == (int)(this->variantT()));
173613 0 : post_construction_initialization();
173614 :
173615 : // Test the isSgContinueStmt() function since it has been problematic
173616 0 : assert(isSgContinueStmt(this) != NULL);
173617 0 : }
173618 :
173619 : // Generated constructor (all data members)
173620 :
173621 : /* #line 173622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173622 :
173623 :
173624 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173625 :
173626 :
173627 : // ********************************************************
173628 : // member functions common across all array grammar objects
173629 : // ********************************************************
173630 :
173631 :
173632 :
173633 : /* #line 173634 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173634 :
173635 :
173636 :
173637 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173638 :
173639 : // ********************************************************
173640 : // member functions specific to each node in the grammar
173641 : // ********************************************************
173642 :
173643 :
173644 : /* #line 173645 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173645 :
173646 : // Start of memberFunctionString
173647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
173648 :
173649 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
173650 :
173651 : SgExpression*
173652 1721 : SgReturnStmt::get_expression () const
173653 : {
173654 1721 : ROSE_ASSERT (this != NULL);
173655 :
173656 : #if 0
173657 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
173658 : // used to trigger marking transformations for the token-based unparsing.
173659 : printf ("SgReturnStmt::get_expression = %p = %s \n",this,this->class_name().c_str());
173660 : #endif
173661 :
173662 1721 : return p_expression;
173663 : }
173664 :
173665 : void
173666 2 : SgReturnStmt::set_expression ( SgExpression* expression )
173667 : {
173668 2 : ROSE_ASSERT (this != NULL);
173669 :
173670 : #if 0
173671 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
173672 : // used to trigger marking transformations for the token-based unparsing.
173673 : printf ("SgReturnStmt::set_expression = %p = %s \n",this,this->class_name().c_str());
173674 : #endif
173675 :
173676 2 : set_isModified(true);
173677 :
173678 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
173679 : if (p_expression != NULL && expression != NULL && p_expression != expression)
173680 : {
173681 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
173682 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
173683 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
173684 : ROSE_ASSERT(false);
173685 : #endif
173686 : }
173687 : #endif
173688 2 : p_expression = expression;
173689 2 : }
173690 :
173691 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
173692 :
173693 :
173694 : // End of memberFunctionString
173695 : // Start of memberFunctionString
173696 : /* #line 15869 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
173697 :
173698 :
173699 : void
173700 14309 : SgReturnStmt::post_construction_initialization()
173701 : {
173702 : // DQ (11/7/2006): removed use of expression root
173703 : // if (get_expression_root() != 0)
173704 : // get_expression_root()->set_statement(this);
173705 14309 : }
173706 :
173707 : // DQ (12/15/2006): We need this sort of function now that we have removed the expression root node!
173708 : // The requirement of not being able to do operations uniformly on expressions may be the disadvantage
173709 : // of not having used the SgExpressionRoot IR node as a concept.
173710 : int
173711 0 : SgReturnStmt::replace_expression(SgExpression * original_expression, SgExpression * new_expression )
173712 : {
173713 : // DQ (12/17/2006): This function should have the semantics that it will represent a
173714 : // structural change to the AST, thus it is free to set the parent of the new expression.
173715 :
173716 0 : ROSE_ASSERT(original_expression != NULL);
173717 0 : ROSE_ASSERT(new_expression != NULL);
173718 :
173719 0 : ROSE_ASSERT(original_expression == p_expression);
173720 :
173721 0 : set_expression(new_expression);
173722 :
173723 0 : new_expression->set_parent(this);
173724 :
173725 : // DQ: Let this be a memory leak for now to avoid initial problems.
173726 0 : ROSE_ASSERT(original_expression != NULL);
173727 : // delete original_expression;
173728 :
173729 0 : return 0;
173730 : }
173731 :
173732 :
173733 :
173734 : // End of memberFunctionString
173735 : // Start of memberFunctionString
173736 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
173737 :
173738 : // *** COMMON CODE SECTION BEGINS HERE ***
173739 :
173740 : #if 0
173741 : int
173742 : SgReturnStmt::getVariant() const
173743 : {
173744 : // This function is used in ROSE while "variant()" is used in SAGE
173745 : assert(this != NULL);
173746 : return variant();
173747 : }
173748 : #endif
173749 :
173750 : // This function is used in ROSE in treeTraversal code
173751 : // eventually replaces getVariant() and variant()
173752 : // though after variant() has been removed for a while we will
173753 : // want to change the name of variantT() back to variant()
173754 : // (since the "T" was ment to stand for temporary).
173755 : // When this happens the variantT() will be depricated.
173756 : VariantT
173757 4713740 : SgReturnStmt::variantT() const
173758 : {
173759 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
173760 4713740 : ROSE_ASSERT(this != NULL);
173761 4713740 : return V_SgReturnStmt;
173762 : }
173763 :
173764 : #if 0
173765 : int
173766 : SgReturnStmt::variant() const
173767 : {
173768 : // This function is used in SAGE
173769 : ROSE_ASSERT(this != NULL);
173770 : return RETURN_STMT;
173771 : }
173772 : #endif
173773 :
173774 : ROSE_DLL_API const char*
173775 399 : SgReturnStmt::sage_class_name() const
173776 : {
173777 399 : ROSE_ASSERT(this != NULL);
173778 399 : return "SgReturnStmt";
173779 : }
173780 :
173781 : std::string
173782 10482 : SgReturnStmt::class_name() const
173783 : {
173784 10482 : ROSE_ASSERT(this != NULL);
173785 10482 : return "SgReturnStmt";
173786 : }
173787 :
173788 : // DQ (11/26/2005): Support for visitor pattern mechanims
173789 : // (inferior to ROSE traversal mechanism, experimental).
173790 : void
173791 195885 : SgReturnStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
173792 : {
173793 195885 : ROSE_ASSERT(this != NULL);
173794 195885 : visitor.visit(this);
173795 195885 : }
173796 :
173797 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
173798 0 : void SgReturnStmt::accept (ROSE_VisitorPattern & visitor) {
173799 0 : ROSE_ASSERT(this != NULL);
173800 0 : visitor.visit(this);
173801 0 : }
173802 :
173803 : SgReturnStmt*
173804 0 : SgReturnStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
173805 : {
173806 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
173807 : // This function is currently only supported for the AST used the represent Binary executables.
173808 : if (0 /* isSgAsmNode(this) != NULL */)
173809 : {
173810 : // Support for regex specification.
173811 : std::string prefixCode = "REGEX:";
173812 : addNewAttribute(prefixCode + s,a);
173813 : }
173814 : #endif
173815 :
173816 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
173817 0 : return this;
173818 : }
173819 :
173820 : // *** COMMON CODE SECTION ENDS HERE ***
173821 :
173822 :
173823 : // End of memberFunctionString
173824 : // Start of memberFunctionString
173825 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
173826 :
173827 :
173828 : #if 0
173829 : //! Error checking support
173830 : /*! Verifies the following:
173831 : - working getVariant() member function
173832 : - calls base class's error() member function
173833 : Every class has one of these functions.
173834 : */
173835 : bool
173836 : SgReturnStmt::error()
173837 : {
173838 : // Put error checking here
173839 :
173840 : ROSE_ASSERT (this != NULL);
173841 : if (getVariant() != RETURN_STMT)
173842 : {
173843 : printf ("Error in SgReturnStmt::error(): SgReturnStmt object has a %s variant \n",
173844 : Cxx_GrammarTerminalNames[getVariant()].name);
173845 : // printf ("Error in SgReturnStmt::error() \n");
173846 : ROSE_ABORT();
173847 : }
173848 :
173849 : ROSE_ASSERT (getVariant() == RETURN_STMT);
173850 : return SgStatement::error();
173851 : }
173852 : #endif
173853 :
173854 :
173855 :
173856 : // End of memberFunctionString
173857 :
173858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
173859 :
173860 18154 : SgReturnStmt* isSgReturnStmt ( SgNode* inputDerivedClassPointer )
173861 : {
173862 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
173863 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
173864 : // So to fix this we return NULL directly when the input is NULL and avoid the
173865 : // dynamic_cast in this case. This is likely a performance improvement as well.
173866 : // return dynamic_cast<SgReturnStmt*>(inputDerivedClassPointer);
173867 : // Milind Chabbi (8/28/2013): isSgReturnStmt uses table-driven castability instead of c++ default dynamic_cast
173868 : // this improves the running time performance by 10-20%.
173869 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgReturnStmt*>(inputDerivedClassPointer);
173870 18154 : return IS_SgReturnStmt_FAST_MACRO(inputDerivedClassPointer);
173871 : }
173872 :
173873 : // DQ (11/8/2003): Added version of functions taking const pointer
173874 0 : const SgReturnStmt* isSgReturnStmt ( const SgNode* inputDerivedClassPointer )
173875 : {
173876 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
173877 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
173878 : // So to fix this we return NULL directly when the input is NULL and avoid the
173879 : // dynamic_cast in this case. This is likely a performance improvement as well.
173880 : // return dynamic_cast<const SgReturnStmt*>(inputDerivedClassPointer);
173881 : // Milind Chabbi (8/28/2013): isSgReturnStmt uses table-driven castability instead of c++ default dynamic_cast
173882 : // this improves the running time performance by 10-20%.
173883 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgReturnStmt*>(inputDerivedClassPointer);
173884 0 : return IS_SgReturnStmt_FAST_MACRO(inputDerivedClassPointer);
173885 : }
173886 :
173887 :
173888 :
173889 : /* #line 173890 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173890 :
173891 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
173892 :
173893 : /**
173894 : \brief Generated destructor
173895 :
173896 : This destructor is automatically generated (by ROSETTA). This destructor
173897 : only frees memory of data members associated with the parts of the current IR node which
173898 : are NOT traversed. Those data members that are part of a traversal can be freed using
173899 : a traversal (calling this destructor on all children in a post-order traversal). Such
173900 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
173901 :
173902 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
173903 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
173904 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
173905 :
173906 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
173907 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
173908 : pointers are not yet implemented to call delete on eash pointer in the container.
173909 : (This could be done by derivation from the STL containers to define containers that
173910 : automatically deleted their members.)
173911 :
173912 : */
173913 5620 : SgReturnStmt::~SgReturnStmt () {
173914 2810 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
173915 :
173916 :
173917 : // case: not a listType for expression
173918 2810 : p_expression = NULL; // non list case
173919 :
173920 : }
173921 :
173922 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
173923 5620 : }
173924 :
173925 :
173926 : /* #line 173927 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173927 :
173928 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
173929 :
173930 : // Generated constructor
173931 2 : SgReturnStmt::SgReturnStmt ( Sg_File_Info* startOfConstruct, SgExpression* expression )
173932 2 : : SgStatement(startOfConstruct)
173933 : {
173934 : #ifdef DEBUG
173935 : // printf ("In SgReturnStmt::SgReturnStmt (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
173936 : #endif
173937 : #if 0
173938 : // debugging information!
173939 : printf ("In SgReturnStmt::SgReturnStmt (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
173940 : #endif
173941 :
173942 2 : p_expression = expression;
173943 :
173944 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
173945 :
173946 : #if 0
173947 : // DQ (7/30/2014): Call a virtual function.
173948 : std::string s = this->class_name();
173949 : #endif
173950 :
173951 : // Test the variant virtual function
173952 : // assert(RETURN_STMT == variant());
173953 2 : assert(RETURN_STMT == this->variant());
173954 2 : ROSE_ASSERT(RETURN_STMT == (int)(this->variantT()));
173955 2 : post_construction_initialization();
173956 :
173957 : // Test the isSgReturnStmt() function since it has been problematic
173958 2 : assert(isSgReturnStmt(this) != NULL);
173959 2 : }
173960 :
173961 : // Generated constructor (all data members)
173962 :
173963 : /* #line 173964 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173964 :
173965 :
173966 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173967 :
173968 :
173969 : // ********************************************************
173970 : // member functions common across all array grammar objects
173971 : // ********************************************************
173972 :
173973 :
173974 :
173975 : /* #line 173976 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173976 :
173977 :
173978 :
173979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
173980 :
173981 : // ********************************************************
173982 : // member functions specific to each node in the grammar
173983 : // ********************************************************
173984 :
173985 :
173986 : /* #line 173987 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
173987 :
173988 : // Start of memberFunctionString
173989 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
173990 :
173991 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
173992 :
173993 : SgLabelStatement*
173994 8 : SgGotoStatement::get_label () const
173995 : {
173996 8 : ROSE_ASSERT (this != NULL);
173997 :
173998 : #if 0
173999 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174000 : // used to trigger marking transformations for the token-based unparsing.
174001 : printf ("SgGotoStatement::get_label = %p = %s \n",this,this->class_name().c_str());
174002 : #endif
174003 :
174004 8 : return p_label;
174005 : }
174006 :
174007 : void
174008 1 : SgGotoStatement::set_label ( SgLabelStatement* label )
174009 : {
174010 1 : ROSE_ASSERT (this != NULL);
174011 :
174012 : #if 0
174013 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174014 : // used to trigger marking transformations for the token-based unparsing.
174015 : printf ("SgGotoStatement::set_label = %p = %s \n",this,this->class_name().c_str());
174016 : #endif
174017 :
174018 1 : set_isModified(true);
174019 :
174020 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
174021 : if (p_label != NULL && label != NULL && p_label != label)
174022 : {
174023 : printf ("Warning: label = %p overwriting valid pointer p_label = %p \n",label,p_label);
174024 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
174025 : printf ("Error fails assertion (p_label != NULL && label != NULL && p_label != label) is false\n");
174026 : ROSE_ASSERT(false);
174027 : #endif
174028 : }
174029 : #endif
174030 1 : p_label = label;
174031 1 : }
174032 :
174033 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
174034 :
174035 :
174036 : // End of memberFunctionString
174037 : // Start of memberFunctionString
174038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
174039 :
174040 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
174041 :
174042 : SgLabelRefExp*
174043 2 : SgGotoStatement::get_label_expression () const
174044 : {
174045 2 : ROSE_ASSERT (this != NULL);
174046 :
174047 : #if 0
174048 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174049 : // used to trigger marking transformations for the token-based unparsing.
174050 : printf ("SgGotoStatement::get_label_expression = %p = %s \n",this,this->class_name().c_str());
174051 : #endif
174052 :
174053 2 : return p_label_expression;
174054 : }
174055 :
174056 : void
174057 1 : SgGotoStatement::set_label_expression ( SgLabelRefExp* label_expression )
174058 : {
174059 1 : ROSE_ASSERT (this != NULL);
174060 :
174061 : #if 0
174062 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174063 : // used to trigger marking transformations for the token-based unparsing.
174064 : printf ("SgGotoStatement::set_label_expression = %p = %s \n",this,this->class_name().c_str());
174065 : #endif
174066 :
174067 1 : set_isModified(true);
174068 :
174069 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
174070 : if (p_label_expression != NULL && label_expression != NULL && p_label_expression != label_expression)
174071 : {
174072 : printf ("Warning: label_expression = %p overwriting valid pointer p_label_expression = %p \n",label_expression,p_label_expression);
174073 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
174074 : printf ("Error fails assertion (p_label_expression != NULL && label_expression != NULL && p_label_expression != label_expression) is false\n");
174075 : ROSE_ASSERT(false);
174076 : #endif
174077 : }
174078 : #endif
174079 1 : p_label_expression = label_expression;
174080 1 : }
174081 :
174082 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
174083 :
174084 :
174085 : // End of memberFunctionString
174086 : // Start of memberFunctionString
174087 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
174088 :
174089 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
174090 :
174091 : SgExpression*
174092 0 : SgGotoStatement::get_selector_expression () const
174093 : {
174094 0 : ROSE_ASSERT (this != NULL);
174095 :
174096 : #if 0
174097 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174098 : // used to trigger marking transformations for the token-based unparsing.
174099 : printf ("SgGotoStatement::get_selector_expression = %p = %s \n",this,this->class_name().c_str());
174100 : #endif
174101 :
174102 0 : return p_selector_expression;
174103 : }
174104 :
174105 : void
174106 0 : SgGotoStatement::set_selector_expression ( SgExpression* selector_expression )
174107 : {
174108 0 : ROSE_ASSERT (this != NULL);
174109 :
174110 : #if 0
174111 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174112 : // used to trigger marking transformations for the token-based unparsing.
174113 : printf ("SgGotoStatement::set_selector_expression = %p = %s \n",this,this->class_name().c_str());
174114 : #endif
174115 :
174116 0 : set_isModified(true);
174117 :
174118 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
174119 : if (p_selector_expression != NULL && selector_expression != NULL && p_selector_expression != selector_expression)
174120 : {
174121 : printf ("Warning: selector_expression = %p overwriting valid pointer p_selector_expression = %p \n",selector_expression,p_selector_expression);
174122 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
174123 : printf ("Error fails assertion (p_selector_expression != NULL && selector_expression != NULL && p_selector_expression != selector_expression) is false\n");
174124 : ROSE_ASSERT(false);
174125 : #endif
174126 : }
174127 : #endif
174128 0 : p_selector_expression = selector_expression;
174129 0 : }
174130 :
174131 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
174132 :
174133 :
174134 : // End of memberFunctionString
174135 : // Start of memberFunctionString
174136 : /* #line 15907 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
174137 :
174138 :
174139 : void
174140 4 : SgGotoStatement::post_construction_initialization()
174141 : {
174142 : #ifndef REMOVE_SET_PARENT_FUNCTION
174143 : if(get_label())
174144 : {
174145 : get_label()->set_parent(this);
174146 : }
174147 : #endif
174148 4 : }
174149 :
174150 : bool
174151 0 : SgGotoStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
174152 : {
174153 0 : return ( StatementReplace(this, p_label, target, newstmt) == true );
174154 : }
174155 :
174156 :
174157 :
174158 : // End of memberFunctionString
174159 : // Start of memberFunctionString
174160 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
174161 :
174162 : // *** COMMON CODE SECTION BEGINS HERE ***
174163 :
174164 : #if 0
174165 : int
174166 : SgGotoStatement::getVariant() const
174167 : {
174168 : // This function is used in ROSE while "variant()" is used in SAGE
174169 : assert(this != NULL);
174170 : return variant();
174171 : }
174172 : #endif
174173 :
174174 : // This function is used in ROSE in treeTraversal code
174175 : // eventually replaces getVariant() and variant()
174176 : // though after variant() has been removed for a while we will
174177 : // want to change the name of variantT() back to variant()
174178 : // (since the "T" was ment to stand for temporary).
174179 : // When this happens the variantT() will be depricated.
174180 : VariantT
174181 547 : SgGotoStatement::variantT() const
174182 : {
174183 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
174184 547 : ROSE_ASSERT(this != NULL);
174185 547 : return V_SgGotoStatement;
174186 : }
174187 :
174188 : #if 0
174189 : int
174190 : SgGotoStatement::variant() const
174191 : {
174192 : // This function is used in SAGE
174193 : ROSE_ASSERT(this != NULL);
174194 : return GOTO_STMT;
174195 : }
174196 : #endif
174197 :
174198 : ROSE_DLL_API const char*
174199 2 : SgGotoStatement::sage_class_name() const
174200 : {
174201 2 : ROSE_ASSERT(this != NULL);
174202 2 : return "SgGotoStatement";
174203 : }
174204 :
174205 : std::string
174206 3 : SgGotoStatement::class_name() const
174207 : {
174208 3 : ROSE_ASSERT(this != NULL);
174209 3 : return "SgGotoStatement";
174210 : }
174211 :
174212 : // DQ (11/26/2005): Support for visitor pattern mechanims
174213 : // (inferior to ROSE traversal mechanism, experimental).
174214 : void
174215 18 : SgGotoStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
174216 : {
174217 18 : ROSE_ASSERT(this != NULL);
174218 18 : visitor.visit(this);
174219 18 : }
174220 :
174221 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
174222 0 : void SgGotoStatement::accept (ROSE_VisitorPattern & visitor) {
174223 0 : ROSE_ASSERT(this != NULL);
174224 0 : visitor.visit(this);
174225 0 : }
174226 :
174227 : SgGotoStatement*
174228 0 : SgGotoStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
174229 : {
174230 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
174231 : // This function is currently only supported for the AST used the represent Binary executables.
174232 : if (0 /* isSgAsmNode(this) != NULL */)
174233 : {
174234 : // Support for regex specification.
174235 : std::string prefixCode = "REGEX:";
174236 : addNewAttribute(prefixCode + s,a);
174237 : }
174238 : #endif
174239 :
174240 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
174241 0 : return this;
174242 : }
174243 :
174244 : // *** COMMON CODE SECTION ENDS HERE ***
174245 :
174246 :
174247 : // End of memberFunctionString
174248 : // Start of memberFunctionString
174249 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
174250 :
174251 :
174252 : #if 0
174253 : //! Error checking support
174254 : /*! Verifies the following:
174255 : - working getVariant() member function
174256 : - calls base class's error() member function
174257 : Every class has one of these functions.
174258 : */
174259 : bool
174260 : SgGotoStatement::error()
174261 : {
174262 : // Put error checking here
174263 :
174264 : ROSE_ASSERT (this != NULL);
174265 : if (getVariant() != GOTO_STMT)
174266 : {
174267 : printf ("Error in SgGotoStatement::error(): SgGotoStatement object has a %s variant \n",
174268 : Cxx_GrammarTerminalNames[getVariant()].name);
174269 : // printf ("Error in SgGotoStatement::error() \n");
174270 : ROSE_ABORT();
174271 : }
174272 :
174273 : ROSE_ASSERT (getVariant() == GOTO_STMT);
174274 : return SgStatement::error();
174275 : }
174276 : #endif
174277 :
174278 :
174279 :
174280 : // End of memberFunctionString
174281 :
174282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
174283 :
174284 1073 : SgGotoStatement* isSgGotoStatement ( SgNode* inputDerivedClassPointer )
174285 : {
174286 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
174287 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
174288 : // So to fix this we return NULL directly when the input is NULL and avoid the
174289 : // dynamic_cast in this case. This is likely a performance improvement as well.
174290 : // return dynamic_cast<SgGotoStatement*>(inputDerivedClassPointer);
174291 : // Milind Chabbi (8/28/2013): isSgGotoStatement uses table-driven castability instead of c++ default dynamic_cast
174292 : // this improves the running time performance by 10-20%.
174293 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGotoStatement*>(inputDerivedClassPointer);
174294 1073 : return IS_SgGotoStatement_FAST_MACRO(inputDerivedClassPointer);
174295 : }
174296 :
174297 : // DQ (11/8/2003): Added version of functions taking const pointer
174298 0 : const SgGotoStatement* isSgGotoStatement ( const SgNode* inputDerivedClassPointer )
174299 : {
174300 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
174301 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
174302 : // So to fix this we return NULL directly when the input is NULL and avoid the
174303 : // dynamic_cast in this case. This is likely a performance improvement as well.
174304 : // return dynamic_cast<const SgGotoStatement*>(inputDerivedClassPointer);
174305 : // Milind Chabbi (8/28/2013): isSgGotoStatement uses table-driven castability instead of c++ default dynamic_cast
174306 : // this improves the running time performance by 10-20%.
174307 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGotoStatement*>(inputDerivedClassPointer);
174308 0 : return IS_SgGotoStatement_FAST_MACRO(inputDerivedClassPointer);
174309 : }
174310 :
174311 :
174312 :
174313 : /* #line 174314 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174314 :
174315 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
174316 :
174317 : /**
174318 : \brief Generated destructor
174319 :
174320 : This destructor is automatically generated (by ROSETTA). This destructor
174321 : only frees memory of data members associated with the parts of the current IR node which
174322 : are NOT traversed. Those data members that are part of a traversal can be freed using
174323 : a traversal (calling this destructor on all children in a post-order traversal). Such
174324 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
174325 :
174326 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
174327 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
174328 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
174329 :
174330 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
174331 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
174332 : pointers are not yet implemented to call delete on eash pointer in the container.
174333 : (This could be done by derivation from the STL containers to define containers that
174334 : automatically deleted their members.)
174335 :
174336 : */
174337 0 : SgGotoStatement::~SgGotoStatement () {
174338 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
174339 :
174340 :
174341 : // case: not a listType for label
174342 0 : p_label = NULL; // non list case
174343 : // case: not a listType for label_expression
174344 0 : p_label_expression = NULL; // non list case
174345 : // case: not a listType for selector_expression
174346 0 : p_selector_expression = NULL; // non list case
174347 :
174348 : }
174349 :
174350 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
174351 0 : }
174352 :
174353 :
174354 : /* #line 174355 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174355 :
174356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
174357 :
174358 : // Generated constructor
174359 0 : SgGotoStatement::SgGotoStatement ( Sg_File_Info* startOfConstruct, SgLabelStatement* label )
174360 0 : : SgStatement(startOfConstruct)
174361 : {
174362 : #ifdef DEBUG
174363 : // printf ("In SgGotoStatement::SgGotoStatement (Sg_File_Info* startOfConstruct, SgLabelStatement* label) sage_class_name() = %s \n",sage_class_name());
174364 : #endif
174365 : #if 0
174366 : // debugging information!
174367 : printf ("In SgGotoStatement::SgGotoStatement (Sg_File_Info* startOfConstruct, SgLabelStatement* label): this = %p = %s \n",this,this->class_name().c_str());
174368 : #endif
174369 :
174370 0 : p_label = label;
174371 0 : p_label_expression = NULL;
174372 0 : p_selector_expression = NULL;
174373 :
174374 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
174375 :
174376 : #if 0
174377 : // DQ (7/30/2014): Call a virtual function.
174378 : std::string s = this->class_name();
174379 : #endif
174380 :
174381 : // Test the variant virtual function
174382 : // assert(GOTO_STMT == variant());
174383 0 : assert(GOTO_STMT == this->variant());
174384 0 : ROSE_ASSERT(GOTO_STMT == (int)(this->variantT()));
174385 0 : post_construction_initialization();
174386 :
174387 : // Test the isSgGotoStatement() function since it has been problematic
174388 0 : assert(isSgGotoStatement(this) != NULL);
174389 0 : }
174390 :
174391 : // Generated constructor (all data members)
174392 :
174393 : /* #line 174394 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174394 :
174395 :
174396 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
174397 :
174398 :
174399 : // ********************************************************
174400 : // member functions common across all array grammar objects
174401 : // ********************************************************
174402 :
174403 :
174404 :
174405 : /* #line 174406 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174406 :
174407 :
174408 :
174409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
174410 :
174411 : // ********************************************************
174412 : // member functions specific to each node in the grammar
174413 : // ********************************************************
174414 :
174415 :
174416 : /* #line 174417 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174417 :
174418 : // Start of memberFunctionString
174419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
174420 :
174421 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
174422 :
174423 : SgFunctionCallExp*
174424 0 : SgSpawnStmt::get_the_func () const
174425 : {
174426 0 : ROSE_ASSERT (this != NULL);
174427 :
174428 : #if 0
174429 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174430 : // used to trigger marking transformations for the token-based unparsing.
174431 : printf ("SgSpawnStmt::get_the_func = %p = %s \n",this,this->class_name().c_str());
174432 : #endif
174433 :
174434 0 : return p_the_func;
174435 : }
174436 :
174437 : void
174438 0 : SgSpawnStmt::set_the_func ( SgFunctionCallExp* the_func )
174439 : {
174440 0 : ROSE_ASSERT (this != NULL);
174441 :
174442 : #if 0
174443 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
174444 : // used to trigger marking transformations for the token-based unparsing.
174445 : printf ("SgSpawnStmt::set_the_func = %p = %s \n",this,this->class_name().c_str());
174446 : #endif
174447 :
174448 0 : set_isModified(true);
174449 :
174450 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
174451 : if (p_the_func != NULL && the_func != NULL && p_the_func != the_func)
174452 : {
174453 : printf ("Warning: the_func = %p overwriting valid pointer p_the_func = %p \n",the_func,p_the_func);
174454 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
174455 : printf ("Error fails assertion (p_the_func != NULL && the_func != NULL && p_the_func != the_func) is false\n");
174456 : ROSE_ASSERT(false);
174457 : #endif
174458 : }
174459 : #endif
174460 0 : p_the_func = the_func;
174461 0 : }
174462 :
174463 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
174464 :
174465 :
174466 : // End of memberFunctionString
174467 : // Start of memberFunctionString
174468 : /* #line 16017 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
174469 :
174470 :
174471 : void
174472 0 : SgSpawnStmt::post_construction_initialization()
174473 0 : {}
174474 :
174475 :
174476 :
174477 : // End of memberFunctionString
174478 : // Start of memberFunctionString
174479 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
174480 :
174481 : // *** COMMON CODE SECTION BEGINS HERE ***
174482 :
174483 : #if 0
174484 : int
174485 : SgSpawnStmt::getVariant() const
174486 : {
174487 : // This function is used in ROSE while "variant()" is used in SAGE
174488 : assert(this != NULL);
174489 : return variant();
174490 : }
174491 : #endif
174492 :
174493 : // This function is used in ROSE in treeTraversal code
174494 : // eventually replaces getVariant() and variant()
174495 : // though after variant() has been removed for a while we will
174496 : // want to change the name of variantT() back to variant()
174497 : // (since the "T" was ment to stand for temporary).
174498 : // When this happens the variantT() will be depricated.
174499 : VariantT
174500 0 : SgSpawnStmt::variantT() const
174501 : {
174502 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
174503 0 : ROSE_ASSERT(this != NULL);
174504 0 : return V_SgSpawnStmt;
174505 : }
174506 :
174507 : #if 0
174508 : int
174509 : SgSpawnStmt::variant() const
174510 : {
174511 : // This function is used in SAGE
174512 : ROSE_ASSERT(this != NULL);
174513 : return SPAWN_STMT;
174514 : }
174515 : #endif
174516 :
174517 : ROSE_DLL_API const char*
174518 0 : SgSpawnStmt::sage_class_name() const
174519 : {
174520 0 : ROSE_ASSERT(this != NULL);
174521 0 : return "SgSpawnStmt";
174522 : }
174523 :
174524 : std::string
174525 0 : SgSpawnStmt::class_name() const
174526 : {
174527 0 : ROSE_ASSERT(this != NULL);
174528 0 : return "SgSpawnStmt";
174529 : }
174530 :
174531 : // DQ (11/26/2005): Support for visitor pattern mechanims
174532 : // (inferior to ROSE traversal mechanism, experimental).
174533 : void
174534 0 : SgSpawnStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
174535 : {
174536 0 : ROSE_ASSERT(this != NULL);
174537 0 : visitor.visit(this);
174538 0 : }
174539 :
174540 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
174541 0 : void SgSpawnStmt::accept (ROSE_VisitorPattern & visitor) {
174542 0 : ROSE_ASSERT(this != NULL);
174543 0 : visitor.visit(this);
174544 0 : }
174545 :
174546 : SgSpawnStmt*
174547 0 : SgSpawnStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
174548 : {
174549 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
174550 : // This function is currently only supported for the AST used the represent Binary executables.
174551 : if (0 /* isSgAsmNode(this) != NULL */)
174552 : {
174553 : // Support for regex specification.
174554 : std::string prefixCode = "REGEX:";
174555 : addNewAttribute(prefixCode + s,a);
174556 : }
174557 : #endif
174558 :
174559 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
174560 0 : return this;
174561 : }
174562 :
174563 : // *** COMMON CODE SECTION ENDS HERE ***
174564 :
174565 :
174566 : // End of memberFunctionString
174567 : // Start of memberFunctionString
174568 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
174569 :
174570 :
174571 : #if 0
174572 : //! Error checking support
174573 : /*! Verifies the following:
174574 : - working getVariant() member function
174575 : - calls base class's error() member function
174576 : Every class has one of these functions.
174577 : */
174578 : bool
174579 : SgSpawnStmt::error()
174580 : {
174581 : // Put error checking here
174582 :
174583 : ROSE_ASSERT (this != NULL);
174584 : if (getVariant() != SPAWN_STMT)
174585 : {
174586 : printf ("Error in SgSpawnStmt::error(): SgSpawnStmt object has a %s variant \n",
174587 : Cxx_GrammarTerminalNames[getVariant()].name);
174588 : // printf ("Error in SgSpawnStmt::error() \n");
174589 : ROSE_ABORT();
174590 : }
174591 :
174592 : ROSE_ASSERT (getVariant() == SPAWN_STMT);
174593 : return SgStatement::error();
174594 : }
174595 : #endif
174596 :
174597 :
174598 :
174599 : // End of memberFunctionString
174600 :
174601 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
174602 :
174603 0 : SgSpawnStmt* isSgSpawnStmt ( SgNode* inputDerivedClassPointer )
174604 : {
174605 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
174606 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
174607 : // So to fix this we return NULL directly when the input is NULL and avoid the
174608 : // dynamic_cast in this case. This is likely a performance improvement as well.
174609 : // return dynamic_cast<SgSpawnStmt*>(inputDerivedClassPointer);
174610 : // Milind Chabbi (8/28/2013): isSgSpawnStmt uses table-driven castability instead of c++ default dynamic_cast
174611 : // this improves the running time performance by 10-20%.
174612 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSpawnStmt*>(inputDerivedClassPointer);
174613 0 : return IS_SgSpawnStmt_FAST_MACRO(inputDerivedClassPointer);
174614 : }
174615 :
174616 : // DQ (11/8/2003): Added version of functions taking const pointer
174617 0 : const SgSpawnStmt* isSgSpawnStmt ( const SgNode* inputDerivedClassPointer )
174618 : {
174619 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
174620 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
174621 : // So to fix this we return NULL directly when the input is NULL and avoid the
174622 : // dynamic_cast in this case. This is likely a performance improvement as well.
174623 : // return dynamic_cast<const SgSpawnStmt*>(inputDerivedClassPointer);
174624 : // Milind Chabbi (8/28/2013): isSgSpawnStmt uses table-driven castability instead of c++ default dynamic_cast
174625 : // this improves the running time performance by 10-20%.
174626 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSpawnStmt*>(inputDerivedClassPointer);
174627 0 : return IS_SgSpawnStmt_FAST_MACRO(inputDerivedClassPointer);
174628 : }
174629 :
174630 :
174631 :
174632 : /* #line 174633 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174633 :
174634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
174635 :
174636 : /**
174637 : \brief Generated destructor
174638 :
174639 : This destructor is automatically generated (by ROSETTA). This destructor
174640 : only frees memory of data members associated with the parts of the current IR node which
174641 : are NOT traversed. Those data members that are part of a traversal can be freed using
174642 : a traversal (calling this destructor on all children in a post-order traversal). Such
174643 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
174644 :
174645 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
174646 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
174647 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
174648 :
174649 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
174650 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
174651 : pointers are not yet implemented to call delete on eash pointer in the container.
174652 : (This could be done by derivation from the STL containers to define containers that
174653 : automatically deleted their members.)
174654 :
174655 : */
174656 0 : SgSpawnStmt::~SgSpawnStmt () {
174657 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
174658 :
174659 :
174660 : // case: not a listType for the_func
174661 0 : p_the_func = NULL; // non list case
174662 :
174663 : }
174664 :
174665 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
174666 0 : }
174667 :
174668 :
174669 : /* #line 174670 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174670 :
174671 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
174672 :
174673 : // Generated constructor
174674 0 : SgSpawnStmt::SgSpawnStmt ( Sg_File_Info* startOfConstruct, SgFunctionCallExp* the_func )
174675 0 : : SgStatement(startOfConstruct)
174676 : {
174677 : #ifdef DEBUG
174678 : // printf ("In SgSpawnStmt::SgSpawnStmt (Sg_File_Info* startOfConstruct, SgFunctionCallExp* the_func) sage_class_name() = %s \n",sage_class_name());
174679 : #endif
174680 : #if 0
174681 : // debugging information!
174682 : printf ("In SgSpawnStmt::SgSpawnStmt (Sg_File_Info* startOfConstruct, SgFunctionCallExp* the_func): this = %p = %s \n",this,this->class_name().c_str());
174683 : #endif
174684 :
174685 0 : p_the_func = the_func;
174686 :
174687 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
174688 :
174689 : #if 0
174690 : // DQ (7/30/2014): Call a virtual function.
174691 : std::string s = this->class_name();
174692 : #endif
174693 :
174694 : // Test the variant virtual function
174695 : // assert(SPAWN_STMT == variant());
174696 0 : assert(SPAWN_STMT == this->variant());
174697 0 : ROSE_ASSERT(SPAWN_STMT == (int)(this->variantT()));
174698 0 : post_construction_initialization();
174699 :
174700 : // Test the isSgSpawnStmt() function since it has been problematic
174701 0 : assert(isSgSpawnStmt(this) != NULL);
174702 0 : }
174703 :
174704 : // Generated constructor (all data members)
174705 :
174706 : /* #line 174707 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174707 :
174708 :
174709 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
174710 :
174711 :
174712 : // ********************************************************
174713 : // member functions common across all array grammar objects
174714 : // ********************************************************
174715 :
174716 :
174717 :
174718 : /* #line 174719 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174719 :
174720 :
174721 :
174722 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
174723 :
174724 : // ********************************************************
174725 : // member functions specific to each node in the grammar
174726 : // ********************************************************
174727 :
174728 :
174729 : /* #line 174730 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174730 :
174731 : // Start of memberFunctionString
174732 : /* #line 16026 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
174733 :
174734 :
174735 : void
174736 258 : SgNullStatement::post_construction_initialization()
174737 258 : {}
174738 :
174739 :
174740 :
174741 : // End of memberFunctionString
174742 : // Start of memberFunctionString
174743 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
174744 :
174745 : // *** COMMON CODE SECTION BEGINS HERE ***
174746 :
174747 : #if 0
174748 : int
174749 : SgNullStatement::getVariant() const
174750 : {
174751 : // This function is used in ROSE while "variant()" is used in SAGE
174752 : assert(this != NULL);
174753 : return variant();
174754 : }
174755 : #endif
174756 :
174757 : // This function is used in ROSE in treeTraversal code
174758 : // eventually replaces getVariant() and variant()
174759 : // though after variant() has been removed for a while we will
174760 : // want to change the name of variantT() back to variant()
174761 : // (since the "T" was ment to stand for temporary).
174762 : // When this happens the variantT() will be depricated.
174763 : VariantT
174764 87071 : SgNullStatement::variantT() const
174765 : {
174766 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
174767 87071 : ROSE_ASSERT(this != NULL);
174768 87071 : return V_SgNullStatement;
174769 : }
174770 :
174771 : #if 0
174772 : int
174773 : SgNullStatement::variant() const
174774 : {
174775 : // This function is used in SAGE
174776 : ROSE_ASSERT(this != NULL);
174777 : return NULL_STMT;
174778 : }
174779 : #endif
174780 :
174781 : ROSE_DLL_API const char*
174782 0 : SgNullStatement::sage_class_name() const
174783 : {
174784 0 : ROSE_ASSERT(this != NULL);
174785 0 : return "SgNullStatement";
174786 : }
174787 :
174788 : std::string
174789 156 : SgNullStatement::class_name() const
174790 : {
174791 156 : ROSE_ASSERT(this != NULL);
174792 156 : return "SgNullStatement";
174793 : }
174794 :
174795 : // DQ (11/26/2005): Support for visitor pattern mechanims
174796 : // (inferior to ROSE traversal mechanism, experimental).
174797 : void
174798 3172 : SgNullStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
174799 : {
174800 3172 : ROSE_ASSERT(this != NULL);
174801 3172 : visitor.visit(this);
174802 3172 : }
174803 :
174804 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
174805 0 : void SgNullStatement::accept (ROSE_VisitorPattern & visitor) {
174806 0 : ROSE_ASSERT(this != NULL);
174807 0 : visitor.visit(this);
174808 0 : }
174809 :
174810 : SgNullStatement*
174811 0 : SgNullStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
174812 : {
174813 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
174814 : // This function is currently only supported for the AST used the represent Binary executables.
174815 : if (0 /* isSgAsmNode(this) != NULL */)
174816 : {
174817 : // Support for regex specification.
174818 : std::string prefixCode = "REGEX:";
174819 : addNewAttribute(prefixCode + s,a);
174820 : }
174821 : #endif
174822 :
174823 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
174824 0 : return this;
174825 : }
174826 :
174827 : // *** COMMON CODE SECTION ENDS HERE ***
174828 :
174829 :
174830 : // End of memberFunctionString
174831 : // Start of memberFunctionString
174832 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
174833 :
174834 :
174835 : #if 0
174836 : //! Error checking support
174837 : /*! Verifies the following:
174838 : - working getVariant() member function
174839 : - calls base class's error() member function
174840 : Every class has one of these functions.
174841 : */
174842 : bool
174843 : SgNullStatement::error()
174844 : {
174845 : // Put error checking here
174846 :
174847 : ROSE_ASSERT (this != NULL);
174848 : if (getVariant() != NULL_STMT)
174849 : {
174850 : printf ("Error in SgNullStatement::error(): SgNullStatement object has a %s variant \n",
174851 : Cxx_GrammarTerminalNames[getVariant()].name);
174852 : // printf ("Error in SgNullStatement::error() \n");
174853 : ROSE_ABORT();
174854 : }
174855 :
174856 : ROSE_ASSERT (getVariant() == NULL_STMT);
174857 : return SgStatement::error();
174858 : }
174859 : #endif
174860 :
174861 :
174862 :
174863 : // End of memberFunctionString
174864 :
174865 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
174866 :
174867 266 : SgNullStatement* isSgNullStatement ( SgNode* inputDerivedClassPointer )
174868 : {
174869 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
174870 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
174871 : // So to fix this we return NULL directly when the input is NULL and avoid the
174872 : // dynamic_cast in this case. This is likely a performance improvement as well.
174873 : // return dynamic_cast<SgNullStatement*>(inputDerivedClassPointer);
174874 : // Milind Chabbi (8/28/2013): isSgNullStatement uses table-driven castability instead of c++ default dynamic_cast
174875 : // this improves the running time performance by 10-20%.
174876 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNullStatement*>(inputDerivedClassPointer);
174877 266 : return IS_SgNullStatement_FAST_MACRO(inputDerivedClassPointer);
174878 : }
174879 :
174880 : // DQ (11/8/2003): Added version of functions taking const pointer
174881 0 : const SgNullStatement* isSgNullStatement ( const SgNode* inputDerivedClassPointer )
174882 : {
174883 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
174884 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
174885 : // So to fix this we return NULL directly when the input is NULL and avoid the
174886 : // dynamic_cast in this case. This is likely a performance improvement as well.
174887 : // return dynamic_cast<const SgNullStatement*>(inputDerivedClassPointer);
174888 : // Milind Chabbi (8/28/2013): isSgNullStatement uses table-driven castability instead of c++ default dynamic_cast
174889 : // this improves the running time performance by 10-20%.
174890 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNullStatement*>(inputDerivedClassPointer);
174891 0 : return IS_SgNullStatement_FAST_MACRO(inputDerivedClassPointer);
174892 : }
174893 :
174894 :
174895 :
174896 : /* #line 174897 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174897 :
174898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
174899 :
174900 : /**
174901 : \brief Generated destructor
174902 :
174903 : This destructor is automatically generated (by ROSETTA). This destructor
174904 : only frees memory of data members associated with the parts of the current IR node which
174905 : are NOT traversed. Those data members that are part of a traversal can be freed using
174906 : a traversal (calling this destructor on all children in a post-order traversal). Such
174907 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
174908 :
174909 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
174910 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
174911 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
174912 :
174913 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
174914 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
174915 : pointers are not yet implemented to call delete on eash pointer in the container.
174916 : (This could be done by derivation from the STL containers to define containers that
174917 : automatically deleted their members.)
174918 :
174919 : */
174920 84 : SgNullStatement::~SgNullStatement () {
174921 42 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
174922 :
174923 :
174924 :
174925 : }
174926 :
174927 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
174928 84 : }
174929 :
174930 :
174931 : /* #line 174932 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174932 :
174933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
174934 :
174935 : // Generated constructor
174936 0 : SgNullStatement::SgNullStatement ( Sg_File_Info* startOfConstruct )
174937 0 : : SgStatement(startOfConstruct)
174938 : {
174939 : #ifdef DEBUG
174940 : // printf ("In SgNullStatement::SgNullStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
174941 : #endif
174942 : #if 0
174943 : // debugging information!
174944 : printf ("In SgNullStatement::SgNullStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
174945 : #endif
174946 :
174947 :
174948 :
174949 : #if 0
174950 : // DQ (7/30/2014): Call a virtual function.
174951 : std::string s = this->class_name();
174952 : #endif
174953 :
174954 : // Test the variant virtual function
174955 : // assert(NULL_STMT == variant());
174956 0 : assert(NULL_STMT == this->variant());
174957 0 : ROSE_ASSERT(NULL_STMT == (int)(this->variantT()));
174958 0 : post_construction_initialization();
174959 :
174960 : // Test the isSgNullStatement() function since it has been problematic
174961 0 : assert(isSgNullStatement(this) != NULL);
174962 0 : }
174963 :
174964 : // Generated constructor (all data members)
174965 :
174966 : /* #line 174967 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174967 :
174968 :
174969 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
174970 :
174971 :
174972 : // ********************************************************
174973 : // member functions common across all array grammar objects
174974 : // ********************************************************
174975 :
174976 :
174977 :
174978 : /* #line 174979 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174979 :
174980 :
174981 :
174982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
174983 :
174984 : // ********************************************************
174985 : // member functions specific to each node in the grammar
174986 : // ********************************************************
174987 :
174988 :
174989 : /* #line 174990 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
174990 :
174991 : // Start of memberFunctionString
174992 : /* #line 16053 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
174993 :
174994 :
174995 : void
174996 0 : SgVariantStatement::post_construction_initialization()
174997 0 : {}
174998 :
174999 :
175000 :
175001 : // End of memberFunctionString
175002 : // Start of memberFunctionString
175003 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
175004 :
175005 : // *** COMMON CODE SECTION BEGINS HERE ***
175006 :
175007 : #if 0
175008 : int
175009 : SgVariantStatement::getVariant() const
175010 : {
175011 : // This function is used in ROSE while "variant()" is used in SAGE
175012 : assert(this != NULL);
175013 : return variant();
175014 : }
175015 : #endif
175016 :
175017 : // This function is used in ROSE in treeTraversal code
175018 : // eventually replaces getVariant() and variant()
175019 : // though after variant() has been removed for a while we will
175020 : // want to change the name of variantT() back to variant()
175021 : // (since the "T" was ment to stand for temporary).
175022 : // When this happens the variantT() will be depricated.
175023 : VariantT
175024 0 : SgVariantStatement::variantT() const
175025 : {
175026 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
175027 0 : ROSE_ASSERT(this != NULL);
175028 0 : return V_SgVariantStatement;
175029 : }
175030 :
175031 : #if 0
175032 : int
175033 : SgVariantStatement::variant() const
175034 : {
175035 : // This function is used in SAGE
175036 : ROSE_ASSERT(this != NULL);
175037 : return VARIANT_STMT;
175038 : }
175039 : #endif
175040 :
175041 : ROSE_DLL_API const char*
175042 0 : SgVariantStatement::sage_class_name() const
175043 : {
175044 0 : ROSE_ASSERT(this != NULL);
175045 0 : return "SgVariantStatement";
175046 : }
175047 :
175048 : std::string
175049 0 : SgVariantStatement::class_name() const
175050 : {
175051 0 : ROSE_ASSERT(this != NULL);
175052 0 : return "SgVariantStatement";
175053 : }
175054 :
175055 : // DQ (11/26/2005): Support for visitor pattern mechanims
175056 : // (inferior to ROSE traversal mechanism, experimental).
175057 : void
175058 0 : SgVariantStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
175059 : {
175060 0 : ROSE_ASSERT(this != NULL);
175061 0 : visitor.visit(this);
175062 0 : }
175063 :
175064 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
175065 0 : void SgVariantStatement::accept (ROSE_VisitorPattern & visitor) {
175066 0 : ROSE_ASSERT(this != NULL);
175067 0 : visitor.visit(this);
175068 0 : }
175069 :
175070 : SgVariantStatement*
175071 0 : SgVariantStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
175072 : {
175073 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
175074 : // This function is currently only supported for the AST used the represent Binary executables.
175075 : if (0 /* isSgAsmNode(this) != NULL */)
175076 : {
175077 : // Support for regex specification.
175078 : std::string prefixCode = "REGEX:";
175079 : addNewAttribute(prefixCode + s,a);
175080 : }
175081 : #endif
175082 :
175083 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
175084 0 : return this;
175085 : }
175086 :
175087 : // *** COMMON CODE SECTION ENDS HERE ***
175088 :
175089 :
175090 : // End of memberFunctionString
175091 : // Start of memberFunctionString
175092 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
175093 :
175094 :
175095 : #if 0
175096 : //! Error checking support
175097 : /*! Verifies the following:
175098 : - working getVariant() member function
175099 : - calls base class's error() member function
175100 : Every class has one of these functions.
175101 : */
175102 : bool
175103 : SgVariantStatement::error()
175104 : {
175105 : // Put error checking here
175106 :
175107 : ROSE_ASSERT (this != NULL);
175108 : if (getVariant() != VARIANT_STMT)
175109 : {
175110 : printf ("Error in SgVariantStatement::error(): SgVariantStatement object has a %s variant \n",
175111 : Cxx_GrammarTerminalNames[getVariant()].name);
175112 : // printf ("Error in SgVariantStatement::error() \n");
175113 : ROSE_ABORT();
175114 : }
175115 :
175116 : ROSE_ASSERT (getVariant() == VARIANT_STMT);
175117 : return SgStatement::error();
175118 : }
175119 : #endif
175120 :
175121 :
175122 :
175123 : // End of memberFunctionString
175124 :
175125 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
175126 :
175127 0 : SgVariantStatement* isSgVariantStatement ( SgNode* inputDerivedClassPointer )
175128 : {
175129 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
175130 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
175131 : // So to fix this we return NULL directly when the input is NULL and avoid the
175132 : // dynamic_cast in this case. This is likely a performance improvement as well.
175133 : // return dynamic_cast<SgVariantStatement*>(inputDerivedClassPointer);
175134 : // Milind Chabbi (8/28/2013): isSgVariantStatement uses table-driven castability instead of c++ default dynamic_cast
175135 : // this improves the running time performance by 10-20%.
175136 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVariantStatement*>(inputDerivedClassPointer);
175137 0 : return IS_SgVariantStatement_FAST_MACRO(inputDerivedClassPointer);
175138 : }
175139 :
175140 : // DQ (11/8/2003): Added version of functions taking const pointer
175141 0 : const SgVariantStatement* isSgVariantStatement ( const SgNode* inputDerivedClassPointer )
175142 : {
175143 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
175144 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
175145 : // So to fix this we return NULL directly when the input is NULL and avoid the
175146 : // dynamic_cast in this case. This is likely a performance improvement as well.
175147 : // return dynamic_cast<const SgVariantStatement*>(inputDerivedClassPointer);
175148 : // Milind Chabbi (8/28/2013): isSgVariantStatement uses table-driven castability instead of c++ default dynamic_cast
175149 : // this improves the running time performance by 10-20%.
175150 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVariantStatement*>(inputDerivedClassPointer);
175151 0 : return IS_SgVariantStatement_FAST_MACRO(inputDerivedClassPointer);
175152 : }
175153 :
175154 :
175155 :
175156 : /* #line 175157 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175157 :
175158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
175159 :
175160 : /**
175161 : \brief Generated destructor
175162 :
175163 : This destructor is automatically generated (by ROSETTA). This destructor
175164 : only frees memory of data members associated with the parts of the current IR node which
175165 : are NOT traversed. Those data members that are part of a traversal can be freed using
175166 : a traversal (calling this destructor on all children in a post-order traversal). Such
175167 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
175168 :
175169 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
175170 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
175171 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
175172 :
175173 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
175174 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
175175 : pointers are not yet implemented to call delete on eash pointer in the container.
175176 : (This could be done by derivation from the STL containers to define containers that
175177 : automatically deleted their members.)
175178 :
175179 : */
175180 0 : SgVariantStatement::~SgVariantStatement () {
175181 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
175182 :
175183 :
175184 :
175185 : }
175186 :
175187 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
175188 0 : }
175189 :
175190 :
175191 : /* #line 175192 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175192 :
175193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
175194 :
175195 : // Generated constructor
175196 0 : SgVariantStatement::SgVariantStatement ( Sg_File_Info* startOfConstruct )
175197 0 : : SgStatement(startOfConstruct)
175198 : {
175199 : #ifdef DEBUG
175200 : // printf ("In SgVariantStatement::SgVariantStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
175201 : #endif
175202 : #if 0
175203 : // debugging information!
175204 : printf ("In SgVariantStatement::SgVariantStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
175205 : #endif
175206 :
175207 :
175208 :
175209 : #if 0
175210 : // DQ (7/30/2014): Call a virtual function.
175211 : std::string s = this->class_name();
175212 : #endif
175213 :
175214 : // Test the variant virtual function
175215 : // assert(VARIANT_STMT == variant());
175216 0 : assert(VARIANT_STMT == this->variant());
175217 0 : ROSE_ASSERT(VARIANT_STMT == (int)(this->variantT()));
175218 0 : post_construction_initialization();
175219 :
175220 : // Test the isSgVariantStatement() function since it has been problematic
175221 0 : assert(isSgVariantStatement(this) != NULL);
175222 0 : }
175223 :
175224 : // Generated constructor (all data members)
175225 :
175226 : /* #line 175227 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175227 :
175228 :
175229 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
175230 :
175231 :
175232 : // ********************************************************
175233 : // member functions common across all array grammar objects
175234 : // ********************************************************
175235 :
175236 :
175237 :
175238 : /* #line 175239 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175239 :
175240 :
175241 :
175242 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
175243 :
175244 : // ********************************************************
175245 : // member functions specific to each node in the grammar
175246 : // ********************************************************
175247 :
175248 :
175249 : /* #line 175250 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175250 :
175251 : // Start of memberFunctionString
175252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
175253 :
175254 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
175255 :
175256 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
175257 : const SgStatementPtrList &
175258 478 : SgForInitStatement::get_init_stmt () const
175259 : {
175260 478 : assert (this != NULL);
175261 478 : return p_init_stmt;
175262 : }
175263 :
175264 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
175265 : SgStatementPtrList &
175266 6093 : SgForInitStatement::get_init_stmt ()
175267 : {
175268 6093 : assert (this != NULL);
175269 :
175270 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
175271 : // As a rule only set_ access functions can set the isModified flag.
175272 : // set_isModified(true);
175273 :
175274 6093 : return p_init_stmt;
175275 : }
175276 :
175277 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
175278 :
175279 :
175280 : // End of memberFunctionString
175281 : // Start of memberFunctionString
175282 : /* #line 9961 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
175283 :
175284 :
175285 : void
175286 1938 : SgForInitStatement::post_construction_initialization()
175287 : {
175288 : #if 0
175289 : // DQ (1/12/13): This is code that can be helpful in debubbing subtle problems in astCopy and astDelete.
175290 : printf ("In SgForInitStatement::post_construction_initialization(): this = %p = %s \n",this,this->class_name().c_str());
175291 : #endif
175292 1938 : }
175293 :
175294 : void
175295 245 : SgForInitStatement::append_init_stmt(SgStatement * what)
175296 : {
175297 245 : get_init_stmt().push_back(what);
175298 245 : what->set_parent(this);
175299 245 : }
175300 :
175301 : void
175302 0 : SgForInitStatement::prepend_init_stmt(SgStatement * what)
175303 : {
175304 0 : get_init_stmt().insert(get_init_stmt().begin(), what);
175305 0 : what->set_parent(this);
175306 0 : }
175307 :
175308 : #if 0
175309 : void
175310 : SgForInitStatement::insert_init_stmt(const SgStatementPtrList::iterator& where, SgStatement * what)
175311 : {
175312 : #ifndef REMOVE_SET_PARENT_FUNCTION
175313 : what->set_parent(this);
175314 : #endif
175315 :
175316 : // DQ (6/24/2006): This is a structural operation so it is OK to set the parent
175317 : what->set_parent(this);
175318 :
175319 : get_init_stmt().insert(where,what);
175320 : }
175321 : #endif
175322 :
175323 : bool
175324 17 : SgForInitStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
175325 : {
175326 17 : return StatementListInsertChild( this, p_init_stmt, target, newstmt, true, extractBasicBlock, true);
175327 : }
175328 :
175329 : bool
175330 0 : SgForInitStatement::insert_child(SgStatement* target, SgStatement* newstmt, bool inFront, bool extractBasicBlock)
175331 : {
175332 0 : return StatementListInsertChild( this, p_init_stmt, target, newstmt, inFront, extractBasicBlock, false);
175333 : }
175334 :
175335 :
175336 :
175337 : // End of memberFunctionString
175338 : // Start of memberFunctionString
175339 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
175340 :
175341 : // *** COMMON CODE SECTION BEGINS HERE ***
175342 :
175343 : #if 0
175344 : int
175345 : SgForInitStatement::getVariant() const
175346 : {
175347 : // This function is used in ROSE while "variant()" is used in SAGE
175348 : assert(this != NULL);
175349 : return variant();
175350 : }
175351 : #endif
175352 :
175353 : // This function is used in ROSE in treeTraversal code
175354 : // eventually replaces getVariant() and variant()
175355 : // though after variant() has been removed for a while we will
175356 : // want to change the name of variantT() back to variant()
175357 : // (since the "T" was ment to stand for temporary).
175358 : // When this happens the variantT() will be depricated.
175359 : VariantT
175360 284866 : SgForInitStatement::variantT() const
175361 : {
175362 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
175363 284866 : ROSE_ASSERT(this != NULL);
175364 284866 : return V_SgForInitStatement;
175365 : }
175366 :
175367 : #if 0
175368 : int
175369 : SgForInitStatement::variant() const
175370 : {
175371 : // This function is used in SAGE
175372 : ROSE_ASSERT(this != NULL);
175373 : return FOR_INIT_STMT;
175374 : }
175375 : #endif
175376 :
175377 : ROSE_DLL_API const char*
175378 30 : SgForInitStatement::sage_class_name() const
175379 : {
175380 30 : ROSE_ASSERT(this != NULL);
175381 30 : return "SgForInitStatement";
175382 : }
175383 :
175384 : std::string
175385 786 : SgForInitStatement::class_name() const
175386 : {
175387 786 : ROSE_ASSERT(this != NULL);
175388 786 : return "SgForInitStatement";
175389 : }
175390 :
175391 : // DQ (11/26/2005): Support for visitor pattern mechanims
175392 : // (inferior to ROSE traversal mechanism, experimental).
175393 : void
175394 6160 : SgForInitStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
175395 : {
175396 6160 : ROSE_ASSERT(this != NULL);
175397 6160 : visitor.visit(this);
175398 6160 : }
175399 :
175400 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
175401 0 : void SgForInitStatement::accept (ROSE_VisitorPattern & visitor) {
175402 0 : ROSE_ASSERT(this != NULL);
175403 0 : visitor.visit(this);
175404 0 : }
175405 :
175406 : SgForInitStatement*
175407 0 : SgForInitStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
175408 : {
175409 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
175410 : // This function is currently only supported for the AST used the represent Binary executables.
175411 : if (0 /* isSgAsmNode(this) != NULL */)
175412 : {
175413 : // Support for regex specification.
175414 : std::string prefixCode = "REGEX:";
175415 : addNewAttribute(prefixCode + s,a);
175416 : }
175417 : #endif
175418 :
175419 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
175420 0 : return this;
175421 : }
175422 :
175423 : // *** COMMON CODE SECTION ENDS HERE ***
175424 :
175425 :
175426 : // End of memberFunctionString
175427 : // Start of memberFunctionString
175428 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
175429 :
175430 :
175431 : #if 0
175432 : //! Error checking support
175433 : /*! Verifies the following:
175434 : - working getVariant() member function
175435 : - calls base class's error() member function
175436 : Every class has one of these functions.
175437 : */
175438 : bool
175439 : SgForInitStatement::error()
175440 : {
175441 : // Put error checking here
175442 :
175443 : ROSE_ASSERT (this != NULL);
175444 : if (getVariant() != FOR_INIT_STMT)
175445 : {
175446 : printf ("Error in SgForInitStatement::error(): SgForInitStatement object has a %s variant \n",
175447 : Cxx_GrammarTerminalNames[getVariant()].name);
175448 : // printf ("Error in SgForInitStatement::error() \n");
175449 : ROSE_ABORT();
175450 : }
175451 :
175452 : ROSE_ASSERT (getVariant() == FOR_INIT_STMT);
175453 : return SgStatement::error();
175454 : }
175455 : #endif
175456 :
175457 :
175458 :
175459 : // End of memberFunctionString
175460 :
175461 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
175462 :
175463 2519 : SgForInitStatement* isSgForInitStatement ( SgNode* inputDerivedClassPointer )
175464 : {
175465 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
175466 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
175467 : // So to fix this we return NULL directly when the input is NULL and avoid the
175468 : // dynamic_cast in this case. This is likely a performance improvement as well.
175469 : // return dynamic_cast<SgForInitStatement*>(inputDerivedClassPointer);
175470 : // Milind Chabbi (8/28/2013): isSgForInitStatement uses table-driven castability instead of c++ default dynamic_cast
175471 : // this improves the running time performance by 10-20%.
175472 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgForInitStatement*>(inputDerivedClassPointer);
175473 2519 : return IS_SgForInitStatement_FAST_MACRO(inputDerivedClassPointer);
175474 : }
175475 :
175476 : // DQ (11/8/2003): Added version of functions taking const pointer
175477 0 : const SgForInitStatement* isSgForInitStatement ( const SgNode* inputDerivedClassPointer )
175478 : {
175479 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
175480 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
175481 : // So to fix this we return NULL directly when the input is NULL and avoid the
175482 : // dynamic_cast in this case. This is likely a performance improvement as well.
175483 : // return dynamic_cast<const SgForInitStatement*>(inputDerivedClassPointer);
175484 : // Milind Chabbi (8/28/2013): isSgForInitStatement uses table-driven castability instead of c++ default dynamic_cast
175485 : // this improves the running time performance by 10-20%.
175486 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgForInitStatement*>(inputDerivedClassPointer);
175487 0 : return IS_SgForInitStatement_FAST_MACRO(inputDerivedClassPointer);
175488 : }
175489 :
175490 :
175491 :
175492 : /* #line 175493 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175493 :
175494 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
175495 :
175496 : /**
175497 : \brief Generated destructor
175498 :
175499 : This destructor is automatically generated (by ROSETTA). This destructor
175500 : only frees memory of data members associated with the parts of the current IR node which
175501 : are NOT traversed. Those data members that are part of a traversal can be freed using
175502 : a traversal (calling this destructor on all children in a post-order traversal). Such
175503 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
175504 :
175505 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
175506 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
175507 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
175508 :
175509 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
175510 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
175511 : pointers are not yet implemented to call delete on eash pointer in the container.
175512 : (This could be done by derivation from the STL containers to define containers that
175513 : automatically deleted their members.)
175514 :
175515 : */
175516 2178 : SgForInitStatement::~SgForInitStatement () {
175517 1049 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
175518 :
175519 :
175520 :
175521 : }
175522 :
175523 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
175524 2098 : }
175525 :
175526 :
175527 : /* #line 175528 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175528 :
175529 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
175530 :
175531 : // Generated constructor
175532 4 : SgForInitStatement::SgForInitStatement ( Sg_File_Info* startOfConstruct )
175533 4 : : SgStatement(startOfConstruct)
175534 : {
175535 : #ifdef DEBUG
175536 : // printf ("In SgForInitStatement::SgForInitStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
175537 : #endif
175538 : #if 0
175539 : // debugging information!
175540 : printf ("In SgForInitStatement::SgForInitStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
175541 : #endif
175542 :
175543 :
175544 :
175545 : #if 0
175546 : // DQ (7/30/2014): Call a virtual function.
175547 : std::string s = this->class_name();
175548 : #endif
175549 :
175550 : // Test the variant virtual function
175551 : // assert(FOR_INIT_STMT == variant());
175552 4 : assert(FOR_INIT_STMT == this->variant());
175553 4 : ROSE_ASSERT(FOR_INIT_STMT == (int)(this->variantT()));
175554 4 : post_construction_initialization();
175555 :
175556 : // Test the isSgForInitStatement() function since it has been problematic
175557 4 : assert(isSgForInitStatement(this) != NULL);
175558 4 : }
175559 :
175560 : // Generated constructor (all data members)
175561 :
175562 : /* #line 175563 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175563 :
175564 :
175565 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
175566 :
175567 :
175568 : // ********************************************************
175569 : // member functions common across all array grammar objects
175570 : // ********************************************************
175571 :
175572 :
175573 :
175574 : /* #line 175575 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175575 :
175576 :
175577 :
175578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
175579 :
175580 : // ********************************************************
175581 : // member functions specific to each node in the grammar
175582 : // ********************************************************
175583 :
175584 :
175585 : /* #line 175586 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175586 :
175587 : // Start of memberFunctionString
175588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
175589 :
175590 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
175591 :
175592 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
175593 : const SgStatementPtrList &
175594 0 : SgCatchStatementSeq::get_catch_statement_seq () const
175595 : {
175596 0 : assert (this != NULL);
175597 0 : return p_catch_statement_seq;
175598 : }
175599 :
175600 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
175601 : SgStatementPtrList &
175602 2344 : SgCatchStatementSeq::get_catch_statement_seq ()
175603 : {
175604 2344 : assert (this != NULL);
175605 :
175606 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
175607 : // As a rule only set_ access functions can set the isModified flag.
175608 : // set_isModified(true);
175609 :
175610 2344 : return p_catch_statement_seq;
175611 : }
175612 :
175613 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
175614 :
175615 :
175616 : // End of memberFunctionString
175617 : // Start of memberFunctionString
175618 : /* #line 15708 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
175619 :
175620 :
175621 : // MS: C++98: handler (catch_statement in SAGE)
175622 : void
175623 514 : SgCatchStatementSeq::post_construction_initialization() {
175624 514 : SgStatementPtrList::iterator p = get_catch_statement_seq().begin();
175625 514 : for (p = get_catch_statement_seq().begin(); p != get_catch_statement_seq().end(); p++)
175626 : {
175627 0 : ROSE_ASSERT((*p) != NULL);
175628 0 : delete (*p);
175629 0 : (*p) = NULL;
175630 : }
175631 514 : }
175632 :
175633 : // MS: C++98: handler (catch_statement in SAGE)
175634 : void
175635 802 : SgCatchStatementSeq::append_catch_statement(SgStatement * what)
175636 : {
175637 802 : get_catch_statement_seq().push_back(what);
175638 802 : what->set_parent(this);
175639 802 : }
175640 :
175641 : // MS: C++98: handler (catch_statement in SAGE)
175642 : void
175643 0 : SgCatchStatementSeq::prepend_catch_statement(SgStatement * what)
175644 : {
175645 0 : get_catch_statement_seq().insert(get_catch_statement_seq().begin(), what);
175646 0 : what->set_parent(this);
175647 0 : }
175648 :
175649 : #if 0
175650 : // MS: C++98: handler (catch_statement in SAGE)
175651 : void
175652 : SgCatchStatementSeq::insert_catch_statement(const SgStatementPtrList::iterator& where, SgStatement * what)
175653 : {
175654 : #ifndef REMOVE_SET_PARENT_FUNCTION
175655 : what->set_parent(this);
175656 : #endif
175657 : get_catch_statement_seq().insert(where,what);
175658 : }
175659 : #endif
175660 :
175661 :
175662 :
175663 : // End of memberFunctionString
175664 : // Start of memberFunctionString
175665 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
175666 :
175667 : // *** COMMON CODE SECTION BEGINS HERE ***
175668 :
175669 : #if 0
175670 : int
175671 : SgCatchStatementSeq::getVariant() const
175672 : {
175673 : // This function is used in ROSE while "variant()" is used in SAGE
175674 : assert(this != NULL);
175675 : return variant();
175676 : }
175677 : #endif
175678 :
175679 : // This function is used in ROSE in treeTraversal code
175680 : // eventually replaces getVariant() and variant()
175681 : // though after variant() has been removed for a while we will
175682 : // want to change the name of variantT() back to variant()
175683 : // (since the "T" was ment to stand for temporary).
175684 : // When this happens the variantT() will be depricated.
175685 : VariantT
175686 185602 : SgCatchStatementSeq::variantT() const
175687 : {
175688 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
175689 185602 : ROSE_ASSERT(this != NULL);
175690 185602 : return V_SgCatchStatementSeq;
175691 : }
175692 :
175693 : #if 0
175694 : int
175695 : SgCatchStatementSeq::variant() const
175696 : {
175697 : // This function is used in SAGE
175698 : ROSE_ASSERT(this != NULL);
175699 : return CATCH_STATEMENT_SEQ;
175700 : }
175701 : #endif
175702 :
175703 : ROSE_DLL_API const char*
175704 12 : SgCatchStatementSeq::sage_class_name() const
175705 : {
175706 12 : ROSE_ASSERT(this != NULL);
175707 12 : return "SgCatchStatementSeq";
175708 : }
175709 :
175710 : std::string
175711 352 : SgCatchStatementSeq::class_name() const
175712 : {
175713 352 : ROSE_ASSERT(this != NULL);
175714 352 : return "SgCatchStatementSeq";
175715 : }
175716 :
175717 : // DQ (11/26/2005): Support for visitor pattern mechanims
175718 : // (inferior to ROSE traversal mechanism, experimental).
175719 : void
175720 7866 : SgCatchStatementSeq::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
175721 : {
175722 7866 : ROSE_ASSERT(this != NULL);
175723 7866 : visitor.visit(this);
175724 7866 : }
175725 :
175726 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
175727 0 : void SgCatchStatementSeq::accept (ROSE_VisitorPattern & visitor) {
175728 0 : ROSE_ASSERT(this != NULL);
175729 0 : visitor.visit(this);
175730 0 : }
175731 :
175732 : SgCatchStatementSeq*
175733 0 : SgCatchStatementSeq::addRegExpAttribute(std::string s, AstRegExAttribute* a)
175734 : {
175735 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
175736 : // This function is currently only supported for the AST used the represent Binary executables.
175737 : if (0 /* isSgAsmNode(this) != NULL */)
175738 : {
175739 : // Support for regex specification.
175740 : std::string prefixCode = "REGEX:";
175741 : addNewAttribute(prefixCode + s,a);
175742 : }
175743 : #endif
175744 :
175745 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
175746 0 : return this;
175747 : }
175748 :
175749 : // *** COMMON CODE SECTION ENDS HERE ***
175750 :
175751 :
175752 : // End of memberFunctionString
175753 : // Start of memberFunctionString
175754 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
175755 :
175756 :
175757 : #if 0
175758 : //! Error checking support
175759 : /*! Verifies the following:
175760 : - working getVariant() member function
175761 : - calls base class's error() member function
175762 : Every class has one of these functions.
175763 : */
175764 : bool
175765 : SgCatchStatementSeq::error()
175766 : {
175767 : // Put error checking here
175768 :
175769 : ROSE_ASSERT (this != NULL);
175770 : if (getVariant() != CATCH_STATEMENT_SEQ)
175771 : {
175772 : printf ("Error in SgCatchStatementSeq::error(): SgCatchStatementSeq object has a %s variant \n",
175773 : Cxx_GrammarTerminalNames[getVariant()].name);
175774 : // printf ("Error in SgCatchStatementSeq::error() \n");
175775 : ROSE_ABORT();
175776 : }
175777 :
175778 : ROSE_ASSERT (getVariant() == CATCH_STATEMENT_SEQ);
175779 : return SgStatement::error();
175780 : }
175781 : #endif
175782 :
175783 :
175784 :
175785 : // End of memberFunctionString
175786 :
175787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
175788 :
175789 514 : SgCatchStatementSeq* isSgCatchStatementSeq ( SgNode* inputDerivedClassPointer )
175790 : {
175791 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
175792 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
175793 : // So to fix this we return NULL directly when the input is NULL and avoid the
175794 : // dynamic_cast in this case. This is likely a performance improvement as well.
175795 : // return dynamic_cast<SgCatchStatementSeq*>(inputDerivedClassPointer);
175796 : // Milind Chabbi (8/28/2013): isSgCatchStatementSeq uses table-driven castability instead of c++ default dynamic_cast
175797 : // this improves the running time performance by 10-20%.
175798 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCatchStatementSeq*>(inputDerivedClassPointer);
175799 514 : return IS_SgCatchStatementSeq_FAST_MACRO(inputDerivedClassPointer);
175800 : }
175801 :
175802 : // DQ (11/8/2003): Added version of functions taking const pointer
175803 0 : const SgCatchStatementSeq* isSgCatchStatementSeq ( const SgNode* inputDerivedClassPointer )
175804 : {
175805 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
175806 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
175807 : // So to fix this we return NULL directly when the input is NULL and avoid the
175808 : // dynamic_cast in this case. This is likely a performance improvement as well.
175809 : // return dynamic_cast<const SgCatchStatementSeq*>(inputDerivedClassPointer);
175810 : // Milind Chabbi (8/28/2013): isSgCatchStatementSeq uses table-driven castability instead of c++ default dynamic_cast
175811 : // this improves the running time performance by 10-20%.
175812 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCatchStatementSeq*>(inputDerivedClassPointer);
175813 0 : return IS_SgCatchStatementSeq_FAST_MACRO(inputDerivedClassPointer);
175814 : }
175815 :
175816 :
175817 :
175818 : /* #line 175819 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175819 :
175820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
175821 :
175822 : /**
175823 : \brief Generated destructor
175824 :
175825 : This destructor is automatically generated (by ROSETTA). This destructor
175826 : only frees memory of data members associated with the parts of the current IR node which
175827 : are NOT traversed. Those data members that are part of a traversal can be freed using
175828 : a traversal (calling this destructor on all children in a post-order traversal). Such
175829 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
175830 :
175831 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
175832 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
175833 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
175834 :
175835 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
175836 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
175837 : pointers are not yet implemented to call delete on eash pointer in the container.
175838 : (This could be done by derivation from the STL containers to define containers that
175839 : automatically deleted their members.)
175840 :
175841 : */
175842 324 : SgCatchStatementSeq::~SgCatchStatementSeq () {
175843 108 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
175844 :
175845 :
175846 :
175847 : }
175848 :
175849 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
175850 216 : }
175851 :
175852 :
175853 : /* #line 175854 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175854 :
175855 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
175856 :
175857 : // Generated constructor
175858 0 : SgCatchStatementSeq::SgCatchStatementSeq ( Sg_File_Info* startOfConstruct )
175859 0 : : SgStatement(startOfConstruct)
175860 : {
175861 : #ifdef DEBUG
175862 : // printf ("In SgCatchStatementSeq::SgCatchStatementSeq (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
175863 : #endif
175864 : #if 0
175865 : // debugging information!
175866 : printf ("In SgCatchStatementSeq::SgCatchStatementSeq (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
175867 : #endif
175868 :
175869 :
175870 :
175871 : #if 0
175872 : // DQ (7/30/2014): Call a virtual function.
175873 : std::string s = this->class_name();
175874 : #endif
175875 :
175876 : // Test the variant virtual function
175877 : // assert(CATCH_STATEMENT_SEQ == variant());
175878 0 : assert(CATCH_STATEMENT_SEQ == this->variant());
175879 0 : ROSE_ASSERT(CATCH_STATEMENT_SEQ == (int)(this->variantT()));
175880 0 : post_construction_initialization();
175881 :
175882 : // Test the isSgCatchStatementSeq() function since it has been problematic
175883 0 : assert(isSgCatchStatementSeq(this) != NULL);
175884 0 : }
175885 :
175886 : // Generated constructor (all data members)
175887 :
175888 : /* #line 175889 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175889 :
175890 :
175891 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
175892 :
175893 :
175894 : // ********************************************************
175895 : // member functions common across all array grammar objects
175896 : // ********************************************************
175897 :
175898 :
175899 :
175900 : /* #line 175901 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175901 :
175902 :
175903 :
175904 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
175905 :
175906 : // ********************************************************
175907 : // member functions specific to each node in the grammar
175908 : // ********************************************************
175909 :
175910 :
175911 : /* #line 175912 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
175912 :
175913 : // Start of memberFunctionString
175914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
175915 :
175916 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
175917 :
175918 : SgProcessControlStatement::control_enum
175919 1 : SgProcessControlStatement::get_control_kind () const
175920 : {
175921 1 : ROSE_ASSERT (this != NULL);
175922 :
175923 : #if 0
175924 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
175925 : // used to trigger marking transformations for the token-based unparsing.
175926 : printf ("SgProcessControlStatement::get_control_kind = %p = %s \n",this,this->class_name().c_str());
175927 : #endif
175928 :
175929 1 : return p_control_kind;
175930 : }
175931 :
175932 : void
175933 1 : SgProcessControlStatement::set_control_kind ( SgProcessControlStatement::control_enum control_kind )
175934 : {
175935 1 : ROSE_ASSERT (this != NULL);
175936 :
175937 : #if 0
175938 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
175939 : // used to trigger marking transformations for the token-based unparsing.
175940 : printf ("SgProcessControlStatement::set_control_kind = %p = %s \n",this,this->class_name().c_str());
175941 : #endif
175942 :
175943 1 : set_isModified(true);
175944 :
175945 1 : p_control_kind = control_kind;
175946 1 : }
175947 :
175948 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
175949 :
175950 :
175951 : // End of memberFunctionString
175952 : // Start of memberFunctionString
175953 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
175954 :
175955 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
175956 :
175957 : SgExpression*
175958 1 : SgProcessControlStatement::get_code () const
175959 : {
175960 1 : ROSE_ASSERT (this != NULL);
175961 :
175962 : #if 0
175963 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
175964 : // used to trigger marking transformations for the token-based unparsing.
175965 : printf ("SgProcessControlStatement::get_code = %p = %s \n",this,this->class_name().c_str());
175966 : #endif
175967 :
175968 1 : return p_code;
175969 : }
175970 :
175971 : void
175972 0 : SgProcessControlStatement::set_code ( SgExpression* code )
175973 : {
175974 0 : ROSE_ASSERT (this != NULL);
175975 :
175976 : #if 0
175977 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
175978 : // used to trigger marking transformations for the token-based unparsing.
175979 : printf ("SgProcessControlStatement::set_code = %p = %s \n",this,this->class_name().c_str());
175980 : #endif
175981 :
175982 0 : set_isModified(true);
175983 :
175984 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
175985 : if (p_code != NULL && code != NULL && p_code != code)
175986 : {
175987 : printf ("Warning: code = %p overwriting valid pointer p_code = %p \n",code,p_code);
175988 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
175989 : printf ("Error fails assertion (p_code != NULL && code != NULL && p_code != code) is false\n");
175990 : ROSE_ASSERT(false);
175991 : #endif
175992 : }
175993 : #endif
175994 0 : p_code = code;
175995 0 : }
175996 :
175997 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
175998 :
175999 :
176000 : // End of memberFunctionString
176001 : // Start of memberFunctionString
176002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176003 :
176004 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176005 :
176006 : SgExpression*
176007 1 : SgProcessControlStatement::get_quiet () const
176008 : {
176009 1 : ROSE_ASSERT (this != NULL);
176010 :
176011 : #if 0
176012 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176013 : // used to trigger marking transformations for the token-based unparsing.
176014 : printf ("SgProcessControlStatement::get_quiet = %p = %s \n",this,this->class_name().c_str());
176015 : #endif
176016 :
176017 1 : return p_quiet;
176018 : }
176019 :
176020 : void
176021 0 : SgProcessControlStatement::set_quiet ( SgExpression* quiet )
176022 : {
176023 0 : ROSE_ASSERT (this != NULL);
176024 :
176025 : #if 0
176026 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176027 : // used to trigger marking transformations for the token-based unparsing.
176028 : printf ("SgProcessControlStatement::set_quiet = %p = %s \n",this,this->class_name().c_str());
176029 : #endif
176030 :
176031 0 : set_isModified(true);
176032 :
176033 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176034 : if (p_quiet != NULL && quiet != NULL && p_quiet != quiet)
176035 : {
176036 : printf ("Warning: quiet = %p overwriting valid pointer p_quiet = %p \n",quiet,p_quiet);
176037 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176038 : printf ("Error fails assertion (p_quiet != NULL && quiet != NULL && p_quiet != quiet) is false\n");
176039 : ROSE_ASSERT(false);
176040 : #endif
176041 : }
176042 : #endif
176043 0 : p_quiet = quiet;
176044 0 : }
176045 :
176046 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176047 :
176048 :
176049 : // End of memberFunctionString
176050 : // Start of memberFunctionString
176051 : /* #line 18288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
176052 :
176053 :
176054 : void
176055 1 : SgProcessControlStatement::post_construction_initialization()
176056 : {
176057 : // Set the parent of any input expression.
176058 1 : if (p_code != NULL)
176059 : {
176060 1 : p_code->set_parent(this);
176061 : }
176062 1 : }
176063 :
176064 :
176065 :
176066 : // End of memberFunctionString
176067 : // Start of memberFunctionString
176068 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
176069 :
176070 : // *** COMMON CODE SECTION BEGINS HERE ***
176071 :
176072 : #if 0
176073 : int
176074 : SgProcessControlStatement::getVariant() const
176075 : {
176076 : // This function is used in ROSE while "variant()" is used in SAGE
176077 : assert(this != NULL);
176078 : return variant();
176079 : }
176080 : #endif
176081 :
176082 : // This function is used in ROSE in treeTraversal code
176083 : // eventually replaces getVariant() and variant()
176084 : // though after variant() has been removed for a while we will
176085 : // want to change the name of variantT() back to variant()
176086 : // (since the "T" was ment to stand for temporary).
176087 : // When this happens the variantT() will be depricated.
176088 : VariantT
176089 711 : SgProcessControlStatement::variantT() const
176090 : {
176091 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
176092 711 : ROSE_ASSERT(this != NULL);
176093 711 : return V_SgProcessControlStatement;
176094 : }
176095 :
176096 : #if 0
176097 : int
176098 : SgProcessControlStatement::variant() const
176099 : {
176100 : // This function is used in SAGE
176101 : ROSE_ASSERT(this != NULL);
176102 : return PROCESS_CONTROL_STATEMENT;
176103 : }
176104 : #endif
176105 :
176106 : ROSE_DLL_API const char*
176107 2 : SgProcessControlStatement::sage_class_name() const
176108 : {
176109 2 : ROSE_ASSERT(this != NULL);
176110 2 : return "SgProcessControlStatement";
176111 : }
176112 :
176113 : std::string
176114 1 : SgProcessControlStatement::class_name() const
176115 : {
176116 1 : ROSE_ASSERT(this != NULL);
176117 1 : return "SgProcessControlStatement";
176118 : }
176119 :
176120 : // DQ (11/26/2005): Support for visitor pattern mechanims
176121 : // (inferior to ROSE traversal mechanism, experimental).
176122 : void
176123 0 : SgProcessControlStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
176124 : {
176125 0 : ROSE_ASSERT(this != NULL);
176126 0 : visitor.visit(this);
176127 0 : }
176128 :
176129 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
176130 0 : void SgProcessControlStatement::accept (ROSE_VisitorPattern & visitor) {
176131 0 : ROSE_ASSERT(this != NULL);
176132 0 : visitor.visit(this);
176133 0 : }
176134 :
176135 : SgProcessControlStatement*
176136 0 : SgProcessControlStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
176137 : {
176138 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
176139 : // This function is currently only supported for the AST used the represent Binary executables.
176140 : if (0 /* isSgAsmNode(this) != NULL */)
176141 : {
176142 : // Support for regex specification.
176143 : std::string prefixCode = "REGEX:";
176144 : addNewAttribute(prefixCode + s,a);
176145 : }
176146 : #endif
176147 :
176148 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
176149 0 : return this;
176150 : }
176151 :
176152 : // *** COMMON CODE SECTION ENDS HERE ***
176153 :
176154 :
176155 : // End of memberFunctionString
176156 : // Start of memberFunctionString
176157 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
176158 :
176159 :
176160 : #if 0
176161 : //! Error checking support
176162 : /*! Verifies the following:
176163 : - working getVariant() member function
176164 : - calls base class's error() member function
176165 : Every class has one of these functions.
176166 : */
176167 : bool
176168 : SgProcessControlStatement::error()
176169 : {
176170 : // Put error checking here
176171 :
176172 : ROSE_ASSERT (this != NULL);
176173 : if (getVariant() != PROCESS_CONTROL_STATEMENT)
176174 : {
176175 : printf ("Error in SgProcessControlStatement::error(): SgProcessControlStatement object has a %s variant \n",
176176 : Cxx_GrammarTerminalNames[getVariant()].name);
176177 : // printf ("Error in SgProcessControlStatement::error() \n");
176178 : ROSE_ABORT();
176179 : }
176180 :
176181 : ROSE_ASSERT (getVariant() == PROCESS_CONTROL_STATEMENT);
176182 : return SgStatement::error();
176183 : }
176184 : #endif
176185 :
176186 :
176187 :
176188 : // End of memberFunctionString
176189 :
176190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
176191 :
176192 3312 : SgProcessControlStatement* isSgProcessControlStatement ( SgNode* inputDerivedClassPointer )
176193 : {
176194 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
176195 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
176196 : // So to fix this we return NULL directly when the input is NULL and avoid the
176197 : // dynamic_cast in this case. This is likely a performance improvement as well.
176198 : // return dynamic_cast<SgProcessControlStatement*>(inputDerivedClassPointer);
176199 : // Milind Chabbi (8/28/2013): isSgProcessControlStatement uses table-driven castability instead of c++ default dynamic_cast
176200 : // this improves the running time performance by 10-20%.
176201 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgProcessControlStatement*>(inputDerivedClassPointer);
176202 3312 : return IS_SgProcessControlStatement_FAST_MACRO(inputDerivedClassPointer);
176203 : }
176204 :
176205 : // DQ (11/8/2003): Added version of functions taking const pointer
176206 0 : const SgProcessControlStatement* isSgProcessControlStatement ( const SgNode* inputDerivedClassPointer )
176207 : {
176208 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
176209 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
176210 : // So to fix this we return NULL directly when the input is NULL and avoid the
176211 : // dynamic_cast in this case. This is likely a performance improvement as well.
176212 : // return dynamic_cast<const SgProcessControlStatement*>(inputDerivedClassPointer);
176213 : // Milind Chabbi (8/28/2013): isSgProcessControlStatement uses table-driven castability instead of c++ default dynamic_cast
176214 : // this improves the running time performance by 10-20%.
176215 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgProcessControlStatement*>(inputDerivedClassPointer);
176216 0 : return IS_SgProcessControlStatement_FAST_MACRO(inputDerivedClassPointer);
176217 : }
176218 :
176219 :
176220 :
176221 : /* #line 176222 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176222 :
176223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
176224 :
176225 : /**
176226 : \brief Generated destructor
176227 :
176228 : This destructor is automatically generated (by ROSETTA). This destructor
176229 : only frees memory of data members associated with the parts of the current IR node which
176230 : are NOT traversed. Those data members that are part of a traversal can be freed using
176231 : a traversal (calling this destructor on all children in a post-order traversal). Such
176232 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
176233 :
176234 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
176235 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
176236 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
176237 :
176238 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
176239 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
176240 : pointers are not yet implemented to call delete on eash pointer in the container.
176241 : (This could be done by derivation from the STL containers to define containers that
176242 : automatically deleted their members.)
176243 :
176244 : */
176245 0 : SgProcessControlStatement::~SgProcessControlStatement () {
176246 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
176247 :
176248 :
176249 : // case: not a listType for control_kind
176250 0 : p_control_kind = SgProcessControlStatement::e_unknown; // non list case
176251 : // case: not a listType for code
176252 0 : p_code = NULL; // non list case
176253 : // case: not a listType for quiet
176254 0 : p_quiet = NULL; // non list case
176255 :
176256 : }
176257 :
176258 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
176259 0 : }
176260 :
176261 :
176262 : /* #line 176263 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176263 :
176264 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
176265 :
176266 : // Generated constructor
176267 0 : SgProcessControlStatement::SgProcessControlStatement ( Sg_File_Info* startOfConstruct, SgExpression* code )
176268 0 : : SgStatement(startOfConstruct)
176269 : {
176270 : #ifdef DEBUG
176271 : // printf ("In SgProcessControlStatement::SgProcessControlStatement (Sg_File_Info* startOfConstruct, SgExpression* code) sage_class_name() = %s \n",sage_class_name());
176272 : #endif
176273 : #if 0
176274 : // debugging information!
176275 : printf ("In SgProcessControlStatement::SgProcessControlStatement (Sg_File_Info* startOfConstruct, SgExpression* code): this = %p = %s \n",this,this->class_name().c_str());
176276 : #endif
176277 :
176278 0 : p_control_kind = SgProcessControlStatement::e_unknown;
176279 0 : p_code = code;
176280 0 : p_quiet = NULL;
176281 :
176282 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
176283 :
176284 : #if 0
176285 : // DQ (7/30/2014): Call a virtual function.
176286 : std::string s = this->class_name();
176287 : #endif
176288 :
176289 : // Test the variant virtual function
176290 : // assert(PROCESS_CONTROL_STATEMENT == variant());
176291 0 : assert(PROCESS_CONTROL_STATEMENT == this->variant());
176292 0 : ROSE_ASSERT(PROCESS_CONTROL_STATEMENT == (int)(this->variantT()));
176293 0 : post_construction_initialization();
176294 :
176295 : // Test the isSgProcessControlStatement() function since it has been problematic
176296 0 : assert(isSgProcessControlStatement(this) != NULL);
176297 0 : }
176298 :
176299 : // Generated constructor (all data members)
176300 :
176301 : /* #line 176302 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176302 :
176303 :
176304 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
176305 :
176306 :
176307 : // ********************************************************
176308 : // member functions common across all array grammar objects
176309 : // ********************************************************
176310 :
176311 :
176312 :
176313 : /* #line 176314 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176314 :
176315 :
176316 :
176317 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
176318 :
176319 : // ********************************************************
176320 : // member functions specific to each node in the grammar
176321 : // ********************************************************
176322 :
176323 :
176324 : /* #line 176325 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176325 :
176326 : // Start of memberFunctionString
176327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176328 :
176329 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176330 :
176331 : SgIOStatement::io_statement_enum
176332 0 : SgIOStatement::get_io_statement () const
176333 : {
176334 0 : ROSE_ASSERT (this != NULL);
176335 :
176336 : #if 0
176337 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176338 : // used to trigger marking transformations for the token-based unparsing.
176339 : printf ("SgIOStatement::get_io_statement = %p = %s \n",this,this->class_name().c_str());
176340 : #endif
176341 :
176342 0 : return p_io_statement;
176343 : }
176344 :
176345 : void
176346 7 : SgIOStatement::set_io_statement ( SgIOStatement::io_statement_enum io_statement )
176347 : {
176348 7 : ROSE_ASSERT (this != NULL);
176349 :
176350 : #if 0
176351 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176352 : // used to trigger marking transformations for the token-based unparsing.
176353 : printf ("SgIOStatement::set_io_statement = %p = %s \n",this,this->class_name().c_str());
176354 : #endif
176355 :
176356 7 : set_isModified(true);
176357 :
176358 7 : p_io_statement = io_statement;
176359 7 : }
176360 :
176361 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176362 :
176363 :
176364 : // End of memberFunctionString
176365 : // Start of memberFunctionString
176366 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176367 :
176368 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176369 :
176370 : SgExprListExp*
176371 62 : SgIOStatement::get_io_stmt_list () const
176372 : {
176373 62 : ROSE_ASSERT (this != NULL);
176374 :
176375 : #if 0
176376 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176377 : // used to trigger marking transformations for the token-based unparsing.
176378 : printf ("SgIOStatement::get_io_stmt_list = %p = %s \n",this,this->class_name().c_str());
176379 : #endif
176380 :
176381 62 : return p_io_stmt_list;
176382 : }
176383 :
176384 : void
176385 62 : SgIOStatement::set_io_stmt_list ( SgExprListExp* io_stmt_list )
176386 : {
176387 62 : ROSE_ASSERT (this != NULL);
176388 :
176389 : #if 0
176390 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176391 : // used to trigger marking transformations for the token-based unparsing.
176392 : printf ("SgIOStatement::set_io_stmt_list = %p = %s \n",this,this->class_name().c_str());
176393 : #endif
176394 :
176395 62 : set_isModified(true);
176396 :
176397 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176398 : if (p_io_stmt_list != NULL && io_stmt_list != NULL && p_io_stmt_list != io_stmt_list)
176399 : {
176400 : printf ("Warning: io_stmt_list = %p overwriting valid pointer p_io_stmt_list = %p \n",io_stmt_list,p_io_stmt_list);
176401 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176402 : printf ("Error fails assertion (p_io_stmt_list != NULL && io_stmt_list != NULL && p_io_stmt_list != io_stmt_list) is false\n");
176403 : ROSE_ASSERT(false);
176404 : #endif
176405 : }
176406 : #endif
176407 62 : p_io_stmt_list = io_stmt_list;
176408 62 : }
176409 :
176410 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176411 :
176412 :
176413 : // End of memberFunctionString
176414 : // Start of memberFunctionString
176415 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176416 :
176417 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176418 :
176419 : SgExpression*
176420 14 : SgIOStatement::get_unit () const
176421 : {
176422 14 : ROSE_ASSERT (this != NULL);
176423 :
176424 : #if 0
176425 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176426 : // used to trigger marking transformations for the token-based unparsing.
176427 : printf ("SgIOStatement::get_unit = %p = %s \n",this,this->class_name().c_str());
176428 : #endif
176429 :
176430 14 : return p_unit;
176431 : }
176432 :
176433 : void
176434 7 : SgIOStatement::set_unit ( SgExpression* unit )
176435 : {
176436 7 : ROSE_ASSERT (this != NULL);
176437 :
176438 : #if 0
176439 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176440 : // used to trigger marking transformations for the token-based unparsing.
176441 : printf ("SgIOStatement::set_unit = %p = %s \n",this,this->class_name().c_str());
176442 : #endif
176443 :
176444 7 : set_isModified(true);
176445 :
176446 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176447 : if (p_unit != NULL && unit != NULL && p_unit != unit)
176448 : {
176449 : printf ("Warning: unit = %p overwriting valid pointer p_unit = %p \n",unit,p_unit);
176450 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176451 : printf ("Error fails assertion (p_unit != NULL && unit != NULL && p_unit != unit) is false\n");
176452 : ROSE_ASSERT(false);
176453 : #endif
176454 : }
176455 : #endif
176456 7 : p_unit = unit;
176457 7 : }
176458 :
176459 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176460 :
176461 :
176462 : // End of memberFunctionString
176463 : // Start of memberFunctionString
176464 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176465 :
176466 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176467 :
176468 : SgExpression*
176469 7 : SgIOStatement::get_iostat () const
176470 : {
176471 7 : ROSE_ASSERT (this != NULL);
176472 :
176473 : #if 0
176474 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176475 : // used to trigger marking transformations for the token-based unparsing.
176476 : printf ("SgIOStatement::get_iostat = %p = %s \n",this,this->class_name().c_str());
176477 : #endif
176478 :
176479 7 : return p_iostat;
176480 : }
176481 :
176482 : void
176483 0 : SgIOStatement::set_iostat ( SgExpression* iostat )
176484 : {
176485 0 : ROSE_ASSERT (this != NULL);
176486 :
176487 : #if 0
176488 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176489 : // used to trigger marking transformations for the token-based unparsing.
176490 : printf ("SgIOStatement::set_iostat = %p = %s \n",this,this->class_name().c_str());
176491 : #endif
176492 :
176493 0 : set_isModified(true);
176494 :
176495 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176496 : if (p_iostat != NULL && iostat != NULL && p_iostat != iostat)
176497 : {
176498 : printf ("Warning: iostat = %p overwriting valid pointer p_iostat = %p \n",iostat,p_iostat);
176499 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176500 : printf ("Error fails assertion (p_iostat != NULL && iostat != NULL && p_iostat != iostat) is false\n");
176501 : ROSE_ASSERT(false);
176502 : #endif
176503 : }
176504 : #endif
176505 0 : p_iostat = iostat;
176506 0 : }
176507 :
176508 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176509 :
176510 :
176511 : // End of memberFunctionString
176512 : // Start of memberFunctionString
176513 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176514 :
176515 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176516 :
176517 : SgExpression*
176518 7 : SgIOStatement::get_err () const
176519 : {
176520 7 : ROSE_ASSERT (this != NULL);
176521 :
176522 : #if 0
176523 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176524 : // used to trigger marking transformations for the token-based unparsing.
176525 : printf ("SgIOStatement::get_err = %p = %s \n",this,this->class_name().c_str());
176526 : #endif
176527 :
176528 7 : return p_err;
176529 : }
176530 :
176531 : void
176532 0 : SgIOStatement::set_err ( SgExpression* err )
176533 : {
176534 0 : ROSE_ASSERT (this != NULL);
176535 :
176536 : #if 0
176537 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176538 : // used to trigger marking transformations for the token-based unparsing.
176539 : printf ("SgIOStatement::set_err = %p = %s \n",this,this->class_name().c_str());
176540 : #endif
176541 :
176542 0 : set_isModified(true);
176543 :
176544 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176545 : if (p_err != NULL && err != NULL && p_err != err)
176546 : {
176547 : printf ("Warning: err = %p overwriting valid pointer p_err = %p \n",err,p_err);
176548 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176549 : printf ("Error fails assertion (p_err != NULL && err != NULL && p_err != err) is false\n");
176550 : ROSE_ASSERT(false);
176551 : #endif
176552 : }
176553 : #endif
176554 0 : p_err = err;
176555 0 : }
176556 :
176557 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176558 :
176559 :
176560 : // End of memberFunctionString
176561 : // Start of memberFunctionString
176562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176563 :
176564 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176565 :
176566 : SgExpression*
176567 7 : SgIOStatement::get_iomsg () const
176568 : {
176569 7 : ROSE_ASSERT (this != NULL);
176570 :
176571 : #if 0
176572 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176573 : // used to trigger marking transformations for the token-based unparsing.
176574 : printf ("SgIOStatement::get_iomsg = %p = %s \n",this,this->class_name().c_str());
176575 : #endif
176576 :
176577 7 : return p_iomsg;
176578 : }
176579 :
176580 : void
176581 0 : SgIOStatement::set_iomsg ( SgExpression* iomsg )
176582 : {
176583 0 : ROSE_ASSERT (this != NULL);
176584 :
176585 : #if 0
176586 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176587 : // used to trigger marking transformations for the token-based unparsing.
176588 : printf ("SgIOStatement::set_iomsg = %p = %s \n",this,this->class_name().c_str());
176589 : #endif
176590 :
176591 0 : set_isModified(true);
176592 :
176593 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176594 : if (p_iomsg != NULL && iomsg != NULL && p_iomsg != iomsg)
176595 : {
176596 : printf ("Warning: iomsg = %p overwriting valid pointer p_iomsg = %p \n",iomsg,p_iomsg);
176597 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176598 : printf ("Error fails assertion (p_iomsg != NULL && iomsg != NULL && p_iomsg != iomsg) is false\n");
176599 : ROSE_ASSERT(false);
176600 : #endif
176601 : }
176602 : #endif
176603 0 : p_iomsg = iomsg;
176604 0 : }
176605 :
176606 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176607 :
176608 :
176609 : // End of memberFunctionString
176610 : // Start of memberFunctionString
176611 : /* #line 18361 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
176612 :
176613 :
176614 : void
176615 62 : SgIOStatement::post_construction_initialization()
176616 62 : {}
176617 :
176618 :
176619 :
176620 : // End of memberFunctionString
176621 : // Start of memberFunctionString
176622 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
176623 :
176624 : // *** COMMON CODE SECTION BEGINS HERE ***
176625 :
176626 : #if 0
176627 : int
176628 : SgIOStatement::getVariant() const
176629 : {
176630 : // This function is used in ROSE while "variant()" is used in SAGE
176631 : assert(this != NULL);
176632 : return variant();
176633 : }
176634 : #endif
176635 :
176636 : // This function is used in ROSE in treeTraversal code
176637 : // eventually replaces getVariant() and variant()
176638 : // though after variant() has been removed for a while we will
176639 : // want to change the name of variantT() back to variant()
176640 : // (since the "T" was ment to stand for temporary).
176641 : // When this happens the variantT() will be depricated.
176642 : VariantT
176643 186 : SgIOStatement::variantT() const
176644 : {
176645 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
176646 186 : ROSE_ASSERT(this != NULL);
176647 186 : return V_SgIOStatement;
176648 : }
176649 :
176650 : #if 0
176651 : int
176652 : SgIOStatement::variant() const
176653 : {
176654 : // This function is used in SAGE
176655 : ROSE_ASSERT(this != NULL);
176656 : return IO_STATEMENT;
176657 : }
176658 : #endif
176659 :
176660 : ROSE_DLL_API const char*
176661 0 : SgIOStatement::sage_class_name() const
176662 : {
176663 0 : ROSE_ASSERT(this != NULL);
176664 0 : return "SgIOStatement";
176665 : }
176666 :
176667 : std::string
176668 0 : SgIOStatement::class_name() const
176669 : {
176670 0 : ROSE_ASSERT(this != NULL);
176671 0 : return "SgIOStatement";
176672 : }
176673 :
176674 : // DQ (11/26/2005): Support for visitor pattern mechanims
176675 : // (inferior to ROSE traversal mechanism, experimental).
176676 : void
176677 0 : SgIOStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
176678 : {
176679 0 : ROSE_ASSERT(this != NULL);
176680 0 : visitor.visit(this);
176681 0 : }
176682 :
176683 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
176684 0 : void SgIOStatement::accept (ROSE_VisitorPattern & visitor) {
176685 0 : ROSE_ASSERT(this != NULL);
176686 0 : visitor.visit(this);
176687 0 : }
176688 :
176689 : SgIOStatement*
176690 0 : SgIOStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
176691 : {
176692 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
176693 : // This function is currently only supported for the AST used the represent Binary executables.
176694 : if (0 /* isSgAsmNode(this) != NULL */)
176695 : {
176696 : // Support for regex specification.
176697 : std::string prefixCode = "REGEX:";
176698 : addNewAttribute(prefixCode + s,a);
176699 : }
176700 : #endif
176701 :
176702 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
176703 0 : return this;
176704 : }
176705 :
176706 : // *** COMMON CODE SECTION ENDS HERE ***
176707 :
176708 :
176709 : // End of memberFunctionString
176710 : // Start of memberFunctionString
176711 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
176712 :
176713 :
176714 : #if 0
176715 : //! Error checking support
176716 : /*! Verifies the following:
176717 : - working getVariant() member function
176718 : - calls base class's error() member function
176719 : Every class has one of these functions.
176720 : */
176721 : bool
176722 : SgIOStatement::error()
176723 : {
176724 : // Put error checking here
176725 :
176726 : ROSE_ASSERT (this != NULL);
176727 : if (getVariant() != IO_STATEMENT)
176728 : {
176729 : printf ("Error in SgIOStatement::error(): SgIOStatement object has a %s variant \n",
176730 : Cxx_GrammarTerminalNames[getVariant()].name);
176731 : // printf ("Error in SgIOStatement::error() \n");
176732 : ROSE_ABORT();
176733 : }
176734 :
176735 : ROSE_ASSERT (getVariant() == IO_STATEMENT);
176736 : return SgStatement::error();
176737 : }
176738 : #endif
176739 :
176740 :
176741 :
176742 : // End of memberFunctionString
176743 :
176744 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
176745 :
176746 69 : SgIOStatement* isSgIOStatement ( SgNode* inputDerivedClassPointer )
176747 : {
176748 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
176749 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
176750 : // So to fix this we return NULL directly when the input is NULL and avoid the
176751 : // dynamic_cast in this case. This is likely a performance improvement as well.
176752 : // return dynamic_cast<SgIOStatement*>(inputDerivedClassPointer);
176753 : // Milind Chabbi (8/28/2013): isSgIOStatement uses table-driven castability instead of c++ default dynamic_cast
176754 : // this improves the running time performance by 10-20%.
176755 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIOStatement*>(inputDerivedClassPointer);
176756 69 : return IS_SgIOStatement_FAST_MACRO(inputDerivedClassPointer);
176757 : }
176758 :
176759 : // DQ (11/8/2003): Added version of functions taking const pointer
176760 0 : const SgIOStatement* isSgIOStatement ( const SgNode* inputDerivedClassPointer )
176761 : {
176762 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
176763 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
176764 : // So to fix this we return NULL directly when the input is NULL and avoid the
176765 : // dynamic_cast in this case. This is likely a performance improvement as well.
176766 : // return dynamic_cast<const SgIOStatement*>(inputDerivedClassPointer);
176767 : // Milind Chabbi (8/28/2013): isSgIOStatement uses table-driven castability instead of c++ default dynamic_cast
176768 : // this improves the running time performance by 10-20%.
176769 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIOStatement*>(inputDerivedClassPointer);
176770 0 : return IS_SgIOStatement_FAST_MACRO(inputDerivedClassPointer);
176771 : }
176772 :
176773 :
176774 :
176775 : /* #line 176776 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176776 :
176777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
176778 :
176779 : /**
176780 : \brief Generated destructor
176781 :
176782 : This destructor is automatically generated (by ROSETTA). This destructor
176783 : only frees memory of data members associated with the parts of the current IR node which
176784 : are NOT traversed. Those data members that are part of a traversal can be freed using
176785 : a traversal (calling this destructor on all children in a post-order traversal). Such
176786 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
176787 :
176788 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
176789 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
176790 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
176791 :
176792 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
176793 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
176794 : pointers are not yet implemented to call delete on eash pointer in the container.
176795 : (This could be done by derivation from the STL containers to define containers that
176796 : automatically deleted their members.)
176797 :
176798 : */
176799 1 : SgIOStatement::~SgIOStatement () {
176800 1 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
176801 :
176802 :
176803 : // case: not a listType for io_statement
176804 1 : p_io_statement = SgIOStatement::e_unknown; // non list case
176805 : // case: not a listType for io_stmt_list
176806 1 : p_io_stmt_list = NULL; // non list case
176807 : // case: not a listType for unit
176808 1 : p_unit = NULL; // non list case
176809 : // case: not a listType for iostat
176810 1 : p_iostat = NULL; // non list case
176811 : // case: not a listType for err
176812 1 : p_err = NULL; // non list case
176813 : // case: not a listType for iomsg
176814 1 : p_iomsg = NULL; // non list case
176815 :
176816 : }
176817 :
176818 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
176819 1 : }
176820 :
176821 :
176822 : /* #line 176823 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176823 :
176824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
176825 :
176826 : // Generated constructor
176827 0 : SgIOStatement::SgIOStatement ( Sg_File_Info* startOfConstruct )
176828 0 : : SgStatement(startOfConstruct)
176829 : {
176830 : #ifdef DEBUG
176831 : // printf ("In SgIOStatement::SgIOStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
176832 : #endif
176833 : #if 0
176834 : // debugging information!
176835 : printf ("In SgIOStatement::SgIOStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
176836 : #endif
176837 :
176838 0 : p_io_statement = SgIOStatement::e_unknown;
176839 0 : p_io_stmt_list = NULL;
176840 0 : p_unit = NULL;
176841 0 : p_iostat = NULL;
176842 0 : p_err = NULL;
176843 0 : p_iomsg = NULL;
176844 :
176845 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
176846 :
176847 : #if 0
176848 : // DQ (7/30/2014): Call a virtual function.
176849 : std::string s = this->class_name();
176850 : #endif
176851 :
176852 : // Test the variant virtual function
176853 : // assert(IO_STATEMENT == variant());
176854 0 : assert(IO_STATEMENT == this->variant());
176855 0 : ROSE_ASSERT(IO_STATEMENT == (int)(this->variantT()));
176856 0 : post_construction_initialization();
176857 :
176858 : // Test the isSgIOStatement() function since it has been problematic
176859 0 : assert(isSgIOStatement(this) != NULL);
176860 0 : }
176861 :
176862 : // Generated constructor (all data members)
176863 :
176864 : /* #line 176865 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176865 :
176866 :
176867 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
176868 :
176869 :
176870 : // ********************************************************
176871 : // member functions common across all array grammar objects
176872 : // ********************************************************
176873 :
176874 :
176875 :
176876 : /* #line 176877 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176877 :
176878 :
176879 :
176880 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
176881 :
176882 : // ********************************************************
176883 : // member functions specific to each node in the grammar
176884 : // ********************************************************
176885 :
176886 :
176887 : /* #line 176888 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
176888 :
176889 : // Start of memberFunctionString
176890 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
176891 :
176892 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
176893 :
176894 : SgExpression*
176895 55 : SgPrintStatement::get_format () const
176896 : {
176897 55 : ROSE_ASSERT (this != NULL);
176898 :
176899 : #if 0
176900 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176901 : // used to trigger marking transformations for the token-based unparsing.
176902 : printf ("SgPrintStatement::get_format = %p = %s \n",this,this->class_name().c_str());
176903 : #endif
176904 :
176905 55 : return p_format;
176906 : }
176907 :
176908 : void
176909 55 : SgPrintStatement::set_format ( SgExpression* format )
176910 : {
176911 55 : ROSE_ASSERT (this != NULL);
176912 :
176913 : #if 0
176914 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
176915 : // used to trigger marking transformations for the token-based unparsing.
176916 : printf ("SgPrintStatement::set_format = %p = %s \n",this,this->class_name().c_str());
176917 : #endif
176918 :
176919 55 : set_isModified(true);
176920 :
176921 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
176922 : if (p_format != NULL && format != NULL && p_format != format)
176923 : {
176924 : printf ("Warning: format = %p overwriting valid pointer p_format = %p \n",format,p_format);
176925 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
176926 : printf ("Error fails assertion (p_format != NULL && format != NULL && p_format != format) is false\n");
176927 : ROSE_ASSERT(false);
176928 : #endif
176929 : }
176930 : #endif
176931 55 : p_format = format;
176932 55 : }
176933 :
176934 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
176935 :
176936 :
176937 : // End of memberFunctionString
176938 : // Start of memberFunctionString
176939 : /* #line 18369 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
176940 :
176941 :
176942 : void
176943 55 : SgPrintStatement::post_construction_initialization()
176944 55 : {}
176945 :
176946 :
176947 :
176948 : // End of memberFunctionString
176949 : // Start of memberFunctionString
176950 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
176951 :
176952 : // *** COMMON CODE SECTION BEGINS HERE ***
176953 :
176954 : #if 0
176955 : int
176956 : SgPrintStatement::getVariant() const
176957 : {
176958 : // This function is used in ROSE while "variant()" is used in SAGE
176959 : assert(this != NULL);
176960 : return variant();
176961 : }
176962 : #endif
176963 :
176964 : // This function is used in ROSE in treeTraversal code
176965 : // eventually replaces getVariant() and variant()
176966 : // though after variant() has been removed for a while we will
176967 : // want to change the name of variantT() back to variant()
176968 : // (since the "T" was ment to stand for temporary).
176969 : // When this happens the variantT() will be depricated.
176970 : VariantT
176971 39664 : SgPrintStatement::variantT() const
176972 : {
176973 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
176974 39664 : ROSE_ASSERT(this != NULL);
176975 39664 : return V_SgPrintStatement;
176976 : }
176977 :
176978 : #if 0
176979 : int
176980 : SgPrintStatement::variant() const
176981 : {
176982 : // This function is used in SAGE
176983 : ROSE_ASSERT(this != NULL);
176984 : return PRINT_STATEMENT;
176985 : }
176986 : #endif
176987 :
176988 : ROSE_DLL_API const char*
176989 110 : SgPrintStatement::sage_class_name() const
176990 : {
176991 110 : ROSE_ASSERT(this != NULL);
176992 110 : return "SgPrintStatement";
176993 : }
176994 :
176995 : std::string
176996 54 : SgPrintStatement::class_name() const
176997 : {
176998 54 : ROSE_ASSERT(this != NULL);
176999 54 : return "SgPrintStatement";
177000 : }
177001 :
177002 : // DQ (11/26/2005): Support for visitor pattern mechanims
177003 : // (inferior to ROSE traversal mechanism, experimental).
177004 : void
177005 0 : SgPrintStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
177006 : {
177007 0 : ROSE_ASSERT(this != NULL);
177008 0 : visitor.visit(this);
177009 0 : }
177010 :
177011 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
177012 0 : void SgPrintStatement::accept (ROSE_VisitorPattern & visitor) {
177013 0 : ROSE_ASSERT(this != NULL);
177014 0 : visitor.visit(this);
177015 0 : }
177016 :
177017 : SgPrintStatement*
177018 0 : SgPrintStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
177019 : {
177020 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
177021 : // This function is currently only supported for the AST used the represent Binary executables.
177022 : if (0 /* isSgAsmNode(this) != NULL */)
177023 : {
177024 : // Support for regex specification.
177025 : std::string prefixCode = "REGEX:";
177026 : addNewAttribute(prefixCode + s,a);
177027 : }
177028 : #endif
177029 :
177030 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
177031 0 : return this;
177032 : }
177033 :
177034 : // *** COMMON CODE SECTION ENDS HERE ***
177035 :
177036 :
177037 : // End of memberFunctionString
177038 : // Start of memberFunctionString
177039 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
177040 :
177041 :
177042 : #if 0
177043 : //! Error checking support
177044 : /*! Verifies the following:
177045 : - working getVariant() member function
177046 : - calls base class's error() member function
177047 : Every class has one of these functions.
177048 : */
177049 : bool
177050 : SgPrintStatement::error()
177051 : {
177052 : // Put error checking here
177053 :
177054 : ROSE_ASSERT (this != NULL);
177055 : if (getVariant() != PRINT_STATEMENT)
177056 : {
177057 : printf ("Error in SgPrintStatement::error(): SgPrintStatement object has a %s variant \n",
177058 : Cxx_GrammarTerminalNames[getVariant()].name);
177059 : // printf ("Error in SgPrintStatement::error() \n");
177060 : ROSE_ABORT();
177061 : }
177062 :
177063 : ROSE_ASSERT (getVariant() == PRINT_STATEMENT);
177064 : return SgIOStatement::error();
177065 : }
177066 : #endif
177067 :
177068 :
177069 :
177070 : // End of memberFunctionString
177071 :
177072 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
177073 :
177074 110 : SgPrintStatement* isSgPrintStatement ( SgNode* inputDerivedClassPointer )
177075 : {
177076 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
177077 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
177078 : // So to fix this we return NULL directly when the input is NULL and avoid the
177079 : // dynamic_cast in this case. This is likely a performance improvement as well.
177080 : // return dynamic_cast<SgPrintStatement*>(inputDerivedClassPointer);
177081 : // Milind Chabbi (8/28/2013): isSgPrintStatement uses table-driven castability instead of c++ default dynamic_cast
177082 : // this improves the running time performance by 10-20%.
177083 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPrintStatement*>(inputDerivedClassPointer);
177084 110 : return IS_SgPrintStatement_FAST_MACRO(inputDerivedClassPointer);
177085 : }
177086 :
177087 : // DQ (11/8/2003): Added version of functions taking const pointer
177088 0 : const SgPrintStatement* isSgPrintStatement ( const SgNode* inputDerivedClassPointer )
177089 : {
177090 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
177091 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
177092 : // So to fix this we return NULL directly when the input is NULL and avoid the
177093 : // dynamic_cast in this case. This is likely a performance improvement as well.
177094 : // return dynamic_cast<const SgPrintStatement*>(inputDerivedClassPointer);
177095 : // Milind Chabbi (8/28/2013): isSgPrintStatement uses table-driven castability instead of c++ default dynamic_cast
177096 : // this improves the running time performance by 10-20%.
177097 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPrintStatement*>(inputDerivedClassPointer);
177098 0 : return IS_SgPrintStatement_FAST_MACRO(inputDerivedClassPointer);
177099 : }
177100 :
177101 :
177102 :
177103 : /* #line 177104 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
177104 :
177105 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
177106 :
177107 : /**
177108 : \brief Generated destructor
177109 :
177110 : This destructor is automatically generated (by ROSETTA). This destructor
177111 : only frees memory of data members associated with the parts of the current IR node which
177112 : are NOT traversed. Those data members that are part of a traversal can be freed using
177113 : a traversal (calling this destructor on all children in a post-order traversal). Such
177114 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
177115 :
177116 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
177117 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
177118 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
177119 :
177120 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
177121 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
177122 : pointers are not yet implemented to call delete on eash pointer in the container.
177123 : (This could be done by derivation from the STL containers to define containers that
177124 : automatically deleted their members.)
177125 :
177126 : */
177127 2 : SgPrintStatement::~SgPrintStatement () {
177128 1 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
177129 :
177130 :
177131 : // case: not a listType for format
177132 1 : p_format = NULL; // non list case
177133 :
177134 : }
177135 :
177136 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
177137 2 : }
177138 :
177139 :
177140 : /* #line 177141 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
177141 :
177142 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
177143 :
177144 : // Generated constructor
177145 0 : SgPrintStatement::SgPrintStatement ( Sg_File_Info* startOfConstruct )
177146 0 : : SgIOStatement(startOfConstruct)
177147 : {
177148 : #ifdef DEBUG
177149 : // printf ("In SgPrintStatement::SgPrintStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
177150 : #endif
177151 : #if 0
177152 : // debugging information!
177153 : printf ("In SgPrintStatement::SgPrintStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
177154 : #endif
177155 :
177156 0 : p_format = NULL;
177157 :
177158 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
177159 :
177160 : #if 0
177161 : // DQ (7/30/2014): Call a virtual function.
177162 : std::string s = this->class_name();
177163 : #endif
177164 :
177165 : // Test the variant virtual function
177166 : // assert(PRINT_STATEMENT == variant());
177167 0 : assert(PRINT_STATEMENT == this->variant());
177168 0 : ROSE_ASSERT(PRINT_STATEMENT == (int)(this->variantT()));
177169 0 : post_construction_initialization();
177170 :
177171 : // Test the isSgPrintStatement() function since it has been problematic
177172 0 : assert(isSgPrintStatement(this) != NULL);
177173 0 : }
177174 :
177175 : // Generated constructor (all data members)
177176 :
177177 : /* #line 177178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
177178 :
177179 :
177180 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
177181 :
177182 :
177183 : // ********************************************************
177184 : // member functions common across all array grammar objects
177185 : // ********************************************************
177186 :
177187 :
177188 :
177189 : /* #line 177190 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
177190 :
177191 :
177192 :
177193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
177194 :
177195 : // ********************************************************
177196 : // member functions specific to each node in the grammar
177197 : // ********************************************************
177198 :
177199 :
177200 : /* #line 177201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
177201 :
177202 : // Start of memberFunctionString
177203 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177204 :
177205 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177206 :
177207 : SgExpression*
177208 0 : SgReadStatement::get_format () const
177209 : {
177210 0 : ROSE_ASSERT (this != NULL);
177211 :
177212 : #if 0
177213 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177214 : // used to trigger marking transformations for the token-based unparsing.
177215 : printf ("SgReadStatement::get_format = %p = %s \n",this,this->class_name().c_str());
177216 : #endif
177217 :
177218 0 : return p_format;
177219 : }
177220 :
177221 : void
177222 0 : SgReadStatement::set_format ( SgExpression* format )
177223 : {
177224 0 : ROSE_ASSERT (this != NULL);
177225 :
177226 : #if 0
177227 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177228 : // used to trigger marking transformations for the token-based unparsing.
177229 : printf ("SgReadStatement::set_format = %p = %s \n",this,this->class_name().c_str());
177230 : #endif
177231 :
177232 0 : set_isModified(true);
177233 :
177234 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177235 : if (p_format != NULL && format != NULL && p_format != format)
177236 : {
177237 : printf ("Warning: format = %p overwriting valid pointer p_format = %p \n",format,p_format);
177238 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177239 : printf ("Error fails assertion (p_format != NULL && format != NULL && p_format != format) is false\n");
177240 : ROSE_ASSERT(false);
177241 : #endif
177242 : }
177243 : #endif
177244 0 : p_format = format;
177245 0 : }
177246 :
177247 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177248 :
177249 :
177250 : // End of memberFunctionString
177251 : // Start of memberFunctionString
177252 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177253 :
177254 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177255 :
177256 : SgExpression*
177257 0 : SgReadStatement::get_namelist () const
177258 : {
177259 0 : ROSE_ASSERT (this != NULL);
177260 :
177261 : #if 0
177262 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177263 : // used to trigger marking transformations for the token-based unparsing.
177264 : printf ("SgReadStatement::get_namelist = %p = %s \n",this,this->class_name().c_str());
177265 : #endif
177266 :
177267 0 : return p_namelist;
177268 : }
177269 :
177270 : void
177271 0 : SgReadStatement::set_namelist ( SgExpression* namelist )
177272 : {
177273 0 : ROSE_ASSERT (this != NULL);
177274 :
177275 : #if 0
177276 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177277 : // used to trigger marking transformations for the token-based unparsing.
177278 : printf ("SgReadStatement::set_namelist = %p = %s \n",this,this->class_name().c_str());
177279 : #endif
177280 :
177281 0 : set_isModified(true);
177282 :
177283 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177284 : if (p_namelist != NULL && namelist != NULL && p_namelist != namelist)
177285 : {
177286 : printf ("Warning: namelist = %p overwriting valid pointer p_namelist = %p \n",namelist,p_namelist);
177287 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177288 : printf ("Error fails assertion (p_namelist != NULL && namelist != NULL && p_namelist != namelist) is false\n");
177289 : ROSE_ASSERT(false);
177290 : #endif
177291 : }
177292 : #endif
177293 0 : p_namelist = namelist;
177294 0 : }
177295 :
177296 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177297 :
177298 :
177299 : // End of memberFunctionString
177300 : // Start of memberFunctionString
177301 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177302 :
177303 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177304 :
177305 : SgExpression*
177306 0 : SgReadStatement::get_advance () const
177307 : {
177308 0 : ROSE_ASSERT (this != NULL);
177309 :
177310 : #if 0
177311 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177312 : // used to trigger marking transformations for the token-based unparsing.
177313 : printf ("SgReadStatement::get_advance = %p = %s \n",this,this->class_name().c_str());
177314 : #endif
177315 :
177316 0 : return p_advance;
177317 : }
177318 :
177319 : void
177320 0 : SgReadStatement::set_advance ( SgExpression* advance )
177321 : {
177322 0 : ROSE_ASSERT (this != NULL);
177323 :
177324 : #if 0
177325 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177326 : // used to trigger marking transformations for the token-based unparsing.
177327 : printf ("SgReadStatement::set_advance = %p = %s \n",this,this->class_name().c_str());
177328 : #endif
177329 :
177330 0 : set_isModified(true);
177331 :
177332 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177333 : if (p_advance != NULL && advance != NULL && p_advance != advance)
177334 : {
177335 : printf ("Warning: advance = %p overwriting valid pointer p_advance = %p \n",advance,p_advance);
177336 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177337 : printf ("Error fails assertion (p_advance != NULL && advance != NULL && p_advance != advance) is false\n");
177338 : ROSE_ASSERT(false);
177339 : #endif
177340 : }
177341 : #endif
177342 0 : p_advance = advance;
177343 0 : }
177344 :
177345 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177346 :
177347 :
177348 : // End of memberFunctionString
177349 : // Start of memberFunctionString
177350 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177351 :
177352 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177353 :
177354 : SgExpression*
177355 0 : SgReadStatement::get_asynchronous () const
177356 : {
177357 0 : ROSE_ASSERT (this != NULL);
177358 :
177359 : #if 0
177360 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177361 : // used to trigger marking transformations for the token-based unparsing.
177362 : printf ("SgReadStatement::get_asynchronous = %p = %s \n",this,this->class_name().c_str());
177363 : #endif
177364 :
177365 0 : return p_asynchronous;
177366 : }
177367 :
177368 : void
177369 0 : SgReadStatement::set_asynchronous ( SgExpression* asynchronous )
177370 : {
177371 0 : ROSE_ASSERT (this != NULL);
177372 :
177373 : #if 0
177374 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177375 : // used to trigger marking transformations for the token-based unparsing.
177376 : printf ("SgReadStatement::set_asynchronous = %p = %s \n",this,this->class_name().c_str());
177377 : #endif
177378 :
177379 0 : set_isModified(true);
177380 :
177381 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177382 : if (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous)
177383 : {
177384 : printf ("Warning: asynchronous = %p overwriting valid pointer p_asynchronous = %p \n",asynchronous,p_asynchronous);
177385 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177386 : printf ("Error fails assertion (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous) is false\n");
177387 : ROSE_ASSERT(false);
177388 : #endif
177389 : }
177390 : #endif
177391 0 : p_asynchronous = asynchronous;
177392 0 : }
177393 :
177394 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177395 :
177396 :
177397 : // End of memberFunctionString
177398 : // Start of memberFunctionString
177399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177400 :
177401 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177402 :
177403 : SgExpression*
177404 0 : SgReadStatement::get_blank () const
177405 : {
177406 0 : ROSE_ASSERT (this != NULL);
177407 :
177408 : #if 0
177409 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177410 : // used to trigger marking transformations for the token-based unparsing.
177411 : printf ("SgReadStatement::get_blank = %p = %s \n",this,this->class_name().c_str());
177412 : #endif
177413 :
177414 0 : return p_blank;
177415 : }
177416 :
177417 : void
177418 0 : SgReadStatement::set_blank ( SgExpression* blank )
177419 : {
177420 0 : ROSE_ASSERT (this != NULL);
177421 :
177422 : #if 0
177423 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177424 : // used to trigger marking transformations for the token-based unparsing.
177425 : printf ("SgReadStatement::set_blank = %p = %s \n",this,this->class_name().c_str());
177426 : #endif
177427 :
177428 0 : set_isModified(true);
177429 :
177430 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177431 : if (p_blank != NULL && blank != NULL && p_blank != blank)
177432 : {
177433 : printf ("Warning: blank = %p overwriting valid pointer p_blank = %p \n",blank,p_blank);
177434 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177435 : printf ("Error fails assertion (p_blank != NULL && blank != NULL && p_blank != blank) is false\n");
177436 : ROSE_ASSERT(false);
177437 : #endif
177438 : }
177439 : #endif
177440 0 : p_blank = blank;
177441 0 : }
177442 :
177443 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177444 :
177445 :
177446 : // End of memberFunctionString
177447 : // Start of memberFunctionString
177448 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177449 :
177450 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177451 :
177452 : SgExpression*
177453 0 : SgReadStatement::get_decimal () const
177454 : {
177455 0 : ROSE_ASSERT (this != NULL);
177456 :
177457 : #if 0
177458 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177459 : // used to trigger marking transformations for the token-based unparsing.
177460 : printf ("SgReadStatement::get_decimal = %p = %s \n",this,this->class_name().c_str());
177461 : #endif
177462 :
177463 0 : return p_decimal;
177464 : }
177465 :
177466 : void
177467 0 : SgReadStatement::set_decimal ( SgExpression* decimal )
177468 : {
177469 0 : ROSE_ASSERT (this != NULL);
177470 :
177471 : #if 0
177472 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177473 : // used to trigger marking transformations for the token-based unparsing.
177474 : printf ("SgReadStatement::set_decimal = %p = %s \n",this,this->class_name().c_str());
177475 : #endif
177476 :
177477 0 : set_isModified(true);
177478 :
177479 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177480 : if (p_decimal != NULL && decimal != NULL && p_decimal != decimal)
177481 : {
177482 : printf ("Warning: decimal = %p overwriting valid pointer p_decimal = %p \n",decimal,p_decimal);
177483 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177484 : printf ("Error fails assertion (p_decimal != NULL && decimal != NULL && p_decimal != decimal) is false\n");
177485 : ROSE_ASSERT(false);
177486 : #endif
177487 : }
177488 : #endif
177489 0 : p_decimal = decimal;
177490 0 : }
177491 :
177492 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177493 :
177494 :
177495 : // End of memberFunctionString
177496 : // Start of memberFunctionString
177497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177498 :
177499 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177500 :
177501 : SgExpression*
177502 0 : SgReadStatement::get_delim () const
177503 : {
177504 0 : ROSE_ASSERT (this != NULL);
177505 :
177506 : #if 0
177507 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177508 : // used to trigger marking transformations for the token-based unparsing.
177509 : printf ("SgReadStatement::get_delim = %p = %s \n",this,this->class_name().c_str());
177510 : #endif
177511 :
177512 0 : return p_delim;
177513 : }
177514 :
177515 : void
177516 0 : SgReadStatement::set_delim ( SgExpression* delim )
177517 : {
177518 0 : ROSE_ASSERT (this != NULL);
177519 :
177520 : #if 0
177521 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177522 : // used to trigger marking transformations for the token-based unparsing.
177523 : printf ("SgReadStatement::set_delim = %p = %s \n",this,this->class_name().c_str());
177524 : #endif
177525 :
177526 0 : set_isModified(true);
177527 :
177528 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177529 : if (p_delim != NULL && delim != NULL && p_delim != delim)
177530 : {
177531 : printf ("Warning: delim = %p overwriting valid pointer p_delim = %p \n",delim,p_delim);
177532 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177533 : printf ("Error fails assertion (p_delim != NULL && delim != NULL && p_delim != delim) is false\n");
177534 : ROSE_ASSERT(false);
177535 : #endif
177536 : }
177537 : #endif
177538 0 : p_delim = delim;
177539 0 : }
177540 :
177541 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177542 :
177543 :
177544 : // End of memberFunctionString
177545 : // Start of memberFunctionString
177546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177547 :
177548 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177549 :
177550 : SgExpression*
177551 0 : SgReadStatement::get_end () const
177552 : {
177553 0 : ROSE_ASSERT (this != NULL);
177554 :
177555 : #if 0
177556 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177557 : // used to trigger marking transformations for the token-based unparsing.
177558 : printf ("SgReadStatement::get_end = %p = %s \n",this,this->class_name().c_str());
177559 : #endif
177560 :
177561 0 : return p_end;
177562 : }
177563 :
177564 : void
177565 0 : SgReadStatement::set_end ( SgExpression* end )
177566 : {
177567 0 : ROSE_ASSERT (this != NULL);
177568 :
177569 : #if 0
177570 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177571 : // used to trigger marking transformations for the token-based unparsing.
177572 : printf ("SgReadStatement::set_end = %p = %s \n",this,this->class_name().c_str());
177573 : #endif
177574 :
177575 0 : set_isModified(true);
177576 :
177577 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177578 : if (p_end != NULL && end != NULL && p_end != end)
177579 : {
177580 : printf ("Warning: end = %p overwriting valid pointer p_end = %p \n",end,p_end);
177581 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177582 : printf ("Error fails assertion (p_end != NULL && end != NULL && p_end != end) is false\n");
177583 : ROSE_ASSERT(false);
177584 : #endif
177585 : }
177586 : #endif
177587 0 : p_end = end;
177588 0 : }
177589 :
177590 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177591 :
177592 :
177593 : // End of memberFunctionString
177594 : // Start of memberFunctionString
177595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177596 :
177597 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177598 :
177599 : SgExpression*
177600 0 : SgReadStatement::get_eor () const
177601 : {
177602 0 : ROSE_ASSERT (this != NULL);
177603 :
177604 : #if 0
177605 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177606 : // used to trigger marking transformations for the token-based unparsing.
177607 : printf ("SgReadStatement::get_eor = %p = %s \n",this,this->class_name().c_str());
177608 : #endif
177609 :
177610 0 : return p_eor;
177611 : }
177612 :
177613 : void
177614 0 : SgReadStatement::set_eor ( SgExpression* eor )
177615 : {
177616 0 : ROSE_ASSERT (this != NULL);
177617 :
177618 : #if 0
177619 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177620 : // used to trigger marking transformations for the token-based unparsing.
177621 : printf ("SgReadStatement::set_eor = %p = %s \n",this,this->class_name().c_str());
177622 : #endif
177623 :
177624 0 : set_isModified(true);
177625 :
177626 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177627 : if (p_eor != NULL && eor != NULL && p_eor != eor)
177628 : {
177629 : printf ("Warning: eor = %p overwriting valid pointer p_eor = %p \n",eor,p_eor);
177630 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177631 : printf ("Error fails assertion (p_eor != NULL && eor != NULL && p_eor != eor) is false\n");
177632 : ROSE_ASSERT(false);
177633 : #endif
177634 : }
177635 : #endif
177636 0 : p_eor = eor;
177637 0 : }
177638 :
177639 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177640 :
177641 :
177642 : // End of memberFunctionString
177643 : // Start of memberFunctionString
177644 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177645 :
177646 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177647 :
177648 : SgExpression*
177649 0 : SgReadStatement::get_id () const
177650 : {
177651 0 : ROSE_ASSERT (this != NULL);
177652 :
177653 : #if 0
177654 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177655 : // used to trigger marking transformations for the token-based unparsing.
177656 : printf ("SgReadStatement::get_id = %p = %s \n",this,this->class_name().c_str());
177657 : #endif
177658 :
177659 0 : return p_id;
177660 : }
177661 :
177662 : void
177663 0 : SgReadStatement::set_id ( SgExpression* id )
177664 : {
177665 0 : ROSE_ASSERT (this != NULL);
177666 :
177667 : #if 0
177668 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177669 : // used to trigger marking transformations for the token-based unparsing.
177670 : printf ("SgReadStatement::set_id = %p = %s \n",this,this->class_name().c_str());
177671 : #endif
177672 :
177673 0 : set_isModified(true);
177674 :
177675 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177676 : if (p_id != NULL && id != NULL && p_id != id)
177677 : {
177678 : printf ("Warning: id = %p overwriting valid pointer p_id = %p \n",id,p_id);
177679 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177680 : printf ("Error fails assertion (p_id != NULL && id != NULL && p_id != id) is false\n");
177681 : ROSE_ASSERT(false);
177682 : #endif
177683 : }
177684 : #endif
177685 0 : p_id = id;
177686 0 : }
177687 :
177688 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177689 :
177690 :
177691 : // End of memberFunctionString
177692 : // Start of memberFunctionString
177693 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177694 :
177695 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177696 :
177697 : SgExpression*
177698 0 : SgReadStatement::get_pad () const
177699 : {
177700 0 : ROSE_ASSERT (this != NULL);
177701 :
177702 : #if 0
177703 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177704 : // used to trigger marking transformations for the token-based unparsing.
177705 : printf ("SgReadStatement::get_pad = %p = %s \n",this,this->class_name().c_str());
177706 : #endif
177707 :
177708 0 : return p_pad;
177709 : }
177710 :
177711 : void
177712 0 : SgReadStatement::set_pad ( SgExpression* pad )
177713 : {
177714 0 : ROSE_ASSERT (this != NULL);
177715 :
177716 : #if 0
177717 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177718 : // used to trigger marking transformations for the token-based unparsing.
177719 : printf ("SgReadStatement::set_pad = %p = %s \n",this,this->class_name().c_str());
177720 : #endif
177721 :
177722 0 : set_isModified(true);
177723 :
177724 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177725 : if (p_pad != NULL && pad != NULL && p_pad != pad)
177726 : {
177727 : printf ("Warning: pad = %p overwriting valid pointer p_pad = %p \n",pad,p_pad);
177728 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177729 : printf ("Error fails assertion (p_pad != NULL && pad != NULL && p_pad != pad) is false\n");
177730 : ROSE_ASSERT(false);
177731 : #endif
177732 : }
177733 : #endif
177734 0 : p_pad = pad;
177735 0 : }
177736 :
177737 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177738 :
177739 :
177740 : // End of memberFunctionString
177741 : // Start of memberFunctionString
177742 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177743 :
177744 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177745 :
177746 : SgExpression*
177747 0 : SgReadStatement::get_pos () const
177748 : {
177749 0 : ROSE_ASSERT (this != NULL);
177750 :
177751 : #if 0
177752 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177753 : // used to trigger marking transformations for the token-based unparsing.
177754 : printf ("SgReadStatement::get_pos = %p = %s \n",this,this->class_name().c_str());
177755 : #endif
177756 :
177757 0 : return p_pos;
177758 : }
177759 :
177760 : void
177761 0 : SgReadStatement::set_pos ( SgExpression* pos )
177762 : {
177763 0 : ROSE_ASSERT (this != NULL);
177764 :
177765 : #if 0
177766 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177767 : // used to trigger marking transformations for the token-based unparsing.
177768 : printf ("SgReadStatement::set_pos = %p = %s \n",this,this->class_name().c_str());
177769 : #endif
177770 :
177771 0 : set_isModified(true);
177772 :
177773 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177774 : if (p_pos != NULL && pos != NULL && p_pos != pos)
177775 : {
177776 : printf ("Warning: pos = %p overwriting valid pointer p_pos = %p \n",pos,p_pos);
177777 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177778 : printf ("Error fails assertion (p_pos != NULL && pos != NULL && p_pos != pos) is false\n");
177779 : ROSE_ASSERT(false);
177780 : #endif
177781 : }
177782 : #endif
177783 0 : p_pos = pos;
177784 0 : }
177785 :
177786 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177787 :
177788 :
177789 : // End of memberFunctionString
177790 : // Start of memberFunctionString
177791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177792 :
177793 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177794 :
177795 : SgExpression*
177796 0 : SgReadStatement::get_rec () const
177797 : {
177798 0 : ROSE_ASSERT (this != NULL);
177799 :
177800 : #if 0
177801 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177802 : // used to trigger marking transformations for the token-based unparsing.
177803 : printf ("SgReadStatement::get_rec = %p = %s \n",this,this->class_name().c_str());
177804 : #endif
177805 :
177806 0 : return p_rec;
177807 : }
177808 :
177809 : void
177810 0 : SgReadStatement::set_rec ( SgExpression* rec )
177811 : {
177812 0 : ROSE_ASSERT (this != NULL);
177813 :
177814 : #if 0
177815 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177816 : // used to trigger marking transformations for the token-based unparsing.
177817 : printf ("SgReadStatement::set_rec = %p = %s \n",this,this->class_name().c_str());
177818 : #endif
177819 :
177820 0 : set_isModified(true);
177821 :
177822 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177823 : if (p_rec != NULL && rec != NULL && p_rec != rec)
177824 : {
177825 : printf ("Warning: rec = %p overwriting valid pointer p_rec = %p \n",rec,p_rec);
177826 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177827 : printf ("Error fails assertion (p_rec != NULL && rec != NULL && p_rec != rec) is false\n");
177828 : ROSE_ASSERT(false);
177829 : #endif
177830 : }
177831 : #endif
177832 0 : p_rec = rec;
177833 0 : }
177834 :
177835 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177836 :
177837 :
177838 : // End of memberFunctionString
177839 : // Start of memberFunctionString
177840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177841 :
177842 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177843 :
177844 : SgExpression*
177845 0 : SgReadStatement::get_round () const
177846 : {
177847 0 : ROSE_ASSERT (this != NULL);
177848 :
177849 : #if 0
177850 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177851 : // used to trigger marking transformations for the token-based unparsing.
177852 : printf ("SgReadStatement::get_round = %p = %s \n",this,this->class_name().c_str());
177853 : #endif
177854 :
177855 0 : return p_round;
177856 : }
177857 :
177858 : void
177859 0 : SgReadStatement::set_round ( SgExpression* round )
177860 : {
177861 0 : ROSE_ASSERT (this != NULL);
177862 :
177863 : #if 0
177864 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177865 : // used to trigger marking transformations for the token-based unparsing.
177866 : printf ("SgReadStatement::set_round = %p = %s \n",this,this->class_name().c_str());
177867 : #endif
177868 :
177869 0 : set_isModified(true);
177870 :
177871 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177872 : if (p_round != NULL && round != NULL && p_round != round)
177873 : {
177874 : printf ("Warning: round = %p overwriting valid pointer p_round = %p \n",round,p_round);
177875 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177876 : printf ("Error fails assertion (p_round != NULL && round != NULL && p_round != round) is false\n");
177877 : ROSE_ASSERT(false);
177878 : #endif
177879 : }
177880 : #endif
177881 0 : p_round = round;
177882 0 : }
177883 :
177884 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177885 :
177886 :
177887 : // End of memberFunctionString
177888 : // Start of memberFunctionString
177889 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177890 :
177891 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177892 :
177893 : SgExpression*
177894 0 : SgReadStatement::get_sign () const
177895 : {
177896 0 : ROSE_ASSERT (this != NULL);
177897 :
177898 : #if 0
177899 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177900 : // used to trigger marking transformations for the token-based unparsing.
177901 : printf ("SgReadStatement::get_sign = %p = %s \n",this,this->class_name().c_str());
177902 : #endif
177903 :
177904 0 : return p_sign;
177905 : }
177906 :
177907 : void
177908 0 : SgReadStatement::set_sign ( SgExpression* sign )
177909 : {
177910 0 : ROSE_ASSERT (this != NULL);
177911 :
177912 : #if 0
177913 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177914 : // used to trigger marking transformations for the token-based unparsing.
177915 : printf ("SgReadStatement::set_sign = %p = %s \n",this,this->class_name().c_str());
177916 : #endif
177917 :
177918 0 : set_isModified(true);
177919 :
177920 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177921 : if (p_sign != NULL && sign != NULL && p_sign != sign)
177922 : {
177923 : printf ("Warning: sign = %p overwriting valid pointer p_sign = %p \n",sign,p_sign);
177924 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177925 : printf ("Error fails assertion (p_sign != NULL && sign != NULL && p_sign != sign) is false\n");
177926 : ROSE_ASSERT(false);
177927 : #endif
177928 : }
177929 : #endif
177930 0 : p_sign = sign;
177931 0 : }
177932 :
177933 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177934 :
177935 :
177936 : // End of memberFunctionString
177937 : // Start of memberFunctionString
177938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
177939 :
177940 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
177941 :
177942 : SgExpression*
177943 0 : SgReadStatement::get_size () const
177944 : {
177945 0 : ROSE_ASSERT (this != NULL);
177946 :
177947 : #if 0
177948 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177949 : // used to trigger marking transformations for the token-based unparsing.
177950 : printf ("SgReadStatement::get_size = %p = %s \n",this,this->class_name().c_str());
177951 : #endif
177952 :
177953 0 : return p_size;
177954 : }
177955 :
177956 : void
177957 0 : SgReadStatement::set_size ( SgExpression* size )
177958 : {
177959 0 : ROSE_ASSERT (this != NULL);
177960 :
177961 : #if 0
177962 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
177963 : // used to trigger marking transformations for the token-based unparsing.
177964 : printf ("SgReadStatement::set_size = %p = %s \n",this,this->class_name().c_str());
177965 : #endif
177966 :
177967 0 : set_isModified(true);
177968 :
177969 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
177970 : if (p_size != NULL && size != NULL && p_size != size)
177971 : {
177972 : printf ("Warning: size = %p overwriting valid pointer p_size = %p \n",size,p_size);
177973 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
177974 : printf ("Error fails assertion (p_size != NULL && size != NULL && p_size != size) is false\n");
177975 : ROSE_ASSERT(false);
177976 : #endif
177977 : }
177978 : #endif
177979 0 : p_size = size;
177980 0 : }
177981 :
177982 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
177983 :
177984 :
177985 : // End of memberFunctionString
177986 : // Start of memberFunctionString
177987 : /* #line 18378 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
177988 :
177989 :
177990 : void
177991 0 : SgReadStatement::post_construction_initialization()
177992 0 : {}
177993 :
177994 :
177995 :
177996 : // End of memberFunctionString
177997 : // Start of memberFunctionString
177998 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
177999 :
178000 : // *** COMMON CODE SECTION BEGINS HERE ***
178001 :
178002 : #if 0
178003 : int
178004 : SgReadStatement::getVariant() const
178005 : {
178006 : // This function is used in ROSE while "variant()" is used in SAGE
178007 : assert(this != NULL);
178008 : return variant();
178009 : }
178010 : #endif
178011 :
178012 : // This function is used in ROSE in treeTraversal code
178013 : // eventually replaces getVariant() and variant()
178014 : // though after variant() has been removed for a while we will
178015 : // want to change the name of variantT() back to variant()
178016 : // (since the "T" was ment to stand for temporary).
178017 : // When this happens the variantT() will be depricated.
178018 : VariantT
178019 0 : SgReadStatement::variantT() const
178020 : {
178021 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
178022 0 : ROSE_ASSERT(this != NULL);
178023 0 : return V_SgReadStatement;
178024 : }
178025 :
178026 : #if 0
178027 : int
178028 : SgReadStatement::variant() const
178029 : {
178030 : // This function is used in SAGE
178031 : ROSE_ASSERT(this != NULL);
178032 : return READ_STATEMENT;
178033 : }
178034 : #endif
178035 :
178036 : ROSE_DLL_API const char*
178037 0 : SgReadStatement::sage_class_name() const
178038 : {
178039 0 : ROSE_ASSERT(this != NULL);
178040 0 : return "SgReadStatement";
178041 : }
178042 :
178043 : std::string
178044 0 : SgReadStatement::class_name() const
178045 : {
178046 0 : ROSE_ASSERT(this != NULL);
178047 0 : return "SgReadStatement";
178048 : }
178049 :
178050 : // DQ (11/26/2005): Support for visitor pattern mechanims
178051 : // (inferior to ROSE traversal mechanism, experimental).
178052 : void
178053 0 : SgReadStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
178054 : {
178055 0 : ROSE_ASSERT(this != NULL);
178056 0 : visitor.visit(this);
178057 0 : }
178058 :
178059 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
178060 0 : void SgReadStatement::accept (ROSE_VisitorPattern & visitor) {
178061 0 : ROSE_ASSERT(this != NULL);
178062 0 : visitor.visit(this);
178063 0 : }
178064 :
178065 : SgReadStatement*
178066 0 : SgReadStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
178067 : {
178068 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
178069 : // This function is currently only supported for the AST used the represent Binary executables.
178070 : if (0 /* isSgAsmNode(this) != NULL */)
178071 : {
178072 : // Support for regex specification.
178073 : std::string prefixCode = "REGEX:";
178074 : addNewAttribute(prefixCode + s,a);
178075 : }
178076 : #endif
178077 :
178078 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
178079 0 : return this;
178080 : }
178081 :
178082 : // *** COMMON CODE SECTION ENDS HERE ***
178083 :
178084 :
178085 : // End of memberFunctionString
178086 : // Start of memberFunctionString
178087 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
178088 :
178089 :
178090 : #if 0
178091 : //! Error checking support
178092 : /*! Verifies the following:
178093 : - working getVariant() member function
178094 : - calls base class's error() member function
178095 : Every class has one of these functions.
178096 : */
178097 : bool
178098 : SgReadStatement::error()
178099 : {
178100 : // Put error checking here
178101 :
178102 : ROSE_ASSERT (this != NULL);
178103 : if (getVariant() != READ_STATEMENT)
178104 : {
178105 : printf ("Error in SgReadStatement::error(): SgReadStatement object has a %s variant \n",
178106 : Cxx_GrammarTerminalNames[getVariant()].name);
178107 : // printf ("Error in SgReadStatement::error() \n");
178108 : ROSE_ABORT();
178109 : }
178110 :
178111 : ROSE_ASSERT (getVariant() == READ_STATEMENT);
178112 : return SgIOStatement::error();
178113 : }
178114 : #endif
178115 :
178116 :
178117 :
178118 : // End of memberFunctionString
178119 :
178120 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
178121 :
178122 0 : SgReadStatement* isSgReadStatement ( SgNode* inputDerivedClassPointer )
178123 : {
178124 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
178125 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
178126 : // So to fix this we return NULL directly when the input is NULL and avoid the
178127 : // dynamic_cast in this case. This is likely a performance improvement as well.
178128 : // return dynamic_cast<SgReadStatement*>(inputDerivedClassPointer);
178129 : // Milind Chabbi (8/28/2013): isSgReadStatement uses table-driven castability instead of c++ default dynamic_cast
178130 : // this improves the running time performance by 10-20%.
178131 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgReadStatement*>(inputDerivedClassPointer);
178132 0 : return IS_SgReadStatement_FAST_MACRO(inputDerivedClassPointer);
178133 : }
178134 :
178135 : // DQ (11/8/2003): Added version of functions taking const pointer
178136 0 : const SgReadStatement* isSgReadStatement ( const SgNode* inputDerivedClassPointer )
178137 : {
178138 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
178139 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
178140 : // So to fix this we return NULL directly when the input is NULL and avoid the
178141 : // dynamic_cast in this case. This is likely a performance improvement as well.
178142 : // return dynamic_cast<const SgReadStatement*>(inputDerivedClassPointer);
178143 : // Milind Chabbi (8/28/2013): isSgReadStatement uses table-driven castability instead of c++ default dynamic_cast
178144 : // this improves the running time performance by 10-20%.
178145 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgReadStatement*>(inputDerivedClassPointer);
178146 0 : return IS_SgReadStatement_FAST_MACRO(inputDerivedClassPointer);
178147 : }
178148 :
178149 :
178150 :
178151 : /* #line 178152 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
178152 :
178153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
178154 :
178155 : /**
178156 : \brief Generated destructor
178157 :
178158 : This destructor is automatically generated (by ROSETTA). This destructor
178159 : only frees memory of data members associated with the parts of the current IR node which
178160 : are NOT traversed. Those data members that are part of a traversal can be freed using
178161 : a traversal (calling this destructor on all children in a post-order traversal). Such
178162 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
178163 :
178164 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
178165 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
178166 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
178167 :
178168 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
178169 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
178170 : pointers are not yet implemented to call delete on eash pointer in the container.
178171 : (This could be done by derivation from the STL containers to define containers that
178172 : automatically deleted their members.)
178173 :
178174 : */
178175 0 : SgReadStatement::~SgReadStatement () {
178176 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
178177 :
178178 :
178179 : // case: not a listType for format
178180 0 : p_format = NULL; // non list case
178181 : // case: not a listType for namelist
178182 0 : p_namelist = NULL; // non list case
178183 : // case: not a listType for advance
178184 0 : p_advance = NULL; // non list case
178185 : // case: not a listType for asynchronous
178186 0 : p_asynchronous = NULL; // non list case
178187 : // case: not a listType for blank
178188 0 : p_blank = NULL; // non list case
178189 : // case: not a listType for decimal
178190 0 : p_decimal = NULL; // non list case
178191 : // case: not a listType for delim
178192 0 : p_delim = NULL; // non list case
178193 : // case: not a listType for end
178194 0 : p_end = NULL; // non list case
178195 : // case: not a listType for eor
178196 0 : p_eor = NULL; // non list case
178197 : // case: not a listType for id
178198 0 : p_id = NULL; // non list case
178199 : // case: not a listType for pad
178200 0 : p_pad = NULL; // non list case
178201 : // case: not a listType for pos
178202 0 : p_pos = NULL; // non list case
178203 : // case: not a listType for rec
178204 0 : p_rec = NULL; // non list case
178205 : // case: not a listType for round
178206 0 : p_round = NULL; // non list case
178207 : // case: not a listType for sign
178208 0 : p_sign = NULL; // non list case
178209 : // case: not a listType for size
178210 0 : p_size = NULL; // non list case
178211 :
178212 : }
178213 :
178214 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
178215 0 : }
178216 :
178217 :
178218 : /* #line 178219 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
178219 :
178220 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
178221 :
178222 : // Generated constructor
178223 0 : SgReadStatement::SgReadStatement ( Sg_File_Info* startOfConstruct )
178224 0 : : SgIOStatement(startOfConstruct)
178225 : {
178226 : #ifdef DEBUG
178227 : // printf ("In SgReadStatement::SgReadStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
178228 : #endif
178229 : #if 0
178230 : // debugging information!
178231 : printf ("In SgReadStatement::SgReadStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
178232 : #endif
178233 :
178234 0 : p_format = NULL;
178235 0 : p_namelist = NULL;
178236 0 : p_advance = NULL;
178237 0 : p_asynchronous = NULL;
178238 0 : p_blank = NULL;
178239 0 : p_decimal = NULL;
178240 0 : p_delim = NULL;
178241 0 : p_end = NULL;
178242 0 : p_eor = NULL;
178243 0 : p_id = NULL;
178244 0 : p_pad = NULL;
178245 0 : p_pos = NULL;
178246 0 : p_rec = NULL;
178247 0 : p_round = NULL;
178248 0 : p_sign = NULL;
178249 0 : p_size = NULL;
178250 :
178251 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
178252 :
178253 : #if 0
178254 : // DQ (7/30/2014): Call a virtual function.
178255 : std::string s = this->class_name();
178256 : #endif
178257 :
178258 : // Test the variant virtual function
178259 : // assert(READ_STATEMENT == variant());
178260 0 : assert(READ_STATEMENT == this->variant());
178261 0 : ROSE_ASSERT(READ_STATEMENT == (int)(this->variantT()));
178262 0 : post_construction_initialization();
178263 :
178264 : // Test the isSgReadStatement() function since it has been problematic
178265 0 : assert(isSgReadStatement(this) != NULL);
178266 0 : }
178267 :
178268 : // Generated constructor (all data members)
178269 :
178270 : /* #line 178271 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
178271 :
178272 :
178273 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
178274 :
178275 :
178276 : // ********************************************************
178277 : // member functions common across all array grammar objects
178278 : // ********************************************************
178279 :
178280 :
178281 :
178282 : /* #line 178283 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
178283 :
178284 :
178285 :
178286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
178287 :
178288 : // ********************************************************
178289 : // member functions specific to each node in the grammar
178290 : // ********************************************************
178291 :
178292 :
178293 : /* #line 178294 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
178294 :
178295 : // Start of memberFunctionString
178296 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178297 :
178298 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178299 :
178300 : SgExpression*
178301 7 : SgWriteStatement::get_format () const
178302 : {
178303 7 : ROSE_ASSERT (this != NULL);
178304 :
178305 : #if 0
178306 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178307 : // used to trigger marking transformations for the token-based unparsing.
178308 : printf ("SgWriteStatement::get_format = %p = %s \n",this,this->class_name().c_str());
178309 : #endif
178310 :
178311 7 : return p_format;
178312 : }
178313 :
178314 : void
178315 7 : SgWriteStatement::set_format ( SgExpression* format )
178316 : {
178317 7 : ROSE_ASSERT (this != NULL);
178318 :
178319 : #if 0
178320 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178321 : // used to trigger marking transformations for the token-based unparsing.
178322 : printf ("SgWriteStatement::set_format = %p = %s \n",this,this->class_name().c_str());
178323 : #endif
178324 :
178325 7 : set_isModified(true);
178326 :
178327 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178328 : if (p_format != NULL && format != NULL && p_format != format)
178329 : {
178330 : printf ("Warning: format = %p overwriting valid pointer p_format = %p \n",format,p_format);
178331 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178332 : printf ("Error fails assertion (p_format != NULL && format != NULL && p_format != format) is false\n");
178333 : ROSE_ASSERT(false);
178334 : #endif
178335 : }
178336 : #endif
178337 7 : p_format = format;
178338 7 : }
178339 :
178340 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178341 :
178342 :
178343 : // End of memberFunctionString
178344 : // Start of memberFunctionString
178345 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178346 :
178347 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178348 :
178349 : SgExpression*
178350 7 : SgWriteStatement::get_namelist () const
178351 : {
178352 7 : ROSE_ASSERT (this != NULL);
178353 :
178354 : #if 0
178355 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178356 : // used to trigger marking transformations for the token-based unparsing.
178357 : printf ("SgWriteStatement::get_namelist = %p = %s \n",this,this->class_name().c_str());
178358 : #endif
178359 :
178360 7 : return p_namelist;
178361 : }
178362 :
178363 : void
178364 0 : SgWriteStatement::set_namelist ( SgExpression* namelist )
178365 : {
178366 0 : ROSE_ASSERT (this != NULL);
178367 :
178368 : #if 0
178369 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178370 : // used to trigger marking transformations for the token-based unparsing.
178371 : printf ("SgWriteStatement::set_namelist = %p = %s \n",this,this->class_name().c_str());
178372 : #endif
178373 :
178374 0 : set_isModified(true);
178375 :
178376 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178377 : if (p_namelist != NULL && namelist != NULL && p_namelist != namelist)
178378 : {
178379 : printf ("Warning: namelist = %p overwriting valid pointer p_namelist = %p \n",namelist,p_namelist);
178380 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178381 : printf ("Error fails assertion (p_namelist != NULL && namelist != NULL && p_namelist != namelist) is false\n");
178382 : ROSE_ASSERT(false);
178383 : #endif
178384 : }
178385 : #endif
178386 0 : p_namelist = namelist;
178387 0 : }
178388 :
178389 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178390 :
178391 :
178392 : // End of memberFunctionString
178393 : // Start of memberFunctionString
178394 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178395 :
178396 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178397 :
178398 : SgExpression*
178399 7 : SgWriteStatement::get_advance () const
178400 : {
178401 7 : ROSE_ASSERT (this != NULL);
178402 :
178403 : #if 0
178404 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178405 : // used to trigger marking transformations for the token-based unparsing.
178406 : printf ("SgWriteStatement::get_advance = %p = %s \n",this,this->class_name().c_str());
178407 : #endif
178408 :
178409 7 : return p_advance;
178410 : }
178411 :
178412 : void
178413 0 : SgWriteStatement::set_advance ( SgExpression* advance )
178414 : {
178415 0 : ROSE_ASSERT (this != NULL);
178416 :
178417 : #if 0
178418 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178419 : // used to trigger marking transformations for the token-based unparsing.
178420 : printf ("SgWriteStatement::set_advance = %p = %s \n",this,this->class_name().c_str());
178421 : #endif
178422 :
178423 0 : set_isModified(true);
178424 :
178425 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178426 : if (p_advance != NULL && advance != NULL && p_advance != advance)
178427 : {
178428 : printf ("Warning: advance = %p overwriting valid pointer p_advance = %p \n",advance,p_advance);
178429 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178430 : printf ("Error fails assertion (p_advance != NULL && advance != NULL && p_advance != advance) is false\n");
178431 : ROSE_ASSERT(false);
178432 : #endif
178433 : }
178434 : #endif
178435 0 : p_advance = advance;
178436 0 : }
178437 :
178438 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178439 :
178440 :
178441 : // End of memberFunctionString
178442 : // Start of memberFunctionString
178443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178444 :
178445 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178446 :
178447 : SgExpression*
178448 7 : SgWriteStatement::get_asynchronous () const
178449 : {
178450 7 : ROSE_ASSERT (this != NULL);
178451 :
178452 : #if 0
178453 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178454 : // used to trigger marking transformations for the token-based unparsing.
178455 : printf ("SgWriteStatement::get_asynchronous = %p = %s \n",this,this->class_name().c_str());
178456 : #endif
178457 :
178458 7 : return p_asynchronous;
178459 : }
178460 :
178461 : void
178462 0 : SgWriteStatement::set_asynchronous ( SgExpression* asynchronous )
178463 : {
178464 0 : ROSE_ASSERT (this != NULL);
178465 :
178466 : #if 0
178467 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178468 : // used to trigger marking transformations for the token-based unparsing.
178469 : printf ("SgWriteStatement::set_asynchronous = %p = %s \n",this,this->class_name().c_str());
178470 : #endif
178471 :
178472 0 : set_isModified(true);
178473 :
178474 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178475 : if (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous)
178476 : {
178477 : printf ("Warning: asynchronous = %p overwriting valid pointer p_asynchronous = %p \n",asynchronous,p_asynchronous);
178478 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178479 : printf ("Error fails assertion (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous) is false\n");
178480 : ROSE_ASSERT(false);
178481 : #endif
178482 : }
178483 : #endif
178484 0 : p_asynchronous = asynchronous;
178485 0 : }
178486 :
178487 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178488 :
178489 :
178490 : // End of memberFunctionString
178491 : // Start of memberFunctionString
178492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178493 :
178494 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178495 :
178496 : SgExpression*
178497 7 : SgWriteStatement::get_blank () const
178498 : {
178499 7 : ROSE_ASSERT (this != NULL);
178500 :
178501 : #if 0
178502 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178503 : // used to trigger marking transformations for the token-based unparsing.
178504 : printf ("SgWriteStatement::get_blank = %p = %s \n",this,this->class_name().c_str());
178505 : #endif
178506 :
178507 7 : return p_blank;
178508 : }
178509 :
178510 : void
178511 0 : SgWriteStatement::set_blank ( SgExpression* blank )
178512 : {
178513 0 : ROSE_ASSERT (this != NULL);
178514 :
178515 : #if 0
178516 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178517 : // used to trigger marking transformations for the token-based unparsing.
178518 : printf ("SgWriteStatement::set_blank = %p = %s \n",this,this->class_name().c_str());
178519 : #endif
178520 :
178521 0 : set_isModified(true);
178522 :
178523 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178524 : if (p_blank != NULL && blank != NULL && p_blank != blank)
178525 : {
178526 : printf ("Warning: blank = %p overwriting valid pointer p_blank = %p \n",blank,p_blank);
178527 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178528 : printf ("Error fails assertion (p_blank != NULL && blank != NULL && p_blank != blank) is false\n");
178529 : ROSE_ASSERT(false);
178530 : #endif
178531 : }
178532 : #endif
178533 0 : p_blank = blank;
178534 0 : }
178535 :
178536 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178537 :
178538 :
178539 : // End of memberFunctionString
178540 : // Start of memberFunctionString
178541 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178542 :
178543 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178544 :
178545 : SgExpression*
178546 7 : SgWriteStatement::get_decimal () const
178547 : {
178548 7 : ROSE_ASSERT (this != NULL);
178549 :
178550 : #if 0
178551 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178552 : // used to trigger marking transformations for the token-based unparsing.
178553 : printf ("SgWriteStatement::get_decimal = %p = %s \n",this,this->class_name().c_str());
178554 : #endif
178555 :
178556 7 : return p_decimal;
178557 : }
178558 :
178559 : void
178560 0 : SgWriteStatement::set_decimal ( SgExpression* decimal )
178561 : {
178562 0 : ROSE_ASSERT (this != NULL);
178563 :
178564 : #if 0
178565 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178566 : // used to trigger marking transformations for the token-based unparsing.
178567 : printf ("SgWriteStatement::set_decimal = %p = %s \n",this,this->class_name().c_str());
178568 : #endif
178569 :
178570 0 : set_isModified(true);
178571 :
178572 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178573 : if (p_decimal != NULL && decimal != NULL && p_decimal != decimal)
178574 : {
178575 : printf ("Warning: decimal = %p overwriting valid pointer p_decimal = %p \n",decimal,p_decimal);
178576 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178577 : printf ("Error fails assertion (p_decimal != NULL && decimal != NULL && p_decimal != decimal) is false\n");
178578 : ROSE_ASSERT(false);
178579 : #endif
178580 : }
178581 : #endif
178582 0 : p_decimal = decimal;
178583 0 : }
178584 :
178585 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178586 :
178587 :
178588 : // End of memberFunctionString
178589 : // Start of memberFunctionString
178590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178591 :
178592 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178593 :
178594 : SgExpression*
178595 7 : SgWriteStatement::get_delim () const
178596 : {
178597 7 : ROSE_ASSERT (this != NULL);
178598 :
178599 : #if 0
178600 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178601 : // used to trigger marking transformations for the token-based unparsing.
178602 : printf ("SgWriteStatement::get_delim = %p = %s \n",this,this->class_name().c_str());
178603 : #endif
178604 :
178605 7 : return p_delim;
178606 : }
178607 :
178608 : void
178609 0 : SgWriteStatement::set_delim ( SgExpression* delim )
178610 : {
178611 0 : ROSE_ASSERT (this != NULL);
178612 :
178613 : #if 0
178614 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178615 : // used to trigger marking transformations for the token-based unparsing.
178616 : printf ("SgWriteStatement::set_delim = %p = %s \n",this,this->class_name().c_str());
178617 : #endif
178618 :
178619 0 : set_isModified(true);
178620 :
178621 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178622 : if (p_delim != NULL && delim != NULL && p_delim != delim)
178623 : {
178624 : printf ("Warning: delim = %p overwriting valid pointer p_delim = %p \n",delim,p_delim);
178625 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178626 : printf ("Error fails assertion (p_delim != NULL && delim != NULL && p_delim != delim) is false\n");
178627 : ROSE_ASSERT(false);
178628 : #endif
178629 : }
178630 : #endif
178631 0 : p_delim = delim;
178632 0 : }
178633 :
178634 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178635 :
178636 :
178637 : // End of memberFunctionString
178638 : // Start of memberFunctionString
178639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178640 :
178641 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178642 :
178643 : SgExpression*
178644 7 : SgWriteStatement::get_end () const
178645 : {
178646 7 : ROSE_ASSERT (this != NULL);
178647 :
178648 : #if 0
178649 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178650 : // used to trigger marking transformations for the token-based unparsing.
178651 : printf ("SgWriteStatement::get_end = %p = %s \n",this,this->class_name().c_str());
178652 : #endif
178653 :
178654 7 : return p_end;
178655 : }
178656 :
178657 : void
178658 0 : SgWriteStatement::set_end ( SgExpression* end )
178659 : {
178660 0 : ROSE_ASSERT (this != NULL);
178661 :
178662 : #if 0
178663 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178664 : // used to trigger marking transformations for the token-based unparsing.
178665 : printf ("SgWriteStatement::set_end = %p = %s \n",this,this->class_name().c_str());
178666 : #endif
178667 :
178668 0 : set_isModified(true);
178669 :
178670 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178671 : if (p_end != NULL && end != NULL && p_end != end)
178672 : {
178673 : printf ("Warning: end = %p overwriting valid pointer p_end = %p \n",end,p_end);
178674 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178675 : printf ("Error fails assertion (p_end != NULL && end != NULL && p_end != end) is false\n");
178676 : ROSE_ASSERT(false);
178677 : #endif
178678 : }
178679 : #endif
178680 0 : p_end = end;
178681 0 : }
178682 :
178683 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178684 :
178685 :
178686 : // End of memberFunctionString
178687 : // Start of memberFunctionString
178688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178689 :
178690 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178691 :
178692 : SgExpression*
178693 7 : SgWriteStatement::get_eor () const
178694 : {
178695 7 : ROSE_ASSERT (this != NULL);
178696 :
178697 : #if 0
178698 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178699 : // used to trigger marking transformations for the token-based unparsing.
178700 : printf ("SgWriteStatement::get_eor = %p = %s \n",this,this->class_name().c_str());
178701 : #endif
178702 :
178703 7 : return p_eor;
178704 : }
178705 :
178706 : void
178707 0 : SgWriteStatement::set_eor ( SgExpression* eor )
178708 : {
178709 0 : ROSE_ASSERT (this != NULL);
178710 :
178711 : #if 0
178712 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178713 : // used to trigger marking transformations for the token-based unparsing.
178714 : printf ("SgWriteStatement::set_eor = %p = %s \n",this,this->class_name().c_str());
178715 : #endif
178716 :
178717 0 : set_isModified(true);
178718 :
178719 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178720 : if (p_eor != NULL && eor != NULL && p_eor != eor)
178721 : {
178722 : printf ("Warning: eor = %p overwriting valid pointer p_eor = %p \n",eor,p_eor);
178723 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178724 : printf ("Error fails assertion (p_eor != NULL && eor != NULL && p_eor != eor) is false\n");
178725 : ROSE_ASSERT(false);
178726 : #endif
178727 : }
178728 : #endif
178729 0 : p_eor = eor;
178730 0 : }
178731 :
178732 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178733 :
178734 :
178735 : // End of memberFunctionString
178736 : // Start of memberFunctionString
178737 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178738 :
178739 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178740 :
178741 : SgExpression*
178742 7 : SgWriteStatement::get_id () const
178743 : {
178744 7 : ROSE_ASSERT (this != NULL);
178745 :
178746 : #if 0
178747 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178748 : // used to trigger marking transformations for the token-based unparsing.
178749 : printf ("SgWriteStatement::get_id = %p = %s \n",this,this->class_name().c_str());
178750 : #endif
178751 :
178752 7 : return p_id;
178753 : }
178754 :
178755 : void
178756 0 : SgWriteStatement::set_id ( SgExpression* id )
178757 : {
178758 0 : ROSE_ASSERT (this != NULL);
178759 :
178760 : #if 0
178761 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178762 : // used to trigger marking transformations for the token-based unparsing.
178763 : printf ("SgWriteStatement::set_id = %p = %s \n",this,this->class_name().c_str());
178764 : #endif
178765 :
178766 0 : set_isModified(true);
178767 :
178768 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178769 : if (p_id != NULL && id != NULL && p_id != id)
178770 : {
178771 : printf ("Warning: id = %p overwriting valid pointer p_id = %p \n",id,p_id);
178772 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178773 : printf ("Error fails assertion (p_id != NULL && id != NULL && p_id != id) is false\n");
178774 : ROSE_ASSERT(false);
178775 : #endif
178776 : }
178777 : #endif
178778 0 : p_id = id;
178779 0 : }
178780 :
178781 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178782 :
178783 :
178784 : // End of memberFunctionString
178785 : // Start of memberFunctionString
178786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178787 :
178788 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178789 :
178790 : SgExpression*
178791 7 : SgWriteStatement::get_pad () const
178792 : {
178793 7 : ROSE_ASSERT (this != NULL);
178794 :
178795 : #if 0
178796 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178797 : // used to trigger marking transformations for the token-based unparsing.
178798 : printf ("SgWriteStatement::get_pad = %p = %s \n",this,this->class_name().c_str());
178799 : #endif
178800 :
178801 7 : return p_pad;
178802 : }
178803 :
178804 : void
178805 0 : SgWriteStatement::set_pad ( SgExpression* pad )
178806 : {
178807 0 : ROSE_ASSERT (this != NULL);
178808 :
178809 : #if 0
178810 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178811 : // used to trigger marking transformations for the token-based unparsing.
178812 : printf ("SgWriteStatement::set_pad = %p = %s \n",this,this->class_name().c_str());
178813 : #endif
178814 :
178815 0 : set_isModified(true);
178816 :
178817 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178818 : if (p_pad != NULL && pad != NULL && p_pad != pad)
178819 : {
178820 : printf ("Warning: pad = %p overwriting valid pointer p_pad = %p \n",pad,p_pad);
178821 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178822 : printf ("Error fails assertion (p_pad != NULL && pad != NULL && p_pad != pad) is false\n");
178823 : ROSE_ASSERT(false);
178824 : #endif
178825 : }
178826 : #endif
178827 0 : p_pad = pad;
178828 0 : }
178829 :
178830 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178831 :
178832 :
178833 : // End of memberFunctionString
178834 : // Start of memberFunctionString
178835 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178836 :
178837 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178838 :
178839 : SgExpression*
178840 7 : SgWriteStatement::get_pos () const
178841 : {
178842 7 : ROSE_ASSERT (this != NULL);
178843 :
178844 : #if 0
178845 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178846 : // used to trigger marking transformations for the token-based unparsing.
178847 : printf ("SgWriteStatement::get_pos = %p = %s \n",this,this->class_name().c_str());
178848 : #endif
178849 :
178850 7 : return p_pos;
178851 : }
178852 :
178853 : void
178854 0 : SgWriteStatement::set_pos ( SgExpression* pos )
178855 : {
178856 0 : ROSE_ASSERT (this != NULL);
178857 :
178858 : #if 0
178859 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178860 : // used to trigger marking transformations for the token-based unparsing.
178861 : printf ("SgWriteStatement::set_pos = %p = %s \n",this,this->class_name().c_str());
178862 : #endif
178863 :
178864 0 : set_isModified(true);
178865 :
178866 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178867 : if (p_pos != NULL && pos != NULL && p_pos != pos)
178868 : {
178869 : printf ("Warning: pos = %p overwriting valid pointer p_pos = %p \n",pos,p_pos);
178870 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178871 : printf ("Error fails assertion (p_pos != NULL && pos != NULL && p_pos != pos) is false\n");
178872 : ROSE_ASSERT(false);
178873 : #endif
178874 : }
178875 : #endif
178876 0 : p_pos = pos;
178877 0 : }
178878 :
178879 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178880 :
178881 :
178882 : // End of memberFunctionString
178883 : // Start of memberFunctionString
178884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178885 :
178886 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178887 :
178888 : SgExpression*
178889 7 : SgWriteStatement::get_rec () const
178890 : {
178891 7 : ROSE_ASSERT (this != NULL);
178892 :
178893 : #if 0
178894 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178895 : // used to trigger marking transformations for the token-based unparsing.
178896 : printf ("SgWriteStatement::get_rec = %p = %s \n",this,this->class_name().c_str());
178897 : #endif
178898 :
178899 7 : return p_rec;
178900 : }
178901 :
178902 : void
178903 0 : SgWriteStatement::set_rec ( SgExpression* rec )
178904 : {
178905 0 : ROSE_ASSERT (this != NULL);
178906 :
178907 : #if 0
178908 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178909 : // used to trigger marking transformations for the token-based unparsing.
178910 : printf ("SgWriteStatement::set_rec = %p = %s \n",this,this->class_name().c_str());
178911 : #endif
178912 :
178913 0 : set_isModified(true);
178914 :
178915 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178916 : if (p_rec != NULL && rec != NULL && p_rec != rec)
178917 : {
178918 : printf ("Warning: rec = %p overwriting valid pointer p_rec = %p \n",rec,p_rec);
178919 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178920 : printf ("Error fails assertion (p_rec != NULL && rec != NULL && p_rec != rec) is false\n");
178921 : ROSE_ASSERT(false);
178922 : #endif
178923 : }
178924 : #endif
178925 0 : p_rec = rec;
178926 0 : }
178927 :
178928 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178929 :
178930 :
178931 : // End of memberFunctionString
178932 : // Start of memberFunctionString
178933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178934 :
178935 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178936 :
178937 : SgExpression*
178938 7 : SgWriteStatement::get_round () const
178939 : {
178940 7 : ROSE_ASSERT (this != NULL);
178941 :
178942 : #if 0
178943 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178944 : // used to trigger marking transformations for the token-based unparsing.
178945 : printf ("SgWriteStatement::get_round = %p = %s \n",this,this->class_name().c_str());
178946 : #endif
178947 :
178948 7 : return p_round;
178949 : }
178950 :
178951 : void
178952 0 : SgWriteStatement::set_round ( SgExpression* round )
178953 : {
178954 0 : ROSE_ASSERT (this != NULL);
178955 :
178956 : #if 0
178957 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178958 : // used to trigger marking transformations for the token-based unparsing.
178959 : printf ("SgWriteStatement::set_round = %p = %s \n",this,this->class_name().c_str());
178960 : #endif
178961 :
178962 0 : set_isModified(true);
178963 :
178964 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
178965 : if (p_round != NULL && round != NULL && p_round != round)
178966 : {
178967 : printf ("Warning: round = %p overwriting valid pointer p_round = %p \n",round,p_round);
178968 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
178969 : printf ("Error fails assertion (p_round != NULL && round != NULL && p_round != round) is false\n");
178970 : ROSE_ASSERT(false);
178971 : #endif
178972 : }
178973 : #endif
178974 0 : p_round = round;
178975 0 : }
178976 :
178977 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
178978 :
178979 :
178980 : // End of memberFunctionString
178981 : // Start of memberFunctionString
178982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
178983 :
178984 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
178985 :
178986 : SgExpression*
178987 7 : SgWriteStatement::get_sign () const
178988 : {
178989 7 : ROSE_ASSERT (this != NULL);
178990 :
178991 : #if 0
178992 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
178993 : // used to trigger marking transformations for the token-based unparsing.
178994 : printf ("SgWriteStatement::get_sign = %p = %s \n",this,this->class_name().c_str());
178995 : #endif
178996 :
178997 7 : return p_sign;
178998 : }
178999 :
179000 : void
179001 0 : SgWriteStatement::set_sign ( SgExpression* sign )
179002 : {
179003 0 : ROSE_ASSERT (this != NULL);
179004 :
179005 : #if 0
179006 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179007 : // used to trigger marking transformations for the token-based unparsing.
179008 : printf ("SgWriteStatement::set_sign = %p = %s \n",this,this->class_name().c_str());
179009 : #endif
179010 :
179011 0 : set_isModified(true);
179012 :
179013 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179014 : if (p_sign != NULL && sign != NULL && p_sign != sign)
179015 : {
179016 : printf ("Warning: sign = %p overwriting valid pointer p_sign = %p \n",sign,p_sign);
179017 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179018 : printf ("Error fails assertion (p_sign != NULL && sign != NULL && p_sign != sign) is false\n");
179019 : ROSE_ASSERT(false);
179020 : #endif
179021 : }
179022 : #endif
179023 0 : p_sign = sign;
179024 0 : }
179025 :
179026 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179027 :
179028 :
179029 : // End of memberFunctionString
179030 : // Start of memberFunctionString
179031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179032 :
179033 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179034 :
179035 : SgExpression*
179036 7 : SgWriteStatement::get_size () const
179037 : {
179038 7 : ROSE_ASSERT (this != NULL);
179039 :
179040 : #if 0
179041 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179042 : // used to trigger marking transformations for the token-based unparsing.
179043 : printf ("SgWriteStatement::get_size = %p = %s \n",this,this->class_name().c_str());
179044 : #endif
179045 :
179046 7 : return p_size;
179047 : }
179048 :
179049 : void
179050 0 : SgWriteStatement::set_size ( SgExpression* size )
179051 : {
179052 0 : ROSE_ASSERT (this != NULL);
179053 :
179054 : #if 0
179055 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179056 : // used to trigger marking transformations for the token-based unparsing.
179057 : printf ("SgWriteStatement::set_size = %p = %s \n",this,this->class_name().c_str());
179058 : #endif
179059 :
179060 0 : set_isModified(true);
179061 :
179062 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179063 : if (p_size != NULL && size != NULL && p_size != size)
179064 : {
179065 : printf ("Warning: size = %p overwriting valid pointer p_size = %p \n",size,p_size);
179066 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179067 : printf ("Error fails assertion (p_size != NULL && size != NULL && p_size != size) is false\n");
179068 : ROSE_ASSERT(false);
179069 : #endif
179070 : }
179071 : #endif
179072 0 : p_size = size;
179073 0 : }
179074 :
179075 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179076 :
179077 :
179078 : // End of memberFunctionString
179079 : // Start of memberFunctionString
179080 : /* #line 18387 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
179081 :
179082 :
179083 : void
179084 7 : SgWriteStatement::post_construction_initialization()
179085 7 : {}
179086 :
179087 :
179088 :
179089 : // End of memberFunctionString
179090 : // Start of memberFunctionString
179091 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
179092 :
179093 : // *** COMMON CODE SECTION BEGINS HERE ***
179094 :
179095 : #if 0
179096 : int
179097 : SgWriteStatement::getVariant() const
179098 : {
179099 : // This function is used in ROSE while "variant()" is used in SAGE
179100 : assert(this != NULL);
179101 : return variant();
179102 : }
179103 : #endif
179104 :
179105 : // This function is used in ROSE in treeTraversal code
179106 : // eventually replaces getVariant() and variant()
179107 : // though after variant() has been removed for a while we will
179108 : // want to change the name of variantT() back to variant()
179109 : // (since the "T" was ment to stand for temporary).
179110 : // When this happens the variantT() will be depricated.
179111 : VariantT
179112 1282 : SgWriteStatement::variantT() const
179113 : {
179114 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
179115 1282 : ROSE_ASSERT(this != NULL);
179116 1282 : return V_SgWriteStatement;
179117 : }
179118 :
179119 : #if 0
179120 : int
179121 : SgWriteStatement::variant() const
179122 : {
179123 : // This function is used in SAGE
179124 : ROSE_ASSERT(this != NULL);
179125 : return WRITE_STATEMENT;
179126 : }
179127 : #endif
179128 :
179129 : ROSE_DLL_API const char*
179130 14 : SgWriteStatement::sage_class_name() const
179131 : {
179132 14 : ROSE_ASSERT(this != NULL);
179133 14 : return "SgWriteStatement";
179134 : }
179135 :
179136 : std::string
179137 7 : SgWriteStatement::class_name() const
179138 : {
179139 7 : ROSE_ASSERT(this != NULL);
179140 7 : return "SgWriteStatement";
179141 : }
179142 :
179143 : // DQ (11/26/2005): Support for visitor pattern mechanims
179144 : // (inferior to ROSE traversal mechanism, experimental).
179145 : void
179146 0 : SgWriteStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
179147 : {
179148 0 : ROSE_ASSERT(this != NULL);
179149 0 : visitor.visit(this);
179150 0 : }
179151 :
179152 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
179153 0 : void SgWriteStatement::accept (ROSE_VisitorPattern & visitor) {
179154 0 : ROSE_ASSERT(this != NULL);
179155 0 : visitor.visit(this);
179156 0 : }
179157 :
179158 : SgWriteStatement*
179159 0 : SgWriteStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
179160 : {
179161 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
179162 : // This function is currently only supported for the AST used the represent Binary executables.
179163 : if (0 /* isSgAsmNode(this) != NULL */)
179164 : {
179165 : // Support for regex specification.
179166 : std::string prefixCode = "REGEX:";
179167 : addNewAttribute(prefixCode + s,a);
179168 : }
179169 : #endif
179170 :
179171 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
179172 0 : return this;
179173 : }
179174 :
179175 : // *** COMMON CODE SECTION ENDS HERE ***
179176 :
179177 :
179178 : // End of memberFunctionString
179179 : // Start of memberFunctionString
179180 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
179181 :
179182 :
179183 : #if 0
179184 : //! Error checking support
179185 : /*! Verifies the following:
179186 : - working getVariant() member function
179187 : - calls base class's error() member function
179188 : Every class has one of these functions.
179189 : */
179190 : bool
179191 : SgWriteStatement::error()
179192 : {
179193 : // Put error checking here
179194 :
179195 : ROSE_ASSERT (this != NULL);
179196 : if (getVariant() != WRITE_STATEMENT)
179197 : {
179198 : printf ("Error in SgWriteStatement::error(): SgWriteStatement object has a %s variant \n",
179199 : Cxx_GrammarTerminalNames[getVariant()].name);
179200 : // printf ("Error in SgWriteStatement::error() \n");
179201 : ROSE_ABORT();
179202 : }
179203 :
179204 : ROSE_ASSERT (getVariant() == WRITE_STATEMENT);
179205 : return SgIOStatement::error();
179206 : }
179207 : #endif
179208 :
179209 :
179210 :
179211 : // End of memberFunctionString
179212 :
179213 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
179214 :
179215 21 : SgWriteStatement* isSgWriteStatement ( SgNode* inputDerivedClassPointer )
179216 : {
179217 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
179218 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
179219 : // So to fix this we return NULL directly when the input is NULL and avoid the
179220 : // dynamic_cast in this case. This is likely a performance improvement as well.
179221 : // return dynamic_cast<SgWriteStatement*>(inputDerivedClassPointer);
179222 : // Milind Chabbi (8/28/2013): isSgWriteStatement uses table-driven castability instead of c++ default dynamic_cast
179223 : // this improves the running time performance by 10-20%.
179224 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWriteStatement*>(inputDerivedClassPointer);
179225 21 : return IS_SgWriteStatement_FAST_MACRO(inputDerivedClassPointer);
179226 : }
179227 :
179228 : // DQ (11/8/2003): Added version of functions taking const pointer
179229 0 : const SgWriteStatement* isSgWriteStatement ( const SgNode* inputDerivedClassPointer )
179230 : {
179231 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
179232 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
179233 : // So to fix this we return NULL directly when the input is NULL and avoid the
179234 : // dynamic_cast in this case. This is likely a performance improvement as well.
179235 : // return dynamic_cast<const SgWriteStatement*>(inputDerivedClassPointer);
179236 : // Milind Chabbi (8/28/2013): isSgWriteStatement uses table-driven castability instead of c++ default dynamic_cast
179237 : // this improves the running time performance by 10-20%.
179238 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWriteStatement*>(inputDerivedClassPointer);
179239 0 : return IS_SgWriteStatement_FAST_MACRO(inputDerivedClassPointer);
179240 : }
179241 :
179242 :
179243 :
179244 : /* #line 179245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
179245 :
179246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
179247 :
179248 : /**
179249 : \brief Generated destructor
179250 :
179251 : This destructor is automatically generated (by ROSETTA). This destructor
179252 : only frees memory of data members associated with the parts of the current IR node which
179253 : are NOT traversed. Those data members that are part of a traversal can be freed using
179254 : a traversal (calling this destructor on all children in a post-order traversal). Such
179255 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
179256 :
179257 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
179258 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
179259 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
179260 :
179261 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
179262 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
179263 : pointers are not yet implemented to call delete on eash pointer in the container.
179264 : (This could be done by derivation from the STL containers to define containers that
179265 : automatically deleted their members.)
179266 :
179267 : */
179268 0 : SgWriteStatement::~SgWriteStatement () {
179269 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
179270 :
179271 :
179272 : // case: not a listType for format
179273 0 : p_format = NULL; // non list case
179274 : // case: not a listType for namelist
179275 0 : p_namelist = NULL; // non list case
179276 : // case: not a listType for advance
179277 0 : p_advance = NULL; // non list case
179278 : // case: not a listType for asynchronous
179279 0 : p_asynchronous = NULL; // non list case
179280 : // case: not a listType for blank
179281 0 : p_blank = NULL; // non list case
179282 : // case: not a listType for decimal
179283 0 : p_decimal = NULL; // non list case
179284 : // case: not a listType for delim
179285 0 : p_delim = NULL; // non list case
179286 : // case: not a listType for end
179287 0 : p_end = NULL; // non list case
179288 : // case: not a listType for eor
179289 0 : p_eor = NULL; // non list case
179290 : // case: not a listType for id
179291 0 : p_id = NULL; // non list case
179292 : // case: not a listType for pad
179293 0 : p_pad = NULL; // non list case
179294 : // case: not a listType for pos
179295 0 : p_pos = NULL; // non list case
179296 : // case: not a listType for rec
179297 0 : p_rec = NULL; // non list case
179298 : // case: not a listType for round
179299 0 : p_round = NULL; // non list case
179300 : // case: not a listType for sign
179301 0 : p_sign = NULL; // non list case
179302 : // case: not a listType for size
179303 0 : p_size = NULL; // non list case
179304 :
179305 : }
179306 :
179307 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
179308 0 : }
179309 :
179310 :
179311 : /* #line 179312 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
179312 :
179313 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
179314 :
179315 : // Generated constructor
179316 0 : SgWriteStatement::SgWriteStatement ( Sg_File_Info* startOfConstruct )
179317 0 : : SgIOStatement(startOfConstruct)
179318 : {
179319 : #ifdef DEBUG
179320 : // printf ("In SgWriteStatement::SgWriteStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
179321 : #endif
179322 : #if 0
179323 : // debugging information!
179324 : printf ("In SgWriteStatement::SgWriteStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
179325 : #endif
179326 :
179327 0 : p_format = NULL;
179328 0 : p_namelist = NULL;
179329 0 : p_advance = NULL;
179330 0 : p_asynchronous = NULL;
179331 0 : p_blank = NULL;
179332 0 : p_decimal = NULL;
179333 0 : p_delim = NULL;
179334 0 : p_end = NULL;
179335 0 : p_eor = NULL;
179336 0 : p_id = NULL;
179337 0 : p_pad = NULL;
179338 0 : p_pos = NULL;
179339 0 : p_rec = NULL;
179340 0 : p_round = NULL;
179341 0 : p_sign = NULL;
179342 0 : p_size = NULL;
179343 :
179344 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
179345 :
179346 : #if 0
179347 : // DQ (7/30/2014): Call a virtual function.
179348 : std::string s = this->class_name();
179349 : #endif
179350 :
179351 : // Test the variant virtual function
179352 : // assert(WRITE_STATEMENT == variant());
179353 0 : assert(WRITE_STATEMENT == this->variant());
179354 0 : ROSE_ASSERT(WRITE_STATEMENT == (int)(this->variantT()));
179355 0 : post_construction_initialization();
179356 :
179357 : // Test the isSgWriteStatement() function since it has been problematic
179358 0 : assert(isSgWriteStatement(this) != NULL);
179359 0 : }
179360 :
179361 : // Generated constructor (all data members)
179362 :
179363 : /* #line 179364 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
179364 :
179365 :
179366 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
179367 :
179368 :
179369 : // ********************************************************
179370 : // member functions common across all array grammar objects
179371 : // ********************************************************
179372 :
179373 :
179374 :
179375 : /* #line 179376 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
179376 :
179377 :
179378 :
179379 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
179380 :
179381 : // ********************************************************
179382 : // member functions specific to each node in the grammar
179383 : // ********************************************************
179384 :
179385 :
179386 : /* #line 179387 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
179387 :
179388 : // Start of memberFunctionString
179389 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179390 :
179391 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179392 :
179393 : SgExpression*
179394 0 : SgOpenStatement::get_file () const
179395 : {
179396 0 : ROSE_ASSERT (this != NULL);
179397 :
179398 : #if 0
179399 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179400 : // used to trigger marking transformations for the token-based unparsing.
179401 : printf ("SgOpenStatement::get_file = %p = %s \n",this,this->class_name().c_str());
179402 : #endif
179403 :
179404 0 : return p_file;
179405 : }
179406 :
179407 : void
179408 0 : SgOpenStatement::set_file ( SgExpression* file )
179409 : {
179410 0 : ROSE_ASSERT (this != NULL);
179411 :
179412 : #if 0
179413 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179414 : // used to trigger marking transformations for the token-based unparsing.
179415 : printf ("SgOpenStatement::set_file = %p = %s \n",this,this->class_name().c_str());
179416 : #endif
179417 :
179418 0 : set_isModified(true);
179419 :
179420 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179421 : if (p_file != NULL && file != NULL && p_file != file)
179422 : {
179423 : printf ("Warning: file = %p overwriting valid pointer p_file = %p \n",file,p_file);
179424 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179425 : printf ("Error fails assertion (p_file != NULL && file != NULL && p_file != file) is false\n");
179426 : ROSE_ASSERT(false);
179427 : #endif
179428 : }
179429 : #endif
179430 0 : p_file = file;
179431 0 : }
179432 :
179433 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179434 :
179435 :
179436 : // End of memberFunctionString
179437 : // Start of memberFunctionString
179438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179439 :
179440 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179441 :
179442 : SgExpression*
179443 0 : SgOpenStatement::get_status () const
179444 : {
179445 0 : ROSE_ASSERT (this != NULL);
179446 :
179447 : #if 0
179448 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179449 : // used to trigger marking transformations for the token-based unparsing.
179450 : printf ("SgOpenStatement::get_status = %p = %s \n",this,this->class_name().c_str());
179451 : #endif
179452 :
179453 0 : return p_status;
179454 : }
179455 :
179456 : void
179457 0 : SgOpenStatement::set_status ( SgExpression* status )
179458 : {
179459 0 : ROSE_ASSERT (this != NULL);
179460 :
179461 : #if 0
179462 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179463 : // used to trigger marking transformations for the token-based unparsing.
179464 : printf ("SgOpenStatement::set_status = %p = %s \n",this,this->class_name().c_str());
179465 : #endif
179466 :
179467 0 : set_isModified(true);
179468 :
179469 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179470 : if (p_status != NULL && status != NULL && p_status != status)
179471 : {
179472 : printf ("Warning: status = %p overwriting valid pointer p_status = %p \n",status,p_status);
179473 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179474 : printf ("Error fails assertion (p_status != NULL && status != NULL && p_status != status) is false\n");
179475 : ROSE_ASSERT(false);
179476 : #endif
179477 : }
179478 : #endif
179479 0 : p_status = status;
179480 0 : }
179481 :
179482 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179483 :
179484 :
179485 : // End of memberFunctionString
179486 : // Start of memberFunctionString
179487 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179488 :
179489 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179490 :
179491 : SgExpression*
179492 0 : SgOpenStatement::get_access () const
179493 : {
179494 0 : ROSE_ASSERT (this != NULL);
179495 :
179496 : #if 0
179497 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179498 : // used to trigger marking transformations for the token-based unparsing.
179499 : printf ("SgOpenStatement::get_access = %p = %s \n",this,this->class_name().c_str());
179500 : #endif
179501 :
179502 0 : return p_access;
179503 : }
179504 :
179505 : void
179506 0 : SgOpenStatement::set_access ( SgExpression* access )
179507 : {
179508 0 : ROSE_ASSERT (this != NULL);
179509 :
179510 : #if 0
179511 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179512 : // used to trigger marking transformations for the token-based unparsing.
179513 : printf ("SgOpenStatement::set_access = %p = %s \n",this,this->class_name().c_str());
179514 : #endif
179515 :
179516 0 : set_isModified(true);
179517 :
179518 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179519 : if (p_access != NULL && access != NULL && p_access != access)
179520 : {
179521 : printf ("Warning: access = %p overwriting valid pointer p_access = %p \n",access,p_access);
179522 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179523 : printf ("Error fails assertion (p_access != NULL && access != NULL && p_access != access) is false\n");
179524 : ROSE_ASSERT(false);
179525 : #endif
179526 : }
179527 : #endif
179528 0 : p_access = access;
179529 0 : }
179530 :
179531 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179532 :
179533 :
179534 : // End of memberFunctionString
179535 : // Start of memberFunctionString
179536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179537 :
179538 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179539 :
179540 : SgExpression*
179541 0 : SgOpenStatement::get_form () const
179542 : {
179543 0 : ROSE_ASSERT (this != NULL);
179544 :
179545 : #if 0
179546 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179547 : // used to trigger marking transformations for the token-based unparsing.
179548 : printf ("SgOpenStatement::get_form = %p = %s \n",this,this->class_name().c_str());
179549 : #endif
179550 :
179551 0 : return p_form;
179552 : }
179553 :
179554 : void
179555 0 : SgOpenStatement::set_form ( SgExpression* form )
179556 : {
179557 0 : ROSE_ASSERT (this != NULL);
179558 :
179559 : #if 0
179560 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179561 : // used to trigger marking transformations for the token-based unparsing.
179562 : printf ("SgOpenStatement::set_form = %p = %s \n",this,this->class_name().c_str());
179563 : #endif
179564 :
179565 0 : set_isModified(true);
179566 :
179567 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179568 : if (p_form != NULL && form != NULL && p_form != form)
179569 : {
179570 : printf ("Warning: form = %p overwriting valid pointer p_form = %p \n",form,p_form);
179571 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179572 : printf ("Error fails assertion (p_form != NULL && form != NULL && p_form != form) is false\n");
179573 : ROSE_ASSERT(false);
179574 : #endif
179575 : }
179576 : #endif
179577 0 : p_form = form;
179578 0 : }
179579 :
179580 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179581 :
179582 :
179583 : // End of memberFunctionString
179584 : // Start of memberFunctionString
179585 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179586 :
179587 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179588 :
179589 : SgExpression*
179590 0 : SgOpenStatement::get_recl () const
179591 : {
179592 0 : ROSE_ASSERT (this != NULL);
179593 :
179594 : #if 0
179595 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179596 : // used to trigger marking transformations for the token-based unparsing.
179597 : printf ("SgOpenStatement::get_recl = %p = %s \n",this,this->class_name().c_str());
179598 : #endif
179599 :
179600 0 : return p_recl;
179601 : }
179602 :
179603 : void
179604 0 : SgOpenStatement::set_recl ( SgExpression* recl )
179605 : {
179606 0 : ROSE_ASSERT (this != NULL);
179607 :
179608 : #if 0
179609 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179610 : // used to trigger marking transformations for the token-based unparsing.
179611 : printf ("SgOpenStatement::set_recl = %p = %s \n",this,this->class_name().c_str());
179612 : #endif
179613 :
179614 0 : set_isModified(true);
179615 :
179616 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179617 : if (p_recl != NULL && recl != NULL && p_recl != recl)
179618 : {
179619 : printf ("Warning: recl = %p overwriting valid pointer p_recl = %p \n",recl,p_recl);
179620 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179621 : printf ("Error fails assertion (p_recl != NULL && recl != NULL && p_recl != recl) is false\n");
179622 : ROSE_ASSERT(false);
179623 : #endif
179624 : }
179625 : #endif
179626 0 : p_recl = recl;
179627 0 : }
179628 :
179629 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179630 :
179631 :
179632 : // End of memberFunctionString
179633 : // Start of memberFunctionString
179634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179635 :
179636 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179637 :
179638 : SgExpression*
179639 0 : SgOpenStatement::get_blank () const
179640 : {
179641 0 : ROSE_ASSERT (this != NULL);
179642 :
179643 : #if 0
179644 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179645 : // used to trigger marking transformations for the token-based unparsing.
179646 : printf ("SgOpenStatement::get_blank = %p = %s \n",this,this->class_name().c_str());
179647 : #endif
179648 :
179649 0 : return p_blank;
179650 : }
179651 :
179652 : void
179653 0 : SgOpenStatement::set_blank ( SgExpression* blank )
179654 : {
179655 0 : ROSE_ASSERT (this != NULL);
179656 :
179657 : #if 0
179658 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179659 : // used to trigger marking transformations for the token-based unparsing.
179660 : printf ("SgOpenStatement::set_blank = %p = %s \n",this,this->class_name().c_str());
179661 : #endif
179662 :
179663 0 : set_isModified(true);
179664 :
179665 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179666 : if (p_blank != NULL && blank != NULL && p_blank != blank)
179667 : {
179668 : printf ("Warning: blank = %p overwriting valid pointer p_blank = %p \n",blank,p_blank);
179669 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179670 : printf ("Error fails assertion (p_blank != NULL && blank != NULL && p_blank != blank) is false\n");
179671 : ROSE_ASSERT(false);
179672 : #endif
179673 : }
179674 : #endif
179675 0 : p_blank = blank;
179676 0 : }
179677 :
179678 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179679 :
179680 :
179681 : // End of memberFunctionString
179682 : // Start of memberFunctionString
179683 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179684 :
179685 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179686 :
179687 : SgExpression*
179688 0 : SgOpenStatement::get_position () const
179689 : {
179690 0 : ROSE_ASSERT (this != NULL);
179691 :
179692 : #if 0
179693 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179694 : // used to trigger marking transformations for the token-based unparsing.
179695 : printf ("SgOpenStatement::get_position = %p = %s \n",this,this->class_name().c_str());
179696 : #endif
179697 :
179698 0 : return p_position;
179699 : }
179700 :
179701 : void
179702 0 : SgOpenStatement::set_position ( SgExpression* position )
179703 : {
179704 0 : ROSE_ASSERT (this != NULL);
179705 :
179706 : #if 0
179707 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179708 : // used to trigger marking transformations for the token-based unparsing.
179709 : printf ("SgOpenStatement::set_position = %p = %s \n",this,this->class_name().c_str());
179710 : #endif
179711 :
179712 0 : set_isModified(true);
179713 :
179714 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179715 : if (p_position != NULL && position != NULL && p_position != position)
179716 : {
179717 : printf ("Warning: position = %p overwriting valid pointer p_position = %p \n",position,p_position);
179718 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179719 : printf ("Error fails assertion (p_position != NULL && position != NULL && p_position != position) is false\n");
179720 : ROSE_ASSERT(false);
179721 : #endif
179722 : }
179723 : #endif
179724 0 : p_position = position;
179725 0 : }
179726 :
179727 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179728 :
179729 :
179730 : // End of memberFunctionString
179731 : // Start of memberFunctionString
179732 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179733 :
179734 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179735 :
179736 : SgExpression*
179737 0 : SgOpenStatement::get_action () const
179738 : {
179739 0 : ROSE_ASSERT (this != NULL);
179740 :
179741 : #if 0
179742 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179743 : // used to trigger marking transformations for the token-based unparsing.
179744 : printf ("SgOpenStatement::get_action = %p = %s \n",this,this->class_name().c_str());
179745 : #endif
179746 :
179747 0 : return p_action;
179748 : }
179749 :
179750 : void
179751 0 : SgOpenStatement::set_action ( SgExpression* action )
179752 : {
179753 0 : ROSE_ASSERT (this != NULL);
179754 :
179755 : #if 0
179756 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179757 : // used to trigger marking transformations for the token-based unparsing.
179758 : printf ("SgOpenStatement::set_action = %p = %s \n",this,this->class_name().c_str());
179759 : #endif
179760 :
179761 0 : set_isModified(true);
179762 :
179763 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179764 : if (p_action != NULL && action != NULL && p_action != action)
179765 : {
179766 : printf ("Warning: action = %p overwriting valid pointer p_action = %p \n",action,p_action);
179767 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179768 : printf ("Error fails assertion (p_action != NULL && action != NULL && p_action != action) is false\n");
179769 : ROSE_ASSERT(false);
179770 : #endif
179771 : }
179772 : #endif
179773 0 : p_action = action;
179774 0 : }
179775 :
179776 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179777 :
179778 :
179779 : // End of memberFunctionString
179780 : // Start of memberFunctionString
179781 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179782 :
179783 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179784 :
179785 : SgExpression*
179786 0 : SgOpenStatement::get_delim () const
179787 : {
179788 0 : ROSE_ASSERT (this != NULL);
179789 :
179790 : #if 0
179791 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179792 : // used to trigger marking transformations for the token-based unparsing.
179793 : printf ("SgOpenStatement::get_delim = %p = %s \n",this,this->class_name().c_str());
179794 : #endif
179795 :
179796 0 : return p_delim;
179797 : }
179798 :
179799 : void
179800 0 : SgOpenStatement::set_delim ( SgExpression* delim )
179801 : {
179802 0 : ROSE_ASSERT (this != NULL);
179803 :
179804 : #if 0
179805 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179806 : // used to trigger marking transformations for the token-based unparsing.
179807 : printf ("SgOpenStatement::set_delim = %p = %s \n",this,this->class_name().c_str());
179808 : #endif
179809 :
179810 0 : set_isModified(true);
179811 :
179812 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179813 : if (p_delim != NULL && delim != NULL && p_delim != delim)
179814 : {
179815 : printf ("Warning: delim = %p overwriting valid pointer p_delim = %p \n",delim,p_delim);
179816 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179817 : printf ("Error fails assertion (p_delim != NULL && delim != NULL && p_delim != delim) is false\n");
179818 : ROSE_ASSERT(false);
179819 : #endif
179820 : }
179821 : #endif
179822 0 : p_delim = delim;
179823 0 : }
179824 :
179825 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179826 :
179827 :
179828 : // End of memberFunctionString
179829 : // Start of memberFunctionString
179830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179831 :
179832 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179833 :
179834 : SgExpression*
179835 0 : SgOpenStatement::get_pad () const
179836 : {
179837 0 : ROSE_ASSERT (this != NULL);
179838 :
179839 : #if 0
179840 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179841 : // used to trigger marking transformations for the token-based unparsing.
179842 : printf ("SgOpenStatement::get_pad = %p = %s \n",this,this->class_name().c_str());
179843 : #endif
179844 :
179845 0 : return p_pad;
179846 : }
179847 :
179848 : void
179849 0 : SgOpenStatement::set_pad ( SgExpression* pad )
179850 : {
179851 0 : ROSE_ASSERT (this != NULL);
179852 :
179853 : #if 0
179854 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179855 : // used to trigger marking transformations for the token-based unparsing.
179856 : printf ("SgOpenStatement::set_pad = %p = %s \n",this,this->class_name().c_str());
179857 : #endif
179858 :
179859 0 : set_isModified(true);
179860 :
179861 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179862 : if (p_pad != NULL && pad != NULL && p_pad != pad)
179863 : {
179864 : printf ("Warning: pad = %p overwriting valid pointer p_pad = %p \n",pad,p_pad);
179865 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179866 : printf ("Error fails assertion (p_pad != NULL && pad != NULL && p_pad != pad) is false\n");
179867 : ROSE_ASSERT(false);
179868 : #endif
179869 : }
179870 : #endif
179871 0 : p_pad = pad;
179872 0 : }
179873 :
179874 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179875 :
179876 :
179877 : // End of memberFunctionString
179878 : // Start of memberFunctionString
179879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179880 :
179881 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179882 :
179883 : SgExpression*
179884 0 : SgOpenStatement::get_round () const
179885 : {
179886 0 : ROSE_ASSERT (this != NULL);
179887 :
179888 : #if 0
179889 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179890 : // used to trigger marking transformations for the token-based unparsing.
179891 : printf ("SgOpenStatement::get_round = %p = %s \n",this,this->class_name().c_str());
179892 : #endif
179893 :
179894 0 : return p_round;
179895 : }
179896 :
179897 : void
179898 0 : SgOpenStatement::set_round ( SgExpression* round )
179899 : {
179900 0 : ROSE_ASSERT (this != NULL);
179901 :
179902 : #if 0
179903 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179904 : // used to trigger marking transformations for the token-based unparsing.
179905 : printf ("SgOpenStatement::set_round = %p = %s \n",this,this->class_name().c_str());
179906 : #endif
179907 :
179908 0 : set_isModified(true);
179909 :
179910 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179911 : if (p_round != NULL && round != NULL && p_round != round)
179912 : {
179913 : printf ("Warning: round = %p overwriting valid pointer p_round = %p \n",round,p_round);
179914 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179915 : printf ("Error fails assertion (p_round != NULL && round != NULL && p_round != round) is false\n");
179916 : ROSE_ASSERT(false);
179917 : #endif
179918 : }
179919 : #endif
179920 0 : p_round = round;
179921 0 : }
179922 :
179923 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179924 :
179925 :
179926 : // End of memberFunctionString
179927 : // Start of memberFunctionString
179928 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179929 :
179930 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179931 :
179932 : SgExpression*
179933 0 : SgOpenStatement::get_sign () const
179934 : {
179935 0 : ROSE_ASSERT (this != NULL);
179936 :
179937 : #if 0
179938 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179939 : // used to trigger marking transformations for the token-based unparsing.
179940 : printf ("SgOpenStatement::get_sign = %p = %s \n",this,this->class_name().c_str());
179941 : #endif
179942 :
179943 0 : return p_sign;
179944 : }
179945 :
179946 : void
179947 0 : SgOpenStatement::set_sign ( SgExpression* sign )
179948 : {
179949 0 : ROSE_ASSERT (this != NULL);
179950 :
179951 : #if 0
179952 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179953 : // used to trigger marking transformations for the token-based unparsing.
179954 : printf ("SgOpenStatement::set_sign = %p = %s \n",this,this->class_name().c_str());
179955 : #endif
179956 :
179957 0 : set_isModified(true);
179958 :
179959 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
179960 : if (p_sign != NULL && sign != NULL && p_sign != sign)
179961 : {
179962 : printf ("Warning: sign = %p overwriting valid pointer p_sign = %p \n",sign,p_sign);
179963 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
179964 : printf ("Error fails assertion (p_sign != NULL && sign != NULL && p_sign != sign) is false\n");
179965 : ROSE_ASSERT(false);
179966 : #endif
179967 : }
179968 : #endif
179969 0 : p_sign = sign;
179970 0 : }
179971 :
179972 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
179973 :
179974 :
179975 : // End of memberFunctionString
179976 : // Start of memberFunctionString
179977 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
179978 :
179979 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
179980 :
179981 : SgExpression*
179982 0 : SgOpenStatement::get_asynchronous () const
179983 : {
179984 0 : ROSE_ASSERT (this != NULL);
179985 :
179986 : #if 0
179987 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
179988 : // used to trigger marking transformations for the token-based unparsing.
179989 : printf ("SgOpenStatement::get_asynchronous = %p = %s \n",this,this->class_name().c_str());
179990 : #endif
179991 :
179992 0 : return p_asynchronous;
179993 : }
179994 :
179995 : void
179996 0 : SgOpenStatement::set_asynchronous ( SgExpression* asynchronous )
179997 : {
179998 0 : ROSE_ASSERT (this != NULL);
179999 :
180000 : #if 0
180001 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180002 : // used to trigger marking transformations for the token-based unparsing.
180003 : printf ("SgOpenStatement::set_asynchronous = %p = %s \n",this,this->class_name().c_str());
180004 : #endif
180005 :
180006 0 : set_isModified(true);
180007 :
180008 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180009 : if (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous)
180010 : {
180011 : printf ("Warning: asynchronous = %p overwriting valid pointer p_asynchronous = %p \n",asynchronous,p_asynchronous);
180012 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180013 : printf ("Error fails assertion (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous) is false\n");
180014 : ROSE_ASSERT(false);
180015 : #endif
180016 : }
180017 : #endif
180018 0 : p_asynchronous = asynchronous;
180019 0 : }
180020 :
180021 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180022 :
180023 :
180024 : // End of memberFunctionString
180025 : // Start of memberFunctionString
180026 : /* #line 18396 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
180027 :
180028 :
180029 : void
180030 0 : SgOpenStatement::post_construction_initialization()
180031 0 : {}
180032 :
180033 :
180034 :
180035 : // End of memberFunctionString
180036 : // Start of memberFunctionString
180037 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
180038 :
180039 : // *** COMMON CODE SECTION BEGINS HERE ***
180040 :
180041 : #if 0
180042 : int
180043 : SgOpenStatement::getVariant() const
180044 : {
180045 : // This function is used in ROSE while "variant()" is used in SAGE
180046 : assert(this != NULL);
180047 : return variant();
180048 : }
180049 : #endif
180050 :
180051 : // This function is used in ROSE in treeTraversal code
180052 : // eventually replaces getVariant() and variant()
180053 : // though after variant() has been removed for a while we will
180054 : // want to change the name of variantT() back to variant()
180055 : // (since the "T" was ment to stand for temporary).
180056 : // When this happens the variantT() will be depricated.
180057 : VariantT
180058 0 : SgOpenStatement::variantT() const
180059 : {
180060 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
180061 0 : ROSE_ASSERT(this != NULL);
180062 0 : return V_SgOpenStatement;
180063 : }
180064 :
180065 : #if 0
180066 : int
180067 : SgOpenStatement::variant() const
180068 : {
180069 : // This function is used in SAGE
180070 : ROSE_ASSERT(this != NULL);
180071 : return OPEN_STATEMENT;
180072 : }
180073 : #endif
180074 :
180075 : ROSE_DLL_API const char*
180076 0 : SgOpenStatement::sage_class_name() const
180077 : {
180078 0 : ROSE_ASSERT(this != NULL);
180079 0 : return "SgOpenStatement";
180080 : }
180081 :
180082 : std::string
180083 0 : SgOpenStatement::class_name() const
180084 : {
180085 0 : ROSE_ASSERT(this != NULL);
180086 0 : return "SgOpenStatement";
180087 : }
180088 :
180089 : // DQ (11/26/2005): Support for visitor pattern mechanims
180090 : // (inferior to ROSE traversal mechanism, experimental).
180091 : void
180092 0 : SgOpenStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
180093 : {
180094 0 : ROSE_ASSERT(this != NULL);
180095 0 : visitor.visit(this);
180096 0 : }
180097 :
180098 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
180099 0 : void SgOpenStatement::accept (ROSE_VisitorPattern & visitor) {
180100 0 : ROSE_ASSERT(this != NULL);
180101 0 : visitor.visit(this);
180102 0 : }
180103 :
180104 : SgOpenStatement*
180105 0 : SgOpenStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
180106 : {
180107 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
180108 : // This function is currently only supported for the AST used the represent Binary executables.
180109 : if (0 /* isSgAsmNode(this) != NULL */)
180110 : {
180111 : // Support for regex specification.
180112 : std::string prefixCode = "REGEX:";
180113 : addNewAttribute(prefixCode + s,a);
180114 : }
180115 : #endif
180116 :
180117 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
180118 0 : return this;
180119 : }
180120 :
180121 : // *** COMMON CODE SECTION ENDS HERE ***
180122 :
180123 :
180124 : // End of memberFunctionString
180125 : // Start of memberFunctionString
180126 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
180127 :
180128 :
180129 : #if 0
180130 : //! Error checking support
180131 : /*! Verifies the following:
180132 : - working getVariant() member function
180133 : - calls base class's error() member function
180134 : Every class has one of these functions.
180135 : */
180136 : bool
180137 : SgOpenStatement::error()
180138 : {
180139 : // Put error checking here
180140 :
180141 : ROSE_ASSERT (this != NULL);
180142 : if (getVariant() != OPEN_STATEMENT)
180143 : {
180144 : printf ("Error in SgOpenStatement::error(): SgOpenStatement object has a %s variant \n",
180145 : Cxx_GrammarTerminalNames[getVariant()].name);
180146 : // printf ("Error in SgOpenStatement::error() \n");
180147 : ROSE_ABORT();
180148 : }
180149 :
180150 : ROSE_ASSERT (getVariant() == OPEN_STATEMENT);
180151 : return SgIOStatement::error();
180152 : }
180153 : #endif
180154 :
180155 :
180156 :
180157 : // End of memberFunctionString
180158 :
180159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
180160 :
180161 0 : SgOpenStatement* isSgOpenStatement ( SgNode* inputDerivedClassPointer )
180162 : {
180163 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
180164 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
180165 : // So to fix this we return NULL directly when the input is NULL and avoid the
180166 : // dynamic_cast in this case. This is likely a performance improvement as well.
180167 : // return dynamic_cast<SgOpenStatement*>(inputDerivedClassPointer);
180168 : // Milind Chabbi (8/28/2013): isSgOpenStatement uses table-driven castability instead of c++ default dynamic_cast
180169 : // this improves the running time performance by 10-20%.
180170 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOpenStatement*>(inputDerivedClassPointer);
180171 0 : return IS_SgOpenStatement_FAST_MACRO(inputDerivedClassPointer);
180172 : }
180173 :
180174 : // DQ (11/8/2003): Added version of functions taking const pointer
180175 0 : const SgOpenStatement* isSgOpenStatement ( const SgNode* inputDerivedClassPointer )
180176 : {
180177 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
180178 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
180179 : // So to fix this we return NULL directly when the input is NULL and avoid the
180180 : // dynamic_cast in this case. This is likely a performance improvement as well.
180181 : // return dynamic_cast<const SgOpenStatement*>(inputDerivedClassPointer);
180182 : // Milind Chabbi (8/28/2013): isSgOpenStatement uses table-driven castability instead of c++ default dynamic_cast
180183 : // this improves the running time performance by 10-20%.
180184 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOpenStatement*>(inputDerivedClassPointer);
180185 0 : return IS_SgOpenStatement_FAST_MACRO(inputDerivedClassPointer);
180186 : }
180187 :
180188 :
180189 :
180190 : /* #line 180191 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180191 :
180192 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
180193 :
180194 : /**
180195 : \brief Generated destructor
180196 :
180197 : This destructor is automatically generated (by ROSETTA). This destructor
180198 : only frees memory of data members associated with the parts of the current IR node which
180199 : are NOT traversed. Those data members that are part of a traversal can be freed using
180200 : a traversal (calling this destructor on all children in a post-order traversal). Such
180201 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
180202 :
180203 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
180204 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
180205 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
180206 :
180207 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
180208 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
180209 : pointers are not yet implemented to call delete on eash pointer in the container.
180210 : (This could be done by derivation from the STL containers to define containers that
180211 : automatically deleted their members.)
180212 :
180213 : */
180214 0 : SgOpenStatement::~SgOpenStatement () {
180215 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
180216 :
180217 :
180218 : // case: not a listType for file
180219 0 : p_file = NULL; // non list case
180220 : // case: not a listType for status
180221 0 : p_status = NULL; // non list case
180222 : // case: not a listType for access
180223 0 : p_access = NULL; // non list case
180224 : // case: not a listType for form
180225 0 : p_form = NULL; // non list case
180226 : // case: not a listType for recl
180227 0 : p_recl = NULL; // non list case
180228 : // case: not a listType for blank
180229 0 : p_blank = NULL; // non list case
180230 : // case: not a listType for position
180231 0 : p_position = NULL; // non list case
180232 : // case: not a listType for action
180233 0 : p_action = NULL; // non list case
180234 : // case: not a listType for delim
180235 0 : p_delim = NULL; // non list case
180236 : // case: not a listType for pad
180237 0 : p_pad = NULL; // non list case
180238 : // case: not a listType for round
180239 0 : p_round = NULL; // non list case
180240 : // case: not a listType for sign
180241 0 : p_sign = NULL; // non list case
180242 : // case: not a listType for asynchronous
180243 0 : p_asynchronous = NULL; // non list case
180244 :
180245 : }
180246 :
180247 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
180248 0 : }
180249 :
180250 :
180251 : /* #line 180252 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180252 :
180253 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
180254 :
180255 : // Generated constructor
180256 0 : SgOpenStatement::SgOpenStatement ( Sg_File_Info* startOfConstruct )
180257 0 : : SgIOStatement(startOfConstruct)
180258 : {
180259 : #ifdef DEBUG
180260 : // printf ("In SgOpenStatement::SgOpenStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
180261 : #endif
180262 : #if 0
180263 : // debugging information!
180264 : printf ("In SgOpenStatement::SgOpenStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
180265 : #endif
180266 :
180267 0 : p_file = NULL;
180268 0 : p_status = NULL;
180269 0 : p_access = NULL;
180270 0 : p_form = NULL;
180271 0 : p_recl = NULL;
180272 0 : p_blank = NULL;
180273 0 : p_position = NULL;
180274 0 : p_action = NULL;
180275 0 : p_delim = NULL;
180276 0 : p_pad = NULL;
180277 0 : p_round = NULL;
180278 0 : p_sign = NULL;
180279 0 : p_asynchronous = NULL;
180280 :
180281 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
180282 :
180283 : #if 0
180284 : // DQ (7/30/2014): Call a virtual function.
180285 : std::string s = this->class_name();
180286 : #endif
180287 :
180288 : // Test the variant virtual function
180289 : // assert(OPEN_STATEMENT == variant());
180290 0 : assert(OPEN_STATEMENT == this->variant());
180291 0 : ROSE_ASSERT(OPEN_STATEMENT == (int)(this->variantT()));
180292 0 : post_construction_initialization();
180293 :
180294 : // Test the isSgOpenStatement() function since it has been problematic
180295 0 : assert(isSgOpenStatement(this) != NULL);
180296 0 : }
180297 :
180298 : // Generated constructor (all data members)
180299 :
180300 : /* #line 180301 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180301 :
180302 :
180303 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
180304 :
180305 :
180306 : // ********************************************************
180307 : // member functions common across all array grammar objects
180308 : // ********************************************************
180309 :
180310 :
180311 :
180312 : /* #line 180313 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180313 :
180314 :
180315 :
180316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
180317 :
180318 : // ********************************************************
180319 : // member functions specific to each node in the grammar
180320 : // ********************************************************
180321 :
180322 :
180323 : /* #line 180324 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180324 :
180325 : // Start of memberFunctionString
180326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180327 :
180328 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180329 :
180330 : SgExpression*
180331 0 : SgCloseStatement::get_status () const
180332 : {
180333 0 : ROSE_ASSERT (this != NULL);
180334 :
180335 : #if 0
180336 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180337 : // used to trigger marking transformations for the token-based unparsing.
180338 : printf ("SgCloseStatement::get_status = %p = %s \n",this,this->class_name().c_str());
180339 : #endif
180340 :
180341 0 : return p_status;
180342 : }
180343 :
180344 : void
180345 0 : SgCloseStatement::set_status ( SgExpression* status )
180346 : {
180347 0 : ROSE_ASSERT (this != NULL);
180348 :
180349 : #if 0
180350 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180351 : // used to trigger marking transformations for the token-based unparsing.
180352 : printf ("SgCloseStatement::set_status = %p = %s \n",this,this->class_name().c_str());
180353 : #endif
180354 :
180355 0 : set_isModified(true);
180356 :
180357 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180358 : if (p_status != NULL && status != NULL && p_status != status)
180359 : {
180360 : printf ("Warning: status = %p overwriting valid pointer p_status = %p \n",status,p_status);
180361 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180362 : printf ("Error fails assertion (p_status != NULL && status != NULL && p_status != status) is false\n");
180363 : ROSE_ASSERT(false);
180364 : #endif
180365 : }
180366 : #endif
180367 0 : p_status = status;
180368 0 : }
180369 :
180370 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180371 :
180372 :
180373 : // End of memberFunctionString
180374 : // Start of memberFunctionString
180375 : /* #line 18405 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
180376 :
180377 :
180378 : void
180379 0 : SgCloseStatement::post_construction_initialization()
180380 0 : {}
180381 :
180382 :
180383 :
180384 : // End of memberFunctionString
180385 : // Start of memberFunctionString
180386 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
180387 :
180388 : // *** COMMON CODE SECTION BEGINS HERE ***
180389 :
180390 : #if 0
180391 : int
180392 : SgCloseStatement::getVariant() const
180393 : {
180394 : // This function is used in ROSE while "variant()" is used in SAGE
180395 : assert(this != NULL);
180396 : return variant();
180397 : }
180398 : #endif
180399 :
180400 : // This function is used in ROSE in treeTraversal code
180401 : // eventually replaces getVariant() and variant()
180402 : // though after variant() has been removed for a while we will
180403 : // want to change the name of variantT() back to variant()
180404 : // (since the "T" was ment to stand for temporary).
180405 : // When this happens the variantT() will be depricated.
180406 : VariantT
180407 0 : SgCloseStatement::variantT() const
180408 : {
180409 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
180410 0 : ROSE_ASSERT(this != NULL);
180411 0 : return V_SgCloseStatement;
180412 : }
180413 :
180414 : #if 0
180415 : int
180416 : SgCloseStatement::variant() const
180417 : {
180418 : // This function is used in SAGE
180419 : ROSE_ASSERT(this != NULL);
180420 : return CLOSE_STATEMENT;
180421 : }
180422 : #endif
180423 :
180424 : ROSE_DLL_API const char*
180425 0 : SgCloseStatement::sage_class_name() const
180426 : {
180427 0 : ROSE_ASSERT(this != NULL);
180428 0 : return "SgCloseStatement";
180429 : }
180430 :
180431 : std::string
180432 0 : SgCloseStatement::class_name() const
180433 : {
180434 0 : ROSE_ASSERT(this != NULL);
180435 0 : return "SgCloseStatement";
180436 : }
180437 :
180438 : // DQ (11/26/2005): Support for visitor pattern mechanims
180439 : // (inferior to ROSE traversal mechanism, experimental).
180440 : void
180441 0 : SgCloseStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
180442 : {
180443 0 : ROSE_ASSERT(this != NULL);
180444 0 : visitor.visit(this);
180445 0 : }
180446 :
180447 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
180448 0 : void SgCloseStatement::accept (ROSE_VisitorPattern & visitor) {
180449 0 : ROSE_ASSERT(this != NULL);
180450 0 : visitor.visit(this);
180451 0 : }
180452 :
180453 : SgCloseStatement*
180454 0 : SgCloseStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
180455 : {
180456 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
180457 : // This function is currently only supported for the AST used the represent Binary executables.
180458 : if (0 /* isSgAsmNode(this) != NULL */)
180459 : {
180460 : // Support for regex specification.
180461 : std::string prefixCode = "REGEX:";
180462 : addNewAttribute(prefixCode + s,a);
180463 : }
180464 : #endif
180465 :
180466 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
180467 0 : return this;
180468 : }
180469 :
180470 : // *** COMMON CODE SECTION ENDS HERE ***
180471 :
180472 :
180473 : // End of memberFunctionString
180474 : // Start of memberFunctionString
180475 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
180476 :
180477 :
180478 : #if 0
180479 : //! Error checking support
180480 : /*! Verifies the following:
180481 : - working getVariant() member function
180482 : - calls base class's error() member function
180483 : Every class has one of these functions.
180484 : */
180485 : bool
180486 : SgCloseStatement::error()
180487 : {
180488 : // Put error checking here
180489 :
180490 : ROSE_ASSERT (this != NULL);
180491 : if (getVariant() != CLOSE_STATEMENT)
180492 : {
180493 : printf ("Error in SgCloseStatement::error(): SgCloseStatement object has a %s variant \n",
180494 : Cxx_GrammarTerminalNames[getVariant()].name);
180495 : // printf ("Error in SgCloseStatement::error() \n");
180496 : ROSE_ABORT();
180497 : }
180498 :
180499 : ROSE_ASSERT (getVariant() == CLOSE_STATEMENT);
180500 : return SgIOStatement::error();
180501 : }
180502 : #endif
180503 :
180504 :
180505 :
180506 : // End of memberFunctionString
180507 :
180508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
180509 :
180510 0 : SgCloseStatement* isSgCloseStatement ( SgNode* inputDerivedClassPointer )
180511 : {
180512 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
180513 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
180514 : // So to fix this we return NULL directly when the input is NULL and avoid the
180515 : // dynamic_cast in this case. This is likely a performance improvement as well.
180516 : // return dynamic_cast<SgCloseStatement*>(inputDerivedClassPointer);
180517 : // Milind Chabbi (8/28/2013): isSgCloseStatement uses table-driven castability instead of c++ default dynamic_cast
180518 : // this improves the running time performance by 10-20%.
180519 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCloseStatement*>(inputDerivedClassPointer);
180520 0 : return IS_SgCloseStatement_FAST_MACRO(inputDerivedClassPointer);
180521 : }
180522 :
180523 : // DQ (11/8/2003): Added version of functions taking const pointer
180524 0 : const SgCloseStatement* isSgCloseStatement ( const SgNode* inputDerivedClassPointer )
180525 : {
180526 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
180527 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
180528 : // So to fix this we return NULL directly when the input is NULL and avoid the
180529 : // dynamic_cast in this case. This is likely a performance improvement as well.
180530 : // return dynamic_cast<const SgCloseStatement*>(inputDerivedClassPointer);
180531 : // Milind Chabbi (8/28/2013): isSgCloseStatement uses table-driven castability instead of c++ default dynamic_cast
180532 : // this improves the running time performance by 10-20%.
180533 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCloseStatement*>(inputDerivedClassPointer);
180534 0 : return IS_SgCloseStatement_FAST_MACRO(inputDerivedClassPointer);
180535 : }
180536 :
180537 :
180538 :
180539 : /* #line 180540 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180540 :
180541 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
180542 :
180543 : /**
180544 : \brief Generated destructor
180545 :
180546 : This destructor is automatically generated (by ROSETTA). This destructor
180547 : only frees memory of data members associated with the parts of the current IR node which
180548 : are NOT traversed. Those data members that are part of a traversal can be freed using
180549 : a traversal (calling this destructor on all children in a post-order traversal). Such
180550 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
180551 :
180552 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
180553 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
180554 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
180555 :
180556 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
180557 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
180558 : pointers are not yet implemented to call delete on eash pointer in the container.
180559 : (This could be done by derivation from the STL containers to define containers that
180560 : automatically deleted their members.)
180561 :
180562 : */
180563 0 : SgCloseStatement::~SgCloseStatement () {
180564 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
180565 :
180566 :
180567 : // case: not a listType for status
180568 0 : p_status = NULL; // non list case
180569 :
180570 : }
180571 :
180572 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
180573 0 : }
180574 :
180575 :
180576 : /* #line 180577 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180577 :
180578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
180579 :
180580 : // Generated constructor
180581 0 : SgCloseStatement::SgCloseStatement ( Sg_File_Info* startOfConstruct )
180582 0 : : SgIOStatement(startOfConstruct)
180583 : {
180584 : #ifdef DEBUG
180585 : // printf ("In SgCloseStatement::SgCloseStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
180586 : #endif
180587 : #if 0
180588 : // debugging information!
180589 : printf ("In SgCloseStatement::SgCloseStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
180590 : #endif
180591 :
180592 0 : p_status = NULL;
180593 :
180594 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
180595 :
180596 : #if 0
180597 : // DQ (7/30/2014): Call a virtual function.
180598 : std::string s = this->class_name();
180599 : #endif
180600 :
180601 : // Test the variant virtual function
180602 : // assert(CLOSE_STATEMENT == variant());
180603 0 : assert(CLOSE_STATEMENT == this->variant());
180604 0 : ROSE_ASSERT(CLOSE_STATEMENT == (int)(this->variantT()));
180605 0 : post_construction_initialization();
180606 :
180607 : // Test the isSgCloseStatement() function since it has been problematic
180608 0 : assert(isSgCloseStatement(this) != NULL);
180609 0 : }
180610 :
180611 : // Generated constructor (all data members)
180612 :
180613 : /* #line 180614 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180614 :
180615 :
180616 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
180617 :
180618 :
180619 : // ********************************************************
180620 : // member functions common across all array grammar objects
180621 : // ********************************************************
180622 :
180623 :
180624 :
180625 : /* #line 180626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180626 :
180627 :
180628 :
180629 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
180630 :
180631 : // ********************************************************
180632 : // member functions specific to each node in the grammar
180633 : // ********************************************************
180634 :
180635 :
180636 : /* #line 180637 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
180637 :
180638 : // Start of memberFunctionString
180639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180640 :
180641 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180642 :
180643 : SgExpression*
180644 0 : SgInquireStatement::get_file () const
180645 : {
180646 0 : ROSE_ASSERT (this != NULL);
180647 :
180648 : #if 0
180649 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180650 : // used to trigger marking transformations for the token-based unparsing.
180651 : printf ("SgInquireStatement::get_file = %p = %s \n",this,this->class_name().c_str());
180652 : #endif
180653 :
180654 0 : return p_file;
180655 : }
180656 :
180657 : void
180658 0 : SgInquireStatement::set_file ( SgExpression* file )
180659 : {
180660 0 : ROSE_ASSERT (this != NULL);
180661 :
180662 : #if 0
180663 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180664 : // used to trigger marking transformations for the token-based unparsing.
180665 : printf ("SgInquireStatement::set_file = %p = %s \n",this,this->class_name().c_str());
180666 : #endif
180667 :
180668 0 : set_isModified(true);
180669 :
180670 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180671 : if (p_file != NULL && file != NULL && p_file != file)
180672 : {
180673 : printf ("Warning: file = %p overwriting valid pointer p_file = %p \n",file,p_file);
180674 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180675 : printf ("Error fails assertion (p_file != NULL && file != NULL && p_file != file) is false\n");
180676 : ROSE_ASSERT(false);
180677 : #endif
180678 : }
180679 : #endif
180680 0 : p_file = file;
180681 0 : }
180682 :
180683 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180684 :
180685 :
180686 : // End of memberFunctionString
180687 : // Start of memberFunctionString
180688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180689 :
180690 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180691 :
180692 : SgExpression*
180693 0 : SgInquireStatement::get_access () const
180694 : {
180695 0 : ROSE_ASSERT (this != NULL);
180696 :
180697 : #if 0
180698 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180699 : // used to trigger marking transformations for the token-based unparsing.
180700 : printf ("SgInquireStatement::get_access = %p = %s \n",this,this->class_name().c_str());
180701 : #endif
180702 :
180703 0 : return p_access;
180704 : }
180705 :
180706 : void
180707 0 : SgInquireStatement::set_access ( SgExpression* access )
180708 : {
180709 0 : ROSE_ASSERT (this != NULL);
180710 :
180711 : #if 0
180712 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180713 : // used to trigger marking transformations for the token-based unparsing.
180714 : printf ("SgInquireStatement::set_access = %p = %s \n",this,this->class_name().c_str());
180715 : #endif
180716 :
180717 0 : set_isModified(true);
180718 :
180719 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180720 : if (p_access != NULL && access != NULL && p_access != access)
180721 : {
180722 : printf ("Warning: access = %p overwriting valid pointer p_access = %p \n",access,p_access);
180723 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180724 : printf ("Error fails assertion (p_access != NULL && access != NULL && p_access != access) is false\n");
180725 : ROSE_ASSERT(false);
180726 : #endif
180727 : }
180728 : #endif
180729 0 : p_access = access;
180730 0 : }
180731 :
180732 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180733 :
180734 :
180735 : // End of memberFunctionString
180736 : // Start of memberFunctionString
180737 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180738 :
180739 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180740 :
180741 : SgExpression*
180742 0 : SgInquireStatement::get_form () const
180743 : {
180744 0 : ROSE_ASSERT (this != NULL);
180745 :
180746 : #if 0
180747 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180748 : // used to trigger marking transformations for the token-based unparsing.
180749 : printf ("SgInquireStatement::get_form = %p = %s \n",this,this->class_name().c_str());
180750 : #endif
180751 :
180752 0 : return p_form;
180753 : }
180754 :
180755 : void
180756 0 : SgInquireStatement::set_form ( SgExpression* form )
180757 : {
180758 0 : ROSE_ASSERT (this != NULL);
180759 :
180760 : #if 0
180761 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180762 : // used to trigger marking transformations for the token-based unparsing.
180763 : printf ("SgInquireStatement::set_form = %p = %s \n",this,this->class_name().c_str());
180764 : #endif
180765 :
180766 0 : set_isModified(true);
180767 :
180768 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180769 : if (p_form != NULL && form != NULL && p_form != form)
180770 : {
180771 : printf ("Warning: form = %p overwriting valid pointer p_form = %p \n",form,p_form);
180772 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180773 : printf ("Error fails assertion (p_form != NULL && form != NULL && p_form != form) is false\n");
180774 : ROSE_ASSERT(false);
180775 : #endif
180776 : }
180777 : #endif
180778 0 : p_form = form;
180779 0 : }
180780 :
180781 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180782 :
180783 :
180784 : // End of memberFunctionString
180785 : // Start of memberFunctionString
180786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180787 :
180788 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180789 :
180790 : SgExpression*
180791 0 : SgInquireStatement::get_recl () const
180792 : {
180793 0 : ROSE_ASSERT (this != NULL);
180794 :
180795 : #if 0
180796 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180797 : // used to trigger marking transformations for the token-based unparsing.
180798 : printf ("SgInquireStatement::get_recl = %p = %s \n",this,this->class_name().c_str());
180799 : #endif
180800 :
180801 0 : return p_recl;
180802 : }
180803 :
180804 : void
180805 0 : SgInquireStatement::set_recl ( SgExpression* recl )
180806 : {
180807 0 : ROSE_ASSERT (this != NULL);
180808 :
180809 : #if 0
180810 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180811 : // used to trigger marking transformations for the token-based unparsing.
180812 : printf ("SgInquireStatement::set_recl = %p = %s \n",this,this->class_name().c_str());
180813 : #endif
180814 :
180815 0 : set_isModified(true);
180816 :
180817 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180818 : if (p_recl != NULL && recl != NULL && p_recl != recl)
180819 : {
180820 : printf ("Warning: recl = %p overwriting valid pointer p_recl = %p \n",recl,p_recl);
180821 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180822 : printf ("Error fails assertion (p_recl != NULL && recl != NULL && p_recl != recl) is false\n");
180823 : ROSE_ASSERT(false);
180824 : #endif
180825 : }
180826 : #endif
180827 0 : p_recl = recl;
180828 0 : }
180829 :
180830 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180831 :
180832 :
180833 : // End of memberFunctionString
180834 : // Start of memberFunctionString
180835 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180836 :
180837 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180838 :
180839 : SgExpression*
180840 0 : SgInquireStatement::get_blank () const
180841 : {
180842 0 : ROSE_ASSERT (this != NULL);
180843 :
180844 : #if 0
180845 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180846 : // used to trigger marking transformations for the token-based unparsing.
180847 : printf ("SgInquireStatement::get_blank = %p = %s \n",this,this->class_name().c_str());
180848 : #endif
180849 :
180850 0 : return p_blank;
180851 : }
180852 :
180853 : void
180854 0 : SgInquireStatement::set_blank ( SgExpression* blank )
180855 : {
180856 0 : ROSE_ASSERT (this != NULL);
180857 :
180858 : #if 0
180859 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180860 : // used to trigger marking transformations for the token-based unparsing.
180861 : printf ("SgInquireStatement::set_blank = %p = %s \n",this,this->class_name().c_str());
180862 : #endif
180863 :
180864 0 : set_isModified(true);
180865 :
180866 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180867 : if (p_blank != NULL && blank != NULL && p_blank != blank)
180868 : {
180869 : printf ("Warning: blank = %p overwriting valid pointer p_blank = %p \n",blank,p_blank);
180870 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180871 : printf ("Error fails assertion (p_blank != NULL && blank != NULL && p_blank != blank) is false\n");
180872 : ROSE_ASSERT(false);
180873 : #endif
180874 : }
180875 : #endif
180876 0 : p_blank = blank;
180877 0 : }
180878 :
180879 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180880 :
180881 :
180882 : // End of memberFunctionString
180883 : // Start of memberFunctionString
180884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180885 :
180886 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180887 :
180888 : SgExpression*
180889 0 : SgInquireStatement::get_exist () const
180890 : {
180891 0 : ROSE_ASSERT (this != NULL);
180892 :
180893 : #if 0
180894 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180895 : // used to trigger marking transformations for the token-based unparsing.
180896 : printf ("SgInquireStatement::get_exist = %p = %s \n",this,this->class_name().c_str());
180897 : #endif
180898 :
180899 0 : return p_exist;
180900 : }
180901 :
180902 : void
180903 0 : SgInquireStatement::set_exist ( SgExpression* exist )
180904 : {
180905 0 : ROSE_ASSERT (this != NULL);
180906 :
180907 : #if 0
180908 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180909 : // used to trigger marking transformations for the token-based unparsing.
180910 : printf ("SgInquireStatement::set_exist = %p = %s \n",this,this->class_name().c_str());
180911 : #endif
180912 :
180913 0 : set_isModified(true);
180914 :
180915 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180916 : if (p_exist != NULL && exist != NULL && p_exist != exist)
180917 : {
180918 : printf ("Warning: exist = %p overwriting valid pointer p_exist = %p \n",exist,p_exist);
180919 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180920 : printf ("Error fails assertion (p_exist != NULL && exist != NULL && p_exist != exist) is false\n");
180921 : ROSE_ASSERT(false);
180922 : #endif
180923 : }
180924 : #endif
180925 0 : p_exist = exist;
180926 0 : }
180927 :
180928 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180929 :
180930 :
180931 : // End of memberFunctionString
180932 : // Start of memberFunctionString
180933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180934 :
180935 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180936 :
180937 : SgExpression*
180938 0 : SgInquireStatement::get_opened () const
180939 : {
180940 0 : ROSE_ASSERT (this != NULL);
180941 :
180942 : #if 0
180943 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180944 : // used to trigger marking transformations for the token-based unparsing.
180945 : printf ("SgInquireStatement::get_opened = %p = %s \n",this,this->class_name().c_str());
180946 : #endif
180947 :
180948 0 : return p_opened;
180949 : }
180950 :
180951 : void
180952 0 : SgInquireStatement::set_opened ( SgExpression* opened )
180953 : {
180954 0 : ROSE_ASSERT (this != NULL);
180955 :
180956 : #if 0
180957 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180958 : // used to trigger marking transformations for the token-based unparsing.
180959 : printf ("SgInquireStatement::set_opened = %p = %s \n",this,this->class_name().c_str());
180960 : #endif
180961 :
180962 0 : set_isModified(true);
180963 :
180964 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
180965 : if (p_opened != NULL && opened != NULL && p_opened != opened)
180966 : {
180967 : printf ("Warning: opened = %p overwriting valid pointer p_opened = %p \n",opened,p_opened);
180968 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
180969 : printf ("Error fails assertion (p_opened != NULL && opened != NULL && p_opened != opened) is false\n");
180970 : ROSE_ASSERT(false);
180971 : #endif
180972 : }
180973 : #endif
180974 0 : p_opened = opened;
180975 0 : }
180976 :
180977 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
180978 :
180979 :
180980 : // End of memberFunctionString
180981 : // Start of memberFunctionString
180982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
180983 :
180984 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
180985 :
180986 : SgExpression*
180987 0 : SgInquireStatement::get_number () const
180988 : {
180989 0 : ROSE_ASSERT (this != NULL);
180990 :
180991 : #if 0
180992 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
180993 : // used to trigger marking transformations for the token-based unparsing.
180994 : printf ("SgInquireStatement::get_number = %p = %s \n",this,this->class_name().c_str());
180995 : #endif
180996 :
180997 0 : return p_number;
180998 : }
180999 :
181000 : void
181001 0 : SgInquireStatement::set_number ( SgExpression* number )
181002 : {
181003 0 : ROSE_ASSERT (this != NULL);
181004 :
181005 : #if 0
181006 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181007 : // used to trigger marking transformations for the token-based unparsing.
181008 : printf ("SgInquireStatement::set_number = %p = %s \n",this,this->class_name().c_str());
181009 : #endif
181010 :
181011 0 : set_isModified(true);
181012 :
181013 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181014 : if (p_number != NULL && number != NULL && p_number != number)
181015 : {
181016 : printf ("Warning: number = %p overwriting valid pointer p_number = %p \n",number,p_number);
181017 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181018 : printf ("Error fails assertion (p_number != NULL && number != NULL && p_number != number) is false\n");
181019 : ROSE_ASSERT(false);
181020 : #endif
181021 : }
181022 : #endif
181023 0 : p_number = number;
181024 0 : }
181025 :
181026 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181027 :
181028 :
181029 : // End of memberFunctionString
181030 : // Start of memberFunctionString
181031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181032 :
181033 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181034 :
181035 : SgExpression*
181036 0 : SgInquireStatement::get_named () const
181037 : {
181038 0 : ROSE_ASSERT (this != NULL);
181039 :
181040 : #if 0
181041 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181042 : // used to trigger marking transformations for the token-based unparsing.
181043 : printf ("SgInquireStatement::get_named = %p = %s \n",this,this->class_name().c_str());
181044 : #endif
181045 :
181046 0 : return p_named;
181047 : }
181048 :
181049 : void
181050 0 : SgInquireStatement::set_named ( SgExpression* named )
181051 : {
181052 0 : ROSE_ASSERT (this != NULL);
181053 :
181054 : #if 0
181055 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181056 : // used to trigger marking transformations for the token-based unparsing.
181057 : printf ("SgInquireStatement::set_named = %p = %s \n",this,this->class_name().c_str());
181058 : #endif
181059 :
181060 0 : set_isModified(true);
181061 :
181062 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181063 : if (p_named != NULL && named != NULL && p_named != named)
181064 : {
181065 : printf ("Warning: named = %p overwriting valid pointer p_named = %p \n",named,p_named);
181066 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181067 : printf ("Error fails assertion (p_named != NULL && named != NULL && p_named != named) is false\n");
181068 : ROSE_ASSERT(false);
181069 : #endif
181070 : }
181071 : #endif
181072 0 : p_named = named;
181073 0 : }
181074 :
181075 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181076 :
181077 :
181078 : // End of memberFunctionString
181079 : // Start of memberFunctionString
181080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181081 :
181082 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181083 :
181084 : SgExpression*
181085 0 : SgInquireStatement::get_name () const
181086 : {
181087 0 : ROSE_ASSERT (this != NULL);
181088 :
181089 : #if 0
181090 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181091 : // used to trigger marking transformations for the token-based unparsing.
181092 : printf ("SgInquireStatement::get_name = %p = %s \n",this,this->class_name().c_str());
181093 : #endif
181094 :
181095 0 : return p_name;
181096 : }
181097 :
181098 : void
181099 0 : SgInquireStatement::set_name ( SgExpression* name )
181100 : {
181101 0 : ROSE_ASSERT (this != NULL);
181102 :
181103 : #if 0
181104 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181105 : // used to trigger marking transformations for the token-based unparsing.
181106 : printf ("SgInquireStatement::set_name = %p = %s \n",this,this->class_name().c_str());
181107 : #endif
181108 :
181109 0 : set_isModified(true);
181110 :
181111 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181112 : if (p_name != NULL && name != NULL && p_name != name)
181113 : {
181114 : printf ("Warning: name = %p overwriting valid pointer p_name = %p \n",name,p_name);
181115 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181116 : printf ("Error fails assertion (p_name != NULL && name != NULL && p_name != name) is false\n");
181117 : ROSE_ASSERT(false);
181118 : #endif
181119 : }
181120 : #endif
181121 0 : p_name = name;
181122 0 : }
181123 :
181124 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181125 :
181126 :
181127 : // End of memberFunctionString
181128 : // Start of memberFunctionString
181129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181130 :
181131 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181132 :
181133 : SgExpression*
181134 0 : SgInquireStatement::get_sequential () const
181135 : {
181136 0 : ROSE_ASSERT (this != NULL);
181137 :
181138 : #if 0
181139 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181140 : // used to trigger marking transformations for the token-based unparsing.
181141 : printf ("SgInquireStatement::get_sequential = %p = %s \n",this,this->class_name().c_str());
181142 : #endif
181143 :
181144 0 : return p_sequential;
181145 : }
181146 :
181147 : void
181148 0 : SgInquireStatement::set_sequential ( SgExpression* sequential )
181149 : {
181150 0 : ROSE_ASSERT (this != NULL);
181151 :
181152 : #if 0
181153 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181154 : // used to trigger marking transformations for the token-based unparsing.
181155 : printf ("SgInquireStatement::set_sequential = %p = %s \n",this,this->class_name().c_str());
181156 : #endif
181157 :
181158 0 : set_isModified(true);
181159 :
181160 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181161 : if (p_sequential != NULL && sequential != NULL && p_sequential != sequential)
181162 : {
181163 : printf ("Warning: sequential = %p overwriting valid pointer p_sequential = %p \n",sequential,p_sequential);
181164 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181165 : printf ("Error fails assertion (p_sequential != NULL && sequential != NULL && p_sequential != sequential) is false\n");
181166 : ROSE_ASSERT(false);
181167 : #endif
181168 : }
181169 : #endif
181170 0 : p_sequential = sequential;
181171 0 : }
181172 :
181173 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181174 :
181175 :
181176 : // End of memberFunctionString
181177 : // Start of memberFunctionString
181178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181179 :
181180 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181181 :
181182 : SgExpression*
181183 0 : SgInquireStatement::get_direct () const
181184 : {
181185 0 : ROSE_ASSERT (this != NULL);
181186 :
181187 : #if 0
181188 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181189 : // used to trigger marking transformations for the token-based unparsing.
181190 : printf ("SgInquireStatement::get_direct = %p = %s \n",this,this->class_name().c_str());
181191 : #endif
181192 :
181193 0 : return p_direct;
181194 : }
181195 :
181196 : void
181197 0 : SgInquireStatement::set_direct ( SgExpression* direct )
181198 : {
181199 0 : ROSE_ASSERT (this != NULL);
181200 :
181201 : #if 0
181202 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181203 : // used to trigger marking transformations for the token-based unparsing.
181204 : printf ("SgInquireStatement::set_direct = %p = %s \n",this,this->class_name().c_str());
181205 : #endif
181206 :
181207 0 : set_isModified(true);
181208 :
181209 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181210 : if (p_direct != NULL && direct != NULL && p_direct != direct)
181211 : {
181212 : printf ("Warning: direct = %p overwriting valid pointer p_direct = %p \n",direct,p_direct);
181213 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181214 : printf ("Error fails assertion (p_direct != NULL && direct != NULL && p_direct != direct) is false\n");
181215 : ROSE_ASSERT(false);
181216 : #endif
181217 : }
181218 : #endif
181219 0 : p_direct = direct;
181220 0 : }
181221 :
181222 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181223 :
181224 :
181225 : // End of memberFunctionString
181226 : // Start of memberFunctionString
181227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181228 :
181229 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181230 :
181231 : SgExpression*
181232 0 : SgInquireStatement::get_formatted () const
181233 : {
181234 0 : ROSE_ASSERT (this != NULL);
181235 :
181236 : #if 0
181237 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181238 : // used to trigger marking transformations for the token-based unparsing.
181239 : printf ("SgInquireStatement::get_formatted = %p = %s \n",this,this->class_name().c_str());
181240 : #endif
181241 :
181242 0 : return p_formatted;
181243 : }
181244 :
181245 : void
181246 0 : SgInquireStatement::set_formatted ( SgExpression* formatted )
181247 : {
181248 0 : ROSE_ASSERT (this != NULL);
181249 :
181250 : #if 0
181251 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181252 : // used to trigger marking transformations for the token-based unparsing.
181253 : printf ("SgInquireStatement::set_formatted = %p = %s \n",this,this->class_name().c_str());
181254 : #endif
181255 :
181256 0 : set_isModified(true);
181257 :
181258 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181259 : if (p_formatted != NULL && formatted != NULL && p_formatted != formatted)
181260 : {
181261 : printf ("Warning: formatted = %p overwriting valid pointer p_formatted = %p \n",formatted,p_formatted);
181262 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181263 : printf ("Error fails assertion (p_formatted != NULL && formatted != NULL && p_formatted != formatted) is false\n");
181264 : ROSE_ASSERT(false);
181265 : #endif
181266 : }
181267 : #endif
181268 0 : p_formatted = formatted;
181269 0 : }
181270 :
181271 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181272 :
181273 :
181274 : // End of memberFunctionString
181275 : // Start of memberFunctionString
181276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181277 :
181278 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181279 :
181280 : SgExpression*
181281 0 : SgInquireStatement::get_unformatted () const
181282 : {
181283 0 : ROSE_ASSERT (this != NULL);
181284 :
181285 : #if 0
181286 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181287 : // used to trigger marking transformations for the token-based unparsing.
181288 : printf ("SgInquireStatement::get_unformatted = %p = %s \n",this,this->class_name().c_str());
181289 : #endif
181290 :
181291 0 : return p_unformatted;
181292 : }
181293 :
181294 : void
181295 0 : SgInquireStatement::set_unformatted ( SgExpression* unformatted )
181296 : {
181297 0 : ROSE_ASSERT (this != NULL);
181298 :
181299 : #if 0
181300 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181301 : // used to trigger marking transformations for the token-based unparsing.
181302 : printf ("SgInquireStatement::set_unformatted = %p = %s \n",this,this->class_name().c_str());
181303 : #endif
181304 :
181305 0 : set_isModified(true);
181306 :
181307 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181308 : if (p_unformatted != NULL && unformatted != NULL && p_unformatted != unformatted)
181309 : {
181310 : printf ("Warning: unformatted = %p overwriting valid pointer p_unformatted = %p \n",unformatted,p_unformatted);
181311 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181312 : printf ("Error fails assertion (p_unformatted != NULL && unformatted != NULL && p_unformatted != unformatted) is false\n");
181313 : ROSE_ASSERT(false);
181314 : #endif
181315 : }
181316 : #endif
181317 0 : p_unformatted = unformatted;
181318 0 : }
181319 :
181320 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181321 :
181322 :
181323 : // End of memberFunctionString
181324 : // Start of memberFunctionString
181325 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181326 :
181327 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181328 :
181329 : SgExpression*
181330 0 : SgInquireStatement::get_nextrec () const
181331 : {
181332 0 : ROSE_ASSERT (this != NULL);
181333 :
181334 : #if 0
181335 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181336 : // used to trigger marking transformations for the token-based unparsing.
181337 : printf ("SgInquireStatement::get_nextrec = %p = %s \n",this,this->class_name().c_str());
181338 : #endif
181339 :
181340 0 : return p_nextrec;
181341 : }
181342 :
181343 : void
181344 0 : SgInquireStatement::set_nextrec ( SgExpression* nextrec )
181345 : {
181346 0 : ROSE_ASSERT (this != NULL);
181347 :
181348 : #if 0
181349 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181350 : // used to trigger marking transformations for the token-based unparsing.
181351 : printf ("SgInquireStatement::set_nextrec = %p = %s \n",this,this->class_name().c_str());
181352 : #endif
181353 :
181354 0 : set_isModified(true);
181355 :
181356 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181357 : if (p_nextrec != NULL && nextrec != NULL && p_nextrec != nextrec)
181358 : {
181359 : printf ("Warning: nextrec = %p overwriting valid pointer p_nextrec = %p \n",nextrec,p_nextrec);
181360 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181361 : printf ("Error fails assertion (p_nextrec != NULL && nextrec != NULL && p_nextrec != nextrec) is false\n");
181362 : ROSE_ASSERT(false);
181363 : #endif
181364 : }
181365 : #endif
181366 0 : p_nextrec = nextrec;
181367 0 : }
181368 :
181369 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181370 :
181371 :
181372 : // End of memberFunctionString
181373 : // Start of memberFunctionString
181374 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181375 :
181376 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181377 :
181378 : SgExpression*
181379 0 : SgInquireStatement::get_position () const
181380 : {
181381 0 : ROSE_ASSERT (this != NULL);
181382 :
181383 : #if 0
181384 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181385 : // used to trigger marking transformations for the token-based unparsing.
181386 : printf ("SgInquireStatement::get_position = %p = %s \n",this,this->class_name().c_str());
181387 : #endif
181388 :
181389 0 : return p_position;
181390 : }
181391 :
181392 : void
181393 0 : SgInquireStatement::set_position ( SgExpression* position )
181394 : {
181395 0 : ROSE_ASSERT (this != NULL);
181396 :
181397 : #if 0
181398 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181399 : // used to trigger marking transformations for the token-based unparsing.
181400 : printf ("SgInquireStatement::set_position = %p = %s \n",this,this->class_name().c_str());
181401 : #endif
181402 :
181403 0 : set_isModified(true);
181404 :
181405 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181406 : if (p_position != NULL && position != NULL && p_position != position)
181407 : {
181408 : printf ("Warning: position = %p overwriting valid pointer p_position = %p \n",position,p_position);
181409 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181410 : printf ("Error fails assertion (p_position != NULL && position != NULL && p_position != position) is false\n");
181411 : ROSE_ASSERT(false);
181412 : #endif
181413 : }
181414 : #endif
181415 0 : p_position = position;
181416 0 : }
181417 :
181418 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181419 :
181420 :
181421 : // End of memberFunctionString
181422 : // Start of memberFunctionString
181423 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181424 :
181425 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181426 :
181427 : SgExpression*
181428 0 : SgInquireStatement::get_action () const
181429 : {
181430 0 : ROSE_ASSERT (this != NULL);
181431 :
181432 : #if 0
181433 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181434 : // used to trigger marking transformations for the token-based unparsing.
181435 : printf ("SgInquireStatement::get_action = %p = %s \n",this,this->class_name().c_str());
181436 : #endif
181437 :
181438 0 : return p_action;
181439 : }
181440 :
181441 : void
181442 0 : SgInquireStatement::set_action ( SgExpression* action )
181443 : {
181444 0 : ROSE_ASSERT (this != NULL);
181445 :
181446 : #if 0
181447 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181448 : // used to trigger marking transformations for the token-based unparsing.
181449 : printf ("SgInquireStatement::set_action = %p = %s \n",this,this->class_name().c_str());
181450 : #endif
181451 :
181452 0 : set_isModified(true);
181453 :
181454 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181455 : if (p_action != NULL && action != NULL && p_action != action)
181456 : {
181457 : printf ("Warning: action = %p overwriting valid pointer p_action = %p \n",action,p_action);
181458 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181459 : printf ("Error fails assertion (p_action != NULL && action != NULL && p_action != action) is false\n");
181460 : ROSE_ASSERT(false);
181461 : #endif
181462 : }
181463 : #endif
181464 0 : p_action = action;
181465 0 : }
181466 :
181467 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181468 :
181469 :
181470 : // End of memberFunctionString
181471 : // Start of memberFunctionString
181472 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181473 :
181474 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181475 :
181476 : SgExpression*
181477 0 : SgInquireStatement::get_read () const
181478 : {
181479 0 : ROSE_ASSERT (this != NULL);
181480 :
181481 : #if 0
181482 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181483 : // used to trigger marking transformations for the token-based unparsing.
181484 : printf ("SgInquireStatement::get_read = %p = %s \n",this,this->class_name().c_str());
181485 : #endif
181486 :
181487 0 : return p_read;
181488 : }
181489 :
181490 : void
181491 0 : SgInquireStatement::set_read ( SgExpression* read )
181492 : {
181493 0 : ROSE_ASSERT (this != NULL);
181494 :
181495 : #if 0
181496 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181497 : // used to trigger marking transformations for the token-based unparsing.
181498 : printf ("SgInquireStatement::set_read = %p = %s \n",this,this->class_name().c_str());
181499 : #endif
181500 :
181501 0 : set_isModified(true);
181502 :
181503 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181504 : if (p_read != NULL && read != NULL && p_read != read)
181505 : {
181506 : printf ("Warning: read = %p overwriting valid pointer p_read = %p \n",read,p_read);
181507 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181508 : printf ("Error fails assertion (p_read != NULL && read != NULL && p_read != read) is false\n");
181509 : ROSE_ASSERT(false);
181510 : #endif
181511 : }
181512 : #endif
181513 0 : p_read = read;
181514 0 : }
181515 :
181516 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181517 :
181518 :
181519 : // End of memberFunctionString
181520 : // Start of memberFunctionString
181521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181522 :
181523 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181524 :
181525 : SgExpression*
181526 0 : SgInquireStatement::get_write () const
181527 : {
181528 0 : ROSE_ASSERT (this != NULL);
181529 :
181530 : #if 0
181531 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181532 : // used to trigger marking transformations for the token-based unparsing.
181533 : printf ("SgInquireStatement::get_write = %p = %s \n",this,this->class_name().c_str());
181534 : #endif
181535 :
181536 0 : return p_write;
181537 : }
181538 :
181539 : void
181540 0 : SgInquireStatement::set_write ( SgExpression* write )
181541 : {
181542 0 : ROSE_ASSERT (this != NULL);
181543 :
181544 : #if 0
181545 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181546 : // used to trigger marking transformations for the token-based unparsing.
181547 : printf ("SgInquireStatement::set_write = %p = %s \n",this,this->class_name().c_str());
181548 : #endif
181549 :
181550 0 : set_isModified(true);
181551 :
181552 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181553 : if (p_write != NULL && write != NULL && p_write != write)
181554 : {
181555 : printf ("Warning: write = %p overwriting valid pointer p_write = %p \n",write,p_write);
181556 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181557 : printf ("Error fails assertion (p_write != NULL && write != NULL && p_write != write) is false\n");
181558 : ROSE_ASSERT(false);
181559 : #endif
181560 : }
181561 : #endif
181562 0 : p_write = write;
181563 0 : }
181564 :
181565 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181566 :
181567 :
181568 : // End of memberFunctionString
181569 : // Start of memberFunctionString
181570 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181571 :
181572 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181573 :
181574 : SgExpression*
181575 0 : SgInquireStatement::get_readwrite () const
181576 : {
181577 0 : ROSE_ASSERT (this != NULL);
181578 :
181579 : #if 0
181580 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181581 : // used to trigger marking transformations for the token-based unparsing.
181582 : printf ("SgInquireStatement::get_readwrite = %p = %s \n",this,this->class_name().c_str());
181583 : #endif
181584 :
181585 0 : return p_readwrite;
181586 : }
181587 :
181588 : void
181589 0 : SgInquireStatement::set_readwrite ( SgExpression* readwrite )
181590 : {
181591 0 : ROSE_ASSERT (this != NULL);
181592 :
181593 : #if 0
181594 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181595 : // used to trigger marking transformations for the token-based unparsing.
181596 : printf ("SgInquireStatement::set_readwrite = %p = %s \n",this,this->class_name().c_str());
181597 : #endif
181598 :
181599 0 : set_isModified(true);
181600 :
181601 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181602 : if (p_readwrite != NULL && readwrite != NULL && p_readwrite != readwrite)
181603 : {
181604 : printf ("Warning: readwrite = %p overwriting valid pointer p_readwrite = %p \n",readwrite,p_readwrite);
181605 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181606 : printf ("Error fails assertion (p_readwrite != NULL && readwrite != NULL && p_readwrite != readwrite) is false\n");
181607 : ROSE_ASSERT(false);
181608 : #endif
181609 : }
181610 : #endif
181611 0 : p_readwrite = readwrite;
181612 0 : }
181613 :
181614 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181615 :
181616 :
181617 : // End of memberFunctionString
181618 : // Start of memberFunctionString
181619 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181620 :
181621 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181622 :
181623 : SgExpression*
181624 0 : SgInquireStatement::get_delim () const
181625 : {
181626 0 : ROSE_ASSERT (this != NULL);
181627 :
181628 : #if 0
181629 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181630 : // used to trigger marking transformations for the token-based unparsing.
181631 : printf ("SgInquireStatement::get_delim = %p = %s \n",this,this->class_name().c_str());
181632 : #endif
181633 :
181634 0 : return p_delim;
181635 : }
181636 :
181637 : void
181638 0 : SgInquireStatement::set_delim ( SgExpression* delim )
181639 : {
181640 0 : ROSE_ASSERT (this != NULL);
181641 :
181642 : #if 0
181643 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181644 : // used to trigger marking transformations for the token-based unparsing.
181645 : printf ("SgInquireStatement::set_delim = %p = %s \n",this,this->class_name().c_str());
181646 : #endif
181647 :
181648 0 : set_isModified(true);
181649 :
181650 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181651 : if (p_delim != NULL && delim != NULL && p_delim != delim)
181652 : {
181653 : printf ("Warning: delim = %p overwriting valid pointer p_delim = %p \n",delim,p_delim);
181654 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181655 : printf ("Error fails assertion (p_delim != NULL && delim != NULL && p_delim != delim) is false\n");
181656 : ROSE_ASSERT(false);
181657 : #endif
181658 : }
181659 : #endif
181660 0 : p_delim = delim;
181661 0 : }
181662 :
181663 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181664 :
181665 :
181666 : // End of memberFunctionString
181667 : // Start of memberFunctionString
181668 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181669 :
181670 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181671 :
181672 : SgExpression*
181673 0 : SgInquireStatement::get_pad () const
181674 : {
181675 0 : ROSE_ASSERT (this != NULL);
181676 :
181677 : #if 0
181678 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181679 : // used to trigger marking transformations for the token-based unparsing.
181680 : printf ("SgInquireStatement::get_pad = %p = %s \n",this,this->class_name().c_str());
181681 : #endif
181682 :
181683 0 : return p_pad;
181684 : }
181685 :
181686 : void
181687 0 : SgInquireStatement::set_pad ( SgExpression* pad )
181688 : {
181689 0 : ROSE_ASSERT (this != NULL);
181690 :
181691 : #if 0
181692 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181693 : // used to trigger marking transformations for the token-based unparsing.
181694 : printf ("SgInquireStatement::set_pad = %p = %s \n",this,this->class_name().c_str());
181695 : #endif
181696 :
181697 0 : set_isModified(true);
181698 :
181699 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181700 : if (p_pad != NULL && pad != NULL && p_pad != pad)
181701 : {
181702 : printf ("Warning: pad = %p overwriting valid pointer p_pad = %p \n",pad,p_pad);
181703 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181704 : printf ("Error fails assertion (p_pad != NULL && pad != NULL && p_pad != pad) is false\n");
181705 : ROSE_ASSERT(false);
181706 : #endif
181707 : }
181708 : #endif
181709 0 : p_pad = pad;
181710 0 : }
181711 :
181712 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181713 :
181714 :
181715 : // End of memberFunctionString
181716 : // Start of memberFunctionString
181717 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181718 :
181719 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181720 :
181721 : SgExpression*
181722 0 : SgInquireStatement::get_asynchronous () const
181723 : {
181724 0 : ROSE_ASSERT (this != NULL);
181725 :
181726 : #if 0
181727 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181728 : // used to trigger marking transformations for the token-based unparsing.
181729 : printf ("SgInquireStatement::get_asynchronous = %p = %s \n",this,this->class_name().c_str());
181730 : #endif
181731 :
181732 0 : return p_asynchronous;
181733 : }
181734 :
181735 : void
181736 0 : SgInquireStatement::set_asynchronous ( SgExpression* asynchronous )
181737 : {
181738 0 : ROSE_ASSERT (this != NULL);
181739 :
181740 : #if 0
181741 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181742 : // used to trigger marking transformations for the token-based unparsing.
181743 : printf ("SgInquireStatement::set_asynchronous = %p = %s \n",this,this->class_name().c_str());
181744 : #endif
181745 :
181746 0 : set_isModified(true);
181747 :
181748 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181749 : if (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous)
181750 : {
181751 : printf ("Warning: asynchronous = %p overwriting valid pointer p_asynchronous = %p \n",asynchronous,p_asynchronous);
181752 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181753 : printf ("Error fails assertion (p_asynchronous != NULL && asynchronous != NULL && p_asynchronous != asynchronous) is false\n");
181754 : ROSE_ASSERT(false);
181755 : #endif
181756 : }
181757 : #endif
181758 0 : p_asynchronous = asynchronous;
181759 0 : }
181760 :
181761 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181762 :
181763 :
181764 : // End of memberFunctionString
181765 : // Start of memberFunctionString
181766 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181767 :
181768 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181769 :
181770 : SgExpression*
181771 0 : SgInquireStatement::get_decimal () const
181772 : {
181773 0 : ROSE_ASSERT (this != NULL);
181774 :
181775 : #if 0
181776 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181777 : // used to trigger marking transformations for the token-based unparsing.
181778 : printf ("SgInquireStatement::get_decimal = %p = %s \n",this,this->class_name().c_str());
181779 : #endif
181780 :
181781 0 : return p_decimal;
181782 : }
181783 :
181784 : void
181785 0 : SgInquireStatement::set_decimal ( SgExpression* decimal )
181786 : {
181787 0 : ROSE_ASSERT (this != NULL);
181788 :
181789 : #if 0
181790 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181791 : // used to trigger marking transformations for the token-based unparsing.
181792 : printf ("SgInquireStatement::set_decimal = %p = %s \n",this,this->class_name().c_str());
181793 : #endif
181794 :
181795 0 : set_isModified(true);
181796 :
181797 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181798 : if (p_decimal != NULL && decimal != NULL && p_decimal != decimal)
181799 : {
181800 : printf ("Warning: decimal = %p overwriting valid pointer p_decimal = %p \n",decimal,p_decimal);
181801 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181802 : printf ("Error fails assertion (p_decimal != NULL && decimal != NULL && p_decimal != decimal) is false\n");
181803 : ROSE_ASSERT(false);
181804 : #endif
181805 : }
181806 : #endif
181807 0 : p_decimal = decimal;
181808 0 : }
181809 :
181810 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181811 :
181812 :
181813 : // End of memberFunctionString
181814 : // Start of memberFunctionString
181815 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181816 :
181817 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181818 :
181819 : SgExpression*
181820 0 : SgInquireStatement::get_stream () const
181821 : {
181822 0 : ROSE_ASSERT (this != NULL);
181823 :
181824 : #if 0
181825 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181826 : // used to trigger marking transformations for the token-based unparsing.
181827 : printf ("SgInquireStatement::get_stream = %p = %s \n",this,this->class_name().c_str());
181828 : #endif
181829 :
181830 0 : return p_stream;
181831 : }
181832 :
181833 : void
181834 0 : SgInquireStatement::set_stream ( SgExpression* stream )
181835 : {
181836 0 : ROSE_ASSERT (this != NULL);
181837 :
181838 : #if 0
181839 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181840 : // used to trigger marking transformations for the token-based unparsing.
181841 : printf ("SgInquireStatement::set_stream = %p = %s \n",this,this->class_name().c_str());
181842 : #endif
181843 :
181844 0 : set_isModified(true);
181845 :
181846 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181847 : if (p_stream != NULL && stream != NULL && p_stream != stream)
181848 : {
181849 : printf ("Warning: stream = %p overwriting valid pointer p_stream = %p \n",stream,p_stream);
181850 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181851 : printf ("Error fails assertion (p_stream != NULL && stream != NULL && p_stream != stream) is false\n");
181852 : ROSE_ASSERT(false);
181853 : #endif
181854 : }
181855 : #endif
181856 0 : p_stream = stream;
181857 0 : }
181858 :
181859 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181860 :
181861 :
181862 : // End of memberFunctionString
181863 : // Start of memberFunctionString
181864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181865 :
181866 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181867 :
181868 : SgExpression*
181869 0 : SgInquireStatement::get_size () const
181870 : {
181871 0 : ROSE_ASSERT (this != NULL);
181872 :
181873 : #if 0
181874 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181875 : // used to trigger marking transformations for the token-based unparsing.
181876 : printf ("SgInquireStatement::get_size = %p = %s \n",this,this->class_name().c_str());
181877 : #endif
181878 :
181879 0 : return p_size;
181880 : }
181881 :
181882 : void
181883 0 : SgInquireStatement::set_size ( SgExpression* size )
181884 : {
181885 0 : ROSE_ASSERT (this != NULL);
181886 :
181887 : #if 0
181888 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181889 : // used to trigger marking transformations for the token-based unparsing.
181890 : printf ("SgInquireStatement::set_size = %p = %s \n",this,this->class_name().c_str());
181891 : #endif
181892 :
181893 0 : set_isModified(true);
181894 :
181895 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181896 : if (p_size != NULL && size != NULL && p_size != size)
181897 : {
181898 : printf ("Warning: size = %p overwriting valid pointer p_size = %p \n",size,p_size);
181899 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181900 : printf ("Error fails assertion (p_size != NULL && size != NULL && p_size != size) is false\n");
181901 : ROSE_ASSERT(false);
181902 : #endif
181903 : }
181904 : #endif
181905 0 : p_size = size;
181906 0 : }
181907 :
181908 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181909 :
181910 :
181911 : // End of memberFunctionString
181912 : // Start of memberFunctionString
181913 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181914 :
181915 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181916 :
181917 : SgExpression*
181918 0 : SgInquireStatement::get_pending () const
181919 : {
181920 0 : ROSE_ASSERT (this != NULL);
181921 :
181922 : #if 0
181923 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181924 : // used to trigger marking transformations for the token-based unparsing.
181925 : printf ("SgInquireStatement::get_pending = %p = %s \n",this,this->class_name().c_str());
181926 : #endif
181927 :
181928 0 : return p_pending;
181929 : }
181930 :
181931 : void
181932 0 : SgInquireStatement::set_pending ( SgExpression* pending )
181933 : {
181934 0 : ROSE_ASSERT (this != NULL);
181935 :
181936 : #if 0
181937 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181938 : // used to trigger marking transformations for the token-based unparsing.
181939 : printf ("SgInquireStatement::set_pending = %p = %s \n",this,this->class_name().c_str());
181940 : #endif
181941 :
181942 0 : set_isModified(true);
181943 :
181944 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181945 : if (p_pending != NULL && pending != NULL && p_pending != pending)
181946 : {
181947 : printf ("Warning: pending = %p overwriting valid pointer p_pending = %p \n",pending,p_pending);
181948 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181949 : printf ("Error fails assertion (p_pending != NULL && pending != NULL && p_pending != pending) is false\n");
181950 : ROSE_ASSERT(false);
181951 : #endif
181952 : }
181953 : #endif
181954 0 : p_pending = pending;
181955 0 : }
181956 :
181957 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
181958 :
181959 :
181960 : // End of memberFunctionString
181961 : // Start of memberFunctionString
181962 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
181963 :
181964 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
181965 :
181966 : SgVarRefExp*
181967 0 : SgInquireStatement::get_iolengthExp () const
181968 : {
181969 0 : ROSE_ASSERT (this != NULL);
181970 :
181971 : #if 0
181972 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181973 : // used to trigger marking transformations for the token-based unparsing.
181974 : printf ("SgInquireStatement::get_iolengthExp = %p = %s \n",this,this->class_name().c_str());
181975 : #endif
181976 :
181977 0 : return p_iolengthExp;
181978 : }
181979 :
181980 : void
181981 0 : SgInquireStatement::set_iolengthExp ( SgVarRefExp* iolengthExp )
181982 : {
181983 0 : ROSE_ASSERT (this != NULL);
181984 :
181985 : #if 0
181986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
181987 : // used to trigger marking transformations for the token-based unparsing.
181988 : printf ("SgInquireStatement::set_iolengthExp = %p = %s \n",this,this->class_name().c_str());
181989 : #endif
181990 :
181991 0 : set_isModified(true);
181992 :
181993 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
181994 : if (p_iolengthExp != NULL && iolengthExp != NULL && p_iolengthExp != iolengthExp)
181995 : {
181996 : printf ("Warning: iolengthExp = %p overwriting valid pointer p_iolengthExp = %p \n",iolengthExp,p_iolengthExp);
181997 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
181998 : printf ("Error fails assertion (p_iolengthExp != NULL && iolengthExp != NULL && p_iolengthExp != iolengthExp) is false\n");
181999 : ROSE_ASSERT(false);
182000 : #endif
182001 : }
182002 : #endif
182003 0 : p_iolengthExp = iolengthExp;
182004 0 : }
182005 :
182006 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
182007 :
182008 :
182009 : // End of memberFunctionString
182010 : // Start of memberFunctionString
182011 : /* #line 18414 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
182012 :
182013 :
182014 : void
182015 0 : SgInquireStatement::post_construction_initialization()
182016 0 : {}
182017 :
182018 :
182019 :
182020 : // End of memberFunctionString
182021 : // Start of memberFunctionString
182022 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
182023 :
182024 : // *** COMMON CODE SECTION BEGINS HERE ***
182025 :
182026 : #if 0
182027 : int
182028 : SgInquireStatement::getVariant() const
182029 : {
182030 : // This function is used in ROSE while "variant()" is used in SAGE
182031 : assert(this != NULL);
182032 : return variant();
182033 : }
182034 : #endif
182035 :
182036 : // This function is used in ROSE in treeTraversal code
182037 : // eventually replaces getVariant() and variant()
182038 : // though after variant() has been removed for a while we will
182039 : // want to change the name of variantT() back to variant()
182040 : // (since the "T" was ment to stand for temporary).
182041 : // When this happens the variantT() will be depricated.
182042 : VariantT
182043 0 : SgInquireStatement::variantT() const
182044 : {
182045 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
182046 0 : ROSE_ASSERT(this != NULL);
182047 0 : return V_SgInquireStatement;
182048 : }
182049 :
182050 : #if 0
182051 : int
182052 : SgInquireStatement::variant() const
182053 : {
182054 : // This function is used in SAGE
182055 : ROSE_ASSERT(this != NULL);
182056 : return INQUIRE_STATEMENT;
182057 : }
182058 : #endif
182059 :
182060 : ROSE_DLL_API const char*
182061 0 : SgInquireStatement::sage_class_name() const
182062 : {
182063 0 : ROSE_ASSERT(this != NULL);
182064 0 : return "SgInquireStatement";
182065 : }
182066 :
182067 : std::string
182068 0 : SgInquireStatement::class_name() const
182069 : {
182070 0 : ROSE_ASSERT(this != NULL);
182071 0 : return "SgInquireStatement";
182072 : }
182073 :
182074 : // DQ (11/26/2005): Support for visitor pattern mechanims
182075 : // (inferior to ROSE traversal mechanism, experimental).
182076 : void
182077 0 : SgInquireStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
182078 : {
182079 0 : ROSE_ASSERT(this != NULL);
182080 0 : visitor.visit(this);
182081 0 : }
182082 :
182083 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
182084 0 : void SgInquireStatement::accept (ROSE_VisitorPattern & visitor) {
182085 0 : ROSE_ASSERT(this != NULL);
182086 0 : visitor.visit(this);
182087 0 : }
182088 :
182089 : SgInquireStatement*
182090 0 : SgInquireStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
182091 : {
182092 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
182093 : // This function is currently only supported for the AST used the represent Binary executables.
182094 : if (0 /* isSgAsmNode(this) != NULL */)
182095 : {
182096 : // Support for regex specification.
182097 : std::string prefixCode = "REGEX:";
182098 : addNewAttribute(prefixCode + s,a);
182099 : }
182100 : #endif
182101 :
182102 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
182103 0 : return this;
182104 : }
182105 :
182106 : // *** COMMON CODE SECTION ENDS HERE ***
182107 :
182108 :
182109 : // End of memberFunctionString
182110 : // Start of memberFunctionString
182111 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
182112 :
182113 :
182114 : #if 0
182115 : //! Error checking support
182116 : /*! Verifies the following:
182117 : - working getVariant() member function
182118 : - calls base class's error() member function
182119 : Every class has one of these functions.
182120 : */
182121 : bool
182122 : SgInquireStatement::error()
182123 : {
182124 : // Put error checking here
182125 :
182126 : ROSE_ASSERT (this != NULL);
182127 : if (getVariant() != INQUIRE_STATEMENT)
182128 : {
182129 : printf ("Error in SgInquireStatement::error(): SgInquireStatement object has a %s variant \n",
182130 : Cxx_GrammarTerminalNames[getVariant()].name);
182131 : // printf ("Error in SgInquireStatement::error() \n");
182132 : ROSE_ABORT();
182133 : }
182134 :
182135 : ROSE_ASSERT (getVariant() == INQUIRE_STATEMENT);
182136 : return SgIOStatement::error();
182137 : }
182138 : #endif
182139 :
182140 :
182141 :
182142 : // End of memberFunctionString
182143 :
182144 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
182145 :
182146 0 : SgInquireStatement* isSgInquireStatement ( SgNode* inputDerivedClassPointer )
182147 : {
182148 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
182149 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
182150 : // So to fix this we return NULL directly when the input is NULL and avoid the
182151 : // dynamic_cast in this case. This is likely a performance improvement as well.
182152 : // return dynamic_cast<SgInquireStatement*>(inputDerivedClassPointer);
182153 : // Milind Chabbi (8/28/2013): isSgInquireStatement uses table-driven castability instead of c++ default dynamic_cast
182154 : // this improves the running time performance by 10-20%.
182155 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgInquireStatement*>(inputDerivedClassPointer);
182156 0 : return IS_SgInquireStatement_FAST_MACRO(inputDerivedClassPointer);
182157 : }
182158 :
182159 : // DQ (11/8/2003): Added version of functions taking const pointer
182160 0 : const SgInquireStatement* isSgInquireStatement ( const SgNode* inputDerivedClassPointer )
182161 : {
182162 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
182163 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
182164 : // So to fix this we return NULL directly when the input is NULL and avoid the
182165 : // dynamic_cast in this case. This is likely a performance improvement as well.
182166 : // return dynamic_cast<const SgInquireStatement*>(inputDerivedClassPointer);
182167 : // Milind Chabbi (8/28/2013): isSgInquireStatement uses table-driven castability instead of c++ default dynamic_cast
182168 : // this improves the running time performance by 10-20%.
182169 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgInquireStatement*>(inputDerivedClassPointer);
182170 0 : return IS_SgInquireStatement_FAST_MACRO(inputDerivedClassPointer);
182171 : }
182172 :
182173 :
182174 :
182175 : /* #line 182176 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182176 :
182177 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
182178 :
182179 : /**
182180 : \brief Generated destructor
182181 :
182182 : This destructor is automatically generated (by ROSETTA). This destructor
182183 : only frees memory of data members associated with the parts of the current IR node which
182184 : are NOT traversed. Those data members that are part of a traversal can be freed using
182185 : a traversal (calling this destructor on all children in a post-order traversal). Such
182186 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
182187 :
182188 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
182189 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
182190 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
182191 :
182192 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
182193 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
182194 : pointers are not yet implemented to call delete on eash pointer in the container.
182195 : (This could be done by derivation from the STL containers to define containers that
182196 : automatically deleted their members.)
182197 :
182198 : */
182199 0 : SgInquireStatement::~SgInquireStatement () {
182200 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
182201 :
182202 :
182203 : // case: not a listType for file
182204 0 : p_file = NULL; // non list case
182205 : // case: not a listType for access
182206 0 : p_access = NULL; // non list case
182207 : // case: not a listType for form
182208 0 : p_form = NULL; // non list case
182209 : // case: not a listType for recl
182210 0 : p_recl = NULL; // non list case
182211 : // case: not a listType for blank
182212 0 : p_blank = NULL; // non list case
182213 : // case: not a listType for exist
182214 0 : p_exist = NULL; // non list case
182215 : // case: not a listType for opened
182216 0 : p_opened = NULL; // non list case
182217 : // case: not a listType for number
182218 0 : p_number = NULL; // non list case
182219 : // case: not a listType for named
182220 0 : p_named = NULL; // non list case
182221 : // case: not a listType for name
182222 0 : p_name = NULL; // non list case
182223 : // case: not a listType for sequential
182224 0 : p_sequential = NULL; // non list case
182225 : // case: not a listType for direct
182226 0 : p_direct = NULL; // non list case
182227 : // case: not a listType for formatted
182228 0 : p_formatted = NULL; // non list case
182229 : // case: not a listType for unformatted
182230 0 : p_unformatted = NULL; // non list case
182231 : // case: not a listType for nextrec
182232 0 : p_nextrec = NULL; // non list case
182233 : // case: not a listType for position
182234 0 : p_position = NULL; // non list case
182235 : // case: not a listType for action
182236 0 : p_action = NULL; // non list case
182237 : // case: not a listType for read
182238 0 : p_read = NULL; // non list case
182239 : // case: not a listType for write
182240 0 : p_write = NULL; // non list case
182241 : // case: not a listType for readwrite
182242 0 : p_readwrite = NULL; // non list case
182243 : // case: not a listType for delim
182244 0 : p_delim = NULL; // non list case
182245 : // case: not a listType for pad
182246 0 : p_pad = NULL; // non list case
182247 : // case: not a listType for asynchronous
182248 0 : p_asynchronous = NULL; // non list case
182249 : // case: not a listType for decimal
182250 0 : p_decimal = NULL; // non list case
182251 : // case: not a listType for stream
182252 0 : p_stream = NULL; // non list case
182253 : // case: not a listType for size
182254 0 : p_size = NULL; // non list case
182255 : // case: not a listType for pending
182256 0 : p_pending = NULL; // non list case
182257 : // case: not a listType for iolengthExp
182258 0 : p_iolengthExp = NULL; // non list case
182259 :
182260 : }
182261 :
182262 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
182263 0 : }
182264 :
182265 :
182266 : /* #line 182267 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182267 :
182268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
182269 :
182270 : // Generated constructor
182271 0 : SgInquireStatement::SgInquireStatement ( Sg_File_Info* startOfConstruct )
182272 0 : : SgIOStatement(startOfConstruct)
182273 : {
182274 : #ifdef DEBUG
182275 : // printf ("In SgInquireStatement::SgInquireStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
182276 : #endif
182277 : #if 0
182278 : // debugging information!
182279 : printf ("In SgInquireStatement::SgInquireStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
182280 : #endif
182281 :
182282 0 : p_file = NULL;
182283 0 : p_access = NULL;
182284 0 : p_form = NULL;
182285 0 : p_recl = NULL;
182286 0 : p_blank = NULL;
182287 0 : p_exist = NULL;
182288 0 : p_opened = NULL;
182289 0 : p_number = NULL;
182290 0 : p_named = NULL;
182291 0 : p_name = NULL;
182292 0 : p_sequential = NULL;
182293 0 : p_direct = NULL;
182294 0 : p_formatted = NULL;
182295 0 : p_unformatted = NULL;
182296 0 : p_nextrec = NULL;
182297 0 : p_position = NULL;
182298 0 : p_action = NULL;
182299 0 : p_read = NULL;
182300 0 : p_write = NULL;
182301 0 : p_readwrite = NULL;
182302 0 : p_delim = NULL;
182303 0 : p_pad = NULL;
182304 0 : p_asynchronous = NULL;
182305 0 : p_decimal = NULL;
182306 0 : p_stream = NULL;
182307 0 : p_size = NULL;
182308 0 : p_pending = NULL;
182309 0 : p_iolengthExp = NULL;
182310 :
182311 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
182312 :
182313 : #if 0
182314 : // DQ (7/30/2014): Call a virtual function.
182315 : std::string s = this->class_name();
182316 : #endif
182317 :
182318 : // Test the variant virtual function
182319 : // assert(INQUIRE_STATEMENT == variant());
182320 0 : assert(INQUIRE_STATEMENT == this->variant());
182321 0 : ROSE_ASSERT(INQUIRE_STATEMENT == (int)(this->variantT()));
182322 0 : post_construction_initialization();
182323 :
182324 : // Test the isSgInquireStatement() function since it has been problematic
182325 0 : assert(isSgInquireStatement(this) != NULL);
182326 0 : }
182327 :
182328 : // Generated constructor (all data members)
182329 :
182330 : /* #line 182331 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182331 :
182332 :
182333 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
182334 :
182335 :
182336 : // ********************************************************
182337 : // member functions common across all array grammar objects
182338 : // ********************************************************
182339 :
182340 :
182341 :
182342 : /* #line 182343 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182343 :
182344 :
182345 :
182346 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
182347 :
182348 : // ********************************************************
182349 : // member functions specific to each node in the grammar
182350 : // ********************************************************
182351 :
182352 :
182353 : /* #line 182354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182354 :
182355 : // Start of memberFunctionString
182356 : /* #line 18423 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
182357 :
182358 :
182359 : void
182360 0 : SgFlushStatement::post_construction_initialization()
182361 0 : {}
182362 :
182363 :
182364 :
182365 : // End of memberFunctionString
182366 : // Start of memberFunctionString
182367 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
182368 :
182369 : // *** COMMON CODE SECTION BEGINS HERE ***
182370 :
182371 : #if 0
182372 : int
182373 : SgFlushStatement::getVariant() const
182374 : {
182375 : // This function is used in ROSE while "variant()" is used in SAGE
182376 : assert(this != NULL);
182377 : return variant();
182378 : }
182379 : #endif
182380 :
182381 : // This function is used in ROSE in treeTraversal code
182382 : // eventually replaces getVariant() and variant()
182383 : // though after variant() has been removed for a while we will
182384 : // want to change the name of variantT() back to variant()
182385 : // (since the "T" was ment to stand for temporary).
182386 : // When this happens the variantT() will be depricated.
182387 : VariantT
182388 0 : SgFlushStatement::variantT() const
182389 : {
182390 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
182391 0 : ROSE_ASSERT(this != NULL);
182392 0 : return V_SgFlushStatement;
182393 : }
182394 :
182395 : #if 0
182396 : int
182397 : SgFlushStatement::variant() const
182398 : {
182399 : // This function is used in SAGE
182400 : ROSE_ASSERT(this != NULL);
182401 : return FLUSH_STATEMENT;
182402 : }
182403 : #endif
182404 :
182405 : ROSE_DLL_API const char*
182406 0 : SgFlushStatement::sage_class_name() const
182407 : {
182408 0 : ROSE_ASSERT(this != NULL);
182409 0 : return "SgFlushStatement";
182410 : }
182411 :
182412 : std::string
182413 0 : SgFlushStatement::class_name() const
182414 : {
182415 0 : ROSE_ASSERT(this != NULL);
182416 0 : return "SgFlushStatement";
182417 : }
182418 :
182419 : // DQ (11/26/2005): Support for visitor pattern mechanims
182420 : // (inferior to ROSE traversal mechanism, experimental).
182421 : void
182422 0 : SgFlushStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
182423 : {
182424 0 : ROSE_ASSERT(this != NULL);
182425 0 : visitor.visit(this);
182426 0 : }
182427 :
182428 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
182429 0 : void SgFlushStatement::accept (ROSE_VisitorPattern & visitor) {
182430 0 : ROSE_ASSERT(this != NULL);
182431 0 : visitor.visit(this);
182432 0 : }
182433 :
182434 : SgFlushStatement*
182435 0 : SgFlushStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
182436 : {
182437 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
182438 : // This function is currently only supported for the AST used the represent Binary executables.
182439 : if (0 /* isSgAsmNode(this) != NULL */)
182440 : {
182441 : // Support for regex specification.
182442 : std::string prefixCode = "REGEX:";
182443 : addNewAttribute(prefixCode + s,a);
182444 : }
182445 : #endif
182446 :
182447 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
182448 0 : return this;
182449 : }
182450 :
182451 : // *** COMMON CODE SECTION ENDS HERE ***
182452 :
182453 :
182454 : // End of memberFunctionString
182455 : // Start of memberFunctionString
182456 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
182457 :
182458 :
182459 : #if 0
182460 : //! Error checking support
182461 : /*! Verifies the following:
182462 : - working getVariant() member function
182463 : - calls base class's error() member function
182464 : Every class has one of these functions.
182465 : */
182466 : bool
182467 : SgFlushStatement::error()
182468 : {
182469 : // Put error checking here
182470 :
182471 : ROSE_ASSERT (this != NULL);
182472 : if (getVariant() != FLUSH_STATEMENT)
182473 : {
182474 : printf ("Error in SgFlushStatement::error(): SgFlushStatement object has a %s variant \n",
182475 : Cxx_GrammarTerminalNames[getVariant()].name);
182476 : // printf ("Error in SgFlushStatement::error() \n");
182477 : ROSE_ABORT();
182478 : }
182479 :
182480 : ROSE_ASSERT (getVariant() == FLUSH_STATEMENT);
182481 : return SgIOStatement::error();
182482 : }
182483 : #endif
182484 :
182485 :
182486 :
182487 : // End of memberFunctionString
182488 :
182489 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
182490 :
182491 0 : SgFlushStatement* isSgFlushStatement ( SgNode* inputDerivedClassPointer )
182492 : {
182493 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
182494 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
182495 : // So to fix this we return NULL directly when the input is NULL and avoid the
182496 : // dynamic_cast in this case. This is likely a performance improvement as well.
182497 : // return dynamic_cast<SgFlushStatement*>(inputDerivedClassPointer);
182498 : // Milind Chabbi (8/28/2013): isSgFlushStatement uses table-driven castability instead of c++ default dynamic_cast
182499 : // this improves the running time performance by 10-20%.
182500 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFlushStatement*>(inputDerivedClassPointer);
182501 0 : return IS_SgFlushStatement_FAST_MACRO(inputDerivedClassPointer);
182502 : }
182503 :
182504 : // DQ (11/8/2003): Added version of functions taking const pointer
182505 0 : const SgFlushStatement* isSgFlushStatement ( const SgNode* inputDerivedClassPointer )
182506 : {
182507 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
182508 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
182509 : // So to fix this we return NULL directly when the input is NULL and avoid the
182510 : // dynamic_cast in this case. This is likely a performance improvement as well.
182511 : // return dynamic_cast<const SgFlushStatement*>(inputDerivedClassPointer);
182512 : // Milind Chabbi (8/28/2013): isSgFlushStatement uses table-driven castability instead of c++ default dynamic_cast
182513 : // this improves the running time performance by 10-20%.
182514 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFlushStatement*>(inputDerivedClassPointer);
182515 0 : return IS_SgFlushStatement_FAST_MACRO(inputDerivedClassPointer);
182516 : }
182517 :
182518 :
182519 :
182520 : /* #line 182521 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182521 :
182522 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
182523 :
182524 : /**
182525 : \brief Generated destructor
182526 :
182527 : This destructor is automatically generated (by ROSETTA). This destructor
182528 : only frees memory of data members associated with the parts of the current IR node which
182529 : are NOT traversed. Those data members that are part of a traversal can be freed using
182530 : a traversal (calling this destructor on all children in a post-order traversal). Such
182531 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
182532 :
182533 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
182534 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
182535 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
182536 :
182537 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
182538 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
182539 : pointers are not yet implemented to call delete on eash pointer in the container.
182540 : (This could be done by derivation from the STL containers to define containers that
182541 : automatically deleted their members.)
182542 :
182543 : */
182544 0 : SgFlushStatement::~SgFlushStatement () {
182545 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
182546 :
182547 :
182548 :
182549 : }
182550 :
182551 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
182552 0 : }
182553 :
182554 :
182555 : /* #line 182556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182556 :
182557 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
182558 :
182559 : // Generated constructor
182560 0 : SgFlushStatement::SgFlushStatement ( Sg_File_Info* startOfConstruct )
182561 0 : : SgIOStatement(startOfConstruct)
182562 : {
182563 : #ifdef DEBUG
182564 : // printf ("In SgFlushStatement::SgFlushStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
182565 : #endif
182566 : #if 0
182567 : // debugging information!
182568 : printf ("In SgFlushStatement::SgFlushStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
182569 : #endif
182570 :
182571 :
182572 :
182573 : #if 0
182574 : // DQ (7/30/2014): Call a virtual function.
182575 : std::string s = this->class_name();
182576 : #endif
182577 :
182578 : // Test the variant virtual function
182579 : // assert(FLUSH_STATEMENT == variant());
182580 0 : assert(FLUSH_STATEMENT == this->variant());
182581 0 : ROSE_ASSERT(FLUSH_STATEMENT == (int)(this->variantT()));
182582 0 : post_construction_initialization();
182583 :
182584 : // Test the isSgFlushStatement() function since it has been problematic
182585 0 : assert(isSgFlushStatement(this) != NULL);
182586 0 : }
182587 :
182588 : // Generated constructor (all data members)
182589 :
182590 : /* #line 182591 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182591 :
182592 :
182593 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
182594 :
182595 :
182596 : // ********************************************************
182597 : // member functions common across all array grammar objects
182598 : // ********************************************************
182599 :
182600 :
182601 :
182602 : /* #line 182603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182603 :
182604 :
182605 :
182606 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
182607 :
182608 : // ********************************************************
182609 : // member functions specific to each node in the grammar
182610 : // ********************************************************
182611 :
182612 :
182613 : /* #line 182614 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182614 :
182615 : // Start of memberFunctionString
182616 : /* #line 18441 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
182617 :
182618 :
182619 : void
182620 0 : SgBackspaceStatement::post_construction_initialization()
182621 0 : {}
182622 :
182623 :
182624 :
182625 : // End of memberFunctionString
182626 : // Start of memberFunctionString
182627 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
182628 :
182629 : // *** COMMON CODE SECTION BEGINS HERE ***
182630 :
182631 : #if 0
182632 : int
182633 : SgBackspaceStatement::getVariant() const
182634 : {
182635 : // This function is used in ROSE while "variant()" is used in SAGE
182636 : assert(this != NULL);
182637 : return variant();
182638 : }
182639 : #endif
182640 :
182641 : // This function is used in ROSE in treeTraversal code
182642 : // eventually replaces getVariant() and variant()
182643 : // though after variant() has been removed for a while we will
182644 : // want to change the name of variantT() back to variant()
182645 : // (since the "T" was ment to stand for temporary).
182646 : // When this happens the variantT() will be depricated.
182647 : VariantT
182648 0 : SgBackspaceStatement::variantT() const
182649 : {
182650 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
182651 0 : ROSE_ASSERT(this != NULL);
182652 0 : return V_SgBackspaceStatement;
182653 : }
182654 :
182655 : #if 0
182656 : int
182657 : SgBackspaceStatement::variant() const
182658 : {
182659 : // This function is used in SAGE
182660 : ROSE_ASSERT(this != NULL);
182661 : return BACKSPACE_STATEMENT;
182662 : }
182663 : #endif
182664 :
182665 : ROSE_DLL_API const char*
182666 0 : SgBackspaceStatement::sage_class_name() const
182667 : {
182668 0 : ROSE_ASSERT(this != NULL);
182669 0 : return "SgBackspaceStatement";
182670 : }
182671 :
182672 : std::string
182673 0 : SgBackspaceStatement::class_name() const
182674 : {
182675 0 : ROSE_ASSERT(this != NULL);
182676 0 : return "SgBackspaceStatement";
182677 : }
182678 :
182679 : // DQ (11/26/2005): Support for visitor pattern mechanims
182680 : // (inferior to ROSE traversal mechanism, experimental).
182681 : void
182682 0 : SgBackspaceStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
182683 : {
182684 0 : ROSE_ASSERT(this != NULL);
182685 0 : visitor.visit(this);
182686 0 : }
182687 :
182688 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
182689 0 : void SgBackspaceStatement::accept (ROSE_VisitorPattern & visitor) {
182690 0 : ROSE_ASSERT(this != NULL);
182691 0 : visitor.visit(this);
182692 0 : }
182693 :
182694 : SgBackspaceStatement*
182695 0 : SgBackspaceStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
182696 : {
182697 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
182698 : // This function is currently only supported for the AST used the represent Binary executables.
182699 : if (0 /* isSgAsmNode(this) != NULL */)
182700 : {
182701 : // Support for regex specification.
182702 : std::string prefixCode = "REGEX:";
182703 : addNewAttribute(prefixCode + s,a);
182704 : }
182705 : #endif
182706 :
182707 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
182708 0 : return this;
182709 : }
182710 :
182711 : // *** COMMON CODE SECTION ENDS HERE ***
182712 :
182713 :
182714 : // End of memberFunctionString
182715 : // Start of memberFunctionString
182716 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
182717 :
182718 :
182719 : #if 0
182720 : //! Error checking support
182721 : /*! Verifies the following:
182722 : - working getVariant() member function
182723 : - calls base class's error() member function
182724 : Every class has one of these functions.
182725 : */
182726 : bool
182727 : SgBackspaceStatement::error()
182728 : {
182729 : // Put error checking here
182730 :
182731 : ROSE_ASSERT (this != NULL);
182732 : if (getVariant() != BACKSPACE_STATEMENT)
182733 : {
182734 : printf ("Error in SgBackspaceStatement::error(): SgBackspaceStatement object has a %s variant \n",
182735 : Cxx_GrammarTerminalNames[getVariant()].name);
182736 : // printf ("Error in SgBackspaceStatement::error() \n");
182737 : ROSE_ABORT();
182738 : }
182739 :
182740 : ROSE_ASSERT (getVariant() == BACKSPACE_STATEMENT);
182741 : return SgIOStatement::error();
182742 : }
182743 : #endif
182744 :
182745 :
182746 :
182747 : // End of memberFunctionString
182748 :
182749 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
182750 :
182751 0 : SgBackspaceStatement* isSgBackspaceStatement ( SgNode* inputDerivedClassPointer )
182752 : {
182753 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
182754 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
182755 : // So to fix this we return NULL directly when the input is NULL and avoid the
182756 : // dynamic_cast in this case. This is likely a performance improvement as well.
182757 : // return dynamic_cast<SgBackspaceStatement*>(inputDerivedClassPointer);
182758 : // Milind Chabbi (8/28/2013): isSgBackspaceStatement uses table-driven castability instead of c++ default dynamic_cast
182759 : // this improves the running time performance by 10-20%.
182760 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBackspaceStatement*>(inputDerivedClassPointer);
182761 0 : return IS_SgBackspaceStatement_FAST_MACRO(inputDerivedClassPointer);
182762 : }
182763 :
182764 : // DQ (11/8/2003): Added version of functions taking const pointer
182765 0 : const SgBackspaceStatement* isSgBackspaceStatement ( const SgNode* inputDerivedClassPointer )
182766 : {
182767 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
182768 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
182769 : // So to fix this we return NULL directly when the input is NULL and avoid the
182770 : // dynamic_cast in this case. This is likely a performance improvement as well.
182771 : // return dynamic_cast<const SgBackspaceStatement*>(inputDerivedClassPointer);
182772 : // Milind Chabbi (8/28/2013): isSgBackspaceStatement uses table-driven castability instead of c++ default dynamic_cast
182773 : // this improves the running time performance by 10-20%.
182774 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBackspaceStatement*>(inputDerivedClassPointer);
182775 0 : return IS_SgBackspaceStatement_FAST_MACRO(inputDerivedClassPointer);
182776 : }
182777 :
182778 :
182779 :
182780 : /* #line 182781 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182781 :
182782 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
182783 :
182784 : /**
182785 : \brief Generated destructor
182786 :
182787 : This destructor is automatically generated (by ROSETTA). This destructor
182788 : only frees memory of data members associated with the parts of the current IR node which
182789 : are NOT traversed. Those data members that are part of a traversal can be freed using
182790 : a traversal (calling this destructor on all children in a post-order traversal). Such
182791 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
182792 :
182793 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
182794 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
182795 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
182796 :
182797 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
182798 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
182799 : pointers are not yet implemented to call delete on eash pointer in the container.
182800 : (This could be done by derivation from the STL containers to define containers that
182801 : automatically deleted their members.)
182802 :
182803 : */
182804 0 : SgBackspaceStatement::~SgBackspaceStatement () {
182805 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
182806 :
182807 :
182808 :
182809 : }
182810 :
182811 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
182812 0 : }
182813 :
182814 :
182815 : /* #line 182816 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182816 :
182817 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
182818 :
182819 : // Generated constructor
182820 0 : SgBackspaceStatement::SgBackspaceStatement ( Sg_File_Info* startOfConstruct )
182821 0 : : SgIOStatement(startOfConstruct)
182822 : {
182823 : #ifdef DEBUG
182824 : // printf ("In SgBackspaceStatement::SgBackspaceStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
182825 : #endif
182826 : #if 0
182827 : // debugging information!
182828 : printf ("In SgBackspaceStatement::SgBackspaceStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
182829 : #endif
182830 :
182831 :
182832 :
182833 : #if 0
182834 : // DQ (7/30/2014): Call a virtual function.
182835 : std::string s = this->class_name();
182836 : #endif
182837 :
182838 : // Test the variant virtual function
182839 : // assert(BACKSPACE_STATEMENT == variant());
182840 0 : assert(BACKSPACE_STATEMENT == this->variant());
182841 0 : ROSE_ASSERT(BACKSPACE_STATEMENT == (int)(this->variantT()));
182842 0 : post_construction_initialization();
182843 :
182844 : // Test the isSgBackspaceStatement() function since it has been problematic
182845 0 : assert(isSgBackspaceStatement(this) != NULL);
182846 0 : }
182847 :
182848 : // Generated constructor (all data members)
182849 :
182850 : /* #line 182851 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182851 :
182852 :
182853 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
182854 :
182855 :
182856 : // ********************************************************
182857 : // member functions common across all array grammar objects
182858 : // ********************************************************
182859 :
182860 :
182861 :
182862 : /* #line 182863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182863 :
182864 :
182865 :
182866 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
182867 :
182868 : // ********************************************************
182869 : // member functions specific to each node in the grammar
182870 : // ********************************************************
182871 :
182872 :
182873 : /* #line 182874 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
182874 :
182875 : // Start of memberFunctionString
182876 : /* #line 18432 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
182877 :
182878 :
182879 : void
182880 0 : SgRewindStatement::post_construction_initialization()
182881 0 : {}
182882 :
182883 :
182884 :
182885 : // End of memberFunctionString
182886 : // Start of memberFunctionString
182887 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
182888 :
182889 : // *** COMMON CODE SECTION BEGINS HERE ***
182890 :
182891 : #if 0
182892 : int
182893 : SgRewindStatement::getVariant() const
182894 : {
182895 : // This function is used in ROSE while "variant()" is used in SAGE
182896 : assert(this != NULL);
182897 : return variant();
182898 : }
182899 : #endif
182900 :
182901 : // This function is used in ROSE in treeTraversal code
182902 : // eventually replaces getVariant() and variant()
182903 : // though after variant() has been removed for a while we will
182904 : // want to change the name of variantT() back to variant()
182905 : // (since the "T" was ment to stand for temporary).
182906 : // When this happens the variantT() will be depricated.
182907 : VariantT
182908 0 : SgRewindStatement::variantT() const
182909 : {
182910 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
182911 0 : ROSE_ASSERT(this != NULL);
182912 0 : return V_SgRewindStatement;
182913 : }
182914 :
182915 : #if 0
182916 : int
182917 : SgRewindStatement::variant() const
182918 : {
182919 : // This function is used in SAGE
182920 : ROSE_ASSERT(this != NULL);
182921 : return REWIND_STATEMENT;
182922 : }
182923 : #endif
182924 :
182925 : ROSE_DLL_API const char*
182926 0 : SgRewindStatement::sage_class_name() const
182927 : {
182928 0 : ROSE_ASSERT(this != NULL);
182929 0 : return "SgRewindStatement";
182930 : }
182931 :
182932 : std::string
182933 0 : SgRewindStatement::class_name() const
182934 : {
182935 0 : ROSE_ASSERT(this != NULL);
182936 0 : return "SgRewindStatement";
182937 : }
182938 :
182939 : // DQ (11/26/2005): Support for visitor pattern mechanims
182940 : // (inferior to ROSE traversal mechanism, experimental).
182941 : void
182942 0 : SgRewindStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
182943 : {
182944 0 : ROSE_ASSERT(this != NULL);
182945 0 : visitor.visit(this);
182946 0 : }
182947 :
182948 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
182949 0 : void SgRewindStatement::accept (ROSE_VisitorPattern & visitor) {
182950 0 : ROSE_ASSERT(this != NULL);
182951 0 : visitor.visit(this);
182952 0 : }
182953 :
182954 : SgRewindStatement*
182955 0 : SgRewindStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
182956 : {
182957 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
182958 : // This function is currently only supported for the AST used the represent Binary executables.
182959 : if (0 /* isSgAsmNode(this) != NULL */)
182960 : {
182961 : // Support for regex specification.
182962 : std::string prefixCode = "REGEX:";
182963 : addNewAttribute(prefixCode + s,a);
182964 : }
182965 : #endif
182966 :
182967 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
182968 0 : return this;
182969 : }
182970 :
182971 : // *** COMMON CODE SECTION ENDS HERE ***
182972 :
182973 :
182974 : // End of memberFunctionString
182975 : // Start of memberFunctionString
182976 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
182977 :
182978 :
182979 : #if 0
182980 : //! Error checking support
182981 : /*! Verifies the following:
182982 : - working getVariant() member function
182983 : - calls base class's error() member function
182984 : Every class has one of these functions.
182985 : */
182986 : bool
182987 : SgRewindStatement::error()
182988 : {
182989 : // Put error checking here
182990 :
182991 : ROSE_ASSERT (this != NULL);
182992 : if (getVariant() != REWIND_STATEMENT)
182993 : {
182994 : printf ("Error in SgRewindStatement::error(): SgRewindStatement object has a %s variant \n",
182995 : Cxx_GrammarTerminalNames[getVariant()].name);
182996 : // printf ("Error in SgRewindStatement::error() \n");
182997 : ROSE_ABORT();
182998 : }
182999 :
183000 : ROSE_ASSERT (getVariant() == REWIND_STATEMENT);
183001 : return SgIOStatement::error();
183002 : }
183003 : #endif
183004 :
183005 :
183006 :
183007 : // End of memberFunctionString
183008 :
183009 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
183010 :
183011 0 : SgRewindStatement* isSgRewindStatement ( SgNode* inputDerivedClassPointer )
183012 : {
183013 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
183014 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
183015 : // So to fix this we return NULL directly when the input is NULL and avoid the
183016 : // dynamic_cast in this case. This is likely a performance improvement as well.
183017 : // return dynamic_cast<SgRewindStatement*>(inputDerivedClassPointer);
183018 : // Milind Chabbi (8/28/2013): isSgRewindStatement uses table-driven castability instead of c++ default dynamic_cast
183019 : // this improves the running time performance by 10-20%.
183020 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRewindStatement*>(inputDerivedClassPointer);
183021 0 : return IS_SgRewindStatement_FAST_MACRO(inputDerivedClassPointer);
183022 : }
183023 :
183024 : // DQ (11/8/2003): Added version of functions taking const pointer
183025 0 : const SgRewindStatement* isSgRewindStatement ( const SgNode* inputDerivedClassPointer )
183026 : {
183027 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
183028 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
183029 : // So to fix this we return NULL directly when the input is NULL and avoid the
183030 : // dynamic_cast in this case. This is likely a performance improvement as well.
183031 : // return dynamic_cast<const SgRewindStatement*>(inputDerivedClassPointer);
183032 : // Milind Chabbi (8/28/2013): isSgRewindStatement uses table-driven castability instead of c++ default dynamic_cast
183033 : // this improves the running time performance by 10-20%.
183034 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRewindStatement*>(inputDerivedClassPointer);
183035 0 : return IS_SgRewindStatement_FAST_MACRO(inputDerivedClassPointer);
183036 : }
183037 :
183038 :
183039 :
183040 : /* #line 183041 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183041 :
183042 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
183043 :
183044 : /**
183045 : \brief Generated destructor
183046 :
183047 : This destructor is automatically generated (by ROSETTA). This destructor
183048 : only frees memory of data members associated with the parts of the current IR node which
183049 : are NOT traversed. Those data members that are part of a traversal can be freed using
183050 : a traversal (calling this destructor on all children in a post-order traversal). Such
183051 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
183052 :
183053 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
183054 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
183055 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
183056 :
183057 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
183058 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
183059 : pointers are not yet implemented to call delete on eash pointer in the container.
183060 : (This could be done by derivation from the STL containers to define containers that
183061 : automatically deleted their members.)
183062 :
183063 : */
183064 0 : SgRewindStatement::~SgRewindStatement () {
183065 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
183066 :
183067 :
183068 :
183069 : }
183070 :
183071 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
183072 0 : }
183073 :
183074 :
183075 : /* #line 183076 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183076 :
183077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
183078 :
183079 : // Generated constructor
183080 0 : SgRewindStatement::SgRewindStatement ( Sg_File_Info* startOfConstruct )
183081 0 : : SgIOStatement(startOfConstruct)
183082 : {
183083 : #ifdef DEBUG
183084 : // printf ("In SgRewindStatement::SgRewindStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
183085 : #endif
183086 : #if 0
183087 : // debugging information!
183088 : printf ("In SgRewindStatement::SgRewindStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
183089 : #endif
183090 :
183091 :
183092 :
183093 : #if 0
183094 : // DQ (7/30/2014): Call a virtual function.
183095 : std::string s = this->class_name();
183096 : #endif
183097 :
183098 : // Test the variant virtual function
183099 : // assert(REWIND_STATEMENT == variant());
183100 0 : assert(REWIND_STATEMENT == this->variant());
183101 0 : ROSE_ASSERT(REWIND_STATEMENT == (int)(this->variantT()));
183102 0 : post_construction_initialization();
183103 :
183104 : // Test the isSgRewindStatement() function since it has been problematic
183105 0 : assert(isSgRewindStatement(this) != NULL);
183106 0 : }
183107 :
183108 : // Generated constructor (all data members)
183109 :
183110 : /* #line 183111 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183111 :
183112 :
183113 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
183114 :
183115 :
183116 : // ********************************************************
183117 : // member functions common across all array grammar objects
183118 : // ********************************************************
183119 :
183120 :
183121 :
183122 : /* #line 183123 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183123 :
183124 :
183125 :
183126 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
183127 :
183128 : // ********************************************************
183129 : // member functions specific to each node in the grammar
183130 : // ********************************************************
183131 :
183132 :
183133 : /* #line 183134 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183134 :
183135 : // Start of memberFunctionString
183136 : /* #line 18450 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
183137 :
183138 :
183139 : void
183140 0 : SgEndfileStatement::post_construction_initialization()
183141 0 : {}
183142 :
183143 :
183144 :
183145 : // End of memberFunctionString
183146 : // Start of memberFunctionString
183147 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
183148 :
183149 : // *** COMMON CODE SECTION BEGINS HERE ***
183150 :
183151 : #if 0
183152 : int
183153 : SgEndfileStatement::getVariant() const
183154 : {
183155 : // This function is used in ROSE while "variant()" is used in SAGE
183156 : assert(this != NULL);
183157 : return variant();
183158 : }
183159 : #endif
183160 :
183161 : // This function is used in ROSE in treeTraversal code
183162 : // eventually replaces getVariant() and variant()
183163 : // though after variant() has been removed for a while we will
183164 : // want to change the name of variantT() back to variant()
183165 : // (since the "T" was ment to stand for temporary).
183166 : // When this happens the variantT() will be depricated.
183167 : VariantT
183168 0 : SgEndfileStatement::variantT() const
183169 : {
183170 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
183171 0 : ROSE_ASSERT(this != NULL);
183172 0 : return V_SgEndfileStatement;
183173 : }
183174 :
183175 : #if 0
183176 : int
183177 : SgEndfileStatement::variant() const
183178 : {
183179 : // This function is used in SAGE
183180 : ROSE_ASSERT(this != NULL);
183181 : return ENDFILE_STATEMENT;
183182 : }
183183 : #endif
183184 :
183185 : ROSE_DLL_API const char*
183186 0 : SgEndfileStatement::sage_class_name() const
183187 : {
183188 0 : ROSE_ASSERT(this != NULL);
183189 0 : return "SgEndfileStatement";
183190 : }
183191 :
183192 : std::string
183193 0 : SgEndfileStatement::class_name() const
183194 : {
183195 0 : ROSE_ASSERT(this != NULL);
183196 0 : return "SgEndfileStatement";
183197 : }
183198 :
183199 : // DQ (11/26/2005): Support for visitor pattern mechanims
183200 : // (inferior to ROSE traversal mechanism, experimental).
183201 : void
183202 0 : SgEndfileStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
183203 : {
183204 0 : ROSE_ASSERT(this != NULL);
183205 0 : visitor.visit(this);
183206 0 : }
183207 :
183208 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
183209 0 : void SgEndfileStatement::accept (ROSE_VisitorPattern & visitor) {
183210 0 : ROSE_ASSERT(this != NULL);
183211 0 : visitor.visit(this);
183212 0 : }
183213 :
183214 : SgEndfileStatement*
183215 0 : SgEndfileStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
183216 : {
183217 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
183218 : // This function is currently only supported for the AST used the represent Binary executables.
183219 : if (0 /* isSgAsmNode(this) != NULL */)
183220 : {
183221 : // Support for regex specification.
183222 : std::string prefixCode = "REGEX:";
183223 : addNewAttribute(prefixCode + s,a);
183224 : }
183225 : #endif
183226 :
183227 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
183228 0 : return this;
183229 : }
183230 :
183231 : // *** COMMON CODE SECTION ENDS HERE ***
183232 :
183233 :
183234 : // End of memberFunctionString
183235 : // Start of memberFunctionString
183236 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
183237 :
183238 :
183239 : #if 0
183240 : //! Error checking support
183241 : /*! Verifies the following:
183242 : - working getVariant() member function
183243 : - calls base class's error() member function
183244 : Every class has one of these functions.
183245 : */
183246 : bool
183247 : SgEndfileStatement::error()
183248 : {
183249 : // Put error checking here
183250 :
183251 : ROSE_ASSERT (this != NULL);
183252 : if (getVariant() != ENDFILE_STATEMENT)
183253 : {
183254 : printf ("Error in SgEndfileStatement::error(): SgEndfileStatement object has a %s variant \n",
183255 : Cxx_GrammarTerminalNames[getVariant()].name);
183256 : // printf ("Error in SgEndfileStatement::error() \n");
183257 : ROSE_ABORT();
183258 : }
183259 :
183260 : ROSE_ASSERT (getVariant() == ENDFILE_STATEMENT);
183261 : return SgIOStatement::error();
183262 : }
183263 : #endif
183264 :
183265 :
183266 :
183267 : // End of memberFunctionString
183268 :
183269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
183270 :
183271 0 : SgEndfileStatement* isSgEndfileStatement ( SgNode* inputDerivedClassPointer )
183272 : {
183273 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
183274 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
183275 : // So to fix this we return NULL directly when the input is NULL and avoid the
183276 : // dynamic_cast in this case. This is likely a performance improvement as well.
183277 : // return dynamic_cast<SgEndfileStatement*>(inputDerivedClassPointer);
183278 : // Milind Chabbi (8/28/2013): isSgEndfileStatement uses table-driven castability instead of c++ default dynamic_cast
183279 : // this improves the running time performance by 10-20%.
183280 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEndfileStatement*>(inputDerivedClassPointer);
183281 0 : return IS_SgEndfileStatement_FAST_MACRO(inputDerivedClassPointer);
183282 : }
183283 :
183284 : // DQ (11/8/2003): Added version of functions taking const pointer
183285 0 : const SgEndfileStatement* isSgEndfileStatement ( const SgNode* inputDerivedClassPointer )
183286 : {
183287 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
183288 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
183289 : // So to fix this we return NULL directly when the input is NULL and avoid the
183290 : // dynamic_cast in this case. This is likely a performance improvement as well.
183291 : // return dynamic_cast<const SgEndfileStatement*>(inputDerivedClassPointer);
183292 : // Milind Chabbi (8/28/2013): isSgEndfileStatement uses table-driven castability instead of c++ default dynamic_cast
183293 : // this improves the running time performance by 10-20%.
183294 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEndfileStatement*>(inputDerivedClassPointer);
183295 0 : return IS_SgEndfileStatement_FAST_MACRO(inputDerivedClassPointer);
183296 : }
183297 :
183298 :
183299 :
183300 : /* #line 183301 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183301 :
183302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
183303 :
183304 : /**
183305 : \brief Generated destructor
183306 :
183307 : This destructor is automatically generated (by ROSETTA). This destructor
183308 : only frees memory of data members associated with the parts of the current IR node which
183309 : are NOT traversed. Those data members that are part of a traversal can be freed using
183310 : a traversal (calling this destructor on all children in a post-order traversal). Such
183311 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
183312 :
183313 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
183314 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
183315 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
183316 :
183317 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
183318 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
183319 : pointers are not yet implemented to call delete on eash pointer in the container.
183320 : (This could be done by derivation from the STL containers to define containers that
183321 : automatically deleted their members.)
183322 :
183323 : */
183324 0 : SgEndfileStatement::~SgEndfileStatement () {
183325 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
183326 :
183327 :
183328 :
183329 : }
183330 :
183331 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
183332 0 : }
183333 :
183334 :
183335 : /* #line 183336 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183336 :
183337 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
183338 :
183339 : // Generated constructor
183340 0 : SgEndfileStatement::SgEndfileStatement ( Sg_File_Info* startOfConstruct )
183341 0 : : SgIOStatement(startOfConstruct)
183342 : {
183343 : #ifdef DEBUG
183344 : // printf ("In SgEndfileStatement::SgEndfileStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
183345 : #endif
183346 : #if 0
183347 : // debugging information!
183348 : printf ("In SgEndfileStatement::SgEndfileStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
183349 : #endif
183350 :
183351 :
183352 :
183353 : #if 0
183354 : // DQ (7/30/2014): Call a virtual function.
183355 : std::string s = this->class_name();
183356 : #endif
183357 :
183358 : // Test the variant virtual function
183359 : // assert(ENDFILE_STATEMENT == variant());
183360 0 : assert(ENDFILE_STATEMENT == this->variant());
183361 0 : ROSE_ASSERT(ENDFILE_STATEMENT == (int)(this->variantT()));
183362 0 : post_construction_initialization();
183363 :
183364 : // Test the isSgEndfileStatement() function since it has been problematic
183365 0 : assert(isSgEndfileStatement(this) != NULL);
183366 0 : }
183367 :
183368 : // Generated constructor (all data members)
183369 :
183370 : /* #line 183371 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183371 :
183372 :
183373 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
183374 :
183375 :
183376 : // ********************************************************
183377 : // member functions common across all array grammar objects
183378 : // ********************************************************
183379 :
183380 :
183381 :
183382 : /* #line 183383 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183383 :
183384 :
183385 :
183386 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
183387 :
183388 : // ********************************************************
183389 : // member functions specific to each node in the grammar
183390 : // ********************************************************
183391 :
183392 :
183393 : /* #line 183394 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183394 :
183395 : // Start of memberFunctionString
183396 : /* #line 18459 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
183397 :
183398 :
183399 : void
183400 0 : SgWaitStatement::post_construction_initialization()
183401 0 : {}
183402 :
183403 :
183404 :
183405 : // End of memberFunctionString
183406 : // Start of memberFunctionString
183407 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
183408 :
183409 : // *** COMMON CODE SECTION BEGINS HERE ***
183410 :
183411 : #if 0
183412 : int
183413 : SgWaitStatement::getVariant() const
183414 : {
183415 : // This function is used in ROSE while "variant()" is used in SAGE
183416 : assert(this != NULL);
183417 : return variant();
183418 : }
183419 : #endif
183420 :
183421 : // This function is used in ROSE in treeTraversal code
183422 : // eventually replaces getVariant() and variant()
183423 : // though after variant() has been removed for a while we will
183424 : // want to change the name of variantT() back to variant()
183425 : // (since the "T" was ment to stand for temporary).
183426 : // When this happens the variantT() will be depricated.
183427 : VariantT
183428 0 : SgWaitStatement::variantT() const
183429 : {
183430 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
183431 0 : ROSE_ASSERT(this != NULL);
183432 0 : return V_SgWaitStatement;
183433 : }
183434 :
183435 : #if 0
183436 : int
183437 : SgWaitStatement::variant() const
183438 : {
183439 : // This function is used in SAGE
183440 : ROSE_ASSERT(this != NULL);
183441 : return WAIT_STATEMENT;
183442 : }
183443 : #endif
183444 :
183445 : ROSE_DLL_API const char*
183446 0 : SgWaitStatement::sage_class_name() const
183447 : {
183448 0 : ROSE_ASSERT(this != NULL);
183449 0 : return "SgWaitStatement";
183450 : }
183451 :
183452 : std::string
183453 0 : SgWaitStatement::class_name() const
183454 : {
183455 0 : ROSE_ASSERT(this != NULL);
183456 0 : return "SgWaitStatement";
183457 : }
183458 :
183459 : // DQ (11/26/2005): Support for visitor pattern mechanims
183460 : // (inferior to ROSE traversal mechanism, experimental).
183461 : void
183462 0 : SgWaitStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
183463 : {
183464 0 : ROSE_ASSERT(this != NULL);
183465 0 : visitor.visit(this);
183466 0 : }
183467 :
183468 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
183469 0 : void SgWaitStatement::accept (ROSE_VisitorPattern & visitor) {
183470 0 : ROSE_ASSERT(this != NULL);
183471 0 : visitor.visit(this);
183472 0 : }
183473 :
183474 : SgWaitStatement*
183475 0 : SgWaitStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
183476 : {
183477 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
183478 : // This function is currently only supported for the AST used the represent Binary executables.
183479 : if (0 /* isSgAsmNode(this) != NULL */)
183480 : {
183481 : // Support for regex specification.
183482 : std::string prefixCode = "REGEX:";
183483 : addNewAttribute(prefixCode + s,a);
183484 : }
183485 : #endif
183486 :
183487 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
183488 0 : return this;
183489 : }
183490 :
183491 : // *** COMMON CODE SECTION ENDS HERE ***
183492 :
183493 :
183494 : // End of memberFunctionString
183495 : // Start of memberFunctionString
183496 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
183497 :
183498 :
183499 : #if 0
183500 : //! Error checking support
183501 : /*! Verifies the following:
183502 : - working getVariant() member function
183503 : - calls base class's error() member function
183504 : Every class has one of these functions.
183505 : */
183506 : bool
183507 : SgWaitStatement::error()
183508 : {
183509 : // Put error checking here
183510 :
183511 : ROSE_ASSERT (this != NULL);
183512 : if (getVariant() != WAIT_STATEMENT)
183513 : {
183514 : printf ("Error in SgWaitStatement::error(): SgWaitStatement object has a %s variant \n",
183515 : Cxx_GrammarTerminalNames[getVariant()].name);
183516 : // printf ("Error in SgWaitStatement::error() \n");
183517 : ROSE_ABORT();
183518 : }
183519 :
183520 : ROSE_ASSERT (getVariant() == WAIT_STATEMENT);
183521 : return SgIOStatement::error();
183522 : }
183523 : #endif
183524 :
183525 :
183526 :
183527 : // End of memberFunctionString
183528 :
183529 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
183530 :
183531 0 : SgWaitStatement* isSgWaitStatement ( SgNode* inputDerivedClassPointer )
183532 : {
183533 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
183534 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
183535 : // So to fix this we return NULL directly when the input is NULL and avoid the
183536 : // dynamic_cast in this case. This is likely a performance improvement as well.
183537 : // return dynamic_cast<SgWaitStatement*>(inputDerivedClassPointer);
183538 : // Milind Chabbi (8/28/2013): isSgWaitStatement uses table-driven castability instead of c++ default dynamic_cast
183539 : // this improves the running time performance by 10-20%.
183540 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWaitStatement*>(inputDerivedClassPointer);
183541 0 : return IS_SgWaitStatement_FAST_MACRO(inputDerivedClassPointer);
183542 : }
183543 :
183544 : // DQ (11/8/2003): Added version of functions taking const pointer
183545 0 : const SgWaitStatement* isSgWaitStatement ( const SgNode* inputDerivedClassPointer )
183546 : {
183547 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
183548 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
183549 : // So to fix this we return NULL directly when the input is NULL and avoid the
183550 : // dynamic_cast in this case. This is likely a performance improvement as well.
183551 : // return dynamic_cast<const SgWaitStatement*>(inputDerivedClassPointer);
183552 : // Milind Chabbi (8/28/2013): isSgWaitStatement uses table-driven castability instead of c++ default dynamic_cast
183553 : // this improves the running time performance by 10-20%.
183554 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWaitStatement*>(inputDerivedClassPointer);
183555 0 : return IS_SgWaitStatement_FAST_MACRO(inputDerivedClassPointer);
183556 : }
183557 :
183558 :
183559 :
183560 : /* #line 183561 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183561 :
183562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
183563 :
183564 : /**
183565 : \brief Generated destructor
183566 :
183567 : This destructor is automatically generated (by ROSETTA). This destructor
183568 : only frees memory of data members associated with the parts of the current IR node which
183569 : are NOT traversed. Those data members that are part of a traversal can be freed using
183570 : a traversal (calling this destructor on all children in a post-order traversal). Such
183571 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
183572 :
183573 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
183574 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
183575 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
183576 :
183577 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
183578 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
183579 : pointers are not yet implemented to call delete on eash pointer in the container.
183580 : (This could be done by derivation from the STL containers to define containers that
183581 : automatically deleted their members.)
183582 :
183583 : */
183584 0 : SgWaitStatement::~SgWaitStatement () {
183585 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
183586 :
183587 :
183588 :
183589 : }
183590 :
183591 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
183592 0 : }
183593 :
183594 :
183595 : /* #line 183596 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183596 :
183597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
183598 :
183599 : // Generated constructor
183600 0 : SgWaitStatement::SgWaitStatement ( Sg_File_Info* startOfConstruct )
183601 0 : : SgIOStatement(startOfConstruct)
183602 : {
183603 : #ifdef DEBUG
183604 : // printf ("In SgWaitStatement::SgWaitStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
183605 : #endif
183606 : #if 0
183607 : // debugging information!
183608 : printf ("In SgWaitStatement::SgWaitStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
183609 : #endif
183610 :
183611 :
183612 :
183613 : #if 0
183614 : // DQ (7/30/2014): Call a virtual function.
183615 : std::string s = this->class_name();
183616 : #endif
183617 :
183618 : // Test the variant virtual function
183619 : // assert(WAIT_STATEMENT == variant());
183620 0 : assert(WAIT_STATEMENT == this->variant());
183621 0 : ROSE_ASSERT(WAIT_STATEMENT == (int)(this->variantT()));
183622 0 : post_construction_initialization();
183623 :
183624 : // Test the isSgWaitStatement() function since it has been problematic
183625 0 : assert(isSgWaitStatement(this) != NULL);
183626 0 : }
183627 :
183628 : // Generated constructor (all data members)
183629 :
183630 : /* #line 183631 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183631 :
183632 :
183633 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
183634 :
183635 :
183636 : // ********************************************************
183637 : // member functions common across all array grammar objects
183638 : // ********************************************************
183639 :
183640 :
183641 :
183642 : /* #line 183643 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183643 :
183644 :
183645 :
183646 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
183647 :
183648 : // ********************************************************
183649 : // member functions specific to each node in the grammar
183650 : // ********************************************************
183651 :
183652 :
183653 : /* #line 183654 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
183654 :
183655 : // Start of memberFunctionString
183656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
183657 :
183658 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
183659 :
183660 : SgExpression*
183661 0 : SgWhereStatement::get_condition () const
183662 : {
183663 0 : ROSE_ASSERT (this != NULL);
183664 :
183665 : #if 0
183666 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183667 : // used to trigger marking transformations for the token-based unparsing.
183668 : printf ("SgWhereStatement::get_condition = %p = %s \n",this,this->class_name().c_str());
183669 : #endif
183670 :
183671 0 : return p_condition;
183672 : }
183673 :
183674 : void
183675 0 : SgWhereStatement::set_condition ( SgExpression* condition )
183676 : {
183677 0 : ROSE_ASSERT (this != NULL);
183678 :
183679 : #if 0
183680 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183681 : // used to trigger marking transformations for the token-based unparsing.
183682 : printf ("SgWhereStatement::set_condition = %p = %s \n",this,this->class_name().c_str());
183683 : #endif
183684 :
183685 0 : set_isModified(true);
183686 :
183687 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
183688 : if (p_condition != NULL && condition != NULL && p_condition != condition)
183689 : {
183690 : printf ("Warning: condition = %p overwriting valid pointer p_condition = %p \n",condition,p_condition);
183691 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
183692 : printf ("Error fails assertion (p_condition != NULL && condition != NULL && p_condition != condition) is false\n");
183693 : ROSE_ASSERT(false);
183694 : #endif
183695 : }
183696 : #endif
183697 0 : p_condition = condition;
183698 0 : }
183699 :
183700 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
183701 :
183702 :
183703 : // End of memberFunctionString
183704 : // Start of memberFunctionString
183705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
183706 :
183707 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
183708 :
183709 : SgBasicBlock*
183710 0 : SgWhereStatement::get_body () const
183711 : {
183712 0 : ROSE_ASSERT (this != NULL);
183713 :
183714 : #if 0
183715 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183716 : // used to trigger marking transformations for the token-based unparsing.
183717 : printf ("SgWhereStatement::get_body = %p = %s \n",this,this->class_name().c_str());
183718 : #endif
183719 :
183720 0 : return p_body;
183721 : }
183722 :
183723 : void
183724 0 : SgWhereStatement::set_body ( SgBasicBlock* body )
183725 : {
183726 0 : ROSE_ASSERT (this != NULL);
183727 :
183728 : #if 0
183729 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183730 : // used to trigger marking transformations for the token-based unparsing.
183731 : printf ("SgWhereStatement::set_body = %p = %s \n",this,this->class_name().c_str());
183732 : #endif
183733 :
183734 0 : set_isModified(true);
183735 :
183736 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
183737 : if (p_body != NULL && body != NULL && p_body != body)
183738 : {
183739 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
183740 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
183741 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
183742 : ROSE_ASSERT(false);
183743 : #endif
183744 : }
183745 : #endif
183746 0 : p_body = body;
183747 0 : }
183748 :
183749 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
183750 :
183751 :
183752 : // End of memberFunctionString
183753 : // Start of memberFunctionString
183754 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
183755 :
183756 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
183757 :
183758 : SgElseWhereStatement*
183759 0 : SgWhereStatement::get_elsewhere () const
183760 : {
183761 0 : ROSE_ASSERT (this != NULL);
183762 :
183763 : #if 0
183764 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183765 : // used to trigger marking transformations for the token-based unparsing.
183766 : printf ("SgWhereStatement::get_elsewhere = %p = %s \n",this,this->class_name().c_str());
183767 : #endif
183768 :
183769 0 : return p_elsewhere;
183770 : }
183771 :
183772 : void
183773 0 : SgWhereStatement::set_elsewhere ( SgElseWhereStatement* elsewhere )
183774 : {
183775 0 : ROSE_ASSERT (this != NULL);
183776 :
183777 : #if 0
183778 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183779 : // used to trigger marking transformations for the token-based unparsing.
183780 : printf ("SgWhereStatement::set_elsewhere = %p = %s \n",this,this->class_name().c_str());
183781 : #endif
183782 :
183783 0 : set_isModified(true);
183784 :
183785 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
183786 : if (p_elsewhere != NULL && elsewhere != NULL && p_elsewhere != elsewhere)
183787 : {
183788 : printf ("Warning: elsewhere = %p overwriting valid pointer p_elsewhere = %p \n",elsewhere,p_elsewhere);
183789 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
183790 : printf ("Error fails assertion (p_elsewhere != NULL && elsewhere != NULL && p_elsewhere != elsewhere) is false\n");
183791 : ROSE_ASSERT(false);
183792 : #endif
183793 : }
183794 : #endif
183795 0 : p_elsewhere = elsewhere;
183796 0 : }
183797 :
183798 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
183799 :
183800 :
183801 : // End of memberFunctionString
183802 : // Start of memberFunctionString
183803 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
183804 :
183805 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
183806 :
183807 : SgLabelRefExp*
183808 0 : SgWhereStatement::get_end_numeric_label () const
183809 : {
183810 0 : ROSE_ASSERT (this != NULL);
183811 :
183812 : #if 0
183813 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183814 : // used to trigger marking transformations for the token-based unparsing.
183815 : printf ("SgWhereStatement::get_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
183816 : #endif
183817 :
183818 0 : return p_end_numeric_label;
183819 : }
183820 :
183821 : void
183822 0 : SgWhereStatement::set_end_numeric_label ( SgLabelRefExp* end_numeric_label )
183823 : {
183824 0 : ROSE_ASSERT (this != NULL);
183825 :
183826 : #if 0
183827 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183828 : // used to trigger marking transformations for the token-based unparsing.
183829 : printf ("SgWhereStatement::set_end_numeric_label = %p = %s \n",this,this->class_name().c_str());
183830 : #endif
183831 :
183832 0 : set_isModified(true);
183833 :
183834 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
183835 : if (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label)
183836 : {
183837 : printf ("Warning: end_numeric_label = %p overwriting valid pointer p_end_numeric_label = %p \n",end_numeric_label,p_end_numeric_label);
183838 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
183839 : printf ("Error fails assertion (p_end_numeric_label != NULL && end_numeric_label != NULL && p_end_numeric_label != end_numeric_label) is false\n");
183840 : ROSE_ASSERT(false);
183841 : #endif
183842 : }
183843 : #endif
183844 0 : p_end_numeric_label = end_numeric_label;
183845 0 : }
183846 :
183847 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
183848 :
183849 :
183850 : // End of memberFunctionString
183851 : // Start of memberFunctionString
183852 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
183853 :
183854 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
183855 :
183856 : std::string
183857 0 : SgWhereStatement::get_string_label () const
183858 : {
183859 0 : ROSE_ASSERT (this != NULL);
183860 :
183861 : #if 0
183862 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183863 : // used to trigger marking transformations for the token-based unparsing.
183864 : printf ("SgWhereStatement::get_string_label = %p = %s \n",this,this->class_name().c_str());
183865 : #endif
183866 :
183867 0 : return p_string_label;
183868 : }
183869 :
183870 : void
183871 0 : SgWhereStatement::set_string_label ( std::string string_label )
183872 : {
183873 0 : ROSE_ASSERT (this != NULL);
183874 :
183875 : #if 0
183876 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183877 : // used to trigger marking transformations for the token-based unparsing.
183878 : printf ("SgWhereStatement::set_string_label = %p = %s \n",this,this->class_name().c_str());
183879 : #endif
183880 :
183881 0 : set_isModified(true);
183882 :
183883 0 : p_string_label = string_label;
183884 0 : }
183885 :
183886 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
183887 :
183888 :
183889 : // End of memberFunctionString
183890 : // Start of memberFunctionString
183891 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
183892 :
183893 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
183894 :
183895 : bool
183896 0 : SgWhereStatement::get_has_end_statement () const
183897 : {
183898 0 : ROSE_ASSERT (this != NULL);
183899 :
183900 : #if 0
183901 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183902 : // used to trigger marking transformations for the token-based unparsing.
183903 : printf ("SgWhereStatement::get_has_end_statement = %p = %s \n",this,this->class_name().c_str());
183904 : #endif
183905 :
183906 0 : return p_has_end_statement;
183907 : }
183908 :
183909 : void
183910 0 : SgWhereStatement::set_has_end_statement ( bool has_end_statement )
183911 : {
183912 0 : ROSE_ASSERT (this != NULL);
183913 :
183914 : #if 0
183915 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
183916 : // used to trigger marking transformations for the token-based unparsing.
183917 : printf ("SgWhereStatement::set_has_end_statement = %p = %s \n",this,this->class_name().c_str());
183918 : #endif
183919 :
183920 0 : set_isModified(true);
183921 :
183922 0 : p_has_end_statement = has_end_statement;
183923 0 : }
183924 :
183925 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
183926 :
183927 :
183928 : // End of memberFunctionString
183929 : // Start of memberFunctionString
183930 : /* #line 18559 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
183931 :
183932 : void
183933 0 : SgWhereStatement::post_construction_initialization()
183934 0 : {}
183935 :
183936 :
183937 : // End of memberFunctionString
183938 : // Start of memberFunctionString
183939 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
183940 :
183941 : // *** COMMON CODE SECTION BEGINS HERE ***
183942 :
183943 : #if 0
183944 : int
183945 : SgWhereStatement::getVariant() const
183946 : {
183947 : // This function is used in ROSE while "variant()" is used in SAGE
183948 : assert(this != NULL);
183949 : return variant();
183950 : }
183951 : #endif
183952 :
183953 : // This function is used in ROSE in treeTraversal code
183954 : // eventually replaces getVariant() and variant()
183955 : // though after variant() has been removed for a while we will
183956 : // want to change the name of variantT() back to variant()
183957 : // (since the "T" was ment to stand for temporary).
183958 : // When this happens the variantT() will be depricated.
183959 : VariantT
183960 0 : SgWhereStatement::variantT() const
183961 : {
183962 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
183963 0 : ROSE_ASSERT(this != NULL);
183964 0 : return V_SgWhereStatement;
183965 : }
183966 :
183967 : #if 0
183968 : int
183969 : SgWhereStatement::variant() const
183970 : {
183971 : // This function is used in SAGE
183972 : ROSE_ASSERT(this != NULL);
183973 : return TEMP_Where_Statement;
183974 : }
183975 : #endif
183976 :
183977 : ROSE_DLL_API const char*
183978 0 : SgWhereStatement::sage_class_name() const
183979 : {
183980 0 : ROSE_ASSERT(this != NULL);
183981 0 : return "SgWhereStatement";
183982 : }
183983 :
183984 : std::string
183985 0 : SgWhereStatement::class_name() const
183986 : {
183987 0 : ROSE_ASSERT(this != NULL);
183988 0 : return "SgWhereStatement";
183989 : }
183990 :
183991 : // DQ (11/26/2005): Support for visitor pattern mechanims
183992 : // (inferior to ROSE traversal mechanism, experimental).
183993 : void
183994 0 : SgWhereStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
183995 : {
183996 0 : ROSE_ASSERT(this != NULL);
183997 0 : visitor.visit(this);
183998 0 : }
183999 :
184000 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
184001 0 : void SgWhereStatement::accept (ROSE_VisitorPattern & visitor) {
184002 0 : ROSE_ASSERT(this != NULL);
184003 0 : visitor.visit(this);
184004 0 : }
184005 :
184006 : SgWhereStatement*
184007 0 : SgWhereStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
184008 : {
184009 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
184010 : // This function is currently only supported for the AST used the represent Binary executables.
184011 : if (0 /* isSgAsmNode(this) != NULL */)
184012 : {
184013 : // Support for regex specification.
184014 : std::string prefixCode = "REGEX:";
184015 : addNewAttribute(prefixCode + s,a);
184016 : }
184017 : #endif
184018 :
184019 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
184020 0 : return this;
184021 : }
184022 :
184023 : // *** COMMON CODE SECTION ENDS HERE ***
184024 :
184025 :
184026 : // End of memberFunctionString
184027 : // Start of memberFunctionString
184028 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
184029 :
184030 :
184031 : #if 0
184032 : //! Error checking support
184033 : /*! Verifies the following:
184034 : - working getVariant() member function
184035 : - calls base class's error() member function
184036 : Every class has one of these functions.
184037 : */
184038 : bool
184039 : SgWhereStatement::error()
184040 : {
184041 : // Put error checking here
184042 :
184043 : ROSE_ASSERT (this != NULL);
184044 : if (getVariant() != TEMP_Where_Statement)
184045 : {
184046 : printf ("Error in SgWhereStatement::error(): SgWhereStatement object has a %s variant \n",
184047 : Cxx_GrammarTerminalNames[getVariant()].name);
184048 : // printf ("Error in SgWhereStatement::error() \n");
184049 : ROSE_ABORT();
184050 : }
184051 :
184052 : ROSE_ASSERT (getVariant() == TEMP_Where_Statement);
184053 : return SgStatement::error();
184054 : }
184055 : #endif
184056 :
184057 :
184058 :
184059 : // End of memberFunctionString
184060 :
184061 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
184062 :
184063 43 : SgWhereStatement* isSgWhereStatement ( SgNode* inputDerivedClassPointer )
184064 : {
184065 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
184066 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
184067 : // So to fix this we return NULL directly when the input is NULL and avoid the
184068 : // dynamic_cast in this case. This is likely a performance improvement as well.
184069 : // return dynamic_cast<SgWhereStatement*>(inputDerivedClassPointer);
184070 : // Milind Chabbi (8/28/2013): isSgWhereStatement uses table-driven castability instead of c++ default dynamic_cast
184071 : // this improves the running time performance by 10-20%.
184072 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWhereStatement*>(inputDerivedClassPointer);
184073 43 : return IS_SgWhereStatement_FAST_MACRO(inputDerivedClassPointer);
184074 : }
184075 :
184076 : // DQ (11/8/2003): Added version of functions taking const pointer
184077 0 : const SgWhereStatement* isSgWhereStatement ( const SgNode* inputDerivedClassPointer )
184078 : {
184079 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
184080 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
184081 : // So to fix this we return NULL directly when the input is NULL and avoid the
184082 : // dynamic_cast in this case. This is likely a performance improvement as well.
184083 : // return dynamic_cast<const SgWhereStatement*>(inputDerivedClassPointer);
184084 : // Milind Chabbi (8/28/2013): isSgWhereStatement uses table-driven castability instead of c++ default dynamic_cast
184085 : // this improves the running time performance by 10-20%.
184086 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWhereStatement*>(inputDerivedClassPointer);
184087 0 : return IS_SgWhereStatement_FAST_MACRO(inputDerivedClassPointer);
184088 : }
184089 :
184090 :
184091 :
184092 : /* #line 184093 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184093 :
184094 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
184095 :
184096 : /**
184097 : \brief Generated destructor
184098 :
184099 : This destructor is automatically generated (by ROSETTA). This destructor
184100 : only frees memory of data members associated with the parts of the current IR node which
184101 : are NOT traversed. Those data members that are part of a traversal can be freed using
184102 : a traversal (calling this destructor on all children in a post-order traversal). Such
184103 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
184104 :
184105 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
184106 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
184107 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
184108 :
184109 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
184110 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
184111 : pointers are not yet implemented to call delete on eash pointer in the container.
184112 : (This could be done by derivation from the STL containers to define containers that
184113 : automatically deleted their members.)
184114 :
184115 : */
184116 0 : SgWhereStatement::~SgWhereStatement () {
184117 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
184118 :
184119 :
184120 : // case: not a listType for condition
184121 0 : p_condition = NULL; // non list case
184122 : // case: not a listType for body
184123 0 : p_body = NULL; // non list case
184124 : // case: not a listType for elsewhere
184125 0 : p_elsewhere = NULL; // non list case
184126 : // case: not a listType for end_numeric_label
184127 0 : p_end_numeric_label = NULL; // non list case
184128 : // case: not a listType for string_label
184129 0 : p_string_label = ""; // non list case
184130 : // case: not a listType for has_end_statement
184131 0 : p_has_end_statement = false; // non list case
184132 :
184133 : }
184134 :
184135 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
184136 0 : }
184137 :
184138 :
184139 : /* #line 184140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184140 :
184141 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
184142 :
184143 : // Generated constructor
184144 0 : SgWhereStatement::SgWhereStatement ( Sg_File_Info* startOfConstruct, SgExpression* condition, SgBasicBlock* body, SgElseWhereStatement* elsewhere )
184145 0 : : SgStatement(startOfConstruct)
184146 : {
184147 : #ifdef DEBUG
184148 : // printf ("In SgWhereStatement::SgWhereStatement (Sg_File_Info* startOfConstruct, SgExpression* condition, SgBasicBlock* body, SgElseWhereStatement* elsewhere) sage_class_name() = %s \n",sage_class_name());
184149 : #endif
184150 : #if 0
184151 : // debugging information!
184152 : printf ("In SgWhereStatement::SgWhereStatement (Sg_File_Info* startOfConstruct, SgExpression* condition, SgBasicBlock* body, SgElseWhereStatement* elsewhere): this = %p = %s \n",this,this->class_name().c_str());
184153 : #endif
184154 :
184155 0 : p_condition = condition;
184156 0 : p_body = body;
184157 0 : p_elsewhere = elsewhere;
184158 0 : p_end_numeric_label = NULL;
184159 0 : p_string_label = "";
184160 0 : p_has_end_statement = false;
184161 :
184162 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
184163 :
184164 : #if 0
184165 : // DQ (7/30/2014): Call a virtual function.
184166 : std::string s = this->class_name();
184167 : #endif
184168 :
184169 : // Test the variant virtual function
184170 : // assert(TEMP_Where_Statement == variant());
184171 0 : assert(TEMP_Where_Statement == this->variant());
184172 0 : ROSE_ASSERT(TEMP_Where_Statement == (int)(this->variantT()));
184173 0 : post_construction_initialization();
184174 :
184175 : // Test the isSgWhereStatement() function since it has been problematic
184176 0 : assert(isSgWhereStatement(this) != NULL);
184177 0 : }
184178 :
184179 : // Generated constructor (all data members)
184180 :
184181 : /* #line 184182 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184182 :
184183 :
184184 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
184185 :
184186 :
184187 : // ********************************************************
184188 : // member functions common across all array grammar objects
184189 : // ********************************************************
184190 :
184191 :
184192 :
184193 : /* #line 184194 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184194 :
184195 :
184196 :
184197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
184198 :
184199 : // ********************************************************
184200 : // member functions specific to each node in the grammar
184201 : // ********************************************************
184202 :
184203 :
184204 : /* #line 184205 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184205 :
184206 : // Start of memberFunctionString
184207 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
184208 :
184209 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
184210 :
184211 : SgExpression*
184212 0 : SgElseWhereStatement::get_condition () const
184213 : {
184214 0 : ROSE_ASSERT (this != NULL);
184215 :
184216 : #if 0
184217 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184218 : // used to trigger marking transformations for the token-based unparsing.
184219 : printf ("SgElseWhereStatement::get_condition = %p = %s \n",this,this->class_name().c_str());
184220 : #endif
184221 :
184222 0 : return p_condition;
184223 : }
184224 :
184225 : void
184226 0 : SgElseWhereStatement::set_condition ( SgExpression* condition )
184227 : {
184228 0 : ROSE_ASSERT (this != NULL);
184229 :
184230 : #if 0
184231 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184232 : // used to trigger marking transformations for the token-based unparsing.
184233 : printf ("SgElseWhereStatement::set_condition = %p = %s \n",this,this->class_name().c_str());
184234 : #endif
184235 :
184236 0 : set_isModified(true);
184237 :
184238 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
184239 : if (p_condition != NULL && condition != NULL && p_condition != condition)
184240 : {
184241 : printf ("Warning: condition = %p overwriting valid pointer p_condition = %p \n",condition,p_condition);
184242 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
184243 : printf ("Error fails assertion (p_condition != NULL && condition != NULL && p_condition != condition) is false\n");
184244 : ROSE_ASSERT(false);
184245 : #endif
184246 : }
184247 : #endif
184248 0 : p_condition = condition;
184249 0 : }
184250 :
184251 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
184252 :
184253 :
184254 : // End of memberFunctionString
184255 : // Start of memberFunctionString
184256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
184257 :
184258 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
184259 :
184260 : SgBasicBlock*
184261 0 : SgElseWhereStatement::get_body () const
184262 : {
184263 0 : ROSE_ASSERT (this != NULL);
184264 :
184265 : #if 0
184266 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184267 : // used to trigger marking transformations for the token-based unparsing.
184268 : printf ("SgElseWhereStatement::get_body = %p = %s \n",this,this->class_name().c_str());
184269 : #endif
184270 :
184271 0 : return p_body;
184272 : }
184273 :
184274 : void
184275 0 : SgElseWhereStatement::set_body ( SgBasicBlock* body )
184276 : {
184277 0 : ROSE_ASSERT (this != NULL);
184278 :
184279 : #if 0
184280 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184281 : // used to trigger marking transformations for the token-based unparsing.
184282 : printf ("SgElseWhereStatement::set_body = %p = %s \n",this,this->class_name().c_str());
184283 : #endif
184284 :
184285 0 : set_isModified(true);
184286 :
184287 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
184288 : if (p_body != NULL && body != NULL && p_body != body)
184289 : {
184290 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
184291 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
184292 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
184293 : ROSE_ASSERT(false);
184294 : #endif
184295 : }
184296 : #endif
184297 0 : p_body = body;
184298 0 : }
184299 :
184300 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
184301 :
184302 :
184303 : // End of memberFunctionString
184304 : // Start of memberFunctionString
184305 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
184306 :
184307 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
184308 :
184309 : SgElseWhereStatement*
184310 0 : SgElseWhereStatement::get_elsewhere () const
184311 : {
184312 0 : ROSE_ASSERT (this != NULL);
184313 :
184314 : #if 0
184315 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184316 : // used to trigger marking transformations for the token-based unparsing.
184317 : printf ("SgElseWhereStatement::get_elsewhere = %p = %s \n",this,this->class_name().c_str());
184318 : #endif
184319 :
184320 0 : return p_elsewhere;
184321 : }
184322 :
184323 : void
184324 0 : SgElseWhereStatement::set_elsewhere ( SgElseWhereStatement* elsewhere )
184325 : {
184326 0 : ROSE_ASSERT (this != NULL);
184327 :
184328 : #if 0
184329 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184330 : // used to trigger marking transformations for the token-based unparsing.
184331 : printf ("SgElseWhereStatement::set_elsewhere = %p = %s \n",this,this->class_name().c_str());
184332 : #endif
184333 :
184334 0 : set_isModified(true);
184335 :
184336 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
184337 : if (p_elsewhere != NULL && elsewhere != NULL && p_elsewhere != elsewhere)
184338 : {
184339 : printf ("Warning: elsewhere = %p overwriting valid pointer p_elsewhere = %p \n",elsewhere,p_elsewhere);
184340 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
184341 : printf ("Error fails assertion (p_elsewhere != NULL && elsewhere != NULL && p_elsewhere != elsewhere) is false\n");
184342 : ROSE_ASSERT(false);
184343 : #endif
184344 : }
184345 : #endif
184346 0 : p_elsewhere = elsewhere;
184347 0 : }
184348 :
184349 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
184350 :
184351 :
184352 : // End of memberFunctionString
184353 : // Start of memberFunctionString
184354 : /* #line 18566 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
184355 :
184356 : void
184357 0 : SgElseWhereStatement::post_construction_initialization()
184358 0 : {}
184359 :
184360 :
184361 : // End of memberFunctionString
184362 : // Start of memberFunctionString
184363 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
184364 :
184365 : // *** COMMON CODE SECTION BEGINS HERE ***
184366 :
184367 : #if 0
184368 : int
184369 : SgElseWhereStatement::getVariant() const
184370 : {
184371 : // This function is used in ROSE while "variant()" is used in SAGE
184372 : assert(this != NULL);
184373 : return variant();
184374 : }
184375 : #endif
184376 :
184377 : // This function is used in ROSE in treeTraversal code
184378 : // eventually replaces getVariant() and variant()
184379 : // though after variant() has been removed for a while we will
184380 : // want to change the name of variantT() back to variant()
184381 : // (since the "T" was ment to stand for temporary).
184382 : // When this happens the variantT() will be depricated.
184383 : VariantT
184384 0 : SgElseWhereStatement::variantT() const
184385 : {
184386 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
184387 0 : ROSE_ASSERT(this != NULL);
184388 0 : return V_SgElseWhereStatement;
184389 : }
184390 :
184391 : #if 0
184392 : int
184393 : SgElseWhereStatement::variant() const
184394 : {
184395 : // This function is used in SAGE
184396 : ROSE_ASSERT(this != NULL);
184397 : return TEMP_Else_Where_Statement;
184398 : }
184399 : #endif
184400 :
184401 : ROSE_DLL_API const char*
184402 0 : SgElseWhereStatement::sage_class_name() const
184403 : {
184404 0 : ROSE_ASSERT(this != NULL);
184405 0 : return "SgElseWhereStatement";
184406 : }
184407 :
184408 : std::string
184409 0 : SgElseWhereStatement::class_name() const
184410 : {
184411 0 : ROSE_ASSERT(this != NULL);
184412 0 : return "SgElseWhereStatement";
184413 : }
184414 :
184415 : // DQ (11/26/2005): Support for visitor pattern mechanims
184416 : // (inferior to ROSE traversal mechanism, experimental).
184417 : void
184418 0 : SgElseWhereStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
184419 : {
184420 0 : ROSE_ASSERT(this != NULL);
184421 0 : visitor.visit(this);
184422 0 : }
184423 :
184424 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
184425 0 : void SgElseWhereStatement::accept (ROSE_VisitorPattern & visitor) {
184426 0 : ROSE_ASSERT(this != NULL);
184427 0 : visitor.visit(this);
184428 0 : }
184429 :
184430 : SgElseWhereStatement*
184431 0 : SgElseWhereStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
184432 : {
184433 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
184434 : // This function is currently only supported for the AST used the represent Binary executables.
184435 : if (0 /* isSgAsmNode(this) != NULL */)
184436 : {
184437 : // Support for regex specification.
184438 : std::string prefixCode = "REGEX:";
184439 : addNewAttribute(prefixCode + s,a);
184440 : }
184441 : #endif
184442 :
184443 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
184444 0 : return this;
184445 : }
184446 :
184447 : // *** COMMON CODE SECTION ENDS HERE ***
184448 :
184449 :
184450 : // End of memberFunctionString
184451 : // Start of memberFunctionString
184452 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
184453 :
184454 :
184455 : #if 0
184456 : //! Error checking support
184457 : /*! Verifies the following:
184458 : - working getVariant() member function
184459 : - calls base class's error() member function
184460 : Every class has one of these functions.
184461 : */
184462 : bool
184463 : SgElseWhereStatement::error()
184464 : {
184465 : // Put error checking here
184466 :
184467 : ROSE_ASSERT (this != NULL);
184468 : if (getVariant() != TEMP_Else_Where_Statement)
184469 : {
184470 : printf ("Error in SgElseWhereStatement::error(): SgElseWhereStatement object has a %s variant \n",
184471 : Cxx_GrammarTerminalNames[getVariant()].name);
184472 : // printf ("Error in SgElseWhereStatement::error() \n");
184473 : ROSE_ABORT();
184474 : }
184475 :
184476 : ROSE_ASSERT (getVariant() == TEMP_Else_Where_Statement);
184477 : return SgStatement::error();
184478 : }
184479 : #endif
184480 :
184481 :
184482 :
184483 : // End of memberFunctionString
184484 :
184485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
184486 :
184487 0 : SgElseWhereStatement* isSgElseWhereStatement ( SgNode* inputDerivedClassPointer )
184488 : {
184489 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
184490 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
184491 : // So to fix this we return NULL directly when the input is NULL and avoid the
184492 : // dynamic_cast in this case. This is likely a performance improvement as well.
184493 : // return dynamic_cast<SgElseWhereStatement*>(inputDerivedClassPointer);
184494 : // Milind Chabbi (8/28/2013): isSgElseWhereStatement uses table-driven castability instead of c++ default dynamic_cast
184495 : // this improves the running time performance by 10-20%.
184496 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElseWhereStatement*>(inputDerivedClassPointer);
184497 0 : return IS_SgElseWhereStatement_FAST_MACRO(inputDerivedClassPointer);
184498 : }
184499 :
184500 : // DQ (11/8/2003): Added version of functions taking const pointer
184501 0 : const SgElseWhereStatement* isSgElseWhereStatement ( const SgNode* inputDerivedClassPointer )
184502 : {
184503 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
184504 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
184505 : // So to fix this we return NULL directly when the input is NULL and avoid the
184506 : // dynamic_cast in this case. This is likely a performance improvement as well.
184507 : // return dynamic_cast<const SgElseWhereStatement*>(inputDerivedClassPointer);
184508 : // Milind Chabbi (8/28/2013): isSgElseWhereStatement uses table-driven castability instead of c++ default dynamic_cast
184509 : // this improves the running time performance by 10-20%.
184510 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElseWhereStatement*>(inputDerivedClassPointer);
184511 0 : return IS_SgElseWhereStatement_FAST_MACRO(inputDerivedClassPointer);
184512 : }
184513 :
184514 :
184515 :
184516 : /* #line 184517 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184517 :
184518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
184519 :
184520 : /**
184521 : \brief Generated destructor
184522 :
184523 : This destructor is automatically generated (by ROSETTA). This destructor
184524 : only frees memory of data members associated with the parts of the current IR node which
184525 : are NOT traversed. Those data members that are part of a traversal can be freed using
184526 : a traversal (calling this destructor on all children in a post-order traversal). Such
184527 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
184528 :
184529 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
184530 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
184531 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
184532 :
184533 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
184534 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
184535 : pointers are not yet implemented to call delete on eash pointer in the container.
184536 : (This could be done by derivation from the STL containers to define containers that
184537 : automatically deleted their members.)
184538 :
184539 : */
184540 0 : SgElseWhereStatement::~SgElseWhereStatement () {
184541 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
184542 :
184543 :
184544 : // case: not a listType for condition
184545 0 : p_condition = NULL; // non list case
184546 : // case: not a listType for body
184547 0 : p_body = NULL; // non list case
184548 : // case: not a listType for elsewhere
184549 0 : p_elsewhere = NULL; // non list case
184550 :
184551 : }
184552 :
184553 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
184554 0 : }
184555 :
184556 :
184557 : /* #line 184558 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184558 :
184559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
184560 :
184561 : // Generated constructor
184562 0 : SgElseWhereStatement::SgElseWhereStatement ( Sg_File_Info* startOfConstruct, SgExpression* condition, SgBasicBlock* body, SgElseWhereStatement* elsewhere )
184563 0 : : SgStatement(startOfConstruct)
184564 : {
184565 : #ifdef DEBUG
184566 : // printf ("In SgElseWhereStatement::SgElseWhereStatement (Sg_File_Info* startOfConstruct, SgExpression* condition, SgBasicBlock* body, SgElseWhereStatement* elsewhere) sage_class_name() = %s \n",sage_class_name());
184567 : #endif
184568 : #if 0
184569 : // debugging information!
184570 : printf ("In SgElseWhereStatement::SgElseWhereStatement (Sg_File_Info* startOfConstruct, SgExpression* condition, SgBasicBlock* body, SgElseWhereStatement* elsewhere): this = %p = %s \n",this,this->class_name().c_str());
184571 : #endif
184572 :
184573 0 : p_condition = condition;
184574 0 : p_body = body;
184575 0 : p_elsewhere = elsewhere;
184576 :
184577 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
184578 :
184579 : #if 0
184580 : // DQ (7/30/2014): Call a virtual function.
184581 : std::string s = this->class_name();
184582 : #endif
184583 :
184584 : // Test the variant virtual function
184585 : // assert(TEMP_Else_Where_Statement == variant());
184586 0 : assert(TEMP_Else_Where_Statement == this->variant());
184587 0 : ROSE_ASSERT(TEMP_Else_Where_Statement == (int)(this->variantT()));
184588 0 : post_construction_initialization();
184589 :
184590 : // Test the isSgElseWhereStatement() function since it has been problematic
184591 0 : assert(isSgElseWhereStatement(this) != NULL);
184592 0 : }
184593 :
184594 : // Generated constructor (all data members)
184595 :
184596 : /* #line 184597 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184597 :
184598 :
184599 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
184600 :
184601 :
184602 : // ********************************************************
184603 : // member functions common across all array grammar objects
184604 : // ********************************************************
184605 :
184606 :
184607 :
184608 : /* #line 184609 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184609 :
184610 :
184611 :
184612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
184613 :
184614 : // ********************************************************
184615 : // member functions specific to each node in the grammar
184616 : // ********************************************************
184617 :
184618 :
184619 : /* #line 184620 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184620 :
184621 : // Start of memberFunctionString
184622 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
184623 :
184624 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
184625 :
184626 : SgExprListExp*
184627 0 : SgNullifyStatement::get_pointer_list () const
184628 : {
184629 0 : ROSE_ASSERT (this != NULL);
184630 :
184631 : #if 0
184632 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184633 : // used to trigger marking transformations for the token-based unparsing.
184634 : printf ("SgNullifyStatement::get_pointer_list = %p = %s \n",this,this->class_name().c_str());
184635 : #endif
184636 :
184637 0 : return p_pointer_list;
184638 : }
184639 :
184640 : void
184641 0 : SgNullifyStatement::set_pointer_list ( SgExprListExp* pointer_list )
184642 : {
184643 0 : ROSE_ASSERT (this != NULL);
184644 :
184645 : #if 0
184646 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184647 : // used to trigger marking transformations for the token-based unparsing.
184648 : printf ("SgNullifyStatement::set_pointer_list = %p = %s \n",this,this->class_name().c_str());
184649 : #endif
184650 :
184651 0 : set_isModified(true);
184652 :
184653 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
184654 : if (p_pointer_list != NULL && pointer_list != NULL && p_pointer_list != pointer_list)
184655 : {
184656 : printf ("Warning: pointer_list = %p overwriting valid pointer p_pointer_list = %p \n",pointer_list,p_pointer_list);
184657 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
184658 : printf ("Error fails assertion (p_pointer_list != NULL && pointer_list != NULL && p_pointer_list != pointer_list) is false\n");
184659 : ROSE_ASSERT(false);
184660 : #endif
184661 : }
184662 : #endif
184663 0 : p_pointer_list = pointer_list;
184664 0 : }
184665 :
184666 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
184667 :
184668 :
184669 : // End of memberFunctionString
184670 : // Start of memberFunctionString
184671 : /* #line 18573 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
184672 :
184673 : void
184674 0 : SgNullifyStatement::post_construction_initialization()
184675 0 : {}
184676 :
184677 :
184678 : // End of memberFunctionString
184679 : // Start of memberFunctionString
184680 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
184681 :
184682 : // *** COMMON CODE SECTION BEGINS HERE ***
184683 :
184684 : #if 0
184685 : int
184686 : SgNullifyStatement::getVariant() const
184687 : {
184688 : // This function is used in ROSE while "variant()" is used in SAGE
184689 : assert(this != NULL);
184690 : return variant();
184691 : }
184692 : #endif
184693 :
184694 : // This function is used in ROSE in treeTraversal code
184695 : // eventually replaces getVariant() and variant()
184696 : // though after variant() has been removed for a while we will
184697 : // want to change the name of variantT() back to variant()
184698 : // (since the "T" was ment to stand for temporary).
184699 : // When this happens the variantT() will be depricated.
184700 : VariantT
184701 0 : SgNullifyStatement::variantT() const
184702 : {
184703 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
184704 0 : ROSE_ASSERT(this != NULL);
184705 0 : return V_SgNullifyStatement;
184706 : }
184707 :
184708 : #if 0
184709 : int
184710 : SgNullifyStatement::variant() const
184711 : {
184712 : // This function is used in SAGE
184713 : ROSE_ASSERT(this != NULL);
184714 : return TEMP_Nullify_Statement;
184715 : }
184716 : #endif
184717 :
184718 : ROSE_DLL_API const char*
184719 0 : SgNullifyStatement::sage_class_name() const
184720 : {
184721 0 : ROSE_ASSERT(this != NULL);
184722 0 : return "SgNullifyStatement";
184723 : }
184724 :
184725 : std::string
184726 0 : SgNullifyStatement::class_name() const
184727 : {
184728 0 : ROSE_ASSERT(this != NULL);
184729 0 : return "SgNullifyStatement";
184730 : }
184731 :
184732 : // DQ (11/26/2005): Support for visitor pattern mechanims
184733 : // (inferior to ROSE traversal mechanism, experimental).
184734 : void
184735 0 : SgNullifyStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
184736 : {
184737 0 : ROSE_ASSERT(this != NULL);
184738 0 : visitor.visit(this);
184739 0 : }
184740 :
184741 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
184742 0 : void SgNullifyStatement::accept (ROSE_VisitorPattern & visitor) {
184743 0 : ROSE_ASSERT(this != NULL);
184744 0 : visitor.visit(this);
184745 0 : }
184746 :
184747 : SgNullifyStatement*
184748 0 : SgNullifyStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
184749 : {
184750 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
184751 : // This function is currently only supported for the AST used the represent Binary executables.
184752 : if (0 /* isSgAsmNode(this) != NULL */)
184753 : {
184754 : // Support for regex specification.
184755 : std::string prefixCode = "REGEX:";
184756 : addNewAttribute(prefixCode + s,a);
184757 : }
184758 : #endif
184759 :
184760 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
184761 0 : return this;
184762 : }
184763 :
184764 : // *** COMMON CODE SECTION ENDS HERE ***
184765 :
184766 :
184767 : // End of memberFunctionString
184768 : // Start of memberFunctionString
184769 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
184770 :
184771 :
184772 : #if 0
184773 : //! Error checking support
184774 : /*! Verifies the following:
184775 : - working getVariant() member function
184776 : - calls base class's error() member function
184777 : Every class has one of these functions.
184778 : */
184779 : bool
184780 : SgNullifyStatement::error()
184781 : {
184782 : // Put error checking here
184783 :
184784 : ROSE_ASSERT (this != NULL);
184785 : if (getVariant() != TEMP_Nullify_Statement)
184786 : {
184787 : printf ("Error in SgNullifyStatement::error(): SgNullifyStatement object has a %s variant \n",
184788 : Cxx_GrammarTerminalNames[getVariant()].name);
184789 : // printf ("Error in SgNullifyStatement::error() \n");
184790 : ROSE_ABORT();
184791 : }
184792 :
184793 : ROSE_ASSERT (getVariant() == TEMP_Nullify_Statement);
184794 : return SgStatement::error();
184795 : }
184796 : #endif
184797 :
184798 :
184799 :
184800 : // End of memberFunctionString
184801 :
184802 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
184803 :
184804 0 : SgNullifyStatement* isSgNullifyStatement ( SgNode* inputDerivedClassPointer )
184805 : {
184806 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
184807 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
184808 : // So to fix this we return NULL directly when the input is NULL and avoid the
184809 : // dynamic_cast in this case. This is likely a performance improvement as well.
184810 : // return dynamic_cast<SgNullifyStatement*>(inputDerivedClassPointer);
184811 : // Milind Chabbi (8/28/2013): isSgNullifyStatement uses table-driven castability instead of c++ default dynamic_cast
184812 : // this improves the running time performance by 10-20%.
184813 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNullifyStatement*>(inputDerivedClassPointer);
184814 0 : return IS_SgNullifyStatement_FAST_MACRO(inputDerivedClassPointer);
184815 : }
184816 :
184817 : // DQ (11/8/2003): Added version of functions taking const pointer
184818 0 : const SgNullifyStatement* isSgNullifyStatement ( const SgNode* inputDerivedClassPointer )
184819 : {
184820 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
184821 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
184822 : // So to fix this we return NULL directly when the input is NULL and avoid the
184823 : // dynamic_cast in this case. This is likely a performance improvement as well.
184824 : // return dynamic_cast<const SgNullifyStatement*>(inputDerivedClassPointer);
184825 : // Milind Chabbi (8/28/2013): isSgNullifyStatement uses table-driven castability instead of c++ default dynamic_cast
184826 : // this improves the running time performance by 10-20%.
184827 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNullifyStatement*>(inputDerivedClassPointer);
184828 0 : return IS_SgNullifyStatement_FAST_MACRO(inputDerivedClassPointer);
184829 : }
184830 :
184831 :
184832 :
184833 : /* #line 184834 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184834 :
184835 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
184836 :
184837 : /**
184838 : \brief Generated destructor
184839 :
184840 : This destructor is automatically generated (by ROSETTA). This destructor
184841 : only frees memory of data members associated with the parts of the current IR node which
184842 : are NOT traversed. Those data members that are part of a traversal can be freed using
184843 : a traversal (calling this destructor on all children in a post-order traversal). Such
184844 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
184845 :
184846 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
184847 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
184848 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
184849 :
184850 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
184851 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
184852 : pointers are not yet implemented to call delete on eash pointer in the container.
184853 : (This could be done by derivation from the STL containers to define containers that
184854 : automatically deleted their members.)
184855 :
184856 : */
184857 0 : SgNullifyStatement::~SgNullifyStatement () {
184858 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
184859 :
184860 :
184861 :
184862 : }
184863 :
184864 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
184865 0 : }
184866 :
184867 :
184868 : /* #line 184869 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184869 :
184870 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
184871 :
184872 : // Generated constructor
184873 0 : SgNullifyStatement::SgNullifyStatement ( Sg_File_Info* startOfConstruct )
184874 0 : : SgStatement(startOfConstruct)
184875 : {
184876 : #ifdef DEBUG
184877 : // printf ("In SgNullifyStatement::SgNullifyStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
184878 : #endif
184879 : #if 0
184880 : // debugging information!
184881 : printf ("In SgNullifyStatement::SgNullifyStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
184882 : #endif
184883 :
184884 :
184885 :
184886 : #if 0
184887 : // DQ (7/30/2014): Call a virtual function.
184888 : std::string s = this->class_name();
184889 : #endif
184890 :
184891 : // Test the variant virtual function
184892 : // assert(TEMP_Nullify_Statement == variant());
184893 0 : assert(TEMP_Nullify_Statement == this->variant());
184894 0 : ROSE_ASSERT(TEMP_Nullify_Statement == (int)(this->variantT()));
184895 0 : post_construction_initialization();
184896 :
184897 : // Test the isSgNullifyStatement() function since it has been problematic
184898 0 : assert(isSgNullifyStatement(this) != NULL);
184899 0 : }
184900 :
184901 : // Generated constructor (all data members)
184902 :
184903 : /* #line 184904 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184904 :
184905 :
184906 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
184907 :
184908 :
184909 : // ********************************************************
184910 : // member functions common across all array grammar objects
184911 : // ********************************************************
184912 :
184913 :
184914 :
184915 : /* #line 184916 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184916 :
184917 :
184918 :
184919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
184920 :
184921 : // ********************************************************
184922 : // member functions specific to each node in the grammar
184923 : // ********************************************************
184924 :
184925 :
184926 : /* #line 184927 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
184927 :
184928 : // Start of memberFunctionString
184929 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
184930 :
184931 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
184932 :
184933 : SgExpression*
184934 0 : SgArithmeticIfStatement::get_conditional () const
184935 : {
184936 0 : ROSE_ASSERT (this != NULL);
184937 :
184938 : #if 0
184939 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184940 : // used to trigger marking transformations for the token-based unparsing.
184941 : printf ("SgArithmeticIfStatement::get_conditional = %p = %s \n",this,this->class_name().c_str());
184942 : #endif
184943 :
184944 0 : return p_conditional;
184945 : }
184946 :
184947 : void
184948 0 : SgArithmeticIfStatement::set_conditional ( SgExpression* conditional )
184949 : {
184950 0 : ROSE_ASSERT (this != NULL);
184951 :
184952 : #if 0
184953 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184954 : // used to trigger marking transformations for the token-based unparsing.
184955 : printf ("SgArithmeticIfStatement::set_conditional = %p = %s \n",this,this->class_name().c_str());
184956 : #endif
184957 :
184958 0 : set_isModified(true);
184959 :
184960 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
184961 : if (p_conditional != NULL && conditional != NULL && p_conditional != conditional)
184962 : {
184963 : printf ("Warning: conditional = %p overwriting valid pointer p_conditional = %p \n",conditional,p_conditional);
184964 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
184965 : printf ("Error fails assertion (p_conditional != NULL && conditional != NULL && p_conditional != conditional) is false\n");
184966 : ROSE_ASSERT(false);
184967 : #endif
184968 : }
184969 : #endif
184970 0 : p_conditional = conditional;
184971 0 : }
184972 :
184973 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
184974 :
184975 :
184976 : // End of memberFunctionString
184977 : // Start of memberFunctionString
184978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
184979 :
184980 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
184981 :
184982 : SgLabelRefExp*
184983 0 : SgArithmeticIfStatement::get_less_label () const
184984 : {
184985 0 : ROSE_ASSERT (this != NULL);
184986 :
184987 : #if 0
184988 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
184989 : // used to trigger marking transformations for the token-based unparsing.
184990 : printf ("SgArithmeticIfStatement::get_less_label = %p = %s \n",this,this->class_name().c_str());
184991 : #endif
184992 :
184993 0 : return p_less_label;
184994 : }
184995 :
184996 : void
184997 0 : SgArithmeticIfStatement::set_less_label ( SgLabelRefExp* less_label )
184998 : {
184999 0 : ROSE_ASSERT (this != NULL);
185000 :
185001 : #if 0
185002 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185003 : // used to trigger marking transformations for the token-based unparsing.
185004 : printf ("SgArithmeticIfStatement::set_less_label = %p = %s \n",this,this->class_name().c_str());
185005 : #endif
185006 :
185007 0 : set_isModified(true);
185008 :
185009 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185010 : if (p_less_label != NULL && less_label != NULL && p_less_label != less_label)
185011 : {
185012 : printf ("Warning: less_label = %p overwriting valid pointer p_less_label = %p \n",less_label,p_less_label);
185013 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185014 : printf ("Error fails assertion (p_less_label != NULL && less_label != NULL && p_less_label != less_label) is false\n");
185015 : ROSE_ASSERT(false);
185016 : #endif
185017 : }
185018 : #endif
185019 0 : p_less_label = less_label;
185020 0 : }
185021 :
185022 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185023 :
185024 :
185025 : // End of memberFunctionString
185026 : // Start of memberFunctionString
185027 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
185028 :
185029 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
185030 :
185031 : SgLabelRefExp*
185032 0 : SgArithmeticIfStatement::get_equal_label () const
185033 : {
185034 0 : ROSE_ASSERT (this != NULL);
185035 :
185036 : #if 0
185037 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185038 : // used to trigger marking transformations for the token-based unparsing.
185039 : printf ("SgArithmeticIfStatement::get_equal_label = %p = %s \n",this,this->class_name().c_str());
185040 : #endif
185041 :
185042 0 : return p_equal_label;
185043 : }
185044 :
185045 : void
185046 0 : SgArithmeticIfStatement::set_equal_label ( SgLabelRefExp* equal_label )
185047 : {
185048 0 : ROSE_ASSERT (this != NULL);
185049 :
185050 : #if 0
185051 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185052 : // used to trigger marking transformations for the token-based unparsing.
185053 : printf ("SgArithmeticIfStatement::set_equal_label = %p = %s \n",this,this->class_name().c_str());
185054 : #endif
185055 :
185056 0 : set_isModified(true);
185057 :
185058 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185059 : if (p_equal_label != NULL && equal_label != NULL && p_equal_label != equal_label)
185060 : {
185061 : printf ("Warning: equal_label = %p overwriting valid pointer p_equal_label = %p \n",equal_label,p_equal_label);
185062 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185063 : printf ("Error fails assertion (p_equal_label != NULL && equal_label != NULL && p_equal_label != equal_label) is false\n");
185064 : ROSE_ASSERT(false);
185065 : #endif
185066 : }
185067 : #endif
185068 0 : p_equal_label = equal_label;
185069 0 : }
185070 :
185071 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185072 :
185073 :
185074 : // End of memberFunctionString
185075 : // Start of memberFunctionString
185076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
185077 :
185078 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
185079 :
185080 : SgLabelRefExp*
185081 0 : SgArithmeticIfStatement::get_greater_label () const
185082 : {
185083 0 : ROSE_ASSERT (this != NULL);
185084 :
185085 : #if 0
185086 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185087 : // used to trigger marking transformations for the token-based unparsing.
185088 : printf ("SgArithmeticIfStatement::get_greater_label = %p = %s \n",this,this->class_name().c_str());
185089 : #endif
185090 :
185091 0 : return p_greater_label;
185092 : }
185093 :
185094 : void
185095 0 : SgArithmeticIfStatement::set_greater_label ( SgLabelRefExp* greater_label )
185096 : {
185097 0 : ROSE_ASSERT (this != NULL);
185098 :
185099 : #if 0
185100 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185101 : // used to trigger marking transformations for the token-based unparsing.
185102 : printf ("SgArithmeticIfStatement::set_greater_label = %p = %s \n",this,this->class_name().c_str());
185103 : #endif
185104 :
185105 0 : set_isModified(true);
185106 :
185107 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185108 : if (p_greater_label != NULL && greater_label != NULL && p_greater_label != greater_label)
185109 : {
185110 : printf ("Warning: greater_label = %p overwriting valid pointer p_greater_label = %p \n",greater_label,p_greater_label);
185111 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185112 : printf ("Error fails assertion (p_greater_label != NULL && greater_label != NULL && p_greater_label != greater_label) is false\n");
185113 : ROSE_ASSERT(false);
185114 : #endif
185115 : }
185116 : #endif
185117 0 : p_greater_label = greater_label;
185118 0 : }
185119 :
185120 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185121 :
185122 :
185123 : // End of memberFunctionString
185124 : // Start of memberFunctionString
185125 : /* #line 18765 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
185126 :
185127 : void
185128 0 : SgArithmeticIfStatement::post_construction_initialization()
185129 0 : {}
185130 :
185131 :
185132 : // End of memberFunctionString
185133 : // Start of memberFunctionString
185134 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
185135 :
185136 : // *** COMMON CODE SECTION BEGINS HERE ***
185137 :
185138 : #if 0
185139 : int
185140 : SgArithmeticIfStatement::getVariant() const
185141 : {
185142 : // This function is used in ROSE while "variant()" is used in SAGE
185143 : assert(this != NULL);
185144 : return variant();
185145 : }
185146 : #endif
185147 :
185148 : // This function is used in ROSE in treeTraversal code
185149 : // eventually replaces getVariant() and variant()
185150 : // though after variant() has been removed for a while we will
185151 : // want to change the name of variantT() back to variant()
185152 : // (since the "T" was ment to stand for temporary).
185153 : // When this happens the variantT() will be depricated.
185154 : VariantT
185155 0 : SgArithmeticIfStatement::variantT() const
185156 : {
185157 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
185158 0 : ROSE_ASSERT(this != NULL);
185159 0 : return V_SgArithmeticIfStatement;
185160 : }
185161 :
185162 : #if 0
185163 : int
185164 : SgArithmeticIfStatement::variant() const
185165 : {
185166 : // This function is used in SAGE
185167 : ROSE_ASSERT(this != NULL);
185168 : return TEMP_Arithmetic_If_Statement;
185169 : }
185170 : #endif
185171 :
185172 : ROSE_DLL_API const char*
185173 0 : SgArithmeticIfStatement::sage_class_name() const
185174 : {
185175 0 : ROSE_ASSERT(this != NULL);
185176 0 : return "SgArithmeticIfStatement";
185177 : }
185178 :
185179 : std::string
185180 0 : SgArithmeticIfStatement::class_name() const
185181 : {
185182 0 : ROSE_ASSERT(this != NULL);
185183 0 : return "SgArithmeticIfStatement";
185184 : }
185185 :
185186 : // DQ (11/26/2005): Support for visitor pattern mechanims
185187 : // (inferior to ROSE traversal mechanism, experimental).
185188 : void
185189 0 : SgArithmeticIfStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
185190 : {
185191 0 : ROSE_ASSERT(this != NULL);
185192 0 : visitor.visit(this);
185193 0 : }
185194 :
185195 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
185196 0 : void SgArithmeticIfStatement::accept (ROSE_VisitorPattern & visitor) {
185197 0 : ROSE_ASSERT(this != NULL);
185198 0 : visitor.visit(this);
185199 0 : }
185200 :
185201 : SgArithmeticIfStatement*
185202 0 : SgArithmeticIfStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
185203 : {
185204 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
185205 : // This function is currently only supported for the AST used the represent Binary executables.
185206 : if (0 /* isSgAsmNode(this) != NULL */)
185207 : {
185208 : // Support for regex specification.
185209 : std::string prefixCode = "REGEX:";
185210 : addNewAttribute(prefixCode + s,a);
185211 : }
185212 : #endif
185213 :
185214 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
185215 0 : return this;
185216 : }
185217 :
185218 : // *** COMMON CODE SECTION ENDS HERE ***
185219 :
185220 :
185221 : // End of memberFunctionString
185222 : // Start of memberFunctionString
185223 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
185224 :
185225 :
185226 : #if 0
185227 : //! Error checking support
185228 : /*! Verifies the following:
185229 : - working getVariant() member function
185230 : - calls base class's error() member function
185231 : Every class has one of these functions.
185232 : */
185233 : bool
185234 : SgArithmeticIfStatement::error()
185235 : {
185236 : // Put error checking here
185237 :
185238 : ROSE_ASSERT (this != NULL);
185239 : if (getVariant() != TEMP_Arithmetic_If_Statement)
185240 : {
185241 : printf ("Error in SgArithmeticIfStatement::error(): SgArithmeticIfStatement object has a %s variant \n",
185242 : Cxx_GrammarTerminalNames[getVariant()].name);
185243 : // printf ("Error in SgArithmeticIfStatement::error() \n");
185244 : ROSE_ABORT();
185245 : }
185246 :
185247 : ROSE_ASSERT (getVariant() == TEMP_Arithmetic_If_Statement);
185248 : return SgStatement::error();
185249 : }
185250 : #endif
185251 :
185252 :
185253 :
185254 : // End of memberFunctionString
185255 :
185256 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
185257 :
185258 2606 : SgArithmeticIfStatement* isSgArithmeticIfStatement ( SgNode* inputDerivedClassPointer )
185259 : {
185260 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
185261 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
185262 : // So to fix this we return NULL directly when the input is NULL and avoid the
185263 : // dynamic_cast in this case. This is likely a performance improvement as well.
185264 : // return dynamic_cast<SgArithmeticIfStatement*>(inputDerivedClassPointer);
185265 : // Milind Chabbi (8/28/2013): isSgArithmeticIfStatement uses table-driven castability instead of c++ default dynamic_cast
185266 : // this improves the running time performance by 10-20%.
185267 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgArithmeticIfStatement*>(inputDerivedClassPointer);
185268 2606 : return IS_SgArithmeticIfStatement_FAST_MACRO(inputDerivedClassPointer);
185269 : }
185270 :
185271 : // DQ (11/8/2003): Added version of functions taking const pointer
185272 0 : const SgArithmeticIfStatement* isSgArithmeticIfStatement ( const SgNode* inputDerivedClassPointer )
185273 : {
185274 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
185275 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
185276 : // So to fix this we return NULL directly when the input is NULL and avoid the
185277 : // dynamic_cast in this case. This is likely a performance improvement as well.
185278 : // return dynamic_cast<const SgArithmeticIfStatement*>(inputDerivedClassPointer);
185279 : // Milind Chabbi (8/28/2013): isSgArithmeticIfStatement uses table-driven castability instead of c++ default dynamic_cast
185280 : // this improves the running time performance by 10-20%.
185281 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgArithmeticIfStatement*>(inputDerivedClassPointer);
185282 0 : return IS_SgArithmeticIfStatement_FAST_MACRO(inputDerivedClassPointer);
185283 : }
185284 :
185285 :
185286 :
185287 : /* #line 185288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185288 :
185289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
185290 :
185291 : /**
185292 : \brief Generated destructor
185293 :
185294 : This destructor is automatically generated (by ROSETTA). This destructor
185295 : only frees memory of data members associated with the parts of the current IR node which
185296 : are NOT traversed. Those data members that are part of a traversal can be freed using
185297 : a traversal (calling this destructor on all children in a post-order traversal). Such
185298 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
185299 :
185300 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
185301 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
185302 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
185303 :
185304 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
185305 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
185306 : pointers are not yet implemented to call delete on eash pointer in the container.
185307 : (This could be done by derivation from the STL containers to define containers that
185308 : automatically deleted their members.)
185309 :
185310 : */
185311 0 : SgArithmeticIfStatement::~SgArithmeticIfStatement () {
185312 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
185313 :
185314 :
185315 : // case: not a listType for conditional
185316 0 : p_conditional = NULL; // non list case
185317 : // case: not a listType for less_label
185318 0 : p_less_label = NULL; // non list case
185319 : // case: not a listType for equal_label
185320 0 : p_equal_label = NULL; // non list case
185321 : // case: not a listType for greater_label
185322 0 : p_greater_label = NULL; // non list case
185323 :
185324 : }
185325 :
185326 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
185327 0 : }
185328 :
185329 :
185330 : /* #line 185331 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185331 :
185332 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
185333 :
185334 : // Generated constructor
185335 0 : SgArithmeticIfStatement::SgArithmeticIfStatement ( Sg_File_Info* startOfConstruct, SgExpression* conditional, SgLabelRefExp* less_label, SgLabelRefExp* equal_label, SgLabelRefExp* greater_label )
185336 0 : : SgStatement(startOfConstruct)
185337 : {
185338 : #ifdef DEBUG
185339 : // printf ("In SgArithmeticIfStatement::SgArithmeticIfStatement (Sg_File_Info* startOfConstruct, SgExpression* conditional, SgLabelRefExp* less_label, SgLabelRefExp* equal_label, SgLabelRefExp* greater_label) sage_class_name() = %s \n",sage_class_name());
185340 : #endif
185341 : #if 0
185342 : // debugging information!
185343 : printf ("In SgArithmeticIfStatement::SgArithmeticIfStatement (Sg_File_Info* startOfConstruct, SgExpression* conditional, SgLabelRefExp* less_label, SgLabelRefExp* equal_label, SgLabelRefExp* greater_label): this = %p = %s \n",this,this->class_name().c_str());
185344 : #endif
185345 :
185346 0 : p_conditional = conditional;
185347 0 : p_less_label = less_label;
185348 0 : p_equal_label = equal_label;
185349 0 : p_greater_label = greater_label;
185350 :
185351 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
185352 :
185353 : #if 0
185354 : // DQ (7/30/2014): Call a virtual function.
185355 : std::string s = this->class_name();
185356 : #endif
185357 :
185358 : // Test the variant virtual function
185359 : // assert(TEMP_Arithmetic_If_Statement == variant());
185360 0 : assert(TEMP_Arithmetic_If_Statement == this->variant());
185361 0 : ROSE_ASSERT(TEMP_Arithmetic_If_Statement == (int)(this->variantT()));
185362 0 : post_construction_initialization();
185363 :
185364 : // Test the isSgArithmeticIfStatement() function since it has been problematic
185365 0 : assert(isSgArithmeticIfStatement(this) != NULL);
185366 0 : }
185367 :
185368 : // Generated constructor (all data members)
185369 :
185370 : /* #line 185371 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185371 :
185372 :
185373 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
185374 :
185375 :
185376 : // ********************************************************
185377 : // member functions common across all array grammar objects
185378 : // ********************************************************
185379 :
185380 :
185381 :
185382 : /* #line 185383 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185383 :
185384 :
185385 :
185386 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
185387 :
185388 : // ********************************************************
185389 : // member functions specific to each node in the grammar
185390 : // ********************************************************
185391 :
185392 :
185393 : /* #line 185394 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185394 :
185395 : // Start of memberFunctionString
185396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
185397 :
185398 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
185399 :
185400 : SgLabelRefExp*
185401 0 : SgAssignStatement::get_label () const
185402 : {
185403 0 : ROSE_ASSERT (this != NULL);
185404 :
185405 : #if 0
185406 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185407 : // used to trigger marking transformations for the token-based unparsing.
185408 : printf ("SgAssignStatement::get_label = %p = %s \n",this,this->class_name().c_str());
185409 : #endif
185410 :
185411 0 : return p_label;
185412 : }
185413 :
185414 : void
185415 0 : SgAssignStatement::set_label ( SgLabelRefExp* label )
185416 : {
185417 0 : ROSE_ASSERT (this != NULL);
185418 :
185419 : #if 0
185420 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185421 : // used to trigger marking transformations for the token-based unparsing.
185422 : printf ("SgAssignStatement::set_label = %p = %s \n",this,this->class_name().c_str());
185423 : #endif
185424 :
185425 0 : set_isModified(true);
185426 :
185427 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185428 : if (p_label != NULL && label != NULL && p_label != label)
185429 : {
185430 : printf ("Warning: label = %p overwriting valid pointer p_label = %p \n",label,p_label);
185431 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185432 : printf ("Error fails assertion (p_label != NULL && label != NULL && p_label != label) is false\n");
185433 : ROSE_ASSERT(false);
185434 : #endif
185435 : }
185436 : #endif
185437 0 : p_label = label;
185438 0 : }
185439 :
185440 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185441 :
185442 :
185443 : // End of memberFunctionString
185444 : // Start of memberFunctionString
185445 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
185446 :
185447 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
185448 :
185449 : SgExpression*
185450 0 : SgAssignStatement::get_value () const
185451 : {
185452 0 : ROSE_ASSERT (this != NULL);
185453 :
185454 : #if 0
185455 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185456 : // used to trigger marking transformations for the token-based unparsing.
185457 : printf ("SgAssignStatement::get_value = %p = %s \n",this,this->class_name().c_str());
185458 : #endif
185459 :
185460 0 : return p_value;
185461 : }
185462 :
185463 : void
185464 0 : SgAssignStatement::set_value ( SgExpression* value )
185465 : {
185466 0 : ROSE_ASSERT (this != NULL);
185467 :
185468 : #if 0
185469 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185470 : // used to trigger marking transformations for the token-based unparsing.
185471 : printf ("SgAssignStatement::set_value = %p = %s \n",this,this->class_name().c_str());
185472 : #endif
185473 :
185474 0 : set_isModified(true);
185475 :
185476 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185477 : if (p_value != NULL && value != NULL && p_value != value)
185478 : {
185479 : printf ("Warning: value = %p overwriting valid pointer p_value = %p \n",value,p_value);
185480 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185481 : printf ("Error fails assertion (p_value != NULL && value != NULL && p_value != value) is false\n");
185482 : ROSE_ASSERT(false);
185483 : #endif
185484 : }
185485 : #endif
185486 0 : p_value = value;
185487 0 : }
185488 :
185489 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185490 :
185491 :
185492 : // End of memberFunctionString
185493 : // Start of memberFunctionString
185494 : /* #line 18772 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
185495 :
185496 : void
185497 0 : SgAssignStatement::post_construction_initialization()
185498 0 : {}
185499 :
185500 :
185501 : // End of memberFunctionString
185502 : // Start of memberFunctionString
185503 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
185504 :
185505 : // *** COMMON CODE SECTION BEGINS HERE ***
185506 :
185507 : #if 0
185508 : int
185509 : SgAssignStatement::getVariant() const
185510 : {
185511 : // This function is used in ROSE while "variant()" is used in SAGE
185512 : assert(this != NULL);
185513 : return variant();
185514 : }
185515 : #endif
185516 :
185517 : // This function is used in ROSE in treeTraversal code
185518 : // eventually replaces getVariant() and variant()
185519 : // though after variant() has been removed for a while we will
185520 : // want to change the name of variantT() back to variant()
185521 : // (since the "T" was ment to stand for temporary).
185522 : // When this happens the variantT() will be depricated.
185523 : VariantT
185524 0 : SgAssignStatement::variantT() const
185525 : {
185526 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
185527 0 : ROSE_ASSERT(this != NULL);
185528 0 : return V_SgAssignStatement;
185529 : }
185530 :
185531 : #if 0
185532 : int
185533 : SgAssignStatement::variant() const
185534 : {
185535 : // This function is used in SAGE
185536 : ROSE_ASSERT(this != NULL);
185537 : return TEMP_Assign_Statement;
185538 : }
185539 : #endif
185540 :
185541 : ROSE_DLL_API const char*
185542 0 : SgAssignStatement::sage_class_name() const
185543 : {
185544 0 : ROSE_ASSERT(this != NULL);
185545 0 : return "SgAssignStatement";
185546 : }
185547 :
185548 : std::string
185549 0 : SgAssignStatement::class_name() const
185550 : {
185551 0 : ROSE_ASSERT(this != NULL);
185552 0 : return "SgAssignStatement";
185553 : }
185554 :
185555 : // DQ (11/26/2005): Support for visitor pattern mechanims
185556 : // (inferior to ROSE traversal mechanism, experimental).
185557 : void
185558 0 : SgAssignStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
185559 : {
185560 0 : ROSE_ASSERT(this != NULL);
185561 0 : visitor.visit(this);
185562 0 : }
185563 :
185564 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
185565 0 : void SgAssignStatement::accept (ROSE_VisitorPattern & visitor) {
185566 0 : ROSE_ASSERT(this != NULL);
185567 0 : visitor.visit(this);
185568 0 : }
185569 :
185570 : SgAssignStatement*
185571 0 : SgAssignStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
185572 : {
185573 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
185574 : // This function is currently only supported for the AST used the represent Binary executables.
185575 : if (0 /* isSgAsmNode(this) != NULL */)
185576 : {
185577 : // Support for regex specification.
185578 : std::string prefixCode = "REGEX:";
185579 : addNewAttribute(prefixCode + s,a);
185580 : }
185581 : #endif
185582 :
185583 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
185584 0 : return this;
185585 : }
185586 :
185587 : // *** COMMON CODE SECTION ENDS HERE ***
185588 :
185589 :
185590 : // End of memberFunctionString
185591 : // Start of memberFunctionString
185592 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
185593 :
185594 :
185595 : #if 0
185596 : //! Error checking support
185597 : /*! Verifies the following:
185598 : - working getVariant() member function
185599 : - calls base class's error() member function
185600 : Every class has one of these functions.
185601 : */
185602 : bool
185603 : SgAssignStatement::error()
185604 : {
185605 : // Put error checking here
185606 :
185607 : ROSE_ASSERT (this != NULL);
185608 : if (getVariant() != TEMP_Assign_Statement)
185609 : {
185610 : printf ("Error in SgAssignStatement::error(): SgAssignStatement object has a %s variant \n",
185611 : Cxx_GrammarTerminalNames[getVariant()].name);
185612 : // printf ("Error in SgAssignStatement::error() \n");
185613 : ROSE_ABORT();
185614 : }
185615 :
185616 : ROSE_ASSERT (getVariant() == TEMP_Assign_Statement);
185617 : return SgStatement::error();
185618 : }
185619 : #endif
185620 :
185621 :
185622 :
185623 : // End of memberFunctionString
185624 :
185625 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
185626 :
185627 0 : SgAssignStatement* isSgAssignStatement ( SgNode* inputDerivedClassPointer )
185628 : {
185629 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
185630 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
185631 : // So to fix this we return NULL directly when the input is NULL and avoid the
185632 : // dynamic_cast in this case. This is likely a performance improvement as well.
185633 : // return dynamic_cast<SgAssignStatement*>(inputDerivedClassPointer);
185634 : // Milind Chabbi (8/28/2013): isSgAssignStatement uses table-driven castability instead of c++ default dynamic_cast
185635 : // this improves the running time performance by 10-20%.
185636 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAssignStatement*>(inputDerivedClassPointer);
185637 0 : return IS_SgAssignStatement_FAST_MACRO(inputDerivedClassPointer);
185638 : }
185639 :
185640 : // DQ (11/8/2003): Added version of functions taking const pointer
185641 0 : const SgAssignStatement* isSgAssignStatement ( const SgNode* inputDerivedClassPointer )
185642 : {
185643 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
185644 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
185645 : // So to fix this we return NULL directly when the input is NULL and avoid the
185646 : // dynamic_cast in this case. This is likely a performance improvement as well.
185647 : // return dynamic_cast<const SgAssignStatement*>(inputDerivedClassPointer);
185648 : // Milind Chabbi (8/28/2013): isSgAssignStatement uses table-driven castability instead of c++ default dynamic_cast
185649 : // this improves the running time performance by 10-20%.
185650 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAssignStatement*>(inputDerivedClassPointer);
185651 0 : return IS_SgAssignStatement_FAST_MACRO(inputDerivedClassPointer);
185652 : }
185653 :
185654 :
185655 :
185656 : /* #line 185657 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185657 :
185658 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
185659 :
185660 : /**
185661 : \brief Generated destructor
185662 :
185663 : This destructor is automatically generated (by ROSETTA). This destructor
185664 : only frees memory of data members associated with the parts of the current IR node which
185665 : are NOT traversed. Those data members that are part of a traversal can be freed using
185666 : a traversal (calling this destructor on all children in a post-order traversal). Such
185667 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
185668 :
185669 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
185670 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
185671 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
185672 :
185673 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
185674 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
185675 : pointers are not yet implemented to call delete on eash pointer in the container.
185676 : (This could be done by derivation from the STL containers to define containers that
185677 : automatically deleted their members.)
185678 :
185679 : */
185680 0 : SgAssignStatement::~SgAssignStatement () {
185681 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
185682 :
185683 :
185684 : // case: not a listType for label
185685 0 : p_label = NULL; // non list case
185686 : // case: not a listType for value
185687 0 : p_value = NULL; // non list case
185688 :
185689 : }
185690 :
185691 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
185692 0 : }
185693 :
185694 :
185695 : /* #line 185696 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185696 :
185697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
185698 :
185699 : // Generated constructor
185700 0 : SgAssignStatement::SgAssignStatement ( Sg_File_Info* startOfConstruct, SgLabelRefExp* label, SgExpression* value )
185701 0 : : SgStatement(startOfConstruct)
185702 : {
185703 : #ifdef DEBUG
185704 : // printf ("In SgAssignStatement::SgAssignStatement (Sg_File_Info* startOfConstruct, SgLabelRefExp* label, SgExpression* value) sage_class_name() = %s \n",sage_class_name());
185705 : #endif
185706 : #if 0
185707 : // debugging information!
185708 : printf ("In SgAssignStatement::SgAssignStatement (Sg_File_Info* startOfConstruct, SgLabelRefExp* label, SgExpression* value): this = %p = %s \n",this,this->class_name().c_str());
185709 : #endif
185710 :
185711 0 : p_label = label;
185712 0 : p_value = value;
185713 :
185714 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
185715 :
185716 : #if 0
185717 : // DQ (7/30/2014): Call a virtual function.
185718 : std::string s = this->class_name();
185719 : #endif
185720 :
185721 : // Test the variant virtual function
185722 : // assert(TEMP_Assign_Statement == variant());
185723 0 : assert(TEMP_Assign_Statement == this->variant());
185724 0 : ROSE_ASSERT(TEMP_Assign_Statement == (int)(this->variantT()));
185725 0 : post_construction_initialization();
185726 :
185727 : // Test the isSgAssignStatement() function since it has been problematic
185728 0 : assert(isSgAssignStatement(this) != NULL);
185729 0 : }
185730 :
185731 : // Generated constructor (all data members)
185732 :
185733 : /* #line 185734 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185734 :
185735 :
185736 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
185737 :
185738 :
185739 : // ********************************************************
185740 : // member functions common across all array grammar objects
185741 : // ********************************************************
185742 :
185743 :
185744 :
185745 : /* #line 185746 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185746 :
185747 :
185748 :
185749 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
185750 :
185751 : // ********************************************************
185752 : // member functions specific to each node in the grammar
185753 : // ********************************************************
185754 :
185755 :
185756 : /* #line 185757 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
185757 :
185758 : // Start of memberFunctionString
185759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
185760 :
185761 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
185762 :
185763 : SgExprListExp*
185764 0 : SgComputedGotoStatement::get_labelList () const
185765 : {
185766 0 : ROSE_ASSERT (this != NULL);
185767 :
185768 : #if 0
185769 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185770 : // used to trigger marking transformations for the token-based unparsing.
185771 : printf ("SgComputedGotoStatement::get_labelList = %p = %s \n",this,this->class_name().c_str());
185772 : #endif
185773 :
185774 0 : return p_labelList;
185775 : }
185776 :
185777 : void
185778 0 : SgComputedGotoStatement::set_labelList ( SgExprListExp* labelList )
185779 : {
185780 0 : ROSE_ASSERT (this != NULL);
185781 :
185782 : #if 0
185783 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185784 : // used to trigger marking transformations for the token-based unparsing.
185785 : printf ("SgComputedGotoStatement::set_labelList = %p = %s \n",this,this->class_name().c_str());
185786 : #endif
185787 :
185788 0 : set_isModified(true);
185789 :
185790 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185791 : if (p_labelList != NULL && labelList != NULL && p_labelList != labelList)
185792 : {
185793 : printf ("Warning: labelList = %p overwriting valid pointer p_labelList = %p \n",labelList,p_labelList);
185794 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185795 : printf ("Error fails assertion (p_labelList != NULL && labelList != NULL && p_labelList != labelList) is false\n");
185796 : ROSE_ASSERT(false);
185797 : #endif
185798 : }
185799 : #endif
185800 0 : p_labelList = labelList;
185801 0 : }
185802 :
185803 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185804 :
185805 :
185806 : // End of memberFunctionString
185807 : // Start of memberFunctionString
185808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
185809 :
185810 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
185811 :
185812 : SgExpression*
185813 0 : SgComputedGotoStatement::get_label_index () const
185814 : {
185815 0 : ROSE_ASSERT (this != NULL);
185816 :
185817 : #if 0
185818 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185819 : // used to trigger marking transformations for the token-based unparsing.
185820 : printf ("SgComputedGotoStatement::get_label_index = %p = %s \n",this,this->class_name().c_str());
185821 : #endif
185822 :
185823 0 : return p_label_index;
185824 : }
185825 :
185826 : void
185827 0 : SgComputedGotoStatement::set_label_index ( SgExpression* label_index )
185828 : {
185829 0 : ROSE_ASSERT (this != NULL);
185830 :
185831 : #if 0
185832 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
185833 : // used to trigger marking transformations for the token-based unparsing.
185834 : printf ("SgComputedGotoStatement::set_label_index = %p = %s \n",this,this->class_name().c_str());
185835 : #endif
185836 :
185837 0 : set_isModified(true);
185838 :
185839 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
185840 : if (p_label_index != NULL && label_index != NULL && p_label_index != label_index)
185841 : {
185842 : printf ("Warning: label_index = %p overwriting valid pointer p_label_index = %p \n",label_index,p_label_index);
185843 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
185844 : printf ("Error fails assertion (p_label_index != NULL && label_index != NULL && p_label_index != label_index) is false\n");
185845 : ROSE_ASSERT(false);
185846 : #endif
185847 : }
185848 : #endif
185849 0 : p_label_index = label_index;
185850 0 : }
185851 :
185852 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
185853 :
185854 :
185855 : // End of memberFunctionString
185856 : // Start of memberFunctionString
185857 : /* #line 18779 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
185858 :
185859 :
185860 : void
185861 0 : SgComputedGotoStatement::post_construction_initialization()
185862 0 : {}
185863 :
185864 : #if 0
185865 : // DQ (12/30/2007): This list is no longer requires since we ave build the IR node for a SgLabelRefExp
185866 : // and we can hold this information using an more common ExprListExp instead.
185867 : const SgLabelSymbolPtrList &
185868 : SgComputedGotoStatement::get_labelList() const
185869 : {
185870 : return p_labelList;
185871 : }
185872 :
185873 : SgLabelSymbolPtrList &
185874 : SgComputedGotoStatement::get_labelList()
185875 : {
185876 : return p_labelList;
185877 : }
185878 :
185879 : void
185880 : SgComputedGotoStatement::set_labelList(const SgLabelSymbolPtrList & labelList)
185881 : {
185882 : p_labelList = labelList;
185883 : }
185884 : #endif
185885 :
185886 :
185887 :
185888 : // End of memberFunctionString
185889 : // Start of memberFunctionString
185890 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
185891 :
185892 : // *** COMMON CODE SECTION BEGINS HERE ***
185893 :
185894 : #if 0
185895 : int
185896 : SgComputedGotoStatement::getVariant() const
185897 : {
185898 : // This function is used in ROSE while "variant()" is used in SAGE
185899 : assert(this != NULL);
185900 : return variant();
185901 : }
185902 : #endif
185903 :
185904 : // This function is used in ROSE in treeTraversal code
185905 : // eventually replaces getVariant() and variant()
185906 : // though after variant() has been removed for a while we will
185907 : // want to change the name of variantT() back to variant()
185908 : // (since the "T" was ment to stand for temporary).
185909 : // When this happens the variantT() will be depricated.
185910 : VariantT
185911 0 : SgComputedGotoStatement::variantT() const
185912 : {
185913 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
185914 0 : ROSE_ASSERT(this != NULL);
185915 0 : return V_SgComputedGotoStatement;
185916 : }
185917 :
185918 : #if 0
185919 : int
185920 : SgComputedGotoStatement::variant() const
185921 : {
185922 : // This function is used in SAGE
185923 : ROSE_ASSERT(this != NULL);
185924 : return TEMP_Computed_Goto_Statement;
185925 : }
185926 : #endif
185927 :
185928 : ROSE_DLL_API const char*
185929 0 : SgComputedGotoStatement::sage_class_name() const
185930 : {
185931 0 : ROSE_ASSERT(this != NULL);
185932 0 : return "SgComputedGotoStatement";
185933 : }
185934 :
185935 : std::string
185936 0 : SgComputedGotoStatement::class_name() const
185937 : {
185938 0 : ROSE_ASSERT(this != NULL);
185939 0 : return "SgComputedGotoStatement";
185940 : }
185941 :
185942 : // DQ (11/26/2005): Support for visitor pattern mechanims
185943 : // (inferior to ROSE traversal mechanism, experimental).
185944 : void
185945 0 : SgComputedGotoStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
185946 : {
185947 0 : ROSE_ASSERT(this != NULL);
185948 0 : visitor.visit(this);
185949 0 : }
185950 :
185951 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
185952 0 : void SgComputedGotoStatement::accept (ROSE_VisitorPattern & visitor) {
185953 0 : ROSE_ASSERT(this != NULL);
185954 0 : visitor.visit(this);
185955 0 : }
185956 :
185957 : SgComputedGotoStatement*
185958 0 : SgComputedGotoStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
185959 : {
185960 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
185961 : // This function is currently only supported for the AST used the represent Binary executables.
185962 : if (0 /* isSgAsmNode(this) != NULL */)
185963 : {
185964 : // Support for regex specification.
185965 : std::string prefixCode = "REGEX:";
185966 : addNewAttribute(prefixCode + s,a);
185967 : }
185968 : #endif
185969 :
185970 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
185971 0 : return this;
185972 : }
185973 :
185974 : // *** COMMON CODE SECTION ENDS HERE ***
185975 :
185976 :
185977 : // End of memberFunctionString
185978 : // Start of memberFunctionString
185979 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
185980 :
185981 :
185982 : #if 0
185983 : //! Error checking support
185984 : /*! Verifies the following:
185985 : - working getVariant() member function
185986 : - calls base class's error() member function
185987 : Every class has one of these functions.
185988 : */
185989 : bool
185990 : SgComputedGotoStatement::error()
185991 : {
185992 : // Put error checking here
185993 :
185994 : ROSE_ASSERT (this != NULL);
185995 : if (getVariant() != TEMP_Computed_Goto_Statement)
185996 : {
185997 : printf ("Error in SgComputedGotoStatement::error(): SgComputedGotoStatement object has a %s variant \n",
185998 : Cxx_GrammarTerminalNames[getVariant()].name);
185999 : // printf ("Error in SgComputedGotoStatement::error() \n");
186000 : ROSE_ABORT();
186001 : }
186002 :
186003 : ROSE_ASSERT (getVariant() == TEMP_Computed_Goto_Statement);
186004 : return SgStatement::error();
186005 : }
186006 : #endif
186007 :
186008 :
186009 :
186010 : // End of memberFunctionString
186011 :
186012 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
186013 :
186014 0 : SgComputedGotoStatement* isSgComputedGotoStatement ( SgNode* inputDerivedClassPointer )
186015 : {
186016 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
186017 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
186018 : // So to fix this we return NULL directly when the input is NULL and avoid the
186019 : // dynamic_cast in this case. This is likely a performance improvement as well.
186020 : // return dynamic_cast<SgComputedGotoStatement*>(inputDerivedClassPointer);
186021 : // Milind Chabbi (8/28/2013): isSgComputedGotoStatement uses table-driven castability instead of c++ default dynamic_cast
186022 : // this improves the running time performance by 10-20%.
186023 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgComputedGotoStatement*>(inputDerivedClassPointer);
186024 0 : return IS_SgComputedGotoStatement_FAST_MACRO(inputDerivedClassPointer);
186025 : }
186026 :
186027 : // DQ (11/8/2003): Added version of functions taking const pointer
186028 0 : const SgComputedGotoStatement* isSgComputedGotoStatement ( const SgNode* inputDerivedClassPointer )
186029 : {
186030 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
186031 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
186032 : // So to fix this we return NULL directly when the input is NULL and avoid the
186033 : // dynamic_cast in this case. This is likely a performance improvement as well.
186034 : // return dynamic_cast<const SgComputedGotoStatement*>(inputDerivedClassPointer);
186035 : // Milind Chabbi (8/28/2013): isSgComputedGotoStatement uses table-driven castability instead of c++ default dynamic_cast
186036 : // this improves the running time performance by 10-20%.
186037 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgComputedGotoStatement*>(inputDerivedClassPointer);
186038 0 : return IS_SgComputedGotoStatement_FAST_MACRO(inputDerivedClassPointer);
186039 : }
186040 :
186041 :
186042 :
186043 : /* #line 186044 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186044 :
186045 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
186046 :
186047 : /**
186048 : \brief Generated destructor
186049 :
186050 : This destructor is automatically generated (by ROSETTA). This destructor
186051 : only frees memory of data members associated with the parts of the current IR node which
186052 : are NOT traversed. Those data members that are part of a traversal can be freed using
186053 : a traversal (calling this destructor on all children in a post-order traversal). Such
186054 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
186055 :
186056 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
186057 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
186058 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
186059 :
186060 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
186061 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
186062 : pointers are not yet implemented to call delete on eash pointer in the container.
186063 : (This could be done by derivation from the STL containers to define containers that
186064 : automatically deleted their members.)
186065 :
186066 : */
186067 0 : SgComputedGotoStatement::~SgComputedGotoStatement () {
186068 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
186069 :
186070 :
186071 : // case: not a listType for labelList
186072 0 : p_labelList = NULL; // non list case
186073 : // case: not a listType for label_index
186074 0 : p_label_index = NULL; // non list case
186075 :
186076 : }
186077 :
186078 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
186079 0 : }
186080 :
186081 :
186082 : /* #line 186083 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186083 :
186084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
186085 :
186086 : // Generated constructor
186087 0 : SgComputedGotoStatement::SgComputedGotoStatement ( Sg_File_Info* startOfConstruct, SgExprListExp* labelList, SgExpression* label_index )
186088 0 : : SgStatement(startOfConstruct)
186089 : {
186090 : #ifdef DEBUG
186091 : // printf ("In SgComputedGotoStatement::SgComputedGotoStatement (Sg_File_Info* startOfConstruct, SgExprListExp* labelList, SgExpression* label_index) sage_class_name() = %s \n",sage_class_name());
186092 : #endif
186093 : #if 0
186094 : // debugging information!
186095 : printf ("In SgComputedGotoStatement::SgComputedGotoStatement (Sg_File_Info* startOfConstruct, SgExprListExp* labelList, SgExpression* label_index): this = %p = %s \n",this,this->class_name().c_str());
186096 : #endif
186097 :
186098 0 : p_labelList = labelList;
186099 0 : p_label_index = label_index;
186100 :
186101 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
186102 :
186103 : #if 0
186104 : // DQ (7/30/2014): Call a virtual function.
186105 : std::string s = this->class_name();
186106 : #endif
186107 :
186108 : // Test the variant virtual function
186109 : // assert(TEMP_Computed_Goto_Statement == variant());
186110 0 : assert(TEMP_Computed_Goto_Statement == this->variant());
186111 0 : ROSE_ASSERT(TEMP_Computed_Goto_Statement == (int)(this->variantT()));
186112 0 : post_construction_initialization();
186113 :
186114 : // Test the isSgComputedGotoStatement() function since it has been problematic
186115 0 : assert(isSgComputedGotoStatement(this) != NULL);
186116 0 : }
186117 :
186118 : // Generated constructor (all data members)
186119 :
186120 : /* #line 186121 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186121 :
186122 :
186123 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
186124 :
186125 :
186126 : // ********************************************************
186127 : // member functions common across all array grammar objects
186128 : // ********************************************************
186129 :
186130 :
186131 :
186132 : /* #line 186133 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186133 :
186134 :
186135 :
186136 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
186137 :
186138 : // ********************************************************
186139 : // member functions specific to each node in the grammar
186140 : // ********************************************************
186141 :
186142 :
186143 : /* #line 186144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186144 :
186145 : // Start of memberFunctionString
186146 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186147 :
186148 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186149 :
186150 : SgExprListExp*
186151 0 : SgAssignedGotoStatement::get_targets () const
186152 : {
186153 0 : ROSE_ASSERT (this != NULL);
186154 :
186155 : #if 0
186156 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186157 : // used to trigger marking transformations for the token-based unparsing.
186158 : printf ("SgAssignedGotoStatement::get_targets = %p = %s \n",this,this->class_name().c_str());
186159 : #endif
186160 :
186161 0 : return p_targets;
186162 : }
186163 :
186164 : void
186165 0 : SgAssignedGotoStatement::set_targets ( SgExprListExp* targets )
186166 : {
186167 0 : ROSE_ASSERT (this != NULL);
186168 :
186169 : #if 0
186170 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186171 : // used to trigger marking transformations for the token-based unparsing.
186172 : printf ("SgAssignedGotoStatement::set_targets = %p = %s \n",this,this->class_name().c_str());
186173 : #endif
186174 :
186175 0 : set_isModified(true);
186176 :
186177 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
186178 : if (p_targets != NULL && targets != NULL && p_targets != targets)
186179 : {
186180 : printf ("Warning: targets = %p overwriting valid pointer p_targets = %p \n",targets,p_targets);
186181 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
186182 : printf ("Error fails assertion (p_targets != NULL && targets != NULL && p_targets != targets) is false\n");
186183 : ROSE_ASSERT(false);
186184 : #endif
186185 : }
186186 : #endif
186187 0 : p_targets = targets;
186188 0 : }
186189 :
186190 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
186191 :
186192 :
186193 : // End of memberFunctionString
186194 : // Start of memberFunctionString
186195 : /* #line 18810 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
186196 :
186197 : void
186198 0 : SgAssignedGotoStatement::post_construction_initialization()
186199 0 : {}
186200 :
186201 :
186202 : // End of memberFunctionString
186203 : // Start of memberFunctionString
186204 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
186205 :
186206 : // *** COMMON CODE SECTION BEGINS HERE ***
186207 :
186208 : #if 0
186209 : int
186210 : SgAssignedGotoStatement::getVariant() const
186211 : {
186212 : // This function is used in ROSE while "variant()" is used in SAGE
186213 : assert(this != NULL);
186214 : return variant();
186215 : }
186216 : #endif
186217 :
186218 : // This function is used in ROSE in treeTraversal code
186219 : // eventually replaces getVariant() and variant()
186220 : // though after variant() has been removed for a while we will
186221 : // want to change the name of variantT() back to variant()
186222 : // (since the "T" was ment to stand for temporary).
186223 : // When this happens the variantT() will be depricated.
186224 : VariantT
186225 0 : SgAssignedGotoStatement::variantT() const
186226 : {
186227 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
186228 0 : ROSE_ASSERT(this != NULL);
186229 0 : return V_SgAssignedGotoStatement;
186230 : }
186231 :
186232 : #if 0
186233 : int
186234 : SgAssignedGotoStatement::variant() const
186235 : {
186236 : // This function is used in SAGE
186237 : ROSE_ASSERT(this != NULL);
186238 : return TEMP_Assigned_Goto_Statement;
186239 : }
186240 : #endif
186241 :
186242 : ROSE_DLL_API const char*
186243 0 : SgAssignedGotoStatement::sage_class_name() const
186244 : {
186245 0 : ROSE_ASSERT(this != NULL);
186246 0 : return "SgAssignedGotoStatement";
186247 : }
186248 :
186249 : std::string
186250 0 : SgAssignedGotoStatement::class_name() const
186251 : {
186252 0 : ROSE_ASSERT(this != NULL);
186253 0 : return "SgAssignedGotoStatement";
186254 : }
186255 :
186256 : // DQ (11/26/2005): Support for visitor pattern mechanims
186257 : // (inferior to ROSE traversal mechanism, experimental).
186258 : void
186259 0 : SgAssignedGotoStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
186260 : {
186261 0 : ROSE_ASSERT(this != NULL);
186262 0 : visitor.visit(this);
186263 0 : }
186264 :
186265 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
186266 0 : void SgAssignedGotoStatement::accept (ROSE_VisitorPattern & visitor) {
186267 0 : ROSE_ASSERT(this != NULL);
186268 0 : visitor.visit(this);
186269 0 : }
186270 :
186271 : SgAssignedGotoStatement*
186272 0 : SgAssignedGotoStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
186273 : {
186274 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
186275 : // This function is currently only supported for the AST used the represent Binary executables.
186276 : if (0 /* isSgAsmNode(this) != NULL */)
186277 : {
186278 : // Support for regex specification.
186279 : std::string prefixCode = "REGEX:";
186280 : addNewAttribute(prefixCode + s,a);
186281 : }
186282 : #endif
186283 :
186284 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
186285 0 : return this;
186286 : }
186287 :
186288 : // *** COMMON CODE SECTION ENDS HERE ***
186289 :
186290 :
186291 : // End of memberFunctionString
186292 : // Start of memberFunctionString
186293 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
186294 :
186295 :
186296 : #if 0
186297 : //! Error checking support
186298 : /*! Verifies the following:
186299 : - working getVariant() member function
186300 : - calls base class's error() member function
186301 : Every class has one of these functions.
186302 : */
186303 : bool
186304 : SgAssignedGotoStatement::error()
186305 : {
186306 : // Put error checking here
186307 :
186308 : ROSE_ASSERT (this != NULL);
186309 : if (getVariant() != TEMP_Assigned_Goto_Statement)
186310 : {
186311 : printf ("Error in SgAssignedGotoStatement::error(): SgAssignedGotoStatement object has a %s variant \n",
186312 : Cxx_GrammarTerminalNames[getVariant()].name);
186313 : // printf ("Error in SgAssignedGotoStatement::error() \n");
186314 : ROSE_ABORT();
186315 : }
186316 :
186317 : ROSE_ASSERT (getVariant() == TEMP_Assigned_Goto_Statement);
186318 : return SgStatement::error();
186319 : }
186320 : #endif
186321 :
186322 :
186323 :
186324 : // End of memberFunctionString
186325 :
186326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
186327 :
186328 0 : SgAssignedGotoStatement* isSgAssignedGotoStatement ( SgNode* inputDerivedClassPointer )
186329 : {
186330 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
186331 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
186332 : // So to fix this we return NULL directly when the input is NULL and avoid the
186333 : // dynamic_cast in this case. This is likely a performance improvement as well.
186334 : // return dynamic_cast<SgAssignedGotoStatement*>(inputDerivedClassPointer);
186335 : // Milind Chabbi (8/28/2013): isSgAssignedGotoStatement uses table-driven castability instead of c++ default dynamic_cast
186336 : // this improves the running time performance by 10-20%.
186337 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAssignedGotoStatement*>(inputDerivedClassPointer);
186338 0 : return IS_SgAssignedGotoStatement_FAST_MACRO(inputDerivedClassPointer);
186339 : }
186340 :
186341 : // DQ (11/8/2003): Added version of functions taking const pointer
186342 0 : const SgAssignedGotoStatement* isSgAssignedGotoStatement ( const SgNode* inputDerivedClassPointer )
186343 : {
186344 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
186345 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
186346 : // So to fix this we return NULL directly when the input is NULL and avoid the
186347 : // dynamic_cast in this case. This is likely a performance improvement as well.
186348 : // return dynamic_cast<const SgAssignedGotoStatement*>(inputDerivedClassPointer);
186349 : // Milind Chabbi (8/28/2013): isSgAssignedGotoStatement uses table-driven castability instead of c++ default dynamic_cast
186350 : // this improves the running time performance by 10-20%.
186351 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAssignedGotoStatement*>(inputDerivedClassPointer);
186352 0 : return IS_SgAssignedGotoStatement_FAST_MACRO(inputDerivedClassPointer);
186353 : }
186354 :
186355 :
186356 :
186357 : /* #line 186358 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186358 :
186359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
186360 :
186361 : /**
186362 : \brief Generated destructor
186363 :
186364 : This destructor is automatically generated (by ROSETTA). This destructor
186365 : only frees memory of data members associated with the parts of the current IR node which
186366 : are NOT traversed. Those data members that are part of a traversal can be freed using
186367 : a traversal (calling this destructor on all children in a post-order traversal). Such
186368 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
186369 :
186370 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
186371 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
186372 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
186373 :
186374 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
186375 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
186376 : pointers are not yet implemented to call delete on eash pointer in the container.
186377 : (This could be done by derivation from the STL containers to define containers that
186378 : automatically deleted their members.)
186379 :
186380 : */
186381 0 : SgAssignedGotoStatement::~SgAssignedGotoStatement () {
186382 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
186383 :
186384 :
186385 : // case: not a listType for targets
186386 0 : p_targets = NULL; // non list case
186387 :
186388 : }
186389 :
186390 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
186391 0 : }
186392 :
186393 :
186394 : /* #line 186395 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186395 :
186396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
186397 :
186398 : // Generated constructor
186399 0 : SgAssignedGotoStatement::SgAssignedGotoStatement ( Sg_File_Info* startOfConstruct, SgExprListExp* targets )
186400 0 : : SgStatement(startOfConstruct)
186401 : {
186402 : #ifdef DEBUG
186403 : // printf ("In SgAssignedGotoStatement::SgAssignedGotoStatement (Sg_File_Info* startOfConstruct, SgExprListExp* targets) sage_class_name() = %s \n",sage_class_name());
186404 : #endif
186405 : #if 0
186406 : // debugging information!
186407 : printf ("In SgAssignedGotoStatement::SgAssignedGotoStatement (Sg_File_Info* startOfConstruct, SgExprListExp* targets): this = %p = %s \n",this,this->class_name().c_str());
186408 : #endif
186409 :
186410 0 : p_targets = targets;
186411 :
186412 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
186413 :
186414 : #if 0
186415 : // DQ (7/30/2014): Call a virtual function.
186416 : std::string s = this->class_name();
186417 : #endif
186418 :
186419 : // Test the variant virtual function
186420 : // assert(TEMP_Assigned_Goto_Statement == variant());
186421 0 : assert(TEMP_Assigned_Goto_Statement == this->variant());
186422 0 : ROSE_ASSERT(TEMP_Assigned_Goto_Statement == (int)(this->variantT()));
186423 0 : post_construction_initialization();
186424 :
186425 : // Test the isSgAssignedGotoStatement() function since it has been problematic
186426 0 : assert(isSgAssignedGotoStatement(this) != NULL);
186427 0 : }
186428 :
186429 : // Generated constructor (all data members)
186430 :
186431 : /* #line 186432 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186432 :
186433 :
186434 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
186435 :
186436 :
186437 : // ********************************************************
186438 : // member functions common across all array grammar objects
186439 : // ********************************************************
186440 :
186441 :
186442 :
186443 : /* #line 186444 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186444 :
186445 :
186446 :
186447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
186448 :
186449 : // ********************************************************
186450 : // member functions specific to each node in the grammar
186451 : // ********************************************************
186452 :
186453 :
186454 : /* #line 186455 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186455 :
186456 : // Start of memberFunctionString
186457 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186458 :
186459 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186460 :
186461 : SgExprListExp*
186462 0 : SgAllocateStatement::get_expr_list () const
186463 : {
186464 0 : ROSE_ASSERT (this != NULL);
186465 :
186466 : #if 0
186467 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186468 : // used to trigger marking transformations for the token-based unparsing.
186469 : printf ("SgAllocateStatement::get_expr_list = %p = %s \n",this,this->class_name().c_str());
186470 : #endif
186471 :
186472 0 : return p_expr_list;
186473 : }
186474 :
186475 : void
186476 0 : SgAllocateStatement::set_expr_list ( SgExprListExp* expr_list )
186477 : {
186478 0 : ROSE_ASSERT (this != NULL);
186479 :
186480 : #if 0
186481 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186482 : // used to trigger marking transformations for the token-based unparsing.
186483 : printf ("SgAllocateStatement::set_expr_list = %p = %s \n",this,this->class_name().c_str());
186484 : #endif
186485 :
186486 0 : set_isModified(true);
186487 :
186488 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
186489 : if (p_expr_list != NULL && expr_list != NULL && p_expr_list != expr_list)
186490 : {
186491 : printf ("Warning: expr_list = %p overwriting valid pointer p_expr_list = %p \n",expr_list,p_expr_list);
186492 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
186493 : printf ("Error fails assertion (p_expr_list != NULL && expr_list != NULL && p_expr_list != expr_list) is false\n");
186494 : ROSE_ASSERT(false);
186495 : #endif
186496 : }
186497 : #endif
186498 0 : p_expr_list = expr_list;
186499 0 : }
186500 :
186501 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
186502 :
186503 :
186504 : // End of memberFunctionString
186505 : // Start of memberFunctionString
186506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186507 :
186508 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186509 :
186510 : SgExpression*
186511 0 : SgAllocateStatement::get_stat_expression () const
186512 : {
186513 0 : ROSE_ASSERT (this != NULL);
186514 :
186515 : #if 0
186516 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186517 : // used to trigger marking transformations for the token-based unparsing.
186518 : printf ("SgAllocateStatement::get_stat_expression = %p = %s \n",this,this->class_name().c_str());
186519 : #endif
186520 :
186521 0 : return p_stat_expression;
186522 : }
186523 :
186524 : void
186525 0 : SgAllocateStatement::set_stat_expression ( SgExpression* stat_expression )
186526 : {
186527 0 : ROSE_ASSERT (this != NULL);
186528 :
186529 : #if 0
186530 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186531 : // used to trigger marking transformations for the token-based unparsing.
186532 : printf ("SgAllocateStatement::set_stat_expression = %p = %s \n",this,this->class_name().c_str());
186533 : #endif
186534 :
186535 0 : set_isModified(true);
186536 :
186537 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
186538 : if (p_stat_expression != NULL && stat_expression != NULL && p_stat_expression != stat_expression)
186539 : {
186540 : printf ("Warning: stat_expression = %p overwriting valid pointer p_stat_expression = %p \n",stat_expression,p_stat_expression);
186541 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
186542 : printf ("Error fails assertion (p_stat_expression != NULL && stat_expression != NULL && p_stat_expression != stat_expression) is false\n");
186543 : ROSE_ASSERT(false);
186544 : #endif
186545 : }
186546 : #endif
186547 0 : p_stat_expression = stat_expression;
186548 0 : }
186549 :
186550 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
186551 :
186552 :
186553 : // End of memberFunctionString
186554 : // Start of memberFunctionString
186555 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186556 :
186557 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186558 :
186559 : SgExpression*
186560 0 : SgAllocateStatement::get_errmsg_expression () const
186561 : {
186562 0 : ROSE_ASSERT (this != NULL);
186563 :
186564 : #if 0
186565 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186566 : // used to trigger marking transformations for the token-based unparsing.
186567 : printf ("SgAllocateStatement::get_errmsg_expression = %p = %s \n",this,this->class_name().c_str());
186568 : #endif
186569 :
186570 0 : return p_errmsg_expression;
186571 : }
186572 :
186573 : void
186574 0 : SgAllocateStatement::set_errmsg_expression ( SgExpression* errmsg_expression )
186575 : {
186576 0 : ROSE_ASSERT (this != NULL);
186577 :
186578 : #if 0
186579 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186580 : // used to trigger marking transformations for the token-based unparsing.
186581 : printf ("SgAllocateStatement::set_errmsg_expression = %p = %s \n",this,this->class_name().c_str());
186582 : #endif
186583 :
186584 0 : set_isModified(true);
186585 :
186586 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
186587 : if (p_errmsg_expression != NULL && errmsg_expression != NULL && p_errmsg_expression != errmsg_expression)
186588 : {
186589 : printf ("Warning: errmsg_expression = %p overwriting valid pointer p_errmsg_expression = %p \n",errmsg_expression,p_errmsg_expression);
186590 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
186591 : printf ("Error fails assertion (p_errmsg_expression != NULL && errmsg_expression != NULL && p_errmsg_expression != errmsg_expression) is false\n");
186592 : ROSE_ASSERT(false);
186593 : #endif
186594 : }
186595 : #endif
186596 0 : p_errmsg_expression = errmsg_expression;
186597 0 : }
186598 :
186599 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
186600 :
186601 :
186602 : // End of memberFunctionString
186603 : // Start of memberFunctionString
186604 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186605 :
186606 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186607 :
186608 : SgExpression*
186609 0 : SgAllocateStatement::get_source_expression () const
186610 : {
186611 0 : ROSE_ASSERT (this != NULL);
186612 :
186613 : #if 0
186614 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186615 : // used to trigger marking transformations for the token-based unparsing.
186616 : printf ("SgAllocateStatement::get_source_expression = %p = %s \n",this,this->class_name().c_str());
186617 : #endif
186618 :
186619 0 : return p_source_expression;
186620 : }
186621 :
186622 : void
186623 0 : SgAllocateStatement::set_source_expression ( SgExpression* source_expression )
186624 : {
186625 0 : ROSE_ASSERT (this != NULL);
186626 :
186627 : #if 0
186628 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186629 : // used to trigger marking transformations for the token-based unparsing.
186630 : printf ("SgAllocateStatement::set_source_expression = %p = %s \n",this,this->class_name().c_str());
186631 : #endif
186632 :
186633 0 : set_isModified(true);
186634 :
186635 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
186636 : if (p_source_expression != NULL && source_expression != NULL && p_source_expression != source_expression)
186637 : {
186638 : printf ("Warning: source_expression = %p overwriting valid pointer p_source_expression = %p \n",source_expression,p_source_expression);
186639 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
186640 : printf ("Error fails assertion (p_source_expression != NULL && source_expression != NULL && p_source_expression != source_expression) is false\n");
186641 : ROSE_ASSERT(false);
186642 : #endif
186643 : }
186644 : #endif
186645 0 : p_source_expression = source_expression;
186646 0 : }
186647 :
186648 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
186649 :
186650 :
186651 : // End of memberFunctionString
186652 : // Start of memberFunctionString
186653 : /* #line 18736 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
186654 :
186655 : void
186656 0 : SgAllocateStatement::post_construction_initialization()
186657 0 : {}
186658 :
186659 :
186660 : // End of memberFunctionString
186661 : // Start of memberFunctionString
186662 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
186663 :
186664 : // *** COMMON CODE SECTION BEGINS HERE ***
186665 :
186666 : #if 0
186667 : int
186668 : SgAllocateStatement::getVariant() const
186669 : {
186670 : // This function is used in ROSE while "variant()" is used in SAGE
186671 : assert(this != NULL);
186672 : return variant();
186673 : }
186674 : #endif
186675 :
186676 : // This function is used in ROSE in treeTraversal code
186677 : // eventually replaces getVariant() and variant()
186678 : // though after variant() has been removed for a while we will
186679 : // want to change the name of variantT() back to variant()
186680 : // (since the "T" was ment to stand for temporary).
186681 : // When this happens the variantT() will be depricated.
186682 : VariantT
186683 0 : SgAllocateStatement::variantT() const
186684 : {
186685 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
186686 0 : ROSE_ASSERT(this != NULL);
186687 0 : return V_SgAllocateStatement;
186688 : }
186689 :
186690 : #if 0
186691 : int
186692 : SgAllocateStatement::variant() const
186693 : {
186694 : // This function is used in SAGE
186695 : ROSE_ASSERT(this != NULL);
186696 : return TEMP_Allocate_Statement;
186697 : }
186698 : #endif
186699 :
186700 : ROSE_DLL_API const char*
186701 0 : SgAllocateStatement::sage_class_name() const
186702 : {
186703 0 : ROSE_ASSERT(this != NULL);
186704 0 : return "SgAllocateStatement";
186705 : }
186706 :
186707 : std::string
186708 0 : SgAllocateStatement::class_name() const
186709 : {
186710 0 : ROSE_ASSERT(this != NULL);
186711 0 : return "SgAllocateStatement";
186712 : }
186713 :
186714 : // DQ (11/26/2005): Support for visitor pattern mechanims
186715 : // (inferior to ROSE traversal mechanism, experimental).
186716 : void
186717 0 : SgAllocateStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
186718 : {
186719 0 : ROSE_ASSERT(this != NULL);
186720 0 : visitor.visit(this);
186721 0 : }
186722 :
186723 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
186724 0 : void SgAllocateStatement::accept (ROSE_VisitorPattern & visitor) {
186725 0 : ROSE_ASSERT(this != NULL);
186726 0 : visitor.visit(this);
186727 0 : }
186728 :
186729 : SgAllocateStatement*
186730 0 : SgAllocateStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
186731 : {
186732 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
186733 : // This function is currently only supported for the AST used the represent Binary executables.
186734 : if (0 /* isSgAsmNode(this) != NULL */)
186735 : {
186736 : // Support for regex specification.
186737 : std::string prefixCode = "REGEX:";
186738 : addNewAttribute(prefixCode + s,a);
186739 : }
186740 : #endif
186741 :
186742 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
186743 0 : return this;
186744 : }
186745 :
186746 : // *** COMMON CODE SECTION ENDS HERE ***
186747 :
186748 :
186749 : // End of memberFunctionString
186750 : // Start of memberFunctionString
186751 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
186752 :
186753 :
186754 : #if 0
186755 : //! Error checking support
186756 : /*! Verifies the following:
186757 : - working getVariant() member function
186758 : - calls base class's error() member function
186759 : Every class has one of these functions.
186760 : */
186761 : bool
186762 : SgAllocateStatement::error()
186763 : {
186764 : // Put error checking here
186765 :
186766 : ROSE_ASSERT (this != NULL);
186767 : if (getVariant() != TEMP_Allocate_Statement)
186768 : {
186769 : printf ("Error in SgAllocateStatement::error(): SgAllocateStatement object has a %s variant \n",
186770 : Cxx_GrammarTerminalNames[getVariant()].name);
186771 : // printf ("Error in SgAllocateStatement::error() \n");
186772 : ROSE_ABORT();
186773 : }
186774 :
186775 : ROSE_ASSERT (getVariant() == TEMP_Allocate_Statement);
186776 : return SgStatement::error();
186777 : }
186778 : #endif
186779 :
186780 :
186781 :
186782 : // End of memberFunctionString
186783 :
186784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
186785 :
186786 0 : SgAllocateStatement* isSgAllocateStatement ( SgNode* inputDerivedClassPointer )
186787 : {
186788 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
186789 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
186790 : // So to fix this we return NULL directly when the input is NULL and avoid the
186791 : // dynamic_cast in this case. This is likely a performance improvement as well.
186792 : // return dynamic_cast<SgAllocateStatement*>(inputDerivedClassPointer);
186793 : // Milind Chabbi (8/28/2013): isSgAllocateStatement uses table-driven castability instead of c++ default dynamic_cast
186794 : // this improves the running time performance by 10-20%.
186795 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAllocateStatement*>(inputDerivedClassPointer);
186796 0 : return IS_SgAllocateStatement_FAST_MACRO(inputDerivedClassPointer);
186797 : }
186798 :
186799 : // DQ (11/8/2003): Added version of functions taking const pointer
186800 0 : const SgAllocateStatement* isSgAllocateStatement ( const SgNode* inputDerivedClassPointer )
186801 : {
186802 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
186803 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
186804 : // So to fix this we return NULL directly when the input is NULL and avoid the
186805 : // dynamic_cast in this case. This is likely a performance improvement as well.
186806 : // return dynamic_cast<const SgAllocateStatement*>(inputDerivedClassPointer);
186807 : // Milind Chabbi (8/28/2013): isSgAllocateStatement uses table-driven castability instead of c++ default dynamic_cast
186808 : // this improves the running time performance by 10-20%.
186809 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAllocateStatement*>(inputDerivedClassPointer);
186810 0 : return IS_SgAllocateStatement_FAST_MACRO(inputDerivedClassPointer);
186811 : }
186812 :
186813 :
186814 :
186815 : /* #line 186816 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186816 :
186817 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
186818 :
186819 : /**
186820 : \brief Generated destructor
186821 :
186822 : This destructor is automatically generated (by ROSETTA). This destructor
186823 : only frees memory of data members associated with the parts of the current IR node which
186824 : are NOT traversed. Those data members that are part of a traversal can be freed using
186825 : a traversal (calling this destructor on all children in a post-order traversal). Such
186826 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
186827 :
186828 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
186829 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
186830 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
186831 :
186832 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
186833 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
186834 : pointers are not yet implemented to call delete on eash pointer in the container.
186835 : (This could be done by derivation from the STL containers to define containers that
186836 : automatically deleted their members.)
186837 :
186838 : */
186839 0 : SgAllocateStatement::~SgAllocateStatement () {
186840 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
186841 :
186842 :
186843 : // case: not a listType for expr_list
186844 0 : p_expr_list = NULL; // non list case
186845 : // case: not a listType for stat_expression
186846 0 : p_stat_expression = NULL; // non list case
186847 : // case: not a listType for errmsg_expression
186848 0 : p_errmsg_expression = NULL; // non list case
186849 : // case: not a listType for source_expression
186850 0 : p_source_expression = NULL; // non list case
186851 :
186852 : }
186853 :
186854 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
186855 0 : }
186856 :
186857 :
186858 : /* #line 186859 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186859 :
186860 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
186861 :
186862 : // Generated constructor
186863 0 : SgAllocateStatement::SgAllocateStatement ( Sg_File_Info* startOfConstruct )
186864 0 : : SgStatement(startOfConstruct)
186865 : {
186866 : #ifdef DEBUG
186867 : // printf ("In SgAllocateStatement::SgAllocateStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
186868 : #endif
186869 : #if 0
186870 : // debugging information!
186871 : printf ("In SgAllocateStatement::SgAllocateStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
186872 : #endif
186873 :
186874 0 : p_expr_list = NULL;
186875 0 : p_stat_expression = NULL;
186876 0 : p_errmsg_expression = NULL;
186877 0 : p_source_expression = NULL;
186878 :
186879 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
186880 :
186881 : #if 0
186882 : // DQ (7/30/2014): Call a virtual function.
186883 : std::string s = this->class_name();
186884 : #endif
186885 :
186886 : // Test the variant virtual function
186887 : // assert(TEMP_Allocate_Statement == variant());
186888 0 : assert(TEMP_Allocate_Statement == this->variant());
186889 0 : ROSE_ASSERT(TEMP_Allocate_Statement == (int)(this->variantT()));
186890 0 : post_construction_initialization();
186891 :
186892 : // Test the isSgAllocateStatement() function since it has been problematic
186893 0 : assert(isSgAllocateStatement(this) != NULL);
186894 0 : }
186895 :
186896 : // Generated constructor (all data members)
186897 :
186898 : /* #line 186899 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186899 :
186900 :
186901 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
186902 :
186903 :
186904 : // ********************************************************
186905 : // member functions common across all array grammar objects
186906 : // ********************************************************
186907 :
186908 :
186909 :
186910 : /* #line 186911 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186911 :
186912 :
186913 :
186914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
186915 :
186916 : // ********************************************************
186917 : // member functions specific to each node in the grammar
186918 : // ********************************************************
186919 :
186920 :
186921 : /* #line 186922 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
186922 :
186923 : // Start of memberFunctionString
186924 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186925 :
186926 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186927 :
186928 : SgExprListExp*
186929 0 : SgDeallocateStatement::get_expr_list () const
186930 : {
186931 0 : ROSE_ASSERT (this != NULL);
186932 :
186933 : #if 0
186934 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186935 : // used to trigger marking transformations for the token-based unparsing.
186936 : printf ("SgDeallocateStatement::get_expr_list = %p = %s \n",this,this->class_name().c_str());
186937 : #endif
186938 :
186939 0 : return p_expr_list;
186940 : }
186941 :
186942 : void
186943 0 : SgDeallocateStatement::set_expr_list ( SgExprListExp* expr_list )
186944 : {
186945 0 : ROSE_ASSERT (this != NULL);
186946 :
186947 : #if 0
186948 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186949 : // used to trigger marking transformations for the token-based unparsing.
186950 : printf ("SgDeallocateStatement::set_expr_list = %p = %s \n",this,this->class_name().c_str());
186951 : #endif
186952 :
186953 0 : set_isModified(true);
186954 :
186955 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
186956 : if (p_expr_list != NULL && expr_list != NULL && p_expr_list != expr_list)
186957 : {
186958 : printf ("Warning: expr_list = %p overwriting valid pointer p_expr_list = %p \n",expr_list,p_expr_list);
186959 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
186960 : printf ("Error fails assertion (p_expr_list != NULL && expr_list != NULL && p_expr_list != expr_list) is false\n");
186961 : ROSE_ASSERT(false);
186962 : #endif
186963 : }
186964 : #endif
186965 0 : p_expr_list = expr_list;
186966 0 : }
186967 :
186968 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
186969 :
186970 :
186971 : // End of memberFunctionString
186972 : // Start of memberFunctionString
186973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
186974 :
186975 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
186976 :
186977 : SgExpression*
186978 0 : SgDeallocateStatement::get_stat_expression () const
186979 : {
186980 0 : ROSE_ASSERT (this != NULL);
186981 :
186982 : #if 0
186983 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186984 : // used to trigger marking transformations for the token-based unparsing.
186985 : printf ("SgDeallocateStatement::get_stat_expression = %p = %s \n",this,this->class_name().c_str());
186986 : #endif
186987 :
186988 0 : return p_stat_expression;
186989 : }
186990 :
186991 : void
186992 0 : SgDeallocateStatement::set_stat_expression ( SgExpression* stat_expression )
186993 : {
186994 0 : ROSE_ASSERT (this != NULL);
186995 :
186996 : #if 0
186997 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
186998 : // used to trigger marking transformations for the token-based unparsing.
186999 : printf ("SgDeallocateStatement::set_stat_expression = %p = %s \n",this,this->class_name().c_str());
187000 : #endif
187001 :
187002 0 : set_isModified(true);
187003 :
187004 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
187005 : if (p_stat_expression != NULL && stat_expression != NULL && p_stat_expression != stat_expression)
187006 : {
187007 : printf ("Warning: stat_expression = %p overwriting valid pointer p_stat_expression = %p \n",stat_expression,p_stat_expression);
187008 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
187009 : printf ("Error fails assertion (p_stat_expression != NULL && stat_expression != NULL && p_stat_expression != stat_expression) is false\n");
187010 : ROSE_ASSERT(false);
187011 : #endif
187012 : }
187013 : #endif
187014 0 : p_stat_expression = stat_expression;
187015 0 : }
187016 :
187017 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
187018 :
187019 :
187020 : // End of memberFunctionString
187021 : // Start of memberFunctionString
187022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
187023 :
187024 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
187025 :
187026 : SgExpression*
187027 0 : SgDeallocateStatement::get_errmsg_expression () const
187028 : {
187029 0 : ROSE_ASSERT (this != NULL);
187030 :
187031 : #if 0
187032 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187033 : // used to trigger marking transformations for the token-based unparsing.
187034 : printf ("SgDeallocateStatement::get_errmsg_expression = %p = %s \n",this,this->class_name().c_str());
187035 : #endif
187036 :
187037 0 : return p_errmsg_expression;
187038 : }
187039 :
187040 : void
187041 0 : SgDeallocateStatement::set_errmsg_expression ( SgExpression* errmsg_expression )
187042 : {
187043 0 : ROSE_ASSERT (this != NULL);
187044 :
187045 : #if 0
187046 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187047 : // used to trigger marking transformations for the token-based unparsing.
187048 : printf ("SgDeallocateStatement::set_errmsg_expression = %p = %s \n",this,this->class_name().c_str());
187049 : #endif
187050 :
187051 0 : set_isModified(true);
187052 :
187053 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
187054 : if (p_errmsg_expression != NULL && errmsg_expression != NULL && p_errmsg_expression != errmsg_expression)
187055 : {
187056 : printf ("Warning: errmsg_expression = %p overwriting valid pointer p_errmsg_expression = %p \n",errmsg_expression,p_errmsg_expression);
187057 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
187058 : printf ("Error fails assertion (p_errmsg_expression != NULL && errmsg_expression != NULL && p_errmsg_expression != errmsg_expression) is false\n");
187059 : ROSE_ASSERT(false);
187060 : #endif
187061 : }
187062 : #endif
187063 0 : p_errmsg_expression = errmsg_expression;
187064 0 : }
187065 :
187066 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
187067 :
187068 :
187069 : // End of memberFunctionString
187070 : // Start of memberFunctionString
187071 : /* #line 18743 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
187072 :
187073 : void
187074 0 : SgDeallocateStatement::post_construction_initialization()
187075 0 : {}
187076 :
187077 :
187078 : // End of memberFunctionString
187079 : // Start of memberFunctionString
187080 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
187081 :
187082 : // *** COMMON CODE SECTION BEGINS HERE ***
187083 :
187084 : #if 0
187085 : int
187086 : SgDeallocateStatement::getVariant() const
187087 : {
187088 : // This function is used in ROSE while "variant()" is used in SAGE
187089 : assert(this != NULL);
187090 : return variant();
187091 : }
187092 : #endif
187093 :
187094 : // This function is used in ROSE in treeTraversal code
187095 : // eventually replaces getVariant() and variant()
187096 : // though after variant() has been removed for a while we will
187097 : // want to change the name of variantT() back to variant()
187098 : // (since the "T" was ment to stand for temporary).
187099 : // When this happens the variantT() will be depricated.
187100 : VariantT
187101 0 : SgDeallocateStatement::variantT() const
187102 : {
187103 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
187104 0 : ROSE_ASSERT(this != NULL);
187105 0 : return V_SgDeallocateStatement;
187106 : }
187107 :
187108 : #if 0
187109 : int
187110 : SgDeallocateStatement::variant() const
187111 : {
187112 : // This function is used in SAGE
187113 : ROSE_ASSERT(this != NULL);
187114 : return TEMP_Deallocate_Statement;
187115 : }
187116 : #endif
187117 :
187118 : ROSE_DLL_API const char*
187119 0 : SgDeallocateStatement::sage_class_name() const
187120 : {
187121 0 : ROSE_ASSERT(this != NULL);
187122 0 : return "SgDeallocateStatement";
187123 : }
187124 :
187125 : std::string
187126 0 : SgDeallocateStatement::class_name() const
187127 : {
187128 0 : ROSE_ASSERT(this != NULL);
187129 0 : return "SgDeallocateStatement";
187130 : }
187131 :
187132 : // DQ (11/26/2005): Support for visitor pattern mechanims
187133 : // (inferior to ROSE traversal mechanism, experimental).
187134 : void
187135 0 : SgDeallocateStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
187136 : {
187137 0 : ROSE_ASSERT(this != NULL);
187138 0 : visitor.visit(this);
187139 0 : }
187140 :
187141 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
187142 0 : void SgDeallocateStatement::accept (ROSE_VisitorPattern & visitor) {
187143 0 : ROSE_ASSERT(this != NULL);
187144 0 : visitor.visit(this);
187145 0 : }
187146 :
187147 : SgDeallocateStatement*
187148 0 : SgDeallocateStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
187149 : {
187150 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
187151 : // This function is currently only supported for the AST used the represent Binary executables.
187152 : if (0 /* isSgAsmNode(this) != NULL */)
187153 : {
187154 : // Support for regex specification.
187155 : std::string prefixCode = "REGEX:";
187156 : addNewAttribute(prefixCode + s,a);
187157 : }
187158 : #endif
187159 :
187160 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
187161 0 : return this;
187162 : }
187163 :
187164 : // *** COMMON CODE SECTION ENDS HERE ***
187165 :
187166 :
187167 : // End of memberFunctionString
187168 : // Start of memberFunctionString
187169 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
187170 :
187171 :
187172 : #if 0
187173 : //! Error checking support
187174 : /*! Verifies the following:
187175 : - working getVariant() member function
187176 : - calls base class's error() member function
187177 : Every class has one of these functions.
187178 : */
187179 : bool
187180 : SgDeallocateStatement::error()
187181 : {
187182 : // Put error checking here
187183 :
187184 : ROSE_ASSERT (this != NULL);
187185 : if (getVariant() != TEMP_Deallocate_Statement)
187186 : {
187187 : printf ("Error in SgDeallocateStatement::error(): SgDeallocateStatement object has a %s variant \n",
187188 : Cxx_GrammarTerminalNames[getVariant()].name);
187189 : // printf ("Error in SgDeallocateStatement::error() \n");
187190 : ROSE_ABORT();
187191 : }
187192 :
187193 : ROSE_ASSERT (getVariant() == TEMP_Deallocate_Statement);
187194 : return SgStatement::error();
187195 : }
187196 : #endif
187197 :
187198 :
187199 :
187200 : // End of memberFunctionString
187201 :
187202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
187203 :
187204 0 : SgDeallocateStatement* isSgDeallocateStatement ( SgNode* inputDerivedClassPointer )
187205 : {
187206 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
187207 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
187208 : // So to fix this we return NULL directly when the input is NULL and avoid the
187209 : // dynamic_cast in this case. This is likely a performance improvement as well.
187210 : // return dynamic_cast<SgDeallocateStatement*>(inputDerivedClassPointer);
187211 : // Milind Chabbi (8/28/2013): isSgDeallocateStatement uses table-driven castability instead of c++ default dynamic_cast
187212 : // this improves the running time performance by 10-20%.
187213 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeallocateStatement*>(inputDerivedClassPointer);
187214 0 : return IS_SgDeallocateStatement_FAST_MACRO(inputDerivedClassPointer);
187215 : }
187216 :
187217 : // DQ (11/8/2003): Added version of functions taking const pointer
187218 0 : const SgDeallocateStatement* isSgDeallocateStatement ( const SgNode* inputDerivedClassPointer )
187219 : {
187220 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
187221 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
187222 : // So to fix this we return NULL directly when the input is NULL and avoid the
187223 : // dynamic_cast in this case. This is likely a performance improvement as well.
187224 : // return dynamic_cast<const SgDeallocateStatement*>(inputDerivedClassPointer);
187225 : // Milind Chabbi (8/28/2013): isSgDeallocateStatement uses table-driven castability instead of c++ default dynamic_cast
187226 : // this improves the running time performance by 10-20%.
187227 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeallocateStatement*>(inputDerivedClassPointer);
187228 0 : return IS_SgDeallocateStatement_FAST_MACRO(inputDerivedClassPointer);
187229 : }
187230 :
187231 :
187232 :
187233 : /* #line 187234 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187234 :
187235 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
187236 :
187237 : /**
187238 : \brief Generated destructor
187239 :
187240 : This destructor is automatically generated (by ROSETTA). This destructor
187241 : only frees memory of data members associated with the parts of the current IR node which
187242 : are NOT traversed. Those data members that are part of a traversal can be freed using
187243 : a traversal (calling this destructor on all children in a post-order traversal). Such
187244 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
187245 :
187246 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
187247 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
187248 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
187249 :
187250 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
187251 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
187252 : pointers are not yet implemented to call delete on eash pointer in the container.
187253 : (This could be done by derivation from the STL containers to define containers that
187254 : automatically deleted their members.)
187255 :
187256 : */
187257 0 : SgDeallocateStatement::~SgDeallocateStatement () {
187258 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
187259 :
187260 :
187261 : // case: not a listType for expr_list
187262 0 : p_expr_list = NULL; // non list case
187263 : // case: not a listType for stat_expression
187264 0 : p_stat_expression = NULL; // non list case
187265 : // case: not a listType for errmsg_expression
187266 0 : p_errmsg_expression = NULL; // non list case
187267 :
187268 : }
187269 :
187270 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
187271 0 : }
187272 :
187273 :
187274 : /* #line 187275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187275 :
187276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
187277 :
187278 : // Generated constructor
187279 0 : SgDeallocateStatement::SgDeallocateStatement ( Sg_File_Info* startOfConstruct )
187280 0 : : SgStatement(startOfConstruct)
187281 : {
187282 : #ifdef DEBUG
187283 : // printf ("In SgDeallocateStatement::SgDeallocateStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
187284 : #endif
187285 : #if 0
187286 : // debugging information!
187287 : printf ("In SgDeallocateStatement::SgDeallocateStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
187288 : #endif
187289 :
187290 0 : p_expr_list = NULL;
187291 0 : p_stat_expression = NULL;
187292 0 : p_errmsg_expression = NULL;
187293 :
187294 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
187295 :
187296 : #if 0
187297 : // DQ (7/30/2014): Call a virtual function.
187298 : std::string s = this->class_name();
187299 : #endif
187300 :
187301 : // Test the variant virtual function
187302 : // assert(TEMP_Deallocate_Statement == variant());
187303 0 : assert(TEMP_Deallocate_Statement == this->variant());
187304 0 : ROSE_ASSERT(TEMP_Deallocate_Statement == (int)(this->variantT()));
187305 0 : post_construction_initialization();
187306 :
187307 : // Test the isSgDeallocateStatement() function since it has been problematic
187308 0 : assert(isSgDeallocateStatement(this) != NULL);
187309 0 : }
187310 :
187311 : // Generated constructor (all data members)
187312 :
187313 : /* #line 187314 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187314 :
187315 :
187316 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
187317 :
187318 :
187319 : // ********************************************************
187320 : // member functions common across all array grammar objects
187321 : // ********************************************************
187322 :
187323 :
187324 :
187325 : /* #line 187326 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187326 :
187327 :
187328 :
187329 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
187330 :
187331 : // ********************************************************
187332 : // member functions specific to each node in the grammar
187333 : // ********************************************************
187334 :
187335 :
187336 : /* #line 187337 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187337 :
187338 : // Start of memberFunctionString
187339 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
187340 :
187341 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
187342 :
187343 : SgExpression*
187344 0 : SgUpcNotifyStatement::get_notify_expression () const
187345 : {
187346 0 : ROSE_ASSERT (this != NULL);
187347 :
187348 : #if 0
187349 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187350 : // used to trigger marking transformations for the token-based unparsing.
187351 : printf ("SgUpcNotifyStatement::get_notify_expression = %p = %s \n",this,this->class_name().c_str());
187352 : #endif
187353 :
187354 0 : return p_notify_expression;
187355 : }
187356 :
187357 : void
187358 0 : SgUpcNotifyStatement::set_notify_expression ( SgExpression* notify_expression )
187359 : {
187360 0 : ROSE_ASSERT (this != NULL);
187361 :
187362 : #if 0
187363 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187364 : // used to trigger marking transformations for the token-based unparsing.
187365 : printf ("SgUpcNotifyStatement::set_notify_expression = %p = %s \n",this,this->class_name().c_str());
187366 : #endif
187367 :
187368 0 : set_isModified(true);
187369 :
187370 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
187371 : if (p_notify_expression != NULL && notify_expression != NULL && p_notify_expression != notify_expression)
187372 : {
187373 : printf ("Warning: notify_expression = %p overwriting valid pointer p_notify_expression = %p \n",notify_expression,p_notify_expression);
187374 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
187375 : printf ("Error fails assertion (p_notify_expression != NULL && notify_expression != NULL && p_notify_expression != notify_expression) is false\n");
187376 : ROSE_ASSERT(false);
187377 : #endif
187378 : }
187379 : #endif
187380 0 : p_notify_expression = notify_expression;
187381 0 : }
187382 :
187383 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
187384 :
187385 :
187386 : // End of memberFunctionString
187387 : // Start of memberFunctionString
187388 : /* #line 10594 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
187389 :
187390 : void
187391 0 : SgUpcNotifyStatement::post_construction_initialization()
187392 : {
187393 0 : }
187394 :
187395 :
187396 :
187397 : // End of memberFunctionString
187398 : // Start of memberFunctionString
187399 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
187400 :
187401 : // *** COMMON CODE SECTION BEGINS HERE ***
187402 :
187403 : #if 0
187404 : int
187405 : SgUpcNotifyStatement::getVariant() const
187406 : {
187407 : // This function is used in ROSE while "variant()" is used in SAGE
187408 : assert(this != NULL);
187409 : return variant();
187410 : }
187411 : #endif
187412 :
187413 : // This function is used in ROSE in treeTraversal code
187414 : // eventually replaces getVariant() and variant()
187415 : // though after variant() has been removed for a while we will
187416 : // want to change the name of variantT() back to variant()
187417 : // (since the "T" was ment to stand for temporary).
187418 : // When this happens the variantT() will be depricated.
187419 : VariantT
187420 0 : SgUpcNotifyStatement::variantT() const
187421 : {
187422 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
187423 0 : ROSE_ASSERT(this != NULL);
187424 0 : return V_SgUpcNotifyStatement;
187425 : }
187426 :
187427 : #if 0
187428 : int
187429 : SgUpcNotifyStatement::variant() const
187430 : {
187431 : // This function is used in SAGE
187432 : ROSE_ASSERT(this != NULL);
187433 : return UPC_NOTIFY_STMT;
187434 : }
187435 : #endif
187436 :
187437 : ROSE_DLL_API const char*
187438 0 : SgUpcNotifyStatement::sage_class_name() const
187439 : {
187440 0 : ROSE_ASSERT(this != NULL);
187441 0 : return "SgUpcNotifyStatement";
187442 : }
187443 :
187444 : std::string
187445 0 : SgUpcNotifyStatement::class_name() const
187446 : {
187447 0 : ROSE_ASSERT(this != NULL);
187448 0 : return "SgUpcNotifyStatement";
187449 : }
187450 :
187451 : // DQ (11/26/2005): Support for visitor pattern mechanims
187452 : // (inferior to ROSE traversal mechanism, experimental).
187453 : void
187454 0 : SgUpcNotifyStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
187455 : {
187456 0 : ROSE_ASSERT(this != NULL);
187457 0 : visitor.visit(this);
187458 0 : }
187459 :
187460 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
187461 0 : void SgUpcNotifyStatement::accept (ROSE_VisitorPattern & visitor) {
187462 0 : ROSE_ASSERT(this != NULL);
187463 0 : visitor.visit(this);
187464 0 : }
187465 :
187466 : SgUpcNotifyStatement*
187467 0 : SgUpcNotifyStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
187468 : {
187469 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
187470 : // This function is currently only supported for the AST used the represent Binary executables.
187471 : if (0 /* isSgAsmNode(this) != NULL */)
187472 : {
187473 : // Support for regex specification.
187474 : std::string prefixCode = "REGEX:";
187475 : addNewAttribute(prefixCode + s,a);
187476 : }
187477 : #endif
187478 :
187479 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
187480 0 : return this;
187481 : }
187482 :
187483 : // *** COMMON CODE SECTION ENDS HERE ***
187484 :
187485 :
187486 : // End of memberFunctionString
187487 : // Start of memberFunctionString
187488 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
187489 :
187490 :
187491 : #if 0
187492 : //! Error checking support
187493 : /*! Verifies the following:
187494 : - working getVariant() member function
187495 : - calls base class's error() member function
187496 : Every class has one of these functions.
187497 : */
187498 : bool
187499 : SgUpcNotifyStatement::error()
187500 : {
187501 : // Put error checking here
187502 :
187503 : ROSE_ASSERT (this != NULL);
187504 : if (getVariant() != UPC_NOTIFY_STMT)
187505 : {
187506 : printf ("Error in SgUpcNotifyStatement::error(): SgUpcNotifyStatement object has a %s variant \n",
187507 : Cxx_GrammarTerminalNames[getVariant()].name);
187508 : // printf ("Error in SgUpcNotifyStatement::error() \n");
187509 : ROSE_ABORT();
187510 : }
187511 :
187512 : ROSE_ASSERT (getVariant() == UPC_NOTIFY_STMT);
187513 : return SgStatement::error();
187514 : }
187515 : #endif
187516 :
187517 :
187518 :
187519 : // End of memberFunctionString
187520 :
187521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
187522 :
187523 0 : SgUpcNotifyStatement* isSgUpcNotifyStatement ( SgNode* inputDerivedClassPointer )
187524 : {
187525 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
187526 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
187527 : // So to fix this we return NULL directly when the input is NULL and avoid the
187528 : // dynamic_cast in this case. This is likely a performance improvement as well.
187529 : // return dynamic_cast<SgUpcNotifyStatement*>(inputDerivedClassPointer);
187530 : // Milind Chabbi (8/28/2013): isSgUpcNotifyStatement uses table-driven castability instead of c++ default dynamic_cast
187531 : // this improves the running time performance by 10-20%.
187532 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcNotifyStatement*>(inputDerivedClassPointer);
187533 0 : return IS_SgUpcNotifyStatement_FAST_MACRO(inputDerivedClassPointer);
187534 : }
187535 :
187536 : // DQ (11/8/2003): Added version of functions taking const pointer
187537 0 : const SgUpcNotifyStatement* isSgUpcNotifyStatement ( const SgNode* inputDerivedClassPointer )
187538 : {
187539 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
187540 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
187541 : // So to fix this we return NULL directly when the input is NULL and avoid the
187542 : // dynamic_cast in this case. This is likely a performance improvement as well.
187543 : // return dynamic_cast<const SgUpcNotifyStatement*>(inputDerivedClassPointer);
187544 : // Milind Chabbi (8/28/2013): isSgUpcNotifyStatement uses table-driven castability instead of c++ default dynamic_cast
187545 : // this improves the running time performance by 10-20%.
187546 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcNotifyStatement*>(inputDerivedClassPointer);
187547 0 : return IS_SgUpcNotifyStatement_FAST_MACRO(inputDerivedClassPointer);
187548 : }
187549 :
187550 :
187551 :
187552 : /* #line 187553 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187553 :
187554 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
187555 :
187556 : /**
187557 : \brief Generated destructor
187558 :
187559 : This destructor is automatically generated (by ROSETTA). This destructor
187560 : only frees memory of data members associated with the parts of the current IR node which
187561 : are NOT traversed. Those data members that are part of a traversal can be freed using
187562 : a traversal (calling this destructor on all children in a post-order traversal). Such
187563 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
187564 :
187565 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
187566 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
187567 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
187568 :
187569 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
187570 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
187571 : pointers are not yet implemented to call delete on eash pointer in the container.
187572 : (This could be done by derivation from the STL containers to define containers that
187573 : automatically deleted their members.)
187574 :
187575 : */
187576 0 : SgUpcNotifyStatement::~SgUpcNotifyStatement () {
187577 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
187578 :
187579 :
187580 : // case: not a listType for notify_expression
187581 0 : p_notify_expression = NULL; // non list case
187582 :
187583 : }
187584 :
187585 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
187586 0 : }
187587 :
187588 :
187589 : /* #line 187590 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187590 :
187591 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
187592 :
187593 : // Generated constructor
187594 0 : SgUpcNotifyStatement::SgUpcNotifyStatement ( Sg_File_Info* startOfConstruct, SgExpression* notify_expression )
187595 0 : : SgStatement(startOfConstruct)
187596 : {
187597 : #ifdef DEBUG
187598 : // printf ("In SgUpcNotifyStatement::SgUpcNotifyStatement (Sg_File_Info* startOfConstruct, SgExpression* notify_expression) sage_class_name() = %s \n",sage_class_name());
187599 : #endif
187600 : #if 0
187601 : // debugging information!
187602 : printf ("In SgUpcNotifyStatement::SgUpcNotifyStatement (Sg_File_Info* startOfConstruct, SgExpression* notify_expression): this = %p = %s \n",this,this->class_name().c_str());
187603 : #endif
187604 :
187605 0 : p_notify_expression = notify_expression;
187606 :
187607 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
187608 :
187609 : #if 0
187610 : // DQ (7/30/2014): Call a virtual function.
187611 : std::string s = this->class_name();
187612 : #endif
187613 :
187614 : // Test the variant virtual function
187615 : // assert(UPC_NOTIFY_STMT == variant());
187616 0 : assert(UPC_NOTIFY_STMT == this->variant());
187617 0 : ROSE_ASSERT(UPC_NOTIFY_STMT == (int)(this->variantT()));
187618 0 : post_construction_initialization();
187619 :
187620 : // Test the isSgUpcNotifyStatement() function since it has been problematic
187621 0 : assert(isSgUpcNotifyStatement(this) != NULL);
187622 0 : }
187623 :
187624 : // Generated constructor (all data members)
187625 :
187626 : /* #line 187627 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187627 :
187628 :
187629 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
187630 :
187631 :
187632 : // ********************************************************
187633 : // member functions common across all array grammar objects
187634 : // ********************************************************
187635 :
187636 :
187637 :
187638 : /* #line 187639 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187639 :
187640 :
187641 :
187642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
187643 :
187644 : // ********************************************************
187645 : // member functions specific to each node in the grammar
187646 : // ********************************************************
187647 :
187648 :
187649 : /* #line 187650 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187650 :
187651 : // Start of memberFunctionString
187652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
187653 :
187654 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
187655 :
187656 : SgExpression*
187657 0 : SgUpcWaitStatement::get_wait_expression () const
187658 : {
187659 0 : ROSE_ASSERT (this != NULL);
187660 :
187661 : #if 0
187662 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187663 : // used to trigger marking transformations for the token-based unparsing.
187664 : printf ("SgUpcWaitStatement::get_wait_expression = %p = %s \n",this,this->class_name().c_str());
187665 : #endif
187666 :
187667 0 : return p_wait_expression;
187668 : }
187669 :
187670 : void
187671 0 : SgUpcWaitStatement::set_wait_expression ( SgExpression* wait_expression )
187672 : {
187673 0 : ROSE_ASSERT (this != NULL);
187674 :
187675 : #if 0
187676 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187677 : // used to trigger marking transformations for the token-based unparsing.
187678 : printf ("SgUpcWaitStatement::set_wait_expression = %p = %s \n",this,this->class_name().c_str());
187679 : #endif
187680 :
187681 0 : set_isModified(true);
187682 :
187683 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
187684 : if (p_wait_expression != NULL && wait_expression != NULL && p_wait_expression != wait_expression)
187685 : {
187686 : printf ("Warning: wait_expression = %p overwriting valid pointer p_wait_expression = %p \n",wait_expression,p_wait_expression);
187687 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
187688 : printf ("Error fails assertion (p_wait_expression != NULL && wait_expression != NULL && p_wait_expression != wait_expression) is false\n");
187689 : ROSE_ASSERT(false);
187690 : #endif
187691 : }
187692 : #endif
187693 0 : p_wait_expression = wait_expression;
187694 0 : }
187695 :
187696 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
187697 :
187698 :
187699 : // End of memberFunctionString
187700 : // Start of memberFunctionString
187701 : /* #line 10602 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
187702 :
187703 : void
187704 0 : SgUpcWaitStatement::post_construction_initialization()
187705 : {
187706 0 : }
187707 :
187708 :
187709 :
187710 : // End of memberFunctionString
187711 : // Start of memberFunctionString
187712 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
187713 :
187714 : // *** COMMON CODE SECTION BEGINS HERE ***
187715 :
187716 : #if 0
187717 : int
187718 : SgUpcWaitStatement::getVariant() const
187719 : {
187720 : // This function is used in ROSE while "variant()" is used in SAGE
187721 : assert(this != NULL);
187722 : return variant();
187723 : }
187724 : #endif
187725 :
187726 : // This function is used in ROSE in treeTraversal code
187727 : // eventually replaces getVariant() and variant()
187728 : // though after variant() has been removed for a while we will
187729 : // want to change the name of variantT() back to variant()
187730 : // (since the "T" was ment to stand for temporary).
187731 : // When this happens the variantT() will be depricated.
187732 : VariantT
187733 0 : SgUpcWaitStatement::variantT() const
187734 : {
187735 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
187736 0 : ROSE_ASSERT(this != NULL);
187737 0 : return V_SgUpcWaitStatement;
187738 : }
187739 :
187740 : #if 0
187741 : int
187742 : SgUpcWaitStatement::variant() const
187743 : {
187744 : // This function is used in SAGE
187745 : ROSE_ASSERT(this != NULL);
187746 : return UPC_WAIT_STMT;
187747 : }
187748 : #endif
187749 :
187750 : ROSE_DLL_API const char*
187751 0 : SgUpcWaitStatement::sage_class_name() const
187752 : {
187753 0 : ROSE_ASSERT(this != NULL);
187754 0 : return "SgUpcWaitStatement";
187755 : }
187756 :
187757 : std::string
187758 0 : SgUpcWaitStatement::class_name() const
187759 : {
187760 0 : ROSE_ASSERT(this != NULL);
187761 0 : return "SgUpcWaitStatement";
187762 : }
187763 :
187764 : // DQ (11/26/2005): Support for visitor pattern mechanims
187765 : // (inferior to ROSE traversal mechanism, experimental).
187766 : void
187767 0 : SgUpcWaitStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
187768 : {
187769 0 : ROSE_ASSERT(this != NULL);
187770 0 : visitor.visit(this);
187771 0 : }
187772 :
187773 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
187774 0 : void SgUpcWaitStatement::accept (ROSE_VisitorPattern & visitor) {
187775 0 : ROSE_ASSERT(this != NULL);
187776 0 : visitor.visit(this);
187777 0 : }
187778 :
187779 : SgUpcWaitStatement*
187780 0 : SgUpcWaitStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
187781 : {
187782 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
187783 : // This function is currently only supported for the AST used the represent Binary executables.
187784 : if (0 /* isSgAsmNode(this) != NULL */)
187785 : {
187786 : // Support for regex specification.
187787 : std::string prefixCode = "REGEX:";
187788 : addNewAttribute(prefixCode + s,a);
187789 : }
187790 : #endif
187791 :
187792 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
187793 0 : return this;
187794 : }
187795 :
187796 : // *** COMMON CODE SECTION ENDS HERE ***
187797 :
187798 :
187799 : // End of memberFunctionString
187800 : // Start of memberFunctionString
187801 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
187802 :
187803 :
187804 : #if 0
187805 : //! Error checking support
187806 : /*! Verifies the following:
187807 : - working getVariant() member function
187808 : - calls base class's error() member function
187809 : Every class has one of these functions.
187810 : */
187811 : bool
187812 : SgUpcWaitStatement::error()
187813 : {
187814 : // Put error checking here
187815 :
187816 : ROSE_ASSERT (this != NULL);
187817 : if (getVariant() != UPC_WAIT_STMT)
187818 : {
187819 : printf ("Error in SgUpcWaitStatement::error(): SgUpcWaitStatement object has a %s variant \n",
187820 : Cxx_GrammarTerminalNames[getVariant()].name);
187821 : // printf ("Error in SgUpcWaitStatement::error() \n");
187822 : ROSE_ABORT();
187823 : }
187824 :
187825 : ROSE_ASSERT (getVariant() == UPC_WAIT_STMT);
187826 : return SgStatement::error();
187827 : }
187828 : #endif
187829 :
187830 :
187831 :
187832 : // End of memberFunctionString
187833 :
187834 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
187835 :
187836 0 : SgUpcWaitStatement* isSgUpcWaitStatement ( SgNode* inputDerivedClassPointer )
187837 : {
187838 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
187839 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
187840 : // So to fix this we return NULL directly when the input is NULL and avoid the
187841 : // dynamic_cast in this case. This is likely a performance improvement as well.
187842 : // return dynamic_cast<SgUpcWaitStatement*>(inputDerivedClassPointer);
187843 : // Milind Chabbi (8/28/2013): isSgUpcWaitStatement uses table-driven castability instead of c++ default dynamic_cast
187844 : // this improves the running time performance by 10-20%.
187845 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcWaitStatement*>(inputDerivedClassPointer);
187846 0 : return IS_SgUpcWaitStatement_FAST_MACRO(inputDerivedClassPointer);
187847 : }
187848 :
187849 : // DQ (11/8/2003): Added version of functions taking const pointer
187850 0 : const SgUpcWaitStatement* isSgUpcWaitStatement ( const SgNode* inputDerivedClassPointer )
187851 : {
187852 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
187853 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
187854 : // So to fix this we return NULL directly when the input is NULL and avoid the
187855 : // dynamic_cast in this case. This is likely a performance improvement as well.
187856 : // return dynamic_cast<const SgUpcWaitStatement*>(inputDerivedClassPointer);
187857 : // Milind Chabbi (8/28/2013): isSgUpcWaitStatement uses table-driven castability instead of c++ default dynamic_cast
187858 : // this improves the running time performance by 10-20%.
187859 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcWaitStatement*>(inputDerivedClassPointer);
187860 0 : return IS_SgUpcWaitStatement_FAST_MACRO(inputDerivedClassPointer);
187861 : }
187862 :
187863 :
187864 :
187865 : /* #line 187866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187866 :
187867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
187868 :
187869 : /**
187870 : \brief Generated destructor
187871 :
187872 : This destructor is automatically generated (by ROSETTA). This destructor
187873 : only frees memory of data members associated with the parts of the current IR node which
187874 : are NOT traversed. Those data members that are part of a traversal can be freed using
187875 : a traversal (calling this destructor on all children in a post-order traversal). Such
187876 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
187877 :
187878 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
187879 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
187880 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
187881 :
187882 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
187883 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
187884 : pointers are not yet implemented to call delete on eash pointer in the container.
187885 : (This could be done by derivation from the STL containers to define containers that
187886 : automatically deleted their members.)
187887 :
187888 : */
187889 0 : SgUpcWaitStatement::~SgUpcWaitStatement () {
187890 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
187891 :
187892 :
187893 : // case: not a listType for wait_expression
187894 0 : p_wait_expression = NULL; // non list case
187895 :
187896 : }
187897 :
187898 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
187899 0 : }
187900 :
187901 :
187902 : /* #line 187903 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187903 :
187904 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
187905 :
187906 : // Generated constructor
187907 0 : SgUpcWaitStatement::SgUpcWaitStatement ( Sg_File_Info* startOfConstruct, SgExpression* wait_expression )
187908 0 : : SgStatement(startOfConstruct)
187909 : {
187910 : #ifdef DEBUG
187911 : // printf ("In SgUpcWaitStatement::SgUpcWaitStatement (Sg_File_Info* startOfConstruct, SgExpression* wait_expression) sage_class_name() = %s \n",sage_class_name());
187912 : #endif
187913 : #if 0
187914 : // debugging information!
187915 : printf ("In SgUpcWaitStatement::SgUpcWaitStatement (Sg_File_Info* startOfConstruct, SgExpression* wait_expression): this = %p = %s \n",this,this->class_name().c_str());
187916 : #endif
187917 :
187918 0 : p_wait_expression = wait_expression;
187919 :
187920 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
187921 :
187922 : #if 0
187923 : // DQ (7/30/2014): Call a virtual function.
187924 : std::string s = this->class_name();
187925 : #endif
187926 :
187927 : // Test the variant virtual function
187928 : // assert(UPC_WAIT_STMT == variant());
187929 0 : assert(UPC_WAIT_STMT == this->variant());
187930 0 : ROSE_ASSERT(UPC_WAIT_STMT == (int)(this->variantT()));
187931 0 : post_construction_initialization();
187932 :
187933 : // Test the isSgUpcWaitStatement() function since it has been problematic
187934 0 : assert(isSgUpcWaitStatement(this) != NULL);
187935 0 : }
187936 :
187937 : // Generated constructor (all data members)
187938 :
187939 : /* #line 187940 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187940 :
187941 :
187942 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
187943 :
187944 :
187945 : // ********************************************************
187946 : // member functions common across all array grammar objects
187947 : // ********************************************************
187948 :
187949 :
187950 :
187951 : /* #line 187952 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187952 :
187953 :
187954 :
187955 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
187956 :
187957 : // ********************************************************
187958 : // member functions specific to each node in the grammar
187959 : // ********************************************************
187960 :
187961 :
187962 : /* #line 187963 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
187963 :
187964 : // Start of memberFunctionString
187965 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
187966 :
187967 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
187968 :
187969 : SgExpression*
187970 0 : SgUpcBarrierStatement::get_barrier_expression () const
187971 : {
187972 0 : ROSE_ASSERT (this != NULL);
187973 :
187974 : #if 0
187975 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187976 : // used to trigger marking transformations for the token-based unparsing.
187977 : printf ("SgUpcBarrierStatement::get_barrier_expression = %p = %s \n",this,this->class_name().c_str());
187978 : #endif
187979 :
187980 0 : return p_barrier_expression;
187981 : }
187982 :
187983 : void
187984 0 : SgUpcBarrierStatement::set_barrier_expression ( SgExpression* barrier_expression )
187985 : {
187986 0 : ROSE_ASSERT (this != NULL);
187987 :
187988 : #if 0
187989 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
187990 : // used to trigger marking transformations for the token-based unparsing.
187991 : printf ("SgUpcBarrierStatement::set_barrier_expression = %p = %s \n",this,this->class_name().c_str());
187992 : #endif
187993 :
187994 0 : set_isModified(true);
187995 :
187996 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
187997 : if (p_barrier_expression != NULL && barrier_expression != NULL && p_barrier_expression != barrier_expression)
187998 : {
187999 : printf ("Warning: barrier_expression = %p overwriting valid pointer p_barrier_expression = %p \n",barrier_expression,p_barrier_expression);
188000 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
188001 : printf ("Error fails assertion (p_barrier_expression != NULL && barrier_expression != NULL && p_barrier_expression != barrier_expression) is false\n");
188002 : ROSE_ASSERT(false);
188003 : #endif
188004 : }
188005 : #endif
188006 0 : p_barrier_expression = barrier_expression;
188007 0 : }
188008 :
188009 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
188010 :
188011 :
188012 : // End of memberFunctionString
188013 : // Start of memberFunctionString
188014 : /* #line 10610 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
188015 :
188016 : void
188017 0 : SgUpcBarrierStatement::post_construction_initialization()
188018 : {
188019 0 : }
188020 :
188021 :
188022 :
188023 : // End of memberFunctionString
188024 : // Start of memberFunctionString
188025 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
188026 :
188027 : // *** COMMON CODE SECTION BEGINS HERE ***
188028 :
188029 : #if 0
188030 : int
188031 : SgUpcBarrierStatement::getVariant() const
188032 : {
188033 : // This function is used in ROSE while "variant()" is used in SAGE
188034 : assert(this != NULL);
188035 : return variant();
188036 : }
188037 : #endif
188038 :
188039 : // This function is used in ROSE in treeTraversal code
188040 : // eventually replaces getVariant() and variant()
188041 : // though after variant() has been removed for a while we will
188042 : // want to change the name of variantT() back to variant()
188043 : // (since the "T" was ment to stand for temporary).
188044 : // When this happens the variantT() will be depricated.
188045 : VariantT
188046 0 : SgUpcBarrierStatement::variantT() const
188047 : {
188048 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
188049 0 : ROSE_ASSERT(this != NULL);
188050 0 : return V_SgUpcBarrierStatement;
188051 : }
188052 :
188053 : #if 0
188054 : int
188055 : SgUpcBarrierStatement::variant() const
188056 : {
188057 : // This function is used in SAGE
188058 : ROSE_ASSERT(this != NULL);
188059 : return UPC_BARRIER_STMT;
188060 : }
188061 : #endif
188062 :
188063 : ROSE_DLL_API const char*
188064 0 : SgUpcBarrierStatement::sage_class_name() const
188065 : {
188066 0 : ROSE_ASSERT(this != NULL);
188067 0 : return "SgUpcBarrierStatement";
188068 : }
188069 :
188070 : std::string
188071 0 : SgUpcBarrierStatement::class_name() const
188072 : {
188073 0 : ROSE_ASSERT(this != NULL);
188074 0 : return "SgUpcBarrierStatement";
188075 : }
188076 :
188077 : // DQ (11/26/2005): Support for visitor pattern mechanims
188078 : // (inferior to ROSE traversal mechanism, experimental).
188079 : void
188080 0 : SgUpcBarrierStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
188081 : {
188082 0 : ROSE_ASSERT(this != NULL);
188083 0 : visitor.visit(this);
188084 0 : }
188085 :
188086 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
188087 0 : void SgUpcBarrierStatement::accept (ROSE_VisitorPattern & visitor) {
188088 0 : ROSE_ASSERT(this != NULL);
188089 0 : visitor.visit(this);
188090 0 : }
188091 :
188092 : SgUpcBarrierStatement*
188093 0 : SgUpcBarrierStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
188094 : {
188095 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
188096 : // This function is currently only supported for the AST used the represent Binary executables.
188097 : if (0 /* isSgAsmNode(this) != NULL */)
188098 : {
188099 : // Support for regex specification.
188100 : std::string prefixCode = "REGEX:";
188101 : addNewAttribute(prefixCode + s,a);
188102 : }
188103 : #endif
188104 :
188105 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
188106 0 : return this;
188107 : }
188108 :
188109 : // *** COMMON CODE SECTION ENDS HERE ***
188110 :
188111 :
188112 : // End of memberFunctionString
188113 : // Start of memberFunctionString
188114 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
188115 :
188116 :
188117 : #if 0
188118 : //! Error checking support
188119 : /*! Verifies the following:
188120 : - working getVariant() member function
188121 : - calls base class's error() member function
188122 : Every class has one of these functions.
188123 : */
188124 : bool
188125 : SgUpcBarrierStatement::error()
188126 : {
188127 : // Put error checking here
188128 :
188129 : ROSE_ASSERT (this != NULL);
188130 : if (getVariant() != UPC_BARRIER_STMT)
188131 : {
188132 : printf ("Error in SgUpcBarrierStatement::error(): SgUpcBarrierStatement object has a %s variant \n",
188133 : Cxx_GrammarTerminalNames[getVariant()].name);
188134 : // printf ("Error in SgUpcBarrierStatement::error() \n");
188135 : ROSE_ABORT();
188136 : }
188137 :
188138 : ROSE_ASSERT (getVariant() == UPC_BARRIER_STMT);
188139 : return SgStatement::error();
188140 : }
188141 : #endif
188142 :
188143 :
188144 :
188145 : // End of memberFunctionString
188146 :
188147 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
188148 :
188149 0 : SgUpcBarrierStatement* isSgUpcBarrierStatement ( SgNode* inputDerivedClassPointer )
188150 : {
188151 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
188152 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
188153 : // So to fix this we return NULL directly when the input is NULL and avoid the
188154 : // dynamic_cast in this case. This is likely a performance improvement as well.
188155 : // return dynamic_cast<SgUpcBarrierStatement*>(inputDerivedClassPointer);
188156 : // Milind Chabbi (8/28/2013): isSgUpcBarrierStatement uses table-driven castability instead of c++ default dynamic_cast
188157 : // this improves the running time performance by 10-20%.
188158 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcBarrierStatement*>(inputDerivedClassPointer);
188159 0 : return IS_SgUpcBarrierStatement_FAST_MACRO(inputDerivedClassPointer);
188160 : }
188161 :
188162 : // DQ (11/8/2003): Added version of functions taking const pointer
188163 0 : const SgUpcBarrierStatement* isSgUpcBarrierStatement ( const SgNode* inputDerivedClassPointer )
188164 : {
188165 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
188166 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
188167 : // So to fix this we return NULL directly when the input is NULL and avoid the
188168 : // dynamic_cast in this case. This is likely a performance improvement as well.
188169 : // return dynamic_cast<const SgUpcBarrierStatement*>(inputDerivedClassPointer);
188170 : // Milind Chabbi (8/28/2013): isSgUpcBarrierStatement uses table-driven castability instead of c++ default dynamic_cast
188171 : // this improves the running time performance by 10-20%.
188172 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcBarrierStatement*>(inputDerivedClassPointer);
188173 0 : return IS_SgUpcBarrierStatement_FAST_MACRO(inputDerivedClassPointer);
188174 : }
188175 :
188176 :
188177 :
188178 : /* #line 188179 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188179 :
188180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
188181 :
188182 : /**
188183 : \brief Generated destructor
188184 :
188185 : This destructor is automatically generated (by ROSETTA). This destructor
188186 : only frees memory of data members associated with the parts of the current IR node which
188187 : are NOT traversed. Those data members that are part of a traversal can be freed using
188188 : a traversal (calling this destructor on all children in a post-order traversal). Such
188189 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
188190 :
188191 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
188192 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
188193 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
188194 :
188195 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
188196 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
188197 : pointers are not yet implemented to call delete on eash pointer in the container.
188198 : (This could be done by derivation from the STL containers to define containers that
188199 : automatically deleted their members.)
188200 :
188201 : */
188202 0 : SgUpcBarrierStatement::~SgUpcBarrierStatement () {
188203 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
188204 :
188205 :
188206 : // case: not a listType for barrier_expression
188207 0 : p_barrier_expression = NULL; // non list case
188208 :
188209 : }
188210 :
188211 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
188212 0 : }
188213 :
188214 :
188215 : /* #line 188216 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188216 :
188217 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
188218 :
188219 : // Generated constructor
188220 0 : SgUpcBarrierStatement::SgUpcBarrierStatement ( Sg_File_Info* startOfConstruct, SgExpression* barrier_expression )
188221 0 : : SgStatement(startOfConstruct)
188222 : {
188223 : #ifdef DEBUG
188224 : // printf ("In SgUpcBarrierStatement::SgUpcBarrierStatement (Sg_File_Info* startOfConstruct, SgExpression* barrier_expression) sage_class_name() = %s \n",sage_class_name());
188225 : #endif
188226 : #if 0
188227 : // debugging information!
188228 : printf ("In SgUpcBarrierStatement::SgUpcBarrierStatement (Sg_File_Info* startOfConstruct, SgExpression* barrier_expression): this = %p = %s \n",this,this->class_name().c_str());
188229 : #endif
188230 :
188231 0 : p_barrier_expression = barrier_expression;
188232 :
188233 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
188234 :
188235 : #if 0
188236 : // DQ (7/30/2014): Call a virtual function.
188237 : std::string s = this->class_name();
188238 : #endif
188239 :
188240 : // Test the variant virtual function
188241 : // assert(UPC_BARRIER_STMT == variant());
188242 0 : assert(UPC_BARRIER_STMT == this->variant());
188243 0 : ROSE_ASSERT(UPC_BARRIER_STMT == (int)(this->variantT()));
188244 0 : post_construction_initialization();
188245 :
188246 : // Test the isSgUpcBarrierStatement() function since it has been problematic
188247 0 : assert(isSgUpcBarrierStatement(this) != NULL);
188248 0 : }
188249 :
188250 : // Generated constructor (all data members)
188251 :
188252 : /* #line 188253 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188253 :
188254 :
188255 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
188256 :
188257 :
188258 : // ********************************************************
188259 : // member functions common across all array grammar objects
188260 : // ********************************************************
188261 :
188262 :
188263 :
188264 : /* #line 188265 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188265 :
188266 :
188267 :
188268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
188269 :
188270 : // ********************************************************
188271 : // member functions specific to each node in the grammar
188272 : // ********************************************************
188273 :
188274 :
188275 : /* #line 188276 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188276 :
188277 : // Start of memberFunctionString
188278 : /* #line 10618 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
188279 :
188280 : void
188281 0 : SgUpcFenceStatement::post_construction_initialization()
188282 : {
188283 0 : }
188284 :
188285 :
188286 :
188287 : // End of memberFunctionString
188288 : // Start of memberFunctionString
188289 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
188290 :
188291 : // *** COMMON CODE SECTION BEGINS HERE ***
188292 :
188293 : #if 0
188294 : int
188295 : SgUpcFenceStatement::getVariant() const
188296 : {
188297 : // This function is used in ROSE while "variant()" is used in SAGE
188298 : assert(this != NULL);
188299 : return variant();
188300 : }
188301 : #endif
188302 :
188303 : // This function is used in ROSE in treeTraversal code
188304 : // eventually replaces getVariant() and variant()
188305 : // though after variant() has been removed for a while we will
188306 : // want to change the name of variantT() back to variant()
188307 : // (since the "T" was ment to stand for temporary).
188308 : // When this happens the variantT() will be depricated.
188309 : VariantT
188310 0 : SgUpcFenceStatement::variantT() const
188311 : {
188312 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
188313 0 : ROSE_ASSERT(this != NULL);
188314 0 : return V_SgUpcFenceStatement;
188315 : }
188316 :
188317 : #if 0
188318 : int
188319 : SgUpcFenceStatement::variant() const
188320 : {
188321 : // This function is used in SAGE
188322 : ROSE_ASSERT(this != NULL);
188323 : return UPC_FENCE_STMT;
188324 : }
188325 : #endif
188326 :
188327 : ROSE_DLL_API const char*
188328 0 : SgUpcFenceStatement::sage_class_name() const
188329 : {
188330 0 : ROSE_ASSERT(this != NULL);
188331 0 : return "SgUpcFenceStatement";
188332 : }
188333 :
188334 : std::string
188335 0 : SgUpcFenceStatement::class_name() const
188336 : {
188337 0 : ROSE_ASSERT(this != NULL);
188338 0 : return "SgUpcFenceStatement";
188339 : }
188340 :
188341 : // DQ (11/26/2005): Support for visitor pattern mechanims
188342 : // (inferior to ROSE traversal mechanism, experimental).
188343 : void
188344 0 : SgUpcFenceStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
188345 : {
188346 0 : ROSE_ASSERT(this != NULL);
188347 0 : visitor.visit(this);
188348 0 : }
188349 :
188350 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
188351 0 : void SgUpcFenceStatement::accept (ROSE_VisitorPattern & visitor) {
188352 0 : ROSE_ASSERT(this != NULL);
188353 0 : visitor.visit(this);
188354 0 : }
188355 :
188356 : SgUpcFenceStatement*
188357 0 : SgUpcFenceStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
188358 : {
188359 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
188360 : // This function is currently only supported for the AST used the represent Binary executables.
188361 : if (0 /* isSgAsmNode(this) != NULL */)
188362 : {
188363 : // Support for regex specification.
188364 : std::string prefixCode = "REGEX:";
188365 : addNewAttribute(prefixCode + s,a);
188366 : }
188367 : #endif
188368 :
188369 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
188370 0 : return this;
188371 : }
188372 :
188373 : // *** COMMON CODE SECTION ENDS HERE ***
188374 :
188375 :
188376 : // End of memberFunctionString
188377 : // Start of memberFunctionString
188378 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
188379 :
188380 :
188381 : #if 0
188382 : //! Error checking support
188383 : /*! Verifies the following:
188384 : - working getVariant() member function
188385 : - calls base class's error() member function
188386 : Every class has one of these functions.
188387 : */
188388 : bool
188389 : SgUpcFenceStatement::error()
188390 : {
188391 : // Put error checking here
188392 :
188393 : ROSE_ASSERT (this != NULL);
188394 : if (getVariant() != UPC_FENCE_STMT)
188395 : {
188396 : printf ("Error in SgUpcFenceStatement::error(): SgUpcFenceStatement object has a %s variant \n",
188397 : Cxx_GrammarTerminalNames[getVariant()].name);
188398 : // printf ("Error in SgUpcFenceStatement::error() \n");
188399 : ROSE_ABORT();
188400 : }
188401 :
188402 : ROSE_ASSERT (getVariant() == UPC_FENCE_STMT);
188403 : return SgStatement::error();
188404 : }
188405 : #endif
188406 :
188407 :
188408 :
188409 : // End of memberFunctionString
188410 :
188411 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
188412 :
188413 0 : SgUpcFenceStatement* isSgUpcFenceStatement ( SgNode* inputDerivedClassPointer )
188414 : {
188415 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
188416 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
188417 : // So to fix this we return NULL directly when the input is NULL and avoid the
188418 : // dynamic_cast in this case. This is likely a performance improvement as well.
188419 : // return dynamic_cast<SgUpcFenceStatement*>(inputDerivedClassPointer);
188420 : // Milind Chabbi (8/28/2013): isSgUpcFenceStatement uses table-driven castability instead of c++ default dynamic_cast
188421 : // this improves the running time performance by 10-20%.
188422 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcFenceStatement*>(inputDerivedClassPointer);
188423 0 : return IS_SgUpcFenceStatement_FAST_MACRO(inputDerivedClassPointer);
188424 : }
188425 :
188426 : // DQ (11/8/2003): Added version of functions taking const pointer
188427 0 : const SgUpcFenceStatement* isSgUpcFenceStatement ( const SgNode* inputDerivedClassPointer )
188428 : {
188429 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
188430 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
188431 : // So to fix this we return NULL directly when the input is NULL and avoid the
188432 : // dynamic_cast in this case. This is likely a performance improvement as well.
188433 : // return dynamic_cast<const SgUpcFenceStatement*>(inputDerivedClassPointer);
188434 : // Milind Chabbi (8/28/2013): isSgUpcFenceStatement uses table-driven castability instead of c++ default dynamic_cast
188435 : // this improves the running time performance by 10-20%.
188436 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcFenceStatement*>(inputDerivedClassPointer);
188437 0 : return IS_SgUpcFenceStatement_FAST_MACRO(inputDerivedClassPointer);
188438 : }
188439 :
188440 :
188441 :
188442 : /* #line 188443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188443 :
188444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
188445 :
188446 : /**
188447 : \brief Generated destructor
188448 :
188449 : This destructor is automatically generated (by ROSETTA). This destructor
188450 : only frees memory of data members associated with the parts of the current IR node which
188451 : are NOT traversed. Those data members that are part of a traversal can be freed using
188452 : a traversal (calling this destructor on all children in a post-order traversal). Such
188453 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
188454 :
188455 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
188456 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
188457 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
188458 :
188459 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
188460 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
188461 : pointers are not yet implemented to call delete on eash pointer in the container.
188462 : (This could be done by derivation from the STL containers to define containers that
188463 : automatically deleted their members.)
188464 :
188465 : */
188466 0 : SgUpcFenceStatement::~SgUpcFenceStatement () {
188467 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
188468 :
188469 :
188470 :
188471 : }
188472 :
188473 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
188474 0 : }
188475 :
188476 :
188477 : /* #line 188478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188478 :
188479 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
188480 :
188481 : // Generated constructor
188482 0 : SgUpcFenceStatement::SgUpcFenceStatement ( Sg_File_Info* startOfConstruct )
188483 0 : : SgStatement(startOfConstruct)
188484 : {
188485 : #ifdef DEBUG
188486 : // printf ("In SgUpcFenceStatement::SgUpcFenceStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
188487 : #endif
188488 : #if 0
188489 : // debugging information!
188490 : printf ("In SgUpcFenceStatement::SgUpcFenceStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
188491 : #endif
188492 :
188493 :
188494 :
188495 : #if 0
188496 : // DQ (7/30/2014): Call a virtual function.
188497 : std::string s = this->class_name();
188498 : #endif
188499 :
188500 : // Test the variant virtual function
188501 : // assert(UPC_FENCE_STMT == variant());
188502 0 : assert(UPC_FENCE_STMT == this->variant());
188503 0 : ROSE_ASSERT(UPC_FENCE_STMT == (int)(this->variantT()));
188504 0 : post_construction_initialization();
188505 :
188506 : // Test the isSgUpcFenceStatement() function since it has been problematic
188507 0 : assert(isSgUpcFenceStatement(this) != NULL);
188508 0 : }
188509 :
188510 : // Generated constructor (all data members)
188511 :
188512 : /* #line 188513 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188513 :
188514 :
188515 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
188516 :
188517 :
188518 : // ********************************************************
188519 : // member functions common across all array grammar objects
188520 : // ********************************************************
188521 :
188522 :
188523 :
188524 : /* #line 188525 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188525 :
188526 :
188527 :
188528 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
188529 :
188530 : // ********************************************************
188531 : // member functions specific to each node in the grammar
188532 : // ********************************************************
188533 :
188534 :
188535 : /* #line 188536 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188536 :
188537 : // Start of memberFunctionString
188538 : /* #line 18985 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
188539 :
188540 : void
188541 1363 : SgUpirBaseStatement::post_construction_initialization()
188542 1363 : {}
188543 :
188544 :
188545 : // End of memberFunctionString
188546 : // Start of memberFunctionString
188547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
188548 :
188549 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
188550 :
188551 : SgStatement*
188552 0 : SgUpirBaseStatement::get_upir_parent () const
188553 : {
188554 0 : ROSE_ASSERT (this != NULL);
188555 :
188556 : #if 0
188557 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
188558 : // used to trigger marking transformations for the token-based unparsing.
188559 : printf ("SgUpirBaseStatement::get_upir_parent = %p = %s \n",this,this->class_name().c_str());
188560 : #endif
188561 :
188562 0 : return p_upir_parent;
188563 : }
188564 :
188565 : void
188566 0 : SgUpirBaseStatement::set_upir_parent ( SgStatement* upir_parent )
188567 : {
188568 0 : ROSE_ASSERT (this != NULL);
188569 :
188570 : #if 0
188571 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
188572 : // used to trigger marking transformations for the token-based unparsing.
188573 : printf ("SgUpirBaseStatement::set_upir_parent = %p = %s \n",this,this->class_name().c_str());
188574 : #endif
188575 :
188576 0 : set_isModified(true);
188577 :
188578 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
188579 : if (p_upir_parent != NULL && upir_parent != NULL && p_upir_parent != upir_parent)
188580 : {
188581 : printf ("Warning: upir_parent = %p overwriting valid pointer p_upir_parent = %p \n",upir_parent,p_upir_parent);
188582 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
188583 : printf ("Error fails assertion (p_upir_parent != NULL && upir_parent != NULL && p_upir_parent != upir_parent) is false\n");
188584 : ROSE_ASSERT(false);
188585 : #endif
188586 : }
188587 : #endif
188588 0 : p_upir_parent = upir_parent;
188589 0 : }
188590 :
188591 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
188592 :
188593 :
188594 : // End of memberFunctionString
188595 : // Start of memberFunctionString
188596 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
188597 :
188598 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
188599 :
188600 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
188601 : const SgStatementPtrList &
188602 0 : SgUpirBaseStatement::get_upir_children () const
188603 : {
188604 0 : assert (this != NULL);
188605 0 : return p_upir_children;
188606 : }
188607 :
188608 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
188609 : SgStatementPtrList &
188610 0 : SgUpirBaseStatement::get_upir_children ()
188611 : {
188612 0 : assert (this != NULL);
188613 :
188614 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
188615 : // As a rule only set_ access functions can set the isModified flag.
188616 : // set_isModified(true);
188617 :
188618 0 : return p_upir_children;
188619 : }
188620 :
188621 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
188622 :
188623 :
188624 : // End of memberFunctionString
188625 : // Start of memberFunctionString
188626 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
188627 :
188628 : // *** COMMON CODE SECTION BEGINS HERE ***
188629 :
188630 : #if 0
188631 : int
188632 : SgUpirBaseStatement::getVariant() const
188633 : {
188634 : // This function is used in ROSE while "variant()" is used in SAGE
188635 : assert(this != NULL);
188636 : return variant();
188637 : }
188638 : #endif
188639 :
188640 : // This function is used in ROSE in treeTraversal code
188641 : // eventually replaces getVariant() and variant()
188642 : // though after variant() has been removed for a while we will
188643 : // want to change the name of variantT() back to variant()
188644 : // (since the "T" was ment to stand for temporary).
188645 : // When this happens the variantT() will be depricated.
188646 : VariantT
188647 4089 : SgUpirBaseStatement::variantT() const
188648 : {
188649 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
188650 4089 : ROSE_ASSERT(this != NULL);
188651 4089 : return V_SgUpirBaseStatement;
188652 : }
188653 :
188654 : #if 0
188655 : int
188656 : SgUpirBaseStatement::variant() const
188657 : {
188658 : // This function is used in SAGE
188659 : ROSE_ASSERT(this != NULL);
188660 : return UpirBaseStatementTag;
188661 : }
188662 : #endif
188663 :
188664 : ROSE_DLL_API const char*
188665 0 : SgUpirBaseStatement::sage_class_name() const
188666 : {
188667 0 : ROSE_ASSERT(this != NULL);
188668 0 : return "SgUpirBaseStatement";
188669 : }
188670 :
188671 : std::string
188672 0 : SgUpirBaseStatement::class_name() const
188673 : {
188674 0 : ROSE_ASSERT(this != NULL);
188675 0 : return "SgUpirBaseStatement";
188676 : }
188677 :
188678 : // DQ (11/26/2005): Support for visitor pattern mechanims
188679 : // (inferior to ROSE traversal mechanism, experimental).
188680 : void
188681 0 : SgUpirBaseStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
188682 : {
188683 0 : ROSE_ASSERT(this != NULL);
188684 0 : visitor.visit(this);
188685 0 : }
188686 :
188687 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
188688 0 : void SgUpirBaseStatement::accept (ROSE_VisitorPattern & visitor) {
188689 0 : ROSE_ASSERT(this != NULL);
188690 0 : visitor.visit(this);
188691 0 : }
188692 :
188693 : SgUpirBaseStatement*
188694 0 : SgUpirBaseStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
188695 : {
188696 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
188697 : // This function is currently only supported for the AST used the represent Binary executables.
188698 : if (0 /* isSgAsmNode(this) != NULL */)
188699 : {
188700 : // Support for regex specification.
188701 : std::string prefixCode = "REGEX:";
188702 : addNewAttribute(prefixCode + s,a);
188703 : }
188704 : #endif
188705 :
188706 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
188707 0 : return this;
188708 : }
188709 :
188710 : // *** COMMON CODE SECTION ENDS HERE ***
188711 :
188712 :
188713 : // End of memberFunctionString
188714 : // Start of memberFunctionString
188715 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
188716 :
188717 :
188718 : #if 0
188719 : //! Error checking support
188720 : /*! Verifies the following:
188721 : - working getVariant() member function
188722 : - calls base class's error() member function
188723 : Every class has one of these functions.
188724 : */
188725 : bool
188726 : SgUpirBaseStatement::error()
188727 : {
188728 : // Put error checking here
188729 :
188730 : ROSE_ASSERT (this != NULL);
188731 : if (getVariant() != UpirBaseStatementTag)
188732 : {
188733 : printf ("Error in SgUpirBaseStatement::error(): SgUpirBaseStatement object has a %s variant \n",
188734 : Cxx_GrammarTerminalNames[getVariant()].name);
188735 : // printf ("Error in SgUpirBaseStatement::error() \n");
188736 : ROSE_ABORT();
188737 : }
188738 :
188739 : ROSE_ASSERT (getVariant() == UpirBaseStatementTag);
188740 : return SgStatement::error();
188741 : }
188742 : #endif
188743 :
188744 :
188745 :
188746 : // End of memberFunctionString
188747 :
188748 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
188749 :
188750 1363 : SgUpirBaseStatement* isSgUpirBaseStatement ( SgNode* inputDerivedClassPointer )
188751 : {
188752 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
188753 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
188754 : // So to fix this we return NULL directly when the input is NULL and avoid the
188755 : // dynamic_cast in this case. This is likely a performance improvement as well.
188756 : // return dynamic_cast<SgUpirBaseStatement*>(inputDerivedClassPointer);
188757 : // Milind Chabbi (8/28/2013): isSgUpirBaseStatement uses table-driven castability instead of c++ default dynamic_cast
188758 : // this improves the running time performance by 10-20%.
188759 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirBaseStatement*>(inputDerivedClassPointer);
188760 1363 : return IS_SgUpirBaseStatement_FAST_MACRO(inputDerivedClassPointer);
188761 : }
188762 :
188763 : // DQ (11/8/2003): Added version of functions taking const pointer
188764 0 : const SgUpirBaseStatement* isSgUpirBaseStatement ( const SgNode* inputDerivedClassPointer )
188765 : {
188766 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
188767 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
188768 : // So to fix this we return NULL directly when the input is NULL and avoid the
188769 : // dynamic_cast in this case. This is likely a performance improvement as well.
188770 : // return dynamic_cast<const SgUpirBaseStatement*>(inputDerivedClassPointer);
188771 : // Milind Chabbi (8/28/2013): isSgUpirBaseStatement uses table-driven castability instead of c++ default dynamic_cast
188772 : // this improves the running time performance by 10-20%.
188773 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirBaseStatement*>(inputDerivedClassPointer);
188774 0 : return IS_SgUpirBaseStatement_FAST_MACRO(inputDerivedClassPointer);
188775 : }
188776 :
188777 :
188778 :
188779 : /* #line 188780 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188780 :
188781 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
188782 :
188783 : /**
188784 : \brief Generated destructor
188785 :
188786 : This destructor is automatically generated (by ROSETTA). This destructor
188787 : only frees memory of data members associated with the parts of the current IR node which
188788 : are NOT traversed. Those data members that are part of a traversal can be freed using
188789 : a traversal (calling this destructor on all children in a post-order traversal). Such
188790 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
188791 :
188792 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
188793 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
188794 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
188795 :
188796 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
188797 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
188798 : pointers are not yet implemented to call delete on eash pointer in the container.
188799 : (This could be done by derivation from the STL containers to define containers that
188800 : automatically deleted their members.)
188801 :
188802 : */
188803 0 : SgUpirBaseStatement::~SgUpirBaseStatement () {
188804 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
188805 :
188806 :
188807 : // case: not a listType for upir_parent
188808 0 : p_upir_parent = NULL; // non list case
188809 :
188810 : }
188811 :
188812 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
188813 0 : }
188814 :
188815 :
188816 : /* #line 188817 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188817 :
188818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
188819 :
188820 : // Generated constructor
188821 1326 : SgUpirBaseStatement::SgUpirBaseStatement ( Sg_File_Info* startOfConstruct )
188822 1326 : : SgStatement(startOfConstruct)
188823 : {
188824 : #ifdef DEBUG
188825 : // printf ("In SgUpirBaseStatement::SgUpirBaseStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
188826 : #endif
188827 : #if 0
188828 : // debugging information!
188829 : printf ("In SgUpirBaseStatement::SgUpirBaseStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
188830 : #endif
188831 :
188832 1326 : p_upir_parent = NULL;
188833 :
188834 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
188835 :
188836 : #if 0
188837 : // DQ (7/30/2014): Call a virtual function.
188838 : std::string s = this->class_name();
188839 : #endif
188840 :
188841 : // Test the variant virtual function
188842 : // assert(UpirBaseStatementTag == variant());
188843 1326 : assert(UpirBaseStatementTag == this->variant());
188844 1326 : ROSE_ASSERT(UpirBaseStatementTag == (int)(this->variantT()));
188845 1326 : post_construction_initialization();
188846 :
188847 : // Test the isSgUpirBaseStatement() function since it has been problematic
188848 1326 : assert(isSgUpirBaseStatement(this) != NULL);
188849 1326 : }
188850 :
188851 : // Generated constructor (all data members)
188852 :
188853 : /* #line 188854 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188854 :
188855 :
188856 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
188857 :
188858 :
188859 : // ********************************************************
188860 : // member functions common across all array grammar objects
188861 : // ********************************************************
188862 :
188863 :
188864 :
188865 : /* #line 188866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188866 :
188867 :
188868 :
188869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
188870 :
188871 : // ********************************************************
188872 : // member functions specific to each node in the grammar
188873 : // ********************************************************
188874 :
188875 :
188876 : /* #line 188877 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
188877 :
188878 : // Start of memberFunctionString
188879 : /* #line 19106 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
188880 :
188881 : void
188882 1 : SgOmpTaskyieldStatement::post_construction_initialization()
188883 1 : {}
188884 :
188885 :
188886 : // End of memberFunctionString
188887 : // Start of memberFunctionString
188888 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
188889 :
188890 : // *** COMMON CODE SECTION BEGINS HERE ***
188891 :
188892 : #if 0
188893 : int
188894 : SgOmpTaskyieldStatement::getVariant() const
188895 : {
188896 : // This function is used in ROSE while "variant()" is used in SAGE
188897 : assert(this != NULL);
188898 : return variant();
188899 : }
188900 : #endif
188901 :
188902 : // This function is used in ROSE in treeTraversal code
188903 : // eventually replaces getVariant() and variant()
188904 : // though after variant() has been removed for a while we will
188905 : // want to change the name of variantT() back to variant()
188906 : // (since the "T" was ment to stand for temporary).
188907 : // When this happens the variantT() will be depricated.
188908 : VariantT
188909 77 : SgOmpTaskyieldStatement::variantT() const
188910 : {
188911 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
188912 77 : ROSE_ASSERT(this != NULL);
188913 77 : return V_SgOmpTaskyieldStatement;
188914 : }
188915 :
188916 : #if 0
188917 : int
188918 : SgOmpTaskyieldStatement::variant() const
188919 : {
188920 : // This function is used in SAGE
188921 : ROSE_ASSERT(this != NULL);
188922 : return OMP_TASKYIELD_STMT;
188923 : }
188924 : #endif
188925 :
188926 : ROSE_DLL_API const char*
188927 0 : SgOmpTaskyieldStatement::sage_class_name() const
188928 : {
188929 0 : ROSE_ASSERT(this != NULL);
188930 0 : return "SgOmpTaskyieldStatement";
188931 : }
188932 :
188933 : std::string
188934 1 : SgOmpTaskyieldStatement::class_name() const
188935 : {
188936 1 : ROSE_ASSERT(this != NULL);
188937 1 : return "SgOmpTaskyieldStatement";
188938 : }
188939 :
188940 : // DQ (11/26/2005): Support for visitor pattern mechanims
188941 : // (inferior to ROSE traversal mechanism, experimental).
188942 : void
188943 0 : SgOmpTaskyieldStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
188944 : {
188945 0 : ROSE_ASSERT(this != NULL);
188946 0 : visitor.visit(this);
188947 0 : }
188948 :
188949 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
188950 0 : void SgOmpTaskyieldStatement::accept (ROSE_VisitorPattern & visitor) {
188951 0 : ROSE_ASSERT(this != NULL);
188952 0 : visitor.visit(this);
188953 0 : }
188954 :
188955 : SgOmpTaskyieldStatement*
188956 0 : SgOmpTaskyieldStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
188957 : {
188958 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
188959 : // This function is currently only supported for the AST used the represent Binary executables.
188960 : if (0 /* isSgAsmNode(this) != NULL */)
188961 : {
188962 : // Support for regex specification.
188963 : std::string prefixCode = "REGEX:";
188964 : addNewAttribute(prefixCode + s,a);
188965 : }
188966 : #endif
188967 :
188968 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
188969 0 : return this;
188970 : }
188971 :
188972 : // *** COMMON CODE SECTION ENDS HERE ***
188973 :
188974 :
188975 : // End of memberFunctionString
188976 : // Start of memberFunctionString
188977 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
188978 :
188979 :
188980 : #if 0
188981 : //! Error checking support
188982 : /*! Verifies the following:
188983 : - working getVariant() member function
188984 : - calls base class's error() member function
188985 : Every class has one of these functions.
188986 : */
188987 : bool
188988 : SgOmpTaskyieldStatement::error()
188989 : {
188990 : // Put error checking here
188991 :
188992 : ROSE_ASSERT (this != NULL);
188993 : if (getVariant() != OMP_TASKYIELD_STMT)
188994 : {
188995 : printf ("Error in SgOmpTaskyieldStatement::error(): SgOmpTaskyieldStatement object has a %s variant \n",
188996 : Cxx_GrammarTerminalNames[getVariant()].name);
188997 : // printf ("Error in SgOmpTaskyieldStatement::error() \n");
188998 : ROSE_ABORT();
188999 : }
189000 :
189001 : ROSE_ASSERT (getVariant() == OMP_TASKYIELD_STMT);
189002 : return SgUpirBaseStatement::error();
189003 : }
189004 : #endif
189005 :
189006 :
189007 :
189008 : // End of memberFunctionString
189009 :
189010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
189011 :
189012 1 : SgOmpTaskyieldStatement* isSgOmpTaskyieldStatement ( SgNode* inputDerivedClassPointer )
189013 : {
189014 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189015 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189016 : // So to fix this we return NULL directly when the input is NULL and avoid the
189017 : // dynamic_cast in this case. This is likely a performance improvement as well.
189018 : // return dynamic_cast<SgOmpTaskyieldStatement*>(inputDerivedClassPointer);
189019 : // Milind Chabbi (8/28/2013): isSgOmpTaskyieldStatement uses table-driven castability instead of c++ default dynamic_cast
189020 : // this improves the running time performance by 10-20%.
189021 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskyieldStatement*>(inputDerivedClassPointer);
189022 1 : return IS_SgOmpTaskyieldStatement_FAST_MACRO(inputDerivedClassPointer);
189023 : }
189024 :
189025 : // DQ (11/8/2003): Added version of functions taking const pointer
189026 0 : const SgOmpTaskyieldStatement* isSgOmpTaskyieldStatement ( const SgNode* inputDerivedClassPointer )
189027 : {
189028 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189029 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189030 : // So to fix this we return NULL directly when the input is NULL and avoid the
189031 : // dynamic_cast in this case. This is likely a performance improvement as well.
189032 : // return dynamic_cast<const SgOmpTaskyieldStatement*>(inputDerivedClassPointer);
189033 : // Milind Chabbi (8/28/2013): isSgOmpTaskyieldStatement uses table-driven castability instead of c++ default dynamic_cast
189034 : // this improves the running time performance by 10-20%.
189035 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskyieldStatement*>(inputDerivedClassPointer);
189036 0 : return IS_SgOmpTaskyieldStatement_FAST_MACRO(inputDerivedClassPointer);
189037 : }
189038 :
189039 :
189040 :
189041 : /* #line 189042 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189042 :
189043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189044 :
189045 : /**
189046 : \brief Generated destructor
189047 :
189048 : This destructor is automatically generated (by ROSETTA). This destructor
189049 : only frees memory of data members associated with the parts of the current IR node which
189050 : are NOT traversed. Those data members that are part of a traversal can be freed using
189051 : a traversal (calling this destructor on all children in a post-order traversal). Such
189052 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
189053 :
189054 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
189055 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
189056 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
189057 :
189058 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
189059 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
189060 : pointers are not yet implemented to call delete on eash pointer in the container.
189061 : (This could be done by derivation from the STL containers to define containers that
189062 : automatically deleted their members.)
189063 :
189064 : */
189065 0 : SgOmpTaskyieldStatement::~SgOmpTaskyieldStatement () {
189066 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
189067 :
189068 :
189069 :
189070 : }
189071 :
189072 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189073 0 : }
189074 :
189075 :
189076 : /* #line 189077 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189077 :
189078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
189079 :
189080 : // Generated constructor
189081 0 : SgOmpTaskyieldStatement::SgOmpTaskyieldStatement ( Sg_File_Info* startOfConstruct )
189082 0 : : SgUpirBaseStatement(startOfConstruct)
189083 : {
189084 : #ifdef DEBUG
189085 : // printf ("In SgOmpTaskyieldStatement::SgOmpTaskyieldStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
189086 : #endif
189087 : #if 0
189088 : // debugging information!
189089 : printf ("In SgOmpTaskyieldStatement::SgOmpTaskyieldStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
189090 : #endif
189091 :
189092 :
189093 :
189094 : #if 0
189095 : // DQ (7/30/2014): Call a virtual function.
189096 : std::string s = this->class_name();
189097 : #endif
189098 :
189099 : // Test the variant virtual function
189100 : // assert(OMP_TASKYIELD_STMT == variant());
189101 0 : assert(OMP_TASKYIELD_STMT == this->variant());
189102 0 : ROSE_ASSERT(OMP_TASKYIELD_STMT == (int)(this->variantT()));
189103 0 : post_construction_initialization();
189104 :
189105 : // Test the isSgOmpTaskyieldStatement() function since it has been problematic
189106 0 : assert(isSgOmpTaskyieldStatement(this) != NULL);
189107 0 : }
189108 :
189109 : // Generated constructor (all data members)
189110 :
189111 : /* #line 189112 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189112 :
189113 :
189114 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189115 :
189116 :
189117 : // ********************************************************
189118 : // member functions common across all array grammar objects
189119 : // ********************************************************
189120 :
189121 :
189122 :
189123 : /* #line 189124 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189124 :
189125 :
189126 :
189127 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189128 :
189129 : // ********************************************************
189130 : // member functions specific to each node in the grammar
189131 : // ********************************************************
189132 :
189133 :
189134 : /* #line 189135 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189135 :
189136 : // Start of memberFunctionString
189137 : /* #line 19554 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
189138 :
189139 : void
189140 17 : SgOmpBarrierStatement::post_construction_initialization()
189141 17 : {}
189142 :
189143 :
189144 : // End of memberFunctionString
189145 : // Start of memberFunctionString
189146 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
189147 :
189148 : // *** COMMON CODE SECTION BEGINS HERE ***
189149 :
189150 : #if 0
189151 : int
189152 : SgOmpBarrierStatement::getVariant() const
189153 : {
189154 : // This function is used in ROSE while "variant()" is used in SAGE
189155 : assert(this != NULL);
189156 : return variant();
189157 : }
189158 : #endif
189159 :
189160 : // This function is used in ROSE in treeTraversal code
189161 : // eventually replaces getVariant() and variant()
189162 : // though after variant() has been removed for a while we will
189163 : // want to change the name of variantT() back to variant()
189164 : // (since the "T" was ment to stand for temporary).
189165 : // When this happens the variantT() will be depricated.
189166 : VariantT
189167 1206 : SgOmpBarrierStatement::variantT() const
189168 : {
189169 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
189170 1206 : ROSE_ASSERT(this != NULL);
189171 1206 : return V_SgOmpBarrierStatement;
189172 : }
189173 :
189174 : #if 0
189175 : int
189176 : SgOmpBarrierStatement::variant() const
189177 : {
189178 : // This function is used in SAGE
189179 : ROSE_ASSERT(this != NULL);
189180 : return OMP_BARRIER_STMT;
189181 : }
189182 : #endif
189183 :
189184 : ROSE_DLL_API const char*
189185 0 : SgOmpBarrierStatement::sage_class_name() const
189186 : {
189187 0 : ROSE_ASSERT(this != NULL);
189188 0 : return "SgOmpBarrierStatement";
189189 : }
189190 :
189191 : std::string
189192 17 : SgOmpBarrierStatement::class_name() const
189193 : {
189194 17 : ROSE_ASSERT(this != NULL);
189195 17 : return "SgOmpBarrierStatement";
189196 : }
189197 :
189198 : // DQ (11/26/2005): Support for visitor pattern mechanims
189199 : // (inferior to ROSE traversal mechanism, experimental).
189200 : void
189201 0 : SgOmpBarrierStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
189202 : {
189203 0 : ROSE_ASSERT(this != NULL);
189204 0 : visitor.visit(this);
189205 0 : }
189206 :
189207 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
189208 0 : void SgOmpBarrierStatement::accept (ROSE_VisitorPattern & visitor) {
189209 0 : ROSE_ASSERT(this != NULL);
189210 0 : visitor.visit(this);
189211 0 : }
189212 :
189213 : SgOmpBarrierStatement*
189214 0 : SgOmpBarrierStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
189215 : {
189216 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
189217 : // This function is currently only supported for the AST used the represent Binary executables.
189218 : if (0 /* isSgAsmNode(this) != NULL */)
189219 : {
189220 : // Support for regex specification.
189221 : std::string prefixCode = "REGEX:";
189222 : addNewAttribute(prefixCode + s,a);
189223 : }
189224 : #endif
189225 :
189226 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
189227 0 : return this;
189228 : }
189229 :
189230 : // *** COMMON CODE SECTION ENDS HERE ***
189231 :
189232 :
189233 : // End of memberFunctionString
189234 : // Start of memberFunctionString
189235 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
189236 :
189237 :
189238 : #if 0
189239 : //! Error checking support
189240 : /*! Verifies the following:
189241 : - working getVariant() member function
189242 : - calls base class's error() member function
189243 : Every class has one of these functions.
189244 : */
189245 : bool
189246 : SgOmpBarrierStatement::error()
189247 : {
189248 : // Put error checking here
189249 :
189250 : ROSE_ASSERT (this != NULL);
189251 : if (getVariant() != OMP_BARRIER_STMT)
189252 : {
189253 : printf ("Error in SgOmpBarrierStatement::error(): SgOmpBarrierStatement object has a %s variant \n",
189254 : Cxx_GrammarTerminalNames[getVariant()].name);
189255 : // printf ("Error in SgOmpBarrierStatement::error() \n");
189256 : ROSE_ABORT();
189257 : }
189258 :
189259 : ROSE_ASSERT (getVariant() == OMP_BARRIER_STMT);
189260 : return SgUpirBaseStatement::error();
189261 : }
189262 : #endif
189263 :
189264 :
189265 :
189266 : // End of memberFunctionString
189267 :
189268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
189269 :
189270 17 : SgOmpBarrierStatement* isSgOmpBarrierStatement ( SgNode* inputDerivedClassPointer )
189271 : {
189272 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189273 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189274 : // So to fix this we return NULL directly when the input is NULL and avoid the
189275 : // dynamic_cast in this case. This is likely a performance improvement as well.
189276 : // return dynamic_cast<SgOmpBarrierStatement*>(inputDerivedClassPointer);
189277 : // Milind Chabbi (8/28/2013): isSgOmpBarrierStatement uses table-driven castability instead of c++ default dynamic_cast
189278 : // this improves the running time performance by 10-20%.
189279 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpBarrierStatement*>(inputDerivedClassPointer);
189280 17 : return IS_SgOmpBarrierStatement_FAST_MACRO(inputDerivedClassPointer);
189281 : }
189282 :
189283 : // DQ (11/8/2003): Added version of functions taking const pointer
189284 0 : const SgOmpBarrierStatement* isSgOmpBarrierStatement ( const SgNode* inputDerivedClassPointer )
189285 : {
189286 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189287 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189288 : // So to fix this we return NULL directly when the input is NULL and avoid the
189289 : // dynamic_cast in this case. This is likely a performance improvement as well.
189290 : // return dynamic_cast<const SgOmpBarrierStatement*>(inputDerivedClassPointer);
189291 : // Milind Chabbi (8/28/2013): isSgOmpBarrierStatement uses table-driven castability instead of c++ default dynamic_cast
189292 : // this improves the running time performance by 10-20%.
189293 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpBarrierStatement*>(inputDerivedClassPointer);
189294 0 : return IS_SgOmpBarrierStatement_FAST_MACRO(inputDerivedClassPointer);
189295 : }
189296 :
189297 :
189298 :
189299 : /* #line 189300 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189300 :
189301 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189302 :
189303 : /**
189304 : \brief Generated destructor
189305 :
189306 : This destructor is automatically generated (by ROSETTA). This destructor
189307 : only frees memory of data members associated with the parts of the current IR node which
189308 : are NOT traversed. Those data members that are part of a traversal can be freed using
189309 : a traversal (calling this destructor on all children in a post-order traversal). Such
189310 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
189311 :
189312 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
189313 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
189314 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
189315 :
189316 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
189317 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
189318 : pointers are not yet implemented to call delete on eash pointer in the container.
189319 : (This could be done by derivation from the STL containers to define containers that
189320 : automatically deleted their members.)
189321 :
189322 : */
189323 0 : SgOmpBarrierStatement::~SgOmpBarrierStatement () {
189324 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
189325 :
189326 :
189327 :
189328 : }
189329 :
189330 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189331 0 : }
189332 :
189333 :
189334 : /* #line 189335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189335 :
189336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
189337 :
189338 : // Generated constructor
189339 0 : SgOmpBarrierStatement::SgOmpBarrierStatement ( Sg_File_Info* startOfConstruct )
189340 0 : : SgUpirBaseStatement(startOfConstruct)
189341 : {
189342 : #ifdef DEBUG
189343 : // printf ("In SgOmpBarrierStatement::SgOmpBarrierStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
189344 : #endif
189345 : #if 0
189346 : // debugging information!
189347 : printf ("In SgOmpBarrierStatement::SgOmpBarrierStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
189348 : #endif
189349 :
189350 :
189351 :
189352 : #if 0
189353 : // DQ (7/30/2014): Call a virtual function.
189354 : std::string s = this->class_name();
189355 : #endif
189356 :
189357 : // Test the variant virtual function
189358 : // assert(OMP_BARRIER_STMT == variant());
189359 0 : assert(OMP_BARRIER_STMT == this->variant());
189360 0 : ROSE_ASSERT(OMP_BARRIER_STMT == (int)(this->variantT()));
189361 0 : post_construction_initialization();
189362 :
189363 : // Test the isSgOmpBarrierStatement() function since it has been problematic
189364 0 : assert(isSgOmpBarrierStatement(this) != NULL);
189365 0 : }
189366 :
189367 : // Generated constructor (all data members)
189368 :
189369 : /* #line 189370 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189370 :
189371 :
189372 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189373 :
189374 :
189375 : // ********************************************************
189376 : // member functions common across all array grammar objects
189377 : // ********************************************************
189378 :
189379 :
189380 :
189381 : /* #line 189382 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189382 :
189383 :
189384 :
189385 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189386 :
189387 : // ********************************************************
189388 : // member functions specific to each node in the grammar
189389 : // ********************************************************
189390 :
189391 :
189392 : /* #line 189393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189393 :
189394 : // Start of memberFunctionString
189395 : /* #line 19523 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
189396 :
189397 : void
189398 928 : SgUpirBodyStatement::post_construction_initialization()
189399 928 : {}
189400 :
189401 : bool
189402 0 : SgUpirBodyStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
189403 : {
189404 0 : return ( StatementReplace(this, p_body, target, newstmt) == true );
189405 : }
189406 :
189407 :
189408 : // End of memberFunctionString
189409 : // Start of memberFunctionString
189410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
189411 :
189412 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
189413 :
189414 : SgStatement*
189415 1775 : SgUpirBodyStatement::get_body () const
189416 : {
189417 1775 : ROSE_ASSERT (this != NULL);
189418 :
189419 : #if 0
189420 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
189421 : // used to trigger marking transformations for the token-based unparsing.
189422 : printf ("SgUpirBodyStatement::get_body = %p = %s \n",this,this->class_name().c_str());
189423 : #endif
189424 :
189425 1775 : return p_body;
189426 : }
189427 :
189428 : void
189429 0 : SgUpirBodyStatement::set_body ( SgStatement* body )
189430 : {
189431 0 : ROSE_ASSERT (this != NULL);
189432 :
189433 : #if 0
189434 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
189435 : // used to trigger marking transformations for the token-based unparsing.
189436 : printf ("SgUpirBodyStatement::set_body = %p = %s \n",this,this->class_name().c_str());
189437 : #endif
189438 :
189439 0 : set_isModified(true);
189440 :
189441 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
189442 : if (p_body != NULL && body != NULL && p_body != body)
189443 : {
189444 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
189445 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
189446 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
189447 : ROSE_ASSERT(false);
189448 : #endif
189449 : }
189450 : #endif
189451 0 : p_body = body;
189452 0 : }
189453 :
189454 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
189455 :
189456 :
189457 : // End of memberFunctionString
189458 : // Start of memberFunctionString
189459 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
189460 :
189461 : // *** COMMON CODE SECTION BEGINS HERE ***
189462 :
189463 : #if 0
189464 : int
189465 : SgUpirBodyStatement::getVariant() const
189466 : {
189467 : // This function is used in ROSE while "variant()" is used in SAGE
189468 : assert(this != NULL);
189469 : return variant();
189470 : }
189471 : #endif
189472 :
189473 : // This function is used in ROSE in treeTraversal code
189474 : // eventually replaces getVariant() and variant()
189475 : // though after variant() has been removed for a while we will
189476 : // want to change the name of variantT() back to variant()
189477 : // (since the "T" was ment to stand for temporary).
189478 : // When this happens the variantT() will be depricated.
189479 : VariantT
189480 2784 : SgUpirBodyStatement::variantT() const
189481 : {
189482 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
189483 2784 : ROSE_ASSERT(this != NULL);
189484 2784 : return V_SgUpirBodyStatement;
189485 : }
189486 :
189487 : #if 0
189488 : int
189489 : SgUpirBodyStatement::variant() const
189490 : {
189491 : // This function is used in SAGE
189492 : ROSE_ASSERT(this != NULL);
189493 : return UPIR_BODY_STMT;
189494 : }
189495 : #endif
189496 :
189497 : ROSE_DLL_API const char*
189498 0 : SgUpirBodyStatement::sage_class_name() const
189499 : {
189500 0 : ROSE_ASSERT(this != NULL);
189501 0 : return "SgUpirBodyStatement";
189502 : }
189503 :
189504 : std::string
189505 0 : SgUpirBodyStatement::class_name() const
189506 : {
189507 0 : ROSE_ASSERT(this != NULL);
189508 0 : return "SgUpirBodyStatement";
189509 : }
189510 :
189511 : // DQ (11/26/2005): Support for visitor pattern mechanims
189512 : // (inferior to ROSE traversal mechanism, experimental).
189513 : void
189514 0 : SgUpirBodyStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
189515 : {
189516 0 : ROSE_ASSERT(this != NULL);
189517 0 : visitor.visit(this);
189518 0 : }
189519 :
189520 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
189521 0 : void SgUpirBodyStatement::accept (ROSE_VisitorPattern & visitor) {
189522 0 : ROSE_ASSERT(this != NULL);
189523 0 : visitor.visit(this);
189524 0 : }
189525 :
189526 : SgUpirBodyStatement*
189527 0 : SgUpirBodyStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
189528 : {
189529 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
189530 : // This function is currently only supported for the AST used the represent Binary executables.
189531 : if (0 /* isSgAsmNode(this) != NULL */)
189532 : {
189533 : // Support for regex specification.
189534 : std::string prefixCode = "REGEX:";
189535 : addNewAttribute(prefixCode + s,a);
189536 : }
189537 : #endif
189538 :
189539 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
189540 0 : return this;
189541 : }
189542 :
189543 : // *** COMMON CODE SECTION ENDS HERE ***
189544 :
189545 :
189546 : // End of memberFunctionString
189547 : // Start of memberFunctionString
189548 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
189549 :
189550 :
189551 : #if 0
189552 : //! Error checking support
189553 : /*! Verifies the following:
189554 : - working getVariant() member function
189555 : - calls base class's error() member function
189556 : Every class has one of these functions.
189557 : */
189558 : bool
189559 : SgUpirBodyStatement::error()
189560 : {
189561 : // Put error checking here
189562 :
189563 : ROSE_ASSERT (this != NULL);
189564 : if (getVariant() != UPIR_BODY_STMT)
189565 : {
189566 : printf ("Error in SgUpirBodyStatement::error(): SgUpirBodyStatement object has a %s variant \n",
189567 : Cxx_GrammarTerminalNames[getVariant()].name);
189568 : // printf ("Error in SgUpirBodyStatement::error() \n");
189569 : ROSE_ABORT();
189570 : }
189571 :
189572 : ROSE_ASSERT (getVariant() == UPIR_BODY_STMT);
189573 : return SgUpirBaseStatement::error();
189574 : }
189575 : #endif
189576 :
189577 :
189578 :
189579 : // End of memberFunctionString
189580 :
189581 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
189582 :
189583 4559 : SgUpirBodyStatement* isSgUpirBodyStatement ( SgNode* inputDerivedClassPointer )
189584 : {
189585 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189586 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189587 : // So to fix this we return NULL directly when the input is NULL and avoid the
189588 : // dynamic_cast in this case. This is likely a performance improvement as well.
189589 : // return dynamic_cast<SgUpirBodyStatement*>(inputDerivedClassPointer);
189590 : // Milind Chabbi (8/28/2013): isSgUpirBodyStatement uses table-driven castability instead of c++ default dynamic_cast
189591 : // this improves the running time performance by 10-20%.
189592 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirBodyStatement*>(inputDerivedClassPointer);
189593 4559 : return IS_SgUpirBodyStatement_FAST_MACRO(inputDerivedClassPointer);
189594 : }
189595 :
189596 : // DQ (11/8/2003): Added version of functions taking const pointer
189597 0 : const SgUpirBodyStatement* isSgUpirBodyStatement ( const SgNode* inputDerivedClassPointer )
189598 : {
189599 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189600 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189601 : // So to fix this we return NULL directly when the input is NULL and avoid the
189602 : // dynamic_cast in this case. This is likely a performance improvement as well.
189603 : // return dynamic_cast<const SgUpirBodyStatement*>(inputDerivedClassPointer);
189604 : // Milind Chabbi (8/28/2013): isSgUpirBodyStatement uses table-driven castability instead of c++ default dynamic_cast
189605 : // this improves the running time performance by 10-20%.
189606 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirBodyStatement*>(inputDerivedClassPointer);
189607 0 : return IS_SgUpirBodyStatement_FAST_MACRO(inputDerivedClassPointer);
189608 : }
189609 :
189610 :
189611 :
189612 : /* #line 189613 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189613 :
189614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189615 :
189616 : /**
189617 : \brief Generated destructor
189618 :
189619 : This destructor is automatically generated (by ROSETTA). This destructor
189620 : only frees memory of data members associated with the parts of the current IR node which
189621 : are NOT traversed. Those data members that are part of a traversal can be freed using
189622 : a traversal (calling this destructor on all children in a post-order traversal). Such
189623 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
189624 :
189625 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
189626 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
189627 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
189628 :
189629 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
189630 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
189631 : pointers are not yet implemented to call delete on eash pointer in the container.
189632 : (This could be done by derivation from the STL containers to define containers that
189633 : automatically deleted their members.)
189634 :
189635 : */
189636 0 : SgUpirBodyStatement::~SgUpirBodyStatement () {
189637 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
189638 :
189639 :
189640 : // case: not a listType for body
189641 0 : p_body = NULL; // non list case
189642 :
189643 : }
189644 :
189645 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189646 0 : }
189647 :
189648 :
189649 : /* #line 189650 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189650 :
189651 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
189652 :
189653 : // Generated constructor
189654 928 : SgUpirBodyStatement::SgUpirBodyStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
189655 928 : : SgUpirBaseStatement(startOfConstruct)
189656 : {
189657 : #ifdef DEBUG
189658 : // printf ("In SgUpirBodyStatement::SgUpirBodyStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
189659 : #endif
189660 : #if 0
189661 : // debugging information!
189662 : printf ("In SgUpirBodyStatement::SgUpirBodyStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
189663 : #endif
189664 :
189665 928 : p_body = body;
189666 :
189667 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
189668 :
189669 : #if 0
189670 : // DQ (7/30/2014): Call a virtual function.
189671 : std::string s = this->class_name();
189672 : #endif
189673 :
189674 : // Test the variant virtual function
189675 : // assert(UPIR_BODY_STMT == variant());
189676 928 : assert(UPIR_BODY_STMT == this->variant());
189677 928 : ROSE_ASSERT(UPIR_BODY_STMT == (int)(this->variantT()));
189678 928 : post_construction_initialization();
189679 :
189680 : // Test the isSgUpirBodyStatement() function since it has been problematic
189681 928 : assert(isSgUpirBodyStatement(this) != NULL);
189682 928 : }
189683 :
189684 : // Generated constructor (all data members)
189685 :
189686 : /* #line 189687 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189687 :
189688 :
189689 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189690 :
189691 :
189692 : // ********************************************************
189693 : // member functions common across all array grammar objects
189694 : // ********************************************************
189695 :
189696 :
189697 :
189698 : /* #line 189699 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189699 :
189700 :
189701 :
189702 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189703 :
189704 : // ********************************************************
189705 : // member functions specific to each node in the grammar
189706 : // ********************************************************
189707 :
189708 :
189709 : /* #line 189710 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189710 :
189711 : // Start of memberFunctionString
189712 : /* #line 19100 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
189713 :
189714 : void
189715 14 : SgOmpMasterStatement::post_construction_initialization()
189716 14 : {}
189717 :
189718 :
189719 : // End of memberFunctionString
189720 : // Start of memberFunctionString
189721 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
189722 :
189723 : // *** COMMON CODE SECTION BEGINS HERE ***
189724 :
189725 : #if 0
189726 : int
189727 : SgOmpMasterStatement::getVariant() const
189728 : {
189729 : // This function is used in ROSE while "variant()" is used in SAGE
189730 : assert(this != NULL);
189731 : return variant();
189732 : }
189733 : #endif
189734 :
189735 : // This function is used in ROSE in treeTraversal code
189736 : // eventually replaces getVariant() and variant()
189737 : // though after variant() has been removed for a while we will
189738 : // want to change the name of variantT() back to variant()
189739 : // (since the "T" was ment to stand for temporary).
189740 : // When this happens the variantT() will be depricated.
189741 : VariantT
189742 1123 : SgOmpMasterStatement::variantT() const
189743 : {
189744 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
189745 1123 : ROSE_ASSERT(this != NULL);
189746 1123 : return V_SgOmpMasterStatement;
189747 : }
189748 :
189749 : #if 0
189750 : int
189751 : SgOmpMasterStatement::variant() const
189752 : {
189753 : // This function is used in SAGE
189754 : ROSE_ASSERT(this != NULL);
189755 : return OMP_MASTER_STMT;
189756 : }
189757 : #endif
189758 :
189759 : ROSE_DLL_API const char*
189760 0 : SgOmpMasterStatement::sage_class_name() const
189761 : {
189762 0 : ROSE_ASSERT(this != NULL);
189763 0 : return "SgOmpMasterStatement";
189764 : }
189765 :
189766 : std::string
189767 14 : SgOmpMasterStatement::class_name() const
189768 : {
189769 14 : ROSE_ASSERT(this != NULL);
189770 14 : return "SgOmpMasterStatement";
189771 : }
189772 :
189773 : // DQ (11/26/2005): Support for visitor pattern mechanims
189774 : // (inferior to ROSE traversal mechanism, experimental).
189775 : void
189776 0 : SgOmpMasterStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
189777 : {
189778 0 : ROSE_ASSERT(this != NULL);
189779 0 : visitor.visit(this);
189780 0 : }
189781 :
189782 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
189783 0 : void SgOmpMasterStatement::accept (ROSE_VisitorPattern & visitor) {
189784 0 : ROSE_ASSERT(this != NULL);
189785 0 : visitor.visit(this);
189786 0 : }
189787 :
189788 : SgOmpMasterStatement*
189789 0 : SgOmpMasterStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
189790 : {
189791 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
189792 : // This function is currently only supported for the AST used the represent Binary executables.
189793 : if (0 /* isSgAsmNode(this) != NULL */)
189794 : {
189795 : // Support for regex specification.
189796 : std::string prefixCode = "REGEX:";
189797 : addNewAttribute(prefixCode + s,a);
189798 : }
189799 : #endif
189800 :
189801 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
189802 0 : return this;
189803 : }
189804 :
189805 : // *** COMMON CODE SECTION ENDS HERE ***
189806 :
189807 :
189808 : // End of memberFunctionString
189809 : // Start of memberFunctionString
189810 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
189811 :
189812 :
189813 : #if 0
189814 : //! Error checking support
189815 : /*! Verifies the following:
189816 : - working getVariant() member function
189817 : - calls base class's error() member function
189818 : Every class has one of these functions.
189819 : */
189820 : bool
189821 : SgOmpMasterStatement::error()
189822 : {
189823 : // Put error checking here
189824 :
189825 : ROSE_ASSERT (this != NULL);
189826 : if (getVariant() != OMP_MASTER_STMT)
189827 : {
189828 : printf ("Error in SgOmpMasterStatement::error(): SgOmpMasterStatement object has a %s variant \n",
189829 : Cxx_GrammarTerminalNames[getVariant()].name);
189830 : // printf ("Error in SgOmpMasterStatement::error() \n");
189831 : ROSE_ABORT();
189832 : }
189833 :
189834 : ROSE_ASSERT (getVariant() == OMP_MASTER_STMT);
189835 : return SgUpirBodyStatement::error();
189836 : }
189837 : #endif
189838 :
189839 :
189840 :
189841 : // End of memberFunctionString
189842 :
189843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
189844 :
189845 14 : SgOmpMasterStatement* isSgOmpMasterStatement ( SgNode* inputDerivedClassPointer )
189846 : {
189847 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189848 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189849 : // So to fix this we return NULL directly when the input is NULL and avoid the
189850 : // dynamic_cast in this case. This is likely a performance improvement as well.
189851 : // return dynamic_cast<SgOmpMasterStatement*>(inputDerivedClassPointer);
189852 : // Milind Chabbi (8/28/2013): isSgOmpMasterStatement uses table-driven castability instead of c++ default dynamic_cast
189853 : // this improves the running time performance by 10-20%.
189854 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpMasterStatement*>(inputDerivedClassPointer);
189855 14 : return IS_SgOmpMasterStatement_FAST_MACRO(inputDerivedClassPointer);
189856 : }
189857 :
189858 : // DQ (11/8/2003): Added version of functions taking const pointer
189859 0 : const SgOmpMasterStatement* isSgOmpMasterStatement ( const SgNode* inputDerivedClassPointer )
189860 : {
189861 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
189862 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
189863 : // So to fix this we return NULL directly when the input is NULL and avoid the
189864 : // dynamic_cast in this case. This is likely a performance improvement as well.
189865 : // return dynamic_cast<const SgOmpMasterStatement*>(inputDerivedClassPointer);
189866 : // Milind Chabbi (8/28/2013): isSgOmpMasterStatement uses table-driven castability instead of c++ default dynamic_cast
189867 : // this improves the running time performance by 10-20%.
189868 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpMasterStatement*>(inputDerivedClassPointer);
189869 0 : return IS_SgOmpMasterStatement_FAST_MACRO(inputDerivedClassPointer);
189870 : }
189871 :
189872 :
189873 :
189874 : /* #line 189875 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189875 :
189876 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189877 :
189878 : /**
189879 : \brief Generated destructor
189880 :
189881 : This destructor is automatically generated (by ROSETTA). This destructor
189882 : only frees memory of data members associated with the parts of the current IR node which
189883 : are NOT traversed. Those data members that are part of a traversal can be freed using
189884 : a traversal (calling this destructor on all children in a post-order traversal). Such
189885 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
189886 :
189887 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
189888 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
189889 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
189890 :
189891 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
189892 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
189893 : pointers are not yet implemented to call delete on eash pointer in the container.
189894 : (This could be done by derivation from the STL containers to define containers that
189895 : automatically deleted their members.)
189896 :
189897 : */
189898 0 : SgOmpMasterStatement::~SgOmpMasterStatement () {
189899 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
189900 :
189901 :
189902 :
189903 : }
189904 :
189905 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
189906 0 : }
189907 :
189908 :
189909 : /* #line 189910 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189910 :
189911 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
189912 :
189913 : // Generated constructor
189914 14 : SgOmpMasterStatement::SgOmpMasterStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
189915 14 : : SgUpirBodyStatement(startOfConstruct, body)
189916 : {
189917 : #ifdef DEBUG
189918 : // printf ("In SgOmpMasterStatement::SgOmpMasterStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
189919 : #endif
189920 : #if 0
189921 : // debugging information!
189922 : printf ("In SgOmpMasterStatement::SgOmpMasterStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
189923 : #endif
189924 :
189925 :
189926 :
189927 : #if 0
189928 : // DQ (7/30/2014): Call a virtual function.
189929 : std::string s = this->class_name();
189930 : #endif
189931 :
189932 : // Test the variant virtual function
189933 : // assert(OMP_MASTER_STMT == variant());
189934 14 : assert(OMP_MASTER_STMT == this->variant());
189935 14 : ROSE_ASSERT(OMP_MASTER_STMT == (int)(this->variantT()));
189936 14 : post_construction_initialization();
189937 :
189938 : // Test the isSgOmpMasterStatement() function since it has been problematic
189939 14 : assert(isSgOmpMasterStatement(this) != NULL);
189940 14 : }
189941 :
189942 : // Generated constructor (all data members)
189943 :
189944 : /* #line 189945 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189945 :
189946 :
189947 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189948 :
189949 :
189950 : // ********************************************************
189951 : // member functions common across all array grammar objects
189952 : // ********************************************************
189953 :
189954 :
189955 :
189956 : /* #line 189957 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189957 :
189958 :
189959 :
189960 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
189961 :
189962 : // ********************************************************
189963 : // member functions specific to each node in the grammar
189964 : // ********************************************************
189965 :
189966 :
189967 : /* #line 189968 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
189968 :
189969 : // Start of memberFunctionString
189970 : /* #line 19488 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
189971 :
189972 : void
189973 29 : SgOmpSectionStatement::post_construction_initialization()
189974 29 : {}
189975 :
189976 :
189977 : // End of memberFunctionString
189978 : // Start of memberFunctionString
189979 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
189980 :
189981 : // *** COMMON CODE SECTION BEGINS HERE ***
189982 :
189983 : #if 0
189984 : int
189985 : SgOmpSectionStatement::getVariant() const
189986 : {
189987 : // This function is used in ROSE while "variant()" is used in SAGE
189988 : assert(this != NULL);
189989 : return variant();
189990 : }
189991 : #endif
189992 :
189993 : // This function is used in ROSE in treeTraversal code
189994 : // eventually replaces getVariant() and variant()
189995 : // though after variant() has been removed for a while we will
189996 : // want to change the name of variantT() back to variant()
189997 : // (since the "T" was ment to stand for temporary).
189998 : // When this happens the variantT() will be depricated.
189999 : VariantT
190000 2133 : SgOmpSectionStatement::variantT() const
190001 : {
190002 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
190003 2133 : ROSE_ASSERT(this != NULL);
190004 2133 : return V_SgOmpSectionStatement;
190005 : }
190006 :
190007 : #if 0
190008 : int
190009 : SgOmpSectionStatement::variant() const
190010 : {
190011 : // This function is used in SAGE
190012 : ROSE_ASSERT(this != NULL);
190013 : return OMP_SECTION_STMT;
190014 : }
190015 : #endif
190016 :
190017 : ROSE_DLL_API const char*
190018 0 : SgOmpSectionStatement::sage_class_name() const
190019 : {
190020 0 : ROSE_ASSERT(this != NULL);
190021 0 : return "SgOmpSectionStatement";
190022 : }
190023 :
190024 : std::string
190025 29 : SgOmpSectionStatement::class_name() const
190026 : {
190027 29 : ROSE_ASSERT(this != NULL);
190028 29 : return "SgOmpSectionStatement";
190029 : }
190030 :
190031 : // DQ (11/26/2005): Support for visitor pattern mechanims
190032 : // (inferior to ROSE traversal mechanism, experimental).
190033 : void
190034 0 : SgOmpSectionStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
190035 : {
190036 0 : ROSE_ASSERT(this != NULL);
190037 0 : visitor.visit(this);
190038 0 : }
190039 :
190040 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
190041 0 : void SgOmpSectionStatement::accept (ROSE_VisitorPattern & visitor) {
190042 0 : ROSE_ASSERT(this != NULL);
190043 0 : visitor.visit(this);
190044 0 : }
190045 :
190046 : SgOmpSectionStatement*
190047 0 : SgOmpSectionStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
190048 : {
190049 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
190050 : // This function is currently only supported for the AST used the represent Binary executables.
190051 : if (0 /* isSgAsmNode(this) != NULL */)
190052 : {
190053 : // Support for regex specification.
190054 : std::string prefixCode = "REGEX:";
190055 : addNewAttribute(prefixCode + s,a);
190056 : }
190057 : #endif
190058 :
190059 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
190060 0 : return this;
190061 : }
190062 :
190063 : // *** COMMON CODE SECTION ENDS HERE ***
190064 :
190065 :
190066 : // End of memberFunctionString
190067 : // Start of memberFunctionString
190068 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
190069 :
190070 :
190071 : #if 0
190072 : //! Error checking support
190073 : /*! Verifies the following:
190074 : - working getVariant() member function
190075 : - calls base class's error() member function
190076 : Every class has one of these functions.
190077 : */
190078 : bool
190079 : SgOmpSectionStatement::error()
190080 : {
190081 : // Put error checking here
190082 :
190083 : ROSE_ASSERT (this != NULL);
190084 : if (getVariant() != OMP_SECTION_STMT)
190085 : {
190086 : printf ("Error in SgOmpSectionStatement::error(): SgOmpSectionStatement object has a %s variant \n",
190087 : Cxx_GrammarTerminalNames[getVariant()].name);
190088 : // printf ("Error in SgOmpSectionStatement::error() \n");
190089 : ROSE_ABORT();
190090 : }
190091 :
190092 : ROSE_ASSERT (getVariant() == OMP_SECTION_STMT);
190093 : return SgUpirBodyStatement::error();
190094 : }
190095 : #endif
190096 :
190097 :
190098 :
190099 : // End of memberFunctionString
190100 :
190101 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
190102 :
190103 29 : SgOmpSectionStatement* isSgOmpSectionStatement ( SgNode* inputDerivedClassPointer )
190104 : {
190105 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190106 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190107 : // So to fix this we return NULL directly when the input is NULL and avoid the
190108 : // dynamic_cast in this case. This is likely a performance improvement as well.
190109 : // return dynamic_cast<SgOmpSectionStatement*>(inputDerivedClassPointer);
190110 : // Milind Chabbi (8/28/2013): isSgOmpSectionStatement uses table-driven castability instead of c++ default dynamic_cast
190111 : // this improves the running time performance by 10-20%.
190112 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSectionStatement*>(inputDerivedClassPointer);
190113 29 : return IS_SgOmpSectionStatement_FAST_MACRO(inputDerivedClassPointer);
190114 : }
190115 :
190116 : // DQ (11/8/2003): Added version of functions taking const pointer
190117 0 : const SgOmpSectionStatement* isSgOmpSectionStatement ( const SgNode* inputDerivedClassPointer )
190118 : {
190119 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190120 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190121 : // So to fix this we return NULL directly when the input is NULL and avoid the
190122 : // dynamic_cast in this case. This is likely a performance improvement as well.
190123 : // return dynamic_cast<const SgOmpSectionStatement*>(inputDerivedClassPointer);
190124 : // Milind Chabbi (8/28/2013): isSgOmpSectionStatement uses table-driven castability instead of c++ default dynamic_cast
190125 : // this improves the running time performance by 10-20%.
190126 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSectionStatement*>(inputDerivedClassPointer);
190127 0 : return IS_SgOmpSectionStatement_FAST_MACRO(inputDerivedClassPointer);
190128 : }
190129 :
190130 :
190131 :
190132 : /* #line 190133 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190133 :
190134 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190135 :
190136 : /**
190137 : \brief Generated destructor
190138 :
190139 : This destructor is automatically generated (by ROSETTA). This destructor
190140 : only frees memory of data members associated with the parts of the current IR node which
190141 : are NOT traversed. Those data members that are part of a traversal can be freed using
190142 : a traversal (calling this destructor on all children in a post-order traversal). Such
190143 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
190144 :
190145 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
190146 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
190147 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
190148 :
190149 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
190150 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
190151 : pointers are not yet implemented to call delete on eash pointer in the container.
190152 : (This could be done by derivation from the STL containers to define containers that
190153 : automatically deleted their members.)
190154 :
190155 : */
190156 0 : SgOmpSectionStatement::~SgOmpSectionStatement () {
190157 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
190158 :
190159 :
190160 :
190161 : }
190162 :
190163 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190164 0 : }
190165 :
190166 :
190167 : /* #line 190168 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190168 :
190169 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
190170 :
190171 : // Generated constructor
190172 29 : SgOmpSectionStatement::SgOmpSectionStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
190173 29 : : SgUpirBodyStatement(startOfConstruct, body)
190174 : {
190175 : #ifdef DEBUG
190176 : // printf ("In SgOmpSectionStatement::SgOmpSectionStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
190177 : #endif
190178 : #if 0
190179 : // debugging information!
190180 : printf ("In SgOmpSectionStatement::SgOmpSectionStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
190181 : #endif
190182 :
190183 :
190184 :
190185 : #if 0
190186 : // DQ (7/30/2014): Call a virtual function.
190187 : std::string s = this->class_name();
190188 : #endif
190189 :
190190 : // Test the variant virtual function
190191 : // assert(OMP_SECTION_STMT == variant());
190192 29 : assert(OMP_SECTION_STMT == this->variant());
190193 29 : ROSE_ASSERT(OMP_SECTION_STMT == (int)(this->variantT()));
190194 29 : post_construction_initialization();
190195 :
190196 : // Test the isSgOmpSectionStatement() function since it has been problematic
190197 29 : assert(isSgOmpSectionStatement(this) != NULL);
190198 29 : }
190199 :
190200 : // Generated constructor (all data members)
190201 :
190202 : /* #line 190203 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190203 :
190204 :
190205 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
190206 :
190207 :
190208 : // ********************************************************
190209 : // member functions common across all array grammar objects
190210 : // ********************************************************
190211 :
190212 :
190213 :
190214 : /* #line 190215 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190215 :
190216 :
190217 :
190218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
190219 :
190220 : // ********************************************************
190221 : // member functions specific to each node in the grammar
190222 : // ********************************************************
190223 :
190224 :
190225 : /* #line 190226 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190226 :
190227 : // Start of memberFunctionString
190228 : /* #line 19454 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
190229 :
190230 : void
190231 0 : SgOmpWorkshareStatement::post_construction_initialization()
190232 0 : {}
190233 :
190234 :
190235 : // End of memberFunctionString
190236 : // Start of memberFunctionString
190237 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
190238 :
190239 : // *** COMMON CODE SECTION BEGINS HERE ***
190240 :
190241 : #if 0
190242 : int
190243 : SgOmpWorkshareStatement::getVariant() const
190244 : {
190245 : // This function is used in ROSE while "variant()" is used in SAGE
190246 : assert(this != NULL);
190247 : return variant();
190248 : }
190249 : #endif
190250 :
190251 : // This function is used in ROSE in treeTraversal code
190252 : // eventually replaces getVariant() and variant()
190253 : // though after variant() has been removed for a while we will
190254 : // want to change the name of variantT() back to variant()
190255 : // (since the "T" was ment to stand for temporary).
190256 : // When this happens the variantT() will be depricated.
190257 : VariantT
190258 0 : SgOmpWorkshareStatement::variantT() const
190259 : {
190260 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
190261 0 : ROSE_ASSERT(this != NULL);
190262 0 : return V_SgOmpWorkshareStatement;
190263 : }
190264 :
190265 : #if 0
190266 : int
190267 : SgOmpWorkshareStatement::variant() const
190268 : {
190269 : // This function is used in SAGE
190270 : ROSE_ASSERT(this != NULL);
190271 : return OMP_WORKSHARE_STMT;
190272 : }
190273 : #endif
190274 :
190275 : ROSE_DLL_API const char*
190276 0 : SgOmpWorkshareStatement::sage_class_name() const
190277 : {
190278 0 : ROSE_ASSERT(this != NULL);
190279 0 : return "SgOmpWorkshareStatement";
190280 : }
190281 :
190282 : std::string
190283 0 : SgOmpWorkshareStatement::class_name() const
190284 : {
190285 0 : ROSE_ASSERT(this != NULL);
190286 0 : return "SgOmpWorkshareStatement";
190287 : }
190288 :
190289 : // DQ (11/26/2005): Support for visitor pattern mechanims
190290 : // (inferior to ROSE traversal mechanism, experimental).
190291 : void
190292 0 : SgOmpWorkshareStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
190293 : {
190294 0 : ROSE_ASSERT(this != NULL);
190295 0 : visitor.visit(this);
190296 0 : }
190297 :
190298 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
190299 0 : void SgOmpWorkshareStatement::accept (ROSE_VisitorPattern & visitor) {
190300 0 : ROSE_ASSERT(this != NULL);
190301 0 : visitor.visit(this);
190302 0 : }
190303 :
190304 : SgOmpWorkshareStatement*
190305 0 : SgOmpWorkshareStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
190306 : {
190307 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
190308 : // This function is currently only supported for the AST used the represent Binary executables.
190309 : if (0 /* isSgAsmNode(this) != NULL */)
190310 : {
190311 : // Support for regex specification.
190312 : std::string prefixCode = "REGEX:";
190313 : addNewAttribute(prefixCode + s,a);
190314 : }
190315 : #endif
190316 :
190317 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
190318 0 : return this;
190319 : }
190320 :
190321 : // *** COMMON CODE SECTION ENDS HERE ***
190322 :
190323 :
190324 : // End of memberFunctionString
190325 : // Start of memberFunctionString
190326 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
190327 :
190328 :
190329 : #if 0
190330 : //! Error checking support
190331 : /*! Verifies the following:
190332 : - working getVariant() member function
190333 : - calls base class's error() member function
190334 : Every class has one of these functions.
190335 : */
190336 : bool
190337 : SgOmpWorkshareStatement::error()
190338 : {
190339 : // Put error checking here
190340 :
190341 : ROSE_ASSERT (this != NULL);
190342 : if (getVariant() != OMP_WORKSHARE_STMT)
190343 : {
190344 : printf ("Error in SgOmpWorkshareStatement::error(): SgOmpWorkshareStatement object has a %s variant \n",
190345 : Cxx_GrammarTerminalNames[getVariant()].name);
190346 : // printf ("Error in SgOmpWorkshareStatement::error() \n");
190347 : ROSE_ABORT();
190348 : }
190349 :
190350 : ROSE_ASSERT (getVariant() == OMP_WORKSHARE_STMT);
190351 : return SgUpirBodyStatement::error();
190352 : }
190353 : #endif
190354 :
190355 :
190356 :
190357 : // End of memberFunctionString
190358 :
190359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
190360 :
190361 0 : SgOmpWorkshareStatement* isSgOmpWorkshareStatement ( SgNode* inputDerivedClassPointer )
190362 : {
190363 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190364 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190365 : // So to fix this we return NULL directly when the input is NULL and avoid the
190366 : // dynamic_cast in this case. This is likely a performance improvement as well.
190367 : // return dynamic_cast<SgOmpWorkshareStatement*>(inputDerivedClassPointer);
190368 : // Milind Chabbi (8/28/2013): isSgOmpWorkshareStatement uses table-driven castability instead of c++ default dynamic_cast
190369 : // this improves the running time performance by 10-20%.
190370 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpWorkshareStatement*>(inputDerivedClassPointer);
190371 0 : return IS_SgOmpWorkshareStatement_FAST_MACRO(inputDerivedClassPointer);
190372 : }
190373 :
190374 : // DQ (11/8/2003): Added version of functions taking const pointer
190375 0 : const SgOmpWorkshareStatement* isSgOmpWorkshareStatement ( const SgNode* inputDerivedClassPointer )
190376 : {
190377 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190378 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190379 : // So to fix this we return NULL directly when the input is NULL and avoid the
190380 : // dynamic_cast in this case. This is likely a performance improvement as well.
190381 : // return dynamic_cast<const SgOmpWorkshareStatement*>(inputDerivedClassPointer);
190382 : // Milind Chabbi (8/28/2013): isSgOmpWorkshareStatement uses table-driven castability instead of c++ default dynamic_cast
190383 : // this improves the running time performance by 10-20%.
190384 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpWorkshareStatement*>(inputDerivedClassPointer);
190385 0 : return IS_SgOmpWorkshareStatement_FAST_MACRO(inputDerivedClassPointer);
190386 : }
190387 :
190388 :
190389 :
190390 : /* #line 190391 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190391 :
190392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190393 :
190394 : /**
190395 : \brief Generated destructor
190396 :
190397 : This destructor is automatically generated (by ROSETTA). This destructor
190398 : only frees memory of data members associated with the parts of the current IR node which
190399 : are NOT traversed. Those data members that are part of a traversal can be freed using
190400 : a traversal (calling this destructor on all children in a post-order traversal). Such
190401 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
190402 :
190403 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
190404 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
190405 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
190406 :
190407 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
190408 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
190409 : pointers are not yet implemented to call delete on eash pointer in the container.
190410 : (This could be done by derivation from the STL containers to define containers that
190411 : automatically deleted their members.)
190412 :
190413 : */
190414 0 : SgOmpWorkshareStatement::~SgOmpWorkshareStatement () {
190415 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
190416 :
190417 :
190418 :
190419 : }
190420 :
190421 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190422 0 : }
190423 :
190424 :
190425 : /* #line 190426 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190426 :
190427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
190428 :
190429 : // Generated constructor
190430 0 : SgOmpWorkshareStatement::SgOmpWorkshareStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
190431 0 : : SgUpirBodyStatement(startOfConstruct, body)
190432 : {
190433 : #ifdef DEBUG
190434 : // printf ("In SgOmpWorkshareStatement::SgOmpWorkshareStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
190435 : #endif
190436 : #if 0
190437 : // debugging information!
190438 : printf ("In SgOmpWorkshareStatement::SgOmpWorkshareStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
190439 : #endif
190440 :
190441 :
190442 :
190443 : #if 0
190444 : // DQ (7/30/2014): Call a virtual function.
190445 : std::string s = this->class_name();
190446 : #endif
190447 :
190448 : // Test the variant virtual function
190449 : // assert(OMP_WORKSHARE_STMT == variant());
190450 0 : assert(OMP_WORKSHARE_STMT == this->variant());
190451 0 : ROSE_ASSERT(OMP_WORKSHARE_STMT == (int)(this->variantT()));
190452 0 : post_construction_initialization();
190453 :
190454 : // Test the isSgOmpWorkshareStatement() function since it has been problematic
190455 0 : assert(isSgOmpWorkshareStatement(this) != NULL);
190456 0 : }
190457 :
190458 : // Generated constructor (all data members)
190459 :
190460 : /* #line 190461 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190461 :
190462 :
190463 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
190464 :
190465 :
190466 : // ********************************************************
190467 : // member functions common across all array grammar objects
190468 : // ********************************************************
190469 :
190470 :
190471 :
190472 : /* #line 190473 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190473 :
190474 :
190475 :
190476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
190477 :
190478 : // ********************************************************
190479 : // member functions specific to each node in the grammar
190480 : // ********************************************************
190481 :
190482 :
190483 : /* #line 190484 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190484 :
190485 : // Start of memberFunctionString
190486 : /* #line 19547 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
190487 :
190488 : void
190489 885 : SgUpirFieldBodyStatement::post_construction_initialization()
190490 885 : {}
190491 :
190492 :
190493 : // End of memberFunctionString
190494 : // Start of memberFunctionString
190495 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
190496 :
190497 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
190498 :
190499 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
190500 : const SgOmpClausePtrList &
190501 0 : SgUpirFieldBodyStatement::get_clauses () const
190502 : {
190503 0 : assert (this != NULL);
190504 0 : return p_clauses;
190505 : }
190506 :
190507 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
190508 : SgOmpClausePtrList &
190509 1156 : SgUpirFieldBodyStatement::get_clauses ()
190510 : {
190511 1156 : assert (this != NULL);
190512 :
190513 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
190514 : // As a rule only set_ access functions can set the isModified flag.
190515 : // set_isModified(true);
190516 :
190517 1156 : return p_clauses;
190518 : }
190519 :
190520 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
190521 :
190522 :
190523 : // End of memberFunctionString
190524 : // Start of memberFunctionString
190525 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
190526 :
190527 : // *** COMMON CODE SECTION BEGINS HERE ***
190528 :
190529 : #if 0
190530 : int
190531 : SgUpirFieldBodyStatement::getVariant() const
190532 : {
190533 : // This function is used in ROSE while "variant()" is used in SAGE
190534 : assert(this != NULL);
190535 : return variant();
190536 : }
190537 : #endif
190538 :
190539 : // This function is used in ROSE in treeTraversal code
190540 : // eventually replaces getVariant() and variant()
190541 : // though after variant() has been removed for a while we will
190542 : // want to change the name of variantT() back to variant()
190543 : // (since the "T" was ment to stand for temporary).
190544 : // When this happens the variantT() will be depricated.
190545 : VariantT
190546 2655 : SgUpirFieldBodyStatement::variantT() const
190547 : {
190548 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
190549 2655 : ROSE_ASSERT(this != NULL);
190550 2655 : return V_SgUpirFieldBodyStatement;
190551 : }
190552 :
190553 : #if 0
190554 : int
190555 : SgUpirFieldBodyStatement::variant() const
190556 : {
190557 : // This function is used in SAGE
190558 : ROSE_ASSERT(this != NULL);
190559 : return UPIR_FIELDBODY_STMT;
190560 : }
190561 : #endif
190562 :
190563 : ROSE_DLL_API const char*
190564 0 : SgUpirFieldBodyStatement::sage_class_name() const
190565 : {
190566 0 : ROSE_ASSERT(this != NULL);
190567 0 : return "SgUpirFieldBodyStatement";
190568 : }
190569 :
190570 : std::string
190571 0 : SgUpirFieldBodyStatement::class_name() const
190572 : {
190573 0 : ROSE_ASSERT(this != NULL);
190574 0 : return "SgUpirFieldBodyStatement";
190575 : }
190576 :
190577 : // DQ (11/26/2005): Support for visitor pattern mechanims
190578 : // (inferior to ROSE traversal mechanism, experimental).
190579 : void
190580 0 : SgUpirFieldBodyStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
190581 : {
190582 0 : ROSE_ASSERT(this != NULL);
190583 0 : visitor.visit(this);
190584 0 : }
190585 :
190586 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
190587 0 : void SgUpirFieldBodyStatement::accept (ROSE_VisitorPattern & visitor) {
190588 0 : ROSE_ASSERT(this != NULL);
190589 0 : visitor.visit(this);
190590 0 : }
190591 :
190592 : SgUpirFieldBodyStatement*
190593 0 : SgUpirFieldBodyStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
190594 : {
190595 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
190596 : // This function is currently only supported for the AST used the represent Binary executables.
190597 : if (0 /* isSgAsmNode(this) != NULL */)
190598 : {
190599 : // Support for regex specification.
190600 : std::string prefixCode = "REGEX:";
190601 : addNewAttribute(prefixCode + s,a);
190602 : }
190603 : #endif
190604 :
190605 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
190606 0 : return this;
190607 : }
190608 :
190609 : // *** COMMON CODE SECTION ENDS HERE ***
190610 :
190611 :
190612 : // End of memberFunctionString
190613 : // Start of memberFunctionString
190614 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
190615 :
190616 :
190617 : #if 0
190618 : //! Error checking support
190619 : /*! Verifies the following:
190620 : - working getVariant() member function
190621 : - calls base class's error() member function
190622 : Every class has one of these functions.
190623 : */
190624 : bool
190625 : SgUpirFieldBodyStatement::error()
190626 : {
190627 : // Put error checking here
190628 :
190629 : ROSE_ASSERT (this != NULL);
190630 : if (getVariant() != UPIR_FIELDBODY_STMT)
190631 : {
190632 : printf ("Error in SgUpirFieldBodyStatement::error(): SgUpirFieldBodyStatement object has a %s variant \n",
190633 : Cxx_GrammarTerminalNames[getVariant()].name);
190634 : // printf ("Error in SgUpirFieldBodyStatement::error() \n");
190635 : ROSE_ABORT();
190636 : }
190637 :
190638 : ROSE_ASSERT (getVariant() == UPIR_FIELDBODY_STMT);
190639 : return SgUpirBodyStatement::error();
190640 : }
190641 : #endif
190642 :
190643 :
190644 :
190645 : // End of memberFunctionString
190646 :
190647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
190648 :
190649 2451 : SgUpirFieldBodyStatement* isSgUpirFieldBodyStatement ( SgNode* inputDerivedClassPointer )
190650 : {
190651 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190652 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190653 : // So to fix this we return NULL directly when the input is NULL and avoid the
190654 : // dynamic_cast in this case. This is likely a performance improvement as well.
190655 : // return dynamic_cast<SgUpirFieldBodyStatement*>(inputDerivedClassPointer);
190656 : // Milind Chabbi (8/28/2013): isSgUpirFieldBodyStatement uses table-driven castability instead of c++ default dynamic_cast
190657 : // this improves the running time performance by 10-20%.
190658 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirFieldBodyStatement*>(inputDerivedClassPointer);
190659 2451 : return IS_SgUpirFieldBodyStatement_FAST_MACRO(inputDerivedClassPointer);
190660 : }
190661 :
190662 : // DQ (11/8/2003): Added version of functions taking const pointer
190663 0 : const SgUpirFieldBodyStatement* isSgUpirFieldBodyStatement ( const SgNode* inputDerivedClassPointer )
190664 : {
190665 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190666 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190667 : // So to fix this we return NULL directly when the input is NULL and avoid the
190668 : // dynamic_cast in this case. This is likely a performance improvement as well.
190669 : // return dynamic_cast<const SgUpirFieldBodyStatement*>(inputDerivedClassPointer);
190670 : // Milind Chabbi (8/28/2013): isSgUpirFieldBodyStatement uses table-driven castability instead of c++ default dynamic_cast
190671 : // this improves the running time performance by 10-20%.
190672 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirFieldBodyStatement*>(inputDerivedClassPointer);
190673 0 : return IS_SgUpirFieldBodyStatement_FAST_MACRO(inputDerivedClassPointer);
190674 : }
190675 :
190676 :
190677 :
190678 : /* #line 190679 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190679 :
190680 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190681 :
190682 : /**
190683 : \brief Generated destructor
190684 :
190685 : This destructor is automatically generated (by ROSETTA). This destructor
190686 : only frees memory of data members associated with the parts of the current IR node which
190687 : are NOT traversed. Those data members that are part of a traversal can be freed using
190688 : a traversal (calling this destructor on all children in a post-order traversal). Such
190689 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
190690 :
190691 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
190692 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
190693 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
190694 :
190695 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
190696 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
190697 : pointers are not yet implemented to call delete on eash pointer in the container.
190698 : (This could be done by derivation from the STL containers to define containers that
190699 : automatically deleted their members.)
190700 :
190701 : */
190702 0 : SgUpirFieldBodyStatement::~SgUpirFieldBodyStatement () {
190703 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
190704 :
190705 :
190706 :
190707 : }
190708 :
190709 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190710 0 : }
190711 :
190712 :
190713 : /* #line 190714 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190714 :
190715 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
190716 :
190717 : // Generated constructor
190718 885 : SgUpirFieldBodyStatement::SgUpirFieldBodyStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
190719 885 : : SgUpirBodyStatement(startOfConstruct, body)
190720 : {
190721 : #ifdef DEBUG
190722 : // printf ("In SgUpirFieldBodyStatement::SgUpirFieldBodyStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
190723 : #endif
190724 : #if 0
190725 : // debugging information!
190726 : printf ("In SgUpirFieldBodyStatement::SgUpirFieldBodyStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
190727 : #endif
190728 :
190729 :
190730 :
190731 : #if 0
190732 : // DQ (7/30/2014): Call a virtual function.
190733 : std::string s = this->class_name();
190734 : #endif
190735 :
190736 : // Test the variant virtual function
190737 : // assert(UPIR_FIELDBODY_STMT == variant());
190738 885 : assert(UPIR_FIELDBODY_STMT == this->variant());
190739 885 : ROSE_ASSERT(UPIR_FIELDBODY_STMT == (int)(this->variantT()));
190740 885 : post_construction_initialization();
190741 :
190742 : // Test the isSgUpirFieldBodyStatement() function since it has been problematic
190743 885 : assert(isSgUpirFieldBodyStatement(this) != NULL);
190744 885 : }
190745 :
190746 : // Generated constructor (all data members)
190747 :
190748 : /* #line 190749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190749 :
190750 :
190751 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
190752 :
190753 :
190754 : // ********************************************************
190755 : // member functions common across all array grammar objects
190756 : // ********************************************************
190757 :
190758 :
190759 :
190760 : /* #line 190761 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190761 :
190762 :
190763 :
190764 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
190765 :
190766 : // ********************************************************
190767 : // member functions specific to each node in the grammar
190768 : // ********************************************************
190769 :
190770 :
190771 : /* #line 190772 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190772 :
190773 : // Start of memberFunctionString
190774 : /* #line 18973 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
190775 :
190776 : void
190777 354 : SgUpirSpmdStatement::post_construction_initialization()
190778 354 : {}
190779 :
190780 :
190781 : // End of memberFunctionString
190782 : // Start of memberFunctionString
190783 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
190784 :
190785 : // *** COMMON CODE SECTION BEGINS HERE ***
190786 :
190787 : #if 0
190788 : int
190789 : SgUpirSpmdStatement::getVariant() const
190790 : {
190791 : // This function is used in ROSE while "variant()" is used in SAGE
190792 : assert(this != NULL);
190793 : return variant();
190794 : }
190795 : #endif
190796 :
190797 : // This function is used in ROSE in treeTraversal code
190798 : // eventually replaces getVariant() and variant()
190799 : // though after variant() has been removed for a while we will
190800 : // want to change the name of variantT() back to variant()
190801 : // (since the "T" was ment to stand for temporary).
190802 : // When this happens the variantT() will be depricated.
190803 : VariantT
190804 35131 : SgUpirSpmdStatement::variantT() const
190805 : {
190806 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
190807 35131 : ROSE_ASSERT(this != NULL);
190808 35131 : return V_SgUpirSpmdStatement;
190809 : }
190810 :
190811 : #if 0
190812 : int
190813 : SgUpirSpmdStatement::variant() const
190814 : {
190815 : // This function is used in SAGE
190816 : ROSE_ASSERT(this != NULL);
190817 : return UPIR_SPMD_STMT;
190818 : }
190819 : #endif
190820 :
190821 : ROSE_DLL_API const char*
190822 0 : SgUpirSpmdStatement::sage_class_name() const
190823 : {
190824 0 : ROSE_ASSERT(this != NULL);
190825 0 : return "SgUpirSpmdStatement";
190826 : }
190827 :
190828 : std::string
190829 354 : SgUpirSpmdStatement::class_name() const
190830 : {
190831 354 : ROSE_ASSERT(this != NULL);
190832 354 : return "SgUpirSpmdStatement";
190833 : }
190834 :
190835 : // DQ (11/26/2005): Support for visitor pattern mechanims
190836 : // (inferior to ROSE traversal mechanism, experimental).
190837 : void
190838 0 : SgUpirSpmdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
190839 : {
190840 0 : ROSE_ASSERT(this != NULL);
190841 0 : visitor.visit(this);
190842 0 : }
190843 :
190844 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
190845 0 : void SgUpirSpmdStatement::accept (ROSE_VisitorPattern & visitor) {
190846 0 : ROSE_ASSERT(this != NULL);
190847 0 : visitor.visit(this);
190848 0 : }
190849 :
190850 : SgUpirSpmdStatement*
190851 0 : SgUpirSpmdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
190852 : {
190853 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
190854 : // This function is currently only supported for the AST used the represent Binary executables.
190855 : if (0 /* isSgAsmNode(this) != NULL */)
190856 : {
190857 : // Support for regex specification.
190858 : std::string prefixCode = "REGEX:";
190859 : addNewAttribute(prefixCode + s,a);
190860 : }
190861 : #endif
190862 :
190863 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
190864 0 : return this;
190865 : }
190866 :
190867 : // *** COMMON CODE SECTION ENDS HERE ***
190868 :
190869 :
190870 : // End of memberFunctionString
190871 : // Start of memberFunctionString
190872 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
190873 :
190874 :
190875 : #if 0
190876 : //! Error checking support
190877 : /*! Verifies the following:
190878 : - working getVariant() member function
190879 : - calls base class's error() member function
190880 : Every class has one of these functions.
190881 : */
190882 : bool
190883 : SgUpirSpmdStatement::error()
190884 : {
190885 : // Put error checking here
190886 :
190887 : ROSE_ASSERT (this != NULL);
190888 : if (getVariant() != UPIR_SPMD_STMT)
190889 : {
190890 : printf ("Error in SgUpirSpmdStatement::error(): SgUpirSpmdStatement object has a %s variant \n",
190891 : Cxx_GrammarTerminalNames[getVariant()].name);
190892 : // printf ("Error in SgUpirSpmdStatement::error() \n");
190893 : ROSE_ABORT();
190894 : }
190895 :
190896 : ROSE_ASSERT (getVariant() == UPIR_SPMD_STMT);
190897 : return SgUpirFieldBodyStatement::error();
190898 : }
190899 : #endif
190900 :
190901 :
190902 :
190903 : // End of memberFunctionString
190904 :
190905 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
190906 :
190907 354 : SgUpirSpmdStatement* isSgUpirSpmdStatement ( SgNode* inputDerivedClassPointer )
190908 : {
190909 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190910 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190911 : // So to fix this we return NULL directly when the input is NULL and avoid the
190912 : // dynamic_cast in this case. This is likely a performance improvement as well.
190913 : // return dynamic_cast<SgUpirSpmdStatement*>(inputDerivedClassPointer);
190914 : // Milind Chabbi (8/28/2013): isSgUpirSpmdStatement uses table-driven castability instead of c++ default dynamic_cast
190915 : // this improves the running time performance by 10-20%.
190916 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirSpmdStatement*>(inputDerivedClassPointer);
190917 354 : return IS_SgUpirSpmdStatement_FAST_MACRO(inputDerivedClassPointer);
190918 : }
190919 :
190920 : // DQ (11/8/2003): Added version of functions taking const pointer
190921 0 : const SgUpirSpmdStatement* isSgUpirSpmdStatement ( const SgNode* inputDerivedClassPointer )
190922 : {
190923 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
190924 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
190925 : // So to fix this we return NULL directly when the input is NULL and avoid the
190926 : // dynamic_cast in this case. This is likely a performance improvement as well.
190927 : // return dynamic_cast<const SgUpirSpmdStatement*>(inputDerivedClassPointer);
190928 : // Milind Chabbi (8/28/2013): isSgUpirSpmdStatement uses table-driven castability instead of c++ default dynamic_cast
190929 : // this improves the running time performance by 10-20%.
190930 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirSpmdStatement*>(inputDerivedClassPointer);
190931 0 : return IS_SgUpirSpmdStatement_FAST_MACRO(inputDerivedClassPointer);
190932 : }
190933 :
190934 :
190935 :
190936 : /* #line 190937 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190937 :
190938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190939 :
190940 : /**
190941 : \brief Generated destructor
190942 :
190943 : This destructor is automatically generated (by ROSETTA). This destructor
190944 : only frees memory of data members associated with the parts of the current IR node which
190945 : are NOT traversed. Those data members that are part of a traversal can be freed using
190946 : a traversal (calling this destructor on all children in a post-order traversal). Such
190947 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
190948 :
190949 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
190950 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
190951 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
190952 :
190953 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
190954 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
190955 : pointers are not yet implemented to call delete on eash pointer in the container.
190956 : (This could be done by derivation from the STL containers to define containers that
190957 : automatically deleted their members.)
190958 :
190959 : */
190960 0 : SgUpirSpmdStatement::~SgUpirSpmdStatement () {
190961 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
190962 :
190963 :
190964 :
190965 : }
190966 :
190967 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
190968 0 : }
190969 :
190970 :
190971 : /* #line 190972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
190972 :
190973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
190974 :
190975 : // Generated constructor
190976 354 : SgUpirSpmdStatement::SgUpirSpmdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
190977 354 : : SgUpirFieldBodyStatement(startOfConstruct, body)
190978 : {
190979 : #ifdef DEBUG
190980 : // printf ("In SgUpirSpmdStatement::SgUpirSpmdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
190981 : #endif
190982 : #if 0
190983 : // debugging information!
190984 : printf ("In SgUpirSpmdStatement::SgUpirSpmdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
190985 : #endif
190986 :
190987 :
190988 :
190989 : #if 0
190990 : // DQ (7/30/2014): Call a virtual function.
190991 : std::string s = this->class_name();
190992 : #endif
190993 :
190994 : // Test the variant virtual function
190995 : // assert(UPIR_SPMD_STMT == variant());
190996 354 : assert(UPIR_SPMD_STMT == this->variant());
190997 354 : ROSE_ASSERT(UPIR_SPMD_STMT == (int)(this->variantT()));
190998 354 : post_construction_initialization();
190999 :
191000 : // Test the isSgUpirSpmdStatement() function since it has been problematic
191001 354 : assert(isSgUpirSpmdStatement(this) != NULL);
191002 354 : }
191003 :
191004 : // Generated constructor (all data members)
191005 :
191006 : /* #line 191007 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191007 :
191008 :
191009 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191010 :
191011 :
191012 : // ********************************************************
191013 : // member functions common across all array grammar objects
191014 : // ********************************************************
191015 :
191016 :
191017 :
191018 : /* #line 191019 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191019 :
191020 :
191021 :
191022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191023 :
191024 : // ********************************************************
191025 : // member functions specific to each node in the grammar
191026 : // ********************************************************
191027 :
191028 :
191029 : /* #line 191030 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191030 :
191031 : // Start of memberFunctionString
191032 : /* #line 18979 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
191033 :
191034 : void
191035 3 : SgOmpTeamsStatement::post_construction_initialization()
191036 3 : {}
191037 :
191038 :
191039 : // End of memberFunctionString
191040 : // Start of memberFunctionString
191041 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
191042 :
191043 : // *** COMMON CODE SECTION BEGINS HERE ***
191044 :
191045 : #if 0
191046 : int
191047 : SgOmpTeamsStatement::getVariant() const
191048 : {
191049 : // This function is used in ROSE while "variant()" is used in SAGE
191050 : assert(this != NULL);
191051 : return variant();
191052 : }
191053 : #endif
191054 :
191055 : // This function is used in ROSE in treeTraversal code
191056 : // eventually replaces getVariant() and variant()
191057 : // though after variant() has been removed for a while we will
191058 : // want to change the name of variantT() back to variant()
191059 : // (since the "T" was ment to stand for temporary).
191060 : // When this happens the variantT() will be depricated.
191061 : VariantT
191062 249 : SgOmpTeamsStatement::variantT() const
191063 : {
191064 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
191065 249 : ROSE_ASSERT(this != NULL);
191066 249 : return V_SgOmpTeamsStatement;
191067 : }
191068 :
191069 : #if 0
191070 : int
191071 : SgOmpTeamsStatement::variant() const
191072 : {
191073 : // This function is used in SAGE
191074 : ROSE_ASSERT(this != NULL);
191075 : return OMP_TEAMS_STMT;
191076 : }
191077 : #endif
191078 :
191079 : ROSE_DLL_API const char*
191080 0 : SgOmpTeamsStatement::sage_class_name() const
191081 : {
191082 0 : ROSE_ASSERT(this != NULL);
191083 0 : return "SgOmpTeamsStatement";
191084 : }
191085 :
191086 : std::string
191087 3 : SgOmpTeamsStatement::class_name() const
191088 : {
191089 3 : ROSE_ASSERT(this != NULL);
191090 3 : return "SgOmpTeamsStatement";
191091 : }
191092 :
191093 : // DQ (11/26/2005): Support for visitor pattern mechanims
191094 : // (inferior to ROSE traversal mechanism, experimental).
191095 : void
191096 0 : SgOmpTeamsStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
191097 : {
191098 0 : ROSE_ASSERT(this != NULL);
191099 0 : visitor.visit(this);
191100 0 : }
191101 :
191102 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
191103 0 : void SgOmpTeamsStatement::accept (ROSE_VisitorPattern & visitor) {
191104 0 : ROSE_ASSERT(this != NULL);
191105 0 : visitor.visit(this);
191106 0 : }
191107 :
191108 : SgOmpTeamsStatement*
191109 0 : SgOmpTeamsStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
191110 : {
191111 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
191112 : // This function is currently only supported for the AST used the represent Binary executables.
191113 : if (0 /* isSgAsmNode(this) != NULL */)
191114 : {
191115 : // Support for regex specification.
191116 : std::string prefixCode = "REGEX:";
191117 : addNewAttribute(prefixCode + s,a);
191118 : }
191119 : #endif
191120 :
191121 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
191122 0 : return this;
191123 : }
191124 :
191125 : // *** COMMON CODE SECTION ENDS HERE ***
191126 :
191127 :
191128 : // End of memberFunctionString
191129 : // Start of memberFunctionString
191130 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
191131 :
191132 :
191133 : #if 0
191134 : //! Error checking support
191135 : /*! Verifies the following:
191136 : - working getVariant() member function
191137 : - calls base class's error() member function
191138 : Every class has one of these functions.
191139 : */
191140 : bool
191141 : SgOmpTeamsStatement::error()
191142 : {
191143 : // Put error checking here
191144 :
191145 : ROSE_ASSERT (this != NULL);
191146 : if (getVariant() != OMP_TEAMS_STMT)
191147 : {
191148 : printf ("Error in SgOmpTeamsStatement::error(): SgOmpTeamsStatement object has a %s variant \n",
191149 : Cxx_GrammarTerminalNames[getVariant()].name);
191150 : // printf ("Error in SgOmpTeamsStatement::error() \n");
191151 : ROSE_ABORT();
191152 : }
191153 :
191154 : ROSE_ASSERT (getVariant() == OMP_TEAMS_STMT);
191155 : return SgUpirFieldBodyStatement::error();
191156 : }
191157 : #endif
191158 :
191159 :
191160 :
191161 : // End of memberFunctionString
191162 :
191163 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
191164 :
191165 3 : SgOmpTeamsStatement* isSgOmpTeamsStatement ( SgNode* inputDerivedClassPointer )
191166 : {
191167 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191168 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191169 : // So to fix this we return NULL directly when the input is NULL and avoid the
191170 : // dynamic_cast in this case. This is likely a performance improvement as well.
191171 : // return dynamic_cast<SgOmpTeamsStatement*>(inputDerivedClassPointer);
191172 : // Milind Chabbi (8/28/2013): isSgOmpTeamsStatement uses table-driven castability instead of c++ default dynamic_cast
191173 : // this improves the running time performance by 10-20%.
191174 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTeamsStatement*>(inputDerivedClassPointer);
191175 3 : return IS_SgOmpTeamsStatement_FAST_MACRO(inputDerivedClassPointer);
191176 : }
191177 :
191178 : // DQ (11/8/2003): Added version of functions taking const pointer
191179 0 : const SgOmpTeamsStatement* isSgOmpTeamsStatement ( const SgNode* inputDerivedClassPointer )
191180 : {
191181 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191182 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191183 : // So to fix this we return NULL directly when the input is NULL and avoid the
191184 : // dynamic_cast in this case. This is likely a performance improvement as well.
191185 : // return dynamic_cast<const SgOmpTeamsStatement*>(inputDerivedClassPointer);
191186 : // Milind Chabbi (8/28/2013): isSgOmpTeamsStatement uses table-driven castability instead of c++ default dynamic_cast
191187 : // this improves the running time performance by 10-20%.
191188 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTeamsStatement*>(inputDerivedClassPointer);
191189 0 : return IS_SgOmpTeamsStatement_FAST_MACRO(inputDerivedClassPointer);
191190 : }
191191 :
191192 :
191193 :
191194 : /* #line 191195 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191195 :
191196 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191197 :
191198 : /**
191199 : \brief Generated destructor
191200 :
191201 : This destructor is automatically generated (by ROSETTA). This destructor
191202 : only frees memory of data members associated with the parts of the current IR node which
191203 : are NOT traversed. Those data members that are part of a traversal can be freed using
191204 : a traversal (calling this destructor on all children in a post-order traversal). Such
191205 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
191206 :
191207 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
191208 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
191209 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
191210 :
191211 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
191212 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
191213 : pointers are not yet implemented to call delete on eash pointer in the container.
191214 : (This could be done by derivation from the STL containers to define containers that
191215 : automatically deleted their members.)
191216 :
191217 : */
191218 0 : SgOmpTeamsStatement::~SgOmpTeamsStatement () {
191219 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
191220 :
191221 :
191222 :
191223 : }
191224 :
191225 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191226 0 : }
191227 :
191228 :
191229 : /* #line 191230 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191230 :
191231 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
191232 :
191233 : // Generated constructor
191234 3 : SgOmpTeamsStatement::SgOmpTeamsStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
191235 3 : : SgUpirFieldBodyStatement(startOfConstruct, body)
191236 : {
191237 : #ifdef DEBUG
191238 : // printf ("In SgOmpTeamsStatement::SgOmpTeamsStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
191239 : #endif
191240 : #if 0
191241 : // debugging information!
191242 : printf ("In SgOmpTeamsStatement::SgOmpTeamsStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
191243 : #endif
191244 :
191245 :
191246 :
191247 : #if 0
191248 : // DQ (7/30/2014): Call a virtual function.
191249 : std::string s = this->class_name();
191250 : #endif
191251 :
191252 : // Test the variant virtual function
191253 : // assert(OMP_TEAMS_STMT == variant());
191254 3 : assert(OMP_TEAMS_STMT == this->variant());
191255 3 : ROSE_ASSERT(OMP_TEAMS_STMT == (int)(this->variantT()));
191256 3 : post_construction_initialization();
191257 :
191258 : // Test the isSgOmpTeamsStatement() function since it has been problematic
191259 3 : assert(isSgOmpTeamsStatement(this) != NULL);
191260 3 : }
191261 :
191262 : // Generated constructor (all data members)
191263 :
191264 : /* #line 191265 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191265 :
191266 :
191267 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191268 :
191269 :
191270 : // ********************************************************
191271 : // member functions common across all array grammar objects
191272 : // ********************************************************
191273 :
191274 :
191275 :
191276 : /* #line 191277 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191277 :
191278 :
191279 :
191280 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191281 :
191282 : // ********************************************************
191283 : // member functions specific to each node in the grammar
191284 : // ********************************************************
191285 :
191286 :
191287 : /* #line 191288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191288 :
191289 : // Start of memberFunctionString
191290 : /* #line 19156 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
191291 :
191292 : void
191293 84 : SgOmpSingleStatement::post_construction_initialization()
191294 84 : {}
191295 :
191296 :
191297 : // End of memberFunctionString
191298 : // Start of memberFunctionString
191299 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
191300 :
191301 : // *** COMMON CODE SECTION BEGINS HERE ***
191302 :
191303 : #if 0
191304 : int
191305 : SgOmpSingleStatement::getVariant() const
191306 : {
191307 : // This function is used in ROSE while "variant()" is used in SAGE
191308 : assert(this != NULL);
191309 : return variant();
191310 : }
191311 : #endif
191312 :
191313 : // This function is used in ROSE in treeTraversal code
191314 : // eventually replaces getVariant() and variant()
191315 : // though after variant() has been removed for a while we will
191316 : // want to change the name of variantT() back to variant()
191317 : // (since the "T" was ment to stand for temporary).
191318 : // When this happens the variantT() will be depricated.
191319 : VariantT
191320 7545 : SgOmpSingleStatement::variantT() const
191321 : {
191322 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
191323 7545 : ROSE_ASSERT(this != NULL);
191324 7545 : return V_SgOmpSingleStatement;
191325 : }
191326 :
191327 : #if 0
191328 : int
191329 : SgOmpSingleStatement::variant() const
191330 : {
191331 : // This function is used in SAGE
191332 : ROSE_ASSERT(this != NULL);
191333 : return OMP_SINGLE_STMT;
191334 : }
191335 : #endif
191336 :
191337 : ROSE_DLL_API const char*
191338 0 : SgOmpSingleStatement::sage_class_name() const
191339 : {
191340 0 : ROSE_ASSERT(this != NULL);
191341 0 : return "SgOmpSingleStatement";
191342 : }
191343 :
191344 : std::string
191345 84 : SgOmpSingleStatement::class_name() const
191346 : {
191347 84 : ROSE_ASSERT(this != NULL);
191348 84 : return "SgOmpSingleStatement";
191349 : }
191350 :
191351 : // DQ (11/26/2005): Support for visitor pattern mechanims
191352 : // (inferior to ROSE traversal mechanism, experimental).
191353 : void
191354 0 : SgOmpSingleStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
191355 : {
191356 0 : ROSE_ASSERT(this != NULL);
191357 0 : visitor.visit(this);
191358 0 : }
191359 :
191360 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
191361 0 : void SgOmpSingleStatement::accept (ROSE_VisitorPattern & visitor) {
191362 0 : ROSE_ASSERT(this != NULL);
191363 0 : visitor.visit(this);
191364 0 : }
191365 :
191366 : SgOmpSingleStatement*
191367 0 : SgOmpSingleStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
191368 : {
191369 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
191370 : // This function is currently only supported for the AST used the represent Binary executables.
191371 : if (0 /* isSgAsmNode(this) != NULL */)
191372 : {
191373 : // Support for regex specification.
191374 : std::string prefixCode = "REGEX:";
191375 : addNewAttribute(prefixCode + s,a);
191376 : }
191377 : #endif
191378 :
191379 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
191380 0 : return this;
191381 : }
191382 :
191383 : // *** COMMON CODE SECTION ENDS HERE ***
191384 :
191385 :
191386 : // End of memberFunctionString
191387 : // Start of memberFunctionString
191388 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
191389 :
191390 :
191391 : #if 0
191392 : //! Error checking support
191393 : /*! Verifies the following:
191394 : - working getVariant() member function
191395 : - calls base class's error() member function
191396 : Every class has one of these functions.
191397 : */
191398 : bool
191399 : SgOmpSingleStatement::error()
191400 : {
191401 : // Put error checking here
191402 :
191403 : ROSE_ASSERT (this != NULL);
191404 : if (getVariant() != OMP_SINGLE_STMT)
191405 : {
191406 : printf ("Error in SgOmpSingleStatement::error(): SgOmpSingleStatement object has a %s variant \n",
191407 : Cxx_GrammarTerminalNames[getVariant()].name);
191408 : // printf ("Error in SgOmpSingleStatement::error() \n");
191409 : ROSE_ABORT();
191410 : }
191411 :
191412 : ROSE_ASSERT (getVariant() == OMP_SINGLE_STMT);
191413 : return SgUpirFieldBodyStatement::error();
191414 : }
191415 : #endif
191416 :
191417 :
191418 :
191419 : // End of memberFunctionString
191420 :
191421 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
191422 :
191423 84 : SgOmpSingleStatement* isSgOmpSingleStatement ( SgNode* inputDerivedClassPointer )
191424 : {
191425 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191426 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191427 : // So to fix this we return NULL directly when the input is NULL and avoid the
191428 : // dynamic_cast in this case. This is likely a performance improvement as well.
191429 : // return dynamic_cast<SgOmpSingleStatement*>(inputDerivedClassPointer);
191430 : // Milind Chabbi (8/28/2013): isSgOmpSingleStatement uses table-driven castability instead of c++ default dynamic_cast
191431 : // this improves the running time performance by 10-20%.
191432 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSingleStatement*>(inputDerivedClassPointer);
191433 84 : return IS_SgOmpSingleStatement_FAST_MACRO(inputDerivedClassPointer);
191434 : }
191435 :
191436 : // DQ (11/8/2003): Added version of functions taking const pointer
191437 0 : const SgOmpSingleStatement* isSgOmpSingleStatement ( const SgNode* inputDerivedClassPointer )
191438 : {
191439 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191440 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191441 : // So to fix this we return NULL directly when the input is NULL and avoid the
191442 : // dynamic_cast in this case. This is likely a performance improvement as well.
191443 : // return dynamic_cast<const SgOmpSingleStatement*>(inputDerivedClassPointer);
191444 : // Milind Chabbi (8/28/2013): isSgOmpSingleStatement uses table-driven castability instead of c++ default dynamic_cast
191445 : // this improves the running time performance by 10-20%.
191446 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSingleStatement*>(inputDerivedClassPointer);
191447 0 : return IS_SgOmpSingleStatement_FAST_MACRO(inputDerivedClassPointer);
191448 : }
191449 :
191450 :
191451 :
191452 : /* #line 191453 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191453 :
191454 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191455 :
191456 : /**
191457 : \brief Generated destructor
191458 :
191459 : This destructor is automatically generated (by ROSETTA). This destructor
191460 : only frees memory of data members associated with the parts of the current IR node which
191461 : are NOT traversed. Those data members that are part of a traversal can be freed using
191462 : a traversal (calling this destructor on all children in a post-order traversal). Such
191463 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
191464 :
191465 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
191466 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
191467 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
191468 :
191469 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
191470 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
191471 : pointers are not yet implemented to call delete on eash pointer in the container.
191472 : (This could be done by derivation from the STL containers to define containers that
191473 : automatically deleted their members.)
191474 :
191475 : */
191476 0 : SgOmpSingleStatement::~SgOmpSingleStatement () {
191477 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
191478 :
191479 :
191480 :
191481 : }
191482 :
191483 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191484 0 : }
191485 :
191486 :
191487 : /* #line 191488 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191488 :
191489 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
191490 :
191491 : // Generated constructor
191492 84 : SgOmpSingleStatement::SgOmpSingleStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
191493 84 : : SgUpirFieldBodyStatement(startOfConstruct, body)
191494 : {
191495 : #ifdef DEBUG
191496 : // printf ("In SgOmpSingleStatement::SgOmpSingleStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
191497 : #endif
191498 : #if 0
191499 : // debugging information!
191500 : printf ("In SgOmpSingleStatement::SgOmpSingleStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
191501 : #endif
191502 :
191503 :
191504 :
191505 : #if 0
191506 : // DQ (7/30/2014): Call a virtual function.
191507 : std::string s = this->class_name();
191508 : #endif
191509 :
191510 : // Test the variant virtual function
191511 : // assert(OMP_SINGLE_STMT == variant());
191512 84 : assert(OMP_SINGLE_STMT == this->variant());
191513 84 : ROSE_ASSERT(OMP_SINGLE_STMT == (int)(this->variantT()));
191514 84 : post_construction_initialization();
191515 :
191516 : // Test the isSgOmpSingleStatement() function since it has been problematic
191517 84 : assert(isSgOmpSingleStatement(this) != NULL);
191518 84 : }
191519 :
191520 : // Generated constructor (all data members)
191521 :
191522 : /* #line 191523 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191523 :
191524 :
191525 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191526 :
191527 :
191528 : // ********************************************************
191529 : // member functions common across all array grammar objects
191530 : // ********************************************************
191531 :
191532 :
191533 :
191534 : /* #line 191535 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191535 :
191536 :
191537 :
191538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191539 :
191540 : // ********************************************************
191541 : // member functions specific to each node in the grammar
191542 : // ********************************************************
191543 :
191544 :
191545 : /* #line 191546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191546 :
191547 : // Start of memberFunctionString
191548 : /* #line 19439 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
191549 :
191550 : void
191551 8 : SgOmpAtomicStatement::post_construction_initialization()
191552 8 : {}
191553 :
191554 :
191555 : // End of memberFunctionString
191556 : // Start of memberFunctionString
191557 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
191558 :
191559 : // *** COMMON CODE SECTION BEGINS HERE ***
191560 :
191561 : #if 0
191562 : int
191563 : SgOmpAtomicStatement::getVariant() const
191564 : {
191565 : // This function is used in ROSE while "variant()" is used in SAGE
191566 : assert(this != NULL);
191567 : return variant();
191568 : }
191569 : #endif
191570 :
191571 : // This function is used in ROSE in treeTraversal code
191572 : // eventually replaces getVariant() and variant()
191573 : // though after variant() has been removed for a while we will
191574 : // want to change the name of variantT() back to variant()
191575 : // (since the "T" was ment to stand for temporary).
191576 : // When this happens the variantT() will be depricated.
191577 : VariantT
191578 649 : SgOmpAtomicStatement::variantT() const
191579 : {
191580 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
191581 649 : ROSE_ASSERT(this != NULL);
191582 649 : return V_SgOmpAtomicStatement;
191583 : }
191584 :
191585 : #if 0
191586 : int
191587 : SgOmpAtomicStatement::variant() const
191588 : {
191589 : // This function is used in SAGE
191590 : ROSE_ASSERT(this != NULL);
191591 : return OMP_ATOMIC_STMT;
191592 : }
191593 : #endif
191594 :
191595 : ROSE_DLL_API const char*
191596 0 : SgOmpAtomicStatement::sage_class_name() const
191597 : {
191598 0 : ROSE_ASSERT(this != NULL);
191599 0 : return "SgOmpAtomicStatement";
191600 : }
191601 :
191602 : std::string
191603 8 : SgOmpAtomicStatement::class_name() const
191604 : {
191605 8 : ROSE_ASSERT(this != NULL);
191606 8 : return "SgOmpAtomicStatement";
191607 : }
191608 :
191609 : // DQ (11/26/2005): Support for visitor pattern mechanims
191610 : // (inferior to ROSE traversal mechanism, experimental).
191611 : void
191612 0 : SgOmpAtomicStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
191613 : {
191614 0 : ROSE_ASSERT(this != NULL);
191615 0 : visitor.visit(this);
191616 0 : }
191617 :
191618 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
191619 0 : void SgOmpAtomicStatement::accept (ROSE_VisitorPattern & visitor) {
191620 0 : ROSE_ASSERT(this != NULL);
191621 0 : visitor.visit(this);
191622 0 : }
191623 :
191624 : SgOmpAtomicStatement*
191625 0 : SgOmpAtomicStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
191626 : {
191627 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
191628 : // This function is currently only supported for the AST used the represent Binary executables.
191629 : if (0 /* isSgAsmNode(this) != NULL */)
191630 : {
191631 : // Support for regex specification.
191632 : std::string prefixCode = "REGEX:";
191633 : addNewAttribute(prefixCode + s,a);
191634 : }
191635 : #endif
191636 :
191637 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
191638 0 : return this;
191639 : }
191640 :
191641 : // *** COMMON CODE SECTION ENDS HERE ***
191642 :
191643 :
191644 : // End of memberFunctionString
191645 : // Start of memberFunctionString
191646 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
191647 :
191648 :
191649 : #if 0
191650 : //! Error checking support
191651 : /*! Verifies the following:
191652 : - working getVariant() member function
191653 : - calls base class's error() member function
191654 : Every class has one of these functions.
191655 : */
191656 : bool
191657 : SgOmpAtomicStatement::error()
191658 : {
191659 : // Put error checking here
191660 :
191661 : ROSE_ASSERT (this != NULL);
191662 : if (getVariant() != OMP_ATOMIC_STMT)
191663 : {
191664 : printf ("Error in SgOmpAtomicStatement::error(): SgOmpAtomicStatement object has a %s variant \n",
191665 : Cxx_GrammarTerminalNames[getVariant()].name);
191666 : // printf ("Error in SgOmpAtomicStatement::error() \n");
191667 : ROSE_ABORT();
191668 : }
191669 :
191670 : ROSE_ASSERT (getVariant() == OMP_ATOMIC_STMT);
191671 : return SgUpirFieldBodyStatement::error();
191672 : }
191673 : #endif
191674 :
191675 :
191676 :
191677 : // End of memberFunctionString
191678 :
191679 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
191680 :
191681 8 : SgOmpAtomicStatement* isSgOmpAtomicStatement ( SgNode* inputDerivedClassPointer )
191682 : {
191683 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191684 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191685 : // So to fix this we return NULL directly when the input is NULL and avoid the
191686 : // dynamic_cast in this case. This is likely a performance improvement as well.
191687 : // return dynamic_cast<SgOmpAtomicStatement*>(inputDerivedClassPointer);
191688 : // Milind Chabbi (8/28/2013): isSgOmpAtomicStatement uses table-driven castability instead of c++ default dynamic_cast
191689 : // this improves the running time performance by 10-20%.
191690 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAtomicStatement*>(inputDerivedClassPointer);
191691 8 : return IS_SgOmpAtomicStatement_FAST_MACRO(inputDerivedClassPointer);
191692 : }
191693 :
191694 : // DQ (11/8/2003): Added version of functions taking const pointer
191695 0 : const SgOmpAtomicStatement* isSgOmpAtomicStatement ( const SgNode* inputDerivedClassPointer )
191696 : {
191697 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191698 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191699 : // So to fix this we return NULL directly when the input is NULL and avoid the
191700 : // dynamic_cast in this case. This is likely a performance improvement as well.
191701 : // return dynamic_cast<const SgOmpAtomicStatement*>(inputDerivedClassPointer);
191702 : // Milind Chabbi (8/28/2013): isSgOmpAtomicStatement uses table-driven castability instead of c++ default dynamic_cast
191703 : // this improves the running time performance by 10-20%.
191704 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAtomicStatement*>(inputDerivedClassPointer);
191705 0 : return IS_SgOmpAtomicStatement_FAST_MACRO(inputDerivedClassPointer);
191706 : }
191707 :
191708 :
191709 :
191710 : /* #line 191711 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191711 :
191712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191713 :
191714 : /**
191715 : \brief Generated destructor
191716 :
191717 : This destructor is automatically generated (by ROSETTA). This destructor
191718 : only frees memory of data members associated with the parts of the current IR node which
191719 : are NOT traversed. Those data members that are part of a traversal can be freed using
191720 : a traversal (calling this destructor on all children in a post-order traversal). Such
191721 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
191722 :
191723 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
191724 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
191725 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
191726 :
191727 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
191728 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
191729 : pointers are not yet implemented to call delete on eash pointer in the container.
191730 : (This could be done by derivation from the STL containers to define containers that
191731 : automatically deleted their members.)
191732 :
191733 : */
191734 0 : SgOmpAtomicStatement::~SgOmpAtomicStatement () {
191735 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
191736 :
191737 :
191738 :
191739 : }
191740 :
191741 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191742 0 : }
191743 :
191744 :
191745 : /* #line 191746 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191746 :
191747 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
191748 :
191749 : // Generated constructor
191750 8 : SgOmpAtomicStatement::SgOmpAtomicStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
191751 8 : : SgUpirFieldBodyStatement(startOfConstruct, body)
191752 : {
191753 : #ifdef DEBUG
191754 : // printf ("In SgOmpAtomicStatement::SgOmpAtomicStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
191755 : #endif
191756 : #if 0
191757 : // debugging information!
191758 : printf ("In SgOmpAtomicStatement::SgOmpAtomicStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
191759 : #endif
191760 :
191761 :
191762 :
191763 : #if 0
191764 : // DQ (7/30/2014): Call a virtual function.
191765 : std::string s = this->class_name();
191766 : #endif
191767 :
191768 : // Test the variant virtual function
191769 : // assert(OMP_ATOMIC_STMT == variant());
191770 8 : assert(OMP_ATOMIC_STMT == this->variant());
191771 8 : ROSE_ASSERT(OMP_ATOMIC_STMT == (int)(this->variantT()));
191772 8 : post_construction_initialization();
191773 :
191774 : // Test the isSgOmpAtomicStatement() function since it has been problematic
191775 8 : assert(isSgOmpAtomicStatement(this) != NULL);
191776 8 : }
191777 :
191778 : // Generated constructor (all data members)
191779 :
191780 : /* #line 191781 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191781 :
191782 :
191783 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191784 :
191785 :
191786 : // ********************************************************
191787 : // member functions common across all array grammar objects
191788 : // ********************************************************
191789 :
191790 :
191791 :
191792 : /* #line 191793 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191793 :
191794 :
191795 :
191796 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
191797 :
191798 : // ********************************************************
191799 : // member functions specific to each node in the grammar
191800 : // ********************************************************
191801 :
191802 :
191803 : /* #line 191804 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191804 :
191805 : // Start of memberFunctionString
191806 : /* #line 19070 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
191807 :
191808 : void
191809 1 : SgOmpScanStatement::post_construction_initialization()
191810 1 : {}
191811 :
191812 :
191813 : // End of memberFunctionString
191814 : // Start of memberFunctionString
191815 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
191816 :
191817 : // *** COMMON CODE SECTION BEGINS HERE ***
191818 :
191819 : #if 0
191820 : int
191821 : SgOmpScanStatement::getVariant() const
191822 : {
191823 : // This function is used in ROSE while "variant()" is used in SAGE
191824 : assert(this != NULL);
191825 : return variant();
191826 : }
191827 : #endif
191828 :
191829 : // This function is used in ROSE in treeTraversal code
191830 : // eventually replaces getVariant() and variant()
191831 : // though after variant() has been removed for a while we will
191832 : // want to change the name of variantT() back to variant()
191833 : // (since the "T" was ment to stand for temporary).
191834 : // When this happens the variantT() will be depricated.
191835 : VariantT
191836 55 : SgOmpScanStatement::variantT() const
191837 : {
191838 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
191839 55 : ROSE_ASSERT(this != NULL);
191840 55 : return V_SgOmpScanStatement;
191841 : }
191842 :
191843 : #if 0
191844 : int
191845 : SgOmpScanStatement::variant() const
191846 : {
191847 : // This function is used in SAGE
191848 : ROSE_ASSERT(this != NULL);
191849 : return OMP_SCAN_STMT;
191850 : }
191851 : #endif
191852 :
191853 : ROSE_DLL_API const char*
191854 0 : SgOmpScanStatement::sage_class_name() const
191855 : {
191856 0 : ROSE_ASSERT(this != NULL);
191857 0 : return "SgOmpScanStatement";
191858 : }
191859 :
191860 : std::string
191861 1 : SgOmpScanStatement::class_name() const
191862 : {
191863 1 : ROSE_ASSERT(this != NULL);
191864 1 : return "SgOmpScanStatement";
191865 : }
191866 :
191867 : // DQ (11/26/2005): Support for visitor pattern mechanims
191868 : // (inferior to ROSE traversal mechanism, experimental).
191869 : void
191870 0 : SgOmpScanStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
191871 : {
191872 0 : ROSE_ASSERT(this != NULL);
191873 0 : visitor.visit(this);
191874 0 : }
191875 :
191876 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
191877 0 : void SgOmpScanStatement::accept (ROSE_VisitorPattern & visitor) {
191878 0 : ROSE_ASSERT(this != NULL);
191879 0 : visitor.visit(this);
191880 0 : }
191881 :
191882 : SgOmpScanStatement*
191883 0 : SgOmpScanStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
191884 : {
191885 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
191886 : // This function is currently only supported for the AST used the represent Binary executables.
191887 : if (0 /* isSgAsmNode(this) != NULL */)
191888 : {
191889 : // Support for regex specification.
191890 : std::string prefixCode = "REGEX:";
191891 : addNewAttribute(prefixCode + s,a);
191892 : }
191893 : #endif
191894 :
191895 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
191896 0 : return this;
191897 : }
191898 :
191899 : // *** COMMON CODE SECTION ENDS HERE ***
191900 :
191901 :
191902 : // End of memberFunctionString
191903 : // Start of memberFunctionString
191904 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
191905 :
191906 :
191907 : #if 0
191908 : //! Error checking support
191909 : /*! Verifies the following:
191910 : - working getVariant() member function
191911 : - calls base class's error() member function
191912 : Every class has one of these functions.
191913 : */
191914 : bool
191915 : SgOmpScanStatement::error()
191916 : {
191917 : // Put error checking here
191918 :
191919 : ROSE_ASSERT (this != NULL);
191920 : if (getVariant() != OMP_SCAN_STMT)
191921 : {
191922 : printf ("Error in SgOmpScanStatement::error(): SgOmpScanStatement object has a %s variant \n",
191923 : Cxx_GrammarTerminalNames[getVariant()].name);
191924 : // printf ("Error in SgOmpScanStatement::error() \n");
191925 : ROSE_ABORT();
191926 : }
191927 :
191928 : ROSE_ASSERT (getVariant() == OMP_SCAN_STMT);
191929 : return SgUpirFieldBodyStatement::error();
191930 : }
191931 : #endif
191932 :
191933 :
191934 :
191935 : // End of memberFunctionString
191936 :
191937 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
191938 :
191939 1 : SgOmpScanStatement* isSgOmpScanStatement ( SgNode* inputDerivedClassPointer )
191940 : {
191941 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191942 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191943 : // So to fix this we return NULL directly when the input is NULL and avoid the
191944 : // dynamic_cast in this case. This is likely a performance improvement as well.
191945 : // return dynamic_cast<SgOmpScanStatement*>(inputDerivedClassPointer);
191946 : // Milind Chabbi (8/28/2013): isSgOmpScanStatement uses table-driven castability instead of c++ default dynamic_cast
191947 : // this improves the running time performance by 10-20%.
191948 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpScanStatement*>(inputDerivedClassPointer);
191949 1 : return IS_SgOmpScanStatement_FAST_MACRO(inputDerivedClassPointer);
191950 : }
191951 :
191952 : // DQ (11/8/2003): Added version of functions taking const pointer
191953 0 : const SgOmpScanStatement* isSgOmpScanStatement ( const SgNode* inputDerivedClassPointer )
191954 : {
191955 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
191956 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
191957 : // So to fix this we return NULL directly when the input is NULL and avoid the
191958 : // dynamic_cast in this case. This is likely a performance improvement as well.
191959 : // return dynamic_cast<const SgOmpScanStatement*>(inputDerivedClassPointer);
191960 : // Milind Chabbi (8/28/2013): isSgOmpScanStatement uses table-driven castability instead of c++ default dynamic_cast
191961 : // this improves the running time performance by 10-20%.
191962 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpScanStatement*>(inputDerivedClassPointer);
191963 0 : return IS_SgOmpScanStatement_FAST_MACRO(inputDerivedClassPointer);
191964 : }
191965 :
191966 :
191967 :
191968 : /* #line 191969 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
191969 :
191970 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
191971 :
191972 : /**
191973 : \brief Generated destructor
191974 :
191975 : This destructor is automatically generated (by ROSETTA). This destructor
191976 : only frees memory of data members associated with the parts of the current IR node which
191977 : are NOT traversed. Those data members that are part of a traversal can be freed using
191978 : a traversal (calling this destructor on all children in a post-order traversal). Such
191979 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
191980 :
191981 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
191982 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
191983 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
191984 :
191985 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
191986 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
191987 : pointers are not yet implemented to call delete on eash pointer in the container.
191988 : (This could be done by derivation from the STL containers to define containers that
191989 : automatically deleted their members.)
191990 :
191991 : */
191992 0 : SgOmpScanStatement::~SgOmpScanStatement () {
191993 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
191994 :
191995 :
191996 :
191997 : }
191998 :
191999 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192000 0 : }
192001 :
192002 :
192003 : /* #line 192004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192004 :
192005 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
192006 :
192007 : // Generated constructor
192008 1 : SgOmpScanStatement::SgOmpScanStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
192009 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
192010 : {
192011 : #ifdef DEBUG
192012 : // printf ("In SgOmpScanStatement::SgOmpScanStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
192013 : #endif
192014 : #if 0
192015 : // debugging information!
192016 : printf ("In SgOmpScanStatement::SgOmpScanStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
192017 : #endif
192018 :
192019 :
192020 :
192021 : #if 0
192022 : // DQ (7/30/2014): Call a virtual function.
192023 : std::string s = this->class_name();
192024 : #endif
192025 :
192026 : // Test the variant virtual function
192027 : // assert(OMP_SCAN_STMT == variant());
192028 1 : assert(OMP_SCAN_STMT == this->variant());
192029 1 : ROSE_ASSERT(OMP_SCAN_STMT == (int)(this->variantT()));
192030 1 : post_construction_initialization();
192031 :
192032 : // Test the isSgOmpScanStatement() function since it has been problematic
192033 1 : assert(isSgOmpScanStatement(this) != NULL);
192034 1 : }
192035 :
192036 : // Generated constructor (all data members)
192037 :
192038 : /* #line 192039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192039 :
192040 :
192041 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192042 :
192043 :
192044 : // ********************************************************
192045 : // member functions common across all array grammar objects
192046 : // ********************************************************
192047 :
192048 :
192049 :
192050 : /* #line 192051 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192051 :
192052 :
192053 :
192054 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192055 :
192056 : // ********************************************************
192057 : // member functions specific to each node in the grammar
192058 : // ********************************************************
192059 :
192060 :
192061 : /* #line 192062 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192062 :
192063 : // Start of memberFunctionString
192064 : /* #line 19094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
192065 :
192066 : void
192067 0 : SgOmpMetadirectiveStatement::post_construction_initialization()
192068 0 : {}
192069 :
192070 :
192071 : // End of memberFunctionString
192072 : // Start of memberFunctionString
192073 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
192074 :
192075 : // *** COMMON CODE SECTION BEGINS HERE ***
192076 :
192077 : #if 0
192078 : int
192079 : SgOmpMetadirectiveStatement::getVariant() const
192080 : {
192081 : // This function is used in ROSE while "variant()" is used in SAGE
192082 : assert(this != NULL);
192083 : return variant();
192084 : }
192085 : #endif
192086 :
192087 : // This function is used in ROSE in treeTraversal code
192088 : // eventually replaces getVariant() and variant()
192089 : // though after variant() has been removed for a while we will
192090 : // want to change the name of variantT() back to variant()
192091 : // (since the "T" was ment to stand for temporary).
192092 : // When this happens the variantT() will be depricated.
192093 : VariantT
192094 0 : SgOmpMetadirectiveStatement::variantT() const
192095 : {
192096 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
192097 0 : ROSE_ASSERT(this != NULL);
192098 0 : return V_SgOmpMetadirectiveStatement;
192099 : }
192100 :
192101 : #if 0
192102 : int
192103 : SgOmpMetadirectiveStatement::variant() const
192104 : {
192105 : // This function is used in SAGE
192106 : ROSE_ASSERT(this != NULL);
192107 : return OMP_METADIRECTIVE_STMT;
192108 : }
192109 : #endif
192110 :
192111 : ROSE_DLL_API const char*
192112 0 : SgOmpMetadirectiveStatement::sage_class_name() const
192113 : {
192114 0 : ROSE_ASSERT(this != NULL);
192115 0 : return "SgOmpMetadirectiveStatement";
192116 : }
192117 :
192118 : std::string
192119 0 : SgOmpMetadirectiveStatement::class_name() const
192120 : {
192121 0 : ROSE_ASSERT(this != NULL);
192122 0 : return "SgOmpMetadirectiveStatement";
192123 : }
192124 :
192125 : // DQ (11/26/2005): Support for visitor pattern mechanims
192126 : // (inferior to ROSE traversal mechanism, experimental).
192127 : void
192128 0 : SgOmpMetadirectiveStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
192129 : {
192130 0 : ROSE_ASSERT(this != NULL);
192131 0 : visitor.visit(this);
192132 0 : }
192133 :
192134 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
192135 0 : void SgOmpMetadirectiveStatement::accept (ROSE_VisitorPattern & visitor) {
192136 0 : ROSE_ASSERT(this != NULL);
192137 0 : visitor.visit(this);
192138 0 : }
192139 :
192140 : SgOmpMetadirectiveStatement*
192141 0 : SgOmpMetadirectiveStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
192142 : {
192143 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
192144 : // This function is currently only supported for the AST used the represent Binary executables.
192145 : if (0 /* isSgAsmNode(this) != NULL */)
192146 : {
192147 : // Support for regex specification.
192148 : std::string prefixCode = "REGEX:";
192149 : addNewAttribute(prefixCode + s,a);
192150 : }
192151 : #endif
192152 :
192153 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
192154 0 : return this;
192155 : }
192156 :
192157 : // *** COMMON CODE SECTION ENDS HERE ***
192158 :
192159 :
192160 : // End of memberFunctionString
192161 : // Start of memberFunctionString
192162 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
192163 :
192164 :
192165 : #if 0
192166 : //! Error checking support
192167 : /*! Verifies the following:
192168 : - working getVariant() member function
192169 : - calls base class's error() member function
192170 : Every class has one of these functions.
192171 : */
192172 : bool
192173 : SgOmpMetadirectiveStatement::error()
192174 : {
192175 : // Put error checking here
192176 :
192177 : ROSE_ASSERT (this != NULL);
192178 : if (getVariant() != OMP_METADIRECTIVE_STMT)
192179 : {
192180 : printf ("Error in SgOmpMetadirectiveStatement::error(): SgOmpMetadirectiveStatement object has a %s variant \n",
192181 : Cxx_GrammarTerminalNames[getVariant()].name);
192182 : // printf ("Error in SgOmpMetadirectiveStatement::error() \n");
192183 : ROSE_ABORT();
192184 : }
192185 :
192186 : ROSE_ASSERT (getVariant() == OMP_METADIRECTIVE_STMT);
192187 : return SgUpirFieldBodyStatement::error();
192188 : }
192189 : #endif
192190 :
192191 :
192192 :
192193 : // End of memberFunctionString
192194 :
192195 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
192196 :
192197 0 : SgOmpMetadirectiveStatement* isSgOmpMetadirectiveStatement ( SgNode* inputDerivedClassPointer )
192198 : {
192199 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192200 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192201 : // So to fix this we return NULL directly when the input is NULL and avoid the
192202 : // dynamic_cast in this case. This is likely a performance improvement as well.
192203 : // return dynamic_cast<SgOmpMetadirectiveStatement*>(inputDerivedClassPointer);
192204 : // Milind Chabbi (8/28/2013): isSgOmpMetadirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
192205 : // this improves the running time performance by 10-20%.
192206 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpMetadirectiveStatement*>(inputDerivedClassPointer);
192207 0 : return IS_SgOmpMetadirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
192208 : }
192209 :
192210 : // DQ (11/8/2003): Added version of functions taking const pointer
192211 0 : const SgOmpMetadirectiveStatement* isSgOmpMetadirectiveStatement ( const SgNode* inputDerivedClassPointer )
192212 : {
192213 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192214 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192215 : // So to fix this we return NULL directly when the input is NULL and avoid the
192216 : // dynamic_cast in this case. This is likely a performance improvement as well.
192217 : // return dynamic_cast<const SgOmpMetadirectiveStatement*>(inputDerivedClassPointer);
192218 : // Milind Chabbi (8/28/2013): isSgOmpMetadirectiveStatement uses table-driven castability instead of c++ default dynamic_cast
192219 : // this improves the running time performance by 10-20%.
192220 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpMetadirectiveStatement*>(inputDerivedClassPointer);
192221 0 : return IS_SgOmpMetadirectiveStatement_FAST_MACRO(inputDerivedClassPointer);
192222 : }
192223 :
192224 :
192225 :
192226 : /* #line 192227 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192227 :
192228 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192229 :
192230 : /**
192231 : \brief Generated destructor
192232 :
192233 : This destructor is automatically generated (by ROSETTA). This destructor
192234 : only frees memory of data members associated with the parts of the current IR node which
192235 : are NOT traversed. Those data members that are part of a traversal can be freed using
192236 : a traversal (calling this destructor on all children in a post-order traversal). Such
192237 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
192238 :
192239 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
192240 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
192241 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
192242 :
192243 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
192244 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
192245 : pointers are not yet implemented to call delete on eash pointer in the container.
192246 : (This could be done by derivation from the STL containers to define containers that
192247 : automatically deleted their members.)
192248 :
192249 : */
192250 0 : SgOmpMetadirectiveStatement::~SgOmpMetadirectiveStatement () {
192251 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
192252 :
192253 :
192254 :
192255 : }
192256 :
192257 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192258 0 : }
192259 :
192260 :
192261 : /* #line 192262 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192262 :
192263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
192264 :
192265 : // Generated constructor
192266 0 : SgOmpMetadirectiveStatement::SgOmpMetadirectiveStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
192267 0 : : SgUpirFieldBodyStatement(startOfConstruct, body)
192268 : {
192269 : #ifdef DEBUG
192270 : // printf ("In SgOmpMetadirectiveStatement::SgOmpMetadirectiveStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
192271 : #endif
192272 : #if 0
192273 : // debugging information!
192274 : printf ("In SgOmpMetadirectiveStatement::SgOmpMetadirectiveStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
192275 : #endif
192276 :
192277 :
192278 :
192279 : #if 0
192280 : // DQ (7/30/2014): Call a virtual function.
192281 : std::string s = this->class_name();
192282 : #endif
192283 :
192284 : // Test the variant virtual function
192285 : // assert(OMP_METADIRECTIVE_STMT == variant());
192286 0 : assert(OMP_METADIRECTIVE_STMT == this->variant());
192287 0 : ROSE_ASSERT(OMP_METADIRECTIVE_STMT == (int)(this->variantT()));
192288 0 : post_construction_initialization();
192289 :
192290 : // Test the isSgOmpMetadirectiveStatement() function since it has been problematic
192291 0 : assert(isSgOmpMetadirectiveStatement(this) != NULL);
192292 0 : }
192293 :
192294 : // Generated constructor (all data members)
192295 :
192296 : /* #line 192297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192297 :
192298 :
192299 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192300 :
192301 :
192302 : // ********************************************************
192303 : // member functions common across all array grammar objects
192304 : // ********************************************************
192305 :
192306 :
192307 :
192308 : /* #line 192309 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192309 :
192310 :
192311 :
192312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192313 :
192314 : // ********************************************************
192315 : // member functions specific to each node in the grammar
192316 : // ********************************************************
192317 :
192318 :
192319 : /* #line 192320 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192320 :
192321 : // Start of memberFunctionString
192322 : /* #line 19064 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
192323 :
192324 : void
192325 1 : SgOmpLoopStatement::post_construction_initialization()
192326 1 : {}
192327 :
192328 :
192329 : // End of memberFunctionString
192330 : // Start of memberFunctionString
192331 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
192332 :
192333 : // *** COMMON CODE SECTION BEGINS HERE ***
192334 :
192335 : #if 0
192336 : int
192337 : SgOmpLoopStatement::getVariant() const
192338 : {
192339 : // This function is used in ROSE while "variant()" is used in SAGE
192340 : assert(this != NULL);
192341 : return variant();
192342 : }
192343 : #endif
192344 :
192345 : // This function is used in ROSE in treeTraversal code
192346 : // eventually replaces getVariant() and variant()
192347 : // though after variant() has been removed for a while we will
192348 : // want to change the name of variantT() back to variant()
192349 : // (since the "T" was ment to stand for temporary).
192350 : // When this happens the variantT() will be depricated.
192351 : VariantT
192352 129 : SgOmpLoopStatement::variantT() const
192353 : {
192354 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
192355 129 : ROSE_ASSERT(this != NULL);
192356 129 : return V_SgOmpLoopStatement;
192357 : }
192358 :
192359 : #if 0
192360 : int
192361 : SgOmpLoopStatement::variant() const
192362 : {
192363 : // This function is used in SAGE
192364 : ROSE_ASSERT(this != NULL);
192365 : return OMP_LOOP_STMT;
192366 : }
192367 : #endif
192368 :
192369 : ROSE_DLL_API const char*
192370 0 : SgOmpLoopStatement::sage_class_name() const
192371 : {
192372 0 : ROSE_ASSERT(this != NULL);
192373 0 : return "SgOmpLoopStatement";
192374 : }
192375 :
192376 : std::string
192377 1 : SgOmpLoopStatement::class_name() const
192378 : {
192379 1 : ROSE_ASSERT(this != NULL);
192380 1 : return "SgOmpLoopStatement";
192381 : }
192382 :
192383 : // DQ (11/26/2005): Support for visitor pattern mechanims
192384 : // (inferior to ROSE traversal mechanism, experimental).
192385 : void
192386 0 : SgOmpLoopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
192387 : {
192388 0 : ROSE_ASSERT(this != NULL);
192389 0 : visitor.visit(this);
192390 0 : }
192391 :
192392 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
192393 0 : void SgOmpLoopStatement::accept (ROSE_VisitorPattern & visitor) {
192394 0 : ROSE_ASSERT(this != NULL);
192395 0 : visitor.visit(this);
192396 0 : }
192397 :
192398 : SgOmpLoopStatement*
192399 0 : SgOmpLoopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
192400 : {
192401 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
192402 : // This function is currently only supported for the AST used the represent Binary executables.
192403 : if (0 /* isSgAsmNode(this) != NULL */)
192404 : {
192405 : // Support for regex specification.
192406 : std::string prefixCode = "REGEX:";
192407 : addNewAttribute(prefixCode + s,a);
192408 : }
192409 : #endif
192410 :
192411 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
192412 0 : return this;
192413 : }
192414 :
192415 : // *** COMMON CODE SECTION ENDS HERE ***
192416 :
192417 :
192418 : // End of memberFunctionString
192419 : // Start of memberFunctionString
192420 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
192421 :
192422 :
192423 : #if 0
192424 : //! Error checking support
192425 : /*! Verifies the following:
192426 : - working getVariant() member function
192427 : - calls base class's error() member function
192428 : Every class has one of these functions.
192429 : */
192430 : bool
192431 : SgOmpLoopStatement::error()
192432 : {
192433 : // Put error checking here
192434 :
192435 : ROSE_ASSERT (this != NULL);
192436 : if (getVariant() != OMP_LOOP_STMT)
192437 : {
192438 : printf ("Error in SgOmpLoopStatement::error(): SgOmpLoopStatement object has a %s variant \n",
192439 : Cxx_GrammarTerminalNames[getVariant()].name);
192440 : // printf ("Error in SgOmpLoopStatement::error() \n");
192441 : ROSE_ABORT();
192442 : }
192443 :
192444 : ROSE_ASSERT (getVariant() == OMP_LOOP_STMT);
192445 : return SgUpirFieldBodyStatement::error();
192446 : }
192447 : #endif
192448 :
192449 :
192450 :
192451 : // End of memberFunctionString
192452 :
192453 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
192454 :
192455 1 : SgOmpLoopStatement* isSgOmpLoopStatement ( SgNode* inputDerivedClassPointer )
192456 : {
192457 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192458 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192459 : // So to fix this we return NULL directly when the input is NULL and avoid the
192460 : // dynamic_cast in this case. This is likely a performance improvement as well.
192461 : // return dynamic_cast<SgOmpLoopStatement*>(inputDerivedClassPointer);
192462 : // Milind Chabbi (8/28/2013): isSgOmpLoopStatement uses table-driven castability instead of c++ default dynamic_cast
192463 : // this improves the running time performance by 10-20%.
192464 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpLoopStatement*>(inputDerivedClassPointer);
192465 1 : return IS_SgOmpLoopStatement_FAST_MACRO(inputDerivedClassPointer);
192466 : }
192467 :
192468 : // DQ (11/8/2003): Added version of functions taking const pointer
192469 0 : const SgOmpLoopStatement* isSgOmpLoopStatement ( const SgNode* inputDerivedClassPointer )
192470 : {
192471 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192472 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192473 : // So to fix this we return NULL directly when the input is NULL and avoid the
192474 : // dynamic_cast in this case. This is likely a performance improvement as well.
192475 : // return dynamic_cast<const SgOmpLoopStatement*>(inputDerivedClassPointer);
192476 : // Milind Chabbi (8/28/2013): isSgOmpLoopStatement uses table-driven castability instead of c++ default dynamic_cast
192477 : // this improves the running time performance by 10-20%.
192478 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpLoopStatement*>(inputDerivedClassPointer);
192479 0 : return IS_SgOmpLoopStatement_FAST_MACRO(inputDerivedClassPointer);
192480 : }
192481 :
192482 :
192483 :
192484 : /* #line 192485 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192485 :
192486 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192487 :
192488 : /**
192489 : \brief Generated destructor
192490 :
192491 : This destructor is automatically generated (by ROSETTA). This destructor
192492 : only frees memory of data members associated with the parts of the current IR node which
192493 : are NOT traversed. Those data members that are part of a traversal can be freed using
192494 : a traversal (calling this destructor on all children in a post-order traversal). Such
192495 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
192496 :
192497 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
192498 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
192499 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
192500 :
192501 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
192502 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
192503 : pointers are not yet implemented to call delete on eash pointer in the container.
192504 : (This could be done by derivation from the STL containers to define containers that
192505 : automatically deleted their members.)
192506 :
192507 : */
192508 0 : SgOmpLoopStatement::~SgOmpLoopStatement () {
192509 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
192510 :
192511 :
192512 :
192513 : }
192514 :
192515 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192516 0 : }
192517 :
192518 :
192519 : /* #line 192520 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192520 :
192521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
192522 :
192523 : // Generated constructor
192524 1 : SgOmpLoopStatement::SgOmpLoopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
192525 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
192526 : {
192527 : #ifdef DEBUG
192528 : // printf ("In SgOmpLoopStatement::SgOmpLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
192529 : #endif
192530 : #if 0
192531 : // debugging information!
192532 : printf ("In SgOmpLoopStatement::SgOmpLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
192533 : #endif
192534 :
192535 :
192536 :
192537 : #if 0
192538 : // DQ (7/30/2014): Call a virtual function.
192539 : std::string s = this->class_name();
192540 : #endif
192541 :
192542 : // Test the variant virtual function
192543 : // assert(OMP_LOOP_STMT == variant());
192544 1 : assert(OMP_LOOP_STMT == this->variant());
192545 1 : ROSE_ASSERT(OMP_LOOP_STMT == (int)(this->variantT()));
192546 1 : post_construction_initialization();
192547 :
192548 : // Test the isSgOmpLoopStatement() function since it has been problematic
192549 1 : assert(isSgOmpLoopStatement(this) != NULL);
192550 1 : }
192551 :
192552 : // Generated constructor (all data members)
192553 :
192554 : /* #line 192555 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192555 :
192556 :
192557 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192558 :
192559 :
192560 : // ********************************************************
192561 : // member functions common across all array grammar objects
192562 : // ********************************************************
192563 :
192564 :
192565 :
192566 : /* #line 192567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192567 :
192568 :
192569 :
192570 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192571 :
192572 : // ********************************************************
192573 : // member functions specific to each node in the grammar
192574 : // ********************************************************
192575 :
192576 :
192577 : /* #line 192578 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192578 :
192579 : // Start of memberFunctionString
192580 : /* #line 19447 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
192581 :
192582 : void
192583 4 : SgOmpOrderedStatement::post_construction_initialization()
192584 4 : {}
192585 :
192586 :
192587 : // End of memberFunctionString
192588 : // Start of memberFunctionString
192589 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
192590 :
192591 : // *** COMMON CODE SECTION BEGINS HERE ***
192592 :
192593 : #if 0
192594 : int
192595 : SgOmpOrderedStatement::getVariant() const
192596 : {
192597 : // This function is used in ROSE while "variant()" is used in SAGE
192598 : assert(this != NULL);
192599 : return variant();
192600 : }
192601 : #endif
192602 :
192603 : // This function is used in ROSE in treeTraversal code
192604 : // eventually replaces getVariant() and variant()
192605 : // though after variant() has been removed for a while we will
192606 : // want to change the name of variantT() back to variant()
192607 : // (since the "T" was ment to stand for temporary).
192608 : // When this happens the variantT() will be depricated.
192609 : VariantT
192610 216 : SgOmpOrderedStatement::variantT() const
192611 : {
192612 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
192613 216 : ROSE_ASSERT(this != NULL);
192614 216 : return V_SgOmpOrderedStatement;
192615 : }
192616 :
192617 : #if 0
192618 : int
192619 : SgOmpOrderedStatement::variant() const
192620 : {
192621 : // This function is used in SAGE
192622 : ROSE_ASSERT(this != NULL);
192623 : return OMP_ORDERED_STMT;
192624 : }
192625 : #endif
192626 :
192627 : ROSE_DLL_API const char*
192628 0 : SgOmpOrderedStatement::sage_class_name() const
192629 : {
192630 0 : ROSE_ASSERT(this != NULL);
192631 0 : return "SgOmpOrderedStatement";
192632 : }
192633 :
192634 : std::string
192635 4 : SgOmpOrderedStatement::class_name() const
192636 : {
192637 4 : ROSE_ASSERT(this != NULL);
192638 4 : return "SgOmpOrderedStatement";
192639 : }
192640 :
192641 : // DQ (11/26/2005): Support for visitor pattern mechanims
192642 : // (inferior to ROSE traversal mechanism, experimental).
192643 : void
192644 0 : SgOmpOrderedStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
192645 : {
192646 0 : ROSE_ASSERT(this != NULL);
192647 0 : visitor.visit(this);
192648 0 : }
192649 :
192650 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
192651 0 : void SgOmpOrderedStatement::accept (ROSE_VisitorPattern & visitor) {
192652 0 : ROSE_ASSERT(this != NULL);
192653 0 : visitor.visit(this);
192654 0 : }
192655 :
192656 : SgOmpOrderedStatement*
192657 0 : SgOmpOrderedStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
192658 : {
192659 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
192660 : // This function is currently only supported for the AST used the represent Binary executables.
192661 : if (0 /* isSgAsmNode(this) != NULL */)
192662 : {
192663 : // Support for regex specification.
192664 : std::string prefixCode = "REGEX:";
192665 : addNewAttribute(prefixCode + s,a);
192666 : }
192667 : #endif
192668 :
192669 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
192670 0 : return this;
192671 : }
192672 :
192673 : // *** COMMON CODE SECTION ENDS HERE ***
192674 :
192675 :
192676 : // End of memberFunctionString
192677 : // Start of memberFunctionString
192678 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
192679 :
192680 :
192681 : #if 0
192682 : //! Error checking support
192683 : /*! Verifies the following:
192684 : - working getVariant() member function
192685 : - calls base class's error() member function
192686 : Every class has one of these functions.
192687 : */
192688 : bool
192689 : SgOmpOrderedStatement::error()
192690 : {
192691 : // Put error checking here
192692 :
192693 : ROSE_ASSERT (this != NULL);
192694 : if (getVariant() != OMP_ORDERED_STMT)
192695 : {
192696 : printf ("Error in SgOmpOrderedStatement::error(): SgOmpOrderedStatement object has a %s variant \n",
192697 : Cxx_GrammarTerminalNames[getVariant()].name);
192698 : // printf ("Error in SgOmpOrderedStatement::error() \n");
192699 : ROSE_ABORT();
192700 : }
192701 :
192702 : ROSE_ASSERT (getVariant() == OMP_ORDERED_STMT);
192703 : return SgUpirFieldBodyStatement::error();
192704 : }
192705 : #endif
192706 :
192707 :
192708 :
192709 : // End of memberFunctionString
192710 :
192711 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
192712 :
192713 4 : SgOmpOrderedStatement* isSgOmpOrderedStatement ( SgNode* inputDerivedClassPointer )
192714 : {
192715 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192716 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192717 : // So to fix this we return NULL directly when the input is NULL and avoid the
192718 : // dynamic_cast in this case. This is likely a performance improvement as well.
192719 : // return dynamic_cast<SgOmpOrderedStatement*>(inputDerivedClassPointer);
192720 : // Milind Chabbi (8/28/2013): isSgOmpOrderedStatement uses table-driven castability instead of c++ default dynamic_cast
192721 : // this improves the running time performance by 10-20%.
192722 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpOrderedStatement*>(inputDerivedClassPointer);
192723 4 : return IS_SgOmpOrderedStatement_FAST_MACRO(inputDerivedClassPointer);
192724 : }
192725 :
192726 : // DQ (11/8/2003): Added version of functions taking const pointer
192727 0 : const SgOmpOrderedStatement* isSgOmpOrderedStatement ( const SgNode* inputDerivedClassPointer )
192728 : {
192729 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192730 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192731 : // So to fix this we return NULL directly when the input is NULL and avoid the
192732 : // dynamic_cast in this case. This is likely a performance improvement as well.
192733 : // return dynamic_cast<const SgOmpOrderedStatement*>(inputDerivedClassPointer);
192734 : // Milind Chabbi (8/28/2013): isSgOmpOrderedStatement uses table-driven castability instead of c++ default dynamic_cast
192735 : // this improves the running time performance by 10-20%.
192736 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpOrderedStatement*>(inputDerivedClassPointer);
192737 0 : return IS_SgOmpOrderedStatement_FAST_MACRO(inputDerivedClassPointer);
192738 : }
192739 :
192740 :
192741 :
192742 : /* #line 192743 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192743 :
192744 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192745 :
192746 : /**
192747 : \brief Generated destructor
192748 :
192749 : This destructor is automatically generated (by ROSETTA). This destructor
192750 : only frees memory of data members associated with the parts of the current IR node which
192751 : are NOT traversed. Those data members that are part of a traversal can be freed using
192752 : a traversal (calling this destructor on all children in a post-order traversal). Such
192753 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
192754 :
192755 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
192756 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
192757 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
192758 :
192759 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
192760 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
192761 : pointers are not yet implemented to call delete on eash pointer in the container.
192762 : (This could be done by derivation from the STL containers to define containers that
192763 : automatically deleted their members.)
192764 :
192765 : */
192766 0 : SgOmpOrderedStatement::~SgOmpOrderedStatement () {
192767 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
192768 :
192769 :
192770 :
192771 : }
192772 :
192773 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
192774 0 : }
192775 :
192776 :
192777 : /* #line 192778 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192778 :
192779 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
192780 :
192781 : // Generated constructor
192782 4 : SgOmpOrderedStatement::SgOmpOrderedStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
192783 4 : : SgUpirFieldBodyStatement(startOfConstruct, body)
192784 : {
192785 : #ifdef DEBUG
192786 : // printf ("In SgOmpOrderedStatement::SgOmpOrderedStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
192787 : #endif
192788 : #if 0
192789 : // debugging information!
192790 : printf ("In SgOmpOrderedStatement::SgOmpOrderedStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
192791 : #endif
192792 :
192793 :
192794 :
192795 : #if 0
192796 : // DQ (7/30/2014): Call a virtual function.
192797 : std::string s = this->class_name();
192798 : #endif
192799 :
192800 : // Test the variant virtual function
192801 : // assert(OMP_ORDERED_STMT == variant());
192802 4 : assert(OMP_ORDERED_STMT == this->variant());
192803 4 : ROSE_ASSERT(OMP_ORDERED_STMT == (int)(this->variantT()));
192804 4 : post_construction_initialization();
192805 :
192806 : // Test the isSgOmpOrderedStatement() function since it has been problematic
192807 4 : assert(isSgOmpOrderedStatement(this) != NULL);
192808 4 : }
192809 :
192810 : // Generated constructor (all data members)
192811 :
192812 : /* #line 192813 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192813 :
192814 :
192815 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192816 :
192817 :
192818 : // ********************************************************
192819 : // member functions common across all array grammar objects
192820 : // ********************************************************
192821 :
192822 :
192823 :
192824 : /* #line 192825 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192825 :
192826 :
192827 :
192828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
192829 :
192830 : // ********************************************************
192831 : // member functions specific to each node in the grammar
192832 : // ********************************************************
192833 :
192834 :
192835 : /* #line 192836 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
192836 :
192837 : // Start of memberFunctionString
192838 : /* #line 19046 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
192839 :
192840 : void
192841 2 : SgOmpTaskgroupStatement::post_construction_initialization()
192842 2 : {}
192843 :
192844 :
192845 : // End of memberFunctionString
192846 : // Start of memberFunctionString
192847 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
192848 :
192849 : // *** COMMON CODE SECTION BEGINS HERE ***
192850 :
192851 : #if 0
192852 : int
192853 : SgOmpTaskgroupStatement::getVariant() const
192854 : {
192855 : // This function is used in ROSE while "variant()" is used in SAGE
192856 : assert(this != NULL);
192857 : return variant();
192858 : }
192859 : #endif
192860 :
192861 : // This function is used in ROSE in treeTraversal code
192862 : // eventually replaces getVariant() and variant()
192863 : // though after variant() has been removed for a while we will
192864 : // want to change the name of variantT() back to variant()
192865 : // (since the "T" was ment to stand for temporary).
192866 : // When this happens the variantT() will be depricated.
192867 : VariantT
192868 250 : SgOmpTaskgroupStatement::variantT() const
192869 : {
192870 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
192871 250 : ROSE_ASSERT(this != NULL);
192872 250 : return V_SgOmpTaskgroupStatement;
192873 : }
192874 :
192875 : #if 0
192876 : int
192877 : SgOmpTaskgroupStatement::variant() const
192878 : {
192879 : // This function is used in SAGE
192880 : ROSE_ASSERT(this != NULL);
192881 : return OMP_TASKGROUP_STMT;
192882 : }
192883 : #endif
192884 :
192885 : ROSE_DLL_API const char*
192886 0 : SgOmpTaskgroupStatement::sage_class_name() const
192887 : {
192888 0 : ROSE_ASSERT(this != NULL);
192889 0 : return "SgOmpTaskgroupStatement";
192890 : }
192891 :
192892 : std::string
192893 2 : SgOmpTaskgroupStatement::class_name() const
192894 : {
192895 2 : ROSE_ASSERT(this != NULL);
192896 2 : return "SgOmpTaskgroupStatement";
192897 : }
192898 :
192899 : // DQ (11/26/2005): Support for visitor pattern mechanims
192900 : // (inferior to ROSE traversal mechanism, experimental).
192901 : void
192902 0 : SgOmpTaskgroupStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
192903 : {
192904 0 : ROSE_ASSERT(this != NULL);
192905 0 : visitor.visit(this);
192906 0 : }
192907 :
192908 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
192909 0 : void SgOmpTaskgroupStatement::accept (ROSE_VisitorPattern & visitor) {
192910 0 : ROSE_ASSERT(this != NULL);
192911 0 : visitor.visit(this);
192912 0 : }
192913 :
192914 : SgOmpTaskgroupStatement*
192915 0 : SgOmpTaskgroupStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
192916 : {
192917 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
192918 : // This function is currently only supported for the AST used the represent Binary executables.
192919 : if (0 /* isSgAsmNode(this) != NULL */)
192920 : {
192921 : // Support for regex specification.
192922 : std::string prefixCode = "REGEX:";
192923 : addNewAttribute(prefixCode + s,a);
192924 : }
192925 : #endif
192926 :
192927 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
192928 0 : return this;
192929 : }
192930 :
192931 : // *** COMMON CODE SECTION ENDS HERE ***
192932 :
192933 :
192934 : // End of memberFunctionString
192935 : // Start of memberFunctionString
192936 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
192937 :
192938 :
192939 : #if 0
192940 : //! Error checking support
192941 : /*! Verifies the following:
192942 : - working getVariant() member function
192943 : - calls base class's error() member function
192944 : Every class has one of these functions.
192945 : */
192946 : bool
192947 : SgOmpTaskgroupStatement::error()
192948 : {
192949 : // Put error checking here
192950 :
192951 : ROSE_ASSERT (this != NULL);
192952 : if (getVariant() != OMP_TASKGROUP_STMT)
192953 : {
192954 : printf ("Error in SgOmpTaskgroupStatement::error(): SgOmpTaskgroupStatement object has a %s variant \n",
192955 : Cxx_GrammarTerminalNames[getVariant()].name);
192956 : // printf ("Error in SgOmpTaskgroupStatement::error() \n");
192957 : ROSE_ABORT();
192958 : }
192959 :
192960 : ROSE_ASSERT (getVariant() == OMP_TASKGROUP_STMT);
192961 : return SgUpirFieldBodyStatement::error();
192962 : }
192963 : #endif
192964 :
192965 :
192966 :
192967 : // End of memberFunctionString
192968 :
192969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
192970 :
192971 2 : SgOmpTaskgroupStatement* isSgOmpTaskgroupStatement ( SgNode* inputDerivedClassPointer )
192972 : {
192973 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192974 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192975 : // So to fix this we return NULL directly when the input is NULL and avoid the
192976 : // dynamic_cast in this case. This is likely a performance improvement as well.
192977 : // return dynamic_cast<SgOmpTaskgroupStatement*>(inputDerivedClassPointer);
192978 : // Milind Chabbi (8/28/2013): isSgOmpTaskgroupStatement uses table-driven castability instead of c++ default dynamic_cast
192979 : // this improves the running time performance by 10-20%.
192980 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskgroupStatement*>(inputDerivedClassPointer);
192981 2 : return IS_SgOmpTaskgroupStatement_FAST_MACRO(inputDerivedClassPointer);
192982 : }
192983 :
192984 : // DQ (11/8/2003): Added version of functions taking const pointer
192985 0 : const SgOmpTaskgroupStatement* isSgOmpTaskgroupStatement ( const SgNode* inputDerivedClassPointer )
192986 : {
192987 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
192988 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
192989 : // So to fix this we return NULL directly when the input is NULL and avoid the
192990 : // dynamic_cast in this case. This is likely a performance improvement as well.
192991 : // return dynamic_cast<const SgOmpTaskgroupStatement*>(inputDerivedClassPointer);
192992 : // Milind Chabbi (8/28/2013): isSgOmpTaskgroupStatement uses table-driven castability instead of c++ default dynamic_cast
192993 : // this improves the running time performance by 10-20%.
192994 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskgroupStatement*>(inputDerivedClassPointer);
192995 0 : return IS_SgOmpTaskgroupStatement_FAST_MACRO(inputDerivedClassPointer);
192996 : }
192997 :
192998 :
192999 :
193000 : /* #line 193001 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193001 :
193002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193003 :
193004 : /**
193005 : \brief Generated destructor
193006 :
193007 : This destructor is automatically generated (by ROSETTA). This destructor
193008 : only frees memory of data members associated with the parts of the current IR node which
193009 : are NOT traversed. Those data members that are part of a traversal can be freed using
193010 : a traversal (calling this destructor on all children in a post-order traversal). Such
193011 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
193012 :
193013 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
193014 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
193015 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
193016 :
193017 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
193018 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
193019 : pointers are not yet implemented to call delete on eash pointer in the container.
193020 : (This could be done by derivation from the STL containers to define containers that
193021 : automatically deleted their members.)
193022 :
193023 : */
193024 0 : SgOmpTaskgroupStatement::~SgOmpTaskgroupStatement () {
193025 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
193026 :
193027 :
193028 :
193029 : }
193030 :
193031 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193032 0 : }
193033 :
193034 :
193035 : /* #line 193036 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193036 :
193037 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
193038 :
193039 : // Generated constructor
193040 2 : SgOmpTaskgroupStatement::SgOmpTaskgroupStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
193041 2 : : SgUpirFieldBodyStatement(startOfConstruct, body)
193042 : {
193043 : #ifdef DEBUG
193044 : // printf ("In SgOmpTaskgroupStatement::SgOmpTaskgroupStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
193045 : #endif
193046 : #if 0
193047 : // debugging information!
193048 : printf ("In SgOmpTaskgroupStatement::SgOmpTaskgroupStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
193049 : #endif
193050 :
193051 :
193052 :
193053 : #if 0
193054 : // DQ (7/30/2014): Call a virtual function.
193055 : std::string s = this->class_name();
193056 : #endif
193057 :
193058 : // Test the variant virtual function
193059 : // assert(OMP_TASKGROUP_STMT == variant());
193060 2 : assert(OMP_TASKGROUP_STMT == this->variant());
193061 2 : ROSE_ASSERT(OMP_TASKGROUP_STMT == (int)(this->variantT()));
193062 2 : post_construction_initialization();
193063 :
193064 : // Test the isSgOmpTaskgroupStatement() function since it has been problematic
193065 2 : assert(isSgOmpTaskgroupStatement(this) != NULL);
193066 2 : }
193067 :
193068 : // Generated constructor (all data members)
193069 :
193070 : /* #line 193071 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193071 :
193072 :
193073 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193074 :
193075 :
193076 : // ********************************************************
193077 : // member functions common across all array grammar objects
193078 : // ********************************************************
193079 :
193080 :
193081 :
193082 : /* #line 193083 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193083 :
193084 :
193085 :
193086 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193087 :
193088 : // ********************************************************
193089 : // member functions specific to each node in the grammar
193090 : // ********************************************************
193091 :
193092 :
193093 : /* #line 193094 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193094 :
193095 : // Start of memberFunctionString
193096 : /* #line 19076 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
193097 :
193098 : void
193099 2 : SgOmpTaskloopStatement::post_construction_initialization()
193100 2 : {}
193101 :
193102 :
193103 : // End of memberFunctionString
193104 : // Start of memberFunctionString
193105 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
193106 :
193107 : // *** COMMON CODE SECTION BEGINS HERE ***
193108 :
193109 : #if 0
193110 : int
193111 : SgOmpTaskloopStatement::getVariant() const
193112 : {
193113 : // This function is used in ROSE while "variant()" is used in SAGE
193114 : assert(this != NULL);
193115 : return variant();
193116 : }
193117 : #endif
193118 :
193119 : // This function is used in ROSE in treeTraversal code
193120 : // eventually replaces getVariant() and variant()
193121 : // though after variant() has been removed for a while we will
193122 : // want to change the name of variantT() back to variant()
193123 : // (since the "T" was ment to stand for temporary).
193124 : // When this happens the variantT() will be depricated.
193125 : VariantT
193126 255 : SgOmpTaskloopStatement::variantT() const
193127 : {
193128 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
193129 255 : ROSE_ASSERT(this != NULL);
193130 255 : return V_SgOmpTaskloopStatement;
193131 : }
193132 :
193133 : #if 0
193134 : int
193135 : SgOmpTaskloopStatement::variant() const
193136 : {
193137 : // This function is used in SAGE
193138 : ROSE_ASSERT(this != NULL);
193139 : return OMP_TASKLOOP_STMT;
193140 : }
193141 : #endif
193142 :
193143 : ROSE_DLL_API const char*
193144 0 : SgOmpTaskloopStatement::sage_class_name() const
193145 : {
193146 0 : ROSE_ASSERT(this != NULL);
193147 0 : return "SgOmpTaskloopStatement";
193148 : }
193149 :
193150 : std::string
193151 2 : SgOmpTaskloopStatement::class_name() const
193152 : {
193153 2 : ROSE_ASSERT(this != NULL);
193154 2 : return "SgOmpTaskloopStatement";
193155 : }
193156 :
193157 : // DQ (11/26/2005): Support for visitor pattern mechanims
193158 : // (inferior to ROSE traversal mechanism, experimental).
193159 : void
193160 0 : SgOmpTaskloopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
193161 : {
193162 0 : ROSE_ASSERT(this != NULL);
193163 0 : visitor.visit(this);
193164 0 : }
193165 :
193166 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
193167 0 : void SgOmpTaskloopStatement::accept (ROSE_VisitorPattern & visitor) {
193168 0 : ROSE_ASSERT(this != NULL);
193169 0 : visitor.visit(this);
193170 0 : }
193171 :
193172 : SgOmpTaskloopStatement*
193173 0 : SgOmpTaskloopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
193174 : {
193175 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
193176 : // This function is currently only supported for the AST used the represent Binary executables.
193177 : if (0 /* isSgAsmNode(this) != NULL */)
193178 : {
193179 : // Support for regex specification.
193180 : std::string prefixCode = "REGEX:";
193181 : addNewAttribute(prefixCode + s,a);
193182 : }
193183 : #endif
193184 :
193185 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
193186 0 : return this;
193187 : }
193188 :
193189 : // *** COMMON CODE SECTION ENDS HERE ***
193190 :
193191 :
193192 : // End of memberFunctionString
193193 : // Start of memberFunctionString
193194 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
193195 :
193196 :
193197 : #if 0
193198 : //! Error checking support
193199 : /*! Verifies the following:
193200 : - working getVariant() member function
193201 : - calls base class's error() member function
193202 : Every class has one of these functions.
193203 : */
193204 : bool
193205 : SgOmpTaskloopStatement::error()
193206 : {
193207 : // Put error checking here
193208 :
193209 : ROSE_ASSERT (this != NULL);
193210 : if (getVariant() != OMP_TASKLOOP_STMT)
193211 : {
193212 : printf ("Error in SgOmpTaskloopStatement::error(): SgOmpTaskloopStatement object has a %s variant \n",
193213 : Cxx_GrammarTerminalNames[getVariant()].name);
193214 : // printf ("Error in SgOmpTaskloopStatement::error() \n");
193215 : ROSE_ABORT();
193216 : }
193217 :
193218 : ROSE_ASSERT (getVariant() == OMP_TASKLOOP_STMT);
193219 : return SgUpirFieldBodyStatement::error();
193220 : }
193221 : #endif
193222 :
193223 :
193224 :
193225 : // End of memberFunctionString
193226 :
193227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
193228 :
193229 2 : SgOmpTaskloopStatement* isSgOmpTaskloopStatement ( SgNode* inputDerivedClassPointer )
193230 : {
193231 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
193232 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
193233 : // So to fix this we return NULL directly when the input is NULL and avoid the
193234 : // dynamic_cast in this case. This is likely a performance improvement as well.
193235 : // return dynamic_cast<SgOmpTaskloopStatement*>(inputDerivedClassPointer);
193236 : // Milind Chabbi (8/28/2013): isSgOmpTaskloopStatement uses table-driven castability instead of c++ default dynamic_cast
193237 : // this improves the running time performance by 10-20%.
193238 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskloopStatement*>(inputDerivedClassPointer);
193239 2 : return IS_SgOmpTaskloopStatement_FAST_MACRO(inputDerivedClassPointer);
193240 : }
193241 :
193242 : // DQ (11/8/2003): Added version of functions taking const pointer
193243 0 : const SgOmpTaskloopStatement* isSgOmpTaskloopStatement ( const SgNode* inputDerivedClassPointer )
193244 : {
193245 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
193246 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
193247 : // So to fix this we return NULL directly when the input is NULL and avoid the
193248 : // dynamic_cast in this case. This is likely a performance improvement as well.
193249 : // return dynamic_cast<const SgOmpTaskloopStatement*>(inputDerivedClassPointer);
193250 : // Milind Chabbi (8/28/2013): isSgOmpTaskloopStatement uses table-driven castability instead of c++ default dynamic_cast
193251 : // this improves the running time performance by 10-20%.
193252 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskloopStatement*>(inputDerivedClassPointer);
193253 0 : return IS_SgOmpTaskloopStatement_FAST_MACRO(inputDerivedClassPointer);
193254 : }
193255 :
193256 :
193257 :
193258 : /* #line 193259 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193259 :
193260 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193261 :
193262 : /**
193263 : \brief Generated destructor
193264 :
193265 : This destructor is automatically generated (by ROSETTA). This destructor
193266 : only frees memory of data members associated with the parts of the current IR node which
193267 : are NOT traversed. Those data members that are part of a traversal can be freed using
193268 : a traversal (calling this destructor on all children in a post-order traversal). Such
193269 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
193270 :
193271 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
193272 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
193273 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
193274 :
193275 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
193276 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
193277 : pointers are not yet implemented to call delete on eash pointer in the container.
193278 : (This could be done by derivation from the STL containers to define containers that
193279 : automatically deleted their members.)
193280 :
193281 : */
193282 0 : SgOmpTaskloopStatement::~SgOmpTaskloopStatement () {
193283 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
193284 :
193285 :
193286 :
193287 : }
193288 :
193289 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193290 0 : }
193291 :
193292 :
193293 : /* #line 193294 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193294 :
193295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
193296 :
193297 : // Generated constructor
193298 2 : SgOmpTaskloopStatement::SgOmpTaskloopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
193299 2 : : SgUpirFieldBodyStatement(startOfConstruct, body)
193300 : {
193301 : #ifdef DEBUG
193302 : // printf ("In SgOmpTaskloopStatement::SgOmpTaskloopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
193303 : #endif
193304 : #if 0
193305 : // debugging information!
193306 : printf ("In SgOmpTaskloopStatement::SgOmpTaskloopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
193307 : #endif
193308 :
193309 :
193310 :
193311 : #if 0
193312 : // DQ (7/30/2014): Call a virtual function.
193313 : std::string s = this->class_name();
193314 : #endif
193315 :
193316 : // Test the variant virtual function
193317 : // assert(OMP_TASKLOOP_STMT == variant());
193318 2 : assert(OMP_TASKLOOP_STMT == this->variant());
193319 2 : ROSE_ASSERT(OMP_TASKLOOP_STMT == (int)(this->variantT()));
193320 2 : post_construction_initialization();
193321 :
193322 : // Test the isSgOmpTaskloopStatement() function since it has been problematic
193323 2 : assert(isSgOmpTaskloopStatement(this) != NULL);
193324 2 : }
193325 :
193326 : // Generated constructor (all data members)
193327 :
193328 : /* #line 193329 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193329 :
193330 :
193331 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193332 :
193333 :
193334 : // ********************************************************
193335 : // member functions common across all array grammar objects
193336 : // ********************************************************
193337 :
193338 :
193339 :
193340 : /* #line 193341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193341 :
193342 :
193343 :
193344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193345 :
193346 : // ********************************************************
193347 : // member functions specific to each node in the grammar
193348 : // ********************************************************
193349 :
193350 :
193351 : /* #line 193352 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193352 :
193353 : // Start of memberFunctionString
193354 : /* #line 19052 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
193355 :
193356 : void
193357 3 : SgOmpDepobjStatement::post_construction_initialization()
193358 3 : {}
193359 :
193360 :
193361 : // End of memberFunctionString
193362 : // Start of memberFunctionString
193363 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
193364 :
193365 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
193366 :
193367 : SgName
193368 6 : SgOmpDepobjStatement::get_name () const
193369 : {
193370 6 : ROSE_ASSERT (this != NULL);
193371 :
193372 : #if 0
193373 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
193374 : // used to trigger marking transformations for the token-based unparsing.
193375 : printf ("SgOmpDepobjStatement::get_name = %p = %s \n",this,this->class_name().c_str());
193376 : #endif
193377 :
193378 6 : return p_name;
193379 : }
193380 :
193381 : void
193382 0 : SgOmpDepobjStatement::set_name ( SgName name )
193383 : {
193384 0 : ROSE_ASSERT (this != NULL);
193385 :
193386 : #if 0
193387 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
193388 : // used to trigger marking transformations for the token-based unparsing.
193389 : printf ("SgOmpDepobjStatement::set_name = %p = %s \n",this,this->class_name().c_str());
193390 : #endif
193391 :
193392 0 : set_isModified(true);
193393 :
193394 0 : p_name = name;
193395 0 : }
193396 :
193397 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
193398 :
193399 :
193400 : // End of memberFunctionString
193401 : // Start of memberFunctionString
193402 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
193403 :
193404 : // *** COMMON CODE SECTION BEGINS HERE ***
193405 :
193406 : #if 0
193407 : int
193408 : SgOmpDepobjStatement::getVariant() const
193409 : {
193410 : // This function is used in ROSE while "variant()" is used in SAGE
193411 : assert(this != NULL);
193412 : return variant();
193413 : }
193414 : #endif
193415 :
193416 : // This function is used in ROSE in treeTraversal code
193417 : // eventually replaces getVariant() and variant()
193418 : // though after variant() has been removed for a while we will
193419 : // want to change the name of variantT() back to variant()
193420 : // (since the "T" was ment to stand for temporary).
193421 : // When this happens the variantT() will be depricated.
193422 : VariantT
193423 256 : SgOmpDepobjStatement::variantT() const
193424 : {
193425 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
193426 256 : ROSE_ASSERT(this != NULL);
193427 256 : return V_SgOmpDepobjStatement;
193428 : }
193429 :
193430 : #if 0
193431 : int
193432 : SgOmpDepobjStatement::variant() const
193433 : {
193434 : // This function is used in SAGE
193435 : ROSE_ASSERT(this != NULL);
193436 : return OMP_DEPOBJ_STMT;
193437 : }
193438 : #endif
193439 :
193440 : ROSE_DLL_API const char*
193441 0 : SgOmpDepobjStatement::sage_class_name() const
193442 : {
193443 0 : ROSE_ASSERT(this != NULL);
193444 0 : return "SgOmpDepobjStatement";
193445 : }
193446 :
193447 : std::string
193448 3 : SgOmpDepobjStatement::class_name() const
193449 : {
193450 3 : ROSE_ASSERT(this != NULL);
193451 3 : return "SgOmpDepobjStatement";
193452 : }
193453 :
193454 : // DQ (11/26/2005): Support for visitor pattern mechanims
193455 : // (inferior to ROSE traversal mechanism, experimental).
193456 : void
193457 0 : SgOmpDepobjStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
193458 : {
193459 0 : ROSE_ASSERT(this != NULL);
193460 0 : visitor.visit(this);
193461 0 : }
193462 :
193463 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
193464 0 : void SgOmpDepobjStatement::accept (ROSE_VisitorPattern & visitor) {
193465 0 : ROSE_ASSERT(this != NULL);
193466 0 : visitor.visit(this);
193467 0 : }
193468 :
193469 : SgOmpDepobjStatement*
193470 0 : SgOmpDepobjStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
193471 : {
193472 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
193473 : // This function is currently only supported for the AST used the represent Binary executables.
193474 : if (0 /* isSgAsmNode(this) != NULL */)
193475 : {
193476 : // Support for regex specification.
193477 : std::string prefixCode = "REGEX:";
193478 : addNewAttribute(prefixCode + s,a);
193479 : }
193480 : #endif
193481 :
193482 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
193483 0 : return this;
193484 : }
193485 :
193486 : // *** COMMON CODE SECTION ENDS HERE ***
193487 :
193488 :
193489 : // End of memberFunctionString
193490 : // Start of memberFunctionString
193491 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
193492 :
193493 :
193494 : #if 0
193495 : //! Error checking support
193496 : /*! Verifies the following:
193497 : - working getVariant() member function
193498 : - calls base class's error() member function
193499 : Every class has one of these functions.
193500 : */
193501 : bool
193502 : SgOmpDepobjStatement::error()
193503 : {
193504 : // Put error checking here
193505 :
193506 : ROSE_ASSERT (this != NULL);
193507 : if (getVariant() != OMP_DEPOBJ_STMT)
193508 : {
193509 : printf ("Error in SgOmpDepobjStatement::error(): SgOmpDepobjStatement object has a %s variant \n",
193510 : Cxx_GrammarTerminalNames[getVariant()].name);
193511 : // printf ("Error in SgOmpDepobjStatement::error() \n");
193512 : ROSE_ABORT();
193513 : }
193514 :
193515 : ROSE_ASSERT (getVariant() == OMP_DEPOBJ_STMT);
193516 : return SgUpirFieldBodyStatement::error();
193517 : }
193518 : #endif
193519 :
193520 :
193521 :
193522 : // End of memberFunctionString
193523 :
193524 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
193525 :
193526 9 : SgOmpDepobjStatement* isSgOmpDepobjStatement ( SgNode* inputDerivedClassPointer )
193527 : {
193528 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
193529 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
193530 : // So to fix this we return NULL directly when the input is NULL and avoid the
193531 : // dynamic_cast in this case. This is likely a performance improvement as well.
193532 : // return dynamic_cast<SgOmpDepobjStatement*>(inputDerivedClassPointer);
193533 : // Milind Chabbi (8/28/2013): isSgOmpDepobjStatement uses table-driven castability instead of c++ default dynamic_cast
193534 : // this improves the running time performance by 10-20%.
193535 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDepobjStatement*>(inputDerivedClassPointer);
193536 9 : return IS_SgOmpDepobjStatement_FAST_MACRO(inputDerivedClassPointer);
193537 : }
193538 :
193539 : // DQ (11/8/2003): Added version of functions taking const pointer
193540 0 : const SgOmpDepobjStatement* isSgOmpDepobjStatement ( const SgNode* inputDerivedClassPointer )
193541 : {
193542 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
193543 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
193544 : // So to fix this we return NULL directly when the input is NULL and avoid the
193545 : // dynamic_cast in this case. This is likely a performance improvement as well.
193546 : // return dynamic_cast<const SgOmpDepobjStatement*>(inputDerivedClassPointer);
193547 : // Milind Chabbi (8/28/2013): isSgOmpDepobjStatement uses table-driven castability instead of c++ default dynamic_cast
193548 : // this improves the running time performance by 10-20%.
193549 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDepobjStatement*>(inputDerivedClassPointer);
193550 0 : return IS_SgOmpDepobjStatement_FAST_MACRO(inputDerivedClassPointer);
193551 : }
193552 :
193553 :
193554 :
193555 : /* #line 193556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193556 :
193557 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193558 :
193559 : /**
193560 : \brief Generated destructor
193561 :
193562 : This destructor is automatically generated (by ROSETTA). This destructor
193563 : only frees memory of data members associated with the parts of the current IR node which
193564 : are NOT traversed. Those data members that are part of a traversal can be freed using
193565 : a traversal (calling this destructor on all children in a post-order traversal). Such
193566 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
193567 :
193568 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
193569 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
193570 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
193571 :
193572 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
193573 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
193574 : pointers are not yet implemented to call delete on eash pointer in the container.
193575 : (This could be done by derivation from the STL containers to define containers that
193576 : automatically deleted their members.)
193577 :
193578 : */
193579 0 : SgOmpDepobjStatement::~SgOmpDepobjStatement () {
193580 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
193581 :
193582 :
193583 : // case: not a listType for name
193584 0 : p_name = ""; // non list case
193585 :
193586 : }
193587 :
193588 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193589 0 : }
193590 :
193591 :
193592 : /* #line 193593 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193593 :
193594 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
193595 :
193596 : // Generated constructor
193597 3 : SgOmpDepobjStatement::SgOmpDepobjStatement ( Sg_File_Info* startOfConstruct, SgStatement* body, SgName name )
193598 3 : : SgUpirFieldBodyStatement(startOfConstruct, body)
193599 : {
193600 : #ifdef DEBUG
193601 : // printf ("In SgOmpDepobjStatement::SgOmpDepobjStatement (Sg_File_Info* startOfConstruct, SgStatement* body, SgName name) sage_class_name() = %s \n",sage_class_name());
193602 : #endif
193603 : #if 0
193604 : // debugging information!
193605 : printf ("In SgOmpDepobjStatement::SgOmpDepobjStatement (Sg_File_Info* startOfConstruct, SgStatement* body, SgName name): this = %p = %s \n",this,this->class_name().c_str());
193606 : #endif
193607 :
193608 3 : p_name = name;
193609 :
193610 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
193611 :
193612 : #if 0
193613 : // DQ (7/30/2014): Call a virtual function.
193614 : std::string s = this->class_name();
193615 : #endif
193616 :
193617 : // Test the variant virtual function
193618 : // assert(OMP_DEPOBJ_STMT == variant());
193619 3 : assert(OMP_DEPOBJ_STMT == this->variant());
193620 3 : ROSE_ASSERT(OMP_DEPOBJ_STMT == (int)(this->variantT()));
193621 3 : post_construction_initialization();
193622 :
193623 : // Test the isSgOmpDepobjStatement() function since it has been problematic
193624 3 : assert(isSgOmpDepobjStatement(this) != NULL);
193625 3 : }
193626 :
193627 : // Generated constructor (all data members)
193628 :
193629 : /* #line 193630 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193630 :
193631 :
193632 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193633 :
193634 :
193635 : // ********************************************************
193636 : // member functions common across all array grammar objects
193637 : // ********************************************************
193638 :
193639 :
193640 :
193641 : /* #line 193642 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193642 :
193643 :
193644 :
193645 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193646 :
193647 : // ********************************************************
193648 : // member functions specific to each node in the grammar
193649 : // ********************************************************
193650 :
193651 :
193652 : /* #line 193653 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193653 :
193654 : // Start of memberFunctionString
193655 : /* #line 19082 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
193656 :
193657 : void
193658 0 : SgOmpTargetEnterDataStatement::post_construction_initialization()
193659 0 : {}
193660 :
193661 :
193662 : // End of memberFunctionString
193663 : // Start of memberFunctionString
193664 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
193665 :
193666 : // *** COMMON CODE SECTION BEGINS HERE ***
193667 :
193668 : #if 0
193669 : int
193670 : SgOmpTargetEnterDataStatement::getVariant() const
193671 : {
193672 : // This function is used in ROSE while "variant()" is used in SAGE
193673 : assert(this != NULL);
193674 : return variant();
193675 : }
193676 : #endif
193677 :
193678 : // This function is used in ROSE in treeTraversal code
193679 : // eventually replaces getVariant() and variant()
193680 : // though after variant() has been removed for a while we will
193681 : // want to change the name of variantT() back to variant()
193682 : // (since the "T" was ment to stand for temporary).
193683 : // When this happens the variantT() will be depricated.
193684 : VariantT
193685 0 : SgOmpTargetEnterDataStatement::variantT() const
193686 : {
193687 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
193688 0 : ROSE_ASSERT(this != NULL);
193689 0 : return V_SgOmpTargetEnterDataStatement;
193690 : }
193691 :
193692 : #if 0
193693 : int
193694 : SgOmpTargetEnterDataStatement::variant() const
193695 : {
193696 : // This function is used in SAGE
193697 : ROSE_ASSERT(this != NULL);
193698 : return OMP_TARGET_ENTER_DATA_STMT;
193699 : }
193700 : #endif
193701 :
193702 : ROSE_DLL_API const char*
193703 0 : SgOmpTargetEnterDataStatement::sage_class_name() const
193704 : {
193705 0 : ROSE_ASSERT(this != NULL);
193706 0 : return "SgOmpTargetEnterDataStatement";
193707 : }
193708 :
193709 : std::string
193710 0 : SgOmpTargetEnterDataStatement::class_name() const
193711 : {
193712 0 : ROSE_ASSERT(this != NULL);
193713 0 : return "SgOmpTargetEnterDataStatement";
193714 : }
193715 :
193716 : // DQ (11/26/2005): Support for visitor pattern mechanims
193717 : // (inferior to ROSE traversal mechanism, experimental).
193718 : void
193719 0 : SgOmpTargetEnterDataStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
193720 : {
193721 0 : ROSE_ASSERT(this != NULL);
193722 0 : visitor.visit(this);
193723 0 : }
193724 :
193725 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
193726 0 : void SgOmpTargetEnterDataStatement::accept (ROSE_VisitorPattern & visitor) {
193727 0 : ROSE_ASSERT(this != NULL);
193728 0 : visitor.visit(this);
193729 0 : }
193730 :
193731 : SgOmpTargetEnterDataStatement*
193732 0 : SgOmpTargetEnterDataStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
193733 : {
193734 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
193735 : // This function is currently only supported for the AST used the represent Binary executables.
193736 : if (0 /* isSgAsmNode(this) != NULL */)
193737 : {
193738 : // Support for regex specification.
193739 : std::string prefixCode = "REGEX:";
193740 : addNewAttribute(prefixCode + s,a);
193741 : }
193742 : #endif
193743 :
193744 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
193745 0 : return this;
193746 : }
193747 :
193748 : // *** COMMON CODE SECTION ENDS HERE ***
193749 :
193750 :
193751 : // End of memberFunctionString
193752 : // Start of memberFunctionString
193753 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
193754 :
193755 :
193756 : #if 0
193757 : //! Error checking support
193758 : /*! Verifies the following:
193759 : - working getVariant() member function
193760 : - calls base class's error() member function
193761 : Every class has one of these functions.
193762 : */
193763 : bool
193764 : SgOmpTargetEnterDataStatement::error()
193765 : {
193766 : // Put error checking here
193767 :
193768 : ROSE_ASSERT (this != NULL);
193769 : if (getVariant() != OMP_TARGET_ENTER_DATA_STMT)
193770 : {
193771 : printf ("Error in SgOmpTargetEnterDataStatement::error(): SgOmpTargetEnterDataStatement object has a %s variant \n",
193772 : Cxx_GrammarTerminalNames[getVariant()].name);
193773 : // printf ("Error in SgOmpTargetEnterDataStatement::error() \n");
193774 : ROSE_ABORT();
193775 : }
193776 :
193777 : ROSE_ASSERT (getVariant() == OMP_TARGET_ENTER_DATA_STMT);
193778 : return SgUpirFieldBodyStatement::error();
193779 : }
193780 : #endif
193781 :
193782 :
193783 :
193784 : // End of memberFunctionString
193785 :
193786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
193787 :
193788 0 : SgOmpTargetEnterDataStatement* isSgOmpTargetEnterDataStatement ( SgNode* inputDerivedClassPointer )
193789 : {
193790 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
193791 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
193792 : // So to fix this we return NULL directly when the input is NULL and avoid the
193793 : // dynamic_cast in this case. This is likely a performance improvement as well.
193794 : // return dynamic_cast<SgOmpTargetEnterDataStatement*>(inputDerivedClassPointer);
193795 : // Milind Chabbi (8/28/2013): isSgOmpTargetEnterDataStatement uses table-driven castability instead of c++ default dynamic_cast
193796 : // this improves the running time performance by 10-20%.
193797 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetEnterDataStatement*>(inputDerivedClassPointer);
193798 0 : return IS_SgOmpTargetEnterDataStatement_FAST_MACRO(inputDerivedClassPointer);
193799 : }
193800 :
193801 : // DQ (11/8/2003): Added version of functions taking const pointer
193802 0 : const SgOmpTargetEnterDataStatement* isSgOmpTargetEnterDataStatement ( const SgNode* inputDerivedClassPointer )
193803 : {
193804 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
193805 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
193806 : // So to fix this we return NULL directly when the input is NULL and avoid the
193807 : // dynamic_cast in this case. This is likely a performance improvement as well.
193808 : // return dynamic_cast<const SgOmpTargetEnterDataStatement*>(inputDerivedClassPointer);
193809 : // Milind Chabbi (8/28/2013): isSgOmpTargetEnterDataStatement uses table-driven castability instead of c++ default dynamic_cast
193810 : // this improves the running time performance by 10-20%.
193811 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetEnterDataStatement*>(inputDerivedClassPointer);
193812 0 : return IS_SgOmpTargetEnterDataStatement_FAST_MACRO(inputDerivedClassPointer);
193813 : }
193814 :
193815 :
193816 :
193817 : /* #line 193818 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193818 :
193819 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193820 :
193821 : /**
193822 : \brief Generated destructor
193823 :
193824 : This destructor is automatically generated (by ROSETTA). This destructor
193825 : only frees memory of data members associated with the parts of the current IR node which
193826 : are NOT traversed. Those data members that are part of a traversal can be freed using
193827 : a traversal (calling this destructor on all children in a post-order traversal). Such
193828 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
193829 :
193830 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
193831 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
193832 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
193833 :
193834 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
193835 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
193836 : pointers are not yet implemented to call delete on eash pointer in the container.
193837 : (This could be done by derivation from the STL containers to define containers that
193838 : automatically deleted their members.)
193839 :
193840 : */
193841 0 : SgOmpTargetEnterDataStatement::~SgOmpTargetEnterDataStatement () {
193842 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
193843 :
193844 :
193845 :
193846 : }
193847 :
193848 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
193849 0 : }
193850 :
193851 :
193852 : /* #line 193853 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193853 :
193854 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
193855 :
193856 : // Generated constructor
193857 0 : SgOmpTargetEnterDataStatement::SgOmpTargetEnterDataStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
193858 0 : : SgUpirFieldBodyStatement(startOfConstruct, body)
193859 : {
193860 : #ifdef DEBUG
193861 : // printf ("In SgOmpTargetEnterDataStatement::SgOmpTargetEnterDataStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
193862 : #endif
193863 : #if 0
193864 : // debugging information!
193865 : printf ("In SgOmpTargetEnterDataStatement::SgOmpTargetEnterDataStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
193866 : #endif
193867 :
193868 :
193869 :
193870 : #if 0
193871 : // DQ (7/30/2014): Call a virtual function.
193872 : std::string s = this->class_name();
193873 : #endif
193874 :
193875 : // Test the variant virtual function
193876 : // assert(OMP_TARGET_ENTER_DATA_STMT == variant());
193877 0 : assert(OMP_TARGET_ENTER_DATA_STMT == this->variant());
193878 0 : ROSE_ASSERT(OMP_TARGET_ENTER_DATA_STMT == (int)(this->variantT()));
193879 0 : post_construction_initialization();
193880 :
193881 : // Test the isSgOmpTargetEnterDataStatement() function since it has been problematic
193882 0 : assert(isSgOmpTargetEnterDataStatement(this) != NULL);
193883 0 : }
193884 :
193885 : // Generated constructor (all data members)
193886 :
193887 : /* #line 193888 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193888 :
193889 :
193890 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193891 :
193892 :
193893 : // ********************************************************
193894 : // member functions common across all array grammar objects
193895 : // ********************************************************
193896 :
193897 :
193898 :
193899 : /* #line 193900 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193900 :
193901 :
193902 :
193903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
193904 :
193905 : // ********************************************************
193906 : // member functions specific to each node in the grammar
193907 : // ********************************************************
193908 :
193909 :
193910 : /* #line 193911 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
193911 :
193912 : // Start of memberFunctionString
193913 : /* #line 19088 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
193914 :
193915 : void
193916 0 : SgOmpTargetExitDataStatement::post_construction_initialization()
193917 0 : {}
193918 :
193919 :
193920 : // End of memberFunctionString
193921 : // Start of memberFunctionString
193922 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
193923 :
193924 : // *** COMMON CODE SECTION BEGINS HERE ***
193925 :
193926 : #if 0
193927 : int
193928 : SgOmpTargetExitDataStatement::getVariant() const
193929 : {
193930 : // This function is used in ROSE while "variant()" is used in SAGE
193931 : assert(this != NULL);
193932 : return variant();
193933 : }
193934 : #endif
193935 :
193936 : // This function is used in ROSE in treeTraversal code
193937 : // eventually replaces getVariant() and variant()
193938 : // though after variant() has been removed for a while we will
193939 : // want to change the name of variantT() back to variant()
193940 : // (since the "T" was ment to stand for temporary).
193941 : // When this happens the variantT() will be depricated.
193942 : VariantT
193943 0 : SgOmpTargetExitDataStatement::variantT() const
193944 : {
193945 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
193946 0 : ROSE_ASSERT(this != NULL);
193947 0 : return V_SgOmpTargetExitDataStatement;
193948 : }
193949 :
193950 : #if 0
193951 : int
193952 : SgOmpTargetExitDataStatement::variant() const
193953 : {
193954 : // This function is used in SAGE
193955 : ROSE_ASSERT(this != NULL);
193956 : return OMP_TARGET_EXIT_DATA_STMT;
193957 : }
193958 : #endif
193959 :
193960 : ROSE_DLL_API const char*
193961 0 : SgOmpTargetExitDataStatement::sage_class_name() const
193962 : {
193963 0 : ROSE_ASSERT(this != NULL);
193964 0 : return "SgOmpTargetExitDataStatement";
193965 : }
193966 :
193967 : std::string
193968 0 : SgOmpTargetExitDataStatement::class_name() const
193969 : {
193970 0 : ROSE_ASSERT(this != NULL);
193971 0 : return "SgOmpTargetExitDataStatement";
193972 : }
193973 :
193974 : // DQ (11/26/2005): Support for visitor pattern mechanims
193975 : // (inferior to ROSE traversal mechanism, experimental).
193976 : void
193977 0 : SgOmpTargetExitDataStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
193978 : {
193979 0 : ROSE_ASSERT(this != NULL);
193980 0 : visitor.visit(this);
193981 0 : }
193982 :
193983 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
193984 0 : void SgOmpTargetExitDataStatement::accept (ROSE_VisitorPattern & visitor) {
193985 0 : ROSE_ASSERT(this != NULL);
193986 0 : visitor.visit(this);
193987 0 : }
193988 :
193989 : SgOmpTargetExitDataStatement*
193990 0 : SgOmpTargetExitDataStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
193991 : {
193992 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
193993 : // This function is currently only supported for the AST used the represent Binary executables.
193994 : if (0 /* isSgAsmNode(this) != NULL */)
193995 : {
193996 : // Support for regex specification.
193997 : std::string prefixCode = "REGEX:";
193998 : addNewAttribute(prefixCode + s,a);
193999 : }
194000 : #endif
194001 :
194002 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
194003 0 : return this;
194004 : }
194005 :
194006 : // *** COMMON CODE SECTION ENDS HERE ***
194007 :
194008 :
194009 : // End of memberFunctionString
194010 : // Start of memberFunctionString
194011 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
194012 :
194013 :
194014 : #if 0
194015 : //! Error checking support
194016 : /*! Verifies the following:
194017 : - working getVariant() member function
194018 : - calls base class's error() member function
194019 : Every class has one of these functions.
194020 : */
194021 : bool
194022 : SgOmpTargetExitDataStatement::error()
194023 : {
194024 : // Put error checking here
194025 :
194026 : ROSE_ASSERT (this != NULL);
194027 : if (getVariant() != OMP_TARGET_EXIT_DATA_STMT)
194028 : {
194029 : printf ("Error in SgOmpTargetExitDataStatement::error(): SgOmpTargetExitDataStatement object has a %s variant \n",
194030 : Cxx_GrammarTerminalNames[getVariant()].name);
194031 : // printf ("Error in SgOmpTargetExitDataStatement::error() \n");
194032 : ROSE_ABORT();
194033 : }
194034 :
194035 : ROSE_ASSERT (getVariant() == OMP_TARGET_EXIT_DATA_STMT);
194036 : return SgUpirFieldBodyStatement::error();
194037 : }
194038 : #endif
194039 :
194040 :
194041 :
194042 : // End of memberFunctionString
194043 :
194044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
194045 :
194046 0 : SgOmpTargetExitDataStatement* isSgOmpTargetExitDataStatement ( SgNode* inputDerivedClassPointer )
194047 : {
194048 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194049 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194050 : // So to fix this we return NULL directly when the input is NULL and avoid the
194051 : // dynamic_cast in this case. This is likely a performance improvement as well.
194052 : // return dynamic_cast<SgOmpTargetExitDataStatement*>(inputDerivedClassPointer);
194053 : // Milind Chabbi (8/28/2013): isSgOmpTargetExitDataStatement uses table-driven castability instead of c++ default dynamic_cast
194054 : // this improves the running time performance by 10-20%.
194055 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetExitDataStatement*>(inputDerivedClassPointer);
194056 0 : return IS_SgOmpTargetExitDataStatement_FAST_MACRO(inputDerivedClassPointer);
194057 : }
194058 :
194059 : // DQ (11/8/2003): Added version of functions taking const pointer
194060 0 : const SgOmpTargetExitDataStatement* isSgOmpTargetExitDataStatement ( const SgNode* inputDerivedClassPointer )
194061 : {
194062 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194063 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194064 : // So to fix this we return NULL directly when the input is NULL and avoid the
194065 : // dynamic_cast in this case. This is likely a performance improvement as well.
194066 : // return dynamic_cast<const SgOmpTargetExitDataStatement*>(inputDerivedClassPointer);
194067 : // Milind Chabbi (8/28/2013): isSgOmpTargetExitDataStatement uses table-driven castability instead of c++ default dynamic_cast
194068 : // this improves the running time performance by 10-20%.
194069 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetExitDataStatement*>(inputDerivedClassPointer);
194070 0 : return IS_SgOmpTargetExitDataStatement_FAST_MACRO(inputDerivedClassPointer);
194071 : }
194072 :
194073 :
194074 :
194075 : /* #line 194076 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194076 :
194077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194078 :
194079 : /**
194080 : \brief Generated destructor
194081 :
194082 : This destructor is automatically generated (by ROSETTA). This destructor
194083 : only frees memory of data members associated with the parts of the current IR node which
194084 : are NOT traversed. Those data members that are part of a traversal can be freed using
194085 : a traversal (calling this destructor on all children in a post-order traversal). Such
194086 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
194087 :
194088 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
194089 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
194090 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
194091 :
194092 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
194093 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
194094 : pointers are not yet implemented to call delete on eash pointer in the container.
194095 : (This could be done by derivation from the STL containers to define containers that
194096 : automatically deleted their members.)
194097 :
194098 : */
194099 0 : SgOmpTargetExitDataStatement::~SgOmpTargetExitDataStatement () {
194100 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
194101 :
194102 :
194103 :
194104 : }
194105 :
194106 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194107 0 : }
194108 :
194109 :
194110 : /* #line 194111 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194111 :
194112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
194113 :
194114 : // Generated constructor
194115 0 : SgOmpTargetExitDataStatement::SgOmpTargetExitDataStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
194116 0 : : SgUpirFieldBodyStatement(startOfConstruct, body)
194117 : {
194118 : #ifdef DEBUG
194119 : // printf ("In SgOmpTargetExitDataStatement::SgOmpTargetExitDataStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
194120 : #endif
194121 : #if 0
194122 : // debugging information!
194123 : printf ("In SgOmpTargetExitDataStatement::SgOmpTargetExitDataStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
194124 : #endif
194125 :
194126 :
194127 :
194128 : #if 0
194129 : // DQ (7/30/2014): Call a virtual function.
194130 : std::string s = this->class_name();
194131 : #endif
194132 :
194133 : // Test the variant virtual function
194134 : // assert(OMP_TARGET_EXIT_DATA_STMT == variant());
194135 0 : assert(OMP_TARGET_EXIT_DATA_STMT == this->variant());
194136 0 : ROSE_ASSERT(OMP_TARGET_EXIT_DATA_STMT == (int)(this->variantT()));
194137 0 : post_construction_initialization();
194138 :
194139 : // Test the isSgOmpTargetExitDataStatement() function since it has been problematic
194140 0 : assert(isSgOmpTargetExitDataStatement(this) != NULL);
194141 0 : }
194142 :
194143 : // Generated constructor (all data members)
194144 :
194145 : /* #line 194146 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194146 :
194147 :
194148 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194149 :
194150 :
194151 : // ********************************************************
194152 : // member functions common across all array grammar objects
194153 : // ********************************************************
194154 :
194155 :
194156 :
194157 : /* #line 194158 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194158 :
194159 :
194160 :
194161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194162 :
194163 : // ********************************************************
194164 : // member functions specific to each node in the grammar
194165 : // ********************************************************
194166 :
194167 :
194168 : /* #line 194169 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194169 :
194170 : // Start of memberFunctionString
194171 : /* #line 19415 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
194172 :
194173 : void
194174 3 : SgOmpParallelMasterStatement::post_construction_initialization()
194175 3 : {}
194176 :
194177 :
194178 : // End of memberFunctionString
194179 : // Start of memberFunctionString
194180 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
194181 :
194182 : // *** COMMON CODE SECTION BEGINS HERE ***
194183 :
194184 : #if 0
194185 : int
194186 : SgOmpParallelMasterStatement::getVariant() const
194187 : {
194188 : // This function is used in ROSE while "variant()" is used in SAGE
194189 : assert(this != NULL);
194190 : return variant();
194191 : }
194192 : #endif
194193 :
194194 : // This function is used in ROSE in treeTraversal code
194195 : // eventually replaces getVariant() and variant()
194196 : // though after variant() has been removed for a while we will
194197 : // want to change the name of variantT() back to variant()
194198 : // (since the "T" was ment to stand for temporary).
194199 : // When this happens the variantT() will be depricated.
194200 : VariantT
194201 245 : SgOmpParallelMasterStatement::variantT() const
194202 : {
194203 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
194204 245 : ROSE_ASSERT(this != NULL);
194205 245 : return V_SgOmpParallelMasterStatement;
194206 : }
194207 :
194208 : #if 0
194209 : int
194210 : SgOmpParallelMasterStatement::variant() const
194211 : {
194212 : // This function is used in SAGE
194213 : ROSE_ASSERT(this != NULL);
194214 : return OMP_PARALLEL_MASTER_STMT;
194215 : }
194216 : #endif
194217 :
194218 : ROSE_DLL_API const char*
194219 0 : SgOmpParallelMasterStatement::sage_class_name() const
194220 : {
194221 0 : ROSE_ASSERT(this != NULL);
194222 0 : return "SgOmpParallelMasterStatement";
194223 : }
194224 :
194225 : std::string
194226 3 : SgOmpParallelMasterStatement::class_name() const
194227 : {
194228 3 : ROSE_ASSERT(this != NULL);
194229 3 : return "SgOmpParallelMasterStatement";
194230 : }
194231 :
194232 : // DQ (11/26/2005): Support for visitor pattern mechanims
194233 : // (inferior to ROSE traversal mechanism, experimental).
194234 : void
194235 0 : SgOmpParallelMasterStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
194236 : {
194237 0 : ROSE_ASSERT(this != NULL);
194238 0 : visitor.visit(this);
194239 0 : }
194240 :
194241 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
194242 0 : void SgOmpParallelMasterStatement::accept (ROSE_VisitorPattern & visitor) {
194243 0 : ROSE_ASSERT(this != NULL);
194244 0 : visitor.visit(this);
194245 0 : }
194246 :
194247 : SgOmpParallelMasterStatement*
194248 0 : SgOmpParallelMasterStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
194249 : {
194250 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
194251 : // This function is currently only supported for the AST used the represent Binary executables.
194252 : if (0 /* isSgAsmNode(this) != NULL */)
194253 : {
194254 : // Support for regex specification.
194255 : std::string prefixCode = "REGEX:";
194256 : addNewAttribute(prefixCode + s,a);
194257 : }
194258 : #endif
194259 :
194260 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
194261 0 : return this;
194262 : }
194263 :
194264 : // *** COMMON CODE SECTION ENDS HERE ***
194265 :
194266 :
194267 : // End of memberFunctionString
194268 : // Start of memberFunctionString
194269 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
194270 :
194271 :
194272 : #if 0
194273 : //! Error checking support
194274 : /*! Verifies the following:
194275 : - working getVariant() member function
194276 : - calls base class's error() member function
194277 : Every class has one of these functions.
194278 : */
194279 : bool
194280 : SgOmpParallelMasterStatement::error()
194281 : {
194282 : // Put error checking here
194283 :
194284 : ROSE_ASSERT (this != NULL);
194285 : if (getVariant() != OMP_PARALLEL_MASTER_STMT)
194286 : {
194287 : printf ("Error in SgOmpParallelMasterStatement::error(): SgOmpParallelMasterStatement object has a %s variant \n",
194288 : Cxx_GrammarTerminalNames[getVariant()].name);
194289 : // printf ("Error in SgOmpParallelMasterStatement::error() \n");
194290 : ROSE_ABORT();
194291 : }
194292 :
194293 : ROSE_ASSERT (getVariant() == OMP_PARALLEL_MASTER_STMT);
194294 : return SgUpirFieldBodyStatement::error();
194295 : }
194296 : #endif
194297 :
194298 :
194299 :
194300 : // End of memberFunctionString
194301 :
194302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
194303 :
194304 3 : SgOmpParallelMasterStatement* isSgOmpParallelMasterStatement ( SgNode* inputDerivedClassPointer )
194305 : {
194306 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194307 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194308 : // So to fix this we return NULL directly when the input is NULL and avoid the
194309 : // dynamic_cast in this case. This is likely a performance improvement as well.
194310 : // return dynamic_cast<SgOmpParallelMasterStatement*>(inputDerivedClassPointer);
194311 : // Milind Chabbi (8/28/2013): isSgOmpParallelMasterStatement uses table-driven castability instead of c++ default dynamic_cast
194312 : // this improves the running time performance by 10-20%.
194313 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpParallelMasterStatement*>(inputDerivedClassPointer);
194314 3 : return IS_SgOmpParallelMasterStatement_FAST_MACRO(inputDerivedClassPointer);
194315 : }
194316 :
194317 : // DQ (11/8/2003): Added version of functions taking const pointer
194318 0 : const SgOmpParallelMasterStatement* isSgOmpParallelMasterStatement ( const SgNode* inputDerivedClassPointer )
194319 : {
194320 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194321 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194322 : // So to fix this we return NULL directly when the input is NULL and avoid the
194323 : // dynamic_cast in this case. This is likely a performance improvement as well.
194324 : // return dynamic_cast<const SgOmpParallelMasterStatement*>(inputDerivedClassPointer);
194325 : // Milind Chabbi (8/28/2013): isSgOmpParallelMasterStatement uses table-driven castability instead of c++ default dynamic_cast
194326 : // this improves the running time performance by 10-20%.
194327 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpParallelMasterStatement*>(inputDerivedClassPointer);
194328 0 : return IS_SgOmpParallelMasterStatement_FAST_MACRO(inputDerivedClassPointer);
194329 : }
194330 :
194331 :
194332 :
194333 : /* #line 194334 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194334 :
194335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194336 :
194337 : /**
194338 : \brief Generated destructor
194339 :
194340 : This destructor is automatically generated (by ROSETTA). This destructor
194341 : only frees memory of data members associated with the parts of the current IR node which
194342 : are NOT traversed. Those data members that are part of a traversal can be freed using
194343 : a traversal (calling this destructor on all children in a post-order traversal). Such
194344 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
194345 :
194346 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
194347 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
194348 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
194349 :
194350 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
194351 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
194352 : pointers are not yet implemented to call delete on eash pointer in the container.
194353 : (This could be done by derivation from the STL containers to define containers that
194354 : automatically deleted their members.)
194355 :
194356 : */
194357 0 : SgOmpParallelMasterStatement::~SgOmpParallelMasterStatement () {
194358 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
194359 :
194360 :
194361 :
194362 : }
194363 :
194364 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194365 0 : }
194366 :
194367 :
194368 : /* #line 194369 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194369 :
194370 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
194371 :
194372 : // Generated constructor
194373 3 : SgOmpParallelMasterStatement::SgOmpParallelMasterStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
194374 3 : : SgUpirFieldBodyStatement(startOfConstruct, body)
194375 : {
194376 : #ifdef DEBUG
194377 : // printf ("In SgOmpParallelMasterStatement::SgOmpParallelMasterStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
194378 : #endif
194379 : #if 0
194380 : // debugging information!
194381 : printf ("In SgOmpParallelMasterStatement::SgOmpParallelMasterStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
194382 : #endif
194383 :
194384 :
194385 :
194386 : #if 0
194387 : // DQ (7/30/2014): Call a virtual function.
194388 : std::string s = this->class_name();
194389 : #endif
194390 :
194391 : // Test the variant virtual function
194392 : // assert(OMP_PARALLEL_MASTER_STMT == variant());
194393 3 : assert(OMP_PARALLEL_MASTER_STMT == this->variant());
194394 3 : ROSE_ASSERT(OMP_PARALLEL_MASTER_STMT == (int)(this->variantT()));
194395 3 : post_construction_initialization();
194396 :
194397 : // Test the isSgOmpParallelMasterStatement() function since it has been problematic
194398 3 : assert(isSgOmpParallelMasterStatement(this) != NULL);
194399 3 : }
194400 :
194401 : // Generated constructor (all data members)
194402 :
194403 : /* #line 194404 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194404 :
194405 :
194406 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194407 :
194408 :
194409 : // ********************************************************
194410 : // member functions common across all array grammar objects
194411 : // ********************************************************
194412 :
194413 :
194414 :
194415 : /* #line 194416 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194416 :
194417 :
194418 :
194419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194420 :
194421 : // ********************************************************
194422 : // member functions specific to each node in the grammar
194423 : // ********************************************************
194424 :
194425 :
194426 : /* #line 194427 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194427 :
194428 : // Start of memberFunctionString
194429 : /* #line 19421 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
194430 :
194431 : void
194432 2 : SgOmpMasterTaskloopStatement::post_construction_initialization()
194433 2 : {}
194434 :
194435 :
194436 : // End of memberFunctionString
194437 : // Start of memberFunctionString
194438 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
194439 :
194440 : // *** COMMON CODE SECTION BEGINS HERE ***
194441 :
194442 : #if 0
194443 : int
194444 : SgOmpMasterTaskloopStatement::getVariant() const
194445 : {
194446 : // This function is used in ROSE while "variant()" is used in SAGE
194447 : assert(this != NULL);
194448 : return variant();
194449 : }
194450 : #endif
194451 :
194452 : // This function is used in ROSE in treeTraversal code
194453 : // eventually replaces getVariant() and variant()
194454 : // though after variant() has been removed for a while we will
194455 : // want to change the name of variantT() back to variant()
194456 : // (since the "T" was ment to stand for temporary).
194457 : // When this happens the variantT() will be depricated.
194458 : VariantT
194459 162 : SgOmpMasterTaskloopStatement::variantT() const
194460 : {
194461 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
194462 162 : ROSE_ASSERT(this != NULL);
194463 162 : return V_SgOmpMasterTaskloopStatement;
194464 : }
194465 :
194466 : #if 0
194467 : int
194468 : SgOmpMasterTaskloopStatement::variant() const
194469 : {
194470 : // This function is used in SAGE
194471 : ROSE_ASSERT(this != NULL);
194472 : return OMP_MASTER_TASKLOOP_STMT;
194473 : }
194474 : #endif
194475 :
194476 : ROSE_DLL_API const char*
194477 0 : SgOmpMasterTaskloopStatement::sage_class_name() const
194478 : {
194479 0 : ROSE_ASSERT(this != NULL);
194480 0 : return "SgOmpMasterTaskloopStatement";
194481 : }
194482 :
194483 : std::string
194484 2 : SgOmpMasterTaskloopStatement::class_name() const
194485 : {
194486 2 : ROSE_ASSERT(this != NULL);
194487 2 : return "SgOmpMasterTaskloopStatement";
194488 : }
194489 :
194490 : // DQ (11/26/2005): Support for visitor pattern mechanims
194491 : // (inferior to ROSE traversal mechanism, experimental).
194492 : void
194493 0 : SgOmpMasterTaskloopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
194494 : {
194495 0 : ROSE_ASSERT(this != NULL);
194496 0 : visitor.visit(this);
194497 0 : }
194498 :
194499 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
194500 0 : void SgOmpMasterTaskloopStatement::accept (ROSE_VisitorPattern & visitor) {
194501 0 : ROSE_ASSERT(this != NULL);
194502 0 : visitor.visit(this);
194503 0 : }
194504 :
194505 : SgOmpMasterTaskloopStatement*
194506 0 : SgOmpMasterTaskloopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
194507 : {
194508 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
194509 : // This function is currently only supported for the AST used the represent Binary executables.
194510 : if (0 /* isSgAsmNode(this) != NULL */)
194511 : {
194512 : // Support for regex specification.
194513 : std::string prefixCode = "REGEX:";
194514 : addNewAttribute(prefixCode + s,a);
194515 : }
194516 : #endif
194517 :
194518 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
194519 0 : return this;
194520 : }
194521 :
194522 : // *** COMMON CODE SECTION ENDS HERE ***
194523 :
194524 :
194525 : // End of memberFunctionString
194526 : // Start of memberFunctionString
194527 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
194528 :
194529 :
194530 : #if 0
194531 : //! Error checking support
194532 : /*! Verifies the following:
194533 : - working getVariant() member function
194534 : - calls base class's error() member function
194535 : Every class has one of these functions.
194536 : */
194537 : bool
194538 : SgOmpMasterTaskloopStatement::error()
194539 : {
194540 : // Put error checking here
194541 :
194542 : ROSE_ASSERT (this != NULL);
194543 : if (getVariant() != OMP_MASTER_TASKLOOP_STMT)
194544 : {
194545 : printf ("Error in SgOmpMasterTaskloopStatement::error(): SgOmpMasterTaskloopStatement object has a %s variant \n",
194546 : Cxx_GrammarTerminalNames[getVariant()].name);
194547 : // printf ("Error in SgOmpMasterTaskloopStatement::error() \n");
194548 : ROSE_ABORT();
194549 : }
194550 :
194551 : ROSE_ASSERT (getVariant() == OMP_MASTER_TASKLOOP_STMT);
194552 : return SgUpirFieldBodyStatement::error();
194553 : }
194554 : #endif
194555 :
194556 :
194557 :
194558 : // End of memberFunctionString
194559 :
194560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
194561 :
194562 2 : SgOmpMasterTaskloopStatement* isSgOmpMasterTaskloopStatement ( SgNode* inputDerivedClassPointer )
194563 : {
194564 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194565 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194566 : // So to fix this we return NULL directly when the input is NULL and avoid the
194567 : // dynamic_cast in this case. This is likely a performance improvement as well.
194568 : // return dynamic_cast<SgOmpMasterTaskloopStatement*>(inputDerivedClassPointer);
194569 : // Milind Chabbi (8/28/2013): isSgOmpMasterTaskloopStatement uses table-driven castability instead of c++ default dynamic_cast
194570 : // this improves the running time performance by 10-20%.
194571 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpMasterTaskloopStatement*>(inputDerivedClassPointer);
194572 2 : return IS_SgOmpMasterTaskloopStatement_FAST_MACRO(inputDerivedClassPointer);
194573 : }
194574 :
194575 : // DQ (11/8/2003): Added version of functions taking const pointer
194576 0 : const SgOmpMasterTaskloopStatement* isSgOmpMasterTaskloopStatement ( const SgNode* inputDerivedClassPointer )
194577 : {
194578 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194579 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194580 : // So to fix this we return NULL directly when the input is NULL and avoid the
194581 : // dynamic_cast in this case. This is likely a performance improvement as well.
194582 : // return dynamic_cast<const SgOmpMasterTaskloopStatement*>(inputDerivedClassPointer);
194583 : // Milind Chabbi (8/28/2013): isSgOmpMasterTaskloopStatement uses table-driven castability instead of c++ default dynamic_cast
194584 : // this improves the running time performance by 10-20%.
194585 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpMasterTaskloopStatement*>(inputDerivedClassPointer);
194586 0 : return IS_SgOmpMasterTaskloopStatement_FAST_MACRO(inputDerivedClassPointer);
194587 : }
194588 :
194589 :
194590 :
194591 : /* #line 194592 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194592 :
194593 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194594 :
194595 : /**
194596 : \brief Generated destructor
194597 :
194598 : This destructor is automatically generated (by ROSETTA). This destructor
194599 : only frees memory of data members associated with the parts of the current IR node which
194600 : are NOT traversed. Those data members that are part of a traversal can be freed using
194601 : a traversal (calling this destructor on all children in a post-order traversal). Such
194602 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
194603 :
194604 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
194605 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
194606 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
194607 :
194608 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
194609 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
194610 : pointers are not yet implemented to call delete on eash pointer in the container.
194611 : (This could be done by derivation from the STL containers to define containers that
194612 : automatically deleted their members.)
194613 :
194614 : */
194615 0 : SgOmpMasterTaskloopStatement::~SgOmpMasterTaskloopStatement () {
194616 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
194617 :
194618 :
194619 :
194620 : }
194621 :
194622 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194623 0 : }
194624 :
194625 :
194626 : /* #line 194627 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194627 :
194628 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
194629 :
194630 : // Generated constructor
194631 2 : SgOmpMasterTaskloopStatement::SgOmpMasterTaskloopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
194632 2 : : SgUpirFieldBodyStatement(startOfConstruct, body)
194633 : {
194634 : #ifdef DEBUG
194635 : // printf ("In SgOmpMasterTaskloopStatement::SgOmpMasterTaskloopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
194636 : #endif
194637 : #if 0
194638 : // debugging information!
194639 : printf ("In SgOmpMasterTaskloopStatement::SgOmpMasterTaskloopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
194640 : #endif
194641 :
194642 :
194643 :
194644 : #if 0
194645 : // DQ (7/30/2014): Call a virtual function.
194646 : std::string s = this->class_name();
194647 : #endif
194648 :
194649 : // Test the variant virtual function
194650 : // assert(OMP_MASTER_TASKLOOP_STMT == variant());
194651 2 : assert(OMP_MASTER_TASKLOOP_STMT == this->variant());
194652 2 : ROSE_ASSERT(OMP_MASTER_TASKLOOP_STMT == (int)(this->variantT()));
194653 2 : post_construction_initialization();
194654 :
194655 : // Test the isSgOmpMasterTaskloopStatement() function since it has been problematic
194656 2 : assert(isSgOmpMasterTaskloopStatement(this) != NULL);
194657 2 : }
194658 :
194659 : // Generated constructor (all data members)
194660 :
194661 : /* #line 194662 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194662 :
194663 :
194664 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194665 :
194666 :
194667 : // ********************************************************
194668 : // member functions common across all array grammar objects
194669 : // ********************************************************
194670 :
194671 :
194672 :
194673 : /* #line 194674 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194674 :
194675 :
194676 :
194677 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194678 :
194679 : // ********************************************************
194680 : // member functions specific to each node in the grammar
194681 : // ********************************************************
194682 :
194683 :
194684 : /* #line 194685 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194685 :
194686 : // Start of memberFunctionString
194687 : /* #line 19495 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
194688 :
194689 : void
194690 74 : SgOmpTaskStatement::post_construction_initialization()
194691 74 : {}
194692 :
194693 :
194694 : // End of memberFunctionString
194695 : // Start of memberFunctionString
194696 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
194697 :
194698 : // *** COMMON CODE SECTION BEGINS HERE ***
194699 :
194700 : #if 0
194701 : int
194702 : SgOmpTaskStatement::getVariant() const
194703 : {
194704 : // This function is used in ROSE while "variant()" is used in SAGE
194705 : assert(this != NULL);
194706 : return variant();
194707 : }
194708 : #endif
194709 :
194710 : // This function is used in ROSE in treeTraversal code
194711 : // eventually replaces getVariant() and variant()
194712 : // though after variant() has been removed for a while we will
194713 : // want to change the name of variantT() back to variant()
194714 : // (since the "T" was ment to stand for temporary).
194715 : // When this happens the variantT() will be depricated.
194716 : VariantT
194717 6783 : SgOmpTaskStatement::variantT() const
194718 : {
194719 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
194720 6783 : ROSE_ASSERT(this != NULL);
194721 6783 : return V_SgOmpTaskStatement;
194722 : }
194723 :
194724 : #if 0
194725 : int
194726 : SgOmpTaskStatement::variant() const
194727 : {
194728 : // This function is used in SAGE
194729 : ROSE_ASSERT(this != NULL);
194730 : return OMP_TASK_STMT;
194731 : }
194732 : #endif
194733 :
194734 : ROSE_DLL_API const char*
194735 0 : SgOmpTaskStatement::sage_class_name() const
194736 : {
194737 0 : ROSE_ASSERT(this != NULL);
194738 0 : return "SgOmpTaskStatement";
194739 : }
194740 :
194741 : std::string
194742 74 : SgOmpTaskStatement::class_name() const
194743 : {
194744 74 : ROSE_ASSERT(this != NULL);
194745 74 : return "SgOmpTaskStatement";
194746 : }
194747 :
194748 : // DQ (11/26/2005): Support for visitor pattern mechanims
194749 : // (inferior to ROSE traversal mechanism, experimental).
194750 : void
194751 0 : SgOmpTaskStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
194752 : {
194753 0 : ROSE_ASSERT(this != NULL);
194754 0 : visitor.visit(this);
194755 0 : }
194756 :
194757 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
194758 0 : void SgOmpTaskStatement::accept (ROSE_VisitorPattern & visitor) {
194759 0 : ROSE_ASSERT(this != NULL);
194760 0 : visitor.visit(this);
194761 0 : }
194762 :
194763 : SgOmpTaskStatement*
194764 0 : SgOmpTaskStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
194765 : {
194766 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
194767 : // This function is currently only supported for the AST used the represent Binary executables.
194768 : if (0 /* isSgAsmNode(this) != NULL */)
194769 : {
194770 : // Support for regex specification.
194771 : std::string prefixCode = "REGEX:";
194772 : addNewAttribute(prefixCode + s,a);
194773 : }
194774 : #endif
194775 :
194776 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
194777 0 : return this;
194778 : }
194779 :
194780 : // *** COMMON CODE SECTION ENDS HERE ***
194781 :
194782 :
194783 : // End of memberFunctionString
194784 : // Start of memberFunctionString
194785 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
194786 :
194787 :
194788 : #if 0
194789 : //! Error checking support
194790 : /*! Verifies the following:
194791 : - working getVariant() member function
194792 : - calls base class's error() member function
194793 : Every class has one of these functions.
194794 : */
194795 : bool
194796 : SgOmpTaskStatement::error()
194797 : {
194798 : // Put error checking here
194799 :
194800 : ROSE_ASSERT (this != NULL);
194801 : if (getVariant() != OMP_TASK_STMT)
194802 : {
194803 : printf ("Error in SgOmpTaskStatement::error(): SgOmpTaskStatement object has a %s variant \n",
194804 : Cxx_GrammarTerminalNames[getVariant()].name);
194805 : // printf ("Error in SgOmpTaskStatement::error() \n");
194806 : ROSE_ABORT();
194807 : }
194808 :
194809 : ROSE_ASSERT (getVariant() == OMP_TASK_STMT);
194810 : return SgUpirFieldBodyStatement::error();
194811 : }
194812 : #endif
194813 :
194814 :
194815 :
194816 : // End of memberFunctionString
194817 :
194818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
194819 :
194820 74 : SgOmpTaskStatement* isSgOmpTaskStatement ( SgNode* inputDerivedClassPointer )
194821 : {
194822 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194823 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194824 : // So to fix this we return NULL directly when the input is NULL and avoid the
194825 : // dynamic_cast in this case. This is likely a performance improvement as well.
194826 : // return dynamic_cast<SgOmpTaskStatement*>(inputDerivedClassPointer);
194827 : // Milind Chabbi (8/28/2013): isSgOmpTaskStatement uses table-driven castability instead of c++ default dynamic_cast
194828 : // this improves the running time performance by 10-20%.
194829 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskStatement*>(inputDerivedClassPointer);
194830 74 : return IS_SgOmpTaskStatement_FAST_MACRO(inputDerivedClassPointer);
194831 : }
194832 :
194833 : // DQ (11/8/2003): Added version of functions taking const pointer
194834 0 : const SgOmpTaskStatement* isSgOmpTaskStatement ( const SgNode* inputDerivedClassPointer )
194835 : {
194836 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
194837 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
194838 : // So to fix this we return NULL directly when the input is NULL and avoid the
194839 : // dynamic_cast in this case. This is likely a performance improvement as well.
194840 : // return dynamic_cast<const SgOmpTaskStatement*>(inputDerivedClassPointer);
194841 : // Milind Chabbi (8/28/2013): isSgOmpTaskStatement uses table-driven castability instead of c++ default dynamic_cast
194842 : // this improves the running time performance by 10-20%.
194843 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskStatement*>(inputDerivedClassPointer);
194844 0 : return IS_SgOmpTaskStatement_FAST_MACRO(inputDerivedClassPointer);
194845 : }
194846 :
194847 :
194848 :
194849 : /* #line 194850 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194850 :
194851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194852 :
194853 : /**
194854 : \brief Generated destructor
194855 :
194856 : This destructor is automatically generated (by ROSETTA). This destructor
194857 : only frees memory of data members associated with the parts of the current IR node which
194858 : are NOT traversed. Those data members that are part of a traversal can be freed using
194859 : a traversal (calling this destructor on all children in a post-order traversal). Such
194860 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
194861 :
194862 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
194863 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
194864 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
194865 :
194866 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
194867 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
194868 : pointers are not yet implemented to call delete on eash pointer in the container.
194869 : (This could be done by derivation from the STL containers to define containers that
194870 : automatically deleted their members.)
194871 :
194872 : */
194873 0 : SgOmpTaskStatement::~SgOmpTaskStatement () {
194874 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
194875 :
194876 :
194877 :
194878 : }
194879 :
194880 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
194881 0 : }
194882 :
194883 :
194884 : /* #line 194885 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194885 :
194886 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
194887 :
194888 : // Generated constructor
194889 74 : SgOmpTaskStatement::SgOmpTaskStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
194890 74 : : SgUpirFieldBodyStatement(startOfConstruct, body)
194891 : {
194892 : #ifdef DEBUG
194893 : // printf ("In SgOmpTaskStatement::SgOmpTaskStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
194894 : #endif
194895 : #if 0
194896 : // debugging information!
194897 : printf ("In SgOmpTaskStatement::SgOmpTaskStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
194898 : #endif
194899 :
194900 :
194901 :
194902 : #if 0
194903 : // DQ (7/30/2014): Call a virtual function.
194904 : std::string s = this->class_name();
194905 : #endif
194906 :
194907 : // Test the variant virtual function
194908 : // assert(OMP_TASK_STMT == variant());
194909 74 : assert(OMP_TASK_STMT == this->variant());
194910 74 : ROSE_ASSERT(OMP_TASK_STMT == (int)(this->variantT()));
194911 74 : post_construction_initialization();
194912 :
194913 : // Test the isSgOmpTaskStatement() function since it has been problematic
194914 74 : assert(isSgOmpTaskStatement(this) != NULL);
194915 74 : }
194916 :
194917 : // Generated constructor (all data members)
194918 :
194919 : /* #line 194920 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194920 :
194921 :
194922 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194923 :
194924 :
194925 : // ********************************************************
194926 : // member functions common across all array grammar objects
194927 : // ********************************************************
194928 :
194929 :
194930 :
194931 : /* #line 194932 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194932 :
194933 :
194934 :
194935 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
194936 :
194937 : // ********************************************************
194938 : // member functions specific to each node in the grammar
194939 : // ********************************************************
194940 :
194941 :
194942 : /* #line 194943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
194943 :
194944 : // Start of memberFunctionString
194945 : /* #line 19149 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
194946 :
194947 : void
194948 12 : SgOmpDoStatement::post_construction_initialization()
194949 12 : {}
194950 :
194951 :
194952 : // End of memberFunctionString
194953 : // Start of memberFunctionString
194954 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
194955 :
194956 : // *** COMMON CODE SECTION BEGINS HERE ***
194957 :
194958 : #if 0
194959 : int
194960 : SgOmpDoStatement::getVariant() const
194961 : {
194962 : // This function is used in ROSE while "variant()" is used in SAGE
194963 : assert(this != NULL);
194964 : return variant();
194965 : }
194966 : #endif
194967 :
194968 : // This function is used in ROSE in treeTraversal code
194969 : // eventually replaces getVariant() and variant()
194970 : // though after variant() has been removed for a while we will
194971 : // want to change the name of variantT() back to variant()
194972 : // (since the "T" was ment to stand for temporary).
194973 : // When this happens the variantT() will be depricated.
194974 : VariantT
194975 968 : SgOmpDoStatement::variantT() const
194976 : {
194977 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
194978 968 : ROSE_ASSERT(this != NULL);
194979 968 : return V_SgOmpDoStatement;
194980 : }
194981 :
194982 : #if 0
194983 : int
194984 : SgOmpDoStatement::variant() const
194985 : {
194986 : // This function is used in SAGE
194987 : ROSE_ASSERT(this != NULL);
194988 : return OMP_DO_STMT;
194989 : }
194990 : #endif
194991 :
194992 : ROSE_DLL_API const char*
194993 0 : SgOmpDoStatement::sage_class_name() const
194994 : {
194995 0 : ROSE_ASSERT(this != NULL);
194996 0 : return "SgOmpDoStatement";
194997 : }
194998 :
194999 : std::string
195000 12 : SgOmpDoStatement::class_name() const
195001 : {
195002 12 : ROSE_ASSERT(this != NULL);
195003 12 : return "SgOmpDoStatement";
195004 : }
195005 :
195006 : // DQ (11/26/2005): Support for visitor pattern mechanims
195007 : // (inferior to ROSE traversal mechanism, experimental).
195008 : void
195009 0 : SgOmpDoStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
195010 : {
195011 0 : ROSE_ASSERT(this != NULL);
195012 0 : visitor.visit(this);
195013 0 : }
195014 :
195015 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
195016 0 : void SgOmpDoStatement::accept (ROSE_VisitorPattern & visitor) {
195017 0 : ROSE_ASSERT(this != NULL);
195018 0 : visitor.visit(this);
195019 0 : }
195020 :
195021 : SgOmpDoStatement*
195022 0 : SgOmpDoStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
195023 : {
195024 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
195025 : // This function is currently only supported for the AST used the represent Binary executables.
195026 : if (0 /* isSgAsmNode(this) != NULL */)
195027 : {
195028 : // Support for regex specification.
195029 : std::string prefixCode = "REGEX:";
195030 : addNewAttribute(prefixCode + s,a);
195031 : }
195032 : #endif
195033 :
195034 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
195035 0 : return this;
195036 : }
195037 :
195038 : // *** COMMON CODE SECTION ENDS HERE ***
195039 :
195040 :
195041 : // End of memberFunctionString
195042 : // Start of memberFunctionString
195043 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
195044 :
195045 :
195046 : #if 0
195047 : //! Error checking support
195048 : /*! Verifies the following:
195049 : - working getVariant() member function
195050 : - calls base class's error() member function
195051 : Every class has one of these functions.
195052 : */
195053 : bool
195054 : SgOmpDoStatement::error()
195055 : {
195056 : // Put error checking here
195057 :
195058 : ROSE_ASSERT (this != NULL);
195059 : if (getVariant() != OMP_DO_STMT)
195060 : {
195061 : printf ("Error in SgOmpDoStatement::error(): SgOmpDoStatement object has a %s variant \n",
195062 : Cxx_GrammarTerminalNames[getVariant()].name);
195063 : // printf ("Error in SgOmpDoStatement::error() \n");
195064 : ROSE_ABORT();
195065 : }
195066 :
195067 : ROSE_ASSERT (getVariant() == OMP_DO_STMT);
195068 : return SgUpirFieldBodyStatement::error();
195069 : }
195070 : #endif
195071 :
195072 :
195073 :
195074 : // End of memberFunctionString
195075 :
195076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
195077 :
195078 24 : SgOmpDoStatement* isSgOmpDoStatement ( SgNode* inputDerivedClassPointer )
195079 : {
195080 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195081 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195082 : // So to fix this we return NULL directly when the input is NULL and avoid the
195083 : // dynamic_cast in this case. This is likely a performance improvement as well.
195084 : // return dynamic_cast<SgOmpDoStatement*>(inputDerivedClassPointer);
195085 : // Milind Chabbi (8/28/2013): isSgOmpDoStatement uses table-driven castability instead of c++ default dynamic_cast
195086 : // this improves the running time performance by 10-20%.
195087 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDoStatement*>(inputDerivedClassPointer);
195088 24 : return IS_SgOmpDoStatement_FAST_MACRO(inputDerivedClassPointer);
195089 : }
195090 :
195091 : // DQ (11/8/2003): Added version of functions taking const pointer
195092 0 : const SgOmpDoStatement* isSgOmpDoStatement ( const SgNode* inputDerivedClassPointer )
195093 : {
195094 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195095 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195096 : // So to fix this we return NULL directly when the input is NULL and avoid the
195097 : // dynamic_cast in this case. This is likely a performance improvement as well.
195098 : // return dynamic_cast<const SgOmpDoStatement*>(inputDerivedClassPointer);
195099 : // Milind Chabbi (8/28/2013): isSgOmpDoStatement uses table-driven castability instead of c++ default dynamic_cast
195100 : // this improves the running time performance by 10-20%.
195101 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDoStatement*>(inputDerivedClassPointer);
195102 0 : return IS_SgOmpDoStatement_FAST_MACRO(inputDerivedClassPointer);
195103 : }
195104 :
195105 :
195106 :
195107 : /* #line 195108 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195108 :
195109 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195110 :
195111 : /**
195112 : \brief Generated destructor
195113 :
195114 : This destructor is automatically generated (by ROSETTA). This destructor
195115 : only frees memory of data members associated with the parts of the current IR node which
195116 : are NOT traversed. Those data members that are part of a traversal can be freed using
195117 : a traversal (calling this destructor on all children in a post-order traversal). Such
195118 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
195119 :
195120 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
195121 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
195122 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
195123 :
195124 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
195125 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
195126 : pointers are not yet implemented to call delete on eash pointer in the container.
195127 : (This could be done by derivation from the STL containers to define containers that
195128 : automatically deleted their members.)
195129 :
195130 : */
195131 0 : SgOmpDoStatement::~SgOmpDoStatement () {
195132 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
195133 :
195134 :
195135 :
195136 : }
195137 :
195138 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195139 0 : }
195140 :
195141 :
195142 : /* #line 195143 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195143 :
195144 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
195145 :
195146 : // Generated constructor
195147 12 : SgOmpDoStatement::SgOmpDoStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
195148 12 : : SgUpirFieldBodyStatement(startOfConstruct, body)
195149 : {
195150 : #ifdef DEBUG
195151 : // printf ("In SgOmpDoStatement::SgOmpDoStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
195152 : #endif
195153 : #if 0
195154 : // debugging information!
195155 : printf ("In SgOmpDoStatement::SgOmpDoStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
195156 : #endif
195157 :
195158 :
195159 :
195160 : #if 0
195161 : // DQ (7/30/2014): Call a virtual function.
195162 : std::string s = this->class_name();
195163 : #endif
195164 :
195165 : // Test the variant virtual function
195166 : // assert(OMP_DO_STMT == variant());
195167 12 : assert(OMP_DO_STMT == this->variant());
195168 12 : ROSE_ASSERT(OMP_DO_STMT == (int)(this->variantT()));
195169 12 : post_construction_initialization();
195170 :
195171 : // Test the isSgOmpDoStatement() function since it has been problematic
195172 12 : assert(isSgOmpDoStatement(this) != NULL);
195173 12 : }
195174 :
195175 : // Generated constructor (all data members)
195176 :
195177 : /* #line 195178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195178 :
195179 :
195180 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195181 :
195182 :
195183 : // ********************************************************
195184 : // member functions common across all array grammar objects
195185 : // ********************************************************
195186 :
195187 :
195188 :
195189 : /* #line 195190 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195190 :
195191 :
195192 :
195193 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195194 :
195195 : // ********************************************************
195196 : // member functions specific to each node in the grammar
195197 : // ********************************************************
195198 :
195199 :
195200 : /* #line 195201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195201 :
195202 : // Start of memberFunctionString
195203 : /* #line 19209 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
195204 :
195205 : void
195206 11 : SgOmpSectionsStatement::post_construction_initialization()
195207 11 : {}
195208 :
195209 :
195210 : // End of memberFunctionString
195211 : // Start of memberFunctionString
195212 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
195213 :
195214 : // *** COMMON CODE SECTION BEGINS HERE ***
195215 :
195216 : #if 0
195217 : int
195218 : SgOmpSectionsStatement::getVariant() const
195219 : {
195220 : // This function is used in ROSE while "variant()" is used in SAGE
195221 : assert(this != NULL);
195222 : return variant();
195223 : }
195224 : #endif
195225 :
195226 : // This function is used in ROSE in treeTraversal code
195227 : // eventually replaces getVariant() and variant()
195228 : // though after variant() has been removed for a while we will
195229 : // want to change the name of variantT() back to variant()
195230 : // (since the "T" was ment to stand for temporary).
195231 : // When this happens the variantT() will be depricated.
195232 : VariantT
195233 923 : SgOmpSectionsStatement::variantT() const
195234 : {
195235 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
195236 923 : ROSE_ASSERT(this != NULL);
195237 923 : return V_SgOmpSectionsStatement;
195238 : }
195239 :
195240 : #if 0
195241 : int
195242 : SgOmpSectionsStatement::variant() const
195243 : {
195244 : // This function is used in SAGE
195245 : ROSE_ASSERT(this != NULL);
195246 : return OMP_SECTIONS_STMT;
195247 : }
195248 : #endif
195249 :
195250 : ROSE_DLL_API const char*
195251 0 : SgOmpSectionsStatement::sage_class_name() const
195252 : {
195253 0 : ROSE_ASSERT(this != NULL);
195254 0 : return "SgOmpSectionsStatement";
195255 : }
195256 :
195257 : std::string
195258 11 : SgOmpSectionsStatement::class_name() const
195259 : {
195260 11 : ROSE_ASSERT(this != NULL);
195261 11 : return "SgOmpSectionsStatement";
195262 : }
195263 :
195264 : // DQ (11/26/2005): Support for visitor pattern mechanims
195265 : // (inferior to ROSE traversal mechanism, experimental).
195266 : void
195267 0 : SgOmpSectionsStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
195268 : {
195269 0 : ROSE_ASSERT(this != NULL);
195270 0 : visitor.visit(this);
195271 0 : }
195272 :
195273 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
195274 0 : void SgOmpSectionsStatement::accept (ROSE_VisitorPattern & visitor) {
195275 0 : ROSE_ASSERT(this != NULL);
195276 0 : visitor.visit(this);
195277 0 : }
195278 :
195279 : SgOmpSectionsStatement*
195280 0 : SgOmpSectionsStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
195281 : {
195282 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
195283 : // This function is currently only supported for the AST used the represent Binary executables.
195284 : if (0 /* isSgAsmNode(this) != NULL */)
195285 : {
195286 : // Support for regex specification.
195287 : std::string prefixCode = "REGEX:";
195288 : addNewAttribute(prefixCode + s,a);
195289 : }
195290 : #endif
195291 :
195292 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
195293 0 : return this;
195294 : }
195295 :
195296 : // *** COMMON CODE SECTION ENDS HERE ***
195297 :
195298 :
195299 : // End of memberFunctionString
195300 : // Start of memberFunctionString
195301 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
195302 :
195303 :
195304 : #if 0
195305 : //! Error checking support
195306 : /*! Verifies the following:
195307 : - working getVariant() member function
195308 : - calls base class's error() member function
195309 : Every class has one of these functions.
195310 : */
195311 : bool
195312 : SgOmpSectionsStatement::error()
195313 : {
195314 : // Put error checking here
195315 :
195316 : ROSE_ASSERT (this != NULL);
195317 : if (getVariant() != OMP_SECTIONS_STMT)
195318 : {
195319 : printf ("Error in SgOmpSectionsStatement::error(): SgOmpSectionsStatement object has a %s variant \n",
195320 : Cxx_GrammarTerminalNames[getVariant()].name);
195321 : // printf ("Error in SgOmpSectionsStatement::error() \n");
195322 : ROSE_ABORT();
195323 : }
195324 :
195325 : ROSE_ASSERT (getVariant() == OMP_SECTIONS_STMT);
195326 : return SgUpirFieldBodyStatement::error();
195327 : }
195328 : #endif
195329 :
195330 :
195331 :
195332 : // End of memberFunctionString
195333 :
195334 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
195335 :
195336 11 : SgOmpSectionsStatement* isSgOmpSectionsStatement ( SgNode* inputDerivedClassPointer )
195337 : {
195338 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195339 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195340 : // So to fix this we return NULL directly when the input is NULL and avoid the
195341 : // dynamic_cast in this case. This is likely a performance improvement as well.
195342 : // return dynamic_cast<SgOmpSectionsStatement*>(inputDerivedClassPointer);
195343 : // Milind Chabbi (8/28/2013): isSgOmpSectionsStatement uses table-driven castability instead of c++ default dynamic_cast
195344 : // this improves the running time performance by 10-20%.
195345 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpSectionsStatement*>(inputDerivedClassPointer);
195346 11 : return IS_SgOmpSectionsStatement_FAST_MACRO(inputDerivedClassPointer);
195347 : }
195348 :
195349 : // DQ (11/8/2003): Added version of functions taking const pointer
195350 0 : const SgOmpSectionsStatement* isSgOmpSectionsStatement ( const SgNode* inputDerivedClassPointer )
195351 : {
195352 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195353 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195354 : // So to fix this we return NULL directly when the input is NULL and avoid the
195355 : // dynamic_cast in this case. This is likely a performance improvement as well.
195356 : // return dynamic_cast<const SgOmpSectionsStatement*>(inputDerivedClassPointer);
195357 : // Milind Chabbi (8/28/2013): isSgOmpSectionsStatement uses table-driven castability instead of c++ default dynamic_cast
195358 : // this improves the running time performance by 10-20%.
195359 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpSectionsStatement*>(inputDerivedClassPointer);
195360 0 : return IS_SgOmpSectionsStatement_FAST_MACRO(inputDerivedClassPointer);
195361 : }
195362 :
195363 :
195364 :
195365 : /* #line 195366 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195366 :
195367 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195368 :
195369 : /**
195370 : \brief Generated destructor
195371 :
195372 : This destructor is automatically generated (by ROSETTA). This destructor
195373 : only frees memory of data members associated with the parts of the current IR node which
195374 : are NOT traversed. Those data members that are part of a traversal can be freed using
195375 : a traversal (calling this destructor on all children in a post-order traversal). Such
195376 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
195377 :
195378 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
195379 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
195380 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
195381 :
195382 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
195383 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
195384 : pointers are not yet implemented to call delete on eash pointer in the container.
195385 : (This could be done by derivation from the STL containers to define containers that
195386 : automatically deleted their members.)
195387 :
195388 : */
195389 0 : SgOmpSectionsStatement::~SgOmpSectionsStatement () {
195390 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
195391 :
195392 :
195393 :
195394 : }
195395 :
195396 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195397 0 : }
195398 :
195399 :
195400 : /* #line 195401 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195401 :
195402 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
195403 :
195404 : // Generated constructor
195405 11 : SgOmpSectionsStatement::SgOmpSectionsStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
195406 11 : : SgUpirFieldBodyStatement(startOfConstruct, body)
195407 : {
195408 : #ifdef DEBUG
195409 : // printf ("In SgOmpSectionsStatement::SgOmpSectionsStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
195410 : #endif
195411 : #if 0
195412 : // debugging information!
195413 : printf ("In SgOmpSectionsStatement::SgOmpSectionsStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
195414 : #endif
195415 :
195416 :
195417 :
195418 : #if 0
195419 : // DQ (7/30/2014): Call a virtual function.
195420 : std::string s = this->class_name();
195421 : #endif
195422 :
195423 : // Test the variant virtual function
195424 : // assert(OMP_SECTIONS_STMT == variant());
195425 11 : assert(OMP_SECTIONS_STMT == this->variant());
195426 11 : ROSE_ASSERT(OMP_SECTIONS_STMT == (int)(this->variantT()));
195427 11 : post_construction_initialization();
195428 :
195429 : // Test the isSgOmpSectionsStatement() function since it has been problematic
195430 11 : assert(isSgOmpSectionsStatement(this) != NULL);
195431 11 : }
195432 :
195433 : // Generated constructor (all data members)
195434 :
195435 : /* #line 195436 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195436 :
195437 :
195438 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195439 :
195440 :
195441 : // ********************************************************
195442 : // member functions common across all array grammar objects
195443 : // ********************************************************
195444 :
195445 :
195446 :
195447 : /* #line 195448 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195448 :
195449 :
195450 :
195451 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195452 :
195453 : // ********************************************************
195454 : // member functions specific to each node in the grammar
195455 : // ********************************************************
195456 :
195457 :
195458 : /* #line 195459 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195459 :
195460 : // Start of memberFunctionString
195461 : /* #line 19215 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
195462 :
195463 : void
195464 24 : SgUpirTaskStatement::post_construction_initialization()
195465 24 : {}
195466 :
195467 :
195468 : // End of memberFunctionString
195469 : // Start of memberFunctionString
195470 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
195471 :
195472 : // *** COMMON CODE SECTION BEGINS HERE ***
195473 :
195474 : #if 0
195475 : int
195476 : SgUpirTaskStatement::getVariant() const
195477 : {
195478 : // This function is used in ROSE while "variant()" is used in SAGE
195479 : assert(this != NULL);
195480 : return variant();
195481 : }
195482 : #endif
195483 :
195484 : // This function is used in ROSE in treeTraversal code
195485 : // eventually replaces getVariant() and variant()
195486 : // though after variant() has been removed for a while we will
195487 : // want to change the name of variantT() back to variant()
195488 : // (since the "T" was ment to stand for temporary).
195489 : // When this happens the variantT() will be depricated.
195490 : VariantT
195491 2006 : SgUpirTaskStatement::variantT() const
195492 : {
195493 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
195494 2006 : ROSE_ASSERT(this != NULL);
195495 2006 : return V_SgUpirTaskStatement;
195496 : }
195497 :
195498 : #if 0
195499 : int
195500 : SgUpirTaskStatement::variant() const
195501 : {
195502 : // This function is used in SAGE
195503 : ROSE_ASSERT(this != NULL);
195504 : return UPIR_TASK_STMT;
195505 : }
195506 : #endif
195507 :
195508 : ROSE_DLL_API const char*
195509 0 : SgUpirTaskStatement::sage_class_name() const
195510 : {
195511 0 : ROSE_ASSERT(this != NULL);
195512 0 : return "SgUpirTaskStatement";
195513 : }
195514 :
195515 : std::string
195516 24 : SgUpirTaskStatement::class_name() const
195517 : {
195518 24 : ROSE_ASSERT(this != NULL);
195519 24 : return "SgUpirTaskStatement";
195520 : }
195521 :
195522 : // DQ (11/26/2005): Support for visitor pattern mechanims
195523 : // (inferior to ROSE traversal mechanism, experimental).
195524 : void
195525 0 : SgUpirTaskStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
195526 : {
195527 0 : ROSE_ASSERT(this != NULL);
195528 0 : visitor.visit(this);
195529 0 : }
195530 :
195531 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
195532 0 : void SgUpirTaskStatement::accept (ROSE_VisitorPattern & visitor) {
195533 0 : ROSE_ASSERT(this != NULL);
195534 0 : visitor.visit(this);
195535 0 : }
195536 :
195537 : SgUpirTaskStatement*
195538 0 : SgUpirTaskStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
195539 : {
195540 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
195541 : // This function is currently only supported for the AST used the represent Binary executables.
195542 : if (0 /* isSgAsmNode(this) != NULL */)
195543 : {
195544 : // Support for regex specification.
195545 : std::string prefixCode = "REGEX:";
195546 : addNewAttribute(prefixCode + s,a);
195547 : }
195548 : #endif
195549 :
195550 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
195551 0 : return this;
195552 : }
195553 :
195554 : // *** COMMON CODE SECTION ENDS HERE ***
195555 :
195556 :
195557 : // End of memberFunctionString
195558 : // Start of memberFunctionString
195559 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
195560 :
195561 :
195562 : #if 0
195563 : //! Error checking support
195564 : /*! Verifies the following:
195565 : - working getVariant() member function
195566 : - calls base class's error() member function
195567 : Every class has one of these functions.
195568 : */
195569 : bool
195570 : SgUpirTaskStatement::error()
195571 : {
195572 : // Put error checking here
195573 :
195574 : ROSE_ASSERT (this != NULL);
195575 : if (getVariant() != UPIR_TASK_STMT)
195576 : {
195577 : printf ("Error in SgUpirTaskStatement::error(): SgUpirTaskStatement object has a %s variant \n",
195578 : Cxx_GrammarTerminalNames[getVariant()].name);
195579 : // printf ("Error in SgUpirTaskStatement::error() \n");
195580 : ROSE_ABORT();
195581 : }
195582 :
195583 : ROSE_ASSERT (getVariant() == UPIR_TASK_STMT);
195584 : return SgUpirFieldBodyStatement::error();
195585 : }
195586 : #endif
195587 :
195588 :
195589 :
195590 : // End of memberFunctionString
195591 :
195592 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
195593 :
195594 24 : SgUpirTaskStatement* isSgUpirTaskStatement ( SgNode* inputDerivedClassPointer )
195595 : {
195596 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195597 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195598 : // So to fix this we return NULL directly when the input is NULL and avoid the
195599 : // dynamic_cast in this case. This is likely a performance improvement as well.
195600 : // return dynamic_cast<SgUpirTaskStatement*>(inputDerivedClassPointer);
195601 : // Milind Chabbi (8/28/2013): isSgUpirTaskStatement uses table-driven castability instead of c++ default dynamic_cast
195602 : // this improves the running time performance by 10-20%.
195603 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirTaskStatement*>(inputDerivedClassPointer);
195604 24 : return IS_SgUpirTaskStatement_FAST_MACRO(inputDerivedClassPointer);
195605 : }
195606 :
195607 : // DQ (11/8/2003): Added version of functions taking const pointer
195608 0 : const SgUpirTaskStatement* isSgUpirTaskStatement ( const SgNode* inputDerivedClassPointer )
195609 : {
195610 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195611 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195612 : // So to fix this we return NULL directly when the input is NULL and avoid the
195613 : // dynamic_cast in this case. This is likely a performance improvement as well.
195614 : // return dynamic_cast<const SgUpirTaskStatement*>(inputDerivedClassPointer);
195615 : // Milind Chabbi (8/28/2013): isSgUpirTaskStatement uses table-driven castability instead of c++ default dynamic_cast
195616 : // this improves the running time performance by 10-20%.
195617 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirTaskStatement*>(inputDerivedClassPointer);
195618 0 : return IS_SgUpirTaskStatement_FAST_MACRO(inputDerivedClassPointer);
195619 : }
195620 :
195621 :
195622 :
195623 : /* #line 195624 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195624 :
195625 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195626 :
195627 : /**
195628 : \brief Generated destructor
195629 :
195630 : This destructor is automatically generated (by ROSETTA). This destructor
195631 : only frees memory of data members associated with the parts of the current IR node which
195632 : are NOT traversed. Those data members that are part of a traversal can be freed using
195633 : a traversal (calling this destructor on all children in a post-order traversal). Such
195634 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
195635 :
195636 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
195637 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
195638 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
195639 :
195640 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
195641 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
195642 : pointers are not yet implemented to call delete on eash pointer in the container.
195643 : (This could be done by derivation from the STL containers to define containers that
195644 : automatically deleted their members.)
195645 :
195646 : */
195647 0 : SgUpirTaskStatement::~SgUpirTaskStatement () {
195648 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
195649 :
195650 :
195651 :
195652 : }
195653 :
195654 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195655 0 : }
195656 :
195657 :
195658 : /* #line 195659 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195659 :
195660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
195661 :
195662 : // Generated constructor
195663 24 : SgUpirTaskStatement::SgUpirTaskStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
195664 24 : : SgUpirFieldBodyStatement(startOfConstruct, body)
195665 : {
195666 : #ifdef DEBUG
195667 : // printf ("In SgUpirTaskStatement::SgUpirTaskStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
195668 : #endif
195669 : #if 0
195670 : // debugging information!
195671 : printf ("In SgUpirTaskStatement::SgUpirTaskStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
195672 : #endif
195673 :
195674 :
195675 :
195676 : #if 0
195677 : // DQ (7/30/2014): Call a virtual function.
195678 : std::string s = this->class_name();
195679 : #endif
195680 :
195681 : // Test the variant virtual function
195682 : // assert(UPIR_TASK_STMT == variant());
195683 24 : assert(UPIR_TASK_STMT == this->variant());
195684 24 : ROSE_ASSERT(UPIR_TASK_STMT == (int)(this->variantT()));
195685 24 : post_construction_initialization();
195686 :
195687 : // Test the isSgUpirTaskStatement() function since it has been problematic
195688 24 : assert(isSgUpirTaskStatement(this) != NULL);
195689 24 : }
195690 :
195691 : // Generated constructor (all data members)
195692 :
195693 : /* #line 195694 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195694 :
195695 :
195696 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195697 :
195698 :
195699 : // ********************************************************
195700 : // member functions common across all array grammar objects
195701 : // ********************************************************
195702 :
195703 :
195704 :
195705 : /* #line 195706 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195706 :
195707 :
195708 :
195709 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195710 :
195711 : // ********************************************************
195712 : // member functions specific to each node in the grammar
195713 : // ********************************************************
195714 :
195715 :
195716 : /* #line 195717 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195717 :
195718 : // Start of memberFunctionString
195719 : /* #line 19433 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
195720 :
195721 : void
195722 7 : SgOmpTargetDataStatement::post_construction_initialization()
195723 7 : {}
195724 :
195725 :
195726 : // End of memberFunctionString
195727 : // Start of memberFunctionString
195728 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
195729 :
195730 : // *** COMMON CODE SECTION BEGINS HERE ***
195731 :
195732 : #if 0
195733 : int
195734 : SgOmpTargetDataStatement::getVariant() const
195735 : {
195736 : // This function is used in ROSE while "variant()" is used in SAGE
195737 : assert(this != NULL);
195738 : return variant();
195739 : }
195740 : #endif
195741 :
195742 : // This function is used in ROSE in treeTraversal code
195743 : // eventually replaces getVariant() and variant()
195744 : // though after variant() has been removed for a while we will
195745 : // want to change the name of variantT() back to variant()
195746 : // (since the "T" was ment to stand for temporary).
195747 : // When this happens the variantT() will be depricated.
195748 : VariantT
195749 617 : SgOmpTargetDataStatement::variantT() const
195750 : {
195751 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
195752 617 : ROSE_ASSERT(this != NULL);
195753 617 : return V_SgOmpTargetDataStatement;
195754 : }
195755 :
195756 : #if 0
195757 : int
195758 : SgOmpTargetDataStatement::variant() const
195759 : {
195760 : // This function is used in SAGE
195761 : ROSE_ASSERT(this != NULL);
195762 : return OMP_TARGET_DATA_STMT;
195763 : }
195764 : #endif
195765 :
195766 : ROSE_DLL_API const char*
195767 0 : SgOmpTargetDataStatement::sage_class_name() const
195768 : {
195769 0 : ROSE_ASSERT(this != NULL);
195770 0 : return "SgOmpTargetDataStatement";
195771 : }
195772 :
195773 : std::string
195774 7 : SgOmpTargetDataStatement::class_name() const
195775 : {
195776 7 : ROSE_ASSERT(this != NULL);
195777 7 : return "SgOmpTargetDataStatement";
195778 : }
195779 :
195780 : // DQ (11/26/2005): Support for visitor pattern mechanims
195781 : // (inferior to ROSE traversal mechanism, experimental).
195782 : void
195783 0 : SgOmpTargetDataStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
195784 : {
195785 0 : ROSE_ASSERT(this != NULL);
195786 0 : visitor.visit(this);
195787 0 : }
195788 :
195789 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
195790 0 : void SgOmpTargetDataStatement::accept (ROSE_VisitorPattern & visitor) {
195791 0 : ROSE_ASSERT(this != NULL);
195792 0 : visitor.visit(this);
195793 0 : }
195794 :
195795 : SgOmpTargetDataStatement*
195796 0 : SgOmpTargetDataStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
195797 : {
195798 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
195799 : // This function is currently only supported for the AST used the represent Binary executables.
195800 : if (0 /* isSgAsmNode(this) != NULL */)
195801 : {
195802 : // Support for regex specification.
195803 : std::string prefixCode = "REGEX:";
195804 : addNewAttribute(prefixCode + s,a);
195805 : }
195806 : #endif
195807 :
195808 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
195809 0 : return this;
195810 : }
195811 :
195812 : // *** COMMON CODE SECTION ENDS HERE ***
195813 :
195814 :
195815 : // End of memberFunctionString
195816 : // Start of memberFunctionString
195817 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
195818 :
195819 :
195820 : #if 0
195821 : //! Error checking support
195822 : /*! Verifies the following:
195823 : - working getVariant() member function
195824 : - calls base class's error() member function
195825 : Every class has one of these functions.
195826 : */
195827 : bool
195828 : SgOmpTargetDataStatement::error()
195829 : {
195830 : // Put error checking here
195831 :
195832 : ROSE_ASSERT (this != NULL);
195833 : if (getVariant() != OMP_TARGET_DATA_STMT)
195834 : {
195835 : printf ("Error in SgOmpTargetDataStatement::error(): SgOmpTargetDataStatement object has a %s variant \n",
195836 : Cxx_GrammarTerminalNames[getVariant()].name);
195837 : // printf ("Error in SgOmpTargetDataStatement::error() \n");
195838 : ROSE_ABORT();
195839 : }
195840 :
195841 : ROSE_ASSERT (getVariant() == OMP_TARGET_DATA_STMT);
195842 : return SgUpirFieldBodyStatement::error();
195843 : }
195844 : #endif
195845 :
195846 :
195847 :
195848 : // End of memberFunctionString
195849 :
195850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
195851 :
195852 7 : SgOmpTargetDataStatement* isSgOmpTargetDataStatement ( SgNode* inputDerivedClassPointer )
195853 : {
195854 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195855 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195856 : // So to fix this we return NULL directly when the input is NULL and avoid the
195857 : // dynamic_cast in this case. This is likely a performance improvement as well.
195858 : // return dynamic_cast<SgOmpTargetDataStatement*>(inputDerivedClassPointer);
195859 : // Milind Chabbi (8/28/2013): isSgOmpTargetDataStatement uses table-driven castability instead of c++ default dynamic_cast
195860 : // this improves the running time performance by 10-20%.
195861 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetDataStatement*>(inputDerivedClassPointer);
195862 7 : return IS_SgOmpTargetDataStatement_FAST_MACRO(inputDerivedClassPointer);
195863 : }
195864 :
195865 : // DQ (11/8/2003): Added version of functions taking const pointer
195866 0 : const SgOmpTargetDataStatement* isSgOmpTargetDataStatement ( const SgNode* inputDerivedClassPointer )
195867 : {
195868 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
195869 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
195870 : // So to fix this we return NULL directly when the input is NULL and avoid the
195871 : // dynamic_cast in this case. This is likely a performance improvement as well.
195872 : // return dynamic_cast<const SgOmpTargetDataStatement*>(inputDerivedClassPointer);
195873 : // Milind Chabbi (8/28/2013): isSgOmpTargetDataStatement uses table-driven castability instead of c++ default dynamic_cast
195874 : // this improves the running time performance by 10-20%.
195875 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetDataStatement*>(inputDerivedClassPointer);
195876 0 : return IS_SgOmpTargetDataStatement_FAST_MACRO(inputDerivedClassPointer);
195877 : }
195878 :
195879 :
195880 :
195881 : /* #line 195882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195882 :
195883 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195884 :
195885 : /**
195886 : \brief Generated destructor
195887 :
195888 : This destructor is automatically generated (by ROSETTA). This destructor
195889 : only frees memory of data members associated with the parts of the current IR node which
195890 : are NOT traversed. Those data members that are part of a traversal can be freed using
195891 : a traversal (calling this destructor on all children in a post-order traversal). Such
195892 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
195893 :
195894 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
195895 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
195896 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
195897 :
195898 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
195899 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
195900 : pointers are not yet implemented to call delete on eash pointer in the container.
195901 : (This could be done by derivation from the STL containers to define containers that
195902 : automatically deleted their members.)
195903 :
195904 : */
195905 0 : SgOmpTargetDataStatement::~SgOmpTargetDataStatement () {
195906 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
195907 :
195908 :
195909 :
195910 : }
195911 :
195912 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
195913 0 : }
195914 :
195915 :
195916 : /* #line 195917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195917 :
195918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
195919 :
195920 : // Generated constructor
195921 7 : SgOmpTargetDataStatement::SgOmpTargetDataStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
195922 7 : : SgUpirFieldBodyStatement(startOfConstruct, body)
195923 : {
195924 : #ifdef DEBUG
195925 : // printf ("In SgOmpTargetDataStatement::SgOmpTargetDataStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
195926 : #endif
195927 : #if 0
195928 : // debugging information!
195929 : printf ("In SgOmpTargetDataStatement::SgOmpTargetDataStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
195930 : #endif
195931 :
195932 :
195933 :
195934 : #if 0
195935 : // DQ (7/30/2014): Call a virtual function.
195936 : std::string s = this->class_name();
195937 : #endif
195938 :
195939 : // Test the variant virtual function
195940 : // assert(OMP_TARGET_DATA_STMT == variant());
195941 7 : assert(OMP_TARGET_DATA_STMT == this->variant());
195942 7 : ROSE_ASSERT(OMP_TARGET_DATA_STMT == (int)(this->variantT()));
195943 7 : post_construction_initialization();
195944 :
195945 : // Test the isSgOmpTargetDataStatement() function since it has been problematic
195946 7 : assert(isSgOmpTargetDataStatement(this) != NULL);
195947 7 : }
195948 :
195949 : // Generated constructor (all data members)
195950 :
195951 : /* #line 195952 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195952 :
195953 :
195954 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195955 :
195956 :
195957 : // ********************************************************
195958 : // member functions common across all array grammar objects
195959 : // ********************************************************
195960 :
195961 :
195962 :
195963 : /* #line 195964 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195964 :
195965 :
195966 :
195967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
195968 :
195969 : // ********************************************************
195970 : // member functions specific to each node in the grammar
195971 : // ********************************************************
195972 :
195973 :
195974 : /* #line 195975 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
195975 :
195976 : // Start of memberFunctionString
195977 : /* #line 19221 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
195978 :
195979 : void
195980 0 : SgOmpTargetParallelForStatement::post_construction_initialization()
195981 0 : {}
195982 :
195983 :
195984 : // End of memberFunctionString
195985 : // Start of memberFunctionString
195986 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
195987 :
195988 : // *** COMMON CODE SECTION BEGINS HERE ***
195989 :
195990 : #if 0
195991 : int
195992 : SgOmpTargetParallelForStatement::getVariant() const
195993 : {
195994 : // This function is used in ROSE while "variant()" is used in SAGE
195995 : assert(this != NULL);
195996 : return variant();
195997 : }
195998 : #endif
195999 :
196000 : // This function is used in ROSE in treeTraversal code
196001 : // eventually replaces getVariant() and variant()
196002 : // though after variant() has been removed for a while we will
196003 : // want to change the name of variantT() back to variant()
196004 : // (since the "T" was ment to stand for temporary).
196005 : // When this happens the variantT() will be depricated.
196006 : VariantT
196007 0 : SgOmpTargetParallelForStatement::variantT() const
196008 : {
196009 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
196010 0 : ROSE_ASSERT(this != NULL);
196011 0 : return V_SgOmpTargetParallelForStatement;
196012 : }
196013 :
196014 : #if 0
196015 : int
196016 : SgOmpTargetParallelForStatement::variant() const
196017 : {
196018 : // This function is used in SAGE
196019 : ROSE_ASSERT(this != NULL);
196020 : return OMP_TARGET_PARALLEL_FOR_STMT;
196021 : }
196022 : #endif
196023 :
196024 : ROSE_DLL_API const char*
196025 0 : SgOmpTargetParallelForStatement::sage_class_name() const
196026 : {
196027 0 : ROSE_ASSERT(this != NULL);
196028 0 : return "SgOmpTargetParallelForStatement";
196029 : }
196030 :
196031 : std::string
196032 0 : SgOmpTargetParallelForStatement::class_name() const
196033 : {
196034 0 : ROSE_ASSERT(this != NULL);
196035 0 : return "SgOmpTargetParallelForStatement";
196036 : }
196037 :
196038 : // DQ (11/26/2005): Support for visitor pattern mechanims
196039 : // (inferior to ROSE traversal mechanism, experimental).
196040 : void
196041 0 : SgOmpTargetParallelForStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
196042 : {
196043 0 : ROSE_ASSERT(this != NULL);
196044 0 : visitor.visit(this);
196045 0 : }
196046 :
196047 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
196048 0 : void SgOmpTargetParallelForStatement::accept (ROSE_VisitorPattern & visitor) {
196049 0 : ROSE_ASSERT(this != NULL);
196050 0 : visitor.visit(this);
196051 0 : }
196052 :
196053 : SgOmpTargetParallelForStatement*
196054 0 : SgOmpTargetParallelForStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
196055 : {
196056 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
196057 : // This function is currently only supported for the AST used the represent Binary executables.
196058 : if (0 /* isSgAsmNode(this) != NULL */)
196059 : {
196060 : // Support for regex specification.
196061 : std::string prefixCode = "REGEX:";
196062 : addNewAttribute(prefixCode + s,a);
196063 : }
196064 : #endif
196065 :
196066 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
196067 0 : return this;
196068 : }
196069 :
196070 : // *** COMMON CODE SECTION ENDS HERE ***
196071 :
196072 :
196073 : // End of memberFunctionString
196074 : // Start of memberFunctionString
196075 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
196076 :
196077 :
196078 : #if 0
196079 : //! Error checking support
196080 : /*! Verifies the following:
196081 : - working getVariant() member function
196082 : - calls base class's error() member function
196083 : Every class has one of these functions.
196084 : */
196085 : bool
196086 : SgOmpTargetParallelForStatement::error()
196087 : {
196088 : // Put error checking here
196089 :
196090 : ROSE_ASSERT (this != NULL);
196091 : if (getVariant() != OMP_TARGET_PARALLEL_FOR_STMT)
196092 : {
196093 : printf ("Error in SgOmpTargetParallelForStatement::error(): SgOmpTargetParallelForStatement object has a %s variant \n",
196094 : Cxx_GrammarTerminalNames[getVariant()].name);
196095 : // printf ("Error in SgOmpTargetParallelForStatement::error() \n");
196096 : ROSE_ABORT();
196097 : }
196098 :
196099 : ROSE_ASSERT (getVariant() == OMP_TARGET_PARALLEL_FOR_STMT);
196100 : return SgUpirFieldBodyStatement::error();
196101 : }
196102 : #endif
196103 :
196104 :
196105 :
196106 : // End of memberFunctionString
196107 :
196108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
196109 :
196110 0 : SgOmpTargetParallelForStatement* isSgOmpTargetParallelForStatement ( SgNode* inputDerivedClassPointer )
196111 : {
196112 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196113 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196114 : // So to fix this we return NULL directly when the input is NULL and avoid the
196115 : // dynamic_cast in this case. This is likely a performance improvement as well.
196116 : // return dynamic_cast<SgOmpTargetParallelForStatement*>(inputDerivedClassPointer);
196117 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
196118 : // this improves the running time performance by 10-20%.
196119 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetParallelForStatement*>(inputDerivedClassPointer);
196120 0 : return IS_SgOmpTargetParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
196121 : }
196122 :
196123 : // DQ (11/8/2003): Added version of functions taking const pointer
196124 0 : const SgOmpTargetParallelForStatement* isSgOmpTargetParallelForStatement ( const SgNode* inputDerivedClassPointer )
196125 : {
196126 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196127 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196128 : // So to fix this we return NULL directly when the input is NULL and avoid the
196129 : // dynamic_cast in this case. This is likely a performance improvement as well.
196130 : // return dynamic_cast<const SgOmpTargetParallelForStatement*>(inputDerivedClassPointer);
196131 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
196132 : // this improves the running time performance by 10-20%.
196133 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetParallelForStatement*>(inputDerivedClassPointer);
196134 0 : return IS_SgOmpTargetParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
196135 : }
196136 :
196137 :
196138 :
196139 : /* #line 196140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196140 :
196141 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196142 :
196143 : /**
196144 : \brief Generated destructor
196145 :
196146 : This destructor is automatically generated (by ROSETTA). This destructor
196147 : only frees memory of data members associated with the parts of the current IR node which
196148 : are NOT traversed. Those data members that are part of a traversal can be freed using
196149 : a traversal (calling this destructor on all children in a post-order traversal). Such
196150 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
196151 :
196152 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
196153 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
196154 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
196155 :
196156 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
196157 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
196158 : pointers are not yet implemented to call delete on eash pointer in the container.
196159 : (This could be done by derivation from the STL containers to define containers that
196160 : automatically deleted their members.)
196161 :
196162 : */
196163 0 : SgOmpTargetParallelForStatement::~SgOmpTargetParallelForStatement () {
196164 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
196165 :
196166 :
196167 :
196168 : }
196169 :
196170 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196171 0 : }
196172 :
196173 :
196174 : /* #line 196175 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196175 :
196176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
196177 :
196178 : // Generated constructor
196179 0 : SgOmpTargetParallelForStatement::SgOmpTargetParallelForStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
196180 0 : : SgUpirFieldBodyStatement(startOfConstruct, body)
196181 : {
196182 : #ifdef DEBUG
196183 : // printf ("In SgOmpTargetParallelForStatement::SgOmpTargetParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
196184 : #endif
196185 : #if 0
196186 : // debugging information!
196187 : printf ("In SgOmpTargetParallelForStatement::SgOmpTargetParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
196188 : #endif
196189 :
196190 :
196191 :
196192 : #if 0
196193 : // DQ (7/30/2014): Call a virtual function.
196194 : std::string s = this->class_name();
196195 : #endif
196196 :
196197 : // Test the variant virtual function
196198 : // assert(OMP_TARGET_PARALLEL_FOR_STMT == variant());
196199 0 : assert(OMP_TARGET_PARALLEL_FOR_STMT == this->variant());
196200 0 : ROSE_ASSERT(OMP_TARGET_PARALLEL_FOR_STMT == (int)(this->variantT()));
196201 0 : post_construction_initialization();
196202 :
196203 : // Test the isSgOmpTargetParallelForStatement() function since it has been problematic
196204 0 : assert(isSgOmpTargetParallelForStatement(this) != NULL);
196205 0 : }
196206 :
196207 : // Generated constructor (all data members)
196208 :
196209 : /* #line 196210 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196210 :
196211 :
196212 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196213 :
196214 :
196215 : // ********************************************************
196216 : // member functions common across all array grammar objects
196217 : // ********************************************************
196218 :
196219 :
196220 :
196221 : /* #line 196222 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196222 :
196223 :
196224 :
196225 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196226 :
196227 : // ********************************************************
196228 : // member functions specific to each node in the grammar
196229 : // ********************************************************
196230 :
196231 :
196232 : /* #line 196233 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196233 :
196234 : // Start of memberFunctionString
196235 : /* #line 19427 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
196236 :
196237 : void
196238 1 : SgOmpParallelLoopStatement::post_construction_initialization()
196239 1 : {}
196240 :
196241 :
196242 : // End of memberFunctionString
196243 : // Start of memberFunctionString
196244 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
196245 :
196246 : // *** COMMON CODE SECTION BEGINS HERE ***
196247 :
196248 : #if 0
196249 : int
196250 : SgOmpParallelLoopStatement::getVariant() const
196251 : {
196252 : // This function is used in ROSE while "variant()" is used in SAGE
196253 : assert(this != NULL);
196254 : return variant();
196255 : }
196256 : #endif
196257 :
196258 : // This function is used in ROSE in treeTraversal code
196259 : // eventually replaces getVariant() and variant()
196260 : // though after variant() has been removed for a while we will
196261 : // want to change the name of variantT() back to variant()
196262 : // (since the "T" was ment to stand for temporary).
196263 : // When this happens the variantT() will be depricated.
196264 : VariantT
196265 81 : SgOmpParallelLoopStatement::variantT() const
196266 : {
196267 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
196268 81 : ROSE_ASSERT(this != NULL);
196269 81 : return V_SgOmpParallelLoopStatement;
196270 : }
196271 :
196272 : #if 0
196273 : int
196274 : SgOmpParallelLoopStatement::variant() const
196275 : {
196276 : // This function is used in SAGE
196277 : ROSE_ASSERT(this != NULL);
196278 : return OMP_PARALLEL_LOOP_STMT;
196279 : }
196280 : #endif
196281 :
196282 : ROSE_DLL_API const char*
196283 0 : SgOmpParallelLoopStatement::sage_class_name() const
196284 : {
196285 0 : ROSE_ASSERT(this != NULL);
196286 0 : return "SgOmpParallelLoopStatement";
196287 : }
196288 :
196289 : std::string
196290 1 : SgOmpParallelLoopStatement::class_name() const
196291 : {
196292 1 : ROSE_ASSERT(this != NULL);
196293 1 : return "SgOmpParallelLoopStatement";
196294 : }
196295 :
196296 : // DQ (11/26/2005): Support for visitor pattern mechanims
196297 : // (inferior to ROSE traversal mechanism, experimental).
196298 : void
196299 0 : SgOmpParallelLoopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
196300 : {
196301 0 : ROSE_ASSERT(this != NULL);
196302 0 : visitor.visit(this);
196303 0 : }
196304 :
196305 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
196306 0 : void SgOmpParallelLoopStatement::accept (ROSE_VisitorPattern & visitor) {
196307 0 : ROSE_ASSERT(this != NULL);
196308 0 : visitor.visit(this);
196309 0 : }
196310 :
196311 : SgOmpParallelLoopStatement*
196312 0 : SgOmpParallelLoopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
196313 : {
196314 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
196315 : // This function is currently only supported for the AST used the represent Binary executables.
196316 : if (0 /* isSgAsmNode(this) != NULL */)
196317 : {
196318 : // Support for regex specification.
196319 : std::string prefixCode = "REGEX:";
196320 : addNewAttribute(prefixCode + s,a);
196321 : }
196322 : #endif
196323 :
196324 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
196325 0 : return this;
196326 : }
196327 :
196328 : // *** COMMON CODE SECTION ENDS HERE ***
196329 :
196330 :
196331 : // End of memberFunctionString
196332 : // Start of memberFunctionString
196333 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
196334 :
196335 :
196336 : #if 0
196337 : //! Error checking support
196338 : /*! Verifies the following:
196339 : - working getVariant() member function
196340 : - calls base class's error() member function
196341 : Every class has one of these functions.
196342 : */
196343 : bool
196344 : SgOmpParallelLoopStatement::error()
196345 : {
196346 : // Put error checking here
196347 :
196348 : ROSE_ASSERT (this != NULL);
196349 : if (getVariant() != OMP_PARALLEL_LOOP_STMT)
196350 : {
196351 : printf ("Error in SgOmpParallelLoopStatement::error(): SgOmpParallelLoopStatement object has a %s variant \n",
196352 : Cxx_GrammarTerminalNames[getVariant()].name);
196353 : // printf ("Error in SgOmpParallelLoopStatement::error() \n");
196354 : ROSE_ABORT();
196355 : }
196356 :
196357 : ROSE_ASSERT (getVariant() == OMP_PARALLEL_LOOP_STMT);
196358 : return SgUpirFieldBodyStatement::error();
196359 : }
196360 : #endif
196361 :
196362 :
196363 :
196364 : // End of memberFunctionString
196365 :
196366 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
196367 :
196368 1 : SgOmpParallelLoopStatement* isSgOmpParallelLoopStatement ( SgNode* inputDerivedClassPointer )
196369 : {
196370 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196371 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196372 : // So to fix this we return NULL directly when the input is NULL and avoid the
196373 : // dynamic_cast in this case. This is likely a performance improvement as well.
196374 : // return dynamic_cast<SgOmpParallelLoopStatement*>(inputDerivedClassPointer);
196375 : // Milind Chabbi (8/28/2013): isSgOmpParallelLoopStatement uses table-driven castability instead of c++ default dynamic_cast
196376 : // this improves the running time performance by 10-20%.
196377 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpParallelLoopStatement*>(inputDerivedClassPointer);
196378 1 : return IS_SgOmpParallelLoopStatement_FAST_MACRO(inputDerivedClassPointer);
196379 : }
196380 :
196381 : // DQ (11/8/2003): Added version of functions taking const pointer
196382 0 : const SgOmpParallelLoopStatement* isSgOmpParallelLoopStatement ( const SgNode* inputDerivedClassPointer )
196383 : {
196384 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196385 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196386 : // So to fix this we return NULL directly when the input is NULL and avoid the
196387 : // dynamic_cast in this case. This is likely a performance improvement as well.
196388 : // return dynamic_cast<const SgOmpParallelLoopStatement*>(inputDerivedClassPointer);
196389 : // Milind Chabbi (8/28/2013): isSgOmpParallelLoopStatement uses table-driven castability instead of c++ default dynamic_cast
196390 : // this improves the running time performance by 10-20%.
196391 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpParallelLoopStatement*>(inputDerivedClassPointer);
196392 0 : return IS_SgOmpParallelLoopStatement_FAST_MACRO(inputDerivedClassPointer);
196393 : }
196394 :
196395 :
196396 :
196397 : /* #line 196398 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196398 :
196399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196400 :
196401 : /**
196402 : \brief Generated destructor
196403 :
196404 : This destructor is automatically generated (by ROSETTA). This destructor
196405 : only frees memory of data members associated with the parts of the current IR node which
196406 : are NOT traversed. Those data members that are part of a traversal can be freed using
196407 : a traversal (calling this destructor on all children in a post-order traversal). Such
196408 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
196409 :
196410 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
196411 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
196412 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
196413 :
196414 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
196415 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
196416 : pointers are not yet implemented to call delete on eash pointer in the container.
196417 : (This could be done by derivation from the STL containers to define containers that
196418 : automatically deleted their members.)
196419 :
196420 : */
196421 0 : SgOmpParallelLoopStatement::~SgOmpParallelLoopStatement () {
196422 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
196423 :
196424 :
196425 :
196426 : }
196427 :
196428 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196429 0 : }
196430 :
196431 :
196432 : /* #line 196433 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196433 :
196434 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
196435 :
196436 : // Generated constructor
196437 1 : SgOmpParallelLoopStatement::SgOmpParallelLoopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
196438 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
196439 : {
196440 : #ifdef DEBUG
196441 : // printf ("In SgOmpParallelLoopStatement::SgOmpParallelLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
196442 : #endif
196443 : #if 0
196444 : // debugging information!
196445 : printf ("In SgOmpParallelLoopStatement::SgOmpParallelLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
196446 : #endif
196447 :
196448 :
196449 :
196450 : #if 0
196451 : // DQ (7/30/2014): Call a virtual function.
196452 : std::string s = this->class_name();
196453 : #endif
196454 :
196455 : // Test the variant virtual function
196456 : // assert(OMP_PARALLEL_LOOP_STMT == variant());
196457 1 : assert(OMP_PARALLEL_LOOP_STMT == this->variant());
196458 1 : ROSE_ASSERT(OMP_PARALLEL_LOOP_STMT == (int)(this->variantT()));
196459 1 : post_construction_initialization();
196460 :
196461 : // Test the isSgOmpParallelLoopStatement() function since it has been problematic
196462 1 : assert(isSgOmpParallelLoopStatement(this) != NULL);
196463 1 : }
196464 :
196465 : // Generated constructor (all data members)
196466 :
196467 : /* #line 196468 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196468 :
196469 :
196470 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196471 :
196472 :
196473 : // ********************************************************
196474 : // member functions common across all array grammar objects
196475 : // ********************************************************
196476 :
196477 :
196478 :
196479 : /* #line 196480 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196480 :
196481 :
196482 :
196483 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196484 :
196485 : // ********************************************************
196486 : // member functions specific to each node in the grammar
196487 : // ********************************************************
196488 :
196489 :
196490 : /* #line 196491 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196491 :
196492 : // Start of memberFunctionString
196493 : /* #line 19307 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
196494 :
196495 : void
196496 1 : SgOmpTargetParallelStatement::post_construction_initialization()
196497 1 : {}
196498 :
196499 :
196500 : // End of memberFunctionString
196501 : // Start of memberFunctionString
196502 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
196503 :
196504 : // *** COMMON CODE SECTION BEGINS HERE ***
196505 :
196506 : #if 0
196507 : int
196508 : SgOmpTargetParallelStatement::getVariant() const
196509 : {
196510 : // This function is used in ROSE while "variant()" is used in SAGE
196511 : assert(this != NULL);
196512 : return variant();
196513 : }
196514 : #endif
196515 :
196516 : // This function is used in ROSE in treeTraversal code
196517 : // eventually replaces getVariant() and variant()
196518 : // though after variant() has been removed for a while we will
196519 : // want to change the name of variantT() back to variant()
196520 : // (since the "T" was ment to stand for temporary).
196521 : // When this happens the variantT() will be depricated.
196522 : VariantT
196523 79 : SgOmpTargetParallelStatement::variantT() const
196524 : {
196525 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
196526 79 : ROSE_ASSERT(this != NULL);
196527 79 : return V_SgOmpTargetParallelStatement;
196528 : }
196529 :
196530 : #if 0
196531 : int
196532 : SgOmpTargetParallelStatement::variant() const
196533 : {
196534 : // This function is used in SAGE
196535 : ROSE_ASSERT(this != NULL);
196536 : return OMP_TARGET_PARALLEL_STMT;
196537 : }
196538 : #endif
196539 :
196540 : ROSE_DLL_API const char*
196541 0 : SgOmpTargetParallelStatement::sage_class_name() const
196542 : {
196543 0 : ROSE_ASSERT(this != NULL);
196544 0 : return "SgOmpTargetParallelStatement";
196545 : }
196546 :
196547 : std::string
196548 1 : SgOmpTargetParallelStatement::class_name() const
196549 : {
196550 1 : ROSE_ASSERT(this != NULL);
196551 1 : return "SgOmpTargetParallelStatement";
196552 : }
196553 :
196554 : // DQ (11/26/2005): Support for visitor pattern mechanims
196555 : // (inferior to ROSE traversal mechanism, experimental).
196556 : void
196557 0 : SgOmpTargetParallelStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
196558 : {
196559 0 : ROSE_ASSERT(this != NULL);
196560 0 : visitor.visit(this);
196561 0 : }
196562 :
196563 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
196564 0 : void SgOmpTargetParallelStatement::accept (ROSE_VisitorPattern & visitor) {
196565 0 : ROSE_ASSERT(this != NULL);
196566 0 : visitor.visit(this);
196567 0 : }
196568 :
196569 : SgOmpTargetParallelStatement*
196570 0 : SgOmpTargetParallelStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
196571 : {
196572 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
196573 : // This function is currently only supported for the AST used the represent Binary executables.
196574 : if (0 /* isSgAsmNode(this) != NULL */)
196575 : {
196576 : // Support for regex specification.
196577 : std::string prefixCode = "REGEX:";
196578 : addNewAttribute(prefixCode + s,a);
196579 : }
196580 : #endif
196581 :
196582 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
196583 0 : return this;
196584 : }
196585 :
196586 : // *** COMMON CODE SECTION ENDS HERE ***
196587 :
196588 :
196589 : // End of memberFunctionString
196590 : // Start of memberFunctionString
196591 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
196592 :
196593 :
196594 : #if 0
196595 : //! Error checking support
196596 : /*! Verifies the following:
196597 : - working getVariant() member function
196598 : - calls base class's error() member function
196599 : Every class has one of these functions.
196600 : */
196601 : bool
196602 : SgOmpTargetParallelStatement::error()
196603 : {
196604 : // Put error checking here
196605 :
196606 : ROSE_ASSERT (this != NULL);
196607 : if (getVariant() != OMP_TARGET_PARALLEL_STMT)
196608 : {
196609 : printf ("Error in SgOmpTargetParallelStatement::error(): SgOmpTargetParallelStatement object has a %s variant \n",
196610 : Cxx_GrammarTerminalNames[getVariant()].name);
196611 : // printf ("Error in SgOmpTargetParallelStatement::error() \n");
196612 : ROSE_ABORT();
196613 : }
196614 :
196615 : ROSE_ASSERT (getVariant() == OMP_TARGET_PARALLEL_STMT);
196616 : return SgUpirFieldBodyStatement::error();
196617 : }
196618 : #endif
196619 :
196620 :
196621 :
196622 : // End of memberFunctionString
196623 :
196624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
196625 :
196626 1 : SgOmpTargetParallelStatement* isSgOmpTargetParallelStatement ( SgNode* inputDerivedClassPointer )
196627 : {
196628 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196629 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196630 : // So to fix this we return NULL directly when the input is NULL and avoid the
196631 : // dynamic_cast in this case. This is likely a performance improvement as well.
196632 : // return dynamic_cast<SgOmpTargetParallelStatement*>(inputDerivedClassPointer);
196633 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelStatement uses table-driven castability instead of c++ default dynamic_cast
196634 : // this improves the running time performance by 10-20%.
196635 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetParallelStatement*>(inputDerivedClassPointer);
196636 1 : return IS_SgOmpTargetParallelStatement_FAST_MACRO(inputDerivedClassPointer);
196637 : }
196638 :
196639 : // DQ (11/8/2003): Added version of functions taking const pointer
196640 0 : const SgOmpTargetParallelStatement* isSgOmpTargetParallelStatement ( const SgNode* inputDerivedClassPointer )
196641 : {
196642 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196643 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196644 : // So to fix this we return NULL directly when the input is NULL and avoid the
196645 : // dynamic_cast in this case. This is likely a performance improvement as well.
196646 : // return dynamic_cast<const SgOmpTargetParallelStatement*>(inputDerivedClassPointer);
196647 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelStatement uses table-driven castability instead of c++ default dynamic_cast
196648 : // this improves the running time performance by 10-20%.
196649 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetParallelStatement*>(inputDerivedClassPointer);
196650 0 : return IS_SgOmpTargetParallelStatement_FAST_MACRO(inputDerivedClassPointer);
196651 : }
196652 :
196653 :
196654 :
196655 : /* #line 196656 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196656 :
196657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196658 :
196659 : /**
196660 : \brief Generated destructor
196661 :
196662 : This destructor is automatically generated (by ROSETTA). This destructor
196663 : only frees memory of data members associated with the parts of the current IR node which
196664 : are NOT traversed. Those data members that are part of a traversal can be freed using
196665 : a traversal (calling this destructor on all children in a post-order traversal). Such
196666 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
196667 :
196668 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
196669 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
196670 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
196671 :
196672 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
196673 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
196674 : pointers are not yet implemented to call delete on eash pointer in the container.
196675 : (This could be done by derivation from the STL containers to define containers that
196676 : automatically deleted their members.)
196677 :
196678 : */
196679 0 : SgOmpTargetParallelStatement::~SgOmpTargetParallelStatement () {
196680 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
196681 :
196682 :
196683 :
196684 : }
196685 :
196686 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196687 0 : }
196688 :
196689 :
196690 : /* #line 196691 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196691 :
196692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
196693 :
196694 : // Generated constructor
196695 1 : SgOmpTargetParallelStatement::SgOmpTargetParallelStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
196696 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
196697 : {
196698 : #ifdef DEBUG
196699 : // printf ("In SgOmpTargetParallelStatement::SgOmpTargetParallelStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
196700 : #endif
196701 : #if 0
196702 : // debugging information!
196703 : printf ("In SgOmpTargetParallelStatement::SgOmpTargetParallelStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
196704 : #endif
196705 :
196706 :
196707 :
196708 : #if 0
196709 : // DQ (7/30/2014): Call a virtual function.
196710 : std::string s = this->class_name();
196711 : #endif
196712 :
196713 : // Test the variant virtual function
196714 : // assert(OMP_TARGET_PARALLEL_STMT == variant());
196715 1 : assert(OMP_TARGET_PARALLEL_STMT == this->variant());
196716 1 : ROSE_ASSERT(OMP_TARGET_PARALLEL_STMT == (int)(this->variantT()));
196717 1 : post_construction_initialization();
196718 :
196719 : // Test the isSgOmpTargetParallelStatement() function since it has been problematic
196720 1 : assert(isSgOmpTargetParallelStatement(this) != NULL);
196721 1 : }
196722 :
196723 : // Generated constructor (all data members)
196724 :
196725 : /* #line 196726 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196726 :
196727 :
196728 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196729 :
196730 :
196731 : // ********************************************************
196732 : // member functions common across all array grammar objects
196733 : // ********************************************************
196734 :
196735 :
196736 :
196737 : /* #line 196738 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196738 :
196739 :
196740 :
196741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196742 :
196743 : // ********************************************************
196744 : // member functions specific to each node in the grammar
196745 : // ********************************************************
196746 :
196747 :
196748 : /* #line 196749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196749 :
196750 : // Start of memberFunctionString
196751 : /* #line 19313 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
196752 :
196753 : void
196754 1 : SgOmpTargetParallelForSimdStatement::post_construction_initialization()
196755 1 : {}
196756 :
196757 :
196758 : // End of memberFunctionString
196759 : // Start of memberFunctionString
196760 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
196761 :
196762 : // *** COMMON CODE SECTION BEGINS HERE ***
196763 :
196764 : #if 0
196765 : int
196766 : SgOmpTargetParallelForSimdStatement::getVariant() const
196767 : {
196768 : // This function is used in ROSE while "variant()" is used in SAGE
196769 : assert(this != NULL);
196770 : return variant();
196771 : }
196772 : #endif
196773 :
196774 : // This function is used in ROSE in treeTraversal code
196775 : // eventually replaces getVariant() and variant()
196776 : // though after variant() has been removed for a while we will
196777 : // want to change the name of variantT() back to variant()
196778 : // (since the "T" was ment to stand for temporary).
196779 : // When this happens the variantT() will be depricated.
196780 : VariantT
196781 79 : SgOmpTargetParallelForSimdStatement::variantT() const
196782 : {
196783 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
196784 79 : ROSE_ASSERT(this != NULL);
196785 79 : return V_SgOmpTargetParallelForSimdStatement;
196786 : }
196787 :
196788 : #if 0
196789 : int
196790 : SgOmpTargetParallelForSimdStatement::variant() const
196791 : {
196792 : // This function is used in SAGE
196793 : ROSE_ASSERT(this != NULL);
196794 : return OMP_TARGET_PARALLEL_FOR_SIMD_STMT;
196795 : }
196796 : #endif
196797 :
196798 : ROSE_DLL_API const char*
196799 0 : SgOmpTargetParallelForSimdStatement::sage_class_name() const
196800 : {
196801 0 : ROSE_ASSERT(this != NULL);
196802 0 : return "SgOmpTargetParallelForSimdStatement";
196803 : }
196804 :
196805 : std::string
196806 1 : SgOmpTargetParallelForSimdStatement::class_name() const
196807 : {
196808 1 : ROSE_ASSERT(this != NULL);
196809 1 : return "SgOmpTargetParallelForSimdStatement";
196810 : }
196811 :
196812 : // DQ (11/26/2005): Support for visitor pattern mechanims
196813 : // (inferior to ROSE traversal mechanism, experimental).
196814 : void
196815 0 : SgOmpTargetParallelForSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
196816 : {
196817 0 : ROSE_ASSERT(this != NULL);
196818 0 : visitor.visit(this);
196819 0 : }
196820 :
196821 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
196822 0 : void SgOmpTargetParallelForSimdStatement::accept (ROSE_VisitorPattern & visitor) {
196823 0 : ROSE_ASSERT(this != NULL);
196824 0 : visitor.visit(this);
196825 0 : }
196826 :
196827 : SgOmpTargetParallelForSimdStatement*
196828 0 : SgOmpTargetParallelForSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
196829 : {
196830 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
196831 : // This function is currently only supported for the AST used the represent Binary executables.
196832 : if (0 /* isSgAsmNode(this) != NULL */)
196833 : {
196834 : // Support for regex specification.
196835 : std::string prefixCode = "REGEX:";
196836 : addNewAttribute(prefixCode + s,a);
196837 : }
196838 : #endif
196839 :
196840 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
196841 0 : return this;
196842 : }
196843 :
196844 : // *** COMMON CODE SECTION ENDS HERE ***
196845 :
196846 :
196847 : // End of memberFunctionString
196848 : // Start of memberFunctionString
196849 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
196850 :
196851 :
196852 : #if 0
196853 : //! Error checking support
196854 : /*! Verifies the following:
196855 : - working getVariant() member function
196856 : - calls base class's error() member function
196857 : Every class has one of these functions.
196858 : */
196859 : bool
196860 : SgOmpTargetParallelForSimdStatement::error()
196861 : {
196862 : // Put error checking here
196863 :
196864 : ROSE_ASSERT (this != NULL);
196865 : if (getVariant() != OMP_TARGET_PARALLEL_FOR_SIMD_STMT)
196866 : {
196867 : printf ("Error in SgOmpTargetParallelForSimdStatement::error(): SgOmpTargetParallelForSimdStatement object has a %s variant \n",
196868 : Cxx_GrammarTerminalNames[getVariant()].name);
196869 : // printf ("Error in SgOmpTargetParallelForSimdStatement::error() \n");
196870 : ROSE_ABORT();
196871 : }
196872 :
196873 : ROSE_ASSERT (getVariant() == OMP_TARGET_PARALLEL_FOR_SIMD_STMT);
196874 : return SgUpirFieldBodyStatement::error();
196875 : }
196876 : #endif
196877 :
196878 :
196879 :
196880 : // End of memberFunctionString
196881 :
196882 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
196883 :
196884 1 : SgOmpTargetParallelForSimdStatement* isSgOmpTargetParallelForSimdStatement ( SgNode* inputDerivedClassPointer )
196885 : {
196886 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196887 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196888 : // So to fix this we return NULL directly when the input is NULL and avoid the
196889 : // dynamic_cast in this case. This is likely a performance improvement as well.
196890 : // return dynamic_cast<SgOmpTargetParallelForSimdStatement*>(inputDerivedClassPointer);
196891 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
196892 : // this improves the running time performance by 10-20%.
196893 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetParallelForSimdStatement*>(inputDerivedClassPointer);
196894 1 : return IS_SgOmpTargetParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
196895 : }
196896 :
196897 : // DQ (11/8/2003): Added version of functions taking const pointer
196898 0 : const SgOmpTargetParallelForSimdStatement* isSgOmpTargetParallelForSimdStatement ( const SgNode* inputDerivedClassPointer )
196899 : {
196900 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
196901 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
196902 : // So to fix this we return NULL directly when the input is NULL and avoid the
196903 : // dynamic_cast in this case. This is likely a performance improvement as well.
196904 : // return dynamic_cast<const SgOmpTargetParallelForSimdStatement*>(inputDerivedClassPointer);
196905 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
196906 : // this improves the running time performance by 10-20%.
196907 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetParallelForSimdStatement*>(inputDerivedClassPointer);
196908 0 : return IS_SgOmpTargetParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
196909 : }
196910 :
196911 :
196912 :
196913 : /* #line 196914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196914 :
196915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196916 :
196917 : /**
196918 : \brief Generated destructor
196919 :
196920 : This destructor is automatically generated (by ROSETTA). This destructor
196921 : only frees memory of data members associated with the parts of the current IR node which
196922 : are NOT traversed. Those data members that are part of a traversal can be freed using
196923 : a traversal (calling this destructor on all children in a post-order traversal). Such
196924 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
196925 :
196926 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
196927 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
196928 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
196929 :
196930 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
196931 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
196932 : pointers are not yet implemented to call delete on eash pointer in the container.
196933 : (This could be done by derivation from the STL containers to define containers that
196934 : automatically deleted their members.)
196935 :
196936 : */
196937 0 : SgOmpTargetParallelForSimdStatement::~SgOmpTargetParallelForSimdStatement () {
196938 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
196939 :
196940 :
196941 :
196942 : }
196943 :
196944 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
196945 0 : }
196946 :
196947 :
196948 : /* #line 196949 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196949 :
196950 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
196951 :
196952 : // Generated constructor
196953 1 : SgOmpTargetParallelForSimdStatement::SgOmpTargetParallelForSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
196954 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
196955 : {
196956 : #ifdef DEBUG
196957 : // printf ("In SgOmpTargetParallelForSimdStatement::SgOmpTargetParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
196958 : #endif
196959 : #if 0
196960 : // debugging information!
196961 : printf ("In SgOmpTargetParallelForSimdStatement::SgOmpTargetParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
196962 : #endif
196963 :
196964 :
196965 :
196966 : #if 0
196967 : // DQ (7/30/2014): Call a virtual function.
196968 : std::string s = this->class_name();
196969 : #endif
196970 :
196971 : // Test the variant virtual function
196972 : // assert(OMP_TARGET_PARALLEL_FOR_SIMD_STMT == variant());
196973 1 : assert(OMP_TARGET_PARALLEL_FOR_SIMD_STMT == this->variant());
196974 1 : ROSE_ASSERT(OMP_TARGET_PARALLEL_FOR_SIMD_STMT == (int)(this->variantT()));
196975 1 : post_construction_initialization();
196976 :
196977 : // Test the isSgOmpTargetParallelForSimdStatement() function since it has been problematic
196978 1 : assert(isSgOmpTargetParallelForSimdStatement(this) != NULL);
196979 1 : }
196980 :
196981 : // Generated constructor (all data members)
196982 :
196983 : /* #line 196984 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196984 :
196985 :
196986 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
196987 :
196988 :
196989 : // ********************************************************
196990 : // member functions common across all array grammar objects
196991 : // ********************************************************
196992 :
196993 :
196994 :
196995 : /* #line 196996 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
196996 :
196997 :
196998 :
196999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197000 :
197001 : // ********************************************************
197002 : // member functions specific to each node in the grammar
197003 : // ********************************************************
197004 :
197005 :
197006 : /* #line 197007 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197007 :
197008 : // Start of memberFunctionString
197009 : /* #line 19319 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
197010 :
197011 : void
197012 1 : SgOmpTargetParallelLoopStatement::post_construction_initialization()
197013 1 : {}
197014 :
197015 :
197016 : // End of memberFunctionString
197017 : // Start of memberFunctionString
197018 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
197019 :
197020 : // *** COMMON CODE SECTION BEGINS HERE ***
197021 :
197022 : #if 0
197023 : int
197024 : SgOmpTargetParallelLoopStatement::getVariant() const
197025 : {
197026 : // This function is used in ROSE while "variant()" is used in SAGE
197027 : assert(this != NULL);
197028 : return variant();
197029 : }
197030 : #endif
197031 :
197032 : // This function is used in ROSE in treeTraversal code
197033 : // eventually replaces getVariant() and variant()
197034 : // though after variant() has been removed for a while we will
197035 : // want to change the name of variantT() back to variant()
197036 : // (since the "T" was ment to stand for temporary).
197037 : // When this happens the variantT() will be depricated.
197038 : VariantT
197039 79 : SgOmpTargetParallelLoopStatement::variantT() const
197040 : {
197041 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
197042 79 : ROSE_ASSERT(this != NULL);
197043 79 : return V_SgOmpTargetParallelLoopStatement;
197044 : }
197045 :
197046 : #if 0
197047 : int
197048 : SgOmpTargetParallelLoopStatement::variant() const
197049 : {
197050 : // This function is used in SAGE
197051 : ROSE_ASSERT(this != NULL);
197052 : return OMP_TARGET_PARALLEL_LOOP_STMT;
197053 : }
197054 : #endif
197055 :
197056 : ROSE_DLL_API const char*
197057 0 : SgOmpTargetParallelLoopStatement::sage_class_name() const
197058 : {
197059 0 : ROSE_ASSERT(this != NULL);
197060 0 : return "SgOmpTargetParallelLoopStatement";
197061 : }
197062 :
197063 : std::string
197064 1 : SgOmpTargetParallelLoopStatement::class_name() const
197065 : {
197066 1 : ROSE_ASSERT(this != NULL);
197067 1 : return "SgOmpTargetParallelLoopStatement";
197068 : }
197069 :
197070 : // DQ (11/26/2005): Support for visitor pattern mechanims
197071 : // (inferior to ROSE traversal mechanism, experimental).
197072 : void
197073 0 : SgOmpTargetParallelLoopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
197074 : {
197075 0 : ROSE_ASSERT(this != NULL);
197076 0 : visitor.visit(this);
197077 0 : }
197078 :
197079 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
197080 0 : void SgOmpTargetParallelLoopStatement::accept (ROSE_VisitorPattern & visitor) {
197081 0 : ROSE_ASSERT(this != NULL);
197082 0 : visitor.visit(this);
197083 0 : }
197084 :
197085 : SgOmpTargetParallelLoopStatement*
197086 0 : SgOmpTargetParallelLoopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
197087 : {
197088 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
197089 : // This function is currently only supported for the AST used the represent Binary executables.
197090 : if (0 /* isSgAsmNode(this) != NULL */)
197091 : {
197092 : // Support for regex specification.
197093 : std::string prefixCode = "REGEX:";
197094 : addNewAttribute(prefixCode + s,a);
197095 : }
197096 : #endif
197097 :
197098 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
197099 0 : return this;
197100 : }
197101 :
197102 : // *** COMMON CODE SECTION ENDS HERE ***
197103 :
197104 :
197105 : // End of memberFunctionString
197106 : // Start of memberFunctionString
197107 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
197108 :
197109 :
197110 : #if 0
197111 : //! Error checking support
197112 : /*! Verifies the following:
197113 : - working getVariant() member function
197114 : - calls base class's error() member function
197115 : Every class has one of these functions.
197116 : */
197117 : bool
197118 : SgOmpTargetParallelLoopStatement::error()
197119 : {
197120 : // Put error checking here
197121 :
197122 : ROSE_ASSERT (this != NULL);
197123 : if (getVariant() != OMP_TARGET_PARALLEL_LOOP_STMT)
197124 : {
197125 : printf ("Error in SgOmpTargetParallelLoopStatement::error(): SgOmpTargetParallelLoopStatement object has a %s variant \n",
197126 : Cxx_GrammarTerminalNames[getVariant()].name);
197127 : // printf ("Error in SgOmpTargetParallelLoopStatement::error() \n");
197128 : ROSE_ABORT();
197129 : }
197130 :
197131 : ROSE_ASSERT (getVariant() == OMP_TARGET_PARALLEL_LOOP_STMT);
197132 : return SgUpirFieldBodyStatement::error();
197133 : }
197134 : #endif
197135 :
197136 :
197137 :
197138 : // End of memberFunctionString
197139 :
197140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
197141 :
197142 1 : SgOmpTargetParallelLoopStatement* isSgOmpTargetParallelLoopStatement ( SgNode* inputDerivedClassPointer )
197143 : {
197144 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197145 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197146 : // So to fix this we return NULL directly when the input is NULL and avoid the
197147 : // dynamic_cast in this case. This is likely a performance improvement as well.
197148 : // return dynamic_cast<SgOmpTargetParallelLoopStatement*>(inputDerivedClassPointer);
197149 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelLoopStatement uses table-driven castability instead of c++ default dynamic_cast
197150 : // this improves the running time performance by 10-20%.
197151 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetParallelLoopStatement*>(inputDerivedClassPointer);
197152 1 : return IS_SgOmpTargetParallelLoopStatement_FAST_MACRO(inputDerivedClassPointer);
197153 : }
197154 :
197155 : // DQ (11/8/2003): Added version of functions taking const pointer
197156 0 : const SgOmpTargetParallelLoopStatement* isSgOmpTargetParallelLoopStatement ( const SgNode* inputDerivedClassPointer )
197157 : {
197158 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197159 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197160 : // So to fix this we return NULL directly when the input is NULL and avoid the
197161 : // dynamic_cast in this case. This is likely a performance improvement as well.
197162 : // return dynamic_cast<const SgOmpTargetParallelLoopStatement*>(inputDerivedClassPointer);
197163 : // Milind Chabbi (8/28/2013): isSgOmpTargetParallelLoopStatement uses table-driven castability instead of c++ default dynamic_cast
197164 : // this improves the running time performance by 10-20%.
197165 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetParallelLoopStatement*>(inputDerivedClassPointer);
197166 0 : return IS_SgOmpTargetParallelLoopStatement_FAST_MACRO(inputDerivedClassPointer);
197167 : }
197168 :
197169 :
197170 :
197171 : /* #line 197172 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197172 :
197173 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197174 :
197175 : /**
197176 : \brief Generated destructor
197177 :
197178 : This destructor is automatically generated (by ROSETTA). This destructor
197179 : only frees memory of data members associated with the parts of the current IR node which
197180 : are NOT traversed. Those data members that are part of a traversal can be freed using
197181 : a traversal (calling this destructor on all children in a post-order traversal). Such
197182 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
197183 :
197184 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
197185 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
197186 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
197187 :
197188 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
197189 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
197190 : pointers are not yet implemented to call delete on eash pointer in the container.
197191 : (This could be done by derivation from the STL containers to define containers that
197192 : automatically deleted their members.)
197193 :
197194 : */
197195 0 : SgOmpTargetParallelLoopStatement::~SgOmpTargetParallelLoopStatement () {
197196 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
197197 :
197198 :
197199 :
197200 : }
197201 :
197202 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197203 0 : }
197204 :
197205 :
197206 : /* #line 197207 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197207 :
197208 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
197209 :
197210 : // Generated constructor
197211 1 : SgOmpTargetParallelLoopStatement::SgOmpTargetParallelLoopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
197212 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
197213 : {
197214 : #ifdef DEBUG
197215 : // printf ("In SgOmpTargetParallelLoopStatement::SgOmpTargetParallelLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
197216 : #endif
197217 : #if 0
197218 : // debugging information!
197219 : printf ("In SgOmpTargetParallelLoopStatement::SgOmpTargetParallelLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
197220 : #endif
197221 :
197222 :
197223 :
197224 : #if 0
197225 : // DQ (7/30/2014): Call a virtual function.
197226 : std::string s = this->class_name();
197227 : #endif
197228 :
197229 : // Test the variant virtual function
197230 : // assert(OMP_TARGET_PARALLEL_LOOP_STMT == variant());
197231 1 : assert(OMP_TARGET_PARALLEL_LOOP_STMT == this->variant());
197232 1 : ROSE_ASSERT(OMP_TARGET_PARALLEL_LOOP_STMT == (int)(this->variantT()));
197233 1 : post_construction_initialization();
197234 :
197235 : // Test the isSgOmpTargetParallelLoopStatement() function since it has been problematic
197236 1 : assert(isSgOmpTargetParallelLoopStatement(this) != NULL);
197237 1 : }
197238 :
197239 : // Generated constructor (all data members)
197240 :
197241 : /* #line 197242 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197242 :
197243 :
197244 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197245 :
197246 :
197247 : // ********************************************************
197248 : // member functions common across all array grammar objects
197249 : // ********************************************************
197250 :
197251 :
197252 :
197253 : /* #line 197254 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197254 :
197255 :
197256 :
197257 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197258 :
197259 : // ********************************************************
197260 : // member functions specific to each node in the grammar
197261 : // ********************************************************
197262 :
197263 :
197264 : /* #line 197265 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197265 :
197266 : // Start of memberFunctionString
197267 : /* #line 19325 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
197268 :
197269 : void
197270 1 : SgOmpTargetSimdStatement::post_construction_initialization()
197271 1 : {}
197272 :
197273 :
197274 : // End of memberFunctionString
197275 : // Start of memberFunctionString
197276 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
197277 :
197278 : // *** COMMON CODE SECTION BEGINS HERE ***
197279 :
197280 : #if 0
197281 : int
197282 : SgOmpTargetSimdStatement::getVariant() const
197283 : {
197284 : // This function is used in ROSE while "variant()" is used in SAGE
197285 : assert(this != NULL);
197286 : return variant();
197287 : }
197288 : #endif
197289 :
197290 : // This function is used in ROSE in treeTraversal code
197291 : // eventually replaces getVariant() and variant()
197292 : // though after variant() has been removed for a while we will
197293 : // want to change the name of variantT() back to variant()
197294 : // (since the "T" was ment to stand for temporary).
197295 : // When this happens the variantT() will be depricated.
197296 : VariantT
197297 79 : SgOmpTargetSimdStatement::variantT() const
197298 : {
197299 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
197300 79 : ROSE_ASSERT(this != NULL);
197301 79 : return V_SgOmpTargetSimdStatement;
197302 : }
197303 :
197304 : #if 0
197305 : int
197306 : SgOmpTargetSimdStatement::variant() const
197307 : {
197308 : // This function is used in SAGE
197309 : ROSE_ASSERT(this != NULL);
197310 : return OMP_TARGET_SIMD_STMT;
197311 : }
197312 : #endif
197313 :
197314 : ROSE_DLL_API const char*
197315 0 : SgOmpTargetSimdStatement::sage_class_name() const
197316 : {
197317 0 : ROSE_ASSERT(this != NULL);
197318 0 : return "SgOmpTargetSimdStatement";
197319 : }
197320 :
197321 : std::string
197322 1 : SgOmpTargetSimdStatement::class_name() const
197323 : {
197324 1 : ROSE_ASSERT(this != NULL);
197325 1 : return "SgOmpTargetSimdStatement";
197326 : }
197327 :
197328 : // DQ (11/26/2005): Support for visitor pattern mechanims
197329 : // (inferior to ROSE traversal mechanism, experimental).
197330 : void
197331 0 : SgOmpTargetSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
197332 : {
197333 0 : ROSE_ASSERT(this != NULL);
197334 0 : visitor.visit(this);
197335 0 : }
197336 :
197337 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
197338 0 : void SgOmpTargetSimdStatement::accept (ROSE_VisitorPattern & visitor) {
197339 0 : ROSE_ASSERT(this != NULL);
197340 0 : visitor.visit(this);
197341 0 : }
197342 :
197343 : SgOmpTargetSimdStatement*
197344 0 : SgOmpTargetSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
197345 : {
197346 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
197347 : // This function is currently only supported for the AST used the represent Binary executables.
197348 : if (0 /* isSgAsmNode(this) != NULL */)
197349 : {
197350 : // Support for regex specification.
197351 : std::string prefixCode = "REGEX:";
197352 : addNewAttribute(prefixCode + s,a);
197353 : }
197354 : #endif
197355 :
197356 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
197357 0 : return this;
197358 : }
197359 :
197360 : // *** COMMON CODE SECTION ENDS HERE ***
197361 :
197362 :
197363 : // End of memberFunctionString
197364 : // Start of memberFunctionString
197365 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
197366 :
197367 :
197368 : #if 0
197369 : //! Error checking support
197370 : /*! Verifies the following:
197371 : - working getVariant() member function
197372 : - calls base class's error() member function
197373 : Every class has one of these functions.
197374 : */
197375 : bool
197376 : SgOmpTargetSimdStatement::error()
197377 : {
197378 : // Put error checking here
197379 :
197380 : ROSE_ASSERT (this != NULL);
197381 : if (getVariant() != OMP_TARGET_SIMD_STMT)
197382 : {
197383 : printf ("Error in SgOmpTargetSimdStatement::error(): SgOmpTargetSimdStatement object has a %s variant \n",
197384 : Cxx_GrammarTerminalNames[getVariant()].name);
197385 : // printf ("Error in SgOmpTargetSimdStatement::error() \n");
197386 : ROSE_ABORT();
197387 : }
197388 :
197389 : ROSE_ASSERT (getVariant() == OMP_TARGET_SIMD_STMT);
197390 : return SgUpirFieldBodyStatement::error();
197391 : }
197392 : #endif
197393 :
197394 :
197395 :
197396 : // End of memberFunctionString
197397 :
197398 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
197399 :
197400 1 : SgOmpTargetSimdStatement* isSgOmpTargetSimdStatement ( SgNode* inputDerivedClassPointer )
197401 : {
197402 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197403 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197404 : // So to fix this we return NULL directly when the input is NULL and avoid the
197405 : // dynamic_cast in this case. This is likely a performance improvement as well.
197406 : // return dynamic_cast<SgOmpTargetSimdStatement*>(inputDerivedClassPointer);
197407 : // Milind Chabbi (8/28/2013): isSgOmpTargetSimdStatement uses table-driven castability instead of c++ default dynamic_cast
197408 : // this improves the running time performance by 10-20%.
197409 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetSimdStatement*>(inputDerivedClassPointer);
197410 1 : return IS_SgOmpTargetSimdStatement_FAST_MACRO(inputDerivedClassPointer);
197411 : }
197412 :
197413 : // DQ (11/8/2003): Added version of functions taking const pointer
197414 0 : const SgOmpTargetSimdStatement* isSgOmpTargetSimdStatement ( const SgNode* inputDerivedClassPointer )
197415 : {
197416 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197417 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197418 : // So to fix this we return NULL directly when the input is NULL and avoid the
197419 : // dynamic_cast in this case. This is likely a performance improvement as well.
197420 : // return dynamic_cast<const SgOmpTargetSimdStatement*>(inputDerivedClassPointer);
197421 : // Milind Chabbi (8/28/2013): isSgOmpTargetSimdStatement uses table-driven castability instead of c++ default dynamic_cast
197422 : // this improves the running time performance by 10-20%.
197423 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetSimdStatement*>(inputDerivedClassPointer);
197424 0 : return IS_SgOmpTargetSimdStatement_FAST_MACRO(inputDerivedClassPointer);
197425 : }
197426 :
197427 :
197428 :
197429 : /* #line 197430 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197430 :
197431 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197432 :
197433 : /**
197434 : \brief Generated destructor
197435 :
197436 : This destructor is automatically generated (by ROSETTA). This destructor
197437 : only frees memory of data members associated with the parts of the current IR node which
197438 : are NOT traversed. Those data members that are part of a traversal can be freed using
197439 : a traversal (calling this destructor on all children in a post-order traversal). Such
197440 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
197441 :
197442 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
197443 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
197444 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
197445 :
197446 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
197447 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
197448 : pointers are not yet implemented to call delete on eash pointer in the container.
197449 : (This could be done by derivation from the STL containers to define containers that
197450 : automatically deleted their members.)
197451 :
197452 : */
197453 0 : SgOmpTargetSimdStatement::~SgOmpTargetSimdStatement () {
197454 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
197455 :
197456 :
197457 :
197458 : }
197459 :
197460 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197461 0 : }
197462 :
197463 :
197464 : /* #line 197465 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197465 :
197466 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
197467 :
197468 : // Generated constructor
197469 1 : SgOmpTargetSimdStatement::SgOmpTargetSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
197470 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
197471 : {
197472 : #ifdef DEBUG
197473 : // printf ("In SgOmpTargetSimdStatement::SgOmpTargetSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
197474 : #endif
197475 : #if 0
197476 : // debugging information!
197477 : printf ("In SgOmpTargetSimdStatement::SgOmpTargetSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
197478 : #endif
197479 :
197480 :
197481 :
197482 : #if 0
197483 : // DQ (7/30/2014): Call a virtual function.
197484 : std::string s = this->class_name();
197485 : #endif
197486 :
197487 : // Test the variant virtual function
197488 : // assert(OMP_TARGET_SIMD_STMT == variant());
197489 1 : assert(OMP_TARGET_SIMD_STMT == this->variant());
197490 1 : ROSE_ASSERT(OMP_TARGET_SIMD_STMT == (int)(this->variantT()));
197491 1 : post_construction_initialization();
197492 :
197493 : // Test the isSgOmpTargetSimdStatement() function since it has been problematic
197494 1 : assert(isSgOmpTargetSimdStatement(this) != NULL);
197495 1 : }
197496 :
197497 : // Generated constructor (all data members)
197498 :
197499 : /* #line 197500 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197500 :
197501 :
197502 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197503 :
197504 :
197505 : // ********************************************************
197506 : // member functions common across all array grammar objects
197507 : // ********************************************************
197508 :
197509 :
197510 :
197511 : /* #line 197512 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197512 :
197513 :
197514 :
197515 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197516 :
197517 : // ********************************************************
197518 : // member functions specific to each node in the grammar
197519 : // ********************************************************
197520 :
197521 :
197522 : /* #line 197523 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197523 :
197524 : // Start of memberFunctionString
197525 : /* #line 19331 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
197526 :
197527 : void
197528 4 : SgOmpTargetTeamsStatement::post_construction_initialization()
197529 4 : {}
197530 :
197531 :
197532 : // End of memberFunctionString
197533 : // Start of memberFunctionString
197534 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
197535 :
197536 : // *** COMMON CODE SECTION BEGINS HERE ***
197537 :
197538 : #if 0
197539 : int
197540 : SgOmpTargetTeamsStatement::getVariant() const
197541 : {
197542 : // This function is used in ROSE while "variant()" is used in SAGE
197543 : assert(this != NULL);
197544 : return variant();
197545 : }
197546 : #endif
197547 :
197548 : // This function is used in ROSE in treeTraversal code
197549 : // eventually replaces getVariant() and variant()
197550 : // though after variant() has been removed for a while we will
197551 : // want to change the name of variantT() back to variant()
197552 : // (since the "T" was ment to stand for temporary).
197553 : // When this happens the variantT() will be depricated.
197554 : VariantT
197555 324 : SgOmpTargetTeamsStatement::variantT() const
197556 : {
197557 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
197558 324 : ROSE_ASSERT(this != NULL);
197559 324 : return V_SgOmpTargetTeamsStatement;
197560 : }
197561 :
197562 : #if 0
197563 : int
197564 : SgOmpTargetTeamsStatement::variant() const
197565 : {
197566 : // This function is used in SAGE
197567 : ROSE_ASSERT(this != NULL);
197568 : return OMP_TARGET_TEAMS_STMT;
197569 : }
197570 : #endif
197571 :
197572 : ROSE_DLL_API const char*
197573 0 : SgOmpTargetTeamsStatement::sage_class_name() const
197574 : {
197575 0 : ROSE_ASSERT(this != NULL);
197576 0 : return "SgOmpTargetTeamsStatement";
197577 : }
197578 :
197579 : std::string
197580 4 : SgOmpTargetTeamsStatement::class_name() const
197581 : {
197582 4 : ROSE_ASSERT(this != NULL);
197583 4 : return "SgOmpTargetTeamsStatement";
197584 : }
197585 :
197586 : // DQ (11/26/2005): Support for visitor pattern mechanims
197587 : // (inferior to ROSE traversal mechanism, experimental).
197588 : void
197589 0 : SgOmpTargetTeamsStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
197590 : {
197591 0 : ROSE_ASSERT(this != NULL);
197592 0 : visitor.visit(this);
197593 0 : }
197594 :
197595 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
197596 0 : void SgOmpTargetTeamsStatement::accept (ROSE_VisitorPattern & visitor) {
197597 0 : ROSE_ASSERT(this != NULL);
197598 0 : visitor.visit(this);
197599 0 : }
197600 :
197601 : SgOmpTargetTeamsStatement*
197602 0 : SgOmpTargetTeamsStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
197603 : {
197604 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
197605 : // This function is currently only supported for the AST used the represent Binary executables.
197606 : if (0 /* isSgAsmNode(this) != NULL */)
197607 : {
197608 : // Support for regex specification.
197609 : std::string prefixCode = "REGEX:";
197610 : addNewAttribute(prefixCode + s,a);
197611 : }
197612 : #endif
197613 :
197614 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
197615 0 : return this;
197616 : }
197617 :
197618 : // *** COMMON CODE SECTION ENDS HERE ***
197619 :
197620 :
197621 : // End of memberFunctionString
197622 : // Start of memberFunctionString
197623 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
197624 :
197625 :
197626 : #if 0
197627 : //! Error checking support
197628 : /*! Verifies the following:
197629 : - working getVariant() member function
197630 : - calls base class's error() member function
197631 : Every class has one of these functions.
197632 : */
197633 : bool
197634 : SgOmpTargetTeamsStatement::error()
197635 : {
197636 : // Put error checking here
197637 :
197638 : ROSE_ASSERT (this != NULL);
197639 : if (getVariant() != OMP_TARGET_TEAMS_STMT)
197640 : {
197641 : printf ("Error in SgOmpTargetTeamsStatement::error(): SgOmpTargetTeamsStatement object has a %s variant \n",
197642 : Cxx_GrammarTerminalNames[getVariant()].name);
197643 : // printf ("Error in SgOmpTargetTeamsStatement::error() \n");
197644 : ROSE_ABORT();
197645 : }
197646 :
197647 : ROSE_ASSERT (getVariant() == OMP_TARGET_TEAMS_STMT);
197648 : return SgUpirFieldBodyStatement::error();
197649 : }
197650 : #endif
197651 :
197652 :
197653 :
197654 : // End of memberFunctionString
197655 :
197656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
197657 :
197658 4 : SgOmpTargetTeamsStatement* isSgOmpTargetTeamsStatement ( SgNode* inputDerivedClassPointer )
197659 : {
197660 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197661 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197662 : // So to fix this we return NULL directly when the input is NULL and avoid the
197663 : // dynamic_cast in this case. This is likely a performance improvement as well.
197664 : // return dynamic_cast<SgOmpTargetTeamsStatement*>(inputDerivedClassPointer);
197665 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsStatement uses table-driven castability instead of c++ default dynamic_cast
197666 : // this improves the running time performance by 10-20%.
197667 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetTeamsStatement*>(inputDerivedClassPointer);
197668 4 : return IS_SgOmpTargetTeamsStatement_FAST_MACRO(inputDerivedClassPointer);
197669 : }
197670 :
197671 : // DQ (11/8/2003): Added version of functions taking const pointer
197672 0 : const SgOmpTargetTeamsStatement* isSgOmpTargetTeamsStatement ( const SgNode* inputDerivedClassPointer )
197673 : {
197674 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197675 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197676 : // So to fix this we return NULL directly when the input is NULL and avoid the
197677 : // dynamic_cast in this case. This is likely a performance improvement as well.
197678 : // return dynamic_cast<const SgOmpTargetTeamsStatement*>(inputDerivedClassPointer);
197679 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsStatement uses table-driven castability instead of c++ default dynamic_cast
197680 : // this improves the running time performance by 10-20%.
197681 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetTeamsStatement*>(inputDerivedClassPointer);
197682 0 : return IS_SgOmpTargetTeamsStatement_FAST_MACRO(inputDerivedClassPointer);
197683 : }
197684 :
197685 :
197686 :
197687 : /* #line 197688 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197688 :
197689 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197690 :
197691 : /**
197692 : \brief Generated destructor
197693 :
197694 : This destructor is automatically generated (by ROSETTA). This destructor
197695 : only frees memory of data members associated with the parts of the current IR node which
197696 : are NOT traversed. Those data members that are part of a traversal can be freed using
197697 : a traversal (calling this destructor on all children in a post-order traversal). Such
197698 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
197699 :
197700 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
197701 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
197702 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
197703 :
197704 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
197705 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
197706 : pointers are not yet implemented to call delete on eash pointer in the container.
197707 : (This could be done by derivation from the STL containers to define containers that
197708 : automatically deleted their members.)
197709 :
197710 : */
197711 0 : SgOmpTargetTeamsStatement::~SgOmpTargetTeamsStatement () {
197712 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
197713 :
197714 :
197715 :
197716 : }
197717 :
197718 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197719 0 : }
197720 :
197721 :
197722 : /* #line 197723 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197723 :
197724 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
197725 :
197726 : // Generated constructor
197727 4 : SgOmpTargetTeamsStatement::SgOmpTargetTeamsStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
197728 4 : : SgUpirFieldBodyStatement(startOfConstruct, body)
197729 : {
197730 : #ifdef DEBUG
197731 : // printf ("In SgOmpTargetTeamsStatement::SgOmpTargetTeamsStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
197732 : #endif
197733 : #if 0
197734 : // debugging information!
197735 : printf ("In SgOmpTargetTeamsStatement::SgOmpTargetTeamsStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
197736 : #endif
197737 :
197738 :
197739 :
197740 : #if 0
197741 : // DQ (7/30/2014): Call a virtual function.
197742 : std::string s = this->class_name();
197743 : #endif
197744 :
197745 : // Test the variant virtual function
197746 : // assert(OMP_TARGET_TEAMS_STMT == variant());
197747 4 : assert(OMP_TARGET_TEAMS_STMT == this->variant());
197748 4 : ROSE_ASSERT(OMP_TARGET_TEAMS_STMT == (int)(this->variantT()));
197749 4 : post_construction_initialization();
197750 :
197751 : // Test the isSgOmpTargetTeamsStatement() function since it has been problematic
197752 4 : assert(isSgOmpTargetTeamsStatement(this) != NULL);
197753 4 : }
197754 :
197755 : // Generated constructor (all data members)
197756 :
197757 : /* #line 197758 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197758 :
197759 :
197760 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197761 :
197762 :
197763 : // ********************************************************
197764 : // member functions common across all array grammar objects
197765 : // ********************************************************
197766 :
197767 :
197768 :
197769 : /* #line 197770 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197770 :
197771 :
197772 :
197773 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
197774 :
197775 : // ********************************************************
197776 : // member functions specific to each node in the grammar
197777 : // ********************************************************
197778 :
197779 :
197780 : /* #line 197781 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197781 :
197782 : // Start of memberFunctionString
197783 : /* #line 19337 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
197784 :
197785 : void
197786 1 : SgOmpTargetTeamsDistributeStatement::post_construction_initialization()
197787 1 : {}
197788 :
197789 :
197790 : // End of memberFunctionString
197791 : // Start of memberFunctionString
197792 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
197793 :
197794 : // *** COMMON CODE SECTION BEGINS HERE ***
197795 :
197796 : #if 0
197797 : int
197798 : SgOmpTargetTeamsDistributeStatement::getVariant() const
197799 : {
197800 : // This function is used in ROSE while "variant()" is used in SAGE
197801 : assert(this != NULL);
197802 : return variant();
197803 : }
197804 : #endif
197805 :
197806 : // This function is used in ROSE in treeTraversal code
197807 : // eventually replaces getVariant() and variant()
197808 : // though after variant() has been removed for a while we will
197809 : // want to change the name of variantT() back to variant()
197810 : // (since the "T" was ment to stand for temporary).
197811 : // When this happens the variantT() will be depricated.
197812 : VariantT
197813 79 : SgOmpTargetTeamsDistributeStatement::variantT() const
197814 : {
197815 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
197816 79 : ROSE_ASSERT(this != NULL);
197817 79 : return V_SgOmpTargetTeamsDistributeStatement;
197818 : }
197819 :
197820 : #if 0
197821 : int
197822 : SgOmpTargetTeamsDistributeStatement::variant() const
197823 : {
197824 : // This function is used in SAGE
197825 : ROSE_ASSERT(this != NULL);
197826 : return OMP_TARGET_TEAMS_DISTRIBUTE_STMT;
197827 : }
197828 : #endif
197829 :
197830 : ROSE_DLL_API const char*
197831 0 : SgOmpTargetTeamsDistributeStatement::sage_class_name() const
197832 : {
197833 0 : ROSE_ASSERT(this != NULL);
197834 0 : return "SgOmpTargetTeamsDistributeStatement";
197835 : }
197836 :
197837 : std::string
197838 1 : SgOmpTargetTeamsDistributeStatement::class_name() const
197839 : {
197840 1 : ROSE_ASSERT(this != NULL);
197841 1 : return "SgOmpTargetTeamsDistributeStatement";
197842 : }
197843 :
197844 : // DQ (11/26/2005): Support for visitor pattern mechanims
197845 : // (inferior to ROSE traversal mechanism, experimental).
197846 : void
197847 0 : SgOmpTargetTeamsDistributeStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
197848 : {
197849 0 : ROSE_ASSERT(this != NULL);
197850 0 : visitor.visit(this);
197851 0 : }
197852 :
197853 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
197854 0 : void SgOmpTargetTeamsDistributeStatement::accept (ROSE_VisitorPattern & visitor) {
197855 0 : ROSE_ASSERT(this != NULL);
197856 0 : visitor.visit(this);
197857 0 : }
197858 :
197859 : SgOmpTargetTeamsDistributeStatement*
197860 0 : SgOmpTargetTeamsDistributeStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
197861 : {
197862 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
197863 : // This function is currently only supported for the AST used the represent Binary executables.
197864 : if (0 /* isSgAsmNode(this) != NULL */)
197865 : {
197866 : // Support for regex specification.
197867 : std::string prefixCode = "REGEX:";
197868 : addNewAttribute(prefixCode + s,a);
197869 : }
197870 : #endif
197871 :
197872 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
197873 0 : return this;
197874 : }
197875 :
197876 : // *** COMMON CODE SECTION ENDS HERE ***
197877 :
197878 :
197879 : // End of memberFunctionString
197880 : // Start of memberFunctionString
197881 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
197882 :
197883 :
197884 : #if 0
197885 : //! Error checking support
197886 : /*! Verifies the following:
197887 : - working getVariant() member function
197888 : - calls base class's error() member function
197889 : Every class has one of these functions.
197890 : */
197891 : bool
197892 : SgOmpTargetTeamsDistributeStatement::error()
197893 : {
197894 : // Put error checking here
197895 :
197896 : ROSE_ASSERT (this != NULL);
197897 : if (getVariant() != OMP_TARGET_TEAMS_DISTRIBUTE_STMT)
197898 : {
197899 : printf ("Error in SgOmpTargetTeamsDistributeStatement::error(): SgOmpTargetTeamsDistributeStatement object has a %s variant \n",
197900 : Cxx_GrammarTerminalNames[getVariant()].name);
197901 : // printf ("Error in SgOmpTargetTeamsDistributeStatement::error() \n");
197902 : ROSE_ABORT();
197903 : }
197904 :
197905 : ROSE_ASSERT (getVariant() == OMP_TARGET_TEAMS_DISTRIBUTE_STMT);
197906 : return SgUpirFieldBodyStatement::error();
197907 : }
197908 : #endif
197909 :
197910 :
197911 :
197912 : // End of memberFunctionString
197913 :
197914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
197915 :
197916 1 : SgOmpTargetTeamsDistributeStatement* isSgOmpTargetTeamsDistributeStatement ( SgNode* inputDerivedClassPointer )
197917 : {
197918 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197919 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197920 : // So to fix this we return NULL directly when the input is NULL and avoid the
197921 : // dynamic_cast in this case. This is likely a performance improvement as well.
197922 : // return dynamic_cast<SgOmpTargetTeamsDistributeStatement*>(inputDerivedClassPointer);
197923 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeStatement uses table-driven castability instead of c++ default dynamic_cast
197924 : // this improves the running time performance by 10-20%.
197925 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetTeamsDistributeStatement*>(inputDerivedClassPointer);
197926 1 : return IS_SgOmpTargetTeamsDistributeStatement_FAST_MACRO(inputDerivedClassPointer);
197927 : }
197928 :
197929 : // DQ (11/8/2003): Added version of functions taking const pointer
197930 0 : const SgOmpTargetTeamsDistributeStatement* isSgOmpTargetTeamsDistributeStatement ( const SgNode* inputDerivedClassPointer )
197931 : {
197932 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
197933 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
197934 : // So to fix this we return NULL directly when the input is NULL and avoid the
197935 : // dynamic_cast in this case. This is likely a performance improvement as well.
197936 : // return dynamic_cast<const SgOmpTargetTeamsDistributeStatement*>(inputDerivedClassPointer);
197937 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeStatement uses table-driven castability instead of c++ default dynamic_cast
197938 : // this improves the running time performance by 10-20%.
197939 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetTeamsDistributeStatement*>(inputDerivedClassPointer);
197940 0 : return IS_SgOmpTargetTeamsDistributeStatement_FAST_MACRO(inputDerivedClassPointer);
197941 : }
197942 :
197943 :
197944 :
197945 : /* #line 197946 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197946 :
197947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197948 :
197949 : /**
197950 : \brief Generated destructor
197951 :
197952 : This destructor is automatically generated (by ROSETTA). This destructor
197953 : only frees memory of data members associated with the parts of the current IR node which
197954 : are NOT traversed. Those data members that are part of a traversal can be freed using
197955 : a traversal (calling this destructor on all children in a post-order traversal). Such
197956 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
197957 :
197958 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
197959 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
197960 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
197961 :
197962 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
197963 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
197964 : pointers are not yet implemented to call delete on eash pointer in the container.
197965 : (This could be done by derivation from the STL containers to define containers that
197966 : automatically deleted their members.)
197967 :
197968 : */
197969 0 : SgOmpTargetTeamsDistributeStatement::~SgOmpTargetTeamsDistributeStatement () {
197970 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
197971 :
197972 :
197973 :
197974 : }
197975 :
197976 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
197977 0 : }
197978 :
197979 :
197980 : /* #line 197981 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
197981 :
197982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
197983 :
197984 : // Generated constructor
197985 1 : SgOmpTargetTeamsDistributeStatement::SgOmpTargetTeamsDistributeStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
197986 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
197987 : {
197988 : #ifdef DEBUG
197989 : // printf ("In SgOmpTargetTeamsDistributeStatement::SgOmpTargetTeamsDistributeStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
197990 : #endif
197991 : #if 0
197992 : // debugging information!
197993 : printf ("In SgOmpTargetTeamsDistributeStatement::SgOmpTargetTeamsDistributeStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
197994 : #endif
197995 :
197996 :
197997 :
197998 : #if 0
197999 : // DQ (7/30/2014): Call a virtual function.
198000 : std::string s = this->class_name();
198001 : #endif
198002 :
198003 : // Test the variant virtual function
198004 : // assert(OMP_TARGET_TEAMS_DISTRIBUTE_STMT == variant());
198005 1 : assert(OMP_TARGET_TEAMS_DISTRIBUTE_STMT == this->variant());
198006 1 : ROSE_ASSERT(OMP_TARGET_TEAMS_DISTRIBUTE_STMT == (int)(this->variantT()));
198007 1 : post_construction_initialization();
198008 :
198009 : // Test the isSgOmpTargetTeamsDistributeStatement() function since it has been problematic
198010 1 : assert(isSgOmpTargetTeamsDistributeStatement(this) != NULL);
198011 1 : }
198012 :
198013 : // Generated constructor (all data members)
198014 :
198015 : /* #line 198016 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198016 :
198017 :
198018 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198019 :
198020 :
198021 : // ********************************************************
198022 : // member functions common across all array grammar objects
198023 : // ********************************************************
198024 :
198025 :
198026 :
198027 : /* #line 198028 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198028 :
198029 :
198030 :
198031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198032 :
198033 : // ********************************************************
198034 : // member functions specific to each node in the grammar
198035 : // ********************************************************
198036 :
198037 :
198038 : /* #line 198039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198039 :
198040 : // Start of memberFunctionString
198041 : /* #line 19343 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
198042 :
198043 : void
198044 1 : SgOmpTargetTeamsDistributeSimdStatement::post_construction_initialization()
198045 1 : {}
198046 :
198047 :
198048 : // End of memberFunctionString
198049 : // Start of memberFunctionString
198050 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
198051 :
198052 : // *** COMMON CODE SECTION BEGINS HERE ***
198053 :
198054 : #if 0
198055 : int
198056 : SgOmpTargetTeamsDistributeSimdStatement::getVariant() const
198057 : {
198058 : // This function is used in ROSE while "variant()" is used in SAGE
198059 : assert(this != NULL);
198060 : return variant();
198061 : }
198062 : #endif
198063 :
198064 : // This function is used in ROSE in treeTraversal code
198065 : // eventually replaces getVariant() and variant()
198066 : // though after variant() has been removed for a while we will
198067 : // want to change the name of variantT() back to variant()
198068 : // (since the "T" was ment to stand for temporary).
198069 : // When this happens the variantT() will be depricated.
198070 : VariantT
198071 79 : SgOmpTargetTeamsDistributeSimdStatement::variantT() const
198072 : {
198073 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
198074 79 : ROSE_ASSERT(this != NULL);
198075 79 : return V_SgOmpTargetTeamsDistributeSimdStatement;
198076 : }
198077 :
198078 : #if 0
198079 : int
198080 : SgOmpTargetTeamsDistributeSimdStatement::variant() const
198081 : {
198082 : // This function is used in SAGE
198083 : ROSE_ASSERT(this != NULL);
198084 : return OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_STMT;
198085 : }
198086 : #endif
198087 :
198088 : ROSE_DLL_API const char*
198089 0 : SgOmpTargetTeamsDistributeSimdStatement::sage_class_name() const
198090 : {
198091 0 : ROSE_ASSERT(this != NULL);
198092 0 : return "SgOmpTargetTeamsDistributeSimdStatement";
198093 : }
198094 :
198095 : std::string
198096 1 : SgOmpTargetTeamsDistributeSimdStatement::class_name() const
198097 : {
198098 1 : ROSE_ASSERT(this != NULL);
198099 1 : return "SgOmpTargetTeamsDistributeSimdStatement";
198100 : }
198101 :
198102 : // DQ (11/26/2005): Support for visitor pattern mechanims
198103 : // (inferior to ROSE traversal mechanism, experimental).
198104 : void
198105 0 : SgOmpTargetTeamsDistributeSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
198106 : {
198107 0 : ROSE_ASSERT(this != NULL);
198108 0 : visitor.visit(this);
198109 0 : }
198110 :
198111 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
198112 0 : void SgOmpTargetTeamsDistributeSimdStatement::accept (ROSE_VisitorPattern & visitor) {
198113 0 : ROSE_ASSERT(this != NULL);
198114 0 : visitor.visit(this);
198115 0 : }
198116 :
198117 : SgOmpTargetTeamsDistributeSimdStatement*
198118 0 : SgOmpTargetTeamsDistributeSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
198119 : {
198120 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
198121 : // This function is currently only supported for the AST used the represent Binary executables.
198122 : if (0 /* isSgAsmNode(this) != NULL */)
198123 : {
198124 : // Support for regex specification.
198125 : std::string prefixCode = "REGEX:";
198126 : addNewAttribute(prefixCode + s,a);
198127 : }
198128 : #endif
198129 :
198130 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
198131 0 : return this;
198132 : }
198133 :
198134 : // *** COMMON CODE SECTION ENDS HERE ***
198135 :
198136 :
198137 : // End of memberFunctionString
198138 : // Start of memberFunctionString
198139 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
198140 :
198141 :
198142 : #if 0
198143 : //! Error checking support
198144 : /*! Verifies the following:
198145 : - working getVariant() member function
198146 : - calls base class's error() member function
198147 : Every class has one of these functions.
198148 : */
198149 : bool
198150 : SgOmpTargetTeamsDistributeSimdStatement::error()
198151 : {
198152 : // Put error checking here
198153 :
198154 : ROSE_ASSERT (this != NULL);
198155 : if (getVariant() != OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_STMT)
198156 : {
198157 : printf ("Error in SgOmpTargetTeamsDistributeSimdStatement::error(): SgOmpTargetTeamsDistributeSimdStatement object has a %s variant \n",
198158 : Cxx_GrammarTerminalNames[getVariant()].name);
198159 : // printf ("Error in SgOmpTargetTeamsDistributeSimdStatement::error() \n");
198160 : ROSE_ABORT();
198161 : }
198162 :
198163 : ROSE_ASSERT (getVariant() == OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_STMT);
198164 : return SgUpirFieldBodyStatement::error();
198165 : }
198166 : #endif
198167 :
198168 :
198169 :
198170 : // End of memberFunctionString
198171 :
198172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
198173 :
198174 1 : SgOmpTargetTeamsDistributeSimdStatement* isSgOmpTargetTeamsDistributeSimdStatement ( SgNode* inputDerivedClassPointer )
198175 : {
198176 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198177 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198178 : // So to fix this we return NULL directly when the input is NULL and avoid the
198179 : // dynamic_cast in this case. This is likely a performance improvement as well.
198180 : // return dynamic_cast<SgOmpTargetTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
198181 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeSimdStatement uses table-driven castability instead of c++ default dynamic_cast
198182 : // this improves the running time performance by 10-20%.
198183 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
198184 1 : return IS_SgOmpTargetTeamsDistributeSimdStatement_FAST_MACRO(inputDerivedClassPointer);
198185 : }
198186 :
198187 : // DQ (11/8/2003): Added version of functions taking const pointer
198188 0 : const SgOmpTargetTeamsDistributeSimdStatement* isSgOmpTargetTeamsDistributeSimdStatement ( const SgNode* inputDerivedClassPointer )
198189 : {
198190 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198191 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198192 : // So to fix this we return NULL directly when the input is NULL and avoid the
198193 : // dynamic_cast in this case. This is likely a performance improvement as well.
198194 : // return dynamic_cast<const SgOmpTargetTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
198195 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeSimdStatement uses table-driven castability instead of c++ default dynamic_cast
198196 : // this improves the running time performance by 10-20%.
198197 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
198198 0 : return IS_SgOmpTargetTeamsDistributeSimdStatement_FAST_MACRO(inputDerivedClassPointer);
198199 : }
198200 :
198201 :
198202 :
198203 : /* #line 198204 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198204 :
198205 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198206 :
198207 : /**
198208 : \brief Generated destructor
198209 :
198210 : This destructor is automatically generated (by ROSETTA). This destructor
198211 : only frees memory of data members associated with the parts of the current IR node which
198212 : are NOT traversed. Those data members that are part of a traversal can be freed using
198213 : a traversal (calling this destructor on all children in a post-order traversal). Such
198214 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
198215 :
198216 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
198217 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
198218 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
198219 :
198220 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
198221 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
198222 : pointers are not yet implemented to call delete on eash pointer in the container.
198223 : (This could be done by derivation from the STL containers to define containers that
198224 : automatically deleted their members.)
198225 :
198226 : */
198227 0 : SgOmpTargetTeamsDistributeSimdStatement::~SgOmpTargetTeamsDistributeSimdStatement () {
198228 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
198229 :
198230 :
198231 :
198232 : }
198233 :
198234 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198235 0 : }
198236 :
198237 :
198238 : /* #line 198239 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198239 :
198240 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
198241 :
198242 : // Generated constructor
198243 1 : SgOmpTargetTeamsDistributeSimdStatement::SgOmpTargetTeamsDistributeSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
198244 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
198245 : {
198246 : #ifdef DEBUG
198247 : // printf ("In SgOmpTargetTeamsDistributeSimdStatement::SgOmpTargetTeamsDistributeSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
198248 : #endif
198249 : #if 0
198250 : // debugging information!
198251 : printf ("In SgOmpTargetTeamsDistributeSimdStatement::SgOmpTargetTeamsDistributeSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
198252 : #endif
198253 :
198254 :
198255 :
198256 : #if 0
198257 : // DQ (7/30/2014): Call a virtual function.
198258 : std::string s = this->class_name();
198259 : #endif
198260 :
198261 : // Test the variant virtual function
198262 : // assert(OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_STMT == variant());
198263 1 : assert(OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_STMT == this->variant());
198264 1 : ROSE_ASSERT(OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_STMT == (int)(this->variantT()));
198265 1 : post_construction_initialization();
198266 :
198267 : // Test the isSgOmpTargetTeamsDistributeSimdStatement() function since it has been problematic
198268 1 : assert(isSgOmpTargetTeamsDistributeSimdStatement(this) != NULL);
198269 1 : }
198270 :
198271 : // Generated constructor (all data members)
198272 :
198273 : /* #line 198274 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198274 :
198275 :
198276 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198277 :
198278 :
198279 : // ********************************************************
198280 : // member functions common across all array grammar objects
198281 : // ********************************************************
198282 :
198283 :
198284 :
198285 : /* #line 198286 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198286 :
198287 :
198288 :
198289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198290 :
198291 : // ********************************************************
198292 : // member functions specific to each node in the grammar
198293 : // ********************************************************
198294 :
198295 :
198296 : /* #line 198297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198297 :
198298 : // Start of memberFunctionString
198299 : /* #line 19349 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
198300 :
198301 : void
198302 1 : SgOmpTargetTeamsLoopStatement::post_construction_initialization()
198303 1 : {}
198304 :
198305 :
198306 : // End of memberFunctionString
198307 : // Start of memberFunctionString
198308 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
198309 :
198310 : // *** COMMON CODE SECTION BEGINS HERE ***
198311 :
198312 : #if 0
198313 : int
198314 : SgOmpTargetTeamsLoopStatement::getVariant() const
198315 : {
198316 : // This function is used in ROSE while "variant()" is used in SAGE
198317 : assert(this != NULL);
198318 : return variant();
198319 : }
198320 : #endif
198321 :
198322 : // This function is used in ROSE in treeTraversal code
198323 : // eventually replaces getVariant() and variant()
198324 : // though after variant() has been removed for a while we will
198325 : // want to change the name of variantT() back to variant()
198326 : // (since the "T" was ment to stand for temporary).
198327 : // When this happens the variantT() will be depricated.
198328 : VariantT
198329 79 : SgOmpTargetTeamsLoopStatement::variantT() const
198330 : {
198331 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
198332 79 : ROSE_ASSERT(this != NULL);
198333 79 : return V_SgOmpTargetTeamsLoopStatement;
198334 : }
198335 :
198336 : #if 0
198337 : int
198338 : SgOmpTargetTeamsLoopStatement::variant() const
198339 : {
198340 : // This function is used in SAGE
198341 : ROSE_ASSERT(this != NULL);
198342 : return OMP_TARGET_TEAMS_LOOP_STMT;
198343 : }
198344 : #endif
198345 :
198346 : ROSE_DLL_API const char*
198347 0 : SgOmpTargetTeamsLoopStatement::sage_class_name() const
198348 : {
198349 0 : ROSE_ASSERT(this != NULL);
198350 0 : return "SgOmpTargetTeamsLoopStatement";
198351 : }
198352 :
198353 : std::string
198354 1 : SgOmpTargetTeamsLoopStatement::class_name() const
198355 : {
198356 1 : ROSE_ASSERT(this != NULL);
198357 1 : return "SgOmpTargetTeamsLoopStatement";
198358 : }
198359 :
198360 : // DQ (11/26/2005): Support for visitor pattern mechanims
198361 : // (inferior to ROSE traversal mechanism, experimental).
198362 : void
198363 0 : SgOmpTargetTeamsLoopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
198364 : {
198365 0 : ROSE_ASSERT(this != NULL);
198366 0 : visitor.visit(this);
198367 0 : }
198368 :
198369 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
198370 0 : void SgOmpTargetTeamsLoopStatement::accept (ROSE_VisitorPattern & visitor) {
198371 0 : ROSE_ASSERT(this != NULL);
198372 0 : visitor.visit(this);
198373 0 : }
198374 :
198375 : SgOmpTargetTeamsLoopStatement*
198376 0 : SgOmpTargetTeamsLoopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
198377 : {
198378 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
198379 : // This function is currently only supported for the AST used the represent Binary executables.
198380 : if (0 /* isSgAsmNode(this) != NULL */)
198381 : {
198382 : // Support for regex specification.
198383 : std::string prefixCode = "REGEX:";
198384 : addNewAttribute(prefixCode + s,a);
198385 : }
198386 : #endif
198387 :
198388 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
198389 0 : return this;
198390 : }
198391 :
198392 : // *** COMMON CODE SECTION ENDS HERE ***
198393 :
198394 :
198395 : // End of memberFunctionString
198396 : // Start of memberFunctionString
198397 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
198398 :
198399 :
198400 : #if 0
198401 : //! Error checking support
198402 : /*! Verifies the following:
198403 : - working getVariant() member function
198404 : - calls base class's error() member function
198405 : Every class has one of these functions.
198406 : */
198407 : bool
198408 : SgOmpTargetTeamsLoopStatement::error()
198409 : {
198410 : // Put error checking here
198411 :
198412 : ROSE_ASSERT (this != NULL);
198413 : if (getVariant() != OMP_TARGET_TEAMS_LOOP_STMT)
198414 : {
198415 : printf ("Error in SgOmpTargetTeamsLoopStatement::error(): SgOmpTargetTeamsLoopStatement object has a %s variant \n",
198416 : Cxx_GrammarTerminalNames[getVariant()].name);
198417 : // printf ("Error in SgOmpTargetTeamsLoopStatement::error() \n");
198418 : ROSE_ABORT();
198419 : }
198420 :
198421 : ROSE_ASSERT (getVariant() == OMP_TARGET_TEAMS_LOOP_STMT);
198422 : return SgUpirFieldBodyStatement::error();
198423 : }
198424 : #endif
198425 :
198426 :
198427 :
198428 : // End of memberFunctionString
198429 :
198430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
198431 :
198432 1 : SgOmpTargetTeamsLoopStatement* isSgOmpTargetTeamsLoopStatement ( SgNode* inputDerivedClassPointer )
198433 : {
198434 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198435 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198436 : // So to fix this we return NULL directly when the input is NULL and avoid the
198437 : // dynamic_cast in this case. This is likely a performance improvement as well.
198438 : // return dynamic_cast<SgOmpTargetTeamsLoopStatement*>(inputDerivedClassPointer);
198439 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsLoopStatement uses table-driven castability instead of c++ default dynamic_cast
198440 : // this improves the running time performance by 10-20%.
198441 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetTeamsLoopStatement*>(inputDerivedClassPointer);
198442 1 : return IS_SgOmpTargetTeamsLoopStatement_FAST_MACRO(inputDerivedClassPointer);
198443 : }
198444 :
198445 : // DQ (11/8/2003): Added version of functions taking const pointer
198446 0 : const SgOmpTargetTeamsLoopStatement* isSgOmpTargetTeamsLoopStatement ( const SgNode* inputDerivedClassPointer )
198447 : {
198448 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198449 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198450 : // So to fix this we return NULL directly when the input is NULL and avoid the
198451 : // dynamic_cast in this case. This is likely a performance improvement as well.
198452 : // return dynamic_cast<const SgOmpTargetTeamsLoopStatement*>(inputDerivedClassPointer);
198453 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsLoopStatement uses table-driven castability instead of c++ default dynamic_cast
198454 : // this improves the running time performance by 10-20%.
198455 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetTeamsLoopStatement*>(inputDerivedClassPointer);
198456 0 : return IS_SgOmpTargetTeamsLoopStatement_FAST_MACRO(inputDerivedClassPointer);
198457 : }
198458 :
198459 :
198460 :
198461 : /* #line 198462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198462 :
198463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198464 :
198465 : /**
198466 : \brief Generated destructor
198467 :
198468 : This destructor is automatically generated (by ROSETTA). This destructor
198469 : only frees memory of data members associated with the parts of the current IR node which
198470 : are NOT traversed. Those data members that are part of a traversal can be freed using
198471 : a traversal (calling this destructor on all children in a post-order traversal). Such
198472 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
198473 :
198474 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
198475 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
198476 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
198477 :
198478 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
198479 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
198480 : pointers are not yet implemented to call delete on eash pointer in the container.
198481 : (This could be done by derivation from the STL containers to define containers that
198482 : automatically deleted their members.)
198483 :
198484 : */
198485 0 : SgOmpTargetTeamsLoopStatement::~SgOmpTargetTeamsLoopStatement () {
198486 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
198487 :
198488 :
198489 :
198490 : }
198491 :
198492 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198493 0 : }
198494 :
198495 :
198496 : /* #line 198497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198497 :
198498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
198499 :
198500 : // Generated constructor
198501 1 : SgOmpTargetTeamsLoopStatement::SgOmpTargetTeamsLoopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
198502 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
198503 : {
198504 : #ifdef DEBUG
198505 : // printf ("In SgOmpTargetTeamsLoopStatement::SgOmpTargetTeamsLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
198506 : #endif
198507 : #if 0
198508 : // debugging information!
198509 : printf ("In SgOmpTargetTeamsLoopStatement::SgOmpTargetTeamsLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
198510 : #endif
198511 :
198512 :
198513 :
198514 : #if 0
198515 : // DQ (7/30/2014): Call a virtual function.
198516 : std::string s = this->class_name();
198517 : #endif
198518 :
198519 : // Test the variant virtual function
198520 : // assert(OMP_TARGET_TEAMS_LOOP_STMT == variant());
198521 1 : assert(OMP_TARGET_TEAMS_LOOP_STMT == this->variant());
198522 1 : ROSE_ASSERT(OMP_TARGET_TEAMS_LOOP_STMT == (int)(this->variantT()));
198523 1 : post_construction_initialization();
198524 :
198525 : // Test the isSgOmpTargetTeamsLoopStatement() function since it has been problematic
198526 1 : assert(isSgOmpTargetTeamsLoopStatement(this) != NULL);
198527 1 : }
198528 :
198529 : // Generated constructor (all data members)
198530 :
198531 : /* #line 198532 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198532 :
198533 :
198534 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198535 :
198536 :
198537 : // ********************************************************
198538 : // member functions common across all array grammar objects
198539 : // ********************************************************
198540 :
198541 :
198542 :
198543 : /* #line 198544 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198544 :
198545 :
198546 :
198547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198548 :
198549 : // ********************************************************
198550 : // member functions specific to each node in the grammar
198551 : // ********************************************************
198552 :
198553 :
198554 : /* #line 198555 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198555 :
198556 : // Start of memberFunctionString
198557 : /* #line 19355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
198558 :
198559 : void
198560 1 : SgOmpTargetTeamsDistributeParallelForStatement::post_construction_initialization()
198561 1 : {}
198562 :
198563 :
198564 : // End of memberFunctionString
198565 : // Start of memberFunctionString
198566 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
198567 :
198568 : // *** COMMON CODE SECTION BEGINS HERE ***
198569 :
198570 : #if 0
198571 : int
198572 : SgOmpTargetTeamsDistributeParallelForStatement::getVariant() const
198573 : {
198574 : // This function is used in ROSE while "variant()" is used in SAGE
198575 : assert(this != NULL);
198576 : return variant();
198577 : }
198578 : #endif
198579 :
198580 : // This function is used in ROSE in treeTraversal code
198581 : // eventually replaces getVariant() and variant()
198582 : // though after variant() has been removed for a while we will
198583 : // want to change the name of variantT() back to variant()
198584 : // (since the "T" was ment to stand for temporary).
198585 : // When this happens the variantT() will be depricated.
198586 : VariantT
198587 79 : SgOmpTargetTeamsDistributeParallelForStatement::variantT() const
198588 : {
198589 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
198590 79 : ROSE_ASSERT(this != NULL);
198591 79 : return V_SgOmpTargetTeamsDistributeParallelForStatement;
198592 : }
198593 :
198594 : #if 0
198595 : int
198596 : SgOmpTargetTeamsDistributeParallelForStatement::variant() const
198597 : {
198598 : // This function is used in SAGE
198599 : ROSE_ASSERT(this != NULL);
198600 : return OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT;
198601 : }
198602 : #endif
198603 :
198604 : ROSE_DLL_API const char*
198605 0 : SgOmpTargetTeamsDistributeParallelForStatement::sage_class_name() const
198606 : {
198607 0 : ROSE_ASSERT(this != NULL);
198608 0 : return "SgOmpTargetTeamsDistributeParallelForStatement";
198609 : }
198610 :
198611 : std::string
198612 1 : SgOmpTargetTeamsDistributeParallelForStatement::class_name() const
198613 : {
198614 1 : ROSE_ASSERT(this != NULL);
198615 1 : return "SgOmpTargetTeamsDistributeParallelForStatement";
198616 : }
198617 :
198618 : // DQ (11/26/2005): Support for visitor pattern mechanims
198619 : // (inferior to ROSE traversal mechanism, experimental).
198620 : void
198621 0 : SgOmpTargetTeamsDistributeParallelForStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
198622 : {
198623 0 : ROSE_ASSERT(this != NULL);
198624 0 : visitor.visit(this);
198625 0 : }
198626 :
198627 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
198628 0 : void SgOmpTargetTeamsDistributeParallelForStatement::accept (ROSE_VisitorPattern & visitor) {
198629 0 : ROSE_ASSERT(this != NULL);
198630 0 : visitor.visit(this);
198631 0 : }
198632 :
198633 : SgOmpTargetTeamsDistributeParallelForStatement*
198634 0 : SgOmpTargetTeamsDistributeParallelForStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
198635 : {
198636 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
198637 : // This function is currently only supported for the AST used the represent Binary executables.
198638 : if (0 /* isSgAsmNode(this) != NULL */)
198639 : {
198640 : // Support for regex specification.
198641 : std::string prefixCode = "REGEX:";
198642 : addNewAttribute(prefixCode + s,a);
198643 : }
198644 : #endif
198645 :
198646 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
198647 0 : return this;
198648 : }
198649 :
198650 : // *** COMMON CODE SECTION ENDS HERE ***
198651 :
198652 :
198653 : // End of memberFunctionString
198654 : // Start of memberFunctionString
198655 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
198656 :
198657 :
198658 : #if 0
198659 : //! Error checking support
198660 : /*! Verifies the following:
198661 : - working getVariant() member function
198662 : - calls base class's error() member function
198663 : Every class has one of these functions.
198664 : */
198665 : bool
198666 : SgOmpTargetTeamsDistributeParallelForStatement::error()
198667 : {
198668 : // Put error checking here
198669 :
198670 : ROSE_ASSERT (this != NULL);
198671 : if (getVariant() != OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT)
198672 : {
198673 : printf ("Error in SgOmpTargetTeamsDistributeParallelForStatement::error(): SgOmpTargetTeamsDistributeParallelForStatement object has a %s variant \n",
198674 : Cxx_GrammarTerminalNames[getVariant()].name);
198675 : // printf ("Error in SgOmpTargetTeamsDistributeParallelForStatement::error() \n");
198676 : ROSE_ABORT();
198677 : }
198678 :
198679 : ROSE_ASSERT (getVariant() == OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT);
198680 : return SgUpirFieldBodyStatement::error();
198681 : }
198682 : #endif
198683 :
198684 :
198685 :
198686 : // End of memberFunctionString
198687 :
198688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
198689 :
198690 1 : SgOmpTargetTeamsDistributeParallelForStatement* isSgOmpTargetTeamsDistributeParallelForStatement ( SgNode* inputDerivedClassPointer )
198691 : {
198692 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198693 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198694 : // So to fix this we return NULL directly when the input is NULL and avoid the
198695 : // dynamic_cast in this case. This is likely a performance improvement as well.
198696 : // return dynamic_cast<SgOmpTargetTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
198697 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
198698 : // this improves the running time performance by 10-20%.
198699 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
198700 1 : return IS_SgOmpTargetTeamsDistributeParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
198701 : }
198702 :
198703 : // DQ (11/8/2003): Added version of functions taking const pointer
198704 0 : const SgOmpTargetTeamsDistributeParallelForStatement* isSgOmpTargetTeamsDistributeParallelForStatement ( const SgNode* inputDerivedClassPointer )
198705 : {
198706 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198707 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198708 : // So to fix this we return NULL directly when the input is NULL and avoid the
198709 : // dynamic_cast in this case. This is likely a performance improvement as well.
198710 : // return dynamic_cast<const SgOmpTargetTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
198711 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
198712 : // this improves the running time performance by 10-20%.
198713 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
198714 0 : return IS_SgOmpTargetTeamsDistributeParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
198715 : }
198716 :
198717 :
198718 :
198719 : /* #line 198720 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198720 :
198721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198722 :
198723 : /**
198724 : \brief Generated destructor
198725 :
198726 : This destructor is automatically generated (by ROSETTA). This destructor
198727 : only frees memory of data members associated with the parts of the current IR node which
198728 : are NOT traversed. Those data members that are part of a traversal can be freed using
198729 : a traversal (calling this destructor on all children in a post-order traversal). Such
198730 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
198731 :
198732 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
198733 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
198734 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
198735 :
198736 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
198737 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
198738 : pointers are not yet implemented to call delete on eash pointer in the container.
198739 : (This could be done by derivation from the STL containers to define containers that
198740 : automatically deleted their members.)
198741 :
198742 : */
198743 0 : SgOmpTargetTeamsDistributeParallelForStatement::~SgOmpTargetTeamsDistributeParallelForStatement () {
198744 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
198745 :
198746 :
198747 :
198748 : }
198749 :
198750 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198751 0 : }
198752 :
198753 :
198754 : /* #line 198755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198755 :
198756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
198757 :
198758 : // Generated constructor
198759 1 : SgOmpTargetTeamsDistributeParallelForStatement::SgOmpTargetTeamsDistributeParallelForStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
198760 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
198761 : {
198762 : #ifdef DEBUG
198763 : // printf ("In SgOmpTargetTeamsDistributeParallelForStatement::SgOmpTargetTeamsDistributeParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
198764 : #endif
198765 : #if 0
198766 : // debugging information!
198767 : printf ("In SgOmpTargetTeamsDistributeParallelForStatement::SgOmpTargetTeamsDistributeParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
198768 : #endif
198769 :
198770 :
198771 :
198772 : #if 0
198773 : // DQ (7/30/2014): Call a virtual function.
198774 : std::string s = this->class_name();
198775 : #endif
198776 :
198777 : // Test the variant virtual function
198778 : // assert(OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT == variant());
198779 1 : assert(OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT == this->variant());
198780 1 : ROSE_ASSERT(OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT == (int)(this->variantT()));
198781 1 : post_construction_initialization();
198782 :
198783 : // Test the isSgOmpTargetTeamsDistributeParallelForStatement() function since it has been problematic
198784 1 : assert(isSgOmpTargetTeamsDistributeParallelForStatement(this) != NULL);
198785 1 : }
198786 :
198787 : // Generated constructor (all data members)
198788 :
198789 : /* #line 198790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198790 :
198791 :
198792 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198793 :
198794 :
198795 : // ********************************************************
198796 : // member functions common across all array grammar objects
198797 : // ********************************************************
198798 :
198799 :
198800 :
198801 : /* #line 198802 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198802 :
198803 :
198804 :
198805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
198806 :
198807 : // ********************************************************
198808 : // member functions specific to each node in the grammar
198809 : // ********************************************************
198810 :
198811 :
198812 : /* #line 198813 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198813 :
198814 : // Start of memberFunctionString
198815 : /* #line 19361 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
198816 :
198817 : void
198818 1 : SgOmpTargetTeamsDistributeParallelForSimdStatement::post_construction_initialization()
198819 1 : {}
198820 :
198821 :
198822 : // End of memberFunctionString
198823 : // Start of memberFunctionString
198824 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
198825 :
198826 : // *** COMMON CODE SECTION BEGINS HERE ***
198827 :
198828 : #if 0
198829 : int
198830 : SgOmpTargetTeamsDistributeParallelForSimdStatement::getVariant() const
198831 : {
198832 : // This function is used in ROSE while "variant()" is used in SAGE
198833 : assert(this != NULL);
198834 : return variant();
198835 : }
198836 : #endif
198837 :
198838 : // This function is used in ROSE in treeTraversal code
198839 : // eventually replaces getVariant() and variant()
198840 : // though after variant() has been removed for a while we will
198841 : // want to change the name of variantT() back to variant()
198842 : // (since the "T" was ment to stand for temporary).
198843 : // When this happens the variantT() will be depricated.
198844 : VariantT
198845 79 : SgOmpTargetTeamsDistributeParallelForSimdStatement::variantT() const
198846 : {
198847 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
198848 79 : ROSE_ASSERT(this != NULL);
198849 79 : return V_SgOmpTargetTeamsDistributeParallelForSimdStatement;
198850 : }
198851 :
198852 : #if 0
198853 : int
198854 : SgOmpTargetTeamsDistributeParallelForSimdStatement::variant() const
198855 : {
198856 : // This function is used in SAGE
198857 : ROSE_ASSERT(this != NULL);
198858 : return OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT;
198859 : }
198860 : #endif
198861 :
198862 : ROSE_DLL_API const char*
198863 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::sage_class_name() const
198864 : {
198865 0 : ROSE_ASSERT(this != NULL);
198866 0 : return "SgOmpTargetTeamsDistributeParallelForSimdStatement";
198867 : }
198868 :
198869 : std::string
198870 1 : SgOmpTargetTeamsDistributeParallelForSimdStatement::class_name() const
198871 : {
198872 1 : ROSE_ASSERT(this != NULL);
198873 1 : return "SgOmpTargetTeamsDistributeParallelForSimdStatement";
198874 : }
198875 :
198876 : // DQ (11/26/2005): Support for visitor pattern mechanims
198877 : // (inferior to ROSE traversal mechanism, experimental).
198878 : void
198879 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
198880 : {
198881 0 : ROSE_ASSERT(this != NULL);
198882 0 : visitor.visit(this);
198883 0 : }
198884 :
198885 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
198886 0 : void SgOmpTargetTeamsDistributeParallelForSimdStatement::accept (ROSE_VisitorPattern & visitor) {
198887 0 : ROSE_ASSERT(this != NULL);
198888 0 : visitor.visit(this);
198889 0 : }
198890 :
198891 : SgOmpTargetTeamsDistributeParallelForSimdStatement*
198892 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
198893 : {
198894 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
198895 : // This function is currently only supported for the AST used the represent Binary executables.
198896 : if (0 /* isSgAsmNode(this) != NULL */)
198897 : {
198898 : // Support for regex specification.
198899 : std::string prefixCode = "REGEX:";
198900 : addNewAttribute(prefixCode + s,a);
198901 : }
198902 : #endif
198903 :
198904 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
198905 0 : return this;
198906 : }
198907 :
198908 : // *** COMMON CODE SECTION ENDS HERE ***
198909 :
198910 :
198911 : // End of memberFunctionString
198912 : // Start of memberFunctionString
198913 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
198914 :
198915 :
198916 : #if 0
198917 : //! Error checking support
198918 : /*! Verifies the following:
198919 : - working getVariant() member function
198920 : - calls base class's error() member function
198921 : Every class has one of these functions.
198922 : */
198923 : bool
198924 : SgOmpTargetTeamsDistributeParallelForSimdStatement::error()
198925 : {
198926 : // Put error checking here
198927 :
198928 : ROSE_ASSERT (this != NULL);
198929 : if (getVariant() != OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT)
198930 : {
198931 : printf ("Error in SgOmpTargetTeamsDistributeParallelForSimdStatement::error(): SgOmpTargetTeamsDistributeParallelForSimdStatement object has a %s variant \n",
198932 : Cxx_GrammarTerminalNames[getVariant()].name);
198933 : // printf ("Error in SgOmpTargetTeamsDistributeParallelForSimdStatement::error() \n");
198934 : ROSE_ABORT();
198935 : }
198936 :
198937 : ROSE_ASSERT (getVariant() == OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT);
198938 : return SgUpirFieldBodyStatement::error();
198939 : }
198940 : #endif
198941 :
198942 :
198943 :
198944 : // End of memberFunctionString
198945 :
198946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
198947 :
198948 1 : SgOmpTargetTeamsDistributeParallelForSimdStatement* isSgOmpTargetTeamsDistributeParallelForSimdStatement ( SgNode* inputDerivedClassPointer )
198949 : {
198950 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198951 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198952 : // So to fix this we return NULL directly when the input is NULL and avoid the
198953 : // dynamic_cast in this case. This is likely a performance improvement as well.
198954 : // return dynamic_cast<SgOmpTargetTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
198955 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
198956 : // this improves the running time performance by 10-20%.
198957 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
198958 1 : return IS_SgOmpTargetTeamsDistributeParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
198959 : }
198960 :
198961 : // DQ (11/8/2003): Added version of functions taking const pointer
198962 0 : const SgOmpTargetTeamsDistributeParallelForSimdStatement* isSgOmpTargetTeamsDistributeParallelForSimdStatement ( const SgNode* inputDerivedClassPointer )
198963 : {
198964 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
198965 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
198966 : // So to fix this we return NULL directly when the input is NULL and avoid the
198967 : // dynamic_cast in this case. This is likely a performance improvement as well.
198968 : // return dynamic_cast<const SgOmpTargetTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
198969 : // Milind Chabbi (8/28/2013): isSgOmpTargetTeamsDistributeParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
198970 : // this improves the running time performance by 10-20%.
198971 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
198972 0 : return IS_SgOmpTargetTeamsDistributeParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
198973 : }
198974 :
198975 :
198976 :
198977 : /* #line 198978 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
198978 :
198979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
198980 :
198981 : /**
198982 : \brief Generated destructor
198983 :
198984 : This destructor is automatically generated (by ROSETTA). This destructor
198985 : only frees memory of data members associated with the parts of the current IR node which
198986 : are NOT traversed. Those data members that are part of a traversal can be freed using
198987 : a traversal (calling this destructor on all children in a post-order traversal). Such
198988 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
198989 :
198990 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
198991 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
198992 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
198993 :
198994 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
198995 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
198996 : pointers are not yet implemented to call delete on eash pointer in the container.
198997 : (This could be done by derivation from the STL containers to define containers that
198998 : automatically deleted their members.)
198999 :
199000 : */
199001 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::~SgOmpTargetTeamsDistributeParallelForSimdStatement () {
199002 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
199003 :
199004 :
199005 :
199006 : }
199007 :
199008 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199009 0 : }
199010 :
199011 :
199012 : /* #line 199013 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199013 :
199014 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
199015 :
199016 : // Generated constructor
199017 1 : SgOmpTargetTeamsDistributeParallelForSimdStatement::SgOmpTargetTeamsDistributeParallelForSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
199018 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
199019 : {
199020 : #ifdef DEBUG
199021 : // printf ("In SgOmpTargetTeamsDistributeParallelForSimdStatement::SgOmpTargetTeamsDistributeParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
199022 : #endif
199023 : #if 0
199024 : // debugging information!
199025 : printf ("In SgOmpTargetTeamsDistributeParallelForSimdStatement::SgOmpTargetTeamsDistributeParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
199026 : #endif
199027 :
199028 :
199029 :
199030 : #if 0
199031 : // DQ (7/30/2014): Call a virtual function.
199032 : std::string s = this->class_name();
199033 : #endif
199034 :
199035 : // Test the variant virtual function
199036 : // assert(OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == variant());
199037 1 : assert(OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == this->variant());
199038 1 : ROSE_ASSERT(OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == (int)(this->variantT()));
199039 1 : post_construction_initialization();
199040 :
199041 : // Test the isSgOmpTargetTeamsDistributeParallelForSimdStatement() function since it has been problematic
199042 1 : assert(isSgOmpTargetTeamsDistributeParallelForSimdStatement(this) != NULL);
199043 1 : }
199044 :
199045 : // Generated constructor (all data members)
199046 :
199047 : /* #line 199048 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199048 :
199049 :
199050 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199051 :
199052 :
199053 : // ********************************************************
199054 : // member functions common across all array grammar objects
199055 : // ********************************************************
199056 :
199057 :
199058 :
199059 : /* #line 199060 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199060 :
199061 :
199062 :
199063 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199064 :
199065 : // ********************************************************
199066 : // member functions specific to each node in the grammar
199067 : // ********************************************************
199068 :
199069 :
199070 : /* #line 199071 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199071 :
199072 : // Start of memberFunctionString
199073 : /* #line 19283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
199074 :
199075 : void
199076 1 : SgOmpDistributeSimdStatement::post_construction_initialization()
199077 1 : {}
199078 :
199079 :
199080 : // End of memberFunctionString
199081 : // Start of memberFunctionString
199082 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
199083 :
199084 : // *** COMMON CODE SECTION BEGINS HERE ***
199085 :
199086 : #if 0
199087 : int
199088 : SgOmpDistributeSimdStatement::getVariant() const
199089 : {
199090 : // This function is used in ROSE while "variant()" is used in SAGE
199091 : assert(this != NULL);
199092 : return variant();
199093 : }
199094 : #endif
199095 :
199096 : // This function is used in ROSE in treeTraversal code
199097 : // eventually replaces getVariant() and variant()
199098 : // though after variant() has been removed for a while we will
199099 : // want to change the name of variantT() back to variant()
199100 : // (since the "T" was ment to stand for temporary).
199101 : // When this happens the variantT() will be depricated.
199102 : VariantT
199103 84 : SgOmpDistributeSimdStatement::variantT() const
199104 : {
199105 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
199106 84 : ROSE_ASSERT(this != NULL);
199107 84 : return V_SgOmpDistributeSimdStatement;
199108 : }
199109 :
199110 : #if 0
199111 : int
199112 : SgOmpDistributeSimdStatement::variant() const
199113 : {
199114 : // This function is used in SAGE
199115 : ROSE_ASSERT(this != NULL);
199116 : return OMP_DISTRIBUTE_SIMD_STMT;
199117 : }
199118 : #endif
199119 :
199120 : ROSE_DLL_API const char*
199121 0 : SgOmpDistributeSimdStatement::sage_class_name() const
199122 : {
199123 0 : ROSE_ASSERT(this != NULL);
199124 0 : return "SgOmpDistributeSimdStatement";
199125 : }
199126 :
199127 : std::string
199128 1 : SgOmpDistributeSimdStatement::class_name() const
199129 : {
199130 1 : ROSE_ASSERT(this != NULL);
199131 1 : return "SgOmpDistributeSimdStatement";
199132 : }
199133 :
199134 : // DQ (11/26/2005): Support for visitor pattern mechanims
199135 : // (inferior to ROSE traversal mechanism, experimental).
199136 : void
199137 0 : SgOmpDistributeSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
199138 : {
199139 0 : ROSE_ASSERT(this != NULL);
199140 0 : visitor.visit(this);
199141 0 : }
199142 :
199143 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
199144 0 : void SgOmpDistributeSimdStatement::accept (ROSE_VisitorPattern & visitor) {
199145 0 : ROSE_ASSERT(this != NULL);
199146 0 : visitor.visit(this);
199147 0 : }
199148 :
199149 : SgOmpDistributeSimdStatement*
199150 0 : SgOmpDistributeSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
199151 : {
199152 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
199153 : // This function is currently only supported for the AST used the represent Binary executables.
199154 : if (0 /* isSgAsmNode(this) != NULL */)
199155 : {
199156 : // Support for regex specification.
199157 : std::string prefixCode = "REGEX:";
199158 : addNewAttribute(prefixCode + s,a);
199159 : }
199160 : #endif
199161 :
199162 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
199163 0 : return this;
199164 : }
199165 :
199166 : // *** COMMON CODE SECTION ENDS HERE ***
199167 :
199168 :
199169 : // End of memberFunctionString
199170 : // Start of memberFunctionString
199171 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
199172 :
199173 :
199174 : #if 0
199175 : //! Error checking support
199176 : /*! Verifies the following:
199177 : - working getVariant() member function
199178 : - calls base class's error() member function
199179 : Every class has one of these functions.
199180 : */
199181 : bool
199182 : SgOmpDistributeSimdStatement::error()
199183 : {
199184 : // Put error checking here
199185 :
199186 : ROSE_ASSERT (this != NULL);
199187 : if (getVariant() != OMP_DISTRIBUTE_SIMD_STMT)
199188 : {
199189 : printf ("Error in SgOmpDistributeSimdStatement::error(): SgOmpDistributeSimdStatement object has a %s variant \n",
199190 : Cxx_GrammarTerminalNames[getVariant()].name);
199191 : // printf ("Error in SgOmpDistributeSimdStatement::error() \n");
199192 : ROSE_ABORT();
199193 : }
199194 :
199195 : ROSE_ASSERT (getVariant() == OMP_DISTRIBUTE_SIMD_STMT);
199196 : return SgUpirFieldBodyStatement::error();
199197 : }
199198 : #endif
199199 :
199200 :
199201 :
199202 : // End of memberFunctionString
199203 :
199204 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
199205 :
199206 1 : SgOmpDistributeSimdStatement* isSgOmpDistributeSimdStatement ( SgNode* inputDerivedClassPointer )
199207 : {
199208 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199209 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199210 : // So to fix this we return NULL directly when the input is NULL and avoid the
199211 : // dynamic_cast in this case. This is likely a performance improvement as well.
199212 : // return dynamic_cast<SgOmpDistributeSimdStatement*>(inputDerivedClassPointer);
199213 : // Milind Chabbi (8/28/2013): isSgOmpDistributeSimdStatement uses table-driven castability instead of c++ default dynamic_cast
199214 : // this improves the running time performance by 10-20%.
199215 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDistributeSimdStatement*>(inputDerivedClassPointer);
199216 1 : return IS_SgOmpDistributeSimdStatement_FAST_MACRO(inputDerivedClassPointer);
199217 : }
199218 :
199219 : // DQ (11/8/2003): Added version of functions taking const pointer
199220 0 : const SgOmpDistributeSimdStatement* isSgOmpDistributeSimdStatement ( const SgNode* inputDerivedClassPointer )
199221 : {
199222 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199223 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199224 : // So to fix this we return NULL directly when the input is NULL and avoid the
199225 : // dynamic_cast in this case. This is likely a performance improvement as well.
199226 : // return dynamic_cast<const SgOmpDistributeSimdStatement*>(inputDerivedClassPointer);
199227 : // Milind Chabbi (8/28/2013): isSgOmpDistributeSimdStatement uses table-driven castability instead of c++ default dynamic_cast
199228 : // this improves the running time performance by 10-20%.
199229 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDistributeSimdStatement*>(inputDerivedClassPointer);
199230 0 : return IS_SgOmpDistributeSimdStatement_FAST_MACRO(inputDerivedClassPointer);
199231 : }
199232 :
199233 :
199234 :
199235 : /* #line 199236 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199236 :
199237 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199238 :
199239 : /**
199240 : \brief Generated destructor
199241 :
199242 : This destructor is automatically generated (by ROSETTA). This destructor
199243 : only frees memory of data members associated with the parts of the current IR node which
199244 : are NOT traversed. Those data members that are part of a traversal can be freed using
199245 : a traversal (calling this destructor on all children in a post-order traversal). Such
199246 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
199247 :
199248 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
199249 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
199250 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
199251 :
199252 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
199253 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
199254 : pointers are not yet implemented to call delete on eash pointer in the container.
199255 : (This could be done by derivation from the STL containers to define containers that
199256 : automatically deleted their members.)
199257 :
199258 : */
199259 0 : SgOmpDistributeSimdStatement::~SgOmpDistributeSimdStatement () {
199260 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
199261 :
199262 :
199263 :
199264 : }
199265 :
199266 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199267 0 : }
199268 :
199269 :
199270 : /* #line 199271 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199271 :
199272 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
199273 :
199274 : // Generated constructor
199275 1 : SgOmpDistributeSimdStatement::SgOmpDistributeSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
199276 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
199277 : {
199278 : #ifdef DEBUG
199279 : // printf ("In SgOmpDistributeSimdStatement::SgOmpDistributeSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
199280 : #endif
199281 : #if 0
199282 : // debugging information!
199283 : printf ("In SgOmpDistributeSimdStatement::SgOmpDistributeSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
199284 : #endif
199285 :
199286 :
199287 :
199288 : #if 0
199289 : // DQ (7/30/2014): Call a virtual function.
199290 : std::string s = this->class_name();
199291 : #endif
199292 :
199293 : // Test the variant virtual function
199294 : // assert(OMP_DISTRIBUTE_SIMD_STMT == variant());
199295 1 : assert(OMP_DISTRIBUTE_SIMD_STMT == this->variant());
199296 1 : ROSE_ASSERT(OMP_DISTRIBUTE_SIMD_STMT == (int)(this->variantT()));
199297 1 : post_construction_initialization();
199298 :
199299 : // Test the isSgOmpDistributeSimdStatement() function since it has been problematic
199300 1 : assert(isSgOmpDistributeSimdStatement(this) != NULL);
199301 1 : }
199302 :
199303 : // Generated constructor (all data members)
199304 :
199305 : /* #line 199306 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199306 :
199307 :
199308 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199309 :
199310 :
199311 : // ********************************************************
199312 : // member functions common across all array grammar objects
199313 : // ********************************************************
199314 :
199315 :
199316 :
199317 : /* #line 199318 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199318 :
199319 :
199320 :
199321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199322 :
199323 : // ********************************************************
199324 : // member functions specific to each node in the grammar
199325 : // ********************************************************
199326 :
199327 :
199328 : /* #line 199329 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199329 :
199330 : // Start of memberFunctionString
199331 : /* #line 19289 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
199332 :
199333 : void
199334 1 : SgOmpDistributeParallelForStatement::post_construction_initialization()
199335 1 : {}
199336 :
199337 :
199338 : // End of memberFunctionString
199339 : // Start of memberFunctionString
199340 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
199341 :
199342 : // *** COMMON CODE SECTION BEGINS HERE ***
199343 :
199344 : #if 0
199345 : int
199346 : SgOmpDistributeParallelForStatement::getVariant() const
199347 : {
199348 : // This function is used in ROSE while "variant()" is used in SAGE
199349 : assert(this != NULL);
199350 : return variant();
199351 : }
199352 : #endif
199353 :
199354 : // This function is used in ROSE in treeTraversal code
199355 : // eventually replaces getVariant() and variant()
199356 : // though after variant() has been removed for a while we will
199357 : // want to change the name of variantT() back to variant()
199358 : // (since the "T" was ment to stand for temporary).
199359 : // When this happens the variantT() will be depricated.
199360 : VariantT
199361 86 : SgOmpDistributeParallelForStatement::variantT() const
199362 : {
199363 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
199364 86 : ROSE_ASSERT(this != NULL);
199365 86 : return V_SgOmpDistributeParallelForStatement;
199366 : }
199367 :
199368 : #if 0
199369 : int
199370 : SgOmpDistributeParallelForStatement::variant() const
199371 : {
199372 : // This function is used in SAGE
199373 : ROSE_ASSERT(this != NULL);
199374 : return OMP_DISTRIBUTE_PARALLEL_FOR_STMT;
199375 : }
199376 : #endif
199377 :
199378 : ROSE_DLL_API const char*
199379 0 : SgOmpDistributeParallelForStatement::sage_class_name() const
199380 : {
199381 0 : ROSE_ASSERT(this != NULL);
199382 0 : return "SgOmpDistributeParallelForStatement";
199383 : }
199384 :
199385 : std::string
199386 1 : SgOmpDistributeParallelForStatement::class_name() const
199387 : {
199388 1 : ROSE_ASSERT(this != NULL);
199389 1 : return "SgOmpDistributeParallelForStatement";
199390 : }
199391 :
199392 : // DQ (11/26/2005): Support for visitor pattern mechanims
199393 : // (inferior to ROSE traversal mechanism, experimental).
199394 : void
199395 0 : SgOmpDistributeParallelForStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
199396 : {
199397 0 : ROSE_ASSERT(this != NULL);
199398 0 : visitor.visit(this);
199399 0 : }
199400 :
199401 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
199402 0 : void SgOmpDistributeParallelForStatement::accept (ROSE_VisitorPattern & visitor) {
199403 0 : ROSE_ASSERT(this != NULL);
199404 0 : visitor.visit(this);
199405 0 : }
199406 :
199407 : SgOmpDistributeParallelForStatement*
199408 0 : SgOmpDistributeParallelForStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
199409 : {
199410 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
199411 : // This function is currently only supported for the AST used the represent Binary executables.
199412 : if (0 /* isSgAsmNode(this) != NULL */)
199413 : {
199414 : // Support for regex specification.
199415 : std::string prefixCode = "REGEX:";
199416 : addNewAttribute(prefixCode + s,a);
199417 : }
199418 : #endif
199419 :
199420 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
199421 0 : return this;
199422 : }
199423 :
199424 : // *** COMMON CODE SECTION ENDS HERE ***
199425 :
199426 :
199427 : // End of memberFunctionString
199428 : // Start of memberFunctionString
199429 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
199430 :
199431 :
199432 : #if 0
199433 : //! Error checking support
199434 : /*! Verifies the following:
199435 : - working getVariant() member function
199436 : - calls base class's error() member function
199437 : Every class has one of these functions.
199438 : */
199439 : bool
199440 : SgOmpDistributeParallelForStatement::error()
199441 : {
199442 : // Put error checking here
199443 :
199444 : ROSE_ASSERT (this != NULL);
199445 : if (getVariant() != OMP_DISTRIBUTE_PARALLEL_FOR_STMT)
199446 : {
199447 : printf ("Error in SgOmpDistributeParallelForStatement::error(): SgOmpDistributeParallelForStatement object has a %s variant \n",
199448 : Cxx_GrammarTerminalNames[getVariant()].name);
199449 : // printf ("Error in SgOmpDistributeParallelForStatement::error() \n");
199450 : ROSE_ABORT();
199451 : }
199452 :
199453 : ROSE_ASSERT (getVariant() == OMP_DISTRIBUTE_PARALLEL_FOR_STMT);
199454 : return SgUpirFieldBodyStatement::error();
199455 : }
199456 : #endif
199457 :
199458 :
199459 :
199460 : // End of memberFunctionString
199461 :
199462 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
199463 :
199464 1 : SgOmpDistributeParallelForStatement* isSgOmpDistributeParallelForStatement ( SgNode* inputDerivedClassPointer )
199465 : {
199466 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199467 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199468 : // So to fix this we return NULL directly when the input is NULL and avoid the
199469 : // dynamic_cast in this case. This is likely a performance improvement as well.
199470 : // return dynamic_cast<SgOmpDistributeParallelForStatement*>(inputDerivedClassPointer);
199471 : // Milind Chabbi (8/28/2013): isSgOmpDistributeParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
199472 : // this improves the running time performance by 10-20%.
199473 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDistributeParallelForStatement*>(inputDerivedClassPointer);
199474 1 : return IS_SgOmpDistributeParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
199475 : }
199476 :
199477 : // DQ (11/8/2003): Added version of functions taking const pointer
199478 0 : const SgOmpDistributeParallelForStatement* isSgOmpDistributeParallelForStatement ( const SgNode* inputDerivedClassPointer )
199479 : {
199480 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199481 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199482 : // So to fix this we return NULL directly when the input is NULL and avoid the
199483 : // dynamic_cast in this case. This is likely a performance improvement as well.
199484 : // return dynamic_cast<const SgOmpDistributeParallelForStatement*>(inputDerivedClassPointer);
199485 : // Milind Chabbi (8/28/2013): isSgOmpDistributeParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
199486 : // this improves the running time performance by 10-20%.
199487 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDistributeParallelForStatement*>(inputDerivedClassPointer);
199488 0 : return IS_SgOmpDistributeParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
199489 : }
199490 :
199491 :
199492 :
199493 : /* #line 199494 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199494 :
199495 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199496 :
199497 : /**
199498 : \brief Generated destructor
199499 :
199500 : This destructor is automatically generated (by ROSETTA). This destructor
199501 : only frees memory of data members associated with the parts of the current IR node which
199502 : are NOT traversed. Those data members that are part of a traversal can be freed using
199503 : a traversal (calling this destructor on all children in a post-order traversal). Such
199504 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
199505 :
199506 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
199507 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
199508 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
199509 :
199510 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
199511 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
199512 : pointers are not yet implemented to call delete on eash pointer in the container.
199513 : (This could be done by derivation from the STL containers to define containers that
199514 : automatically deleted their members.)
199515 :
199516 : */
199517 0 : SgOmpDistributeParallelForStatement::~SgOmpDistributeParallelForStatement () {
199518 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
199519 :
199520 :
199521 :
199522 : }
199523 :
199524 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199525 0 : }
199526 :
199527 :
199528 : /* #line 199529 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199529 :
199530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
199531 :
199532 : // Generated constructor
199533 1 : SgOmpDistributeParallelForStatement::SgOmpDistributeParallelForStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
199534 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
199535 : {
199536 : #ifdef DEBUG
199537 : // printf ("In SgOmpDistributeParallelForStatement::SgOmpDistributeParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
199538 : #endif
199539 : #if 0
199540 : // debugging information!
199541 : printf ("In SgOmpDistributeParallelForStatement::SgOmpDistributeParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
199542 : #endif
199543 :
199544 :
199545 :
199546 : #if 0
199547 : // DQ (7/30/2014): Call a virtual function.
199548 : std::string s = this->class_name();
199549 : #endif
199550 :
199551 : // Test the variant virtual function
199552 : // assert(OMP_DISTRIBUTE_PARALLEL_FOR_STMT == variant());
199553 1 : assert(OMP_DISTRIBUTE_PARALLEL_FOR_STMT == this->variant());
199554 1 : ROSE_ASSERT(OMP_DISTRIBUTE_PARALLEL_FOR_STMT == (int)(this->variantT()));
199555 1 : post_construction_initialization();
199556 :
199557 : // Test the isSgOmpDistributeParallelForStatement() function since it has been problematic
199558 1 : assert(isSgOmpDistributeParallelForStatement(this) != NULL);
199559 1 : }
199560 :
199561 : // Generated constructor (all data members)
199562 :
199563 : /* #line 199564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199564 :
199565 :
199566 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199567 :
199568 :
199569 : // ********************************************************
199570 : // member functions common across all array grammar objects
199571 : // ********************************************************
199572 :
199573 :
199574 :
199575 : /* #line 199576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199576 :
199577 :
199578 :
199579 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199580 :
199581 : // ********************************************************
199582 : // member functions specific to each node in the grammar
199583 : // ********************************************************
199584 :
199585 :
199586 : /* #line 199587 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199587 :
199588 : // Start of memberFunctionString
199589 : /* #line 19295 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
199590 :
199591 : void
199592 1 : SgOmpDistributeParallelForSimdStatement::post_construction_initialization()
199593 1 : {}
199594 :
199595 :
199596 : // End of memberFunctionString
199597 : // Start of memberFunctionString
199598 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
199599 :
199600 : // *** COMMON CODE SECTION BEGINS HERE ***
199601 :
199602 : #if 0
199603 : int
199604 : SgOmpDistributeParallelForSimdStatement::getVariant() const
199605 : {
199606 : // This function is used in ROSE while "variant()" is used in SAGE
199607 : assert(this != NULL);
199608 : return variant();
199609 : }
199610 : #endif
199611 :
199612 : // This function is used in ROSE in treeTraversal code
199613 : // eventually replaces getVariant() and variant()
199614 : // though after variant() has been removed for a while we will
199615 : // want to change the name of variantT() back to variant()
199616 : // (since the "T" was ment to stand for temporary).
199617 : // When this happens the variantT() will be depricated.
199618 : VariantT
199619 84 : SgOmpDistributeParallelForSimdStatement::variantT() const
199620 : {
199621 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
199622 84 : ROSE_ASSERT(this != NULL);
199623 84 : return V_SgOmpDistributeParallelForSimdStatement;
199624 : }
199625 :
199626 : #if 0
199627 : int
199628 : SgOmpDistributeParallelForSimdStatement::variant() const
199629 : {
199630 : // This function is used in SAGE
199631 : ROSE_ASSERT(this != NULL);
199632 : return OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT;
199633 : }
199634 : #endif
199635 :
199636 : ROSE_DLL_API const char*
199637 0 : SgOmpDistributeParallelForSimdStatement::sage_class_name() const
199638 : {
199639 0 : ROSE_ASSERT(this != NULL);
199640 0 : return "SgOmpDistributeParallelForSimdStatement";
199641 : }
199642 :
199643 : std::string
199644 1 : SgOmpDistributeParallelForSimdStatement::class_name() const
199645 : {
199646 1 : ROSE_ASSERT(this != NULL);
199647 1 : return "SgOmpDistributeParallelForSimdStatement";
199648 : }
199649 :
199650 : // DQ (11/26/2005): Support for visitor pattern mechanims
199651 : // (inferior to ROSE traversal mechanism, experimental).
199652 : void
199653 0 : SgOmpDistributeParallelForSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
199654 : {
199655 0 : ROSE_ASSERT(this != NULL);
199656 0 : visitor.visit(this);
199657 0 : }
199658 :
199659 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
199660 0 : void SgOmpDistributeParallelForSimdStatement::accept (ROSE_VisitorPattern & visitor) {
199661 0 : ROSE_ASSERT(this != NULL);
199662 0 : visitor.visit(this);
199663 0 : }
199664 :
199665 : SgOmpDistributeParallelForSimdStatement*
199666 0 : SgOmpDistributeParallelForSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
199667 : {
199668 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
199669 : // This function is currently only supported for the AST used the represent Binary executables.
199670 : if (0 /* isSgAsmNode(this) != NULL */)
199671 : {
199672 : // Support for regex specification.
199673 : std::string prefixCode = "REGEX:";
199674 : addNewAttribute(prefixCode + s,a);
199675 : }
199676 : #endif
199677 :
199678 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
199679 0 : return this;
199680 : }
199681 :
199682 : // *** COMMON CODE SECTION ENDS HERE ***
199683 :
199684 :
199685 : // End of memberFunctionString
199686 : // Start of memberFunctionString
199687 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
199688 :
199689 :
199690 : #if 0
199691 : //! Error checking support
199692 : /*! Verifies the following:
199693 : - working getVariant() member function
199694 : - calls base class's error() member function
199695 : Every class has one of these functions.
199696 : */
199697 : bool
199698 : SgOmpDistributeParallelForSimdStatement::error()
199699 : {
199700 : // Put error checking here
199701 :
199702 : ROSE_ASSERT (this != NULL);
199703 : if (getVariant() != OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT)
199704 : {
199705 : printf ("Error in SgOmpDistributeParallelForSimdStatement::error(): SgOmpDistributeParallelForSimdStatement object has a %s variant \n",
199706 : Cxx_GrammarTerminalNames[getVariant()].name);
199707 : // printf ("Error in SgOmpDistributeParallelForSimdStatement::error() \n");
199708 : ROSE_ABORT();
199709 : }
199710 :
199711 : ROSE_ASSERT (getVariant() == OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT);
199712 : return SgUpirFieldBodyStatement::error();
199713 : }
199714 : #endif
199715 :
199716 :
199717 :
199718 : // End of memberFunctionString
199719 :
199720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
199721 :
199722 1 : SgOmpDistributeParallelForSimdStatement* isSgOmpDistributeParallelForSimdStatement ( SgNode* inputDerivedClassPointer )
199723 : {
199724 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199725 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199726 : // So to fix this we return NULL directly when the input is NULL and avoid the
199727 : // dynamic_cast in this case. This is likely a performance improvement as well.
199728 : // return dynamic_cast<SgOmpDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
199729 : // Milind Chabbi (8/28/2013): isSgOmpDistributeParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
199730 : // this improves the running time performance by 10-20%.
199731 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
199732 1 : return IS_SgOmpDistributeParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
199733 : }
199734 :
199735 : // DQ (11/8/2003): Added version of functions taking const pointer
199736 0 : const SgOmpDistributeParallelForSimdStatement* isSgOmpDistributeParallelForSimdStatement ( const SgNode* inputDerivedClassPointer )
199737 : {
199738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199740 : // So to fix this we return NULL directly when the input is NULL and avoid the
199741 : // dynamic_cast in this case. This is likely a performance improvement as well.
199742 : // return dynamic_cast<const SgOmpDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
199743 : // Milind Chabbi (8/28/2013): isSgOmpDistributeParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
199744 : // this improves the running time performance by 10-20%.
199745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
199746 0 : return IS_SgOmpDistributeParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
199747 : }
199748 :
199749 :
199750 :
199751 : /* #line 199752 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199752 :
199753 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199754 :
199755 : /**
199756 : \brief Generated destructor
199757 :
199758 : This destructor is automatically generated (by ROSETTA). This destructor
199759 : only frees memory of data members associated with the parts of the current IR node which
199760 : are NOT traversed. Those data members that are part of a traversal can be freed using
199761 : a traversal (calling this destructor on all children in a post-order traversal). Such
199762 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
199763 :
199764 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
199765 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
199766 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
199767 :
199768 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
199769 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
199770 : pointers are not yet implemented to call delete on eash pointer in the container.
199771 : (This could be done by derivation from the STL containers to define containers that
199772 : automatically deleted their members.)
199773 :
199774 : */
199775 0 : SgOmpDistributeParallelForSimdStatement::~SgOmpDistributeParallelForSimdStatement () {
199776 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
199777 :
199778 :
199779 :
199780 : }
199781 :
199782 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
199783 0 : }
199784 :
199785 :
199786 : /* #line 199787 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199787 :
199788 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
199789 :
199790 : // Generated constructor
199791 1 : SgOmpDistributeParallelForSimdStatement::SgOmpDistributeParallelForSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
199792 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
199793 : {
199794 : #ifdef DEBUG
199795 : // printf ("In SgOmpDistributeParallelForSimdStatement::SgOmpDistributeParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
199796 : #endif
199797 : #if 0
199798 : // debugging information!
199799 : printf ("In SgOmpDistributeParallelForSimdStatement::SgOmpDistributeParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
199800 : #endif
199801 :
199802 :
199803 :
199804 : #if 0
199805 : // DQ (7/30/2014): Call a virtual function.
199806 : std::string s = this->class_name();
199807 : #endif
199808 :
199809 : // Test the variant virtual function
199810 : // assert(OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == variant());
199811 1 : assert(OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == this->variant());
199812 1 : ROSE_ASSERT(OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == (int)(this->variantT()));
199813 1 : post_construction_initialization();
199814 :
199815 : // Test the isSgOmpDistributeParallelForSimdStatement() function since it has been problematic
199816 1 : assert(isSgOmpDistributeParallelForSimdStatement(this) != NULL);
199817 1 : }
199818 :
199819 : // Generated constructor (all data members)
199820 :
199821 : /* #line 199822 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199822 :
199823 :
199824 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199825 :
199826 :
199827 : // ********************************************************
199828 : // member functions common across all array grammar objects
199829 : // ********************************************************
199830 :
199831 :
199832 :
199833 : /* #line 199834 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199834 :
199835 :
199836 :
199837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
199838 :
199839 : // ********************************************************
199840 : // member functions specific to each node in the grammar
199841 : // ********************************************************
199842 :
199843 :
199844 : /* #line 199845 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
199845 :
199846 : // Start of memberFunctionString
199847 : /* #line 19301 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
199848 :
199849 : void
199850 1 : SgOmpTaskloopSimdStatement::post_construction_initialization()
199851 1 : {}
199852 :
199853 :
199854 : // End of memberFunctionString
199855 : // Start of memberFunctionString
199856 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
199857 :
199858 : // *** COMMON CODE SECTION BEGINS HERE ***
199859 :
199860 : #if 0
199861 : int
199862 : SgOmpTaskloopSimdStatement::getVariant() const
199863 : {
199864 : // This function is used in ROSE while "variant()" is used in SAGE
199865 : assert(this != NULL);
199866 : return variant();
199867 : }
199868 : #endif
199869 :
199870 : // This function is used in ROSE in treeTraversal code
199871 : // eventually replaces getVariant() and variant()
199872 : // though after variant() has been removed for a while we will
199873 : // want to change the name of variantT() back to variant()
199874 : // (since the "T" was ment to stand for temporary).
199875 : // When this happens the variantT() will be depricated.
199876 : VariantT
199877 86 : SgOmpTaskloopSimdStatement::variantT() const
199878 : {
199879 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
199880 86 : ROSE_ASSERT(this != NULL);
199881 86 : return V_SgOmpTaskloopSimdStatement;
199882 : }
199883 :
199884 : #if 0
199885 : int
199886 : SgOmpTaskloopSimdStatement::variant() const
199887 : {
199888 : // This function is used in SAGE
199889 : ROSE_ASSERT(this != NULL);
199890 : return OMP_TASKLOOP_SIMD_STMT;
199891 : }
199892 : #endif
199893 :
199894 : ROSE_DLL_API const char*
199895 0 : SgOmpTaskloopSimdStatement::sage_class_name() const
199896 : {
199897 0 : ROSE_ASSERT(this != NULL);
199898 0 : return "SgOmpTaskloopSimdStatement";
199899 : }
199900 :
199901 : std::string
199902 1 : SgOmpTaskloopSimdStatement::class_name() const
199903 : {
199904 1 : ROSE_ASSERT(this != NULL);
199905 1 : return "SgOmpTaskloopSimdStatement";
199906 : }
199907 :
199908 : // DQ (11/26/2005): Support for visitor pattern mechanims
199909 : // (inferior to ROSE traversal mechanism, experimental).
199910 : void
199911 0 : SgOmpTaskloopSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
199912 : {
199913 0 : ROSE_ASSERT(this != NULL);
199914 0 : visitor.visit(this);
199915 0 : }
199916 :
199917 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
199918 0 : void SgOmpTaskloopSimdStatement::accept (ROSE_VisitorPattern & visitor) {
199919 0 : ROSE_ASSERT(this != NULL);
199920 0 : visitor.visit(this);
199921 0 : }
199922 :
199923 : SgOmpTaskloopSimdStatement*
199924 0 : SgOmpTaskloopSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
199925 : {
199926 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
199927 : // This function is currently only supported for the AST used the represent Binary executables.
199928 : if (0 /* isSgAsmNode(this) != NULL */)
199929 : {
199930 : // Support for regex specification.
199931 : std::string prefixCode = "REGEX:";
199932 : addNewAttribute(prefixCode + s,a);
199933 : }
199934 : #endif
199935 :
199936 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
199937 0 : return this;
199938 : }
199939 :
199940 : // *** COMMON CODE SECTION ENDS HERE ***
199941 :
199942 :
199943 : // End of memberFunctionString
199944 : // Start of memberFunctionString
199945 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
199946 :
199947 :
199948 : #if 0
199949 : //! Error checking support
199950 : /*! Verifies the following:
199951 : - working getVariant() member function
199952 : - calls base class's error() member function
199953 : Every class has one of these functions.
199954 : */
199955 : bool
199956 : SgOmpTaskloopSimdStatement::error()
199957 : {
199958 : // Put error checking here
199959 :
199960 : ROSE_ASSERT (this != NULL);
199961 : if (getVariant() != OMP_TASKLOOP_SIMD_STMT)
199962 : {
199963 : printf ("Error in SgOmpTaskloopSimdStatement::error(): SgOmpTaskloopSimdStatement object has a %s variant \n",
199964 : Cxx_GrammarTerminalNames[getVariant()].name);
199965 : // printf ("Error in SgOmpTaskloopSimdStatement::error() \n");
199966 : ROSE_ABORT();
199967 : }
199968 :
199969 : ROSE_ASSERT (getVariant() == OMP_TASKLOOP_SIMD_STMT);
199970 : return SgUpirFieldBodyStatement::error();
199971 : }
199972 : #endif
199973 :
199974 :
199975 :
199976 : // End of memberFunctionString
199977 :
199978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
199979 :
199980 1 : SgOmpTaskloopSimdStatement* isSgOmpTaskloopSimdStatement ( SgNode* inputDerivedClassPointer )
199981 : {
199982 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199983 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199984 : // So to fix this we return NULL directly when the input is NULL and avoid the
199985 : // dynamic_cast in this case. This is likely a performance improvement as well.
199986 : // return dynamic_cast<SgOmpTaskloopSimdStatement*>(inputDerivedClassPointer);
199987 : // Milind Chabbi (8/28/2013): isSgOmpTaskloopSimdStatement uses table-driven castability instead of c++ default dynamic_cast
199988 : // this improves the running time performance by 10-20%.
199989 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTaskloopSimdStatement*>(inputDerivedClassPointer);
199990 1 : return IS_SgOmpTaskloopSimdStatement_FAST_MACRO(inputDerivedClassPointer);
199991 : }
199992 :
199993 : // DQ (11/8/2003): Added version of functions taking const pointer
199994 0 : const SgOmpTaskloopSimdStatement* isSgOmpTaskloopSimdStatement ( const SgNode* inputDerivedClassPointer )
199995 : {
199996 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
199997 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
199998 : // So to fix this we return NULL directly when the input is NULL and avoid the
199999 : // dynamic_cast in this case. This is likely a performance improvement as well.
200000 : // return dynamic_cast<const SgOmpTaskloopSimdStatement*>(inputDerivedClassPointer);
200001 : // Milind Chabbi (8/28/2013): isSgOmpTaskloopSimdStatement uses table-driven castability instead of c++ default dynamic_cast
200002 : // this improves the running time performance by 10-20%.
200003 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTaskloopSimdStatement*>(inputDerivedClassPointer);
200004 0 : return IS_SgOmpTaskloopSimdStatement_FAST_MACRO(inputDerivedClassPointer);
200005 : }
200006 :
200007 :
200008 :
200009 : /* #line 200010 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200010 :
200011 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200012 :
200013 : /**
200014 : \brief Generated destructor
200015 :
200016 : This destructor is automatically generated (by ROSETTA). This destructor
200017 : only frees memory of data members associated with the parts of the current IR node which
200018 : are NOT traversed. Those data members that are part of a traversal can be freed using
200019 : a traversal (calling this destructor on all children in a post-order traversal). Such
200020 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
200021 :
200022 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
200023 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
200024 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
200025 :
200026 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
200027 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
200028 : pointers are not yet implemented to call delete on eash pointer in the container.
200029 : (This could be done by derivation from the STL containers to define containers that
200030 : automatically deleted their members.)
200031 :
200032 : */
200033 0 : SgOmpTaskloopSimdStatement::~SgOmpTaskloopSimdStatement () {
200034 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
200035 :
200036 :
200037 :
200038 : }
200039 :
200040 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200041 0 : }
200042 :
200043 :
200044 : /* #line 200045 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200045 :
200046 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
200047 :
200048 : // Generated constructor
200049 1 : SgOmpTaskloopSimdStatement::SgOmpTaskloopSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
200050 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
200051 : {
200052 : #ifdef DEBUG
200053 : // printf ("In SgOmpTaskloopSimdStatement::SgOmpTaskloopSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
200054 : #endif
200055 : #if 0
200056 : // debugging information!
200057 : printf ("In SgOmpTaskloopSimdStatement::SgOmpTaskloopSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
200058 : #endif
200059 :
200060 :
200061 :
200062 : #if 0
200063 : // DQ (7/30/2014): Call a virtual function.
200064 : std::string s = this->class_name();
200065 : #endif
200066 :
200067 : // Test the variant virtual function
200068 : // assert(OMP_TASKLOOP_SIMD_STMT == variant());
200069 1 : assert(OMP_TASKLOOP_SIMD_STMT == this->variant());
200070 1 : ROSE_ASSERT(OMP_TASKLOOP_SIMD_STMT == (int)(this->variantT()));
200071 1 : post_construction_initialization();
200072 :
200073 : // Test the isSgOmpTaskloopSimdStatement() function since it has been problematic
200074 1 : assert(isSgOmpTaskloopSimdStatement(this) != NULL);
200075 1 : }
200076 :
200077 : // Generated constructor (all data members)
200078 :
200079 : /* #line 200080 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200080 :
200081 :
200082 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200083 :
200084 :
200085 : // ********************************************************
200086 : // member functions common across all array grammar objects
200087 : // ********************************************************
200088 :
200089 :
200090 :
200091 : /* #line 200092 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200092 :
200093 :
200094 :
200095 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200096 :
200097 : // ********************************************************
200098 : // member functions specific to each node in the grammar
200099 : // ********************************************************
200100 :
200101 :
200102 : /* #line 200103 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200103 :
200104 : // Start of memberFunctionString
200105 : /* #line 19367 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
200106 :
200107 : void
200108 2 : SgOmpMasterTaskloopSimdStatement::post_construction_initialization()
200109 2 : {}
200110 :
200111 :
200112 : // End of memberFunctionString
200113 : // Start of memberFunctionString
200114 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
200115 :
200116 : // *** COMMON CODE SECTION BEGINS HERE ***
200117 :
200118 : #if 0
200119 : int
200120 : SgOmpMasterTaskloopSimdStatement::getVariant() const
200121 : {
200122 : // This function is used in ROSE while "variant()" is used in SAGE
200123 : assert(this != NULL);
200124 : return variant();
200125 : }
200126 : #endif
200127 :
200128 : // This function is used in ROSE in treeTraversal code
200129 : // eventually replaces getVariant() and variant()
200130 : // though after variant() has been removed for a while we will
200131 : // want to change the name of variantT() back to variant()
200132 : // (since the "T" was ment to stand for temporary).
200133 : // When this happens the variantT() will be depricated.
200134 : VariantT
200135 162 : SgOmpMasterTaskloopSimdStatement::variantT() const
200136 : {
200137 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
200138 162 : ROSE_ASSERT(this != NULL);
200139 162 : return V_SgOmpMasterTaskloopSimdStatement;
200140 : }
200141 :
200142 : #if 0
200143 : int
200144 : SgOmpMasterTaskloopSimdStatement::variant() const
200145 : {
200146 : // This function is used in SAGE
200147 : ROSE_ASSERT(this != NULL);
200148 : return OMP_MASTER_TASKLOOP_SIMD_STMT;
200149 : }
200150 : #endif
200151 :
200152 : ROSE_DLL_API const char*
200153 0 : SgOmpMasterTaskloopSimdStatement::sage_class_name() const
200154 : {
200155 0 : ROSE_ASSERT(this != NULL);
200156 0 : return "SgOmpMasterTaskloopSimdStatement";
200157 : }
200158 :
200159 : std::string
200160 2 : SgOmpMasterTaskloopSimdStatement::class_name() const
200161 : {
200162 2 : ROSE_ASSERT(this != NULL);
200163 2 : return "SgOmpMasterTaskloopSimdStatement";
200164 : }
200165 :
200166 : // DQ (11/26/2005): Support for visitor pattern mechanims
200167 : // (inferior to ROSE traversal mechanism, experimental).
200168 : void
200169 0 : SgOmpMasterTaskloopSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
200170 : {
200171 0 : ROSE_ASSERT(this != NULL);
200172 0 : visitor.visit(this);
200173 0 : }
200174 :
200175 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
200176 0 : void SgOmpMasterTaskloopSimdStatement::accept (ROSE_VisitorPattern & visitor) {
200177 0 : ROSE_ASSERT(this != NULL);
200178 0 : visitor.visit(this);
200179 0 : }
200180 :
200181 : SgOmpMasterTaskloopSimdStatement*
200182 0 : SgOmpMasterTaskloopSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
200183 : {
200184 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
200185 : // This function is currently only supported for the AST used the represent Binary executables.
200186 : if (0 /* isSgAsmNode(this) != NULL */)
200187 : {
200188 : // Support for regex specification.
200189 : std::string prefixCode = "REGEX:";
200190 : addNewAttribute(prefixCode + s,a);
200191 : }
200192 : #endif
200193 :
200194 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
200195 0 : return this;
200196 : }
200197 :
200198 : // *** COMMON CODE SECTION ENDS HERE ***
200199 :
200200 :
200201 : // End of memberFunctionString
200202 : // Start of memberFunctionString
200203 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
200204 :
200205 :
200206 : #if 0
200207 : //! Error checking support
200208 : /*! Verifies the following:
200209 : - working getVariant() member function
200210 : - calls base class's error() member function
200211 : Every class has one of these functions.
200212 : */
200213 : bool
200214 : SgOmpMasterTaskloopSimdStatement::error()
200215 : {
200216 : // Put error checking here
200217 :
200218 : ROSE_ASSERT (this != NULL);
200219 : if (getVariant() != OMP_MASTER_TASKLOOP_SIMD_STMT)
200220 : {
200221 : printf ("Error in SgOmpMasterTaskloopSimdStatement::error(): SgOmpMasterTaskloopSimdStatement object has a %s variant \n",
200222 : Cxx_GrammarTerminalNames[getVariant()].name);
200223 : // printf ("Error in SgOmpMasterTaskloopSimdStatement::error() \n");
200224 : ROSE_ABORT();
200225 : }
200226 :
200227 : ROSE_ASSERT (getVariant() == OMP_MASTER_TASKLOOP_SIMD_STMT);
200228 : return SgUpirFieldBodyStatement::error();
200229 : }
200230 : #endif
200231 :
200232 :
200233 :
200234 : // End of memberFunctionString
200235 :
200236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
200237 :
200238 2 : SgOmpMasterTaskloopSimdStatement* isSgOmpMasterTaskloopSimdStatement ( SgNode* inputDerivedClassPointer )
200239 : {
200240 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
200241 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
200242 : // So to fix this we return NULL directly when the input is NULL and avoid the
200243 : // dynamic_cast in this case. This is likely a performance improvement as well.
200244 : // return dynamic_cast<SgOmpMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200245 : // Milind Chabbi (8/28/2013): isSgOmpMasterTaskloopSimdStatement uses table-driven castability instead of c++ default dynamic_cast
200246 : // this improves the running time performance by 10-20%.
200247 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200248 2 : return IS_SgOmpMasterTaskloopSimdStatement_FAST_MACRO(inputDerivedClassPointer);
200249 : }
200250 :
200251 : // DQ (11/8/2003): Added version of functions taking const pointer
200252 0 : const SgOmpMasterTaskloopSimdStatement* isSgOmpMasterTaskloopSimdStatement ( const SgNode* inputDerivedClassPointer )
200253 : {
200254 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
200255 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
200256 : // So to fix this we return NULL directly when the input is NULL and avoid the
200257 : // dynamic_cast in this case. This is likely a performance improvement as well.
200258 : // return dynamic_cast<const SgOmpMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200259 : // Milind Chabbi (8/28/2013): isSgOmpMasterTaskloopSimdStatement uses table-driven castability instead of c++ default dynamic_cast
200260 : // this improves the running time performance by 10-20%.
200261 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200262 0 : return IS_SgOmpMasterTaskloopSimdStatement_FAST_MACRO(inputDerivedClassPointer);
200263 : }
200264 :
200265 :
200266 :
200267 : /* #line 200268 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200268 :
200269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200270 :
200271 : /**
200272 : \brief Generated destructor
200273 :
200274 : This destructor is automatically generated (by ROSETTA). This destructor
200275 : only frees memory of data members associated with the parts of the current IR node which
200276 : are NOT traversed. Those data members that are part of a traversal can be freed using
200277 : a traversal (calling this destructor on all children in a post-order traversal). Such
200278 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
200279 :
200280 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
200281 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
200282 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
200283 :
200284 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
200285 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
200286 : pointers are not yet implemented to call delete on eash pointer in the container.
200287 : (This could be done by derivation from the STL containers to define containers that
200288 : automatically deleted their members.)
200289 :
200290 : */
200291 0 : SgOmpMasterTaskloopSimdStatement::~SgOmpMasterTaskloopSimdStatement () {
200292 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
200293 :
200294 :
200295 :
200296 : }
200297 :
200298 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200299 0 : }
200300 :
200301 :
200302 : /* #line 200303 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200303 :
200304 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
200305 :
200306 : // Generated constructor
200307 2 : SgOmpMasterTaskloopSimdStatement::SgOmpMasterTaskloopSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
200308 2 : : SgUpirFieldBodyStatement(startOfConstruct, body)
200309 : {
200310 : #ifdef DEBUG
200311 : // printf ("In SgOmpMasterTaskloopSimdStatement::SgOmpMasterTaskloopSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
200312 : #endif
200313 : #if 0
200314 : // debugging information!
200315 : printf ("In SgOmpMasterTaskloopSimdStatement::SgOmpMasterTaskloopSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
200316 : #endif
200317 :
200318 :
200319 :
200320 : #if 0
200321 : // DQ (7/30/2014): Call a virtual function.
200322 : std::string s = this->class_name();
200323 : #endif
200324 :
200325 : // Test the variant virtual function
200326 : // assert(OMP_MASTER_TASKLOOP_SIMD_STMT == variant());
200327 2 : assert(OMP_MASTER_TASKLOOP_SIMD_STMT == this->variant());
200328 2 : ROSE_ASSERT(OMP_MASTER_TASKLOOP_SIMD_STMT == (int)(this->variantT()));
200329 2 : post_construction_initialization();
200330 :
200331 : // Test the isSgOmpMasterTaskloopSimdStatement() function since it has been problematic
200332 2 : assert(isSgOmpMasterTaskloopSimdStatement(this) != NULL);
200333 2 : }
200334 :
200335 : // Generated constructor (all data members)
200336 :
200337 : /* #line 200338 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200338 :
200339 :
200340 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200341 :
200342 :
200343 : // ********************************************************
200344 : // member functions common across all array grammar objects
200345 : // ********************************************************
200346 :
200347 :
200348 :
200349 : /* #line 200350 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200350 :
200351 :
200352 :
200353 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200354 :
200355 : // ********************************************************
200356 : // member functions specific to each node in the grammar
200357 : // ********************************************************
200358 :
200359 :
200360 : /* #line 200361 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200361 :
200362 : // Start of memberFunctionString
200363 : /* #line 19373 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
200364 :
200365 : void
200366 1 : SgOmpParallelMasterTaskloopStatement::post_construction_initialization()
200367 1 : {}
200368 :
200369 :
200370 : // End of memberFunctionString
200371 : // Start of memberFunctionString
200372 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
200373 :
200374 : // *** COMMON CODE SECTION BEGINS HERE ***
200375 :
200376 : #if 0
200377 : int
200378 : SgOmpParallelMasterTaskloopStatement::getVariant() const
200379 : {
200380 : // This function is used in ROSE while "variant()" is used in SAGE
200381 : assert(this != NULL);
200382 : return variant();
200383 : }
200384 : #endif
200385 :
200386 : // This function is used in ROSE in treeTraversal code
200387 : // eventually replaces getVariant() and variant()
200388 : // though after variant() has been removed for a while we will
200389 : // want to change the name of variantT() back to variant()
200390 : // (since the "T" was ment to stand for temporary).
200391 : // When this happens the variantT() will be depricated.
200392 : VariantT
200393 81 : SgOmpParallelMasterTaskloopStatement::variantT() const
200394 : {
200395 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
200396 81 : ROSE_ASSERT(this != NULL);
200397 81 : return V_SgOmpParallelMasterTaskloopStatement;
200398 : }
200399 :
200400 : #if 0
200401 : int
200402 : SgOmpParallelMasterTaskloopStatement::variant() const
200403 : {
200404 : // This function is used in SAGE
200405 : ROSE_ASSERT(this != NULL);
200406 : return OMP_PARALLEL_MASTER_TASKLOOP_STMT;
200407 : }
200408 : #endif
200409 :
200410 : ROSE_DLL_API const char*
200411 0 : SgOmpParallelMasterTaskloopStatement::sage_class_name() const
200412 : {
200413 0 : ROSE_ASSERT(this != NULL);
200414 0 : return "SgOmpParallelMasterTaskloopStatement";
200415 : }
200416 :
200417 : std::string
200418 1 : SgOmpParallelMasterTaskloopStatement::class_name() const
200419 : {
200420 1 : ROSE_ASSERT(this != NULL);
200421 1 : return "SgOmpParallelMasterTaskloopStatement";
200422 : }
200423 :
200424 : // DQ (11/26/2005): Support for visitor pattern mechanims
200425 : // (inferior to ROSE traversal mechanism, experimental).
200426 : void
200427 0 : SgOmpParallelMasterTaskloopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
200428 : {
200429 0 : ROSE_ASSERT(this != NULL);
200430 0 : visitor.visit(this);
200431 0 : }
200432 :
200433 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
200434 0 : void SgOmpParallelMasterTaskloopStatement::accept (ROSE_VisitorPattern & visitor) {
200435 0 : ROSE_ASSERT(this != NULL);
200436 0 : visitor.visit(this);
200437 0 : }
200438 :
200439 : SgOmpParallelMasterTaskloopStatement*
200440 0 : SgOmpParallelMasterTaskloopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
200441 : {
200442 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
200443 : // This function is currently only supported for the AST used the represent Binary executables.
200444 : if (0 /* isSgAsmNode(this) != NULL */)
200445 : {
200446 : // Support for regex specification.
200447 : std::string prefixCode = "REGEX:";
200448 : addNewAttribute(prefixCode + s,a);
200449 : }
200450 : #endif
200451 :
200452 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
200453 0 : return this;
200454 : }
200455 :
200456 : // *** COMMON CODE SECTION ENDS HERE ***
200457 :
200458 :
200459 : // End of memberFunctionString
200460 : // Start of memberFunctionString
200461 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
200462 :
200463 :
200464 : #if 0
200465 : //! Error checking support
200466 : /*! Verifies the following:
200467 : - working getVariant() member function
200468 : - calls base class's error() member function
200469 : Every class has one of these functions.
200470 : */
200471 : bool
200472 : SgOmpParallelMasterTaskloopStatement::error()
200473 : {
200474 : // Put error checking here
200475 :
200476 : ROSE_ASSERT (this != NULL);
200477 : if (getVariant() != OMP_PARALLEL_MASTER_TASKLOOP_STMT)
200478 : {
200479 : printf ("Error in SgOmpParallelMasterTaskloopStatement::error(): SgOmpParallelMasterTaskloopStatement object has a %s variant \n",
200480 : Cxx_GrammarTerminalNames[getVariant()].name);
200481 : // printf ("Error in SgOmpParallelMasterTaskloopStatement::error() \n");
200482 : ROSE_ABORT();
200483 : }
200484 :
200485 : ROSE_ASSERT (getVariant() == OMP_PARALLEL_MASTER_TASKLOOP_STMT);
200486 : return SgUpirFieldBodyStatement::error();
200487 : }
200488 : #endif
200489 :
200490 :
200491 :
200492 : // End of memberFunctionString
200493 :
200494 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
200495 :
200496 1 : SgOmpParallelMasterTaskloopStatement* isSgOmpParallelMasterTaskloopStatement ( SgNode* inputDerivedClassPointer )
200497 : {
200498 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
200499 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
200500 : // So to fix this we return NULL directly when the input is NULL and avoid the
200501 : // dynamic_cast in this case. This is likely a performance improvement as well.
200502 : // return dynamic_cast<SgOmpParallelMasterTaskloopStatement*>(inputDerivedClassPointer);
200503 : // Milind Chabbi (8/28/2013): isSgOmpParallelMasterTaskloopStatement uses table-driven castability instead of c++ default dynamic_cast
200504 : // this improves the running time performance by 10-20%.
200505 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpParallelMasterTaskloopStatement*>(inputDerivedClassPointer);
200506 1 : return IS_SgOmpParallelMasterTaskloopStatement_FAST_MACRO(inputDerivedClassPointer);
200507 : }
200508 :
200509 : // DQ (11/8/2003): Added version of functions taking const pointer
200510 0 : const SgOmpParallelMasterTaskloopStatement* isSgOmpParallelMasterTaskloopStatement ( const SgNode* inputDerivedClassPointer )
200511 : {
200512 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
200513 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
200514 : // So to fix this we return NULL directly when the input is NULL and avoid the
200515 : // dynamic_cast in this case. This is likely a performance improvement as well.
200516 : // return dynamic_cast<const SgOmpParallelMasterTaskloopStatement*>(inputDerivedClassPointer);
200517 : // Milind Chabbi (8/28/2013): isSgOmpParallelMasterTaskloopStatement uses table-driven castability instead of c++ default dynamic_cast
200518 : // this improves the running time performance by 10-20%.
200519 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpParallelMasterTaskloopStatement*>(inputDerivedClassPointer);
200520 0 : return IS_SgOmpParallelMasterTaskloopStatement_FAST_MACRO(inputDerivedClassPointer);
200521 : }
200522 :
200523 :
200524 :
200525 : /* #line 200526 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200526 :
200527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200528 :
200529 : /**
200530 : \brief Generated destructor
200531 :
200532 : This destructor is automatically generated (by ROSETTA). This destructor
200533 : only frees memory of data members associated with the parts of the current IR node which
200534 : are NOT traversed. Those data members that are part of a traversal can be freed using
200535 : a traversal (calling this destructor on all children in a post-order traversal). Such
200536 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
200537 :
200538 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
200539 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
200540 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
200541 :
200542 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
200543 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
200544 : pointers are not yet implemented to call delete on eash pointer in the container.
200545 : (This could be done by derivation from the STL containers to define containers that
200546 : automatically deleted their members.)
200547 :
200548 : */
200549 0 : SgOmpParallelMasterTaskloopStatement::~SgOmpParallelMasterTaskloopStatement () {
200550 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
200551 :
200552 :
200553 :
200554 : }
200555 :
200556 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200557 0 : }
200558 :
200559 :
200560 : /* #line 200561 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200561 :
200562 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
200563 :
200564 : // Generated constructor
200565 1 : SgOmpParallelMasterTaskloopStatement::SgOmpParallelMasterTaskloopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
200566 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
200567 : {
200568 : #ifdef DEBUG
200569 : // printf ("In SgOmpParallelMasterTaskloopStatement::SgOmpParallelMasterTaskloopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
200570 : #endif
200571 : #if 0
200572 : // debugging information!
200573 : printf ("In SgOmpParallelMasterTaskloopStatement::SgOmpParallelMasterTaskloopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
200574 : #endif
200575 :
200576 :
200577 :
200578 : #if 0
200579 : // DQ (7/30/2014): Call a virtual function.
200580 : std::string s = this->class_name();
200581 : #endif
200582 :
200583 : // Test the variant virtual function
200584 : // assert(OMP_PARALLEL_MASTER_TASKLOOP_STMT == variant());
200585 1 : assert(OMP_PARALLEL_MASTER_TASKLOOP_STMT == this->variant());
200586 1 : ROSE_ASSERT(OMP_PARALLEL_MASTER_TASKLOOP_STMT == (int)(this->variantT()));
200587 1 : post_construction_initialization();
200588 :
200589 : // Test the isSgOmpParallelMasterTaskloopStatement() function since it has been problematic
200590 1 : assert(isSgOmpParallelMasterTaskloopStatement(this) != NULL);
200591 1 : }
200592 :
200593 : // Generated constructor (all data members)
200594 :
200595 : /* #line 200596 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200596 :
200597 :
200598 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200599 :
200600 :
200601 : // ********************************************************
200602 : // member functions common across all array grammar objects
200603 : // ********************************************************
200604 :
200605 :
200606 :
200607 : /* #line 200608 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200608 :
200609 :
200610 :
200611 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200612 :
200613 : // ********************************************************
200614 : // member functions specific to each node in the grammar
200615 : // ********************************************************
200616 :
200617 :
200618 : /* #line 200619 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200619 :
200620 : // Start of memberFunctionString
200621 : /* #line 19379 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
200622 :
200623 : void
200624 1 : SgOmpParallelMasterTaskloopSimdStatement::post_construction_initialization()
200625 1 : {}
200626 :
200627 :
200628 : // End of memberFunctionString
200629 : // Start of memberFunctionString
200630 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
200631 :
200632 : // *** COMMON CODE SECTION BEGINS HERE ***
200633 :
200634 : #if 0
200635 : int
200636 : SgOmpParallelMasterTaskloopSimdStatement::getVariant() const
200637 : {
200638 : // This function is used in ROSE while "variant()" is used in SAGE
200639 : assert(this != NULL);
200640 : return variant();
200641 : }
200642 : #endif
200643 :
200644 : // This function is used in ROSE in treeTraversal code
200645 : // eventually replaces getVariant() and variant()
200646 : // though after variant() has been removed for a while we will
200647 : // want to change the name of variantT() back to variant()
200648 : // (since the "T" was ment to stand for temporary).
200649 : // When this happens the variantT() will be depricated.
200650 : VariantT
200651 81 : SgOmpParallelMasterTaskloopSimdStatement::variantT() const
200652 : {
200653 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
200654 81 : ROSE_ASSERT(this != NULL);
200655 81 : return V_SgOmpParallelMasterTaskloopSimdStatement;
200656 : }
200657 :
200658 : #if 0
200659 : int
200660 : SgOmpParallelMasterTaskloopSimdStatement::variant() const
200661 : {
200662 : // This function is used in SAGE
200663 : ROSE_ASSERT(this != NULL);
200664 : return OMP_PARALLEL_MASTER_TASKLOOP_SIMD_STMT;
200665 : }
200666 : #endif
200667 :
200668 : ROSE_DLL_API const char*
200669 0 : SgOmpParallelMasterTaskloopSimdStatement::sage_class_name() const
200670 : {
200671 0 : ROSE_ASSERT(this != NULL);
200672 0 : return "SgOmpParallelMasterTaskloopSimdStatement";
200673 : }
200674 :
200675 : std::string
200676 1 : SgOmpParallelMasterTaskloopSimdStatement::class_name() const
200677 : {
200678 1 : ROSE_ASSERT(this != NULL);
200679 1 : return "SgOmpParallelMasterTaskloopSimdStatement";
200680 : }
200681 :
200682 : // DQ (11/26/2005): Support for visitor pattern mechanims
200683 : // (inferior to ROSE traversal mechanism, experimental).
200684 : void
200685 0 : SgOmpParallelMasterTaskloopSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
200686 : {
200687 0 : ROSE_ASSERT(this != NULL);
200688 0 : visitor.visit(this);
200689 0 : }
200690 :
200691 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
200692 0 : void SgOmpParallelMasterTaskloopSimdStatement::accept (ROSE_VisitorPattern & visitor) {
200693 0 : ROSE_ASSERT(this != NULL);
200694 0 : visitor.visit(this);
200695 0 : }
200696 :
200697 : SgOmpParallelMasterTaskloopSimdStatement*
200698 0 : SgOmpParallelMasterTaskloopSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
200699 : {
200700 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
200701 : // This function is currently only supported for the AST used the represent Binary executables.
200702 : if (0 /* isSgAsmNode(this) != NULL */)
200703 : {
200704 : // Support for regex specification.
200705 : std::string prefixCode = "REGEX:";
200706 : addNewAttribute(prefixCode + s,a);
200707 : }
200708 : #endif
200709 :
200710 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
200711 0 : return this;
200712 : }
200713 :
200714 : // *** COMMON CODE SECTION ENDS HERE ***
200715 :
200716 :
200717 : // End of memberFunctionString
200718 : // Start of memberFunctionString
200719 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
200720 :
200721 :
200722 : #if 0
200723 : //! Error checking support
200724 : /*! Verifies the following:
200725 : - working getVariant() member function
200726 : - calls base class's error() member function
200727 : Every class has one of these functions.
200728 : */
200729 : bool
200730 : SgOmpParallelMasterTaskloopSimdStatement::error()
200731 : {
200732 : // Put error checking here
200733 :
200734 : ROSE_ASSERT (this != NULL);
200735 : if (getVariant() != OMP_PARALLEL_MASTER_TASKLOOP_SIMD_STMT)
200736 : {
200737 : printf ("Error in SgOmpParallelMasterTaskloopSimdStatement::error(): SgOmpParallelMasterTaskloopSimdStatement object has a %s variant \n",
200738 : Cxx_GrammarTerminalNames[getVariant()].name);
200739 : // printf ("Error in SgOmpParallelMasterTaskloopSimdStatement::error() \n");
200740 : ROSE_ABORT();
200741 : }
200742 :
200743 : ROSE_ASSERT (getVariant() == OMP_PARALLEL_MASTER_TASKLOOP_SIMD_STMT);
200744 : return SgUpirFieldBodyStatement::error();
200745 : }
200746 : #endif
200747 :
200748 :
200749 :
200750 : // End of memberFunctionString
200751 :
200752 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
200753 :
200754 1 : SgOmpParallelMasterTaskloopSimdStatement* isSgOmpParallelMasterTaskloopSimdStatement ( SgNode* inputDerivedClassPointer )
200755 : {
200756 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
200757 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
200758 : // So to fix this we return NULL directly when the input is NULL and avoid the
200759 : // dynamic_cast in this case. This is likely a performance improvement as well.
200760 : // return dynamic_cast<SgOmpParallelMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200761 : // Milind Chabbi (8/28/2013): isSgOmpParallelMasterTaskloopSimdStatement uses table-driven castability instead of c++ default dynamic_cast
200762 : // this improves the running time performance by 10-20%.
200763 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpParallelMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200764 1 : return IS_SgOmpParallelMasterTaskloopSimdStatement_FAST_MACRO(inputDerivedClassPointer);
200765 : }
200766 :
200767 : // DQ (11/8/2003): Added version of functions taking const pointer
200768 0 : const SgOmpParallelMasterTaskloopSimdStatement* isSgOmpParallelMasterTaskloopSimdStatement ( const SgNode* inputDerivedClassPointer )
200769 : {
200770 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
200771 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
200772 : // So to fix this we return NULL directly when the input is NULL and avoid the
200773 : // dynamic_cast in this case. This is likely a performance improvement as well.
200774 : // return dynamic_cast<const SgOmpParallelMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200775 : // Milind Chabbi (8/28/2013): isSgOmpParallelMasterTaskloopSimdStatement uses table-driven castability instead of c++ default dynamic_cast
200776 : // this improves the running time performance by 10-20%.
200777 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpParallelMasterTaskloopSimdStatement*>(inputDerivedClassPointer);
200778 0 : return IS_SgOmpParallelMasterTaskloopSimdStatement_FAST_MACRO(inputDerivedClassPointer);
200779 : }
200780 :
200781 :
200782 :
200783 : /* #line 200784 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200784 :
200785 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200786 :
200787 : /**
200788 : \brief Generated destructor
200789 :
200790 : This destructor is automatically generated (by ROSETTA). This destructor
200791 : only frees memory of data members associated with the parts of the current IR node which
200792 : are NOT traversed. Those data members that are part of a traversal can be freed using
200793 : a traversal (calling this destructor on all children in a post-order traversal). Such
200794 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
200795 :
200796 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
200797 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
200798 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
200799 :
200800 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
200801 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
200802 : pointers are not yet implemented to call delete on eash pointer in the container.
200803 : (This could be done by derivation from the STL containers to define containers that
200804 : automatically deleted their members.)
200805 :
200806 : */
200807 0 : SgOmpParallelMasterTaskloopSimdStatement::~SgOmpParallelMasterTaskloopSimdStatement () {
200808 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
200809 :
200810 :
200811 :
200812 : }
200813 :
200814 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
200815 0 : }
200816 :
200817 :
200818 : /* #line 200819 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200819 :
200820 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
200821 :
200822 : // Generated constructor
200823 1 : SgOmpParallelMasterTaskloopSimdStatement::SgOmpParallelMasterTaskloopSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
200824 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
200825 : {
200826 : #ifdef DEBUG
200827 : // printf ("In SgOmpParallelMasterTaskloopSimdStatement::SgOmpParallelMasterTaskloopSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
200828 : #endif
200829 : #if 0
200830 : // debugging information!
200831 : printf ("In SgOmpParallelMasterTaskloopSimdStatement::SgOmpParallelMasterTaskloopSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
200832 : #endif
200833 :
200834 :
200835 :
200836 : #if 0
200837 : // DQ (7/30/2014): Call a virtual function.
200838 : std::string s = this->class_name();
200839 : #endif
200840 :
200841 : // Test the variant virtual function
200842 : // assert(OMP_PARALLEL_MASTER_TASKLOOP_SIMD_STMT == variant());
200843 1 : assert(OMP_PARALLEL_MASTER_TASKLOOP_SIMD_STMT == this->variant());
200844 1 : ROSE_ASSERT(OMP_PARALLEL_MASTER_TASKLOOP_SIMD_STMT == (int)(this->variantT()));
200845 1 : post_construction_initialization();
200846 :
200847 : // Test the isSgOmpParallelMasterTaskloopSimdStatement() function since it has been problematic
200848 1 : assert(isSgOmpParallelMasterTaskloopSimdStatement(this) != NULL);
200849 1 : }
200850 :
200851 : // Generated constructor (all data members)
200852 :
200853 : /* #line 200854 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200854 :
200855 :
200856 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200857 :
200858 :
200859 : // ********************************************************
200860 : // member functions common across all array grammar objects
200861 : // ********************************************************
200862 :
200863 :
200864 :
200865 : /* #line 200866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200866 :
200867 :
200868 :
200869 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
200870 :
200871 : // ********************************************************
200872 : // member functions specific to each node in the grammar
200873 : // ********************************************************
200874 :
200875 :
200876 : /* #line 200877 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
200877 :
200878 : // Start of memberFunctionString
200879 : /* #line 19385 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
200880 :
200881 : void
200882 1 : SgOmpTeamsDistributeStatement::post_construction_initialization()
200883 1 : {}
200884 :
200885 :
200886 : // End of memberFunctionString
200887 : // Start of memberFunctionString
200888 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
200889 :
200890 : // *** COMMON CODE SECTION BEGINS HERE ***
200891 :
200892 : #if 0
200893 : int
200894 : SgOmpTeamsDistributeStatement::getVariant() const
200895 : {
200896 : // This function is used in ROSE while "variant()" is used in SAGE
200897 : assert(this != NULL);
200898 : return variant();
200899 : }
200900 : #endif
200901 :
200902 : // This function is used in ROSE in treeTraversal code
200903 : // eventually replaces getVariant() and variant()
200904 : // though after variant() has been removed for a while we will
200905 : // want to change the name of variantT() back to variant()
200906 : // (since the "T" was ment to stand for temporary).
200907 : // When this happens the variantT() will be depricated.
200908 : VariantT
200909 83 : SgOmpTeamsDistributeStatement::variantT() const
200910 : {
200911 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
200912 83 : ROSE_ASSERT(this != NULL);
200913 83 : return V_SgOmpTeamsDistributeStatement;
200914 : }
200915 :
200916 : #if 0
200917 : int
200918 : SgOmpTeamsDistributeStatement::variant() const
200919 : {
200920 : // This function is used in SAGE
200921 : ROSE_ASSERT(this != NULL);
200922 : return OMP_TEAMS_DISTRIBUTE_STMT;
200923 : }
200924 : #endif
200925 :
200926 : ROSE_DLL_API const char*
200927 0 : SgOmpTeamsDistributeStatement::sage_class_name() const
200928 : {
200929 0 : ROSE_ASSERT(this != NULL);
200930 0 : return "SgOmpTeamsDistributeStatement";
200931 : }
200932 :
200933 : std::string
200934 1 : SgOmpTeamsDistributeStatement::class_name() const
200935 : {
200936 1 : ROSE_ASSERT(this != NULL);
200937 1 : return "SgOmpTeamsDistributeStatement";
200938 : }
200939 :
200940 : // DQ (11/26/2005): Support for visitor pattern mechanims
200941 : // (inferior to ROSE traversal mechanism, experimental).
200942 : void
200943 0 : SgOmpTeamsDistributeStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
200944 : {
200945 0 : ROSE_ASSERT(this != NULL);
200946 0 : visitor.visit(this);
200947 0 : }
200948 :
200949 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
200950 0 : void SgOmpTeamsDistributeStatement::accept (ROSE_VisitorPattern & visitor) {
200951 0 : ROSE_ASSERT(this != NULL);
200952 0 : visitor.visit(this);
200953 0 : }
200954 :
200955 : SgOmpTeamsDistributeStatement*
200956 0 : SgOmpTeamsDistributeStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
200957 : {
200958 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
200959 : // This function is currently only supported for the AST used the represent Binary executables.
200960 : if (0 /* isSgAsmNode(this) != NULL */)
200961 : {
200962 : // Support for regex specification.
200963 : std::string prefixCode = "REGEX:";
200964 : addNewAttribute(prefixCode + s,a);
200965 : }
200966 : #endif
200967 :
200968 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
200969 0 : return this;
200970 : }
200971 :
200972 : // *** COMMON CODE SECTION ENDS HERE ***
200973 :
200974 :
200975 : // End of memberFunctionString
200976 : // Start of memberFunctionString
200977 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
200978 :
200979 :
200980 : #if 0
200981 : //! Error checking support
200982 : /*! Verifies the following:
200983 : - working getVariant() member function
200984 : - calls base class's error() member function
200985 : Every class has one of these functions.
200986 : */
200987 : bool
200988 : SgOmpTeamsDistributeStatement::error()
200989 : {
200990 : // Put error checking here
200991 :
200992 : ROSE_ASSERT (this != NULL);
200993 : if (getVariant() != OMP_TEAMS_DISTRIBUTE_STMT)
200994 : {
200995 : printf ("Error in SgOmpTeamsDistributeStatement::error(): SgOmpTeamsDistributeStatement object has a %s variant \n",
200996 : Cxx_GrammarTerminalNames[getVariant()].name);
200997 : // printf ("Error in SgOmpTeamsDistributeStatement::error() \n");
200998 : ROSE_ABORT();
200999 : }
201000 :
201001 : ROSE_ASSERT (getVariant() == OMP_TEAMS_DISTRIBUTE_STMT);
201002 : return SgUpirFieldBodyStatement::error();
201003 : }
201004 : #endif
201005 :
201006 :
201007 :
201008 : // End of memberFunctionString
201009 :
201010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
201011 :
201012 1 : SgOmpTeamsDistributeStatement* isSgOmpTeamsDistributeStatement ( SgNode* inputDerivedClassPointer )
201013 : {
201014 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201015 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201016 : // So to fix this we return NULL directly when the input is NULL and avoid the
201017 : // dynamic_cast in this case. This is likely a performance improvement as well.
201018 : // return dynamic_cast<SgOmpTeamsDistributeStatement*>(inputDerivedClassPointer);
201019 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeStatement uses table-driven castability instead of c++ default dynamic_cast
201020 : // this improves the running time performance by 10-20%.
201021 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTeamsDistributeStatement*>(inputDerivedClassPointer);
201022 1 : return IS_SgOmpTeamsDistributeStatement_FAST_MACRO(inputDerivedClassPointer);
201023 : }
201024 :
201025 : // DQ (11/8/2003): Added version of functions taking const pointer
201026 0 : const SgOmpTeamsDistributeStatement* isSgOmpTeamsDistributeStatement ( const SgNode* inputDerivedClassPointer )
201027 : {
201028 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201029 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201030 : // So to fix this we return NULL directly when the input is NULL and avoid the
201031 : // dynamic_cast in this case. This is likely a performance improvement as well.
201032 : // return dynamic_cast<const SgOmpTeamsDistributeStatement*>(inputDerivedClassPointer);
201033 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeStatement uses table-driven castability instead of c++ default dynamic_cast
201034 : // this improves the running time performance by 10-20%.
201035 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTeamsDistributeStatement*>(inputDerivedClassPointer);
201036 0 : return IS_SgOmpTeamsDistributeStatement_FAST_MACRO(inputDerivedClassPointer);
201037 : }
201038 :
201039 :
201040 :
201041 : /* #line 201042 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201042 :
201043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201044 :
201045 : /**
201046 : \brief Generated destructor
201047 :
201048 : This destructor is automatically generated (by ROSETTA). This destructor
201049 : only frees memory of data members associated with the parts of the current IR node which
201050 : are NOT traversed. Those data members that are part of a traversal can be freed using
201051 : a traversal (calling this destructor on all children in a post-order traversal). Such
201052 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
201053 :
201054 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
201055 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
201056 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
201057 :
201058 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
201059 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
201060 : pointers are not yet implemented to call delete on eash pointer in the container.
201061 : (This could be done by derivation from the STL containers to define containers that
201062 : automatically deleted their members.)
201063 :
201064 : */
201065 0 : SgOmpTeamsDistributeStatement::~SgOmpTeamsDistributeStatement () {
201066 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
201067 :
201068 :
201069 :
201070 : }
201071 :
201072 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201073 0 : }
201074 :
201075 :
201076 : /* #line 201077 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201077 :
201078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
201079 :
201080 : // Generated constructor
201081 1 : SgOmpTeamsDistributeStatement::SgOmpTeamsDistributeStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
201082 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
201083 : {
201084 : #ifdef DEBUG
201085 : // printf ("In SgOmpTeamsDistributeStatement::SgOmpTeamsDistributeStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
201086 : #endif
201087 : #if 0
201088 : // debugging information!
201089 : printf ("In SgOmpTeamsDistributeStatement::SgOmpTeamsDistributeStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
201090 : #endif
201091 :
201092 :
201093 :
201094 : #if 0
201095 : // DQ (7/30/2014): Call a virtual function.
201096 : std::string s = this->class_name();
201097 : #endif
201098 :
201099 : // Test the variant virtual function
201100 : // assert(OMP_TEAMS_DISTRIBUTE_STMT == variant());
201101 1 : assert(OMP_TEAMS_DISTRIBUTE_STMT == this->variant());
201102 1 : ROSE_ASSERT(OMP_TEAMS_DISTRIBUTE_STMT == (int)(this->variantT()));
201103 1 : post_construction_initialization();
201104 :
201105 : // Test the isSgOmpTeamsDistributeStatement() function since it has been problematic
201106 1 : assert(isSgOmpTeamsDistributeStatement(this) != NULL);
201107 1 : }
201108 :
201109 : // Generated constructor (all data members)
201110 :
201111 : /* #line 201112 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201112 :
201113 :
201114 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201115 :
201116 :
201117 : // ********************************************************
201118 : // member functions common across all array grammar objects
201119 : // ********************************************************
201120 :
201121 :
201122 :
201123 : /* #line 201124 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201124 :
201125 :
201126 :
201127 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201128 :
201129 : // ********************************************************
201130 : // member functions specific to each node in the grammar
201131 : // ********************************************************
201132 :
201133 :
201134 : /* #line 201135 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201135 :
201136 : // Start of memberFunctionString
201137 : /* #line 19391 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
201138 :
201139 : void
201140 1 : SgOmpTeamsDistributeSimdStatement::post_construction_initialization()
201141 1 : {}
201142 :
201143 :
201144 : // End of memberFunctionString
201145 : // Start of memberFunctionString
201146 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
201147 :
201148 : // *** COMMON CODE SECTION BEGINS HERE ***
201149 :
201150 : #if 0
201151 : int
201152 : SgOmpTeamsDistributeSimdStatement::getVariant() const
201153 : {
201154 : // This function is used in ROSE while "variant()" is used in SAGE
201155 : assert(this != NULL);
201156 : return variant();
201157 : }
201158 : #endif
201159 :
201160 : // This function is used in ROSE in treeTraversal code
201161 : // eventually replaces getVariant() and variant()
201162 : // though after variant() has been removed for a while we will
201163 : // want to change the name of variantT() back to variant()
201164 : // (since the "T" was ment to stand for temporary).
201165 : // When this happens the variantT() will be depricated.
201166 : VariantT
201167 83 : SgOmpTeamsDistributeSimdStatement::variantT() const
201168 : {
201169 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
201170 83 : ROSE_ASSERT(this != NULL);
201171 83 : return V_SgOmpTeamsDistributeSimdStatement;
201172 : }
201173 :
201174 : #if 0
201175 : int
201176 : SgOmpTeamsDistributeSimdStatement::variant() const
201177 : {
201178 : // This function is used in SAGE
201179 : ROSE_ASSERT(this != NULL);
201180 : return OMP_TEAMS_DISTRIBUTE_SIMD_STMT;
201181 : }
201182 : #endif
201183 :
201184 : ROSE_DLL_API const char*
201185 0 : SgOmpTeamsDistributeSimdStatement::sage_class_name() const
201186 : {
201187 0 : ROSE_ASSERT(this != NULL);
201188 0 : return "SgOmpTeamsDistributeSimdStatement";
201189 : }
201190 :
201191 : std::string
201192 1 : SgOmpTeamsDistributeSimdStatement::class_name() const
201193 : {
201194 1 : ROSE_ASSERT(this != NULL);
201195 1 : return "SgOmpTeamsDistributeSimdStatement";
201196 : }
201197 :
201198 : // DQ (11/26/2005): Support for visitor pattern mechanims
201199 : // (inferior to ROSE traversal mechanism, experimental).
201200 : void
201201 0 : SgOmpTeamsDistributeSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
201202 : {
201203 0 : ROSE_ASSERT(this != NULL);
201204 0 : visitor.visit(this);
201205 0 : }
201206 :
201207 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
201208 0 : void SgOmpTeamsDistributeSimdStatement::accept (ROSE_VisitorPattern & visitor) {
201209 0 : ROSE_ASSERT(this != NULL);
201210 0 : visitor.visit(this);
201211 0 : }
201212 :
201213 : SgOmpTeamsDistributeSimdStatement*
201214 0 : SgOmpTeamsDistributeSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
201215 : {
201216 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
201217 : // This function is currently only supported for the AST used the represent Binary executables.
201218 : if (0 /* isSgAsmNode(this) != NULL */)
201219 : {
201220 : // Support for regex specification.
201221 : std::string prefixCode = "REGEX:";
201222 : addNewAttribute(prefixCode + s,a);
201223 : }
201224 : #endif
201225 :
201226 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
201227 0 : return this;
201228 : }
201229 :
201230 : // *** COMMON CODE SECTION ENDS HERE ***
201231 :
201232 :
201233 : // End of memberFunctionString
201234 : // Start of memberFunctionString
201235 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
201236 :
201237 :
201238 : #if 0
201239 : //! Error checking support
201240 : /*! Verifies the following:
201241 : - working getVariant() member function
201242 : - calls base class's error() member function
201243 : Every class has one of these functions.
201244 : */
201245 : bool
201246 : SgOmpTeamsDistributeSimdStatement::error()
201247 : {
201248 : // Put error checking here
201249 :
201250 : ROSE_ASSERT (this != NULL);
201251 : if (getVariant() != OMP_TEAMS_DISTRIBUTE_SIMD_STMT)
201252 : {
201253 : printf ("Error in SgOmpTeamsDistributeSimdStatement::error(): SgOmpTeamsDistributeSimdStatement object has a %s variant \n",
201254 : Cxx_GrammarTerminalNames[getVariant()].name);
201255 : // printf ("Error in SgOmpTeamsDistributeSimdStatement::error() \n");
201256 : ROSE_ABORT();
201257 : }
201258 :
201259 : ROSE_ASSERT (getVariant() == OMP_TEAMS_DISTRIBUTE_SIMD_STMT);
201260 : return SgUpirFieldBodyStatement::error();
201261 : }
201262 : #endif
201263 :
201264 :
201265 :
201266 : // End of memberFunctionString
201267 :
201268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
201269 :
201270 1 : SgOmpTeamsDistributeSimdStatement* isSgOmpTeamsDistributeSimdStatement ( SgNode* inputDerivedClassPointer )
201271 : {
201272 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201273 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201274 : // So to fix this we return NULL directly when the input is NULL and avoid the
201275 : // dynamic_cast in this case. This is likely a performance improvement as well.
201276 : // return dynamic_cast<SgOmpTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
201277 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeSimdStatement uses table-driven castability instead of c++ default dynamic_cast
201278 : // this improves the running time performance by 10-20%.
201279 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
201280 1 : return IS_SgOmpTeamsDistributeSimdStatement_FAST_MACRO(inputDerivedClassPointer);
201281 : }
201282 :
201283 : // DQ (11/8/2003): Added version of functions taking const pointer
201284 0 : const SgOmpTeamsDistributeSimdStatement* isSgOmpTeamsDistributeSimdStatement ( const SgNode* inputDerivedClassPointer )
201285 : {
201286 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201287 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201288 : // So to fix this we return NULL directly when the input is NULL and avoid the
201289 : // dynamic_cast in this case. This is likely a performance improvement as well.
201290 : // return dynamic_cast<const SgOmpTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
201291 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeSimdStatement uses table-driven castability instead of c++ default dynamic_cast
201292 : // this improves the running time performance by 10-20%.
201293 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTeamsDistributeSimdStatement*>(inputDerivedClassPointer);
201294 0 : return IS_SgOmpTeamsDistributeSimdStatement_FAST_MACRO(inputDerivedClassPointer);
201295 : }
201296 :
201297 :
201298 :
201299 : /* #line 201300 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201300 :
201301 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201302 :
201303 : /**
201304 : \brief Generated destructor
201305 :
201306 : This destructor is automatically generated (by ROSETTA). This destructor
201307 : only frees memory of data members associated with the parts of the current IR node which
201308 : are NOT traversed. Those data members that are part of a traversal can be freed using
201309 : a traversal (calling this destructor on all children in a post-order traversal). Such
201310 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
201311 :
201312 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
201313 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
201314 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
201315 :
201316 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
201317 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
201318 : pointers are not yet implemented to call delete on eash pointer in the container.
201319 : (This could be done by derivation from the STL containers to define containers that
201320 : automatically deleted their members.)
201321 :
201322 : */
201323 0 : SgOmpTeamsDistributeSimdStatement::~SgOmpTeamsDistributeSimdStatement () {
201324 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
201325 :
201326 :
201327 :
201328 : }
201329 :
201330 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201331 0 : }
201332 :
201333 :
201334 : /* #line 201335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201335 :
201336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
201337 :
201338 : // Generated constructor
201339 1 : SgOmpTeamsDistributeSimdStatement::SgOmpTeamsDistributeSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
201340 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
201341 : {
201342 : #ifdef DEBUG
201343 : // printf ("In SgOmpTeamsDistributeSimdStatement::SgOmpTeamsDistributeSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
201344 : #endif
201345 : #if 0
201346 : // debugging information!
201347 : printf ("In SgOmpTeamsDistributeSimdStatement::SgOmpTeamsDistributeSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
201348 : #endif
201349 :
201350 :
201351 :
201352 : #if 0
201353 : // DQ (7/30/2014): Call a virtual function.
201354 : std::string s = this->class_name();
201355 : #endif
201356 :
201357 : // Test the variant virtual function
201358 : // assert(OMP_TEAMS_DISTRIBUTE_SIMD_STMT == variant());
201359 1 : assert(OMP_TEAMS_DISTRIBUTE_SIMD_STMT == this->variant());
201360 1 : ROSE_ASSERT(OMP_TEAMS_DISTRIBUTE_SIMD_STMT == (int)(this->variantT()));
201361 1 : post_construction_initialization();
201362 :
201363 : // Test the isSgOmpTeamsDistributeSimdStatement() function since it has been problematic
201364 1 : assert(isSgOmpTeamsDistributeSimdStatement(this) != NULL);
201365 1 : }
201366 :
201367 : // Generated constructor (all data members)
201368 :
201369 : /* #line 201370 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201370 :
201371 :
201372 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201373 :
201374 :
201375 : // ********************************************************
201376 : // member functions common across all array grammar objects
201377 : // ********************************************************
201378 :
201379 :
201380 :
201381 : /* #line 201382 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201382 :
201383 :
201384 :
201385 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201386 :
201387 : // ********************************************************
201388 : // member functions specific to each node in the grammar
201389 : // ********************************************************
201390 :
201391 :
201392 : /* #line 201393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201393 :
201394 : // Start of memberFunctionString
201395 : /* #line 19397 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
201396 :
201397 : void
201398 1 : SgOmpTeamsDistributeParallelForStatement::post_construction_initialization()
201399 1 : {}
201400 :
201401 :
201402 : // End of memberFunctionString
201403 : // Start of memberFunctionString
201404 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
201405 :
201406 : // *** COMMON CODE SECTION BEGINS HERE ***
201407 :
201408 : #if 0
201409 : int
201410 : SgOmpTeamsDistributeParallelForStatement::getVariant() const
201411 : {
201412 : // This function is used in ROSE while "variant()" is used in SAGE
201413 : assert(this != NULL);
201414 : return variant();
201415 : }
201416 : #endif
201417 :
201418 : // This function is used in ROSE in treeTraversal code
201419 : // eventually replaces getVariant() and variant()
201420 : // though after variant() has been removed for a while we will
201421 : // want to change the name of variantT() back to variant()
201422 : // (since the "T" was ment to stand for temporary).
201423 : // When this happens the variantT() will be depricated.
201424 : VariantT
201425 83 : SgOmpTeamsDistributeParallelForStatement::variantT() const
201426 : {
201427 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
201428 83 : ROSE_ASSERT(this != NULL);
201429 83 : return V_SgOmpTeamsDistributeParallelForStatement;
201430 : }
201431 :
201432 : #if 0
201433 : int
201434 : SgOmpTeamsDistributeParallelForStatement::variant() const
201435 : {
201436 : // This function is used in SAGE
201437 : ROSE_ASSERT(this != NULL);
201438 : return OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT;
201439 : }
201440 : #endif
201441 :
201442 : ROSE_DLL_API const char*
201443 0 : SgOmpTeamsDistributeParallelForStatement::sage_class_name() const
201444 : {
201445 0 : ROSE_ASSERT(this != NULL);
201446 0 : return "SgOmpTeamsDistributeParallelForStatement";
201447 : }
201448 :
201449 : std::string
201450 1 : SgOmpTeamsDistributeParallelForStatement::class_name() const
201451 : {
201452 1 : ROSE_ASSERT(this != NULL);
201453 1 : return "SgOmpTeamsDistributeParallelForStatement";
201454 : }
201455 :
201456 : // DQ (11/26/2005): Support for visitor pattern mechanims
201457 : // (inferior to ROSE traversal mechanism, experimental).
201458 : void
201459 0 : SgOmpTeamsDistributeParallelForStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
201460 : {
201461 0 : ROSE_ASSERT(this != NULL);
201462 0 : visitor.visit(this);
201463 0 : }
201464 :
201465 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
201466 0 : void SgOmpTeamsDistributeParallelForStatement::accept (ROSE_VisitorPattern & visitor) {
201467 0 : ROSE_ASSERT(this != NULL);
201468 0 : visitor.visit(this);
201469 0 : }
201470 :
201471 : SgOmpTeamsDistributeParallelForStatement*
201472 0 : SgOmpTeamsDistributeParallelForStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
201473 : {
201474 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
201475 : // This function is currently only supported for the AST used the represent Binary executables.
201476 : if (0 /* isSgAsmNode(this) != NULL */)
201477 : {
201478 : // Support for regex specification.
201479 : std::string prefixCode = "REGEX:";
201480 : addNewAttribute(prefixCode + s,a);
201481 : }
201482 : #endif
201483 :
201484 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
201485 0 : return this;
201486 : }
201487 :
201488 : // *** COMMON CODE SECTION ENDS HERE ***
201489 :
201490 :
201491 : // End of memberFunctionString
201492 : // Start of memberFunctionString
201493 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
201494 :
201495 :
201496 : #if 0
201497 : //! Error checking support
201498 : /*! Verifies the following:
201499 : - working getVariant() member function
201500 : - calls base class's error() member function
201501 : Every class has one of these functions.
201502 : */
201503 : bool
201504 : SgOmpTeamsDistributeParallelForStatement::error()
201505 : {
201506 : // Put error checking here
201507 :
201508 : ROSE_ASSERT (this != NULL);
201509 : if (getVariant() != OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT)
201510 : {
201511 : printf ("Error in SgOmpTeamsDistributeParallelForStatement::error(): SgOmpTeamsDistributeParallelForStatement object has a %s variant \n",
201512 : Cxx_GrammarTerminalNames[getVariant()].name);
201513 : // printf ("Error in SgOmpTeamsDistributeParallelForStatement::error() \n");
201514 : ROSE_ABORT();
201515 : }
201516 :
201517 : ROSE_ASSERT (getVariant() == OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT);
201518 : return SgUpirFieldBodyStatement::error();
201519 : }
201520 : #endif
201521 :
201522 :
201523 :
201524 : // End of memberFunctionString
201525 :
201526 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
201527 :
201528 1 : SgOmpTeamsDistributeParallelForStatement* isSgOmpTeamsDistributeParallelForStatement ( SgNode* inputDerivedClassPointer )
201529 : {
201530 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201531 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201532 : // So to fix this we return NULL directly when the input is NULL and avoid the
201533 : // dynamic_cast in this case. This is likely a performance improvement as well.
201534 : // return dynamic_cast<SgOmpTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
201535 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
201536 : // this improves the running time performance by 10-20%.
201537 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
201538 1 : return IS_SgOmpTeamsDistributeParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
201539 : }
201540 :
201541 : // DQ (11/8/2003): Added version of functions taking const pointer
201542 0 : const SgOmpTeamsDistributeParallelForStatement* isSgOmpTeamsDistributeParallelForStatement ( const SgNode* inputDerivedClassPointer )
201543 : {
201544 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201545 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201546 : // So to fix this we return NULL directly when the input is NULL and avoid the
201547 : // dynamic_cast in this case. This is likely a performance improvement as well.
201548 : // return dynamic_cast<const SgOmpTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
201549 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeParallelForStatement uses table-driven castability instead of c++ default dynamic_cast
201550 : // this improves the running time performance by 10-20%.
201551 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTeamsDistributeParallelForStatement*>(inputDerivedClassPointer);
201552 0 : return IS_SgOmpTeamsDistributeParallelForStatement_FAST_MACRO(inputDerivedClassPointer);
201553 : }
201554 :
201555 :
201556 :
201557 : /* #line 201558 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201558 :
201559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201560 :
201561 : /**
201562 : \brief Generated destructor
201563 :
201564 : This destructor is automatically generated (by ROSETTA). This destructor
201565 : only frees memory of data members associated with the parts of the current IR node which
201566 : are NOT traversed. Those data members that are part of a traversal can be freed using
201567 : a traversal (calling this destructor on all children in a post-order traversal). Such
201568 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
201569 :
201570 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
201571 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
201572 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
201573 :
201574 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
201575 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
201576 : pointers are not yet implemented to call delete on eash pointer in the container.
201577 : (This could be done by derivation from the STL containers to define containers that
201578 : automatically deleted their members.)
201579 :
201580 : */
201581 0 : SgOmpTeamsDistributeParallelForStatement::~SgOmpTeamsDistributeParallelForStatement () {
201582 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
201583 :
201584 :
201585 :
201586 : }
201587 :
201588 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201589 0 : }
201590 :
201591 :
201592 : /* #line 201593 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201593 :
201594 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
201595 :
201596 : // Generated constructor
201597 1 : SgOmpTeamsDistributeParallelForStatement::SgOmpTeamsDistributeParallelForStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
201598 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
201599 : {
201600 : #ifdef DEBUG
201601 : // printf ("In SgOmpTeamsDistributeParallelForStatement::SgOmpTeamsDistributeParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
201602 : #endif
201603 : #if 0
201604 : // debugging information!
201605 : printf ("In SgOmpTeamsDistributeParallelForStatement::SgOmpTeamsDistributeParallelForStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
201606 : #endif
201607 :
201608 :
201609 :
201610 : #if 0
201611 : // DQ (7/30/2014): Call a virtual function.
201612 : std::string s = this->class_name();
201613 : #endif
201614 :
201615 : // Test the variant virtual function
201616 : // assert(OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT == variant());
201617 1 : assert(OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT == this->variant());
201618 1 : ROSE_ASSERT(OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_STMT == (int)(this->variantT()));
201619 1 : post_construction_initialization();
201620 :
201621 : // Test the isSgOmpTeamsDistributeParallelForStatement() function since it has been problematic
201622 1 : assert(isSgOmpTeamsDistributeParallelForStatement(this) != NULL);
201623 1 : }
201624 :
201625 : // Generated constructor (all data members)
201626 :
201627 : /* #line 201628 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201628 :
201629 :
201630 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201631 :
201632 :
201633 : // ********************************************************
201634 : // member functions common across all array grammar objects
201635 : // ********************************************************
201636 :
201637 :
201638 :
201639 : /* #line 201640 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201640 :
201641 :
201642 :
201643 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201644 :
201645 : // ********************************************************
201646 : // member functions specific to each node in the grammar
201647 : // ********************************************************
201648 :
201649 :
201650 : /* #line 201651 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201651 :
201652 : // Start of memberFunctionString
201653 : /* #line 19403 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
201654 :
201655 : void
201656 1 : SgOmpTeamsDistributeParallelForSimdStatement::post_construction_initialization()
201657 1 : {}
201658 :
201659 :
201660 : // End of memberFunctionString
201661 : // Start of memberFunctionString
201662 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
201663 :
201664 : // *** COMMON CODE SECTION BEGINS HERE ***
201665 :
201666 : #if 0
201667 : int
201668 : SgOmpTeamsDistributeParallelForSimdStatement::getVariant() const
201669 : {
201670 : // This function is used in ROSE while "variant()" is used in SAGE
201671 : assert(this != NULL);
201672 : return variant();
201673 : }
201674 : #endif
201675 :
201676 : // This function is used in ROSE in treeTraversal code
201677 : // eventually replaces getVariant() and variant()
201678 : // though after variant() has been removed for a while we will
201679 : // want to change the name of variantT() back to variant()
201680 : // (since the "T" was ment to stand for temporary).
201681 : // When this happens the variantT() will be depricated.
201682 : VariantT
201683 83 : SgOmpTeamsDistributeParallelForSimdStatement::variantT() const
201684 : {
201685 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
201686 83 : ROSE_ASSERT(this != NULL);
201687 83 : return V_SgOmpTeamsDistributeParallelForSimdStatement;
201688 : }
201689 :
201690 : #if 0
201691 : int
201692 : SgOmpTeamsDistributeParallelForSimdStatement::variant() const
201693 : {
201694 : // This function is used in SAGE
201695 : ROSE_ASSERT(this != NULL);
201696 : return OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT;
201697 : }
201698 : #endif
201699 :
201700 : ROSE_DLL_API const char*
201701 0 : SgOmpTeamsDistributeParallelForSimdStatement::sage_class_name() const
201702 : {
201703 0 : ROSE_ASSERT(this != NULL);
201704 0 : return "SgOmpTeamsDistributeParallelForSimdStatement";
201705 : }
201706 :
201707 : std::string
201708 1 : SgOmpTeamsDistributeParallelForSimdStatement::class_name() const
201709 : {
201710 1 : ROSE_ASSERT(this != NULL);
201711 1 : return "SgOmpTeamsDistributeParallelForSimdStatement";
201712 : }
201713 :
201714 : // DQ (11/26/2005): Support for visitor pattern mechanims
201715 : // (inferior to ROSE traversal mechanism, experimental).
201716 : void
201717 0 : SgOmpTeamsDistributeParallelForSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
201718 : {
201719 0 : ROSE_ASSERT(this != NULL);
201720 0 : visitor.visit(this);
201721 0 : }
201722 :
201723 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
201724 0 : void SgOmpTeamsDistributeParallelForSimdStatement::accept (ROSE_VisitorPattern & visitor) {
201725 0 : ROSE_ASSERT(this != NULL);
201726 0 : visitor.visit(this);
201727 0 : }
201728 :
201729 : SgOmpTeamsDistributeParallelForSimdStatement*
201730 0 : SgOmpTeamsDistributeParallelForSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
201731 : {
201732 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
201733 : // This function is currently only supported for the AST used the represent Binary executables.
201734 : if (0 /* isSgAsmNode(this) != NULL */)
201735 : {
201736 : // Support for regex specification.
201737 : std::string prefixCode = "REGEX:";
201738 : addNewAttribute(prefixCode + s,a);
201739 : }
201740 : #endif
201741 :
201742 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
201743 0 : return this;
201744 : }
201745 :
201746 : // *** COMMON CODE SECTION ENDS HERE ***
201747 :
201748 :
201749 : // End of memberFunctionString
201750 : // Start of memberFunctionString
201751 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
201752 :
201753 :
201754 : #if 0
201755 : //! Error checking support
201756 : /*! Verifies the following:
201757 : - working getVariant() member function
201758 : - calls base class's error() member function
201759 : Every class has one of these functions.
201760 : */
201761 : bool
201762 : SgOmpTeamsDistributeParallelForSimdStatement::error()
201763 : {
201764 : // Put error checking here
201765 :
201766 : ROSE_ASSERT (this != NULL);
201767 : if (getVariant() != OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT)
201768 : {
201769 : printf ("Error in SgOmpTeamsDistributeParallelForSimdStatement::error(): SgOmpTeamsDistributeParallelForSimdStatement object has a %s variant \n",
201770 : Cxx_GrammarTerminalNames[getVariant()].name);
201771 : // printf ("Error in SgOmpTeamsDistributeParallelForSimdStatement::error() \n");
201772 : ROSE_ABORT();
201773 : }
201774 :
201775 : ROSE_ASSERT (getVariant() == OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT);
201776 : return SgUpirFieldBodyStatement::error();
201777 : }
201778 : #endif
201779 :
201780 :
201781 :
201782 : // End of memberFunctionString
201783 :
201784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
201785 :
201786 1 : SgOmpTeamsDistributeParallelForSimdStatement* isSgOmpTeamsDistributeParallelForSimdStatement ( SgNode* inputDerivedClassPointer )
201787 : {
201788 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201789 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201790 : // So to fix this we return NULL directly when the input is NULL and avoid the
201791 : // dynamic_cast in this case. This is likely a performance improvement as well.
201792 : // return dynamic_cast<SgOmpTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
201793 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
201794 : // this improves the running time performance by 10-20%.
201795 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
201796 1 : return IS_SgOmpTeamsDistributeParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
201797 : }
201798 :
201799 : // DQ (11/8/2003): Added version of functions taking const pointer
201800 0 : const SgOmpTeamsDistributeParallelForSimdStatement* isSgOmpTeamsDistributeParallelForSimdStatement ( const SgNode* inputDerivedClassPointer )
201801 : {
201802 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
201803 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
201804 : // So to fix this we return NULL directly when the input is NULL and avoid the
201805 : // dynamic_cast in this case. This is likely a performance improvement as well.
201806 : // return dynamic_cast<const SgOmpTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
201807 : // Milind Chabbi (8/28/2013): isSgOmpTeamsDistributeParallelForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
201808 : // this improves the running time performance by 10-20%.
201809 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTeamsDistributeParallelForSimdStatement*>(inputDerivedClassPointer);
201810 0 : return IS_SgOmpTeamsDistributeParallelForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
201811 : }
201812 :
201813 :
201814 :
201815 : /* #line 201816 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201816 :
201817 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201818 :
201819 : /**
201820 : \brief Generated destructor
201821 :
201822 : This destructor is automatically generated (by ROSETTA). This destructor
201823 : only frees memory of data members associated with the parts of the current IR node which
201824 : are NOT traversed. Those data members that are part of a traversal can be freed using
201825 : a traversal (calling this destructor on all children in a post-order traversal). Such
201826 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
201827 :
201828 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
201829 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
201830 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
201831 :
201832 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
201833 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
201834 : pointers are not yet implemented to call delete on eash pointer in the container.
201835 : (This could be done by derivation from the STL containers to define containers that
201836 : automatically deleted their members.)
201837 :
201838 : */
201839 0 : SgOmpTeamsDistributeParallelForSimdStatement::~SgOmpTeamsDistributeParallelForSimdStatement () {
201840 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
201841 :
201842 :
201843 :
201844 : }
201845 :
201846 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
201847 0 : }
201848 :
201849 :
201850 : /* #line 201851 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201851 :
201852 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
201853 :
201854 : // Generated constructor
201855 1 : SgOmpTeamsDistributeParallelForSimdStatement::SgOmpTeamsDistributeParallelForSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
201856 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
201857 : {
201858 : #ifdef DEBUG
201859 : // printf ("In SgOmpTeamsDistributeParallelForSimdStatement::SgOmpTeamsDistributeParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
201860 : #endif
201861 : #if 0
201862 : // debugging information!
201863 : printf ("In SgOmpTeamsDistributeParallelForSimdStatement::SgOmpTeamsDistributeParallelForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
201864 : #endif
201865 :
201866 :
201867 :
201868 : #if 0
201869 : // DQ (7/30/2014): Call a virtual function.
201870 : std::string s = this->class_name();
201871 : #endif
201872 :
201873 : // Test the variant virtual function
201874 : // assert(OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == variant());
201875 1 : assert(OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == this->variant());
201876 1 : ROSE_ASSERT(OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_STMT == (int)(this->variantT()));
201877 1 : post_construction_initialization();
201878 :
201879 : // Test the isSgOmpTeamsDistributeParallelForSimdStatement() function since it has been problematic
201880 1 : assert(isSgOmpTeamsDistributeParallelForSimdStatement(this) != NULL);
201881 1 : }
201882 :
201883 : // Generated constructor (all data members)
201884 :
201885 : /* #line 201886 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201886 :
201887 :
201888 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201889 :
201890 :
201891 : // ********************************************************
201892 : // member functions common across all array grammar objects
201893 : // ********************************************************
201894 :
201895 :
201896 :
201897 : /* #line 201898 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201898 :
201899 :
201900 :
201901 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
201902 :
201903 : // ********************************************************
201904 : // member functions specific to each node in the grammar
201905 : // ********************************************************
201906 :
201907 :
201908 : /* #line 201909 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
201909 :
201910 : // Start of memberFunctionString
201911 : /* #line 19409 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
201912 :
201913 : void
201914 1 : SgOmpTeamsLoopStatement::post_construction_initialization()
201915 1 : {}
201916 :
201917 :
201918 : // End of memberFunctionString
201919 : // Start of memberFunctionString
201920 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
201921 :
201922 : // *** COMMON CODE SECTION BEGINS HERE ***
201923 :
201924 : #if 0
201925 : int
201926 : SgOmpTeamsLoopStatement::getVariant() const
201927 : {
201928 : // This function is used in ROSE while "variant()" is used in SAGE
201929 : assert(this != NULL);
201930 : return variant();
201931 : }
201932 : #endif
201933 :
201934 : // This function is used in ROSE in treeTraversal code
201935 : // eventually replaces getVariant() and variant()
201936 : // though after variant() has been removed for a while we will
201937 : // want to change the name of variantT() back to variant()
201938 : // (since the "T" was ment to stand for temporary).
201939 : // When this happens the variantT() will be depricated.
201940 : VariantT
201941 83 : SgOmpTeamsLoopStatement::variantT() const
201942 : {
201943 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
201944 83 : ROSE_ASSERT(this != NULL);
201945 83 : return V_SgOmpTeamsLoopStatement;
201946 : }
201947 :
201948 : #if 0
201949 : int
201950 : SgOmpTeamsLoopStatement::variant() const
201951 : {
201952 : // This function is used in SAGE
201953 : ROSE_ASSERT(this != NULL);
201954 : return OMP_TEAMS_LOOP_STMT;
201955 : }
201956 : #endif
201957 :
201958 : ROSE_DLL_API const char*
201959 0 : SgOmpTeamsLoopStatement::sage_class_name() const
201960 : {
201961 0 : ROSE_ASSERT(this != NULL);
201962 0 : return "SgOmpTeamsLoopStatement";
201963 : }
201964 :
201965 : std::string
201966 1 : SgOmpTeamsLoopStatement::class_name() const
201967 : {
201968 1 : ROSE_ASSERT(this != NULL);
201969 1 : return "SgOmpTeamsLoopStatement";
201970 : }
201971 :
201972 : // DQ (11/26/2005): Support for visitor pattern mechanims
201973 : // (inferior to ROSE traversal mechanism, experimental).
201974 : void
201975 0 : SgOmpTeamsLoopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
201976 : {
201977 0 : ROSE_ASSERT(this != NULL);
201978 0 : visitor.visit(this);
201979 0 : }
201980 :
201981 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
201982 0 : void SgOmpTeamsLoopStatement::accept (ROSE_VisitorPattern & visitor) {
201983 0 : ROSE_ASSERT(this != NULL);
201984 0 : visitor.visit(this);
201985 0 : }
201986 :
201987 : SgOmpTeamsLoopStatement*
201988 0 : SgOmpTeamsLoopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
201989 : {
201990 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
201991 : // This function is currently only supported for the AST used the represent Binary executables.
201992 : if (0 /* isSgAsmNode(this) != NULL */)
201993 : {
201994 : // Support for regex specification.
201995 : std::string prefixCode = "REGEX:";
201996 : addNewAttribute(prefixCode + s,a);
201997 : }
201998 : #endif
201999 :
202000 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
202001 0 : return this;
202002 : }
202003 :
202004 : // *** COMMON CODE SECTION ENDS HERE ***
202005 :
202006 :
202007 : // End of memberFunctionString
202008 : // Start of memberFunctionString
202009 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
202010 :
202011 :
202012 : #if 0
202013 : //! Error checking support
202014 : /*! Verifies the following:
202015 : - working getVariant() member function
202016 : - calls base class's error() member function
202017 : Every class has one of these functions.
202018 : */
202019 : bool
202020 : SgOmpTeamsLoopStatement::error()
202021 : {
202022 : // Put error checking here
202023 :
202024 : ROSE_ASSERT (this != NULL);
202025 : if (getVariant() != OMP_TEAMS_LOOP_STMT)
202026 : {
202027 : printf ("Error in SgOmpTeamsLoopStatement::error(): SgOmpTeamsLoopStatement object has a %s variant \n",
202028 : Cxx_GrammarTerminalNames[getVariant()].name);
202029 : // printf ("Error in SgOmpTeamsLoopStatement::error() \n");
202030 : ROSE_ABORT();
202031 : }
202032 :
202033 : ROSE_ASSERT (getVariant() == OMP_TEAMS_LOOP_STMT);
202034 : return SgUpirFieldBodyStatement::error();
202035 : }
202036 : #endif
202037 :
202038 :
202039 :
202040 : // End of memberFunctionString
202041 :
202042 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
202043 :
202044 1 : SgOmpTeamsLoopStatement* isSgOmpTeamsLoopStatement ( SgNode* inputDerivedClassPointer )
202045 : {
202046 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202047 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202048 : // So to fix this we return NULL directly when the input is NULL and avoid the
202049 : // dynamic_cast in this case. This is likely a performance improvement as well.
202050 : // return dynamic_cast<SgOmpTeamsLoopStatement*>(inputDerivedClassPointer);
202051 : // Milind Chabbi (8/28/2013): isSgOmpTeamsLoopStatement uses table-driven castability instead of c++ default dynamic_cast
202052 : // this improves the running time performance by 10-20%.
202053 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTeamsLoopStatement*>(inputDerivedClassPointer);
202054 1 : return IS_SgOmpTeamsLoopStatement_FAST_MACRO(inputDerivedClassPointer);
202055 : }
202056 :
202057 : // DQ (11/8/2003): Added version of functions taking const pointer
202058 0 : const SgOmpTeamsLoopStatement* isSgOmpTeamsLoopStatement ( const SgNode* inputDerivedClassPointer )
202059 : {
202060 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202061 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202062 : // So to fix this we return NULL directly when the input is NULL and avoid the
202063 : // dynamic_cast in this case. This is likely a performance improvement as well.
202064 : // return dynamic_cast<const SgOmpTeamsLoopStatement*>(inputDerivedClassPointer);
202065 : // Milind Chabbi (8/28/2013): isSgOmpTeamsLoopStatement uses table-driven castability instead of c++ default dynamic_cast
202066 : // this improves the running time performance by 10-20%.
202067 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTeamsLoopStatement*>(inputDerivedClassPointer);
202068 0 : return IS_SgOmpTeamsLoopStatement_FAST_MACRO(inputDerivedClassPointer);
202069 : }
202070 :
202071 :
202072 :
202073 : /* #line 202074 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202074 :
202075 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202076 :
202077 : /**
202078 : \brief Generated destructor
202079 :
202080 : This destructor is automatically generated (by ROSETTA). This destructor
202081 : only frees memory of data members associated with the parts of the current IR node which
202082 : are NOT traversed. Those data members that are part of a traversal can be freed using
202083 : a traversal (calling this destructor on all children in a post-order traversal). Such
202084 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
202085 :
202086 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
202087 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
202088 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
202089 :
202090 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
202091 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
202092 : pointers are not yet implemented to call delete on eash pointer in the container.
202093 : (This could be done by derivation from the STL containers to define containers that
202094 : automatically deleted their members.)
202095 :
202096 : */
202097 0 : SgOmpTeamsLoopStatement::~SgOmpTeamsLoopStatement () {
202098 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
202099 :
202100 :
202101 :
202102 : }
202103 :
202104 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202105 0 : }
202106 :
202107 :
202108 : /* #line 202109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202109 :
202110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
202111 :
202112 : // Generated constructor
202113 1 : SgOmpTeamsLoopStatement::SgOmpTeamsLoopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
202114 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
202115 : {
202116 : #ifdef DEBUG
202117 : // printf ("In SgOmpTeamsLoopStatement::SgOmpTeamsLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
202118 : #endif
202119 : #if 0
202120 : // debugging information!
202121 : printf ("In SgOmpTeamsLoopStatement::SgOmpTeamsLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
202122 : #endif
202123 :
202124 :
202125 :
202126 : #if 0
202127 : // DQ (7/30/2014): Call a virtual function.
202128 : std::string s = this->class_name();
202129 : #endif
202130 :
202131 : // Test the variant virtual function
202132 : // assert(OMP_TEAMS_LOOP_STMT == variant());
202133 1 : assert(OMP_TEAMS_LOOP_STMT == this->variant());
202134 1 : ROSE_ASSERT(OMP_TEAMS_LOOP_STMT == (int)(this->variantT()));
202135 1 : post_construction_initialization();
202136 :
202137 : // Test the isSgOmpTeamsLoopStatement() function since it has been problematic
202138 1 : assert(isSgOmpTeamsLoopStatement(this) != NULL);
202139 1 : }
202140 :
202141 : // Generated constructor (all data members)
202142 :
202143 : /* #line 202144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202144 :
202145 :
202146 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202147 :
202148 :
202149 : // ********************************************************
202150 : // member functions common across all array grammar objects
202151 : // ********************************************************
202152 :
202153 :
202154 :
202155 : /* #line 202156 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202156 :
202157 :
202158 :
202159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202160 :
202161 : // ********************************************************
202162 : // member functions specific to each node in the grammar
202163 : // ********************************************************
202164 :
202165 :
202166 : /* #line 202167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202167 :
202168 : // Start of memberFunctionString
202169 : /* #line 19467 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
202170 :
202171 : void
202172 1 : SgOmpForSimdStatement::post_construction_initialization()
202173 1 : {}
202174 :
202175 :
202176 : // End of memberFunctionString
202177 : // Start of memberFunctionString
202178 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
202179 :
202180 : // *** COMMON CODE SECTION BEGINS HERE ***
202181 :
202182 : #if 0
202183 : int
202184 : SgOmpForSimdStatement::getVariant() const
202185 : {
202186 : // This function is used in ROSE while "variant()" is used in SAGE
202187 : assert(this != NULL);
202188 : return variant();
202189 : }
202190 : #endif
202191 :
202192 : // This function is used in ROSE in treeTraversal code
202193 : // eventually replaces getVariant() and variant()
202194 : // though after variant() has been removed for a while we will
202195 : // want to change the name of variantT() back to variant()
202196 : // (since the "T" was ment to stand for temporary).
202197 : // When this happens the variantT() will be depricated.
202198 : VariantT
202199 86 : SgOmpForSimdStatement::variantT() const
202200 : {
202201 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
202202 86 : ROSE_ASSERT(this != NULL);
202203 86 : return V_SgOmpForSimdStatement;
202204 : }
202205 :
202206 : #if 0
202207 : int
202208 : SgOmpForSimdStatement::variant() const
202209 : {
202210 : // This function is used in SAGE
202211 : ROSE_ASSERT(this != NULL);
202212 : return OMP_FOR_SIMD_STMT;
202213 : }
202214 : #endif
202215 :
202216 : ROSE_DLL_API const char*
202217 0 : SgOmpForSimdStatement::sage_class_name() const
202218 : {
202219 0 : ROSE_ASSERT(this != NULL);
202220 0 : return "SgOmpForSimdStatement";
202221 : }
202222 :
202223 : std::string
202224 1 : SgOmpForSimdStatement::class_name() const
202225 : {
202226 1 : ROSE_ASSERT(this != NULL);
202227 1 : return "SgOmpForSimdStatement";
202228 : }
202229 :
202230 : // DQ (11/26/2005): Support for visitor pattern mechanims
202231 : // (inferior to ROSE traversal mechanism, experimental).
202232 : void
202233 0 : SgOmpForSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
202234 : {
202235 0 : ROSE_ASSERT(this != NULL);
202236 0 : visitor.visit(this);
202237 0 : }
202238 :
202239 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
202240 0 : void SgOmpForSimdStatement::accept (ROSE_VisitorPattern & visitor) {
202241 0 : ROSE_ASSERT(this != NULL);
202242 0 : visitor.visit(this);
202243 0 : }
202244 :
202245 : SgOmpForSimdStatement*
202246 0 : SgOmpForSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
202247 : {
202248 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
202249 : // This function is currently only supported for the AST used the represent Binary executables.
202250 : if (0 /* isSgAsmNode(this) != NULL */)
202251 : {
202252 : // Support for regex specification.
202253 : std::string prefixCode = "REGEX:";
202254 : addNewAttribute(prefixCode + s,a);
202255 : }
202256 : #endif
202257 :
202258 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
202259 0 : return this;
202260 : }
202261 :
202262 : // *** COMMON CODE SECTION ENDS HERE ***
202263 :
202264 :
202265 : // End of memberFunctionString
202266 : // Start of memberFunctionString
202267 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
202268 :
202269 :
202270 : #if 0
202271 : //! Error checking support
202272 : /*! Verifies the following:
202273 : - working getVariant() member function
202274 : - calls base class's error() member function
202275 : Every class has one of these functions.
202276 : */
202277 : bool
202278 : SgOmpForSimdStatement::error()
202279 : {
202280 : // Put error checking here
202281 :
202282 : ROSE_ASSERT (this != NULL);
202283 : if (getVariant() != OMP_FOR_SIMD_STMT)
202284 : {
202285 : printf ("Error in SgOmpForSimdStatement::error(): SgOmpForSimdStatement object has a %s variant \n",
202286 : Cxx_GrammarTerminalNames[getVariant()].name);
202287 : // printf ("Error in SgOmpForSimdStatement::error() \n");
202288 : ROSE_ABORT();
202289 : }
202290 :
202291 : ROSE_ASSERT (getVariant() == OMP_FOR_SIMD_STMT);
202292 : return SgUpirFieldBodyStatement::error();
202293 : }
202294 : #endif
202295 :
202296 :
202297 :
202298 : // End of memberFunctionString
202299 :
202300 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
202301 :
202302 2 : SgOmpForSimdStatement* isSgOmpForSimdStatement ( SgNode* inputDerivedClassPointer )
202303 : {
202304 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202305 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202306 : // So to fix this we return NULL directly when the input is NULL and avoid the
202307 : // dynamic_cast in this case. This is likely a performance improvement as well.
202308 : // return dynamic_cast<SgOmpForSimdStatement*>(inputDerivedClassPointer);
202309 : // Milind Chabbi (8/28/2013): isSgOmpForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
202310 : // this improves the running time performance by 10-20%.
202311 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpForSimdStatement*>(inputDerivedClassPointer);
202312 2 : return IS_SgOmpForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
202313 : }
202314 :
202315 : // DQ (11/8/2003): Added version of functions taking const pointer
202316 0 : const SgOmpForSimdStatement* isSgOmpForSimdStatement ( const SgNode* inputDerivedClassPointer )
202317 : {
202318 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202319 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202320 : // So to fix this we return NULL directly when the input is NULL and avoid the
202321 : // dynamic_cast in this case. This is likely a performance improvement as well.
202322 : // return dynamic_cast<const SgOmpForSimdStatement*>(inputDerivedClassPointer);
202323 : // Milind Chabbi (8/28/2013): isSgOmpForSimdStatement uses table-driven castability instead of c++ default dynamic_cast
202324 : // this improves the running time performance by 10-20%.
202325 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpForSimdStatement*>(inputDerivedClassPointer);
202326 0 : return IS_SgOmpForSimdStatement_FAST_MACRO(inputDerivedClassPointer);
202327 : }
202328 :
202329 :
202330 :
202331 : /* #line 202332 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202332 :
202333 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202334 :
202335 : /**
202336 : \brief Generated destructor
202337 :
202338 : This destructor is automatically generated (by ROSETTA). This destructor
202339 : only frees memory of data members associated with the parts of the current IR node which
202340 : are NOT traversed. Those data members that are part of a traversal can be freed using
202341 : a traversal (calling this destructor on all children in a post-order traversal). Such
202342 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
202343 :
202344 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
202345 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
202346 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
202347 :
202348 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
202349 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
202350 : pointers are not yet implemented to call delete on eash pointer in the container.
202351 : (This could be done by derivation from the STL containers to define containers that
202352 : automatically deleted their members.)
202353 :
202354 : */
202355 0 : SgOmpForSimdStatement::~SgOmpForSimdStatement () {
202356 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
202357 :
202358 :
202359 :
202360 : }
202361 :
202362 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202363 0 : }
202364 :
202365 :
202366 : /* #line 202367 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202367 :
202368 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
202369 :
202370 : // Generated constructor
202371 1 : SgOmpForSimdStatement::SgOmpForSimdStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
202372 1 : : SgUpirFieldBodyStatement(startOfConstruct, body)
202373 : {
202374 : #ifdef DEBUG
202375 : // printf ("In SgOmpForSimdStatement::SgOmpForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
202376 : #endif
202377 : #if 0
202378 : // debugging information!
202379 : printf ("In SgOmpForSimdStatement::SgOmpForSimdStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
202380 : #endif
202381 :
202382 :
202383 :
202384 : #if 0
202385 : // DQ (7/30/2014): Call a virtual function.
202386 : std::string s = this->class_name();
202387 : #endif
202388 :
202389 : // Test the variant virtual function
202390 : // assert(OMP_FOR_SIMD_STMT == variant());
202391 1 : assert(OMP_FOR_SIMD_STMT == this->variant());
202392 1 : ROSE_ASSERT(OMP_FOR_SIMD_STMT == (int)(this->variantT()));
202393 1 : post_construction_initialization();
202394 :
202395 : // Test the isSgOmpForSimdStatement() function since it has been problematic
202396 1 : assert(isSgOmpForSimdStatement(this) != NULL);
202397 1 : }
202398 :
202399 : // Generated constructor (all data members)
202400 :
202401 : /* #line 202402 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202402 :
202403 :
202404 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202405 :
202406 :
202407 : // ********************************************************
202408 : // member functions common across all array grammar objects
202409 : // ********************************************************
202410 :
202411 :
202412 :
202413 : /* #line 202414 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202414 :
202415 :
202416 :
202417 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202418 :
202419 : // ********************************************************
202420 : // member functions specific to each node in the grammar
202421 : // ********************************************************
202422 :
202423 :
202424 : /* #line 202425 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202425 :
202426 : // Start of memberFunctionString
202427 : /* #line 19163 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
202428 :
202429 : void
202430 61 : SgOmpCriticalStatement::post_construction_initialization()
202431 61 : {}
202432 :
202433 :
202434 : // End of memberFunctionString
202435 : // Start of memberFunctionString
202436 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
202437 :
202438 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
202439 :
202440 : SgName
202441 69 : SgOmpCriticalStatement::get_name () const
202442 : {
202443 69 : ROSE_ASSERT (this != NULL);
202444 :
202445 : #if 0
202446 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
202447 : // used to trigger marking transformations for the token-based unparsing.
202448 : printf ("SgOmpCriticalStatement::get_name = %p = %s \n",this,this->class_name().c_str());
202449 : #endif
202450 :
202451 69 : return p_name;
202452 : }
202453 :
202454 : void
202455 0 : SgOmpCriticalStatement::set_name ( SgName name )
202456 : {
202457 0 : ROSE_ASSERT (this != NULL);
202458 :
202459 : #if 0
202460 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
202461 : // used to trigger marking transformations for the token-based unparsing.
202462 : printf ("SgOmpCriticalStatement::set_name = %p = %s \n",this,this->class_name().c_str());
202463 : #endif
202464 :
202465 0 : set_isModified(true);
202466 :
202467 0 : p_name = name;
202468 0 : }
202469 :
202470 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
202471 :
202472 :
202473 : // End of memberFunctionString
202474 : // Start of memberFunctionString
202475 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
202476 :
202477 : // *** COMMON CODE SECTION BEGINS HERE ***
202478 :
202479 : #if 0
202480 : int
202481 : SgOmpCriticalStatement::getVariant() const
202482 : {
202483 : // This function is used in ROSE while "variant()" is used in SAGE
202484 : assert(this != NULL);
202485 : return variant();
202486 : }
202487 : #endif
202488 :
202489 : // This function is used in ROSE in treeTraversal code
202490 : // eventually replaces getVariant() and variant()
202491 : // though after variant() has been removed for a while we will
202492 : // want to change the name of variantT() back to variant()
202493 : // (since the "T" was ment to stand for temporary).
202494 : // When this happens the variantT() will be depricated.
202495 : VariantT
202496 5532 : SgOmpCriticalStatement::variantT() const
202497 : {
202498 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
202499 5532 : ROSE_ASSERT(this != NULL);
202500 5532 : return V_SgOmpCriticalStatement;
202501 : }
202502 :
202503 : #if 0
202504 : int
202505 : SgOmpCriticalStatement::variant() const
202506 : {
202507 : // This function is used in SAGE
202508 : ROSE_ASSERT(this != NULL);
202509 : return OMP_CRITICAL_STMT;
202510 : }
202511 : #endif
202512 :
202513 : ROSE_DLL_API const char*
202514 0 : SgOmpCriticalStatement::sage_class_name() const
202515 : {
202516 0 : ROSE_ASSERT(this != NULL);
202517 0 : return "SgOmpCriticalStatement";
202518 : }
202519 :
202520 : std::string
202521 61 : SgOmpCriticalStatement::class_name() const
202522 : {
202523 61 : ROSE_ASSERT(this != NULL);
202524 61 : return "SgOmpCriticalStatement";
202525 : }
202526 :
202527 : // DQ (11/26/2005): Support for visitor pattern mechanims
202528 : // (inferior to ROSE traversal mechanism, experimental).
202529 : void
202530 0 : SgOmpCriticalStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
202531 : {
202532 0 : ROSE_ASSERT(this != NULL);
202533 0 : visitor.visit(this);
202534 0 : }
202535 :
202536 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
202537 0 : void SgOmpCriticalStatement::accept (ROSE_VisitorPattern & visitor) {
202538 0 : ROSE_ASSERT(this != NULL);
202539 0 : visitor.visit(this);
202540 0 : }
202541 :
202542 : SgOmpCriticalStatement*
202543 0 : SgOmpCriticalStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
202544 : {
202545 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
202546 : // This function is currently only supported for the AST used the represent Binary executables.
202547 : if (0 /* isSgAsmNode(this) != NULL */)
202548 : {
202549 : // Support for regex specification.
202550 : std::string prefixCode = "REGEX:";
202551 : addNewAttribute(prefixCode + s,a);
202552 : }
202553 : #endif
202554 :
202555 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
202556 0 : return this;
202557 : }
202558 :
202559 : // *** COMMON CODE SECTION ENDS HERE ***
202560 :
202561 :
202562 : // End of memberFunctionString
202563 : // Start of memberFunctionString
202564 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
202565 :
202566 :
202567 : #if 0
202568 : //! Error checking support
202569 : /*! Verifies the following:
202570 : - working getVariant() member function
202571 : - calls base class's error() member function
202572 : Every class has one of these functions.
202573 : */
202574 : bool
202575 : SgOmpCriticalStatement::error()
202576 : {
202577 : // Put error checking here
202578 :
202579 : ROSE_ASSERT (this != NULL);
202580 : if (getVariant() != OMP_CRITICAL_STMT)
202581 : {
202582 : printf ("Error in SgOmpCriticalStatement::error(): SgOmpCriticalStatement object has a %s variant \n",
202583 : Cxx_GrammarTerminalNames[getVariant()].name);
202584 : // printf ("Error in SgOmpCriticalStatement::error() \n");
202585 : ROSE_ABORT();
202586 : }
202587 :
202588 : ROSE_ASSERT (getVariant() == OMP_CRITICAL_STMT);
202589 : return SgUpirFieldBodyStatement::error();
202590 : }
202591 : #endif
202592 :
202593 :
202594 :
202595 : // End of memberFunctionString
202596 :
202597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
202598 :
202599 130 : SgOmpCriticalStatement* isSgOmpCriticalStatement ( SgNode* inputDerivedClassPointer )
202600 : {
202601 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202602 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202603 : // So to fix this we return NULL directly when the input is NULL and avoid the
202604 : // dynamic_cast in this case. This is likely a performance improvement as well.
202605 : // return dynamic_cast<SgOmpCriticalStatement*>(inputDerivedClassPointer);
202606 : // Milind Chabbi (8/28/2013): isSgOmpCriticalStatement uses table-driven castability instead of c++ default dynamic_cast
202607 : // this improves the running time performance by 10-20%.
202608 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCriticalStatement*>(inputDerivedClassPointer);
202609 130 : return IS_SgOmpCriticalStatement_FAST_MACRO(inputDerivedClassPointer);
202610 : }
202611 :
202612 : // DQ (11/8/2003): Added version of functions taking const pointer
202613 0 : const SgOmpCriticalStatement* isSgOmpCriticalStatement ( const SgNode* inputDerivedClassPointer )
202614 : {
202615 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202616 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202617 : // So to fix this we return NULL directly when the input is NULL and avoid the
202618 : // dynamic_cast in this case. This is likely a performance improvement as well.
202619 : // return dynamic_cast<const SgOmpCriticalStatement*>(inputDerivedClassPointer);
202620 : // Milind Chabbi (8/28/2013): isSgOmpCriticalStatement uses table-driven castability instead of c++ default dynamic_cast
202621 : // this improves the running time performance by 10-20%.
202622 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCriticalStatement*>(inputDerivedClassPointer);
202623 0 : return IS_SgOmpCriticalStatement_FAST_MACRO(inputDerivedClassPointer);
202624 : }
202625 :
202626 :
202627 :
202628 : /* #line 202629 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202629 :
202630 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202631 :
202632 : /**
202633 : \brief Generated destructor
202634 :
202635 : This destructor is automatically generated (by ROSETTA). This destructor
202636 : only frees memory of data members associated with the parts of the current IR node which
202637 : are NOT traversed. Those data members that are part of a traversal can be freed using
202638 : a traversal (calling this destructor on all children in a post-order traversal). Such
202639 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
202640 :
202641 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
202642 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
202643 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
202644 :
202645 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
202646 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
202647 : pointers are not yet implemented to call delete on eash pointer in the container.
202648 : (This could be done by derivation from the STL containers to define containers that
202649 : automatically deleted their members.)
202650 :
202651 : */
202652 0 : SgOmpCriticalStatement::~SgOmpCriticalStatement () {
202653 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
202654 :
202655 :
202656 : // case: not a listType for name
202657 0 : p_name = ""; // non list case
202658 :
202659 : }
202660 :
202661 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202662 0 : }
202663 :
202664 :
202665 : /* #line 202666 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202666 :
202667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
202668 :
202669 : // Generated constructor
202670 61 : SgOmpCriticalStatement::SgOmpCriticalStatement ( Sg_File_Info* startOfConstruct, SgStatement* body, SgName name )
202671 61 : : SgUpirFieldBodyStatement(startOfConstruct, body)
202672 : {
202673 : #ifdef DEBUG
202674 : // printf ("In SgOmpCriticalStatement::SgOmpCriticalStatement (Sg_File_Info* startOfConstruct, SgStatement* body, SgName name) sage_class_name() = %s \n",sage_class_name());
202675 : #endif
202676 : #if 0
202677 : // debugging information!
202678 : printf ("In SgOmpCriticalStatement::SgOmpCriticalStatement (Sg_File_Info* startOfConstruct, SgStatement* body, SgName name): this = %p = %s \n",this,this->class_name().c_str());
202679 : #endif
202680 :
202681 61 : p_name = name;
202682 :
202683 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
202684 :
202685 : #if 0
202686 : // DQ (7/30/2014): Call a virtual function.
202687 : std::string s = this->class_name();
202688 : #endif
202689 :
202690 : // Test the variant virtual function
202691 : // assert(OMP_CRITICAL_STMT == variant());
202692 61 : assert(OMP_CRITICAL_STMT == this->variant());
202693 61 : ROSE_ASSERT(OMP_CRITICAL_STMT == (int)(this->variantT()));
202694 61 : post_construction_initialization();
202695 :
202696 : // Test the isSgOmpCriticalStatement() function since it has been problematic
202697 61 : assert(isSgOmpCriticalStatement(this) != NULL);
202698 61 : }
202699 :
202700 : // Generated constructor (all data members)
202701 :
202702 : /* #line 202703 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202703 :
202704 :
202705 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202706 :
202707 :
202708 : // ********************************************************
202709 : // member functions common across all array grammar objects
202710 : // ********************************************************
202711 :
202712 :
202713 :
202714 : /* #line 202715 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202715 :
202716 :
202717 :
202718 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202719 :
202720 : // ********************************************************
202721 : // member functions specific to each node in the grammar
202722 : // ********************************************************
202723 :
202724 :
202725 : /* #line 202726 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202726 :
202727 : // Start of memberFunctionString
202728 : /* #line 19058 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
202729 :
202730 : void
202731 2 : SgOmpDistributeStatement::post_construction_initialization()
202732 2 : {}
202733 :
202734 :
202735 : // End of memberFunctionString
202736 : // Start of memberFunctionString
202737 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
202738 :
202739 : // *** COMMON CODE SECTION BEGINS HERE ***
202740 :
202741 : #if 0
202742 : int
202743 : SgOmpDistributeStatement::getVariant() const
202744 : {
202745 : // This function is used in ROSE while "variant()" is used in SAGE
202746 : assert(this != NULL);
202747 : return variant();
202748 : }
202749 : #endif
202750 :
202751 : // This function is used in ROSE in treeTraversal code
202752 : // eventually replaces getVariant() and variant()
202753 : // though after variant() has been removed for a while we will
202754 : // want to change the name of variantT() back to variant()
202755 : // (since the "T" was ment to stand for temporary).
202756 : // When this happens the variantT() will be depricated.
202757 : VariantT
202758 169 : SgOmpDistributeStatement::variantT() const
202759 : {
202760 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
202761 169 : ROSE_ASSERT(this != NULL);
202762 169 : return V_SgOmpDistributeStatement;
202763 : }
202764 :
202765 : #if 0
202766 : int
202767 : SgOmpDistributeStatement::variant() const
202768 : {
202769 : // This function is used in SAGE
202770 : ROSE_ASSERT(this != NULL);
202771 : return OMP_DISTRIBUTE_STMT;
202772 : }
202773 : #endif
202774 :
202775 : ROSE_DLL_API const char*
202776 0 : SgOmpDistributeStatement::sage_class_name() const
202777 : {
202778 0 : ROSE_ASSERT(this != NULL);
202779 0 : return "SgOmpDistributeStatement";
202780 : }
202781 :
202782 : std::string
202783 2 : SgOmpDistributeStatement::class_name() const
202784 : {
202785 2 : ROSE_ASSERT(this != NULL);
202786 2 : return "SgOmpDistributeStatement";
202787 : }
202788 :
202789 : // DQ (11/26/2005): Support for visitor pattern mechanims
202790 : // (inferior to ROSE traversal mechanism, experimental).
202791 : void
202792 0 : SgOmpDistributeStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
202793 : {
202794 0 : ROSE_ASSERT(this != NULL);
202795 0 : visitor.visit(this);
202796 0 : }
202797 :
202798 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
202799 0 : void SgOmpDistributeStatement::accept (ROSE_VisitorPattern & visitor) {
202800 0 : ROSE_ASSERT(this != NULL);
202801 0 : visitor.visit(this);
202802 0 : }
202803 :
202804 : SgOmpDistributeStatement*
202805 0 : SgOmpDistributeStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
202806 : {
202807 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
202808 : // This function is currently only supported for the AST used the represent Binary executables.
202809 : if (0 /* isSgAsmNode(this) != NULL */)
202810 : {
202811 : // Support for regex specification.
202812 : std::string prefixCode = "REGEX:";
202813 : addNewAttribute(prefixCode + s,a);
202814 : }
202815 : #endif
202816 :
202817 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
202818 0 : return this;
202819 : }
202820 :
202821 : // *** COMMON CODE SECTION ENDS HERE ***
202822 :
202823 :
202824 : // End of memberFunctionString
202825 : // Start of memberFunctionString
202826 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
202827 :
202828 :
202829 : #if 0
202830 : //! Error checking support
202831 : /*! Verifies the following:
202832 : - working getVariant() member function
202833 : - calls base class's error() member function
202834 : Every class has one of these functions.
202835 : */
202836 : bool
202837 : SgOmpDistributeStatement::error()
202838 : {
202839 : // Put error checking here
202840 :
202841 : ROSE_ASSERT (this != NULL);
202842 : if (getVariant() != OMP_DISTRIBUTE_STMT)
202843 : {
202844 : printf ("Error in SgOmpDistributeStatement::error(): SgOmpDistributeStatement object has a %s variant \n",
202845 : Cxx_GrammarTerminalNames[getVariant()].name);
202846 : // printf ("Error in SgOmpDistributeStatement::error() \n");
202847 : ROSE_ABORT();
202848 : }
202849 :
202850 : ROSE_ASSERT (getVariant() == OMP_DISTRIBUTE_STMT);
202851 : return SgUpirFieldBodyStatement::error();
202852 : }
202853 : #endif
202854 :
202855 :
202856 :
202857 : // End of memberFunctionString
202858 :
202859 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
202860 :
202861 2 : SgOmpDistributeStatement* isSgOmpDistributeStatement ( SgNode* inputDerivedClassPointer )
202862 : {
202863 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202864 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202865 : // So to fix this we return NULL directly when the input is NULL and avoid the
202866 : // dynamic_cast in this case. This is likely a performance improvement as well.
202867 : // return dynamic_cast<SgOmpDistributeStatement*>(inputDerivedClassPointer);
202868 : // Milind Chabbi (8/28/2013): isSgOmpDistributeStatement uses table-driven castability instead of c++ default dynamic_cast
202869 : // this improves the running time performance by 10-20%.
202870 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDistributeStatement*>(inputDerivedClassPointer);
202871 2 : return IS_SgOmpDistributeStatement_FAST_MACRO(inputDerivedClassPointer);
202872 : }
202873 :
202874 : // DQ (11/8/2003): Added version of functions taking const pointer
202875 0 : const SgOmpDistributeStatement* isSgOmpDistributeStatement ( const SgNode* inputDerivedClassPointer )
202876 : {
202877 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
202878 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
202879 : // So to fix this we return NULL directly when the input is NULL and avoid the
202880 : // dynamic_cast in this case. This is likely a performance improvement as well.
202881 : // return dynamic_cast<const SgOmpDistributeStatement*>(inputDerivedClassPointer);
202882 : // Milind Chabbi (8/28/2013): isSgOmpDistributeStatement uses table-driven castability instead of c++ default dynamic_cast
202883 : // this improves the running time performance by 10-20%.
202884 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDistributeStatement*>(inputDerivedClassPointer);
202885 0 : return IS_SgOmpDistributeStatement_FAST_MACRO(inputDerivedClassPointer);
202886 : }
202887 :
202888 :
202889 :
202890 : /* #line 202891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202891 :
202892 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202893 :
202894 : /**
202895 : \brief Generated destructor
202896 :
202897 : This destructor is automatically generated (by ROSETTA). This destructor
202898 : only frees memory of data members associated with the parts of the current IR node which
202899 : are NOT traversed. Those data members that are part of a traversal can be freed using
202900 : a traversal (calling this destructor on all children in a post-order traversal). Such
202901 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
202902 :
202903 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
202904 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
202905 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
202906 :
202907 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
202908 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
202909 : pointers are not yet implemented to call delete on eash pointer in the container.
202910 : (This could be done by derivation from the STL containers to define containers that
202911 : automatically deleted their members.)
202912 :
202913 : */
202914 0 : SgOmpDistributeStatement::~SgOmpDistributeStatement () {
202915 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
202916 :
202917 :
202918 :
202919 : }
202920 :
202921 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
202922 0 : }
202923 :
202924 :
202925 : /* #line 202926 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202926 :
202927 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
202928 :
202929 : // Generated constructor
202930 2 : SgOmpDistributeStatement::SgOmpDistributeStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
202931 2 : : SgUpirFieldBodyStatement(startOfConstruct, body)
202932 : {
202933 : #ifdef DEBUG
202934 : // printf ("In SgOmpDistributeStatement::SgOmpDistributeStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
202935 : #endif
202936 : #if 0
202937 : // debugging information!
202938 : printf ("In SgOmpDistributeStatement::SgOmpDistributeStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
202939 : #endif
202940 :
202941 :
202942 :
202943 : #if 0
202944 : // DQ (7/30/2014): Call a virtual function.
202945 : std::string s = this->class_name();
202946 : #endif
202947 :
202948 : // Test the variant virtual function
202949 : // assert(OMP_DISTRIBUTE_STMT == variant());
202950 2 : assert(OMP_DISTRIBUTE_STMT == this->variant());
202951 2 : ROSE_ASSERT(OMP_DISTRIBUTE_STMT == (int)(this->variantT()));
202952 2 : post_construction_initialization();
202953 :
202954 : // Test the isSgOmpDistributeStatement() function since it has been problematic
202955 2 : assert(isSgOmpDistributeStatement(this) != NULL);
202956 2 : }
202957 :
202958 : // Generated constructor (all data members)
202959 :
202960 : /* #line 202961 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202961 :
202962 :
202963 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202964 :
202965 :
202966 : // ********************************************************
202967 : // member functions common across all array grammar objects
202968 : // ********************************************************
202969 :
202970 :
202971 :
202972 : /* #line 202973 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202973 :
202974 :
202975 :
202976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
202977 :
202978 : // ********************************************************
202979 : // member functions specific to each node in the grammar
202980 : // ********************************************************
202981 :
202982 :
202983 : /* #line 202984 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
202984 :
202985 : // Start of memberFunctionString
202986 : /* #line 19474 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
202987 :
202988 : void
202989 0 : SgOmpUnrollStatement::post_construction_initialization()
202990 0 : {}
202991 :
202992 :
202993 : // End of memberFunctionString
202994 : // Start of memberFunctionString
202995 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
202996 :
202997 : // *** COMMON CODE SECTION BEGINS HERE ***
202998 :
202999 : #if 0
203000 : int
203001 : SgOmpUnrollStatement::getVariant() const
203002 : {
203003 : // This function is used in ROSE while "variant()" is used in SAGE
203004 : assert(this != NULL);
203005 : return variant();
203006 : }
203007 : #endif
203008 :
203009 : // This function is used in ROSE in treeTraversal code
203010 : // eventually replaces getVariant() and variant()
203011 : // though after variant() has been removed for a while we will
203012 : // want to change the name of variantT() back to variant()
203013 : // (since the "T" was ment to stand for temporary).
203014 : // When this happens the variantT() will be depricated.
203015 : VariantT
203016 0 : SgOmpUnrollStatement::variantT() const
203017 : {
203018 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
203019 0 : ROSE_ASSERT(this != NULL);
203020 0 : return V_SgOmpUnrollStatement;
203021 : }
203022 :
203023 : #if 0
203024 : int
203025 : SgOmpUnrollStatement::variant() const
203026 : {
203027 : // This function is used in SAGE
203028 : ROSE_ASSERT(this != NULL);
203029 : return OMP_UNROLL_STMT;
203030 : }
203031 : #endif
203032 :
203033 : ROSE_DLL_API const char*
203034 0 : SgOmpUnrollStatement::sage_class_name() const
203035 : {
203036 0 : ROSE_ASSERT(this != NULL);
203037 0 : return "SgOmpUnrollStatement";
203038 : }
203039 :
203040 : std::string
203041 0 : SgOmpUnrollStatement::class_name() const
203042 : {
203043 0 : ROSE_ASSERT(this != NULL);
203044 0 : return "SgOmpUnrollStatement";
203045 : }
203046 :
203047 : // DQ (11/26/2005): Support for visitor pattern mechanims
203048 : // (inferior to ROSE traversal mechanism, experimental).
203049 : void
203050 0 : SgOmpUnrollStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
203051 : {
203052 0 : ROSE_ASSERT(this != NULL);
203053 0 : visitor.visit(this);
203054 0 : }
203055 :
203056 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
203057 0 : void SgOmpUnrollStatement::accept (ROSE_VisitorPattern & visitor) {
203058 0 : ROSE_ASSERT(this != NULL);
203059 0 : visitor.visit(this);
203060 0 : }
203061 :
203062 : SgOmpUnrollStatement*
203063 0 : SgOmpUnrollStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
203064 : {
203065 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
203066 : // This function is currently only supported for the AST used the represent Binary executables.
203067 : if (0 /* isSgAsmNode(this) != NULL */)
203068 : {
203069 : // Support for regex specification.
203070 : std::string prefixCode = "REGEX:";
203071 : addNewAttribute(prefixCode + s,a);
203072 : }
203073 : #endif
203074 :
203075 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
203076 0 : return this;
203077 : }
203078 :
203079 : // *** COMMON CODE SECTION ENDS HERE ***
203080 :
203081 :
203082 : // End of memberFunctionString
203083 : // Start of memberFunctionString
203084 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
203085 :
203086 :
203087 : #if 0
203088 : //! Error checking support
203089 : /*! Verifies the following:
203090 : - working getVariant() member function
203091 : - calls base class's error() member function
203092 : Every class has one of these functions.
203093 : */
203094 : bool
203095 : SgOmpUnrollStatement::error()
203096 : {
203097 : // Put error checking here
203098 :
203099 : ROSE_ASSERT (this != NULL);
203100 : if (getVariant() != OMP_UNROLL_STMT)
203101 : {
203102 : printf ("Error in SgOmpUnrollStatement::error(): SgOmpUnrollStatement object has a %s variant \n",
203103 : Cxx_GrammarTerminalNames[getVariant()].name);
203104 : // printf ("Error in SgOmpUnrollStatement::error() \n");
203105 : ROSE_ABORT();
203106 : }
203107 :
203108 : ROSE_ASSERT (getVariant() == OMP_UNROLL_STMT);
203109 : return SgUpirFieldBodyStatement::error();
203110 : }
203111 : #endif
203112 :
203113 :
203114 :
203115 : // End of memberFunctionString
203116 :
203117 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
203118 :
203119 0 : SgOmpUnrollStatement* isSgOmpUnrollStatement ( SgNode* inputDerivedClassPointer )
203120 : {
203121 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
203122 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
203123 : // So to fix this we return NULL directly when the input is NULL and avoid the
203124 : // dynamic_cast in this case. This is likely a performance improvement as well.
203125 : // return dynamic_cast<SgOmpUnrollStatement*>(inputDerivedClassPointer);
203126 : // Milind Chabbi (8/28/2013): isSgOmpUnrollStatement uses table-driven castability instead of c++ default dynamic_cast
203127 : // this improves the running time performance by 10-20%.
203128 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpUnrollStatement*>(inputDerivedClassPointer);
203129 0 : return IS_SgOmpUnrollStatement_FAST_MACRO(inputDerivedClassPointer);
203130 : }
203131 :
203132 : // DQ (11/8/2003): Added version of functions taking const pointer
203133 0 : const SgOmpUnrollStatement* isSgOmpUnrollStatement ( const SgNode* inputDerivedClassPointer )
203134 : {
203135 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
203136 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
203137 : // So to fix this we return NULL directly when the input is NULL and avoid the
203138 : // dynamic_cast in this case. This is likely a performance improvement as well.
203139 : // return dynamic_cast<const SgOmpUnrollStatement*>(inputDerivedClassPointer);
203140 : // Milind Chabbi (8/28/2013): isSgOmpUnrollStatement uses table-driven castability instead of c++ default dynamic_cast
203141 : // this improves the running time performance by 10-20%.
203142 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpUnrollStatement*>(inputDerivedClassPointer);
203143 0 : return IS_SgOmpUnrollStatement_FAST_MACRO(inputDerivedClassPointer);
203144 : }
203145 :
203146 :
203147 :
203148 : /* #line 203149 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203149 :
203150 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
203151 :
203152 : /**
203153 : \brief Generated destructor
203154 :
203155 : This destructor is automatically generated (by ROSETTA). This destructor
203156 : only frees memory of data members associated with the parts of the current IR node which
203157 : are NOT traversed. Those data members that are part of a traversal can be freed using
203158 : a traversal (calling this destructor on all children in a post-order traversal). Such
203159 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
203160 :
203161 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
203162 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
203163 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
203164 :
203165 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
203166 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
203167 : pointers are not yet implemented to call delete on eash pointer in the container.
203168 : (This could be done by derivation from the STL containers to define containers that
203169 : automatically deleted their members.)
203170 :
203171 : */
203172 0 : SgOmpUnrollStatement::~SgOmpUnrollStatement () {
203173 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
203174 :
203175 :
203176 :
203177 : }
203178 :
203179 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
203180 0 : }
203181 :
203182 :
203183 : /* #line 203184 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203184 :
203185 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
203186 :
203187 : // Generated constructor
203188 0 : SgOmpUnrollStatement::SgOmpUnrollStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
203189 0 : : SgUpirFieldBodyStatement(startOfConstruct, body)
203190 : {
203191 : #ifdef DEBUG
203192 : // printf ("In SgOmpUnrollStatement::SgOmpUnrollStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
203193 : #endif
203194 : #if 0
203195 : // debugging information!
203196 : printf ("In SgOmpUnrollStatement::SgOmpUnrollStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
203197 : #endif
203198 :
203199 :
203200 :
203201 : #if 0
203202 : // DQ (7/30/2014): Call a virtual function.
203203 : std::string s = this->class_name();
203204 : #endif
203205 :
203206 : // Test the variant virtual function
203207 : // assert(OMP_UNROLL_STMT == variant());
203208 0 : assert(OMP_UNROLL_STMT == this->variant());
203209 0 : ROSE_ASSERT(OMP_UNROLL_STMT == (int)(this->variantT()));
203210 0 : post_construction_initialization();
203211 :
203212 : // Test the isSgOmpUnrollStatement() function since it has been problematic
203213 0 : assert(isSgOmpUnrollStatement(this) != NULL);
203214 0 : }
203215 :
203216 : // Generated constructor (all data members)
203217 :
203218 : /* #line 203219 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203219 :
203220 :
203221 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
203222 :
203223 :
203224 : // ********************************************************
203225 : // member functions common across all array grammar objects
203226 : // ********************************************************
203227 :
203228 :
203229 :
203230 : /* #line 203231 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203231 :
203232 :
203233 :
203234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
203235 :
203236 : // ********************************************************
203237 : // member functions specific to each node in the grammar
203238 : // ********************************************************
203239 :
203240 :
203241 : /* #line 203242 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203242 :
203243 : // Start of memberFunctionString
203244 : /* #line 19481 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
203245 :
203246 : void
203247 0 : SgOmpTileStatement::post_construction_initialization()
203248 0 : {}
203249 :
203250 :
203251 : // End of memberFunctionString
203252 : // Start of memberFunctionString
203253 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
203254 :
203255 : // *** COMMON CODE SECTION BEGINS HERE ***
203256 :
203257 : #if 0
203258 : int
203259 : SgOmpTileStatement::getVariant() const
203260 : {
203261 : // This function is used in ROSE while "variant()" is used in SAGE
203262 : assert(this != NULL);
203263 : return variant();
203264 : }
203265 : #endif
203266 :
203267 : // This function is used in ROSE in treeTraversal code
203268 : // eventually replaces getVariant() and variant()
203269 : // though after variant() has been removed for a while we will
203270 : // want to change the name of variantT() back to variant()
203271 : // (since the "T" was ment to stand for temporary).
203272 : // When this happens the variantT() will be depricated.
203273 : VariantT
203274 0 : SgOmpTileStatement::variantT() const
203275 : {
203276 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
203277 0 : ROSE_ASSERT(this != NULL);
203278 0 : return V_SgOmpTileStatement;
203279 : }
203280 :
203281 : #if 0
203282 : int
203283 : SgOmpTileStatement::variant() const
203284 : {
203285 : // This function is used in SAGE
203286 : ROSE_ASSERT(this != NULL);
203287 : return OMP_TILE_STMT;
203288 : }
203289 : #endif
203290 :
203291 : ROSE_DLL_API const char*
203292 0 : SgOmpTileStatement::sage_class_name() const
203293 : {
203294 0 : ROSE_ASSERT(this != NULL);
203295 0 : return "SgOmpTileStatement";
203296 : }
203297 :
203298 : std::string
203299 0 : SgOmpTileStatement::class_name() const
203300 : {
203301 0 : ROSE_ASSERT(this != NULL);
203302 0 : return "SgOmpTileStatement";
203303 : }
203304 :
203305 : // DQ (11/26/2005): Support for visitor pattern mechanims
203306 : // (inferior to ROSE traversal mechanism, experimental).
203307 : void
203308 0 : SgOmpTileStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
203309 : {
203310 0 : ROSE_ASSERT(this != NULL);
203311 0 : visitor.visit(this);
203312 0 : }
203313 :
203314 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
203315 0 : void SgOmpTileStatement::accept (ROSE_VisitorPattern & visitor) {
203316 0 : ROSE_ASSERT(this != NULL);
203317 0 : visitor.visit(this);
203318 0 : }
203319 :
203320 : SgOmpTileStatement*
203321 0 : SgOmpTileStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
203322 : {
203323 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
203324 : // This function is currently only supported for the AST used the represent Binary executables.
203325 : if (0 /* isSgAsmNode(this) != NULL */)
203326 : {
203327 : // Support for regex specification.
203328 : std::string prefixCode = "REGEX:";
203329 : addNewAttribute(prefixCode + s,a);
203330 : }
203331 : #endif
203332 :
203333 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
203334 0 : return this;
203335 : }
203336 :
203337 : // *** COMMON CODE SECTION ENDS HERE ***
203338 :
203339 :
203340 : // End of memberFunctionString
203341 : // Start of memberFunctionString
203342 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
203343 :
203344 :
203345 : #if 0
203346 : //! Error checking support
203347 : /*! Verifies the following:
203348 : - working getVariant() member function
203349 : - calls base class's error() member function
203350 : Every class has one of these functions.
203351 : */
203352 : bool
203353 : SgOmpTileStatement::error()
203354 : {
203355 : // Put error checking here
203356 :
203357 : ROSE_ASSERT (this != NULL);
203358 : if (getVariant() != OMP_TILE_STMT)
203359 : {
203360 : printf ("Error in SgOmpTileStatement::error(): SgOmpTileStatement object has a %s variant \n",
203361 : Cxx_GrammarTerminalNames[getVariant()].name);
203362 : // printf ("Error in SgOmpTileStatement::error() \n");
203363 : ROSE_ABORT();
203364 : }
203365 :
203366 : ROSE_ASSERT (getVariant() == OMP_TILE_STMT);
203367 : return SgUpirFieldBodyStatement::error();
203368 : }
203369 : #endif
203370 :
203371 :
203372 :
203373 : // End of memberFunctionString
203374 :
203375 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
203376 :
203377 0 : SgOmpTileStatement* isSgOmpTileStatement ( SgNode* inputDerivedClassPointer )
203378 : {
203379 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
203380 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
203381 : // So to fix this we return NULL directly when the input is NULL and avoid the
203382 : // dynamic_cast in this case. This is likely a performance improvement as well.
203383 : // return dynamic_cast<SgOmpTileStatement*>(inputDerivedClassPointer);
203384 : // Milind Chabbi (8/28/2013): isSgOmpTileStatement uses table-driven castability instead of c++ default dynamic_cast
203385 : // this improves the running time performance by 10-20%.
203386 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTileStatement*>(inputDerivedClassPointer);
203387 0 : return IS_SgOmpTileStatement_FAST_MACRO(inputDerivedClassPointer);
203388 : }
203389 :
203390 : // DQ (11/8/2003): Added version of functions taking const pointer
203391 0 : const SgOmpTileStatement* isSgOmpTileStatement ( const SgNode* inputDerivedClassPointer )
203392 : {
203393 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
203394 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
203395 : // So to fix this we return NULL directly when the input is NULL and avoid the
203396 : // dynamic_cast in this case. This is likely a performance improvement as well.
203397 : // return dynamic_cast<const SgOmpTileStatement*>(inputDerivedClassPointer);
203398 : // Milind Chabbi (8/28/2013): isSgOmpTileStatement uses table-driven castability instead of c++ default dynamic_cast
203399 : // this improves the running time performance by 10-20%.
203400 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTileStatement*>(inputDerivedClassPointer);
203401 0 : return IS_SgOmpTileStatement_FAST_MACRO(inputDerivedClassPointer);
203402 : }
203403 :
203404 :
203405 :
203406 : /* #line 203407 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203407 :
203408 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
203409 :
203410 : /**
203411 : \brief Generated destructor
203412 :
203413 : This destructor is automatically generated (by ROSETTA). This destructor
203414 : only frees memory of data members associated with the parts of the current IR node which
203415 : are NOT traversed. Those data members that are part of a traversal can be freed using
203416 : a traversal (calling this destructor on all children in a post-order traversal). Such
203417 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
203418 :
203419 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
203420 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
203421 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
203422 :
203423 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
203424 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
203425 : pointers are not yet implemented to call delete on eash pointer in the container.
203426 : (This could be done by derivation from the STL containers to define containers that
203427 : automatically deleted their members.)
203428 :
203429 : */
203430 0 : SgOmpTileStatement::~SgOmpTileStatement () {
203431 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
203432 :
203433 :
203434 :
203435 : }
203436 :
203437 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
203438 0 : }
203439 :
203440 :
203441 : /* #line 203442 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203442 :
203443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
203444 :
203445 : // Generated constructor
203446 0 : SgOmpTileStatement::SgOmpTileStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
203447 0 : : SgUpirFieldBodyStatement(startOfConstruct, body)
203448 : {
203449 : #ifdef DEBUG
203450 : // printf ("In SgOmpTileStatement::SgOmpTileStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
203451 : #endif
203452 : #if 0
203453 : // debugging information!
203454 : printf ("In SgOmpTileStatement::SgOmpTileStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
203455 : #endif
203456 :
203457 :
203458 :
203459 : #if 0
203460 : // DQ (7/30/2014): Call a virtual function.
203461 : std::string s = this->class_name();
203462 : #endif
203463 :
203464 : // Test the variant virtual function
203465 : // assert(OMP_TILE_STMT == variant());
203466 0 : assert(OMP_TILE_STMT == this->variant());
203467 0 : ROSE_ASSERT(OMP_TILE_STMT == (int)(this->variantT()));
203468 0 : post_construction_initialization();
203469 :
203470 : // Test the isSgOmpTileStatement() function since it has been problematic
203471 0 : assert(isSgOmpTileStatement(this) != NULL);
203472 0 : }
203473 :
203474 : // Generated constructor (all data members)
203475 :
203476 : /* #line 203477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203477 :
203478 :
203479 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
203480 :
203481 :
203482 : // ********************************************************
203483 : // member functions common across all array grammar objects
203484 : // ********************************************************
203485 :
203486 :
203487 :
203488 : /* #line 203489 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203489 :
203490 :
203491 :
203492 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
203493 :
203494 : // ********************************************************
203495 : // member functions specific to each node in the grammar
203496 : // ********************************************************
203497 :
203498 :
203499 : /* #line 203500 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203500 :
203501 : // Start of memberFunctionString
203502 : /* #line 18991 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
203503 :
203504 : void
203505 199 : SgUpirLoopStatement::post_construction_initialization()
203506 199 : {}
203507 :
203508 :
203509 : // End of memberFunctionString
203510 : // Start of memberFunctionString
203511 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
203512 :
203513 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
203514 :
203515 : SgInitializedName*
203516 0 : SgUpirLoopStatement::get_induction () const
203517 : {
203518 0 : ROSE_ASSERT (this != NULL);
203519 :
203520 : #if 0
203521 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203522 : // used to trigger marking transformations for the token-based unparsing.
203523 : printf ("SgUpirLoopStatement::get_induction = %p = %s \n",this,this->class_name().c_str());
203524 : #endif
203525 :
203526 0 : return p_induction;
203527 : }
203528 :
203529 : void
203530 0 : SgUpirLoopStatement::set_induction ( SgInitializedName* induction )
203531 : {
203532 0 : ROSE_ASSERT (this != NULL);
203533 :
203534 : #if 0
203535 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203536 : // used to trigger marking transformations for the token-based unparsing.
203537 : printf ("SgUpirLoopStatement::set_induction = %p = %s \n",this,this->class_name().c_str());
203538 : #endif
203539 :
203540 0 : set_isModified(true);
203541 :
203542 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
203543 : if (p_induction != NULL && induction != NULL && p_induction != induction)
203544 : {
203545 : printf ("Warning: induction = %p overwriting valid pointer p_induction = %p \n",induction,p_induction);
203546 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
203547 : printf ("Error fails assertion (p_induction != NULL && induction != NULL && p_induction != induction) is false\n");
203548 : ROSE_ASSERT(false);
203549 : #endif
203550 : }
203551 : #endif
203552 0 : p_induction = induction;
203553 0 : }
203554 :
203555 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
203556 :
203557 :
203558 : // End of memberFunctionString
203559 : // Start of memberFunctionString
203560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
203561 :
203562 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
203563 :
203564 : SgExpression*
203565 0 : SgUpirLoopStatement::get_lower_bound () const
203566 : {
203567 0 : ROSE_ASSERT (this != NULL);
203568 :
203569 : #if 0
203570 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203571 : // used to trigger marking transformations for the token-based unparsing.
203572 : printf ("SgUpirLoopStatement::get_lower_bound = %p = %s \n",this,this->class_name().c_str());
203573 : #endif
203574 :
203575 0 : return p_lower_bound;
203576 : }
203577 :
203578 : void
203579 0 : SgUpirLoopStatement::set_lower_bound ( SgExpression* lower_bound )
203580 : {
203581 0 : ROSE_ASSERT (this != NULL);
203582 :
203583 : #if 0
203584 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203585 : // used to trigger marking transformations for the token-based unparsing.
203586 : printf ("SgUpirLoopStatement::set_lower_bound = %p = %s \n",this,this->class_name().c_str());
203587 : #endif
203588 :
203589 0 : set_isModified(true);
203590 :
203591 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
203592 : if (p_lower_bound != NULL && lower_bound != NULL && p_lower_bound != lower_bound)
203593 : {
203594 : printf ("Warning: lower_bound = %p overwriting valid pointer p_lower_bound = %p \n",lower_bound,p_lower_bound);
203595 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
203596 : printf ("Error fails assertion (p_lower_bound != NULL && lower_bound != NULL && p_lower_bound != lower_bound) is false\n");
203597 : ROSE_ASSERT(false);
203598 : #endif
203599 : }
203600 : #endif
203601 0 : p_lower_bound = lower_bound;
203602 0 : }
203603 :
203604 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
203605 :
203606 :
203607 : // End of memberFunctionString
203608 : // Start of memberFunctionString
203609 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
203610 :
203611 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
203612 :
203613 : SgExpression*
203614 0 : SgUpirLoopStatement::get_upper_bound () const
203615 : {
203616 0 : ROSE_ASSERT (this != NULL);
203617 :
203618 : #if 0
203619 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203620 : // used to trigger marking transformations for the token-based unparsing.
203621 : printf ("SgUpirLoopStatement::get_upper_bound = %p = %s \n",this,this->class_name().c_str());
203622 : #endif
203623 :
203624 0 : return p_upper_bound;
203625 : }
203626 :
203627 : void
203628 0 : SgUpirLoopStatement::set_upper_bound ( SgExpression* upper_bound )
203629 : {
203630 0 : ROSE_ASSERT (this != NULL);
203631 :
203632 : #if 0
203633 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203634 : // used to trigger marking transformations for the token-based unparsing.
203635 : printf ("SgUpirLoopStatement::set_upper_bound = %p = %s \n",this,this->class_name().c_str());
203636 : #endif
203637 :
203638 0 : set_isModified(true);
203639 :
203640 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
203641 : if (p_upper_bound != NULL && upper_bound != NULL && p_upper_bound != upper_bound)
203642 : {
203643 : printf ("Warning: upper_bound = %p overwriting valid pointer p_upper_bound = %p \n",upper_bound,p_upper_bound);
203644 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
203645 : printf ("Error fails assertion (p_upper_bound != NULL && upper_bound != NULL && p_upper_bound != upper_bound) is false\n");
203646 : ROSE_ASSERT(false);
203647 : #endif
203648 : }
203649 : #endif
203650 0 : p_upper_bound = upper_bound;
203651 0 : }
203652 :
203653 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
203654 :
203655 :
203656 : // End of memberFunctionString
203657 : // Start of memberFunctionString
203658 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
203659 :
203660 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
203661 :
203662 : SgExpression*
203663 0 : SgUpirLoopStatement::get_step () const
203664 : {
203665 0 : ROSE_ASSERT (this != NULL);
203666 :
203667 : #if 0
203668 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203669 : // used to trigger marking transformations for the token-based unparsing.
203670 : printf ("SgUpirLoopStatement::get_step = %p = %s \n",this,this->class_name().c_str());
203671 : #endif
203672 :
203673 0 : return p_step;
203674 : }
203675 :
203676 : void
203677 0 : SgUpirLoopStatement::set_step ( SgExpression* step )
203678 : {
203679 0 : ROSE_ASSERT (this != NULL);
203680 :
203681 : #if 0
203682 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203683 : // used to trigger marking transformations for the token-based unparsing.
203684 : printf ("SgUpirLoopStatement::set_step = %p = %s \n",this,this->class_name().c_str());
203685 : #endif
203686 :
203687 0 : set_isModified(true);
203688 :
203689 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
203690 : if (p_step != NULL && step != NULL && p_step != step)
203691 : {
203692 : printf ("Warning: step = %p overwriting valid pointer p_step = %p \n",step,p_step);
203693 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
203694 : printf ("Error fails assertion (p_step != NULL && step != NULL && p_step != step) is false\n");
203695 : ROSE_ASSERT(false);
203696 : #endif
203697 : }
203698 : #endif
203699 0 : p_step = step;
203700 0 : }
203701 :
203702 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
203703 :
203704 :
203705 : // End of memberFunctionString
203706 : // Start of memberFunctionString
203707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
203708 :
203709 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
203710 :
203711 : bool
203712 0 : SgUpirLoopStatement::get_incremental () const
203713 : {
203714 0 : ROSE_ASSERT (this != NULL);
203715 :
203716 : #if 0
203717 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203718 : // used to trigger marking transformations for the token-based unparsing.
203719 : printf ("SgUpirLoopStatement::get_incremental = %p = %s \n",this,this->class_name().c_str());
203720 : #endif
203721 :
203722 0 : return p_incremental;
203723 : }
203724 :
203725 : void
203726 0 : SgUpirLoopStatement::set_incremental ( bool incremental )
203727 : {
203728 0 : ROSE_ASSERT (this != NULL);
203729 :
203730 : #if 0
203731 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
203732 : // used to trigger marking transformations for the token-based unparsing.
203733 : printf ("SgUpirLoopStatement::set_incremental = %p = %s \n",this,this->class_name().c_str());
203734 : #endif
203735 :
203736 0 : set_isModified(true);
203737 :
203738 0 : p_incremental = incremental;
203739 0 : }
203740 :
203741 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
203742 :
203743 :
203744 : // End of memberFunctionString
203745 : // Start of memberFunctionString
203746 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
203747 :
203748 : // *** COMMON CODE SECTION BEGINS HERE ***
203749 :
203750 : #if 0
203751 : int
203752 : SgUpirLoopStatement::getVariant() const
203753 : {
203754 : // This function is used in ROSE while "variant()" is used in SAGE
203755 : assert(this != NULL);
203756 : return variant();
203757 : }
203758 : #endif
203759 :
203760 : // This function is used in ROSE in treeTraversal code
203761 : // eventually replaces getVariant() and variant()
203762 : // though after variant() has been removed for a while we will
203763 : // want to change the name of variantT() back to variant()
203764 : // (since the "T" was ment to stand for temporary).
203765 : // When this happens the variantT() will be depricated.
203766 : VariantT
203767 4975 : SgUpirLoopStatement::variantT() const
203768 : {
203769 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
203770 4975 : ROSE_ASSERT(this != NULL);
203771 4975 : return V_SgUpirLoopStatement;
203772 : }
203773 :
203774 : #if 0
203775 : int
203776 : SgUpirLoopStatement::variant() const
203777 : {
203778 : // This function is used in SAGE
203779 : ROSE_ASSERT(this != NULL);
203780 : return UPIR_LOOP_STMT;
203781 : }
203782 : #endif
203783 :
203784 : ROSE_DLL_API const char*
203785 0 : SgUpirLoopStatement::sage_class_name() const
203786 : {
203787 0 : ROSE_ASSERT(this != NULL);
203788 0 : return "SgUpirLoopStatement";
203789 : }
203790 :
203791 : std::string
203792 199 : SgUpirLoopStatement::class_name() const
203793 : {
203794 199 : ROSE_ASSERT(this != NULL);
203795 199 : return "SgUpirLoopStatement";
203796 : }
203797 :
203798 : // DQ (11/26/2005): Support for visitor pattern mechanims
203799 : // (inferior to ROSE traversal mechanism, experimental).
203800 : void
203801 0 : SgUpirLoopStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
203802 : {
203803 0 : ROSE_ASSERT(this != NULL);
203804 0 : visitor.visit(this);
203805 0 : }
203806 :
203807 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
203808 0 : void SgUpirLoopStatement::accept (ROSE_VisitorPattern & visitor) {
203809 0 : ROSE_ASSERT(this != NULL);
203810 0 : visitor.visit(this);
203811 0 : }
203812 :
203813 : SgUpirLoopStatement*
203814 0 : SgUpirLoopStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
203815 : {
203816 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
203817 : // This function is currently only supported for the AST used the represent Binary executables.
203818 : if (0 /* isSgAsmNode(this) != NULL */)
203819 : {
203820 : // Support for regex specification.
203821 : std::string prefixCode = "REGEX:";
203822 : addNewAttribute(prefixCode + s,a);
203823 : }
203824 : #endif
203825 :
203826 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
203827 0 : return this;
203828 : }
203829 :
203830 : // *** COMMON CODE SECTION ENDS HERE ***
203831 :
203832 :
203833 : // End of memberFunctionString
203834 : // Start of memberFunctionString
203835 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
203836 :
203837 :
203838 : #if 0
203839 : //! Error checking support
203840 : /*! Verifies the following:
203841 : - working getVariant() member function
203842 : - calls base class's error() member function
203843 : Every class has one of these functions.
203844 : */
203845 : bool
203846 : SgUpirLoopStatement::error()
203847 : {
203848 : // Put error checking here
203849 :
203850 : ROSE_ASSERT (this != NULL);
203851 : if (getVariant() != UPIR_LOOP_STMT)
203852 : {
203853 : printf ("Error in SgUpirLoopStatement::error(): SgUpirLoopStatement object has a %s variant \n",
203854 : Cxx_GrammarTerminalNames[getVariant()].name);
203855 : // printf ("Error in SgUpirLoopStatement::error() \n");
203856 : ROSE_ABORT();
203857 : }
203858 :
203859 : ROSE_ASSERT (getVariant() == UPIR_LOOP_STMT);
203860 : return SgUpirFieldBodyStatement::error();
203861 : }
203862 : #endif
203863 :
203864 :
203865 :
203866 : // End of memberFunctionString
203867 :
203868 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
203869 :
203870 199 : SgUpirLoopStatement* isSgUpirLoopStatement ( SgNode* inputDerivedClassPointer )
203871 : {
203872 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
203873 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
203874 : // So to fix this we return NULL directly when the input is NULL and avoid the
203875 : // dynamic_cast in this case. This is likely a performance improvement as well.
203876 : // return dynamic_cast<SgUpirLoopStatement*>(inputDerivedClassPointer);
203877 : // Milind Chabbi (8/28/2013): isSgUpirLoopStatement uses table-driven castability instead of c++ default dynamic_cast
203878 : // this improves the running time performance by 10-20%.
203879 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirLoopStatement*>(inputDerivedClassPointer);
203880 199 : return IS_SgUpirLoopStatement_FAST_MACRO(inputDerivedClassPointer);
203881 : }
203882 :
203883 : // DQ (11/8/2003): Added version of functions taking const pointer
203884 0 : const SgUpirLoopStatement* isSgUpirLoopStatement ( const SgNode* inputDerivedClassPointer )
203885 : {
203886 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
203887 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
203888 : // So to fix this we return NULL directly when the input is NULL and avoid the
203889 : // dynamic_cast in this case. This is likely a performance improvement as well.
203890 : // return dynamic_cast<const SgUpirLoopStatement*>(inputDerivedClassPointer);
203891 : // Milind Chabbi (8/28/2013): isSgUpirLoopStatement uses table-driven castability instead of c++ default dynamic_cast
203892 : // this improves the running time performance by 10-20%.
203893 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirLoopStatement*>(inputDerivedClassPointer);
203894 0 : return IS_SgUpirLoopStatement_FAST_MACRO(inputDerivedClassPointer);
203895 : }
203896 :
203897 :
203898 :
203899 : /* #line 203900 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203900 :
203901 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
203902 :
203903 : /**
203904 : \brief Generated destructor
203905 :
203906 : This destructor is automatically generated (by ROSETTA). This destructor
203907 : only frees memory of data members associated with the parts of the current IR node which
203908 : are NOT traversed. Those data members that are part of a traversal can be freed using
203909 : a traversal (calling this destructor on all children in a post-order traversal). Such
203910 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
203911 :
203912 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
203913 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
203914 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
203915 :
203916 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
203917 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
203918 : pointers are not yet implemented to call delete on eash pointer in the container.
203919 : (This could be done by derivation from the STL containers to define containers that
203920 : automatically deleted their members.)
203921 :
203922 : */
203923 0 : SgUpirLoopStatement::~SgUpirLoopStatement () {
203924 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
203925 :
203926 :
203927 : // case: not a listType for induction
203928 0 : p_induction = NULL; // non list case
203929 : // case: not a listType for lower_bound
203930 0 : p_lower_bound = NULL; // non list case
203931 : // case: not a listType for upper_bound
203932 0 : p_upper_bound = NULL; // non list case
203933 : // case: not a listType for step
203934 0 : p_step = NULL; // non list case
203935 : // case: not a listType for incremental
203936 0 : p_incremental = true; // non list case
203937 :
203938 : }
203939 :
203940 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
203941 0 : }
203942 :
203943 :
203944 : /* #line 203945 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203945 :
203946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
203947 :
203948 : // Generated constructor
203949 199 : SgUpirLoopStatement::SgUpirLoopStatement ( Sg_File_Info* startOfConstruct, SgStatement* body )
203950 199 : : SgUpirFieldBodyStatement(startOfConstruct, body)
203951 : {
203952 : #ifdef DEBUG
203953 : // printf ("In SgUpirLoopStatement::SgUpirLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
203954 : #endif
203955 : #if 0
203956 : // debugging information!
203957 : printf ("In SgUpirLoopStatement::SgUpirLoopStatement (Sg_File_Info* startOfConstruct, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
203958 : #endif
203959 :
203960 199 : p_induction = NULL;
203961 199 : p_lower_bound = NULL;
203962 199 : p_upper_bound = NULL;
203963 199 : p_step = NULL;
203964 199 : p_incremental = true;
203965 :
203966 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
203967 :
203968 : #if 0
203969 : // DQ (7/30/2014): Call a virtual function.
203970 : std::string s = this->class_name();
203971 : #endif
203972 :
203973 : // Test the variant virtual function
203974 : // assert(UPIR_LOOP_STMT == variant());
203975 199 : assert(UPIR_LOOP_STMT == this->variant());
203976 199 : ROSE_ASSERT(UPIR_LOOP_STMT == (int)(this->variantT()));
203977 199 : post_construction_initialization();
203978 :
203979 : // Test the isSgUpirLoopStatement() function since it has been problematic
203980 199 : assert(isSgUpirLoopStatement(this) != NULL);
203981 199 : }
203982 :
203983 : // Generated constructor (all data members)
203984 :
203985 : /* #line 203986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203986 :
203987 :
203988 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
203989 :
203990 :
203991 : // ********************************************************
203992 : // member functions common across all array grammar objects
203993 : // ********************************************************
203994 :
203995 :
203996 :
203997 : /* #line 203998 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
203998 :
203999 :
204000 :
204001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204002 :
204003 : // ********************************************************
204004 : // member functions specific to each node in the grammar
204005 : // ********************************************************
204006 :
204007 :
204008 : /* #line 204009 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204009 :
204010 : // Start of memberFunctionString
204011 : /* #line 19517 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
204012 :
204013 : void
204014 417 : SgUpirFieldStatement::post_construction_initialization()
204015 417 : {}
204016 :
204017 :
204018 : // End of memberFunctionString
204019 : // Start of memberFunctionString
204020 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
204021 :
204022 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
204023 :
204024 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
204025 : const SgOmpClausePtrList &
204026 0 : SgUpirFieldStatement::get_clauses () const
204027 : {
204028 0 : assert (this != NULL);
204029 0 : return p_clauses;
204030 : }
204031 :
204032 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
204033 : SgOmpClausePtrList &
204034 497 : SgUpirFieldStatement::get_clauses ()
204035 : {
204036 497 : assert (this != NULL);
204037 :
204038 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
204039 : // As a rule only set_ access functions can set the isModified flag.
204040 : // set_isModified(true);
204041 :
204042 497 : return p_clauses;
204043 : }
204044 :
204045 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
204046 :
204047 :
204048 : // End of memberFunctionString
204049 : // Start of memberFunctionString
204050 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
204051 :
204052 : // *** COMMON CODE SECTION BEGINS HERE ***
204053 :
204054 : #if 0
204055 : int
204056 : SgUpirFieldStatement::getVariant() const
204057 : {
204058 : // This function is used in ROSE while "variant()" is used in SAGE
204059 : assert(this != NULL);
204060 : return variant();
204061 : }
204062 : #endif
204063 :
204064 : // This function is used in ROSE in treeTraversal code
204065 : // eventually replaces getVariant() and variant()
204066 : // though after variant() has been removed for a while we will
204067 : // want to change the name of variantT() back to variant()
204068 : // (since the "T" was ment to stand for temporary).
204069 : // When this happens the variantT() will be depricated.
204070 : VariantT
204071 1251 : SgUpirFieldStatement::variantT() const
204072 : {
204073 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
204074 1251 : ROSE_ASSERT(this != NULL);
204075 1251 : return V_SgUpirFieldStatement;
204076 : }
204077 :
204078 : #if 0
204079 : int
204080 : SgUpirFieldStatement::variant() const
204081 : {
204082 : // This function is used in SAGE
204083 : ROSE_ASSERT(this != NULL);
204084 : return UPIR_FIELD_STMT;
204085 : }
204086 : #endif
204087 :
204088 : ROSE_DLL_API const char*
204089 0 : SgUpirFieldStatement::sage_class_name() const
204090 : {
204091 0 : ROSE_ASSERT(this != NULL);
204092 0 : return "SgUpirFieldStatement";
204093 : }
204094 :
204095 : std::string
204096 0 : SgUpirFieldStatement::class_name() const
204097 : {
204098 0 : ROSE_ASSERT(this != NULL);
204099 0 : return "SgUpirFieldStatement";
204100 : }
204101 :
204102 : // DQ (11/26/2005): Support for visitor pattern mechanims
204103 : // (inferior to ROSE traversal mechanism, experimental).
204104 : void
204105 0 : SgUpirFieldStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
204106 : {
204107 0 : ROSE_ASSERT(this != NULL);
204108 0 : visitor.visit(this);
204109 0 : }
204110 :
204111 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
204112 0 : void SgUpirFieldStatement::accept (ROSE_VisitorPattern & visitor) {
204113 0 : ROSE_ASSERT(this != NULL);
204114 0 : visitor.visit(this);
204115 0 : }
204116 :
204117 : SgUpirFieldStatement*
204118 0 : SgUpirFieldStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
204119 : {
204120 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
204121 : // This function is currently only supported for the AST used the represent Binary executables.
204122 : if (0 /* isSgAsmNode(this) != NULL */)
204123 : {
204124 : // Support for regex specification.
204125 : std::string prefixCode = "REGEX:";
204126 : addNewAttribute(prefixCode + s,a);
204127 : }
204128 : #endif
204129 :
204130 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
204131 0 : return this;
204132 : }
204133 :
204134 : // *** COMMON CODE SECTION ENDS HERE ***
204135 :
204136 :
204137 : // End of memberFunctionString
204138 : // Start of memberFunctionString
204139 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
204140 :
204141 :
204142 : #if 0
204143 : //! Error checking support
204144 : /*! Verifies the following:
204145 : - working getVariant() member function
204146 : - calls base class's error() member function
204147 : Every class has one of these functions.
204148 : */
204149 : bool
204150 : SgUpirFieldStatement::error()
204151 : {
204152 : // Put error checking here
204153 :
204154 : ROSE_ASSERT (this != NULL);
204155 : if (getVariant() != UPIR_FIELD_STMT)
204156 : {
204157 : printf ("Error in SgUpirFieldStatement::error(): SgUpirFieldStatement object has a %s variant \n",
204158 : Cxx_GrammarTerminalNames[getVariant()].name);
204159 : // printf ("Error in SgUpirFieldStatement::error() \n");
204160 : ROSE_ABORT();
204161 : }
204162 :
204163 : ROSE_ASSERT (getVariant() == UPIR_FIELD_STMT);
204164 : return SgUpirBaseStatement::error();
204165 : }
204166 : #endif
204167 :
204168 :
204169 :
204170 : // End of memberFunctionString
204171 :
204172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
204173 :
204174 1889 : SgUpirFieldStatement* isSgUpirFieldStatement ( SgNode* inputDerivedClassPointer )
204175 : {
204176 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204177 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204178 : // So to fix this we return NULL directly when the input is NULL and avoid the
204179 : // dynamic_cast in this case. This is likely a performance improvement as well.
204180 : // return dynamic_cast<SgUpirFieldStatement*>(inputDerivedClassPointer);
204181 : // Milind Chabbi (8/28/2013): isSgUpirFieldStatement uses table-driven castability instead of c++ default dynamic_cast
204182 : // this improves the running time performance by 10-20%.
204183 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirFieldStatement*>(inputDerivedClassPointer);
204184 1889 : return IS_SgUpirFieldStatement_FAST_MACRO(inputDerivedClassPointer);
204185 : }
204186 :
204187 : // DQ (11/8/2003): Added version of functions taking const pointer
204188 0 : const SgUpirFieldStatement* isSgUpirFieldStatement ( const SgNode* inputDerivedClassPointer )
204189 : {
204190 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204191 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204192 : // So to fix this we return NULL directly when the input is NULL and avoid the
204193 : // dynamic_cast in this case. This is likely a performance improvement as well.
204194 : // return dynamic_cast<const SgUpirFieldStatement*>(inputDerivedClassPointer);
204195 : // Milind Chabbi (8/28/2013): isSgUpirFieldStatement uses table-driven castability instead of c++ default dynamic_cast
204196 : // this improves the running time performance by 10-20%.
204197 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirFieldStatement*>(inputDerivedClassPointer);
204198 0 : return IS_SgUpirFieldStatement_FAST_MACRO(inputDerivedClassPointer);
204199 : }
204200 :
204201 :
204202 :
204203 : /* #line 204204 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204204 :
204205 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204206 :
204207 : /**
204208 : \brief Generated destructor
204209 :
204210 : This destructor is automatically generated (by ROSETTA). This destructor
204211 : only frees memory of data members associated with the parts of the current IR node which
204212 : are NOT traversed. Those data members that are part of a traversal can be freed using
204213 : a traversal (calling this destructor on all children in a post-order traversal). Such
204214 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
204215 :
204216 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
204217 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
204218 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
204219 :
204220 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
204221 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
204222 : pointers are not yet implemented to call delete on eash pointer in the container.
204223 : (This could be done by derivation from the STL containers to define containers that
204224 : automatically deleted their members.)
204225 :
204226 : */
204227 0 : SgUpirFieldStatement::~SgUpirFieldStatement () {
204228 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
204229 :
204230 :
204231 :
204232 : }
204233 :
204234 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204235 0 : }
204236 :
204237 :
204238 : /* #line 204239 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204239 :
204240 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
204241 :
204242 : // Generated constructor
204243 398 : SgUpirFieldStatement::SgUpirFieldStatement ( Sg_File_Info* startOfConstruct )
204244 398 : : SgUpirBaseStatement(startOfConstruct)
204245 : {
204246 : #ifdef DEBUG
204247 : // printf ("In SgUpirFieldStatement::SgUpirFieldStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
204248 : #endif
204249 : #if 0
204250 : // debugging information!
204251 : printf ("In SgUpirFieldStatement::SgUpirFieldStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
204252 : #endif
204253 :
204254 :
204255 :
204256 : #if 0
204257 : // DQ (7/30/2014): Call a virtual function.
204258 : std::string s = this->class_name();
204259 : #endif
204260 :
204261 : // Test the variant virtual function
204262 : // assert(UPIR_FIELD_STMT == variant());
204263 398 : assert(UPIR_FIELD_STMT == this->variant());
204264 398 : ROSE_ASSERT(UPIR_FIELD_STMT == (int)(this->variantT()));
204265 398 : post_construction_initialization();
204266 :
204267 : // Test the isSgUpirFieldStatement() function since it has been problematic
204268 398 : assert(isSgUpirFieldStatement(this) != NULL);
204269 398 : }
204270 :
204271 : // Generated constructor (all data members)
204272 :
204273 : /* #line 204274 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204274 :
204275 :
204276 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204277 :
204278 :
204279 : // ********************************************************
204280 : // member functions common across all array grammar objects
204281 : // ********************************************************
204282 :
204283 :
204284 :
204285 : /* #line 204286 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204286 :
204287 :
204288 :
204289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204290 :
204291 : // ********************************************************
204292 : // member functions specific to each node in the grammar
204293 : // ********************************************************
204294 :
204295 :
204296 : /* #line 204297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204297 :
204298 : // Start of memberFunctionString
204299 : /* #line 19040 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
204300 :
204301 : void
204302 1 : SgOmpCancelStatement::post_construction_initialization()
204303 1 : {}
204304 :
204305 :
204306 : // End of memberFunctionString
204307 : // Start of memberFunctionString
204308 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
204309 :
204310 : // *** COMMON CODE SECTION BEGINS HERE ***
204311 :
204312 : #if 0
204313 : int
204314 : SgOmpCancelStatement::getVariant() const
204315 : {
204316 : // This function is used in ROSE while "variant()" is used in SAGE
204317 : assert(this != NULL);
204318 : return variant();
204319 : }
204320 : #endif
204321 :
204322 : // This function is used in ROSE in treeTraversal code
204323 : // eventually replaces getVariant() and variant()
204324 : // though after variant() has been removed for a while we will
204325 : // want to change the name of variantT() back to variant()
204326 : // (since the "T" was ment to stand for temporary).
204327 : // When this happens the variantT() will be depricated.
204328 : VariantT
204329 78 : SgOmpCancelStatement::variantT() const
204330 : {
204331 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
204332 78 : ROSE_ASSERT(this != NULL);
204333 78 : return V_SgOmpCancelStatement;
204334 : }
204335 :
204336 : #if 0
204337 : int
204338 : SgOmpCancelStatement::variant() const
204339 : {
204340 : // This function is used in SAGE
204341 : ROSE_ASSERT(this != NULL);
204342 : return OMP_CANCEL_STMT;
204343 : }
204344 : #endif
204345 :
204346 : ROSE_DLL_API const char*
204347 0 : SgOmpCancelStatement::sage_class_name() const
204348 : {
204349 0 : ROSE_ASSERT(this != NULL);
204350 0 : return "SgOmpCancelStatement";
204351 : }
204352 :
204353 : std::string
204354 1 : SgOmpCancelStatement::class_name() const
204355 : {
204356 1 : ROSE_ASSERT(this != NULL);
204357 1 : return "SgOmpCancelStatement";
204358 : }
204359 :
204360 : // DQ (11/26/2005): Support for visitor pattern mechanims
204361 : // (inferior to ROSE traversal mechanism, experimental).
204362 : void
204363 0 : SgOmpCancelStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
204364 : {
204365 0 : ROSE_ASSERT(this != NULL);
204366 0 : visitor.visit(this);
204367 0 : }
204368 :
204369 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
204370 0 : void SgOmpCancelStatement::accept (ROSE_VisitorPattern & visitor) {
204371 0 : ROSE_ASSERT(this != NULL);
204372 0 : visitor.visit(this);
204373 0 : }
204374 :
204375 : SgOmpCancelStatement*
204376 0 : SgOmpCancelStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
204377 : {
204378 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
204379 : // This function is currently only supported for the AST used the represent Binary executables.
204380 : if (0 /* isSgAsmNode(this) != NULL */)
204381 : {
204382 : // Support for regex specification.
204383 : std::string prefixCode = "REGEX:";
204384 : addNewAttribute(prefixCode + s,a);
204385 : }
204386 : #endif
204387 :
204388 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
204389 0 : return this;
204390 : }
204391 :
204392 : // *** COMMON CODE SECTION ENDS HERE ***
204393 :
204394 :
204395 : // End of memberFunctionString
204396 : // Start of memberFunctionString
204397 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
204398 :
204399 :
204400 : #if 0
204401 : //! Error checking support
204402 : /*! Verifies the following:
204403 : - working getVariant() member function
204404 : - calls base class's error() member function
204405 : Every class has one of these functions.
204406 : */
204407 : bool
204408 : SgOmpCancelStatement::error()
204409 : {
204410 : // Put error checking here
204411 :
204412 : ROSE_ASSERT (this != NULL);
204413 : if (getVariant() != OMP_CANCEL_STMT)
204414 : {
204415 : printf ("Error in SgOmpCancelStatement::error(): SgOmpCancelStatement object has a %s variant \n",
204416 : Cxx_GrammarTerminalNames[getVariant()].name);
204417 : // printf ("Error in SgOmpCancelStatement::error() \n");
204418 : ROSE_ABORT();
204419 : }
204420 :
204421 : ROSE_ASSERT (getVariant() == OMP_CANCEL_STMT);
204422 : return SgUpirFieldStatement::error();
204423 : }
204424 : #endif
204425 :
204426 :
204427 :
204428 : // End of memberFunctionString
204429 :
204430 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
204431 :
204432 1 : SgOmpCancelStatement* isSgOmpCancelStatement ( SgNode* inputDerivedClassPointer )
204433 : {
204434 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204435 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204436 : // So to fix this we return NULL directly when the input is NULL and avoid the
204437 : // dynamic_cast in this case. This is likely a performance improvement as well.
204438 : // return dynamic_cast<SgOmpCancelStatement*>(inputDerivedClassPointer);
204439 : // Milind Chabbi (8/28/2013): isSgOmpCancelStatement uses table-driven castability instead of c++ default dynamic_cast
204440 : // this improves the running time performance by 10-20%.
204441 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCancelStatement*>(inputDerivedClassPointer);
204442 1 : return IS_SgOmpCancelStatement_FAST_MACRO(inputDerivedClassPointer);
204443 : }
204444 :
204445 : // DQ (11/8/2003): Added version of functions taking const pointer
204446 0 : const SgOmpCancelStatement* isSgOmpCancelStatement ( const SgNode* inputDerivedClassPointer )
204447 : {
204448 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204449 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204450 : // So to fix this we return NULL directly when the input is NULL and avoid the
204451 : // dynamic_cast in this case. This is likely a performance improvement as well.
204452 : // return dynamic_cast<const SgOmpCancelStatement*>(inputDerivedClassPointer);
204453 : // Milind Chabbi (8/28/2013): isSgOmpCancelStatement uses table-driven castability instead of c++ default dynamic_cast
204454 : // this improves the running time performance by 10-20%.
204455 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCancelStatement*>(inputDerivedClassPointer);
204456 0 : return IS_SgOmpCancelStatement_FAST_MACRO(inputDerivedClassPointer);
204457 : }
204458 :
204459 :
204460 :
204461 : /* #line 204462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204462 :
204463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204464 :
204465 : /**
204466 : \brief Generated destructor
204467 :
204468 : This destructor is automatically generated (by ROSETTA). This destructor
204469 : only frees memory of data members associated with the parts of the current IR node which
204470 : are NOT traversed. Those data members that are part of a traversal can be freed using
204471 : a traversal (calling this destructor on all children in a post-order traversal). Such
204472 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
204473 :
204474 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
204475 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
204476 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
204477 :
204478 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
204479 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
204480 : pointers are not yet implemented to call delete on eash pointer in the container.
204481 : (This could be done by derivation from the STL containers to define containers that
204482 : automatically deleted their members.)
204483 :
204484 : */
204485 0 : SgOmpCancelStatement::~SgOmpCancelStatement () {
204486 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
204487 :
204488 :
204489 :
204490 : }
204491 :
204492 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204493 0 : }
204494 :
204495 :
204496 : /* #line 204497 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204497 :
204498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
204499 :
204500 : // Generated constructor
204501 0 : SgOmpCancelStatement::SgOmpCancelStatement ( Sg_File_Info* startOfConstruct )
204502 0 : : SgUpirFieldStatement(startOfConstruct)
204503 : {
204504 : #ifdef DEBUG
204505 : // printf ("In SgOmpCancelStatement::SgOmpCancelStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
204506 : #endif
204507 : #if 0
204508 : // debugging information!
204509 : printf ("In SgOmpCancelStatement::SgOmpCancelStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
204510 : #endif
204511 :
204512 :
204513 :
204514 : #if 0
204515 : // DQ (7/30/2014): Call a virtual function.
204516 : std::string s = this->class_name();
204517 : #endif
204518 :
204519 : // Test the variant virtual function
204520 : // assert(OMP_CANCEL_STMT == variant());
204521 0 : assert(OMP_CANCEL_STMT == this->variant());
204522 0 : ROSE_ASSERT(OMP_CANCEL_STMT == (int)(this->variantT()));
204523 0 : post_construction_initialization();
204524 :
204525 : // Test the isSgOmpCancelStatement() function since it has been problematic
204526 0 : assert(isSgOmpCancelStatement(this) != NULL);
204527 0 : }
204528 :
204529 : // Generated constructor (all data members)
204530 :
204531 : /* #line 204532 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204532 :
204533 :
204534 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204535 :
204536 :
204537 : // ********************************************************
204538 : // member functions common across all array grammar objects
204539 : // ********************************************************
204540 :
204541 :
204542 :
204543 : /* #line 204544 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204544 :
204545 :
204546 :
204547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204548 :
204549 : // ********************************************************
204550 : // member functions specific to each node in the grammar
204551 : // ********************************************************
204552 :
204553 :
204554 : /* #line 204555 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204555 :
204556 : // Start of memberFunctionString
204557 : /* #line 19022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
204558 :
204559 : void
204560 1 : SgOmpCancellationPointStatement::post_construction_initialization()
204561 1 : {}
204562 :
204563 :
204564 : // End of memberFunctionString
204565 : // Start of memberFunctionString
204566 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
204567 :
204568 : // *** COMMON CODE SECTION BEGINS HERE ***
204569 :
204570 : #if 0
204571 : int
204572 : SgOmpCancellationPointStatement::getVariant() const
204573 : {
204574 : // This function is used in ROSE while "variant()" is used in SAGE
204575 : assert(this != NULL);
204576 : return variant();
204577 : }
204578 : #endif
204579 :
204580 : // This function is used in ROSE in treeTraversal code
204581 : // eventually replaces getVariant() and variant()
204582 : // though after variant() has been removed for a while we will
204583 : // want to change the name of variantT() back to variant()
204584 : // (since the "T" was ment to stand for temporary).
204585 : // When this happens the variantT() will be depricated.
204586 : VariantT
204587 78 : SgOmpCancellationPointStatement::variantT() const
204588 : {
204589 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
204590 78 : ROSE_ASSERT(this != NULL);
204591 78 : return V_SgOmpCancellationPointStatement;
204592 : }
204593 :
204594 : #if 0
204595 : int
204596 : SgOmpCancellationPointStatement::variant() const
204597 : {
204598 : // This function is used in SAGE
204599 : ROSE_ASSERT(this != NULL);
204600 : return OMP_CANCELLATION_POINT_STMT;
204601 : }
204602 : #endif
204603 :
204604 : ROSE_DLL_API const char*
204605 0 : SgOmpCancellationPointStatement::sage_class_name() const
204606 : {
204607 0 : ROSE_ASSERT(this != NULL);
204608 0 : return "SgOmpCancellationPointStatement";
204609 : }
204610 :
204611 : std::string
204612 1 : SgOmpCancellationPointStatement::class_name() const
204613 : {
204614 1 : ROSE_ASSERT(this != NULL);
204615 1 : return "SgOmpCancellationPointStatement";
204616 : }
204617 :
204618 : // DQ (11/26/2005): Support for visitor pattern mechanims
204619 : // (inferior to ROSE traversal mechanism, experimental).
204620 : void
204621 0 : SgOmpCancellationPointStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
204622 : {
204623 0 : ROSE_ASSERT(this != NULL);
204624 0 : visitor.visit(this);
204625 0 : }
204626 :
204627 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
204628 0 : void SgOmpCancellationPointStatement::accept (ROSE_VisitorPattern & visitor) {
204629 0 : ROSE_ASSERT(this != NULL);
204630 0 : visitor.visit(this);
204631 0 : }
204632 :
204633 : SgOmpCancellationPointStatement*
204634 0 : SgOmpCancellationPointStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
204635 : {
204636 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
204637 : // This function is currently only supported for the AST used the represent Binary executables.
204638 : if (0 /* isSgAsmNode(this) != NULL */)
204639 : {
204640 : // Support for regex specification.
204641 : std::string prefixCode = "REGEX:";
204642 : addNewAttribute(prefixCode + s,a);
204643 : }
204644 : #endif
204645 :
204646 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
204647 0 : return this;
204648 : }
204649 :
204650 : // *** COMMON CODE SECTION ENDS HERE ***
204651 :
204652 :
204653 : // End of memberFunctionString
204654 : // Start of memberFunctionString
204655 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
204656 :
204657 :
204658 : #if 0
204659 : //! Error checking support
204660 : /*! Verifies the following:
204661 : - working getVariant() member function
204662 : - calls base class's error() member function
204663 : Every class has one of these functions.
204664 : */
204665 : bool
204666 : SgOmpCancellationPointStatement::error()
204667 : {
204668 : // Put error checking here
204669 :
204670 : ROSE_ASSERT (this != NULL);
204671 : if (getVariant() != OMP_CANCELLATION_POINT_STMT)
204672 : {
204673 : printf ("Error in SgOmpCancellationPointStatement::error(): SgOmpCancellationPointStatement object has a %s variant \n",
204674 : Cxx_GrammarTerminalNames[getVariant()].name);
204675 : // printf ("Error in SgOmpCancellationPointStatement::error() \n");
204676 : ROSE_ABORT();
204677 : }
204678 :
204679 : ROSE_ASSERT (getVariant() == OMP_CANCELLATION_POINT_STMT);
204680 : return SgUpirFieldStatement::error();
204681 : }
204682 : #endif
204683 :
204684 :
204685 :
204686 : // End of memberFunctionString
204687 :
204688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
204689 :
204690 1 : SgOmpCancellationPointStatement* isSgOmpCancellationPointStatement ( SgNode* inputDerivedClassPointer )
204691 : {
204692 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204693 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204694 : // So to fix this we return NULL directly when the input is NULL and avoid the
204695 : // dynamic_cast in this case. This is likely a performance improvement as well.
204696 : // return dynamic_cast<SgOmpCancellationPointStatement*>(inputDerivedClassPointer);
204697 : // Milind Chabbi (8/28/2013): isSgOmpCancellationPointStatement uses table-driven castability instead of c++ default dynamic_cast
204698 : // this improves the running time performance by 10-20%.
204699 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpCancellationPointStatement*>(inputDerivedClassPointer);
204700 1 : return IS_SgOmpCancellationPointStatement_FAST_MACRO(inputDerivedClassPointer);
204701 : }
204702 :
204703 : // DQ (11/8/2003): Added version of functions taking const pointer
204704 0 : const SgOmpCancellationPointStatement* isSgOmpCancellationPointStatement ( const SgNode* inputDerivedClassPointer )
204705 : {
204706 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204707 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204708 : // So to fix this we return NULL directly when the input is NULL and avoid the
204709 : // dynamic_cast in this case. This is likely a performance improvement as well.
204710 : // return dynamic_cast<const SgOmpCancellationPointStatement*>(inputDerivedClassPointer);
204711 : // Milind Chabbi (8/28/2013): isSgOmpCancellationPointStatement uses table-driven castability instead of c++ default dynamic_cast
204712 : // this improves the running time performance by 10-20%.
204713 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpCancellationPointStatement*>(inputDerivedClassPointer);
204714 0 : return IS_SgOmpCancellationPointStatement_FAST_MACRO(inputDerivedClassPointer);
204715 : }
204716 :
204717 :
204718 :
204719 : /* #line 204720 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204720 :
204721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204722 :
204723 : /**
204724 : \brief Generated destructor
204725 :
204726 : This destructor is automatically generated (by ROSETTA). This destructor
204727 : only frees memory of data members associated with the parts of the current IR node which
204728 : are NOT traversed. Those data members that are part of a traversal can be freed using
204729 : a traversal (calling this destructor on all children in a post-order traversal). Such
204730 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
204731 :
204732 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
204733 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
204734 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
204735 :
204736 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
204737 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
204738 : pointers are not yet implemented to call delete on eash pointer in the container.
204739 : (This could be done by derivation from the STL containers to define containers that
204740 : automatically deleted their members.)
204741 :
204742 : */
204743 0 : SgOmpCancellationPointStatement::~SgOmpCancellationPointStatement () {
204744 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
204745 :
204746 :
204747 :
204748 : }
204749 :
204750 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204751 0 : }
204752 :
204753 :
204754 : /* #line 204755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204755 :
204756 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
204757 :
204758 : // Generated constructor
204759 0 : SgOmpCancellationPointStatement::SgOmpCancellationPointStatement ( Sg_File_Info* startOfConstruct )
204760 0 : : SgUpirFieldStatement(startOfConstruct)
204761 : {
204762 : #ifdef DEBUG
204763 : // printf ("In SgOmpCancellationPointStatement::SgOmpCancellationPointStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
204764 : #endif
204765 : #if 0
204766 : // debugging information!
204767 : printf ("In SgOmpCancellationPointStatement::SgOmpCancellationPointStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
204768 : #endif
204769 :
204770 :
204771 :
204772 : #if 0
204773 : // DQ (7/30/2014): Call a virtual function.
204774 : std::string s = this->class_name();
204775 : #endif
204776 :
204777 : // Test the variant virtual function
204778 : // assert(OMP_CANCELLATION_POINT_STMT == variant());
204779 0 : assert(OMP_CANCELLATION_POINT_STMT == this->variant());
204780 0 : ROSE_ASSERT(OMP_CANCELLATION_POINT_STMT == (int)(this->variantT()));
204781 0 : post_construction_initialization();
204782 :
204783 : // Test the isSgOmpCancellationPointStatement() function since it has been problematic
204784 0 : assert(isSgOmpCancellationPointStatement(this) != NULL);
204785 0 : }
204786 :
204787 : // Generated constructor (all data members)
204788 :
204789 : /* #line 204790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204790 :
204791 :
204792 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204793 :
204794 :
204795 : // ********************************************************
204796 : // member functions common across all array grammar objects
204797 : // ********************************************************
204798 :
204799 :
204800 :
204801 : /* #line 204802 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204802 :
204803 :
204804 :
204805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
204806 :
204807 : // ********************************************************
204808 : // member functions specific to each node in the grammar
204809 : // ********************************************************
204810 :
204811 :
204812 : /* #line 204813 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204813 :
204814 : // Start of memberFunctionString
204815 : /* #line 19277 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
204816 :
204817 : void
204818 5 : SgOmpTargetUpdateStatement::post_construction_initialization()
204819 5 : {}
204820 :
204821 :
204822 : // End of memberFunctionString
204823 : // Start of memberFunctionString
204824 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
204825 :
204826 : // *** COMMON CODE SECTION BEGINS HERE ***
204827 :
204828 : #if 0
204829 : int
204830 : SgOmpTargetUpdateStatement::getVariant() const
204831 : {
204832 : // This function is used in ROSE while "variant()" is used in SAGE
204833 : assert(this != NULL);
204834 : return variant();
204835 : }
204836 : #endif
204837 :
204838 : // This function is used in ROSE in treeTraversal code
204839 : // eventually replaces getVariant() and variant()
204840 : // though after variant() has been removed for a while we will
204841 : // want to change the name of variantT() back to variant()
204842 : // (since the "T" was ment to stand for temporary).
204843 : // When this happens the variantT() will be depricated.
204844 : VariantT
204845 394 : SgOmpTargetUpdateStatement::variantT() const
204846 : {
204847 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
204848 394 : ROSE_ASSERT(this != NULL);
204849 394 : return V_SgOmpTargetUpdateStatement;
204850 : }
204851 :
204852 : #if 0
204853 : int
204854 : SgOmpTargetUpdateStatement::variant() const
204855 : {
204856 : // This function is used in SAGE
204857 : ROSE_ASSERT(this != NULL);
204858 : return OMP_TARGET_UPDATE_STMT;
204859 : }
204860 : #endif
204861 :
204862 : ROSE_DLL_API const char*
204863 0 : SgOmpTargetUpdateStatement::sage_class_name() const
204864 : {
204865 0 : ROSE_ASSERT(this != NULL);
204866 0 : return "SgOmpTargetUpdateStatement";
204867 : }
204868 :
204869 : std::string
204870 5 : SgOmpTargetUpdateStatement::class_name() const
204871 : {
204872 5 : ROSE_ASSERT(this != NULL);
204873 5 : return "SgOmpTargetUpdateStatement";
204874 : }
204875 :
204876 : // DQ (11/26/2005): Support for visitor pattern mechanims
204877 : // (inferior to ROSE traversal mechanism, experimental).
204878 : void
204879 0 : SgOmpTargetUpdateStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
204880 : {
204881 0 : ROSE_ASSERT(this != NULL);
204882 0 : visitor.visit(this);
204883 0 : }
204884 :
204885 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
204886 0 : void SgOmpTargetUpdateStatement::accept (ROSE_VisitorPattern & visitor) {
204887 0 : ROSE_ASSERT(this != NULL);
204888 0 : visitor.visit(this);
204889 0 : }
204890 :
204891 : SgOmpTargetUpdateStatement*
204892 0 : SgOmpTargetUpdateStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
204893 : {
204894 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
204895 : // This function is currently only supported for the AST used the represent Binary executables.
204896 : if (0 /* isSgAsmNode(this) != NULL */)
204897 : {
204898 : // Support for regex specification.
204899 : std::string prefixCode = "REGEX:";
204900 : addNewAttribute(prefixCode + s,a);
204901 : }
204902 : #endif
204903 :
204904 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
204905 0 : return this;
204906 : }
204907 :
204908 : // *** COMMON CODE SECTION ENDS HERE ***
204909 :
204910 :
204911 : // End of memberFunctionString
204912 : // Start of memberFunctionString
204913 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
204914 :
204915 :
204916 : #if 0
204917 : //! Error checking support
204918 : /*! Verifies the following:
204919 : - working getVariant() member function
204920 : - calls base class's error() member function
204921 : Every class has one of these functions.
204922 : */
204923 : bool
204924 : SgOmpTargetUpdateStatement::error()
204925 : {
204926 : // Put error checking here
204927 :
204928 : ROSE_ASSERT (this != NULL);
204929 : if (getVariant() != OMP_TARGET_UPDATE_STMT)
204930 : {
204931 : printf ("Error in SgOmpTargetUpdateStatement::error(): SgOmpTargetUpdateStatement object has a %s variant \n",
204932 : Cxx_GrammarTerminalNames[getVariant()].name);
204933 : // printf ("Error in SgOmpTargetUpdateStatement::error() \n");
204934 : ROSE_ABORT();
204935 : }
204936 :
204937 : ROSE_ASSERT (getVariant() == OMP_TARGET_UPDATE_STMT);
204938 : return SgUpirFieldStatement::error();
204939 : }
204940 : #endif
204941 :
204942 :
204943 :
204944 : // End of memberFunctionString
204945 :
204946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
204947 :
204948 5 : SgOmpTargetUpdateStatement* isSgOmpTargetUpdateStatement ( SgNode* inputDerivedClassPointer )
204949 : {
204950 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204951 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204952 : // So to fix this we return NULL directly when the input is NULL and avoid the
204953 : // dynamic_cast in this case. This is likely a performance improvement as well.
204954 : // return dynamic_cast<SgOmpTargetUpdateStatement*>(inputDerivedClassPointer);
204955 : // Milind Chabbi (8/28/2013): isSgOmpTargetUpdateStatement uses table-driven castability instead of c++ default dynamic_cast
204956 : // this improves the running time performance by 10-20%.
204957 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpTargetUpdateStatement*>(inputDerivedClassPointer);
204958 5 : return IS_SgOmpTargetUpdateStatement_FAST_MACRO(inputDerivedClassPointer);
204959 : }
204960 :
204961 : // DQ (11/8/2003): Added version of functions taking const pointer
204962 0 : const SgOmpTargetUpdateStatement* isSgOmpTargetUpdateStatement ( const SgNode* inputDerivedClassPointer )
204963 : {
204964 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
204965 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
204966 : // So to fix this we return NULL directly when the input is NULL and avoid the
204967 : // dynamic_cast in this case. This is likely a performance improvement as well.
204968 : // return dynamic_cast<const SgOmpTargetUpdateStatement*>(inputDerivedClassPointer);
204969 : // Milind Chabbi (8/28/2013): isSgOmpTargetUpdateStatement uses table-driven castability instead of c++ default dynamic_cast
204970 : // this improves the running time performance by 10-20%.
204971 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpTargetUpdateStatement*>(inputDerivedClassPointer);
204972 0 : return IS_SgOmpTargetUpdateStatement_FAST_MACRO(inputDerivedClassPointer);
204973 : }
204974 :
204975 :
204976 :
204977 : /* #line 204978 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
204978 :
204979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
204980 :
204981 : /**
204982 : \brief Generated destructor
204983 :
204984 : This destructor is automatically generated (by ROSETTA). This destructor
204985 : only frees memory of data members associated with the parts of the current IR node which
204986 : are NOT traversed. Those data members that are part of a traversal can be freed using
204987 : a traversal (calling this destructor on all children in a post-order traversal). Such
204988 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
204989 :
204990 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
204991 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
204992 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
204993 :
204994 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
204995 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
204996 : pointers are not yet implemented to call delete on eash pointer in the container.
204997 : (This could be done by derivation from the STL containers to define containers that
204998 : automatically deleted their members.)
204999 :
205000 : */
205001 0 : SgOmpTargetUpdateStatement::~SgOmpTargetUpdateStatement () {
205002 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
205003 :
205004 :
205005 :
205006 : }
205007 :
205008 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205009 0 : }
205010 :
205011 :
205012 : /* #line 205013 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205013 :
205014 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
205015 :
205016 : // Generated constructor
205017 0 : SgOmpTargetUpdateStatement::SgOmpTargetUpdateStatement ( Sg_File_Info* startOfConstruct )
205018 0 : : SgUpirFieldStatement(startOfConstruct)
205019 : {
205020 : #ifdef DEBUG
205021 : // printf ("In SgOmpTargetUpdateStatement::SgOmpTargetUpdateStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
205022 : #endif
205023 : #if 0
205024 : // debugging information!
205025 : printf ("In SgOmpTargetUpdateStatement::SgOmpTargetUpdateStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
205026 : #endif
205027 :
205028 :
205029 :
205030 : #if 0
205031 : // DQ (7/30/2014): Call a virtual function.
205032 : std::string s = this->class_name();
205033 : #endif
205034 :
205035 : // Test the variant virtual function
205036 : // assert(OMP_TARGET_UPDATE_STMT == variant());
205037 0 : assert(OMP_TARGET_UPDATE_STMT == this->variant());
205038 0 : ROSE_ASSERT(OMP_TARGET_UPDATE_STMT == (int)(this->variantT()));
205039 0 : post_construction_initialization();
205040 :
205041 : // Test the isSgOmpTargetUpdateStatement() function since it has been problematic
205042 0 : assert(isSgOmpTargetUpdateStatement(this) != NULL);
205043 0 : }
205044 :
205045 : // Generated constructor (all data members)
205046 :
205047 : /* #line 205048 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205048 :
205049 :
205050 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205051 :
205052 :
205053 : // ********************************************************
205054 : // member functions common across all array grammar objects
205055 : // ********************************************************
205056 :
205057 :
205058 :
205059 : /* #line 205060 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205060 :
205061 :
205062 :
205063 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205064 :
205065 : // ********************************************************
205066 : // member functions specific to each node in the grammar
205067 : // ********************************************************
205068 :
205069 :
205070 : /* #line 205071 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205071 :
205072 : // Start of memberFunctionString
205073 : /* #line 19112 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
205074 :
205075 : void
205076 9 : SgOmpFlushStatement::post_construction_initialization()
205077 9 : {}
205078 :
205079 :
205080 : // End of memberFunctionString
205081 : // Start of memberFunctionString
205082 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
205083 :
205084 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
205085 :
205086 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
205087 : const SgVarRefExpPtrList &
205088 0 : SgOmpFlushStatement::get_variables () const
205089 : {
205090 0 : assert (this != NULL);
205091 0 : return p_variables;
205092 : }
205093 :
205094 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
205095 : SgVarRefExpPtrList &
205096 75 : SgOmpFlushStatement::get_variables ()
205097 : {
205098 75 : assert (this != NULL);
205099 :
205100 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
205101 : // As a rule only set_ access functions can set the isModified flag.
205102 : // set_isModified(true);
205103 :
205104 75 : return p_variables;
205105 : }
205106 :
205107 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
205108 :
205109 :
205110 : // End of memberFunctionString
205111 : // Start of memberFunctionString
205112 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
205113 :
205114 : // *** COMMON CODE SECTION BEGINS HERE ***
205115 :
205116 : #if 0
205117 : int
205118 : SgOmpFlushStatement::getVariant() const
205119 : {
205120 : // This function is used in ROSE while "variant()" is used in SAGE
205121 : assert(this != NULL);
205122 : return variant();
205123 : }
205124 : #endif
205125 :
205126 : // This function is used in ROSE in treeTraversal code
205127 : // eventually replaces getVariant() and variant()
205128 : // though after variant() has been removed for a while we will
205129 : // want to change the name of variantT() back to variant()
205130 : // (since the "T" was ment to stand for temporary).
205131 : // When this happens the variantT() will be depricated.
205132 : VariantT
205133 649 : SgOmpFlushStatement::variantT() const
205134 : {
205135 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
205136 649 : ROSE_ASSERT(this != NULL);
205137 649 : return V_SgOmpFlushStatement;
205138 : }
205139 :
205140 : #if 0
205141 : int
205142 : SgOmpFlushStatement::variant() const
205143 : {
205144 : // This function is used in SAGE
205145 : ROSE_ASSERT(this != NULL);
205146 : return OMP_FLUSH_STMT;
205147 : }
205148 : #endif
205149 :
205150 : ROSE_DLL_API const char*
205151 0 : SgOmpFlushStatement::sage_class_name() const
205152 : {
205153 0 : ROSE_ASSERT(this != NULL);
205154 0 : return "SgOmpFlushStatement";
205155 : }
205156 :
205157 : std::string
205158 9 : SgOmpFlushStatement::class_name() const
205159 : {
205160 9 : ROSE_ASSERT(this != NULL);
205161 9 : return "SgOmpFlushStatement";
205162 : }
205163 :
205164 : // DQ (11/26/2005): Support for visitor pattern mechanims
205165 : // (inferior to ROSE traversal mechanism, experimental).
205166 : void
205167 0 : SgOmpFlushStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
205168 : {
205169 0 : ROSE_ASSERT(this != NULL);
205170 0 : visitor.visit(this);
205171 0 : }
205172 :
205173 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
205174 0 : void SgOmpFlushStatement::accept (ROSE_VisitorPattern & visitor) {
205175 0 : ROSE_ASSERT(this != NULL);
205176 0 : visitor.visit(this);
205177 0 : }
205178 :
205179 : SgOmpFlushStatement*
205180 0 : SgOmpFlushStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
205181 : {
205182 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
205183 : // This function is currently only supported for the AST used the represent Binary executables.
205184 : if (0 /* isSgAsmNode(this) != NULL */)
205185 : {
205186 : // Support for regex specification.
205187 : std::string prefixCode = "REGEX:";
205188 : addNewAttribute(prefixCode + s,a);
205189 : }
205190 : #endif
205191 :
205192 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
205193 0 : return this;
205194 : }
205195 :
205196 : // *** COMMON CODE SECTION ENDS HERE ***
205197 :
205198 :
205199 : // End of memberFunctionString
205200 : // Start of memberFunctionString
205201 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
205202 :
205203 :
205204 : #if 0
205205 : //! Error checking support
205206 : /*! Verifies the following:
205207 : - working getVariant() member function
205208 : - calls base class's error() member function
205209 : Every class has one of these functions.
205210 : */
205211 : bool
205212 : SgOmpFlushStatement::error()
205213 : {
205214 : // Put error checking here
205215 :
205216 : ROSE_ASSERT (this != NULL);
205217 : if (getVariant() != OMP_FLUSH_STMT)
205218 : {
205219 : printf ("Error in SgOmpFlushStatement::error(): SgOmpFlushStatement object has a %s variant \n",
205220 : Cxx_GrammarTerminalNames[getVariant()].name);
205221 : // printf ("Error in SgOmpFlushStatement::error() \n");
205222 : ROSE_ABORT();
205223 : }
205224 :
205225 : ROSE_ASSERT (getVariant() == OMP_FLUSH_STMT);
205226 : return SgUpirFieldStatement::error();
205227 : }
205228 : #endif
205229 :
205230 :
205231 :
205232 : // End of memberFunctionString
205233 :
205234 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
205235 :
205236 899 : SgOmpFlushStatement* isSgOmpFlushStatement ( SgNode* inputDerivedClassPointer )
205237 : {
205238 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
205239 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
205240 : // So to fix this we return NULL directly when the input is NULL and avoid the
205241 : // dynamic_cast in this case. This is likely a performance improvement as well.
205242 : // return dynamic_cast<SgOmpFlushStatement*>(inputDerivedClassPointer);
205243 : // Milind Chabbi (8/28/2013): isSgOmpFlushStatement uses table-driven castability instead of c++ default dynamic_cast
205244 : // this improves the running time performance by 10-20%.
205245 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpFlushStatement*>(inputDerivedClassPointer);
205246 899 : return IS_SgOmpFlushStatement_FAST_MACRO(inputDerivedClassPointer);
205247 : }
205248 :
205249 : // DQ (11/8/2003): Added version of functions taking const pointer
205250 0 : const SgOmpFlushStatement* isSgOmpFlushStatement ( const SgNode* inputDerivedClassPointer )
205251 : {
205252 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
205253 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
205254 : // So to fix this we return NULL directly when the input is NULL and avoid the
205255 : // dynamic_cast in this case. This is likely a performance improvement as well.
205256 : // return dynamic_cast<const SgOmpFlushStatement*>(inputDerivedClassPointer);
205257 : // Milind Chabbi (8/28/2013): isSgOmpFlushStatement uses table-driven castability instead of c++ default dynamic_cast
205258 : // this improves the running time performance by 10-20%.
205259 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpFlushStatement*>(inputDerivedClassPointer);
205260 0 : return IS_SgOmpFlushStatement_FAST_MACRO(inputDerivedClassPointer);
205261 : }
205262 :
205263 :
205264 :
205265 : /* #line 205266 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205266 :
205267 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205268 :
205269 : /**
205270 : \brief Generated destructor
205271 :
205272 : This destructor is automatically generated (by ROSETTA). This destructor
205273 : only frees memory of data members associated with the parts of the current IR node which
205274 : are NOT traversed. Those data members that are part of a traversal can be freed using
205275 : a traversal (calling this destructor on all children in a post-order traversal). Such
205276 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
205277 :
205278 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
205279 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
205280 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
205281 :
205282 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
205283 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
205284 : pointers are not yet implemented to call delete on eash pointer in the container.
205285 : (This could be done by derivation from the STL containers to define containers that
205286 : automatically deleted their members.)
205287 :
205288 : */
205289 0 : SgOmpFlushStatement::~SgOmpFlushStatement () {
205290 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
205291 :
205292 :
205293 :
205294 : }
205295 :
205296 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205297 0 : }
205298 :
205299 :
205300 : /* #line 205301 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205301 :
205302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
205303 :
205304 : // Generated constructor
205305 0 : SgOmpFlushStatement::SgOmpFlushStatement ( Sg_File_Info* startOfConstruct )
205306 0 : : SgUpirFieldStatement(startOfConstruct)
205307 : {
205308 : #ifdef DEBUG
205309 : // printf ("In SgOmpFlushStatement::SgOmpFlushStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
205310 : #endif
205311 : #if 0
205312 : // debugging information!
205313 : printf ("In SgOmpFlushStatement::SgOmpFlushStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
205314 : #endif
205315 :
205316 :
205317 :
205318 : #if 0
205319 : // DQ (7/30/2014): Call a virtual function.
205320 : std::string s = this->class_name();
205321 : #endif
205322 :
205323 : // Test the variant virtual function
205324 : // assert(OMP_FLUSH_STMT == variant());
205325 0 : assert(OMP_FLUSH_STMT == this->variant());
205326 0 : ROSE_ASSERT(OMP_FLUSH_STMT == (int)(this->variantT()));
205327 0 : post_construction_initialization();
205328 :
205329 : // Test the isSgOmpFlushStatement() function since it has been problematic
205330 0 : assert(isSgOmpFlushStatement(this) != NULL);
205331 0 : }
205332 :
205333 : // Generated constructor (all data members)
205334 :
205335 : /* #line 205336 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205336 :
205337 :
205338 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205339 :
205340 :
205341 : // ********************************************************
205342 : // member functions common across all array grammar objects
205343 : // ********************************************************
205344 :
205345 :
205346 :
205347 : /* #line 205348 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205348 :
205349 :
205350 :
205351 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205352 :
205353 : // ********************************************************
205354 : // member functions specific to each node in the grammar
205355 : // ********************************************************
205356 :
205357 :
205358 : /* #line 205359 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205359 :
205360 : // Start of memberFunctionString
205361 : /* #line 19118 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
205362 :
205363 : void
205364 1 : SgOmpAllocateStatement::post_construction_initialization()
205365 1 : {}
205366 :
205367 :
205368 : // End of memberFunctionString
205369 : // Start of memberFunctionString
205370 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
205371 :
205372 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
205373 :
205374 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
205375 : const SgVarRefExpPtrList &
205376 0 : SgOmpAllocateStatement::get_variables () const
205377 : {
205378 0 : assert (this != NULL);
205379 0 : return p_variables;
205380 : }
205381 :
205382 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
205383 : SgVarRefExpPtrList &
205384 7 : SgOmpAllocateStatement::get_variables ()
205385 : {
205386 7 : assert (this != NULL);
205387 :
205388 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
205389 : // As a rule only set_ access functions can set the isModified flag.
205390 : // set_isModified(true);
205391 :
205392 7 : return p_variables;
205393 : }
205394 :
205395 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
205396 :
205397 :
205398 : // End of memberFunctionString
205399 : // Start of memberFunctionString
205400 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
205401 :
205402 : // *** COMMON CODE SECTION BEGINS HERE ***
205403 :
205404 : #if 0
205405 : int
205406 : SgOmpAllocateStatement::getVariant() const
205407 : {
205408 : // This function is used in ROSE while "variant()" is used in SAGE
205409 : assert(this != NULL);
205410 : return variant();
205411 : }
205412 : #endif
205413 :
205414 : // This function is used in ROSE in treeTraversal code
205415 : // eventually replaces getVariant() and variant()
205416 : // though after variant() has been removed for a while we will
205417 : // want to change the name of variantT() back to variant()
205418 : // (since the "T" was ment to stand for temporary).
205419 : // When this happens the variantT() will be depricated.
205420 : VariantT
205421 78 : SgOmpAllocateStatement::variantT() const
205422 : {
205423 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
205424 78 : ROSE_ASSERT(this != NULL);
205425 78 : return V_SgOmpAllocateStatement;
205426 : }
205427 :
205428 : #if 0
205429 : int
205430 : SgOmpAllocateStatement::variant() const
205431 : {
205432 : // This function is used in SAGE
205433 : ROSE_ASSERT(this != NULL);
205434 : return OMP_ALLOCATE_STMT;
205435 : }
205436 : #endif
205437 :
205438 : ROSE_DLL_API const char*
205439 0 : SgOmpAllocateStatement::sage_class_name() const
205440 : {
205441 0 : ROSE_ASSERT(this != NULL);
205442 0 : return "SgOmpAllocateStatement";
205443 : }
205444 :
205445 : std::string
205446 1 : SgOmpAllocateStatement::class_name() const
205447 : {
205448 1 : ROSE_ASSERT(this != NULL);
205449 1 : return "SgOmpAllocateStatement";
205450 : }
205451 :
205452 : // DQ (11/26/2005): Support for visitor pattern mechanims
205453 : // (inferior to ROSE traversal mechanism, experimental).
205454 : void
205455 0 : SgOmpAllocateStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
205456 : {
205457 0 : ROSE_ASSERT(this != NULL);
205458 0 : visitor.visit(this);
205459 0 : }
205460 :
205461 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
205462 0 : void SgOmpAllocateStatement::accept (ROSE_VisitorPattern & visitor) {
205463 0 : ROSE_ASSERT(this != NULL);
205464 0 : visitor.visit(this);
205465 0 : }
205466 :
205467 : SgOmpAllocateStatement*
205468 0 : SgOmpAllocateStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
205469 : {
205470 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
205471 : // This function is currently only supported for the AST used the represent Binary executables.
205472 : if (0 /* isSgAsmNode(this) != NULL */)
205473 : {
205474 : // Support for regex specification.
205475 : std::string prefixCode = "REGEX:";
205476 : addNewAttribute(prefixCode + s,a);
205477 : }
205478 : #endif
205479 :
205480 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
205481 0 : return this;
205482 : }
205483 :
205484 : // *** COMMON CODE SECTION ENDS HERE ***
205485 :
205486 :
205487 : // End of memberFunctionString
205488 : // Start of memberFunctionString
205489 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
205490 :
205491 :
205492 : #if 0
205493 : //! Error checking support
205494 : /*! Verifies the following:
205495 : - working getVariant() member function
205496 : - calls base class's error() member function
205497 : Every class has one of these functions.
205498 : */
205499 : bool
205500 : SgOmpAllocateStatement::error()
205501 : {
205502 : // Put error checking here
205503 :
205504 : ROSE_ASSERT (this != NULL);
205505 : if (getVariant() != OMP_ALLOCATE_STMT)
205506 : {
205507 : printf ("Error in SgOmpAllocateStatement::error(): SgOmpAllocateStatement object has a %s variant \n",
205508 : Cxx_GrammarTerminalNames[getVariant()].name);
205509 : // printf ("Error in SgOmpAllocateStatement::error() \n");
205510 : ROSE_ABORT();
205511 : }
205512 :
205513 : ROSE_ASSERT (getVariant() == OMP_ALLOCATE_STMT);
205514 : return SgUpirFieldStatement::error();
205515 : }
205516 : #endif
205517 :
205518 :
205519 :
205520 : // End of memberFunctionString
205521 :
205522 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
205523 :
205524 883 : SgOmpAllocateStatement* isSgOmpAllocateStatement ( SgNode* inputDerivedClassPointer )
205525 : {
205526 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
205527 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
205528 : // So to fix this we return NULL directly when the input is NULL and avoid the
205529 : // dynamic_cast in this case. This is likely a performance improvement as well.
205530 : // return dynamic_cast<SgOmpAllocateStatement*>(inputDerivedClassPointer);
205531 : // Milind Chabbi (8/28/2013): isSgOmpAllocateStatement uses table-driven castability instead of c++ default dynamic_cast
205532 : // this improves the running time performance by 10-20%.
205533 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpAllocateStatement*>(inputDerivedClassPointer);
205534 883 : return IS_SgOmpAllocateStatement_FAST_MACRO(inputDerivedClassPointer);
205535 : }
205536 :
205537 : // DQ (11/8/2003): Added version of functions taking const pointer
205538 0 : const SgOmpAllocateStatement* isSgOmpAllocateStatement ( const SgNode* inputDerivedClassPointer )
205539 : {
205540 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
205541 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
205542 : // So to fix this we return NULL directly when the input is NULL and avoid the
205543 : // dynamic_cast in this case. This is likely a performance improvement as well.
205544 : // return dynamic_cast<const SgOmpAllocateStatement*>(inputDerivedClassPointer);
205545 : // Milind Chabbi (8/28/2013): isSgOmpAllocateStatement uses table-driven castability instead of c++ default dynamic_cast
205546 : // this improves the running time performance by 10-20%.
205547 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpAllocateStatement*>(inputDerivedClassPointer);
205548 0 : return IS_SgOmpAllocateStatement_FAST_MACRO(inputDerivedClassPointer);
205549 : }
205550 :
205551 :
205552 :
205553 : /* #line 205554 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205554 :
205555 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205556 :
205557 : /**
205558 : \brief Generated destructor
205559 :
205560 : This destructor is automatically generated (by ROSETTA). This destructor
205561 : only frees memory of data members associated with the parts of the current IR node which
205562 : are NOT traversed. Those data members that are part of a traversal can be freed using
205563 : a traversal (calling this destructor on all children in a post-order traversal). Such
205564 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
205565 :
205566 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
205567 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
205568 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
205569 :
205570 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
205571 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
205572 : pointers are not yet implemented to call delete on eash pointer in the container.
205573 : (This could be done by derivation from the STL containers to define containers that
205574 : automatically deleted their members.)
205575 :
205576 : */
205577 0 : SgOmpAllocateStatement::~SgOmpAllocateStatement () {
205578 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
205579 :
205580 :
205581 :
205582 : }
205583 :
205584 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205585 0 : }
205586 :
205587 :
205588 : /* #line 205589 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205589 :
205590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
205591 :
205592 : // Generated constructor
205593 0 : SgOmpAllocateStatement::SgOmpAllocateStatement ( Sg_File_Info* startOfConstruct )
205594 0 : : SgUpirFieldStatement(startOfConstruct)
205595 : {
205596 : #ifdef DEBUG
205597 : // printf ("In SgOmpAllocateStatement::SgOmpAllocateStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
205598 : #endif
205599 : #if 0
205600 : // debugging information!
205601 : printf ("In SgOmpAllocateStatement::SgOmpAllocateStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
205602 : #endif
205603 :
205604 :
205605 :
205606 : #if 0
205607 : // DQ (7/30/2014): Call a virtual function.
205608 : std::string s = this->class_name();
205609 : #endif
205610 :
205611 : // Test the variant virtual function
205612 : // assert(OMP_ALLOCATE_STMT == variant());
205613 0 : assert(OMP_ALLOCATE_STMT == this->variant());
205614 0 : ROSE_ASSERT(OMP_ALLOCATE_STMT == (int)(this->variantT()));
205615 0 : post_construction_initialization();
205616 :
205617 : // Test the isSgOmpAllocateStatement() function since it has been problematic
205618 0 : assert(isSgOmpAllocateStatement(this) != NULL);
205619 0 : }
205620 :
205621 : // Generated constructor (all data members)
205622 :
205623 : /* #line 205624 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205624 :
205625 :
205626 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205627 :
205628 :
205629 : // ********************************************************
205630 : // member functions common across all array grammar objects
205631 : // ********************************************************
205632 :
205633 :
205634 :
205635 : /* #line 205636 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205636 :
205637 :
205638 :
205639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205640 :
205641 : // ********************************************************
205642 : // member functions specific to each node in the grammar
205643 : // ********************************************************
205644 :
205645 :
205646 : /* #line 205647 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205647 :
205648 : // Start of memberFunctionString
205649 : /* #line 19028 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
205650 :
205651 : void
205652 2 : SgOmpOrderedDependStatement::post_construction_initialization()
205653 2 : {}
205654 :
205655 :
205656 : // End of memberFunctionString
205657 : // Start of memberFunctionString
205658 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
205659 :
205660 : // *** COMMON CODE SECTION BEGINS HERE ***
205661 :
205662 : #if 0
205663 : int
205664 : SgOmpOrderedDependStatement::getVariant() const
205665 : {
205666 : // This function is used in ROSE while "variant()" is used in SAGE
205667 : assert(this != NULL);
205668 : return variant();
205669 : }
205670 : #endif
205671 :
205672 : // This function is used in ROSE in treeTraversal code
205673 : // eventually replaces getVariant() and variant()
205674 : // though after variant() has been removed for a while we will
205675 : // want to change the name of variantT() back to variant()
205676 : // (since the "T" was ment to stand for temporary).
205677 : // When this happens the variantT() will be depricated.
205678 : VariantT
205679 104 : SgOmpOrderedDependStatement::variantT() const
205680 : {
205681 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
205682 104 : ROSE_ASSERT(this != NULL);
205683 104 : return V_SgOmpOrderedDependStatement;
205684 : }
205685 :
205686 : #if 0
205687 : int
205688 : SgOmpOrderedDependStatement::variant() const
205689 : {
205690 : // This function is used in SAGE
205691 : ROSE_ASSERT(this != NULL);
205692 : return OMP_ORDERED_DEPEND_STMT;
205693 : }
205694 : #endif
205695 :
205696 : ROSE_DLL_API const char*
205697 0 : SgOmpOrderedDependStatement::sage_class_name() const
205698 : {
205699 0 : ROSE_ASSERT(this != NULL);
205700 0 : return "SgOmpOrderedDependStatement";
205701 : }
205702 :
205703 : std::string
205704 2 : SgOmpOrderedDependStatement::class_name() const
205705 : {
205706 2 : ROSE_ASSERT(this != NULL);
205707 2 : return "SgOmpOrderedDependStatement";
205708 : }
205709 :
205710 : // DQ (11/26/2005): Support for visitor pattern mechanims
205711 : // (inferior to ROSE traversal mechanism, experimental).
205712 : void
205713 0 : SgOmpOrderedDependStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
205714 : {
205715 0 : ROSE_ASSERT(this != NULL);
205716 0 : visitor.visit(this);
205717 0 : }
205718 :
205719 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
205720 0 : void SgOmpOrderedDependStatement::accept (ROSE_VisitorPattern & visitor) {
205721 0 : ROSE_ASSERT(this != NULL);
205722 0 : visitor.visit(this);
205723 0 : }
205724 :
205725 : SgOmpOrderedDependStatement*
205726 0 : SgOmpOrderedDependStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
205727 : {
205728 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
205729 : // This function is currently only supported for the AST used the represent Binary executables.
205730 : if (0 /* isSgAsmNode(this) != NULL */)
205731 : {
205732 : // Support for regex specification.
205733 : std::string prefixCode = "REGEX:";
205734 : addNewAttribute(prefixCode + s,a);
205735 : }
205736 : #endif
205737 :
205738 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
205739 0 : return this;
205740 : }
205741 :
205742 : // *** COMMON CODE SECTION ENDS HERE ***
205743 :
205744 :
205745 : // End of memberFunctionString
205746 : // Start of memberFunctionString
205747 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
205748 :
205749 :
205750 : #if 0
205751 : //! Error checking support
205752 : /*! Verifies the following:
205753 : - working getVariant() member function
205754 : - calls base class's error() member function
205755 : Every class has one of these functions.
205756 : */
205757 : bool
205758 : SgOmpOrderedDependStatement::error()
205759 : {
205760 : // Put error checking here
205761 :
205762 : ROSE_ASSERT (this != NULL);
205763 : if (getVariant() != OMP_ORDERED_DEPEND_STMT)
205764 : {
205765 : printf ("Error in SgOmpOrderedDependStatement::error(): SgOmpOrderedDependStatement object has a %s variant \n",
205766 : Cxx_GrammarTerminalNames[getVariant()].name);
205767 : // printf ("Error in SgOmpOrderedDependStatement::error() \n");
205768 : ROSE_ABORT();
205769 : }
205770 :
205771 : ROSE_ASSERT (getVariant() == OMP_ORDERED_DEPEND_STMT);
205772 : return SgUpirFieldStatement::error();
205773 : }
205774 : #endif
205775 :
205776 :
205777 :
205778 : // End of memberFunctionString
205779 :
205780 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
205781 :
205782 2 : SgOmpOrderedDependStatement* isSgOmpOrderedDependStatement ( SgNode* inputDerivedClassPointer )
205783 : {
205784 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
205785 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
205786 : // So to fix this we return NULL directly when the input is NULL and avoid the
205787 : // dynamic_cast in this case. This is likely a performance improvement as well.
205788 : // return dynamic_cast<SgOmpOrderedDependStatement*>(inputDerivedClassPointer);
205789 : // Milind Chabbi (8/28/2013): isSgOmpOrderedDependStatement uses table-driven castability instead of c++ default dynamic_cast
205790 : // this improves the running time performance by 10-20%.
205791 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpOrderedDependStatement*>(inputDerivedClassPointer);
205792 2 : return IS_SgOmpOrderedDependStatement_FAST_MACRO(inputDerivedClassPointer);
205793 : }
205794 :
205795 : // DQ (11/8/2003): Added version of functions taking const pointer
205796 0 : const SgOmpOrderedDependStatement* isSgOmpOrderedDependStatement ( const SgNode* inputDerivedClassPointer )
205797 : {
205798 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
205799 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
205800 : // So to fix this we return NULL directly when the input is NULL and avoid the
205801 : // dynamic_cast in this case. This is likely a performance improvement as well.
205802 : // return dynamic_cast<const SgOmpOrderedDependStatement*>(inputDerivedClassPointer);
205803 : // Milind Chabbi (8/28/2013): isSgOmpOrderedDependStatement uses table-driven castability instead of c++ default dynamic_cast
205804 : // this improves the running time performance by 10-20%.
205805 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpOrderedDependStatement*>(inputDerivedClassPointer);
205806 0 : return IS_SgOmpOrderedDependStatement_FAST_MACRO(inputDerivedClassPointer);
205807 : }
205808 :
205809 :
205810 :
205811 : /* #line 205812 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205812 :
205813 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205814 :
205815 : /**
205816 : \brief Generated destructor
205817 :
205818 : This destructor is automatically generated (by ROSETTA). This destructor
205819 : only frees memory of data members associated with the parts of the current IR node which
205820 : are NOT traversed. Those data members that are part of a traversal can be freed using
205821 : a traversal (calling this destructor on all children in a post-order traversal). Such
205822 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
205823 :
205824 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
205825 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
205826 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
205827 :
205828 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
205829 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
205830 : pointers are not yet implemented to call delete on eash pointer in the container.
205831 : (This could be done by derivation from the STL containers to define containers that
205832 : automatically deleted their members.)
205833 :
205834 : */
205835 0 : SgOmpOrderedDependStatement::~SgOmpOrderedDependStatement () {
205836 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
205837 :
205838 :
205839 :
205840 : }
205841 :
205842 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
205843 0 : }
205844 :
205845 :
205846 : /* #line 205847 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205847 :
205848 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
205849 :
205850 : // Generated constructor
205851 0 : SgOmpOrderedDependStatement::SgOmpOrderedDependStatement ( Sg_File_Info* startOfConstruct )
205852 0 : : SgUpirFieldStatement(startOfConstruct)
205853 : {
205854 : #ifdef DEBUG
205855 : // printf ("In SgOmpOrderedDependStatement::SgOmpOrderedDependStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
205856 : #endif
205857 : #if 0
205858 : // debugging information!
205859 : printf ("In SgOmpOrderedDependStatement::SgOmpOrderedDependStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
205860 : #endif
205861 :
205862 :
205863 :
205864 : #if 0
205865 : // DQ (7/30/2014): Call a virtual function.
205866 : std::string s = this->class_name();
205867 : #endif
205868 :
205869 : // Test the variant virtual function
205870 : // assert(OMP_ORDERED_DEPEND_STMT == variant());
205871 0 : assert(OMP_ORDERED_DEPEND_STMT == this->variant());
205872 0 : ROSE_ASSERT(OMP_ORDERED_DEPEND_STMT == (int)(this->variantT()));
205873 0 : post_construction_initialization();
205874 :
205875 : // Test the isSgOmpOrderedDependStatement() function since it has been problematic
205876 0 : assert(isSgOmpOrderedDependStatement(this) != NULL);
205877 0 : }
205878 :
205879 : // Generated constructor (all data members)
205880 :
205881 : /* #line 205882 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205882 :
205883 :
205884 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205885 :
205886 :
205887 : // ********************************************************
205888 : // member functions common across all array grammar objects
205889 : // ********************************************************
205890 :
205891 :
205892 :
205893 : /* #line 205894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205894 :
205895 :
205896 :
205897 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
205898 :
205899 : // ********************************************************
205900 : // member functions specific to each node in the grammar
205901 : // ********************************************************
205902 :
205903 :
205904 : /* #line 205905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
205905 :
205906 : // Start of memberFunctionString
205907 : /* #line 19016 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
205908 :
205909 : void
205910 0 : SgUpirSyncStatement::post_construction_initialization()
205911 0 : {}
205912 :
205913 :
205914 : // End of memberFunctionString
205915 : // Start of memberFunctionString
205916 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
205917 :
205918 : // *** COMMON CODE SECTION BEGINS HERE ***
205919 :
205920 : #if 0
205921 : int
205922 : SgUpirSyncStatement::getVariant() const
205923 : {
205924 : // This function is used in ROSE while "variant()" is used in SAGE
205925 : assert(this != NULL);
205926 : return variant();
205927 : }
205928 : #endif
205929 :
205930 : // This function is used in ROSE in treeTraversal code
205931 : // eventually replaces getVariant() and variant()
205932 : // though after variant() has been removed for a while we will
205933 : // want to change the name of variantT() back to variant()
205934 : // (since the "T" was ment to stand for temporary).
205935 : // When this happens the variantT() will be depricated.
205936 : VariantT
205937 0 : SgUpirSyncStatement::variantT() const
205938 : {
205939 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
205940 0 : ROSE_ASSERT(this != NULL);
205941 0 : return V_SgUpirSyncStatement;
205942 : }
205943 :
205944 : #if 0
205945 : int
205946 : SgUpirSyncStatement::variant() const
205947 : {
205948 : // This function is used in SAGE
205949 : ROSE_ASSERT(this != NULL);
205950 : return UPIR_SYNC_STMT;
205951 : }
205952 : #endif
205953 :
205954 : ROSE_DLL_API const char*
205955 0 : SgUpirSyncStatement::sage_class_name() const
205956 : {
205957 0 : ROSE_ASSERT(this != NULL);
205958 0 : return "SgUpirSyncStatement";
205959 : }
205960 :
205961 : std::string
205962 0 : SgUpirSyncStatement::class_name() const
205963 : {
205964 0 : ROSE_ASSERT(this != NULL);
205965 0 : return "SgUpirSyncStatement";
205966 : }
205967 :
205968 : // DQ (11/26/2005): Support for visitor pattern mechanims
205969 : // (inferior to ROSE traversal mechanism, experimental).
205970 : void
205971 0 : SgUpirSyncStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
205972 : {
205973 0 : ROSE_ASSERT(this != NULL);
205974 0 : visitor.visit(this);
205975 0 : }
205976 :
205977 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
205978 0 : void SgUpirSyncStatement::accept (ROSE_VisitorPattern & visitor) {
205979 0 : ROSE_ASSERT(this != NULL);
205980 0 : visitor.visit(this);
205981 0 : }
205982 :
205983 : SgUpirSyncStatement*
205984 0 : SgUpirSyncStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
205985 : {
205986 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
205987 : // This function is currently only supported for the AST used the represent Binary executables.
205988 : if (0 /* isSgAsmNode(this) != NULL */)
205989 : {
205990 : // Support for regex specification.
205991 : std::string prefixCode = "REGEX:";
205992 : addNewAttribute(prefixCode + s,a);
205993 : }
205994 : #endif
205995 :
205996 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
205997 0 : return this;
205998 : }
205999 :
206000 : // *** COMMON CODE SECTION ENDS HERE ***
206001 :
206002 :
206003 : // End of memberFunctionString
206004 : // Start of memberFunctionString
206005 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
206006 :
206007 :
206008 : #if 0
206009 : //! Error checking support
206010 : /*! Verifies the following:
206011 : - working getVariant() member function
206012 : - calls base class's error() member function
206013 : Every class has one of these functions.
206014 : */
206015 : bool
206016 : SgUpirSyncStatement::error()
206017 : {
206018 : // Put error checking here
206019 :
206020 : ROSE_ASSERT (this != NULL);
206021 : if (getVariant() != UPIR_SYNC_STMT)
206022 : {
206023 : printf ("Error in SgUpirSyncStatement::error(): SgUpirSyncStatement object has a %s variant \n",
206024 : Cxx_GrammarTerminalNames[getVariant()].name);
206025 : // printf ("Error in SgUpirSyncStatement::error() \n");
206026 : ROSE_ABORT();
206027 : }
206028 :
206029 : ROSE_ASSERT (getVariant() == UPIR_SYNC_STMT);
206030 : return SgUpirFieldStatement::error();
206031 : }
206032 : #endif
206033 :
206034 :
206035 :
206036 : // End of memberFunctionString
206037 :
206038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
206039 :
206040 0 : SgUpirSyncStatement* isSgUpirSyncStatement ( SgNode* inputDerivedClassPointer )
206041 : {
206042 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
206043 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
206044 : // So to fix this we return NULL directly when the input is NULL and avoid the
206045 : // dynamic_cast in this case. This is likely a performance improvement as well.
206046 : // return dynamic_cast<SgUpirSyncStatement*>(inputDerivedClassPointer);
206047 : // Milind Chabbi (8/28/2013): isSgUpirSyncStatement uses table-driven castability instead of c++ default dynamic_cast
206048 : // this improves the running time performance by 10-20%.
206049 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirSyncStatement*>(inputDerivedClassPointer);
206050 0 : return IS_SgUpirSyncStatement_FAST_MACRO(inputDerivedClassPointer);
206051 : }
206052 :
206053 : // DQ (11/8/2003): Added version of functions taking const pointer
206054 0 : const SgUpirSyncStatement* isSgUpirSyncStatement ( const SgNode* inputDerivedClassPointer )
206055 : {
206056 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
206057 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
206058 : // So to fix this we return NULL directly when the input is NULL and avoid the
206059 : // dynamic_cast in this case. This is likely a performance improvement as well.
206060 : // return dynamic_cast<const SgUpirSyncStatement*>(inputDerivedClassPointer);
206061 : // Milind Chabbi (8/28/2013): isSgUpirSyncStatement uses table-driven castability instead of c++ default dynamic_cast
206062 : // this improves the running time performance by 10-20%.
206063 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirSyncStatement*>(inputDerivedClassPointer);
206064 0 : return IS_SgUpirSyncStatement_FAST_MACRO(inputDerivedClassPointer);
206065 : }
206066 :
206067 :
206068 :
206069 : /* #line 206070 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206070 :
206071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
206072 :
206073 : /**
206074 : \brief Generated destructor
206075 :
206076 : This destructor is automatically generated (by ROSETTA). This destructor
206077 : only frees memory of data members associated with the parts of the current IR node which
206078 : are NOT traversed. Those data members that are part of a traversal can be freed using
206079 : a traversal (calling this destructor on all children in a post-order traversal). Such
206080 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
206081 :
206082 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
206083 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
206084 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
206085 :
206086 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
206087 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
206088 : pointers are not yet implemented to call delete on eash pointer in the container.
206089 : (This could be done by derivation from the STL containers to define containers that
206090 : automatically deleted their members.)
206091 :
206092 : */
206093 0 : SgUpirSyncStatement::~SgUpirSyncStatement () {
206094 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
206095 :
206096 :
206097 :
206098 : }
206099 :
206100 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
206101 0 : }
206102 :
206103 :
206104 : /* #line 206105 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206105 :
206106 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
206107 :
206108 : // Generated constructor
206109 0 : SgUpirSyncStatement::SgUpirSyncStatement ( Sg_File_Info* startOfConstruct )
206110 0 : : SgUpirFieldStatement(startOfConstruct)
206111 : {
206112 : #ifdef DEBUG
206113 : // printf ("In SgUpirSyncStatement::SgUpirSyncStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
206114 : #endif
206115 : #if 0
206116 : // debugging information!
206117 : printf ("In SgUpirSyncStatement::SgUpirSyncStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
206118 : #endif
206119 :
206120 :
206121 :
206122 : #if 0
206123 : // DQ (7/30/2014): Call a virtual function.
206124 : std::string s = this->class_name();
206125 : #endif
206126 :
206127 : // Test the variant virtual function
206128 : // assert(UPIR_SYNC_STMT == variant());
206129 0 : assert(UPIR_SYNC_STMT == this->variant());
206130 0 : ROSE_ASSERT(UPIR_SYNC_STMT == (int)(this->variantT()));
206131 0 : post_construction_initialization();
206132 :
206133 : // Test the isSgUpirSyncStatement() function since it has been problematic
206134 0 : assert(isSgUpirSyncStatement(this) != NULL);
206135 0 : }
206136 :
206137 : // Generated constructor (all data members)
206138 :
206139 : /* #line 206140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206140 :
206141 :
206142 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
206143 :
206144 :
206145 : // ********************************************************
206146 : // member functions common across all array grammar objects
206147 : // ********************************************************
206148 :
206149 :
206150 :
206151 : /* #line 206152 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206152 :
206153 :
206154 :
206155 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
206156 :
206157 : // ********************************************************
206158 : // member functions specific to each node in the grammar
206159 : // ********************************************************
206160 :
206161 :
206162 : /* #line 206163 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206163 :
206164 : // Start of memberFunctionString
206165 : /* #line 19003 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
206166 :
206167 : void
206168 199 : SgUpirLoopParallelStatement::post_construction_initialization()
206169 199 : {}
206170 :
206171 : bool
206172 0 : SgUpirLoopParallelStatement::replace_child(SgStatement *target,SgStatement *newstmt, bool extractBasicBlock)
206173 : {
206174 0 : SgStatement* upir_loop_body = ((SgUpirLoopStatement*)((SgUpirLoopParallelStatement*)this)->get_loop())->get_body();
206175 0 : return ( StatementReplace(this, upir_loop_body, target, newstmt) == true );
206176 : }
206177 :
206178 :
206179 : // End of memberFunctionString
206180 : // Start of memberFunctionString
206181 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
206182 :
206183 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
206184 :
206185 : SgStatement*
206186 199 : SgUpirLoopParallelStatement::get_worksharing () const
206187 : {
206188 199 : ROSE_ASSERT (this != NULL);
206189 :
206190 : #if 0
206191 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206192 : // used to trigger marking transformations for the token-based unparsing.
206193 : printf ("SgUpirLoopParallelStatement::get_worksharing = %p = %s \n",this,this->class_name().c_str());
206194 : #endif
206195 :
206196 199 : return p_worksharing;
206197 : }
206198 :
206199 : void
206200 185 : SgUpirLoopParallelStatement::set_worksharing ( SgStatement* worksharing )
206201 : {
206202 185 : ROSE_ASSERT (this != NULL);
206203 :
206204 : #if 0
206205 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206206 : // used to trigger marking transformations for the token-based unparsing.
206207 : printf ("SgUpirLoopParallelStatement::set_worksharing = %p = %s \n",this,this->class_name().c_str());
206208 : #endif
206209 :
206210 185 : set_isModified(true);
206211 :
206212 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
206213 : if (p_worksharing != NULL && worksharing != NULL && p_worksharing != worksharing)
206214 : {
206215 : printf ("Warning: worksharing = %p overwriting valid pointer p_worksharing = %p \n",worksharing,p_worksharing);
206216 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
206217 : printf ("Error fails assertion (p_worksharing != NULL && worksharing != NULL && p_worksharing != worksharing) is false\n");
206218 : ROSE_ASSERT(false);
206219 : #endif
206220 : }
206221 : #endif
206222 185 : p_worksharing = worksharing;
206223 185 : }
206224 :
206225 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
206226 :
206227 :
206228 : // End of memberFunctionString
206229 : // Start of memberFunctionString
206230 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
206231 :
206232 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
206233 :
206234 : SgStatement*
206235 14 : SgUpirLoopParallelStatement::get_simd () const
206236 : {
206237 14 : ROSE_ASSERT (this != NULL);
206238 :
206239 : #if 0
206240 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206241 : // used to trigger marking transformations for the token-based unparsing.
206242 : printf ("SgUpirLoopParallelStatement::get_simd = %p = %s \n",this,this->class_name().c_str());
206243 : #endif
206244 :
206245 14 : return p_simd;
206246 : }
206247 :
206248 : void
206249 14 : SgUpirLoopParallelStatement::set_simd ( SgStatement* simd )
206250 : {
206251 14 : ROSE_ASSERT (this != NULL);
206252 :
206253 : #if 0
206254 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206255 : // used to trigger marking transformations for the token-based unparsing.
206256 : printf ("SgUpirLoopParallelStatement::set_simd = %p = %s \n",this,this->class_name().c_str());
206257 : #endif
206258 :
206259 14 : set_isModified(true);
206260 :
206261 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
206262 : if (p_simd != NULL && simd != NULL && p_simd != simd)
206263 : {
206264 : printf ("Warning: simd = %p overwriting valid pointer p_simd = %p \n",simd,p_simd);
206265 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
206266 : printf ("Error fails assertion (p_simd != NULL && simd != NULL && p_simd != simd) is false\n");
206267 : ROSE_ASSERT(false);
206268 : #endif
206269 : }
206270 : #endif
206271 14 : p_simd = simd;
206272 14 : }
206273 :
206274 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
206275 :
206276 :
206277 : // End of memberFunctionString
206278 : // Start of memberFunctionString
206279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
206280 :
206281 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
206282 :
206283 : SgStatement*
206284 0 : SgUpirLoopParallelStatement::get_taskloop () const
206285 : {
206286 0 : ROSE_ASSERT (this != NULL);
206287 :
206288 : #if 0
206289 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206290 : // used to trigger marking transformations for the token-based unparsing.
206291 : printf ("SgUpirLoopParallelStatement::get_taskloop = %p = %s \n",this,this->class_name().c_str());
206292 : #endif
206293 :
206294 0 : return p_taskloop;
206295 : }
206296 :
206297 : void
206298 0 : SgUpirLoopParallelStatement::set_taskloop ( SgStatement* taskloop )
206299 : {
206300 0 : ROSE_ASSERT (this != NULL);
206301 :
206302 : #if 0
206303 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206304 : // used to trigger marking transformations for the token-based unparsing.
206305 : printf ("SgUpirLoopParallelStatement::set_taskloop = %p = %s \n",this,this->class_name().c_str());
206306 : #endif
206307 :
206308 0 : set_isModified(true);
206309 :
206310 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
206311 : if (p_taskloop != NULL && taskloop != NULL && p_taskloop != taskloop)
206312 : {
206313 : printf ("Warning: taskloop = %p overwriting valid pointer p_taskloop = %p \n",taskloop,p_taskloop);
206314 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
206315 : printf ("Error fails assertion (p_taskloop != NULL && taskloop != NULL && p_taskloop != taskloop) is false\n");
206316 : ROSE_ASSERT(false);
206317 : #endif
206318 : }
206319 : #endif
206320 0 : p_taskloop = taskloop;
206321 0 : }
206322 :
206323 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
206324 :
206325 :
206326 : // End of memberFunctionString
206327 : // Start of memberFunctionString
206328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
206329 :
206330 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
206331 :
206332 : SgStatement*
206333 199 : SgUpirLoopParallelStatement::get_loop () const
206334 : {
206335 199 : ROSE_ASSERT (this != NULL);
206336 :
206337 : #if 0
206338 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206339 : // used to trigger marking transformations for the token-based unparsing.
206340 : printf ("SgUpirLoopParallelStatement::get_loop = %p = %s \n",this,this->class_name().c_str());
206341 : #endif
206342 :
206343 199 : return p_loop;
206344 : }
206345 :
206346 : void
206347 199 : SgUpirLoopParallelStatement::set_loop ( SgStatement* loop )
206348 : {
206349 199 : ROSE_ASSERT (this != NULL);
206350 :
206351 : #if 0
206352 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
206353 : // used to trigger marking transformations for the token-based unparsing.
206354 : printf ("SgUpirLoopParallelStatement::set_loop = %p = %s \n",this,this->class_name().c_str());
206355 : #endif
206356 :
206357 199 : set_isModified(true);
206358 :
206359 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
206360 : if (p_loop != NULL && loop != NULL && p_loop != loop)
206361 : {
206362 : printf ("Warning: loop = %p overwriting valid pointer p_loop = %p \n",loop,p_loop);
206363 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
206364 : printf ("Error fails assertion (p_loop != NULL && loop != NULL && p_loop != loop) is false\n");
206365 : ROSE_ASSERT(false);
206366 : #endif
206367 : }
206368 : #endif
206369 199 : p_loop = loop;
206370 199 : }
206371 :
206372 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
206373 :
206374 :
206375 : // End of memberFunctionString
206376 : // Start of memberFunctionString
206377 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
206378 :
206379 : // *** COMMON CODE SECTION BEGINS HERE ***
206380 :
206381 : #if 0
206382 : int
206383 : SgUpirLoopParallelStatement::getVariant() const
206384 : {
206385 : // This function is used in ROSE while "variant()" is used in SAGE
206386 : assert(this != NULL);
206387 : return variant();
206388 : }
206389 : #endif
206390 :
206391 : // This function is used in ROSE in treeTraversal code
206392 : // eventually replaces getVariant() and variant()
206393 : // though after variant() has been removed for a while we will
206394 : // want to change the name of variantT() back to variant()
206395 : // (since the "T" was ment to stand for temporary).
206396 : // When this happens the variantT() will be depricated.
206397 : VariantT
206398 18837 : SgUpirLoopParallelStatement::variantT() const
206399 : {
206400 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
206401 18837 : ROSE_ASSERT(this != NULL);
206402 18837 : return V_SgUpirLoopParallelStatement;
206403 : }
206404 :
206405 : #if 0
206406 : int
206407 : SgUpirLoopParallelStatement::variant() const
206408 : {
206409 : // This function is used in SAGE
206410 : ROSE_ASSERT(this != NULL);
206411 : return UPIR_LOOP_PARALLEL_STMT;
206412 : }
206413 : #endif
206414 :
206415 : ROSE_DLL_API const char*
206416 0 : SgUpirLoopParallelStatement::sage_class_name() const
206417 : {
206418 0 : ROSE_ASSERT(this != NULL);
206419 0 : return "SgUpirLoopParallelStatement";
206420 : }
206421 :
206422 : std::string
206423 199 : SgUpirLoopParallelStatement::class_name() const
206424 : {
206425 199 : ROSE_ASSERT(this != NULL);
206426 199 : return "SgUpirLoopParallelStatement";
206427 : }
206428 :
206429 : // DQ (11/26/2005): Support for visitor pattern mechanims
206430 : // (inferior to ROSE traversal mechanism, experimental).
206431 : void
206432 0 : SgUpirLoopParallelStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
206433 : {
206434 0 : ROSE_ASSERT(this != NULL);
206435 0 : visitor.visit(this);
206436 0 : }
206437 :
206438 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
206439 0 : void SgUpirLoopParallelStatement::accept (ROSE_VisitorPattern & visitor) {
206440 0 : ROSE_ASSERT(this != NULL);
206441 0 : visitor.visit(this);
206442 0 : }
206443 :
206444 : SgUpirLoopParallelStatement*
206445 0 : SgUpirLoopParallelStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
206446 : {
206447 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
206448 : // This function is currently only supported for the AST used the represent Binary executables.
206449 : if (0 /* isSgAsmNode(this) != NULL */)
206450 : {
206451 : // Support for regex specification.
206452 : std::string prefixCode = "REGEX:";
206453 : addNewAttribute(prefixCode + s,a);
206454 : }
206455 : #endif
206456 :
206457 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
206458 0 : return this;
206459 : }
206460 :
206461 : // *** COMMON CODE SECTION ENDS HERE ***
206462 :
206463 :
206464 : // End of memberFunctionString
206465 : // Start of memberFunctionString
206466 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
206467 :
206468 :
206469 : #if 0
206470 : //! Error checking support
206471 : /*! Verifies the following:
206472 : - working getVariant() member function
206473 : - calls base class's error() member function
206474 : Every class has one of these functions.
206475 : */
206476 : bool
206477 : SgUpirLoopParallelStatement::error()
206478 : {
206479 : // Put error checking here
206480 :
206481 : ROSE_ASSERT (this != NULL);
206482 : if (getVariant() != UPIR_LOOP_PARALLEL_STMT)
206483 : {
206484 : printf ("Error in SgUpirLoopParallelStatement::error(): SgUpirLoopParallelStatement object has a %s variant \n",
206485 : Cxx_GrammarTerminalNames[getVariant()].name);
206486 : // printf ("Error in SgUpirLoopParallelStatement::error() \n");
206487 : ROSE_ABORT();
206488 : }
206489 :
206490 : ROSE_ASSERT (getVariant() == UPIR_LOOP_PARALLEL_STMT);
206491 : return SgUpirFieldStatement::error();
206492 : }
206493 : #endif
206494 :
206495 :
206496 :
206497 : // End of memberFunctionString
206498 :
206499 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
206500 :
206501 597 : SgUpirLoopParallelStatement* isSgUpirLoopParallelStatement ( SgNode* inputDerivedClassPointer )
206502 : {
206503 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
206504 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
206505 : // So to fix this we return NULL directly when the input is NULL and avoid the
206506 : // dynamic_cast in this case. This is likely a performance improvement as well.
206507 : // return dynamic_cast<SgUpirLoopParallelStatement*>(inputDerivedClassPointer);
206508 : // Milind Chabbi (8/28/2013): isSgUpirLoopParallelStatement uses table-driven castability instead of c++ default dynamic_cast
206509 : // this improves the running time performance by 10-20%.
206510 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirLoopParallelStatement*>(inputDerivedClassPointer);
206511 597 : return IS_SgUpirLoopParallelStatement_FAST_MACRO(inputDerivedClassPointer);
206512 : }
206513 :
206514 : // DQ (11/8/2003): Added version of functions taking const pointer
206515 0 : const SgUpirLoopParallelStatement* isSgUpirLoopParallelStatement ( const SgNode* inputDerivedClassPointer )
206516 : {
206517 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
206518 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
206519 : // So to fix this we return NULL directly when the input is NULL and avoid the
206520 : // dynamic_cast in this case. This is likely a performance improvement as well.
206521 : // return dynamic_cast<const SgUpirLoopParallelStatement*>(inputDerivedClassPointer);
206522 : // Milind Chabbi (8/28/2013): isSgUpirLoopParallelStatement uses table-driven castability instead of c++ default dynamic_cast
206523 : // this improves the running time performance by 10-20%.
206524 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirLoopParallelStatement*>(inputDerivedClassPointer);
206525 0 : return IS_SgUpirLoopParallelStatement_FAST_MACRO(inputDerivedClassPointer);
206526 : }
206527 :
206528 :
206529 :
206530 : /* #line 206531 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206531 :
206532 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
206533 :
206534 : /**
206535 : \brief Generated destructor
206536 :
206537 : This destructor is automatically generated (by ROSETTA). This destructor
206538 : only frees memory of data members associated with the parts of the current IR node which
206539 : are NOT traversed. Those data members that are part of a traversal can be freed using
206540 : a traversal (calling this destructor on all children in a post-order traversal). Such
206541 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
206542 :
206543 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
206544 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
206545 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
206546 :
206547 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
206548 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
206549 : pointers are not yet implemented to call delete on eash pointer in the container.
206550 : (This could be done by derivation from the STL containers to define containers that
206551 : automatically deleted their members.)
206552 :
206553 : */
206554 0 : SgUpirLoopParallelStatement::~SgUpirLoopParallelStatement () {
206555 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
206556 :
206557 :
206558 : // case: not a listType for worksharing
206559 0 : p_worksharing = NULL; // non list case
206560 : // case: not a listType for simd
206561 0 : p_simd = NULL; // non list case
206562 : // case: not a listType for taskloop
206563 0 : p_taskloop = NULL; // non list case
206564 : // case: not a listType for loop
206565 0 : p_loop = NULL; // non list case
206566 :
206567 : }
206568 :
206569 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
206570 0 : }
206571 :
206572 :
206573 : /* #line 206574 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206574 :
206575 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
206576 :
206577 : // Generated constructor
206578 199 : SgUpirLoopParallelStatement::SgUpirLoopParallelStatement ( Sg_File_Info* startOfConstruct )
206579 199 : : SgUpirFieldStatement(startOfConstruct)
206580 : {
206581 : #ifdef DEBUG
206582 : // printf ("In SgUpirLoopParallelStatement::SgUpirLoopParallelStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
206583 : #endif
206584 : #if 0
206585 : // debugging information!
206586 : printf ("In SgUpirLoopParallelStatement::SgUpirLoopParallelStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
206587 : #endif
206588 :
206589 199 : p_worksharing = NULL;
206590 199 : p_simd = NULL;
206591 199 : p_taskloop = NULL;
206592 199 : p_loop = NULL;
206593 :
206594 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
206595 :
206596 : #if 0
206597 : // DQ (7/30/2014): Call a virtual function.
206598 : std::string s = this->class_name();
206599 : #endif
206600 :
206601 : // Test the variant virtual function
206602 : // assert(UPIR_LOOP_PARALLEL_STMT == variant());
206603 199 : assert(UPIR_LOOP_PARALLEL_STMT == this->variant());
206604 199 : ROSE_ASSERT(UPIR_LOOP_PARALLEL_STMT == (int)(this->variantT()));
206605 199 : post_construction_initialization();
206606 :
206607 : // Test the isSgUpirLoopParallelStatement() function since it has been problematic
206608 199 : assert(isSgUpirLoopParallelStatement(this) != NULL);
206609 199 : }
206610 :
206611 : // Generated constructor (all data members)
206612 :
206613 : /* #line 206614 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206614 :
206615 :
206616 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
206617 :
206618 :
206619 : // ********************************************************
206620 : // member functions common across all array grammar objects
206621 : // ********************************************************
206622 :
206623 :
206624 :
206625 : /* #line 206626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206626 :
206627 :
206628 :
206629 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
206630 :
206631 : // ********************************************************
206632 : // member functions specific to each node in the grammar
206633 : // ********************************************************
206634 :
206635 :
206636 : /* #line 206637 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206637 :
206638 : // Start of memberFunctionString
206639 : /* #line 19461 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
206640 :
206641 : void
206642 185 : SgUpirWorksharingStatement::post_construction_initialization()
206643 185 : {}
206644 :
206645 :
206646 : // End of memberFunctionString
206647 : // Start of memberFunctionString
206648 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
206649 :
206650 : // *** COMMON CODE SECTION BEGINS HERE ***
206651 :
206652 : #if 0
206653 : int
206654 : SgUpirWorksharingStatement::getVariant() const
206655 : {
206656 : // This function is used in ROSE while "variant()" is used in SAGE
206657 : assert(this != NULL);
206658 : return variant();
206659 : }
206660 : #endif
206661 :
206662 : // This function is used in ROSE in treeTraversal code
206663 : // eventually replaces getVariant() and variant()
206664 : // though after variant() has been removed for a while we will
206665 : // want to change the name of variantT() back to variant()
206666 : // (since the "T" was ment to stand for temporary).
206667 : // When this happens the variantT() will be depricated.
206668 : VariantT
206669 4625 : SgUpirWorksharingStatement::variantT() const
206670 : {
206671 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
206672 4625 : ROSE_ASSERT(this != NULL);
206673 4625 : return V_SgUpirWorksharingStatement;
206674 : }
206675 :
206676 : #if 0
206677 : int
206678 : SgUpirWorksharingStatement::variant() const
206679 : {
206680 : // This function is used in SAGE
206681 : ROSE_ASSERT(this != NULL);
206682 : return UPIR_WORKSHARING_STMT;
206683 : }
206684 : #endif
206685 :
206686 : ROSE_DLL_API const char*
206687 0 : SgUpirWorksharingStatement::sage_class_name() const
206688 : {
206689 0 : ROSE_ASSERT(this != NULL);
206690 0 : return "SgUpirWorksharingStatement";
206691 : }
206692 :
206693 : std::string
206694 185 : SgUpirWorksharingStatement::class_name() const
206695 : {
206696 185 : ROSE_ASSERT(this != NULL);
206697 185 : return "SgUpirWorksharingStatement";
206698 : }
206699 :
206700 : // DQ (11/26/2005): Support for visitor pattern mechanims
206701 : // (inferior to ROSE traversal mechanism, experimental).
206702 : void
206703 0 : SgUpirWorksharingStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
206704 : {
206705 0 : ROSE_ASSERT(this != NULL);
206706 0 : visitor.visit(this);
206707 0 : }
206708 :
206709 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
206710 0 : void SgUpirWorksharingStatement::accept (ROSE_VisitorPattern & visitor) {
206711 0 : ROSE_ASSERT(this != NULL);
206712 0 : visitor.visit(this);
206713 0 : }
206714 :
206715 : SgUpirWorksharingStatement*
206716 0 : SgUpirWorksharingStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
206717 : {
206718 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
206719 : // This function is currently only supported for the AST used the represent Binary executables.
206720 : if (0 /* isSgAsmNode(this) != NULL */)
206721 : {
206722 : // Support for regex specification.
206723 : std::string prefixCode = "REGEX:";
206724 : addNewAttribute(prefixCode + s,a);
206725 : }
206726 : #endif
206727 :
206728 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
206729 0 : return this;
206730 : }
206731 :
206732 : // *** COMMON CODE SECTION ENDS HERE ***
206733 :
206734 :
206735 : // End of memberFunctionString
206736 : // Start of memberFunctionString
206737 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
206738 :
206739 :
206740 : #if 0
206741 : //! Error checking support
206742 : /*! Verifies the following:
206743 : - working getVariant() member function
206744 : - calls base class's error() member function
206745 : Every class has one of these functions.
206746 : */
206747 : bool
206748 : SgUpirWorksharingStatement::error()
206749 : {
206750 : // Put error checking here
206751 :
206752 : ROSE_ASSERT (this != NULL);
206753 : if (getVariant() != UPIR_WORKSHARING_STMT)
206754 : {
206755 : printf ("Error in SgUpirWorksharingStatement::error(): SgUpirWorksharingStatement object has a %s variant \n",
206756 : Cxx_GrammarTerminalNames[getVariant()].name);
206757 : // printf ("Error in SgUpirWorksharingStatement::error() \n");
206758 : ROSE_ABORT();
206759 : }
206760 :
206761 : ROSE_ASSERT (getVariant() == UPIR_WORKSHARING_STMT);
206762 : return SgUpirFieldStatement::error();
206763 : }
206764 : #endif
206765 :
206766 :
206767 :
206768 : // End of memberFunctionString
206769 :
206770 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
206771 :
206772 185 : SgUpirWorksharingStatement* isSgUpirWorksharingStatement ( SgNode* inputDerivedClassPointer )
206773 : {
206774 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
206775 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
206776 : // So to fix this we return NULL directly when the input is NULL and avoid the
206777 : // dynamic_cast in this case. This is likely a performance improvement as well.
206778 : // return dynamic_cast<SgUpirWorksharingStatement*>(inputDerivedClassPointer);
206779 : // Milind Chabbi (8/28/2013): isSgUpirWorksharingStatement uses table-driven castability instead of c++ default dynamic_cast
206780 : // this improves the running time performance by 10-20%.
206781 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirWorksharingStatement*>(inputDerivedClassPointer);
206782 185 : return IS_SgUpirWorksharingStatement_FAST_MACRO(inputDerivedClassPointer);
206783 : }
206784 :
206785 : // DQ (11/8/2003): Added version of functions taking const pointer
206786 0 : const SgUpirWorksharingStatement* isSgUpirWorksharingStatement ( const SgNode* inputDerivedClassPointer )
206787 : {
206788 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
206789 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
206790 : // So to fix this we return NULL directly when the input is NULL and avoid the
206791 : // dynamic_cast in this case. This is likely a performance improvement as well.
206792 : // return dynamic_cast<const SgUpirWorksharingStatement*>(inputDerivedClassPointer);
206793 : // Milind Chabbi (8/28/2013): isSgUpirWorksharingStatement uses table-driven castability instead of c++ default dynamic_cast
206794 : // this improves the running time performance by 10-20%.
206795 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirWorksharingStatement*>(inputDerivedClassPointer);
206796 0 : return IS_SgUpirWorksharingStatement_FAST_MACRO(inputDerivedClassPointer);
206797 : }
206798 :
206799 :
206800 :
206801 : /* #line 206802 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206802 :
206803 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
206804 :
206805 : /**
206806 : \brief Generated destructor
206807 :
206808 : This destructor is automatically generated (by ROSETTA). This destructor
206809 : only frees memory of data members associated with the parts of the current IR node which
206810 : are NOT traversed. Those data members that are part of a traversal can be freed using
206811 : a traversal (calling this destructor on all children in a post-order traversal). Such
206812 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
206813 :
206814 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
206815 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
206816 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
206817 :
206818 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
206819 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
206820 : pointers are not yet implemented to call delete on eash pointer in the container.
206821 : (This could be done by derivation from the STL containers to define containers that
206822 : automatically deleted their members.)
206823 :
206824 : */
206825 0 : SgUpirWorksharingStatement::~SgUpirWorksharingStatement () {
206826 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
206827 :
206828 :
206829 :
206830 : }
206831 :
206832 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
206833 0 : }
206834 :
206835 :
206836 : /* #line 206837 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206837 :
206838 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
206839 :
206840 : // Generated constructor
206841 185 : SgUpirWorksharingStatement::SgUpirWorksharingStatement ( Sg_File_Info* startOfConstruct )
206842 185 : : SgUpirFieldStatement(startOfConstruct)
206843 : {
206844 : #ifdef DEBUG
206845 : // printf ("In SgUpirWorksharingStatement::SgUpirWorksharingStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
206846 : #endif
206847 : #if 0
206848 : // debugging information!
206849 : printf ("In SgUpirWorksharingStatement::SgUpirWorksharingStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
206850 : #endif
206851 :
206852 :
206853 :
206854 : #if 0
206855 : // DQ (7/30/2014): Call a virtual function.
206856 : std::string s = this->class_name();
206857 : #endif
206858 :
206859 : // Test the variant virtual function
206860 : // assert(UPIR_WORKSHARING_STMT == variant());
206861 185 : assert(UPIR_WORKSHARING_STMT == this->variant());
206862 185 : ROSE_ASSERT(UPIR_WORKSHARING_STMT == (int)(this->variantT()));
206863 185 : post_construction_initialization();
206864 :
206865 : // Test the isSgUpirWorksharingStatement() function since it has been problematic
206866 185 : assert(isSgUpirWorksharingStatement(this) != NULL);
206867 185 : }
206868 :
206869 : // Generated constructor (all data members)
206870 :
206871 : /* #line 206872 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206872 :
206873 :
206874 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
206875 :
206876 :
206877 : // ********************************************************
206878 : // member functions common across all array grammar objects
206879 : // ********************************************************
206880 :
206881 :
206882 :
206883 : /* #line 206884 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206884 :
206885 :
206886 :
206887 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
206888 :
206889 : // ********************************************************
206890 : // member functions specific to each node in the grammar
206891 : // ********************************************************
206892 :
206893 :
206894 : /* #line 206895 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
206895 :
206896 : // Start of memberFunctionString
206897 : /* #line 19573 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
206898 :
206899 : void
206900 14 : SgUpirSimdStatement::post_construction_initialization()
206901 14 : {}
206902 :
206903 :
206904 : // End of memberFunctionString
206905 : // Start of memberFunctionString
206906 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
206907 :
206908 : // *** COMMON CODE SECTION BEGINS HERE ***
206909 :
206910 : #if 0
206911 : int
206912 : SgUpirSimdStatement::getVariant() const
206913 : {
206914 : // This function is used in ROSE while "variant()" is used in SAGE
206915 : assert(this != NULL);
206916 : return variant();
206917 : }
206918 : #endif
206919 :
206920 : // This function is used in ROSE in treeTraversal code
206921 : // eventually replaces getVariant() and variant()
206922 : // though after variant() has been removed for a while we will
206923 : // want to change the name of variantT() back to variant()
206924 : // (since the "T" was ment to stand for temporary).
206925 : // When this happens the variantT() will be depricated.
206926 : VariantT
206927 350 : SgUpirSimdStatement::variantT() const
206928 : {
206929 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
206930 350 : ROSE_ASSERT(this != NULL);
206931 350 : return V_SgUpirSimdStatement;
206932 : }
206933 :
206934 : #if 0
206935 : int
206936 : SgUpirSimdStatement::variant() const
206937 : {
206938 : // This function is used in SAGE
206939 : ROSE_ASSERT(this != NULL);
206940 : return UPIR_SIMD_STMT;
206941 : }
206942 : #endif
206943 :
206944 : ROSE_DLL_API const char*
206945 0 : SgUpirSimdStatement::sage_class_name() const
206946 : {
206947 0 : ROSE_ASSERT(this != NULL);
206948 0 : return "SgUpirSimdStatement";
206949 : }
206950 :
206951 : std::string
206952 14 : SgUpirSimdStatement::class_name() const
206953 : {
206954 14 : ROSE_ASSERT(this != NULL);
206955 14 : return "SgUpirSimdStatement";
206956 : }
206957 :
206958 : // DQ (11/26/2005): Support for visitor pattern mechanims
206959 : // (inferior to ROSE traversal mechanism, experimental).
206960 : void
206961 0 : SgUpirSimdStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
206962 : {
206963 0 : ROSE_ASSERT(this != NULL);
206964 0 : visitor.visit(this);
206965 0 : }
206966 :
206967 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
206968 0 : void SgUpirSimdStatement::accept (ROSE_VisitorPattern & visitor) {
206969 0 : ROSE_ASSERT(this != NULL);
206970 0 : visitor.visit(this);
206971 0 : }
206972 :
206973 : SgUpirSimdStatement*
206974 0 : SgUpirSimdStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
206975 : {
206976 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
206977 : // This function is currently only supported for the AST used the represent Binary executables.
206978 : if (0 /* isSgAsmNode(this) != NULL */)
206979 : {
206980 : // Support for regex specification.
206981 : std::string prefixCode = "REGEX:";
206982 : addNewAttribute(prefixCode + s,a);
206983 : }
206984 : #endif
206985 :
206986 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
206987 0 : return this;
206988 : }
206989 :
206990 : // *** COMMON CODE SECTION ENDS HERE ***
206991 :
206992 :
206993 : // End of memberFunctionString
206994 : // Start of memberFunctionString
206995 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
206996 :
206997 :
206998 : #if 0
206999 : //! Error checking support
207000 : /*! Verifies the following:
207001 : - working getVariant() member function
207002 : - calls base class's error() member function
207003 : Every class has one of these functions.
207004 : */
207005 : bool
207006 : SgUpirSimdStatement::error()
207007 : {
207008 : // Put error checking here
207009 :
207010 : ROSE_ASSERT (this != NULL);
207011 : if (getVariant() != UPIR_SIMD_STMT)
207012 : {
207013 : printf ("Error in SgUpirSimdStatement::error(): SgUpirSimdStatement object has a %s variant \n",
207014 : Cxx_GrammarTerminalNames[getVariant()].name);
207015 : // printf ("Error in SgUpirSimdStatement::error() \n");
207016 : ROSE_ABORT();
207017 : }
207018 :
207019 : ROSE_ASSERT (getVariant() == UPIR_SIMD_STMT);
207020 : return SgUpirFieldStatement::error();
207021 : }
207022 : #endif
207023 :
207024 :
207025 :
207026 : // End of memberFunctionString
207027 :
207028 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
207029 :
207030 14 : SgUpirSimdStatement* isSgUpirSimdStatement ( SgNode* inputDerivedClassPointer )
207031 : {
207032 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207033 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207034 : // So to fix this we return NULL directly when the input is NULL and avoid the
207035 : // dynamic_cast in this case. This is likely a performance improvement as well.
207036 : // return dynamic_cast<SgUpirSimdStatement*>(inputDerivedClassPointer);
207037 : // Milind Chabbi (8/28/2013): isSgUpirSimdStatement uses table-driven castability instead of c++ default dynamic_cast
207038 : // this improves the running time performance by 10-20%.
207039 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpirSimdStatement*>(inputDerivedClassPointer);
207040 14 : return IS_SgUpirSimdStatement_FAST_MACRO(inputDerivedClassPointer);
207041 : }
207042 :
207043 : // DQ (11/8/2003): Added version of functions taking const pointer
207044 0 : const SgUpirSimdStatement* isSgUpirSimdStatement ( const SgNode* inputDerivedClassPointer )
207045 : {
207046 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207047 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207048 : // So to fix this we return NULL directly when the input is NULL and avoid the
207049 : // dynamic_cast in this case. This is likely a performance improvement as well.
207050 : // return dynamic_cast<const SgUpirSimdStatement*>(inputDerivedClassPointer);
207051 : // Milind Chabbi (8/28/2013): isSgUpirSimdStatement uses table-driven castability instead of c++ default dynamic_cast
207052 : // this improves the running time performance by 10-20%.
207053 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpirSimdStatement*>(inputDerivedClassPointer);
207054 0 : return IS_SgUpirSimdStatement_FAST_MACRO(inputDerivedClassPointer);
207055 : }
207056 :
207057 :
207058 :
207059 : /* #line 207060 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207060 :
207061 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207062 :
207063 : /**
207064 : \brief Generated destructor
207065 :
207066 : This destructor is automatically generated (by ROSETTA). This destructor
207067 : only frees memory of data members associated with the parts of the current IR node which
207068 : are NOT traversed. Those data members that are part of a traversal can be freed using
207069 : a traversal (calling this destructor on all children in a post-order traversal). Such
207070 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
207071 :
207072 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
207073 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
207074 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
207075 :
207076 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
207077 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
207078 : pointers are not yet implemented to call delete on eash pointer in the container.
207079 : (This could be done by derivation from the STL containers to define containers that
207080 : automatically deleted their members.)
207081 :
207082 : */
207083 0 : SgUpirSimdStatement::~SgUpirSimdStatement () {
207084 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
207085 :
207086 :
207087 :
207088 : }
207089 :
207090 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207091 0 : }
207092 :
207093 :
207094 : /* #line 207095 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207095 :
207096 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
207097 :
207098 : // Generated constructor
207099 14 : SgUpirSimdStatement::SgUpirSimdStatement ( Sg_File_Info* startOfConstruct )
207100 14 : : SgUpirFieldStatement(startOfConstruct)
207101 : {
207102 : #ifdef DEBUG
207103 : // printf ("In SgUpirSimdStatement::SgUpirSimdStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
207104 : #endif
207105 : #if 0
207106 : // debugging information!
207107 : printf ("In SgUpirSimdStatement::SgUpirSimdStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
207108 : #endif
207109 :
207110 :
207111 :
207112 : #if 0
207113 : // DQ (7/30/2014): Call a virtual function.
207114 : std::string s = this->class_name();
207115 : #endif
207116 :
207117 : // Test the variant virtual function
207118 : // assert(UPIR_SIMD_STMT == variant());
207119 14 : assert(UPIR_SIMD_STMT == this->variant());
207120 14 : ROSE_ASSERT(UPIR_SIMD_STMT == (int)(this->variantT()));
207121 14 : post_construction_initialization();
207122 :
207123 : // Test the isSgUpirSimdStatement() function since it has been problematic
207124 14 : assert(isSgUpirSimdStatement(this) != NULL);
207125 14 : }
207126 :
207127 : // Generated constructor (all data members)
207128 :
207129 : /* #line 207130 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207130 :
207131 :
207132 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
207133 :
207134 :
207135 : // ********************************************************
207136 : // member functions common across all array grammar objects
207137 : // ********************************************************
207138 :
207139 :
207140 :
207141 : /* #line 207142 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207142 :
207143 :
207144 :
207145 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
207146 :
207147 : // ********************************************************
207148 : // member functions specific to each node in the grammar
207149 : // ********************************************************
207150 :
207151 :
207152 : /* #line 207153 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207153 :
207154 : // Start of memberFunctionString
207155 : /* #line 19034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
207156 :
207157 : void
207158 0 : SgOmpDeclareMapperStatement::post_construction_initialization()
207159 0 : {}
207160 :
207161 :
207162 : // End of memberFunctionString
207163 : // Start of memberFunctionString
207164 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
207165 :
207166 : // *** COMMON CODE SECTION BEGINS HERE ***
207167 :
207168 : #if 0
207169 : int
207170 : SgOmpDeclareMapperStatement::getVariant() const
207171 : {
207172 : // This function is used in ROSE while "variant()" is used in SAGE
207173 : assert(this != NULL);
207174 : return variant();
207175 : }
207176 : #endif
207177 :
207178 : // This function is used in ROSE in treeTraversal code
207179 : // eventually replaces getVariant() and variant()
207180 : // though after variant() has been removed for a while we will
207181 : // want to change the name of variantT() back to variant()
207182 : // (since the "T" was ment to stand for temporary).
207183 : // When this happens the variantT() will be depricated.
207184 : VariantT
207185 0 : SgOmpDeclareMapperStatement::variantT() const
207186 : {
207187 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
207188 0 : ROSE_ASSERT(this != NULL);
207189 0 : return V_SgOmpDeclareMapperStatement;
207190 : }
207191 :
207192 : #if 0
207193 : int
207194 : SgOmpDeclareMapperStatement::variant() const
207195 : {
207196 : // This function is used in SAGE
207197 : ROSE_ASSERT(this != NULL);
207198 : return OMP_DECLARE_MAPPER_STMT;
207199 : }
207200 : #endif
207201 :
207202 : ROSE_DLL_API const char*
207203 0 : SgOmpDeclareMapperStatement::sage_class_name() const
207204 : {
207205 0 : ROSE_ASSERT(this != NULL);
207206 0 : return "SgOmpDeclareMapperStatement";
207207 : }
207208 :
207209 : std::string
207210 0 : SgOmpDeclareMapperStatement::class_name() const
207211 : {
207212 0 : ROSE_ASSERT(this != NULL);
207213 0 : return "SgOmpDeclareMapperStatement";
207214 : }
207215 :
207216 : // DQ (11/26/2005): Support for visitor pattern mechanims
207217 : // (inferior to ROSE traversal mechanism, experimental).
207218 : void
207219 0 : SgOmpDeclareMapperStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
207220 : {
207221 0 : ROSE_ASSERT(this != NULL);
207222 0 : visitor.visit(this);
207223 0 : }
207224 :
207225 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
207226 0 : void SgOmpDeclareMapperStatement::accept (ROSE_VisitorPattern & visitor) {
207227 0 : ROSE_ASSERT(this != NULL);
207228 0 : visitor.visit(this);
207229 0 : }
207230 :
207231 : SgOmpDeclareMapperStatement*
207232 0 : SgOmpDeclareMapperStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
207233 : {
207234 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
207235 : // This function is currently only supported for the AST used the represent Binary executables.
207236 : if (0 /* isSgAsmNode(this) != NULL */)
207237 : {
207238 : // Support for regex specification.
207239 : std::string prefixCode = "REGEX:";
207240 : addNewAttribute(prefixCode + s,a);
207241 : }
207242 : #endif
207243 :
207244 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
207245 0 : return this;
207246 : }
207247 :
207248 : // *** COMMON CODE SECTION ENDS HERE ***
207249 :
207250 :
207251 : // End of memberFunctionString
207252 : // Start of memberFunctionString
207253 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
207254 :
207255 :
207256 : #if 0
207257 : //! Error checking support
207258 : /*! Verifies the following:
207259 : - working getVariant() member function
207260 : - calls base class's error() member function
207261 : Every class has one of these functions.
207262 : */
207263 : bool
207264 : SgOmpDeclareMapperStatement::error()
207265 : {
207266 : // Put error checking here
207267 :
207268 : ROSE_ASSERT (this != NULL);
207269 : if (getVariant() != OMP_DECLARE_MAPPER_STMT)
207270 : {
207271 : printf ("Error in SgOmpDeclareMapperStatement::error(): SgOmpDeclareMapperStatement object has a %s variant \n",
207272 : Cxx_GrammarTerminalNames[getVariant()].name);
207273 : // printf ("Error in SgOmpDeclareMapperStatement::error() \n");
207274 : ROSE_ABORT();
207275 : }
207276 :
207277 : ROSE_ASSERT (getVariant() == OMP_DECLARE_MAPPER_STMT);
207278 : return SgUpirBaseStatement::error();
207279 : }
207280 : #endif
207281 :
207282 :
207283 :
207284 : // End of memberFunctionString
207285 :
207286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
207287 :
207288 0 : SgOmpDeclareMapperStatement* isSgOmpDeclareMapperStatement ( SgNode* inputDerivedClassPointer )
207289 : {
207290 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207291 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207292 : // So to fix this we return NULL directly when the input is NULL and avoid the
207293 : // dynamic_cast in this case. This is likely a performance improvement as well.
207294 : // return dynamic_cast<SgOmpDeclareMapperStatement*>(inputDerivedClassPointer);
207295 : // Milind Chabbi (8/28/2013): isSgOmpDeclareMapperStatement uses table-driven castability instead of c++ default dynamic_cast
207296 : // this improves the running time performance by 10-20%.
207297 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOmpDeclareMapperStatement*>(inputDerivedClassPointer);
207298 0 : return IS_SgOmpDeclareMapperStatement_FAST_MACRO(inputDerivedClassPointer);
207299 : }
207300 :
207301 : // DQ (11/8/2003): Added version of functions taking const pointer
207302 0 : const SgOmpDeclareMapperStatement* isSgOmpDeclareMapperStatement ( const SgNode* inputDerivedClassPointer )
207303 : {
207304 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207305 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207306 : // So to fix this we return NULL directly when the input is NULL and avoid the
207307 : // dynamic_cast in this case. This is likely a performance improvement as well.
207308 : // return dynamic_cast<const SgOmpDeclareMapperStatement*>(inputDerivedClassPointer);
207309 : // Milind Chabbi (8/28/2013): isSgOmpDeclareMapperStatement uses table-driven castability instead of c++ default dynamic_cast
207310 : // this improves the running time performance by 10-20%.
207311 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOmpDeclareMapperStatement*>(inputDerivedClassPointer);
207312 0 : return IS_SgOmpDeclareMapperStatement_FAST_MACRO(inputDerivedClassPointer);
207313 : }
207314 :
207315 :
207316 :
207317 : /* #line 207318 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207318 :
207319 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207320 :
207321 : /**
207322 : \brief Generated destructor
207323 :
207324 : This destructor is automatically generated (by ROSETTA). This destructor
207325 : only frees memory of data members associated with the parts of the current IR node which
207326 : are NOT traversed. Those data members that are part of a traversal can be freed using
207327 : a traversal (calling this destructor on all children in a post-order traversal). Such
207328 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
207329 :
207330 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
207331 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
207332 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
207333 :
207334 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
207335 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
207336 : pointers are not yet implemented to call delete on eash pointer in the container.
207337 : (This could be done by derivation from the STL containers to define containers that
207338 : automatically deleted their members.)
207339 :
207340 : */
207341 0 : SgOmpDeclareMapperStatement::~SgOmpDeclareMapperStatement () {
207342 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
207343 :
207344 :
207345 :
207346 : }
207347 :
207348 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207349 0 : }
207350 :
207351 :
207352 : /* #line 207353 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207353 :
207354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
207355 :
207356 : // Generated constructor
207357 0 : SgOmpDeclareMapperStatement::SgOmpDeclareMapperStatement ( Sg_File_Info* startOfConstruct )
207358 0 : : SgUpirBaseStatement(startOfConstruct)
207359 : {
207360 : #ifdef DEBUG
207361 : // printf ("In SgOmpDeclareMapperStatement::SgOmpDeclareMapperStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
207362 : #endif
207363 : #if 0
207364 : // debugging information!
207365 : printf ("In SgOmpDeclareMapperStatement::SgOmpDeclareMapperStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
207366 : #endif
207367 :
207368 :
207369 :
207370 : #if 0
207371 : // DQ (7/30/2014): Call a virtual function.
207372 : std::string s = this->class_name();
207373 : #endif
207374 :
207375 : // Test the variant virtual function
207376 : // assert(OMP_DECLARE_MAPPER_STMT == variant());
207377 0 : assert(OMP_DECLARE_MAPPER_STMT == this->variant());
207378 0 : ROSE_ASSERT(OMP_DECLARE_MAPPER_STMT == (int)(this->variantT()));
207379 0 : post_construction_initialization();
207380 :
207381 : // Test the isSgOmpDeclareMapperStatement() function since it has been problematic
207382 0 : assert(isSgOmpDeclareMapperStatement(this) != NULL);
207383 0 : }
207384 :
207385 : // Generated constructor (all data members)
207386 :
207387 : /* #line 207388 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207388 :
207389 :
207390 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
207391 :
207392 :
207393 : // ********************************************************
207394 : // member functions common across all array grammar objects
207395 : // ********************************************************
207396 :
207397 :
207398 :
207399 : /* #line 207400 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207400 :
207401 :
207402 :
207403 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
207404 :
207405 : // ********************************************************
207406 : // member functions specific to each node in the grammar
207407 : // ********************************************************
207408 :
207409 :
207410 : /* #line 207411 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207411 :
207412 : // Start of memberFunctionString
207413 : /* #line 18757 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
207414 :
207415 : void
207416 0 : SgSequenceStatement::post_construction_initialization()
207417 0 : {}
207418 :
207419 :
207420 : // End of memberFunctionString
207421 : // Start of memberFunctionString
207422 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
207423 :
207424 : // *** COMMON CODE SECTION BEGINS HERE ***
207425 :
207426 : #if 0
207427 : int
207428 : SgSequenceStatement::getVariant() const
207429 : {
207430 : // This function is used in ROSE while "variant()" is used in SAGE
207431 : assert(this != NULL);
207432 : return variant();
207433 : }
207434 : #endif
207435 :
207436 : // This function is used in ROSE in treeTraversal code
207437 : // eventually replaces getVariant() and variant()
207438 : // though after variant() has been removed for a while we will
207439 : // want to change the name of variantT() back to variant()
207440 : // (since the "T" was ment to stand for temporary).
207441 : // When this happens the variantT() will be depricated.
207442 : VariantT
207443 0 : SgSequenceStatement::variantT() const
207444 : {
207445 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
207446 0 : ROSE_ASSERT(this != NULL);
207447 0 : return V_SgSequenceStatement;
207448 : }
207449 :
207450 : #if 0
207451 : int
207452 : SgSequenceStatement::variant() const
207453 : {
207454 : // This function is used in SAGE
207455 : ROSE_ASSERT(this != NULL);
207456 : return TEMP_Sequence_Statement;
207457 : }
207458 : #endif
207459 :
207460 : ROSE_DLL_API const char*
207461 0 : SgSequenceStatement::sage_class_name() const
207462 : {
207463 0 : ROSE_ASSERT(this != NULL);
207464 0 : return "SgSequenceStatement";
207465 : }
207466 :
207467 : std::string
207468 0 : SgSequenceStatement::class_name() const
207469 : {
207470 0 : ROSE_ASSERT(this != NULL);
207471 0 : return "SgSequenceStatement";
207472 : }
207473 :
207474 : // DQ (11/26/2005): Support for visitor pattern mechanims
207475 : // (inferior to ROSE traversal mechanism, experimental).
207476 : void
207477 0 : SgSequenceStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
207478 : {
207479 0 : ROSE_ASSERT(this != NULL);
207480 0 : visitor.visit(this);
207481 0 : }
207482 :
207483 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
207484 0 : void SgSequenceStatement::accept (ROSE_VisitorPattern & visitor) {
207485 0 : ROSE_ASSERT(this != NULL);
207486 0 : visitor.visit(this);
207487 0 : }
207488 :
207489 : SgSequenceStatement*
207490 0 : SgSequenceStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
207491 : {
207492 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
207493 : // This function is currently only supported for the AST used the represent Binary executables.
207494 : if (0 /* isSgAsmNode(this) != NULL */)
207495 : {
207496 : // Support for regex specification.
207497 : std::string prefixCode = "REGEX:";
207498 : addNewAttribute(prefixCode + s,a);
207499 : }
207500 : #endif
207501 :
207502 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
207503 0 : return this;
207504 : }
207505 :
207506 : // *** COMMON CODE SECTION ENDS HERE ***
207507 :
207508 :
207509 : // End of memberFunctionString
207510 : // Start of memberFunctionString
207511 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
207512 :
207513 :
207514 : #if 0
207515 : //! Error checking support
207516 : /*! Verifies the following:
207517 : - working getVariant() member function
207518 : - calls base class's error() member function
207519 : Every class has one of these functions.
207520 : */
207521 : bool
207522 : SgSequenceStatement::error()
207523 : {
207524 : // Put error checking here
207525 :
207526 : ROSE_ASSERT (this != NULL);
207527 : if (getVariant() != TEMP_Sequence_Statement)
207528 : {
207529 : printf ("Error in SgSequenceStatement::error(): SgSequenceStatement object has a %s variant \n",
207530 : Cxx_GrammarTerminalNames[getVariant()].name);
207531 : // printf ("Error in SgSequenceStatement::error() \n");
207532 : ROSE_ABORT();
207533 : }
207534 :
207535 : ROSE_ASSERT (getVariant() == TEMP_Sequence_Statement);
207536 : return SgStatement::error();
207537 : }
207538 : #endif
207539 :
207540 :
207541 :
207542 : // End of memberFunctionString
207543 :
207544 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
207545 :
207546 0 : SgSequenceStatement* isSgSequenceStatement ( SgNode* inputDerivedClassPointer )
207547 : {
207548 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207549 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207550 : // So to fix this we return NULL directly when the input is NULL and avoid the
207551 : // dynamic_cast in this case. This is likely a performance improvement as well.
207552 : // return dynamic_cast<SgSequenceStatement*>(inputDerivedClassPointer);
207553 : // Milind Chabbi (8/28/2013): isSgSequenceStatement uses table-driven castability instead of c++ default dynamic_cast
207554 : // this improves the running time performance by 10-20%.
207555 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSequenceStatement*>(inputDerivedClassPointer);
207556 0 : return IS_SgSequenceStatement_FAST_MACRO(inputDerivedClassPointer);
207557 : }
207558 :
207559 : // DQ (11/8/2003): Added version of functions taking const pointer
207560 0 : const SgSequenceStatement* isSgSequenceStatement ( const SgNode* inputDerivedClassPointer )
207561 : {
207562 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207563 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207564 : // So to fix this we return NULL directly when the input is NULL and avoid the
207565 : // dynamic_cast in this case. This is likely a performance improvement as well.
207566 : // return dynamic_cast<const SgSequenceStatement*>(inputDerivedClassPointer);
207567 : // Milind Chabbi (8/28/2013): isSgSequenceStatement uses table-driven castability instead of c++ default dynamic_cast
207568 : // this improves the running time performance by 10-20%.
207569 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSequenceStatement*>(inputDerivedClassPointer);
207570 0 : return IS_SgSequenceStatement_FAST_MACRO(inputDerivedClassPointer);
207571 : }
207572 :
207573 :
207574 :
207575 : /* #line 207576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207576 :
207577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207578 :
207579 : /**
207580 : \brief Generated destructor
207581 :
207582 : This destructor is automatically generated (by ROSETTA). This destructor
207583 : only frees memory of data members associated with the parts of the current IR node which
207584 : are NOT traversed. Those data members that are part of a traversal can be freed using
207585 : a traversal (calling this destructor on all children in a post-order traversal). Such
207586 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
207587 :
207588 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
207589 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
207590 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
207591 :
207592 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
207593 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
207594 : pointers are not yet implemented to call delete on eash pointer in the container.
207595 : (This could be done by derivation from the STL containers to define containers that
207596 : automatically deleted their members.)
207597 :
207598 : */
207599 0 : SgSequenceStatement::~SgSequenceStatement () {
207600 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
207601 :
207602 :
207603 :
207604 : }
207605 :
207606 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207607 0 : }
207608 :
207609 :
207610 : /* #line 207611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207611 :
207612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
207613 :
207614 : // Generated constructor
207615 0 : SgSequenceStatement::SgSequenceStatement ( Sg_File_Info* startOfConstruct )
207616 0 : : SgStatement(startOfConstruct)
207617 : {
207618 : #ifdef DEBUG
207619 : // printf ("In SgSequenceStatement::SgSequenceStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
207620 : #endif
207621 : #if 0
207622 : // debugging information!
207623 : printf ("In SgSequenceStatement::SgSequenceStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
207624 : #endif
207625 :
207626 :
207627 :
207628 : #if 0
207629 : // DQ (7/30/2014): Call a virtual function.
207630 : std::string s = this->class_name();
207631 : #endif
207632 :
207633 : // Test the variant virtual function
207634 : // assert(TEMP_Sequence_Statement == variant());
207635 0 : assert(TEMP_Sequence_Statement == this->variant());
207636 0 : ROSE_ASSERT(TEMP_Sequence_Statement == (int)(this->variantT()));
207637 0 : post_construction_initialization();
207638 :
207639 : // Test the isSgSequenceStatement() function since it has been problematic
207640 0 : assert(isSgSequenceStatement(this) != NULL);
207641 0 : }
207642 :
207643 : // Generated constructor (all data members)
207644 :
207645 : /* #line 207646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207646 :
207647 :
207648 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
207649 :
207650 :
207651 : // ********************************************************
207652 : // member functions common across all array grammar objects
207653 : // ********************************************************
207654 :
207655 :
207656 :
207657 : /* #line 207658 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207658 :
207659 :
207660 :
207661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
207662 :
207663 : // ********************************************************
207664 : // member functions specific to each node in the grammar
207665 : // ********************************************************
207666 :
207667 :
207668 : /* #line 207669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207669 :
207670 : // Start of memberFunctionString
207671 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
207672 :
207673 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
207674 :
207675 : SgExpression*
207676 0 : SgWithStatement::get_expression () const
207677 : {
207678 0 : ROSE_ASSERT (this != NULL);
207679 :
207680 : #if 0
207681 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
207682 : // used to trigger marking transformations for the token-based unparsing.
207683 : printf ("SgWithStatement::get_expression = %p = %s \n",this,this->class_name().c_str());
207684 : #endif
207685 :
207686 0 : return p_expression;
207687 : }
207688 :
207689 : void
207690 0 : SgWithStatement::set_expression ( SgExpression* expression )
207691 : {
207692 0 : ROSE_ASSERT (this != NULL);
207693 :
207694 : #if 0
207695 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
207696 : // used to trigger marking transformations for the token-based unparsing.
207697 : printf ("SgWithStatement::set_expression = %p = %s \n",this,this->class_name().c_str());
207698 : #endif
207699 :
207700 0 : set_isModified(true);
207701 :
207702 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
207703 : if (p_expression != NULL && expression != NULL && p_expression != expression)
207704 : {
207705 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
207706 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
207707 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
207708 : ROSE_ASSERT(false);
207709 : #endif
207710 : }
207711 : #endif
207712 0 : p_expression = expression;
207713 0 : }
207714 :
207715 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
207716 :
207717 :
207718 : // End of memberFunctionString
207719 : // Start of memberFunctionString
207720 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
207721 :
207722 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
207723 :
207724 : SgStatement*
207725 0 : SgWithStatement::get_body () const
207726 : {
207727 0 : ROSE_ASSERT (this != NULL);
207728 :
207729 : #if 0
207730 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
207731 : // used to trigger marking transformations for the token-based unparsing.
207732 : printf ("SgWithStatement::get_body = %p = %s \n",this,this->class_name().c_str());
207733 : #endif
207734 :
207735 0 : return p_body;
207736 : }
207737 :
207738 : void
207739 0 : SgWithStatement::set_body ( SgStatement* body )
207740 : {
207741 0 : ROSE_ASSERT (this != NULL);
207742 :
207743 : #if 0
207744 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
207745 : // used to trigger marking transformations for the token-based unparsing.
207746 : printf ("SgWithStatement::set_body = %p = %s \n",this,this->class_name().c_str());
207747 : #endif
207748 :
207749 0 : set_isModified(true);
207750 :
207751 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
207752 : if (p_body != NULL && body != NULL && p_body != body)
207753 : {
207754 : printf ("Warning: body = %p overwriting valid pointer p_body = %p \n",body,p_body);
207755 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
207756 : printf ("Error fails assertion (p_body != NULL && body != NULL && p_body != body) is false\n");
207757 : ROSE_ASSERT(false);
207758 : #endif
207759 : }
207760 : #endif
207761 0 : p_body = body;
207762 0 : }
207763 :
207764 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
207765 :
207766 :
207767 : // End of memberFunctionString
207768 : // Start of memberFunctionString
207769 : /* #line 15412 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
207770 :
207771 :
207772 :
207773 : // End of memberFunctionString
207774 : // Start of memberFunctionString
207775 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
207776 :
207777 : void
207778 0 : SgWithStatement::post_construction_initialization()
207779 : {
207780 0 : }
207781 :
207782 :
207783 :
207784 : // End of memberFunctionString
207785 : // Start of memberFunctionString
207786 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
207787 :
207788 : // *** COMMON CODE SECTION BEGINS HERE ***
207789 :
207790 : #if 0
207791 : int
207792 : SgWithStatement::getVariant() const
207793 : {
207794 : // This function is used in ROSE while "variant()" is used in SAGE
207795 : assert(this != NULL);
207796 : return variant();
207797 : }
207798 : #endif
207799 :
207800 : // This function is used in ROSE in treeTraversal code
207801 : // eventually replaces getVariant() and variant()
207802 : // though after variant() has been removed for a while we will
207803 : // want to change the name of variantT() back to variant()
207804 : // (since the "T" was ment to stand for temporary).
207805 : // When this happens the variantT() will be depricated.
207806 : VariantT
207807 0 : SgWithStatement::variantT() const
207808 : {
207809 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
207810 0 : ROSE_ASSERT(this != NULL);
207811 0 : return V_SgWithStatement;
207812 : }
207813 :
207814 : #if 0
207815 : int
207816 : SgWithStatement::variant() const
207817 : {
207818 : // This function is used in SAGE
207819 : ROSE_ASSERT(this != NULL);
207820 : return WITH_STATEMENT;
207821 : }
207822 : #endif
207823 :
207824 : ROSE_DLL_API const char*
207825 0 : SgWithStatement::sage_class_name() const
207826 : {
207827 0 : ROSE_ASSERT(this != NULL);
207828 0 : return "SgWithStatement";
207829 : }
207830 :
207831 : std::string
207832 0 : SgWithStatement::class_name() const
207833 : {
207834 0 : ROSE_ASSERT(this != NULL);
207835 0 : return "SgWithStatement";
207836 : }
207837 :
207838 : // DQ (11/26/2005): Support for visitor pattern mechanims
207839 : // (inferior to ROSE traversal mechanism, experimental).
207840 : void
207841 0 : SgWithStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
207842 : {
207843 0 : ROSE_ASSERT(this != NULL);
207844 0 : visitor.visit(this);
207845 0 : }
207846 :
207847 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
207848 0 : void SgWithStatement::accept (ROSE_VisitorPattern & visitor) {
207849 0 : ROSE_ASSERT(this != NULL);
207850 0 : visitor.visit(this);
207851 0 : }
207852 :
207853 : SgWithStatement*
207854 0 : SgWithStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
207855 : {
207856 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
207857 : // This function is currently only supported for the AST used the represent Binary executables.
207858 : if (0 /* isSgAsmNode(this) != NULL */)
207859 : {
207860 : // Support for regex specification.
207861 : std::string prefixCode = "REGEX:";
207862 : addNewAttribute(prefixCode + s,a);
207863 : }
207864 : #endif
207865 :
207866 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
207867 0 : return this;
207868 : }
207869 :
207870 : // *** COMMON CODE SECTION ENDS HERE ***
207871 :
207872 :
207873 : // End of memberFunctionString
207874 : // Start of memberFunctionString
207875 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
207876 :
207877 :
207878 : #if 0
207879 : //! Error checking support
207880 : /*! Verifies the following:
207881 : - working getVariant() member function
207882 : - calls base class's error() member function
207883 : Every class has one of these functions.
207884 : */
207885 : bool
207886 : SgWithStatement::error()
207887 : {
207888 : // Put error checking here
207889 :
207890 : ROSE_ASSERT (this != NULL);
207891 : if (getVariant() != WITH_STATEMENT)
207892 : {
207893 : printf ("Error in SgWithStatement::error(): SgWithStatement object has a %s variant \n",
207894 : Cxx_GrammarTerminalNames[getVariant()].name);
207895 : // printf ("Error in SgWithStatement::error() \n");
207896 : ROSE_ABORT();
207897 : }
207898 :
207899 : ROSE_ASSERT (getVariant() == WITH_STATEMENT);
207900 : return SgStatement::error();
207901 : }
207902 : #endif
207903 :
207904 :
207905 :
207906 : // End of memberFunctionString
207907 :
207908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
207909 :
207910 0 : SgWithStatement* isSgWithStatement ( SgNode* inputDerivedClassPointer )
207911 : {
207912 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207913 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207914 : // So to fix this we return NULL directly when the input is NULL and avoid the
207915 : // dynamic_cast in this case. This is likely a performance improvement as well.
207916 : // return dynamic_cast<SgWithStatement*>(inputDerivedClassPointer);
207917 : // Milind Chabbi (8/28/2013): isSgWithStatement uses table-driven castability instead of c++ default dynamic_cast
207918 : // this improves the running time performance by 10-20%.
207919 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWithStatement*>(inputDerivedClassPointer);
207920 0 : return IS_SgWithStatement_FAST_MACRO(inputDerivedClassPointer);
207921 : }
207922 :
207923 : // DQ (11/8/2003): Added version of functions taking const pointer
207924 0 : const SgWithStatement* isSgWithStatement ( const SgNode* inputDerivedClassPointer )
207925 : {
207926 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
207927 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
207928 : // So to fix this we return NULL directly when the input is NULL and avoid the
207929 : // dynamic_cast in this case. This is likely a performance improvement as well.
207930 : // return dynamic_cast<const SgWithStatement*>(inputDerivedClassPointer);
207931 : // Milind Chabbi (8/28/2013): isSgWithStatement uses table-driven castability instead of c++ default dynamic_cast
207932 : // this improves the running time performance by 10-20%.
207933 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWithStatement*>(inputDerivedClassPointer);
207934 0 : return IS_SgWithStatement_FAST_MACRO(inputDerivedClassPointer);
207935 : }
207936 :
207937 :
207938 :
207939 : /* #line 207940 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207940 :
207941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207942 :
207943 : /**
207944 : \brief Generated destructor
207945 :
207946 : This destructor is automatically generated (by ROSETTA). This destructor
207947 : only frees memory of data members associated with the parts of the current IR node which
207948 : are NOT traversed. Those data members that are part of a traversal can be freed using
207949 : a traversal (calling this destructor on all children in a post-order traversal). Such
207950 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
207951 :
207952 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
207953 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
207954 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
207955 :
207956 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
207957 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
207958 : pointers are not yet implemented to call delete on eash pointer in the container.
207959 : (This could be done by derivation from the STL containers to define containers that
207960 : automatically deleted their members.)
207961 :
207962 : */
207963 0 : SgWithStatement::~SgWithStatement () {
207964 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
207965 :
207966 :
207967 : // case: not a listType for expression
207968 0 : p_expression = NULL; // non list case
207969 : // case: not a listType for body
207970 0 : p_body = NULL; // non list case
207971 :
207972 : }
207973 :
207974 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
207975 0 : }
207976 :
207977 :
207978 : /* #line 207979 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
207979 :
207980 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
207981 :
207982 : // Generated constructor
207983 0 : SgWithStatement::SgWithStatement ( Sg_File_Info* startOfConstruct, SgExpression* expression, SgStatement* body )
207984 0 : : SgStatement(startOfConstruct)
207985 : {
207986 : #ifdef DEBUG
207987 : // printf ("In SgWithStatement::SgWithStatement (Sg_File_Info* startOfConstruct, SgExpression* expression, SgStatement* body) sage_class_name() = %s \n",sage_class_name());
207988 : #endif
207989 : #if 0
207990 : // debugging information!
207991 : printf ("In SgWithStatement::SgWithStatement (Sg_File_Info* startOfConstruct, SgExpression* expression, SgStatement* body): this = %p = %s \n",this,this->class_name().c_str());
207992 : #endif
207993 :
207994 0 : p_expression = expression;
207995 0 : p_body = body;
207996 :
207997 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
207998 :
207999 : #if 0
208000 : // DQ (7/30/2014): Call a virtual function.
208001 : std::string s = this->class_name();
208002 : #endif
208003 :
208004 : // Test the variant virtual function
208005 : // assert(WITH_STATEMENT == variant());
208006 0 : assert(WITH_STATEMENT == this->variant());
208007 0 : ROSE_ASSERT(WITH_STATEMENT == (int)(this->variantT()));
208008 0 : post_construction_initialization();
208009 :
208010 : // Test the isSgWithStatement() function since it has been problematic
208011 0 : assert(isSgWithStatement(this) != NULL);
208012 0 : }
208013 :
208014 : // Generated constructor (all data members)
208015 :
208016 : /* #line 208017 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208017 :
208018 :
208019 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
208020 :
208021 :
208022 : // ********************************************************
208023 : // member functions common across all array grammar objects
208024 : // ********************************************************
208025 :
208026 :
208027 :
208028 : /* #line 208029 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208029 :
208030 :
208031 :
208032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
208033 :
208034 : // ********************************************************
208035 : // member functions specific to each node in the grammar
208036 : // ********************************************************
208037 :
208038 :
208039 : /* #line 208040 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208040 :
208041 : // Start of memberFunctionString
208042 : /* #line 16034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
208043 :
208044 :
208045 : void
208046 0 : SgPassStatement::post_construction_initialization()
208047 0 : {}
208048 :
208049 :
208050 :
208051 : // End of memberFunctionString
208052 : // Start of memberFunctionString
208053 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
208054 :
208055 : // *** COMMON CODE SECTION BEGINS HERE ***
208056 :
208057 : #if 0
208058 : int
208059 : SgPassStatement::getVariant() const
208060 : {
208061 : // This function is used in ROSE while "variant()" is used in SAGE
208062 : assert(this != NULL);
208063 : return variant();
208064 : }
208065 : #endif
208066 :
208067 : // This function is used in ROSE in treeTraversal code
208068 : // eventually replaces getVariant() and variant()
208069 : // though after variant() has been removed for a while we will
208070 : // want to change the name of variantT() back to variant()
208071 : // (since the "T" was ment to stand for temporary).
208072 : // When this happens the variantT() will be depricated.
208073 : VariantT
208074 0 : SgPassStatement::variantT() const
208075 : {
208076 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
208077 0 : ROSE_ASSERT(this != NULL);
208078 0 : return V_SgPassStatement;
208079 : }
208080 :
208081 : #if 0
208082 : int
208083 : SgPassStatement::variant() const
208084 : {
208085 : // This function is used in SAGE
208086 : ROSE_ASSERT(this != NULL);
208087 : return PASS_STATEMENT;
208088 : }
208089 : #endif
208090 :
208091 : ROSE_DLL_API const char*
208092 0 : SgPassStatement::sage_class_name() const
208093 : {
208094 0 : ROSE_ASSERT(this != NULL);
208095 0 : return "SgPassStatement";
208096 : }
208097 :
208098 : std::string
208099 0 : SgPassStatement::class_name() const
208100 : {
208101 0 : ROSE_ASSERT(this != NULL);
208102 0 : return "SgPassStatement";
208103 : }
208104 :
208105 : // DQ (11/26/2005): Support for visitor pattern mechanims
208106 : // (inferior to ROSE traversal mechanism, experimental).
208107 : void
208108 0 : SgPassStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
208109 : {
208110 0 : ROSE_ASSERT(this != NULL);
208111 0 : visitor.visit(this);
208112 0 : }
208113 :
208114 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
208115 0 : void SgPassStatement::accept (ROSE_VisitorPattern & visitor) {
208116 0 : ROSE_ASSERT(this != NULL);
208117 0 : visitor.visit(this);
208118 0 : }
208119 :
208120 : SgPassStatement*
208121 0 : SgPassStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
208122 : {
208123 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
208124 : // This function is currently only supported for the AST used the represent Binary executables.
208125 : if (0 /* isSgAsmNode(this) != NULL */)
208126 : {
208127 : // Support for regex specification.
208128 : std::string prefixCode = "REGEX:";
208129 : addNewAttribute(prefixCode + s,a);
208130 : }
208131 : #endif
208132 :
208133 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
208134 0 : return this;
208135 : }
208136 :
208137 : // *** COMMON CODE SECTION ENDS HERE ***
208138 :
208139 :
208140 : // End of memberFunctionString
208141 : // Start of memberFunctionString
208142 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
208143 :
208144 :
208145 : #if 0
208146 : //! Error checking support
208147 : /*! Verifies the following:
208148 : - working getVariant() member function
208149 : - calls base class's error() member function
208150 : Every class has one of these functions.
208151 : */
208152 : bool
208153 : SgPassStatement::error()
208154 : {
208155 : // Put error checking here
208156 :
208157 : ROSE_ASSERT (this != NULL);
208158 : if (getVariant() != PASS_STATEMENT)
208159 : {
208160 : printf ("Error in SgPassStatement::error(): SgPassStatement object has a %s variant \n",
208161 : Cxx_GrammarTerminalNames[getVariant()].name);
208162 : // printf ("Error in SgPassStatement::error() \n");
208163 : ROSE_ABORT();
208164 : }
208165 :
208166 : ROSE_ASSERT (getVariant() == PASS_STATEMENT);
208167 : return SgStatement::error();
208168 : }
208169 : #endif
208170 :
208171 :
208172 :
208173 : // End of memberFunctionString
208174 :
208175 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
208176 :
208177 0 : SgPassStatement* isSgPassStatement ( SgNode* inputDerivedClassPointer )
208178 : {
208179 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
208180 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
208181 : // So to fix this we return NULL directly when the input is NULL and avoid the
208182 : // dynamic_cast in this case. This is likely a performance improvement as well.
208183 : // return dynamic_cast<SgPassStatement*>(inputDerivedClassPointer);
208184 : // Milind Chabbi (8/28/2013): isSgPassStatement uses table-driven castability instead of c++ default dynamic_cast
208185 : // this improves the running time performance by 10-20%.
208186 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPassStatement*>(inputDerivedClassPointer);
208187 0 : return IS_SgPassStatement_FAST_MACRO(inputDerivedClassPointer);
208188 : }
208189 :
208190 : // DQ (11/8/2003): Added version of functions taking const pointer
208191 0 : const SgPassStatement* isSgPassStatement ( const SgNode* inputDerivedClassPointer )
208192 : {
208193 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
208194 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
208195 : // So to fix this we return NULL directly when the input is NULL and avoid the
208196 : // dynamic_cast in this case. This is likely a performance improvement as well.
208197 : // return dynamic_cast<const SgPassStatement*>(inputDerivedClassPointer);
208198 : // Milind Chabbi (8/28/2013): isSgPassStatement uses table-driven castability instead of c++ default dynamic_cast
208199 : // this improves the running time performance by 10-20%.
208200 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPassStatement*>(inputDerivedClassPointer);
208201 0 : return IS_SgPassStatement_FAST_MACRO(inputDerivedClassPointer);
208202 : }
208203 :
208204 :
208205 :
208206 : /* #line 208207 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208207 :
208208 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
208209 :
208210 : /**
208211 : \brief Generated destructor
208212 :
208213 : This destructor is automatically generated (by ROSETTA). This destructor
208214 : only frees memory of data members associated with the parts of the current IR node which
208215 : are NOT traversed. Those data members that are part of a traversal can be freed using
208216 : a traversal (calling this destructor on all children in a post-order traversal). Such
208217 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
208218 :
208219 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
208220 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
208221 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
208222 :
208223 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
208224 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
208225 : pointers are not yet implemented to call delete on eash pointer in the container.
208226 : (This could be done by derivation from the STL containers to define containers that
208227 : automatically deleted their members.)
208228 :
208229 : */
208230 0 : SgPassStatement::~SgPassStatement () {
208231 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
208232 :
208233 :
208234 :
208235 : }
208236 :
208237 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
208238 0 : }
208239 :
208240 :
208241 : /* #line 208242 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208242 :
208243 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
208244 :
208245 : // Generated constructor
208246 0 : SgPassStatement::SgPassStatement ( Sg_File_Info* startOfConstruct )
208247 0 : : SgStatement(startOfConstruct)
208248 : {
208249 : #ifdef DEBUG
208250 : // printf ("In SgPassStatement::SgPassStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
208251 : #endif
208252 : #if 0
208253 : // debugging information!
208254 : printf ("In SgPassStatement::SgPassStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
208255 : #endif
208256 :
208257 :
208258 :
208259 : #if 0
208260 : // DQ (7/30/2014): Call a virtual function.
208261 : std::string s = this->class_name();
208262 : #endif
208263 :
208264 : // Test the variant virtual function
208265 : // assert(PASS_STATEMENT == variant());
208266 0 : assert(PASS_STATEMENT == this->variant());
208267 0 : ROSE_ASSERT(PASS_STATEMENT == (int)(this->variantT()));
208268 0 : post_construction_initialization();
208269 :
208270 : // Test the isSgPassStatement() function since it has been problematic
208271 0 : assert(isSgPassStatement(this) != NULL);
208272 0 : }
208273 :
208274 : // Generated constructor (all data members)
208275 :
208276 : /* #line 208277 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208277 :
208278 :
208279 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
208280 :
208281 :
208282 : // ********************************************************
208283 : // member functions common across all array grammar objects
208284 : // ********************************************************
208285 :
208286 :
208287 :
208288 : /* #line 208289 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208289 :
208290 :
208291 :
208292 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
208293 :
208294 : // ********************************************************
208295 : // member functions specific to each node in the grammar
208296 : // ********************************************************
208297 :
208298 :
208299 : /* #line 208300 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208300 :
208301 : // Start of memberFunctionString
208302 : /* #line 16042 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
208303 :
208304 :
208305 : void
208306 0 : SgAssertStmt::post_construction_initialization()
208307 0 : {}
208308 :
208309 :
208310 :
208311 : // End of memberFunctionString
208312 : // Start of memberFunctionString
208313 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
208314 :
208315 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
208316 :
208317 : SgExpression*
208318 0 : SgAssertStmt::get_test () const
208319 : {
208320 0 : ROSE_ASSERT (this != NULL);
208321 :
208322 : #if 0
208323 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208324 : // used to trigger marking transformations for the token-based unparsing.
208325 : printf ("SgAssertStmt::get_test = %p = %s \n",this,this->class_name().c_str());
208326 : #endif
208327 :
208328 0 : return p_test;
208329 : }
208330 :
208331 : void
208332 0 : SgAssertStmt::set_test ( SgExpression* test )
208333 : {
208334 0 : ROSE_ASSERT (this != NULL);
208335 :
208336 : #if 0
208337 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208338 : // used to trigger marking transformations for the token-based unparsing.
208339 : printf ("SgAssertStmt::set_test = %p = %s \n",this,this->class_name().c_str());
208340 : #endif
208341 :
208342 0 : set_isModified(true);
208343 :
208344 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
208345 : if (p_test != NULL && test != NULL && p_test != test)
208346 : {
208347 : printf ("Warning: test = %p overwriting valid pointer p_test = %p \n",test,p_test);
208348 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
208349 : printf ("Error fails assertion (p_test != NULL && test != NULL && p_test != test) is false\n");
208350 : ROSE_ASSERT(false);
208351 : #endif
208352 : }
208353 : #endif
208354 0 : p_test = test;
208355 0 : }
208356 :
208357 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
208358 :
208359 :
208360 : // End of memberFunctionString
208361 : // Start of memberFunctionString
208362 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
208363 :
208364 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
208365 :
208366 : SgExpression*
208367 0 : SgAssertStmt::get_exception_argument () const
208368 : {
208369 0 : ROSE_ASSERT (this != NULL);
208370 :
208371 : #if 0
208372 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208373 : // used to trigger marking transformations for the token-based unparsing.
208374 : printf ("SgAssertStmt::get_exception_argument = %p = %s \n",this,this->class_name().c_str());
208375 : #endif
208376 :
208377 0 : return p_exception_argument;
208378 : }
208379 :
208380 : void
208381 0 : SgAssertStmt::set_exception_argument ( SgExpression* exception_argument )
208382 : {
208383 0 : ROSE_ASSERT (this != NULL);
208384 :
208385 : #if 0
208386 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208387 : // used to trigger marking transformations for the token-based unparsing.
208388 : printf ("SgAssertStmt::set_exception_argument = %p = %s \n",this,this->class_name().c_str());
208389 : #endif
208390 :
208391 0 : set_isModified(true);
208392 :
208393 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
208394 : if (p_exception_argument != NULL && exception_argument != NULL && p_exception_argument != exception_argument)
208395 : {
208396 : printf ("Warning: exception_argument = %p overwriting valid pointer p_exception_argument = %p \n",exception_argument,p_exception_argument);
208397 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
208398 : printf ("Error fails assertion (p_exception_argument != NULL && exception_argument != NULL && p_exception_argument != exception_argument) is false\n");
208399 : ROSE_ASSERT(false);
208400 : #endif
208401 : }
208402 : #endif
208403 0 : p_exception_argument = exception_argument;
208404 0 : }
208405 :
208406 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
208407 :
208408 :
208409 : // End of memberFunctionString
208410 : // Start of memberFunctionString
208411 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
208412 :
208413 : // *** COMMON CODE SECTION BEGINS HERE ***
208414 :
208415 : #if 0
208416 : int
208417 : SgAssertStmt::getVariant() const
208418 : {
208419 : // This function is used in ROSE while "variant()" is used in SAGE
208420 : assert(this != NULL);
208421 : return variant();
208422 : }
208423 : #endif
208424 :
208425 : // This function is used in ROSE in treeTraversal code
208426 : // eventually replaces getVariant() and variant()
208427 : // though after variant() has been removed for a while we will
208428 : // want to change the name of variantT() back to variant()
208429 : // (since the "T" was ment to stand for temporary).
208430 : // When this happens the variantT() will be depricated.
208431 : VariantT
208432 0 : SgAssertStmt::variantT() const
208433 : {
208434 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
208435 0 : ROSE_ASSERT(this != NULL);
208436 0 : return V_SgAssertStmt;
208437 : }
208438 :
208439 : #if 0
208440 : int
208441 : SgAssertStmt::variant() const
208442 : {
208443 : // This function is used in SAGE
208444 : ROSE_ASSERT(this != NULL);
208445 : return ASSERT_STMT;
208446 : }
208447 : #endif
208448 :
208449 : ROSE_DLL_API const char*
208450 0 : SgAssertStmt::sage_class_name() const
208451 : {
208452 0 : ROSE_ASSERT(this != NULL);
208453 0 : return "SgAssertStmt";
208454 : }
208455 :
208456 : std::string
208457 0 : SgAssertStmt::class_name() const
208458 : {
208459 0 : ROSE_ASSERT(this != NULL);
208460 0 : return "SgAssertStmt";
208461 : }
208462 :
208463 : // DQ (11/26/2005): Support for visitor pattern mechanims
208464 : // (inferior to ROSE traversal mechanism, experimental).
208465 : void
208466 0 : SgAssertStmt::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
208467 : {
208468 0 : ROSE_ASSERT(this != NULL);
208469 0 : visitor.visit(this);
208470 0 : }
208471 :
208472 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
208473 0 : void SgAssertStmt::accept (ROSE_VisitorPattern & visitor) {
208474 0 : ROSE_ASSERT(this != NULL);
208475 0 : visitor.visit(this);
208476 0 : }
208477 :
208478 : SgAssertStmt*
208479 0 : SgAssertStmt::addRegExpAttribute(std::string s, AstRegExAttribute* a)
208480 : {
208481 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
208482 : // This function is currently only supported for the AST used the represent Binary executables.
208483 : if (0 /* isSgAsmNode(this) != NULL */)
208484 : {
208485 : // Support for regex specification.
208486 : std::string prefixCode = "REGEX:";
208487 : addNewAttribute(prefixCode + s,a);
208488 : }
208489 : #endif
208490 :
208491 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
208492 0 : return this;
208493 : }
208494 :
208495 : // *** COMMON CODE SECTION ENDS HERE ***
208496 :
208497 :
208498 : // End of memberFunctionString
208499 : // Start of memberFunctionString
208500 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
208501 :
208502 :
208503 : #if 0
208504 : //! Error checking support
208505 : /*! Verifies the following:
208506 : - working getVariant() member function
208507 : - calls base class's error() member function
208508 : Every class has one of these functions.
208509 : */
208510 : bool
208511 : SgAssertStmt::error()
208512 : {
208513 : // Put error checking here
208514 :
208515 : ROSE_ASSERT (this != NULL);
208516 : if (getVariant() != ASSERT_STMT)
208517 : {
208518 : printf ("Error in SgAssertStmt::error(): SgAssertStmt object has a %s variant \n",
208519 : Cxx_GrammarTerminalNames[getVariant()].name);
208520 : // printf ("Error in SgAssertStmt::error() \n");
208521 : ROSE_ABORT();
208522 : }
208523 :
208524 : ROSE_ASSERT (getVariant() == ASSERT_STMT);
208525 : return SgStatement::error();
208526 : }
208527 : #endif
208528 :
208529 :
208530 :
208531 : // End of memberFunctionString
208532 :
208533 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
208534 :
208535 0 : SgAssertStmt* isSgAssertStmt ( SgNode* inputDerivedClassPointer )
208536 : {
208537 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
208538 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
208539 : // So to fix this we return NULL directly when the input is NULL and avoid the
208540 : // dynamic_cast in this case. This is likely a performance improvement as well.
208541 : // return dynamic_cast<SgAssertStmt*>(inputDerivedClassPointer);
208542 : // Milind Chabbi (8/28/2013): isSgAssertStmt uses table-driven castability instead of c++ default dynamic_cast
208543 : // this improves the running time performance by 10-20%.
208544 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAssertStmt*>(inputDerivedClassPointer);
208545 0 : return IS_SgAssertStmt_FAST_MACRO(inputDerivedClassPointer);
208546 : }
208547 :
208548 : // DQ (11/8/2003): Added version of functions taking const pointer
208549 0 : const SgAssertStmt* isSgAssertStmt ( const SgNode* inputDerivedClassPointer )
208550 : {
208551 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
208552 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
208553 : // So to fix this we return NULL directly when the input is NULL and avoid the
208554 : // dynamic_cast in this case. This is likely a performance improvement as well.
208555 : // return dynamic_cast<const SgAssertStmt*>(inputDerivedClassPointer);
208556 : // Milind Chabbi (8/28/2013): isSgAssertStmt uses table-driven castability instead of c++ default dynamic_cast
208557 : // this improves the running time performance by 10-20%.
208558 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAssertStmt*>(inputDerivedClassPointer);
208559 0 : return IS_SgAssertStmt_FAST_MACRO(inputDerivedClassPointer);
208560 : }
208561 :
208562 :
208563 :
208564 : /* #line 208565 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208565 :
208566 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
208567 :
208568 : /**
208569 : \brief Generated destructor
208570 :
208571 : This destructor is automatically generated (by ROSETTA). This destructor
208572 : only frees memory of data members associated with the parts of the current IR node which
208573 : are NOT traversed. Those data members that are part of a traversal can be freed using
208574 : a traversal (calling this destructor on all children in a post-order traversal). Such
208575 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
208576 :
208577 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
208578 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
208579 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
208580 :
208581 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
208582 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
208583 : pointers are not yet implemented to call delete on eash pointer in the container.
208584 : (This could be done by derivation from the STL containers to define containers that
208585 : automatically deleted their members.)
208586 :
208587 : */
208588 0 : SgAssertStmt::~SgAssertStmt () {
208589 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
208590 :
208591 :
208592 : // case: not a listType for test
208593 0 : p_test = NULL; // non list case
208594 : // case: not a listType for exception_argument
208595 0 : p_exception_argument = NULL; // non list case
208596 :
208597 : }
208598 :
208599 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
208600 0 : }
208601 :
208602 :
208603 : /* #line 208604 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208604 :
208605 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
208606 :
208607 : // Generated constructor
208608 0 : SgAssertStmt::SgAssertStmt ( Sg_File_Info* startOfConstruct, SgExpression* test )
208609 0 : : SgStatement(startOfConstruct)
208610 : {
208611 : #ifdef DEBUG
208612 : // printf ("In SgAssertStmt::SgAssertStmt (Sg_File_Info* startOfConstruct, SgExpression* test) sage_class_name() = %s \n",sage_class_name());
208613 : #endif
208614 : #if 0
208615 : // debugging information!
208616 : printf ("In SgAssertStmt::SgAssertStmt (Sg_File_Info* startOfConstruct, SgExpression* test): this = %p = %s \n",this,this->class_name().c_str());
208617 : #endif
208618 :
208619 0 : p_test = test;
208620 0 : p_exception_argument = NULL;
208621 :
208622 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
208623 :
208624 : #if 0
208625 : // DQ (7/30/2014): Call a virtual function.
208626 : std::string s = this->class_name();
208627 : #endif
208628 :
208629 : // Test the variant virtual function
208630 : // assert(ASSERT_STMT == variant());
208631 0 : assert(ASSERT_STMT == this->variant());
208632 0 : ROSE_ASSERT(ASSERT_STMT == (int)(this->variantT()));
208633 0 : post_construction_initialization();
208634 :
208635 : // Test the isSgAssertStmt() function since it has been problematic
208636 0 : assert(isSgAssertStmt(this) != NULL);
208637 0 : }
208638 :
208639 : // Generated constructor (all data members)
208640 :
208641 : /* #line 208642 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208642 :
208643 :
208644 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
208645 :
208646 :
208647 : // ********************************************************
208648 : // member functions common across all array grammar objects
208649 : // ********************************************************
208650 :
208651 :
208652 :
208653 : /* #line 208654 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208654 :
208655 :
208656 :
208657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
208658 :
208659 : // ********************************************************
208660 : // member functions specific to each node in the grammar
208661 : // ********************************************************
208662 :
208663 :
208664 : /* #line 208665 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208665 :
208666 : // Start of memberFunctionString
208667 : /* #line 16050 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
208668 :
208669 :
208670 :
208671 : // End of memberFunctionString
208672 : // Start of memberFunctionString
208673 : /* #line 17322 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
208674 :
208675 : void
208676 0 : SgExecStatement::post_construction_initialization()
208677 : {
208678 0 : }
208679 :
208680 :
208681 :
208682 : // End of memberFunctionString
208683 : // Start of memberFunctionString
208684 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
208685 :
208686 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
208687 :
208688 : SgExpression*
208689 0 : SgExecStatement::get_executable () const
208690 : {
208691 0 : ROSE_ASSERT (this != NULL);
208692 :
208693 : #if 0
208694 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208695 : // used to trigger marking transformations for the token-based unparsing.
208696 : printf ("SgExecStatement::get_executable = %p = %s \n",this,this->class_name().c_str());
208697 : #endif
208698 :
208699 0 : return p_executable;
208700 : }
208701 :
208702 : void
208703 0 : SgExecStatement::set_executable ( SgExpression* executable )
208704 : {
208705 0 : ROSE_ASSERT (this != NULL);
208706 :
208707 : #if 0
208708 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208709 : // used to trigger marking transformations for the token-based unparsing.
208710 : printf ("SgExecStatement::set_executable = %p = %s \n",this,this->class_name().c_str());
208711 : #endif
208712 :
208713 0 : set_isModified(true);
208714 :
208715 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
208716 : if (p_executable != NULL && executable != NULL && p_executable != executable)
208717 : {
208718 : printf ("Warning: executable = %p overwriting valid pointer p_executable = %p \n",executable,p_executable);
208719 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
208720 : printf ("Error fails assertion (p_executable != NULL && executable != NULL && p_executable != executable) is false\n");
208721 : ROSE_ASSERT(false);
208722 : #endif
208723 : }
208724 : #endif
208725 0 : p_executable = executable;
208726 0 : }
208727 :
208728 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
208729 :
208730 :
208731 : // End of memberFunctionString
208732 : // Start of memberFunctionString
208733 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
208734 :
208735 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
208736 :
208737 : SgExpression*
208738 0 : SgExecStatement::get_globals () const
208739 : {
208740 0 : ROSE_ASSERT (this != NULL);
208741 :
208742 : #if 0
208743 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208744 : // used to trigger marking transformations for the token-based unparsing.
208745 : printf ("SgExecStatement::get_globals = %p = %s \n",this,this->class_name().c_str());
208746 : #endif
208747 :
208748 0 : return p_globals;
208749 : }
208750 :
208751 : void
208752 0 : SgExecStatement::set_globals ( SgExpression* globals )
208753 : {
208754 0 : ROSE_ASSERT (this != NULL);
208755 :
208756 : #if 0
208757 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208758 : // used to trigger marking transformations for the token-based unparsing.
208759 : printf ("SgExecStatement::set_globals = %p = %s \n",this,this->class_name().c_str());
208760 : #endif
208761 :
208762 0 : set_isModified(true);
208763 :
208764 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
208765 : if (p_globals != NULL && globals != NULL && p_globals != globals)
208766 : {
208767 : printf ("Warning: globals = %p overwriting valid pointer p_globals = %p \n",globals,p_globals);
208768 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
208769 : printf ("Error fails assertion (p_globals != NULL && globals != NULL && p_globals != globals) is false\n");
208770 : ROSE_ASSERT(false);
208771 : #endif
208772 : }
208773 : #endif
208774 0 : p_globals = globals;
208775 0 : }
208776 :
208777 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
208778 :
208779 :
208780 : // End of memberFunctionString
208781 : // Start of memberFunctionString
208782 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
208783 :
208784 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
208785 :
208786 : SgExpression*
208787 0 : SgExecStatement::get_locals () const
208788 : {
208789 0 : ROSE_ASSERT (this != NULL);
208790 :
208791 : #if 0
208792 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208793 : // used to trigger marking transformations for the token-based unparsing.
208794 : printf ("SgExecStatement::get_locals = %p = %s \n",this,this->class_name().c_str());
208795 : #endif
208796 :
208797 0 : return p_locals;
208798 : }
208799 :
208800 : void
208801 0 : SgExecStatement::set_locals ( SgExpression* locals )
208802 : {
208803 0 : ROSE_ASSERT (this != NULL);
208804 :
208805 : #if 0
208806 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
208807 : // used to trigger marking transformations for the token-based unparsing.
208808 : printf ("SgExecStatement::set_locals = %p = %s \n",this,this->class_name().c_str());
208809 : #endif
208810 :
208811 0 : set_isModified(true);
208812 :
208813 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
208814 : if (p_locals != NULL && locals != NULL && p_locals != locals)
208815 : {
208816 : printf ("Warning: locals = %p overwriting valid pointer p_locals = %p \n",locals,p_locals);
208817 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
208818 : printf ("Error fails assertion (p_locals != NULL && locals != NULL && p_locals != locals) is false\n");
208819 : ROSE_ASSERT(false);
208820 : #endif
208821 : }
208822 : #endif
208823 0 : p_locals = locals;
208824 0 : }
208825 :
208826 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
208827 :
208828 :
208829 : // End of memberFunctionString
208830 : // Start of memberFunctionString
208831 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
208832 :
208833 : // *** COMMON CODE SECTION BEGINS HERE ***
208834 :
208835 : #if 0
208836 : int
208837 : SgExecStatement::getVariant() const
208838 : {
208839 : // This function is used in ROSE while "variant()" is used in SAGE
208840 : assert(this != NULL);
208841 : return variant();
208842 : }
208843 : #endif
208844 :
208845 : // This function is used in ROSE in treeTraversal code
208846 : // eventually replaces getVariant() and variant()
208847 : // though after variant() has been removed for a while we will
208848 : // want to change the name of variantT() back to variant()
208849 : // (since the "T" was ment to stand for temporary).
208850 : // When this happens the variantT() will be depricated.
208851 : VariantT
208852 0 : SgExecStatement::variantT() const
208853 : {
208854 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
208855 0 : ROSE_ASSERT(this != NULL);
208856 0 : return V_SgExecStatement;
208857 : }
208858 :
208859 : #if 0
208860 : int
208861 : SgExecStatement::variant() const
208862 : {
208863 : // This function is used in SAGE
208864 : ROSE_ASSERT(this != NULL);
208865 : return EXEC_STMT;
208866 : }
208867 : #endif
208868 :
208869 : ROSE_DLL_API const char*
208870 0 : SgExecStatement::sage_class_name() const
208871 : {
208872 0 : ROSE_ASSERT(this != NULL);
208873 0 : return "SgExecStatement";
208874 : }
208875 :
208876 : std::string
208877 0 : SgExecStatement::class_name() const
208878 : {
208879 0 : ROSE_ASSERT(this != NULL);
208880 0 : return "SgExecStatement";
208881 : }
208882 :
208883 : // DQ (11/26/2005): Support for visitor pattern mechanims
208884 : // (inferior to ROSE traversal mechanism, experimental).
208885 : void
208886 0 : SgExecStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
208887 : {
208888 0 : ROSE_ASSERT(this != NULL);
208889 0 : visitor.visit(this);
208890 0 : }
208891 :
208892 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
208893 0 : void SgExecStatement::accept (ROSE_VisitorPattern & visitor) {
208894 0 : ROSE_ASSERT(this != NULL);
208895 0 : visitor.visit(this);
208896 0 : }
208897 :
208898 : SgExecStatement*
208899 0 : SgExecStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
208900 : {
208901 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
208902 : // This function is currently only supported for the AST used the represent Binary executables.
208903 : if (0 /* isSgAsmNode(this) != NULL */)
208904 : {
208905 : // Support for regex specification.
208906 : std::string prefixCode = "REGEX:";
208907 : addNewAttribute(prefixCode + s,a);
208908 : }
208909 : #endif
208910 :
208911 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
208912 0 : return this;
208913 : }
208914 :
208915 : // *** COMMON CODE SECTION ENDS HERE ***
208916 :
208917 :
208918 : // End of memberFunctionString
208919 : // Start of memberFunctionString
208920 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
208921 :
208922 :
208923 : #if 0
208924 : //! Error checking support
208925 : /*! Verifies the following:
208926 : - working getVariant() member function
208927 : - calls base class's error() member function
208928 : Every class has one of these functions.
208929 : */
208930 : bool
208931 : SgExecStatement::error()
208932 : {
208933 : // Put error checking here
208934 :
208935 : ROSE_ASSERT (this != NULL);
208936 : if (getVariant() != EXEC_STMT)
208937 : {
208938 : printf ("Error in SgExecStatement::error(): SgExecStatement object has a %s variant \n",
208939 : Cxx_GrammarTerminalNames[getVariant()].name);
208940 : // printf ("Error in SgExecStatement::error() \n");
208941 : ROSE_ABORT();
208942 : }
208943 :
208944 : ROSE_ASSERT (getVariant() == EXEC_STMT);
208945 : return SgStatement::error();
208946 : }
208947 : #endif
208948 :
208949 :
208950 :
208951 : // End of memberFunctionString
208952 :
208953 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
208954 :
208955 0 : SgExecStatement* isSgExecStatement ( SgNode* inputDerivedClassPointer )
208956 : {
208957 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
208958 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
208959 : // So to fix this we return NULL directly when the input is NULL and avoid the
208960 : // dynamic_cast in this case. This is likely a performance improvement as well.
208961 : // return dynamic_cast<SgExecStatement*>(inputDerivedClassPointer);
208962 : // Milind Chabbi (8/28/2013): isSgExecStatement uses table-driven castability instead of c++ default dynamic_cast
208963 : // this improves the running time performance by 10-20%.
208964 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExecStatement*>(inputDerivedClassPointer);
208965 0 : return IS_SgExecStatement_FAST_MACRO(inputDerivedClassPointer);
208966 : }
208967 :
208968 : // DQ (11/8/2003): Added version of functions taking const pointer
208969 0 : const SgExecStatement* isSgExecStatement ( const SgNode* inputDerivedClassPointer )
208970 : {
208971 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
208972 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
208973 : // So to fix this we return NULL directly when the input is NULL and avoid the
208974 : // dynamic_cast in this case. This is likely a performance improvement as well.
208975 : // return dynamic_cast<const SgExecStatement*>(inputDerivedClassPointer);
208976 : // Milind Chabbi (8/28/2013): isSgExecStatement uses table-driven castability instead of c++ default dynamic_cast
208977 : // this improves the running time performance by 10-20%.
208978 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExecStatement*>(inputDerivedClassPointer);
208979 0 : return IS_SgExecStatement_FAST_MACRO(inputDerivedClassPointer);
208980 : }
208981 :
208982 :
208983 :
208984 : /* #line 208985 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
208985 :
208986 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
208987 :
208988 : /**
208989 : \brief Generated destructor
208990 :
208991 : This destructor is automatically generated (by ROSETTA). This destructor
208992 : only frees memory of data members associated with the parts of the current IR node which
208993 : are NOT traversed. Those data members that are part of a traversal can be freed using
208994 : a traversal (calling this destructor on all children in a post-order traversal). Such
208995 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
208996 :
208997 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
208998 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
208999 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
209000 :
209001 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
209002 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
209003 : pointers are not yet implemented to call delete on eash pointer in the container.
209004 : (This could be done by derivation from the STL containers to define containers that
209005 : automatically deleted their members.)
209006 :
209007 : */
209008 0 : SgExecStatement::~SgExecStatement () {
209009 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
209010 :
209011 :
209012 : // case: not a listType for executable
209013 0 : p_executable = NULL; // non list case
209014 : // case: not a listType for globals
209015 0 : p_globals = NULL; // non list case
209016 : // case: not a listType for locals
209017 0 : p_locals = NULL; // non list case
209018 :
209019 : }
209020 :
209021 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
209022 0 : }
209023 :
209024 :
209025 : /* #line 209026 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209026 :
209027 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
209028 :
209029 : // Generated constructor
209030 0 : SgExecStatement::SgExecStatement ( Sg_File_Info* startOfConstruct, SgExpression* executable, SgExpression* globals, SgExpression* locals )
209031 0 : : SgStatement(startOfConstruct)
209032 : {
209033 : #ifdef DEBUG
209034 : // printf ("In SgExecStatement::SgExecStatement (Sg_File_Info* startOfConstruct, SgExpression* executable, SgExpression* globals, SgExpression* locals) sage_class_name() = %s \n",sage_class_name());
209035 : #endif
209036 : #if 0
209037 : // debugging information!
209038 : printf ("In SgExecStatement::SgExecStatement (Sg_File_Info* startOfConstruct, SgExpression* executable, SgExpression* globals, SgExpression* locals): this = %p = %s \n",this,this->class_name().c_str());
209039 : #endif
209040 :
209041 0 : p_executable = executable;
209042 0 : p_globals = globals;
209043 0 : p_locals = locals;
209044 :
209045 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
209046 :
209047 : #if 0
209048 : // DQ (7/30/2014): Call a virtual function.
209049 : std::string s = this->class_name();
209050 : #endif
209051 :
209052 : // Test the variant virtual function
209053 : // assert(EXEC_STMT == variant());
209054 0 : assert(EXEC_STMT == this->variant());
209055 0 : ROSE_ASSERT(EXEC_STMT == (int)(this->variantT()));
209056 0 : post_construction_initialization();
209057 :
209058 : // Test the isSgExecStatement() function since it has been problematic
209059 0 : assert(isSgExecStatement(this) != NULL);
209060 0 : }
209061 :
209062 : // Generated constructor (all data members)
209063 :
209064 : /* #line 209065 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209065 :
209066 :
209067 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
209068 :
209069 :
209070 : // ********************************************************
209071 : // member functions common across all array grammar objects
209072 : // ********************************************************
209073 :
209074 :
209075 :
209076 : /* #line 209077 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209077 :
209078 :
209079 :
209080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
209081 :
209082 : // ********************************************************
209083 : // member functions specific to each node in the grammar
209084 : // ********************************************************
209085 :
209086 :
209087 : /* #line 209088 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209088 :
209089 : // Start of memberFunctionString
209090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
209091 :
209092 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
209093 :
209094 : SgImageControlStatement::image_control_statement_enum
209095 0 : SgImageControlStatement::get_image_control_statement () const
209096 : {
209097 0 : ROSE_ASSERT (this != NULL);
209098 :
209099 : #if 0
209100 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209101 : // used to trigger marking transformations for the token-based unparsing.
209102 : printf ("SgImageControlStatement::get_image_control_statement = %p = %s \n",this,this->class_name().c_str());
209103 : #endif
209104 :
209105 0 : return p_image_control_statement;
209106 : }
209107 :
209108 : void
209109 0 : SgImageControlStatement::set_image_control_statement ( SgImageControlStatement::image_control_statement_enum image_control_statement )
209110 : {
209111 0 : ROSE_ASSERT (this != NULL);
209112 :
209113 : #if 0
209114 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209115 : // used to trigger marking transformations for the token-based unparsing.
209116 : printf ("SgImageControlStatement::set_image_control_statement = %p = %s \n",this,this->class_name().c_str());
209117 : #endif
209118 :
209119 0 : set_isModified(true);
209120 :
209121 0 : p_image_control_statement = image_control_statement;
209122 0 : }
209123 :
209124 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
209125 :
209126 :
209127 : // End of memberFunctionString
209128 : // Start of memberFunctionString
209129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
209130 :
209131 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
209132 :
209133 : SgExpression*
209134 0 : SgImageControlStatement::get_stat () const
209135 : {
209136 0 : ROSE_ASSERT (this != NULL);
209137 :
209138 : #if 0
209139 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209140 : // used to trigger marking transformations for the token-based unparsing.
209141 : printf ("SgImageControlStatement::get_stat = %p = %s \n",this,this->class_name().c_str());
209142 : #endif
209143 :
209144 0 : return p_stat;
209145 : }
209146 :
209147 : void
209148 0 : SgImageControlStatement::set_stat ( SgExpression* stat )
209149 : {
209150 0 : ROSE_ASSERT (this != NULL);
209151 :
209152 : #if 0
209153 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209154 : // used to trigger marking transformations for the token-based unparsing.
209155 : printf ("SgImageControlStatement::set_stat = %p = %s \n",this,this->class_name().c_str());
209156 : #endif
209157 :
209158 0 : set_isModified(true);
209159 :
209160 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
209161 : if (p_stat != NULL && stat != NULL && p_stat != stat)
209162 : {
209163 : printf ("Warning: stat = %p overwriting valid pointer p_stat = %p \n",stat,p_stat);
209164 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
209165 : printf ("Error fails assertion (p_stat != NULL && stat != NULL && p_stat != stat) is false\n");
209166 : ROSE_ASSERT(false);
209167 : #endif
209168 : }
209169 : #endif
209170 0 : p_stat = stat;
209171 0 : }
209172 :
209173 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
209174 :
209175 :
209176 : // End of memberFunctionString
209177 : // Start of memberFunctionString
209178 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
209179 :
209180 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
209181 :
209182 : SgExpression*
209183 0 : SgImageControlStatement::get_err_msg () const
209184 : {
209185 0 : ROSE_ASSERT (this != NULL);
209186 :
209187 : #if 0
209188 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209189 : // used to trigger marking transformations for the token-based unparsing.
209190 : printf ("SgImageControlStatement::get_err_msg = %p = %s \n",this,this->class_name().c_str());
209191 : #endif
209192 :
209193 0 : return p_err_msg;
209194 : }
209195 :
209196 : void
209197 0 : SgImageControlStatement::set_err_msg ( SgExpression* err_msg )
209198 : {
209199 0 : ROSE_ASSERT (this != NULL);
209200 :
209201 : #if 0
209202 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209203 : // used to trigger marking transformations for the token-based unparsing.
209204 : printf ("SgImageControlStatement::set_err_msg = %p = %s \n",this,this->class_name().c_str());
209205 : #endif
209206 :
209207 0 : set_isModified(true);
209208 :
209209 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
209210 : if (p_err_msg != NULL && err_msg != NULL && p_err_msg != err_msg)
209211 : {
209212 : printf ("Warning: err_msg = %p overwriting valid pointer p_err_msg = %p \n",err_msg,p_err_msg);
209213 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
209214 : printf ("Error fails assertion (p_err_msg != NULL && err_msg != NULL && p_err_msg != err_msg) is false\n");
209215 : ROSE_ASSERT(false);
209216 : #endif
209217 : }
209218 : #endif
209219 0 : p_err_msg = err_msg;
209220 0 : }
209221 :
209222 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
209223 :
209224 :
209225 : // End of memberFunctionString
209226 : // Start of memberFunctionString
209227 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
209228 :
209229 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
209230 :
209231 : SgExpression*
209232 0 : SgImageControlStatement::get_acquired_lock () const
209233 : {
209234 0 : ROSE_ASSERT (this != NULL);
209235 :
209236 : #if 0
209237 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209238 : // used to trigger marking transformations for the token-based unparsing.
209239 : printf ("SgImageControlStatement::get_acquired_lock = %p = %s \n",this,this->class_name().c_str());
209240 : #endif
209241 :
209242 0 : return p_acquired_lock;
209243 : }
209244 :
209245 : void
209246 0 : SgImageControlStatement::set_acquired_lock ( SgExpression* acquired_lock )
209247 : {
209248 0 : ROSE_ASSERT (this != NULL);
209249 :
209250 : #if 0
209251 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209252 : // used to trigger marking transformations for the token-based unparsing.
209253 : printf ("SgImageControlStatement::set_acquired_lock = %p = %s \n",this,this->class_name().c_str());
209254 : #endif
209255 :
209256 0 : set_isModified(true);
209257 :
209258 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
209259 : if (p_acquired_lock != NULL && acquired_lock != NULL && p_acquired_lock != acquired_lock)
209260 : {
209261 : printf ("Warning: acquired_lock = %p overwriting valid pointer p_acquired_lock = %p \n",acquired_lock,p_acquired_lock);
209262 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
209263 : printf ("Error fails assertion (p_acquired_lock != NULL && acquired_lock != NULL && p_acquired_lock != acquired_lock) is false\n");
209264 : ROSE_ASSERT(false);
209265 : #endif
209266 : }
209267 : #endif
209268 0 : p_acquired_lock = acquired_lock;
209269 0 : }
209270 :
209271 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
209272 :
209273 :
209274 : // End of memberFunctionString
209275 : // Start of memberFunctionString
209276 : /* #line 18302 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
209277 :
209278 :
209279 : void
209280 0 : SgImageControlStatement::post_construction_initialization()
209281 0 : {}
209282 :
209283 :
209284 :
209285 : // End of memberFunctionString
209286 : // Start of memberFunctionString
209287 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
209288 :
209289 : // *** COMMON CODE SECTION BEGINS HERE ***
209290 :
209291 : #if 0
209292 : int
209293 : SgImageControlStatement::getVariant() const
209294 : {
209295 : // This function is used in ROSE while "variant()" is used in SAGE
209296 : assert(this != NULL);
209297 : return variant();
209298 : }
209299 : #endif
209300 :
209301 : // This function is used in ROSE in treeTraversal code
209302 : // eventually replaces getVariant() and variant()
209303 : // though after variant() has been removed for a while we will
209304 : // want to change the name of variantT() back to variant()
209305 : // (since the "T" was ment to stand for temporary).
209306 : // When this happens the variantT() will be depricated.
209307 : VariantT
209308 0 : SgImageControlStatement::variantT() const
209309 : {
209310 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
209311 0 : ROSE_ASSERT(this != NULL);
209312 0 : return V_SgImageControlStatement;
209313 : }
209314 :
209315 : #if 0
209316 : int
209317 : SgImageControlStatement::variant() const
209318 : {
209319 : // This function is used in SAGE
209320 : ROSE_ASSERT(this != NULL);
209321 : return IMAGE_CONTROL_STATEMENT;
209322 : }
209323 : #endif
209324 :
209325 : ROSE_DLL_API const char*
209326 0 : SgImageControlStatement::sage_class_name() const
209327 : {
209328 0 : ROSE_ASSERT(this != NULL);
209329 0 : return "SgImageControlStatement";
209330 : }
209331 :
209332 : std::string
209333 0 : SgImageControlStatement::class_name() const
209334 : {
209335 0 : ROSE_ASSERT(this != NULL);
209336 0 : return "SgImageControlStatement";
209337 : }
209338 :
209339 : // DQ (11/26/2005): Support for visitor pattern mechanims
209340 : // (inferior to ROSE traversal mechanism, experimental).
209341 : void
209342 0 : SgImageControlStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
209343 : {
209344 0 : ROSE_ASSERT(this != NULL);
209345 0 : visitor.visit(this);
209346 0 : }
209347 :
209348 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
209349 0 : void SgImageControlStatement::accept (ROSE_VisitorPattern & visitor) {
209350 0 : ROSE_ASSERT(this != NULL);
209351 0 : visitor.visit(this);
209352 0 : }
209353 :
209354 : SgImageControlStatement*
209355 0 : SgImageControlStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
209356 : {
209357 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
209358 : // This function is currently only supported for the AST used the represent Binary executables.
209359 : if (0 /* isSgAsmNode(this) != NULL */)
209360 : {
209361 : // Support for regex specification.
209362 : std::string prefixCode = "REGEX:";
209363 : addNewAttribute(prefixCode + s,a);
209364 : }
209365 : #endif
209366 :
209367 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
209368 0 : return this;
209369 : }
209370 :
209371 : // *** COMMON CODE SECTION ENDS HERE ***
209372 :
209373 :
209374 : // End of memberFunctionString
209375 : // Start of memberFunctionString
209376 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
209377 :
209378 :
209379 : #if 0
209380 : //! Error checking support
209381 : /*! Verifies the following:
209382 : - working getVariant() member function
209383 : - calls base class's error() member function
209384 : Every class has one of these functions.
209385 : */
209386 : bool
209387 : SgImageControlStatement::error()
209388 : {
209389 : // Put error checking here
209390 :
209391 : ROSE_ASSERT (this != NULL);
209392 : if (getVariant() != IMAGE_CONTROL_STATEMENT)
209393 : {
209394 : printf ("Error in SgImageControlStatement::error(): SgImageControlStatement object has a %s variant \n",
209395 : Cxx_GrammarTerminalNames[getVariant()].name);
209396 : // printf ("Error in SgImageControlStatement::error() \n");
209397 : ROSE_ABORT();
209398 : }
209399 :
209400 : ROSE_ASSERT (getVariant() == IMAGE_CONTROL_STATEMENT);
209401 : return SgStatement::error();
209402 : }
209403 : #endif
209404 :
209405 :
209406 :
209407 : // End of memberFunctionString
209408 :
209409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
209410 :
209411 0 : SgImageControlStatement* isSgImageControlStatement ( SgNode* inputDerivedClassPointer )
209412 : {
209413 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
209414 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
209415 : // So to fix this we return NULL directly when the input is NULL and avoid the
209416 : // dynamic_cast in this case. This is likely a performance improvement as well.
209417 : // return dynamic_cast<SgImageControlStatement*>(inputDerivedClassPointer);
209418 : // Milind Chabbi (8/28/2013): isSgImageControlStatement uses table-driven castability instead of c++ default dynamic_cast
209419 : // this improves the running time performance by 10-20%.
209420 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgImageControlStatement*>(inputDerivedClassPointer);
209421 0 : return IS_SgImageControlStatement_FAST_MACRO(inputDerivedClassPointer);
209422 : }
209423 :
209424 : // DQ (11/8/2003): Added version of functions taking const pointer
209425 0 : const SgImageControlStatement* isSgImageControlStatement ( const SgNode* inputDerivedClassPointer )
209426 : {
209427 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
209428 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
209429 : // So to fix this we return NULL directly when the input is NULL and avoid the
209430 : // dynamic_cast in this case. This is likely a performance improvement as well.
209431 : // return dynamic_cast<const SgImageControlStatement*>(inputDerivedClassPointer);
209432 : // Milind Chabbi (8/28/2013): isSgImageControlStatement uses table-driven castability instead of c++ default dynamic_cast
209433 : // this improves the running time performance by 10-20%.
209434 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgImageControlStatement*>(inputDerivedClassPointer);
209435 0 : return IS_SgImageControlStatement_FAST_MACRO(inputDerivedClassPointer);
209436 : }
209437 :
209438 :
209439 :
209440 : /* #line 209441 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209441 :
209442 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
209443 :
209444 : /**
209445 : \brief Generated destructor
209446 :
209447 : This destructor is automatically generated (by ROSETTA). This destructor
209448 : only frees memory of data members associated with the parts of the current IR node which
209449 : are NOT traversed. Those data members that are part of a traversal can be freed using
209450 : a traversal (calling this destructor on all children in a post-order traversal). Such
209451 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
209452 :
209453 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
209454 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
209455 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
209456 :
209457 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
209458 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
209459 : pointers are not yet implemented to call delete on eash pointer in the container.
209460 : (This could be done by derivation from the STL containers to define containers that
209461 : automatically deleted their members.)
209462 :
209463 : */
209464 0 : SgImageControlStatement::~SgImageControlStatement () {
209465 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
209466 :
209467 :
209468 : // case: not a listType for image_control_statement
209469 0 : p_image_control_statement = SgImageControlStatement::e_unknown; // non list case
209470 : // case: not a listType for stat
209471 0 : p_stat = NULL; // non list case
209472 : // case: not a listType for err_msg
209473 0 : p_err_msg = NULL; // non list case
209474 : // case: not a listType for acquired_lock
209475 0 : p_acquired_lock = NULL; // non list case
209476 :
209477 : }
209478 :
209479 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
209480 0 : }
209481 :
209482 :
209483 : /* #line 209484 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209484 :
209485 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
209486 :
209487 : // Generated constructor
209488 0 : SgImageControlStatement::SgImageControlStatement ( Sg_File_Info* startOfConstruct )
209489 0 : : SgStatement(startOfConstruct)
209490 : {
209491 : #ifdef DEBUG
209492 : // printf ("In SgImageControlStatement::SgImageControlStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
209493 : #endif
209494 : #if 0
209495 : // debugging information!
209496 : printf ("In SgImageControlStatement::SgImageControlStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
209497 : #endif
209498 :
209499 0 : p_image_control_statement = SgImageControlStatement::e_unknown;
209500 0 : p_stat = NULL;
209501 0 : p_err_msg = NULL;
209502 0 : p_acquired_lock = NULL;
209503 :
209504 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
209505 :
209506 : #if 0
209507 : // DQ (7/30/2014): Call a virtual function.
209508 : std::string s = this->class_name();
209509 : #endif
209510 :
209511 : // Test the variant virtual function
209512 : // assert(IMAGE_CONTROL_STATEMENT == variant());
209513 0 : assert(IMAGE_CONTROL_STATEMENT == this->variant());
209514 0 : ROSE_ASSERT(IMAGE_CONTROL_STATEMENT == (int)(this->variantT()));
209515 0 : post_construction_initialization();
209516 :
209517 : // Test the isSgImageControlStatement() function since it has been problematic
209518 0 : assert(isSgImageControlStatement(this) != NULL);
209519 0 : }
209520 :
209521 : // Generated constructor (all data members)
209522 :
209523 : /* #line 209524 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209524 :
209525 :
209526 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
209527 :
209528 :
209529 : // ********************************************************
209530 : // member functions common across all array grammar objects
209531 : // ********************************************************
209532 :
209533 :
209534 :
209535 : /* #line 209536 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209536 :
209537 :
209538 :
209539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
209540 :
209541 : // ********************************************************
209542 : // member functions specific to each node in the grammar
209543 : // ********************************************************
209544 :
209545 :
209546 : /* #line 209547 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209547 :
209548 : // Start of memberFunctionString
209549 : /* #line 18310 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
209550 :
209551 :
209552 : void
209553 0 : SgSyncAllStatement::post_construction_initialization()
209554 0 : {}
209555 :
209556 :
209557 :
209558 : // End of memberFunctionString
209559 : // Start of memberFunctionString
209560 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
209561 :
209562 : // *** COMMON CODE SECTION BEGINS HERE ***
209563 :
209564 : #if 0
209565 : int
209566 : SgSyncAllStatement::getVariant() const
209567 : {
209568 : // This function is used in ROSE while "variant()" is used in SAGE
209569 : assert(this != NULL);
209570 : return variant();
209571 : }
209572 : #endif
209573 :
209574 : // This function is used in ROSE in treeTraversal code
209575 : // eventually replaces getVariant() and variant()
209576 : // though after variant() has been removed for a while we will
209577 : // want to change the name of variantT() back to variant()
209578 : // (since the "T" was ment to stand for temporary).
209579 : // When this happens the variantT() will be depricated.
209580 : VariantT
209581 0 : SgSyncAllStatement::variantT() const
209582 : {
209583 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
209584 0 : ROSE_ASSERT(this != NULL);
209585 0 : return V_SgSyncAllStatement;
209586 : }
209587 :
209588 : #if 0
209589 : int
209590 : SgSyncAllStatement::variant() const
209591 : {
209592 : // This function is used in SAGE
209593 : ROSE_ASSERT(this != NULL);
209594 : return SYNC_ALL_STATEMENT;
209595 : }
209596 : #endif
209597 :
209598 : ROSE_DLL_API const char*
209599 0 : SgSyncAllStatement::sage_class_name() const
209600 : {
209601 0 : ROSE_ASSERT(this != NULL);
209602 0 : return "SgSyncAllStatement";
209603 : }
209604 :
209605 : std::string
209606 0 : SgSyncAllStatement::class_name() const
209607 : {
209608 0 : ROSE_ASSERT(this != NULL);
209609 0 : return "SgSyncAllStatement";
209610 : }
209611 :
209612 : // DQ (11/26/2005): Support for visitor pattern mechanims
209613 : // (inferior to ROSE traversal mechanism, experimental).
209614 : void
209615 0 : SgSyncAllStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
209616 : {
209617 0 : ROSE_ASSERT(this != NULL);
209618 0 : visitor.visit(this);
209619 0 : }
209620 :
209621 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
209622 0 : void SgSyncAllStatement::accept (ROSE_VisitorPattern & visitor) {
209623 0 : ROSE_ASSERT(this != NULL);
209624 0 : visitor.visit(this);
209625 0 : }
209626 :
209627 : SgSyncAllStatement*
209628 0 : SgSyncAllStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
209629 : {
209630 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
209631 : // This function is currently only supported for the AST used the represent Binary executables.
209632 : if (0 /* isSgAsmNode(this) != NULL */)
209633 : {
209634 : // Support for regex specification.
209635 : std::string prefixCode = "REGEX:";
209636 : addNewAttribute(prefixCode + s,a);
209637 : }
209638 : #endif
209639 :
209640 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
209641 0 : return this;
209642 : }
209643 :
209644 : // *** COMMON CODE SECTION ENDS HERE ***
209645 :
209646 :
209647 : // End of memberFunctionString
209648 : // Start of memberFunctionString
209649 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
209650 :
209651 :
209652 : #if 0
209653 : //! Error checking support
209654 : /*! Verifies the following:
209655 : - working getVariant() member function
209656 : - calls base class's error() member function
209657 : Every class has one of these functions.
209658 : */
209659 : bool
209660 : SgSyncAllStatement::error()
209661 : {
209662 : // Put error checking here
209663 :
209664 : ROSE_ASSERT (this != NULL);
209665 : if (getVariant() != SYNC_ALL_STATEMENT)
209666 : {
209667 : printf ("Error in SgSyncAllStatement::error(): SgSyncAllStatement object has a %s variant \n",
209668 : Cxx_GrammarTerminalNames[getVariant()].name);
209669 : // printf ("Error in SgSyncAllStatement::error() \n");
209670 : ROSE_ABORT();
209671 : }
209672 :
209673 : ROSE_ASSERT (getVariant() == SYNC_ALL_STATEMENT);
209674 : return SgImageControlStatement::error();
209675 : }
209676 : #endif
209677 :
209678 :
209679 :
209680 : // End of memberFunctionString
209681 :
209682 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
209683 :
209684 0 : SgSyncAllStatement* isSgSyncAllStatement ( SgNode* inputDerivedClassPointer )
209685 : {
209686 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
209687 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
209688 : // So to fix this we return NULL directly when the input is NULL and avoid the
209689 : // dynamic_cast in this case. This is likely a performance improvement as well.
209690 : // return dynamic_cast<SgSyncAllStatement*>(inputDerivedClassPointer);
209691 : // Milind Chabbi (8/28/2013): isSgSyncAllStatement uses table-driven castability instead of c++ default dynamic_cast
209692 : // this improves the running time performance by 10-20%.
209693 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSyncAllStatement*>(inputDerivedClassPointer);
209694 0 : return IS_SgSyncAllStatement_FAST_MACRO(inputDerivedClassPointer);
209695 : }
209696 :
209697 : // DQ (11/8/2003): Added version of functions taking const pointer
209698 0 : const SgSyncAllStatement* isSgSyncAllStatement ( const SgNode* inputDerivedClassPointer )
209699 : {
209700 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
209701 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
209702 : // So to fix this we return NULL directly when the input is NULL and avoid the
209703 : // dynamic_cast in this case. This is likely a performance improvement as well.
209704 : // return dynamic_cast<const SgSyncAllStatement*>(inputDerivedClassPointer);
209705 : // Milind Chabbi (8/28/2013): isSgSyncAllStatement uses table-driven castability instead of c++ default dynamic_cast
209706 : // this improves the running time performance by 10-20%.
209707 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSyncAllStatement*>(inputDerivedClassPointer);
209708 0 : return IS_SgSyncAllStatement_FAST_MACRO(inputDerivedClassPointer);
209709 : }
209710 :
209711 :
209712 :
209713 : /* #line 209714 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209714 :
209715 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
209716 :
209717 : /**
209718 : \brief Generated destructor
209719 :
209720 : This destructor is automatically generated (by ROSETTA). This destructor
209721 : only frees memory of data members associated with the parts of the current IR node which
209722 : are NOT traversed. Those data members that are part of a traversal can be freed using
209723 : a traversal (calling this destructor on all children in a post-order traversal). Such
209724 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
209725 :
209726 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
209727 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
209728 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
209729 :
209730 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
209731 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
209732 : pointers are not yet implemented to call delete on eash pointer in the container.
209733 : (This could be done by derivation from the STL containers to define containers that
209734 : automatically deleted their members.)
209735 :
209736 : */
209737 0 : SgSyncAllStatement::~SgSyncAllStatement () {
209738 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
209739 :
209740 :
209741 :
209742 : }
209743 :
209744 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
209745 0 : }
209746 :
209747 :
209748 : /* #line 209749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209749 :
209750 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
209751 :
209752 : // Generated constructor
209753 0 : SgSyncAllStatement::SgSyncAllStatement ( Sg_File_Info* startOfConstruct )
209754 0 : : SgImageControlStatement(startOfConstruct)
209755 : {
209756 : #ifdef DEBUG
209757 : // printf ("In SgSyncAllStatement::SgSyncAllStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
209758 : #endif
209759 : #if 0
209760 : // debugging information!
209761 : printf ("In SgSyncAllStatement::SgSyncAllStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
209762 : #endif
209763 :
209764 :
209765 :
209766 : #if 0
209767 : // DQ (7/30/2014): Call a virtual function.
209768 : std::string s = this->class_name();
209769 : #endif
209770 :
209771 : // Test the variant virtual function
209772 : // assert(SYNC_ALL_STATEMENT == variant());
209773 0 : assert(SYNC_ALL_STATEMENT == this->variant());
209774 0 : ROSE_ASSERT(SYNC_ALL_STATEMENT == (int)(this->variantT()));
209775 0 : post_construction_initialization();
209776 :
209777 : // Test the isSgSyncAllStatement() function since it has been problematic
209778 0 : assert(isSgSyncAllStatement(this) != NULL);
209779 0 : }
209780 :
209781 : // Generated constructor (all data members)
209782 :
209783 : /* #line 209784 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209784 :
209785 :
209786 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
209787 :
209788 :
209789 : // ********************************************************
209790 : // member functions common across all array grammar objects
209791 : // ********************************************************
209792 :
209793 :
209794 :
209795 : /* #line 209796 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209796 :
209797 :
209798 :
209799 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
209800 :
209801 : // ********************************************************
209802 : // member functions specific to each node in the grammar
209803 : // ********************************************************
209804 :
209805 :
209806 : /* #line 209807 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
209807 :
209808 : // Start of memberFunctionString
209809 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
209810 :
209811 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
209812 :
209813 : SgExpression*
209814 0 : SgSyncImagesStatement::get_image_set () const
209815 : {
209816 0 : ROSE_ASSERT (this != NULL);
209817 :
209818 : #if 0
209819 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209820 : // used to trigger marking transformations for the token-based unparsing.
209821 : printf ("SgSyncImagesStatement::get_image_set = %p = %s \n",this,this->class_name().c_str());
209822 : #endif
209823 :
209824 0 : return p_image_set;
209825 : }
209826 :
209827 : void
209828 0 : SgSyncImagesStatement::set_image_set ( SgExpression* image_set )
209829 : {
209830 0 : ROSE_ASSERT (this != NULL);
209831 :
209832 : #if 0
209833 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
209834 : // used to trigger marking transformations for the token-based unparsing.
209835 : printf ("SgSyncImagesStatement::set_image_set = %p = %s \n",this,this->class_name().c_str());
209836 : #endif
209837 :
209838 0 : set_isModified(true);
209839 :
209840 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
209841 : if (p_image_set != NULL && image_set != NULL && p_image_set != image_set)
209842 : {
209843 : printf ("Warning: image_set = %p overwriting valid pointer p_image_set = %p \n",image_set,p_image_set);
209844 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
209845 : printf ("Error fails assertion (p_image_set != NULL && image_set != NULL && p_image_set != image_set) is false\n");
209846 : ROSE_ASSERT(false);
209847 : #endif
209848 : }
209849 : #endif
209850 0 : p_image_set = image_set;
209851 0 : }
209852 :
209853 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
209854 :
209855 :
209856 : // End of memberFunctionString
209857 : // Start of memberFunctionString
209858 : /* #line 18318 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
209859 :
209860 :
209861 : void
209862 0 : SgSyncImagesStatement::post_construction_initialization()
209863 0 : {}
209864 :
209865 :
209866 :
209867 : // End of memberFunctionString
209868 : // Start of memberFunctionString
209869 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
209870 :
209871 : // *** COMMON CODE SECTION BEGINS HERE ***
209872 :
209873 : #if 0
209874 : int
209875 : SgSyncImagesStatement::getVariant() const
209876 : {
209877 : // This function is used in ROSE while "variant()" is used in SAGE
209878 : assert(this != NULL);
209879 : return variant();
209880 : }
209881 : #endif
209882 :
209883 : // This function is used in ROSE in treeTraversal code
209884 : // eventually replaces getVariant() and variant()
209885 : // though after variant() has been removed for a while we will
209886 : // want to change the name of variantT() back to variant()
209887 : // (since the "T" was ment to stand for temporary).
209888 : // When this happens the variantT() will be depricated.
209889 : VariantT
209890 0 : SgSyncImagesStatement::variantT() const
209891 : {
209892 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
209893 0 : ROSE_ASSERT(this != NULL);
209894 0 : return V_SgSyncImagesStatement;
209895 : }
209896 :
209897 : #if 0
209898 : int
209899 : SgSyncImagesStatement::variant() const
209900 : {
209901 : // This function is used in SAGE
209902 : ROSE_ASSERT(this != NULL);
209903 : return SYNC_IMAGES_STATEMENT;
209904 : }
209905 : #endif
209906 :
209907 : ROSE_DLL_API const char*
209908 0 : SgSyncImagesStatement::sage_class_name() const
209909 : {
209910 0 : ROSE_ASSERT(this != NULL);
209911 0 : return "SgSyncImagesStatement";
209912 : }
209913 :
209914 : std::string
209915 0 : SgSyncImagesStatement::class_name() const
209916 : {
209917 0 : ROSE_ASSERT(this != NULL);
209918 0 : return "SgSyncImagesStatement";
209919 : }
209920 :
209921 : // DQ (11/26/2005): Support for visitor pattern mechanims
209922 : // (inferior to ROSE traversal mechanism, experimental).
209923 : void
209924 0 : SgSyncImagesStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
209925 : {
209926 0 : ROSE_ASSERT(this != NULL);
209927 0 : visitor.visit(this);
209928 0 : }
209929 :
209930 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
209931 0 : void SgSyncImagesStatement::accept (ROSE_VisitorPattern & visitor) {
209932 0 : ROSE_ASSERT(this != NULL);
209933 0 : visitor.visit(this);
209934 0 : }
209935 :
209936 : SgSyncImagesStatement*
209937 0 : SgSyncImagesStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
209938 : {
209939 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
209940 : // This function is currently only supported for the AST used the represent Binary executables.
209941 : if (0 /* isSgAsmNode(this) != NULL */)
209942 : {
209943 : // Support for regex specification.
209944 : std::string prefixCode = "REGEX:";
209945 : addNewAttribute(prefixCode + s,a);
209946 : }
209947 : #endif
209948 :
209949 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
209950 0 : return this;
209951 : }
209952 :
209953 : // *** COMMON CODE SECTION ENDS HERE ***
209954 :
209955 :
209956 : // End of memberFunctionString
209957 : // Start of memberFunctionString
209958 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
209959 :
209960 :
209961 : #if 0
209962 : //! Error checking support
209963 : /*! Verifies the following:
209964 : - working getVariant() member function
209965 : - calls base class's error() member function
209966 : Every class has one of these functions.
209967 : */
209968 : bool
209969 : SgSyncImagesStatement::error()
209970 : {
209971 : // Put error checking here
209972 :
209973 : ROSE_ASSERT (this != NULL);
209974 : if (getVariant() != SYNC_IMAGES_STATEMENT)
209975 : {
209976 : printf ("Error in SgSyncImagesStatement::error(): SgSyncImagesStatement object has a %s variant \n",
209977 : Cxx_GrammarTerminalNames[getVariant()].name);
209978 : // printf ("Error in SgSyncImagesStatement::error() \n");
209979 : ROSE_ABORT();
209980 : }
209981 :
209982 : ROSE_ASSERT (getVariant() == SYNC_IMAGES_STATEMENT);
209983 : return SgImageControlStatement::error();
209984 : }
209985 : #endif
209986 :
209987 :
209988 :
209989 : // End of memberFunctionString
209990 :
209991 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
209992 :
209993 0 : SgSyncImagesStatement* isSgSyncImagesStatement ( SgNode* inputDerivedClassPointer )
209994 : {
209995 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
209996 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
209997 : // So to fix this we return NULL directly when the input is NULL and avoid the
209998 : // dynamic_cast in this case. This is likely a performance improvement as well.
209999 : // return dynamic_cast<SgSyncImagesStatement*>(inputDerivedClassPointer);
210000 : // Milind Chabbi (8/28/2013): isSgSyncImagesStatement uses table-driven castability instead of c++ default dynamic_cast
210001 : // this improves the running time performance by 10-20%.
210002 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSyncImagesStatement*>(inputDerivedClassPointer);
210003 0 : return IS_SgSyncImagesStatement_FAST_MACRO(inputDerivedClassPointer);
210004 : }
210005 :
210006 : // DQ (11/8/2003): Added version of functions taking const pointer
210007 0 : const SgSyncImagesStatement* isSgSyncImagesStatement ( const SgNode* inputDerivedClassPointer )
210008 : {
210009 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210010 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210011 : // So to fix this we return NULL directly when the input is NULL and avoid the
210012 : // dynamic_cast in this case. This is likely a performance improvement as well.
210013 : // return dynamic_cast<const SgSyncImagesStatement*>(inputDerivedClassPointer);
210014 : // Milind Chabbi (8/28/2013): isSgSyncImagesStatement uses table-driven castability instead of c++ default dynamic_cast
210015 : // this improves the running time performance by 10-20%.
210016 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSyncImagesStatement*>(inputDerivedClassPointer);
210017 0 : return IS_SgSyncImagesStatement_FAST_MACRO(inputDerivedClassPointer);
210018 : }
210019 :
210020 :
210021 :
210022 : /* #line 210023 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210023 :
210024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210025 :
210026 : /**
210027 : \brief Generated destructor
210028 :
210029 : This destructor is automatically generated (by ROSETTA). This destructor
210030 : only frees memory of data members associated with the parts of the current IR node which
210031 : are NOT traversed. Those data members that are part of a traversal can be freed using
210032 : a traversal (calling this destructor on all children in a post-order traversal). Such
210033 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
210034 :
210035 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
210036 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
210037 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
210038 :
210039 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
210040 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
210041 : pointers are not yet implemented to call delete on eash pointer in the container.
210042 : (This could be done by derivation from the STL containers to define containers that
210043 : automatically deleted their members.)
210044 :
210045 : */
210046 0 : SgSyncImagesStatement::~SgSyncImagesStatement () {
210047 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
210048 :
210049 :
210050 : // case: not a listType for image_set
210051 0 : p_image_set = NULL; // non list case
210052 :
210053 : }
210054 :
210055 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210056 0 : }
210057 :
210058 :
210059 : /* #line 210060 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210060 :
210061 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210062 :
210063 : // Generated constructor
210064 0 : SgSyncImagesStatement::SgSyncImagesStatement ( Sg_File_Info* startOfConstruct, SgExpression* image_set )
210065 0 : : SgImageControlStatement(startOfConstruct)
210066 : {
210067 : #ifdef DEBUG
210068 : // printf ("In SgSyncImagesStatement::SgSyncImagesStatement (Sg_File_Info* startOfConstruct, SgExpression* image_set) sage_class_name() = %s \n",sage_class_name());
210069 : #endif
210070 : #if 0
210071 : // debugging information!
210072 : printf ("In SgSyncImagesStatement::SgSyncImagesStatement (Sg_File_Info* startOfConstruct, SgExpression* image_set): this = %p = %s \n",this,this->class_name().c_str());
210073 : #endif
210074 :
210075 0 : p_image_set = image_set;
210076 :
210077 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210078 :
210079 : #if 0
210080 : // DQ (7/30/2014): Call a virtual function.
210081 : std::string s = this->class_name();
210082 : #endif
210083 :
210084 : // Test the variant virtual function
210085 : // assert(SYNC_IMAGES_STATEMENT == variant());
210086 0 : assert(SYNC_IMAGES_STATEMENT == this->variant());
210087 0 : ROSE_ASSERT(SYNC_IMAGES_STATEMENT == (int)(this->variantT()));
210088 0 : post_construction_initialization();
210089 :
210090 : // Test the isSgSyncImagesStatement() function since it has been problematic
210091 0 : assert(isSgSyncImagesStatement(this) != NULL);
210092 0 : }
210093 :
210094 : // Generated constructor (all data members)
210095 :
210096 : /* #line 210097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210097 :
210098 :
210099 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210100 :
210101 :
210102 : // ********************************************************
210103 : // member functions common across all array grammar objects
210104 : // ********************************************************
210105 :
210106 :
210107 :
210108 : /* #line 210109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210109 :
210110 :
210111 :
210112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210113 :
210114 : // ********************************************************
210115 : // member functions specific to each node in the grammar
210116 : // ********************************************************
210117 :
210118 :
210119 : /* #line 210120 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210120 :
210121 : // Start of memberFunctionString
210122 : /* #line 18326 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
210123 :
210124 :
210125 : void
210126 0 : SgSyncMemoryStatement::post_construction_initialization()
210127 0 : {}
210128 :
210129 :
210130 :
210131 : // End of memberFunctionString
210132 : // Start of memberFunctionString
210133 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
210134 :
210135 : // *** COMMON CODE SECTION BEGINS HERE ***
210136 :
210137 : #if 0
210138 : int
210139 : SgSyncMemoryStatement::getVariant() const
210140 : {
210141 : // This function is used in ROSE while "variant()" is used in SAGE
210142 : assert(this != NULL);
210143 : return variant();
210144 : }
210145 : #endif
210146 :
210147 : // This function is used in ROSE in treeTraversal code
210148 : // eventually replaces getVariant() and variant()
210149 : // though after variant() has been removed for a while we will
210150 : // want to change the name of variantT() back to variant()
210151 : // (since the "T" was ment to stand for temporary).
210152 : // When this happens the variantT() will be depricated.
210153 : VariantT
210154 0 : SgSyncMemoryStatement::variantT() const
210155 : {
210156 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
210157 0 : ROSE_ASSERT(this != NULL);
210158 0 : return V_SgSyncMemoryStatement;
210159 : }
210160 :
210161 : #if 0
210162 : int
210163 : SgSyncMemoryStatement::variant() const
210164 : {
210165 : // This function is used in SAGE
210166 : ROSE_ASSERT(this != NULL);
210167 : return SYNC_MEMORY_STATEMENT;
210168 : }
210169 : #endif
210170 :
210171 : ROSE_DLL_API const char*
210172 0 : SgSyncMemoryStatement::sage_class_name() const
210173 : {
210174 0 : ROSE_ASSERT(this != NULL);
210175 0 : return "SgSyncMemoryStatement";
210176 : }
210177 :
210178 : std::string
210179 0 : SgSyncMemoryStatement::class_name() const
210180 : {
210181 0 : ROSE_ASSERT(this != NULL);
210182 0 : return "SgSyncMemoryStatement";
210183 : }
210184 :
210185 : // DQ (11/26/2005): Support for visitor pattern mechanims
210186 : // (inferior to ROSE traversal mechanism, experimental).
210187 : void
210188 0 : SgSyncMemoryStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
210189 : {
210190 0 : ROSE_ASSERT(this != NULL);
210191 0 : visitor.visit(this);
210192 0 : }
210193 :
210194 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
210195 0 : void SgSyncMemoryStatement::accept (ROSE_VisitorPattern & visitor) {
210196 0 : ROSE_ASSERT(this != NULL);
210197 0 : visitor.visit(this);
210198 0 : }
210199 :
210200 : SgSyncMemoryStatement*
210201 0 : SgSyncMemoryStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
210202 : {
210203 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
210204 : // This function is currently only supported for the AST used the represent Binary executables.
210205 : if (0 /* isSgAsmNode(this) != NULL */)
210206 : {
210207 : // Support for regex specification.
210208 : std::string prefixCode = "REGEX:";
210209 : addNewAttribute(prefixCode + s,a);
210210 : }
210211 : #endif
210212 :
210213 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
210214 0 : return this;
210215 : }
210216 :
210217 : // *** COMMON CODE SECTION ENDS HERE ***
210218 :
210219 :
210220 : // End of memberFunctionString
210221 : // Start of memberFunctionString
210222 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
210223 :
210224 :
210225 : #if 0
210226 : //! Error checking support
210227 : /*! Verifies the following:
210228 : - working getVariant() member function
210229 : - calls base class's error() member function
210230 : Every class has one of these functions.
210231 : */
210232 : bool
210233 : SgSyncMemoryStatement::error()
210234 : {
210235 : // Put error checking here
210236 :
210237 : ROSE_ASSERT (this != NULL);
210238 : if (getVariant() != SYNC_MEMORY_STATEMENT)
210239 : {
210240 : printf ("Error in SgSyncMemoryStatement::error(): SgSyncMemoryStatement object has a %s variant \n",
210241 : Cxx_GrammarTerminalNames[getVariant()].name);
210242 : // printf ("Error in SgSyncMemoryStatement::error() \n");
210243 : ROSE_ABORT();
210244 : }
210245 :
210246 : ROSE_ASSERT (getVariant() == SYNC_MEMORY_STATEMENT);
210247 : return SgImageControlStatement::error();
210248 : }
210249 : #endif
210250 :
210251 :
210252 :
210253 : // End of memberFunctionString
210254 :
210255 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
210256 :
210257 0 : SgSyncMemoryStatement* isSgSyncMemoryStatement ( SgNode* inputDerivedClassPointer )
210258 : {
210259 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210260 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210261 : // So to fix this we return NULL directly when the input is NULL and avoid the
210262 : // dynamic_cast in this case. This is likely a performance improvement as well.
210263 : // return dynamic_cast<SgSyncMemoryStatement*>(inputDerivedClassPointer);
210264 : // Milind Chabbi (8/28/2013): isSgSyncMemoryStatement uses table-driven castability instead of c++ default dynamic_cast
210265 : // this improves the running time performance by 10-20%.
210266 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSyncMemoryStatement*>(inputDerivedClassPointer);
210267 0 : return IS_SgSyncMemoryStatement_FAST_MACRO(inputDerivedClassPointer);
210268 : }
210269 :
210270 : // DQ (11/8/2003): Added version of functions taking const pointer
210271 0 : const SgSyncMemoryStatement* isSgSyncMemoryStatement ( const SgNode* inputDerivedClassPointer )
210272 : {
210273 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210274 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210275 : // So to fix this we return NULL directly when the input is NULL and avoid the
210276 : // dynamic_cast in this case. This is likely a performance improvement as well.
210277 : // return dynamic_cast<const SgSyncMemoryStatement*>(inputDerivedClassPointer);
210278 : // Milind Chabbi (8/28/2013): isSgSyncMemoryStatement uses table-driven castability instead of c++ default dynamic_cast
210279 : // this improves the running time performance by 10-20%.
210280 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSyncMemoryStatement*>(inputDerivedClassPointer);
210281 0 : return IS_SgSyncMemoryStatement_FAST_MACRO(inputDerivedClassPointer);
210282 : }
210283 :
210284 :
210285 :
210286 : /* #line 210287 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210287 :
210288 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210289 :
210290 : /**
210291 : \brief Generated destructor
210292 :
210293 : This destructor is automatically generated (by ROSETTA). This destructor
210294 : only frees memory of data members associated with the parts of the current IR node which
210295 : are NOT traversed. Those data members that are part of a traversal can be freed using
210296 : a traversal (calling this destructor on all children in a post-order traversal). Such
210297 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
210298 :
210299 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
210300 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
210301 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
210302 :
210303 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
210304 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
210305 : pointers are not yet implemented to call delete on eash pointer in the container.
210306 : (This could be done by derivation from the STL containers to define containers that
210307 : automatically deleted their members.)
210308 :
210309 : */
210310 0 : SgSyncMemoryStatement::~SgSyncMemoryStatement () {
210311 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
210312 :
210313 :
210314 :
210315 : }
210316 :
210317 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210318 0 : }
210319 :
210320 :
210321 : /* #line 210322 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210322 :
210323 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210324 :
210325 : // Generated constructor
210326 0 : SgSyncMemoryStatement::SgSyncMemoryStatement ( Sg_File_Info* startOfConstruct )
210327 0 : : SgImageControlStatement(startOfConstruct)
210328 : {
210329 : #ifdef DEBUG
210330 : // printf ("In SgSyncMemoryStatement::SgSyncMemoryStatement (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
210331 : #endif
210332 : #if 0
210333 : // debugging information!
210334 : printf ("In SgSyncMemoryStatement::SgSyncMemoryStatement (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
210335 : #endif
210336 :
210337 :
210338 :
210339 : #if 0
210340 : // DQ (7/30/2014): Call a virtual function.
210341 : std::string s = this->class_name();
210342 : #endif
210343 :
210344 : // Test the variant virtual function
210345 : // assert(SYNC_MEMORY_STATEMENT == variant());
210346 0 : assert(SYNC_MEMORY_STATEMENT == this->variant());
210347 0 : ROSE_ASSERT(SYNC_MEMORY_STATEMENT == (int)(this->variantT()));
210348 0 : post_construction_initialization();
210349 :
210350 : // Test the isSgSyncMemoryStatement() function since it has been problematic
210351 0 : assert(isSgSyncMemoryStatement(this) != NULL);
210352 0 : }
210353 :
210354 : // Generated constructor (all data members)
210355 :
210356 : /* #line 210357 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210357 :
210358 :
210359 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210360 :
210361 :
210362 : // ********************************************************
210363 : // member functions common across all array grammar objects
210364 : // ********************************************************
210365 :
210366 :
210367 :
210368 : /* #line 210369 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210369 :
210370 :
210371 :
210372 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210373 :
210374 : // ********************************************************
210375 : // member functions specific to each node in the grammar
210376 : // ********************************************************
210377 :
210378 :
210379 : /* #line 210380 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210380 :
210381 : // Start of memberFunctionString
210382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
210383 :
210384 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
210385 :
210386 : SgExpression*
210387 0 : SgSyncTeamStatement::get_team_value () const
210388 : {
210389 0 : ROSE_ASSERT (this != NULL);
210390 :
210391 : #if 0
210392 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
210393 : // used to trigger marking transformations for the token-based unparsing.
210394 : printf ("SgSyncTeamStatement::get_team_value = %p = %s \n",this,this->class_name().c_str());
210395 : #endif
210396 :
210397 0 : return p_team_value;
210398 : }
210399 :
210400 : void
210401 0 : SgSyncTeamStatement::set_team_value ( SgExpression* team_value )
210402 : {
210403 0 : ROSE_ASSERT (this != NULL);
210404 :
210405 : #if 0
210406 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
210407 : // used to trigger marking transformations for the token-based unparsing.
210408 : printf ("SgSyncTeamStatement::set_team_value = %p = %s \n",this,this->class_name().c_str());
210409 : #endif
210410 :
210411 0 : set_isModified(true);
210412 :
210413 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
210414 : if (p_team_value != NULL && team_value != NULL && p_team_value != team_value)
210415 : {
210416 : printf ("Warning: team_value = %p overwriting valid pointer p_team_value = %p \n",team_value,p_team_value);
210417 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
210418 : printf ("Error fails assertion (p_team_value != NULL && team_value != NULL && p_team_value != team_value) is false\n");
210419 : ROSE_ASSERT(false);
210420 : #endif
210421 : }
210422 : #endif
210423 0 : p_team_value = team_value;
210424 0 : }
210425 :
210426 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
210427 :
210428 :
210429 : // End of memberFunctionString
210430 : // Start of memberFunctionString
210431 : /* #line 18334 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
210432 :
210433 :
210434 : void
210435 0 : SgSyncTeamStatement::post_construction_initialization()
210436 0 : {}
210437 :
210438 :
210439 :
210440 : // End of memberFunctionString
210441 : // Start of memberFunctionString
210442 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
210443 :
210444 : // *** COMMON CODE SECTION BEGINS HERE ***
210445 :
210446 : #if 0
210447 : int
210448 : SgSyncTeamStatement::getVariant() const
210449 : {
210450 : // This function is used in ROSE while "variant()" is used in SAGE
210451 : assert(this != NULL);
210452 : return variant();
210453 : }
210454 : #endif
210455 :
210456 : // This function is used in ROSE in treeTraversal code
210457 : // eventually replaces getVariant() and variant()
210458 : // though after variant() has been removed for a while we will
210459 : // want to change the name of variantT() back to variant()
210460 : // (since the "T" was ment to stand for temporary).
210461 : // When this happens the variantT() will be depricated.
210462 : VariantT
210463 0 : SgSyncTeamStatement::variantT() const
210464 : {
210465 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
210466 0 : ROSE_ASSERT(this != NULL);
210467 0 : return V_SgSyncTeamStatement;
210468 : }
210469 :
210470 : #if 0
210471 : int
210472 : SgSyncTeamStatement::variant() const
210473 : {
210474 : // This function is used in SAGE
210475 : ROSE_ASSERT(this != NULL);
210476 : return SYNC_TEAM_STATEMENT;
210477 : }
210478 : #endif
210479 :
210480 : ROSE_DLL_API const char*
210481 0 : SgSyncTeamStatement::sage_class_name() const
210482 : {
210483 0 : ROSE_ASSERT(this != NULL);
210484 0 : return "SgSyncTeamStatement";
210485 : }
210486 :
210487 : std::string
210488 0 : SgSyncTeamStatement::class_name() const
210489 : {
210490 0 : ROSE_ASSERT(this != NULL);
210491 0 : return "SgSyncTeamStatement";
210492 : }
210493 :
210494 : // DQ (11/26/2005): Support for visitor pattern mechanims
210495 : // (inferior to ROSE traversal mechanism, experimental).
210496 : void
210497 0 : SgSyncTeamStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
210498 : {
210499 0 : ROSE_ASSERT(this != NULL);
210500 0 : visitor.visit(this);
210501 0 : }
210502 :
210503 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
210504 0 : void SgSyncTeamStatement::accept (ROSE_VisitorPattern & visitor) {
210505 0 : ROSE_ASSERT(this != NULL);
210506 0 : visitor.visit(this);
210507 0 : }
210508 :
210509 : SgSyncTeamStatement*
210510 0 : SgSyncTeamStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
210511 : {
210512 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
210513 : // This function is currently only supported for the AST used the represent Binary executables.
210514 : if (0 /* isSgAsmNode(this) != NULL */)
210515 : {
210516 : // Support for regex specification.
210517 : std::string prefixCode = "REGEX:";
210518 : addNewAttribute(prefixCode + s,a);
210519 : }
210520 : #endif
210521 :
210522 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
210523 0 : return this;
210524 : }
210525 :
210526 : // *** COMMON CODE SECTION ENDS HERE ***
210527 :
210528 :
210529 : // End of memberFunctionString
210530 : // Start of memberFunctionString
210531 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
210532 :
210533 :
210534 : #if 0
210535 : //! Error checking support
210536 : /*! Verifies the following:
210537 : - working getVariant() member function
210538 : - calls base class's error() member function
210539 : Every class has one of these functions.
210540 : */
210541 : bool
210542 : SgSyncTeamStatement::error()
210543 : {
210544 : // Put error checking here
210545 :
210546 : ROSE_ASSERT (this != NULL);
210547 : if (getVariant() != SYNC_TEAM_STATEMENT)
210548 : {
210549 : printf ("Error in SgSyncTeamStatement::error(): SgSyncTeamStatement object has a %s variant \n",
210550 : Cxx_GrammarTerminalNames[getVariant()].name);
210551 : // printf ("Error in SgSyncTeamStatement::error() \n");
210552 : ROSE_ABORT();
210553 : }
210554 :
210555 : ROSE_ASSERT (getVariant() == SYNC_TEAM_STATEMENT);
210556 : return SgImageControlStatement::error();
210557 : }
210558 : #endif
210559 :
210560 :
210561 :
210562 : // End of memberFunctionString
210563 :
210564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
210565 :
210566 0 : SgSyncTeamStatement* isSgSyncTeamStatement ( SgNode* inputDerivedClassPointer )
210567 : {
210568 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210569 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210570 : // So to fix this we return NULL directly when the input is NULL and avoid the
210571 : // dynamic_cast in this case. This is likely a performance improvement as well.
210572 : // return dynamic_cast<SgSyncTeamStatement*>(inputDerivedClassPointer);
210573 : // Milind Chabbi (8/28/2013): isSgSyncTeamStatement uses table-driven castability instead of c++ default dynamic_cast
210574 : // this improves the running time performance by 10-20%.
210575 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSyncTeamStatement*>(inputDerivedClassPointer);
210576 0 : return IS_SgSyncTeamStatement_FAST_MACRO(inputDerivedClassPointer);
210577 : }
210578 :
210579 : // DQ (11/8/2003): Added version of functions taking const pointer
210580 0 : const SgSyncTeamStatement* isSgSyncTeamStatement ( const SgNode* inputDerivedClassPointer )
210581 : {
210582 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210583 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210584 : // So to fix this we return NULL directly when the input is NULL and avoid the
210585 : // dynamic_cast in this case. This is likely a performance improvement as well.
210586 : // return dynamic_cast<const SgSyncTeamStatement*>(inputDerivedClassPointer);
210587 : // Milind Chabbi (8/28/2013): isSgSyncTeamStatement uses table-driven castability instead of c++ default dynamic_cast
210588 : // this improves the running time performance by 10-20%.
210589 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSyncTeamStatement*>(inputDerivedClassPointer);
210590 0 : return IS_SgSyncTeamStatement_FAST_MACRO(inputDerivedClassPointer);
210591 : }
210592 :
210593 :
210594 :
210595 : /* #line 210596 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210596 :
210597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210598 :
210599 : /**
210600 : \brief Generated destructor
210601 :
210602 : This destructor is automatically generated (by ROSETTA). This destructor
210603 : only frees memory of data members associated with the parts of the current IR node which
210604 : are NOT traversed. Those data members that are part of a traversal can be freed using
210605 : a traversal (calling this destructor on all children in a post-order traversal). Such
210606 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
210607 :
210608 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
210609 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
210610 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
210611 :
210612 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
210613 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
210614 : pointers are not yet implemented to call delete on eash pointer in the container.
210615 : (This could be done by derivation from the STL containers to define containers that
210616 : automatically deleted their members.)
210617 :
210618 : */
210619 0 : SgSyncTeamStatement::~SgSyncTeamStatement () {
210620 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
210621 :
210622 :
210623 : // case: not a listType for team_value
210624 0 : p_team_value = NULL; // non list case
210625 :
210626 : }
210627 :
210628 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210629 0 : }
210630 :
210631 :
210632 : /* #line 210633 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210633 :
210634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210635 :
210636 : // Generated constructor
210637 0 : SgSyncTeamStatement::SgSyncTeamStatement ( Sg_File_Info* startOfConstruct, SgExpression* team_value )
210638 0 : : SgImageControlStatement(startOfConstruct)
210639 : {
210640 : #ifdef DEBUG
210641 : // printf ("In SgSyncTeamStatement::SgSyncTeamStatement (Sg_File_Info* startOfConstruct, SgExpression* team_value) sage_class_name() = %s \n",sage_class_name());
210642 : #endif
210643 : #if 0
210644 : // debugging information!
210645 : printf ("In SgSyncTeamStatement::SgSyncTeamStatement (Sg_File_Info* startOfConstruct, SgExpression* team_value): this = %p = %s \n",this,this->class_name().c_str());
210646 : #endif
210647 :
210648 0 : p_team_value = team_value;
210649 :
210650 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210651 :
210652 : #if 0
210653 : // DQ (7/30/2014): Call a virtual function.
210654 : std::string s = this->class_name();
210655 : #endif
210656 :
210657 : // Test the variant virtual function
210658 : // assert(SYNC_TEAM_STATEMENT == variant());
210659 0 : assert(SYNC_TEAM_STATEMENT == this->variant());
210660 0 : ROSE_ASSERT(SYNC_TEAM_STATEMENT == (int)(this->variantT()));
210661 0 : post_construction_initialization();
210662 :
210663 : // Test the isSgSyncTeamStatement() function since it has been problematic
210664 0 : assert(isSgSyncTeamStatement(this) != NULL);
210665 0 : }
210666 :
210667 : // Generated constructor (all data members)
210668 :
210669 : /* #line 210670 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210670 :
210671 :
210672 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210673 :
210674 :
210675 : // ********************************************************
210676 : // member functions common across all array grammar objects
210677 : // ********************************************************
210678 :
210679 :
210680 :
210681 : /* #line 210682 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210682 :
210683 :
210684 :
210685 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210686 :
210687 : // ********************************************************
210688 : // member functions specific to each node in the grammar
210689 : // ********************************************************
210690 :
210691 :
210692 : /* #line 210693 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210693 :
210694 : // Start of memberFunctionString
210695 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
210696 :
210697 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
210698 :
210699 : SgExpression*
210700 0 : SgLockStatement::get_lock_variable () const
210701 : {
210702 0 : ROSE_ASSERT (this != NULL);
210703 :
210704 : #if 0
210705 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
210706 : // used to trigger marking transformations for the token-based unparsing.
210707 : printf ("SgLockStatement::get_lock_variable = %p = %s \n",this,this->class_name().c_str());
210708 : #endif
210709 :
210710 0 : return p_lock_variable;
210711 : }
210712 :
210713 : void
210714 0 : SgLockStatement::set_lock_variable ( SgExpression* lock_variable )
210715 : {
210716 0 : ROSE_ASSERT (this != NULL);
210717 :
210718 : #if 0
210719 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
210720 : // used to trigger marking transformations for the token-based unparsing.
210721 : printf ("SgLockStatement::set_lock_variable = %p = %s \n",this,this->class_name().c_str());
210722 : #endif
210723 :
210724 0 : set_isModified(true);
210725 :
210726 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
210727 : if (p_lock_variable != NULL && lock_variable != NULL && p_lock_variable != lock_variable)
210728 : {
210729 : printf ("Warning: lock_variable = %p overwriting valid pointer p_lock_variable = %p \n",lock_variable,p_lock_variable);
210730 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
210731 : printf ("Error fails assertion (p_lock_variable != NULL && lock_variable != NULL && p_lock_variable != lock_variable) is false\n");
210732 : ROSE_ASSERT(false);
210733 : #endif
210734 : }
210735 : #endif
210736 0 : p_lock_variable = lock_variable;
210737 0 : }
210738 :
210739 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
210740 :
210741 :
210742 : // End of memberFunctionString
210743 : // Start of memberFunctionString
210744 : /* #line 18343 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
210745 :
210746 :
210747 : void
210748 0 : SgLockStatement::post_construction_initialization()
210749 0 : {}
210750 :
210751 :
210752 :
210753 : // End of memberFunctionString
210754 : // Start of memberFunctionString
210755 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
210756 :
210757 : // *** COMMON CODE SECTION BEGINS HERE ***
210758 :
210759 : #if 0
210760 : int
210761 : SgLockStatement::getVariant() const
210762 : {
210763 : // This function is used in ROSE while "variant()" is used in SAGE
210764 : assert(this != NULL);
210765 : return variant();
210766 : }
210767 : #endif
210768 :
210769 : // This function is used in ROSE in treeTraversal code
210770 : // eventually replaces getVariant() and variant()
210771 : // though after variant() has been removed for a while we will
210772 : // want to change the name of variantT() back to variant()
210773 : // (since the "T" was ment to stand for temporary).
210774 : // When this happens the variantT() will be depricated.
210775 : VariantT
210776 0 : SgLockStatement::variantT() const
210777 : {
210778 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
210779 0 : ROSE_ASSERT(this != NULL);
210780 0 : return V_SgLockStatement;
210781 : }
210782 :
210783 : #if 0
210784 : int
210785 : SgLockStatement::variant() const
210786 : {
210787 : // This function is used in SAGE
210788 : ROSE_ASSERT(this != NULL);
210789 : return LOCK_STATEMENT;
210790 : }
210791 : #endif
210792 :
210793 : ROSE_DLL_API const char*
210794 0 : SgLockStatement::sage_class_name() const
210795 : {
210796 0 : ROSE_ASSERT(this != NULL);
210797 0 : return "SgLockStatement";
210798 : }
210799 :
210800 : std::string
210801 0 : SgLockStatement::class_name() const
210802 : {
210803 0 : ROSE_ASSERT(this != NULL);
210804 0 : return "SgLockStatement";
210805 : }
210806 :
210807 : // DQ (11/26/2005): Support for visitor pattern mechanims
210808 : // (inferior to ROSE traversal mechanism, experimental).
210809 : void
210810 0 : SgLockStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
210811 : {
210812 0 : ROSE_ASSERT(this != NULL);
210813 0 : visitor.visit(this);
210814 0 : }
210815 :
210816 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
210817 0 : void SgLockStatement::accept (ROSE_VisitorPattern & visitor) {
210818 0 : ROSE_ASSERT(this != NULL);
210819 0 : visitor.visit(this);
210820 0 : }
210821 :
210822 : SgLockStatement*
210823 0 : SgLockStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
210824 : {
210825 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
210826 : // This function is currently only supported for the AST used the represent Binary executables.
210827 : if (0 /* isSgAsmNode(this) != NULL */)
210828 : {
210829 : // Support for regex specification.
210830 : std::string prefixCode = "REGEX:";
210831 : addNewAttribute(prefixCode + s,a);
210832 : }
210833 : #endif
210834 :
210835 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
210836 0 : return this;
210837 : }
210838 :
210839 : // *** COMMON CODE SECTION ENDS HERE ***
210840 :
210841 :
210842 : // End of memberFunctionString
210843 : // Start of memberFunctionString
210844 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
210845 :
210846 :
210847 : #if 0
210848 : //! Error checking support
210849 : /*! Verifies the following:
210850 : - working getVariant() member function
210851 : - calls base class's error() member function
210852 : Every class has one of these functions.
210853 : */
210854 : bool
210855 : SgLockStatement::error()
210856 : {
210857 : // Put error checking here
210858 :
210859 : ROSE_ASSERT (this != NULL);
210860 : if (getVariant() != LOCK_STATEMENT)
210861 : {
210862 : printf ("Error in SgLockStatement::error(): SgLockStatement object has a %s variant \n",
210863 : Cxx_GrammarTerminalNames[getVariant()].name);
210864 : // printf ("Error in SgLockStatement::error() \n");
210865 : ROSE_ABORT();
210866 : }
210867 :
210868 : ROSE_ASSERT (getVariant() == LOCK_STATEMENT);
210869 : return SgImageControlStatement::error();
210870 : }
210871 : #endif
210872 :
210873 :
210874 :
210875 : // End of memberFunctionString
210876 :
210877 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
210878 :
210879 0 : SgLockStatement* isSgLockStatement ( SgNode* inputDerivedClassPointer )
210880 : {
210881 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210882 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210883 : // So to fix this we return NULL directly when the input is NULL and avoid the
210884 : // dynamic_cast in this case. This is likely a performance improvement as well.
210885 : // return dynamic_cast<SgLockStatement*>(inputDerivedClassPointer);
210886 : // Milind Chabbi (8/28/2013): isSgLockStatement uses table-driven castability instead of c++ default dynamic_cast
210887 : // this improves the running time performance by 10-20%.
210888 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLockStatement*>(inputDerivedClassPointer);
210889 0 : return IS_SgLockStatement_FAST_MACRO(inputDerivedClassPointer);
210890 : }
210891 :
210892 : // DQ (11/8/2003): Added version of functions taking const pointer
210893 0 : const SgLockStatement* isSgLockStatement ( const SgNode* inputDerivedClassPointer )
210894 : {
210895 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
210896 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
210897 : // So to fix this we return NULL directly when the input is NULL and avoid the
210898 : // dynamic_cast in this case. This is likely a performance improvement as well.
210899 : // return dynamic_cast<const SgLockStatement*>(inputDerivedClassPointer);
210900 : // Milind Chabbi (8/28/2013): isSgLockStatement uses table-driven castability instead of c++ default dynamic_cast
210901 : // this improves the running time performance by 10-20%.
210902 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLockStatement*>(inputDerivedClassPointer);
210903 0 : return IS_SgLockStatement_FAST_MACRO(inputDerivedClassPointer);
210904 : }
210905 :
210906 :
210907 :
210908 : /* #line 210909 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210909 :
210910 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210911 :
210912 : /**
210913 : \brief Generated destructor
210914 :
210915 : This destructor is automatically generated (by ROSETTA). This destructor
210916 : only frees memory of data members associated with the parts of the current IR node which
210917 : are NOT traversed. Those data members that are part of a traversal can be freed using
210918 : a traversal (calling this destructor on all children in a post-order traversal). Such
210919 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
210920 :
210921 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
210922 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
210923 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
210924 :
210925 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
210926 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
210927 : pointers are not yet implemented to call delete on eash pointer in the container.
210928 : (This could be done by derivation from the STL containers to define containers that
210929 : automatically deleted their members.)
210930 :
210931 : */
210932 0 : SgLockStatement::~SgLockStatement () {
210933 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
210934 :
210935 :
210936 : // case: not a listType for lock_variable
210937 0 : p_lock_variable = NULL; // non list case
210938 :
210939 : }
210940 :
210941 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
210942 0 : }
210943 :
210944 :
210945 : /* #line 210946 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210946 :
210947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210948 :
210949 : // Generated constructor
210950 0 : SgLockStatement::SgLockStatement ( Sg_File_Info* startOfConstruct, SgExpression* lock_variable )
210951 0 : : SgImageControlStatement(startOfConstruct)
210952 : {
210953 : #ifdef DEBUG
210954 : // printf ("In SgLockStatement::SgLockStatement (Sg_File_Info* startOfConstruct, SgExpression* lock_variable) sage_class_name() = %s \n",sage_class_name());
210955 : #endif
210956 : #if 0
210957 : // debugging information!
210958 : printf ("In SgLockStatement::SgLockStatement (Sg_File_Info* startOfConstruct, SgExpression* lock_variable): this = %p = %s \n",this,this->class_name().c_str());
210959 : #endif
210960 :
210961 0 : p_lock_variable = lock_variable;
210962 :
210963 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
210964 :
210965 : #if 0
210966 : // DQ (7/30/2014): Call a virtual function.
210967 : std::string s = this->class_name();
210968 : #endif
210969 :
210970 : // Test the variant virtual function
210971 : // assert(LOCK_STATEMENT == variant());
210972 0 : assert(LOCK_STATEMENT == this->variant());
210973 0 : ROSE_ASSERT(LOCK_STATEMENT == (int)(this->variantT()));
210974 0 : post_construction_initialization();
210975 :
210976 : // Test the isSgLockStatement() function since it has been problematic
210977 0 : assert(isSgLockStatement(this) != NULL);
210978 0 : }
210979 :
210980 : // Generated constructor (all data members)
210981 :
210982 : /* #line 210983 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210983 :
210984 :
210985 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210986 :
210987 :
210988 : // ********************************************************
210989 : // member functions common across all array grammar objects
210990 : // ********************************************************
210991 :
210992 :
210993 :
210994 : /* #line 210995 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
210995 :
210996 :
210997 :
210998 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
210999 :
211000 : // ********************************************************
211001 : // member functions specific to each node in the grammar
211002 : // ********************************************************
211003 :
211004 :
211005 : /* #line 211006 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
211006 :
211007 : // Start of memberFunctionString
211008 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
211009 :
211010 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
211011 :
211012 : SgExpression*
211013 0 : SgUnlockStatement::get_lock_variable () const
211014 : {
211015 0 : ROSE_ASSERT (this != NULL);
211016 :
211017 : #if 0
211018 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211019 : // used to trigger marking transformations for the token-based unparsing.
211020 : printf ("SgUnlockStatement::get_lock_variable = %p = %s \n",this,this->class_name().c_str());
211021 : #endif
211022 :
211023 0 : return p_lock_variable;
211024 : }
211025 :
211026 : void
211027 0 : SgUnlockStatement::set_lock_variable ( SgExpression* lock_variable )
211028 : {
211029 0 : ROSE_ASSERT (this != NULL);
211030 :
211031 : #if 0
211032 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211033 : // used to trigger marking transformations for the token-based unparsing.
211034 : printf ("SgUnlockStatement::set_lock_variable = %p = %s \n",this,this->class_name().c_str());
211035 : #endif
211036 :
211037 0 : set_isModified(true);
211038 :
211039 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
211040 : if (p_lock_variable != NULL && lock_variable != NULL && p_lock_variable != lock_variable)
211041 : {
211042 : printf ("Warning: lock_variable = %p overwriting valid pointer p_lock_variable = %p \n",lock_variable,p_lock_variable);
211043 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
211044 : printf ("Error fails assertion (p_lock_variable != NULL && lock_variable != NULL && p_lock_variable != lock_variable) is false\n");
211045 : ROSE_ASSERT(false);
211046 : #endif
211047 : }
211048 : #endif
211049 0 : p_lock_variable = lock_variable;
211050 0 : }
211051 :
211052 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
211053 :
211054 :
211055 : // End of memberFunctionString
211056 : // Start of memberFunctionString
211057 : /* #line 18352 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Statement.code" */
211058 :
211059 :
211060 : void
211061 0 : SgUnlockStatement::post_construction_initialization()
211062 0 : {}
211063 :
211064 :
211065 :
211066 : // End of memberFunctionString
211067 : // Start of memberFunctionString
211068 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
211069 :
211070 : // *** COMMON CODE SECTION BEGINS HERE ***
211071 :
211072 : #if 0
211073 : int
211074 : SgUnlockStatement::getVariant() const
211075 : {
211076 : // This function is used in ROSE while "variant()" is used in SAGE
211077 : assert(this != NULL);
211078 : return variant();
211079 : }
211080 : #endif
211081 :
211082 : // This function is used in ROSE in treeTraversal code
211083 : // eventually replaces getVariant() and variant()
211084 : // though after variant() has been removed for a while we will
211085 : // want to change the name of variantT() back to variant()
211086 : // (since the "T" was ment to stand for temporary).
211087 : // When this happens the variantT() will be depricated.
211088 : VariantT
211089 0 : SgUnlockStatement::variantT() const
211090 : {
211091 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
211092 0 : ROSE_ASSERT(this != NULL);
211093 0 : return V_SgUnlockStatement;
211094 : }
211095 :
211096 : #if 0
211097 : int
211098 : SgUnlockStatement::variant() const
211099 : {
211100 : // This function is used in SAGE
211101 : ROSE_ASSERT(this != NULL);
211102 : return UNLOCK_STATEMENT;
211103 : }
211104 : #endif
211105 :
211106 : ROSE_DLL_API const char*
211107 0 : SgUnlockStatement::sage_class_name() const
211108 : {
211109 0 : ROSE_ASSERT(this != NULL);
211110 0 : return "SgUnlockStatement";
211111 : }
211112 :
211113 : std::string
211114 0 : SgUnlockStatement::class_name() const
211115 : {
211116 0 : ROSE_ASSERT(this != NULL);
211117 0 : return "SgUnlockStatement";
211118 : }
211119 :
211120 : // DQ (11/26/2005): Support for visitor pattern mechanims
211121 : // (inferior to ROSE traversal mechanism, experimental).
211122 : void
211123 0 : SgUnlockStatement::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
211124 : {
211125 0 : ROSE_ASSERT(this != NULL);
211126 0 : visitor.visit(this);
211127 0 : }
211128 :
211129 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
211130 0 : void SgUnlockStatement::accept (ROSE_VisitorPattern & visitor) {
211131 0 : ROSE_ASSERT(this != NULL);
211132 0 : visitor.visit(this);
211133 0 : }
211134 :
211135 : SgUnlockStatement*
211136 0 : SgUnlockStatement::addRegExpAttribute(std::string s, AstRegExAttribute* a)
211137 : {
211138 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
211139 : // This function is currently only supported for the AST used the represent Binary executables.
211140 : if (0 /* isSgAsmNode(this) != NULL */)
211141 : {
211142 : // Support for regex specification.
211143 : std::string prefixCode = "REGEX:";
211144 : addNewAttribute(prefixCode + s,a);
211145 : }
211146 : #endif
211147 :
211148 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
211149 0 : return this;
211150 : }
211151 :
211152 : // *** COMMON CODE SECTION ENDS HERE ***
211153 :
211154 :
211155 : // End of memberFunctionString
211156 : // Start of memberFunctionString
211157 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
211158 :
211159 :
211160 : #if 0
211161 : //! Error checking support
211162 : /*! Verifies the following:
211163 : - working getVariant() member function
211164 : - calls base class's error() member function
211165 : Every class has one of these functions.
211166 : */
211167 : bool
211168 : SgUnlockStatement::error()
211169 : {
211170 : // Put error checking here
211171 :
211172 : ROSE_ASSERT (this != NULL);
211173 : if (getVariant() != UNLOCK_STATEMENT)
211174 : {
211175 : printf ("Error in SgUnlockStatement::error(): SgUnlockStatement object has a %s variant \n",
211176 : Cxx_GrammarTerminalNames[getVariant()].name);
211177 : // printf ("Error in SgUnlockStatement::error() \n");
211178 : ROSE_ABORT();
211179 : }
211180 :
211181 : ROSE_ASSERT (getVariant() == UNLOCK_STATEMENT);
211182 : return SgImageControlStatement::error();
211183 : }
211184 : #endif
211185 :
211186 :
211187 :
211188 : // End of memberFunctionString
211189 :
211190 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
211191 :
211192 0 : SgUnlockStatement* isSgUnlockStatement ( SgNode* inputDerivedClassPointer )
211193 : {
211194 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
211195 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
211196 : // So to fix this we return NULL directly when the input is NULL and avoid the
211197 : // dynamic_cast in this case. This is likely a performance improvement as well.
211198 : // return dynamic_cast<SgUnlockStatement*>(inputDerivedClassPointer);
211199 : // Milind Chabbi (8/28/2013): isSgUnlockStatement uses table-driven castability instead of c++ default dynamic_cast
211200 : // this improves the running time performance by 10-20%.
211201 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnlockStatement*>(inputDerivedClassPointer);
211202 0 : return IS_SgUnlockStatement_FAST_MACRO(inputDerivedClassPointer);
211203 : }
211204 :
211205 : // DQ (11/8/2003): Added version of functions taking const pointer
211206 0 : const SgUnlockStatement* isSgUnlockStatement ( const SgNode* inputDerivedClassPointer )
211207 : {
211208 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
211209 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
211210 : // So to fix this we return NULL directly when the input is NULL and avoid the
211211 : // dynamic_cast in this case. This is likely a performance improvement as well.
211212 : // return dynamic_cast<const SgUnlockStatement*>(inputDerivedClassPointer);
211213 : // Milind Chabbi (8/28/2013): isSgUnlockStatement uses table-driven castability instead of c++ default dynamic_cast
211214 : // this improves the running time performance by 10-20%.
211215 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnlockStatement*>(inputDerivedClassPointer);
211216 0 : return IS_SgUnlockStatement_FAST_MACRO(inputDerivedClassPointer);
211217 : }
211218 :
211219 :
211220 :
211221 : /* #line 211222 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
211222 :
211223 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
211224 :
211225 : /**
211226 : \brief Generated destructor
211227 :
211228 : This destructor is automatically generated (by ROSETTA). This destructor
211229 : only frees memory of data members associated with the parts of the current IR node which
211230 : are NOT traversed. Those data members that are part of a traversal can be freed using
211231 : a traversal (calling this destructor on all children in a post-order traversal). Such
211232 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
211233 :
211234 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
211235 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
211236 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
211237 :
211238 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
211239 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
211240 : pointers are not yet implemented to call delete on eash pointer in the container.
211241 : (This could be done by derivation from the STL containers to define containers that
211242 : automatically deleted their members.)
211243 :
211244 : */
211245 0 : SgUnlockStatement::~SgUnlockStatement () {
211246 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
211247 :
211248 :
211249 : // case: not a listType for lock_variable
211250 0 : p_lock_variable = NULL; // non list case
211251 :
211252 : }
211253 :
211254 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
211255 0 : }
211256 :
211257 :
211258 : /* #line 211259 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
211259 :
211260 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
211261 :
211262 : // Generated constructor
211263 0 : SgUnlockStatement::SgUnlockStatement ( Sg_File_Info* startOfConstruct, SgExpression* lock_variable )
211264 0 : : SgImageControlStatement(startOfConstruct)
211265 : {
211266 : #ifdef DEBUG
211267 : // printf ("In SgUnlockStatement::SgUnlockStatement (Sg_File_Info* startOfConstruct, SgExpression* lock_variable) sage_class_name() = %s \n",sage_class_name());
211268 : #endif
211269 : #if 0
211270 : // debugging information!
211271 : printf ("In SgUnlockStatement::SgUnlockStatement (Sg_File_Info* startOfConstruct, SgExpression* lock_variable): this = %p = %s \n",this,this->class_name().c_str());
211272 : #endif
211273 :
211274 0 : p_lock_variable = lock_variable;
211275 :
211276 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
211277 :
211278 : #if 0
211279 : // DQ (7/30/2014): Call a virtual function.
211280 : std::string s = this->class_name();
211281 : #endif
211282 :
211283 : // Test the variant virtual function
211284 : // assert(UNLOCK_STATEMENT == variant());
211285 0 : assert(UNLOCK_STATEMENT == this->variant());
211286 0 : ROSE_ASSERT(UNLOCK_STATEMENT == (int)(this->variantT()));
211287 0 : post_construction_initialization();
211288 :
211289 : // Test the isSgUnlockStatement() function since it has been problematic
211290 0 : assert(isSgUnlockStatement(this) != NULL);
211291 0 : }
211292 :
211293 : // Generated constructor (all data members)
211294 :
211295 : /* #line 211296 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
211296 :
211297 :
211298 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
211299 :
211300 :
211301 : // ********************************************************
211302 : // member functions common across all array grammar objects
211303 : // ********************************************************
211304 :
211305 :
211306 :
211307 : /* #line 211308 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
211308 :
211309 :
211310 :
211311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
211312 :
211313 : // ********************************************************
211314 : // member functions specific to each node in the grammar
211315 : // ********************************************************
211316 :
211317 :
211318 : /* #line 211319 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
211319 :
211320 : // Start of memberFunctionString
211321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
211322 :
211323 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
211324 :
211325 : bool
211326 7739 : SgExpression::get_need_paren () const
211327 : {
211328 7739 : ROSE_ASSERT (this != NULL);
211329 :
211330 : #if 0
211331 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211332 : // used to trigger marking transformations for the token-based unparsing.
211333 : printf ("SgExpression::get_need_paren = %p = %s \n",this,this->class_name().c_str());
211334 : #endif
211335 :
211336 7739 : return p_need_paren;
211337 : }
211338 :
211339 : void
211340 78670 : SgExpression::set_need_paren ( bool need_paren )
211341 : {
211342 78670 : ROSE_ASSERT (this != NULL);
211343 :
211344 : #if 0
211345 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211346 : // used to trigger marking transformations for the token-based unparsing.
211347 : printf ("SgExpression::set_need_paren = %p = %s \n",this,this->class_name().c_str());
211348 : #endif
211349 :
211350 78670 : set_isModified(true);
211351 :
211352 78670 : p_need_paren = need_paren;
211353 78670 : }
211354 :
211355 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
211356 :
211357 :
211358 : // End of memberFunctionString
211359 : // Start of memberFunctionString
211360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
211361 :
211362 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
211363 :
211364 : bool
211365 11032 : SgExpression::get_lvalue () const
211366 : {
211367 11032 : ROSE_ASSERT (this != NULL);
211368 :
211369 : #if 0
211370 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211371 : // used to trigger marking transformations for the token-based unparsing.
211372 : printf ("SgExpression::get_lvalue = %p = %s \n",this,this->class_name().c_str());
211373 : #endif
211374 :
211375 11032 : return p_lvalue;
211376 : }
211377 :
211378 : void
211379 16912 : SgExpression::set_lvalue ( bool lvalue )
211380 : {
211381 16912 : ROSE_ASSERT (this != NULL);
211382 :
211383 : #if 0
211384 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211385 : // used to trigger marking transformations for the token-based unparsing.
211386 : printf ("SgExpression::set_lvalue = %p = %s \n",this,this->class_name().c_str());
211387 : #endif
211388 :
211389 16912 : set_isModified(true);
211390 :
211391 16912 : p_lvalue = lvalue;
211392 16912 : }
211393 :
211394 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
211395 :
211396 :
211397 : // End of memberFunctionString
211398 : // Start of memberFunctionString
211399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
211400 :
211401 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
211402 :
211403 : bool
211404 0 : SgExpression::get_global_qualified_name () const
211405 : {
211406 0 : ROSE_ASSERT (this != NULL);
211407 :
211408 : #if 0
211409 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211410 : // used to trigger marking transformations for the token-based unparsing.
211411 : printf ("SgExpression::get_global_qualified_name = %p = %s \n",this,this->class_name().c_str());
211412 : #endif
211413 :
211414 0 : return p_global_qualified_name;
211415 : }
211416 :
211417 : void
211418 0 : SgExpression::set_global_qualified_name ( bool global_qualified_name )
211419 : {
211420 0 : ROSE_ASSERT (this != NULL);
211421 :
211422 : #if 0
211423 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211424 : // used to trigger marking transformations for the token-based unparsing.
211425 : printf ("SgExpression::set_global_qualified_name = %p = %s \n",this,this->class_name().c_str());
211426 : #endif
211427 :
211428 0 : set_isModified(true);
211429 :
211430 0 : p_global_qualified_name = global_qualified_name;
211431 0 : }
211432 :
211433 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
211434 :
211435 :
211436 : // End of memberFunctionString
211437 : // Start of memberFunctionString
211438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
211439 :
211440 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
211441 :
211442 : Sg_File_Info*
211443 10831400 : SgExpression::get_operatorPosition () const
211444 : {
211445 10831400 : ROSE_ASSERT (this != NULL);
211446 :
211447 : #if 0
211448 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211449 : // used to trigger marking transformations for the token-based unparsing.
211450 : printf ("SgExpression::get_operatorPosition = %p = %s \n",this,this->class_name().c_str());
211451 : #endif
211452 :
211453 10831400 : return p_operatorPosition;
211454 : }
211455 :
211456 : void
211457 1268960 : SgExpression::set_operatorPosition ( Sg_File_Info* operatorPosition )
211458 : {
211459 1268960 : ROSE_ASSERT (this != NULL);
211460 :
211461 : #if 0
211462 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
211463 : // used to trigger marking transformations for the token-based unparsing.
211464 : printf ("SgExpression::set_operatorPosition = %p = %s \n",this,this->class_name().c_str());
211465 : #endif
211466 :
211467 1268960 : set_isModified(true);
211468 :
211469 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
211470 : if (p_operatorPosition != NULL && operatorPosition != NULL && p_operatorPosition != operatorPosition)
211471 : {
211472 : printf ("Warning: operatorPosition = %p overwriting valid pointer p_operatorPosition = %p \n",operatorPosition,p_operatorPosition);
211473 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
211474 : printf ("Error fails assertion (p_operatorPosition != NULL && operatorPosition != NULL && p_operatorPosition != operatorPosition) is false\n");
211475 : ROSE_ASSERT(false);
211476 : #endif
211477 : }
211478 : #endif
211479 1268960 : p_operatorPosition = operatorPosition;
211480 1268960 : }
211481 :
211482 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
211483 :
211484 :
211485 : // End of memberFunctionString
211486 : // Start of memberFunctionString
211487 : /* #line 1940 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
211488 :
211489 :
211490 : Sg_File_Info*
211491 4317560 : SgExpression::get_file_info() const
211492 : {
211493 : // DQ (11/8/2006): Note that the EDG/SageIII translation only
211494 : // uses set_startOfConstruct() and set_endOfConstruct().
211495 :
211496 : // This redefines get_file_info() as it is implemented for a SgLocatedNode
211497 : // to use the "get_operatorPosition()" instead of the get_startOfConstruct()"
211498 : // Most if not all operator positions will associated with syntax for the operator.
211499 : // return get_operatorPosition();
211500 4317560 : Sg_File_Info* returnFileInfo = get_operatorPosition();
211501 4317560 : if (returnFileInfo == NULL)
211502 0 : returnFileInfo = get_startOfConstruct();
211503 4317560 : return returnFileInfo;
211504 : }
211505 :
211506 : void
211507 0 : SgExpression::set_file_info(Sg_File_Info* fileInfo)
211508 : {
211509 : // DQ (11/8/2006): Note that the EDG/SageIII translation only
211510 : // uses set_startOfConstruct() and set_endOfConstruct().
211511 :
211512 : // This redefines get_file_info() as it is implemented for a SgLocatedNode
211513 : // to use the "get_operatorPosition()" instead of the get_startOfConstruct()"
211514 : // Most if not all operator positions will associated with syntax for the operator.
211515 0 : return set_operatorPosition(fileInfo);
211516 : }
211517 :
211518 : #define DEBUG_SGEXPRESSION_GET_QUALIFIED_NAME_PREFIX 0
211519 :
211520 : SgName
211521 12669 : SgExpression::get_qualified_name_prefix() const
211522 : {
211523 : // DQ (5/29/2011): Added to support for new qualified name generation.
211524 : // This only applies to specific SgSupport IR nodes:
211525 : // SgVarRefExp
211526 : // SgFunctionRefExp
211527 : // SgMemberFunctionRefExp
211528 :
211529 : #if DEBUG_SGEXPRESSION_GET_QUALIFIED_NAME_PREFIX
211530 : printf ("In get_qualified_name_prefix(): search globalQualifiedNameMapForNames: this = %p = %s \n",this,this->class_name().c_str());
211531 : #endif
211532 :
211533 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
211534 : // different and so it depends upon where the type is referenced. Thus the qualified name is
211535 : // stored in a map to the IR node that references the type.
211536 12669 : SgName nameQualifier;
211537 12669 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForNames().find(const_cast<SgExpression*>(this));
211538 : // ROSE_ASSERT(i != SgNode::get_globalQualifiedNameMapForNames().end());
211539 :
211540 12669 : if (i != SgNode::get_globalQualifiedNameMapForNames().end())
211541 : {
211542 2193 : nameQualifier = i->second;
211543 : #if DEBUG_SGEXPRESSION_GET_QUALIFIED_NAME_PREFIX
211544 : printf ("In SgExpression::get_qualified_name_prefix(): Found a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
211545 : #endif
211546 : }
211547 : else
211548 : {
211549 : #if DEBUG_SGEXPRESSION_GET_QUALIFIED_NAME_PREFIX
211550 : printf ("In SgExpression::get_qualified_name_prefix(): Could NOT find a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
211551 : #endif
211552 : }
211553 :
211554 : #if DEBUG_SGEXPRESSION_GET_QUALIFIED_NAME_PREFIX
211555 : printf ("nameQualifier for SgExpression = %p = %p = %s = %s \n",this,const_cast<SgExpression*>(this),class_name().c_str(),nameQualifier.str());
211556 : #endif
211557 :
211558 : #if 0
211559 : // DQ (8/19/2013): Error checking on the globalTypeNameMap...check if there is an entry here that we might have wanted to use instead.
211560 : std::map<SgNode*,std::string>::iterator j = SgNode::get_globalTypeNameMap().find(const_cast<SgExpression*>(this));
211561 : if (j != SgNode::get_globalTypeNameMap().end())
211562 : {
211563 : SgName debug_nameQualifier = j->second;
211564 : printf ("In SgExpression::get_qualified_name_prefix(): Found a valid name qualification in the globalTypeNameMap: debug_nameQualifier = %s \n",debug_nameQualifier.str());
211565 : }
211566 : #endif
211567 :
211568 12669 : return nameQualifier;
211569 : }
211570 :
211571 :
211572 : SgName
211573 9025 : SgExpression::get_qualified_name_prefix_for_referenced_type() const
211574 : {
211575 : // DQ (6/2/2011): Added to support for new qualified name generation.
211576 :
211577 : #if 0
211578 : printf ("In get_qualified_name_prefix_for_referenced_type(): search globalQualifiedNameMapForNames: this = %p = %s \n",this,this->class_name().c_str());
211579 : #endif
211580 :
211581 : // DQ (5/28/2011): We have to handle the name qualification directly since types can be qualified
211582 : // different and so it depends upon where the type is referenced. Thus the qualified name is
211583 : // stored in a map to the IR node that references the type.
211584 9025 : SgName nameQualifier;
211585 9025 : std::map<SgNode*,std::string>::iterator i = SgNode::get_globalQualifiedNameMapForTypes().find(const_cast<SgExpression*>(this));
211586 :
211587 9025 : if (i != SgNode::get_globalQualifiedNameMapForTypes().end())
211588 : {
211589 6912 : nameQualifier = i->second;
211590 : #if 0
211591 : printf ("In SgExpression::get_qualified_name_prefix_for_referenced_type(): Found a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
211592 : #endif
211593 : }
211594 : else
211595 : {
211596 : #if 0
211597 : printf ("In SgExpression::get_qualified_name_prefix_for_referenced_type(): Could NOT find a valid name qualification: nameQualifier = %s \n",nameQualifier.str());
211598 : #endif
211599 : }
211600 :
211601 : // printf ("nameQualifier for SgExpression referenced type = %s = %s \n",class_name().c_str(),nameQualifier.str());
211602 :
211603 : #if 0
211604 : // DQ (8/19/2013): Error checking on the globalTypeNameMap...check if there is an entry here that we might have wanted to use instead.
211605 : std::map<SgNode*,std::string>::iterator j = SgNode::get_globalTypeNameMap().find(const_cast<SgExpression*>(this));
211606 : if (j != SgNode::get_globalTypeNameMap().end())
211607 : {
211608 : SgName debug_nameQualifier = j->second;
211609 : printf ("In SgExpression::get_qualified_name_prefix_for_referenced_type(): Found a valid name qualification in the globalTypeNameMap: debug_nameQualifier = %s \n",debug_nameQualifier.str());
211610 : }
211611 : #endif
211612 :
211613 9025 : return nameQualifier;
211614 : }
211615 :
211616 :
211617 : void
211618 382839 : SgExpression::post_construction_initialization()
211619 : {
211620 382839 : }
211621 :
211622 : int
211623 0 : SgExpression::replace_expression(SgExpression *,SgExpression *)
211624 : {
211625 0 : cerr << "Call to undefined SgExpression::replace_expression(): aborting" << endl;
211626 0 : cerr << "dynamic type: " << this->class_name() << endl;
211627 0 : ROSE_ASSERT(false);
211628 : return 0;
211629 : }
211630 :
211631 : #if 0
211632 : // DQ (1/14/2006): set_type is removed
211633 : void
211634 : SgExpression::set_type()
211635 : {
211636 : /*
211637 : * this is a quick hack to allow me to rely on being to create a non
211638 : * abstract object. For some expression classes this had not been
211639 : * overridden
211640 : */
211641 :
211642 : cerr << "Call to undefined set_type(): aborting" << endl;
211643 : exit(1);
211644 : }
211645 : #endif
211646 :
211647 : SgType*
211648 0 : SgExpression::get_type() const
211649 : {
211650 : // DQ: With this function defined we can be sure that we don't call it by accident.
211651 : // This catches any IR nodes where the fucntion should have been overwritten and was not.
211652 :
211653 0 : cerr << "Call to undefined SgExpression::get_type(): aborting" << endl;
211654 0 : cerr << "dynamic type: " << this->class_name() << endl;
211655 0 : ROSE_ASSERT(false);
211656 :
211657 : return 0;
211658 : }
211659 :
211660 : #if 0
211661 : // DQ (8/18/2004): removing this older pragma mechanism
211662 : void
211663 : SgExpression::output_pragma(ostream& os)
211664 : {
211665 : ::print_pragma( p_uattributes, os);
211666 : }
211667 : #endif
211668 :
211669 : int
211670 0 : SgExpression::precedence() const
211671 : {
211672 0 : return 0;
211673 : }
211674 :
211675 : #if 0
211676 : int
211677 : SgExpression::length() const
211678 : {
211679 : return 0;
211680 : }
211681 : #endif
211682 :
211683 : #if 0
211684 : bool
211685 : SgExpression::empty() const
211686 : {
211687 : return 1;
211688 : }
211689 : #endif
211690 :
211691 : #if 0
211692 : SgExpression*
211693 : SgExpression::get_first() const
211694 : {
211695 : int p = 0;
211696 : return get_next(p);
211697 : }
211698 : #endif
211699 :
211700 : #if 0
211701 : SgExpression*
211702 : SgExpression::get_next(int&) const
211703 : {
211704 : printf ("Error: baseClass called! \n");
211705 : abort();
211706 :
211707 : return NULL;
211708 : }
211709 : #endif
211710 :
211711 : #if 0
211712 : SgExpression*
211713 : SgExpression::get_end() const
211714 : {
211715 : printf ("Error: baseClass called! \n");
211716 : abort();
211717 :
211718 : return NULL;
211719 : }
211720 : #endif
211721 :
211722 : #if 0
211723 : void
211724 : SgExpression::insert_next(int,SgExpression *)
211725 : {
211726 : }
211727 : #endif
211728 :
211729 : #if 0
211730 : SgExpressionPtrList::iterator
211731 : SgExpression::begin()
211732 : { return get_first(); }
211733 :
211734 : SgExpressionPtrList::iterator
211735 : SgExpression::end()
211736 : { return get_end(); }
211737 : #endif
211738 :
211739 : #if 0
211740 : // DQ (8/18/2004): Removed since it is not used!
211741 : void
211742 : SgExpression::set_lvalue()
211743 : {
211744 : #if 0
211745 : printf ("ERROR: not yet implemented in SAGE3! \n");
211746 : abort();
211747 : #else
211748 : set_system_bitflag(p_uattributes,e_lvalue);
211749 : #endif
211750 : }
211751 :
211752 : int
211753 : SgExpression::get_is_lvalue() const
211754 : { return is_system_bitflag(p_uattributes,e_lvalue); }
211755 : #endif
211756 :
211757 :
211758 : #if 0
211759 : void
211760 : SgExpression::unset_lvalue()
211761 : { unset_system_bitflag(p_uattributes,e_lvalue); }
211762 :
211763 : void
211764 : SgExpression::add_pragma(int cnt, SgPragma** plist)
211765 : {
211766 : for(int i=0; i<cnt; i++)
211767 : {
211768 : ::add_pragma(p_uattributes, plist[i]);
211769 : plist[i]=0;
211770 : }
211771 : }
211772 :
211773 : SgPragma*
211774 : SgExpression::add_pragma(char *nm)
211775 : { return ::add_pragma(p_uattributes, nm); }
211776 :
211777 : SgPragma*
211778 : SgExpression::get_pragma(char *nm) const
211779 : { return ::get_pragma(p_uattributes, nm); }
211780 :
211781 : int
211782 : SgExpression::remove_pragma(char *nm)
211783 : { return ::remove_pragma(p_uattributes,nm); }
211784 :
211785 : // get attribute,
211786 : SgAttribute*
211787 : SgExpression::get_user_attribute(char *nm) const
211788 : { return ::Sgget_user_attribute(p_uattributes,nm); }
211789 :
211790 : SgAttribute*
211791 : SgExpression::add_user_attribute(char *nm, SgAttribute* attr)
211792 : { return ::Sgadd_user_attribute(p_uattributes,nm,attr); }
211793 :
211794 : int
211795 : SgExpression::remove_user_attribute(char *nm)
211796 : { return ::remove_user_attribute(p_uattributes,nm); }
211797 : #endif
211798 :
211799 : #if 0
211800 : // DQ (8/18/2004): Removed since it uses the old attribute mechanism
211801 : // Some global functions that are used by expressions
211802 : SgAttribute*
211803 : get_system_bitflag(const SgAttributePtrList & pattr)
211804 : {
211805 : SgAttributePtrList::const_iterator p = pattr.begin();
211806 : if(p == pattr.end())
211807 : return NULL;
211808 : else
211809 : {
211810 : assert((*p) != NULL);
211811 : return (SgAttribute *)(*p); // first one
211812 : }
211813 : }
211814 :
211815 : /* always the first SgAttributePtr in the list */
211816 : void
211817 : set_system_bitflag(SgAttributePtrList & pattr, unsigned long int bit)
211818 : {
211819 : SgAttributePtrList::iterator p = pattr.begin();
211820 : if(p==pattr.end())
211821 : {
211822 : SgBitAttribute* newAttribute = new SgBitAttribute("SYS_BITFLAG");
211823 : assert(newAttribute != NULL);
211824 : p = pattr.insert(p, newAttribute);
211825 : // p = pattr.insert(p,(SgAttribute *) new SgBitAttribute("SYS_BITFLAG"));
211826 : }
211827 :
211828 : SgBitAttribute *bp = (SgBitAttribute *)(*p);
211829 : assert(bp != NULL);
211830 : bp->setAttribute(bit);
211831 : }
211832 :
211833 : void
211834 : unset_system_bitflag(SgAttributePtrList& pattr, unsigned long int bit)
211835 : {
211836 : SgAttributePtrList::iterator p=pattr.begin();
211837 : if(p==pattr.end())
211838 : {
211839 : SgBitAttribute* newAttribute = new SgBitAttribute("SYS_BITFLAG");
211840 : assert(newAttribute != NULL);
211841 : p=pattr.insert(p,(SgAttribute *) newAttribute);
211842 : // p=pattr.insert(p,(SgAttribute *) new SgBitAttribute("SYS_BITFLAG"));
211843 : }
211844 :
211845 : SgBitAttribute* bp = (SgBitAttribute *)(*p);
211846 : assert(bp != NULL);
211847 : bp->unsetAttribute(bit);
211848 : }
211849 :
211850 : int
211851 : is_system_bitflag(const SgAttributePtrList& pattr, unsigned long int bit)
211852 : {
211853 : SgAttributePtrList::const_iterator p=pattr.begin();
211854 : if(p==pattr.end())
211855 : return 0;
211856 :
211857 : SgBitAttribute *bp = (SgBitAttribute *)(*p);
211858 : assert(bp != NULL);
211859 : return bp->isAttributeSet(bit);
211860 : }
211861 :
211862 : SgAttribute*
211863 : Sgadd_user_attribute(SgAttributePtrList& pattr, char *attr_name, SgAttribute* attr)
211864 : {
211865 : SgAttributePtrList::iterator p=pattr.begin();
211866 : if(p==pattr.end())
211867 : {
211868 : SgBitAttribute* newAttribute = new SgBitAttribute("SYS_BITFLAG");
211869 : assert(newAttribute != NULL);
211870 : pattr.insert(p,newAttribute);
211871 : // pattr.insert(p,(SgAttribute *)new SgBitAttribute("SYS_BITFLAG"));
211872 : }
211873 : p++;
211874 :
211875 : // I think it would not make much sense to insert a NULL pointer
211876 : assert(attr != NULL);
211877 : pattr.insert(pattr.end(), attr);
211878 : p++;
211879 :
211880 : // DQ: Not sure we can assert that the return value is a valid pointer
211881 : assert((*p) != NULL);
211882 : return (SgAttribute *)(*p);
211883 : }
211884 :
211885 : // get user attribute,
211886 : SgAttribute*
211887 : Sgget_user_attribute(const SgAttributePtrList& pattr, char *attr_name)
211888 : {
211889 : assert(attr_name != NULL);
211890 : SgAttributePtrList::const_iterator p = pattr.begin();
211891 : if(p == pattr.end())
211892 : return 0;
211893 : else
211894 : p++; // skip the system attribute
211895 :
211896 : while( p != pattr.end())
211897 : {
211898 : assert((*p) != NULL);
211899 : if( !(*p)->isPragma() && (*p)->isSame(attr_name) )
211900 : {
211901 : assert((*p) != NULL);
211902 : return (SgAttribute *)(*p);
211903 : }
211904 : p++;
211905 : }
211906 :
211907 : return NULL;
211908 : }
211909 :
211910 : int
211911 : remove_user_attribute(SgAttributePtrList& pattr, char *attr_name)
211912 : {
211913 : assert(attr_name != NULL);
211914 : SgAttributePtrList::iterator p = pattr.begin();
211915 : if(p==pattr.end())
211916 : return 0;
211917 : else
211918 : p++; // skip the system one
211919 :
211920 : while( p!=pattr.end())
211921 : {
211922 : assert((*p) != NULL);
211923 : if( !(*p)->isPragma() && (*p)->isSame(attr_name) )
211924 : {
211925 : pattr.remove((*p));
211926 : return 1;
211927 : }
211928 : p++;
211929 : }
211930 :
211931 : return 0;
211932 : }
211933 : #endif
211934 :
211935 :
211936 : int
211937 0 : SgExpression::get_name_qualification_length () const
211938 : {
211939 0 : ROSE_ASSERT (this != NULL);
211940 :
211941 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
211942 0 : ROSE_ASSERT(false);
211943 :
211944 : return 0; // p_name_qualification_length;
211945 : }
211946 :
211947 : void
211948 0 : SgExpression::set_name_qualification_length ( int name_qualification_length )
211949 : {
211950 0 : ROSE_ASSERT (this != NULL);
211951 : // This can't be called by the name qualification API (see test2015_26.C).
211952 : // set_isModified(true);
211953 :
211954 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
211955 0 : ROSE_ASSERT(false);
211956 :
211957 : // p_name_qualification_length = name_qualification_length;
211958 : }
211959 :
211960 :
211961 : bool
211962 0 : SgExpression::get_type_elaboration_required () const
211963 : {
211964 0 : ROSE_ASSERT (this != NULL);
211965 :
211966 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
211967 0 : ROSE_ASSERT(false);
211968 :
211969 : return false; // p_type_elaboration_required;
211970 : }
211971 :
211972 : void
211973 0 : SgExpression::set_type_elaboration_required ( bool type_elaboration_required )
211974 : {
211975 0 : ROSE_ASSERT (this != NULL);
211976 : // This can't be called by the name qualification API (see test2015_26.C).
211977 : // set_isModified(true);
211978 :
211979 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
211980 0 : ROSE_ASSERT(false);
211981 :
211982 : // p_type_elaboration_required = type_elaboration_required;
211983 : }
211984 :
211985 : bool
211986 0 : SgExpression::get_global_qualification_required () const
211987 : {
211988 0 : ROSE_ASSERT (this != NULL);
211989 :
211990 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
211991 0 : ROSE_ASSERT(false);
211992 :
211993 : return false; // p_global_qualification_required;
211994 : }
211995 :
211996 : void
211997 0 : SgExpression::set_global_qualification_required ( bool global_qualification_required )
211998 : {
211999 0 : ROSE_ASSERT (this != NULL);
212000 : // This can't be called by the name qualification API (see test2015_26.C).
212001 : // set_isModified(true);
212002 :
212003 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212004 0 : ROSE_ASSERT(false);
212005 :
212006 : // p_global_qualification_required = global_qualification_required;
212007 : }
212008 :
212009 :
212010 : int
212011 0 : SgExpression::get_name_qualification_for_pointer_to_member_class_length () const
212012 : {
212013 0 : ROSE_ASSERT (this != NULL);
212014 :
212015 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212016 0 : ROSE_ASSERT(false);
212017 :
212018 : return 0; // p_name_qualification_length;
212019 : }
212020 :
212021 : void
212022 0 : SgExpression::set_name_qualification_for_pointer_to_member_class_length ( int name_qualification_length )
212023 : {
212024 0 : ROSE_ASSERT (this != NULL);
212025 : // This can't be called by the name qualification API (see test2015_26.C).
212026 : // set_isModified(true);
212027 :
212028 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212029 0 : ROSE_ASSERT(false);
212030 :
212031 : // p_name_qualification_length = name_qualification_length;
212032 : }
212033 :
212034 :
212035 : bool
212036 0 : SgExpression::get_type_elaboration_for_pointer_to_member_class_required () const
212037 : {
212038 0 : ROSE_ASSERT (this != NULL);
212039 :
212040 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212041 0 : ROSE_ASSERT(false);
212042 :
212043 : return false; // p_type_elaboration_required;
212044 : }
212045 :
212046 : void
212047 0 : SgExpression::set_type_elaboration_for_pointer_to_member_class_required ( bool type_elaboration_required )
212048 : {
212049 0 : ROSE_ASSERT (this != NULL);
212050 : // This can't be called by the name qualification API (see test2015_26.C).
212051 : // set_isModified(true);
212052 :
212053 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212054 0 : ROSE_ASSERT(false);
212055 :
212056 : // p_type_elaboration_required = type_elaboration_required;
212057 : }
212058 :
212059 : bool
212060 0 : SgExpression::get_global_qualification_for_pointer_to_member_class_required () const
212061 : {
212062 0 : ROSE_ASSERT (this != NULL);
212063 :
212064 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212065 0 : ROSE_ASSERT(false);
212066 :
212067 : return false; // p_global_qualification_required;
212068 : }
212069 :
212070 : void
212071 0 : SgExpression::set_global_qualification_for_pointer_to_member_class_required ( bool global_qualification_required )
212072 : {
212073 0 : ROSE_ASSERT (this != NULL);
212074 : // This can't be called by the name qualification API (see test2015_26.C).
212075 : // set_isModified(true);
212076 :
212077 0 : printf ("Error: base class virtual function called by mistake on node = %p = %s \n",this,this->class_name().c_str());
212078 0 : ROSE_ASSERT(false);
212079 :
212080 : // p_global_qualification_required = global_qualification_required;
212081 : }
212082 :
212083 :
212084 : // DQ (9/23/2011): Use the vitual function version so that we can test within ROSE (part of incremental testing of new original expression tree support).
212085 : // DQ (9/19/2011): Put back the original code (non-virtual functions) so that we can test against previously passing tests.
212086 : SgExpression*
212087 293998 : SgExpression::get_originalExpressionTree() const
212088 : {
212089 293998 : SgExpression* originalExpressionTree = NULL;
212090 :
212091 : #if 0
212092 : // DQ (9/17/2011): It is OK to call this function, where it is not supported by a function in the derived class it should return NULL.
212093 : printf ("WARNING: base function SgExpression::get_originalExpressionTree() called for %p = %s (returning NULL) \n",this,this->class_name().c_str());
212094 : // ROSE_ASSERT(false);
212095 : #endif
212096 :
212097 293998 : return originalExpressionTree;
212098 : }
212099 :
212100 : // DQ (9/19/2011): Put back the original code (non-virtual functions) so that we can test against previously passing tests.
212101 : void
212102 0 : SgExpression::set_originalExpressionTree(SgExpression* X)
212103 : {
212104 0 : printf ("ERROR: base function SgExpression::set_originalExpressionTree() called for %p = %s \n",this,this->class_name().c_str());
212105 0 : ROSE_ASSERT(false);
212106 : }
212107 :
212108 : bool
212109 0 : SgExpression::hasExplicitType()
212110 : {
212111 : // DQ (3/7/2014): This could be implemented as a virtual function but would require 11 functions to be
212112 : // implemented. I have thus instead implemented it as a single function on the SgType instead. We
212113 : // can review this if it is important.
212114 :
212115 : // This function returns true only if this is either a SgTemplateParameterVal, SgComplexVal, SgSizeOfOp, SgAlignOfOp,
212116 : // SgTypeIdOp, SgVarArgStartOp, SgVarArgStartOneOperandOp,
212117 : // SgVarArgOp, SgVarArgEndOp, SgVarArgCopyOp, SgNewExp, SgRefExp, SgAggregateInitializer, SgCompoundInitializer,
212118 : // SgConstructorInitializer, SgAssignInitializer, SgPseudoDestructorRefExp.
212119 :
212120 0 : bool returnValue = false;
212121 :
212122 : // Need to add: SgUpcLocalsizeofExpression, SgUpcBlocksizeofExpression, SgUpcElemsizeofExpression.
212123 :
212124 : // DQ (11/10/2014): Added support for SgFunctionParameterRefExp node to store the type explicitly.
212125 :
212126 0 : if ( isSgTemplateParameterVal(this) != NULL || isSgComplexVal(this) != NULL || isSgSizeOfOp(this) != NULL ||
212127 0 : isSgAlignOfOp(this) != NULL || isSgTypeIdOp(this) != NULL ||
212128 0 : isSgVarArgStartOp(this) != NULL || isSgVarArgStartOneOperandOp(this) != NULL || isSgVarArgOp(this) != NULL ||
212129 0 : isSgVarArgEndOp(this) != NULL || isSgVarArgCopyOp(this) != NULL || isSgNewExp(this) != NULL ||
212130 0 : isSgRefExp(this) != NULL || isSgAggregateInitializer(this) != NULL || isSgCompoundInitializer(this) != NULL ||
212131 0 : isSgUpcLocalsizeofExpression(this) != NULL || isSgUpcBlocksizeofExpression(this) != NULL || isSgUpcElemsizeofExpression(this) != NULL ||
212132 : // isSgConstructorInitializer(this) != NULL || isSgAssignInitializer(this) != NULL || isSgPseudoDestructorRefExp(this) != NULL ||
212133 0 : isSgConstructorInitializer(this) != NULL || isSgPseudoDestructorRefExp(this) != NULL || isSgFunctionParameterRefExp(this) != NULL )
212134 : {
212135 : returnValue = true;
212136 : }
212137 :
212138 0 : return returnValue;
212139 : }
212140 :
212141 : void
212142 0 : SgExpression::set_explicitly_stored_type( SgType* type )
212143 : {
212144 : // DQ (3/7/2014): Some expressions store internal SgType pointers explicitly, this allows these IR nodes to be reset with new types (used in the snippet support).
212145 :
212146 0 : switch (this->variantT())
212147 : {
212148 0 : case V_SgNewExp:
212149 0 : {
212150 0 : SgNewExp* exp = isSgNewExp(this);
212151 0 : ROSE_ASSERT(exp != NULL);
212152 0 : exp->set_specified_type(type);
212153 0 : break;
212154 : }
212155 :
212156 0 : case V_SgConstructorInitializer:
212157 0 : {
212158 0 : SgConstructorInitializer* exp = isSgConstructorInitializer(this);
212159 0 : ROSE_ASSERT(exp != NULL);
212160 0 : exp->set_expression_type(type);
212161 0 : break;
212162 : }
212163 :
212164 0 : case V_SgTemplateParameterVal:
212165 0 : {
212166 0 : SgTemplateParameterVal* exp = isSgTemplateParameterVal(this);
212167 0 : ROSE_ASSERT(exp != NULL);
212168 0 : exp->set_valueType(type);
212169 0 : break;
212170 : }
212171 :
212172 0 : case V_SgComplexVal:
212173 0 : {
212174 0 : SgComplexVal* exp = isSgComplexVal(this);
212175 0 : ROSE_ASSERT(exp != NULL);
212176 0 : exp->set_precisionType(type);
212177 0 : break;
212178 : }
212179 :
212180 0 : case V_SgSizeOfOp:
212181 0 : {
212182 0 : SgSizeOfOp* exp = isSgSizeOfOp(this);
212183 0 : ROSE_ASSERT(exp != NULL);
212184 0 : exp->set_operand_type(type);
212185 0 : break;
212186 : }
212187 :
212188 0 : case V_SgAlignOfOp:
212189 0 : {
212190 0 : SgAlignOfOp* exp = isSgAlignOfOp(this);
212191 0 : ROSE_ASSERT(exp != NULL);
212192 0 : exp->set_operand_type(type);
212193 0 : break;
212194 : }
212195 :
212196 0 : case V_SgTypeIdOp:
212197 0 : {
212198 0 : SgTypeIdOp* exp = isSgTypeIdOp(this);
212199 0 : ROSE_ASSERT(exp != NULL);
212200 0 : exp->set_operand_type(type);
212201 0 : break;
212202 : }
212203 :
212204 0 : case V_SgVarArgStartOp:
212205 0 : {
212206 0 : SgVarArgStartOp* exp = isSgVarArgStartOp(this);
212207 0 : ROSE_ASSERT(exp != NULL);
212208 0 : exp->set_expression_type(type);
212209 0 : break;
212210 : }
212211 :
212212 0 : case V_SgVarArgStartOneOperandOp:
212213 0 : {
212214 0 : SgVarArgStartOneOperandOp* exp = isSgVarArgStartOneOperandOp(this);
212215 0 : ROSE_ASSERT(exp != NULL);
212216 0 : exp->set_expression_type(type);
212217 0 : break;
212218 : }
212219 :
212220 0 : case V_SgVarArgOp:
212221 0 : {
212222 0 : SgVarArgOp* exp = isSgVarArgOp(this);
212223 0 : ROSE_ASSERT(exp != NULL);
212224 0 : exp->set_expression_type(type);
212225 0 : break;
212226 : }
212227 :
212228 0 : case V_SgVarArgEndOp:
212229 0 : {
212230 0 : SgVarArgEndOp* exp = isSgVarArgEndOp(this);
212231 0 : ROSE_ASSERT(exp != NULL);
212232 0 : exp->set_expression_type(type);
212233 0 : break;
212234 : }
212235 :
212236 0 : case V_SgVarArgCopyOp:
212237 0 : {
212238 0 : SgVarArgCopyOp* exp = isSgVarArgCopyOp(this);
212239 0 : ROSE_ASSERT(exp != NULL);
212240 0 : exp->set_expression_type(type);
212241 0 : break;
212242 : }
212243 :
212244 0 : case V_SgRefExp:
212245 0 : {
212246 0 : SgRefExp* exp = isSgRefExp(this);
212247 0 : ROSE_ASSERT(exp != NULL);
212248 0 : exp->set_type_name(type);
212249 0 : break;
212250 : }
212251 :
212252 0 : case V_SgAggregateInitializer:
212253 0 : {
212254 0 : SgAggregateInitializer* exp = isSgAggregateInitializer(this);
212255 0 : ROSE_ASSERT(exp != NULL);
212256 0 : exp->set_expression_type(type);
212257 0 : break;
212258 : }
212259 :
212260 0 : case V_SgCompoundInitializer:
212261 0 : {
212262 0 : SgCompoundInitializer* exp = isSgCompoundInitializer(this);
212263 0 : ROSE_ASSERT(exp != NULL);
212264 0 : exp->set_expression_type(type);
212265 0 : break;
212266 : }
212267 :
212268 0 : case V_SgPseudoDestructorRefExp:
212269 0 : {
212270 0 : SgPseudoDestructorRefExp* exp = isSgPseudoDestructorRefExp(this);
212271 0 : ROSE_ASSERT(exp != NULL);
212272 0 : exp->set_object_type(type);
212273 0 : break;
212274 : }
212275 :
212276 0 : case V_SgUpcLocalsizeofExpression:
212277 0 : {
212278 0 : SgUpcLocalsizeofExpression* exp = isSgUpcLocalsizeofExpression(this);
212279 0 : ROSE_ASSERT(exp != NULL);
212280 0 : exp->set_operand_type(type);
212281 0 : break;
212282 : }
212283 :
212284 0 : case V_SgUpcBlocksizeofExpression:
212285 0 : {
212286 0 : SgUpcBlocksizeofExpression* exp = isSgUpcBlocksizeofExpression(this);
212287 0 : ROSE_ASSERT(exp != NULL);
212288 0 : exp->set_operand_type(type);
212289 0 : break;
212290 : }
212291 :
212292 0 : case V_SgUpcElemsizeofExpression:
212293 0 : {
212294 0 : SgUpcElemsizeofExpression* exp = isSgUpcElemsizeofExpression(this);
212295 0 : ROSE_ASSERT(exp != NULL);
212296 0 : exp->set_operand_type(type);
212297 0 : break;
212298 : }
212299 :
212300 : #if 0
212301 : {
212302 : printf ("Error: case not handled: expression = %p = %s \n",this,this->class_name().c_str());
212303 : ROSE_ASSERT(false);
212304 : break;
212305 : }
212306 : #endif
212307 0 : default:
212308 0 : {
212309 0 : printf ("Error: SgExpression::set_explicit_type(): default reached: expression = %p = %s \n",this,this->class_name().c_str());
212310 0 : ROSE_ASSERT(false);
212311 : }
212312 : }
212313 0 : }
212314 :
212315 :
212316 :
212317 : // End of memberFunctionString
212318 : // Start of memberFunctionString
212319 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
212320 :
212321 : // *** COMMON CODE SECTION BEGINS HERE ***
212322 :
212323 : #if 0
212324 : int
212325 : SgExpression::getVariant() const
212326 : {
212327 : // This function is used in ROSE while "variant()" is used in SAGE
212328 : assert(this != NULL);
212329 : return variant();
212330 : }
212331 : #endif
212332 :
212333 : // This function is used in ROSE in treeTraversal code
212334 : // eventually replaces getVariant() and variant()
212335 : // though after variant() has been removed for a while we will
212336 : // want to change the name of variantT() back to variant()
212337 : // (since the "T" was ment to stand for temporary).
212338 : // When this happens the variantT() will be depricated.
212339 : VariantT
212340 1148520 : SgExpression::variantT() const
212341 : {
212342 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
212343 1148520 : ROSE_ASSERT(this != NULL);
212344 1148520 : return V_SgExpression;
212345 : }
212346 :
212347 : #if 0
212348 : int
212349 : SgExpression::variant() const
212350 : {
212351 : // This function is used in SAGE
212352 : ROSE_ASSERT(this != NULL);
212353 : return ExpressionTag;
212354 : }
212355 : #endif
212356 :
212357 : ROSE_DLL_API const char*
212358 0 : SgExpression::sage_class_name() const
212359 : {
212360 0 : ROSE_ASSERT(this != NULL);
212361 0 : return "SgExpression";
212362 : }
212363 :
212364 : std::string
212365 0 : SgExpression::class_name() const
212366 : {
212367 0 : ROSE_ASSERT(this != NULL);
212368 0 : return "SgExpression";
212369 : }
212370 :
212371 : // DQ (11/26/2005): Support for visitor pattern mechanims
212372 : // (inferior to ROSE traversal mechanism, experimental).
212373 : void
212374 0 : SgExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
212375 : {
212376 0 : ROSE_ASSERT(this != NULL);
212377 0 : visitor.visit(this);
212378 0 : }
212379 :
212380 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
212381 0 : void SgExpression::accept (ROSE_VisitorPattern & visitor) {
212382 0 : ROSE_ASSERT(this != NULL);
212383 0 : visitor.visit(this);
212384 0 : }
212385 :
212386 : SgExpression*
212387 0 : SgExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
212388 : {
212389 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
212390 : // This function is currently only supported for the AST used the represent Binary executables.
212391 : if (0 /* isSgAsmNode(this) != NULL */)
212392 : {
212393 : // Support for regex specification.
212394 : std::string prefixCode = "REGEX:";
212395 : addNewAttribute(prefixCode + s,a);
212396 : }
212397 : #endif
212398 :
212399 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
212400 0 : return this;
212401 : }
212402 :
212403 : // *** COMMON CODE SECTION ENDS HERE ***
212404 :
212405 :
212406 : // End of memberFunctionString
212407 : // Start of memberFunctionString
212408 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
212409 :
212410 :
212411 : #if 0
212412 : //! Error checking support
212413 : /*! Verifies the following:
212414 : - working getVariant() member function
212415 : - calls base class's error() member function
212416 : Every class has one of these functions.
212417 : */
212418 : bool
212419 : SgExpression::error()
212420 : {
212421 : // Put error checking here
212422 :
212423 : ROSE_ASSERT (this != NULL);
212424 : if (getVariant() != ExpressionTag)
212425 : {
212426 : printf ("Error in SgExpression::error(): SgExpression object has a %s variant \n",
212427 : Cxx_GrammarTerminalNames[getVariant()].name);
212428 : // printf ("Error in SgExpression::error() \n");
212429 : ROSE_ABORT();
212430 : }
212431 :
212432 : ROSE_ASSERT (getVariant() == ExpressionTag);
212433 : return SgLocatedNode::error();
212434 : }
212435 : #endif
212436 :
212437 :
212438 :
212439 : // End of memberFunctionString
212440 :
212441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
212442 :
212443 94051500 : SgExpression* isSgExpression ( SgNode* inputDerivedClassPointer )
212444 : {
212445 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
212446 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
212447 : // So to fix this we return NULL directly when the input is NULL and avoid the
212448 : // dynamic_cast in this case. This is likely a performance improvement as well.
212449 : // return dynamic_cast<SgExpression*>(inputDerivedClassPointer);
212450 : // Milind Chabbi (8/28/2013): isSgExpression uses table-driven castability instead of c++ default dynamic_cast
212451 : // this improves the running time performance by 10-20%.
212452 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExpression*>(inputDerivedClassPointer);
212453 94051500 : return IS_SgExpression_FAST_MACRO(inputDerivedClassPointer);
212454 : }
212455 :
212456 : // DQ (11/8/2003): Added version of functions taking const pointer
212457 2040440 : const SgExpression* isSgExpression ( const SgNode* inputDerivedClassPointer )
212458 : {
212459 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
212460 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
212461 : // So to fix this we return NULL directly when the input is NULL and avoid the
212462 : // dynamic_cast in this case. This is likely a performance improvement as well.
212463 : // return dynamic_cast<const SgExpression*>(inputDerivedClassPointer);
212464 : // Milind Chabbi (8/28/2013): isSgExpression uses table-driven castability instead of c++ default dynamic_cast
212465 : // this improves the running time performance by 10-20%.
212466 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExpression*>(inputDerivedClassPointer);
212467 2040440 : return IS_SgExpression_FAST_MACRO(inputDerivedClassPointer);
212468 : }
212469 :
212470 :
212471 :
212472 : /* #line 212473 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212473 :
212474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
212475 :
212476 : /**
212477 : \brief Generated destructor
212478 :
212479 : This destructor is automatically generated (by ROSETTA). This destructor
212480 : only frees memory of data members associated with the parts of the current IR node which
212481 : are NOT traversed. Those data members that are part of a traversal can be freed using
212482 : a traversal (calling this destructor on all children in a post-order traversal). Such
212483 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
212484 :
212485 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
212486 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
212487 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
212488 :
212489 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
212490 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
212491 : pointers are not yet implemented to call delete on eash pointer in the container.
212492 : (This could be done by derivation from the STL containers to define containers that
212493 : automatically deleted their members.)
212494 :
212495 : */
212496 103921 : SgExpression::~SgExpression () {
212497 103921 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
212498 :
212499 103921 : if (p_operatorPosition && p_operatorPosition->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_operatorPosition; }
212500 :
212501 : // case: not a listType for need_paren
212502 103921 : p_need_paren = false; // non list case
212503 : // case: not a listType for lvalue
212504 103921 : p_lvalue = false; // non list case
212505 : // case: not a listType for global_qualified_name
212506 103921 : p_global_qualified_name = false; // non list case
212507 : // case: not a listType for operatorPosition
212508 103921 : p_operatorPosition = NULL; // non list case
212509 :
212510 : }
212511 :
212512 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
212513 103921 : }
212514 :
212515 :
212516 : /* #line 212517 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212517 :
212518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
212519 :
212520 : // Generated constructor
212521 10956 : SgExpression::SgExpression ( Sg_File_Info* startOfConstruct )
212522 10956 : : SgLocatedNode(startOfConstruct)
212523 : {
212524 : #ifdef DEBUG
212525 : // printf ("In SgExpression::SgExpression (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
212526 : #endif
212527 : #if 0
212528 : // debugging information!
212529 : printf ("In SgExpression::SgExpression (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
212530 : #endif
212531 :
212532 10956 : p_need_paren = false;
212533 10956 : p_lvalue = false;
212534 10956 : p_global_qualified_name = false;
212535 10956 : p_operatorPosition = NULL;
212536 :
212537 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
212538 :
212539 : #if 0
212540 : // DQ (7/30/2014): Call a virtual function.
212541 : std::string s = this->class_name();
212542 : #endif
212543 :
212544 : // Test the variant virtual function
212545 : // assert(ExpressionTag == variant());
212546 10956 : assert(ExpressionTag == this->variant());
212547 10956 : ROSE_ASSERT(ExpressionTag == (int)(this->variantT()));
212548 10956 : post_construction_initialization();
212549 :
212550 : // Test the isSgExpression() function since it has been problematic
212551 10956 : assert(isSgExpression(this) != NULL);
212552 10956 : }
212553 :
212554 : // Generated constructor (all data members)
212555 :
212556 : /* #line 212557 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212557 :
212558 :
212559 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
212560 :
212561 :
212562 : // ********************************************************
212563 : // member functions common across all array grammar objects
212564 : // ********************************************************
212565 :
212566 :
212567 :
212568 : /* #line 212569 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212569 :
212570 :
212571 :
212572 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
212573 :
212574 : // ********************************************************
212575 : // member functions specific to each node in the grammar
212576 : // ********************************************************
212577 :
212578 :
212579 : /* #line 212580 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212580 :
212581 : // Start of memberFunctionString
212582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
212583 :
212584 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
212585 :
212586 : SgExpression*
212587 218887 : SgUnaryOp::get_operand_i () const
212588 : {
212589 218887 : ROSE_ASSERT (this != NULL);
212590 :
212591 : #if 0
212592 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
212593 : // used to trigger marking transformations for the token-based unparsing.
212594 : printf ("SgUnaryOp::get_operand_i = %p = %s \n",this,this->class_name().c_str());
212595 : #endif
212596 :
212597 218887 : return p_operand_i;
212598 : }
212599 :
212600 : void
212601 0 : SgUnaryOp::set_operand_i ( SgExpression* operand_i )
212602 : {
212603 0 : ROSE_ASSERT (this != NULL);
212604 :
212605 : #if 0
212606 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
212607 : // used to trigger marking transformations for the token-based unparsing.
212608 : printf ("SgUnaryOp::set_operand_i = %p = %s \n",this,this->class_name().c_str());
212609 : #endif
212610 :
212611 0 : set_isModified(true);
212612 :
212613 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
212614 : if (p_operand_i != NULL && operand_i != NULL && p_operand_i != operand_i)
212615 : {
212616 : printf ("Warning: operand_i = %p overwriting valid pointer p_operand_i = %p \n",operand_i,p_operand_i);
212617 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
212618 : printf ("Error fails assertion (p_operand_i != NULL && operand_i != NULL && p_operand_i != operand_i) is false\n");
212619 : ROSE_ASSERT(false);
212620 : #endif
212621 : }
212622 : #endif
212623 0 : p_operand_i = operand_i;
212624 0 : }
212625 :
212626 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
212627 :
212628 :
212629 : // End of memberFunctionString
212630 : // Start of memberFunctionString
212631 :
212632 :
212633 : // End of memberFunctionString
212634 : // Start of memberFunctionString
212635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
212636 :
212637 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
212638 :
212639 : SgUnaryOp::Sgop_mode
212640 2526 : SgUnaryOp::get_mode () const
212641 : {
212642 2526 : ROSE_ASSERT (this != NULL);
212643 :
212644 : #if 0
212645 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
212646 : // used to trigger marking transformations for the token-based unparsing.
212647 : printf ("SgUnaryOp::get_mode = %p = %s \n",this,this->class_name().c_str());
212648 : #endif
212649 :
212650 2526 : return p_mode;
212651 : }
212652 :
212653 : void
212654 5121 : SgUnaryOp::set_mode ( SgUnaryOp::Sgop_mode mode )
212655 : {
212656 5121 : ROSE_ASSERT (this != NULL);
212657 :
212658 : #if 0
212659 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
212660 : // used to trigger marking transformations for the token-based unparsing.
212661 : printf ("SgUnaryOp::set_mode = %p = %s \n",this,this->class_name().c_str());
212662 : #endif
212663 :
212664 5121 : set_isModified(true);
212665 :
212666 5121 : p_mode = mode;
212667 5121 : }
212668 :
212669 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
212670 :
212671 :
212672 : // End of memberFunctionString
212673 : // Start of memberFunctionString
212674 : /* #line 2799 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
212675 :
212676 :
212677 : void
212678 38903 : SgUnaryOp::post_construction_initialization()
212679 : {
212680 : // #ifndef REMOVE_SET_PARENT_FUNCTION
212681 38903 : if (get_operand())
212682 38428 : get_operand()->set_parent(this);
212683 : // #endif
212684 38903 : p_mode = SgUnaryOp::prefix;
212685 38903 : }
212686 :
212687 : SgExpression*
212688 202507 : SgUnaryOp::get_operand() const
212689 202507 : { return get_operand_i(); }
212690 :
212691 : void
212692 0 : SgUnaryOp::set_operand(SgExpression * exp)
212693 : {
212694 0 : set_operand_i(exp);
212695 : // #ifndef REMOVE_SET_PARENT_FUNCTION
212696 0 : if (exp)
212697 0 : exp->set_parent(this);
212698 : // #endif
212699 :
212700 : // DQ (1/14/2006): set_type is removed
212701 : // set_type();
212702 0 : }
212703 :
212704 : SgType*
212705 3267 : SgUnaryOp::get_type() const
212706 : {
212707 : // DQ (1/14/2006): Get the type from the operand
212708 : // return get_expression_type();
212709 :
212710 : #if 0
212711 : printf ("SgUnaryOp::get_type(): getting type from operand \n");
212712 : #endif
212713 :
212714 3267 : ROSE_ASSERT(get_operand() != NULL);
212715 :
212716 3267 : SgType* returnType = get_operand()->get_type();
212717 :
212718 3267 : return returnType;
212719 : }
212720 :
212721 : int
212722 0 : SgUnaryOp::length() const
212723 0 : { return 1;}
212724 :
212725 : bool
212726 0 : SgUnaryOp::empty() const
212727 0 : { return 0; }
212728 :
212729 : // void SgUnaryOp::operator_unparse(const char * op, Unparse_Info & info, ostream & os);
212730 :
212731 : #if 0
212732 : // This should be automatically generated!
212733 : int
212734 : SgUnaryOp::get_mode()
212735 : { return p_mode; }
212736 :
212737 : void
212738 : SgUnaryOp::set_mode(Sgop_mode m)
212739 : { p_mode=m; }
212740 : #endif
212741 :
212742 : SgExpression*
212743 0 : SgUnaryOp::get_next (int &n) const
212744 : {
212745 0 : if(n)
212746 : {
212747 : return NULL;
212748 : }
212749 : else
212750 : {
212751 0 : n++;
212752 0 : return get_operand();
212753 : }
212754 : }
212755 :
212756 : int
212757 0 : SgUnaryOp::replace_expression (SgExpression *o, SgExpression *n)
212758 : {
212759 : // DQ (12/17/2006): This function should have the semantics that it will represent a
212760 : // structural change to the AST, thus it is free to set the parent of the new expression.
212761 :
212762 0 : ROSE_ASSERT(o != NULL);
212763 0 : ROSE_ASSERT(n != NULL);
212764 :
212765 0 : if (get_operand() == o)
212766 : {
212767 0 : set_operand(n);
212768 0 : return 1;
212769 : }
212770 : else
212771 : {
212772 0 : printf ("Warning: inside of SgUnaryOp::replace_expression original SgExpression unidentified \n");
212773 0 : return 0;
212774 : }
212775 : }
212776 :
212777 :
212778 :
212779 : // End of memberFunctionString
212780 : // Start of memberFunctionString
212781 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
212782 :
212783 : // *** COMMON CODE SECTION BEGINS HERE ***
212784 :
212785 : #if 0
212786 : int
212787 : SgUnaryOp::getVariant() const
212788 : {
212789 : // This function is used in ROSE while "variant()" is used in SAGE
212790 : assert(this != NULL);
212791 : return variant();
212792 : }
212793 : #endif
212794 :
212795 : // This function is used in ROSE in treeTraversal code
212796 : // eventually replaces getVariant() and variant()
212797 : // though after variant() has been removed for a while we will
212798 : // want to change the name of variantT() back to variant()
212799 : // (since the "T" was ment to stand for temporary).
212800 : // When this happens the variantT() will be depricated.
212801 : VariantT
212802 116709 : SgUnaryOp::variantT() const
212803 : {
212804 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
212805 116709 : ROSE_ASSERT(this != NULL);
212806 116709 : return V_SgUnaryOp;
212807 : }
212808 :
212809 : #if 0
212810 : int
212811 : SgUnaryOp::variant() const
212812 : {
212813 : // This function is used in SAGE
212814 : ROSE_ASSERT(this != NULL);
212815 : return UNARY_EXPRESSION;
212816 : }
212817 : #endif
212818 :
212819 : ROSE_DLL_API const char*
212820 0 : SgUnaryOp::sage_class_name() const
212821 : {
212822 0 : ROSE_ASSERT(this != NULL);
212823 0 : return "SgUnaryOp";
212824 : }
212825 :
212826 : std::string
212827 0 : SgUnaryOp::class_name() const
212828 : {
212829 0 : ROSE_ASSERT(this != NULL);
212830 0 : return "SgUnaryOp";
212831 : }
212832 :
212833 : // DQ (11/26/2005): Support for visitor pattern mechanims
212834 : // (inferior to ROSE traversal mechanism, experimental).
212835 : void
212836 0 : SgUnaryOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
212837 : {
212838 0 : ROSE_ASSERT(this != NULL);
212839 0 : visitor.visit(this);
212840 0 : }
212841 :
212842 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
212843 0 : void SgUnaryOp::accept (ROSE_VisitorPattern & visitor) {
212844 0 : ROSE_ASSERT(this != NULL);
212845 0 : visitor.visit(this);
212846 0 : }
212847 :
212848 : SgUnaryOp*
212849 0 : SgUnaryOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
212850 : {
212851 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
212852 : // This function is currently only supported for the AST used the represent Binary executables.
212853 : if (0 /* isSgAsmNode(this) != NULL */)
212854 : {
212855 : // Support for regex specification.
212856 : std::string prefixCode = "REGEX:";
212857 : addNewAttribute(prefixCode + s,a);
212858 : }
212859 : #endif
212860 :
212861 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
212862 0 : return this;
212863 : }
212864 :
212865 : // *** COMMON CODE SECTION ENDS HERE ***
212866 :
212867 :
212868 : // End of memberFunctionString
212869 : // Start of memberFunctionString
212870 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
212871 :
212872 :
212873 : #if 0
212874 : //! Error checking support
212875 : /*! Verifies the following:
212876 : - working getVariant() member function
212877 : - calls base class's error() member function
212878 : Every class has one of these functions.
212879 : */
212880 : bool
212881 : SgUnaryOp::error()
212882 : {
212883 : // Put error checking here
212884 :
212885 : ROSE_ASSERT (this != NULL);
212886 : if (getVariant() != UNARY_EXPRESSION)
212887 : {
212888 : printf ("Error in SgUnaryOp::error(): SgUnaryOp object has a %s variant \n",
212889 : Cxx_GrammarTerminalNames[getVariant()].name);
212890 : // printf ("Error in SgUnaryOp::error() \n");
212891 : ROSE_ABORT();
212892 : }
212893 :
212894 : ROSE_ASSERT (getVariant() == UNARY_EXPRESSION);
212895 : return SgExpression::error();
212896 : }
212897 : #endif
212898 :
212899 :
212900 :
212901 : // End of memberFunctionString
212902 :
212903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
212904 :
212905 695038 : SgUnaryOp* isSgUnaryOp ( SgNode* inputDerivedClassPointer )
212906 : {
212907 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
212908 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
212909 : // So to fix this we return NULL directly when the input is NULL and avoid the
212910 : // dynamic_cast in this case. This is likely a performance improvement as well.
212911 : // return dynamic_cast<SgUnaryOp*>(inputDerivedClassPointer);
212912 : // Milind Chabbi (8/28/2013): isSgUnaryOp uses table-driven castability instead of c++ default dynamic_cast
212913 : // this improves the running time performance by 10-20%.
212914 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnaryOp*>(inputDerivedClassPointer);
212915 695038 : return IS_SgUnaryOp_FAST_MACRO(inputDerivedClassPointer);
212916 : }
212917 :
212918 : // DQ (11/8/2003): Added version of functions taking const pointer
212919 0 : const SgUnaryOp* isSgUnaryOp ( const SgNode* inputDerivedClassPointer )
212920 : {
212921 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
212922 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
212923 : // So to fix this we return NULL directly when the input is NULL and avoid the
212924 : // dynamic_cast in this case. This is likely a performance improvement as well.
212925 : // return dynamic_cast<const SgUnaryOp*>(inputDerivedClassPointer);
212926 : // Milind Chabbi (8/28/2013): isSgUnaryOp uses table-driven castability instead of c++ default dynamic_cast
212927 : // this improves the running time performance by 10-20%.
212928 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnaryOp*>(inputDerivedClassPointer);
212929 0 : return IS_SgUnaryOp_FAST_MACRO(inputDerivedClassPointer);
212930 : }
212931 :
212932 :
212933 :
212934 : /* #line 212935 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212935 :
212936 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
212937 :
212938 : /**
212939 : \brief Generated destructor
212940 :
212941 : This destructor is automatically generated (by ROSETTA). This destructor
212942 : only frees memory of data members associated with the parts of the current IR node which
212943 : are NOT traversed. Those data members that are part of a traversal can be freed using
212944 : a traversal (calling this destructor on all children in a post-order traversal). Such
212945 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
212946 :
212947 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
212948 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
212949 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
212950 :
212951 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
212952 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
212953 : pointers are not yet implemented to call delete on eash pointer in the container.
212954 : (This could be done by derivation from the STL containers to define containers that
212955 : automatically deleted their members.)
212956 :
212957 : */
212958 10489 : SgUnaryOp::~SgUnaryOp () {
212959 10489 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
212960 :
212961 :
212962 : // case: not a listType for operand_i
212963 10489 : p_operand_i = NULL; // non list case
212964 : // case: not a listType for expression_type
212965 10489 : p_expression_type = NULL; // non list case
212966 : // case: not a listType for mode
212967 10489 : p_mode = prefix; // non list case
212968 :
212969 : }
212970 :
212971 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
212972 10489 : }
212973 :
212974 :
212975 : /* #line 212976 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
212976 :
212977 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
212978 :
212979 : // Generated constructor
212980 1890 : SgUnaryOp::SgUnaryOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
212981 1890 : : SgExpression(startOfConstruct)
212982 : {
212983 : #ifdef DEBUG
212984 : // printf ("In SgUnaryOp::SgUnaryOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
212985 : #endif
212986 : #if 0
212987 : // debugging information!
212988 : printf ("In SgUnaryOp::SgUnaryOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
212989 : #endif
212990 :
212991 1890 : p_operand_i = operand_i;
212992 1890 : p_expression_type = expression_type;
212993 1890 : p_mode = prefix;
212994 :
212995 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
212996 :
212997 : #if 0
212998 : // DQ (7/30/2014): Call a virtual function.
212999 : std::string s = this->class_name();
213000 : #endif
213001 :
213002 : // Test the variant virtual function
213003 : // assert(UNARY_EXPRESSION == variant());
213004 1890 : assert(UNARY_EXPRESSION == this->variant());
213005 1890 : ROSE_ASSERT(UNARY_EXPRESSION == (int)(this->variantT()));
213006 1890 : post_construction_initialization();
213007 :
213008 : // Test the isSgUnaryOp() function since it has been problematic
213009 1890 : assert(isSgUnaryOp(this) != NULL);
213010 1890 : }
213011 :
213012 : // Generated constructor (all data members)
213013 :
213014 : /* #line 213015 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213015 :
213016 :
213017 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213018 :
213019 :
213020 : // ********************************************************
213021 : // member functions common across all array grammar objects
213022 : // ********************************************************
213023 :
213024 :
213025 :
213026 : /* #line 213027 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213027 :
213028 :
213029 :
213030 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213031 :
213032 : // ********************************************************
213033 : // member functions specific to each node in the grammar
213034 : // ********************************************************
213035 :
213036 :
213037 : /* #line 213038 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213038 :
213039 : // Start of memberFunctionString
213040 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213041 :
213042 : void
213043 0 : SgExpressionRoot::post_construction_initialization()
213044 : {
213045 0 : }
213046 :
213047 :
213048 :
213049 : // End of memberFunctionString
213050 : // Start of memberFunctionString
213051 : /* #line 3069 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213052 :
213053 : //QY:9/30/2004: removed stmt pointer inside exprRoot. Use parent pointer instead.
213054 : #if 0
213055 : void
213056 : SgExpressionRoot::initialize_root ( SgExpression* exp, SgStatement* stmt )
213057 : {
213058 : // The root of an expression should be an expression.
213059 : // If the expression's parent is a statement then the
213060 : // statement should contain an expression root object.
213061 :
213062 : // stmt should always be initialized to calling object's this pointer
213063 : ROSE_ASSERT(stmt != NULL);
213064 :
213065 : // set the parent of this expression to the calling statement
213066 : // (this might be better off set to NULL or some other value!)
213067 : // set_parent(stmt);
213068 : // Let the parent of the expression root be NULL (since it really should be an expression type)
213069 : // Access the parent through the p_statement pointer!
213070 : // set_parent(NULL);
213071 : // We can't call the set_parent function because it can't take a NULL pointer
213072 :
213073 : // We don't want to call set_statement since this will attempt to
213074 : // initialize the parent of stmt (which would be backwards)
213075 : // set_statement(stmt);
213076 : // p_statement = stmt;
213077 : // call the modified set_statement function
213078 : set_statement(stmt);
213079 :
213080 : // We use the SgExpressionRoot as the parent of the exp
213081 : // (this is the purpose of the SgExpressionRoot object)
213082 : // #ifndef REMOVE_SET_PARENT_FUNCTION
213083 : if (exp)
213084 : exp->set_parent(this);
213085 : // #endif
213086 : set_operand(exp);
213087 : }
213088 : #endif
213089 :
213090 : #if 0
213091 : // DQ (1/14/2006): set_type is removed
213092 : void
213093 : SgExpressionRoot::set_type()
213094 : {
213095 : if (get_operand())
213096 : set_expression_type(get_operand()->get_type());
213097 : else
213098 : set_expression_type(SgTypeDefault::createType());
213099 : }
213100 : #endif
213101 :
213102 : #if 0
213103 : // DQ (12/17/2006): Removed to clean up code (not used, I think).
213104 : //QY:9/30/2004: removed stmt pointer inside exprRoot. Use parent pointer instead.
213105 : void
213106 : SgExpressionRoot::set_statement( SgStatement* stmt )
213107 : {
213108 : set_parent(stmt);
213109 : }
213110 :
213111 : //QY:9/30/2004: removed stmt pointer inside exprRoot. Use parent pointer instead.
213112 : SgStatement*
213113 : SgExpressionRoot::get_statement() const
213114 : {
213115 : if (get_parent() == 0)
213116 : return 0;
213117 : SgStatement* res= isSgStatement( get_parent());
213118 : assert(res != 0);
213119 : return res;
213120 : }
213121 : #endif
213122 :
213123 :
213124 :
213125 : // End of memberFunctionString
213126 : // Start of memberFunctionString
213127 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
213128 :
213129 : // *** COMMON CODE SECTION BEGINS HERE ***
213130 :
213131 : #if 0
213132 : int
213133 : SgExpressionRoot::getVariant() const
213134 : {
213135 : // This function is used in ROSE while "variant()" is used in SAGE
213136 : assert(this != NULL);
213137 : return variant();
213138 : }
213139 : #endif
213140 :
213141 : // This function is used in ROSE in treeTraversal code
213142 : // eventually replaces getVariant() and variant()
213143 : // though after variant() has been removed for a while we will
213144 : // want to change the name of variantT() back to variant()
213145 : // (since the "T" was ment to stand for temporary).
213146 : // When this happens the variantT() will be depricated.
213147 : VariantT
213148 0 : SgExpressionRoot::variantT() const
213149 : {
213150 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
213151 0 : ROSE_ASSERT(this != NULL);
213152 0 : return V_SgExpressionRoot;
213153 : }
213154 :
213155 : #if 0
213156 : int
213157 : SgExpressionRoot::variant() const
213158 : {
213159 : // This function is used in SAGE
213160 : ROSE_ASSERT(this != NULL);
213161 : return EXPRESSION_ROOT;
213162 : }
213163 : #endif
213164 :
213165 : ROSE_DLL_API const char*
213166 0 : SgExpressionRoot::sage_class_name() const
213167 : {
213168 0 : ROSE_ASSERT(this != NULL);
213169 0 : return "SgExpressionRoot";
213170 : }
213171 :
213172 : std::string
213173 0 : SgExpressionRoot::class_name() const
213174 : {
213175 0 : ROSE_ASSERT(this != NULL);
213176 0 : return "SgExpressionRoot";
213177 : }
213178 :
213179 : // DQ (11/26/2005): Support for visitor pattern mechanims
213180 : // (inferior to ROSE traversal mechanism, experimental).
213181 : void
213182 0 : SgExpressionRoot::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
213183 : {
213184 0 : ROSE_ASSERT(this != NULL);
213185 0 : visitor.visit(this);
213186 0 : }
213187 :
213188 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
213189 0 : void SgExpressionRoot::accept (ROSE_VisitorPattern & visitor) {
213190 0 : ROSE_ASSERT(this != NULL);
213191 0 : visitor.visit(this);
213192 0 : }
213193 :
213194 : SgExpressionRoot*
213195 0 : SgExpressionRoot::addRegExpAttribute(std::string s, AstRegExAttribute* a)
213196 : {
213197 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
213198 : // This function is currently only supported for the AST used the represent Binary executables.
213199 : if (0 /* isSgAsmNode(this) != NULL */)
213200 : {
213201 : // Support for regex specification.
213202 : std::string prefixCode = "REGEX:";
213203 : addNewAttribute(prefixCode + s,a);
213204 : }
213205 : #endif
213206 :
213207 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
213208 0 : return this;
213209 : }
213210 :
213211 : // *** COMMON CODE SECTION ENDS HERE ***
213212 :
213213 :
213214 : // End of memberFunctionString
213215 : // Start of memberFunctionString
213216 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
213217 :
213218 :
213219 : #if 0
213220 : //! Error checking support
213221 : /*! Verifies the following:
213222 : - working getVariant() member function
213223 : - calls base class's error() member function
213224 : Every class has one of these functions.
213225 : */
213226 : bool
213227 : SgExpressionRoot::error()
213228 : {
213229 : // Put error checking here
213230 :
213231 : ROSE_ASSERT (this != NULL);
213232 : if (getVariant() != EXPRESSION_ROOT)
213233 : {
213234 : printf ("Error in SgExpressionRoot::error(): SgExpressionRoot object has a %s variant \n",
213235 : Cxx_GrammarTerminalNames[getVariant()].name);
213236 : // printf ("Error in SgExpressionRoot::error() \n");
213237 : ROSE_ABORT();
213238 : }
213239 :
213240 : ROSE_ASSERT (getVariant() == EXPRESSION_ROOT);
213241 : return SgUnaryOp::error();
213242 : }
213243 : #endif
213244 :
213245 :
213246 :
213247 : // End of memberFunctionString
213248 :
213249 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
213250 :
213251 0 : SgExpressionRoot* isSgExpressionRoot ( SgNode* inputDerivedClassPointer )
213252 : {
213253 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
213254 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
213255 : // So to fix this we return NULL directly when the input is NULL and avoid the
213256 : // dynamic_cast in this case. This is likely a performance improvement as well.
213257 : // return dynamic_cast<SgExpressionRoot*>(inputDerivedClassPointer);
213258 : // Milind Chabbi (8/28/2013): isSgExpressionRoot uses table-driven castability instead of c++ default dynamic_cast
213259 : // this improves the running time performance by 10-20%.
213260 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExpressionRoot*>(inputDerivedClassPointer);
213261 0 : return IS_SgExpressionRoot_FAST_MACRO(inputDerivedClassPointer);
213262 : }
213263 :
213264 : // DQ (11/8/2003): Added version of functions taking const pointer
213265 0 : const SgExpressionRoot* isSgExpressionRoot ( const SgNode* inputDerivedClassPointer )
213266 : {
213267 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
213268 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
213269 : // So to fix this we return NULL directly when the input is NULL and avoid the
213270 : // dynamic_cast in this case. This is likely a performance improvement as well.
213271 : // return dynamic_cast<const SgExpressionRoot*>(inputDerivedClassPointer);
213272 : // Milind Chabbi (8/28/2013): isSgExpressionRoot uses table-driven castability instead of c++ default dynamic_cast
213273 : // this improves the running time performance by 10-20%.
213274 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExpressionRoot*>(inputDerivedClassPointer);
213275 0 : return IS_SgExpressionRoot_FAST_MACRO(inputDerivedClassPointer);
213276 : }
213277 :
213278 :
213279 :
213280 : /* #line 213281 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213281 :
213282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
213283 :
213284 : /**
213285 : \brief Generated destructor
213286 :
213287 : This destructor is automatically generated (by ROSETTA). This destructor
213288 : only frees memory of data members associated with the parts of the current IR node which
213289 : are NOT traversed. Those data members that are part of a traversal can be freed using
213290 : a traversal (calling this destructor on all children in a post-order traversal). Such
213291 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
213292 :
213293 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
213294 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
213295 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
213296 :
213297 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
213298 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
213299 : pointers are not yet implemented to call delete on eash pointer in the container.
213300 : (This could be done by derivation from the STL containers to define containers that
213301 : automatically deleted their members.)
213302 :
213303 : */
213304 0 : SgExpressionRoot::~SgExpressionRoot () {
213305 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
213306 :
213307 :
213308 :
213309 : }
213310 :
213311 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
213312 0 : }
213313 :
213314 :
213315 : /* #line 213316 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213316 :
213317 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
213318 :
213319 : // Generated constructor
213320 0 : SgExpressionRoot::SgExpressionRoot ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
213321 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
213322 : {
213323 : #ifdef DEBUG
213324 : // printf ("In SgExpressionRoot::SgExpressionRoot (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
213325 : #endif
213326 : #if 0
213327 : // debugging information!
213328 : printf ("In SgExpressionRoot::SgExpressionRoot (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
213329 : #endif
213330 :
213331 :
213332 :
213333 : #if 0
213334 : // DQ (7/30/2014): Call a virtual function.
213335 : std::string s = this->class_name();
213336 : #endif
213337 :
213338 : // Test the variant virtual function
213339 : // assert(EXPRESSION_ROOT == variant());
213340 0 : assert(EXPRESSION_ROOT == this->variant());
213341 0 : ROSE_ASSERT(EXPRESSION_ROOT == (int)(this->variantT()));
213342 0 : post_construction_initialization();
213343 :
213344 : // Test the isSgExpressionRoot() function since it has been problematic
213345 0 : assert(isSgExpressionRoot(this) != NULL);
213346 0 : }
213347 :
213348 : // Generated constructor (all data members)
213349 :
213350 : /* #line 213351 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213351 :
213352 :
213353 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213354 :
213355 :
213356 : // ********************************************************
213357 : // member functions common across all array grammar objects
213358 : // ********************************************************
213359 :
213360 :
213361 :
213362 : /* #line 213363 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213363 :
213364 :
213365 :
213366 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213367 :
213368 : // ********************************************************
213369 : // member functions specific to each node in the grammar
213370 : // ********************************************************
213371 :
213372 :
213373 : /* #line 213374 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213374 :
213375 : // Start of memberFunctionString
213376 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213377 :
213378 : void
213379 609 : SgMinusOp::post_construction_initialization()
213380 : {
213381 609 : }
213382 :
213383 :
213384 :
213385 : // End of memberFunctionString
213386 : // Start of memberFunctionString
213387 : /* #line 5291 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213388 :
213389 :
213390 :
213391 : // End of memberFunctionString
213392 : // Start of memberFunctionString
213393 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
213394 :
213395 : // *** COMMON CODE SECTION BEGINS HERE ***
213396 :
213397 : #if 0
213398 : int
213399 : SgMinusOp::getVariant() const
213400 : {
213401 : // This function is used in ROSE while "variant()" is used in SAGE
213402 : assert(this != NULL);
213403 : return variant();
213404 : }
213405 : #endif
213406 :
213407 : // This function is used in ROSE in treeTraversal code
213408 : // eventually replaces getVariant() and variant()
213409 : // though after variant() has been removed for a while we will
213410 : // want to change the name of variantT() back to variant()
213411 : // (since the "T" was ment to stand for temporary).
213412 : // When this happens the variantT() will be depricated.
213413 : VariantT
213414 164063 : SgMinusOp::variantT() const
213415 : {
213416 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
213417 164063 : ROSE_ASSERT(this != NULL);
213418 164063 : return V_SgMinusOp;
213419 : }
213420 :
213421 : #if 0
213422 : int
213423 : SgMinusOp::variant() const
213424 : {
213425 : // This function is used in SAGE
213426 : ROSE_ASSERT(this != NULL);
213427 : return UNARY_MINUS_OP;
213428 : }
213429 : #endif
213430 :
213431 : ROSE_DLL_API const char*
213432 22 : SgMinusOp::sage_class_name() const
213433 : {
213434 22 : ROSE_ASSERT(this != NULL);
213435 22 : return "SgMinusOp";
213436 : }
213437 :
213438 : std::string
213439 532 : SgMinusOp::class_name() const
213440 : {
213441 532 : ROSE_ASSERT(this != NULL);
213442 532 : return "SgMinusOp";
213443 : }
213444 :
213445 : // DQ (11/26/2005): Support for visitor pattern mechanims
213446 : // (inferior to ROSE traversal mechanism, experimental).
213447 : void
213448 7928 : SgMinusOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
213449 : {
213450 7928 : ROSE_ASSERT(this != NULL);
213451 7928 : visitor.visit(this);
213452 7928 : }
213453 :
213454 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
213455 0 : void SgMinusOp::accept (ROSE_VisitorPattern & visitor) {
213456 0 : ROSE_ASSERT(this != NULL);
213457 0 : visitor.visit(this);
213458 0 : }
213459 :
213460 : SgMinusOp*
213461 0 : SgMinusOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
213462 : {
213463 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
213464 : // This function is currently only supported for the AST used the represent Binary executables.
213465 : if (0 /* isSgAsmNode(this) != NULL */)
213466 : {
213467 : // Support for regex specification.
213468 : std::string prefixCode = "REGEX:";
213469 : addNewAttribute(prefixCode + s,a);
213470 : }
213471 : #endif
213472 :
213473 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
213474 0 : return this;
213475 : }
213476 :
213477 : // *** COMMON CODE SECTION ENDS HERE ***
213478 :
213479 :
213480 : // End of memberFunctionString
213481 : // Start of memberFunctionString
213482 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
213483 :
213484 :
213485 : #if 0
213486 : //! Error checking support
213487 : /*! Verifies the following:
213488 : - working getVariant() member function
213489 : - calls base class's error() member function
213490 : Every class has one of these functions.
213491 : */
213492 : bool
213493 : SgMinusOp::error()
213494 : {
213495 : // Put error checking here
213496 :
213497 : ROSE_ASSERT (this != NULL);
213498 : if (getVariant() != UNARY_MINUS_OP)
213499 : {
213500 : printf ("Error in SgMinusOp::error(): SgMinusOp object has a %s variant \n",
213501 : Cxx_GrammarTerminalNames[getVariant()].name);
213502 : // printf ("Error in SgMinusOp::error() \n");
213503 : ROSE_ABORT();
213504 : }
213505 :
213506 : ROSE_ASSERT (getVariant() == UNARY_MINUS_OP);
213507 : return SgUnaryOp::error();
213508 : }
213509 : #endif
213510 :
213511 :
213512 :
213513 : // End of memberFunctionString
213514 :
213515 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
213516 :
213517 1950 : SgMinusOp* isSgMinusOp ( SgNode* inputDerivedClassPointer )
213518 : {
213519 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
213520 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
213521 : // So to fix this we return NULL directly when the input is NULL and avoid the
213522 : // dynamic_cast in this case. This is likely a performance improvement as well.
213523 : // return dynamic_cast<SgMinusOp*>(inputDerivedClassPointer);
213524 : // Milind Chabbi (8/28/2013): isSgMinusOp uses table-driven castability instead of c++ default dynamic_cast
213525 : // this improves the running time performance by 10-20%.
213526 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMinusOp*>(inputDerivedClassPointer);
213527 1950 : return IS_SgMinusOp_FAST_MACRO(inputDerivedClassPointer);
213528 : }
213529 :
213530 : // DQ (11/8/2003): Added version of functions taking const pointer
213531 0 : const SgMinusOp* isSgMinusOp ( const SgNode* inputDerivedClassPointer )
213532 : {
213533 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
213534 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
213535 : // So to fix this we return NULL directly when the input is NULL and avoid the
213536 : // dynamic_cast in this case. This is likely a performance improvement as well.
213537 : // return dynamic_cast<const SgMinusOp*>(inputDerivedClassPointer);
213538 : // Milind Chabbi (8/28/2013): isSgMinusOp uses table-driven castability instead of c++ default dynamic_cast
213539 : // this improves the running time performance by 10-20%.
213540 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMinusOp*>(inputDerivedClassPointer);
213541 0 : return IS_SgMinusOp_FAST_MACRO(inputDerivedClassPointer);
213542 : }
213543 :
213544 :
213545 :
213546 : /* #line 213547 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213547 :
213548 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
213549 :
213550 : /**
213551 : \brief Generated destructor
213552 :
213553 : This destructor is automatically generated (by ROSETTA). This destructor
213554 : only frees memory of data members associated with the parts of the current IR node which
213555 : are NOT traversed. Those data members that are part of a traversal can be freed using
213556 : a traversal (calling this destructor on all children in a post-order traversal). Such
213557 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
213558 :
213559 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
213560 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
213561 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
213562 :
213563 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
213564 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
213565 : pointers are not yet implemented to call delete on eash pointer in the container.
213566 : (This could be done by derivation from the STL containers to define containers that
213567 : automatically deleted their members.)
213568 :
213569 : */
213570 230 : SgMinusOp::~SgMinusOp () {
213571 115 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
213572 :
213573 :
213574 :
213575 : }
213576 :
213577 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
213578 230 : }
213579 :
213580 :
213581 : /* #line 213582 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213582 :
213583 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
213584 :
213585 : // Generated constructor
213586 37 : SgMinusOp::SgMinusOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
213587 37 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
213588 : {
213589 : #ifdef DEBUG
213590 : // printf ("In SgMinusOp::SgMinusOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
213591 : #endif
213592 : #if 0
213593 : // debugging information!
213594 : printf ("In SgMinusOp::SgMinusOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
213595 : #endif
213596 :
213597 :
213598 :
213599 : #if 0
213600 : // DQ (7/30/2014): Call a virtual function.
213601 : std::string s = this->class_name();
213602 : #endif
213603 :
213604 : // Test the variant virtual function
213605 : // assert(UNARY_MINUS_OP == variant());
213606 37 : assert(UNARY_MINUS_OP == this->variant());
213607 37 : ROSE_ASSERT(UNARY_MINUS_OP == (int)(this->variantT()));
213608 37 : post_construction_initialization();
213609 :
213610 : // Test the isSgMinusOp() function since it has been problematic
213611 37 : assert(isSgMinusOp(this) != NULL);
213612 37 : }
213613 :
213614 : // Generated constructor (all data members)
213615 :
213616 : /* #line 213617 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213617 :
213618 :
213619 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213620 :
213621 :
213622 : // ********************************************************
213623 : // member functions common across all array grammar objects
213624 : // ********************************************************
213625 :
213626 :
213627 :
213628 : /* #line 213629 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213629 :
213630 :
213631 :
213632 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213633 :
213634 : // ********************************************************
213635 : // member functions specific to each node in the grammar
213636 : // ********************************************************
213637 :
213638 :
213639 : /* #line 213640 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213640 :
213641 : // Start of memberFunctionString
213642 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213643 :
213644 : void
213645 1 : SgUnaryAddOp::post_construction_initialization()
213646 : {
213647 1 : }
213648 :
213649 :
213650 :
213651 : // End of memberFunctionString
213652 : // Start of memberFunctionString
213653 : /* #line 5294 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213654 :
213655 :
213656 :
213657 : // End of memberFunctionString
213658 : // Start of memberFunctionString
213659 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
213660 :
213661 : // *** COMMON CODE SECTION BEGINS HERE ***
213662 :
213663 : #if 0
213664 : int
213665 : SgUnaryAddOp::getVariant() const
213666 : {
213667 : // This function is used in ROSE while "variant()" is used in SAGE
213668 : assert(this != NULL);
213669 : return variant();
213670 : }
213671 : #endif
213672 :
213673 : // This function is used in ROSE in treeTraversal code
213674 : // eventually replaces getVariant() and variant()
213675 : // though after variant() has been removed for a while we will
213676 : // want to change the name of variantT() back to variant()
213677 : // (since the "T" was ment to stand for temporary).
213678 : // When this happens the variantT() will be depricated.
213679 : VariantT
213680 230 : SgUnaryAddOp::variantT() const
213681 : {
213682 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
213683 230 : ROSE_ASSERT(this != NULL);
213684 230 : return V_SgUnaryAddOp;
213685 : }
213686 :
213687 : #if 0
213688 : int
213689 : SgUnaryAddOp::variant() const
213690 : {
213691 : // This function is used in SAGE
213692 : ROSE_ASSERT(this != NULL);
213693 : return UNARY_ADD_OP;
213694 : }
213695 : #endif
213696 :
213697 : ROSE_DLL_API const char*
213698 2 : SgUnaryAddOp::sage_class_name() const
213699 : {
213700 2 : ROSE_ASSERT(this != NULL);
213701 2 : return "SgUnaryAddOp";
213702 : }
213703 :
213704 : std::string
213705 1 : SgUnaryAddOp::class_name() const
213706 : {
213707 1 : ROSE_ASSERT(this != NULL);
213708 1 : return "SgUnaryAddOp";
213709 : }
213710 :
213711 : // DQ (11/26/2005): Support for visitor pattern mechanims
213712 : // (inferior to ROSE traversal mechanism, experimental).
213713 : void
213714 18 : SgUnaryAddOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
213715 : {
213716 18 : ROSE_ASSERT(this != NULL);
213717 18 : visitor.visit(this);
213718 18 : }
213719 :
213720 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
213721 0 : void SgUnaryAddOp::accept (ROSE_VisitorPattern & visitor) {
213722 0 : ROSE_ASSERT(this != NULL);
213723 0 : visitor.visit(this);
213724 0 : }
213725 :
213726 : SgUnaryAddOp*
213727 0 : SgUnaryAddOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
213728 : {
213729 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
213730 : // This function is currently only supported for the AST used the represent Binary executables.
213731 : if (0 /* isSgAsmNode(this) != NULL */)
213732 : {
213733 : // Support for regex specification.
213734 : std::string prefixCode = "REGEX:";
213735 : addNewAttribute(prefixCode + s,a);
213736 : }
213737 : #endif
213738 :
213739 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
213740 0 : return this;
213741 : }
213742 :
213743 : // *** COMMON CODE SECTION ENDS HERE ***
213744 :
213745 :
213746 : // End of memberFunctionString
213747 : // Start of memberFunctionString
213748 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
213749 :
213750 :
213751 : #if 0
213752 : //! Error checking support
213753 : /*! Verifies the following:
213754 : - working getVariant() member function
213755 : - calls base class's error() member function
213756 : Every class has one of these functions.
213757 : */
213758 : bool
213759 : SgUnaryAddOp::error()
213760 : {
213761 : // Put error checking here
213762 :
213763 : ROSE_ASSERT (this != NULL);
213764 : if (getVariant() != UNARY_ADD_OP)
213765 : {
213766 : printf ("Error in SgUnaryAddOp::error(): SgUnaryAddOp object has a %s variant \n",
213767 : Cxx_GrammarTerminalNames[getVariant()].name);
213768 : // printf ("Error in SgUnaryAddOp::error() \n");
213769 : ROSE_ABORT();
213770 : }
213771 :
213772 : ROSE_ASSERT (getVariant() == UNARY_ADD_OP);
213773 : return SgUnaryOp::error();
213774 : }
213775 : #endif
213776 :
213777 :
213778 :
213779 : // End of memberFunctionString
213780 :
213781 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
213782 :
213783 78 : SgUnaryAddOp* isSgUnaryAddOp ( SgNode* inputDerivedClassPointer )
213784 : {
213785 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
213786 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
213787 : // So to fix this we return NULL directly when the input is NULL and avoid the
213788 : // dynamic_cast in this case. This is likely a performance improvement as well.
213789 : // return dynamic_cast<SgUnaryAddOp*>(inputDerivedClassPointer);
213790 : // Milind Chabbi (8/28/2013): isSgUnaryAddOp uses table-driven castability instead of c++ default dynamic_cast
213791 : // this improves the running time performance by 10-20%.
213792 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnaryAddOp*>(inputDerivedClassPointer);
213793 78 : return IS_SgUnaryAddOp_FAST_MACRO(inputDerivedClassPointer);
213794 : }
213795 :
213796 : // DQ (11/8/2003): Added version of functions taking const pointer
213797 0 : const SgUnaryAddOp* isSgUnaryAddOp ( const SgNode* inputDerivedClassPointer )
213798 : {
213799 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
213800 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
213801 : // So to fix this we return NULL directly when the input is NULL and avoid the
213802 : // dynamic_cast in this case. This is likely a performance improvement as well.
213803 : // return dynamic_cast<const SgUnaryAddOp*>(inputDerivedClassPointer);
213804 : // Milind Chabbi (8/28/2013): isSgUnaryAddOp uses table-driven castability instead of c++ default dynamic_cast
213805 : // this improves the running time performance by 10-20%.
213806 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnaryAddOp*>(inputDerivedClassPointer);
213807 0 : return IS_SgUnaryAddOp_FAST_MACRO(inputDerivedClassPointer);
213808 : }
213809 :
213810 :
213811 :
213812 : /* #line 213813 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213813 :
213814 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
213815 :
213816 : /**
213817 : \brief Generated destructor
213818 :
213819 : This destructor is automatically generated (by ROSETTA). This destructor
213820 : only frees memory of data members associated with the parts of the current IR node which
213821 : are NOT traversed. Those data members that are part of a traversal can be freed using
213822 : a traversal (calling this destructor on all children in a post-order traversal). Such
213823 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
213824 :
213825 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
213826 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
213827 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
213828 :
213829 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
213830 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
213831 : pointers are not yet implemented to call delete on eash pointer in the container.
213832 : (This could be done by derivation from the STL containers to define containers that
213833 : automatically deleted their members.)
213834 :
213835 : */
213836 0 : SgUnaryAddOp::~SgUnaryAddOp () {
213837 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
213838 :
213839 :
213840 :
213841 : }
213842 :
213843 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
213844 0 : }
213845 :
213846 :
213847 : /* #line 213848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213848 :
213849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
213850 :
213851 : // Generated constructor
213852 0 : SgUnaryAddOp::SgUnaryAddOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
213853 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
213854 : {
213855 : #ifdef DEBUG
213856 : // printf ("In SgUnaryAddOp::SgUnaryAddOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
213857 : #endif
213858 : #if 0
213859 : // debugging information!
213860 : printf ("In SgUnaryAddOp::SgUnaryAddOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
213861 : #endif
213862 :
213863 :
213864 :
213865 : #if 0
213866 : // DQ (7/30/2014): Call a virtual function.
213867 : std::string s = this->class_name();
213868 : #endif
213869 :
213870 : // Test the variant virtual function
213871 : // assert(UNARY_ADD_OP == variant());
213872 0 : assert(UNARY_ADD_OP == this->variant());
213873 0 : ROSE_ASSERT(UNARY_ADD_OP == (int)(this->variantT()));
213874 0 : post_construction_initialization();
213875 :
213876 : // Test the isSgUnaryAddOp() function since it has been problematic
213877 0 : assert(isSgUnaryAddOp(this) != NULL);
213878 0 : }
213879 :
213880 : // Generated constructor (all data members)
213881 :
213882 : /* #line 213883 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213883 :
213884 :
213885 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213886 :
213887 :
213888 : // ********************************************************
213889 : // member functions common across all array grammar objects
213890 : // ********************************************************
213891 :
213892 :
213893 :
213894 : /* #line 213895 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213895 :
213896 :
213897 :
213898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
213899 :
213900 : // ********************************************************
213901 : // member functions specific to each node in the grammar
213902 : // ********************************************************
213903 :
213904 :
213905 : /* #line 213906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
213906 :
213907 : // Start of memberFunctionString
213908 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213909 :
213910 : void
213911 2473 : SgNotOp::post_construction_initialization()
213912 : {
213913 2473 : }
213914 :
213915 :
213916 :
213917 : // End of memberFunctionString
213918 : // Start of memberFunctionString
213919 : /* #line 5083 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213920 :
213921 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213922 :
213923 :
213924 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
213925 : SgType*
213926 1908 : SgNotOp::get_type() const
213927 : {
213928 : #if 0
213929 : printf ("In SgNotOp::get_type() \n");
213930 : #endif
213931 :
213932 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
213933 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
213934 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
213935 1908 : SgType* returnType = (SageInterface::is_C_language() == true) ?
213936 28 : static_cast<SgType*>(SgTypeInt::createType()) :
213937 1880 : static_cast<SgType*>(SgTypeBool::createType());
213938 1908 : ROSE_ASSERT(returnType != NULL);
213939 1908 : return returnType;
213940 : }
213941 :
213942 :
213943 :
213944 :
213945 : // End of memberFunctionString
213946 : // Start of memberFunctionString
213947 : /* #line 8116 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
213948 :
213949 :
213950 : #if 0
213951 : #error "This code from SOURCE_INTEGER_OPERATOR_EXPRESSION should not be used"
213952 :
213953 : // DQ (1/14/2006): set_type is removed
213954 : void
213955 : SgNotOp::set_type()
213956 : {
213957 : set_expression_type(SgTypeInt::createType());
213958 : }
213959 : #endif
213960 :
213961 :
213962 :
213963 : // End of memberFunctionString
213964 : // Start of memberFunctionString
213965 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
213966 :
213967 : // *** COMMON CODE SECTION BEGINS HERE ***
213968 :
213969 : #if 0
213970 : int
213971 : SgNotOp::getVariant() const
213972 : {
213973 : // This function is used in ROSE while "variant()" is used in SAGE
213974 : assert(this != NULL);
213975 : return variant();
213976 : }
213977 : #endif
213978 :
213979 : // This function is used in ROSE in treeTraversal code
213980 : // eventually replaces getVariant() and variant()
213981 : // though after variant() has been removed for a while we will
213982 : // want to change the name of variantT() back to variant()
213983 : // (since the "T" was ment to stand for temporary).
213984 : // When this happens the variantT() will be depricated.
213985 : VariantT
213986 698355 : SgNotOp::variantT() const
213987 : {
213988 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
213989 698355 : ROSE_ASSERT(this != NULL);
213990 698355 : return V_SgNotOp;
213991 : }
213992 :
213993 : #if 0
213994 : int
213995 : SgNotOp::variant() const
213996 : {
213997 : // This function is used in SAGE
213998 : ROSE_ASSERT(this != NULL);
213999 : return NOT_OP;
214000 : }
214001 : #endif
214002 :
214003 : ROSE_DLL_API const char*
214004 12 : SgNotOp::sage_class_name() const
214005 : {
214006 12 : ROSE_ASSERT(this != NULL);
214007 12 : return "SgNotOp";
214008 : }
214009 :
214010 : std::string
214011 1884 : SgNotOp::class_name() const
214012 : {
214013 1884 : ROSE_ASSERT(this != NULL);
214014 1884 : return "SgNotOp";
214015 : }
214016 :
214017 : // DQ (11/26/2005): Support for visitor pattern mechanims
214018 : // (inferior to ROSE traversal mechanism, experimental).
214019 : void
214020 30583 : SgNotOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
214021 : {
214022 30583 : ROSE_ASSERT(this != NULL);
214023 30583 : visitor.visit(this);
214024 30583 : }
214025 :
214026 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
214027 0 : void SgNotOp::accept (ROSE_VisitorPattern & visitor) {
214028 0 : ROSE_ASSERT(this != NULL);
214029 0 : visitor.visit(this);
214030 0 : }
214031 :
214032 : SgNotOp*
214033 0 : SgNotOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
214034 : {
214035 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
214036 : // This function is currently only supported for the AST used the represent Binary executables.
214037 : if (0 /* isSgAsmNode(this) != NULL */)
214038 : {
214039 : // Support for regex specification.
214040 : std::string prefixCode = "REGEX:";
214041 : addNewAttribute(prefixCode + s,a);
214042 : }
214043 : #endif
214044 :
214045 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
214046 0 : return this;
214047 : }
214048 :
214049 : // *** COMMON CODE SECTION ENDS HERE ***
214050 :
214051 :
214052 : // End of memberFunctionString
214053 : // Start of memberFunctionString
214054 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
214055 :
214056 :
214057 : #if 0
214058 : //! Error checking support
214059 : /*! Verifies the following:
214060 : - working getVariant() member function
214061 : - calls base class's error() member function
214062 : Every class has one of these functions.
214063 : */
214064 : bool
214065 : SgNotOp::error()
214066 : {
214067 : // Put error checking here
214068 :
214069 : ROSE_ASSERT (this != NULL);
214070 : if (getVariant() != NOT_OP)
214071 : {
214072 : printf ("Error in SgNotOp::error(): SgNotOp object has a %s variant \n",
214073 : Cxx_GrammarTerminalNames[getVariant()].name);
214074 : // printf ("Error in SgNotOp::error() \n");
214075 : ROSE_ABORT();
214076 : }
214077 :
214078 : ROSE_ASSERT (getVariant() == NOT_OP);
214079 : return SgUnaryOp::error();
214080 : }
214081 : #endif
214082 :
214083 :
214084 :
214085 : // End of memberFunctionString
214086 :
214087 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
214088 :
214089 3617 : SgNotOp* isSgNotOp ( SgNode* inputDerivedClassPointer )
214090 : {
214091 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
214092 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
214093 : // So to fix this we return NULL directly when the input is NULL and avoid the
214094 : // dynamic_cast in this case. This is likely a performance improvement as well.
214095 : // return dynamic_cast<SgNotOp*>(inputDerivedClassPointer);
214096 : // Milind Chabbi (8/28/2013): isSgNotOp uses table-driven castability instead of c++ default dynamic_cast
214097 : // this improves the running time performance by 10-20%.
214098 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNotOp*>(inputDerivedClassPointer);
214099 3617 : return IS_SgNotOp_FAST_MACRO(inputDerivedClassPointer);
214100 : }
214101 :
214102 : // DQ (11/8/2003): Added version of functions taking const pointer
214103 0 : const SgNotOp* isSgNotOp ( const SgNode* inputDerivedClassPointer )
214104 : {
214105 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
214106 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
214107 : // So to fix this we return NULL directly when the input is NULL and avoid the
214108 : // dynamic_cast in this case. This is likely a performance improvement as well.
214109 : // return dynamic_cast<const SgNotOp*>(inputDerivedClassPointer);
214110 : // Milind Chabbi (8/28/2013): isSgNotOp uses table-driven castability instead of c++ default dynamic_cast
214111 : // this improves the running time performance by 10-20%.
214112 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNotOp*>(inputDerivedClassPointer);
214113 0 : return IS_SgNotOp_FAST_MACRO(inputDerivedClassPointer);
214114 : }
214115 :
214116 :
214117 :
214118 : /* #line 214119 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214119 :
214120 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
214121 :
214122 : /**
214123 : \brief Generated destructor
214124 :
214125 : This destructor is automatically generated (by ROSETTA). This destructor
214126 : only frees memory of data members associated with the parts of the current IR node which
214127 : are NOT traversed. Those data members that are part of a traversal can be freed using
214128 : a traversal (calling this destructor on all children in a post-order traversal). Such
214129 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
214130 :
214131 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
214132 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
214133 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
214134 :
214135 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
214136 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
214137 : pointers are not yet implemented to call delete on eash pointer in the container.
214138 : (This could be done by derivation from the STL containers to define containers that
214139 : automatically deleted their members.)
214140 :
214141 : */
214142 1492 : SgNotOp::~SgNotOp () {
214143 746 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
214144 :
214145 :
214146 :
214147 : }
214148 :
214149 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
214150 1492 : }
214151 :
214152 :
214153 : /* #line 214154 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214154 :
214155 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
214156 :
214157 : // Generated constructor
214158 242 : SgNotOp::SgNotOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
214159 242 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
214160 : {
214161 : #ifdef DEBUG
214162 : // printf ("In SgNotOp::SgNotOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
214163 : #endif
214164 : #if 0
214165 : // debugging information!
214166 : printf ("In SgNotOp::SgNotOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
214167 : #endif
214168 :
214169 :
214170 :
214171 : #if 0
214172 : // DQ (7/30/2014): Call a virtual function.
214173 : std::string s = this->class_name();
214174 : #endif
214175 :
214176 : // Test the variant virtual function
214177 : // assert(NOT_OP == variant());
214178 242 : assert(NOT_OP == this->variant());
214179 242 : ROSE_ASSERT(NOT_OP == (int)(this->variantT()));
214180 242 : post_construction_initialization();
214181 :
214182 : // Test the isSgNotOp() function since it has been problematic
214183 242 : assert(isSgNotOp(this) != NULL);
214184 242 : }
214185 :
214186 : // Generated constructor (all data members)
214187 :
214188 : /* #line 214189 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214189 :
214190 :
214191 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
214192 :
214193 :
214194 : // ********************************************************
214195 : // member functions common across all array grammar objects
214196 : // ********************************************************
214197 :
214198 :
214199 :
214200 : /* #line 214201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214201 :
214202 :
214203 :
214204 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
214205 :
214206 : // ********************************************************
214207 : // member functions specific to each node in the grammar
214208 : // ********************************************************
214209 :
214210 :
214211 : /* #line 214212 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214212 :
214213 : // Start of memberFunctionString
214214 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
214215 :
214216 : void
214217 3724 : SgPointerDerefExp::post_construction_initialization()
214218 : {
214219 3724 : }
214220 :
214221 :
214222 :
214223 : // End of memberFunctionString
214224 : // Start of memberFunctionString
214225 : /* #line 5870 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
214226 :
214227 :
214228 : // SgType* SgPointerDerefExp::get_type() const
214229 : SgType*
214230 4379 : SgPointerDerefExp::get_type() const
214231 : {
214232 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
214233 :
214234 : // DQ (7/28/2006): This code can't be used for both the SgPointerDerefExp and the SgPntrArrRefExp IR nodes because
214235 : // it is a bit different (one node is a unary operator and the other is a binary operator).
214236 :
214237 : // This function returns the base type of the type returned from get_operand()->get_type() (which should be a SgPointerType).
214238 :
214239 4379 : ROSE_ASSERT(get_operand() != NULL);
214240 :
214241 : // printf ("In SgPointerDerefExp::get_type(): get_operand() = %p = %s \n",get_operand(),get_operand()->class_name().c_str());
214242 :
214243 : #if 0
214244 : printf ("In SgPointerDerefExp::get_type() \n");
214245 : #endif
214246 :
214247 4379 : SgType* someType = get_operand()->get_type();
214248 4379 : ROSE_ASSERT(someType != NULL);
214249 : #if 0
214250 : printf ("In SgPointerDerefExp::get_type(): %s->get_type() = %p = %s \n",
214251 : get_operand()->class_name().c_str(),get_operand()->get_type(),
214252 : get_operand()->get_type()->class_name().c_str());
214253 : #endif
214254 4379 : if (p_expression_type != NULL)
214255 : {
214256 0 : printf ("In SgPointerDerefExp::get_type(): p_expression_type = %s \n",p_expression_type->class_name().c_str());
214257 : }
214258 :
214259 : // This code should be shared between the SgPntrArrRefExp and the SgPointerDerefExp IR nodes
214260 : // A better idea would be to have a function that strips off types based on a set of flags
214261 : // that would control stripping of pointer references, array references, C++ references,
214262 : // modifiers, and typedefs.
214263 :
214264 4580 : SgType* returnType = NULL;
214265 4580 : keepStripping:
214266 4580 : ROSE_ASSERT (someType);
214267 4580 : switch(someType->variantT())
214268 : {
214269 : // These cases all have base types and the pointer dereferencing returns the base type
214270 : // But since p_base_type is placed at each of the different SgType IR nodes we have
214271 : // to handle each case separately.
214272 3327 : case V_SgPointerType:
214273 3327 : {
214274 3327 : SgPointerType* pointerType = isSgPointerType(someType);
214275 3327 : returnType = pointerType->get_base_type();
214276 : #if 0
214277 : printf ("In SgPointerDerefExp::get_type(): SgPointerType: BEFORE stripType(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
214278 : #endif
214279 : // DQ (6/11/2014): We also need to take any associated SgModifierType node chains used to modity the SgPointerType (e.g. defining const or UPC shared type attributes).
214280 3327 : returnType = returnType->stripType (SgType::STRIP_MODIFIER_TYPE);
214281 : #if 0
214282 : printf ("In SgPointerDerefExp::get_type(): SgPointerType: AFTER stripType(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
214283 : #endif
214284 3327 : break;
214285 : }
214286 138 : case V_SgArrayType:
214287 138 : {
214288 138 : SgArrayType* arrayType = isSgArrayType(someType);
214289 138 : returnType = arrayType->get_base_type();
214290 138 : break;
214291 : }
214292 201 : case V_SgTypedefType:
214293 201 : {
214294 201 : SgTypedefType* typedefType = isSgTypedefType(someType);
214295 201 : someType = typedefType->get_base_type();
214296 201 : goto keepStripping;
214297 : }
214298 0 : case V_SgReferenceType:
214299 0 : {
214300 0 : SgReferenceType* referenceType = isSgReferenceType(someType);
214301 0 : someType = referenceType->get_base_type();
214302 0 : goto keepStripping;
214303 : }
214304 0 : case V_SgModifierType:
214305 0 : {
214306 0 : SgModifierType* modifierType = isSgModifierType(someType);
214307 0 : someType = modifierType->get_base_type();
214308 0 : goto keepStripping;
214309 : }
214310 :
214311 : // DQ (5/10/2016): Added this for the case of the C++11 support.
214312 0 : case V_SgRvalueReferenceType:
214313 0 : {
214314 0 : SgRvalueReferenceType* rvalueReferenceType = isSgRvalueReferenceType(someType);
214315 : // returnType = rvalueReferenceType;
214316 0 : someType = rvalueReferenceType->get_base_type();
214317 0 : goto keepStripping;
214318 : }
214319 :
214320 : // DQ (9/27/2012): Added case to avoid falling through the default case (more template support).
214321 : case V_SgTemplateType:
214322 : {
214323 : // DQ (9/27/2012): I think that this is the correct handling of the return value generation.
214324 : returnType = someType;
214325 : break;
214326 : }
214327 :
214328 : // DQ (9/27/2012): The dereference of a function type is a function call so the type is it's return type (I think)
214329 0 : case V_SgMemberFunctionType:
214330 0 : {
214331 0 : SgMemberFunctionType* memberFunctionType = isSgMemberFunctionType(someType);
214332 : // returnType = functionType->get_return_type();
214333 0 : returnType = memberFunctionType;
214334 0 : break;
214335 : }
214336 :
214337 : // DQ (5/25/2013): Added this for the case of the new EDG interface.
214338 : // DQ (6/18/2007): The dereference of a function type is a function call so the type is it's return type (I think)
214339 0 : case V_SgFunctionType:
214340 0 : {
214341 0 : SgFunctionType* functionType = isSgFunctionType(someType);
214342 : // returnType = functionType->get_return_type();
214343 0 : returnType = functionType;
214344 0 : break;
214345 : }
214346 :
214347 : // DQ (5/25/2013): Added this for the case of the new EDG interface.
214348 8 : case V_SgClassType:
214349 8 : {
214350 8 : SgClassType* classType = isSgClassType(someType);
214351 8 : returnType = classType;
214352 8 : break;
214353 : }
214354 :
214355 : // DQ (7/13/2013): Added this for the case of the new EDG interface.
214356 0 : case V_SgTypeVoid:
214357 0 : {
214358 0 : SgTypeVoid* voidType = isSgTypeVoid(someType);
214359 0 : returnType = voidType;
214360 0 : break;
214361 : }
214362 :
214363 : #if 0
214364 : // DQ (10/3/2006): I think this is no longer required, since we fixed the case of sizeof taking an
214365 : // expression (not required to be an lvalue)!
214366 : // DQ (9/30/2006): This case appears where the expression of sizeof is a literal (in this case a char*).
214367 : // This can be a SgTypeChar for "sizeof('\x1234567890123456789012345678901234567890')",
214368 : // it is not clear how to handle this case, at present we just return the SgTypeChar type.
214369 : case V_SgTypeChar:
214370 : {
214371 : returnType = someType;
214372 : break;
214373 : }
214374 : #endif
214375 : // DQ (2/16/2014): Added this for the case of the new EDG interface (sometimes this case is required).
214376 : case V_SgTypeUnknown:
214377 : {
214378 : returnType = someType;
214379 : break;
214380 : }
214381 :
214382 : default:
214383 : {
214384 : // DQ (10/23/2016): Commented out message to avoid output spew.
214385 : // DQ (12/31/2008): This is the new behavior for EDG version 4.x.
214386 : // printf ("Warning: default reached in In SgPointerDerefExp::get_type() someType = %s \n",someType->class_name().c_str());
214387 : returnType = someType;
214388 : }
214389 : }
214390 :
214391 4379 : ROSE_ASSERT(returnType != NULL);
214392 4379 : return returnType;
214393 : }
214394 :
214395 :
214396 :
214397 : // End of memberFunctionString
214398 : // Start of memberFunctionString
214399 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
214400 :
214401 : // *** COMMON CODE SECTION BEGINS HERE ***
214402 :
214403 : #if 0
214404 : int
214405 : SgPointerDerefExp::getVariant() const
214406 : {
214407 : // This function is used in ROSE while "variant()" is used in SAGE
214408 : assert(this != NULL);
214409 : return variant();
214410 : }
214411 : #endif
214412 :
214413 : // This function is used in ROSE in treeTraversal code
214414 : // eventually replaces getVariant() and variant()
214415 : // though after variant() has been removed for a while we will
214416 : // want to change the name of variantT() back to variant()
214417 : // (since the "T" was ment to stand for temporary).
214418 : // When this happens the variantT() will be depricated.
214419 : VariantT
214420 1223830 : SgPointerDerefExp::variantT() const
214421 : {
214422 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
214423 1223830 : ROSE_ASSERT(this != NULL);
214424 1223830 : return V_SgPointerDerefExp;
214425 : }
214426 :
214427 : #if 0
214428 : int
214429 : SgPointerDerefExp::variant() const
214430 : {
214431 : // This function is used in SAGE
214432 : ROSE_ASSERT(this != NULL);
214433 : return DEREF_OP;
214434 : }
214435 : #endif
214436 :
214437 : ROSE_DLL_API const char*
214438 236 : SgPointerDerefExp::sage_class_name() const
214439 : {
214440 236 : ROSE_ASSERT(this != NULL);
214441 236 : return "SgPointerDerefExp";
214442 : }
214443 :
214444 : std::string
214445 3106 : SgPointerDerefExp::class_name() const
214446 : {
214447 3106 : ROSE_ASSERT(this != NULL);
214448 3106 : return "SgPointerDerefExp";
214449 : }
214450 :
214451 : // DQ (11/26/2005): Support for visitor pattern mechanims
214452 : // (inferior to ROSE traversal mechanism, experimental).
214453 : void
214454 54533 : SgPointerDerefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
214455 : {
214456 54533 : ROSE_ASSERT(this != NULL);
214457 54533 : visitor.visit(this);
214458 54533 : }
214459 :
214460 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
214461 0 : void SgPointerDerefExp::accept (ROSE_VisitorPattern & visitor) {
214462 0 : ROSE_ASSERT(this != NULL);
214463 0 : visitor.visit(this);
214464 0 : }
214465 :
214466 : SgPointerDerefExp*
214467 0 : SgPointerDerefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
214468 : {
214469 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
214470 : // This function is currently only supported for the AST used the represent Binary executables.
214471 : if (0 /* isSgAsmNode(this) != NULL */)
214472 : {
214473 : // Support for regex specification.
214474 : std::string prefixCode = "REGEX:";
214475 : addNewAttribute(prefixCode + s,a);
214476 : }
214477 : #endif
214478 :
214479 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
214480 0 : return this;
214481 : }
214482 :
214483 : // *** COMMON CODE SECTION ENDS HERE ***
214484 :
214485 :
214486 : // End of memberFunctionString
214487 : // Start of memberFunctionString
214488 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
214489 :
214490 :
214491 : #if 0
214492 : //! Error checking support
214493 : /*! Verifies the following:
214494 : - working getVariant() member function
214495 : - calls base class's error() member function
214496 : Every class has one of these functions.
214497 : */
214498 : bool
214499 : SgPointerDerefExp::error()
214500 : {
214501 : // Put error checking here
214502 :
214503 : ROSE_ASSERT (this != NULL);
214504 : if (getVariant() != DEREF_OP)
214505 : {
214506 : printf ("Error in SgPointerDerefExp::error(): SgPointerDerefExp object has a %s variant \n",
214507 : Cxx_GrammarTerminalNames[getVariant()].name);
214508 : // printf ("Error in SgPointerDerefExp::error() \n");
214509 : ROSE_ABORT();
214510 : }
214511 :
214512 : ROSE_ASSERT (getVariant() == DEREF_OP);
214513 : return SgUnaryOp::error();
214514 : }
214515 : #endif
214516 :
214517 :
214518 :
214519 : // End of memberFunctionString
214520 :
214521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
214522 :
214523 34631 : SgPointerDerefExp* isSgPointerDerefExp ( SgNode* inputDerivedClassPointer )
214524 : {
214525 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
214526 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
214527 : // So to fix this we return NULL directly when the input is NULL and avoid the
214528 : // dynamic_cast in this case. This is likely a performance improvement as well.
214529 : // return dynamic_cast<SgPointerDerefExp*>(inputDerivedClassPointer);
214530 : // Milind Chabbi (8/28/2013): isSgPointerDerefExp uses table-driven castability instead of c++ default dynamic_cast
214531 : // this improves the running time performance by 10-20%.
214532 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPointerDerefExp*>(inputDerivedClassPointer);
214533 34631 : return IS_SgPointerDerefExp_FAST_MACRO(inputDerivedClassPointer);
214534 : }
214535 :
214536 : // DQ (11/8/2003): Added version of functions taking const pointer
214537 0 : const SgPointerDerefExp* isSgPointerDerefExp ( const SgNode* inputDerivedClassPointer )
214538 : {
214539 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
214540 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
214541 : // So to fix this we return NULL directly when the input is NULL and avoid the
214542 : // dynamic_cast in this case. This is likely a performance improvement as well.
214543 : // return dynamic_cast<const SgPointerDerefExp*>(inputDerivedClassPointer);
214544 : // Milind Chabbi (8/28/2013): isSgPointerDerefExp uses table-driven castability instead of c++ default dynamic_cast
214545 : // this improves the running time performance by 10-20%.
214546 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPointerDerefExp*>(inputDerivedClassPointer);
214547 0 : return IS_SgPointerDerefExp_FAST_MACRO(inputDerivedClassPointer);
214548 : }
214549 :
214550 :
214551 :
214552 : /* #line 214553 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214553 :
214554 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
214555 :
214556 : /**
214557 : \brief Generated destructor
214558 :
214559 : This destructor is automatically generated (by ROSETTA). This destructor
214560 : only frees memory of data members associated with the parts of the current IR node which
214561 : are NOT traversed. Those data members that are part of a traversal can be freed using
214562 : a traversal (calling this destructor on all children in a post-order traversal). Such
214563 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
214564 :
214565 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
214566 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
214567 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
214568 :
214569 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
214570 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
214571 : pointers are not yet implemented to call delete on eash pointer in the container.
214572 : (This could be done by derivation from the STL containers to define containers that
214573 : automatically deleted their members.)
214574 :
214575 : */
214576 1616 : SgPointerDerefExp::~SgPointerDerefExp () {
214577 808 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
214578 :
214579 :
214580 :
214581 : }
214582 :
214583 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
214584 1616 : }
214585 :
214586 :
214587 : /* #line 214588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214588 :
214589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
214590 :
214591 : // Generated constructor
214592 88 : SgPointerDerefExp::SgPointerDerefExp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
214593 88 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
214594 : {
214595 : #ifdef DEBUG
214596 : // printf ("In SgPointerDerefExp::SgPointerDerefExp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
214597 : #endif
214598 : #if 0
214599 : // debugging information!
214600 : printf ("In SgPointerDerefExp::SgPointerDerefExp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
214601 : #endif
214602 :
214603 :
214604 :
214605 : #if 0
214606 : // DQ (7/30/2014): Call a virtual function.
214607 : std::string s = this->class_name();
214608 : #endif
214609 :
214610 : // Test the variant virtual function
214611 : // assert(DEREF_OP == variant());
214612 88 : assert(DEREF_OP == this->variant());
214613 88 : ROSE_ASSERT(DEREF_OP == (int)(this->variantT()));
214614 88 : post_construction_initialization();
214615 :
214616 : // Test the isSgPointerDerefExp() function since it has been problematic
214617 88 : assert(isSgPointerDerefExp(this) != NULL);
214618 88 : }
214619 :
214620 : // Generated constructor (all data members)
214621 :
214622 : /* #line 214623 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214623 :
214624 :
214625 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
214626 :
214627 :
214628 : // ********************************************************
214629 : // member functions common across all array grammar objects
214630 : // ********************************************************
214631 :
214632 :
214633 :
214634 : /* #line 214635 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214635 :
214636 :
214637 :
214638 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
214639 :
214640 : // ********************************************************
214641 : // member functions specific to each node in the grammar
214642 : // ********************************************************
214643 :
214644 :
214645 : /* #line 214646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214646 :
214647 : // Start of memberFunctionString
214648 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
214649 :
214650 : void
214651 796 : SgAddressOfOp::post_construction_initialization()
214652 : {
214653 796 : }
214654 :
214655 :
214656 :
214657 : // End of memberFunctionString
214658 : // Start of memberFunctionString
214659 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
214660 :
214661 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
214662 :
214663 : SgExpression*
214664 1578 : SgAddressOfOp::get_originalExpressionTree () const
214665 : {
214666 1578 : ROSE_ASSERT (this != NULL);
214667 :
214668 : #if 0
214669 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
214670 : // used to trigger marking transformations for the token-based unparsing.
214671 : printf ("SgAddressOfOp::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
214672 : #endif
214673 :
214674 1578 : return p_originalExpressionTree;
214675 : }
214676 :
214677 : void
214678 2 : SgAddressOfOp::set_originalExpressionTree ( SgExpression* originalExpressionTree )
214679 : {
214680 2 : ROSE_ASSERT (this != NULL);
214681 :
214682 : #if 0
214683 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
214684 : // used to trigger marking transformations for the token-based unparsing.
214685 : printf ("SgAddressOfOp::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
214686 : #endif
214687 :
214688 2 : set_isModified(true);
214689 :
214690 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
214691 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
214692 : {
214693 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
214694 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
214695 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
214696 : ROSE_ASSERT(false);
214697 : #endif
214698 : }
214699 : #endif
214700 2 : p_originalExpressionTree = originalExpressionTree;
214701 2 : }
214702 :
214703 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
214704 :
214705 :
214706 : // End of memberFunctionString
214707 : // Start of memberFunctionString
214708 : /* #line 6042 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
214709 :
214710 :
214711 : SgType*
214712 750 : SgAddressOfOp::get_type() const
214713 : {
214714 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
214715 :
214716 : // This function returns a pointer to the type return from get_operand()->get_type().
214717 :
214718 : #if 0
214719 : printf ("In SgAddressOfOp::get_type() \n");
214720 : #endif
214721 :
214722 750 : ROSE_ASSERT(get_operand() != NULL);
214723 750 : SgType* baseType = get_operand()->get_type();
214724 750 : ROSE_ASSERT(baseType != NULL);
214725 :
214726 : // DQ (7/31/2006): Suggested change by Jeremiah.
214727 : // SgType* returnType = SgPointerType::createType(baseType);
214728 750 : SgClassDefinition* classDefinition = NULL;
214729 :
214730 : // DQ (7/31/2006): check if this is a data member of a class
214731 : // (and save the class for the SgPointerMemberType::createType() function!)
214732 750 : SgVarRefExp* varRefExp = isSgVarRefExp(get_operand());
214733 750 : if (varRefExp != NULL)
214734 : {
214735 396 : ROSE_ASSERT(varRefExp->get_symbol() != NULL);
214736 396 : ROSE_ASSERT(varRefExp->get_symbol()->get_declaration() != NULL);
214737 396 : SgInitializedName* variable = varRefExp->get_symbol()->get_declaration();
214738 396 : ROSE_ASSERT(variable != NULL);
214739 396 : SgScopeStatement* scope = variable->get_scope();
214740 396 : ROSE_ASSERT(scope != NULL);
214741 :
214742 396 : classDefinition = isSgClassDefinition(scope);
214743 : }
214744 :
214745 : // printf ("In SgAddressOfOp::get_type(): classDefinition is valid = %s \n",(classDefinition != NULL) ? "true" : "false");
214746 :
214747 1146 : SgType* returnType = NULL;
214748 396 : if (classDefinition != NULL)
214749 : {
214750 0 : SgClassType* classType = classDefinition->get_declaration()->get_type();
214751 0 : returnType = SgPointerMemberType::createType(baseType,classType);
214752 : #if 0
214753 : // DQ (7/16/2014): Make this a warning for the moment.
214754 : printf ("Warning: In SgAddressOfOp::get_type(): checkForSharedTypeAndReturnSharedType() not supported for generation of SgPointerMemberType \n");
214755 : #endif
214756 : }
214757 : else
214758 : {
214759 : // Milind Chabbi (8/1/2013) We must strip the reference else we will get pointer to a reference.
214760 : // See CompileTests/Cxx_tests/test2004_157.C run under extractFunctionArgumentsNormalization
214761 : // TODO: should we strip STRIP_TYPEDEF_TYPE? Not sure, need to talk to Dan.
214762 : // DQ (7/16/2014): Dan says no. Don't strip the typedef or we could generate references to types
214763 : // in the AST that might be private or inaccessible when we compile the unparsed the source code).
214764 : // TV (11/13/2018): Added r-value reference handling
214765 750 : returnType = SgPointerType::createType(baseType->stripType(SgType::STRIP_REFERENCE_TYPE|SgType::STRIP_RVALUE_REFERENCE_TYPE));
214766 :
214767 : // DQ (7/16/2014): In the case of UPC shared type for the lhs_operand, we need to return a type that is marked as
214768 : // shared (even if the type on the rhs_operand is non-shared) (see UPC_tests/test2014_56.c for an example).
214769 750 : returnType = checkForSharedTypeAndReturnSharedType(returnType);
214770 : }
214771 :
214772 : // ROSE_ASSERT(returnType != NULL);
214773 750 : return returnType;
214774 : }
214775 :
214776 :
214777 : // DQ (7/16/2014): Shared types from expressions in UPC have some expected symantics that are not a matter of returning the result of get_type().
214778 : // This function supports the get_type() function.
214779 : SgType*
214780 750 : SgAddressOfOp::checkForSharedTypeAndReturnSharedType( SgType* possibleReturnType ) const
214781 : {
214782 : // DQ (7/16/2014): In the case of UPC shared type for the lhs_operand, we need to return a type that is marked as
214783 : // shared (even if the type on the rhs_operand is non-shared) (see UPC_tests/test2014_56.c for an example).
214784 :
214785 750 : SgType* returnType = possibleReturnType;
214786 :
214787 750 : ROSE_ASSERT(get_operand()->get_type() != NULL);
214788 750 : SgModifierType* mod_type = isSgModifierType(get_operand()->get_type());
214789 750 : if (mod_type != NULL)
214790 : {
214791 : #if 0
214792 : printf ("In SgAddressOfOp::checkForSharedTypeAndReturnSharedType(): (mod_type != NULL): get_operand()->get_type() = %p = %s \n",get_operand()->get_type(),get_operand()->get_type()->class_name().c_str());
214793 : #endif
214794 0 : if (mod_type->get_typeModifier().get_upcModifier().get_isShared() == true)
214795 : {
214796 : #if 0
214797 : printf ("In SgAddressOfOp::checkForSharedTypeAndReturnSharedType(): Detected a UPC shared lhs type in the evaluation of the type for SgAddressOf expression (need to return a type same as rhs type, but marked as shared) \n");
214798 : #endif
214799 0 : returnType = SageBuilder::buildUpcSharedType(possibleReturnType);
214800 : }
214801 : }
214802 : else
214803 : {
214804 : #if 0
214805 : printf ("In SgAddressOfOp::checkForSharedTypeAndReturnSharedType(): (mod_type == NULL): get_operand()->get_type() = %p = %s \n",get_operand()->get_type(),get_operand()->get_type()->class_name().c_str());
214806 : #endif
214807 750 : SgPointerType* pointerType = isSgPointerType(get_operand()->get_type());
214808 750 : if (pointerType != NULL)
214809 : {
214810 : #if 0
214811 : printf ("In SgAddressOfOp::checkForSharedTypeAndReturnSharedType(): Detected pointer type: pointerType = %p \n",pointerType);
214812 : #endif
214813 135 : SgType* base_type = pointerType->get_base_type();
214814 135 : SgModifierType* modifier_type = isSgModifierType(base_type);
214815 135 : while (modifier_type != NULL && modifier_type->get_typeModifier().get_upcModifier().get_isShared() == false)
214816 : {
214817 : #if 0
214818 : printf ("In SgAddressOfOp::checkForSharedTypeAndReturnSharedType(): SgPointerType: SgModifierType type: (loop): Detected a SgModifierType \n");
214819 : #endif
214820 0 : modifier_type = isSgModifierType(modifier_type->get_base_type());
214821 : }
214822 135 : if (modifier_type != NULL && modifier_type->get_typeModifier().get_upcModifier().get_isShared() == true)
214823 : {
214824 : #if 0
214825 : printf ("In SgAddressOfOp::checkForSharedTypeAndReturnSharedType(): SgPointerType: SgModifierType type: Detected a UPC shared lhs type in the evaluation of the type for SgAddressOf expression (need to return a type same as rhs type, but marked as shared) \n");
214826 : #endif
214827 0 : returnType = SageBuilder::buildUpcSharedType(possibleReturnType);
214828 : }
214829 : }
214830 : }
214831 :
214832 750 : return returnType;
214833 : }
214834 :
214835 :
214836 :
214837 :
214838 :
214839 : // End of memberFunctionString
214840 : // Start of memberFunctionString
214841 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
214842 :
214843 : // *** COMMON CODE SECTION BEGINS HERE ***
214844 :
214845 : #if 0
214846 : int
214847 : SgAddressOfOp::getVariant() const
214848 : {
214849 : // This function is used in ROSE while "variant()" is used in SAGE
214850 : assert(this != NULL);
214851 : return variant();
214852 : }
214853 : #endif
214854 :
214855 : // This function is used in ROSE in treeTraversal code
214856 : // eventually replaces getVariant() and variant()
214857 : // though after variant() has been removed for a while we will
214858 : // want to change the name of variantT() back to variant()
214859 : // (since the "T" was ment to stand for temporary).
214860 : // When this happens the variantT() will be depricated.
214861 : VariantT
214862 207264 : SgAddressOfOp::variantT() const
214863 : {
214864 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
214865 207264 : ROSE_ASSERT(this != NULL);
214866 207264 : return V_SgAddressOfOp;
214867 : }
214868 :
214869 : #if 0
214870 : int
214871 : SgAddressOfOp::variant() const
214872 : {
214873 : // This function is used in SAGE
214874 : ROSE_ASSERT(this != NULL);
214875 : return ADDRESS_OP;
214876 : }
214877 : #endif
214878 :
214879 : ROSE_DLL_API const char*
214880 51 : SgAddressOfOp::sage_class_name() const
214881 : {
214882 51 : ROSE_ASSERT(this != NULL);
214883 51 : return "SgAddressOfOp";
214884 : }
214885 :
214886 : std::string
214887 698 : SgAddressOfOp::class_name() const
214888 : {
214889 698 : ROSE_ASSERT(this != NULL);
214890 698 : return "SgAddressOfOp";
214891 : }
214892 :
214893 : // DQ (11/26/2005): Support for visitor pattern mechanims
214894 : // (inferior to ROSE traversal mechanism, experimental).
214895 : void
214896 11649 : SgAddressOfOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
214897 : {
214898 11649 : ROSE_ASSERT(this != NULL);
214899 11649 : visitor.visit(this);
214900 11649 : }
214901 :
214902 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
214903 0 : void SgAddressOfOp::accept (ROSE_VisitorPattern & visitor) {
214904 0 : ROSE_ASSERT(this != NULL);
214905 0 : visitor.visit(this);
214906 0 : }
214907 :
214908 : SgAddressOfOp*
214909 0 : SgAddressOfOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
214910 : {
214911 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
214912 : // This function is currently only supported for the AST used the represent Binary executables.
214913 : if (0 /* isSgAsmNode(this) != NULL */)
214914 : {
214915 : // Support for regex specification.
214916 : std::string prefixCode = "REGEX:";
214917 : addNewAttribute(prefixCode + s,a);
214918 : }
214919 : #endif
214920 :
214921 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
214922 0 : return this;
214923 : }
214924 :
214925 : // *** COMMON CODE SECTION ENDS HERE ***
214926 :
214927 :
214928 : // End of memberFunctionString
214929 : // Start of memberFunctionString
214930 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
214931 :
214932 :
214933 : #if 0
214934 : //! Error checking support
214935 : /*! Verifies the following:
214936 : - working getVariant() member function
214937 : - calls base class's error() member function
214938 : Every class has one of these functions.
214939 : */
214940 : bool
214941 : SgAddressOfOp::error()
214942 : {
214943 : // Put error checking here
214944 :
214945 : ROSE_ASSERT (this != NULL);
214946 : if (getVariant() != ADDRESS_OP)
214947 : {
214948 : printf ("Error in SgAddressOfOp::error(): SgAddressOfOp object has a %s variant \n",
214949 : Cxx_GrammarTerminalNames[getVariant()].name);
214950 : // printf ("Error in SgAddressOfOp::error() \n");
214951 : ROSE_ABORT();
214952 : }
214953 :
214954 : ROSE_ASSERT (getVariant() == ADDRESS_OP);
214955 : return SgUnaryOp::error();
214956 : }
214957 : #endif
214958 :
214959 :
214960 :
214961 : // End of memberFunctionString
214962 :
214963 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
214964 :
214965 181536 : SgAddressOfOp* isSgAddressOfOp ( SgNode* inputDerivedClassPointer )
214966 : {
214967 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
214968 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
214969 : // So to fix this we return NULL directly when the input is NULL and avoid the
214970 : // dynamic_cast in this case. This is likely a performance improvement as well.
214971 : // return dynamic_cast<SgAddressOfOp*>(inputDerivedClassPointer);
214972 : // Milind Chabbi (8/28/2013): isSgAddressOfOp uses table-driven castability instead of c++ default dynamic_cast
214973 : // this improves the running time performance by 10-20%.
214974 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAddressOfOp*>(inputDerivedClassPointer);
214975 181536 : return IS_SgAddressOfOp_FAST_MACRO(inputDerivedClassPointer);
214976 : }
214977 :
214978 : // DQ (11/8/2003): Added version of functions taking const pointer
214979 0 : const SgAddressOfOp* isSgAddressOfOp ( const SgNode* inputDerivedClassPointer )
214980 : {
214981 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
214982 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
214983 : // So to fix this we return NULL directly when the input is NULL and avoid the
214984 : // dynamic_cast in this case. This is likely a performance improvement as well.
214985 : // return dynamic_cast<const SgAddressOfOp*>(inputDerivedClassPointer);
214986 : // Milind Chabbi (8/28/2013): isSgAddressOfOp uses table-driven castability instead of c++ default dynamic_cast
214987 : // this improves the running time performance by 10-20%.
214988 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAddressOfOp*>(inputDerivedClassPointer);
214989 0 : return IS_SgAddressOfOp_FAST_MACRO(inputDerivedClassPointer);
214990 : }
214991 :
214992 :
214993 :
214994 : /* #line 214995 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
214995 :
214996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
214997 :
214998 : /**
214999 : \brief Generated destructor
215000 :
215001 : This destructor is automatically generated (by ROSETTA). This destructor
215002 : only frees memory of data members associated with the parts of the current IR node which
215003 : are NOT traversed. Those data members that are part of a traversal can be freed using
215004 : a traversal (calling this destructor on all children in a post-order traversal). Such
215005 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
215006 :
215007 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
215008 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
215009 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
215010 :
215011 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
215012 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
215013 : pointers are not yet implemented to call delete on eash pointer in the container.
215014 : (This could be done by derivation from the STL containers to define containers that
215015 : automatically deleted their members.)
215016 :
215017 : */
215018 338 : SgAddressOfOp::~SgAddressOfOp () {
215019 169 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
215020 :
215021 :
215022 : // case: not a listType for originalExpressionTree
215023 169 : p_originalExpressionTree = NULL; // non list case
215024 :
215025 : }
215026 :
215027 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215028 338 : }
215029 :
215030 :
215031 : /* #line 215032 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215032 :
215033 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
215034 :
215035 : // Generated constructor
215036 16 : SgAddressOfOp::SgAddressOfOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
215037 16 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
215038 : {
215039 : #ifdef DEBUG
215040 : // printf ("In SgAddressOfOp::SgAddressOfOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
215041 : #endif
215042 : #if 0
215043 : // debugging information!
215044 : printf ("In SgAddressOfOp::SgAddressOfOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
215045 : #endif
215046 :
215047 16 : p_originalExpressionTree = NULL;
215048 :
215049 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
215050 :
215051 : #if 0
215052 : // DQ (7/30/2014): Call a virtual function.
215053 : std::string s = this->class_name();
215054 : #endif
215055 :
215056 : // Test the variant virtual function
215057 : // assert(ADDRESS_OP == variant());
215058 16 : assert(ADDRESS_OP == this->variant());
215059 16 : ROSE_ASSERT(ADDRESS_OP == (int)(this->variantT()));
215060 16 : post_construction_initialization();
215061 :
215062 : // Test the isSgAddressOfOp() function since it has been problematic
215063 16 : assert(isSgAddressOfOp(this) != NULL);
215064 16 : }
215065 :
215066 : // Generated constructor (all data members)
215067 :
215068 : /* #line 215069 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215069 :
215070 :
215071 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215072 :
215073 :
215074 : // ********************************************************
215075 : // member functions common across all array grammar objects
215076 : // ********************************************************
215077 :
215078 :
215079 :
215080 : /* #line 215081 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215081 :
215082 :
215083 :
215084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215085 :
215086 : // ********************************************************
215087 : // member functions specific to each node in the grammar
215088 : // ********************************************************
215089 :
215090 :
215091 : /* #line 215092 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215092 :
215093 : // Start of memberFunctionString
215094 : /* #line 6173 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
215095 :
215096 0 : SgMinusMinusOp::SgMinusMinusOp(Sg_File_Info * fi, SgExpression * exp, Sgop_mode a_mode)
215097 0 : : SgUnaryOp(fi, exp, NULL)
215098 : {
215099 0 : set_mode(a_mode);
215100 0 : if (exp)
215101 0 : exp->set_parent(this);
215102 0 : }
215103 :
215104 0 : SgMinusMinusOp::SgMinusMinusOp(SgExpression * exp, Sgop_mode a_mode)
215105 0 : : SgUnaryOp(exp, NULL)
215106 : {
215107 0 : set_mode(a_mode);
215108 0 : if (exp)
215109 0 : exp->set_parent(this);
215110 0 : }
215111 :
215112 : void
215113 564 : SgMinusMinusOp::post_construction_initialization()
215114 : {
215115 564 : set_mode(SgUnaryOp::prefix);
215116 564 : }
215117 :
215118 :
215119 :
215120 : // End of memberFunctionString
215121 : // Start of memberFunctionString
215122 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
215123 :
215124 : // *** COMMON CODE SECTION BEGINS HERE ***
215125 :
215126 : #if 0
215127 : int
215128 : SgMinusMinusOp::getVariant() const
215129 : {
215130 : // This function is used in ROSE while "variant()" is used in SAGE
215131 : assert(this != NULL);
215132 : return variant();
215133 : }
215134 : #endif
215135 :
215136 : // This function is used in ROSE in treeTraversal code
215137 : // eventually replaces getVariant() and variant()
215138 : // though after variant() has been removed for a while we will
215139 : // want to change the name of variantT() back to variant()
215140 : // (since the "T" was ment to stand for temporary).
215141 : // When this happens the variantT() will be depricated.
215142 : VariantT
215143 185704 : SgMinusMinusOp::variantT() const
215144 : {
215145 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
215146 185704 : ROSE_ASSERT(this != NULL);
215147 185704 : return V_SgMinusMinusOp;
215148 : }
215149 :
215150 : #if 0
215151 : int
215152 : SgMinusMinusOp::variant() const
215153 : {
215154 : // This function is used in SAGE
215155 : ROSE_ASSERT(this != NULL);
215156 : return MINUSMINUS_OP;
215157 : }
215158 : #endif
215159 :
215160 : ROSE_DLL_API const char*
215161 0 : SgMinusMinusOp::sage_class_name() const
215162 : {
215163 0 : ROSE_ASSERT(this != NULL);
215164 0 : return "SgMinusMinusOp";
215165 : }
215166 :
215167 : std::string
215168 415 : SgMinusMinusOp::class_name() const
215169 : {
215170 415 : ROSE_ASSERT(this != NULL);
215171 415 : return "SgMinusMinusOp";
215172 : }
215173 :
215174 : // DQ (11/26/2005): Support for visitor pattern mechanims
215175 : // (inferior to ROSE traversal mechanism, experimental).
215176 : void
215177 6860 : SgMinusMinusOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
215178 : {
215179 6860 : ROSE_ASSERT(this != NULL);
215180 6860 : visitor.visit(this);
215181 6860 : }
215182 :
215183 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
215184 0 : void SgMinusMinusOp::accept (ROSE_VisitorPattern & visitor) {
215185 0 : ROSE_ASSERT(this != NULL);
215186 0 : visitor.visit(this);
215187 0 : }
215188 :
215189 : SgMinusMinusOp*
215190 0 : SgMinusMinusOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
215191 : {
215192 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
215193 : // This function is currently only supported for the AST used the represent Binary executables.
215194 : if (0 /* isSgAsmNode(this) != NULL */)
215195 : {
215196 : // Support for regex specification.
215197 : std::string prefixCode = "REGEX:";
215198 : addNewAttribute(prefixCode + s,a);
215199 : }
215200 : #endif
215201 :
215202 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
215203 0 : return this;
215204 : }
215205 :
215206 : // *** COMMON CODE SECTION ENDS HERE ***
215207 :
215208 :
215209 : // End of memberFunctionString
215210 : // Start of memberFunctionString
215211 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
215212 :
215213 :
215214 : #if 0
215215 : //! Error checking support
215216 : /*! Verifies the following:
215217 : - working getVariant() member function
215218 : - calls base class's error() member function
215219 : Every class has one of these functions.
215220 : */
215221 : bool
215222 : SgMinusMinusOp::error()
215223 : {
215224 : // Put error checking here
215225 :
215226 : ROSE_ASSERT (this != NULL);
215227 : if (getVariant() != MINUSMINUS_OP)
215228 : {
215229 : printf ("Error in SgMinusMinusOp::error(): SgMinusMinusOp object has a %s variant \n",
215230 : Cxx_GrammarTerminalNames[getVariant()].name);
215231 : // printf ("Error in SgMinusMinusOp::error() \n");
215232 : ROSE_ABORT();
215233 : }
215234 :
215235 : ROSE_ASSERT (getVariant() == MINUSMINUS_OP);
215236 : return SgUnaryOp::error();
215237 : }
215238 : #endif
215239 :
215240 :
215241 :
215242 : // End of memberFunctionString
215243 :
215244 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
215245 :
215246 565 : SgMinusMinusOp* isSgMinusMinusOp ( SgNode* inputDerivedClassPointer )
215247 : {
215248 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
215249 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
215250 : // So to fix this we return NULL directly when the input is NULL and avoid the
215251 : // dynamic_cast in this case. This is likely a performance improvement as well.
215252 : // return dynamic_cast<SgMinusMinusOp*>(inputDerivedClassPointer);
215253 : // Milind Chabbi (8/28/2013): isSgMinusMinusOp uses table-driven castability instead of c++ default dynamic_cast
215254 : // this improves the running time performance by 10-20%.
215255 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMinusMinusOp*>(inputDerivedClassPointer);
215256 565 : return IS_SgMinusMinusOp_FAST_MACRO(inputDerivedClassPointer);
215257 : }
215258 :
215259 : // DQ (11/8/2003): Added version of functions taking const pointer
215260 0 : const SgMinusMinusOp* isSgMinusMinusOp ( const SgNode* inputDerivedClassPointer )
215261 : {
215262 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
215263 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
215264 : // So to fix this we return NULL directly when the input is NULL and avoid the
215265 : // dynamic_cast in this case. This is likely a performance improvement as well.
215266 : // return dynamic_cast<const SgMinusMinusOp*>(inputDerivedClassPointer);
215267 : // Milind Chabbi (8/28/2013): isSgMinusMinusOp uses table-driven castability instead of c++ default dynamic_cast
215268 : // this improves the running time performance by 10-20%.
215269 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMinusMinusOp*>(inputDerivedClassPointer);
215270 0 : return IS_SgMinusMinusOp_FAST_MACRO(inputDerivedClassPointer);
215271 : }
215272 :
215273 :
215274 :
215275 : /* #line 215276 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215276 :
215277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215278 :
215279 : /**
215280 : \brief Generated destructor
215281 :
215282 : This destructor is automatically generated (by ROSETTA). This destructor
215283 : only frees memory of data members associated with the parts of the current IR node which
215284 : are NOT traversed. Those data members that are part of a traversal can be freed using
215285 : a traversal (calling this destructor on all children in a post-order traversal). Such
215286 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
215287 :
215288 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
215289 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
215290 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
215291 :
215292 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
215293 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
215294 : pointers are not yet implemented to call delete on eash pointer in the container.
215295 : (This could be done by derivation from the STL containers to define containers that
215296 : automatically deleted their members.)
215297 :
215298 : */
215299 314 : SgMinusMinusOp::~SgMinusMinusOp () {
215300 157 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
215301 :
215302 :
215303 :
215304 : }
215305 :
215306 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215307 314 : }
215308 :
215309 :
215310 : /* #line 215311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215311 :
215312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
215313 :
215314 : // Generated constructor
215315 10 : SgMinusMinusOp::SgMinusMinusOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
215316 10 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
215317 : {
215318 : #ifdef DEBUG
215319 : // printf ("In SgMinusMinusOp::SgMinusMinusOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
215320 : #endif
215321 : #if 0
215322 : // debugging information!
215323 : printf ("In SgMinusMinusOp::SgMinusMinusOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
215324 : #endif
215325 :
215326 :
215327 :
215328 : #if 0
215329 : // DQ (7/30/2014): Call a virtual function.
215330 : std::string s = this->class_name();
215331 : #endif
215332 :
215333 : // Test the variant virtual function
215334 : // assert(MINUSMINUS_OP == variant());
215335 10 : assert(MINUSMINUS_OP == this->variant());
215336 10 : ROSE_ASSERT(MINUSMINUS_OP == (int)(this->variantT()));
215337 10 : post_construction_initialization();
215338 :
215339 : // Test the isSgMinusMinusOp() function since it has been problematic
215340 10 : assert(isSgMinusMinusOp(this) != NULL);
215341 10 : }
215342 :
215343 : // Generated constructor (all data members)
215344 :
215345 : /* #line 215346 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215346 :
215347 :
215348 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215349 :
215350 :
215351 : // ********************************************************
215352 : // member functions common across all array grammar objects
215353 : // ********************************************************
215354 :
215355 :
215356 :
215357 : /* #line 215358 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215358 :
215359 :
215360 :
215361 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215362 :
215363 : // ********************************************************
215364 : // member functions specific to each node in the grammar
215365 : // ********************************************************
215366 :
215367 :
215368 : /* #line 215369 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215369 :
215370 : // Start of memberFunctionString
215371 : /* #line 6199 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
215372 :
215373 0 : SgPlusPlusOp::SgPlusPlusOp(Sg_File_Info * fi, SgExpression * exp, Sgop_mode a_mode)
215374 0 : : SgUnaryOp(fi, exp, NULL)
215375 : {
215376 0 : set_mode(a_mode);
215377 0 : if (exp)
215378 0 : exp->set_parent(this);
215379 0 : }
215380 :
215381 0 : SgPlusPlusOp::SgPlusPlusOp( SgExpression * exp, Sgop_mode a_mode)
215382 0 : : SgUnaryOp(exp, NULL)
215383 : {
215384 0 : set_mode(a_mode);
215385 0 : if (exp)
215386 0 : exp->set_parent(this);
215387 0 : }
215388 :
215389 : void
215390 1929 : SgPlusPlusOp::post_construction_initialization()
215391 : {
215392 1929 : set_mode(SgUnaryOp::prefix);
215393 1929 : }
215394 :
215395 :
215396 :
215397 : // End of memberFunctionString
215398 : // Start of memberFunctionString
215399 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
215400 :
215401 : // *** COMMON CODE SECTION BEGINS HERE ***
215402 :
215403 : #if 0
215404 : int
215405 : SgPlusPlusOp::getVariant() const
215406 : {
215407 : // This function is used in ROSE while "variant()" is used in SAGE
215408 : assert(this != NULL);
215409 : return variant();
215410 : }
215411 : #endif
215412 :
215413 : // This function is used in ROSE in treeTraversal code
215414 : // eventually replaces getVariant() and variant()
215415 : // though after variant() has been removed for a while we will
215416 : // want to change the name of variantT() back to variant()
215417 : // (since the "T" was ment to stand for temporary).
215418 : // When this happens the variantT() will be depricated.
215419 : VariantT
215420 544706 : SgPlusPlusOp::variantT() const
215421 : {
215422 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
215423 544706 : ROSE_ASSERT(this != NULL);
215424 544706 : return V_SgPlusPlusOp;
215425 : }
215426 :
215427 : #if 0
215428 : int
215429 : SgPlusPlusOp::variant() const
215430 : {
215431 : // This function is used in SAGE
215432 : ROSE_ASSERT(this != NULL);
215433 : return PLUSPLUS_OP;
215434 : }
215435 : #endif
215436 :
215437 : ROSE_DLL_API const char*
215438 38 : SgPlusPlusOp::sage_class_name() const
215439 : {
215440 38 : ROSE_ASSERT(this != NULL);
215441 38 : return "SgPlusPlusOp";
215442 : }
215443 :
215444 : std::string
215445 1683 : SgPlusPlusOp::class_name() const
215446 : {
215447 1683 : ROSE_ASSERT(this != NULL);
215448 1683 : return "SgPlusPlusOp";
215449 : }
215450 :
215451 : // DQ (11/26/2005): Support for visitor pattern mechanims
215452 : // (inferior to ROSE traversal mechanism, experimental).
215453 : void
215454 18932 : SgPlusPlusOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
215455 : {
215456 18932 : ROSE_ASSERT(this != NULL);
215457 18932 : visitor.visit(this);
215458 18932 : }
215459 :
215460 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
215461 0 : void SgPlusPlusOp::accept (ROSE_VisitorPattern & visitor) {
215462 0 : ROSE_ASSERT(this != NULL);
215463 0 : visitor.visit(this);
215464 0 : }
215465 :
215466 : SgPlusPlusOp*
215467 0 : SgPlusPlusOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
215468 : {
215469 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
215470 : // This function is currently only supported for the AST used the represent Binary executables.
215471 : if (0 /* isSgAsmNode(this) != NULL */)
215472 : {
215473 : // Support for regex specification.
215474 : std::string prefixCode = "REGEX:";
215475 : addNewAttribute(prefixCode + s,a);
215476 : }
215477 : #endif
215478 :
215479 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
215480 0 : return this;
215481 : }
215482 :
215483 : // *** COMMON CODE SECTION ENDS HERE ***
215484 :
215485 :
215486 : // End of memberFunctionString
215487 : // Start of memberFunctionString
215488 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
215489 :
215490 :
215491 : #if 0
215492 : //! Error checking support
215493 : /*! Verifies the following:
215494 : - working getVariant() member function
215495 : - calls base class's error() member function
215496 : Every class has one of these functions.
215497 : */
215498 : bool
215499 : SgPlusPlusOp::error()
215500 : {
215501 : // Put error checking here
215502 :
215503 : ROSE_ASSERT (this != NULL);
215504 : if (getVariant() != PLUSPLUS_OP)
215505 : {
215506 : printf ("Error in SgPlusPlusOp::error(): SgPlusPlusOp object has a %s variant \n",
215507 : Cxx_GrammarTerminalNames[getVariant()].name);
215508 : // printf ("Error in SgPlusPlusOp::error() \n");
215509 : ROSE_ABORT();
215510 : }
215511 :
215512 : ROSE_ASSERT (getVariant() == PLUSPLUS_OP);
215513 : return SgUnaryOp::error();
215514 : }
215515 : #endif
215516 :
215517 :
215518 :
215519 : // End of memberFunctionString
215520 :
215521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
215522 :
215523 1939 : SgPlusPlusOp* isSgPlusPlusOp ( SgNode* inputDerivedClassPointer )
215524 : {
215525 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
215526 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
215527 : // So to fix this we return NULL directly when the input is NULL and avoid the
215528 : // dynamic_cast in this case. This is likely a performance improvement as well.
215529 : // return dynamic_cast<SgPlusPlusOp*>(inputDerivedClassPointer);
215530 : // Milind Chabbi (8/28/2013): isSgPlusPlusOp uses table-driven castability instead of c++ default dynamic_cast
215531 : // this improves the running time performance by 10-20%.
215532 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPlusPlusOp*>(inputDerivedClassPointer);
215533 1939 : return IS_SgPlusPlusOp_FAST_MACRO(inputDerivedClassPointer);
215534 : }
215535 :
215536 : // DQ (11/8/2003): Added version of functions taking const pointer
215537 0 : const SgPlusPlusOp* isSgPlusPlusOp ( const SgNode* inputDerivedClassPointer )
215538 : {
215539 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
215540 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
215541 : // So to fix this we return NULL directly when the input is NULL and avoid the
215542 : // dynamic_cast in this case. This is likely a performance improvement as well.
215543 : // return dynamic_cast<const SgPlusPlusOp*>(inputDerivedClassPointer);
215544 : // Milind Chabbi (8/28/2013): isSgPlusPlusOp uses table-driven castability instead of c++ default dynamic_cast
215545 : // this improves the running time performance by 10-20%.
215546 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPlusPlusOp*>(inputDerivedClassPointer);
215547 0 : return IS_SgPlusPlusOp_FAST_MACRO(inputDerivedClassPointer);
215548 : }
215549 :
215550 :
215551 :
215552 : /* #line 215553 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215553 :
215554 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215555 :
215556 : /**
215557 : \brief Generated destructor
215558 :
215559 : This destructor is automatically generated (by ROSETTA). This destructor
215560 : only frees memory of data members associated with the parts of the current IR node which
215561 : are NOT traversed. Those data members that are part of a traversal can be freed using
215562 : a traversal (calling this destructor on all children in a post-order traversal). Such
215563 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
215564 :
215565 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
215566 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
215567 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
215568 :
215569 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
215570 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
215571 : pointers are not yet implemented to call delete on eash pointer in the container.
215572 : (This could be done by derivation from the STL containers to define containers that
215573 : automatically deleted their members.)
215574 :
215575 : */
215576 552 : SgPlusPlusOp::~SgPlusPlusOp () {
215577 276 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
215578 :
215579 :
215580 :
215581 : }
215582 :
215583 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215584 552 : }
215585 :
215586 :
215587 : /* #line 215588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215588 :
215589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
215590 :
215591 : // Generated constructor
215592 22 : SgPlusPlusOp::SgPlusPlusOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
215593 22 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
215594 : {
215595 : #ifdef DEBUG
215596 : // printf ("In SgPlusPlusOp::SgPlusPlusOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
215597 : #endif
215598 : #if 0
215599 : // debugging information!
215600 : printf ("In SgPlusPlusOp::SgPlusPlusOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
215601 : #endif
215602 :
215603 :
215604 :
215605 : #if 0
215606 : // DQ (7/30/2014): Call a virtual function.
215607 : std::string s = this->class_name();
215608 : #endif
215609 :
215610 : // Test the variant virtual function
215611 : // assert(PLUSPLUS_OP == variant());
215612 22 : assert(PLUSPLUS_OP == this->variant());
215613 22 : ROSE_ASSERT(PLUSPLUS_OP == (int)(this->variantT()));
215614 22 : post_construction_initialization();
215615 :
215616 : // Test the isSgPlusPlusOp() function since it has been problematic
215617 22 : assert(isSgPlusPlusOp(this) != NULL);
215618 22 : }
215619 :
215620 : // Generated constructor (all data members)
215621 :
215622 : /* #line 215623 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215623 :
215624 :
215625 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215626 :
215627 :
215628 : // ********************************************************
215629 : // member functions common across all array grammar objects
215630 : // ********************************************************
215631 :
215632 :
215633 :
215634 : /* #line 215635 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215635 :
215636 :
215637 :
215638 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215639 :
215640 : // ********************************************************
215641 : // member functions specific to each node in the grammar
215642 : // ********************************************************
215643 :
215644 :
215645 : /* #line 215646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215646 :
215647 : // Start of memberFunctionString
215648 : /* #line 6225 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
215649 :
215650 :
215651 : void
215652 167 : SgBitComplementOp::post_construction_initialization()
215653 : {
215654 : // DQ (1/20/2019): This function must be defined here so that we can properly mark this operator as a prefix operator (see test2019_10.C).
215655 167 : set_mode(SgUnaryOp::prefix);
215656 :
215657 : #if 0
215658 : printf ("SgBitComplementOp::post_construction_initialization(): this->get_mode() == SgUnaryOp::prefix is %s \n",(this->get_mode() == SgUnaryOp::prefix) ? "true" : "false");
215659 : #endif
215660 167 : }
215661 :
215662 :
215663 :
215664 : // End of memberFunctionString
215665 : // Start of memberFunctionString
215666 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
215667 :
215668 : // *** COMMON CODE SECTION BEGINS HERE ***
215669 :
215670 : #if 0
215671 : int
215672 : SgBitComplementOp::getVariant() const
215673 : {
215674 : // This function is used in ROSE while "variant()" is used in SAGE
215675 : assert(this != NULL);
215676 : return variant();
215677 : }
215678 : #endif
215679 :
215680 : // This function is used in ROSE in treeTraversal code
215681 : // eventually replaces getVariant() and variant()
215682 : // though after variant() has been removed for a while we will
215683 : // want to change the name of variantT() back to variant()
215684 : // (since the "T" was ment to stand for temporary).
215685 : // When this happens the variantT() will be depricated.
215686 : VariantT
215687 42226 : SgBitComplementOp::variantT() const
215688 : {
215689 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
215690 42226 : ROSE_ASSERT(this != NULL);
215691 42226 : return V_SgBitComplementOp;
215692 : }
215693 :
215694 : #if 0
215695 : int
215696 : SgBitComplementOp::variant() const
215697 : {
215698 : // This function is used in SAGE
215699 : ROSE_ASSERT(this != NULL);
215700 : return BIT_COMPLEMENT_OP;
215701 : }
215702 : #endif
215703 :
215704 : ROSE_DLL_API const char*
215705 0 : SgBitComplementOp::sage_class_name() const
215706 : {
215707 0 : ROSE_ASSERT(this != NULL);
215708 0 : return "SgBitComplementOp";
215709 : }
215710 :
215711 : std::string
215712 97 : SgBitComplementOp::class_name() const
215713 : {
215714 97 : ROSE_ASSERT(this != NULL);
215715 97 : return "SgBitComplementOp";
215716 : }
215717 :
215718 : // DQ (11/26/2005): Support for visitor pattern mechanims
215719 : // (inferior to ROSE traversal mechanism, experimental).
215720 : void
215721 1669 : SgBitComplementOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
215722 : {
215723 1669 : ROSE_ASSERT(this != NULL);
215724 1669 : visitor.visit(this);
215725 1669 : }
215726 :
215727 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
215728 0 : void SgBitComplementOp::accept (ROSE_VisitorPattern & visitor) {
215729 0 : ROSE_ASSERT(this != NULL);
215730 0 : visitor.visit(this);
215731 0 : }
215732 :
215733 : SgBitComplementOp*
215734 0 : SgBitComplementOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
215735 : {
215736 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
215737 : // This function is currently only supported for the AST used the represent Binary executables.
215738 : if (0 /* isSgAsmNode(this) != NULL */)
215739 : {
215740 : // Support for regex specification.
215741 : std::string prefixCode = "REGEX:";
215742 : addNewAttribute(prefixCode + s,a);
215743 : }
215744 : #endif
215745 :
215746 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
215747 0 : return this;
215748 : }
215749 :
215750 : // *** COMMON CODE SECTION ENDS HERE ***
215751 :
215752 :
215753 : // End of memberFunctionString
215754 : // Start of memberFunctionString
215755 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
215756 :
215757 :
215758 : #if 0
215759 : //! Error checking support
215760 : /*! Verifies the following:
215761 : - working getVariant() member function
215762 : - calls base class's error() member function
215763 : Every class has one of these functions.
215764 : */
215765 : bool
215766 : SgBitComplementOp::error()
215767 : {
215768 : // Put error checking here
215769 :
215770 : ROSE_ASSERT (this != NULL);
215771 : if (getVariant() != BIT_COMPLEMENT_OP)
215772 : {
215773 : printf ("Error in SgBitComplementOp::error(): SgBitComplementOp object has a %s variant \n",
215774 : Cxx_GrammarTerminalNames[getVariant()].name);
215775 : // printf ("Error in SgBitComplementOp::error() \n");
215776 : ROSE_ABORT();
215777 : }
215778 :
215779 : ROSE_ASSERT (getVariant() == BIT_COMPLEMENT_OP);
215780 : return SgUnaryOp::error();
215781 : }
215782 : #endif
215783 :
215784 :
215785 :
215786 : // End of memberFunctionString
215787 :
215788 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
215789 :
215790 167 : SgBitComplementOp* isSgBitComplementOp ( SgNode* inputDerivedClassPointer )
215791 : {
215792 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
215793 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
215794 : // So to fix this we return NULL directly when the input is NULL and avoid the
215795 : // dynamic_cast in this case. This is likely a performance improvement as well.
215796 : // return dynamic_cast<SgBitComplementOp*>(inputDerivedClassPointer);
215797 : // Milind Chabbi (8/28/2013): isSgBitComplementOp uses table-driven castability instead of c++ default dynamic_cast
215798 : // this improves the running time performance by 10-20%.
215799 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBitComplementOp*>(inputDerivedClassPointer);
215800 167 : return IS_SgBitComplementOp_FAST_MACRO(inputDerivedClassPointer);
215801 : }
215802 :
215803 : // DQ (11/8/2003): Added version of functions taking const pointer
215804 0 : const SgBitComplementOp* isSgBitComplementOp ( const SgNode* inputDerivedClassPointer )
215805 : {
215806 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
215807 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
215808 : // So to fix this we return NULL directly when the input is NULL and avoid the
215809 : // dynamic_cast in this case. This is likely a performance improvement as well.
215810 : // return dynamic_cast<const SgBitComplementOp*>(inputDerivedClassPointer);
215811 : // Milind Chabbi (8/28/2013): isSgBitComplementOp uses table-driven castability instead of c++ default dynamic_cast
215812 : // this improves the running time performance by 10-20%.
215813 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBitComplementOp*>(inputDerivedClassPointer);
215814 0 : return IS_SgBitComplementOp_FAST_MACRO(inputDerivedClassPointer);
215815 : }
215816 :
215817 :
215818 :
215819 : /* #line 215820 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215820 :
215821 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215822 :
215823 : /**
215824 : \brief Generated destructor
215825 :
215826 : This destructor is automatically generated (by ROSETTA). This destructor
215827 : only frees memory of data members associated with the parts of the current IR node which
215828 : are NOT traversed. Those data members that are part of a traversal can be freed using
215829 : a traversal (calling this destructor on all children in a post-order traversal). Such
215830 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
215831 :
215832 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
215833 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
215834 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
215835 :
215836 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
215837 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
215838 : pointers are not yet implemented to call delete on eash pointer in the container.
215839 : (This could be done by derivation from the STL containers to define containers that
215840 : automatically deleted their members.)
215841 :
215842 : */
215843 140 : SgBitComplementOp::~SgBitComplementOp () {
215844 70 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
215845 :
215846 :
215847 :
215848 : }
215849 :
215850 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
215851 140 : }
215852 :
215853 :
215854 : /* #line 215855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215855 :
215856 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
215857 :
215858 : // Generated constructor
215859 0 : SgBitComplementOp::SgBitComplementOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
215860 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
215861 : {
215862 : #ifdef DEBUG
215863 : // printf ("In SgBitComplementOp::SgBitComplementOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
215864 : #endif
215865 : #if 0
215866 : // debugging information!
215867 : printf ("In SgBitComplementOp::SgBitComplementOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
215868 : #endif
215869 :
215870 :
215871 :
215872 : #if 0
215873 : // DQ (7/30/2014): Call a virtual function.
215874 : std::string s = this->class_name();
215875 : #endif
215876 :
215877 : // Test the variant virtual function
215878 : // assert(BIT_COMPLEMENT_OP == variant());
215879 0 : assert(BIT_COMPLEMENT_OP == this->variant());
215880 0 : ROSE_ASSERT(BIT_COMPLEMENT_OP == (int)(this->variantT()));
215881 0 : post_construction_initialization();
215882 :
215883 : // Test the isSgBitComplementOp() function since it has been problematic
215884 0 : assert(isSgBitComplementOp(this) != NULL);
215885 0 : }
215886 :
215887 : // Generated constructor (all data members)
215888 :
215889 : /* #line 215890 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215890 :
215891 :
215892 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215893 :
215894 :
215895 : // ********************************************************
215896 : // member functions common across all array grammar objects
215897 : // ********************************************************
215898 :
215899 :
215900 :
215901 : /* #line 215902 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215902 :
215903 :
215904 :
215905 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
215906 :
215907 : // ********************************************************
215908 : // member functions specific to each node in the grammar
215909 : // ********************************************************
215910 :
215911 :
215912 : /* #line 215913 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
215913 :
215914 : // Start of memberFunctionString
215915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
215916 :
215917 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
215918 :
215919 : SgCastExp::cast_type_enum
215920 0 : SgCastExp::get_cast_type () const
215921 : {
215922 0 : ROSE_ASSERT (this != NULL);
215923 :
215924 : #if 0
215925 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
215926 : // used to trigger marking transformations for the token-based unparsing.
215927 : printf ("SgCastExp::get_cast_type = %p = %s \n",this,this->class_name().c_str());
215928 : #endif
215929 :
215930 0 : return p_cast_type;
215931 : }
215932 :
215933 : void
215934 0 : SgCastExp::set_cast_type ( SgCastExp::cast_type_enum cast_type )
215935 : {
215936 0 : ROSE_ASSERT (this != NULL);
215937 :
215938 : #if 0
215939 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
215940 : // used to trigger marking transformations for the token-based unparsing.
215941 : printf ("SgCastExp::set_cast_type = %p = %s \n",this,this->class_name().c_str());
215942 : #endif
215943 :
215944 0 : set_isModified(true);
215945 :
215946 0 : p_cast_type = cast_type;
215947 0 : }
215948 :
215949 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
215950 :
215951 :
215952 : // End of memberFunctionString
215953 : // Start of memberFunctionString
215954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
215955 :
215956 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
215957 :
215958 : SgExpression*
215959 75263 : SgCastExp::get_originalExpressionTree () const
215960 : {
215961 75263 : ROSE_ASSERT (this != NULL);
215962 :
215963 : #if 0
215964 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
215965 : // used to trigger marking transformations for the token-based unparsing.
215966 : printf ("SgCastExp::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
215967 : #endif
215968 :
215969 75263 : return p_originalExpressionTree;
215970 : }
215971 :
215972 : void
215973 3442 : SgCastExp::set_originalExpressionTree ( SgExpression* originalExpressionTree )
215974 : {
215975 3442 : ROSE_ASSERT (this != NULL);
215976 :
215977 : #if 0
215978 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
215979 : // used to trigger marking transformations for the token-based unparsing.
215980 : printf ("SgCastExp::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
215981 : #endif
215982 :
215983 3442 : set_isModified(true);
215984 :
215985 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
215986 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
215987 : {
215988 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
215989 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
215990 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
215991 : ROSE_ASSERT(false);
215992 : #endif
215993 : }
215994 : #endif
215995 3442 : p_originalExpressionTree = originalExpressionTree;
215996 3442 : }
215997 :
215998 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
215999 :
216000 :
216001 : // End of memberFunctionString
216002 : // Start of memberFunctionString
216003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
216004 :
216005 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
216006 :
216007 : bool
216008 5100 : SgCastExp::get_castContainsBaseTypeDefiningDeclaration () const
216009 : {
216010 5100 : ROSE_ASSERT (this != NULL);
216011 :
216012 : #if 0
216013 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
216014 : // used to trigger marking transformations for the token-based unparsing.
216015 : printf ("SgCastExp::get_castContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
216016 : #endif
216017 :
216018 5100 : return p_castContainsBaseTypeDefiningDeclaration;
216019 : }
216020 :
216021 : void
216022 0 : SgCastExp::set_castContainsBaseTypeDefiningDeclaration ( bool castContainsBaseTypeDefiningDeclaration )
216023 : {
216024 0 : ROSE_ASSERT (this != NULL);
216025 :
216026 : #if 0
216027 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
216028 : // used to trigger marking transformations for the token-based unparsing.
216029 : printf ("SgCastExp::set_castContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
216030 : #endif
216031 :
216032 0 : set_isModified(true);
216033 :
216034 0 : p_castContainsBaseTypeDefiningDeclaration = castContainsBaseTypeDefiningDeclaration;
216035 0 : }
216036 :
216037 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
216038 :
216039 :
216040 : // End of memberFunctionString
216041 : // Start of memberFunctionString
216042 :
216043 :
216044 : // End of memberFunctionString
216045 : // Start of memberFunctionString
216046 : /* #line 6380 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
216047 :
216048 :
216049 : void
216050 28145 : SgCastExp::post_construction_initialization()
216051 : {
216052 28145 : }
216053 :
216054 : // DQ (6/14/2005): Modified to make enum name consistant with elsewhere in ROSE (Sage III)
216055 : // SgCastExp::Sg_e_cast_type
216056 : SgCastExp::cast_type_enum
216057 5100 : SgCastExp::cast_type() const
216058 : {
216059 5100 : return p_cast_type;
216060 : }
216061 :
216062 : // DQ (1/17/2008): Added set_type function since this is one of a few IR nodes that require
216063 : // the type to be held explicitly, for all other IR nodes the type is computed dynamicly.
216064 : void
216065 0 : SgCastExp::set_type( SgType* type )
216066 : {
216067 0 : p_expression_type = type;
216068 0 : }
216069 :
216070 : SgType*
216071 69524 : SgCastExp::get_type() const
216072 : {
216073 : // DQ (1/16/2006): In this function we want to return the stored p_expression_type.
216074 : // This IR node has to store the type explicitly since there is no other way to
216075 : // recover what the cast is TO (since the operand stored what the cast in FROM).
216076 :
216077 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
216078 :
216079 : // printf ("SgCastOp::get_type(): p_expression_type has been removed from many IR nodes but is required for SgCastOp \n");
216080 :
216081 : #if 0
216082 : printf ("In SgCastExp::get_type() \n");
216083 : #endif
216084 :
216085 69524 : ROSE_ASSERT(p_expression_type != NULL);
216086 69524 : return p_expression_type;
216087 : }
216088 :
216089 : bool
216090 0 : SgCastExp::cast_looses_precision()
216091 : {
216092 : // DQ (10/24/2014): Added support to determine when cast should be allowable.
216093 : // This is used in the SageInterace support for evaluation of constant expressions.
216094 :
216095 0 : bool result = false;
216096 0 : if (isSgTypeDouble(p_expression_type) != NULL && isSgTypeFloat(p_expression_type) != NULL)
216097 : {
216098 0 : SgExpression* operand = this->get_operand();
216099 0 : ROSE_ASSERT(operand != NULL);
216100 :
216101 0 : SgType* operantType = operand->get_type();
216102 0 : ROSE_ASSERT(operantType != NULL);
216103 :
216104 0 : if (isSgTypeInt(operantType) != NULL || isSgTypeLong(operantType) != NULL || isSgTypeShort(operantType) != NULL || isSgTypeChar(operantType) != NULL ||
216105 0 : isSgTypeUnsignedInt(operantType) != NULL || isSgTypeUnsignedLong(operantType) != NULL || isSgTypeUnsignedShort(operantType) != NULL || isSgTypeUnsignedChar(operantType) != NULL ||
216106 0 : isSgTypeSignedInt(operantType) != NULL || isSgTypeSignedLong(operantType) != NULL || isSgTypeSignedShort(operantType) != NULL || isSgTypeSignedChar(operantType) != NULL)
216107 : {
216108 : result = true;
216109 : }
216110 : }
216111 :
216112 0 : return result;
216113 : }
216114 :
216115 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
216116 : // so that we could avoid them setting the isModified flag which is a problem in the
216117 : // name qualification support for C++ (interfering with the token-based unparsing).
216118 : int
216119 0 : SgCastExp::get_name_qualification_length () const
216120 : {
216121 0 : ROSE_ASSERT (this != NULL);
216122 0 : return p_name_qualification_length;
216123 : }
216124 :
216125 : void
216126 8137 : SgCastExp::set_name_qualification_length ( int name_qualification_length )
216127 : {
216128 8137 : ROSE_ASSERT (this != NULL);
216129 : // This can't be called by the name qualification API (see test2015_26.C).
216130 : // set_isModified(true);
216131 :
216132 8137 : p_name_qualification_length = name_qualification_length;
216133 8137 : }
216134 :
216135 : bool
216136 0 : SgCastExp::get_type_elaboration_required () const
216137 : {
216138 0 : ROSE_ASSERT (this != NULL);
216139 0 : return p_type_elaboration_required;
216140 : }
216141 :
216142 : void
216143 8137 : SgCastExp::set_type_elaboration_required ( bool type_elaboration_required )
216144 : {
216145 8137 : ROSE_ASSERT (this != NULL);
216146 : // This can't be called by the name qualification API (see test2015_26.C).
216147 : // set_isModified(true);
216148 :
216149 8137 : p_type_elaboration_required = type_elaboration_required;
216150 8137 : }
216151 :
216152 : bool
216153 0 : SgCastExp::get_global_qualification_required () const
216154 : {
216155 0 : ROSE_ASSERT (this != NULL);
216156 0 : return p_global_qualification_required;
216157 : }
216158 :
216159 : void
216160 8137 : SgCastExp::set_global_qualification_required ( bool global_qualification_required )
216161 : {
216162 8137 : ROSE_ASSERT (this != NULL);
216163 :
216164 : // This can't be called by the name qualification API (see test2015_26.C).
216165 : // set_isModified(true);
216166 :
216167 8137 : p_global_qualification_required = global_qualification_required;
216168 8137 : }
216169 :
216170 : std::string
216171 0 : SgCastExp::cast_type_to_string ( enum cast_type_enum cast_type )
216172 : {
216173 0 : string s;
216174 :
216175 0 : switch (cast_type)
216176 : {
216177 0 : case e_unknown: s = "e_unknown"; break;
216178 0 : case e_default: s = "e_default"; break;
216179 0 : case e_C_style_cast: s = "e_C_style_cast"; break;
216180 0 : case e_const_cast: s = "e_const_cast"; break;
216181 0 : case e_static_cast: s = "e_static_cast"; break;
216182 0 : case e_dynamic_cast: s = "e_dynamic_cast"; break;
216183 0 : case e_reinterpret_cast: s = "e_reinterpret_cast"; break;
216184 0 : case e_safe_cast: s = "e_safe_cast"; break;
216185 0 : case e_last_cast: s = "e_last_cast"; break;
216186 :
216187 0 : default:
216188 0 : printf ("ERROR: default reached in switch: cast_type = %d \n",cast_type);
216189 : }
216190 :
216191 0 : return s;
216192 : }
216193 :
216194 : // DQ (4/15/2019): These six access functions should not be generated by ROSETTA
216195 : // so that we could avoid them setting the isModified flag which is a problem in the
216196 : // name qualification support for C++ (interfering with the token-based unparsing).
216197 : int
216198 0 : SgCastExp::get_name_qualification_for_pointer_to_member_class_length () const
216199 : {
216200 0 : ROSE_ASSERT (this != NULL);
216201 0 : return p_name_qualification_for_pointer_to_member_class_length;
216202 : }
216203 :
216204 : void
216205 0 : SgCastExp::set_name_qualification_for_pointer_to_member_class_length ( int name_qualification_length )
216206 : {
216207 0 : ROSE_ASSERT (this != NULL);
216208 : // This can't be called by the name qualification API (see test2015_26.C).
216209 : // set_isModified(true);
216210 :
216211 0 : p_name_qualification_for_pointer_to_member_class_length = name_qualification_length;
216212 0 : }
216213 :
216214 : bool
216215 0 : SgCastExp::get_type_elaboration_for_pointer_to_member_class_required () const
216216 : {
216217 0 : ROSE_ASSERT (this != NULL);
216218 0 : return p_type_elaboration_for_pointer_to_member_class_required;
216219 : }
216220 :
216221 : void
216222 0 : SgCastExp::set_type_elaboration_for_pointer_to_member_class_required ( bool type_elaboration_required )
216223 : {
216224 0 : ROSE_ASSERT (this != NULL);
216225 : // This can't be called by the name qualification API (see test2015_26.C).
216226 : // set_isModified(true);
216227 :
216228 0 : p_type_elaboration_for_pointer_to_member_class_required = type_elaboration_required;
216229 0 : }
216230 :
216231 : bool
216232 0 : SgCastExp::get_global_qualification_for_pointer_to_member_class_required () const
216233 : {
216234 0 : ROSE_ASSERT (this != NULL);
216235 0 : return p_global_qualification_for_pointer_to_member_class_required;
216236 : }
216237 :
216238 : void
216239 0 : SgCastExp::set_global_qualification_for_pointer_to_member_class_required ( bool global_qualification_required )
216240 : {
216241 0 : ROSE_ASSERT (this != NULL);
216242 :
216243 : // This can't be called by the name qualification API (see test2015_26.C).
216244 : // set_isModified(true);
216245 :
216246 0 : p_global_qualification_for_pointer_to_member_class_required = global_qualification_required;
216247 0 : }
216248 :
216249 :
216250 :
216251 :
216252 :
216253 : // End of memberFunctionString
216254 : // Start of memberFunctionString
216255 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
216256 :
216257 : // *** COMMON CODE SECTION BEGINS HERE ***
216258 :
216259 : #if 0
216260 : int
216261 : SgCastExp::getVariant() const
216262 : {
216263 : // This function is used in ROSE while "variant()" is used in SAGE
216264 : assert(this != NULL);
216265 : return variant();
216266 : }
216267 : #endif
216268 :
216269 : // This function is used in ROSE in treeTraversal code
216270 : // eventually replaces getVariant() and variant()
216271 : // though after variant() has been removed for a while we will
216272 : // want to change the name of variantT() back to variant()
216273 : // (since the "T" was ment to stand for temporary).
216274 : // When this happens the variantT() will be depricated.
216275 : VariantT
216276 7616060 : SgCastExp::variantT() const
216277 : {
216278 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
216279 7616060 : ROSE_ASSERT(this != NULL);
216280 7616060 : return V_SgCastExp;
216281 : }
216282 :
216283 : #if 0
216284 : int
216285 : SgCastExp::variant() const
216286 : {
216287 : // This function is used in SAGE
216288 : ROSE_ASSERT(this != NULL);
216289 : return CAST_OP;
216290 : }
216291 : #endif
216292 :
216293 : ROSE_DLL_API const char*
216294 716 : SgCastExp::sage_class_name() const
216295 : {
216296 716 : ROSE_ASSERT(this != NULL);
216297 716 : return "SgCastExp";
216298 : }
216299 :
216300 : std::string
216301 21294 : SgCastExp::class_name() const
216302 : {
216303 21294 : ROSE_ASSERT(this != NULL);
216304 21294 : return "SgCastExp";
216305 : }
216306 :
216307 : // DQ (11/26/2005): Support for visitor pattern mechanims
216308 : // (inferior to ROSE traversal mechanism, experimental).
216309 : void
216310 317934 : SgCastExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
216311 : {
216312 317934 : ROSE_ASSERT(this != NULL);
216313 317934 : visitor.visit(this);
216314 317934 : }
216315 :
216316 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
216317 0 : void SgCastExp::accept (ROSE_VisitorPattern & visitor) {
216318 0 : ROSE_ASSERT(this != NULL);
216319 0 : visitor.visit(this);
216320 0 : }
216321 :
216322 : SgCastExp*
216323 0 : SgCastExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
216324 : {
216325 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
216326 : // This function is currently only supported for the AST used the represent Binary executables.
216327 : if (0 /* isSgAsmNode(this) != NULL */)
216328 : {
216329 : // Support for regex specification.
216330 : std::string prefixCode = "REGEX:";
216331 : addNewAttribute(prefixCode + s,a);
216332 : }
216333 : #endif
216334 :
216335 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
216336 0 : return this;
216337 : }
216338 :
216339 : // *** COMMON CODE SECTION ENDS HERE ***
216340 :
216341 :
216342 : // End of memberFunctionString
216343 : // Start of memberFunctionString
216344 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
216345 :
216346 :
216347 : #if 0
216348 : //! Error checking support
216349 : /*! Verifies the following:
216350 : - working getVariant() member function
216351 : - calls base class's error() member function
216352 : Every class has one of these functions.
216353 : */
216354 : bool
216355 : SgCastExp::error()
216356 : {
216357 : // Put error checking here
216358 :
216359 : ROSE_ASSERT (this != NULL);
216360 : if (getVariant() != CAST_OP)
216361 : {
216362 : printf ("Error in SgCastExp::error(): SgCastExp object has a %s variant \n",
216363 : Cxx_GrammarTerminalNames[getVariant()].name);
216364 : // printf ("Error in SgCastExp::error() \n");
216365 : ROSE_ABORT();
216366 : }
216367 :
216368 : ROSE_ASSERT (getVariant() == CAST_OP);
216369 : return SgUnaryOp::error();
216370 : }
216371 : #endif
216372 :
216373 :
216374 :
216375 : // End of memberFunctionString
216376 :
216377 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
216378 :
216379 2949210 : SgCastExp* isSgCastExp ( SgNode* inputDerivedClassPointer )
216380 : {
216381 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
216382 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
216383 : // So to fix this we return NULL directly when the input is NULL and avoid the
216384 : // dynamic_cast in this case. This is likely a performance improvement as well.
216385 : // return dynamic_cast<SgCastExp*>(inputDerivedClassPointer);
216386 : // Milind Chabbi (8/28/2013): isSgCastExp uses table-driven castability instead of c++ default dynamic_cast
216387 : // this improves the running time performance by 10-20%.
216388 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCastExp*>(inputDerivedClassPointer);
216389 2949210 : return IS_SgCastExp_FAST_MACRO(inputDerivedClassPointer);
216390 : }
216391 :
216392 : // DQ (11/8/2003): Added version of functions taking const pointer
216393 10732 : const SgCastExp* isSgCastExp ( const SgNode* inputDerivedClassPointer )
216394 : {
216395 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
216396 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
216397 : // So to fix this we return NULL directly when the input is NULL and avoid the
216398 : // dynamic_cast in this case. This is likely a performance improvement as well.
216399 : // return dynamic_cast<const SgCastExp*>(inputDerivedClassPointer);
216400 : // Milind Chabbi (8/28/2013): isSgCastExp uses table-driven castability instead of c++ default dynamic_cast
216401 : // this improves the running time performance by 10-20%.
216402 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCastExp*>(inputDerivedClassPointer);
216403 10732 : return IS_SgCastExp_FAST_MACRO(inputDerivedClassPointer);
216404 : }
216405 :
216406 :
216407 :
216408 : /* #line 216409 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216409 :
216410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
216411 :
216412 : /**
216413 : \brief Generated destructor
216414 :
216415 : This destructor is automatically generated (by ROSETTA). This destructor
216416 : only frees memory of data members associated with the parts of the current IR node which
216417 : are NOT traversed. Those data members that are part of a traversal can be freed using
216418 : a traversal (calling this destructor on all children in a post-order traversal). Such
216419 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
216420 :
216421 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
216422 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
216423 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
216424 :
216425 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
216426 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
216427 : pointers are not yet implemented to call delete on eash pointer in the container.
216428 : (This could be done by derivation from the STL containers to define containers that
216429 : automatically deleted their members.)
216430 :
216431 : */
216432 16088 : SgCastExp::~SgCastExp () {
216433 8044 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
216434 :
216435 :
216436 : // case: not a listType for cast_type
216437 8044 : p_cast_type = SgCastExp::e_C_style_cast; // non list case
216438 : // case: not a listType for originalExpressionTree
216439 8044 : p_originalExpressionTree = NULL; // non list case
216440 : // case: not a listType for name_qualification_length
216441 8044 : p_name_qualification_length = 0; // non list case
216442 : // case: not a listType for type_elaboration_required
216443 8044 : p_type_elaboration_required = false; // non list case
216444 : // case: not a listType for global_qualification_required
216445 8044 : p_global_qualification_required = false; // non list case
216446 : // case: not a listType for castContainsBaseTypeDefiningDeclaration
216447 8044 : p_castContainsBaseTypeDefiningDeclaration = false; // non list case
216448 : // case: not a listType for name_qualification_for_pointer_to_member_class_length
216449 8044 : p_name_qualification_for_pointer_to_member_class_length = 0; // non list case
216450 : // case: not a listType for type_elaboration_for_pointer_to_member_class_required
216451 8044 : p_type_elaboration_for_pointer_to_member_class_required = false; // non list case
216452 : // case: not a listType for global_qualification_for_pointer_to_member_class_required
216453 8044 : p_global_qualification_for_pointer_to_member_class_required = false; // non list case
216454 :
216455 : }
216456 :
216457 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
216458 16088 : }
216459 :
216460 :
216461 : /* #line 216462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216462 :
216463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
216464 :
216465 : // Generated constructor
216466 1475 : SgCastExp::SgCastExp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type )
216467 1475 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
216468 : {
216469 : #ifdef DEBUG
216470 : // printf ("In SgCastExp::SgCastExp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type) sage_class_name() = %s \n",sage_class_name());
216471 : #endif
216472 : #if 0
216473 : // debugging information!
216474 : printf ("In SgCastExp::SgCastExp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgCastExp::cast_type_enum cast_type): this = %p = %s \n",this,this->class_name().c_str());
216475 : #endif
216476 :
216477 1475 : p_cast_type = cast_type;
216478 1475 : p_originalExpressionTree = NULL;
216479 1475 : p_name_qualification_length = 0;
216480 1475 : p_type_elaboration_required = false;
216481 1475 : p_global_qualification_required = false;
216482 1475 : p_castContainsBaseTypeDefiningDeclaration = false;
216483 1475 : p_name_qualification_for_pointer_to_member_class_length = 0;
216484 1475 : p_type_elaboration_for_pointer_to_member_class_required = false;
216485 1475 : p_global_qualification_for_pointer_to_member_class_required = false;
216486 :
216487 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
216488 :
216489 : #if 0
216490 : // DQ (7/30/2014): Call a virtual function.
216491 : std::string s = this->class_name();
216492 : #endif
216493 :
216494 : // Test the variant virtual function
216495 : // assert(CAST_OP == variant());
216496 1475 : assert(CAST_OP == this->variant());
216497 1475 : ROSE_ASSERT(CAST_OP == (int)(this->variantT()));
216498 1475 : post_construction_initialization();
216499 :
216500 : // Test the isSgCastExp() function since it has been problematic
216501 1475 : assert(isSgCastExp(this) != NULL);
216502 1475 : }
216503 :
216504 : // Generated constructor (all data members)
216505 :
216506 : /* #line 216507 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216507 :
216508 :
216509 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
216510 :
216511 :
216512 : // ********************************************************
216513 : // member functions common across all array grammar objects
216514 : // ********************************************************
216515 :
216516 :
216517 :
216518 : /* #line 216519 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216519 :
216520 :
216521 :
216522 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
216523 :
216524 : // ********************************************************
216525 : // member functions specific to each node in the grammar
216526 : // ********************************************************
216527 :
216528 :
216529 : /* #line 216530 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216530 :
216531 : // Start of memberFunctionString
216532 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
216533 :
216534 : void
216535 495 : SgThrowOp::post_construction_initialization()
216536 : {
216537 495 : }
216538 :
216539 :
216540 :
216541 : // End of memberFunctionString
216542 : // Start of memberFunctionString
216543 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
216544 :
216545 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
216546 :
216547 : SgThrowOp::e_throw_kind
216548 0 : SgThrowOp::get_throwKind () const
216549 : {
216550 0 : ROSE_ASSERT (this != NULL);
216551 :
216552 : #if 0
216553 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
216554 : // used to trigger marking transformations for the token-based unparsing.
216555 : printf ("SgThrowOp::get_throwKind = %p = %s \n",this,this->class_name().c_str());
216556 : #endif
216557 :
216558 0 : return p_throwKind;
216559 : }
216560 :
216561 : void
216562 0 : SgThrowOp::set_throwKind ( SgThrowOp::e_throw_kind throwKind )
216563 : {
216564 0 : ROSE_ASSERT (this != NULL);
216565 :
216566 : #if 0
216567 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
216568 : // used to trigger marking transformations for the token-based unparsing.
216569 : printf ("SgThrowOp::set_throwKind = %p = %s \n",this,this->class_name().c_str());
216570 : #endif
216571 :
216572 0 : set_isModified(true);
216573 :
216574 0 : p_throwKind = throwKind;
216575 0 : }
216576 :
216577 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
216578 :
216579 :
216580 : // End of memberFunctionString
216581 : // Start of memberFunctionString
216582 : /* #line 7162 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
216583 :
216584 :
216585 : SgType*
216586 422 : SgThrowOp::get_type() const
216587 : {
216588 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
216589 :
216590 : #if 0
216591 : printf ("In SgThrowOp::get_type() \n");
216592 : #endif
216593 :
216594 : // DQ (1/14/2006): For a list of types held internally it is not clear what to return.
216595 : // So return a SgDefaultType as in Sage II previously. Might be better to research
216596 : // this in more details later.
216597 422 : SgType* returnType = SgTypeDefault::createType();
216598 :
216599 422 : ROSE_ASSERT(returnType != NULL);
216600 422 : return returnType;
216601 : }
216602 :
216603 :
216604 :
216605 : // End of memberFunctionString
216606 : // Start of memberFunctionString
216607 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
216608 :
216609 : // *** COMMON CODE SECTION BEGINS HERE ***
216610 :
216611 : #if 0
216612 : int
216613 : SgThrowOp::getVariant() const
216614 : {
216615 : // This function is used in ROSE while "variant()" is used in SAGE
216616 : assert(this != NULL);
216617 : return variant();
216618 : }
216619 : #endif
216620 :
216621 : // This function is used in ROSE in treeTraversal code
216622 : // eventually replaces getVariant() and variant()
216623 : // though after variant() has been removed for a while we will
216624 : // want to change the name of variantT() back to variant()
216625 : // (since the "T" was ment to stand for temporary).
216626 : // When this happens the variantT() will be depricated.
216627 : VariantT
216628 121442 : SgThrowOp::variantT() const
216629 : {
216630 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
216631 121442 : ROSE_ASSERT(this != NULL);
216632 121442 : return V_SgThrowOp;
216633 : }
216634 :
216635 : #if 0
216636 : int
216637 : SgThrowOp::variant() const
216638 : {
216639 : // This function is used in SAGE
216640 : ROSE_ASSERT(this != NULL);
216641 : return THROW_OP;
216642 : }
216643 : #endif
216644 :
216645 : ROSE_DLL_API const char*
216646 12 : SgThrowOp::sage_class_name() const
216647 : {
216648 12 : ROSE_ASSERT(this != NULL);
216649 12 : return "SgThrowOp";
216650 : }
216651 :
216652 : std::string
216653 416 : SgThrowOp::class_name() const
216654 : {
216655 416 : ROSE_ASSERT(this != NULL);
216656 416 : return "SgThrowOp";
216657 : }
216658 :
216659 : // DQ (11/26/2005): Support for visitor pattern mechanims
216660 : // (inferior to ROSE traversal mechanism, experimental).
216661 : void
216662 7574 : SgThrowOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
216663 : {
216664 7574 : ROSE_ASSERT(this != NULL);
216665 7574 : visitor.visit(this);
216666 7574 : }
216667 :
216668 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
216669 0 : void SgThrowOp::accept (ROSE_VisitorPattern & visitor) {
216670 0 : ROSE_ASSERT(this != NULL);
216671 0 : visitor.visit(this);
216672 0 : }
216673 :
216674 : SgThrowOp*
216675 0 : SgThrowOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
216676 : {
216677 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
216678 : // This function is currently only supported for the AST used the represent Binary executables.
216679 : if (0 /* isSgAsmNode(this) != NULL */)
216680 : {
216681 : // Support for regex specification.
216682 : std::string prefixCode = "REGEX:";
216683 : addNewAttribute(prefixCode + s,a);
216684 : }
216685 : #endif
216686 :
216687 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
216688 0 : return this;
216689 : }
216690 :
216691 : // *** COMMON CODE SECTION ENDS HERE ***
216692 :
216693 :
216694 : // End of memberFunctionString
216695 : // Start of memberFunctionString
216696 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
216697 :
216698 :
216699 : #if 0
216700 : //! Error checking support
216701 : /*! Verifies the following:
216702 : - working getVariant() member function
216703 : - calls base class's error() member function
216704 : Every class has one of these functions.
216705 : */
216706 : bool
216707 : SgThrowOp::error()
216708 : {
216709 : // Put error checking here
216710 :
216711 : ROSE_ASSERT (this != NULL);
216712 : if (getVariant() != THROW_OP)
216713 : {
216714 : printf ("Error in SgThrowOp::error(): SgThrowOp object has a %s variant \n",
216715 : Cxx_GrammarTerminalNames[getVariant()].name);
216716 : // printf ("Error in SgThrowOp::error() \n");
216717 : ROSE_ABORT();
216718 : }
216719 :
216720 : ROSE_ASSERT (getVariant() == THROW_OP);
216721 : return SgUnaryOp::error();
216722 : }
216723 : #endif
216724 :
216725 :
216726 :
216727 : // End of memberFunctionString
216728 :
216729 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
216730 :
216731 495 : SgThrowOp* isSgThrowOp ( SgNode* inputDerivedClassPointer )
216732 : {
216733 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
216734 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
216735 : // So to fix this we return NULL directly when the input is NULL and avoid the
216736 : // dynamic_cast in this case. This is likely a performance improvement as well.
216737 : // return dynamic_cast<SgThrowOp*>(inputDerivedClassPointer);
216738 : // Milind Chabbi (8/28/2013): isSgThrowOp uses table-driven castability instead of c++ default dynamic_cast
216739 : // this improves the running time performance by 10-20%.
216740 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgThrowOp*>(inputDerivedClassPointer);
216741 495 : return IS_SgThrowOp_FAST_MACRO(inputDerivedClassPointer);
216742 : }
216743 :
216744 : // DQ (11/8/2003): Added version of functions taking const pointer
216745 0 : const SgThrowOp* isSgThrowOp ( const SgNode* inputDerivedClassPointer )
216746 : {
216747 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
216748 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
216749 : // So to fix this we return NULL directly when the input is NULL and avoid the
216750 : // dynamic_cast in this case. This is likely a performance improvement as well.
216751 : // return dynamic_cast<const SgThrowOp*>(inputDerivedClassPointer);
216752 : // Milind Chabbi (8/28/2013): isSgThrowOp uses table-driven castability instead of c++ default dynamic_cast
216753 : // this improves the running time performance by 10-20%.
216754 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgThrowOp*>(inputDerivedClassPointer);
216755 0 : return IS_SgThrowOp_FAST_MACRO(inputDerivedClassPointer);
216756 : }
216757 :
216758 :
216759 :
216760 : /* #line 216761 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216761 :
216762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
216763 :
216764 : /**
216765 : \brief Generated destructor
216766 :
216767 : This destructor is automatically generated (by ROSETTA). This destructor
216768 : only frees memory of data members associated with the parts of the current IR node which
216769 : are NOT traversed. Those data members that are part of a traversal can be freed using
216770 : a traversal (calling this destructor on all children in a post-order traversal). Such
216771 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
216772 :
216773 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
216774 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
216775 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
216776 :
216777 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
216778 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
216779 : pointers are not yet implemented to call delete on eash pointer in the container.
216780 : (This could be done by derivation from the STL containers to define containers that
216781 : automatically deleted their members.)
216782 :
216783 : */
216784 208 : SgThrowOp::~SgThrowOp () {
216785 104 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
216786 :
216787 :
216788 : // case: not a listType for throwKind
216789 104 : p_throwKind = SgThrowOp::unknown_throw; // non list case
216790 :
216791 : }
216792 :
216793 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
216794 208 : }
216795 :
216796 :
216797 : /* #line 216798 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216798 :
216799 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
216800 :
216801 : // Generated constructor
216802 0 : SgThrowOp::SgThrowOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgThrowOp::e_throw_kind throwKind )
216803 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
216804 : {
216805 : #ifdef DEBUG
216806 : // printf ("In SgThrowOp::SgThrowOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgThrowOp::e_throw_kind throwKind) sage_class_name() = %s \n",sage_class_name());
216807 : #endif
216808 : #if 0
216809 : // debugging information!
216810 : printf ("In SgThrowOp::SgThrowOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgThrowOp::e_throw_kind throwKind): this = %p = %s \n",this,this->class_name().c_str());
216811 : #endif
216812 :
216813 0 : p_throwKind = throwKind;
216814 :
216815 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
216816 :
216817 : #if 0
216818 : // DQ (7/30/2014): Call a virtual function.
216819 : std::string s = this->class_name();
216820 : #endif
216821 :
216822 : // Test the variant virtual function
216823 : // assert(THROW_OP == variant());
216824 0 : assert(THROW_OP == this->variant());
216825 0 : ROSE_ASSERT(THROW_OP == (int)(this->variantT()));
216826 0 : post_construction_initialization();
216827 :
216828 : // Test the isSgThrowOp() function since it has been problematic
216829 0 : assert(isSgThrowOp(this) != NULL);
216830 0 : }
216831 :
216832 : // Generated constructor (all data members)
216833 :
216834 : /* #line 216835 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216835 :
216836 :
216837 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
216838 :
216839 :
216840 : // ********************************************************
216841 : // member functions common across all array grammar objects
216842 : // ********************************************************
216843 :
216844 :
216845 :
216846 : /* #line 216847 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216847 :
216848 :
216849 :
216850 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
216851 :
216852 : // ********************************************************
216853 : // member functions specific to each node in the grammar
216854 : // ********************************************************
216855 :
216856 :
216857 : /* #line 216858 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
216858 :
216859 : // Start of memberFunctionString
216860 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
216861 :
216862 : void
216863 0 : SgRealPartOp::post_construction_initialization()
216864 : {
216865 0 : }
216866 :
216867 :
216868 :
216869 : // End of memberFunctionString
216870 : // Start of memberFunctionString
216871 : /* #line 6241 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
216872 :
216873 :
216874 :
216875 : // End of memberFunctionString
216876 : // Start of memberFunctionString
216877 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
216878 :
216879 : // *** COMMON CODE SECTION BEGINS HERE ***
216880 :
216881 : #if 0
216882 : int
216883 : SgRealPartOp::getVariant() const
216884 : {
216885 : // This function is used in ROSE while "variant()" is used in SAGE
216886 : assert(this != NULL);
216887 : return variant();
216888 : }
216889 : #endif
216890 :
216891 : // This function is used in ROSE in treeTraversal code
216892 : // eventually replaces getVariant() and variant()
216893 : // though after variant() has been removed for a while we will
216894 : // want to change the name of variantT() back to variant()
216895 : // (since the "T" was ment to stand for temporary).
216896 : // When this happens the variantT() will be depricated.
216897 : VariantT
216898 0 : SgRealPartOp::variantT() const
216899 : {
216900 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
216901 0 : ROSE_ASSERT(this != NULL);
216902 0 : return V_SgRealPartOp;
216903 : }
216904 :
216905 : #if 0
216906 : int
216907 : SgRealPartOp::variant() const
216908 : {
216909 : // This function is used in SAGE
216910 : ROSE_ASSERT(this != NULL);
216911 : return REAL_PART_OP;
216912 : }
216913 : #endif
216914 :
216915 : ROSE_DLL_API const char*
216916 0 : SgRealPartOp::sage_class_name() const
216917 : {
216918 0 : ROSE_ASSERT(this != NULL);
216919 0 : return "SgRealPartOp";
216920 : }
216921 :
216922 : std::string
216923 0 : SgRealPartOp::class_name() const
216924 : {
216925 0 : ROSE_ASSERT(this != NULL);
216926 0 : return "SgRealPartOp";
216927 : }
216928 :
216929 : // DQ (11/26/2005): Support for visitor pattern mechanims
216930 : // (inferior to ROSE traversal mechanism, experimental).
216931 : void
216932 0 : SgRealPartOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
216933 : {
216934 0 : ROSE_ASSERT(this != NULL);
216935 0 : visitor.visit(this);
216936 0 : }
216937 :
216938 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
216939 0 : void SgRealPartOp::accept (ROSE_VisitorPattern & visitor) {
216940 0 : ROSE_ASSERT(this != NULL);
216941 0 : visitor.visit(this);
216942 0 : }
216943 :
216944 : SgRealPartOp*
216945 0 : SgRealPartOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
216946 : {
216947 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
216948 : // This function is currently only supported for the AST used the represent Binary executables.
216949 : if (0 /* isSgAsmNode(this) != NULL */)
216950 : {
216951 : // Support for regex specification.
216952 : std::string prefixCode = "REGEX:";
216953 : addNewAttribute(prefixCode + s,a);
216954 : }
216955 : #endif
216956 :
216957 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
216958 0 : return this;
216959 : }
216960 :
216961 : // *** COMMON CODE SECTION ENDS HERE ***
216962 :
216963 :
216964 : // End of memberFunctionString
216965 : // Start of memberFunctionString
216966 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
216967 :
216968 :
216969 : #if 0
216970 : //! Error checking support
216971 : /*! Verifies the following:
216972 : - working getVariant() member function
216973 : - calls base class's error() member function
216974 : Every class has one of these functions.
216975 : */
216976 : bool
216977 : SgRealPartOp::error()
216978 : {
216979 : // Put error checking here
216980 :
216981 : ROSE_ASSERT (this != NULL);
216982 : if (getVariant() != REAL_PART_OP)
216983 : {
216984 : printf ("Error in SgRealPartOp::error(): SgRealPartOp object has a %s variant \n",
216985 : Cxx_GrammarTerminalNames[getVariant()].name);
216986 : // printf ("Error in SgRealPartOp::error() \n");
216987 : ROSE_ABORT();
216988 : }
216989 :
216990 : ROSE_ASSERT (getVariant() == REAL_PART_OP);
216991 : return SgUnaryOp::error();
216992 : }
216993 : #endif
216994 :
216995 :
216996 :
216997 : // End of memberFunctionString
216998 :
216999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
217000 :
217001 0 : SgRealPartOp* isSgRealPartOp ( SgNode* inputDerivedClassPointer )
217002 : {
217003 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217004 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217005 : // So to fix this we return NULL directly when the input is NULL and avoid the
217006 : // dynamic_cast in this case. This is likely a performance improvement as well.
217007 : // return dynamic_cast<SgRealPartOp*>(inputDerivedClassPointer);
217008 : // Milind Chabbi (8/28/2013): isSgRealPartOp uses table-driven castability instead of c++ default dynamic_cast
217009 : // this improves the running time performance by 10-20%.
217010 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRealPartOp*>(inputDerivedClassPointer);
217011 0 : return IS_SgRealPartOp_FAST_MACRO(inputDerivedClassPointer);
217012 : }
217013 :
217014 : // DQ (11/8/2003): Added version of functions taking const pointer
217015 0 : const SgRealPartOp* isSgRealPartOp ( const SgNode* inputDerivedClassPointer )
217016 : {
217017 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217018 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217019 : // So to fix this we return NULL directly when the input is NULL and avoid the
217020 : // dynamic_cast in this case. This is likely a performance improvement as well.
217021 : // return dynamic_cast<const SgRealPartOp*>(inputDerivedClassPointer);
217022 : // Milind Chabbi (8/28/2013): isSgRealPartOp uses table-driven castability instead of c++ default dynamic_cast
217023 : // this improves the running time performance by 10-20%.
217024 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRealPartOp*>(inputDerivedClassPointer);
217025 0 : return IS_SgRealPartOp_FAST_MACRO(inputDerivedClassPointer);
217026 : }
217027 :
217028 :
217029 :
217030 : /* #line 217031 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217031 :
217032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217033 :
217034 : /**
217035 : \brief Generated destructor
217036 :
217037 : This destructor is automatically generated (by ROSETTA). This destructor
217038 : only frees memory of data members associated with the parts of the current IR node which
217039 : are NOT traversed. Those data members that are part of a traversal can be freed using
217040 : a traversal (calling this destructor on all children in a post-order traversal). Such
217041 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
217042 :
217043 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
217044 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
217045 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
217046 :
217047 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
217048 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
217049 : pointers are not yet implemented to call delete on eash pointer in the container.
217050 : (This could be done by derivation from the STL containers to define containers that
217051 : automatically deleted their members.)
217052 :
217053 : */
217054 0 : SgRealPartOp::~SgRealPartOp () {
217055 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
217056 :
217057 :
217058 :
217059 : }
217060 :
217061 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217062 0 : }
217063 :
217064 :
217065 : /* #line 217066 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217066 :
217067 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
217068 :
217069 : // Generated constructor
217070 0 : SgRealPartOp::SgRealPartOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
217071 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
217072 : {
217073 : #ifdef DEBUG
217074 : // printf ("In SgRealPartOp::SgRealPartOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
217075 : #endif
217076 : #if 0
217077 : // debugging information!
217078 : printf ("In SgRealPartOp::SgRealPartOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
217079 : #endif
217080 :
217081 :
217082 :
217083 : #if 0
217084 : // DQ (7/30/2014): Call a virtual function.
217085 : std::string s = this->class_name();
217086 : #endif
217087 :
217088 : // Test the variant virtual function
217089 : // assert(REAL_PART_OP == variant());
217090 0 : assert(REAL_PART_OP == this->variant());
217091 0 : ROSE_ASSERT(REAL_PART_OP == (int)(this->variantT()));
217092 0 : post_construction_initialization();
217093 :
217094 : // Test the isSgRealPartOp() function since it has been problematic
217095 0 : assert(isSgRealPartOp(this) != NULL);
217096 0 : }
217097 :
217098 : // Generated constructor (all data members)
217099 :
217100 : /* #line 217101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217101 :
217102 :
217103 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
217104 :
217105 :
217106 : // ********************************************************
217107 : // member functions common across all array grammar objects
217108 : // ********************************************************
217109 :
217110 :
217111 :
217112 : /* #line 217113 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217113 :
217114 :
217115 :
217116 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
217117 :
217118 : // ********************************************************
217119 : // member functions specific to each node in the grammar
217120 : // ********************************************************
217121 :
217122 :
217123 : /* #line 217124 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217124 :
217125 : // Start of memberFunctionString
217126 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
217127 :
217128 : void
217129 0 : SgImagPartOp::post_construction_initialization()
217130 : {
217131 0 : }
217132 :
217133 :
217134 :
217135 : // End of memberFunctionString
217136 : // Start of memberFunctionString
217137 : /* #line 6245 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
217138 :
217139 :
217140 :
217141 : // End of memberFunctionString
217142 : // Start of memberFunctionString
217143 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
217144 :
217145 : // *** COMMON CODE SECTION BEGINS HERE ***
217146 :
217147 : #if 0
217148 : int
217149 : SgImagPartOp::getVariant() const
217150 : {
217151 : // This function is used in ROSE while "variant()" is used in SAGE
217152 : assert(this != NULL);
217153 : return variant();
217154 : }
217155 : #endif
217156 :
217157 : // This function is used in ROSE in treeTraversal code
217158 : // eventually replaces getVariant() and variant()
217159 : // though after variant() has been removed for a while we will
217160 : // want to change the name of variantT() back to variant()
217161 : // (since the "T" was ment to stand for temporary).
217162 : // When this happens the variantT() will be depricated.
217163 : VariantT
217164 0 : SgImagPartOp::variantT() const
217165 : {
217166 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
217167 0 : ROSE_ASSERT(this != NULL);
217168 0 : return V_SgImagPartOp;
217169 : }
217170 :
217171 : #if 0
217172 : int
217173 : SgImagPartOp::variant() const
217174 : {
217175 : // This function is used in SAGE
217176 : ROSE_ASSERT(this != NULL);
217177 : return IMAG_PART_OP;
217178 : }
217179 : #endif
217180 :
217181 : ROSE_DLL_API const char*
217182 0 : SgImagPartOp::sage_class_name() const
217183 : {
217184 0 : ROSE_ASSERT(this != NULL);
217185 0 : return "SgImagPartOp";
217186 : }
217187 :
217188 : std::string
217189 0 : SgImagPartOp::class_name() const
217190 : {
217191 0 : ROSE_ASSERT(this != NULL);
217192 0 : return "SgImagPartOp";
217193 : }
217194 :
217195 : // DQ (11/26/2005): Support for visitor pattern mechanims
217196 : // (inferior to ROSE traversal mechanism, experimental).
217197 : void
217198 0 : SgImagPartOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
217199 : {
217200 0 : ROSE_ASSERT(this != NULL);
217201 0 : visitor.visit(this);
217202 0 : }
217203 :
217204 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
217205 0 : void SgImagPartOp::accept (ROSE_VisitorPattern & visitor) {
217206 0 : ROSE_ASSERT(this != NULL);
217207 0 : visitor.visit(this);
217208 0 : }
217209 :
217210 : SgImagPartOp*
217211 0 : SgImagPartOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
217212 : {
217213 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
217214 : // This function is currently only supported for the AST used the represent Binary executables.
217215 : if (0 /* isSgAsmNode(this) != NULL */)
217216 : {
217217 : // Support for regex specification.
217218 : std::string prefixCode = "REGEX:";
217219 : addNewAttribute(prefixCode + s,a);
217220 : }
217221 : #endif
217222 :
217223 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
217224 0 : return this;
217225 : }
217226 :
217227 : // *** COMMON CODE SECTION ENDS HERE ***
217228 :
217229 :
217230 : // End of memberFunctionString
217231 : // Start of memberFunctionString
217232 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
217233 :
217234 :
217235 : #if 0
217236 : //! Error checking support
217237 : /*! Verifies the following:
217238 : - working getVariant() member function
217239 : - calls base class's error() member function
217240 : Every class has one of these functions.
217241 : */
217242 : bool
217243 : SgImagPartOp::error()
217244 : {
217245 : // Put error checking here
217246 :
217247 : ROSE_ASSERT (this != NULL);
217248 : if (getVariant() != IMAG_PART_OP)
217249 : {
217250 : printf ("Error in SgImagPartOp::error(): SgImagPartOp object has a %s variant \n",
217251 : Cxx_GrammarTerminalNames[getVariant()].name);
217252 : // printf ("Error in SgImagPartOp::error() \n");
217253 : ROSE_ABORT();
217254 : }
217255 :
217256 : ROSE_ASSERT (getVariant() == IMAG_PART_OP);
217257 : return SgUnaryOp::error();
217258 : }
217259 : #endif
217260 :
217261 :
217262 :
217263 : // End of memberFunctionString
217264 :
217265 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
217266 :
217267 0 : SgImagPartOp* isSgImagPartOp ( SgNode* inputDerivedClassPointer )
217268 : {
217269 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217270 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217271 : // So to fix this we return NULL directly when the input is NULL and avoid the
217272 : // dynamic_cast in this case. This is likely a performance improvement as well.
217273 : // return dynamic_cast<SgImagPartOp*>(inputDerivedClassPointer);
217274 : // Milind Chabbi (8/28/2013): isSgImagPartOp uses table-driven castability instead of c++ default dynamic_cast
217275 : // this improves the running time performance by 10-20%.
217276 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgImagPartOp*>(inputDerivedClassPointer);
217277 0 : return IS_SgImagPartOp_FAST_MACRO(inputDerivedClassPointer);
217278 : }
217279 :
217280 : // DQ (11/8/2003): Added version of functions taking const pointer
217281 0 : const SgImagPartOp* isSgImagPartOp ( const SgNode* inputDerivedClassPointer )
217282 : {
217283 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217284 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217285 : // So to fix this we return NULL directly when the input is NULL and avoid the
217286 : // dynamic_cast in this case. This is likely a performance improvement as well.
217287 : // return dynamic_cast<const SgImagPartOp*>(inputDerivedClassPointer);
217288 : // Milind Chabbi (8/28/2013): isSgImagPartOp uses table-driven castability instead of c++ default dynamic_cast
217289 : // this improves the running time performance by 10-20%.
217290 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgImagPartOp*>(inputDerivedClassPointer);
217291 0 : return IS_SgImagPartOp_FAST_MACRO(inputDerivedClassPointer);
217292 : }
217293 :
217294 :
217295 :
217296 : /* #line 217297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217297 :
217298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217299 :
217300 : /**
217301 : \brief Generated destructor
217302 :
217303 : This destructor is automatically generated (by ROSETTA). This destructor
217304 : only frees memory of data members associated with the parts of the current IR node which
217305 : are NOT traversed. Those data members that are part of a traversal can be freed using
217306 : a traversal (calling this destructor on all children in a post-order traversal). Such
217307 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
217308 :
217309 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
217310 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
217311 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
217312 :
217313 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
217314 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
217315 : pointers are not yet implemented to call delete on eash pointer in the container.
217316 : (This could be done by derivation from the STL containers to define containers that
217317 : automatically deleted their members.)
217318 :
217319 : */
217320 0 : SgImagPartOp::~SgImagPartOp () {
217321 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
217322 :
217323 :
217324 :
217325 : }
217326 :
217327 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217328 0 : }
217329 :
217330 :
217331 : /* #line 217332 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217332 :
217333 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
217334 :
217335 : // Generated constructor
217336 0 : SgImagPartOp::SgImagPartOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
217337 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
217338 : {
217339 : #ifdef DEBUG
217340 : // printf ("In SgImagPartOp::SgImagPartOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
217341 : #endif
217342 : #if 0
217343 : // debugging information!
217344 : printf ("In SgImagPartOp::SgImagPartOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
217345 : #endif
217346 :
217347 :
217348 :
217349 : #if 0
217350 : // DQ (7/30/2014): Call a virtual function.
217351 : std::string s = this->class_name();
217352 : #endif
217353 :
217354 : // Test the variant virtual function
217355 : // assert(IMAG_PART_OP == variant());
217356 0 : assert(IMAG_PART_OP == this->variant());
217357 0 : ROSE_ASSERT(IMAG_PART_OP == (int)(this->variantT()));
217358 0 : post_construction_initialization();
217359 :
217360 : // Test the isSgImagPartOp() function since it has been problematic
217361 0 : assert(isSgImagPartOp(this) != NULL);
217362 0 : }
217363 :
217364 : // Generated constructor (all data members)
217365 :
217366 : /* #line 217367 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217367 :
217368 :
217369 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
217370 :
217371 :
217372 : // ********************************************************
217373 : // member functions common across all array grammar objects
217374 : // ********************************************************
217375 :
217376 :
217377 :
217378 : /* #line 217379 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217379 :
217380 :
217381 :
217382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
217383 :
217384 : // ********************************************************
217385 : // member functions specific to each node in the grammar
217386 : // ********************************************************
217387 :
217388 :
217389 : /* #line 217390 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217390 :
217391 : // Start of memberFunctionString
217392 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
217393 :
217394 : void
217395 0 : SgConjugateOp::post_construction_initialization()
217396 : {
217397 0 : }
217398 :
217399 :
217400 :
217401 : // End of memberFunctionString
217402 : // Start of memberFunctionString
217403 : /* #line 6249 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
217404 :
217405 :
217406 :
217407 : // End of memberFunctionString
217408 : // Start of memberFunctionString
217409 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
217410 :
217411 : // *** COMMON CODE SECTION BEGINS HERE ***
217412 :
217413 : #if 0
217414 : int
217415 : SgConjugateOp::getVariant() const
217416 : {
217417 : // This function is used in ROSE while "variant()" is used in SAGE
217418 : assert(this != NULL);
217419 : return variant();
217420 : }
217421 : #endif
217422 :
217423 : // This function is used in ROSE in treeTraversal code
217424 : // eventually replaces getVariant() and variant()
217425 : // though after variant() has been removed for a while we will
217426 : // want to change the name of variantT() back to variant()
217427 : // (since the "T" was ment to stand for temporary).
217428 : // When this happens the variantT() will be depricated.
217429 : VariantT
217430 0 : SgConjugateOp::variantT() const
217431 : {
217432 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
217433 0 : ROSE_ASSERT(this != NULL);
217434 0 : return V_SgConjugateOp;
217435 : }
217436 :
217437 : #if 0
217438 : int
217439 : SgConjugateOp::variant() const
217440 : {
217441 : // This function is used in SAGE
217442 : ROSE_ASSERT(this != NULL);
217443 : return CONJUGATE_OP;
217444 : }
217445 : #endif
217446 :
217447 : ROSE_DLL_API const char*
217448 0 : SgConjugateOp::sage_class_name() const
217449 : {
217450 0 : ROSE_ASSERT(this != NULL);
217451 0 : return "SgConjugateOp";
217452 : }
217453 :
217454 : std::string
217455 0 : SgConjugateOp::class_name() const
217456 : {
217457 0 : ROSE_ASSERT(this != NULL);
217458 0 : return "SgConjugateOp";
217459 : }
217460 :
217461 : // DQ (11/26/2005): Support for visitor pattern mechanims
217462 : // (inferior to ROSE traversal mechanism, experimental).
217463 : void
217464 0 : SgConjugateOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
217465 : {
217466 0 : ROSE_ASSERT(this != NULL);
217467 0 : visitor.visit(this);
217468 0 : }
217469 :
217470 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
217471 0 : void SgConjugateOp::accept (ROSE_VisitorPattern & visitor) {
217472 0 : ROSE_ASSERT(this != NULL);
217473 0 : visitor.visit(this);
217474 0 : }
217475 :
217476 : SgConjugateOp*
217477 0 : SgConjugateOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
217478 : {
217479 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
217480 : // This function is currently only supported for the AST used the represent Binary executables.
217481 : if (0 /* isSgAsmNode(this) != NULL */)
217482 : {
217483 : // Support for regex specification.
217484 : std::string prefixCode = "REGEX:";
217485 : addNewAttribute(prefixCode + s,a);
217486 : }
217487 : #endif
217488 :
217489 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
217490 0 : return this;
217491 : }
217492 :
217493 : // *** COMMON CODE SECTION ENDS HERE ***
217494 :
217495 :
217496 : // End of memberFunctionString
217497 : // Start of memberFunctionString
217498 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
217499 :
217500 :
217501 : #if 0
217502 : //! Error checking support
217503 : /*! Verifies the following:
217504 : - working getVariant() member function
217505 : - calls base class's error() member function
217506 : Every class has one of these functions.
217507 : */
217508 : bool
217509 : SgConjugateOp::error()
217510 : {
217511 : // Put error checking here
217512 :
217513 : ROSE_ASSERT (this != NULL);
217514 : if (getVariant() != CONJUGATE_OP)
217515 : {
217516 : printf ("Error in SgConjugateOp::error(): SgConjugateOp object has a %s variant \n",
217517 : Cxx_GrammarTerminalNames[getVariant()].name);
217518 : // printf ("Error in SgConjugateOp::error() \n");
217519 : ROSE_ABORT();
217520 : }
217521 :
217522 : ROSE_ASSERT (getVariant() == CONJUGATE_OP);
217523 : return SgUnaryOp::error();
217524 : }
217525 : #endif
217526 :
217527 :
217528 :
217529 : // End of memberFunctionString
217530 :
217531 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
217532 :
217533 0 : SgConjugateOp* isSgConjugateOp ( SgNode* inputDerivedClassPointer )
217534 : {
217535 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217536 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217537 : // So to fix this we return NULL directly when the input is NULL and avoid the
217538 : // dynamic_cast in this case. This is likely a performance improvement as well.
217539 : // return dynamic_cast<SgConjugateOp*>(inputDerivedClassPointer);
217540 : // Milind Chabbi (8/28/2013): isSgConjugateOp uses table-driven castability instead of c++ default dynamic_cast
217541 : // this improves the running time performance by 10-20%.
217542 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgConjugateOp*>(inputDerivedClassPointer);
217543 0 : return IS_SgConjugateOp_FAST_MACRO(inputDerivedClassPointer);
217544 : }
217545 :
217546 : // DQ (11/8/2003): Added version of functions taking const pointer
217547 0 : const SgConjugateOp* isSgConjugateOp ( const SgNode* inputDerivedClassPointer )
217548 : {
217549 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217550 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217551 : // So to fix this we return NULL directly when the input is NULL and avoid the
217552 : // dynamic_cast in this case. This is likely a performance improvement as well.
217553 : // return dynamic_cast<const SgConjugateOp*>(inputDerivedClassPointer);
217554 : // Milind Chabbi (8/28/2013): isSgConjugateOp uses table-driven castability instead of c++ default dynamic_cast
217555 : // this improves the running time performance by 10-20%.
217556 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgConjugateOp*>(inputDerivedClassPointer);
217557 0 : return IS_SgConjugateOp_FAST_MACRO(inputDerivedClassPointer);
217558 : }
217559 :
217560 :
217561 :
217562 : /* #line 217563 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217563 :
217564 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217565 :
217566 : /**
217567 : \brief Generated destructor
217568 :
217569 : This destructor is automatically generated (by ROSETTA). This destructor
217570 : only frees memory of data members associated with the parts of the current IR node which
217571 : are NOT traversed. Those data members that are part of a traversal can be freed using
217572 : a traversal (calling this destructor on all children in a post-order traversal). Such
217573 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
217574 :
217575 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
217576 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
217577 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
217578 :
217579 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
217580 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
217581 : pointers are not yet implemented to call delete on eash pointer in the container.
217582 : (This could be done by derivation from the STL containers to define containers that
217583 : automatically deleted their members.)
217584 :
217585 : */
217586 0 : SgConjugateOp::~SgConjugateOp () {
217587 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
217588 :
217589 :
217590 :
217591 : }
217592 :
217593 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217594 0 : }
217595 :
217596 :
217597 : /* #line 217598 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217598 :
217599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
217600 :
217601 : // Generated constructor
217602 0 : SgConjugateOp::SgConjugateOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
217603 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
217604 : {
217605 : #ifdef DEBUG
217606 : // printf ("In SgConjugateOp::SgConjugateOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
217607 : #endif
217608 : #if 0
217609 : // debugging information!
217610 : printf ("In SgConjugateOp::SgConjugateOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
217611 : #endif
217612 :
217613 :
217614 :
217615 : #if 0
217616 : // DQ (7/30/2014): Call a virtual function.
217617 : std::string s = this->class_name();
217618 : #endif
217619 :
217620 : // Test the variant virtual function
217621 : // assert(CONJUGATE_OP == variant());
217622 0 : assert(CONJUGATE_OP == this->variant());
217623 0 : ROSE_ASSERT(CONJUGATE_OP == (int)(this->variantT()));
217624 0 : post_construction_initialization();
217625 :
217626 : // Test the isSgConjugateOp() function since it has been problematic
217627 0 : assert(isSgConjugateOp(this) != NULL);
217628 0 : }
217629 :
217630 : // Generated constructor (all data members)
217631 :
217632 : /* #line 217633 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217633 :
217634 :
217635 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
217636 :
217637 :
217638 : // ********************************************************
217639 : // member functions common across all array grammar objects
217640 : // ********************************************************
217641 :
217642 :
217643 :
217644 : /* #line 217645 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217645 :
217646 :
217647 :
217648 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
217649 :
217650 : // ********************************************************
217651 : // member functions specific to each node in the grammar
217652 : // ********************************************************
217653 :
217654 :
217655 : /* #line 217656 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217656 :
217657 : // Start of memberFunctionString
217658 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
217659 :
217660 : void
217661 0 : SgUserDefinedUnaryOp::post_construction_initialization()
217662 : {
217663 0 : }
217664 :
217665 :
217666 :
217667 : // End of memberFunctionString
217668 : // Start of memberFunctionString
217669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
217670 :
217671 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
217672 :
217673 : SgName
217674 0 : SgUserDefinedUnaryOp::get_operator_name () const
217675 : {
217676 0 : ROSE_ASSERT (this != NULL);
217677 :
217678 : #if 0
217679 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
217680 : // used to trigger marking transformations for the token-based unparsing.
217681 : printf ("SgUserDefinedUnaryOp::get_operator_name = %p = %s \n",this,this->class_name().c_str());
217682 : #endif
217683 :
217684 0 : return p_operator_name;
217685 : }
217686 :
217687 : void
217688 0 : SgUserDefinedUnaryOp::set_operator_name ( SgName operator_name )
217689 : {
217690 0 : ROSE_ASSERT (this != NULL);
217691 :
217692 : #if 0
217693 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
217694 : // used to trigger marking transformations for the token-based unparsing.
217695 : printf ("SgUserDefinedUnaryOp::set_operator_name = %p = %s \n",this,this->class_name().c_str());
217696 : #endif
217697 :
217698 0 : set_isModified(true);
217699 :
217700 0 : p_operator_name = operator_name;
217701 0 : }
217702 :
217703 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
217704 :
217705 :
217706 : // End of memberFunctionString
217707 : // Start of memberFunctionString
217708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
217709 :
217710 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
217711 :
217712 : SgFunctionSymbol*
217713 0 : SgUserDefinedUnaryOp::get_symbol () const
217714 : {
217715 0 : ROSE_ASSERT (this != NULL);
217716 :
217717 : #if 0
217718 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
217719 : // used to trigger marking transformations for the token-based unparsing.
217720 : printf ("SgUserDefinedUnaryOp::get_symbol = %p = %s \n",this,this->class_name().c_str());
217721 : #endif
217722 :
217723 0 : return p_symbol;
217724 : }
217725 :
217726 : void
217727 0 : SgUserDefinedUnaryOp::set_symbol ( SgFunctionSymbol* symbol )
217728 : {
217729 0 : ROSE_ASSERT (this != NULL);
217730 :
217731 : #if 0
217732 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
217733 : // used to trigger marking transformations for the token-based unparsing.
217734 : printf ("SgUserDefinedUnaryOp::set_symbol = %p = %s \n",this,this->class_name().c_str());
217735 : #endif
217736 :
217737 0 : set_isModified(true);
217738 :
217739 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
217740 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
217741 : {
217742 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
217743 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
217744 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
217745 : ROSE_ASSERT(false);
217746 : #endif
217747 : }
217748 : #endif
217749 0 : p_symbol = symbol;
217750 0 : }
217751 :
217752 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
217753 :
217754 :
217755 : // End of memberFunctionString
217756 : // Start of memberFunctionString
217757 : /* #line 9302 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
217758 :
217759 : SgType*
217760 0 : SgUserDefinedUnaryOp::get_type() const
217761 : {
217762 : // DQ (10/8/2008): Unclear how this should be implemented right now!
217763 0 : ROSE_ASSERT(get_symbol() != NULL);
217764 :
217765 : #if 1
217766 0 : printf ("In SgUserDefinedUnaryOp::get_type() \n");
217767 : #endif
217768 :
217769 0 : SgType* returnType = get_symbol()->get_type();
217770 0 : ROSE_ASSERT(returnType != NULL);
217771 0 : return returnType;
217772 : }
217773 :
217774 :
217775 :
217776 : // End of memberFunctionString
217777 : // Start of memberFunctionString
217778 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
217779 :
217780 : // *** COMMON CODE SECTION BEGINS HERE ***
217781 :
217782 : #if 0
217783 : int
217784 : SgUserDefinedUnaryOp::getVariant() const
217785 : {
217786 : // This function is used in ROSE while "variant()" is used in SAGE
217787 : assert(this != NULL);
217788 : return variant();
217789 : }
217790 : #endif
217791 :
217792 : // This function is used in ROSE in treeTraversal code
217793 : // eventually replaces getVariant() and variant()
217794 : // though after variant() has been removed for a while we will
217795 : // want to change the name of variantT() back to variant()
217796 : // (since the "T" was ment to stand for temporary).
217797 : // When this happens the variantT() will be depricated.
217798 : VariantT
217799 0 : SgUserDefinedUnaryOp::variantT() const
217800 : {
217801 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
217802 0 : ROSE_ASSERT(this != NULL);
217803 0 : return V_SgUserDefinedUnaryOp;
217804 : }
217805 :
217806 : #if 0
217807 : int
217808 : SgUserDefinedUnaryOp::variant() const
217809 : {
217810 : // This function is used in SAGE
217811 : ROSE_ASSERT(this != NULL);
217812 : return USER_DEFINED_UNARY_OP;
217813 : }
217814 : #endif
217815 :
217816 : ROSE_DLL_API const char*
217817 0 : SgUserDefinedUnaryOp::sage_class_name() const
217818 : {
217819 0 : ROSE_ASSERT(this != NULL);
217820 0 : return "SgUserDefinedUnaryOp";
217821 : }
217822 :
217823 : std::string
217824 0 : SgUserDefinedUnaryOp::class_name() const
217825 : {
217826 0 : ROSE_ASSERT(this != NULL);
217827 0 : return "SgUserDefinedUnaryOp";
217828 : }
217829 :
217830 : // DQ (11/26/2005): Support for visitor pattern mechanims
217831 : // (inferior to ROSE traversal mechanism, experimental).
217832 : void
217833 0 : SgUserDefinedUnaryOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
217834 : {
217835 0 : ROSE_ASSERT(this != NULL);
217836 0 : visitor.visit(this);
217837 0 : }
217838 :
217839 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
217840 0 : void SgUserDefinedUnaryOp::accept (ROSE_VisitorPattern & visitor) {
217841 0 : ROSE_ASSERT(this != NULL);
217842 0 : visitor.visit(this);
217843 0 : }
217844 :
217845 : SgUserDefinedUnaryOp*
217846 0 : SgUserDefinedUnaryOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
217847 : {
217848 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
217849 : // This function is currently only supported for the AST used the represent Binary executables.
217850 : if (0 /* isSgAsmNode(this) != NULL */)
217851 : {
217852 : // Support for regex specification.
217853 : std::string prefixCode = "REGEX:";
217854 : addNewAttribute(prefixCode + s,a);
217855 : }
217856 : #endif
217857 :
217858 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
217859 0 : return this;
217860 : }
217861 :
217862 : // *** COMMON CODE SECTION ENDS HERE ***
217863 :
217864 :
217865 : // End of memberFunctionString
217866 : // Start of memberFunctionString
217867 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
217868 :
217869 :
217870 : #if 0
217871 : //! Error checking support
217872 : /*! Verifies the following:
217873 : - working getVariant() member function
217874 : - calls base class's error() member function
217875 : Every class has one of these functions.
217876 : */
217877 : bool
217878 : SgUserDefinedUnaryOp::error()
217879 : {
217880 : // Put error checking here
217881 :
217882 : ROSE_ASSERT (this != NULL);
217883 : if (getVariant() != USER_DEFINED_UNARY_OP)
217884 : {
217885 : printf ("Error in SgUserDefinedUnaryOp::error(): SgUserDefinedUnaryOp object has a %s variant \n",
217886 : Cxx_GrammarTerminalNames[getVariant()].name);
217887 : // printf ("Error in SgUserDefinedUnaryOp::error() \n");
217888 : ROSE_ABORT();
217889 : }
217890 :
217891 : ROSE_ASSERT (getVariant() == USER_DEFINED_UNARY_OP);
217892 : return SgUnaryOp::error();
217893 : }
217894 : #endif
217895 :
217896 :
217897 :
217898 : // End of memberFunctionString
217899 :
217900 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
217901 :
217902 0 : SgUserDefinedUnaryOp* isSgUserDefinedUnaryOp ( SgNode* inputDerivedClassPointer )
217903 : {
217904 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217905 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217906 : // So to fix this we return NULL directly when the input is NULL and avoid the
217907 : // dynamic_cast in this case. This is likely a performance improvement as well.
217908 : // return dynamic_cast<SgUserDefinedUnaryOp*>(inputDerivedClassPointer);
217909 : // Milind Chabbi (8/28/2013): isSgUserDefinedUnaryOp uses table-driven castability instead of c++ default dynamic_cast
217910 : // this improves the running time performance by 10-20%.
217911 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUserDefinedUnaryOp*>(inputDerivedClassPointer);
217912 0 : return IS_SgUserDefinedUnaryOp_FAST_MACRO(inputDerivedClassPointer);
217913 : }
217914 :
217915 : // DQ (11/8/2003): Added version of functions taking const pointer
217916 0 : const SgUserDefinedUnaryOp* isSgUserDefinedUnaryOp ( const SgNode* inputDerivedClassPointer )
217917 : {
217918 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
217919 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
217920 : // So to fix this we return NULL directly when the input is NULL and avoid the
217921 : // dynamic_cast in this case. This is likely a performance improvement as well.
217922 : // return dynamic_cast<const SgUserDefinedUnaryOp*>(inputDerivedClassPointer);
217923 : // Milind Chabbi (8/28/2013): isSgUserDefinedUnaryOp uses table-driven castability instead of c++ default dynamic_cast
217924 : // this improves the running time performance by 10-20%.
217925 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUserDefinedUnaryOp*>(inputDerivedClassPointer);
217926 0 : return IS_SgUserDefinedUnaryOp_FAST_MACRO(inputDerivedClassPointer);
217927 : }
217928 :
217929 :
217930 :
217931 : /* #line 217932 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217932 :
217933 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217934 :
217935 : /**
217936 : \brief Generated destructor
217937 :
217938 : This destructor is automatically generated (by ROSETTA). This destructor
217939 : only frees memory of data members associated with the parts of the current IR node which
217940 : are NOT traversed. Those data members that are part of a traversal can be freed using
217941 : a traversal (calling this destructor on all children in a post-order traversal). Such
217942 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
217943 :
217944 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
217945 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
217946 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
217947 :
217948 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
217949 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
217950 : pointers are not yet implemented to call delete on eash pointer in the container.
217951 : (This could be done by derivation from the STL containers to define containers that
217952 : automatically deleted their members.)
217953 :
217954 : */
217955 0 : SgUserDefinedUnaryOp::~SgUserDefinedUnaryOp () {
217956 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
217957 :
217958 :
217959 : // case: not a listType for operator_name
217960 0 : p_operator_name = ""; // non list case
217961 : // case: not a listType for symbol
217962 0 : p_symbol = NULL; // non list case
217963 :
217964 : }
217965 :
217966 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
217967 0 : }
217968 :
217969 :
217970 : /* #line 217971 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
217971 :
217972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
217973 :
217974 : // Generated constructor
217975 0 : SgUserDefinedUnaryOp::SgUserDefinedUnaryOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgName operator_name, SgFunctionSymbol* symbol )
217976 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
217977 : {
217978 : #ifdef DEBUG
217979 : // printf ("In SgUserDefinedUnaryOp::SgUserDefinedUnaryOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgName operator_name, SgFunctionSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
217980 : #endif
217981 : #if 0
217982 : // debugging information!
217983 : printf ("In SgUserDefinedUnaryOp::SgUserDefinedUnaryOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type, SgName operator_name, SgFunctionSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
217984 : #endif
217985 :
217986 0 : p_operator_name = operator_name;
217987 0 : p_symbol = symbol;
217988 :
217989 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
217990 :
217991 : #if 0
217992 : // DQ (7/30/2014): Call a virtual function.
217993 : std::string s = this->class_name();
217994 : #endif
217995 :
217996 : // Test the variant virtual function
217997 : // assert(USER_DEFINED_UNARY_OP == variant());
217998 0 : assert(USER_DEFINED_UNARY_OP == this->variant());
217999 0 : ROSE_ASSERT(USER_DEFINED_UNARY_OP == (int)(this->variantT()));
218000 0 : post_construction_initialization();
218001 :
218002 : // Test the isSgUserDefinedUnaryOp() function since it has been problematic
218003 0 : assert(isSgUserDefinedUnaryOp(this) != NULL);
218004 0 : }
218005 :
218006 : // Generated constructor (all data members)
218007 :
218008 : /* #line 218009 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218009 :
218010 :
218011 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
218012 :
218013 :
218014 : // ********************************************************
218015 : // member functions common across all array grammar objects
218016 : // ********************************************************
218017 :
218018 :
218019 :
218020 : /* #line 218021 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218021 :
218022 :
218023 :
218024 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
218025 :
218026 : // ********************************************************
218027 : // member functions specific to each node in the grammar
218028 : // ********************************************************
218029 :
218030 :
218031 : /* #line 218032 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218032 :
218033 : // Start of memberFunctionString
218034 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
218035 :
218036 : void
218037 0 : SgMatrixTransposeOp::post_construction_initialization()
218038 : {
218039 0 : }
218040 :
218041 :
218042 :
218043 : // End of memberFunctionString
218044 : // Start of memberFunctionString
218045 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
218046 :
218047 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
218048 :
218049 : bool
218050 0 : SgMatrixTransposeOp::get_is_conjugate () const
218051 : {
218052 0 : ROSE_ASSERT (this != NULL);
218053 :
218054 : #if 0
218055 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218056 : // used to trigger marking transformations for the token-based unparsing.
218057 : printf ("SgMatrixTransposeOp::get_is_conjugate = %p = %s \n",this,this->class_name().c_str());
218058 : #endif
218059 :
218060 0 : return p_is_conjugate;
218061 : }
218062 :
218063 : void
218064 0 : SgMatrixTransposeOp::set_is_conjugate ( bool is_conjugate )
218065 : {
218066 0 : ROSE_ASSERT (this != NULL);
218067 :
218068 : #if 0
218069 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218070 : // used to trigger marking transformations for the token-based unparsing.
218071 : printf ("SgMatrixTransposeOp::set_is_conjugate = %p = %s \n",this,this->class_name().c_str());
218072 : #endif
218073 :
218074 0 : set_isModified(true);
218075 :
218076 0 : p_is_conjugate = is_conjugate;
218077 0 : }
218078 :
218079 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
218080 :
218081 :
218082 : // End of memberFunctionString
218083 : // Start of memberFunctionString
218084 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
218085 :
218086 : // *** COMMON CODE SECTION BEGINS HERE ***
218087 :
218088 : #if 0
218089 : int
218090 : SgMatrixTransposeOp::getVariant() const
218091 : {
218092 : // This function is used in ROSE while "variant()" is used in SAGE
218093 : assert(this != NULL);
218094 : return variant();
218095 : }
218096 : #endif
218097 :
218098 : // This function is used in ROSE in treeTraversal code
218099 : // eventually replaces getVariant() and variant()
218100 : // though after variant() has been removed for a while we will
218101 : // want to change the name of variantT() back to variant()
218102 : // (since the "T" was ment to stand for temporary).
218103 : // When this happens the variantT() will be depricated.
218104 : VariantT
218105 0 : SgMatrixTransposeOp::variantT() const
218106 : {
218107 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
218108 0 : ROSE_ASSERT(this != NULL);
218109 0 : return V_SgMatrixTransposeOp;
218110 : }
218111 :
218112 : #if 0
218113 : int
218114 : SgMatrixTransposeOp::variant() const
218115 : {
218116 : // This function is used in SAGE
218117 : ROSE_ASSERT(this != NULL);
218118 : return MATRIX_TRANSPOSE_OP;
218119 : }
218120 : #endif
218121 :
218122 : ROSE_DLL_API const char*
218123 0 : SgMatrixTransposeOp::sage_class_name() const
218124 : {
218125 0 : ROSE_ASSERT(this != NULL);
218126 0 : return "SgMatrixTransposeOp";
218127 : }
218128 :
218129 : std::string
218130 0 : SgMatrixTransposeOp::class_name() const
218131 : {
218132 0 : ROSE_ASSERT(this != NULL);
218133 0 : return "SgMatrixTransposeOp";
218134 : }
218135 :
218136 : // DQ (11/26/2005): Support for visitor pattern mechanims
218137 : // (inferior to ROSE traversal mechanism, experimental).
218138 : void
218139 0 : SgMatrixTransposeOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
218140 : {
218141 0 : ROSE_ASSERT(this != NULL);
218142 0 : visitor.visit(this);
218143 0 : }
218144 :
218145 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
218146 0 : void SgMatrixTransposeOp::accept (ROSE_VisitorPattern & visitor) {
218147 0 : ROSE_ASSERT(this != NULL);
218148 0 : visitor.visit(this);
218149 0 : }
218150 :
218151 : SgMatrixTransposeOp*
218152 0 : SgMatrixTransposeOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
218153 : {
218154 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
218155 : // This function is currently only supported for the AST used the represent Binary executables.
218156 : if (0 /* isSgAsmNode(this) != NULL */)
218157 : {
218158 : // Support for regex specification.
218159 : std::string prefixCode = "REGEX:";
218160 : addNewAttribute(prefixCode + s,a);
218161 : }
218162 : #endif
218163 :
218164 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
218165 0 : return this;
218166 : }
218167 :
218168 : // *** COMMON CODE SECTION ENDS HERE ***
218169 :
218170 :
218171 : // End of memberFunctionString
218172 : // Start of memberFunctionString
218173 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
218174 :
218175 :
218176 : #if 0
218177 : //! Error checking support
218178 : /*! Verifies the following:
218179 : - working getVariant() member function
218180 : - calls base class's error() member function
218181 : Every class has one of these functions.
218182 : */
218183 : bool
218184 : SgMatrixTransposeOp::error()
218185 : {
218186 : // Put error checking here
218187 :
218188 : ROSE_ASSERT (this != NULL);
218189 : if (getVariant() != MATRIX_TRANSPOSE_OP)
218190 : {
218191 : printf ("Error in SgMatrixTransposeOp::error(): SgMatrixTransposeOp object has a %s variant \n",
218192 : Cxx_GrammarTerminalNames[getVariant()].name);
218193 : // printf ("Error in SgMatrixTransposeOp::error() \n");
218194 : ROSE_ABORT();
218195 : }
218196 :
218197 : ROSE_ASSERT (getVariant() == MATRIX_TRANSPOSE_OP);
218198 : return SgUnaryOp::error();
218199 : }
218200 : #endif
218201 :
218202 :
218203 :
218204 : // End of memberFunctionString
218205 :
218206 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
218207 :
218208 0 : SgMatrixTransposeOp* isSgMatrixTransposeOp ( SgNode* inputDerivedClassPointer )
218209 : {
218210 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
218211 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
218212 : // So to fix this we return NULL directly when the input is NULL and avoid the
218213 : // dynamic_cast in this case. This is likely a performance improvement as well.
218214 : // return dynamic_cast<SgMatrixTransposeOp*>(inputDerivedClassPointer);
218215 : // Milind Chabbi (8/28/2013): isSgMatrixTransposeOp uses table-driven castability instead of c++ default dynamic_cast
218216 : // this improves the running time performance by 10-20%.
218217 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMatrixTransposeOp*>(inputDerivedClassPointer);
218218 0 : return IS_SgMatrixTransposeOp_FAST_MACRO(inputDerivedClassPointer);
218219 : }
218220 :
218221 : // DQ (11/8/2003): Added version of functions taking const pointer
218222 0 : const SgMatrixTransposeOp* isSgMatrixTransposeOp ( const SgNode* inputDerivedClassPointer )
218223 : {
218224 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
218225 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
218226 : // So to fix this we return NULL directly when the input is NULL and avoid the
218227 : // dynamic_cast in this case. This is likely a performance improvement as well.
218228 : // return dynamic_cast<const SgMatrixTransposeOp*>(inputDerivedClassPointer);
218229 : // Milind Chabbi (8/28/2013): isSgMatrixTransposeOp uses table-driven castability instead of c++ default dynamic_cast
218230 : // this improves the running time performance by 10-20%.
218231 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMatrixTransposeOp*>(inputDerivedClassPointer);
218232 0 : return IS_SgMatrixTransposeOp_FAST_MACRO(inputDerivedClassPointer);
218233 : }
218234 :
218235 :
218236 :
218237 : /* #line 218238 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218238 :
218239 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
218240 :
218241 : /**
218242 : \brief Generated destructor
218243 :
218244 : This destructor is automatically generated (by ROSETTA). This destructor
218245 : only frees memory of data members associated with the parts of the current IR node which
218246 : are NOT traversed. Those data members that are part of a traversal can be freed using
218247 : a traversal (calling this destructor on all children in a post-order traversal). Such
218248 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
218249 :
218250 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
218251 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
218252 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
218253 :
218254 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
218255 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
218256 : pointers are not yet implemented to call delete on eash pointer in the container.
218257 : (This could be done by derivation from the STL containers to define containers that
218258 : automatically deleted their members.)
218259 :
218260 : */
218261 0 : SgMatrixTransposeOp::~SgMatrixTransposeOp () {
218262 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
218263 :
218264 :
218265 : // case: not a listType for is_conjugate
218266 0 : p_is_conjugate = false; // non list case
218267 :
218268 : }
218269 :
218270 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
218271 0 : }
218272 :
218273 :
218274 : /* #line 218275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218275 :
218276 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
218277 :
218278 : // Generated constructor
218279 0 : SgMatrixTransposeOp::SgMatrixTransposeOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
218280 0 : : SgUnaryOp(startOfConstruct, operand_i, expression_type)
218281 : {
218282 : #ifdef DEBUG
218283 : // printf ("In SgMatrixTransposeOp::SgMatrixTransposeOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
218284 : #endif
218285 : #if 0
218286 : // debugging information!
218287 : printf ("In SgMatrixTransposeOp::SgMatrixTransposeOp (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
218288 : #endif
218289 :
218290 0 : p_is_conjugate = false;
218291 :
218292 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
218293 :
218294 : #if 0
218295 : // DQ (7/30/2014): Call a virtual function.
218296 : std::string s = this->class_name();
218297 : #endif
218298 :
218299 : // Test the variant virtual function
218300 : // assert(MATRIX_TRANSPOSE_OP == variant());
218301 0 : assert(MATRIX_TRANSPOSE_OP == this->variant());
218302 0 : ROSE_ASSERT(MATRIX_TRANSPOSE_OP == (int)(this->variantT()));
218303 0 : post_construction_initialization();
218304 :
218305 : // Test the isSgMatrixTransposeOp() function since it has been problematic
218306 0 : assert(isSgMatrixTransposeOp(this) != NULL);
218307 0 : }
218308 :
218309 : // Generated constructor (all data members)
218310 :
218311 : /* #line 218312 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218312 :
218313 :
218314 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
218315 :
218316 :
218317 : // ********************************************************
218318 : // member functions common across all array grammar objects
218319 : // ********************************************************
218320 :
218321 :
218322 :
218323 : /* #line 218324 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218324 :
218325 :
218326 :
218327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
218328 :
218329 : // ********************************************************
218330 : // member functions specific to each node in the grammar
218331 : // ********************************************************
218332 :
218333 :
218334 : /* #line 218335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218335 :
218336 : // Start of memberFunctionString
218337 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
218338 :
218339 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
218340 :
218341 : SgExpression*
218342 576050 : SgBinaryOp::get_lhs_operand_i () const
218343 : {
218344 576050 : ROSE_ASSERT (this != NULL);
218345 :
218346 : #if 0
218347 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218348 : // used to trigger marking transformations for the token-based unparsing.
218349 : printf ("SgBinaryOp::get_lhs_operand_i = %p = %s \n",this,this->class_name().c_str());
218350 : #endif
218351 :
218352 576050 : return p_lhs_operand_i;
218353 : }
218354 :
218355 : void
218356 38 : SgBinaryOp::set_lhs_operand_i ( SgExpression* lhs_operand_i )
218357 : {
218358 38 : ROSE_ASSERT (this != NULL);
218359 :
218360 : #if 0
218361 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218362 : // used to trigger marking transformations for the token-based unparsing.
218363 : printf ("SgBinaryOp::set_lhs_operand_i = %p = %s \n",this,this->class_name().c_str());
218364 : #endif
218365 :
218366 38 : set_isModified(true);
218367 :
218368 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
218369 : if (p_lhs_operand_i != NULL && lhs_operand_i != NULL && p_lhs_operand_i != lhs_operand_i)
218370 : {
218371 : printf ("Warning: lhs_operand_i = %p overwriting valid pointer p_lhs_operand_i = %p \n",lhs_operand_i,p_lhs_operand_i);
218372 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
218373 : printf ("Error fails assertion (p_lhs_operand_i != NULL && lhs_operand_i != NULL && p_lhs_operand_i != lhs_operand_i) is false\n");
218374 : ROSE_ASSERT(false);
218375 : #endif
218376 : }
218377 : #endif
218378 38 : p_lhs_operand_i = lhs_operand_i;
218379 38 : }
218380 :
218381 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
218382 :
218383 :
218384 : // End of memberFunctionString
218385 : // Start of memberFunctionString
218386 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
218387 :
218388 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
218389 :
218390 : SgExpression*
218391 437762 : SgBinaryOp::get_rhs_operand_i () const
218392 : {
218393 437762 : ROSE_ASSERT (this != NULL);
218394 :
218395 : #if 0
218396 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218397 : // used to trigger marking transformations for the token-based unparsing.
218398 : printf ("SgBinaryOp::get_rhs_operand_i = %p = %s \n",this,this->class_name().c_str());
218399 : #endif
218400 :
218401 437762 : return p_rhs_operand_i;
218402 : }
218403 :
218404 : void
218405 40 : SgBinaryOp::set_rhs_operand_i ( SgExpression* rhs_operand_i )
218406 : {
218407 40 : ROSE_ASSERT (this != NULL);
218408 :
218409 : #if 0
218410 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218411 : // used to trigger marking transformations for the token-based unparsing.
218412 : printf ("SgBinaryOp::set_rhs_operand_i = %p = %s \n",this,this->class_name().c_str());
218413 : #endif
218414 :
218415 40 : set_isModified(true);
218416 :
218417 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
218418 : if (p_rhs_operand_i != NULL && rhs_operand_i != NULL && p_rhs_operand_i != rhs_operand_i)
218419 : {
218420 : printf ("Warning: rhs_operand_i = %p overwriting valid pointer p_rhs_operand_i = %p \n",rhs_operand_i,p_rhs_operand_i);
218421 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
218422 : printf ("Error fails assertion (p_rhs_operand_i != NULL && rhs_operand_i != NULL && p_rhs_operand_i != rhs_operand_i) is false\n");
218423 : ROSE_ASSERT(false);
218424 : #endif
218425 : }
218426 : #endif
218427 40 : p_rhs_operand_i = rhs_operand_i;
218428 40 : }
218429 :
218430 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
218431 :
218432 :
218433 : // End of memberFunctionString
218434 : // Start of memberFunctionString
218435 :
218436 :
218437 : // End of memberFunctionString
218438 : // Start of memberFunctionString
218439 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
218440 :
218441 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
218442 :
218443 : SgExpression*
218444 175838 : SgBinaryOp::get_originalExpressionTree () const
218445 : {
218446 175838 : ROSE_ASSERT (this != NULL);
218447 :
218448 : #if 0
218449 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218450 : // used to trigger marking transformations for the token-based unparsing.
218451 : printf ("SgBinaryOp::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
218452 : #endif
218453 :
218454 175838 : return p_originalExpressionTree;
218455 : }
218456 :
218457 : void
218458 0 : SgBinaryOp::set_originalExpressionTree ( SgExpression* originalExpressionTree )
218459 : {
218460 0 : ROSE_ASSERT (this != NULL);
218461 :
218462 : #if 0
218463 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
218464 : // used to trigger marking transformations for the token-based unparsing.
218465 : printf ("SgBinaryOp::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
218466 : #endif
218467 :
218468 0 : set_isModified(true);
218469 :
218470 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
218471 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
218472 : {
218473 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
218474 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
218475 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
218476 : ROSE_ASSERT(false);
218477 : #endif
218478 : }
218479 : #endif
218480 0 : p_originalExpressionTree = originalExpressionTree;
218481 0 : }
218482 :
218483 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
218484 :
218485 :
218486 : // End of memberFunctionString
218487 : // Start of memberFunctionString
218488 : /* #line 2904 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
218489 :
218490 : void
218491 55123 : SgBinaryOp::post_construction_initialization()
218492 : {
218493 : // #ifndef REMOVE_SET_PARENT_FUNCTION
218494 55123 : if (get_lhs_operand())
218495 55044 : get_lhs_operand()->set_parent(this);
218496 55123 : if (get_rhs_operand())
218497 55043 : get_rhs_operand()->set_parent(this);
218498 : // #endif
218499 55123 : }
218500 :
218501 : SgExpression*
218502 567328 : SgBinaryOp::get_lhs_operand() const
218503 567328 : { return get_lhs_operand_i(); }
218504 :
218505 : void
218506 38 : SgBinaryOp::set_lhs_operand(SgExpression * exp)
218507 : {
218508 38 : set_lhs_operand_i(exp);
218509 : // #ifndef REMOVE_SET_PARENT_FUNCTION
218510 38 : if (exp)
218511 38 : exp->set_parent(this);
218512 : // #endif
218513 :
218514 : // DQ (1/14/2006): set_type is removed
218515 : // set_type();
218516 38 : }
218517 :
218518 : int
218519 0 : SgBinaryOp::length() const
218520 : {
218521 0 : return 2;
218522 : }
218523 :
218524 : // I don't think this is used (so exclude it until we clearly need it)!
218525 : bool
218526 0 : SgBinaryOp::empty() const
218527 : {
218528 0 : return false; // return 0;
218529 : }
218530 :
218531 : SgExpression*
218532 429040 : SgBinaryOp::get_rhs_operand() const
218533 429040 : { return get_rhs_operand_i(); }
218534 :
218535 : void
218536 40 : SgBinaryOp::set_rhs_operand(SgExpression * exp)
218537 : {
218538 40 : set_rhs_operand_i(exp);
218539 : // #ifndef REMOVE_SET_PARENT_FUNCTION
218540 40 : if (exp)
218541 40 : exp->set_parent(this);
218542 : // #endif
218543 :
218544 : // DQ (1/14/2006): set_type is removed
218545 : // set_type();
218546 40 : }
218547 :
218548 : SgType*
218549 13638 : SgBinaryOp::get_type() const
218550 : {
218551 : // We have to select one, so for now chose the lhs, it might be that
218552 : // we have to explicitly store the return type of binary operators.
218553 :
218554 13638 : ROSE_ASSERT(get_lhs_operand() != NULL);
218555 13638 : ROSE_ASSERT(get_rhs_operand() != NULL);
218556 :
218557 : #if 0
218558 : printf ("In SgBinaryOp::get_type(): this->class_name() = %s \n",this->class_name().c_str());
218559 : #endif
218560 :
218561 13638 : SgType* lhsType = get_lhs_operand()->get_type();
218562 13638 : ROSE_ASSERT(lhsType != NULL);
218563 :
218564 13638 : SgType* rhsType = get_rhs_operand()->get_type();
218565 13638 : ROSE_ASSERT(rhsType != NULL);
218566 :
218567 : // DQ (9/27/2006): Ideally, this should not be set, though sometimes it is.
218568 : // ROSE_ASSERT(p_expression_type != NULL);
218569 27276 : string expression_type_name = "NULL";
218570 13638 : if (p_expression_type != NULL)
218571 : {
218572 0 : expression_type_name = p_expression_type->class_name();
218573 0 : printf ("Found an case where SgBinaryOp::p_expression_type != NULL on %s expression_type_name = %s \n",
218574 0 : this->class_name().c_str(),expression_type_name.c_str());
218575 : }
218576 :
218577 13638 : if (variantT() == V_SgAddOp || variantT() == V_SgSubtractOp)
218578 : {
218579 : // PC (10/9/2009): Pointer arithmetic is a special case
218580 5375 : SgType *lhsBase = SageInterface::getElementType(lhsType),
218581 5375 : *rhsBase = SageInterface::getElementType(rhsType);
218582 :
218583 : /* Note that we return an SgPointerType regardless of whether the original
218584 : * type was an SgPointerType or SgArrayType. This is because the latter
218585 : * undergoes implicit array-to-pointer conversion. */
218586 5375 : if (lhsBase != NULL && rhsBase == NULL)
218587 : {
218588 432 : return SgPointerType::createType(lhsBase);
218589 : }
218590 4943 : else if (lhsBase == NULL && rhsBase != NULL)
218591 : {
218592 28 : return SgPointerType::createType(rhsBase);
218593 : }
218594 4915 : else if (lhsBase != NULL && rhsBase != NULL && variantT() == V_SgSubtractOp)
218595 : {
218596 : // TODO: return ptrdiff_t
218597 : return lhsType;
218598 : }
218599 : }
218600 :
218601 : return lhsType;
218602 : }
218603 :
218604 : SgExpression*
218605 0 : SgBinaryOp::get_next(int& n) const
218606 : {
218607 0 : if(n==0)
218608 : {
218609 0 : n++;
218610 0 : return get_lhs_operand();
218611 : }
218612 : else
218613 : {
218614 0 : if (n==1)
218615 : {
218616 0 : n++;
218617 0 : return get_rhs_operand();
218618 : }
218619 : }
218620 :
218621 : return 0;
218622 : }
218623 :
218624 : int
218625 0 : SgBinaryOp::replace_expression(SgExpression *o, SgExpression *n)
218626 : {
218627 : // DQ (12/17/2006): This function should have the semantics that it will represent a
218628 : // structural change to the AST, thus it is free to set the parent of the new expression.
218629 :
218630 0 : ROSE_ASSERT(o != NULL);
218631 0 : ROSE_ASSERT(n != NULL);
218632 :
218633 0 : if (get_lhs_operand() == o)
218634 : {
218635 0 : set_lhs_operand(n);
218636 0 : return 1;
218637 : }
218638 : else
218639 0 : if (get_rhs_operand() == o)
218640 : {
218641 0 : set_rhs_operand(n);
218642 0 : return 1;
218643 : }
218644 : else
218645 : {
218646 0 : printf ("Warning: inside of SgBinaryOp::replace_expression original SgExpression unidentified \n");
218647 0 : return 0;
218648 : }
218649 : }
218650 :
218651 :
218652 :
218653 : // End of memberFunctionString
218654 : // Start of memberFunctionString
218655 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
218656 :
218657 : // *** COMMON CODE SECTION BEGINS HERE ***
218658 :
218659 : #if 0
218660 : int
218661 : SgBinaryOp::getVariant() const
218662 : {
218663 : // This function is used in ROSE while "variant()" is used in SAGE
218664 : assert(this != NULL);
218665 : return variant();
218666 : }
218667 : #endif
218668 :
218669 : // This function is used in ROSE in treeTraversal code
218670 : // eventually replaces getVariant() and variant()
218671 : // though after variant() has been removed for a while we will
218672 : // want to change the name of variantT() back to variant()
218673 : // (since the "T" was ment to stand for temporary).
218674 : // When this happens the variantT() will be depricated.
218675 : VariantT
218676 165369 : SgBinaryOp::variantT() const
218677 : {
218678 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
218679 165369 : ROSE_ASSERT(this != NULL);
218680 165369 : return V_SgBinaryOp;
218681 : }
218682 :
218683 : #if 0
218684 : int
218685 : SgBinaryOp::variant() const
218686 : {
218687 : // This function is used in SAGE
218688 : ROSE_ASSERT(this != NULL);
218689 : return BINARY_EXPRESSION;
218690 : }
218691 : #endif
218692 :
218693 : ROSE_DLL_API const char*
218694 0 : SgBinaryOp::sage_class_name() const
218695 : {
218696 0 : ROSE_ASSERT(this != NULL);
218697 0 : return "SgBinaryOp";
218698 : }
218699 :
218700 : std::string
218701 0 : SgBinaryOp::class_name() const
218702 : {
218703 0 : ROSE_ASSERT(this != NULL);
218704 0 : return "SgBinaryOp";
218705 : }
218706 :
218707 : // DQ (11/26/2005): Support for visitor pattern mechanims
218708 : // (inferior to ROSE traversal mechanism, experimental).
218709 : void
218710 0 : SgBinaryOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
218711 : {
218712 0 : ROSE_ASSERT(this != NULL);
218713 0 : visitor.visit(this);
218714 0 : }
218715 :
218716 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
218717 0 : void SgBinaryOp::accept (ROSE_VisitorPattern & visitor) {
218718 0 : ROSE_ASSERT(this != NULL);
218719 0 : visitor.visit(this);
218720 0 : }
218721 :
218722 : SgBinaryOp*
218723 0 : SgBinaryOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
218724 : {
218725 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
218726 : // This function is currently only supported for the AST used the represent Binary executables.
218727 : if (0 /* isSgAsmNode(this) != NULL */)
218728 : {
218729 : // Support for regex specification.
218730 : std::string prefixCode = "REGEX:";
218731 : addNewAttribute(prefixCode + s,a);
218732 : }
218733 : #endif
218734 :
218735 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
218736 0 : return this;
218737 : }
218738 :
218739 : // *** COMMON CODE SECTION ENDS HERE ***
218740 :
218741 :
218742 : // End of memberFunctionString
218743 : // Start of memberFunctionString
218744 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
218745 :
218746 :
218747 : #if 0
218748 : //! Error checking support
218749 : /*! Verifies the following:
218750 : - working getVariant() member function
218751 : - calls base class's error() member function
218752 : Every class has one of these functions.
218753 : */
218754 : bool
218755 : SgBinaryOp::error()
218756 : {
218757 : // Put error checking here
218758 :
218759 : ROSE_ASSERT (this != NULL);
218760 : if (getVariant() != BINARY_EXPRESSION)
218761 : {
218762 : printf ("Error in SgBinaryOp::error(): SgBinaryOp object has a %s variant \n",
218763 : Cxx_GrammarTerminalNames[getVariant()].name);
218764 : // printf ("Error in SgBinaryOp::error() \n");
218765 : ROSE_ABORT();
218766 : }
218767 :
218768 : ROSE_ASSERT (getVariant() == BINARY_EXPRESSION);
218769 : return SgExpression::error();
218770 : }
218771 : #endif
218772 :
218773 :
218774 :
218775 : // End of memberFunctionString
218776 :
218777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
218778 :
218779 828822 : SgBinaryOp* isSgBinaryOp ( SgNode* inputDerivedClassPointer )
218780 : {
218781 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
218782 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
218783 : // So to fix this we return NULL directly when the input is NULL and avoid the
218784 : // dynamic_cast in this case. This is likely a performance improvement as well.
218785 : // return dynamic_cast<SgBinaryOp*>(inputDerivedClassPointer);
218786 : // Milind Chabbi (8/28/2013): isSgBinaryOp uses table-driven castability instead of c++ default dynamic_cast
218787 : // this improves the running time performance by 10-20%.
218788 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBinaryOp*>(inputDerivedClassPointer);
218789 828822 : return IS_SgBinaryOp_FAST_MACRO(inputDerivedClassPointer);
218790 : }
218791 :
218792 : // DQ (11/8/2003): Added version of functions taking const pointer
218793 12 : const SgBinaryOp* isSgBinaryOp ( const SgNode* inputDerivedClassPointer )
218794 : {
218795 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
218796 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
218797 : // So to fix this we return NULL directly when the input is NULL and avoid the
218798 : // dynamic_cast in this case. This is likely a performance improvement as well.
218799 : // return dynamic_cast<const SgBinaryOp*>(inputDerivedClassPointer);
218800 : // Milind Chabbi (8/28/2013): isSgBinaryOp uses table-driven castability instead of c++ default dynamic_cast
218801 : // this improves the running time performance by 10-20%.
218802 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBinaryOp*>(inputDerivedClassPointer);
218803 12 : return IS_SgBinaryOp_FAST_MACRO(inputDerivedClassPointer);
218804 : }
218805 :
218806 :
218807 :
218808 : /* #line 218809 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218809 :
218810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
218811 :
218812 : /**
218813 : \brief Generated destructor
218814 :
218815 : This destructor is automatically generated (by ROSETTA). This destructor
218816 : only frees memory of data members associated with the parts of the current IR node which
218817 : are NOT traversed. Those data members that are part of a traversal can be freed using
218818 : a traversal (calling this destructor on all children in a post-order traversal). Such
218819 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
218820 :
218821 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
218822 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
218823 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
218824 :
218825 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
218826 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
218827 : pointers are not yet implemented to call delete on eash pointer in the container.
218828 : (This could be done by derivation from the STL containers to define containers that
218829 : automatically deleted their members.)
218830 :
218831 : */
218832 14229 : SgBinaryOp::~SgBinaryOp () {
218833 14229 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
218834 :
218835 :
218836 : // case: not a listType for lhs_operand_i
218837 14229 : p_lhs_operand_i = NULL; // non list case
218838 : // case: not a listType for rhs_operand_i
218839 14229 : p_rhs_operand_i = NULL; // non list case
218840 : // case: not a listType for expression_type
218841 14229 : p_expression_type = NULL; // non list case
218842 : // case: not a listType for originalExpressionTree
218843 14229 : p_originalExpressionTree = NULL; // non list case
218844 :
218845 : }
218846 :
218847 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
218848 14229 : }
218849 :
218850 :
218851 : /* #line 218852 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218852 :
218853 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
218854 :
218855 : // Generated constructor
218856 2233 : SgBinaryOp::SgBinaryOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
218857 2233 : : SgExpression(startOfConstruct)
218858 : {
218859 : #ifdef DEBUG
218860 : // printf ("In SgBinaryOp::SgBinaryOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
218861 : #endif
218862 : #if 0
218863 : // debugging information!
218864 : printf ("In SgBinaryOp::SgBinaryOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
218865 : #endif
218866 :
218867 2233 : p_lhs_operand_i = lhs_operand_i;
218868 2233 : p_rhs_operand_i = rhs_operand_i;
218869 2233 : p_expression_type = expression_type;
218870 2233 : p_originalExpressionTree = NULL;
218871 :
218872 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
218873 :
218874 : #if 0
218875 : // DQ (7/30/2014): Call a virtual function.
218876 : std::string s = this->class_name();
218877 : #endif
218878 :
218879 : // Test the variant virtual function
218880 : // assert(BINARY_EXPRESSION == variant());
218881 2233 : assert(BINARY_EXPRESSION == this->variant());
218882 2233 : ROSE_ASSERT(BINARY_EXPRESSION == (int)(this->variantT()));
218883 2233 : post_construction_initialization();
218884 :
218885 : // Test the isSgBinaryOp() function since it has been problematic
218886 2233 : assert(isSgBinaryOp(this) != NULL);
218887 2233 : }
218888 :
218889 : // Generated constructor (all data members)
218890 :
218891 : /* #line 218892 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218892 :
218893 :
218894 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
218895 :
218896 :
218897 : // ********************************************************
218898 : // member functions common across all array grammar objects
218899 : // ********************************************************
218900 :
218901 :
218902 :
218903 : /* #line 218904 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218904 :
218905 :
218906 :
218907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
218908 :
218909 : // ********************************************************
218910 : // member functions specific to each node in the grammar
218911 : // ********************************************************
218912 :
218913 :
218914 : /* #line 218915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
218915 :
218916 : // Start of memberFunctionString
218917 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
218918 :
218919 : void
218920 12134 : SgArrowExp::post_construction_initialization()
218921 : {
218922 12134 : }
218923 :
218924 :
218925 :
218926 : // End of memberFunctionString
218927 : // Start of memberFunctionString
218928 : /* #line 4714 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
218929 :
218930 :
218931 : SgType*
218932 52644 : SgArrowExp::get_type() const
218933 : {
218934 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
218935 :
218936 : // For the SgArrowExp, the type is the type of the rhs operand (e.g. "Aptr->x" where "x" is the data member of the pointer to class "A").
218937 :
218938 : // printf ("SgArrowExp::get_type(): p_expression_type has been removed, we have to compute the appropriate type \n");
218939 :
218940 52644 : ROSE_ASSERT(get_lhs_operand() != NULL);
218941 52644 : ROSE_ASSERT(get_rhs_operand() != NULL);
218942 :
218943 : #if 0
218944 : printf ("In SgArrowExp::get_type() \n");
218945 : #endif
218946 :
218947 52644 : SgType* returnType = get_rhs_operand()->get_type();
218948 :
218949 52644 : ROSE_ASSERT(returnType != NULL);
218950 :
218951 : #if 0
218952 : printf ("SgArrowExp::get_type(): get the type of the rhs operand returnType = %p = %s \n",returnType,returnType->class_name().c_str());
218953 : #endif
218954 :
218955 : // DQ (7/16/2014): In the case of UPC shared type for the lhs_operand, we need to return a type that is marked as
218956 : // shared (even if the type on the rhs_operand is non-shared) (see UPC_tests/test2014_56.c for an example).
218957 52644 : returnType = checkForSharedTypeAndReturnSharedType(returnType);
218958 :
218959 : #if 0
218960 : printf ("Leaving SgArrowExp::get_type(): returnType->get_mangled() = %s \n",returnType->get_mangled().str());
218961 : #endif
218962 :
218963 52644 : return returnType;
218964 : }
218965 :
218966 :
218967 : SgType*
218968 52644 : SgArrowExp::checkForSharedTypeAndReturnSharedType( SgType* possibleReturnType ) const
218969 : {
218970 : // DQ (7/16/2014): In the case of UPC shared type for the lhs_operand, we need to return a type that is marked as
218971 : // shared (even if the type on the rhs_operand is non-shared) (see UPC_tests/test2014_56.c for an example).
218972 :
218973 52644 : SgType* returnType = possibleReturnType;
218974 :
218975 52644 : ROSE_ASSERT(get_lhs_operand()->get_type() != NULL);
218976 52644 : SgModifierType* mod_type = isSgModifierType(get_lhs_operand()->get_type());
218977 52644 : if (mod_type != NULL)
218978 : {
218979 : #if 0
218980 : printf ("In SgArrowExp::checkForSharedTypeAndReturnSharedType(): (mod_type != NULL): get_lhs_operand()->get_type() = %p = %s \n",get_lhs_operand()->get_type(),get_lhs_operand()->get_type()->class_name().c_str());
218981 : #endif
218982 0 : if (mod_type->get_typeModifier().get_upcModifier().get_isShared() == true)
218983 : {
218984 : #if 0
218985 : printf ("In SgArrowExp::checkForSharedTypeAndReturnSharedType(): Detected a UPC shared lhs type in the evaluation of the type for SgArrowExp expression (need to return a type same as rhs type, but marked as shared) \n");
218986 : #endif
218987 0 : returnType = SageBuilder::buildUpcSharedType(returnType);
218988 : }
218989 : }
218990 : else
218991 : {
218992 : #if 0
218993 : printf ("In SgArrowExp::checkForSharedTypeAndReturnSharedType(): (mod_type == NULL): get_lhs_operand()->get_type() = %p = %s \n",get_lhs_operand()->get_type(),get_lhs_operand()->get_type()->class_name().c_str());
218994 : #endif
218995 52644 : SgPointerType* pointerType = isSgPointerType(get_lhs_operand()->get_type());
218996 52644 : if (pointerType != NULL)
218997 : {
218998 : #if 0
218999 : printf ("In SgArrowExp::checkForSharedTypeAndReturnSharedType(): Detected pointer type: pointerType = %p \n",pointerType);
219000 : #endif
219001 51092 : SgType* base_type = pointerType->get_base_type();
219002 51092 : SgModifierType* modifier_type = isSgModifierType(base_type);
219003 53022 : while (modifier_type != NULL && modifier_type->get_typeModifier().get_upcModifier().get_isShared() == false)
219004 : {
219005 : #if 0
219006 : printf ("In SgArrowExp::checkForSharedTypeAndReturnSharedType(): SgPointerType: SgModifierType type: (loop): Detected a SgModifierType \n");
219007 : #endif
219008 1930 : modifier_type = isSgModifierType(modifier_type->get_base_type());
219009 : }
219010 51092 : if (modifier_type != NULL && modifier_type->get_typeModifier().get_upcModifier().get_isShared() == true)
219011 : {
219012 : #if 0
219013 : printf ("In SgArrowExp::checkForSharedTypeAndReturnSharedType(): SgPointerType: SgModifierType type: Detected a UPC shared lhs type in the evaluation of the type for SgArrowExp expression (need to return a type same as rhs type, but marked as shared) \n");
219014 : #endif
219015 0 : returnType = SageBuilder::buildUpcSharedType(returnType);
219016 : }
219017 : }
219018 : }
219019 :
219020 52644 : return returnType;
219021 : }
219022 :
219023 :
219024 :
219025 :
219026 :
219027 : // End of memberFunctionString
219028 : // Start of memberFunctionString
219029 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
219030 :
219031 : // *** COMMON CODE SECTION BEGINS HERE ***
219032 :
219033 : #if 0
219034 : int
219035 : SgArrowExp::getVariant() const
219036 : {
219037 : // This function is used in ROSE while "variant()" is used in SAGE
219038 : assert(this != NULL);
219039 : return variant();
219040 : }
219041 : #endif
219042 :
219043 : // This function is used in ROSE in treeTraversal code
219044 : // eventually replaces getVariant() and variant()
219045 : // though after variant() has been removed for a while we will
219046 : // want to change the name of variantT() back to variant()
219047 : // (since the "T" was ment to stand for temporary).
219048 : // When this happens the variantT() will be depricated.
219049 : VariantT
219050 4255430 : SgArrowExp::variantT() const
219051 : {
219052 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
219053 4255430 : ROSE_ASSERT(this != NULL);
219054 4255430 : return V_SgArrowExp;
219055 : }
219056 :
219057 : #if 0
219058 : int
219059 : SgArrowExp::variant() const
219060 : {
219061 : // This function is used in SAGE
219062 : ROSE_ASSERT(this != NULL);
219063 : return POINTST_OP;
219064 : }
219065 : #endif
219066 :
219067 : ROSE_DLL_API const char*
219068 503 : SgArrowExp::sage_class_name() const
219069 : {
219070 503 : ROSE_ASSERT(this != NULL);
219071 503 : return "SgArrowExp";
219072 : }
219073 :
219074 : std::string
219075 10181 : SgArrowExp::class_name() const
219076 : {
219077 10181 : ROSE_ASSERT(this != NULL);
219078 10181 : return "SgArrowExp";
219079 : }
219080 :
219081 : // DQ (11/26/2005): Support for visitor pattern mechanims
219082 : // (inferior to ROSE traversal mechanism, experimental).
219083 : void
219084 180989 : SgArrowExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
219085 : {
219086 180989 : ROSE_ASSERT(this != NULL);
219087 180989 : visitor.visit(this);
219088 180989 : }
219089 :
219090 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
219091 0 : void SgArrowExp::accept (ROSE_VisitorPattern & visitor) {
219092 0 : ROSE_ASSERT(this != NULL);
219093 0 : visitor.visit(this);
219094 0 : }
219095 :
219096 : SgArrowExp*
219097 0 : SgArrowExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
219098 : {
219099 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
219100 : // This function is currently only supported for the AST used the represent Binary executables.
219101 : if (0 /* isSgAsmNode(this) != NULL */)
219102 : {
219103 : // Support for regex specification.
219104 : std::string prefixCode = "REGEX:";
219105 : addNewAttribute(prefixCode + s,a);
219106 : }
219107 : #endif
219108 :
219109 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
219110 0 : return this;
219111 : }
219112 :
219113 : // *** COMMON CODE SECTION ENDS HERE ***
219114 :
219115 :
219116 : // End of memberFunctionString
219117 : // Start of memberFunctionString
219118 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
219119 :
219120 :
219121 : #if 0
219122 : //! Error checking support
219123 : /*! Verifies the following:
219124 : - working getVariant() member function
219125 : - calls base class's error() member function
219126 : Every class has one of these functions.
219127 : */
219128 : bool
219129 : SgArrowExp::error()
219130 : {
219131 : // Put error checking here
219132 :
219133 : ROSE_ASSERT (this != NULL);
219134 : if (getVariant() != POINTST_OP)
219135 : {
219136 : printf ("Error in SgArrowExp::error(): SgArrowExp object has a %s variant \n",
219137 : Cxx_GrammarTerminalNames[getVariant()].name);
219138 : // printf ("Error in SgArrowExp::error() \n");
219139 : ROSE_ABORT();
219140 : }
219141 :
219142 : ROSE_ASSERT (getVariant() == POINTST_OP);
219143 : return SgBinaryOp::error();
219144 : }
219145 : #endif
219146 :
219147 :
219148 :
219149 : // End of memberFunctionString
219150 :
219151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
219152 :
219153 216031 : SgArrowExp* isSgArrowExp ( SgNode* inputDerivedClassPointer )
219154 : {
219155 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
219156 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
219157 : // So to fix this we return NULL directly when the input is NULL and avoid the
219158 : // dynamic_cast in this case. This is likely a performance improvement as well.
219159 : // return dynamic_cast<SgArrowExp*>(inputDerivedClassPointer);
219160 : // Milind Chabbi (8/28/2013): isSgArrowExp uses table-driven castability instead of c++ default dynamic_cast
219161 : // this improves the running time performance by 10-20%.
219162 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgArrowExp*>(inputDerivedClassPointer);
219163 216031 : return IS_SgArrowExp_FAST_MACRO(inputDerivedClassPointer);
219164 : }
219165 :
219166 : // DQ (11/8/2003): Added version of functions taking const pointer
219167 0 : const SgArrowExp* isSgArrowExp ( const SgNode* inputDerivedClassPointer )
219168 : {
219169 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
219170 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
219171 : // So to fix this we return NULL directly when the input is NULL and avoid the
219172 : // dynamic_cast in this case. This is likely a performance improvement as well.
219173 : // return dynamic_cast<const SgArrowExp*>(inputDerivedClassPointer);
219174 : // Milind Chabbi (8/28/2013): isSgArrowExp uses table-driven castability instead of c++ default dynamic_cast
219175 : // this improves the running time performance by 10-20%.
219176 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgArrowExp*>(inputDerivedClassPointer);
219177 0 : return IS_SgArrowExp_FAST_MACRO(inputDerivedClassPointer);
219178 : }
219179 :
219180 :
219181 :
219182 : /* #line 219183 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219183 :
219184 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
219185 :
219186 : /**
219187 : \brief Generated destructor
219188 :
219189 : This destructor is automatically generated (by ROSETTA). This destructor
219190 : only frees memory of data members associated with the parts of the current IR node which
219191 : are NOT traversed. Those data members that are part of a traversal can be freed using
219192 : a traversal (calling this destructor on all children in a post-order traversal). Such
219193 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
219194 :
219195 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
219196 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
219197 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
219198 :
219199 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
219200 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
219201 : pointers are not yet implemented to call delete on eash pointer in the container.
219202 : (This could be done by derivation from the STL containers to define containers that
219203 : automatically deleted their members.)
219204 :
219205 : */
219206 5268 : SgArrowExp::~SgArrowExp () {
219207 2634 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
219208 :
219209 :
219210 :
219211 : }
219212 :
219213 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
219214 5268 : }
219215 :
219216 :
219217 : /* #line 219218 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219218 :
219219 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
219220 :
219221 : // Generated constructor
219222 336 : SgArrowExp::SgArrowExp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
219223 336 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
219224 : {
219225 : #ifdef DEBUG
219226 : // printf ("In SgArrowExp::SgArrowExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
219227 : #endif
219228 : #if 0
219229 : // debugging information!
219230 : printf ("In SgArrowExp::SgArrowExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
219231 : #endif
219232 :
219233 :
219234 :
219235 : #if 0
219236 : // DQ (7/30/2014): Call a virtual function.
219237 : std::string s = this->class_name();
219238 : #endif
219239 :
219240 : // Test the variant virtual function
219241 : // assert(POINTST_OP == variant());
219242 336 : assert(POINTST_OP == this->variant());
219243 336 : ROSE_ASSERT(POINTST_OP == (int)(this->variantT()));
219244 336 : post_construction_initialization();
219245 :
219246 : // Test the isSgArrowExp() function since it has been problematic
219247 336 : assert(isSgArrowExp(this) != NULL);
219248 336 : }
219249 :
219250 : // Generated constructor (all data members)
219251 :
219252 : /* #line 219253 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219253 :
219254 :
219255 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
219256 :
219257 :
219258 : // ********************************************************
219259 : // member functions common across all array grammar objects
219260 : // ********************************************************
219261 :
219262 :
219263 :
219264 : /* #line 219265 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219265 :
219266 :
219267 :
219268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
219269 :
219270 : // ********************************************************
219271 : // member functions specific to each node in the grammar
219272 : // ********************************************************
219273 :
219274 :
219275 : /* #line 219276 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219276 :
219277 : // Start of memberFunctionString
219278 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
219279 :
219280 : void
219281 8750 : SgDotExp::post_construction_initialization()
219282 : {
219283 8750 : }
219284 :
219285 :
219286 :
219287 : // End of memberFunctionString
219288 : // Start of memberFunctionString
219289 : /* #line 4813 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
219290 :
219291 :
219292 : SgType*
219293 : // SgDotExp::get_type() const
219294 41933 : SgDotExp::get_type() const
219295 : {
219296 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
219297 :
219298 : // For the SgDotExp, the type is the type of the rhs operand (e.g. "A.x" where "x" is the data member of the class "A").
219299 :
219300 : // printf ("SgDotExp::get_type(): p_expression_type has been removed, we have to compute the appropriate type \n");
219301 :
219302 41933 : ROSE_ASSERT(get_lhs_operand() != NULL);
219303 41933 : ROSE_ASSERT(get_rhs_operand() != NULL);
219304 :
219305 : #if 0
219306 : printf ("In SgDotExp::get_type() \n");
219307 : #endif
219308 :
219309 41933 : SgType* returnType = get_rhs_operand()->get_type();
219310 :
219311 41933 : ROSE_ASSERT(returnType != NULL);
219312 :
219313 : // printf ("SgDotExp::get_type(): get the type of the rhs operand returnType = %s \n",returnType->class_name().c_str());
219314 :
219315 41933 : return returnType;
219316 : }
219317 :
219318 :
219319 :
219320 : // End of memberFunctionString
219321 : // Start of memberFunctionString
219322 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
219323 :
219324 : // *** COMMON CODE SECTION BEGINS HERE ***
219325 :
219326 : #if 0
219327 : int
219328 : SgDotExp::getVariant() const
219329 : {
219330 : // This function is used in ROSE while "variant()" is used in SAGE
219331 : assert(this != NULL);
219332 : return variant();
219333 : }
219334 : #endif
219335 :
219336 : // This function is used in ROSE in treeTraversal code
219337 : // eventually replaces getVariant() and variant()
219338 : // though after variant() has been removed for a while we will
219339 : // want to change the name of variantT() back to variant()
219340 : // (since the "T" was ment to stand for temporary).
219341 : // When this happens the variantT() will be depricated.
219342 : VariantT
219343 3822500 : SgDotExp::variantT() const
219344 : {
219345 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
219346 3822500 : ROSE_ASSERT(this != NULL);
219347 3822500 : return V_SgDotExp;
219348 : }
219349 :
219350 : #if 0
219351 : int
219352 : SgDotExp::variant() const
219353 : {
219354 : // This function is used in SAGE
219355 : ROSE_ASSERT(this != NULL);
219356 : return RECORD_REF;
219357 : }
219358 : #endif
219359 :
219360 : ROSE_DLL_API const char*
219361 212 : SgDotExp::sage_class_name() const
219362 : {
219363 212 : ROSE_ASSERT(this != NULL);
219364 212 : return "SgDotExp";
219365 : }
219366 :
219367 : std::string
219368 7210 : SgDotExp::class_name() const
219369 : {
219370 7210 : ROSE_ASSERT(this != NULL);
219371 7210 : return "SgDotExp";
219372 : }
219373 :
219374 : // DQ (11/26/2005): Support for visitor pattern mechanims
219375 : // (inferior to ROSE traversal mechanism, experimental).
219376 : void
219377 121974 : SgDotExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
219378 : {
219379 121974 : ROSE_ASSERT(this != NULL);
219380 121974 : visitor.visit(this);
219381 121974 : }
219382 :
219383 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
219384 0 : void SgDotExp::accept (ROSE_VisitorPattern & visitor) {
219385 0 : ROSE_ASSERT(this != NULL);
219386 0 : visitor.visit(this);
219387 0 : }
219388 :
219389 : SgDotExp*
219390 0 : SgDotExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
219391 : {
219392 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
219393 : // This function is currently only supported for the AST used the represent Binary executables.
219394 : if (0 /* isSgAsmNode(this) != NULL */)
219395 : {
219396 : // Support for regex specification.
219397 : std::string prefixCode = "REGEX:";
219398 : addNewAttribute(prefixCode + s,a);
219399 : }
219400 : #endif
219401 :
219402 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
219403 0 : return this;
219404 : }
219405 :
219406 : // *** COMMON CODE SECTION ENDS HERE ***
219407 :
219408 :
219409 : // End of memberFunctionString
219410 : // Start of memberFunctionString
219411 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
219412 :
219413 :
219414 : #if 0
219415 : //! Error checking support
219416 : /*! Verifies the following:
219417 : - working getVariant() member function
219418 : - calls base class's error() member function
219419 : Every class has one of these functions.
219420 : */
219421 : bool
219422 : SgDotExp::error()
219423 : {
219424 : // Put error checking here
219425 :
219426 : ROSE_ASSERT (this != NULL);
219427 : if (getVariant() != RECORD_REF)
219428 : {
219429 : printf ("Error in SgDotExp::error(): SgDotExp object has a %s variant \n",
219430 : Cxx_GrammarTerminalNames[getVariant()].name);
219431 : // printf ("Error in SgDotExp::error() \n");
219432 : ROSE_ABORT();
219433 : }
219434 :
219435 : ROSE_ASSERT (getVariant() == RECORD_REF);
219436 : return SgBinaryOp::error();
219437 : }
219438 : #endif
219439 :
219440 :
219441 :
219442 : // End of memberFunctionString
219443 :
219444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
219445 :
219446 294377 : SgDotExp* isSgDotExp ( SgNode* inputDerivedClassPointer )
219447 : {
219448 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
219449 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
219450 : // So to fix this we return NULL directly when the input is NULL and avoid the
219451 : // dynamic_cast in this case. This is likely a performance improvement as well.
219452 : // return dynamic_cast<SgDotExp*>(inputDerivedClassPointer);
219453 : // Milind Chabbi (8/28/2013): isSgDotExp uses table-driven castability instead of c++ default dynamic_cast
219454 : // this improves the running time performance by 10-20%.
219455 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDotExp*>(inputDerivedClassPointer);
219456 294377 : return IS_SgDotExp_FAST_MACRO(inputDerivedClassPointer);
219457 : }
219458 :
219459 : // DQ (11/8/2003): Added version of functions taking const pointer
219460 0 : const SgDotExp* isSgDotExp ( const SgNode* inputDerivedClassPointer )
219461 : {
219462 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
219463 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
219464 : // So to fix this we return NULL directly when the input is NULL and avoid the
219465 : // dynamic_cast in this case. This is likely a performance improvement as well.
219466 : // return dynamic_cast<const SgDotExp*>(inputDerivedClassPointer);
219467 : // Milind Chabbi (8/28/2013): isSgDotExp uses table-driven castability instead of c++ default dynamic_cast
219468 : // this improves the running time performance by 10-20%.
219469 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDotExp*>(inputDerivedClassPointer);
219470 0 : return IS_SgDotExp_FAST_MACRO(inputDerivedClassPointer);
219471 : }
219472 :
219473 :
219474 :
219475 : /* #line 219476 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219476 :
219477 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
219478 :
219479 : /**
219480 : \brief Generated destructor
219481 :
219482 : This destructor is automatically generated (by ROSETTA). This destructor
219483 : only frees memory of data members associated with the parts of the current IR node which
219484 : are NOT traversed. Those data members that are part of a traversal can be freed using
219485 : a traversal (calling this destructor on all children in a post-order traversal). Such
219486 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
219487 :
219488 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
219489 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
219490 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
219491 :
219492 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
219493 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
219494 : pointers are not yet implemented to call delete on eash pointer in the container.
219495 : (This could be done by derivation from the STL containers to define containers that
219496 : automatically deleted their members.)
219497 :
219498 : */
219499 3314 : SgDotExp::~SgDotExp () {
219500 1657 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
219501 :
219502 :
219503 :
219504 : }
219505 :
219506 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
219507 3314 : }
219508 :
219509 :
219510 : /* #line 219511 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219511 :
219512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
219513 :
219514 : // Generated constructor
219515 192 : SgDotExp::SgDotExp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
219516 192 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
219517 : {
219518 : #ifdef DEBUG
219519 : // printf ("In SgDotExp::SgDotExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
219520 : #endif
219521 : #if 0
219522 : // debugging information!
219523 : printf ("In SgDotExp::SgDotExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
219524 : #endif
219525 :
219526 :
219527 :
219528 : #if 0
219529 : // DQ (7/30/2014): Call a virtual function.
219530 : std::string s = this->class_name();
219531 : #endif
219532 :
219533 : // Test the variant virtual function
219534 : // assert(RECORD_REF == variant());
219535 192 : assert(RECORD_REF == this->variant());
219536 192 : ROSE_ASSERT(RECORD_REF == (int)(this->variantT()));
219537 192 : post_construction_initialization();
219538 :
219539 : // Test the isSgDotExp() function since it has been problematic
219540 192 : assert(isSgDotExp(this) != NULL);
219541 192 : }
219542 :
219543 : // Generated constructor (all data members)
219544 :
219545 : /* #line 219546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219546 :
219547 :
219548 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
219549 :
219550 :
219551 : // ********************************************************
219552 : // member functions common across all array grammar objects
219553 : // ********************************************************
219554 :
219555 :
219556 :
219557 : /* #line 219558 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219558 :
219559 :
219560 :
219561 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
219562 :
219563 : // ********************************************************
219564 : // member functions specific to each node in the grammar
219565 : // ********************************************************
219566 :
219567 :
219568 : /* #line 219569 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219569 :
219570 : // Start of memberFunctionString
219571 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
219572 :
219573 : void
219574 112 : SgDotStarOp::post_construction_initialization()
219575 : {
219576 112 : }
219577 :
219578 :
219579 :
219580 : // End of memberFunctionString
219581 : // Start of memberFunctionString
219582 : /* #line 4844 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
219583 :
219584 :
219585 : SgType*
219586 440 : SgDotStarOp::get_type() const
219587 : {
219588 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
219589 :
219590 : // For the SgDotStarOp, the type is the type of the rhs operand (e.g. "A.*x" where "x" is a member function pointer of the class "A").
219591 :
219592 : // Comment from Jeremiah (7/20/2006)
219593 : // In SOURCE_DOT_STAR_OPERATOR_EXPRESSION's get_type() method, the expression type is computed as the type of the RHS operand.
219594 : // This is most likely a pointer to member type, though, not the type of the underlying member (assuming the types of
219595 : // pointer-to-member expressions are set correctly). The same issue applies to SOURCE_ARROW_STAR_OPERATOR_EXPRESSION.
219596 :
219597 : // printf ("SgDotStarOp::get_type(): p_expression_type has been removed, we have to compute the appropriate type from rhs = %s \n",get_rhs_operand()->class_name().c_str());
219598 :
219599 440 : ROSE_ASSERT(get_lhs_operand() != NULL);
219600 440 : ROSE_ASSERT(get_rhs_operand() != NULL);
219601 :
219602 : #if 0
219603 : printf ("In SgDotStarExp::get_type() \n");
219604 : #endif
219605 :
219606 440 : SgType* someType = get_rhs_operand()->get_type();
219607 :
219608 440 : SgType* returnType = NULL;
219609 440 : keepStripping:
219610 :
219611 : // printf ("SgDotStarOp::get_type(): someType = %s \n",someType->class_name().c_str());
219612 :
219613 440 : ROSE_ASSERT (someType != NULL);
219614 440 : switch(someType->variantT())
219615 : {
219616 : // These cases all have base types and the pointer dereferencing returns the base type
219617 : // But since p_base_type is placed at each of the different SgType IR nodes we have
219618 : // to handle each case separately.
219619 0 : case V_SgPointerType:
219620 0 : {
219621 0 : SgPointerType* pointerType = isSgPointerType(someType);
219622 0 : returnType = pointerType->get_base_type();
219623 0 : break;
219624 : }
219625 : // DQ (7/31/2006): Added a new case so now this code is no longer a clone of what is used in SgPointerDerefExp and SgPntrArrRefExp.
219626 224 : case V_SgPointerMemberType:
219627 224 : {
219628 224 : SgPointerMemberType* pointerMemberType = isSgPointerMemberType(someType);
219629 224 : returnType = pointerMemberType->get_base_type();
219630 224 : break;
219631 : }
219632 0 : case V_SgArrayType:
219633 0 : {
219634 0 : SgArrayType* arrayType = isSgArrayType(someType);
219635 0 : returnType = arrayType->get_base_type();
219636 0 : break;
219637 : }
219638 0 : case V_SgTypedefType:
219639 0 : {
219640 0 : SgTypedefType* typedefType = isSgTypedefType(someType);
219641 0 : someType = typedefType->get_base_type();
219642 0 : goto keepStripping;
219643 : }
219644 0 : case V_SgReferenceType:
219645 0 : {
219646 0 : SgReferenceType* referenceType = isSgReferenceType(someType);
219647 0 : someType = referenceType->get_base_type();
219648 0 : goto keepStripping;
219649 : }
219650 0 : case V_SgModifierType:
219651 0 : {
219652 0 : SgModifierType* modifierType = isSgModifierType(someType);
219653 0 : someType = modifierType->get_base_type();
219654 0 : goto keepStripping;
219655 : }
219656 : default:
219657 : {
219658 : returnType = someType;
219659 : }
219660 : }
219661 :
219662 440 : ROSE_ASSERT(returnType != NULL);
219663 :
219664 : // printf ("SgDotStarOp::get_type(): get the type of the rhs operand returnType = %s \n",returnType->class_name().c_str());
219665 :
219666 440 : return returnType;
219667 : }
219668 :
219669 :
219670 :
219671 : // End of memberFunctionString
219672 : // Start of memberFunctionString
219673 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
219674 :
219675 : // *** COMMON CODE SECTION BEGINS HERE ***
219676 :
219677 : #if 0
219678 : int
219679 : SgDotStarOp::getVariant() const
219680 : {
219681 : // This function is used in ROSE while "variant()" is used in SAGE
219682 : assert(this != NULL);
219683 : return variant();
219684 : }
219685 : #endif
219686 :
219687 : // This function is used in ROSE in treeTraversal code
219688 : // eventually replaces getVariant() and variant()
219689 : // though after variant() has been removed for a while we will
219690 : // want to change the name of variantT() back to variant()
219691 : // (since the "T" was ment to stand for temporary).
219692 : // When this happens the variantT() will be depricated.
219693 : VariantT
219694 25800 : SgDotStarOp::variantT() const
219695 : {
219696 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
219697 25800 : ROSE_ASSERT(this != NULL);
219698 25800 : return V_SgDotStarOp;
219699 : }
219700 :
219701 : #if 0
219702 : int
219703 : SgDotStarOp::variant() const
219704 : {
219705 : // This function is used in SAGE
219706 : ROSE_ASSERT(this != NULL);
219707 : return DOTSTAR_OP;
219708 : }
219709 : #endif
219710 :
219711 : ROSE_DLL_API const char*
219712 0 : SgDotStarOp::sage_class_name() const
219713 : {
219714 0 : ROSE_ASSERT(this != NULL);
219715 0 : return "SgDotStarOp";
219716 : }
219717 :
219718 : std::string
219719 92 : SgDotStarOp::class_name() const
219720 : {
219721 92 : ROSE_ASSERT(this != NULL);
219722 92 : return "SgDotStarOp";
219723 : }
219724 :
219725 : // DQ (11/26/2005): Support for visitor pattern mechanims
219726 : // (inferior to ROSE traversal mechanism, experimental).
219727 : void
219728 1644 : SgDotStarOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
219729 : {
219730 1644 : ROSE_ASSERT(this != NULL);
219731 1644 : visitor.visit(this);
219732 1644 : }
219733 :
219734 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
219735 0 : void SgDotStarOp::accept (ROSE_VisitorPattern & visitor) {
219736 0 : ROSE_ASSERT(this != NULL);
219737 0 : visitor.visit(this);
219738 0 : }
219739 :
219740 : SgDotStarOp*
219741 0 : SgDotStarOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
219742 : {
219743 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
219744 : // This function is currently only supported for the AST used the represent Binary executables.
219745 : if (0 /* isSgAsmNode(this) != NULL */)
219746 : {
219747 : // Support for regex specification.
219748 : std::string prefixCode = "REGEX:";
219749 : addNewAttribute(prefixCode + s,a);
219750 : }
219751 : #endif
219752 :
219753 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
219754 0 : return this;
219755 : }
219756 :
219757 : // *** COMMON CODE SECTION ENDS HERE ***
219758 :
219759 :
219760 : // End of memberFunctionString
219761 : // Start of memberFunctionString
219762 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
219763 :
219764 :
219765 : #if 0
219766 : //! Error checking support
219767 : /*! Verifies the following:
219768 : - working getVariant() member function
219769 : - calls base class's error() member function
219770 : Every class has one of these functions.
219771 : */
219772 : bool
219773 : SgDotStarOp::error()
219774 : {
219775 : // Put error checking here
219776 :
219777 : ROSE_ASSERT (this != NULL);
219778 : if (getVariant() != DOTSTAR_OP)
219779 : {
219780 : printf ("Error in SgDotStarOp::error(): SgDotStarOp object has a %s variant \n",
219781 : Cxx_GrammarTerminalNames[getVariant()].name);
219782 : // printf ("Error in SgDotStarOp::error() \n");
219783 : ROSE_ABORT();
219784 : }
219785 :
219786 : ROSE_ASSERT (getVariant() == DOTSTAR_OP);
219787 : return SgBinaryOp::error();
219788 : }
219789 : #endif
219790 :
219791 :
219792 :
219793 : // End of memberFunctionString
219794 :
219795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
219796 :
219797 112 : SgDotStarOp* isSgDotStarOp ( SgNode* inputDerivedClassPointer )
219798 : {
219799 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
219800 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
219801 : // So to fix this we return NULL directly when the input is NULL and avoid the
219802 : // dynamic_cast in this case. This is likely a performance improvement as well.
219803 : // return dynamic_cast<SgDotStarOp*>(inputDerivedClassPointer);
219804 : // Milind Chabbi (8/28/2013): isSgDotStarOp uses table-driven castability instead of c++ default dynamic_cast
219805 : // this improves the running time performance by 10-20%.
219806 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDotStarOp*>(inputDerivedClassPointer);
219807 112 : return IS_SgDotStarOp_FAST_MACRO(inputDerivedClassPointer);
219808 : }
219809 :
219810 : // DQ (11/8/2003): Added version of functions taking const pointer
219811 0 : const SgDotStarOp* isSgDotStarOp ( const SgNode* inputDerivedClassPointer )
219812 : {
219813 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
219814 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
219815 : // So to fix this we return NULL directly when the input is NULL and avoid the
219816 : // dynamic_cast in this case. This is likely a performance improvement as well.
219817 : // return dynamic_cast<const SgDotStarOp*>(inputDerivedClassPointer);
219818 : // Milind Chabbi (8/28/2013): isSgDotStarOp uses table-driven castability instead of c++ default dynamic_cast
219819 : // this improves the running time performance by 10-20%.
219820 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDotStarOp*>(inputDerivedClassPointer);
219821 0 : return IS_SgDotStarOp_FAST_MACRO(inputDerivedClassPointer);
219822 : }
219823 :
219824 :
219825 :
219826 : /* #line 219827 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219827 :
219828 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
219829 :
219830 : /**
219831 : \brief Generated destructor
219832 :
219833 : This destructor is automatically generated (by ROSETTA). This destructor
219834 : only frees memory of data members associated with the parts of the current IR node which
219835 : are NOT traversed. Those data members that are part of a traversal can be freed using
219836 : a traversal (calling this destructor on all children in a post-order traversal). Such
219837 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
219838 :
219839 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
219840 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
219841 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
219842 :
219843 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
219844 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
219845 : pointers are not yet implemented to call delete on eash pointer in the container.
219846 : (This could be done by derivation from the STL containers to define containers that
219847 : automatically deleted their members.)
219848 :
219849 : */
219850 48 : SgDotStarOp::~SgDotStarOp () {
219851 24 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
219852 :
219853 :
219854 :
219855 : }
219856 :
219857 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
219858 48 : }
219859 :
219860 :
219861 : /* #line 219862 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219862 :
219863 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
219864 :
219865 : // Generated constructor
219866 0 : SgDotStarOp::SgDotStarOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
219867 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
219868 : {
219869 : #ifdef DEBUG
219870 : // printf ("In SgDotStarOp::SgDotStarOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
219871 : #endif
219872 : #if 0
219873 : // debugging information!
219874 : printf ("In SgDotStarOp::SgDotStarOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
219875 : #endif
219876 :
219877 :
219878 :
219879 : #if 0
219880 : // DQ (7/30/2014): Call a virtual function.
219881 : std::string s = this->class_name();
219882 : #endif
219883 :
219884 : // Test the variant virtual function
219885 : // assert(DOTSTAR_OP == variant());
219886 0 : assert(DOTSTAR_OP == this->variant());
219887 0 : ROSE_ASSERT(DOTSTAR_OP == (int)(this->variantT()));
219888 0 : post_construction_initialization();
219889 :
219890 : // Test the isSgDotStarOp() function since it has been problematic
219891 0 : assert(isSgDotStarOp(this) != NULL);
219892 0 : }
219893 :
219894 : // Generated constructor (all data members)
219895 :
219896 : /* #line 219897 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219897 :
219898 :
219899 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
219900 :
219901 :
219902 : // ********************************************************
219903 : // member functions common across all array grammar objects
219904 : // ********************************************************
219905 :
219906 :
219907 :
219908 : /* #line 219909 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219909 :
219910 :
219911 :
219912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
219913 :
219914 : // ********************************************************
219915 : // member functions specific to each node in the grammar
219916 : // ********************************************************
219917 :
219918 :
219919 : /* #line 219920 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
219920 :
219921 : // Start of memberFunctionString
219922 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
219923 :
219924 : void
219925 32 : SgArrowStarOp::post_construction_initialization()
219926 : {
219927 32 : }
219928 :
219929 :
219930 :
219931 : // End of memberFunctionString
219932 : // Start of memberFunctionString
219933 : /* #line 4933 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
219934 :
219935 :
219936 : SgType*
219937 224 : SgArrowStarOp::get_type() const
219938 : {
219939 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
219940 :
219941 : // For the SgArrowStarOp, the type is the type of the rhs operand (e.g. "A->*x" where "x" is a member function pointer of the pointer to the class "A").
219942 :
219943 : // printf ("SgArrowStarOp::get_type(): p_expression_type has been removed, we have to compute the appropriate type from rhs = %s \n",get_rhs_operand()->class_name().c_str());
219944 :
219945 224 : ROSE_ASSERT(get_lhs_operand() != NULL);
219946 224 : ROSE_ASSERT(get_rhs_operand() != NULL);
219947 :
219948 : #if 0
219949 : printf ("In SgArrowStarExp::get_type() \n");
219950 : #endif
219951 :
219952 224 : SgType* someType = get_rhs_operand()->get_type();
219953 :
219954 224 : SgType* returnType = NULL;
219955 224 : keepStripping:
219956 224 : ROSE_ASSERT (someType != NULL);
219957 224 : switch(someType->variantT())
219958 : {
219959 : // These cases all have base types and the pointer dereferencing returns the base type
219960 : // But since p_base_type is placed at each of the different SgType IR nodes we have
219961 : // to handle each case separately.
219962 0 : case V_SgPointerType:
219963 0 : {
219964 0 : SgPointerType* pointerType = isSgPointerType(someType);
219965 0 : returnType = pointerType->get_base_type();
219966 0 : break;
219967 : }
219968 : // DQ (7/31/2006): Added a new case so now this code is no longer a clone of what is used in SgPointerDerefExp and SgPntrArrRefExp.
219969 224 : case V_SgPointerMemberType:
219970 224 : {
219971 224 : SgPointerMemberType* pointerMemberType = isSgPointerMemberType(someType);
219972 224 : returnType = pointerMemberType->get_base_type();
219973 224 : break;
219974 : }
219975 0 : case V_SgArrayType:
219976 0 : {
219977 0 : SgArrayType* arrayType = isSgArrayType(someType);
219978 0 : returnType = arrayType->get_base_type();
219979 0 : break;
219980 : }
219981 0 : case V_SgTypedefType:
219982 0 : {
219983 0 : SgTypedefType* typedefType = isSgTypedefType(someType);
219984 0 : someType = typedefType->get_base_type();
219985 0 : goto keepStripping;
219986 : }
219987 0 : case V_SgReferenceType:
219988 0 : {
219989 0 : SgReferenceType* referenceType = isSgReferenceType(someType);
219990 0 : someType = referenceType->get_base_type();
219991 0 : goto keepStripping;
219992 : }
219993 0 : case V_SgModifierType:
219994 0 : {
219995 0 : SgModifierType* modifierType = isSgModifierType(someType);
219996 0 : someType = modifierType->get_base_type();
219997 0 : goto keepStripping;
219998 : }
219999 : #if 0
220000 : // DQ (1/19/2017): Added support for SgTemplateType. However we might want to handle this similarly to SgDotStarExp::get_type() (above)
220001 : case V_SgTemplateType:
220002 : {
220003 : #if 1
220004 : printf ("In SgArrowStarOp::get_type(): Found SgTemplateType \n");
220005 : #endif
220006 : SgTemplateType* templateType = isSgTemplateType(someType);
220007 : someType = templateType->get_base_type();
220008 : goto keepStripping;
220009 : }
220010 : #endif
220011 :
220012 0 : default:
220013 0 : {
220014 : #if defined(ROSE_USE_EDG_VERSION_4) || defined(ROSE_USE_CLANG_FRONTEND)
220015 : // DQ (1/19/2017): I think we want to fix this similarly to the case of SgDotStarExp::get_type() (above)
220016 : // printf ("Using default case in SgArrowStarOp::get_type() differently with EDG version 4.x someType = %s \n",someType->class_name().c_str());
220017 : returnType = someType;
220018 : #else
220019 0 : printf ("Error: default reached in In SgArrowStarOp::get_type() someType = %s \n",someType->class_name().c_str());
220020 0 : ROSE_ASSERT(false);
220021 : #endif
220022 : }
220023 : }
220024 :
220025 224 : ROSE_ASSERT(returnType != NULL);
220026 :
220027 : // printf ("SgArrowStarOp::get_type(): get the type of the rhs operand returnType = %s \n",returnType->class_name().c_str());
220028 :
220029 224 : return returnType;
220030 : }
220031 :
220032 :
220033 :
220034 : // End of memberFunctionString
220035 : // Start of memberFunctionString
220036 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
220037 :
220038 : // *** COMMON CODE SECTION BEGINS HERE ***
220039 :
220040 : #if 0
220041 : int
220042 : SgArrowStarOp::getVariant() const
220043 : {
220044 : // This function is used in ROSE while "variant()" is used in SAGE
220045 : assert(this != NULL);
220046 : return variant();
220047 : }
220048 : #endif
220049 :
220050 : // This function is used in ROSE in treeTraversal code
220051 : // eventually replaces getVariant() and variant()
220052 : // though after variant() has been removed for a while we will
220053 : // want to change the name of variantT() back to variant()
220054 : // (since the "T" was ment to stand for temporary).
220055 : // When this happens the variantT() will be depricated.
220056 : VariantT
220057 6196 : SgArrowStarOp::variantT() const
220058 : {
220059 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
220060 6196 : ROSE_ASSERT(this != NULL);
220061 6196 : return V_SgArrowStarOp;
220062 : }
220063 :
220064 : #if 0
220065 : int
220066 : SgArrowStarOp::variant() const
220067 : {
220068 : // This function is used in SAGE
220069 : ROSE_ASSERT(this != NULL);
220070 : return ARROWSTAR_OP;
220071 : }
220072 : #endif
220073 :
220074 : ROSE_DLL_API const char*
220075 0 : SgArrowStarOp::sage_class_name() const
220076 : {
220077 0 : ROSE_ASSERT(this != NULL);
220078 0 : return "SgArrowStarOp";
220079 : }
220080 :
220081 : std::string
220082 28 : SgArrowStarOp::class_name() const
220083 : {
220084 28 : ROSE_ASSERT(this != NULL);
220085 28 : return "SgArrowStarOp";
220086 : }
220087 :
220088 : // DQ (11/26/2005): Support for visitor pattern mechanims
220089 : // (inferior to ROSE traversal mechanism, experimental).
220090 : void
220091 548 : SgArrowStarOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
220092 : {
220093 548 : ROSE_ASSERT(this != NULL);
220094 548 : visitor.visit(this);
220095 548 : }
220096 :
220097 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
220098 0 : void SgArrowStarOp::accept (ROSE_VisitorPattern & visitor) {
220099 0 : ROSE_ASSERT(this != NULL);
220100 0 : visitor.visit(this);
220101 0 : }
220102 :
220103 : SgArrowStarOp*
220104 0 : SgArrowStarOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
220105 : {
220106 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
220107 : // This function is currently only supported for the AST used the represent Binary executables.
220108 : if (0 /* isSgAsmNode(this) != NULL */)
220109 : {
220110 : // Support for regex specification.
220111 : std::string prefixCode = "REGEX:";
220112 : addNewAttribute(prefixCode + s,a);
220113 : }
220114 : #endif
220115 :
220116 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
220117 0 : return this;
220118 : }
220119 :
220120 : // *** COMMON CODE SECTION ENDS HERE ***
220121 :
220122 :
220123 : // End of memberFunctionString
220124 : // Start of memberFunctionString
220125 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
220126 :
220127 :
220128 : #if 0
220129 : //! Error checking support
220130 : /*! Verifies the following:
220131 : - working getVariant() member function
220132 : - calls base class's error() member function
220133 : Every class has one of these functions.
220134 : */
220135 : bool
220136 : SgArrowStarOp::error()
220137 : {
220138 : // Put error checking here
220139 :
220140 : ROSE_ASSERT (this != NULL);
220141 : if (getVariant() != ARROWSTAR_OP)
220142 : {
220143 : printf ("Error in SgArrowStarOp::error(): SgArrowStarOp object has a %s variant \n",
220144 : Cxx_GrammarTerminalNames[getVariant()].name);
220145 : // printf ("Error in SgArrowStarOp::error() \n");
220146 : ROSE_ABORT();
220147 : }
220148 :
220149 : ROSE_ASSERT (getVariant() == ARROWSTAR_OP);
220150 : return SgBinaryOp::error();
220151 : }
220152 : #endif
220153 :
220154 :
220155 :
220156 : // End of memberFunctionString
220157 :
220158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
220159 :
220160 32 : SgArrowStarOp* isSgArrowStarOp ( SgNode* inputDerivedClassPointer )
220161 : {
220162 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
220163 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
220164 : // So to fix this we return NULL directly when the input is NULL and avoid the
220165 : // dynamic_cast in this case. This is likely a performance improvement as well.
220166 : // return dynamic_cast<SgArrowStarOp*>(inputDerivedClassPointer);
220167 : // Milind Chabbi (8/28/2013): isSgArrowStarOp uses table-driven castability instead of c++ default dynamic_cast
220168 : // this improves the running time performance by 10-20%.
220169 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgArrowStarOp*>(inputDerivedClassPointer);
220170 32 : return IS_SgArrowStarOp_FAST_MACRO(inputDerivedClassPointer);
220171 : }
220172 :
220173 : // DQ (11/8/2003): Added version of functions taking const pointer
220174 0 : const SgArrowStarOp* isSgArrowStarOp ( const SgNode* inputDerivedClassPointer )
220175 : {
220176 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
220177 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
220178 : // So to fix this we return NULL directly when the input is NULL and avoid the
220179 : // dynamic_cast in this case. This is likely a performance improvement as well.
220180 : // return dynamic_cast<const SgArrowStarOp*>(inputDerivedClassPointer);
220181 : // Milind Chabbi (8/28/2013): isSgArrowStarOp uses table-driven castability instead of c++ default dynamic_cast
220182 : // this improves the running time performance by 10-20%.
220183 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgArrowStarOp*>(inputDerivedClassPointer);
220184 0 : return IS_SgArrowStarOp_FAST_MACRO(inputDerivedClassPointer);
220185 : }
220186 :
220187 :
220188 :
220189 : /* #line 220190 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220190 :
220191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
220192 :
220193 : /**
220194 : \brief Generated destructor
220195 :
220196 : This destructor is automatically generated (by ROSETTA). This destructor
220197 : only frees memory of data members associated with the parts of the current IR node which
220198 : are NOT traversed. Those data members that are part of a traversal can be freed using
220199 : a traversal (calling this destructor on all children in a post-order traversal). Such
220200 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
220201 :
220202 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
220203 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
220204 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
220205 :
220206 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
220207 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
220208 : pointers are not yet implemented to call delete on eash pointer in the container.
220209 : (This could be done by derivation from the STL containers to define containers that
220210 : automatically deleted their members.)
220211 :
220212 : */
220213 16 : SgArrowStarOp::~SgArrowStarOp () {
220214 8 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
220215 :
220216 :
220217 :
220218 : }
220219 :
220220 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
220221 16 : }
220222 :
220223 :
220224 : /* #line 220225 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220225 :
220226 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
220227 :
220228 : // Generated constructor
220229 0 : SgArrowStarOp::SgArrowStarOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
220230 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
220231 : {
220232 : #ifdef DEBUG
220233 : // printf ("In SgArrowStarOp::SgArrowStarOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
220234 : #endif
220235 : #if 0
220236 : // debugging information!
220237 : printf ("In SgArrowStarOp::SgArrowStarOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
220238 : #endif
220239 :
220240 :
220241 :
220242 : #if 0
220243 : // DQ (7/30/2014): Call a virtual function.
220244 : std::string s = this->class_name();
220245 : #endif
220246 :
220247 : // Test the variant virtual function
220248 : // assert(ARROWSTAR_OP == variant());
220249 0 : assert(ARROWSTAR_OP == this->variant());
220250 0 : ROSE_ASSERT(ARROWSTAR_OP == (int)(this->variantT()));
220251 0 : post_construction_initialization();
220252 :
220253 : // Test the isSgArrowStarOp() function since it has been problematic
220254 0 : assert(isSgArrowStarOp(this) != NULL);
220255 0 : }
220256 :
220257 : // Generated constructor (all data members)
220258 :
220259 : /* #line 220260 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220260 :
220261 :
220262 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
220263 :
220264 :
220265 : // ********************************************************
220266 : // member functions common across all array grammar objects
220267 : // ********************************************************
220268 :
220269 :
220270 :
220271 : /* #line 220272 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220272 :
220273 :
220274 :
220275 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
220276 :
220277 : // ********************************************************
220278 : // member functions specific to each node in the grammar
220279 : // ********************************************************
220280 :
220281 :
220282 : /* #line 220283 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220283 :
220284 : // Start of memberFunctionString
220285 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220286 :
220287 : void
220288 2721 : SgEqualityOp::post_construction_initialization()
220289 : {
220290 2721 : }
220291 :
220292 :
220293 :
220294 : // End of memberFunctionString
220295 : // Start of memberFunctionString
220296 : /* #line 5055 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220297 :
220298 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220299 :
220300 :
220301 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
220302 : SgType*
220303 2599 : SgEqualityOp::get_type() const
220304 : {
220305 : #if 0
220306 : printf ("In SgEqualityOp::get_type() \n");
220307 : #endif
220308 :
220309 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
220310 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
220311 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
220312 2599 : SgType* returnType = (SageInterface::is_C_language() == true) ?
220313 152 : static_cast<SgType*>(SgTypeInt::createType()) :
220314 2447 : static_cast<SgType*>(SgTypeBool::createType());
220315 2599 : ROSE_ASSERT(returnType != NULL);
220316 2599 : return returnType;
220317 : }
220318 :
220319 :
220320 :
220321 :
220322 : // End of memberFunctionString
220323 : // Start of memberFunctionString
220324 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
220325 :
220326 : // *** COMMON CODE SECTION BEGINS HERE ***
220327 :
220328 : #if 0
220329 : int
220330 : SgEqualityOp::getVariant() const
220331 : {
220332 : // This function is used in ROSE while "variant()" is used in SAGE
220333 : assert(this != NULL);
220334 : return variant();
220335 : }
220336 : #endif
220337 :
220338 : // This function is used in ROSE in treeTraversal code
220339 : // eventually replaces getVariant() and variant()
220340 : // though after variant() has been removed for a while we will
220341 : // want to change the name of variantT() back to variant()
220342 : // (since the "T" was ment to stand for temporary).
220343 : // When this happens the variantT() will be depricated.
220344 : VariantT
220345 997044 : SgEqualityOp::variantT() const
220346 : {
220347 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
220348 997044 : ROSE_ASSERT(this != NULL);
220349 997044 : return V_SgEqualityOp;
220350 : }
220351 :
220352 : #if 0
220353 : int
220354 : SgEqualityOp::variant() const
220355 : {
220356 : // This function is used in SAGE
220357 : ROSE_ASSERT(this != NULL);
220358 : return EQ_OP;
220359 : }
220360 : #endif
220361 :
220362 : ROSE_DLL_API const char*
220363 133 : SgEqualityOp::sage_class_name() const
220364 : {
220365 133 : ROSE_ASSERT(this != NULL);
220366 133 : return "SgEqualityOp";
220367 : }
220368 :
220369 : std::string
220370 2367 : SgEqualityOp::class_name() const
220371 : {
220372 2367 : ROSE_ASSERT(this != NULL);
220373 2367 : return "SgEqualityOp";
220374 : }
220375 :
220376 : // DQ (11/26/2005): Support for visitor pattern mechanims
220377 : // (inferior to ROSE traversal mechanism, experimental).
220378 : void
220379 35174 : SgEqualityOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
220380 : {
220381 35174 : ROSE_ASSERT(this != NULL);
220382 35174 : visitor.visit(this);
220383 35174 : }
220384 :
220385 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
220386 0 : void SgEqualityOp::accept (ROSE_VisitorPattern & visitor) {
220387 0 : ROSE_ASSERT(this != NULL);
220388 0 : visitor.visit(this);
220389 0 : }
220390 :
220391 : SgEqualityOp*
220392 0 : SgEqualityOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
220393 : {
220394 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
220395 : // This function is currently only supported for the AST used the represent Binary executables.
220396 : if (0 /* isSgAsmNode(this) != NULL */)
220397 : {
220398 : // Support for regex specification.
220399 : std::string prefixCode = "REGEX:";
220400 : addNewAttribute(prefixCode + s,a);
220401 : }
220402 : #endif
220403 :
220404 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
220405 0 : return this;
220406 : }
220407 :
220408 : // *** COMMON CODE SECTION ENDS HERE ***
220409 :
220410 :
220411 : // End of memberFunctionString
220412 : // Start of memberFunctionString
220413 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
220414 :
220415 :
220416 : #if 0
220417 : //! Error checking support
220418 : /*! Verifies the following:
220419 : - working getVariant() member function
220420 : - calls base class's error() member function
220421 : Every class has one of these functions.
220422 : */
220423 : bool
220424 : SgEqualityOp::error()
220425 : {
220426 : // Put error checking here
220427 :
220428 : ROSE_ASSERT (this != NULL);
220429 : if (getVariant() != EQ_OP)
220430 : {
220431 : printf ("Error in SgEqualityOp::error(): SgEqualityOp object has a %s variant \n",
220432 : Cxx_GrammarTerminalNames[getVariant()].name);
220433 : // printf ("Error in SgEqualityOp::error() \n");
220434 : ROSE_ABORT();
220435 : }
220436 :
220437 : ROSE_ASSERT (getVariant() == EQ_OP);
220438 : return SgBinaryOp::error();
220439 : }
220440 : #endif
220441 :
220442 :
220443 :
220444 : // End of memberFunctionString
220445 :
220446 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
220447 :
220448 2721 : SgEqualityOp* isSgEqualityOp ( SgNode* inputDerivedClassPointer )
220449 : {
220450 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
220451 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
220452 : // So to fix this we return NULL directly when the input is NULL and avoid the
220453 : // dynamic_cast in this case. This is likely a performance improvement as well.
220454 : // return dynamic_cast<SgEqualityOp*>(inputDerivedClassPointer);
220455 : // Milind Chabbi (8/28/2013): isSgEqualityOp uses table-driven castability instead of c++ default dynamic_cast
220456 : // this improves the running time performance by 10-20%.
220457 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEqualityOp*>(inputDerivedClassPointer);
220458 2721 : return IS_SgEqualityOp_FAST_MACRO(inputDerivedClassPointer);
220459 : }
220460 :
220461 : // DQ (11/8/2003): Added version of functions taking const pointer
220462 0 : const SgEqualityOp* isSgEqualityOp ( const SgNode* inputDerivedClassPointer )
220463 : {
220464 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
220465 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
220466 : // So to fix this we return NULL directly when the input is NULL and avoid the
220467 : // dynamic_cast in this case. This is likely a performance improvement as well.
220468 : // return dynamic_cast<const SgEqualityOp*>(inputDerivedClassPointer);
220469 : // Milind Chabbi (8/28/2013): isSgEqualityOp uses table-driven castability instead of c++ default dynamic_cast
220470 : // this improves the running time performance by 10-20%.
220471 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEqualityOp*>(inputDerivedClassPointer);
220472 0 : return IS_SgEqualityOp_FAST_MACRO(inputDerivedClassPointer);
220473 : }
220474 :
220475 :
220476 :
220477 : /* #line 220478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220478 :
220479 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
220480 :
220481 : /**
220482 : \brief Generated destructor
220483 :
220484 : This destructor is automatically generated (by ROSETTA). This destructor
220485 : only frees memory of data members associated with the parts of the current IR node which
220486 : are NOT traversed. Those data members that are part of a traversal can be freed using
220487 : a traversal (calling this destructor on all children in a post-order traversal). Such
220488 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
220489 :
220490 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
220491 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
220492 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
220493 :
220494 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
220495 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
220496 : pointers are not yet implemented to call delete on eash pointer in the container.
220497 : (This could be done by derivation from the STL containers to define containers that
220498 : automatically deleted their members.)
220499 :
220500 : */
220501 1056 : SgEqualityOp::~SgEqualityOp () {
220502 528 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
220503 :
220504 :
220505 :
220506 : }
220507 :
220508 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
220509 1056 : }
220510 :
220511 :
220512 : /* #line 220513 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220513 :
220514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
220515 :
220516 : // Generated constructor
220517 374 : SgEqualityOp::SgEqualityOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
220518 374 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
220519 : {
220520 : #ifdef DEBUG
220521 : // printf ("In SgEqualityOp::SgEqualityOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
220522 : #endif
220523 : #if 0
220524 : // debugging information!
220525 : printf ("In SgEqualityOp::SgEqualityOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
220526 : #endif
220527 :
220528 :
220529 :
220530 : #if 0
220531 : // DQ (7/30/2014): Call a virtual function.
220532 : std::string s = this->class_name();
220533 : #endif
220534 :
220535 : // Test the variant virtual function
220536 : // assert(EQ_OP == variant());
220537 374 : assert(EQ_OP == this->variant());
220538 374 : ROSE_ASSERT(EQ_OP == (int)(this->variantT()));
220539 374 : post_construction_initialization();
220540 :
220541 : // Test the isSgEqualityOp() function since it has been problematic
220542 374 : assert(isSgEqualityOp(this) != NULL);
220543 374 : }
220544 :
220545 : // Generated constructor (all data members)
220546 :
220547 : /* #line 220548 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220548 :
220549 :
220550 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
220551 :
220552 :
220553 : // ********************************************************
220554 : // member functions common across all array grammar objects
220555 : // ********************************************************
220556 :
220557 :
220558 :
220559 : /* #line 220560 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220560 :
220561 :
220562 :
220563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
220564 :
220565 : // ********************************************************
220566 : // member functions specific to each node in the grammar
220567 : // ********************************************************
220568 :
220569 :
220570 : /* #line 220571 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220571 :
220572 : // Start of memberFunctionString
220573 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220574 :
220575 : void
220576 2724 : SgLessThanOp::post_construction_initialization()
220577 : {
220578 2724 : }
220579 :
220580 :
220581 :
220582 : // End of memberFunctionString
220583 : // Start of memberFunctionString
220584 : /* #line 5059 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220585 :
220586 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220587 :
220588 :
220589 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
220590 : SgType*
220591 1512 : SgLessThanOp::get_type() const
220592 : {
220593 : #if 0
220594 : printf ("In SgLessThanOp::get_type() \n");
220595 : #endif
220596 :
220597 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
220598 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
220599 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
220600 1512 : SgType* returnType = (SageInterface::is_C_language() == true) ?
220601 300 : static_cast<SgType*>(SgTypeInt::createType()) :
220602 1212 : static_cast<SgType*>(SgTypeBool::createType());
220603 1512 : ROSE_ASSERT(returnType != NULL);
220604 1512 : return returnType;
220605 : }
220606 :
220607 :
220608 :
220609 :
220610 : // End of memberFunctionString
220611 : // Start of memberFunctionString
220612 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
220613 :
220614 : // *** COMMON CODE SECTION BEGINS HERE ***
220615 :
220616 : #if 0
220617 : int
220618 : SgLessThanOp::getVariant() const
220619 : {
220620 : // This function is used in ROSE while "variant()" is used in SAGE
220621 : assert(this != NULL);
220622 : return variant();
220623 : }
220624 : #endif
220625 :
220626 : // This function is used in ROSE in treeTraversal code
220627 : // eventually replaces getVariant() and variant()
220628 : // though after variant() has been removed for a while we will
220629 : // want to change the name of variantT() back to variant()
220630 : // (since the "T" was ment to stand for temporary).
220631 : // When this happens the variantT() will be depricated.
220632 : VariantT
220633 592250 : SgLessThanOp::variantT() const
220634 : {
220635 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
220636 592250 : ROSE_ASSERT(this != NULL);
220637 592250 : return V_SgLessThanOp;
220638 : }
220639 :
220640 : #if 0
220641 : int
220642 : SgLessThanOp::variant() const
220643 : {
220644 : // This function is used in SAGE
220645 : ROSE_ASSERT(this != NULL);
220646 : return LT_OP;
220647 : }
220648 : #endif
220649 :
220650 : ROSE_DLL_API const char*
220651 72 : SgLessThanOp::sage_class_name() const
220652 : {
220653 72 : ROSE_ASSERT(this != NULL);
220654 72 : return "SgLessThanOp";
220655 : }
220656 :
220657 : std::string
220658 1614 : SgLessThanOp::class_name() const
220659 : {
220660 1614 : ROSE_ASSERT(this != NULL);
220661 1614 : return "SgLessThanOp";
220662 : }
220663 :
220664 : // DQ (11/26/2005): Support for visitor pattern mechanims
220665 : // (inferior to ROSE traversal mechanism, experimental).
220666 : void
220667 19162 : SgLessThanOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
220668 : {
220669 19162 : ROSE_ASSERT(this != NULL);
220670 19162 : visitor.visit(this);
220671 19162 : }
220672 :
220673 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
220674 0 : void SgLessThanOp::accept (ROSE_VisitorPattern & visitor) {
220675 0 : ROSE_ASSERT(this != NULL);
220676 0 : visitor.visit(this);
220677 0 : }
220678 :
220679 : SgLessThanOp*
220680 0 : SgLessThanOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
220681 : {
220682 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
220683 : // This function is currently only supported for the AST used the represent Binary executables.
220684 : if (0 /* isSgAsmNode(this) != NULL */)
220685 : {
220686 : // Support for regex specification.
220687 : std::string prefixCode = "REGEX:";
220688 : addNewAttribute(prefixCode + s,a);
220689 : }
220690 : #endif
220691 :
220692 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
220693 0 : return this;
220694 : }
220695 :
220696 : // *** COMMON CODE SECTION ENDS HERE ***
220697 :
220698 :
220699 : // End of memberFunctionString
220700 : // Start of memberFunctionString
220701 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
220702 :
220703 :
220704 : #if 0
220705 : //! Error checking support
220706 : /*! Verifies the following:
220707 : - working getVariant() member function
220708 : - calls base class's error() member function
220709 : Every class has one of these functions.
220710 : */
220711 : bool
220712 : SgLessThanOp::error()
220713 : {
220714 : // Put error checking here
220715 :
220716 : ROSE_ASSERT (this != NULL);
220717 : if (getVariant() != LT_OP)
220718 : {
220719 : printf ("Error in SgLessThanOp::error(): SgLessThanOp object has a %s variant \n",
220720 : Cxx_GrammarTerminalNames[getVariant()].name);
220721 : // printf ("Error in SgLessThanOp::error() \n");
220722 : ROSE_ABORT();
220723 : }
220724 :
220725 : ROSE_ASSERT (getVariant() == LT_OP);
220726 : return SgBinaryOp::error();
220727 : }
220728 : #endif
220729 :
220730 :
220731 :
220732 : // End of memberFunctionString
220733 :
220734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
220735 :
220736 2724 : SgLessThanOp* isSgLessThanOp ( SgNode* inputDerivedClassPointer )
220737 : {
220738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
220739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
220740 : // So to fix this we return NULL directly when the input is NULL and avoid the
220741 : // dynamic_cast in this case. This is likely a performance improvement as well.
220742 : // return dynamic_cast<SgLessThanOp*>(inputDerivedClassPointer);
220743 : // Milind Chabbi (8/28/2013): isSgLessThanOp uses table-driven castability instead of c++ default dynamic_cast
220744 : // this improves the running time performance by 10-20%.
220745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLessThanOp*>(inputDerivedClassPointer);
220746 2724 : return IS_SgLessThanOp_FAST_MACRO(inputDerivedClassPointer);
220747 : }
220748 :
220749 : // DQ (11/8/2003): Added version of functions taking const pointer
220750 0 : const SgLessThanOp* isSgLessThanOp ( const SgNode* inputDerivedClassPointer )
220751 : {
220752 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
220753 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
220754 : // So to fix this we return NULL directly when the input is NULL and avoid the
220755 : // dynamic_cast in this case. This is likely a performance improvement as well.
220756 : // return dynamic_cast<const SgLessThanOp*>(inputDerivedClassPointer);
220757 : // Milind Chabbi (8/28/2013): isSgLessThanOp uses table-driven castability instead of c++ default dynamic_cast
220758 : // this improves the running time performance by 10-20%.
220759 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLessThanOp*>(inputDerivedClassPointer);
220760 0 : return IS_SgLessThanOp_FAST_MACRO(inputDerivedClassPointer);
220761 : }
220762 :
220763 :
220764 :
220765 : /* #line 220766 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220766 :
220767 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
220768 :
220769 : /**
220770 : \brief Generated destructor
220771 :
220772 : This destructor is automatically generated (by ROSETTA). This destructor
220773 : only frees memory of data members associated with the parts of the current IR node which
220774 : are NOT traversed. Those data members that are part of a traversal can be freed using
220775 : a traversal (calling this destructor on all children in a post-order traversal). Such
220776 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
220777 :
220778 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
220779 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
220780 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
220781 :
220782 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
220783 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
220784 : pointers are not yet implemented to call delete on eash pointer in the container.
220785 : (This could be done by derivation from the STL containers to define containers that
220786 : automatically deleted their members.)
220787 :
220788 : */
220789 2354 : SgLessThanOp::~SgLessThanOp () {
220790 1177 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
220791 :
220792 :
220793 :
220794 : }
220795 :
220796 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
220797 2354 : }
220798 :
220799 :
220800 : /* #line 220801 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220801 :
220802 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
220803 :
220804 : // Generated constructor
220805 72 : SgLessThanOp::SgLessThanOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
220806 72 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
220807 : {
220808 : #ifdef DEBUG
220809 : // printf ("In SgLessThanOp::SgLessThanOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
220810 : #endif
220811 : #if 0
220812 : // debugging information!
220813 : printf ("In SgLessThanOp::SgLessThanOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
220814 : #endif
220815 :
220816 :
220817 :
220818 : #if 0
220819 : // DQ (7/30/2014): Call a virtual function.
220820 : std::string s = this->class_name();
220821 : #endif
220822 :
220823 : // Test the variant virtual function
220824 : // assert(LT_OP == variant());
220825 72 : assert(LT_OP == this->variant());
220826 72 : ROSE_ASSERT(LT_OP == (int)(this->variantT()));
220827 72 : post_construction_initialization();
220828 :
220829 : // Test the isSgLessThanOp() function since it has been problematic
220830 72 : assert(isSgLessThanOp(this) != NULL);
220831 72 : }
220832 :
220833 : // Generated constructor (all data members)
220834 :
220835 : /* #line 220836 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220836 :
220837 :
220838 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
220839 :
220840 :
220841 : // ********************************************************
220842 : // member functions common across all array grammar objects
220843 : // ********************************************************
220844 :
220845 :
220846 :
220847 : /* #line 220848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220848 :
220849 :
220850 :
220851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
220852 :
220853 : // ********************************************************
220854 : // member functions specific to each node in the grammar
220855 : // ********************************************************
220856 :
220857 :
220858 : /* #line 220859 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
220859 :
220860 : // Start of memberFunctionString
220861 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220862 :
220863 : void
220864 1181 : SgGreaterThanOp::post_construction_initialization()
220865 : {
220866 1181 : }
220867 :
220868 :
220869 :
220870 : // End of memberFunctionString
220871 : // Start of memberFunctionString
220872 : /* #line 5064 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220873 :
220874 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
220875 :
220876 :
220877 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
220878 : SgType*
220879 1114 : SgGreaterThanOp::get_type() const
220880 : {
220881 : #if 0
220882 : printf ("In SgGreaterThanOp::get_type() \n");
220883 : #endif
220884 :
220885 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
220886 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
220887 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
220888 1114 : SgType* returnType = (SageInterface::is_C_language() == true) ?
220889 32 : static_cast<SgType*>(SgTypeInt::createType()) :
220890 1082 : static_cast<SgType*>(SgTypeBool::createType());
220891 1114 : ROSE_ASSERT(returnType != NULL);
220892 1114 : return returnType;
220893 : }
220894 :
220895 :
220896 :
220897 :
220898 : // End of memberFunctionString
220899 : // Start of memberFunctionString
220900 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
220901 :
220902 : // *** COMMON CODE SECTION BEGINS HERE ***
220903 :
220904 : #if 0
220905 : int
220906 : SgGreaterThanOp::getVariant() const
220907 : {
220908 : // This function is used in ROSE while "variant()" is used in SAGE
220909 : assert(this != NULL);
220910 : return variant();
220911 : }
220912 : #endif
220913 :
220914 : // This function is used in ROSE in treeTraversal code
220915 : // eventually replaces getVariant() and variant()
220916 : // though after variant() has been removed for a while we will
220917 : // want to change the name of variantT() back to variant()
220918 : // (since the "T" was ment to stand for temporary).
220919 : // When this happens the variantT() will be depricated.
220920 : VariantT
220921 460840 : SgGreaterThanOp::variantT() const
220922 : {
220923 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
220924 460840 : ROSE_ASSERT(this != NULL);
220925 460840 : return V_SgGreaterThanOp;
220926 : }
220927 :
220928 : #if 0
220929 : int
220930 : SgGreaterThanOp::variant() const
220931 : {
220932 : // This function is used in SAGE
220933 : ROSE_ASSERT(this != NULL);
220934 : return GT_OP;
220935 : }
220936 : #endif
220937 :
220938 : ROSE_DLL_API const char*
220939 73 : SgGreaterThanOp::sage_class_name() const
220940 : {
220941 73 : ROSE_ASSERT(this != NULL);
220942 73 : return "SgGreaterThanOp";
220943 : }
220944 :
220945 : std::string
220946 1013 : SgGreaterThanOp::class_name() const
220947 : {
220948 1013 : ROSE_ASSERT(this != NULL);
220949 1013 : return "SgGreaterThanOp";
220950 : }
220951 :
220952 : // DQ (11/26/2005): Support for visitor pattern mechanims
220953 : // (inferior to ROSE traversal mechanism, experimental).
220954 : void
220955 15499 : SgGreaterThanOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
220956 : {
220957 15499 : ROSE_ASSERT(this != NULL);
220958 15499 : visitor.visit(this);
220959 15499 : }
220960 :
220961 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
220962 0 : void SgGreaterThanOp::accept (ROSE_VisitorPattern & visitor) {
220963 0 : ROSE_ASSERT(this != NULL);
220964 0 : visitor.visit(this);
220965 0 : }
220966 :
220967 : SgGreaterThanOp*
220968 0 : SgGreaterThanOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
220969 : {
220970 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
220971 : // This function is currently only supported for the AST used the represent Binary executables.
220972 : if (0 /* isSgAsmNode(this) != NULL */)
220973 : {
220974 : // Support for regex specification.
220975 : std::string prefixCode = "REGEX:";
220976 : addNewAttribute(prefixCode + s,a);
220977 : }
220978 : #endif
220979 :
220980 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
220981 0 : return this;
220982 : }
220983 :
220984 : // *** COMMON CODE SECTION ENDS HERE ***
220985 :
220986 :
220987 : // End of memberFunctionString
220988 : // Start of memberFunctionString
220989 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
220990 :
220991 :
220992 : #if 0
220993 : //! Error checking support
220994 : /*! Verifies the following:
220995 : - working getVariant() member function
220996 : - calls base class's error() member function
220997 : Every class has one of these functions.
220998 : */
220999 : bool
221000 : SgGreaterThanOp::error()
221001 : {
221002 : // Put error checking here
221003 :
221004 : ROSE_ASSERT (this != NULL);
221005 : if (getVariant() != GT_OP)
221006 : {
221007 : printf ("Error in SgGreaterThanOp::error(): SgGreaterThanOp object has a %s variant \n",
221008 : Cxx_GrammarTerminalNames[getVariant()].name);
221009 : // printf ("Error in SgGreaterThanOp::error() \n");
221010 : ROSE_ABORT();
221011 : }
221012 :
221013 : ROSE_ASSERT (getVariant() == GT_OP);
221014 : return SgBinaryOp::error();
221015 : }
221016 : #endif
221017 :
221018 :
221019 :
221020 : // End of memberFunctionString
221021 :
221022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
221023 :
221024 1181 : SgGreaterThanOp* isSgGreaterThanOp ( SgNode* inputDerivedClassPointer )
221025 : {
221026 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221027 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221028 : // So to fix this we return NULL directly when the input is NULL and avoid the
221029 : // dynamic_cast in this case. This is likely a performance improvement as well.
221030 : // return dynamic_cast<SgGreaterThanOp*>(inputDerivedClassPointer);
221031 : // Milind Chabbi (8/28/2013): isSgGreaterThanOp uses table-driven castability instead of c++ default dynamic_cast
221032 : // this improves the running time performance by 10-20%.
221033 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGreaterThanOp*>(inputDerivedClassPointer);
221034 1181 : return IS_SgGreaterThanOp_FAST_MACRO(inputDerivedClassPointer);
221035 : }
221036 :
221037 : // DQ (11/8/2003): Added version of functions taking const pointer
221038 0 : const SgGreaterThanOp* isSgGreaterThanOp ( const SgNode* inputDerivedClassPointer )
221039 : {
221040 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221041 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221042 : // So to fix this we return NULL directly when the input is NULL and avoid the
221043 : // dynamic_cast in this case. This is likely a performance improvement as well.
221044 : // return dynamic_cast<const SgGreaterThanOp*>(inputDerivedClassPointer);
221045 : // Milind Chabbi (8/28/2013): isSgGreaterThanOp uses table-driven castability instead of c++ default dynamic_cast
221046 : // this improves the running time performance by 10-20%.
221047 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGreaterThanOp*>(inputDerivedClassPointer);
221048 0 : return IS_SgGreaterThanOp_FAST_MACRO(inputDerivedClassPointer);
221049 : }
221050 :
221051 :
221052 :
221053 : /* #line 221054 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221054 :
221055 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221056 :
221057 : /**
221058 : \brief Generated destructor
221059 :
221060 : This destructor is automatically generated (by ROSETTA). This destructor
221061 : only frees memory of data members associated with the parts of the current IR node which
221062 : are NOT traversed. Those data members that are part of a traversal can be freed using
221063 : a traversal (calling this destructor on all children in a post-order traversal). Such
221064 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
221065 :
221066 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
221067 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
221068 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
221069 :
221070 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
221071 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
221072 : pointers are not yet implemented to call delete on eash pointer in the container.
221073 : (This could be done by derivation from the STL containers to define containers that
221074 : automatically deleted their members.)
221075 :
221076 : */
221077 472 : SgGreaterThanOp::~SgGreaterThanOp () {
221078 236 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
221079 :
221080 :
221081 :
221082 : }
221083 :
221084 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221085 472 : }
221086 :
221087 :
221088 : /* #line 221089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221089 :
221090 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
221091 :
221092 : // Generated constructor
221093 146 : SgGreaterThanOp::SgGreaterThanOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
221094 146 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
221095 : {
221096 : #ifdef DEBUG
221097 : // printf ("In SgGreaterThanOp::SgGreaterThanOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
221098 : #endif
221099 : #if 0
221100 : // debugging information!
221101 : printf ("In SgGreaterThanOp::SgGreaterThanOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
221102 : #endif
221103 :
221104 :
221105 :
221106 : #if 0
221107 : // DQ (7/30/2014): Call a virtual function.
221108 : std::string s = this->class_name();
221109 : #endif
221110 :
221111 : // Test the variant virtual function
221112 : // assert(GT_OP == variant());
221113 146 : assert(GT_OP == this->variant());
221114 146 : ROSE_ASSERT(GT_OP == (int)(this->variantT()));
221115 146 : post_construction_initialization();
221116 :
221117 : // Test the isSgGreaterThanOp() function since it has been problematic
221118 146 : assert(isSgGreaterThanOp(this) != NULL);
221119 146 : }
221120 :
221121 : // Generated constructor (all data members)
221122 :
221123 : /* #line 221124 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221124 :
221125 :
221126 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221127 :
221128 :
221129 : // ********************************************************
221130 : // member functions common across all array grammar objects
221131 : // ********************************************************
221132 :
221133 :
221134 :
221135 : /* #line 221136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221136 :
221137 :
221138 :
221139 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221140 :
221141 : // ********************************************************
221142 : // member functions specific to each node in the grammar
221143 : // ********************************************************
221144 :
221145 :
221146 : /* #line 221147 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221147 :
221148 : // Start of memberFunctionString
221149 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221150 :
221151 : void
221152 1858 : SgNotEqualOp::post_construction_initialization()
221153 : {
221154 1858 : }
221155 :
221156 :
221157 :
221158 : // End of memberFunctionString
221159 : // Start of memberFunctionString
221160 : /* #line 5069 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221161 :
221162 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221163 :
221164 :
221165 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
221166 : SgType*
221167 1708 : SgNotEqualOp::get_type() const
221168 : {
221169 : #if 0
221170 : printf ("In SgNotEqualOp::get_type() \n");
221171 : #endif
221172 :
221173 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
221174 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
221175 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
221176 1708 : SgType* returnType = (SageInterface::is_C_language() == true) ?
221177 61 : static_cast<SgType*>(SgTypeInt::createType()) :
221178 1647 : static_cast<SgType*>(SgTypeBool::createType());
221179 1708 : ROSE_ASSERT(returnType != NULL);
221180 1708 : return returnType;
221181 : }
221182 :
221183 :
221184 :
221185 :
221186 : // End of memberFunctionString
221187 : // Start of memberFunctionString
221188 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
221189 :
221190 : // *** COMMON CODE SECTION BEGINS HERE ***
221191 :
221192 : #if 0
221193 : int
221194 : SgNotEqualOp::getVariant() const
221195 : {
221196 : // This function is used in ROSE while "variant()" is used in SAGE
221197 : assert(this != NULL);
221198 : return variant();
221199 : }
221200 : #endif
221201 :
221202 : // This function is used in ROSE in treeTraversal code
221203 : // eventually replaces getVariant() and variant()
221204 : // though after variant() has been removed for a while we will
221205 : // want to change the name of variantT() back to variant()
221206 : // (since the "T" was ment to stand for temporary).
221207 : // When this happens the variantT() will be depricated.
221208 : VariantT
221209 619652 : SgNotEqualOp::variantT() const
221210 : {
221211 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
221212 619652 : ROSE_ASSERT(this != NULL);
221213 619652 : return V_SgNotEqualOp;
221214 : }
221215 :
221216 : #if 0
221217 : int
221218 : SgNotEqualOp::variant() const
221219 : {
221220 : // This function is used in SAGE
221221 : ROSE_ASSERT(this != NULL);
221222 : return NE_OP;
221223 : }
221224 : #endif
221225 :
221226 : ROSE_DLL_API const char*
221227 14 : SgNotEqualOp::sage_class_name() const
221228 : {
221229 14 : ROSE_ASSERT(this != NULL);
221230 14 : return "SgNotEqualOp";
221231 : }
221232 :
221233 : std::string
221234 1674 : SgNotEqualOp::class_name() const
221235 : {
221236 1674 : ROSE_ASSERT(this != NULL);
221237 1674 : return "SgNotEqualOp";
221238 : }
221239 :
221240 : // DQ (11/26/2005): Support for visitor pattern mechanims
221241 : // (inferior to ROSE traversal mechanism, experimental).
221242 : void
221243 14594 : SgNotEqualOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
221244 : {
221245 14594 : ROSE_ASSERT(this != NULL);
221246 14594 : visitor.visit(this);
221247 14594 : }
221248 :
221249 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
221250 0 : void SgNotEqualOp::accept (ROSE_VisitorPattern & visitor) {
221251 0 : ROSE_ASSERT(this != NULL);
221252 0 : visitor.visit(this);
221253 0 : }
221254 :
221255 : SgNotEqualOp*
221256 0 : SgNotEqualOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
221257 : {
221258 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
221259 : // This function is currently only supported for the AST used the represent Binary executables.
221260 : if (0 /* isSgAsmNode(this) != NULL */)
221261 : {
221262 : // Support for regex specification.
221263 : std::string prefixCode = "REGEX:";
221264 : addNewAttribute(prefixCode + s,a);
221265 : }
221266 : #endif
221267 :
221268 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
221269 0 : return this;
221270 : }
221271 :
221272 : // *** COMMON CODE SECTION ENDS HERE ***
221273 :
221274 :
221275 : // End of memberFunctionString
221276 : // Start of memberFunctionString
221277 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
221278 :
221279 :
221280 : #if 0
221281 : //! Error checking support
221282 : /*! Verifies the following:
221283 : - working getVariant() member function
221284 : - calls base class's error() member function
221285 : Every class has one of these functions.
221286 : */
221287 : bool
221288 : SgNotEqualOp::error()
221289 : {
221290 : // Put error checking here
221291 :
221292 : ROSE_ASSERT (this != NULL);
221293 : if (getVariant() != NE_OP)
221294 : {
221295 : printf ("Error in SgNotEqualOp::error(): SgNotEqualOp object has a %s variant \n",
221296 : Cxx_GrammarTerminalNames[getVariant()].name);
221297 : // printf ("Error in SgNotEqualOp::error() \n");
221298 : ROSE_ABORT();
221299 : }
221300 :
221301 : ROSE_ASSERT (getVariant() == NE_OP);
221302 : return SgBinaryOp::error();
221303 : }
221304 : #endif
221305 :
221306 :
221307 :
221308 : // End of memberFunctionString
221309 :
221310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
221311 :
221312 1858 : SgNotEqualOp* isSgNotEqualOp ( SgNode* inputDerivedClassPointer )
221313 : {
221314 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221315 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221316 : // So to fix this we return NULL directly when the input is NULL and avoid the
221317 : // dynamic_cast in this case. This is likely a performance improvement as well.
221318 : // return dynamic_cast<SgNotEqualOp*>(inputDerivedClassPointer);
221319 : // Milind Chabbi (8/28/2013): isSgNotEqualOp uses table-driven castability instead of c++ default dynamic_cast
221320 : // this improves the running time performance by 10-20%.
221321 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNotEqualOp*>(inputDerivedClassPointer);
221322 1858 : return IS_SgNotEqualOp_FAST_MACRO(inputDerivedClassPointer);
221323 : }
221324 :
221325 : // DQ (11/8/2003): Added version of functions taking const pointer
221326 0 : const SgNotEqualOp* isSgNotEqualOp ( const SgNode* inputDerivedClassPointer )
221327 : {
221328 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221329 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221330 : // So to fix this we return NULL directly when the input is NULL and avoid the
221331 : // dynamic_cast in this case. This is likely a performance improvement as well.
221332 : // return dynamic_cast<const SgNotEqualOp*>(inputDerivedClassPointer);
221333 : // Milind Chabbi (8/28/2013): isSgNotEqualOp uses table-driven castability instead of c++ default dynamic_cast
221334 : // this improves the running time performance by 10-20%.
221335 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNotEqualOp*>(inputDerivedClassPointer);
221336 0 : return IS_SgNotEqualOp_FAST_MACRO(inputDerivedClassPointer);
221337 : }
221338 :
221339 :
221340 :
221341 : /* #line 221342 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221342 :
221343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221344 :
221345 : /**
221346 : \brief Generated destructor
221347 :
221348 : This destructor is automatically generated (by ROSETTA). This destructor
221349 : only frees memory of data members associated with the parts of the current IR node which
221350 : are NOT traversed. Those data members that are part of a traversal can be freed using
221351 : a traversal (calling this destructor on all children in a post-order traversal). Such
221352 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
221353 :
221354 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
221355 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
221356 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
221357 :
221358 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
221359 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
221360 : pointers are not yet implemented to call delete on eash pointer in the container.
221361 : (This could be done by derivation from the STL containers to define containers that
221362 : automatically deleted their members.)
221363 :
221364 : */
221365 412 : SgNotEqualOp::~SgNotEqualOp () {
221366 206 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
221367 :
221368 :
221369 :
221370 : }
221371 :
221372 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221373 412 : }
221374 :
221375 :
221376 : /* #line 221377 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221377 :
221378 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
221379 :
221380 : // Generated constructor
221381 136 : SgNotEqualOp::SgNotEqualOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
221382 136 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
221383 : {
221384 : #ifdef DEBUG
221385 : // printf ("In SgNotEqualOp::SgNotEqualOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
221386 : #endif
221387 : #if 0
221388 : // debugging information!
221389 : printf ("In SgNotEqualOp::SgNotEqualOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
221390 : #endif
221391 :
221392 :
221393 :
221394 : #if 0
221395 : // DQ (7/30/2014): Call a virtual function.
221396 : std::string s = this->class_name();
221397 : #endif
221398 :
221399 : // Test the variant virtual function
221400 : // assert(NE_OP == variant());
221401 136 : assert(NE_OP == this->variant());
221402 136 : ROSE_ASSERT(NE_OP == (int)(this->variantT()));
221403 136 : post_construction_initialization();
221404 :
221405 : // Test the isSgNotEqualOp() function since it has been problematic
221406 136 : assert(isSgNotEqualOp(this) != NULL);
221407 136 : }
221408 :
221409 : // Generated constructor (all data members)
221410 :
221411 : /* #line 221412 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221412 :
221413 :
221414 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221415 :
221416 :
221417 : // ********************************************************
221418 : // member functions common across all array grammar objects
221419 : // ********************************************************
221420 :
221421 :
221422 :
221423 : /* #line 221424 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221424 :
221425 :
221426 :
221427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221428 :
221429 : // ********************************************************
221430 : // member functions specific to each node in the grammar
221431 : // ********************************************************
221432 :
221433 :
221434 : /* #line 221435 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221435 :
221436 : // Start of memberFunctionString
221437 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221438 :
221439 : void
221440 367 : SgLessOrEqualOp::post_construction_initialization()
221441 : {
221442 367 : }
221443 :
221444 :
221445 :
221446 : // End of memberFunctionString
221447 : // Start of memberFunctionString
221448 : /* #line 5074 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221449 :
221450 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221451 :
221452 :
221453 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
221454 : SgType*
221455 262 : SgLessOrEqualOp::get_type() const
221456 : {
221457 : #if 0
221458 : printf ("In SgLessOrEqualOp::get_type() \n");
221459 : #endif
221460 :
221461 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
221462 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
221463 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
221464 262 : SgType* returnType = (SageInterface::is_C_language() == true) ?
221465 16 : static_cast<SgType*>(SgTypeInt::createType()) :
221466 246 : static_cast<SgType*>(SgTypeBool::createType());
221467 262 : ROSE_ASSERT(returnType != NULL);
221468 262 : return returnType;
221469 : }
221470 :
221471 :
221472 :
221473 :
221474 : // End of memberFunctionString
221475 : // Start of memberFunctionString
221476 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
221477 :
221478 : // *** COMMON CODE SECTION BEGINS HERE ***
221479 :
221480 : #if 0
221481 : int
221482 : SgLessOrEqualOp::getVariant() const
221483 : {
221484 : // This function is used in ROSE while "variant()" is used in SAGE
221485 : assert(this != NULL);
221486 : return variant();
221487 : }
221488 : #endif
221489 :
221490 : // This function is used in ROSE in treeTraversal code
221491 : // eventually replaces getVariant() and variant()
221492 : // though after variant() has been removed for a while we will
221493 : // want to change the name of variantT() back to variant()
221494 : // (since the "T" was ment to stand for temporary).
221495 : // When this happens the variantT() will be depricated.
221496 : VariantT
221497 99142 : SgLessOrEqualOp::variantT() const
221498 : {
221499 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
221500 99142 : ROSE_ASSERT(this != NULL);
221501 99142 : return V_SgLessOrEqualOp;
221502 : }
221503 :
221504 : #if 0
221505 : int
221506 : SgLessOrEqualOp::variant() const
221507 : {
221508 : // This function is used in SAGE
221509 : ROSE_ASSERT(this != NULL);
221510 : return LE_OP;
221511 : }
221512 : #endif
221513 :
221514 : ROSE_DLL_API const char*
221515 5 : SgLessOrEqualOp::sage_class_name() const
221516 : {
221517 5 : ROSE_ASSERT(this != NULL);
221518 5 : return "SgLessOrEqualOp";
221519 : }
221520 :
221521 : std::string
221522 308 : SgLessOrEqualOp::class_name() const
221523 : {
221524 308 : ROSE_ASSERT(this != NULL);
221525 308 : return "SgLessOrEqualOp";
221526 : }
221527 :
221528 : // DQ (11/26/2005): Support for visitor pattern mechanims
221529 : // (inferior to ROSE traversal mechanism, experimental).
221530 : void
221531 4383 : SgLessOrEqualOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
221532 : {
221533 4383 : ROSE_ASSERT(this != NULL);
221534 4383 : visitor.visit(this);
221535 4383 : }
221536 :
221537 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
221538 0 : void SgLessOrEqualOp::accept (ROSE_VisitorPattern & visitor) {
221539 0 : ROSE_ASSERT(this != NULL);
221540 0 : visitor.visit(this);
221541 0 : }
221542 :
221543 : SgLessOrEqualOp*
221544 0 : SgLessOrEqualOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
221545 : {
221546 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
221547 : // This function is currently only supported for the AST used the represent Binary executables.
221548 : if (0 /* isSgAsmNode(this) != NULL */)
221549 : {
221550 : // Support for regex specification.
221551 : std::string prefixCode = "REGEX:";
221552 : addNewAttribute(prefixCode + s,a);
221553 : }
221554 : #endif
221555 :
221556 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
221557 0 : return this;
221558 : }
221559 :
221560 : // *** COMMON CODE SECTION ENDS HERE ***
221561 :
221562 :
221563 : // End of memberFunctionString
221564 : // Start of memberFunctionString
221565 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
221566 :
221567 :
221568 : #if 0
221569 : //! Error checking support
221570 : /*! Verifies the following:
221571 : - working getVariant() member function
221572 : - calls base class's error() member function
221573 : Every class has one of these functions.
221574 : */
221575 : bool
221576 : SgLessOrEqualOp::error()
221577 : {
221578 : // Put error checking here
221579 :
221580 : ROSE_ASSERT (this != NULL);
221581 : if (getVariant() != LE_OP)
221582 : {
221583 : printf ("Error in SgLessOrEqualOp::error(): SgLessOrEqualOp object has a %s variant \n",
221584 : Cxx_GrammarTerminalNames[getVariant()].name);
221585 : // printf ("Error in SgLessOrEqualOp::error() \n");
221586 : ROSE_ABORT();
221587 : }
221588 :
221589 : ROSE_ASSERT (getVariant() == LE_OP);
221590 : return SgBinaryOp::error();
221591 : }
221592 : #endif
221593 :
221594 :
221595 :
221596 : // End of memberFunctionString
221597 :
221598 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
221599 :
221600 368 : SgLessOrEqualOp* isSgLessOrEqualOp ( SgNode* inputDerivedClassPointer )
221601 : {
221602 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221603 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221604 : // So to fix this we return NULL directly when the input is NULL and avoid the
221605 : // dynamic_cast in this case. This is likely a performance improvement as well.
221606 : // return dynamic_cast<SgLessOrEqualOp*>(inputDerivedClassPointer);
221607 : // Milind Chabbi (8/28/2013): isSgLessOrEqualOp uses table-driven castability instead of c++ default dynamic_cast
221608 : // this improves the running time performance by 10-20%.
221609 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLessOrEqualOp*>(inputDerivedClassPointer);
221610 368 : return IS_SgLessOrEqualOp_FAST_MACRO(inputDerivedClassPointer);
221611 : }
221612 :
221613 : // DQ (11/8/2003): Added version of functions taking const pointer
221614 0 : const SgLessOrEqualOp* isSgLessOrEqualOp ( const SgNode* inputDerivedClassPointer )
221615 : {
221616 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221617 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221618 : // So to fix this we return NULL directly when the input is NULL and avoid the
221619 : // dynamic_cast in this case. This is likely a performance improvement as well.
221620 : // return dynamic_cast<const SgLessOrEqualOp*>(inputDerivedClassPointer);
221621 : // Milind Chabbi (8/28/2013): isSgLessOrEqualOp uses table-driven castability instead of c++ default dynamic_cast
221622 : // this improves the running time performance by 10-20%.
221623 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLessOrEqualOp*>(inputDerivedClassPointer);
221624 0 : return IS_SgLessOrEqualOp_FAST_MACRO(inputDerivedClassPointer);
221625 : }
221626 :
221627 :
221628 :
221629 : /* #line 221630 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221630 :
221631 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221632 :
221633 : /**
221634 : \brief Generated destructor
221635 :
221636 : This destructor is automatically generated (by ROSETTA). This destructor
221637 : only frees memory of data members associated with the parts of the current IR node which
221638 : are NOT traversed. Those data members that are part of a traversal can be freed using
221639 : a traversal (calling this destructor on all children in a post-order traversal). Such
221640 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
221641 :
221642 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
221643 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
221644 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
221645 :
221646 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
221647 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
221648 : pointers are not yet implemented to call delete on eash pointer in the container.
221649 : (This could be done by derivation from the STL containers to define containers that
221650 : automatically deleted their members.)
221651 :
221652 : */
221653 124 : SgLessOrEqualOp::~SgLessOrEqualOp () {
221654 62 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
221655 :
221656 :
221657 :
221658 : }
221659 :
221660 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221661 124 : }
221662 :
221663 :
221664 : /* #line 221665 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221665 :
221666 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
221667 :
221668 : // Generated constructor
221669 30 : SgLessOrEqualOp::SgLessOrEqualOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
221670 30 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
221671 : {
221672 : #ifdef DEBUG
221673 : // printf ("In SgLessOrEqualOp::SgLessOrEqualOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
221674 : #endif
221675 : #if 0
221676 : // debugging information!
221677 : printf ("In SgLessOrEqualOp::SgLessOrEqualOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
221678 : #endif
221679 :
221680 :
221681 :
221682 : #if 0
221683 : // DQ (7/30/2014): Call a virtual function.
221684 : std::string s = this->class_name();
221685 : #endif
221686 :
221687 : // Test the variant virtual function
221688 : // assert(LE_OP == variant());
221689 30 : assert(LE_OP == this->variant());
221690 30 : ROSE_ASSERT(LE_OP == (int)(this->variantT()));
221691 30 : post_construction_initialization();
221692 :
221693 : // Test the isSgLessOrEqualOp() function since it has been problematic
221694 30 : assert(isSgLessOrEqualOp(this) != NULL);
221695 30 : }
221696 :
221697 : // Generated constructor (all data members)
221698 :
221699 : /* #line 221700 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221700 :
221701 :
221702 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221703 :
221704 :
221705 : // ********************************************************
221706 : // member functions common across all array grammar objects
221707 : // ********************************************************
221708 :
221709 :
221710 :
221711 : /* #line 221712 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221712 :
221713 :
221714 :
221715 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221716 :
221717 : // ********************************************************
221718 : // member functions specific to each node in the grammar
221719 : // ********************************************************
221720 :
221721 :
221722 : /* #line 221723 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221723 :
221724 : // Start of memberFunctionString
221725 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221726 :
221727 : void
221728 328 : SgGreaterOrEqualOp::post_construction_initialization()
221729 : {
221730 328 : }
221731 :
221732 :
221733 :
221734 : // End of memberFunctionString
221735 : // Start of memberFunctionString
221736 : /* #line 5079 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221737 :
221738 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
221739 :
221740 :
221741 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
221742 : SgType*
221743 290 : SgGreaterOrEqualOp::get_type() const
221744 : {
221745 : #if 0
221746 : printf ("In SgGreaterOrEqualOp::get_type() \n");
221747 : #endif
221748 :
221749 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
221750 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
221751 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
221752 290 : SgType* returnType = (SageInterface::is_C_language() == true) ?
221753 14 : static_cast<SgType*>(SgTypeInt::createType()) :
221754 276 : static_cast<SgType*>(SgTypeBool::createType());
221755 290 : ROSE_ASSERT(returnType != NULL);
221756 290 : return returnType;
221757 : }
221758 :
221759 :
221760 :
221761 :
221762 : // End of memberFunctionString
221763 : // Start of memberFunctionString
221764 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
221765 :
221766 : // *** COMMON CODE SECTION BEGINS HERE ***
221767 :
221768 : #if 0
221769 : int
221770 : SgGreaterOrEqualOp::getVariant() const
221771 : {
221772 : // This function is used in ROSE while "variant()" is used in SAGE
221773 : assert(this != NULL);
221774 : return variant();
221775 : }
221776 : #endif
221777 :
221778 : // This function is used in ROSE in treeTraversal code
221779 : // eventually replaces getVariant() and variant()
221780 : // though after variant() has been removed for a while we will
221781 : // want to change the name of variantT() back to variant()
221782 : // (since the "T" was ment to stand for temporary).
221783 : // When this happens the variantT() will be depricated.
221784 : VariantT
221785 133320 : SgGreaterOrEqualOp::variantT() const
221786 : {
221787 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
221788 133320 : ROSE_ASSERT(this != NULL);
221789 133320 : return V_SgGreaterOrEqualOp;
221790 : }
221791 :
221792 : #if 0
221793 : int
221794 : SgGreaterOrEqualOp::variant() const
221795 : {
221796 : // This function is used in SAGE
221797 : ROSE_ASSERT(this != NULL);
221798 : return GE_OP;
221799 : }
221800 : #endif
221801 :
221802 : ROSE_DLL_API const char*
221803 0 : SgGreaterOrEqualOp::sage_class_name() const
221804 : {
221805 0 : ROSE_ASSERT(this != NULL);
221806 0 : return "SgGreaterOrEqualOp";
221807 : }
221808 :
221809 : std::string
221810 288 : SgGreaterOrEqualOp::class_name() const
221811 : {
221812 288 : ROSE_ASSERT(this != NULL);
221813 288 : return "SgGreaterOrEqualOp";
221814 : }
221815 :
221816 : // DQ (11/26/2005): Support for visitor pattern mechanims
221817 : // (inferior to ROSE traversal mechanism, experimental).
221818 : void
221819 4068 : SgGreaterOrEqualOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
221820 : {
221821 4068 : ROSE_ASSERT(this != NULL);
221822 4068 : visitor.visit(this);
221823 4068 : }
221824 :
221825 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
221826 0 : void SgGreaterOrEqualOp::accept (ROSE_VisitorPattern & visitor) {
221827 0 : ROSE_ASSERT(this != NULL);
221828 0 : visitor.visit(this);
221829 0 : }
221830 :
221831 : SgGreaterOrEqualOp*
221832 0 : SgGreaterOrEqualOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
221833 : {
221834 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
221835 : // This function is currently only supported for the AST used the represent Binary executables.
221836 : if (0 /* isSgAsmNode(this) != NULL */)
221837 : {
221838 : // Support for regex specification.
221839 : std::string prefixCode = "REGEX:";
221840 : addNewAttribute(prefixCode + s,a);
221841 : }
221842 : #endif
221843 :
221844 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
221845 0 : return this;
221846 : }
221847 :
221848 : // *** COMMON CODE SECTION ENDS HERE ***
221849 :
221850 :
221851 : // End of memberFunctionString
221852 : // Start of memberFunctionString
221853 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
221854 :
221855 :
221856 : #if 0
221857 : //! Error checking support
221858 : /*! Verifies the following:
221859 : - working getVariant() member function
221860 : - calls base class's error() member function
221861 : Every class has one of these functions.
221862 : */
221863 : bool
221864 : SgGreaterOrEqualOp::error()
221865 : {
221866 : // Put error checking here
221867 :
221868 : ROSE_ASSERT (this != NULL);
221869 : if (getVariant() != GE_OP)
221870 : {
221871 : printf ("Error in SgGreaterOrEqualOp::error(): SgGreaterOrEqualOp object has a %s variant \n",
221872 : Cxx_GrammarTerminalNames[getVariant()].name);
221873 : // printf ("Error in SgGreaterOrEqualOp::error() \n");
221874 : ROSE_ABORT();
221875 : }
221876 :
221877 : ROSE_ASSERT (getVariant() == GE_OP);
221878 : return SgBinaryOp::error();
221879 : }
221880 : #endif
221881 :
221882 :
221883 :
221884 : // End of memberFunctionString
221885 :
221886 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
221887 :
221888 328 : SgGreaterOrEqualOp* isSgGreaterOrEqualOp ( SgNode* inputDerivedClassPointer )
221889 : {
221890 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221891 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221892 : // So to fix this we return NULL directly when the input is NULL and avoid the
221893 : // dynamic_cast in this case. This is likely a performance improvement as well.
221894 : // return dynamic_cast<SgGreaterOrEqualOp*>(inputDerivedClassPointer);
221895 : // Milind Chabbi (8/28/2013): isSgGreaterOrEqualOp uses table-driven castability instead of c++ default dynamic_cast
221896 : // this improves the running time performance by 10-20%.
221897 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgGreaterOrEqualOp*>(inputDerivedClassPointer);
221898 328 : return IS_SgGreaterOrEqualOp_FAST_MACRO(inputDerivedClassPointer);
221899 : }
221900 :
221901 : // DQ (11/8/2003): Added version of functions taking const pointer
221902 0 : const SgGreaterOrEqualOp* isSgGreaterOrEqualOp ( const SgNode* inputDerivedClassPointer )
221903 : {
221904 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
221905 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
221906 : // So to fix this we return NULL directly when the input is NULL and avoid the
221907 : // dynamic_cast in this case. This is likely a performance improvement as well.
221908 : // return dynamic_cast<const SgGreaterOrEqualOp*>(inputDerivedClassPointer);
221909 : // Milind Chabbi (8/28/2013): isSgGreaterOrEqualOp uses table-driven castability instead of c++ default dynamic_cast
221910 : // this improves the running time performance by 10-20%.
221911 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgGreaterOrEqualOp*>(inputDerivedClassPointer);
221912 0 : return IS_SgGreaterOrEqualOp_FAST_MACRO(inputDerivedClassPointer);
221913 : }
221914 :
221915 :
221916 :
221917 : /* #line 221918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221918 :
221919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221920 :
221921 : /**
221922 : \brief Generated destructor
221923 :
221924 : This destructor is automatically generated (by ROSETTA). This destructor
221925 : only frees memory of data members associated with the parts of the current IR node which
221926 : are NOT traversed. Those data members that are part of a traversal can be freed using
221927 : a traversal (calling this destructor on all children in a post-order traversal). Such
221928 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
221929 :
221930 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
221931 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
221932 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
221933 :
221934 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
221935 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
221936 : pointers are not yet implemented to call delete on eash pointer in the container.
221937 : (This could be done by derivation from the STL containers to define containers that
221938 : automatically deleted their members.)
221939 :
221940 : */
221941 112 : SgGreaterOrEqualOp::~SgGreaterOrEqualOp () {
221942 56 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
221943 :
221944 :
221945 :
221946 : }
221947 :
221948 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
221949 112 : }
221950 :
221951 :
221952 : /* #line 221953 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221953 :
221954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
221955 :
221956 : // Generated constructor
221957 46 : SgGreaterOrEqualOp::SgGreaterOrEqualOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
221958 46 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
221959 : {
221960 : #ifdef DEBUG
221961 : // printf ("In SgGreaterOrEqualOp::SgGreaterOrEqualOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
221962 : #endif
221963 : #if 0
221964 : // debugging information!
221965 : printf ("In SgGreaterOrEqualOp::SgGreaterOrEqualOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
221966 : #endif
221967 :
221968 :
221969 :
221970 : #if 0
221971 : // DQ (7/30/2014): Call a virtual function.
221972 : std::string s = this->class_name();
221973 : #endif
221974 :
221975 : // Test the variant virtual function
221976 : // assert(GE_OP == variant());
221977 46 : assert(GE_OP == this->variant());
221978 46 : ROSE_ASSERT(GE_OP == (int)(this->variantT()));
221979 46 : post_construction_initialization();
221980 :
221981 : // Test the isSgGreaterOrEqualOp() function since it has been problematic
221982 46 : assert(isSgGreaterOrEqualOp(this) != NULL);
221983 46 : }
221984 :
221985 : // Generated constructor (all data members)
221986 :
221987 : /* #line 221988 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
221988 :
221989 :
221990 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
221991 :
221992 :
221993 : // ********************************************************
221994 : // member functions common across all array grammar objects
221995 : // ********************************************************
221996 :
221997 :
221998 :
221999 : /* #line 222000 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222000 :
222001 :
222002 :
222003 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222004 :
222005 : // ********************************************************
222006 : // member functions specific to each node in the grammar
222007 : // ********************************************************
222008 :
222009 :
222010 : /* #line 222011 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222011 :
222012 : // Start of memberFunctionString
222013 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222014 :
222015 : void
222016 2880 : SgAddOp::post_construction_initialization()
222017 : {
222018 2880 : }
222019 :
222020 :
222021 :
222022 : // End of memberFunctionString
222023 : // Start of memberFunctionString
222024 : /* #line 5088 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222025 :
222026 :
222027 :
222028 : // End of memberFunctionString
222029 : // Start of memberFunctionString
222030 : /* #line 8094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222031 :
222032 :
222033 : #if 0
222034 : #error "This code from SOURCE_ARITHMETIC_OPERATOR_EXPRESSION should not be used"
222035 :
222036 : // DQ (1/14/2006): set_type is removed
222037 : void
222038 : SgAddOp::set_type()
222039 : {
222040 : assert(get_lhs_operand() != NULL);
222041 : assert(get_rhs_operand() != NULL);
222042 : SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
222043 : set_expression_type(op_type);
222044 : }
222045 : #endif
222046 :
222047 :
222048 :
222049 : // End of memberFunctionString
222050 : // Start of memberFunctionString
222051 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
222052 :
222053 : // *** COMMON CODE SECTION BEGINS HERE ***
222054 :
222055 : #if 0
222056 : int
222057 : SgAddOp::getVariant() const
222058 : {
222059 : // This function is used in ROSE while "variant()" is used in SAGE
222060 : assert(this != NULL);
222061 : return variant();
222062 : }
222063 : #endif
222064 :
222065 : // This function is used in ROSE in treeTraversal code
222066 : // eventually replaces getVariant() and variant()
222067 : // though after variant() has been removed for a while we will
222068 : // want to change the name of variantT() back to variant()
222069 : // (since the "T" was ment to stand for temporary).
222070 : // When this happens the variantT() will be depricated.
222071 : VariantT
222072 922400 : SgAddOp::variantT() const
222073 : {
222074 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
222075 922400 : ROSE_ASSERT(this != NULL);
222076 922400 : return V_SgAddOp;
222077 : }
222078 :
222079 : #if 0
222080 : int
222081 : SgAddOp::variant() const
222082 : {
222083 : // This function is used in SAGE
222084 : ROSE_ASSERT(this != NULL);
222085 : return ADD_OP;
222086 : }
222087 : #endif
222088 :
222089 : ROSE_DLL_API const char*
222090 106 : SgAddOp::sage_class_name() const
222091 : {
222092 106 : ROSE_ASSERT(this != NULL);
222093 106 : return "SgAddOp";
222094 : }
222095 :
222096 : std::string
222097 2010 : SgAddOp::class_name() const
222098 : {
222099 2010 : ROSE_ASSERT(this != NULL);
222100 2010 : return "SgAddOp";
222101 : }
222102 :
222103 : // DQ (11/26/2005): Support for visitor pattern mechanims
222104 : // (inferior to ROSE traversal mechanism, experimental).
222105 : void
222106 27993 : SgAddOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
222107 : {
222108 27993 : ROSE_ASSERT(this != NULL);
222109 27993 : visitor.visit(this);
222110 27993 : }
222111 :
222112 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
222113 0 : void SgAddOp::accept (ROSE_VisitorPattern & visitor) {
222114 0 : ROSE_ASSERT(this != NULL);
222115 0 : visitor.visit(this);
222116 0 : }
222117 :
222118 : SgAddOp*
222119 0 : SgAddOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
222120 : {
222121 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
222122 : // This function is currently only supported for the AST used the represent Binary executables.
222123 : if (0 /* isSgAsmNode(this) != NULL */)
222124 : {
222125 : // Support for regex specification.
222126 : std::string prefixCode = "REGEX:";
222127 : addNewAttribute(prefixCode + s,a);
222128 : }
222129 : #endif
222130 :
222131 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
222132 0 : return this;
222133 : }
222134 :
222135 : // *** COMMON CODE SECTION ENDS HERE ***
222136 :
222137 :
222138 : // End of memberFunctionString
222139 : // Start of memberFunctionString
222140 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
222141 :
222142 :
222143 : #if 0
222144 : //! Error checking support
222145 : /*! Verifies the following:
222146 : - working getVariant() member function
222147 : - calls base class's error() member function
222148 : Every class has one of these functions.
222149 : */
222150 : bool
222151 : SgAddOp::error()
222152 : {
222153 : // Put error checking here
222154 :
222155 : ROSE_ASSERT (this != NULL);
222156 : if (getVariant() != ADD_OP)
222157 : {
222158 : printf ("Error in SgAddOp::error(): SgAddOp object has a %s variant \n",
222159 : Cxx_GrammarTerminalNames[getVariant()].name);
222160 : // printf ("Error in SgAddOp::error() \n");
222161 : ROSE_ABORT();
222162 : }
222163 :
222164 : ROSE_ASSERT (getVariant() == ADD_OP);
222165 : return SgBinaryOp::error();
222166 : }
222167 : #endif
222168 :
222169 :
222170 :
222171 : // End of memberFunctionString
222172 :
222173 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
222174 :
222175 19509 : SgAddOp* isSgAddOp ( SgNode* inputDerivedClassPointer )
222176 : {
222177 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
222178 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
222179 : // So to fix this we return NULL directly when the input is NULL and avoid the
222180 : // dynamic_cast in this case. This is likely a performance improvement as well.
222181 : // return dynamic_cast<SgAddOp*>(inputDerivedClassPointer);
222182 : // Milind Chabbi (8/28/2013): isSgAddOp uses table-driven castability instead of c++ default dynamic_cast
222183 : // this improves the running time performance by 10-20%.
222184 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAddOp*>(inputDerivedClassPointer);
222185 19509 : return IS_SgAddOp_FAST_MACRO(inputDerivedClassPointer);
222186 : }
222187 :
222188 : // DQ (11/8/2003): Added version of functions taking const pointer
222189 0 : const SgAddOp* isSgAddOp ( const SgNode* inputDerivedClassPointer )
222190 : {
222191 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
222192 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
222193 : // So to fix this we return NULL directly when the input is NULL and avoid the
222194 : // dynamic_cast in this case. This is likely a performance improvement as well.
222195 : // return dynamic_cast<const SgAddOp*>(inputDerivedClassPointer);
222196 : // Milind Chabbi (8/28/2013): isSgAddOp uses table-driven castability instead of c++ default dynamic_cast
222197 : // this improves the running time performance by 10-20%.
222198 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAddOp*>(inputDerivedClassPointer);
222199 0 : return IS_SgAddOp_FAST_MACRO(inputDerivedClassPointer);
222200 : }
222201 :
222202 :
222203 :
222204 : /* #line 222205 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222205 :
222206 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
222207 :
222208 : /**
222209 : \brief Generated destructor
222210 :
222211 : This destructor is automatically generated (by ROSETTA). This destructor
222212 : only frees memory of data members associated with the parts of the current IR node which
222213 : are NOT traversed. Those data members that are part of a traversal can be freed using
222214 : a traversal (calling this destructor on all children in a post-order traversal). Such
222215 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
222216 :
222217 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
222218 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
222219 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
222220 :
222221 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
222222 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
222223 : pointers are not yet implemented to call delete on eash pointer in the container.
222224 : (This could be done by derivation from the STL containers to define containers that
222225 : automatically deleted their members.)
222226 :
222227 : */
222228 1528 : SgAddOp::~SgAddOp () {
222229 764 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
222230 :
222231 :
222232 :
222233 : }
222234 :
222235 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
222236 1528 : }
222237 :
222238 :
222239 : /* #line 222240 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222240 :
222241 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
222242 :
222243 : // Generated constructor
222244 229 : SgAddOp::SgAddOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
222245 229 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
222246 : {
222247 : #ifdef DEBUG
222248 : // printf ("In SgAddOp::SgAddOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
222249 : #endif
222250 : #if 0
222251 : // debugging information!
222252 : printf ("In SgAddOp::SgAddOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
222253 : #endif
222254 :
222255 :
222256 :
222257 : #if 0
222258 : // DQ (7/30/2014): Call a virtual function.
222259 : std::string s = this->class_name();
222260 : #endif
222261 :
222262 : // Test the variant virtual function
222263 : // assert(ADD_OP == variant());
222264 229 : assert(ADD_OP == this->variant());
222265 229 : ROSE_ASSERT(ADD_OP == (int)(this->variantT()));
222266 229 : post_construction_initialization();
222267 :
222268 : // Test the isSgAddOp() function since it has been problematic
222269 229 : assert(isSgAddOp(this) != NULL);
222270 229 : }
222271 :
222272 : // Generated constructor (all data members)
222273 :
222274 : /* #line 222275 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222275 :
222276 :
222277 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222278 :
222279 :
222280 : // ********************************************************
222281 : // member functions common across all array grammar objects
222282 : // ********************************************************
222283 :
222284 :
222285 :
222286 : /* #line 222287 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222287 :
222288 :
222289 :
222290 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222291 :
222292 : // ********************************************************
222293 : // member functions specific to each node in the grammar
222294 : // ********************************************************
222295 :
222296 :
222297 : /* #line 222298 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222298 :
222299 : // Start of memberFunctionString
222300 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222301 :
222302 : void
222303 2798 : SgSubtractOp::post_construction_initialization()
222304 : {
222305 2798 : }
222306 :
222307 :
222308 :
222309 : // End of memberFunctionString
222310 : // Start of memberFunctionString
222311 : /* #line 5091 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222312 :
222313 :
222314 :
222315 : // End of memberFunctionString
222316 : // Start of memberFunctionString
222317 : /* #line 8094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222318 :
222319 :
222320 : #if 0
222321 : #error "This code from SOURCE_ARITHMETIC_OPERATOR_EXPRESSION should not be used"
222322 :
222323 : // DQ (1/14/2006): set_type is removed
222324 : void
222325 : SgSubtractOp::set_type()
222326 : {
222327 : assert(get_lhs_operand() != NULL);
222328 : assert(get_rhs_operand() != NULL);
222329 : SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
222330 : set_expression_type(op_type);
222331 : }
222332 : #endif
222333 :
222334 :
222335 :
222336 : // End of memberFunctionString
222337 : // Start of memberFunctionString
222338 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
222339 :
222340 : // *** COMMON CODE SECTION BEGINS HERE ***
222341 :
222342 : #if 0
222343 : int
222344 : SgSubtractOp::getVariant() const
222345 : {
222346 : // This function is used in ROSE while "variant()" is used in SAGE
222347 : assert(this != NULL);
222348 : return variant();
222349 : }
222350 : #endif
222351 :
222352 : // This function is used in ROSE in treeTraversal code
222353 : // eventually replaces getVariant() and variant()
222354 : // though after variant() has been removed for a while we will
222355 : // want to change the name of variantT() back to variant()
222356 : // (since the "T" was ment to stand for temporary).
222357 : // When this happens the variantT() will be depricated.
222358 : VariantT
222359 1007100 : SgSubtractOp::variantT() const
222360 : {
222361 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
222362 1007100 : ROSE_ASSERT(this != NULL);
222363 1007100 : return V_SgSubtractOp;
222364 : }
222365 :
222366 : #if 0
222367 : int
222368 : SgSubtractOp::variant() const
222369 : {
222370 : // This function is used in SAGE
222371 : ROSE_ASSERT(this != NULL);
222372 : return SUBT_OP;
222373 : }
222374 : #endif
222375 :
222376 : ROSE_DLL_API const char*
222377 161 : SgSubtractOp::sage_class_name() const
222378 : {
222379 161 : ROSE_ASSERT(this != NULL);
222380 161 : return "SgSubtractOp";
222381 : }
222382 :
222383 : std::string
222384 2301 : SgSubtractOp::class_name() const
222385 : {
222386 2301 : ROSE_ASSERT(this != NULL);
222387 2301 : return "SgSubtractOp";
222388 : }
222389 :
222390 : // DQ (11/26/2005): Support for visitor pattern mechanims
222391 : // (inferior to ROSE traversal mechanism, experimental).
222392 : void
222393 30246 : SgSubtractOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
222394 : {
222395 30246 : ROSE_ASSERT(this != NULL);
222396 30246 : visitor.visit(this);
222397 30246 : }
222398 :
222399 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
222400 0 : void SgSubtractOp::accept (ROSE_VisitorPattern & visitor) {
222401 0 : ROSE_ASSERT(this != NULL);
222402 0 : visitor.visit(this);
222403 0 : }
222404 :
222405 : SgSubtractOp*
222406 0 : SgSubtractOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
222407 : {
222408 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
222409 : // This function is currently only supported for the AST used the represent Binary executables.
222410 : if (0 /* isSgAsmNode(this) != NULL */)
222411 : {
222412 : // Support for regex specification.
222413 : std::string prefixCode = "REGEX:";
222414 : addNewAttribute(prefixCode + s,a);
222415 : }
222416 : #endif
222417 :
222418 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
222419 0 : return this;
222420 : }
222421 :
222422 : // *** COMMON CODE SECTION ENDS HERE ***
222423 :
222424 :
222425 : // End of memberFunctionString
222426 : // Start of memberFunctionString
222427 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
222428 :
222429 :
222430 : #if 0
222431 : //! Error checking support
222432 : /*! Verifies the following:
222433 : - working getVariant() member function
222434 : - calls base class's error() member function
222435 : Every class has one of these functions.
222436 : */
222437 : bool
222438 : SgSubtractOp::error()
222439 : {
222440 : // Put error checking here
222441 :
222442 : ROSE_ASSERT (this != NULL);
222443 : if (getVariant() != SUBT_OP)
222444 : {
222445 : printf ("Error in SgSubtractOp::error(): SgSubtractOp object has a %s variant \n",
222446 : Cxx_GrammarTerminalNames[getVariant()].name);
222447 : // printf ("Error in SgSubtractOp::error() \n");
222448 : ROSE_ABORT();
222449 : }
222450 :
222451 : ROSE_ASSERT (getVariant() == SUBT_OP);
222452 : return SgBinaryOp::error();
222453 : }
222454 : #endif
222455 :
222456 :
222457 :
222458 : // End of memberFunctionString
222459 :
222460 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
222461 :
222462 2798 : SgSubtractOp* isSgSubtractOp ( SgNode* inputDerivedClassPointer )
222463 : {
222464 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
222465 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
222466 : // So to fix this we return NULL directly when the input is NULL and avoid the
222467 : // dynamic_cast in this case. This is likely a performance improvement as well.
222468 : // return dynamic_cast<SgSubtractOp*>(inputDerivedClassPointer);
222469 : // Milind Chabbi (8/28/2013): isSgSubtractOp uses table-driven castability instead of c++ default dynamic_cast
222470 : // this improves the running time performance by 10-20%.
222471 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSubtractOp*>(inputDerivedClassPointer);
222472 2798 : return IS_SgSubtractOp_FAST_MACRO(inputDerivedClassPointer);
222473 : }
222474 :
222475 : // DQ (11/8/2003): Added version of functions taking const pointer
222476 0 : const SgSubtractOp* isSgSubtractOp ( const SgNode* inputDerivedClassPointer )
222477 : {
222478 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
222479 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
222480 : // So to fix this we return NULL directly when the input is NULL and avoid the
222481 : // dynamic_cast in this case. This is likely a performance improvement as well.
222482 : // return dynamic_cast<const SgSubtractOp*>(inputDerivedClassPointer);
222483 : // Milind Chabbi (8/28/2013): isSgSubtractOp uses table-driven castability instead of c++ default dynamic_cast
222484 : // this improves the running time performance by 10-20%.
222485 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSubtractOp*>(inputDerivedClassPointer);
222486 0 : return IS_SgSubtractOp_FAST_MACRO(inputDerivedClassPointer);
222487 : }
222488 :
222489 :
222490 :
222491 : /* #line 222492 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222492 :
222493 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
222494 :
222495 : /**
222496 : \brief Generated destructor
222497 :
222498 : This destructor is automatically generated (by ROSETTA). This destructor
222499 : only frees memory of data members associated with the parts of the current IR node which
222500 : are NOT traversed. Those data members that are part of a traversal can be freed using
222501 : a traversal (calling this destructor on all children in a post-order traversal). Such
222502 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
222503 :
222504 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
222505 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
222506 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
222507 :
222508 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
222509 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
222510 : pointers are not yet implemented to call delete on eash pointer in the container.
222511 : (This could be done by derivation from the STL containers to define containers that
222512 : automatically deleted their members.)
222513 :
222514 : */
222515 896 : SgSubtractOp::~SgSubtractOp () {
222516 448 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
222517 :
222518 :
222519 :
222520 : }
222521 :
222522 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
222523 896 : }
222524 :
222525 :
222526 : /* #line 222527 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222527 :
222528 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
222529 :
222530 : // Generated constructor
222531 101 : SgSubtractOp::SgSubtractOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
222532 101 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
222533 : {
222534 : #ifdef DEBUG
222535 : // printf ("In SgSubtractOp::SgSubtractOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
222536 : #endif
222537 : #if 0
222538 : // debugging information!
222539 : printf ("In SgSubtractOp::SgSubtractOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
222540 : #endif
222541 :
222542 :
222543 :
222544 : #if 0
222545 : // DQ (7/30/2014): Call a virtual function.
222546 : std::string s = this->class_name();
222547 : #endif
222548 :
222549 : // Test the variant virtual function
222550 : // assert(SUBT_OP == variant());
222551 101 : assert(SUBT_OP == this->variant());
222552 101 : ROSE_ASSERT(SUBT_OP == (int)(this->variantT()));
222553 101 : post_construction_initialization();
222554 :
222555 : // Test the isSgSubtractOp() function since it has been problematic
222556 101 : assert(isSgSubtractOp(this) != NULL);
222557 101 : }
222558 :
222559 : // Generated constructor (all data members)
222560 :
222561 : /* #line 222562 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222562 :
222563 :
222564 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222565 :
222566 :
222567 : // ********************************************************
222568 : // member functions common across all array grammar objects
222569 : // ********************************************************
222570 :
222571 :
222572 :
222573 : /* #line 222574 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222574 :
222575 :
222576 :
222577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222578 :
222579 : // ********************************************************
222580 : // member functions specific to each node in the grammar
222581 : // ********************************************************
222582 :
222583 :
222584 : /* #line 222585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222585 :
222586 : // Start of memberFunctionString
222587 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222588 :
222589 : void
222590 2052 : SgMultiplyOp::post_construction_initialization()
222591 : {
222592 2052 : }
222593 :
222594 :
222595 :
222596 : // End of memberFunctionString
222597 : // Start of memberFunctionString
222598 : /* #line 5095 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222599 :
222600 :
222601 :
222602 : // End of memberFunctionString
222603 : // Start of memberFunctionString
222604 : /* #line 8094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222605 :
222606 :
222607 : #if 0
222608 : #error "This code from SOURCE_ARITHMETIC_OPERATOR_EXPRESSION should not be used"
222609 :
222610 : // DQ (1/14/2006): set_type is removed
222611 : void
222612 : SgMultiplyOp::set_type()
222613 : {
222614 : assert(get_lhs_operand() != NULL);
222615 : assert(get_rhs_operand() != NULL);
222616 : SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
222617 : set_expression_type(op_type);
222618 : }
222619 : #endif
222620 :
222621 :
222622 :
222623 : // End of memberFunctionString
222624 : // Start of memberFunctionString
222625 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
222626 :
222627 : // *** COMMON CODE SECTION BEGINS HERE ***
222628 :
222629 : #if 0
222630 : int
222631 : SgMultiplyOp::getVariant() const
222632 : {
222633 : // This function is used in ROSE while "variant()" is used in SAGE
222634 : assert(this != NULL);
222635 : return variant();
222636 : }
222637 : #endif
222638 :
222639 : // This function is used in ROSE in treeTraversal code
222640 : // eventually replaces getVariant() and variant()
222641 : // though after variant() has been removed for a while we will
222642 : // want to change the name of variantT() back to variant()
222643 : // (since the "T" was ment to stand for temporary).
222644 : // When this happens the variantT() will be depricated.
222645 : VariantT
222646 508736 : SgMultiplyOp::variantT() const
222647 : {
222648 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
222649 508736 : ROSE_ASSERT(this != NULL);
222650 508736 : return V_SgMultiplyOp;
222651 : }
222652 :
222653 : #if 0
222654 : int
222655 : SgMultiplyOp::variant() const
222656 : {
222657 : // This function is used in SAGE
222658 : ROSE_ASSERT(this != NULL);
222659 : return MULT_OP;
222660 : }
222661 : #endif
222662 :
222663 : ROSE_DLL_API const char*
222664 106 : SgMultiplyOp::sage_class_name() const
222665 : {
222666 106 : ROSE_ASSERT(this != NULL);
222667 106 : return "SgMultiplyOp";
222668 : }
222669 :
222670 : std::string
222671 1561 : SgMultiplyOp::class_name() const
222672 : {
222673 1561 : ROSE_ASSERT(this != NULL);
222674 1561 : return "SgMultiplyOp";
222675 : }
222676 :
222677 : // DQ (11/26/2005): Support for visitor pattern mechanims
222678 : // (inferior to ROSE traversal mechanism, experimental).
222679 : void
222680 8899 : SgMultiplyOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
222681 : {
222682 8899 : ROSE_ASSERT(this != NULL);
222683 8899 : visitor.visit(this);
222684 8899 : }
222685 :
222686 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
222687 0 : void SgMultiplyOp::accept (ROSE_VisitorPattern & visitor) {
222688 0 : ROSE_ASSERT(this != NULL);
222689 0 : visitor.visit(this);
222690 0 : }
222691 :
222692 : SgMultiplyOp*
222693 0 : SgMultiplyOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
222694 : {
222695 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
222696 : // This function is currently only supported for the AST used the represent Binary executables.
222697 : if (0 /* isSgAsmNode(this) != NULL */)
222698 : {
222699 : // Support for regex specification.
222700 : std::string prefixCode = "REGEX:";
222701 : addNewAttribute(prefixCode + s,a);
222702 : }
222703 : #endif
222704 :
222705 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
222706 0 : return this;
222707 : }
222708 :
222709 : // *** COMMON CODE SECTION ENDS HERE ***
222710 :
222711 :
222712 : // End of memberFunctionString
222713 : // Start of memberFunctionString
222714 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
222715 :
222716 :
222717 : #if 0
222718 : //! Error checking support
222719 : /*! Verifies the following:
222720 : - working getVariant() member function
222721 : - calls base class's error() member function
222722 : Every class has one of these functions.
222723 : */
222724 : bool
222725 : SgMultiplyOp::error()
222726 : {
222727 : // Put error checking here
222728 :
222729 : ROSE_ASSERT (this != NULL);
222730 : if (getVariant() != MULT_OP)
222731 : {
222732 : printf ("Error in SgMultiplyOp::error(): SgMultiplyOp object has a %s variant \n",
222733 : Cxx_GrammarTerminalNames[getVariant()].name);
222734 : // printf ("Error in SgMultiplyOp::error() \n");
222735 : ROSE_ABORT();
222736 : }
222737 :
222738 : ROSE_ASSERT (getVariant() == MULT_OP);
222739 : return SgBinaryOp::error();
222740 : }
222741 : #endif
222742 :
222743 :
222744 :
222745 : // End of memberFunctionString
222746 :
222747 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
222748 :
222749 2103 : SgMultiplyOp* isSgMultiplyOp ( SgNode* inputDerivedClassPointer )
222750 : {
222751 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
222752 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
222753 : // So to fix this we return NULL directly when the input is NULL and avoid the
222754 : // dynamic_cast in this case. This is likely a performance improvement as well.
222755 : // return dynamic_cast<SgMultiplyOp*>(inputDerivedClassPointer);
222756 : // Milind Chabbi (8/28/2013): isSgMultiplyOp uses table-driven castability instead of c++ default dynamic_cast
222757 : // this improves the running time performance by 10-20%.
222758 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMultiplyOp*>(inputDerivedClassPointer);
222759 2103 : return IS_SgMultiplyOp_FAST_MACRO(inputDerivedClassPointer);
222760 : }
222761 :
222762 : // DQ (11/8/2003): Added version of functions taking const pointer
222763 0 : const SgMultiplyOp* isSgMultiplyOp ( const SgNode* inputDerivedClassPointer )
222764 : {
222765 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
222766 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
222767 : // So to fix this we return NULL directly when the input is NULL and avoid the
222768 : // dynamic_cast in this case. This is likely a performance improvement as well.
222769 : // return dynamic_cast<const SgMultiplyOp*>(inputDerivedClassPointer);
222770 : // Milind Chabbi (8/28/2013): isSgMultiplyOp uses table-driven castability instead of c++ default dynamic_cast
222771 : // this improves the running time performance by 10-20%.
222772 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMultiplyOp*>(inputDerivedClassPointer);
222773 0 : return IS_SgMultiplyOp_FAST_MACRO(inputDerivedClassPointer);
222774 : }
222775 :
222776 :
222777 :
222778 : /* #line 222779 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222779 :
222780 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
222781 :
222782 : /**
222783 : \brief Generated destructor
222784 :
222785 : This destructor is automatically generated (by ROSETTA). This destructor
222786 : only frees memory of data members associated with the parts of the current IR node which
222787 : are NOT traversed. Those data members that are part of a traversal can be freed using
222788 : a traversal (calling this destructor on all children in a post-order traversal). Such
222789 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
222790 :
222791 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
222792 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
222793 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
222794 :
222795 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
222796 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
222797 : pointers are not yet implemented to call delete on eash pointer in the container.
222798 : (This could be done by derivation from the STL containers to define containers that
222799 : automatically deleted their members.)
222800 :
222801 : */
222802 746 : SgMultiplyOp::~SgMultiplyOp () {
222803 373 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
222804 :
222805 :
222806 :
222807 : }
222808 :
222809 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
222810 746 : }
222811 :
222812 :
222813 : /* #line 222814 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222814 :
222815 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
222816 :
222817 : // Generated constructor
222818 65 : SgMultiplyOp::SgMultiplyOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
222819 65 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
222820 : {
222821 : #ifdef DEBUG
222822 : // printf ("In SgMultiplyOp::SgMultiplyOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
222823 : #endif
222824 : #if 0
222825 : // debugging information!
222826 : printf ("In SgMultiplyOp::SgMultiplyOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
222827 : #endif
222828 :
222829 :
222830 :
222831 : #if 0
222832 : // DQ (7/30/2014): Call a virtual function.
222833 : std::string s = this->class_name();
222834 : #endif
222835 :
222836 : // Test the variant virtual function
222837 : // assert(MULT_OP == variant());
222838 65 : assert(MULT_OP == this->variant());
222839 65 : ROSE_ASSERT(MULT_OP == (int)(this->variantT()));
222840 65 : post_construction_initialization();
222841 :
222842 : // Test the isSgMultiplyOp() function since it has been problematic
222843 65 : assert(isSgMultiplyOp(this) != NULL);
222844 65 : }
222845 :
222846 : // Generated constructor (all data members)
222847 :
222848 : /* #line 222849 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222849 :
222850 :
222851 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222852 :
222853 :
222854 : // ********************************************************
222855 : // member functions common across all array grammar objects
222856 : // ********************************************************
222857 :
222858 :
222859 :
222860 : /* #line 222861 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222861 :
222862 :
222863 :
222864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
222865 :
222866 : // ********************************************************
222867 : // member functions specific to each node in the grammar
222868 : // ********************************************************
222869 :
222870 :
222871 : /* #line 222872 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
222872 :
222873 : // Start of memberFunctionString
222874 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222875 :
222876 : void
222877 1174 : SgDivideOp::post_construction_initialization()
222878 : {
222879 1174 : }
222880 :
222881 :
222882 :
222883 : // End of memberFunctionString
222884 : // Start of memberFunctionString
222885 : /* #line 5099 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222886 :
222887 :
222888 :
222889 : // End of memberFunctionString
222890 : // Start of memberFunctionString
222891 : /* #line 8094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
222892 :
222893 :
222894 : #if 0
222895 : #error "This code from SOURCE_ARITHMETIC_OPERATOR_EXPRESSION should not be used"
222896 :
222897 : // DQ (1/14/2006): set_type is removed
222898 : void
222899 : SgDivideOp::set_type()
222900 : {
222901 : assert(get_lhs_operand() != NULL);
222902 : assert(get_rhs_operand() != NULL);
222903 : SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
222904 : set_expression_type(op_type);
222905 : }
222906 : #endif
222907 :
222908 :
222909 :
222910 : // End of memberFunctionString
222911 : // Start of memberFunctionString
222912 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
222913 :
222914 : // *** COMMON CODE SECTION BEGINS HERE ***
222915 :
222916 : #if 0
222917 : int
222918 : SgDivideOp::getVariant() const
222919 : {
222920 : // This function is used in ROSE while "variant()" is used in SAGE
222921 : assert(this != NULL);
222922 : return variant();
222923 : }
222924 : #endif
222925 :
222926 : // This function is used in ROSE in treeTraversal code
222927 : // eventually replaces getVariant() and variant()
222928 : // though after variant() has been removed for a while we will
222929 : // want to change the name of variantT() back to variant()
222930 : // (since the "T" was ment to stand for temporary).
222931 : // When this happens the variantT() will be depricated.
222932 : VariantT
222933 302558 : SgDivideOp::variantT() const
222934 : {
222935 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
222936 302558 : ROSE_ASSERT(this != NULL);
222937 302558 : return V_SgDivideOp;
222938 : }
222939 :
222940 : #if 0
222941 : int
222942 : SgDivideOp::variant() const
222943 : {
222944 : // This function is used in SAGE
222945 : ROSE_ASSERT(this != NULL);
222946 : return DIV_OP;
222947 : }
222948 : #endif
222949 :
222950 : ROSE_DLL_API const char*
222951 53 : SgDivideOp::sage_class_name() const
222952 : {
222953 53 : ROSE_ASSERT(this != NULL);
222954 53 : return "SgDivideOp";
222955 : }
222956 :
222957 : std::string
222958 853 : SgDivideOp::class_name() const
222959 : {
222960 853 : ROSE_ASSERT(this != NULL);
222961 853 : return "SgDivideOp";
222962 : }
222963 :
222964 : // DQ (11/26/2005): Support for visitor pattern mechanims
222965 : // (inferior to ROSE traversal mechanism, experimental).
222966 : void
222967 5351 : SgDivideOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
222968 : {
222969 5351 : ROSE_ASSERT(this != NULL);
222970 5351 : visitor.visit(this);
222971 5351 : }
222972 :
222973 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
222974 0 : void SgDivideOp::accept (ROSE_VisitorPattern & visitor) {
222975 0 : ROSE_ASSERT(this != NULL);
222976 0 : visitor.visit(this);
222977 0 : }
222978 :
222979 : SgDivideOp*
222980 0 : SgDivideOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
222981 : {
222982 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
222983 : // This function is currently only supported for the AST used the represent Binary executables.
222984 : if (0 /* isSgAsmNode(this) != NULL */)
222985 : {
222986 : // Support for regex specification.
222987 : std::string prefixCode = "REGEX:";
222988 : addNewAttribute(prefixCode + s,a);
222989 : }
222990 : #endif
222991 :
222992 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
222993 0 : return this;
222994 : }
222995 :
222996 : // *** COMMON CODE SECTION ENDS HERE ***
222997 :
222998 :
222999 : // End of memberFunctionString
223000 : // Start of memberFunctionString
223001 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
223002 :
223003 :
223004 : #if 0
223005 : //! Error checking support
223006 : /*! Verifies the following:
223007 : - working getVariant() member function
223008 : - calls base class's error() member function
223009 : Every class has one of these functions.
223010 : */
223011 : bool
223012 : SgDivideOp::error()
223013 : {
223014 : // Put error checking here
223015 :
223016 : ROSE_ASSERT (this != NULL);
223017 : if (getVariant() != DIV_OP)
223018 : {
223019 : printf ("Error in SgDivideOp::error(): SgDivideOp object has a %s variant \n",
223020 : Cxx_GrammarTerminalNames[getVariant()].name);
223021 : // printf ("Error in SgDivideOp::error() \n");
223022 : ROSE_ABORT();
223023 : }
223024 :
223025 : ROSE_ASSERT (getVariant() == DIV_OP);
223026 : return SgBinaryOp::error();
223027 : }
223028 : #endif
223029 :
223030 :
223031 :
223032 : // End of memberFunctionString
223033 :
223034 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
223035 :
223036 1174 : SgDivideOp* isSgDivideOp ( SgNode* inputDerivedClassPointer )
223037 : {
223038 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223039 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223040 : // So to fix this we return NULL directly when the input is NULL and avoid the
223041 : // dynamic_cast in this case. This is likely a performance improvement as well.
223042 : // return dynamic_cast<SgDivideOp*>(inputDerivedClassPointer);
223043 : // Milind Chabbi (8/28/2013): isSgDivideOp uses table-driven castability instead of c++ default dynamic_cast
223044 : // this improves the running time performance by 10-20%.
223045 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDivideOp*>(inputDerivedClassPointer);
223046 1174 : return IS_SgDivideOp_FAST_MACRO(inputDerivedClassPointer);
223047 : }
223048 :
223049 : // DQ (11/8/2003): Added version of functions taking const pointer
223050 0 : const SgDivideOp* isSgDivideOp ( const SgNode* inputDerivedClassPointer )
223051 : {
223052 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223053 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223054 : // So to fix this we return NULL directly when the input is NULL and avoid the
223055 : // dynamic_cast in this case. This is likely a performance improvement as well.
223056 : // return dynamic_cast<const SgDivideOp*>(inputDerivedClassPointer);
223057 : // Milind Chabbi (8/28/2013): isSgDivideOp uses table-driven castability instead of c++ default dynamic_cast
223058 : // this improves the running time performance by 10-20%.
223059 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDivideOp*>(inputDerivedClassPointer);
223060 0 : return IS_SgDivideOp_FAST_MACRO(inputDerivedClassPointer);
223061 : }
223062 :
223063 :
223064 :
223065 : /* #line 223066 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223066 :
223067 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223068 :
223069 : /**
223070 : \brief Generated destructor
223071 :
223072 : This destructor is automatically generated (by ROSETTA). This destructor
223073 : only frees memory of data members associated with the parts of the current IR node which
223074 : are NOT traversed. Those data members that are part of a traversal can be freed using
223075 : a traversal (calling this destructor on all children in a post-order traversal). Such
223076 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
223077 :
223078 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
223079 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
223080 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
223081 :
223082 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
223083 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
223084 : pointers are not yet implemented to call delete on eash pointer in the container.
223085 : (This could be done by derivation from the STL containers to define containers that
223086 : automatically deleted their members.)
223087 :
223088 : */
223089 552 : SgDivideOp::~SgDivideOp () {
223090 276 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
223091 :
223092 :
223093 :
223094 : }
223095 :
223096 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223097 552 : }
223098 :
223099 :
223100 : /* #line 223101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223101 :
223102 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
223103 :
223104 : // Generated constructor
223105 61 : SgDivideOp::SgDivideOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
223106 61 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
223107 : {
223108 : #ifdef DEBUG
223109 : // printf ("In SgDivideOp::SgDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
223110 : #endif
223111 : #if 0
223112 : // debugging information!
223113 : printf ("In SgDivideOp::SgDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
223114 : #endif
223115 :
223116 :
223117 :
223118 : #if 0
223119 : // DQ (7/30/2014): Call a virtual function.
223120 : std::string s = this->class_name();
223121 : #endif
223122 :
223123 : // Test the variant virtual function
223124 : // assert(DIV_OP == variant());
223125 61 : assert(DIV_OP == this->variant());
223126 61 : ROSE_ASSERT(DIV_OP == (int)(this->variantT()));
223127 61 : post_construction_initialization();
223128 :
223129 : // Test the isSgDivideOp() function since it has been problematic
223130 61 : assert(isSgDivideOp(this) != NULL);
223131 61 : }
223132 :
223133 : // Generated constructor (all data members)
223134 :
223135 : /* #line 223136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223136 :
223137 :
223138 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
223139 :
223140 :
223141 : // ********************************************************
223142 : // member functions common across all array grammar objects
223143 : // ********************************************************
223144 :
223145 :
223146 :
223147 : /* #line 223148 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223148 :
223149 :
223150 :
223151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
223152 :
223153 : // ********************************************************
223154 : // member functions specific to each node in the grammar
223155 : // ********************************************************
223156 :
223157 :
223158 : /* #line 223159 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223159 :
223160 : // Start of memberFunctionString
223161 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223162 :
223163 : void
223164 0 : SgIntegerDivideOp::post_construction_initialization()
223165 : {
223166 0 : }
223167 :
223168 :
223169 :
223170 : // End of memberFunctionString
223171 : // Start of memberFunctionString
223172 : /* #line 5103 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223173 :
223174 :
223175 :
223176 : // End of memberFunctionString
223177 : // Start of memberFunctionString
223178 : /* #line 8094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223179 :
223180 :
223181 : #if 0
223182 : #error "This code from SOURCE_ARITHMETIC_OPERATOR_EXPRESSION should not be used"
223183 :
223184 : // DQ (1/14/2006): set_type is removed
223185 : void
223186 : SgIntegerDivideOp::set_type()
223187 : {
223188 : assert(get_lhs_operand() != NULL);
223189 : assert(get_rhs_operand() != NULL);
223190 : SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
223191 : set_expression_type(op_type);
223192 : }
223193 : #endif
223194 :
223195 :
223196 :
223197 : // End of memberFunctionString
223198 : // Start of memberFunctionString
223199 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
223200 :
223201 : // *** COMMON CODE SECTION BEGINS HERE ***
223202 :
223203 : #if 0
223204 : int
223205 : SgIntegerDivideOp::getVariant() const
223206 : {
223207 : // This function is used in ROSE while "variant()" is used in SAGE
223208 : assert(this != NULL);
223209 : return variant();
223210 : }
223211 : #endif
223212 :
223213 : // This function is used in ROSE in treeTraversal code
223214 : // eventually replaces getVariant() and variant()
223215 : // though after variant() has been removed for a while we will
223216 : // want to change the name of variantT() back to variant()
223217 : // (since the "T" was ment to stand for temporary).
223218 : // When this happens the variantT() will be depricated.
223219 : VariantT
223220 0 : SgIntegerDivideOp::variantT() const
223221 : {
223222 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
223223 0 : ROSE_ASSERT(this != NULL);
223224 0 : return V_SgIntegerDivideOp;
223225 : }
223226 :
223227 : #if 0
223228 : int
223229 : SgIntegerDivideOp::variant() const
223230 : {
223231 : // This function is used in SAGE
223232 : ROSE_ASSERT(this != NULL);
223233 : return INTEGER_DIV_OP;
223234 : }
223235 : #endif
223236 :
223237 : ROSE_DLL_API const char*
223238 0 : SgIntegerDivideOp::sage_class_name() const
223239 : {
223240 0 : ROSE_ASSERT(this != NULL);
223241 0 : return "SgIntegerDivideOp";
223242 : }
223243 :
223244 : std::string
223245 0 : SgIntegerDivideOp::class_name() const
223246 : {
223247 0 : ROSE_ASSERT(this != NULL);
223248 0 : return "SgIntegerDivideOp";
223249 : }
223250 :
223251 : // DQ (11/26/2005): Support for visitor pattern mechanims
223252 : // (inferior to ROSE traversal mechanism, experimental).
223253 : void
223254 0 : SgIntegerDivideOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
223255 : {
223256 0 : ROSE_ASSERT(this != NULL);
223257 0 : visitor.visit(this);
223258 0 : }
223259 :
223260 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
223261 0 : void SgIntegerDivideOp::accept (ROSE_VisitorPattern & visitor) {
223262 0 : ROSE_ASSERT(this != NULL);
223263 0 : visitor.visit(this);
223264 0 : }
223265 :
223266 : SgIntegerDivideOp*
223267 0 : SgIntegerDivideOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
223268 : {
223269 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
223270 : // This function is currently only supported for the AST used the represent Binary executables.
223271 : if (0 /* isSgAsmNode(this) != NULL */)
223272 : {
223273 : // Support for regex specification.
223274 : std::string prefixCode = "REGEX:";
223275 : addNewAttribute(prefixCode + s,a);
223276 : }
223277 : #endif
223278 :
223279 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
223280 0 : return this;
223281 : }
223282 :
223283 : // *** COMMON CODE SECTION ENDS HERE ***
223284 :
223285 :
223286 : // End of memberFunctionString
223287 : // Start of memberFunctionString
223288 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
223289 :
223290 :
223291 : #if 0
223292 : //! Error checking support
223293 : /*! Verifies the following:
223294 : - working getVariant() member function
223295 : - calls base class's error() member function
223296 : Every class has one of these functions.
223297 : */
223298 : bool
223299 : SgIntegerDivideOp::error()
223300 : {
223301 : // Put error checking here
223302 :
223303 : ROSE_ASSERT (this != NULL);
223304 : if (getVariant() != INTEGER_DIV_OP)
223305 : {
223306 : printf ("Error in SgIntegerDivideOp::error(): SgIntegerDivideOp object has a %s variant \n",
223307 : Cxx_GrammarTerminalNames[getVariant()].name);
223308 : // printf ("Error in SgIntegerDivideOp::error() \n");
223309 : ROSE_ABORT();
223310 : }
223311 :
223312 : ROSE_ASSERT (getVariant() == INTEGER_DIV_OP);
223313 : return SgBinaryOp::error();
223314 : }
223315 : #endif
223316 :
223317 :
223318 :
223319 : // End of memberFunctionString
223320 :
223321 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
223322 :
223323 0 : SgIntegerDivideOp* isSgIntegerDivideOp ( SgNode* inputDerivedClassPointer )
223324 : {
223325 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223326 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223327 : // So to fix this we return NULL directly when the input is NULL and avoid the
223328 : // dynamic_cast in this case. This is likely a performance improvement as well.
223329 : // return dynamic_cast<SgIntegerDivideOp*>(inputDerivedClassPointer);
223330 : // Milind Chabbi (8/28/2013): isSgIntegerDivideOp uses table-driven castability instead of c++ default dynamic_cast
223331 : // this improves the running time performance by 10-20%.
223332 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIntegerDivideOp*>(inputDerivedClassPointer);
223333 0 : return IS_SgIntegerDivideOp_FAST_MACRO(inputDerivedClassPointer);
223334 : }
223335 :
223336 : // DQ (11/8/2003): Added version of functions taking const pointer
223337 0 : const SgIntegerDivideOp* isSgIntegerDivideOp ( const SgNode* inputDerivedClassPointer )
223338 : {
223339 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223340 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223341 : // So to fix this we return NULL directly when the input is NULL and avoid the
223342 : // dynamic_cast in this case. This is likely a performance improvement as well.
223343 : // return dynamic_cast<const SgIntegerDivideOp*>(inputDerivedClassPointer);
223344 : // Milind Chabbi (8/28/2013): isSgIntegerDivideOp uses table-driven castability instead of c++ default dynamic_cast
223345 : // this improves the running time performance by 10-20%.
223346 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIntegerDivideOp*>(inputDerivedClassPointer);
223347 0 : return IS_SgIntegerDivideOp_FAST_MACRO(inputDerivedClassPointer);
223348 : }
223349 :
223350 :
223351 :
223352 : /* #line 223353 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223353 :
223354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223355 :
223356 : /**
223357 : \brief Generated destructor
223358 :
223359 : This destructor is automatically generated (by ROSETTA). This destructor
223360 : only frees memory of data members associated with the parts of the current IR node which
223361 : are NOT traversed. Those data members that are part of a traversal can be freed using
223362 : a traversal (calling this destructor on all children in a post-order traversal). Such
223363 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
223364 :
223365 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
223366 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
223367 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
223368 :
223369 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
223370 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
223371 : pointers are not yet implemented to call delete on eash pointer in the container.
223372 : (This could be done by derivation from the STL containers to define containers that
223373 : automatically deleted their members.)
223374 :
223375 : */
223376 0 : SgIntegerDivideOp::~SgIntegerDivideOp () {
223377 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
223378 :
223379 :
223380 :
223381 : }
223382 :
223383 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223384 0 : }
223385 :
223386 :
223387 : /* #line 223388 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223388 :
223389 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
223390 :
223391 : // Generated constructor
223392 0 : SgIntegerDivideOp::SgIntegerDivideOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
223393 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
223394 : {
223395 : #ifdef DEBUG
223396 : // printf ("In SgIntegerDivideOp::SgIntegerDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
223397 : #endif
223398 : #if 0
223399 : // debugging information!
223400 : printf ("In SgIntegerDivideOp::SgIntegerDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
223401 : #endif
223402 :
223403 :
223404 :
223405 : #if 0
223406 : // DQ (7/30/2014): Call a virtual function.
223407 : std::string s = this->class_name();
223408 : #endif
223409 :
223410 : // Test the variant virtual function
223411 : // assert(INTEGER_DIV_OP == variant());
223412 0 : assert(INTEGER_DIV_OP == this->variant());
223413 0 : ROSE_ASSERT(INTEGER_DIV_OP == (int)(this->variantT()));
223414 0 : post_construction_initialization();
223415 :
223416 : // Test the isSgIntegerDivideOp() function since it has been problematic
223417 0 : assert(isSgIntegerDivideOp(this) != NULL);
223418 0 : }
223419 :
223420 : // Generated constructor (all data members)
223421 :
223422 : /* #line 223423 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223423 :
223424 :
223425 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
223426 :
223427 :
223428 : // ********************************************************
223429 : // member functions common across all array grammar objects
223430 : // ********************************************************
223431 :
223432 :
223433 :
223434 : /* #line 223435 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223435 :
223436 :
223437 :
223438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
223439 :
223440 : // ********************************************************
223441 : // member functions specific to each node in the grammar
223442 : // ********************************************************
223443 :
223444 :
223445 : /* #line 223446 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223446 :
223447 : // Start of memberFunctionString
223448 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223449 :
223450 : void
223451 108 : SgModOp::post_construction_initialization()
223452 : {
223453 108 : }
223454 :
223455 :
223456 :
223457 : // End of memberFunctionString
223458 : // Start of memberFunctionString
223459 : /* #line 5107 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223460 :
223461 :
223462 :
223463 : // End of memberFunctionString
223464 : // Start of memberFunctionString
223465 : /* #line 8094 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223466 :
223467 :
223468 : #if 0
223469 : #error "This code from SOURCE_ARITHMETIC_OPERATOR_EXPRESSION should not be used"
223470 :
223471 : // DQ (1/14/2006): set_type is removed
223472 : void
223473 : SgModOp::set_type()
223474 : {
223475 : assert(get_lhs_operand() != NULL);
223476 : assert(get_rhs_operand() != NULL);
223477 : SgType * op_type = SgType::arithmetic_conversions(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
223478 : set_expression_type(op_type);
223479 : }
223480 : #endif
223481 :
223482 :
223483 :
223484 : // End of memberFunctionString
223485 : // Start of memberFunctionString
223486 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
223487 :
223488 : // *** COMMON CODE SECTION BEGINS HERE ***
223489 :
223490 : #if 0
223491 : int
223492 : SgModOp::getVariant() const
223493 : {
223494 : // This function is used in ROSE while "variant()" is used in SAGE
223495 : assert(this != NULL);
223496 : return variant();
223497 : }
223498 : #endif
223499 :
223500 : // This function is used in ROSE in treeTraversal code
223501 : // eventually replaces getVariant() and variant()
223502 : // though after variant() has been removed for a while we will
223503 : // want to change the name of variantT() back to variant()
223504 : // (since the "T" was ment to stand for temporary).
223505 : // When this happens the variantT() will be depricated.
223506 : VariantT
223507 53602 : SgModOp::variantT() const
223508 : {
223509 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
223510 53602 : ROSE_ASSERT(this != NULL);
223511 53602 : return V_SgModOp;
223512 : }
223513 :
223514 : #if 0
223515 : int
223516 : SgModOp::variant() const
223517 : {
223518 : // This function is used in SAGE
223519 : ROSE_ASSERT(this != NULL);
223520 : return MOD_OP;
223521 : }
223522 : #endif
223523 :
223524 : ROSE_DLL_API const char*
223525 3 : SgModOp::sage_class_name() const
223526 : {
223527 3 : ROSE_ASSERT(this != NULL);
223528 3 : return "SgModOp";
223529 : }
223530 :
223531 : std::string
223532 67 : SgModOp::class_name() const
223533 : {
223534 67 : ROSE_ASSERT(this != NULL);
223535 67 : return "SgModOp";
223536 : }
223537 :
223538 : // DQ (11/26/2005): Support for visitor pattern mechanims
223539 : // (inferior to ROSE traversal mechanism, experimental).
223540 : void
223541 822 : SgModOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
223542 : {
223543 822 : ROSE_ASSERT(this != NULL);
223544 822 : visitor.visit(this);
223545 822 : }
223546 :
223547 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
223548 0 : void SgModOp::accept (ROSE_VisitorPattern & visitor) {
223549 0 : ROSE_ASSERT(this != NULL);
223550 0 : visitor.visit(this);
223551 0 : }
223552 :
223553 : SgModOp*
223554 0 : SgModOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
223555 : {
223556 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
223557 : // This function is currently only supported for the AST used the represent Binary executables.
223558 : if (0 /* isSgAsmNode(this) != NULL */)
223559 : {
223560 : // Support for regex specification.
223561 : std::string prefixCode = "REGEX:";
223562 : addNewAttribute(prefixCode + s,a);
223563 : }
223564 : #endif
223565 :
223566 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
223567 0 : return this;
223568 : }
223569 :
223570 : // *** COMMON CODE SECTION ENDS HERE ***
223571 :
223572 :
223573 : // End of memberFunctionString
223574 : // Start of memberFunctionString
223575 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
223576 :
223577 :
223578 : #if 0
223579 : //! Error checking support
223580 : /*! Verifies the following:
223581 : - working getVariant() member function
223582 : - calls base class's error() member function
223583 : Every class has one of these functions.
223584 : */
223585 : bool
223586 : SgModOp::error()
223587 : {
223588 : // Put error checking here
223589 :
223590 : ROSE_ASSERT (this != NULL);
223591 : if (getVariant() != MOD_OP)
223592 : {
223593 : printf ("Error in SgModOp::error(): SgModOp object has a %s variant \n",
223594 : Cxx_GrammarTerminalNames[getVariant()].name);
223595 : // printf ("Error in SgModOp::error() \n");
223596 : ROSE_ABORT();
223597 : }
223598 :
223599 : ROSE_ASSERT (getVariant() == MOD_OP);
223600 : return SgBinaryOp::error();
223601 : }
223602 : #endif
223603 :
223604 :
223605 :
223606 : // End of memberFunctionString
223607 :
223608 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
223609 :
223610 108 : SgModOp* isSgModOp ( SgNode* inputDerivedClassPointer )
223611 : {
223612 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223613 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223614 : // So to fix this we return NULL directly when the input is NULL and avoid the
223615 : // dynamic_cast in this case. This is likely a performance improvement as well.
223616 : // return dynamic_cast<SgModOp*>(inputDerivedClassPointer);
223617 : // Milind Chabbi (8/28/2013): isSgModOp uses table-driven castability instead of c++ default dynamic_cast
223618 : // this improves the running time performance by 10-20%.
223619 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModOp*>(inputDerivedClassPointer);
223620 108 : return IS_SgModOp_FAST_MACRO(inputDerivedClassPointer);
223621 : }
223622 :
223623 : // DQ (11/8/2003): Added version of functions taking const pointer
223624 0 : const SgModOp* isSgModOp ( const SgNode* inputDerivedClassPointer )
223625 : {
223626 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223627 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223628 : // So to fix this we return NULL directly when the input is NULL and avoid the
223629 : // dynamic_cast in this case. This is likely a performance improvement as well.
223630 : // return dynamic_cast<const SgModOp*>(inputDerivedClassPointer);
223631 : // Milind Chabbi (8/28/2013): isSgModOp uses table-driven castability instead of c++ default dynamic_cast
223632 : // this improves the running time performance by 10-20%.
223633 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModOp*>(inputDerivedClassPointer);
223634 0 : return IS_SgModOp_FAST_MACRO(inputDerivedClassPointer);
223635 : }
223636 :
223637 :
223638 :
223639 : /* #line 223640 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223640 :
223641 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223642 :
223643 : /**
223644 : \brief Generated destructor
223645 :
223646 : This destructor is automatically generated (by ROSETTA). This destructor
223647 : only frees memory of data members associated with the parts of the current IR node which
223648 : are NOT traversed. Those data members that are part of a traversal can be freed using
223649 : a traversal (calling this destructor on all children in a post-order traversal). Such
223650 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
223651 :
223652 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
223653 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
223654 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
223655 :
223656 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
223657 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
223658 : pointers are not yet implemented to call delete on eash pointer in the container.
223659 : (This could be done by derivation from the STL containers to define containers that
223660 : automatically deleted their members.)
223661 :
223662 : */
223663 20 : SgModOp::~SgModOp () {
223664 10 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
223665 :
223666 :
223667 :
223668 : }
223669 :
223670 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223671 20 : }
223672 :
223673 :
223674 : /* #line 223675 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223675 :
223676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
223677 :
223678 : // Generated constructor
223679 0 : SgModOp::SgModOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
223680 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
223681 : {
223682 : #ifdef DEBUG
223683 : // printf ("In SgModOp::SgModOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
223684 : #endif
223685 : #if 0
223686 : // debugging information!
223687 : printf ("In SgModOp::SgModOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
223688 : #endif
223689 :
223690 :
223691 :
223692 : #if 0
223693 : // DQ (7/30/2014): Call a virtual function.
223694 : std::string s = this->class_name();
223695 : #endif
223696 :
223697 : // Test the variant virtual function
223698 : // assert(MOD_OP == variant());
223699 0 : assert(MOD_OP == this->variant());
223700 0 : ROSE_ASSERT(MOD_OP == (int)(this->variantT()));
223701 0 : post_construction_initialization();
223702 :
223703 : // Test the isSgModOp() function since it has been problematic
223704 0 : assert(isSgModOp(this) != NULL);
223705 0 : }
223706 :
223707 : // Generated constructor (all data members)
223708 :
223709 : /* #line 223710 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223710 :
223711 :
223712 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
223713 :
223714 :
223715 : // ********************************************************
223716 : // member functions common across all array grammar objects
223717 : // ********************************************************
223718 :
223719 :
223720 :
223721 : /* #line 223722 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223722 :
223723 :
223724 :
223725 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
223726 :
223727 : // ********************************************************
223728 : // member functions specific to each node in the grammar
223729 : // ********************************************************
223730 :
223731 :
223732 : /* #line 223733 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223733 :
223734 : // Start of memberFunctionString
223735 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223736 :
223737 : void
223738 1791 : SgAndOp::post_construction_initialization()
223739 : {
223740 1791 : }
223741 :
223742 :
223743 :
223744 : // End of memberFunctionString
223745 : // Start of memberFunctionString
223746 : /* #line 5201 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223747 :
223748 :
223749 : SgType*
223750 1529 : SgAndOp::get_type() const
223751 : {
223752 : // This function returns an integer representing the logical type
223753 :
223754 : #if 0
223755 : printf ("In SgAndOp::get_type() \n");
223756 : #endif
223757 :
223758 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
223759 : // DQ (7/20/2006): Modified to remove redundant SgTypeInt qualifier.
223760 : // SgType* returnType = SgTypeInt::SgTypeInt::createType();
223761 1529 : SgType* returnType = SgTypeInt::createType();
223762 :
223763 1529 : ROSE_ASSERT(returnType != NULL);
223764 1529 : return returnType;
223765 : }
223766 :
223767 :
223768 :
223769 : // End of memberFunctionString
223770 : // Start of memberFunctionString
223771 : /* #line 8116 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
223772 :
223773 :
223774 : #if 0
223775 : #error "This code from SOURCE_INTEGER_OPERATOR_EXPRESSION should not be used"
223776 :
223777 : // DQ (1/14/2006): set_type is removed
223778 : void
223779 : SgAndOp::set_type()
223780 : {
223781 : set_expression_type(SgTypeInt::createType());
223782 : }
223783 : #endif
223784 :
223785 :
223786 :
223787 : // End of memberFunctionString
223788 : // Start of memberFunctionString
223789 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
223790 :
223791 : // *** COMMON CODE SECTION BEGINS HERE ***
223792 :
223793 : #if 0
223794 : int
223795 : SgAndOp::getVariant() const
223796 : {
223797 : // This function is used in ROSE while "variant()" is used in SAGE
223798 : assert(this != NULL);
223799 : return variant();
223800 : }
223801 : #endif
223802 :
223803 : // This function is used in ROSE in treeTraversal code
223804 : // eventually replaces getVariant() and variant()
223805 : // though after variant() has been removed for a while we will
223806 : // want to change the name of variantT() back to variant()
223807 : // (since the "T" was ment to stand for temporary).
223808 : // When this happens the variantT() will be depricated.
223809 : VariantT
223810 595884 : SgAndOp::variantT() const
223811 : {
223812 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
223813 595884 : ROSE_ASSERT(this != NULL);
223814 595884 : return V_SgAndOp;
223815 : }
223816 :
223817 : #if 0
223818 : int
223819 : SgAndOp::variant() const
223820 : {
223821 : // This function is used in SAGE
223822 : ROSE_ASSERT(this != NULL);
223823 : return AND_OP;
223824 : }
223825 : #endif
223826 :
223827 : ROSE_DLL_API const char*
223828 21 : SgAndOp::sage_class_name() const
223829 : {
223830 21 : ROSE_ASSERT(this != NULL);
223831 21 : return "SgAndOp";
223832 : }
223833 :
223834 : std::string
223835 1520 : SgAndOp::class_name() const
223836 : {
223837 1520 : ROSE_ASSERT(this != NULL);
223838 1520 : return "SgAndOp";
223839 : }
223840 :
223841 : // DQ (11/26/2005): Support for visitor pattern mechanims
223842 : // (inferior to ROSE traversal mechanism, experimental).
223843 : void
223844 24153 : SgAndOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
223845 : {
223846 24153 : ROSE_ASSERT(this != NULL);
223847 24153 : visitor.visit(this);
223848 24153 : }
223849 :
223850 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
223851 0 : void SgAndOp::accept (ROSE_VisitorPattern & visitor) {
223852 0 : ROSE_ASSERT(this != NULL);
223853 0 : visitor.visit(this);
223854 0 : }
223855 :
223856 : SgAndOp*
223857 0 : SgAndOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
223858 : {
223859 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
223860 : // This function is currently only supported for the AST used the represent Binary executables.
223861 : if (0 /* isSgAsmNode(this) != NULL */)
223862 : {
223863 : // Support for regex specification.
223864 : std::string prefixCode = "REGEX:";
223865 : addNewAttribute(prefixCode + s,a);
223866 : }
223867 : #endif
223868 :
223869 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
223870 0 : return this;
223871 : }
223872 :
223873 : // *** COMMON CODE SECTION ENDS HERE ***
223874 :
223875 :
223876 : // End of memberFunctionString
223877 : // Start of memberFunctionString
223878 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
223879 :
223880 :
223881 : #if 0
223882 : //! Error checking support
223883 : /*! Verifies the following:
223884 : - working getVariant() member function
223885 : - calls base class's error() member function
223886 : Every class has one of these functions.
223887 : */
223888 : bool
223889 : SgAndOp::error()
223890 : {
223891 : // Put error checking here
223892 :
223893 : ROSE_ASSERT (this != NULL);
223894 : if (getVariant() != AND_OP)
223895 : {
223896 : printf ("Error in SgAndOp::error(): SgAndOp object has a %s variant \n",
223897 : Cxx_GrammarTerminalNames[getVariant()].name);
223898 : // printf ("Error in SgAndOp::error() \n");
223899 : ROSE_ABORT();
223900 : }
223901 :
223902 : ROSE_ASSERT (getVariant() == AND_OP);
223903 : return SgBinaryOp::error();
223904 : }
223905 : #endif
223906 :
223907 :
223908 :
223909 : // End of memberFunctionString
223910 :
223911 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
223912 :
223913 1791 : SgAndOp* isSgAndOp ( SgNode* inputDerivedClassPointer )
223914 : {
223915 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223916 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223917 : // So to fix this we return NULL directly when the input is NULL and avoid the
223918 : // dynamic_cast in this case. This is likely a performance improvement as well.
223919 : // return dynamic_cast<SgAndOp*>(inputDerivedClassPointer);
223920 : // Milind Chabbi (8/28/2013): isSgAndOp uses table-driven castability instead of c++ default dynamic_cast
223921 : // this improves the running time performance by 10-20%.
223922 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAndOp*>(inputDerivedClassPointer);
223923 1791 : return IS_SgAndOp_FAST_MACRO(inputDerivedClassPointer);
223924 : }
223925 :
223926 : // DQ (11/8/2003): Added version of functions taking const pointer
223927 0 : const SgAndOp* isSgAndOp ( const SgNode* inputDerivedClassPointer )
223928 : {
223929 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
223930 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
223931 : // So to fix this we return NULL directly when the input is NULL and avoid the
223932 : // dynamic_cast in this case. This is likely a performance improvement as well.
223933 : // return dynamic_cast<const SgAndOp*>(inputDerivedClassPointer);
223934 : // Milind Chabbi (8/28/2013): isSgAndOp uses table-driven castability instead of c++ default dynamic_cast
223935 : // this improves the running time performance by 10-20%.
223936 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAndOp*>(inputDerivedClassPointer);
223937 0 : return IS_SgAndOp_FAST_MACRO(inputDerivedClassPointer);
223938 : }
223939 :
223940 :
223941 :
223942 : /* #line 223943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223943 :
223944 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223945 :
223946 : /**
223947 : \brief Generated destructor
223948 :
223949 : This destructor is automatically generated (by ROSETTA). This destructor
223950 : only frees memory of data members associated with the parts of the current IR node which
223951 : are NOT traversed. Those data members that are part of a traversal can be freed using
223952 : a traversal (calling this destructor on all children in a post-order traversal). Such
223953 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
223954 :
223955 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
223956 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
223957 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
223958 :
223959 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
223960 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
223961 : pointers are not yet implemented to call delete on eash pointer in the container.
223962 : (This could be done by derivation from the STL containers to define containers that
223963 : automatically deleted their members.)
223964 :
223965 : */
223966 772 : SgAndOp::~SgAndOp () {
223967 386 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
223968 :
223969 :
223970 :
223971 : }
223972 :
223973 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
223974 772 : }
223975 :
223976 :
223977 : /* #line 223978 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
223978 :
223979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
223980 :
223981 : // Generated constructor
223982 200 : SgAndOp::SgAndOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
223983 200 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
223984 : {
223985 : #ifdef DEBUG
223986 : // printf ("In SgAndOp::SgAndOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
223987 : #endif
223988 : #if 0
223989 : // debugging information!
223990 : printf ("In SgAndOp::SgAndOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
223991 : #endif
223992 :
223993 :
223994 :
223995 : #if 0
223996 : // DQ (7/30/2014): Call a virtual function.
223997 : std::string s = this->class_name();
223998 : #endif
223999 :
224000 : // Test the variant virtual function
224001 : // assert(AND_OP == variant());
224002 200 : assert(AND_OP == this->variant());
224003 200 : ROSE_ASSERT(AND_OP == (int)(this->variantT()));
224004 200 : post_construction_initialization();
224005 :
224006 : // Test the isSgAndOp() function since it has been problematic
224007 200 : assert(isSgAndOp(this) != NULL);
224008 200 : }
224009 :
224010 : // Generated constructor (all data members)
224011 :
224012 : /* #line 224013 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224013 :
224014 :
224015 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224016 :
224017 :
224018 : // ********************************************************
224019 : // member functions common across all array grammar objects
224020 : // ********************************************************
224021 :
224022 :
224023 :
224024 : /* #line 224025 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224025 :
224026 :
224027 :
224028 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224029 :
224030 : // ********************************************************
224031 : // member functions specific to each node in the grammar
224032 : // ********************************************************
224033 :
224034 :
224035 : /* #line 224036 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224036 :
224037 : // Start of memberFunctionString
224038 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224039 :
224040 : void
224041 808 : SgOrOp::post_construction_initialization()
224042 : {
224043 808 : }
224044 :
224045 :
224046 :
224047 : // End of memberFunctionString
224048 : // Start of memberFunctionString
224049 : /* #line 5224 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224050 :
224051 :
224052 : SgType*
224053 755 : SgOrOp::get_type() const
224054 : {
224055 : // This function returns an integer representing the logical type
224056 :
224057 : #if 0
224058 : printf ("In SgOrOp::get_type() \n");
224059 : #endif
224060 :
224061 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
224062 : // DQ (7/20/2006): Modified to remove redundant SgTypeInt qualifier.
224063 755 : SgType* returnType = SgTypeInt::createType();
224064 :
224065 755 : ROSE_ASSERT(returnType != NULL);
224066 755 : return returnType;
224067 : }
224068 :
224069 :
224070 :
224071 : // End of memberFunctionString
224072 : // Start of memberFunctionString
224073 : /* #line 8116 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224074 :
224075 :
224076 : #if 0
224077 : #error "This code from SOURCE_INTEGER_OPERATOR_EXPRESSION should not be used"
224078 :
224079 : // DQ (1/14/2006): set_type is removed
224080 : void
224081 : SgOrOp::set_type()
224082 : {
224083 : set_expression_type(SgTypeInt::createType());
224084 : }
224085 : #endif
224086 :
224087 :
224088 :
224089 : // End of memberFunctionString
224090 : // Start of memberFunctionString
224091 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
224092 :
224093 : // *** COMMON CODE SECTION BEGINS HERE ***
224094 :
224095 : #if 0
224096 : int
224097 : SgOrOp::getVariant() const
224098 : {
224099 : // This function is used in ROSE while "variant()" is used in SAGE
224100 : assert(this != NULL);
224101 : return variant();
224102 : }
224103 : #endif
224104 :
224105 : // This function is used in ROSE in treeTraversal code
224106 : // eventually replaces getVariant() and variant()
224107 : // though after variant() has been removed for a while we will
224108 : // want to change the name of variantT() back to variant()
224109 : // (since the "T" was ment to stand for temporary).
224110 : // When this happens the variantT() will be depricated.
224111 : VariantT
224112 254322 : SgOrOp::variantT() const
224113 : {
224114 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
224115 254322 : ROSE_ASSERT(this != NULL);
224116 254322 : return V_SgOrOp;
224117 : }
224118 :
224119 : #if 0
224120 : int
224121 : SgOrOp::variant() const
224122 : {
224123 : // This function is used in SAGE
224124 : ROSE_ASSERT(this != NULL);
224125 : return OR_OP;
224126 : }
224127 : #endif
224128 :
224129 : ROSE_DLL_API const char*
224130 64 : SgOrOp::sage_class_name() const
224131 : {
224132 64 : ROSE_ASSERT(this != NULL);
224133 64 : return "SgOrOp";
224134 : }
224135 :
224136 : std::string
224137 709 : SgOrOp::class_name() const
224138 : {
224139 709 : ROSE_ASSERT(this != NULL);
224140 709 : return "SgOrOp";
224141 : }
224142 :
224143 : // DQ (11/26/2005): Support for visitor pattern mechanims
224144 : // (inferior to ROSE traversal mechanism, experimental).
224145 : void
224146 11571 : SgOrOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
224147 : {
224148 11571 : ROSE_ASSERT(this != NULL);
224149 11571 : visitor.visit(this);
224150 11571 : }
224151 :
224152 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
224153 0 : void SgOrOp::accept (ROSE_VisitorPattern & visitor) {
224154 0 : ROSE_ASSERT(this != NULL);
224155 0 : visitor.visit(this);
224156 0 : }
224157 :
224158 : SgOrOp*
224159 0 : SgOrOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
224160 : {
224161 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
224162 : // This function is currently only supported for the AST used the represent Binary executables.
224163 : if (0 /* isSgAsmNode(this) != NULL */)
224164 : {
224165 : // Support for regex specification.
224166 : std::string prefixCode = "REGEX:";
224167 : addNewAttribute(prefixCode + s,a);
224168 : }
224169 : #endif
224170 :
224171 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
224172 0 : return this;
224173 : }
224174 :
224175 : // *** COMMON CODE SECTION ENDS HERE ***
224176 :
224177 :
224178 : // End of memberFunctionString
224179 : // Start of memberFunctionString
224180 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
224181 :
224182 :
224183 : #if 0
224184 : //! Error checking support
224185 : /*! Verifies the following:
224186 : - working getVariant() member function
224187 : - calls base class's error() member function
224188 : Every class has one of these functions.
224189 : */
224190 : bool
224191 : SgOrOp::error()
224192 : {
224193 : // Put error checking here
224194 :
224195 : ROSE_ASSERT (this != NULL);
224196 : if (getVariant() != OR_OP)
224197 : {
224198 : printf ("Error in SgOrOp::error(): SgOrOp object has a %s variant \n",
224199 : Cxx_GrammarTerminalNames[getVariant()].name);
224200 : // printf ("Error in SgOrOp::error() \n");
224201 : ROSE_ABORT();
224202 : }
224203 :
224204 : ROSE_ASSERT (getVariant() == OR_OP);
224205 : return SgBinaryOp::error();
224206 : }
224207 : #endif
224208 :
224209 :
224210 :
224211 : // End of memberFunctionString
224212 :
224213 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
224214 :
224215 808 : SgOrOp* isSgOrOp ( SgNode* inputDerivedClassPointer )
224216 : {
224217 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
224218 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
224219 : // So to fix this we return NULL directly when the input is NULL and avoid the
224220 : // dynamic_cast in this case. This is likely a performance improvement as well.
224221 : // return dynamic_cast<SgOrOp*>(inputDerivedClassPointer);
224222 : // Milind Chabbi (8/28/2013): isSgOrOp uses table-driven castability instead of c++ default dynamic_cast
224223 : // this improves the running time performance by 10-20%.
224224 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgOrOp*>(inputDerivedClassPointer);
224225 808 : return IS_SgOrOp_FAST_MACRO(inputDerivedClassPointer);
224226 : }
224227 :
224228 : // DQ (11/8/2003): Added version of functions taking const pointer
224229 0 : const SgOrOp* isSgOrOp ( const SgNode* inputDerivedClassPointer )
224230 : {
224231 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
224232 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
224233 : // So to fix this we return NULL directly when the input is NULL and avoid the
224234 : // dynamic_cast in this case. This is likely a performance improvement as well.
224235 : // return dynamic_cast<const SgOrOp*>(inputDerivedClassPointer);
224236 : // Milind Chabbi (8/28/2013): isSgOrOp uses table-driven castability instead of c++ default dynamic_cast
224237 : // this improves the running time performance by 10-20%.
224238 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgOrOp*>(inputDerivedClassPointer);
224239 0 : return IS_SgOrOp_FAST_MACRO(inputDerivedClassPointer);
224240 : }
224241 :
224242 :
224243 :
224244 : /* #line 224245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224245 :
224246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
224247 :
224248 : /**
224249 : \brief Generated destructor
224250 :
224251 : This destructor is automatically generated (by ROSETTA). This destructor
224252 : only frees memory of data members associated with the parts of the current IR node which
224253 : are NOT traversed. Those data members that are part of a traversal can be freed using
224254 : a traversal (calling this destructor on all children in a post-order traversal). Such
224255 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
224256 :
224257 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
224258 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
224259 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
224260 :
224261 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
224262 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
224263 : pointers are not yet implemented to call delete on eash pointer in the container.
224264 : (This could be done by derivation from the STL containers to define containers that
224265 : automatically deleted their members.)
224266 :
224267 : */
224268 332 : SgOrOp::~SgOrOp () {
224269 166 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
224270 :
224271 :
224272 :
224273 : }
224274 :
224275 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
224276 332 : }
224277 :
224278 :
224279 : /* #line 224280 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224280 :
224281 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
224282 :
224283 : // Generated constructor
224284 92 : SgOrOp::SgOrOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
224285 92 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
224286 : {
224287 : #ifdef DEBUG
224288 : // printf ("In SgOrOp::SgOrOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
224289 : #endif
224290 : #if 0
224291 : // debugging information!
224292 : printf ("In SgOrOp::SgOrOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
224293 : #endif
224294 :
224295 :
224296 :
224297 : #if 0
224298 : // DQ (7/30/2014): Call a virtual function.
224299 : std::string s = this->class_name();
224300 : #endif
224301 :
224302 : // Test the variant virtual function
224303 : // assert(OR_OP == variant());
224304 92 : assert(OR_OP == this->variant());
224305 92 : ROSE_ASSERT(OR_OP == (int)(this->variantT()));
224306 92 : post_construction_initialization();
224307 :
224308 : // Test the isSgOrOp() function since it has been problematic
224309 92 : assert(isSgOrOp(this) != NULL);
224310 92 : }
224311 :
224312 : // Generated constructor (all data members)
224313 :
224314 : /* #line 224315 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224315 :
224316 :
224317 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224318 :
224319 :
224320 : // ********************************************************
224321 : // member functions common across all array grammar objects
224322 : // ********************************************************
224323 :
224324 :
224325 :
224326 : /* #line 224327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224327 :
224328 :
224329 :
224330 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224331 :
224332 : // ********************************************************
224333 : // member functions specific to each node in the grammar
224334 : // ********************************************************
224335 :
224336 :
224337 : /* #line 224338 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224338 :
224339 : // Start of memberFunctionString
224340 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224341 :
224342 : void
224343 52 : SgBitXorOp::post_construction_initialization()
224344 : {
224345 52 : }
224346 :
224347 :
224348 :
224349 : // End of memberFunctionString
224350 : // Start of memberFunctionString
224351 : /* #line 5246 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224352 :
224353 :
224354 :
224355 : // End of memberFunctionString
224356 : // Start of memberFunctionString
224357 : /* #line 8136 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224358 :
224359 :
224360 : #if 0
224361 : #error "This code from SOURCE_BIT_OPERATOR_EXPRESSION should not be used"
224362 :
224363 : // DQ (1/14/2006): set_type is removed
224364 : void
224365 : SgBitXorOp::set_type()
224366 : {
224367 : assert(get_lhs_operand() != NULL);
224368 : assert(get_rhs_operand() != NULL);
224369 : SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
224370 : assert(int_type != NULL);
224371 : set_expression_type(int_type);
224372 : }
224373 : #endif
224374 :
224375 :
224376 :
224377 : // End of memberFunctionString
224378 : // Start of memberFunctionString
224379 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
224380 :
224381 : // *** COMMON CODE SECTION BEGINS HERE ***
224382 :
224383 : #if 0
224384 : int
224385 : SgBitXorOp::getVariant() const
224386 : {
224387 : // This function is used in ROSE while "variant()" is used in SAGE
224388 : assert(this != NULL);
224389 : return variant();
224390 : }
224391 : #endif
224392 :
224393 : // This function is used in ROSE in treeTraversal code
224394 : // eventually replaces getVariant() and variant()
224395 : // though after variant() has been removed for a while we will
224396 : // want to change the name of variantT() back to variant()
224397 : // (since the "T" was ment to stand for temporary).
224398 : // When this happens the variantT() will be depricated.
224399 : VariantT
224400 8500 : SgBitXorOp::variantT() const
224401 : {
224402 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
224403 8500 : ROSE_ASSERT(this != NULL);
224404 8500 : return V_SgBitXorOp;
224405 : }
224406 :
224407 : #if 0
224408 : int
224409 : SgBitXorOp::variant() const
224410 : {
224411 : // This function is used in SAGE
224412 : ROSE_ASSERT(this != NULL);
224413 : return BITXOR_OP;
224414 : }
224415 : #endif
224416 :
224417 : ROSE_DLL_API const char*
224418 0 : SgBitXorOp::sage_class_name() const
224419 : {
224420 0 : ROSE_ASSERT(this != NULL);
224421 0 : return "SgBitXorOp";
224422 : }
224423 :
224424 : std::string
224425 46 : SgBitXorOp::class_name() const
224426 : {
224427 46 : ROSE_ASSERT(this != NULL);
224428 46 : return "SgBitXorOp";
224429 : }
224430 :
224431 : // DQ (11/26/2005): Support for visitor pattern mechanims
224432 : // (inferior to ROSE traversal mechanism, experimental).
224433 : void
224434 822 : SgBitXorOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
224435 : {
224436 822 : ROSE_ASSERT(this != NULL);
224437 822 : visitor.visit(this);
224438 822 : }
224439 :
224440 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
224441 0 : void SgBitXorOp::accept (ROSE_VisitorPattern & visitor) {
224442 0 : ROSE_ASSERT(this != NULL);
224443 0 : visitor.visit(this);
224444 0 : }
224445 :
224446 : SgBitXorOp*
224447 0 : SgBitXorOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
224448 : {
224449 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
224450 : // This function is currently only supported for the AST used the represent Binary executables.
224451 : if (0 /* isSgAsmNode(this) != NULL */)
224452 : {
224453 : // Support for regex specification.
224454 : std::string prefixCode = "REGEX:";
224455 : addNewAttribute(prefixCode + s,a);
224456 : }
224457 : #endif
224458 :
224459 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
224460 0 : return this;
224461 : }
224462 :
224463 : // *** COMMON CODE SECTION ENDS HERE ***
224464 :
224465 :
224466 : // End of memberFunctionString
224467 : // Start of memberFunctionString
224468 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
224469 :
224470 :
224471 : #if 0
224472 : //! Error checking support
224473 : /*! Verifies the following:
224474 : - working getVariant() member function
224475 : - calls base class's error() member function
224476 : Every class has one of these functions.
224477 : */
224478 : bool
224479 : SgBitXorOp::error()
224480 : {
224481 : // Put error checking here
224482 :
224483 : ROSE_ASSERT (this != NULL);
224484 : if (getVariant() != BITXOR_OP)
224485 : {
224486 : printf ("Error in SgBitXorOp::error(): SgBitXorOp object has a %s variant \n",
224487 : Cxx_GrammarTerminalNames[getVariant()].name);
224488 : // printf ("Error in SgBitXorOp::error() \n");
224489 : ROSE_ABORT();
224490 : }
224491 :
224492 : ROSE_ASSERT (getVariant() == BITXOR_OP);
224493 : return SgBinaryOp::error();
224494 : }
224495 : #endif
224496 :
224497 :
224498 :
224499 : // End of memberFunctionString
224500 :
224501 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
224502 :
224503 52 : SgBitXorOp* isSgBitXorOp ( SgNode* inputDerivedClassPointer )
224504 : {
224505 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
224506 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
224507 : // So to fix this we return NULL directly when the input is NULL and avoid the
224508 : // dynamic_cast in this case. This is likely a performance improvement as well.
224509 : // return dynamic_cast<SgBitXorOp*>(inputDerivedClassPointer);
224510 : // Milind Chabbi (8/28/2013): isSgBitXorOp uses table-driven castability instead of c++ default dynamic_cast
224511 : // this improves the running time performance by 10-20%.
224512 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBitXorOp*>(inputDerivedClassPointer);
224513 52 : return IS_SgBitXorOp_FAST_MACRO(inputDerivedClassPointer);
224514 : }
224515 :
224516 : // DQ (11/8/2003): Added version of functions taking const pointer
224517 0 : const SgBitXorOp* isSgBitXorOp ( const SgNode* inputDerivedClassPointer )
224518 : {
224519 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
224520 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
224521 : // So to fix this we return NULL directly when the input is NULL and avoid the
224522 : // dynamic_cast in this case. This is likely a performance improvement as well.
224523 : // return dynamic_cast<const SgBitXorOp*>(inputDerivedClassPointer);
224524 : // Milind Chabbi (8/28/2013): isSgBitXorOp uses table-driven castability instead of c++ default dynamic_cast
224525 : // this improves the running time performance by 10-20%.
224526 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBitXorOp*>(inputDerivedClassPointer);
224527 0 : return IS_SgBitXorOp_FAST_MACRO(inputDerivedClassPointer);
224528 : }
224529 :
224530 :
224531 :
224532 : /* #line 224533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224533 :
224534 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
224535 :
224536 : /**
224537 : \brief Generated destructor
224538 :
224539 : This destructor is automatically generated (by ROSETTA). This destructor
224540 : only frees memory of data members associated with the parts of the current IR node which
224541 : are NOT traversed. Those data members that are part of a traversal can be freed using
224542 : a traversal (calling this destructor on all children in a post-order traversal). Such
224543 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
224544 :
224545 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
224546 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
224547 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
224548 :
224549 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
224550 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
224551 : pointers are not yet implemented to call delete on eash pointer in the container.
224552 : (This could be done by derivation from the STL containers to define containers that
224553 : automatically deleted their members.)
224554 :
224555 : */
224556 24 : SgBitXorOp::~SgBitXorOp () {
224557 12 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
224558 :
224559 :
224560 :
224561 : }
224562 :
224563 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
224564 24 : }
224565 :
224566 :
224567 : /* #line 224568 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224568 :
224569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
224570 :
224571 : // Generated constructor
224572 0 : SgBitXorOp::SgBitXorOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
224573 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
224574 : {
224575 : #ifdef DEBUG
224576 : // printf ("In SgBitXorOp::SgBitXorOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
224577 : #endif
224578 : #if 0
224579 : // debugging information!
224580 : printf ("In SgBitXorOp::SgBitXorOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
224581 : #endif
224582 :
224583 :
224584 :
224585 : #if 0
224586 : // DQ (7/30/2014): Call a virtual function.
224587 : std::string s = this->class_name();
224588 : #endif
224589 :
224590 : // Test the variant virtual function
224591 : // assert(BITXOR_OP == variant());
224592 0 : assert(BITXOR_OP == this->variant());
224593 0 : ROSE_ASSERT(BITXOR_OP == (int)(this->variantT()));
224594 0 : post_construction_initialization();
224595 :
224596 : // Test the isSgBitXorOp() function since it has been problematic
224597 0 : assert(isSgBitXorOp(this) != NULL);
224598 0 : }
224599 :
224600 : // Generated constructor (all data members)
224601 :
224602 : /* #line 224603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224603 :
224604 :
224605 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224606 :
224607 :
224608 : // ********************************************************
224609 : // member functions common across all array grammar objects
224610 : // ********************************************************
224611 :
224612 :
224613 :
224614 : /* #line 224615 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224615 :
224616 :
224617 :
224618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224619 :
224620 : // ********************************************************
224621 : // member functions specific to each node in the grammar
224622 : // ********************************************************
224623 :
224624 :
224625 : /* #line 224626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224626 :
224627 : // Start of memberFunctionString
224628 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224629 :
224630 : void
224631 178 : SgBitAndOp::post_construction_initialization()
224632 : {
224633 178 : }
224634 :
224635 :
224636 :
224637 : // End of memberFunctionString
224638 : // Start of memberFunctionString
224639 : /* #line 5249 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224640 :
224641 :
224642 :
224643 : // End of memberFunctionString
224644 : // Start of memberFunctionString
224645 : /* #line 8136 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224646 :
224647 :
224648 : #if 0
224649 : #error "This code from SOURCE_BIT_OPERATOR_EXPRESSION should not be used"
224650 :
224651 : // DQ (1/14/2006): set_type is removed
224652 : void
224653 : SgBitAndOp::set_type()
224654 : {
224655 : assert(get_lhs_operand() != NULL);
224656 : assert(get_rhs_operand() != NULL);
224657 : SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
224658 : assert(int_type != NULL);
224659 : set_expression_type(int_type);
224660 : }
224661 : #endif
224662 :
224663 :
224664 :
224665 : // End of memberFunctionString
224666 : // Start of memberFunctionString
224667 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
224668 :
224669 : // *** COMMON CODE SECTION BEGINS HERE ***
224670 :
224671 : #if 0
224672 : int
224673 : SgBitAndOp::getVariant() const
224674 : {
224675 : // This function is used in ROSE while "variant()" is used in SAGE
224676 : assert(this != NULL);
224677 : return variant();
224678 : }
224679 : #endif
224680 :
224681 : // This function is used in ROSE in treeTraversal code
224682 : // eventually replaces getVariant() and variant()
224683 : // though after variant() has been removed for a while we will
224684 : // want to change the name of variantT() back to variant()
224685 : // (since the "T" was ment to stand for temporary).
224686 : // When this happens the variantT() will be depricated.
224687 : VariantT
224688 41353 : SgBitAndOp::variantT() const
224689 : {
224690 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
224691 41353 : ROSE_ASSERT(this != NULL);
224692 41353 : return V_SgBitAndOp;
224693 : }
224694 :
224695 : #if 0
224696 : int
224697 : SgBitAndOp::variant() const
224698 : {
224699 : // This function is used in SAGE
224700 : ROSE_ASSERT(this != NULL);
224701 : return BITAND_OP;
224702 : }
224703 : #endif
224704 :
224705 : ROSE_DLL_API const char*
224706 0 : SgBitAndOp::sage_class_name() const
224707 : {
224708 0 : ROSE_ASSERT(this != NULL);
224709 0 : return "SgBitAndOp";
224710 : }
224711 :
224712 : std::string
224713 156 : SgBitAndOp::class_name() const
224714 : {
224715 156 : ROSE_ASSERT(this != NULL);
224716 156 : return "SgBitAndOp";
224717 : }
224718 :
224719 : // DQ (11/26/2005): Support for visitor pattern mechanims
224720 : // (inferior to ROSE traversal mechanism, experimental).
224721 : void
224722 2780 : SgBitAndOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
224723 : {
224724 2780 : ROSE_ASSERT(this != NULL);
224725 2780 : visitor.visit(this);
224726 2780 : }
224727 :
224728 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
224729 0 : void SgBitAndOp::accept (ROSE_VisitorPattern & visitor) {
224730 0 : ROSE_ASSERT(this != NULL);
224731 0 : visitor.visit(this);
224732 0 : }
224733 :
224734 : SgBitAndOp*
224735 0 : SgBitAndOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
224736 : {
224737 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
224738 : // This function is currently only supported for the AST used the represent Binary executables.
224739 : if (0 /* isSgAsmNode(this) != NULL */)
224740 : {
224741 : // Support for regex specification.
224742 : std::string prefixCode = "REGEX:";
224743 : addNewAttribute(prefixCode + s,a);
224744 : }
224745 : #endif
224746 :
224747 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
224748 0 : return this;
224749 : }
224750 :
224751 : // *** COMMON CODE SECTION ENDS HERE ***
224752 :
224753 :
224754 : // End of memberFunctionString
224755 : // Start of memberFunctionString
224756 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
224757 :
224758 :
224759 : #if 0
224760 : //! Error checking support
224761 : /*! Verifies the following:
224762 : - working getVariant() member function
224763 : - calls base class's error() member function
224764 : Every class has one of these functions.
224765 : */
224766 : bool
224767 : SgBitAndOp::error()
224768 : {
224769 : // Put error checking here
224770 :
224771 : ROSE_ASSERT (this != NULL);
224772 : if (getVariant() != BITAND_OP)
224773 : {
224774 : printf ("Error in SgBitAndOp::error(): SgBitAndOp object has a %s variant \n",
224775 : Cxx_GrammarTerminalNames[getVariant()].name);
224776 : // printf ("Error in SgBitAndOp::error() \n");
224777 : ROSE_ABORT();
224778 : }
224779 :
224780 : ROSE_ASSERT (getVariant() == BITAND_OP);
224781 : return SgBinaryOp::error();
224782 : }
224783 : #endif
224784 :
224785 :
224786 :
224787 : // End of memberFunctionString
224788 :
224789 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
224790 :
224791 178 : SgBitAndOp* isSgBitAndOp ( SgNode* inputDerivedClassPointer )
224792 : {
224793 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
224794 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
224795 : // So to fix this we return NULL directly when the input is NULL and avoid the
224796 : // dynamic_cast in this case. This is likely a performance improvement as well.
224797 : // return dynamic_cast<SgBitAndOp*>(inputDerivedClassPointer);
224798 : // Milind Chabbi (8/28/2013): isSgBitAndOp uses table-driven castability instead of c++ default dynamic_cast
224799 : // this improves the running time performance by 10-20%.
224800 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBitAndOp*>(inputDerivedClassPointer);
224801 178 : return IS_SgBitAndOp_FAST_MACRO(inputDerivedClassPointer);
224802 : }
224803 :
224804 : // DQ (11/8/2003): Added version of functions taking const pointer
224805 0 : const SgBitAndOp* isSgBitAndOp ( const SgNode* inputDerivedClassPointer )
224806 : {
224807 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
224808 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
224809 : // So to fix this we return NULL directly when the input is NULL and avoid the
224810 : // dynamic_cast in this case. This is likely a performance improvement as well.
224811 : // return dynamic_cast<const SgBitAndOp*>(inputDerivedClassPointer);
224812 : // Milind Chabbi (8/28/2013): isSgBitAndOp uses table-driven castability instead of c++ default dynamic_cast
224813 : // this improves the running time performance by 10-20%.
224814 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBitAndOp*>(inputDerivedClassPointer);
224815 0 : return IS_SgBitAndOp_FAST_MACRO(inputDerivedClassPointer);
224816 : }
224817 :
224818 :
224819 :
224820 : /* #line 224821 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224821 :
224822 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
224823 :
224824 : /**
224825 : \brief Generated destructor
224826 :
224827 : This destructor is automatically generated (by ROSETTA). This destructor
224828 : only frees memory of data members associated with the parts of the current IR node which
224829 : are NOT traversed. Those data members that are part of a traversal can be freed using
224830 : a traversal (calling this destructor on all children in a post-order traversal). Such
224831 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
224832 :
224833 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
224834 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
224835 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
224836 :
224837 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
224838 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
224839 : pointers are not yet implemented to call delete on eash pointer in the container.
224840 : (This could be done by derivation from the STL containers to define containers that
224841 : automatically deleted their members.)
224842 :
224843 : */
224844 80 : SgBitAndOp::~SgBitAndOp () {
224845 40 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
224846 :
224847 :
224848 :
224849 : }
224850 :
224851 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
224852 80 : }
224853 :
224854 :
224855 : /* #line 224856 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224856 :
224857 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
224858 :
224859 : // Generated constructor
224860 4 : SgBitAndOp::SgBitAndOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
224861 4 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
224862 : {
224863 : #ifdef DEBUG
224864 : // printf ("In SgBitAndOp::SgBitAndOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
224865 : #endif
224866 : #if 0
224867 : // debugging information!
224868 : printf ("In SgBitAndOp::SgBitAndOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
224869 : #endif
224870 :
224871 :
224872 :
224873 : #if 0
224874 : // DQ (7/30/2014): Call a virtual function.
224875 : std::string s = this->class_name();
224876 : #endif
224877 :
224878 : // Test the variant virtual function
224879 : // assert(BITAND_OP == variant());
224880 4 : assert(BITAND_OP == this->variant());
224881 4 : ROSE_ASSERT(BITAND_OP == (int)(this->variantT()));
224882 4 : post_construction_initialization();
224883 :
224884 : // Test the isSgBitAndOp() function since it has been problematic
224885 4 : assert(isSgBitAndOp(this) != NULL);
224886 4 : }
224887 :
224888 : // Generated constructor (all data members)
224889 :
224890 : /* #line 224891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224891 :
224892 :
224893 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224894 :
224895 :
224896 : // ********************************************************
224897 : // member functions common across all array grammar objects
224898 : // ********************************************************
224899 :
224900 :
224901 :
224902 : /* #line 224903 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224903 :
224904 :
224905 :
224906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
224907 :
224908 : // ********************************************************
224909 : // member functions specific to each node in the grammar
224910 : // ********************************************************
224911 :
224912 :
224913 : /* #line 224914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
224914 :
224915 : // Start of memberFunctionString
224916 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224917 :
224918 : void
224919 252 : SgBitOrOp::post_construction_initialization()
224920 : {
224921 252 : }
224922 :
224923 :
224924 :
224925 : // End of memberFunctionString
224926 : // Start of memberFunctionString
224927 : /* #line 5252 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224928 :
224929 :
224930 :
224931 : // End of memberFunctionString
224932 : // Start of memberFunctionString
224933 : /* #line 8136 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
224934 :
224935 :
224936 : #if 0
224937 : #error "This code from SOURCE_BIT_OPERATOR_EXPRESSION should not be used"
224938 :
224939 : // DQ (1/14/2006): set_type is removed
224940 : void
224941 : SgBitOrOp::set_type()
224942 : {
224943 : assert(get_lhs_operand() != NULL);
224944 : assert(get_rhs_operand() != NULL);
224945 : SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
224946 : assert(int_type != NULL);
224947 : set_expression_type(int_type);
224948 : }
224949 : #endif
224950 :
224951 :
224952 :
224953 : // End of memberFunctionString
224954 : // Start of memberFunctionString
224955 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
224956 :
224957 : // *** COMMON CODE SECTION BEGINS HERE ***
224958 :
224959 : #if 0
224960 : int
224961 : SgBitOrOp::getVariant() const
224962 : {
224963 : // This function is used in ROSE while "variant()" is used in SAGE
224964 : assert(this != NULL);
224965 : return variant();
224966 : }
224967 : #endif
224968 :
224969 : // This function is used in ROSE in treeTraversal code
224970 : // eventually replaces getVariant() and variant()
224971 : // though after variant() has been removed for a while we will
224972 : // want to change the name of variantT() back to variant()
224973 : // (since the "T" was ment to stand for temporary).
224974 : // When this happens the variantT() will be depricated.
224975 : VariantT
224976 27512 : SgBitOrOp::variantT() const
224977 : {
224978 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
224979 27512 : ROSE_ASSERT(this != NULL);
224980 27512 : return V_SgBitOrOp;
224981 : }
224982 :
224983 : #if 0
224984 : int
224985 : SgBitOrOp::variant() const
224986 : {
224987 : // This function is used in SAGE
224988 : ROSE_ASSERT(this != NULL);
224989 : return BITOR_OP;
224990 : }
224991 : #endif
224992 :
224993 : ROSE_DLL_API const char*
224994 0 : SgBitOrOp::sage_class_name() const
224995 : {
224996 0 : ROSE_ASSERT(this != NULL);
224997 0 : return "SgBitOrOp";
224998 : }
224999 :
225000 : std::string
225001 117 : SgBitOrOp::class_name() const
225002 : {
225003 117 : ROSE_ASSERT(this != NULL);
225004 117 : return "SgBitOrOp";
225005 : }
225006 :
225007 : // DQ (11/26/2005): Support for visitor pattern mechanims
225008 : // (inferior to ROSE traversal mechanism, experimental).
225009 : void
225010 2055 : SgBitOrOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
225011 : {
225012 2055 : ROSE_ASSERT(this != NULL);
225013 2055 : visitor.visit(this);
225014 2055 : }
225015 :
225016 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
225017 0 : void SgBitOrOp::accept (ROSE_VisitorPattern & visitor) {
225018 0 : ROSE_ASSERT(this != NULL);
225019 0 : visitor.visit(this);
225020 0 : }
225021 :
225022 : SgBitOrOp*
225023 0 : SgBitOrOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
225024 : {
225025 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
225026 : // This function is currently only supported for the AST used the represent Binary executables.
225027 : if (0 /* isSgAsmNode(this) != NULL */)
225028 : {
225029 : // Support for regex specification.
225030 : std::string prefixCode = "REGEX:";
225031 : addNewAttribute(prefixCode + s,a);
225032 : }
225033 : #endif
225034 :
225035 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
225036 0 : return this;
225037 : }
225038 :
225039 : // *** COMMON CODE SECTION ENDS HERE ***
225040 :
225041 :
225042 : // End of memberFunctionString
225043 : // Start of memberFunctionString
225044 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
225045 :
225046 :
225047 : #if 0
225048 : //! Error checking support
225049 : /*! Verifies the following:
225050 : - working getVariant() member function
225051 : - calls base class's error() member function
225052 : Every class has one of these functions.
225053 : */
225054 : bool
225055 : SgBitOrOp::error()
225056 : {
225057 : // Put error checking here
225058 :
225059 : ROSE_ASSERT (this != NULL);
225060 : if (getVariant() != BITOR_OP)
225061 : {
225062 : printf ("Error in SgBitOrOp::error(): SgBitOrOp object has a %s variant \n",
225063 : Cxx_GrammarTerminalNames[getVariant()].name);
225064 : // printf ("Error in SgBitOrOp::error() \n");
225065 : ROSE_ABORT();
225066 : }
225067 :
225068 : ROSE_ASSERT (getVariant() == BITOR_OP);
225069 : return SgBinaryOp::error();
225070 : }
225071 : #endif
225072 :
225073 :
225074 :
225075 : // End of memberFunctionString
225076 :
225077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
225078 :
225079 252 : SgBitOrOp* isSgBitOrOp ( SgNode* inputDerivedClassPointer )
225080 : {
225081 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225082 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225083 : // So to fix this we return NULL directly when the input is NULL and avoid the
225084 : // dynamic_cast in this case. This is likely a performance improvement as well.
225085 : // return dynamic_cast<SgBitOrOp*>(inputDerivedClassPointer);
225086 : // Milind Chabbi (8/28/2013): isSgBitOrOp uses table-driven castability instead of c++ default dynamic_cast
225087 : // this improves the running time performance by 10-20%.
225088 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBitOrOp*>(inputDerivedClassPointer);
225089 252 : return IS_SgBitOrOp_FAST_MACRO(inputDerivedClassPointer);
225090 : }
225091 :
225092 : // DQ (11/8/2003): Added version of functions taking const pointer
225093 0 : const SgBitOrOp* isSgBitOrOp ( const SgNode* inputDerivedClassPointer )
225094 : {
225095 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225096 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225097 : // So to fix this we return NULL directly when the input is NULL and avoid the
225098 : // dynamic_cast in this case. This is likely a performance improvement as well.
225099 : // return dynamic_cast<const SgBitOrOp*>(inputDerivedClassPointer);
225100 : // Milind Chabbi (8/28/2013): isSgBitOrOp uses table-driven castability instead of c++ default dynamic_cast
225101 : // this improves the running time performance by 10-20%.
225102 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBitOrOp*>(inputDerivedClassPointer);
225103 0 : return IS_SgBitOrOp_FAST_MACRO(inputDerivedClassPointer);
225104 : }
225105 :
225106 :
225107 :
225108 : /* #line 225109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225109 :
225110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225111 :
225112 : /**
225113 : \brief Generated destructor
225114 :
225115 : This destructor is automatically generated (by ROSETTA). This destructor
225116 : only frees memory of data members associated with the parts of the current IR node which
225117 : are NOT traversed. Those data members that are part of a traversal can be freed using
225118 : a traversal (calling this destructor on all children in a post-order traversal). Such
225119 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
225120 :
225121 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
225122 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
225123 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
225124 :
225125 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
225126 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
225127 : pointers are not yet implemented to call delete on eash pointer in the container.
225128 : (This could be done by derivation from the STL containers to define containers that
225129 : automatically deleted their members.)
225130 :
225131 : */
225132 300 : SgBitOrOp::~SgBitOrOp () {
225133 150 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
225134 :
225135 :
225136 :
225137 : }
225138 :
225139 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225140 300 : }
225141 :
225142 :
225143 : /* #line 225144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225144 :
225145 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
225146 :
225147 : // Generated constructor
225148 0 : SgBitOrOp::SgBitOrOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
225149 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
225150 : {
225151 : #ifdef DEBUG
225152 : // printf ("In SgBitOrOp::SgBitOrOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
225153 : #endif
225154 : #if 0
225155 : // debugging information!
225156 : printf ("In SgBitOrOp::SgBitOrOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
225157 : #endif
225158 :
225159 :
225160 :
225161 : #if 0
225162 : // DQ (7/30/2014): Call a virtual function.
225163 : std::string s = this->class_name();
225164 : #endif
225165 :
225166 : // Test the variant virtual function
225167 : // assert(BITOR_OP == variant());
225168 0 : assert(BITOR_OP == this->variant());
225169 0 : ROSE_ASSERT(BITOR_OP == (int)(this->variantT()));
225170 0 : post_construction_initialization();
225171 :
225172 : // Test the isSgBitOrOp() function since it has been problematic
225173 0 : assert(isSgBitOrOp(this) != NULL);
225174 0 : }
225175 :
225176 : // Generated constructor (all data members)
225177 :
225178 : /* #line 225179 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225179 :
225180 :
225181 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
225182 :
225183 :
225184 : // ********************************************************
225185 : // member functions common across all array grammar objects
225186 : // ********************************************************
225187 :
225188 :
225189 :
225190 : /* #line 225191 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225191 :
225192 :
225193 :
225194 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
225195 :
225196 : // ********************************************************
225197 : // member functions specific to each node in the grammar
225198 : // ********************************************************
225199 :
225200 :
225201 : /* #line 225202 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225202 :
225203 : // Start of memberFunctionString
225204 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225205 :
225206 : void
225207 0 : SgBitEqvOp::post_construction_initialization()
225208 : {
225209 0 : }
225210 :
225211 :
225212 :
225213 : // End of memberFunctionString
225214 : // Start of memberFunctionString
225215 : /* #line 5256 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225216 :
225217 :
225218 :
225219 : // End of memberFunctionString
225220 : // Start of memberFunctionString
225221 : /* #line 8136 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225222 :
225223 :
225224 : #if 0
225225 : #error "This code from SOURCE_BIT_OPERATOR_EXPRESSION should not be used"
225226 :
225227 : // DQ (1/14/2006): set_type is removed
225228 : void
225229 : SgBitEqvOp::set_type()
225230 : {
225231 : assert(get_lhs_operand() != NULL);
225232 : assert(get_rhs_operand() != NULL);
225233 : SgType * int_type = SgType::integer_promotion(get_lhs_operand()->get_type(), get_rhs_operand()->get_type());
225234 : assert(int_type != NULL);
225235 : set_expression_type(int_type);
225236 : }
225237 : #endif
225238 :
225239 :
225240 :
225241 : // End of memberFunctionString
225242 : // Start of memberFunctionString
225243 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
225244 :
225245 : // *** COMMON CODE SECTION BEGINS HERE ***
225246 :
225247 : #if 0
225248 : int
225249 : SgBitEqvOp::getVariant() const
225250 : {
225251 : // This function is used in ROSE while "variant()" is used in SAGE
225252 : assert(this != NULL);
225253 : return variant();
225254 : }
225255 : #endif
225256 :
225257 : // This function is used in ROSE in treeTraversal code
225258 : // eventually replaces getVariant() and variant()
225259 : // though after variant() has been removed for a while we will
225260 : // want to change the name of variantT() back to variant()
225261 : // (since the "T" was ment to stand for temporary).
225262 : // When this happens the variantT() will be depricated.
225263 : VariantT
225264 0 : SgBitEqvOp::variantT() const
225265 : {
225266 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
225267 0 : ROSE_ASSERT(this != NULL);
225268 0 : return V_SgBitEqvOp;
225269 : }
225270 :
225271 : #if 0
225272 : int
225273 : SgBitEqvOp::variant() const
225274 : {
225275 : // This function is used in SAGE
225276 : ROSE_ASSERT(this != NULL);
225277 : return BITEQV_OP;
225278 : }
225279 : #endif
225280 :
225281 : ROSE_DLL_API const char*
225282 0 : SgBitEqvOp::sage_class_name() const
225283 : {
225284 0 : ROSE_ASSERT(this != NULL);
225285 0 : return "SgBitEqvOp";
225286 : }
225287 :
225288 : std::string
225289 0 : SgBitEqvOp::class_name() const
225290 : {
225291 0 : ROSE_ASSERT(this != NULL);
225292 0 : return "SgBitEqvOp";
225293 : }
225294 :
225295 : // DQ (11/26/2005): Support for visitor pattern mechanims
225296 : // (inferior to ROSE traversal mechanism, experimental).
225297 : void
225298 0 : SgBitEqvOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
225299 : {
225300 0 : ROSE_ASSERT(this != NULL);
225301 0 : visitor.visit(this);
225302 0 : }
225303 :
225304 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
225305 0 : void SgBitEqvOp::accept (ROSE_VisitorPattern & visitor) {
225306 0 : ROSE_ASSERT(this != NULL);
225307 0 : visitor.visit(this);
225308 0 : }
225309 :
225310 : SgBitEqvOp*
225311 0 : SgBitEqvOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
225312 : {
225313 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
225314 : // This function is currently only supported for the AST used the represent Binary executables.
225315 : if (0 /* isSgAsmNode(this) != NULL */)
225316 : {
225317 : // Support for regex specification.
225318 : std::string prefixCode = "REGEX:";
225319 : addNewAttribute(prefixCode + s,a);
225320 : }
225321 : #endif
225322 :
225323 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
225324 0 : return this;
225325 : }
225326 :
225327 : // *** COMMON CODE SECTION ENDS HERE ***
225328 :
225329 :
225330 : // End of memberFunctionString
225331 : // Start of memberFunctionString
225332 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
225333 :
225334 :
225335 : #if 0
225336 : //! Error checking support
225337 : /*! Verifies the following:
225338 : - working getVariant() member function
225339 : - calls base class's error() member function
225340 : Every class has one of these functions.
225341 : */
225342 : bool
225343 : SgBitEqvOp::error()
225344 : {
225345 : // Put error checking here
225346 :
225347 : ROSE_ASSERT (this != NULL);
225348 : if (getVariant() != BITEQV_OP)
225349 : {
225350 : printf ("Error in SgBitEqvOp::error(): SgBitEqvOp object has a %s variant \n",
225351 : Cxx_GrammarTerminalNames[getVariant()].name);
225352 : // printf ("Error in SgBitEqvOp::error() \n");
225353 : ROSE_ABORT();
225354 : }
225355 :
225356 : ROSE_ASSERT (getVariant() == BITEQV_OP);
225357 : return SgBinaryOp::error();
225358 : }
225359 : #endif
225360 :
225361 :
225362 :
225363 : // End of memberFunctionString
225364 :
225365 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
225366 :
225367 0 : SgBitEqvOp* isSgBitEqvOp ( SgNode* inputDerivedClassPointer )
225368 : {
225369 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225370 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225371 : // So to fix this we return NULL directly when the input is NULL and avoid the
225372 : // dynamic_cast in this case. This is likely a performance improvement as well.
225373 : // return dynamic_cast<SgBitEqvOp*>(inputDerivedClassPointer);
225374 : // Milind Chabbi (8/28/2013): isSgBitEqvOp uses table-driven castability instead of c++ default dynamic_cast
225375 : // this improves the running time performance by 10-20%.
225376 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBitEqvOp*>(inputDerivedClassPointer);
225377 0 : return IS_SgBitEqvOp_FAST_MACRO(inputDerivedClassPointer);
225378 : }
225379 :
225380 : // DQ (11/8/2003): Added version of functions taking const pointer
225381 0 : const SgBitEqvOp* isSgBitEqvOp ( const SgNode* inputDerivedClassPointer )
225382 : {
225383 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225384 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225385 : // So to fix this we return NULL directly when the input is NULL and avoid the
225386 : // dynamic_cast in this case. This is likely a performance improvement as well.
225387 : // return dynamic_cast<const SgBitEqvOp*>(inputDerivedClassPointer);
225388 : // Milind Chabbi (8/28/2013): isSgBitEqvOp uses table-driven castability instead of c++ default dynamic_cast
225389 : // this improves the running time performance by 10-20%.
225390 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBitEqvOp*>(inputDerivedClassPointer);
225391 0 : return IS_SgBitEqvOp_FAST_MACRO(inputDerivedClassPointer);
225392 : }
225393 :
225394 :
225395 :
225396 : /* #line 225397 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225397 :
225398 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225399 :
225400 : /**
225401 : \brief Generated destructor
225402 :
225403 : This destructor is automatically generated (by ROSETTA). This destructor
225404 : only frees memory of data members associated with the parts of the current IR node which
225405 : are NOT traversed. Those data members that are part of a traversal can be freed using
225406 : a traversal (calling this destructor on all children in a post-order traversal). Such
225407 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
225408 :
225409 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
225410 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
225411 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
225412 :
225413 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
225414 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
225415 : pointers are not yet implemented to call delete on eash pointer in the container.
225416 : (This could be done by derivation from the STL containers to define containers that
225417 : automatically deleted their members.)
225418 :
225419 : */
225420 0 : SgBitEqvOp::~SgBitEqvOp () {
225421 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
225422 :
225423 :
225424 :
225425 : }
225426 :
225427 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225428 0 : }
225429 :
225430 :
225431 : /* #line 225432 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225432 :
225433 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
225434 :
225435 : // Generated constructor
225436 0 : SgBitEqvOp::SgBitEqvOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
225437 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
225438 : {
225439 : #ifdef DEBUG
225440 : // printf ("In SgBitEqvOp::SgBitEqvOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
225441 : #endif
225442 : #if 0
225443 : // debugging information!
225444 : printf ("In SgBitEqvOp::SgBitEqvOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
225445 : #endif
225446 :
225447 :
225448 :
225449 : #if 0
225450 : // DQ (7/30/2014): Call a virtual function.
225451 : std::string s = this->class_name();
225452 : #endif
225453 :
225454 : // Test the variant virtual function
225455 : // assert(BITEQV_OP == variant());
225456 0 : assert(BITEQV_OP == this->variant());
225457 0 : ROSE_ASSERT(BITEQV_OP == (int)(this->variantT()));
225458 0 : post_construction_initialization();
225459 :
225460 : // Test the isSgBitEqvOp() function since it has been problematic
225461 0 : assert(isSgBitEqvOp(this) != NULL);
225462 0 : }
225463 :
225464 : // Generated constructor (all data members)
225465 :
225466 : /* #line 225467 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225467 :
225468 :
225469 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
225470 :
225471 :
225472 : // ********************************************************
225473 : // member functions common across all array grammar objects
225474 : // ********************************************************
225475 :
225476 :
225477 :
225478 : /* #line 225479 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225479 :
225480 :
225481 :
225482 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
225483 :
225484 : // ********************************************************
225485 : // member functions specific to each node in the grammar
225486 : // ********************************************************
225487 :
225488 :
225489 : /* #line 225490 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225490 :
225491 : // Start of memberFunctionString
225492 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225493 :
225494 : void
225495 274 : SgCommaOpExp::post_construction_initialization()
225496 : {
225497 274 : }
225498 :
225499 :
225500 :
225501 : // End of memberFunctionString
225502 : // Start of memberFunctionString
225503 : /* #line 5260 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225504 :
225505 :
225506 : SgType*
225507 216 : SgCommaOpExp::get_type() const
225508 : {
225509 : // DQ (10/2/2006): Comma operator's get_type function didn't previously exist, but it should
225510 : // because its semantics is different from the default SgBinaryOp::get_type() which returns
225511 : // the type associated with the lhs. This returns the type of the rhs.
225512 216 : ROSE_ASSERT(get_lhs_operand() != NULL);
225513 216 : ROSE_ASSERT(get_rhs_operand() != NULL);
225514 :
225515 : #if 0
225516 : printf ("In SgCommaOpExp::get_type() \n");
225517 : #endif
225518 :
225519 216 : SgType* returnType = get_rhs_operand()->get_type();
225520 216 : ROSE_ASSERT(returnType != NULL);
225521 :
225522 : // printf ("SgCommaOpExp::get_type(): get the type of the rhs operand returnType = %s \n",returnType->class_name().c_str());
225523 :
225524 216 : return returnType;
225525 : }
225526 :
225527 :
225528 :
225529 : // End of memberFunctionString
225530 : // Start of memberFunctionString
225531 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
225532 :
225533 : // *** COMMON CODE SECTION BEGINS HERE ***
225534 :
225535 : #if 0
225536 : int
225537 : SgCommaOpExp::getVariant() const
225538 : {
225539 : // This function is used in ROSE while "variant()" is used in SAGE
225540 : assert(this != NULL);
225541 : return variant();
225542 : }
225543 : #endif
225544 :
225545 : // This function is used in ROSE in treeTraversal code
225546 : // eventually replaces getVariant() and variant()
225547 : // though after variant() has been removed for a while we will
225548 : // want to change the name of variantT() back to variant()
225549 : // (since the "T" was ment to stand for temporary).
225550 : // When this happens the variantT() will be depricated.
225551 : VariantT
225552 120365 : SgCommaOpExp::variantT() const
225553 : {
225554 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
225555 120365 : ROSE_ASSERT(this != NULL);
225556 120365 : return V_SgCommaOpExp;
225557 : }
225558 :
225559 : #if 0
225560 : int
225561 : SgCommaOpExp::variant() const
225562 : {
225563 : // This function is used in SAGE
225564 : ROSE_ASSERT(this != NULL);
225565 : return COMMA_OP;
225566 : }
225567 : #endif
225568 :
225569 : ROSE_DLL_API const char*
225570 0 : SgCommaOpExp::sage_class_name() const
225571 : {
225572 0 : ROSE_ASSERT(this != NULL);
225573 0 : return "SgCommaOpExp";
225574 : }
225575 :
225576 : std::string
225577 227 : SgCommaOpExp::class_name() const
225578 : {
225579 227 : ROSE_ASSERT(this != NULL);
225580 227 : return "SgCommaOpExp";
225581 : }
225582 :
225583 : // DQ (11/26/2005): Support for visitor pattern mechanims
225584 : // (inferior to ROSE traversal mechanism, experimental).
225585 : void
225586 2466 : SgCommaOpExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
225587 : {
225588 2466 : ROSE_ASSERT(this != NULL);
225589 2466 : visitor.visit(this);
225590 2466 : }
225591 :
225592 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
225593 0 : void SgCommaOpExp::accept (ROSE_VisitorPattern & visitor) {
225594 0 : ROSE_ASSERT(this != NULL);
225595 0 : visitor.visit(this);
225596 0 : }
225597 :
225598 : SgCommaOpExp*
225599 0 : SgCommaOpExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
225600 : {
225601 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
225602 : // This function is currently only supported for the AST used the represent Binary executables.
225603 : if (0 /* isSgAsmNode(this) != NULL */)
225604 : {
225605 : // Support for regex specification.
225606 : std::string prefixCode = "REGEX:";
225607 : addNewAttribute(prefixCode + s,a);
225608 : }
225609 : #endif
225610 :
225611 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
225612 0 : return this;
225613 : }
225614 :
225615 : // *** COMMON CODE SECTION ENDS HERE ***
225616 :
225617 :
225618 : // End of memberFunctionString
225619 : // Start of memberFunctionString
225620 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
225621 :
225622 :
225623 : #if 0
225624 : //! Error checking support
225625 : /*! Verifies the following:
225626 : - working getVariant() member function
225627 : - calls base class's error() member function
225628 : Every class has one of these functions.
225629 : */
225630 : bool
225631 : SgCommaOpExp::error()
225632 : {
225633 : // Put error checking here
225634 :
225635 : ROSE_ASSERT (this != NULL);
225636 : if (getVariant() != COMMA_OP)
225637 : {
225638 : printf ("Error in SgCommaOpExp::error(): SgCommaOpExp object has a %s variant \n",
225639 : Cxx_GrammarTerminalNames[getVariant()].name);
225640 : // printf ("Error in SgCommaOpExp::error() \n");
225641 : ROSE_ABORT();
225642 : }
225643 :
225644 : ROSE_ASSERT (getVariant() == COMMA_OP);
225645 : return SgBinaryOp::error();
225646 : }
225647 : #endif
225648 :
225649 :
225650 :
225651 : // End of memberFunctionString
225652 :
225653 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
225654 :
225655 21206 : SgCommaOpExp* isSgCommaOpExp ( SgNode* inputDerivedClassPointer )
225656 : {
225657 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225658 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225659 : // So to fix this we return NULL directly when the input is NULL and avoid the
225660 : // dynamic_cast in this case. This is likely a performance improvement as well.
225661 : // return dynamic_cast<SgCommaOpExp*>(inputDerivedClassPointer);
225662 : // Milind Chabbi (8/28/2013): isSgCommaOpExp uses table-driven castability instead of c++ default dynamic_cast
225663 : // this improves the running time performance by 10-20%.
225664 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCommaOpExp*>(inputDerivedClassPointer);
225665 21206 : return IS_SgCommaOpExp_FAST_MACRO(inputDerivedClassPointer);
225666 : }
225667 :
225668 : // DQ (11/8/2003): Added version of functions taking const pointer
225669 0 : const SgCommaOpExp* isSgCommaOpExp ( const SgNode* inputDerivedClassPointer )
225670 : {
225671 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225672 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225673 : // So to fix this we return NULL directly when the input is NULL and avoid the
225674 : // dynamic_cast in this case. This is likely a performance improvement as well.
225675 : // return dynamic_cast<const SgCommaOpExp*>(inputDerivedClassPointer);
225676 : // Milind Chabbi (8/28/2013): isSgCommaOpExp uses table-driven castability instead of c++ default dynamic_cast
225677 : // this improves the running time performance by 10-20%.
225678 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCommaOpExp*>(inputDerivedClassPointer);
225679 0 : return IS_SgCommaOpExp_FAST_MACRO(inputDerivedClassPointer);
225680 : }
225681 :
225682 :
225683 :
225684 : /* #line 225685 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225685 :
225686 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225687 :
225688 : /**
225689 : \brief Generated destructor
225690 :
225691 : This destructor is automatically generated (by ROSETTA). This destructor
225692 : only frees memory of data members associated with the parts of the current IR node which
225693 : are NOT traversed. Those data members that are part of a traversal can be freed using
225694 : a traversal (calling this destructor on all children in a post-order traversal). Such
225695 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
225696 :
225697 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
225698 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
225699 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
225700 :
225701 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
225702 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
225703 : pointers are not yet implemented to call delete on eash pointer in the container.
225704 : (This could be done by derivation from the STL containers to define containers that
225705 : automatically deleted their members.)
225706 :
225707 : */
225708 64 : SgCommaOpExp::~SgCommaOpExp () {
225709 32 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
225710 :
225711 :
225712 :
225713 : }
225714 :
225715 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225716 64 : }
225717 :
225718 :
225719 : /* #line 225720 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225720 :
225721 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
225722 :
225723 : // Generated constructor
225724 0 : SgCommaOpExp::SgCommaOpExp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
225725 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
225726 : {
225727 : #ifdef DEBUG
225728 : // printf ("In SgCommaOpExp::SgCommaOpExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
225729 : #endif
225730 : #if 0
225731 : // debugging information!
225732 : printf ("In SgCommaOpExp::SgCommaOpExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
225733 : #endif
225734 :
225735 :
225736 :
225737 : #if 0
225738 : // DQ (7/30/2014): Call a virtual function.
225739 : std::string s = this->class_name();
225740 : #endif
225741 :
225742 : // Test the variant virtual function
225743 : // assert(COMMA_OP == variant());
225744 0 : assert(COMMA_OP == this->variant());
225745 0 : ROSE_ASSERT(COMMA_OP == (int)(this->variantT()));
225746 0 : post_construction_initialization();
225747 :
225748 : // Test the isSgCommaOpExp() function since it has been problematic
225749 0 : assert(isSgCommaOpExp(this) != NULL);
225750 0 : }
225751 :
225752 : // Generated constructor (all data members)
225753 :
225754 : /* #line 225755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225755 :
225756 :
225757 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
225758 :
225759 :
225760 : // ********************************************************
225761 : // member functions common across all array grammar objects
225762 : // ********************************************************
225763 :
225764 :
225765 :
225766 : /* #line 225767 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225767 :
225768 :
225769 :
225770 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
225771 :
225772 : // ********************************************************
225773 : // member functions specific to each node in the grammar
225774 : // ********************************************************
225775 :
225776 :
225777 : /* #line 225778 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225778 :
225779 : // Start of memberFunctionString
225780 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225781 :
225782 : void
225783 3158 : SgLshiftOp::post_construction_initialization()
225784 : {
225785 3158 : }
225786 :
225787 :
225788 :
225789 : // End of memberFunctionString
225790 : // Start of memberFunctionString
225791 : /* #line 5285 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
225792 :
225793 :
225794 :
225795 : // End of memberFunctionString
225796 : // Start of memberFunctionString
225797 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
225798 :
225799 : // *** COMMON CODE SECTION BEGINS HERE ***
225800 :
225801 : #if 0
225802 : int
225803 : SgLshiftOp::getVariant() const
225804 : {
225805 : // This function is used in ROSE while "variant()" is used in SAGE
225806 : assert(this != NULL);
225807 : return variant();
225808 : }
225809 : #endif
225810 :
225811 : // This function is used in ROSE in treeTraversal code
225812 : // eventually replaces getVariant() and variant()
225813 : // though after variant() has been removed for a while we will
225814 : // want to change the name of variantT() back to variant()
225815 : // (since the "T" was ment to stand for temporary).
225816 : // When this happens the variantT() will be depricated.
225817 : VariantT
225818 169646 : SgLshiftOp::variantT() const
225819 : {
225820 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
225821 169646 : ROSE_ASSERT(this != NULL);
225822 169646 : return V_SgLshiftOp;
225823 : }
225824 :
225825 : #if 0
225826 : int
225827 : SgLshiftOp::variant() const
225828 : {
225829 : // This function is used in SAGE
225830 : ROSE_ASSERT(this != NULL);
225831 : return LSHIFT_OP;
225832 : }
225833 : #endif
225834 :
225835 : ROSE_DLL_API const char*
225836 0 : SgLshiftOp::sage_class_name() const
225837 : {
225838 0 : ROSE_ASSERT(this != NULL);
225839 0 : return "SgLshiftOp";
225840 : }
225841 :
225842 : std::string
225843 203 : SgLshiftOp::class_name() const
225844 : {
225845 203 : ROSE_ASSERT(this != NULL);
225846 203 : return "SgLshiftOp";
225847 : }
225848 :
225849 : // DQ (11/26/2005): Support for visitor pattern mechanims
225850 : // (inferior to ROSE traversal mechanism, experimental).
225851 : void
225852 3771 : SgLshiftOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
225853 : {
225854 3771 : ROSE_ASSERT(this != NULL);
225855 3771 : visitor.visit(this);
225856 3771 : }
225857 :
225858 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
225859 0 : void SgLshiftOp::accept (ROSE_VisitorPattern & visitor) {
225860 0 : ROSE_ASSERT(this != NULL);
225861 0 : visitor.visit(this);
225862 0 : }
225863 :
225864 : SgLshiftOp*
225865 0 : SgLshiftOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
225866 : {
225867 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
225868 : // This function is currently only supported for the AST used the represent Binary executables.
225869 : if (0 /* isSgAsmNode(this) != NULL */)
225870 : {
225871 : // Support for regex specification.
225872 : std::string prefixCode = "REGEX:";
225873 : addNewAttribute(prefixCode + s,a);
225874 : }
225875 : #endif
225876 :
225877 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
225878 0 : return this;
225879 : }
225880 :
225881 : // *** COMMON CODE SECTION ENDS HERE ***
225882 :
225883 :
225884 : // End of memberFunctionString
225885 : // Start of memberFunctionString
225886 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
225887 :
225888 :
225889 : #if 0
225890 : //! Error checking support
225891 : /*! Verifies the following:
225892 : - working getVariant() member function
225893 : - calls base class's error() member function
225894 : Every class has one of these functions.
225895 : */
225896 : bool
225897 : SgLshiftOp::error()
225898 : {
225899 : // Put error checking here
225900 :
225901 : ROSE_ASSERT (this != NULL);
225902 : if (getVariant() != LSHIFT_OP)
225903 : {
225904 : printf ("Error in SgLshiftOp::error(): SgLshiftOp object has a %s variant \n",
225905 : Cxx_GrammarTerminalNames[getVariant()].name);
225906 : // printf ("Error in SgLshiftOp::error() \n");
225907 : ROSE_ABORT();
225908 : }
225909 :
225910 : ROSE_ASSERT (getVariant() == LSHIFT_OP);
225911 : return SgBinaryOp::error();
225912 : }
225913 : #endif
225914 :
225915 :
225916 :
225917 : // End of memberFunctionString
225918 :
225919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
225920 :
225921 3158 : SgLshiftOp* isSgLshiftOp ( SgNode* inputDerivedClassPointer )
225922 : {
225923 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225924 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225925 : // So to fix this we return NULL directly when the input is NULL and avoid the
225926 : // dynamic_cast in this case. This is likely a performance improvement as well.
225927 : // return dynamic_cast<SgLshiftOp*>(inputDerivedClassPointer);
225928 : // Milind Chabbi (8/28/2013): isSgLshiftOp uses table-driven castability instead of c++ default dynamic_cast
225929 : // this improves the running time performance by 10-20%.
225930 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLshiftOp*>(inputDerivedClassPointer);
225931 3158 : return IS_SgLshiftOp_FAST_MACRO(inputDerivedClassPointer);
225932 : }
225933 :
225934 : // DQ (11/8/2003): Added version of functions taking const pointer
225935 0 : const SgLshiftOp* isSgLshiftOp ( const SgNode* inputDerivedClassPointer )
225936 : {
225937 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
225938 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
225939 : // So to fix this we return NULL directly when the input is NULL and avoid the
225940 : // dynamic_cast in this case. This is likely a performance improvement as well.
225941 : // return dynamic_cast<const SgLshiftOp*>(inputDerivedClassPointer);
225942 : // Milind Chabbi (8/28/2013): isSgLshiftOp uses table-driven castability instead of c++ default dynamic_cast
225943 : // this improves the running time performance by 10-20%.
225944 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLshiftOp*>(inputDerivedClassPointer);
225945 0 : return IS_SgLshiftOp_FAST_MACRO(inputDerivedClassPointer);
225946 : }
225947 :
225948 :
225949 :
225950 : /* #line 225951 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225951 :
225952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225953 :
225954 : /**
225955 : \brief Generated destructor
225956 :
225957 : This destructor is automatically generated (by ROSETTA). This destructor
225958 : only frees memory of data members associated with the parts of the current IR node which
225959 : are NOT traversed. Those data members that are part of a traversal can be freed using
225960 : a traversal (calling this destructor on all children in a post-order traversal). Such
225961 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
225962 :
225963 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
225964 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
225965 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
225966 :
225967 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
225968 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
225969 : pointers are not yet implemented to call delete on eash pointer in the container.
225970 : (This could be done by derivation from the STL containers to define containers that
225971 : automatically deleted their members.)
225972 :
225973 : */
225974 5948 : SgLshiftOp::~SgLshiftOp () {
225975 2974 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
225976 :
225977 :
225978 :
225979 : }
225980 :
225981 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
225982 5948 : }
225983 :
225984 :
225985 : /* #line 225986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
225986 :
225987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
225988 :
225989 : // Generated constructor
225990 0 : SgLshiftOp::SgLshiftOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
225991 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
225992 : {
225993 : #ifdef DEBUG
225994 : // printf ("In SgLshiftOp::SgLshiftOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
225995 : #endif
225996 : #if 0
225997 : // debugging information!
225998 : printf ("In SgLshiftOp::SgLshiftOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
225999 : #endif
226000 :
226001 :
226002 :
226003 : #if 0
226004 : // DQ (7/30/2014): Call a virtual function.
226005 : std::string s = this->class_name();
226006 : #endif
226007 :
226008 : // Test the variant virtual function
226009 : // assert(LSHIFT_OP == variant());
226010 0 : assert(LSHIFT_OP == this->variant());
226011 0 : ROSE_ASSERT(LSHIFT_OP == (int)(this->variantT()));
226012 0 : post_construction_initialization();
226013 :
226014 : // Test the isSgLshiftOp() function since it has been problematic
226015 0 : assert(isSgLshiftOp(this) != NULL);
226016 0 : }
226017 :
226018 : // Generated constructor (all data members)
226019 :
226020 : /* #line 226021 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226021 :
226022 :
226023 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226024 :
226025 :
226026 : // ********************************************************
226027 : // member functions common across all array grammar objects
226028 : // ********************************************************
226029 :
226030 :
226031 :
226032 : /* #line 226033 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226033 :
226034 :
226035 :
226036 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226037 :
226038 : // ********************************************************
226039 : // member functions specific to each node in the grammar
226040 : // ********************************************************
226041 :
226042 :
226043 : /* #line 226044 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226044 :
226045 : // Start of memberFunctionString
226046 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226047 :
226048 : void
226049 765 : SgRshiftOp::post_construction_initialization()
226050 : {
226051 765 : }
226052 :
226053 :
226054 :
226055 : // End of memberFunctionString
226056 : // Start of memberFunctionString
226057 : /* #line 5288 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226058 :
226059 :
226060 :
226061 : // End of memberFunctionString
226062 : // Start of memberFunctionString
226063 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
226064 :
226065 : // *** COMMON CODE SECTION BEGINS HERE ***
226066 :
226067 : #if 0
226068 : int
226069 : SgRshiftOp::getVariant() const
226070 : {
226071 : // This function is used in ROSE while "variant()" is used in SAGE
226072 : assert(this != NULL);
226073 : return variant();
226074 : }
226075 : #endif
226076 :
226077 : // This function is used in ROSE in treeTraversal code
226078 : // eventually replaces getVariant() and variant()
226079 : // though after variant() has been removed for a while we will
226080 : // want to change the name of variantT() back to variant()
226081 : // (since the "T" was ment to stand for temporary).
226082 : // When this happens the variantT() will be depricated.
226083 : VariantT
226084 44550 : SgRshiftOp::variantT() const
226085 : {
226086 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
226087 44550 : ROSE_ASSERT(this != NULL);
226088 44550 : return V_SgRshiftOp;
226089 : }
226090 :
226091 : #if 0
226092 : int
226093 : SgRshiftOp::variant() const
226094 : {
226095 : // This function is used in SAGE
226096 : ROSE_ASSERT(this != NULL);
226097 : return RSHIFT_OP;
226098 : }
226099 : #endif
226100 :
226101 : ROSE_DLL_API const char*
226102 0 : SgRshiftOp::sage_class_name() const
226103 : {
226104 0 : ROSE_ASSERT(this != NULL);
226105 0 : return "SgRshiftOp";
226106 : }
226107 :
226108 : std::string
226109 59 : SgRshiftOp::class_name() const
226110 : {
226111 59 : ROSE_ASSERT(this != NULL);
226112 59 : return "SgRshiftOp";
226113 : }
226114 :
226115 : // DQ (11/26/2005): Support for visitor pattern mechanims
226116 : // (inferior to ROSE traversal mechanism, experimental).
226117 : void
226118 1114 : SgRshiftOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
226119 : {
226120 1114 : ROSE_ASSERT(this != NULL);
226121 1114 : visitor.visit(this);
226122 1114 : }
226123 :
226124 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
226125 0 : void SgRshiftOp::accept (ROSE_VisitorPattern & visitor) {
226126 0 : ROSE_ASSERT(this != NULL);
226127 0 : visitor.visit(this);
226128 0 : }
226129 :
226130 : SgRshiftOp*
226131 0 : SgRshiftOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
226132 : {
226133 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
226134 : // This function is currently only supported for the AST used the represent Binary executables.
226135 : if (0 /* isSgAsmNode(this) != NULL */)
226136 : {
226137 : // Support for regex specification.
226138 : std::string prefixCode = "REGEX:";
226139 : addNewAttribute(prefixCode + s,a);
226140 : }
226141 : #endif
226142 :
226143 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
226144 0 : return this;
226145 : }
226146 :
226147 : // *** COMMON CODE SECTION ENDS HERE ***
226148 :
226149 :
226150 : // End of memberFunctionString
226151 : // Start of memberFunctionString
226152 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
226153 :
226154 :
226155 : #if 0
226156 : //! Error checking support
226157 : /*! Verifies the following:
226158 : - working getVariant() member function
226159 : - calls base class's error() member function
226160 : Every class has one of these functions.
226161 : */
226162 : bool
226163 : SgRshiftOp::error()
226164 : {
226165 : // Put error checking here
226166 :
226167 : ROSE_ASSERT (this != NULL);
226168 : if (getVariant() != RSHIFT_OP)
226169 : {
226170 : printf ("Error in SgRshiftOp::error(): SgRshiftOp object has a %s variant \n",
226171 : Cxx_GrammarTerminalNames[getVariant()].name);
226172 : // printf ("Error in SgRshiftOp::error() \n");
226173 : ROSE_ABORT();
226174 : }
226175 :
226176 : ROSE_ASSERT (getVariant() == RSHIFT_OP);
226177 : return SgBinaryOp::error();
226178 : }
226179 : #endif
226180 :
226181 :
226182 :
226183 : // End of memberFunctionString
226184 :
226185 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
226186 :
226187 765 : SgRshiftOp* isSgRshiftOp ( SgNode* inputDerivedClassPointer )
226188 : {
226189 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
226190 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
226191 : // So to fix this we return NULL directly when the input is NULL and avoid the
226192 : // dynamic_cast in this case. This is likely a performance improvement as well.
226193 : // return dynamic_cast<SgRshiftOp*>(inputDerivedClassPointer);
226194 : // Milind Chabbi (8/28/2013): isSgRshiftOp uses table-driven castability instead of c++ default dynamic_cast
226195 : // this improves the running time performance by 10-20%.
226196 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRshiftOp*>(inputDerivedClassPointer);
226197 765 : return IS_SgRshiftOp_FAST_MACRO(inputDerivedClassPointer);
226198 : }
226199 :
226200 : // DQ (11/8/2003): Added version of functions taking const pointer
226201 0 : const SgRshiftOp* isSgRshiftOp ( const SgNode* inputDerivedClassPointer )
226202 : {
226203 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
226204 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
226205 : // So to fix this we return NULL directly when the input is NULL and avoid the
226206 : // dynamic_cast in this case. This is likely a performance improvement as well.
226207 : // return dynamic_cast<const SgRshiftOp*>(inputDerivedClassPointer);
226208 : // Milind Chabbi (8/28/2013): isSgRshiftOp uses table-driven castability instead of c++ default dynamic_cast
226209 : // this improves the running time performance by 10-20%.
226210 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRshiftOp*>(inputDerivedClassPointer);
226211 0 : return IS_SgRshiftOp_FAST_MACRO(inputDerivedClassPointer);
226212 : }
226213 :
226214 :
226215 :
226216 : /* #line 226217 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226217 :
226218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
226219 :
226220 : /**
226221 : \brief Generated destructor
226222 :
226223 : This destructor is automatically generated (by ROSETTA). This destructor
226224 : only frees memory of data members associated with the parts of the current IR node which
226225 : are NOT traversed. Those data members that are part of a traversal can be freed using
226226 : a traversal (calling this destructor on all children in a post-order traversal). Such
226227 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
226228 :
226229 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
226230 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
226231 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
226232 :
226233 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
226234 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
226235 : pointers are not yet implemented to call delete on eash pointer in the container.
226236 : (This could be done by derivation from the STL containers to define containers that
226237 : automatically deleted their members.)
226238 :
226239 : */
226240 1424 : SgRshiftOp::~SgRshiftOp () {
226241 712 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
226242 :
226243 :
226244 :
226245 : }
226246 :
226247 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
226248 1424 : }
226249 :
226250 :
226251 : /* #line 226252 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226252 :
226253 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
226254 :
226255 : // Generated constructor
226256 0 : SgRshiftOp::SgRshiftOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
226257 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
226258 : {
226259 : #ifdef DEBUG
226260 : // printf ("In SgRshiftOp::SgRshiftOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
226261 : #endif
226262 : #if 0
226263 : // debugging information!
226264 : printf ("In SgRshiftOp::SgRshiftOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
226265 : #endif
226266 :
226267 :
226268 :
226269 : #if 0
226270 : // DQ (7/30/2014): Call a virtual function.
226271 : std::string s = this->class_name();
226272 : #endif
226273 :
226274 : // Test the variant virtual function
226275 : // assert(RSHIFT_OP == variant());
226276 0 : assert(RSHIFT_OP == this->variant());
226277 0 : ROSE_ASSERT(RSHIFT_OP == (int)(this->variantT()));
226278 0 : post_construction_initialization();
226279 :
226280 : // Test the isSgRshiftOp() function since it has been problematic
226281 0 : assert(isSgRshiftOp(this) != NULL);
226282 0 : }
226283 :
226284 : // Generated constructor (all data members)
226285 :
226286 : /* #line 226287 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226287 :
226288 :
226289 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226290 :
226291 :
226292 : // ********************************************************
226293 : // member functions common across all array grammar objects
226294 : // ********************************************************
226295 :
226296 :
226297 :
226298 : /* #line 226299 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226299 :
226300 :
226301 :
226302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226303 :
226304 : // ********************************************************
226305 : // member functions specific to each node in the grammar
226306 : // ********************************************************
226307 :
226308 :
226309 : /* #line 226310 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226310 :
226311 : // Start of memberFunctionString
226312 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226313 :
226314 : void
226315 2178 : SgPntrArrRefExp::post_construction_initialization()
226316 : {
226317 2178 : }
226318 :
226319 :
226320 :
226321 : // End of memberFunctionString
226322 : // Start of memberFunctionString
226323 : /* #line 6587 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226324 :
226325 :
226326 : SgType*
226327 3197 : SgPntrArrRefExp::get_type() const
226328 : {
226329 : // DQ (1/16/2006): In this function we want to return the base type of the array being referenced (lhs->get_type()).
226330 :
226331 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
226332 :
226333 : // printf ("SgPntrArrRefExp::get_type(): p_expression_type has been removed from many IR nodes \n");
226334 :
226335 : #if 0
226336 : printf ("In SgPntrArrRefExp::get_type() \n");
226337 : #endif
226338 :
226339 : // ROSE_ASSERT(p_expression_type != NULL);
226340 3197 : if (p_expression_type != NULL)
226341 : {
226342 0 : printf ("In SgPntrArrRefExp::get_type(): p_expression_type = %s \n",p_expression_type->class_name().c_str());
226343 : }
226344 :
226345 3197 : ROSE_ASSERT(get_lhs_operand() != NULL);
226346 3197 : ROSE_ASSERT(get_rhs_operand() != NULL);
226347 :
226348 : #if 0
226349 : printf ("In SgPntrArrRefExp::get_type(): this = %p \n",this);
226350 : #endif
226351 :
226352 : // SgType* returnType = get_lhs_operand()->get_type();
226353 3197 : SgType* someType = get_lhs_operand()->get_type();
226354 3197 : ROSE_ASSERT(someType != NULL);
226355 :
226356 : // This code should be shared between the SgPntrArrRefExp and the SgPointerDerefExp IR nodes
226357 : // A better idea would be to have a function that strips off types based on a set of flags
226358 : // that would control stripping of pointer references, array references, C++ references,
226359 : // modifiers, and typedefs.
226360 :
226361 3197 : SgType* returnType = NULL;
226362 3315 : keepStripping:
226363 3315 : ROSE_ASSERT (someType);
226364 :
226365 : #if 0
226366 : printf ("In SgPntrArrRefExp::get_type(): someType = %p = %s \n",someType,someType->class_name().c_str());
226367 : #endif
226368 :
226369 3315 : switch(someType->variantT())
226370 : {
226371 : // These cases all have base types and the pointer dereferencing returns the base type
226372 : // But since p_base_type is placed at each of the different SgType IR nodes we have
226373 : // to handle each case separately.
226374 1202 : case V_SgPointerType:
226375 1202 : {
226376 1202 : SgPointerType* pointerType = isSgPointerType(someType);
226377 1202 : returnType = pointerType->get_base_type();
226378 : #if 0
226379 : printf ("In SgPntrArrRefExp::get_type(): SgPointerType: BEFORE stripType(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
226380 : #endif
226381 : // DQ (6/11/2014): We also need to take any associated SgModifierType node chains used to modity the SgPointerType (e.g. defining const or UPC shared type attributes).
226382 1202 : returnType = returnType->stripType (SgType::STRIP_MODIFIER_TYPE);
226383 : #if 0
226384 : printf ("In SgPntrArrRefExp::get_type(): SgPointerType: AFTER stripType(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
226385 : #endif
226386 1202 : break;
226387 : }
226388 1824 : case V_SgArrayType:
226389 1824 : {
226390 1824 : SgArrayType* arrayType = isSgArrayType(someType);
226391 1824 : returnType = arrayType->get_base_type();
226392 1824 : break;
226393 : }
226394 102 : case V_SgTypedefType:
226395 102 : {
226396 102 : SgTypedefType* typedefType = isSgTypedefType(someType);
226397 102 : someType = typedefType->get_base_type();
226398 102 : goto keepStripping;
226399 : }
226400 16 : case V_SgReferenceType:
226401 16 : {
226402 16 : SgReferenceType* referenceType = isSgReferenceType(someType);
226403 16 : someType = referenceType->get_base_type();
226404 16 : goto keepStripping;
226405 : }
226406 0 : case V_SgModifierType:
226407 0 : {
226408 0 : SgModifierType* modifierType = isSgModifierType(someType);
226409 0 : someType = modifierType->get_base_type();
226410 0 : goto keepStripping;
226411 : }
226412 :
226413 : // DQ (9/12/2010): Added SgTypeFloat support to handle Fortran support (in file LANL_POP/grid.F90).
226414 : case V_SgTypeFloat:
226415 : {
226416 : // DQ (8/17/2010): I think that this is the correct handling of the return value generation.
226417 : returnType = someType;
226418 : break;
226419 : }
226420 :
226421 : // DQ (10/3/2006): Added case of array reference of string type (assume it returns a char).
226422 : // Once we have a wcharString type then we have to add that case to this list as well!
226423 0 : case V_SgTypeString:
226424 0 : {
226425 : // SgTypeString* stringType = isSgTypeString(someType);
226426 : // someType = stringType->get_base_type();
226427 0 : returnType = SgTypeChar::createType();
226428 0 : break;
226429 : }
226430 : // DQ (12/31/2008): This is a better fit for the new EDG/ROSE translation interface.
226431 : default:
226432 : {
226433 : #if 0
226434 : printf ("In SgPntrArrRefExp::get_type(): default case: someType = %p = %s \n",someType,someType->class_name().c_str());
226435 : #endif
226436 : returnType = someType;
226437 : }
226438 : }
226439 :
226440 3197 : ROSE_ASSERT(returnType != NULL);
226441 :
226442 : #if 0
226443 : printf ("In SgPntrArrRefExp::get_type(): returnType = %p = %s \n",returnType,returnType->class_name().c_str());
226444 : #endif
226445 :
226446 3197 : return returnType;
226447 : }
226448 :
226449 :
226450 :
226451 : // End of memberFunctionString
226452 : // Start of memberFunctionString
226453 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
226454 :
226455 : // *** COMMON CODE SECTION BEGINS HERE ***
226456 :
226457 : #if 0
226458 : int
226459 : SgPntrArrRefExp::getVariant() const
226460 : {
226461 : // This function is used in ROSE while "variant()" is used in SAGE
226462 : assert(this != NULL);
226463 : return variant();
226464 : }
226465 : #endif
226466 :
226467 : // This function is used in ROSE in treeTraversal code
226468 : // eventually replaces getVariant() and variant()
226469 : // though after variant() has been removed for a while we will
226470 : // want to change the name of variantT() back to variant()
226471 : // (since the "T" was ment to stand for temporary).
226472 : // When this happens the variantT() will be depricated.
226473 : VariantT
226474 633262 : SgPntrArrRefExp::variantT() const
226475 : {
226476 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
226477 633262 : ROSE_ASSERT(this != NULL);
226478 633262 : return V_SgPntrArrRefExp;
226479 : }
226480 :
226481 : #if 0
226482 : int
226483 : SgPntrArrRefExp::variant() const
226484 : {
226485 : // This function is used in SAGE
226486 : ROSE_ASSERT(this != NULL);
226487 : return ARRAY_OP;
226488 : }
226489 : #endif
226490 :
226491 : ROSE_DLL_API const char*
226492 156 : SgPntrArrRefExp::sage_class_name() const
226493 : {
226494 156 : ROSE_ASSERT(this != NULL);
226495 156 : return "SgPntrArrRefExp";
226496 : }
226497 :
226498 : std::string
226499 1928 : SgPntrArrRefExp::class_name() const
226500 : {
226501 1928 : ROSE_ASSERT(this != NULL);
226502 1928 : return "SgPntrArrRefExp";
226503 : }
226504 :
226505 : // DQ (11/26/2005): Support for visitor pattern mechanims
226506 : // (inferior to ROSE traversal mechanism, experimental).
226507 : void
226508 17916 : SgPntrArrRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
226509 : {
226510 17916 : ROSE_ASSERT(this != NULL);
226511 17916 : visitor.visit(this);
226512 17916 : }
226513 :
226514 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
226515 0 : void SgPntrArrRefExp::accept (ROSE_VisitorPattern & visitor) {
226516 0 : ROSE_ASSERT(this != NULL);
226517 0 : visitor.visit(this);
226518 0 : }
226519 :
226520 : SgPntrArrRefExp*
226521 0 : SgPntrArrRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
226522 : {
226523 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
226524 : // This function is currently only supported for the AST used the represent Binary executables.
226525 : if (0 /* isSgAsmNode(this) != NULL */)
226526 : {
226527 : // Support for regex specification.
226528 : std::string prefixCode = "REGEX:";
226529 : addNewAttribute(prefixCode + s,a);
226530 : }
226531 : #endif
226532 :
226533 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
226534 0 : return this;
226535 : }
226536 :
226537 : // *** COMMON CODE SECTION ENDS HERE ***
226538 :
226539 :
226540 : // End of memberFunctionString
226541 : // Start of memberFunctionString
226542 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
226543 :
226544 :
226545 : #if 0
226546 : //! Error checking support
226547 : /*! Verifies the following:
226548 : - working getVariant() member function
226549 : - calls base class's error() member function
226550 : Every class has one of these functions.
226551 : */
226552 : bool
226553 : SgPntrArrRefExp::error()
226554 : {
226555 : // Put error checking here
226556 :
226557 : ROSE_ASSERT (this != NULL);
226558 : if (getVariant() != ARRAY_OP)
226559 : {
226560 : printf ("Error in SgPntrArrRefExp::error(): SgPntrArrRefExp object has a %s variant \n",
226561 : Cxx_GrammarTerminalNames[getVariant()].name);
226562 : // printf ("Error in SgPntrArrRefExp::error() \n");
226563 : ROSE_ABORT();
226564 : }
226565 :
226566 : ROSE_ASSERT (getVariant() == ARRAY_OP);
226567 : return SgBinaryOp::error();
226568 : }
226569 : #endif
226570 :
226571 :
226572 :
226573 : // End of memberFunctionString
226574 :
226575 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
226576 :
226577 78401 : SgPntrArrRefExp* isSgPntrArrRefExp ( SgNode* inputDerivedClassPointer )
226578 : {
226579 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
226580 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
226581 : // So to fix this we return NULL directly when the input is NULL and avoid the
226582 : // dynamic_cast in this case. This is likely a performance improvement as well.
226583 : // return dynamic_cast<SgPntrArrRefExp*>(inputDerivedClassPointer);
226584 : // Milind Chabbi (8/28/2013): isSgPntrArrRefExp uses table-driven castability instead of c++ default dynamic_cast
226585 : // this improves the running time performance by 10-20%.
226586 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPntrArrRefExp*>(inputDerivedClassPointer);
226587 78401 : return IS_SgPntrArrRefExp_FAST_MACRO(inputDerivedClassPointer);
226588 : }
226589 :
226590 : // DQ (11/8/2003): Added version of functions taking const pointer
226591 0 : const SgPntrArrRefExp* isSgPntrArrRefExp ( const SgNode* inputDerivedClassPointer )
226592 : {
226593 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
226594 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
226595 : // So to fix this we return NULL directly when the input is NULL and avoid the
226596 : // dynamic_cast in this case. This is likely a performance improvement as well.
226597 : // return dynamic_cast<const SgPntrArrRefExp*>(inputDerivedClassPointer);
226598 : // Milind Chabbi (8/28/2013): isSgPntrArrRefExp uses table-driven castability instead of c++ default dynamic_cast
226599 : // this improves the running time performance by 10-20%.
226600 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPntrArrRefExp*>(inputDerivedClassPointer);
226601 0 : return IS_SgPntrArrRefExp_FAST_MACRO(inputDerivedClassPointer);
226602 : }
226603 :
226604 :
226605 :
226606 : /* #line 226607 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226607 :
226608 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
226609 :
226610 : /**
226611 : \brief Generated destructor
226612 :
226613 : This destructor is automatically generated (by ROSETTA). This destructor
226614 : only frees memory of data members associated with the parts of the current IR node which
226615 : are NOT traversed. Those data members that are part of a traversal can be freed using
226616 : a traversal (calling this destructor on all children in a post-order traversal). Such
226617 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
226618 :
226619 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
226620 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
226621 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
226622 :
226623 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
226624 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
226625 : pointers are not yet implemented to call delete on eash pointer in the container.
226626 : (This could be done by derivation from the STL containers to define containers that
226627 : automatically deleted their members.)
226628 :
226629 : */
226630 568 : SgPntrArrRefExp::~SgPntrArrRefExp () {
226631 284 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
226632 :
226633 :
226634 :
226635 : }
226636 :
226637 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
226638 568 : }
226639 :
226640 :
226641 : /* #line 226642 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226642 :
226643 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
226644 :
226645 : // Generated constructor
226646 130 : SgPntrArrRefExp::SgPntrArrRefExp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
226647 130 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
226648 : {
226649 : #ifdef DEBUG
226650 : // printf ("In SgPntrArrRefExp::SgPntrArrRefExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
226651 : #endif
226652 : #if 0
226653 : // debugging information!
226654 : printf ("In SgPntrArrRefExp::SgPntrArrRefExp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
226655 : #endif
226656 :
226657 :
226658 :
226659 : #if 0
226660 : // DQ (7/30/2014): Call a virtual function.
226661 : std::string s = this->class_name();
226662 : #endif
226663 :
226664 : // Test the variant virtual function
226665 : // assert(ARRAY_OP == variant());
226666 130 : assert(ARRAY_OP == this->variant());
226667 130 : ROSE_ASSERT(ARRAY_OP == (int)(this->variantT()));
226668 130 : post_construction_initialization();
226669 :
226670 : // Test the isSgPntrArrRefExp() function since it has been problematic
226671 130 : assert(isSgPntrArrRefExp(this) != NULL);
226672 130 : }
226673 :
226674 : // Generated constructor (all data members)
226675 :
226676 : /* #line 226677 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226677 :
226678 :
226679 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226680 :
226681 :
226682 : // ********************************************************
226683 : // member functions common across all array grammar objects
226684 : // ********************************************************
226685 :
226686 :
226687 :
226688 : /* #line 226689 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226689 :
226690 :
226691 :
226692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226693 :
226694 : // ********************************************************
226695 : // member functions specific to each node in the grammar
226696 : // ********************************************************
226697 :
226698 :
226699 : /* #line 226700 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226700 :
226701 : // Start of memberFunctionString
226702 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226703 :
226704 : void
226705 0 : SgScopeOp::post_construction_initialization()
226706 : {
226707 0 : }
226708 :
226709 :
226710 :
226711 : // End of memberFunctionString
226712 : // Start of memberFunctionString
226713 : /* #line 7141 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226714 :
226715 :
226716 :
226717 : // End of memberFunctionString
226718 : // Start of memberFunctionString
226719 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
226720 :
226721 : // *** COMMON CODE SECTION BEGINS HERE ***
226722 :
226723 : #if 0
226724 : int
226725 : SgScopeOp::getVariant() const
226726 : {
226727 : // This function is used in ROSE while "variant()" is used in SAGE
226728 : assert(this != NULL);
226729 : return variant();
226730 : }
226731 : #endif
226732 :
226733 : // This function is used in ROSE in treeTraversal code
226734 : // eventually replaces getVariant() and variant()
226735 : // though after variant() has been removed for a while we will
226736 : // want to change the name of variantT() back to variant()
226737 : // (since the "T" was ment to stand for temporary).
226738 : // When this happens the variantT() will be depricated.
226739 : VariantT
226740 0 : SgScopeOp::variantT() const
226741 : {
226742 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
226743 0 : ROSE_ASSERT(this != NULL);
226744 0 : return V_SgScopeOp;
226745 : }
226746 :
226747 : #if 0
226748 : int
226749 : SgScopeOp::variant() const
226750 : {
226751 : // This function is used in SAGE
226752 : ROSE_ASSERT(this != NULL);
226753 : return SCOPE_OP;
226754 : }
226755 : #endif
226756 :
226757 : ROSE_DLL_API const char*
226758 0 : SgScopeOp::sage_class_name() const
226759 : {
226760 0 : ROSE_ASSERT(this != NULL);
226761 0 : return "SgScopeOp";
226762 : }
226763 :
226764 : std::string
226765 0 : SgScopeOp::class_name() const
226766 : {
226767 0 : ROSE_ASSERT(this != NULL);
226768 0 : return "SgScopeOp";
226769 : }
226770 :
226771 : // DQ (11/26/2005): Support for visitor pattern mechanims
226772 : // (inferior to ROSE traversal mechanism, experimental).
226773 : void
226774 0 : SgScopeOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
226775 : {
226776 0 : ROSE_ASSERT(this != NULL);
226777 0 : visitor.visit(this);
226778 0 : }
226779 :
226780 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
226781 0 : void SgScopeOp::accept (ROSE_VisitorPattern & visitor) {
226782 0 : ROSE_ASSERT(this != NULL);
226783 0 : visitor.visit(this);
226784 0 : }
226785 :
226786 : SgScopeOp*
226787 0 : SgScopeOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
226788 : {
226789 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
226790 : // This function is currently only supported for the AST used the represent Binary executables.
226791 : if (0 /* isSgAsmNode(this) != NULL */)
226792 : {
226793 : // Support for regex specification.
226794 : std::string prefixCode = "REGEX:";
226795 : addNewAttribute(prefixCode + s,a);
226796 : }
226797 : #endif
226798 :
226799 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
226800 0 : return this;
226801 : }
226802 :
226803 : // *** COMMON CODE SECTION ENDS HERE ***
226804 :
226805 :
226806 : // End of memberFunctionString
226807 : // Start of memberFunctionString
226808 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
226809 :
226810 :
226811 : #if 0
226812 : //! Error checking support
226813 : /*! Verifies the following:
226814 : - working getVariant() member function
226815 : - calls base class's error() member function
226816 : Every class has one of these functions.
226817 : */
226818 : bool
226819 : SgScopeOp::error()
226820 : {
226821 : // Put error checking here
226822 :
226823 : ROSE_ASSERT (this != NULL);
226824 : if (getVariant() != SCOPE_OP)
226825 : {
226826 : printf ("Error in SgScopeOp::error(): SgScopeOp object has a %s variant \n",
226827 : Cxx_GrammarTerminalNames[getVariant()].name);
226828 : // printf ("Error in SgScopeOp::error() \n");
226829 : ROSE_ABORT();
226830 : }
226831 :
226832 : ROSE_ASSERT (getVariant() == SCOPE_OP);
226833 : return SgBinaryOp::error();
226834 : }
226835 : #endif
226836 :
226837 :
226838 :
226839 : // End of memberFunctionString
226840 :
226841 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
226842 :
226843 0 : SgScopeOp* isSgScopeOp ( SgNode* inputDerivedClassPointer )
226844 : {
226845 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
226846 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
226847 : // So to fix this we return NULL directly when the input is NULL and avoid the
226848 : // dynamic_cast in this case. This is likely a performance improvement as well.
226849 : // return dynamic_cast<SgScopeOp*>(inputDerivedClassPointer);
226850 : // Milind Chabbi (8/28/2013): isSgScopeOp uses table-driven castability instead of c++ default dynamic_cast
226851 : // this improves the running time performance by 10-20%.
226852 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgScopeOp*>(inputDerivedClassPointer);
226853 0 : return IS_SgScopeOp_FAST_MACRO(inputDerivedClassPointer);
226854 : }
226855 :
226856 : // DQ (11/8/2003): Added version of functions taking const pointer
226857 0 : const SgScopeOp* isSgScopeOp ( const SgNode* inputDerivedClassPointer )
226858 : {
226859 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
226860 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
226861 : // So to fix this we return NULL directly when the input is NULL and avoid the
226862 : // dynamic_cast in this case. This is likely a performance improvement as well.
226863 : // return dynamic_cast<const SgScopeOp*>(inputDerivedClassPointer);
226864 : // Milind Chabbi (8/28/2013): isSgScopeOp uses table-driven castability instead of c++ default dynamic_cast
226865 : // this improves the running time performance by 10-20%.
226866 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgScopeOp*>(inputDerivedClassPointer);
226867 0 : return IS_SgScopeOp_FAST_MACRO(inputDerivedClassPointer);
226868 : }
226869 :
226870 :
226871 :
226872 : /* #line 226873 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226873 :
226874 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
226875 :
226876 : /**
226877 : \brief Generated destructor
226878 :
226879 : This destructor is automatically generated (by ROSETTA). This destructor
226880 : only frees memory of data members associated with the parts of the current IR node which
226881 : are NOT traversed. Those data members that are part of a traversal can be freed using
226882 : a traversal (calling this destructor on all children in a post-order traversal). Such
226883 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
226884 :
226885 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
226886 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
226887 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
226888 :
226889 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
226890 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
226891 : pointers are not yet implemented to call delete on eash pointer in the container.
226892 : (This could be done by derivation from the STL containers to define containers that
226893 : automatically deleted their members.)
226894 :
226895 : */
226896 0 : SgScopeOp::~SgScopeOp () {
226897 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
226898 :
226899 :
226900 :
226901 : }
226902 :
226903 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
226904 0 : }
226905 :
226906 :
226907 : /* #line 226908 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226908 :
226909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
226910 :
226911 : // Generated constructor
226912 0 : SgScopeOp::SgScopeOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
226913 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
226914 : {
226915 : #ifdef DEBUG
226916 : // printf ("In SgScopeOp::SgScopeOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
226917 : #endif
226918 : #if 0
226919 : // debugging information!
226920 : printf ("In SgScopeOp::SgScopeOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
226921 : #endif
226922 :
226923 :
226924 :
226925 : #if 0
226926 : // DQ (7/30/2014): Call a virtual function.
226927 : std::string s = this->class_name();
226928 : #endif
226929 :
226930 : // Test the variant virtual function
226931 : // assert(SCOPE_OP == variant());
226932 0 : assert(SCOPE_OP == this->variant());
226933 0 : ROSE_ASSERT(SCOPE_OP == (int)(this->variantT()));
226934 0 : post_construction_initialization();
226935 :
226936 : // Test the isSgScopeOp() function since it has been problematic
226937 0 : assert(isSgScopeOp(this) != NULL);
226938 0 : }
226939 :
226940 : // Generated constructor (all data members)
226941 :
226942 : /* #line 226943 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226943 :
226944 :
226945 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226946 :
226947 :
226948 : // ********************************************************
226949 : // member functions common across all array grammar objects
226950 : // ********************************************************
226951 :
226952 :
226953 :
226954 : /* #line 226955 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226955 :
226956 :
226957 :
226958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
226959 :
226960 : // ********************************************************
226961 : // member functions specific to each node in the grammar
226962 : // ********************************************************
226963 :
226964 :
226965 : /* #line 226966 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
226966 :
226967 : // Start of memberFunctionString
226968 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226969 :
226970 : void
226971 5843 : SgAssignOp::post_construction_initialization()
226972 : {
226973 5843 : }
226974 :
226975 :
226976 :
226977 : // End of memberFunctionString
226978 : // Start of memberFunctionString
226979 : /* #line 7145 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
226980 :
226981 :
226982 :
226983 : // End of memberFunctionString
226984 : // Start of memberFunctionString
226985 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
226986 :
226987 : // *** COMMON CODE SECTION BEGINS HERE ***
226988 :
226989 : #if 0
226990 : int
226991 : SgAssignOp::getVariant() const
226992 : {
226993 : // This function is used in ROSE while "variant()" is used in SAGE
226994 : assert(this != NULL);
226995 : return variant();
226996 : }
226997 : #endif
226998 :
226999 : // This function is used in ROSE in treeTraversal code
227000 : // eventually replaces getVariant() and variant()
227001 : // though after variant() has been removed for a while we will
227002 : // want to change the name of variantT() back to variant()
227003 : // (since the "T" was ment to stand for temporary).
227004 : // When this happens the variantT() will be depricated.
227005 : VariantT
227006 1597930 : SgAssignOp::variantT() const
227007 : {
227008 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
227009 1597930 : ROSE_ASSERT(this != NULL);
227010 1597930 : return V_SgAssignOp;
227011 : }
227012 :
227013 : #if 0
227014 : int
227015 : SgAssignOp::variant() const
227016 : {
227017 : // This function is used in SAGE
227018 : ROSE_ASSERT(this != NULL);
227019 : return ASSIGN_OP;
227020 : }
227021 : #endif
227022 :
227023 : ROSE_DLL_API const char*
227024 453 : SgAssignOp::sage_class_name() const
227025 : {
227026 453 : ROSE_ASSERT(this != NULL);
227027 453 : return "SgAssignOp";
227028 : }
227029 :
227030 : std::string
227031 5146 : SgAssignOp::class_name() const
227032 : {
227033 5146 : ROSE_ASSERT(this != NULL);
227034 5146 : return "SgAssignOp";
227035 : }
227036 :
227037 : // DQ (11/26/2005): Support for visitor pattern mechanims
227038 : // (inferior to ROSE traversal mechanism, experimental).
227039 : void
227040 64721 : SgAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
227041 : {
227042 64721 : ROSE_ASSERT(this != NULL);
227043 64721 : visitor.visit(this);
227044 64721 : }
227045 :
227046 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
227047 0 : void SgAssignOp::accept (ROSE_VisitorPattern & visitor) {
227048 0 : ROSE_ASSERT(this != NULL);
227049 0 : visitor.visit(this);
227050 0 : }
227051 :
227052 : SgAssignOp*
227053 0 : SgAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
227054 : {
227055 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
227056 : // This function is currently only supported for the AST used the represent Binary executables.
227057 : if (0 /* isSgAsmNode(this) != NULL */)
227058 : {
227059 : // Support for regex specification.
227060 : std::string prefixCode = "REGEX:";
227061 : addNewAttribute(prefixCode + s,a);
227062 : }
227063 : #endif
227064 :
227065 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
227066 0 : return this;
227067 : }
227068 :
227069 : // *** COMMON CODE SECTION ENDS HERE ***
227070 :
227071 :
227072 : // End of memberFunctionString
227073 : // Start of memberFunctionString
227074 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
227075 :
227076 :
227077 : #if 0
227078 : //! Error checking support
227079 : /*! Verifies the following:
227080 : - working getVariant() member function
227081 : - calls base class's error() member function
227082 : Every class has one of these functions.
227083 : */
227084 : bool
227085 : SgAssignOp::error()
227086 : {
227087 : // Put error checking here
227088 :
227089 : ROSE_ASSERT (this != NULL);
227090 : if (getVariant() != ASSIGN_OP)
227091 : {
227092 : printf ("Error in SgAssignOp::error(): SgAssignOp object has a %s variant \n",
227093 : Cxx_GrammarTerminalNames[getVariant()].name);
227094 : // printf ("Error in SgAssignOp::error() \n");
227095 : ROSE_ABORT();
227096 : }
227097 :
227098 : ROSE_ASSERT (getVariant() == ASSIGN_OP);
227099 : return SgBinaryOp::error();
227100 : }
227101 : #endif
227102 :
227103 :
227104 :
227105 : // End of memberFunctionString
227106 :
227107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
227108 :
227109 5925 : SgAssignOp* isSgAssignOp ( SgNode* inputDerivedClassPointer )
227110 : {
227111 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227112 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227113 : // So to fix this we return NULL directly when the input is NULL and avoid the
227114 : // dynamic_cast in this case. This is likely a performance improvement as well.
227115 : // return dynamic_cast<SgAssignOp*>(inputDerivedClassPointer);
227116 : // Milind Chabbi (8/28/2013): isSgAssignOp uses table-driven castability instead of c++ default dynamic_cast
227117 : // this improves the running time performance by 10-20%.
227118 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAssignOp*>(inputDerivedClassPointer);
227119 5925 : return IS_SgAssignOp_FAST_MACRO(inputDerivedClassPointer);
227120 : }
227121 :
227122 : // DQ (11/8/2003): Added version of functions taking const pointer
227123 0 : const SgAssignOp* isSgAssignOp ( const SgNode* inputDerivedClassPointer )
227124 : {
227125 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227126 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227127 : // So to fix this we return NULL directly when the input is NULL and avoid the
227128 : // dynamic_cast in this case. This is likely a performance improvement as well.
227129 : // return dynamic_cast<const SgAssignOp*>(inputDerivedClassPointer);
227130 : // Milind Chabbi (8/28/2013): isSgAssignOp uses table-driven castability instead of c++ default dynamic_cast
227131 : // this improves the running time performance by 10-20%.
227132 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAssignOp*>(inputDerivedClassPointer);
227133 0 : return IS_SgAssignOp_FAST_MACRO(inputDerivedClassPointer);
227134 : }
227135 :
227136 :
227137 :
227138 : /* #line 227139 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227139 :
227140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227141 :
227142 : /**
227143 : \brief Generated destructor
227144 :
227145 : This destructor is automatically generated (by ROSETTA). This destructor
227146 : only frees memory of data members associated with the parts of the current IR node which
227147 : are NOT traversed. Those data members that are part of a traversal can be freed using
227148 : a traversal (calling this destructor on all children in a post-order traversal). Such
227149 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
227150 :
227151 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
227152 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
227153 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
227154 :
227155 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
227156 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
227157 : pointers are not yet implemented to call delete on eash pointer in the container.
227158 : (This could be done by derivation from the STL containers to define containers that
227159 : automatically deleted their members.)
227160 :
227161 : */
227162 1822 : SgAssignOp::~SgAssignOp () {
227163 911 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
227164 :
227165 :
227166 :
227167 : }
227168 :
227169 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227170 1822 : }
227171 :
227172 :
227173 : /* #line 227174 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227174 :
227175 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
227176 :
227177 : // Generated constructor
227178 17 : SgAssignOp::SgAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
227179 17 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
227180 : {
227181 : #ifdef DEBUG
227182 : // printf ("In SgAssignOp::SgAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
227183 : #endif
227184 : #if 0
227185 : // debugging information!
227186 : printf ("In SgAssignOp::SgAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
227187 : #endif
227188 :
227189 :
227190 :
227191 : #if 0
227192 : // DQ (7/30/2014): Call a virtual function.
227193 : std::string s = this->class_name();
227194 : #endif
227195 :
227196 : // Test the variant virtual function
227197 : // assert(ASSIGN_OP == variant());
227198 17 : assert(ASSIGN_OP == this->variant());
227199 17 : ROSE_ASSERT(ASSIGN_OP == (int)(this->variantT()));
227200 17 : post_construction_initialization();
227201 :
227202 : // Test the isSgAssignOp() function since it has been problematic
227203 17 : assert(isSgAssignOp(this) != NULL);
227204 17 : }
227205 :
227206 : // Generated constructor (all data members)
227207 :
227208 : /* #line 227209 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227209 :
227210 :
227211 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
227212 :
227213 :
227214 : // ********************************************************
227215 : // member functions common across all array grammar objects
227216 : // ********************************************************
227217 :
227218 :
227219 :
227220 : /* #line 227221 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227221 :
227222 :
227223 :
227224 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
227225 :
227226 : // ********************************************************
227227 : // member functions specific to each node in the grammar
227228 : // ********************************************************
227229 :
227230 :
227231 : /* #line 227232 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227232 :
227233 : // Start of memberFunctionString
227234 : /* #line 8631 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
227235 :
227236 :
227237 : void
227238 0 : SgExponentiationOp::post_construction_initialization()
227239 : {
227240 0 : }
227241 :
227242 : #if 0
227243 : SgType*
227244 : SgExponentiationOp::get_type() const
227245 : {
227246 : return NULL;
227247 : }
227248 : #endif
227249 :
227250 :
227251 :
227252 : // End of memberFunctionString
227253 : // Start of memberFunctionString
227254 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
227255 :
227256 : // *** COMMON CODE SECTION BEGINS HERE ***
227257 :
227258 : #if 0
227259 : int
227260 : SgExponentiationOp::getVariant() const
227261 : {
227262 : // This function is used in ROSE while "variant()" is used in SAGE
227263 : assert(this != NULL);
227264 : return variant();
227265 : }
227266 : #endif
227267 :
227268 : // This function is used in ROSE in treeTraversal code
227269 : // eventually replaces getVariant() and variant()
227270 : // though after variant() has been removed for a while we will
227271 : // want to change the name of variantT() back to variant()
227272 : // (since the "T" was ment to stand for temporary).
227273 : // When this happens the variantT() will be depricated.
227274 : VariantT
227275 0 : SgExponentiationOp::variantT() const
227276 : {
227277 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
227278 0 : ROSE_ASSERT(this != NULL);
227279 0 : return V_SgExponentiationOp;
227280 : }
227281 :
227282 : #if 0
227283 : int
227284 : SgExponentiationOp::variant() const
227285 : {
227286 : // This function is used in SAGE
227287 : ROSE_ASSERT(this != NULL);
227288 : return EXPONENTIATION_OP;
227289 : }
227290 : #endif
227291 :
227292 : ROSE_DLL_API const char*
227293 0 : SgExponentiationOp::sage_class_name() const
227294 : {
227295 0 : ROSE_ASSERT(this != NULL);
227296 0 : return "SgExponentiationOp";
227297 : }
227298 :
227299 : std::string
227300 0 : SgExponentiationOp::class_name() const
227301 : {
227302 0 : ROSE_ASSERT(this != NULL);
227303 0 : return "SgExponentiationOp";
227304 : }
227305 :
227306 : // DQ (11/26/2005): Support for visitor pattern mechanims
227307 : // (inferior to ROSE traversal mechanism, experimental).
227308 : void
227309 0 : SgExponentiationOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
227310 : {
227311 0 : ROSE_ASSERT(this != NULL);
227312 0 : visitor.visit(this);
227313 0 : }
227314 :
227315 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
227316 0 : void SgExponentiationOp::accept (ROSE_VisitorPattern & visitor) {
227317 0 : ROSE_ASSERT(this != NULL);
227318 0 : visitor.visit(this);
227319 0 : }
227320 :
227321 : SgExponentiationOp*
227322 0 : SgExponentiationOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
227323 : {
227324 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
227325 : // This function is currently only supported for the AST used the represent Binary executables.
227326 : if (0 /* isSgAsmNode(this) != NULL */)
227327 : {
227328 : // Support for regex specification.
227329 : std::string prefixCode = "REGEX:";
227330 : addNewAttribute(prefixCode + s,a);
227331 : }
227332 : #endif
227333 :
227334 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
227335 0 : return this;
227336 : }
227337 :
227338 : // *** COMMON CODE SECTION ENDS HERE ***
227339 :
227340 :
227341 : // End of memberFunctionString
227342 : // Start of memberFunctionString
227343 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
227344 :
227345 :
227346 : #if 0
227347 : //! Error checking support
227348 : /*! Verifies the following:
227349 : - working getVariant() member function
227350 : - calls base class's error() member function
227351 : Every class has one of these functions.
227352 : */
227353 : bool
227354 : SgExponentiationOp::error()
227355 : {
227356 : // Put error checking here
227357 :
227358 : ROSE_ASSERT (this != NULL);
227359 : if (getVariant() != EXPONENTIATION_OP)
227360 : {
227361 : printf ("Error in SgExponentiationOp::error(): SgExponentiationOp object has a %s variant \n",
227362 : Cxx_GrammarTerminalNames[getVariant()].name);
227363 : // printf ("Error in SgExponentiationOp::error() \n");
227364 : ROSE_ABORT();
227365 : }
227366 :
227367 : ROSE_ASSERT (getVariant() == EXPONENTIATION_OP);
227368 : return SgBinaryOp::error();
227369 : }
227370 : #endif
227371 :
227372 :
227373 :
227374 : // End of memberFunctionString
227375 :
227376 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
227377 :
227378 0 : SgExponentiationOp* isSgExponentiationOp ( SgNode* inputDerivedClassPointer )
227379 : {
227380 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227381 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227382 : // So to fix this we return NULL directly when the input is NULL and avoid the
227383 : // dynamic_cast in this case. This is likely a performance improvement as well.
227384 : // return dynamic_cast<SgExponentiationOp*>(inputDerivedClassPointer);
227385 : // Milind Chabbi (8/28/2013): isSgExponentiationOp uses table-driven castability instead of c++ default dynamic_cast
227386 : // this improves the running time performance by 10-20%.
227387 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExponentiationOp*>(inputDerivedClassPointer);
227388 0 : return IS_SgExponentiationOp_FAST_MACRO(inputDerivedClassPointer);
227389 : }
227390 :
227391 : // DQ (11/8/2003): Added version of functions taking const pointer
227392 0 : const SgExponentiationOp* isSgExponentiationOp ( const SgNode* inputDerivedClassPointer )
227393 : {
227394 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227395 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227396 : // So to fix this we return NULL directly when the input is NULL and avoid the
227397 : // dynamic_cast in this case. This is likely a performance improvement as well.
227398 : // return dynamic_cast<const SgExponentiationOp*>(inputDerivedClassPointer);
227399 : // Milind Chabbi (8/28/2013): isSgExponentiationOp uses table-driven castability instead of c++ default dynamic_cast
227400 : // this improves the running time performance by 10-20%.
227401 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExponentiationOp*>(inputDerivedClassPointer);
227402 0 : return IS_SgExponentiationOp_FAST_MACRO(inputDerivedClassPointer);
227403 : }
227404 :
227405 :
227406 :
227407 : /* #line 227408 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227408 :
227409 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227410 :
227411 : /**
227412 : \brief Generated destructor
227413 :
227414 : This destructor is automatically generated (by ROSETTA). This destructor
227415 : only frees memory of data members associated with the parts of the current IR node which
227416 : are NOT traversed. Those data members that are part of a traversal can be freed using
227417 : a traversal (calling this destructor on all children in a post-order traversal). Such
227418 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
227419 :
227420 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
227421 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
227422 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
227423 :
227424 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
227425 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
227426 : pointers are not yet implemented to call delete on eash pointer in the container.
227427 : (This could be done by derivation from the STL containers to define containers that
227428 : automatically deleted their members.)
227429 :
227430 : */
227431 0 : SgExponentiationOp::~SgExponentiationOp () {
227432 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
227433 :
227434 :
227435 :
227436 : }
227437 :
227438 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227439 0 : }
227440 :
227441 :
227442 : /* #line 227443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227443 :
227444 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
227445 :
227446 : // Generated constructor
227447 0 : SgExponentiationOp::SgExponentiationOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
227448 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
227449 : {
227450 : #ifdef DEBUG
227451 : // printf ("In SgExponentiationOp::SgExponentiationOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
227452 : #endif
227453 : #if 0
227454 : // debugging information!
227455 : printf ("In SgExponentiationOp::SgExponentiationOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
227456 : #endif
227457 :
227458 :
227459 :
227460 : #if 0
227461 : // DQ (7/30/2014): Call a virtual function.
227462 : std::string s = this->class_name();
227463 : #endif
227464 :
227465 : // Test the variant virtual function
227466 : // assert(EXPONENTIATION_OP == variant());
227467 0 : assert(EXPONENTIATION_OP == this->variant());
227468 0 : ROSE_ASSERT(EXPONENTIATION_OP == (int)(this->variantT()));
227469 0 : post_construction_initialization();
227470 :
227471 : // Test the isSgExponentiationOp() function since it has been problematic
227472 0 : assert(isSgExponentiationOp(this) != NULL);
227473 0 : }
227474 :
227475 : // Generated constructor (all data members)
227476 :
227477 : /* #line 227478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227478 :
227479 :
227480 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
227481 :
227482 :
227483 : // ********************************************************
227484 : // member functions common across all array grammar objects
227485 : // ********************************************************
227486 :
227487 :
227488 :
227489 : /* #line 227490 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227490 :
227491 :
227492 :
227493 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
227494 :
227495 : // ********************************************************
227496 : // member functions specific to each node in the grammar
227497 : // ********************************************************
227498 :
227499 :
227500 : /* #line 227501 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227501 :
227502 : // Start of memberFunctionString
227503 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
227504 :
227505 : void
227506 0 : SgConcatenationOp::post_construction_initialization()
227507 : {
227508 0 : }
227509 :
227510 :
227511 :
227512 : // End of memberFunctionString
227513 : // Start of memberFunctionString
227514 : /* #line 7185 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
227515 :
227516 :
227517 :
227518 : // End of memberFunctionString
227519 : // Start of memberFunctionString
227520 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
227521 :
227522 : // *** COMMON CODE SECTION BEGINS HERE ***
227523 :
227524 : #if 0
227525 : int
227526 : SgConcatenationOp::getVariant() const
227527 : {
227528 : // This function is used in ROSE while "variant()" is used in SAGE
227529 : assert(this != NULL);
227530 : return variant();
227531 : }
227532 : #endif
227533 :
227534 : // This function is used in ROSE in treeTraversal code
227535 : // eventually replaces getVariant() and variant()
227536 : // though after variant() has been removed for a while we will
227537 : // want to change the name of variantT() back to variant()
227538 : // (since the "T" was ment to stand for temporary).
227539 : // When this happens the variantT() will be depricated.
227540 : VariantT
227541 0 : SgConcatenationOp::variantT() const
227542 : {
227543 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
227544 0 : ROSE_ASSERT(this != NULL);
227545 0 : return V_SgConcatenationOp;
227546 : }
227547 :
227548 : #if 0
227549 : int
227550 : SgConcatenationOp::variant() const
227551 : {
227552 : // This function is used in SAGE
227553 : ROSE_ASSERT(this != NULL);
227554 : return CONCATENATION_OP;
227555 : }
227556 : #endif
227557 :
227558 : ROSE_DLL_API const char*
227559 0 : SgConcatenationOp::sage_class_name() const
227560 : {
227561 0 : ROSE_ASSERT(this != NULL);
227562 0 : return "SgConcatenationOp";
227563 : }
227564 :
227565 : std::string
227566 0 : SgConcatenationOp::class_name() const
227567 : {
227568 0 : ROSE_ASSERT(this != NULL);
227569 0 : return "SgConcatenationOp";
227570 : }
227571 :
227572 : // DQ (11/26/2005): Support for visitor pattern mechanims
227573 : // (inferior to ROSE traversal mechanism, experimental).
227574 : void
227575 0 : SgConcatenationOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
227576 : {
227577 0 : ROSE_ASSERT(this != NULL);
227578 0 : visitor.visit(this);
227579 0 : }
227580 :
227581 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
227582 0 : void SgConcatenationOp::accept (ROSE_VisitorPattern & visitor) {
227583 0 : ROSE_ASSERT(this != NULL);
227584 0 : visitor.visit(this);
227585 0 : }
227586 :
227587 : SgConcatenationOp*
227588 0 : SgConcatenationOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
227589 : {
227590 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
227591 : // This function is currently only supported for the AST used the represent Binary executables.
227592 : if (0 /* isSgAsmNode(this) != NULL */)
227593 : {
227594 : // Support for regex specification.
227595 : std::string prefixCode = "REGEX:";
227596 : addNewAttribute(prefixCode + s,a);
227597 : }
227598 : #endif
227599 :
227600 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
227601 0 : return this;
227602 : }
227603 :
227604 : // *** COMMON CODE SECTION ENDS HERE ***
227605 :
227606 :
227607 : // End of memberFunctionString
227608 : // Start of memberFunctionString
227609 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
227610 :
227611 :
227612 : #if 0
227613 : //! Error checking support
227614 : /*! Verifies the following:
227615 : - working getVariant() member function
227616 : - calls base class's error() member function
227617 : Every class has one of these functions.
227618 : */
227619 : bool
227620 : SgConcatenationOp::error()
227621 : {
227622 : // Put error checking here
227623 :
227624 : ROSE_ASSERT (this != NULL);
227625 : if (getVariant() != CONCATENATION_OP)
227626 : {
227627 : printf ("Error in SgConcatenationOp::error(): SgConcatenationOp object has a %s variant \n",
227628 : Cxx_GrammarTerminalNames[getVariant()].name);
227629 : // printf ("Error in SgConcatenationOp::error() \n");
227630 : ROSE_ABORT();
227631 : }
227632 :
227633 : ROSE_ASSERT (getVariant() == CONCATENATION_OP);
227634 : return SgBinaryOp::error();
227635 : }
227636 : #endif
227637 :
227638 :
227639 :
227640 : // End of memberFunctionString
227641 :
227642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
227643 :
227644 0 : SgConcatenationOp* isSgConcatenationOp ( SgNode* inputDerivedClassPointer )
227645 : {
227646 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227647 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227648 : // So to fix this we return NULL directly when the input is NULL and avoid the
227649 : // dynamic_cast in this case. This is likely a performance improvement as well.
227650 : // return dynamic_cast<SgConcatenationOp*>(inputDerivedClassPointer);
227651 : // Milind Chabbi (8/28/2013): isSgConcatenationOp uses table-driven castability instead of c++ default dynamic_cast
227652 : // this improves the running time performance by 10-20%.
227653 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgConcatenationOp*>(inputDerivedClassPointer);
227654 0 : return IS_SgConcatenationOp_FAST_MACRO(inputDerivedClassPointer);
227655 : }
227656 :
227657 : // DQ (11/8/2003): Added version of functions taking const pointer
227658 0 : const SgConcatenationOp* isSgConcatenationOp ( const SgNode* inputDerivedClassPointer )
227659 : {
227660 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227661 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227662 : // So to fix this we return NULL directly when the input is NULL and avoid the
227663 : // dynamic_cast in this case. This is likely a performance improvement as well.
227664 : // return dynamic_cast<const SgConcatenationOp*>(inputDerivedClassPointer);
227665 : // Milind Chabbi (8/28/2013): isSgConcatenationOp uses table-driven castability instead of c++ default dynamic_cast
227666 : // this improves the running time performance by 10-20%.
227667 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgConcatenationOp*>(inputDerivedClassPointer);
227668 0 : return IS_SgConcatenationOp_FAST_MACRO(inputDerivedClassPointer);
227669 : }
227670 :
227671 :
227672 :
227673 : /* #line 227674 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227674 :
227675 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227676 :
227677 : /**
227678 : \brief Generated destructor
227679 :
227680 : This destructor is automatically generated (by ROSETTA). This destructor
227681 : only frees memory of data members associated with the parts of the current IR node which
227682 : are NOT traversed. Those data members that are part of a traversal can be freed using
227683 : a traversal (calling this destructor on all children in a post-order traversal). Such
227684 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
227685 :
227686 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
227687 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
227688 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
227689 :
227690 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
227691 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
227692 : pointers are not yet implemented to call delete on eash pointer in the container.
227693 : (This could be done by derivation from the STL containers to define containers that
227694 : automatically deleted their members.)
227695 :
227696 : */
227697 0 : SgConcatenationOp::~SgConcatenationOp () {
227698 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
227699 :
227700 :
227701 :
227702 : }
227703 :
227704 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227705 0 : }
227706 :
227707 :
227708 : /* #line 227709 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227709 :
227710 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
227711 :
227712 : // Generated constructor
227713 0 : SgConcatenationOp::SgConcatenationOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
227714 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
227715 : {
227716 : #ifdef DEBUG
227717 : // printf ("In SgConcatenationOp::SgConcatenationOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
227718 : #endif
227719 : #if 0
227720 : // debugging information!
227721 : printf ("In SgConcatenationOp::SgConcatenationOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
227722 : #endif
227723 :
227724 :
227725 :
227726 : #if 0
227727 : // DQ (7/30/2014): Call a virtual function.
227728 : std::string s = this->class_name();
227729 : #endif
227730 :
227731 : // Test the variant virtual function
227732 : // assert(CONCATENATION_OP == variant());
227733 0 : assert(CONCATENATION_OP == this->variant());
227734 0 : ROSE_ASSERT(CONCATENATION_OP == (int)(this->variantT()));
227735 0 : post_construction_initialization();
227736 :
227737 : // Test the isSgConcatenationOp() function since it has been problematic
227738 0 : assert(isSgConcatenationOp(this) != NULL);
227739 0 : }
227740 :
227741 : // Generated constructor (all data members)
227742 :
227743 : /* #line 227744 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227744 :
227745 :
227746 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
227747 :
227748 :
227749 : // ********************************************************
227750 : // member functions common across all array grammar objects
227751 : // ********************************************************
227752 :
227753 :
227754 :
227755 : /* #line 227756 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227756 :
227757 :
227758 :
227759 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
227760 :
227761 : // ********************************************************
227762 : // member functions specific to each node in the grammar
227763 : // ********************************************************
227764 :
227765 :
227766 : /* #line 227767 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227767 :
227768 : // Start of memberFunctionString
227769 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
227770 :
227771 : void
227772 1 : SgPointerAssignOp::post_construction_initialization()
227773 : {
227774 1 : }
227775 :
227776 :
227777 :
227778 : // End of memberFunctionString
227779 : // Start of memberFunctionString
227780 : /* #line 7149 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
227781 :
227782 :
227783 :
227784 : // End of memberFunctionString
227785 : // Start of memberFunctionString
227786 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
227787 :
227788 : // *** COMMON CODE SECTION BEGINS HERE ***
227789 :
227790 : #if 0
227791 : int
227792 : SgPointerAssignOp::getVariant() const
227793 : {
227794 : // This function is used in ROSE while "variant()" is used in SAGE
227795 : assert(this != NULL);
227796 : return variant();
227797 : }
227798 : #endif
227799 :
227800 : // This function is used in ROSE in treeTraversal code
227801 : // eventually replaces getVariant() and variant()
227802 : // though after variant() has been removed for a while we will
227803 : // want to change the name of variantT() back to variant()
227804 : // (since the "T" was ment to stand for temporary).
227805 : // When this happens the variantT() will be depricated.
227806 : VariantT
227807 708 : SgPointerAssignOp::variantT() const
227808 : {
227809 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
227810 708 : ROSE_ASSERT(this != NULL);
227811 708 : return V_SgPointerAssignOp;
227812 : }
227813 :
227814 : #if 0
227815 : int
227816 : SgPointerAssignOp::variant() const
227817 : {
227818 : // This function is used in SAGE
227819 : ROSE_ASSERT(this != NULL);
227820 : return POINTER_ASSIGN_OP;
227821 : }
227822 : #endif
227823 :
227824 : ROSE_DLL_API const char*
227825 2 : SgPointerAssignOp::sage_class_name() const
227826 : {
227827 2 : ROSE_ASSERT(this != NULL);
227828 2 : return "SgPointerAssignOp";
227829 : }
227830 :
227831 : std::string
227832 1 : SgPointerAssignOp::class_name() const
227833 : {
227834 1 : ROSE_ASSERT(this != NULL);
227835 1 : return "SgPointerAssignOp";
227836 : }
227837 :
227838 : // DQ (11/26/2005): Support for visitor pattern mechanims
227839 : // (inferior to ROSE traversal mechanism, experimental).
227840 : void
227841 0 : SgPointerAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
227842 : {
227843 0 : ROSE_ASSERT(this != NULL);
227844 0 : visitor.visit(this);
227845 0 : }
227846 :
227847 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
227848 0 : void SgPointerAssignOp::accept (ROSE_VisitorPattern & visitor) {
227849 0 : ROSE_ASSERT(this != NULL);
227850 0 : visitor.visit(this);
227851 0 : }
227852 :
227853 : SgPointerAssignOp*
227854 0 : SgPointerAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
227855 : {
227856 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
227857 : // This function is currently only supported for the AST used the represent Binary executables.
227858 : if (0 /* isSgAsmNode(this) != NULL */)
227859 : {
227860 : // Support for regex specification.
227861 : std::string prefixCode = "REGEX:";
227862 : addNewAttribute(prefixCode + s,a);
227863 : }
227864 : #endif
227865 :
227866 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
227867 0 : return this;
227868 : }
227869 :
227870 : // *** COMMON CODE SECTION ENDS HERE ***
227871 :
227872 :
227873 : // End of memberFunctionString
227874 : // Start of memberFunctionString
227875 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
227876 :
227877 :
227878 : #if 0
227879 : //! Error checking support
227880 : /*! Verifies the following:
227881 : - working getVariant() member function
227882 : - calls base class's error() member function
227883 : Every class has one of these functions.
227884 : */
227885 : bool
227886 : SgPointerAssignOp::error()
227887 : {
227888 : // Put error checking here
227889 :
227890 : ROSE_ASSERT (this != NULL);
227891 : if (getVariant() != POINTER_ASSIGN_OP)
227892 : {
227893 : printf ("Error in SgPointerAssignOp::error(): SgPointerAssignOp object has a %s variant \n",
227894 : Cxx_GrammarTerminalNames[getVariant()].name);
227895 : // printf ("Error in SgPointerAssignOp::error() \n");
227896 : ROSE_ABORT();
227897 : }
227898 :
227899 : ROSE_ASSERT (getVariant() == POINTER_ASSIGN_OP);
227900 : return SgBinaryOp::error();
227901 : }
227902 : #endif
227903 :
227904 :
227905 :
227906 : // End of memberFunctionString
227907 :
227908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
227909 :
227910 1 : SgPointerAssignOp* isSgPointerAssignOp ( SgNode* inputDerivedClassPointer )
227911 : {
227912 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227913 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227914 : // So to fix this we return NULL directly when the input is NULL and avoid the
227915 : // dynamic_cast in this case. This is likely a performance improvement as well.
227916 : // return dynamic_cast<SgPointerAssignOp*>(inputDerivedClassPointer);
227917 : // Milind Chabbi (8/28/2013): isSgPointerAssignOp uses table-driven castability instead of c++ default dynamic_cast
227918 : // this improves the running time performance by 10-20%.
227919 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPointerAssignOp*>(inputDerivedClassPointer);
227920 1 : return IS_SgPointerAssignOp_FAST_MACRO(inputDerivedClassPointer);
227921 : }
227922 :
227923 : // DQ (11/8/2003): Added version of functions taking const pointer
227924 0 : const SgPointerAssignOp* isSgPointerAssignOp ( const SgNode* inputDerivedClassPointer )
227925 : {
227926 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
227927 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
227928 : // So to fix this we return NULL directly when the input is NULL and avoid the
227929 : // dynamic_cast in this case. This is likely a performance improvement as well.
227930 : // return dynamic_cast<const SgPointerAssignOp*>(inputDerivedClassPointer);
227931 : // Milind Chabbi (8/28/2013): isSgPointerAssignOp uses table-driven castability instead of c++ default dynamic_cast
227932 : // this improves the running time performance by 10-20%.
227933 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPointerAssignOp*>(inputDerivedClassPointer);
227934 0 : return IS_SgPointerAssignOp_FAST_MACRO(inputDerivedClassPointer);
227935 : }
227936 :
227937 :
227938 :
227939 : /* #line 227940 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227940 :
227941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227942 :
227943 : /**
227944 : \brief Generated destructor
227945 :
227946 : This destructor is automatically generated (by ROSETTA). This destructor
227947 : only frees memory of data members associated with the parts of the current IR node which
227948 : are NOT traversed. Those data members that are part of a traversal can be freed using
227949 : a traversal (calling this destructor on all children in a post-order traversal). Such
227950 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
227951 :
227952 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
227953 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
227954 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
227955 :
227956 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
227957 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
227958 : pointers are not yet implemented to call delete on eash pointer in the container.
227959 : (This could be done by derivation from the STL containers to define containers that
227960 : automatically deleted their members.)
227961 :
227962 : */
227963 0 : SgPointerAssignOp::~SgPointerAssignOp () {
227964 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
227965 :
227966 :
227967 :
227968 : }
227969 :
227970 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
227971 0 : }
227972 :
227973 :
227974 : /* #line 227975 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
227975 :
227976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
227977 :
227978 : // Generated constructor
227979 0 : SgPointerAssignOp::SgPointerAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
227980 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
227981 : {
227982 : #ifdef DEBUG
227983 : // printf ("In SgPointerAssignOp::SgPointerAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
227984 : #endif
227985 : #if 0
227986 : // debugging information!
227987 : printf ("In SgPointerAssignOp::SgPointerAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
227988 : #endif
227989 :
227990 :
227991 :
227992 : #if 0
227993 : // DQ (7/30/2014): Call a virtual function.
227994 : std::string s = this->class_name();
227995 : #endif
227996 :
227997 : // Test the variant virtual function
227998 : // assert(POINTER_ASSIGN_OP == variant());
227999 0 : assert(POINTER_ASSIGN_OP == this->variant());
228000 0 : ROSE_ASSERT(POINTER_ASSIGN_OP == (int)(this->variantT()));
228001 0 : post_construction_initialization();
228002 :
228003 : // Test the isSgPointerAssignOp() function since it has been problematic
228004 0 : assert(isSgPointerAssignOp(this) != NULL);
228005 0 : }
228006 :
228007 : // Generated constructor (all data members)
228008 :
228009 : /* #line 228010 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228010 :
228011 :
228012 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228013 :
228014 :
228015 : // ********************************************************
228016 : // member functions common across all array grammar objects
228017 : // ********************************************************
228018 :
228019 :
228020 :
228021 : /* #line 228022 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228022 :
228023 :
228024 :
228025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228026 :
228027 : // ********************************************************
228028 : // member functions specific to each node in the grammar
228029 : // ********************************************************
228030 :
228031 :
228032 : /* #line 228033 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228033 :
228034 : // Start of memberFunctionString
228035 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
228036 :
228037 : void
228038 0 : SgUserDefinedBinaryOp::post_construction_initialization()
228039 : {
228040 0 : }
228041 :
228042 :
228043 :
228044 : // End of memberFunctionString
228045 : // Start of memberFunctionString
228046 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
228047 :
228048 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
228049 :
228050 : SgName
228051 0 : SgUserDefinedBinaryOp::get_operator_name () const
228052 : {
228053 0 : ROSE_ASSERT (this != NULL);
228054 :
228055 : #if 0
228056 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
228057 : // used to trigger marking transformations for the token-based unparsing.
228058 : printf ("SgUserDefinedBinaryOp::get_operator_name = %p = %s \n",this,this->class_name().c_str());
228059 : #endif
228060 :
228061 0 : return p_operator_name;
228062 : }
228063 :
228064 : void
228065 0 : SgUserDefinedBinaryOp::set_operator_name ( SgName operator_name )
228066 : {
228067 0 : ROSE_ASSERT (this != NULL);
228068 :
228069 : #if 0
228070 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
228071 : // used to trigger marking transformations for the token-based unparsing.
228072 : printf ("SgUserDefinedBinaryOp::set_operator_name = %p = %s \n",this,this->class_name().c_str());
228073 : #endif
228074 :
228075 0 : set_isModified(true);
228076 :
228077 0 : p_operator_name = operator_name;
228078 0 : }
228079 :
228080 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
228081 :
228082 :
228083 : // End of memberFunctionString
228084 : // Start of memberFunctionString
228085 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
228086 :
228087 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
228088 :
228089 : SgFunctionSymbol*
228090 0 : SgUserDefinedBinaryOp::get_symbol () const
228091 : {
228092 0 : ROSE_ASSERT (this != NULL);
228093 :
228094 : #if 0
228095 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
228096 : // used to trigger marking transformations for the token-based unparsing.
228097 : printf ("SgUserDefinedBinaryOp::get_symbol = %p = %s \n",this,this->class_name().c_str());
228098 : #endif
228099 :
228100 0 : return p_symbol;
228101 : }
228102 :
228103 : void
228104 0 : SgUserDefinedBinaryOp::set_symbol ( SgFunctionSymbol* symbol )
228105 : {
228106 0 : ROSE_ASSERT (this != NULL);
228107 :
228108 : #if 0
228109 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
228110 : // used to trigger marking transformations for the token-based unparsing.
228111 : printf ("SgUserDefinedBinaryOp::set_symbol = %p = %s \n",this,this->class_name().c_str());
228112 : #endif
228113 :
228114 0 : set_isModified(true);
228115 :
228116 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
228117 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
228118 : {
228119 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
228120 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
228121 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
228122 : ROSE_ASSERT(false);
228123 : #endif
228124 : }
228125 : #endif
228126 0 : p_symbol = symbol;
228127 0 : }
228128 :
228129 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
228130 :
228131 :
228132 : // End of memberFunctionString
228133 : // Start of memberFunctionString
228134 : /* #line 9320 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
228135 :
228136 : SgType*
228137 0 : SgUserDefinedBinaryOp::get_type() const
228138 : {
228139 : // DQ (10/8/2008): Unclear how this should be implemented right now!
228140 0 : ROSE_ASSERT(get_symbol() != NULL);
228141 :
228142 : #if 1
228143 0 : printf ("In SgUserDefinedBinaryOp::get_type() \n");
228144 : #endif
228145 :
228146 0 : SgType* returnType = get_symbol()->get_type();
228147 0 : ROSE_ASSERT(returnType != NULL);
228148 0 : return returnType;
228149 : }
228150 :
228151 :
228152 :
228153 : // End of memberFunctionString
228154 : // Start of memberFunctionString
228155 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
228156 :
228157 : // *** COMMON CODE SECTION BEGINS HERE ***
228158 :
228159 : #if 0
228160 : int
228161 : SgUserDefinedBinaryOp::getVariant() const
228162 : {
228163 : // This function is used in ROSE while "variant()" is used in SAGE
228164 : assert(this != NULL);
228165 : return variant();
228166 : }
228167 : #endif
228168 :
228169 : // This function is used in ROSE in treeTraversal code
228170 : // eventually replaces getVariant() and variant()
228171 : // though after variant() has been removed for a while we will
228172 : // want to change the name of variantT() back to variant()
228173 : // (since the "T" was ment to stand for temporary).
228174 : // When this happens the variantT() will be depricated.
228175 : VariantT
228176 0 : SgUserDefinedBinaryOp::variantT() const
228177 : {
228178 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
228179 0 : ROSE_ASSERT(this != NULL);
228180 0 : return V_SgUserDefinedBinaryOp;
228181 : }
228182 :
228183 : #if 0
228184 : int
228185 : SgUserDefinedBinaryOp::variant() const
228186 : {
228187 : // This function is used in SAGE
228188 : ROSE_ASSERT(this != NULL);
228189 : return USER_DEFINED_BINARY_OP;
228190 : }
228191 : #endif
228192 :
228193 : ROSE_DLL_API const char*
228194 0 : SgUserDefinedBinaryOp::sage_class_name() const
228195 : {
228196 0 : ROSE_ASSERT(this != NULL);
228197 0 : return "SgUserDefinedBinaryOp";
228198 : }
228199 :
228200 : std::string
228201 0 : SgUserDefinedBinaryOp::class_name() const
228202 : {
228203 0 : ROSE_ASSERT(this != NULL);
228204 0 : return "SgUserDefinedBinaryOp";
228205 : }
228206 :
228207 : // DQ (11/26/2005): Support for visitor pattern mechanims
228208 : // (inferior to ROSE traversal mechanism, experimental).
228209 : void
228210 0 : SgUserDefinedBinaryOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
228211 : {
228212 0 : ROSE_ASSERT(this != NULL);
228213 0 : visitor.visit(this);
228214 0 : }
228215 :
228216 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
228217 0 : void SgUserDefinedBinaryOp::accept (ROSE_VisitorPattern & visitor) {
228218 0 : ROSE_ASSERT(this != NULL);
228219 0 : visitor.visit(this);
228220 0 : }
228221 :
228222 : SgUserDefinedBinaryOp*
228223 0 : SgUserDefinedBinaryOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
228224 : {
228225 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
228226 : // This function is currently only supported for the AST used the represent Binary executables.
228227 : if (0 /* isSgAsmNode(this) != NULL */)
228228 : {
228229 : // Support for regex specification.
228230 : std::string prefixCode = "REGEX:";
228231 : addNewAttribute(prefixCode + s,a);
228232 : }
228233 : #endif
228234 :
228235 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
228236 0 : return this;
228237 : }
228238 :
228239 : // *** COMMON CODE SECTION ENDS HERE ***
228240 :
228241 :
228242 : // End of memberFunctionString
228243 : // Start of memberFunctionString
228244 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
228245 :
228246 :
228247 : #if 0
228248 : //! Error checking support
228249 : /*! Verifies the following:
228250 : - working getVariant() member function
228251 : - calls base class's error() member function
228252 : Every class has one of these functions.
228253 : */
228254 : bool
228255 : SgUserDefinedBinaryOp::error()
228256 : {
228257 : // Put error checking here
228258 :
228259 : ROSE_ASSERT (this != NULL);
228260 : if (getVariant() != USER_DEFINED_BINARY_OP)
228261 : {
228262 : printf ("Error in SgUserDefinedBinaryOp::error(): SgUserDefinedBinaryOp object has a %s variant \n",
228263 : Cxx_GrammarTerminalNames[getVariant()].name);
228264 : // printf ("Error in SgUserDefinedBinaryOp::error() \n");
228265 : ROSE_ABORT();
228266 : }
228267 :
228268 : ROSE_ASSERT (getVariant() == USER_DEFINED_BINARY_OP);
228269 : return SgBinaryOp::error();
228270 : }
228271 : #endif
228272 :
228273 :
228274 :
228275 : // End of memberFunctionString
228276 :
228277 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
228278 :
228279 1342 : SgUserDefinedBinaryOp* isSgUserDefinedBinaryOp ( SgNode* inputDerivedClassPointer )
228280 : {
228281 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
228282 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
228283 : // So to fix this we return NULL directly when the input is NULL and avoid the
228284 : // dynamic_cast in this case. This is likely a performance improvement as well.
228285 : // return dynamic_cast<SgUserDefinedBinaryOp*>(inputDerivedClassPointer);
228286 : // Milind Chabbi (8/28/2013): isSgUserDefinedBinaryOp uses table-driven castability instead of c++ default dynamic_cast
228287 : // this improves the running time performance by 10-20%.
228288 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUserDefinedBinaryOp*>(inputDerivedClassPointer);
228289 1342 : return IS_SgUserDefinedBinaryOp_FAST_MACRO(inputDerivedClassPointer);
228290 : }
228291 :
228292 : // DQ (11/8/2003): Added version of functions taking const pointer
228293 0 : const SgUserDefinedBinaryOp* isSgUserDefinedBinaryOp ( const SgNode* inputDerivedClassPointer )
228294 : {
228295 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
228296 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
228297 : // So to fix this we return NULL directly when the input is NULL and avoid the
228298 : // dynamic_cast in this case. This is likely a performance improvement as well.
228299 : // return dynamic_cast<const SgUserDefinedBinaryOp*>(inputDerivedClassPointer);
228300 : // Milind Chabbi (8/28/2013): isSgUserDefinedBinaryOp uses table-driven castability instead of c++ default dynamic_cast
228301 : // this improves the running time performance by 10-20%.
228302 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUserDefinedBinaryOp*>(inputDerivedClassPointer);
228303 0 : return IS_SgUserDefinedBinaryOp_FAST_MACRO(inputDerivedClassPointer);
228304 : }
228305 :
228306 :
228307 :
228308 : /* #line 228309 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228309 :
228310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
228311 :
228312 : /**
228313 : \brief Generated destructor
228314 :
228315 : This destructor is automatically generated (by ROSETTA). This destructor
228316 : only frees memory of data members associated with the parts of the current IR node which
228317 : are NOT traversed. Those data members that are part of a traversal can be freed using
228318 : a traversal (calling this destructor on all children in a post-order traversal). Such
228319 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
228320 :
228321 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
228322 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
228323 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
228324 :
228325 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
228326 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
228327 : pointers are not yet implemented to call delete on eash pointer in the container.
228328 : (This could be done by derivation from the STL containers to define containers that
228329 : automatically deleted their members.)
228330 :
228331 : */
228332 0 : SgUserDefinedBinaryOp::~SgUserDefinedBinaryOp () {
228333 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
228334 :
228335 :
228336 : // case: not a listType for operator_name
228337 0 : p_operator_name = ""; // non list case
228338 : // case: not a listType for symbol
228339 0 : p_symbol = NULL; // non list case
228340 :
228341 : }
228342 :
228343 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
228344 0 : }
228345 :
228346 :
228347 : /* #line 228348 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228348 :
228349 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
228350 :
228351 : // Generated constructor
228352 0 : SgUserDefinedBinaryOp::SgUserDefinedBinaryOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type, SgName operator_name, SgFunctionSymbol* symbol )
228353 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
228354 : {
228355 : #ifdef DEBUG
228356 : // printf ("In SgUserDefinedBinaryOp::SgUserDefinedBinaryOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type, SgName operator_name, SgFunctionSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
228357 : #endif
228358 : #if 0
228359 : // debugging information!
228360 : printf ("In SgUserDefinedBinaryOp::SgUserDefinedBinaryOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type, SgName operator_name, SgFunctionSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
228361 : #endif
228362 :
228363 0 : p_operator_name = operator_name;
228364 0 : p_symbol = symbol;
228365 :
228366 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
228367 :
228368 : #if 0
228369 : // DQ (7/30/2014): Call a virtual function.
228370 : std::string s = this->class_name();
228371 : #endif
228372 :
228373 : // Test the variant virtual function
228374 : // assert(USER_DEFINED_BINARY_OP == variant());
228375 0 : assert(USER_DEFINED_BINARY_OP == this->variant());
228376 0 : ROSE_ASSERT(USER_DEFINED_BINARY_OP == (int)(this->variantT()));
228377 0 : post_construction_initialization();
228378 :
228379 : // Test the isSgUserDefinedBinaryOp() function since it has been problematic
228380 0 : assert(isSgUserDefinedBinaryOp(this) != NULL);
228381 0 : }
228382 :
228383 : // Generated constructor (all data members)
228384 :
228385 : /* #line 228386 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228386 :
228387 :
228388 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228389 :
228390 :
228391 : // ********************************************************
228392 : // member functions common across all array grammar objects
228393 : // ********************************************************
228394 :
228395 :
228396 :
228397 : /* #line 228398 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228398 :
228399 :
228400 :
228401 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228402 :
228403 : // ********************************************************
228404 : // member functions specific to each node in the grammar
228405 : // ********************************************************
228406 :
228407 :
228408 : /* #line 228409 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228409 :
228410 : // Start of memberFunctionString
228411 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
228412 :
228413 : void
228414 604 : SgCompoundAssignOp::post_construction_initialization()
228415 : {
228416 604 : }
228417 :
228418 :
228419 :
228420 : // End of memberFunctionString
228421 : // Start of memberFunctionString
228422 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
228423 :
228424 : // *** COMMON CODE SECTION BEGINS HERE ***
228425 :
228426 : #if 0
228427 : int
228428 : SgCompoundAssignOp::getVariant() const
228429 : {
228430 : // This function is used in ROSE while "variant()" is used in SAGE
228431 : assert(this != NULL);
228432 : return variant();
228433 : }
228434 : #endif
228435 :
228436 : // This function is used in ROSE in treeTraversal code
228437 : // eventually replaces getVariant() and variant()
228438 : // though after variant() has been removed for a while we will
228439 : // want to change the name of variantT() back to variant()
228440 : // (since the "T" was ment to stand for temporary).
228441 : // When this happens the variantT() will be depricated.
228442 : VariantT
228443 1812 : SgCompoundAssignOp::variantT() const
228444 : {
228445 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
228446 1812 : ROSE_ASSERT(this != NULL);
228447 1812 : return V_SgCompoundAssignOp;
228448 : }
228449 :
228450 : #if 0
228451 : int
228452 : SgCompoundAssignOp::variant() const
228453 : {
228454 : // This function is used in SAGE
228455 : ROSE_ASSERT(this != NULL);
228456 : return COMPOUND_ASSIGN_OP;
228457 : }
228458 : #endif
228459 :
228460 : ROSE_DLL_API const char*
228461 0 : SgCompoundAssignOp::sage_class_name() const
228462 : {
228463 0 : ROSE_ASSERT(this != NULL);
228464 0 : return "SgCompoundAssignOp";
228465 : }
228466 :
228467 : std::string
228468 0 : SgCompoundAssignOp::class_name() const
228469 : {
228470 0 : ROSE_ASSERT(this != NULL);
228471 0 : return "SgCompoundAssignOp";
228472 : }
228473 :
228474 : // DQ (11/26/2005): Support for visitor pattern mechanims
228475 : // (inferior to ROSE traversal mechanism, experimental).
228476 : void
228477 0 : SgCompoundAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
228478 : {
228479 0 : ROSE_ASSERT(this != NULL);
228480 0 : visitor.visit(this);
228481 0 : }
228482 :
228483 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
228484 0 : void SgCompoundAssignOp::accept (ROSE_VisitorPattern & visitor) {
228485 0 : ROSE_ASSERT(this != NULL);
228486 0 : visitor.visit(this);
228487 0 : }
228488 :
228489 : SgCompoundAssignOp*
228490 0 : SgCompoundAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
228491 : {
228492 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
228493 : // This function is currently only supported for the AST used the represent Binary executables.
228494 : if (0 /* isSgAsmNode(this) != NULL */)
228495 : {
228496 : // Support for regex specification.
228497 : std::string prefixCode = "REGEX:";
228498 : addNewAttribute(prefixCode + s,a);
228499 : }
228500 : #endif
228501 :
228502 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
228503 0 : return this;
228504 : }
228505 :
228506 : // *** COMMON CODE SECTION ENDS HERE ***
228507 :
228508 :
228509 : // End of memberFunctionString
228510 : // Start of memberFunctionString
228511 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
228512 :
228513 :
228514 : #if 0
228515 : //! Error checking support
228516 : /*! Verifies the following:
228517 : - working getVariant() member function
228518 : - calls base class's error() member function
228519 : Every class has one of these functions.
228520 : */
228521 : bool
228522 : SgCompoundAssignOp::error()
228523 : {
228524 : // Put error checking here
228525 :
228526 : ROSE_ASSERT (this != NULL);
228527 : if (getVariant() != COMPOUND_ASSIGN_OP)
228528 : {
228529 : printf ("Error in SgCompoundAssignOp::error(): SgCompoundAssignOp object has a %s variant \n",
228530 : Cxx_GrammarTerminalNames[getVariant()].name);
228531 : // printf ("Error in SgCompoundAssignOp::error() \n");
228532 : ROSE_ABORT();
228533 : }
228534 :
228535 : ROSE_ASSERT (getVariant() == COMPOUND_ASSIGN_OP);
228536 : return SgBinaryOp::error();
228537 : }
228538 : #endif
228539 :
228540 :
228541 :
228542 : // End of memberFunctionString
228543 :
228544 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
228545 :
228546 604 : SgCompoundAssignOp* isSgCompoundAssignOp ( SgNode* inputDerivedClassPointer )
228547 : {
228548 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
228549 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
228550 : // So to fix this we return NULL directly when the input is NULL and avoid the
228551 : // dynamic_cast in this case. This is likely a performance improvement as well.
228552 : // return dynamic_cast<SgCompoundAssignOp*>(inputDerivedClassPointer);
228553 : // Milind Chabbi (8/28/2013): isSgCompoundAssignOp uses table-driven castability instead of c++ default dynamic_cast
228554 : // this improves the running time performance by 10-20%.
228555 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCompoundAssignOp*>(inputDerivedClassPointer);
228556 604 : return IS_SgCompoundAssignOp_FAST_MACRO(inputDerivedClassPointer);
228557 : }
228558 :
228559 : // DQ (11/8/2003): Added version of functions taking const pointer
228560 0 : const SgCompoundAssignOp* isSgCompoundAssignOp ( const SgNode* inputDerivedClassPointer )
228561 : {
228562 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
228563 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
228564 : // So to fix this we return NULL directly when the input is NULL and avoid the
228565 : // dynamic_cast in this case. This is likely a performance improvement as well.
228566 : // return dynamic_cast<const SgCompoundAssignOp*>(inputDerivedClassPointer);
228567 : // Milind Chabbi (8/28/2013): isSgCompoundAssignOp uses table-driven castability instead of c++ default dynamic_cast
228568 : // this improves the running time performance by 10-20%.
228569 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCompoundAssignOp*>(inputDerivedClassPointer);
228570 0 : return IS_SgCompoundAssignOp_FAST_MACRO(inputDerivedClassPointer);
228571 : }
228572 :
228573 :
228574 :
228575 : /* #line 228576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228576 :
228577 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
228578 :
228579 : /**
228580 : \brief Generated destructor
228581 :
228582 : This destructor is automatically generated (by ROSETTA). This destructor
228583 : only frees memory of data members associated with the parts of the current IR node which
228584 : are NOT traversed. Those data members that are part of a traversal can be freed using
228585 : a traversal (calling this destructor on all children in a post-order traversal). Such
228586 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
228587 :
228588 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
228589 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
228590 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
228591 :
228592 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
228593 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
228594 : pointers are not yet implemented to call delete on eash pointer in the container.
228595 : (This could be done by derivation from the STL containers to define containers that
228596 : automatically deleted their members.)
228597 :
228598 : */
228599 103 : SgCompoundAssignOp::~SgCompoundAssignOp () {
228600 103 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
228601 :
228602 :
228603 :
228604 : }
228605 :
228606 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
228607 103 : }
228608 :
228609 :
228610 : /* #line 228611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228611 :
228612 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
228613 :
228614 : // Generated constructor
228615 2 : SgCompoundAssignOp::SgCompoundAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
228616 2 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
228617 : {
228618 : #ifdef DEBUG
228619 : // printf ("In SgCompoundAssignOp::SgCompoundAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
228620 : #endif
228621 : #if 0
228622 : // debugging information!
228623 : printf ("In SgCompoundAssignOp::SgCompoundAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
228624 : #endif
228625 :
228626 :
228627 :
228628 : #if 0
228629 : // DQ (7/30/2014): Call a virtual function.
228630 : std::string s = this->class_name();
228631 : #endif
228632 :
228633 : // Test the variant virtual function
228634 : // assert(COMPOUND_ASSIGN_OP == variant());
228635 2 : assert(COMPOUND_ASSIGN_OP == this->variant());
228636 2 : ROSE_ASSERT(COMPOUND_ASSIGN_OP == (int)(this->variantT()));
228637 2 : post_construction_initialization();
228638 :
228639 : // Test the isSgCompoundAssignOp() function since it has been problematic
228640 2 : assert(isSgCompoundAssignOp(this) != NULL);
228641 2 : }
228642 :
228643 : // Generated constructor (all data members)
228644 :
228645 : /* #line 228646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228646 :
228647 :
228648 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228649 :
228650 :
228651 : // ********************************************************
228652 : // member functions common across all array grammar objects
228653 : // ********************************************************
228654 :
228655 :
228656 :
228657 : /* #line 228658 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228658 :
228659 :
228660 :
228661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228662 :
228663 : // ********************************************************
228664 : // member functions specific to each node in the grammar
228665 : // ********************************************************
228666 :
228667 :
228668 : /* #line 228669 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228669 :
228670 : // Start of memberFunctionString
228671 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
228672 :
228673 : void
228674 379 : SgPlusAssignOp::post_construction_initialization()
228675 : {
228676 379 : }
228677 :
228678 :
228679 :
228680 : // End of memberFunctionString
228681 : // Start of memberFunctionString
228682 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
228683 :
228684 : // *** COMMON CODE SECTION BEGINS HERE ***
228685 :
228686 : #if 0
228687 : int
228688 : SgPlusAssignOp::getVariant() const
228689 : {
228690 : // This function is used in ROSE while "variant()" is used in SAGE
228691 : assert(this != NULL);
228692 : return variant();
228693 : }
228694 : #endif
228695 :
228696 : // This function is used in ROSE in treeTraversal code
228697 : // eventually replaces getVariant() and variant()
228698 : // though after variant() has been removed for a while we will
228699 : // want to change the name of variantT() back to variant()
228700 : // (since the "T" was ment to stand for temporary).
228701 : // When this happens the variantT() will be depricated.
228702 : VariantT
228703 113875 : SgPlusAssignOp::variantT() const
228704 : {
228705 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
228706 113875 : ROSE_ASSERT(this != NULL);
228707 113875 : return V_SgPlusAssignOp;
228708 : }
228709 :
228710 : #if 0
228711 : int
228712 : SgPlusAssignOp::variant() const
228713 : {
228714 : // This function is used in SAGE
228715 : ROSE_ASSERT(this != NULL);
228716 : return PLUS_ASSIGN_OP;
228717 : }
228718 : #endif
228719 :
228720 : ROSE_DLL_API const char*
228721 2 : SgPlusAssignOp::sage_class_name() const
228722 : {
228723 2 : ROSE_ASSERT(this != NULL);
228724 2 : return "SgPlusAssignOp";
228725 : }
228726 :
228727 : std::string
228728 310 : SgPlusAssignOp::class_name() const
228729 : {
228730 310 : ROSE_ASSERT(this != NULL);
228731 310 : return "SgPlusAssignOp";
228732 : }
228733 :
228734 : // DQ (11/26/2005): Support for visitor pattern mechanims
228735 : // (inferior to ROSE traversal mechanism, experimental).
228736 : void
228737 4317 : SgPlusAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
228738 : {
228739 4317 : ROSE_ASSERT(this != NULL);
228740 4317 : visitor.visit(this);
228741 4317 : }
228742 :
228743 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
228744 0 : void SgPlusAssignOp::accept (ROSE_VisitorPattern & visitor) {
228745 0 : ROSE_ASSERT(this != NULL);
228746 0 : visitor.visit(this);
228747 0 : }
228748 :
228749 : SgPlusAssignOp*
228750 0 : SgPlusAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
228751 : {
228752 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
228753 : // This function is currently only supported for the AST used the represent Binary executables.
228754 : if (0 /* isSgAsmNode(this) != NULL */)
228755 : {
228756 : // Support for regex specification.
228757 : std::string prefixCode = "REGEX:";
228758 : addNewAttribute(prefixCode + s,a);
228759 : }
228760 : #endif
228761 :
228762 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
228763 0 : return this;
228764 : }
228765 :
228766 : // *** COMMON CODE SECTION ENDS HERE ***
228767 :
228768 :
228769 : // End of memberFunctionString
228770 : // Start of memberFunctionString
228771 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
228772 :
228773 :
228774 : #if 0
228775 : //! Error checking support
228776 : /*! Verifies the following:
228777 : - working getVariant() member function
228778 : - calls base class's error() member function
228779 : Every class has one of these functions.
228780 : */
228781 : bool
228782 : SgPlusAssignOp::error()
228783 : {
228784 : // Put error checking here
228785 :
228786 : ROSE_ASSERT (this != NULL);
228787 : if (getVariant() != PLUS_ASSIGN_OP)
228788 : {
228789 : printf ("Error in SgPlusAssignOp::error(): SgPlusAssignOp object has a %s variant \n",
228790 : Cxx_GrammarTerminalNames[getVariant()].name);
228791 : // printf ("Error in SgPlusAssignOp::error() \n");
228792 : ROSE_ABORT();
228793 : }
228794 :
228795 : ROSE_ASSERT (getVariant() == PLUS_ASSIGN_OP);
228796 : return SgCompoundAssignOp::error();
228797 : }
228798 : #endif
228799 :
228800 :
228801 :
228802 : // End of memberFunctionString
228803 :
228804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
228805 :
228806 382 : SgPlusAssignOp* isSgPlusAssignOp ( SgNode* inputDerivedClassPointer )
228807 : {
228808 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
228809 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
228810 : // So to fix this we return NULL directly when the input is NULL and avoid the
228811 : // dynamic_cast in this case. This is likely a performance improvement as well.
228812 : // return dynamic_cast<SgPlusAssignOp*>(inputDerivedClassPointer);
228813 : // Milind Chabbi (8/28/2013): isSgPlusAssignOp uses table-driven castability instead of c++ default dynamic_cast
228814 : // this improves the running time performance by 10-20%.
228815 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPlusAssignOp*>(inputDerivedClassPointer);
228816 382 : return IS_SgPlusAssignOp_FAST_MACRO(inputDerivedClassPointer);
228817 : }
228818 :
228819 : // DQ (11/8/2003): Added version of functions taking const pointer
228820 0 : const SgPlusAssignOp* isSgPlusAssignOp ( const SgNode* inputDerivedClassPointer )
228821 : {
228822 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
228823 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
228824 : // So to fix this we return NULL directly when the input is NULL and avoid the
228825 : // dynamic_cast in this case. This is likely a performance improvement as well.
228826 : // return dynamic_cast<const SgPlusAssignOp*>(inputDerivedClassPointer);
228827 : // Milind Chabbi (8/28/2013): isSgPlusAssignOp uses table-driven castability instead of c++ default dynamic_cast
228828 : // this improves the running time performance by 10-20%.
228829 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPlusAssignOp*>(inputDerivedClassPointer);
228830 0 : return IS_SgPlusAssignOp_FAST_MACRO(inputDerivedClassPointer);
228831 : }
228832 :
228833 :
228834 :
228835 : /* #line 228836 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228836 :
228837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
228838 :
228839 : /**
228840 : \brief Generated destructor
228841 :
228842 : This destructor is automatically generated (by ROSETTA). This destructor
228843 : only frees memory of data members associated with the parts of the current IR node which
228844 : are NOT traversed. Those data members that are part of a traversal can be freed using
228845 : a traversal (calling this destructor on all children in a post-order traversal). Such
228846 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
228847 :
228848 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
228849 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
228850 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
228851 :
228852 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
228853 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
228854 : pointers are not yet implemented to call delete on eash pointer in the container.
228855 : (This could be done by derivation from the STL containers to define containers that
228856 : automatically deleted their members.)
228857 :
228858 : */
228859 116 : SgPlusAssignOp::~SgPlusAssignOp () {
228860 58 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
228861 :
228862 :
228863 :
228864 : }
228865 :
228866 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
228867 116 : }
228868 :
228869 :
228870 : /* #line 228871 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228871 :
228872 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
228873 :
228874 : // Generated constructor
228875 2 : SgPlusAssignOp::SgPlusAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
228876 2 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
228877 : {
228878 : #ifdef DEBUG
228879 : // printf ("In SgPlusAssignOp::SgPlusAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
228880 : #endif
228881 : #if 0
228882 : // debugging information!
228883 : printf ("In SgPlusAssignOp::SgPlusAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
228884 : #endif
228885 :
228886 :
228887 :
228888 : #if 0
228889 : // DQ (7/30/2014): Call a virtual function.
228890 : std::string s = this->class_name();
228891 : #endif
228892 :
228893 : // Test the variant virtual function
228894 : // assert(PLUS_ASSIGN_OP == variant());
228895 2 : assert(PLUS_ASSIGN_OP == this->variant());
228896 2 : ROSE_ASSERT(PLUS_ASSIGN_OP == (int)(this->variantT()));
228897 2 : post_construction_initialization();
228898 :
228899 : // Test the isSgPlusAssignOp() function since it has been problematic
228900 2 : assert(isSgPlusAssignOp(this) != NULL);
228901 2 : }
228902 :
228903 : // Generated constructor (all data members)
228904 :
228905 : /* #line 228906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228906 :
228907 :
228908 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228909 :
228910 :
228911 : // ********************************************************
228912 : // member functions common across all array grammar objects
228913 : // ********************************************************
228914 :
228915 :
228916 :
228917 : /* #line 228918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228918 :
228919 :
228920 :
228921 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
228922 :
228923 : // ********************************************************
228924 : // member functions specific to each node in the grammar
228925 : // ********************************************************
228926 :
228927 :
228928 : /* #line 228929 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
228929 :
228930 : // Start of memberFunctionString
228931 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
228932 :
228933 : void
228934 96 : SgMinusAssignOp::post_construction_initialization()
228935 : {
228936 96 : }
228937 :
228938 :
228939 :
228940 : // End of memberFunctionString
228941 : // Start of memberFunctionString
228942 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
228943 :
228944 : // *** COMMON CODE SECTION BEGINS HERE ***
228945 :
228946 : #if 0
228947 : int
228948 : SgMinusAssignOp::getVariant() const
228949 : {
228950 : // This function is used in ROSE while "variant()" is used in SAGE
228951 : assert(this != NULL);
228952 : return variant();
228953 : }
228954 : #endif
228955 :
228956 : // This function is used in ROSE in treeTraversal code
228957 : // eventually replaces getVariant() and variant()
228958 : // though after variant() has been removed for a while we will
228959 : // want to change the name of variantT() back to variant()
228960 : // (since the "T" was ment to stand for temporary).
228961 : // When this happens the variantT() will be depricated.
228962 : VariantT
228963 24872 : SgMinusAssignOp::variantT() const
228964 : {
228965 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
228966 24872 : ROSE_ASSERT(this != NULL);
228967 24872 : return V_SgMinusAssignOp;
228968 : }
228969 :
228970 : #if 0
228971 : int
228972 : SgMinusAssignOp::variant() const
228973 : {
228974 : // This function is used in SAGE
228975 : ROSE_ASSERT(this != NULL);
228976 : return MINUS_ASSIGN_OP;
228977 : }
228978 : #endif
228979 :
228980 : ROSE_DLL_API const char*
228981 0 : SgMinusAssignOp::sage_class_name() const
228982 : {
228983 0 : ROSE_ASSERT(this != NULL);
228984 0 : return "SgMinusAssignOp";
228985 : }
228986 :
228987 : std::string
228988 83 : SgMinusAssignOp::class_name() const
228989 : {
228990 83 : ROSE_ASSERT(this != NULL);
228991 83 : return "SgMinusAssignOp";
228992 : }
228993 :
228994 : // DQ (11/26/2005): Support for visitor pattern mechanims
228995 : // (inferior to ROSE traversal mechanism, experimental).
228996 : void
228997 1375 : SgMinusAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
228998 : {
228999 1375 : ROSE_ASSERT(this != NULL);
229000 1375 : visitor.visit(this);
229001 1375 : }
229002 :
229003 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
229004 0 : void SgMinusAssignOp::accept (ROSE_VisitorPattern & visitor) {
229005 0 : ROSE_ASSERT(this != NULL);
229006 0 : visitor.visit(this);
229007 0 : }
229008 :
229009 : SgMinusAssignOp*
229010 0 : SgMinusAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
229011 : {
229012 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
229013 : // This function is currently only supported for the AST used the represent Binary executables.
229014 : if (0 /* isSgAsmNode(this) != NULL */)
229015 : {
229016 : // Support for regex specification.
229017 : std::string prefixCode = "REGEX:";
229018 : addNewAttribute(prefixCode + s,a);
229019 : }
229020 : #endif
229021 :
229022 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
229023 0 : return this;
229024 : }
229025 :
229026 : // *** COMMON CODE SECTION ENDS HERE ***
229027 :
229028 :
229029 : // End of memberFunctionString
229030 : // Start of memberFunctionString
229031 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
229032 :
229033 :
229034 : #if 0
229035 : //! Error checking support
229036 : /*! Verifies the following:
229037 : - working getVariant() member function
229038 : - calls base class's error() member function
229039 : Every class has one of these functions.
229040 : */
229041 : bool
229042 : SgMinusAssignOp::error()
229043 : {
229044 : // Put error checking here
229045 :
229046 : ROSE_ASSERT (this != NULL);
229047 : if (getVariant() != MINUS_ASSIGN_OP)
229048 : {
229049 : printf ("Error in SgMinusAssignOp::error(): SgMinusAssignOp object has a %s variant \n",
229050 : Cxx_GrammarTerminalNames[getVariant()].name);
229051 : // printf ("Error in SgMinusAssignOp::error() \n");
229052 : ROSE_ABORT();
229053 : }
229054 :
229055 : ROSE_ASSERT (getVariant() == MINUS_ASSIGN_OP);
229056 : return SgCompoundAssignOp::error();
229057 : }
229058 : #endif
229059 :
229060 :
229061 :
229062 : // End of memberFunctionString
229063 :
229064 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
229065 :
229066 98 : SgMinusAssignOp* isSgMinusAssignOp ( SgNode* inputDerivedClassPointer )
229067 : {
229068 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229069 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229070 : // So to fix this we return NULL directly when the input is NULL and avoid the
229071 : // dynamic_cast in this case. This is likely a performance improvement as well.
229072 : // return dynamic_cast<SgMinusAssignOp*>(inputDerivedClassPointer);
229073 : // Milind Chabbi (8/28/2013): isSgMinusAssignOp uses table-driven castability instead of c++ default dynamic_cast
229074 : // this improves the running time performance by 10-20%.
229075 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMinusAssignOp*>(inputDerivedClassPointer);
229076 98 : return IS_SgMinusAssignOp_FAST_MACRO(inputDerivedClassPointer);
229077 : }
229078 :
229079 : // DQ (11/8/2003): Added version of functions taking const pointer
229080 0 : const SgMinusAssignOp* isSgMinusAssignOp ( const SgNode* inputDerivedClassPointer )
229081 : {
229082 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229083 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229084 : // So to fix this we return NULL directly when the input is NULL and avoid the
229085 : // dynamic_cast in this case. This is likely a performance improvement as well.
229086 : // return dynamic_cast<const SgMinusAssignOp*>(inputDerivedClassPointer);
229087 : // Milind Chabbi (8/28/2013): isSgMinusAssignOp uses table-driven castability instead of c++ default dynamic_cast
229088 : // this improves the running time performance by 10-20%.
229089 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMinusAssignOp*>(inputDerivedClassPointer);
229090 0 : return IS_SgMinusAssignOp_FAST_MACRO(inputDerivedClassPointer);
229091 : }
229092 :
229093 :
229094 :
229095 : /* #line 229096 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229096 :
229097 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229098 :
229099 : /**
229100 : \brief Generated destructor
229101 :
229102 : This destructor is automatically generated (by ROSETTA). This destructor
229103 : only frees memory of data members associated with the parts of the current IR node which
229104 : are NOT traversed. Those data members that are part of a traversal can be freed using
229105 : a traversal (calling this destructor on all children in a post-order traversal). Such
229106 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
229107 :
229108 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
229109 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
229110 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
229111 :
229112 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
229113 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
229114 : pointers are not yet implemented to call delete on eash pointer in the container.
229115 : (This could be done by derivation from the STL containers to define containers that
229116 : automatically deleted their members.)
229117 :
229118 : */
229119 42 : SgMinusAssignOp::~SgMinusAssignOp () {
229120 21 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
229121 :
229122 :
229123 :
229124 : }
229125 :
229126 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229127 42 : }
229128 :
229129 :
229130 : /* #line 229131 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229131 :
229132 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
229133 :
229134 : // Generated constructor
229135 0 : SgMinusAssignOp::SgMinusAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
229136 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
229137 : {
229138 : #ifdef DEBUG
229139 : // printf ("In SgMinusAssignOp::SgMinusAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
229140 : #endif
229141 : #if 0
229142 : // debugging information!
229143 : printf ("In SgMinusAssignOp::SgMinusAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
229144 : #endif
229145 :
229146 :
229147 :
229148 : #if 0
229149 : // DQ (7/30/2014): Call a virtual function.
229150 : std::string s = this->class_name();
229151 : #endif
229152 :
229153 : // Test the variant virtual function
229154 : // assert(MINUS_ASSIGN_OP == variant());
229155 0 : assert(MINUS_ASSIGN_OP == this->variant());
229156 0 : ROSE_ASSERT(MINUS_ASSIGN_OP == (int)(this->variantT()));
229157 0 : post_construction_initialization();
229158 :
229159 : // Test the isSgMinusAssignOp() function since it has been problematic
229160 0 : assert(isSgMinusAssignOp(this) != NULL);
229161 0 : }
229162 :
229163 : // Generated constructor (all data members)
229164 :
229165 : /* #line 229166 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229166 :
229167 :
229168 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229169 :
229170 :
229171 : // ********************************************************
229172 : // member functions common across all array grammar objects
229173 : // ********************************************************
229174 :
229175 :
229176 :
229177 : /* #line 229178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229178 :
229179 :
229180 :
229181 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229182 :
229183 : // ********************************************************
229184 : // member functions specific to each node in the grammar
229185 : // ********************************************************
229186 :
229187 :
229188 : /* #line 229189 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229189 :
229190 : // Start of memberFunctionString
229191 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
229192 :
229193 : void
229194 9 : SgAndAssignOp::post_construction_initialization()
229195 : {
229196 9 : }
229197 :
229198 :
229199 :
229200 : // End of memberFunctionString
229201 : // Start of memberFunctionString
229202 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
229203 :
229204 : // *** COMMON CODE SECTION BEGINS HERE ***
229205 :
229206 : #if 0
229207 : int
229208 : SgAndAssignOp::getVariant() const
229209 : {
229210 : // This function is used in ROSE while "variant()" is used in SAGE
229211 : assert(this != NULL);
229212 : return variant();
229213 : }
229214 : #endif
229215 :
229216 : // This function is used in ROSE in treeTraversal code
229217 : // eventually replaces getVariant() and variant()
229218 : // though after variant() has been removed for a while we will
229219 : // want to change the name of variantT() back to variant()
229220 : // (since the "T" was ment to stand for temporary).
229221 : // When this happens the variantT() will be depricated.
229222 : VariantT
229223 9234 : SgAndAssignOp::variantT() const
229224 : {
229225 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
229226 9234 : ROSE_ASSERT(this != NULL);
229227 9234 : return V_SgAndAssignOp;
229228 : }
229229 :
229230 : #if 0
229231 : int
229232 : SgAndAssignOp::variant() const
229233 : {
229234 : // This function is used in SAGE
229235 : ROSE_ASSERT(this != NULL);
229236 : return AND_ASSIGN_OP;
229237 : }
229238 : #endif
229239 :
229240 : ROSE_DLL_API const char*
229241 0 : SgAndAssignOp::sage_class_name() const
229242 : {
229243 0 : ROSE_ASSERT(this != NULL);
229244 0 : return "SgAndAssignOp";
229245 : }
229246 :
229247 : std::string
229248 6 : SgAndAssignOp::class_name() const
229249 : {
229250 6 : ROSE_ASSERT(this != NULL);
229251 6 : return "SgAndAssignOp";
229252 : }
229253 :
229254 : // DQ (11/26/2005): Support for visitor pattern mechanims
229255 : // (inferior to ROSE traversal mechanism, experimental).
229256 : void
229257 54 : SgAndAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
229258 : {
229259 54 : ROSE_ASSERT(this != NULL);
229260 54 : visitor.visit(this);
229261 54 : }
229262 :
229263 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
229264 0 : void SgAndAssignOp::accept (ROSE_VisitorPattern & visitor) {
229265 0 : ROSE_ASSERT(this != NULL);
229266 0 : visitor.visit(this);
229267 0 : }
229268 :
229269 : SgAndAssignOp*
229270 0 : SgAndAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
229271 : {
229272 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
229273 : // This function is currently only supported for the AST used the represent Binary executables.
229274 : if (0 /* isSgAsmNode(this) != NULL */)
229275 : {
229276 : // Support for regex specification.
229277 : std::string prefixCode = "REGEX:";
229278 : addNewAttribute(prefixCode + s,a);
229279 : }
229280 : #endif
229281 :
229282 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
229283 0 : return this;
229284 : }
229285 :
229286 : // *** COMMON CODE SECTION ENDS HERE ***
229287 :
229288 :
229289 : // End of memberFunctionString
229290 : // Start of memberFunctionString
229291 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
229292 :
229293 :
229294 : #if 0
229295 : //! Error checking support
229296 : /*! Verifies the following:
229297 : - working getVariant() member function
229298 : - calls base class's error() member function
229299 : Every class has one of these functions.
229300 : */
229301 : bool
229302 : SgAndAssignOp::error()
229303 : {
229304 : // Put error checking here
229305 :
229306 : ROSE_ASSERT (this != NULL);
229307 : if (getVariant() != AND_ASSIGN_OP)
229308 : {
229309 : printf ("Error in SgAndAssignOp::error(): SgAndAssignOp object has a %s variant \n",
229310 : Cxx_GrammarTerminalNames[getVariant()].name);
229311 : // printf ("Error in SgAndAssignOp::error() \n");
229312 : ROSE_ABORT();
229313 : }
229314 :
229315 : ROSE_ASSERT (getVariant() == AND_ASSIGN_OP);
229316 : return SgCompoundAssignOp::error();
229317 : }
229318 : #endif
229319 :
229320 :
229321 :
229322 : // End of memberFunctionString
229323 :
229324 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
229325 :
229326 9 : SgAndAssignOp* isSgAndAssignOp ( SgNode* inputDerivedClassPointer )
229327 : {
229328 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229329 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229330 : // So to fix this we return NULL directly when the input is NULL and avoid the
229331 : // dynamic_cast in this case. This is likely a performance improvement as well.
229332 : // return dynamic_cast<SgAndAssignOp*>(inputDerivedClassPointer);
229333 : // Milind Chabbi (8/28/2013): isSgAndAssignOp uses table-driven castability instead of c++ default dynamic_cast
229334 : // this improves the running time performance by 10-20%.
229335 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAndAssignOp*>(inputDerivedClassPointer);
229336 9 : return IS_SgAndAssignOp_FAST_MACRO(inputDerivedClassPointer);
229337 : }
229338 :
229339 : // DQ (11/8/2003): Added version of functions taking const pointer
229340 0 : const SgAndAssignOp* isSgAndAssignOp ( const SgNode* inputDerivedClassPointer )
229341 : {
229342 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229343 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229344 : // So to fix this we return NULL directly when the input is NULL and avoid the
229345 : // dynamic_cast in this case. This is likely a performance improvement as well.
229346 : // return dynamic_cast<const SgAndAssignOp*>(inputDerivedClassPointer);
229347 : // Milind Chabbi (8/28/2013): isSgAndAssignOp uses table-driven castability instead of c++ default dynamic_cast
229348 : // this improves the running time performance by 10-20%.
229349 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAndAssignOp*>(inputDerivedClassPointer);
229350 0 : return IS_SgAndAssignOp_FAST_MACRO(inputDerivedClassPointer);
229351 : }
229352 :
229353 :
229354 :
229355 : /* #line 229356 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229356 :
229357 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229358 :
229359 : /**
229360 : \brief Generated destructor
229361 :
229362 : This destructor is automatically generated (by ROSETTA). This destructor
229363 : only frees memory of data members associated with the parts of the current IR node which
229364 : are NOT traversed. Those data members that are part of a traversal can be freed using
229365 : a traversal (calling this destructor on all children in a post-order traversal). Such
229366 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
229367 :
229368 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
229369 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
229370 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
229371 :
229372 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
229373 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
229374 : pointers are not yet implemented to call delete on eash pointer in the container.
229375 : (This could be done by derivation from the STL containers to define containers that
229376 : automatically deleted their members.)
229377 :
229378 : */
229379 0 : SgAndAssignOp::~SgAndAssignOp () {
229380 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
229381 :
229382 :
229383 :
229384 : }
229385 :
229386 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229387 0 : }
229388 :
229389 :
229390 : /* #line 229391 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229391 :
229392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
229393 :
229394 : // Generated constructor
229395 0 : SgAndAssignOp::SgAndAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
229396 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
229397 : {
229398 : #ifdef DEBUG
229399 : // printf ("In SgAndAssignOp::SgAndAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
229400 : #endif
229401 : #if 0
229402 : // debugging information!
229403 : printf ("In SgAndAssignOp::SgAndAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
229404 : #endif
229405 :
229406 :
229407 :
229408 : #if 0
229409 : // DQ (7/30/2014): Call a virtual function.
229410 : std::string s = this->class_name();
229411 : #endif
229412 :
229413 : // Test the variant virtual function
229414 : // assert(AND_ASSIGN_OP == variant());
229415 0 : assert(AND_ASSIGN_OP == this->variant());
229416 0 : ROSE_ASSERT(AND_ASSIGN_OP == (int)(this->variantT()));
229417 0 : post_construction_initialization();
229418 :
229419 : // Test the isSgAndAssignOp() function since it has been problematic
229420 0 : assert(isSgAndAssignOp(this) != NULL);
229421 0 : }
229422 :
229423 : // Generated constructor (all data members)
229424 :
229425 : /* #line 229426 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229426 :
229427 :
229428 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229429 :
229430 :
229431 : // ********************************************************
229432 : // member functions common across all array grammar objects
229433 : // ********************************************************
229434 :
229435 :
229436 :
229437 : /* #line 229438 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229438 :
229439 :
229440 :
229441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229442 :
229443 : // ********************************************************
229444 : // member functions specific to each node in the grammar
229445 : // ********************************************************
229446 :
229447 :
229448 : /* #line 229449 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229449 :
229450 : // Start of memberFunctionString
229451 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
229452 :
229453 : void
229454 62 : SgIorAssignOp::post_construction_initialization()
229455 : {
229456 62 : }
229457 :
229458 :
229459 :
229460 : // End of memberFunctionString
229461 : // Start of memberFunctionString
229462 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
229463 :
229464 : // *** COMMON CODE SECTION BEGINS HERE ***
229465 :
229466 : #if 0
229467 : int
229468 : SgIorAssignOp::getVariant() const
229469 : {
229470 : // This function is used in ROSE while "variant()" is used in SAGE
229471 : assert(this != NULL);
229472 : return variant();
229473 : }
229474 : #endif
229475 :
229476 : // This function is used in ROSE in treeTraversal code
229477 : // eventually replaces getVariant() and variant()
229478 : // though after variant() has been removed for a while we will
229479 : // want to change the name of variantT() back to variant()
229480 : // (since the "T" was ment to stand for temporary).
229481 : // When this happens the variantT() will be depricated.
229482 : VariantT
229483 17215 : SgIorAssignOp::variantT() const
229484 : {
229485 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
229486 17215 : ROSE_ASSERT(this != NULL);
229487 17215 : return V_SgIorAssignOp;
229488 : }
229489 :
229490 : #if 0
229491 : int
229492 : SgIorAssignOp::variant() const
229493 : {
229494 : // This function is used in SAGE
229495 : ROSE_ASSERT(this != NULL);
229496 : return IOR_ASSIGN_OP;
229497 : }
229498 : #endif
229499 :
229500 : ROSE_DLL_API const char*
229501 0 : SgIorAssignOp::sage_class_name() const
229502 : {
229503 0 : ROSE_ASSERT(this != NULL);
229504 0 : return "SgIorAssignOp";
229505 : }
229506 :
229507 : std::string
229508 53 : SgIorAssignOp::class_name() const
229509 : {
229510 53 : ROSE_ASSERT(this != NULL);
229511 53 : return "SgIorAssignOp";
229512 : }
229513 :
229514 : // DQ (11/26/2005): Support for visitor pattern mechanims
229515 : // (inferior to ROSE traversal mechanism, experimental).
229516 : void
229517 995 : SgIorAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
229518 : {
229519 995 : ROSE_ASSERT(this != NULL);
229520 995 : visitor.visit(this);
229521 995 : }
229522 :
229523 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
229524 0 : void SgIorAssignOp::accept (ROSE_VisitorPattern & visitor) {
229525 0 : ROSE_ASSERT(this != NULL);
229526 0 : visitor.visit(this);
229527 0 : }
229528 :
229529 : SgIorAssignOp*
229530 0 : SgIorAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
229531 : {
229532 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
229533 : // This function is currently only supported for the AST used the represent Binary executables.
229534 : if (0 /* isSgAsmNode(this) != NULL */)
229535 : {
229536 : // Support for regex specification.
229537 : std::string prefixCode = "REGEX:";
229538 : addNewAttribute(prefixCode + s,a);
229539 : }
229540 : #endif
229541 :
229542 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
229543 0 : return this;
229544 : }
229545 :
229546 : // *** COMMON CODE SECTION ENDS HERE ***
229547 :
229548 :
229549 : // End of memberFunctionString
229550 : // Start of memberFunctionString
229551 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
229552 :
229553 :
229554 : #if 0
229555 : //! Error checking support
229556 : /*! Verifies the following:
229557 : - working getVariant() member function
229558 : - calls base class's error() member function
229559 : Every class has one of these functions.
229560 : */
229561 : bool
229562 : SgIorAssignOp::error()
229563 : {
229564 : // Put error checking here
229565 :
229566 : ROSE_ASSERT (this != NULL);
229567 : if (getVariant() != IOR_ASSIGN_OP)
229568 : {
229569 : printf ("Error in SgIorAssignOp::error(): SgIorAssignOp object has a %s variant \n",
229570 : Cxx_GrammarTerminalNames[getVariant()].name);
229571 : // printf ("Error in SgIorAssignOp::error() \n");
229572 : ROSE_ABORT();
229573 : }
229574 :
229575 : ROSE_ASSERT (getVariant() == IOR_ASSIGN_OP);
229576 : return SgCompoundAssignOp::error();
229577 : }
229578 : #endif
229579 :
229580 :
229581 :
229582 : // End of memberFunctionString
229583 :
229584 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
229585 :
229586 62 : SgIorAssignOp* isSgIorAssignOp ( SgNode* inputDerivedClassPointer )
229587 : {
229588 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229589 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229590 : // So to fix this we return NULL directly when the input is NULL and avoid the
229591 : // dynamic_cast in this case. This is likely a performance improvement as well.
229592 : // return dynamic_cast<SgIorAssignOp*>(inputDerivedClassPointer);
229593 : // Milind Chabbi (8/28/2013): isSgIorAssignOp uses table-driven castability instead of c++ default dynamic_cast
229594 : // this improves the running time performance by 10-20%.
229595 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIorAssignOp*>(inputDerivedClassPointer);
229596 62 : return IS_SgIorAssignOp_FAST_MACRO(inputDerivedClassPointer);
229597 : }
229598 :
229599 : // DQ (11/8/2003): Added version of functions taking const pointer
229600 0 : const SgIorAssignOp* isSgIorAssignOp ( const SgNode* inputDerivedClassPointer )
229601 : {
229602 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229603 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229604 : // So to fix this we return NULL directly when the input is NULL and avoid the
229605 : // dynamic_cast in this case. This is likely a performance improvement as well.
229606 : // return dynamic_cast<const SgIorAssignOp*>(inputDerivedClassPointer);
229607 : // Milind Chabbi (8/28/2013): isSgIorAssignOp uses table-driven castability instead of c++ default dynamic_cast
229608 : // this improves the running time performance by 10-20%.
229609 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIorAssignOp*>(inputDerivedClassPointer);
229610 0 : return IS_SgIorAssignOp_FAST_MACRO(inputDerivedClassPointer);
229611 : }
229612 :
229613 :
229614 :
229615 : /* #line 229616 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229616 :
229617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229618 :
229619 : /**
229620 : \brief Generated destructor
229621 :
229622 : This destructor is automatically generated (by ROSETTA). This destructor
229623 : only frees memory of data members associated with the parts of the current IR node which
229624 : are NOT traversed. Those data members that are part of a traversal can be freed using
229625 : a traversal (calling this destructor on all children in a post-order traversal). Such
229626 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
229627 :
229628 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
229629 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
229630 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
229631 :
229632 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
229633 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
229634 : pointers are not yet implemented to call delete on eash pointer in the container.
229635 : (This could be done by derivation from the STL containers to define containers that
229636 : automatically deleted their members.)
229637 :
229638 : */
229639 28 : SgIorAssignOp::~SgIorAssignOp () {
229640 14 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
229641 :
229642 :
229643 :
229644 : }
229645 :
229646 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229647 28 : }
229648 :
229649 :
229650 : /* #line 229651 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229651 :
229652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
229653 :
229654 : // Generated constructor
229655 0 : SgIorAssignOp::SgIorAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
229656 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
229657 : {
229658 : #ifdef DEBUG
229659 : // printf ("In SgIorAssignOp::SgIorAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
229660 : #endif
229661 : #if 0
229662 : // debugging information!
229663 : printf ("In SgIorAssignOp::SgIorAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
229664 : #endif
229665 :
229666 :
229667 :
229668 : #if 0
229669 : // DQ (7/30/2014): Call a virtual function.
229670 : std::string s = this->class_name();
229671 : #endif
229672 :
229673 : // Test the variant virtual function
229674 : // assert(IOR_ASSIGN_OP == variant());
229675 0 : assert(IOR_ASSIGN_OP == this->variant());
229676 0 : ROSE_ASSERT(IOR_ASSIGN_OP == (int)(this->variantT()));
229677 0 : post_construction_initialization();
229678 :
229679 : // Test the isSgIorAssignOp() function since it has been problematic
229680 0 : assert(isSgIorAssignOp(this) != NULL);
229681 0 : }
229682 :
229683 : // Generated constructor (all data members)
229684 :
229685 : /* #line 229686 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229686 :
229687 :
229688 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229689 :
229690 :
229691 : // ********************************************************
229692 : // member functions common across all array grammar objects
229693 : // ********************************************************
229694 :
229695 :
229696 :
229697 : /* #line 229698 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229698 :
229699 :
229700 :
229701 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229702 :
229703 : // ********************************************************
229704 : // member functions specific to each node in the grammar
229705 : // ********************************************************
229706 :
229707 :
229708 : /* #line 229709 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229709 :
229710 : // Start of memberFunctionString
229711 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
229712 :
229713 : void
229714 30 : SgMultAssignOp::post_construction_initialization()
229715 : {
229716 30 : }
229717 :
229718 :
229719 :
229720 : // End of memberFunctionString
229721 : // Start of memberFunctionString
229722 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
229723 :
229724 : // *** COMMON CODE SECTION BEGINS HERE ***
229725 :
229726 : #if 0
229727 : int
229728 : SgMultAssignOp::getVariant() const
229729 : {
229730 : // This function is used in ROSE while "variant()" is used in SAGE
229731 : assert(this != NULL);
229732 : return variant();
229733 : }
229734 : #endif
229735 :
229736 : // This function is used in ROSE in treeTraversal code
229737 : // eventually replaces getVariant() and variant()
229738 : // though after variant() has been removed for a while we will
229739 : // want to change the name of variantT() back to variant()
229740 : // (since the "T" was ment to stand for temporary).
229741 : // When this happens the variantT() will be depricated.
229742 : VariantT
229743 5370 : SgMultAssignOp::variantT() const
229744 : {
229745 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
229746 5370 : ROSE_ASSERT(this != NULL);
229747 5370 : return V_SgMultAssignOp;
229748 : }
229749 :
229750 : #if 0
229751 : int
229752 : SgMultAssignOp::variant() const
229753 : {
229754 : // This function is used in SAGE
229755 : ROSE_ASSERT(this != NULL);
229756 : return MULT_ASSIGN_OP;
229757 : }
229758 : #endif
229759 :
229760 : ROSE_DLL_API const char*
229761 0 : SgMultAssignOp::sage_class_name() const
229762 : {
229763 0 : ROSE_ASSERT(this != NULL);
229764 0 : return "SgMultAssignOp";
229765 : }
229766 :
229767 : std::string
229768 28 : SgMultAssignOp::class_name() const
229769 : {
229770 28 : ROSE_ASSERT(this != NULL);
229771 28 : return "SgMultAssignOp";
229772 : }
229773 :
229774 : // DQ (11/26/2005): Support for visitor pattern mechanims
229775 : // (inferior to ROSE traversal mechanism, experimental).
229776 : void
229777 274 : SgMultAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
229778 : {
229779 274 : ROSE_ASSERT(this != NULL);
229780 274 : visitor.visit(this);
229781 274 : }
229782 :
229783 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
229784 0 : void SgMultAssignOp::accept (ROSE_VisitorPattern & visitor) {
229785 0 : ROSE_ASSERT(this != NULL);
229786 0 : visitor.visit(this);
229787 0 : }
229788 :
229789 : SgMultAssignOp*
229790 0 : SgMultAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
229791 : {
229792 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
229793 : // This function is currently only supported for the AST used the represent Binary executables.
229794 : if (0 /* isSgAsmNode(this) != NULL */)
229795 : {
229796 : // Support for regex specification.
229797 : std::string prefixCode = "REGEX:";
229798 : addNewAttribute(prefixCode + s,a);
229799 : }
229800 : #endif
229801 :
229802 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
229803 0 : return this;
229804 : }
229805 :
229806 : // *** COMMON CODE SECTION ENDS HERE ***
229807 :
229808 :
229809 : // End of memberFunctionString
229810 : // Start of memberFunctionString
229811 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
229812 :
229813 :
229814 : #if 0
229815 : //! Error checking support
229816 : /*! Verifies the following:
229817 : - working getVariant() member function
229818 : - calls base class's error() member function
229819 : Every class has one of these functions.
229820 : */
229821 : bool
229822 : SgMultAssignOp::error()
229823 : {
229824 : // Put error checking here
229825 :
229826 : ROSE_ASSERT (this != NULL);
229827 : if (getVariant() != MULT_ASSIGN_OP)
229828 : {
229829 : printf ("Error in SgMultAssignOp::error(): SgMultAssignOp object has a %s variant \n",
229830 : Cxx_GrammarTerminalNames[getVariant()].name);
229831 : // printf ("Error in SgMultAssignOp::error() \n");
229832 : ROSE_ABORT();
229833 : }
229834 :
229835 : ROSE_ASSERT (getVariant() == MULT_ASSIGN_OP);
229836 : return SgCompoundAssignOp::error();
229837 : }
229838 : #endif
229839 :
229840 :
229841 :
229842 : // End of memberFunctionString
229843 :
229844 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
229845 :
229846 30 : SgMultAssignOp* isSgMultAssignOp ( SgNode* inputDerivedClassPointer )
229847 : {
229848 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229849 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229850 : // So to fix this we return NULL directly when the input is NULL and avoid the
229851 : // dynamic_cast in this case. This is likely a performance improvement as well.
229852 : // return dynamic_cast<SgMultAssignOp*>(inputDerivedClassPointer);
229853 : // Milind Chabbi (8/28/2013): isSgMultAssignOp uses table-driven castability instead of c++ default dynamic_cast
229854 : // this improves the running time performance by 10-20%.
229855 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMultAssignOp*>(inputDerivedClassPointer);
229856 30 : return IS_SgMultAssignOp_FAST_MACRO(inputDerivedClassPointer);
229857 : }
229858 :
229859 : // DQ (11/8/2003): Added version of functions taking const pointer
229860 0 : const SgMultAssignOp* isSgMultAssignOp ( const SgNode* inputDerivedClassPointer )
229861 : {
229862 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
229863 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
229864 : // So to fix this we return NULL directly when the input is NULL and avoid the
229865 : // dynamic_cast in this case. This is likely a performance improvement as well.
229866 : // return dynamic_cast<const SgMultAssignOp*>(inputDerivedClassPointer);
229867 : // Milind Chabbi (8/28/2013): isSgMultAssignOp uses table-driven castability instead of c++ default dynamic_cast
229868 : // this improves the running time performance by 10-20%.
229869 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMultAssignOp*>(inputDerivedClassPointer);
229870 0 : return IS_SgMultAssignOp_FAST_MACRO(inputDerivedClassPointer);
229871 : }
229872 :
229873 :
229874 :
229875 : /* #line 229876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229876 :
229877 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229878 :
229879 : /**
229880 : \brief Generated destructor
229881 :
229882 : This destructor is automatically generated (by ROSETTA). This destructor
229883 : only frees memory of data members associated with the parts of the current IR node which
229884 : are NOT traversed. Those data members that are part of a traversal can be freed using
229885 : a traversal (calling this destructor on all children in a post-order traversal). Such
229886 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
229887 :
229888 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
229889 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
229890 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
229891 :
229892 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
229893 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
229894 : pointers are not yet implemented to call delete on eash pointer in the container.
229895 : (This could be done by derivation from the STL containers to define containers that
229896 : automatically deleted their members.)
229897 :
229898 : */
229899 8 : SgMultAssignOp::~SgMultAssignOp () {
229900 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
229901 :
229902 :
229903 :
229904 : }
229905 :
229906 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
229907 8 : }
229908 :
229909 :
229910 : /* #line 229911 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229911 :
229912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
229913 :
229914 : // Generated constructor
229915 0 : SgMultAssignOp::SgMultAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
229916 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
229917 : {
229918 : #ifdef DEBUG
229919 : // printf ("In SgMultAssignOp::SgMultAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
229920 : #endif
229921 : #if 0
229922 : // debugging information!
229923 : printf ("In SgMultAssignOp::SgMultAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
229924 : #endif
229925 :
229926 :
229927 :
229928 : #if 0
229929 : // DQ (7/30/2014): Call a virtual function.
229930 : std::string s = this->class_name();
229931 : #endif
229932 :
229933 : // Test the variant virtual function
229934 : // assert(MULT_ASSIGN_OP == variant());
229935 0 : assert(MULT_ASSIGN_OP == this->variant());
229936 0 : ROSE_ASSERT(MULT_ASSIGN_OP == (int)(this->variantT()));
229937 0 : post_construction_initialization();
229938 :
229939 : // Test the isSgMultAssignOp() function since it has been problematic
229940 0 : assert(isSgMultAssignOp(this) != NULL);
229941 0 : }
229942 :
229943 : // Generated constructor (all data members)
229944 :
229945 : /* #line 229946 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229946 :
229947 :
229948 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229949 :
229950 :
229951 : // ********************************************************
229952 : // member functions common across all array grammar objects
229953 : // ********************************************************
229954 :
229955 :
229956 :
229957 : /* #line 229958 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229958 :
229959 :
229960 :
229961 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
229962 :
229963 : // ********************************************************
229964 : // member functions specific to each node in the grammar
229965 : // ********************************************************
229966 :
229967 :
229968 : /* #line 229969 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
229969 :
229970 : // Start of memberFunctionString
229971 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
229972 :
229973 : void
229974 9 : SgDivAssignOp::post_construction_initialization()
229975 : {
229976 9 : }
229977 :
229978 :
229979 :
229980 : // End of memberFunctionString
229981 : // Start of memberFunctionString
229982 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
229983 :
229984 : // *** COMMON CODE SECTION BEGINS HERE ***
229985 :
229986 : #if 0
229987 : int
229988 : SgDivAssignOp::getVariant() const
229989 : {
229990 : // This function is used in ROSE while "variant()" is used in SAGE
229991 : assert(this != NULL);
229992 : return variant();
229993 : }
229994 : #endif
229995 :
229996 : // This function is used in ROSE in treeTraversal code
229997 : // eventually replaces getVariant() and variant()
229998 : // though after variant() has been removed for a while we will
229999 : // want to change the name of variantT() back to variant()
230000 : // (since the "T" was ment to stand for temporary).
230001 : // When this happens the variantT() will be depricated.
230002 : VariantT
230003 1627 : SgDivAssignOp::variantT() const
230004 : {
230005 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
230006 1627 : ROSE_ASSERT(this != NULL);
230007 1627 : return V_SgDivAssignOp;
230008 : }
230009 :
230010 : #if 0
230011 : int
230012 : SgDivAssignOp::variant() const
230013 : {
230014 : // This function is used in SAGE
230015 : ROSE_ASSERT(this != NULL);
230016 : return DIV_ASSIGN_OP;
230017 : }
230018 : #endif
230019 :
230020 : ROSE_DLL_API const char*
230021 0 : SgDivAssignOp::sage_class_name() const
230022 : {
230023 0 : ROSE_ASSERT(this != NULL);
230024 0 : return "SgDivAssignOp";
230025 : }
230026 :
230027 : std::string
230028 8 : SgDivAssignOp::class_name() const
230029 : {
230030 8 : ROSE_ASSERT(this != NULL);
230031 8 : return "SgDivAssignOp";
230032 : }
230033 :
230034 : // DQ (11/26/2005): Support for visitor pattern mechanims
230035 : // (inferior to ROSE traversal mechanism, experimental).
230036 : void
230037 137 : SgDivAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
230038 : {
230039 137 : ROSE_ASSERT(this != NULL);
230040 137 : visitor.visit(this);
230041 137 : }
230042 :
230043 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
230044 0 : void SgDivAssignOp::accept (ROSE_VisitorPattern & visitor) {
230045 0 : ROSE_ASSERT(this != NULL);
230046 0 : visitor.visit(this);
230047 0 : }
230048 :
230049 : SgDivAssignOp*
230050 0 : SgDivAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
230051 : {
230052 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
230053 : // This function is currently only supported for the AST used the represent Binary executables.
230054 : if (0 /* isSgAsmNode(this) != NULL */)
230055 : {
230056 : // Support for regex specification.
230057 : std::string prefixCode = "REGEX:";
230058 : addNewAttribute(prefixCode + s,a);
230059 : }
230060 : #endif
230061 :
230062 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
230063 0 : return this;
230064 : }
230065 :
230066 : // *** COMMON CODE SECTION ENDS HERE ***
230067 :
230068 :
230069 : // End of memberFunctionString
230070 : // Start of memberFunctionString
230071 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
230072 :
230073 :
230074 : #if 0
230075 : //! Error checking support
230076 : /*! Verifies the following:
230077 : - working getVariant() member function
230078 : - calls base class's error() member function
230079 : Every class has one of these functions.
230080 : */
230081 : bool
230082 : SgDivAssignOp::error()
230083 : {
230084 : // Put error checking here
230085 :
230086 : ROSE_ASSERT (this != NULL);
230087 : if (getVariant() != DIV_ASSIGN_OP)
230088 : {
230089 : printf ("Error in SgDivAssignOp::error(): SgDivAssignOp object has a %s variant \n",
230090 : Cxx_GrammarTerminalNames[getVariant()].name);
230091 : // printf ("Error in SgDivAssignOp::error() \n");
230092 : ROSE_ABORT();
230093 : }
230094 :
230095 : ROSE_ASSERT (getVariant() == DIV_ASSIGN_OP);
230096 : return SgCompoundAssignOp::error();
230097 : }
230098 : #endif
230099 :
230100 :
230101 :
230102 : // End of memberFunctionString
230103 :
230104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
230105 :
230106 9 : SgDivAssignOp* isSgDivAssignOp ( SgNode* inputDerivedClassPointer )
230107 : {
230108 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230109 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230110 : // So to fix this we return NULL directly when the input is NULL and avoid the
230111 : // dynamic_cast in this case. This is likely a performance improvement as well.
230112 : // return dynamic_cast<SgDivAssignOp*>(inputDerivedClassPointer);
230113 : // Milind Chabbi (8/28/2013): isSgDivAssignOp uses table-driven castability instead of c++ default dynamic_cast
230114 : // this improves the running time performance by 10-20%.
230115 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDivAssignOp*>(inputDerivedClassPointer);
230116 9 : return IS_SgDivAssignOp_FAST_MACRO(inputDerivedClassPointer);
230117 : }
230118 :
230119 : // DQ (11/8/2003): Added version of functions taking const pointer
230120 0 : const SgDivAssignOp* isSgDivAssignOp ( const SgNode* inputDerivedClassPointer )
230121 : {
230122 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230123 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230124 : // So to fix this we return NULL directly when the input is NULL and avoid the
230125 : // dynamic_cast in this case. This is likely a performance improvement as well.
230126 : // return dynamic_cast<const SgDivAssignOp*>(inputDerivedClassPointer);
230127 : // Milind Chabbi (8/28/2013): isSgDivAssignOp uses table-driven castability instead of c++ default dynamic_cast
230128 : // this improves the running time performance by 10-20%.
230129 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDivAssignOp*>(inputDerivedClassPointer);
230130 0 : return IS_SgDivAssignOp_FAST_MACRO(inputDerivedClassPointer);
230131 : }
230132 :
230133 :
230134 :
230135 : /* #line 230136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230136 :
230137 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230138 :
230139 : /**
230140 : \brief Generated destructor
230141 :
230142 : This destructor is automatically generated (by ROSETTA). This destructor
230143 : only frees memory of data members associated with the parts of the current IR node which
230144 : are NOT traversed. Those data members that are part of a traversal can be freed using
230145 : a traversal (calling this destructor on all children in a post-order traversal). Such
230146 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
230147 :
230148 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
230149 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
230150 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
230151 :
230152 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
230153 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
230154 : pointers are not yet implemented to call delete on eash pointer in the container.
230155 : (This could be done by derivation from the STL containers to define containers that
230156 : automatically deleted their members.)
230157 :
230158 : */
230159 4 : SgDivAssignOp::~SgDivAssignOp () {
230160 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
230161 :
230162 :
230163 :
230164 : }
230165 :
230166 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230167 4 : }
230168 :
230169 :
230170 : /* #line 230171 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230171 :
230172 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
230173 :
230174 : // Generated constructor
230175 0 : SgDivAssignOp::SgDivAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
230176 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
230177 : {
230178 : #ifdef DEBUG
230179 : // printf ("In SgDivAssignOp::SgDivAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
230180 : #endif
230181 : #if 0
230182 : // debugging information!
230183 : printf ("In SgDivAssignOp::SgDivAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
230184 : #endif
230185 :
230186 :
230187 :
230188 : #if 0
230189 : // DQ (7/30/2014): Call a virtual function.
230190 : std::string s = this->class_name();
230191 : #endif
230192 :
230193 : // Test the variant virtual function
230194 : // assert(DIV_ASSIGN_OP == variant());
230195 0 : assert(DIV_ASSIGN_OP == this->variant());
230196 0 : ROSE_ASSERT(DIV_ASSIGN_OP == (int)(this->variantT()));
230197 0 : post_construction_initialization();
230198 :
230199 : // Test the isSgDivAssignOp() function since it has been problematic
230200 0 : assert(isSgDivAssignOp(this) != NULL);
230201 0 : }
230202 :
230203 : // Generated constructor (all data members)
230204 :
230205 : /* #line 230206 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230206 :
230207 :
230208 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230209 :
230210 :
230211 : // ********************************************************
230212 : // member functions common across all array grammar objects
230213 : // ********************************************************
230214 :
230215 :
230216 :
230217 : /* #line 230218 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230218 :
230219 :
230220 :
230221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230222 :
230223 : // ********************************************************
230224 : // member functions specific to each node in the grammar
230225 : // ********************************************************
230226 :
230227 :
230228 : /* #line 230229 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230229 :
230230 : // Start of memberFunctionString
230231 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
230232 :
230233 : void
230234 0 : SgModAssignOp::post_construction_initialization()
230235 : {
230236 0 : }
230237 :
230238 :
230239 :
230240 : // End of memberFunctionString
230241 : // Start of memberFunctionString
230242 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
230243 :
230244 : // *** COMMON CODE SECTION BEGINS HERE ***
230245 :
230246 : #if 0
230247 : int
230248 : SgModAssignOp::getVariant() const
230249 : {
230250 : // This function is used in ROSE while "variant()" is used in SAGE
230251 : assert(this != NULL);
230252 : return variant();
230253 : }
230254 : #endif
230255 :
230256 : // This function is used in ROSE in treeTraversal code
230257 : // eventually replaces getVariant() and variant()
230258 : // though after variant() has been removed for a while we will
230259 : // want to change the name of variantT() back to variant()
230260 : // (since the "T" was ment to stand for temporary).
230261 : // When this happens the variantT() will be depricated.
230262 : VariantT
230263 0 : SgModAssignOp::variantT() const
230264 : {
230265 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
230266 0 : ROSE_ASSERT(this != NULL);
230267 0 : return V_SgModAssignOp;
230268 : }
230269 :
230270 : #if 0
230271 : int
230272 : SgModAssignOp::variant() const
230273 : {
230274 : // This function is used in SAGE
230275 : ROSE_ASSERT(this != NULL);
230276 : return MOD_ASSIGN_OP;
230277 : }
230278 : #endif
230279 :
230280 : ROSE_DLL_API const char*
230281 0 : SgModAssignOp::sage_class_name() const
230282 : {
230283 0 : ROSE_ASSERT(this != NULL);
230284 0 : return "SgModAssignOp";
230285 : }
230286 :
230287 : std::string
230288 0 : SgModAssignOp::class_name() const
230289 : {
230290 0 : ROSE_ASSERT(this != NULL);
230291 0 : return "SgModAssignOp";
230292 : }
230293 :
230294 : // DQ (11/26/2005): Support for visitor pattern mechanims
230295 : // (inferior to ROSE traversal mechanism, experimental).
230296 : void
230297 0 : SgModAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
230298 : {
230299 0 : ROSE_ASSERT(this != NULL);
230300 0 : visitor.visit(this);
230301 0 : }
230302 :
230303 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
230304 0 : void SgModAssignOp::accept (ROSE_VisitorPattern & visitor) {
230305 0 : ROSE_ASSERT(this != NULL);
230306 0 : visitor.visit(this);
230307 0 : }
230308 :
230309 : SgModAssignOp*
230310 0 : SgModAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
230311 : {
230312 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
230313 : // This function is currently only supported for the AST used the represent Binary executables.
230314 : if (0 /* isSgAsmNode(this) != NULL */)
230315 : {
230316 : // Support for regex specification.
230317 : std::string prefixCode = "REGEX:";
230318 : addNewAttribute(prefixCode + s,a);
230319 : }
230320 : #endif
230321 :
230322 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
230323 0 : return this;
230324 : }
230325 :
230326 : // *** COMMON CODE SECTION ENDS HERE ***
230327 :
230328 :
230329 : // End of memberFunctionString
230330 : // Start of memberFunctionString
230331 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
230332 :
230333 :
230334 : #if 0
230335 : //! Error checking support
230336 : /*! Verifies the following:
230337 : - working getVariant() member function
230338 : - calls base class's error() member function
230339 : Every class has one of these functions.
230340 : */
230341 : bool
230342 : SgModAssignOp::error()
230343 : {
230344 : // Put error checking here
230345 :
230346 : ROSE_ASSERT (this != NULL);
230347 : if (getVariant() != MOD_ASSIGN_OP)
230348 : {
230349 : printf ("Error in SgModAssignOp::error(): SgModAssignOp object has a %s variant \n",
230350 : Cxx_GrammarTerminalNames[getVariant()].name);
230351 : // printf ("Error in SgModAssignOp::error() \n");
230352 : ROSE_ABORT();
230353 : }
230354 :
230355 : ROSE_ASSERT (getVariant() == MOD_ASSIGN_OP);
230356 : return SgCompoundAssignOp::error();
230357 : }
230358 : #endif
230359 :
230360 :
230361 :
230362 : // End of memberFunctionString
230363 :
230364 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
230365 :
230366 0 : SgModAssignOp* isSgModAssignOp ( SgNode* inputDerivedClassPointer )
230367 : {
230368 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230369 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230370 : // So to fix this we return NULL directly when the input is NULL and avoid the
230371 : // dynamic_cast in this case. This is likely a performance improvement as well.
230372 : // return dynamic_cast<SgModAssignOp*>(inputDerivedClassPointer);
230373 : // Milind Chabbi (8/28/2013): isSgModAssignOp uses table-driven castability instead of c++ default dynamic_cast
230374 : // this improves the running time performance by 10-20%.
230375 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModAssignOp*>(inputDerivedClassPointer);
230376 0 : return IS_SgModAssignOp_FAST_MACRO(inputDerivedClassPointer);
230377 : }
230378 :
230379 : // DQ (11/8/2003): Added version of functions taking const pointer
230380 0 : const SgModAssignOp* isSgModAssignOp ( const SgNode* inputDerivedClassPointer )
230381 : {
230382 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230383 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230384 : // So to fix this we return NULL directly when the input is NULL and avoid the
230385 : // dynamic_cast in this case. This is likely a performance improvement as well.
230386 : // return dynamic_cast<const SgModAssignOp*>(inputDerivedClassPointer);
230387 : // Milind Chabbi (8/28/2013): isSgModAssignOp uses table-driven castability instead of c++ default dynamic_cast
230388 : // this improves the running time performance by 10-20%.
230389 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModAssignOp*>(inputDerivedClassPointer);
230390 0 : return IS_SgModAssignOp_FAST_MACRO(inputDerivedClassPointer);
230391 : }
230392 :
230393 :
230394 :
230395 : /* #line 230396 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230396 :
230397 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230398 :
230399 : /**
230400 : \brief Generated destructor
230401 :
230402 : This destructor is automatically generated (by ROSETTA). This destructor
230403 : only frees memory of data members associated with the parts of the current IR node which
230404 : are NOT traversed. Those data members that are part of a traversal can be freed using
230405 : a traversal (calling this destructor on all children in a post-order traversal). Such
230406 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
230407 :
230408 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
230409 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
230410 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
230411 :
230412 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
230413 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
230414 : pointers are not yet implemented to call delete on eash pointer in the container.
230415 : (This could be done by derivation from the STL containers to define containers that
230416 : automatically deleted their members.)
230417 :
230418 : */
230419 0 : SgModAssignOp::~SgModAssignOp () {
230420 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
230421 :
230422 :
230423 :
230424 : }
230425 :
230426 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230427 0 : }
230428 :
230429 :
230430 : /* #line 230431 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230431 :
230432 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
230433 :
230434 : // Generated constructor
230435 0 : SgModAssignOp::SgModAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
230436 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
230437 : {
230438 : #ifdef DEBUG
230439 : // printf ("In SgModAssignOp::SgModAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
230440 : #endif
230441 : #if 0
230442 : // debugging information!
230443 : printf ("In SgModAssignOp::SgModAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
230444 : #endif
230445 :
230446 :
230447 :
230448 : #if 0
230449 : // DQ (7/30/2014): Call a virtual function.
230450 : std::string s = this->class_name();
230451 : #endif
230452 :
230453 : // Test the variant virtual function
230454 : // assert(MOD_ASSIGN_OP == variant());
230455 0 : assert(MOD_ASSIGN_OP == this->variant());
230456 0 : ROSE_ASSERT(MOD_ASSIGN_OP == (int)(this->variantT()));
230457 0 : post_construction_initialization();
230458 :
230459 : // Test the isSgModAssignOp() function since it has been problematic
230460 0 : assert(isSgModAssignOp(this) != NULL);
230461 0 : }
230462 :
230463 : // Generated constructor (all data members)
230464 :
230465 : /* #line 230466 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230466 :
230467 :
230468 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230469 :
230470 :
230471 : // ********************************************************
230472 : // member functions common across all array grammar objects
230473 : // ********************************************************
230474 :
230475 :
230476 :
230477 : /* #line 230478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230478 :
230479 :
230480 :
230481 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230482 :
230483 : // ********************************************************
230484 : // member functions specific to each node in the grammar
230485 : // ********************************************************
230486 :
230487 :
230488 : /* #line 230489 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230489 :
230490 : // Start of memberFunctionString
230491 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
230492 :
230493 : void
230494 3 : SgXorAssignOp::post_construction_initialization()
230495 : {
230496 3 : }
230497 :
230498 :
230499 :
230500 : // End of memberFunctionString
230501 : // Start of memberFunctionString
230502 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
230503 :
230504 : // *** COMMON CODE SECTION BEGINS HERE ***
230505 :
230506 : #if 0
230507 : int
230508 : SgXorAssignOp::getVariant() const
230509 : {
230510 : // This function is used in ROSE while "variant()" is used in SAGE
230511 : assert(this != NULL);
230512 : return variant();
230513 : }
230514 : #endif
230515 :
230516 : // This function is used in ROSE in treeTraversal code
230517 : // eventually replaces getVariant() and variant()
230518 : // though after variant() has been removed for a while we will
230519 : // want to change the name of variantT() back to variant()
230520 : // (since the "T" was ment to stand for temporary).
230521 : // When this happens the variantT() will be depricated.
230522 : VariantT
230523 3128 : SgXorAssignOp::variantT() const
230524 : {
230525 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
230526 3128 : ROSE_ASSERT(this != NULL);
230527 3128 : return V_SgXorAssignOp;
230528 : }
230529 :
230530 : #if 0
230531 : int
230532 : SgXorAssignOp::variant() const
230533 : {
230534 : // This function is used in SAGE
230535 : ROSE_ASSERT(this != NULL);
230536 : return XOR_ASSIGN_OP;
230537 : }
230538 : #endif
230539 :
230540 : ROSE_DLL_API const char*
230541 0 : SgXorAssignOp::sage_class_name() const
230542 : {
230543 0 : ROSE_ASSERT(this != NULL);
230544 0 : return "SgXorAssignOp";
230545 : }
230546 :
230547 : std::string
230548 2 : SgXorAssignOp::class_name() const
230549 : {
230550 2 : ROSE_ASSERT(this != NULL);
230551 2 : return "SgXorAssignOp";
230552 : }
230553 :
230554 : // DQ (11/26/2005): Support for visitor pattern mechanims
230555 : // (inferior to ROSE traversal mechanism, experimental).
230556 : void
230557 18 : SgXorAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
230558 : {
230559 18 : ROSE_ASSERT(this != NULL);
230560 18 : visitor.visit(this);
230561 18 : }
230562 :
230563 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
230564 0 : void SgXorAssignOp::accept (ROSE_VisitorPattern & visitor) {
230565 0 : ROSE_ASSERT(this != NULL);
230566 0 : visitor.visit(this);
230567 0 : }
230568 :
230569 : SgXorAssignOp*
230570 0 : SgXorAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
230571 : {
230572 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
230573 : // This function is currently only supported for the AST used the represent Binary executables.
230574 : if (0 /* isSgAsmNode(this) != NULL */)
230575 : {
230576 : // Support for regex specification.
230577 : std::string prefixCode = "REGEX:";
230578 : addNewAttribute(prefixCode + s,a);
230579 : }
230580 : #endif
230581 :
230582 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
230583 0 : return this;
230584 : }
230585 :
230586 : // *** COMMON CODE SECTION ENDS HERE ***
230587 :
230588 :
230589 : // End of memberFunctionString
230590 : // Start of memberFunctionString
230591 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
230592 :
230593 :
230594 : #if 0
230595 : //! Error checking support
230596 : /*! Verifies the following:
230597 : - working getVariant() member function
230598 : - calls base class's error() member function
230599 : Every class has one of these functions.
230600 : */
230601 : bool
230602 : SgXorAssignOp::error()
230603 : {
230604 : // Put error checking here
230605 :
230606 : ROSE_ASSERT (this != NULL);
230607 : if (getVariant() != XOR_ASSIGN_OP)
230608 : {
230609 : printf ("Error in SgXorAssignOp::error(): SgXorAssignOp object has a %s variant \n",
230610 : Cxx_GrammarTerminalNames[getVariant()].name);
230611 : // printf ("Error in SgXorAssignOp::error() \n");
230612 : ROSE_ABORT();
230613 : }
230614 :
230615 : ROSE_ASSERT (getVariant() == XOR_ASSIGN_OP);
230616 : return SgCompoundAssignOp::error();
230617 : }
230618 : #endif
230619 :
230620 :
230621 :
230622 : // End of memberFunctionString
230623 :
230624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
230625 :
230626 3 : SgXorAssignOp* isSgXorAssignOp ( SgNode* inputDerivedClassPointer )
230627 : {
230628 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230629 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230630 : // So to fix this we return NULL directly when the input is NULL and avoid the
230631 : // dynamic_cast in this case. This is likely a performance improvement as well.
230632 : // return dynamic_cast<SgXorAssignOp*>(inputDerivedClassPointer);
230633 : // Milind Chabbi (8/28/2013): isSgXorAssignOp uses table-driven castability instead of c++ default dynamic_cast
230634 : // this improves the running time performance by 10-20%.
230635 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgXorAssignOp*>(inputDerivedClassPointer);
230636 3 : return IS_SgXorAssignOp_FAST_MACRO(inputDerivedClassPointer);
230637 : }
230638 :
230639 : // DQ (11/8/2003): Added version of functions taking const pointer
230640 0 : const SgXorAssignOp* isSgXorAssignOp ( const SgNode* inputDerivedClassPointer )
230641 : {
230642 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230643 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230644 : // So to fix this we return NULL directly when the input is NULL and avoid the
230645 : // dynamic_cast in this case. This is likely a performance improvement as well.
230646 : // return dynamic_cast<const SgXorAssignOp*>(inputDerivedClassPointer);
230647 : // Milind Chabbi (8/28/2013): isSgXorAssignOp uses table-driven castability instead of c++ default dynamic_cast
230648 : // this improves the running time performance by 10-20%.
230649 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgXorAssignOp*>(inputDerivedClassPointer);
230650 0 : return IS_SgXorAssignOp_FAST_MACRO(inputDerivedClassPointer);
230651 : }
230652 :
230653 :
230654 :
230655 : /* #line 230656 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230656 :
230657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230658 :
230659 : /**
230660 : \brief Generated destructor
230661 :
230662 : This destructor is automatically generated (by ROSETTA). This destructor
230663 : only frees memory of data members associated with the parts of the current IR node which
230664 : are NOT traversed. Those data members that are part of a traversal can be freed using
230665 : a traversal (calling this destructor on all children in a post-order traversal). Such
230666 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
230667 :
230668 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
230669 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
230670 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
230671 :
230672 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
230673 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
230674 : pointers are not yet implemented to call delete on eash pointer in the container.
230675 : (This could be done by derivation from the STL containers to define containers that
230676 : automatically deleted their members.)
230677 :
230678 : */
230679 0 : SgXorAssignOp::~SgXorAssignOp () {
230680 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
230681 :
230682 :
230683 :
230684 : }
230685 :
230686 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230687 0 : }
230688 :
230689 :
230690 : /* #line 230691 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230691 :
230692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
230693 :
230694 : // Generated constructor
230695 0 : SgXorAssignOp::SgXorAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
230696 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
230697 : {
230698 : #ifdef DEBUG
230699 : // printf ("In SgXorAssignOp::SgXorAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
230700 : #endif
230701 : #if 0
230702 : // debugging information!
230703 : printf ("In SgXorAssignOp::SgXorAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
230704 : #endif
230705 :
230706 :
230707 :
230708 : #if 0
230709 : // DQ (7/30/2014): Call a virtual function.
230710 : std::string s = this->class_name();
230711 : #endif
230712 :
230713 : // Test the variant virtual function
230714 : // assert(XOR_ASSIGN_OP == variant());
230715 0 : assert(XOR_ASSIGN_OP == this->variant());
230716 0 : ROSE_ASSERT(XOR_ASSIGN_OP == (int)(this->variantT()));
230717 0 : post_construction_initialization();
230718 :
230719 : // Test the isSgXorAssignOp() function since it has been problematic
230720 0 : assert(isSgXorAssignOp(this) != NULL);
230721 0 : }
230722 :
230723 : // Generated constructor (all data members)
230724 :
230725 : /* #line 230726 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230726 :
230727 :
230728 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230729 :
230730 :
230731 : // ********************************************************
230732 : // member functions common across all array grammar objects
230733 : // ********************************************************
230734 :
230735 :
230736 :
230737 : /* #line 230738 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230738 :
230739 :
230740 :
230741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230742 :
230743 : // ********************************************************
230744 : // member functions specific to each node in the grammar
230745 : // ********************************************************
230746 :
230747 :
230748 : /* #line 230749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230749 :
230750 : // Start of memberFunctionString
230751 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
230752 :
230753 : void
230754 0 : SgLshiftAssignOp::post_construction_initialization()
230755 : {
230756 0 : }
230757 :
230758 :
230759 :
230760 : // End of memberFunctionString
230761 : // Start of memberFunctionString
230762 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
230763 :
230764 : // *** COMMON CODE SECTION BEGINS HERE ***
230765 :
230766 : #if 0
230767 : int
230768 : SgLshiftAssignOp::getVariant() const
230769 : {
230770 : // This function is used in ROSE while "variant()" is used in SAGE
230771 : assert(this != NULL);
230772 : return variant();
230773 : }
230774 : #endif
230775 :
230776 : // This function is used in ROSE in treeTraversal code
230777 : // eventually replaces getVariant() and variant()
230778 : // though after variant() has been removed for a while we will
230779 : // want to change the name of variantT() back to variant()
230780 : // (since the "T" was ment to stand for temporary).
230781 : // When this happens the variantT() will be depricated.
230782 : VariantT
230783 0 : SgLshiftAssignOp::variantT() const
230784 : {
230785 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
230786 0 : ROSE_ASSERT(this != NULL);
230787 0 : return V_SgLshiftAssignOp;
230788 : }
230789 :
230790 : #if 0
230791 : int
230792 : SgLshiftAssignOp::variant() const
230793 : {
230794 : // This function is used in SAGE
230795 : ROSE_ASSERT(this != NULL);
230796 : return LSHIFT_ASSIGN_OP;
230797 : }
230798 : #endif
230799 :
230800 : ROSE_DLL_API const char*
230801 0 : SgLshiftAssignOp::sage_class_name() const
230802 : {
230803 0 : ROSE_ASSERT(this != NULL);
230804 0 : return "SgLshiftAssignOp";
230805 : }
230806 :
230807 : std::string
230808 0 : SgLshiftAssignOp::class_name() const
230809 : {
230810 0 : ROSE_ASSERT(this != NULL);
230811 0 : return "SgLshiftAssignOp";
230812 : }
230813 :
230814 : // DQ (11/26/2005): Support for visitor pattern mechanims
230815 : // (inferior to ROSE traversal mechanism, experimental).
230816 : void
230817 0 : SgLshiftAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
230818 : {
230819 0 : ROSE_ASSERT(this != NULL);
230820 0 : visitor.visit(this);
230821 0 : }
230822 :
230823 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
230824 0 : void SgLshiftAssignOp::accept (ROSE_VisitorPattern & visitor) {
230825 0 : ROSE_ASSERT(this != NULL);
230826 0 : visitor.visit(this);
230827 0 : }
230828 :
230829 : SgLshiftAssignOp*
230830 0 : SgLshiftAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
230831 : {
230832 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
230833 : // This function is currently only supported for the AST used the represent Binary executables.
230834 : if (0 /* isSgAsmNode(this) != NULL */)
230835 : {
230836 : // Support for regex specification.
230837 : std::string prefixCode = "REGEX:";
230838 : addNewAttribute(prefixCode + s,a);
230839 : }
230840 : #endif
230841 :
230842 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
230843 0 : return this;
230844 : }
230845 :
230846 : // *** COMMON CODE SECTION ENDS HERE ***
230847 :
230848 :
230849 : // End of memberFunctionString
230850 : // Start of memberFunctionString
230851 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
230852 :
230853 :
230854 : #if 0
230855 : //! Error checking support
230856 : /*! Verifies the following:
230857 : - working getVariant() member function
230858 : - calls base class's error() member function
230859 : Every class has one of these functions.
230860 : */
230861 : bool
230862 : SgLshiftAssignOp::error()
230863 : {
230864 : // Put error checking here
230865 :
230866 : ROSE_ASSERT (this != NULL);
230867 : if (getVariant() != LSHIFT_ASSIGN_OP)
230868 : {
230869 : printf ("Error in SgLshiftAssignOp::error(): SgLshiftAssignOp object has a %s variant \n",
230870 : Cxx_GrammarTerminalNames[getVariant()].name);
230871 : // printf ("Error in SgLshiftAssignOp::error() \n");
230872 : ROSE_ABORT();
230873 : }
230874 :
230875 : ROSE_ASSERT (getVariant() == LSHIFT_ASSIGN_OP);
230876 : return SgCompoundAssignOp::error();
230877 : }
230878 : #endif
230879 :
230880 :
230881 :
230882 : // End of memberFunctionString
230883 :
230884 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
230885 :
230886 0 : SgLshiftAssignOp* isSgLshiftAssignOp ( SgNode* inputDerivedClassPointer )
230887 : {
230888 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230889 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230890 : // So to fix this we return NULL directly when the input is NULL and avoid the
230891 : // dynamic_cast in this case. This is likely a performance improvement as well.
230892 : // return dynamic_cast<SgLshiftAssignOp*>(inputDerivedClassPointer);
230893 : // Milind Chabbi (8/28/2013): isSgLshiftAssignOp uses table-driven castability instead of c++ default dynamic_cast
230894 : // this improves the running time performance by 10-20%.
230895 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLshiftAssignOp*>(inputDerivedClassPointer);
230896 0 : return IS_SgLshiftAssignOp_FAST_MACRO(inputDerivedClassPointer);
230897 : }
230898 :
230899 : // DQ (11/8/2003): Added version of functions taking const pointer
230900 0 : const SgLshiftAssignOp* isSgLshiftAssignOp ( const SgNode* inputDerivedClassPointer )
230901 : {
230902 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
230903 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
230904 : // So to fix this we return NULL directly when the input is NULL and avoid the
230905 : // dynamic_cast in this case. This is likely a performance improvement as well.
230906 : // return dynamic_cast<const SgLshiftAssignOp*>(inputDerivedClassPointer);
230907 : // Milind Chabbi (8/28/2013): isSgLshiftAssignOp uses table-driven castability instead of c++ default dynamic_cast
230908 : // this improves the running time performance by 10-20%.
230909 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLshiftAssignOp*>(inputDerivedClassPointer);
230910 0 : return IS_SgLshiftAssignOp_FAST_MACRO(inputDerivedClassPointer);
230911 : }
230912 :
230913 :
230914 :
230915 : /* #line 230916 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230916 :
230917 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230918 :
230919 : /**
230920 : \brief Generated destructor
230921 :
230922 : This destructor is automatically generated (by ROSETTA). This destructor
230923 : only frees memory of data members associated with the parts of the current IR node which
230924 : are NOT traversed. Those data members that are part of a traversal can be freed using
230925 : a traversal (calling this destructor on all children in a post-order traversal). Such
230926 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
230927 :
230928 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
230929 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
230930 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
230931 :
230932 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
230933 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
230934 : pointers are not yet implemented to call delete on eash pointer in the container.
230935 : (This could be done by derivation from the STL containers to define containers that
230936 : automatically deleted their members.)
230937 :
230938 : */
230939 0 : SgLshiftAssignOp::~SgLshiftAssignOp () {
230940 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
230941 :
230942 :
230943 :
230944 : }
230945 :
230946 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
230947 0 : }
230948 :
230949 :
230950 : /* #line 230951 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230951 :
230952 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
230953 :
230954 : // Generated constructor
230955 0 : SgLshiftAssignOp::SgLshiftAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
230956 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
230957 : {
230958 : #ifdef DEBUG
230959 : // printf ("In SgLshiftAssignOp::SgLshiftAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
230960 : #endif
230961 : #if 0
230962 : // debugging information!
230963 : printf ("In SgLshiftAssignOp::SgLshiftAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
230964 : #endif
230965 :
230966 :
230967 :
230968 : #if 0
230969 : // DQ (7/30/2014): Call a virtual function.
230970 : std::string s = this->class_name();
230971 : #endif
230972 :
230973 : // Test the variant virtual function
230974 : // assert(LSHIFT_ASSIGN_OP == variant());
230975 0 : assert(LSHIFT_ASSIGN_OP == this->variant());
230976 0 : ROSE_ASSERT(LSHIFT_ASSIGN_OP == (int)(this->variantT()));
230977 0 : post_construction_initialization();
230978 :
230979 : // Test the isSgLshiftAssignOp() function since it has been problematic
230980 0 : assert(isSgLshiftAssignOp(this) != NULL);
230981 0 : }
230982 :
230983 : // Generated constructor (all data members)
230984 :
230985 : /* #line 230986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230986 :
230987 :
230988 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
230989 :
230990 :
230991 : // ********************************************************
230992 : // member functions common across all array grammar objects
230993 : // ********************************************************
230994 :
230995 :
230996 :
230997 : /* #line 230998 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
230998 :
230999 :
231000 :
231001 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231002 :
231003 : // ********************************************************
231004 : // member functions specific to each node in the grammar
231005 : // ********************************************************
231006 :
231007 :
231008 : /* #line 231009 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231009 :
231010 : // Start of memberFunctionString
231011 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231012 :
231013 : void
231014 16 : SgRshiftAssignOp::post_construction_initialization()
231015 : {
231016 16 : }
231017 :
231018 :
231019 :
231020 : // End of memberFunctionString
231021 : // Start of memberFunctionString
231022 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
231023 :
231024 : // *** COMMON CODE SECTION BEGINS HERE ***
231025 :
231026 : #if 0
231027 : int
231028 : SgRshiftAssignOp::getVariant() const
231029 : {
231030 : // This function is used in ROSE while "variant()" is used in SAGE
231031 : assert(this != NULL);
231032 : return variant();
231033 : }
231034 : #endif
231035 :
231036 : // This function is used in ROSE in treeTraversal code
231037 : // eventually replaces getVariant() and variant()
231038 : // though after variant() has been removed for a while we will
231039 : // want to change the name of variantT() back to variant()
231040 : // (since the "T" was ment to stand for temporary).
231041 : // When this happens the variantT() will be depricated.
231042 : VariantT
231043 3034 : SgRshiftAssignOp::variantT() const
231044 : {
231045 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
231046 3034 : ROSE_ASSERT(this != NULL);
231047 3034 : return V_SgRshiftAssignOp;
231048 : }
231049 :
231050 : #if 0
231051 : int
231052 : SgRshiftAssignOp::variant() const
231053 : {
231054 : // This function is used in SAGE
231055 : ROSE_ASSERT(this != NULL);
231056 : return RSHIFT_ASSIGN_OP;
231057 : }
231058 : #endif
231059 :
231060 : ROSE_DLL_API const char*
231061 0 : SgRshiftAssignOp::sage_class_name() const
231062 : {
231063 0 : ROSE_ASSERT(this != NULL);
231064 0 : return "SgRshiftAssignOp";
231065 : }
231066 :
231067 : std::string
231068 14 : SgRshiftAssignOp::class_name() const
231069 : {
231070 14 : ROSE_ASSERT(this != NULL);
231071 14 : return "SgRshiftAssignOp";
231072 : }
231073 :
231074 : // DQ (11/26/2005): Support for visitor pattern mechanims
231075 : // (inferior to ROSE traversal mechanism, experimental).
231076 : void
231077 274 : SgRshiftAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
231078 : {
231079 274 : ROSE_ASSERT(this != NULL);
231080 274 : visitor.visit(this);
231081 274 : }
231082 :
231083 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
231084 0 : void SgRshiftAssignOp::accept (ROSE_VisitorPattern & visitor) {
231085 0 : ROSE_ASSERT(this != NULL);
231086 0 : visitor.visit(this);
231087 0 : }
231088 :
231089 : SgRshiftAssignOp*
231090 0 : SgRshiftAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
231091 : {
231092 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
231093 : // This function is currently only supported for the AST used the represent Binary executables.
231094 : if (0 /* isSgAsmNode(this) != NULL */)
231095 : {
231096 : // Support for regex specification.
231097 : std::string prefixCode = "REGEX:";
231098 : addNewAttribute(prefixCode + s,a);
231099 : }
231100 : #endif
231101 :
231102 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
231103 0 : return this;
231104 : }
231105 :
231106 : // *** COMMON CODE SECTION ENDS HERE ***
231107 :
231108 :
231109 : // End of memberFunctionString
231110 : // Start of memberFunctionString
231111 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
231112 :
231113 :
231114 : #if 0
231115 : //! Error checking support
231116 : /*! Verifies the following:
231117 : - working getVariant() member function
231118 : - calls base class's error() member function
231119 : Every class has one of these functions.
231120 : */
231121 : bool
231122 : SgRshiftAssignOp::error()
231123 : {
231124 : // Put error checking here
231125 :
231126 : ROSE_ASSERT (this != NULL);
231127 : if (getVariant() != RSHIFT_ASSIGN_OP)
231128 : {
231129 : printf ("Error in SgRshiftAssignOp::error(): SgRshiftAssignOp object has a %s variant \n",
231130 : Cxx_GrammarTerminalNames[getVariant()].name);
231131 : // printf ("Error in SgRshiftAssignOp::error() \n");
231132 : ROSE_ABORT();
231133 : }
231134 :
231135 : ROSE_ASSERT (getVariant() == RSHIFT_ASSIGN_OP);
231136 : return SgCompoundAssignOp::error();
231137 : }
231138 : #endif
231139 :
231140 :
231141 :
231142 : // End of memberFunctionString
231143 :
231144 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
231145 :
231146 16 : SgRshiftAssignOp* isSgRshiftAssignOp ( SgNode* inputDerivedClassPointer )
231147 : {
231148 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231149 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231150 : // So to fix this we return NULL directly when the input is NULL and avoid the
231151 : // dynamic_cast in this case. This is likely a performance improvement as well.
231152 : // return dynamic_cast<SgRshiftAssignOp*>(inputDerivedClassPointer);
231153 : // Milind Chabbi (8/28/2013): isSgRshiftAssignOp uses table-driven castability instead of c++ default dynamic_cast
231154 : // this improves the running time performance by 10-20%.
231155 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRshiftAssignOp*>(inputDerivedClassPointer);
231156 16 : return IS_SgRshiftAssignOp_FAST_MACRO(inputDerivedClassPointer);
231157 : }
231158 :
231159 : // DQ (11/8/2003): Added version of functions taking const pointer
231160 0 : const SgRshiftAssignOp* isSgRshiftAssignOp ( const SgNode* inputDerivedClassPointer )
231161 : {
231162 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231163 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231164 : // So to fix this we return NULL directly when the input is NULL and avoid the
231165 : // dynamic_cast in this case. This is likely a performance improvement as well.
231166 : // return dynamic_cast<const SgRshiftAssignOp*>(inputDerivedClassPointer);
231167 : // Milind Chabbi (8/28/2013): isSgRshiftAssignOp uses table-driven castability instead of c++ default dynamic_cast
231168 : // this improves the running time performance by 10-20%.
231169 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRshiftAssignOp*>(inputDerivedClassPointer);
231170 0 : return IS_SgRshiftAssignOp_FAST_MACRO(inputDerivedClassPointer);
231171 : }
231172 :
231173 :
231174 :
231175 : /* #line 231176 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231176 :
231177 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231178 :
231179 : /**
231180 : \brief Generated destructor
231181 :
231182 : This destructor is automatically generated (by ROSETTA). This destructor
231183 : only frees memory of data members associated with the parts of the current IR node which
231184 : are NOT traversed. Those data members that are part of a traversal can be freed using
231185 : a traversal (calling this destructor on all children in a post-order traversal). Such
231186 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
231187 :
231188 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
231189 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
231190 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
231191 :
231192 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
231193 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
231194 : pointers are not yet implemented to call delete on eash pointer in the container.
231195 : (This could be done by derivation from the STL containers to define containers that
231196 : automatically deleted their members.)
231197 :
231198 : */
231199 8 : SgRshiftAssignOp::~SgRshiftAssignOp () {
231200 4 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
231201 :
231202 :
231203 :
231204 : }
231205 :
231206 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231207 8 : }
231208 :
231209 :
231210 : /* #line 231211 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231211 :
231212 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
231213 :
231214 : // Generated constructor
231215 0 : SgRshiftAssignOp::SgRshiftAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
231216 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
231217 : {
231218 : #ifdef DEBUG
231219 : // printf ("In SgRshiftAssignOp::SgRshiftAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
231220 : #endif
231221 : #if 0
231222 : // debugging information!
231223 : printf ("In SgRshiftAssignOp::SgRshiftAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
231224 : #endif
231225 :
231226 :
231227 :
231228 : #if 0
231229 : // DQ (7/30/2014): Call a virtual function.
231230 : std::string s = this->class_name();
231231 : #endif
231232 :
231233 : // Test the variant virtual function
231234 : // assert(RSHIFT_ASSIGN_OP == variant());
231235 0 : assert(RSHIFT_ASSIGN_OP == this->variant());
231236 0 : ROSE_ASSERT(RSHIFT_ASSIGN_OP == (int)(this->variantT()));
231237 0 : post_construction_initialization();
231238 :
231239 : // Test the isSgRshiftAssignOp() function since it has been problematic
231240 0 : assert(isSgRshiftAssignOp(this) != NULL);
231241 0 : }
231242 :
231243 : // Generated constructor (all data members)
231244 :
231245 : /* #line 231246 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231246 :
231247 :
231248 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231249 :
231250 :
231251 : // ********************************************************
231252 : // member functions common across all array grammar objects
231253 : // ********************************************************
231254 :
231255 :
231256 :
231257 : /* #line 231258 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231258 :
231259 :
231260 :
231261 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231262 :
231263 : // ********************************************************
231264 : // member functions specific to each node in the grammar
231265 : // ********************************************************
231266 :
231267 :
231268 : /* #line 231269 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231269 :
231270 : // Start of memberFunctionString
231271 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231272 :
231273 : void
231274 0 : SgIntegerDivideAssignOp::post_construction_initialization()
231275 : {
231276 0 : }
231277 :
231278 :
231279 :
231280 : // End of memberFunctionString
231281 : // Start of memberFunctionString
231282 : /* #line 7152 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231283 :
231284 :
231285 :
231286 : // End of memberFunctionString
231287 : // Start of memberFunctionString
231288 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
231289 :
231290 : // *** COMMON CODE SECTION BEGINS HERE ***
231291 :
231292 : #if 0
231293 : int
231294 : SgIntegerDivideAssignOp::getVariant() const
231295 : {
231296 : // This function is used in ROSE while "variant()" is used in SAGE
231297 : assert(this != NULL);
231298 : return variant();
231299 : }
231300 : #endif
231301 :
231302 : // This function is used in ROSE in treeTraversal code
231303 : // eventually replaces getVariant() and variant()
231304 : // though after variant() has been removed for a while we will
231305 : // want to change the name of variantT() back to variant()
231306 : // (since the "T" was ment to stand for temporary).
231307 : // When this happens the variantT() will be depricated.
231308 : VariantT
231309 0 : SgIntegerDivideAssignOp::variantT() const
231310 : {
231311 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
231312 0 : ROSE_ASSERT(this != NULL);
231313 0 : return V_SgIntegerDivideAssignOp;
231314 : }
231315 :
231316 : #if 0
231317 : int
231318 : SgIntegerDivideAssignOp::variant() const
231319 : {
231320 : // This function is used in SAGE
231321 : ROSE_ASSERT(this != NULL);
231322 : return IDIV_ASSIGN_OP;
231323 : }
231324 : #endif
231325 :
231326 : ROSE_DLL_API const char*
231327 0 : SgIntegerDivideAssignOp::sage_class_name() const
231328 : {
231329 0 : ROSE_ASSERT(this != NULL);
231330 0 : return "SgIntegerDivideAssignOp";
231331 : }
231332 :
231333 : std::string
231334 0 : SgIntegerDivideAssignOp::class_name() const
231335 : {
231336 0 : ROSE_ASSERT(this != NULL);
231337 0 : return "SgIntegerDivideAssignOp";
231338 : }
231339 :
231340 : // DQ (11/26/2005): Support for visitor pattern mechanims
231341 : // (inferior to ROSE traversal mechanism, experimental).
231342 : void
231343 0 : SgIntegerDivideAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
231344 : {
231345 0 : ROSE_ASSERT(this != NULL);
231346 0 : visitor.visit(this);
231347 0 : }
231348 :
231349 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
231350 0 : void SgIntegerDivideAssignOp::accept (ROSE_VisitorPattern & visitor) {
231351 0 : ROSE_ASSERT(this != NULL);
231352 0 : visitor.visit(this);
231353 0 : }
231354 :
231355 : SgIntegerDivideAssignOp*
231356 0 : SgIntegerDivideAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
231357 : {
231358 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
231359 : // This function is currently only supported for the AST used the represent Binary executables.
231360 : if (0 /* isSgAsmNode(this) != NULL */)
231361 : {
231362 : // Support for regex specification.
231363 : std::string prefixCode = "REGEX:";
231364 : addNewAttribute(prefixCode + s,a);
231365 : }
231366 : #endif
231367 :
231368 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
231369 0 : return this;
231370 : }
231371 :
231372 : // *** COMMON CODE SECTION ENDS HERE ***
231373 :
231374 :
231375 : // End of memberFunctionString
231376 : // Start of memberFunctionString
231377 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
231378 :
231379 :
231380 : #if 0
231381 : //! Error checking support
231382 : /*! Verifies the following:
231383 : - working getVariant() member function
231384 : - calls base class's error() member function
231385 : Every class has one of these functions.
231386 : */
231387 : bool
231388 : SgIntegerDivideAssignOp::error()
231389 : {
231390 : // Put error checking here
231391 :
231392 : ROSE_ASSERT (this != NULL);
231393 : if (getVariant() != IDIV_ASSIGN_OP)
231394 : {
231395 : printf ("Error in SgIntegerDivideAssignOp::error(): SgIntegerDivideAssignOp object has a %s variant \n",
231396 : Cxx_GrammarTerminalNames[getVariant()].name);
231397 : // printf ("Error in SgIntegerDivideAssignOp::error() \n");
231398 : ROSE_ABORT();
231399 : }
231400 :
231401 : ROSE_ASSERT (getVariant() == IDIV_ASSIGN_OP);
231402 : return SgCompoundAssignOp::error();
231403 : }
231404 : #endif
231405 :
231406 :
231407 :
231408 : // End of memberFunctionString
231409 :
231410 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
231411 :
231412 0 : SgIntegerDivideAssignOp* isSgIntegerDivideAssignOp ( SgNode* inputDerivedClassPointer )
231413 : {
231414 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231415 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231416 : // So to fix this we return NULL directly when the input is NULL and avoid the
231417 : // dynamic_cast in this case. This is likely a performance improvement as well.
231418 : // return dynamic_cast<SgIntegerDivideAssignOp*>(inputDerivedClassPointer);
231419 : // Milind Chabbi (8/28/2013): isSgIntegerDivideAssignOp uses table-driven castability instead of c++ default dynamic_cast
231420 : // this improves the running time performance by 10-20%.
231421 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIntegerDivideAssignOp*>(inputDerivedClassPointer);
231422 0 : return IS_SgIntegerDivideAssignOp_FAST_MACRO(inputDerivedClassPointer);
231423 : }
231424 :
231425 : // DQ (11/8/2003): Added version of functions taking const pointer
231426 0 : const SgIntegerDivideAssignOp* isSgIntegerDivideAssignOp ( const SgNode* inputDerivedClassPointer )
231427 : {
231428 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231429 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231430 : // So to fix this we return NULL directly when the input is NULL and avoid the
231431 : // dynamic_cast in this case. This is likely a performance improvement as well.
231432 : // return dynamic_cast<const SgIntegerDivideAssignOp*>(inputDerivedClassPointer);
231433 : // Milind Chabbi (8/28/2013): isSgIntegerDivideAssignOp uses table-driven castability instead of c++ default dynamic_cast
231434 : // this improves the running time performance by 10-20%.
231435 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIntegerDivideAssignOp*>(inputDerivedClassPointer);
231436 0 : return IS_SgIntegerDivideAssignOp_FAST_MACRO(inputDerivedClassPointer);
231437 : }
231438 :
231439 :
231440 :
231441 : /* #line 231442 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231442 :
231443 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231444 :
231445 : /**
231446 : \brief Generated destructor
231447 :
231448 : This destructor is automatically generated (by ROSETTA). This destructor
231449 : only frees memory of data members associated with the parts of the current IR node which
231450 : are NOT traversed. Those data members that are part of a traversal can be freed using
231451 : a traversal (calling this destructor on all children in a post-order traversal). Such
231452 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
231453 :
231454 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
231455 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
231456 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
231457 :
231458 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
231459 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
231460 : pointers are not yet implemented to call delete on eash pointer in the container.
231461 : (This could be done by derivation from the STL containers to define containers that
231462 : automatically deleted their members.)
231463 :
231464 : */
231465 0 : SgIntegerDivideAssignOp::~SgIntegerDivideAssignOp () {
231466 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
231467 :
231468 :
231469 :
231470 : }
231471 :
231472 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231473 0 : }
231474 :
231475 :
231476 : /* #line 231477 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231477 :
231478 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
231479 :
231480 : // Generated constructor
231481 0 : SgIntegerDivideAssignOp::SgIntegerDivideAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
231482 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
231483 : {
231484 : #ifdef DEBUG
231485 : // printf ("In SgIntegerDivideAssignOp::SgIntegerDivideAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
231486 : #endif
231487 : #if 0
231488 : // debugging information!
231489 : printf ("In SgIntegerDivideAssignOp::SgIntegerDivideAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
231490 : #endif
231491 :
231492 :
231493 :
231494 : #if 0
231495 : // DQ (7/30/2014): Call a virtual function.
231496 : std::string s = this->class_name();
231497 : #endif
231498 :
231499 : // Test the variant virtual function
231500 : // assert(IDIV_ASSIGN_OP == variant());
231501 0 : assert(IDIV_ASSIGN_OP == this->variant());
231502 0 : ROSE_ASSERT(IDIV_ASSIGN_OP == (int)(this->variantT()));
231503 0 : post_construction_initialization();
231504 :
231505 : // Test the isSgIntegerDivideAssignOp() function since it has been problematic
231506 0 : assert(isSgIntegerDivideAssignOp(this) != NULL);
231507 0 : }
231508 :
231509 : // Generated constructor (all data members)
231510 :
231511 : /* #line 231512 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231512 :
231513 :
231514 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231515 :
231516 :
231517 : // ********************************************************
231518 : // member functions common across all array grammar objects
231519 : // ********************************************************
231520 :
231521 :
231522 :
231523 : /* #line 231524 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231524 :
231525 :
231526 :
231527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231528 :
231529 : // ********************************************************
231530 : // member functions specific to each node in the grammar
231531 : // ********************************************************
231532 :
231533 :
231534 : /* #line 231535 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231535 :
231536 : // Start of memberFunctionString
231537 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231538 :
231539 : void
231540 0 : SgExponentiationAssignOp::post_construction_initialization()
231541 : {
231542 0 : }
231543 :
231544 :
231545 :
231546 : // End of memberFunctionString
231547 : // Start of memberFunctionString
231548 : /* #line 7155 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231549 :
231550 :
231551 :
231552 : // End of memberFunctionString
231553 : // Start of memberFunctionString
231554 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
231555 :
231556 : // *** COMMON CODE SECTION BEGINS HERE ***
231557 :
231558 : #if 0
231559 : int
231560 : SgExponentiationAssignOp::getVariant() const
231561 : {
231562 : // This function is used in ROSE while "variant()" is used in SAGE
231563 : assert(this != NULL);
231564 : return variant();
231565 : }
231566 : #endif
231567 :
231568 : // This function is used in ROSE in treeTraversal code
231569 : // eventually replaces getVariant() and variant()
231570 : // though after variant() has been removed for a while we will
231571 : // want to change the name of variantT() back to variant()
231572 : // (since the "T" was ment to stand for temporary).
231573 : // When this happens the variantT() will be depricated.
231574 : VariantT
231575 0 : SgExponentiationAssignOp::variantT() const
231576 : {
231577 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
231578 0 : ROSE_ASSERT(this != NULL);
231579 0 : return V_SgExponentiationAssignOp;
231580 : }
231581 :
231582 : #if 0
231583 : int
231584 : SgExponentiationAssignOp::variant() const
231585 : {
231586 : // This function is used in SAGE
231587 : ROSE_ASSERT(this != NULL);
231588 : return EXP_ASSIGN_OP;
231589 : }
231590 : #endif
231591 :
231592 : ROSE_DLL_API const char*
231593 0 : SgExponentiationAssignOp::sage_class_name() const
231594 : {
231595 0 : ROSE_ASSERT(this != NULL);
231596 0 : return "SgExponentiationAssignOp";
231597 : }
231598 :
231599 : std::string
231600 0 : SgExponentiationAssignOp::class_name() const
231601 : {
231602 0 : ROSE_ASSERT(this != NULL);
231603 0 : return "SgExponentiationAssignOp";
231604 : }
231605 :
231606 : // DQ (11/26/2005): Support for visitor pattern mechanims
231607 : // (inferior to ROSE traversal mechanism, experimental).
231608 : void
231609 0 : SgExponentiationAssignOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
231610 : {
231611 0 : ROSE_ASSERT(this != NULL);
231612 0 : visitor.visit(this);
231613 0 : }
231614 :
231615 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
231616 0 : void SgExponentiationAssignOp::accept (ROSE_VisitorPattern & visitor) {
231617 0 : ROSE_ASSERT(this != NULL);
231618 0 : visitor.visit(this);
231619 0 : }
231620 :
231621 : SgExponentiationAssignOp*
231622 0 : SgExponentiationAssignOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
231623 : {
231624 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
231625 : // This function is currently only supported for the AST used the represent Binary executables.
231626 : if (0 /* isSgAsmNode(this) != NULL */)
231627 : {
231628 : // Support for regex specification.
231629 : std::string prefixCode = "REGEX:";
231630 : addNewAttribute(prefixCode + s,a);
231631 : }
231632 : #endif
231633 :
231634 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
231635 0 : return this;
231636 : }
231637 :
231638 : // *** COMMON CODE SECTION ENDS HERE ***
231639 :
231640 :
231641 : // End of memberFunctionString
231642 : // Start of memberFunctionString
231643 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
231644 :
231645 :
231646 : #if 0
231647 : //! Error checking support
231648 : /*! Verifies the following:
231649 : - working getVariant() member function
231650 : - calls base class's error() member function
231651 : Every class has one of these functions.
231652 : */
231653 : bool
231654 : SgExponentiationAssignOp::error()
231655 : {
231656 : // Put error checking here
231657 :
231658 : ROSE_ASSERT (this != NULL);
231659 : if (getVariant() != EXP_ASSIGN_OP)
231660 : {
231661 : printf ("Error in SgExponentiationAssignOp::error(): SgExponentiationAssignOp object has a %s variant \n",
231662 : Cxx_GrammarTerminalNames[getVariant()].name);
231663 : // printf ("Error in SgExponentiationAssignOp::error() \n");
231664 : ROSE_ABORT();
231665 : }
231666 :
231667 : ROSE_ASSERT (getVariant() == EXP_ASSIGN_OP);
231668 : return SgCompoundAssignOp::error();
231669 : }
231670 : #endif
231671 :
231672 :
231673 :
231674 : // End of memberFunctionString
231675 :
231676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
231677 :
231678 0 : SgExponentiationAssignOp* isSgExponentiationAssignOp ( SgNode* inputDerivedClassPointer )
231679 : {
231680 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231681 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231682 : // So to fix this we return NULL directly when the input is NULL and avoid the
231683 : // dynamic_cast in this case. This is likely a performance improvement as well.
231684 : // return dynamic_cast<SgExponentiationAssignOp*>(inputDerivedClassPointer);
231685 : // Milind Chabbi (8/28/2013): isSgExponentiationAssignOp uses table-driven castability instead of c++ default dynamic_cast
231686 : // this improves the running time performance by 10-20%.
231687 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExponentiationAssignOp*>(inputDerivedClassPointer);
231688 0 : return IS_SgExponentiationAssignOp_FAST_MACRO(inputDerivedClassPointer);
231689 : }
231690 :
231691 : // DQ (11/8/2003): Added version of functions taking const pointer
231692 0 : const SgExponentiationAssignOp* isSgExponentiationAssignOp ( const SgNode* inputDerivedClassPointer )
231693 : {
231694 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231695 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231696 : // So to fix this we return NULL directly when the input is NULL and avoid the
231697 : // dynamic_cast in this case. This is likely a performance improvement as well.
231698 : // return dynamic_cast<const SgExponentiationAssignOp*>(inputDerivedClassPointer);
231699 : // Milind Chabbi (8/28/2013): isSgExponentiationAssignOp uses table-driven castability instead of c++ default dynamic_cast
231700 : // this improves the running time performance by 10-20%.
231701 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExponentiationAssignOp*>(inputDerivedClassPointer);
231702 0 : return IS_SgExponentiationAssignOp_FAST_MACRO(inputDerivedClassPointer);
231703 : }
231704 :
231705 :
231706 :
231707 : /* #line 231708 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231708 :
231709 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231710 :
231711 : /**
231712 : \brief Generated destructor
231713 :
231714 : This destructor is automatically generated (by ROSETTA). This destructor
231715 : only frees memory of data members associated with the parts of the current IR node which
231716 : are NOT traversed. Those data members that are part of a traversal can be freed using
231717 : a traversal (calling this destructor on all children in a post-order traversal). Such
231718 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
231719 :
231720 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
231721 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
231722 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
231723 :
231724 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
231725 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
231726 : pointers are not yet implemented to call delete on eash pointer in the container.
231727 : (This could be done by derivation from the STL containers to define containers that
231728 : automatically deleted their members.)
231729 :
231730 : */
231731 0 : SgExponentiationAssignOp::~SgExponentiationAssignOp () {
231732 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
231733 :
231734 :
231735 :
231736 : }
231737 :
231738 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231739 0 : }
231740 :
231741 :
231742 : /* #line 231743 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231743 :
231744 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
231745 :
231746 : // Generated constructor
231747 0 : SgExponentiationAssignOp::SgExponentiationAssignOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
231748 0 : : SgCompoundAssignOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
231749 : {
231750 : #ifdef DEBUG
231751 : // printf ("In SgExponentiationAssignOp::SgExponentiationAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
231752 : #endif
231753 : #if 0
231754 : // debugging information!
231755 : printf ("In SgExponentiationAssignOp::SgExponentiationAssignOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
231756 : #endif
231757 :
231758 :
231759 :
231760 : #if 0
231761 : // DQ (7/30/2014): Call a virtual function.
231762 : std::string s = this->class_name();
231763 : #endif
231764 :
231765 : // Test the variant virtual function
231766 : // assert(EXP_ASSIGN_OP == variant());
231767 0 : assert(EXP_ASSIGN_OP == this->variant());
231768 0 : ROSE_ASSERT(EXP_ASSIGN_OP == (int)(this->variantT()));
231769 0 : post_construction_initialization();
231770 :
231771 : // Test the isSgExponentiationAssignOp() function since it has been problematic
231772 0 : assert(isSgExponentiationAssignOp(this) != NULL);
231773 0 : }
231774 :
231775 : // Generated constructor (all data members)
231776 :
231777 : /* #line 231778 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231778 :
231779 :
231780 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231781 :
231782 :
231783 : // ********************************************************
231784 : // member functions common across all array grammar objects
231785 : // ********************************************************
231786 :
231787 :
231788 :
231789 : /* #line 231790 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231790 :
231791 :
231792 :
231793 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
231794 :
231795 : // ********************************************************
231796 : // member functions specific to each node in the grammar
231797 : // ********************************************************
231798 :
231799 :
231800 : /* #line 231801 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231801 :
231802 : // Start of memberFunctionString
231803 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231804 :
231805 : void
231806 0 : SgMembershipOp::post_construction_initialization()
231807 : {
231808 0 : }
231809 :
231810 :
231811 :
231812 : // End of memberFunctionString
231813 : // Start of memberFunctionString
231814 : /* #line 5110 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231815 :
231816 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
231817 :
231818 :
231819 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
231820 : SgType*
231821 0 : SgMembershipOp::get_type() const
231822 : {
231823 : #if 0
231824 : printf ("In SgMembershipOp::get_type() \n");
231825 : #endif
231826 :
231827 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
231828 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
231829 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
231830 0 : SgType* returnType = (SageInterface::is_C_language() == true) ?
231831 0 : static_cast<SgType*>(SgTypeInt::createType()) :
231832 0 : static_cast<SgType*>(SgTypeBool::createType());
231833 0 : ROSE_ASSERT(returnType != NULL);
231834 0 : return returnType;
231835 : }
231836 :
231837 :
231838 :
231839 :
231840 : // End of memberFunctionString
231841 : // Start of memberFunctionString
231842 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
231843 :
231844 : // *** COMMON CODE SECTION BEGINS HERE ***
231845 :
231846 : #if 0
231847 : int
231848 : SgMembershipOp::getVariant() const
231849 : {
231850 : // This function is used in ROSE while "variant()" is used in SAGE
231851 : assert(this != NULL);
231852 : return variant();
231853 : }
231854 : #endif
231855 :
231856 : // This function is used in ROSE in treeTraversal code
231857 : // eventually replaces getVariant() and variant()
231858 : // though after variant() has been removed for a while we will
231859 : // want to change the name of variantT() back to variant()
231860 : // (since the "T" was ment to stand for temporary).
231861 : // When this happens the variantT() will be depricated.
231862 : VariantT
231863 0 : SgMembershipOp::variantT() const
231864 : {
231865 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
231866 0 : ROSE_ASSERT(this != NULL);
231867 0 : return V_SgMembershipOp;
231868 : }
231869 :
231870 : #if 0
231871 : int
231872 : SgMembershipOp::variant() const
231873 : {
231874 : // This function is used in SAGE
231875 : ROSE_ASSERT(this != NULL);
231876 : return MEMBERSHIP_OP;
231877 : }
231878 : #endif
231879 :
231880 : ROSE_DLL_API const char*
231881 0 : SgMembershipOp::sage_class_name() const
231882 : {
231883 0 : ROSE_ASSERT(this != NULL);
231884 0 : return "SgMembershipOp";
231885 : }
231886 :
231887 : std::string
231888 0 : SgMembershipOp::class_name() const
231889 : {
231890 0 : ROSE_ASSERT(this != NULL);
231891 0 : return "SgMembershipOp";
231892 : }
231893 :
231894 : // DQ (11/26/2005): Support for visitor pattern mechanims
231895 : // (inferior to ROSE traversal mechanism, experimental).
231896 : void
231897 0 : SgMembershipOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
231898 : {
231899 0 : ROSE_ASSERT(this != NULL);
231900 0 : visitor.visit(this);
231901 0 : }
231902 :
231903 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
231904 0 : void SgMembershipOp::accept (ROSE_VisitorPattern & visitor) {
231905 0 : ROSE_ASSERT(this != NULL);
231906 0 : visitor.visit(this);
231907 0 : }
231908 :
231909 : SgMembershipOp*
231910 0 : SgMembershipOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
231911 : {
231912 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
231913 : // This function is currently only supported for the AST used the represent Binary executables.
231914 : if (0 /* isSgAsmNode(this) != NULL */)
231915 : {
231916 : // Support for regex specification.
231917 : std::string prefixCode = "REGEX:";
231918 : addNewAttribute(prefixCode + s,a);
231919 : }
231920 : #endif
231921 :
231922 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
231923 0 : return this;
231924 : }
231925 :
231926 : // *** COMMON CODE SECTION ENDS HERE ***
231927 :
231928 :
231929 : // End of memberFunctionString
231930 : // Start of memberFunctionString
231931 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
231932 :
231933 :
231934 : #if 0
231935 : //! Error checking support
231936 : /*! Verifies the following:
231937 : - working getVariant() member function
231938 : - calls base class's error() member function
231939 : Every class has one of these functions.
231940 : */
231941 : bool
231942 : SgMembershipOp::error()
231943 : {
231944 : // Put error checking here
231945 :
231946 : ROSE_ASSERT (this != NULL);
231947 : if (getVariant() != MEMBERSHIP_OP)
231948 : {
231949 : printf ("Error in SgMembershipOp::error(): SgMembershipOp object has a %s variant \n",
231950 : Cxx_GrammarTerminalNames[getVariant()].name);
231951 : // printf ("Error in SgMembershipOp::error() \n");
231952 : ROSE_ABORT();
231953 : }
231954 :
231955 : ROSE_ASSERT (getVariant() == MEMBERSHIP_OP);
231956 : return SgBinaryOp::error();
231957 : }
231958 : #endif
231959 :
231960 :
231961 :
231962 : // End of memberFunctionString
231963 :
231964 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
231965 :
231966 0 : SgMembershipOp* isSgMembershipOp ( SgNode* inputDerivedClassPointer )
231967 : {
231968 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231969 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231970 : // So to fix this we return NULL directly when the input is NULL and avoid the
231971 : // dynamic_cast in this case. This is likely a performance improvement as well.
231972 : // return dynamic_cast<SgMembershipOp*>(inputDerivedClassPointer);
231973 : // Milind Chabbi (8/28/2013): isSgMembershipOp uses table-driven castability instead of c++ default dynamic_cast
231974 : // this improves the running time performance by 10-20%.
231975 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMembershipOp*>(inputDerivedClassPointer);
231976 0 : return IS_SgMembershipOp_FAST_MACRO(inputDerivedClassPointer);
231977 : }
231978 :
231979 : // DQ (11/8/2003): Added version of functions taking const pointer
231980 0 : const SgMembershipOp* isSgMembershipOp ( const SgNode* inputDerivedClassPointer )
231981 : {
231982 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
231983 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
231984 : // So to fix this we return NULL directly when the input is NULL and avoid the
231985 : // dynamic_cast in this case. This is likely a performance improvement as well.
231986 : // return dynamic_cast<const SgMembershipOp*>(inputDerivedClassPointer);
231987 : // Milind Chabbi (8/28/2013): isSgMembershipOp uses table-driven castability instead of c++ default dynamic_cast
231988 : // this improves the running time performance by 10-20%.
231989 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMembershipOp*>(inputDerivedClassPointer);
231990 0 : return IS_SgMembershipOp_FAST_MACRO(inputDerivedClassPointer);
231991 : }
231992 :
231993 :
231994 :
231995 : /* #line 231996 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
231996 :
231997 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
231998 :
231999 : /**
232000 : \brief Generated destructor
232001 :
232002 : This destructor is automatically generated (by ROSETTA). This destructor
232003 : only frees memory of data members associated with the parts of the current IR node which
232004 : are NOT traversed. Those data members that are part of a traversal can be freed using
232005 : a traversal (calling this destructor on all children in a post-order traversal). Such
232006 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
232007 :
232008 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
232009 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
232010 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
232011 :
232012 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
232013 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
232014 : pointers are not yet implemented to call delete on eash pointer in the container.
232015 : (This could be done by derivation from the STL containers to define containers that
232016 : automatically deleted their members.)
232017 :
232018 : */
232019 0 : SgMembershipOp::~SgMembershipOp () {
232020 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
232021 :
232022 :
232023 :
232024 : }
232025 :
232026 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232027 0 : }
232028 :
232029 :
232030 : /* #line 232031 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232031 :
232032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
232033 :
232034 : // Generated constructor
232035 0 : SgMembershipOp::SgMembershipOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
232036 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
232037 : {
232038 : #ifdef DEBUG
232039 : // printf ("In SgMembershipOp::SgMembershipOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
232040 : #endif
232041 : #if 0
232042 : // debugging information!
232043 : printf ("In SgMembershipOp::SgMembershipOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
232044 : #endif
232045 :
232046 :
232047 :
232048 : #if 0
232049 : // DQ (7/30/2014): Call a virtual function.
232050 : std::string s = this->class_name();
232051 : #endif
232052 :
232053 : // Test the variant virtual function
232054 : // assert(MEMBERSHIP_OP == variant());
232055 0 : assert(MEMBERSHIP_OP == this->variant());
232056 0 : ROSE_ASSERT(MEMBERSHIP_OP == (int)(this->variantT()));
232057 0 : post_construction_initialization();
232058 :
232059 : // Test the isSgMembershipOp() function since it has been problematic
232060 0 : assert(isSgMembershipOp(this) != NULL);
232061 0 : }
232062 :
232063 : // Generated constructor (all data members)
232064 :
232065 : /* #line 232066 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232066 :
232067 :
232068 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232069 :
232070 :
232071 : // ********************************************************
232072 : // member functions common across all array grammar objects
232073 : // ********************************************************
232074 :
232075 :
232076 :
232077 : /* #line 232078 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232078 :
232079 :
232080 :
232081 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232082 :
232083 : // ********************************************************
232084 : // member functions specific to each node in the grammar
232085 : // ********************************************************
232086 :
232087 :
232088 : /* #line 232089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232089 :
232090 : // Start of memberFunctionString
232091 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232092 :
232093 : void
232094 0 : SgSpaceshipOp::post_construction_initialization()
232095 : {
232096 0 : }
232097 :
232098 :
232099 :
232100 : // End of memberFunctionString
232101 : // Start of memberFunctionString
232102 : /* #line 4489 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232103 :
232104 :
232105 :
232106 : // End of memberFunctionString
232107 : // Start of memberFunctionString
232108 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
232109 :
232110 : // *** COMMON CODE SECTION BEGINS HERE ***
232111 :
232112 : #if 0
232113 : int
232114 : SgSpaceshipOp::getVariant() const
232115 : {
232116 : // This function is used in ROSE while "variant()" is used in SAGE
232117 : assert(this != NULL);
232118 : return variant();
232119 : }
232120 : #endif
232121 :
232122 : // This function is used in ROSE in treeTraversal code
232123 : // eventually replaces getVariant() and variant()
232124 : // though after variant() has been removed for a while we will
232125 : // want to change the name of variantT() back to variant()
232126 : // (since the "T" was ment to stand for temporary).
232127 : // When this happens the variantT() will be depricated.
232128 : VariantT
232129 0 : SgSpaceshipOp::variantT() const
232130 : {
232131 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
232132 0 : ROSE_ASSERT(this != NULL);
232133 0 : return V_SgSpaceshipOp;
232134 : }
232135 :
232136 : #if 0
232137 : int
232138 : SgSpaceshipOp::variant() const
232139 : {
232140 : // This function is used in SAGE
232141 : ROSE_ASSERT(this != NULL);
232142 : return SPACESHIP_OP;
232143 : }
232144 : #endif
232145 :
232146 : ROSE_DLL_API const char*
232147 0 : SgSpaceshipOp::sage_class_name() const
232148 : {
232149 0 : ROSE_ASSERT(this != NULL);
232150 0 : return "SgSpaceshipOp";
232151 : }
232152 :
232153 : std::string
232154 0 : SgSpaceshipOp::class_name() const
232155 : {
232156 0 : ROSE_ASSERT(this != NULL);
232157 0 : return "SgSpaceshipOp";
232158 : }
232159 :
232160 : // DQ (11/26/2005): Support for visitor pattern mechanims
232161 : // (inferior to ROSE traversal mechanism, experimental).
232162 : void
232163 0 : SgSpaceshipOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
232164 : {
232165 0 : ROSE_ASSERT(this != NULL);
232166 0 : visitor.visit(this);
232167 0 : }
232168 :
232169 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
232170 0 : void SgSpaceshipOp::accept (ROSE_VisitorPattern & visitor) {
232171 0 : ROSE_ASSERT(this != NULL);
232172 0 : visitor.visit(this);
232173 0 : }
232174 :
232175 : SgSpaceshipOp*
232176 0 : SgSpaceshipOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
232177 : {
232178 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
232179 : // This function is currently only supported for the AST used the represent Binary executables.
232180 : if (0 /* isSgAsmNode(this) != NULL */)
232181 : {
232182 : // Support for regex specification.
232183 : std::string prefixCode = "REGEX:";
232184 : addNewAttribute(prefixCode + s,a);
232185 : }
232186 : #endif
232187 :
232188 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
232189 0 : return this;
232190 : }
232191 :
232192 : // *** COMMON CODE SECTION ENDS HERE ***
232193 :
232194 :
232195 : // End of memberFunctionString
232196 : // Start of memberFunctionString
232197 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
232198 :
232199 :
232200 : #if 0
232201 : //! Error checking support
232202 : /*! Verifies the following:
232203 : - working getVariant() member function
232204 : - calls base class's error() member function
232205 : Every class has one of these functions.
232206 : */
232207 : bool
232208 : SgSpaceshipOp::error()
232209 : {
232210 : // Put error checking here
232211 :
232212 : ROSE_ASSERT (this != NULL);
232213 : if (getVariant() != SPACESHIP_OP)
232214 : {
232215 : printf ("Error in SgSpaceshipOp::error(): SgSpaceshipOp object has a %s variant \n",
232216 : Cxx_GrammarTerminalNames[getVariant()].name);
232217 : // printf ("Error in SgSpaceshipOp::error() \n");
232218 : ROSE_ABORT();
232219 : }
232220 :
232221 : ROSE_ASSERT (getVariant() == SPACESHIP_OP);
232222 : return SgBinaryOp::error();
232223 : }
232224 : #endif
232225 :
232226 :
232227 :
232228 : // End of memberFunctionString
232229 :
232230 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
232231 :
232232 0 : SgSpaceshipOp* isSgSpaceshipOp ( SgNode* inputDerivedClassPointer )
232233 : {
232234 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
232235 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
232236 : // So to fix this we return NULL directly when the input is NULL and avoid the
232237 : // dynamic_cast in this case. This is likely a performance improvement as well.
232238 : // return dynamic_cast<SgSpaceshipOp*>(inputDerivedClassPointer);
232239 : // Milind Chabbi (8/28/2013): isSgSpaceshipOp uses table-driven castability instead of c++ default dynamic_cast
232240 : // this improves the running time performance by 10-20%.
232241 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSpaceshipOp*>(inputDerivedClassPointer);
232242 0 : return IS_SgSpaceshipOp_FAST_MACRO(inputDerivedClassPointer);
232243 : }
232244 :
232245 : // DQ (11/8/2003): Added version of functions taking const pointer
232246 0 : const SgSpaceshipOp* isSgSpaceshipOp ( const SgNode* inputDerivedClassPointer )
232247 : {
232248 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
232249 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
232250 : // So to fix this we return NULL directly when the input is NULL and avoid the
232251 : // dynamic_cast in this case. This is likely a performance improvement as well.
232252 : // return dynamic_cast<const SgSpaceshipOp*>(inputDerivedClassPointer);
232253 : // Milind Chabbi (8/28/2013): isSgSpaceshipOp uses table-driven castability instead of c++ default dynamic_cast
232254 : // this improves the running time performance by 10-20%.
232255 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSpaceshipOp*>(inputDerivedClassPointer);
232256 0 : return IS_SgSpaceshipOp_FAST_MACRO(inputDerivedClassPointer);
232257 : }
232258 :
232259 :
232260 :
232261 : /* #line 232262 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232262 :
232263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232264 :
232265 : /**
232266 : \brief Generated destructor
232267 :
232268 : This destructor is automatically generated (by ROSETTA). This destructor
232269 : only frees memory of data members associated with the parts of the current IR node which
232270 : are NOT traversed. Those data members that are part of a traversal can be freed using
232271 : a traversal (calling this destructor on all children in a post-order traversal). Such
232272 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
232273 :
232274 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
232275 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
232276 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
232277 :
232278 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
232279 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
232280 : pointers are not yet implemented to call delete on eash pointer in the container.
232281 : (This could be done by derivation from the STL containers to define containers that
232282 : automatically deleted their members.)
232283 :
232284 : */
232285 0 : SgSpaceshipOp::~SgSpaceshipOp () {
232286 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
232287 :
232288 :
232289 :
232290 : }
232291 :
232292 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232293 0 : }
232294 :
232295 :
232296 : /* #line 232297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232297 :
232298 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
232299 :
232300 : // Generated constructor
232301 0 : SgSpaceshipOp::SgSpaceshipOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
232302 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
232303 : {
232304 : #ifdef DEBUG
232305 : // printf ("In SgSpaceshipOp::SgSpaceshipOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
232306 : #endif
232307 : #if 0
232308 : // debugging information!
232309 : printf ("In SgSpaceshipOp::SgSpaceshipOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
232310 : #endif
232311 :
232312 :
232313 :
232314 : #if 0
232315 : // DQ (7/30/2014): Call a virtual function.
232316 : std::string s = this->class_name();
232317 : #endif
232318 :
232319 : // Test the variant virtual function
232320 : // assert(SPACESHIP_OP == variant());
232321 0 : assert(SPACESHIP_OP == this->variant());
232322 0 : ROSE_ASSERT(SPACESHIP_OP == (int)(this->variantT()));
232323 0 : post_construction_initialization();
232324 :
232325 : // Test the isSgSpaceshipOp() function since it has been problematic
232326 0 : assert(isSgSpaceshipOp(this) != NULL);
232327 0 : }
232328 :
232329 : // Generated constructor (all data members)
232330 :
232331 : /* #line 232332 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232332 :
232333 :
232334 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232335 :
232336 :
232337 : // ********************************************************
232338 : // member functions common across all array grammar objects
232339 : // ********************************************************
232340 :
232341 :
232342 :
232343 : /* #line 232344 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232344 :
232345 :
232346 :
232347 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232348 :
232349 : // ********************************************************
232350 : // member functions specific to each node in the grammar
232351 : // ********************************************************
232352 :
232353 :
232354 : /* #line 232355 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232355 :
232356 : // Start of memberFunctionString
232357 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232358 :
232359 : void
232360 0 : SgNonMembershipOp::post_construction_initialization()
232361 : {
232362 0 : }
232363 :
232364 :
232365 :
232366 : // End of memberFunctionString
232367 : // Start of memberFunctionString
232368 : /* #line 5114 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232369 :
232370 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232371 :
232372 :
232373 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
232374 : SgType*
232375 0 : SgNonMembershipOp::get_type() const
232376 : {
232377 : #if 0
232378 : printf ("In SgNonMembershipOp::get_type() \n");
232379 : #endif
232380 :
232381 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
232382 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
232383 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
232384 0 : SgType* returnType = (SageInterface::is_C_language() == true) ?
232385 0 : static_cast<SgType*>(SgTypeInt::createType()) :
232386 0 : static_cast<SgType*>(SgTypeBool::createType());
232387 0 : ROSE_ASSERT(returnType != NULL);
232388 0 : return returnType;
232389 : }
232390 :
232391 :
232392 :
232393 :
232394 : // End of memberFunctionString
232395 : // Start of memberFunctionString
232396 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
232397 :
232398 : // *** COMMON CODE SECTION BEGINS HERE ***
232399 :
232400 : #if 0
232401 : int
232402 : SgNonMembershipOp::getVariant() const
232403 : {
232404 : // This function is used in ROSE while "variant()" is used in SAGE
232405 : assert(this != NULL);
232406 : return variant();
232407 : }
232408 : #endif
232409 :
232410 : // This function is used in ROSE in treeTraversal code
232411 : // eventually replaces getVariant() and variant()
232412 : // though after variant() has been removed for a while we will
232413 : // want to change the name of variantT() back to variant()
232414 : // (since the "T" was ment to stand for temporary).
232415 : // When this happens the variantT() will be depricated.
232416 : VariantT
232417 0 : SgNonMembershipOp::variantT() const
232418 : {
232419 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
232420 0 : ROSE_ASSERT(this != NULL);
232421 0 : return V_SgNonMembershipOp;
232422 : }
232423 :
232424 : #if 0
232425 : int
232426 : SgNonMembershipOp::variant() const
232427 : {
232428 : // This function is used in SAGE
232429 : ROSE_ASSERT(this != NULL);
232430 : return NON_MEMBERSHIP_OP;
232431 : }
232432 : #endif
232433 :
232434 : ROSE_DLL_API const char*
232435 0 : SgNonMembershipOp::sage_class_name() const
232436 : {
232437 0 : ROSE_ASSERT(this != NULL);
232438 0 : return "SgNonMembershipOp";
232439 : }
232440 :
232441 : std::string
232442 0 : SgNonMembershipOp::class_name() const
232443 : {
232444 0 : ROSE_ASSERT(this != NULL);
232445 0 : return "SgNonMembershipOp";
232446 : }
232447 :
232448 : // DQ (11/26/2005): Support for visitor pattern mechanims
232449 : // (inferior to ROSE traversal mechanism, experimental).
232450 : void
232451 0 : SgNonMembershipOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
232452 : {
232453 0 : ROSE_ASSERT(this != NULL);
232454 0 : visitor.visit(this);
232455 0 : }
232456 :
232457 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
232458 0 : void SgNonMembershipOp::accept (ROSE_VisitorPattern & visitor) {
232459 0 : ROSE_ASSERT(this != NULL);
232460 0 : visitor.visit(this);
232461 0 : }
232462 :
232463 : SgNonMembershipOp*
232464 0 : SgNonMembershipOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
232465 : {
232466 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
232467 : // This function is currently only supported for the AST used the represent Binary executables.
232468 : if (0 /* isSgAsmNode(this) != NULL */)
232469 : {
232470 : // Support for regex specification.
232471 : std::string prefixCode = "REGEX:";
232472 : addNewAttribute(prefixCode + s,a);
232473 : }
232474 : #endif
232475 :
232476 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
232477 0 : return this;
232478 : }
232479 :
232480 : // *** COMMON CODE SECTION ENDS HERE ***
232481 :
232482 :
232483 : // End of memberFunctionString
232484 : // Start of memberFunctionString
232485 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
232486 :
232487 :
232488 : #if 0
232489 : //! Error checking support
232490 : /*! Verifies the following:
232491 : - working getVariant() member function
232492 : - calls base class's error() member function
232493 : Every class has one of these functions.
232494 : */
232495 : bool
232496 : SgNonMembershipOp::error()
232497 : {
232498 : // Put error checking here
232499 :
232500 : ROSE_ASSERT (this != NULL);
232501 : if (getVariant() != NON_MEMBERSHIP_OP)
232502 : {
232503 : printf ("Error in SgNonMembershipOp::error(): SgNonMembershipOp object has a %s variant \n",
232504 : Cxx_GrammarTerminalNames[getVariant()].name);
232505 : // printf ("Error in SgNonMembershipOp::error() \n");
232506 : ROSE_ABORT();
232507 : }
232508 :
232509 : ROSE_ASSERT (getVariant() == NON_MEMBERSHIP_OP);
232510 : return SgBinaryOp::error();
232511 : }
232512 : #endif
232513 :
232514 :
232515 :
232516 : // End of memberFunctionString
232517 :
232518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
232519 :
232520 0 : SgNonMembershipOp* isSgNonMembershipOp ( SgNode* inputDerivedClassPointer )
232521 : {
232522 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
232523 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
232524 : // So to fix this we return NULL directly when the input is NULL and avoid the
232525 : // dynamic_cast in this case. This is likely a performance improvement as well.
232526 : // return dynamic_cast<SgNonMembershipOp*>(inputDerivedClassPointer);
232527 : // Milind Chabbi (8/28/2013): isSgNonMembershipOp uses table-driven castability instead of c++ default dynamic_cast
232528 : // this improves the running time performance by 10-20%.
232529 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNonMembershipOp*>(inputDerivedClassPointer);
232530 0 : return IS_SgNonMembershipOp_FAST_MACRO(inputDerivedClassPointer);
232531 : }
232532 :
232533 : // DQ (11/8/2003): Added version of functions taking const pointer
232534 0 : const SgNonMembershipOp* isSgNonMembershipOp ( const SgNode* inputDerivedClassPointer )
232535 : {
232536 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
232537 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
232538 : // So to fix this we return NULL directly when the input is NULL and avoid the
232539 : // dynamic_cast in this case. This is likely a performance improvement as well.
232540 : // return dynamic_cast<const SgNonMembershipOp*>(inputDerivedClassPointer);
232541 : // Milind Chabbi (8/28/2013): isSgNonMembershipOp uses table-driven castability instead of c++ default dynamic_cast
232542 : // this improves the running time performance by 10-20%.
232543 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNonMembershipOp*>(inputDerivedClassPointer);
232544 0 : return IS_SgNonMembershipOp_FAST_MACRO(inputDerivedClassPointer);
232545 : }
232546 :
232547 :
232548 :
232549 : /* #line 232550 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232550 :
232551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232552 :
232553 : /**
232554 : \brief Generated destructor
232555 :
232556 : This destructor is automatically generated (by ROSETTA). This destructor
232557 : only frees memory of data members associated with the parts of the current IR node which
232558 : are NOT traversed. Those data members that are part of a traversal can be freed using
232559 : a traversal (calling this destructor on all children in a post-order traversal). Such
232560 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
232561 :
232562 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
232563 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
232564 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
232565 :
232566 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
232567 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
232568 : pointers are not yet implemented to call delete on eash pointer in the container.
232569 : (This could be done by derivation from the STL containers to define containers that
232570 : automatically deleted their members.)
232571 :
232572 : */
232573 0 : SgNonMembershipOp::~SgNonMembershipOp () {
232574 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
232575 :
232576 :
232577 :
232578 : }
232579 :
232580 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232581 0 : }
232582 :
232583 :
232584 : /* #line 232585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232585 :
232586 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
232587 :
232588 : // Generated constructor
232589 0 : SgNonMembershipOp::SgNonMembershipOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
232590 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
232591 : {
232592 : #ifdef DEBUG
232593 : // printf ("In SgNonMembershipOp::SgNonMembershipOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
232594 : #endif
232595 : #if 0
232596 : // debugging information!
232597 : printf ("In SgNonMembershipOp::SgNonMembershipOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
232598 : #endif
232599 :
232600 :
232601 :
232602 : #if 0
232603 : // DQ (7/30/2014): Call a virtual function.
232604 : std::string s = this->class_name();
232605 : #endif
232606 :
232607 : // Test the variant virtual function
232608 : // assert(NON_MEMBERSHIP_OP == variant());
232609 0 : assert(NON_MEMBERSHIP_OP == this->variant());
232610 0 : ROSE_ASSERT(NON_MEMBERSHIP_OP == (int)(this->variantT()));
232611 0 : post_construction_initialization();
232612 :
232613 : // Test the isSgNonMembershipOp() function since it has been problematic
232614 0 : assert(isSgNonMembershipOp(this) != NULL);
232615 0 : }
232616 :
232617 : // Generated constructor (all data members)
232618 :
232619 : /* #line 232620 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232620 :
232621 :
232622 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232623 :
232624 :
232625 : // ********************************************************
232626 : // member functions common across all array grammar objects
232627 : // ********************************************************
232628 :
232629 :
232630 :
232631 : /* #line 232632 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232632 :
232633 :
232634 :
232635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232636 :
232637 : // ********************************************************
232638 : // member functions specific to each node in the grammar
232639 : // ********************************************************
232640 :
232641 :
232642 : /* #line 232643 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232643 :
232644 : // Start of memberFunctionString
232645 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232646 :
232647 : void
232648 0 : SgIsOp::post_construction_initialization()
232649 : {
232650 0 : }
232651 :
232652 :
232653 :
232654 : // End of memberFunctionString
232655 : // Start of memberFunctionString
232656 : /* #line 5118 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232657 :
232658 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232659 :
232660 :
232661 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
232662 : SgType*
232663 0 : SgIsOp::get_type() const
232664 : {
232665 : #if 0
232666 : printf ("In SgIsOp::get_type() \n");
232667 : #endif
232668 :
232669 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
232670 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
232671 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
232672 0 : SgType* returnType = (SageInterface::is_C_language() == true) ?
232673 0 : static_cast<SgType*>(SgTypeInt::createType()) :
232674 0 : static_cast<SgType*>(SgTypeBool::createType());
232675 0 : ROSE_ASSERT(returnType != NULL);
232676 0 : return returnType;
232677 : }
232678 :
232679 :
232680 :
232681 :
232682 : // End of memberFunctionString
232683 : // Start of memberFunctionString
232684 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
232685 :
232686 : // *** COMMON CODE SECTION BEGINS HERE ***
232687 :
232688 : #if 0
232689 : int
232690 : SgIsOp::getVariant() const
232691 : {
232692 : // This function is used in ROSE while "variant()" is used in SAGE
232693 : assert(this != NULL);
232694 : return variant();
232695 : }
232696 : #endif
232697 :
232698 : // This function is used in ROSE in treeTraversal code
232699 : // eventually replaces getVariant() and variant()
232700 : // though after variant() has been removed for a while we will
232701 : // want to change the name of variantT() back to variant()
232702 : // (since the "T" was ment to stand for temporary).
232703 : // When this happens the variantT() will be depricated.
232704 : VariantT
232705 0 : SgIsOp::variantT() const
232706 : {
232707 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
232708 0 : ROSE_ASSERT(this != NULL);
232709 0 : return V_SgIsOp;
232710 : }
232711 :
232712 : #if 0
232713 : int
232714 : SgIsOp::variant() const
232715 : {
232716 : // This function is used in SAGE
232717 : ROSE_ASSERT(this != NULL);
232718 : return IS_OP;
232719 : }
232720 : #endif
232721 :
232722 : ROSE_DLL_API const char*
232723 0 : SgIsOp::sage_class_name() const
232724 : {
232725 0 : ROSE_ASSERT(this != NULL);
232726 0 : return "SgIsOp";
232727 : }
232728 :
232729 : std::string
232730 0 : SgIsOp::class_name() const
232731 : {
232732 0 : ROSE_ASSERT(this != NULL);
232733 0 : return "SgIsOp";
232734 : }
232735 :
232736 : // DQ (11/26/2005): Support for visitor pattern mechanims
232737 : // (inferior to ROSE traversal mechanism, experimental).
232738 : void
232739 0 : SgIsOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
232740 : {
232741 0 : ROSE_ASSERT(this != NULL);
232742 0 : visitor.visit(this);
232743 0 : }
232744 :
232745 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
232746 0 : void SgIsOp::accept (ROSE_VisitorPattern & visitor) {
232747 0 : ROSE_ASSERT(this != NULL);
232748 0 : visitor.visit(this);
232749 0 : }
232750 :
232751 : SgIsOp*
232752 0 : SgIsOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
232753 : {
232754 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
232755 : // This function is currently only supported for the AST used the represent Binary executables.
232756 : if (0 /* isSgAsmNode(this) != NULL */)
232757 : {
232758 : // Support for regex specification.
232759 : std::string prefixCode = "REGEX:";
232760 : addNewAttribute(prefixCode + s,a);
232761 : }
232762 : #endif
232763 :
232764 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
232765 0 : return this;
232766 : }
232767 :
232768 : // *** COMMON CODE SECTION ENDS HERE ***
232769 :
232770 :
232771 : // End of memberFunctionString
232772 : // Start of memberFunctionString
232773 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
232774 :
232775 :
232776 : #if 0
232777 : //! Error checking support
232778 : /*! Verifies the following:
232779 : - working getVariant() member function
232780 : - calls base class's error() member function
232781 : Every class has one of these functions.
232782 : */
232783 : bool
232784 : SgIsOp::error()
232785 : {
232786 : // Put error checking here
232787 :
232788 : ROSE_ASSERT (this != NULL);
232789 : if (getVariant() != IS_OP)
232790 : {
232791 : printf ("Error in SgIsOp::error(): SgIsOp object has a %s variant \n",
232792 : Cxx_GrammarTerminalNames[getVariant()].name);
232793 : // printf ("Error in SgIsOp::error() \n");
232794 : ROSE_ABORT();
232795 : }
232796 :
232797 : ROSE_ASSERT (getVariant() == IS_OP);
232798 : return SgBinaryOp::error();
232799 : }
232800 : #endif
232801 :
232802 :
232803 :
232804 : // End of memberFunctionString
232805 :
232806 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
232807 :
232808 0 : SgIsOp* isSgIsOp ( SgNode* inputDerivedClassPointer )
232809 : {
232810 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
232811 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
232812 : // So to fix this we return NULL directly when the input is NULL and avoid the
232813 : // dynamic_cast in this case. This is likely a performance improvement as well.
232814 : // return dynamic_cast<SgIsOp*>(inputDerivedClassPointer);
232815 : // Milind Chabbi (8/28/2013): isSgIsOp uses table-driven castability instead of c++ default dynamic_cast
232816 : // this improves the running time performance by 10-20%.
232817 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIsOp*>(inputDerivedClassPointer);
232818 0 : return IS_SgIsOp_FAST_MACRO(inputDerivedClassPointer);
232819 : }
232820 :
232821 : // DQ (11/8/2003): Added version of functions taking const pointer
232822 0 : const SgIsOp* isSgIsOp ( const SgNode* inputDerivedClassPointer )
232823 : {
232824 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
232825 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
232826 : // So to fix this we return NULL directly when the input is NULL and avoid the
232827 : // dynamic_cast in this case. This is likely a performance improvement as well.
232828 : // return dynamic_cast<const SgIsOp*>(inputDerivedClassPointer);
232829 : // Milind Chabbi (8/28/2013): isSgIsOp uses table-driven castability instead of c++ default dynamic_cast
232830 : // this improves the running time performance by 10-20%.
232831 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIsOp*>(inputDerivedClassPointer);
232832 0 : return IS_SgIsOp_FAST_MACRO(inputDerivedClassPointer);
232833 : }
232834 :
232835 :
232836 :
232837 : /* #line 232838 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232838 :
232839 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232840 :
232841 : /**
232842 : \brief Generated destructor
232843 :
232844 : This destructor is automatically generated (by ROSETTA). This destructor
232845 : only frees memory of data members associated with the parts of the current IR node which
232846 : are NOT traversed. Those data members that are part of a traversal can be freed using
232847 : a traversal (calling this destructor on all children in a post-order traversal). Such
232848 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
232849 :
232850 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
232851 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
232852 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
232853 :
232854 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
232855 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
232856 : pointers are not yet implemented to call delete on eash pointer in the container.
232857 : (This could be done by derivation from the STL containers to define containers that
232858 : automatically deleted their members.)
232859 :
232860 : */
232861 0 : SgIsOp::~SgIsOp () {
232862 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
232863 :
232864 :
232865 :
232866 : }
232867 :
232868 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
232869 0 : }
232870 :
232871 :
232872 : /* #line 232873 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232873 :
232874 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
232875 :
232876 : // Generated constructor
232877 0 : SgIsOp::SgIsOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
232878 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
232879 : {
232880 : #ifdef DEBUG
232881 : // printf ("In SgIsOp::SgIsOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
232882 : #endif
232883 : #if 0
232884 : // debugging information!
232885 : printf ("In SgIsOp::SgIsOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
232886 : #endif
232887 :
232888 :
232889 :
232890 : #if 0
232891 : // DQ (7/30/2014): Call a virtual function.
232892 : std::string s = this->class_name();
232893 : #endif
232894 :
232895 : // Test the variant virtual function
232896 : // assert(IS_OP == variant());
232897 0 : assert(IS_OP == this->variant());
232898 0 : ROSE_ASSERT(IS_OP == (int)(this->variantT()));
232899 0 : post_construction_initialization();
232900 :
232901 : // Test the isSgIsOp() function since it has been problematic
232902 0 : assert(isSgIsOp(this) != NULL);
232903 0 : }
232904 :
232905 : // Generated constructor (all data members)
232906 :
232907 : /* #line 232908 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232908 :
232909 :
232910 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232911 :
232912 :
232913 : // ********************************************************
232914 : // member functions common across all array grammar objects
232915 : // ********************************************************
232916 :
232917 :
232918 :
232919 : /* #line 232920 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232920 :
232921 :
232922 :
232923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
232924 :
232925 : // ********************************************************
232926 : // member functions specific to each node in the grammar
232927 : // ********************************************************
232928 :
232929 :
232930 : /* #line 232931 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
232931 :
232932 : // Start of memberFunctionString
232933 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232934 :
232935 : void
232936 0 : SgIsNotOp::post_construction_initialization()
232937 : {
232938 0 : }
232939 :
232940 :
232941 :
232942 : // End of memberFunctionString
232943 : // Start of memberFunctionString
232944 : /* #line 5122 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232945 :
232946 : /* #line 5034 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
232947 :
232948 :
232949 : // DQ (6/20/2006): Used for all relational operators: ==, !=, <, >, <=, >=, !
232950 : SgType*
232951 0 : SgIsNotOp::get_type() const
232952 : {
232953 : #if 0
232954 : printf ("In SgIsNotOp::get_type() \n");
232955 : #endif
232956 :
232957 : // DQ (8/27/2006): We can get this result more quickly without searching the AST backward to the root and
232958 : // if we do so it will be more consistant with what we have to do for the SgTypeBool which similarly must
232959 : // be unparsed differently for C99 and C++ (gnu gcc also accepts "_Bool" as a type).
232960 0 : SgType* returnType = (SageInterface::is_C_language() == true) ?
232961 0 : static_cast<SgType*>(SgTypeInt::createType()) :
232962 0 : static_cast<SgType*>(SgTypeBool::createType());
232963 0 : ROSE_ASSERT(returnType != NULL);
232964 0 : return returnType;
232965 : }
232966 :
232967 :
232968 :
232969 :
232970 : // End of memberFunctionString
232971 : // Start of memberFunctionString
232972 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
232973 :
232974 : // *** COMMON CODE SECTION BEGINS HERE ***
232975 :
232976 : #if 0
232977 : int
232978 : SgIsNotOp::getVariant() const
232979 : {
232980 : // This function is used in ROSE while "variant()" is used in SAGE
232981 : assert(this != NULL);
232982 : return variant();
232983 : }
232984 : #endif
232985 :
232986 : // This function is used in ROSE in treeTraversal code
232987 : // eventually replaces getVariant() and variant()
232988 : // though after variant() has been removed for a while we will
232989 : // want to change the name of variantT() back to variant()
232990 : // (since the "T" was ment to stand for temporary).
232991 : // When this happens the variantT() will be depricated.
232992 : VariantT
232993 0 : SgIsNotOp::variantT() const
232994 : {
232995 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
232996 0 : ROSE_ASSERT(this != NULL);
232997 0 : return V_SgIsNotOp;
232998 : }
232999 :
233000 : #if 0
233001 : int
233002 : SgIsNotOp::variant() const
233003 : {
233004 : // This function is used in SAGE
233005 : ROSE_ASSERT(this != NULL);
233006 : return IS_NOT_OP;
233007 : }
233008 : #endif
233009 :
233010 : ROSE_DLL_API const char*
233011 0 : SgIsNotOp::sage_class_name() const
233012 : {
233013 0 : ROSE_ASSERT(this != NULL);
233014 0 : return "SgIsNotOp";
233015 : }
233016 :
233017 : std::string
233018 0 : SgIsNotOp::class_name() const
233019 : {
233020 0 : ROSE_ASSERT(this != NULL);
233021 0 : return "SgIsNotOp";
233022 : }
233023 :
233024 : // DQ (11/26/2005): Support for visitor pattern mechanims
233025 : // (inferior to ROSE traversal mechanism, experimental).
233026 : void
233027 0 : SgIsNotOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
233028 : {
233029 0 : ROSE_ASSERT(this != NULL);
233030 0 : visitor.visit(this);
233031 0 : }
233032 :
233033 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
233034 0 : void SgIsNotOp::accept (ROSE_VisitorPattern & visitor) {
233035 0 : ROSE_ASSERT(this != NULL);
233036 0 : visitor.visit(this);
233037 0 : }
233038 :
233039 : SgIsNotOp*
233040 0 : SgIsNotOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
233041 : {
233042 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
233043 : // This function is currently only supported for the AST used the represent Binary executables.
233044 : if (0 /* isSgAsmNode(this) != NULL */)
233045 : {
233046 : // Support for regex specification.
233047 : std::string prefixCode = "REGEX:";
233048 : addNewAttribute(prefixCode + s,a);
233049 : }
233050 : #endif
233051 :
233052 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
233053 0 : return this;
233054 : }
233055 :
233056 : // *** COMMON CODE SECTION ENDS HERE ***
233057 :
233058 :
233059 : // End of memberFunctionString
233060 : // Start of memberFunctionString
233061 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
233062 :
233063 :
233064 : #if 0
233065 : //! Error checking support
233066 : /*! Verifies the following:
233067 : - working getVariant() member function
233068 : - calls base class's error() member function
233069 : Every class has one of these functions.
233070 : */
233071 : bool
233072 : SgIsNotOp::error()
233073 : {
233074 : // Put error checking here
233075 :
233076 : ROSE_ASSERT (this != NULL);
233077 : if (getVariant() != IS_NOT_OP)
233078 : {
233079 : printf ("Error in SgIsNotOp::error(): SgIsNotOp object has a %s variant \n",
233080 : Cxx_GrammarTerminalNames[getVariant()].name);
233081 : // printf ("Error in SgIsNotOp::error() \n");
233082 : ROSE_ABORT();
233083 : }
233084 :
233085 : ROSE_ASSERT (getVariant() == IS_NOT_OP);
233086 : return SgBinaryOp::error();
233087 : }
233088 : #endif
233089 :
233090 :
233091 :
233092 : // End of memberFunctionString
233093 :
233094 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
233095 :
233096 0 : SgIsNotOp* isSgIsNotOp ( SgNode* inputDerivedClassPointer )
233097 : {
233098 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233099 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233100 : // So to fix this we return NULL directly when the input is NULL and avoid the
233101 : // dynamic_cast in this case. This is likely a performance improvement as well.
233102 : // return dynamic_cast<SgIsNotOp*>(inputDerivedClassPointer);
233103 : // Milind Chabbi (8/28/2013): isSgIsNotOp uses table-driven castability instead of c++ default dynamic_cast
233104 : // this improves the running time performance by 10-20%.
233105 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIsNotOp*>(inputDerivedClassPointer);
233106 0 : return IS_SgIsNotOp_FAST_MACRO(inputDerivedClassPointer);
233107 : }
233108 :
233109 : // DQ (11/8/2003): Added version of functions taking const pointer
233110 0 : const SgIsNotOp* isSgIsNotOp ( const SgNode* inputDerivedClassPointer )
233111 : {
233112 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233113 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233114 : // So to fix this we return NULL directly when the input is NULL and avoid the
233115 : // dynamic_cast in this case. This is likely a performance improvement as well.
233116 : // return dynamic_cast<const SgIsNotOp*>(inputDerivedClassPointer);
233117 : // Milind Chabbi (8/28/2013): isSgIsNotOp uses table-driven castability instead of c++ default dynamic_cast
233118 : // this improves the running time performance by 10-20%.
233119 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIsNotOp*>(inputDerivedClassPointer);
233120 0 : return IS_SgIsNotOp_FAST_MACRO(inputDerivedClassPointer);
233121 : }
233122 :
233123 :
233124 :
233125 : /* #line 233126 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233126 :
233127 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233128 :
233129 : /**
233130 : \brief Generated destructor
233131 :
233132 : This destructor is automatically generated (by ROSETTA). This destructor
233133 : only frees memory of data members associated with the parts of the current IR node which
233134 : are NOT traversed. Those data members that are part of a traversal can be freed using
233135 : a traversal (calling this destructor on all children in a post-order traversal). Such
233136 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
233137 :
233138 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
233139 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
233140 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
233141 :
233142 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
233143 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
233144 : pointers are not yet implemented to call delete on eash pointer in the container.
233145 : (This could be done by derivation from the STL containers to define containers that
233146 : automatically deleted their members.)
233147 :
233148 : */
233149 0 : SgIsNotOp::~SgIsNotOp () {
233150 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
233151 :
233152 :
233153 :
233154 : }
233155 :
233156 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233157 0 : }
233158 :
233159 :
233160 : /* #line 233161 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233161 :
233162 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
233163 :
233164 : // Generated constructor
233165 0 : SgIsNotOp::SgIsNotOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
233166 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
233167 : {
233168 : #ifdef DEBUG
233169 : // printf ("In SgIsNotOp::SgIsNotOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
233170 : #endif
233171 : #if 0
233172 : // debugging information!
233173 : printf ("In SgIsNotOp::SgIsNotOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
233174 : #endif
233175 :
233176 :
233177 :
233178 : #if 0
233179 : // DQ (7/30/2014): Call a virtual function.
233180 : std::string s = this->class_name();
233181 : #endif
233182 :
233183 : // Test the variant virtual function
233184 : // assert(IS_NOT_OP == variant());
233185 0 : assert(IS_NOT_OP == this->variant());
233186 0 : ROSE_ASSERT(IS_NOT_OP == (int)(this->variantT()));
233187 0 : post_construction_initialization();
233188 :
233189 : // Test the isSgIsNotOp() function since it has been problematic
233190 0 : assert(isSgIsNotOp(this) != NULL);
233191 0 : }
233192 :
233193 : // Generated constructor (all data members)
233194 :
233195 : /* #line 233196 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233196 :
233197 :
233198 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233199 :
233200 :
233201 : // ********************************************************
233202 : // member functions common across all array grammar objects
233203 : // ********************************************************
233204 :
233205 :
233206 :
233207 : /* #line 233208 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233208 :
233209 :
233210 :
233211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233212 :
233213 : // ********************************************************
233214 : // member functions specific to each node in the grammar
233215 : // ********************************************************
233216 :
233217 :
233218 : /* #line 233219 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233219 :
233220 : // Start of memberFunctionString
233221 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
233222 :
233223 : void
233224 0 : SgElementwiseOp::post_construction_initialization()
233225 : {
233226 0 : }
233227 :
233228 :
233229 :
233230 : // End of memberFunctionString
233231 : // Start of memberFunctionString
233232 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
233233 :
233234 : // *** COMMON CODE SECTION BEGINS HERE ***
233235 :
233236 : #if 0
233237 : int
233238 : SgElementwiseOp::getVariant() const
233239 : {
233240 : // This function is used in ROSE while "variant()" is used in SAGE
233241 : assert(this != NULL);
233242 : return variant();
233243 : }
233244 : #endif
233245 :
233246 : // This function is used in ROSE in treeTraversal code
233247 : // eventually replaces getVariant() and variant()
233248 : // though after variant() has been removed for a while we will
233249 : // want to change the name of variantT() back to variant()
233250 : // (since the "T" was ment to stand for temporary).
233251 : // When this happens the variantT() will be depricated.
233252 : VariantT
233253 0 : SgElementwiseOp::variantT() const
233254 : {
233255 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
233256 0 : ROSE_ASSERT(this != NULL);
233257 0 : return V_SgElementwiseOp;
233258 : }
233259 :
233260 : #if 0
233261 : int
233262 : SgElementwiseOp::variant() const
233263 : {
233264 : // This function is used in SAGE
233265 : ROSE_ASSERT(this != NULL);
233266 : return ELEMENT_WISE_OP;
233267 : }
233268 : #endif
233269 :
233270 : ROSE_DLL_API const char*
233271 0 : SgElementwiseOp::sage_class_name() const
233272 : {
233273 0 : ROSE_ASSERT(this != NULL);
233274 0 : return "SgElementwiseOp";
233275 : }
233276 :
233277 : std::string
233278 0 : SgElementwiseOp::class_name() const
233279 : {
233280 0 : ROSE_ASSERT(this != NULL);
233281 0 : return "SgElementwiseOp";
233282 : }
233283 :
233284 : // DQ (11/26/2005): Support for visitor pattern mechanims
233285 : // (inferior to ROSE traversal mechanism, experimental).
233286 : void
233287 0 : SgElementwiseOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
233288 : {
233289 0 : ROSE_ASSERT(this != NULL);
233290 0 : visitor.visit(this);
233291 0 : }
233292 :
233293 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
233294 0 : void SgElementwiseOp::accept (ROSE_VisitorPattern & visitor) {
233295 0 : ROSE_ASSERT(this != NULL);
233296 0 : visitor.visit(this);
233297 0 : }
233298 :
233299 : SgElementwiseOp*
233300 0 : SgElementwiseOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
233301 : {
233302 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
233303 : // This function is currently only supported for the AST used the represent Binary executables.
233304 : if (0 /* isSgAsmNode(this) != NULL */)
233305 : {
233306 : // Support for regex specification.
233307 : std::string prefixCode = "REGEX:";
233308 : addNewAttribute(prefixCode + s,a);
233309 : }
233310 : #endif
233311 :
233312 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
233313 0 : return this;
233314 : }
233315 :
233316 : // *** COMMON CODE SECTION ENDS HERE ***
233317 :
233318 :
233319 : // End of memberFunctionString
233320 : // Start of memberFunctionString
233321 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
233322 :
233323 :
233324 : #if 0
233325 : //! Error checking support
233326 : /*! Verifies the following:
233327 : - working getVariant() member function
233328 : - calls base class's error() member function
233329 : Every class has one of these functions.
233330 : */
233331 : bool
233332 : SgElementwiseOp::error()
233333 : {
233334 : // Put error checking here
233335 :
233336 : ROSE_ASSERT (this != NULL);
233337 : if (getVariant() != ELEMENT_WISE_OP)
233338 : {
233339 : printf ("Error in SgElementwiseOp::error(): SgElementwiseOp object has a %s variant \n",
233340 : Cxx_GrammarTerminalNames[getVariant()].name);
233341 : // printf ("Error in SgElementwiseOp::error() \n");
233342 : ROSE_ABORT();
233343 : }
233344 :
233345 : ROSE_ASSERT (getVariant() == ELEMENT_WISE_OP);
233346 : return SgBinaryOp::error();
233347 : }
233348 : #endif
233349 :
233350 :
233351 :
233352 : // End of memberFunctionString
233353 :
233354 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
233355 :
233356 0 : SgElementwiseOp* isSgElementwiseOp ( SgNode* inputDerivedClassPointer )
233357 : {
233358 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233359 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233360 : // So to fix this we return NULL directly when the input is NULL and avoid the
233361 : // dynamic_cast in this case. This is likely a performance improvement as well.
233362 : // return dynamic_cast<SgElementwiseOp*>(inputDerivedClassPointer);
233363 : // Milind Chabbi (8/28/2013): isSgElementwiseOp uses table-driven castability instead of c++ default dynamic_cast
233364 : // this improves the running time performance by 10-20%.
233365 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwiseOp*>(inputDerivedClassPointer);
233366 0 : return IS_SgElementwiseOp_FAST_MACRO(inputDerivedClassPointer);
233367 : }
233368 :
233369 : // DQ (11/8/2003): Added version of functions taking const pointer
233370 0 : const SgElementwiseOp* isSgElementwiseOp ( const SgNode* inputDerivedClassPointer )
233371 : {
233372 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233373 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233374 : // So to fix this we return NULL directly when the input is NULL and avoid the
233375 : // dynamic_cast in this case. This is likely a performance improvement as well.
233376 : // return dynamic_cast<const SgElementwiseOp*>(inputDerivedClassPointer);
233377 : // Milind Chabbi (8/28/2013): isSgElementwiseOp uses table-driven castability instead of c++ default dynamic_cast
233378 : // this improves the running time performance by 10-20%.
233379 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwiseOp*>(inputDerivedClassPointer);
233380 0 : return IS_SgElementwiseOp_FAST_MACRO(inputDerivedClassPointer);
233381 : }
233382 :
233383 :
233384 :
233385 : /* #line 233386 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233386 :
233387 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233388 :
233389 : /**
233390 : \brief Generated destructor
233391 :
233392 : This destructor is automatically generated (by ROSETTA). This destructor
233393 : only frees memory of data members associated with the parts of the current IR node which
233394 : are NOT traversed. Those data members that are part of a traversal can be freed using
233395 : a traversal (calling this destructor on all children in a post-order traversal). Such
233396 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
233397 :
233398 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
233399 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
233400 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
233401 :
233402 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
233403 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
233404 : pointers are not yet implemented to call delete on eash pointer in the container.
233405 : (This could be done by derivation from the STL containers to define containers that
233406 : automatically deleted their members.)
233407 :
233408 : */
233409 0 : SgElementwiseOp::~SgElementwiseOp () {
233410 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
233411 :
233412 :
233413 :
233414 : }
233415 :
233416 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233417 0 : }
233418 :
233419 :
233420 : /* #line 233421 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233421 :
233422 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
233423 :
233424 : // Generated constructor
233425 0 : SgElementwiseOp::SgElementwiseOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
233426 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
233427 : {
233428 : #ifdef DEBUG
233429 : // printf ("In SgElementwiseOp::SgElementwiseOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
233430 : #endif
233431 : #if 0
233432 : // debugging information!
233433 : printf ("In SgElementwiseOp::SgElementwiseOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
233434 : #endif
233435 :
233436 :
233437 :
233438 : #if 0
233439 : // DQ (7/30/2014): Call a virtual function.
233440 : std::string s = this->class_name();
233441 : #endif
233442 :
233443 : // Test the variant virtual function
233444 : // assert(ELEMENT_WISE_OP == variant());
233445 0 : assert(ELEMENT_WISE_OP == this->variant());
233446 0 : ROSE_ASSERT(ELEMENT_WISE_OP == (int)(this->variantT()));
233447 0 : post_construction_initialization();
233448 :
233449 : // Test the isSgElementwiseOp() function since it has been problematic
233450 0 : assert(isSgElementwiseOp(this) != NULL);
233451 0 : }
233452 :
233453 : // Generated constructor (all data members)
233454 :
233455 : /* #line 233456 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233456 :
233457 :
233458 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233459 :
233460 :
233461 : // ********************************************************
233462 : // member functions common across all array grammar objects
233463 : // ********************************************************
233464 :
233465 :
233466 :
233467 : /* #line 233468 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233468 :
233469 :
233470 :
233471 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233472 :
233473 : // ********************************************************
233474 : // member functions specific to each node in the grammar
233475 : // ********************************************************
233476 :
233477 :
233478 : /* #line 233479 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233479 :
233480 : // Start of memberFunctionString
233481 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
233482 :
233483 : void
233484 0 : SgElementwiseMultiplyOp::post_construction_initialization()
233485 : {
233486 0 : }
233487 :
233488 :
233489 :
233490 : // End of memberFunctionString
233491 : // Start of memberFunctionString
233492 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
233493 :
233494 : // *** COMMON CODE SECTION BEGINS HERE ***
233495 :
233496 : #if 0
233497 : int
233498 : SgElementwiseMultiplyOp::getVariant() const
233499 : {
233500 : // This function is used in ROSE while "variant()" is used in SAGE
233501 : assert(this != NULL);
233502 : return variant();
233503 : }
233504 : #endif
233505 :
233506 : // This function is used in ROSE in treeTraversal code
233507 : // eventually replaces getVariant() and variant()
233508 : // though after variant() has been removed for a while we will
233509 : // want to change the name of variantT() back to variant()
233510 : // (since the "T" was ment to stand for temporary).
233511 : // When this happens the variantT() will be depricated.
233512 : VariantT
233513 0 : SgElementwiseMultiplyOp::variantT() const
233514 : {
233515 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
233516 0 : ROSE_ASSERT(this != NULL);
233517 0 : return V_SgElementwiseMultiplyOp;
233518 : }
233519 :
233520 : #if 0
233521 : int
233522 : SgElementwiseMultiplyOp::variant() const
233523 : {
233524 : // This function is used in SAGE
233525 : ROSE_ASSERT(this != NULL);
233526 : return ELEMENT_MULT_OP;
233527 : }
233528 : #endif
233529 :
233530 : ROSE_DLL_API const char*
233531 0 : SgElementwiseMultiplyOp::sage_class_name() const
233532 : {
233533 0 : ROSE_ASSERT(this != NULL);
233534 0 : return "SgElementwiseMultiplyOp";
233535 : }
233536 :
233537 : std::string
233538 0 : SgElementwiseMultiplyOp::class_name() const
233539 : {
233540 0 : ROSE_ASSERT(this != NULL);
233541 0 : return "SgElementwiseMultiplyOp";
233542 : }
233543 :
233544 : // DQ (11/26/2005): Support for visitor pattern mechanims
233545 : // (inferior to ROSE traversal mechanism, experimental).
233546 : void
233547 0 : SgElementwiseMultiplyOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
233548 : {
233549 0 : ROSE_ASSERT(this != NULL);
233550 0 : visitor.visit(this);
233551 0 : }
233552 :
233553 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
233554 0 : void SgElementwiseMultiplyOp::accept (ROSE_VisitorPattern & visitor) {
233555 0 : ROSE_ASSERT(this != NULL);
233556 0 : visitor.visit(this);
233557 0 : }
233558 :
233559 : SgElementwiseMultiplyOp*
233560 0 : SgElementwiseMultiplyOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
233561 : {
233562 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
233563 : // This function is currently only supported for the AST used the represent Binary executables.
233564 : if (0 /* isSgAsmNode(this) != NULL */)
233565 : {
233566 : // Support for regex specification.
233567 : std::string prefixCode = "REGEX:";
233568 : addNewAttribute(prefixCode + s,a);
233569 : }
233570 : #endif
233571 :
233572 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
233573 0 : return this;
233574 : }
233575 :
233576 : // *** COMMON CODE SECTION ENDS HERE ***
233577 :
233578 :
233579 : // End of memberFunctionString
233580 : // Start of memberFunctionString
233581 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
233582 :
233583 :
233584 : #if 0
233585 : //! Error checking support
233586 : /*! Verifies the following:
233587 : - working getVariant() member function
233588 : - calls base class's error() member function
233589 : Every class has one of these functions.
233590 : */
233591 : bool
233592 : SgElementwiseMultiplyOp::error()
233593 : {
233594 : // Put error checking here
233595 :
233596 : ROSE_ASSERT (this != NULL);
233597 : if (getVariant() != ELEMENT_MULT_OP)
233598 : {
233599 : printf ("Error in SgElementwiseMultiplyOp::error(): SgElementwiseMultiplyOp object has a %s variant \n",
233600 : Cxx_GrammarTerminalNames[getVariant()].name);
233601 : // printf ("Error in SgElementwiseMultiplyOp::error() \n");
233602 : ROSE_ABORT();
233603 : }
233604 :
233605 : ROSE_ASSERT (getVariant() == ELEMENT_MULT_OP);
233606 : return SgElementwiseOp::error();
233607 : }
233608 : #endif
233609 :
233610 :
233611 :
233612 : // End of memberFunctionString
233613 :
233614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
233615 :
233616 0 : SgElementwiseMultiplyOp* isSgElementwiseMultiplyOp ( SgNode* inputDerivedClassPointer )
233617 : {
233618 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233619 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233620 : // So to fix this we return NULL directly when the input is NULL and avoid the
233621 : // dynamic_cast in this case. This is likely a performance improvement as well.
233622 : // return dynamic_cast<SgElementwiseMultiplyOp*>(inputDerivedClassPointer);
233623 : // Milind Chabbi (8/28/2013): isSgElementwiseMultiplyOp uses table-driven castability instead of c++ default dynamic_cast
233624 : // this improves the running time performance by 10-20%.
233625 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwiseMultiplyOp*>(inputDerivedClassPointer);
233626 0 : return IS_SgElementwiseMultiplyOp_FAST_MACRO(inputDerivedClassPointer);
233627 : }
233628 :
233629 : // DQ (11/8/2003): Added version of functions taking const pointer
233630 0 : const SgElementwiseMultiplyOp* isSgElementwiseMultiplyOp ( const SgNode* inputDerivedClassPointer )
233631 : {
233632 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233633 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233634 : // So to fix this we return NULL directly when the input is NULL and avoid the
233635 : // dynamic_cast in this case. This is likely a performance improvement as well.
233636 : // return dynamic_cast<const SgElementwiseMultiplyOp*>(inputDerivedClassPointer);
233637 : // Milind Chabbi (8/28/2013): isSgElementwiseMultiplyOp uses table-driven castability instead of c++ default dynamic_cast
233638 : // this improves the running time performance by 10-20%.
233639 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwiseMultiplyOp*>(inputDerivedClassPointer);
233640 0 : return IS_SgElementwiseMultiplyOp_FAST_MACRO(inputDerivedClassPointer);
233641 : }
233642 :
233643 :
233644 :
233645 : /* #line 233646 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233646 :
233647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233648 :
233649 : /**
233650 : \brief Generated destructor
233651 :
233652 : This destructor is automatically generated (by ROSETTA). This destructor
233653 : only frees memory of data members associated with the parts of the current IR node which
233654 : are NOT traversed. Those data members that are part of a traversal can be freed using
233655 : a traversal (calling this destructor on all children in a post-order traversal). Such
233656 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
233657 :
233658 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
233659 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
233660 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
233661 :
233662 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
233663 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
233664 : pointers are not yet implemented to call delete on eash pointer in the container.
233665 : (This could be done by derivation from the STL containers to define containers that
233666 : automatically deleted their members.)
233667 :
233668 : */
233669 0 : SgElementwiseMultiplyOp::~SgElementwiseMultiplyOp () {
233670 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
233671 :
233672 :
233673 :
233674 : }
233675 :
233676 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233677 0 : }
233678 :
233679 :
233680 : /* #line 233681 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233681 :
233682 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
233683 :
233684 : // Generated constructor
233685 0 : SgElementwiseMultiplyOp::SgElementwiseMultiplyOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
233686 0 : : SgElementwiseOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
233687 : {
233688 : #ifdef DEBUG
233689 : // printf ("In SgElementwiseMultiplyOp::SgElementwiseMultiplyOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
233690 : #endif
233691 : #if 0
233692 : // debugging information!
233693 : printf ("In SgElementwiseMultiplyOp::SgElementwiseMultiplyOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
233694 : #endif
233695 :
233696 :
233697 :
233698 : #if 0
233699 : // DQ (7/30/2014): Call a virtual function.
233700 : std::string s = this->class_name();
233701 : #endif
233702 :
233703 : // Test the variant virtual function
233704 : // assert(ELEMENT_MULT_OP == variant());
233705 0 : assert(ELEMENT_MULT_OP == this->variant());
233706 0 : ROSE_ASSERT(ELEMENT_MULT_OP == (int)(this->variantT()));
233707 0 : post_construction_initialization();
233708 :
233709 : // Test the isSgElementwiseMultiplyOp() function since it has been problematic
233710 0 : assert(isSgElementwiseMultiplyOp(this) != NULL);
233711 0 : }
233712 :
233713 : // Generated constructor (all data members)
233714 :
233715 : /* #line 233716 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233716 :
233717 :
233718 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233719 :
233720 :
233721 : // ********************************************************
233722 : // member functions common across all array grammar objects
233723 : // ********************************************************
233724 :
233725 :
233726 :
233727 : /* #line 233728 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233728 :
233729 :
233730 :
233731 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233732 :
233733 : // ********************************************************
233734 : // member functions specific to each node in the grammar
233735 : // ********************************************************
233736 :
233737 :
233738 : /* #line 233739 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233739 :
233740 : // Start of memberFunctionString
233741 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
233742 :
233743 : void
233744 0 : SgElementwisePowerOp::post_construction_initialization()
233745 : {
233746 0 : }
233747 :
233748 :
233749 :
233750 : // End of memberFunctionString
233751 : // Start of memberFunctionString
233752 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
233753 :
233754 : // *** COMMON CODE SECTION BEGINS HERE ***
233755 :
233756 : #if 0
233757 : int
233758 : SgElementwisePowerOp::getVariant() const
233759 : {
233760 : // This function is used in ROSE while "variant()" is used in SAGE
233761 : assert(this != NULL);
233762 : return variant();
233763 : }
233764 : #endif
233765 :
233766 : // This function is used in ROSE in treeTraversal code
233767 : // eventually replaces getVariant() and variant()
233768 : // though after variant() has been removed for a while we will
233769 : // want to change the name of variantT() back to variant()
233770 : // (since the "T" was ment to stand for temporary).
233771 : // When this happens the variantT() will be depricated.
233772 : VariantT
233773 0 : SgElementwisePowerOp::variantT() const
233774 : {
233775 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
233776 0 : ROSE_ASSERT(this != NULL);
233777 0 : return V_SgElementwisePowerOp;
233778 : }
233779 :
233780 : #if 0
233781 : int
233782 : SgElementwisePowerOp::variant() const
233783 : {
233784 : // This function is used in SAGE
233785 : ROSE_ASSERT(this != NULL);
233786 : return ELEMENT_POWER_OP;
233787 : }
233788 : #endif
233789 :
233790 : ROSE_DLL_API const char*
233791 0 : SgElementwisePowerOp::sage_class_name() const
233792 : {
233793 0 : ROSE_ASSERT(this != NULL);
233794 0 : return "SgElementwisePowerOp";
233795 : }
233796 :
233797 : std::string
233798 0 : SgElementwisePowerOp::class_name() const
233799 : {
233800 0 : ROSE_ASSERT(this != NULL);
233801 0 : return "SgElementwisePowerOp";
233802 : }
233803 :
233804 : // DQ (11/26/2005): Support for visitor pattern mechanims
233805 : // (inferior to ROSE traversal mechanism, experimental).
233806 : void
233807 0 : SgElementwisePowerOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
233808 : {
233809 0 : ROSE_ASSERT(this != NULL);
233810 0 : visitor.visit(this);
233811 0 : }
233812 :
233813 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
233814 0 : void SgElementwisePowerOp::accept (ROSE_VisitorPattern & visitor) {
233815 0 : ROSE_ASSERT(this != NULL);
233816 0 : visitor.visit(this);
233817 0 : }
233818 :
233819 : SgElementwisePowerOp*
233820 0 : SgElementwisePowerOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
233821 : {
233822 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
233823 : // This function is currently only supported for the AST used the represent Binary executables.
233824 : if (0 /* isSgAsmNode(this) != NULL */)
233825 : {
233826 : // Support for regex specification.
233827 : std::string prefixCode = "REGEX:";
233828 : addNewAttribute(prefixCode + s,a);
233829 : }
233830 : #endif
233831 :
233832 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
233833 0 : return this;
233834 : }
233835 :
233836 : // *** COMMON CODE SECTION ENDS HERE ***
233837 :
233838 :
233839 : // End of memberFunctionString
233840 : // Start of memberFunctionString
233841 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
233842 :
233843 :
233844 : #if 0
233845 : //! Error checking support
233846 : /*! Verifies the following:
233847 : - working getVariant() member function
233848 : - calls base class's error() member function
233849 : Every class has one of these functions.
233850 : */
233851 : bool
233852 : SgElementwisePowerOp::error()
233853 : {
233854 : // Put error checking here
233855 :
233856 : ROSE_ASSERT (this != NULL);
233857 : if (getVariant() != ELEMENT_POWER_OP)
233858 : {
233859 : printf ("Error in SgElementwisePowerOp::error(): SgElementwisePowerOp object has a %s variant \n",
233860 : Cxx_GrammarTerminalNames[getVariant()].name);
233861 : // printf ("Error in SgElementwisePowerOp::error() \n");
233862 : ROSE_ABORT();
233863 : }
233864 :
233865 : ROSE_ASSERT (getVariant() == ELEMENT_POWER_OP);
233866 : return SgElementwiseOp::error();
233867 : }
233868 : #endif
233869 :
233870 :
233871 :
233872 : // End of memberFunctionString
233873 :
233874 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
233875 :
233876 0 : SgElementwisePowerOp* isSgElementwisePowerOp ( SgNode* inputDerivedClassPointer )
233877 : {
233878 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233879 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233880 : // So to fix this we return NULL directly when the input is NULL and avoid the
233881 : // dynamic_cast in this case. This is likely a performance improvement as well.
233882 : // return dynamic_cast<SgElementwisePowerOp*>(inputDerivedClassPointer);
233883 : // Milind Chabbi (8/28/2013): isSgElementwisePowerOp uses table-driven castability instead of c++ default dynamic_cast
233884 : // this improves the running time performance by 10-20%.
233885 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwisePowerOp*>(inputDerivedClassPointer);
233886 0 : return IS_SgElementwisePowerOp_FAST_MACRO(inputDerivedClassPointer);
233887 : }
233888 :
233889 : // DQ (11/8/2003): Added version of functions taking const pointer
233890 0 : const SgElementwisePowerOp* isSgElementwisePowerOp ( const SgNode* inputDerivedClassPointer )
233891 : {
233892 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
233893 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
233894 : // So to fix this we return NULL directly when the input is NULL and avoid the
233895 : // dynamic_cast in this case. This is likely a performance improvement as well.
233896 : // return dynamic_cast<const SgElementwisePowerOp*>(inputDerivedClassPointer);
233897 : // Milind Chabbi (8/28/2013): isSgElementwisePowerOp uses table-driven castability instead of c++ default dynamic_cast
233898 : // this improves the running time performance by 10-20%.
233899 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwisePowerOp*>(inputDerivedClassPointer);
233900 0 : return IS_SgElementwisePowerOp_FAST_MACRO(inputDerivedClassPointer);
233901 : }
233902 :
233903 :
233904 :
233905 : /* #line 233906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233906 :
233907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233908 :
233909 : /**
233910 : \brief Generated destructor
233911 :
233912 : This destructor is automatically generated (by ROSETTA). This destructor
233913 : only frees memory of data members associated with the parts of the current IR node which
233914 : are NOT traversed. Those data members that are part of a traversal can be freed using
233915 : a traversal (calling this destructor on all children in a post-order traversal). Such
233916 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
233917 :
233918 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
233919 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
233920 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
233921 :
233922 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
233923 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
233924 : pointers are not yet implemented to call delete on eash pointer in the container.
233925 : (This could be done by derivation from the STL containers to define containers that
233926 : automatically deleted their members.)
233927 :
233928 : */
233929 0 : SgElementwisePowerOp::~SgElementwisePowerOp () {
233930 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
233931 :
233932 :
233933 :
233934 : }
233935 :
233936 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
233937 0 : }
233938 :
233939 :
233940 : /* #line 233941 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233941 :
233942 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
233943 :
233944 : // Generated constructor
233945 0 : SgElementwisePowerOp::SgElementwisePowerOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
233946 0 : : SgElementwiseOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
233947 : {
233948 : #ifdef DEBUG
233949 : // printf ("In SgElementwisePowerOp::SgElementwisePowerOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
233950 : #endif
233951 : #if 0
233952 : // debugging information!
233953 : printf ("In SgElementwisePowerOp::SgElementwisePowerOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
233954 : #endif
233955 :
233956 :
233957 :
233958 : #if 0
233959 : // DQ (7/30/2014): Call a virtual function.
233960 : std::string s = this->class_name();
233961 : #endif
233962 :
233963 : // Test the variant virtual function
233964 : // assert(ELEMENT_POWER_OP == variant());
233965 0 : assert(ELEMENT_POWER_OP == this->variant());
233966 0 : ROSE_ASSERT(ELEMENT_POWER_OP == (int)(this->variantT()));
233967 0 : post_construction_initialization();
233968 :
233969 : // Test the isSgElementwisePowerOp() function since it has been problematic
233970 0 : assert(isSgElementwisePowerOp(this) != NULL);
233971 0 : }
233972 :
233973 : // Generated constructor (all data members)
233974 :
233975 : /* #line 233976 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233976 :
233977 :
233978 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233979 :
233980 :
233981 : // ********************************************************
233982 : // member functions common across all array grammar objects
233983 : // ********************************************************
233984 :
233985 :
233986 :
233987 : /* #line 233988 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233988 :
233989 :
233990 :
233991 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
233992 :
233993 : // ********************************************************
233994 : // member functions specific to each node in the grammar
233995 : // ********************************************************
233996 :
233997 :
233998 : /* #line 233999 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
233999 :
234000 : // Start of memberFunctionString
234001 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
234002 :
234003 : void
234004 0 : SgElementwiseLeftDivideOp::post_construction_initialization()
234005 : {
234006 0 : }
234007 :
234008 :
234009 :
234010 : // End of memberFunctionString
234011 : // Start of memberFunctionString
234012 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
234013 :
234014 : // *** COMMON CODE SECTION BEGINS HERE ***
234015 :
234016 : #if 0
234017 : int
234018 : SgElementwiseLeftDivideOp::getVariant() const
234019 : {
234020 : // This function is used in ROSE while "variant()" is used in SAGE
234021 : assert(this != NULL);
234022 : return variant();
234023 : }
234024 : #endif
234025 :
234026 : // This function is used in ROSE in treeTraversal code
234027 : // eventually replaces getVariant() and variant()
234028 : // though after variant() has been removed for a while we will
234029 : // want to change the name of variantT() back to variant()
234030 : // (since the "T" was ment to stand for temporary).
234031 : // When this happens the variantT() will be depricated.
234032 : VariantT
234033 0 : SgElementwiseLeftDivideOp::variantT() const
234034 : {
234035 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
234036 0 : ROSE_ASSERT(this != NULL);
234037 0 : return V_SgElementwiseLeftDivideOp;
234038 : }
234039 :
234040 : #if 0
234041 : int
234042 : SgElementwiseLeftDivideOp::variant() const
234043 : {
234044 : // This function is used in SAGE
234045 : ROSE_ASSERT(this != NULL);
234046 : return ELEMENT_LEFT_DIVIDE_OP;
234047 : }
234048 : #endif
234049 :
234050 : ROSE_DLL_API const char*
234051 0 : SgElementwiseLeftDivideOp::sage_class_name() const
234052 : {
234053 0 : ROSE_ASSERT(this != NULL);
234054 0 : return "SgElementwiseLeftDivideOp";
234055 : }
234056 :
234057 : std::string
234058 0 : SgElementwiseLeftDivideOp::class_name() const
234059 : {
234060 0 : ROSE_ASSERT(this != NULL);
234061 0 : return "SgElementwiseLeftDivideOp";
234062 : }
234063 :
234064 : // DQ (11/26/2005): Support for visitor pattern mechanims
234065 : // (inferior to ROSE traversal mechanism, experimental).
234066 : void
234067 0 : SgElementwiseLeftDivideOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
234068 : {
234069 0 : ROSE_ASSERT(this != NULL);
234070 0 : visitor.visit(this);
234071 0 : }
234072 :
234073 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
234074 0 : void SgElementwiseLeftDivideOp::accept (ROSE_VisitorPattern & visitor) {
234075 0 : ROSE_ASSERT(this != NULL);
234076 0 : visitor.visit(this);
234077 0 : }
234078 :
234079 : SgElementwiseLeftDivideOp*
234080 0 : SgElementwiseLeftDivideOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
234081 : {
234082 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
234083 : // This function is currently only supported for the AST used the represent Binary executables.
234084 : if (0 /* isSgAsmNode(this) != NULL */)
234085 : {
234086 : // Support for regex specification.
234087 : std::string prefixCode = "REGEX:";
234088 : addNewAttribute(prefixCode + s,a);
234089 : }
234090 : #endif
234091 :
234092 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
234093 0 : return this;
234094 : }
234095 :
234096 : // *** COMMON CODE SECTION ENDS HERE ***
234097 :
234098 :
234099 : // End of memberFunctionString
234100 : // Start of memberFunctionString
234101 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
234102 :
234103 :
234104 : #if 0
234105 : //! Error checking support
234106 : /*! Verifies the following:
234107 : - working getVariant() member function
234108 : - calls base class's error() member function
234109 : Every class has one of these functions.
234110 : */
234111 : bool
234112 : SgElementwiseLeftDivideOp::error()
234113 : {
234114 : // Put error checking here
234115 :
234116 : ROSE_ASSERT (this != NULL);
234117 : if (getVariant() != ELEMENT_LEFT_DIVIDE_OP)
234118 : {
234119 : printf ("Error in SgElementwiseLeftDivideOp::error(): SgElementwiseLeftDivideOp object has a %s variant \n",
234120 : Cxx_GrammarTerminalNames[getVariant()].name);
234121 : // printf ("Error in SgElementwiseLeftDivideOp::error() \n");
234122 : ROSE_ABORT();
234123 : }
234124 :
234125 : ROSE_ASSERT (getVariant() == ELEMENT_LEFT_DIVIDE_OP);
234126 : return SgElementwiseOp::error();
234127 : }
234128 : #endif
234129 :
234130 :
234131 :
234132 : // End of memberFunctionString
234133 :
234134 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
234135 :
234136 0 : SgElementwiseLeftDivideOp* isSgElementwiseLeftDivideOp ( SgNode* inputDerivedClassPointer )
234137 : {
234138 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234139 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234140 : // So to fix this we return NULL directly when the input is NULL and avoid the
234141 : // dynamic_cast in this case. This is likely a performance improvement as well.
234142 : // return dynamic_cast<SgElementwiseLeftDivideOp*>(inputDerivedClassPointer);
234143 : // Milind Chabbi (8/28/2013): isSgElementwiseLeftDivideOp uses table-driven castability instead of c++ default dynamic_cast
234144 : // this improves the running time performance by 10-20%.
234145 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwiseLeftDivideOp*>(inputDerivedClassPointer);
234146 0 : return IS_SgElementwiseLeftDivideOp_FAST_MACRO(inputDerivedClassPointer);
234147 : }
234148 :
234149 : // DQ (11/8/2003): Added version of functions taking const pointer
234150 0 : const SgElementwiseLeftDivideOp* isSgElementwiseLeftDivideOp ( const SgNode* inputDerivedClassPointer )
234151 : {
234152 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234153 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234154 : // So to fix this we return NULL directly when the input is NULL and avoid the
234155 : // dynamic_cast in this case. This is likely a performance improvement as well.
234156 : // return dynamic_cast<const SgElementwiseLeftDivideOp*>(inputDerivedClassPointer);
234157 : // Milind Chabbi (8/28/2013): isSgElementwiseLeftDivideOp uses table-driven castability instead of c++ default dynamic_cast
234158 : // this improves the running time performance by 10-20%.
234159 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwiseLeftDivideOp*>(inputDerivedClassPointer);
234160 0 : return IS_SgElementwiseLeftDivideOp_FAST_MACRO(inputDerivedClassPointer);
234161 : }
234162 :
234163 :
234164 :
234165 : /* #line 234166 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234166 :
234167 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234168 :
234169 : /**
234170 : \brief Generated destructor
234171 :
234172 : This destructor is automatically generated (by ROSETTA). This destructor
234173 : only frees memory of data members associated with the parts of the current IR node which
234174 : are NOT traversed. Those data members that are part of a traversal can be freed using
234175 : a traversal (calling this destructor on all children in a post-order traversal). Such
234176 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
234177 :
234178 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
234179 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
234180 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
234181 :
234182 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
234183 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
234184 : pointers are not yet implemented to call delete on eash pointer in the container.
234185 : (This could be done by derivation from the STL containers to define containers that
234186 : automatically deleted their members.)
234187 :
234188 : */
234189 0 : SgElementwiseLeftDivideOp::~SgElementwiseLeftDivideOp () {
234190 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
234191 :
234192 :
234193 :
234194 : }
234195 :
234196 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234197 0 : }
234198 :
234199 :
234200 : /* #line 234201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234201 :
234202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
234203 :
234204 : // Generated constructor
234205 0 : SgElementwiseLeftDivideOp::SgElementwiseLeftDivideOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
234206 0 : : SgElementwiseOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
234207 : {
234208 : #ifdef DEBUG
234209 : // printf ("In SgElementwiseLeftDivideOp::SgElementwiseLeftDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
234210 : #endif
234211 : #if 0
234212 : // debugging information!
234213 : printf ("In SgElementwiseLeftDivideOp::SgElementwiseLeftDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
234214 : #endif
234215 :
234216 :
234217 :
234218 : #if 0
234219 : // DQ (7/30/2014): Call a virtual function.
234220 : std::string s = this->class_name();
234221 : #endif
234222 :
234223 : // Test the variant virtual function
234224 : // assert(ELEMENT_LEFT_DIVIDE_OP == variant());
234225 0 : assert(ELEMENT_LEFT_DIVIDE_OP == this->variant());
234226 0 : ROSE_ASSERT(ELEMENT_LEFT_DIVIDE_OP == (int)(this->variantT()));
234227 0 : post_construction_initialization();
234228 :
234229 : // Test the isSgElementwiseLeftDivideOp() function since it has been problematic
234230 0 : assert(isSgElementwiseLeftDivideOp(this) != NULL);
234231 0 : }
234232 :
234233 : // Generated constructor (all data members)
234234 :
234235 : /* #line 234236 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234236 :
234237 :
234238 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
234239 :
234240 :
234241 : // ********************************************************
234242 : // member functions common across all array grammar objects
234243 : // ********************************************************
234244 :
234245 :
234246 :
234247 : /* #line 234248 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234248 :
234249 :
234250 :
234251 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
234252 :
234253 : // ********************************************************
234254 : // member functions specific to each node in the grammar
234255 : // ********************************************************
234256 :
234257 :
234258 : /* #line 234259 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234259 :
234260 : // Start of memberFunctionString
234261 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
234262 :
234263 : void
234264 0 : SgElementwiseDivideOp::post_construction_initialization()
234265 : {
234266 0 : }
234267 :
234268 :
234269 :
234270 : // End of memberFunctionString
234271 : // Start of memberFunctionString
234272 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
234273 :
234274 : // *** COMMON CODE SECTION BEGINS HERE ***
234275 :
234276 : #if 0
234277 : int
234278 : SgElementwiseDivideOp::getVariant() const
234279 : {
234280 : // This function is used in ROSE while "variant()" is used in SAGE
234281 : assert(this != NULL);
234282 : return variant();
234283 : }
234284 : #endif
234285 :
234286 : // This function is used in ROSE in treeTraversal code
234287 : // eventually replaces getVariant() and variant()
234288 : // though after variant() has been removed for a while we will
234289 : // want to change the name of variantT() back to variant()
234290 : // (since the "T" was ment to stand for temporary).
234291 : // When this happens the variantT() will be depricated.
234292 : VariantT
234293 0 : SgElementwiseDivideOp::variantT() const
234294 : {
234295 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
234296 0 : ROSE_ASSERT(this != NULL);
234297 0 : return V_SgElementwiseDivideOp;
234298 : }
234299 :
234300 : #if 0
234301 : int
234302 : SgElementwiseDivideOp::variant() const
234303 : {
234304 : // This function is used in SAGE
234305 : ROSE_ASSERT(this != NULL);
234306 : return ELEMENT_DIVIDE_OP;
234307 : }
234308 : #endif
234309 :
234310 : ROSE_DLL_API const char*
234311 0 : SgElementwiseDivideOp::sage_class_name() const
234312 : {
234313 0 : ROSE_ASSERT(this != NULL);
234314 0 : return "SgElementwiseDivideOp";
234315 : }
234316 :
234317 : std::string
234318 0 : SgElementwiseDivideOp::class_name() const
234319 : {
234320 0 : ROSE_ASSERT(this != NULL);
234321 0 : return "SgElementwiseDivideOp";
234322 : }
234323 :
234324 : // DQ (11/26/2005): Support for visitor pattern mechanims
234325 : // (inferior to ROSE traversal mechanism, experimental).
234326 : void
234327 0 : SgElementwiseDivideOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
234328 : {
234329 0 : ROSE_ASSERT(this != NULL);
234330 0 : visitor.visit(this);
234331 0 : }
234332 :
234333 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
234334 0 : void SgElementwiseDivideOp::accept (ROSE_VisitorPattern & visitor) {
234335 0 : ROSE_ASSERT(this != NULL);
234336 0 : visitor.visit(this);
234337 0 : }
234338 :
234339 : SgElementwiseDivideOp*
234340 0 : SgElementwiseDivideOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
234341 : {
234342 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
234343 : // This function is currently only supported for the AST used the represent Binary executables.
234344 : if (0 /* isSgAsmNode(this) != NULL */)
234345 : {
234346 : // Support for regex specification.
234347 : std::string prefixCode = "REGEX:";
234348 : addNewAttribute(prefixCode + s,a);
234349 : }
234350 : #endif
234351 :
234352 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
234353 0 : return this;
234354 : }
234355 :
234356 : // *** COMMON CODE SECTION ENDS HERE ***
234357 :
234358 :
234359 : // End of memberFunctionString
234360 : // Start of memberFunctionString
234361 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
234362 :
234363 :
234364 : #if 0
234365 : //! Error checking support
234366 : /*! Verifies the following:
234367 : - working getVariant() member function
234368 : - calls base class's error() member function
234369 : Every class has one of these functions.
234370 : */
234371 : bool
234372 : SgElementwiseDivideOp::error()
234373 : {
234374 : // Put error checking here
234375 :
234376 : ROSE_ASSERT (this != NULL);
234377 : if (getVariant() != ELEMENT_DIVIDE_OP)
234378 : {
234379 : printf ("Error in SgElementwiseDivideOp::error(): SgElementwiseDivideOp object has a %s variant \n",
234380 : Cxx_GrammarTerminalNames[getVariant()].name);
234381 : // printf ("Error in SgElementwiseDivideOp::error() \n");
234382 : ROSE_ABORT();
234383 : }
234384 :
234385 : ROSE_ASSERT (getVariant() == ELEMENT_DIVIDE_OP);
234386 : return SgElementwiseOp::error();
234387 : }
234388 : #endif
234389 :
234390 :
234391 :
234392 : // End of memberFunctionString
234393 :
234394 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
234395 :
234396 0 : SgElementwiseDivideOp* isSgElementwiseDivideOp ( SgNode* inputDerivedClassPointer )
234397 : {
234398 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234399 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234400 : // So to fix this we return NULL directly when the input is NULL and avoid the
234401 : // dynamic_cast in this case. This is likely a performance improvement as well.
234402 : // return dynamic_cast<SgElementwiseDivideOp*>(inputDerivedClassPointer);
234403 : // Milind Chabbi (8/28/2013): isSgElementwiseDivideOp uses table-driven castability instead of c++ default dynamic_cast
234404 : // this improves the running time performance by 10-20%.
234405 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwiseDivideOp*>(inputDerivedClassPointer);
234406 0 : return IS_SgElementwiseDivideOp_FAST_MACRO(inputDerivedClassPointer);
234407 : }
234408 :
234409 : // DQ (11/8/2003): Added version of functions taking const pointer
234410 0 : const SgElementwiseDivideOp* isSgElementwiseDivideOp ( const SgNode* inputDerivedClassPointer )
234411 : {
234412 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234413 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234414 : // So to fix this we return NULL directly when the input is NULL and avoid the
234415 : // dynamic_cast in this case. This is likely a performance improvement as well.
234416 : // return dynamic_cast<const SgElementwiseDivideOp*>(inputDerivedClassPointer);
234417 : // Milind Chabbi (8/28/2013): isSgElementwiseDivideOp uses table-driven castability instead of c++ default dynamic_cast
234418 : // this improves the running time performance by 10-20%.
234419 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwiseDivideOp*>(inputDerivedClassPointer);
234420 0 : return IS_SgElementwiseDivideOp_FAST_MACRO(inputDerivedClassPointer);
234421 : }
234422 :
234423 :
234424 :
234425 : /* #line 234426 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234426 :
234427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234428 :
234429 : /**
234430 : \brief Generated destructor
234431 :
234432 : This destructor is automatically generated (by ROSETTA). This destructor
234433 : only frees memory of data members associated with the parts of the current IR node which
234434 : are NOT traversed. Those data members that are part of a traversal can be freed using
234435 : a traversal (calling this destructor on all children in a post-order traversal). Such
234436 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
234437 :
234438 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
234439 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
234440 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
234441 :
234442 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
234443 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
234444 : pointers are not yet implemented to call delete on eash pointer in the container.
234445 : (This could be done by derivation from the STL containers to define containers that
234446 : automatically deleted their members.)
234447 :
234448 : */
234449 0 : SgElementwiseDivideOp::~SgElementwiseDivideOp () {
234450 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
234451 :
234452 :
234453 :
234454 : }
234455 :
234456 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234457 0 : }
234458 :
234459 :
234460 : /* #line 234461 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234461 :
234462 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
234463 :
234464 : // Generated constructor
234465 0 : SgElementwiseDivideOp::SgElementwiseDivideOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
234466 0 : : SgElementwiseOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
234467 : {
234468 : #ifdef DEBUG
234469 : // printf ("In SgElementwiseDivideOp::SgElementwiseDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
234470 : #endif
234471 : #if 0
234472 : // debugging information!
234473 : printf ("In SgElementwiseDivideOp::SgElementwiseDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
234474 : #endif
234475 :
234476 :
234477 :
234478 : #if 0
234479 : // DQ (7/30/2014): Call a virtual function.
234480 : std::string s = this->class_name();
234481 : #endif
234482 :
234483 : // Test the variant virtual function
234484 : // assert(ELEMENT_DIVIDE_OP == variant());
234485 0 : assert(ELEMENT_DIVIDE_OP == this->variant());
234486 0 : ROSE_ASSERT(ELEMENT_DIVIDE_OP == (int)(this->variantT()));
234487 0 : post_construction_initialization();
234488 :
234489 : // Test the isSgElementwiseDivideOp() function since it has been problematic
234490 0 : assert(isSgElementwiseDivideOp(this) != NULL);
234491 0 : }
234492 :
234493 : // Generated constructor (all data members)
234494 :
234495 : /* #line 234496 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234496 :
234497 :
234498 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
234499 :
234500 :
234501 : // ********************************************************
234502 : // member functions common across all array grammar objects
234503 : // ********************************************************
234504 :
234505 :
234506 :
234507 : /* #line 234508 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234508 :
234509 :
234510 :
234511 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
234512 :
234513 : // ********************************************************
234514 : // member functions specific to each node in the grammar
234515 : // ********************************************************
234516 :
234517 :
234518 : /* #line 234519 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234519 :
234520 : // Start of memberFunctionString
234521 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
234522 :
234523 : void
234524 0 : SgElementwiseAddOp::post_construction_initialization()
234525 : {
234526 0 : }
234527 :
234528 :
234529 :
234530 : // End of memberFunctionString
234531 : // Start of memberFunctionString
234532 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
234533 :
234534 : // *** COMMON CODE SECTION BEGINS HERE ***
234535 :
234536 : #if 0
234537 : int
234538 : SgElementwiseAddOp::getVariant() const
234539 : {
234540 : // This function is used in ROSE while "variant()" is used in SAGE
234541 : assert(this != NULL);
234542 : return variant();
234543 : }
234544 : #endif
234545 :
234546 : // This function is used in ROSE in treeTraversal code
234547 : // eventually replaces getVariant() and variant()
234548 : // though after variant() has been removed for a while we will
234549 : // want to change the name of variantT() back to variant()
234550 : // (since the "T" was ment to stand for temporary).
234551 : // When this happens the variantT() will be depricated.
234552 : VariantT
234553 0 : SgElementwiseAddOp::variantT() const
234554 : {
234555 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
234556 0 : ROSE_ASSERT(this != NULL);
234557 0 : return V_SgElementwiseAddOp;
234558 : }
234559 :
234560 : #if 0
234561 : int
234562 : SgElementwiseAddOp::variant() const
234563 : {
234564 : // This function is used in SAGE
234565 : ROSE_ASSERT(this != NULL);
234566 : return ELEMENT_ADD_OP;
234567 : }
234568 : #endif
234569 :
234570 : ROSE_DLL_API const char*
234571 0 : SgElementwiseAddOp::sage_class_name() const
234572 : {
234573 0 : ROSE_ASSERT(this != NULL);
234574 0 : return "SgElementwiseAddOp";
234575 : }
234576 :
234577 : std::string
234578 0 : SgElementwiseAddOp::class_name() const
234579 : {
234580 0 : ROSE_ASSERT(this != NULL);
234581 0 : return "SgElementwiseAddOp";
234582 : }
234583 :
234584 : // DQ (11/26/2005): Support for visitor pattern mechanims
234585 : // (inferior to ROSE traversal mechanism, experimental).
234586 : void
234587 0 : SgElementwiseAddOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
234588 : {
234589 0 : ROSE_ASSERT(this != NULL);
234590 0 : visitor.visit(this);
234591 0 : }
234592 :
234593 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
234594 0 : void SgElementwiseAddOp::accept (ROSE_VisitorPattern & visitor) {
234595 0 : ROSE_ASSERT(this != NULL);
234596 0 : visitor.visit(this);
234597 0 : }
234598 :
234599 : SgElementwiseAddOp*
234600 0 : SgElementwiseAddOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
234601 : {
234602 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
234603 : // This function is currently only supported for the AST used the represent Binary executables.
234604 : if (0 /* isSgAsmNode(this) != NULL */)
234605 : {
234606 : // Support for regex specification.
234607 : std::string prefixCode = "REGEX:";
234608 : addNewAttribute(prefixCode + s,a);
234609 : }
234610 : #endif
234611 :
234612 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
234613 0 : return this;
234614 : }
234615 :
234616 : // *** COMMON CODE SECTION ENDS HERE ***
234617 :
234618 :
234619 : // End of memberFunctionString
234620 : // Start of memberFunctionString
234621 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
234622 :
234623 :
234624 : #if 0
234625 : //! Error checking support
234626 : /*! Verifies the following:
234627 : - working getVariant() member function
234628 : - calls base class's error() member function
234629 : Every class has one of these functions.
234630 : */
234631 : bool
234632 : SgElementwiseAddOp::error()
234633 : {
234634 : // Put error checking here
234635 :
234636 : ROSE_ASSERT (this != NULL);
234637 : if (getVariant() != ELEMENT_ADD_OP)
234638 : {
234639 : printf ("Error in SgElementwiseAddOp::error(): SgElementwiseAddOp object has a %s variant \n",
234640 : Cxx_GrammarTerminalNames[getVariant()].name);
234641 : // printf ("Error in SgElementwiseAddOp::error() \n");
234642 : ROSE_ABORT();
234643 : }
234644 :
234645 : ROSE_ASSERT (getVariant() == ELEMENT_ADD_OP);
234646 : return SgElementwiseOp::error();
234647 : }
234648 : #endif
234649 :
234650 :
234651 :
234652 : // End of memberFunctionString
234653 :
234654 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
234655 :
234656 0 : SgElementwiseAddOp* isSgElementwiseAddOp ( SgNode* inputDerivedClassPointer )
234657 : {
234658 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234659 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234660 : // So to fix this we return NULL directly when the input is NULL and avoid the
234661 : // dynamic_cast in this case. This is likely a performance improvement as well.
234662 : // return dynamic_cast<SgElementwiseAddOp*>(inputDerivedClassPointer);
234663 : // Milind Chabbi (8/28/2013): isSgElementwiseAddOp uses table-driven castability instead of c++ default dynamic_cast
234664 : // this improves the running time performance by 10-20%.
234665 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwiseAddOp*>(inputDerivedClassPointer);
234666 0 : return IS_SgElementwiseAddOp_FAST_MACRO(inputDerivedClassPointer);
234667 : }
234668 :
234669 : // DQ (11/8/2003): Added version of functions taking const pointer
234670 0 : const SgElementwiseAddOp* isSgElementwiseAddOp ( const SgNode* inputDerivedClassPointer )
234671 : {
234672 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234673 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234674 : // So to fix this we return NULL directly when the input is NULL and avoid the
234675 : // dynamic_cast in this case. This is likely a performance improvement as well.
234676 : // return dynamic_cast<const SgElementwiseAddOp*>(inputDerivedClassPointer);
234677 : // Milind Chabbi (8/28/2013): isSgElementwiseAddOp uses table-driven castability instead of c++ default dynamic_cast
234678 : // this improves the running time performance by 10-20%.
234679 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwiseAddOp*>(inputDerivedClassPointer);
234680 0 : return IS_SgElementwiseAddOp_FAST_MACRO(inputDerivedClassPointer);
234681 : }
234682 :
234683 :
234684 :
234685 : /* #line 234686 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234686 :
234687 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234688 :
234689 : /**
234690 : \brief Generated destructor
234691 :
234692 : This destructor is automatically generated (by ROSETTA). This destructor
234693 : only frees memory of data members associated with the parts of the current IR node which
234694 : are NOT traversed. Those data members that are part of a traversal can be freed using
234695 : a traversal (calling this destructor on all children in a post-order traversal). Such
234696 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
234697 :
234698 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
234699 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
234700 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
234701 :
234702 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
234703 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
234704 : pointers are not yet implemented to call delete on eash pointer in the container.
234705 : (This could be done by derivation from the STL containers to define containers that
234706 : automatically deleted their members.)
234707 :
234708 : */
234709 0 : SgElementwiseAddOp::~SgElementwiseAddOp () {
234710 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
234711 :
234712 :
234713 :
234714 : }
234715 :
234716 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234717 0 : }
234718 :
234719 :
234720 : /* #line 234721 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234721 :
234722 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
234723 :
234724 : // Generated constructor
234725 0 : SgElementwiseAddOp::SgElementwiseAddOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
234726 0 : : SgElementwiseOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
234727 : {
234728 : #ifdef DEBUG
234729 : // printf ("In SgElementwiseAddOp::SgElementwiseAddOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
234730 : #endif
234731 : #if 0
234732 : // debugging information!
234733 : printf ("In SgElementwiseAddOp::SgElementwiseAddOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
234734 : #endif
234735 :
234736 :
234737 :
234738 : #if 0
234739 : // DQ (7/30/2014): Call a virtual function.
234740 : std::string s = this->class_name();
234741 : #endif
234742 :
234743 : // Test the variant virtual function
234744 : // assert(ELEMENT_ADD_OP == variant());
234745 0 : assert(ELEMENT_ADD_OP == this->variant());
234746 0 : ROSE_ASSERT(ELEMENT_ADD_OP == (int)(this->variantT()));
234747 0 : post_construction_initialization();
234748 :
234749 : // Test the isSgElementwiseAddOp() function since it has been problematic
234750 0 : assert(isSgElementwiseAddOp(this) != NULL);
234751 0 : }
234752 :
234753 : // Generated constructor (all data members)
234754 :
234755 : /* #line 234756 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234756 :
234757 :
234758 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
234759 :
234760 :
234761 : // ********************************************************
234762 : // member functions common across all array grammar objects
234763 : // ********************************************************
234764 :
234765 :
234766 :
234767 : /* #line 234768 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234768 :
234769 :
234770 :
234771 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
234772 :
234773 : // ********************************************************
234774 : // member functions specific to each node in the grammar
234775 : // ********************************************************
234776 :
234777 :
234778 : /* #line 234779 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234779 :
234780 : // Start of memberFunctionString
234781 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
234782 :
234783 : void
234784 0 : SgElementwiseSubtractOp::post_construction_initialization()
234785 : {
234786 0 : }
234787 :
234788 :
234789 :
234790 : // End of memberFunctionString
234791 : // Start of memberFunctionString
234792 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
234793 :
234794 : // *** COMMON CODE SECTION BEGINS HERE ***
234795 :
234796 : #if 0
234797 : int
234798 : SgElementwiseSubtractOp::getVariant() const
234799 : {
234800 : // This function is used in ROSE while "variant()" is used in SAGE
234801 : assert(this != NULL);
234802 : return variant();
234803 : }
234804 : #endif
234805 :
234806 : // This function is used in ROSE in treeTraversal code
234807 : // eventually replaces getVariant() and variant()
234808 : // though after variant() has been removed for a while we will
234809 : // want to change the name of variantT() back to variant()
234810 : // (since the "T" was ment to stand for temporary).
234811 : // When this happens the variantT() will be depricated.
234812 : VariantT
234813 0 : SgElementwiseSubtractOp::variantT() const
234814 : {
234815 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
234816 0 : ROSE_ASSERT(this != NULL);
234817 0 : return V_SgElementwiseSubtractOp;
234818 : }
234819 :
234820 : #if 0
234821 : int
234822 : SgElementwiseSubtractOp::variant() const
234823 : {
234824 : // This function is used in SAGE
234825 : ROSE_ASSERT(this != NULL);
234826 : return ELEMENT_SUBTRACT_OP;
234827 : }
234828 : #endif
234829 :
234830 : ROSE_DLL_API const char*
234831 0 : SgElementwiseSubtractOp::sage_class_name() const
234832 : {
234833 0 : ROSE_ASSERT(this != NULL);
234834 0 : return "SgElementwiseSubtractOp";
234835 : }
234836 :
234837 : std::string
234838 0 : SgElementwiseSubtractOp::class_name() const
234839 : {
234840 0 : ROSE_ASSERT(this != NULL);
234841 0 : return "SgElementwiseSubtractOp";
234842 : }
234843 :
234844 : // DQ (11/26/2005): Support for visitor pattern mechanims
234845 : // (inferior to ROSE traversal mechanism, experimental).
234846 : void
234847 0 : SgElementwiseSubtractOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
234848 : {
234849 0 : ROSE_ASSERT(this != NULL);
234850 0 : visitor.visit(this);
234851 0 : }
234852 :
234853 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
234854 0 : void SgElementwiseSubtractOp::accept (ROSE_VisitorPattern & visitor) {
234855 0 : ROSE_ASSERT(this != NULL);
234856 0 : visitor.visit(this);
234857 0 : }
234858 :
234859 : SgElementwiseSubtractOp*
234860 0 : SgElementwiseSubtractOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
234861 : {
234862 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
234863 : // This function is currently only supported for the AST used the represent Binary executables.
234864 : if (0 /* isSgAsmNode(this) != NULL */)
234865 : {
234866 : // Support for regex specification.
234867 : std::string prefixCode = "REGEX:";
234868 : addNewAttribute(prefixCode + s,a);
234869 : }
234870 : #endif
234871 :
234872 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
234873 0 : return this;
234874 : }
234875 :
234876 : // *** COMMON CODE SECTION ENDS HERE ***
234877 :
234878 :
234879 : // End of memberFunctionString
234880 : // Start of memberFunctionString
234881 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
234882 :
234883 :
234884 : #if 0
234885 : //! Error checking support
234886 : /*! Verifies the following:
234887 : - working getVariant() member function
234888 : - calls base class's error() member function
234889 : Every class has one of these functions.
234890 : */
234891 : bool
234892 : SgElementwiseSubtractOp::error()
234893 : {
234894 : // Put error checking here
234895 :
234896 : ROSE_ASSERT (this != NULL);
234897 : if (getVariant() != ELEMENT_SUBTRACT_OP)
234898 : {
234899 : printf ("Error in SgElementwiseSubtractOp::error(): SgElementwiseSubtractOp object has a %s variant \n",
234900 : Cxx_GrammarTerminalNames[getVariant()].name);
234901 : // printf ("Error in SgElementwiseSubtractOp::error() \n");
234902 : ROSE_ABORT();
234903 : }
234904 :
234905 : ROSE_ASSERT (getVariant() == ELEMENT_SUBTRACT_OP);
234906 : return SgElementwiseOp::error();
234907 : }
234908 : #endif
234909 :
234910 :
234911 :
234912 : // End of memberFunctionString
234913 :
234914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
234915 :
234916 0 : SgElementwiseSubtractOp* isSgElementwiseSubtractOp ( SgNode* inputDerivedClassPointer )
234917 : {
234918 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234919 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234920 : // So to fix this we return NULL directly when the input is NULL and avoid the
234921 : // dynamic_cast in this case. This is likely a performance improvement as well.
234922 : // return dynamic_cast<SgElementwiseSubtractOp*>(inputDerivedClassPointer);
234923 : // Milind Chabbi (8/28/2013): isSgElementwiseSubtractOp uses table-driven castability instead of c++ default dynamic_cast
234924 : // this improves the running time performance by 10-20%.
234925 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgElementwiseSubtractOp*>(inputDerivedClassPointer);
234926 0 : return IS_SgElementwiseSubtractOp_FAST_MACRO(inputDerivedClassPointer);
234927 : }
234928 :
234929 : // DQ (11/8/2003): Added version of functions taking const pointer
234930 0 : const SgElementwiseSubtractOp* isSgElementwiseSubtractOp ( const SgNode* inputDerivedClassPointer )
234931 : {
234932 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
234933 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
234934 : // So to fix this we return NULL directly when the input is NULL and avoid the
234935 : // dynamic_cast in this case. This is likely a performance improvement as well.
234936 : // return dynamic_cast<const SgElementwiseSubtractOp*>(inputDerivedClassPointer);
234937 : // Milind Chabbi (8/28/2013): isSgElementwiseSubtractOp uses table-driven castability instead of c++ default dynamic_cast
234938 : // this improves the running time performance by 10-20%.
234939 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgElementwiseSubtractOp*>(inputDerivedClassPointer);
234940 0 : return IS_SgElementwiseSubtractOp_FAST_MACRO(inputDerivedClassPointer);
234941 : }
234942 :
234943 :
234944 :
234945 : /* #line 234946 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234946 :
234947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234948 :
234949 : /**
234950 : \brief Generated destructor
234951 :
234952 : This destructor is automatically generated (by ROSETTA). This destructor
234953 : only frees memory of data members associated with the parts of the current IR node which
234954 : are NOT traversed. Those data members that are part of a traversal can be freed using
234955 : a traversal (calling this destructor on all children in a post-order traversal). Such
234956 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
234957 :
234958 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
234959 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
234960 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
234961 :
234962 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
234963 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
234964 : pointers are not yet implemented to call delete on eash pointer in the container.
234965 : (This could be done by derivation from the STL containers to define containers that
234966 : automatically deleted their members.)
234967 :
234968 : */
234969 0 : SgElementwiseSubtractOp::~SgElementwiseSubtractOp () {
234970 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
234971 :
234972 :
234973 :
234974 : }
234975 :
234976 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
234977 0 : }
234978 :
234979 :
234980 : /* #line 234981 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
234981 :
234982 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
234983 :
234984 : // Generated constructor
234985 0 : SgElementwiseSubtractOp::SgElementwiseSubtractOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
234986 0 : : SgElementwiseOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
234987 : {
234988 : #ifdef DEBUG
234989 : // printf ("In SgElementwiseSubtractOp::SgElementwiseSubtractOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
234990 : #endif
234991 : #if 0
234992 : // debugging information!
234993 : printf ("In SgElementwiseSubtractOp::SgElementwiseSubtractOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
234994 : #endif
234995 :
234996 :
234997 :
234998 : #if 0
234999 : // DQ (7/30/2014): Call a virtual function.
235000 : std::string s = this->class_name();
235001 : #endif
235002 :
235003 : // Test the variant virtual function
235004 : // assert(ELEMENT_SUBTRACT_OP == variant());
235005 0 : assert(ELEMENT_SUBTRACT_OP == this->variant());
235006 0 : ROSE_ASSERT(ELEMENT_SUBTRACT_OP == (int)(this->variantT()));
235007 0 : post_construction_initialization();
235008 :
235009 : // Test the isSgElementwiseSubtractOp() function since it has been problematic
235010 0 : assert(isSgElementwiseSubtractOp(this) != NULL);
235011 0 : }
235012 :
235013 : // Generated constructor (all data members)
235014 :
235015 : /* #line 235016 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235016 :
235017 :
235018 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235019 :
235020 :
235021 : // ********************************************************
235022 : // member functions common across all array grammar objects
235023 : // ********************************************************
235024 :
235025 :
235026 :
235027 : /* #line 235028 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235028 :
235029 :
235030 :
235031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235032 :
235033 : // ********************************************************
235034 : // member functions specific to each node in the grammar
235035 : // ********************************************************
235036 :
235037 :
235038 : /* #line 235039 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235039 :
235040 : // Start of memberFunctionString
235041 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
235042 :
235043 : void
235044 0 : SgPowerOp::post_construction_initialization()
235045 : {
235046 0 : }
235047 :
235048 :
235049 :
235050 : // End of memberFunctionString
235051 : // Start of memberFunctionString
235052 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
235053 :
235054 : // *** COMMON CODE SECTION BEGINS HERE ***
235055 :
235056 : #if 0
235057 : int
235058 : SgPowerOp::getVariant() const
235059 : {
235060 : // This function is used in ROSE while "variant()" is used in SAGE
235061 : assert(this != NULL);
235062 : return variant();
235063 : }
235064 : #endif
235065 :
235066 : // This function is used in ROSE in treeTraversal code
235067 : // eventually replaces getVariant() and variant()
235068 : // though after variant() has been removed for a while we will
235069 : // want to change the name of variantT() back to variant()
235070 : // (since the "T" was ment to stand for temporary).
235071 : // When this happens the variantT() will be depricated.
235072 : VariantT
235073 0 : SgPowerOp::variantT() const
235074 : {
235075 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
235076 0 : ROSE_ASSERT(this != NULL);
235077 0 : return V_SgPowerOp;
235078 : }
235079 :
235080 : #if 0
235081 : int
235082 : SgPowerOp::variant() const
235083 : {
235084 : // This function is used in SAGE
235085 : ROSE_ASSERT(this != NULL);
235086 : return POWER_OP;
235087 : }
235088 : #endif
235089 :
235090 : ROSE_DLL_API const char*
235091 0 : SgPowerOp::sage_class_name() const
235092 : {
235093 0 : ROSE_ASSERT(this != NULL);
235094 0 : return "SgPowerOp";
235095 : }
235096 :
235097 : std::string
235098 0 : SgPowerOp::class_name() const
235099 : {
235100 0 : ROSE_ASSERT(this != NULL);
235101 0 : return "SgPowerOp";
235102 : }
235103 :
235104 : // DQ (11/26/2005): Support for visitor pattern mechanims
235105 : // (inferior to ROSE traversal mechanism, experimental).
235106 : void
235107 0 : SgPowerOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
235108 : {
235109 0 : ROSE_ASSERT(this != NULL);
235110 0 : visitor.visit(this);
235111 0 : }
235112 :
235113 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
235114 0 : void SgPowerOp::accept (ROSE_VisitorPattern & visitor) {
235115 0 : ROSE_ASSERT(this != NULL);
235116 0 : visitor.visit(this);
235117 0 : }
235118 :
235119 : SgPowerOp*
235120 0 : SgPowerOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
235121 : {
235122 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
235123 : // This function is currently only supported for the AST used the represent Binary executables.
235124 : if (0 /* isSgAsmNode(this) != NULL */)
235125 : {
235126 : // Support for regex specification.
235127 : std::string prefixCode = "REGEX:";
235128 : addNewAttribute(prefixCode + s,a);
235129 : }
235130 : #endif
235131 :
235132 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
235133 0 : return this;
235134 : }
235135 :
235136 : // *** COMMON CODE SECTION ENDS HERE ***
235137 :
235138 :
235139 : // End of memberFunctionString
235140 : // Start of memberFunctionString
235141 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
235142 :
235143 :
235144 : #if 0
235145 : //! Error checking support
235146 : /*! Verifies the following:
235147 : - working getVariant() member function
235148 : - calls base class's error() member function
235149 : Every class has one of these functions.
235150 : */
235151 : bool
235152 : SgPowerOp::error()
235153 : {
235154 : // Put error checking here
235155 :
235156 : ROSE_ASSERT (this != NULL);
235157 : if (getVariant() != POWER_OP)
235158 : {
235159 : printf ("Error in SgPowerOp::error(): SgPowerOp object has a %s variant \n",
235160 : Cxx_GrammarTerminalNames[getVariant()].name);
235161 : // printf ("Error in SgPowerOp::error() \n");
235162 : ROSE_ABORT();
235163 : }
235164 :
235165 : ROSE_ASSERT (getVariant() == POWER_OP);
235166 : return SgBinaryOp::error();
235167 : }
235168 : #endif
235169 :
235170 :
235171 :
235172 : // End of memberFunctionString
235173 :
235174 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
235175 :
235176 0 : SgPowerOp* isSgPowerOp ( SgNode* inputDerivedClassPointer )
235177 : {
235178 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235179 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235180 : // So to fix this we return NULL directly when the input is NULL and avoid the
235181 : // dynamic_cast in this case. This is likely a performance improvement as well.
235182 : // return dynamic_cast<SgPowerOp*>(inputDerivedClassPointer);
235183 : // Milind Chabbi (8/28/2013): isSgPowerOp uses table-driven castability instead of c++ default dynamic_cast
235184 : // this improves the running time performance by 10-20%.
235185 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPowerOp*>(inputDerivedClassPointer);
235186 0 : return IS_SgPowerOp_FAST_MACRO(inputDerivedClassPointer);
235187 : }
235188 :
235189 : // DQ (11/8/2003): Added version of functions taking const pointer
235190 0 : const SgPowerOp* isSgPowerOp ( const SgNode* inputDerivedClassPointer )
235191 : {
235192 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235193 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235194 : // So to fix this we return NULL directly when the input is NULL and avoid the
235195 : // dynamic_cast in this case. This is likely a performance improvement as well.
235196 : // return dynamic_cast<const SgPowerOp*>(inputDerivedClassPointer);
235197 : // Milind Chabbi (8/28/2013): isSgPowerOp uses table-driven castability instead of c++ default dynamic_cast
235198 : // this improves the running time performance by 10-20%.
235199 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPowerOp*>(inputDerivedClassPointer);
235200 0 : return IS_SgPowerOp_FAST_MACRO(inputDerivedClassPointer);
235201 : }
235202 :
235203 :
235204 :
235205 : /* #line 235206 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235206 :
235207 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235208 :
235209 : /**
235210 : \brief Generated destructor
235211 :
235212 : This destructor is automatically generated (by ROSETTA). This destructor
235213 : only frees memory of data members associated with the parts of the current IR node which
235214 : are NOT traversed. Those data members that are part of a traversal can be freed using
235215 : a traversal (calling this destructor on all children in a post-order traversal). Such
235216 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
235217 :
235218 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
235219 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
235220 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
235221 :
235222 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
235223 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
235224 : pointers are not yet implemented to call delete on eash pointer in the container.
235225 : (This could be done by derivation from the STL containers to define containers that
235226 : automatically deleted their members.)
235227 :
235228 : */
235229 0 : SgPowerOp::~SgPowerOp () {
235230 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
235231 :
235232 :
235233 :
235234 : }
235235 :
235236 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235237 0 : }
235238 :
235239 :
235240 : /* #line 235241 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235241 :
235242 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
235243 :
235244 : // Generated constructor
235245 0 : SgPowerOp::SgPowerOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
235246 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
235247 : {
235248 : #ifdef DEBUG
235249 : // printf ("In SgPowerOp::SgPowerOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
235250 : #endif
235251 : #if 0
235252 : // debugging information!
235253 : printf ("In SgPowerOp::SgPowerOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
235254 : #endif
235255 :
235256 :
235257 :
235258 : #if 0
235259 : // DQ (7/30/2014): Call a virtual function.
235260 : std::string s = this->class_name();
235261 : #endif
235262 :
235263 : // Test the variant virtual function
235264 : // assert(POWER_OP == variant());
235265 0 : assert(POWER_OP == this->variant());
235266 0 : ROSE_ASSERT(POWER_OP == (int)(this->variantT()));
235267 0 : post_construction_initialization();
235268 :
235269 : // Test the isSgPowerOp() function since it has been problematic
235270 0 : assert(isSgPowerOp(this) != NULL);
235271 0 : }
235272 :
235273 : // Generated constructor (all data members)
235274 :
235275 : /* #line 235276 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235276 :
235277 :
235278 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235279 :
235280 :
235281 : // ********************************************************
235282 : // member functions common across all array grammar objects
235283 : // ********************************************************
235284 :
235285 :
235286 :
235287 : /* #line 235288 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235288 :
235289 :
235290 :
235291 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235292 :
235293 : // ********************************************************
235294 : // member functions specific to each node in the grammar
235295 : // ********************************************************
235296 :
235297 :
235298 : /* #line 235299 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235299 :
235300 : // Start of memberFunctionString
235301 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
235302 :
235303 : void
235304 0 : SgLeftDivideOp::post_construction_initialization()
235305 : {
235306 0 : }
235307 :
235308 :
235309 :
235310 : // End of memberFunctionString
235311 : // Start of memberFunctionString
235312 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
235313 :
235314 : // *** COMMON CODE SECTION BEGINS HERE ***
235315 :
235316 : #if 0
235317 : int
235318 : SgLeftDivideOp::getVariant() const
235319 : {
235320 : // This function is used in ROSE while "variant()" is used in SAGE
235321 : assert(this != NULL);
235322 : return variant();
235323 : }
235324 : #endif
235325 :
235326 : // This function is used in ROSE in treeTraversal code
235327 : // eventually replaces getVariant() and variant()
235328 : // though after variant() has been removed for a while we will
235329 : // want to change the name of variantT() back to variant()
235330 : // (since the "T" was ment to stand for temporary).
235331 : // When this happens the variantT() will be depricated.
235332 : VariantT
235333 0 : SgLeftDivideOp::variantT() const
235334 : {
235335 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
235336 0 : ROSE_ASSERT(this != NULL);
235337 0 : return V_SgLeftDivideOp;
235338 : }
235339 :
235340 : #if 0
235341 : int
235342 : SgLeftDivideOp::variant() const
235343 : {
235344 : // This function is used in SAGE
235345 : ROSE_ASSERT(this != NULL);
235346 : return LEFT_DIVIDE_OP;
235347 : }
235348 : #endif
235349 :
235350 : ROSE_DLL_API const char*
235351 0 : SgLeftDivideOp::sage_class_name() const
235352 : {
235353 0 : ROSE_ASSERT(this != NULL);
235354 0 : return "SgLeftDivideOp";
235355 : }
235356 :
235357 : std::string
235358 0 : SgLeftDivideOp::class_name() const
235359 : {
235360 0 : ROSE_ASSERT(this != NULL);
235361 0 : return "SgLeftDivideOp";
235362 : }
235363 :
235364 : // DQ (11/26/2005): Support for visitor pattern mechanims
235365 : // (inferior to ROSE traversal mechanism, experimental).
235366 : void
235367 0 : SgLeftDivideOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
235368 : {
235369 0 : ROSE_ASSERT(this != NULL);
235370 0 : visitor.visit(this);
235371 0 : }
235372 :
235373 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
235374 0 : void SgLeftDivideOp::accept (ROSE_VisitorPattern & visitor) {
235375 0 : ROSE_ASSERT(this != NULL);
235376 0 : visitor.visit(this);
235377 0 : }
235378 :
235379 : SgLeftDivideOp*
235380 0 : SgLeftDivideOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
235381 : {
235382 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
235383 : // This function is currently only supported for the AST used the represent Binary executables.
235384 : if (0 /* isSgAsmNode(this) != NULL */)
235385 : {
235386 : // Support for regex specification.
235387 : std::string prefixCode = "REGEX:";
235388 : addNewAttribute(prefixCode + s,a);
235389 : }
235390 : #endif
235391 :
235392 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
235393 0 : return this;
235394 : }
235395 :
235396 : // *** COMMON CODE SECTION ENDS HERE ***
235397 :
235398 :
235399 : // End of memberFunctionString
235400 : // Start of memberFunctionString
235401 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
235402 :
235403 :
235404 : #if 0
235405 : //! Error checking support
235406 : /*! Verifies the following:
235407 : - working getVariant() member function
235408 : - calls base class's error() member function
235409 : Every class has one of these functions.
235410 : */
235411 : bool
235412 : SgLeftDivideOp::error()
235413 : {
235414 : // Put error checking here
235415 :
235416 : ROSE_ASSERT (this != NULL);
235417 : if (getVariant() != LEFT_DIVIDE_OP)
235418 : {
235419 : printf ("Error in SgLeftDivideOp::error(): SgLeftDivideOp object has a %s variant \n",
235420 : Cxx_GrammarTerminalNames[getVariant()].name);
235421 : // printf ("Error in SgLeftDivideOp::error() \n");
235422 : ROSE_ABORT();
235423 : }
235424 :
235425 : ROSE_ASSERT (getVariant() == LEFT_DIVIDE_OP);
235426 : return SgBinaryOp::error();
235427 : }
235428 : #endif
235429 :
235430 :
235431 :
235432 : // End of memberFunctionString
235433 :
235434 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
235435 :
235436 0 : SgLeftDivideOp* isSgLeftDivideOp ( SgNode* inputDerivedClassPointer )
235437 : {
235438 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235439 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235440 : // So to fix this we return NULL directly when the input is NULL and avoid the
235441 : // dynamic_cast in this case. This is likely a performance improvement as well.
235442 : // return dynamic_cast<SgLeftDivideOp*>(inputDerivedClassPointer);
235443 : // Milind Chabbi (8/28/2013): isSgLeftDivideOp uses table-driven castability instead of c++ default dynamic_cast
235444 : // this improves the running time performance by 10-20%.
235445 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLeftDivideOp*>(inputDerivedClassPointer);
235446 0 : return IS_SgLeftDivideOp_FAST_MACRO(inputDerivedClassPointer);
235447 : }
235448 :
235449 : // DQ (11/8/2003): Added version of functions taking const pointer
235450 0 : const SgLeftDivideOp* isSgLeftDivideOp ( const SgNode* inputDerivedClassPointer )
235451 : {
235452 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235453 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235454 : // So to fix this we return NULL directly when the input is NULL and avoid the
235455 : // dynamic_cast in this case. This is likely a performance improvement as well.
235456 : // return dynamic_cast<const SgLeftDivideOp*>(inputDerivedClassPointer);
235457 : // Milind Chabbi (8/28/2013): isSgLeftDivideOp uses table-driven castability instead of c++ default dynamic_cast
235458 : // this improves the running time performance by 10-20%.
235459 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLeftDivideOp*>(inputDerivedClassPointer);
235460 0 : return IS_SgLeftDivideOp_FAST_MACRO(inputDerivedClassPointer);
235461 : }
235462 :
235463 :
235464 :
235465 : /* #line 235466 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235466 :
235467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235468 :
235469 : /**
235470 : \brief Generated destructor
235471 :
235472 : This destructor is automatically generated (by ROSETTA). This destructor
235473 : only frees memory of data members associated with the parts of the current IR node which
235474 : are NOT traversed. Those data members that are part of a traversal can be freed using
235475 : a traversal (calling this destructor on all children in a post-order traversal). Such
235476 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
235477 :
235478 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
235479 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
235480 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
235481 :
235482 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
235483 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
235484 : pointers are not yet implemented to call delete on eash pointer in the container.
235485 : (This could be done by derivation from the STL containers to define containers that
235486 : automatically deleted their members.)
235487 :
235488 : */
235489 0 : SgLeftDivideOp::~SgLeftDivideOp () {
235490 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
235491 :
235492 :
235493 :
235494 : }
235495 :
235496 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235497 0 : }
235498 :
235499 :
235500 : /* #line 235501 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235501 :
235502 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
235503 :
235504 : // Generated constructor
235505 0 : SgLeftDivideOp::SgLeftDivideOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
235506 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
235507 : {
235508 : #ifdef DEBUG
235509 : // printf ("In SgLeftDivideOp::SgLeftDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
235510 : #endif
235511 : #if 0
235512 : // debugging information!
235513 : printf ("In SgLeftDivideOp::SgLeftDivideOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
235514 : #endif
235515 :
235516 :
235517 :
235518 : #if 0
235519 : // DQ (7/30/2014): Call a virtual function.
235520 : std::string s = this->class_name();
235521 : #endif
235522 :
235523 : // Test the variant virtual function
235524 : // assert(LEFT_DIVIDE_OP == variant());
235525 0 : assert(LEFT_DIVIDE_OP == this->variant());
235526 0 : ROSE_ASSERT(LEFT_DIVIDE_OP == (int)(this->variantT()));
235527 0 : post_construction_initialization();
235528 :
235529 : // Test the isSgLeftDivideOp() function since it has been problematic
235530 0 : assert(isSgLeftDivideOp(this) != NULL);
235531 0 : }
235532 :
235533 : // Generated constructor (all data members)
235534 :
235535 : /* #line 235536 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235536 :
235537 :
235538 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235539 :
235540 :
235541 : // ********************************************************
235542 : // member functions common across all array grammar objects
235543 : // ********************************************************
235544 :
235545 :
235546 :
235547 : /* #line 235548 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235548 :
235549 :
235550 :
235551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235552 :
235553 : // ********************************************************
235554 : // member functions specific to each node in the grammar
235555 : // ********************************************************
235556 :
235557 :
235558 : /* #line 235559 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235559 :
235560 : // Start of memberFunctionString
235561 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
235562 :
235563 : void
235564 0 : SgSIMDBinaryOp::post_construction_initialization()
235565 : {
235566 0 : }
235567 :
235568 :
235569 :
235570 : // End of memberFunctionString
235571 : // Start of memberFunctionString
235572 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
235573 :
235574 : // *** COMMON CODE SECTION BEGINS HERE ***
235575 :
235576 : #if 0
235577 : int
235578 : SgSIMDBinaryOp::getVariant() const
235579 : {
235580 : // This function is used in ROSE while "variant()" is used in SAGE
235581 : assert(this != NULL);
235582 : return variant();
235583 : }
235584 : #endif
235585 :
235586 : // This function is used in ROSE in treeTraversal code
235587 : // eventually replaces getVariant() and variant()
235588 : // though after variant() has been removed for a while we will
235589 : // want to change the name of variantT() back to variant()
235590 : // (since the "T" was ment to stand for temporary).
235591 : // When this happens the variantT() will be depricated.
235592 : VariantT
235593 0 : SgSIMDBinaryOp::variantT() const
235594 : {
235595 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
235596 0 : ROSE_ASSERT(this != NULL);
235597 0 : return V_SgSIMDBinaryOp;
235598 : }
235599 :
235600 : #if 0
235601 : int
235602 : SgSIMDBinaryOp::variant() const
235603 : {
235604 : // This function is used in SAGE
235605 : ROSE_ASSERT(this != NULL);
235606 : return SIMD_BINARY_OP;
235607 : }
235608 : #endif
235609 :
235610 : ROSE_DLL_API const char*
235611 0 : SgSIMDBinaryOp::sage_class_name() const
235612 : {
235613 0 : ROSE_ASSERT(this != NULL);
235614 0 : return "SgSIMDBinaryOp";
235615 : }
235616 :
235617 : std::string
235618 0 : SgSIMDBinaryOp::class_name() const
235619 : {
235620 0 : ROSE_ASSERT(this != NULL);
235621 0 : return "SgSIMDBinaryOp";
235622 : }
235623 :
235624 : // DQ (11/26/2005): Support for visitor pattern mechanims
235625 : // (inferior to ROSE traversal mechanism, experimental).
235626 : void
235627 0 : SgSIMDBinaryOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
235628 : {
235629 0 : ROSE_ASSERT(this != NULL);
235630 0 : visitor.visit(this);
235631 0 : }
235632 :
235633 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
235634 0 : void SgSIMDBinaryOp::accept (ROSE_VisitorPattern & visitor) {
235635 0 : ROSE_ASSERT(this != NULL);
235636 0 : visitor.visit(this);
235637 0 : }
235638 :
235639 : SgSIMDBinaryOp*
235640 0 : SgSIMDBinaryOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
235641 : {
235642 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
235643 : // This function is currently only supported for the AST used the represent Binary executables.
235644 : if (0 /* isSgAsmNode(this) != NULL */)
235645 : {
235646 : // Support for regex specification.
235647 : std::string prefixCode = "REGEX:";
235648 : addNewAttribute(prefixCode + s,a);
235649 : }
235650 : #endif
235651 :
235652 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
235653 0 : return this;
235654 : }
235655 :
235656 : // *** COMMON CODE SECTION ENDS HERE ***
235657 :
235658 :
235659 : // End of memberFunctionString
235660 : // Start of memberFunctionString
235661 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
235662 :
235663 :
235664 : #if 0
235665 : //! Error checking support
235666 : /*! Verifies the following:
235667 : - working getVariant() member function
235668 : - calls base class's error() member function
235669 : Every class has one of these functions.
235670 : */
235671 : bool
235672 : SgSIMDBinaryOp::error()
235673 : {
235674 : // Put error checking here
235675 :
235676 : ROSE_ASSERT (this != NULL);
235677 : if (getVariant() != SIMD_BINARY_OP)
235678 : {
235679 : printf ("Error in SgSIMDBinaryOp::error(): SgSIMDBinaryOp object has a %s variant \n",
235680 : Cxx_GrammarTerminalNames[getVariant()].name);
235681 : // printf ("Error in SgSIMDBinaryOp::error() \n");
235682 : ROSE_ABORT();
235683 : }
235684 :
235685 : ROSE_ASSERT (getVariant() == SIMD_BINARY_OP);
235686 : return SgBinaryOp::error();
235687 : }
235688 : #endif
235689 :
235690 :
235691 :
235692 : // End of memberFunctionString
235693 :
235694 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
235695 :
235696 0 : SgSIMDBinaryOp* isSgSIMDBinaryOp ( SgNode* inputDerivedClassPointer )
235697 : {
235698 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235699 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235700 : // So to fix this we return NULL directly when the input is NULL and avoid the
235701 : // dynamic_cast in this case. This is likely a performance improvement as well.
235702 : // return dynamic_cast<SgSIMDBinaryOp*>(inputDerivedClassPointer);
235703 : // Milind Chabbi (8/28/2013): isSgSIMDBinaryOp uses table-driven castability instead of c++ default dynamic_cast
235704 : // this improves the running time performance by 10-20%.
235705 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDBinaryOp*>(inputDerivedClassPointer);
235706 0 : return IS_SgSIMDBinaryOp_FAST_MACRO(inputDerivedClassPointer);
235707 : }
235708 :
235709 : // DQ (11/8/2003): Added version of functions taking const pointer
235710 0 : const SgSIMDBinaryOp* isSgSIMDBinaryOp ( const SgNode* inputDerivedClassPointer )
235711 : {
235712 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235713 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235714 : // So to fix this we return NULL directly when the input is NULL and avoid the
235715 : // dynamic_cast in this case. This is likely a performance improvement as well.
235716 : // return dynamic_cast<const SgSIMDBinaryOp*>(inputDerivedClassPointer);
235717 : // Milind Chabbi (8/28/2013): isSgSIMDBinaryOp uses table-driven castability instead of c++ default dynamic_cast
235718 : // this improves the running time performance by 10-20%.
235719 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDBinaryOp*>(inputDerivedClassPointer);
235720 0 : return IS_SgSIMDBinaryOp_FAST_MACRO(inputDerivedClassPointer);
235721 : }
235722 :
235723 :
235724 :
235725 : /* #line 235726 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235726 :
235727 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235728 :
235729 : /**
235730 : \brief Generated destructor
235731 :
235732 : This destructor is automatically generated (by ROSETTA). This destructor
235733 : only frees memory of data members associated with the parts of the current IR node which
235734 : are NOT traversed. Those data members that are part of a traversal can be freed using
235735 : a traversal (calling this destructor on all children in a post-order traversal). Such
235736 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
235737 :
235738 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
235739 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
235740 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
235741 :
235742 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
235743 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
235744 : pointers are not yet implemented to call delete on eash pointer in the container.
235745 : (This could be done by derivation from the STL containers to define containers that
235746 : automatically deleted their members.)
235747 :
235748 : */
235749 0 : SgSIMDBinaryOp::~SgSIMDBinaryOp () {
235750 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
235751 :
235752 :
235753 :
235754 : }
235755 :
235756 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235757 0 : }
235758 :
235759 :
235760 : /* #line 235761 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235761 :
235762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
235763 :
235764 : // Generated constructor
235765 0 : SgSIMDBinaryOp::SgSIMDBinaryOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
235766 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
235767 : {
235768 : #ifdef DEBUG
235769 : // printf ("In SgSIMDBinaryOp::SgSIMDBinaryOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
235770 : #endif
235771 : #if 0
235772 : // debugging information!
235773 : printf ("In SgSIMDBinaryOp::SgSIMDBinaryOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
235774 : #endif
235775 :
235776 :
235777 :
235778 : #if 0
235779 : // DQ (7/30/2014): Call a virtual function.
235780 : std::string s = this->class_name();
235781 : #endif
235782 :
235783 : // Test the variant virtual function
235784 : // assert(SIMD_BINARY_OP == variant());
235785 0 : assert(SIMD_BINARY_OP == this->variant());
235786 0 : ROSE_ASSERT(SIMD_BINARY_OP == (int)(this->variantT()));
235787 0 : post_construction_initialization();
235788 :
235789 : // Test the isSgSIMDBinaryOp() function since it has been problematic
235790 0 : assert(isSgSIMDBinaryOp(this) != NULL);
235791 0 : }
235792 :
235793 : // Generated constructor (all data members)
235794 :
235795 : /* #line 235796 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235796 :
235797 :
235798 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235799 :
235800 :
235801 : // ********************************************************
235802 : // member functions common across all array grammar objects
235803 : // ********************************************************
235804 :
235805 :
235806 :
235807 : /* #line 235808 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235808 :
235809 :
235810 :
235811 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
235812 :
235813 : // ********************************************************
235814 : // member functions specific to each node in the grammar
235815 : // ********************************************************
235816 :
235817 :
235818 : /* #line 235819 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235819 :
235820 : // Start of memberFunctionString
235821 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
235822 :
235823 : void
235824 0 : SgSIMDAddOp::post_construction_initialization()
235825 : {
235826 0 : }
235827 :
235828 :
235829 :
235830 : // End of memberFunctionString
235831 : // Start of memberFunctionString
235832 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
235833 :
235834 : // *** COMMON CODE SECTION BEGINS HERE ***
235835 :
235836 : #if 0
235837 : int
235838 : SgSIMDAddOp::getVariant() const
235839 : {
235840 : // This function is used in ROSE while "variant()" is used in SAGE
235841 : assert(this != NULL);
235842 : return variant();
235843 : }
235844 : #endif
235845 :
235846 : // This function is used in ROSE in treeTraversal code
235847 : // eventually replaces getVariant() and variant()
235848 : // though after variant() has been removed for a while we will
235849 : // want to change the name of variantT() back to variant()
235850 : // (since the "T" was ment to stand for temporary).
235851 : // When this happens the variantT() will be depricated.
235852 : VariantT
235853 0 : SgSIMDAddOp::variantT() const
235854 : {
235855 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
235856 0 : ROSE_ASSERT(this != NULL);
235857 0 : return V_SgSIMDAddOp;
235858 : }
235859 :
235860 : #if 0
235861 : int
235862 : SgSIMDAddOp::variant() const
235863 : {
235864 : // This function is used in SAGE
235865 : ROSE_ASSERT(this != NULL);
235866 : return SIMD_ADD_OP;
235867 : }
235868 : #endif
235869 :
235870 : ROSE_DLL_API const char*
235871 0 : SgSIMDAddOp::sage_class_name() const
235872 : {
235873 0 : ROSE_ASSERT(this != NULL);
235874 0 : return "SgSIMDAddOp";
235875 : }
235876 :
235877 : std::string
235878 0 : SgSIMDAddOp::class_name() const
235879 : {
235880 0 : ROSE_ASSERT(this != NULL);
235881 0 : return "SgSIMDAddOp";
235882 : }
235883 :
235884 : // DQ (11/26/2005): Support for visitor pattern mechanims
235885 : // (inferior to ROSE traversal mechanism, experimental).
235886 : void
235887 0 : SgSIMDAddOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
235888 : {
235889 0 : ROSE_ASSERT(this != NULL);
235890 0 : visitor.visit(this);
235891 0 : }
235892 :
235893 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
235894 0 : void SgSIMDAddOp::accept (ROSE_VisitorPattern & visitor) {
235895 0 : ROSE_ASSERT(this != NULL);
235896 0 : visitor.visit(this);
235897 0 : }
235898 :
235899 : SgSIMDAddOp*
235900 0 : SgSIMDAddOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
235901 : {
235902 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
235903 : // This function is currently only supported for the AST used the represent Binary executables.
235904 : if (0 /* isSgAsmNode(this) != NULL */)
235905 : {
235906 : // Support for regex specification.
235907 : std::string prefixCode = "REGEX:";
235908 : addNewAttribute(prefixCode + s,a);
235909 : }
235910 : #endif
235911 :
235912 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
235913 0 : return this;
235914 : }
235915 :
235916 : // *** COMMON CODE SECTION ENDS HERE ***
235917 :
235918 :
235919 : // End of memberFunctionString
235920 : // Start of memberFunctionString
235921 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
235922 :
235923 :
235924 : #if 0
235925 : //! Error checking support
235926 : /*! Verifies the following:
235927 : - working getVariant() member function
235928 : - calls base class's error() member function
235929 : Every class has one of these functions.
235930 : */
235931 : bool
235932 : SgSIMDAddOp::error()
235933 : {
235934 : // Put error checking here
235935 :
235936 : ROSE_ASSERT (this != NULL);
235937 : if (getVariant() != SIMD_ADD_OP)
235938 : {
235939 : printf ("Error in SgSIMDAddOp::error(): SgSIMDAddOp object has a %s variant \n",
235940 : Cxx_GrammarTerminalNames[getVariant()].name);
235941 : // printf ("Error in SgSIMDAddOp::error() \n");
235942 : ROSE_ABORT();
235943 : }
235944 :
235945 : ROSE_ASSERT (getVariant() == SIMD_ADD_OP);
235946 : return SgSIMDBinaryOp::error();
235947 : }
235948 : #endif
235949 :
235950 :
235951 :
235952 : // End of memberFunctionString
235953 :
235954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
235955 :
235956 0 : SgSIMDAddOp* isSgSIMDAddOp ( SgNode* inputDerivedClassPointer )
235957 : {
235958 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235959 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235960 : // So to fix this we return NULL directly when the input is NULL and avoid the
235961 : // dynamic_cast in this case. This is likely a performance improvement as well.
235962 : // return dynamic_cast<SgSIMDAddOp*>(inputDerivedClassPointer);
235963 : // Milind Chabbi (8/28/2013): isSgSIMDAddOp uses table-driven castability instead of c++ default dynamic_cast
235964 : // this improves the running time performance by 10-20%.
235965 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDAddOp*>(inputDerivedClassPointer);
235966 0 : return IS_SgSIMDAddOp_FAST_MACRO(inputDerivedClassPointer);
235967 : }
235968 :
235969 : // DQ (11/8/2003): Added version of functions taking const pointer
235970 0 : const SgSIMDAddOp* isSgSIMDAddOp ( const SgNode* inputDerivedClassPointer )
235971 : {
235972 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
235973 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
235974 : // So to fix this we return NULL directly when the input is NULL and avoid the
235975 : // dynamic_cast in this case. This is likely a performance improvement as well.
235976 : // return dynamic_cast<const SgSIMDAddOp*>(inputDerivedClassPointer);
235977 : // Milind Chabbi (8/28/2013): isSgSIMDAddOp uses table-driven castability instead of c++ default dynamic_cast
235978 : // this improves the running time performance by 10-20%.
235979 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDAddOp*>(inputDerivedClassPointer);
235980 0 : return IS_SgSIMDAddOp_FAST_MACRO(inputDerivedClassPointer);
235981 : }
235982 :
235983 :
235984 :
235985 : /* #line 235986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
235986 :
235987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
235988 :
235989 : /**
235990 : \brief Generated destructor
235991 :
235992 : This destructor is automatically generated (by ROSETTA). This destructor
235993 : only frees memory of data members associated with the parts of the current IR node which
235994 : are NOT traversed. Those data members that are part of a traversal can be freed using
235995 : a traversal (calling this destructor on all children in a post-order traversal). Such
235996 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
235997 :
235998 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
235999 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
236000 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
236001 :
236002 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
236003 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
236004 : pointers are not yet implemented to call delete on eash pointer in the container.
236005 : (This could be done by derivation from the STL containers to define containers that
236006 : automatically deleted their members.)
236007 :
236008 : */
236009 0 : SgSIMDAddOp::~SgSIMDAddOp () {
236010 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
236011 :
236012 :
236013 :
236014 : }
236015 :
236016 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236017 0 : }
236018 :
236019 :
236020 : /* #line 236021 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236021 :
236022 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
236023 :
236024 : // Generated constructor
236025 0 : SgSIMDAddOp::SgSIMDAddOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
236026 0 : : SgSIMDBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
236027 : {
236028 : #ifdef DEBUG
236029 : // printf ("In SgSIMDAddOp::SgSIMDAddOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
236030 : #endif
236031 : #if 0
236032 : // debugging information!
236033 : printf ("In SgSIMDAddOp::SgSIMDAddOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
236034 : #endif
236035 :
236036 :
236037 :
236038 : #if 0
236039 : // DQ (7/30/2014): Call a virtual function.
236040 : std::string s = this->class_name();
236041 : #endif
236042 :
236043 : // Test the variant virtual function
236044 : // assert(SIMD_ADD_OP == variant());
236045 0 : assert(SIMD_ADD_OP == this->variant());
236046 0 : ROSE_ASSERT(SIMD_ADD_OP == (int)(this->variantT()));
236047 0 : post_construction_initialization();
236048 :
236049 : // Test the isSgSIMDAddOp() function since it has been problematic
236050 0 : assert(isSgSIMDAddOp(this) != NULL);
236051 0 : }
236052 :
236053 : // Generated constructor (all data members)
236054 :
236055 : /* #line 236056 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236056 :
236057 :
236058 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236059 :
236060 :
236061 : // ********************************************************
236062 : // member functions common across all array grammar objects
236063 : // ********************************************************
236064 :
236065 :
236066 :
236067 : /* #line 236068 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236068 :
236069 :
236070 :
236071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236072 :
236073 : // ********************************************************
236074 : // member functions specific to each node in the grammar
236075 : // ********************************************************
236076 :
236077 :
236078 : /* #line 236079 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236079 :
236080 : // Start of memberFunctionString
236081 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
236082 :
236083 : void
236084 0 : SgSIMDSubOp::post_construction_initialization()
236085 : {
236086 0 : }
236087 :
236088 :
236089 :
236090 : // End of memberFunctionString
236091 : // Start of memberFunctionString
236092 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
236093 :
236094 : // *** COMMON CODE SECTION BEGINS HERE ***
236095 :
236096 : #if 0
236097 : int
236098 : SgSIMDSubOp::getVariant() const
236099 : {
236100 : // This function is used in ROSE while "variant()" is used in SAGE
236101 : assert(this != NULL);
236102 : return variant();
236103 : }
236104 : #endif
236105 :
236106 : // This function is used in ROSE in treeTraversal code
236107 : // eventually replaces getVariant() and variant()
236108 : // though after variant() has been removed for a while we will
236109 : // want to change the name of variantT() back to variant()
236110 : // (since the "T" was ment to stand for temporary).
236111 : // When this happens the variantT() will be depricated.
236112 : VariantT
236113 0 : SgSIMDSubOp::variantT() const
236114 : {
236115 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
236116 0 : ROSE_ASSERT(this != NULL);
236117 0 : return V_SgSIMDSubOp;
236118 : }
236119 :
236120 : #if 0
236121 : int
236122 : SgSIMDSubOp::variant() const
236123 : {
236124 : // This function is used in SAGE
236125 : ROSE_ASSERT(this != NULL);
236126 : return SIMD_SUB_OP;
236127 : }
236128 : #endif
236129 :
236130 : ROSE_DLL_API const char*
236131 0 : SgSIMDSubOp::sage_class_name() const
236132 : {
236133 0 : ROSE_ASSERT(this != NULL);
236134 0 : return "SgSIMDSubOp";
236135 : }
236136 :
236137 : std::string
236138 0 : SgSIMDSubOp::class_name() const
236139 : {
236140 0 : ROSE_ASSERT(this != NULL);
236141 0 : return "SgSIMDSubOp";
236142 : }
236143 :
236144 : // DQ (11/26/2005): Support for visitor pattern mechanims
236145 : // (inferior to ROSE traversal mechanism, experimental).
236146 : void
236147 0 : SgSIMDSubOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
236148 : {
236149 0 : ROSE_ASSERT(this != NULL);
236150 0 : visitor.visit(this);
236151 0 : }
236152 :
236153 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
236154 0 : void SgSIMDSubOp::accept (ROSE_VisitorPattern & visitor) {
236155 0 : ROSE_ASSERT(this != NULL);
236156 0 : visitor.visit(this);
236157 0 : }
236158 :
236159 : SgSIMDSubOp*
236160 0 : SgSIMDSubOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
236161 : {
236162 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
236163 : // This function is currently only supported for the AST used the represent Binary executables.
236164 : if (0 /* isSgAsmNode(this) != NULL */)
236165 : {
236166 : // Support for regex specification.
236167 : std::string prefixCode = "REGEX:";
236168 : addNewAttribute(prefixCode + s,a);
236169 : }
236170 : #endif
236171 :
236172 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
236173 0 : return this;
236174 : }
236175 :
236176 : // *** COMMON CODE SECTION ENDS HERE ***
236177 :
236178 :
236179 : // End of memberFunctionString
236180 : // Start of memberFunctionString
236181 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
236182 :
236183 :
236184 : #if 0
236185 : //! Error checking support
236186 : /*! Verifies the following:
236187 : - working getVariant() member function
236188 : - calls base class's error() member function
236189 : Every class has one of these functions.
236190 : */
236191 : bool
236192 : SgSIMDSubOp::error()
236193 : {
236194 : // Put error checking here
236195 :
236196 : ROSE_ASSERT (this != NULL);
236197 : if (getVariant() != SIMD_SUB_OP)
236198 : {
236199 : printf ("Error in SgSIMDSubOp::error(): SgSIMDSubOp object has a %s variant \n",
236200 : Cxx_GrammarTerminalNames[getVariant()].name);
236201 : // printf ("Error in SgSIMDSubOp::error() \n");
236202 : ROSE_ABORT();
236203 : }
236204 :
236205 : ROSE_ASSERT (getVariant() == SIMD_SUB_OP);
236206 : return SgSIMDBinaryOp::error();
236207 : }
236208 : #endif
236209 :
236210 :
236211 :
236212 : // End of memberFunctionString
236213 :
236214 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
236215 :
236216 0 : SgSIMDSubOp* isSgSIMDSubOp ( SgNode* inputDerivedClassPointer )
236217 : {
236218 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236219 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
236220 : // So to fix this we return NULL directly when the input is NULL and avoid the
236221 : // dynamic_cast in this case. This is likely a performance improvement as well.
236222 : // return dynamic_cast<SgSIMDSubOp*>(inputDerivedClassPointer);
236223 : // Milind Chabbi (8/28/2013): isSgSIMDSubOp uses table-driven castability instead of c++ default dynamic_cast
236224 : // this improves the running time performance by 10-20%.
236225 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDSubOp*>(inputDerivedClassPointer);
236226 0 : return IS_SgSIMDSubOp_FAST_MACRO(inputDerivedClassPointer);
236227 : }
236228 :
236229 : // DQ (11/8/2003): Added version of functions taking const pointer
236230 0 : const SgSIMDSubOp* isSgSIMDSubOp ( const SgNode* inputDerivedClassPointer )
236231 : {
236232 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236233 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
236234 : // So to fix this we return NULL directly when the input is NULL and avoid the
236235 : // dynamic_cast in this case. This is likely a performance improvement as well.
236236 : // return dynamic_cast<const SgSIMDSubOp*>(inputDerivedClassPointer);
236237 : // Milind Chabbi (8/28/2013): isSgSIMDSubOp uses table-driven castability instead of c++ default dynamic_cast
236238 : // this improves the running time performance by 10-20%.
236239 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDSubOp*>(inputDerivedClassPointer);
236240 0 : return IS_SgSIMDSubOp_FAST_MACRO(inputDerivedClassPointer);
236241 : }
236242 :
236243 :
236244 :
236245 : /* #line 236246 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236246 :
236247 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236248 :
236249 : /**
236250 : \brief Generated destructor
236251 :
236252 : This destructor is automatically generated (by ROSETTA). This destructor
236253 : only frees memory of data members associated with the parts of the current IR node which
236254 : are NOT traversed. Those data members that are part of a traversal can be freed using
236255 : a traversal (calling this destructor on all children in a post-order traversal). Such
236256 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
236257 :
236258 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
236259 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
236260 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
236261 :
236262 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
236263 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
236264 : pointers are not yet implemented to call delete on eash pointer in the container.
236265 : (This could be done by derivation from the STL containers to define containers that
236266 : automatically deleted their members.)
236267 :
236268 : */
236269 0 : SgSIMDSubOp::~SgSIMDSubOp () {
236270 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
236271 :
236272 :
236273 :
236274 : }
236275 :
236276 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236277 0 : }
236278 :
236279 :
236280 : /* #line 236281 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236281 :
236282 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
236283 :
236284 : // Generated constructor
236285 0 : SgSIMDSubOp::SgSIMDSubOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
236286 0 : : SgSIMDBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
236287 : {
236288 : #ifdef DEBUG
236289 : // printf ("In SgSIMDSubOp::SgSIMDSubOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
236290 : #endif
236291 : #if 0
236292 : // debugging information!
236293 : printf ("In SgSIMDSubOp::SgSIMDSubOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
236294 : #endif
236295 :
236296 :
236297 :
236298 : #if 0
236299 : // DQ (7/30/2014): Call a virtual function.
236300 : std::string s = this->class_name();
236301 : #endif
236302 :
236303 : // Test the variant virtual function
236304 : // assert(SIMD_SUB_OP == variant());
236305 0 : assert(SIMD_SUB_OP == this->variant());
236306 0 : ROSE_ASSERT(SIMD_SUB_OP == (int)(this->variantT()));
236307 0 : post_construction_initialization();
236308 :
236309 : // Test the isSgSIMDSubOp() function since it has been problematic
236310 0 : assert(isSgSIMDSubOp(this) != NULL);
236311 0 : }
236312 :
236313 : // Generated constructor (all data members)
236314 :
236315 : /* #line 236316 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236316 :
236317 :
236318 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236319 :
236320 :
236321 : // ********************************************************
236322 : // member functions common across all array grammar objects
236323 : // ********************************************************
236324 :
236325 :
236326 :
236327 : /* #line 236328 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236328 :
236329 :
236330 :
236331 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236332 :
236333 : // ********************************************************
236334 : // member functions specific to each node in the grammar
236335 : // ********************************************************
236336 :
236337 :
236338 : /* #line 236339 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236339 :
236340 : // Start of memberFunctionString
236341 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
236342 :
236343 : void
236344 0 : SgSIMDMulOp::post_construction_initialization()
236345 : {
236346 0 : }
236347 :
236348 :
236349 :
236350 : // End of memberFunctionString
236351 : // Start of memberFunctionString
236352 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
236353 :
236354 : // *** COMMON CODE SECTION BEGINS HERE ***
236355 :
236356 : #if 0
236357 : int
236358 : SgSIMDMulOp::getVariant() const
236359 : {
236360 : // This function is used in ROSE while "variant()" is used in SAGE
236361 : assert(this != NULL);
236362 : return variant();
236363 : }
236364 : #endif
236365 :
236366 : // This function is used in ROSE in treeTraversal code
236367 : // eventually replaces getVariant() and variant()
236368 : // though after variant() has been removed for a while we will
236369 : // want to change the name of variantT() back to variant()
236370 : // (since the "T" was ment to stand for temporary).
236371 : // When this happens the variantT() will be depricated.
236372 : VariantT
236373 0 : SgSIMDMulOp::variantT() const
236374 : {
236375 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
236376 0 : ROSE_ASSERT(this != NULL);
236377 0 : return V_SgSIMDMulOp;
236378 : }
236379 :
236380 : #if 0
236381 : int
236382 : SgSIMDMulOp::variant() const
236383 : {
236384 : // This function is used in SAGE
236385 : ROSE_ASSERT(this != NULL);
236386 : return SIMD_MUL_OP;
236387 : }
236388 : #endif
236389 :
236390 : ROSE_DLL_API const char*
236391 0 : SgSIMDMulOp::sage_class_name() const
236392 : {
236393 0 : ROSE_ASSERT(this != NULL);
236394 0 : return "SgSIMDMulOp";
236395 : }
236396 :
236397 : std::string
236398 0 : SgSIMDMulOp::class_name() const
236399 : {
236400 0 : ROSE_ASSERT(this != NULL);
236401 0 : return "SgSIMDMulOp";
236402 : }
236403 :
236404 : // DQ (11/26/2005): Support for visitor pattern mechanims
236405 : // (inferior to ROSE traversal mechanism, experimental).
236406 : void
236407 0 : SgSIMDMulOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
236408 : {
236409 0 : ROSE_ASSERT(this != NULL);
236410 0 : visitor.visit(this);
236411 0 : }
236412 :
236413 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
236414 0 : void SgSIMDMulOp::accept (ROSE_VisitorPattern & visitor) {
236415 0 : ROSE_ASSERT(this != NULL);
236416 0 : visitor.visit(this);
236417 0 : }
236418 :
236419 : SgSIMDMulOp*
236420 0 : SgSIMDMulOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
236421 : {
236422 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
236423 : // This function is currently only supported for the AST used the represent Binary executables.
236424 : if (0 /* isSgAsmNode(this) != NULL */)
236425 : {
236426 : // Support for regex specification.
236427 : std::string prefixCode = "REGEX:";
236428 : addNewAttribute(prefixCode + s,a);
236429 : }
236430 : #endif
236431 :
236432 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
236433 0 : return this;
236434 : }
236435 :
236436 : // *** COMMON CODE SECTION ENDS HERE ***
236437 :
236438 :
236439 : // End of memberFunctionString
236440 : // Start of memberFunctionString
236441 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
236442 :
236443 :
236444 : #if 0
236445 : //! Error checking support
236446 : /*! Verifies the following:
236447 : - working getVariant() member function
236448 : - calls base class's error() member function
236449 : Every class has one of these functions.
236450 : */
236451 : bool
236452 : SgSIMDMulOp::error()
236453 : {
236454 : // Put error checking here
236455 :
236456 : ROSE_ASSERT (this != NULL);
236457 : if (getVariant() != SIMD_MUL_OP)
236458 : {
236459 : printf ("Error in SgSIMDMulOp::error(): SgSIMDMulOp object has a %s variant \n",
236460 : Cxx_GrammarTerminalNames[getVariant()].name);
236461 : // printf ("Error in SgSIMDMulOp::error() \n");
236462 : ROSE_ABORT();
236463 : }
236464 :
236465 : ROSE_ASSERT (getVariant() == SIMD_MUL_OP);
236466 : return SgSIMDBinaryOp::error();
236467 : }
236468 : #endif
236469 :
236470 :
236471 :
236472 : // End of memberFunctionString
236473 :
236474 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
236475 :
236476 0 : SgSIMDMulOp* isSgSIMDMulOp ( SgNode* inputDerivedClassPointer )
236477 : {
236478 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236479 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
236480 : // So to fix this we return NULL directly when the input is NULL and avoid the
236481 : // dynamic_cast in this case. This is likely a performance improvement as well.
236482 : // return dynamic_cast<SgSIMDMulOp*>(inputDerivedClassPointer);
236483 : // Milind Chabbi (8/28/2013): isSgSIMDMulOp uses table-driven castability instead of c++ default dynamic_cast
236484 : // this improves the running time performance by 10-20%.
236485 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDMulOp*>(inputDerivedClassPointer);
236486 0 : return IS_SgSIMDMulOp_FAST_MACRO(inputDerivedClassPointer);
236487 : }
236488 :
236489 : // DQ (11/8/2003): Added version of functions taking const pointer
236490 0 : const SgSIMDMulOp* isSgSIMDMulOp ( const SgNode* inputDerivedClassPointer )
236491 : {
236492 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236493 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
236494 : // So to fix this we return NULL directly when the input is NULL and avoid the
236495 : // dynamic_cast in this case. This is likely a performance improvement as well.
236496 : // return dynamic_cast<const SgSIMDMulOp*>(inputDerivedClassPointer);
236497 : // Milind Chabbi (8/28/2013): isSgSIMDMulOp uses table-driven castability instead of c++ default dynamic_cast
236498 : // this improves the running time performance by 10-20%.
236499 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDMulOp*>(inputDerivedClassPointer);
236500 0 : return IS_SgSIMDMulOp_FAST_MACRO(inputDerivedClassPointer);
236501 : }
236502 :
236503 :
236504 :
236505 : /* #line 236506 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236506 :
236507 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236508 :
236509 : /**
236510 : \brief Generated destructor
236511 :
236512 : This destructor is automatically generated (by ROSETTA). This destructor
236513 : only frees memory of data members associated with the parts of the current IR node which
236514 : are NOT traversed. Those data members that are part of a traversal can be freed using
236515 : a traversal (calling this destructor on all children in a post-order traversal). Such
236516 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
236517 :
236518 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
236519 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
236520 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
236521 :
236522 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
236523 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
236524 : pointers are not yet implemented to call delete on eash pointer in the container.
236525 : (This could be done by derivation from the STL containers to define containers that
236526 : automatically deleted their members.)
236527 :
236528 : */
236529 0 : SgSIMDMulOp::~SgSIMDMulOp () {
236530 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
236531 :
236532 :
236533 :
236534 : }
236535 :
236536 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236537 0 : }
236538 :
236539 :
236540 : /* #line 236541 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236541 :
236542 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
236543 :
236544 : // Generated constructor
236545 0 : SgSIMDMulOp::SgSIMDMulOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
236546 0 : : SgSIMDBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
236547 : {
236548 : #ifdef DEBUG
236549 : // printf ("In SgSIMDMulOp::SgSIMDMulOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
236550 : #endif
236551 : #if 0
236552 : // debugging information!
236553 : printf ("In SgSIMDMulOp::SgSIMDMulOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
236554 : #endif
236555 :
236556 :
236557 :
236558 : #if 0
236559 : // DQ (7/30/2014): Call a virtual function.
236560 : std::string s = this->class_name();
236561 : #endif
236562 :
236563 : // Test the variant virtual function
236564 : // assert(SIMD_MUL_OP == variant());
236565 0 : assert(SIMD_MUL_OP == this->variant());
236566 0 : ROSE_ASSERT(SIMD_MUL_OP == (int)(this->variantT()));
236567 0 : post_construction_initialization();
236568 :
236569 : // Test the isSgSIMDMulOp() function since it has been problematic
236570 0 : assert(isSgSIMDMulOp(this) != NULL);
236571 0 : }
236572 :
236573 : // Generated constructor (all data members)
236574 :
236575 : /* #line 236576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236576 :
236577 :
236578 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236579 :
236580 :
236581 : // ********************************************************
236582 : // member functions common across all array grammar objects
236583 : // ********************************************************
236584 :
236585 :
236586 :
236587 : /* #line 236588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236588 :
236589 :
236590 :
236591 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236592 :
236593 : // ********************************************************
236594 : // member functions specific to each node in the grammar
236595 : // ********************************************************
236596 :
236597 :
236598 : /* #line 236599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236599 :
236600 : // Start of memberFunctionString
236601 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
236602 :
236603 : void
236604 0 : SgSIMDDivOp::post_construction_initialization()
236605 : {
236606 0 : }
236607 :
236608 :
236609 :
236610 : // End of memberFunctionString
236611 : // Start of memberFunctionString
236612 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
236613 :
236614 : // *** COMMON CODE SECTION BEGINS HERE ***
236615 :
236616 : #if 0
236617 : int
236618 : SgSIMDDivOp::getVariant() const
236619 : {
236620 : // This function is used in ROSE while "variant()" is used in SAGE
236621 : assert(this != NULL);
236622 : return variant();
236623 : }
236624 : #endif
236625 :
236626 : // This function is used in ROSE in treeTraversal code
236627 : // eventually replaces getVariant() and variant()
236628 : // though after variant() has been removed for a while we will
236629 : // want to change the name of variantT() back to variant()
236630 : // (since the "T" was ment to stand for temporary).
236631 : // When this happens the variantT() will be depricated.
236632 : VariantT
236633 0 : SgSIMDDivOp::variantT() const
236634 : {
236635 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
236636 0 : ROSE_ASSERT(this != NULL);
236637 0 : return V_SgSIMDDivOp;
236638 : }
236639 :
236640 : #if 0
236641 : int
236642 : SgSIMDDivOp::variant() const
236643 : {
236644 : // This function is used in SAGE
236645 : ROSE_ASSERT(this != NULL);
236646 : return SIMD_DIV_OP;
236647 : }
236648 : #endif
236649 :
236650 : ROSE_DLL_API const char*
236651 0 : SgSIMDDivOp::sage_class_name() const
236652 : {
236653 0 : ROSE_ASSERT(this != NULL);
236654 0 : return "SgSIMDDivOp";
236655 : }
236656 :
236657 : std::string
236658 0 : SgSIMDDivOp::class_name() const
236659 : {
236660 0 : ROSE_ASSERT(this != NULL);
236661 0 : return "SgSIMDDivOp";
236662 : }
236663 :
236664 : // DQ (11/26/2005): Support for visitor pattern mechanims
236665 : // (inferior to ROSE traversal mechanism, experimental).
236666 : void
236667 0 : SgSIMDDivOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
236668 : {
236669 0 : ROSE_ASSERT(this != NULL);
236670 0 : visitor.visit(this);
236671 0 : }
236672 :
236673 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
236674 0 : void SgSIMDDivOp::accept (ROSE_VisitorPattern & visitor) {
236675 0 : ROSE_ASSERT(this != NULL);
236676 0 : visitor.visit(this);
236677 0 : }
236678 :
236679 : SgSIMDDivOp*
236680 0 : SgSIMDDivOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
236681 : {
236682 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
236683 : // This function is currently only supported for the AST used the represent Binary executables.
236684 : if (0 /* isSgAsmNode(this) != NULL */)
236685 : {
236686 : // Support for regex specification.
236687 : std::string prefixCode = "REGEX:";
236688 : addNewAttribute(prefixCode + s,a);
236689 : }
236690 : #endif
236691 :
236692 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
236693 0 : return this;
236694 : }
236695 :
236696 : // *** COMMON CODE SECTION ENDS HERE ***
236697 :
236698 :
236699 : // End of memberFunctionString
236700 : // Start of memberFunctionString
236701 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
236702 :
236703 :
236704 : #if 0
236705 : //! Error checking support
236706 : /*! Verifies the following:
236707 : - working getVariant() member function
236708 : - calls base class's error() member function
236709 : Every class has one of these functions.
236710 : */
236711 : bool
236712 : SgSIMDDivOp::error()
236713 : {
236714 : // Put error checking here
236715 :
236716 : ROSE_ASSERT (this != NULL);
236717 : if (getVariant() != SIMD_DIV_OP)
236718 : {
236719 : printf ("Error in SgSIMDDivOp::error(): SgSIMDDivOp object has a %s variant \n",
236720 : Cxx_GrammarTerminalNames[getVariant()].name);
236721 : // printf ("Error in SgSIMDDivOp::error() \n");
236722 : ROSE_ABORT();
236723 : }
236724 :
236725 : ROSE_ASSERT (getVariant() == SIMD_DIV_OP);
236726 : return SgSIMDBinaryOp::error();
236727 : }
236728 : #endif
236729 :
236730 :
236731 :
236732 : // End of memberFunctionString
236733 :
236734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
236735 :
236736 0 : SgSIMDDivOp* isSgSIMDDivOp ( SgNode* inputDerivedClassPointer )
236737 : {
236738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
236740 : // So to fix this we return NULL directly when the input is NULL and avoid the
236741 : // dynamic_cast in this case. This is likely a performance improvement as well.
236742 : // return dynamic_cast<SgSIMDDivOp*>(inputDerivedClassPointer);
236743 : // Milind Chabbi (8/28/2013): isSgSIMDDivOp uses table-driven castability instead of c++ default dynamic_cast
236744 : // this improves the running time performance by 10-20%.
236745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDDivOp*>(inputDerivedClassPointer);
236746 0 : return IS_SgSIMDDivOp_FAST_MACRO(inputDerivedClassPointer);
236747 : }
236748 :
236749 : // DQ (11/8/2003): Added version of functions taking const pointer
236750 0 : const SgSIMDDivOp* isSgSIMDDivOp ( const SgNode* inputDerivedClassPointer )
236751 : {
236752 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236753 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
236754 : // So to fix this we return NULL directly when the input is NULL and avoid the
236755 : // dynamic_cast in this case. This is likely a performance improvement as well.
236756 : // return dynamic_cast<const SgSIMDDivOp*>(inputDerivedClassPointer);
236757 : // Milind Chabbi (8/28/2013): isSgSIMDDivOp uses table-driven castability instead of c++ default dynamic_cast
236758 : // this improves the running time performance by 10-20%.
236759 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDDivOp*>(inputDerivedClassPointer);
236760 0 : return IS_SgSIMDDivOp_FAST_MACRO(inputDerivedClassPointer);
236761 : }
236762 :
236763 :
236764 :
236765 : /* #line 236766 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236766 :
236767 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236768 :
236769 : /**
236770 : \brief Generated destructor
236771 :
236772 : This destructor is automatically generated (by ROSETTA). This destructor
236773 : only frees memory of data members associated with the parts of the current IR node which
236774 : are NOT traversed. Those data members that are part of a traversal can be freed using
236775 : a traversal (calling this destructor on all children in a post-order traversal). Such
236776 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
236777 :
236778 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
236779 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
236780 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
236781 :
236782 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
236783 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
236784 : pointers are not yet implemented to call delete on eash pointer in the container.
236785 : (This could be done by derivation from the STL containers to define containers that
236786 : automatically deleted their members.)
236787 :
236788 : */
236789 0 : SgSIMDDivOp::~SgSIMDDivOp () {
236790 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
236791 :
236792 :
236793 :
236794 : }
236795 :
236796 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
236797 0 : }
236798 :
236799 :
236800 : /* #line 236801 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236801 :
236802 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
236803 :
236804 : // Generated constructor
236805 0 : SgSIMDDivOp::SgSIMDDivOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
236806 0 : : SgSIMDBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
236807 : {
236808 : #ifdef DEBUG
236809 : // printf ("In SgSIMDDivOp::SgSIMDDivOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
236810 : #endif
236811 : #if 0
236812 : // debugging information!
236813 : printf ("In SgSIMDDivOp::SgSIMDDivOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
236814 : #endif
236815 :
236816 :
236817 :
236818 : #if 0
236819 : // DQ (7/30/2014): Call a virtual function.
236820 : std::string s = this->class_name();
236821 : #endif
236822 :
236823 : // Test the variant virtual function
236824 : // assert(SIMD_DIV_OP == variant());
236825 0 : assert(SIMD_DIV_OP == this->variant());
236826 0 : ROSE_ASSERT(SIMD_DIV_OP == (int)(this->variantT()));
236827 0 : post_construction_initialization();
236828 :
236829 : // Test the isSgSIMDDivOp() function since it has been problematic
236830 0 : assert(isSgSIMDDivOp(this) != NULL);
236831 0 : }
236832 :
236833 : // Generated constructor (all data members)
236834 :
236835 : /* #line 236836 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236836 :
236837 :
236838 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236839 :
236840 :
236841 : // ********************************************************
236842 : // member functions common across all array grammar objects
236843 : // ********************************************************
236844 :
236845 :
236846 :
236847 : /* #line 236848 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236848 :
236849 :
236850 :
236851 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
236852 :
236853 : // ********************************************************
236854 : // member functions specific to each node in the grammar
236855 : // ********************************************************
236856 :
236857 :
236858 : /* #line 236859 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
236859 :
236860 : // Start of memberFunctionString
236861 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
236862 :
236863 : void
236864 0 : SgSIMDFmaOp::post_construction_initialization()
236865 : {
236866 0 : }
236867 :
236868 :
236869 :
236870 : // End of memberFunctionString
236871 : // Start of memberFunctionString
236872 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
236873 :
236874 : // *** COMMON CODE SECTION BEGINS HERE ***
236875 :
236876 : #if 0
236877 : int
236878 : SgSIMDFmaOp::getVariant() const
236879 : {
236880 : // This function is used in ROSE while "variant()" is used in SAGE
236881 : assert(this != NULL);
236882 : return variant();
236883 : }
236884 : #endif
236885 :
236886 : // This function is used in ROSE in treeTraversal code
236887 : // eventually replaces getVariant() and variant()
236888 : // though after variant() has been removed for a while we will
236889 : // want to change the name of variantT() back to variant()
236890 : // (since the "T" was ment to stand for temporary).
236891 : // When this happens the variantT() will be depricated.
236892 : VariantT
236893 0 : SgSIMDFmaOp::variantT() const
236894 : {
236895 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
236896 0 : ROSE_ASSERT(this != NULL);
236897 0 : return V_SgSIMDFmaOp;
236898 : }
236899 :
236900 : #if 0
236901 : int
236902 : SgSIMDFmaOp::variant() const
236903 : {
236904 : // This function is used in SAGE
236905 : ROSE_ASSERT(this != NULL);
236906 : return SIMD_FMA_OP;
236907 : }
236908 : #endif
236909 :
236910 : ROSE_DLL_API const char*
236911 0 : SgSIMDFmaOp::sage_class_name() const
236912 : {
236913 0 : ROSE_ASSERT(this != NULL);
236914 0 : return "SgSIMDFmaOp";
236915 : }
236916 :
236917 : std::string
236918 0 : SgSIMDFmaOp::class_name() const
236919 : {
236920 0 : ROSE_ASSERT(this != NULL);
236921 0 : return "SgSIMDFmaOp";
236922 : }
236923 :
236924 : // DQ (11/26/2005): Support for visitor pattern mechanims
236925 : // (inferior to ROSE traversal mechanism, experimental).
236926 : void
236927 0 : SgSIMDFmaOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
236928 : {
236929 0 : ROSE_ASSERT(this != NULL);
236930 0 : visitor.visit(this);
236931 0 : }
236932 :
236933 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
236934 0 : void SgSIMDFmaOp::accept (ROSE_VisitorPattern & visitor) {
236935 0 : ROSE_ASSERT(this != NULL);
236936 0 : visitor.visit(this);
236937 0 : }
236938 :
236939 : SgSIMDFmaOp*
236940 0 : SgSIMDFmaOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
236941 : {
236942 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
236943 : // This function is currently only supported for the AST used the represent Binary executables.
236944 : if (0 /* isSgAsmNode(this) != NULL */)
236945 : {
236946 : // Support for regex specification.
236947 : std::string prefixCode = "REGEX:";
236948 : addNewAttribute(prefixCode + s,a);
236949 : }
236950 : #endif
236951 :
236952 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
236953 0 : return this;
236954 : }
236955 :
236956 : // *** COMMON CODE SECTION ENDS HERE ***
236957 :
236958 :
236959 : // End of memberFunctionString
236960 : // Start of memberFunctionString
236961 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
236962 :
236963 :
236964 : #if 0
236965 : //! Error checking support
236966 : /*! Verifies the following:
236967 : - working getVariant() member function
236968 : - calls base class's error() member function
236969 : Every class has one of these functions.
236970 : */
236971 : bool
236972 : SgSIMDFmaOp::error()
236973 : {
236974 : // Put error checking here
236975 :
236976 : ROSE_ASSERT (this != NULL);
236977 : if (getVariant() != SIMD_FMA_OP)
236978 : {
236979 : printf ("Error in SgSIMDFmaOp::error(): SgSIMDFmaOp object has a %s variant \n",
236980 : Cxx_GrammarTerminalNames[getVariant()].name);
236981 : // printf ("Error in SgSIMDFmaOp::error() \n");
236982 : ROSE_ABORT();
236983 : }
236984 :
236985 : ROSE_ASSERT (getVariant() == SIMD_FMA_OP);
236986 : return SgSIMDBinaryOp::error();
236987 : }
236988 : #endif
236989 :
236990 :
236991 :
236992 : // End of memberFunctionString
236993 :
236994 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
236995 :
236996 0 : SgSIMDFmaOp* isSgSIMDFmaOp ( SgNode* inputDerivedClassPointer )
236997 : {
236998 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
236999 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237000 : // So to fix this we return NULL directly when the input is NULL and avoid the
237001 : // dynamic_cast in this case. This is likely a performance improvement as well.
237002 : // return dynamic_cast<SgSIMDFmaOp*>(inputDerivedClassPointer);
237003 : // Milind Chabbi (8/28/2013): isSgSIMDFmaOp uses table-driven castability instead of c++ default dynamic_cast
237004 : // this improves the running time performance by 10-20%.
237005 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDFmaOp*>(inputDerivedClassPointer);
237006 0 : return IS_SgSIMDFmaOp_FAST_MACRO(inputDerivedClassPointer);
237007 : }
237008 :
237009 : // DQ (11/8/2003): Added version of functions taking const pointer
237010 0 : const SgSIMDFmaOp* isSgSIMDFmaOp ( const SgNode* inputDerivedClassPointer )
237011 : {
237012 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237013 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237014 : // So to fix this we return NULL directly when the input is NULL and avoid the
237015 : // dynamic_cast in this case. This is likely a performance improvement as well.
237016 : // return dynamic_cast<const SgSIMDFmaOp*>(inputDerivedClassPointer);
237017 : // Milind Chabbi (8/28/2013): isSgSIMDFmaOp uses table-driven castability instead of c++ default dynamic_cast
237018 : // this improves the running time performance by 10-20%.
237019 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDFmaOp*>(inputDerivedClassPointer);
237020 0 : return IS_SgSIMDFmaOp_FAST_MACRO(inputDerivedClassPointer);
237021 : }
237022 :
237023 :
237024 :
237025 : /* #line 237026 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237026 :
237027 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237028 :
237029 : /**
237030 : \brief Generated destructor
237031 :
237032 : This destructor is automatically generated (by ROSETTA). This destructor
237033 : only frees memory of data members associated with the parts of the current IR node which
237034 : are NOT traversed. Those data members that are part of a traversal can be freed using
237035 : a traversal (calling this destructor on all children in a post-order traversal). Such
237036 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
237037 :
237038 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
237039 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
237040 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
237041 :
237042 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
237043 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
237044 : pointers are not yet implemented to call delete on eash pointer in the container.
237045 : (This could be done by derivation from the STL containers to define containers that
237046 : automatically deleted their members.)
237047 :
237048 : */
237049 0 : SgSIMDFmaOp::~SgSIMDFmaOp () {
237050 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
237051 :
237052 :
237053 :
237054 : }
237055 :
237056 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237057 0 : }
237058 :
237059 :
237060 : /* #line 237061 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237061 :
237062 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
237063 :
237064 : // Generated constructor
237065 0 : SgSIMDFmaOp::SgSIMDFmaOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
237066 0 : : SgSIMDBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
237067 : {
237068 : #ifdef DEBUG
237069 : // printf ("In SgSIMDFmaOp::SgSIMDFmaOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
237070 : #endif
237071 : #if 0
237072 : // debugging information!
237073 : printf ("In SgSIMDFmaOp::SgSIMDFmaOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
237074 : #endif
237075 :
237076 :
237077 :
237078 : #if 0
237079 : // DQ (7/30/2014): Call a virtual function.
237080 : std::string s = this->class_name();
237081 : #endif
237082 :
237083 : // Test the variant virtual function
237084 : // assert(SIMD_FMA_OP == variant());
237085 0 : assert(SIMD_FMA_OP == this->variant());
237086 0 : ROSE_ASSERT(SIMD_FMA_OP == (int)(this->variantT()));
237087 0 : post_construction_initialization();
237088 :
237089 : // Test the isSgSIMDFmaOp() function since it has been problematic
237090 0 : assert(isSgSIMDFmaOp(this) != NULL);
237091 0 : }
237092 :
237093 : // Generated constructor (all data members)
237094 :
237095 : /* #line 237096 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237096 :
237097 :
237098 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237099 :
237100 :
237101 : // ********************************************************
237102 : // member functions common across all array grammar objects
237103 : // ********************************************************
237104 :
237105 :
237106 :
237107 : /* #line 237108 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237108 :
237109 :
237110 :
237111 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237112 :
237113 : // ********************************************************
237114 : // member functions specific to each node in the grammar
237115 : // ********************************************************
237116 :
237117 :
237118 : /* #line 237119 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237119 :
237120 : // Start of memberFunctionString
237121 : /* #line 9567 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
237122 :
237123 0 : void SgSIMDLoad::post_construction_initialization() {}
237124 :
237125 :
237126 : // End of memberFunctionString
237127 : // Start of memberFunctionString
237128 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
237129 :
237130 : // *** COMMON CODE SECTION BEGINS HERE ***
237131 :
237132 : #if 0
237133 : int
237134 : SgSIMDLoad::getVariant() const
237135 : {
237136 : // This function is used in ROSE while "variant()" is used in SAGE
237137 : assert(this != NULL);
237138 : return variant();
237139 : }
237140 : #endif
237141 :
237142 : // This function is used in ROSE in treeTraversal code
237143 : // eventually replaces getVariant() and variant()
237144 : // though after variant() has been removed for a while we will
237145 : // want to change the name of variantT() back to variant()
237146 : // (since the "T" was ment to stand for temporary).
237147 : // When this happens the variantT() will be depricated.
237148 : VariantT
237149 0 : SgSIMDLoad::variantT() const
237150 : {
237151 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
237152 0 : ROSE_ASSERT(this != NULL);
237153 0 : return V_SgSIMDLoad;
237154 : }
237155 :
237156 : #if 0
237157 : int
237158 : SgSIMDLoad::variant() const
237159 : {
237160 : // This function is used in SAGE
237161 : ROSE_ASSERT(this != NULL);
237162 : return SIMD_LOAD;
237163 : }
237164 : #endif
237165 :
237166 : ROSE_DLL_API const char*
237167 0 : SgSIMDLoad::sage_class_name() const
237168 : {
237169 0 : ROSE_ASSERT(this != NULL);
237170 0 : return "SgSIMDLoad";
237171 : }
237172 :
237173 : std::string
237174 0 : SgSIMDLoad::class_name() const
237175 : {
237176 0 : ROSE_ASSERT(this != NULL);
237177 0 : return "SgSIMDLoad";
237178 : }
237179 :
237180 : // DQ (11/26/2005): Support for visitor pattern mechanims
237181 : // (inferior to ROSE traversal mechanism, experimental).
237182 : void
237183 0 : SgSIMDLoad::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
237184 : {
237185 0 : ROSE_ASSERT(this != NULL);
237186 0 : visitor.visit(this);
237187 0 : }
237188 :
237189 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
237190 0 : void SgSIMDLoad::accept (ROSE_VisitorPattern & visitor) {
237191 0 : ROSE_ASSERT(this != NULL);
237192 0 : visitor.visit(this);
237193 0 : }
237194 :
237195 : SgSIMDLoad*
237196 0 : SgSIMDLoad::addRegExpAttribute(std::string s, AstRegExAttribute* a)
237197 : {
237198 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
237199 : // This function is currently only supported for the AST used the represent Binary executables.
237200 : if (0 /* isSgAsmNode(this) != NULL */)
237201 : {
237202 : // Support for regex specification.
237203 : std::string prefixCode = "REGEX:";
237204 : addNewAttribute(prefixCode + s,a);
237205 : }
237206 : #endif
237207 :
237208 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
237209 0 : return this;
237210 : }
237211 :
237212 : // *** COMMON CODE SECTION ENDS HERE ***
237213 :
237214 :
237215 : // End of memberFunctionString
237216 : // Start of memberFunctionString
237217 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
237218 :
237219 :
237220 : #if 0
237221 : //! Error checking support
237222 : /*! Verifies the following:
237223 : - working getVariant() member function
237224 : - calls base class's error() member function
237225 : Every class has one of these functions.
237226 : */
237227 : bool
237228 : SgSIMDLoad::error()
237229 : {
237230 : // Put error checking here
237231 :
237232 : ROSE_ASSERT (this != NULL);
237233 : if (getVariant() != SIMD_LOAD)
237234 : {
237235 : printf ("Error in SgSIMDLoad::error(): SgSIMDLoad object has a %s variant \n",
237236 : Cxx_GrammarTerminalNames[getVariant()].name);
237237 : // printf ("Error in SgSIMDLoad::error() \n");
237238 : ROSE_ABORT();
237239 : }
237240 :
237241 : ROSE_ASSERT (getVariant() == SIMD_LOAD);
237242 : return SgBinaryOp::error();
237243 : }
237244 : #endif
237245 :
237246 :
237247 :
237248 : // End of memberFunctionString
237249 :
237250 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
237251 :
237252 0 : SgSIMDLoad* isSgSIMDLoad ( SgNode* inputDerivedClassPointer )
237253 : {
237254 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237255 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237256 : // So to fix this we return NULL directly when the input is NULL and avoid the
237257 : // dynamic_cast in this case. This is likely a performance improvement as well.
237258 : // return dynamic_cast<SgSIMDLoad*>(inputDerivedClassPointer);
237259 : // Milind Chabbi (8/28/2013): isSgSIMDLoad uses table-driven castability instead of c++ default dynamic_cast
237260 : // this improves the running time performance by 10-20%.
237261 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDLoad*>(inputDerivedClassPointer);
237262 0 : return IS_SgSIMDLoad_FAST_MACRO(inputDerivedClassPointer);
237263 : }
237264 :
237265 : // DQ (11/8/2003): Added version of functions taking const pointer
237266 0 : const SgSIMDLoad* isSgSIMDLoad ( const SgNode* inputDerivedClassPointer )
237267 : {
237268 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237269 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237270 : // So to fix this we return NULL directly when the input is NULL and avoid the
237271 : // dynamic_cast in this case. This is likely a performance improvement as well.
237272 : // return dynamic_cast<const SgSIMDLoad*>(inputDerivedClassPointer);
237273 : // Milind Chabbi (8/28/2013): isSgSIMDLoad uses table-driven castability instead of c++ default dynamic_cast
237274 : // this improves the running time performance by 10-20%.
237275 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDLoad*>(inputDerivedClassPointer);
237276 0 : return IS_SgSIMDLoad_FAST_MACRO(inputDerivedClassPointer);
237277 : }
237278 :
237279 :
237280 :
237281 : /* #line 237282 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237282 :
237283 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237284 :
237285 : /**
237286 : \brief Generated destructor
237287 :
237288 : This destructor is automatically generated (by ROSETTA). This destructor
237289 : only frees memory of data members associated with the parts of the current IR node which
237290 : are NOT traversed. Those data members that are part of a traversal can be freed using
237291 : a traversal (calling this destructor on all children in a post-order traversal). Such
237292 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
237293 :
237294 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
237295 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
237296 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
237297 :
237298 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
237299 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
237300 : pointers are not yet implemented to call delete on eash pointer in the container.
237301 : (This could be done by derivation from the STL containers to define containers that
237302 : automatically deleted their members.)
237303 :
237304 : */
237305 0 : SgSIMDLoad::~SgSIMDLoad () {
237306 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
237307 :
237308 :
237309 :
237310 : }
237311 :
237312 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237313 0 : }
237314 :
237315 :
237316 : /* #line 237317 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237317 :
237318 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
237319 :
237320 : // Generated constructor
237321 0 : SgSIMDLoad::SgSIMDLoad ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
237322 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
237323 : {
237324 : #ifdef DEBUG
237325 : // printf ("In SgSIMDLoad::SgSIMDLoad (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
237326 : #endif
237327 : #if 0
237328 : // debugging information!
237329 : printf ("In SgSIMDLoad::SgSIMDLoad (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
237330 : #endif
237331 :
237332 :
237333 :
237334 : #if 0
237335 : // DQ (7/30/2014): Call a virtual function.
237336 : std::string s = this->class_name();
237337 : #endif
237338 :
237339 : // Test the variant virtual function
237340 : // assert(SIMD_LOAD == variant());
237341 0 : assert(SIMD_LOAD == this->variant());
237342 0 : ROSE_ASSERT(SIMD_LOAD == (int)(this->variantT()));
237343 0 : post_construction_initialization();
237344 :
237345 : // Test the isSgSIMDLoad() function since it has been problematic
237346 0 : assert(isSgSIMDLoad(this) != NULL);
237347 0 : }
237348 :
237349 : // Generated constructor (all data members)
237350 :
237351 : /* #line 237352 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237352 :
237353 :
237354 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237355 :
237356 :
237357 : // ********************************************************
237358 : // member functions common across all array grammar objects
237359 : // ********************************************************
237360 :
237361 :
237362 :
237363 : /* #line 237364 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237364 :
237365 :
237366 :
237367 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237368 :
237369 : // ********************************************************
237370 : // member functions specific to each node in the grammar
237371 : // ********************************************************
237372 :
237373 :
237374 : /* #line 237375 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237375 :
237376 : // Start of memberFunctionString
237377 : /* #line 9575 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
237378 :
237379 0 : void SgSIMDBroadcast::post_construction_initialization() {}
237380 :
237381 :
237382 : // End of memberFunctionString
237383 : // Start of memberFunctionString
237384 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
237385 :
237386 : // *** COMMON CODE SECTION BEGINS HERE ***
237387 :
237388 : #if 0
237389 : int
237390 : SgSIMDBroadcast::getVariant() const
237391 : {
237392 : // This function is used in ROSE while "variant()" is used in SAGE
237393 : assert(this != NULL);
237394 : return variant();
237395 : }
237396 : #endif
237397 :
237398 : // This function is used in ROSE in treeTraversal code
237399 : // eventually replaces getVariant() and variant()
237400 : // though after variant() has been removed for a while we will
237401 : // want to change the name of variantT() back to variant()
237402 : // (since the "T" was ment to stand for temporary).
237403 : // When this happens the variantT() will be depricated.
237404 : VariantT
237405 0 : SgSIMDBroadcast::variantT() const
237406 : {
237407 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
237408 0 : ROSE_ASSERT(this != NULL);
237409 0 : return V_SgSIMDBroadcast;
237410 : }
237411 :
237412 : #if 0
237413 : int
237414 : SgSIMDBroadcast::variant() const
237415 : {
237416 : // This function is used in SAGE
237417 : ROSE_ASSERT(this != NULL);
237418 : return SIMD_BROADCAST;
237419 : }
237420 : #endif
237421 :
237422 : ROSE_DLL_API const char*
237423 0 : SgSIMDBroadcast::sage_class_name() const
237424 : {
237425 0 : ROSE_ASSERT(this != NULL);
237426 0 : return "SgSIMDBroadcast";
237427 : }
237428 :
237429 : std::string
237430 0 : SgSIMDBroadcast::class_name() const
237431 : {
237432 0 : ROSE_ASSERT(this != NULL);
237433 0 : return "SgSIMDBroadcast";
237434 : }
237435 :
237436 : // DQ (11/26/2005): Support for visitor pattern mechanims
237437 : // (inferior to ROSE traversal mechanism, experimental).
237438 : void
237439 0 : SgSIMDBroadcast::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
237440 : {
237441 0 : ROSE_ASSERT(this != NULL);
237442 0 : visitor.visit(this);
237443 0 : }
237444 :
237445 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
237446 0 : void SgSIMDBroadcast::accept (ROSE_VisitorPattern & visitor) {
237447 0 : ROSE_ASSERT(this != NULL);
237448 0 : visitor.visit(this);
237449 0 : }
237450 :
237451 : SgSIMDBroadcast*
237452 0 : SgSIMDBroadcast::addRegExpAttribute(std::string s, AstRegExAttribute* a)
237453 : {
237454 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
237455 : // This function is currently only supported for the AST used the represent Binary executables.
237456 : if (0 /* isSgAsmNode(this) != NULL */)
237457 : {
237458 : // Support for regex specification.
237459 : std::string prefixCode = "REGEX:";
237460 : addNewAttribute(prefixCode + s,a);
237461 : }
237462 : #endif
237463 :
237464 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
237465 0 : return this;
237466 : }
237467 :
237468 : // *** COMMON CODE SECTION ENDS HERE ***
237469 :
237470 :
237471 : // End of memberFunctionString
237472 : // Start of memberFunctionString
237473 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
237474 :
237475 :
237476 : #if 0
237477 : //! Error checking support
237478 : /*! Verifies the following:
237479 : - working getVariant() member function
237480 : - calls base class's error() member function
237481 : Every class has one of these functions.
237482 : */
237483 : bool
237484 : SgSIMDBroadcast::error()
237485 : {
237486 : // Put error checking here
237487 :
237488 : ROSE_ASSERT (this != NULL);
237489 : if (getVariant() != SIMD_BROADCAST)
237490 : {
237491 : printf ("Error in SgSIMDBroadcast::error(): SgSIMDBroadcast object has a %s variant \n",
237492 : Cxx_GrammarTerminalNames[getVariant()].name);
237493 : // printf ("Error in SgSIMDBroadcast::error() \n");
237494 : ROSE_ABORT();
237495 : }
237496 :
237497 : ROSE_ASSERT (getVariant() == SIMD_BROADCAST);
237498 : return SgBinaryOp::error();
237499 : }
237500 : #endif
237501 :
237502 :
237503 :
237504 : // End of memberFunctionString
237505 :
237506 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
237507 :
237508 0 : SgSIMDBroadcast* isSgSIMDBroadcast ( SgNode* inputDerivedClassPointer )
237509 : {
237510 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237511 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237512 : // So to fix this we return NULL directly when the input is NULL and avoid the
237513 : // dynamic_cast in this case. This is likely a performance improvement as well.
237514 : // return dynamic_cast<SgSIMDBroadcast*>(inputDerivedClassPointer);
237515 : // Milind Chabbi (8/28/2013): isSgSIMDBroadcast uses table-driven castability instead of c++ default dynamic_cast
237516 : // this improves the running time performance by 10-20%.
237517 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDBroadcast*>(inputDerivedClassPointer);
237518 0 : return IS_SgSIMDBroadcast_FAST_MACRO(inputDerivedClassPointer);
237519 : }
237520 :
237521 : // DQ (11/8/2003): Added version of functions taking const pointer
237522 0 : const SgSIMDBroadcast* isSgSIMDBroadcast ( const SgNode* inputDerivedClassPointer )
237523 : {
237524 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237525 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237526 : // So to fix this we return NULL directly when the input is NULL and avoid the
237527 : // dynamic_cast in this case. This is likely a performance improvement as well.
237528 : // return dynamic_cast<const SgSIMDBroadcast*>(inputDerivedClassPointer);
237529 : // Milind Chabbi (8/28/2013): isSgSIMDBroadcast uses table-driven castability instead of c++ default dynamic_cast
237530 : // this improves the running time performance by 10-20%.
237531 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDBroadcast*>(inputDerivedClassPointer);
237532 0 : return IS_SgSIMDBroadcast_FAST_MACRO(inputDerivedClassPointer);
237533 : }
237534 :
237535 :
237536 :
237537 : /* #line 237538 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237538 :
237539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237540 :
237541 : /**
237542 : \brief Generated destructor
237543 :
237544 : This destructor is automatically generated (by ROSETTA). This destructor
237545 : only frees memory of data members associated with the parts of the current IR node which
237546 : are NOT traversed. Those data members that are part of a traversal can be freed using
237547 : a traversal (calling this destructor on all children in a post-order traversal). Such
237548 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
237549 :
237550 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
237551 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
237552 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
237553 :
237554 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
237555 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
237556 : pointers are not yet implemented to call delete on eash pointer in the container.
237557 : (This could be done by derivation from the STL containers to define containers that
237558 : automatically deleted their members.)
237559 :
237560 : */
237561 0 : SgSIMDBroadcast::~SgSIMDBroadcast () {
237562 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
237563 :
237564 :
237565 :
237566 : }
237567 :
237568 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237569 0 : }
237570 :
237571 :
237572 : /* #line 237573 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237573 :
237574 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
237575 :
237576 : // Generated constructor
237577 0 : SgSIMDBroadcast::SgSIMDBroadcast ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
237578 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
237579 : {
237580 : #ifdef DEBUG
237581 : // printf ("In SgSIMDBroadcast::SgSIMDBroadcast (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
237582 : #endif
237583 : #if 0
237584 : // debugging information!
237585 : printf ("In SgSIMDBroadcast::SgSIMDBroadcast (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
237586 : #endif
237587 :
237588 :
237589 :
237590 : #if 0
237591 : // DQ (7/30/2014): Call a virtual function.
237592 : std::string s = this->class_name();
237593 : #endif
237594 :
237595 : // Test the variant virtual function
237596 : // assert(SIMD_BROADCAST == variant());
237597 0 : assert(SIMD_BROADCAST == this->variant());
237598 0 : ROSE_ASSERT(SIMD_BROADCAST == (int)(this->variantT()));
237599 0 : post_construction_initialization();
237600 :
237601 : // Test the isSgSIMDBroadcast() function since it has been problematic
237602 0 : assert(isSgSIMDBroadcast(this) != NULL);
237603 0 : }
237604 :
237605 : // Generated constructor (all data members)
237606 :
237607 : /* #line 237608 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237608 :
237609 :
237610 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237611 :
237612 :
237613 : // ********************************************************
237614 : // member functions common across all array grammar objects
237615 : // ********************************************************
237616 :
237617 :
237618 :
237619 : /* #line 237620 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237620 :
237621 :
237622 :
237623 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237624 :
237625 : // ********************************************************
237626 : // member functions specific to each node in the grammar
237627 : // ********************************************************
237628 :
237629 :
237630 : /* #line 237631 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237631 :
237632 : // Start of memberFunctionString
237633 : /* #line 9583 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
237634 :
237635 0 : void SgSIMDStore::post_construction_initialization() {}
237636 :
237637 :
237638 : // End of memberFunctionString
237639 : // Start of memberFunctionString
237640 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
237641 :
237642 : // *** COMMON CODE SECTION BEGINS HERE ***
237643 :
237644 : #if 0
237645 : int
237646 : SgSIMDStore::getVariant() const
237647 : {
237648 : // This function is used in ROSE while "variant()" is used in SAGE
237649 : assert(this != NULL);
237650 : return variant();
237651 : }
237652 : #endif
237653 :
237654 : // This function is used in ROSE in treeTraversal code
237655 : // eventually replaces getVariant() and variant()
237656 : // though after variant() has been removed for a while we will
237657 : // want to change the name of variantT() back to variant()
237658 : // (since the "T" was ment to stand for temporary).
237659 : // When this happens the variantT() will be depricated.
237660 : VariantT
237661 0 : SgSIMDStore::variantT() const
237662 : {
237663 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
237664 0 : ROSE_ASSERT(this != NULL);
237665 0 : return V_SgSIMDStore;
237666 : }
237667 :
237668 : #if 0
237669 : int
237670 : SgSIMDStore::variant() const
237671 : {
237672 : // This function is used in SAGE
237673 : ROSE_ASSERT(this != NULL);
237674 : return SIMD_STORE;
237675 : }
237676 : #endif
237677 :
237678 : ROSE_DLL_API const char*
237679 0 : SgSIMDStore::sage_class_name() const
237680 : {
237681 0 : ROSE_ASSERT(this != NULL);
237682 0 : return "SgSIMDStore";
237683 : }
237684 :
237685 : std::string
237686 0 : SgSIMDStore::class_name() const
237687 : {
237688 0 : ROSE_ASSERT(this != NULL);
237689 0 : return "SgSIMDStore";
237690 : }
237691 :
237692 : // DQ (11/26/2005): Support for visitor pattern mechanims
237693 : // (inferior to ROSE traversal mechanism, experimental).
237694 : void
237695 0 : SgSIMDStore::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
237696 : {
237697 0 : ROSE_ASSERT(this != NULL);
237698 0 : visitor.visit(this);
237699 0 : }
237700 :
237701 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
237702 0 : void SgSIMDStore::accept (ROSE_VisitorPattern & visitor) {
237703 0 : ROSE_ASSERT(this != NULL);
237704 0 : visitor.visit(this);
237705 0 : }
237706 :
237707 : SgSIMDStore*
237708 0 : SgSIMDStore::addRegExpAttribute(std::string s, AstRegExAttribute* a)
237709 : {
237710 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
237711 : // This function is currently only supported for the AST used the represent Binary executables.
237712 : if (0 /* isSgAsmNode(this) != NULL */)
237713 : {
237714 : // Support for regex specification.
237715 : std::string prefixCode = "REGEX:";
237716 : addNewAttribute(prefixCode + s,a);
237717 : }
237718 : #endif
237719 :
237720 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
237721 0 : return this;
237722 : }
237723 :
237724 : // *** COMMON CODE SECTION ENDS HERE ***
237725 :
237726 :
237727 : // End of memberFunctionString
237728 : // Start of memberFunctionString
237729 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
237730 :
237731 :
237732 : #if 0
237733 : //! Error checking support
237734 : /*! Verifies the following:
237735 : - working getVariant() member function
237736 : - calls base class's error() member function
237737 : Every class has one of these functions.
237738 : */
237739 : bool
237740 : SgSIMDStore::error()
237741 : {
237742 : // Put error checking here
237743 :
237744 : ROSE_ASSERT (this != NULL);
237745 : if (getVariant() != SIMD_STORE)
237746 : {
237747 : printf ("Error in SgSIMDStore::error(): SgSIMDStore object has a %s variant \n",
237748 : Cxx_GrammarTerminalNames[getVariant()].name);
237749 : // printf ("Error in SgSIMDStore::error() \n");
237750 : ROSE_ABORT();
237751 : }
237752 :
237753 : ROSE_ASSERT (getVariant() == SIMD_STORE);
237754 : return SgBinaryOp::error();
237755 : }
237756 : #endif
237757 :
237758 :
237759 :
237760 : // End of memberFunctionString
237761 :
237762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
237763 :
237764 0 : SgSIMDStore* isSgSIMDStore ( SgNode* inputDerivedClassPointer )
237765 : {
237766 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237767 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237768 : // So to fix this we return NULL directly when the input is NULL and avoid the
237769 : // dynamic_cast in this case. This is likely a performance improvement as well.
237770 : // return dynamic_cast<SgSIMDStore*>(inputDerivedClassPointer);
237771 : // Milind Chabbi (8/28/2013): isSgSIMDStore uses table-driven castability instead of c++ default dynamic_cast
237772 : // this improves the running time performance by 10-20%.
237773 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDStore*>(inputDerivedClassPointer);
237774 0 : return IS_SgSIMDStore_FAST_MACRO(inputDerivedClassPointer);
237775 : }
237776 :
237777 : // DQ (11/8/2003): Added version of functions taking const pointer
237778 0 : const SgSIMDStore* isSgSIMDStore ( const SgNode* inputDerivedClassPointer )
237779 : {
237780 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
237781 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
237782 : // So to fix this we return NULL directly when the input is NULL and avoid the
237783 : // dynamic_cast in this case. This is likely a performance improvement as well.
237784 : // return dynamic_cast<const SgSIMDStore*>(inputDerivedClassPointer);
237785 : // Milind Chabbi (8/28/2013): isSgSIMDStore uses table-driven castability instead of c++ default dynamic_cast
237786 : // this improves the running time performance by 10-20%.
237787 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDStore*>(inputDerivedClassPointer);
237788 0 : return IS_SgSIMDStore_FAST_MACRO(inputDerivedClassPointer);
237789 : }
237790 :
237791 :
237792 :
237793 : /* #line 237794 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237794 :
237795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237796 :
237797 : /**
237798 : \brief Generated destructor
237799 :
237800 : This destructor is automatically generated (by ROSETTA). This destructor
237801 : only frees memory of data members associated with the parts of the current IR node which
237802 : are NOT traversed. Those data members that are part of a traversal can be freed using
237803 : a traversal (calling this destructor on all children in a post-order traversal). Such
237804 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
237805 :
237806 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
237807 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
237808 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
237809 :
237810 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
237811 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
237812 : pointers are not yet implemented to call delete on eash pointer in the container.
237813 : (This could be done by derivation from the STL containers to define containers that
237814 : automatically deleted their members.)
237815 :
237816 : */
237817 0 : SgSIMDStore::~SgSIMDStore () {
237818 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
237819 :
237820 :
237821 :
237822 : }
237823 :
237824 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
237825 0 : }
237826 :
237827 :
237828 : /* #line 237829 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237829 :
237830 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
237831 :
237832 : // Generated constructor
237833 0 : SgSIMDStore::SgSIMDStore ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
237834 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
237835 : {
237836 : #ifdef DEBUG
237837 : // printf ("In SgSIMDStore::SgSIMDStore (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
237838 : #endif
237839 : #if 0
237840 : // debugging information!
237841 : printf ("In SgSIMDStore::SgSIMDStore (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
237842 : #endif
237843 :
237844 :
237845 :
237846 : #if 0
237847 : // DQ (7/30/2014): Call a virtual function.
237848 : std::string s = this->class_name();
237849 : #endif
237850 :
237851 : // Test the variant virtual function
237852 : // assert(SIMD_STORE == variant());
237853 0 : assert(SIMD_STORE == this->variant());
237854 0 : ROSE_ASSERT(SIMD_STORE == (int)(this->variantT()));
237855 0 : post_construction_initialization();
237856 :
237857 : // Test the isSgSIMDStore() function since it has been problematic
237858 0 : assert(isSgSIMDStore(this) != NULL);
237859 0 : }
237860 :
237861 : // Generated constructor (all data members)
237862 :
237863 : /* #line 237864 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237864 :
237865 :
237866 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237867 :
237868 :
237869 : // ********************************************************
237870 : // member functions common across all array grammar objects
237871 : // ********************************************************
237872 :
237873 :
237874 :
237875 : /* #line 237876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237876 :
237877 :
237878 :
237879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
237880 :
237881 : // ********************************************************
237882 : // member functions specific to each node in the grammar
237883 : // ********************************************************
237884 :
237885 :
237886 : /* #line 237887 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
237887 :
237888 : // Start of memberFunctionString
237889 : /* #line 9591 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
237890 :
237891 0 : void SgSIMDPartialStore::post_construction_initialization() {}
237892 :
237893 :
237894 : // End of memberFunctionString
237895 : // Start of memberFunctionString
237896 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
237897 :
237898 : // *** COMMON CODE SECTION BEGINS HERE ***
237899 :
237900 : #if 0
237901 : int
237902 : SgSIMDPartialStore::getVariant() const
237903 : {
237904 : // This function is used in ROSE while "variant()" is used in SAGE
237905 : assert(this != NULL);
237906 : return variant();
237907 : }
237908 : #endif
237909 :
237910 : // This function is used in ROSE in treeTraversal code
237911 : // eventually replaces getVariant() and variant()
237912 : // though after variant() has been removed for a while we will
237913 : // want to change the name of variantT() back to variant()
237914 : // (since the "T" was ment to stand for temporary).
237915 : // When this happens the variantT() will be depricated.
237916 : VariantT
237917 0 : SgSIMDPartialStore::variantT() const
237918 : {
237919 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
237920 0 : ROSE_ASSERT(this != NULL);
237921 0 : return V_SgSIMDPartialStore;
237922 : }
237923 :
237924 : #if 0
237925 : int
237926 : SgSIMDPartialStore::variant() const
237927 : {
237928 : // This function is used in SAGE
237929 : ROSE_ASSERT(this != NULL);
237930 : return SIMD_PARTIAL_STORE;
237931 : }
237932 : #endif
237933 :
237934 : ROSE_DLL_API const char*
237935 0 : SgSIMDPartialStore::sage_class_name() const
237936 : {
237937 0 : ROSE_ASSERT(this != NULL);
237938 0 : return "SgSIMDPartialStore";
237939 : }
237940 :
237941 : std::string
237942 0 : SgSIMDPartialStore::class_name() const
237943 : {
237944 0 : ROSE_ASSERT(this != NULL);
237945 0 : return "SgSIMDPartialStore";
237946 : }
237947 :
237948 : // DQ (11/26/2005): Support for visitor pattern mechanims
237949 : // (inferior to ROSE traversal mechanism, experimental).
237950 : void
237951 0 : SgSIMDPartialStore::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
237952 : {
237953 0 : ROSE_ASSERT(this != NULL);
237954 0 : visitor.visit(this);
237955 0 : }
237956 :
237957 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
237958 0 : void SgSIMDPartialStore::accept (ROSE_VisitorPattern & visitor) {
237959 0 : ROSE_ASSERT(this != NULL);
237960 0 : visitor.visit(this);
237961 0 : }
237962 :
237963 : SgSIMDPartialStore*
237964 0 : SgSIMDPartialStore::addRegExpAttribute(std::string s, AstRegExAttribute* a)
237965 : {
237966 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
237967 : // This function is currently only supported for the AST used the represent Binary executables.
237968 : if (0 /* isSgAsmNode(this) != NULL */)
237969 : {
237970 : // Support for regex specification.
237971 : std::string prefixCode = "REGEX:";
237972 : addNewAttribute(prefixCode + s,a);
237973 : }
237974 : #endif
237975 :
237976 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
237977 0 : return this;
237978 : }
237979 :
237980 : // *** COMMON CODE SECTION ENDS HERE ***
237981 :
237982 :
237983 : // End of memberFunctionString
237984 : // Start of memberFunctionString
237985 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
237986 :
237987 :
237988 : #if 0
237989 : //! Error checking support
237990 : /*! Verifies the following:
237991 : - working getVariant() member function
237992 : - calls base class's error() member function
237993 : Every class has one of these functions.
237994 : */
237995 : bool
237996 : SgSIMDPartialStore::error()
237997 : {
237998 : // Put error checking here
237999 :
238000 : ROSE_ASSERT (this != NULL);
238001 : if (getVariant() != SIMD_PARTIAL_STORE)
238002 : {
238003 : printf ("Error in SgSIMDPartialStore::error(): SgSIMDPartialStore object has a %s variant \n",
238004 : Cxx_GrammarTerminalNames[getVariant()].name);
238005 : // printf ("Error in SgSIMDPartialStore::error() \n");
238006 : ROSE_ABORT();
238007 : }
238008 :
238009 : ROSE_ASSERT (getVariant() == SIMD_PARTIAL_STORE);
238010 : return SgBinaryOp::error();
238011 : }
238012 : #endif
238013 :
238014 :
238015 :
238016 : // End of memberFunctionString
238017 :
238018 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
238019 :
238020 0 : SgSIMDPartialStore* isSgSIMDPartialStore ( SgNode* inputDerivedClassPointer )
238021 : {
238022 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238023 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238024 : // So to fix this we return NULL directly when the input is NULL and avoid the
238025 : // dynamic_cast in this case. This is likely a performance improvement as well.
238026 : // return dynamic_cast<SgSIMDPartialStore*>(inputDerivedClassPointer);
238027 : // Milind Chabbi (8/28/2013): isSgSIMDPartialStore uses table-driven castability instead of c++ default dynamic_cast
238028 : // this improves the running time performance by 10-20%.
238029 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDPartialStore*>(inputDerivedClassPointer);
238030 0 : return IS_SgSIMDPartialStore_FAST_MACRO(inputDerivedClassPointer);
238031 : }
238032 :
238033 : // DQ (11/8/2003): Added version of functions taking const pointer
238034 0 : const SgSIMDPartialStore* isSgSIMDPartialStore ( const SgNode* inputDerivedClassPointer )
238035 : {
238036 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238037 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238038 : // So to fix this we return NULL directly when the input is NULL and avoid the
238039 : // dynamic_cast in this case. This is likely a performance improvement as well.
238040 : // return dynamic_cast<const SgSIMDPartialStore*>(inputDerivedClassPointer);
238041 : // Milind Chabbi (8/28/2013): isSgSIMDPartialStore uses table-driven castability instead of c++ default dynamic_cast
238042 : // this improves the running time performance by 10-20%.
238043 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDPartialStore*>(inputDerivedClassPointer);
238044 0 : return IS_SgSIMDPartialStore_FAST_MACRO(inputDerivedClassPointer);
238045 : }
238046 :
238047 :
238048 :
238049 : /* #line 238050 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238050 :
238051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238052 :
238053 : /**
238054 : \brief Generated destructor
238055 :
238056 : This destructor is automatically generated (by ROSETTA). This destructor
238057 : only frees memory of data members associated with the parts of the current IR node which
238058 : are NOT traversed. Those data members that are part of a traversal can be freed using
238059 : a traversal (calling this destructor on all children in a post-order traversal). Such
238060 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
238061 :
238062 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
238063 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
238064 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
238065 :
238066 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
238067 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
238068 : pointers are not yet implemented to call delete on eash pointer in the container.
238069 : (This could be done by derivation from the STL containers to define containers that
238070 : automatically deleted their members.)
238071 :
238072 : */
238073 0 : SgSIMDPartialStore::~SgSIMDPartialStore () {
238074 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
238075 :
238076 :
238077 :
238078 : }
238079 :
238080 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238081 0 : }
238082 :
238083 :
238084 : /* #line 238085 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238085 :
238086 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
238087 :
238088 : // Generated constructor
238089 0 : SgSIMDPartialStore::SgSIMDPartialStore ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
238090 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
238091 : {
238092 : #ifdef DEBUG
238093 : // printf ("In SgSIMDPartialStore::SgSIMDPartialStore (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
238094 : #endif
238095 : #if 0
238096 : // debugging information!
238097 : printf ("In SgSIMDPartialStore::SgSIMDPartialStore (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
238098 : #endif
238099 :
238100 :
238101 :
238102 : #if 0
238103 : // DQ (7/30/2014): Call a virtual function.
238104 : std::string s = this->class_name();
238105 : #endif
238106 :
238107 : // Test the variant virtual function
238108 : // assert(SIMD_PARTIAL_STORE == variant());
238109 0 : assert(SIMD_PARTIAL_STORE == this->variant());
238110 0 : ROSE_ASSERT(SIMD_PARTIAL_STORE == (int)(this->variantT()));
238111 0 : post_construction_initialization();
238112 :
238113 : // Test the isSgSIMDPartialStore() function since it has been problematic
238114 0 : assert(isSgSIMDPartialStore(this) != NULL);
238115 0 : }
238116 :
238117 : // Generated constructor (all data members)
238118 :
238119 : /* #line 238120 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238120 :
238121 :
238122 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238123 :
238124 :
238125 : // ********************************************************
238126 : // member functions common across all array grammar objects
238127 : // ********************************************************
238128 :
238129 :
238130 :
238131 : /* #line 238132 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238132 :
238133 :
238134 :
238135 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238136 :
238137 : // ********************************************************
238138 : // member functions specific to each node in the grammar
238139 : // ********************************************************
238140 :
238141 :
238142 : /* #line 238143 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238143 :
238144 : // Start of memberFunctionString
238145 : /* #line 9599 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
238146 :
238147 0 : void SgSIMDScalarStore::post_construction_initialization() {}
238148 :
238149 :
238150 : // End of memberFunctionString
238151 : // Start of memberFunctionString
238152 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
238153 :
238154 : // *** COMMON CODE SECTION BEGINS HERE ***
238155 :
238156 : #if 0
238157 : int
238158 : SgSIMDScalarStore::getVariant() const
238159 : {
238160 : // This function is used in ROSE while "variant()" is used in SAGE
238161 : assert(this != NULL);
238162 : return variant();
238163 : }
238164 : #endif
238165 :
238166 : // This function is used in ROSE in treeTraversal code
238167 : // eventually replaces getVariant() and variant()
238168 : // though after variant() has been removed for a while we will
238169 : // want to change the name of variantT() back to variant()
238170 : // (since the "T" was ment to stand for temporary).
238171 : // When this happens the variantT() will be depricated.
238172 : VariantT
238173 0 : SgSIMDScalarStore::variantT() const
238174 : {
238175 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
238176 0 : ROSE_ASSERT(this != NULL);
238177 0 : return V_SgSIMDScalarStore;
238178 : }
238179 :
238180 : #if 0
238181 : int
238182 : SgSIMDScalarStore::variant() const
238183 : {
238184 : // This function is used in SAGE
238185 : ROSE_ASSERT(this != NULL);
238186 : return SIMD_SCALAR_STORE;
238187 : }
238188 : #endif
238189 :
238190 : ROSE_DLL_API const char*
238191 0 : SgSIMDScalarStore::sage_class_name() const
238192 : {
238193 0 : ROSE_ASSERT(this != NULL);
238194 0 : return "SgSIMDScalarStore";
238195 : }
238196 :
238197 : std::string
238198 0 : SgSIMDScalarStore::class_name() const
238199 : {
238200 0 : ROSE_ASSERT(this != NULL);
238201 0 : return "SgSIMDScalarStore";
238202 : }
238203 :
238204 : // DQ (11/26/2005): Support for visitor pattern mechanims
238205 : // (inferior to ROSE traversal mechanism, experimental).
238206 : void
238207 0 : SgSIMDScalarStore::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
238208 : {
238209 0 : ROSE_ASSERT(this != NULL);
238210 0 : visitor.visit(this);
238211 0 : }
238212 :
238213 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
238214 0 : void SgSIMDScalarStore::accept (ROSE_VisitorPattern & visitor) {
238215 0 : ROSE_ASSERT(this != NULL);
238216 0 : visitor.visit(this);
238217 0 : }
238218 :
238219 : SgSIMDScalarStore*
238220 0 : SgSIMDScalarStore::addRegExpAttribute(std::string s, AstRegExAttribute* a)
238221 : {
238222 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
238223 : // This function is currently only supported for the AST used the represent Binary executables.
238224 : if (0 /* isSgAsmNode(this) != NULL */)
238225 : {
238226 : // Support for regex specification.
238227 : std::string prefixCode = "REGEX:";
238228 : addNewAttribute(prefixCode + s,a);
238229 : }
238230 : #endif
238231 :
238232 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
238233 0 : return this;
238234 : }
238235 :
238236 : // *** COMMON CODE SECTION ENDS HERE ***
238237 :
238238 :
238239 : // End of memberFunctionString
238240 : // Start of memberFunctionString
238241 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
238242 :
238243 :
238244 : #if 0
238245 : //! Error checking support
238246 : /*! Verifies the following:
238247 : - working getVariant() member function
238248 : - calls base class's error() member function
238249 : Every class has one of these functions.
238250 : */
238251 : bool
238252 : SgSIMDScalarStore::error()
238253 : {
238254 : // Put error checking here
238255 :
238256 : ROSE_ASSERT (this != NULL);
238257 : if (getVariant() != SIMD_SCALAR_STORE)
238258 : {
238259 : printf ("Error in SgSIMDScalarStore::error(): SgSIMDScalarStore object has a %s variant \n",
238260 : Cxx_GrammarTerminalNames[getVariant()].name);
238261 : // printf ("Error in SgSIMDScalarStore::error() \n");
238262 : ROSE_ABORT();
238263 : }
238264 :
238265 : ROSE_ASSERT (getVariant() == SIMD_SCALAR_STORE);
238266 : return SgBinaryOp::error();
238267 : }
238268 : #endif
238269 :
238270 :
238271 :
238272 : // End of memberFunctionString
238273 :
238274 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
238275 :
238276 0 : SgSIMDScalarStore* isSgSIMDScalarStore ( SgNode* inputDerivedClassPointer )
238277 : {
238278 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238279 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238280 : // So to fix this we return NULL directly when the input is NULL and avoid the
238281 : // dynamic_cast in this case. This is likely a performance improvement as well.
238282 : // return dynamic_cast<SgSIMDScalarStore*>(inputDerivedClassPointer);
238283 : // Milind Chabbi (8/28/2013): isSgSIMDScalarStore uses table-driven castability instead of c++ default dynamic_cast
238284 : // this improves the running time performance by 10-20%.
238285 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDScalarStore*>(inputDerivedClassPointer);
238286 0 : return IS_SgSIMDScalarStore_FAST_MACRO(inputDerivedClassPointer);
238287 : }
238288 :
238289 : // DQ (11/8/2003): Added version of functions taking const pointer
238290 0 : const SgSIMDScalarStore* isSgSIMDScalarStore ( const SgNode* inputDerivedClassPointer )
238291 : {
238292 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238293 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238294 : // So to fix this we return NULL directly when the input is NULL and avoid the
238295 : // dynamic_cast in this case. This is likely a performance improvement as well.
238296 : // return dynamic_cast<const SgSIMDScalarStore*>(inputDerivedClassPointer);
238297 : // Milind Chabbi (8/28/2013): isSgSIMDScalarStore uses table-driven castability instead of c++ default dynamic_cast
238298 : // this improves the running time performance by 10-20%.
238299 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDScalarStore*>(inputDerivedClassPointer);
238300 0 : return IS_SgSIMDScalarStore_FAST_MACRO(inputDerivedClassPointer);
238301 : }
238302 :
238303 :
238304 :
238305 : /* #line 238306 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238306 :
238307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238308 :
238309 : /**
238310 : \brief Generated destructor
238311 :
238312 : This destructor is automatically generated (by ROSETTA). This destructor
238313 : only frees memory of data members associated with the parts of the current IR node which
238314 : are NOT traversed. Those data members that are part of a traversal can be freed using
238315 : a traversal (calling this destructor on all children in a post-order traversal). Such
238316 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
238317 :
238318 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
238319 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
238320 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
238321 :
238322 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
238323 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
238324 : pointers are not yet implemented to call delete on eash pointer in the container.
238325 : (This could be done by derivation from the STL containers to define containers that
238326 : automatically deleted their members.)
238327 :
238328 : */
238329 0 : SgSIMDScalarStore::~SgSIMDScalarStore () {
238330 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
238331 :
238332 :
238333 :
238334 : }
238335 :
238336 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238337 0 : }
238338 :
238339 :
238340 : /* #line 238341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238341 :
238342 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
238343 :
238344 : // Generated constructor
238345 0 : SgSIMDScalarStore::SgSIMDScalarStore ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
238346 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
238347 : {
238348 : #ifdef DEBUG
238349 : // printf ("In SgSIMDScalarStore::SgSIMDScalarStore (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
238350 : #endif
238351 : #if 0
238352 : // debugging information!
238353 : printf ("In SgSIMDScalarStore::SgSIMDScalarStore (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
238354 : #endif
238355 :
238356 :
238357 :
238358 : #if 0
238359 : // DQ (7/30/2014): Call a virtual function.
238360 : std::string s = this->class_name();
238361 : #endif
238362 :
238363 : // Test the variant virtual function
238364 : // assert(SIMD_SCALAR_STORE == variant());
238365 0 : assert(SIMD_SCALAR_STORE == this->variant());
238366 0 : ROSE_ASSERT(SIMD_SCALAR_STORE == (int)(this->variantT()));
238367 0 : post_construction_initialization();
238368 :
238369 : // Test the isSgSIMDScalarStore() function since it has been problematic
238370 0 : assert(isSgSIMDScalarStore(this) != NULL);
238371 0 : }
238372 :
238373 : // Generated constructor (all data members)
238374 :
238375 : /* #line 238376 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238376 :
238377 :
238378 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238379 :
238380 :
238381 : // ********************************************************
238382 : // member functions common across all array grammar objects
238383 : // ********************************************************
238384 :
238385 :
238386 :
238387 : /* #line 238388 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238388 :
238389 :
238390 :
238391 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238392 :
238393 : // ********************************************************
238394 : // member functions specific to each node in the grammar
238395 : // ********************************************************
238396 :
238397 :
238398 : /* #line 238399 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238399 :
238400 : // Start of memberFunctionString
238401 : /* #line 9607 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
238402 :
238403 0 : void SgSIMDGather::post_construction_initialization() {}
238404 :
238405 :
238406 : // End of memberFunctionString
238407 : // Start of memberFunctionString
238408 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
238409 :
238410 : // *** COMMON CODE SECTION BEGINS HERE ***
238411 :
238412 : #if 0
238413 : int
238414 : SgSIMDGather::getVariant() const
238415 : {
238416 : // This function is used in ROSE while "variant()" is used in SAGE
238417 : assert(this != NULL);
238418 : return variant();
238419 : }
238420 : #endif
238421 :
238422 : // This function is used in ROSE in treeTraversal code
238423 : // eventually replaces getVariant() and variant()
238424 : // though after variant() has been removed for a while we will
238425 : // want to change the name of variantT() back to variant()
238426 : // (since the "T" was ment to stand for temporary).
238427 : // When this happens the variantT() will be depricated.
238428 : VariantT
238429 0 : SgSIMDGather::variantT() const
238430 : {
238431 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
238432 0 : ROSE_ASSERT(this != NULL);
238433 0 : return V_SgSIMDGather;
238434 : }
238435 :
238436 : #if 0
238437 : int
238438 : SgSIMDGather::variant() const
238439 : {
238440 : // This function is used in SAGE
238441 : ROSE_ASSERT(this != NULL);
238442 : return SIMD_GATHER;
238443 : }
238444 : #endif
238445 :
238446 : ROSE_DLL_API const char*
238447 0 : SgSIMDGather::sage_class_name() const
238448 : {
238449 0 : ROSE_ASSERT(this != NULL);
238450 0 : return "SgSIMDGather";
238451 : }
238452 :
238453 : std::string
238454 0 : SgSIMDGather::class_name() const
238455 : {
238456 0 : ROSE_ASSERT(this != NULL);
238457 0 : return "SgSIMDGather";
238458 : }
238459 :
238460 : // DQ (11/26/2005): Support for visitor pattern mechanims
238461 : // (inferior to ROSE traversal mechanism, experimental).
238462 : void
238463 0 : SgSIMDGather::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
238464 : {
238465 0 : ROSE_ASSERT(this != NULL);
238466 0 : visitor.visit(this);
238467 0 : }
238468 :
238469 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
238470 0 : void SgSIMDGather::accept (ROSE_VisitorPattern & visitor) {
238471 0 : ROSE_ASSERT(this != NULL);
238472 0 : visitor.visit(this);
238473 0 : }
238474 :
238475 : SgSIMDGather*
238476 0 : SgSIMDGather::addRegExpAttribute(std::string s, AstRegExAttribute* a)
238477 : {
238478 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
238479 : // This function is currently only supported for the AST used the represent Binary executables.
238480 : if (0 /* isSgAsmNode(this) != NULL */)
238481 : {
238482 : // Support for regex specification.
238483 : std::string prefixCode = "REGEX:";
238484 : addNewAttribute(prefixCode + s,a);
238485 : }
238486 : #endif
238487 :
238488 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
238489 0 : return this;
238490 : }
238491 :
238492 : // *** COMMON CODE SECTION ENDS HERE ***
238493 :
238494 :
238495 : // End of memberFunctionString
238496 : // Start of memberFunctionString
238497 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
238498 :
238499 :
238500 : #if 0
238501 : //! Error checking support
238502 : /*! Verifies the following:
238503 : - working getVariant() member function
238504 : - calls base class's error() member function
238505 : Every class has one of these functions.
238506 : */
238507 : bool
238508 : SgSIMDGather::error()
238509 : {
238510 : // Put error checking here
238511 :
238512 : ROSE_ASSERT (this != NULL);
238513 : if (getVariant() != SIMD_GATHER)
238514 : {
238515 : printf ("Error in SgSIMDGather::error(): SgSIMDGather object has a %s variant \n",
238516 : Cxx_GrammarTerminalNames[getVariant()].name);
238517 : // printf ("Error in SgSIMDGather::error() \n");
238518 : ROSE_ABORT();
238519 : }
238520 :
238521 : ROSE_ASSERT (getVariant() == SIMD_GATHER);
238522 : return SgBinaryOp::error();
238523 : }
238524 : #endif
238525 :
238526 :
238527 :
238528 : // End of memberFunctionString
238529 :
238530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
238531 :
238532 0 : SgSIMDGather* isSgSIMDGather ( SgNode* inputDerivedClassPointer )
238533 : {
238534 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238535 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238536 : // So to fix this we return NULL directly when the input is NULL and avoid the
238537 : // dynamic_cast in this case. This is likely a performance improvement as well.
238538 : // return dynamic_cast<SgSIMDGather*>(inputDerivedClassPointer);
238539 : // Milind Chabbi (8/28/2013): isSgSIMDGather uses table-driven castability instead of c++ default dynamic_cast
238540 : // this improves the running time performance by 10-20%.
238541 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDGather*>(inputDerivedClassPointer);
238542 0 : return IS_SgSIMDGather_FAST_MACRO(inputDerivedClassPointer);
238543 : }
238544 :
238545 : // DQ (11/8/2003): Added version of functions taking const pointer
238546 0 : const SgSIMDGather* isSgSIMDGather ( const SgNode* inputDerivedClassPointer )
238547 : {
238548 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238549 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238550 : // So to fix this we return NULL directly when the input is NULL and avoid the
238551 : // dynamic_cast in this case. This is likely a performance improvement as well.
238552 : // return dynamic_cast<const SgSIMDGather*>(inputDerivedClassPointer);
238553 : // Milind Chabbi (8/28/2013): isSgSIMDGather uses table-driven castability instead of c++ default dynamic_cast
238554 : // this improves the running time performance by 10-20%.
238555 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDGather*>(inputDerivedClassPointer);
238556 0 : return IS_SgSIMDGather_FAST_MACRO(inputDerivedClassPointer);
238557 : }
238558 :
238559 :
238560 :
238561 : /* #line 238562 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238562 :
238563 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238564 :
238565 : /**
238566 : \brief Generated destructor
238567 :
238568 : This destructor is automatically generated (by ROSETTA). This destructor
238569 : only frees memory of data members associated with the parts of the current IR node which
238570 : are NOT traversed. Those data members that are part of a traversal can be freed using
238571 : a traversal (calling this destructor on all children in a post-order traversal). Such
238572 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
238573 :
238574 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
238575 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
238576 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
238577 :
238578 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
238579 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
238580 : pointers are not yet implemented to call delete on eash pointer in the container.
238581 : (This could be done by derivation from the STL containers to define containers that
238582 : automatically deleted their members.)
238583 :
238584 : */
238585 0 : SgSIMDGather::~SgSIMDGather () {
238586 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
238587 :
238588 :
238589 :
238590 : }
238591 :
238592 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238593 0 : }
238594 :
238595 :
238596 : /* #line 238597 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238597 :
238598 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
238599 :
238600 : // Generated constructor
238601 0 : SgSIMDGather::SgSIMDGather ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
238602 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
238603 : {
238604 : #ifdef DEBUG
238605 : // printf ("In SgSIMDGather::SgSIMDGather (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
238606 : #endif
238607 : #if 0
238608 : // debugging information!
238609 : printf ("In SgSIMDGather::SgSIMDGather (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
238610 : #endif
238611 :
238612 :
238613 :
238614 : #if 0
238615 : // DQ (7/30/2014): Call a virtual function.
238616 : std::string s = this->class_name();
238617 : #endif
238618 :
238619 : // Test the variant virtual function
238620 : // assert(SIMD_GATHER == variant());
238621 0 : assert(SIMD_GATHER == this->variant());
238622 0 : ROSE_ASSERT(SIMD_GATHER == (int)(this->variantT()));
238623 0 : post_construction_initialization();
238624 :
238625 : // Test the isSgSIMDGather() function since it has been problematic
238626 0 : assert(isSgSIMDGather(this) != NULL);
238627 0 : }
238628 :
238629 : // Generated constructor (all data members)
238630 :
238631 : /* #line 238632 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238632 :
238633 :
238634 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238635 :
238636 :
238637 : // ********************************************************
238638 : // member functions common across all array grammar objects
238639 : // ********************************************************
238640 :
238641 :
238642 :
238643 : /* #line 238644 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238644 :
238645 :
238646 :
238647 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238648 :
238649 : // ********************************************************
238650 : // member functions specific to each node in the grammar
238651 : // ********************************************************
238652 :
238653 :
238654 : /* #line 238655 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238655 :
238656 : // Start of memberFunctionString
238657 : /* #line 9615 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
238658 :
238659 0 : void SgSIMDExplicitGather::post_construction_initialization() {}
238660 :
238661 :
238662 : // End of memberFunctionString
238663 : // Start of memberFunctionString
238664 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
238665 :
238666 : // *** COMMON CODE SECTION BEGINS HERE ***
238667 :
238668 : #if 0
238669 : int
238670 : SgSIMDExplicitGather::getVariant() const
238671 : {
238672 : // This function is used in ROSE while "variant()" is used in SAGE
238673 : assert(this != NULL);
238674 : return variant();
238675 : }
238676 : #endif
238677 :
238678 : // This function is used in ROSE in treeTraversal code
238679 : // eventually replaces getVariant() and variant()
238680 : // though after variant() has been removed for a while we will
238681 : // want to change the name of variantT() back to variant()
238682 : // (since the "T" was ment to stand for temporary).
238683 : // When this happens the variantT() will be depricated.
238684 : VariantT
238685 0 : SgSIMDExplicitGather::variantT() const
238686 : {
238687 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
238688 0 : ROSE_ASSERT(this != NULL);
238689 0 : return V_SgSIMDExplicitGather;
238690 : }
238691 :
238692 : #if 0
238693 : int
238694 : SgSIMDExplicitGather::variant() const
238695 : {
238696 : // This function is used in SAGE
238697 : ROSE_ASSERT(this != NULL);
238698 : return SIMD_EXPLICIT_GATHER;
238699 : }
238700 : #endif
238701 :
238702 : ROSE_DLL_API const char*
238703 0 : SgSIMDExplicitGather::sage_class_name() const
238704 : {
238705 0 : ROSE_ASSERT(this != NULL);
238706 0 : return "SgSIMDExplicitGather";
238707 : }
238708 :
238709 : std::string
238710 0 : SgSIMDExplicitGather::class_name() const
238711 : {
238712 0 : ROSE_ASSERT(this != NULL);
238713 0 : return "SgSIMDExplicitGather";
238714 : }
238715 :
238716 : // DQ (11/26/2005): Support for visitor pattern mechanims
238717 : // (inferior to ROSE traversal mechanism, experimental).
238718 : void
238719 0 : SgSIMDExplicitGather::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
238720 : {
238721 0 : ROSE_ASSERT(this != NULL);
238722 0 : visitor.visit(this);
238723 0 : }
238724 :
238725 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
238726 0 : void SgSIMDExplicitGather::accept (ROSE_VisitorPattern & visitor) {
238727 0 : ROSE_ASSERT(this != NULL);
238728 0 : visitor.visit(this);
238729 0 : }
238730 :
238731 : SgSIMDExplicitGather*
238732 0 : SgSIMDExplicitGather::addRegExpAttribute(std::string s, AstRegExAttribute* a)
238733 : {
238734 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
238735 : // This function is currently only supported for the AST used the represent Binary executables.
238736 : if (0 /* isSgAsmNode(this) != NULL */)
238737 : {
238738 : // Support for regex specification.
238739 : std::string prefixCode = "REGEX:";
238740 : addNewAttribute(prefixCode + s,a);
238741 : }
238742 : #endif
238743 :
238744 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
238745 0 : return this;
238746 : }
238747 :
238748 : // *** COMMON CODE SECTION ENDS HERE ***
238749 :
238750 :
238751 : // End of memberFunctionString
238752 : // Start of memberFunctionString
238753 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
238754 :
238755 :
238756 : #if 0
238757 : //! Error checking support
238758 : /*! Verifies the following:
238759 : - working getVariant() member function
238760 : - calls base class's error() member function
238761 : Every class has one of these functions.
238762 : */
238763 : bool
238764 : SgSIMDExplicitGather::error()
238765 : {
238766 : // Put error checking here
238767 :
238768 : ROSE_ASSERT (this != NULL);
238769 : if (getVariant() != SIMD_EXPLICIT_GATHER)
238770 : {
238771 : printf ("Error in SgSIMDExplicitGather::error(): SgSIMDExplicitGather object has a %s variant \n",
238772 : Cxx_GrammarTerminalNames[getVariant()].name);
238773 : // printf ("Error in SgSIMDExplicitGather::error() \n");
238774 : ROSE_ABORT();
238775 : }
238776 :
238777 : ROSE_ASSERT (getVariant() == SIMD_EXPLICIT_GATHER);
238778 : return SgBinaryOp::error();
238779 : }
238780 : #endif
238781 :
238782 :
238783 :
238784 : // End of memberFunctionString
238785 :
238786 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
238787 :
238788 0 : SgSIMDExplicitGather* isSgSIMDExplicitGather ( SgNode* inputDerivedClassPointer )
238789 : {
238790 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238791 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238792 : // So to fix this we return NULL directly when the input is NULL and avoid the
238793 : // dynamic_cast in this case. This is likely a performance improvement as well.
238794 : // return dynamic_cast<SgSIMDExplicitGather*>(inputDerivedClassPointer);
238795 : // Milind Chabbi (8/28/2013): isSgSIMDExplicitGather uses table-driven castability instead of c++ default dynamic_cast
238796 : // this improves the running time performance by 10-20%.
238797 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDExplicitGather*>(inputDerivedClassPointer);
238798 0 : return IS_SgSIMDExplicitGather_FAST_MACRO(inputDerivedClassPointer);
238799 : }
238800 :
238801 : // DQ (11/8/2003): Added version of functions taking const pointer
238802 0 : const SgSIMDExplicitGather* isSgSIMDExplicitGather ( const SgNode* inputDerivedClassPointer )
238803 : {
238804 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
238805 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
238806 : // So to fix this we return NULL directly when the input is NULL and avoid the
238807 : // dynamic_cast in this case. This is likely a performance improvement as well.
238808 : // return dynamic_cast<const SgSIMDExplicitGather*>(inputDerivedClassPointer);
238809 : // Milind Chabbi (8/28/2013): isSgSIMDExplicitGather uses table-driven castability instead of c++ default dynamic_cast
238810 : // this improves the running time performance by 10-20%.
238811 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDExplicitGather*>(inputDerivedClassPointer);
238812 0 : return IS_SgSIMDExplicitGather_FAST_MACRO(inputDerivedClassPointer);
238813 : }
238814 :
238815 :
238816 :
238817 : /* #line 238818 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238818 :
238819 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238820 :
238821 : /**
238822 : \brief Generated destructor
238823 :
238824 : This destructor is automatically generated (by ROSETTA). This destructor
238825 : only frees memory of data members associated with the parts of the current IR node which
238826 : are NOT traversed. Those data members that are part of a traversal can be freed using
238827 : a traversal (calling this destructor on all children in a post-order traversal). Such
238828 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
238829 :
238830 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
238831 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
238832 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
238833 :
238834 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
238835 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
238836 : pointers are not yet implemented to call delete on eash pointer in the container.
238837 : (This could be done by derivation from the STL containers to define containers that
238838 : automatically deleted their members.)
238839 :
238840 : */
238841 0 : SgSIMDExplicitGather::~SgSIMDExplicitGather () {
238842 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
238843 :
238844 :
238845 :
238846 : }
238847 :
238848 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
238849 0 : }
238850 :
238851 :
238852 : /* #line 238853 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238853 :
238854 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
238855 :
238856 : // Generated constructor
238857 0 : SgSIMDExplicitGather::SgSIMDExplicitGather ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
238858 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
238859 : {
238860 : #ifdef DEBUG
238861 : // printf ("In SgSIMDExplicitGather::SgSIMDExplicitGather (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
238862 : #endif
238863 : #if 0
238864 : // debugging information!
238865 : printf ("In SgSIMDExplicitGather::SgSIMDExplicitGather (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
238866 : #endif
238867 :
238868 :
238869 :
238870 : #if 0
238871 : // DQ (7/30/2014): Call a virtual function.
238872 : std::string s = this->class_name();
238873 : #endif
238874 :
238875 : // Test the variant virtual function
238876 : // assert(SIMD_EXPLICIT_GATHER == variant());
238877 0 : assert(SIMD_EXPLICIT_GATHER == this->variant());
238878 0 : ROSE_ASSERT(SIMD_EXPLICIT_GATHER == (int)(this->variantT()));
238879 0 : post_construction_initialization();
238880 :
238881 : // Test the isSgSIMDExplicitGather() function since it has been problematic
238882 0 : assert(isSgSIMDExplicitGather(this) != NULL);
238883 0 : }
238884 :
238885 : // Generated constructor (all data members)
238886 :
238887 : /* #line 238888 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238888 :
238889 :
238890 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238891 :
238892 :
238893 : // ********************************************************
238894 : // member functions common across all array grammar objects
238895 : // ********************************************************
238896 :
238897 :
238898 :
238899 : /* #line 238900 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238900 :
238901 :
238902 :
238903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
238904 :
238905 : // ********************************************************
238906 : // member functions specific to each node in the grammar
238907 : // ********************************************************
238908 :
238909 :
238910 : /* #line 238911 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
238911 :
238912 : // Start of memberFunctionString
238913 : /* #line 9623 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
238914 :
238915 0 : void SgSIMDScatter::post_construction_initialization() {}
238916 :
238917 :
238918 : // End of memberFunctionString
238919 : // Start of memberFunctionString
238920 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
238921 :
238922 : // *** COMMON CODE SECTION BEGINS HERE ***
238923 :
238924 : #if 0
238925 : int
238926 : SgSIMDScatter::getVariant() const
238927 : {
238928 : // This function is used in ROSE while "variant()" is used in SAGE
238929 : assert(this != NULL);
238930 : return variant();
238931 : }
238932 : #endif
238933 :
238934 : // This function is used in ROSE in treeTraversal code
238935 : // eventually replaces getVariant() and variant()
238936 : // though after variant() has been removed for a while we will
238937 : // want to change the name of variantT() back to variant()
238938 : // (since the "T" was ment to stand for temporary).
238939 : // When this happens the variantT() will be depricated.
238940 : VariantT
238941 0 : SgSIMDScatter::variantT() const
238942 : {
238943 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
238944 0 : ROSE_ASSERT(this != NULL);
238945 0 : return V_SgSIMDScatter;
238946 : }
238947 :
238948 : #if 0
238949 : int
238950 : SgSIMDScatter::variant() const
238951 : {
238952 : // This function is used in SAGE
238953 : ROSE_ASSERT(this != NULL);
238954 : return SIMD_SCATTER;
238955 : }
238956 : #endif
238957 :
238958 : ROSE_DLL_API const char*
238959 0 : SgSIMDScatter::sage_class_name() const
238960 : {
238961 0 : ROSE_ASSERT(this != NULL);
238962 0 : return "SgSIMDScatter";
238963 : }
238964 :
238965 : std::string
238966 0 : SgSIMDScatter::class_name() const
238967 : {
238968 0 : ROSE_ASSERT(this != NULL);
238969 0 : return "SgSIMDScatter";
238970 : }
238971 :
238972 : // DQ (11/26/2005): Support for visitor pattern mechanims
238973 : // (inferior to ROSE traversal mechanism, experimental).
238974 : void
238975 0 : SgSIMDScatter::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
238976 : {
238977 0 : ROSE_ASSERT(this != NULL);
238978 0 : visitor.visit(this);
238979 0 : }
238980 :
238981 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
238982 0 : void SgSIMDScatter::accept (ROSE_VisitorPattern & visitor) {
238983 0 : ROSE_ASSERT(this != NULL);
238984 0 : visitor.visit(this);
238985 0 : }
238986 :
238987 : SgSIMDScatter*
238988 0 : SgSIMDScatter::addRegExpAttribute(std::string s, AstRegExAttribute* a)
238989 : {
238990 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
238991 : // This function is currently only supported for the AST used the represent Binary executables.
238992 : if (0 /* isSgAsmNode(this) != NULL */)
238993 : {
238994 : // Support for regex specification.
238995 : std::string prefixCode = "REGEX:";
238996 : addNewAttribute(prefixCode + s,a);
238997 : }
238998 : #endif
238999 :
239000 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
239001 0 : return this;
239002 : }
239003 :
239004 : // *** COMMON CODE SECTION ENDS HERE ***
239005 :
239006 :
239007 : // End of memberFunctionString
239008 : // Start of memberFunctionString
239009 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
239010 :
239011 :
239012 : #if 0
239013 : //! Error checking support
239014 : /*! Verifies the following:
239015 : - working getVariant() member function
239016 : - calls base class's error() member function
239017 : Every class has one of these functions.
239018 : */
239019 : bool
239020 : SgSIMDScatter::error()
239021 : {
239022 : // Put error checking here
239023 :
239024 : ROSE_ASSERT (this != NULL);
239025 : if (getVariant() != SIMD_SCATTER)
239026 : {
239027 : printf ("Error in SgSIMDScatter::error(): SgSIMDScatter object has a %s variant \n",
239028 : Cxx_GrammarTerminalNames[getVariant()].name);
239029 : // printf ("Error in SgSIMDScatter::error() \n");
239030 : ROSE_ABORT();
239031 : }
239032 :
239033 : ROSE_ASSERT (getVariant() == SIMD_SCATTER);
239034 : return SgBinaryOp::error();
239035 : }
239036 : #endif
239037 :
239038 :
239039 :
239040 : // End of memberFunctionString
239041 :
239042 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
239043 :
239044 0 : SgSIMDScatter* isSgSIMDScatter ( SgNode* inputDerivedClassPointer )
239045 : {
239046 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
239047 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
239048 : // So to fix this we return NULL directly when the input is NULL and avoid the
239049 : // dynamic_cast in this case. This is likely a performance improvement as well.
239050 : // return dynamic_cast<SgSIMDScatter*>(inputDerivedClassPointer);
239051 : // Milind Chabbi (8/28/2013): isSgSIMDScatter uses table-driven castability instead of c++ default dynamic_cast
239052 : // this improves the running time performance by 10-20%.
239053 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSIMDScatter*>(inputDerivedClassPointer);
239054 0 : return IS_SgSIMDScatter_FAST_MACRO(inputDerivedClassPointer);
239055 : }
239056 :
239057 : // DQ (11/8/2003): Added version of functions taking const pointer
239058 0 : const SgSIMDScatter* isSgSIMDScatter ( const SgNode* inputDerivedClassPointer )
239059 : {
239060 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
239061 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
239062 : // So to fix this we return NULL directly when the input is NULL and avoid the
239063 : // dynamic_cast in this case. This is likely a performance improvement as well.
239064 : // return dynamic_cast<const SgSIMDScatter*>(inputDerivedClassPointer);
239065 : // Milind Chabbi (8/28/2013): isSgSIMDScatter uses table-driven castability instead of c++ default dynamic_cast
239066 : // this improves the running time performance by 10-20%.
239067 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSIMDScatter*>(inputDerivedClassPointer);
239068 0 : return IS_SgSIMDScatter_FAST_MACRO(inputDerivedClassPointer);
239069 : }
239070 :
239071 :
239072 :
239073 : /* #line 239074 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239074 :
239075 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
239076 :
239077 : /**
239078 : \brief Generated destructor
239079 :
239080 : This destructor is automatically generated (by ROSETTA). This destructor
239081 : only frees memory of data members associated with the parts of the current IR node which
239082 : are NOT traversed. Those data members that are part of a traversal can be freed using
239083 : a traversal (calling this destructor on all children in a post-order traversal). Such
239084 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
239085 :
239086 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
239087 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
239088 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
239089 :
239090 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
239091 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
239092 : pointers are not yet implemented to call delete on eash pointer in the container.
239093 : (This could be done by derivation from the STL containers to define containers that
239094 : automatically deleted their members.)
239095 :
239096 : */
239097 0 : SgSIMDScatter::~SgSIMDScatter () {
239098 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
239099 :
239100 :
239101 :
239102 : }
239103 :
239104 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
239105 0 : }
239106 :
239107 :
239108 : /* #line 239109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239109 :
239110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
239111 :
239112 : // Generated constructor
239113 0 : SgSIMDScatter::SgSIMDScatter ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type )
239114 0 : : SgBinaryOp(startOfConstruct, lhs_operand_i, rhs_operand_i, expression_type)
239115 : {
239116 : #ifdef DEBUG
239117 : // printf ("In SgSIMDScatter::SgSIMDScatter (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
239118 : #endif
239119 : #if 0
239120 : // debugging information!
239121 : printf ("In SgSIMDScatter::SgSIMDScatter (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand_i, SgExpression* rhs_operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
239122 : #endif
239123 :
239124 :
239125 :
239126 : #if 0
239127 : // DQ (7/30/2014): Call a virtual function.
239128 : std::string s = this->class_name();
239129 : #endif
239130 :
239131 : // Test the variant virtual function
239132 : // assert(SIMD_SCATTER == variant());
239133 0 : assert(SIMD_SCATTER == this->variant());
239134 0 : ROSE_ASSERT(SIMD_SCATTER == (int)(this->variantT()));
239135 0 : post_construction_initialization();
239136 :
239137 : // Test the isSgSIMDScatter() function since it has been problematic
239138 0 : assert(isSgSIMDScatter(this) != NULL);
239139 0 : }
239140 :
239141 : // Generated constructor (all data members)
239142 :
239143 : /* #line 239144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239144 :
239145 :
239146 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
239147 :
239148 :
239149 : // ********************************************************
239150 : // member functions common across all array grammar objects
239151 : // ********************************************************
239152 :
239153 :
239154 :
239155 : /* #line 239156 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239156 :
239157 :
239158 :
239159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
239160 :
239161 : // ********************************************************
239162 : // member functions specific to each node in the grammar
239163 : // ********************************************************
239164 :
239165 :
239166 : /* #line 239167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239167 :
239168 : // Start of memberFunctionString
239169 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239170 :
239171 : void
239172 38919 : SgExprListExp::post_construction_initialization()
239173 : {
239174 38919 : }
239175 :
239176 :
239177 :
239178 : // End of memberFunctionString
239179 : // Start of memberFunctionString
239180 :
239181 :
239182 : // End of memberFunctionString
239183 : // Start of memberFunctionString
239184 : /* #line 3143 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239185 :
239186 : bool
239187 0 : SgExprListExp::empty() const
239188 : {
239189 0 : if (p_expressions.empty())
239190 : return 1;
239191 : else
239192 0 : return 0;
239193 : }
239194 :
239195 : SgExpressionPtrList&
239196 9126 : SgExprListExp::get_expressions()
239197 9126 : { return p_expressions; }
239198 :
239199 : const SgExpressionPtrList&
239200 11494 : SgExprListExp::get_expressions() const
239201 11494 : { return p_expressions; }
239202 :
239203 0 : void SgExprListExp::set_expressions(SgExpressionPtrList e_list)
239204 0 : { p_expressions= e_list; }
239205 :
239206 : void
239207 40938 : SgExprListExp::append_expression(SgExpression *what)
239208 40938 : { what->set_parent(this); p_expressions.push_back(what); }
239209 :
239210 : void
239211 700 : SgExprListExp::prepend_expression(SgExpression *what)
239212 700 : { what->set_parent(this); p_expressions.insert(p_expressions.begin(), what); }
239213 :
239214 : #if 0
239215 : void
239216 : SgExprListExp::insert_expression(const SgExpressionPtrList::iterator &where, SgExpression *what)
239217 : {
239218 : // #ifndef REMOVE_SET_PARENT_FUNCTION
239219 : what->set_parent(this);
239220 : // #endif
239221 : p_expressions.insert(where,what);
239222 : }
239223 : #endif
239224 :
239225 : #if 0
239226 : SgExpression*
239227 : SgExprListExp::get_first() const
239228 : {
239229 : if(get_expressions().empty())
239230 : return 0;
239231 : SgExpressionPtrList::const_iterator p=get_expressions().begin();
239232 : ROSE_ASSERT( (*p) != NULL );
239233 : return (*p);
239234 : }
239235 : #endif
239236 :
239237 : #if 0
239238 : SgExpression*
239239 : SgExprListExp::get_end() const
239240 : {
239241 : return NULL;
239242 : }
239243 : #endif
239244 :
239245 : #if 0
239246 : int
239247 : SgExprListExp::get_index(SgExpression *e) const
239248 : {
239249 : if(get_expressions().empty()) return -1;
239250 : SgExpressionPtrList::const_iterator p=get_expressions().begin();
239251 : int i=0;
239252 : while(p!=p_expressions.end())
239253 : {
239254 : #if 0
239255 : if( (*p).irep()== e )
239256 : return i;
239257 : #else
239258 : printf ("ERROR: not yet implemented in SAGE3 \n");
239259 : abort();
239260 : #endif
239261 : i++;
239262 : p++;
239263 : }
239264 : return -1;
239265 : }
239266 : #endif
239267 :
239268 : #if 1
239269 : int
239270 2 : SgExprListExp::replace_expression(SgExpression *o, SgExpression *n)
239271 : {
239272 : // DQ (10/5/2007): This is a new version of this function (from Jeremiah) which observes STL vector iterator semantics.
239273 :
239274 : // DQ (12/17/2006): This function should have the semantics that it will represent a
239275 : // structural change to the AST, thus it is free to set the parent of the new expression.
239276 :
239277 2 : ROSE_ASSERT(o != NULL);
239278 2 : ROSE_ASSERT(n != NULL);
239279 :
239280 3 : for (SgExpressionPtrList::iterator i=p_expressions.begin();
239281 3 : i != p_expressions.end(); ++i)
239282 : {
239283 3 : if( (*i) == o)
239284 : {
239285 2 : *i = n;
239286 2 : return 1;
239287 : }
239288 : }
239289 : return 0;
239290 : }
239291 : #else
239292 : int
239293 : SgExprListExp::replace_expression(SgExpression *o, SgExpression *n)
239294 : {
239295 : // DQ (12/17/2006): This function should have the semantics that it will represent a
239296 : // structural change to the AST, thus it is free to set the parent of the new expression.
239297 :
239298 : ROSE_ASSERT(o != NULL);
239299 : ROSE_ASSERT(n != NULL);
239300 :
239301 : SgExpressionPtrList::iterator i=p_expressions.begin();
239302 : while (i != p_expressions.end())
239303 : {
239304 : if( (*i) == o)
239305 : {
239306 : insert_expression(i, n);
239307 : p_expressions.erase(i);
239308 : return 1;
239309 : }
239310 : /*
239311 : printf ("ERROR: not yet implemented in SAGE3 \n");
239312 : abort();
239313 : */
239314 : i++;
239315 : }
239316 : return 0;
239317 : }
239318 : #endif
239319 :
239320 : #if 0
239321 : void
239322 : SgExprListExp::insert_expression(SgExpression *o, SgExpression *n, int inFront)
239323 : {
239324 : SgExpressionPtrList::iterator i=p_expressions.begin();
239325 : while(i!=p_expressions.end())
239326 : {
239327 : #if 0
239328 : if((*i).irep() == o)
239329 : {
239330 : if(!inFront) i++;
239331 : #ifndef REMOVE_SET_PARENT_FUNCTION
239332 : n->set_parent(this);
239333 : #endif
239334 : insert_expression(i,n);
239335 : }
239336 : #else
239337 : printf ("ERROR: not yet implemented in SAGE3 \n");
239338 : abort();
239339 : #endif
239340 : }
239341 : }
239342 : #endif
239343 :
239344 :
239345 :
239346 : // End of memberFunctionString
239347 : // Start of memberFunctionString
239348 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239349 :
239350 : SgType*
239351 :
239352 30890 : SgExprListExp::get_type() const
239353 : {
239354 30890 : ROSE_ASSERT(this != NULL);
239355 :
239356 : #if 0
239357 : printf ("In SgExprListExp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
239358 : #endif
239359 :
239360 : // DQ (10/31/2016): Debugging...
239361 : // return SgTypeDefault::createType();
239362 30890 : SgType* returnType = SgTypeDefault::createType();
239363 :
239364 : #if 0
239365 : printf ("Leaving SgExprListExp::get_type() (default_get_type) returnType = %p \n",returnType);
239366 : #endif
239367 :
239368 30890 : return returnType;
239369 : }
239370 :
239371 :
239372 :
239373 : // End of memberFunctionString
239374 : // Start of memberFunctionString
239375 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
239376 :
239377 : // *** COMMON CODE SECTION BEGINS HERE ***
239378 :
239379 : #if 0
239380 : int
239381 : SgExprListExp::getVariant() const
239382 : {
239383 : // This function is used in ROSE while "variant()" is used in SAGE
239384 : assert(this != NULL);
239385 : return variant();
239386 : }
239387 : #endif
239388 :
239389 : // This function is used in ROSE in treeTraversal code
239390 : // eventually replaces getVariant() and variant()
239391 : // though after variant() has been removed for a while we will
239392 : // want to change the name of variantT() back to variant()
239393 : // (since the "T" was ment to stand for temporary).
239394 : // When this happens the variantT() will be depricated.
239395 : VariantT
239396 13227700 : SgExprListExp::variantT() const
239397 : {
239398 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
239399 13227700 : ROSE_ASSERT(this != NULL);
239400 13227700 : return V_SgExprListExp;
239401 : }
239402 :
239403 : #if 0
239404 : int
239405 : SgExprListExp::variant() const
239406 : {
239407 : // This function is used in SAGE
239408 : ROSE_ASSERT(this != NULL);
239409 : return EXPR_LIST;
239410 : }
239411 : #endif
239412 :
239413 : ROSE_DLL_API const char*
239414 1541 : SgExprListExp::sage_class_name() const
239415 : {
239416 1541 : ROSE_ASSERT(this != NULL);
239417 1541 : return "SgExprListExp";
239418 : }
239419 :
239420 : std::string
239421 32448 : SgExprListExp::class_name() const
239422 : {
239423 32448 : ROSE_ASSERT(this != NULL);
239424 32448 : return "SgExprListExp";
239425 : }
239426 :
239427 : // DQ (11/26/2005): Support for visitor pattern mechanims
239428 : // (inferior to ROSE traversal mechanism, experimental).
239429 : void
239430 527761 : SgExprListExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
239431 : {
239432 527761 : ROSE_ASSERT(this != NULL);
239433 527761 : visitor.visit(this);
239434 527761 : }
239435 :
239436 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
239437 0 : void SgExprListExp::accept (ROSE_VisitorPattern & visitor) {
239438 0 : ROSE_ASSERT(this != NULL);
239439 0 : visitor.visit(this);
239440 0 : }
239441 :
239442 : SgExprListExp*
239443 0 : SgExprListExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
239444 : {
239445 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
239446 : // This function is currently only supported for the AST used the represent Binary executables.
239447 : if (0 /* isSgAsmNode(this) != NULL */)
239448 : {
239449 : // Support for regex specification.
239450 : std::string prefixCode = "REGEX:";
239451 : addNewAttribute(prefixCode + s,a);
239452 : }
239453 : #endif
239454 :
239455 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
239456 0 : return this;
239457 : }
239458 :
239459 : // *** COMMON CODE SECTION ENDS HERE ***
239460 :
239461 :
239462 : // End of memberFunctionString
239463 : // Start of memberFunctionString
239464 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
239465 :
239466 :
239467 : #if 0
239468 : //! Error checking support
239469 : /*! Verifies the following:
239470 : - working getVariant() member function
239471 : - calls base class's error() member function
239472 : Every class has one of these functions.
239473 : */
239474 : bool
239475 : SgExprListExp::error()
239476 : {
239477 : // Put error checking here
239478 :
239479 : ROSE_ASSERT (this != NULL);
239480 : if (getVariant() != EXPR_LIST)
239481 : {
239482 : printf ("Error in SgExprListExp::error(): SgExprListExp object has a %s variant \n",
239483 : Cxx_GrammarTerminalNames[getVariant()].name);
239484 : // printf ("Error in SgExprListExp::error() \n");
239485 : ROSE_ABORT();
239486 : }
239487 :
239488 : ROSE_ASSERT (getVariant() == EXPR_LIST);
239489 : return SgExpression::error();
239490 : }
239491 : #endif
239492 :
239493 :
239494 :
239495 : // End of memberFunctionString
239496 :
239497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
239498 :
239499 76497 : SgExprListExp* isSgExprListExp ( SgNode* inputDerivedClassPointer )
239500 : {
239501 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
239502 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
239503 : // So to fix this we return NULL directly when the input is NULL and avoid the
239504 : // dynamic_cast in this case. This is likely a performance improvement as well.
239505 : // return dynamic_cast<SgExprListExp*>(inputDerivedClassPointer);
239506 : // Milind Chabbi (8/28/2013): isSgExprListExp uses table-driven castability instead of c++ default dynamic_cast
239507 : // this improves the running time performance by 10-20%.
239508 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgExprListExp*>(inputDerivedClassPointer);
239509 76497 : return IS_SgExprListExp_FAST_MACRO(inputDerivedClassPointer);
239510 : }
239511 :
239512 : // DQ (11/8/2003): Added version of functions taking const pointer
239513 9333 : const SgExprListExp* isSgExprListExp ( const SgNode* inputDerivedClassPointer )
239514 : {
239515 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
239516 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
239517 : // So to fix this we return NULL directly when the input is NULL and avoid the
239518 : // dynamic_cast in this case. This is likely a performance improvement as well.
239519 : // return dynamic_cast<const SgExprListExp*>(inputDerivedClassPointer);
239520 : // Milind Chabbi (8/28/2013): isSgExprListExp uses table-driven castability instead of c++ default dynamic_cast
239521 : // this improves the running time performance by 10-20%.
239522 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgExprListExp*>(inputDerivedClassPointer);
239523 9333 : return IS_SgExprListExp_FAST_MACRO(inputDerivedClassPointer);
239524 : }
239525 :
239526 :
239527 :
239528 : /* #line 239529 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239529 :
239530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
239531 :
239532 : /**
239533 : \brief Generated destructor
239534 :
239535 : This destructor is automatically generated (by ROSETTA). This destructor
239536 : only frees memory of data members associated with the parts of the current IR node which
239537 : are NOT traversed. Those data members that are part of a traversal can be freed using
239538 : a traversal (calling this destructor on all children in a post-order traversal). Such
239539 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
239540 :
239541 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
239542 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
239543 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
239544 :
239545 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
239546 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
239547 : pointers are not yet implemented to call delete on eash pointer in the container.
239548 : (This could be done by derivation from the STL containers to define containers that
239549 : automatically deleted their members.)
239550 :
239551 : */
239552 21284 : SgExprListExp::~SgExprListExp () {
239553 8125 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
239554 :
239555 :
239556 :
239557 : }
239558 :
239559 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
239560 16250 : }
239561 :
239562 :
239563 : /* #line 239564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239564 :
239565 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
239566 :
239567 : // Generated constructor
239568 821 : SgExprListExp::SgExprListExp ( Sg_File_Info* startOfConstruct )
239569 821 : : SgExpression(startOfConstruct)
239570 : {
239571 : #ifdef DEBUG
239572 : // printf ("In SgExprListExp::SgExprListExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
239573 : #endif
239574 : #if 0
239575 : // debugging information!
239576 : printf ("In SgExprListExp::SgExprListExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
239577 : #endif
239578 :
239579 :
239580 :
239581 : #if 0
239582 : // DQ (7/30/2014): Call a virtual function.
239583 : std::string s = this->class_name();
239584 : #endif
239585 :
239586 : // Test the variant virtual function
239587 : // assert(EXPR_LIST == variant());
239588 821 : assert(EXPR_LIST == this->variant());
239589 821 : ROSE_ASSERT(EXPR_LIST == (int)(this->variantT()));
239590 821 : post_construction_initialization();
239591 :
239592 : // Test the isSgExprListExp() function since it has been problematic
239593 821 : assert(isSgExprListExp(this) != NULL);
239594 821 : }
239595 :
239596 : // Generated constructor (all data members)
239597 :
239598 : /* #line 239599 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239599 :
239600 :
239601 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
239602 :
239603 :
239604 : // ********************************************************
239605 : // member functions common across all array grammar objects
239606 : // ********************************************************
239607 :
239608 :
239609 :
239610 : /* #line 239611 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239611 :
239612 :
239613 :
239614 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
239615 :
239616 : // ********************************************************
239617 : // member functions specific to each node in the grammar
239618 : // ********************************************************
239619 :
239620 :
239621 : /* #line 239622 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239622 :
239623 : // Start of memberFunctionString
239624 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239625 :
239626 : void
239627 0 : SgListExp::post_construction_initialization()
239628 : {
239629 0 : }
239630 :
239631 :
239632 :
239633 : // End of memberFunctionString
239634 : // Start of memberFunctionString
239635 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239636 :
239637 : SgType*
239638 :
239639 0 : SgListExp::get_type() const
239640 : {
239641 0 : ROSE_ASSERT(this != NULL);
239642 :
239643 : #if 0
239644 : printf ("In SgListExp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
239645 : #endif
239646 :
239647 : // DQ (10/31/2016): Debugging...
239648 : // return SgTypeDefault::createType();
239649 0 : SgType* returnType = SgTypeDefault::createType();
239650 :
239651 : #if 0
239652 : printf ("Leaving SgListExp::get_type() (default_get_type) returnType = %p \n",returnType);
239653 : #endif
239654 :
239655 0 : return returnType;
239656 : }
239657 :
239658 :
239659 :
239660 : // End of memberFunctionString
239661 : // Start of memberFunctionString
239662 : /* #line 7049 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239663 :
239664 :
239665 :
239666 : // End of memberFunctionString
239667 : // Start of memberFunctionString
239668 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
239669 :
239670 : // *** COMMON CODE SECTION BEGINS HERE ***
239671 :
239672 : #if 0
239673 : int
239674 : SgListExp::getVariant() const
239675 : {
239676 : // This function is used in ROSE while "variant()" is used in SAGE
239677 : assert(this != NULL);
239678 : return variant();
239679 : }
239680 : #endif
239681 :
239682 : // This function is used in ROSE in treeTraversal code
239683 : // eventually replaces getVariant() and variant()
239684 : // though after variant() has been removed for a while we will
239685 : // want to change the name of variantT() back to variant()
239686 : // (since the "T" was ment to stand for temporary).
239687 : // When this happens the variantT() will be depricated.
239688 : VariantT
239689 0 : SgListExp::variantT() const
239690 : {
239691 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
239692 0 : ROSE_ASSERT(this != NULL);
239693 0 : return V_SgListExp;
239694 : }
239695 :
239696 : #if 0
239697 : int
239698 : SgListExp::variant() const
239699 : {
239700 : // This function is used in SAGE
239701 : ROSE_ASSERT(this != NULL);
239702 : return LIST_EXP;
239703 : }
239704 : #endif
239705 :
239706 : ROSE_DLL_API const char*
239707 0 : SgListExp::sage_class_name() const
239708 : {
239709 0 : ROSE_ASSERT(this != NULL);
239710 0 : return "SgListExp";
239711 : }
239712 :
239713 : std::string
239714 0 : SgListExp::class_name() const
239715 : {
239716 0 : ROSE_ASSERT(this != NULL);
239717 0 : return "SgListExp";
239718 : }
239719 :
239720 : // DQ (11/26/2005): Support for visitor pattern mechanims
239721 : // (inferior to ROSE traversal mechanism, experimental).
239722 : void
239723 0 : SgListExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
239724 : {
239725 0 : ROSE_ASSERT(this != NULL);
239726 0 : visitor.visit(this);
239727 0 : }
239728 :
239729 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
239730 0 : void SgListExp::accept (ROSE_VisitorPattern & visitor) {
239731 0 : ROSE_ASSERT(this != NULL);
239732 0 : visitor.visit(this);
239733 0 : }
239734 :
239735 : SgListExp*
239736 0 : SgListExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
239737 : {
239738 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
239739 : // This function is currently only supported for the AST used the represent Binary executables.
239740 : if (0 /* isSgAsmNode(this) != NULL */)
239741 : {
239742 : // Support for regex specification.
239743 : std::string prefixCode = "REGEX:";
239744 : addNewAttribute(prefixCode + s,a);
239745 : }
239746 : #endif
239747 :
239748 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
239749 0 : return this;
239750 : }
239751 :
239752 : // *** COMMON CODE SECTION ENDS HERE ***
239753 :
239754 :
239755 : // End of memberFunctionString
239756 : // Start of memberFunctionString
239757 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
239758 :
239759 :
239760 : #if 0
239761 : //! Error checking support
239762 : /*! Verifies the following:
239763 : - working getVariant() member function
239764 : - calls base class's error() member function
239765 : Every class has one of these functions.
239766 : */
239767 : bool
239768 : SgListExp::error()
239769 : {
239770 : // Put error checking here
239771 :
239772 : ROSE_ASSERT (this != NULL);
239773 : if (getVariant() != LIST_EXP)
239774 : {
239775 : printf ("Error in SgListExp::error(): SgListExp object has a %s variant \n",
239776 : Cxx_GrammarTerminalNames[getVariant()].name);
239777 : // printf ("Error in SgListExp::error() \n");
239778 : ROSE_ABORT();
239779 : }
239780 :
239781 : ROSE_ASSERT (getVariant() == LIST_EXP);
239782 : return SgExprListExp::error();
239783 : }
239784 : #endif
239785 :
239786 :
239787 :
239788 : // End of memberFunctionString
239789 :
239790 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
239791 :
239792 0 : SgListExp* isSgListExp ( SgNode* inputDerivedClassPointer )
239793 : {
239794 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
239795 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
239796 : // So to fix this we return NULL directly when the input is NULL and avoid the
239797 : // dynamic_cast in this case. This is likely a performance improvement as well.
239798 : // return dynamic_cast<SgListExp*>(inputDerivedClassPointer);
239799 : // Milind Chabbi (8/28/2013): isSgListExp uses table-driven castability instead of c++ default dynamic_cast
239800 : // this improves the running time performance by 10-20%.
239801 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgListExp*>(inputDerivedClassPointer);
239802 0 : return IS_SgListExp_FAST_MACRO(inputDerivedClassPointer);
239803 : }
239804 :
239805 : // DQ (11/8/2003): Added version of functions taking const pointer
239806 0 : const SgListExp* isSgListExp ( const SgNode* inputDerivedClassPointer )
239807 : {
239808 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
239809 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
239810 : // So to fix this we return NULL directly when the input is NULL and avoid the
239811 : // dynamic_cast in this case. This is likely a performance improvement as well.
239812 : // return dynamic_cast<const SgListExp*>(inputDerivedClassPointer);
239813 : // Milind Chabbi (8/28/2013): isSgListExp uses table-driven castability instead of c++ default dynamic_cast
239814 : // this improves the running time performance by 10-20%.
239815 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgListExp*>(inputDerivedClassPointer);
239816 0 : return IS_SgListExp_FAST_MACRO(inputDerivedClassPointer);
239817 : }
239818 :
239819 :
239820 :
239821 : /* #line 239822 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239822 :
239823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
239824 :
239825 : /**
239826 : \brief Generated destructor
239827 :
239828 : This destructor is automatically generated (by ROSETTA). This destructor
239829 : only frees memory of data members associated with the parts of the current IR node which
239830 : are NOT traversed. Those data members that are part of a traversal can be freed using
239831 : a traversal (calling this destructor on all children in a post-order traversal). Such
239832 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
239833 :
239834 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
239835 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
239836 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
239837 :
239838 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
239839 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
239840 : pointers are not yet implemented to call delete on eash pointer in the container.
239841 : (This could be done by derivation from the STL containers to define containers that
239842 : automatically deleted their members.)
239843 :
239844 : */
239845 0 : SgListExp::~SgListExp () {
239846 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
239847 :
239848 :
239849 :
239850 : }
239851 :
239852 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
239853 0 : }
239854 :
239855 :
239856 : /* #line 239857 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239857 :
239858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
239859 :
239860 : // Generated constructor
239861 0 : SgListExp::SgListExp ( Sg_File_Info* startOfConstruct )
239862 0 : : SgExprListExp(startOfConstruct)
239863 : {
239864 : #ifdef DEBUG
239865 : // printf ("In SgListExp::SgListExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
239866 : #endif
239867 : #if 0
239868 : // debugging information!
239869 : printf ("In SgListExp::SgListExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
239870 : #endif
239871 :
239872 :
239873 :
239874 : #if 0
239875 : // DQ (7/30/2014): Call a virtual function.
239876 : std::string s = this->class_name();
239877 : #endif
239878 :
239879 : // Test the variant virtual function
239880 : // assert(LIST_EXP == variant());
239881 0 : assert(LIST_EXP == this->variant());
239882 0 : ROSE_ASSERT(LIST_EXP == (int)(this->variantT()));
239883 0 : post_construction_initialization();
239884 :
239885 : // Test the isSgListExp() function since it has been problematic
239886 0 : assert(isSgListExp(this) != NULL);
239887 0 : }
239888 :
239889 : // Generated constructor (all data members)
239890 :
239891 : /* #line 239892 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239892 :
239893 :
239894 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
239895 :
239896 :
239897 : // ********************************************************
239898 : // member functions common across all array grammar objects
239899 : // ********************************************************
239900 :
239901 :
239902 :
239903 : /* #line 239904 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239904 :
239905 :
239906 :
239907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
239908 :
239909 : // ********************************************************
239910 : // member functions specific to each node in the grammar
239911 : // ********************************************************
239912 :
239913 :
239914 : /* #line 239915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
239915 :
239916 : // Start of memberFunctionString
239917 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239918 :
239919 : void
239920 0 : SgTupleExp::post_construction_initialization()
239921 : {
239922 0 : }
239923 :
239924 :
239925 :
239926 : // End of memberFunctionString
239927 : // Start of memberFunctionString
239928 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239929 :
239930 : SgType*
239931 :
239932 0 : SgTupleExp::get_type() const
239933 : {
239934 0 : ROSE_ASSERT(this != NULL);
239935 :
239936 : #if 0
239937 : printf ("In SgTupleExp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
239938 : #endif
239939 :
239940 : // DQ (10/31/2016): Debugging...
239941 : // return SgTypeDefault::createType();
239942 0 : SgType* returnType = SgTypeDefault::createType();
239943 :
239944 : #if 0
239945 : printf ("Leaving SgTupleExp::get_type() (default_get_type) returnType = %p \n",returnType);
239946 : #endif
239947 :
239948 0 : return returnType;
239949 : }
239950 :
239951 :
239952 :
239953 : // End of memberFunctionString
239954 : // Start of memberFunctionString
239955 : /* #line 7046 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
239956 :
239957 :
239958 :
239959 : // End of memberFunctionString
239960 : // Start of memberFunctionString
239961 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
239962 :
239963 : // *** COMMON CODE SECTION BEGINS HERE ***
239964 :
239965 : #if 0
239966 : int
239967 : SgTupleExp::getVariant() const
239968 : {
239969 : // This function is used in ROSE while "variant()" is used in SAGE
239970 : assert(this != NULL);
239971 : return variant();
239972 : }
239973 : #endif
239974 :
239975 : // This function is used in ROSE in treeTraversal code
239976 : // eventually replaces getVariant() and variant()
239977 : // though after variant() has been removed for a while we will
239978 : // want to change the name of variantT() back to variant()
239979 : // (since the "T" was ment to stand for temporary).
239980 : // When this happens the variantT() will be depricated.
239981 : VariantT
239982 0 : SgTupleExp::variantT() const
239983 : {
239984 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
239985 0 : ROSE_ASSERT(this != NULL);
239986 0 : return V_SgTupleExp;
239987 : }
239988 :
239989 : #if 0
239990 : int
239991 : SgTupleExp::variant() const
239992 : {
239993 : // This function is used in SAGE
239994 : ROSE_ASSERT(this != NULL);
239995 : return TUPLE_EXP;
239996 : }
239997 : #endif
239998 :
239999 : ROSE_DLL_API const char*
240000 0 : SgTupleExp::sage_class_name() const
240001 : {
240002 0 : ROSE_ASSERT(this != NULL);
240003 0 : return "SgTupleExp";
240004 : }
240005 :
240006 : std::string
240007 0 : SgTupleExp::class_name() const
240008 : {
240009 0 : ROSE_ASSERT(this != NULL);
240010 0 : return "SgTupleExp";
240011 : }
240012 :
240013 : // DQ (11/26/2005): Support for visitor pattern mechanims
240014 : // (inferior to ROSE traversal mechanism, experimental).
240015 : void
240016 0 : SgTupleExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
240017 : {
240018 0 : ROSE_ASSERT(this != NULL);
240019 0 : visitor.visit(this);
240020 0 : }
240021 :
240022 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
240023 0 : void SgTupleExp::accept (ROSE_VisitorPattern & visitor) {
240024 0 : ROSE_ASSERT(this != NULL);
240025 0 : visitor.visit(this);
240026 0 : }
240027 :
240028 : SgTupleExp*
240029 0 : SgTupleExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
240030 : {
240031 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
240032 : // This function is currently only supported for the AST used the represent Binary executables.
240033 : if (0 /* isSgAsmNode(this) != NULL */)
240034 : {
240035 : // Support for regex specification.
240036 : std::string prefixCode = "REGEX:";
240037 : addNewAttribute(prefixCode + s,a);
240038 : }
240039 : #endif
240040 :
240041 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
240042 0 : return this;
240043 : }
240044 :
240045 : // *** COMMON CODE SECTION ENDS HERE ***
240046 :
240047 :
240048 : // End of memberFunctionString
240049 : // Start of memberFunctionString
240050 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
240051 :
240052 :
240053 : #if 0
240054 : //! Error checking support
240055 : /*! Verifies the following:
240056 : - working getVariant() member function
240057 : - calls base class's error() member function
240058 : Every class has one of these functions.
240059 : */
240060 : bool
240061 : SgTupleExp::error()
240062 : {
240063 : // Put error checking here
240064 :
240065 : ROSE_ASSERT (this != NULL);
240066 : if (getVariant() != TUPLE_EXP)
240067 : {
240068 : printf ("Error in SgTupleExp::error(): SgTupleExp object has a %s variant \n",
240069 : Cxx_GrammarTerminalNames[getVariant()].name);
240070 : // printf ("Error in SgTupleExp::error() \n");
240071 : ROSE_ABORT();
240072 : }
240073 :
240074 : ROSE_ASSERT (getVariant() == TUPLE_EXP);
240075 : return SgExprListExp::error();
240076 : }
240077 : #endif
240078 :
240079 :
240080 :
240081 : // End of memberFunctionString
240082 :
240083 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
240084 :
240085 0 : SgTupleExp* isSgTupleExp ( SgNode* inputDerivedClassPointer )
240086 : {
240087 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
240088 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
240089 : // So to fix this we return NULL directly when the input is NULL and avoid the
240090 : // dynamic_cast in this case. This is likely a performance improvement as well.
240091 : // return dynamic_cast<SgTupleExp*>(inputDerivedClassPointer);
240092 : // Milind Chabbi (8/28/2013): isSgTupleExp uses table-driven castability instead of c++ default dynamic_cast
240093 : // this improves the running time performance by 10-20%.
240094 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTupleExp*>(inputDerivedClassPointer);
240095 0 : return IS_SgTupleExp_FAST_MACRO(inputDerivedClassPointer);
240096 : }
240097 :
240098 : // DQ (11/8/2003): Added version of functions taking const pointer
240099 0 : const SgTupleExp* isSgTupleExp ( const SgNode* inputDerivedClassPointer )
240100 : {
240101 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
240102 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
240103 : // So to fix this we return NULL directly when the input is NULL and avoid the
240104 : // dynamic_cast in this case. This is likely a performance improvement as well.
240105 : // return dynamic_cast<const SgTupleExp*>(inputDerivedClassPointer);
240106 : // Milind Chabbi (8/28/2013): isSgTupleExp uses table-driven castability instead of c++ default dynamic_cast
240107 : // this improves the running time performance by 10-20%.
240108 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTupleExp*>(inputDerivedClassPointer);
240109 0 : return IS_SgTupleExp_FAST_MACRO(inputDerivedClassPointer);
240110 : }
240111 :
240112 :
240113 :
240114 : /* #line 240115 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240115 :
240116 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
240117 :
240118 : /**
240119 : \brief Generated destructor
240120 :
240121 : This destructor is automatically generated (by ROSETTA). This destructor
240122 : only frees memory of data members associated with the parts of the current IR node which
240123 : are NOT traversed. Those data members that are part of a traversal can be freed using
240124 : a traversal (calling this destructor on all children in a post-order traversal). Such
240125 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
240126 :
240127 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
240128 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
240129 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
240130 :
240131 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
240132 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
240133 : pointers are not yet implemented to call delete on eash pointer in the container.
240134 : (This could be done by derivation from the STL containers to define containers that
240135 : automatically deleted their members.)
240136 :
240137 : */
240138 0 : SgTupleExp::~SgTupleExp () {
240139 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
240140 :
240141 :
240142 :
240143 : }
240144 :
240145 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
240146 0 : }
240147 :
240148 :
240149 : /* #line 240150 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240150 :
240151 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
240152 :
240153 : // Generated constructor
240154 0 : SgTupleExp::SgTupleExp ( Sg_File_Info* startOfConstruct )
240155 0 : : SgExprListExp(startOfConstruct)
240156 : {
240157 : #ifdef DEBUG
240158 : // printf ("In SgTupleExp::SgTupleExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
240159 : #endif
240160 : #if 0
240161 : // debugging information!
240162 : printf ("In SgTupleExp::SgTupleExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
240163 : #endif
240164 :
240165 :
240166 :
240167 : #if 0
240168 : // DQ (7/30/2014): Call a virtual function.
240169 : std::string s = this->class_name();
240170 : #endif
240171 :
240172 : // Test the variant virtual function
240173 : // assert(TUPLE_EXP == variant());
240174 0 : assert(TUPLE_EXP == this->variant());
240175 0 : ROSE_ASSERT(TUPLE_EXP == (int)(this->variantT()));
240176 0 : post_construction_initialization();
240177 :
240178 : // Test the isSgTupleExp() function since it has been problematic
240179 0 : assert(isSgTupleExp(this) != NULL);
240180 0 : }
240181 :
240182 : // Generated constructor (all data members)
240183 :
240184 : /* #line 240185 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240185 :
240186 :
240187 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
240188 :
240189 :
240190 : // ********************************************************
240191 : // member functions common across all array grammar objects
240192 : // ********************************************************
240193 :
240194 :
240195 :
240196 : /* #line 240197 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240197 :
240198 :
240199 :
240200 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
240201 :
240202 : // ********************************************************
240203 : // member functions specific to each node in the grammar
240204 : // ********************************************************
240205 :
240206 :
240207 : /* #line 240208 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240208 :
240209 : // Start of memberFunctionString
240210 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
240211 :
240212 : void
240213 0 : SgMatrixExp::post_construction_initialization()
240214 : {
240215 0 : }
240216 :
240217 :
240218 :
240219 : // End of memberFunctionString
240220 : // Start of memberFunctionString
240221 : /* #line 7053 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
240222 :
240223 :
240224 : SgType*
240225 0 : SgMatrixExp::get_type() const
240226 : {
240227 : #if 0
240228 : printf ("In SgMatrixExp::get_type() \n");
240229 : #endif
240230 0 : return SageBuilder::buildMatrixType();
240231 : }
240232 :
240233 :
240234 :
240235 : // End of memberFunctionString
240236 : // Start of memberFunctionString
240237 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
240238 :
240239 : // *** COMMON CODE SECTION BEGINS HERE ***
240240 :
240241 : #if 0
240242 : int
240243 : SgMatrixExp::getVariant() const
240244 : {
240245 : // This function is used in ROSE while "variant()" is used in SAGE
240246 : assert(this != NULL);
240247 : return variant();
240248 : }
240249 : #endif
240250 :
240251 : // This function is used in ROSE in treeTraversal code
240252 : // eventually replaces getVariant() and variant()
240253 : // though after variant() has been removed for a while we will
240254 : // want to change the name of variantT() back to variant()
240255 : // (since the "T" was ment to stand for temporary).
240256 : // When this happens the variantT() will be depricated.
240257 : VariantT
240258 0 : SgMatrixExp::variantT() const
240259 : {
240260 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
240261 0 : ROSE_ASSERT(this != NULL);
240262 0 : return V_SgMatrixExp;
240263 : }
240264 :
240265 : #if 0
240266 : int
240267 : SgMatrixExp::variant() const
240268 : {
240269 : // This function is used in SAGE
240270 : ROSE_ASSERT(this != NULL);
240271 : return MATRIX_EXP;
240272 : }
240273 : #endif
240274 :
240275 : ROSE_DLL_API const char*
240276 0 : SgMatrixExp::sage_class_name() const
240277 : {
240278 0 : ROSE_ASSERT(this != NULL);
240279 0 : return "SgMatrixExp";
240280 : }
240281 :
240282 : std::string
240283 0 : SgMatrixExp::class_name() const
240284 : {
240285 0 : ROSE_ASSERT(this != NULL);
240286 0 : return "SgMatrixExp";
240287 : }
240288 :
240289 : // DQ (11/26/2005): Support for visitor pattern mechanims
240290 : // (inferior to ROSE traversal mechanism, experimental).
240291 : void
240292 0 : SgMatrixExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
240293 : {
240294 0 : ROSE_ASSERT(this != NULL);
240295 0 : visitor.visit(this);
240296 0 : }
240297 :
240298 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
240299 0 : void SgMatrixExp::accept (ROSE_VisitorPattern & visitor) {
240300 0 : ROSE_ASSERT(this != NULL);
240301 0 : visitor.visit(this);
240302 0 : }
240303 :
240304 : SgMatrixExp*
240305 0 : SgMatrixExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
240306 : {
240307 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
240308 : // This function is currently only supported for the AST used the represent Binary executables.
240309 : if (0 /* isSgAsmNode(this) != NULL */)
240310 : {
240311 : // Support for regex specification.
240312 : std::string prefixCode = "REGEX:";
240313 : addNewAttribute(prefixCode + s,a);
240314 : }
240315 : #endif
240316 :
240317 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
240318 0 : return this;
240319 : }
240320 :
240321 : // *** COMMON CODE SECTION ENDS HERE ***
240322 :
240323 :
240324 : // End of memberFunctionString
240325 : // Start of memberFunctionString
240326 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
240327 :
240328 :
240329 : #if 0
240330 : //! Error checking support
240331 : /*! Verifies the following:
240332 : - working getVariant() member function
240333 : - calls base class's error() member function
240334 : Every class has one of these functions.
240335 : */
240336 : bool
240337 : SgMatrixExp::error()
240338 : {
240339 : // Put error checking here
240340 :
240341 : ROSE_ASSERT (this != NULL);
240342 : if (getVariant() != MATRIX_EXP)
240343 : {
240344 : printf ("Error in SgMatrixExp::error(): SgMatrixExp object has a %s variant \n",
240345 : Cxx_GrammarTerminalNames[getVariant()].name);
240346 : // printf ("Error in SgMatrixExp::error() \n");
240347 : ROSE_ABORT();
240348 : }
240349 :
240350 : ROSE_ASSERT (getVariant() == MATRIX_EXP);
240351 : return SgExprListExp::error();
240352 : }
240353 : #endif
240354 :
240355 :
240356 :
240357 : // End of memberFunctionString
240358 :
240359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
240360 :
240361 3189 : SgMatrixExp* isSgMatrixExp ( SgNode* inputDerivedClassPointer )
240362 : {
240363 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
240364 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
240365 : // So to fix this we return NULL directly when the input is NULL and avoid the
240366 : // dynamic_cast in this case. This is likely a performance improvement as well.
240367 : // return dynamic_cast<SgMatrixExp*>(inputDerivedClassPointer);
240368 : // Milind Chabbi (8/28/2013): isSgMatrixExp uses table-driven castability instead of c++ default dynamic_cast
240369 : // this improves the running time performance by 10-20%.
240370 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMatrixExp*>(inputDerivedClassPointer);
240371 3189 : return IS_SgMatrixExp_FAST_MACRO(inputDerivedClassPointer);
240372 : }
240373 :
240374 : // DQ (11/8/2003): Added version of functions taking const pointer
240375 0 : const SgMatrixExp* isSgMatrixExp ( const SgNode* inputDerivedClassPointer )
240376 : {
240377 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
240378 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
240379 : // So to fix this we return NULL directly when the input is NULL and avoid the
240380 : // dynamic_cast in this case. This is likely a performance improvement as well.
240381 : // return dynamic_cast<const SgMatrixExp*>(inputDerivedClassPointer);
240382 : // Milind Chabbi (8/28/2013): isSgMatrixExp uses table-driven castability instead of c++ default dynamic_cast
240383 : // this improves the running time performance by 10-20%.
240384 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMatrixExp*>(inputDerivedClassPointer);
240385 0 : return IS_SgMatrixExp_FAST_MACRO(inputDerivedClassPointer);
240386 : }
240387 :
240388 :
240389 :
240390 : /* #line 240391 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240391 :
240392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
240393 :
240394 : /**
240395 : \brief Generated destructor
240396 :
240397 : This destructor is automatically generated (by ROSETTA). This destructor
240398 : only frees memory of data members associated with the parts of the current IR node which
240399 : are NOT traversed. Those data members that are part of a traversal can be freed using
240400 : a traversal (calling this destructor on all children in a post-order traversal). Such
240401 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
240402 :
240403 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
240404 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
240405 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
240406 :
240407 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
240408 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
240409 : pointers are not yet implemented to call delete on eash pointer in the container.
240410 : (This could be done by derivation from the STL containers to define containers that
240411 : automatically deleted their members.)
240412 :
240413 : */
240414 0 : SgMatrixExp::~SgMatrixExp () {
240415 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
240416 :
240417 :
240418 :
240419 : }
240420 :
240421 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
240422 0 : }
240423 :
240424 :
240425 : /* #line 240426 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240426 :
240427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
240428 :
240429 : // Generated constructor
240430 0 : SgMatrixExp::SgMatrixExp ( Sg_File_Info* startOfConstruct )
240431 0 : : SgExprListExp(startOfConstruct)
240432 : {
240433 : #ifdef DEBUG
240434 : // printf ("In SgMatrixExp::SgMatrixExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
240435 : #endif
240436 : #if 0
240437 : // debugging information!
240438 : printf ("In SgMatrixExp::SgMatrixExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
240439 : #endif
240440 :
240441 :
240442 :
240443 : #if 0
240444 : // DQ (7/30/2014): Call a virtual function.
240445 : std::string s = this->class_name();
240446 : #endif
240447 :
240448 : // Test the variant virtual function
240449 : // assert(MATRIX_EXP == variant());
240450 0 : assert(MATRIX_EXP == this->variant());
240451 0 : ROSE_ASSERT(MATRIX_EXP == (int)(this->variantT()));
240452 0 : post_construction_initialization();
240453 :
240454 : // Test the isSgMatrixExp() function since it has been problematic
240455 0 : assert(isSgMatrixExp(this) != NULL);
240456 0 : }
240457 :
240458 : // Generated constructor (all data members)
240459 :
240460 : /* #line 240461 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240461 :
240462 :
240463 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
240464 :
240465 :
240466 : // ********************************************************
240467 : // member functions common across all array grammar objects
240468 : // ********************************************************
240469 :
240470 :
240471 :
240472 : /* #line 240473 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240473 :
240474 :
240475 :
240476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
240477 :
240478 : // ********************************************************
240479 : // member functions specific to each node in the grammar
240480 : // ********************************************************
240481 :
240482 :
240483 : /* #line 240484 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240484 :
240485 : // Start of memberFunctionString
240486 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
240487 :
240488 : void
240489 76045 : SgVarRefExp::post_construction_initialization()
240490 : {
240491 76045 : }
240492 :
240493 :
240494 :
240495 : // End of memberFunctionString
240496 : // Start of memberFunctionString
240497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
240498 :
240499 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
240500 :
240501 : SgVariableSymbol*
240502 1052790 : SgVarRefExp::get_symbol () const
240503 : {
240504 1052790 : ROSE_ASSERT (this != NULL);
240505 1052790 : return p_symbol;
240506 : }
240507 :
240508 : void
240509 79 : SgVarRefExp::set_symbol ( SgVariableSymbol* symbol )
240510 : {
240511 79 : ROSE_ASSERT (this != NULL);
240512 :
240513 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
240514 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
240515 : {
240516 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
240517 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
240518 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
240519 : ROSE_ASSERT(false);
240520 : #endif
240521 : }
240522 : #endif
240523 79 : p_symbol = symbol;
240524 79 : }
240525 :
240526 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
240527 :
240528 :
240529 : // End of memberFunctionString
240530 : // Start of memberFunctionString
240531 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
240532 :
240533 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
240534 :
240535 : SgExpression*
240536 81453 : SgVarRefExp::get_originalExpressionTree () const
240537 : {
240538 81453 : ROSE_ASSERT (this != NULL);
240539 :
240540 : #if 0
240541 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
240542 : // used to trigger marking transformations for the token-based unparsing.
240543 : printf ("SgVarRefExp::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
240544 : #endif
240545 :
240546 81453 : return p_originalExpressionTree;
240547 : }
240548 :
240549 : void
240550 0 : SgVarRefExp::set_originalExpressionTree ( SgExpression* originalExpressionTree )
240551 : {
240552 0 : ROSE_ASSERT (this != NULL);
240553 :
240554 : #if 0
240555 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
240556 : // used to trigger marking transformations for the token-based unparsing.
240557 : printf ("SgVarRefExp::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
240558 : #endif
240559 :
240560 0 : set_isModified(true);
240561 :
240562 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
240563 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
240564 : {
240565 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
240566 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
240567 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
240568 : ROSE_ASSERT(false);
240569 : #endif
240570 : }
240571 : #endif
240572 0 : p_originalExpressionTree = originalExpressionTree;
240573 0 : }
240574 :
240575 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
240576 :
240577 :
240578 : // End of memberFunctionString
240579 : // Start of memberFunctionString
240580 :
240581 :
240582 : // End of memberFunctionString
240583 : // Start of memberFunctionString
240584 : /* #line 3305 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
240585 :
240586 : #if 0
240587 : // DQ (11/7/2007): I think this is not used any more.
240588 : void
240589 : SgVarRefExp::fixupCopy(SgNode* copy, SgCopyHelp & help) const
240590 : {
240591 : // This is the empty default inplementation, not a problem if it is called!
240592 : printf ("Inside of SgVarRefExp::fixupCopy() \n");
240593 :
240594 : SgVarRefExp* variableRefExpression_copy = isSgVarRefExp(copy);
240595 :
240596 : // We could first check if the declarations are the same, but that would not imply that they had to be reset!
240597 :
240598 : ROSE_ASSERT(variableRefExpression_copy->get_symbol() != NULL);
240599 : SgNode* declaration_key = variableRefExpression_copy->get_symbol()->get_declaration();
240600 : ROSE_ASSERT(declaration_key != NULL);
240601 :
240602 : // If this is a reference to a declaration that was copied, then we have a new symbol that should be referencec by the reference.
240603 : // The declaration is saved into a map held as state in the SgCopyHelp object.
240604 : SgCopyHelp::copiedNodeMapTypeIterator i = help.get_copiedNodeMap().find(declaration_key);
240605 : if (i != help.get_copiedNodeMap().end())
240606 : {
240607 : // Found the key (a declaration SgDeclarationStatement or a SgInitializedName) so get the symbol and reset the symbol in the referencec to the value's associated symbol!
240608 : SgNode* declaration_value = i->second;
240609 : SgInitializedName* initializedName_copy = isSgInitializedName(declaration_value);
240610 : ROSE_ASSERT(initializedName_copy != NULL);
240611 : SgSymbol* symbol_copy = initializedName_copy->get_symbol_from_symbol_table();
240612 :
240613 : // DQ (10/8/2007): It might be too early to expect this to work!
240614 : // ROSE_ASSERT(symbol_copy != NULL);
240615 : printf ("Inside of SgVarRefExp::fixupCopy(): symbol_copy = %p \n",symbol_copy);
240616 : if (symbol_copy != NULL)
240617 : {
240618 : SgVariableSymbol* variableSymbol_copy = isSgVariableSymbol(symbol_copy);
240619 : ROSE_ASSERT(variableSymbol_copy != NULL);
240620 : variableRefExpression_copy->set_symbol(variableSymbol_copy);
240621 : }
240622 : }
240623 : }
240624 : #endif
240625 :
240626 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
240627 : // so that we could avoid them setting the isModified flag which is a problem in the
240628 : // name qualification support for C++ (interfering with the token-based unparsing).
240629 : int
240630 0 : SgVarRefExp::get_name_qualification_length () const
240631 : {
240632 0 : ROSE_ASSERT (this != NULL);
240633 0 : return p_name_qualification_length;
240634 : }
240635 :
240636 : void
240637 20547 : SgVarRefExp::set_name_qualification_length ( int name_qualification_length )
240638 : {
240639 20547 : ROSE_ASSERT (this != NULL);
240640 : // This can't be called by the name qualification API (see test2015_26.C).
240641 : // set_isModified(true);
240642 :
240643 20547 : p_name_qualification_length = name_qualification_length;
240644 20547 : }
240645 :
240646 : bool
240647 0 : SgVarRefExp::get_type_elaboration_required () const
240648 : {
240649 0 : ROSE_ASSERT (this != NULL);
240650 0 : return p_type_elaboration_required;
240651 : }
240652 :
240653 : void
240654 20547 : SgVarRefExp::set_type_elaboration_required ( bool type_elaboration_required )
240655 : {
240656 20547 : ROSE_ASSERT (this != NULL);
240657 : // This can't be called by the name qualification API (see test2015_26.C).
240658 : // set_isModified(true);
240659 :
240660 20547 : p_type_elaboration_required = type_elaboration_required;
240661 20547 : }
240662 :
240663 : bool
240664 0 : SgVarRefExp::get_global_qualification_required () const
240665 : {
240666 0 : ROSE_ASSERT (this != NULL);
240667 0 : return p_global_qualification_required;
240668 : }
240669 :
240670 : void
240671 20547 : SgVarRefExp::set_global_qualification_required ( bool global_qualification_required )
240672 : {
240673 20547 : ROSE_ASSERT (this != NULL);
240674 :
240675 : // This can't be called by the name qualification API (see test2015_26.C).
240676 : // set_isModified(true);
240677 :
240678 20547 : p_global_qualification_required = global_qualification_required;
240679 20547 : }
240680 :
240681 :
240682 :
240683 : // End of memberFunctionString
240684 : // Start of memberFunctionString
240685 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
240686 :
240687 :
240688 : SgType*
240689 119036 : SgVarRefExp::get_type() const
240690 : {
240691 119036 : ROSE_ASSERT(this != NULL);
240692 :
240693 : #if 0
240694 : printf ("In SgVarRefExp::get_type() \n");
240695 : #endif
240696 :
240697 119036 : SgSymbol* symbol = this->get_symbol();
240698 119036 : if (symbol == NULL)
240699 : {
240700 0 : printf ("Error: In SgVarRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
240701 : }
240702 119036 : ROSE_ASSERT(symbol != NULL);
240703 :
240704 : // DQ (9/27/2006): Added assertion
240705 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
240706 :
240707 : // printf ("In SgVarRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
240708 119036 : SgType* type = symbol->get_type();
240709 119036 : if (type == NULL)
240710 : {
240711 0 : printf ("Error: In SgVarRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
240712 : }
240713 119036 : ROSE_ASSERT(type != NULL);
240714 :
240715 : // return get_symbol()->get_type();
240716 119036 : return type;
240717 : }
240718 :
240719 :
240720 :
240721 : // End of memberFunctionString
240722 : // Start of memberFunctionString
240723 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
240724 :
240725 : // *** COMMON CODE SECTION BEGINS HERE ***
240726 :
240727 : #if 0
240728 : int
240729 : SgVarRefExp::getVariant() const
240730 : {
240731 : // This function is used in ROSE while "variant()" is used in SAGE
240732 : assert(this != NULL);
240733 : return variant();
240734 : }
240735 : #endif
240736 :
240737 : // This function is used in ROSE in treeTraversal code
240738 : // eventually replaces getVariant() and variant()
240739 : // though after variant() has been removed for a while we will
240740 : // want to change the name of variantT() back to variant()
240741 : // (since the "T" was ment to stand for temporary).
240742 : // When this happens the variantT() will be depricated.
240743 : VariantT
240744 20666900 : SgVarRefExp::variantT() const
240745 : {
240746 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
240747 20666900 : ROSE_ASSERT(this != NULL);
240748 20666900 : return V_SgVarRefExp;
240749 : }
240750 :
240751 : #if 0
240752 : int
240753 : SgVarRefExp::variant() const
240754 : {
240755 : // This function is used in SAGE
240756 : ROSE_ASSERT(this != NULL);
240757 : return VAR_REF;
240758 : }
240759 : #endif
240760 :
240761 : ROSE_DLL_API const char*
240762 2813 : SgVarRefExp::sage_class_name() const
240763 : {
240764 2813 : ROSE_ASSERT(this != NULL);
240765 2813 : return "SgVarRefExp";
240766 : }
240767 :
240768 : std::string
240769 62950 : SgVarRefExp::class_name() const
240770 : {
240771 62950 : ROSE_ASSERT(this != NULL);
240772 62950 : return "SgVarRefExp";
240773 : }
240774 :
240775 : // DQ (11/26/2005): Support for visitor pattern mechanims
240776 : // (inferior to ROSE traversal mechanism, experimental).
240777 : void
240778 924234 : SgVarRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
240779 : {
240780 924234 : ROSE_ASSERT(this != NULL);
240781 924234 : visitor.visit(this);
240782 924234 : }
240783 :
240784 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
240785 0 : void SgVarRefExp::accept (ROSE_VisitorPattern & visitor) {
240786 0 : ROSE_ASSERT(this != NULL);
240787 0 : visitor.visit(this);
240788 0 : }
240789 :
240790 : SgVarRefExp*
240791 0 : SgVarRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
240792 : {
240793 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
240794 : // This function is currently only supported for the AST used the represent Binary executables.
240795 : if (0 /* isSgAsmNode(this) != NULL */)
240796 : {
240797 : // Support for regex specification.
240798 : std::string prefixCode = "REGEX:";
240799 : addNewAttribute(prefixCode + s,a);
240800 : }
240801 : #endif
240802 :
240803 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
240804 0 : return this;
240805 : }
240806 :
240807 : // *** COMMON CODE SECTION ENDS HERE ***
240808 :
240809 :
240810 : // End of memberFunctionString
240811 : // Start of memberFunctionString
240812 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
240813 :
240814 :
240815 : #if 0
240816 : //! Error checking support
240817 : /*! Verifies the following:
240818 : - working getVariant() member function
240819 : - calls base class's error() member function
240820 : Every class has one of these functions.
240821 : */
240822 : bool
240823 : SgVarRefExp::error()
240824 : {
240825 : // Put error checking here
240826 :
240827 : ROSE_ASSERT (this != NULL);
240828 : if (getVariant() != VAR_REF)
240829 : {
240830 : printf ("Error in SgVarRefExp::error(): SgVarRefExp object has a %s variant \n",
240831 : Cxx_GrammarTerminalNames[getVariant()].name);
240832 : // printf ("Error in SgVarRefExp::error() \n");
240833 : ROSE_ABORT();
240834 : }
240835 :
240836 : ROSE_ASSERT (getVariant() == VAR_REF);
240837 : return SgExpression::error();
240838 : }
240839 : #endif
240840 :
240841 :
240842 :
240843 : // End of memberFunctionString
240844 :
240845 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
240846 :
240847 4101890 : SgVarRefExp* isSgVarRefExp ( SgNode* inputDerivedClassPointer )
240848 : {
240849 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
240850 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
240851 : // So to fix this we return NULL directly when the input is NULL and avoid the
240852 : // dynamic_cast in this case. This is likely a performance improvement as well.
240853 : // return dynamic_cast<SgVarRefExp*>(inputDerivedClassPointer);
240854 : // Milind Chabbi (8/28/2013): isSgVarRefExp uses table-driven castability instead of c++ default dynamic_cast
240855 : // this improves the running time performance by 10-20%.
240856 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVarRefExp*>(inputDerivedClassPointer);
240857 4101890 : return IS_SgVarRefExp_FAST_MACRO(inputDerivedClassPointer);
240858 : }
240859 :
240860 : // DQ (11/8/2003): Added version of functions taking const pointer
240861 19412 : const SgVarRefExp* isSgVarRefExp ( const SgNode* inputDerivedClassPointer )
240862 : {
240863 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
240864 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
240865 : // So to fix this we return NULL directly when the input is NULL and avoid the
240866 : // dynamic_cast in this case. This is likely a performance improvement as well.
240867 : // return dynamic_cast<const SgVarRefExp*>(inputDerivedClassPointer);
240868 : // Milind Chabbi (8/28/2013): isSgVarRefExp uses table-driven castability instead of c++ default dynamic_cast
240869 : // this improves the running time performance by 10-20%.
240870 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVarRefExp*>(inputDerivedClassPointer);
240871 19412 : return IS_SgVarRefExp_FAST_MACRO(inputDerivedClassPointer);
240872 : }
240873 :
240874 :
240875 :
240876 : /* #line 240877 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240877 :
240878 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
240879 :
240880 : /**
240881 : \brief Generated destructor
240882 :
240883 : This destructor is automatically generated (by ROSETTA). This destructor
240884 : only frees memory of data members associated with the parts of the current IR node which
240885 : are NOT traversed. Those data members that are part of a traversal can be freed using
240886 : a traversal (calling this destructor on all children in a post-order traversal). Such
240887 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
240888 :
240889 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
240890 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
240891 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
240892 :
240893 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
240894 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
240895 : pointers are not yet implemented to call delete on eash pointer in the container.
240896 : (This could be done by derivation from the STL containers to define containers that
240897 : automatically deleted their members.)
240898 :
240899 : */
240900 33610 : SgVarRefExp::~SgVarRefExp () {
240901 16805 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
240902 :
240903 :
240904 : // case: not a listType for symbol
240905 16805 : p_symbol = NULL; // non list case
240906 : // case: not a listType for originalExpressionTree
240907 16805 : p_originalExpressionTree = NULL; // non list case
240908 : // case: not a listType for name_qualification_length
240909 16805 : p_name_qualification_length = 0; // non list case
240910 : // case: not a listType for type_elaboration_required
240911 16805 : p_type_elaboration_required = false; // non list case
240912 : // case: not a listType for global_qualification_required
240913 16805 : p_global_qualification_required = false; // non list case
240914 :
240915 : }
240916 :
240917 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
240918 33610 : }
240919 :
240920 :
240921 : /* #line 240922 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240922 :
240923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
240924 :
240925 : // Generated constructor
240926 2415 : SgVarRefExp::SgVarRefExp ( Sg_File_Info* startOfConstruct, SgVariableSymbol* symbol )
240927 2415 : : SgExpression(startOfConstruct)
240928 : {
240929 : #ifdef DEBUG
240930 : // printf ("In SgVarRefExp::SgVarRefExp (Sg_File_Info* startOfConstruct, SgVariableSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
240931 : #endif
240932 : #if 0
240933 : // debugging information!
240934 : printf ("In SgVarRefExp::SgVarRefExp (Sg_File_Info* startOfConstruct, SgVariableSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
240935 : #endif
240936 :
240937 2415 : p_symbol = symbol;
240938 2415 : p_originalExpressionTree = NULL;
240939 2415 : p_name_qualification_length = 0;
240940 2415 : p_type_elaboration_required = false;
240941 2415 : p_global_qualification_required = false;
240942 :
240943 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
240944 :
240945 : #if 0
240946 : // DQ (7/30/2014): Call a virtual function.
240947 : std::string s = this->class_name();
240948 : #endif
240949 :
240950 : // Test the variant virtual function
240951 : // assert(VAR_REF == variant());
240952 2415 : assert(VAR_REF == this->variant());
240953 2415 : ROSE_ASSERT(VAR_REF == (int)(this->variantT()));
240954 2415 : post_construction_initialization();
240955 :
240956 : // Test the isSgVarRefExp() function since it has been problematic
240957 2415 : assert(isSgVarRefExp(this) != NULL);
240958 2415 : }
240959 :
240960 : // Generated constructor (all data members)
240961 :
240962 : /* #line 240963 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240963 :
240964 :
240965 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
240966 :
240967 :
240968 : // ********************************************************
240969 : // member functions common across all array grammar objects
240970 : // ********************************************************
240971 :
240972 :
240973 :
240974 : /* #line 240975 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240975 :
240976 :
240977 :
240978 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
240979 :
240980 : // ********************************************************
240981 : // member functions specific to each node in the grammar
240982 : // ********************************************************
240983 :
240984 :
240985 : /* #line 240986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
240986 :
240987 : // Start of memberFunctionString
240988 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
240989 :
240990 : void
240991 0 : SgClassNameRefExp::post_construction_initialization()
240992 : {
240993 0 : }
240994 :
240995 :
240996 :
240997 : // End of memberFunctionString
240998 : // Start of memberFunctionString
240999 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
241000 :
241001 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
241002 :
241003 : SgClassSymbol*
241004 0 : SgClassNameRefExp::get_symbol () const
241005 : {
241006 0 : ROSE_ASSERT (this != NULL);
241007 :
241008 : #if 0
241009 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241010 : // used to trigger marking transformations for the token-based unparsing.
241011 : printf ("SgClassNameRefExp::get_symbol = %p = %s \n",this,this->class_name().c_str());
241012 : #endif
241013 :
241014 0 : return p_symbol;
241015 : }
241016 :
241017 : void
241018 0 : SgClassNameRefExp::set_symbol ( SgClassSymbol* symbol )
241019 : {
241020 0 : ROSE_ASSERT (this != NULL);
241021 :
241022 : #if 0
241023 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241024 : // used to trigger marking transformations for the token-based unparsing.
241025 : printf ("SgClassNameRefExp::set_symbol = %p = %s \n",this,this->class_name().c_str());
241026 : #endif
241027 :
241028 0 : set_isModified(true);
241029 :
241030 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
241031 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
241032 : {
241033 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
241034 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
241035 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
241036 : ROSE_ASSERT(false);
241037 : #endif
241038 : }
241039 : #endif
241040 0 : p_symbol = symbol;
241041 0 : }
241042 :
241043 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
241044 :
241045 :
241046 : // End of memberFunctionString
241047 : // Start of memberFunctionString
241048 : /* #line 3538 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
241049 :
241050 :
241051 :
241052 : // End of memberFunctionString
241053 : // Start of memberFunctionString
241054 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
241055 :
241056 : // *** COMMON CODE SECTION BEGINS HERE ***
241057 :
241058 : #if 0
241059 : int
241060 : SgClassNameRefExp::getVariant() const
241061 : {
241062 : // This function is used in ROSE while "variant()" is used in SAGE
241063 : assert(this != NULL);
241064 : return variant();
241065 : }
241066 : #endif
241067 :
241068 : // This function is used in ROSE in treeTraversal code
241069 : // eventually replaces getVariant() and variant()
241070 : // though after variant() has been removed for a while we will
241071 : // want to change the name of variantT() back to variant()
241072 : // (since the "T" was ment to stand for temporary).
241073 : // When this happens the variantT() will be depricated.
241074 : VariantT
241075 0 : SgClassNameRefExp::variantT() const
241076 : {
241077 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
241078 0 : ROSE_ASSERT(this != NULL);
241079 0 : return V_SgClassNameRefExp;
241080 : }
241081 :
241082 : #if 0
241083 : int
241084 : SgClassNameRefExp::variant() const
241085 : {
241086 : // This function is used in SAGE
241087 : ROSE_ASSERT(this != NULL);
241088 : return CLASSNAME_REF;
241089 : }
241090 : #endif
241091 :
241092 : ROSE_DLL_API const char*
241093 0 : SgClassNameRefExp::sage_class_name() const
241094 : {
241095 0 : ROSE_ASSERT(this != NULL);
241096 0 : return "SgClassNameRefExp";
241097 : }
241098 :
241099 : std::string
241100 0 : SgClassNameRefExp::class_name() const
241101 : {
241102 0 : ROSE_ASSERT(this != NULL);
241103 0 : return "SgClassNameRefExp";
241104 : }
241105 :
241106 : // DQ (11/26/2005): Support for visitor pattern mechanims
241107 : // (inferior to ROSE traversal mechanism, experimental).
241108 : void
241109 0 : SgClassNameRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
241110 : {
241111 0 : ROSE_ASSERT(this != NULL);
241112 0 : visitor.visit(this);
241113 0 : }
241114 :
241115 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
241116 0 : void SgClassNameRefExp::accept (ROSE_VisitorPattern & visitor) {
241117 0 : ROSE_ASSERT(this != NULL);
241118 0 : visitor.visit(this);
241119 0 : }
241120 :
241121 : SgClassNameRefExp*
241122 0 : SgClassNameRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
241123 : {
241124 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
241125 : // This function is currently only supported for the AST used the represent Binary executables.
241126 : if (0 /* isSgAsmNode(this) != NULL */)
241127 : {
241128 : // Support for regex specification.
241129 : std::string prefixCode = "REGEX:";
241130 : addNewAttribute(prefixCode + s,a);
241131 : }
241132 : #endif
241133 :
241134 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
241135 0 : return this;
241136 : }
241137 :
241138 : // *** COMMON CODE SECTION ENDS HERE ***
241139 :
241140 :
241141 : // End of memberFunctionString
241142 : // Start of memberFunctionString
241143 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
241144 :
241145 :
241146 : #if 0
241147 : //! Error checking support
241148 : /*! Verifies the following:
241149 : - working getVariant() member function
241150 : - calls base class's error() member function
241151 : Every class has one of these functions.
241152 : */
241153 : bool
241154 : SgClassNameRefExp::error()
241155 : {
241156 : // Put error checking here
241157 :
241158 : ROSE_ASSERT (this != NULL);
241159 : if (getVariant() != CLASSNAME_REF)
241160 : {
241161 : printf ("Error in SgClassNameRefExp::error(): SgClassNameRefExp object has a %s variant \n",
241162 : Cxx_GrammarTerminalNames[getVariant()].name);
241163 : // printf ("Error in SgClassNameRefExp::error() \n");
241164 : ROSE_ABORT();
241165 : }
241166 :
241167 : ROSE_ASSERT (getVariant() == CLASSNAME_REF);
241168 : return SgExpression::error();
241169 : }
241170 : #endif
241171 :
241172 :
241173 :
241174 : // End of memberFunctionString
241175 :
241176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
241177 :
241178 1342 : SgClassNameRefExp* isSgClassNameRefExp ( SgNode* inputDerivedClassPointer )
241179 : {
241180 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
241181 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
241182 : // So to fix this we return NULL directly when the input is NULL and avoid the
241183 : // dynamic_cast in this case. This is likely a performance improvement as well.
241184 : // return dynamic_cast<SgClassNameRefExp*>(inputDerivedClassPointer);
241185 : // Milind Chabbi (8/28/2013): isSgClassNameRefExp uses table-driven castability instead of c++ default dynamic_cast
241186 : // this improves the running time performance by 10-20%.
241187 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassNameRefExp*>(inputDerivedClassPointer);
241188 1342 : return IS_SgClassNameRefExp_FAST_MACRO(inputDerivedClassPointer);
241189 : }
241190 :
241191 : // DQ (11/8/2003): Added version of functions taking const pointer
241192 0 : const SgClassNameRefExp* isSgClassNameRefExp ( const SgNode* inputDerivedClassPointer )
241193 : {
241194 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
241195 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
241196 : // So to fix this we return NULL directly when the input is NULL and avoid the
241197 : // dynamic_cast in this case. This is likely a performance improvement as well.
241198 : // return dynamic_cast<const SgClassNameRefExp*>(inputDerivedClassPointer);
241199 : // Milind Chabbi (8/28/2013): isSgClassNameRefExp uses table-driven castability instead of c++ default dynamic_cast
241200 : // this improves the running time performance by 10-20%.
241201 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassNameRefExp*>(inputDerivedClassPointer);
241202 0 : return IS_SgClassNameRefExp_FAST_MACRO(inputDerivedClassPointer);
241203 : }
241204 :
241205 :
241206 :
241207 : /* #line 241208 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241208 :
241209 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
241210 :
241211 : /**
241212 : \brief Generated destructor
241213 :
241214 : This destructor is automatically generated (by ROSETTA). This destructor
241215 : only frees memory of data members associated with the parts of the current IR node which
241216 : are NOT traversed. Those data members that are part of a traversal can be freed using
241217 : a traversal (calling this destructor on all children in a post-order traversal). Such
241218 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
241219 :
241220 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
241221 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
241222 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
241223 :
241224 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
241225 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
241226 : pointers are not yet implemented to call delete on eash pointer in the container.
241227 : (This could be done by derivation from the STL containers to define containers that
241228 : automatically deleted their members.)
241229 :
241230 : */
241231 0 : SgClassNameRefExp::~SgClassNameRefExp () {
241232 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
241233 :
241234 :
241235 : // case: not a listType for symbol
241236 0 : p_symbol = NULL; // non list case
241237 :
241238 : }
241239 :
241240 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
241241 0 : }
241242 :
241243 :
241244 : /* #line 241245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241245 :
241246 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
241247 :
241248 : // Generated constructor
241249 0 : SgClassNameRefExp::SgClassNameRefExp ( Sg_File_Info* startOfConstruct, SgClassSymbol* symbol )
241250 0 : : SgExpression(startOfConstruct)
241251 : {
241252 : #ifdef DEBUG
241253 : // printf ("In SgClassNameRefExp::SgClassNameRefExp (Sg_File_Info* startOfConstruct, SgClassSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
241254 : #endif
241255 : #if 0
241256 : // debugging information!
241257 : printf ("In SgClassNameRefExp::SgClassNameRefExp (Sg_File_Info* startOfConstruct, SgClassSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
241258 : #endif
241259 :
241260 0 : p_symbol = symbol;
241261 :
241262 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
241263 :
241264 : #if 0
241265 : // DQ (7/30/2014): Call a virtual function.
241266 : std::string s = this->class_name();
241267 : #endif
241268 :
241269 : // Test the variant virtual function
241270 : // assert(CLASSNAME_REF == variant());
241271 0 : assert(CLASSNAME_REF == this->variant());
241272 0 : ROSE_ASSERT(CLASSNAME_REF == (int)(this->variantT()));
241273 0 : post_construction_initialization();
241274 :
241275 : // Test the isSgClassNameRefExp() function since it has been problematic
241276 0 : assert(isSgClassNameRefExp(this) != NULL);
241277 0 : }
241278 :
241279 : // Generated constructor (all data members)
241280 :
241281 : /* #line 241282 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241282 :
241283 :
241284 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
241285 :
241286 :
241287 : // ********************************************************
241288 : // member functions common across all array grammar objects
241289 : // ********************************************************
241290 :
241291 :
241292 :
241293 : /* #line 241294 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241294 :
241295 :
241296 :
241297 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
241298 :
241299 : // ********************************************************
241300 : // member functions specific to each node in the grammar
241301 : // ********************************************************
241302 :
241303 :
241304 : /* #line 241305 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241305 :
241306 : // Start of memberFunctionString
241307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
241308 :
241309 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
241310 :
241311 : SgFunctionSymbol*
241312 118864 : SgFunctionRefExp::get_symbol_i () const
241313 : {
241314 118864 : ROSE_ASSERT (this != NULL);
241315 :
241316 : #if 0
241317 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241318 : // used to trigger marking transformations for the token-based unparsing.
241319 : printf ("SgFunctionRefExp::get_symbol_i = %p = %s \n",this,this->class_name().c_str());
241320 : #endif
241321 :
241322 118864 : return p_symbol_i;
241323 : }
241324 :
241325 : void
241326 0 : SgFunctionRefExp::set_symbol_i ( SgFunctionSymbol* symbol_i )
241327 : {
241328 0 : ROSE_ASSERT (this != NULL);
241329 :
241330 : #if 0
241331 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241332 : // used to trigger marking transformations for the token-based unparsing.
241333 : printf ("SgFunctionRefExp::set_symbol_i = %p = %s \n",this,this->class_name().c_str());
241334 : #endif
241335 :
241336 0 : set_isModified(true);
241337 :
241338 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
241339 : if (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i)
241340 : {
241341 : printf ("Warning: symbol_i = %p overwriting valid pointer p_symbol_i = %p \n",symbol_i,p_symbol_i);
241342 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
241343 : printf ("Error fails assertion (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i) is false\n");
241344 : ROSE_ASSERT(false);
241345 : #endif
241346 : }
241347 : #endif
241348 0 : p_symbol_i = symbol_i;
241349 0 : }
241350 :
241351 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
241352 :
241353 :
241354 : // End of memberFunctionString
241355 : // Start of memberFunctionString
241356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
241357 :
241358 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
241359 :
241360 : SgExpression*
241361 8957 : SgFunctionRefExp::get_originalExpressionTree () const
241362 : {
241363 8957 : ROSE_ASSERT (this != NULL);
241364 :
241365 : #if 0
241366 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241367 : // used to trigger marking transformations for the token-based unparsing.
241368 : printf ("SgFunctionRefExp::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
241369 : #endif
241370 :
241371 8957 : return p_originalExpressionTree;
241372 : }
241373 :
241374 : void
241375 172 : SgFunctionRefExp::set_originalExpressionTree ( SgExpression* originalExpressionTree )
241376 : {
241377 172 : ROSE_ASSERT (this != NULL);
241378 :
241379 : #if 0
241380 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241381 : // used to trigger marking transformations for the token-based unparsing.
241382 : printf ("SgFunctionRefExp::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
241383 : #endif
241384 :
241385 172 : set_isModified(true);
241386 :
241387 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
241388 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
241389 : {
241390 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
241391 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
241392 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
241393 : ROSE_ASSERT(false);
241394 : #endif
241395 : }
241396 : #endif
241397 172 : p_originalExpressionTree = originalExpressionTree;
241398 172 : }
241399 :
241400 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
241401 :
241402 :
241403 : // End of memberFunctionString
241404 : // Start of memberFunctionString
241405 :
241406 :
241407 : // End of memberFunctionString
241408 : // Start of memberFunctionString
241409 : /* #line 3559 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
241410 :
241411 :
241412 : #if 0
241413 : // DQ (11/7/2007): I think this is not used any more.
241414 : void
241415 : SgFunctionRefExp::fixupCopy(SgNode* copy, SgCopyHelp & help) const
241416 : {
241417 : // This is the empty default inplementation, not a problem if it is called!
241418 : printf ("Inside of SgFunctionRefExp::fixupCopy() \n");
241419 :
241420 : SgFunctionRefExp* functionRefExpression_copy = isSgFunctionRefExp(copy);
241421 :
241422 : // We could first check if the declarations are the same, but that would not imply that they had to be reset!
241423 :
241424 : ROSE_ASSERT(functionRefExpression_copy->get_symbol() != NULL);
241425 : SgNode* declaration_key = functionRefExpression_copy->get_symbol()->get_declaration();
241426 : ROSE_ASSERT(declaration_key != NULL);
241427 :
241428 : // If this is a reference to a declaration that was copied, then we have a new symbol that should be referencec by the reference.
241429 : // The declaration is saved into a map held as state in the SgCopyHelp object.
241430 : SgCopyHelp::copiedNodeMapTypeIterator i = help.get_copiedNodeMap().find(declaration_key);
241431 : if (i != help.get_copiedNodeMap().end())
241432 : {
241433 : // Found the key (a declaration SgDeclarationStatement or a SgInitializedName) so get the symbol and reset the symbol in the referencec to the value's associated symbol!
241434 : SgNode* declaration_value = i->second;
241435 : SgFunctionDeclaration* functionDeclaration_copy = isSgFunctionDeclaration(declaration_value);
241436 : ROSE_ASSERT(functionDeclaration_copy != NULL);
241437 : SgSymbol* symbol_copy = functionDeclaration_copy->get_symbol_from_symbol_table();
241438 : // ROSE_ASSERT(symbol_copy != NULL);
241439 : if (symbol_copy != NULL)
241440 : {
241441 : SgFunctionSymbol* functionSymbol_copy = isSgFunctionSymbol(symbol_copy);
241442 : ROSE_ASSERT(functionSymbol_copy != NULL);
241443 : functionRefExpression_copy->set_symbol(functionSymbol_copy);
241444 : }
241445 : }
241446 : }
241447 : #endif
241448 :
241449 : void
241450 7982 : SgFunctionRefExp::post_construction_initialization()
241451 : {
241452 : // DQ (1/14/2006): set_type is removed
241453 : // if (! get_function_type())
241454 : // set_type();
241455 7982 : }
241456 :
241457 : SgFunctionSymbol*
241458 98727 : SgFunctionRefExp::get_symbol() const
241459 98727 : { return get_symbol_i(); }
241460 :
241461 : void
241462 0 : SgFunctionRefExp::set_symbol(SgFunctionSymbol * symbol)
241463 : {
241464 0 : set_symbol_i(symbol);
241465 :
241466 : // DQ (1/14/2006): set_type is removed
241467 : // set_type();
241468 0 : }
241469 :
241470 :
241471 : SgFunctionDeclaration*
241472 14006 : SgFunctionRefExp::getAssociatedFunctionDeclaration() const
241473 : {
241474 : // This is helpful in chasing down the associated declaration to this function reference.
241475 14006 : SgFunctionDeclaration* returnFunctionDeclaration = NULL;
241476 14006 : SgFunctionSymbol* functionSymbol = this->get_symbol();
241477 :
241478 : // DQ (2/8/2009): Can we assert this! What about pointers to functions?
241479 14006 : ROSE_ASSERT(functionSymbol != NULL);
241480 :
241481 : // It might be that a pointer to a function would not have a symbol.
241482 14006 : if (functionSymbol != NULL)
241483 14006 : returnFunctionDeclaration = functionSymbol->get_declaration();
241484 :
241485 14006 : return returnFunctionDeclaration;
241486 : }
241487 :
241488 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
241489 : // so that we could avoid them setting the isModified flag which is a problem in the
241490 : // name qualification support for C++ (interfering with the token-based unparsing).
241491 : int
241492 1061 : SgFunctionRefExp::get_name_qualification_length () const
241493 : {
241494 1061 : ROSE_ASSERT (this != NULL);
241495 1061 : return p_name_qualification_length;
241496 : }
241497 :
241498 : void
241499 6086 : SgFunctionRefExp::set_name_qualification_length ( int name_qualification_length )
241500 : {
241501 6086 : ROSE_ASSERT (this != NULL);
241502 : // This can't be called by the name qualification API (see test2015_26.C).
241503 : // set_isModified(true);
241504 :
241505 6086 : p_name_qualification_length = name_qualification_length;
241506 6086 : }
241507 :
241508 : bool
241509 0 : SgFunctionRefExp::get_type_elaboration_required () const
241510 : {
241511 0 : ROSE_ASSERT (this != NULL);
241512 0 : return p_type_elaboration_required;
241513 : }
241514 :
241515 : void
241516 6086 : SgFunctionRefExp::set_type_elaboration_required ( bool type_elaboration_required )
241517 : {
241518 6086 : ROSE_ASSERT (this != NULL);
241519 : // This can't be called by the name qualification API (see test2015_26.C).
241520 : // set_isModified(true);
241521 :
241522 6086 : p_type_elaboration_required = type_elaboration_required;
241523 6086 : }
241524 :
241525 : bool
241526 1061 : SgFunctionRefExp::get_global_qualification_required () const
241527 : {
241528 1061 : ROSE_ASSERT (this != NULL);
241529 1061 : return p_global_qualification_required;
241530 : }
241531 :
241532 : void
241533 6086 : SgFunctionRefExp::set_global_qualification_required ( bool global_qualification_required )
241534 : {
241535 6086 : ROSE_ASSERT (this != NULL);
241536 :
241537 : // This can't be called by the name qualification API (see test2015_26.C).
241538 : // set_isModified(true);
241539 :
241540 6086 : p_global_qualification_required = global_qualification_required;
241541 6086 : }
241542 :
241543 :
241544 :
241545 : // End of memberFunctionString
241546 : // Start of memberFunctionString
241547 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
241548 :
241549 :
241550 : SgType*
241551 50052 : SgFunctionRefExp::get_type() const
241552 : {
241553 50052 : ROSE_ASSERT(this != NULL);
241554 :
241555 : #if 0
241556 : printf ("In SgFunctionRefExp::get_type() \n");
241557 : #endif
241558 :
241559 50052 : SgSymbol* symbol = this->get_symbol();
241560 50052 : if (symbol == NULL)
241561 : {
241562 0 : printf ("Error: In SgFunctionRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
241563 : }
241564 50052 : ROSE_ASSERT(symbol != NULL);
241565 :
241566 : // DQ (9/27/2006): Added assertion
241567 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
241568 :
241569 : // printf ("In SgFunctionRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
241570 50052 : SgType* type = symbol->get_type();
241571 50052 : if (type == NULL)
241572 : {
241573 0 : printf ("Error: In SgFunctionRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
241574 : }
241575 50052 : ROSE_ASSERT(type != NULL);
241576 :
241577 : // return get_symbol()->get_type();
241578 50052 : return type;
241579 : }
241580 :
241581 :
241582 :
241583 : // End of memberFunctionString
241584 : // Start of memberFunctionString
241585 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
241586 :
241587 : // *** COMMON CODE SECTION BEGINS HERE ***
241588 :
241589 : #if 0
241590 : int
241591 : SgFunctionRefExp::getVariant() const
241592 : {
241593 : // This function is used in ROSE while "variant()" is used in SAGE
241594 : assert(this != NULL);
241595 : return variant();
241596 : }
241597 : #endif
241598 :
241599 : // This function is used in ROSE in treeTraversal code
241600 : // eventually replaces getVariant() and variant()
241601 : // though after variant() has been removed for a while we will
241602 : // want to change the name of variantT() back to variant()
241603 : // (since the "T" was ment to stand for temporary).
241604 : // When this happens the variantT() will be depricated.
241605 : VariantT
241606 2574850 : SgFunctionRefExp::variantT() const
241607 : {
241608 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
241609 2574850 : ROSE_ASSERT(this != NULL);
241610 2574850 : return V_SgFunctionRefExp;
241611 : }
241612 :
241613 : #if 0
241614 : int
241615 : SgFunctionRefExp::variant() const
241616 : {
241617 : // This function is used in SAGE
241618 : ROSE_ASSERT(this != NULL);
241619 : return FUNCTION_REF;
241620 : }
241621 : #endif
241622 :
241623 : ROSE_DLL_API const char*
241624 508 : SgFunctionRefExp::sage_class_name() const
241625 : {
241626 508 : ROSE_ASSERT(this != NULL);
241627 508 : return "SgFunctionRefExp";
241628 : }
241629 :
241630 : std::string
241631 6026 : SgFunctionRefExp::class_name() const
241632 : {
241633 6026 : ROSE_ASSERT(this != NULL);
241634 6026 : return "SgFunctionRefExp";
241635 : }
241636 :
241637 : // DQ (11/26/2005): Support for visitor pattern mechanims
241638 : // (inferior to ROSE traversal mechanism, experimental).
241639 : void
241640 84885 : SgFunctionRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
241641 : {
241642 84885 : ROSE_ASSERT(this != NULL);
241643 84885 : visitor.visit(this);
241644 84885 : }
241645 :
241646 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
241647 0 : void SgFunctionRefExp::accept (ROSE_VisitorPattern & visitor) {
241648 0 : ROSE_ASSERT(this != NULL);
241649 0 : visitor.visit(this);
241650 0 : }
241651 :
241652 : SgFunctionRefExp*
241653 0 : SgFunctionRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
241654 : {
241655 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
241656 : // This function is currently only supported for the AST used the represent Binary executables.
241657 : if (0 /* isSgAsmNode(this) != NULL */)
241658 : {
241659 : // Support for regex specification.
241660 : std::string prefixCode = "REGEX:";
241661 : addNewAttribute(prefixCode + s,a);
241662 : }
241663 : #endif
241664 :
241665 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
241666 0 : return this;
241667 : }
241668 :
241669 : // *** COMMON CODE SECTION ENDS HERE ***
241670 :
241671 :
241672 : // End of memberFunctionString
241673 : // Start of memberFunctionString
241674 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
241675 :
241676 :
241677 : #if 0
241678 : //! Error checking support
241679 : /*! Verifies the following:
241680 : - working getVariant() member function
241681 : - calls base class's error() member function
241682 : Every class has one of these functions.
241683 : */
241684 : bool
241685 : SgFunctionRefExp::error()
241686 : {
241687 : // Put error checking here
241688 :
241689 : ROSE_ASSERT (this != NULL);
241690 : if (getVariant() != FUNCTION_REF)
241691 : {
241692 : printf ("Error in SgFunctionRefExp::error(): SgFunctionRefExp object has a %s variant \n",
241693 : Cxx_GrammarTerminalNames[getVariant()].name);
241694 : // printf ("Error in SgFunctionRefExp::error() \n");
241695 : ROSE_ABORT();
241696 : }
241697 :
241698 : ROSE_ASSERT (getVariant() == FUNCTION_REF);
241699 : return SgExpression::error();
241700 : }
241701 : #endif
241702 :
241703 :
241704 :
241705 : // End of memberFunctionString
241706 :
241707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
241708 :
241709 9171380 : SgFunctionRefExp* isSgFunctionRefExp ( SgNode* inputDerivedClassPointer )
241710 : {
241711 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
241712 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
241713 : // So to fix this we return NULL directly when the input is NULL and avoid the
241714 : // dynamic_cast in this case. This is likely a performance improvement as well.
241715 : // return dynamic_cast<SgFunctionRefExp*>(inputDerivedClassPointer);
241716 : // Milind Chabbi (8/28/2013): isSgFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
241717 : // this improves the running time performance by 10-20%.
241718 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionRefExp*>(inputDerivedClassPointer);
241719 9171380 : return IS_SgFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
241720 : }
241721 :
241722 : // DQ (11/8/2003): Added version of functions taking const pointer
241723 350 : const SgFunctionRefExp* isSgFunctionRefExp ( const SgNode* inputDerivedClassPointer )
241724 : {
241725 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
241726 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
241727 : // So to fix this we return NULL directly when the input is NULL and avoid the
241728 : // dynamic_cast in this case. This is likely a performance improvement as well.
241729 : // return dynamic_cast<const SgFunctionRefExp*>(inputDerivedClassPointer);
241730 : // Milind Chabbi (8/28/2013): isSgFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
241731 : // this improves the running time performance by 10-20%.
241732 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionRefExp*>(inputDerivedClassPointer);
241733 350 : return IS_SgFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
241734 : }
241735 :
241736 :
241737 :
241738 : /* #line 241739 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241739 :
241740 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
241741 :
241742 : /**
241743 : \brief Generated destructor
241744 :
241745 : This destructor is automatically generated (by ROSETTA). This destructor
241746 : only frees memory of data members associated with the parts of the current IR node which
241747 : are NOT traversed. Those data members that are part of a traversal can be freed using
241748 : a traversal (calling this destructor on all children in a post-order traversal). Such
241749 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
241750 :
241751 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
241752 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
241753 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
241754 :
241755 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
241756 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
241757 : pointers are not yet implemented to call delete on eash pointer in the container.
241758 : (This could be done by derivation from the STL containers to define containers that
241759 : automatically deleted their members.)
241760 :
241761 : */
241762 2758 : SgFunctionRefExp::~SgFunctionRefExp () {
241763 1379 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
241764 :
241765 :
241766 : // case: not a listType for symbol_i
241767 1379 : p_symbol_i = NULL; // non list case
241768 : // case: not a listType for function_type
241769 1379 : p_function_type = NULL; // non list case
241770 : // case: not a listType for originalExpressionTree
241771 1379 : p_originalExpressionTree = NULL; // non list case
241772 : // case: not a listType for name_qualification_length
241773 1379 : p_name_qualification_length = 0; // non list case
241774 : // case: not a listType for type_elaboration_required
241775 1379 : p_type_elaboration_required = false; // non list case
241776 : // case: not a listType for global_qualification_required
241777 1379 : p_global_qualification_required = false; // non list case
241778 :
241779 : }
241780 :
241781 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
241782 2758 : }
241783 :
241784 :
241785 : /* #line 241786 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241786 :
241787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
241788 :
241789 : // Generated constructor
241790 205 : SgFunctionRefExp::SgFunctionRefExp ( Sg_File_Info* startOfConstruct, SgFunctionSymbol* symbol_i, SgFunctionType* function_type )
241791 205 : : SgExpression(startOfConstruct)
241792 : {
241793 : #ifdef DEBUG
241794 : // printf ("In SgFunctionRefExp::SgFunctionRefExp (Sg_File_Info* startOfConstruct, SgFunctionSymbol* symbol_i, SgFunctionType* function_type) sage_class_name() = %s \n",sage_class_name());
241795 : #endif
241796 : #if 0
241797 : // debugging information!
241798 : printf ("In SgFunctionRefExp::SgFunctionRefExp (Sg_File_Info* startOfConstruct, SgFunctionSymbol* symbol_i, SgFunctionType* function_type): this = %p = %s \n",this,this->class_name().c_str());
241799 : #endif
241800 :
241801 205 : p_symbol_i = symbol_i;
241802 205 : p_function_type = function_type;
241803 205 : p_originalExpressionTree = NULL;
241804 205 : p_name_qualification_length = 0;
241805 205 : p_type_elaboration_required = false;
241806 205 : p_global_qualification_required = false;
241807 :
241808 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
241809 :
241810 : #if 0
241811 : // DQ (7/30/2014): Call a virtual function.
241812 : std::string s = this->class_name();
241813 : #endif
241814 :
241815 : // Test the variant virtual function
241816 : // assert(FUNCTION_REF == variant());
241817 205 : assert(FUNCTION_REF == this->variant());
241818 205 : ROSE_ASSERT(FUNCTION_REF == (int)(this->variantT()));
241819 205 : post_construction_initialization();
241820 :
241821 : // Test the isSgFunctionRefExp() function since it has been problematic
241822 205 : assert(isSgFunctionRefExp(this) != NULL);
241823 205 : }
241824 :
241825 : // Generated constructor (all data members)
241826 :
241827 : /* #line 241828 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241828 :
241829 :
241830 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
241831 :
241832 :
241833 : // ********************************************************
241834 : // member functions common across all array grammar objects
241835 : // ********************************************************
241836 :
241837 :
241838 :
241839 : /* #line 241840 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241840 :
241841 :
241842 :
241843 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
241844 :
241845 : // ********************************************************
241846 : // member functions specific to each node in the grammar
241847 : // ********************************************************
241848 :
241849 :
241850 : /* #line 241851 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
241851 :
241852 : // Start of memberFunctionString
241853 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
241854 :
241855 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
241856 :
241857 : SgMemberFunctionSymbol*
241858 100204 : SgMemberFunctionRefExp::get_symbol_i () const
241859 : {
241860 100204 : ROSE_ASSERT (this != NULL);
241861 :
241862 : #if 0
241863 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241864 : // used to trigger marking transformations for the token-based unparsing.
241865 : printf ("SgMemberFunctionRefExp::get_symbol_i = %p = %s \n",this,this->class_name().c_str());
241866 : #endif
241867 :
241868 100204 : return p_symbol_i;
241869 : }
241870 :
241871 : void
241872 0 : SgMemberFunctionRefExp::set_symbol_i ( SgMemberFunctionSymbol* symbol_i )
241873 : {
241874 0 : ROSE_ASSERT (this != NULL);
241875 :
241876 : #if 0
241877 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241878 : // used to trigger marking transformations for the token-based unparsing.
241879 : printf ("SgMemberFunctionRefExp::set_symbol_i = %p = %s \n",this,this->class_name().c_str());
241880 : #endif
241881 :
241882 0 : set_isModified(true);
241883 :
241884 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
241885 : if (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i)
241886 : {
241887 : printf ("Warning: symbol_i = %p overwriting valid pointer p_symbol_i = %p \n",symbol_i,p_symbol_i);
241888 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
241889 : printf ("Error fails assertion (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i) is false\n");
241890 : ROSE_ASSERT(false);
241891 : #endif
241892 : }
241893 : #endif
241894 0 : p_symbol_i = symbol_i;
241895 0 : }
241896 :
241897 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
241898 :
241899 :
241900 : // End of memberFunctionString
241901 : // Start of memberFunctionString
241902 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
241903 :
241904 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
241905 :
241906 : int
241907 0 : SgMemberFunctionRefExp::get_virtual_call () const
241908 : {
241909 0 : ROSE_ASSERT (this != NULL);
241910 :
241911 : #if 0
241912 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241913 : // used to trigger marking transformations for the token-based unparsing.
241914 : printf ("SgMemberFunctionRefExp::get_virtual_call = %p = %s \n",this,this->class_name().c_str());
241915 : #endif
241916 :
241917 0 : return p_virtual_call;
241918 : }
241919 :
241920 : void
241921 0 : SgMemberFunctionRefExp::set_virtual_call ( int virtual_call )
241922 : {
241923 0 : ROSE_ASSERT (this != NULL);
241924 :
241925 : #if 0
241926 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241927 : // used to trigger marking transformations for the token-based unparsing.
241928 : printf ("SgMemberFunctionRefExp::set_virtual_call = %p = %s \n",this,this->class_name().c_str());
241929 : #endif
241930 :
241931 0 : set_isModified(true);
241932 :
241933 0 : p_virtual_call = virtual_call;
241934 0 : }
241935 :
241936 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
241937 :
241938 :
241939 : // End of memberFunctionString
241940 : // Start of memberFunctionString
241941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
241942 :
241943 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
241944 :
241945 : int
241946 2850 : SgMemberFunctionRefExp::get_need_qualifier () const
241947 : {
241948 2850 : ROSE_ASSERT (this != NULL);
241949 :
241950 : #if 0
241951 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241952 : // used to trigger marking transformations for the token-based unparsing.
241953 : printf ("SgMemberFunctionRefExp::get_need_qualifier = %p = %s \n",this,this->class_name().c_str());
241954 : #endif
241955 :
241956 2850 : return p_need_qualifier;
241957 : }
241958 :
241959 : void
241960 563 : SgMemberFunctionRefExp::set_need_qualifier ( int need_qualifier )
241961 : {
241962 563 : ROSE_ASSERT (this != NULL);
241963 :
241964 : #if 0
241965 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
241966 : // used to trigger marking transformations for the token-based unparsing.
241967 : printf ("SgMemberFunctionRefExp::set_need_qualifier = %p = %s \n",this,this->class_name().c_str());
241968 : #endif
241969 :
241970 563 : set_isModified(true);
241971 :
241972 563 : p_need_qualifier = need_qualifier;
241973 563 : }
241974 :
241975 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
241976 :
241977 :
241978 : // End of memberFunctionString
241979 : // Start of memberFunctionString
241980 :
241981 :
241982 : // End of memberFunctionString
241983 : // Start of memberFunctionString
241984 : /* #line 3695 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
241985 :
241986 :
241987 : void
241988 4759 : SgMemberFunctionRefExp::post_construction_initialization()
241989 : {
241990 4759 : }
241991 :
241992 : SgMemberFunctionSymbol*
241993 82420 : SgMemberFunctionRefExp::get_symbol() const
241994 82420 : { return get_symbol_i(); }
241995 :
241996 : void
241997 0 : SgMemberFunctionRefExp::set_symbol(SgMemberFunctionSymbol * symbol)
241998 : {
241999 0 : set_symbol_i(symbol);
242000 :
242001 : // DQ (1/14/2006): set_type is removed
242002 : // set_type();
242003 0 : }
242004 :
242005 : #if 0
242006 : void
242007 : SgMemberFunctionRefExp::set_type()
242008 : {
242009 : SgMemberFunctionSymbol *mfsym = get_symbol();
242010 : ROSE_ASSERT(mfsym != NULL);
242011 : p_function_type = (SgFunctionType *)(mfsym->get_type());
242012 : if ( p_function_type == NULL )
242013 : {
242014 : cout << "bad" << mfsym->get_name().str() << endl;
242015 :
242016 : // DQ (9/12/2004): Made this an error (I think it should be and it is in the case of a function pointer)
242017 : ROSE_ASSERT(false);
242018 : }
242019 : }
242020 : #endif
242021 :
242022 : // DQ (2/8/2009): I always wanted to have this function!
242023 : SgMemberFunctionDeclaration*
242024 15379 : SgMemberFunctionRefExp::getAssociatedMemberFunctionDeclaration() const
242025 : {
242026 : // This is helpful in chasing down the associated declaration to this member function reference.
242027 15379 : SgMemberFunctionDeclaration* returnMemberFunctionDeclaration = NULL;
242028 15379 : SgMemberFunctionSymbol* memberFunctionSymbol = this->get_symbol();
242029 :
242030 : // DQ (2/8/2009): Can we assert this! What about pointers to functions?
242031 15379 : ROSE_ASSERT(memberFunctionSymbol != NULL);
242032 :
242033 : // It might be that a pointer to a function would not have a symbol.
242034 15379 : if (memberFunctionSymbol != NULL)
242035 15379 : returnMemberFunctionDeclaration = memberFunctionSymbol->get_declaration();
242036 :
242037 15379 : return returnMemberFunctionDeclaration;
242038 : }
242039 :
242040 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
242041 : // so that we could avoid them setting the isModified flag which is a problem in the
242042 : // name qualification support for C++ (interfering with the token-based unparsing).
242043 : int
242044 0 : SgMemberFunctionRefExp::get_name_qualification_length () const
242045 : {
242046 0 : ROSE_ASSERT (this != NULL);
242047 0 : return p_name_qualification_length;
242048 : }
242049 :
242050 : void
242051 5161 : SgMemberFunctionRefExp::set_name_qualification_length ( int name_qualification_length )
242052 : {
242053 5161 : ROSE_ASSERT (this != NULL);
242054 : // This can't be called by the name qualification API (see test2015_26.C).
242055 : // set_isModified(true);
242056 :
242057 5161 : p_name_qualification_length = name_qualification_length;
242058 5161 : }
242059 :
242060 : bool
242061 0 : SgMemberFunctionRefExp::get_type_elaboration_required () const
242062 : {
242063 0 : ROSE_ASSERT (this != NULL);
242064 0 : return p_type_elaboration_required;
242065 : }
242066 :
242067 : void
242068 5161 : SgMemberFunctionRefExp::set_type_elaboration_required ( bool type_elaboration_required )
242069 : {
242070 5161 : ROSE_ASSERT (this != NULL);
242071 : // This can't be called by the name qualification API (see test2015_26.C).
242072 : // set_isModified(true);
242073 :
242074 5161 : p_type_elaboration_required = type_elaboration_required;
242075 5161 : }
242076 :
242077 : bool
242078 0 : SgMemberFunctionRefExp::get_global_qualification_required () const
242079 : {
242080 0 : ROSE_ASSERT (this != NULL);
242081 0 : return p_global_qualification_required;
242082 : }
242083 :
242084 : void
242085 5161 : SgMemberFunctionRefExp::set_global_qualification_required ( bool global_qualification_required )
242086 : {
242087 5161 : ROSE_ASSERT (this != NULL);
242088 :
242089 : // This can't be called by the name qualification API (see test2015_26.C).
242090 : // set_isModified(true);
242091 :
242092 5161 : p_global_qualification_required = global_qualification_required;
242093 5161 : }
242094 :
242095 :
242096 :
242097 : // End of memberFunctionString
242098 : // Start of memberFunctionString
242099 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
242100 :
242101 :
242102 : SgType*
242103 29569 : SgMemberFunctionRefExp::get_type() const
242104 : {
242105 29569 : ROSE_ASSERT(this != NULL);
242106 :
242107 : #if 0
242108 : printf ("In SgMemberFunctionRefExp::get_type() \n");
242109 : #endif
242110 :
242111 29569 : SgSymbol* symbol = this->get_symbol();
242112 29569 : if (symbol == NULL)
242113 : {
242114 0 : printf ("Error: In SgMemberFunctionRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
242115 : }
242116 29569 : ROSE_ASSERT(symbol != NULL);
242117 :
242118 : // DQ (9/27/2006): Added assertion
242119 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
242120 :
242121 : // printf ("In SgMemberFunctionRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
242122 29569 : SgType* type = symbol->get_type();
242123 29569 : if (type == NULL)
242124 : {
242125 0 : printf ("Error: In SgMemberFunctionRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
242126 : }
242127 29569 : ROSE_ASSERT(type != NULL);
242128 :
242129 : // return get_symbol()->get_type();
242130 29569 : return type;
242131 : }
242132 :
242133 :
242134 :
242135 : // End of memberFunctionString
242136 : // Start of memberFunctionString
242137 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
242138 :
242139 : // *** COMMON CODE SECTION BEGINS HERE ***
242140 :
242141 : #if 0
242142 : int
242143 : SgMemberFunctionRefExp::getVariant() const
242144 : {
242145 : // This function is used in ROSE while "variant()" is used in SAGE
242146 : assert(this != NULL);
242147 : return variant();
242148 : }
242149 : #endif
242150 :
242151 : // This function is used in ROSE in treeTraversal code
242152 : // eventually replaces getVariant() and variant()
242153 : // though after variant() has been removed for a while we will
242154 : // want to change the name of variantT() back to variant()
242155 : // (since the "T" was ment to stand for temporary).
242156 : // When this happens the variantT() will be depricated.
242157 : VariantT
242158 1407590 : SgMemberFunctionRefExp::variantT() const
242159 : {
242160 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
242161 1407590 : ROSE_ASSERT(this != NULL);
242162 1407590 : return V_SgMemberFunctionRefExp;
242163 : }
242164 :
242165 : #if 0
242166 : int
242167 : SgMemberFunctionRefExp::variant() const
242168 : {
242169 : // This function is used in SAGE
242170 : ROSE_ASSERT(this != NULL);
242171 : return MEMBER_FUNCTION_REF;
242172 : }
242173 : #endif
242174 :
242175 : ROSE_DLL_API const char*
242176 597 : SgMemberFunctionRefExp::sage_class_name() const
242177 : {
242178 597 : ROSE_ASSERT(this != NULL);
242179 597 : return "SgMemberFunctionRefExp";
242180 : }
242181 :
242182 : std::string
242183 3368 : SgMemberFunctionRefExp::class_name() const
242184 : {
242185 3368 : ROSE_ASSERT(this != NULL);
242186 3368 : return "SgMemberFunctionRefExp";
242187 : }
242188 :
242189 : // DQ (11/26/2005): Support for visitor pattern mechanims
242190 : // (inferior to ROSE traversal mechanism, experimental).
242191 : void
242192 76152 : SgMemberFunctionRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
242193 : {
242194 76152 : ROSE_ASSERT(this != NULL);
242195 76152 : visitor.visit(this);
242196 76152 : }
242197 :
242198 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
242199 0 : void SgMemberFunctionRefExp::accept (ROSE_VisitorPattern & visitor) {
242200 0 : ROSE_ASSERT(this != NULL);
242201 0 : visitor.visit(this);
242202 0 : }
242203 :
242204 : SgMemberFunctionRefExp*
242205 0 : SgMemberFunctionRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
242206 : {
242207 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
242208 : // This function is currently only supported for the AST used the represent Binary executables.
242209 : if (0 /* isSgAsmNode(this) != NULL */)
242210 : {
242211 : // Support for regex specification.
242212 : std::string prefixCode = "REGEX:";
242213 : addNewAttribute(prefixCode + s,a);
242214 : }
242215 : #endif
242216 :
242217 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
242218 0 : return this;
242219 : }
242220 :
242221 : // *** COMMON CODE SECTION ENDS HERE ***
242222 :
242223 :
242224 : // End of memberFunctionString
242225 : // Start of memberFunctionString
242226 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
242227 :
242228 :
242229 : #if 0
242230 : //! Error checking support
242231 : /*! Verifies the following:
242232 : - working getVariant() member function
242233 : - calls base class's error() member function
242234 : Every class has one of these functions.
242235 : */
242236 : bool
242237 : SgMemberFunctionRefExp::error()
242238 : {
242239 : // Put error checking here
242240 :
242241 : ROSE_ASSERT (this != NULL);
242242 : if (getVariant() != MEMBER_FUNCTION_REF)
242243 : {
242244 : printf ("Error in SgMemberFunctionRefExp::error(): SgMemberFunctionRefExp object has a %s variant \n",
242245 : Cxx_GrammarTerminalNames[getVariant()].name);
242246 : // printf ("Error in SgMemberFunctionRefExp::error() \n");
242247 : ROSE_ABORT();
242248 : }
242249 :
242250 : ROSE_ASSERT (getVariant() == MEMBER_FUNCTION_REF);
242251 : return SgExpression::error();
242252 : }
242253 : #endif
242254 :
242255 :
242256 :
242257 : // End of memberFunctionString
242258 :
242259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
242260 :
242261 3110390 : SgMemberFunctionRefExp* isSgMemberFunctionRefExp ( SgNode* inputDerivedClassPointer )
242262 : {
242263 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
242264 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
242265 : // So to fix this we return NULL directly when the input is NULL and avoid the
242266 : // dynamic_cast in this case. This is likely a performance improvement as well.
242267 : // return dynamic_cast<SgMemberFunctionRefExp*>(inputDerivedClassPointer);
242268 : // Milind Chabbi (8/28/2013): isSgMemberFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
242269 : // this improves the running time performance by 10-20%.
242270 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMemberFunctionRefExp*>(inputDerivedClassPointer);
242271 3110390 : return IS_SgMemberFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
242272 : }
242273 :
242274 : // DQ (11/8/2003): Added version of functions taking const pointer
242275 40 : const SgMemberFunctionRefExp* isSgMemberFunctionRefExp ( const SgNode* inputDerivedClassPointer )
242276 : {
242277 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
242278 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
242279 : // So to fix this we return NULL directly when the input is NULL and avoid the
242280 : // dynamic_cast in this case. This is likely a performance improvement as well.
242281 : // return dynamic_cast<const SgMemberFunctionRefExp*>(inputDerivedClassPointer);
242282 : // Milind Chabbi (8/28/2013): isSgMemberFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
242283 : // this improves the running time performance by 10-20%.
242284 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMemberFunctionRefExp*>(inputDerivedClassPointer);
242285 40 : return IS_SgMemberFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
242286 : }
242287 :
242288 :
242289 :
242290 : /* #line 242291 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242291 :
242292 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
242293 :
242294 : /**
242295 : \brief Generated destructor
242296 :
242297 : This destructor is automatically generated (by ROSETTA). This destructor
242298 : only frees memory of data members associated with the parts of the current IR node which
242299 : are NOT traversed. Those data members that are part of a traversal can be freed using
242300 : a traversal (calling this destructor on all children in a post-order traversal). Such
242301 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
242302 :
242303 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
242304 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
242305 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
242306 :
242307 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
242308 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
242309 : pointers are not yet implemented to call delete on eash pointer in the container.
242310 : (This could be done by derivation from the STL containers to define containers that
242311 : automatically deleted their members.)
242312 :
242313 : */
242314 2160 : SgMemberFunctionRefExp::~SgMemberFunctionRefExp () {
242315 1080 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
242316 :
242317 :
242318 : // case: not a listType for symbol_i
242319 1080 : p_symbol_i = NULL; // non list case
242320 : // case: not a listType for virtual_call
242321 1080 : p_virtual_call = 0; // non list case
242322 : // case: not a listType for function_type
242323 1080 : p_function_type = NULL; // non list case
242324 : // case: not a listType for need_qualifier
242325 1080 : p_need_qualifier = true; // non list case
242326 : // case: not a listType for name_qualification_length
242327 1080 : p_name_qualification_length = 0; // non list case
242328 : // case: not a listType for type_elaboration_required
242329 1080 : p_type_elaboration_required = false; // non list case
242330 : // case: not a listType for global_qualification_required
242331 1080 : p_global_qualification_required = false; // non list case
242332 :
242333 : }
242334 :
242335 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
242336 2160 : }
242337 :
242338 :
242339 : /* #line 242340 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242340 :
242341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
242342 :
242343 : // Generated constructor
242344 100 : SgMemberFunctionRefExp::SgMemberFunctionRefExp ( Sg_File_Info* startOfConstruct, SgMemberFunctionSymbol* symbol_i, int virtual_call, SgFunctionType* function_type, int need_qualifier )
242345 100 : : SgExpression(startOfConstruct)
242346 : {
242347 : #ifdef DEBUG
242348 : // printf ("In SgMemberFunctionRefExp::SgMemberFunctionRefExp (Sg_File_Info* startOfConstruct, SgMemberFunctionSymbol* symbol_i, int virtual_call, SgFunctionType* function_type, int need_qualifier) sage_class_name() = %s \n",sage_class_name());
242349 : #endif
242350 : #if 0
242351 : // debugging information!
242352 : printf ("In SgMemberFunctionRefExp::SgMemberFunctionRefExp (Sg_File_Info* startOfConstruct, SgMemberFunctionSymbol* symbol_i, int virtual_call, SgFunctionType* function_type, int need_qualifier): this = %p = %s \n",this,this->class_name().c_str());
242353 : #endif
242354 :
242355 100 : p_symbol_i = symbol_i;
242356 100 : p_virtual_call = virtual_call;
242357 100 : p_function_type = function_type;
242358 100 : p_need_qualifier = need_qualifier;
242359 100 : p_name_qualification_length = 0;
242360 100 : p_type_elaboration_required = false;
242361 100 : p_global_qualification_required = false;
242362 :
242363 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
242364 :
242365 : #if 0
242366 : // DQ (7/30/2014): Call a virtual function.
242367 : std::string s = this->class_name();
242368 : #endif
242369 :
242370 : // Test the variant virtual function
242371 : // assert(MEMBER_FUNCTION_REF == variant());
242372 100 : assert(MEMBER_FUNCTION_REF == this->variant());
242373 100 : ROSE_ASSERT(MEMBER_FUNCTION_REF == (int)(this->variantT()));
242374 100 : post_construction_initialization();
242375 :
242376 : // Test the isSgMemberFunctionRefExp() function since it has been problematic
242377 100 : assert(isSgMemberFunctionRefExp(this) != NULL);
242378 100 : }
242379 :
242380 : // Generated constructor (all data members)
242381 :
242382 : /* #line 242383 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242383 :
242384 :
242385 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
242386 :
242387 :
242388 : // ********************************************************
242389 : // member functions common across all array grammar objects
242390 : // ********************************************************
242391 :
242392 :
242393 :
242394 : /* #line 242395 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242395 :
242396 :
242397 :
242398 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
242399 :
242400 : // ********************************************************
242401 : // member functions specific to each node in the grammar
242402 : // ********************************************************
242403 :
242404 :
242405 : /* #line 242406 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242406 :
242407 : // Start of memberFunctionString
242408 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
242409 :
242410 : void
242411 60269 : SgValueExp::post_construction_initialization()
242412 : {
242413 60269 : }
242414 :
242415 :
242416 :
242417 : // End of memberFunctionString
242418 : // Start of memberFunctionString
242419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
242420 :
242421 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
242422 :
242423 : SgExpression*
242424 166611 : SgValueExp::get_originalExpressionTree () const
242425 : {
242426 166611 : ROSE_ASSERT (this != NULL);
242427 :
242428 : #if 0
242429 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
242430 : // used to trigger marking transformations for the token-based unparsing.
242431 : printf ("SgValueExp::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
242432 : #endif
242433 :
242434 166611 : return p_originalExpressionTree;
242435 : }
242436 :
242437 : void
242438 37425 : SgValueExp::set_originalExpressionTree ( SgExpression* originalExpressionTree )
242439 : {
242440 37425 : ROSE_ASSERT (this != NULL);
242441 :
242442 : #if 0
242443 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
242444 : // used to trigger marking transformations for the token-based unparsing.
242445 : printf ("SgValueExp::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
242446 : #endif
242447 :
242448 37425 : set_isModified(true);
242449 :
242450 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
242451 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
242452 : {
242453 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
242454 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
242455 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
242456 : ROSE_ASSERT(false);
242457 : #endif
242458 : }
242459 : #endif
242460 37425 : p_originalExpressionTree = originalExpressionTree;
242461 37425 : }
242462 :
242463 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
242464 :
242465 :
242466 : // End of memberFunctionString
242467 : // Start of memberFunctionString
242468 : /* #line 3994 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
242469 :
242470 :
242471 :
242472 :
242473 : // End of memberFunctionString
242474 : // Start of memberFunctionString
242475 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
242476 :
242477 : // *** COMMON CODE SECTION BEGINS HERE ***
242478 :
242479 : #if 0
242480 : int
242481 : SgValueExp::getVariant() const
242482 : {
242483 : // This function is used in ROSE while "variant()" is used in SAGE
242484 : assert(this != NULL);
242485 : return variant();
242486 : }
242487 : #endif
242488 :
242489 : // This function is used in ROSE in treeTraversal code
242490 : // eventually replaces getVariant() and variant()
242491 : // though after variant() has been removed for a while we will
242492 : // want to change the name of variantT() back to variant()
242493 : // (since the "T" was ment to stand for temporary).
242494 : // When this happens the variantT() will be depricated.
242495 : VariantT
242496 180807 : SgValueExp::variantT() const
242497 : {
242498 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
242499 180807 : ROSE_ASSERT(this != NULL);
242500 180807 : return V_SgValueExp;
242501 : }
242502 :
242503 : #if 0
242504 : int
242505 : SgValueExp::variant() const
242506 : {
242507 : // This function is used in SAGE
242508 : ROSE_ASSERT(this != NULL);
242509 : return ValueExpTag;
242510 : }
242511 : #endif
242512 :
242513 : ROSE_DLL_API const char*
242514 0 : SgValueExp::sage_class_name() const
242515 : {
242516 0 : ROSE_ASSERT(this != NULL);
242517 0 : return "SgValueExp";
242518 : }
242519 :
242520 : std::string
242521 0 : SgValueExp::class_name() const
242522 : {
242523 0 : ROSE_ASSERT(this != NULL);
242524 0 : return "SgValueExp";
242525 : }
242526 :
242527 : // DQ (11/26/2005): Support for visitor pattern mechanims
242528 : // (inferior to ROSE traversal mechanism, experimental).
242529 : void
242530 0 : SgValueExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
242531 : {
242532 0 : ROSE_ASSERT(this != NULL);
242533 0 : visitor.visit(this);
242534 0 : }
242535 :
242536 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
242537 0 : void SgValueExp::accept (ROSE_VisitorPattern & visitor) {
242538 0 : ROSE_ASSERT(this != NULL);
242539 0 : visitor.visit(this);
242540 0 : }
242541 :
242542 : SgValueExp*
242543 0 : SgValueExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
242544 : {
242545 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
242546 : // This function is currently only supported for the AST used the represent Binary executables.
242547 : if (0 /* isSgAsmNode(this) != NULL */)
242548 : {
242549 : // Support for regex specification.
242550 : std::string prefixCode = "REGEX:";
242551 : addNewAttribute(prefixCode + s,a);
242552 : }
242553 : #endif
242554 :
242555 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
242556 0 : return this;
242557 : }
242558 :
242559 : // *** COMMON CODE SECTION ENDS HERE ***
242560 :
242561 :
242562 : // End of memberFunctionString
242563 : // Start of memberFunctionString
242564 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
242565 :
242566 :
242567 : #if 0
242568 : //! Error checking support
242569 : /*! Verifies the following:
242570 : - working getVariant() member function
242571 : - calls base class's error() member function
242572 : Every class has one of these functions.
242573 : */
242574 : bool
242575 : SgValueExp::error()
242576 : {
242577 : // Put error checking here
242578 :
242579 : ROSE_ASSERT (this != NULL);
242580 : if (getVariant() != ValueExpTag)
242581 : {
242582 : printf ("Error in SgValueExp::error(): SgValueExp object has a %s variant \n",
242583 : Cxx_GrammarTerminalNames[getVariant()].name);
242584 : // printf ("Error in SgValueExp::error() \n");
242585 : ROSE_ABORT();
242586 : }
242587 :
242588 : ROSE_ASSERT (getVariant() == ValueExpTag);
242589 : return SgExpression::error();
242590 : }
242591 : #endif
242592 :
242593 :
242594 :
242595 : // End of memberFunctionString
242596 :
242597 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
242598 :
242599 131947 : SgValueExp* isSgValueExp ( SgNode* inputDerivedClassPointer )
242600 : {
242601 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
242602 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
242603 : // So to fix this we return NULL directly when the input is NULL and avoid the
242604 : // dynamic_cast in this case. This is likely a performance improvement as well.
242605 : // return dynamic_cast<SgValueExp*>(inputDerivedClassPointer);
242606 : // Milind Chabbi (8/28/2013): isSgValueExp uses table-driven castability instead of c++ default dynamic_cast
242607 : // this improves the running time performance by 10-20%.
242608 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgValueExp*>(inputDerivedClassPointer);
242609 131947 : return IS_SgValueExp_FAST_MACRO(inputDerivedClassPointer);
242610 : }
242611 :
242612 : // DQ (11/8/2003): Added version of functions taking const pointer
242613 85038 : const SgValueExp* isSgValueExp ( const SgNode* inputDerivedClassPointer )
242614 : {
242615 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
242616 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
242617 : // So to fix this we return NULL directly when the input is NULL and avoid the
242618 : // dynamic_cast in this case. This is likely a performance improvement as well.
242619 : // return dynamic_cast<const SgValueExp*>(inputDerivedClassPointer);
242620 : // Milind Chabbi (8/28/2013): isSgValueExp uses table-driven castability instead of c++ default dynamic_cast
242621 : // this improves the running time performance by 10-20%.
242622 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgValueExp*>(inputDerivedClassPointer);
242623 85038 : return IS_SgValueExp_FAST_MACRO(inputDerivedClassPointer);
242624 : }
242625 :
242626 :
242627 :
242628 : /* #line 242629 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242629 :
242630 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
242631 :
242632 : /**
242633 : \brief Generated destructor
242634 :
242635 : This destructor is automatically generated (by ROSETTA). This destructor
242636 : only frees memory of data members associated with the parts of the current IR node which
242637 : are NOT traversed. Those data members that are part of a traversal can be freed using
242638 : a traversal (calling this destructor on all children in a post-order traversal). Such
242639 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
242640 :
242641 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
242642 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
242643 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
242644 :
242645 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
242646 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
242647 : pointers are not yet implemented to call delete on eash pointer in the container.
242648 : (This could be done by derivation from the STL containers to define containers that
242649 : automatically deleted their members.)
242650 :
242651 : */
242652 30210 : SgValueExp::~SgValueExp () {
242653 30210 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
242654 :
242655 :
242656 : // case: not a listType for originalExpressionTree
242657 30210 : p_originalExpressionTree = NULL; // non list case
242658 :
242659 : }
242660 :
242661 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
242662 30210 : }
242663 :
242664 :
242665 : /* #line 242666 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242666 :
242667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
242668 :
242669 : // Generated constructor
242670 921 : SgValueExp::SgValueExp ( Sg_File_Info* startOfConstruct )
242671 921 : : SgExpression(startOfConstruct)
242672 : {
242673 : #ifdef DEBUG
242674 : // printf ("In SgValueExp::SgValueExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
242675 : #endif
242676 : #if 0
242677 : // debugging information!
242678 : printf ("In SgValueExp::SgValueExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
242679 : #endif
242680 :
242681 921 : p_originalExpressionTree = NULL;
242682 :
242683 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
242684 :
242685 : #if 0
242686 : // DQ (7/30/2014): Call a virtual function.
242687 : std::string s = this->class_name();
242688 : #endif
242689 :
242690 : // Test the variant virtual function
242691 : // assert(ValueExpTag == variant());
242692 921 : assert(ValueExpTag == this->variant());
242693 921 : ROSE_ASSERT(ValueExpTag == (int)(this->variantT()));
242694 921 : post_construction_initialization();
242695 :
242696 : // Test the isSgValueExp() function since it has been problematic
242697 921 : assert(isSgValueExp(this) != NULL);
242698 921 : }
242699 :
242700 : // Generated constructor (all data members)
242701 :
242702 : /* #line 242703 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242703 :
242704 :
242705 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
242706 :
242707 :
242708 : // ********************************************************
242709 : // member functions common across all array grammar objects
242710 : // ********************************************************
242711 :
242712 :
242713 :
242714 : /* #line 242715 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242715 :
242716 :
242717 :
242718 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
242719 :
242720 : // ********************************************************
242721 : // member functions specific to each node in the grammar
242722 : // ********************************************************
242723 :
242724 :
242725 : /* #line 242726 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242726 :
242727 : // Start of memberFunctionString
242728 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
242729 :
242730 : void
242731 5006 : SgBoolValExp::post_construction_initialization()
242732 : {
242733 5006 : }
242734 :
242735 :
242736 :
242737 : // End of memberFunctionString
242738 : // Start of memberFunctionString
242739 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
242740 :
242741 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
242742 :
242743 : int
242744 25993 : SgBoolValExp::get_value () const
242745 : {
242746 25993 : ROSE_ASSERT (this != NULL);
242747 :
242748 : #if 0
242749 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
242750 : // used to trigger marking transformations for the token-based unparsing.
242751 : printf ("SgBoolValExp::get_value = %p = %s \n",this,this->class_name().c_str());
242752 : #endif
242753 :
242754 25993 : return p_value;
242755 : }
242756 :
242757 : void
242758 0 : SgBoolValExp::set_value ( int value )
242759 : {
242760 0 : ROSE_ASSERT (this != NULL);
242761 :
242762 : #if 0
242763 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
242764 : // used to trigger marking transformations for the token-based unparsing.
242765 : printf ("SgBoolValExp::set_value = %p = %s \n",this,this->class_name().c_str());
242766 : #endif
242767 :
242768 0 : set_isModified(true);
242769 :
242770 0 : p_value = value;
242771 0 : }
242772 :
242773 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
242774 :
242775 :
242776 : // End of memberFunctionString
242777 : // Start of memberFunctionString
242778 : /* #line 3999 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
242779 :
242780 :
242781 :
242782 : // End of memberFunctionString
242783 : // Start of memberFunctionString
242784 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
242785 :
242786 :
242787 : SgType*
242788 17680 : SgBoolValExp::get_type(void) const
242789 : {
242790 : #if 0
242791 : printf ("In SgBoolValExp::get_type() \n");
242792 : #endif
242793 :
242794 17680 : return SgTypeBool::createType();
242795 : }
242796 :
242797 :
242798 :
242799 : // End of memberFunctionString
242800 : // Start of memberFunctionString
242801 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
242802 :
242803 : // *** COMMON CODE SECTION BEGINS HERE ***
242804 :
242805 : #if 0
242806 : int
242807 : SgBoolValExp::getVariant() const
242808 : {
242809 : // This function is used in ROSE while "variant()" is used in SAGE
242810 : assert(this != NULL);
242811 : return variant();
242812 : }
242813 : #endif
242814 :
242815 : // This function is used in ROSE in treeTraversal code
242816 : // eventually replaces getVariant() and variant()
242817 : // though after variant() has been removed for a while we will
242818 : // want to change the name of variantT() back to variant()
242819 : // (since the "T" was ment to stand for temporary).
242820 : // When this happens the variantT() will be depricated.
242821 : VariantT
242822 1131020 : SgBoolValExp::variantT() const
242823 : {
242824 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
242825 1131020 : ROSE_ASSERT(this != NULL);
242826 1131020 : return V_SgBoolValExp;
242827 : }
242828 :
242829 : #if 0
242830 : int
242831 : SgBoolValExp::variant() const
242832 : {
242833 : // This function is used in SAGE
242834 : ROSE_ASSERT(this != NULL);
242835 : return BOOL_VAL;
242836 : }
242837 : #endif
242838 :
242839 : ROSE_DLL_API const char*
242840 32 : SgBoolValExp::sage_class_name() const
242841 : {
242842 32 : ROSE_ASSERT(this != NULL);
242843 32 : return "SgBoolValExp";
242844 : }
242845 :
242846 : std::string
242847 3090 : SgBoolValExp::class_name() const
242848 : {
242849 3090 : ROSE_ASSERT(this != NULL);
242850 3090 : return "SgBoolValExp";
242851 : }
242852 :
242853 : // DQ (11/26/2005): Support for visitor pattern mechanims
242854 : // (inferior to ROSE traversal mechanism, experimental).
242855 : void
242856 55071 : SgBoolValExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
242857 : {
242858 55071 : ROSE_ASSERT(this != NULL);
242859 55071 : visitor.visit(this);
242860 55071 : }
242861 :
242862 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
242863 0 : void SgBoolValExp::accept (ROSE_VisitorPattern & visitor) {
242864 0 : ROSE_ASSERT(this != NULL);
242865 0 : visitor.visit(this);
242866 0 : }
242867 :
242868 : SgBoolValExp*
242869 0 : SgBoolValExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
242870 : {
242871 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
242872 : // This function is currently only supported for the AST used the represent Binary executables.
242873 : if (0 /* isSgAsmNode(this) != NULL */)
242874 : {
242875 : // Support for regex specification.
242876 : std::string prefixCode = "REGEX:";
242877 : addNewAttribute(prefixCode + s,a);
242878 : }
242879 : #endif
242880 :
242881 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
242882 0 : return this;
242883 : }
242884 :
242885 : // *** COMMON CODE SECTION ENDS HERE ***
242886 :
242887 :
242888 : // End of memberFunctionString
242889 : // Start of memberFunctionString
242890 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
242891 :
242892 :
242893 : #if 0
242894 : //! Error checking support
242895 : /*! Verifies the following:
242896 : - working getVariant() member function
242897 : - calls base class's error() member function
242898 : Every class has one of these functions.
242899 : */
242900 : bool
242901 : SgBoolValExp::error()
242902 : {
242903 : // Put error checking here
242904 :
242905 : ROSE_ASSERT (this != NULL);
242906 : if (getVariant() != BOOL_VAL)
242907 : {
242908 : printf ("Error in SgBoolValExp::error(): SgBoolValExp object has a %s variant \n",
242909 : Cxx_GrammarTerminalNames[getVariant()].name);
242910 : // printf ("Error in SgBoolValExp::error() \n");
242911 : ROSE_ABORT();
242912 : }
242913 :
242914 : ROSE_ASSERT (getVariant() == BOOL_VAL);
242915 : return SgValueExp::error();
242916 : }
242917 : #endif
242918 :
242919 :
242920 :
242921 : // End of memberFunctionString
242922 :
242923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
242924 :
242925 22521 : SgBoolValExp* isSgBoolValExp ( SgNode* inputDerivedClassPointer )
242926 : {
242927 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
242928 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
242929 : // So to fix this we return NULL directly when the input is NULL and avoid the
242930 : // dynamic_cast in this case. This is likely a performance improvement as well.
242931 : // return dynamic_cast<SgBoolValExp*>(inputDerivedClassPointer);
242932 : // Milind Chabbi (8/28/2013): isSgBoolValExp uses table-driven castability instead of c++ default dynamic_cast
242933 : // this improves the running time performance by 10-20%.
242934 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBoolValExp*>(inputDerivedClassPointer);
242935 22521 : return IS_SgBoolValExp_FAST_MACRO(inputDerivedClassPointer);
242936 : }
242937 :
242938 : // DQ (11/8/2003): Added version of functions taking const pointer
242939 9278 : const SgBoolValExp* isSgBoolValExp ( const SgNode* inputDerivedClassPointer )
242940 : {
242941 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
242942 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
242943 : // So to fix this we return NULL directly when the input is NULL and avoid the
242944 : // dynamic_cast in this case. This is likely a performance improvement as well.
242945 : // return dynamic_cast<const SgBoolValExp*>(inputDerivedClassPointer);
242946 : // Milind Chabbi (8/28/2013): isSgBoolValExp uses table-driven castability instead of c++ default dynamic_cast
242947 : // this improves the running time performance by 10-20%.
242948 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBoolValExp*>(inputDerivedClassPointer);
242949 9278 : return IS_SgBoolValExp_FAST_MACRO(inputDerivedClassPointer);
242950 : }
242951 :
242952 :
242953 :
242954 : /* #line 242955 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242955 :
242956 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
242957 :
242958 : /**
242959 : \brief Generated destructor
242960 :
242961 : This destructor is automatically generated (by ROSETTA). This destructor
242962 : only frees memory of data members associated with the parts of the current IR node which
242963 : are NOT traversed. Those data members that are part of a traversal can be freed using
242964 : a traversal (calling this destructor on all children in a post-order traversal). Such
242965 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
242966 :
242967 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
242968 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
242969 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
242970 :
242971 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
242972 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
242973 : pointers are not yet implemented to call delete on eash pointer in the container.
242974 : (This could be done by derivation from the STL containers to define containers that
242975 : automatically deleted their members.)
242976 :
242977 : */
242978 4136 : SgBoolValExp::~SgBoolValExp () {
242979 2068 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
242980 :
242981 :
242982 : // case: not a listType for value
242983 2068 : p_value = 0; // non list case
242984 :
242985 : }
242986 :
242987 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
242988 4136 : }
242989 :
242990 :
242991 : /* #line 242992 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
242992 :
242993 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
242994 :
242995 : // Generated constructor
242996 36 : SgBoolValExp::SgBoolValExp ( Sg_File_Info* startOfConstruct, int value )
242997 36 : : SgValueExp(startOfConstruct)
242998 : {
242999 : #ifdef DEBUG
243000 : // printf ("In SgBoolValExp::SgBoolValExp (Sg_File_Info* startOfConstruct, int value) sage_class_name() = %s \n",sage_class_name());
243001 : #endif
243002 : #if 0
243003 : // debugging information!
243004 : printf ("In SgBoolValExp::SgBoolValExp (Sg_File_Info* startOfConstruct, int value): this = %p = %s \n",this,this->class_name().c_str());
243005 : #endif
243006 :
243007 36 : p_value = value;
243008 :
243009 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
243010 :
243011 : #if 0
243012 : // DQ (7/30/2014): Call a virtual function.
243013 : std::string s = this->class_name();
243014 : #endif
243015 :
243016 : // Test the variant virtual function
243017 : // assert(BOOL_VAL == variant());
243018 36 : assert(BOOL_VAL == this->variant());
243019 36 : ROSE_ASSERT(BOOL_VAL == (int)(this->variantT()));
243020 36 : post_construction_initialization();
243021 :
243022 : // Test the isSgBoolValExp() function since it has been problematic
243023 36 : assert(isSgBoolValExp(this) != NULL);
243024 36 : }
243025 :
243026 : // Generated constructor (all data members)
243027 :
243028 : /* #line 243029 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243029 :
243030 :
243031 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
243032 :
243033 :
243034 : // ********************************************************
243035 : // member functions common across all array grammar objects
243036 : // ********************************************************
243037 :
243038 :
243039 :
243040 : /* #line 243041 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243041 :
243042 :
243043 :
243044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
243045 :
243046 : // ********************************************************
243047 : // member functions specific to each node in the grammar
243048 : // ********************************************************
243049 :
243050 :
243051 : /* #line 243052 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243052 :
243053 : // Start of memberFunctionString
243054 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243055 :
243056 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243057 :
243058 : std::string
243059 1661 : SgStringVal::get_value () const
243060 : {
243061 1661 : ROSE_ASSERT (this != NULL);
243062 :
243063 : #if 0
243064 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243065 : // used to trigger marking transformations for the token-based unparsing.
243066 : printf ("SgStringVal::get_value = %p = %s \n",this,this->class_name().c_str());
243067 : #endif
243068 :
243069 1661 : return p_value;
243070 : }
243071 :
243072 : void
243073 0 : SgStringVal::set_value ( std::string value )
243074 : {
243075 0 : ROSE_ASSERT (this != NULL);
243076 :
243077 : #if 0
243078 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243079 : // used to trigger marking transformations for the token-based unparsing.
243080 : printf ("SgStringVal::set_value = %p = %s \n",this,this->class_name().c_str());
243081 : #endif
243082 :
243083 0 : set_isModified(true);
243084 :
243085 0 : p_value = value;
243086 0 : }
243087 :
243088 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243089 :
243090 :
243091 : // End of memberFunctionString
243092 : // Start of memberFunctionString
243093 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243094 :
243095 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243096 :
243097 : bool
243098 631 : SgStringVal::get_wcharString () const
243099 : {
243100 631 : ROSE_ASSERT (this != NULL);
243101 :
243102 : #if 0
243103 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243104 : // used to trigger marking transformations for the token-based unparsing.
243105 : printf ("SgStringVal::get_wcharString = %p = %s \n",this,this->class_name().c_str());
243106 : #endif
243107 :
243108 631 : return p_wcharString;
243109 : }
243110 :
243111 : void
243112 72 : SgStringVal::set_wcharString ( bool wcharString )
243113 : {
243114 72 : ROSE_ASSERT (this != NULL);
243115 :
243116 : #if 0
243117 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243118 : // used to trigger marking transformations for the token-based unparsing.
243119 : printf ("SgStringVal::set_wcharString = %p = %s \n",this,this->class_name().c_str());
243120 : #endif
243121 :
243122 72 : set_isModified(true);
243123 :
243124 72 : p_wcharString = wcharString;
243125 72 : }
243126 :
243127 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243128 :
243129 :
243130 : // End of memberFunctionString
243131 : // Start of memberFunctionString
243132 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243133 :
243134 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243135 :
243136 : char
243137 93 : SgStringVal::get_stringDelimiter () const
243138 : {
243139 93 : ROSE_ASSERT (this != NULL);
243140 :
243141 : #if 0
243142 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243143 : // used to trigger marking transformations for the token-based unparsing.
243144 : printf ("SgStringVal::get_stringDelimiter = %p = %s \n",this,this->class_name().c_str());
243145 : #endif
243146 :
243147 93 : return p_stringDelimiter;
243148 : }
243149 :
243150 : void
243151 55 : SgStringVal::set_stringDelimiter ( char stringDelimiter )
243152 : {
243153 55 : ROSE_ASSERT (this != NULL);
243154 :
243155 : #if 0
243156 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243157 : // used to trigger marking transformations for the token-based unparsing.
243158 : printf ("SgStringVal::set_stringDelimiter = %p = %s \n",this,this->class_name().c_str());
243159 : #endif
243160 :
243161 55 : set_isModified(true);
243162 :
243163 55 : p_stringDelimiter = stringDelimiter;
243164 55 : }
243165 :
243166 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243167 :
243168 :
243169 : // End of memberFunctionString
243170 : // Start of memberFunctionString
243171 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243172 :
243173 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243174 :
243175 : bool
243176 631 : SgStringVal::get_is16bitString () const
243177 : {
243178 631 : ROSE_ASSERT (this != NULL);
243179 :
243180 : #if 0
243181 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243182 : // used to trigger marking transformations for the token-based unparsing.
243183 : printf ("SgStringVal::get_is16bitString = %p = %s \n",this,this->class_name().c_str());
243184 : #endif
243185 :
243186 631 : return p_is16bitString;
243187 : }
243188 :
243189 : void
243190 0 : SgStringVal::set_is16bitString ( bool is16bitString )
243191 : {
243192 0 : ROSE_ASSERT (this != NULL);
243193 :
243194 : #if 0
243195 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243196 : // used to trigger marking transformations for the token-based unparsing.
243197 : printf ("SgStringVal::set_is16bitString = %p = %s \n",this,this->class_name().c_str());
243198 : #endif
243199 :
243200 0 : set_isModified(true);
243201 :
243202 0 : p_is16bitString = is16bitString;
243203 0 : }
243204 :
243205 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243206 :
243207 :
243208 : // End of memberFunctionString
243209 : // Start of memberFunctionString
243210 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243211 :
243212 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243213 :
243214 : bool
243215 631 : SgStringVal::get_is32bitString () const
243216 : {
243217 631 : ROSE_ASSERT (this != NULL);
243218 :
243219 : #if 0
243220 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243221 : // used to trigger marking transformations for the token-based unparsing.
243222 : printf ("SgStringVal::get_is32bitString = %p = %s \n",this,this->class_name().c_str());
243223 : #endif
243224 :
243225 631 : return p_is32bitString;
243226 : }
243227 :
243228 : void
243229 72 : SgStringVal::set_is32bitString ( bool is32bitString )
243230 : {
243231 72 : ROSE_ASSERT (this != NULL);
243232 :
243233 : #if 0
243234 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243235 : // used to trigger marking transformations for the token-based unparsing.
243236 : printf ("SgStringVal::set_is32bitString = %p = %s \n",this,this->class_name().c_str());
243237 : #endif
243238 :
243239 72 : set_isModified(true);
243240 :
243241 72 : p_is32bitString = is32bitString;
243242 72 : }
243243 :
243244 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243245 :
243246 :
243247 : // End of memberFunctionString
243248 : // Start of memberFunctionString
243249 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243250 :
243251 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243252 :
243253 : bool
243254 631 : SgStringVal::get_isRawString () const
243255 : {
243256 631 : ROSE_ASSERT (this != NULL);
243257 :
243258 : #if 0
243259 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243260 : // used to trigger marking transformations for the token-based unparsing.
243261 : printf ("SgStringVal::get_isRawString = %p = %s \n",this,this->class_name().c_str());
243262 : #endif
243263 :
243264 631 : return p_isRawString;
243265 : }
243266 :
243267 : void
243268 0 : SgStringVal::set_isRawString ( bool isRawString )
243269 : {
243270 0 : ROSE_ASSERT (this != NULL);
243271 :
243272 : #if 0
243273 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243274 : // used to trigger marking transformations for the token-based unparsing.
243275 : printf ("SgStringVal::set_isRawString = %p = %s \n",this,this->class_name().c_str());
243276 : #endif
243277 :
243278 0 : set_isModified(true);
243279 :
243280 0 : p_isRawString = isRawString;
243281 0 : }
243282 :
243283 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243284 :
243285 :
243286 : // End of memberFunctionString
243287 : // Start of memberFunctionString
243288 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243289 :
243290 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243291 :
243292 : std::string
243293 0 : SgStringVal::get_raw_string_value () const
243294 : {
243295 0 : ROSE_ASSERT (this != NULL);
243296 :
243297 : #if 0
243298 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243299 : // used to trigger marking transformations for the token-based unparsing.
243300 : printf ("SgStringVal::get_raw_string_value = %p = %s \n",this,this->class_name().c_str());
243301 : #endif
243302 :
243303 0 : return p_raw_string_value;
243304 : }
243305 :
243306 : void
243307 0 : SgStringVal::set_raw_string_value ( std::string raw_string_value )
243308 : {
243309 0 : ROSE_ASSERT (this != NULL);
243310 :
243311 : #if 0
243312 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243313 : // used to trigger marking transformations for the token-based unparsing.
243314 : printf ("SgStringVal::set_raw_string_value = %p = %s \n",this,this->class_name().c_str());
243315 : #endif
243316 :
243317 0 : set_isModified(true);
243318 :
243319 0 : p_raw_string_value = raw_string_value;
243320 0 : }
243321 :
243322 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243323 :
243324 :
243325 : // End of memberFunctionString
243326 : // Start of memberFunctionString
243327 : /* #line 4011 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
243328 :
243329 :
243330 : void
243331 1600 : SgStringVal::post_construction_initialization()
243332 : {
243333 : // We can't initialize this to NULL since it might have just been set!
243334 : // p_value = (char*)0L;
243335 1600 : }
243336 :
243337 : #if 0
243338 : SgStringVal::SgStringVal ( Sg_File_Info* file_info, string value )
243339 : : SgValueExp(file_info)
243340 : {
243341 : // Build a custom constructor since we have to make a
243342 : // copy (using strdup(char*)) of the input string (value)
243343 :
243344 : // Copy the string (else it is lost and not represented in the unparsed output code)
243345 : // p_value = (value == 0)? 0 : strdup(value);
243346 : p_value = value;
243347 :
243348 : // Test the variant virtual function
243349 : assert(STRING_VAL == variant());
243350 : post_construction_initialization();
243351 :
243352 : // Test the isSgStringVal() function since it has been problematic
243353 : assert(isSgStringVal(this) != NULL);
243354 : }
243355 : #endif
243356 :
243357 : #if 0
243358 : SgStringVal::~SgStringVal()
243359 : {
243360 : // Delete the array of char (so use "delete []")
243361 : delete [] p_value;
243362 : p_value = NULL;
243363 : }
243364 : #endif
243365 :
243366 74 : void SgStringVal::set_usesSingleQuotes(bool usesSingleQuotes)
243367 : {
243368 74 : if (usesSingleQuotes)
243369 : {
243370 55 : set_stringDelimiter('\'');
243371 : }
243372 19 : else if (get_usesSingleQuotes())
243373 : {
243374 : // unset only if the current delimiter uses single quotes
243375 0 : set_stringDelimiter(0);
243376 : }
243377 74 : }
243378 :
243379 0 : void SgStringVal::set_usesDoubleQuotes(bool usesDoubleQuotes)
243380 : {
243381 0 : if (usesDoubleQuotes)
243382 : {
243383 0 : set_stringDelimiter('"');
243384 : }
243385 0 : else if (get_usesDoubleQuotes())
243386 : {
243387 : // unset only if the current delimiter uses double quotes
243388 0 : set_stringDelimiter(0);
243389 : }
243390 0 : }
243391 :
243392 :
243393 :
243394 : // End of memberFunctionString
243395 : // Start of memberFunctionString
243396 : /* #line 8374 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
243397 :
243398 :
243399 : SgType*
243400 169 : SgStringVal::get_type(void) const
243401 : {
243402 : #if 0
243403 : printf ("In SgStringVal::get_type() \n");
243404 : #endif
243405 :
243406 : // Since this is a literal, it must have a defined size (even if it is length zero).
243407 169 : size_t stringSize = get_value().size();
243408 :
243409 : #if 0
243410 : // Debugging...
243411 : if (stringSize == 0)
243412 : {
243413 : printf ("SgStringVal::get_type(): string generated an empty string type -- get_value() = %s \n",get_value().c_str());
243414 : }
243415 : #endif
243416 :
243417 : // DQ (10/5/2010): Modified to used new API (only lengthExpression is supported).
243418 : // Use the literal size and assume that there is no associated expression.
243419 : // return SgTypeString::createType(NULL,stringSize);
243420 169 : Sg_File_Info* fileInfo = Sg_File_Info::generateDefaultFileInfoForCompilerGeneratedNode();
243421 169 : SgIntVal* lengthExpression = new SgIntVal(fileInfo,(int)stringSize,"");
243422 169 : ROSE_ASSERT(lengthExpression != NULL);
243423 169 : return SgTypeString::createType(lengthExpression);
243424 : }
243425 :
243426 :
243427 :
243428 : // End of memberFunctionString
243429 : // Start of memberFunctionString
243430 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
243431 :
243432 : // *** COMMON CODE SECTION BEGINS HERE ***
243433 :
243434 : #if 0
243435 : int
243436 : SgStringVal::getVariant() const
243437 : {
243438 : // This function is used in ROSE while "variant()" is used in SAGE
243439 : assert(this != NULL);
243440 : return variant();
243441 : }
243442 : #endif
243443 :
243444 : // This function is used in ROSE in treeTraversal code
243445 : // eventually replaces getVariant() and variant()
243446 : // though after variant() has been removed for a while we will
243447 : // want to change the name of variantT() back to variant()
243448 : // (since the "T" was ment to stand for temporary).
243449 : // When this happens the variantT() will be depricated.
243450 : VariantT
243451 317357 : SgStringVal::variantT() const
243452 : {
243453 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
243454 317357 : ROSE_ASSERT(this != NULL);
243455 317357 : return V_SgStringVal;
243456 : }
243457 :
243458 : #if 0
243459 : int
243460 : SgStringVal::variant() const
243461 : {
243462 : // This function is used in SAGE
243463 : ROSE_ASSERT(this != NULL);
243464 : return STRING_VAL;
243465 : }
243466 : #endif
243467 :
243468 : ROSE_DLL_API const char*
243469 194 : SgStringVal::sage_class_name() const
243470 : {
243471 194 : ROSE_ASSERT(this != NULL);
243472 194 : return "SgStringVal";
243473 : }
243474 :
243475 : std::string
243476 1295 : SgStringVal::class_name() const
243477 : {
243478 1295 : ROSE_ASSERT(this != NULL);
243479 1295 : return "SgStringVal";
243480 : }
243481 :
243482 : // DQ (11/26/2005): Support for visitor pattern mechanims
243483 : // (inferior to ROSE traversal mechanism, experimental).
243484 : void
243485 11595 : SgStringVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
243486 : {
243487 11595 : ROSE_ASSERT(this != NULL);
243488 11595 : visitor.visit(this);
243489 11595 : }
243490 :
243491 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
243492 0 : void SgStringVal::accept (ROSE_VisitorPattern & visitor) {
243493 0 : ROSE_ASSERT(this != NULL);
243494 0 : visitor.visit(this);
243495 0 : }
243496 :
243497 : SgStringVal*
243498 0 : SgStringVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
243499 : {
243500 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
243501 : // This function is currently only supported for the AST used the represent Binary executables.
243502 : if (0 /* isSgAsmNode(this) != NULL */)
243503 : {
243504 : // Support for regex specification.
243505 : std::string prefixCode = "REGEX:";
243506 : addNewAttribute(prefixCode + s,a);
243507 : }
243508 : #endif
243509 :
243510 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
243511 0 : return this;
243512 : }
243513 :
243514 : // *** COMMON CODE SECTION ENDS HERE ***
243515 :
243516 :
243517 : // End of memberFunctionString
243518 : // Start of memberFunctionString
243519 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
243520 :
243521 :
243522 : #if 0
243523 : //! Error checking support
243524 : /*! Verifies the following:
243525 : - working getVariant() member function
243526 : - calls base class's error() member function
243527 : Every class has one of these functions.
243528 : */
243529 : bool
243530 : SgStringVal::error()
243531 : {
243532 : // Put error checking here
243533 :
243534 : ROSE_ASSERT (this != NULL);
243535 : if (getVariant() != STRING_VAL)
243536 : {
243537 : printf ("Error in SgStringVal::error(): SgStringVal object has a %s variant \n",
243538 : Cxx_GrammarTerminalNames[getVariant()].name);
243539 : // printf ("Error in SgStringVal::error() \n");
243540 : ROSE_ABORT();
243541 : }
243542 :
243543 : ROSE_ASSERT (getVariant() == STRING_VAL);
243544 : return SgValueExp::error();
243545 : }
243546 : #endif
243547 :
243548 :
243549 :
243550 : // End of memberFunctionString
243551 :
243552 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
243553 :
243554 5469860 : SgStringVal* isSgStringVal ( SgNode* inputDerivedClassPointer )
243555 : {
243556 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
243557 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
243558 : // So to fix this we return NULL directly when the input is NULL and avoid the
243559 : // dynamic_cast in this case. This is likely a performance improvement as well.
243560 : // return dynamic_cast<SgStringVal*>(inputDerivedClassPointer);
243561 : // Milind Chabbi (8/28/2013): isSgStringVal uses table-driven castability instead of c++ default dynamic_cast
243562 : // this improves the running time performance by 10-20%.
243563 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStringVal*>(inputDerivedClassPointer);
243564 5469860 : return IS_SgStringVal_FAST_MACRO(inputDerivedClassPointer);
243565 : }
243566 :
243567 : // DQ (11/8/2003): Added version of functions taking const pointer
243568 0 : const SgStringVal* isSgStringVal ( const SgNode* inputDerivedClassPointer )
243569 : {
243570 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
243571 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
243572 : // So to fix this we return NULL directly when the input is NULL and avoid the
243573 : // dynamic_cast in this case. This is likely a performance improvement as well.
243574 : // return dynamic_cast<const SgStringVal*>(inputDerivedClassPointer);
243575 : // Milind Chabbi (8/28/2013): isSgStringVal uses table-driven castability instead of c++ default dynamic_cast
243576 : // this improves the running time performance by 10-20%.
243577 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStringVal*>(inputDerivedClassPointer);
243578 0 : return IS_SgStringVal_FAST_MACRO(inputDerivedClassPointer);
243579 : }
243580 :
243581 :
243582 :
243583 : /* #line 243584 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243584 :
243585 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
243586 :
243587 : /**
243588 : \brief Generated destructor
243589 :
243590 : This destructor is automatically generated (by ROSETTA). This destructor
243591 : only frees memory of data members associated with the parts of the current IR node which
243592 : are NOT traversed. Those data members that are part of a traversal can be freed using
243593 : a traversal (calling this destructor on all children in a post-order traversal). Such
243594 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
243595 :
243596 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
243597 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
243598 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
243599 :
243600 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
243601 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
243602 : pointers are not yet implemented to call delete on eash pointer in the container.
243603 : (This could be done by derivation from the STL containers to define containers that
243604 : automatically deleted their members.)
243605 :
243606 : */
243607 1012 : SgStringVal::~SgStringVal () {
243608 368 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
243609 :
243610 :
243611 : // case: not a listType for value
243612 368 : p_value = ""; // non list case
243613 : // case: not a listType for wcharString
243614 368 : p_wcharString = false; // non list case
243615 : // case: not a listType for stringDelimiter
243616 368 : p_stringDelimiter = 0; // non list case
243617 : // case: not a listType for is16bitString
243618 368 : p_is16bitString = false; // non list case
243619 : // case: not a listType for is32bitString
243620 368 : p_is32bitString = false; // non list case
243621 : // case: not a listType for isRawString
243622 368 : p_isRawString = false; // non list case
243623 : // case: not a listType for raw_string_value
243624 368 : p_raw_string_value = ""; // non list case
243625 :
243626 : }
243627 :
243628 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
243629 736 : }
243630 :
243631 :
243632 : /* #line 243633 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243633 :
243634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
243635 :
243636 : // Generated constructor
243637 8 : SgStringVal::SgStringVal ( Sg_File_Info* startOfConstruct, std::string value )
243638 8 : : SgValueExp(startOfConstruct)
243639 : {
243640 : #ifdef DEBUG
243641 : // printf ("In SgStringVal::SgStringVal (Sg_File_Info* startOfConstruct, std::string value) sage_class_name() = %s \n",sage_class_name());
243642 : #endif
243643 : #if 0
243644 : // debugging information!
243645 : printf ("In SgStringVal::SgStringVal (Sg_File_Info* startOfConstruct, std::string value): this = %p = %s \n",this,this->class_name().c_str());
243646 : #endif
243647 :
243648 8 : p_value = value;
243649 8 : p_wcharString = false;
243650 8 : p_stringDelimiter = 0;
243651 8 : p_is16bitString = false;
243652 8 : p_is32bitString = false;
243653 8 : p_isRawString = false;
243654 8 : p_raw_string_value = "";
243655 :
243656 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
243657 :
243658 : #if 0
243659 : // DQ (7/30/2014): Call a virtual function.
243660 : std::string s = this->class_name();
243661 : #endif
243662 :
243663 : // Test the variant virtual function
243664 : // assert(STRING_VAL == variant());
243665 8 : assert(STRING_VAL == this->variant());
243666 8 : ROSE_ASSERT(STRING_VAL == (int)(this->variantT()));
243667 8 : post_construction_initialization();
243668 :
243669 : // Test the isSgStringVal() function since it has been problematic
243670 8 : assert(isSgStringVal(this) != NULL);
243671 8 : }
243672 :
243673 : // Generated constructor (all data members)
243674 :
243675 : /* #line 243676 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243676 :
243677 :
243678 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
243679 :
243680 :
243681 : // ********************************************************
243682 : // member functions common across all array grammar objects
243683 : // ********************************************************
243684 :
243685 :
243686 :
243687 : /* #line 243688 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243688 :
243689 :
243690 :
243691 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
243692 :
243693 : // ********************************************************
243694 : // member functions specific to each node in the grammar
243695 : // ********************************************************
243696 :
243697 :
243698 : /* #line 243699 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243699 :
243700 : // Start of memberFunctionString
243701 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
243702 :
243703 : void
243704 35 : SgShortVal::post_construction_initialization()
243705 : {
243706 35 : }
243707 :
243708 :
243709 :
243710 : // End of memberFunctionString
243711 : // Start of memberFunctionString
243712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243713 :
243714 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243715 :
243716 : short
243717 1 : SgShortVal::get_value () const
243718 : {
243719 1 : ROSE_ASSERT (this != NULL);
243720 :
243721 : #if 0
243722 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243723 : // used to trigger marking transformations for the token-based unparsing.
243724 : printf ("SgShortVal::get_value = %p = %s \n",this,this->class_name().c_str());
243725 : #endif
243726 :
243727 1 : return p_value;
243728 : }
243729 :
243730 : void
243731 0 : SgShortVal::set_value ( short value )
243732 : {
243733 0 : ROSE_ASSERT (this != NULL);
243734 :
243735 : #if 0
243736 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243737 : // used to trigger marking transformations for the token-based unparsing.
243738 : printf ("SgShortVal::set_value = %p = %s \n",this,this->class_name().c_str());
243739 : #endif
243740 :
243741 0 : set_isModified(true);
243742 :
243743 0 : p_value = value;
243744 0 : }
243745 :
243746 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243747 :
243748 :
243749 : // End of memberFunctionString
243750 : // Start of memberFunctionString
243751 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
243752 :
243753 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
243754 :
243755 : std::string
243756 3 : SgShortVal::get_valueString () const
243757 : {
243758 3 : ROSE_ASSERT (this != NULL);
243759 :
243760 : #if 0
243761 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243762 : // used to trigger marking transformations for the token-based unparsing.
243763 : printf ("SgShortVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
243764 : #endif
243765 :
243766 3 : return p_valueString;
243767 : }
243768 :
243769 : void
243770 0 : SgShortVal::set_valueString ( std::string valueString )
243771 : {
243772 0 : ROSE_ASSERT (this != NULL);
243773 :
243774 : #if 0
243775 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
243776 : // used to trigger marking transformations for the token-based unparsing.
243777 : printf ("SgShortVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
243778 : #endif
243779 :
243780 0 : set_isModified(true);
243781 :
243782 0 : p_valueString = valueString;
243783 0 : }
243784 :
243785 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
243786 :
243787 :
243788 : // End of memberFunctionString
243789 : // Start of memberFunctionString
243790 : /* #line 4078 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
243791 :
243792 :
243793 :
243794 : // End of memberFunctionString
243795 : // Start of memberFunctionString
243796 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
243797 :
243798 :
243799 : SgType*
243800 2 : SgShortVal::get_type(void) const
243801 : {
243802 : #if 0
243803 : printf ("In SgShortVal::get_type() \n");
243804 : #endif
243805 :
243806 2 : return SgTypeShort::createType();
243807 : }
243808 :
243809 :
243810 :
243811 : // End of memberFunctionString
243812 : // Start of memberFunctionString
243813 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
243814 :
243815 : // *** COMMON CODE SECTION BEGINS HERE ***
243816 :
243817 : #if 0
243818 : int
243819 : SgShortVal::getVariant() const
243820 : {
243821 : // This function is used in ROSE while "variant()" is used in SAGE
243822 : assert(this != NULL);
243823 : return variant();
243824 : }
243825 : #endif
243826 :
243827 : // This function is used in ROSE in treeTraversal code
243828 : // eventually replaces getVariant() and variant()
243829 : // though after variant() has been removed for a while we will
243830 : // want to change the name of variantT() back to variant()
243831 : // (since the "T" was ment to stand for temporary).
243832 : // When this happens the variantT() will be depricated.
243833 : VariantT
243834 2108 : SgShortVal::variantT() const
243835 : {
243836 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
243837 2108 : ROSE_ASSERT(this != NULL);
243838 2108 : return V_SgShortVal;
243839 : }
243840 :
243841 : #if 0
243842 : int
243843 : SgShortVal::variant() const
243844 : {
243845 : // This function is used in SAGE
243846 : ROSE_ASSERT(this != NULL);
243847 : return SHORT_VAL;
243848 : }
243849 : #endif
243850 :
243851 : ROSE_DLL_API const char*
243852 0 : SgShortVal::sage_class_name() const
243853 : {
243854 0 : ROSE_ASSERT(this != NULL);
243855 0 : return "SgShortVal";
243856 : }
243857 :
243858 : std::string
243859 2 : SgShortVal::class_name() const
243860 : {
243861 2 : ROSE_ASSERT(this != NULL);
243862 2 : return "SgShortVal";
243863 : }
243864 :
243865 : // DQ (11/26/2005): Support for visitor pattern mechanims
243866 : // (inferior to ROSE traversal mechanism, experimental).
243867 : void
243868 0 : SgShortVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
243869 : {
243870 0 : ROSE_ASSERT(this != NULL);
243871 0 : visitor.visit(this);
243872 0 : }
243873 :
243874 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
243875 0 : void SgShortVal::accept (ROSE_VisitorPattern & visitor) {
243876 0 : ROSE_ASSERT(this != NULL);
243877 0 : visitor.visit(this);
243878 0 : }
243879 :
243880 : SgShortVal*
243881 0 : SgShortVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
243882 : {
243883 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
243884 : // This function is currently only supported for the AST used the represent Binary executables.
243885 : if (0 /* isSgAsmNode(this) != NULL */)
243886 : {
243887 : // Support for regex specification.
243888 : std::string prefixCode = "REGEX:";
243889 : addNewAttribute(prefixCode + s,a);
243890 : }
243891 : #endif
243892 :
243893 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
243894 0 : return this;
243895 : }
243896 :
243897 : // *** COMMON CODE SECTION ENDS HERE ***
243898 :
243899 :
243900 : // End of memberFunctionString
243901 : // Start of memberFunctionString
243902 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
243903 :
243904 :
243905 : #if 0
243906 : //! Error checking support
243907 : /*! Verifies the following:
243908 : - working getVariant() member function
243909 : - calls base class's error() member function
243910 : Every class has one of these functions.
243911 : */
243912 : bool
243913 : SgShortVal::error()
243914 : {
243915 : // Put error checking here
243916 :
243917 : ROSE_ASSERT (this != NULL);
243918 : if (getVariant() != SHORT_VAL)
243919 : {
243920 : printf ("Error in SgShortVal::error(): SgShortVal object has a %s variant \n",
243921 : Cxx_GrammarTerminalNames[getVariant()].name);
243922 : // printf ("Error in SgShortVal::error() \n");
243923 : ROSE_ABORT();
243924 : }
243925 :
243926 : ROSE_ASSERT (getVariant() == SHORT_VAL);
243927 : return SgValueExp::error();
243928 : }
243929 : #endif
243930 :
243931 :
243932 :
243933 : // End of memberFunctionString
243934 :
243935 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
243936 :
243937 50814 : SgShortVal* isSgShortVal ( SgNode* inputDerivedClassPointer )
243938 : {
243939 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
243940 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
243941 : // So to fix this we return NULL directly when the input is NULL and avoid the
243942 : // dynamic_cast in this case. This is likely a performance improvement as well.
243943 : // return dynamic_cast<SgShortVal*>(inputDerivedClassPointer);
243944 : // Milind Chabbi (8/28/2013): isSgShortVal uses table-driven castability instead of c++ default dynamic_cast
243945 : // this improves the running time performance by 10-20%.
243946 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgShortVal*>(inputDerivedClassPointer);
243947 50814 : return IS_SgShortVal_FAST_MACRO(inputDerivedClassPointer);
243948 : }
243949 :
243950 : // DQ (11/8/2003): Added version of functions taking const pointer
243951 0 : const SgShortVal* isSgShortVal ( const SgNode* inputDerivedClassPointer )
243952 : {
243953 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
243954 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
243955 : // So to fix this we return NULL directly when the input is NULL and avoid the
243956 : // dynamic_cast in this case. This is likely a performance improvement as well.
243957 : // return dynamic_cast<const SgShortVal*>(inputDerivedClassPointer);
243958 : // Milind Chabbi (8/28/2013): isSgShortVal uses table-driven castability instead of c++ default dynamic_cast
243959 : // this improves the running time performance by 10-20%.
243960 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgShortVal*>(inputDerivedClassPointer);
243961 0 : return IS_SgShortVal_FAST_MACRO(inputDerivedClassPointer);
243962 : }
243963 :
243964 :
243965 :
243966 : /* #line 243967 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
243967 :
243968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
243969 :
243970 : /**
243971 : \brief Generated destructor
243972 :
243973 : This destructor is automatically generated (by ROSETTA). This destructor
243974 : only frees memory of data members associated with the parts of the current IR node which
243975 : are NOT traversed. Those data members that are part of a traversal can be freed using
243976 : a traversal (calling this destructor on all children in a post-order traversal). Such
243977 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
243978 :
243979 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
243980 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
243981 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
243982 :
243983 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
243984 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
243985 : pointers are not yet implemented to call delete on eash pointer in the container.
243986 : (This could be done by derivation from the STL containers to define containers that
243987 : automatically deleted their members.)
243988 :
243989 : */
243990 66 : SgShortVal::~SgShortVal () {
243991 33 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
243992 :
243993 :
243994 : // case: not a listType for value
243995 33 : p_value = 0; // non list case
243996 : // case: not a listType for valueString
243997 33 : p_valueString = ""; // non list case
243998 :
243999 : }
244000 :
244001 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
244002 66 : }
244003 :
244004 :
244005 : /* #line 244006 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244006 :
244007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
244008 :
244009 : // Generated constructor
244010 0 : SgShortVal::SgShortVal ( Sg_File_Info* startOfConstruct, short value, std::string valueString )
244011 0 : : SgValueExp(startOfConstruct)
244012 : {
244013 : #ifdef DEBUG
244014 : // printf ("In SgShortVal::SgShortVal (Sg_File_Info* startOfConstruct, short value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
244015 : #endif
244016 : #if 0
244017 : // debugging information!
244018 : printf ("In SgShortVal::SgShortVal (Sg_File_Info* startOfConstruct, short value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
244019 : #endif
244020 :
244021 0 : p_value = value;
244022 0 : p_valueString = valueString;
244023 :
244024 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
244025 :
244026 : #if 0
244027 : // DQ (7/30/2014): Call a virtual function.
244028 : std::string s = this->class_name();
244029 : #endif
244030 :
244031 : // Test the variant virtual function
244032 : // assert(SHORT_VAL == variant());
244033 0 : assert(SHORT_VAL == this->variant());
244034 0 : ROSE_ASSERT(SHORT_VAL == (int)(this->variantT()));
244035 0 : post_construction_initialization();
244036 :
244037 : // Test the isSgShortVal() function since it has been problematic
244038 0 : assert(isSgShortVal(this) != NULL);
244039 0 : }
244040 :
244041 : // Generated constructor (all data members)
244042 :
244043 : /* #line 244044 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244044 :
244045 :
244046 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
244047 :
244048 :
244049 : // ********************************************************
244050 : // member functions common across all array grammar objects
244051 : // ********************************************************
244052 :
244053 :
244054 :
244055 : /* #line 244056 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244056 :
244057 :
244058 :
244059 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
244060 :
244061 : // ********************************************************
244062 : // member functions specific to each node in the grammar
244063 : // ********************************************************
244064 :
244065 :
244066 : /* #line 244067 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244067 :
244068 : // Start of memberFunctionString
244069 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244070 :
244071 : void
244072 444 : SgCharVal::post_construction_initialization()
244073 : {
244074 444 : }
244075 :
244076 :
244077 :
244078 : // End of memberFunctionString
244079 : // Start of memberFunctionString
244080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
244081 :
244082 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
244083 :
244084 : char
244085 87 : SgCharVal::get_value () const
244086 : {
244087 87 : ROSE_ASSERT (this != NULL);
244088 :
244089 : #if 0
244090 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244091 : // used to trigger marking transformations for the token-based unparsing.
244092 : printf ("SgCharVal::get_value = %p = %s \n",this,this->class_name().c_str());
244093 : #endif
244094 :
244095 87 : return p_value;
244096 : }
244097 :
244098 : void
244099 0 : SgCharVal::set_value ( char value )
244100 : {
244101 0 : ROSE_ASSERT (this != NULL);
244102 :
244103 : #if 0
244104 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244105 : // used to trigger marking transformations for the token-based unparsing.
244106 : printf ("SgCharVal::set_value = %p = %s \n",this,this->class_name().c_str());
244107 : #endif
244108 :
244109 0 : set_isModified(true);
244110 :
244111 0 : p_value = value;
244112 0 : }
244113 :
244114 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
244115 :
244116 :
244117 : // End of memberFunctionString
244118 : // Start of memberFunctionString
244119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
244120 :
244121 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
244122 :
244123 : std::string
244124 4 : SgCharVal::get_valueString () const
244125 : {
244126 4 : ROSE_ASSERT (this != NULL);
244127 :
244128 : #if 0
244129 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244130 : // used to trigger marking transformations for the token-based unparsing.
244131 : printf ("SgCharVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
244132 : #endif
244133 :
244134 4 : return p_valueString;
244135 : }
244136 :
244137 : void
244138 0 : SgCharVal::set_valueString ( std::string valueString )
244139 : {
244140 0 : ROSE_ASSERT (this != NULL);
244141 :
244142 : #if 0
244143 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244144 : // used to trigger marking transformations for the token-based unparsing.
244145 : printf ("SgCharVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
244146 : #endif
244147 :
244148 0 : set_isModified(true);
244149 :
244150 0 : p_valueString = valueString;
244151 0 : }
244152 :
244153 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
244154 :
244155 :
244156 : // End of memberFunctionString
244157 : // Start of memberFunctionString
244158 : /* #line 4082 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244159 :
244160 :
244161 :
244162 : // End of memberFunctionString
244163 : // Start of memberFunctionString
244164 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244165 :
244166 :
244167 : SgType*
244168 444 : SgCharVal::get_type(void) const
244169 : {
244170 : #if 0
244171 : printf ("In SgCharVal::get_type() \n");
244172 : #endif
244173 :
244174 444 : return SgTypeChar::createType();
244175 : }
244176 :
244177 :
244178 :
244179 : // End of memberFunctionString
244180 : // Start of memberFunctionString
244181 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
244182 :
244183 : // *** COMMON CODE SECTION BEGINS HERE ***
244184 :
244185 : #if 0
244186 : int
244187 : SgCharVal::getVariant() const
244188 : {
244189 : // This function is used in ROSE while "variant()" is used in SAGE
244190 : assert(this != NULL);
244191 : return variant();
244192 : }
244193 : #endif
244194 :
244195 : // This function is used in ROSE in treeTraversal code
244196 : // eventually replaces getVariant() and variant()
244197 : // though after variant() has been removed for a while we will
244198 : // want to change the name of variantT() back to variant()
244199 : // (since the "T" was ment to stand for temporary).
244200 : // When this happens the variantT() will be depricated.
244201 : VariantT
244202 112645 : SgCharVal::variantT() const
244203 : {
244204 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
244205 112645 : ROSE_ASSERT(this != NULL);
244206 112645 : return V_SgCharVal;
244207 : }
244208 :
244209 : #if 0
244210 : int
244211 : SgCharVal::variant() const
244212 : {
244213 : // This function is used in SAGE
244214 : ROSE_ASSERT(this != NULL);
244215 : return CHAR_VAL;
244216 : }
244217 : #endif
244218 :
244219 : ROSE_DLL_API const char*
244220 6 : SgCharVal::sage_class_name() const
244221 : {
244222 6 : ROSE_ASSERT(this != NULL);
244223 6 : return "SgCharVal";
244224 : }
244225 :
244226 : std::string
244227 369 : SgCharVal::class_name() const
244228 : {
244229 369 : ROSE_ASSERT(this != NULL);
244230 369 : return "SgCharVal";
244231 : }
244232 :
244233 : // DQ (11/26/2005): Support for visitor pattern mechanims
244234 : // (inferior to ROSE traversal mechanism, experimental).
244235 : void
244236 6496 : SgCharVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
244237 : {
244238 6496 : ROSE_ASSERT(this != NULL);
244239 6496 : visitor.visit(this);
244240 6496 : }
244241 :
244242 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
244243 0 : void SgCharVal::accept (ROSE_VisitorPattern & visitor) {
244244 0 : ROSE_ASSERT(this != NULL);
244245 0 : visitor.visit(this);
244246 0 : }
244247 :
244248 : SgCharVal*
244249 0 : SgCharVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
244250 : {
244251 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
244252 : // This function is currently only supported for the AST used the represent Binary executables.
244253 : if (0 /* isSgAsmNode(this) != NULL */)
244254 : {
244255 : // Support for regex specification.
244256 : std::string prefixCode = "REGEX:";
244257 : addNewAttribute(prefixCode + s,a);
244258 : }
244259 : #endif
244260 :
244261 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
244262 0 : return this;
244263 : }
244264 :
244265 : // *** COMMON CODE SECTION ENDS HERE ***
244266 :
244267 :
244268 : // End of memberFunctionString
244269 : // Start of memberFunctionString
244270 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
244271 :
244272 :
244273 : #if 0
244274 : //! Error checking support
244275 : /*! Verifies the following:
244276 : - working getVariant() member function
244277 : - calls base class's error() member function
244278 : Every class has one of these functions.
244279 : */
244280 : bool
244281 : SgCharVal::error()
244282 : {
244283 : // Put error checking here
244284 :
244285 : ROSE_ASSERT (this != NULL);
244286 : if (getVariant() != CHAR_VAL)
244287 : {
244288 : printf ("Error in SgCharVal::error(): SgCharVal object has a %s variant \n",
244289 : Cxx_GrammarTerminalNames[getVariant()].name);
244290 : // printf ("Error in SgCharVal::error() \n");
244291 : ROSE_ABORT();
244292 : }
244293 :
244294 : ROSE_ASSERT (getVariant() == CHAR_VAL);
244295 : return SgValueExp::error();
244296 : }
244297 : #endif
244298 :
244299 :
244300 :
244301 : // End of memberFunctionString
244302 :
244303 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
244304 :
244305 51285 : SgCharVal* isSgCharVal ( SgNode* inputDerivedClassPointer )
244306 : {
244307 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
244308 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
244309 : // So to fix this we return NULL directly when the input is NULL and avoid the
244310 : // dynamic_cast in this case. This is likely a performance improvement as well.
244311 : // return dynamic_cast<SgCharVal*>(inputDerivedClassPointer);
244312 : // Milind Chabbi (8/28/2013): isSgCharVal uses table-driven castability instead of c++ default dynamic_cast
244313 : // this improves the running time performance by 10-20%.
244314 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCharVal*>(inputDerivedClassPointer);
244315 51285 : return IS_SgCharVal_FAST_MACRO(inputDerivedClassPointer);
244316 : }
244317 :
244318 : // DQ (11/8/2003): Added version of functions taking const pointer
244319 0 : const SgCharVal* isSgCharVal ( const SgNode* inputDerivedClassPointer )
244320 : {
244321 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
244322 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
244323 : // So to fix this we return NULL directly when the input is NULL and avoid the
244324 : // dynamic_cast in this case. This is likely a performance improvement as well.
244325 : // return dynamic_cast<const SgCharVal*>(inputDerivedClassPointer);
244326 : // Milind Chabbi (8/28/2013): isSgCharVal uses table-driven castability instead of c++ default dynamic_cast
244327 : // this improves the running time performance by 10-20%.
244328 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCharVal*>(inputDerivedClassPointer);
244329 0 : return IS_SgCharVal_FAST_MACRO(inputDerivedClassPointer);
244330 : }
244331 :
244332 :
244333 :
244334 : /* #line 244335 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244335 :
244336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
244337 :
244338 : /**
244339 : \brief Generated destructor
244340 :
244341 : This destructor is automatically generated (by ROSETTA). This destructor
244342 : only frees memory of data members associated with the parts of the current IR node which
244343 : are NOT traversed. Those data members that are part of a traversal can be freed using
244344 : a traversal (calling this destructor on all children in a post-order traversal). Such
244345 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
244346 :
244347 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
244348 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
244349 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
244350 :
244351 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
244352 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
244353 : pointers are not yet implemented to call delete on eash pointer in the container.
244354 : (This could be done by derivation from the STL containers to define containers that
244355 : automatically deleted their members.)
244356 :
244357 : */
244358 242 : SgCharVal::~SgCharVal () {
244359 121 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
244360 :
244361 :
244362 : // case: not a listType for value
244363 121 : p_value = 0; // non list case
244364 : // case: not a listType for valueString
244365 121 : p_valueString = ""; // non list case
244366 :
244367 : }
244368 :
244369 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
244370 242 : }
244371 :
244372 :
244373 : /* #line 244374 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244374 :
244375 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
244376 :
244377 : // Generated constructor
244378 38 : SgCharVal::SgCharVal ( Sg_File_Info* startOfConstruct, char value, std::string valueString )
244379 38 : : SgValueExp(startOfConstruct)
244380 : {
244381 : #ifdef DEBUG
244382 : // printf ("In SgCharVal::SgCharVal (Sg_File_Info* startOfConstruct, char value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
244383 : #endif
244384 : #if 0
244385 : // debugging information!
244386 : printf ("In SgCharVal::SgCharVal (Sg_File_Info* startOfConstruct, char value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
244387 : #endif
244388 :
244389 38 : p_value = value;
244390 38 : p_valueString = valueString;
244391 :
244392 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
244393 :
244394 : #if 0
244395 : // DQ (7/30/2014): Call a virtual function.
244396 : std::string s = this->class_name();
244397 : #endif
244398 :
244399 : // Test the variant virtual function
244400 : // assert(CHAR_VAL == variant());
244401 38 : assert(CHAR_VAL == this->variant());
244402 38 : ROSE_ASSERT(CHAR_VAL == (int)(this->variantT()));
244403 38 : post_construction_initialization();
244404 :
244405 : // Test the isSgCharVal() function since it has been problematic
244406 38 : assert(isSgCharVal(this) != NULL);
244407 38 : }
244408 :
244409 : // Generated constructor (all data members)
244410 :
244411 : /* #line 244412 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244412 :
244413 :
244414 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
244415 :
244416 :
244417 : // ********************************************************
244418 : // member functions common across all array grammar objects
244419 : // ********************************************************
244420 :
244421 :
244422 :
244423 : /* #line 244424 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244424 :
244425 :
244426 :
244427 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
244428 :
244429 : // ********************************************************
244430 : // member functions specific to each node in the grammar
244431 : // ********************************************************
244432 :
244433 :
244434 : /* #line 244435 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244435 :
244436 : // Start of memberFunctionString
244437 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244438 :
244439 : void
244440 2 : SgUnsignedCharVal::post_construction_initialization()
244441 : {
244442 2 : }
244443 :
244444 :
244445 :
244446 : // End of memberFunctionString
244447 : // Start of memberFunctionString
244448 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
244449 :
244450 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
244451 :
244452 : unsigned char
244453 1 : SgUnsignedCharVal::get_value () const
244454 : {
244455 1 : ROSE_ASSERT (this != NULL);
244456 :
244457 : #if 0
244458 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244459 : // used to trigger marking transformations for the token-based unparsing.
244460 : printf ("SgUnsignedCharVal::get_value = %p = %s \n",this,this->class_name().c_str());
244461 : #endif
244462 :
244463 1 : return p_value;
244464 : }
244465 :
244466 : void
244467 0 : SgUnsignedCharVal::set_value ( unsigned char value )
244468 : {
244469 0 : ROSE_ASSERT (this != NULL);
244470 :
244471 : #if 0
244472 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244473 : // used to trigger marking transformations for the token-based unparsing.
244474 : printf ("SgUnsignedCharVal::set_value = %p = %s \n",this,this->class_name().c_str());
244475 : #endif
244476 :
244477 0 : set_isModified(true);
244478 :
244479 0 : p_value = value;
244480 0 : }
244481 :
244482 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
244483 :
244484 :
244485 : // End of memberFunctionString
244486 : // Start of memberFunctionString
244487 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
244488 :
244489 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
244490 :
244491 : std::string
244492 3 : SgUnsignedCharVal::get_valueString () const
244493 : {
244494 3 : ROSE_ASSERT (this != NULL);
244495 :
244496 : #if 0
244497 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244498 : // used to trigger marking transformations for the token-based unparsing.
244499 : printf ("SgUnsignedCharVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
244500 : #endif
244501 :
244502 3 : return p_valueString;
244503 : }
244504 :
244505 : void
244506 0 : SgUnsignedCharVal::set_valueString ( std::string valueString )
244507 : {
244508 0 : ROSE_ASSERT (this != NULL);
244509 :
244510 : #if 0
244511 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244512 : // used to trigger marking transformations for the token-based unparsing.
244513 : printf ("SgUnsignedCharVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
244514 : #endif
244515 :
244516 0 : set_isModified(true);
244517 :
244518 0 : p_valueString = valueString;
244519 0 : }
244520 :
244521 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
244522 :
244523 :
244524 : // End of memberFunctionString
244525 : // Start of memberFunctionString
244526 : /* #line 4086 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244527 :
244528 :
244529 :
244530 : // End of memberFunctionString
244531 : // Start of memberFunctionString
244532 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244533 :
244534 :
244535 : SgType*
244536 2 : SgUnsignedCharVal::get_type(void) const
244537 : {
244538 : #if 0
244539 : printf ("In SgUnsignedCharVal::get_type() \n");
244540 : #endif
244541 :
244542 2 : return SgTypeUnsignedChar::createType();
244543 : }
244544 :
244545 :
244546 :
244547 : // End of memberFunctionString
244548 : // Start of memberFunctionString
244549 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
244550 :
244551 : // *** COMMON CODE SECTION BEGINS HERE ***
244552 :
244553 : #if 0
244554 : int
244555 : SgUnsignedCharVal::getVariant() const
244556 : {
244557 : // This function is used in ROSE while "variant()" is used in SAGE
244558 : assert(this != NULL);
244559 : return variant();
244560 : }
244561 : #endif
244562 :
244563 : // This function is used in ROSE in treeTraversal code
244564 : // eventually replaces getVariant() and variant()
244565 : // though after variant() has been removed for a while we will
244566 : // want to change the name of variantT() back to variant()
244567 : // (since the "T" was ment to stand for temporary).
244568 : // When this happens the variantT() will be depricated.
244569 : VariantT
244570 224 : SgUnsignedCharVal::variantT() const
244571 : {
244572 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
244573 224 : ROSE_ASSERT(this != NULL);
244574 224 : return V_SgUnsignedCharVal;
244575 : }
244576 :
244577 : #if 0
244578 : int
244579 : SgUnsignedCharVal::variant() const
244580 : {
244581 : // This function is used in SAGE
244582 : ROSE_ASSERT(this != NULL);
244583 : return UNSIGNED_CHAR_VAL;
244584 : }
244585 : #endif
244586 :
244587 : ROSE_DLL_API const char*
244588 0 : SgUnsignedCharVal::sage_class_name() const
244589 : {
244590 0 : ROSE_ASSERT(this != NULL);
244591 0 : return "SgUnsignedCharVal";
244592 : }
244593 :
244594 : std::string
244595 2 : SgUnsignedCharVal::class_name() const
244596 : {
244597 2 : ROSE_ASSERT(this != NULL);
244598 2 : return "SgUnsignedCharVal";
244599 : }
244600 :
244601 : // DQ (11/26/2005): Support for visitor pattern mechanims
244602 : // (inferior to ROSE traversal mechanism, experimental).
244603 : void
244604 0 : SgUnsignedCharVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
244605 : {
244606 0 : ROSE_ASSERT(this != NULL);
244607 0 : visitor.visit(this);
244608 0 : }
244609 :
244610 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
244611 0 : void SgUnsignedCharVal::accept (ROSE_VisitorPattern & visitor) {
244612 0 : ROSE_ASSERT(this != NULL);
244613 0 : visitor.visit(this);
244614 0 : }
244615 :
244616 : SgUnsignedCharVal*
244617 0 : SgUnsignedCharVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
244618 : {
244619 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
244620 : // This function is currently only supported for the AST used the represent Binary executables.
244621 : if (0 /* isSgAsmNode(this) != NULL */)
244622 : {
244623 : // Support for regex specification.
244624 : std::string prefixCode = "REGEX:";
244625 : addNewAttribute(prefixCode + s,a);
244626 : }
244627 : #endif
244628 :
244629 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
244630 0 : return this;
244631 : }
244632 :
244633 : // *** COMMON CODE SECTION ENDS HERE ***
244634 :
244635 :
244636 : // End of memberFunctionString
244637 : // Start of memberFunctionString
244638 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
244639 :
244640 :
244641 : #if 0
244642 : //! Error checking support
244643 : /*! Verifies the following:
244644 : - working getVariant() member function
244645 : - calls base class's error() member function
244646 : Every class has one of these functions.
244647 : */
244648 : bool
244649 : SgUnsignedCharVal::error()
244650 : {
244651 : // Put error checking here
244652 :
244653 : ROSE_ASSERT (this != NULL);
244654 : if (getVariant() != UNSIGNED_CHAR_VAL)
244655 : {
244656 : printf ("Error in SgUnsignedCharVal::error(): SgUnsignedCharVal object has a %s variant \n",
244657 : Cxx_GrammarTerminalNames[getVariant()].name);
244658 : // printf ("Error in SgUnsignedCharVal::error() \n");
244659 : ROSE_ABORT();
244660 : }
244661 :
244662 : ROSE_ASSERT (getVariant() == UNSIGNED_CHAR_VAL);
244663 : return SgValueExp::error();
244664 : }
244665 : #endif
244666 :
244667 :
244668 :
244669 : // End of memberFunctionString
244670 :
244671 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
244672 :
244673 50662 : SgUnsignedCharVal* isSgUnsignedCharVal ( SgNode* inputDerivedClassPointer )
244674 : {
244675 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
244676 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
244677 : // So to fix this we return NULL directly when the input is NULL and avoid the
244678 : // dynamic_cast in this case. This is likely a performance improvement as well.
244679 : // return dynamic_cast<SgUnsignedCharVal*>(inputDerivedClassPointer);
244680 : // Milind Chabbi (8/28/2013): isSgUnsignedCharVal uses table-driven castability instead of c++ default dynamic_cast
244681 : // this improves the running time performance by 10-20%.
244682 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnsignedCharVal*>(inputDerivedClassPointer);
244683 50662 : return IS_SgUnsignedCharVal_FAST_MACRO(inputDerivedClassPointer);
244684 : }
244685 :
244686 : // DQ (11/8/2003): Added version of functions taking const pointer
244687 0 : const SgUnsignedCharVal* isSgUnsignedCharVal ( const SgNode* inputDerivedClassPointer )
244688 : {
244689 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
244690 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
244691 : // So to fix this we return NULL directly when the input is NULL and avoid the
244692 : // dynamic_cast in this case. This is likely a performance improvement as well.
244693 : // return dynamic_cast<const SgUnsignedCharVal*>(inputDerivedClassPointer);
244694 : // Milind Chabbi (8/28/2013): isSgUnsignedCharVal uses table-driven castability instead of c++ default dynamic_cast
244695 : // this improves the running time performance by 10-20%.
244696 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnsignedCharVal*>(inputDerivedClassPointer);
244697 0 : return IS_SgUnsignedCharVal_FAST_MACRO(inputDerivedClassPointer);
244698 : }
244699 :
244700 :
244701 :
244702 : /* #line 244703 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244703 :
244704 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
244705 :
244706 : /**
244707 : \brief Generated destructor
244708 :
244709 : This destructor is automatically generated (by ROSETTA). This destructor
244710 : only frees memory of data members associated with the parts of the current IR node which
244711 : are NOT traversed. Those data members that are part of a traversal can be freed using
244712 : a traversal (calling this destructor on all children in a post-order traversal). Such
244713 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
244714 :
244715 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
244716 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
244717 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
244718 :
244719 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
244720 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
244721 : pointers are not yet implemented to call delete on eash pointer in the container.
244722 : (This could be done by derivation from the STL containers to define containers that
244723 : automatically deleted their members.)
244724 :
244725 : */
244726 0 : SgUnsignedCharVal::~SgUnsignedCharVal () {
244727 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
244728 :
244729 :
244730 : // case: not a listType for value
244731 0 : p_value = 0; // non list case
244732 : // case: not a listType for valueString
244733 0 : p_valueString = ""; // non list case
244734 :
244735 : }
244736 :
244737 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
244738 0 : }
244739 :
244740 :
244741 : /* #line 244742 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244742 :
244743 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
244744 :
244745 : // Generated constructor
244746 0 : SgUnsignedCharVal::SgUnsignedCharVal ( Sg_File_Info* startOfConstruct, unsigned char value, std::string valueString )
244747 0 : : SgValueExp(startOfConstruct)
244748 : {
244749 : #ifdef DEBUG
244750 : // printf ("In SgUnsignedCharVal::SgUnsignedCharVal (Sg_File_Info* startOfConstruct, unsigned char value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
244751 : #endif
244752 : #if 0
244753 : // debugging information!
244754 : printf ("In SgUnsignedCharVal::SgUnsignedCharVal (Sg_File_Info* startOfConstruct, unsigned char value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
244755 : #endif
244756 :
244757 0 : p_value = value;
244758 0 : p_valueString = valueString;
244759 :
244760 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
244761 :
244762 : #if 0
244763 : // DQ (7/30/2014): Call a virtual function.
244764 : std::string s = this->class_name();
244765 : #endif
244766 :
244767 : // Test the variant virtual function
244768 : // assert(UNSIGNED_CHAR_VAL == variant());
244769 0 : assert(UNSIGNED_CHAR_VAL == this->variant());
244770 0 : ROSE_ASSERT(UNSIGNED_CHAR_VAL == (int)(this->variantT()));
244771 0 : post_construction_initialization();
244772 :
244773 : // Test the isSgUnsignedCharVal() function since it has been problematic
244774 0 : assert(isSgUnsignedCharVal(this) != NULL);
244775 0 : }
244776 :
244777 : // Generated constructor (all data members)
244778 :
244779 : /* #line 244780 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244780 :
244781 :
244782 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
244783 :
244784 :
244785 : // ********************************************************
244786 : // member functions common across all array grammar objects
244787 : // ********************************************************
244788 :
244789 :
244790 :
244791 : /* #line 244792 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244792 :
244793 :
244794 :
244795 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
244796 :
244797 : // ********************************************************
244798 : // member functions specific to each node in the grammar
244799 : // ********************************************************
244800 :
244801 :
244802 : /* #line 244803 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
244803 :
244804 : // Start of memberFunctionString
244805 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
244806 :
244807 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
244808 :
244809 : unsigned long
244810 0 : SgWcharVal::get_valueUL () const
244811 : {
244812 0 : ROSE_ASSERT (this != NULL);
244813 :
244814 : #if 0
244815 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244816 : // used to trigger marking transformations for the token-based unparsing.
244817 : printf ("SgWcharVal::get_valueUL = %p = %s \n",this,this->class_name().c_str());
244818 : #endif
244819 :
244820 0 : return p_valueUL;
244821 : }
244822 :
244823 : void
244824 0 : SgWcharVal::set_valueUL ( unsigned long valueUL )
244825 : {
244826 0 : ROSE_ASSERT (this != NULL);
244827 :
244828 : #if 0
244829 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244830 : // used to trigger marking transformations for the token-based unparsing.
244831 : printf ("SgWcharVal::set_valueUL = %p = %s \n",this,this->class_name().c_str());
244832 : #endif
244833 :
244834 0 : set_isModified(true);
244835 :
244836 0 : p_valueUL = valueUL;
244837 0 : }
244838 :
244839 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
244840 :
244841 :
244842 : // End of memberFunctionString
244843 : // Start of memberFunctionString
244844 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
244845 :
244846 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
244847 :
244848 : std::string
244849 1 : SgWcharVal::get_valueString () const
244850 : {
244851 1 : ROSE_ASSERT (this != NULL);
244852 :
244853 : #if 0
244854 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244855 : // used to trigger marking transformations for the token-based unparsing.
244856 : printf ("SgWcharVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
244857 : #endif
244858 :
244859 1 : return p_valueString;
244860 : }
244861 :
244862 : void
244863 0 : SgWcharVal::set_valueString ( std::string valueString )
244864 : {
244865 0 : ROSE_ASSERT (this != NULL);
244866 :
244867 : #if 0
244868 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
244869 : // used to trigger marking transformations for the token-based unparsing.
244870 : printf ("SgWcharVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
244871 : #endif
244872 :
244873 0 : set_isModified(true);
244874 :
244875 0 : p_valueString = valueString;
244876 0 : }
244877 :
244878 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
244879 :
244880 :
244881 : // End of memberFunctionString
244882 : // Start of memberFunctionString
244883 : /* #line 4090 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244884 :
244885 : void
244886 9 : SgWcharVal::post_construction_initialization()
244887 : {
244888 : // We can't initialize this to NULL since it might have just been set!
244889 : // p_valueUL = 0L;
244890 9 : }
244891 :
244892 : wchar_t
244893 1 : SgWcharVal::get_value() const
244894 : {
244895 1 : return p_valueUL;
244896 : }
244897 :
244898 : void
244899 0 : SgWcharVal::set_value(wchar_t new_val)
244900 : {
244901 0 : p_valueUL = new_val;
244902 0 : }
244903 :
244904 :
244905 :
244906 : // End of memberFunctionString
244907 : // Start of memberFunctionString
244908 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
244909 :
244910 :
244911 : SgType*
244912 1 : SgWcharVal::get_type(void) const
244913 : {
244914 : #if 0
244915 : printf ("In SgWcharVal::get_type() \n");
244916 : #endif
244917 :
244918 1 : return SgTypeWchar::createType();
244919 : }
244920 :
244921 :
244922 :
244923 : // End of memberFunctionString
244924 : // Start of memberFunctionString
244925 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
244926 :
244927 : // *** COMMON CODE SECTION BEGINS HERE ***
244928 :
244929 : #if 0
244930 : int
244931 : SgWcharVal::getVariant() const
244932 : {
244933 : // This function is used in ROSE while "variant()" is used in SAGE
244934 : assert(this != NULL);
244935 : return variant();
244936 : }
244937 : #endif
244938 :
244939 : // This function is used in ROSE in treeTraversal code
244940 : // eventually replaces getVariant() and variant()
244941 : // though after variant() has been removed for a while we will
244942 : // want to change the name of variantT() back to variant()
244943 : // (since the "T" was ment to stand for temporary).
244944 : // When this happens the variantT() will be depricated.
244945 : VariantT
244946 576 : SgWcharVal::variantT() const
244947 : {
244948 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
244949 576 : ROSE_ASSERT(this != NULL);
244950 576 : return V_SgWcharVal;
244951 : }
244952 :
244953 : #if 0
244954 : int
244955 : SgWcharVal::variant() const
244956 : {
244957 : // This function is used in SAGE
244958 : ROSE_ASSERT(this != NULL);
244959 : return WCHAR_VAL;
244960 : }
244961 : #endif
244962 :
244963 : ROSE_DLL_API const char*
244964 0 : SgWcharVal::sage_class_name() const
244965 : {
244966 0 : ROSE_ASSERT(this != NULL);
244967 0 : return "SgWcharVal";
244968 : }
244969 :
244970 : std::string
244971 1 : SgWcharVal::class_name() const
244972 : {
244973 1 : ROSE_ASSERT(this != NULL);
244974 1 : return "SgWcharVal";
244975 : }
244976 :
244977 : // DQ (11/26/2005): Support for visitor pattern mechanims
244978 : // (inferior to ROSE traversal mechanism, experimental).
244979 : void
244980 0 : SgWcharVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
244981 : {
244982 0 : ROSE_ASSERT(this != NULL);
244983 0 : visitor.visit(this);
244984 0 : }
244985 :
244986 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
244987 0 : void SgWcharVal::accept (ROSE_VisitorPattern & visitor) {
244988 0 : ROSE_ASSERT(this != NULL);
244989 0 : visitor.visit(this);
244990 0 : }
244991 :
244992 : SgWcharVal*
244993 0 : SgWcharVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
244994 : {
244995 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
244996 : // This function is currently only supported for the AST used the represent Binary executables.
244997 : if (0 /* isSgAsmNode(this) != NULL */)
244998 : {
244999 : // Support for regex specification.
245000 : std::string prefixCode = "REGEX:";
245001 : addNewAttribute(prefixCode + s,a);
245002 : }
245003 : #endif
245004 :
245005 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
245006 0 : return this;
245007 : }
245008 :
245009 : // *** COMMON CODE SECTION ENDS HERE ***
245010 :
245011 :
245012 : // End of memberFunctionString
245013 : // Start of memberFunctionString
245014 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
245015 :
245016 :
245017 : #if 0
245018 : //! Error checking support
245019 : /*! Verifies the following:
245020 : - working getVariant() member function
245021 : - calls base class's error() member function
245022 : Every class has one of these functions.
245023 : */
245024 : bool
245025 : SgWcharVal::error()
245026 : {
245027 : // Put error checking here
245028 :
245029 : ROSE_ASSERT (this != NULL);
245030 : if (getVariant() != WCHAR_VAL)
245031 : {
245032 : printf ("Error in SgWcharVal::error(): SgWcharVal object has a %s variant \n",
245033 : Cxx_GrammarTerminalNames[getVariant()].name);
245034 : // printf ("Error in SgWcharVal::error() \n");
245035 : ROSE_ABORT();
245036 : }
245037 :
245038 : ROSE_ASSERT (getVariant() == WCHAR_VAL);
245039 : return SgValueExp::error();
245040 : }
245041 : #endif
245042 :
245043 :
245044 :
245045 : // End of memberFunctionString
245046 :
245047 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
245048 :
245049 10 : SgWcharVal* isSgWcharVal ( SgNode* inputDerivedClassPointer )
245050 : {
245051 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
245052 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
245053 : // So to fix this we return NULL directly when the input is NULL and avoid the
245054 : // dynamic_cast in this case. This is likely a performance improvement as well.
245055 : // return dynamic_cast<SgWcharVal*>(inputDerivedClassPointer);
245056 : // Milind Chabbi (8/28/2013): isSgWcharVal uses table-driven castability instead of c++ default dynamic_cast
245057 : // this improves the running time performance by 10-20%.
245058 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgWcharVal*>(inputDerivedClassPointer);
245059 10 : return IS_SgWcharVal_FAST_MACRO(inputDerivedClassPointer);
245060 : }
245061 :
245062 : // DQ (11/8/2003): Added version of functions taking const pointer
245063 0 : const SgWcharVal* isSgWcharVal ( const SgNode* inputDerivedClassPointer )
245064 : {
245065 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
245066 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
245067 : // So to fix this we return NULL directly when the input is NULL and avoid the
245068 : // dynamic_cast in this case. This is likely a performance improvement as well.
245069 : // return dynamic_cast<const SgWcharVal*>(inputDerivedClassPointer);
245070 : // Milind Chabbi (8/28/2013): isSgWcharVal uses table-driven castability instead of c++ default dynamic_cast
245071 : // this improves the running time performance by 10-20%.
245072 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgWcharVal*>(inputDerivedClassPointer);
245073 0 : return IS_SgWcharVal_FAST_MACRO(inputDerivedClassPointer);
245074 : }
245075 :
245076 :
245077 :
245078 : /* #line 245079 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245079 :
245080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
245081 :
245082 : /**
245083 : \brief Generated destructor
245084 :
245085 : This destructor is automatically generated (by ROSETTA). This destructor
245086 : only frees memory of data members associated with the parts of the current IR node which
245087 : are NOT traversed. Those data members that are part of a traversal can be freed using
245088 : a traversal (calling this destructor on all children in a post-order traversal). Such
245089 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
245090 :
245091 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
245092 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
245093 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
245094 :
245095 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
245096 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
245097 : pointers are not yet implemented to call delete on eash pointer in the container.
245098 : (This could be done by derivation from the STL containers to define containers that
245099 : automatically deleted their members.)
245100 :
245101 : */
245102 16 : SgWcharVal::~SgWcharVal () {
245103 8 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
245104 :
245105 :
245106 : // case: not a listType for valueUL
245107 8 : p_valueUL = 0; // non list case
245108 : // case: not a listType for valueString
245109 8 : p_valueString = ""; // non list case
245110 :
245111 : }
245112 :
245113 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
245114 16 : }
245115 :
245116 :
245117 : /* #line 245118 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245118 :
245119 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
245120 :
245121 : // Generated constructor
245122 0 : SgWcharVal::SgWcharVal ( Sg_File_Info* startOfConstruct, unsigned long valueUL, std::string valueString )
245123 0 : : SgValueExp(startOfConstruct)
245124 : {
245125 : #ifdef DEBUG
245126 : // printf ("In SgWcharVal::SgWcharVal (Sg_File_Info* startOfConstruct, unsigned long valueUL, std::string valueString) sage_class_name() = %s \n",sage_class_name());
245127 : #endif
245128 : #if 0
245129 : // debugging information!
245130 : printf ("In SgWcharVal::SgWcharVal (Sg_File_Info* startOfConstruct, unsigned long valueUL, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
245131 : #endif
245132 :
245133 0 : p_valueUL = valueUL;
245134 0 : p_valueString = valueString;
245135 :
245136 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
245137 :
245138 : #if 0
245139 : // DQ (7/30/2014): Call a virtual function.
245140 : std::string s = this->class_name();
245141 : #endif
245142 :
245143 : // Test the variant virtual function
245144 : // assert(WCHAR_VAL == variant());
245145 0 : assert(WCHAR_VAL == this->variant());
245146 0 : ROSE_ASSERT(WCHAR_VAL == (int)(this->variantT()));
245147 0 : post_construction_initialization();
245148 :
245149 : // Test the isSgWcharVal() function since it has been problematic
245150 0 : assert(isSgWcharVal(this) != NULL);
245151 0 : }
245152 :
245153 : // Generated constructor (all data members)
245154 :
245155 : /* #line 245156 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245156 :
245157 :
245158 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
245159 :
245160 :
245161 : // ********************************************************
245162 : // member functions common across all array grammar objects
245163 : // ********************************************************
245164 :
245165 :
245166 :
245167 : /* #line 245168 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245168 :
245169 :
245170 :
245171 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
245172 :
245173 : // ********************************************************
245174 : // member functions specific to each node in the grammar
245175 : // ********************************************************
245176 :
245177 :
245178 : /* #line 245179 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245179 :
245180 : // Start of memberFunctionString
245181 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245182 :
245183 : void
245184 219 : SgUnsignedShortVal::post_construction_initialization()
245185 : {
245186 219 : }
245187 :
245188 :
245189 :
245190 : // End of memberFunctionString
245191 : // Start of memberFunctionString
245192 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
245193 :
245194 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
245195 :
245196 : unsigned short
245197 2 : SgUnsignedShortVal::get_value () const
245198 : {
245199 2 : ROSE_ASSERT (this != NULL);
245200 :
245201 : #if 0
245202 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245203 : // used to trigger marking transformations for the token-based unparsing.
245204 : printf ("SgUnsignedShortVal::get_value = %p = %s \n",this,this->class_name().c_str());
245205 : #endif
245206 :
245207 2 : return p_value;
245208 : }
245209 :
245210 : void
245211 0 : SgUnsignedShortVal::set_value ( unsigned short value )
245212 : {
245213 0 : ROSE_ASSERT (this != NULL);
245214 :
245215 : #if 0
245216 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245217 : // used to trigger marking transformations for the token-based unparsing.
245218 : printf ("SgUnsignedShortVal::set_value = %p = %s \n",this,this->class_name().c_str());
245219 : #endif
245220 :
245221 0 : set_isModified(true);
245222 :
245223 0 : p_value = value;
245224 0 : }
245225 :
245226 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
245227 :
245228 :
245229 : // End of memberFunctionString
245230 : // Start of memberFunctionString
245231 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
245232 :
245233 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
245234 :
245235 : std::string
245236 0 : SgUnsignedShortVal::get_valueString () const
245237 : {
245238 0 : ROSE_ASSERT (this != NULL);
245239 :
245240 : #if 0
245241 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245242 : // used to trigger marking transformations for the token-based unparsing.
245243 : printf ("SgUnsignedShortVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
245244 : #endif
245245 :
245246 0 : return p_valueString;
245247 : }
245248 :
245249 : void
245250 0 : SgUnsignedShortVal::set_valueString ( std::string valueString )
245251 : {
245252 0 : ROSE_ASSERT (this != NULL);
245253 :
245254 : #if 0
245255 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245256 : // used to trigger marking transformations for the token-based unparsing.
245257 : printf ("SgUnsignedShortVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
245258 : #endif
245259 :
245260 0 : set_isModified(true);
245261 :
245262 0 : p_valueString = valueString;
245263 0 : }
245264 :
245265 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
245266 :
245267 :
245268 : // End of memberFunctionString
245269 : // Start of memberFunctionString
245270 : /* #line 4165 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245271 :
245272 :
245273 :
245274 : // End of memberFunctionString
245275 : // Start of memberFunctionString
245276 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245277 :
245278 :
245279 : SgType*
245280 2 : SgUnsignedShortVal::get_type(void) const
245281 : {
245282 : #if 0
245283 : printf ("In SgUnsignedShortVal::get_type() \n");
245284 : #endif
245285 :
245286 2 : return SgTypeUnsignedShort::createType();
245287 : }
245288 :
245289 :
245290 :
245291 : // End of memberFunctionString
245292 : // Start of memberFunctionString
245293 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
245294 :
245295 : // *** COMMON CODE SECTION BEGINS HERE ***
245296 :
245297 : #if 0
245298 : int
245299 : SgUnsignedShortVal::getVariant() const
245300 : {
245301 : // This function is used in ROSE while "variant()" is used in SAGE
245302 : assert(this != NULL);
245303 : return variant();
245304 : }
245305 : #endif
245306 :
245307 : // This function is used in ROSE in treeTraversal code
245308 : // eventually replaces getVariant() and variant()
245309 : // though after variant() has been removed for a while we will
245310 : // want to change the name of variantT() back to variant()
245311 : // (since the "T" was ment to stand for temporary).
245312 : // When this happens the variantT() will be depricated.
245313 : VariantT
245314 10676 : SgUnsignedShortVal::variantT() const
245315 : {
245316 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
245317 10676 : ROSE_ASSERT(this != NULL);
245318 10676 : return V_SgUnsignedShortVal;
245319 : }
245320 :
245321 : #if 0
245322 : int
245323 : SgUnsignedShortVal::variant() const
245324 : {
245325 : // This function is used in SAGE
245326 : ROSE_ASSERT(this != NULL);
245327 : return UNSIGNED_SHORT_VAL;
245328 : }
245329 : #endif
245330 :
245331 : ROSE_DLL_API const char*
245332 0 : SgUnsignedShortVal::sage_class_name() const
245333 : {
245334 0 : ROSE_ASSERT(this != NULL);
245335 0 : return "SgUnsignedShortVal";
245336 : }
245337 :
245338 : std::string
245339 2 : SgUnsignedShortVal::class_name() const
245340 : {
245341 2 : ROSE_ASSERT(this != NULL);
245342 2 : return "SgUnsignedShortVal";
245343 : }
245344 :
245345 : // DQ (11/26/2005): Support for visitor pattern mechanims
245346 : // (inferior to ROSE traversal mechanism, experimental).
245347 : void
245348 0 : SgUnsignedShortVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
245349 : {
245350 0 : ROSE_ASSERT(this != NULL);
245351 0 : visitor.visit(this);
245352 0 : }
245353 :
245354 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
245355 0 : void SgUnsignedShortVal::accept (ROSE_VisitorPattern & visitor) {
245356 0 : ROSE_ASSERT(this != NULL);
245357 0 : visitor.visit(this);
245358 0 : }
245359 :
245360 : SgUnsignedShortVal*
245361 0 : SgUnsignedShortVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
245362 : {
245363 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
245364 : // This function is currently only supported for the AST used the represent Binary executables.
245365 : if (0 /* isSgAsmNode(this) != NULL */)
245366 : {
245367 : // Support for regex specification.
245368 : std::string prefixCode = "REGEX:";
245369 : addNewAttribute(prefixCode + s,a);
245370 : }
245371 : #endif
245372 :
245373 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
245374 0 : return this;
245375 : }
245376 :
245377 : // *** COMMON CODE SECTION ENDS HERE ***
245378 :
245379 :
245380 : // End of memberFunctionString
245381 : // Start of memberFunctionString
245382 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
245383 :
245384 :
245385 : #if 0
245386 : //! Error checking support
245387 : /*! Verifies the following:
245388 : - working getVariant() member function
245389 : - calls base class's error() member function
245390 : Every class has one of these functions.
245391 : */
245392 : bool
245393 : SgUnsignedShortVal::error()
245394 : {
245395 : // Put error checking here
245396 :
245397 : ROSE_ASSERT (this != NULL);
245398 : if (getVariant() != UNSIGNED_SHORT_VAL)
245399 : {
245400 : printf ("Error in SgUnsignedShortVal::error(): SgUnsignedShortVal object has a %s variant \n",
245401 : Cxx_GrammarTerminalNames[getVariant()].name);
245402 : // printf ("Error in SgUnsignedShortVal::error() \n");
245403 : ROSE_ABORT();
245404 : }
245405 :
245406 : ROSE_ASSERT (getVariant() == UNSIGNED_SHORT_VAL);
245407 : return SgValueExp::error();
245408 : }
245409 : #endif
245410 :
245411 :
245412 :
245413 : // End of memberFunctionString
245414 :
245415 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
245416 :
245417 50966 : SgUnsignedShortVal* isSgUnsignedShortVal ( SgNode* inputDerivedClassPointer )
245418 : {
245419 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
245420 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
245421 : // So to fix this we return NULL directly when the input is NULL and avoid the
245422 : // dynamic_cast in this case. This is likely a performance improvement as well.
245423 : // return dynamic_cast<SgUnsignedShortVal*>(inputDerivedClassPointer);
245424 : // Milind Chabbi (8/28/2013): isSgUnsignedShortVal uses table-driven castability instead of c++ default dynamic_cast
245425 : // this improves the running time performance by 10-20%.
245426 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnsignedShortVal*>(inputDerivedClassPointer);
245427 50966 : return IS_SgUnsignedShortVal_FAST_MACRO(inputDerivedClassPointer);
245428 : }
245429 :
245430 : // DQ (11/8/2003): Added version of functions taking const pointer
245431 0 : const SgUnsignedShortVal* isSgUnsignedShortVal ( const SgNode* inputDerivedClassPointer )
245432 : {
245433 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
245434 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
245435 : // So to fix this we return NULL directly when the input is NULL and avoid the
245436 : // dynamic_cast in this case. This is likely a performance improvement as well.
245437 : // return dynamic_cast<const SgUnsignedShortVal*>(inputDerivedClassPointer);
245438 : // Milind Chabbi (8/28/2013): isSgUnsignedShortVal uses table-driven castability instead of c++ default dynamic_cast
245439 : // this improves the running time performance by 10-20%.
245440 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnsignedShortVal*>(inputDerivedClassPointer);
245441 0 : return IS_SgUnsignedShortVal_FAST_MACRO(inputDerivedClassPointer);
245442 : }
245443 :
245444 :
245445 :
245446 : /* #line 245447 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245447 :
245448 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
245449 :
245450 : /**
245451 : \brief Generated destructor
245452 :
245453 : This destructor is automatically generated (by ROSETTA). This destructor
245454 : only frees memory of data members associated with the parts of the current IR node which
245455 : are NOT traversed. Those data members that are part of a traversal can be freed using
245456 : a traversal (calling this destructor on all children in a post-order traversal). Such
245457 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
245458 :
245459 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
245460 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
245461 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
245462 :
245463 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
245464 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
245465 : pointers are not yet implemented to call delete on eash pointer in the container.
245466 : (This could be done by derivation from the STL containers to define containers that
245467 : automatically deleted their members.)
245468 :
245469 : */
245470 434 : SgUnsignedShortVal::~SgUnsignedShortVal () {
245471 217 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
245472 :
245473 :
245474 : // case: not a listType for value
245475 217 : p_value = 0; // non list case
245476 : // case: not a listType for valueString
245477 217 : p_valueString = ""; // non list case
245478 :
245479 : }
245480 :
245481 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
245482 434 : }
245483 :
245484 :
245485 : /* #line 245486 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245486 :
245487 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
245488 :
245489 : // Generated constructor
245490 0 : SgUnsignedShortVal::SgUnsignedShortVal ( Sg_File_Info* startOfConstruct, unsigned short value, std::string valueString )
245491 0 : : SgValueExp(startOfConstruct)
245492 : {
245493 : #ifdef DEBUG
245494 : // printf ("In SgUnsignedShortVal::SgUnsignedShortVal (Sg_File_Info* startOfConstruct, unsigned short value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
245495 : #endif
245496 : #if 0
245497 : // debugging information!
245498 : printf ("In SgUnsignedShortVal::SgUnsignedShortVal (Sg_File_Info* startOfConstruct, unsigned short value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
245499 : #endif
245500 :
245501 0 : p_value = value;
245502 0 : p_valueString = valueString;
245503 :
245504 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
245505 :
245506 : #if 0
245507 : // DQ (7/30/2014): Call a virtual function.
245508 : std::string s = this->class_name();
245509 : #endif
245510 :
245511 : // Test the variant virtual function
245512 : // assert(UNSIGNED_SHORT_VAL == variant());
245513 0 : assert(UNSIGNED_SHORT_VAL == this->variant());
245514 0 : ROSE_ASSERT(UNSIGNED_SHORT_VAL == (int)(this->variantT()));
245515 0 : post_construction_initialization();
245516 :
245517 : // Test the isSgUnsignedShortVal() function since it has been problematic
245518 0 : assert(isSgUnsignedShortVal(this) != NULL);
245519 0 : }
245520 :
245521 : // Generated constructor (all data members)
245522 :
245523 : /* #line 245524 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245524 :
245525 :
245526 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
245527 :
245528 :
245529 : // ********************************************************
245530 : // member functions common across all array grammar objects
245531 : // ********************************************************
245532 :
245533 :
245534 :
245535 : /* #line 245536 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245536 :
245537 :
245538 :
245539 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
245540 :
245541 : // ********************************************************
245542 : // member functions specific to each node in the grammar
245543 : // ********************************************************
245544 :
245545 :
245546 : /* #line 245547 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245547 :
245548 : // Start of memberFunctionString
245549 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245550 :
245551 : void
245552 29764 : SgIntVal::post_construction_initialization()
245553 : {
245554 29764 : }
245555 :
245556 :
245557 :
245558 : // End of memberFunctionString
245559 : // Start of memberFunctionString
245560 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
245561 :
245562 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
245563 :
245564 : int
245565 24362 : SgIntVal::get_value () const
245566 : {
245567 24362 : ROSE_ASSERT (this != NULL);
245568 :
245569 : #if 0
245570 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245571 : // used to trigger marking transformations for the token-based unparsing.
245572 : printf ("SgIntVal::get_value = %p = %s \n",this,this->class_name().c_str());
245573 : #endif
245574 :
245575 24362 : return p_value;
245576 : }
245577 :
245578 : void
245579 0 : SgIntVal::set_value ( int value )
245580 : {
245581 0 : ROSE_ASSERT (this != NULL);
245582 :
245583 : #if 0
245584 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245585 : // used to trigger marking transformations for the token-based unparsing.
245586 : printf ("SgIntVal::set_value = %p = %s \n",this,this->class_name().c_str());
245587 : #endif
245588 :
245589 0 : set_isModified(true);
245590 :
245591 0 : p_value = value;
245592 0 : }
245593 :
245594 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
245595 :
245596 :
245597 : // End of memberFunctionString
245598 : // Start of memberFunctionString
245599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
245600 :
245601 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
245602 :
245603 : std::string
245604 20889 : SgIntVal::get_valueString () const
245605 : {
245606 20889 : ROSE_ASSERT (this != NULL);
245607 :
245608 : #if 0
245609 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245610 : // used to trigger marking transformations for the token-based unparsing.
245611 : printf ("SgIntVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
245612 : #endif
245613 :
245614 20889 : return p_valueString;
245615 : }
245616 :
245617 : void
245618 0 : SgIntVal::set_valueString ( std::string valueString )
245619 : {
245620 0 : ROSE_ASSERT (this != NULL);
245621 :
245622 : #if 0
245623 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245624 : // used to trigger marking transformations for the token-based unparsing.
245625 : printf ("SgIntVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
245626 : #endif
245627 :
245628 0 : set_isModified(true);
245629 :
245630 0 : p_valueString = valueString;
245631 0 : }
245632 :
245633 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
245634 :
245635 :
245636 : // End of memberFunctionString
245637 : // Start of memberFunctionString
245638 : /* #line 4169 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245639 :
245640 :
245641 :
245642 : // End of memberFunctionString
245643 : // Start of memberFunctionString
245644 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245645 :
245646 :
245647 : SgType*
245648 14146 : SgIntVal::get_type(void) const
245649 : {
245650 : #if 0
245651 : printf ("In SgIntVal::get_type() \n");
245652 : #endif
245653 :
245654 14146 : return SgTypeInt::createType();
245655 : }
245656 :
245657 :
245658 :
245659 : // End of memberFunctionString
245660 : // Start of memberFunctionString
245661 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
245662 :
245663 : // *** COMMON CODE SECTION BEGINS HERE ***
245664 :
245665 : #if 0
245666 : int
245667 : SgIntVal::getVariant() const
245668 : {
245669 : // This function is used in ROSE while "variant()" is used in SAGE
245670 : assert(this != NULL);
245671 : return variant();
245672 : }
245673 : #endif
245674 :
245675 : // This function is used in ROSE in treeTraversal code
245676 : // eventually replaces getVariant() and variant()
245677 : // though after variant() has been removed for a while we will
245678 : // want to change the name of variantT() back to variant()
245679 : // (since the "T" was ment to stand for temporary).
245680 : // When this happens the variantT() will be depricated.
245681 : VariantT
245682 4725410 : SgIntVal::variantT() const
245683 : {
245684 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
245685 4725410 : ROSE_ASSERT(this != NULL);
245686 4725410 : return V_SgIntVal;
245687 : }
245688 :
245689 : #if 0
245690 : int
245691 : SgIntVal::variant() const
245692 : {
245693 : // This function is used in SAGE
245694 : ROSE_ASSERT(this != NULL);
245695 : return INT_VAL;
245696 : }
245697 : #endif
245698 :
245699 : ROSE_DLL_API const char*
245700 488 : SgIntVal::sage_class_name() const
245701 : {
245702 488 : ROSE_ASSERT(this != NULL);
245703 488 : return "SgIntVal";
245704 : }
245705 :
245706 : std::string
245707 16622 : SgIntVal::class_name() const
245708 : {
245709 16622 : ROSE_ASSERT(this != NULL);
245710 16622 : return "SgIntVal";
245711 : }
245712 :
245713 : // DQ (11/26/2005): Support for visitor pattern mechanims
245714 : // (inferior to ROSE traversal mechanism, experimental).
245715 : void
245716 133448 : SgIntVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
245717 : {
245718 133448 : ROSE_ASSERT(this != NULL);
245719 133448 : visitor.visit(this);
245720 133448 : }
245721 :
245722 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
245723 0 : void SgIntVal::accept (ROSE_VisitorPattern & visitor) {
245724 0 : ROSE_ASSERT(this != NULL);
245725 0 : visitor.visit(this);
245726 0 : }
245727 :
245728 : SgIntVal*
245729 0 : SgIntVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
245730 : {
245731 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
245732 : // This function is currently only supported for the AST used the represent Binary executables.
245733 : if (0 /* isSgAsmNode(this) != NULL */)
245734 : {
245735 : // Support for regex specification.
245736 : std::string prefixCode = "REGEX:";
245737 : addNewAttribute(prefixCode + s,a);
245738 : }
245739 : #endif
245740 :
245741 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
245742 0 : return this;
245743 : }
245744 :
245745 : // *** COMMON CODE SECTION ENDS HERE ***
245746 :
245747 :
245748 : // End of memberFunctionString
245749 : // Start of memberFunctionString
245750 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
245751 :
245752 :
245753 : #if 0
245754 : //! Error checking support
245755 : /*! Verifies the following:
245756 : - working getVariant() member function
245757 : - calls base class's error() member function
245758 : Every class has one of these functions.
245759 : */
245760 : bool
245761 : SgIntVal::error()
245762 : {
245763 : // Put error checking here
245764 :
245765 : ROSE_ASSERT (this != NULL);
245766 : if (getVariant() != INT_VAL)
245767 : {
245768 : printf ("Error in SgIntVal::error(): SgIntVal object has a %s variant \n",
245769 : Cxx_GrammarTerminalNames[getVariant()].name);
245770 : // printf ("Error in SgIntVal::error() \n");
245771 : ROSE_ABORT();
245772 : }
245773 :
245774 : ROSE_ASSERT (getVariant() == INT_VAL);
245775 : return SgValueExp::error();
245776 : }
245777 : #endif
245778 :
245779 :
245780 :
245781 : // End of memberFunctionString
245782 :
245783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
245784 :
245785 142829 : SgIntVal* isSgIntVal ( SgNode* inputDerivedClassPointer )
245786 : {
245787 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
245788 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
245789 : // So to fix this we return NULL directly when the input is NULL and avoid the
245790 : // dynamic_cast in this case. This is likely a performance improvement as well.
245791 : // return dynamic_cast<SgIntVal*>(inputDerivedClassPointer);
245792 : // Milind Chabbi (8/28/2013): isSgIntVal uses table-driven castability instead of c++ default dynamic_cast
245793 : // this improves the running time performance by 10-20%.
245794 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIntVal*>(inputDerivedClassPointer);
245795 142829 : return IS_SgIntVal_FAST_MACRO(inputDerivedClassPointer);
245796 : }
245797 :
245798 : // DQ (11/8/2003): Added version of functions taking const pointer
245799 999 : const SgIntVal* isSgIntVal ( const SgNode* inputDerivedClassPointer )
245800 : {
245801 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
245802 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
245803 : // So to fix this we return NULL directly when the input is NULL and avoid the
245804 : // dynamic_cast in this case. This is likely a performance improvement as well.
245805 : // return dynamic_cast<const SgIntVal*>(inputDerivedClassPointer);
245806 : // Milind Chabbi (8/28/2013): isSgIntVal uses table-driven castability instead of c++ default dynamic_cast
245807 : // this improves the running time performance by 10-20%.
245808 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIntVal*>(inputDerivedClassPointer);
245809 999 : return IS_SgIntVal_FAST_MACRO(inputDerivedClassPointer);
245810 : }
245811 :
245812 :
245813 :
245814 : /* #line 245815 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245815 :
245816 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
245817 :
245818 : /**
245819 : \brief Generated destructor
245820 :
245821 : This destructor is automatically generated (by ROSETTA). This destructor
245822 : only frees memory of data members associated with the parts of the current IR node which
245823 : are NOT traversed. Those data members that are part of a traversal can be freed using
245824 : a traversal (calling this destructor on all children in a post-order traversal). Such
245825 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
245826 :
245827 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
245828 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
245829 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
245830 :
245831 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
245832 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
245833 : pointers are not yet implemented to call delete on eash pointer in the container.
245834 : (This could be done by derivation from the STL containers to define containers that
245835 : automatically deleted their members.)
245836 :
245837 : */
245838 26560 : SgIntVal::~SgIntVal () {
245839 13280 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
245840 :
245841 :
245842 : // case: not a listType for value
245843 13280 : p_value = 0; // non list case
245844 : // case: not a listType for valueString
245845 13280 : p_valueString = ""; // non list case
245846 :
245847 : }
245848 :
245849 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
245850 26560 : }
245851 :
245852 :
245853 : /* #line 245854 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245854 :
245855 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
245856 :
245857 : // Generated constructor
245858 765 : SgIntVal::SgIntVal ( Sg_File_Info* startOfConstruct, int value, std::string valueString )
245859 765 : : SgValueExp(startOfConstruct)
245860 : {
245861 : #ifdef DEBUG
245862 : // printf ("In SgIntVal::SgIntVal (Sg_File_Info* startOfConstruct, int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
245863 : #endif
245864 : #if 0
245865 : // debugging information!
245866 : printf ("In SgIntVal::SgIntVal (Sg_File_Info* startOfConstruct, int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
245867 : #endif
245868 :
245869 765 : p_value = value;
245870 765 : p_valueString = valueString;
245871 :
245872 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
245873 :
245874 : #if 0
245875 : // DQ (7/30/2014): Call a virtual function.
245876 : std::string s = this->class_name();
245877 : #endif
245878 :
245879 : // Test the variant virtual function
245880 : // assert(INT_VAL == variant());
245881 765 : assert(INT_VAL == this->variant());
245882 765 : ROSE_ASSERT(INT_VAL == (int)(this->variantT()));
245883 765 : post_construction_initialization();
245884 :
245885 : // Test the isSgIntVal() function since it has been problematic
245886 765 : assert(isSgIntVal(this) != NULL);
245887 765 : }
245888 :
245889 : // Generated constructor (all data members)
245890 :
245891 : /* #line 245892 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245892 :
245893 :
245894 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
245895 :
245896 :
245897 : // ********************************************************
245898 : // member functions common across all array grammar objects
245899 : // ********************************************************
245900 :
245901 :
245902 :
245903 : /* #line 245904 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245904 :
245905 :
245906 :
245907 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
245908 :
245909 : // ********************************************************
245910 : // member functions specific to each node in the grammar
245911 : // ********************************************************
245912 :
245913 :
245914 : /* #line 245915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
245915 :
245916 : // Start of memberFunctionString
245917 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
245918 :
245919 : void
245920 12198 : SgEnumVal::post_construction_initialization()
245921 : {
245922 12198 : }
245923 :
245924 :
245925 :
245926 : // End of memberFunctionString
245927 : // Start of memberFunctionString
245928 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
245929 :
245930 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
245931 :
245932 : long long int
245933 308 : SgEnumVal::get_value () const
245934 : {
245935 308 : ROSE_ASSERT (this != NULL);
245936 :
245937 : #if 0
245938 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245939 : // used to trigger marking transformations for the token-based unparsing.
245940 : printf ("SgEnumVal::get_value = %p = %s \n",this,this->class_name().c_str());
245941 : #endif
245942 :
245943 308 : return p_value;
245944 : }
245945 :
245946 : void
245947 0 : SgEnumVal::set_value ( long long int value )
245948 : {
245949 0 : ROSE_ASSERT (this != NULL);
245950 :
245951 : #if 0
245952 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245953 : // used to trigger marking transformations for the token-based unparsing.
245954 : printf ("SgEnumVal::set_value = %p = %s \n",this,this->class_name().c_str());
245955 : #endif
245956 :
245957 0 : set_isModified(true);
245958 :
245959 0 : p_value = value;
245960 0 : }
245961 :
245962 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
245963 :
245964 :
245965 : // End of memberFunctionString
245966 : // Start of memberFunctionString
245967 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
245968 :
245969 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
245970 :
245971 : SgEnumDeclaration*
245972 41314 : SgEnumVal::get_declaration () const
245973 : {
245974 41314 : ROSE_ASSERT (this != NULL);
245975 :
245976 : #if 0
245977 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245978 : // used to trigger marking transformations for the token-based unparsing.
245979 : printf ("SgEnumVal::get_declaration = %p = %s \n",this,this->class_name().c_str());
245980 : #endif
245981 :
245982 41314 : return p_declaration;
245983 : }
245984 :
245985 : void
245986 0 : SgEnumVal::set_declaration ( SgEnumDeclaration* declaration )
245987 : {
245988 0 : ROSE_ASSERT (this != NULL);
245989 :
245990 : #if 0
245991 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
245992 : // used to trigger marking transformations for the token-based unparsing.
245993 : printf ("SgEnumVal::set_declaration = %p = %s \n",this,this->class_name().c_str());
245994 : #endif
245995 :
245996 0 : set_isModified(true);
245997 :
245998 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
245999 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
246000 : {
246001 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
246002 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
246003 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
246004 : ROSE_ASSERT(false);
246005 : #endif
246006 : }
246007 : #endif
246008 0 : p_declaration = declaration;
246009 0 : }
246010 :
246011 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246012 :
246013 :
246014 : // End of memberFunctionString
246015 : // Start of memberFunctionString
246016 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
246017 :
246018 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
246019 :
246020 : SgName
246021 5554 : SgEnumVal::get_name () const
246022 : {
246023 5554 : ROSE_ASSERT (this != NULL);
246024 :
246025 : #if 0
246026 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246027 : // used to trigger marking transformations for the token-based unparsing.
246028 : printf ("SgEnumVal::get_name = %p = %s \n",this,this->class_name().c_str());
246029 : #endif
246030 :
246031 5554 : return p_name;
246032 : }
246033 :
246034 : void
246035 0 : SgEnumVal::set_name ( SgName name )
246036 : {
246037 0 : ROSE_ASSERT (this != NULL);
246038 :
246039 : #if 0
246040 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246041 : // used to trigger marking transformations for the token-based unparsing.
246042 : printf ("SgEnumVal::set_name = %p = %s \n",this,this->class_name().c_str());
246043 : #endif
246044 :
246045 0 : set_isModified(true);
246046 :
246047 0 : p_name = name;
246048 0 : }
246049 :
246050 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246051 :
246052 :
246053 : // End of memberFunctionString
246054 : // Start of memberFunctionString
246055 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
246056 :
246057 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
246058 :
246059 : bool
246060 93 : SgEnumVal::get_requiresNameQualification () const
246061 : {
246062 93 : ROSE_ASSERT (this != NULL);
246063 :
246064 : #if 0
246065 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246066 : // used to trigger marking transformations for the token-based unparsing.
246067 : printf ("SgEnumVal::get_requiresNameQualification = %p = %s \n",this,this->class_name().c_str());
246068 : #endif
246069 :
246070 93 : return p_requiresNameQualification;
246071 : }
246072 :
246073 : void
246074 0 : SgEnumVal::set_requiresNameQualification ( bool requiresNameQualification )
246075 : {
246076 0 : ROSE_ASSERT (this != NULL);
246077 :
246078 : #if 0
246079 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246080 : // used to trigger marking transformations for the token-based unparsing.
246081 : printf ("SgEnumVal::set_requiresNameQualification = %p = %s \n",this,this->class_name().c_str());
246082 : #endif
246083 :
246084 0 : set_isModified(true);
246085 :
246086 0 : p_requiresNameQualification = requiresNameQualification;
246087 0 : }
246088 :
246089 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246090 :
246091 :
246092 : // End of memberFunctionString
246093 : // Start of memberFunctionString
246094 :
246095 :
246096 : // End of memberFunctionString
246097 : // Start of memberFunctionString
246098 : /* #line 4173 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246099 :
246100 :
246101 : // DQ (2/5/2020): Addedin custom get_type() function so that we can pass the associated SgEnumDeclaration.
246102 22663 : SgType* SgEnumVal::get_type() const
246103 : {
246104 : #if 0
246105 : printf ("In SgEnumVal::get_type() \n");
246106 : #endif
246107 :
246108 22663 : SgEnumDeclaration* enumDeclaration = this->get_declaration();
246109 22663 : ROSE_ASSERT(enumDeclaration != NULL);
246110 :
246111 22663 : return SgEnumType::createType(enumDeclaration);
246112 : }
246113 :
246114 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
246115 : // so that we could avoid them setting the isModified flag which is a problem in the
246116 : // name qualification support for C++ (interfering with the token-based unparsing).
246117 : int
246118 0 : SgEnumVal::get_name_qualification_length () const
246119 : {
246120 0 : ROSE_ASSERT (this != NULL);
246121 0 : return p_name_qualification_length;
246122 : }
246123 :
246124 : void
246125 5141 : SgEnumVal::set_name_qualification_length ( int name_qualification_length )
246126 : {
246127 5141 : ROSE_ASSERT (this != NULL);
246128 : // This can't be called by the name qualification API (see test2015_26.C).
246129 : // set_isModified(true);
246130 :
246131 5141 : p_name_qualification_length = name_qualification_length;
246132 5141 : }
246133 :
246134 : bool
246135 0 : SgEnumVal::get_type_elaboration_required () const
246136 : {
246137 0 : ROSE_ASSERT (this != NULL);
246138 0 : return p_type_elaboration_required;
246139 : }
246140 :
246141 : void
246142 5141 : SgEnumVal::set_type_elaboration_required ( bool type_elaboration_required )
246143 : {
246144 5141 : ROSE_ASSERT (this != NULL);
246145 : // This can't be called by the name qualification API (see test2015_26.C).
246146 : // set_isModified(true);
246147 :
246148 5141 : p_type_elaboration_required = type_elaboration_required;
246149 5141 : }
246150 :
246151 : bool
246152 0 : SgEnumVal::get_global_qualification_required () const
246153 : {
246154 0 : ROSE_ASSERT (this != NULL);
246155 0 : return p_global_qualification_required;
246156 : }
246157 :
246158 : void
246159 5141 : SgEnumVal::set_global_qualification_required ( bool global_qualification_required )
246160 : {
246161 5141 : ROSE_ASSERT (this != NULL);
246162 :
246163 : // This can't be called by the name qualification API (see test2015_26.C).
246164 : // set_isModified(true);
246165 :
246166 5141 : p_global_qualification_required = global_qualification_required;
246167 5141 : }
246168 :
246169 :
246170 :
246171 : // End of memberFunctionString
246172 : // Start of memberFunctionString
246173 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
246174 :
246175 : // *** COMMON CODE SECTION BEGINS HERE ***
246176 :
246177 : #if 0
246178 : int
246179 : SgEnumVal::getVariant() const
246180 : {
246181 : // This function is used in ROSE while "variant()" is used in SAGE
246182 : assert(this != NULL);
246183 : return variant();
246184 : }
246185 : #endif
246186 :
246187 : // This function is used in ROSE in treeTraversal code
246188 : // eventually replaces getVariant() and variant()
246189 : // though after variant() has been removed for a while we will
246190 : // want to change the name of variantT() back to variant()
246191 : // (since the "T" was ment to stand for temporary).
246192 : // When this happens the variantT() will be depricated.
246193 : VariantT
246194 1786060 : SgEnumVal::variantT() const
246195 : {
246196 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
246197 1786060 : ROSE_ASSERT(this != NULL);
246198 1786060 : return V_SgEnumVal;
246199 : }
246200 :
246201 : #if 0
246202 : int
246203 : SgEnumVal::variant() const
246204 : {
246205 : // This function is used in SAGE
246206 : ROSE_ASSERT(this != NULL);
246207 : return ENUM_VAL;
246208 : }
246209 : #endif
246210 :
246211 : ROSE_DLL_API const char*
246212 36 : SgEnumVal::sage_class_name() const
246213 : {
246214 36 : ROSE_ASSERT(this != NULL);
246215 36 : return "SgEnumVal";
246216 : }
246217 :
246218 : std::string
246219 8669 : SgEnumVal::class_name() const
246220 : {
246221 8669 : ROSE_ASSERT(this != NULL);
246222 8669 : return "SgEnumVal";
246223 : }
246224 :
246225 : // DQ (11/26/2005): Support for visitor pattern mechanims
246226 : // (inferior to ROSE traversal mechanism, experimental).
246227 : void
246228 77066 : SgEnumVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
246229 : {
246230 77066 : ROSE_ASSERT(this != NULL);
246231 77066 : visitor.visit(this);
246232 77066 : }
246233 :
246234 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
246235 0 : void SgEnumVal::accept (ROSE_VisitorPattern & visitor) {
246236 0 : ROSE_ASSERT(this != NULL);
246237 0 : visitor.visit(this);
246238 0 : }
246239 :
246240 : SgEnumVal*
246241 0 : SgEnumVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
246242 : {
246243 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
246244 : // This function is currently only supported for the AST used the represent Binary executables.
246245 : if (0 /* isSgAsmNode(this) != NULL */)
246246 : {
246247 : // Support for regex specification.
246248 : std::string prefixCode = "REGEX:";
246249 : addNewAttribute(prefixCode + s,a);
246250 : }
246251 : #endif
246252 :
246253 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
246254 0 : return this;
246255 : }
246256 :
246257 : // *** COMMON CODE SECTION ENDS HERE ***
246258 :
246259 :
246260 : // End of memberFunctionString
246261 : // Start of memberFunctionString
246262 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
246263 :
246264 :
246265 : #if 0
246266 : //! Error checking support
246267 : /*! Verifies the following:
246268 : - working getVariant() member function
246269 : - calls base class's error() member function
246270 : Every class has one of these functions.
246271 : */
246272 : bool
246273 : SgEnumVal::error()
246274 : {
246275 : // Put error checking here
246276 :
246277 : ROSE_ASSERT (this != NULL);
246278 : if (getVariant() != ENUM_VAL)
246279 : {
246280 : printf ("Error in SgEnumVal::error(): SgEnumVal object has a %s variant \n",
246281 : Cxx_GrammarTerminalNames[getVariant()].name);
246282 : // printf ("Error in SgEnumVal::error() \n");
246283 : ROSE_ABORT();
246284 : }
246285 :
246286 : ROSE_ASSERT (getVariant() == ENUM_VAL);
246287 : return SgValueExp::error();
246288 : }
246289 : #endif
246290 :
246291 :
246292 :
246293 : // End of memberFunctionString
246294 :
246295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
246296 :
246297 2850530 : SgEnumVal* isSgEnumVal ( SgNode* inputDerivedClassPointer )
246298 : {
246299 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
246300 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
246301 : // So to fix this we return NULL directly when the input is NULL and avoid the
246302 : // dynamic_cast in this case. This is likely a performance improvement as well.
246303 : // return dynamic_cast<SgEnumVal*>(inputDerivedClassPointer);
246304 : // Milind Chabbi (8/28/2013): isSgEnumVal uses table-driven castability instead of c++ default dynamic_cast
246305 : // this improves the running time performance by 10-20%.
246306 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEnumVal*>(inputDerivedClassPointer);
246307 2850530 : return IS_SgEnumVal_FAST_MACRO(inputDerivedClassPointer);
246308 : }
246309 :
246310 : // DQ (11/8/2003): Added version of functions taking const pointer
246311 0 : const SgEnumVal* isSgEnumVal ( const SgNode* inputDerivedClassPointer )
246312 : {
246313 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
246314 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
246315 : // So to fix this we return NULL directly when the input is NULL and avoid the
246316 : // dynamic_cast in this case. This is likely a performance improvement as well.
246317 : // return dynamic_cast<const SgEnumVal*>(inputDerivedClassPointer);
246318 : // Milind Chabbi (8/28/2013): isSgEnumVal uses table-driven castability instead of c++ default dynamic_cast
246319 : // this improves the running time performance by 10-20%.
246320 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEnumVal*>(inputDerivedClassPointer);
246321 0 : return IS_SgEnumVal_FAST_MACRO(inputDerivedClassPointer);
246322 : }
246323 :
246324 :
246325 :
246326 : /* #line 246327 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246327 :
246328 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
246329 :
246330 : /**
246331 : \brief Generated destructor
246332 :
246333 : This destructor is automatically generated (by ROSETTA). This destructor
246334 : only frees memory of data members associated with the parts of the current IR node which
246335 : are NOT traversed. Those data members that are part of a traversal can be freed using
246336 : a traversal (calling this destructor on all children in a post-order traversal). Such
246337 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
246338 :
246339 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
246340 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
246341 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
246342 :
246343 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
246344 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
246345 : pointers are not yet implemented to call delete on eash pointer in the container.
246346 : (This could be done by derivation from the STL containers to define containers that
246347 : automatically deleted their members.)
246348 :
246349 : */
246350 8026 : SgEnumVal::~SgEnumVal () {
246351 4013 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
246352 :
246353 :
246354 : // case: not a listType for value
246355 4013 : p_value = 0; // non list case
246356 : // case: not a listType for declaration
246357 4013 : p_declaration = NULL; // non list case
246358 : // case: not a listType for name
246359 4013 : p_name = ""; // non list case
246360 : // case: not a listType for requiresNameQualification
246361 4013 : p_requiresNameQualification = false; // non list case
246362 : // case: not a listType for name_qualification_length
246363 4013 : p_name_qualification_length = 0; // non list case
246364 : // case: not a listType for type_elaboration_required
246365 4013 : p_type_elaboration_required = false; // non list case
246366 : // case: not a listType for global_qualification_required
246367 4013 : p_global_qualification_required = false; // non list case
246368 :
246369 : }
246370 :
246371 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
246372 8026 : }
246373 :
246374 :
246375 : /* #line 246376 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246376 :
246377 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
246378 :
246379 : // Generated constructor
246380 74 : SgEnumVal::SgEnumVal ( Sg_File_Info* startOfConstruct, long long int value, SgEnumDeclaration* declaration, SgName name )
246381 74 : : SgValueExp(startOfConstruct)
246382 : {
246383 : #ifdef DEBUG
246384 : // printf ("In SgEnumVal::SgEnumVal (Sg_File_Info* startOfConstruct, long long int value, SgEnumDeclaration* declaration, SgName name) sage_class_name() = %s \n",sage_class_name());
246385 : #endif
246386 : #if 0
246387 : // debugging information!
246388 : printf ("In SgEnumVal::SgEnumVal (Sg_File_Info* startOfConstruct, long long int value, SgEnumDeclaration* declaration, SgName name): this = %p = %s \n",this,this->class_name().c_str());
246389 : #endif
246390 :
246391 74 : p_value = value;
246392 74 : p_declaration = declaration;
246393 74 : p_name = name;
246394 74 : p_requiresNameQualification = false;
246395 74 : p_name_qualification_length = 0;
246396 74 : p_type_elaboration_required = false;
246397 74 : p_global_qualification_required = false;
246398 :
246399 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
246400 :
246401 : #if 0
246402 : // DQ (7/30/2014): Call a virtual function.
246403 : std::string s = this->class_name();
246404 : #endif
246405 :
246406 : // Test the variant virtual function
246407 : // assert(ENUM_VAL == variant());
246408 74 : assert(ENUM_VAL == this->variant());
246409 74 : ROSE_ASSERT(ENUM_VAL == (int)(this->variantT()));
246410 74 : post_construction_initialization();
246411 :
246412 : // Test the isSgEnumVal() function since it has been problematic
246413 74 : assert(isSgEnumVal(this) != NULL);
246414 74 : }
246415 :
246416 : // Generated constructor (all data members)
246417 :
246418 : /* #line 246419 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246419 :
246420 :
246421 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
246422 :
246423 :
246424 : // ********************************************************
246425 : // member functions common across all array grammar objects
246426 : // ********************************************************
246427 :
246428 :
246429 :
246430 : /* #line 246431 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246431 :
246432 :
246433 :
246434 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
246435 :
246436 : // ********************************************************
246437 : // member functions specific to each node in the grammar
246438 : // ********************************************************
246439 :
246440 :
246441 : /* #line 246442 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246442 :
246443 : // Start of memberFunctionString
246444 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246445 :
246446 : void
246447 251 : SgUnsignedIntVal::post_construction_initialization()
246448 : {
246449 251 : }
246450 :
246451 :
246452 :
246453 : // End of memberFunctionString
246454 : // Start of memberFunctionString
246455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
246456 :
246457 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
246458 :
246459 : unsigned int
246460 303 : SgUnsignedIntVal::get_value () const
246461 : {
246462 303 : ROSE_ASSERT (this != NULL);
246463 :
246464 : #if 0
246465 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246466 : // used to trigger marking transformations for the token-based unparsing.
246467 : printf ("SgUnsignedIntVal::get_value = %p = %s \n",this,this->class_name().c_str());
246468 : #endif
246469 :
246470 303 : return p_value;
246471 : }
246472 :
246473 : void
246474 0 : SgUnsignedIntVal::set_value ( unsigned int value )
246475 : {
246476 0 : ROSE_ASSERT (this != NULL);
246477 :
246478 : #if 0
246479 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246480 : // used to trigger marking transformations for the token-based unparsing.
246481 : printf ("SgUnsignedIntVal::set_value = %p = %s \n",this,this->class_name().c_str());
246482 : #endif
246483 :
246484 0 : set_isModified(true);
246485 :
246486 0 : p_value = value;
246487 0 : }
246488 :
246489 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246490 :
246491 :
246492 : // End of memberFunctionString
246493 : // Start of memberFunctionString
246494 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
246495 :
246496 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
246497 :
246498 : std::string
246499 14 : SgUnsignedIntVal::get_valueString () const
246500 : {
246501 14 : ROSE_ASSERT (this != NULL);
246502 :
246503 : #if 0
246504 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246505 : // used to trigger marking transformations for the token-based unparsing.
246506 : printf ("SgUnsignedIntVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
246507 : #endif
246508 :
246509 14 : return p_valueString;
246510 : }
246511 :
246512 : void
246513 0 : SgUnsignedIntVal::set_valueString ( std::string valueString )
246514 : {
246515 0 : ROSE_ASSERT (this != NULL);
246516 :
246517 : #if 0
246518 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246519 : // used to trigger marking transformations for the token-based unparsing.
246520 : printf ("SgUnsignedIntVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
246521 : #endif
246522 :
246523 0 : set_isModified(true);
246524 :
246525 0 : p_valueString = valueString;
246526 0 : }
246527 :
246528 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246529 :
246530 :
246531 : // End of memberFunctionString
246532 : // Start of memberFunctionString
246533 : /* #line 4246 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246534 :
246535 :
246536 :
246537 : // End of memberFunctionString
246538 : // Start of memberFunctionString
246539 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246540 :
246541 :
246542 : SgType*
246543 30 : SgUnsignedIntVal::get_type(void) const
246544 : {
246545 : #if 0
246546 : printf ("In SgUnsignedIntVal::get_type() \n");
246547 : #endif
246548 :
246549 30 : return SgTypeUnsignedInt::createType();
246550 : }
246551 :
246552 :
246553 :
246554 : // End of memberFunctionString
246555 : // Start of memberFunctionString
246556 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
246557 :
246558 : // *** COMMON CODE SECTION BEGINS HERE ***
246559 :
246560 : #if 0
246561 : int
246562 : SgUnsignedIntVal::getVariant() const
246563 : {
246564 : // This function is used in ROSE while "variant()" is used in SAGE
246565 : assert(this != NULL);
246566 : return variant();
246567 : }
246568 : #endif
246569 :
246570 : // This function is used in ROSE in treeTraversal code
246571 : // eventually replaces getVariant() and variant()
246572 : // though after variant() has been removed for a while we will
246573 : // want to change the name of variantT() back to variant()
246574 : // (since the "T" was ment to stand for temporary).
246575 : // When this happens the variantT() will be depricated.
246576 : VariantT
246577 20585 : SgUnsignedIntVal::variantT() const
246578 : {
246579 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
246580 20585 : ROSE_ASSERT(this != NULL);
246581 20585 : return V_SgUnsignedIntVal;
246582 : }
246583 :
246584 : #if 0
246585 : int
246586 : SgUnsignedIntVal::variant() const
246587 : {
246588 : // This function is used in SAGE
246589 : ROSE_ASSERT(this != NULL);
246590 : return UNSIGNED_INT_VAL;
246591 : }
246592 : #endif
246593 :
246594 : ROSE_DLL_API const char*
246595 0 : SgUnsignedIntVal::sage_class_name() const
246596 : {
246597 0 : ROSE_ASSERT(this != NULL);
246598 0 : return "SgUnsignedIntVal";
246599 : }
246600 :
246601 : std::string
246602 65 : SgUnsignedIntVal::class_name() const
246603 : {
246604 65 : ROSE_ASSERT(this != NULL);
246605 65 : return "SgUnsignedIntVal";
246606 : }
246607 :
246608 : // DQ (11/26/2005): Support for visitor pattern mechanims
246609 : // (inferior to ROSE traversal mechanism, experimental).
246610 : void
246611 1096 : SgUnsignedIntVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
246612 : {
246613 1096 : ROSE_ASSERT(this != NULL);
246614 1096 : visitor.visit(this);
246615 1096 : }
246616 :
246617 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
246618 0 : void SgUnsignedIntVal::accept (ROSE_VisitorPattern & visitor) {
246619 0 : ROSE_ASSERT(this != NULL);
246620 0 : visitor.visit(this);
246621 0 : }
246622 :
246623 : SgUnsignedIntVal*
246624 0 : SgUnsignedIntVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
246625 : {
246626 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
246627 : // This function is currently only supported for the AST used the represent Binary executables.
246628 : if (0 /* isSgAsmNode(this) != NULL */)
246629 : {
246630 : // Support for regex specification.
246631 : std::string prefixCode = "REGEX:";
246632 : addNewAttribute(prefixCode + s,a);
246633 : }
246634 : #endif
246635 :
246636 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
246637 0 : return this;
246638 : }
246639 :
246640 : // *** COMMON CODE SECTION ENDS HERE ***
246641 :
246642 :
246643 : // End of memberFunctionString
246644 : // Start of memberFunctionString
246645 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
246646 :
246647 :
246648 : #if 0
246649 : //! Error checking support
246650 : /*! Verifies the following:
246651 : - working getVariant() member function
246652 : - calls base class's error() member function
246653 : Every class has one of these functions.
246654 : */
246655 : bool
246656 : SgUnsignedIntVal::error()
246657 : {
246658 : // Put error checking here
246659 :
246660 : ROSE_ASSERT (this != NULL);
246661 : if (getVariant() != UNSIGNED_INT_VAL)
246662 : {
246663 : printf ("Error in SgUnsignedIntVal::error(): SgUnsignedIntVal object has a %s variant \n",
246664 : Cxx_GrammarTerminalNames[getVariant()].name);
246665 : // printf ("Error in SgUnsignedIntVal::error() \n");
246666 : ROSE_ABORT();
246667 : }
246668 :
246669 : ROSE_ASSERT (getVariant() == UNSIGNED_INT_VAL);
246670 : return SgValueExp::error();
246671 : }
246672 : #endif
246673 :
246674 :
246675 :
246676 : // End of memberFunctionString
246677 :
246678 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
246679 :
246680 51057 : SgUnsignedIntVal* isSgUnsignedIntVal ( SgNode* inputDerivedClassPointer )
246681 : {
246682 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
246683 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
246684 : // So to fix this we return NULL directly when the input is NULL and avoid the
246685 : // dynamic_cast in this case. This is likely a performance improvement as well.
246686 : // return dynamic_cast<SgUnsignedIntVal*>(inputDerivedClassPointer);
246687 : // Milind Chabbi (8/28/2013): isSgUnsignedIntVal uses table-driven castability instead of c++ default dynamic_cast
246688 : // this improves the running time performance by 10-20%.
246689 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnsignedIntVal*>(inputDerivedClassPointer);
246690 51057 : return IS_SgUnsignedIntVal_FAST_MACRO(inputDerivedClassPointer);
246691 : }
246692 :
246693 : // DQ (11/8/2003): Added version of functions taking const pointer
246694 275 : const SgUnsignedIntVal* isSgUnsignedIntVal ( const SgNode* inputDerivedClassPointer )
246695 : {
246696 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
246697 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
246698 : // So to fix this we return NULL directly when the input is NULL and avoid the
246699 : // dynamic_cast in this case. This is likely a performance improvement as well.
246700 : // return dynamic_cast<const SgUnsignedIntVal*>(inputDerivedClassPointer);
246701 : // Milind Chabbi (8/28/2013): isSgUnsignedIntVal uses table-driven castability instead of c++ default dynamic_cast
246702 : // this improves the running time performance by 10-20%.
246703 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnsignedIntVal*>(inputDerivedClassPointer);
246704 275 : return IS_SgUnsignedIntVal_FAST_MACRO(inputDerivedClassPointer);
246705 : }
246706 :
246707 :
246708 :
246709 : /* #line 246710 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246710 :
246711 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
246712 :
246713 : /**
246714 : \brief Generated destructor
246715 :
246716 : This destructor is automatically generated (by ROSETTA). This destructor
246717 : only frees memory of data members associated with the parts of the current IR node which
246718 : are NOT traversed. Those data members that are part of a traversal can be freed using
246719 : a traversal (calling this destructor on all children in a post-order traversal). Such
246720 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
246721 :
246722 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
246723 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
246724 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
246725 :
246726 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
246727 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
246728 : pointers are not yet implemented to call delete on eash pointer in the container.
246729 : (This could be done by derivation from the STL containers to define containers that
246730 : automatically deleted their members.)
246731 :
246732 : */
246733 372 : SgUnsignedIntVal::~SgUnsignedIntVal () {
246734 186 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
246735 :
246736 :
246737 : // case: not a listType for value
246738 186 : p_value = 0; // non list case
246739 : // case: not a listType for valueString
246740 186 : p_valueString = ""; // non list case
246741 :
246742 : }
246743 :
246744 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
246745 372 : }
246746 :
246747 :
246748 : /* #line 246749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246749 :
246750 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
246751 :
246752 : // Generated constructor
246753 0 : SgUnsignedIntVal::SgUnsignedIntVal ( Sg_File_Info* startOfConstruct, unsigned int value, std::string valueString )
246754 0 : : SgValueExp(startOfConstruct)
246755 : {
246756 : #ifdef DEBUG
246757 : // printf ("In SgUnsignedIntVal::SgUnsignedIntVal (Sg_File_Info* startOfConstruct, unsigned int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
246758 : #endif
246759 : #if 0
246760 : // debugging information!
246761 : printf ("In SgUnsignedIntVal::SgUnsignedIntVal (Sg_File_Info* startOfConstruct, unsigned int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
246762 : #endif
246763 :
246764 0 : p_value = value;
246765 0 : p_valueString = valueString;
246766 :
246767 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
246768 :
246769 : #if 0
246770 : // DQ (7/30/2014): Call a virtual function.
246771 : std::string s = this->class_name();
246772 : #endif
246773 :
246774 : // Test the variant virtual function
246775 : // assert(UNSIGNED_INT_VAL == variant());
246776 0 : assert(UNSIGNED_INT_VAL == this->variant());
246777 0 : ROSE_ASSERT(UNSIGNED_INT_VAL == (int)(this->variantT()));
246778 0 : post_construction_initialization();
246779 :
246780 : // Test the isSgUnsignedIntVal() function since it has been problematic
246781 0 : assert(isSgUnsignedIntVal(this) != NULL);
246782 0 : }
246783 :
246784 : // Generated constructor (all data members)
246785 :
246786 : /* #line 246787 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246787 :
246788 :
246789 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
246790 :
246791 :
246792 : // ********************************************************
246793 : // member functions common across all array grammar objects
246794 : // ********************************************************
246795 :
246796 :
246797 :
246798 : /* #line 246799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246799 :
246800 :
246801 :
246802 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
246803 :
246804 : // ********************************************************
246805 : // member functions specific to each node in the grammar
246806 : // ********************************************************
246807 :
246808 :
246809 : /* #line 246810 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
246810 :
246811 : // Start of memberFunctionString
246812 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246813 :
246814 : void
246815 1927 : SgLongIntVal::post_construction_initialization()
246816 : {
246817 1927 : }
246818 :
246819 :
246820 :
246821 : // End of memberFunctionString
246822 : // Start of memberFunctionString
246823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
246824 :
246825 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
246826 :
246827 : long int
246828 27 : SgLongIntVal::get_value () const
246829 : {
246830 27 : ROSE_ASSERT (this != NULL);
246831 :
246832 : #if 0
246833 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246834 : // used to trigger marking transformations for the token-based unparsing.
246835 : printf ("SgLongIntVal::get_value = %p = %s \n",this,this->class_name().c_str());
246836 : #endif
246837 :
246838 27 : return p_value;
246839 : }
246840 :
246841 : void
246842 0 : SgLongIntVal::set_value ( long int value )
246843 : {
246844 0 : ROSE_ASSERT (this != NULL);
246845 :
246846 : #if 0
246847 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246848 : // used to trigger marking transformations for the token-based unparsing.
246849 : printf ("SgLongIntVal::set_value = %p = %s \n",this,this->class_name().c_str());
246850 : #endif
246851 :
246852 0 : set_isModified(true);
246853 :
246854 0 : p_value = value;
246855 0 : }
246856 :
246857 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246858 :
246859 :
246860 : // End of memberFunctionString
246861 : // Start of memberFunctionString
246862 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
246863 :
246864 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
246865 :
246866 : std::string
246867 1 : SgLongIntVal::get_valueString () const
246868 : {
246869 1 : ROSE_ASSERT (this != NULL);
246870 :
246871 : #if 0
246872 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246873 : // used to trigger marking transformations for the token-based unparsing.
246874 : printf ("SgLongIntVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
246875 : #endif
246876 :
246877 1 : return p_valueString;
246878 : }
246879 :
246880 : void
246881 0 : SgLongIntVal::set_valueString ( std::string valueString )
246882 : {
246883 0 : ROSE_ASSERT (this != NULL);
246884 :
246885 : #if 0
246886 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
246887 : // used to trigger marking transformations for the token-based unparsing.
246888 : printf ("SgLongIntVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
246889 : #endif
246890 :
246891 0 : set_isModified(true);
246892 :
246893 0 : p_valueString = valueString;
246894 0 : }
246895 :
246896 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
246897 :
246898 :
246899 : // End of memberFunctionString
246900 : // Start of memberFunctionString
246901 : /* #line 4250 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246902 :
246903 :
246904 :
246905 : // End of memberFunctionString
246906 : // Start of memberFunctionString
246907 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
246908 :
246909 :
246910 : SgType*
246911 163 : SgLongIntVal::get_type(void) const
246912 : {
246913 : #if 0
246914 : printf ("In SgLongIntVal::get_type() \n");
246915 : #endif
246916 :
246917 163 : return SgTypeLong::createType();
246918 : }
246919 :
246920 :
246921 :
246922 : // End of memberFunctionString
246923 : // Start of memberFunctionString
246924 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
246925 :
246926 : // *** COMMON CODE SECTION BEGINS HERE ***
246927 :
246928 : #if 0
246929 : int
246930 : SgLongIntVal::getVariant() const
246931 : {
246932 : // This function is used in ROSE while "variant()" is used in SAGE
246933 : assert(this != NULL);
246934 : return variant();
246935 : }
246936 : #endif
246937 :
246938 : // This function is used in ROSE in treeTraversal code
246939 : // eventually replaces getVariant() and variant()
246940 : // though after variant() has been removed for a while we will
246941 : // want to change the name of variantT() back to variant()
246942 : // (since the "T" was ment to stand for temporary).
246943 : // When this happens the variantT() will be depricated.
246944 : VariantT
246945 115236 : SgLongIntVal::variantT() const
246946 : {
246947 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
246948 115236 : ROSE_ASSERT(this != NULL);
246949 115236 : return V_SgLongIntVal;
246950 : }
246951 :
246952 : #if 0
246953 : int
246954 : SgLongIntVal::variant() const
246955 : {
246956 : // This function is used in SAGE
246957 : ROSE_ASSERT(this != NULL);
246958 : return LONG_INT_VAL;
246959 : }
246960 : #endif
246961 :
246962 : ROSE_DLL_API const char*
246963 9 : SgLongIntVal::sage_class_name() const
246964 : {
246965 9 : ROSE_ASSERT(this != NULL);
246966 9 : return "SgLongIntVal";
246967 : }
246968 :
246969 : std::string
246970 93 : SgLongIntVal::class_name() const
246971 : {
246972 93 : ROSE_ASSERT(this != NULL);
246973 93 : return "SgLongIntVal";
246974 : }
246975 :
246976 : // DQ (11/26/2005): Support for visitor pattern mechanims
246977 : // (inferior to ROSE traversal mechanism, experimental).
246978 : void
246979 1781 : SgLongIntVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
246980 : {
246981 1781 : ROSE_ASSERT(this != NULL);
246982 1781 : visitor.visit(this);
246983 1781 : }
246984 :
246985 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
246986 0 : void SgLongIntVal::accept (ROSE_VisitorPattern & visitor) {
246987 0 : ROSE_ASSERT(this != NULL);
246988 0 : visitor.visit(this);
246989 0 : }
246990 :
246991 : SgLongIntVal*
246992 0 : SgLongIntVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
246993 : {
246994 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
246995 : // This function is currently only supported for the AST used the represent Binary executables.
246996 : if (0 /* isSgAsmNode(this) != NULL */)
246997 : {
246998 : // Support for regex specification.
246999 : std::string prefixCode = "REGEX:";
247000 : addNewAttribute(prefixCode + s,a);
247001 : }
247002 : #endif
247003 :
247004 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
247005 0 : return this;
247006 : }
247007 :
247008 : // *** COMMON CODE SECTION ENDS HERE ***
247009 :
247010 :
247011 : // End of memberFunctionString
247012 : // Start of memberFunctionString
247013 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
247014 :
247015 :
247016 : #if 0
247017 : //! Error checking support
247018 : /*! Verifies the following:
247019 : - working getVariant() member function
247020 : - calls base class's error() member function
247021 : Every class has one of these functions.
247022 : */
247023 : bool
247024 : SgLongIntVal::error()
247025 : {
247026 : // Put error checking here
247027 :
247028 : ROSE_ASSERT (this != NULL);
247029 : if (getVariant() != LONG_INT_VAL)
247030 : {
247031 : printf ("Error in SgLongIntVal::error(): SgLongIntVal object has a %s variant \n",
247032 : Cxx_GrammarTerminalNames[getVariant()].name);
247033 : // printf ("Error in SgLongIntVal::error() \n");
247034 : ROSE_ABORT();
247035 : }
247036 :
247037 : ROSE_ASSERT (getVariant() == LONG_INT_VAL);
247038 : return SgValueExp::error();
247039 : }
247040 : #endif
247041 :
247042 :
247043 :
247044 : // End of memberFunctionString
247045 :
247046 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
247047 :
247048 52736 : SgLongIntVal* isSgLongIntVal ( SgNode* inputDerivedClassPointer )
247049 : {
247050 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
247051 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
247052 : // So to fix this we return NULL directly when the input is NULL and avoid the
247053 : // dynamic_cast in this case. This is likely a performance improvement as well.
247054 : // return dynamic_cast<SgLongIntVal*>(inputDerivedClassPointer);
247055 : // Milind Chabbi (8/28/2013): isSgLongIntVal uses table-driven castability instead of c++ default dynamic_cast
247056 : // this improves the running time performance by 10-20%.
247057 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLongIntVal*>(inputDerivedClassPointer);
247058 52736 : return IS_SgLongIntVal_FAST_MACRO(inputDerivedClassPointer);
247059 : }
247060 :
247061 : // DQ (11/8/2003): Added version of functions taking const pointer
247062 0 : const SgLongIntVal* isSgLongIntVal ( const SgNode* inputDerivedClassPointer )
247063 : {
247064 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
247065 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
247066 : // So to fix this we return NULL directly when the input is NULL and avoid the
247067 : // dynamic_cast in this case. This is likely a performance improvement as well.
247068 : // return dynamic_cast<const SgLongIntVal*>(inputDerivedClassPointer);
247069 : // Milind Chabbi (8/28/2013): isSgLongIntVal uses table-driven castability instead of c++ default dynamic_cast
247070 : // this improves the running time performance by 10-20%.
247071 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLongIntVal*>(inputDerivedClassPointer);
247072 0 : return IS_SgLongIntVal_FAST_MACRO(inputDerivedClassPointer);
247073 : }
247074 :
247075 :
247076 :
247077 : /* #line 247078 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247078 :
247079 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
247080 :
247081 : /**
247082 : \brief Generated destructor
247083 :
247084 : This destructor is automatically generated (by ROSETTA). This destructor
247085 : only frees memory of data members associated with the parts of the current IR node which
247086 : are NOT traversed. Those data members that are part of a traversal can be freed using
247087 : a traversal (calling this destructor on all children in a post-order traversal). Such
247088 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
247089 :
247090 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
247091 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
247092 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
247093 :
247094 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
247095 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
247096 : pointers are not yet implemented to call delete on eash pointer in the container.
247097 : (This could be done by derivation from the STL containers to define containers that
247098 : automatically deleted their members.)
247099 :
247100 : */
247101 3688 : SgLongIntVal::~SgLongIntVal () {
247102 1844 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
247103 :
247104 :
247105 : // case: not a listType for value
247106 1844 : p_value = 0; // non list case
247107 : // case: not a listType for valueString
247108 1844 : p_valueString = ""; // non list case
247109 :
247110 : }
247111 :
247112 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
247113 3688 : }
247114 :
247115 :
247116 : /* #line 247117 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247117 :
247118 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
247119 :
247120 : // Generated constructor
247121 0 : SgLongIntVal::SgLongIntVal ( Sg_File_Info* startOfConstruct, long int value, std::string valueString )
247122 0 : : SgValueExp(startOfConstruct)
247123 : {
247124 : #ifdef DEBUG
247125 : // printf ("In SgLongIntVal::SgLongIntVal (Sg_File_Info* startOfConstruct, long int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
247126 : #endif
247127 : #if 0
247128 : // debugging information!
247129 : printf ("In SgLongIntVal::SgLongIntVal (Sg_File_Info* startOfConstruct, long int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
247130 : #endif
247131 :
247132 0 : p_value = value;
247133 0 : p_valueString = valueString;
247134 :
247135 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
247136 :
247137 : #if 0
247138 : // DQ (7/30/2014): Call a virtual function.
247139 : std::string s = this->class_name();
247140 : #endif
247141 :
247142 : // Test the variant virtual function
247143 : // assert(LONG_INT_VAL == variant());
247144 0 : assert(LONG_INT_VAL == this->variant());
247145 0 : ROSE_ASSERT(LONG_INT_VAL == (int)(this->variantT()));
247146 0 : post_construction_initialization();
247147 :
247148 : // Test the isSgLongIntVal() function since it has been problematic
247149 0 : assert(isSgLongIntVal(this) != NULL);
247150 0 : }
247151 :
247152 : // Generated constructor (all data members)
247153 :
247154 : /* #line 247155 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247155 :
247156 :
247157 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
247158 :
247159 :
247160 : // ********************************************************
247161 : // member functions common across all array grammar objects
247162 : // ********************************************************
247163 :
247164 :
247165 :
247166 : /* #line 247167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247167 :
247168 :
247169 :
247170 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
247171 :
247172 : // ********************************************************
247173 : // member functions specific to each node in the grammar
247174 : // ********************************************************
247175 :
247176 :
247177 : /* #line 247178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247178 :
247179 : // Start of memberFunctionString
247180 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247181 :
247182 : void
247183 47 : SgLongLongIntVal::post_construction_initialization()
247184 : {
247185 47 : }
247186 :
247187 :
247188 :
247189 : // End of memberFunctionString
247190 : // Start of memberFunctionString
247191 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
247192 :
247193 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
247194 :
247195 : long long int
247196 1 : SgLongLongIntVal::get_value () const
247197 : {
247198 1 : ROSE_ASSERT (this != NULL);
247199 :
247200 : #if 0
247201 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247202 : // used to trigger marking transformations for the token-based unparsing.
247203 : printf ("SgLongLongIntVal::get_value = %p = %s \n",this,this->class_name().c_str());
247204 : #endif
247205 :
247206 1 : return p_value;
247207 : }
247208 :
247209 : void
247210 0 : SgLongLongIntVal::set_value ( long long int value )
247211 : {
247212 0 : ROSE_ASSERT (this != NULL);
247213 :
247214 : #if 0
247215 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247216 : // used to trigger marking transformations for the token-based unparsing.
247217 : printf ("SgLongLongIntVal::set_value = %p = %s \n",this,this->class_name().c_str());
247218 : #endif
247219 :
247220 0 : set_isModified(true);
247221 :
247222 0 : p_value = value;
247223 0 : }
247224 :
247225 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
247226 :
247227 :
247228 : // End of memberFunctionString
247229 : // Start of memberFunctionString
247230 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
247231 :
247232 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
247233 :
247234 : std::string
247235 1 : SgLongLongIntVal::get_valueString () const
247236 : {
247237 1 : ROSE_ASSERT (this != NULL);
247238 :
247239 : #if 0
247240 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247241 : // used to trigger marking transformations for the token-based unparsing.
247242 : printf ("SgLongLongIntVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
247243 : #endif
247244 :
247245 1 : return p_valueString;
247246 : }
247247 :
247248 : void
247249 0 : SgLongLongIntVal::set_valueString ( std::string valueString )
247250 : {
247251 0 : ROSE_ASSERT (this != NULL);
247252 :
247253 : #if 0
247254 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247255 : // used to trigger marking transformations for the token-based unparsing.
247256 : printf ("SgLongLongIntVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
247257 : #endif
247258 :
247259 0 : set_isModified(true);
247260 :
247261 0 : p_valueString = valueString;
247262 0 : }
247263 :
247264 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
247265 :
247266 :
247267 : // End of memberFunctionString
247268 : // Start of memberFunctionString
247269 : /* #line 4254 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247270 :
247271 :
247272 :
247273 : // End of memberFunctionString
247274 : // Start of memberFunctionString
247275 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247276 :
247277 :
247278 : SgType*
247279 1 : SgLongLongIntVal::get_type(void) const
247280 : {
247281 : #if 0
247282 : printf ("In SgLongLongIntVal::get_type() \n");
247283 : #endif
247284 :
247285 1 : return SgTypeLong::createType();
247286 : }
247287 :
247288 :
247289 :
247290 : // End of memberFunctionString
247291 : // Start of memberFunctionString
247292 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
247293 :
247294 : // *** COMMON CODE SECTION BEGINS HERE ***
247295 :
247296 : #if 0
247297 : int
247298 : SgLongLongIntVal::getVariant() const
247299 : {
247300 : // This function is used in ROSE while "variant()" is used in SAGE
247301 : assert(this != NULL);
247302 : return variant();
247303 : }
247304 : #endif
247305 :
247306 : // This function is used in ROSE in treeTraversal code
247307 : // eventually replaces getVariant() and variant()
247308 : // though after variant() has been removed for a while we will
247309 : // want to change the name of variantT() back to variant()
247310 : // (since the "T" was ment to stand for temporary).
247311 : // When this happens the variantT() will be depricated.
247312 : VariantT
247313 2935 : SgLongLongIntVal::variantT() const
247314 : {
247315 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
247316 2935 : ROSE_ASSERT(this != NULL);
247317 2935 : return V_SgLongLongIntVal;
247318 : }
247319 :
247320 : #if 0
247321 : int
247322 : SgLongLongIntVal::variant() const
247323 : {
247324 : // This function is used in SAGE
247325 : ROSE_ASSERT(this != NULL);
247326 : return LONG_LONG_INT_VAL;
247327 : }
247328 : #endif
247329 :
247330 : ROSE_DLL_API const char*
247331 0 : SgLongLongIntVal::sage_class_name() const
247332 : {
247333 0 : ROSE_ASSERT(this != NULL);
247334 0 : return "SgLongLongIntVal";
247335 : }
247336 :
247337 : std::string
247338 1 : SgLongLongIntVal::class_name() const
247339 : {
247340 1 : ROSE_ASSERT(this != NULL);
247341 1 : return "SgLongLongIntVal";
247342 : }
247343 :
247344 : // DQ (11/26/2005): Support for visitor pattern mechanims
247345 : // (inferior to ROSE traversal mechanism, experimental).
247346 : void
247347 0 : SgLongLongIntVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
247348 : {
247349 0 : ROSE_ASSERT(this != NULL);
247350 0 : visitor.visit(this);
247351 0 : }
247352 :
247353 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
247354 0 : void SgLongLongIntVal::accept (ROSE_VisitorPattern & visitor) {
247355 0 : ROSE_ASSERT(this != NULL);
247356 0 : visitor.visit(this);
247357 0 : }
247358 :
247359 : SgLongLongIntVal*
247360 0 : SgLongLongIntVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
247361 : {
247362 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
247363 : // This function is currently only supported for the AST used the represent Binary executables.
247364 : if (0 /* isSgAsmNode(this) != NULL */)
247365 : {
247366 : // Support for regex specification.
247367 : std::string prefixCode = "REGEX:";
247368 : addNewAttribute(prefixCode + s,a);
247369 : }
247370 : #endif
247371 :
247372 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
247373 0 : return this;
247374 : }
247375 :
247376 : // *** COMMON CODE SECTION ENDS HERE ***
247377 :
247378 :
247379 : // End of memberFunctionString
247380 : // Start of memberFunctionString
247381 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
247382 :
247383 :
247384 : #if 0
247385 : //! Error checking support
247386 : /*! Verifies the following:
247387 : - working getVariant() member function
247388 : - calls base class's error() member function
247389 : Every class has one of these functions.
247390 : */
247391 : bool
247392 : SgLongLongIntVal::error()
247393 : {
247394 : // Put error checking here
247395 :
247396 : ROSE_ASSERT (this != NULL);
247397 : if (getVariant() != LONG_LONG_INT_VAL)
247398 : {
247399 : printf ("Error in SgLongLongIntVal::error(): SgLongLongIntVal object has a %s variant \n",
247400 : Cxx_GrammarTerminalNames[getVariant()].name);
247401 : // printf ("Error in SgLongLongIntVal::error() \n");
247402 : ROSE_ABORT();
247403 : }
247404 :
247405 : ROSE_ASSERT (getVariant() == LONG_LONG_INT_VAL);
247406 : return SgValueExp::error();
247407 : }
247408 : #endif
247409 :
247410 :
247411 :
247412 : // End of memberFunctionString
247413 :
247414 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
247415 :
247416 50780 : SgLongLongIntVal* isSgLongLongIntVal ( SgNode* inputDerivedClassPointer )
247417 : {
247418 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
247419 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
247420 : // So to fix this we return NULL directly when the input is NULL and avoid the
247421 : // dynamic_cast in this case. This is likely a performance improvement as well.
247422 : // return dynamic_cast<SgLongLongIntVal*>(inputDerivedClassPointer);
247423 : // Milind Chabbi (8/28/2013): isSgLongLongIntVal uses table-driven castability instead of c++ default dynamic_cast
247424 : // this improves the running time performance by 10-20%.
247425 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLongLongIntVal*>(inputDerivedClassPointer);
247426 50780 : return IS_SgLongLongIntVal_FAST_MACRO(inputDerivedClassPointer);
247427 : }
247428 :
247429 : // DQ (11/8/2003): Added version of functions taking const pointer
247430 0 : const SgLongLongIntVal* isSgLongLongIntVal ( const SgNode* inputDerivedClassPointer )
247431 : {
247432 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
247433 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
247434 : // So to fix this we return NULL directly when the input is NULL and avoid the
247435 : // dynamic_cast in this case. This is likely a performance improvement as well.
247436 : // return dynamic_cast<const SgLongLongIntVal*>(inputDerivedClassPointer);
247437 : // Milind Chabbi (8/28/2013): isSgLongLongIntVal uses table-driven castability instead of c++ default dynamic_cast
247438 : // this improves the running time performance by 10-20%.
247439 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLongLongIntVal*>(inputDerivedClassPointer);
247440 0 : return IS_SgLongLongIntVal_FAST_MACRO(inputDerivedClassPointer);
247441 : }
247442 :
247443 :
247444 :
247445 : /* #line 247446 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247446 :
247447 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
247448 :
247449 : /**
247450 : \brief Generated destructor
247451 :
247452 : This destructor is automatically generated (by ROSETTA). This destructor
247453 : only frees memory of data members associated with the parts of the current IR node which
247454 : are NOT traversed. Those data members that are part of a traversal can be freed using
247455 : a traversal (calling this destructor on all children in a post-order traversal). Such
247456 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
247457 :
247458 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
247459 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
247460 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
247461 :
247462 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
247463 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
247464 : pointers are not yet implemented to call delete on eash pointer in the container.
247465 : (This could be done by derivation from the STL containers to define containers that
247466 : automatically deleted their members.)
247467 :
247468 : */
247469 92 : SgLongLongIntVal::~SgLongLongIntVal () {
247470 46 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
247471 :
247472 :
247473 : // case: not a listType for value
247474 46 : p_value = 0; // non list case
247475 : // case: not a listType for valueString
247476 46 : p_valueString = ""; // non list case
247477 :
247478 : }
247479 :
247480 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
247481 92 : }
247482 :
247483 :
247484 : /* #line 247485 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247485 :
247486 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
247487 :
247488 : // Generated constructor
247489 0 : SgLongLongIntVal::SgLongLongIntVal ( Sg_File_Info* startOfConstruct, long long int value, std::string valueString )
247490 0 : : SgValueExp(startOfConstruct)
247491 : {
247492 : #ifdef DEBUG
247493 : // printf ("In SgLongLongIntVal::SgLongLongIntVal (Sg_File_Info* startOfConstruct, long long int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
247494 : #endif
247495 : #if 0
247496 : // debugging information!
247497 : printf ("In SgLongLongIntVal::SgLongLongIntVal (Sg_File_Info* startOfConstruct, long long int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
247498 : #endif
247499 :
247500 0 : p_value = value;
247501 0 : p_valueString = valueString;
247502 :
247503 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
247504 :
247505 : #if 0
247506 : // DQ (7/30/2014): Call a virtual function.
247507 : std::string s = this->class_name();
247508 : #endif
247509 :
247510 : // Test the variant virtual function
247511 : // assert(LONG_LONG_INT_VAL == variant());
247512 0 : assert(LONG_LONG_INT_VAL == this->variant());
247513 0 : ROSE_ASSERT(LONG_LONG_INT_VAL == (int)(this->variantT()));
247514 0 : post_construction_initialization();
247515 :
247516 : // Test the isSgLongLongIntVal() function since it has been problematic
247517 0 : assert(isSgLongLongIntVal(this) != NULL);
247518 0 : }
247519 :
247520 : // Generated constructor (all data members)
247521 :
247522 : /* #line 247523 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247523 :
247524 :
247525 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
247526 :
247527 :
247528 : // ********************************************************
247529 : // member functions common across all array grammar objects
247530 : // ********************************************************
247531 :
247532 :
247533 :
247534 : /* #line 247535 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247535 :
247536 :
247537 :
247538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
247539 :
247540 : // ********************************************************
247541 : // member functions specific to each node in the grammar
247542 : // ********************************************************
247543 :
247544 :
247545 : /* #line 247546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247546 :
247547 : // Start of memberFunctionString
247548 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247549 :
247550 : void
247551 35 : SgUnsignedLongLongIntVal::post_construction_initialization()
247552 : {
247553 35 : }
247554 :
247555 :
247556 :
247557 : // End of memberFunctionString
247558 : // Start of memberFunctionString
247559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
247560 :
247561 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
247562 :
247563 : unsigned long long int
247564 1 : SgUnsignedLongLongIntVal::get_value () const
247565 : {
247566 1 : ROSE_ASSERT (this != NULL);
247567 :
247568 : #if 0
247569 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247570 : // used to trigger marking transformations for the token-based unparsing.
247571 : printf ("SgUnsignedLongLongIntVal::get_value = %p = %s \n",this,this->class_name().c_str());
247572 : #endif
247573 :
247574 1 : return p_value;
247575 : }
247576 :
247577 : void
247578 0 : SgUnsignedLongLongIntVal::set_value ( unsigned long long int value )
247579 : {
247580 0 : ROSE_ASSERT (this != NULL);
247581 :
247582 : #if 0
247583 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247584 : // used to trigger marking transformations for the token-based unparsing.
247585 : printf ("SgUnsignedLongLongIntVal::set_value = %p = %s \n",this,this->class_name().c_str());
247586 : #endif
247587 :
247588 0 : set_isModified(true);
247589 :
247590 0 : p_value = value;
247591 0 : }
247592 :
247593 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
247594 :
247595 :
247596 : // End of memberFunctionString
247597 : // Start of memberFunctionString
247598 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
247599 :
247600 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
247601 :
247602 : std::string
247603 3 : SgUnsignedLongLongIntVal::get_valueString () const
247604 : {
247605 3 : ROSE_ASSERT (this != NULL);
247606 :
247607 : #if 0
247608 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247609 : // used to trigger marking transformations for the token-based unparsing.
247610 : printf ("SgUnsignedLongLongIntVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
247611 : #endif
247612 :
247613 3 : return p_valueString;
247614 : }
247615 :
247616 : void
247617 0 : SgUnsignedLongLongIntVal::set_valueString ( std::string valueString )
247618 : {
247619 0 : ROSE_ASSERT (this != NULL);
247620 :
247621 : #if 0
247622 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247623 : // used to trigger marking transformations for the token-based unparsing.
247624 : printf ("SgUnsignedLongLongIntVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
247625 : #endif
247626 :
247627 0 : set_isModified(true);
247628 :
247629 0 : p_valueString = valueString;
247630 0 : }
247631 :
247632 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
247633 :
247634 :
247635 : // End of memberFunctionString
247636 : // Start of memberFunctionString
247637 : /* #line 4258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247638 :
247639 :
247640 :
247641 : // End of memberFunctionString
247642 : // Start of memberFunctionString
247643 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247644 :
247645 :
247646 : SgType*
247647 2 : SgUnsignedLongLongIntVal::get_type(void) const
247648 : {
247649 : #if 0
247650 : printf ("In SgUnsignedLongLongIntVal::get_type() \n");
247651 : #endif
247652 :
247653 2 : return SgTypeUnsignedLongLong::createType();
247654 : }
247655 :
247656 :
247657 :
247658 : // End of memberFunctionString
247659 : // Start of memberFunctionString
247660 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
247661 :
247662 : // *** COMMON CODE SECTION BEGINS HERE ***
247663 :
247664 : #if 0
247665 : int
247666 : SgUnsignedLongLongIntVal::getVariant() const
247667 : {
247668 : // This function is used in ROSE while "variant()" is used in SAGE
247669 : assert(this != NULL);
247670 : return variant();
247671 : }
247672 : #endif
247673 :
247674 : // This function is used in ROSE in treeTraversal code
247675 : // eventually replaces getVariant() and variant()
247676 : // though after variant() has been removed for a while we will
247677 : // want to change the name of variantT() back to variant()
247678 : // (since the "T" was ment to stand for temporary).
247679 : // When this happens the variantT() will be depricated.
247680 : VariantT
247681 2332 : SgUnsignedLongLongIntVal::variantT() const
247682 : {
247683 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
247684 2332 : ROSE_ASSERT(this != NULL);
247685 2332 : return V_SgUnsignedLongLongIntVal;
247686 : }
247687 :
247688 : #if 0
247689 : int
247690 : SgUnsignedLongLongIntVal::variant() const
247691 : {
247692 : // This function is used in SAGE
247693 : ROSE_ASSERT(this != NULL);
247694 : return UNSIGNED_LONG_LONG_INT_VAL;
247695 : }
247696 : #endif
247697 :
247698 : ROSE_DLL_API const char*
247699 0 : SgUnsignedLongLongIntVal::sage_class_name() const
247700 : {
247701 0 : ROSE_ASSERT(this != NULL);
247702 0 : return "SgUnsignedLongLongIntVal";
247703 : }
247704 :
247705 : std::string
247706 2 : SgUnsignedLongLongIntVal::class_name() const
247707 : {
247708 2 : ROSE_ASSERT(this != NULL);
247709 2 : return "SgUnsignedLongLongIntVal";
247710 : }
247711 :
247712 : // DQ (11/26/2005): Support for visitor pattern mechanims
247713 : // (inferior to ROSE traversal mechanism, experimental).
247714 : void
247715 0 : SgUnsignedLongLongIntVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
247716 : {
247717 0 : ROSE_ASSERT(this != NULL);
247718 0 : visitor.visit(this);
247719 0 : }
247720 :
247721 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
247722 0 : void SgUnsignedLongLongIntVal::accept (ROSE_VisitorPattern & visitor) {
247723 0 : ROSE_ASSERT(this != NULL);
247724 0 : visitor.visit(this);
247725 0 : }
247726 :
247727 : SgUnsignedLongLongIntVal*
247728 0 : SgUnsignedLongLongIntVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
247729 : {
247730 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
247731 : // This function is currently only supported for the AST used the represent Binary executables.
247732 : if (0 /* isSgAsmNode(this) != NULL */)
247733 : {
247734 : // Support for regex specification.
247735 : std::string prefixCode = "REGEX:";
247736 : addNewAttribute(prefixCode + s,a);
247737 : }
247738 : #endif
247739 :
247740 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
247741 0 : return this;
247742 : }
247743 :
247744 : // *** COMMON CODE SECTION ENDS HERE ***
247745 :
247746 :
247747 : // End of memberFunctionString
247748 : // Start of memberFunctionString
247749 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
247750 :
247751 :
247752 : #if 0
247753 : //! Error checking support
247754 : /*! Verifies the following:
247755 : - working getVariant() member function
247756 : - calls base class's error() member function
247757 : Every class has one of these functions.
247758 : */
247759 : bool
247760 : SgUnsignedLongLongIntVal::error()
247761 : {
247762 : // Put error checking here
247763 :
247764 : ROSE_ASSERT (this != NULL);
247765 : if (getVariant() != UNSIGNED_LONG_LONG_INT_VAL)
247766 : {
247767 : printf ("Error in SgUnsignedLongLongIntVal::error(): SgUnsignedLongLongIntVal object has a %s variant \n",
247768 : Cxx_GrammarTerminalNames[getVariant()].name);
247769 : // printf ("Error in SgUnsignedLongLongIntVal::error() \n");
247770 : ROSE_ABORT();
247771 : }
247772 :
247773 : ROSE_ASSERT (getVariant() == UNSIGNED_LONG_LONG_INT_VAL);
247774 : return SgValueExp::error();
247775 : }
247776 : #endif
247777 :
247778 :
247779 :
247780 : // End of memberFunctionString
247781 :
247782 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
247783 :
247784 50737 : SgUnsignedLongLongIntVal* isSgUnsignedLongLongIntVal ( SgNode* inputDerivedClassPointer )
247785 : {
247786 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
247787 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
247788 : // So to fix this we return NULL directly when the input is NULL and avoid the
247789 : // dynamic_cast in this case. This is likely a performance improvement as well.
247790 : // return dynamic_cast<SgUnsignedLongLongIntVal*>(inputDerivedClassPointer);
247791 : // Milind Chabbi (8/28/2013): isSgUnsignedLongLongIntVal uses table-driven castability instead of c++ default dynamic_cast
247792 : // this improves the running time performance by 10-20%.
247793 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnsignedLongLongIntVal*>(inputDerivedClassPointer);
247794 50737 : return IS_SgUnsignedLongLongIntVal_FAST_MACRO(inputDerivedClassPointer);
247795 : }
247796 :
247797 : // DQ (11/8/2003): Added version of functions taking const pointer
247798 0 : const SgUnsignedLongLongIntVal* isSgUnsignedLongLongIntVal ( const SgNode* inputDerivedClassPointer )
247799 : {
247800 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
247801 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
247802 : // So to fix this we return NULL directly when the input is NULL and avoid the
247803 : // dynamic_cast in this case. This is likely a performance improvement as well.
247804 : // return dynamic_cast<const SgUnsignedLongLongIntVal*>(inputDerivedClassPointer);
247805 : // Milind Chabbi (8/28/2013): isSgUnsignedLongLongIntVal uses table-driven castability instead of c++ default dynamic_cast
247806 : // this improves the running time performance by 10-20%.
247807 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnsignedLongLongIntVal*>(inputDerivedClassPointer);
247808 0 : return IS_SgUnsignedLongLongIntVal_FAST_MACRO(inputDerivedClassPointer);
247809 : }
247810 :
247811 :
247812 :
247813 : /* #line 247814 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247814 :
247815 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
247816 :
247817 : /**
247818 : \brief Generated destructor
247819 :
247820 : This destructor is automatically generated (by ROSETTA). This destructor
247821 : only frees memory of data members associated with the parts of the current IR node which
247822 : are NOT traversed. Those data members that are part of a traversal can be freed using
247823 : a traversal (calling this destructor on all children in a post-order traversal). Such
247824 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
247825 :
247826 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
247827 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
247828 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
247829 :
247830 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
247831 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
247832 : pointers are not yet implemented to call delete on eash pointer in the container.
247833 : (This could be done by derivation from the STL containers to define containers that
247834 : automatically deleted their members.)
247835 :
247836 : */
247837 66 : SgUnsignedLongLongIntVal::~SgUnsignedLongLongIntVal () {
247838 33 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
247839 :
247840 :
247841 : // case: not a listType for value
247842 33 : p_value = 0; // non list case
247843 : // case: not a listType for valueString
247844 33 : p_valueString = ""; // non list case
247845 :
247846 : }
247847 :
247848 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
247849 66 : }
247850 :
247851 :
247852 : /* #line 247853 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247853 :
247854 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
247855 :
247856 : // Generated constructor
247857 0 : SgUnsignedLongLongIntVal::SgUnsignedLongLongIntVal ( Sg_File_Info* startOfConstruct, unsigned long long int value, std::string valueString )
247858 0 : : SgValueExp(startOfConstruct)
247859 : {
247860 : #ifdef DEBUG
247861 : // printf ("In SgUnsignedLongLongIntVal::SgUnsignedLongLongIntVal (Sg_File_Info* startOfConstruct, unsigned long long int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
247862 : #endif
247863 : #if 0
247864 : // debugging information!
247865 : printf ("In SgUnsignedLongLongIntVal::SgUnsignedLongLongIntVal (Sg_File_Info* startOfConstruct, unsigned long long int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
247866 : #endif
247867 :
247868 0 : p_value = value;
247869 0 : p_valueString = valueString;
247870 :
247871 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
247872 :
247873 : #if 0
247874 : // DQ (7/30/2014): Call a virtual function.
247875 : std::string s = this->class_name();
247876 : #endif
247877 :
247878 : // Test the variant virtual function
247879 : // assert(UNSIGNED_LONG_LONG_INT_VAL == variant());
247880 0 : assert(UNSIGNED_LONG_LONG_INT_VAL == this->variant());
247881 0 : ROSE_ASSERT(UNSIGNED_LONG_LONG_INT_VAL == (int)(this->variantT()));
247882 0 : post_construction_initialization();
247883 :
247884 : // Test the isSgUnsignedLongLongIntVal() function since it has been problematic
247885 0 : assert(isSgUnsignedLongLongIntVal(this) != NULL);
247886 0 : }
247887 :
247888 : // Generated constructor (all data members)
247889 :
247890 : /* #line 247891 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247891 :
247892 :
247893 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
247894 :
247895 :
247896 : // ********************************************************
247897 : // member functions common across all array grammar objects
247898 : // ********************************************************
247899 :
247900 :
247901 :
247902 : /* #line 247903 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247903 :
247904 :
247905 :
247906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
247907 :
247908 : // ********************************************************
247909 : // member functions specific to each node in the grammar
247910 : // ********************************************************
247911 :
247912 :
247913 : /* #line 247914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
247914 :
247915 : // Start of memberFunctionString
247916 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
247917 :
247918 : void
247919 7864 : SgUnsignedLongVal::post_construction_initialization()
247920 : {
247921 7864 : }
247922 :
247923 :
247924 :
247925 : // End of memberFunctionString
247926 : // Start of memberFunctionString
247927 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
247928 :
247929 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
247930 :
247931 : unsigned long
247932 1165 : SgUnsignedLongVal::get_value () const
247933 : {
247934 1165 : ROSE_ASSERT (this != NULL);
247935 :
247936 : #if 0
247937 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247938 : // used to trigger marking transformations for the token-based unparsing.
247939 : printf ("SgUnsignedLongVal::get_value = %p = %s \n",this,this->class_name().c_str());
247940 : #endif
247941 :
247942 1165 : return p_value;
247943 : }
247944 :
247945 : void
247946 0 : SgUnsignedLongVal::set_value ( unsigned long value )
247947 : {
247948 0 : ROSE_ASSERT (this != NULL);
247949 :
247950 : #if 0
247951 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247952 : // used to trigger marking transformations for the token-based unparsing.
247953 : printf ("SgUnsignedLongVal::set_value = %p = %s \n",this,this->class_name().c_str());
247954 : #endif
247955 :
247956 0 : set_isModified(true);
247957 :
247958 0 : p_value = value;
247959 0 : }
247960 :
247961 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
247962 :
247963 :
247964 : // End of memberFunctionString
247965 : // Start of memberFunctionString
247966 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
247967 :
247968 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
247969 :
247970 : std::string
247971 741 : SgUnsignedLongVal::get_valueString () const
247972 : {
247973 741 : ROSE_ASSERT (this != NULL);
247974 :
247975 : #if 0
247976 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247977 : // used to trigger marking transformations for the token-based unparsing.
247978 : printf ("SgUnsignedLongVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
247979 : #endif
247980 :
247981 741 : return p_valueString;
247982 : }
247983 :
247984 : void
247985 0 : SgUnsignedLongVal::set_valueString ( std::string valueString )
247986 : {
247987 0 : ROSE_ASSERT (this != NULL);
247988 :
247989 : #if 0
247990 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
247991 : // used to trigger marking transformations for the token-based unparsing.
247992 : printf ("SgUnsignedLongVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
247993 : #endif
247994 :
247995 0 : set_isModified(true);
247996 :
247997 0 : p_valueString = valueString;
247998 0 : }
247999 :
248000 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
248001 :
248002 :
248003 : // End of memberFunctionString
248004 : // Start of memberFunctionString
248005 : /* #line 4262 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248006 :
248007 :
248008 :
248009 : // End of memberFunctionString
248010 : // Start of memberFunctionString
248011 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248012 :
248013 :
248014 : SgType*
248015 775 : SgUnsignedLongVal::get_type(void) const
248016 : {
248017 : #if 0
248018 : printf ("In SgUnsignedLongVal::get_type() \n");
248019 : #endif
248020 :
248021 775 : return SgTypeUnsignedLong::createType();
248022 : }
248023 :
248024 :
248025 :
248026 : // End of memberFunctionString
248027 : // Start of memberFunctionString
248028 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
248029 :
248030 : // *** COMMON CODE SECTION BEGINS HERE ***
248031 :
248032 : #if 0
248033 : int
248034 : SgUnsignedLongVal::getVariant() const
248035 : {
248036 : // This function is used in ROSE while "variant()" is used in SAGE
248037 : assert(this != NULL);
248038 : return variant();
248039 : }
248040 : #endif
248041 :
248042 : // This function is used in ROSE in treeTraversal code
248043 : // eventually replaces getVariant() and variant()
248044 : // though after variant() has been removed for a while we will
248045 : // want to change the name of variantT() back to variant()
248046 : // (since the "T" was ment to stand for temporary).
248047 : // When this happens the variantT() will be depricated.
248048 : VariantT
248049 506514 : SgUnsignedLongVal::variantT() const
248050 : {
248051 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
248052 506514 : ROSE_ASSERT(this != NULL);
248053 506514 : return V_SgUnsignedLongVal;
248054 : }
248055 :
248056 : #if 0
248057 : int
248058 : SgUnsignedLongVal::variant() const
248059 : {
248060 : // This function is used in SAGE
248061 : ROSE_ASSERT(this != NULL);
248062 : return UNSIGNED_LONG_INT_VAL;
248063 : }
248064 : #endif
248065 :
248066 : ROSE_DLL_API const char*
248067 12 : SgUnsignedLongVal::sage_class_name() const
248068 : {
248069 12 : ROSE_ASSERT(this != NULL);
248070 12 : return "SgUnsignedLongVal";
248071 : }
248072 :
248073 : std::string
248074 167 : SgUnsignedLongVal::class_name() const
248075 : {
248076 167 : ROSE_ASSERT(this != NULL);
248077 167 : return "SgUnsignedLongVal";
248078 : }
248079 :
248080 : // DQ (11/26/2005): Support for visitor pattern mechanims
248081 : // (inferior to ROSE traversal mechanism, experimental).
248082 : void
248083 2846 : SgUnsignedLongVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
248084 : {
248085 2846 : ROSE_ASSERT(this != NULL);
248086 2846 : visitor.visit(this);
248087 2846 : }
248088 :
248089 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
248090 0 : void SgUnsignedLongVal::accept (ROSE_VisitorPattern & visitor) {
248091 0 : ROSE_ASSERT(this != NULL);
248092 0 : visitor.visit(this);
248093 0 : }
248094 :
248095 : SgUnsignedLongVal*
248096 0 : SgUnsignedLongVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
248097 : {
248098 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
248099 : // This function is currently only supported for the AST used the represent Binary executables.
248100 : if (0 /* isSgAsmNode(this) != NULL */)
248101 : {
248102 : // Support for regex specification.
248103 : std::string prefixCode = "REGEX:";
248104 : addNewAttribute(prefixCode + s,a);
248105 : }
248106 : #endif
248107 :
248108 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
248109 0 : return this;
248110 : }
248111 :
248112 : // *** COMMON CODE SECTION ENDS HERE ***
248113 :
248114 :
248115 : // End of memberFunctionString
248116 : // Start of memberFunctionString
248117 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
248118 :
248119 :
248120 : #if 0
248121 : //! Error checking support
248122 : /*! Verifies the following:
248123 : - working getVariant() member function
248124 : - calls base class's error() member function
248125 : Every class has one of these functions.
248126 : */
248127 : bool
248128 : SgUnsignedLongVal::error()
248129 : {
248130 : // Put error checking here
248131 :
248132 : ROSE_ASSERT (this != NULL);
248133 : if (getVariant() != UNSIGNED_LONG_INT_VAL)
248134 : {
248135 : printf ("Error in SgUnsignedLongVal::error(): SgUnsignedLongVal object has a %s variant \n",
248136 : Cxx_GrammarTerminalNames[getVariant()].name);
248137 : // printf ("Error in SgUnsignedLongVal::error() \n");
248138 : ROSE_ABORT();
248139 : }
248140 :
248141 : ROSE_ASSERT (getVariant() == UNSIGNED_LONG_INT_VAL);
248142 : return SgValueExp::error();
248143 : }
248144 : #endif
248145 :
248146 :
248147 :
248148 : // End of memberFunctionString
248149 :
248150 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
248151 :
248152 59409 : SgUnsignedLongVal* isSgUnsignedLongVal ( SgNode* inputDerivedClassPointer )
248153 : {
248154 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
248155 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
248156 : // So to fix this we return NULL directly when the input is NULL and avoid the
248157 : // dynamic_cast in this case. This is likely a performance improvement as well.
248158 : // return dynamic_cast<SgUnsignedLongVal*>(inputDerivedClassPointer);
248159 : // Milind Chabbi (8/28/2013): isSgUnsignedLongVal uses table-driven castability instead of c++ default dynamic_cast
248160 : // this improves the running time performance by 10-20%.
248161 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnsignedLongVal*>(inputDerivedClassPointer);
248162 59409 : return IS_SgUnsignedLongVal_FAST_MACRO(inputDerivedClassPointer);
248163 : }
248164 :
248165 : // DQ (11/8/2003): Added version of functions taking const pointer
248166 378 : const SgUnsignedLongVal* isSgUnsignedLongVal ( const SgNode* inputDerivedClassPointer )
248167 : {
248168 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
248169 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
248170 : // So to fix this we return NULL directly when the input is NULL and avoid the
248171 : // dynamic_cast in this case. This is likely a performance improvement as well.
248172 : // return dynamic_cast<const SgUnsignedLongVal*>(inputDerivedClassPointer);
248173 : // Milind Chabbi (8/28/2013): isSgUnsignedLongVal uses table-driven castability instead of c++ default dynamic_cast
248174 : // this improves the running time performance by 10-20%.
248175 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnsignedLongVal*>(inputDerivedClassPointer);
248176 378 : return IS_SgUnsignedLongVal_FAST_MACRO(inputDerivedClassPointer);
248177 : }
248178 :
248179 :
248180 :
248181 : /* #line 248182 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248182 :
248183 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
248184 :
248185 : /**
248186 : \brief Generated destructor
248187 :
248188 : This destructor is automatically generated (by ROSETTA). This destructor
248189 : only frees memory of data members associated with the parts of the current IR node which
248190 : are NOT traversed. Those data members that are part of a traversal can be freed using
248191 : a traversal (calling this destructor on all children in a post-order traversal). Such
248192 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
248193 :
248194 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
248195 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
248196 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
248197 :
248198 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
248199 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
248200 : pointers are not yet implemented to call delete on eash pointer in the container.
248201 : (This could be done by derivation from the STL containers to define containers that
248202 : automatically deleted their members.)
248203 :
248204 : */
248205 15396 : SgUnsignedLongVal::~SgUnsignedLongVal () {
248206 7698 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
248207 :
248208 :
248209 : // case: not a listType for value
248210 7698 : p_value = 0; // non list case
248211 : // case: not a listType for valueString
248212 7698 : p_valueString = ""; // non list case
248213 :
248214 : }
248215 :
248216 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
248217 15396 : }
248218 :
248219 :
248220 : /* #line 248221 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248221 :
248222 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
248223 :
248224 : // Generated constructor
248225 0 : SgUnsignedLongVal::SgUnsignedLongVal ( Sg_File_Info* startOfConstruct, unsigned long value, std::string valueString )
248226 0 : : SgValueExp(startOfConstruct)
248227 : {
248228 : #ifdef DEBUG
248229 : // printf ("In SgUnsignedLongVal::SgUnsignedLongVal (Sg_File_Info* startOfConstruct, unsigned long value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
248230 : #endif
248231 : #if 0
248232 : // debugging information!
248233 : printf ("In SgUnsignedLongVal::SgUnsignedLongVal (Sg_File_Info* startOfConstruct, unsigned long value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
248234 : #endif
248235 :
248236 0 : p_value = value;
248237 0 : p_valueString = valueString;
248238 :
248239 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
248240 :
248241 : #if 0
248242 : // DQ (7/30/2014): Call a virtual function.
248243 : std::string s = this->class_name();
248244 : #endif
248245 :
248246 : // Test the variant virtual function
248247 : // assert(UNSIGNED_LONG_INT_VAL == variant());
248248 0 : assert(UNSIGNED_LONG_INT_VAL == this->variant());
248249 0 : ROSE_ASSERT(UNSIGNED_LONG_INT_VAL == (int)(this->variantT()));
248250 0 : post_construction_initialization();
248251 :
248252 : // Test the isSgUnsignedLongVal() function since it has been problematic
248253 0 : assert(isSgUnsignedLongVal(this) != NULL);
248254 0 : }
248255 :
248256 : // Generated constructor (all data members)
248257 :
248258 : /* #line 248259 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248259 :
248260 :
248261 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
248262 :
248263 :
248264 : // ********************************************************
248265 : // member functions common across all array grammar objects
248266 : // ********************************************************
248267 :
248268 :
248269 :
248270 : /* #line 248271 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248271 :
248272 :
248273 :
248274 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
248275 :
248276 : // ********************************************************
248277 : // member functions specific to each node in the grammar
248278 : // ********************************************************
248279 :
248280 :
248281 : /* #line 248282 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248282 :
248283 : // Start of memberFunctionString
248284 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248285 :
248286 : void
248287 121 : SgFloatVal::post_construction_initialization()
248288 : {
248289 121 : }
248290 :
248291 :
248292 :
248293 : // End of memberFunctionString
248294 : // Start of memberFunctionString
248295 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
248296 :
248297 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
248298 :
248299 : float
248300 10 : SgFloatVal::get_value () const
248301 : {
248302 10 : ROSE_ASSERT (this != NULL);
248303 :
248304 : #if 0
248305 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248306 : // used to trigger marking transformations for the token-based unparsing.
248307 : printf ("SgFloatVal::get_value = %p = %s \n",this,this->class_name().c_str());
248308 : #endif
248309 :
248310 10 : return p_value;
248311 : }
248312 :
248313 : void
248314 0 : SgFloatVal::set_value ( float value )
248315 : {
248316 0 : ROSE_ASSERT (this != NULL);
248317 :
248318 : #if 0
248319 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248320 : // used to trigger marking transformations for the token-based unparsing.
248321 : printf ("SgFloatVal::set_value = %p = %s \n",this,this->class_name().c_str());
248322 : #endif
248323 :
248324 0 : set_isModified(true);
248325 :
248326 0 : p_value = value;
248327 0 : }
248328 :
248329 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
248330 :
248331 :
248332 : // End of memberFunctionString
248333 : // Start of memberFunctionString
248334 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
248335 :
248336 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
248337 :
248338 : std::string
248339 15 : SgFloatVal::get_valueString () const
248340 : {
248341 15 : ROSE_ASSERT (this != NULL);
248342 :
248343 : #if 0
248344 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248345 : // used to trigger marking transformations for the token-based unparsing.
248346 : printf ("SgFloatVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
248347 : #endif
248348 :
248349 15 : return p_valueString;
248350 : }
248351 :
248352 : void
248353 0 : SgFloatVal::set_valueString ( std::string valueString )
248354 : {
248355 0 : ROSE_ASSERT (this != NULL);
248356 :
248357 : #if 0
248358 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248359 : // used to trigger marking transformations for the token-based unparsing.
248360 : printf ("SgFloatVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
248361 : #endif
248362 :
248363 0 : set_isModified(true);
248364 :
248365 0 : p_valueString = valueString;
248366 0 : }
248367 :
248368 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
248369 :
248370 :
248371 : // End of memberFunctionString
248372 : // Start of memberFunctionString
248373 : /* #line 4266 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248374 :
248375 :
248376 :
248377 : // End of memberFunctionString
248378 : // Start of memberFunctionString
248379 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248380 :
248381 :
248382 : SgType*
248383 28 : SgFloatVal::get_type(void) const
248384 : {
248385 : #if 0
248386 : printf ("In SgFloatVal::get_type() \n");
248387 : #endif
248388 :
248389 28 : return SgTypeFloat::createType();
248390 : }
248391 :
248392 :
248393 :
248394 : // End of memberFunctionString
248395 : // Start of memberFunctionString
248396 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
248397 :
248398 : // *** COMMON CODE SECTION BEGINS HERE ***
248399 :
248400 : #if 0
248401 : int
248402 : SgFloatVal::getVariant() const
248403 : {
248404 : // This function is used in ROSE while "variant()" is used in SAGE
248405 : assert(this != NULL);
248406 : return variant();
248407 : }
248408 : #endif
248409 :
248410 : // This function is used in ROSE in treeTraversal code
248411 : // eventually replaces getVariant() and variant()
248412 : // though after variant() has been removed for a while we will
248413 : // want to change the name of variantT() back to variant()
248414 : // (since the "T" was ment to stand for temporary).
248415 : // When this happens the variantT() will be depricated.
248416 : VariantT
248417 13114 : SgFloatVal::variantT() const
248418 : {
248419 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
248420 13114 : ROSE_ASSERT(this != NULL);
248421 13114 : return V_SgFloatVal;
248422 : }
248423 :
248424 : #if 0
248425 : int
248426 : SgFloatVal::variant() const
248427 : {
248428 : // This function is used in SAGE
248429 : ROSE_ASSERT(this != NULL);
248430 : return FLOAT_VAL;
248431 : }
248432 : #endif
248433 :
248434 : ROSE_DLL_API const char*
248435 10 : SgFloatVal::sage_class_name() const
248436 : {
248437 10 : ROSE_ASSERT(this != NULL);
248438 10 : return "SgFloatVal";
248439 : }
248440 :
248441 : std::string
248442 16 : SgFloatVal::class_name() const
248443 : {
248444 16 : ROSE_ASSERT(this != NULL);
248445 16 : return "SgFloatVal";
248446 : }
248447 :
248448 : // DQ (11/26/2005): Support for visitor pattern mechanims
248449 : // (inferior to ROSE traversal mechanism, experimental).
248450 : void
248451 137 : SgFloatVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
248452 : {
248453 137 : ROSE_ASSERT(this != NULL);
248454 137 : visitor.visit(this);
248455 137 : }
248456 :
248457 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
248458 0 : void SgFloatVal::accept (ROSE_VisitorPattern & visitor) {
248459 0 : ROSE_ASSERT(this != NULL);
248460 0 : visitor.visit(this);
248461 0 : }
248462 :
248463 : SgFloatVal*
248464 0 : SgFloatVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
248465 : {
248466 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
248467 : // This function is currently only supported for the AST used the represent Binary executables.
248468 : if (0 /* isSgAsmNode(this) != NULL */)
248469 : {
248470 : // Support for regex specification.
248471 : std::string prefixCode = "REGEX:";
248472 : addNewAttribute(prefixCode + s,a);
248473 : }
248474 : #endif
248475 :
248476 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
248477 0 : return this;
248478 : }
248479 :
248480 : // *** COMMON CODE SECTION ENDS HERE ***
248481 :
248482 :
248483 : // End of memberFunctionString
248484 : // Start of memberFunctionString
248485 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
248486 :
248487 :
248488 : #if 0
248489 : //! Error checking support
248490 : /*! Verifies the following:
248491 : - working getVariant() member function
248492 : - calls base class's error() member function
248493 : Every class has one of these functions.
248494 : */
248495 : bool
248496 : SgFloatVal::error()
248497 : {
248498 : // Put error checking here
248499 :
248500 : ROSE_ASSERT (this != NULL);
248501 : if (getVariant() != FLOAT_VAL)
248502 : {
248503 : printf ("Error in SgFloatVal::error(): SgFloatVal object has a %s variant \n",
248504 : Cxx_GrammarTerminalNames[getVariant()].name);
248505 : // printf ("Error in SgFloatVal::error() \n");
248506 : ROSE_ABORT();
248507 : }
248508 :
248509 : ROSE_ASSERT (getVariant() == FLOAT_VAL);
248510 : return SgValueExp::error();
248511 : }
248512 : #endif
248513 :
248514 :
248515 :
248516 : // End of memberFunctionString
248517 :
248518 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
248519 :
248520 129 : SgFloatVal* isSgFloatVal ( SgNode* inputDerivedClassPointer )
248521 : {
248522 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
248523 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
248524 : // So to fix this we return NULL directly when the input is NULL and avoid the
248525 : // dynamic_cast in this case. This is likely a performance improvement as well.
248526 : // return dynamic_cast<SgFloatVal*>(inputDerivedClassPointer);
248527 : // Milind Chabbi (8/28/2013): isSgFloatVal uses table-driven castability instead of c++ default dynamic_cast
248528 : // this improves the running time performance by 10-20%.
248529 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFloatVal*>(inputDerivedClassPointer);
248530 129 : return IS_SgFloatVal_FAST_MACRO(inputDerivedClassPointer);
248531 : }
248532 :
248533 : // DQ (11/8/2003): Added version of functions taking const pointer
248534 1 : const SgFloatVal* isSgFloatVal ( const SgNode* inputDerivedClassPointer )
248535 : {
248536 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
248537 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
248538 : // So to fix this we return NULL directly when the input is NULL and avoid the
248539 : // dynamic_cast in this case. This is likely a performance improvement as well.
248540 : // return dynamic_cast<const SgFloatVal*>(inputDerivedClassPointer);
248541 : // Milind Chabbi (8/28/2013): isSgFloatVal uses table-driven castability instead of c++ default dynamic_cast
248542 : // this improves the running time performance by 10-20%.
248543 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFloatVal*>(inputDerivedClassPointer);
248544 1 : return IS_SgFloatVal_FAST_MACRO(inputDerivedClassPointer);
248545 : }
248546 :
248547 :
248548 :
248549 : /* #line 248550 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248550 :
248551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
248552 :
248553 : /**
248554 : \brief Generated destructor
248555 :
248556 : This destructor is automatically generated (by ROSETTA). This destructor
248557 : only frees memory of data members associated with the parts of the current IR node which
248558 : are NOT traversed. Those data members that are part of a traversal can be freed using
248559 : a traversal (calling this destructor on all children in a post-order traversal). Such
248560 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
248561 :
248562 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
248563 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
248564 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
248565 :
248566 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
248567 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
248568 : pointers are not yet implemented to call delete on eash pointer in the container.
248569 : (This could be done by derivation from the STL containers to define containers that
248570 : automatically deleted their members.)
248571 :
248572 : */
248573 210 : SgFloatVal::~SgFloatVal () {
248574 105 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
248575 :
248576 :
248577 : // case: not a listType for value
248578 105 : p_value = 0.0; // non list case
248579 : // case: not a listType for valueString
248580 105 : p_valueString = ""; // non list case
248581 :
248582 : }
248583 :
248584 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
248585 210 : }
248586 :
248587 :
248588 : /* #line 248589 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248589 :
248590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
248591 :
248592 : // Generated constructor
248593 0 : SgFloatVal::SgFloatVal ( Sg_File_Info* startOfConstruct, float value, std::string valueString )
248594 0 : : SgValueExp(startOfConstruct)
248595 : {
248596 : #ifdef DEBUG
248597 : // printf ("In SgFloatVal::SgFloatVal (Sg_File_Info* startOfConstruct, float value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
248598 : #endif
248599 : #if 0
248600 : // debugging information!
248601 : printf ("In SgFloatVal::SgFloatVal (Sg_File_Info* startOfConstruct, float value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
248602 : #endif
248603 :
248604 0 : p_value = value;
248605 0 : p_valueString = valueString;
248606 :
248607 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
248608 :
248609 : #if 0
248610 : // DQ (7/30/2014): Call a virtual function.
248611 : std::string s = this->class_name();
248612 : #endif
248613 :
248614 : // Test the variant virtual function
248615 : // assert(FLOAT_VAL == variant());
248616 0 : assert(FLOAT_VAL == this->variant());
248617 0 : ROSE_ASSERT(FLOAT_VAL == (int)(this->variantT()));
248618 0 : post_construction_initialization();
248619 :
248620 : // Test the isSgFloatVal() function since it has been problematic
248621 0 : assert(isSgFloatVal(this) != NULL);
248622 0 : }
248623 :
248624 : // Generated constructor (all data members)
248625 :
248626 : /* #line 248627 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248627 :
248628 :
248629 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
248630 :
248631 :
248632 : // ********************************************************
248633 : // member functions common across all array grammar objects
248634 : // ********************************************************
248635 :
248636 :
248637 :
248638 : /* #line 248639 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248639 :
248640 :
248641 :
248642 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
248643 :
248644 : // ********************************************************
248645 : // member functions specific to each node in the grammar
248646 : // ********************************************************
248647 :
248648 :
248649 : /* #line 248650 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248650 :
248651 : // Start of memberFunctionString
248652 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248653 :
248654 : void
248655 585 : SgDoubleVal::post_construction_initialization()
248656 : {
248657 585 : }
248658 :
248659 :
248660 :
248661 : // End of memberFunctionString
248662 : // Start of memberFunctionString
248663 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
248664 :
248665 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
248666 :
248667 : double
248668 832 : SgDoubleVal::get_value () const
248669 : {
248670 832 : ROSE_ASSERT (this != NULL);
248671 :
248672 : #if 0
248673 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248674 : // used to trigger marking transformations for the token-based unparsing.
248675 : printf ("SgDoubleVal::get_value = %p = %s \n",this,this->class_name().c_str());
248676 : #endif
248677 :
248678 832 : return p_value;
248679 : }
248680 :
248681 : void
248682 0 : SgDoubleVal::set_value ( double value )
248683 : {
248684 0 : ROSE_ASSERT (this != NULL);
248685 :
248686 : #if 0
248687 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248688 : // used to trigger marking transformations for the token-based unparsing.
248689 : printf ("SgDoubleVal::set_value = %p = %s \n",this,this->class_name().c_str());
248690 : #endif
248691 :
248692 0 : set_isModified(true);
248693 :
248694 0 : p_value = value;
248695 0 : }
248696 :
248697 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
248698 :
248699 :
248700 : // End of memberFunctionString
248701 : // Start of memberFunctionString
248702 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
248703 :
248704 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
248705 :
248706 : std::string
248707 826 : SgDoubleVal::get_valueString () const
248708 : {
248709 826 : ROSE_ASSERT (this != NULL);
248710 :
248711 : #if 0
248712 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248713 : // used to trigger marking transformations for the token-based unparsing.
248714 : printf ("SgDoubleVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
248715 : #endif
248716 :
248717 826 : return p_valueString;
248718 : }
248719 :
248720 : void
248721 0 : SgDoubleVal::set_valueString ( std::string valueString )
248722 : {
248723 0 : ROSE_ASSERT (this != NULL);
248724 :
248725 : #if 0
248726 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
248727 : // used to trigger marking transformations for the token-based unparsing.
248728 : printf ("SgDoubleVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
248729 : #endif
248730 :
248731 0 : set_isModified(true);
248732 :
248733 0 : p_valueString = valueString;
248734 0 : }
248735 :
248736 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
248737 :
248738 :
248739 : // End of memberFunctionString
248740 : // Start of memberFunctionString
248741 : /* #line 4270 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248742 :
248743 :
248744 :
248745 : // End of memberFunctionString
248746 : // Start of memberFunctionString
248747 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
248748 :
248749 :
248750 : SgType*
248751 944 : SgDoubleVal::get_type(void) const
248752 : {
248753 : #if 0
248754 : printf ("In SgDoubleVal::get_type() \n");
248755 : #endif
248756 :
248757 944 : return SgTypeDouble::createType();
248758 : }
248759 :
248760 :
248761 :
248762 : // End of memberFunctionString
248763 : // Start of memberFunctionString
248764 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
248765 :
248766 : // *** COMMON CODE SECTION BEGINS HERE ***
248767 :
248768 : #if 0
248769 : int
248770 : SgDoubleVal::getVariant() const
248771 : {
248772 : // This function is used in ROSE while "variant()" is used in SAGE
248773 : assert(this != NULL);
248774 : return variant();
248775 : }
248776 : #endif
248777 :
248778 : // This function is used in ROSE in treeTraversal code
248779 : // eventually replaces getVariant() and variant()
248780 : // though after variant() has been removed for a while we will
248781 : // want to change the name of variantT() back to variant()
248782 : // (since the "T" was ment to stand for temporary).
248783 : // When this happens the variantT() will be depricated.
248784 : VariantT
248785 121240 : SgDoubleVal::variantT() const
248786 : {
248787 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
248788 121240 : ROSE_ASSERT(this != NULL);
248789 121240 : return V_SgDoubleVal;
248790 : }
248791 :
248792 : #if 0
248793 : int
248794 : SgDoubleVal::variant() const
248795 : {
248796 : // This function is used in SAGE
248797 : ROSE_ASSERT(this != NULL);
248798 : return DOUBLE_VAL;
248799 : }
248800 : #endif
248801 :
248802 : ROSE_DLL_API const char*
248803 91 : SgDoubleVal::sage_class_name() const
248804 : {
248805 91 : ROSE_ASSERT(this != NULL);
248806 91 : return "SgDoubleVal";
248807 : }
248808 :
248809 : std::string
248810 406 : SgDoubleVal::class_name() const
248811 : {
248812 406 : ROSE_ASSERT(this != NULL);
248813 406 : return "SgDoubleVal";
248814 : }
248815 :
248816 : // DQ (11/26/2005): Support for visitor pattern mechanims
248817 : // (inferior to ROSE traversal mechanism, experimental).
248818 : void
248819 173 : SgDoubleVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
248820 : {
248821 173 : ROSE_ASSERT(this != NULL);
248822 173 : visitor.visit(this);
248823 173 : }
248824 :
248825 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
248826 0 : void SgDoubleVal::accept (ROSE_VisitorPattern & visitor) {
248827 0 : ROSE_ASSERT(this != NULL);
248828 0 : visitor.visit(this);
248829 0 : }
248830 :
248831 : SgDoubleVal*
248832 0 : SgDoubleVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
248833 : {
248834 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
248835 : // This function is currently only supported for the AST used the represent Binary executables.
248836 : if (0 /* isSgAsmNode(this) != NULL */)
248837 : {
248838 : // Support for regex specification.
248839 : std::string prefixCode = "REGEX:";
248840 : addNewAttribute(prefixCode + s,a);
248841 : }
248842 : #endif
248843 :
248844 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
248845 0 : return this;
248846 : }
248847 :
248848 : // *** COMMON CODE SECTION ENDS HERE ***
248849 :
248850 :
248851 : // End of memberFunctionString
248852 : // Start of memberFunctionString
248853 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
248854 :
248855 :
248856 : #if 0
248857 : //! Error checking support
248858 : /*! Verifies the following:
248859 : - working getVariant() member function
248860 : - calls base class's error() member function
248861 : Every class has one of these functions.
248862 : */
248863 : bool
248864 : SgDoubleVal::error()
248865 : {
248866 : // Put error checking here
248867 :
248868 : ROSE_ASSERT (this != NULL);
248869 : if (getVariant() != DOUBLE_VAL)
248870 : {
248871 : printf ("Error in SgDoubleVal::error(): SgDoubleVal object has a %s variant \n",
248872 : Cxx_GrammarTerminalNames[getVariant()].name);
248873 : // printf ("Error in SgDoubleVal::error() \n");
248874 : ROSE_ABORT();
248875 : }
248876 :
248877 : ROSE_ASSERT (getVariant() == DOUBLE_VAL);
248878 : return SgValueExp::error();
248879 : }
248880 : #endif
248881 :
248882 :
248883 :
248884 : // End of memberFunctionString
248885 :
248886 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
248887 :
248888 1001 : SgDoubleVal* isSgDoubleVal ( SgNode* inputDerivedClassPointer )
248889 : {
248890 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
248891 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
248892 : // So to fix this we return NULL directly when the input is NULL and avoid the
248893 : // dynamic_cast in this case. This is likely a performance improvement as well.
248894 : // return dynamic_cast<SgDoubleVal*>(inputDerivedClassPointer);
248895 : // Milind Chabbi (8/28/2013): isSgDoubleVal uses table-driven castability instead of c++ default dynamic_cast
248896 : // this improves the running time performance by 10-20%.
248897 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDoubleVal*>(inputDerivedClassPointer);
248898 1001 : return IS_SgDoubleVal_FAST_MACRO(inputDerivedClassPointer);
248899 : }
248900 :
248901 : // DQ (11/8/2003): Added version of functions taking const pointer
248902 0 : const SgDoubleVal* isSgDoubleVal ( const SgNode* inputDerivedClassPointer )
248903 : {
248904 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
248905 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
248906 : // So to fix this we return NULL directly when the input is NULL and avoid the
248907 : // dynamic_cast in this case. This is likely a performance improvement as well.
248908 : // return dynamic_cast<const SgDoubleVal*>(inputDerivedClassPointer);
248909 : // Milind Chabbi (8/28/2013): isSgDoubleVal uses table-driven castability instead of c++ default dynamic_cast
248910 : // this improves the running time performance by 10-20%.
248911 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDoubleVal*>(inputDerivedClassPointer);
248912 0 : return IS_SgDoubleVal_FAST_MACRO(inputDerivedClassPointer);
248913 : }
248914 :
248915 :
248916 :
248917 : /* #line 248918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248918 :
248919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
248920 :
248921 : /**
248922 : \brief Generated destructor
248923 :
248924 : This destructor is automatically generated (by ROSETTA). This destructor
248925 : only frees memory of data members associated with the parts of the current IR node which
248926 : are NOT traversed. Those data members that are part of a traversal can be freed using
248927 : a traversal (calling this destructor on all children in a post-order traversal). Such
248928 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
248929 :
248930 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
248931 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
248932 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
248933 :
248934 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
248935 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
248936 : pointers are not yet implemented to call delete on eash pointer in the container.
248937 : (This could be done by derivation from the STL containers to define containers that
248938 : automatically deleted their members.)
248939 :
248940 : */
248941 292 : SgDoubleVal::~SgDoubleVal () {
248942 146 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
248943 :
248944 :
248945 : // case: not a listType for value
248946 146 : p_value = 0.0; // non list case
248947 : // case: not a listType for valueString
248948 146 : p_valueString = ""; // non list case
248949 :
248950 : }
248951 :
248952 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
248953 292 : }
248954 :
248955 :
248956 : /* #line 248957 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248957 :
248958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
248959 :
248960 : // Generated constructor
248961 0 : SgDoubleVal::SgDoubleVal ( Sg_File_Info* startOfConstruct, double value, std::string valueString )
248962 0 : : SgValueExp(startOfConstruct)
248963 : {
248964 : #ifdef DEBUG
248965 : // printf ("In SgDoubleVal::SgDoubleVal (Sg_File_Info* startOfConstruct, double value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
248966 : #endif
248967 : #if 0
248968 : // debugging information!
248969 : printf ("In SgDoubleVal::SgDoubleVal (Sg_File_Info* startOfConstruct, double value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
248970 : #endif
248971 :
248972 0 : p_value = value;
248973 0 : p_valueString = valueString;
248974 :
248975 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
248976 :
248977 : #if 0
248978 : // DQ (7/30/2014): Call a virtual function.
248979 : std::string s = this->class_name();
248980 : #endif
248981 :
248982 : // Test the variant virtual function
248983 : // assert(DOUBLE_VAL == variant());
248984 0 : assert(DOUBLE_VAL == this->variant());
248985 0 : ROSE_ASSERT(DOUBLE_VAL == (int)(this->variantT()));
248986 0 : post_construction_initialization();
248987 :
248988 : // Test the isSgDoubleVal() function since it has been problematic
248989 0 : assert(isSgDoubleVal(this) != NULL);
248990 0 : }
248991 :
248992 : // Generated constructor (all data members)
248993 :
248994 : /* #line 248995 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
248995 :
248996 :
248997 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
248998 :
248999 :
249000 : // ********************************************************
249001 : // member functions common across all array grammar objects
249002 : // ********************************************************
249003 :
249004 :
249005 :
249006 : /* #line 249007 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249007 :
249008 :
249009 :
249010 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
249011 :
249012 : // ********************************************************
249013 : // member functions specific to each node in the grammar
249014 : // ********************************************************
249015 :
249016 :
249017 : /* #line 249018 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249018 :
249019 : // Start of memberFunctionString
249020 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249021 :
249022 : void
249023 33 : SgLongDoubleVal::post_construction_initialization()
249024 : {
249025 33 : }
249026 :
249027 :
249028 :
249029 : // End of memberFunctionString
249030 : // Start of memberFunctionString
249031 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249032 :
249033 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249034 :
249035 : long double
249036 1 : SgLongDoubleVal::get_value () const
249037 : {
249038 1 : ROSE_ASSERT (this != NULL);
249039 :
249040 : #if 0
249041 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249042 : // used to trigger marking transformations for the token-based unparsing.
249043 : printf ("SgLongDoubleVal::get_value = %p = %s \n",this,this->class_name().c_str());
249044 : #endif
249045 :
249046 1 : return p_value;
249047 : }
249048 :
249049 : void
249050 0 : SgLongDoubleVal::set_value ( long double value )
249051 : {
249052 0 : ROSE_ASSERT (this != NULL);
249053 :
249054 : #if 0
249055 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249056 : // used to trigger marking transformations for the token-based unparsing.
249057 : printf ("SgLongDoubleVal::set_value = %p = %s \n",this,this->class_name().c_str());
249058 : #endif
249059 :
249060 0 : set_isModified(true);
249061 :
249062 0 : p_value = value;
249063 0 : }
249064 :
249065 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249066 :
249067 :
249068 : // End of memberFunctionString
249069 : // Start of memberFunctionString
249070 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249071 :
249072 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249073 :
249074 : std::string
249075 1 : SgLongDoubleVal::get_valueString () const
249076 : {
249077 1 : ROSE_ASSERT (this != NULL);
249078 :
249079 : #if 0
249080 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249081 : // used to trigger marking transformations for the token-based unparsing.
249082 : printf ("SgLongDoubleVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
249083 : #endif
249084 :
249085 1 : return p_valueString;
249086 : }
249087 :
249088 : void
249089 0 : SgLongDoubleVal::set_valueString ( std::string valueString )
249090 : {
249091 0 : ROSE_ASSERT (this != NULL);
249092 :
249093 : #if 0
249094 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249095 : // used to trigger marking transformations for the token-based unparsing.
249096 : printf ("SgLongDoubleVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
249097 : #endif
249098 :
249099 0 : set_isModified(true);
249100 :
249101 0 : p_valueString = valueString;
249102 0 : }
249103 :
249104 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249105 :
249106 :
249107 : // End of memberFunctionString
249108 : // Start of memberFunctionString
249109 : /* #line 4274 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249110 :
249111 :
249112 :
249113 : // End of memberFunctionString
249114 : // Start of memberFunctionString
249115 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249116 :
249117 :
249118 : SgType*
249119 1 : SgLongDoubleVal::get_type(void) const
249120 : {
249121 : #if 0
249122 : printf ("In SgLongDoubleVal::get_type() \n");
249123 : #endif
249124 :
249125 1 : return SgTypeLongDouble::createType();
249126 : }
249127 :
249128 :
249129 :
249130 : // End of memberFunctionString
249131 : // Start of memberFunctionString
249132 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
249133 :
249134 : // *** COMMON CODE SECTION BEGINS HERE ***
249135 :
249136 : #if 0
249137 : int
249138 : SgLongDoubleVal::getVariant() const
249139 : {
249140 : // This function is used in ROSE while "variant()" is used in SAGE
249141 : assert(this != NULL);
249142 : return variant();
249143 : }
249144 : #endif
249145 :
249146 : // This function is used in ROSE in treeTraversal code
249147 : // eventually replaces getVariant() and variant()
249148 : // though after variant() has been removed for a while we will
249149 : // want to change the name of variantT() back to variant()
249150 : // (since the "T" was ment to stand for temporary).
249151 : // When this happens the variantT() will be depricated.
249152 : VariantT
249153 2148 : SgLongDoubleVal::variantT() const
249154 : {
249155 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
249156 2148 : ROSE_ASSERT(this != NULL);
249157 2148 : return V_SgLongDoubleVal;
249158 : }
249159 :
249160 : #if 0
249161 : int
249162 : SgLongDoubleVal::variant() const
249163 : {
249164 : // This function is used in SAGE
249165 : ROSE_ASSERT(this != NULL);
249166 : return LONG_DOUBLE_VAL;
249167 : }
249168 : #endif
249169 :
249170 : ROSE_DLL_API const char*
249171 0 : SgLongDoubleVal::sage_class_name() const
249172 : {
249173 0 : ROSE_ASSERT(this != NULL);
249174 0 : return "SgLongDoubleVal";
249175 : }
249176 :
249177 : std::string
249178 1 : SgLongDoubleVal::class_name() const
249179 : {
249180 1 : ROSE_ASSERT(this != NULL);
249181 1 : return "SgLongDoubleVal";
249182 : }
249183 :
249184 : // DQ (11/26/2005): Support for visitor pattern mechanims
249185 : // (inferior to ROSE traversal mechanism, experimental).
249186 : void
249187 0 : SgLongDoubleVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
249188 : {
249189 0 : ROSE_ASSERT(this != NULL);
249190 0 : visitor.visit(this);
249191 0 : }
249192 :
249193 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
249194 0 : void SgLongDoubleVal::accept (ROSE_VisitorPattern & visitor) {
249195 0 : ROSE_ASSERT(this != NULL);
249196 0 : visitor.visit(this);
249197 0 : }
249198 :
249199 : SgLongDoubleVal*
249200 0 : SgLongDoubleVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
249201 : {
249202 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
249203 : // This function is currently only supported for the AST used the represent Binary executables.
249204 : if (0 /* isSgAsmNode(this) != NULL */)
249205 : {
249206 : // Support for regex specification.
249207 : std::string prefixCode = "REGEX:";
249208 : addNewAttribute(prefixCode + s,a);
249209 : }
249210 : #endif
249211 :
249212 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
249213 0 : return this;
249214 : }
249215 :
249216 : // *** COMMON CODE SECTION ENDS HERE ***
249217 :
249218 :
249219 : // End of memberFunctionString
249220 : // Start of memberFunctionString
249221 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
249222 :
249223 :
249224 : #if 0
249225 : //! Error checking support
249226 : /*! Verifies the following:
249227 : - working getVariant() member function
249228 : - calls base class's error() member function
249229 : Every class has one of these functions.
249230 : */
249231 : bool
249232 : SgLongDoubleVal::error()
249233 : {
249234 : // Put error checking here
249235 :
249236 : ROSE_ASSERT (this != NULL);
249237 : if (getVariant() != LONG_DOUBLE_VAL)
249238 : {
249239 : printf ("Error in SgLongDoubleVal::error(): SgLongDoubleVal object has a %s variant \n",
249240 : Cxx_GrammarTerminalNames[getVariant()].name);
249241 : // printf ("Error in SgLongDoubleVal::error() \n");
249242 : ROSE_ABORT();
249243 : }
249244 :
249245 : ROSE_ASSERT (getVariant() == LONG_DOUBLE_VAL);
249246 : return SgValueExp::error();
249247 : }
249248 : #endif
249249 :
249250 :
249251 :
249252 : // End of memberFunctionString
249253 :
249254 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
249255 :
249256 34 : SgLongDoubleVal* isSgLongDoubleVal ( SgNode* inputDerivedClassPointer )
249257 : {
249258 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
249259 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
249260 : // So to fix this we return NULL directly when the input is NULL and avoid the
249261 : // dynamic_cast in this case. This is likely a performance improvement as well.
249262 : // return dynamic_cast<SgLongDoubleVal*>(inputDerivedClassPointer);
249263 : // Milind Chabbi (8/28/2013): isSgLongDoubleVal uses table-driven castability instead of c++ default dynamic_cast
249264 : // this improves the running time performance by 10-20%.
249265 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLongDoubleVal*>(inputDerivedClassPointer);
249266 34 : return IS_SgLongDoubleVal_FAST_MACRO(inputDerivedClassPointer);
249267 : }
249268 :
249269 : // DQ (11/8/2003): Added version of functions taking const pointer
249270 0 : const SgLongDoubleVal* isSgLongDoubleVal ( const SgNode* inputDerivedClassPointer )
249271 : {
249272 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
249273 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
249274 : // So to fix this we return NULL directly when the input is NULL and avoid the
249275 : // dynamic_cast in this case. This is likely a performance improvement as well.
249276 : // return dynamic_cast<const SgLongDoubleVal*>(inputDerivedClassPointer);
249277 : // Milind Chabbi (8/28/2013): isSgLongDoubleVal uses table-driven castability instead of c++ default dynamic_cast
249278 : // this improves the running time performance by 10-20%.
249279 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLongDoubleVal*>(inputDerivedClassPointer);
249280 0 : return IS_SgLongDoubleVal_FAST_MACRO(inputDerivedClassPointer);
249281 : }
249282 :
249283 :
249284 :
249285 : /* #line 249286 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249286 :
249287 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
249288 :
249289 : /**
249290 : \brief Generated destructor
249291 :
249292 : This destructor is automatically generated (by ROSETTA). This destructor
249293 : only frees memory of data members associated with the parts of the current IR node which
249294 : are NOT traversed. Those data members that are part of a traversal can be freed using
249295 : a traversal (calling this destructor on all children in a post-order traversal). Such
249296 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
249297 :
249298 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
249299 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
249300 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
249301 :
249302 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
249303 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
249304 : pointers are not yet implemented to call delete on eash pointer in the container.
249305 : (This could be done by derivation from the STL containers to define containers that
249306 : automatically deleted their members.)
249307 :
249308 : */
249309 64 : SgLongDoubleVal::~SgLongDoubleVal () {
249310 32 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
249311 :
249312 :
249313 : // case: not a listType for value
249314 32 : p_value = 0.0; // non list case
249315 : // case: not a listType for valueString
249316 32 : p_valueString = ""; // non list case
249317 :
249318 : }
249319 :
249320 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
249321 64 : }
249322 :
249323 :
249324 : /* #line 249325 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249325 :
249326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
249327 :
249328 : // Generated constructor
249329 0 : SgLongDoubleVal::SgLongDoubleVal ( Sg_File_Info* startOfConstruct, long double value, std::string valueString )
249330 0 : : SgValueExp(startOfConstruct)
249331 : {
249332 : #ifdef DEBUG
249333 : // printf ("In SgLongDoubleVal::SgLongDoubleVal (Sg_File_Info* startOfConstruct, long double value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
249334 : #endif
249335 : #if 0
249336 : // debugging information!
249337 : printf ("In SgLongDoubleVal::SgLongDoubleVal (Sg_File_Info* startOfConstruct, long double value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
249338 : #endif
249339 :
249340 0 : p_value = value;
249341 0 : p_valueString = valueString;
249342 :
249343 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
249344 :
249345 : #if 0
249346 : // DQ (7/30/2014): Call a virtual function.
249347 : std::string s = this->class_name();
249348 : #endif
249349 :
249350 : // Test the variant virtual function
249351 : // assert(LONG_DOUBLE_VAL == variant());
249352 0 : assert(LONG_DOUBLE_VAL == this->variant());
249353 0 : ROSE_ASSERT(LONG_DOUBLE_VAL == (int)(this->variantT()));
249354 0 : post_construction_initialization();
249355 :
249356 : // Test the isSgLongDoubleVal() function since it has been problematic
249357 0 : assert(isSgLongDoubleVal(this) != NULL);
249358 0 : }
249359 :
249360 : // Generated constructor (all data members)
249361 :
249362 : /* #line 249363 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249363 :
249364 :
249365 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
249366 :
249367 :
249368 : // ********************************************************
249369 : // member functions common across all array grammar objects
249370 : // ********************************************************
249371 :
249372 :
249373 :
249374 : /* #line 249375 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249375 :
249376 :
249377 :
249378 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
249379 :
249380 : // ********************************************************
249381 : // member functions specific to each node in the grammar
249382 : // ********************************************************
249383 :
249384 :
249385 : /* #line 249386 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249386 :
249387 : // Start of memberFunctionString
249388 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249389 :
249390 : void
249391 4 : SgComplexVal::post_construction_initialization()
249392 : {
249393 4 : }
249394 :
249395 :
249396 :
249397 : // End of memberFunctionString
249398 : // Start of memberFunctionString
249399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249400 :
249401 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249402 :
249403 : SgValueExp*
249404 4 : SgComplexVal::get_real_value () const
249405 : {
249406 4 : ROSE_ASSERT (this != NULL);
249407 :
249408 : #if 0
249409 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249410 : // used to trigger marking transformations for the token-based unparsing.
249411 : printf ("SgComplexVal::get_real_value = %p = %s \n",this,this->class_name().c_str());
249412 : #endif
249413 :
249414 4 : return p_real_value;
249415 : }
249416 :
249417 : void
249418 0 : SgComplexVal::set_real_value ( SgValueExp* real_value )
249419 : {
249420 0 : ROSE_ASSERT (this != NULL);
249421 :
249422 : #if 0
249423 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249424 : // used to trigger marking transformations for the token-based unparsing.
249425 : printf ("SgComplexVal::set_real_value = %p = %s \n",this,this->class_name().c_str());
249426 : #endif
249427 :
249428 0 : set_isModified(true);
249429 :
249430 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
249431 : if (p_real_value != NULL && real_value != NULL && p_real_value != real_value)
249432 : {
249433 : printf ("Warning: real_value = %p overwriting valid pointer p_real_value = %p \n",real_value,p_real_value);
249434 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
249435 : printf ("Error fails assertion (p_real_value != NULL && real_value != NULL && p_real_value != real_value) is false\n");
249436 : ROSE_ASSERT(false);
249437 : #endif
249438 : }
249439 : #endif
249440 0 : p_real_value = real_value;
249441 0 : }
249442 :
249443 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249444 :
249445 :
249446 : // End of memberFunctionString
249447 : // Start of memberFunctionString
249448 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249449 :
249450 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249451 :
249452 : SgValueExp*
249453 5 : SgComplexVal::get_imaginary_value () const
249454 : {
249455 5 : ROSE_ASSERT (this != NULL);
249456 :
249457 : #if 0
249458 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249459 : // used to trigger marking transformations for the token-based unparsing.
249460 : printf ("SgComplexVal::get_imaginary_value = %p = %s \n",this,this->class_name().c_str());
249461 : #endif
249462 :
249463 5 : return p_imaginary_value;
249464 : }
249465 :
249466 : void
249467 0 : SgComplexVal::set_imaginary_value ( SgValueExp* imaginary_value )
249468 : {
249469 0 : ROSE_ASSERT (this != NULL);
249470 :
249471 : #if 0
249472 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249473 : // used to trigger marking transformations for the token-based unparsing.
249474 : printf ("SgComplexVal::set_imaginary_value = %p = %s \n",this,this->class_name().c_str());
249475 : #endif
249476 :
249477 0 : set_isModified(true);
249478 :
249479 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
249480 : if (p_imaginary_value != NULL && imaginary_value != NULL && p_imaginary_value != imaginary_value)
249481 : {
249482 : printf ("Warning: imaginary_value = %p overwriting valid pointer p_imaginary_value = %p \n",imaginary_value,p_imaginary_value);
249483 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
249484 : printf ("Error fails assertion (p_imaginary_value != NULL && imaginary_value != NULL && p_imaginary_value != imaginary_value) is false\n");
249485 : ROSE_ASSERT(false);
249486 : #endif
249487 : }
249488 : #endif
249489 0 : p_imaginary_value = imaginary_value;
249490 0 : }
249491 :
249492 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249493 :
249494 :
249495 : // End of memberFunctionString
249496 : // Start of memberFunctionString
249497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249498 :
249499 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249500 :
249501 : SgType*
249502 0 : SgComplexVal::get_precisionType () const
249503 : {
249504 0 : ROSE_ASSERT (this != NULL);
249505 :
249506 : #if 0
249507 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249508 : // used to trigger marking transformations for the token-based unparsing.
249509 : printf ("SgComplexVal::get_precisionType = %p = %s \n",this,this->class_name().c_str());
249510 : #endif
249511 :
249512 0 : return p_precisionType;
249513 : }
249514 :
249515 : void
249516 0 : SgComplexVal::set_precisionType ( SgType* precisionType )
249517 : {
249518 0 : ROSE_ASSERT (this != NULL);
249519 :
249520 : #if 0
249521 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249522 : // used to trigger marking transformations for the token-based unparsing.
249523 : printf ("SgComplexVal::set_precisionType = %p = %s \n",this,this->class_name().c_str());
249524 : #endif
249525 :
249526 0 : set_isModified(true);
249527 :
249528 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
249529 : if (p_precisionType != NULL && precisionType != NULL && p_precisionType != precisionType)
249530 : {
249531 : printf ("Warning: precisionType = %p overwriting valid pointer p_precisionType = %p \n",precisionType,p_precisionType);
249532 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
249533 : printf ("Error fails assertion (p_precisionType != NULL && precisionType != NULL && p_precisionType != precisionType) is false\n");
249534 : ROSE_ASSERT(false);
249535 : #endif
249536 : }
249537 : #endif
249538 0 : p_precisionType = precisionType;
249539 0 : }
249540 :
249541 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249542 :
249543 :
249544 : // End of memberFunctionString
249545 : // Start of memberFunctionString
249546 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249547 :
249548 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249549 :
249550 : std::string
249551 5 : SgComplexVal::get_valueString () const
249552 : {
249553 5 : ROSE_ASSERT (this != NULL);
249554 :
249555 : #if 0
249556 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249557 : // used to trigger marking transformations for the token-based unparsing.
249558 : printf ("SgComplexVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
249559 : #endif
249560 :
249561 5 : return p_valueString;
249562 : }
249563 :
249564 : void
249565 0 : SgComplexVal::set_valueString ( std::string valueString )
249566 : {
249567 0 : ROSE_ASSERT (this != NULL);
249568 :
249569 : #if 0
249570 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249571 : // used to trigger marking transformations for the token-based unparsing.
249572 : printf ("SgComplexVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
249573 : #endif
249574 :
249575 0 : set_isModified(true);
249576 :
249577 0 : p_valueString = valueString;
249578 0 : }
249579 :
249580 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249581 :
249582 :
249583 : // End of memberFunctionString
249584 : // Start of memberFunctionString
249585 : /* #line 4455 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249586 :
249587 :
249588 :
249589 : // End of memberFunctionString
249590 : // Start of memberFunctionString
249591 : /* #line 8405 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249592 :
249593 :
249594 : SgType*
249595 4 : SgComplexVal::get_type(void) const
249596 : {
249597 : // Use the stored SgType to return the correct SgTypeComplex using the correct precision.
249598 4 : ROSE_ASSERT(p_precisionType != NULL);
249599 :
249600 : #if 0
249601 : printf ("In SgComplexVal::get_type() \n");
249602 : #endif
249603 :
249604 : // returns a shared SgTypeComplex type
249605 4 : return SgTypeComplex::createType(p_precisionType);
249606 : }
249607 :
249608 :
249609 :
249610 : // End of memberFunctionString
249611 : // Start of memberFunctionString
249612 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
249613 :
249614 : // *** COMMON CODE SECTION BEGINS HERE ***
249615 :
249616 : #if 0
249617 : int
249618 : SgComplexVal::getVariant() const
249619 : {
249620 : // This function is used in ROSE while "variant()" is used in SAGE
249621 : assert(this != NULL);
249622 : return variant();
249623 : }
249624 : #endif
249625 :
249626 : // This function is used in ROSE in treeTraversal code
249627 : // eventually replaces getVariant() and variant()
249628 : // though after variant() has been removed for a while we will
249629 : // want to change the name of variantT() back to variant()
249630 : // (since the "T" was ment to stand for temporary).
249631 : // When this happens the variantT() will be depricated.
249632 : VariantT
249633 448 : SgComplexVal::variantT() const
249634 : {
249635 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
249636 448 : ROSE_ASSERT(this != NULL);
249637 448 : return V_SgComplexVal;
249638 : }
249639 :
249640 : #if 0
249641 : int
249642 : SgComplexVal::variant() const
249643 : {
249644 : // This function is used in SAGE
249645 : ROSE_ASSERT(this != NULL);
249646 : return COMPLEX_VAL;
249647 : }
249648 : #endif
249649 :
249650 : ROSE_DLL_API const char*
249651 0 : SgComplexVal::sage_class_name() const
249652 : {
249653 0 : ROSE_ASSERT(this != NULL);
249654 0 : return "SgComplexVal";
249655 : }
249656 :
249657 : std::string
249658 4 : SgComplexVal::class_name() const
249659 : {
249660 4 : ROSE_ASSERT(this != NULL);
249661 4 : return "SgComplexVal";
249662 : }
249663 :
249664 : // DQ (11/26/2005): Support for visitor pattern mechanims
249665 : // (inferior to ROSE traversal mechanism, experimental).
249666 : void
249667 0 : SgComplexVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
249668 : {
249669 0 : ROSE_ASSERT(this != NULL);
249670 0 : visitor.visit(this);
249671 0 : }
249672 :
249673 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
249674 0 : void SgComplexVal::accept (ROSE_VisitorPattern & visitor) {
249675 0 : ROSE_ASSERT(this != NULL);
249676 0 : visitor.visit(this);
249677 0 : }
249678 :
249679 : SgComplexVal*
249680 0 : SgComplexVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
249681 : {
249682 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
249683 : // This function is currently only supported for the AST used the represent Binary executables.
249684 : if (0 /* isSgAsmNode(this) != NULL */)
249685 : {
249686 : // Support for regex specification.
249687 : std::string prefixCode = "REGEX:";
249688 : addNewAttribute(prefixCode + s,a);
249689 : }
249690 : #endif
249691 :
249692 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
249693 0 : return this;
249694 : }
249695 :
249696 : // *** COMMON CODE SECTION ENDS HERE ***
249697 :
249698 :
249699 : // End of memberFunctionString
249700 : // Start of memberFunctionString
249701 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
249702 :
249703 :
249704 : #if 0
249705 : //! Error checking support
249706 : /*! Verifies the following:
249707 : - working getVariant() member function
249708 : - calls base class's error() member function
249709 : Every class has one of these functions.
249710 : */
249711 : bool
249712 : SgComplexVal::error()
249713 : {
249714 : // Put error checking here
249715 :
249716 : ROSE_ASSERT (this != NULL);
249717 : if (getVariant() != COMPLEX_VAL)
249718 : {
249719 : printf ("Error in SgComplexVal::error(): SgComplexVal object has a %s variant \n",
249720 : Cxx_GrammarTerminalNames[getVariant()].name);
249721 : // printf ("Error in SgComplexVal::error() \n");
249722 : ROSE_ABORT();
249723 : }
249724 :
249725 : ROSE_ASSERT (getVariant() == COMPLEX_VAL);
249726 : return SgValueExp::error();
249727 : }
249728 : #endif
249729 :
249730 :
249731 :
249732 : // End of memberFunctionString
249733 :
249734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
249735 :
249736 8 : SgComplexVal* isSgComplexVal ( SgNode* inputDerivedClassPointer )
249737 : {
249738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
249739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
249740 : // So to fix this we return NULL directly when the input is NULL and avoid the
249741 : // dynamic_cast in this case. This is likely a performance improvement as well.
249742 : // return dynamic_cast<SgComplexVal*>(inputDerivedClassPointer);
249743 : // Milind Chabbi (8/28/2013): isSgComplexVal uses table-driven castability instead of c++ default dynamic_cast
249744 : // this improves the running time performance by 10-20%.
249745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgComplexVal*>(inputDerivedClassPointer);
249746 8 : return IS_SgComplexVal_FAST_MACRO(inputDerivedClassPointer);
249747 : }
249748 :
249749 : // DQ (11/8/2003): Added version of functions taking const pointer
249750 0 : const SgComplexVal* isSgComplexVal ( const SgNode* inputDerivedClassPointer )
249751 : {
249752 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
249753 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
249754 : // So to fix this we return NULL directly when the input is NULL and avoid the
249755 : // dynamic_cast in this case. This is likely a performance improvement as well.
249756 : // return dynamic_cast<const SgComplexVal*>(inputDerivedClassPointer);
249757 : // Milind Chabbi (8/28/2013): isSgComplexVal uses table-driven castability instead of c++ default dynamic_cast
249758 : // this improves the running time performance by 10-20%.
249759 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgComplexVal*>(inputDerivedClassPointer);
249760 0 : return IS_SgComplexVal_FAST_MACRO(inputDerivedClassPointer);
249761 : }
249762 :
249763 :
249764 :
249765 : /* #line 249766 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249766 :
249767 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
249768 :
249769 : /**
249770 : \brief Generated destructor
249771 :
249772 : This destructor is automatically generated (by ROSETTA). This destructor
249773 : only frees memory of data members associated with the parts of the current IR node which
249774 : are NOT traversed. Those data members that are part of a traversal can be freed using
249775 : a traversal (calling this destructor on all children in a post-order traversal). Such
249776 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
249777 :
249778 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
249779 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
249780 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
249781 :
249782 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
249783 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
249784 : pointers are not yet implemented to call delete on eash pointer in the container.
249785 : (This could be done by derivation from the STL containers to define containers that
249786 : automatically deleted their members.)
249787 :
249788 : */
249789 0 : SgComplexVal::~SgComplexVal () {
249790 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
249791 :
249792 :
249793 : // case: not a listType for real_value
249794 0 : p_real_value = NULL; // non list case
249795 : // case: not a listType for imaginary_value
249796 0 : p_imaginary_value = NULL; // non list case
249797 : // case: not a listType for precisionType
249798 0 : p_precisionType = NULL; // non list case
249799 : // case: not a listType for valueString
249800 0 : p_valueString = ""; // non list case
249801 :
249802 : }
249803 :
249804 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
249805 0 : }
249806 :
249807 :
249808 : /* #line 249809 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249809 :
249810 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
249811 :
249812 : // Generated constructor
249813 0 : SgComplexVal::SgComplexVal ( Sg_File_Info* startOfConstruct, SgValueExp* real_value, SgValueExp* imaginary_value, SgType* precisionType, std::string valueString )
249814 0 : : SgValueExp(startOfConstruct)
249815 : {
249816 : #ifdef DEBUG
249817 : // printf ("In SgComplexVal::SgComplexVal (Sg_File_Info* startOfConstruct, SgValueExp* real_value, SgValueExp* imaginary_value, SgType* precisionType, std::string valueString) sage_class_name() = %s \n",sage_class_name());
249818 : #endif
249819 : #if 0
249820 : // debugging information!
249821 : printf ("In SgComplexVal::SgComplexVal (Sg_File_Info* startOfConstruct, SgValueExp* real_value, SgValueExp* imaginary_value, SgType* precisionType, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
249822 : #endif
249823 :
249824 0 : p_real_value = real_value;
249825 0 : p_imaginary_value = imaginary_value;
249826 0 : p_precisionType = precisionType;
249827 0 : p_valueString = valueString;
249828 :
249829 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
249830 :
249831 : #if 0
249832 : // DQ (7/30/2014): Call a virtual function.
249833 : std::string s = this->class_name();
249834 : #endif
249835 :
249836 : // Test the variant virtual function
249837 : // assert(COMPLEX_VAL == variant());
249838 0 : assert(COMPLEX_VAL == this->variant());
249839 0 : ROSE_ASSERT(COMPLEX_VAL == (int)(this->variantT()));
249840 0 : post_construction_initialization();
249841 :
249842 : // Test the isSgComplexVal() function since it has been problematic
249843 0 : assert(isSgComplexVal(this) != NULL);
249844 0 : }
249845 :
249846 : // Generated constructor (all data members)
249847 :
249848 : /* #line 249849 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249849 :
249850 :
249851 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
249852 :
249853 :
249854 : // ********************************************************
249855 : // member functions common across all array grammar objects
249856 : // ********************************************************
249857 :
249858 :
249859 :
249860 : /* #line 249861 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249861 :
249862 :
249863 :
249864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
249865 :
249866 : // ********************************************************
249867 : // member functions specific to each node in the grammar
249868 : // ********************************************************
249869 :
249870 :
249871 : /* #line 249872 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
249872 :
249873 : // Start of memberFunctionString
249874 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249875 :
249876 : void
249877 0 : SgUpcThreads::post_construction_initialization()
249878 : {
249879 0 : }
249880 :
249881 :
249882 :
249883 : // End of memberFunctionString
249884 : // Start of memberFunctionString
249885 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249886 :
249887 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249888 :
249889 : int
249890 0 : SgUpcThreads::get_value () const
249891 : {
249892 0 : ROSE_ASSERT (this != NULL);
249893 :
249894 : #if 0
249895 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249896 : // used to trigger marking transformations for the token-based unparsing.
249897 : printf ("SgUpcThreads::get_value = %p = %s \n",this,this->class_name().c_str());
249898 : #endif
249899 :
249900 0 : return p_value;
249901 : }
249902 :
249903 : void
249904 0 : SgUpcThreads::set_value ( int value )
249905 : {
249906 0 : ROSE_ASSERT (this != NULL);
249907 :
249908 : #if 0
249909 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249910 : // used to trigger marking transformations for the token-based unparsing.
249911 : printf ("SgUpcThreads::set_value = %p = %s \n",this,this->class_name().c_str());
249912 : #endif
249913 :
249914 0 : set_isModified(true);
249915 :
249916 0 : p_value = value;
249917 0 : }
249918 :
249919 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249920 :
249921 :
249922 : // End of memberFunctionString
249923 : // Start of memberFunctionString
249924 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
249925 :
249926 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
249927 :
249928 : std::string
249929 0 : SgUpcThreads::get_valueString () const
249930 : {
249931 0 : ROSE_ASSERT (this != NULL);
249932 :
249933 : #if 0
249934 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249935 : // used to trigger marking transformations for the token-based unparsing.
249936 : printf ("SgUpcThreads::get_valueString = %p = %s \n",this,this->class_name().c_str());
249937 : #endif
249938 :
249939 0 : return p_valueString;
249940 : }
249941 :
249942 : void
249943 0 : SgUpcThreads::set_valueString ( std::string valueString )
249944 : {
249945 0 : ROSE_ASSERT (this != NULL);
249946 :
249947 : #if 0
249948 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
249949 : // used to trigger marking transformations for the token-based unparsing.
249950 : printf ("SgUpcThreads::set_valueString = %p = %s \n",this,this->class_name().c_str());
249951 : #endif
249952 :
249953 0 : set_isModified(true);
249954 :
249955 0 : p_valueString = valueString;
249956 0 : }
249957 :
249958 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
249959 :
249960 :
249961 : // End of memberFunctionString
249962 : // Start of memberFunctionString
249963 : /* #line 4461 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249964 :
249965 :
249966 :
249967 : // End of memberFunctionString
249968 : // Start of memberFunctionString
249969 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
249970 :
249971 :
249972 : SgType*
249973 0 : SgUpcThreads::get_type(void) const
249974 : {
249975 : #if 0
249976 : printf ("In SgUpcThreads::get_type() \n");
249977 : #endif
249978 :
249979 0 : return SgTypeInt::createType();
249980 : }
249981 :
249982 :
249983 :
249984 : // End of memberFunctionString
249985 : // Start of memberFunctionString
249986 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
249987 :
249988 : // *** COMMON CODE SECTION BEGINS HERE ***
249989 :
249990 : #if 0
249991 : int
249992 : SgUpcThreads::getVariant() const
249993 : {
249994 : // This function is used in ROSE while "variant()" is used in SAGE
249995 : assert(this != NULL);
249996 : return variant();
249997 : }
249998 : #endif
249999 :
250000 : // This function is used in ROSE in treeTraversal code
250001 : // eventually replaces getVariant() and variant()
250002 : // though after variant() has been removed for a while we will
250003 : // want to change the name of variantT() back to variant()
250004 : // (since the "T" was ment to stand for temporary).
250005 : // When this happens the variantT() will be depricated.
250006 : VariantT
250007 0 : SgUpcThreads::variantT() const
250008 : {
250009 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
250010 0 : ROSE_ASSERT(this != NULL);
250011 0 : return V_SgUpcThreads;
250012 : }
250013 :
250014 : #if 0
250015 : int
250016 : SgUpcThreads::variant() const
250017 : {
250018 : // This function is used in SAGE
250019 : ROSE_ASSERT(this != NULL);
250020 : return UPC_THREADS;
250021 : }
250022 : #endif
250023 :
250024 : ROSE_DLL_API const char*
250025 0 : SgUpcThreads::sage_class_name() const
250026 : {
250027 0 : ROSE_ASSERT(this != NULL);
250028 0 : return "SgUpcThreads";
250029 : }
250030 :
250031 : std::string
250032 0 : SgUpcThreads::class_name() const
250033 : {
250034 0 : ROSE_ASSERT(this != NULL);
250035 0 : return "SgUpcThreads";
250036 : }
250037 :
250038 : // DQ (11/26/2005): Support for visitor pattern mechanims
250039 : // (inferior to ROSE traversal mechanism, experimental).
250040 : void
250041 0 : SgUpcThreads::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
250042 : {
250043 0 : ROSE_ASSERT(this != NULL);
250044 0 : visitor.visit(this);
250045 0 : }
250046 :
250047 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
250048 0 : void SgUpcThreads::accept (ROSE_VisitorPattern & visitor) {
250049 0 : ROSE_ASSERT(this != NULL);
250050 0 : visitor.visit(this);
250051 0 : }
250052 :
250053 : SgUpcThreads*
250054 0 : SgUpcThreads::addRegExpAttribute(std::string s, AstRegExAttribute* a)
250055 : {
250056 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
250057 : // This function is currently only supported for the AST used the represent Binary executables.
250058 : if (0 /* isSgAsmNode(this) != NULL */)
250059 : {
250060 : // Support for regex specification.
250061 : std::string prefixCode = "REGEX:";
250062 : addNewAttribute(prefixCode + s,a);
250063 : }
250064 : #endif
250065 :
250066 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
250067 0 : return this;
250068 : }
250069 :
250070 : // *** COMMON CODE SECTION ENDS HERE ***
250071 :
250072 :
250073 : // End of memberFunctionString
250074 : // Start of memberFunctionString
250075 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
250076 :
250077 :
250078 : #if 0
250079 : //! Error checking support
250080 : /*! Verifies the following:
250081 : - working getVariant() member function
250082 : - calls base class's error() member function
250083 : Every class has one of these functions.
250084 : */
250085 : bool
250086 : SgUpcThreads::error()
250087 : {
250088 : // Put error checking here
250089 :
250090 : ROSE_ASSERT (this != NULL);
250091 : if (getVariant() != UPC_THREADS)
250092 : {
250093 : printf ("Error in SgUpcThreads::error(): SgUpcThreads object has a %s variant \n",
250094 : Cxx_GrammarTerminalNames[getVariant()].name);
250095 : // printf ("Error in SgUpcThreads::error() \n");
250096 : ROSE_ABORT();
250097 : }
250098 :
250099 : ROSE_ASSERT (getVariant() == UPC_THREADS);
250100 : return SgValueExp::error();
250101 : }
250102 : #endif
250103 :
250104 :
250105 :
250106 : // End of memberFunctionString
250107 :
250108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
250109 :
250110 12 : SgUpcThreads* isSgUpcThreads ( SgNode* inputDerivedClassPointer )
250111 : {
250112 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
250113 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
250114 : // So to fix this we return NULL directly when the input is NULL and avoid the
250115 : // dynamic_cast in this case. This is likely a performance improvement as well.
250116 : // return dynamic_cast<SgUpcThreads*>(inputDerivedClassPointer);
250117 : // Milind Chabbi (8/28/2013): isSgUpcThreads uses table-driven castability instead of c++ default dynamic_cast
250118 : // this improves the running time performance by 10-20%.
250119 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcThreads*>(inputDerivedClassPointer);
250120 12 : return IS_SgUpcThreads_FAST_MACRO(inputDerivedClassPointer);
250121 : }
250122 :
250123 : // DQ (11/8/2003): Added version of functions taking const pointer
250124 0 : const SgUpcThreads* isSgUpcThreads ( const SgNode* inputDerivedClassPointer )
250125 : {
250126 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
250127 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
250128 : // So to fix this we return NULL directly when the input is NULL and avoid the
250129 : // dynamic_cast in this case. This is likely a performance improvement as well.
250130 : // return dynamic_cast<const SgUpcThreads*>(inputDerivedClassPointer);
250131 : // Milind Chabbi (8/28/2013): isSgUpcThreads uses table-driven castability instead of c++ default dynamic_cast
250132 : // this improves the running time performance by 10-20%.
250133 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcThreads*>(inputDerivedClassPointer);
250134 0 : return IS_SgUpcThreads_FAST_MACRO(inputDerivedClassPointer);
250135 : }
250136 :
250137 :
250138 :
250139 : /* #line 250140 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250140 :
250141 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
250142 :
250143 : /**
250144 : \brief Generated destructor
250145 :
250146 : This destructor is automatically generated (by ROSETTA). This destructor
250147 : only frees memory of data members associated with the parts of the current IR node which
250148 : are NOT traversed. Those data members that are part of a traversal can be freed using
250149 : a traversal (calling this destructor on all children in a post-order traversal). Such
250150 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
250151 :
250152 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
250153 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
250154 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
250155 :
250156 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
250157 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
250158 : pointers are not yet implemented to call delete on eash pointer in the container.
250159 : (This could be done by derivation from the STL containers to define containers that
250160 : automatically deleted their members.)
250161 :
250162 : */
250163 0 : SgUpcThreads::~SgUpcThreads () {
250164 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
250165 :
250166 :
250167 : // case: not a listType for value
250168 0 : p_value = 0; // non list case
250169 : // case: not a listType for valueString
250170 0 : p_valueString = ""; // non list case
250171 :
250172 : }
250173 :
250174 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
250175 0 : }
250176 :
250177 :
250178 : /* #line 250179 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250179 :
250180 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
250181 :
250182 : // Generated constructor
250183 0 : SgUpcThreads::SgUpcThreads ( Sg_File_Info* startOfConstruct, int value, std::string valueString )
250184 0 : : SgValueExp(startOfConstruct)
250185 : {
250186 : #ifdef DEBUG
250187 : // printf ("In SgUpcThreads::SgUpcThreads (Sg_File_Info* startOfConstruct, int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
250188 : #endif
250189 : #if 0
250190 : // debugging information!
250191 : printf ("In SgUpcThreads::SgUpcThreads (Sg_File_Info* startOfConstruct, int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
250192 : #endif
250193 :
250194 0 : p_value = value;
250195 0 : p_valueString = valueString;
250196 :
250197 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
250198 :
250199 : #if 0
250200 : // DQ (7/30/2014): Call a virtual function.
250201 : std::string s = this->class_name();
250202 : #endif
250203 :
250204 : // Test the variant virtual function
250205 : // assert(UPC_THREADS == variant());
250206 0 : assert(UPC_THREADS == this->variant());
250207 0 : ROSE_ASSERT(UPC_THREADS == (int)(this->variantT()));
250208 0 : post_construction_initialization();
250209 :
250210 : // Test the isSgUpcThreads() function since it has been problematic
250211 0 : assert(isSgUpcThreads(this) != NULL);
250212 0 : }
250213 :
250214 : // Generated constructor (all data members)
250215 :
250216 : /* #line 250217 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250217 :
250218 :
250219 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
250220 :
250221 :
250222 : // ********************************************************
250223 : // member functions common across all array grammar objects
250224 : // ********************************************************
250225 :
250226 :
250227 :
250228 : /* #line 250229 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250229 :
250230 :
250231 :
250232 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
250233 :
250234 : // ********************************************************
250235 : // member functions specific to each node in the grammar
250236 : // ********************************************************
250237 :
250238 :
250239 : /* #line 250240 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250240 :
250241 : // Start of memberFunctionString
250242 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
250243 :
250244 : void
250245 0 : SgUpcMythread::post_construction_initialization()
250246 : {
250247 0 : }
250248 :
250249 :
250250 :
250251 : // End of memberFunctionString
250252 : // Start of memberFunctionString
250253 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
250254 :
250255 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
250256 :
250257 : int
250258 0 : SgUpcMythread::get_value () const
250259 : {
250260 0 : ROSE_ASSERT (this != NULL);
250261 :
250262 : #if 0
250263 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250264 : // used to trigger marking transformations for the token-based unparsing.
250265 : printf ("SgUpcMythread::get_value = %p = %s \n",this,this->class_name().c_str());
250266 : #endif
250267 :
250268 0 : return p_value;
250269 : }
250270 :
250271 : void
250272 0 : SgUpcMythread::set_value ( int value )
250273 : {
250274 0 : ROSE_ASSERT (this != NULL);
250275 :
250276 : #if 0
250277 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250278 : // used to trigger marking transformations for the token-based unparsing.
250279 : printf ("SgUpcMythread::set_value = %p = %s \n",this,this->class_name().c_str());
250280 : #endif
250281 :
250282 0 : set_isModified(true);
250283 :
250284 0 : p_value = value;
250285 0 : }
250286 :
250287 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
250288 :
250289 :
250290 : // End of memberFunctionString
250291 : // Start of memberFunctionString
250292 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
250293 :
250294 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
250295 :
250296 : std::string
250297 0 : SgUpcMythread::get_valueString () const
250298 : {
250299 0 : ROSE_ASSERT (this != NULL);
250300 :
250301 : #if 0
250302 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250303 : // used to trigger marking transformations for the token-based unparsing.
250304 : printf ("SgUpcMythread::get_valueString = %p = %s \n",this,this->class_name().c_str());
250305 : #endif
250306 :
250307 0 : return p_valueString;
250308 : }
250309 :
250310 : void
250311 0 : SgUpcMythread::set_valueString ( std::string valueString )
250312 : {
250313 0 : ROSE_ASSERT (this != NULL);
250314 :
250315 : #if 0
250316 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250317 : // used to trigger marking transformations for the token-based unparsing.
250318 : printf ("SgUpcMythread::set_valueString = %p = %s \n",this,this->class_name().c_str());
250319 : #endif
250320 :
250321 0 : set_isModified(true);
250322 :
250323 0 : p_valueString = valueString;
250324 0 : }
250325 :
250326 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
250327 :
250328 :
250329 : // End of memberFunctionString
250330 : // Start of memberFunctionString
250331 : /* #line 4465 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
250332 :
250333 :
250334 :
250335 : // End of memberFunctionString
250336 : // Start of memberFunctionString
250337 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
250338 :
250339 :
250340 : SgType*
250341 0 : SgUpcMythread::get_type(void) const
250342 : {
250343 : #if 0
250344 : printf ("In SgUpcMythread::get_type() \n");
250345 : #endif
250346 :
250347 0 : return SgTypeInt::createType();
250348 : }
250349 :
250350 :
250351 :
250352 : // End of memberFunctionString
250353 : // Start of memberFunctionString
250354 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
250355 :
250356 : // *** COMMON CODE SECTION BEGINS HERE ***
250357 :
250358 : #if 0
250359 : int
250360 : SgUpcMythread::getVariant() const
250361 : {
250362 : // This function is used in ROSE while "variant()" is used in SAGE
250363 : assert(this != NULL);
250364 : return variant();
250365 : }
250366 : #endif
250367 :
250368 : // This function is used in ROSE in treeTraversal code
250369 : // eventually replaces getVariant() and variant()
250370 : // though after variant() has been removed for a while we will
250371 : // want to change the name of variantT() back to variant()
250372 : // (since the "T" was ment to stand for temporary).
250373 : // When this happens the variantT() will be depricated.
250374 : VariantT
250375 0 : SgUpcMythread::variantT() const
250376 : {
250377 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
250378 0 : ROSE_ASSERT(this != NULL);
250379 0 : return V_SgUpcMythread;
250380 : }
250381 :
250382 : #if 0
250383 : int
250384 : SgUpcMythread::variant() const
250385 : {
250386 : // This function is used in SAGE
250387 : ROSE_ASSERT(this != NULL);
250388 : return UPC_MYTHREAD;
250389 : }
250390 : #endif
250391 :
250392 : ROSE_DLL_API const char*
250393 0 : SgUpcMythread::sage_class_name() const
250394 : {
250395 0 : ROSE_ASSERT(this != NULL);
250396 0 : return "SgUpcMythread";
250397 : }
250398 :
250399 : std::string
250400 0 : SgUpcMythread::class_name() const
250401 : {
250402 0 : ROSE_ASSERT(this != NULL);
250403 0 : return "SgUpcMythread";
250404 : }
250405 :
250406 : // DQ (11/26/2005): Support for visitor pattern mechanims
250407 : // (inferior to ROSE traversal mechanism, experimental).
250408 : void
250409 0 : SgUpcMythread::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
250410 : {
250411 0 : ROSE_ASSERT(this != NULL);
250412 0 : visitor.visit(this);
250413 0 : }
250414 :
250415 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
250416 0 : void SgUpcMythread::accept (ROSE_VisitorPattern & visitor) {
250417 0 : ROSE_ASSERT(this != NULL);
250418 0 : visitor.visit(this);
250419 0 : }
250420 :
250421 : SgUpcMythread*
250422 0 : SgUpcMythread::addRegExpAttribute(std::string s, AstRegExAttribute* a)
250423 : {
250424 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
250425 : // This function is currently only supported for the AST used the represent Binary executables.
250426 : if (0 /* isSgAsmNode(this) != NULL */)
250427 : {
250428 : // Support for regex specification.
250429 : std::string prefixCode = "REGEX:";
250430 : addNewAttribute(prefixCode + s,a);
250431 : }
250432 : #endif
250433 :
250434 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
250435 0 : return this;
250436 : }
250437 :
250438 : // *** COMMON CODE SECTION ENDS HERE ***
250439 :
250440 :
250441 : // End of memberFunctionString
250442 : // Start of memberFunctionString
250443 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
250444 :
250445 :
250446 : #if 0
250447 : //! Error checking support
250448 : /*! Verifies the following:
250449 : - working getVariant() member function
250450 : - calls base class's error() member function
250451 : Every class has one of these functions.
250452 : */
250453 : bool
250454 : SgUpcMythread::error()
250455 : {
250456 : // Put error checking here
250457 :
250458 : ROSE_ASSERT (this != NULL);
250459 : if (getVariant() != UPC_MYTHREAD)
250460 : {
250461 : printf ("Error in SgUpcMythread::error(): SgUpcMythread object has a %s variant \n",
250462 : Cxx_GrammarTerminalNames[getVariant()].name);
250463 : // printf ("Error in SgUpcMythread::error() \n");
250464 : ROSE_ABORT();
250465 : }
250466 :
250467 : ROSE_ASSERT (getVariant() == UPC_MYTHREAD);
250468 : return SgValueExp::error();
250469 : }
250470 : #endif
250471 :
250472 :
250473 :
250474 : // End of memberFunctionString
250475 :
250476 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
250477 :
250478 0 : SgUpcMythread* isSgUpcMythread ( SgNode* inputDerivedClassPointer )
250479 : {
250480 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
250481 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
250482 : // So to fix this we return NULL directly when the input is NULL and avoid the
250483 : // dynamic_cast in this case. This is likely a performance improvement as well.
250484 : // return dynamic_cast<SgUpcMythread*>(inputDerivedClassPointer);
250485 : // Milind Chabbi (8/28/2013): isSgUpcMythread uses table-driven castability instead of c++ default dynamic_cast
250486 : // this improves the running time performance by 10-20%.
250487 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcMythread*>(inputDerivedClassPointer);
250488 0 : return IS_SgUpcMythread_FAST_MACRO(inputDerivedClassPointer);
250489 : }
250490 :
250491 : // DQ (11/8/2003): Added version of functions taking const pointer
250492 0 : const SgUpcMythread* isSgUpcMythread ( const SgNode* inputDerivedClassPointer )
250493 : {
250494 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
250495 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
250496 : // So to fix this we return NULL directly when the input is NULL and avoid the
250497 : // dynamic_cast in this case. This is likely a performance improvement as well.
250498 : // return dynamic_cast<const SgUpcMythread*>(inputDerivedClassPointer);
250499 : // Milind Chabbi (8/28/2013): isSgUpcMythread uses table-driven castability instead of c++ default dynamic_cast
250500 : // this improves the running time performance by 10-20%.
250501 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcMythread*>(inputDerivedClassPointer);
250502 0 : return IS_SgUpcMythread_FAST_MACRO(inputDerivedClassPointer);
250503 : }
250504 :
250505 :
250506 :
250507 : /* #line 250508 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250508 :
250509 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
250510 :
250511 : /**
250512 : \brief Generated destructor
250513 :
250514 : This destructor is automatically generated (by ROSETTA). This destructor
250515 : only frees memory of data members associated with the parts of the current IR node which
250516 : are NOT traversed. Those data members that are part of a traversal can be freed using
250517 : a traversal (calling this destructor on all children in a post-order traversal). Such
250518 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
250519 :
250520 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
250521 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
250522 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
250523 :
250524 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
250525 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
250526 : pointers are not yet implemented to call delete on eash pointer in the container.
250527 : (This could be done by derivation from the STL containers to define containers that
250528 : automatically deleted their members.)
250529 :
250530 : */
250531 0 : SgUpcMythread::~SgUpcMythread () {
250532 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
250533 :
250534 :
250535 : // case: not a listType for value
250536 0 : p_value = 0; // non list case
250537 : // case: not a listType for valueString
250538 0 : p_valueString = ""; // non list case
250539 :
250540 : }
250541 :
250542 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
250543 0 : }
250544 :
250545 :
250546 : /* #line 250547 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250547 :
250548 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
250549 :
250550 : // Generated constructor
250551 0 : SgUpcMythread::SgUpcMythread ( Sg_File_Info* startOfConstruct, int value, std::string valueString )
250552 0 : : SgValueExp(startOfConstruct)
250553 : {
250554 : #ifdef DEBUG
250555 : // printf ("In SgUpcMythread::SgUpcMythread (Sg_File_Info* startOfConstruct, int value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
250556 : #endif
250557 : #if 0
250558 : // debugging information!
250559 : printf ("In SgUpcMythread::SgUpcMythread (Sg_File_Info* startOfConstruct, int value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
250560 : #endif
250561 :
250562 0 : p_value = value;
250563 0 : p_valueString = valueString;
250564 :
250565 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
250566 :
250567 : #if 0
250568 : // DQ (7/30/2014): Call a virtual function.
250569 : std::string s = this->class_name();
250570 : #endif
250571 :
250572 : // Test the variant virtual function
250573 : // assert(UPC_MYTHREAD == variant());
250574 0 : assert(UPC_MYTHREAD == this->variant());
250575 0 : ROSE_ASSERT(UPC_MYTHREAD == (int)(this->variantT()));
250576 0 : post_construction_initialization();
250577 :
250578 : // Test the isSgUpcMythread() function since it has been problematic
250579 0 : assert(isSgUpcMythread(this) != NULL);
250580 0 : }
250581 :
250582 : // Generated constructor (all data members)
250583 :
250584 : /* #line 250585 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250585 :
250586 :
250587 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
250588 :
250589 :
250590 : // ********************************************************
250591 : // member functions common across all array grammar objects
250592 : // ********************************************************
250593 :
250594 :
250595 :
250596 : /* #line 250597 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250597 :
250598 :
250599 :
250600 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
250601 :
250602 : // ********************************************************
250603 : // member functions specific to each node in the grammar
250604 : // ********************************************************
250605 :
250606 :
250607 : /* #line 250608 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
250608 :
250609 : // Start of memberFunctionString
250610 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
250611 :
250612 : void
250613 0 : SgTemplateParameterVal::post_construction_initialization()
250614 : {
250615 0 : }
250616 :
250617 :
250618 :
250619 : // End of memberFunctionString
250620 : // Start of memberFunctionString
250621 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
250622 :
250623 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
250624 :
250625 : int
250626 0 : SgTemplateParameterVal::get_template_parameter_position () const
250627 : {
250628 0 : ROSE_ASSERT (this != NULL);
250629 :
250630 : #if 0
250631 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250632 : // used to trigger marking transformations for the token-based unparsing.
250633 : printf ("SgTemplateParameterVal::get_template_parameter_position = %p = %s \n",this,this->class_name().c_str());
250634 : #endif
250635 :
250636 0 : return p_template_parameter_position;
250637 : }
250638 :
250639 : void
250640 0 : SgTemplateParameterVal::set_template_parameter_position ( int template_parameter_position )
250641 : {
250642 0 : ROSE_ASSERT (this != NULL);
250643 :
250644 : #if 0
250645 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250646 : // used to trigger marking transformations for the token-based unparsing.
250647 : printf ("SgTemplateParameterVal::set_template_parameter_position = %p = %s \n",this,this->class_name().c_str());
250648 : #endif
250649 :
250650 0 : set_isModified(true);
250651 :
250652 0 : p_template_parameter_position = template_parameter_position;
250653 0 : }
250654 :
250655 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
250656 :
250657 :
250658 : // End of memberFunctionString
250659 : // Start of memberFunctionString
250660 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
250661 :
250662 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
250663 :
250664 : std::string
250665 0 : SgTemplateParameterVal::get_valueString () const
250666 : {
250667 0 : ROSE_ASSERT (this != NULL);
250668 :
250669 : #if 0
250670 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250671 : // used to trigger marking transformations for the token-based unparsing.
250672 : printf ("SgTemplateParameterVal::get_valueString = %p = %s \n",this,this->class_name().c_str());
250673 : #endif
250674 :
250675 0 : return p_valueString;
250676 : }
250677 :
250678 : void
250679 0 : SgTemplateParameterVal::set_valueString ( std::string valueString )
250680 : {
250681 0 : ROSE_ASSERT (this != NULL);
250682 :
250683 : #if 0
250684 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250685 : // used to trigger marking transformations for the token-based unparsing.
250686 : printf ("SgTemplateParameterVal::set_valueString = %p = %s \n",this,this->class_name().c_str());
250687 : #endif
250688 :
250689 0 : set_isModified(true);
250690 :
250691 0 : p_valueString = valueString;
250692 0 : }
250693 :
250694 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
250695 :
250696 :
250697 : // End of memberFunctionString
250698 : // Start of memberFunctionString
250699 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
250700 :
250701 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
250702 :
250703 : SgType*
250704 0 : SgTemplateParameterVal::get_valueType () const
250705 : {
250706 0 : ROSE_ASSERT (this != NULL);
250707 :
250708 : #if 0
250709 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250710 : // used to trigger marking transformations for the token-based unparsing.
250711 : printf ("SgTemplateParameterVal::get_valueType = %p = %s \n",this,this->class_name().c_str());
250712 : #endif
250713 :
250714 0 : return p_valueType;
250715 : }
250716 :
250717 : void
250718 0 : SgTemplateParameterVal::set_valueType ( SgType* valueType )
250719 : {
250720 0 : ROSE_ASSERT (this != NULL);
250721 :
250722 : #if 0
250723 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
250724 : // used to trigger marking transformations for the token-based unparsing.
250725 : printf ("SgTemplateParameterVal::set_valueType = %p = %s \n",this,this->class_name().c_str());
250726 : #endif
250727 :
250728 0 : set_isModified(true);
250729 :
250730 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
250731 : if (p_valueType != NULL && valueType != NULL && p_valueType != valueType)
250732 : {
250733 : printf ("Warning: valueType = %p overwriting valid pointer p_valueType = %p \n",valueType,p_valueType);
250734 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
250735 : printf ("Error fails assertion (p_valueType != NULL && valueType != NULL && p_valueType != valueType) is false\n");
250736 : ROSE_ASSERT(false);
250737 : #endif
250738 : }
250739 : #endif
250740 0 : p_valueType = valueType;
250741 0 : }
250742 :
250743 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
250744 :
250745 :
250746 : // End of memberFunctionString
250747 : // Start of memberFunctionString
250748 : /* #line 4284 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
250749 :
250750 :
250751 : SgName
250752 0 : SgTemplateParameterVal::get_template_parameter_name() const
250753 : {
250754 : // DQ (11/28/2011): Added to support template declarations in the AST.
250755 :
250756 : // Note that we have to store the index position into the template parameter list
250757 : // so that this template parameter can be identified and its name used. It
250758 : // can be different from the template parameter name of the template class declaration
250759 : // (which is the name referenced in EDG), so we have to find the enclosing template
250760 : // declaration and use the index position into its template parameter list (which
250761 : // can of course use different names).
250762 :
250763 : // DQ (7/24/2012): Added test.
250764 0 : ROSE_ASSERT(this != NULL);
250765 :
250766 0 : ROSE_ASSERT(get_parent() != NULL);
250767 :
250768 : // DQ (7/24/2012): For the new EDG support (4.x) and new template handling, we don't use
250769 : // a generic SgTemplateDeclaration; instead we have specific kinds of template declarations.
250770 : // So templateDeclaration will always be NULL now.
250771 :
250772 0 : int template_parameter_position = get_template_parameter_position();
250773 :
250774 : #if 0
250775 : SgTemplateDeclaration* templateDeclaration = TransformationSupport::getTemplateDeclaration(this);
250776 : if (templateDeclaration == NULL)
250777 : {
250778 : printf ("Error: In SgTemplateParameterVal::get_template_parameter_name(): templateDeclaration == NULL: this = %p = %s \n",this,this->class_name().c_str());
250779 : }
250780 :
250781 : #error "DEAD CODE!"
250782 :
250783 : ROSE_ASSERT(templateDeclaration != NULL);
250784 :
250785 : SgTemplateParameterPtrList & templateParameters = templateDeclaration->get_templateParameters();
250786 : #else
250787 : // DQ (7/25/2012): This reflects the new design of how templates are supported in ROSE.
250788 0 : SgDeclarationStatement* templateDeclaration = TransformationSupport::getTemplateDeclaration(this);
250789 0 : if (templateDeclaration == NULL)
250790 : {
250791 0 : printf ("Error: In SgTemplateParameterVal::get_template_parameter_name(): templateDeclaration == NULL: this = %p = %s \n",this,this->class_name().c_str());
250792 :
250793 : // DQ (6/6/2013): If the template parameter is used as a template argument, then we just return a simple name.
250794 : // Nowever, maybe the constant should have been shared so that it would be correctly associated with a template declaration.
250795 0 : SgName name = "__template_parameter_used_as_template_argument__";
250796 : #if 0
250797 : printf ("In SgTemplateParameterVal::get_template_parameter_name(): template_parameter_position = %d I think this is the case of a template parameter used as an argument to another template (see test2013_198.C) \n",template_parameter_position);
250798 : #endif
250799 0 : return name;
250800 : }
250801 0 : ROSE_ASSERT(templateDeclaration != NULL);
250802 :
250803 0 : SgTemplateParameterPtrList* templateParameters = NULL;
250804 0 : switch(templateDeclaration->variantT())
250805 : {
250806 0 : case V_SgTemplateDeclaration: templateParameters = &(isSgTemplateDeclaration(templateDeclaration)->get_templateParameters()); break;
250807 0 : case V_SgTemplateClassDeclaration: templateParameters = &(isSgTemplateClassDeclaration(templateDeclaration)->get_templateParameters()); break;
250808 :
250809 : // DQ (2/1/2019): Bug fix, likely copy-paste error, casting to wrong type.
250810 : // case V_SgTemplateFunctionDeclaration: templateParameters = &(isSgTemplateMemberFunctionDeclaration(templateDeclaration)->get_templateParameters()); break;
250811 0 : case V_SgTemplateFunctionDeclaration: templateParameters = &(isSgTemplateFunctionDeclaration(templateDeclaration)->get_templateParameters()); break;
250812 :
250813 0 : case V_SgTemplateMemberFunctionDeclaration: templateParameters = &(isSgTemplateMemberFunctionDeclaration(templateDeclaration)->get_templateParameters()); break;
250814 0 : case V_SgTemplateVariableDeclaration: templateParameters = &(isSgTemplateVariableDeclaration(templateDeclaration)->get_templateParameters()); break;
250815 :
250816 0 : default:
250817 0 : {
250818 0 : printf ("Error: default reached in SgTemplateParameterVal::get_template_parameter_name(): templateDeclaration = %p = %s \n",templateDeclaration,templateDeclaration->class_name().c_str());
250819 0 : ROSE_ASSERT(false);
250820 : }
250821 : }
250822 :
250823 0 : ROSE_ASSERT(templateParameters != NULL);
250824 : #endif
250825 :
250826 0 : long int numberOfTemplateParameters = (long int) templateParameters->size();
250827 :
250828 : // DQ (12/13/2011): this is a problem demonstrated by test2011_186.C, so we have to disable the template parameter position error checking.
250829 0 : bool getParameterNameFromTemplateParameterList = true;
250830 : // if (template_parameter_position >= (long int) templateParameters.size())
250831 0 : if (template_parameter_position >= numberOfTemplateParameters)
250832 : {
250833 : #if 0
250834 : printf ("This is a reference to a template parameter in an outer scope (e.g. we are a part of a member function with out explicit templates within a templated class declaration) \n");
250835 : #endif
250836 0 : getParameterNameFromTemplateParameterList = false;
250837 : }
250838 :
250839 : // printf ("In SgTemplateParameterVal::get_template_parameter_name(): template_parameter_position = %d \n",template_parameter_position);
250840 : // printf ("In SgTemplateParameterVal::get_template_parameter_name(): templateParameters.size() = %" PRIuPTR " \n",templateParameters.size());
250841 :
250842 : #if 0
250843 : // if (template_parameter_position >= (long int)(templateParameters.size()))
250844 : if (template_parameter_position >= numberOfTemplateParameters)
250845 : {
250846 : printf ("In SgTemplateParameterVal::get_template_parameter_name(): template_parameter_position = %d \n",template_parameter_position);
250847 : // printf ("In SgTemplateParameterVal::get_template_parameter_name(): templateParameters.size() = %" PRIuPTR " \n",templateParameters.size());
250848 : printf ("In SgTemplateParameterVal::get_template_parameter_name(): numberOfTemplateParameters = %" PRIuPTR " \n",numberOfTemplateParameters);
250849 : }
250850 :
250851 : printf ("In SgTemplateParameterVal::get_template_parameter_name(): getParameterNameFromTemplateParameterList = %s \n",getParameterNameFromTemplateParameterList ? "true" : "false");
250852 : #endif
250853 :
250854 0 : SgName name;
250855 0 : if (getParameterNameFromTemplateParameterList == true)
250856 : {
250857 0 : ROSE_ASSERT(template_parameter_position >= 0);
250858 : // ROSE_ASSERT(template_parameter_position < (long int)(templateParameters.size()));
250859 0 : ROSE_ASSERT(template_parameter_position < numberOfTemplateParameters);
250860 :
250861 : // SgTemplateParameter* templateParameter = templateParameters[position];
250862 :
250863 0 : name = "__template_parameter_name__error__";
250864 :
250865 0 : SgTemplateParameter* templateParameter = NULL;
250866 0 : if (template_parameter_position >= 0)
250867 : {
250868 : // templateParameter = templateParameters[template_parameter_position];
250869 0 : templateParameter = (*templateParameters)[template_parameter_position];
250870 0 : ROSE_ASSERT(templateParameter != NULL);
250871 :
250872 : // printf ("In SgTemplateParameterVal::get_template_parameter_name(): templateParameter->get_parameterType() = %d \n",templateParameter->get_parameterType());
250873 :
250874 0 : ROSE_ASSERT(templateParameter->get_parameterType() == SgTemplateParameter::nontype_parameter);
250875 : // ROSE_ASSERT(templateParameter->get_parameterType() == SgTemplateParameter::template_parameter);
250876 :
250877 0 : SgInitializedName* initializedName = templateParameter->get_initializedName();
250878 0 : ROSE_ASSERT(initializedName != NULL);
250879 :
250880 : // name = "__template_parameter_name__";
250881 0 : name = initializedName->get_name();
250882 :
250883 : // printf ("In SgTemplateParameterVal::get_template_parameter_name(): name of template parameter used = %s \n",name.str());
250884 : }
250885 : }
250886 : else
250887 : {
250888 : // This is not the favored case since i think it can be problematic to use template parameter names.
250889 0 : name = get_valueString();
250890 : #if 0
250891 : printf ("In SgTemplateParameterVal::get_template_parameter_name(): Using the string in the template parameter value = %s \n",name.str());
250892 : #endif
250893 : }
250894 :
250895 : #if 0
250896 : printf ("In SgTemplateParameterVal::get_template_parameter_name(): Using the string in the template parameteer value = %s \n",name.str());
250897 : #endif
250898 :
250899 0 : return name;
250900 : }
250901 :
250902 : SgType*
250903 0 : SgTemplateParameterVal::get_type() const
250904 : {
250905 : // DQ (8/6/2013): The correct type is now saved explicitly so that it can be used to disambiguate
250906 : // template functions overloaded on template parameters. See test2013_303.C for an example.
250907 0 : ROSE_ASSERT(this->get_valueType() != NULL);
250908 :
250909 : #if 0
250910 : printf ("In SgTemplateParameterVal::get_type() \n");
250911 : #endif
250912 :
250913 0 : return this->get_valueType();
250914 : }
250915 :
250916 :
250917 :
250918 :
250919 : // End of memberFunctionString
250920 : // Start of memberFunctionString
250921 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
250922 :
250923 : // *** COMMON CODE SECTION BEGINS HERE ***
250924 :
250925 : #if 0
250926 : int
250927 : SgTemplateParameterVal::getVariant() const
250928 : {
250929 : // This function is used in ROSE while "variant()" is used in SAGE
250930 : assert(this != NULL);
250931 : return variant();
250932 : }
250933 : #endif
250934 :
250935 : // This function is used in ROSE in treeTraversal code
250936 : // eventually replaces getVariant() and variant()
250937 : // though after variant() has been removed for a while we will
250938 : // want to change the name of variantT() back to variant()
250939 : // (since the "T" was ment to stand for temporary).
250940 : // When this happens the variantT() will be depricated.
250941 : VariantT
250942 0 : SgTemplateParameterVal::variantT() const
250943 : {
250944 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
250945 0 : ROSE_ASSERT(this != NULL);
250946 0 : return V_SgTemplateParameterVal;
250947 : }
250948 :
250949 : #if 0
250950 : int
250951 : SgTemplateParameterVal::variant() const
250952 : {
250953 : // This function is used in SAGE
250954 : ROSE_ASSERT(this != NULL);
250955 : return TEMPLATE_PARAMETER_VAL;
250956 : }
250957 : #endif
250958 :
250959 : ROSE_DLL_API const char*
250960 0 : SgTemplateParameterVal::sage_class_name() const
250961 : {
250962 0 : ROSE_ASSERT(this != NULL);
250963 0 : return "SgTemplateParameterVal";
250964 : }
250965 :
250966 : std::string
250967 0 : SgTemplateParameterVal::class_name() const
250968 : {
250969 0 : ROSE_ASSERT(this != NULL);
250970 0 : return "SgTemplateParameterVal";
250971 : }
250972 :
250973 : // DQ (11/26/2005): Support for visitor pattern mechanims
250974 : // (inferior to ROSE traversal mechanism, experimental).
250975 : void
250976 0 : SgTemplateParameterVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
250977 : {
250978 0 : ROSE_ASSERT(this != NULL);
250979 0 : visitor.visit(this);
250980 0 : }
250981 :
250982 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
250983 0 : void SgTemplateParameterVal::accept (ROSE_VisitorPattern & visitor) {
250984 0 : ROSE_ASSERT(this != NULL);
250985 0 : visitor.visit(this);
250986 0 : }
250987 :
250988 : SgTemplateParameterVal*
250989 0 : SgTemplateParameterVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
250990 : {
250991 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
250992 : // This function is currently only supported for the AST used the represent Binary executables.
250993 : if (0 /* isSgAsmNode(this) != NULL */)
250994 : {
250995 : // Support for regex specification.
250996 : std::string prefixCode = "REGEX:";
250997 : addNewAttribute(prefixCode + s,a);
250998 : }
250999 : #endif
251000 :
251001 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
251002 0 : return this;
251003 : }
251004 :
251005 : // *** COMMON CODE SECTION ENDS HERE ***
251006 :
251007 :
251008 : // End of memberFunctionString
251009 : // Start of memberFunctionString
251010 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
251011 :
251012 :
251013 : #if 0
251014 : //! Error checking support
251015 : /*! Verifies the following:
251016 : - working getVariant() member function
251017 : - calls base class's error() member function
251018 : Every class has one of these functions.
251019 : */
251020 : bool
251021 : SgTemplateParameterVal::error()
251022 : {
251023 : // Put error checking here
251024 :
251025 : ROSE_ASSERT (this != NULL);
251026 : if (getVariant() != TEMPLATE_PARAMETER_VAL)
251027 : {
251028 : printf ("Error in SgTemplateParameterVal::error(): SgTemplateParameterVal object has a %s variant \n",
251029 : Cxx_GrammarTerminalNames[getVariant()].name);
251030 : // printf ("Error in SgTemplateParameterVal::error() \n");
251031 : ROSE_ABORT();
251032 : }
251033 :
251034 : ROSE_ASSERT (getVariant() == TEMPLATE_PARAMETER_VAL);
251035 : return SgValueExp::error();
251036 : }
251037 : #endif
251038 :
251039 :
251040 :
251041 : // End of memberFunctionString
251042 :
251043 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
251044 :
251045 0 : SgTemplateParameterVal* isSgTemplateParameterVal ( SgNode* inputDerivedClassPointer )
251046 : {
251047 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
251048 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
251049 : // So to fix this we return NULL directly when the input is NULL and avoid the
251050 : // dynamic_cast in this case. This is likely a performance improvement as well.
251051 : // return dynamic_cast<SgTemplateParameterVal*>(inputDerivedClassPointer);
251052 : // Milind Chabbi (8/28/2013): isSgTemplateParameterVal uses table-driven castability instead of c++ default dynamic_cast
251053 : // this improves the running time performance by 10-20%.
251054 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateParameterVal*>(inputDerivedClassPointer);
251055 0 : return IS_SgTemplateParameterVal_FAST_MACRO(inputDerivedClassPointer);
251056 : }
251057 :
251058 : // DQ (11/8/2003): Added version of functions taking const pointer
251059 0 : const SgTemplateParameterVal* isSgTemplateParameterVal ( const SgNode* inputDerivedClassPointer )
251060 : {
251061 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
251062 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
251063 : // So to fix this we return NULL directly when the input is NULL and avoid the
251064 : // dynamic_cast in this case. This is likely a performance improvement as well.
251065 : // return dynamic_cast<const SgTemplateParameterVal*>(inputDerivedClassPointer);
251066 : // Milind Chabbi (8/28/2013): isSgTemplateParameterVal uses table-driven castability instead of c++ default dynamic_cast
251067 : // this improves the running time performance by 10-20%.
251068 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateParameterVal*>(inputDerivedClassPointer);
251069 0 : return IS_SgTemplateParameterVal_FAST_MACRO(inputDerivedClassPointer);
251070 : }
251071 :
251072 :
251073 :
251074 : /* #line 251075 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251075 :
251076 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
251077 :
251078 : /**
251079 : \brief Generated destructor
251080 :
251081 : This destructor is automatically generated (by ROSETTA). This destructor
251082 : only frees memory of data members associated with the parts of the current IR node which
251083 : are NOT traversed. Those data members that are part of a traversal can be freed using
251084 : a traversal (calling this destructor on all children in a post-order traversal). Such
251085 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
251086 :
251087 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
251088 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
251089 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
251090 :
251091 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
251092 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
251093 : pointers are not yet implemented to call delete on eash pointer in the container.
251094 : (This could be done by derivation from the STL containers to define containers that
251095 : automatically deleted their members.)
251096 :
251097 : */
251098 0 : SgTemplateParameterVal::~SgTemplateParameterVal () {
251099 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
251100 :
251101 :
251102 : // case: not a listType for template_parameter_position
251103 0 : p_template_parameter_position = -1; // non list case
251104 : // case: not a listType for valueString
251105 0 : p_valueString = ""; // non list case
251106 : // case: not a listType for valueType
251107 0 : p_valueType = NULL; // non list case
251108 :
251109 : }
251110 :
251111 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
251112 0 : }
251113 :
251114 :
251115 : /* #line 251116 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251116 :
251117 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
251118 :
251119 : // Generated constructor
251120 0 : SgTemplateParameterVal::SgTemplateParameterVal ( Sg_File_Info* startOfConstruct, int template_parameter_position, std::string valueString )
251121 0 : : SgValueExp(startOfConstruct)
251122 : {
251123 : #ifdef DEBUG
251124 : // printf ("In SgTemplateParameterVal::SgTemplateParameterVal (Sg_File_Info* startOfConstruct, int template_parameter_position, std::string valueString) sage_class_name() = %s \n",sage_class_name());
251125 : #endif
251126 : #if 0
251127 : // debugging information!
251128 : printf ("In SgTemplateParameterVal::SgTemplateParameterVal (Sg_File_Info* startOfConstruct, int template_parameter_position, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
251129 : #endif
251130 :
251131 0 : p_template_parameter_position = template_parameter_position;
251132 0 : p_valueString = valueString;
251133 0 : p_valueType = NULL;
251134 :
251135 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
251136 :
251137 : #if 0
251138 : // DQ (7/30/2014): Call a virtual function.
251139 : std::string s = this->class_name();
251140 : #endif
251141 :
251142 : // Test the variant virtual function
251143 : // assert(TEMPLATE_PARAMETER_VAL == variant());
251144 0 : assert(TEMPLATE_PARAMETER_VAL == this->variant());
251145 0 : ROSE_ASSERT(TEMPLATE_PARAMETER_VAL == (int)(this->variantT()));
251146 0 : post_construction_initialization();
251147 :
251148 : // Test the isSgTemplateParameterVal() function since it has been problematic
251149 0 : assert(isSgTemplateParameterVal(this) != NULL);
251150 0 : }
251151 :
251152 : // Generated constructor (all data members)
251153 :
251154 : /* #line 251155 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251155 :
251156 :
251157 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
251158 :
251159 :
251160 : // ********************************************************
251161 : // member functions common across all array grammar objects
251162 : // ********************************************************
251163 :
251164 :
251165 :
251166 : /* #line 251167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251167 :
251168 :
251169 :
251170 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
251171 :
251172 : // ********************************************************
251173 : // member functions specific to each node in the grammar
251174 : // ********************************************************
251175 :
251176 :
251177 : /* #line 251178 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251178 :
251179 : // Start of memberFunctionString
251180 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251181 :
251182 : void
251183 125 : SgNullptrValExp::post_construction_initialization()
251184 : {
251185 125 : }
251186 :
251187 :
251188 :
251189 : // End of memberFunctionString
251190 : // Start of memberFunctionString
251191 : /* #line 4003 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251192 :
251193 :
251194 :
251195 : // End of memberFunctionString
251196 : // Start of memberFunctionString
251197 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251198 :
251199 :
251200 : SgType*
251201 179 : SgNullptrValExp::get_type(void) const
251202 : {
251203 : #if 0
251204 : printf ("In SgNullptrValExp::get_type() \n");
251205 : #endif
251206 :
251207 179 : return SgTypeNullptr::createType();
251208 : }
251209 :
251210 :
251211 :
251212 : // End of memberFunctionString
251213 : // Start of memberFunctionString
251214 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
251215 :
251216 : // *** COMMON CODE SECTION BEGINS HERE ***
251217 :
251218 : #if 0
251219 : int
251220 : SgNullptrValExp::getVariant() const
251221 : {
251222 : // This function is used in ROSE while "variant()" is used in SAGE
251223 : assert(this != NULL);
251224 : return variant();
251225 : }
251226 : #endif
251227 :
251228 : // This function is used in ROSE in treeTraversal code
251229 : // eventually replaces getVariant() and variant()
251230 : // though after variant() has been removed for a while we will
251231 : // want to change the name of variantT() back to variant()
251232 : // (since the "T" was ment to stand for temporary).
251233 : // When this happens the variantT() will be depricated.
251234 : VariantT
251235 21582 : SgNullptrValExp::variantT() const
251236 : {
251237 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
251238 21582 : ROSE_ASSERT(this != NULL);
251239 21582 : return V_SgNullptrValExp;
251240 : }
251241 :
251242 : #if 0
251243 : int
251244 : SgNullptrValExp::variant() const
251245 : {
251246 : // This function is used in SAGE
251247 : ROSE_ASSERT(this != NULL);
251248 : return NULLPTR_VAL;
251249 : }
251250 : #endif
251251 :
251252 : ROSE_DLL_API const char*
251253 0 : SgNullptrValExp::sage_class_name() const
251254 : {
251255 0 : ROSE_ASSERT(this != NULL);
251256 0 : return "SgNullptrValExp";
251257 : }
251258 :
251259 : std::string
251260 101 : SgNullptrValExp::class_name() const
251261 : {
251262 101 : ROSE_ASSERT(this != NULL);
251263 101 : return "SgNullptrValExp";
251264 : }
251265 :
251266 : // DQ (11/26/2005): Support for visitor pattern mechanims
251267 : // (inferior to ROSE traversal mechanism, experimental).
251268 : void
251269 951 : SgNullptrValExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
251270 : {
251271 951 : ROSE_ASSERT(this != NULL);
251272 951 : visitor.visit(this);
251273 951 : }
251274 :
251275 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
251276 0 : void SgNullptrValExp::accept (ROSE_VisitorPattern & visitor) {
251277 0 : ROSE_ASSERT(this != NULL);
251278 0 : visitor.visit(this);
251279 0 : }
251280 :
251281 : SgNullptrValExp*
251282 0 : SgNullptrValExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
251283 : {
251284 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
251285 : // This function is currently only supported for the AST used the represent Binary executables.
251286 : if (0 /* isSgAsmNode(this) != NULL */)
251287 : {
251288 : // Support for regex specification.
251289 : std::string prefixCode = "REGEX:";
251290 : addNewAttribute(prefixCode + s,a);
251291 : }
251292 : #endif
251293 :
251294 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
251295 0 : return this;
251296 : }
251297 :
251298 : // *** COMMON CODE SECTION ENDS HERE ***
251299 :
251300 :
251301 : // End of memberFunctionString
251302 : // Start of memberFunctionString
251303 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
251304 :
251305 :
251306 : #if 0
251307 : //! Error checking support
251308 : /*! Verifies the following:
251309 : - working getVariant() member function
251310 : - calls base class's error() member function
251311 : Every class has one of these functions.
251312 : */
251313 : bool
251314 : SgNullptrValExp::error()
251315 : {
251316 : // Put error checking here
251317 :
251318 : ROSE_ASSERT (this != NULL);
251319 : if (getVariant() != NULLPTR_VAL)
251320 : {
251321 : printf ("Error in SgNullptrValExp::error(): SgNullptrValExp object has a %s variant \n",
251322 : Cxx_GrammarTerminalNames[getVariant()].name);
251323 : // printf ("Error in SgNullptrValExp::error() \n");
251324 : ROSE_ABORT();
251325 : }
251326 :
251327 : ROSE_ASSERT (getVariant() == NULLPTR_VAL);
251328 : return SgValueExp::error();
251329 : }
251330 : #endif
251331 :
251332 :
251333 :
251334 : // End of memberFunctionString
251335 :
251336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
251337 :
251338 125 : SgNullptrValExp* isSgNullptrValExp ( SgNode* inputDerivedClassPointer )
251339 : {
251340 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
251341 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
251342 : // So to fix this we return NULL directly when the input is NULL and avoid the
251343 : // dynamic_cast in this case. This is likely a performance improvement as well.
251344 : // return dynamic_cast<SgNullptrValExp*>(inputDerivedClassPointer);
251345 : // Milind Chabbi (8/28/2013): isSgNullptrValExp uses table-driven castability instead of c++ default dynamic_cast
251346 : // this improves the running time performance by 10-20%.
251347 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNullptrValExp*>(inputDerivedClassPointer);
251348 125 : return IS_SgNullptrValExp_FAST_MACRO(inputDerivedClassPointer);
251349 : }
251350 :
251351 : // DQ (11/8/2003): Added version of functions taking const pointer
251352 0 : const SgNullptrValExp* isSgNullptrValExp ( const SgNode* inputDerivedClassPointer )
251353 : {
251354 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
251355 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
251356 : // So to fix this we return NULL directly when the input is NULL and avoid the
251357 : // dynamic_cast in this case. This is likely a performance improvement as well.
251358 : // return dynamic_cast<const SgNullptrValExp*>(inputDerivedClassPointer);
251359 : // Milind Chabbi (8/28/2013): isSgNullptrValExp uses table-driven castability instead of c++ default dynamic_cast
251360 : // this improves the running time performance by 10-20%.
251361 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNullptrValExp*>(inputDerivedClassPointer);
251362 0 : return IS_SgNullptrValExp_FAST_MACRO(inputDerivedClassPointer);
251363 : }
251364 :
251365 :
251366 :
251367 : /* #line 251368 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251368 :
251369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
251370 :
251371 : /**
251372 : \brief Generated destructor
251373 :
251374 : This destructor is automatically generated (by ROSETTA). This destructor
251375 : only frees memory of data members associated with the parts of the current IR node which
251376 : are NOT traversed. Those data members that are part of a traversal can be freed using
251377 : a traversal (calling this destructor on all children in a post-order traversal). Such
251378 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
251379 :
251380 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
251381 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
251382 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
251383 :
251384 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
251385 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
251386 : pointers are not yet implemented to call delete on eash pointer in the container.
251387 : (This could be done by derivation from the STL containers to define containers that
251388 : automatically deleted their members.)
251389 :
251390 : */
251391 24 : SgNullptrValExp::~SgNullptrValExp () {
251392 12 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
251393 :
251394 :
251395 :
251396 : }
251397 :
251398 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
251399 24 : }
251400 :
251401 :
251402 : /* #line 251403 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251403 :
251404 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
251405 :
251406 : // Generated constructor
251407 0 : SgNullptrValExp::SgNullptrValExp ( Sg_File_Info* startOfConstruct )
251408 0 : : SgValueExp(startOfConstruct)
251409 : {
251410 : #ifdef DEBUG
251411 : // printf ("In SgNullptrValExp::SgNullptrValExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
251412 : #endif
251413 : #if 0
251414 : // debugging information!
251415 : printf ("In SgNullptrValExp::SgNullptrValExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
251416 : #endif
251417 :
251418 :
251419 :
251420 : #if 0
251421 : // DQ (7/30/2014): Call a virtual function.
251422 : std::string s = this->class_name();
251423 : #endif
251424 :
251425 : // Test the variant virtual function
251426 : // assert(NULLPTR_VAL == variant());
251427 0 : assert(NULLPTR_VAL == this->variant());
251428 0 : ROSE_ASSERT(NULLPTR_VAL == (int)(this->variantT()));
251429 0 : post_construction_initialization();
251430 :
251431 : // Test the isSgNullptrValExp() function since it has been problematic
251432 0 : assert(isSgNullptrValExp(this) != NULL);
251433 0 : }
251434 :
251435 : // Generated constructor (all data members)
251436 :
251437 : /* #line 251438 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251438 :
251439 :
251440 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
251441 :
251442 :
251443 : // ********************************************************
251444 : // member functions common across all array grammar objects
251445 : // ********************************************************
251446 :
251447 :
251448 :
251449 : /* #line 251450 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251450 :
251451 :
251452 :
251453 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
251454 :
251455 : // ********************************************************
251456 : // member functions specific to each node in the grammar
251457 : // ********************************************************
251458 :
251459 :
251460 : /* #line 251461 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251461 :
251462 : // Start of memberFunctionString
251463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
251464 :
251465 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
251466 :
251467 : unsigned short
251468 0 : SgChar16Val::get_valueUL () const
251469 : {
251470 0 : ROSE_ASSERT (this != NULL);
251471 :
251472 : #if 0
251473 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251474 : // used to trigger marking transformations for the token-based unparsing.
251475 : printf ("SgChar16Val::get_valueUL = %p = %s \n",this,this->class_name().c_str());
251476 : #endif
251477 :
251478 0 : return p_valueUL;
251479 : }
251480 :
251481 : void
251482 0 : SgChar16Val::set_valueUL ( unsigned short valueUL )
251483 : {
251484 0 : ROSE_ASSERT (this != NULL);
251485 :
251486 : #if 0
251487 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251488 : // used to trigger marking transformations for the token-based unparsing.
251489 : printf ("SgChar16Val::set_valueUL = %p = %s \n",this,this->class_name().c_str());
251490 : #endif
251491 :
251492 0 : set_isModified(true);
251493 :
251494 0 : p_valueUL = valueUL;
251495 0 : }
251496 :
251497 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
251498 :
251499 :
251500 : // End of memberFunctionString
251501 : // Start of memberFunctionString
251502 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
251503 :
251504 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
251505 :
251506 : std::string
251507 0 : SgChar16Val::get_valueString () const
251508 : {
251509 0 : ROSE_ASSERT (this != NULL);
251510 :
251511 : #if 0
251512 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251513 : // used to trigger marking transformations for the token-based unparsing.
251514 : printf ("SgChar16Val::get_valueString = %p = %s \n",this,this->class_name().c_str());
251515 : #endif
251516 :
251517 0 : return p_valueString;
251518 : }
251519 :
251520 : void
251521 0 : SgChar16Val::set_valueString ( std::string valueString )
251522 : {
251523 0 : ROSE_ASSERT (this != NULL);
251524 :
251525 : #if 0
251526 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251527 : // used to trigger marking transformations for the token-based unparsing.
251528 : printf ("SgChar16Val::set_valueString = %p = %s \n",this,this->class_name().c_str());
251529 : #endif
251530 :
251531 0 : set_isModified(true);
251532 :
251533 0 : p_valueString = valueString;
251534 0 : }
251535 :
251536 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
251537 :
251538 :
251539 : // End of memberFunctionString
251540 : // Start of memberFunctionString
251541 : /* #line 4113 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251542 :
251543 : void
251544 0 : SgChar16Val::post_construction_initialization()
251545 : {
251546 : // We can't initialize this to NULL since it might have just been set!
251547 : // p_valueUL = 0L;
251548 0 : }
251549 :
251550 : // DQ (2/16/2018): ROSE needs to be able to be compiled on non C++11 systems where char_32_t is not defiled.
251551 : // char16_t
251552 : unsigned short
251553 0 : SgChar16Val::get_value() const
251554 : {
251555 0 : return p_valueUL;
251556 : }
251557 :
251558 : // void SgChar16Val::set_value(char16_t new_val)
251559 : void
251560 0 : SgChar16Val::set_value(unsigned short new_val)
251561 : {
251562 0 : p_valueUL = new_val;
251563 0 : }
251564 :
251565 :
251566 :
251567 : // End of memberFunctionString
251568 : // Start of memberFunctionString
251569 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251570 :
251571 :
251572 : SgType*
251573 0 : SgChar16Val::get_type(void) const
251574 : {
251575 : #if 0
251576 : printf ("In SgChar16Val::get_type() \n");
251577 : #endif
251578 :
251579 0 : return SgTypeChar16::createType();
251580 : }
251581 :
251582 :
251583 :
251584 : // End of memberFunctionString
251585 : // Start of memberFunctionString
251586 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
251587 :
251588 : // *** COMMON CODE SECTION BEGINS HERE ***
251589 :
251590 : #if 0
251591 : int
251592 : SgChar16Val::getVariant() const
251593 : {
251594 : // This function is used in ROSE while "variant()" is used in SAGE
251595 : assert(this != NULL);
251596 : return variant();
251597 : }
251598 : #endif
251599 :
251600 : // This function is used in ROSE in treeTraversal code
251601 : // eventually replaces getVariant() and variant()
251602 : // though after variant() has been removed for a while we will
251603 : // want to change the name of variantT() back to variant()
251604 : // (since the "T" was ment to stand for temporary).
251605 : // When this happens the variantT() will be depricated.
251606 : VariantT
251607 0 : SgChar16Val::variantT() const
251608 : {
251609 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
251610 0 : ROSE_ASSERT(this != NULL);
251611 0 : return V_SgChar16Val;
251612 : }
251613 :
251614 : #if 0
251615 : int
251616 : SgChar16Val::variant() const
251617 : {
251618 : // This function is used in SAGE
251619 : ROSE_ASSERT(this != NULL);
251620 : return CHAR16_VAL;
251621 : }
251622 : #endif
251623 :
251624 : ROSE_DLL_API const char*
251625 0 : SgChar16Val::sage_class_name() const
251626 : {
251627 0 : ROSE_ASSERT(this != NULL);
251628 0 : return "SgChar16Val";
251629 : }
251630 :
251631 : std::string
251632 0 : SgChar16Val::class_name() const
251633 : {
251634 0 : ROSE_ASSERT(this != NULL);
251635 0 : return "SgChar16Val";
251636 : }
251637 :
251638 : // DQ (11/26/2005): Support for visitor pattern mechanims
251639 : // (inferior to ROSE traversal mechanism, experimental).
251640 : void
251641 0 : SgChar16Val::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
251642 : {
251643 0 : ROSE_ASSERT(this != NULL);
251644 0 : visitor.visit(this);
251645 0 : }
251646 :
251647 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
251648 0 : void SgChar16Val::accept (ROSE_VisitorPattern & visitor) {
251649 0 : ROSE_ASSERT(this != NULL);
251650 0 : visitor.visit(this);
251651 0 : }
251652 :
251653 : SgChar16Val*
251654 0 : SgChar16Val::addRegExpAttribute(std::string s, AstRegExAttribute* a)
251655 : {
251656 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
251657 : // This function is currently only supported for the AST used the represent Binary executables.
251658 : if (0 /* isSgAsmNode(this) != NULL */)
251659 : {
251660 : // Support for regex specification.
251661 : std::string prefixCode = "REGEX:";
251662 : addNewAttribute(prefixCode + s,a);
251663 : }
251664 : #endif
251665 :
251666 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
251667 0 : return this;
251668 : }
251669 :
251670 : // *** COMMON CODE SECTION ENDS HERE ***
251671 :
251672 :
251673 : // End of memberFunctionString
251674 : // Start of memberFunctionString
251675 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
251676 :
251677 :
251678 : #if 0
251679 : //! Error checking support
251680 : /*! Verifies the following:
251681 : - working getVariant() member function
251682 : - calls base class's error() member function
251683 : Every class has one of these functions.
251684 : */
251685 : bool
251686 : SgChar16Val::error()
251687 : {
251688 : // Put error checking here
251689 :
251690 : ROSE_ASSERT (this != NULL);
251691 : if (getVariant() != CHAR16_VAL)
251692 : {
251693 : printf ("Error in SgChar16Val::error(): SgChar16Val object has a %s variant \n",
251694 : Cxx_GrammarTerminalNames[getVariant()].name);
251695 : // printf ("Error in SgChar16Val::error() \n");
251696 : ROSE_ABORT();
251697 : }
251698 :
251699 : ROSE_ASSERT (getVariant() == CHAR16_VAL);
251700 : return SgValueExp::error();
251701 : }
251702 : #endif
251703 :
251704 :
251705 :
251706 : // End of memberFunctionString
251707 :
251708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
251709 :
251710 0 : SgChar16Val* isSgChar16Val ( SgNode* inputDerivedClassPointer )
251711 : {
251712 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
251713 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
251714 : // So to fix this we return NULL directly when the input is NULL and avoid the
251715 : // dynamic_cast in this case. This is likely a performance improvement as well.
251716 : // return dynamic_cast<SgChar16Val*>(inputDerivedClassPointer);
251717 : // Milind Chabbi (8/28/2013): isSgChar16Val uses table-driven castability instead of c++ default dynamic_cast
251718 : // this improves the running time performance by 10-20%.
251719 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgChar16Val*>(inputDerivedClassPointer);
251720 0 : return IS_SgChar16Val_FAST_MACRO(inputDerivedClassPointer);
251721 : }
251722 :
251723 : // DQ (11/8/2003): Added version of functions taking const pointer
251724 0 : const SgChar16Val* isSgChar16Val ( const SgNode* inputDerivedClassPointer )
251725 : {
251726 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
251727 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
251728 : // So to fix this we return NULL directly when the input is NULL and avoid the
251729 : // dynamic_cast in this case. This is likely a performance improvement as well.
251730 : // return dynamic_cast<const SgChar16Val*>(inputDerivedClassPointer);
251731 : // Milind Chabbi (8/28/2013): isSgChar16Val uses table-driven castability instead of c++ default dynamic_cast
251732 : // this improves the running time performance by 10-20%.
251733 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgChar16Val*>(inputDerivedClassPointer);
251734 0 : return IS_SgChar16Val_FAST_MACRO(inputDerivedClassPointer);
251735 : }
251736 :
251737 :
251738 :
251739 : /* #line 251740 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251740 :
251741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
251742 :
251743 : /**
251744 : \brief Generated destructor
251745 :
251746 : This destructor is automatically generated (by ROSETTA). This destructor
251747 : only frees memory of data members associated with the parts of the current IR node which
251748 : are NOT traversed. Those data members that are part of a traversal can be freed using
251749 : a traversal (calling this destructor on all children in a post-order traversal). Such
251750 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
251751 :
251752 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
251753 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
251754 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
251755 :
251756 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
251757 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
251758 : pointers are not yet implemented to call delete on eash pointer in the container.
251759 : (This could be done by derivation from the STL containers to define containers that
251760 : automatically deleted their members.)
251761 :
251762 : */
251763 0 : SgChar16Val::~SgChar16Val () {
251764 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
251765 :
251766 :
251767 : // case: not a listType for valueUL
251768 0 : p_valueUL = 0; // non list case
251769 : // case: not a listType for valueString
251770 0 : p_valueString = ""; // non list case
251771 :
251772 : }
251773 :
251774 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
251775 0 : }
251776 :
251777 :
251778 : /* #line 251779 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251779 :
251780 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
251781 :
251782 : // Generated constructor
251783 0 : SgChar16Val::SgChar16Val ( Sg_File_Info* startOfConstruct, unsigned short valueUL, std::string valueString )
251784 0 : : SgValueExp(startOfConstruct)
251785 : {
251786 : #ifdef DEBUG
251787 : // printf ("In SgChar16Val::SgChar16Val (Sg_File_Info* startOfConstruct, unsigned short valueUL, std::string valueString) sage_class_name() = %s \n",sage_class_name());
251788 : #endif
251789 : #if 0
251790 : // debugging information!
251791 : printf ("In SgChar16Val::SgChar16Val (Sg_File_Info* startOfConstruct, unsigned short valueUL, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
251792 : #endif
251793 :
251794 0 : p_valueUL = valueUL;
251795 0 : p_valueString = valueString;
251796 :
251797 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
251798 :
251799 : #if 0
251800 : // DQ (7/30/2014): Call a virtual function.
251801 : std::string s = this->class_name();
251802 : #endif
251803 :
251804 : // Test the variant virtual function
251805 : // assert(CHAR16_VAL == variant());
251806 0 : assert(CHAR16_VAL == this->variant());
251807 0 : ROSE_ASSERT(CHAR16_VAL == (int)(this->variantT()));
251808 0 : post_construction_initialization();
251809 :
251810 : // Test the isSgChar16Val() function since it has been problematic
251811 0 : assert(isSgChar16Val(this) != NULL);
251812 0 : }
251813 :
251814 : // Generated constructor (all data members)
251815 :
251816 : /* #line 251817 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251817 :
251818 :
251819 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
251820 :
251821 :
251822 : // ********************************************************
251823 : // member functions common across all array grammar objects
251824 : // ********************************************************
251825 :
251826 :
251827 :
251828 : /* #line 251829 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251829 :
251830 :
251831 :
251832 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
251833 :
251834 : // ********************************************************
251835 : // member functions specific to each node in the grammar
251836 : // ********************************************************
251837 :
251838 :
251839 : /* #line 251840 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
251840 :
251841 : // Start of memberFunctionString
251842 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
251843 :
251844 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
251845 :
251846 : unsigned int
251847 0 : SgChar32Val::get_valueUL () const
251848 : {
251849 0 : ROSE_ASSERT (this != NULL);
251850 :
251851 : #if 0
251852 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251853 : // used to trigger marking transformations for the token-based unparsing.
251854 : printf ("SgChar32Val::get_valueUL = %p = %s \n",this,this->class_name().c_str());
251855 : #endif
251856 :
251857 0 : return p_valueUL;
251858 : }
251859 :
251860 : void
251861 0 : SgChar32Val::set_valueUL ( unsigned int valueUL )
251862 : {
251863 0 : ROSE_ASSERT (this != NULL);
251864 :
251865 : #if 0
251866 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251867 : // used to trigger marking transformations for the token-based unparsing.
251868 : printf ("SgChar32Val::set_valueUL = %p = %s \n",this,this->class_name().c_str());
251869 : #endif
251870 :
251871 0 : set_isModified(true);
251872 :
251873 0 : p_valueUL = valueUL;
251874 0 : }
251875 :
251876 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
251877 :
251878 :
251879 : // End of memberFunctionString
251880 : // Start of memberFunctionString
251881 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
251882 :
251883 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
251884 :
251885 : std::string
251886 0 : SgChar32Val::get_valueString () const
251887 : {
251888 0 : ROSE_ASSERT (this != NULL);
251889 :
251890 : #if 0
251891 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251892 : // used to trigger marking transformations for the token-based unparsing.
251893 : printf ("SgChar32Val::get_valueString = %p = %s \n",this,this->class_name().c_str());
251894 : #endif
251895 :
251896 0 : return p_valueString;
251897 : }
251898 :
251899 : void
251900 0 : SgChar32Val::set_valueString ( std::string valueString )
251901 : {
251902 0 : ROSE_ASSERT (this != NULL);
251903 :
251904 : #if 0
251905 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
251906 : // used to trigger marking transformations for the token-based unparsing.
251907 : printf ("SgChar32Val::set_valueString = %p = %s \n",this,this->class_name().c_str());
251908 : #endif
251909 :
251910 0 : set_isModified(true);
251911 :
251912 0 : p_valueString = valueString;
251913 0 : }
251914 :
251915 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
251916 :
251917 :
251918 : // End of memberFunctionString
251919 : // Start of memberFunctionString
251920 : /* #line 4139 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251921 :
251922 : void
251923 0 : SgChar32Val::post_construction_initialization()
251924 : {
251925 : // We can't initialize this to NULL since it might have just been set!
251926 : // p_valueUL = 0L;
251927 0 : }
251928 :
251929 : // DQ (2/16/2018): ROSE needs to be able to be compiled on non C++11 systems where char_32_t is not defiled.
251930 : // char32_t
251931 : unsigned int
251932 0 : SgChar32Val::get_value() const
251933 : {
251934 0 : return p_valueUL;
251935 : }
251936 :
251937 : // void SgChar32Val::set_value(char32_t new_val)
251938 : void
251939 0 : SgChar32Val::set_value(unsigned int new_val)
251940 : {
251941 0 : p_valueUL = new_val;
251942 0 : }
251943 :
251944 :
251945 :
251946 : // End of memberFunctionString
251947 : // Start of memberFunctionString
251948 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
251949 :
251950 :
251951 : SgType*
251952 0 : SgChar32Val::get_type(void) const
251953 : {
251954 : #if 0
251955 : printf ("In SgChar32Val::get_type() \n");
251956 : #endif
251957 :
251958 0 : return SgTypeChar32::createType();
251959 : }
251960 :
251961 :
251962 :
251963 : // End of memberFunctionString
251964 : // Start of memberFunctionString
251965 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
251966 :
251967 : // *** COMMON CODE SECTION BEGINS HERE ***
251968 :
251969 : #if 0
251970 : int
251971 : SgChar32Val::getVariant() const
251972 : {
251973 : // This function is used in ROSE while "variant()" is used in SAGE
251974 : assert(this != NULL);
251975 : return variant();
251976 : }
251977 : #endif
251978 :
251979 : // This function is used in ROSE in treeTraversal code
251980 : // eventually replaces getVariant() and variant()
251981 : // though after variant() has been removed for a while we will
251982 : // want to change the name of variantT() back to variant()
251983 : // (since the "T" was ment to stand for temporary).
251984 : // When this happens the variantT() will be depricated.
251985 : VariantT
251986 0 : SgChar32Val::variantT() const
251987 : {
251988 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
251989 0 : ROSE_ASSERT(this != NULL);
251990 0 : return V_SgChar32Val;
251991 : }
251992 :
251993 : #if 0
251994 : int
251995 : SgChar32Val::variant() const
251996 : {
251997 : // This function is used in SAGE
251998 : ROSE_ASSERT(this != NULL);
251999 : return CHAR32_VAL;
252000 : }
252001 : #endif
252002 :
252003 : ROSE_DLL_API const char*
252004 0 : SgChar32Val::sage_class_name() const
252005 : {
252006 0 : ROSE_ASSERT(this != NULL);
252007 0 : return "SgChar32Val";
252008 : }
252009 :
252010 : std::string
252011 0 : SgChar32Val::class_name() const
252012 : {
252013 0 : ROSE_ASSERT(this != NULL);
252014 0 : return "SgChar32Val";
252015 : }
252016 :
252017 : // DQ (11/26/2005): Support for visitor pattern mechanims
252018 : // (inferior to ROSE traversal mechanism, experimental).
252019 : void
252020 0 : SgChar32Val::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
252021 : {
252022 0 : ROSE_ASSERT(this != NULL);
252023 0 : visitor.visit(this);
252024 0 : }
252025 :
252026 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
252027 0 : void SgChar32Val::accept (ROSE_VisitorPattern & visitor) {
252028 0 : ROSE_ASSERT(this != NULL);
252029 0 : visitor.visit(this);
252030 0 : }
252031 :
252032 : SgChar32Val*
252033 0 : SgChar32Val::addRegExpAttribute(std::string s, AstRegExAttribute* a)
252034 : {
252035 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
252036 : // This function is currently only supported for the AST used the represent Binary executables.
252037 : if (0 /* isSgAsmNode(this) != NULL */)
252038 : {
252039 : // Support for regex specification.
252040 : std::string prefixCode = "REGEX:";
252041 : addNewAttribute(prefixCode + s,a);
252042 : }
252043 : #endif
252044 :
252045 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
252046 0 : return this;
252047 : }
252048 :
252049 : // *** COMMON CODE SECTION ENDS HERE ***
252050 :
252051 :
252052 : // End of memberFunctionString
252053 : // Start of memberFunctionString
252054 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
252055 :
252056 :
252057 : #if 0
252058 : //! Error checking support
252059 : /*! Verifies the following:
252060 : - working getVariant() member function
252061 : - calls base class's error() member function
252062 : Every class has one of these functions.
252063 : */
252064 : bool
252065 : SgChar32Val::error()
252066 : {
252067 : // Put error checking here
252068 :
252069 : ROSE_ASSERT (this != NULL);
252070 : if (getVariant() != CHAR32_VAL)
252071 : {
252072 : printf ("Error in SgChar32Val::error(): SgChar32Val object has a %s variant \n",
252073 : Cxx_GrammarTerminalNames[getVariant()].name);
252074 : // printf ("Error in SgChar32Val::error() \n");
252075 : ROSE_ABORT();
252076 : }
252077 :
252078 : ROSE_ASSERT (getVariant() == CHAR32_VAL);
252079 : return SgValueExp::error();
252080 : }
252081 : #endif
252082 :
252083 :
252084 :
252085 : // End of memberFunctionString
252086 :
252087 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
252088 :
252089 0 : SgChar32Val* isSgChar32Val ( SgNode* inputDerivedClassPointer )
252090 : {
252091 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
252092 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
252093 : // So to fix this we return NULL directly when the input is NULL and avoid the
252094 : // dynamic_cast in this case. This is likely a performance improvement as well.
252095 : // return dynamic_cast<SgChar32Val*>(inputDerivedClassPointer);
252096 : // Milind Chabbi (8/28/2013): isSgChar32Val uses table-driven castability instead of c++ default dynamic_cast
252097 : // this improves the running time performance by 10-20%.
252098 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgChar32Val*>(inputDerivedClassPointer);
252099 0 : return IS_SgChar32Val_FAST_MACRO(inputDerivedClassPointer);
252100 : }
252101 :
252102 : // DQ (11/8/2003): Added version of functions taking const pointer
252103 0 : const SgChar32Val* isSgChar32Val ( const SgNode* inputDerivedClassPointer )
252104 : {
252105 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
252106 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
252107 : // So to fix this we return NULL directly when the input is NULL and avoid the
252108 : // dynamic_cast in this case. This is likely a performance improvement as well.
252109 : // return dynamic_cast<const SgChar32Val*>(inputDerivedClassPointer);
252110 : // Milind Chabbi (8/28/2013): isSgChar32Val uses table-driven castability instead of c++ default dynamic_cast
252111 : // this improves the running time performance by 10-20%.
252112 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgChar32Val*>(inputDerivedClassPointer);
252113 0 : return IS_SgChar32Val_FAST_MACRO(inputDerivedClassPointer);
252114 : }
252115 :
252116 :
252117 :
252118 : /* #line 252119 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252119 :
252120 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
252121 :
252122 : /**
252123 : \brief Generated destructor
252124 :
252125 : This destructor is automatically generated (by ROSETTA). This destructor
252126 : only frees memory of data members associated with the parts of the current IR node which
252127 : are NOT traversed. Those data members that are part of a traversal can be freed using
252128 : a traversal (calling this destructor on all children in a post-order traversal). Such
252129 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
252130 :
252131 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
252132 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
252133 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
252134 :
252135 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
252136 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
252137 : pointers are not yet implemented to call delete on eash pointer in the container.
252138 : (This could be done by derivation from the STL containers to define containers that
252139 : automatically deleted their members.)
252140 :
252141 : */
252142 0 : SgChar32Val::~SgChar32Val () {
252143 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
252144 :
252145 :
252146 : // case: not a listType for valueUL
252147 0 : p_valueUL = 0; // non list case
252148 : // case: not a listType for valueString
252149 0 : p_valueString = ""; // non list case
252150 :
252151 : }
252152 :
252153 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
252154 0 : }
252155 :
252156 :
252157 : /* #line 252158 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252158 :
252159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
252160 :
252161 : // Generated constructor
252162 0 : SgChar32Val::SgChar32Val ( Sg_File_Info* startOfConstruct, unsigned int valueUL, std::string valueString )
252163 0 : : SgValueExp(startOfConstruct)
252164 : {
252165 : #ifdef DEBUG
252166 : // printf ("In SgChar32Val::SgChar32Val (Sg_File_Info* startOfConstruct, unsigned int valueUL, std::string valueString) sage_class_name() = %s \n",sage_class_name());
252167 : #endif
252168 : #if 0
252169 : // debugging information!
252170 : printf ("In SgChar32Val::SgChar32Val (Sg_File_Info* startOfConstruct, unsigned int valueUL, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
252171 : #endif
252172 :
252173 0 : p_valueUL = valueUL;
252174 0 : p_valueString = valueString;
252175 :
252176 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
252177 :
252178 : #if 0
252179 : // DQ (7/30/2014): Call a virtual function.
252180 : std::string s = this->class_name();
252181 : #endif
252182 :
252183 : // Test the variant virtual function
252184 : // assert(CHAR32_VAL == variant());
252185 0 : assert(CHAR32_VAL == this->variant());
252186 0 : ROSE_ASSERT(CHAR32_VAL == (int)(this->variantT()));
252187 0 : post_construction_initialization();
252188 :
252189 : // Test the isSgChar32Val() function since it has been problematic
252190 0 : assert(isSgChar32Val(this) != NULL);
252191 0 : }
252192 :
252193 : // Generated constructor (all data members)
252194 :
252195 : /* #line 252196 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252196 :
252197 :
252198 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
252199 :
252200 :
252201 : // ********************************************************
252202 : // member functions common across all array grammar objects
252203 : // ********************************************************
252204 :
252205 :
252206 :
252207 : /* #line 252208 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252208 :
252209 :
252210 :
252211 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
252212 :
252213 : // ********************************************************
252214 : // member functions specific to each node in the grammar
252215 : // ********************************************************
252216 :
252217 :
252218 : /* #line 252219 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252219 :
252220 : // Start of memberFunctionString
252221 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252222 :
252223 : void
252224 0 : SgFloat80Val::post_construction_initialization()
252225 : {
252226 0 : }
252227 :
252228 :
252229 :
252230 : // End of memberFunctionString
252231 : // Start of memberFunctionString
252232 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
252233 :
252234 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
252235 :
252236 : long double
252237 0 : SgFloat80Val::get_value () const
252238 : {
252239 0 : ROSE_ASSERT (this != NULL);
252240 :
252241 : #if 0
252242 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252243 : // used to trigger marking transformations for the token-based unparsing.
252244 : printf ("SgFloat80Val::get_value = %p = %s \n",this,this->class_name().c_str());
252245 : #endif
252246 :
252247 0 : return p_value;
252248 : }
252249 :
252250 : void
252251 0 : SgFloat80Val::set_value ( long double value )
252252 : {
252253 0 : ROSE_ASSERT (this != NULL);
252254 :
252255 : #if 0
252256 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252257 : // used to trigger marking transformations for the token-based unparsing.
252258 : printf ("SgFloat80Val::set_value = %p = %s \n",this,this->class_name().c_str());
252259 : #endif
252260 :
252261 0 : set_isModified(true);
252262 :
252263 0 : p_value = value;
252264 0 : }
252265 :
252266 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
252267 :
252268 :
252269 : // End of memberFunctionString
252270 : // Start of memberFunctionString
252271 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
252272 :
252273 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
252274 :
252275 : std::string
252276 0 : SgFloat80Val::get_valueString () const
252277 : {
252278 0 : ROSE_ASSERT (this != NULL);
252279 :
252280 : #if 0
252281 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252282 : // used to trigger marking transformations for the token-based unparsing.
252283 : printf ("SgFloat80Val::get_valueString = %p = %s \n",this,this->class_name().c_str());
252284 : #endif
252285 :
252286 0 : return p_valueString;
252287 : }
252288 :
252289 : void
252290 0 : SgFloat80Val::set_valueString ( std::string valueString )
252291 : {
252292 0 : ROSE_ASSERT (this != NULL);
252293 :
252294 : #if 0
252295 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252296 : // used to trigger marking transformations for the token-based unparsing.
252297 : printf ("SgFloat80Val::set_valueString = %p = %s \n",this,this->class_name().c_str());
252298 : #endif
252299 :
252300 0 : set_isModified(true);
252301 :
252302 0 : p_valueString = valueString;
252303 0 : }
252304 :
252305 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
252306 :
252307 :
252308 : // End of memberFunctionString
252309 : // Start of memberFunctionString
252310 : /* #line 4277 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252311 :
252312 :
252313 :
252314 : // End of memberFunctionString
252315 : // Start of memberFunctionString
252316 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252317 :
252318 :
252319 : SgType*
252320 0 : SgFloat80Val::get_type(void) const
252321 : {
252322 : #if 0
252323 : printf ("In SgFloat80Val::get_type() \n");
252324 : #endif
252325 :
252326 0 : return SgTypeFloat80::createType();
252327 : }
252328 :
252329 :
252330 :
252331 : // End of memberFunctionString
252332 : // Start of memberFunctionString
252333 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
252334 :
252335 : // *** COMMON CODE SECTION BEGINS HERE ***
252336 :
252337 : #if 0
252338 : int
252339 : SgFloat80Val::getVariant() const
252340 : {
252341 : // This function is used in ROSE while "variant()" is used in SAGE
252342 : assert(this != NULL);
252343 : return variant();
252344 : }
252345 : #endif
252346 :
252347 : // This function is used in ROSE in treeTraversal code
252348 : // eventually replaces getVariant() and variant()
252349 : // though after variant() has been removed for a while we will
252350 : // want to change the name of variantT() back to variant()
252351 : // (since the "T" was ment to stand for temporary).
252352 : // When this happens the variantT() will be depricated.
252353 : VariantT
252354 0 : SgFloat80Val::variantT() const
252355 : {
252356 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
252357 0 : ROSE_ASSERT(this != NULL);
252358 0 : return V_SgFloat80Val;
252359 : }
252360 :
252361 : #if 0
252362 : int
252363 : SgFloat80Val::variant() const
252364 : {
252365 : // This function is used in SAGE
252366 : ROSE_ASSERT(this != NULL);
252367 : return FLOAT_80_VAL;
252368 : }
252369 : #endif
252370 :
252371 : ROSE_DLL_API const char*
252372 0 : SgFloat80Val::sage_class_name() const
252373 : {
252374 0 : ROSE_ASSERT(this != NULL);
252375 0 : return "SgFloat80Val";
252376 : }
252377 :
252378 : std::string
252379 0 : SgFloat80Val::class_name() const
252380 : {
252381 0 : ROSE_ASSERT(this != NULL);
252382 0 : return "SgFloat80Val";
252383 : }
252384 :
252385 : // DQ (11/26/2005): Support for visitor pattern mechanims
252386 : // (inferior to ROSE traversal mechanism, experimental).
252387 : void
252388 0 : SgFloat80Val::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
252389 : {
252390 0 : ROSE_ASSERT(this != NULL);
252391 0 : visitor.visit(this);
252392 0 : }
252393 :
252394 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
252395 0 : void SgFloat80Val::accept (ROSE_VisitorPattern & visitor) {
252396 0 : ROSE_ASSERT(this != NULL);
252397 0 : visitor.visit(this);
252398 0 : }
252399 :
252400 : SgFloat80Val*
252401 0 : SgFloat80Val::addRegExpAttribute(std::string s, AstRegExAttribute* a)
252402 : {
252403 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
252404 : // This function is currently only supported for the AST used the represent Binary executables.
252405 : if (0 /* isSgAsmNode(this) != NULL */)
252406 : {
252407 : // Support for regex specification.
252408 : std::string prefixCode = "REGEX:";
252409 : addNewAttribute(prefixCode + s,a);
252410 : }
252411 : #endif
252412 :
252413 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
252414 0 : return this;
252415 : }
252416 :
252417 : // *** COMMON CODE SECTION ENDS HERE ***
252418 :
252419 :
252420 : // End of memberFunctionString
252421 : // Start of memberFunctionString
252422 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
252423 :
252424 :
252425 : #if 0
252426 : //! Error checking support
252427 : /*! Verifies the following:
252428 : - working getVariant() member function
252429 : - calls base class's error() member function
252430 : Every class has one of these functions.
252431 : */
252432 : bool
252433 : SgFloat80Val::error()
252434 : {
252435 : // Put error checking here
252436 :
252437 : ROSE_ASSERT (this != NULL);
252438 : if (getVariant() != FLOAT_80_VAL)
252439 : {
252440 : printf ("Error in SgFloat80Val::error(): SgFloat80Val object has a %s variant \n",
252441 : Cxx_GrammarTerminalNames[getVariant()].name);
252442 : // printf ("Error in SgFloat80Val::error() \n");
252443 : ROSE_ABORT();
252444 : }
252445 :
252446 : ROSE_ASSERT (getVariant() == FLOAT_80_VAL);
252447 : return SgValueExp::error();
252448 : }
252449 : #endif
252450 :
252451 :
252452 :
252453 : // End of memberFunctionString
252454 :
252455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
252456 :
252457 0 : SgFloat80Val* isSgFloat80Val ( SgNode* inputDerivedClassPointer )
252458 : {
252459 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
252460 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
252461 : // So to fix this we return NULL directly when the input is NULL and avoid the
252462 : // dynamic_cast in this case. This is likely a performance improvement as well.
252463 : // return dynamic_cast<SgFloat80Val*>(inputDerivedClassPointer);
252464 : // Milind Chabbi (8/28/2013): isSgFloat80Val uses table-driven castability instead of c++ default dynamic_cast
252465 : // this improves the running time performance by 10-20%.
252466 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFloat80Val*>(inputDerivedClassPointer);
252467 0 : return IS_SgFloat80Val_FAST_MACRO(inputDerivedClassPointer);
252468 : }
252469 :
252470 : // DQ (11/8/2003): Added version of functions taking const pointer
252471 0 : const SgFloat80Val* isSgFloat80Val ( const SgNode* inputDerivedClassPointer )
252472 : {
252473 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
252474 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
252475 : // So to fix this we return NULL directly when the input is NULL and avoid the
252476 : // dynamic_cast in this case. This is likely a performance improvement as well.
252477 : // return dynamic_cast<const SgFloat80Val*>(inputDerivedClassPointer);
252478 : // Milind Chabbi (8/28/2013): isSgFloat80Val uses table-driven castability instead of c++ default dynamic_cast
252479 : // this improves the running time performance by 10-20%.
252480 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFloat80Val*>(inputDerivedClassPointer);
252481 0 : return IS_SgFloat80Val_FAST_MACRO(inputDerivedClassPointer);
252482 : }
252483 :
252484 :
252485 :
252486 : /* #line 252487 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252487 :
252488 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
252489 :
252490 : /**
252491 : \brief Generated destructor
252492 :
252493 : This destructor is automatically generated (by ROSETTA). This destructor
252494 : only frees memory of data members associated with the parts of the current IR node which
252495 : are NOT traversed. Those data members that are part of a traversal can be freed using
252496 : a traversal (calling this destructor on all children in a post-order traversal). Such
252497 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
252498 :
252499 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
252500 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
252501 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
252502 :
252503 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
252504 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
252505 : pointers are not yet implemented to call delete on eash pointer in the container.
252506 : (This could be done by derivation from the STL containers to define containers that
252507 : automatically deleted their members.)
252508 :
252509 : */
252510 0 : SgFloat80Val::~SgFloat80Val () {
252511 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
252512 :
252513 :
252514 : // case: not a listType for value
252515 0 : p_value = 0.0; // non list case
252516 : // case: not a listType for valueString
252517 0 : p_valueString = ""; // non list case
252518 :
252519 : }
252520 :
252521 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
252522 0 : }
252523 :
252524 :
252525 : /* #line 252526 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252526 :
252527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
252528 :
252529 : // Generated constructor
252530 0 : SgFloat80Val::SgFloat80Val ( Sg_File_Info* startOfConstruct, long double value, std::string valueString )
252531 0 : : SgValueExp(startOfConstruct)
252532 : {
252533 : #ifdef DEBUG
252534 : // printf ("In SgFloat80Val::SgFloat80Val (Sg_File_Info* startOfConstruct, long double value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
252535 : #endif
252536 : #if 0
252537 : // debugging information!
252538 : printf ("In SgFloat80Val::SgFloat80Val (Sg_File_Info* startOfConstruct, long double value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
252539 : #endif
252540 :
252541 0 : p_value = value;
252542 0 : p_valueString = valueString;
252543 :
252544 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
252545 :
252546 : #if 0
252547 : // DQ (7/30/2014): Call a virtual function.
252548 : std::string s = this->class_name();
252549 : #endif
252550 :
252551 : // Test the variant virtual function
252552 : // assert(FLOAT_80_VAL == variant());
252553 0 : assert(FLOAT_80_VAL == this->variant());
252554 0 : ROSE_ASSERT(FLOAT_80_VAL == (int)(this->variantT()));
252555 0 : post_construction_initialization();
252556 :
252557 : // Test the isSgFloat80Val() function since it has been problematic
252558 0 : assert(isSgFloat80Val(this) != NULL);
252559 0 : }
252560 :
252561 : // Generated constructor (all data members)
252562 :
252563 : /* #line 252564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252564 :
252565 :
252566 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
252567 :
252568 :
252569 : // ********************************************************
252570 : // member functions common across all array grammar objects
252571 : // ********************************************************
252572 :
252573 :
252574 :
252575 : /* #line 252576 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252576 :
252577 :
252578 :
252579 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
252580 :
252581 : // ********************************************************
252582 : // member functions specific to each node in the grammar
252583 : // ********************************************************
252584 :
252585 :
252586 : /* #line 252587 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252587 :
252588 : // Start of memberFunctionString
252589 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252590 :
252591 : void
252592 0 : SgFloat128Val::post_construction_initialization()
252593 : {
252594 0 : }
252595 :
252596 :
252597 :
252598 : // End of memberFunctionString
252599 : // Start of memberFunctionString
252600 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
252601 :
252602 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
252603 :
252604 : long double
252605 0 : SgFloat128Val::get_value () const
252606 : {
252607 0 : ROSE_ASSERT (this != NULL);
252608 :
252609 : #if 0
252610 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252611 : // used to trigger marking transformations for the token-based unparsing.
252612 : printf ("SgFloat128Val::get_value = %p = %s \n",this,this->class_name().c_str());
252613 : #endif
252614 :
252615 0 : return p_value;
252616 : }
252617 :
252618 : void
252619 0 : SgFloat128Val::set_value ( long double value )
252620 : {
252621 0 : ROSE_ASSERT (this != NULL);
252622 :
252623 : #if 0
252624 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252625 : // used to trigger marking transformations for the token-based unparsing.
252626 : printf ("SgFloat128Val::set_value = %p = %s \n",this,this->class_name().c_str());
252627 : #endif
252628 :
252629 0 : set_isModified(true);
252630 :
252631 0 : p_value = value;
252632 0 : }
252633 :
252634 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
252635 :
252636 :
252637 : // End of memberFunctionString
252638 : // Start of memberFunctionString
252639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
252640 :
252641 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
252642 :
252643 : std::string
252644 0 : SgFloat128Val::get_valueString () const
252645 : {
252646 0 : ROSE_ASSERT (this != NULL);
252647 :
252648 : #if 0
252649 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252650 : // used to trigger marking transformations for the token-based unparsing.
252651 : printf ("SgFloat128Val::get_valueString = %p = %s \n",this,this->class_name().c_str());
252652 : #endif
252653 :
252654 0 : return p_valueString;
252655 : }
252656 :
252657 : void
252658 0 : SgFloat128Val::set_valueString ( std::string valueString )
252659 : {
252660 0 : ROSE_ASSERT (this != NULL);
252661 :
252662 : #if 0
252663 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
252664 : // used to trigger marking transformations for the token-based unparsing.
252665 : printf ("SgFloat128Val::set_valueString = %p = %s \n",this,this->class_name().c_str());
252666 : #endif
252667 :
252668 0 : set_isModified(true);
252669 :
252670 0 : p_valueString = valueString;
252671 0 : }
252672 :
252673 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
252674 :
252675 :
252676 : // End of memberFunctionString
252677 : // Start of memberFunctionString
252678 : /* #line 4280 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252679 :
252680 :
252681 :
252682 : // End of memberFunctionString
252683 : // Start of memberFunctionString
252684 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252685 :
252686 :
252687 : SgType*
252688 0 : SgFloat128Val::get_type(void) const
252689 : {
252690 : #if 0
252691 : printf ("In SgFloat128Val::get_type() \n");
252692 : #endif
252693 :
252694 0 : return SgTypeFloat128::createType();
252695 : }
252696 :
252697 :
252698 :
252699 : // End of memberFunctionString
252700 : // Start of memberFunctionString
252701 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
252702 :
252703 : // *** COMMON CODE SECTION BEGINS HERE ***
252704 :
252705 : #if 0
252706 : int
252707 : SgFloat128Val::getVariant() const
252708 : {
252709 : // This function is used in ROSE while "variant()" is used in SAGE
252710 : assert(this != NULL);
252711 : return variant();
252712 : }
252713 : #endif
252714 :
252715 : // This function is used in ROSE in treeTraversal code
252716 : // eventually replaces getVariant() and variant()
252717 : // though after variant() has been removed for a while we will
252718 : // want to change the name of variantT() back to variant()
252719 : // (since the "T" was ment to stand for temporary).
252720 : // When this happens the variantT() will be depricated.
252721 : VariantT
252722 0 : SgFloat128Val::variantT() const
252723 : {
252724 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
252725 0 : ROSE_ASSERT(this != NULL);
252726 0 : return V_SgFloat128Val;
252727 : }
252728 :
252729 : #if 0
252730 : int
252731 : SgFloat128Val::variant() const
252732 : {
252733 : // This function is used in SAGE
252734 : ROSE_ASSERT(this != NULL);
252735 : return FLOAT_128_VAL;
252736 : }
252737 : #endif
252738 :
252739 : ROSE_DLL_API const char*
252740 0 : SgFloat128Val::sage_class_name() const
252741 : {
252742 0 : ROSE_ASSERT(this != NULL);
252743 0 : return "SgFloat128Val";
252744 : }
252745 :
252746 : std::string
252747 0 : SgFloat128Val::class_name() const
252748 : {
252749 0 : ROSE_ASSERT(this != NULL);
252750 0 : return "SgFloat128Val";
252751 : }
252752 :
252753 : // DQ (11/26/2005): Support for visitor pattern mechanims
252754 : // (inferior to ROSE traversal mechanism, experimental).
252755 : void
252756 0 : SgFloat128Val::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
252757 : {
252758 0 : ROSE_ASSERT(this != NULL);
252759 0 : visitor.visit(this);
252760 0 : }
252761 :
252762 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
252763 0 : void SgFloat128Val::accept (ROSE_VisitorPattern & visitor) {
252764 0 : ROSE_ASSERT(this != NULL);
252765 0 : visitor.visit(this);
252766 0 : }
252767 :
252768 : SgFloat128Val*
252769 0 : SgFloat128Val::addRegExpAttribute(std::string s, AstRegExAttribute* a)
252770 : {
252771 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
252772 : // This function is currently only supported for the AST used the represent Binary executables.
252773 : if (0 /* isSgAsmNode(this) != NULL */)
252774 : {
252775 : // Support for regex specification.
252776 : std::string prefixCode = "REGEX:";
252777 : addNewAttribute(prefixCode + s,a);
252778 : }
252779 : #endif
252780 :
252781 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
252782 0 : return this;
252783 : }
252784 :
252785 : // *** COMMON CODE SECTION ENDS HERE ***
252786 :
252787 :
252788 : // End of memberFunctionString
252789 : // Start of memberFunctionString
252790 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
252791 :
252792 :
252793 : #if 0
252794 : //! Error checking support
252795 : /*! Verifies the following:
252796 : - working getVariant() member function
252797 : - calls base class's error() member function
252798 : Every class has one of these functions.
252799 : */
252800 : bool
252801 : SgFloat128Val::error()
252802 : {
252803 : // Put error checking here
252804 :
252805 : ROSE_ASSERT (this != NULL);
252806 : if (getVariant() != FLOAT_128_VAL)
252807 : {
252808 : printf ("Error in SgFloat128Val::error(): SgFloat128Val object has a %s variant \n",
252809 : Cxx_GrammarTerminalNames[getVariant()].name);
252810 : // printf ("Error in SgFloat128Val::error() \n");
252811 : ROSE_ABORT();
252812 : }
252813 :
252814 : ROSE_ASSERT (getVariant() == FLOAT_128_VAL);
252815 : return SgValueExp::error();
252816 : }
252817 : #endif
252818 :
252819 :
252820 :
252821 : // End of memberFunctionString
252822 :
252823 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
252824 :
252825 0 : SgFloat128Val* isSgFloat128Val ( SgNode* inputDerivedClassPointer )
252826 : {
252827 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
252828 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
252829 : // So to fix this we return NULL directly when the input is NULL and avoid the
252830 : // dynamic_cast in this case. This is likely a performance improvement as well.
252831 : // return dynamic_cast<SgFloat128Val*>(inputDerivedClassPointer);
252832 : // Milind Chabbi (8/28/2013): isSgFloat128Val uses table-driven castability instead of c++ default dynamic_cast
252833 : // this improves the running time performance by 10-20%.
252834 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFloat128Val*>(inputDerivedClassPointer);
252835 0 : return IS_SgFloat128Val_FAST_MACRO(inputDerivedClassPointer);
252836 : }
252837 :
252838 : // DQ (11/8/2003): Added version of functions taking const pointer
252839 0 : const SgFloat128Val* isSgFloat128Val ( const SgNode* inputDerivedClassPointer )
252840 : {
252841 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
252842 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
252843 : // So to fix this we return NULL directly when the input is NULL and avoid the
252844 : // dynamic_cast in this case. This is likely a performance improvement as well.
252845 : // return dynamic_cast<const SgFloat128Val*>(inputDerivedClassPointer);
252846 : // Milind Chabbi (8/28/2013): isSgFloat128Val uses table-driven castability instead of c++ default dynamic_cast
252847 : // this improves the running time performance by 10-20%.
252848 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFloat128Val*>(inputDerivedClassPointer);
252849 0 : return IS_SgFloat128Val_FAST_MACRO(inputDerivedClassPointer);
252850 : }
252851 :
252852 :
252853 :
252854 : /* #line 252855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252855 :
252856 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
252857 :
252858 : /**
252859 : \brief Generated destructor
252860 :
252861 : This destructor is automatically generated (by ROSETTA). This destructor
252862 : only frees memory of data members associated with the parts of the current IR node which
252863 : are NOT traversed. Those data members that are part of a traversal can be freed using
252864 : a traversal (calling this destructor on all children in a post-order traversal). Such
252865 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
252866 :
252867 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
252868 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
252869 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
252870 :
252871 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
252872 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
252873 : pointers are not yet implemented to call delete on eash pointer in the container.
252874 : (This could be done by derivation from the STL containers to define containers that
252875 : automatically deleted their members.)
252876 :
252877 : */
252878 0 : SgFloat128Val::~SgFloat128Val () {
252879 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
252880 :
252881 :
252882 : // case: not a listType for value
252883 0 : p_value = 0.0; // non list case
252884 : // case: not a listType for valueString
252885 0 : p_valueString = ""; // non list case
252886 :
252887 : }
252888 :
252889 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
252890 0 : }
252891 :
252892 :
252893 : /* #line 252894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252894 :
252895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
252896 :
252897 : // Generated constructor
252898 0 : SgFloat128Val::SgFloat128Val ( Sg_File_Info* startOfConstruct, long double value, std::string valueString )
252899 0 : : SgValueExp(startOfConstruct)
252900 : {
252901 : #ifdef DEBUG
252902 : // printf ("In SgFloat128Val::SgFloat128Val (Sg_File_Info* startOfConstruct, long double value, std::string valueString) sage_class_name() = %s \n",sage_class_name());
252903 : #endif
252904 : #if 0
252905 : // debugging information!
252906 : printf ("In SgFloat128Val::SgFloat128Val (Sg_File_Info* startOfConstruct, long double value, std::string valueString): this = %p = %s \n",this,this->class_name().c_str());
252907 : #endif
252908 :
252909 0 : p_value = value;
252910 0 : p_valueString = valueString;
252911 :
252912 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
252913 :
252914 : #if 0
252915 : // DQ (7/30/2014): Call a virtual function.
252916 : std::string s = this->class_name();
252917 : #endif
252918 :
252919 : // Test the variant virtual function
252920 : // assert(FLOAT_128_VAL == variant());
252921 0 : assert(FLOAT_128_VAL == this->variant());
252922 0 : ROSE_ASSERT(FLOAT_128_VAL == (int)(this->variantT()));
252923 0 : post_construction_initialization();
252924 :
252925 : // Test the isSgFloat128Val() function since it has been problematic
252926 0 : assert(isSgFloat128Val(this) != NULL);
252927 0 : }
252928 :
252929 : // Generated constructor (all data members)
252930 :
252931 : /* #line 252932 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252932 :
252933 :
252934 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
252935 :
252936 :
252937 : // ********************************************************
252938 : // member functions common across all array grammar objects
252939 : // ********************************************************
252940 :
252941 :
252942 :
252943 : /* #line 252944 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252944 :
252945 :
252946 :
252947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
252948 :
252949 : // ********************************************************
252950 : // member functions specific to each node in the grammar
252951 : // ********************************************************
252952 :
252953 :
252954 : /* #line 252955 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
252955 :
252956 : // Start of memberFunctionString
252957 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252958 :
252959 : void
252960 0 : SgVoidVal::post_construction_initialization()
252961 : {
252962 0 : }
252963 :
252964 :
252965 :
252966 : // End of memberFunctionString
252967 : // Start of memberFunctionString
252968 : /* #line 4007 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252969 :
252970 :
252971 :
252972 : // End of memberFunctionString
252973 : // Start of memberFunctionString
252974 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
252975 :
252976 :
252977 : SgType*
252978 0 : SgVoidVal::get_type(void) const
252979 : {
252980 : #if 0
252981 : printf ("In SgVoidVal::get_type() \n");
252982 : #endif
252983 :
252984 0 : return SgTypeVoid::createType();
252985 : }
252986 :
252987 :
252988 :
252989 : // End of memberFunctionString
252990 : // Start of memberFunctionString
252991 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
252992 :
252993 : // *** COMMON CODE SECTION BEGINS HERE ***
252994 :
252995 : #if 0
252996 : int
252997 : SgVoidVal::getVariant() const
252998 : {
252999 : // This function is used in ROSE while "variant()" is used in SAGE
253000 : assert(this != NULL);
253001 : return variant();
253002 : }
253003 : #endif
253004 :
253005 : // This function is used in ROSE in treeTraversal code
253006 : // eventually replaces getVariant() and variant()
253007 : // though after variant() has been removed for a while we will
253008 : // want to change the name of variantT() back to variant()
253009 : // (since the "T" was ment to stand for temporary).
253010 : // When this happens the variantT() will be depricated.
253011 : VariantT
253012 0 : SgVoidVal::variantT() const
253013 : {
253014 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
253015 0 : ROSE_ASSERT(this != NULL);
253016 0 : return V_SgVoidVal;
253017 : }
253018 :
253019 : #if 0
253020 : int
253021 : SgVoidVal::variant() const
253022 : {
253023 : // This function is used in SAGE
253024 : ROSE_ASSERT(this != NULL);
253025 : return VOID_VAL;
253026 : }
253027 : #endif
253028 :
253029 : ROSE_DLL_API const char*
253030 0 : SgVoidVal::sage_class_name() const
253031 : {
253032 0 : ROSE_ASSERT(this != NULL);
253033 0 : return "SgVoidVal";
253034 : }
253035 :
253036 : std::string
253037 0 : SgVoidVal::class_name() const
253038 : {
253039 0 : ROSE_ASSERT(this != NULL);
253040 0 : return "SgVoidVal";
253041 : }
253042 :
253043 : // DQ (11/26/2005): Support for visitor pattern mechanims
253044 : // (inferior to ROSE traversal mechanism, experimental).
253045 : void
253046 0 : SgVoidVal::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
253047 : {
253048 0 : ROSE_ASSERT(this != NULL);
253049 0 : visitor.visit(this);
253050 0 : }
253051 :
253052 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
253053 0 : void SgVoidVal::accept (ROSE_VisitorPattern & visitor) {
253054 0 : ROSE_ASSERT(this != NULL);
253055 0 : visitor.visit(this);
253056 0 : }
253057 :
253058 : SgVoidVal*
253059 0 : SgVoidVal::addRegExpAttribute(std::string s, AstRegExAttribute* a)
253060 : {
253061 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
253062 : // This function is currently only supported for the AST used the represent Binary executables.
253063 : if (0 /* isSgAsmNode(this) != NULL */)
253064 : {
253065 : // Support for regex specification.
253066 : std::string prefixCode = "REGEX:";
253067 : addNewAttribute(prefixCode + s,a);
253068 : }
253069 : #endif
253070 :
253071 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
253072 0 : return this;
253073 : }
253074 :
253075 : // *** COMMON CODE SECTION ENDS HERE ***
253076 :
253077 :
253078 : // End of memberFunctionString
253079 : // Start of memberFunctionString
253080 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
253081 :
253082 :
253083 : #if 0
253084 : //! Error checking support
253085 : /*! Verifies the following:
253086 : - working getVariant() member function
253087 : - calls base class's error() member function
253088 : Every class has one of these functions.
253089 : */
253090 : bool
253091 : SgVoidVal::error()
253092 : {
253093 : // Put error checking here
253094 :
253095 : ROSE_ASSERT (this != NULL);
253096 : if (getVariant() != VOID_VAL)
253097 : {
253098 : printf ("Error in SgVoidVal::error(): SgVoidVal object has a %s variant \n",
253099 : Cxx_GrammarTerminalNames[getVariant()].name);
253100 : // printf ("Error in SgVoidVal::error() \n");
253101 : ROSE_ABORT();
253102 : }
253103 :
253104 : ROSE_ASSERT (getVariant() == VOID_VAL);
253105 : return SgValueExp::error();
253106 : }
253107 : #endif
253108 :
253109 :
253110 :
253111 : // End of memberFunctionString
253112 :
253113 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
253114 :
253115 0 : SgVoidVal* isSgVoidVal ( SgNode* inputDerivedClassPointer )
253116 : {
253117 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
253118 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
253119 : // So to fix this we return NULL directly when the input is NULL and avoid the
253120 : // dynamic_cast in this case. This is likely a performance improvement as well.
253121 : // return dynamic_cast<SgVoidVal*>(inputDerivedClassPointer);
253122 : // Milind Chabbi (8/28/2013): isSgVoidVal uses table-driven castability instead of c++ default dynamic_cast
253123 : // this improves the running time performance by 10-20%.
253124 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVoidVal*>(inputDerivedClassPointer);
253125 0 : return IS_SgVoidVal_FAST_MACRO(inputDerivedClassPointer);
253126 : }
253127 :
253128 : // DQ (11/8/2003): Added version of functions taking const pointer
253129 0 : const SgVoidVal* isSgVoidVal ( const SgNode* inputDerivedClassPointer )
253130 : {
253131 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
253132 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
253133 : // So to fix this we return NULL directly when the input is NULL and avoid the
253134 : // dynamic_cast in this case. This is likely a performance improvement as well.
253135 : // return dynamic_cast<const SgVoidVal*>(inputDerivedClassPointer);
253136 : // Milind Chabbi (8/28/2013): isSgVoidVal uses table-driven castability instead of c++ default dynamic_cast
253137 : // this improves the running time performance by 10-20%.
253138 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVoidVal*>(inputDerivedClassPointer);
253139 0 : return IS_SgVoidVal_FAST_MACRO(inputDerivedClassPointer);
253140 : }
253141 :
253142 :
253143 :
253144 : /* #line 253145 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253145 :
253146 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
253147 :
253148 : /**
253149 : \brief Generated destructor
253150 :
253151 : This destructor is automatically generated (by ROSETTA). This destructor
253152 : only frees memory of data members associated with the parts of the current IR node which
253153 : are NOT traversed. Those data members that are part of a traversal can be freed using
253154 : a traversal (calling this destructor on all children in a post-order traversal). Such
253155 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
253156 :
253157 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
253158 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
253159 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
253160 :
253161 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
253162 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
253163 : pointers are not yet implemented to call delete on eash pointer in the container.
253164 : (This could be done by derivation from the STL containers to define containers that
253165 : automatically deleted their members.)
253166 :
253167 : */
253168 0 : SgVoidVal::~SgVoidVal () {
253169 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
253170 :
253171 :
253172 :
253173 : }
253174 :
253175 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
253176 0 : }
253177 :
253178 :
253179 : /* #line 253180 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253180 :
253181 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
253182 :
253183 : // Generated constructor
253184 0 : SgVoidVal::SgVoidVal ( Sg_File_Info* startOfConstruct )
253185 0 : : SgValueExp(startOfConstruct)
253186 : {
253187 : #ifdef DEBUG
253188 : // printf ("In SgVoidVal::SgVoidVal (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
253189 : #endif
253190 : #if 0
253191 : // debugging information!
253192 : printf ("In SgVoidVal::SgVoidVal (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
253193 : #endif
253194 :
253195 :
253196 :
253197 : #if 0
253198 : // DQ (7/30/2014): Call a virtual function.
253199 : std::string s = this->class_name();
253200 : #endif
253201 :
253202 : // Test the variant virtual function
253203 : // assert(VOID_VAL == variant());
253204 0 : assert(VOID_VAL == this->variant());
253205 0 : ROSE_ASSERT(VOID_VAL == (int)(this->variantT()));
253206 0 : post_construction_initialization();
253207 :
253208 : // Test the isSgVoidVal() function since it has been problematic
253209 0 : assert(isSgVoidVal(this) != NULL);
253210 0 : }
253211 :
253212 : // Generated constructor (all data members)
253213 :
253214 : /* #line 253215 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253215 :
253216 :
253217 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
253218 :
253219 :
253220 : // ********************************************************
253221 : // member functions common across all array grammar objects
253222 : // ********************************************************
253223 :
253224 :
253225 :
253226 : /* #line 253227 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253227 :
253228 :
253229 :
253230 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
253231 :
253232 : // ********************************************************
253233 : // member functions specific to each node in the grammar
253234 : // ********************************************************
253235 :
253236 :
253237 : /* #line 253238 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253238 :
253239 : // Start of memberFunctionString
253240 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
253241 :
253242 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
253243 :
253244 : SgExpression*
253245 115731 : SgCallExpression::get_function () const
253246 : {
253247 115731 : ROSE_ASSERT (this != NULL);
253248 :
253249 : #if 0
253250 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
253251 : // used to trigger marking transformations for the token-based unparsing.
253252 : printf ("SgCallExpression::get_function = %p = %s \n",this,this->class_name().c_str());
253253 : #endif
253254 :
253255 115731 : return p_function;
253256 : }
253257 :
253258 : void
253259 0 : SgCallExpression::set_function ( SgExpression* function )
253260 : {
253261 0 : ROSE_ASSERT (this != NULL);
253262 :
253263 : #if 0
253264 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
253265 : // used to trigger marking transformations for the token-based unparsing.
253266 : printf ("SgCallExpression::set_function = %p = %s \n",this,this->class_name().c_str());
253267 : #endif
253268 :
253269 0 : set_isModified(true);
253270 :
253271 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
253272 : if (p_function != NULL && function != NULL && p_function != function)
253273 : {
253274 : printf ("Warning: function = %p overwriting valid pointer p_function = %p \n",function,p_function);
253275 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
253276 : printf ("Error fails assertion (p_function != NULL && function != NULL && p_function != function) is false\n");
253277 : ROSE_ASSERT(false);
253278 : #endif
253279 : }
253280 : #endif
253281 0 : p_function = function;
253282 0 : }
253283 :
253284 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
253285 :
253286 :
253287 : // End of memberFunctionString
253288 : // Start of memberFunctionString
253289 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
253290 :
253291 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
253292 :
253293 : SgExprListExp*
253294 13903 : SgCallExpression::get_args () const
253295 : {
253296 13903 : ROSE_ASSERT (this != NULL);
253297 :
253298 : #if 0
253299 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
253300 : // used to trigger marking transformations for the token-based unparsing.
253301 : printf ("SgCallExpression::get_args = %p = %s \n",this,this->class_name().c_str());
253302 : #endif
253303 :
253304 13903 : return p_args;
253305 : }
253306 :
253307 : void
253308 0 : SgCallExpression::set_args ( SgExprListExp* args )
253309 : {
253310 0 : ROSE_ASSERT (this != NULL);
253311 :
253312 : #if 0
253313 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
253314 : // used to trigger marking transformations for the token-based unparsing.
253315 : printf ("SgCallExpression::set_args = %p = %s \n",this,this->class_name().c_str());
253316 : #endif
253317 :
253318 0 : set_isModified(true);
253319 :
253320 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
253321 : if (p_args != NULL && args != NULL && p_args != args)
253322 : {
253323 : printf ("Warning: args = %p overwriting valid pointer p_args = %p \n",args,p_args);
253324 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
253325 : printf ("Error fails assertion (p_args != NULL && args != NULL && p_args != args) is false\n");
253326 : ROSE_ASSERT(false);
253327 : #endif
253328 : }
253329 : #endif
253330 0 : p_args = args;
253331 0 : }
253332 :
253333 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
253334 :
253335 :
253336 : // End of memberFunctionString
253337 : // Start of memberFunctionString
253338 :
253339 :
253340 : // End of memberFunctionString
253341 : // Start of memberFunctionString
253342 : /* #line 4493 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
253343 :
253344 :
253345 : void
253346 65852 : SgCallExpression::post_construction_initialization()
253347 : {
253348 65852 : if (p_function != NULL)
253349 65852 : p_function->set_parent(this);
253350 65852 : }
253351 :
253352 :
253353 : SgExpression*
253354 0 : SgCallExpression::get_next(int& n) const
253355 : {
253356 0 : if(n==0)
253357 : {
253358 0 : n++;
253359 0 : return get_function();
253360 : }
253361 : else
253362 0 : if(p_args && n==1)
253363 : {
253364 0 : n++;
253365 0 : return get_args();
253366 : }
253367 :
253368 : return 0;
253369 : }
253370 :
253371 : #if 1
253372 : // DQ: trying to remove the nested iterator class
253373 : void
253374 0 : SgCallExpression::append_arg(SgExpression* what)
253375 : {
253376 0 : assert(this != NULL);
253377 :
253378 : // DQ (11/15/2006): avoid setting newArgs this late in the process.
253379 0 : ROSE_ASSERT(p_args != NULL);
253380 0 : if (p_args == NULL)
253381 : {
253382 : // set_args(new SgExprListExp(this->get_file_info()));
253383 : SgExprListExp* newArgs = new SgExprListExp ( this->get_file_info() );
253384 : assert(newArgs != NULL);
253385 : newArgs->set_endOfConstruct( this->get_file_info() );
253386 : set_args(newArgs);
253387 : }
253388 :
253389 : // insert_arg(p_args->end(),what);
253390 0 : p_args->append_expression(what);
253391 0 : }
253392 : #endif
253393 :
253394 : #if 0
253395 : // DQ: trying to remove the nested iterator class
253396 : // SgCallExpression::insert_arg(const SgExpression::iterator& where, SgExpression* what)
253397 : void
253398 : SgCallExpression::insert_arg(const SgExpressionPtrList::iterator& where, SgExpression* what)
253399 : {
253400 : p_args->insert_expression(where,what);
253401 : }
253402 : #endif
253403 :
253404 :
253405 : int
253406 0 : SgCallExpression::replace_expression(SgExpression *o, SgExpression *n)
253407 : {
253408 : // DQ (12/17/2006): This function should have the semantics that it will represent a
253409 : // structural change to the AST, thus it is free to set the parent of the new expression.
253410 :
253411 0 : ROSE_ASSERT(o != NULL);
253412 0 : ROSE_ASSERT(n != NULL);
253413 :
253414 0 : if (get_function() == o)
253415 : {
253416 0 : set_function(n);
253417 0 : n->set_parent(this);
253418 :
253419 0 : return 1;
253420 : }
253421 : else
253422 : {
253423 0 : if (p_args == o)
253424 : {
253425 : // DQ (12/17/2006): Make this code safer (avoid passing NULL pointers to functions that we call!
253426 : // set_args(isSgExprListExp(n));
253427 0 : SgExprListExp* expressionList = isSgExprListExp(n);
253428 0 : ROSE_ASSERT(expressionList != NULL);
253429 0 : set_args(expressionList);
253430 0 : n->set_parent(this);
253431 0 : return 1;
253432 : }
253433 : }
253434 :
253435 : return 0;
253436 : }
253437 :
253438 : SgType*
253439 0 : SgCallExpression::get_type() const
253440 : {
253441 : #if 0
253442 : printf ("In SgCallExpression::get_type() \n");
253443 : #endif
253444 :
253445 0 : return SageBuilder::buildVoidType(); //TODO this is wrong
253446 : }
253447 :
253448 :
253449 :
253450 : // End of memberFunctionString
253451 : // Start of memberFunctionString
253452 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
253453 :
253454 : // *** COMMON CODE SECTION BEGINS HERE ***
253455 :
253456 : #if 0
253457 : int
253458 : SgCallExpression::getVariant() const
253459 : {
253460 : // This function is used in ROSE while "variant()" is used in SAGE
253461 : assert(this != NULL);
253462 : return variant();
253463 : }
253464 : #endif
253465 :
253466 : // This function is used in ROSE in treeTraversal code
253467 : // eventually replaces getVariant() and variant()
253468 : // though after variant() has been removed for a while we will
253469 : // want to change the name of variantT() back to variant()
253470 : // (since the "T" was ment to stand for temporary).
253471 : // When this happens the variantT() will be depricated.
253472 : VariantT
253473 98778 : SgCallExpression::variantT() const
253474 : {
253475 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
253476 98778 : ROSE_ASSERT(this != NULL);
253477 98778 : return V_SgCallExpression;
253478 : }
253479 :
253480 : #if 0
253481 : int
253482 : SgCallExpression::variant() const
253483 : {
253484 : // This function is used in SAGE
253485 : ROSE_ASSERT(this != NULL);
253486 : return CALL_EXPRESSION;
253487 : }
253488 : #endif
253489 :
253490 : ROSE_DLL_API const char*
253491 0 : SgCallExpression::sage_class_name() const
253492 : {
253493 0 : ROSE_ASSERT(this != NULL);
253494 0 : return "SgCallExpression";
253495 : }
253496 :
253497 : std::string
253498 0 : SgCallExpression::class_name() const
253499 : {
253500 0 : ROSE_ASSERT(this != NULL);
253501 0 : return "SgCallExpression";
253502 : }
253503 :
253504 : // DQ (11/26/2005): Support for visitor pattern mechanims
253505 : // (inferior to ROSE traversal mechanism, experimental).
253506 : void
253507 0 : SgCallExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
253508 : {
253509 0 : ROSE_ASSERT(this != NULL);
253510 0 : visitor.visit(this);
253511 0 : }
253512 :
253513 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
253514 0 : void SgCallExpression::accept (ROSE_VisitorPattern & visitor) {
253515 0 : ROSE_ASSERT(this != NULL);
253516 0 : visitor.visit(this);
253517 0 : }
253518 :
253519 : SgCallExpression*
253520 0 : SgCallExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
253521 : {
253522 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
253523 : // This function is currently only supported for the AST used the represent Binary executables.
253524 : if (0 /* isSgAsmNode(this) != NULL */)
253525 : {
253526 : // Support for regex specification.
253527 : std::string prefixCode = "REGEX:";
253528 : addNewAttribute(prefixCode + s,a);
253529 : }
253530 : #endif
253531 :
253532 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
253533 0 : return this;
253534 : }
253535 :
253536 : // *** COMMON CODE SECTION ENDS HERE ***
253537 :
253538 :
253539 : // End of memberFunctionString
253540 : // Start of memberFunctionString
253541 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
253542 :
253543 :
253544 : #if 0
253545 : //! Error checking support
253546 : /*! Verifies the following:
253547 : - working getVariant() member function
253548 : - calls base class's error() member function
253549 : Every class has one of these functions.
253550 : */
253551 : bool
253552 : SgCallExpression::error()
253553 : {
253554 : // Put error checking here
253555 :
253556 : ROSE_ASSERT (this != NULL);
253557 : if (getVariant() != CALL_EXPRESSION)
253558 : {
253559 : printf ("Error in SgCallExpression::error(): SgCallExpression object has a %s variant \n",
253560 : Cxx_GrammarTerminalNames[getVariant()].name);
253561 : // printf ("Error in SgCallExpression::error() \n");
253562 : ROSE_ABORT();
253563 : }
253564 :
253565 : ROSE_ASSERT (getVariant() == CALL_EXPRESSION);
253566 : return SgExpression::error();
253567 : }
253568 : #endif
253569 :
253570 :
253571 :
253572 : // End of memberFunctionString
253573 :
253574 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
253575 :
253576 32926 : SgCallExpression* isSgCallExpression ( SgNode* inputDerivedClassPointer )
253577 : {
253578 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
253579 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
253580 : // So to fix this we return NULL directly when the input is NULL and avoid the
253581 : // dynamic_cast in this case. This is likely a performance improvement as well.
253582 : // return dynamic_cast<SgCallExpression*>(inputDerivedClassPointer);
253583 : // Milind Chabbi (8/28/2013): isSgCallExpression uses table-driven castability instead of c++ default dynamic_cast
253584 : // this improves the running time performance by 10-20%.
253585 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCallExpression*>(inputDerivedClassPointer);
253586 32926 : return IS_SgCallExpression_FAST_MACRO(inputDerivedClassPointer);
253587 : }
253588 :
253589 : // DQ (11/8/2003): Added version of functions taking const pointer
253590 0 : const SgCallExpression* isSgCallExpression ( const SgNode* inputDerivedClassPointer )
253591 : {
253592 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
253593 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
253594 : // So to fix this we return NULL directly when the input is NULL and avoid the
253595 : // dynamic_cast in this case. This is likely a performance improvement as well.
253596 : // return dynamic_cast<const SgCallExpression*>(inputDerivedClassPointer);
253597 : // Milind Chabbi (8/28/2013): isSgCallExpression uses table-driven castability instead of c++ default dynamic_cast
253598 : // this improves the running time performance by 10-20%.
253599 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCallExpression*>(inputDerivedClassPointer);
253600 0 : return IS_SgCallExpression_FAST_MACRO(inputDerivedClassPointer);
253601 : }
253602 :
253603 :
253604 :
253605 : /* #line 253606 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253606 :
253607 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
253608 :
253609 : /**
253610 : \brief Generated destructor
253611 :
253612 : This destructor is automatically generated (by ROSETTA). This destructor
253613 : only frees memory of data members associated with the parts of the current IR node which
253614 : are NOT traversed. Those data members that are part of a traversal can be freed using
253615 : a traversal (calling this destructor on all children in a post-order traversal). Such
253616 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
253617 :
253618 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
253619 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
253620 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
253621 :
253622 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
253623 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
253624 : pointers are not yet implemented to call delete on eash pointer in the container.
253625 : (This could be done by derivation from the STL containers to define containers that
253626 : automatically deleted their members.)
253627 :
253628 : */
253629 6889 : SgCallExpression::~SgCallExpression () {
253630 6889 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
253631 :
253632 :
253633 : // case: not a listType for function
253634 6889 : p_function = NULL; // non list case
253635 : // case: not a listType for args
253636 6889 : p_args = NULL; // non list case
253637 : // case: not a listType for expression_type
253638 6889 : p_expression_type = NULL; // non list case
253639 :
253640 : }
253641 :
253642 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
253643 6889 : }
253644 :
253645 :
253646 : /* #line 253647 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253647 :
253648 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
253649 :
253650 : // Generated constructor
253651 783 : SgCallExpression::SgCallExpression ( Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type )
253652 783 : : SgExpression(startOfConstruct)
253653 : {
253654 : #ifdef DEBUG
253655 : // printf ("In SgCallExpression::SgCallExpression (Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
253656 : #endif
253657 : #if 0
253658 : // debugging information!
253659 : printf ("In SgCallExpression::SgCallExpression (Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
253660 : #endif
253661 :
253662 783 : p_function = function;
253663 783 : p_args = args;
253664 783 : p_expression_type = expression_type;
253665 :
253666 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
253667 :
253668 : #if 0
253669 : // DQ (7/30/2014): Call a virtual function.
253670 : std::string s = this->class_name();
253671 : #endif
253672 :
253673 : // Test the variant virtual function
253674 : // assert(CALL_EXPRESSION == variant());
253675 783 : assert(CALL_EXPRESSION == this->variant());
253676 783 : ROSE_ASSERT(CALL_EXPRESSION == (int)(this->variantT()));
253677 783 : post_construction_initialization();
253678 :
253679 : // Test the isSgCallExpression() function since it has been problematic
253680 783 : assert(isSgCallExpression(this) != NULL);
253681 783 : }
253682 :
253683 : // Generated constructor (all data members)
253684 :
253685 : /* #line 253686 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253686 :
253687 :
253688 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
253689 :
253690 :
253691 : // ********************************************************
253692 : // member functions common across all array grammar objects
253693 : // ********************************************************
253694 :
253695 :
253696 :
253697 : /* #line 253698 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253698 :
253699 :
253700 :
253701 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
253702 :
253703 : // ********************************************************
253704 : // member functions specific to each node in the grammar
253705 : // ********************************************************
253706 :
253707 :
253708 : /* #line 253709 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253709 :
253710 : // Start of memberFunctionString
253711 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
253712 :
253713 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
253714 :
253715 : bool
253716 7634 : SgFunctionCallExp::get_uses_operator_syntax () const
253717 : {
253718 7634 : ROSE_ASSERT (this != NULL);
253719 :
253720 : #if 0
253721 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
253722 : // used to trigger marking transformations for the token-based unparsing.
253723 : printf ("SgFunctionCallExp::get_uses_operator_syntax = %p = %s \n",this,this->class_name().c_str());
253724 : #endif
253725 :
253726 7634 : return p_uses_operator_syntax;
253727 : }
253728 :
253729 : void
253730 32107 : SgFunctionCallExp::set_uses_operator_syntax ( bool uses_operator_syntax )
253731 : {
253732 32107 : ROSE_ASSERT (this != NULL);
253733 :
253734 : #if 0
253735 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
253736 : // used to trigger marking transformations for the token-based unparsing.
253737 : printf ("SgFunctionCallExp::set_uses_operator_syntax = %p = %s \n",this,this->class_name().c_str());
253738 : #endif
253739 :
253740 32107 : set_isModified(true);
253741 :
253742 32107 : p_uses_operator_syntax = uses_operator_syntax;
253743 32107 : }
253744 :
253745 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
253746 :
253747 :
253748 : // End of memberFunctionString
253749 : // Start of memberFunctionString
253750 : /* #line 4600 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
253751 :
253752 :
253753 : void
253754 32926 : SgFunctionCallExp::post_construction_initialization()
253755 : {
253756 32926 : SgCallExpression::post_construction_initialization();
253757 32926 : }
253758 :
253759 :
253760 : SgType*
253761 57794 : SgFunctionCallExp::get_type() const
253762 : {
253763 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
253764 :
253765 : // printf ("SgFunctionCallExp::get_type(): p_expression_type has been removed, we have to compute the appropriate type \n");
253766 :
253767 : #if 0
253768 : printf ("In SgFunctionCallExp::get_type() \n");
253769 : #endif
253770 :
253771 : // DQ (7/20/2006): Peter's patch now allows this function to be simplified to the following (suggested by Jeremiah).
253772 57794 : SgType* returnType = NULL;
253773 :
253774 57794 : ROSE_ASSERT(p_function != NULL);
253775 : // printf ("In SgFunctionCallExp::get_type(): calling get_type() on p_function = %p = %s \n",p_function,p_function->class_name().c_str());
253776 57794 : SgType* likelyFunctionType = p_function->get_type();
253777 57794 : ROSE_ASSERT(likelyFunctionType != NULL);
253778 57798 : while (likelyFunctionType && isSgTypedefType(likelyFunctionType))
253779 : {
253780 4 : likelyFunctionType = isSgTypedefType(likelyFunctionType)->get_base_type();
253781 4 : ROSE_ASSERT(likelyFunctionType != NULL);
253782 : }
253783 :
253784 57794 : SgFunctionType* functionType = isSgFunctionType(likelyFunctionType);
253785 57794 : if (functionType == NULL)
253786 : {
253787 : #if 1
253788 : // DQ (8/26/2012): Decrease the volume of warnings from this part of the code.
253789 : #ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
253790 : static int count = 0;
253791 : if (count++ % 100 == 0)
253792 : {
253793 : printf ("Warning: unexpected type found for likelyFunctionType = %p = %s \n",likelyFunctionType,likelyFunctionType->class_name().c_str());
253794 : }
253795 : #endif
253796 : #else
253797 : printf ("Warning: unexpected type found for likelyFunctionType = %p = %s \n",likelyFunctionType,likelyFunctionType->class_name().c_str());
253798 : #endif
253799 : // get_file_info()->display("Location of call to SgFunctionCallExp::get_type(): debug");
253800 :
253801 : // DQ (7/15/2007): Handle case of typedef of function type
253802 : // Milind Chabbi, after discussing with DQ (7/29/2013), we need to strip all. See test: CompileTests/Cxx_tests/test2013_milind_01.C
253803 20546 : likelyFunctionType = likelyFunctionType->stripType(SgType::STRIP_MODIFIER_TYPE |
253804 : SgType::STRIP_REFERENCE_TYPE |
253805 : SgType::STRIP_RVALUE_REFERENCE_TYPE |
253806 : SgType::STRIP_POINTER_TYPE |
253807 : SgType::STRIP_ARRAY_TYPE |
253808 : SgType::STRIP_TYPEDEF_TYPE);
253809 :
253810 : // printf ("After calling stripType(SgType::STRIP_TYPEDEF_TYPE): likelyFunctionType = %p = %s \n",likelyFunctionType,likelyFunctionType->class_name().c_str());
253811 20546 : functionType = isSgFunctionType(likelyFunctionType);
253812 :
253813 : // if functionType is NULL (e.g SgTemplateType or SgClassType) we have no idea what the return type is, so we will return SgTypeUnknown
253814 20546 : if (functionType == NULL) {
253815 : //printf ("Warning: Unable to infer the return type of %s in SgFunctionCallExp\n", likelyFunctionType->class_name().c_str());
253816 19568 : return SgTypeUnknown::createType();
253817 : }
253818 : }
253819 38226 : ROSE_ASSERT(functionType);
253820 38226 : returnType = functionType->get_return_type();
253821 38226 : ROSE_ASSERT(returnType != NULL);
253822 38226 : return returnType;
253823 : }
253824 :
253825 :
253826 :
253827 : // End of memberFunctionString
253828 : // Start of memberFunctionString
253829 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
253830 :
253831 : // *** COMMON CODE SECTION BEGINS HERE ***
253832 :
253833 : #if 0
253834 : int
253835 : SgFunctionCallExp::getVariant() const
253836 : {
253837 : // This function is used in ROSE while "variant()" is used in SAGE
253838 : assert(this != NULL);
253839 : return variant();
253840 : }
253841 : #endif
253842 :
253843 : // This function is used in ROSE in treeTraversal code
253844 : // eventually replaces getVariant() and variant()
253845 : // though after variant() has been removed for a while we will
253846 : // want to change the name of variantT() back to variant()
253847 : // (since the "T" was ment to stand for temporary).
253848 : // When this happens the variantT() will be depricated.
253849 : VariantT
253850 11369900 : SgFunctionCallExp::variantT() const
253851 : {
253852 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
253853 11369900 : ROSE_ASSERT(this != NULL);
253854 11369900 : return V_SgFunctionCallExp;
253855 : }
253856 :
253857 : #if 0
253858 : int
253859 : SgFunctionCallExp::variant() const
253860 : {
253861 : // This function is used in SAGE
253862 : ROSE_ASSERT(this != NULL);
253863 : return FUNC_CALL;
253864 : }
253865 : #endif
253866 :
253867 : ROSE_DLL_API const char*
253868 1139 : SgFunctionCallExp::sage_class_name() const
253869 : {
253870 1139 : ROSE_ASSERT(this != NULL);
253871 1139 : return "SgFunctionCallExp";
253872 : }
253873 :
253874 : std::string
253875 27536 : SgFunctionCallExp::class_name() const
253876 : {
253877 27536 : ROSE_ASSERT(this != NULL);
253878 27536 : return "SgFunctionCallExp";
253879 : }
253880 :
253881 : // DQ (11/26/2005): Support for visitor pattern mechanims
253882 : // (inferior to ROSE traversal mechanism, experimental).
253883 : void
253884 460372 : SgFunctionCallExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
253885 : {
253886 460372 : ROSE_ASSERT(this != NULL);
253887 460372 : visitor.visit(this);
253888 460372 : }
253889 :
253890 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
253891 0 : void SgFunctionCallExp::accept (ROSE_VisitorPattern & visitor) {
253892 0 : ROSE_ASSERT(this != NULL);
253893 0 : visitor.visit(this);
253894 0 : }
253895 :
253896 : SgFunctionCallExp*
253897 0 : SgFunctionCallExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
253898 : {
253899 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
253900 : // This function is currently only supported for the AST used the represent Binary executables.
253901 : if (0 /* isSgAsmNode(this) != NULL */)
253902 : {
253903 : // Support for regex specification.
253904 : std::string prefixCode = "REGEX:";
253905 : addNewAttribute(prefixCode + s,a);
253906 : }
253907 : #endif
253908 :
253909 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
253910 0 : return this;
253911 : }
253912 :
253913 : // *** COMMON CODE SECTION ENDS HERE ***
253914 :
253915 :
253916 : // End of memberFunctionString
253917 : // Start of memberFunctionString
253918 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
253919 :
253920 :
253921 : #if 0
253922 : //! Error checking support
253923 : /*! Verifies the following:
253924 : - working getVariant() member function
253925 : - calls base class's error() member function
253926 : Every class has one of these functions.
253927 : */
253928 : bool
253929 : SgFunctionCallExp::error()
253930 : {
253931 : // Put error checking here
253932 :
253933 : ROSE_ASSERT (this != NULL);
253934 : if (getVariant() != FUNC_CALL)
253935 : {
253936 : printf ("Error in SgFunctionCallExp::error(): SgFunctionCallExp object has a %s variant \n",
253937 : Cxx_GrammarTerminalNames[getVariant()].name);
253938 : // printf ("Error in SgFunctionCallExp::error() \n");
253939 : ROSE_ABORT();
253940 : }
253941 :
253942 : ROSE_ASSERT (getVariant() == FUNC_CALL);
253943 : return SgCallExpression::error();
253944 : }
253945 : #endif
253946 :
253947 :
253948 :
253949 : // End of memberFunctionString
253950 :
253951 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
253952 :
253953 1125930 : SgFunctionCallExp* isSgFunctionCallExp ( SgNode* inputDerivedClassPointer )
253954 : {
253955 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
253956 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
253957 : // So to fix this we return NULL directly when the input is NULL and avoid the
253958 : // dynamic_cast in this case. This is likely a performance improvement as well.
253959 : // return dynamic_cast<SgFunctionCallExp*>(inputDerivedClassPointer);
253960 : // Milind Chabbi (8/28/2013): isSgFunctionCallExp uses table-driven castability instead of c++ default dynamic_cast
253961 : // this improves the running time performance by 10-20%.
253962 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionCallExp*>(inputDerivedClassPointer);
253963 1125930 : return IS_SgFunctionCallExp_FAST_MACRO(inputDerivedClassPointer);
253964 : }
253965 :
253966 : // DQ (11/8/2003): Added version of functions taking const pointer
253967 9166 : const SgFunctionCallExp* isSgFunctionCallExp ( const SgNode* inputDerivedClassPointer )
253968 : {
253969 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
253970 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
253971 : // So to fix this we return NULL directly when the input is NULL and avoid the
253972 : // dynamic_cast in this case. This is likely a performance improvement as well.
253973 : // return dynamic_cast<const SgFunctionCallExp*>(inputDerivedClassPointer);
253974 : // Milind Chabbi (8/28/2013): isSgFunctionCallExp uses table-driven castability instead of c++ default dynamic_cast
253975 : // this improves the running time performance by 10-20%.
253976 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionCallExp*>(inputDerivedClassPointer);
253977 9166 : return IS_SgFunctionCallExp_FAST_MACRO(inputDerivedClassPointer);
253978 : }
253979 :
253980 :
253981 :
253982 : /* #line 253983 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
253983 :
253984 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
253985 :
253986 : /**
253987 : \brief Generated destructor
253988 :
253989 : This destructor is automatically generated (by ROSETTA). This destructor
253990 : only frees memory of data members associated with the parts of the current IR node which
253991 : are NOT traversed. Those data members that are part of a traversal can be freed using
253992 : a traversal (calling this destructor on all children in a post-order traversal). Such
253993 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
253994 :
253995 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
253996 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
253997 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
253998 :
253999 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
254000 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
254001 : pointers are not yet implemented to call delete on eash pointer in the container.
254002 : (This could be done by derivation from the STL containers to define containers that
254003 : automatically deleted their members.)
254004 :
254005 : */
254006 13778 : SgFunctionCallExp::~SgFunctionCallExp () {
254007 6889 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
254008 :
254009 :
254010 : // case: not a listType for uses_operator_syntax
254011 6889 : p_uses_operator_syntax = false; // non list case
254012 :
254013 : }
254014 :
254015 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
254016 13778 : }
254017 :
254018 :
254019 : /* #line 254020 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254020 :
254021 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
254022 :
254023 : // Generated constructor
254024 783 : SgFunctionCallExp::SgFunctionCallExp ( Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type )
254025 783 : : SgCallExpression(startOfConstruct, function, args, expression_type)
254026 : {
254027 : #ifdef DEBUG
254028 : // printf ("In SgFunctionCallExp::SgFunctionCallExp (Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
254029 : #endif
254030 : #if 0
254031 : // debugging information!
254032 : printf ("In SgFunctionCallExp::SgFunctionCallExp (Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
254033 : #endif
254034 :
254035 783 : p_uses_operator_syntax = false;
254036 :
254037 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
254038 :
254039 : #if 0
254040 : // DQ (7/30/2014): Call a virtual function.
254041 : std::string s = this->class_name();
254042 : #endif
254043 :
254044 : // Test the variant virtual function
254045 : // assert(FUNC_CALL == variant());
254046 783 : assert(FUNC_CALL == this->variant());
254047 783 : ROSE_ASSERT(FUNC_CALL == (int)(this->variantT()));
254048 783 : post_construction_initialization();
254049 :
254050 : // Test the isSgFunctionCallExp() function since it has been problematic
254051 783 : assert(isSgFunctionCallExp(this) != NULL);
254052 783 : }
254053 :
254054 : // Generated constructor (all data members)
254055 :
254056 : /* #line 254057 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254057 :
254058 :
254059 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
254060 :
254061 :
254062 : // ********************************************************
254063 : // member functions common across all array grammar objects
254064 : // ********************************************************
254065 :
254066 :
254067 :
254068 : /* #line 254069 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254069 :
254070 :
254071 :
254072 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
254073 :
254074 : // ********************************************************
254075 : // member functions specific to each node in the grammar
254076 : // ********************************************************
254077 :
254078 :
254079 : /* #line 254080 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254080 :
254081 : // Start of memberFunctionString
254082 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
254083 :
254084 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
254085 :
254086 : SgCudaKernelExecConfig*
254087 0 : SgCudaKernelCallExp::get_exec_config () const
254088 : {
254089 0 : ROSE_ASSERT (this != NULL);
254090 :
254091 : #if 0
254092 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254093 : // used to trigger marking transformations for the token-based unparsing.
254094 : printf ("SgCudaKernelCallExp::get_exec_config = %p = %s \n",this,this->class_name().c_str());
254095 : #endif
254096 :
254097 0 : return p_exec_config;
254098 : }
254099 :
254100 : void
254101 0 : SgCudaKernelCallExp::set_exec_config ( SgCudaKernelExecConfig* exec_config )
254102 : {
254103 0 : ROSE_ASSERT (this != NULL);
254104 :
254105 : #if 0
254106 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254107 : // used to trigger marking transformations for the token-based unparsing.
254108 : printf ("SgCudaKernelCallExp::set_exec_config = %p = %s \n",this,this->class_name().c_str());
254109 : #endif
254110 :
254111 0 : set_isModified(true);
254112 :
254113 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
254114 : if (p_exec_config != NULL && exec_config != NULL && p_exec_config != exec_config)
254115 : {
254116 : printf ("Warning: exec_config = %p overwriting valid pointer p_exec_config = %p \n",exec_config,p_exec_config);
254117 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
254118 : printf ("Error fails assertion (p_exec_config != NULL && exec_config != NULL && p_exec_config != exec_config) is false\n");
254119 : ROSE_ASSERT(false);
254120 : #endif
254121 : }
254122 : #endif
254123 0 : p_exec_config = exec_config;
254124 0 : }
254125 :
254126 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
254127 :
254128 :
254129 : // End of memberFunctionString
254130 : // Start of memberFunctionString
254131 : /* #line 9474 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
254132 :
254133 :
254134 : void
254135 0 : SgCudaKernelCallExp::post_construction_initialization()
254136 : {
254137 0 : if (p_function != NULL)
254138 0 : p_function->set_parent(this);
254139 :
254140 : // TODO : exec_config
254141 0 : }
254142 :
254143 : SgType*
254144 0 : SgCudaKernelCallExp::get_type() const
254145 : {
254146 : #if 0
254147 : printf ("In SgCudaKernelCallExp::get_type() \n");
254148 : #endif
254149 :
254150 0 : return SgFunctionCallExp::get_type();
254151 : }
254152 :
254153 :
254154 :
254155 : // End of memberFunctionString
254156 : // Start of memberFunctionString
254157 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
254158 :
254159 : // *** COMMON CODE SECTION BEGINS HERE ***
254160 :
254161 : #if 0
254162 : int
254163 : SgCudaKernelCallExp::getVariant() const
254164 : {
254165 : // This function is used in ROSE while "variant()" is used in SAGE
254166 : assert(this != NULL);
254167 : return variant();
254168 : }
254169 : #endif
254170 :
254171 : // This function is used in ROSE in treeTraversal code
254172 : // eventually replaces getVariant() and variant()
254173 : // though after variant() has been removed for a while we will
254174 : // want to change the name of variantT() back to variant()
254175 : // (since the "T" was ment to stand for temporary).
254176 : // When this happens the variantT() will be depricated.
254177 : VariantT
254178 0 : SgCudaKernelCallExp::variantT() const
254179 : {
254180 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
254181 0 : ROSE_ASSERT(this != NULL);
254182 0 : return V_SgCudaKernelCallExp;
254183 : }
254184 :
254185 : #if 0
254186 : int
254187 : SgCudaKernelCallExp::variant() const
254188 : {
254189 : // This function is used in SAGE
254190 : ROSE_ASSERT(this != NULL);
254191 : return KERN_CALL;
254192 : }
254193 : #endif
254194 :
254195 : ROSE_DLL_API const char*
254196 0 : SgCudaKernelCallExp::sage_class_name() const
254197 : {
254198 0 : ROSE_ASSERT(this != NULL);
254199 0 : return "SgCudaKernelCallExp";
254200 : }
254201 :
254202 : std::string
254203 0 : SgCudaKernelCallExp::class_name() const
254204 : {
254205 0 : ROSE_ASSERT(this != NULL);
254206 0 : return "SgCudaKernelCallExp";
254207 : }
254208 :
254209 : // DQ (11/26/2005): Support for visitor pattern mechanims
254210 : // (inferior to ROSE traversal mechanism, experimental).
254211 : void
254212 0 : SgCudaKernelCallExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
254213 : {
254214 0 : ROSE_ASSERT(this != NULL);
254215 0 : visitor.visit(this);
254216 0 : }
254217 :
254218 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
254219 0 : void SgCudaKernelCallExp::accept (ROSE_VisitorPattern & visitor) {
254220 0 : ROSE_ASSERT(this != NULL);
254221 0 : visitor.visit(this);
254222 0 : }
254223 :
254224 : SgCudaKernelCallExp*
254225 0 : SgCudaKernelCallExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
254226 : {
254227 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
254228 : // This function is currently only supported for the AST used the represent Binary executables.
254229 : if (0 /* isSgAsmNode(this) != NULL */)
254230 : {
254231 : // Support for regex specification.
254232 : std::string prefixCode = "REGEX:";
254233 : addNewAttribute(prefixCode + s,a);
254234 : }
254235 : #endif
254236 :
254237 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
254238 0 : return this;
254239 : }
254240 :
254241 : // *** COMMON CODE SECTION ENDS HERE ***
254242 :
254243 :
254244 : // End of memberFunctionString
254245 : // Start of memberFunctionString
254246 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
254247 :
254248 :
254249 : #if 0
254250 : //! Error checking support
254251 : /*! Verifies the following:
254252 : - working getVariant() member function
254253 : - calls base class's error() member function
254254 : Every class has one of these functions.
254255 : */
254256 : bool
254257 : SgCudaKernelCallExp::error()
254258 : {
254259 : // Put error checking here
254260 :
254261 : ROSE_ASSERT (this != NULL);
254262 : if (getVariant() != KERN_CALL)
254263 : {
254264 : printf ("Error in SgCudaKernelCallExp::error(): SgCudaKernelCallExp object has a %s variant \n",
254265 : Cxx_GrammarTerminalNames[getVariant()].name);
254266 : // printf ("Error in SgCudaKernelCallExp::error() \n");
254267 : ROSE_ABORT();
254268 : }
254269 :
254270 : ROSE_ASSERT (getVariant() == KERN_CALL);
254271 : return SgFunctionCallExp::error();
254272 : }
254273 : #endif
254274 :
254275 :
254276 :
254277 : // End of memberFunctionString
254278 :
254279 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
254280 :
254281 0 : SgCudaKernelCallExp* isSgCudaKernelCallExp ( SgNode* inputDerivedClassPointer )
254282 : {
254283 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
254284 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
254285 : // So to fix this we return NULL directly when the input is NULL and avoid the
254286 : // dynamic_cast in this case. This is likely a performance improvement as well.
254287 : // return dynamic_cast<SgCudaKernelCallExp*>(inputDerivedClassPointer);
254288 : // Milind Chabbi (8/28/2013): isSgCudaKernelCallExp uses table-driven castability instead of c++ default dynamic_cast
254289 : // this improves the running time performance by 10-20%.
254290 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCudaKernelCallExp*>(inputDerivedClassPointer);
254291 0 : return IS_SgCudaKernelCallExp_FAST_MACRO(inputDerivedClassPointer);
254292 : }
254293 :
254294 : // DQ (11/8/2003): Added version of functions taking const pointer
254295 0 : const SgCudaKernelCallExp* isSgCudaKernelCallExp ( const SgNode* inputDerivedClassPointer )
254296 : {
254297 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
254298 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
254299 : // So to fix this we return NULL directly when the input is NULL and avoid the
254300 : // dynamic_cast in this case. This is likely a performance improvement as well.
254301 : // return dynamic_cast<const SgCudaKernelCallExp*>(inputDerivedClassPointer);
254302 : // Milind Chabbi (8/28/2013): isSgCudaKernelCallExp uses table-driven castability instead of c++ default dynamic_cast
254303 : // this improves the running time performance by 10-20%.
254304 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCudaKernelCallExp*>(inputDerivedClassPointer);
254305 0 : return IS_SgCudaKernelCallExp_FAST_MACRO(inputDerivedClassPointer);
254306 : }
254307 :
254308 :
254309 :
254310 : /* #line 254311 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254311 :
254312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
254313 :
254314 : /**
254315 : \brief Generated destructor
254316 :
254317 : This destructor is automatically generated (by ROSETTA). This destructor
254318 : only frees memory of data members associated with the parts of the current IR node which
254319 : are NOT traversed. Those data members that are part of a traversal can be freed using
254320 : a traversal (calling this destructor on all children in a post-order traversal). Such
254321 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
254322 :
254323 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
254324 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
254325 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
254326 :
254327 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
254328 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
254329 : pointers are not yet implemented to call delete on eash pointer in the container.
254330 : (This could be done by derivation from the STL containers to define containers that
254331 : automatically deleted their members.)
254332 :
254333 : */
254334 0 : SgCudaKernelCallExp::~SgCudaKernelCallExp () {
254335 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
254336 :
254337 :
254338 : // case: not a listType for exec_config
254339 0 : p_exec_config = NULL; // non list case
254340 :
254341 : }
254342 :
254343 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
254344 0 : }
254345 :
254346 :
254347 : /* #line 254348 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254348 :
254349 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
254350 :
254351 : // Generated constructor
254352 0 : SgCudaKernelCallExp::SgCudaKernelCallExp ( Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type, SgCudaKernelExecConfig* exec_config )
254353 0 : : SgFunctionCallExp(startOfConstruct, function, args, expression_type)
254354 : {
254355 : #ifdef DEBUG
254356 : // printf ("In SgCudaKernelCallExp::SgCudaKernelCallExp (Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type, SgCudaKernelExecConfig* exec_config) sage_class_name() = %s \n",sage_class_name());
254357 : #endif
254358 : #if 0
254359 : // debugging information!
254360 : printf ("In SgCudaKernelCallExp::SgCudaKernelCallExp (Sg_File_Info* startOfConstruct, SgExpression* function, SgExprListExp* args, SgType* expression_type, SgCudaKernelExecConfig* exec_config): this = %p = %s \n",this,this->class_name().c_str());
254361 : #endif
254362 :
254363 0 : p_exec_config = exec_config;
254364 :
254365 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
254366 :
254367 : #if 0
254368 : // DQ (7/30/2014): Call a virtual function.
254369 : std::string s = this->class_name();
254370 : #endif
254371 :
254372 : // Test the variant virtual function
254373 : // assert(KERN_CALL == variant());
254374 0 : assert(KERN_CALL == this->variant());
254375 0 : ROSE_ASSERT(KERN_CALL == (int)(this->variantT()));
254376 0 : post_construction_initialization();
254377 :
254378 : // Test the isSgCudaKernelCallExp() function since it has been problematic
254379 0 : assert(isSgCudaKernelCallExp(this) != NULL);
254380 0 : }
254381 :
254382 : // Generated constructor (all data members)
254383 :
254384 : /* #line 254385 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254385 :
254386 :
254387 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
254388 :
254389 :
254390 : // ********************************************************
254391 : // member functions common across all array grammar objects
254392 : // ********************************************************
254393 :
254394 :
254395 :
254396 : /* #line 254397 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254397 :
254398 :
254399 :
254400 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
254401 :
254402 : // ********************************************************
254403 : // member functions specific to each node in the grammar
254404 : // ********************************************************
254405 :
254406 :
254407 : /* #line 254408 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254408 :
254409 : // Start of memberFunctionString
254410 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
254411 :
254412 : void
254413 2182 : SgSizeOfOp::post_construction_initialization()
254414 : {
254415 2182 : }
254416 :
254417 :
254418 :
254419 : // End of memberFunctionString
254420 : // Start of memberFunctionString
254421 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
254422 :
254423 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
254424 :
254425 : SgExpression*
254426 1298 : SgSizeOfOp::get_operand_expr () const
254427 : {
254428 1298 : ROSE_ASSERT (this != NULL);
254429 :
254430 : #if 0
254431 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254432 : // used to trigger marking transformations for the token-based unparsing.
254433 : printf ("SgSizeOfOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
254434 : #endif
254435 :
254436 1298 : return p_operand_expr;
254437 : }
254438 :
254439 : void
254440 0 : SgSizeOfOp::set_operand_expr ( SgExpression* operand_expr )
254441 : {
254442 0 : ROSE_ASSERT (this != NULL);
254443 :
254444 : #if 0
254445 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254446 : // used to trigger marking transformations for the token-based unparsing.
254447 : printf ("SgSizeOfOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
254448 : #endif
254449 :
254450 0 : set_isModified(true);
254451 :
254452 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
254453 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
254454 : {
254455 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
254456 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
254457 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
254458 : ROSE_ASSERT(false);
254459 : #endif
254460 : }
254461 : #endif
254462 0 : p_operand_expr = operand_expr;
254463 0 : }
254464 :
254465 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
254466 :
254467 :
254468 : // End of memberFunctionString
254469 : // Start of memberFunctionString
254470 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
254471 :
254472 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
254473 :
254474 : SgType*
254475 5794 : SgSizeOfOp::get_operand_type () const
254476 : {
254477 5794 : ROSE_ASSERT (this != NULL);
254478 :
254479 : #if 0
254480 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254481 : // used to trigger marking transformations for the token-based unparsing.
254482 : printf ("SgSizeOfOp::get_operand_type = %p = %s \n",this,this->class_name().c_str());
254483 : #endif
254484 :
254485 5794 : return p_operand_type;
254486 : }
254487 :
254488 : void
254489 0 : SgSizeOfOp::set_operand_type ( SgType* operand_type )
254490 : {
254491 0 : ROSE_ASSERT (this != NULL);
254492 :
254493 : #if 0
254494 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254495 : // used to trigger marking transformations for the token-based unparsing.
254496 : printf ("SgSizeOfOp::set_operand_type = %p = %s \n",this,this->class_name().c_str());
254497 : #endif
254498 :
254499 0 : set_isModified(true);
254500 :
254501 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
254502 : if (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type)
254503 : {
254504 : printf ("Warning: operand_type = %p overwriting valid pointer p_operand_type = %p \n",operand_type,p_operand_type);
254505 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
254506 : printf ("Error fails assertion (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type) is false\n");
254507 : ROSE_ASSERT(false);
254508 : #endif
254509 : }
254510 : #endif
254511 0 : p_operand_type = operand_type;
254512 0 : }
254513 :
254514 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
254515 :
254516 :
254517 : // End of memberFunctionString
254518 : // Start of memberFunctionString
254519 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
254520 :
254521 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
254522 :
254523 : bool
254524 1144 : SgSizeOfOp::get_sizeOfContainsBaseTypeDefiningDeclaration () const
254525 : {
254526 1144 : ROSE_ASSERT (this != NULL);
254527 :
254528 : #if 0
254529 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254530 : // used to trigger marking transformations for the token-based unparsing.
254531 : printf ("SgSizeOfOp::get_sizeOfContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
254532 : #endif
254533 :
254534 1144 : return p_sizeOfContainsBaseTypeDefiningDeclaration;
254535 : }
254536 :
254537 : void
254538 0 : SgSizeOfOp::set_sizeOfContainsBaseTypeDefiningDeclaration ( bool sizeOfContainsBaseTypeDefiningDeclaration )
254539 : {
254540 0 : ROSE_ASSERT (this != NULL);
254541 :
254542 : #if 0
254543 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254544 : // used to trigger marking transformations for the token-based unparsing.
254545 : printf ("SgSizeOfOp::set_sizeOfContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
254546 : #endif
254547 :
254548 0 : set_isModified(true);
254549 :
254550 0 : p_sizeOfContainsBaseTypeDefiningDeclaration = sizeOfContainsBaseTypeDefiningDeclaration;
254551 0 : }
254552 :
254553 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
254554 :
254555 :
254556 : // End of memberFunctionString
254557 : // Start of memberFunctionString
254558 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
254559 :
254560 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
254561 :
254562 : bool
254563 61 : SgSizeOfOp::get_is_objectless_nonstatic_data_member_reference () const
254564 : {
254565 61 : ROSE_ASSERT (this != NULL);
254566 :
254567 : #if 0
254568 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254569 : // used to trigger marking transformations for the token-based unparsing.
254570 : printf ("SgSizeOfOp::get_is_objectless_nonstatic_data_member_reference = %p = %s \n",this,this->class_name().c_str());
254571 : #endif
254572 :
254573 61 : return p_is_objectless_nonstatic_data_member_reference;
254574 : }
254575 :
254576 : void
254577 0 : SgSizeOfOp::set_is_objectless_nonstatic_data_member_reference ( bool is_objectless_nonstatic_data_member_reference )
254578 : {
254579 0 : ROSE_ASSERT (this != NULL);
254580 :
254581 : #if 0
254582 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
254583 : // used to trigger marking transformations for the token-based unparsing.
254584 : printf ("SgSizeOfOp::set_is_objectless_nonstatic_data_member_reference = %p = %s \n",this,this->class_name().c_str());
254585 : #endif
254586 :
254587 0 : set_isModified(true);
254588 :
254589 0 : p_is_objectless_nonstatic_data_member_reference = is_objectless_nonstatic_data_member_reference;
254590 0 : }
254591 :
254592 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
254593 :
254594 :
254595 : // End of memberFunctionString
254596 : // Start of memberFunctionString
254597 :
254598 :
254599 : // End of memberFunctionString
254600 : // Start of memberFunctionString
254601 : /* #line 5297 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
254602 :
254603 :
254604 : SgType*
254605 1401 : SgSizeOfOp::get_type() const
254606 : {
254607 : // This function returns an unsigned integer representing the size of type
254608 : // (the unsigned int should match size_t, which may or may not be defined).
254609 :
254610 1401 : ROSE_ASSERT(p_operand_expr != NULL || p_operand_type != NULL);
254611 :
254612 : #if 0
254613 : printf ("In SgSizeOfOp::get_type() \n");
254614 : #endif
254615 :
254616 1401 : SgType* returnType = SgTypeUnsignedInt::createType();
254617 :
254618 1401 : ROSE_ASSERT(returnType != NULL);
254619 1401 : return returnType;
254620 : }
254621 :
254622 : // Liao, 11/17/2009
254623 : int
254624 0 : SgSizeOfOp::replace_expression (SgExpression *o, SgExpression *n)
254625 : {
254626 : // DQ (12/17/2006): This function should have the semantics that it will represent a
254627 : // structural change to the AST, thus it is free to set the parent of the new expression.
254628 :
254629 0 : ROSE_ASSERT(o != NULL);
254630 0 : ROSE_ASSERT(n != NULL);
254631 :
254632 0 : if (get_operand_expr() == o)
254633 : {
254634 0 : set_operand_expr(n);
254635 0 : return 1;
254636 : }
254637 : else
254638 : {
254639 0 : printf ("Warning: inside of SgSizeOfOp::replace_expression original SgExpression unidentified \n");
254640 0 : return 0;
254641 : }
254642 : }
254643 :
254644 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
254645 : // so that we could avoid them setting the isModified flag which is a problem in the
254646 : // name qualification support for C++ (interfering with the token-based unparsing).
254647 : int
254648 0 : SgSizeOfOp::get_name_qualification_length () const
254649 : {
254650 0 : ROSE_ASSERT (this != NULL);
254651 0 : return p_name_qualification_length;
254652 : }
254653 :
254654 : void
254655 497 : SgSizeOfOp::set_name_qualification_length ( int name_qualification_length )
254656 : {
254657 497 : ROSE_ASSERT (this != NULL);
254658 : // This can't be called by the name qualification API (see test2015_26.C).
254659 : // set_isModified(true);
254660 :
254661 497 : p_name_qualification_length = name_qualification_length;
254662 497 : }
254663 :
254664 : bool
254665 0 : SgSizeOfOp::get_type_elaboration_required () const
254666 : {
254667 0 : ROSE_ASSERT (this != NULL);
254668 0 : return p_type_elaboration_required;
254669 : }
254670 :
254671 : void
254672 497 : SgSizeOfOp::set_type_elaboration_required ( bool type_elaboration_required )
254673 : {
254674 497 : ROSE_ASSERT (this != NULL);
254675 : // This can't be called by the name qualification API (see test2015_26.C).
254676 : // set_isModified(true);
254677 :
254678 497 : p_type_elaboration_required = type_elaboration_required;
254679 497 : }
254680 :
254681 : bool
254682 0 : SgSizeOfOp::get_global_qualification_required () const
254683 : {
254684 0 : ROSE_ASSERT (this != NULL);
254685 0 : return p_global_qualification_required;
254686 : }
254687 :
254688 : void
254689 497 : SgSizeOfOp::set_global_qualification_required ( bool global_qualification_required )
254690 : {
254691 497 : ROSE_ASSERT (this != NULL);
254692 :
254693 : // This can't be called by the name qualification API (see test2015_26.C).
254694 : // set_isModified(true);
254695 :
254696 497 : p_global_qualification_required = global_qualification_required;
254697 497 : }
254698 :
254699 : // DQ (4/15/2019): These six access functions should not be generated by ROSETTA
254700 : // so that we could avoid them setting the isModified flag which is a problem in the
254701 : // name qualification support for C++ (interfering with the token-based unparsing).
254702 : int
254703 0 : SgSizeOfOp::get_name_qualification_for_pointer_to_member_class_length () const
254704 : {
254705 0 : ROSE_ASSERT (this != NULL);
254706 0 : return p_name_qualification_for_pointer_to_member_class_length;
254707 : }
254708 :
254709 : void
254710 0 : SgSizeOfOp::set_name_qualification_for_pointer_to_member_class_length ( int name_qualification_length )
254711 : {
254712 0 : ROSE_ASSERT (this != NULL);
254713 : // This can't be called by the name qualification API (see test2015_26.C).
254714 : // set_isModified(true);
254715 :
254716 0 : p_name_qualification_for_pointer_to_member_class_length = name_qualification_length;
254717 0 : }
254718 :
254719 : bool
254720 0 : SgSizeOfOp::get_type_elaboration_for_pointer_to_member_class_required () const
254721 : {
254722 0 : ROSE_ASSERT (this != NULL);
254723 0 : return p_type_elaboration_for_pointer_to_member_class_required;
254724 : }
254725 :
254726 : void
254727 0 : SgSizeOfOp::set_type_elaboration_for_pointer_to_member_class_required ( bool type_elaboration_required )
254728 : {
254729 0 : ROSE_ASSERT (this != NULL);
254730 : // This can't be called by the name qualification API (see test2015_26.C).
254731 : // set_isModified(true);
254732 :
254733 0 : p_type_elaboration_for_pointer_to_member_class_required = type_elaboration_required;
254734 0 : }
254735 :
254736 : bool
254737 0 : SgSizeOfOp::get_global_qualification_for_pointer_to_member_class_required () const
254738 : {
254739 0 : ROSE_ASSERT (this != NULL);
254740 0 : return p_global_qualification_for_pointer_to_member_class_required;
254741 : }
254742 :
254743 : void
254744 0 : SgSizeOfOp::set_global_qualification_for_pointer_to_member_class_required ( bool global_qualification_required )
254745 : {
254746 0 : ROSE_ASSERT (this != NULL);
254747 :
254748 : // This can't be called by the name qualification API (see test2015_26.C).
254749 : // set_isModified(true);
254750 :
254751 0 : p_global_qualification_for_pointer_to_member_class_required = global_qualification_required;
254752 0 : }
254753 :
254754 :
254755 :
254756 :
254757 :
254758 :
254759 : // End of memberFunctionString
254760 : // Start of memberFunctionString
254761 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
254762 :
254763 : // *** COMMON CODE SECTION BEGINS HERE ***
254764 :
254765 : #if 0
254766 : int
254767 : SgSizeOfOp::getVariant() const
254768 : {
254769 : // This function is used in ROSE while "variant()" is used in SAGE
254770 : assert(this != NULL);
254771 : return variant();
254772 : }
254773 : #endif
254774 :
254775 : // This function is used in ROSE in treeTraversal code
254776 : // eventually replaces getVariant() and variant()
254777 : // though after variant() has been removed for a while we will
254778 : // want to change the name of variantT() back to variant()
254779 : // (since the "T" was ment to stand for temporary).
254780 : // When this happens the variantT() will be depricated.
254781 : VariantT
254782 304962 : SgSizeOfOp::variantT() const
254783 : {
254784 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
254785 304962 : ROSE_ASSERT(this != NULL);
254786 304962 : return V_SgSizeOfOp;
254787 : }
254788 :
254789 : #if 0
254790 : int
254791 : SgSizeOfOp::variant() const
254792 : {
254793 : // This function is used in SAGE
254794 : ROSE_ASSERT(this != NULL);
254795 : return SIZEOF_OP;
254796 : }
254797 : #endif
254798 :
254799 : ROSE_DLL_API const char*
254800 28 : SgSizeOfOp::sage_class_name() const
254801 : {
254802 28 : ROSE_ASSERT(this != NULL);
254803 28 : return "SgSizeOfOp";
254804 : }
254805 :
254806 : std::string
254807 1612 : SgSizeOfOp::class_name() const
254808 : {
254809 1612 : ROSE_ASSERT(this != NULL);
254810 1612 : return "SgSizeOfOp";
254811 : }
254812 :
254813 : // DQ (11/26/2005): Support for visitor pattern mechanims
254814 : // (inferior to ROSE traversal mechanism, experimental).
254815 : void
254816 13157 : SgSizeOfOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
254817 : {
254818 13157 : ROSE_ASSERT(this != NULL);
254819 13157 : visitor.visit(this);
254820 13157 : }
254821 :
254822 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
254823 0 : void SgSizeOfOp::accept (ROSE_VisitorPattern & visitor) {
254824 0 : ROSE_ASSERT(this != NULL);
254825 0 : visitor.visit(this);
254826 0 : }
254827 :
254828 : SgSizeOfOp*
254829 0 : SgSizeOfOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
254830 : {
254831 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
254832 : // This function is currently only supported for the AST used the represent Binary executables.
254833 : if (0 /* isSgAsmNode(this) != NULL */)
254834 : {
254835 : // Support for regex specification.
254836 : std::string prefixCode = "REGEX:";
254837 : addNewAttribute(prefixCode + s,a);
254838 : }
254839 : #endif
254840 :
254841 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
254842 0 : return this;
254843 : }
254844 :
254845 : // *** COMMON CODE SECTION ENDS HERE ***
254846 :
254847 :
254848 : // End of memberFunctionString
254849 : // Start of memberFunctionString
254850 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
254851 :
254852 :
254853 : #if 0
254854 : //! Error checking support
254855 : /*! Verifies the following:
254856 : - working getVariant() member function
254857 : - calls base class's error() member function
254858 : Every class has one of these functions.
254859 : */
254860 : bool
254861 : SgSizeOfOp::error()
254862 : {
254863 : // Put error checking here
254864 :
254865 : ROSE_ASSERT (this != NULL);
254866 : if (getVariant() != SIZEOF_OP)
254867 : {
254868 : printf ("Error in SgSizeOfOp::error(): SgSizeOfOp object has a %s variant \n",
254869 : Cxx_GrammarTerminalNames[getVariant()].name);
254870 : // printf ("Error in SgSizeOfOp::error() \n");
254871 : ROSE_ABORT();
254872 : }
254873 :
254874 : ROSE_ASSERT (getVariant() == SIZEOF_OP);
254875 : return SgExpression::error();
254876 : }
254877 : #endif
254878 :
254879 :
254880 :
254881 : // End of memberFunctionString
254882 :
254883 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
254884 :
254885 2843610 : SgSizeOfOp* isSgSizeOfOp ( SgNode* inputDerivedClassPointer )
254886 : {
254887 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
254888 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
254889 : // So to fix this we return NULL directly when the input is NULL and avoid the
254890 : // dynamic_cast in this case. This is likely a performance improvement as well.
254891 : // return dynamic_cast<SgSizeOfOp*>(inputDerivedClassPointer);
254892 : // Milind Chabbi (8/28/2013): isSgSizeOfOp uses table-driven castability instead of c++ default dynamic_cast
254893 : // this improves the running time performance by 10-20%.
254894 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSizeOfOp*>(inputDerivedClassPointer);
254895 2843610 : return IS_SgSizeOfOp_FAST_MACRO(inputDerivedClassPointer);
254896 : }
254897 :
254898 : // DQ (11/8/2003): Added version of functions taking const pointer
254899 79 : const SgSizeOfOp* isSgSizeOfOp ( const SgNode* inputDerivedClassPointer )
254900 : {
254901 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
254902 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
254903 : // So to fix this we return NULL directly when the input is NULL and avoid the
254904 : // dynamic_cast in this case. This is likely a performance improvement as well.
254905 : // return dynamic_cast<const SgSizeOfOp*>(inputDerivedClassPointer);
254906 : // Milind Chabbi (8/28/2013): isSgSizeOfOp uses table-driven castability instead of c++ default dynamic_cast
254907 : // this improves the running time performance by 10-20%.
254908 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSizeOfOp*>(inputDerivedClassPointer);
254909 79 : return IS_SgSizeOfOp_FAST_MACRO(inputDerivedClassPointer);
254910 : }
254911 :
254912 :
254913 :
254914 : /* #line 254915 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254915 :
254916 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
254917 :
254918 : /**
254919 : \brief Generated destructor
254920 :
254921 : This destructor is automatically generated (by ROSETTA). This destructor
254922 : only frees memory of data members associated with the parts of the current IR node which
254923 : are NOT traversed. Those data members that are part of a traversal can be freed using
254924 : a traversal (calling this destructor on all children in a post-order traversal). Such
254925 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
254926 :
254927 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
254928 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
254929 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
254930 :
254931 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
254932 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
254933 : pointers are not yet implemented to call delete on eash pointer in the container.
254934 : (This could be done by derivation from the STL containers to define containers that
254935 : automatically deleted their members.)
254936 :
254937 : */
254938 1258 : SgSizeOfOp::~SgSizeOfOp () {
254939 629 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
254940 :
254941 :
254942 : // case: not a listType for operand_expr
254943 629 : p_operand_expr = NULL; // non list case
254944 : // case: not a listType for operand_type
254945 629 : p_operand_type = NULL; // non list case
254946 : // case: not a listType for expression_type
254947 629 : p_expression_type = NULL; // non list case
254948 : // case: not a listType for name_qualification_length
254949 629 : p_name_qualification_length = 0; // non list case
254950 : // case: not a listType for type_elaboration_required
254951 629 : p_type_elaboration_required = false; // non list case
254952 : // case: not a listType for global_qualification_required
254953 629 : p_global_qualification_required = false; // non list case
254954 : // case: not a listType for sizeOfContainsBaseTypeDefiningDeclaration
254955 629 : p_sizeOfContainsBaseTypeDefiningDeclaration = false; // non list case
254956 : // case: not a listType for is_objectless_nonstatic_data_member_reference
254957 629 : p_is_objectless_nonstatic_data_member_reference = false; // non list case
254958 : // case: not a listType for name_qualification_for_pointer_to_member_class_length
254959 629 : p_name_qualification_for_pointer_to_member_class_length = 0; // non list case
254960 : // case: not a listType for type_elaboration_for_pointer_to_member_class_required
254961 629 : p_type_elaboration_for_pointer_to_member_class_required = false; // non list case
254962 : // case: not a listType for global_qualification_for_pointer_to_member_class_required
254963 629 : p_global_qualification_for_pointer_to_member_class_required = false; // non list case
254964 :
254965 : }
254966 :
254967 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
254968 1258 : }
254969 :
254970 :
254971 : /* #line 254972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
254972 :
254973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
254974 :
254975 : // Generated constructor
254976 34 : SgSizeOfOp::SgSizeOfOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type, SgType* expression_type )
254977 34 : : SgExpression(startOfConstruct)
254978 : {
254979 : #ifdef DEBUG
254980 : // printf ("In SgSizeOfOp::SgSizeOfOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
254981 : #endif
254982 : #if 0
254983 : // debugging information!
254984 : printf ("In SgSizeOfOp::SgSizeOfOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
254985 : #endif
254986 :
254987 34 : p_operand_expr = operand_expr;
254988 34 : p_operand_type = operand_type;
254989 34 : p_expression_type = expression_type;
254990 34 : p_name_qualification_length = 0;
254991 34 : p_type_elaboration_required = false;
254992 34 : p_global_qualification_required = false;
254993 34 : p_sizeOfContainsBaseTypeDefiningDeclaration = false;
254994 34 : p_is_objectless_nonstatic_data_member_reference = false;
254995 34 : p_name_qualification_for_pointer_to_member_class_length = 0;
254996 34 : p_type_elaboration_for_pointer_to_member_class_required = false;
254997 34 : p_global_qualification_for_pointer_to_member_class_required = false;
254998 :
254999 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
255000 :
255001 : #if 0
255002 : // DQ (7/30/2014): Call a virtual function.
255003 : std::string s = this->class_name();
255004 : #endif
255005 :
255006 : // Test the variant virtual function
255007 : // assert(SIZEOF_OP == variant());
255008 34 : assert(SIZEOF_OP == this->variant());
255009 34 : ROSE_ASSERT(SIZEOF_OP == (int)(this->variantT()));
255010 34 : post_construction_initialization();
255011 :
255012 : // Test the isSgSizeOfOp() function since it has been problematic
255013 34 : assert(isSgSizeOfOp(this) != NULL);
255014 34 : }
255015 :
255016 : // Generated constructor (all data members)
255017 :
255018 : /* #line 255019 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255019 :
255020 :
255021 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
255022 :
255023 :
255024 : // ********************************************************
255025 : // member functions common across all array grammar objects
255026 : // ********************************************************
255027 :
255028 :
255029 :
255030 : /* #line 255031 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255031 :
255032 :
255033 :
255034 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
255035 :
255036 : // ********************************************************
255037 : // member functions specific to each node in the grammar
255038 : // ********************************************************
255039 :
255040 :
255041 : /* #line 255042 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255042 :
255043 : // Start of memberFunctionString
255044 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
255045 :
255046 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
255047 :
255048 : SgExpression*
255049 0 : SgUpcLocalsizeofExpression::get_expression () const
255050 : {
255051 0 : ROSE_ASSERT (this != NULL);
255052 :
255053 : #if 0
255054 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255055 : // used to trigger marking transformations for the token-based unparsing.
255056 : printf ("SgUpcLocalsizeofExpression::get_expression = %p = %s \n",this,this->class_name().c_str());
255057 : #endif
255058 :
255059 0 : return p_expression;
255060 : }
255061 :
255062 : void
255063 0 : SgUpcLocalsizeofExpression::set_expression ( SgExpression* expression )
255064 : {
255065 0 : ROSE_ASSERT (this != NULL);
255066 :
255067 : #if 0
255068 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255069 : // used to trigger marking transformations for the token-based unparsing.
255070 : printf ("SgUpcLocalsizeofExpression::set_expression = %p = %s \n",this,this->class_name().c_str());
255071 : #endif
255072 :
255073 0 : set_isModified(true);
255074 :
255075 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
255076 : if (p_expression != NULL && expression != NULL && p_expression != expression)
255077 : {
255078 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
255079 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
255080 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
255081 : ROSE_ASSERT(false);
255082 : #endif
255083 : }
255084 : #endif
255085 0 : p_expression = expression;
255086 0 : }
255087 :
255088 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
255089 :
255090 :
255091 : // End of memberFunctionString
255092 : // Start of memberFunctionString
255093 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
255094 :
255095 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
255096 :
255097 : SgType*
255098 0 : SgUpcLocalsizeofExpression::get_operand_type () const
255099 : {
255100 0 : ROSE_ASSERT (this != NULL);
255101 :
255102 : #if 0
255103 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255104 : // used to trigger marking transformations for the token-based unparsing.
255105 : printf ("SgUpcLocalsizeofExpression::get_operand_type = %p = %s \n",this,this->class_name().c_str());
255106 : #endif
255107 :
255108 0 : return p_operand_type;
255109 : }
255110 :
255111 : void
255112 0 : SgUpcLocalsizeofExpression::set_operand_type ( SgType* operand_type )
255113 : {
255114 0 : ROSE_ASSERT (this != NULL);
255115 :
255116 : #if 0
255117 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255118 : // used to trigger marking transformations for the token-based unparsing.
255119 : printf ("SgUpcLocalsizeofExpression::set_operand_type = %p = %s \n",this,this->class_name().c_str());
255120 : #endif
255121 :
255122 0 : set_isModified(true);
255123 :
255124 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
255125 : if (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type)
255126 : {
255127 : printf ("Warning: operand_type = %p overwriting valid pointer p_operand_type = %p \n",operand_type,p_operand_type);
255128 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
255129 : printf ("Error fails assertion (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type) is false\n");
255130 : ROSE_ASSERT(false);
255131 : #endif
255132 : }
255133 : #endif
255134 0 : p_operand_type = operand_type;
255135 0 : }
255136 :
255137 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
255138 :
255139 :
255140 : // End of memberFunctionString
255141 : // Start of memberFunctionString
255142 :
255143 :
255144 : // End of memberFunctionString
255145 : // Start of memberFunctionString
255146 : /* #line 9189 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
255147 :
255148 : void
255149 0 : SgUpcLocalsizeofExpression::post_construction_initialization()
255150 : {
255151 0 : }
255152 :
255153 : // DQ (2/12/2011): Copied this version from SgSizeOfOp::get_type().
255154 : SgType*
255155 0 : SgUpcLocalsizeofExpression::get_type() const
255156 : {
255157 : // This function returns an unsigned integer representing the size of type
255158 : // (the unsigned int should match size_t, which may or may not be defined).
255159 :
255160 0 : ROSE_ASSERT(p_expression != NULL || p_operand_type != NULL);
255161 :
255162 : #if 0
255163 : printf ("In SgUpcLocalsizeofExpression::get_type() \n");
255164 : #endif
255165 :
255166 0 : SgType* returnType = SgTypeUnsignedInt::createType();
255167 :
255168 0 : ROSE_ASSERT(returnType != NULL);
255169 0 : return returnType;
255170 : }
255171 :
255172 : #if 0
255173 : SgType*
255174 : SgUpcLocalsizeofExpression::get_type() const
255175 : {
255176 : SgType* returnType = get_expression()->get_type();
255177 : ROSE_ASSERT(returnType != NULL);
255178 : return returnType;
255179 : }
255180 : #endif
255181 :
255182 :
255183 :
255184 : // End of memberFunctionString
255185 : // Start of memberFunctionString
255186 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
255187 :
255188 : // *** COMMON CODE SECTION BEGINS HERE ***
255189 :
255190 : #if 0
255191 : int
255192 : SgUpcLocalsizeofExpression::getVariant() const
255193 : {
255194 : // This function is used in ROSE while "variant()" is used in SAGE
255195 : assert(this != NULL);
255196 : return variant();
255197 : }
255198 : #endif
255199 :
255200 : // This function is used in ROSE in treeTraversal code
255201 : // eventually replaces getVariant() and variant()
255202 : // though after variant() has been removed for a while we will
255203 : // want to change the name of variantT() back to variant()
255204 : // (since the "T" was ment to stand for temporary).
255205 : // When this happens the variantT() will be depricated.
255206 : VariantT
255207 0 : SgUpcLocalsizeofExpression::variantT() const
255208 : {
255209 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
255210 0 : ROSE_ASSERT(this != NULL);
255211 0 : return V_SgUpcLocalsizeofExpression;
255212 : }
255213 :
255214 : #if 0
255215 : int
255216 : SgUpcLocalsizeofExpression::variant() const
255217 : {
255218 : // This function is used in SAGE
255219 : ROSE_ASSERT(this != NULL);
255220 : return UPC_LOCAL_SIZEOF_EXPR;
255221 : }
255222 : #endif
255223 :
255224 : ROSE_DLL_API const char*
255225 0 : SgUpcLocalsizeofExpression::sage_class_name() const
255226 : {
255227 0 : ROSE_ASSERT(this != NULL);
255228 0 : return "SgUpcLocalsizeofExpression";
255229 : }
255230 :
255231 : std::string
255232 0 : SgUpcLocalsizeofExpression::class_name() const
255233 : {
255234 0 : ROSE_ASSERT(this != NULL);
255235 0 : return "SgUpcLocalsizeofExpression";
255236 : }
255237 :
255238 : // DQ (11/26/2005): Support for visitor pattern mechanims
255239 : // (inferior to ROSE traversal mechanism, experimental).
255240 : void
255241 0 : SgUpcLocalsizeofExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
255242 : {
255243 0 : ROSE_ASSERT(this != NULL);
255244 0 : visitor.visit(this);
255245 0 : }
255246 :
255247 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
255248 0 : void SgUpcLocalsizeofExpression::accept (ROSE_VisitorPattern & visitor) {
255249 0 : ROSE_ASSERT(this != NULL);
255250 0 : visitor.visit(this);
255251 0 : }
255252 :
255253 : SgUpcLocalsizeofExpression*
255254 0 : SgUpcLocalsizeofExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
255255 : {
255256 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
255257 : // This function is currently only supported for the AST used the represent Binary executables.
255258 : if (0 /* isSgAsmNode(this) != NULL */)
255259 : {
255260 : // Support for regex specification.
255261 : std::string prefixCode = "REGEX:";
255262 : addNewAttribute(prefixCode + s,a);
255263 : }
255264 : #endif
255265 :
255266 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
255267 0 : return this;
255268 : }
255269 :
255270 : // *** COMMON CODE SECTION ENDS HERE ***
255271 :
255272 :
255273 : // End of memberFunctionString
255274 : // Start of memberFunctionString
255275 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
255276 :
255277 :
255278 : #if 0
255279 : //! Error checking support
255280 : /*! Verifies the following:
255281 : - working getVariant() member function
255282 : - calls base class's error() member function
255283 : Every class has one of these functions.
255284 : */
255285 : bool
255286 : SgUpcLocalsizeofExpression::error()
255287 : {
255288 : // Put error checking here
255289 :
255290 : ROSE_ASSERT (this != NULL);
255291 : if (getVariant() != UPC_LOCAL_SIZEOF_EXPR)
255292 : {
255293 : printf ("Error in SgUpcLocalsizeofExpression::error(): SgUpcLocalsizeofExpression object has a %s variant \n",
255294 : Cxx_GrammarTerminalNames[getVariant()].name);
255295 : // printf ("Error in SgUpcLocalsizeofExpression::error() \n");
255296 : ROSE_ABORT();
255297 : }
255298 :
255299 : ROSE_ASSERT (getVariant() == UPC_LOCAL_SIZEOF_EXPR);
255300 : return SgExpression::error();
255301 : }
255302 : #endif
255303 :
255304 :
255305 :
255306 : // End of memberFunctionString
255307 :
255308 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
255309 :
255310 0 : SgUpcLocalsizeofExpression* isSgUpcLocalsizeofExpression ( SgNode* inputDerivedClassPointer )
255311 : {
255312 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
255313 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
255314 : // So to fix this we return NULL directly when the input is NULL and avoid the
255315 : // dynamic_cast in this case. This is likely a performance improvement as well.
255316 : // return dynamic_cast<SgUpcLocalsizeofExpression*>(inputDerivedClassPointer);
255317 : // Milind Chabbi (8/28/2013): isSgUpcLocalsizeofExpression uses table-driven castability instead of c++ default dynamic_cast
255318 : // this improves the running time performance by 10-20%.
255319 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcLocalsizeofExpression*>(inputDerivedClassPointer);
255320 0 : return IS_SgUpcLocalsizeofExpression_FAST_MACRO(inputDerivedClassPointer);
255321 : }
255322 :
255323 : // DQ (11/8/2003): Added version of functions taking const pointer
255324 0 : const SgUpcLocalsizeofExpression* isSgUpcLocalsizeofExpression ( const SgNode* inputDerivedClassPointer )
255325 : {
255326 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
255327 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
255328 : // So to fix this we return NULL directly when the input is NULL and avoid the
255329 : // dynamic_cast in this case. This is likely a performance improvement as well.
255330 : // return dynamic_cast<const SgUpcLocalsizeofExpression*>(inputDerivedClassPointer);
255331 : // Milind Chabbi (8/28/2013): isSgUpcLocalsizeofExpression uses table-driven castability instead of c++ default dynamic_cast
255332 : // this improves the running time performance by 10-20%.
255333 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcLocalsizeofExpression*>(inputDerivedClassPointer);
255334 0 : return IS_SgUpcLocalsizeofExpression_FAST_MACRO(inputDerivedClassPointer);
255335 : }
255336 :
255337 :
255338 :
255339 : /* #line 255340 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255340 :
255341 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
255342 :
255343 : /**
255344 : \brief Generated destructor
255345 :
255346 : This destructor is automatically generated (by ROSETTA). This destructor
255347 : only frees memory of data members associated with the parts of the current IR node which
255348 : are NOT traversed. Those data members that are part of a traversal can be freed using
255349 : a traversal (calling this destructor on all children in a post-order traversal). Such
255350 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
255351 :
255352 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
255353 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
255354 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
255355 :
255356 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
255357 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
255358 : pointers are not yet implemented to call delete on eash pointer in the container.
255359 : (This could be done by derivation from the STL containers to define containers that
255360 : automatically deleted their members.)
255361 :
255362 : */
255363 0 : SgUpcLocalsizeofExpression::~SgUpcLocalsizeofExpression () {
255364 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
255365 :
255366 :
255367 : // case: not a listType for expression
255368 0 : p_expression = NULL; // non list case
255369 : // case: not a listType for operand_type
255370 0 : p_operand_type = NULL; // non list case
255371 : // case: not a listType for expression_type
255372 0 : p_expression_type = NULL; // non list case
255373 :
255374 : }
255375 :
255376 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
255377 0 : }
255378 :
255379 :
255380 : /* #line 255381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255381 :
255382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
255383 :
255384 : // Generated constructor
255385 0 : SgUpcLocalsizeofExpression::SgUpcLocalsizeofExpression ( Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type )
255386 0 : : SgExpression(startOfConstruct)
255387 : {
255388 : #ifdef DEBUG
255389 : // printf ("In SgUpcLocalsizeofExpression::SgUpcLocalsizeofExpression (Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
255390 : #endif
255391 : #if 0
255392 : // debugging information!
255393 : printf ("In SgUpcLocalsizeofExpression::SgUpcLocalsizeofExpression (Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
255394 : #endif
255395 :
255396 0 : p_expression = expression;
255397 0 : p_operand_type = operand_type;
255398 0 : p_expression_type = expression_type;
255399 :
255400 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
255401 :
255402 : #if 0
255403 : // DQ (7/30/2014): Call a virtual function.
255404 : std::string s = this->class_name();
255405 : #endif
255406 :
255407 : // Test the variant virtual function
255408 : // assert(UPC_LOCAL_SIZEOF_EXPR == variant());
255409 0 : assert(UPC_LOCAL_SIZEOF_EXPR == this->variant());
255410 0 : ROSE_ASSERT(UPC_LOCAL_SIZEOF_EXPR == (int)(this->variantT()));
255411 0 : post_construction_initialization();
255412 :
255413 : // Test the isSgUpcLocalsizeofExpression() function since it has been problematic
255414 0 : assert(isSgUpcLocalsizeofExpression(this) != NULL);
255415 0 : }
255416 :
255417 : // Generated constructor (all data members)
255418 :
255419 : /* #line 255420 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255420 :
255421 :
255422 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
255423 :
255424 :
255425 : // ********************************************************
255426 : // member functions common across all array grammar objects
255427 : // ********************************************************
255428 :
255429 :
255430 :
255431 : /* #line 255432 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255432 :
255433 :
255434 :
255435 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
255436 :
255437 : // ********************************************************
255438 : // member functions specific to each node in the grammar
255439 : // ********************************************************
255440 :
255441 :
255442 : /* #line 255443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255443 :
255444 : // Start of memberFunctionString
255445 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
255446 :
255447 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
255448 :
255449 : SgExpression*
255450 0 : SgUpcBlocksizeofExpression::get_expression () const
255451 : {
255452 0 : ROSE_ASSERT (this != NULL);
255453 :
255454 : #if 0
255455 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255456 : // used to trigger marking transformations for the token-based unparsing.
255457 : printf ("SgUpcBlocksizeofExpression::get_expression = %p = %s \n",this,this->class_name().c_str());
255458 : #endif
255459 :
255460 0 : return p_expression;
255461 : }
255462 :
255463 : void
255464 0 : SgUpcBlocksizeofExpression::set_expression ( SgExpression* expression )
255465 : {
255466 0 : ROSE_ASSERT (this != NULL);
255467 :
255468 : #if 0
255469 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255470 : // used to trigger marking transformations for the token-based unparsing.
255471 : printf ("SgUpcBlocksizeofExpression::set_expression = %p = %s \n",this,this->class_name().c_str());
255472 : #endif
255473 :
255474 0 : set_isModified(true);
255475 :
255476 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
255477 : if (p_expression != NULL && expression != NULL && p_expression != expression)
255478 : {
255479 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
255480 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
255481 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
255482 : ROSE_ASSERT(false);
255483 : #endif
255484 : }
255485 : #endif
255486 0 : p_expression = expression;
255487 0 : }
255488 :
255489 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
255490 :
255491 :
255492 : // End of memberFunctionString
255493 : // Start of memberFunctionString
255494 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
255495 :
255496 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
255497 :
255498 : SgType*
255499 0 : SgUpcBlocksizeofExpression::get_operand_type () const
255500 : {
255501 0 : ROSE_ASSERT (this != NULL);
255502 :
255503 : #if 0
255504 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255505 : // used to trigger marking transformations for the token-based unparsing.
255506 : printf ("SgUpcBlocksizeofExpression::get_operand_type = %p = %s \n",this,this->class_name().c_str());
255507 : #endif
255508 :
255509 0 : return p_operand_type;
255510 : }
255511 :
255512 : void
255513 0 : SgUpcBlocksizeofExpression::set_operand_type ( SgType* operand_type )
255514 : {
255515 0 : ROSE_ASSERT (this != NULL);
255516 :
255517 : #if 0
255518 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255519 : // used to trigger marking transformations for the token-based unparsing.
255520 : printf ("SgUpcBlocksizeofExpression::set_operand_type = %p = %s \n",this,this->class_name().c_str());
255521 : #endif
255522 :
255523 0 : set_isModified(true);
255524 :
255525 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
255526 : if (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type)
255527 : {
255528 : printf ("Warning: operand_type = %p overwriting valid pointer p_operand_type = %p \n",operand_type,p_operand_type);
255529 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
255530 : printf ("Error fails assertion (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type) is false\n");
255531 : ROSE_ASSERT(false);
255532 : #endif
255533 : }
255534 : #endif
255535 0 : p_operand_type = operand_type;
255536 0 : }
255537 :
255538 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
255539 :
255540 :
255541 : // End of memberFunctionString
255542 : // Start of memberFunctionString
255543 :
255544 :
255545 : // End of memberFunctionString
255546 : // Start of memberFunctionString
255547 : /* #line 9227 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
255548 :
255549 : void
255550 0 : SgUpcBlocksizeofExpression::post_construction_initialization()
255551 : {
255552 0 : }
255553 :
255554 : // DQ (2/12/2011): Copied this version from SgSizeOfOp::get_type().
255555 : SgType*
255556 0 : SgUpcBlocksizeofExpression::get_type() const
255557 : {
255558 : // This function returns an unsigned integer representing the size of type
255559 : // (the unsigned int should match size_t, which may or may not be defined).
255560 :
255561 0 : ROSE_ASSERT(p_expression != NULL || p_operand_type != NULL);
255562 :
255563 : #if 0
255564 : printf ("In SgUpcBlocksizeofExpression::get_type() \n");
255565 : #endif
255566 :
255567 0 : SgType* returnType = SgTypeUnsignedInt::createType();
255568 :
255569 0 : ROSE_ASSERT(returnType != NULL);
255570 0 : return returnType;
255571 : }
255572 :
255573 : #if 0
255574 : SgType*
255575 : SgUpcBlocksizeofExpression::get_type() const
255576 : {
255577 : SgType* returnType = get_expression()->get_type();
255578 : ROSE_ASSERT(returnType != NULL);
255579 : return returnType;
255580 : }
255581 : #endif
255582 :
255583 :
255584 :
255585 : // End of memberFunctionString
255586 : // Start of memberFunctionString
255587 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
255588 :
255589 : // *** COMMON CODE SECTION BEGINS HERE ***
255590 :
255591 : #if 0
255592 : int
255593 : SgUpcBlocksizeofExpression::getVariant() const
255594 : {
255595 : // This function is used in ROSE while "variant()" is used in SAGE
255596 : assert(this != NULL);
255597 : return variant();
255598 : }
255599 : #endif
255600 :
255601 : // This function is used in ROSE in treeTraversal code
255602 : // eventually replaces getVariant() and variant()
255603 : // though after variant() has been removed for a while we will
255604 : // want to change the name of variantT() back to variant()
255605 : // (since the "T" was ment to stand for temporary).
255606 : // When this happens the variantT() will be depricated.
255607 : VariantT
255608 0 : SgUpcBlocksizeofExpression::variantT() const
255609 : {
255610 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
255611 0 : ROSE_ASSERT(this != NULL);
255612 0 : return V_SgUpcBlocksizeofExpression;
255613 : }
255614 :
255615 : #if 0
255616 : int
255617 : SgUpcBlocksizeofExpression::variant() const
255618 : {
255619 : // This function is used in SAGE
255620 : ROSE_ASSERT(this != NULL);
255621 : return UPC_BLOCK_SIZEOF_EXPR;
255622 : }
255623 : #endif
255624 :
255625 : ROSE_DLL_API const char*
255626 0 : SgUpcBlocksizeofExpression::sage_class_name() const
255627 : {
255628 0 : ROSE_ASSERT(this != NULL);
255629 0 : return "SgUpcBlocksizeofExpression";
255630 : }
255631 :
255632 : std::string
255633 0 : SgUpcBlocksizeofExpression::class_name() const
255634 : {
255635 0 : ROSE_ASSERT(this != NULL);
255636 0 : return "SgUpcBlocksizeofExpression";
255637 : }
255638 :
255639 : // DQ (11/26/2005): Support for visitor pattern mechanims
255640 : // (inferior to ROSE traversal mechanism, experimental).
255641 : void
255642 0 : SgUpcBlocksizeofExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
255643 : {
255644 0 : ROSE_ASSERT(this != NULL);
255645 0 : visitor.visit(this);
255646 0 : }
255647 :
255648 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
255649 0 : void SgUpcBlocksizeofExpression::accept (ROSE_VisitorPattern & visitor) {
255650 0 : ROSE_ASSERT(this != NULL);
255651 0 : visitor.visit(this);
255652 0 : }
255653 :
255654 : SgUpcBlocksizeofExpression*
255655 0 : SgUpcBlocksizeofExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
255656 : {
255657 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
255658 : // This function is currently only supported for the AST used the represent Binary executables.
255659 : if (0 /* isSgAsmNode(this) != NULL */)
255660 : {
255661 : // Support for regex specification.
255662 : std::string prefixCode = "REGEX:";
255663 : addNewAttribute(prefixCode + s,a);
255664 : }
255665 : #endif
255666 :
255667 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
255668 0 : return this;
255669 : }
255670 :
255671 : // *** COMMON CODE SECTION ENDS HERE ***
255672 :
255673 :
255674 : // End of memberFunctionString
255675 : // Start of memberFunctionString
255676 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
255677 :
255678 :
255679 : #if 0
255680 : //! Error checking support
255681 : /*! Verifies the following:
255682 : - working getVariant() member function
255683 : - calls base class's error() member function
255684 : Every class has one of these functions.
255685 : */
255686 : bool
255687 : SgUpcBlocksizeofExpression::error()
255688 : {
255689 : // Put error checking here
255690 :
255691 : ROSE_ASSERT (this != NULL);
255692 : if (getVariant() != UPC_BLOCK_SIZEOF_EXPR)
255693 : {
255694 : printf ("Error in SgUpcBlocksizeofExpression::error(): SgUpcBlocksizeofExpression object has a %s variant \n",
255695 : Cxx_GrammarTerminalNames[getVariant()].name);
255696 : // printf ("Error in SgUpcBlocksizeofExpression::error() \n");
255697 : ROSE_ABORT();
255698 : }
255699 :
255700 : ROSE_ASSERT (getVariant() == UPC_BLOCK_SIZEOF_EXPR);
255701 : return SgExpression::error();
255702 : }
255703 : #endif
255704 :
255705 :
255706 :
255707 : // End of memberFunctionString
255708 :
255709 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
255710 :
255711 0 : SgUpcBlocksizeofExpression* isSgUpcBlocksizeofExpression ( SgNode* inputDerivedClassPointer )
255712 : {
255713 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
255714 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
255715 : // So to fix this we return NULL directly when the input is NULL and avoid the
255716 : // dynamic_cast in this case. This is likely a performance improvement as well.
255717 : // return dynamic_cast<SgUpcBlocksizeofExpression*>(inputDerivedClassPointer);
255718 : // Milind Chabbi (8/28/2013): isSgUpcBlocksizeofExpression uses table-driven castability instead of c++ default dynamic_cast
255719 : // this improves the running time performance by 10-20%.
255720 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcBlocksizeofExpression*>(inputDerivedClassPointer);
255721 0 : return IS_SgUpcBlocksizeofExpression_FAST_MACRO(inputDerivedClassPointer);
255722 : }
255723 :
255724 : // DQ (11/8/2003): Added version of functions taking const pointer
255725 0 : const SgUpcBlocksizeofExpression* isSgUpcBlocksizeofExpression ( const SgNode* inputDerivedClassPointer )
255726 : {
255727 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
255728 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
255729 : // So to fix this we return NULL directly when the input is NULL and avoid the
255730 : // dynamic_cast in this case. This is likely a performance improvement as well.
255731 : // return dynamic_cast<const SgUpcBlocksizeofExpression*>(inputDerivedClassPointer);
255732 : // Milind Chabbi (8/28/2013): isSgUpcBlocksizeofExpression uses table-driven castability instead of c++ default dynamic_cast
255733 : // this improves the running time performance by 10-20%.
255734 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcBlocksizeofExpression*>(inputDerivedClassPointer);
255735 0 : return IS_SgUpcBlocksizeofExpression_FAST_MACRO(inputDerivedClassPointer);
255736 : }
255737 :
255738 :
255739 :
255740 : /* #line 255741 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255741 :
255742 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
255743 :
255744 : /**
255745 : \brief Generated destructor
255746 :
255747 : This destructor is automatically generated (by ROSETTA). This destructor
255748 : only frees memory of data members associated with the parts of the current IR node which
255749 : are NOT traversed. Those data members that are part of a traversal can be freed using
255750 : a traversal (calling this destructor on all children in a post-order traversal). Such
255751 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
255752 :
255753 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
255754 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
255755 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
255756 :
255757 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
255758 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
255759 : pointers are not yet implemented to call delete on eash pointer in the container.
255760 : (This could be done by derivation from the STL containers to define containers that
255761 : automatically deleted their members.)
255762 :
255763 : */
255764 0 : SgUpcBlocksizeofExpression::~SgUpcBlocksizeofExpression () {
255765 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
255766 :
255767 :
255768 : // case: not a listType for expression
255769 0 : p_expression = NULL; // non list case
255770 : // case: not a listType for operand_type
255771 0 : p_operand_type = NULL; // non list case
255772 : // case: not a listType for expression_type
255773 0 : p_expression_type = NULL; // non list case
255774 :
255775 : }
255776 :
255777 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
255778 0 : }
255779 :
255780 :
255781 : /* #line 255782 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255782 :
255783 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
255784 :
255785 : // Generated constructor
255786 0 : SgUpcBlocksizeofExpression::SgUpcBlocksizeofExpression ( Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type )
255787 0 : : SgExpression(startOfConstruct)
255788 : {
255789 : #ifdef DEBUG
255790 : // printf ("In SgUpcBlocksizeofExpression::SgUpcBlocksizeofExpression (Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
255791 : #endif
255792 : #if 0
255793 : // debugging information!
255794 : printf ("In SgUpcBlocksizeofExpression::SgUpcBlocksizeofExpression (Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
255795 : #endif
255796 :
255797 0 : p_expression = expression;
255798 0 : p_operand_type = operand_type;
255799 0 : p_expression_type = expression_type;
255800 :
255801 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
255802 :
255803 : #if 0
255804 : // DQ (7/30/2014): Call a virtual function.
255805 : std::string s = this->class_name();
255806 : #endif
255807 :
255808 : // Test the variant virtual function
255809 : // assert(UPC_BLOCK_SIZEOF_EXPR == variant());
255810 0 : assert(UPC_BLOCK_SIZEOF_EXPR == this->variant());
255811 0 : ROSE_ASSERT(UPC_BLOCK_SIZEOF_EXPR == (int)(this->variantT()));
255812 0 : post_construction_initialization();
255813 :
255814 : // Test the isSgUpcBlocksizeofExpression() function since it has been problematic
255815 0 : assert(isSgUpcBlocksizeofExpression(this) != NULL);
255816 0 : }
255817 :
255818 : // Generated constructor (all data members)
255819 :
255820 : /* #line 255821 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255821 :
255822 :
255823 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
255824 :
255825 :
255826 : // ********************************************************
255827 : // member functions common across all array grammar objects
255828 : // ********************************************************
255829 :
255830 :
255831 :
255832 : /* #line 255833 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255833 :
255834 :
255835 :
255836 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
255837 :
255838 : // ********************************************************
255839 : // member functions specific to each node in the grammar
255840 : // ********************************************************
255841 :
255842 :
255843 : /* #line 255844 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
255844 :
255845 : // Start of memberFunctionString
255846 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
255847 :
255848 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
255849 :
255850 : SgExpression*
255851 0 : SgUpcElemsizeofExpression::get_expression () const
255852 : {
255853 0 : ROSE_ASSERT (this != NULL);
255854 :
255855 : #if 0
255856 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255857 : // used to trigger marking transformations for the token-based unparsing.
255858 : printf ("SgUpcElemsizeofExpression::get_expression = %p = %s \n",this,this->class_name().c_str());
255859 : #endif
255860 :
255861 0 : return p_expression;
255862 : }
255863 :
255864 : void
255865 0 : SgUpcElemsizeofExpression::set_expression ( SgExpression* expression )
255866 : {
255867 0 : ROSE_ASSERT (this != NULL);
255868 :
255869 : #if 0
255870 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255871 : // used to trigger marking transformations for the token-based unparsing.
255872 : printf ("SgUpcElemsizeofExpression::set_expression = %p = %s \n",this,this->class_name().c_str());
255873 : #endif
255874 :
255875 0 : set_isModified(true);
255876 :
255877 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
255878 : if (p_expression != NULL && expression != NULL && p_expression != expression)
255879 : {
255880 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
255881 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
255882 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
255883 : ROSE_ASSERT(false);
255884 : #endif
255885 : }
255886 : #endif
255887 0 : p_expression = expression;
255888 0 : }
255889 :
255890 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
255891 :
255892 :
255893 : // End of memberFunctionString
255894 : // Start of memberFunctionString
255895 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
255896 :
255897 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
255898 :
255899 : SgType*
255900 0 : SgUpcElemsizeofExpression::get_operand_type () const
255901 : {
255902 0 : ROSE_ASSERT (this != NULL);
255903 :
255904 : #if 0
255905 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255906 : // used to trigger marking transformations for the token-based unparsing.
255907 : printf ("SgUpcElemsizeofExpression::get_operand_type = %p = %s \n",this,this->class_name().c_str());
255908 : #endif
255909 :
255910 0 : return p_operand_type;
255911 : }
255912 :
255913 : void
255914 0 : SgUpcElemsizeofExpression::set_operand_type ( SgType* operand_type )
255915 : {
255916 0 : ROSE_ASSERT (this != NULL);
255917 :
255918 : #if 0
255919 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
255920 : // used to trigger marking transformations for the token-based unparsing.
255921 : printf ("SgUpcElemsizeofExpression::set_operand_type = %p = %s \n",this,this->class_name().c_str());
255922 : #endif
255923 :
255924 0 : set_isModified(true);
255925 :
255926 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
255927 : if (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type)
255928 : {
255929 : printf ("Warning: operand_type = %p overwriting valid pointer p_operand_type = %p \n",operand_type,p_operand_type);
255930 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
255931 : printf ("Error fails assertion (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type) is false\n");
255932 : ROSE_ASSERT(false);
255933 : #endif
255934 : }
255935 : #endif
255936 0 : p_operand_type = operand_type;
255937 0 : }
255938 :
255939 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
255940 :
255941 :
255942 : // End of memberFunctionString
255943 : // Start of memberFunctionString
255944 :
255945 :
255946 : // End of memberFunctionString
255947 : // Start of memberFunctionString
255948 : /* #line 9264 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
255949 :
255950 : void
255951 0 : SgUpcElemsizeofExpression::post_construction_initialization()
255952 : {
255953 0 : }
255954 :
255955 : // DQ (2/12/2011): Copied this version from SgSizeOfOp::get_type().
255956 : SgType*
255957 0 : SgUpcElemsizeofExpression::get_type() const
255958 : {
255959 : // This function returns an unsigned integer representing the size of type
255960 : // (the unsigned int should match size_t, which may or may not be defined).
255961 :
255962 0 : ROSE_ASSERT(p_expression != NULL || p_operand_type != NULL);
255963 :
255964 : #if 0
255965 : printf ("In SgUpcElemsizeofExpression::get_type() \n");
255966 : #endif
255967 :
255968 0 : SgType* returnType = SgTypeUnsignedInt::createType();
255969 :
255970 0 : ROSE_ASSERT(returnType != NULL);
255971 0 : return returnType;
255972 : }
255973 :
255974 : #if 0
255975 : SgType*
255976 : SgUpcElemsizeofExpression::get_type() const
255977 : {
255978 : SgType* returnType = get_expression()->get_type();
255979 : ROSE_ASSERT(returnType != NULL);
255980 : return returnType;
255981 : }
255982 : #endif
255983 :
255984 :
255985 :
255986 : // End of memberFunctionString
255987 : // Start of memberFunctionString
255988 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
255989 :
255990 : // *** COMMON CODE SECTION BEGINS HERE ***
255991 :
255992 : #if 0
255993 : int
255994 : SgUpcElemsizeofExpression::getVariant() const
255995 : {
255996 : // This function is used in ROSE while "variant()" is used in SAGE
255997 : assert(this != NULL);
255998 : return variant();
255999 : }
256000 : #endif
256001 :
256002 : // This function is used in ROSE in treeTraversal code
256003 : // eventually replaces getVariant() and variant()
256004 : // though after variant() has been removed for a while we will
256005 : // want to change the name of variantT() back to variant()
256006 : // (since the "T" was ment to stand for temporary).
256007 : // When this happens the variantT() will be depricated.
256008 : VariantT
256009 0 : SgUpcElemsizeofExpression::variantT() const
256010 : {
256011 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
256012 0 : ROSE_ASSERT(this != NULL);
256013 0 : return V_SgUpcElemsizeofExpression;
256014 : }
256015 :
256016 : #if 0
256017 : int
256018 : SgUpcElemsizeofExpression::variant() const
256019 : {
256020 : // This function is used in SAGE
256021 : ROSE_ASSERT(this != NULL);
256022 : return UPC_ELEM_SIZEOF_EXPR;
256023 : }
256024 : #endif
256025 :
256026 : ROSE_DLL_API const char*
256027 0 : SgUpcElemsizeofExpression::sage_class_name() const
256028 : {
256029 0 : ROSE_ASSERT(this != NULL);
256030 0 : return "SgUpcElemsizeofExpression";
256031 : }
256032 :
256033 : std::string
256034 0 : SgUpcElemsizeofExpression::class_name() const
256035 : {
256036 0 : ROSE_ASSERT(this != NULL);
256037 0 : return "SgUpcElemsizeofExpression";
256038 : }
256039 :
256040 : // DQ (11/26/2005): Support for visitor pattern mechanims
256041 : // (inferior to ROSE traversal mechanism, experimental).
256042 : void
256043 0 : SgUpcElemsizeofExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
256044 : {
256045 0 : ROSE_ASSERT(this != NULL);
256046 0 : visitor.visit(this);
256047 0 : }
256048 :
256049 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
256050 0 : void SgUpcElemsizeofExpression::accept (ROSE_VisitorPattern & visitor) {
256051 0 : ROSE_ASSERT(this != NULL);
256052 0 : visitor.visit(this);
256053 0 : }
256054 :
256055 : SgUpcElemsizeofExpression*
256056 0 : SgUpcElemsizeofExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
256057 : {
256058 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
256059 : // This function is currently only supported for the AST used the represent Binary executables.
256060 : if (0 /* isSgAsmNode(this) != NULL */)
256061 : {
256062 : // Support for regex specification.
256063 : std::string prefixCode = "REGEX:";
256064 : addNewAttribute(prefixCode + s,a);
256065 : }
256066 : #endif
256067 :
256068 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
256069 0 : return this;
256070 : }
256071 :
256072 : // *** COMMON CODE SECTION ENDS HERE ***
256073 :
256074 :
256075 : // End of memberFunctionString
256076 : // Start of memberFunctionString
256077 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
256078 :
256079 :
256080 : #if 0
256081 : //! Error checking support
256082 : /*! Verifies the following:
256083 : - working getVariant() member function
256084 : - calls base class's error() member function
256085 : Every class has one of these functions.
256086 : */
256087 : bool
256088 : SgUpcElemsizeofExpression::error()
256089 : {
256090 : // Put error checking here
256091 :
256092 : ROSE_ASSERT (this != NULL);
256093 : if (getVariant() != UPC_ELEM_SIZEOF_EXPR)
256094 : {
256095 : printf ("Error in SgUpcElemsizeofExpression::error(): SgUpcElemsizeofExpression object has a %s variant \n",
256096 : Cxx_GrammarTerminalNames[getVariant()].name);
256097 : // printf ("Error in SgUpcElemsizeofExpression::error() \n");
256098 : ROSE_ABORT();
256099 : }
256100 :
256101 : ROSE_ASSERT (getVariant() == UPC_ELEM_SIZEOF_EXPR);
256102 : return SgExpression::error();
256103 : }
256104 : #endif
256105 :
256106 :
256107 :
256108 : // End of memberFunctionString
256109 :
256110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
256111 :
256112 0 : SgUpcElemsizeofExpression* isSgUpcElemsizeofExpression ( SgNode* inputDerivedClassPointer )
256113 : {
256114 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
256115 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
256116 : // So to fix this we return NULL directly when the input is NULL and avoid the
256117 : // dynamic_cast in this case. This is likely a performance improvement as well.
256118 : // return dynamic_cast<SgUpcElemsizeofExpression*>(inputDerivedClassPointer);
256119 : // Milind Chabbi (8/28/2013): isSgUpcElemsizeofExpression uses table-driven castability instead of c++ default dynamic_cast
256120 : // this improves the running time performance by 10-20%.
256121 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUpcElemsizeofExpression*>(inputDerivedClassPointer);
256122 0 : return IS_SgUpcElemsizeofExpression_FAST_MACRO(inputDerivedClassPointer);
256123 : }
256124 :
256125 : // DQ (11/8/2003): Added version of functions taking const pointer
256126 0 : const SgUpcElemsizeofExpression* isSgUpcElemsizeofExpression ( const SgNode* inputDerivedClassPointer )
256127 : {
256128 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
256129 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
256130 : // So to fix this we return NULL directly when the input is NULL and avoid the
256131 : // dynamic_cast in this case. This is likely a performance improvement as well.
256132 : // return dynamic_cast<const SgUpcElemsizeofExpression*>(inputDerivedClassPointer);
256133 : // Milind Chabbi (8/28/2013): isSgUpcElemsizeofExpression uses table-driven castability instead of c++ default dynamic_cast
256134 : // this improves the running time performance by 10-20%.
256135 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUpcElemsizeofExpression*>(inputDerivedClassPointer);
256136 0 : return IS_SgUpcElemsizeofExpression_FAST_MACRO(inputDerivedClassPointer);
256137 : }
256138 :
256139 :
256140 :
256141 : /* #line 256142 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256142 :
256143 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
256144 :
256145 : /**
256146 : \brief Generated destructor
256147 :
256148 : This destructor is automatically generated (by ROSETTA). This destructor
256149 : only frees memory of data members associated with the parts of the current IR node which
256150 : are NOT traversed. Those data members that are part of a traversal can be freed using
256151 : a traversal (calling this destructor on all children in a post-order traversal). Such
256152 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
256153 :
256154 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
256155 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
256156 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
256157 :
256158 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
256159 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
256160 : pointers are not yet implemented to call delete on eash pointer in the container.
256161 : (This could be done by derivation from the STL containers to define containers that
256162 : automatically deleted their members.)
256163 :
256164 : */
256165 0 : SgUpcElemsizeofExpression::~SgUpcElemsizeofExpression () {
256166 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
256167 :
256168 :
256169 : // case: not a listType for expression
256170 0 : p_expression = NULL; // non list case
256171 : // case: not a listType for operand_type
256172 0 : p_operand_type = NULL; // non list case
256173 : // case: not a listType for expression_type
256174 0 : p_expression_type = NULL; // non list case
256175 :
256176 : }
256177 :
256178 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
256179 0 : }
256180 :
256181 :
256182 : /* #line 256183 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256183 :
256184 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
256185 :
256186 : // Generated constructor
256187 0 : SgUpcElemsizeofExpression::SgUpcElemsizeofExpression ( Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type )
256188 0 : : SgExpression(startOfConstruct)
256189 : {
256190 : #ifdef DEBUG
256191 : // printf ("In SgUpcElemsizeofExpression::SgUpcElemsizeofExpression (Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
256192 : #endif
256193 : #if 0
256194 : // debugging information!
256195 : printf ("In SgUpcElemsizeofExpression::SgUpcElemsizeofExpression (Sg_File_Info* startOfConstruct, SgExpression* expression, SgType* operand_type, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
256196 : #endif
256197 :
256198 0 : p_expression = expression;
256199 0 : p_operand_type = operand_type;
256200 0 : p_expression_type = expression_type;
256201 :
256202 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
256203 :
256204 : #if 0
256205 : // DQ (7/30/2014): Call a virtual function.
256206 : std::string s = this->class_name();
256207 : #endif
256208 :
256209 : // Test the variant virtual function
256210 : // assert(UPC_ELEM_SIZEOF_EXPR == variant());
256211 0 : assert(UPC_ELEM_SIZEOF_EXPR == this->variant());
256212 0 : ROSE_ASSERT(UPC_ELEM_SIZEOF_EXPR == (int)(this->variantT()));
256213 0 : post_construction_initialization();
256214 :
256215 : // Test the isSgUpcElemsizeofExpression() function since it has been problematic
256216 0 : assert(isSgUpcElemsizeofExpression(this) != NULL);
256217 0 : }
256218 :
256219 : // Generated constructor (all data members)
256220 :
256221 : /* #line 256222 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256222 :
256223 :
256224 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
256225 :
256226 :
256227 : // ********************************************************
256228 : // member functions common across all array grammar objects
256229 : // ********************************************************
256230 :
256231 :
256232 :
256233 : /* #line 256234 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256234 :
256235 :
256236 :
256237 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
256238 :
256239 : // ********************************************************
256240 : // member functions specific to each node in the grammar
256241 : // ********************************************************
256242 :
256243 :
256244 : /* #line 256245 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256245 :
256246 : // Start of memberFunctionString
256247 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
256248 :
256249 : void
256250 0 : SgSuperExp::post_construction_initialization()
256251 : {
256252 0 : }
256253 :
256254 :
256255 :
256256 : // End of memberFunctionString
256257 : // Start of memberFunctionString
256258 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
256259 :
256260 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
256261 :
256262 : SgClassSymbol*
256263 0 : SgSuperExp::get_class_symbol () const
256264 : {
256265 0 : ROSE_ASSERT (this != NULL);
256266 :
256267 : #if 0
256268 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256269 : // used to trigger marking transformations for the token-based unparsing.
256270 : printf ("SgSuperExp::get_class_symbol = %p = %s \n",this,this->class_name().c_str());
256271 : #endif
256272 :
256273 0 : return p_class_symbol;
256274 : }
256275 :
256276 : void
256277 0 : SgSuperExp::set_class_symbol ( SgClassSymbol* class_symbol )
256278 : {
256279 0 : ROSE_ASSERT (this != NULL);
256280 :
256281 : #if 0
256282 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256283 : // used to trigger marking transformations for the token-based unparsing.
256284 : printf ("SgSuperExp::set_class_symbol = %p = %s \n",this,this->class_name().c_str());
256285 : #endif
256286 :
256287 0 : set_isModified(true);
256288 :
256289 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
256290 : if (p_class_symbol != NULL && class_symbol != NULL && p_class_symbol != class_symbol)
256291 : {
256292 : printf ("Warning: class_symbol = %p overwriting valid pointer p_class_symbol = %p \n",class_symbol,p_class_symbol);
256293 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
256294 : printf ("Error fails assertion (p_class_symbol != NULL && class_symbol != NULL && p_class_symbol != class_symbol) is false\n");
256295 : ROSE_ASSERT(false);
256296 : #endif
256297 : }
256298 : #endif
256299 0 : p_class_symbol = class_symbol;
256300 0 : }
256301 :
256302 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
256303 :
256304 :
256305 : // End of memberFunctionString
256306 : // Start of memberFunctionString
256307 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
256308 :
256309 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
256310 :
256311 : int
256312 0 : SgSuperExp::get_pobj_super () const
256313 : {
256314 0 : ROSE_ASSERT (this != NULL);
256315 :
256316 : #if 0
256317 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256318 : // used to trigger marking transformations for the token-based unparsing.
256319 : printf ("SgSuperExp::get_pobj_super = %p = %s \n",this,this->class_name().c_str());
256320 : #endif
256321 :
256322 0 : return p_pobj_super;
256323 : }
256324 :
256325 : void
256326 0 : SgSuperExp::set_pobj_super ( int pobj_super )
256327 : {
256328 0 : ROSE_ASSERT (this != NULL);
256329 :
256330 : #if 0
256331 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256332 : // used to trigger marking transformations for the token-based unparsing.
256333 : printf ("SgSuperExp::set_pobj_super = %p = %s \n",this,this->class_name().c_str());
256334 : #endif
256335 :
256336 0 : set_isModified(true);
256337 :
256338 0 : p_pobj_super = pobj_super;
256339 0 : }
256340 :
256341 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
256342 :
256343 :
256344 : // End of memberFunctionString
256345 : // Start of memberFunctionString
256346 : /* #line 7040 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
256347 :
256348 :
256349 :
256350 : // End of memberFunctionString
256351 : // Start of memberFunctionString
256352 : /* #line 8493 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
256353 :
256354 :
256355 : SgType*
256356 0 : SgSuperExp::get_type() const
256357 : {
256358 0 : ROSE_ASSERT(get_class_symbol() != NULL);
256359 0 : ROSE_ASSERT(get_class_symbol()->get_type() != NULL);
256360 :
256361 : #if 0
256362 : printf ("In SgSuperExp::get_type() \n");
256363 : #endif
256364 :
256365 0 : return SgPointerType::createType(get_class_symbol()->get_type());
256366 : }
256367 :
256368 :
256369 :
256370 : // End of memberFunctionString
256371 : // Start of memberFunctionString
256372 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
256373 :
256374 : // *** COMMON CODE SECTION BEGINS HERE ***
256375 :
256376 : #if 0
256377 : int
256378 : SgSuperExp::getVariant() const
256379 : {
256380 : // This function is used in ROSE while "variant()" is used in SAGE
256381 : assert(this != NULL);
256382 : return variant();
256383 : }
256384 : #endif
256385 :
256386 : // This function is used in ROSE in treeTraversal code
256387 : // eventually replaces getVariant() and variant()
256388 : // though after variant() has been removed for a while we will
256389 : // want to change the name of variantT() back to variant()
256390 : // (since the "T" was ment to stand for temporary).
256391 : // When this happens the variantT() will be depricated.
256392 : VariantT
256393 0 : SgSuperExp::variantT() const
256394 : {
256395 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
256396 0 : ROSE_ASSERT(this != NULL);
256397 0 : return V_SgSuperExp;
256398 : }
256399 :
256400 : #if 0
256401 : int
256402 : SgSuperExp::variant() const
256403 : {
256404 : // This function is used in SAGE
256405 : ROSE_ASSERT(this != NULL);
256406 : return SUPER_NODE;
256407 : }
256408 : #endif
256409 :
256410 : ROSE_DLL_API const char*
256411 0 : SgSuperExp::sage_class_name() const
256412 : {
256413 0 : ROSE_ASSERT(this != NULL);
256414 0 : return "SgSuperExp";
256415 : }
256416 :
256417 : std::string
256418 0 : SgSuperExp::class_name() const
256419 : {
256420 0 : ROSE_ASSERT(this != NULL);
256421 0 : return "SgSuperExp";
256422 : }
256423 :
256424 : // DQ (11/26/2005): Support for visitor pattern mechanims
256425 : // (inferior to ROSE traversal mechanism, experimental).
256426 : void
256427 0 : SgSuperExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
256428 : {
256429 0 : ROSE_ASSERT(this != NULL);
256430 0 : visitor.visit(this);
256431 0 : }
256432 :
256433 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
256434 0 : void SgSuperExp::accept (ROSE_VisitorPattern & visitor) {
256435 0 : ROSE_ASSERT(this != NULL);
256436 0 : visitor.visit(this);
256437 0 : }
256438 :
256439 : SgSuperExp*
256440 0 : SgSuperExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
256441 : {
256442 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
256443 : // This function is currently only supported for the AST used the represent Binary executables.
256444 : if (0 /* isSgAsmNode(this) != NULL */)
256445 : {
256446 : // Support for regex specification.
256447 : std::string prefixCode = "REGEX:";
256448 : addNewAttribute(prefixCode + s,a);
256449 : }
256450 : #endif
256451 :
256452 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
256453 0 : return this;
256454 : }
256455 :
256456 : // *** COMMON CODE SECTION ENDS HERE ***
256457 :
256458 :
256459 : // End of memberFunctionString
256460 : // Start of memberFunctionString
256461 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
256462 :
256463 :
256464 : #if 0
256465 : //! Error checking support
256466 : /*! Verifies the following:
256467 : - working getVariant() member function
256468 : - calls base class's error() member function
256469 : Every class has one of these functions.
256470 : */
256471 : bool
256472 : SgSuperExp::error()
256473 : {
256474 : // Put error checking here
256475 :
256476 : ROSE_ASSERT (this != NULL);
256477 : if (getVariant() != SUPER_NODE)
256478 : {
256479 : printf ("Error in SgSuperExp::error(): SgSuperExp object has a %s variant \n",
256480 : Cxx_GrammarTerminalNames[getVariant()].name);
256481 : // printf ("Error in SgSuperExp::error() \n");
256482 : ROSE_ABORT();
256483 : }
256484 :
256485 : ROSE_ASSERT (getVariant() == SUPER_NODE);
256486 : return SgExpression::error();
256487 : }
256488 : #endif
256489 :
256490 :
256491 :
256492 : // End of memberFunctionString
256493 :
256494 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
256495 :
256496 0 : SgSuperExp* isSgSuperExp ( SgNode* inputDerivedClassPointer )
256497 : {
256498 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
256499 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
256500 : // So to fix this we return NULL directly when the input is NULL and avoid the
256501 : // dynamic_cast in this case. This is likely a performance improvement as well.
256502 : // return dynamic_cast<SgSuperExp*>(inputDerivedClassPointer);
256503 : // Milind Chabbi (8/28/2013): isSgSuperExp uses table-driven castability instead of c++ default dynamic_cast
256504 : // this improves the running time performance by 10-20%.
256505 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSuperExp*>(inputDerivedClassPointer);
256506 0 : return IS_SgSuperExp_FAST_MACRO(inputDerivedClassPointer);
256507 : }
256508 :
256509 : // DQ (11/8/2003): Added version of functions taking const pointer
256510 0 : const SgSuperExp* isSgSuperExp ( const SgNode* inputDerivedClassPointer )
256511 : {
256512 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
256513 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
256514 : // So to fix this we return NULL directly when the input is NULL and avoid the
256515 : // dynamic_cast in this case. This is likely a performance improvement as well.
256516 : // return dynamic_cast<const SgSuperExp*>(inputDerivedClassPointer);
256517 : // Milind Chabbi (8/28/2013): isSgSuperExp uses table-driven castability instead of c++ default dynamic_cast
256518 : // this improves the running time performance by 10-20%.
256519 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSuperExp*>(inputDerivedClassPointer);
256520 0 : return IS_SgSuperExp_FAST_MACRO(inputDerivedClassPointer);
256521 : }
256522 :
256523 :
256524 :
256525 : /* #line 256526 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256526 :
256527 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
256528 :
256529 : /**
256530 : \brief Generated destructor
256531 :
256532 : This destructor is automatically generated (by ROSETTA). This destructor
256533 : only frees memory of data members associated with the parts of the current IR node which
256534 : are NOT traversed. Those data members that are part of a traversal can be freed using
256535 : a traversal (calling this destructor on all children in a post-order traversal). Such
256536 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
256537 :
256538 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
256539 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
256540 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
256541 :
256542 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
256543 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
256544 : pointers are not yet implemented to call delete on eash pointer in the container.
256545 : (This could be done by derivation from the STL containers to define containers that
256546 : automatically deleted their members.)
256547 :
256548 : */
256549 0 : SgSuperExp::~SgSuperExp () {
256550 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
256551 :
256552 :
256553 : // case: not a listType for class_symbol
256554 0 : p_class_symbol = NULL; // non list case
256555 : // case: not a listType for pobj_super
256556 0 : p_pobj_super = 0; // non list case
256557 :
256558 : }
256559 :
256560 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
256561 0 : }
256562 :
256563 :
256564 : /* #line 256565 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256565 :
256566 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
256567 :
256568 : // Generated constructor
256569 0 : SgSuperExp::SgSuperExp ( Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, int pobj_super )
256570 0 : : SgExpression(startOfConstruct)
256571 : {
256572 : #ifdef DEBUG
256573 : // printf ("In SgSuperExp::SgSuperExp (Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, int pobj_super) sage_class_name() = %s \n",sage_class_name());
256574 : #endif
256575 : #if 0
256576 : // debugging information!
256577 : printf ("In SgSuperExp::SgSuperExp (Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, int pobj_super): this = %p = %s \n",this,this->class_name().c_str());
256578 : #endif
256579 :
256580 0 : p_class_symbol = class_symbol;
256581 0 : p_pobj_super = pobj_super;
256582 :
256583 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
256584 :
256585 : #if 0
256586 : // DQ (7/30/2014): Call a virtual function.
256587 : std::string s = this->class_name();
256588 : #endif
256589 :
256590 : // Test the variant virtual function
256591 : // assert(SUPER_NODE == variant());
256592 0 : assert(SUPER_NODE == this->variant());
256593 0 : ROSE_ASSERT(SUPER_NODE == (int)(this->variantT()));
256594 0 : post_construction_initialization();
256595 :
256596 : // Test the isSgSuperExp() function since it has been problematic
256597 0 : assert(isSgSuperExp(this) != NULL);
256598 0 : }
256599 :
256600 : // Generated constructor (all data members)
256601 :
256602 : /* #line 256603 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256603 :
256604 :
256605 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
256606 :
256607 :
256608 : // ********************************************************
256609 : // member functions common across all array grammar objects
256610 : // ********************************************************
256611 :
256612 :
256613 :
256614 : /* #line 256615 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256615 :
256616 :
256617 :
256618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
256619 :
256620 : // ********************************************************
256621 : // member functions specific to each node in the grammar
256622 : // ********************************************************
256623 :
256624 :
256625 : /* #line 256626 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
256626 :
256627 : // Start of memberFunctionString
256628 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
256629 :
256630 : void
256631 10 : SgTypeIdOp::post_construction_initialization()
256632 : {
256633 10 : }
256634 :
256635 :
256636 :
256637 : // End of memberFunctionString
256638 : // Start of memberFunctionString
256639 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
256640 :
256641 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
256642 :
256643 : SgExpression*
256644 0 : SgTypeIdOp::get_operand_expr () const
256645 : {
256646 0 : ROSE_ASSERT (this != NULL);
256647 :
256648 : #if 0
256649 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256650 : // used to trigger marking transformations for the token-based unparsing.
256651 : printf ("SgTypeIdOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
256652 : #endif
256653 :
256654 0 : return p_operand_expr;
256655 : }
256656 :
256657 : void
256658 0 : SgTypeIdOp::set_operand_expr ( SgExpression* operand_expr )
256659 : {
256660 0 : ROSE_ASSERT (this != NULL);
256661 :
256662 : #if 0
256663 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256664 : // used to trigger marking transformations for the token-based unparsing.
256665 : printf ("SgTypeIdOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
256666 : #endif
256667 :
256668 0 : set_isModified(true);
256669 :
256670 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
256671 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
256672 : {
256673 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
256674 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
256675 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
256676 : ROSE_ASSERT(false);
256677 : #endif
256678 : }
256679 : #endif
256680 0 : p_operand_expr = operand_expr;
256681 0 : }
256682 :
256683 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
256684 :
256685 :
256686 : // End of memberFunctionString
256687 : // Start of memberFunctionString
256688 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
256689 :
256690 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
256691 :
256692 : SgType*
256693 11 : SgTypeIdOp::get_operand_type () const
256694 : {
256695 11 : ROSE_ASSERT (this != NULL);
256696 :
256697 : #if 0
256698 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256699 : // used to trigger marking transformations for the token-based unparsing.
256700 : printf ("SgTypeIdOp::get_operand_type = %p = %s \n",this,this->class_name().c_str());
256701 : #endif
256702 :
256703 11 : return p_operand_type;
256704 : }
256705 :
256706 : void
256707 0 : SgTypeIdOp::set_operand_type ( SgType* operand_type )
256708 : {
256709 0 : ROSE_ASSERT (this != NULL);
256710 :
256711 : #if 0
256712 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
256713 : // used to trigger marking transformations for the token-based unparsing.
256714 : printf ("SgTypeIdOp::set_operand_type = %p = %s \n",this,this->class_name().c_str());
256715 : #endif
256716 :
256717 0 : set_isModified(true);
256718 :
256719 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
256720 : if (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type)
256721 : {
256722 : printf ("Warning: operand_type = %p overwriting valid pointer p_operand_type = %p \n",operand_type,p_operand_type);
256723 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
256724 : printf ("Error fails assertion (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type) is false\n");
256725 : ROSE_ASSERT(false);
256726 : #endif
256727 : }
256728 : #endif
256729 0 : p_operand_type = operand_type;
256730 0 : }
256731 :
256732 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
256733 :
256734 :
256735 : // End of memberFunctionString
256736 : // Start of memberFunctionString
256737 :
256738 :
256739 : // End of memberFunctionString
256740 : // Start of memberFunctionString
256741 : /* #line 5601 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
256742 :
256743 :
256744 : #if 0
256745 : // DQ (1/17/2008): There is already an operand_type with get and set functions generated by ROSETTA.
256746 : // DQ (1/17/2008): Added set_type function since this is one of three IR nodes that require
256747 : // the type to be held explicitly, for all other IR nodes the type is computed dynamicly.
256748 : void
256749 : SgTypeIdOp::set_type( SgType* type )
256750 : {
256751 : p_expression_type = type;
256752 : }
256753 : #endif
256754 :
256755 : SgType*
256756 40 : SgTypeIdOp::get_type() const
256757 : {
256758 : #if 0
256759 : printf ("In SgTypeIdOp::get_type() \n");
256760 : #endif
256761 :
256762 : #if 0
256763 : // DQ (7/20/2006): The typeid operator returns an lvalue of type const std::type_info that represents the
256764 : // type of expression expr. You must include the standard template library header <typeinfo> to use the
256765 : // typeid operator (obtained from IBM C++ web page). So it seems that the correct return type is a
256766 : // SgClassType with reference to the class declaration that should have been seen or we can perhaps assume to be
256767 : // simply: "std::type_info"
256768 :
256769 : // DQ (1/26/2013): Since the operand can be either an expression or a type, the return type has to be either from the expression, or from the operand.
256770 : // DQ (8/8/2006): The C++ standard requires that this return a "std::type_info" classType
256771 : // SgType* returnType = p_expression_type;
256772 : SgType* returnType = NULL;
256773 : if (p_operand_expr != NULL)
256774 : {
256775 : // Could we alternatively just call get_type on the expression directly?
256776 : // Note that EDG provised us with the type on the expression explicitly so
256777 : // this has influenced the design here with saves the expression type explicitly.
256778 : returnType = p_expression_type;
256779 : ROSE_ASSERT(returnType != NULL);
256780 : }
256781 : else
256782 : {
256783 : returnType = p_operand_type;
256784 : ROSE_ASSERT(returnType != NULL);
256785 : }
256786 :
256787 : ROSE_ASSERT(returnType != NULL);
256788 :
256789 : return returnType;
256790 : #else
256791 : // get_type on SgTypeIdOp must always retuen a const referene to "std::type_info"
256792 :
256793 40 : SgType* returnType = NULL;
256794 : // If we call get_type() on a node that is not fully build then this will break.
256795 40 : SgGlobal* globalScope = SageInterface::getGlobalScope(this);
256796 40 : ROSE_ASSERT(globalScope && "globalScope is NULL");
256797 :
256798 40 : SgNamespaceSymbol* stdNamespaceSymbol = globalScope->lookup_namespace_symbol(SgName("std"));
256799 40 : ROSE_ASSERT(stdNamespaceSymbol && "lookup_namespace_symbol did not found std symbol");
256800 :
256801 40 : SgNamespaceDeclarationStatement * namespaceDeclarationStatement = stdNamespaceSymbol->get_declaration ();
256802 40 : SgNamespaceDefinitionStatement * namespaceDefinitionStatement = namespaceDeclarationStatement->get_definition();
256803 40 : ROSE_ASSERT(namespaceDefinitionStatement && "get_definition() retured NULL");
256804 :
256805 40 : SgClassSymbol * typeInfoClassSymbol = namespaceDefinitionStatement->lookup_class_symbol(SgName("type_info"));
256806 40 : ROSE_ASSERT(typeInfoClassSymbol && "lookup_class_symbol did not found type_info symbol");
256807 :
256808 : //returnType = SageInterface::deepCopy(typeInfoClassSymbol->get_type());
256809 40 : returnType = typeInfoClassSymbol->get_type();
256810 40 : ROSE_ASSERT(isSgClassType(returnType));
256811 :
256812 :
256813 40 : SgModifierType* constType = SageBuilder::buildConstType(returnType);
256814 40 : ROSE_ASSERT (constType);
256815 40 : SgReferenceType * constRefType = SageBuilder::buildReferenceType(constType);
256816 40 : return constRefType;
256817 : #endif
256818 : }
256819 :
256820 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
256821 : // so that we could avoid them setting the isModified flag which is a problem in the
256822 : // name qualification support for C++ (interfering with the token-based unparsing).
256823 : int
256824 0 : SgTypeIdOp::get_name_qualification_length () const
256825 : {
256826 0 : ROSE_ASSERT (this != NULL);
256827 0 : return p_name_qualification_length;
256828 : }
256829 :
256830 : void
256831 11 : SgTypeIdOp::set_name_qualification_length ( int name_qualification_length )
256832 : {
256833 11 : ROSE_ASSERT (this != NULL);
256834 : // This can't be called by the name qualification API (see test2015_26.C).
256835 : // set_isModified(true);
256836 :
256837 11 : p_name_qualification_length = name_qualification_length;
256838 11 : }
256839 :
256840 : bool
256841 0 : SgTypeIdOp::get_type_elaboration_required () const
256842 : {
256843 0 : ROSE_ASSERT (this != NULL);
256844 0 : return p_type_elaboration_required;
256845 : }
256846 :
256847 : void
256848 11 : SgTypeIdOp::set_type_elaboration_required ( bool type_elaboration_required )
256849 : {
256850 11 : ROSE_ASSERT (this != NULL);
256851 : // This can't be called by the name qualification API (see test2015_26.C).
256852 : // set_isModified(true);
256853 :
256854 11 : p_type_elaboration_required = type_elaboration_required;
256855 11 : }
256856 :
256857 : bool
256858 0 : SgTypeIdOp::get_global_qualification_required () const
256859 : {
256860 0 : ROSE_ASSERT (this != NULL);
256861 0 : return p_global_qualification_required;
256862 : }
256863 :
256864 : void
256865 11 : SgTypeIdOp::set_global_qualification_required ( bool global_qualification_required )
256866 : {
256867 11 : ROSE_ASSERT (this != NULL);
256868 :
256869 : // This can't be called by the name qualification API (see test2015_26.C).
256870 : // set_isModified(true);
256871 :
256872 11 : p_global_qualification_required = global_qualification_required;
256873 11 : }
256874 :
256875 : // DQ (4/15/2019): These six access functions should not be generated by ROSETTA
256876 : // so that we could avoid them setting the isModified flag which is a problem in the
256877 : // name qualification support for C++ (interfering with the token-based unparsing).
256878 : int
256879 0 : SgTypeIdOp::get_name_qualification_for_pointer_to_member_class_length () const
256880 : {
256881 0 : ROSE_ASSERT (this != NULL);
256882 0 : return p_name_qualification_for_pointer_to_member_class_length;
256883 : }
256884 :
256885 : void
256886 0 : SgTypeIdOp::set_name_qualification_for_pointer_to_member_class_length ( int name_qualification_length )
256887 : {
256888 0 : ROSE_ASSERT (this != NULL);
256889 : // This can't be called by the name qualification API (see test2015_26.C).
256890 : // set_isModified(true);
256891 :
256892 0 : p_name_qualification_for_pointer_to_member_class_length = name_qualification_length;
256893 0 : }
256894 :
256895 : bool
256896 0 : SgTypeIdOp::get_type_elaboration_for_pointer_to_member_class_required () const
256897 : {
256898 0 : ROSE_ASSERT (this != NULL);
256899 0 : return p_type_elaboration_for_pointer_to_member_class_required;
256900 : }
256901 :
256902 : void
256903 0 : SgTypeIdOp::set_type_elaboration_for_pointer_to_member_class_required ( bool type_elaboration_required )
256904 : {
256905 0 : ROSE_ASSERT (this != NULL);
256906 : // This can't be called by the name qualification API (see test2015_26.C).
256907 : // set_isModified(true);
256908 :
256909 0 : p_type_elaboration_for_pointer_to_member_class_required = type_elaboration_required;
256910 0 : }
256911 :
256912 : bool
256913 0 : SgTypeIdOp::get_global_qualification_for_pointer_to_member_class_required () const
256914 : {
256915 0 : ROSE_ASSERT (this != NULL);
256916 0 : return p_global_qualification_for_pointer_to_member_class_required;
256917 : }
256918 :
256919 : void
256920 0 : SgTypeIdOp::set_global_qualification_for_pointer_to_member_class_required ( bool global_qualification_required )
256921 : {
256922 0 : ROSE_ASSERT (this != NULL);
256923 :
256924 : // This can't be called by the name qualification API (see test2015_26.C).
256925 : // set_isModified(true);
256926 :
256927 0 : p_global_qualification_for_pointer_to_member_class_required = global_qualification_required;
256928 0 : }
256929 :
256930 :
256931 :
256932 : // End of memberFunctionString
256933 : // Start of memberFunctionString
256934 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
256935 :
256936 : // *** COMMON CODE SECTION BEGINS HERE ***
256937 :
256938 : #if 0
256939 : int
256940 : SgTypeIdOp::getVariant() const
256941 : {
256942 : // This function is used in ROSE while "variant()" is used in SAGE
256943 : assert(this != NULL);
256944 : return variant();
256945 : }
256946 : #endif
256947 :
256948 : // This function is used in ROSE in treeTraversal code
256949 : // eventually replaces getVariant() and variant()
256950 : // though after variant() has been removed for a while we will
256951 : // want to change the name of variantT() back to variant()
256952 : // (since the "T" was ment to stand for temporary).
256953 : // When this happens the variantT() will be depricated.
256954 : VariantT
256955 3874 : SgTypeIdOp::variantT() const
256956 : {
256957 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
256958 3874 : ROSE_ASSERT(this != NULL);
256959 3874 : return V_SgTypeIdOp;
256960 : }
256961 :
256962 : #if 0
256963 : int
256964 : SgTypeIdOp::variant() const
256965 : {
256966 : // This function is used in SAGE
256967 : ROSE_ASSERT(this != NULL);
256968 : return TYPEID_OP;
256969 : }
256970 : #endif
256971 :
256972 : ROSE_DLL_API const char*
256973 0 : SgTypeIdOp::sage_class_name() const
256974 : {
256975 0 : ROSE_ASSERT(this != NULL);
256976 0 : return "SgTypeIdOp";
256977 : }
256978 :
256979 : std::string
256980 8 : SgTypeIdOp::class_name() const
256981 : {
256982 8 : ROSE_ASSERT(this != NULL);
256983 8 : return "SgTypeIdOp";
256984 : }
256985 :
256986 : // DQ (11/26/2005): Support for visitor pattern mechanims
256987 : // (inferior to ROSE traversal mechanism, experimental).
256988 : void
256989 137 : SgTypeIdOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
256990 : {
256991 137 : ROSE_ASSERT(this != NULL);
256992 137 : visitor.visit(this);
256993 137 : }
256994 :
256995 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
256996 0 : void SgTypeIdOp::accept (ROSE_VisitorPattern & visitor) {
256997 0 : ROSE_ASSERT(this != NULL);
256998 0 : visitor.visit(this);
256999 0 : }
257000 :
257001 : SgTypeIdOp*
257002 0 : SgTypeIdOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
257003 : {
257004 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
257005 : // This function is currently only supported for the AST used the represent Binary executables.
257006 : if (0 /* isSgAsmNode(this) != NULL */)
257007 : {
257008 : // Support for regex specification.
257009 : std::string prefixCode = "REGEX:";
257010 : addNewAttribute(prefixCode + s,a);
257011 : }
257012 : #endif
257013 :
257014 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
257015 0 : return this;
257016 : }
257017 :
257018 : // *** COMMON CODE SECTION ENDS HERE ***
257019 :
257020 :
257021 : // End of memberFunctionString
257022 : // Start of memberFunctionString
257023 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
257024 :
257025 :
257026 : #if 0
257027 : //! Error checking support
257028 : /*! Verifies the following:
257029 : - working getVariant() member function
257030 : - calls base class's error() member function
257031 : Every class has one of these functions.
257032 : */
257033 : bool
257034 : SgTypeIdOp::error()
257035 : {
257036 : // Put error checking here
257037 :
257038 : ROSE_ASSERT (this != NULL);
257039 : if (getVariant() != TYPEID_OP)
257040 : {
257041 : printf ("Error in SgTypeIdOp::error(): SgTypeIdOp object has a %s variant \n",
257042 : Cxx_GrammarTerminalNames[getVariant()].name);
257043 : // printf ("Error in SgTypeIdOp::error() \n");
257044 : ROSE_ABORT();
257045 : }
257046 :
257047 : ROSE_ASSERT (getVariant() == TYPEID_OP);
257048 : return SgExpression::error();
257049 : }
257050 : #endif
257051 :
257052 :
257053 :
257054 : // End of memberFunctionString
257055 :
257056 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
257057 :
257058 2834280 : SgTypeIdOp* isSgTypeIdOp ( SgNode* inputDerivedClassPointer )
257059 : {
257060 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
257061 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
257062 : // So to fix this we return NULL directly when the input is NULL and avoid the
257063 : // dynamic_cast in this case. This is likely a performance improvement as well.
257064 : // return dynamic_cast<SgTypeIdOp*>(inputDerivedClassPointer);
257065 : // Milind Chabbi (8/28/2013): isSgTypeIdOp uses table-driven castability instead of c++ default dynamic_cast
257066 : // this improves the running time performance by 10-20%.
257067 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeIdOp*>(inputDerivedClassPointer);
257068 2834280 : return IS_SgTypeIdOp_FAST_MACRO(inputDerivedClassPointer);
257069 : }
257070 :
257071 : // DQ (11/8/2003): Added version of functions taking const pointer
257072 0 : const SgTypeIdOp* isSgTypeIdOp ( const SgNode* inputDerivedClassPointer )
257073 : {
257074 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
257075 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
257076 : // So to fix this we return NULL directly when the input is NULL and avoid the
257077 : // dynamic_cast in this case. This is likely a performance improvement as well.
257078 : // return dynamic_cast<const SgTypeIdOp*>(inputDerivedClassPointer);
257079 : // Milind Chabbi (8/28/2013): isSgTypeIdOp uses table-driven castability instead of c++ default dynamic_cast
257080 : // this improves the running time performance by 10-20%.
257081 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeIdOp*>(inputDerivedClassPointer);
257082 0 : return IS_SgTypeIdOp_FAST_MACRO(inputDerivedClassPointer);
257083 : }
257084 :
257085 :
257086 :
257087 : /* #line 257088 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257088 :
257089 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
257090 :
257091 : /**
257092 : \brief Generated destructor
257093 :
257094 : This destructor is automatically generated (by ROSETTA). This destructor
257095 : only frees memory of data members associated with the parts of the current IR node which
257096 : are NOT traversed. Those data members that are part of a traversal can be freed using
257097 : a traversal (calling this destructor on all children in a post-order traversal). Such
257098 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
257099 :
257100 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
257101 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
257102 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
257103 :
257104 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
257105 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
257106 : pointers are not yet implemented to call delete on eash pointer in the container.
257107 : (This could be done by derivation from the STL containers to define containers that
257108 : automatically deleted their members.)
257109 :
257110 : */
257111 4 : SgTypeIdOp::~SgTypeIdOp () {
257112 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
257113 :
257114 :
257115 : // case: not a listType for operand_expr
257116 2 : p_operand_expr = NULL; // non list case
257117 : // case: not a listType for operand_type
257118 2 : p_operand_type = NULL; // non list case
257119 : // case: not a listType for name_qualification_length
257120 2 : p_name_qualification_length = 0; // non list case
257121 : // case: not a listType for type_elaboration_required
257122 2 : p_type_elaboration_required = false; // non list case
257123 : // case: not a listType for global_qualification_required
257124 2 : p_global_qualification_required = false; // non list case
257125 : // case: not a listType for name_qualification_for_pointer_to_member_class_length
257126 2 : p_name_qualification_for_pointer_to_member_class_length = 0; // non list case
257127 : // case: not a listType for type_elaboration_for_pointer_to_member_class_required
257128 2 : p_type_elaboration_for_pointer_to_member_class_required = false; // non list case
257129 : // case: not a listType for global_qualification_for_pointer_to_member_class_required
257130 2 : p_global_qualification_for_pointer_to_member_class_required = false; // non list case
257131 :
257132 : }
257133 :
257134 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
257135 4 : }
257136 :
257137 :
257138 : /* #line 257139 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257139 :
257140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
257141 :
257142 : // Generated constructor
257143 0 : SgTypeIdOp::SgTypeIdOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type )
257144 0 : : SgExpression(startOfConstruct)
257145 : {
257146 : #ifdef DEBUG
257147 : // printf ("In SgTypeIdOp::SgTypeIdOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type) sage_class_name() = %s \n",sage_class_name());
257148 : #endif
257149 : #if 0
257150 : // debugging information!
257151 : printf ("In SgTypeIdOp::SgTypeIdOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type): this = %p = %s \n",this,this->class_name().c_str());
257152 : #endif
257153 :
257154 0 : p_operand_expr = operand_expr;
257155 0 : p_operand_type = operand_type;
257156 0 : p_name_qualification_length = 0;
257157 0 : p_type_elaboration_required = false;
257158 0 : p_global_qualification_required = false;
257159 0 : p_name_qualification_for_pointer_to_member_class_length = 0;
257160 0 : p_type_elaboration_for_pointer_to_member_class_required = false;
257161 0 : p_global_qualification_for_pointer_to_member_class_required = false;
257162 :
257163 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
257164 :
257165 : #if 0
257166 : // DQ (7/30/2014): Call a virtual function.
257167 : std::string s = this->class_name();
257168 : #endif
257169 :
257170 : // Test the variant virtual function
257171 : // assert(TYPEID_OP == variant());
257172 0 : assert(TYPEID_OP == this->variant());
257173 0 : ROSE_ASSERT(TYPEID_OP == (int)(this->variantT()));
257174 0 : post_construction_initialization();
257175 :
257176 : // Test the isSgTypeIdOp() function since it has been problematic
257177 0 : assert(isSgTypeIdOp(this) != NULL);
257178 0 : }
257179 :
257180 : // Generated constructor (all data members)
257181 :
257182 : /* #line 257183 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257183 :
257184 :
257185 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
257186 :
257187 :
257188 : // ********************************************************
257189 : // member functions common across all array grammar objects
257190 : // ********************************************************
257191 :
257192 :
257193 :
257194 : /* #line 257195 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257195 :
257196 :
257197 :
257198 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
257199 :
257200 : // ********************************************************
257201 : // member functions specific to each node in the grammar
257202 : // ********************************************************
257203 :
257204 :
257205 : /* #line 257206 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257206 :
257207 : // Start of memberFunctionString
257208 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257209 :
257210 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257211 :
257212 : SgExpression*
257213 282 : SgConditionalExp::get_conditional_exp () const
257214 : {
257215 282 : ROSE_ASSERT (this != NULL);
257216 :
257217 : #if 0
257218 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257219 : // used to trigger marking transformations for the token-based unparsing.
257220 : printf ("SgConditionalExp::get_conditional_exp = %p = %s \n",this,this->class_name().c_str());
257221 : #endif
257222 :
257223 282 : return p_conditional_exp;
257224 : }
257225 :
257226 : void
257227 6 : SgConditionalExp::set_conditional_exp ( SgExpression* conditional_exp )
257228 : {
257229 6 : ROSE_ASSERT (this != NULL);
257230 :
257231 : #if 0
257232 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257233 : // used to trigger marking transformations for the token-based unparsing.
257234 : printf ("SgConditionalExp::set_conditional_exp = %p = %s \n",this,this->class_name().c_str());
257235 : #endif
257236 :
257237 6 : set_isModified(true);
257238 :
257239 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257240 : if (p_conditional_exp != NULL && conditional_exp != NULL && p_conditional_exp != conditional_exp)
257241 : {
257242 : printf ("Warning: conditional_exp = %p overwriting valid pointer p_conditional_exp = %p \n",conditional_exp,p_conditional_exp);
257243 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257244 : printf ("Error fails assertion (p_conditional_exp != NULL && conditional_exp != NULL && p_conditional_exp != conditional_exp) is false\n");
257245 : ROSE_ASSERT(false);
257246 : #endif
257247 : }
257248 : #endif
257249 6 : p_conditional_exp = conditional_exp;
257250 6 : }
257251 :
257252 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257253 :
257254 :
257255 : // End of memberFunctionString
257256 : // Start of memberFunctionString
257257 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257258 :
257259 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257260 :
257261 : SgExpression*
257262 282 : SgConditionalExp::get_true_exp () const
257263 : {
257264 282 : ROSE_ASSERT (this != NULL);
257265 :
257266 : #if 0
257267 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257268 : // used to trigger marking transformations for the token-based unparsing.
257269 : printf ("SgConditionalExp::get_true_exp = %p = %s \n",this,this->class_name().c_str());
257270 : #endif
257271 :
257272 282 : return p_true_exp;
257273 : }
257274 :
257275 : void
257276 4 : SgConditionalExp::set_true_exp ( SgExpression* true_exp )
257277 : {
257278 4 : ROSE_ASSERT (this != NULL);
257279 :
257280 : #if 0
257281 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257282 : // used to trigger marking transformations for the token-based unparsing.
257283 : printf ("SgConditionalExp::set_true_exp = %p = %s \n",this,this->class_name().c_str());
257284 : #endif
257285 :
257286 4 : set_isModified(true);
257287 :
257288 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257289 : if (p_true_exp != NULL && true_exp != NULL && p_true_exp != true_exp)
257290 : {
257291 : printf ("Warning: true_exp = %p overwriting valid pointer p_true_exp = %p \n",true_exp,p_true_exp);
257292 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257293 : printf ("Error fails assertion (p_true_exp != NULL && true_exp != NULL && p_true_exp != true_exp) is false\n");
257294 : ROSE_ASSERT(false);
257295 : #endif
257296 : }
257297 : #endif
257298 4 : p_true_exp = true_exp;
257299 4 : }
257300 :
257301 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257302 :
257303 :
257304 : // End of memberFunctionString
257305 : // Start of memberFunctionString
257306 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257307 :
257308 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257309 :
257310 : SgExpression*
257311 282 : SgConditionalExp::get_false_exp () const
257312 : {
257313 282 : ROSE_ASSERT (this != NULL);
257314 :
257315 : #if 0
257316 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257317 : // used to trigger marking transformations for the token-based unparsing.
257318 : printf ("SgConditionalExp::get_false_exp = %p = %s \n",this,this->class_name().c_str());
257319 : #endif
257320 :
257321 282 : return p_false_exp;
257322 : }
257323 :
257324 : void
257325 6 : SgConditionalExp::set_false_exp ( SgExpression* false_exp )
257326 : {
257327 6 : ROSE_ASSERT (this != NULL);
257328 :
257329 : #if 0
257330 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257331 : // used to trigger marking transformations for the token-based unparsing.
257332 : printf ("SgConditionalExp::set_false_exp = %p = %s \n",this,this->class_name().c_str());
257333 : #endif
257334 :
257335 6 : set_isModified(true);
257336 :
257337 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257338 : if (p_false_exp != NULL && false_exp != NULL && p_false_exp != false_exp)
257339 : {
257340 : printf ("Warning: false_exp = %p overwriting valid pointer p_false_exp = %p \n",false_exp,p_false_exp);
257341 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257342 : printf ("Error fails assertion (p_false_exp != NULL && false_exp != NULL && p_false_exp != false_exp) is false\n");
257343 : ROSE_ASSERT(false);
257344 : #endif
257345 : }
257346 : #endif
257347 6 : p_false_exp = false_exp;
257348 6 : }
257349 :
257350 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257351 :
257352 :
257353 : // End of memberFunctionString
257354 : // Start of memberFunctionString
257355 :
257356 :
257357 : // End of memberFunctionString
257358 : // Start of memberFunctionString
257359 : /* #line 6252 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
257360 :
257361 : void
257362 1815 : SgConditionalExp::post_construction_initialization()
257363 : {
257364 : // #ifndef REMOVE_SET_PARENT_FUNCTION
257365 1815 : if (p_conditional_exp != NULL)
257366 1815 : p_conditional_exp->set_parent(this);
257367 1815 : if (p_true_exp != NULL)
257368 1815 : p_true_exp->set_parent(this);
257369 1815 : if (p_false_exp != NULL)
257370 1815 : p_false_exp->set_parent(this);
257371 : // #endif
257372 :
257373 : // DQ (1/14/2006): set_type is removed
257374 : // set_type();
257375 1815 : }
257376 :
257377 : SgType*
257378 839 : SgConditionalExp::get_type() const
257379 : {
257380 : // In this function we want to return the type of the true of false option but it only makes sense for them to be the same type.
257381 :
257382 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
257383 : // printf ("SgConditionalExp::get_type(): p_expression_type has been removed, we have to compute the appropriate type \n");
257384 :
257385 : // Jeremiah (7/20/2006): Despite the comments, SOURCE_CONDITIONAL_EXPRESSION refers to a p_expression_type member,
257386 : // but then ignores it. I think you may want to store the type explicitly for this operator, as computing it is
257387 : // difficult (requires handling user-defined conversions and such). The return type can be either the true or false
257388 : // types, and they can be different.
257389 :
257390 839 : ROSE_ASSERT(p_true_exp != NULL);
257391 839 : ROSE_ASSERT(p_false_exp != NULL);
257392 :
257393 : #if 0
257394 : printf ("In SgConditionalExp::get_type() \n");
257395 : #endif
257396 :
257397 839 : SgType* trueType = p_true_exp->get_type();
257398 839 : ROSE_ASSERT(trueType != NULL);
257399 :
257400 839 : SgType* falseType = p_false_exp->get_type();
257401 839 : ROSE_ASSERT(falseType != NULL);
257402 :
257403 : #if PRINT_DEVELOPER_WARNINGS
257404 : string expression_type_name = "NULL";
257405 : if (p_expression_type != NULL)
257406 : expression_type_name = p_expression_type->class_name();
257407 :
257408 : // ROSE_ASSERT(trueType == falseType);
257409 : if (trueType != falseType)
257410 : {
257411 : printf ("Warning: In SgConditionalExp::get_type(): trueType = %s != falseType = %s (p_expression_type = %s) \n",
257412 : trueType->class_name().c_str(),falseType->class_name().c_str(),expression_type_name.c_str());
257413 : // get_file_info()->display("Warning: In SgConditionalExp::get_type(): trueType != falseType");
257414 : }
257415 : #endif
257416 :
257417 : // This was the previous choice for how p_expression_type was set,
257418 : // so to be consistant we will select the same branch.
257419 839 : SgType* returnType = trueType;
257420 :
257421 : // PC (10/12/2009): If returnType is in fact an SgArrayType it will undergo array-to-pointer conversion
257422 839 : SgType *retElemType = SageInterface::getElementType(returnType);
257423 839 : if (retElemType != NULL)
257424 : {
257425 43 : returnType = SgPointerType::createType(retElemType);
257426 : }
257427 :
257428 839 : ROSE_ASSERT(returnType != NULL);
257429 839 : return returnType;
257430 : }
257431 :
257432 : SgExpression*
257433 0 : SgConditionalExp::get_next(int& n) const
257434 : {
257435 0 : SgExpression *tmp = NULL;
257436 0 : switch (n)
257437 : {
257438 0 : case 0: tmp = get_conditional_exp(); n++; break;
257439 0 : case 1: tmp = get_true_exp(); n++; break;
257440 0 : case 2: tmp = get_false_exp(); n++; break;
257441 : }
257442 :
257443 0 : return tmp;
257444 : }
257445 :
257446 : int
257447 0 : SgConditionalExp::replace_expression(SgExpression *o, SgExpression *n)
257448 : {
257449 : // DQ (12/17/2006): This function should have the semantics that it will represent a
257450 : // structural change to the AST, thus it is free to set the parent of the new expression.
257451 :
257452 0 : ROSE_ASSERT(o != NULL);
257453 0 : ROSE_ASSERT(n != NULL);
257454 :
257455 0 : if (get_conditional_exp() == o)
257456 : {
257457 0 : set_conditional_exp(n);
257458 0 : n->set_parent(this);
257459 0 : return 1;
257460 : }
257461 : else
257462 : {
257463 0 : if (get_true_exp() == o)
257464 : {
257465 0 : set_true_exp(n);
257466 0 : n->set_parent(this);
257467 0 : return 1;
257468 : }
257469 : else
257470 : {
257471 0 : if (get_false_exp() == o)
257472 : {
257473 0 : set_false_exp(n);
257474 0 : n->set_parent(this);
257475 0 : return 1;
257476 : }
257477 : else
257478 : {
257479 : return 0;
257480 : }
257481 : }
257482 : }
257483 : }
257484 :
257485 :
257486 :
257487 : // End of memberFunctionString
257488 : // Start of memberFunctionString
257489 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
257490 :
257491 : // *** COMMON CODE SECTION BEGINS HERE ***
257492 :
257493 : #if 0
257494 : int
257495 : SgConditionalExp::getVariant() const
257496 : {
257497 : // This function is used in ROSE while "variant()" is used in SAGE
257498 : assert(this != NULL);
257499 : return variant();
257500 : }
257501 : #endif
257502 :
257503 : // This function is used in ROSE in treeTraversal code
257504 : // eventually replaces getVariant() and variant()
257505 : // though after variant() has been removed for a while we will
257506 : // want to change the name of variantT() back to variant()
257507 : // (since the "T" was ment to stand for temporary).
257508 : // When this happens the variantT() will be depricated.
257509 : VariantT
257510 280328 : SgConditionalExp::variantT() const
257511 : {
257512 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
257513 280328 : ROSE_ASSERT(this != NULL);
257514 280328 : return V_SgConditionalExp;
257515 : }
257516 :
257517 : #if 0
257518 : int
257519 : SgConditionalExp::variant() const
257520 : {
257521 : // This function is used in SAGE
257522 : ROSE_ASSERT(this != NULL);
257523 : return EXPR_CONDITIONAL;
257524 : }
257525 : #endif
257526 :
257527 : ROSE_DLL_API const char*
257528 10 : SgConditionalExp::sage_class_name() const
257529 : {
257530 10 : ROSE_ASSERT(this != NULL);
257531 10 : return "SgConditionalExp";
257532 : }
257533 :
257534 : std::string
257535 619 : SgConditionalExp::class_name() const
257536 : {
257537 619 : ROSE_ASSERT(this != NULL);
257538 619 : return "SgConditionalExp";
257539 : }
257540 :
257541 : // DQ (11/26/2005): Support for visitor pattern mechanims
257542 : // (inferior to ROSE traversal mechanism, experimental).
257543 : void
257544 9971 : SgConditionalExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
257545 : {
257546 9971 : ROSE_ASSERT(this != NULL);
257547 9971 : visitor.visit(this);
257548 9971 : }
257549 :
257550 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
257551 0 : void SgConditionalExp::accept (ROSE_VisitorPattern & visitor) {
257552 0 : ROSE_ASSERT(this != NULL);
257553 0 : visitor.visit(this);
257554 0 : }
257555 :
257556 : SgConditionalExp*
257557 0 : SgConditionalExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
257558 : {
257559 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
257560 : // This function is currently only supported for the AST used the represent Binary executables.
257561 : if (0 /* isSgAsmNode(this) != NULL */)
257562 : {
257563 : // Support for regex specification.
257564 : std::string prefixCode = "REGEX:";
257565 : addNewAttribute(prefixCode + s,a);
257566 : }
257567 : #endif
257568 :
257569 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
257570 0 : return this;
257571 : }
257572 :
257573 : // *** COMMON CODE SECTION ENDS HERE ***
257574 :
257575 :
257576 : // End of memberFunctionString
257577 : // Start of memberFunctionString
257578 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
257579 :
257580 :
257581 : #if 0
257582 : //! Error checking support
257583 : /*! Verifies the following:
257584 : - working getVariant() member function
257585 : - calls base class's error() member function
257586 : Every class has one of these functions.
257587 : */
257588 : bool
257589 : SgConditionalExp::error()
257590 : {
257591 : // Put error checking here
257592 :
257593 : ROSE_ASSERT (this != NULL);
257594 : if (getVariant() != EXPR_CONDITIONAL)
257595 : {
257596 : printf ("Error in SgConditionalExp::error(): SgConditionalExp object has a %s variant \n",
257597 : Cxx_GrammarTerminalNames[getVariant()].name);
257598 : // printf ("Error in SgConditionalExp::error() \n");
257599 : ROSE_ABORT();
257600 : }
257601 :
257602 : ROSE_ASSERT (getVariant() == EXPR_CONDITIONAL);
257603 : return SgExpression::error();
257604 : }
257605 : #endif
257606 :
257607 :
257608 :
257609 : // End of memberFunctionString
257610 :
257611 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
257612 :
257613 3009 : SgConditionalExp* isSgConditionalExp ( SgNode* inputDerivedClassPointer )
257614 : {
257615 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
257616 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
257617 : // So to fix this we return NULL directly when the input is NULL and avoid the
257618 : // dynamic_cast in this case. This is likely a performance improvement as well.
257619 : // return dynamic_cast<SgConditionalExp*>(inputDerivedClassPointer);
257620 : // Milind Chabbi (8/28/2013): isSgConditionalExp uses table-driven castability instead of c++ default dynamic_cast
257621 : // this improves the running time performance by 10-20%.
257622 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgConditionalExp*>(inputDerivedClassPointer);
257623 3009 : return IS_SgConditionalExp_FAST_MACRO(inputDerivedClassPointer);
257624 : }
257625 :
257626 : // DQ (11/8/2003): Added version of functions taking const pointer
257627 153 : const SgConditionalExp* isSgConditionalExp ( const SgNode* inputDerivedClassPointer )
257628 : {
257629 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
257630 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
257631 : // So to fix this we return NULL directly when the input is NULL and avoid the
257632 : // dynamic_cast in this case. This is likely a performance improvement as well.
257633 : // return dynamic_cast<const SgConditionalExp*>(inputDerivedClassPointer);
257634 : // Milind Chabbi (8/28/2013): isSgConditionalExp uses table-driven castability instead of c++ default dynamic_cast
257635 : // this improves the running time performance by 10-20%.
257636 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgConditionalExp*>(inputDerivedClassPointer);
257637 153 : return IS_SgConditionalExp_FAST_MACRO(inputDerivedClassPointer);
257638 : }
257639 :
257640 :
257641 :
257642 : /* #line 257643 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257643 :
257644 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
257645 :
257646 : /**
257647 : \brief Generated destructor
257648 :
257649 : This destructor is automatically generated (by ROSETTA). This destructor
257650 : only frees memory of data members associated with the parts of the current IR node which
257651 : are NOT traversed. Those data members that are part of a traversal can be freed using
257652 : a traversal (calling this destructor on all children in a post-order traversal). Such
257653 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
257654 :
257655 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
257656 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
257657 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
257658 :
257659 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
257660 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
257661 : pointers are not yet implemented to call delete on eash pointer in the container.
257662 : (This could be done by derivation from the STL containers to define containers that
257663 : automatically deleted their members.)
257664 :
257665 : */
257666 2432 : SgConditionalExp::~SgConditionalExp () {
257667 1216 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
257668 :
257669 :
257670 : // case: not a listType for conditional_exp
257671 1216 : p_conditional_exp = NULL; // non list case
257672 : // case: not a listType for true_exp
257673 1216 : p_true_exp = NULL; // non list case
257674 : // case: not a listType for false_exp
257675 1216 : p_false_exp = NULL; // non list case
257676 : // case: not a listType for expression_type
257677 1216 : p_expression_type = NULL; // non list case
257678 :
257679 : }
257680 :
257681 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
257682 2432 : }
257683 :
257684 :
257685 : /* #line 257686 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257686 :
257687 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
257688 :
257689 : // Generated constructor
257690 0 : SgConditionalExp::SgConditionalExp ( Sg_File_Info* startOfConstruct, SgExpression* conditional_exp, SgExpression* true_exp, SgExpression* false_exp, SgType* expression_type )
257691 0 : : SgExpression(startOfConstruct)
257692 : {
257693 : #ifdef DEBUG
257694 : // printf ("In SgConditionalExp::SgConditionalExp (Sg_File_Info* startOfConstruct, SgExpression* conditional_exp, SgExpression* true_exp, SgExpression* false_exp, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
257695 : #endif
257696 : #if 0
257697 : // debugging information!
257698 : printf ("In SgConditionalExp::SgConditionalExp (Sg_File_Info* startOfConstruct, SgExpression* conditional_exp, SgExpression* true_exp, SgExpression* false_exp, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
257699 : #endif
257700 :
257701 0 : p_conditional_exp = conditional_exp;
257702 0 : p_true_exp = true_exp;
257703 0 : p_false_exp = false_exp;
257704 0 : p_expression_type = expression_type;
257705 :
257706 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
257707 :
257708 : #if 0
257709 : // DQ (7/30/2014): Call a virtual function.
257710 : std::string s = this->class_name();
257711 : #endif
257712 :
257713 : // Test the variant virtual function
257714 : // assert(EXPR_CONDITIONAL == variant());
257715 0 : assert(EXPR_CONDITIONAL == this->variant());
257716 0 : ROSE_ASSERT(EXPR_CONDITIONAL == (int)(this->variantT()));
257717 0 : post_construction_initialization();
257718 :
257719 : // Test the isSgConditionalExp() function since it has been problematic
257720 0 : assert(isSgConditionalExp(this) != NULL);
257721 0 : }
257722 :
257723 : // Generated constructor (all data members)
257724 :
257725 : /* #line 257726 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257726 :
257727 :
257728 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
257729 :
257730 :
257731 : // ********************************************************
257732 : // member functions common across all array grammar objects
257733 : // ********************************************************
257734 :
257735 :
257736 :
257737 : /* #line 257738 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257738 :
257739 :
257740 :
257741 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
257742 :
257743 : // ********************************************************
257744 : // member functions specific to each node in the grammar
257745 : // ********************************************************
257746 :
257747 :
257748 : /* #line 257749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
257749 :
257750 : // Start of memberFunctionString
257751 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257752 :
257753 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257754 :
257755 : SgType*
257756 149 : SgNewExp::get_specified_type () const
257757 : {
257758 149 : ROSE_ASSERT (this != NULL);
257759 :
257760 : #if 0
257761 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257762 : // used to trigger marking transformations for the token-based unparsing.
257763 : printf ("SgNewExp::get_specified_type = %p = %s \n",this,this->class_name().c_str());
257764 : #endif
257765 :
257766 149 : return p_specified_type;
257767 : }
257768 :
257769 : void
257770 0 : SgNewExp::set_specified_type ( SgType* specified_type )
257771 : {
257772 0 : ROSE_ASSERT (this != NULL);
257773 :
257774 : #if 0
257775 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257776 : // used to trigger marking transformations for the token-based unparsing.
257777 : printf ("SgNewExp::set_specified_type = %p = %s \n",this,this->class_name().c_str());
257778 : #endif
257779 :
257780 0 : set_isModified(true);
257781 :
257782 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257783 : if (p_specified_type != NULL && specified_type != NULL && p_specified_type != specified_type)
257784 : {
257785 : printf ("Warning: specified_type = %p overwriting valid pointer p_specified_type = %p \n",specified_type,p_specified_type);
257786 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257787 : printf ("Error fails assertion (p_specified_type != NULL && specified_type != NULL && p_specified_type != specified_type) is false\n");
257788 : ROSE_ASSERT(false);
257789 : #endif
257790 : }
257791 : #endif
257792 0 : p_specified_type = specified_type;
257793 0 : }
257794 :
257795 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257796 :
257797 :
257798 : // End of memberFunctionString
257799 : // Start of memberFunctionString
257800 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257801 :
257802 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257803 :
257804 : SgExprListExp*
257805 3 : SgNewExp::get_placement_args () const
257806 : {
257807 3 : ROSE_ASSERT (this != NULL);
257808 :
257809 : #if 0
257810 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257811 : // used to trigger marking transformations for the token-based unparsing.
257812 : printf ("SgNewExp::get_placement_args = %p = %s \n",this,this->class_name().c_str());
257813 : #endif
257814 :
257815 3 : return p_placement_args;
257816 : }
257817 :
257818 : void
257819 0 : SgNewExp::set_placement_args ( SgExprListExp* placement_args )
257820 : {
257821 0 : ROSE_ASSERT (this != NULL);
257822 :
257823 : #if 0
257824 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257825 : // used to trigger marking transformations for the token-based unparsing.
257826 : printf ("SgNewExp::set_placement_args = %p = %s \n",this,this->class_name().c_str());
257827 : #endif
257828 :
257829 0 : set_isModified(true);
257830 :
257831 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257832 : if (p_placement_args != NULL && placement_args != NULL && p_placement_args != placement_args)
257833 : {
257834 : printf ("Warning: placement_args = %p overwriting valid pointer p_placement_args = %p \n",placement_args,p_placement_args);
257835 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257836 : printf ("Error fails assertion (p_placement_args != NULL && placement_args != NULL && p_placement_args != placement_args) is false\n");
257837 : ROSE_ASSERT(false);
257838 : #endif
257839 : }
257840 : #endif
257841 0 : p_placement_args = placement_args;
257842 0 : }
257843 :
257844 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257845 :
257846 :
257847 : // End of memberFunctionString
257848 : // Start of memberFunctionString
257849 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257850 :
257851 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257852 :
257853 : SgConstructorInitializer*
257854 26 : SgNewExp::get_constructor_args () const
257855 : {
257856 26 : ROSE_ASSERT (this != NULL);
257857 :
257858 : #if 0
257859 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257860 : // used to trigger marking transformations for the token-based unparsing.
257861 : printf ("SgNewExp::get_constructor_args = %p = %s \n",this,this->class_name().c_str());
257862 : #endif
257863 :
257864 26 : return p_constructor_args;
257865 : }
257866 :
257867 : void
257868 0 : SgNewExp::set_constructor_args ( SgConstructorInitializer* constructor_args )
257869 : {
257870 0 : ROSE_ASSERT (this != NULL);
257871 :
257872 : #if 0
257873 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257874 : // used to trigger marking transformations for the token-based unparsing.
257875 : printf ("SgNewExp::set_constructor_args = %p = %s \n",this,this->class_name().c_str());
257876 : #endif
257877 :
257878 0 : set_isModified(true);
257879 :
257880 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257881 : if (p_constructor_args != NULL && constructor_args != NULL && p_constructor_args != constructor_args)
257882 : {
257883 : printf ("Warning: constructor_args = %p overwriting valid pointer p_constructor_args = %p \n",constructor_args,p_constructor_args);
257884 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257885 : printf ("Error fails assertion (p_constructor_args != NULL && constructor_args != NULL && p_constructor_args != constructor_args) is false\n");
257886 : ROSE_ASSERT(false);
257887 : #endif
257888 : }
257889 : #endif
257890 0 : p_constructor_args = constructor_args;
257891 0 : }
257892 :
257893 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257894 :
257895 :
257896 : // End of memberFunctionString
257897 : // Start of memberFunctionString
257898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257899 :
257900 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257901 :
257902 : SgExpression*
257903 3 : SgNewExp::get_builtin_args () const
257904 : {
257905 3 : ROSE_ASSERT (this != NULL);
257906 :
257907 : #if 0
257908 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257909 : // used to trigger marking transformations for the token-based unparsing.
257910 : printf ("SgNewExp::get_builtin_args = %p = %s \n",this,this->class_name().c_str());
257911 : #endif
257912 :
257913 3 : return p_builtin_args;
257914 : }
257915 :
257916 : void
257917 0 : SgNewExp::set_builtin_args ( SgExpression* builtin_args )
257918 : {
257919 0 : ROSE_ASSERT (this != NULL);
257920 :
257921 : #if 0
257922 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257923 : // used to trigger marking transformations for the token-based unparsing.
257924 : printf ("SgNewExp::set_builtin_args = %p = %s \n",this,this->class_name().c_str());
257925 : #endif
257926 :
257927 0 : set_isModified(true);
257928 :
257929 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
257930 : if (p_builtin_args != NULL && builtin_args != NULL && p_builtin_args != builtin_args)
257931 : {
257932 : printf ("Warning: builtin_args = %p overwriting valid pointer p_builtin_args = %p \n",builtin_args,p_builtin_args);
257933 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
257934 : printf ("Error fails assertion (p_builtin_args != NULL && builtin_args != NULL && p_builtin_args != builtin_args) is false\n");
257935 : ROSE_ASSERT(false);
257936 : #endif
257937 : }
257938 : #endif
257939 0 : p_builtin_args = builtin_args;
257940 0 : }
257941 :
257942 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257943 :
257944 :
257945 : // End of memberFunctionString
257946 : // Start of memberFunctionString
257947 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257948 :
257949 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257950 :
257951 : short
257952 3 : SgNewExp::get_need_global_specifier () const
257953 : {
257954 3 : ROSE_ASSERT (this != NULL);
257955 :
257956 : #if 0
257957 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257958 : // used to trigger marking transformations for the token-based unparsing.
257959 : printf ("SgNewExp::get_need_global_specifier = %p = %s \n",this,this->class_name().c_str());
257960 : #endif
257961 :
257962 3 : return p_need_global_specifier;
257963 : }
257964 :
257965 : void
257966 0 : SgNewExp::set_need_global_specifier ( short need_global_specifier )
257967 : {
257968 0 : ROSE_ASSERT (this != NULL);
257969 :
257970 : #if 0
257971 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257972 : // used to trigger marking transformations for the token-based unparsing.
257973 : printf ("SgNewExp::set_need_global_specifier = %p = %s \n",this,this->class_name().c_str());
257974 : #endif
257975 :
257976 0 : set_isModified(true);
257977 :
257978 0 : p_need_global_specifier = need_global_specifier;
257979 0 : }
257980 :
257981 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
257982 :
257983 :
257984 : // End of memberFunctionString
257985 : // Start of memberFunctionString
257986 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
257987 :
257988 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
257989 :
257990 : SgFunctionDeclaration*
257991 0 : SgNewExp::get_newOperatorDeclaration () const
257992 : {
257993 0 : ROSE_ASSERT (this != NULL);
257994 :
257995 : #if 0
257996 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
257997 : // used to trigger marking transformations for the token-based unparsing.
257998 : printf ("SgNewExp::get_newOperatorDeclaration = %p = %s \n",this,this->class_name().c_str());
257999 : #endif
258000 :
258001 0 : return p_newOperatorDeclaration;
258002 : }
258003 :
258004 : void
258005 0 : SgNewExp::set_newOperatorDeclaration ( SgFunctionDeclaration* newOperatorDeclaration )
258006 : {
258007 0 : ROSE_ASSERT (this != NULL);
258008 :
258009 : #if 0
258010 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258011 : // used to trigger marking transformations for the token-based unparsing.
258012 : printf ("SgNewExp::set_newOperatorDeclaration = %p = %s \n",this,this->class_name().c_str());
258013 : #endif
258014 :
258015 0 : set_isModified(true);
258016 :
258017 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
258018 : if (p_newOperatorDeclaration != NULL && newOperatorDeclaration != NULL && p_newOperatorDeclaration != newOperatorDeclaration)
258019 : {
258020 : printf ("Warning: newOperatorDeclaration = %p overwriting valid pointer p_newOperatorDeclaration = %p \n",newOperatorDeclaration,p_newOperatorDeclaration);
258021 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
258022 : printf ("Error fails assertion (p_newOperatorDeclaration != NULL && newOperatorDeclaration != NULL && p_newOperatorDeclaration != newOperatorDeclaration) is false\n");
258023 : ROSE_ASSERT(false);
258024 : #endif
258025 : }
258026 : #endif
258027 0 : p_newOperatorDeclaration = newOperatorDeclaration;
258028 0 : }
258029 :
258030 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
258031 :
258032 :
258033 : // End of memberFunctionString
258034 : // Start of memberFunctionString
258035 :
258036 :
258037 : // End of memberFunctionString
258038 : // Start of memberFunctionString
258039 : /* #line 6715 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
258040 :
258041 :
258042 : void
258043 129 : SgNewExp::post_construction_initialization()
258044 : {
258045 129 : if(p_constructor_args)
258046 : {
258047 : // #ifndef REMOVE_SET_PARENT_FUNCTION
258048 129 : p_constructor_args->set_parent(this);
258049 : // #endif
258050 129 : p_constructor_args->set_need_paren(true);
258051 : }
258052 :
258053 : // #ifndef REMOVE_SET_PARENT_FUNCTION
258054 129 : if(p_builtin_args)
258055 : {
258056 0 : p_builtin_args->set_parent(this);
258057 : }
258058 :
258059 129 : if(p_placement_args)
258060 46 : p_placement_args->set_parent(this);
258061 : // #endif
258062 129 : }
258063 :
258064 :
258065 : SgExpression*
258066 0 : SgNewExp::get_next(int& n) const
258067 : {
258068 : // SgExpression *tmp = NULL;
258069 0 : if(n==0)
258070 : {
258071 0 : n++;
258072 0 : if(get_placement_args()) return get_placement_args();
258073 : else
258074 : {
258075 0 : n++;
258076 0 : if(get_constructor_args())
258077 0 : return get_constructor_args();
258078 : else
258079 0 : return get_builtin_args();
258080 : }
258081 : }
258082 : else
258083 0 : if(n==1)
258084 : {
258085 0 : n++;
258086 0 : if(get_constructor_args())
258087 0 : return get_constructor_args();
258088 : else
258089 0 : return get_builtin_args();
258090 : }
258091 :
258092 : return NULL;
258093 : }
258094 :
258095 : int
258096 0 : SgNewExp::replace_expression(SgExpression *o, SgExpression *n)
258097 : {
258098 : // DQ (12/17/2006): This function should have the semantics that it will represent a
258099 : // structural change to the AST, thus it is free to set the parent of the new expression.
258100 :
258101 0 : ROSE_ASSERT(o != NULL);
258102 0 : ROSE_ASSERT(n != NULL);
258103 :
258104 0 : if(get_placement_args()==o)
258105 : {
258106 0 : set_placement_args(isSgExprListExp(n));
258107 0 : n->set_parent(this);
258108 0 : return 1;
258109 : }
258110 : else
258111 : {
258112 0 : if(get_constructor_args()==o)
258113 : {
258114 0 : set_constructor_args(isSgConstructorInitializer(n));
258115 0 : n->set_parent(this);
258116 0 : return 1;
258117 : }
258118 : else
258119 : {
258120 0 : if(get_builtin_args()==o)
258121 : {
258122 0 : set_builtin_args(n);
258123 0 : n->set_parent(this);
258124 0 : return 1;
258125 : }
258126 : else
258127 : {
258128 : return 0;
258129 : }
258130 : }
258131 : }
258132 : }
258133 :
258134 : SgType*
258135 228 : SgNewExp::get_type() const
258136 : {
258137 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
258138 :
258139 : // printf ("SgNewExp::get_type(): p_expression_type has been removed, we have to compute the appropriate type \n");
258140 :
258141 : // The p_constructor_args really just identifies the constructor being called,
258142 : // from which we can get the type to be returned from the new operator!
258143 : // If there is no constructor then this might be a primative type or perhaps
258144 : // a class or struct without an explicit constructor.
258145 : // ROSE_ASSERT(p_constructor_args != NULL); -- JJW hack
258146 :
258147 : #if 0
258148 : printf ("In SgNewExp::get_type() \n");
258149 : #endif
258150 :
258151 : // Since where the p_constructor_args->get_declaration() == NULL (often for primative types)
258152 : // we need the explicitly stored p_expression_type pointer anyway so we can just make it the
258153 : // return type for all cases.
258154 : // SgType* returnType = p_expression_type;
258155 : // SgType* returnType = SgPointerType::createType(p_expression_type);
258156 228 : ROSE_ASSERT(p_specified_type != NULL);
258157 228 : SgType* returnType = SgPointerType::createType(p_specified_type);
258158 :
258159 228 : ROSE_ASSERT(returnType != NULL);
258160 : // printf ("SgNewExp::get_type(): We might have to return a pointer to this type! returnType = %s \n",returnType->class_name().c_str());
258161 :
258162 228 : return returnType;
258163 : }
258164 :
258165 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
258166 : // so that we could avoid them setting the isModified flag which is a problem in the
258167 : // name qualification support for C++ (interfering with the token-based unparsing).
258168 : int
258169 0 : SgNewExp::get_name_qualification_length () const
258170 : {
258171 0 : ROSE_ASSERT (this != NULL);
258172 0 : return p_name_qualification_length;
258173 : }
258174 :
258175 : void
258176 134 : SgNewExp::set_name_qualification_length ( int name_qualification_length )
258177 : {
258178 134 : ROSE_ASSERT (this != NULL);
258179 : // This can't be called by the name qualification API (see test2015_26.C).
258180 : // set_isModified(true);
258181 :
258182 134 : p_name_qualification_length = name_qualification_length;
258183 134 : }
258184 :
258185 : bool
258186 0 : SgNewExp::get_type_elaboration_required () const
258187 : {
258188 0 : ROSE_ASSERT (this != NULL);
258189 0 : return p_type_elaboration_required;
258190 : }
258191 :
258192 : void
258193 134 : SgNewExp::set_type_elaboration_required ( bool type_elaboration_required )
258194 : {
258195 134 : ROSE_ASSERT (this != NULL);
258196 : // This can't be called by the name qualification API (see test2015_26.C).
258197 : // set_isModified(true);
258198 :
258199 134 : p_type_elaboration_required = type_elaboration_required;
258200 134 : }
258201 :
258202 : bool
258203 0 : SgNewExp::get_global_qualification_required () const
258204 : {
258205 0 : ROSE_ASSERT (this != NULL);
258206 0 : return p_global_qualification_required;
258207 : }
258208 :
258209 : void
258210 134 : SgNewExp::set_global_qualification_required ( bool global_qualification_required )
258211 : {
258212 134 : ROSE_ASSERT (this != NULL);
258213 :
258214 : // This can't be called by the name qualification API (see test2015_26.C).
258215 : // set_isModified(true);
258216 :
258217 134 : p_global_qualification_required = global_qualification_required;
258218 134 : }
258219 :
258220 :
258221 : // DQ (4/15/2019): These six access functions should not be generated by ROSETTA
258222 : // so that we could avoid them setting the isModified flag which is a problem in the
258223 : // name qualification support for C++ (interfering with the token-based unparsing).
258224 : int
258225 0 : SgNewExp::get_name_qualification_for_pointer_to_member_class_length () const
258226 : {
258227 0 : ROSE_ASSERT (this != NULL);
258228 0 : return p_name_qualification_for_pointer_to_member_class_length;
258229 : }
258230 :
258231 : void
258232 0 : SgNewExp::set_name_qualification_for_pointer_to_member_class_length ( int name_qualification_length )
258233 : {
258234 0 : ROSE_ASSERT (this != NULL);
258235 : // This can't be called by the name qualification API (see test2015_26.C).
258236 : // set_isModified(true);
258237 :
258238 0 : p_name_qualification_for_pointer_to_member_class_length = name_qualification_length;
258239 0 : }
258240 :
258241 : bool
258242 0 : SgNewExp::get_type_elaboration_for_pointer_to_member_class_required () const
258243 : {
258244 0 : ROSE_ASSERT (this != NULL);
258245 0 : return p_type_elaboration_for_pointer_to_member_class_required;
258246 : }
258247 :
258248 : void
258249 0 : SgNewExp::set_type_elaboration_for_pointer_to_member_class_required ( bool type_elaboration_required )
258250 : {
258251 0 : ROSE_ASSERT (this != NULL);
258252 : // This can't be called by the name qualification API (see test2015_26.C).
258253 : // set_isModified(true);
258254 :
258255 0 : p_type_elaboration_for_pointer_to_member_class_required = type_elaboration_required;
258256 0 : }
258257 :
258258 : bool
258259 0 : SgNewExp::get_global_qualification_for_pointer_to_member_class_required () const
258260 : {
258261 0 : ROSE_ASSERT (this != NULL);
258262 0 : return p_global_qualification_for_pointer_to_member_class_required;
258263 : }
258264 :
258265 : void
258266 0 : SgNewExp::set_global_qualification_for_pointer_to_member_class_required ( bool global_qualification_required )
258267 : {
258268 0 : ROSE_ASSERT (this != NULL);
258269 :
258270 : // This can't be called by the name qualification API (see test2015_26.C).
258271 : // set_isModified(true);
258272 :
258273 0 : p_global_qualification_for_pointer_to_member_class_required = global_qualification_required;
258274 0 : }
258275 :
258276 :
258277 :
258278 :
258279 :
258280 :
258281 : // End of memberFunctionString
258282 : // Start of memberFunctionString
258283 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
258284 :
258285 : // *** COMMON CODE SECTION BEGINS HERE ***
258286 :
258287 : #if 0
258288 : int
258289 : SgNewExp::getVariant() const
258290 : {
258291 : // This function is used in ROSE while "variant()" is used in SAGE
258292 : assert(this != NULL);
258293 : return variant();
258294 : }
258295 : #endif
258296 :
258297 : // This function is used in ROSE in treeTraversal code
258298 : // eventually replaces getVariant() and variant()
258299 : // though after variant() has been removed for a while we will
258300 : // want to change the name of variantT() back to variant()
258301 : // (since the "T" was ment to stand for temporary).
258302 : // When this happens the variantT() will be depricated.
258303 : VariantT
258304 39883 : SgNewExp::variantT() const
258305 : {
258306 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
258307 39883 : ROSE_ASSERT(this != NULL);
258308 39883 : return V_SgNewExp;
258309 : }
258310 :
258311 : #if 0
258312 : int
258313 : SgNewExp::variant() const
258314 : {
258315 : // This function is used in SAGE
258316 : ROSE_ASSERT(this != NULL);
258317 : return NEW_OP;
258318 : }
258319 : #endif
258320 :
258321 : ROSE_DLL_API const char*
258322 0 : SgNewExp::sage_class_name() const
258323 : {
258324 0 : ROSE_ASSERT(this != NULL);
258325 0 : return "SgNewExp";
258326 : }
258327 :
258328 : std::string
258329 110 : SgNewExp::class_name() const
258330 : {
258331 110 : ROSE_ASSERT(this != NULL);
258332 110 : return "SgNewExp";
258333 : }
258334 :
258335 : // DQ (11/26/2005): Support for visitor pattern mechanims
258336 : // (inferior to ROSE traversal mechanism, experimental).
258337 : void
258338 1954 : SgNewExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
258339 : {
258340 1954 : ROSE_ASSERT(this != NULL);
258341 1954 : visitor.visit(this);
258342 1954 : }
258343 :
258344 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
258345 0 : void SgNewExp::accept (ROSE_VisitorPattern & visitor) {
258346 0 : ROSE_ASSERT(this != NULL);
258347 0 : visitor.visit(this);
258348 0 : }
258349 :
258350 : SgNewExp*
258351 0 : SgNewExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
258352 : {
258353 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
258354 : // This function is currently only supported for the AST used the represent Binary executables.
258355 : if (0 /* isSgAsmNode(this) != NULL */)
258356 : {
258357 : // Support for regex specification.
258358 : std::string prefixCode = "REGEX:";
258359 : addNewAttribute(prefixCode + s,a);
258360 : }
258361 : #endif
258362 :
258363 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
258364 0 : return this;
258365 : }
258366 :
258367 : // *** COMMON CODE SECTION ENDS HERE ***
258368 :
258369 :
258370 : // End of memberFunctionString
258371 : // Start of memberFunctionString
258372 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
258373 :
258374 :
258375 : #if 0
258376 : //! Error checking support
258377 : /*! Verifies the following:
258378 : - working getVariant() member function
258379 : - calls base class's error() member function
258380 : Every class has one of these functions.
258381 : */
258382 : bool
258383 : SgNewExp::error()
258384 : {
258385 : // Put error checking here
258386 :
258387 : ROSE_ASSERT (this != NULL);
258388 : if (getVariant() != NEW_OP)
258389 : {
258390 : printf ("Error in SgNewExp::error(): SgNewExp object has a %s variant \n",
258391 : Cxx_GrammarTerminalNames[getVariant()].name);
258392 : // printf ("Error in SgNewExp::error() \n");
258393 : ROSE_ABORT();
258394 : }
258395 :
258396 : ROSE_ASSERT (getVariant() == NEW_OP);
258397 : return SgExpression::error();
258398 : }
258399 : #endif
258400 :
258401 :
258402 :
258403 : // End of memberFunctionString
258404 :
258405 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
258406 :
258407 2814860 : SgNewExp* isSgNewExp ( SgNode* inputDerivedClassPointer )
258408 : {
258409 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
258410 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
258411 : // So to fix this we return NULL directly when the input is NULL and avoid the
258412 : // dynamic_cast in this case. This is likely a performance improvement as well.
258413 : // return dynamic_cast<SgNewExp*>(inputDerivedClassPointer);
258414 : // Milind Chabbi (8/28/2013): isSgNewExp uses table-driven castability instead of c++ default dynamic_cast
258415 : // this improves the running time performance by 10-20%.
258416 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNewExp*>(inputDerivedClassPointer);
258417 2814860 : return IS_SgNewExp_FAST_MACRO(inputDerivedClassPointer);
258418 : }
258419 :
258420 : // DQ (11/8/2003): Added version of functions taking const pointer
258421 0 : const SgNewExp* isSgNewExp ( const SgNode* inputDerivedClassPointer )
258422 : {
258423 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
258424 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
258425 : // So to fix this we return NULL directly when the input is NULL and avoid the
258426 : // dynamic_cast in this case. This is likely a performance improvement as well.
258427 : // return dynamic_cast<const SgNewExp*>(inputDerivedClassPointer);
258428 : // Milind Chabbi (8/28/2013): isSgNewExp uses table-driven castability instead of c++ default dynamic_cast
258429 : // this improves the running time performance by 10-20%.
258430 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNewExp*>(inputDerivedClassPointer);
258431 0 : return IS_SgNewExp_FAST_MACRO(inputDerivedClassPointer);
258432 : }
258433 :
258434 :
258435 :
258436 : /* #line 258437 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
258437 :
258438 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
258439 :
258440 : /**
258441 : \brief Generated destructor
258442 :
258443 : This destructor is automatically generated (by ROSETTA). This destructor
258444 : only frees memory of data members associated with the parts of the current IR node which
258445 : are NOT traversed. Those data members that are part of a traversal can be freed using
258446 : a traversal (calling this destructor on all children in a post-order traversal). Such
258447 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
258448 :
258449 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
258450 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
258451 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
258452 :
258453 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
258454 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
258455 : pointers are not yet implemented to call delete on eash pointer in the container.
258456 : (This could be done by derivation from the STL containers to define containers that
258457 : automatically deleted their members.)
258458 :
258459 : */
258460 56 : SgNewExp::~SgNewExp () {
258461 28 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
258462 :
258463 :
258464 : // case: not a listType for specified_type
258465 28 : p_specified_type = NULL; // non list case
258466 : // case: not a listType for placement_args
258467 28 : p_placement_args = NULL; // non list case
258468 : // case: not a listType for constructor_args
258469 28 : p_constructor_args = NULL; // non list case
258470 : // case: not a listType for builtin_args
258471 28 : p_builtin_args = NULL; // non list case
258472 : // case: not a listType for need_global_specifier
258473 28 : p_need_global_specifier = 0; // non list case
258474 : // case: not a listType for newOperatorDeclaration
258475 28 : p_newOperatorDeclaration = NULL; // non list case
258476 : // case: not a listType for name_qualification_length
258477 28 : p_name_qualification_length = 0; // non list case
258478 : // case: not a listType for type_elaboration_required
258479 28 : p_type_elaboration_required = false; // non list case
258480 : // case: not a listType for global_qualification_required
258481 28 : p_global_qualification_required = false; // non list case
258482 : // case: not a listType for name_qualification_for_pointer_to_member_class_length
258483 28 : p_name_qualification_for_pointer_to_member_class_length = 0; // non list case
258484 : // case: not a listType for type_elaboration_for_pointer_to_member_class_required
258485 28 : p_type_elaboration_for_pointer_to_member_class_required = false; // non list case
258486 : // case: not a listType for global_qualification_for_pointer_to_member_class_required
258487 28 : p_global_qualification_for_pointer_to_member_class_required = false; // non list case
258488 :
258489 : }
258490 :
258491 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
258492 56 : }
258493 :
258494 :
258495 : /* #line 258496 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
258496 :
258497 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
258498 :
258499 : // Generated constructor
258500 0 : SgNewExp::SgNewExp ( Sg_File_Info* startOfConstruct, SgType* specified_type, SgExprListExp* placement_args, SgConstructorInitializer* constructor_args, SgExpression* builtin_args, short need_global_specifier, SgFunctionDeclaration* newOperatorDeclaration )
258501 0 : : SgExpression(startOfConstruct)
258502 : {
258503 : #ifdef DEBUG
258504 : // printf ("In SgNewExp::SgNewExp (Sg_File_Info* startOfConstruct, SgType* specified_type, SgExprListExp* placement_args, SgConstructorInitializer* constructor_args, SgExpression* builtin_args, short need_global_specifier, SgFunctionDeclaration* newOperatorDeclaration) sage_class_name() = %s \n",sage_class_name());
258505 : #endif
258506 : #if 0
258507 : // debugging information!
258508 : printf ("In SgNewExp::SgNewExp (Sg_File_Info* startOfConstruct, SgType* specified_type, SgExprListExp* placement_args, SgConstructorInitializer* constructor_args, SgExpression* builtin_args, short need_global_specifier, SgFunctionDeclaration* newOperatorDeclaration): this = %p = %s \n",this,this->class_name().c_str());
258509 : #endif
258510 :
258511 0 : p_specified_type = specified_type;
258512 0 : p_placement_args = placement_args;
258513 0 : p_constructor_args = constructor_args;
258514 0 : p_builtin_args = builtin_args;
258515 0 : p_need_global_specifier = need_global_specifier;
258516 0 : p_newOperatorDeclaration = newOperatorDeclaration;
258517 0 : p_name_qualification_length = 0;
258518 0 : p_type_elaboration_required = false;
258519 0 : p_global_qualification_required = false;
258520 0 : p_name_qualification_for_pointer_to_member_class_length = 0;
258521 0 : p_type_elaboration_for_pointer_to_member_class_required = false;
258522 0 : p_global_qualification_for_pointer_to_member_class_required = false;
258523 :
258524 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
258525 :
258526 : #if 0
258527 : // DQ (7/30/2014): Call a virtual function.
258528 : std::string s = this->class_name();
258529 : #endif
258530 :
258531 : // Test the variant virtual function
258532 : // assert(NEW_OP == variant());
258533 0 : assert(NEW_OP == this->variant());
258534 0 : ROSE_ASSERT(NEW_OP == (int)(this->variantT()));
258535 0 : post_construction_initialization();
258536 :
258537 : // Test the isSgNewExp() function since it has been problematic
258538 0 : assert(isSgNewExp(this) != NULL);
258539 0 : }
258540 :
258541 : // Generated constructor (all data members)
258542 :
258543 : /* #line 258544 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
258544 :
258545 :
258546 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
258547 :
258548 :
258549 : // ********************************************************
258550 : // member functions common across all array grammar objects
258551 : // ********************************************************
258552 :
258553 :
258554 :
258555 : /* #line 258556 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
258556 :
258557 :
258558 :
258559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
258560 :
258561 : // ********************************************************
258562 : // member functions specific to each node in the grammar
258563 : // ********************************************************
258564 :
258565 :
258566 : /* #line 258567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
258567 :
258568 : // Start of memberFunctionString
258569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
258570 :
258571 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
258572 :
258573 : SgExpression*
258574 0 : SgDeleteExp::get_variable () const
258575 : {
258576 0 : ROSE_ASSERT (this != NULL);
258577 :
258578 : #if 0
258579 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258580 : // used to trigger marking transformations for the token-based unparsing.
258581 : printf ("SgDeleteExp::get_variable = %p = %s \n",this,this->class_name().c_str());
258582 : #endif
258583 :
258584 0 : return p_variable;
258585 : }
258586 :
258587 : void
258588 0 : SgDeleteExp::set_variable ( SgExpression* variable )
258589 : {
258590 0 : ROSE_ASSERT (this != NULL);
258591 :
258592 : #if 0
258593 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258594 : // used to trigger marking transformations for the token-based unparsing.
258595 : printf ("SgDeleteExp::set_variable = %p = %s \n",this,this->class_name().c_str());
258596 : #endif
258597 :
258598 0 : set_isModified(true);
258599 :
258600 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
258601 : if (p_variable != NULL && variable != NULL && p_variable != variable)
258602 : {
258603 : printf ("Warning: variable = %p overwriting valid pointer p_variable = %p \n",variable,p_variable);
258604 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
258605 : printf ("Error fails assertion (p_variable != NULL && variable != NULL && p_variable != variable) is false\n");
258606 : ROSE_ASSERT(false);
258607 : #endif
258608 : }
258609 : #endif
258610 0 : p_variable = variable;
258611 0 : }
258612 :
258613 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
258614 :
258615 :
258616 : // End of memberFunctionString
258617 : // Start of memberFunctionString
258618 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
258619 :
258620 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
258621 :
258622 : short
258623 0 : SgDeleteExp::get_is_array () const
258624 : {
258625 0 : ROSE_ASSERT (this != NULL);
258626 :
258627 : #if 0
258628 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258629 : // used to trigger marking transformations for the token-based unparsing.
258630 : printf ("SgDeleteExp::get_is_array = %p = %s \n",this,this->class_name().c_str());
258631 : #endif
258632 :
258633 0 : return p_is_array;
258634 : }
258635 :
258636 : void
258637 0 : SgDeleteExp::set_is_array ( short is_array )
258638 : {
258639 0 : ROSE_ASSERT (this != NULL);
258640 :
258641 : #if 0
258642 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258643 : // used to trigger marking transformations for the token-based unparsing.
258644 : printf ("SgDeleteExp::set_is_array = %p = %s \n",this,this->class_name().c_str());
258645 : #endif
258646 :
258647 0 : set_isModified(true);
258648 :
258649 0 : p_is_array = is_array;
258650 0 : }
258651 :
258652 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
258653 :
258654 :
258655 : // End of memberFunctionString
258656 : // Start of memberFunctionString
258657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
258658 :
258659 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
258660 :
258661 : short
258662 0 : SgDeleteExp::get_need_global_specifier () const
258663 : {
258664 0 : ROSE_ASSERT (this != NULL);
258665 :
258666 : #if 0
258667 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258668 : // used to trigger marking transformations for the token-based unparsing.
258669 : printf ("SgDeleteExp::get_need_global_specifier = %p = %s \n",this,this->class_name().c_str());
258670 : #endif
258671 :
258672 0 : return p_need_global_specifier;
258673 : }
258674 :
258675 : void
258676 0 : SgDeleteExp::set_need_global_specifier ( short need_global_specifier )
258677 : {
258678 0 : ROSE_ASSERT (this != NULL);
258679 :
258680 : #if 0
258681 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258682 : // used to trigger marking transformations for the token-based unparsing.
258683 : printf ("SgDeleteExp::set_need_global_specifier = %p = %s \n",this,this->class_name().c_str());
258684 : #endif
258685 :
258686 0 : set_isModified(true);
258687 :
258688 0 : p_need_global_specifier = need_global_specifier;
258689 0 : }
258690 :
258691 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
258692 :
258693 :
258694 : // End of memberFunctionString
258695 : // Start of memberFunctionString
258696 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
258697 :
258698 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
258699 :
258700 : SgFunctionDeclaration*
258701 0 : SgDeleteExp::get_deleteOperatorDeclaration () const
258702 : {
258703 0 : ROSE_ASSERT (this != NULL);
258704 :
258705 : #if 0
258706 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258707 : // used to trigger marking transformations for the token-based unparsing.
258708 : printf ("SgDeleteExp::get_deleteOperatorDeclaration = %p = %s \n",this,this->class_name().c_str());
258709 : #endif
258710 :
258711 0 : return p_deleteOperatorDeclaration;
258712 : }
258713 :
258714 : void
258715 0 : SgDeleteExp::set_deleteOperatorDeclaration ( SgFunctionDeclaration* deleteOperatorDeclaration )
258716 : {
258717 0 : ROSE_ASSERT (this != NULL);
258718 :
258719 : #if 0
258720 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
258721 : // used to trigger marking transformations for the token-based unparsing.
258722 : printf ("SgDeleteExp::set_deleteOperatorDeclaration = %p = %s \n",this,this->class_name().c_str());
258723 : #endif
258724 :
258725 0 : set_isModified(true);
258726 :
258727 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
258728 : if (p_deleteOperatorDeclaration != NULL && deleteOperatorDeclaration != NULL && p_deleteOperatorDeclaration != deleteOperatorDeclaration)
258729 : {
258730 : printf ("Warning: deleteOperatorDeclaration = %p overwriting valid pointer p_deleteOperatorDeclaration = %p \n",deleteOperatorDeclaration,p_deleteOperatorDeclaration);
258731 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
258732 : printf ("Error fails assertion (p_deleteOperatorDeclaration != NULL && deleteOperatorDeclaration != NULL && p_deleteOperatorDeclaration != deleteOperatorDeclaration) is false\n");
258733 : ROSE_ASSERT(false);
258734 : #endif
258735 : }
258736 : #endif
258737 0 : p_deleteOperatorDeclaration = deleteOperatorDeclaration;
258738 0 : }
258739 :
258740 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
258741 :
258742 :
258743 : // End of memberFunctionString
258744 : // Start of memberFunctionString
258745 : /* #line 6957 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
258746 :
258747 :
258748 : #if 0
258749 : // This should be generated automatically
258750 : SgDeleteExp::SgDeleteExp(Sg_File_Info* info , SgExpression* variable, short is_array, short need_global_specifier)
258751 : : SgExpression(info)
258752 : {
258753 : p_variable = variable;
258754 : p_is_array = is_array;
258755 : p_need_global_specifier = need_global_specifier;
258756 : /* now a call to the user defined intialization function */
258757 : post_construction_initialization();
258758 : }
258759 : #endif
258760 :
258761 : void
258762 120 : SgDeleteExp::post_construction_initialization()
258763 : {
258764 : // #ifndef REMOVE_SET_PARENT_FUNCTION
258765 120 : if(p_variable)
258766 120 : p_variable->set_parent(this);
258767 : // #endif
258768 120 : }
258769 :
258770 : SgType*
258771 99 : SgDeleteExp::get_type() const
258772 : {
258773 : // The delete operator always returns "void" as a type. This used to return SgDefaultType (but that didn't seem quite right)
258774 :
258775 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
258776 :
258777 : // printf ("SgDeleteExp::get_type(): p_expression_type has been removed, we now return SgTypeVoid \n");
258778 :
258779 : #if 0
258780 : printf ("In SgDeleteExp::get_type() \n");
258781 : #endif
258782 :
258783 99 : SgType* returnType = SgTypeVoid::createType();
258784 :
258785 99 : ROSE_ASSERT(returnType != NULL);
258786 99 : return returnType;
258787 : }
258788 :
258789 : SgExpression*
258790 0 : SgDeleteExp::get_next(int& n) const
258791 : {
258792 0 : if(n==0)
258793 : {
258794 0 : n++;
258795 0 : return get_variable();
258796 : }
258797 : else
258798 : {
258799 : return 0;
258800 : }
258801 : }
258802 :
258803 : int
258804 0 : SgDeleteExp::replace_expression(SgExpression *o, SgExpression *n)
258805 : {
258806 : // DQ (12/17/2006): This function should have the semantics that it will represent a
258807 : // structural change to the AST, thus it is free to set the parent of the new expression.
258808 :
258809 0 : ROSE_ASSERT(o != NULL);
258810 0 : ROSE_ASSERT(n != NULL);
258811 :
258812 0 : if (get_variable() == o)
258813 : {
258814 0 : set_variable(n);
258815 0 : n->set_parent(this);
258816 0 : return 1;
258817 : }
258818 : else
258819 : {
258820 : return 0;
258821 : }
258822 : }
258823 :
258824 :
258825 :
258826 : // End of memberFunctionString
258827 : // Start of memberFunctionString
258828 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
258829 :
258830 : // *** COMMON CODE SECTION BEGINS HERE ***
258831 :
258832 : #if 0
258833 : int
258834 : SgDeleteExp::getVariant() const
258835 : {
258836 : // This function is used in ROSE while "variant()" is used in SAGE
258837 : assert(this != NULL);
258838 : return variant();
258839 : }
258840 : #endif
258841 :
258842 : // This function is used in ROSE in treeTraversal code
258843 : // eventually replaces getVariant() and variant()
258844 : // though after variant() has been removed for a while we will
258845 : // want to change the name of variantT() back to variant()
258846 : // (since the "T" was ment to stand for temporary).
258847 : // When this happens the variantT() will be depricated.
258848 : VariantT
258849 20147 : SgDeleteExp::variantT() const
258850 : {
258851 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
258852 20147 : ROSE_ASSERT(this != NULL);
258853 20147 : return V_SgDeleteExp;
258854 : }
258855 :
258856 : #if 0
258857 : int
258858 : SgDeleteExp::variant() const
258859 : {
258860 : // This function is used in SAGE
258861 : ROSE_ASSERT(this != NULL);
258862 : return DELETE_OP;
258863 : }
258864 : #endif
258865 :
258866 : ROSE_DLL_API const char*
258867 0 : SgDeleteExp::sage_class_name() const
258868 : {
258869 0 : ROSE_ASSERT(this != NULL);
258870 0 : return "SgDeleteExp";
258871 : }
258872 :
258873 : std::string
258874 105 : SgDeleteExp::class_name() const
258875 : {
258876 105 : ROSE_ASSERT(this != NULL);
258877 105 : return "SgDeleteExp";
258878 : }
258879 :
258880 : // DQ (11/26/2005): Support for visitor pattern mechanims
258881 : // (inferior to ROSE traversal mechanism, experimental).
258882 : void
258883 2055 : SgDeleteExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
258884 : {
258885 2055 : ROSE_ASSERT(this != NULL);
258886 2055 : visitor.visit(this);
258887 2055 : }
258888 :
258889 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
258890 0 : void SgDeleteExp::accept (ROSE_VisitorPattern & visitor) {
258891 0 : ROSE_ASSERT(this != NULL);
258892 0 : visitor.visit(this);
258893 0 : }
258894 :
258895 : SgDeleteExp*
258896 0 : SgDeleteExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
258897 : {
258898 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
258899 : // This function is currently only supported for the AST used the represent Binary executables.
258900 : if (0 /* isSgAsmNode(this) != NULL */)
258901 : {
258902 : // Support for regex specification.
258903 : std::string prefixCode = "REGEX:";
258904 : addNewAttribute(prefixCode + s,a);
258905 : }
258906 : #endif
258907 :
258908 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
258909 0 : return this;
258910 : }
258911 :
258912 : // *** COMMON CODE SECTION ENDS HERE ***
258913 :
258914 :
258915 : // End of memberFunctionString
258916 : // Start of memberFunctionString
258917 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
258918 :
258919 :
258920 : #if 0
258921 : //! Error checking support
258922 : /*! Verifies the following:
258923 : - working getVariant() member function
258924 : - calls base class's error() member function
258925 : Every class has one of these functions.
258926 : */
258927 : bool
258928 : SgDeleteExp::error()
258929 : {
258930 : // Put error checking here
258931 :
258932 : ROSE_ASSERT (this != NULL);
258933 : if (getVariant() != DELETE_OP)
258934 : {
258935 : printf ("Error in SgDeleteExp::error(): SgDeleteExp object has a %s variant \n",
258936 : Cxx_GrammarTerminalNames[getVariant()].name);
258937 : // printf ("Error in SgDeleteExp::error() \n");
258938 : ROSE_ABORT();
258939 : }
258940 :
258941 : ROSE_ASSERT (getVariant() == DELETE_OP);
258942 : return SgExpression::error();
258943 : }
258944 : #endif
258945 :
258946 :
258947 :
258948 : // End of memberFunctionString
258949 :
258950 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
258951 :
258952 120 : SgDeleteExp* isSgDeleteExp ( SgNode* inputDerivedClassPointer )
258953 : {
258954 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
258955 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
258956 : // So to fix this we return NULL directly when the input is NULL and avoid the
258957 : // dynamic_cast in this case. This is likely a performance improvement as well.
258958 : // return dynamic_cast<SgDeleteExp*>(inputDerivedClassPointer);
258959 : // Milind Chabbi (8/28/2013): isSgDeleteExp uses table-driven castability instead of c++ default dynamic_cast
258960 : // this improves the running time performance by 10-20%.
258961 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDeleteExp*>(inputDerivedClassPointer);
258962 120 : return IS_SgDeleteExp_FAST_MACRO(inputDerivedClassPointer);
258963 : }
258964 :
258965 : // DQ (11/8/2003): Added version of functions taking const pointer
258966 0 : const SgDeleteExp* isSgDeleteExp ( const SgNode* inputDerivedClassPointer )
258967 : {
258968 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
258969 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
258970 : // So to fix this we return NULL directly when the input is NULL and avoid the
258971 : // dynamic_cast in this case. This is likely a performance improvement as well.
258972 : // return dynamic_cast<const SgDeleteExp*>(inputDerivedClassPointer);
258973 : // Milind Chabbi (8/28/2013): isSgDeleteExp uses table-driven castability instead of c++ default dynamic_cast
258974 : // this improves the running time performance by 10-20%.
258975 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDeleteExp*>(inputDerivedClassPointer);
258976 0 : return IS_SgDeleteExp_FAST_MACRO(inputDerivedClassPointer);
258977 : }
258978 :
258979 :
258980 :
258981 : /* #line 258982 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
258982 :
258983 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
258984 :
258985 : /**
258986 : \brief Generated destructor
258987 :
258988 : This destructor is automatically generated (by ROSETTA). This destructor
258989 : only frees memory of data members associated with the parts of the current IR node which
258990 : are NOT traversed. Those data members that are part of a traversal can be freed using
258991 : a traversal (calling this destructor on all children in a post-order traversal). Such
258992 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
258993 :
258994 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
258995 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
258996 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
258997 :
258998 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
258999 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
259000 : pointers are not yet implemented to call delete on eash pointer in the container.
259001 : (This could be done by derivation from the STL containers to define containers that
259002 : automatically deleted their members.)
259003 :
259004 : */
259005 60 : SgDeleteExp::~SgDeleteExp () {
259006 30 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
259007 :
259008 :
259009 : // case: not a listType for variable
259010 30 : p_variable = NULL; // non list case
259011 : // case: not a listType for is_array
259012 30 : p_is_array = 0; // non list case
259013 : // case: not a listType for need_global_specifier
259014 30 : p_need_global_specifier = 0; // non list case
259015 : // case: not a listType for deleteOperatorDeclaration
259016 30 : p_deleteOperatorDeclaration = NULL; // non list case
259017 :
259018 : }
259019 :
259020 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
259021 60 : }
259022 :
259023 :
259024 : /* #line 259025 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259025 :
259026 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
259027 :
259028 : // Generated constructor
259029 0 : SgDeleteExp::SgDeleteExp ( Sg_File_Info* startOfConstruct, SgExpression* variable, short is_array, short need_global_specifier, SgFunctionDeclaration* deleteOperatorDeclaration )
259030 0 : : SgExpression(startOfConstruct)
259031 : {
259032 : #ifdef DEBUG
259033 : // printf ("In SgDeleteExp::SgDeleteExp (Sg_File_Info* startOfConstruct, SgExpression* variable, short is_array, short need_global_specifier, SgFunctionDeclaration* deleteOperatorDeclaration) sage_class_name() = %s \n",sage_class_name());
259034 : #endif
259035 : #if 0
259036 : // debugging information!
259037 : printf ("In SgDeleteExp::SgDeleteExp (Sg_File_Info* startOfConstruct, SgExpression* variable, short is_array, short need_global_specifier, SgFunctionDeclaration* deleteOperatorDeclaration): this = %p = %s \n",this,this->class_name().c_str());
259038 : #endif
259039 :
259040 0 : p_variable = variable;
259041 0 : p_is_array = is_array;
259042 0 : p_need_global_specifier = need_global_specifier;
259043 0 : p_deleteOperatorDeclaration = deleteOperatorDeclaration;
259044 :
259045 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
259046 :
259047 : #if 0
259048 : // DQ (7/30/2014): Call a virtual function.
259049 : std::string s = this->class_name();
259050 : #endif
259051 :
259052 : // Test the variant virtual function
259053 : // assert(DELETE_OP == variant());
259054 0 : assert(DELETE_OP == this->variant());
259055 0 : ROSE_ASSERT(DELETE_OP == (int)(this->variantT()));
259056 0 : post_construction_initialization();
259057 :
259058 : // Test the isSgDeleteExp() function since it has been problematic
259059 0 : assert(isSgDeleteExp(this) != NULL);
259060 0 : }
259061 :
259062 : // Generated constructor (all data members)
259063 :
259064 : /* #line 259065 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259065 :
259066 :
259067 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
259068 :
259069 :
259070 : // ********************************************************
259071 : // member functions common across all array grammar objects
259072 : // ********************************************************
259073 :
259074 :
259075 :
259076 : /* #line 259077 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259077 :
259078 :
259079 :
259080 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
259081 :
259082 : // ********************************************************
259083 : // member functions specific to each node in the grammar
259084 : // ********************************************************
259085 :
259086 :
259087 : /* #line 259088 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259088 :
259089 : // Start of memberFunctionString
259090 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259091 :
259092 : void
259093 12055 : SgThisExp::post_construction_initialization()
259094 : {
259095 12055 : }
259096 :
259097 :
259098 :
259099 : // End of memberFunctionString
259100 : // Start of memberFunctionString
259101 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
259102 :
259103 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
259104 :
259105 : SgClassSymbol*
259106 301080 : SgThisExp::get_class_symbol () const
259107 : {
259108 301080 : ROSE_ASSERT (this != NULL);
259109 :
259110 : #if 0
259111 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259112 : // used to trigger marking transformations for the token-based unparsing.
259113 : printf ("SgThisExp::get_class_symbol = %p = %s \n",this,this->class_name().c_str());
259114 : #endif
259115 :
259116 301080 : return p_class_symbol;
259117 : }
259118 :
259119 : void
259120 0 : SgThisExp::set_class_symbol ( SgClassSymbol* class_symbol )
259121 : {
259122 0 : ROSE_ASSERT (this != NULL);
259123 :
259124 : #if 0
259125 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259126 : // used to trigger marking transformations for the token-based unparsing.
259127 : printf ("SgThisExp::set_class_symbol = %p = %s \n",this,this->class_name().c_str());
259128 : #endif
259129 :
259130 0 : set_isModified(true);
259131 :
259132 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
259133 : if (p_class_symbol != NULL && class_symbol != NULL && p_class_symbol != class_symbol)
259134 : {
259135 : printf ("Warning: class_symbol = %p overwriting valid pointer p_class_symbol = %p \n",class_symbol,p_class_symbol);
259136 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
259137 : printf ("Error fails assertion (p_class_symbol != NULL && class_symbol != NULL && p_class_symbol != class_symbol) is false\n");
259138 : ROSE_ASSERT(false);
259139 : #endif
259140 : }
259141 : #endif
259142 0 : p_class_symbol = class_symbol;
259143 0 : }
259144 :
259145 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
259146 :
259147 :
259148 : // End of memberFunctionString
259149 : // Start of memberFunctionString
259150 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
259151 :
259152 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
259153 :
259154 : SgNonrealSymbol*
259155 150540 : SgThisExp::get_nonreal_symbol () const
259156 : {
259157 150540 : ROSE_ASSERT (this != NULL);
259158 :
259159 : #if 0
259160 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259161 : // used to trigger marking transformations for the token-based unparsing.
259162 : printf ("SgThisExp::get_nonreal_symbol = %p = %s \n",this,this->class_name().c_str());
259163 : #endif
259164 :
259165 150540 : return p_nonreal_symbol;
259166 : }
259167 :
259168 : void
259169 0 : SgThisExp::set_nonreal_symbol ( SgNonrealSymbol* nonreal_symbol )
259170 : {
259171 0 : ROSE_ASSERT (this != NULL);
259172 :
259173 : #if 0
259174 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259175 : // used to trigger marking transformations for the token-based unparsing.
259176 : printf ("SgThisExp::set_nonreal_symbol = %p = %s \n",this,this->class_name().c_str());
259177 : #endif
259178 :
259179 0 : set_isModified(true);
259180 :
259181 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
259182 : if (p_nonreal_symbol != NULL && nonreal_symbol != NULL && p_nonreal_symbol != nonreal_symbol)
259183 : {
259184 : printf ("Warning: nonreal_symbol = %p overwriting valid pointer p_nonreal_symbol = %p \n",nonreal_symbol,p_nonreal_symbol);
259185 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
259186 : printf ("Error fails assertion (p_nonreal_symbol != NULL && nonreal_symbol != NULL && p_nonreal_symbol != nonreal_symbol) is false\n");
259187 : ROSE_ASSERT(false);
259188 : #endif
259189 : }
259190 : #endif
259191 0 : p_nonreal_symbol = nonreal_symbol;
259192 0 : }
259193 :
259194 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
259195 :
259196 :
259197 : // End of memberFunctionString
259198 : // Start of memberFunctionString
259199 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
259200 :
259201 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
259202 :
259203 : int
259204 0 : SgThisExp::get_pobj_this () const
259205 : {
259206 0 : ROSE_ASSERT (this != NULL);
259207 :
259208 : #if 0
259209 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259210 : // used to trigger marking transformations for the token-based unparsing.
259211 : printf ("SgThisExp::get_pobj_this = %p = %s \n",this,this->class_name().c_str());
259212 : #endif
259213 :
259214 0 : return p_pobj_this;
259215 : }
259216 :
259217 : void
259218 0 : SgThisExp::set_pobj_this ( int pobj_this )
259219 : {
259220 0 : ROSE_ASSERT (this != NULL);
259221 :
259222 : #if 0
259223 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259224 : // used to trigger marking transformations for the token-based unparsing.
259225 : printf ("SgThisExp::set_pobj_this = %p = %s \n",this,this->class_name().c_str());
259226 : #endif
259227 :
259228 0 : set_isModified(true);
259229 :
259230 0 : p_pobj_this = pobj_this;
259231 0 : }
259232 :
259233 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
259234 :
259235 :
259236 : // End of memberFunctionString
259237 : // Start of memberFunctionString
259238 : /* #line 7037 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259239 :
259240 :
259241 :
259242 : // End of memberFunctionString
259243 : // Start of memberFunctionString
259244 : /* #line 8470 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259245 :
259246 :
259247 : SgType*
259248 150540 : SgThisExp::get_type() const
259249 : {
259250 150540 : SgType * type = NULL;
259251 150540 : if (get_class_symbol() != NULL) {
259252 150540 : type = get_class_symbol()->get_type();
259253 : }
259254 150540 : if (get_nonreal_symbol() != NULL) {
259255 0 : type = get_nonreal_symbol()->get_type();
259256 : }
259257 :
259258 : #if 0
259259 : printf ("In SgThisExp::get_type() \n");
259260 : #endif
259261 150540 : ROSE_ASSERT(type != NULL);
259262 :
259263 150540 : return SgPointerType::createType(type);
259264 : }
259265 :
259266 :
259267 :
259268 : // End of memberFunctionString
259269 : // Start of memberFunctionString
259270 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
259271 :
259272 : // *** COMMON CODE SECTION BEGINS HERE ***
259273 :
259274 : #if 0
259275 : int
259276 : SgThisExp::getVariant() const
259277 : {
259278 : // This function is used in ROSE while "variant()" is used in SAGE
259279 : assert(this != NULL);
259280 : return variant();
259281 : }
259282 : #endif
259283 :
259284 : // This function is used in ROSE in treeTraversal code
259285 : // eventually replaces getVariant() and variant()
259286 : // though after variant() has been removed for a while we will
259287 : // want to change the name of variantT() back to variant()
259288 : // (since the "T" was ment to stand for temporary).
259289 : // When this happens the variantT() will be depricated.
259290 : VariantT
259291 3354350 : SgThisExp::variantT() const
259292 : {
259293 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
259294 3354350 : ROSE_ASSERT(this != NULL);
259295 3354350 : return V_SgThisExp;
259296 : }
259297 :
259298 : #if 0
259299 : int
259300 : SgThisExp::variant() const
259301 : {
259302 : // This function is used in SAGE
259303 : ROSE_ASSERT(this != NULL);
259304 : return THIS_NODE;
259305 : }
259306 : #endif
259307 :
259308 : ROSE_DLL_API const char*
259309 515 : SgThisExp::sage_class_name() const
259310 : {
259311 515 : ROSE_ASSERT(this != NULL);
259312 515 : return "SgThisExp";
259313 : }
259314 :
259315 : std::string
259316 10098 : SgThisExp::class_name() const
259317 : {
259318 10098 : ROSE_ASSERT(this != NULL);
259319 10098 : return "SgThisExp";
259320 : }
259321 :
259322 : // DQ (11/26/2005): Support for visitor pattern mechanims
259323 : // (inferior to ROSE traversal mechanism, experimental).
259324 : void
259325 179329 : SgThisExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
259326 : {
259327 179329 : ROSE_ASSERT(this != NULL);
259328 179329 : visitor.visit(this);
259329 179329 : }
259330 :
259331 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
259332 0 : void SgThisExp::accept (ROSE_VisitorPattern & visitor) {
259333 0 : ROSE_ASSERT(this != NULL);
259334 0 : visitor.visit(this);
259335 0 : }
259336 :
259337 : SgThisExp*
259338 0 : SgThisExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
259339 : {
259340 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
259341 : // This function is currently only supported for the AST used the represent Binary executables.
259342 : if (0 /* isSgAsmNode(this) != NULL */)
259343 : {
259344 : // Support for regex specification.
259345 : std::string prefixCode = "REGEX:";
259346 : addNewAttribute(prefixCode + s,a);
259347 : }
259348 : #endif
259349 :
259350 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
259351 0 : return this;
259352 : }
259353 :
259354 : // *** COMMON CODE SECTION ENDS HERE ***
259355 :
259356 :
259357 : // End of memberFunctionString
259358 : // Start of memberFunctionString
259359 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
259360 :
259361 :
259362 : #if 0
259363 : //! Error checking support
259364 : /*! Verifies the following:
259365 : - working getVariant() member function
259366 : - calls base class's error() member function
259367 : Every class has one of these functions.
259368 : */
259369 : bool
259370 : SgThisExp::error()
259371 : {
259372 : // Put error checking here
259373 :
259374 : ROSE_ASSERT (this != NULL);
259375 : if (getVariant() != THIS_NODE)
259376 : {
259377 : printf ("Error in SgThisExp::error(): SgThisExp object has a %s variant \n",
259378 : Cxx_GrammarTerminalNames[getVariant()].name);
259379 : // printf ("Error in SgThisExp::error() \n");
259380 : ROSE_ABORT();
259381 : }
259382 :
259383 : ROSE_ASSERT (getVariant() == THIS_NODE);
259384 : return SgExpression::error();
259385 : }
259386 : #endif
259387 :
259388 :
259389 :
259390 : // End of memberFunctionString
259391 :
259392 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
259393 :
259394 13816 : SgThisExp* isSgThisExp ( SgNode* inputDerivedClassPointer )
259395 : {
259396 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
259397 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
259398 : // So to fix this we return NULL directly when the input is NULL and avoid the
259399 : // dynamic_cast in this case. This is likely a performance improvement as well.
259400 : // return dynamic_cast<SgThisExp*>(inputDerivedClassPointer);
259401 : // Milind Chabbi (8/28/2013): isSgThisExp uses table-driven castability instead of c++ default dynamic_cast
259402 : // this improves the running time performance by 10-20%.
259403 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgThisExp*>(inputDerivedClassPointer);
259404 13816 : return IS_SgThisExp_FAST_MACRO(inputDerivedClassPointer);
259405 : }
259406 :
259407 : // DQ (11/8/2003): Added version of functions taking const pointer
259408 0 : const SgThisExp* isSgThisExp ( const SgNode* inputDerivedClassPointer )
259409 : {
259410 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
259411 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
259412 : // So to fix this we return NULL directly when the input is NULL and avoid the
259413 : // dynamic_cast in this case. This is likely a performance improvement as well.
259414 : // return dynamic_cast<const SgThisExp*>(inputDerivedClassPointer);
259415 : // Milind Chabbi (8/28/2013): isSgThisExp uses table-driven castability instead of c++ default dynamic_cast
259416 : // this improves the running time performance by 10-20%.
259417 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgThisExp*>(inputDerivedClassPointer);
259418 0 : return IS_SgThisExp_FAST_MACRO(inputDerivedClassPointer);
259419 : }
259420 :
259421 :
259422 :
259423 : /* #line 259424 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259424 :
259425 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
259426 :
259427 : /**
259428 : \brief Generated destructor
259429 :
259430 : This destructor is automatically generated (by ROSETTA). This destructor
259431 : only frees memory of data members associated with the parts of the current IR node which
259432 : are NOT traversed. Those data members that are part of a traversal can be freed using
259433 : a traversal (calling this destructor on all children in a post-order traversal). Such
259434 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
259435 :
259436 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
259437 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
259438 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
259439 :
259440 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
259441 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
259442 : pointers are not yet implemented to call delete on eash pointer in the container.
259443 : (This could be done by derivation from the STL containers to define containers that
259444 : automatically deleted their members.)
259445 :
259446 : */
259447 5100 : SgThisExp::~SgThisExp () {
259448 2550 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
259449 :
259450 :
259451 : // case: not a listType for class_symbol
259452 2550 : p_class_symbol = NULL; // non list case
259453 : // case: not a listType for nonreal_symbol
259454 2550 : p_nonreal_symbol = NULL; // non list case
259455 : // case: not a listType for pobj_this
259456 2550 : p_pobj_this = 0; // non list case
259457 :
259458 : }
259459 :
259460 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
259461 5100 : }
259462 :
259463 :
259464 : /* #line 259465 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259465 :
259466 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
259467 :
259468 : // Generated constructor
259469 260 : SgThisExp::SgThisExp ( Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, SgNonrealSymbol* nonreal_symbol, int pobj_this )
259470 260 : : SgExpression(startOfConstruct)
259471 : {
259472 : #ifdef DEBUG
259473 : // printf ("In SgThisExp::SgThisExp (Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, SgNonrealSymbol* nonreal_symbol, int pobj_this) sage_class_name() = %s \n",sage_class_name());
259474 : #endif
259475 : #if 0
259476 : // debugging information!
259477 : printf ("In SgThisExp::SgThisExp (Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, SgNonrealSymbol* nonreal_symbol, int pobj_this): this = %p = %s \n",this,this->class_name().c_str());
259478 : #endif
259479 :
259480 260 : p_class_symbol = class_symbol;
259481 260 : p_nonreal_symbol = nonreal_symbol;
259482 260 : p_pobj_this = pobj_this;
259483 :
259484 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
259485 :
259486 : #if 0
259487 : // DQ (7/30/2014): Call a virtual function.
259488 : std::string s = this->class_name();
259489 : #endif
259490 :
259491 : // Test the variant virtual function
259492 : // assert(THIS_NODE == variant());
259493 260 : assert(THIS_NODE == this->variant());
259494 260 : ROSE_ASSERT(THIS_NODE == (int)(this->variantT()));
259495 260 : post_construction_initialization();
259496 :
259497 : // Test the isSgThisExp() function since it has been problematic
259498 260 : assert(isSgThisExp(this) != NULL);
259499 260 : }
259500 :
259501 : // Generated constructor (all data members)
259502 :
259503 : /* #line 259504 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259504 :
259505 :
259506 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
259507 :
259508 :
259509 : // ********************************************************
259510 : // member functions common across all array grammar objects
259511 : // ********************************************************
259512 :
259513 :
259514 :
259515 : /* #line 259516 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259516 :
259517 :
259518 :
259519 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
259520 :
259521 : // ********************************************************
259522 : // member functions specific to each node in the grammar
259523 : // ********************************************************
259524 :
259525 :
259526 : /* #line 259527 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259527 :
259528 : // Start of memberFunctionString
259529 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259530 :
259531 : void
259532 0 : SgRefExp::post_construction_initialization()
259533 : {
259534 0 : }
259535 :
259536 :
259537 :
259538 : // End of memberFunctionString
259539 : // Start of memberFunctionString
259540 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
259541 :
259542 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
259543 :
259544 : SgType*
259545 0 : SgRefExp::get_type_name () const
259546 : {
259547 0 : ROSE_ASSERT (this != NULL);
259548 :
259549 : #if 0
259550 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259551 : // used to trigger marking transformations for the token-based unparsing.
259552 : printf ("SgRefExp::get_type_name = %p = %s \n",this,this->class_name().c_str());
259553 : #endif
259554 :
259555 0 : return p_type_name;
259556 : }
259557 :
259558 : void
259559 0 : SgRefExp::set_type_name ( SgType* type_name )
259560 : {
259561 0 : ROSE_ASSERT (this != NULL);
259562 :
259563 : #if 0
259564 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259565 : // used to trigger marking transformations for the token-based unparsing.
259566 : printf ("SgRefExp::set_type_name = %p = %s \n",this,this->class_name().c_str());
259567 : #endif
259568 :
259569 0 : set_isModified(true);
259570 :
259571 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
259572 : if (p_type_name != NULL && type_name != NULL && p_type_name != type_name)
259573 : {
259574 : printf ("Warning: type_name = %p overwriting valid pointer p_type_name = %p \n",type_name,p_type_name);
259575 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
259576 : printf ("Error fails assertion (p_type_name != NULL && type_name != NULL && p_type_name != type_name) is false\n");
259577 : ROSE_ASSERT(false);
259578 : #endif
259579 : }
259580 : #endif
259581 0 : p_type_name = type_name;
259582 0 : }
259583 :
259584 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
259585 :
259586 :
259587 : // End of memberFunctionString
259588 : // Start of memberFunctionString
259589 : /* #line 7158 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259590 :
259591 :
259592 :
259593 : // End of memberFunctionString
259594 : // Start of memberFunctionString
259595 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
259596 :
259597 : // *** COMMON CODE SECTION BEGINS HERE ***
259598 :
259599 : #if 0
259600 : int
259601 : SgRefExp::getVariant() const
259602 : {
259603 : // This function is used in ROSE while "variant()" is used in SAGE
259604 : assert(this != NULL);
259605 : return variant();
259606 : }
259607 : #endif
259608 :
259609 : // This function is used in ROSE in treeTraversal code
259610 : // eventually replaces getVariant() and variant()
259611 : // though after variant() has been removed for a while we will
259612 : // want to change the name of variantT() back to variant()
259613 : // (since the "T" was ment to stand for temporary).
259614 : // When this happens the variantT() will be depricated.
259615 : VariantT
259616 0 : SgRefExp::variantT() const
259617 : {
259618 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
259619 0 : ROSE_ASSERT(this != NULL);
259620 0 : return V_SgRefExp;
259621 : }
259622 :
259623 : #if 0
259624 : int
259625 : SgRefExp::variant() const
259626 : {
259627 : // This function is used in SAGE
259628 : ROSE_ASSERT(this != NULL);
259629 : return TYPE_REF;
259630 : }
259631 : #endif
259632 :
259633 : ROSE_DLL_API const char*
259634 0 : SgRefExp::sage_class_name() const
259635 : {
259636 0 : ROSE_ASSERT(this != NULL);
259637 0 : return "SgRefExp";
259638 : }
259639 :
259640 : std::string
259641 0 : SgRefExp::class_name() const
259642 : {
259643 0 : ROSE_ASSERT(this != NULL);
259644 0 : return "SgRefExp";
259645 : }
259646 :
259647 : // DQ (11/26/2005): Support for visitor pattern mechanims
259648 : // (inferior to ROSE traversal mechanism, experimental).
259649 : void
259650 0 : SgRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
259651 : {
259652 0 : ROSE_ASSERT(this != NULL);
259653 0 : visitor.visit(this);
259654 0 : }
259655 :
259656 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
259657 0 : void SgRefExp::accept (ROSE_VisitorPattern & visitor) {
259658 0 : ROSE_ASSERT(this != NULL);
259659 0 : visitor.visit(this);
259660 0 : }
259661 :
259662 : SgRefExp*
259663 0 : SgRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
259664 : {
259665 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
259666 : // This function is currently only supported for the AST used the represent Binary executables.
259667 : if (0 /* isSgAsmNode(this) != NULL */)
259668 : {
259669 : // Support for regex specification.
259670 : std::string prefixCode = "REGEX:";
259671 : addNewAttribute(prefixCode + s,a);
259672 : }
259673 : #endif
259674 :
259675 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
259676 0 : return this;
259677 : }
259678 :
259679 : // *** COMMON CODE SECTION ENDS HERE ***
259680 :
259681 :
259682 : // End of memberFunctionString
259683 : // Start of memberFunctionString
259684 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
259685 :
259686 :
259687 : #if 0
259688 : //! Error checking support
259689 : /*! Verifies the following:
259690 : - working getVariant() member function
259691 : - calls base class's error() member function
259692 : Every class has one of these functions.
259693 : */
259694 : bool
259695 : SgRefExp::error()
259696 : {
259697 : // Put error checking here
259698 :
259699 : ROSE_ASSERT (this != NULL);
259700 : if (getVariant() != TYPE_REF)
259701 : {
259702 : printf ("Error in SgRefExp::error(): SgRefExp object has a %s variant \n",
259703 : Cxx_GrammarTerminalNames[getVariant()].name);
259704 : // printf ("Error in SgRefExp::error() \n");
259705 : ROSE_ABORT();
259706 : }
259707 :
259708 : ROSE_ASSERT (getVariant() == TYPE_REF);
259709 : return SgExpression::error();
259710 : }
259711 : #endif
259712 :
259713 :
259714 :
259715 : // End of memberFunctionString
259716 :
259717 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
259718 :
259719 0 : SgRefExp* isSgRefExp ( SgNode* inputDerivedClassPointer )
259720 : {
259721 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
259722 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
259723 : // So to fix this we return NULL directly when the input is NULL and avoid the
259724 : // dynamic_cast in this case. This is likely a performance improvement as well.
259725 : // return dynamic_cast<SgRefExp*>(inputDerivedClassPointer);
259726 : // Milind Chabbi (8/28/2013): isSgRefExp uses table-driven castability instead of c++ default dynamic_cast
259727 : // this improves the running time performance by 10-20%.
259728 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRefExp*>(inputDerivedClassPointer);
259729 0 : return IS_SgRefExp_FAST_MACRO(inputDerivedClassPointer);
259730 : }
259731 :
259732 : // DQ (11/8/2003): Added version of functions taking const pointer
259733 0 : const SgRefExp* isSgRefExp ( const SgNode* inputDerivedClassPointer )
259734 : {
259735 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
259736 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
259737 : // So to fix this we return NULL directly when the input is NULL and avoid the
259738 : // dynamic_cast in this case. This is likely a performance improvement as well.
259739 : // return dynamic_cast<const SgRefExp*>(inputDerivedClassPointer);
259740 : // Milind Chabbi (8/28/2013): isSgRefExp uses table-driven castability instead of c++ default dynamic_cast
259741 : // this improves the running time performance by 10-20%.
259742 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRefExp*>(inputDerivedClassPointer);
259743 0 : return IS_SgRefExp_FAST_MACRO(inputDerivedClassPointer);
259744 : }
259745 :
259746 :
259747 :
259748 : /* #line 259749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259749 :
259750 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
259751 :
259752 : /**
259753 : \brief Generated destructor
259754 :
259755 : This destructor is automatically generated (by ROSETTA). This destructor
259756 : only frees memory of data members associated with the parts of the current IR node which
259757 : are NOT traversed. Those data members that are part of a traversal can be freed using
259758 : a traversal (calling this destructor on all children in a post-order traversal). Such
259759 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
259760 :
259761 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
259762 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
259763 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
259764 :
259765 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
259766 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
259767 : pointers are not yet implemented to call delete on eash pointer in the container.
259768 : (This could be done by derivation from the STL containers to define containers that
259769 : automatically deleted their members.)
259770 :
259771 : */
259772 0 : SgRefExp::~SgRefExp () {
259773 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
259774 :
259775 :
259776 : // case: not a listType for type_name
259777 0 : p_type_name = NULL; // non list case
259778 :
259779 : }
259780 :
259781 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
259782 0 : }
259783 :
259784 :
259785 : /* #line 259786 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259786 :
259787 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
259788 :
259789 : // Generated constructor
259790 0 : SgRefExp::SgRefExp ( Sg_File_Info* startOfConstruct, SgType* type_name )
259791 0 : : SgExpression(startOfConstruct)
259792 : {
259793 : #ifdef DEBUG
259794 : // printf ("In SgRefExp::SgRefExp (Sg_File_Info* startOfConstruct, SgType* type_name) sage_class_name() = %s \n",sage_class_name());
259795 : #endif
259796 : #if 0
259797 : // debugging information!
259798 : printf ("In SgRefExp::SgRefExp (Sg_File_Info* startOfConstruct, SgType* type_name): this = %p = %s \n",this,this->class_name().c_str());
259799 : #endif
259800 :
259801 0 : p_type_name = type_name;
259802 :
259803 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
259804 :
259805 : #if 0
259806 : // DQ (7/30/2014): Call a virtual function.
259807 : std::string s = this->class_name();
259808 : #endif
259809 :
259810 : // Test the variant virtual function
259811 : // assert(TYPE_REF == variant());
259812 0 : assert(TYPE_REF == this->variant());
259813 0 : ROSE_ASSERT(TYPE_REF == (int)(this->variantT()));
259814 0 : post_construction_initialization();
259815 :
259816 : // Test the isSgRefExp() function since it has been problematic
259817 0 : assert(isSgRefExp(this) != NULL);
259818 0 : }
259819 :
259820 : // Generated constructor (all data members)
259821 :
259822 : /* #line 259823 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259823 :
259824 :
259825 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
259826 :
259827 :
259828 : // ********************************************************
259829 : // member functions common across all array grammar objects
259830 : // ********************************************************
259831 :
259832 :
259833 :
259834 : /* #line 259835 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259835 :
259836 :
259837 :
259838 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
259839 :
259840 : // ********************************************************
259841 : // member functions specific to each node in the grammar
259842 : // ********************************************************
259843 :
259844 :
259845 : /* #line 259846 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
259846 :
259847 : // Start of memberFunctionString
259848 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259849 :
259850 : void
259851 21814 : SgInitializer::post_construction_initialization()
259852 : {
259853 21814 : }
259854 :
259855 :
259856 :
259857 : // End of memberFunctionString
259858 : // Start of memberFunctionString
259859 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
259860 :
259861 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
259862 :
259863 : bool
259864 6125 : SgInitializer::get_is_explicit_cast () const
259865 : {
259866 6125 : ROSE_ASSERT (this != NULL);
259867 :
259868 : #if 0
259869 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259870 : // used to trigger marking transformations for the token-based unparsing.
259871 : printf ("SgInitializer::get_is_explicit_cast = %p = %s \n",this,this->class_name().c_str());
259872 : #endif
259873 :
259874 6125 : return p_is_explicit_cast;
259875 : }
259876 :
259877 : void
259878 3144 : SgInitializer::set_is_explicit_cast ( bool is_explicit_cast )
259879 : {
259880 3144 : ROSE_ASSERT (this != NULL);
259881 :
259882 : #if 0
259883 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259884 : // used to trigger marking transformations for the token-based unparsing.
259885 : printf ("SgInitializer::set_is_explicit_cast = %p = %s \n",this,this->class_name().c_str());
259886 : #endif
259887 :
259888 3144 : set_isModified(true);
259889 :
259890 3144 : p_is_explicit_cast = is_explicit_cast;
259891 3144 : }
259892 :
259893 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
259894 :
259895 :
259896 : // End of memberFunctionString
259897 : // Start of memberFunctionString
259898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
259899 :
259900 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
259901 :
259902 : bool
259903 439 : SgInitializer::get_is_braced_initialized () const
259904 : {
259905 439 : ROSE_ASSERT (this != NULL);
259906 :
259907 : #if 0
259908 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259909 : // used to trigger marking transformations for the token-based unparsing.
259910 : printf ("SgInitializer::get_is_braced_initialized = %p = %s \n",this,this->class_name().c_str());
259911 : #endif
259912 :
259913 439 : return p_is_braced_initialized;
259914 : }
259915 :
259916 : void
259917 2416 : SgInitializer::set_is_braced_initialized ( bool is_braced_initialized )
259918 : {
259919 2416 : ROSE_ASSERT (this != NULL);
259920 :
259921 : #if 0
259922 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
259923 : // used to trigger marking transformations for the token-based unparsing.
259924 : printf ("SgInitializer::set_is_braced_initialized = %p = %s \n",this,this->class_name().c_str());
259925 : #endif
259926 :
259927 2416 : set_isModified(true);
259928 :
259929 2416 : p_is_braced_initialized = is_braced_initialized;
259930 2416 : }
259931 :
259932 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
259933 :
259934 :
259935 : // End of memberFunctionString
259936 : // Start of memberFunctionString
259937 : /* #line 7194 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
259938 :
259939 :
259940 :
259941 : // End of memberFunctionString
259942 : // Start of memberFunctionString
259943 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
259944 :
259945 : // *** COMMON CODE SECTION BEGINS HERE ***
259946 :
259947 : #if 0
259948 : int
259949 : SgInitializer::getVariant() const
259950 : {
259951 : // This function is used in ROSE while "variant()" is used in SAGE
259952 : assert(this != NULL);
259953 : return variant();
259954 : }
259955 : #endif
259956 :
259957 : // This function is used in ROSE in treeTraversal code
259958 : // eventually replaces getVariant() and variant()
259959 : // though after variant() has been removed for a while we will
259960 : // want to change the name of variantT() back to variant()
259961 : // (since the "T" was ment to stand for temporary).
259962 : // When this happens the variantT() will be depricated.
259963 : VariantT
259964 65442 : SgInitializer::variantT() const
259965 : {
259966 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
259967 65442 : ROSE_ASSERT(this != NULL);
259968 65442 : return V_SgInitializer;
259969 : }
259970 :
259971 : #if 0
259972 : int
259973 : SgInitializer::variant() const
259974 : {
259975 : // This function is used in SAGE
259976 : ROSE_ASSERT(this != NULL);
259977 : return EXPR_INIT;
259978 : }
259979 : #endif
259980 :
259981 : ROSE_DLL_API const char*
259982 0 : SgInitializer::sage_class_name() const
259983 : {
259984 0 : ROSE_ASSERT(this != NULL);
259985 0 : return "SgInitializer";
259986 : }
259987 :
259988 : std::string
259989 0 : SgInitializer::class_name() const
259990 : {
259991 0 : ROSE_ASSERT(this != NULL);
259992 0 : return "SgInitializer";
259993 : }
259994 :
259995 : // DQ (11/26/2005): Support for visitor pattern mechanims
259996 : // (inferior to ROSE traversal mechanism, experimental).
259997 : void
259998 0 : SgInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
259999 : {
260000 0 : ROSE_ASSERT(this != NULL);
260001 0 : visitor.visit(this);
260002 0 : }
260003 :
260004 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
260005 0 : void SgInitializer::accept (ROSE_VisitorPattern & visitor) {
260006 0 : ROSE_ASSERT(this != NULL);
260007 0 : visitor.visit(this);
260008 0 : }
260009 :
260010 : SgInitializer*
260011 0 : SgInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
260012 : {
260013 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
260014 : // This function is currently only supported for the AST used the represent Binary executables.
260015 : if (0 /* isSgAsmNode(this) != NULL */)
260016 : {
260017 : // Support for regex specification.
260018 : std::string prefixCode = "REGEX:";
260019 : addNewAttribute(prefixCode + s,a);
260020 : }
260021 : #endif
260022 :
260023 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
260024 0 : return this;
260025 : }
260026 :
260027 : // *** COMMON CODE SECTION ENDS HERE ***
260028 :
260029 :
260030 : // End of memberFunctionString
260031 : // Start of memberFunctionString
260032 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
260033 :
260034 :
260035 : #if 0
260036 : //! Error checking support
260037 : /*! Verifies the following:
260038 : - working getVariant() member function
260039 : - calls base class's error() member function
260040 : Every class has one of these functions.
260041 : */
260042 : bool
260043 : SgInitializer::error()
260044 : {
260045 : // Put error checking here
260046 :
260047 : ROSE_ASSERT (this != NULL);
260048 : if (getVariant() != EXPR_INIT)
260049 : {
260050 : printf ("Error in SgInitializer::error(): SgInitializer object has a %s variant \n",
260051 : Cxx_GrammarTerminalNames[getVariant()].name);
260052 : // printf ("Error in SgInitializer::error() \n");
260053 : ROSE_ABORT();
260054 : }
260055 :
260056 : ROSE_ASSERT (getVariant() == EXPR_INIT);
260057 : return SgExpression::error();
260058 : }
260059 : #endif
260060 :
260061 :
260062 :
260063 : // End of memberFunctionString
260064 :
260065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
260066 :
260067 47597 : SgInitializer* isSgInitializer ( SgNode* inputDerivedClassPointer )
260068 : {
260069 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
260070 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
260071 : // So to fix this we return NULL directly when the input is NULL and avoid the
260072 : // dynamic_cast in this case. This is likely a performance improvement as well.
260073 : // return dynamic_cast<SgInitializer*>(inputDerivedClassPointer);
260074 : // Milind Chabbi (8/28/2013): isSgInitializer uses table-driven castability instead of c++ default dynamic_cast
260075 : // this improves the running time performance by 10-20%.
260076 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgInitializer*>(inputDerivedClassPointer);
260077 47597 : return IS_SgInitializer_FAST_MACRO(inputDerivedClassPointer);
260078 : }
260079 :
260080 : // DQ (11/8/2003): Added version of functions taking const pointer
260081 0 : const SgInitializer* isSgInitializer ( const SgNode* inputDerivedClassPointer )
260082 : {
260083 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
260084 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
260085 : // So to fix this we return NULL directly when the input is NULL and avoid the
260086 : // dynamic_cast in this case. This is likely a performance improvement as well.
260087 : // return dynamic_cast<const SgInitializer*>(inputDerivedClassPointer);
260088 : // Milind Chabbi (8/28/2013): isSgInitializer uses table-driven castability instead of c++ default dynamic_cast
260089 : // this improves the running time performance by 10-20%.
260090 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgInitializer*>(inputDerivedClassPointer);
260091 0 : return IS_SgInitializer_FAST_MACRO(inputDerivedClassPointer);
260092 : }
260093 :
260094 :
260095 :
260096 : /* #line 260097 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260097 :
260098 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
260099 :
260100 : /**
260101 : \brief Generated destructor
260102 :
260103 : This destructor is automatically generated (by ROSETTA). This destructor
260104 : only frees memory of data members associated with the parts of the current IR node which
260105 : are NOT traversed. Those data members that are part of a traversal can be freed using
260106 : a traversal (calling this destructor on all children in a post-order traversal). Such
260107 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
260108 :
260109 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
260110 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
260111 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
260112 :
260113 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
260114 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
260115 : pointers are not yet implemented to call delete on eash pointer in the container.
260116 : (This could be done by derivation from the STL containers to define containers that
260117 : automatically deleted their members.)
260118 :
260119 : */
260120 4144 : SgInitializer::~SgInitializer () {
260121 4144 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
260122 :
260123 :
260124 : // case: not a listType for is_explicit_cast
260125 4144 : p_is_explicit_cast = true; // non list case
260126 : // case: not a listType for is_braced_initialized
260127 4144 : p_is_braced_initialized = false; // non list case
260128 :
260129 : }
260130 :
260131 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
260132 4144 : }
260133 :
260134 :
260135 : /* #line 260136 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260136 :
260137 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
260138 :
260139 : // Generated constructor
260140 56 : SgInitializer::SgInitializer ( Sg_File_Info* startOfConstruct )
260141 56 : : SgExpression(startOfConstruct)
260142 : {
260143 : #ifdef DEBUG
260144 : // printf ("In SgInitializer::SgInitializer (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
260145 : #endif
260146 : #if 0
260147 : // debugging information!
260148 : printf ("In SgInitializer::SgInitializer (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
260149 : #endif
260150 :
260151 56 : p_is_explicit_cast = true;
260152 56 : p_is_braced_initialized = false;
260153 :
260154 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
260155 :
260156 : #if 0
260157 : // DQ (7/30/2014): Call a virtual function.
260158 : std::string s = this->class_name();
260159 : #endif
260160 :
260161 : // Test the variant virtual function
260162 : // assert(EXPR_INIT == variant());
260163 56 : assert(EXPR_INIT == this->variant());
260164 56 : ROSE_ASSERT(EXPR_INIT == (int)(this->variantT()));
260165 56 : post_construction_initialization();
260166 :
260167 : // Test the isSgInitializer() function since it has been problematic
260168 56 : assert(isSgInitializer(this) != NULL);
260169 56 : }
260170 :
260171 : // Generated constructor (all data members)
260172 :
260173 : /* #line 260174 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260174 :
260175 :
260176 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
260177 :
260178 :
260179 : // ********************************************************
260180 : // member functions common across all array grammar objects
260181 : // ********************************************************
260182 :
260183 :
260184 :
260185 : /* #line 260186 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260186 :
260187 :
260188 :
260189 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
260190 :
260191 : // ********************************************************
260192 : // member functions specific to each node in the grammar
260193 : // ********************************************************
260194 :
260195 :
260196 : /* #line 260197 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260197 :
260198 : // Start of memberFunctionString
260199 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260200 :
260201 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260202 :
260203 : SgExprListExp*
260204 614 : SgAggregateInitializer::get_initializers () const
260205 : {
260206 614 : ROSE_ASSERT (this != NULL);
260207 :
260208 : #if 0
260209 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260210 : // used to trigger marking transformations for the token-based unparsing.
260211 : printf ("SgAggregateInitializer::get_initializers = %p = %s \n",this,this->class_name().c_str());
260212 : #endif
260213 :
260214 614 : return p_initializers;
260215 : }
260216 :
260217 : void
260218 0 : SgAggregateInitializer::set_initializers ( SgExprListExp* initializers )
260219 : {
260220 0 : ROSE_ASSERT (this != NULL);
260221 :
260222 : #if 0
260223 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260224 : // used to trigger marking transformations for the token-based unparsing.
260225 : printf ("SgAggregateInitializer::set_initializers = %p = %s \n",this,this->class_name().c_str());
260226 : #endif
260227 :
260228 0 : set_isModified(true);
260229 :
260230 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
260231 : if (p_initializers != NULL && initializers != NULL && p_initializers != initializers)
260232 : {
260233 : printf ("Warning: initializers = %p overwriting valid pointer p_initializers = %p \n",initializers,p_initializers);
260234 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
260235 : printf ("Error fails assertion (p_initializers != NULL && initializers != NULL && p_initializers != initializers) is false\n");
260236 : ROSE_ASSERT(false);
260237 : #endif
260238 : }
260239 : #endif
260240 0 : p_initializers = initializers;
260241 0 : }
260242 :
260243 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
260244 :
260245 :
260246 : // End of memberFunctionString
260247 : // Start of memberFunctionString
260248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260249 :
260250 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260251 :
260252 : SgType*
260253 0 : SgAggregateInitializer::get_expression_type () const
260254 : {
260255 0 : ROSE_ASSERT (this != NULL);
260256 :
260257 : #if 0
260258 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260259 : // used to trigger marking transformations for the token-based unparsing.
260260 : printf ("SgAggregateInitializer::get_expression_type = %p = %s \n",this,this->class_name().c_str());
260261 : #endif
260262 :
260263 0 : return p_expression_type;
260264 : }
260265 :
260266 : void
260267 0 : SgAggregateInitializer::set_expression_type ( SgType* expression_type )
260268 : {
260269 0 : ROSE_ASSERT (this != NULL);
260270 :
260271 : #if 0
260272 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260273 : // used to trigger marking transformations for the token-based unparsing.
260274 : printf ("SgAggregateInitializer::set_expression_type = %p = %s \n",this,this->class_name().c_str());
260275 : #endif
260276 :
260277 0 : set_isModified(true);
260278 :
260279 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
260280 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
260281 : {
260282 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
260283 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
260284 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
260285 : ROSE_ASSERT(false);
260286 : #endif
260287 : }
260288 : #endif
260289 0 : p_expression_type = expression_type;
260290 0 : }
260291 :
260292 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
260293 :
260294 :
260295 : // End of memberFunctionString
260296 : // Start of memberFunctionString
260297 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260298 :
260299 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260300 :
260301 : bool
260302 49 : SgAggregateInitializer::get_need_explicit_braces () const
260303 : {
260304 49 : ROSE_ASSERT (this != NULL);
260305 :
260306 : #if 0
260307 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260308 : // used to trigger marking transformations for the token-based unparsing.
260309 : printf ("SgAggregateInitializer::get_need_explicit_braces = %p = %s \n",this,this->class_name().c_str());
260310 : #endif
260311 :
260312 49 : return p_need_explicit_braces;
260313 : }
260314 :
260315 : void
260316 544 : SgAggregateInitializer::set_need_explicit_braces ( bool need_explicit_braces )
260317 : {
260318 544 : ROSE_ASSERT (this != NULL);
260319 :
260320 : #if 0
260321 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260322 : // used to trigger marking transformations for the token-based unparsing.
260323 : printf ("SgAggregateInitializer::set_need_explicit_braces = %p = %s \n",this,this->class_name().c_str());
260324 : #endif
260325 :
260326 544 : set_isModified(true);
260327 :
260328 544 : p_need_explicit_braces = need_explicit_braces;
260329 544 : }
260330 :
260331 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
260332 :
260333 :
260334 : // End of memberFunctionString
260335 : // Start of memberFunctionString
260336 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260337 :
260338 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260339 :
260340 : bool
260341 49 : SgAggregateInitializer::get_uses_compound_literal () const
260342 : {
260343 49 : ROSE_ASSERT (this != NULL);
260344 :
260345 : #if 0
260346 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260347 : // used to trigger marking transformations for the token-based unparsing.
260348 : printf ("SgAggregateInitializer::get_uses_compound_literal = %p = %s \n",this,this->class_name().c_str());
260349 : #endif
260350 :
260351 49 : return p_uses_compound_literal;
260352 : }
260353 :
260354 : void
260355 272 : SgAggregateInitializer::set_uses_compound_literal ( bool uses_compound_literal )
260356 : {
260357 272 : ROSE_ASSERT (this != NULL);
260358 :
260359 : #if 0
260360 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260361 : // used to trigger marking transformations for the token-based unparsing.
260362 : printf ("SgAggregateInitializer::set_uses_compound_literal = %p = %s \n",this,this->class_name().c_str());
260363 : #endif
260364 :
260365 272 : set_isModified(true);
260366 :
260367 272 : p_uses_compound_literal = uses_compound_literal;
260368 272 : }
260369 :
260370 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
260371 :
260372 :
260373 : // End of memberFunctionString
260374 : // Start of memberFunctionString
260375 :
260376 :
260377 : // End of memberFunctionString
260378 : // Start of memberFunctionString
260379 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260380 :
260381 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260382 :
260383 : SgExpression*
260384 630 : SgAggregateInitializer::get_originalExpressionTree () const
260385 : {
260386 630 : ROSE_ASSERT (this != NULL);
260387 :
260388 : #if 0
260389 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260390 : // used to trigger marking transformations for the token-based unparsing.
260391 : printf ("SgAggregateInitializer::get_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
260392 : #endif
260393 :
260394 630 : return p_originalExpressionTree;
260395 : }
260396 :
260397 : void
260398 96 : SgAggregateInitializer::set_originalExpressionTree ( SgExpression* originalExpressionTree )
260399 : {
260400 96 : ROSE_ASSERT (this != NULL);
260401 :
260402 : #if 0
260403 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260404 : // used to trigger marking transformations for the token-based unparsing.
260405 : printf ("SgAggregateInitializer::set_originalExpressionTree = %p = %s \n",this,this->class_name().c_str());
260406 : #endif
260407 :
260408 96 : set_isModified(true);
260409 :
260410 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
260411 : if (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree)
260412 : {
260413 : printf ("Warning: originalExpressionTree = %p overwriting valid pointer p_originalExpressionTree = %p \n",originalExpressionTree,p_originalExpressionTree);
260414 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
260415 : printf ("Error fails assertion (p_originalExpressionTree != NULL && originalExpressionTree != NULL && p_originalExpressionTree != originalExpressionTree) is false\n");
260416 : ROSE_ASSERT(false);
260417 : #endif
260418 : }
260419 : #endif
260420 96 : p_originalExpressionTree = originalExpressionTree;
260421 96 : }
260422 :
260423 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
260424 :
260425 :
260426 : // End of memberFunctionString
260427 : // Start of memberFunctionString
260428 : /* #line 7198 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
260429 :
260430 :
260431 : void
260432 272 : SgAggregateInitializer::post_construction_initialization()
260433 : {
260434 272 : if (get_initializers())
260435 272 : get_initializers()->set_parent(this);
260436 272 : }
260437 :
260438 : // DQ: trying to remove the nested iterator class
260439 : void
260440 0 : SgAggregateInitializer::append_initializer(SgExpression* what)
260441 : {
260442 0 : assert(this != NULL);
260443 :
260444 : // DQ (11/15/2006): avoid setting newArgs this late in the process.
260445 0 : ROSE_ASSERT(p_initializers != NULL);
260446 0 : if(!p_initializers)
260447 : {
260448 : // set_initializers(new SgExprListExp(this->get_file_info()));
260449 : SgExprListExp* newArgs = new SgExprListExp ( this->get_file_info() );
260450 : assert(newArgs != NULL);
260451 : newArgs->set_endOfConstruct( this->get_file_info() );
260452 : set_initializers(newArgs);
260453 : }
260454 :
260455 : // insert_initializer(p_initializers->end(),what);
260456 0 : p_initializers->append_expression(what);
260457 0 : }
260458 :
260459 : SgExpression*
260460 0 : SgAggregateInitializer::get_next(int& n) const
260461 : {
260462 0 : if(n==0)
260463 : {
260464 0 : n++;
260465 0 : return get_initializers();
260466 : }
260467 : else
260468 : return 0;
260469 : }
260470 :
260471 : int
260472 0 : SgAggregateInitializer::replace_expression(SgExpression* o, SgExpression* n)
260473 : {
260474 : // DQ (12/17/2006): This function should have the semantics that it will represent a
260475 : // structural change to the AST, thus it is free to set the parent of the new expression.
260476 :
260477 0 : ROSE_ASSERT(o != NULL);
260478 0 : ROSE_ASSERT(n != NULL);
260479 :
260480 0 : if (get_initializers() == o)
260481 : {
260482 0 : set_initializers(isSgExprListExp(n));
260483 0 : n->set_parent(this);
260484 0 : return 1;
260485 : }
260486 : else
260487 : {
260488 : return 0;
260489 : }
260490 : }
260491 :
260492 : SgType*
260493 107 : SgAggregateInitializer::get_type() const
260494 : {
260495 : #if 0
260496 : printf ("In SgAggregateInitializer::get_type() \n");
260497 : #endif
260498 :
260499 : #if 0
260500 : printf ("In SgAggregateInitializer::get_type(): p_expression_type = %p \n",p_expression_type);
260501 : #endif
260502 107 : if (p_expression_type != NULL)
260503 : {
260504 : #if 0
260505 : printf ("SgAggregateInitializer::get_type(): p_expression_type != NULL: return p_expression_type = %p = %s \n",p_expression_type,p_expression_type->class_name().c_str());
260506 : #endif
260507 : return p_expression_type;
260508 : }
260509 : else
260510 : {
260511 : #if 0
260512 : printf ("SgAggregateInitializer::get_type(): default case: return SgTypeDefault::createType()\n");
260513 : #endif
260514 0 : return SgTypeDefault::createType();
260515 : }
260516 : }
260517 :
260518 : // DQ (6/11/2015): Moved these eight access functions, they should not be generated by ROSETTA
260519 : // so that we could avoid them setting the isModified flag which is a problem in the
260520 : // name qualification support for C++ (interfering with the token-based unparsing).
260521 : #if 1
260522 : bool
260523 0 : SgAggregateInitializer::get_requiresGlobalNameQualificationOnType () const
260524 : {
260525 0 : ROSE_ASSERT (this != NULL);
260526 0 : return p_requiresGlobalNameQualificationOnType;
260527 : }
260528 :
260529 : void
260530 0 : SgAggregateInitializer::set_requiresGlobalNameQualificationOnType ( bool requiresGlobalNameQualificationOnType )
260531 : {
260532 0 : ROSE_ASSERT (this != NULL);
260533 : // This can't be called by the name qualification API (see test2015_26.C).
260534 : // set_isModified(true);
260535 :
260536 0 : p_requiresGlobalNameQualificationOnType = requiresGlobalNameQualificationOnType;
260537 0 : }
260538 :
260539 : int
260540 0 : SgAggregateInitializer::get_name_qualification_length_for_type () const
260541 : {
260542 0 : ROSE_ASSERT (this != NULL);
260543 0 : return p_name_qualification_length_for_type;
260544 : }
260545 :
260546 : void
260547 11 : SgAggregateInitializer::set_name_qualification_length_for_type ( int name_qualification_length_for_type )
260548 : {
260549 11 : ROSE_ASSERT (this != NULL);
260550 : // This can't be called by the name qualification API (see test2015_26.C).
260551 : // set_isModified(true);
260552 :
260553 11 : p_name_qualification_length_for_type = name_qualification_length_for_type;
260554 11 : }
260555 :
260556 : bool
260557 0 : SgAggregateInitializer::get_type_elaboration_required_for_type () const
260558 : {
260559 0 : ROSE_ASSERT (this != NULL);
260560 0 : return p_type_elaboration_required_for_type;
260561 : }
260562 :
260563 : void
260564 11 : SgAggregateInitializer::set_type_elaboration_required_for_type ( bool type_elaboration_required_for_type )
260565 : {
260566 11 : ROSE_ASSERT (this != NULL);
260567 : // This can't be called by the name qualification API (see test2015_26.C).
260568 : // set_isModified(true);
260569 :
260570 11 : p_type_elaboration_required_for_type = type_elaboration_required_for_type;
260571 11 : }
260572 :
260573 : bool
260574 0 : SgAggregateInitializer::get_global_qualification_required_for_type () const
260575 : {
260576 0 : ROSE_ASSERT (this != NULL);
260577 0 : return p_global_qualification_required_for_type;
260578 : }
260579 :
260580 : void
260581 11 : SgAggregateInitializer::set_global_qualification_required_for_type ( bool global_qualification_required_for_type )
260582 : {
260583 11 : ROSE_ASSERT (this != NULL);
260584 : // This can't be called by the name qualification API (see test2015_26.C).
260585 : // set_isModified(true);
260586 :
260587 11 : p_global_qualification_required_for_type = global_qualification_required_for_type;
260588 11 : }
260589 : #else
260590 : // DQ (3/22/2018): The names of the data members have been renamed to support the name qualification support
260591 : // using the same support as for the SgConstructor initializer. The name qualification that is supported for
260592 : // an aggregate initializer is just that for the C++11 specific type specifier that is sometime required
260593 : // (for an example of this see Cxx11_tests/test2018_47.C). Since it is the type name that is qualified
260594 : // it does make sens to use the original names (e.g. name_qualification_length_for_type), but it would be
260595 : // inconsistant with the constructor initializer support, and eliminate the opportunity to reuse that
260596 : // supporting name qualification code.
260597 : int
260598 : SgAggregateInitializer::get_name_qualification_length () const
260599 : {
260600 : ROSE_ASSERT (this != NULL);
260601 : return p_name_qualification_length;
260602 : }
260603 :
260604 : void
260605 : SgAggregateInitializer::set_name_qualification_length ( int name_qualification_length )
260606 : {
260607 : ROSE_ASSERT (this != NULL);
260608 : // This can't be called by the name qualification API (see test2015_26.C).
260609 : // set_isModified(true);
260610 :
260611 : p_name_qualification_length = name_qualification_length;
260612 : }
260613 :
260614 : bool
260615 : SgAggregateInitializer::get_type_elaboration_required () const
260616 : {
260617 : ROSE_ASSERT (this != NULL);
260618 : return p_type_elaboration_required;
260619 : }
260620 :
260621 : void
260622 : SgAggregateInitializer::set_type_elaboration_required ( bool type_elaboration_required )
260623 : {
260624 : ROSE_ASSERT (this != NULL);
260625 : // This can't be called by the name qualification API (see test2015_26.C).
260626 : // set_isModified(true);
260627 :
260628 : p_type_elaboration_required = type_elaboration_required;
260629 : }
260630 :
260631 : bool
260632 : SgAggregateInitializer::get_global_qualification_required () const
260633 : {
260634 : ROSE_ASSERT (this != NULL);
260635 : return p_global_qualification_required;
260636 : }
260637 :
260638 : void
260639 : SgAggregateInitializer::set_global_qualification_required ( bool global_qualification_required )
260640 : {
260641 : ROSE_ASSERT (this != NULL);
260642 : // This can't be called by the name qualification API (see test2015_26.C).
260643 : // set_isModified(true);
260644 :
260645 : p_global_qualification_required = global_qualification_required;
260646 : }
260647 : #endif
260648 :
260649 :
260650 :
260651 : // End of memberFunctionString
260652 : // Start of memberFunctionString
260653 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
260654 :
260655 : // *** COMMON CODE SECTION BEGINS HERE ***
260656 :
260657 : #if 0
260658 : int
260659 : SgAggregateInitializer::getVariant() const
260660 : {
260661 : // This function is used in ROSE while "variant()" is used in SAGE
260662 : assert(this != NULL);
260663 : return variant();
260664 : }
260665 : #endif
260666 :
260667 : // This function is used in ROSE in treeTraversal code
260668 : // eventually replaces getVariant() and variant()
260669 : // though after variant() has been removed for a while we will
260670 : // want to change the name of variantT() back to variant()
260671 : // (since the "T" was ment to stand for temporary).
260672 : // When this happens the variantT() will be depricated.
260673 : VariantT
260674 23742 : SgAggregateInitializer::variantT() const
260675 : {
260676 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
260677 23742 : ROSE_ASSERT(this != NULL);
260678 23742 : return V_SgAggregateInitializer;
260679 : }
260680 :
260681 : #if 0
260682 : int
260683 : SgAggregateInitializer::variant() const
260684 : {
260685 : // This function is used in SAGE
260686 : ROSE_ASSERT(this != NULL);
260687 : return AGGREGATE_INIT;
260688 : }
260689 : #endif
260690 :
260691 : ROSE_DLL_API const char*
260692 0 : SgAggregateInitializer::sage_class_name() const
260693 : {
260694 0 : ROSE_ASSERT(this != NULL);
260695 0 : return "SgAggregateInitializer";
260696 : }
260697 :
260698 : std::string
260699 70 : SgAggregateInitializer::class_name() const
260700 : {
260701 70 : ROSE_ASSERT(this != NULL);
260702 70 : return "SgAggregateInitializer";
260703 : }
260704 :
260705 : // DQ (11/26/2005): Support for visitor pattern mechanims
260706 : // (inferior to ROSE traversal mechanism, experimental).
260707 : void
260708 411 : SgAggregateInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
260709 : {
260710 411 : ROSE_ASSERT(this != NULL);
260711 411 : visitor.visit(this);
260712 411 : }
260713 :
260714 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
260715 0 : void SgAggregateInitializer::accept (ROSE_VisitorPattern & visitor) {
260716 0 : ROSE_ASSERT(this != NULL);
260717 0 : visitor.visit(this);
260718 0 : }
260719 :
260720 : SgAggregateInitializer*
260721 0 : SgAggregateInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
260722 : {
260723 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
260724 : // This function is currently only supported for the AST used the represent Binary executables.
260725 : if (0 /* isSgAsmNode(this) != NULL */)
260726 : {
260727 : // Support for regex specification.
260728 : std::string prefixCode = "REGEX:";
260729 : addNewAttribute(prefixCode + s,a);
260730 : }
260731 : #endif
260732 :
260733 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
260734 0 : return this;
260735 : }
260736 :
260737 : // *** COMMON CODE SECTION ENDS HERE ***
260738 :
260739 :
260740 : // End of memberFunctionString
260741 : // Start of memberFunctionString
260742 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
260743 :
260744 :
260745 : #if 0
260746 : //! Error checking support
260747 : /*! Verifies the following:
260748 : - working getVariant() member function
260749 : - calls base class's error() member function
260750 : Every class has one of these functions.
260751 : */
260752 : bool
260753 : SgAggregateInitializer::error()
260754 : {
260755 : // Put error checking here
260756 :
260757 : ROSE_ASSERT (this != NULL);
260758 : if (getVariant() != AGGREGATE_INIT)
260759 : {
260760 : printf ("Error in SgAggregateInitializer::error(): SgAggregateInitializer object has a %s variant \n",
260761 : Cxx_GrammarTerminalNames[getVariant()].name);
260762 : // printf ("Error in SgAggregateInitializer::error() \n");
260763 : ROSE_ABORT();
260764 : }
260765 :
260766 : ROSE_ASSERT (getVariant() == AGGREGATE_INIT);
260767 : return SgInitializer::error();
260768 : }
260769 : #endif
260770 :
260771 :
260772 :
260773 : // End of memberFunctionString
260774 :
260775 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
260776 :
260777 9823850 : SgAggregateInitializer* isSgAggregateInitializer ( SgNode* inputDerivedClassPointer )
260778 : {
260779 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
260780 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
260781 : // So to fix this we return NULL directly when the input is NULL and avoid the
260782 : // dynamic_cast in this case. This is likely a performance improvement as well.
260783 : // return dynamic_cast<SgAggregateInitializer*>(inputDerivedClassPointer);
260784 : // Milind Chabbi (8/28/2013): isSgAggregateInitializer uses table-driven castability instead of c++ default dynamic_cast
260785 : // this improves the running time performance by 10-20%.
260786 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAggregateInitializer*>(inputDerivedClassPointer);
260787 9823850 : return IS_SgAggregateInitializer_FAST_MACRO(inputDerivedClassPointer);
260788 : }
260789 :
260790 : // DQ (11/8/2003): Added version of functions taking const pointer
260791 21 : const SgAggregateInitializer* isSgAggregateInitializer ( const SgNode* inputDerivedClassPointer )
260792 : {
260793 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
260794 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
260795 : // So to fix this we return NULL directly when the input is NULL and avoid the
260796 : // dynamic_cast in this case. This is likely a performance improvement as well.
260797 : // return dynamic_cast<const SgAggregateInitializer*>(inputDerivedClassPointer);
260798 : // Milind Chabbi (8/28/2013): isSgAggregateInitializer uses table-driven castability instead of c++ default dynamic_cast
260799 : // this improves the running time performance by 10-20%.
260800 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAggregateInitializer*>(inputDerivedClassPointer);
260801 21 : return IS_SgAggregateInitializer_FAST_MACRO(inputDerivedClassPointer);
260802 : }
260803 :
260804 :
260805 :
260806 : /* #line 260807 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260807 :
260808 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
260809 :
260810 : /**
260811 : \brief Generated destructor
260812 :
260813 : This destructor is automatically generated (by ROSETTA). This destructor
260814 : only frees memory of data members associated with the parts of the current IR node which
260815 : are NOT traversed. Those data members that are part of a traversal can be freed using
260816 : a traversal (calling this destructor on all children in a post-order traversal). Such
260817 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
260818 :
260819 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
260820 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
260821 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
260822 :
260823 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
260824 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
260825 : pointers are not yet implemented to call delete on eash pointer in the container.
260826 : (This could be done by derivation from the STL containers to define containers that
260827 : automatically deleted their members.)
260828 :
260829 : */
260830 396 : SgAggregateInitializer::~SgAggregateInitializer () {
260831 198 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
260832 :
260833 :
260834 : // case: not a listType for initializers
260835 198 : p_initializers = NULL; // non list case
260836 : // case: not a listType for expression_type
260837 198 : p_expression_type = NULL; // non list case
260838 : // case: not a listType for need_explicit_braces
260839 198 : p_need_explicit_braces = true; // non list case
260840 : // case: not a listType for uses_compound_literal
260841 198 : p_uses_compound_literal = false; // non list case
260842 : // case: not a listType for requiresGlobalNameQualificationOnType
260843 198 : p_requiresGlobalNameQualificationOnType = false; // non list case
260844 : // case: not a listType for name_qualification_length_for_type
260845 198 : p_name_qualification_length_for_type = 0; // non list case
260846 : // case: not a listType for type_elaboration_required_for_type
260847 198 : p_type_elaboration_required_for_type = false; // non list case
260848 : // case: not a listType for global_qualification_required_for_type
260849 198 : p_global_qualification_required_for_type = false; // non list case
260850 : // case: not a listType for originalExpressionTree
260851 198 : p_originalExpressionTree = NULL; // non list case
260852 :
260853 : }
260854 :
260855 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
260856 396 : }
260857 :
260858 :
260859 : /* #line 260860 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260860 :
260861 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
260862 :
260863 : // Generated constructor
260864 0 : SgAggregateInitializer::SgAggregateInitializer ( Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type )
260865 0 : : SgInitializer(startOfConstruct)
260866 : {
260867 : #ifdef DEBUG
260868 : // printf ("In SgAggregateInitializer::SgAggregateInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
260869 : #endif
260870 : #if 0
260871 : // debugging information!
260872 : printf ("In SgAggregateInitializer::SgAggregateInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
260873 : #endif
260874 :
260875 0 : p_initializers = initializers;
260876 0 : p_expression_type = expression_type;
260877 0 : p_need_explicit_braces = true;
260878 0 : p_uses_compound_literal = false;
260879 0 : p_requiresGlobalNameQualificationOnType = false;
260880 0 : p_name_qualification_length_for_type = 0;
260881 0 : p_type_elaboration_required_for_type = false;
260882 0 : p_global_qualification_required_for_type = false;
260883 0 : p_originalExpressionTree = NULL;
260884 :
260885 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
260886 :
260887 : #if 0
260888 : // DQ (7/30/2014): Call a virtual function.
260889 : std::string s = this->class_name();
260890 : #endif
260891 :
260892 : // Test the variant virtual function
260893 : // assert(AGGREGATE_INIT == variant());
260894 0 : assert(AGGREGATE_INIT == this->variant());
260895 0 : ROSE_ASSERT(AGGREGATE_INIT == (int)(this->variantT()));
260896 0 : post_construction_initialization();
260897 :
260898 : // Test the isSgAggregateInitializer() function since it has been problematic
260899 0 : assert(isSgAggregateInitializer(this) != NULL);
260900 0 : }
260901 :
260902 : // Generated constructor (all data members)
260903 :
260904 : /* #line 260905 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260905 :
260906 :
260907 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
260908 :
260909 :
260910 : // ********************************************************
260911 : // member functions common across all array grammar objects
260912 : // ********************************************************
260913 :
260914 :
260915 :
260916 : /* #line 260917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260917 :
260918 :
260919 :
260920 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
260921 :
260922 : // ********************************************************
260923 : // member functions specific to each node in the grammar
260924 : // ********************************************************
260925 :
260926 :
260927 : /* #line 260928 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
260928 :
260929 : // Start of memberFunctionString
260930 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260931 :
260932 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260933 :
260934 : SgExprListExp*
260935 0 : SgCompoundInitializer::get_initializers () const
260936 : {
260937 0 : ROSE_ASSERT (this != NULL);
260938 :
260939 : #if 0
260940 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260941 : // used to trigger marking transformations for the token-based unparsing.
260942 : printf ("SgCompoundInitializer::get_initializers = %p = %s \n",this,this->class_name().c_str());
260943 : #endif
260944 :
260945 0 : return p_initializers;
260946 : }
260947 :
260948 : void
260949 0 : SgCompoundInitializer::set_initializers ( SgExprListExp* initializers )
260950 : {
260951 0 : ROSE_ASSERT (this != NULL);
260952 :
260953 : #if 0
260954 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260955 : // used to trigger marking transformations for the token-based unparsing.
260956 : printf ("SgCompoundInitializer::set_initializers = %p = %s \n",this,this->class_name().c_str());
260957 : #endif
260958 :
260959 0 : set_isModified(true);
260960 :
260961 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
260962 : if (p_initializers != NULL && initializers != NULL && p_initializers != initializers)
260963 : {
260964 : printf ("Warning: initializers = %p overwriting valid pointer p_initializers = %p \n",initializers,p_initializers);
260965 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
260966 : printf ("Error fails assertion (p_initializers != NULL && initializers != NULL && p_initializers != initializers) is false\n");
260967 : ROSE_ASSERT(false);
260968 : #endif
260969 : }
260970 : #endif
260971 0 : p_initializers = initializers;
260972 0 : }
260973 :
260974 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
260975 :
260976 :
260977 : // End of memberFunctionString
260978 : // Start of memberFunctionString
260979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
260980 :
260981 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
260982 :
260983 : SgType*
260984 0 : SgCompoundInitializer::get_expression_type () const
260985 : {
260986 0 : ROSE_ASSERT (this != NULL);
260987 :
260988 : #if 0
260989 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
260990 : // used to trigger marking transformations for the token-based unparsing.
260991 : printf ("SgCompoundInitializer::get_expression_type = %p = %s \n",this,this->class_name().c_str());
260992 : #endif
260993 :
260994 0 : return p_expression_type;
260995 : }
260996 :
260997 : void
260998 0 : SgCompoundInitializer::set_expression_type ( SgType* expression_type )
260999 : {
261000 0 : ROSE_ASSERT (this != NULL);
261001 :
261002 : #if 0
261003 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261004 : // used to trigger marking transformations for the token-based unparsing.
261005 : printf ("SgCompoundInitializer::set_expression_type = %p = %s \n",this,this->class_name().c_str());
261006 : #endif
261007 :
261008 0 : set_isModified(true);
261009 :
261010 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
261011 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
261012 : {
261013 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
261014 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
261015 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
261016 : ROSE_ASSERT(false);
261017 : #endif
261018 : }
261019 : #endif
261020 0 : p_expression_type = expression_type;
261021 0 : }
261022 :
261023 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261024 :
261025 :
261026 : // End of memberFunctionString
261027 : // Start of memberFunctionString
261028 : /* #line 7421 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
261029 :
261030 :
261031 : void
261032 0 : SgCompoundInitializer::post_construction_initialization()
261033 : {
261034 0 : if (get_initializers())
261035 0 : get_initializers()->set_parent(this);
261036 0 : }
261037 :
261038 : // DQ: trying to remove the nested iterator class
261039 : void
261040 0 : SgCompoundInitializer::append_initializer(SgExpression* what)
261041 : {
261042 0 : assert(this != NULL);
261043 :
261044 : // DQ (11/15/2006): avoid setting newArgs this late in the process.
261045 0 : ROSE_ASSERT(p_initializers != NULL);
261046 0 : if(!p_initializers)
261047 : {
261048 : // set_initializers(new SgExprListExp(this->get_file_info()));
261049 : SgExprListExp* newArgs = new SgExprListExp ( this->get_file_info() );
261050 : assert(newArgs != NULL);
261051 : newArgs->set_endOfConstruct( this->get_file_info() );
261052 : set_initializers(newArgs);
261053 : }
261054 :
261055 : // insert_initializer(p_initializers->end(),what);
261056 0 : p_initializers->append_expression(what);
261057 0 : }
261058 :
261059 : SgExpression*
261060 0 : SgCompoundInitializer::get_next(int& n) const
261061 : {
261062 0 : if(n==0)
261063 : {
261064 0 : n++;
261065 0 : return get_initializers();
261066 : }
261067 : else
261068 : return 0;
261069 : }
261070 :
261071 : int
261072 0 : SgCompoundInitializer::replace_expression(SgExpression* o, SgExpression* n)
261073 : {
261074 : // DQ (12/17/2006): This function should have the semantics that it will represent a
261075 : // structural change to the AST, thus it is free to set the parent of the new expression.
261076 :
261077 0 : ROSE_ASSERT(o != NULL);
261078 0 : ROSE_ASSERT(n != NULL);
261079 :
261080 0 : if (get_initializers() == o)
261081 : {
261082 0 : set_initializers(isSgExprListExp(n));
261083 0 : n->set_parent(this);
261084 0 : return 1;
261085 : }
261086 : else
261087 : {
261088 : return 0;
261089 : }
261090 : }
261091 :
261092 : SgType*
261093 0 : SgCompoundInitializer::get_type() const
261094 : {
261095 : #if 0
261096 : printf ("In SgCompoundInitializer::get_type() \n");
261097 : #endif
261098 :
261099 0 : if (p_expression_type != NULL)
261100 : {
261101 : return p_expression_type;
261102 : }
261103 : else
261104 : {
261105 : // printf ("SgAggregateInitializer::get_type(): default case\n");
261106 0 : return SgTypeDefault::createType();
261107 : }
261108 : }
261109 :
261110 :
261111 :
261112 : // End of memberFunctionString
261113 : // Start of memberFunctionString
261114 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
261115 :
261116 : // *** COMMON CODE SECTION BEGINS HERE ***
261117 :
261118 : #if 0
261119 : int
261120 : SgCompoundInitializer::getVariant() const
261121 : {
261122 : // This function is used in ROSE while "variant()" is used in SAGE
261123 : assert(this != NULL);
261124 : return variant();
261125 : }
261126 : #endif
261127 :
261128 : // This function is used in ROSE in treeTraversal code
261129 : // eventually replaces getVariant() and variant()
261130 : // though after variant() has been removed for a while we will
261131 : // want to change the name of variantT() back to variant()
261132 : // (since the "T" was ment to stand for temporary).
261133 : // When this happens the variantT() will be depricated.
261134 : VariantT
261135 0 : SgCompoundInitializer::variantT() const
261136 : {
261137 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
261138 0 : ROSE_ASSERT(this != NULL);
261139 0 : return V_SgCompoundInitializer;
261140 : }
261141 :
261142 : #if 0
261143 : int
261144 : SgCompoundInitializer::variant() const
261145 : {
261146 : // This function is used in SAGE
261147 : ROSE_ASSERT(this != NULL);
261148 : return COMPOUND_INIT;
261149 : }
261150 : #endif
261151 :
261152 : ROSE_DLL_API const char*
261153 0 : SgCompoundInitializer::sage_class_name() const
261154 : {
261155 0 : ROSE_ASSERT(this != NULL);
261156 0 : return "SgCompoundInitializer";
261157 : }
261158 :
261159 : std::string
261160 0 : SgCompoundInitializer::class_name() const
261161 : {
261162 0 : ROSE_ASSERT(this != NULL);
261163 0 : return "SgCompoundInitializer";
261164 : }
261165 :
261166 : // DQ (11/26/2005): Support for visitor pattern mechanims
261167 : // (inferior to ROSE traversal mechanism, experimental).
261168 : void
261169 0 : SgCompoundInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
261170 : {
261171 0 : ROSE_ASSERT(this != NULL);
261172 0 : visitor.visit(this);
261173 0 : }
261174 :
261175 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
261176 0 : void SgCompoundInitializer::accept (ROSE_VisitorPattern & visitor) {
261177 0 : ROSE_ASSERT(this != NULL);
261178 0 : visitor.visit(this);
261179 0 : }
261180 :
261181 : SgCompoundInitializer*
261182 0 : SgCompoundInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
261183 : {
261184 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
261185 : // This function is currently only supported for the AST used the represent Binary executables.
261186 : if (0 /* isSgAsmNode(this) != NULL */)
261187 : {
261188 : // Support for regex specification.
261189 : std::string prefixCode = "REGEX:";
261190 : addNewAttribute(prefixCode + s,a);
261191 : }
261192 : #endif
261193 :
261194 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
261195 0 : return this;
261196 : }
261197 :
261198 : // *** COMMON CODE SECTION ENDS HERE ***
261199 :
261200 :
261201 : // End of memberFunctionString
261202 : // Start of memberFunctionString
261203 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
261204 :
261205 :
261206 : #if 0
261207 : //! Error checking support
261208 : /*! Verifies the following:
261209 : - working getVariant() member function
261210 : - calls base class's error() member function
261211 : Every class has one of these functions.
261212 : */
261213 : bool
261214 : SgCompoundInitializer::error()
261215 : {
261216 : // Put error checking here
261217 :
261218 : ROSE_ASSERT (this != NULL);
261219 : if (getVariant() != COMPOUND_INIT)
261220 : {
261221 : printf ("Error in SgCompoundInitializer::error(): SgCompoundInitializer object has a %s variant \n",
261222 : Cxx_GrammarTerminalNames[getVariant()].name);
261223 : // printf ("Error in SgCompoundInitializer::error() \n");
261224 : ROSE_ABORT();
261225 : }
261226 :
261227 : ROSE_ASSERT (getVariant() == COMPOUND_INIT);
261228 : return SgInitializer::error();
261229 : }
261230 : #endif
261231 :
261232 :
261233 :
261234 : // End of memberFunctionString
261235 :
261236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
261237 :
261238 0 : SgCompoundInitializer* isSgCompoundInitializer ( SgNode* inputDerivedClassPointer )
261239 : {
261240 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
261241 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
261242 : // So to fix this we return NULL directly when the input is NULL and avoid the
261243 : // dynamic_cast in this case. This is likely a performance improvement as well.
261244 : // return dynamic_cast<SgCompoundInitializer*>(inputDerivedClassPointer);
261245 : // Milind Chabbi (8/28/2013): isSgCompoundInitializer uses table-driven castability instead of c++ default dynamic_cast
261246 : // this improves the running time performance by 10-20%.
261247 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCompoundInitializer*>(inputDerivedClassPointer);
261248 0 : return IS_SgCompoundInitializer_FAST_MACRO(inputDerivedClassPointer);
261249 : }
261250 :
261251 : // DQ (11/8/2003): Added version of functions taking const pointer
261252 0 : const SgCompoundInitializer* isSgCompoundInitializer ( const SgNode* inputDerivedClassPointer )
261253 : {
261254 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
261255 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
261256 : // So to fix this we return NULL directly when the input is NULL and avoid the
261257 : // dynamic_cast in this case. This is likely a performance improvement as well.
261258 : // return dynamic_cast<const SgCompoundInitializer*>(inputDerivedClassPointer);
261259 : // Milind Chabbi (8/28/2013): isSgCompoundInitializer uses table-driven castability instead of c++ default dynamic_cast
261260 : // this improves the running time performance by 10-20%.
261261 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCompoundInitializer*>(inputDerivedClassPointer);
261262 0 : return IS_SgCompoundInitializer_FAST_MACRO(inputDerivedClassPointer);
261263 : }
261264 :
261265 :
261266 :
261267 : /* #line 261268 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
261268 :
261269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
261270 :
261271 : /**
261272 : \brief Generated destructor
261273 :
261274 : This destructor is automatically generated (by ROSETTA). This destructor
261275 : only frees memory of data members associated with the parts of the current IR node which
261276 : are NOT traversed. Those data members that are part of a traversal can be freed using
261277 : a traversal (calling this destructor on all children in a post-order traversal). Such
261278 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
261279 :
261280 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
261281 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
261282 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
261283 :
261284 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
261285 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
261286 : pointers are not yet implemented to call delete on eash pointer in the container.
261287 : (This could be done by derivation from the STL containers to define containers that
261288 : automatically deleted their members.)
261289 :
261290 : */
261291 0 : SgCompoundInitializer::~SgCompoundInitializer () {
261292 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
261293 :
261294 :
261295 : // case: not a listType for initializers
261296 0 : p_initializers = NULL; // non list case
261297 : // case: not a listType for expression_type
261298 0 : p_expression_type = NULL; // non list case
261299 :
261300 : }
261301 :
261302 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
261303 0 : }
261304 :
261305 :
261306 : /* #line 261307 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
261307 :
261308 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
261309 :
261310 : // Generated constructor
261311 0 : SgCompoundInitializer::SgCompoundInitializer ( Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type )
261312 0 : : SgInitializer(startOfConstruct)
261313 : {
261314 : #ifdef DEBUG
261315 : // printf ("In SgCompoundInitializer::SgCompoundInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
261316 : #endif
261317 : #if 0
261318 : // debugging information!
261319 : printf ("In SgCompoundInitializer::SgCompoundInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
261320 : #endif
261321 :
261322 0 : p_initializers = initializers;
261323 0 : p_expression_type = expression_type;
261324 :
261325 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
261326 :
261327 : #if 0
261328 : // DQ (7/30/2014): Call a virtual function.
261329 : std::string s = this->class_name();
261330 : #endif
261331 :
261332 : // Test the variant virtual function
261333 : // assert(COMPOUND_INIT == variant());
261334 0 : assert(COMPOUND_INIT == this->variant());
261335 0 : ROSE_ASSERT(COMPOUND_INIT == (int)(this->variantT()));
261336 0 : post_construction_initialization();
261337 :
261338 : // Test the isSgCompoundInitializer() function since it has been problematic
261339 0 : assert(isSgCompoundInitializer(this) != NULL);
261340 0 : }
261341 :
261342 : // Generated constructor (all data members)
261343 :
261344 : /* #line 261345 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
261345 :
261346 :
261347 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
261348 :
261349 :
261350 : // ********************************************************
261351 : // member functions common across all array grammar objects
261352 : // ********************************************************
261353 :
261354 :
261355 :
261356 : /* #line 261357 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
261357 :
261358 :
261359 :
261360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
261361 :
261362 : // ********************************************************
261363 : // member functions specific to each node in the grammar
261364 : // ********************************************************
261365 :
261366 :
261367 : /* #line 261368 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
261368 :
261369 : // Start of memberFunctionString
261370 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261371 :
261372 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261373 :
261374 : SgMemberFunctionDeclaration*
261375 21703 : SgConstructorInitializer::get_declaration () const
261376 : {
261377 21703 : ROSE_ASSERT (this != NULL);
261378 :
261379 : #if 0
261380 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261381 : // used to trigger marking transformations for the token-based unparsing.
261382 : printf ("SgConstructorInitializer::get_declaration = %p = %s \n",this,this->class_name().c_str());
261383 : #endif
261384 :
261385 21703 : return p_declaration;
261386 : }
261387 :
261388 : void
261389 0 : SgConstructorInitializer::set_declaration ( SgMemberFunctionDeclaration* declaration )
261390 : {
261391 0 : ROSE_ASSERT (this != NULL);
261392 :
261393 : #if 0
261394 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261395 : // used to trigger marking transformations for the token-based unparsing.
261396 : printf ("SgConstructorInitializer::set_declaration = %p = %s \n",this,this->class_name().c_str());
261397 : #endif
261398 :
261399 0 : set_isModified(true);
261400 :
261401 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
261402 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
261403 : {
261404 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
261405 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
261406 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
261407 : ROSE_ASSERT(false);
261408 : #endif
261409 : }
261410 : #endif
261411 0 : p_declaration = declaration;
261412 0 : }
261413 :
261414 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261415 :
261416 :
261417 : // End of memberFunctionString
261418 : // Start of memberFunctionString
261419 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261420 :
261421 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261422 :
261423 : SgExprListExp*
261424 14597 : SgConstructorInitializer::get_args () const
261425 : {
261426 14597 : ROSE_ASSERT (this != NULL);
261427 :
261428 : #if 0
261429 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261430 : // used to trigger marking transformations for the token-based unparsing.
261431 : printf ("SgConstructorInitializer::get_args = %p = %s \n",this,this->class_name().c_str());
261432 : #endif
261433 :
261434 14597 : return p_args;
261435 : }
261436 :
261437 : void
261438 1060 : SgConstructorInitializer::set_args ( SgExprListExp* args )
261439 : {
261440 1060 : ROSE_ASSERT (this != NULL);
261441 :
261442 : #if 0
261443 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261444 : // used to trigger marking transformations for the token-based unparsing.
261445 : printf ("SgConstructorInitializer::set_args = %p = %s \n",this,this->class_name().c_str());
261446 : #endif
261447 :
261448 1060 : set_isModified(true);
261449 :
261450 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
261451 : if (p_args != NULL && args != NULL && p_args != args)
261452 : {
261453 : printf ("Warning: args = %p overwriting valid pointer p_args = %p \n",args,p_args);
261454 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
261455 : printf ("Error fails assertion (p_args != NULL && args != NULL && p_args != args) is false\n");
261456 : ROSE_ASSERT(false);
261457 : #endif
261458 : }
261459 : #endif
261460 1060 : p_args = args;
261461 1060 : }
261462 :
261463 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261464 :
261465 :
261466 : // End of memberFunctionString
261467 : // Start of memberFunctionString
261468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261469 :
261470 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261471 :
261472 : SgType*
261473 9820 : SgConstructorInitializer::get_expression_type () const
261474 : {
261475 9820 : ROSE_ASSERT (this != NULL);
261476 :
261477 : #if 0
261478 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261479 : // used to trigger marking transformations for the token-based unparsing.
261480 : printf ("SgConstructorInitializer::get_expression_type = %p = %s \n",this,this->class_name().c_str());
261481 : #endif
261482 :
261483 9820 : return p_expression_type;
261484 : }
261485 :
261486 : void
261487 0 : SgConstructorInitializer::set_expression_type ( SgType* expression_type )
261488 : {
261489 0 : ROSE_ASSERT (this != NULL);
261490 :
261491 : #if 0
261492 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261493 : // used to trigger marking transformations for the token-based unparsing.
261494 : printf ("SgConstructorInitializer::set_expression_type = %p = %s \n",this,this->class_name().c_str());
261495 : #endif
261496 :
261497 0 : set_isModified(true);
261498 :
261499 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
261500 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
261501 : {
261502 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
261503 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
261504 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
261505 : ROSE_ASSERT(false);
261506 : #endif
261507 : }
261508 : #endif
261509 0 : p_expression_type = expression_type;
261510 0 : }
261511 :
261512 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261513 :
261514 :
261515 : // End of memberFunctionString
261516 : // Start of memberFunctionString
261517 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261518 :
261519 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261520 :
261521 : bool
261522 216 : SgConstructorInitializer::get_need_name () const
261523 : {
261524 216 : ROSE_ASSERT (this != NULL);
261525 :
261526 : #if 0
261527 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261528 : // used to trigger marking transformations for the token-based unparsing.
261529 : printf ("SgConstructorInitializer::get_need_name = %p = %s \n",this,this->class_name().c_str());
261530 : #endif
261531 :
261532 216 : return p_need_name;
261533 : }
261534 :
261535 : void
261536 3338 : SgConstructorInitializer::set_need_name ( bool need_name )
261537 : {
261538 3338 : ROSE_ASSERT (this != NULL);
261539 :
261540 : #if 0
261541 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261542 : // used to trigger marking transformations for the token-based unparsing.
261543 : printf ("SgConstructorInitializer::set_need_name = %p = %s \n",this,this->class_name().c_str());
261544 : #endif
261545 :
261546 3338 : set_isModified(true);
261547 :
261548 3338 : p_need_name = need_name;
261549 3338 : }
261550 :
261551 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261552 :
261553 :
261554 : // End of memberFunctionString
261555 : // Start of memberFunctionString
261556 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261557 :
261558 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261559 :
261560 : bool
261561 0 : SgConstructorInitializer::get_need_qualifier () const
261562 : {
261563 0 : ROSE_ASSERT (this != NULL);
261564 :
261565 : #if 0
261566 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261567 : // used to trigger marking transformations for the token-based unparsing.
261568 : printf ("SgConstructorInitializer::get_need_qualifier = %p = %s \n",this,this->class_name().c_str());
261569 : #endif
261570 :
261571 0 : return p_need_qualifier;
261572 : }
261573 :
261574 : void
261575 0 : SgConstructorInitializer::set_need_qualifier ( bool need_qualifier )
261576 : {
261577 0 : ROSE_ASSERT (this != NULL);
261578 :
261579 : #if 0
261580 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261581 : // used to trigger marking transformations for the token-based unparsing.
261582 : printf ("SgConstructorInitializer::set_need_qualifier = %p = %s \n",this,this->class_name().c_str());
261583 : #endif
261584 :
261585 0 : set_isModified(true);
261586 :
261587 0 : p_need_qualifier = need_qualifier;
261588 0 : }
261589 :
261590 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261591 :
261592 :
261593 : // End of memberFunctionString
261594 : // Start of memberFunctionString
261595 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261596 :
261597 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261598 :
261599 : bool
261600 492 : SgConstructorInitializer::get_need_parenthesis_after_name () const
261601 : {
261602 492 : ROSE_ASSERT (this != NULL);
261603 :
261604 : #if 0
261605 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261606 : // used to trigger marking transformations for the token-based unparsing.
261607 : printf ("SgConstructorInitializer::get_need_parenthesis_after_name = %p = %s \n",this,this->class_name().c_str());
261608 : #endif
261609 :
261610 492 : return p_need_parenthesis_after_name;
261611 : }
261612 :
261613 : void
261614 1066 : SgConstructorInitializer::set_need_parenthesis_after_name ( bool need_parenthesis_after_name )
261615 : {
261616 1066 : ROSE_ASSERT (this != NULL);
261617 :
261618 : #if 0
261619 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261620 : // used to trigger marking transformations for the token-based unparsing.
261621 : printf ("SgConstructorInitializer::set_need_parenthesis_after_name = %p = %s \n",this,this->class_name().c_str());
261622 : #endif
261623 :
261624 1066 : set_isModified(true);
261625 :
261626 1066 : p_need_parenthesis_after_name = need_parenthesis_after_name;
261627 1066 : }
261628 :
261629 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261630 :
261631 :
261632 : // End of memberFunctionString
261633 : // Start of memberFunctionString
261634 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261635 :
261636 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261637 :
261638 : bool
261639 3516 : SgConstructorInitializer::get_associated_class_unknown () const
261640 : {
261641 3516 : ROSE_ASSERT (this != NULL);
261642 :
261643 : #if 0
261644 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261645 : // used to trigger marking transformations for the token-based unparsing.
261646 : printf ("SgConstructorInitializer::get_associated_class_unknown = %p = %s \n",this,this->class_name().c_str());
261647 : #endif
261648 :
261649 3516 : return p_associated_class_unknown;
261650 : }
261651 :
261652 : void
261653 34 : SgConstructorInitializer::set_associated_class_unknown ( bool associated_class_unknown )
261654 : {
261655 34 : ROSE_ASSERT (this != NULL);
261656 :
261657 : #if 0
261658 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261659 : // used to trigger marking transformations for the token-based unparsing.
261660 : printf ("SgConstructorInitializer::set_associated_class_unknown = %p = %s \n",this,this->class_name().c_str());
261661 : #endif
261662 :
261663 34 : set_isModified(true);
261664 :
261665 34 : p_associated_class_unknown = associated_class_unknown;
261666 34 : }
261667 :
261668 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261669 :
261670 :
261671 : // End of memberFunctionString
261672 : // Start of memberFunctionString
261673 :
261674 :
261675 : // End of memberFunctionString
261676 : // Start of memberFunctionString
261677 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
261678 :
261679 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
261680 :
261681 : bool
261682 144 : SgConstructorInitializer::get_is_used_in_conditional () const
261683 : {
261684 144 : ROSE_ASSERT (this != NULL);
261685 :
261686 : #if 0
261687 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261688 : // used to trigger marking transformations for the token-based unparsing.
261689 : printf ("SgConstructorInitializer::get_is_used_in_conditional = %p = %s \n",this,this->class_name().c_str());
261690 : #endif
261691 :
261692 144 : return p_is_used_in_conditional;
261693 : }
261694 :
261695 : void
261696 0 : SgConstructorInitializer::set_is_used_in_conditional ( bool is_used_in_conditional )
261697 : {
261698 0 : ROSE_ASSERT (this != NULL);
261699 :
261700 : #if 0
261701 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
261702 : // used to trigger marking transformations for the token-based unparsing.
261703 : printf ("SgConstructorInitializer::set_is_used_in_conditional = %p = %s \n",this,this->class_name().c_str());
261704 : #endif
261705 :
261706 0 : set_isModified(true);
261707 :
261708 0 : p_is_used_in_conditional = is_used_in_conditional;
261709 0 : }
261710 :
261711 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
261712 :
261713 :
261714 : // End of memberFunctionString
261715 : // Start of memberFunctionString
261716 : /* #line 7504 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
261717 :
261718 :
261719 : /** Obtain the class declaration for a constructor initializer if possible.
261720 : *
261721 : * If this is a constructor initializer for a class type then the first non-defining declaration of the constructor's class is
261722 : * returned; the null pointer is returned for constructor initializers of primitive types.
261723 : *
261724 : * The SgConstructorInitializer::p_declaration points to a SgMemberFunctionDeclaration when the constructor is declared, but is
261725 : * the null pointer when the constructor is not declared or when the constructor is for a non-class type.
261726 : *
261727 : * When the p_declaration is the null pointer then the SgConstructorInitializer::p_expression_type can be used to determine
261728 : * whether the constructor initializer is for a class type without a declared constructor, or for a non-class type. In the
261729 : * former case, the p_expression_type points to a SgClassType. In the latter case it points to either a SgFunctionType (EDG4)
261730 : * or null (EDG3). */
261731 : SgClassDeclaration*
261732 9453 : SgConstructorInitializer::get_class_decl () const
261733 : {
261734 9453 : SgClassDeclaration *class_decl = NULL;
261735 :
261736 9453 : if (SgMemberFunctionDeclaration *fdecl = get_declaration()) {
261737 : // The constructor is declared (and is a member of a class type)
261738 : #if 1
261739 : // DQ (11/11/2014): Modified version of code to address the fact that Fortran is organized a bit differently.
261740 : // That it is different from C++ might be something to revisit later in the Fortran support.
261741 0 : ROSE_ASSERT(get_declaration() != NULL);
261742 : // printf ("In SgConstructorInitializer::get_class_decl(): get_declaration() = %p = %s \n",get_declaration(),get_declaration()->class_name().c_str());
261743 0 : ROSE_ASSERT(fdecl->get_scope() != NULL);
261744 : // printf ("In SgConstructorInitializer::get_class_decl(): fdecl->get_scope() = %p = %s \n",fdecl->get_scope(),fdecl->get_scope()->class_name().c_str());
261745 :
261746 0 : SgClassDefinition *cdef = isSgClassDefinition(fdecl->get_scope());
261747 0 : if (cdef != NULL)
261748 : {
261749 0 : assert(cdef!=NULL);
261750 0 : class_decl = isSgClassDeclaration(cdef->get_parent());
261751 0 : assert(class_decl!=NULL);
261752 : }
261753 : #else
261754 : // DQ (11/11/2014): Original code which does not work for Fortran (the fortran_constructor_function for a data type is not in the same scope as the data type).
261755 : // This might be something that we want to visit at some point. But this is caught as an error because the C++11 support caused more
261756 : // debug information to be placed into the generated AST graphs and so this function is now called for Fortran code where it had not
261757 : // previously been called for Fortran code.
261758 : SgClassDefinition *cdef = isSgClassDefinition(fdecl->get_scope());
261759 : assert(cdef!=NULL);
261760 : class_decl = isSgClassDeclaration(cdef->get_parent());
261761 : assert(class_decl!=NULL);
261762 : #endif
261763 9453 : } else if (SgClassType *expr_type = isSgClassType(get_expression_type())) {
261764 : // Constructor initializer is for a class type with a non-declared default constructor. We can follow the
261765 : // p_expression_type's declaration.
261766 2454 : class_decl = isSgClassDeclaration(expr_type->get_declaration());
261767 2454 : assert(class_decl!=NULL);
261768 : } else {
261769 : // Constructor is for a primitive type. There is no class declaration to return.
261770 : }
261771 :
261772 2454 : if (class_decl) {
261773 2454 : class_decl = isSgClassDeclaration(class_decl->get_firstNondefiningDeclaration());
261774 2454 : assert(class_decl!=NULL);
261775 : }
261776 9453 : return class_decl;
261777 : }
261778 :
261779 : void
261780 4586 : SgConstructorInitializer::post_construction_initialization()
261781 : {
261782 4586 : ROSE_ASSERT(p_expression_type != NULL);
261783 4586 : if (p_declaration == NULL)
261784 : {
261785 : // DQ (1/19/2019): This is failing in the copyAST tests for test2005_24.C
261786 3637 : if ( !((isSgTypedefType(p_expression_type) || isSgClassType(p_expression_type) != NULL) || (p_associated_class_unknown == true)) )
261787 : {
261788 0 : printf ("In SgConstructorInitializer::post_construction_initialization(): What is this failing case? p_expression_type = %p \n",p_expression_type);
261789 0 : if (p_expression_type != NULL)
261790 : {
261791 0 : printf (" --- What is this failing case? p_expression_type = %p = %s \n",p_expression_type,p_expression_type->class_name().c_str());
261792 : }
261793 : }
261794 :
261795 3637 : ROSE_ASSERT( (isSgTypedefType(p_expression_type) || isSgClassType(p_expression_type) != NULL) || (p_associated_class_unknown == true) );
261796 : }
261797 :
261798 : // DQ (11/15/2006): avoid setting newArgs this late in the process.
261799 : // ROSE_ASSERT(p_args != NULL);
261800 4586 : if (p_args == NULL)
261801 : {
261802 : // Build an empty argument list
261803 :
261804 : // DQ (11/16/2006): Need to handle use in new constructors that don't have fileInfo parameters.
261805 : // p_args = new SgExprListExp(New_File_Info(this));
261806 1068 : if (get_startOfConstruct() != NULL)
261807 : {
261808 0 : p_args = new SgExprListExp(New_File_Info(this));
261809 0 : p_args->set_endOfConstruct(New_File_Info(this));
261810 : }
261811 : else
261812 : {
261813 2136 : p_args = new SgExprListExp();
261814 : }
261815 1068 : ROSE_ASSERT(p_args != NULL);
261816 : }
261817 :
261818 : // if (get_args() != NULL)
261819 : // get_args()->set_parent(this);
261820 4586 : get_args()->set_parent(this);
261821 :
261822 4586 : ROSE_ASSERT(p_args != NULL);
261823 4586 : }
261824 :
261825 : #if 0
261826 : SgClassDeclaration*
261827 : SgConstructorInitializer::get_class_decl () const
261828 : {
261829 : assert (this != NULL);
261830 :
261831 : // Look this up from the SgType that we now store explicitly instead of the SgClassDeclaration
261832 : // return p_class_decl;
261833 :
261834 : SgClassDeclaration* classDeclaration = NULL;
261835 : ROSE_ASSERT(this->get_type() != NULL);
261836 :
261837 : return classDeclaration;
261838 : }
261839 : #endif
261840 :
261841 : #if 0
261842 : // Need a feature in the grammar code generator to permit
261843 : // user specification of the set_DATA member function
261844 : void
261845 : SgConstructorInitializer::set_declaration(SgMemberFunctionDeclaration* new_val)
261846 : {
261847 : p_declaration = new_val;
261848 : #ifndef REMOVE_SET_PARENT_FUNCTION
261849 : if(p_declaration)p_declaration->set_parent(this);
261850 : #endif
261851 : }
261852 :
261853 : void
261854 : SgConstructorInitializer::set_args(SgExprListExp* new_val)
261855 : {
261856 : p_args = new_val;
261857 : #ifndef REMOVE_SET_PARENT_FUNCTION
261858 : if(p_args)p_args->set_parent(this);
261859 : #endif
261860 : }
261861 :
261862 : void
261863 : SgConstructorInitializer::set_class_decl(SgClassDeclaration* new_val)
261864 : {
261865 : p_class_decl = new_val;
261866 : #ifndef REMOVE_SET_PARENT_FUNCTION
261867 : if(p_class_decl)p_class_decl->set_parent(this);
261868 : #endif
261869 : }
261870 : #endif
261871 :
261872 : //#if 0
261873 : SgExpression*
261874 0 : SgConstructorInitializer::get_next(int& n) const
261875 : {
261876 0 : if(n==0)
261877 : {
261878 0 : n++;
261879 0 : return get_args();
261880 : }
261881 : return 0;
261882 : }
261883 : //#endif
261884 :
261885 : int
261886 0 : SgConstructorInitializer::replace_expression(SgExpression *o, SgExpression *n)
261887 : {
261888 : // DQ (12/17/2006): This function should have the semantics that it will represent a
261889 : // structural change to the AST, thus it is free to set the parent of the new expression.
261890 :
261891 0 : ROSE_ASSERT(o != NULL);
261892 0 : ROSE_ASSERT(n != NULL);
261893 :
261894 0 : if(get_args() == o)
261895 : {
261896 0 : set_args(isSgExprListExp(n));
261897 0 : n->set_parent(this);
261898 0 : return 1;
261899 : }
261900 : else
261901 : return 0;
261902 : }
261903 :
261904 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
261905 : // so that we could avoid them setting the isModified flag which is a problem in the
261906 : // name qualification support for C++ (interfering with the token-based unparsing).
261907 : int
261908 0 : SgConstructorInitializer::get_name_qualification_length () const
261909 : {
261910 0 : ROSE_ASSERT (this != NULL);
261911 0 : return p_name_qualification_length;
261912 : }
261913 :
261914 : void
261915 1945 : SgConstructorInitializer::set_name_qualification_length ( int name_qualification_length )
261916 : {
261917 1945 : ROSE_ASSERT (this != NULL);
261918 : // This can't be called by the name qualification API (see test2015_26.C).
261919 : // set_isModified(true);
261920 :
261921 1945 : p_name_qualification_length = name_qualification_length;
261922 1945 : }
261923 :
261924 : bool
261925 0 : SgConstructorInitializer::get_type_elaboration_required () const
261926 : {
261927 0 : ROSE_ASSERT (this != NULL);
261928 :
261929 0 : return p_type_elaboration_required;
261930 : }
261931 :
261932 : void
261933 1945 : SgConstructorInitializer::set_type_elaboration_required ( bool type_elaboration_required )
261934 : {
261935 1945 : ROSE_ASSERT (this != NULL);
261936 : // This can't be called by the name qualification API (see test2015_26.C).
261937 : // set_isModified(true);
261938 :
261939 1945 : p_type_elaboration_required = type_elaboration_required;
261940 1945 : }
261941 :
261942 : bool
261943 0 : SgConstructorInitializer::get_global_qualification_required () const
261944 : {
261945 0 : ROSE_ASSERT (this != NULL);
261946 0 : return p_global_qualification_required;
261947 : }
261948 :
261949 : void
261950 1945 : SgConstructorInitializer::set_global_qualification_required ( bool global_qualification_required )
261951 : {
261952 1945 : ROSE_ASSERT (this != NULL);
261953 :
261954 : // This can't be called by the name qualification API (see test2015_26.C).
261955 : // set_isModified(true);
261956 :
261957 1945 : p_global_qualification_required = global_qualification_required;
261958 1945 : }
261959 :
261960 :
261961 :
261962 : // End of memberFunctionString
261963 : // Start of memberFunctionString
261964 : /* #line 8424 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
261965 :
261966 :
261967 : // DQ (7/19/2006): Function suggested by Jeremiah Willcock and fixed up for general use by DQ
261968 : // A better fix (later) will allow us to save the SgType and not use a SgDefaultType for the
261969 : // special case below.
261970 : SgType*
261971 16040 : SgConstructorInitializer::get_type(void) const
261972 : {
261973 16040 : ROSE_ASSERT(this != NULL);
261974 :
261975 : #if 0
261976 : printf ("In SgConstructorInitializer::get_type() \n");
261977 : #endif
261978 :
261979 : // DQ (8/5/2006): Now that we store the expression type explicitly this is a simpler function.
261980 16040 : SgType* returnType = p_expression_type;
261981 :
261982 16040 : ROSE_ASSERT(returnType != NULL);
261983 16040 : return returnType;
261984 : }
261985 :
261986 :
261987 :
261988 : // End of memberFunctionString
261989 : // Start of memberFunctionString
261990 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
261991 :
261992 : // *** COMMON CODE SECTION BEGINS HERE ***
261993 :
261994 : #if 0
261995 : int
261996 : SgConstructorInitializer::getVariant() const
261997 : {
261998 : // This function is used in ROSE while "variant()" is used in SAGE
261999 : assert(this != NULL);
262000 : return variant();
262001 : }
262002 : #endif
262003 :
262004 : // This function is used in ROSE in treeTraversal code
262005 : // eventually replaces getVariant() and variant()
262006 : // though after variant() has been removed for a while we will
262007 : // want to change the name of variantT() back to variant()
262008 : // (since the "T" was ment to stand for temporary).
262009 : // When this happens the variantT() will be depricated.
262010 : VariantT
262011 2611390 : SgConstructorInitializer::variantT() const
262012 : {
262013 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
262014 2611390 : ROSE_ASSERT(this != NULL);
262015 2611390 : return V_SgConstructorInitializer;
262016 : }
262017 :
262018 : #if 0
262019 : int
262020 : SgConstructorInitializer::variant() const
262021 : {
262022 : // This function is used in SAGE
262023 : ROSE_ASSERT(this != NULL);
262024 : return CONSTRUCTOR_INIT;
262025 : }
262026 : #endif
262027 :
262028 : ROSE_DLL_API const char*
262029 222 : SgConstructorInitializer::sage_class_name() const
262030 : {
262031 222 : ROSE_ASSERT(this != NULL);
262032 222 : return "SgConstructorInitializer";
262033 : }
262034 :
262035 : std::string
262036 3725 : SgConstructorInitializer::class_name() const
262037 : {
262038 3725 : ROSE_ASSERT(this != NULL);
262039 3725 : return "SgConstructorInitializer";
262040 : }
262041 :
262042 : // DQ (11/26/2005): Support for visitor pattern mechanims
262043 : // (inferior to ROSE traversal mechanism, experimental).
262044 : void
262045 66227 : SgConstructorInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
262046 : {
262047 66227 : ROSE_ASSERT(this != NULL);
262048 66227 : visitor.visit(this);
262049 66227 : }
262050 :
262051 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
262052 0 : void SgConstructorInitializer::accept (ROSE_VisitorPattern & visitor) {
262053 0 : ROSE_ASSERT(this != NULL);
262054 0 : visitor.visit(this);
262055 0 : }
262056 :
262057 : SgConstructorInitializer*
262058 0 : SgConstructorInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
262059 : {
262060 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
262061 : // This function is currently only supported for the AST used the represent Binary executables.
262062 : if (0 /* isSgAsmNode(this) != NULL */)
262063 : {
262064 : // Support for regex specification.
262065 : std::string prefixCode = "REGEX:";
262066 : addNewAttribute(prefixCode + s,a);
262067 : }
262068 : #endif
262069 :
262070 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
262071 0 : return this;
262072 : }
262073 :
262074 : // *** COMMON CODE SECTION ENDS HERE ***
262075 :
262076 :
262077 : // End of memberFunctionString
262078 : // Start of memberFunctionString
262079 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
262080 :
262081 :
262082 : #if 0
262083 : //! Error checking support
262084 : /*! Verifies the following:
262085 : - working getVariant() member function
262086 : - calls base class's error() member function
262087 : Every class has one of these functions.
262088 : */
262089 : bool
262090 : SgConstructorInitializer::error()
262091 : {
262092 : // Put error checking here
262093 :
262094 : ROSE_ASSERT (this != NULL);
262095 : if (getVariant() != CONSTRUCTOR_INIT)
262096 : {
262097 : printf ("Error in SgConstructorInitializer::error(): SgConstructorInitializer object has a %s variant \n",
262098 : Cxx_GrammarTerminalNames[getVariant()].name);
262099 : // printf ("Error in SgConstructorInitializer::error() \n");
262100 : ROSE_ABORT();
262101 : }
262102 :
262103 : ROSE_ASSERT (getVariant() == CONSTRUCTOR_INIT);
262104 : return SgInitializer::error();
262105 : }
262106 : #endif
262107 :
262108 :
262109 :
262110 : // End of memberFunctionString
262111 :
262112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
262113 :
262114 5853420 : SgConstructorInitializer* isSgConstructorInitializer ( SgNode* inputDerivedClassPointer )
262115 : {
262116 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
262117 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
262118 : // So to fix this we return NULL directly when the input is NULL and avoid the
262119 : // dynamic_cast in this case. This is likely a performance improvement as well.
262120 : // return dynamic_cast<SgConstructorInitializer*>(inputDerivedClassPointer);
262121 : // Milind Chabbi (8/28/2013): isSgConstructorInitializer uses table-driven castability instead of c++ default dynamic_cast
262122 : // this improves the running time performance by 10-20%.
262123 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgConstructorInitializer*>(inputDerivedClassPointer);
262124 5853420 : return IS_SgConstructorInitializer_FAST_MACRO(inputDerivedClassPointer);
262125 : }
262126 :
262127 : // DQ (11/8/2003): Added version of functions taking const pointer
262128 60 : const SgConstructorInitializer* isSgConstructorInitializer ( const SgNode* inputDerivedClassPointer )
262129 : {
262130 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
262131 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
262132 : // So to fix this we return NULL directly when the input is NULL and avoid the
262133 : // dynamic_cast in this case. This is likely a performance improvement as well.
262134 : // return dynamic_cast<const SgConstructorInitializer*>(inputDerivedClassPointer);
262135 : // Milind Chabbi (8/28/2013): isSgConstructorInitializer uses table-driven castability instead of c++ default dynamic_cast
262136 : // this improves the running time performance by 10-20%.
262137 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgConstructorInitializer*>(inputDerivedClassPointer);
262138 60 : return IS_SgConstructorInitializer_FAST_MACRO(inputDerivedClassPointer);
262139 : }
262140 :
262141 :
262142 :
262143 : /* #line 262144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262144 :
262145 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
262146 :
262147 : /**
262148 : \brief Generated destructor
262149 :
262150 : This destructor is automatically generated (by ROSETTA). This destructor
262151 : only frees memory of data members associated with the parts of the current IR node which
262152 : are NOT traversed. Those data members that are part of a traversal can be freed using
262153 : a traversal (calling this destructor on all children in a post-order traversal). Such
262154 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
262155 :
262156 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
262157 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
262158 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
262159 :
262160 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
262161 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
262162 : pointers are not yet implemented to call delete on eash pointer in the container.
262163 : (This could be done by derivation from the STL containers to define containers that
262164 : automatically deleted their members.)
262165 :
262166 : */
262167 2054 : SgConstructorInitializer::~SgConstructorInitializer () {
262168 1027 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
262169 :
262170 :
262171 : // case: not a listType for declaration
262172 1027 : p_declaration = NULL; // non list case
262173 : // case: not a listType for args
262174 1027 : p_args = NULL; // non list case
262175 : // case: not a listType for expression_type
262176 1027 : p_expression_type = NULL; // non list case
262177 : // case: not a listType for need_name
262178 1027 : p_need_name = false; // non list case
262179 : // case: not a listType for need_qualifier
262180 1027 : p_need_qualifier = false; // non list case
262181 : // case: not a listType for need_parenthesis_after_name
262182 1027 : p_need_parenthesis_after_name = false; // non list case
262183 : // case: not a listType for associated_class_unknown
262184 1027 : p_associated_class_unknown = false; // non list case
262185 : // case: not a listType for name_qualification_length
262186 1027 : p_name_qualification_length = 0; // non list case
262187 : // case: not a listType for type_elaboration_required
262188 1027 : p_type_elaboration_required = false; // non list case
262189 : // case: not a listType for global_qualification_required
262190 1027 : p_global_qualification_required = false; // non list case
262191 : // case: not a listType for is_used_in_conditional
262192 1027 : p_is_used_in_conditional = false; // non list case
262193 :
262194 : }
262195 :
262196 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
262197 2054 : }
262198 :
262199 :
262200 : /* #line 262201 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262201 :
262202 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
262203 :
262204 : // Generated constructor
262205 38 : SgConstructorInitializer::SgConstructorInitializer ( Sg_File_Info* startOfConstruct, SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgType* expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown )
262206 38 : : SgInitializer(startOfConstruct)
262207 : {
262208 : #ifdef DEBUG
262209 : // printf ("In SgConstructorInitializer::SgConstructorInitializer (Sg_File_Info* startOfConstruct, SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgType* expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown) sage_class_name() = %s \n",sage_class_name());
262210 : #endif
262211 : #if 0
262212 : // debugging information!
262213 : printf ("In SgConstructorInitializer::SgConstructorInitializer (Sg_File_Info* startOfConstruct, SgMemberFunctionDeclaration* declaration, SgExprListExp* args, SgType* expression_type, bool need_name, bool need_qualifier, bool need_parenthesis_after_name, bool associated_class_unknown): this = %p = %s \n",this,this->class_name().c_str());
262214 : #endif
262215 :
262216 38 : p_declaration = declaration;
262217 38 : p_args = args;
262218 38 : p_expression_type = expression_type;
262219 38 : p_need_name = need_name;
262220 38 : p_need_qualifier = need_qualifier;
262221 38 : p_need_parenthesis_after_name = need_parenthesis_after_name;
262222 38 : p_associated_class_unknown = associated_class_unknown;
262223 38 : p_name_qualification_length = 0;
262224 38 : p_type_elaboration_required = false;
262225 38 : p_global_qualification_required = false;
262226 38 : p_is_used_in_conditional = false;
262227 :
262228 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
262229 :
262230 : #if 0
262231 : // DQ (7/30/2014): Call a virtual function.
262232 : std::string s = this->class_name();
262233 : #endif
262234 :
262235 : // Test the variant virtual function
262236 : // assert(CONSTRUCTOR_INIT == variant());
262237 38 : assert(CONSTRUCTOR_INIT == this->variant());
262238 38 : ROSE_ASSERT(CONSTRUCTOR_INIT == (int)(this->variantT()));
262239 38 : post_construction_initialization();
262240 :
262241 : // Test the isSgConstructorInitializer() function since it has been problematic
262242 38 : assert(isSgConstructorInitializer(this) != NULL);
262243 38 : }
262244 :
262245 : // Generated constructor (all data members)
262246 :
262247 : /* #line 262248 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262248 :
262249 :
262250 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
262251 :
262252 :
262253 : // ********************************************************
262254 : // member functions common across all array grammar objects
262255 : // ********************************************************
262256 :
262257 :
262258 :
262259 : /* #line 262260 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262260 :
262261 :
262262 :
262263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
262264 :
262265 : // ********************************************************
262266 : // member functions specific to each node in the grammar
262267 : // ********************************************************
262268 :
262269 :
262270 : /* #line 262271 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262271 :
262272 : // Start of memberFunctionString
262273 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
262274 :
262275 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
262276 :
262277 : SgExpression*
262278 79519 : SgAssignInitializer::get_operand_i () const
262279 : {
262280 79519 : ROSE_ASSERT (this != NULL);
262281 :
262282 : #if 0
262283 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
262284 : // used to trigger marking transformations for the token-based unparsing.
262285 : printf ("SgAssignInitializer::get_operand_i = %p = %s \n",this,this->class_name().c_str());
262286 : #endif
262287 :
262288 79519 : return p_operand_i;
262289 : }
262290 :
262291 : void
262292 6 : SgAssignInitializer::set_operand_i ( SgExpression* operand_i )
262293 : {
262294 6 : ROSE_ASSERT (this != NULL);
262295 :
262296 : #if 0
262297 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
262298 : // used to trigger marking transformations for the token-based unparsing.
262299 : printf ("SgAssignInitializer::set_operand_i = %p = %s \n",this,this->class_name().c_str());
262300 : #endif
262301 :
262302 6 : set_isModified(true);
262303 :
262304 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
262305 : if (p_operand_i != NULL && operand_i != NULL && p_operand_i != operand_i)
262306 : {
262307 : printf ("Warning: operand_i = %p overwriting valid pointer p_operand_i = %p \n",operand_i,p_operand_i);
262308 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
262309 : printf ("Error fails assertion (p_operand_i != NULL && operand_i != NULL && p_operand_i != operand_i) is false\n");
262310 : ROSE_ASSERT(false);
262311 : #endif
262312 : }
262313 : #endif
262314 6 : p_operand_i = operand_i;
262315 6 : }
262316 :
262317 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
262318 :
262319 :
262320 : // End of memberFunctionString
262321 : // Start of memberFunctionString
262322 :
262323 :
262324 : // End of memberFunctionString
262325 : // Start of memberFunctionString
262326 : /* #line 7749 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
262327 :
262328 :
262329 : SgExpression*
262330 79479 : SgAssignInitializer::get_operand() const
262331 79479 : { return get_operand_i(); }
262332 :
262333 : void
262334 16946 : SgAssignInitializer::post_construction_initialization()
262335 : {
262336 : // #ifndef REMOVE_SET_PARENT_FUNCTION
262337 16946 : if (get_operand() != NULL)
262338 16946 : get_operand()->set_parent(this);
262339 : // #endif
262340 :
262341 : // DQ (1/14/2006): set_type is removed
262342 : // set_type();
262343 16946 : }
262344 :
262345 : SgType*
262346 14207 : SgAssignInitializer::get_type() const
262347 : {
262348 : // DQ (1/14/2006): p_expression_type has been removed, we have to compute the appropriate type (IR specific code)
262349 :
262350 : // printf ("SgAssignInitializer::get_type(): p_expression_type has been removed, getting the return type from the stored internal operand \n");
262351 :
262352 14207 : ROSE_ASSERT(get_operand() != NULL);
262353 :
262354 : #if 0
262355 : printf ("In SgAssignInitializer::get_type() \n");
262356 : #endif
262357 :
262358 14207 : SgType* returnType = p_expression_type ? p_expression_type : get_operand()->get_type();
262359 :
262360 14207 : ROSE_ASSERT(returnType != NULL);
262361 :
262362 14207 : if (!p_expression_type && get_operand()->variantT() != V_SgStringVal)
262363 : {
262364 14161 : SgType* retElemType = SageInterface::getElementType(returnType);
262365 14161 : if (retElemType != NULL)
262366 : {
262367 1180 : returnType = SgPointerType::createType(retElemType);
262368 : }
262369 : }
262370 :
262371 14207 : ROSE_ASSERT(returnType != NULL);
262372 14207 : return returnType;
262373 : }
262374 :
262375 : void
262376 6 : SgAssignInitializer::set_operand(SgExpression * exp)
262377 : {
262378 6 : set_operand_i(exp);
262379 : // #ifndef REMOVE_SET_PARENT_FUNCTION
262380 6 : if (exp)
262381 6 : exp->set_parent(this);
262382 : // #endif
262383 :
262384 : // DQ (1/14/2006): set_type is removed
262385 : // set_type();
262386 6 : }
262387 :
262388 : SgExpression*
262389 0 : SgAssignInitializer::get_next(int& n) const
262390 : {
262391 0 : if(n==0)
262392 : {
262393 0 : n++;
262394 0 : return get_operand();
262395 : }
262396 : else
262397 : return 0;
262398 : }
262399 :
262400 : int
262401 0 : SgAssignInitializer::replace_expression(SgExpression *o, SgExpression *n)
262402 : {
262403 : // DQ (12/17/2006): This function should have the semantics that it will represent a
262404 : // structural change to the AST, thus it is free to set the parent of the new expression.
262405 :
262406 0 : ROSE_ASSERT(o != NULL);
262407 0 : ROSE_ASSERT(n != NULL);
262408 :
262409 0 : if(get_operand()==o)
262410 : {
262411 0 : set_operand(n);
262412 0 : n->set_parent(this);
262413 0 : return 1;
262414 : }
262415 : else
262416 : return 0;
262417 : }
262418 :
262419 :
262420 :
262421 : // End of memberFunctionString
262422 : // Start of memberFunctionString
262423 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
262424 :
262425 : // *** COMMON CODE SECTION BEGINS HERE ***
262426 :
262427 : #if 0
262428 : int
262429 : SgAssignInitializer::getVariant() const
262430 : {
262431 : // This function is used in ROSE while "variant()" is used in SAGE
262432 : assert(this != NULL);
262433 : return variant();
262434 : }
262435 : #endif
262436 :
262437 : // This function is used in ROSE in treeTraversal code
262438 : // eventually replaces getVariant() and variant()
262439 : // though after variant() has been removed for a while we will
262440 : // want to change the name of variantT() back to variant()
262441 : // (since the "T" was ment to stand for temporary).
262442 : // When this happens the variantT() will be depricated.
262443 : VariantT
262444 5276400 : SgAssignInitializer::variantT() const
262445 : {
262446 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
262447 5276400 : ROSE_ASSERT(this != NULL);
262448 5276400 : return V_SgAssignInitializer;
262449 : }
262450 :
262451 : #if 0
262452 : int
262453 : SgAssignInitializer::variant() const
262454 : {
262455 : // This function is used in SAGE
262456 : ROSE_ASSERT(this != NULL);
262457 : return ASSIGN_INIT;
262458 : }
262459 : #endif
262460 :
262461 : ROSE_DLL_API const char*
262462 181 : SgAssignInitializer::sage_class_name() const
262463 : {
262464 181 : ROSE_ASSERT(this != NULL);
262465 181 : return "SgAssignInitializer";
262466 : }
262467 :
262468 : std::string
262469 14777 : SgAssignInitializer::class_name() const
262470 : {
262471 14777 : ROSE_ASSERT(this != NULL);
262472 14777 : return "SgAssignInitializer";
262473 : }
262474 :
262475 : // DQ (11/26/2005): Support for visitor pattern mechanims
262476 : // (inferior to ROSE traversal mechanism, experimental).
262477 : void
262478 171587 : SgAssignInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
262479 : {
262480 171587 : ROSE_ASSERT(this != NULL);
262481 171587 : visitor.visit(this);
262482 171587 : }
262483 :
262484 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
262485 0 : void SgAssignInitializer::accept (ROSE_VisitorPattern & visitor) {
262486 0 : ROSE_ASSERT(this != NULL);
262487 0 : visitor.visit(this);
262488 0 : }
262489 :
262490 : SgAssignInitializer*
262491 0 : SgAssignInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
262492 : {
262493 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
262494 : // This function is currently only supported for the AST used the represent Binary executables.
262495 : if (0 /* isSgAsmNode(this) != NULL */)
262496 : {
262497 : // Support for regex specification.
262498 : std::string prefixCode = "REGEX:";
262499 : addNewAttribute(prefixCode + s,a);
262500 : }
262501 : #endif
262502 :
262503 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
262504 0 : return this;
262505 : }
262506 :
262507 : // *** COMMON CODE SECTION ENDS HERE ***
262508 :
262509 :
262510 : // End of memberFunctionString
262511 : // Start of memberFunctionString
262512 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
262513 :
262514 :
262515 : #if 0
262516 : //! Error checking support
262517 : /*! Verifies the following:
262518 : - working getVariant() member function
262519 : - calls base class's error() member function
262520 : Every class has one of these functions.
262521 : */
262522 : bool
262523 : SgAssignInitializer::error()
262524 : {
262525 : // Put error checking here
262526 :
262527 : ROSE_ASSERT (this != NULL);
262528 : if (getVariant() != ASSIGN_INIT)
262529 : {
262530 : printf ("Error in SgAssignInitializer::error(): SgAssignInitializer object has a %s variant \n",
262531 : Cxx_GrammarTerminalNames[getVariant()].name);
262532 : // printf ("Error in SgAssignInitializer::error() \n");
262533 : ROSE_ABORT();
262534 : }
262535 :
262536 : ROSE_ASSERT (getVariant() == ASSIGN_INIT);
262537 : return SgInitializer::error();
262538 : }
262539 : #endif
262540 :
262541 :
262542 :
262543 : // End of memberFunctionString
262544 :
262545 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
262546 :
262547 51395 : SgAssignInitializer* isSgAssignInitializer ( SgNode* inputDerivedClassPointer )
262548 : {
262549 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
262550 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
262551 : // So to fix this we return NULL directly when the input is NULL and avoid the
262552 : // dynamic_cast in this case. This is likely a performance improvement as well.
262553 : // return dynamic_cast<SgAssignInitializer*>(inputDerivedClassPointer);
262554 : // Milind Chabbi (8/28/2013): isSgAssignInitializer uses table-driven castability instead of c++ default dynamic_cast
262555 : // this improves the running time performance by 10-20%.
262556 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAssignInitializer*>(inputDerivedClassPointer);
262557 51395 : return IS_SgAssignInitializer_FAST_MACRO(inputDerivedClassPointer);
262558 : }
262559 :
262560 : // DQ (11/8/2003): Added version of functions taking const pointer
262561 0 : const SgAssignInitializer* isSgAssignInitializer ( const SgNode* inputDerivedClassPointer )
262562 : {
262563 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
262564 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
262565 : // So to fix this we return NULL directly when the input is NULL and avoid the
262566 : // dynamic_cast in this case. This is likely a performance improvement as well.
262567 : // return dynamic_cast<const SgAssignInitializer*>(inputDerivedClassPointer);
262568 : // Milind Chabbi (8/28/2013): isSgAssignInitializer uses table-driven castability instead of c++ default dynamic_cast
262569 : // this improves the running time performance by 10-20%.
262570 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAssignInitializer*>(inputDerivedClassPointer);
262571 0 : return IS_SgAssignInitializer_FAST_MACRO(inputDerivedClassPointer);
262572 : }
262573 :
262574 :
262575 :
262576 : /* #line 262577 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262577 :
262578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
262579 :
262580 : /**
262581 : \brief Generated destructor
262582 :
262583 : This destructor is automatically generated (by ROSETTA). This destructor
262584 : only frees memory of data members associated with the parts of the current IR node which
262585 : are NOT traversed. Those data members that are part of a traversal can be freed using
262586 : a traversal (calling this destructor on all children in a post-order traversal). Such
262587 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
262588 :
262589 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
262590 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
262591 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
262592 :
262593 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
262594 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
262595 : pointers are not yet implemented to call delete on eash pointer in the container.
262596 : (This could be done by derivation from the STL containers to define containers that
262597 : automatically deleted their members.)
262598 :
262599 : */
262600 5834 : SgAssignInitializer::~SgAssignInitializer () {
262601 2917 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
262602 :
262603 :
262604 : // case: not a listType for operand_i
262605 2917 : p_operand_i = NULL; // non list case
262606 : // case: not a listType for expression_type
262607 2917 : p_expression_type = NULL; // non list case
262608 :
262609 : }
262610 :
262611 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
262612 5834 : }
262613 :
262614 :
262615 : /* #line 262616 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262616 :
262617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
262618 :
262619 : // Generated constructor
262620 18 : SgAssignInitializer::SgAssignInitializer ( Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type )
262621 18 : : SgInitializer(startOfConstruct)
262622 : {
262623 : #ifdef DEBUG
262624 : // printf ("In SgAssignInitializer::SgAssignInitializer (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
262625 : #endif
262626 : #if 0
262627 : // debugging information!
262628 : printf ("In SgAssignInitializer::SgAssignInitializer (Sg_File_Info* startOfConstruct, SgExpression* operand_i, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
262629 : #endif
262630 :
262631 18 : p_operand_i = operand_i;
262632 18 : p_expression_type = expression_type;
262633 :
262634 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
262635 :
262636 : #if 0
262637 : // DQ (7/30/2014): Call a virtual function.
262638 : std::string s = this->class_name();
262639 : #endif
262640 :
262641 : // Test the variant virtual function
262642 : // assert(ASSIGN_INIT == variant());
262643 18 : assert(ASSIGN_INIT == this->variant());
262644 18 : ROSE_ASSERT(ASSIGN_INIT == (int)(this->variantT()));
262645 18 : post_construction_initialization();
262646 :
262647 : // Test the isSgAssignInitializer() function since it has been problematic
262648 18 : assert(isSgAssignInitializer(this) != NULL);
262649 18 : }
262650 :
262651 : // Generated constructor (all data members)
262652 :
262653 : /* #line 262654 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262654 :
262655 :
262656 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
262657 :
262658 :
262659 : // ********************************************************
262660 : // member functions common across all array grammar objects
262661 : // ********************************************************
262662 :
262663 :
262664 :
262665 : /* #line 262666 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262666 :
262667 :
262668 :
262669 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
262670 :
262671 : // ********************************************************
262672 : // member functions specific to each node in the grammar
262673 : // ********************************************************
262674 :
262675 :
262676 : /* #line 262677 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
262677 :
262678 : // Start of memberFunctionString
262679 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
262680 :
262681 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
262682 :
262683 : SgExprListExp*
262684 0 : SgDesignatedInitializer::get_designatorList () const
262685 : {
262686 0 : ROSE_ASSERT (this != NULL);
262687 :
262688 : #if 0
262689 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
262690 : // used to trigger marking transformations for the token-based unparsing.
262691 : printf ("SgDesignatedInitializer::get_designatorList = %p = %s \n",this,this->class_name().c_str());
262692 : #endif
262693 :
262694 0 : return p_designatorList;
262695 : }
262696 :
262697 : void
262698 0 : SgDesignatedInitializer::set_designatorList ( SgExprListExp* designatorList )
262699 : {
262700 0 : ROSE_ASSERT (this != NULL);
262701 :
262702 : #if 0
262703 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
262704 : // used to trigger marking transformations for the token-based unparsing.
262705 : printf ("SgDesignatedInitializer::set_designatorList = %p = %s \n",this,this->class_name().c_str());
262706 : #endif
262707 :
262708 0 : set_isModified(true);
262709 :
262710 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
262711 : if (p_designatorList != NULL && designatorList != NULL && p_designatorList != designatorList)
262712 : {
262713 : printf ("Warning: designatorList = %p overwriting valid pointer p_designatorList = %p \n",designatorList,p_designatorList);
262714 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
262715 : printf ("Error fails assertion (p_designatorList != NULL && designatorList != NULL && p_designatorList != designatorList) is false\n");
262716 : ROSE_ASSERT(false);
262717 : #endif
262718 : }
262719 : #endif
262720 0 : p_designatorList = designatorList;
262721 0 : }
262722 :
262723 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
262724 :
262725 :
262726 : // End of memberFunctionString
262727 : // Start of memberFunctionString
262728 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
262729 :
262730 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
262731 :
262732 : SgInitializer*
262733 0 : SgDesignatedInitializer::get_memberInit () const
262734 : {
262735 0 : ROSE_ASSERT (this != NULL);
262736 :
262737 : #if 0
262738 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
262739 : // used to trigger marking transformations for the token-based unparsing.
262740 : printf ("SgDesignatedInitializer::get_memberInit = %p = %s \n",this,this->class_name().c_str());
262741 : #endif
262742 :
262743 0 : return p_memberInit;
262744 : }
262745 :
262746 : void
262747 0 : SgDesignatedInitializer::set_memberInit ( SgInitializer* memberInit )
262748 : {
262749 0 : ROSE_ASSERT (this != NULL);
262750 :
262751 : #if 0
262752 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
262753 : // used to trigger marking transformations for the token-based unparsing.
262754 : printf ("SgDesignatedInitializer::set_memberInit = %p = %s \n",this,this->class_name().c_str());
262755 : #endif
262756 :
262757 0 : set_isModified(true);
262758 :
262759 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
262760 : if (p_memberInit != NULL && memberInit != NULL && p_memberInit != memberInit)
262761 : {
262762 : printf ("Warning: memberInit = %p overwriting valid pointer p_memberInit = %p \n",memberInit,p_memberInit);
262763 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
262764 : printf ("Error fails assertion (p_memberInit != NULL && memberInit != NULL && p_memberInit != memberInit) is false\n");
262765 : ROSE_ASSERT(false);
262766 : #endif
262767 : }
262768 : #endif
262769 0 : p_memberInit = memberInit;
262770 0 : }
262771 :
262772 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
262773 :
262774 :
262775 : // End of memberFunctionString
262776 : // Start of memberFunctionString
262777 : /* #line 9110 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
262778 :
262779 :
262780 : void
262781 0 : SgDesignatedInitializer::post_construction_initialization()
262782 : {
262783 : // This should be a list of designators to handle the case of multi-deminsional array references.
262784 0 : ROSE_ASSERT(p_designatorList != NULL);
262785 0 : p_designatorList->set_parent(this);
262786 : // ROSE_ASSERT(p_designator != NULL);
262787 : // p_designator->set_parent(this);
262788 :
262789 0 : if (p_memberInit != NULL) // We want to support NULL p_memberInit when building this node
262790 : {
262791 0 : p_memberInit->set_parent(this);
262792 : }
262793 0 : }
262794 :
262795 : SgType*
262796 0 : SgDesignatedInitializer::get_type() const
262797 : {
262798 0 : ROSE_ASSERT(p_memberInit != NULL);
262799 :
262800 : #if 0
262801 : printf ("In SgDesignatedInitializer::get_type() \n");
262802 : #endif
262803 :
262804 0 : return p_memberInit->get_type();
262805 : }
262806 :
262807 : int
262808 0 : SgDesignatedInitializer::replace_expression(SgExpression *o, SgExpression *n)
262809 : {
262810 : // DQ (12/17/2006): This function should have the semantics that it will represent a
262811 : // structural change to the AST, thus it is free to set the parent of the new expression.
262812 :
262813 0 : ROSE_ASSERT(o != NULL);
262814 0 : ROSE_ASSERT(n != NULL);
262815 :
262816 0 : if (get_memberInit() == o)
262817 : {
262818 0 : ROSE_ASSERT (isSgInitializer(n));
262819 0 : set_memberInit(isSgInitializer(n));
262820 0 : n->set_parent(this);
262821 :
262822 : // Return 1 to indicate sucess.
262823 0 : return 1;
262824 : }
262825 0 : else if (get_designatorList() == o)
262826 : {
262827 0 : ROSE_ASSERT (isSgExprListExp(n));
262828 0 : set_designatorList(isSgExprListExp(n));
262829 : // set_designator(n);
262830 0 : n->set_parent(this);
262831 :
262832 : // Return 1 to indicate sucess.
262833 0 : return 1;
262834 : }
262835 : else
262836 : {
262837 : // Return 0 to indicate failure to match original expression ("o").
262838 : return 0;
262839 : }
262840 : }
262841 :
262842 : SgExpression*
262843 0 : SgDesignatedInitializer::get_next(int& n) const
262844 : {
262845 : // DQ (7/21/2013): This function should not be called and should be removed at some point.
262846 :
262847 0 : printf ("This function should not be called and should be removed at some point \n");
262848 0 : ROSE_ASSERT(false);
262849 :
262850 : // tps (12/9/2009) : MSC requires a return value
262851 : return NULL;
262852 : }
262853 :
262854 :
262855 :
262856 : // End of memberFunctionString
262857 : // Start of memberFunctionString
262858 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
262859 :
262860 : // *** COMMON CODE SECTION BEGINS HERE ***
262861 :
262862 : #if 0
262863 : int
262864 : SgDesignatedInitializer::getVariant() const
262865 : {
262866 : // This function is used in ROSE while "variant()" is used in SAGE
262867 : assert(this != NULL);
262868 : return variant();
262869 : }
262870 : #endif
262871 :
262872 : // This function is used in ROSE in treeTraversal code
262873 : // eventually replaces getVariant() and variant()
262874 : // though after variant() has been removed for a while we will
262875 : // want to change the name of variantT() back to variant()
262876 : // (since the "T" was ment to stand for temporary).
262877 : // When this happens the variantT() will be depricated.
262878 : VariantT
262879 0 : SgDesignatedInitializer::variantT() const
262880 : {
262881 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
262882 0 : ROSE_ASSERT(this != NULL);
262883 0 : return V_SgDesignatedInitializer;
262884 : }
262885 :
262886 : #if 0
262887 : int
262888 : SgDesignatedInitializer::variant() const
262889 : {
262890 : // This function is used in SAGE
262891 : ROSE_ASSERT(this != NULL);
262892 : return DESIGNATED_INITIALIZER;
262893 : }
262894 : #endif
262895 :
262896 : ROSE_DLL_API const char*
262897 0 : SgDesignatedInitializer::sage_class_name() const
262898 : {
262899 0 : ROSE_ASSERT(this != NULL);
262900 0 : return "SgDesignatedInitializer";
262901 : }
262902 :
262903 : std::string
262904 0 : SgDesignatedInitializer::class_name() const
262905 : {
262906 0 : ROSE_ASSERT(this != NULL);
262907 0 : return "SgDesignatedInitializer";
262908 : }
262909 :
262910 : // DQ (11/26/2005): Support for visitor pattern mechanims
262911 : // (inferior to ROSE traversal mechanism, experimental).
262912 : void
262913 0 : SgDesignatedInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
262914 : {
262915 0 : ROSE_ASSERT(this != NULL);
262916 0 : visitor.visit(this);
262917 0 : }
262918 :
262919 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
262920 0 : void SgDesignatedInitializer::accept (ROSE_VisitorPattern & visitor) {
262921 0 : ROSE_ASSERT(this != NULL);
262922 0 : visitor.visit(this);
262923 0 : }
262924 :
262925 : SgDesignatedInitializer*
262926 0 : SgDesignatedInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
262927 : {
262928 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
262929 : // This function is currently only supported for the AST used the represent Binary executables.
262930 : if (0 /* isSgAsmNode(this) != NULL */)
262931 : {
262932 : // Support for regex specification.
262933 : std::string prefixCode = "REGEX:";
262934 : addNewAttribute(prefixCode + s,a);
262935 : }
262936 : #endif
262937 :
262938 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
262939 0 : return this;
262940 : }
262941 :
262942 : // *** COMMON CODE SECTION ENDS HERE ***
262943 :
262944 :
262945 : // End of memberFunctionString
262946 : // Start of memberFunctionString
262947 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
262948 :
262949 :
262950 : #if 0
262951 : //! Error checking support
262952 : /*! Verifies the following:
262953 : - working getVariant() member function
262954 : - calls base class's error() member function
262955 : Every class has one of these functions.
262956 : */
262957 : bool
262958 : SgDesignatedInitializer::error()
262959 : {
262960 : // Put error checking here
262961 :
262962 : ROSE_ASSERT (this != NULL);
262963 : if (getVariant() != DESIGNATED_INITIALIZER)
262964 : {
262965 : printf ("Error in SgDesignatedInitializer::error(): SgDesignatedInitializer object has a %s variant \n",
262966 : Cxx_GrammarTerminalNames[getVariant()].name);
262967 : // printf ("Error in SgDesignatedInitializer::error() \n");
262968 : ROSE_ABORT();
262969 : }
262970 :
262971 : ROSE_ASSERT (getVariant() == DESIGNATED_INITIALIZER);
262972 : return SgInitializer::error();
262973 : }
262974 : #endif
262975 :
262976 :
262977 :
262978 : // End of memberFunctionString
262979 :
262980 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
262981 :
262982 5911 : SgDesignatedInitializer* isSgDesignatedInitializer ( SgNode* inputDerivedClassPointer )
262983 : {
262984 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
262985 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
262986 : // So to fix this we return NULL directly when the input is NULL and avoid the
262987 : // dynamic_cast in this case. This is likely a performance improvement as well.
262988 : // return dynamic_cast<SgDesignatedInitializer*>(inputDerivedClassPointer);
262989 : // Milind Chabbi (8/28/2013): isSgDesignatedInitializer uses table-driven castability instead of c++ default dynamic_cast
262990 : // this improves the running time performance by 10-20%.
262991 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDesignatedInitializer*>(inputDerivedClassPointer);
262992 5911 : return IS_SgDesignatedInitializer_FAST_MACRO(inputDerivedClassPointer);
262993 : }
262994 :
262995 : // DQ (11/8/2003): Added version of functions taking const pointer
262996 0 : const SgDesignatedInitializer* isSgDesignatedInitializer ( const SgNode* inputDerivedClassPointer )
262997 : {
262998 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
262999 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
263000 : // So to fix this we return NULL directly when the input is NULL and avoid the
263001 : // dynamic_cast in this case. This is likely a performance improvement as well.
263002 : // return dynamic_cast<const SgDesignatedInitializer*>(inputDerivedClassPointer);
263003 : // Milind Chabbi (8/28/2013): isSgDesignatedInitializer uses table-driven castability instead of c++ default dynamic_cast
263004 : // this improves the running time performance by 10-20%.
263005 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDesignatedInitializer*>(inputDerivedClassPointer);
263006 0 : return IS_SgDesignatedInitializer_FAST_MACRO(inputDerivedClassPointer);
263007 : }
263008 :
263009 :
263010 :
263011 : /* #line 263012 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263012 :
263013 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
263014 :
263015 : /**
263016 : \brief Generated destructor
263017 :
263018 : This destructor is automatically generated (by ROSETTA). This destructor
263019 : only frees memory of data members associated with the parts of the current IR node which
263020 : are NOT traversed. Those data members that are part of a traversal can be freed using
263021 : a traversal (calling this destructor on all children in a post-order traversal). Such
263022 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
263023 :
263024 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
263025 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
263026 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
263027 :
263028 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
263029 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
263030 : pointers are not yet implemented to call delete on eash pointer in the container.
263031 : (This could be done by derivation from the STL containers to define containers that
263032 : automatically deleted their members.)
263033 :
263034 : */
263035 0 : SgDesignatedInitializer::~SgDesignatedInitializer () {
263036 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
263037 :
263038 :
263039 : // case: not a listType for designatorList
263040 0 : p_designatorList = NULL; // non list case
263041 : // case: not a listType for memberInit
263042 0 : p_memberInit = NULL; // non list case
263043 :
263044 : }
263045 :
263046 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
263047 0 : }
263048 :
263049 :
263050 : /* #line 263051 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263051 :
263052 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
263053 :
263054 : // Generated constructor
263055 0 : SgDesignatedInitializer::SgDesignatedInitializer ( Sg_File_Info* startOfConstruct, SgExprListExp* designatorList, SgInitializer* memberInit )
263056 0 : : SgInitializer(startOfConstruct)
263057 : {
263058 : #ifdef DEBUG
263059 : // printf ("In SgDesignatedInitializer::SgDesignatedInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* designatorList, SgInitializer* memberInit) sage_class_name() = %s \n",sage_class_name());
263060 : #endif
263061 : #if 0
263062 : // debugging information!
263063 : printf ("In SgDesignatedInitializer::SgDesignatedInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* designatorList, SgInitializer* memberInit): this = %p = %s \n",this,this->class_name().c_str());
263064 : #endif
263065 :
263066 0 : p_designatorList = designatorList;
263067 0 : p_memberInit = memberInit;
263068 :
263069 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
263070 :
263071 : #if 0
263072 : // DQ (7/30/2014): Call a virtual function.
263073 : std::string s = this->class_name();
263074 : #endif
263075 :
263076 : // Test the variant virtual function
263077 : // assert(DESIGNATED_INITIALIZER == variant());
263078 0 : assert(DESIGNATED_INITIALIZER == this->variant());
263079 0 : ROSE_ASSERT(DESIGNATED_INITIALIZER == (int)(this->variantT()));
263080 0 : post_construction_initialization();
263081 :
263082 : // Test the isSgDesignatedInitializer() function since it has been problematic
263083 0 : assert(isSgDesignatedInitializer(this) != NULL);
263084 0 : }
263085 :
263086 : // Generated constructor (all data members)
263087 :
263088 : /* #line 263089 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263089 :
263090 :
263091 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
263092 :
263093 :
263094 : // ********************************************************
263095 : // member functions common across all array grammar objects
263096 : // ********************************************************
263097 :
263098 :
263099 :
263100 : /* #line 263101 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263101 :
263102 :
263103 :
263104 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
263105 :
263106 : // ********************************************************
263107 : // member functions specific to each node in the grammar
263108 : // ********************************************************
263109 :
263110 :
263111 : /* #line 263112 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263112 :
263113 : // Start of memberFunctionString
263114 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
263115 :
263116 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
263117 :
263118 : SgExprListExp*
263119 107 : SgBracedInitializer::get_initializers () const
263120 : {
263121 107 : ROSE_ASSERT (this != NULL);
263122 :
263123 : #if 0
263124 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263125 : // used to trigger marking transformations for the token-based unparsing.
263126 : printf ("SgBracedInitializer::get_initializers = %p = %s \n",this,this->class_name().c_str());
263127 : #endif
263128 :
263129 107 : return p_initializers;
263130 : }
263131 :
263132 : void
263133 0 : SgBracedInitializer::set_initializers ( SgExprListExp* initializers )
263134 : {
263135 0 : ROSE_ASSERT (this != NULL);
263136 :
263137 : #if 0
263138 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263139 : // used to trigger marking transformations for the token-based unparsing.
263140 : printf ("SgBracedInitializer::set_initializers = %p = %s \n",this,this->class_name().c_str());
263141 : #endif
263142 :
263143 0 : set_isModified(true);
263144 :
263145 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
263146 : if (p_initializers != NULL && initializers != NULL && p_initializers != initializers)
263147 : {
263148 : printf ("Warning: initializers = %p overwriting valid pointer p_initializers = %p \n",initializers,p_initializers);
263149 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
263150 : printf ("Error fails assertion (p_initializers != NULL && initializers != NULL && p_initializers != initializers) is false\n");
263151 : ROSE_ASSERT(false);
263152 : #endif
263153 : }
263154 : #endif
263155 0 : p_initializers = initializers;
263156 0 : }
263157 :
263158 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
263159 :
263160 :
263161 : // End of memberFunctionString
263162 : // Start of memberFunctionString
263163 :
263164 :
263165 : // End of memberFunctionString
263166 : // Start of memberFunctionString
263167 : /* #line 7844 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
263168 :
263169 :
263170 : void
263171 10 : SgBracedInitializer::post_construction_initialization()
263172 : {
263173 10 : if (get_initializers())
263174 10 : get_initializers()->set_parent(this);
263175 10 : }
263176 :
263177 : // DQ: trying to remove the nested iterator class
263178 : void
263179 0 : SgBracedInitializer::append_initializer(SgExpression* what)
263180 : {
263181 0 : assert(this != NULL);
263182 :
263183 : // DQ (11/15/2006): avoid setting newArgs this late in the process.
263184 0 : ROSE_ASSERT(p_initializers != NULL);
263185 0 : if(!p_initializers)
263186 : {
263187 : // set_initializers(new SgExprListExp(this->get_file_info()));
263188 : SgExprListExp* newArgs = new SgExprListExp ( this->get_file_info() );
263189 : assert(newArgs != NULL);
263190 : newArgs->set_endOfConstruct( this->get_file_info() );
263191 : set_initializers(newArgs);
263192 : }
263193 :
263194 : // insert_initializer(p_initializers->end(),what);
263195 0 : p_initializers->append_expression(what);
263196 0 : }
263197 :
263198 : SgExpression*
263199 0 : SgBracedInitializer::get_next(int& n) const
263200 : {
263201 0 : if(n==0)
263202 : {
263203 0 : n++;
263204 0 : return get_initializers();
263205 : }
263206 : else
263207 : return 0;
263208 : }
263209 :
263210 : int
263211 0 : SgBracedInitializer::replace_expression(SgExpression* o, SgExpression* n)
263212 : {
263213 : // DQ (12/17/2006): This function should have the semantics that it will represent a
263214 : // structural change to the AST, thus it is free to set the parent of the new expression.
263215 :
263216 0 : ROSE_ASSERT(o != NULL);
263217 0 : ROSE_ASSERT(n != NULL);
263218 :
263219 0 : if (get_initializers() == o)
263220 : {
263221 0 : set_initializers(isSgExprListExp(n));
263222 0 : n->set_parent(this);
263223 0 : return 1;
263224 : }
263225 : else
263226 : {
263227 : return 0;
263228 : }
263229 : }
263230 :
263231 : SgType*
263232 1 : SgBracedInitializer::get_type() const
263233 : {
263234 : #if 0
263235 : printf ("In SgAggregateInitializer::get_type() \n");
263236 : #endif
263237 :
263238 : #if 0
263239 : printf ("In SgAggregateInitializer::get_type(): p_expression_type = %p \n",p_expression_type);
263240 : #endif
263241 1 : if (p_expression_type != NULL)
263242 : {
263243 : #if 0
263244 : printf ("SgAggregateInitializer::get_type(): p_expression_type != NULL: return p_expression_type = %p = %s \n",p_expression_type,p_expression_type->class_name().c_str());
263245 : #endif
263246 : return p_expression_type;
263247 : }
263248 : else
263249 : {
263250 : #if 0
263251 : printf ("SgAggregateInitializer::get_type(): default case: return SgTypeDefault::createType()\n");
263252 : #endif
263253 1 : return SgTypeDefault::createType();
263254 : }
263255 : }
263256 :
263257 : #if 0
263258 : // DQ (11/15/2016): I don' think that name qualification maes sense for a braced initializer.
263259 :
263260 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
263261 : // so that we could avoid them setting the isModified flag which is a problem in the
263262 : // name qualification support for C++ (interfering with the token-based unparsing).
263263 : bool
263264 : SgBracedInitializer::get_requiresGlobalNameQualificationOnType () const
263265 : {
263266 : ROSE_ASSERT (this != NULL);
263267 : return p_requiresGlobalNameQualificationOnType;
263268 : }
263269 :
263270 : void
263271 : SgBracedInitializer::set_requiresGlobalNameQualificationOnType ( bool requiresGlobalNameQualificationOnType )
263272 : {
263273 : ROSE_ASSERT (this != NULL);
263274 : // This can't be called by the name qualification API (see test2015_26.C).
263275 : // set_isModified(true);
263276 :
263277 : p_requiresGlobalNameQualificationOnType = requiresGlobalNameQualificationOnType;
263278 : }
263279 :
263280 : int
263281 : SgBracedInitializer::get_name_qualification_length_for_type () const
263282 : {
263283 : ROSE_ASSERT (this != NULL);
263284 : return p_name_qualification_length_for_type;
263285 : }
263286 :
263287 : void
263288 : SgBracedInitializer::set_name_qualification_length_for_type ( int name_qualification_length_for_type )
263289 : {
263290 : ROSE_ASSERT (this != NULL);
263291 : // This can't be called by the name qualification API (see test2015_26.C).
263292 : // set_isModified(true);
263293 :
263294 : p_name_qualification_length_for_type = name_qualification_length_for_type;
263295 : }
263296 :
263297 : bool
263298 : SgBracedInitializer::get_type_elaboration_required_for_type () const
263299 : {
263300 : ROSE_ASSERT (this != NULL);
263301 : return p_type_elaboration_required_for_type;
263302 : }
263303 :
263304 : void
263305 : SgBracedInitializer::set_type_elaboration_required_for_type ( bool type_elaboration_required_for_type )
263306 : {
263307 : ROSE_ASSERT (this != NULL);
263308 : // This can't be called by the name qualification API (see test2015_26.C).
263309 : // set_isModified(true);
263310 :
263311 : p_type_elaboration_required_for_type = type_elaboration_required_for_type;
263312 : }
263313 :
263314 : bool
263315 : SgBracedInitializer::get_global_qualification_required_for_type () const
263316 : {
263317 : ROSE_ASSERT (this != NULL);
263318 : return p_global_qualification_required_for_type;
263319 : }
263320 :
263321 : void
263322 : SgBracedInitializer::set_global_qualification_required_for_type ( bool global_qualification_required_for_type )
263323 : {
263324 : ROSE_ASSERT (this != NULL);
263325 : // This can't be called by the name qualification API (see test2015_26.C).
263326 : // set_isModified(true);
263327 :
263328 : p_global_qualification_required_for_type = global_qualification_required_for_type;
263329 : }
263330 : #endif
263331 :
263332 :
263333 :
263334 : // End of memberFunctionString
263335 : // Start of memberFunctionString
263336 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
263337 :
263338 : // *** COMMON CODE SECTION BEGINS HERE ***
263339 :
263340 : #if 0
263341 : int
263342 : SgBracedInitializer::getVariant() const
263343 : {
263344 : // This function is used in ROSE while "variant()" is used in SAGE
263345 : assert(this != NULL);
263346 : return variant();
263347 : }
263348 : #endif
263349 :
263350 : // This function is used in ROSE in treeTraversal code
263351 : // eventually replaces getVariant() and variant()
263352 : // though after variant() has been removed for a while we will
263353 : // want to change the name of variantT() back to variant()
263354 : // (since the "T" was ment to stand for temporary).
263355 : // When this happens the variantT() will be depricated.
263356 : VariantT
263357 1138 : SgBracedInitializer::variantT() const
263358 : {
263359 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
263360 1138 : ROSE_ASSERT(this != NULL);
263361 1138 : return V_SgBracedInitializer;
263362 : }
263363 :
263364 : #if 0
263365 : int
263366 : SgBracedInitializer::variant() const
263367 : {
263368 : // This function is used in SAGE
263369 : ROSE_ASSERT(this != NULL);
263370 : return BRACED_INIT;
263371 : }
263372 : #endif
263373 :
263374 : ROSE_DLL_API const char*
263375 0 : SgBracedInitializer::sage_class_name() const
263376 : {
263377 0 : ROSE_ASSERT(this != NULL);
263378 0 : return "SgBracedInitializer";
263379 : }
263380 :
263381 : std::string
263382 8 : SgBracedInitializer::class_name() const
263383 : {
263384 8 : ROSE_ASSERT(this != NULL);
263385 8 : return "SgBracedInitializer";
263386 : }
263387 :
263388 : // DQ (11/26/2005): Support for visitor pattern mechanims
263389 : // (inferior to ROSE traversal mechanism, experimental).
263390 : void
263391 137 : SgBracedInitializer::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
263392 : {
263393 137 : ROSE_ASSERT(this != NULL);
263394 137 : visitor.visit(this);
263395 137 : }
263396 :
263397 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
263398 0 : void SgBracedInitializer::accept (ROSE_VisitorPattern & visitor) {
263399 0 : ROSE_ASSERT(this != NULL);
263400 0 : visitor.visit(this);
263401 0 : }
263402 :
263403 : SgBracedInitializer*
263404 0 : SgBracedInitializer::addRegExpAttribute(std::string s, AstRegExAttribute* a)
263405 : {
263406 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
263407 : // This function is currently only supported for the AST used the represent Binary executables.
263408 : if (0 /* isSgAsmNode(this) != NULL */)
263409 : {
263410 : // Support for regex specification.
263411 : std::string prefixCode = "REGEX:";
263412 : addNewAttribute(prefixCode + s,a);
263413 : }
263414 : #endif
263415 :
263416 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
263417 0 : return this;
263418 : }
263419 :
263420 : // *** COMMON CODE SECTION ENDS HERE ***
263421 :
263422 :
263423 : // End of memberFunctionString
263424 : // Start of memberFunctionString
263425 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
263426 :
263427 :
263428 : #if 0
263429 : //! Error checking support
263430 : /*! Verifies the following:
263431 : - working getVariant() member function
263432 : - calls base class's error() member function
263433 : Every class has one of these functions.
263434 : */
263435 : bool
263436 : SgBracedInitializer::error()
263437 : {
263438 : // Put error checking here
263439 :
263440 : ROSE_ASSERT (this != NULL);
263441 : if (getVariant() != BRACED_INIT)
263442 : {
263443 : printf ("Error in SgBracedInitializer::error(): SgBracedInitializer object has a %s variant \n",
263444 : Cxx_GrammarTerminalNames[getVariant()].name);
263445 : // printf ("Error in SgBracedInitializer::error() \n");
263446 : ROSE_ABORT();
263447 : }
263448 :
263449 : ROSE_ASSERT (getVariant() == BRACED_INIT);
263450 : return SgInitializer::error();
263451 : }
263452 : #endif
263453 :
263454 :
263455 :
263456 : // End of memberFunctionString
263457 :
263458 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
263459 :
263460 11 : SgBracedInitializer* isSgBracedInitializer ( SgNode* inputDerivedClassPointer )
263461 : {
263462 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
263463 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
263464 : // So to fix this we return NULL directly when the input is NULL and avoid the
263465 : // dynamic_cast in this case. This is likely a performance improvement as well.
263466 : // return dynamic_cast<SgBracedInitializer*>(inputDerivedClassPointer);
263467 : // Milind Chabbi (8/28/2013): isSgBracedInitializer uses table-driven castability instead of c++ default dynamic_cast
263468 : // this improves the running time performance by 10-20%.
263469 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgBracedInitializer*>(inputDerivedClassPointer);
263470 11 : return IS_SgBracedInitializer_FAST_MACRO(inputDerivedClassPointer);
263471 : }
263472 :
263473 : // DQ (11/8/2003): Added version of functions taking const pointer
263474 86 : const SgBracedInitializer* isSgBracedInitializer ( const SgNode* inputDerivedClassPointer )
263475 : {
263476 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
263477 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
263478 : // So to fix this we return NULL directly when the input is NULL and avoid the
263479 : // dynamic_cast in this case. This is likely a performance improvement as well.
263480 : // return dynamic_cast<const SgBracedInitializer*>(inputDerivedClassPointer);
263481 : // Milind Chabbi (8/28/2013): isSgBracedInitializer uses table-driven castability instead of c++ default dynamic_cast
263482 : // this improves the running time performance by 10-20%.
263483 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgBracedInitializer*>(inputDerivedClassPointer);
263484 86 : return IS_SgBracedInitializer_FAST_MACRO(inputDerivedClassPointer);
263485 : }
263486 :
263487 :
263488 :
263489 : /* #line 263490 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263490 :
263491 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
263492 :
263493 : /**
263494 : \brief Generated destructor
263495 :
263496 : This destructor is automatically generated (by ROSETTA). This destructor
263497 : only frees memory of data members associated with the parts of the current IR node which
263498 : are NOT traversed. Those data members that are part of a traversal can be freed using
263499 : a traversal (calling this destructor on all children in a post-order traversal). Such
263500 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
263501 :
263502 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
263503 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
263504 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
263505 :
263506 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
263507 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
263508 : pointers are not yet implemented to call delete on eash pointer in the container.
263509 : (This could be done by derivation from the STL containers to define containers that
263510 : automatically deleted their members.)
263511 :
263512 : */
263513 4 : SgBracedInitializer::~SgBracedInitializer () {
263514 2 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
263515 :
263516 :
263517 : // case: not a listType for initializers
263518 2 : p_initializers = NULL; // non list case
263519 : // case: not a listType for expression_type
263520 2 : p_expression_type = NULL; // non list case
263521 :
263522 : }
263523 :
263524 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
263525 4 : }
263526 :
263527 :
263528 : /* #line 263529 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263529 :
263530 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
263531 :
263532 : // Generated constructor
263533 0 : SgBracedInitializer::SgBracedInitializer ( Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type )
263534 0 : : SgInitializer(startOfConstruct)
263535 : {
263536 : #ifdef DEBUG
263537 : // printf ("In SgBracedInitializer::SgBracedInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
263538 : #endif
263539 : #if 0
263540 : // debugging information!
263541 : printf ("In SgBracedInitializer::SgBracedInitializer (Sg_File_Info* startOfConstruct, SgExprListExp* initializers, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
263542 : #endif
263543 :
263544 0 : p_initializers = initializers;
263545 0 : p_expression_type = expression_type;
263546 :
263547 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
263548 :
263549 : #if 0
263550 : // DQ (7/30/2014): Call a virtual function.
263551 : std::string s = this->class_name();
263552 : #endif
263553 :
263554 : // Test the variant virtual function
263555 : // assert(BRACED_INIT == variant());
263556 0 : assert(BRACED_INIT == this->variant());
263557 0 : ROSE_ASSERT(BRACED_INIT == (int)(this->variantT()));
263558 0 : post_construction_initialization();
263559 :
263560 : // Test the isSgBracedInitializer() function since it has been problematic
263561 0 : assert(isSgBracedInitializer(this) != NULL);
263562 0 : }
263563 :
263564 : // Generated constructor (all data members)
263565 :
263566 : /* #line 263567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263567 :
263568 :
263569 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
263570 :
263571 :
263572 : // ********************************************************
263573 : // member functions common across all array grammar objects
263574 : // ********************************************************
263575 :
263576 :
263577 :
263578 : /* #line 263579 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263579 :
263580 :
263581 :
263582 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
263583 :
263584 : // ********************************************************
263585 : // member functions specific to each node in the grammar
263586 : // ********************************************************
263587 :
263588 :
263589 : /* #line 263590 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263590 :
263591 : // Start of memberFunctionString
263592 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
263593 :
263594 : void
263595 0 : SgVarArgStartOp::post_construction_initialization()
263596 : {
263597 0 : }
263598 :
263599 :
263600 :
263601 : // End of memberFunctionString
263602 : // Start of memberFunctionString
263603 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
263604 :
263605 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
263606 :
263607 : SgExpression*
263608 0 : SgVarArgStartOp::get_lhs_operand () const
263609 : {
263610 0 : ROSE_ASSERT (this != NULL);
263611 :
263612 : #if 0
263613 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263614 : // used to trigger marking transformations for the token-based unparsing.
263615 : printf ("SgVarArgStartOp::get_lhs_operand = %p = %s \n",this,this->class_name().c_str());
263616 : #endif
263617 :
263618 0 : return p_lhs_operand;
263619 : }
263620 :
263621 : void
263622 0 : SgVarArgStartOp::set_lhs_operand ( SgExpression* lhs_operand )
263623 : {
263624 0 : ROSE_ASSERT (this != NULL);
263625 :
263626 : #if 0
263627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263628 : // used to trigger marking transformations for the token-based unparsing.
263629 : printf ("SgVarArgStartOp::set_lhs_operand = %p = %s \n",this,this->class_name().c_str());
263630 : #endif
263631 :
263632 0 : set_isModified(true);
263633 :
263634 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
263635 : if (p_lhs_operand != NULL && lhs_operand != NULL && p_lhs_operand != lhs_operand)
263636 : {
263637 : printf ("Warning: lhs_operand = %p overwriting valid pointer p_lhs_operand = %p \n",lhs_operand,p_lhs_operand);
263638 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
263639 : printf ("Error fails assertion (p_lhs_operand != NULL && lhs_operand != NULL && p_lhs_operand != lhs_operand) is false\n");
263640 : ROSE_ASSERT(false);
263641 : #endif
263642 : }
263643 : #endif
263644 0 : p_lhs_operand = lhs_operand;
263645 0 : }
263646 :
263647 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
263648 :
263649 :
263650 : // End of memberFunctionString
263651 : // Start of memberFunctionString
263652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
263653 :
263654 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
263655 :
263656 : SgExpression*
263657 0 : SgVarArgStartOp::get_rhs_operand () const
263658 : {
263659 0 : ROSE_ASSERT (this != NULL);
263660 :
263661 : #if 0
263662 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263663 : // used to trigger marking transformations for the token-based unparsing.
263664 : printf ("SgVarArgStartOp::get_rhs_operand = %p = %s \n",this,this->class_name().c_str());
263665 : #endif
263666 :
263667 0 : return p_rhs_operand;
263668 : }
263669 :
263670 : void
263671 0 : SgVarArgStartOp::set_rhs_operand ( SgExpression* rhs_operand )
263672 : {
263673 0 : ROSE_ASSERT (this != NULL);
263674 :
263675 : #if 0
263676 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263677 : // used to trigger marking transformations for the token-based unparsing.
263678 : printf ("SgVarArgStartOp::set_rhs_operand = %p = %s \n",this,this->class_name().c_str());
263679 : #endif
263680 :
263681 0 : set_isModified(true);
263682 :
263683 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
263684 : if (p_rhs_operand != NULL && rhs_operand != NULL && p_rhs_operand != rhs_operand)
263685 : {
263686 : printf ("Warning: rhs_operand = %p overwriting valid pointer p_rhs_operand = %p \n",rhs_operand,p_rhs_operand);
263687 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
263688 : printf ("Error fails assertion (p_rhs_operand != NULL && rhs_operand != NULL && p_rhs_operand != rhs_operand) is false\n");
263689 : ROSE_ASSERT(false);
263690 : #endif
263691 : }
263692 : #endif
263693 0 : p_rhs_operand = rhs_operand;
263694 0 : }
263695 :
263696 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
263697 :
263698 :
263699 : // End of memberFunctionString
263700 : // Start of memberFunctionString
263701 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
263702 :
263703 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
263704 :
263705 : SgType*
263706 0 : SgVarArgStartOp::get_expression_type () const
263707 : {
263708 0 : ROSE_ASSERT (this != NULL);
263709 :
263710 : #if 0
263711 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263712 : // used to trigger marking transformations for the token-based unparsing.
263713 : printf ("SgVarArgStartOp::get_expression_type = %p = %s \n",this,this->class_name().c_str());
263714 : #endif
263715 :
263716 0 : return p_expression_type;
263717 : }
263718 :
263719 : void
263720 0 : SgVarArgStartOp::set_expression_type ( SgType* expression_type )
263721 : {
263722 0 : ROSE_ASSERT (this != NULL);
263723 :
263724 : #if 0
263725 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
263726 : // used to trigger marking transformations for the token-based unparsing.
263727 : printf ("SgVarArgStartOp::set_expression_type = %p = %s \n",this,this->class_name().c_str());
263728 : #endif
263729 :
263730 0 : set_isModified(true);
263731 :
263732 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
263733 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
263734 : {
263735 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
263736 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
263737 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
263738 : ROSE_ASSERT(false);
263739 : #endif
263740 : }
263741 : #endif
263742 0 : p_expression_type = expression_type;
263743 0 : }
263744 :
263745 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
263746 :
263747 :
263748 : // End of memberFunctionString
263749 : // Start of memberFunctionString
263750 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
263751 :
263752 : SgType*
263753 :
263754 0 : SgVarArgStartOp::get_type() const
263755 : {
263756 0 : ROSE_ASSERT(this != NULL);
263757 :
263758 : #if 0
263759 : printf ("In SgVarArgStartOp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
263760 : #endif
263761 :
263762 : // DQ (10/31/2016): Debugging...
263763 : // return SgTypeDefault::createType();
263764 0 : SgType* returnType = SgTypeDefault::createType();
263765 :
263766 : #if 0
263767 : printf ("Leaving SgVarArgStartOp::get_type() (default_get_type) returnType = %p \n",returnType);
263768 : #endif
263769 :
263770 0 : return returnType;
263771 : }
263772 :
263773 :
263774 :
263775 : // End of memberFunctionString
263776 : // Start of memberFunctionString
263777 : /* #line 5792 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
263778 :
263779 :
263780 :
263781 : // End of memberFunctionString
263782 : // Start of memberFunctionString
263783 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
263784 :
263785 : // *** COMMON CODE SECTION BEGINS HERE ***
263786 :
263787 : #if 0
263788 : int
263789 : SgVarArgStartOp::getVariant() const
263790 : {
263791 : // This function is used in ROSE while "variant()" is used in SAGE
263792 : assert(this != NULL);
263793 : return variant();
263794 : }
263795 : #endif
263796 :
263797 : // This function is used in ROSE in treeTraversal code
263798 : // eventually replaces getVariant() and variant()
263799 : // though after variant() has been removed for a while we will
263800 : // want to change the name of variantT() back to variant()
263801 : // (since the "T" was ment to stand for temporary).
263802 : // When this happens the variantT() will be depricated.
263803 : VariantT
263804 0 : SgVarArgStartOp::variantT() const
263805 : {
263806 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
263807 0 : ROSE_ASSERT(this != NULL);
263808 0 : return V_SgVarArgStartOp;
263809 : }
263810 :
263811 : #if 0
263812 : int
263813 : SgVarArgStartOp::variant() const
263814 : {
263815 : // This function is used in SAGE
263816 : ROSE_ASSERT(this != NULL);
263817 : return VA_START_OP;
263818 : }
263819 : #endif
263820 :
263821 : ROSE_DLL_API const char*
263822 0 : SgVarArgStartOp::sage_class_name() const
263823 : {
263824 0 : ROSE_ASSERT(this != NULL);
263825 0 : return "SgVarArgStartOp";
263826 : }
263827 :
263828 : std::string
263829 0 : SgVarArgStartOp::class_name() const
263830 : {
263831 0 : ROSE_ASSERT(this != NULL);
263832 0 : return "SgVarArgStartOp";
263833 : }
263834 :
263835 : // DQ (11/26/2005): Support for visitor pattern mechanims
263836 : // (inferior to ROSE traversal mechanism, experimental).
263837 : void
263838 0 : SgVarArgStartOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
263839 : {
263840 0 : ROSE_ASSERT(this != NULL);
263841 0 : visitor.visit(this);
263842 0 : }
263843 :
263844 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
263845 0 : void SgVarArgStartOp::accept (ROSE_VisitorPattern & visitor) {
263846 0 : ROSE_ASSERT(this != NULL);
263847 0 : visitor.visit(this);
263848 0 : }
263849 :
263850 : SgVarArgStartOp*
263851 0 : SgVarArgStartOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
263852 : {
263853 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
263854 : // This function is currently only supported for the AST used the represent Binary executables.
263855 : if (0 /* isSgAsmNode(this) != NULL */)
263856 : {
263857 : // Support for regex specification.
263858 : std::string prefixCode = "REGEX:";
263859 : addNewAttribute(prefixCode + s,a);
263860 : }
263861 : #endif
263862 :
263863 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
263864 0 : return this;
263865 : }
263866 :
263867 : // *** COMMON CODE SECTION ENDS HERE ***
263868 :
263869 :
263870 : // End of memberFunctionString
263871 : // Start of memberFunctionString
263872 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
263873 :
263874 :
263875 : #if 0
263876 : //! Error checking support
263877 : /*! Verifies the following:
263878 : - working getVariant() member function
263879 : - calls base class's error() member function
263880 : Every class has one of these functions.
263881 : */
263882 : bool
263883 : SgVarArgStartOp::error()
263884 : {
263885 : // Put error checking here
263886 :
263887 : ROSE_ASSERT (this != NULL);
263888 : if (getVariant() != VA_START_OP)
263889 : {
263890 : printf ("Error in SgVarArgStartOp::error(): SgVarArgStartOp object has a %s variant \n",
263891 : Cxx_GrammarTerminalNames[getVariant()].name);
263892 : // printf ("Error in SgVarArgStartOp::error() \n");
263893 : ROSE_ABORT();
263894 : }
263895 :
263896 : ROSE_ASSERT (getVariant() == VA_START_OP);
263897 : return SgExpression::error();
263898 : }
263899 : #endif
263900 :
263901 :
263902 :
263903 : // End of memberFunctionString
263904 :
263905 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
263906 :
263907 2 : SgVarArgStartOp* isSgVarArgStartOp ( SgNode* inputDerivedClassPointer )
263908 : {
263909 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
263910 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
263911 : // So to fix this we return NULL directly when the input is NULL and avoid the
263912 : // dynamic_cast in this case. This is likely a performance improvement as well.
263913 : // return dynamic_cast<SgVarArgStartOp*>(inputDerivedClassPointer);
263914 : // Milind Chabbi (8/28/2013): isSgVarArgStartOp uses table-driven castability instead of c++ default dynamic_cast
263915 : // this improves the running time performance by 10-20%.
263916 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVarArgStartOp*>(inputDerivedClassPointer);
263917 2 : return IS_SgVarArgStartOp_FAST_MACRO(inputDerivedClassPointer);
263918 : }
263919 :
263920 : // DQ (11/8/2003): Added version of functions taking const pointer
263921 0 : const SgVarArgStartOp* isSgVarArgStartOp ( const SgNode* inputDerivedClassPointer )
263922 : {
263923 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
263924 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
263925 : // So to fix this we return NULL directly when the input is NULL and avoid the
263926 : // dynamic_cast in this case. This is likely a performance improvement as well.
263927 : // return dynamic_cast<const SgVarArgStartOp*>(inputDerivedClassPointer);
263928 : // Milind Chabbi (8/28/2013): isSgVarArgStartOp uses table-driven castability instead of c++ default dynamic_cast
263929 : // this improves the running time performance by 10-20%.
263930 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVarArgStartOp*>(inputDerivedClassPointer);
263931 0 : return IS_SgVarArgStartOp_FAST_MACRO(inputDerivedClassPointer);
263932 : }
263933 :
263934 :
263935 :
263936 : /* #line 263937 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263937 :
263938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
263939 :
263940 : /**
263941 : \brief Generated destructor
263942 :
263943 : This destructor is automatically generated (by ROSETTA). This destructor
263944 : only frees memory of data members associated with the parts of the current IR node which
263945 : are NOT traversed. Those data members that are part of a traversal can be freed using
263946 : a traversal (calling this destructor on all children in a post-order traversal). Such
263947 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
263948 :
263949 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
263950 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
263951 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
263952 :
263953 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
263954 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
263955 : pointers are not yet implemented to call delete on eash pointer in the container.
263956 : (This could be done by derivation from the STL containers to define containers that
263957 : automatically deleted their members.)
263958 :
263959 : */
263960 0 : SgVarArgStartOp::~SgVarArgStartOp () {
263961 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
263962 :
263963 :
263964 : // case: not a listType for lhs_operand
263965 0 : p_lhs_operand = NULL; // non list case
263966 : // case: not a listType for rhs_operand
263967 0 : p_rhs_operand = NULL; // non list case
263968 : // case: not a listType for expression_type
263969 0 : p_expression_type = NULL; // non list case
263970 :
263971 : }
263972 :
263973 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
263974 0 : }
263975 :
263976 :
263977 : /* #line 263978 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
263978 :
263979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
263980 :
263981 : // Generated constructor
263982 0 : SgVarArgStartOp::SgVarArgStartOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand, SgExpression* rhs_operand, SgType* expression_type )
263983 0 : : SgExpression(startOfConstruct)
263984 : {
263985 : #ifdef DEBUG
263986 : // printf ("In SgVarArgStartOp::SgVarArgStartOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand, SgExpression* rhs_operand, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
263987 : #endif
263988 : #if 0
263989 : // debugging information!
263990 : printf ("In SgVarArgStartOp::SgVarArgStartOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand, SgExpression* rhs_operand, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
263991 : #endif
263992 :
263993 0 : p_lhs_operand = lhs_operand;
263994 0 : p_rhs_operand = rhs_operand;
263995 0 : p_expression_type = expression_type;
263996 :
263997 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
263998 :
263999 : #if 0
264000 : // DQ (7/30/2014): Call a virtual function.
264001 : std::string s = this->class_name();
264002 : #endif
264003 :
264004 : // Test the variant virtual function
264005 : // assert(VA_START_OP == variant());
264006 0 : assert(VA_START_OP == this->variant());
264007 0 : ROSE_ASSERT(VA_START_OP == (int)(this->variantT()));
264008 0 : post_construction_initialization();
264009 :
264010 : // Test the isSgVarArgStartOp() function since it has been problematic
264011 0 : assert(isSgVarArgStartOp(this) != NULL);
264012 0 : }
264013 :
264014 : // Generated constructor (all data members)
264015 :
264016 : /* #line 264017 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264017 :
264018 :
264019 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
264020 :
264021 :
264022 : // ********************************************************
264023 : // member functions common across all array grammar objects
264024 : // ********************************************************
264025 :
264026 :
264027 :
264028 : /* #line 264029 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264029 :
264030 :
264031 :
264032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
264033 :
264034 : // ********************************************************
264035 : // member functions specific to each node in the grammar
264036 : // ********************************************************
264037 :
264038 :
264039 : /* #line 264040 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264040 :
264041 : // Start of memberFunctionString
264042 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
264043 :
264044 : void
264045 0 : SgVarArgOp::post_construction_initialization()
264046 : {
264047 0 : }
264048 :
264049 :
264050 :
264051 : // End of memberFunctionString
264052 : // Start of memberFunctionString
264053 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264054 :
264055 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264056 :
264057 : SgExpression*
264058 0 : SgVarArgOp::get_operand_expr () const
264059 : {
264060 0 : ROSE_ASSERT (this != NULL);
264061 :
264062 : #if 0
264063 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264064 : // used to trigger marking transformations for the token-based unparsing.
264065 : printf ("SgVarArgOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
264066 : #endif
264067 :
264068 0 : return p_operand_expr;
264069 : }
264070 :
264071 : void
264072 0 : SgVarArgOp::set_operand_expr ( SgExpression* operand_expr )
264073 : {
264074 0 : ROSE_ASSERT (this != NULL);
264075 :
264076 : #if 0
264077 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264078 : // used to trigger marking transformations for the token-based unparsing.
264079 : printf ("SgVarArgOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
264080 : #endif
264081 :
264082 0 : set_isModified(true);
264083 :
264084 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
264085 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
264086 : {
264087 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
264088 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
264089 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
264090 : ROSE_ASSERT(false);
264091 : #endif
264092 : }
264093 : #endif
264094 0 : p_operand_expr = operand_expr;
264095 0 : }
264096 :
264097 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
264098 :
264099 :
264100 : // End of memberFunctionString
264101 : // Start of memberFunctionString
264102 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264103 :
264104 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264105 :
264106 : SgType*
264107 0 : SgVarArgOp::get_expression_type () const
264108 : {
264109 0 : ROSE_ASSERT (this != NULL);
264110 :
264111 : #if 0
264112 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264113 : // used to trigger marking transformations for the token-based unparsing.
264114 : printf ("SgVarArgOp::get_expression_type = %p = %s \n",this,this->class_name().c_str());
264115 : #endif
264116 :
264117 0 : return p_expression_type;
264118 : }
264119 :
264120 : void
264121 0 : SgVarArgOp::set_expression_type ( SgType* expression_type )
264122 : {
264123 0 : ROSE_ASSERT (this != NULL);
264124 :
264125 : #if 0
264126 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264127 : // used to trigger marking transformations for the token-based unparsing.
264128 : printf ("SgVarArgOp::set_expression_type = %p = %s \n",this,this->class_name().c_str());
264129 : #endif
264130 :
264131 0 : set_isModified(true);
264132 :
264133 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
264134 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
264135 : {
264136 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
264137 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
264138 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
264139 : ROSE_ASSERT(false);
264140 : #endif
264141 : }
264142 : #endif
264143 0 : p_expression_type = expression_type;
264144 0 : }
264145 :
264146 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
264147 :
264148 :
264149 : // End of memberFunctionString
264150 : // Start of memberFunctionString
264151 : /* #line 5796 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
264152 :
264153 :
264154 : #if 0
264155 : // There is a set_expression_type function alread, soe we don't need this.
264156 : // DQ (1/17/2008): Added set_type function since this is one of a few IR nodes that require
264157 : // the type to be held explicitly, for all other IR nodes the type is computed dynamicly.
264158 : void
264159 : SgVarArgOp::set_type( SgType* type )
264160 : {
264161 : p_expression_type = type;
264162 : }
264163 : #endif
264164 :
264165 : // This function helps to provide a uniform interface even though the type is help in a field called p_expression_type.
264166 : SgType*
264167 0 : SgVarArgOp::get_type() const
264168 : {
264169 : // This function returns an explicitly stored type
264170 :
264171 0 : SgType* returnType = p_expression_type;
264172 :
264173 : #if 0
264174 : printf ("In SgVarArgOp::get_type() \n");
264175 : #endif
264176 :
264177 0 : ROSE_ASSERT(returnType != NULL);
264178 0 : return returnType;
264179 : }
264180 :
264181 :
264182 : int
264183 0 : SgVarArgOp::replace_expression(SgExpression *o, SgExpression *n)
264184 : {
264185 :
264186 0 : ROSE_ASSERT(o != NULL);
264187 0 : ROSE_ASSERT(n != NULL);
264188 :
264189 0 : if (get_operand_expr() == o)
264190 : {
264191 0 : set_operand_expr(n);
264192 0 : return 1;
264193 : }
264194 : else
264195 : {
264196 0 : printf ("Warning: inside of SgVarArgOp::replace_expression original SgExpression unidentified \n");
264197 0 : return 0;
264198 : }
264199 : }
264200 :
264201 :
264202 :
264203 : // End of memberFunctionString
264204 : // Start of memberFunctionString
264205 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
264206 :
264207 : // *** COMMON CODE SECTION BEGINS HERE ***
264208 :
264209 : #if 0
264210 : int
264211 : SgVarArgOp::getVariant() const
264212 : {
264213 : // This function is used in ROSE while "variant()" is used in SAGE
264214 : assert(this != NULL);
264215 : return variant();
264216 : }
264217 : #endif
264218 :
264219 : // This function is used in ROSE in treeTraversal code
264220 : // eventually replaces getVariant() and variant()
264221 : // though after variant() has been removed for a while we will
264222 : // want to change the name of variantT() back to variant()
264223 : // (since the "T" was ment to stand for temporary).
264224 : // When this happens the variantT() will be depricated.
264225 : VariantT
264226 0 : SgVarArgOp::variantT() const
264227 : {
264228 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
264229 0 : ROSE_ASSERT(this != NULL);
264230 0 : return V_SgVarArgOp;
264231 : }
264232 :
264233 : #if 0
264234 : int
264235 : SgVarArgOp::variant() const
264236 : {
264237 : // This function is used in SAGE
264238 : ROSE_ASSERT(this != NULL);
264239 : return VA_OP;
264240 : }
264241 : #endif
264242 :
264243 : ROSE_DLL_API const char*
264244 0 : SgVarArgOp::sage_class_name() const
264245 : {
264246 0 : ROSE_ASSERT(this != NULL);
264247 0 : return "SgVarArgOp";
264248 : }
264249 :
264250 : std::string
264251 0 : SgVarArgOp::class_name() const
264252 : {
264253 0 : ROSE_ASSERT(this != NULL);
264254 0 : return "SgVarArgOp";
264255 : }
264256 :
264257 : // DQ (11/26/2005): Support for visitor pattern mechanims
264258 : // (inferior to ROSE traversal mechanism, experimental).
264259 : void
264260 0 : SgVarArgOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
264261 : {
264262 0 : ROSE_ASSERT(this != NULL);
264263 0 : visitor.visit(this);
264264 0 : }
264265 :
264266 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
264267 0 : void SgVarArgOp::accept (ROSE_VisitorPattern & visitor) {
264268 0 : ROSE_ASSERT(this != NULL);
264269 0 : visitor.visit(this);
264270 0 : }
264271 :
264272 : SgVarArgOp*
264273 0 : SgVarArgOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
264274 : {
264275 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
264276 : // This function is currently only supported for the AST used the represent Binary executables.
264277 : if (0 /* isSgAsmNode(this) != NULL */)
264278 : {
264279 : // Support for regex specification.
264280 : std::string prefixCode = "REGEX:";
264281 : addNewAttribute(prefixCode + s,a);
264282 : }
264283 : #endif
264284 :
264285 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
264286 0 : return this;
264287 : }
264288 :
264289 : // *** COMMON CODE SECTION ENDS HERE ***
264290 :
264291 :
264292 : // End of memberFunctionString
264293 : // Start of memberFunctionString
264294 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
264295 :
264296 :
264297 : #if 0
264298 : //! Error checking support
264299 : /*! Verifies the following:
264300 : - working getVariant() member function
264301 : - calls base class's error() member function
264302 : Every class has one of these functions.
264303 : */
264304 : bool
264305 : SgVarArgOp::error()
264306 : {
264307 : // Put error checking here
264308 :
264309 : ROSE_ASSERT (this != NULL);
264310 : if (getVariant() != VA_OP)
264311 : {
264312 : printf ("Error in SgVarArgOp::error(): SgVarArgOp object has a %s variant \n",
264313 : Cxx_GrammarTerminalNames[getVariant()].name);
264314 : // printf ("Error in SgVarArgOp::error() \n");
264315 : ROSE_ABORT();
264316 : }
264317 :
264318 : ROSE_ASSERT (getVariant() == VA_OP);
264319 : return SgExpression::error();
264320 : }
264321 : #endif
264322 :
264323 :
264324 :
264325 : // End of memberFunctionString
264326 :
264327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
264328 :
264329 0 : SgVarArgOp* isSgVarArgOp ( SgNode* inputDerivedClassPointer )
264330 : {
264331 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
264332 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
264333 : // So to fix this we return NULL directly when the input is NULL and avoid the
264334 : // dynamic_cast in this case. This is likely a performance improvement as well.
264335 : // return dynamic_cast<SgVarArgOp*>(inputDerivedClassPointer);
264336 : // Milind Chabbi (8/28/2013): isSgVarArgOp uses table-driven castability instead of c++ default dynamic_cast
264337 : // this improves the running time performance by 10-20%.
264338 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVarArgOp*>(inputDerivedClassPointer);
264339 0 : return IS_SgVarArgOp_FAST_MACRO(inputDerivedClassPointer);
264340 : }
264341 :
264342 : // DQ (11/8/2003): Added version of functions taking const pointer
264343 0 : const SgVarArgOp* isSgVarArgOp ( const SgNode* inputDerivedClassPointer )
264344 : {
264345 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
264346 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
264347 : // So to fix this we return NULL directly when the input is NULL and avoid the
264348 : // dynamic_cast in this case. This is likely a performance improvement as well.
264349 : // return dynamic_cast<const SgVarArgOp*>(inputDerivedClassPointer);
264350 : // Milind Chabbi (8/28/2013): isSgVarArgOp uses table-driven castability instead of c++ default dynamic_cast
264351 : // this improves the running time performance by 10-20%.
264352 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVarArgOp*>(inputDerivedClassPointer);
264353 0 : return IS_SgVarArgOp_FAST_MACRO(inputDerivedClassPointer);
264354 : }
264355 :
264356 :
264357 :
264358 : /* #line 264359 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264359 :
264360 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
264361 :
264362 : /**
264363 : \brief Generated destructor
264364 :
264365 : This destructor is automatically generated (by ROSETTA). This destructor
264366 : only frees memory of data members associated with the parts of the current IR node which
264367 : are NOT traversed. Those data members that are part of a traversal can be freed using
264368 : a traversal (calling this destructor on all children in a post-order traversal). Such
264369 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
264370 :
264371 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
264372 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
264373 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
264374 :
264375 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
264376 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
264377 : pointers are not yet implemented to call delete on eash pointer in the container.
264378 : (This could be done by derivation from the STL containers to define containers that
264379 : automatically deleted their members.)
264380 :
264381 : */
264382 0 : SgVarArgOp::~SgVarArgOp () {
264383 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
264384 :
264385 :
264386 : // case: not a listType for operand_expr
264387 0 : p_operand_expr = NULL; // non list case
264388 : // case: not a listType for expression_type
264389 0 : p_expression_type = NULL; // non list case
264390 :
264391 : }
264392 :
264393 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
264394 0 : }
264395 :
264396 :
264397 : /* #line 264398 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264398 :
264399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
264400 :
264401 : // Generated constructor
264402 0 : SgVarArgOp::SgVarArgOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type )
264403 0 : : SgExpression(startOfConstruct)
264404 : {
264405 : #ifdef DEBUG
264406 : // printf ("In SgVarArgOp::SgVarArgOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
264407 : #endif
264408 : #if 0
264409 : // debugging information!
264410 : printf ("In SgVarArgOp::SgVarArgOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
264411 : #endif
264412 :
264413 0 : p_operand_expr = operand_expr;
264414 0 : p_expression_type = expression_type;
264415 :
264416 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
264417 :
264418 : #if 0
264419 : // DQ (7/30/2014): Call a virtual function.
264420 : std::string s = this->class_name();
264421 : #endif
264422 :
264423 : // Test the variant virtual function
264424 : // assert(VA_OP == variant());
264425 0 : assert(VA_OP == this->variant());
264426 0 : ROSE_ASSERT(VA_OP == (int)(this->variantT()));
264427 0 : post_construction_initialization();
264428 :
264429 : // Test the isSgVarArgOp() function since it has been problematic
264430 0 : assert(isSgVarArgOp(this) != NULL);
264431 0 : }
264432 :
264433 : // Generated constructor (all data members)
264434 :
264435 : /* #line 264436 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264436 :
264437 :
264438 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
264439 :
264440 :
264441 : // ********************************************************
264442 : // member functions common across all array grammar objects
264443 : // ********************************************************
264444 :
264445 :
264446 :
264447 : /* #line 264448 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264448 :
264449 :
264450 :
264451 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
264452 :
264453 : // ********************************************************
264454 : // member functions specific to each node in the grammar
264455 : // ********************************************************
264456 :
264457 :
264458 : /* #line 264459 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264459 :
264460 : // Start of memberFunctionString
264461 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
264462 :
264463 : void
264464 0 : SgVarArgEndOp::post_construction_initialization()
264465 : {
264466 0 : }
264467 :
264468 :
264469 :
264470 : // End of memberFunctionString
264471 : // Start of memberFunctionString
264472 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264473 :
264474 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264475 :
264476 : SgExpression*
264477 0 : SgVarArgEndOp::get_operand_expr () const
264478 : {
264479 0 : ROSE_ASSERT (this != NULL);
264480 :
264481 : #if 0
264482 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264483 : // used to trigger marking transformations for the token-based unparsing.
264484 : printf ("SgVarArgEndOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
264485 : #endif
264486 :
264487 0 : return p_operand_expr;
264488 : }
264489 :
264490 : void
264491 0 : SgVarArgEndOp::set_operand_expr ( SgExpression* operand_expr )
264492 : {
264493 0 : ROSE_ASSERT (this != NULL);
264494 :
264495 : #if 0
264496 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264497 : // used to trigger marking transformations for the token-based unparsing.
264498 : printf ("SgVarArgEndOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
264499 : #endif
264500 :
264501 0 : set_isModified(true);
264502 :
264503 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
264504 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
264505 : {
264506 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
264507 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
264508 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
264509 : ROSE_ASSERT(false);
264510 : #endif
264511 : }
264512 : #endif
264513 0 : p_operand_expr = operand_expr;
264514 0 : }
264515 :
264516 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
264517 :
264518 :
264519 : // End of memberFunctionString
264520 : // Start of memberFunctionString
264521 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264522 :
264523 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264524 :
264525 : SgType*
264526 0 : SgVarArgEndOp::get_expression_type () const
264527 : {
264528 0 : ROSE_ASSERT (this != NULL);
264529 :
264530 : #if 0
264531 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264532 : // used to trigger marking transformations for the token-based unparsing.
264533 : printf ("SgVarArgEndOp::get_expression_type = %p = %s \n",this,this->class_name().c_str());
264534 : #endif
264535 :
264536 0 : return p_expression_type;
264537 : }
264538 :
264539 : void
264540 0 : SgVarArgEndOp::set_expression_type ( SgType* expression_type )
264541 : {
264542 0 : ROSE_ASSERT (this != NULL);
264543 :
264544 : #if 0
264545 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264546 : // used to trigger marking transformations for the token-based unparsing.
264547 : printf ("SgVarArgEndOp::set_expression_type = %p = %s \n",this,this->class_name().c_str());
264548 : #endif
264549 :
264550 0 : set_isModified(true);
264551 :
264552 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
264553 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
264554 : {
264555 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
264556 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
264557 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
264558 : ROSE_ASSERT(false);
264559 : #endif
264560 : }
264561 : #endif
264562 0 : p_expression_type = expression_type;
264563 0 : }
264564 :
264565 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
264566 :
264567 :
264568 : // End of memberFunctionString
264569 : // Start of memberFunctionString
264570 : /* #line 5848 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
264571 :
264572 : int
264573 0 : SgVarArgEndOp::replace_expression(SgExpression *o, SgExpression *n)
264574 : {
264575 :
264576 0 : ROSE_ASSERT(o != NULL);
264577 0 : ROSE_ASSERT(n != NULL);
264578 :
264579 0 : if (get_operand_expr() == o)
264580 : {
264581 0 : set_operand_expr(n);
264582 0 : return 1;
264583 : }
264584 : else
264585 : {
264586 0 : printf ("Warning: inside of SgVarArgEndOp::replace_expression original SgExpression unidentified \n");
264587 0 : return 0;
264588 : }
264589 : }
264590 :
264591 :
264592 :
264593 : // End of memberFunctionString
264594 : // Start of memberFunctionString
264595 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
264596 :
264597 : SgType*
264598 :
264599 0 : SgVarArgEndOp::get_type() const
264600 : {
264601 0 : ROSE_ASSERT(this != NULL);
264602 :
264603 : #if 0
264604 : printf ("In SgVarArgEndOp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
264605 : #endif
264606 :
264607 : // DQ (10/31/2016): Debugging...
264608 : // return SgTypeDefault::createType();
264609 0 : SgType* returnType = SgTypeDefault::createType();
264610 :
264611 : #if 0
264612 : printf ("Leaving SgVarArgEndOp::get_type() (default_get_type) returnType = %p \n",returnType);
264613 : #endif
264614 :
264615 0 : return returnType;
264616 : }
264617 :
264618 :
264619 :
264620 : // End of memberFunctionString
264621 : // Start of memberFunctionString
264622 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
264623 :
264624 : // *** COMMON CODE SECTION BEGINS HERE ***
264625 :
264626 : #if 0
264627 : int
264628 : SgVarArgEndOp::getVariant() const
264629 : {
264630 : // This function is used in ROSE while "variant()" is used in SAGE
264631 : assert(this != NULL);
264632 : return variant();
264633 : }
264634 : #endif
264635 :
264636 : // This function is used in ROSE in treeTraversal code
264637 : // eventually replaces getVariant() and variant()
264638 : // though after variant() has been removed for a while we will
264639 : // want to change the name of variantT() back to variant()
264640 : // (since the "T" was ment to stand for temporary).
264641 : // When this happens the variantT() will be depricated.
264642 : VariantT
264643 0 : SgVarArgEndOp::variantT() const
264644 : {
264645 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
264646 0 : ROSE_ASSERT(this != NULL);
264647 0 : return V_SgVarArgEndOp;
264648 : }
264649 :
264650 : #if 0
264651 : int
264652 : SgVarArgEndOp::variant() const
264653 : {
264654 : // This function is used in SAGE
264655 : ROSE_ASSERT(this != NULL);
264656 : return VA_END_OP;
264657 : }
264658 : #endif
264659 :
264660 : ROSE_DLL_API const char*
264661 0 : SgVarArgEndOp::sage_class_name() const
264662 : {
264663 0 : ROSE_ASSERT(this != NULL);
264664 0 : return "SgVarArgEndOp";
264665 : }
264666 :
264667 : std::string
264668 0 : SgVarArgEndOp::class_name() const
264669 : {
264670 0 : ROSE_ASSERT(this != NULL);
264671 0 : return "SgVarArgEndOp";
264672 : }
264673 :
264674 : // DQ (11/26/2005): Support for visitor pattern mechanims
264675 : // (inferior to ROSE traversal mechanism, experimental).
264676 : void
264677 0 : SgVarArgEndOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
264678 : {
264679 0 : ROSE_ASSERT(this != NULL);
264680 0 : visitor.visit(this);
264681 0 : }
264682 :
264683 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
264684 0 : void SgVarArgEndOp::accept (ROSE_VisitorPattern & visitor) {
264685 0 : ROSE_ASSERT(this != NULL);
264686 0 : visitor.visit(this);
264687 0 : }
264688 :
264689 : SgVarArgEndOp*
264690 0 : SgVarArgEndOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
264691 : {
264692 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
264693 : // This function is currently only supported for the AST used the represent Binary executables.
264694 : if (0 /* isSgAsmNode(this) != NULL */)
264695 : {
264696 : // Support for regex specification.
264697 : std::string prefixCode = "REGEX:";
264698 : addNewAttribute(prefixCode + s,a);
264699 : }
264700 : #endif
264701 :
264702 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
264703 0 : return this;
264704 : }
264705 :
264706 : // *** COMMON CODE SECTION ENDS HERE ***
264707 :
264708 :
264709 : // End of memberFunctionString
264710 : // Start of memberFunctionString
264711 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
264712 :
264713 :
264714 : #if 0
264715 : //! Error checking support
264716 : /*! Verifies the following:
264717 : - working getVariant() member function
264718 : - calls base class's error() member function
264719 : Every class has one of these functions.
264720 : */
264721 : bool
264722 : SgVarArgEndOp::error()
264723 : {
264724 : // Put error checking here
264725 :
264726 : ROSE_ASSERT (this != NULL);
264727 : if (getVariant() != VA_END_OP)
264728 : {
264729 : printf ("Error in SgVarArgEndOp::error(): SgVarArgEndOp object has a %s variant \n",
264730 : Cxx_GrammarTerminalNames[getVariant()].name);
264731 : // printf ("Error in SgVarArgEndOp::error() \n");
264732 : ROSE_ABORT();
264733 : }
264734 :
264735 : ROSE_ASSERT (getVariant() == VA_END_OP);
264736 : return SgExpression::error();
264737 : }
264738 : #endif
264739 :
264740 :
264741 :
264742 : // End of memberFunctionString
264743 :
264744 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
264745 :
264746 0 : SgVarArgEndOp* isSgVarArgEndOp ( SgNode* inputDerivedClassPointer )
264747 : {
264748 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
264749 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
264750 : // So to fix this we return NULL directly when the input is NULL and avoid the
264751 : // dynamic_cast in this case. This is likely a performance improvement as well.
264752 : // return dynamic_cast<SgVarArgEndOp*>(inputDerivedClassPointer);
264753 : // Milind Chabbi (8/28/2013): isSgVarArgEndOp uses table-driven castability instead of c++ default dynamic_cast
264754 : // this improves the running time performance by 10-20%.
264755 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVarArgEndOp*>(inputDerivedClassPointer);
264756 0 : return IS_SgVarArgEndOp_FAST_MACRO(inputDerivedClassPointer);
264757 : }
264758 :
264759 : // DQ (11/8/2003): Added version of functions taking const pointer
264760 0 : const SgVarArgEndOp* isSgVarArgEndOp ( const SgNode* inputDerivedClassPointer )
264761 : {
264762 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
264763 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
264764 : // So to fix this we return NULL directly when the input is NULL and avoid the
264765 : // dynamic_cast in this case. This is likely a performance improvement as well.
264766 : // return dynamic_cast<const SgVarArgEndOp*>(inputDerivedClassPointer);
264767 : // Milind Chabbi (8/28/2013): isSgVarArgEndOp uses table-driven castability instead of c++ default dynamic_cast
264768 : // this improves the running time performance by 10-20%.
264769 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVarArgEndOp*>(inputDerivedClassPointer);
264770 0 : return IS_SgVarArgEndOp_FAST_MACRO(inputDerivedClassPointer);
264771 : }
264772 :
264773 :
264774 :
264775 : /* #line 264776 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264776 :
264777 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
264778 :
264779 : /**
264780 : \brief Generated destructor
264781 :
264782 : This destructor is automatically generated (by ROSETTA). This destructor
264783 : only frees memory of data members associated with the parts of the current IR node which
264784 : are NOT traversed. Those data members that are part of a traversal can be freed using
264785 : a traversal (calling this destructor on all children in a post-order traversal). Such
264786 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
264787 :
264788 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
264789 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
264790 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
264791 :
264792 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
264793 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
264794 : pointers are not yet implemented to call delete on eash pointer in the container.
264795 : (This could be done by derivation from the STL containers to define containers that
264796 : automatically deleted their members.)
264797 :
264798 : */
264799 0 : SgVarArgEndOp::~SgVarArgEndOp () {
264800 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
264801 :
264802 :
264803 : // case: not a listType for operand_expr
264804 0 : p_operand_expr = NULL; // non list case
264805 : // case: not a listType for expression_type
264806 0 : p_expression_type = NULL; // non list case
264807 :
264808 : }
264809 :
264810 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
264811 0 : }
264812 :
264813 :
264814 : /* #line 264815 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264815 :
264816 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
264817 :
264818 : // Generated constructor
264819 0 : SgVarArgEndOp::SgVarArgEndOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type )
264820 0 : : SgExpression(startOfConstruct)
264821 : {
264822 : #ifdef DEBUG
264823 : // printf ("In SgVarArgEndOp::SgVarArgEndOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
264824 : #endif
264825 : #if 0
264826 : // debugging information!
264827 : printf ("In SgVarArgEndOp::SgVarArgEndOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
264828 : #endif
264829 :
264830 0 : p_operand_expr = operand_expr;
264831 0 : p_expression_type = expression_type;
264832 :
264833 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
264834 :
264835 : #if 0
264836 : // DQ (7/30/2014): Call a virtual function.
264837 : std::string s = this->class_name();
264838 : #endif
264839 :
264840 : // Test the variant virtual function
264841 : // assert(VA_END_OP == variant());
264842 0 : assert(VA_END_OP == this->variant());
264843 0 : ROSE_ASSERT(VA_END_OP == (int)(this->variantT()));
264844 0 : post_construction_initialization();
264845 :
264846 : // Test the isSgVarArgEndOp() function since it has been problematic
264847 0 : assert(isSgVarArgEndOp(this) != NULL);
264848 0 : }
264849 :
264850 : // Generated constructor (all data members)
264851 :
264852 : /* #line 264853 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264853 :
264854 :
264855 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
264856 :
264857 :
264858 : // ********************************************************
264859 : // member functions common across all array grammar objects
264860 : // ********************************************************
264861 :
264862 :
264863 :
264864 : /* #line 264865 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264865 :
264866 :
264867 :
264868 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
264869 :
264870 : // ********************************************************
264871 : // member functions specific to each node in the grammar
264872 : // ********************************************************
264873 :
264874 :
264875 : /* #line 264876 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
264876 :
264877 : // Start of memberFunctionString
264878 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
264879 :
264880 : void
264881 0 : SgVarArgCopyOp::post_construction_initialization()
264882 : {
264883 0 : }
264884 :
264885 :
264886 :
264887 : // End of memberFunctionString
264888 : // Start of memberFunctionString
264889 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264890 :
264891 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264892 :
264893 : SgExpression*
264894 0 : SgVarArgCopyOp::get_lhs_operand () const
264895 : {
264896 0 : ROSE_ASSERT (this != NULL);
264897 :
264898 : #if 0
264899 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264900 : // used to trigger marking transformations for the token-based unparsing.
264901 : printf ("SgVarArgCopyOp::get_lhs_operand = %p = %s \n",this,this->class_name().c_str());
264902 : #endif
264903 :
264904 0 : return p_lhs_operand;
264905 : }
264906 :
264907 : void
264908 0 : SgVarArgCopyOp::set_lhs_operand ( SgExpression* lhs_operand )
264909 : {
264910 0 : ROSE_ASSERT (this != NULL);
264911 :
264912 : #if 0
264913 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264914 : // used to trigger marking transformations for the token-based unparsing.
264915 : printf ("SgVarArgCopyOp::set_lhs_operand = %p = %s \n",this,this->class_name().c_str());
264916 : #endif
264917 :
264918 0 : set_isModified(true);
264919 :
264920 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
264921 : if (p_lhs_operand != NULL && lhs_operand != NULL && p_lhs_operand != lhs_operand)
264922 : {
264923 : printf ("Warning: lhs_operand = %p overwriting valid pointer p_lhs_operand = %p \n",lhs_operand,p_lhs_operand);
264924 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
264925 : printf ("Error fails assertion (p_lhs_operand != NULL && lhs_operand != NULL && p_lhs_operand != lhs_operand) is false\n");
264926 : ROSE_ASSERT(false);
264927 : #endif
264928 : }
264929 : #endif
264930 0 : p_lhs_operand = lhs_operand;
264931 0 : }
264932 :
264933 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
264934 :
264935 :
264936 : // End of memberFunctionString
264937 : // Start of memberFunctionString
264938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264939 :
264940 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264941 :
264942 : SgExpression*
264943 0 : SgVarArgCopyOp::get_rhs_operand () const
264944 : {
264945 0 : ROSE_ASSERT (this != NULL);
264946 :
264947 : #if 0
264948 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264949 : // used to trigger marking transformations for the token-based unparsing.
264950 : printf ("SgVarArgCopyOp::get_rhs_operand = %p = %s \n",this,this->class_name().c_str());
264951 : #endif
264952 :
264953 0 : return p_rhs_operand;
264954 : }
264955 :
264956 : void
264957 0 : SgVarArgCopyOp::set_rhs_operand ( SgExpression* rhs_operand )
264958 : {
264959 0 : ROSE_ASSERT (this != NULL);
264960 :
264961 : #if 0
264962 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264963 : // used to trigger marking transformations for the token-based unparsing.
264964 : printf ("SgVarArgCopyOp::set_rhs_operand = %p = %s \n",this,this->class_name().c_str());
264965 : #endif
264966 :
264967 0 : set_isModified(true);
264968 :
264969 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
264970 : if (p_rhs_operand != NULL && rhs_operand != NULL && p_rhs_operand != rhs_operand)
264971 : {
264972 : printf ("Warning: rhs_operand = %p overwriting valid pointer p_rhs_operand = %p \n",rhs_operand,p_rhs_operand);
264973 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
264974 : printf ("Error fails assertion (p_rhs_operand != NULL && rhs_operand != NULL && p_rhs_operand != rhs_operand) is false\n");
264975 : ROSE_ASSERT(false);
264976 : #endif
264977 : }
264978 : #endif
264979 0 : p_rhs_operand = rhs_operand;
264980 0 : }
264981 :
264982 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
264983 :
264984 :
264985 : // End of memberFunctionString
264986 : // Start of memberFunctionString
264987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
264988 :
264989 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
264990 :
264991 : SgType*
264992 0 : SgVarArgCopyOp::get_expression_type () const
264993 : {
264994 0 : ROSE_ASSERT (this != NULL);
264995 :
264996 : #if 0
264997 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
264998 : // used to trigger marking transformations for the token-based unparsing.
264999 : printf ("SgVarArgCopyOp::get_expression_type = %p = %s \n",this,this->class_name().c_str());
265000 : #endif
265001 :
265002 0 : return p_expression_type;
265003 : }
265004 :
265005 : void
265006 0 : SgVarArgCopyOp::set_expression_type ( SgType* expression_type )
265007 : {
265008 0 : ROSE_ASSERT (this != NULL);
265009 :
265010 : #if 0
265011 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
265012 : // used to trigger marking transformations for the token-based unparsing.
265013 : printf ("SgVarArgCopyOp::set_expression_type = %p = %s \n",this,this->class_name().c_str());
265014 : #endif
265015 :
265016 0 : set_isModified(true);
265017 :
265018 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
265019 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
265020 : {
265021 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
265022 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
265023 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
265024 : ROSE_ASSERT(false);
265025 : #endif
265026 : }
265027 : #endif
265028 0 : p_expression_type = expression_type;
265029 0 : }
265030 :
265031 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
265032 :
265033 :
265034 : // End of memberFunctionString
265035 : // Start of memberFunctionString
265036 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265037 :
265038 : SgType*
265039 :
265040 0 : SgVarArgCopyOp::get_type() const
265041 : {
265042 0 : ROSE_ASSERT(this != NULL);
265043 :
265044 : #if 0
265045 : printf ("In SgVarArgCopyOp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
265046 : #endif
265047 :
265048 : // DQ (10/31/2016): Debugging...
265049 : // return SgTypeDefault::createType();
265050 0 : SgType* returnType = SgTypeDefault::createType();
265051 :
265052 : #if 0
265053 : printf ("Leaving SgVarArgCopyOp::get_type() (default_get_type) returnType = %p \n",returnType);
265054 : #endif
265055 :
265056 0 : return returnType;
265057 : }
265058 :
265059 :
265060 :
265061 : // End of memberFunctionString
265062 : // Start of memberFunctionString
265063 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
265064 :
265065 : // *** COMMON CODE SECTION BEGINS HERE ***
265066 :
265067 : #if 0
265068 : int
265069 : SgVarArgCopyOp::getVariant() const
265070 : {
265071 : // This function is used in ROSE while "variant()" is used in SAGE
265072 : assert(this != NULL);
265073 : return variant();
265074 : }
265075 : #endif
265076 :
265077 : // This function is used in ROSE in treeTraversal code
265078 : // eventually replaces getVariant() and variant()
265079 : // though after variant() has been removed for a while we will
265080 : // want to change the name of variantT() back to variant()
265081 : // (since the "T" was ment to stand for temporary).
265082 : // When this happens the variantT() will be depricated.
265083 : VariantT
265084 0 : SgVarArgCopyOp::variantT() const
265085 : {
265086 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
265087 0 : ROSE_ASSERT(this != NULL);
265088 0 : return V_SgVarArgCopyOp;
265089 : }
265090 :
265091 : #if 0
265092 : int
265093 : SgVarArgCopyOp::variant() const
265094 : {
265095 : // This function is used in SAGE
265096 : ROSE_ASSERT(this != NULL);
265097 : return VA_COPY_OP;
265098 : }
265099 : #endif
265100 :
265101 : ROSE_DLL_API const char*
265102 0 : SgVarArgCopyOp::sage_class_name() const
265103 : {
265104 0 : ROSE_ASSERT(this != NULL);
265105 0 : return "SgVarArgCopyOp";
265106 : }
265107 :
265108 : std::string
265109 0 : SgVarArgCopyOp::class_name() const
265110 : {
265111 0 : ROSE_ASSERT(this != NULL);
265112 0 : return "SgVarArgCopyOp";
265113 : }
265114 :
265115 : // DQ (11/26/2005): Support for visitor pattern mechanims
265116 : // (inferior to ROSE traversal mechanism, experimental).
265117 : void
265118 0 : SgVarArgCopyOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
265119 : {
265120 0 : ROSE_ASSERT(this != NULL);
265121 0 : visitor.visit(this);
265122 0 : }
265123 :
265124 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
265125 0 : void SgVarArgCopyOp::accept (ROSE_VisitorPattern & visitor) {
265126 0 : ROSE_ASSERT(this != NULL);
265127 0 : visitor.visit(this);
265128 0 : }
265129 :
265130 : SgVarArgCopyOp*
265131 0 : SgVarArgCopyOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
265132 : {
265133 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
265134 : // This function is currently only supported for the AST used the represent Binary executables.
265135 : if (0 /* isSgAsmNode(this) != NULL */)
265136 : {
265137 : // Support for regex specification.
265138 : std::string prefixCode = "REGEX:";
265139 : addNewAttribute(prefixCode + s,a);
265140 : }
265141 : #endif
265142 :
265143 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
265144 0 : return this;
265145 : }
265146 :
265147 : // *** COMMON CODE SECTION ENDS HERE ***
265148 :
265149 :
265150 : // End of memberFunctionString
265151 : // Start of memberFunctionString
265152 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
265153 :
265154 :
265155 : #if 0
265156 : //! Error checking support
265157 : /*! Verifies the following:
265158 : - working getVariant() member function
265159 : - calls base class's error() member function
265160 : Every class has one of these functions.
265161 : */
265162 : bool
265163 : SgVarArgCopyOp::error()
265164 : {
265165 : // Put error checking here
265166 :
265167 : ROSE_ASSERT (this != NULL);
265168 : if (getVariant() != VA_COPY_OP)
265169 : {
265170 : printf ("Error in SgVarArgCopyOp::error(): SgVarArgCopyOp object has a %s variant \n",
265171 : Cxx_GrammarTerminalNames[getVariant()].name);
265172 : // printf ("Error in SgVarArgCopyOp::error() \n");
265173 : ROSE_ABORT();
265174 : }
265175 :
265176 : ROSE_ASSERT (getVariant() == VA_COPY_OP);
265177 : return SgExpression::error();
265178 : }
265179 : #endif
265180 :
265181 :
265182 :
265183 : // End of memberFunctionString
265184 :
265185 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
265186 :
265187 2 : SgVarArgCopyOp* isSgVarArgCopyOp ( SgNode* inputDerivedClassPointer )
265188 : {
265189 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
265190 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
265191 : // So to fix this we return NULL directly when the input is NULL and avoid the
265192 : // dynamic_cast in this case. This is likely a performance improvement as well.
265193 : // return dynamic_cast<SgVarArgCopyOp*>(inputDerivedClassPointer);
265194 : // Milind Chabbi (8/28/2013): isSgVarArgCopyOp uses table-driven castability instead of c++ default dynamic_cast
265195 : // this improves the running time performance by 10-20%.
265196 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVarArgCopyOp*>(inputDerivedClassPointer);
265197 2 : return IS_SgVarArgCopyOp_FAST_MACRO(inputDerivedClassPointer);
265198 : }
265199 :
265200 : // DQ (11/8/2003): Added version of functions taking const pointer
265201 0 : const SgVarArgCopyOp* isSgVarArgCopyOp ( const SgNode* inputDerivedClassPointer )
265202 : {
265203 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
265204 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
265205 : // So to fix this we return NULL directly when the input is NULL and avoid the
265206 : // dynamic_cast in this case. This is likely a performance improvement as well.
265207 : // return dynamic_cast<const SgVarArgCopyOp*>(inputDerivedClassPointer);
265208 : // Milind Chabbi (8/28/2013): isSgVarArgCopyOp uses table-driven castability instead of c++ default dynamic_cast
265209 : // this improves the running time performance by 10-20%.
265210 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVarArgCopyOp*>(inputDerivedClassPointer);
265211 0 : return IS_SgVarArgCopyOp_FAST_MACRO(inputDerivedClassPointer);
265212 : }
265213 :
265214 :
265215 :
265216 : /* #line 265217 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265217 :
265218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
265219 :
265220 : /**
265221 : \brief Generated destructor
265222 :
265223 : This destructor is automatically generated (by ROSETTA). This destructor
265224 : only frees memory of data members associated with the parts of the current IR node which
265225 : are NOT traversed. Those data members that are part of a traversal can be freed using
265226 : a traversal (calling this destructor on all children in a post-order traversal). Such
265227 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
265228 :
265229 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
265230 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
265231 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
265232 :
265233 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
265234 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
265235 : pointers are not yet implemented to call delete on eash pointer in the container.
265236 : (This could be done by derivation from the STL containers to define containers that
265237 : automatically deleted their members.)
265238 :
265239 : */
265240 0 : SgVarArgCopyOp::~SgVarArgCopyOp () {
265241 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
265242 :
265243 :
265244 : // case: not a listType for lhs_operand
265245 0 : p_lhs_operand = NULL; // non list case
265246 : // case: not a listType for rhs_operand
265247 0 : p_rhs_operand = NULL; // non list case
265248 : // case: not a listType for expression_type
265249 0 : p_expression_type = NULL; // non list case
265250 :
265251 : }
265252 :
265253 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
265254 0 : }
265255 :
265256 :
265257 : /* #line 265258 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265258 :
265259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
265260 :
265261 : // Generated constructor
265262 0 : SgVarArgCopyOp::SgVarArgCopyOp ( Sg_File_Info* startOfConstruct, SgExpression* lhs_operand, SgExpression* rhs_operand, SgType* expression_type )
265263 0 : : SgExpression(startOfConstruct)
265264 : {
265265 : #ifdef DEBUG
265266 : // printf ("In SgVarArgCopyOp::SgVarArgCopyOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand, SgExpression* rhs_operand, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
265267 : #endif
265268 : #if 0
265269 : // debugging information!
265270 : printf ("In SgVarArgCopyOp::SgVarArgCopyOp (Sg_File_Info* startOfConstruct, SgExpression* lhs_operand, SgExpression* rhs_operand, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
265271 : #endif
265272 :
265273 0 : p_lhs_operand = lhs_operand;
265274 0 : p_rhs_operand = rhs_operand;
265275 0 : p_expression_type = expression_type;
265276 :
265277 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
265278 :
265279 : #if 0
265280 : // DQ (7/30/2014): Call a virtual function.
265281 : std::string s = this->class_name();
265282 : #endif
265283 :
265284 : // Test the variant virtual function
265285 : // assert(VA_COPY_OP == variant());
265286 0 : assert(VA_COPY_OP == this->variant());
265287 0 : ROSE_ASSERT(VA_COPY_OP == (int)(this->variantT()));
265288 0 : post_construction_initialization();
265289 :
265290 : // Test the isSgVarArgCopyOp() function since it has been problematic
265291 0 : assert(isSgVarArgCopyOp(this) != NULL);
265292 0 : }
265293 :
265294 : // Generated constructor (all data members)
265295 :
265296 : /* #line 265297 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265297 :
265298 :
265299 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
265300 :
265301 :
265302 : // ********************************************************
265303 : // member functions common across all array grammar objects
265304 : // ********************************************************
265305 :
265306 :
265307 :
265308 : /* #line 265309 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265309 :
265310 :
265311 :
265312 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
265313 :
265314 : // ********************************************************
265315 : // member functions specific to each node in the grammar
265316 : // ********************************************************
265317 :
265318 :
265319 : /* #line 265320 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265320 :
265321 : // Start of memberFunctionString
265322 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265323 :
265324 : void
265325 0 : SgVarArgStartOneOperandOp::post_construction_initialization()
265326 : {
265327 0 : }
265328 :
265329 :
265330 :
265331 : // End of memberFunctionString
265332 : // Start of memberFunctionString
265333 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
265334 :
265335 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
265336 :
265337 : SgExpression*
265338 0 : SgVarArgStartOneOperandOp::get_operand_expr () const
265339 : {
265340 0 : ROSE_ASSERT (this != NULL);
265341 :
265342 : #if 0
265343 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
265344 : // used to trigger marking transformations for the token-based unparsing.
265345 : printf ("SgVarArgStartOneOperandOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
265346 : #endif
265347 :
265348 0 : return p_operand_expr;
265349 : }
265350 :
265351 : void
265352 0 : SgVarArgStartOneOperandOp::set_operand_expr ( SgExpression* operand_expr )
265353 : {
265354 0 : ROSE_ASSERT (this != NULL);
265355 :
265356 : #if 0
265357 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
265358 : // used to trigger marking transformations for the token-based unparsing.
265359 : printf ("SgVarArgStartOneOperandOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
265360 : #endif
265361 :
265362 0 : set_isModified(true);
265363 :
265364 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
265365 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
265366 : {
265367 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
265368 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
265369 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
265370 : ROSE_ASSERT(false);
265371 : #endif
265372 : }
265373 : #endif
265374 0 : p_operand_expr = operand_expr;
265375 0 : }
265376 :
265377 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
265378 :
265379 :
265380 : // End of memberFunctionString
265381 : // Start of memberFunctionString
265382 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
265383 :
265384 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
265385 :
265386 : SgType*
265387 0 : SgVarArgStartOneOperandOp::get_expression_type () const
265388 : {
265389 0 : ROSE_ASSERT (this != NULL);
265390 :
265391 : #if 0
265392 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
265393 : // used to trigger marking transformations for the token-based unparsing.
265394 : printf ("SgVarArgStartOneOperandOp::get_expression_type = %p = %s \n",this,this->class_name().c_str());
265395 : #endif
265396 :
265397 0 : return p_expression_type;
265398 : }
265399 :
265400 : void
265401 0 : SgVarArgStartOneOperandOp::set_expression_type ( SgType* expression_type )
265402 : {
265403 0 : ROSE_ASSERT (this != NULL);
265404 :
265405 : #if 0
265406 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
265407 : // used to trigger marking transformations for the token-based unparsing.
265408 : printf ("SgVarArgStartOneOperandOp::set_expression_type = %p = %s \n",this,this->class_name().c_str());
265409 : #endif
265410 :
265411 0 : set_isModified(true);
265412 :
265413 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
265414 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
265415 : {
265416 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
265417 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
265418 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
265419 : ROSE_ASSERT(false);
265420 : #endif
265421 : }
265422 : #endif
265423 0 : p_expression_type = expression_type;
265424 0 : }
265425 :
265426 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
265427 :
265428 :
265429 : // End of memberFunctionString
265430 : // Start of memberFunctionString
265431 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265432 :
265433 : SgType*
265434 :
265435 0 : SgVarArgStartOneOperandOp::get_type() const
265436 : {
265437 0 : ROSE_ASSERT(this != NULL);
265438 :
265439 : #if 0
265440 : printf ("In SgVarArgStartOneOperandOp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
265441 : #endif
265442 :
265443 : // DQ (10/31/2016): Debugging...
265444 : // return SgTypeDefault::createType();
265445 0 : SgType* returnType = SgTypeDefault::createType();
265446 :
265447 : #if 0
265448 : printf ("Leaving SgVarArgStartOneOperandOp::get_type() (default_get_type) returnType = %p \n",returnType);
265449 : #endif
265450 :
265451 0 : return returnType;
265452 : }
265453 :
265454 :
265455 :
265456 : // End of memberFunctionString
265457 : // Start of memberFunctionString
265458 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
265459 :
265460 : // *** COMMON CODE SECTION BEGINS HERE ***
265461 :
265462 : #if 0
265463 : int
265464 : SgVarArgStartOneOperandOp::getVariant() const
265465 : {
265466 : // This function is used in ROSE while "variant()" is used in SAGE
265467 : assert(this != NULL);
265468 : return variant();
265469 : }
265470 : #endif
265471 :
265472 : // This function is used in ROSE in treeTraversal code
265473 : // eventually replaces getVariant() and variant()
265474 : // though after variant() has been removed for a while we will
265475 : // want to change the name of variantT() back to variant()
265476 : // (since the "T" was ment to stand for temporary).
265477 : // When this happens the variantT() will be depricated.
265478 : VariantT
265479 0 : SgVarArgStartOneOperandOp::variantT() const
265480 : {
265481 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
265482 0 : ROSE_ASSERT(this != NULL);
265483 0 : return V_SgVarArgStartOneOperandOp;
265484 : }
265485 :
265486 : #if 0
265487 : int
265488 : SgVarArgStartOneOperandOp::variant() const
265489 : {
265490 : // This function is used in SAGE
265491 : ROSE_ASSERT(this != NULL);
265492 : return VA_START_ONE_OPERAND_OP;
265493 : }
265494 : #endif
265495 :
265496 : ROSE_DLL_API const char*
265497 0 : SgVarArgStartOneOperandOp::sage_class_name() const
265498 : {
265499 0 : ROSE_ASSERT(this != NULL);
265500 0 : return "SgVarArgStartOneOperandOp";
265501 : }
265502 :
265503 : std::string
265504 0 : SgVarArgStartOneOperandOp::class_name() const
265505 : {
265506 0 : ROSE_ASSERT(this != NULL);
265507 0 : return "SgVarArgStartOneOperandOp";
265508 : }
265509 :
265510 : // DQ (11/26/2005): Support for visitor pattern mechanims
265511 : // (inferior to ROSE traversal mechanism, experimental).
265512 : void
265513 0 : SgVarArgStartOneOperandOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
265514 : {
265515 0 : ROSE_ASSERT(this != NULL);
265516 0 : visitor.visit(this);
265517 0 : }
265518 :
265519 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
265520 0 : void SgVarArgStartOneOperandOp::accept (ROSE_VisitorPattern & visitor) {
265521 0 : ROSE_ASSERT(this != NULL);
265522 0 : visitor.visit(this);
265523 0 : }
265524 :
265525 : SgVarArgStartOneOperandOp*
265526 0 : SgVarArgStartOneOperandOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
265527 : {
265528 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
265529 : // This function is currently only supported for the AST used the represent Binary executables.
265530 : if (0 /* isSgAsmNode(this) != NULL */)
265531 : {
265532 : // Support for regex specification.
265533 : std::string prefixCode = "REGEX:";
265534 : addNewAttribute(prefixCode + s,a);
265535 : }
265536 : #endif
265537 :
265538 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
265539 0 : return this;
265540 : }
265541 :
265542 : // *** COMMON CODE SECTION ENDS HERE ***
265543 :
265544 :
265545 : // End of memberFunctionString
265546 : // Start of memberFunctionString
265547 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
265548 :
265549 :
265550 : #if 0
265551 : //! Error checking support
265552 : /*! Verifies the following:
265553 : - working getVariant() member function
265554 : - calls base class's error() member function
265555 : Every class has one of these functions.
265556 : */
265557 : bool
265558 : SgVarArgStartOneOperandOp::error()
265559 : {
265560 : // Put error checking here
265561 :
265562 : ROSE_ASSERT (this != NULL);
265563 : if (getVariant() != VA_START_ONE_OPERAND_OP)
265564 : {
265565 : printf ("Error in SgVarArgStartOneOperandOp::error(): SgVarArgStartOneOperandOp object has a %s variant \n",
265566 : Cxx_GrammarTerminalNames[getVariant()].name);
265567 : // printf ("Error in SgVarArgStartOneOperandOp::error() \n");
265568 : ROSE_ABORT();
265569 : }
265570 :
265571 : ROSE_ASSERT (getVariant() == VA_START_ONE_OPERAND_OP);
265572 : return SgExpression::error();
265573 : }
265574 : #endif
265575 :
265576 :
265577 :
265578 : // End of memberFunctionString
265579 :
265580 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
265581 :
265582 0 : SgVarArgStartOneOperandOp* isSgVarArgStartOneOperandOp ( SgNode* inputDerivedClassPointer )
265583 : {
265584 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
265585 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
265586 : // So to fix this we return NULL directly when the input is NULL and avoid the
265587 : // dynamic_cast in this case. This is likely a performance improvement as well.
265588 : // return dynamic_cast<SgVarArgStartOneOperandOp*>(inputDerivedClassPointer);
265589 : // Milind Chabbi (8/28/2013): isSgVarArgStartOneOperandOp uses table-driven castability instead of c++ default dynamic_cast
265590 : // this improves the running time performance by 10-20%.
265591 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVarArgStartOneOperandOp*>(inputDerivedClassPointer);
265592 0 : return IS_SgVarArgStartOneOperandOp_FAST_MACRO(inputDerivedClassPointer);
265593 : }
265594 :
265595 : // DQ (11/8/2003): Added version of functions taking const pointer
265596 0 : const SgVarArgStartOneOperandOp* isSgVarArgStartOneOperandOp ( const SgNode* inputDerivedClassPointer )
265597 : {
265598 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
265599 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
265600 : // So to fix this we return NULL directly when the input is NULL and avoid the
265601 : // dynamic_cast in this case. This is likely a performance improvement as well.
265602 : // return dynamic_cast<const SgVarArgStartOneOperandOp*>(inputDerivedClassPointer);
265603 : // Milind Chabbi (8/28/2013): isSgVarArgStartOneOperandOp uses table-driven castability instead of c++ default dynamic_cast
265604 : // this improves the running time performance by 10-20%.
265605 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVarArgStartOneOperandOp*>(inputDerivedClassPointer);
265606 0 : return IS_SgVarArgStartOneOperandOp_FAST_MACRO(inputDerivedClassPointer);
265607 : }
265608 :
265609 :
265610 :
265611 : /* #line 265612 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265612 :
265613 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
265614 :
265615 : /**
265616 : \brief Generated destructor
265617 :
265618 : This destructor is automatically generated (by ROSETTA). This destructor
265619 : only frees memory of data members associated with the parts of the current IR node which
265620 : are NOT traversed. Those data members that are part of a traversal can be freed using
265621 : a traversal (calling this destructor on all children in a post-order traversal). Such
265622 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
265623 :
265624 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
265625 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
265626 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
265627 :
265628 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
265629 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
265630 : pointers are not yet implemented to call delete on eash pointer in the container.
265631 : (This could be done by derivation from the STL containers to define containers that
265632 : automatically deleted their members.)
265633 :
265634 : */
265635 0 : SgVarArgStartOneOperandOp::~SgVarArgStartOneOperandOp () {
265636 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
265637 :
265638 :
265639 : // case: not a listType for operand_expr
265640 0 : p_operand_expr = NULL; // non list case
265641 : // case: not a listType for expression_type
265642 0 : p_expression_type = NULL; // non list case
265643 :
265644 : }
265645 :
265646 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
265647 0 : }
265648 :
265649 :
265650 : /* #line 265651 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265651 :
265652 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
265653 :
265654 : // Generated constructor
265655 0 : SgVarArgStartOneOperandOp::SgVarArgStartOneOperandOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type )
265656 0 : : SgExpression(startOfConstruct)
265657 : {
265658 : #ifdef DEBUG
265659 : // printf ("In SgVarArgStartOneOperandOp::SgVarArgStartOneOperandOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
265660 : #endif
265661 : #if 0
265662 : // debugging information!
265663 : printf ("In SgVarArgStartOneOperandOp::SgVarArgStartOneOperandOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
265664 : #endif
265665 :
265666 0 : p_operand_expr = operand_expr;
265667 0 : p_expression_type = expression_type;
265668 :
265669 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
265670 :
265671 : #if 0
265672 : // DQ (7/30/2014): Call a virtual function.
265673 : std::string s = this->class_name();
265674 : #endif
265675 :
265676 : // Test the variant virtual function
265677 : // assert(VA_START_ONE_OPERAND_OP == variant());
265678 0 : assert(VA_START_ONE_OPERAND_OP == this->variant());
265679 0 : ROSE_ASSERT(VA_START_ONE_OPERAND_OP == (int)(this->variantT()));
265680 0 : post_construction_initialization();
265681 :
265682 : // Test the isSgVarArgStartOneOperandOp() function since it has been problematic
265683 0 : assert(isSgVarArgStartOneOperandOp(this) != NULL);
265684 0 : }
265685 :
265686 : // Generated constructor (all data members)
265687 :
265688 : /* #line 265689 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265689 :
265690 :
265691 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
265692 :
265693 :
265694 : // ********************************************************
265695 : // member functions common across all array grammar objects
265696 : // ********************************************************
265697 :
265698 :
265699 :
265700 : /* #line 265701 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265701 :
265702 :
265703 :
265704 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
265705 :
265706 : // ********************************************************
265707 : // member functions specific to each node in the grammar
265708 : // ********************************************************
265709 :
265710 :
265711 : /* #line 265712 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265712 :
265713 : // Start of memberFunctionString
265714 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265715 :
265716 : void
265717 1699 : SgNullExpression::post_construction_initialization()
265718 : {
265719 1699 : }
265720 :
265721 :
265722 :
265723 : // End of memberFunctionString
265724 : // Start of memberFunctionString
265725 : /* #line 8527 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265726 :
265727 :
265728 :
265729 : // End of memberFunctionString
265730 : // Start of memberFunctionString
265731 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265732 :
265733 :
265734 : SgType*
265735 922 : SgNullExpression::get_type(void) const
265736 : {
265737 : #if 0
265738 : printf ("In SgNullExpression::get_type() \n");
265739 : #endif
265740 :
265741 922 : return SgTypeDefault::createType();
265742 : }
265743 :
265744 :
265745 :
265746 : // End of memberFunctionString
265747 : // Start of memberFunctionString
265748 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
265749 :
265750 : // *** COMMON CODE SECTION BEGINS HERE ***
265751 :
265752 : #if 0
265753 : int
265754 : SgNullExpression::getVariant() const
265755 : {
265756 : // This function is used in ROSE while "variant()" is used in SAGE
265757 : assert(this != NULL);
265758 : return variant();
265759 : }
265760 : #endif
265761 :
265762 : // This function is used in ROSE in treeTraversal code
265763 : // eventually replaces getVariant() and variant()
265764 : // though after variant() has been removed for a while we will
265765 : // want to change the name of variantT() back to variant()
265766 : // (since the "T" was ment to stand for temporary).
265767 : // When this happens the variantT() will be depricated.
265768 : VariantT
265769 386686 : SgNullExpression::variantT() const
265770 : {
265771 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
265772 386686 : ROSE_ASSERT(this != NULL);
265773 386686 : return V_SgNullExpression;
265774 : }
265775 :
265776 : #if 0
265777 : int
265778 : SgNullExpression::variant() const
265779 : {
265780 : // This function is used in SAGE
265781 : ROSE_ASSERT(this != NULL);
265782 : return NULL_EXPR;
265783 : }
265784 : #endif
265785 :
265786 : ROSE_DLL_API const char*
265787 51 : SgNullExpression::sage_class_name() const
265788 : {
265789 51 : ROSE_ASSERT(this != NULL);
265790 51 : return "SgNullExpression";
265791 : }
265792 :
265793 : std::string
265794 1492 : SgNullExpression::class_name() const
265795 : {
265796 1492 : ROSE_ASSERT(this != NULL);
265797 1492 : return "SgNullExpression";
265798 : }
265799 :
265800 : // DQ (11/26/2005): Support for visitor pattern mechanims
265801 : // (inferior to ROSE traversal mechanism, experimental).
265802 : void
265803 17374 : SgNullExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
265804 : {
265805 17374 : ROSE_ASSERT(this != NULL);
265806 17374 : visitor.visit(this);
265807 17374 : }
265808 :
265809 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
265810 0 : void SgNullExpression::accept (ROSE_VisitorPattern & visitor) {
265811 0 : ROSE_ASSERT(this != NULL);
265812 0 : visitor.visit(this);
265813 0 : }
265814 :
265815 : SgNullExpression*
265816 0 : SgNullExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
265817 : {
265818 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
265819 : // This function is currently only supported for the AST used the represent Binary executables.
265820 : if (0 /* isSgAsmNode(this) != NULL */)
265821 : {
265822 : // Support for regex specification.
265823 : std::string prefixCode = "REGEX:";
265824 : addNewAttribute(prefixCode + s,a);
265825 : }
265826 : #endif
265827 :
265828 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
265829 0 : return this;
265830 : }
265831 :
265832 : // *** COMMON CODE SECTION ENDS HERE ***
265833 :
265834 :
265835 : // End of memberFunctionString
265836 : // Start of memberFunctionString
265837 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
265838 :
265839 :
265840 : #if 0
265841 : //! Error checking support
265842 : /*! Verifies the following:
265843 : - working getVariant() member function
265844 : - calls base class's error() member function
265845 : Every class has one of these functions.
265846 : */
265847 : bool
265848 : SgNullExpression::error()
265849 : {
265850 : // Put error checking here
265851 :
265852 : ROSE_ASSERT (this != NULL);
265853 : if (getVariant() != NULL_EXPR)
265854 : {
265855 : printf ("Error in SgNullExpression::error(): SgNullExpression object has a %s variant \n",
265856 : Cxx_GrammarTerminalNames[getVariant()].name);
265857 : // printf ("Error in SgNullExpression::error() \n");
265858 : ROSE_ABORT();
265859 : }
265860 :
265861 : ROSE_ASSERT (getVariant() == NULL_EXPR);
265862 : return SgExpression::error();
265863 : }
265864 : #endif
265865 :
265866 :
265867 :
265868 : // End of memberFunctionString
265869 :
265870 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
265871 :
265872 1825 : SgNullExpression* isSgNullExpression ( SgNode* inputDerivedClassPointer )
265873 : {
265874 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
265875 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
265876 : // So to fix this we return NULL directly when the input is NULL and avoid the
265877 : // dynamic_cast in this case. This is likely a performance improvement as well.
265878 : // return dynamic_cast<SgNullExpression*>(inputDerivedClassPointer);
265879 : // Milind Chabbi (8/28/2013): isSgNullExpression uses table-driven castability instead of c++ default dynamic_cast
265880 : // this improves the running time performance by 10-20%.
265881 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNullExpression*>(inputDerivedClassPointer);
265882 1825 : return IS_SgNullExpression_FAST_MACRO(inputDerivedClassPointer);
265883 : }
265884 :
265885 : // DQ (11/8/2003): Added version of functions taking const pointer
265886 0 : const SgNullExpression* isSgNullExpression ( const SgNode* inputDerivedClassPointer )
265887 : {
265888 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
265889 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
265890 : // So to fix this we return NULL directly when the input is NULL and avoid the
265891 : // dynamic_cast in this case. This is likely a performance improvement as well.
265892 : // return dynamic_cast<const SgNullExpression*>(inputDerivedClassPointer);
265893 : // Milind Chabbi (8/28/2013): isSgNullExpression uses table-driven castability instead of c++ default dynamic_cast
265894 : // this improves the running time performance by 10-20%.
265895 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNullExpression*>(inputDerivedClassPointer);
265896 0 : return IS_SgNullExpression_FAST_MACRO(inputDerivedClassPointer);
265897 : }
265898 :
265899 :
265900 :
265901 : /* #line 265902 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265902 :
265903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
265904 :
265905 : /**
265906 : \brief Generated destructor
265907 :
265908 : This destructor is automatically generated (by ROSETTA). This destructor
265909 : only frees memory of data members associated with the parts of the current IR node which
265910 : are NOT traversed. Those data members that are part of a traversal can be freed using
265911 : a traversal (calling this destructor on all children in a post-order traversal). Such
265912 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
265913 :
265914 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
265915 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
265916 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
265917 :
265918 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
265919 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
265920 : pointers are not yet implemented to call delete on eash pointer in the container.
265921 : (This could be done by derivation from the STL containers to define containers that
265922 : automatically deleted their members.)
265923 :
265924 : */
265925 488 : SgNullExpression::~SgNullExpression () {
265926 244 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
265927 :
265928 :
265929 :
265930 : }
265931 :
265932 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
265933 488 : }
265934 :
265935 :
265936 : /* #line 265937 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265937 :
265938 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
265939 :
265940 : // Generated constructor
265941 0 : SgNullExpression::SgNullExpression ( Sg_File_Info* startOfConstruct )
265942 0 : : SgExpression(startOfConstruct)
265943 : {
265944 : #ifdef DEBUG
265945 : // printf ("In SgNullExpression::SgNullExpression (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
265946 : #endif
265947 : #if 0
265948 : // debugging information!
265949 : printf ("In SgNullExpression::SgNullExpression (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
265950 : #endif
265951 :
265952 :
265953 :
265954 : #if 0
265955 : // DQ (7/30/2014): Call a virtual function.
265956 : std::string s = this->class_name();
265957 : #endif
265958 :
265959 : // Test the variant virtual function
265960 : // assert(NULL_EXPR == variant());
265961 0 : assert(NULL_EXPR == this->variant());
265962 0 : ROSE_ASSERT(NULL_EXPR == (int)(this->variantT()));
265963 0 : post_construction_initialization();
265964 :
265965 : // Test the isSgNullExpression() function since it has been problematic
265966 0 : assert(isSgNullExpression(this) != NULL);
265967 0 : }
265968 :
265969 : // Generated constructor (all data members)
265970 :
265971 : /* #line 265972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265972 :
265973 :
265974 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
265975 :
265976 :
265977 : // ********************************************************
265978 : // member functions common across all array grammar objects
265979 : // ********************************************************
265980 :
265981 :
265982 :
265983 : /* #line 265984 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265984 :
265985 :
265986 :
265987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
265988 :
265989 : // ********************************************************
265990 : // member functions specific to each node in the grammar
265991 : // ********************************************************
265992 :
265993 :
265994 : /* #line 265995 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
265995 :
265996 : // Start of memberFunctionString
265997 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
265998 :
265999 : void
266000 1 : SgVariantExpression::post_construction_initialization()
266001 : {
266002 1 : }
266003 :
266004 :
266005 :
266006 : // End of memberFunctionString
266007 : // Start of memberFunctionString
266008 : /* #line 8530 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
266009 :
266010 :
266011 :
266012 : // End of memberFunctionString
266013 : // Start of memberFunctionString
266014 : /* #line 8359 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
266015 :
266016 :
266017 : SgType*
266018 1 : SgVariantExpression::get_type(void) const
266019 : {
266020 : #if 0
266021 : printf ("In SgVariantExpression::get_type() \n");
266022 : #endif
266023 :
266024 1 : return SgTypeDefault::createType();
266025 : }
266026 :
266027 :
266028 :
266029 : // End of memberFunctionString
266030 : // Start of memberFunctionString
266031 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
266032 :
266033 : // *** COMMON CODE SECTION BEGINS HERE ***
266034 :
266035 : #if 0
266036 : int
266037 : SgVariantExpression::getVariant() const
266038 : {
266039 : // This function is used in ROSE while "variant()" is used in SAGE
266040 : assert(this != NULL);
266041 : return variant();
266042 : }
266043 : #endif
266044 :
266045 : // This function is used in ROSE in treeTraversal code
266046 : // eventually replaces getVariant() and variant()
266047 : // though after variant() has been removed for a while we will
266048 : // want to change the name of variantT() back to variant()
266049 : // (since the "T" was ment to stand for temporary).
266050 : // When this happens the variantT() will be depricated.
266051 : VariantT
266052 233 : SgVariantExpression::variantT() const
266053 : {
266054 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
266055 233 : ROSE_ASSERT(this != NULL);
266056 233 : return V_SgVariantExpression;
266057 : }
266058 :
266059 : #if 0
266060 : int
266061 : SgVariantExpression::variant() const
266062 : {
266063 : // This function is used in SAGE
266064 : ROSE_ASSERT(this != NULL);
266065 : return VARIANT_EXPR;
266066 : }
266067 : #endif
266068 :
266069 : ROSE_DLL_API const char*
266070 0 : SgVariantExpression::sage_class_name() const
266071 : {
266072 0 : ROSE_ASSERT(this != NULL);
266073 0 : return "SgVariantExpression";
266074 : }
266075 :
266076 : std::string
266077 0 : SgVariantExpression::class_name() const
266078 : {
266079 0 : ROSE_ASSERT(this != NULL);
266080 0 : return "SgVariantExpression";
266081 : }
266082 :
266083 : // DQ (11/26/2005): Support for visitor pattern mechanims
266084 : // (inferior to ROSE traversal mechanism, experimental).
266085 : void
266086 0 : SgVariantExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
266087 : {
266088 0 : ROSE_ASSERT(this != NULL);
266089 0 : visitor.visit(this);
266090 0 : }
266091 :
266092 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
266093 0 : void SgVariantExpression::accept (ROSE_VisitorPattern & visitor) {
266094 0 : ROSE_ASSERT(this != NULL);
266095 0 : visitor.visit(this);
266096 0 : }
266097 :
266098 : SgVariantExpression*
266099 0 : SgVariantExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
266100 : {
266101 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
266102 : // This function is currently only supported for the AST used the represent Binary executables.
266103 : if (0 /* isSgAsmNode(this) != NULL */)
266104 : {
266105 : // Support for regex specification.
266106 : std::string prefixCode = "REGEX:";
266107 : addNewAttribute(prefixCode + s,a);
266108 : }
266109 : #endif
266110 :
266111 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
266112 0 : return this;
266113 : }
266114 :
266115 : // *** COMMON CODE SECTION ENDS HERE ***
266116 :
266117 :
266118 : // End of memberFunctionString
266119 : // Start of memberFunctionString
266120 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
266121 :
266122 :
266123 : #if 0
266124 : //! Error checking support
266125 : /*! Verifies the following:
266126 : - working getVariant() member function
266127 : - calls base class's error() member function
266128 : Every class has one of these functions.
266129 : */
266130 : bool
266131 : SgVariantExpression::error()
266132 : {
266133 : // Put error checking here
266134 :
266135 : ROSE_ASSERT (this != NULL);
266136 : if (getVariant() != VARIANT_EXPR)
266137 : {
266138 : printf ("Error in SgVariantExpression::error(): SgVariantExpression object has a %s variant \n",
266139 : Cxx_GrammarTerminalNames[getVariant()].name);
266140 : // printf ("Error in SgVariantExpression::error() \n");
266141 : ROSE_ABORT();
266142 : }
266143 :
266144 : ROSE_ASSERT (getVariant() == VARIANT_EXPR);
266145 : return SgExpression::error();
266146 : }
266147 : #endif
266148 :
266149 :
266150 :
266151 : // End of memberFunctionString
266152 :
266153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
266154 :
266155 1 : SgVariantExpression* isSgVariantExpression ( SgNode* inputDerivedClassPointer )
266156 : {
266157 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
266158 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
266159 : // So to fix this we return NULL directly when the input is NULL and avoid the
266160 : // dynamic_cast in this case. This is likely a performance improvement as well.
266161 : // return dynamic_cast<SgVariantExpression*>(inputDerivedClassPointer);
266162 : // Milind Chabbi (8/28/2013): isSgVariantExpression uses table-driven castability instead of c++ default dynamic_cast
266163 : // this improves the running time performance by 10-20%.
266164 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVariantExpression*>(inputDerivedClassPointer);
266165 1 : return IS_SgVariantExpression_FAST_MACRO(inputDerivedClassPointer);
266166 : }
266167 :
266168 : // DQ (11/8/2003): Added version of functions taking const pointer
266169 0 : const SgVariantExpression* isSgVariantExpression ( const SgNode* inputDerivedClassPointer )
266170 : {
266171 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
266172 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
266173 : // So to fix this we return NULL directly when the input is NULL and avoid the
266174 : // dynamic_cast in this case. This is likely a performance improvement as well.
266175 : // return dynamic_cast<const SgVariantExpression*>(inputDerivedClassPointer);
266176 : // Milind Chabbi (8/28/2013): isSgVariantExpression uses table-driven castability instead of c++ default dynamic_cast
266177 : // this improves the running time performance by 10-20%.
266178 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVariantExpression*>(inputDerivedClassPointer);
266179 0 : return IS_SgVariantExpression_FAST_MACRO(inputDerivedClassPointer);
266180 : }
266181 :
266182 :
266183 :
266184 : /* #line 266185 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266185 :
266186 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
266187 :
266188 : /**
266189 : \brief Generated destructor
266190 :
266191 : This destructor is automatically generated (by ROSETTA). This destructor
266192 : only frees memory of data members associated with the parts of the current IR node which
266193 : are NOT traversed. Those data members that are part of a traversal can be freed using
266194 : a traversal (calling this destructor on all children in a post-order traversal). Such
266195 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
266196 :
266197 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
266198 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
266199 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
266200 :
266201 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
266202 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
266203 : pointers are not yet implemented to call delete on eash pointer in the container.
266204 : (This could be done by derivation from the STL containers to define containers that
266205 : automatically deleted their members.)
266206 :
266207 : */
266208 2 : SgVariantExpression::~SgVariantExpression () {
266209 1 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
266210 :
266211 :
266212 :
266213 : }
266214 :
266215 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
266216 2 : }
266217 :
266218 :
266219 : /* #line 266220 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266220 :
266221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
266222 :
266223 : // Generated constructor
266224 0 : SgVariantExpression::SgVariantExpression ( Sg_File_Info* startOfConstruct )
266225 0 : : SgExpression(startOfConstruct)
266226 : {
266227 : #ifdef DEBUG
266228 : // printf ("In SgVariantExpression::SgVariantExpression (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
266229 : #endif
266230 : #if 0
266231 : // debugging information!
266232 : printf ("In SgVariantExpression::SgVariantExpression (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
266233 : #endif
266234 :
266235 :
266236 :
266237 : #if 0
266238 : // DQ (7/30/2014): Call a virtual function.
266239 : std::string s = this->class_name();
266240 : #endif
266241 :
266242 : // Test the variant virtual function
266243 : // assert(VARIANT_EXPR == variant());
266244 0 : assert(VARIANT_EXPR == this->variant());
266245 0 : ROSE_ASSERT(VARIANT_EXPR == (int)(this->variantT()));
266246 0 : post_construction_initialization();
266247 :
266248 : // Test the isSgVariantExpression() function since it has been problematic
266249 0 : assert(isSgVariantExpression(this) != NULL);
266250 0 : }
266251 :
266252 : // Generated constructor (all data members)
266253 :
266254 : /* #line 266255 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266255 :
266256 :
266257 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
266258 :
266259 :
266260 : // ********************************************************
266261 : // member functions common across all array grammar objects
266262 : // ********************************************************
266263 :
266264 :
266265 :
266266 : /* #line 266267 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266267 :
266268 :
266269 :
266270 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
266271 :
266272 : // ********************************************************
266273 : // member functions specific to each node in the grammar
266274 : // ********************************************************
266275 :
266276 :
266277 : /* #line 266278 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266278 :
266279 : // Start of memberFunctionString
266280 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
266281 :
266282 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
266283 :
266284 : SgExpression*
266285 0 : SgSubscriptExpression::get_lowerBound () const
266286 : {
266287 0 : ROSE_ASSERT (this != NULL);
266288 :
266289 : #if 0
266290 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
266291 : // used to trigger marking transformations for the token-based unparsing.
266292 : printf ("SgSubscriptExpression::get_lowerBound = %p = %s \n",this,this->class_name().c_str());
266293 : #endif
266294 :
266295 0 : return p_lowerBound;
266296 : }
266297 :
266298 : void
266299 0 : SgSubscriptExpression::set_lowerBound ( SgExpression* lowerBound )
266300 : {
266301 0 : ROSE_ASSERT (this != NULL);
266302 :
266303 : #if 0
266304 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
266305 : // used to trigger marking transformations for the token-based unparsing.
266306 : printf ("SgSubscriptExpression::set_lowerBound = %p = %s \n",this,this->class_name().c_str());
266307 : #endif
266308 :
266309 0 : set_isModified(true);
266310 :
266311 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
266312 : if (p_lowerBound != NULL && lowerBound != NULL && p_lowerBound != lowerBound)
266313 : {
266314 : printf ("Warning: lowerBound = %p overwriting valid pointer p_lowerBound = %p \n",lowerBound,p_lowerBound);
266315 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
266316 : printf ("Error fails assertion (p_lowerBound != NULL && lowerBound != NULL && p_lowerBound != lowerBound) is false\n");
266317 : ROSE_ASSERT(false);
266318 : #endif
266319 : }
266320 : #endif
266321 0 : p_lowerBound = lowerBound;
266322 0 : }
266323 :
266324 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
266325 :
266326 :
266327 : // End of memberFunctionString
266328 : // Start of memberFunctionString
266329 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
266330 :
266331 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
266332 :
266333 : SgExpression*
266334 0 : SgSubscriptExpression::get_upperBound () const
266335 : {
266336 0 : ROSE_ASSERT (this != NULL);
266337 :
266338 : #if 0
266339 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
266340 : // used to trigger marking transformations for the token-based unparsing.
266341 : printf ("SgSubscriptExpression::get_upperBound = %p = %s \n",this,this->class_name().c_str());
266342 : #endif
266343 :
266344 0 : return p_upperBound;
266345 : }
266346 :
266347 : void
266348 0 : SgSubscriptExpression::set_upperBound ( SgExpression* upperBound )
266349 : {
266350 0 : ROSE_ASSERT (this != NULL);
266351 :
266352 : #if 0
266353 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
266354 : // used to trigger marking transformations for the token-based unparsing.
266355 : printf ("SgSubscriptExpression::set_upperBound = %p = %s \n",this,this->class_name().c_str());
266356 : #endif
266357 :
266358 0 : set_isModified(true);
266359 :
266360 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
266361 : if (p_upperBound != NULL && upperBound != NULL && p_upperBound != upperBound)
266362 : {
266363 : printf ("Warning: upperBound = %p overwriting valid pointer p_upperBound = %p \n",upperBound,p_upperBound);
266364 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
266365 : printf ("Error fails assertion (p_upperBound != NULL && upperBound != NULL && p_upperBound != upperBound) is false\n");
266366 : ROSE_ASSERT(false);
266367 : #endif
266368 : }
266369 : #endif
266370 0 : p_upperBound = upperBound;
266371 0 : }
266372 :
266373 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
266374 :
266375 :
266376 : // End of memberFunctionString
266377 : // Start of memberFunctionString
266378 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
266379 :
266380 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
266381 :
266382 : SgExpression*
266383 0 : SgSubscriptExpression::get_stride () const
266384 : {
266385 0 : ROSE_ASSERT (this != NULL);
266386 :
266387 : #if 0
266388 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
266389 : // used to trigger marking transformations for the token-based unparsing.
266390 : printf ("SgSubscriptExpression::get_stride = %p = %s \n",this,this->class_name().c_str());
266391 : #endif
266392 :
266393 0 : return p_stride;
266394 : }
266395 :
266396 : void
266397 0 : SgSubscriptExpression::set_stride ( SgExpression* stride )
266398 : {
266399 0 : ROSE_ASSERT (this != NULL);
266400 :
266401 : #if 0
266402 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
266403 : // used to trigger marking transformations for the token-based unparsing.
266404 : printf ("SgSubscriptExpression::set_stride = %p = %s \n",this,this->class_name().c_str());
266405 : #endif
266406 :
266407 0 : set_isModified(true);
266408 :
266409 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
266410 : if (p_stride != NULL && stride != NULL && p_stride != stride)
266411 : {
266412 : printf ("Warning: stride = %p overwriting valid pointer p_stride = %p \n",stride,p_stride);
266413 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
266414 : printf ("Error fails assertion (p_stride != NULL && stride != NULL && p_stride != stride) is false\n");
266415 : ROSE_ASSERT(false);
266416 : #endif
266417 : }
266418 : #endif
266419 0 : p_stride = stride;
266420 0 : }
266421 :
266422 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
266423 :
266424 :
266425 : // End of memberFunctionString
266426 : // Start of memberFunctionString
266427 : /* #line 8700 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
266428 :
266429 :
266430 : void
266431 0 : SgSubscriptExpression::post_construction_initialization()
266432 0 : { }
266433 :
266434 : SgType*
266435 0 : SgSubscriptExpression::get_type() const
266436 : {
266437 : // printf ("Not clear what the type should be for a SgSubscriptExpression: returning type of lower bound,upper bound, and string; or SgIntType if none are available. \n");
266438 : // ROSE_ASSERT(false);
266439 :
266440 0 : SgType* returnType = NULL;
266441 :
266442 : #if 0
266443 : printf ("In SgSubscriptExpression::get_type() \n");
266444 : #endif
266445 :
266446 0 : bool isLowerBoundNullExpression = (isSgNullExpression(get_lowerBound()) != NULL);
266447 0 : bool isUpperBoundNullExpression = (isSgNullExpression(get_upperBound()) != NULL);
266448 0 : bool isStrideNullExpression = (isSgNullExpression(get_stride()) != NULL);
266449 :
266450 : // Even if the stride was not specified it should default to unit stride (value == 1).
266451 0 : ROSE_ASSERT(isStrideNullExpression == false);
266452 :
266453 0 : if (isLowerBoundNullExpression == true)
266454 : {
266455 : // There was no lower bound specified
266456 0 : if (isUpperBoundNullExpression == true)
266457 : {
266458 : // There was no upper bound specified, so we have to assume SgIntType is OK!
266459 0 : returnType = SgTypeInt::createType();
266460 : }
266461 : else
266462 : {
266463 0 : returnType = get_upperBound()->get_type();
266464 : }
266465 : }
266466 : else
266467 : {
266468 0 : returnType = get_lowerBound()->get_type();
266469 0 : if (isUpperBoundNullExpression == true)
266470 : {
266471 : // Not a problem since the lower bound was specified
266472 : }
266473 : else
266474 : {
266475 : // Just make sure that they are the same type, not clear how important this is!
266476 0 : SgType* upperBoundType = get_upperBound()->get_type();
266477 : // ROSE_ASSERT(upperBoundType->variantT() == returnType->variantT());
266478 0 : if (upperBoundType->variantT() != returnType->variantT())
266479 : {
266480 : // These are a different type..., I wonder why
266481 0 : printf ("In SgSubscriptExpression::get_type(): Note that lowerBound = %s and upperBound = %s are different types \n",returnType->class_name().c_str(),upperBoundType->class_name().c_str());
266482 0 : this->get_startOfConstruct()->display("In SgSubscriptExpression::get_type(): lowerBound and upperBound are different types");
266483 : }
266484 : }
266485 : }
266486 :
266487 0 : return returnType;
266488 : }
266489 :
266490 : #if 0
266491 : // DQ (3/20/2007): This is an older function now depricated.
266492 : int
266493 : SgSubscriptExpression::replace_expression(SgExpression *o, SgExpression *n)
266494 : {
266495 : if(get_lowerBound()==o)
266496 : {
266497 : set_lowerBound(n);
266498 : return 1;
266499 : }
266500 : else
266501 : if(get_upperBound()==o)
266502 : {
266503 : set_upperBound(n);
266504 : return 1;
266505 : }
266506 : else
266507 : if(get_stride()==o)
266508 : {
266509 : set_stride(n);
266510 : return 1;
266511 : }
266512 : else
266513 : return 0;
266514 : }
266515 : #endif
266516 :
266517 :
266518 :
266519 : // End of memberFunctionString
266520 : // Start of memberFunctionString
266521 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
266522 :
266523 : // *** COMMON CODE SECTION BEGINS HERE ***
266524 :
266525 : #if 0
266526 : int
266527 : SgSubscriptExpression::getVariant() const
266528 : {
266529 : // This function is used in ROSE while "variant()" is used in SAGE
266530 : assert(this != NULL);
266531 : return variant();
266532 : }
266533 : #endif
266534 :
266535 : // This function is used in ROSE in treeTraversal code
266536 : // eventually replaces getVariant() and variant()
266537 : // though after variant() has been removed for a while we will
266538 : // want to change the name of variantT() back to variant()
266539 : // (since the "T" was ment to stand for temporary).
266540 : // When this happens the variantT() will be depricated.
266541 : VariantT
266542 0 : SgSubscriptExpression::variantT() const
266543 : {
266544 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
266545 0 : ROSE_ASSERT(this != NULL);
266546 0 : return V_SgSubscriptExpression;
266547 : }
266548 :
266549 : #if 0
266550 : int
266551 : SgSubscriptExpression::variant() const
266552 : {
266553 : // This function is used in SAGE
266554 : ROSE_ASSERT(this != NULL);
266555 : return SUBSCRIPT_EXPR;
266556 : }
266557 : #endif
266558 :
266559 : ROSE_DLL_API const char*
266560 0 : SgSubscriptExpression::sage_class_name() const
266561 : {
266562 0 : ROSE_ASSERT(this != NULL);
266563 0 : return "SgSubscriptExpression";
266564 : }
266565 :
266566 : std::string
266567 0 : SgSubscriptExpression::class_name() const
266568 : {
266569 0 : ROSE_ASSERT(this != NULL);
266570 0 : return "SgSubscriptExpression";
266571 : }
266572 :
266573 : // DQ (11/26/2005): Support for visitor pattern mechanims
266574 : // (inferior to ROSE traversal mechanism, experimental).
266575 : void
266576 0 : SgSubscriptExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
266577 : {
266578 0 : ROSE_ASSERT(this != NULL);
266579 0 : visitor.visit(this);
266580 0 : }
266581 :
266582 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
266583 0 : void SgSubscriptExpression::accept (ROSE_VisitorPattern & visitor) {
266584 0 : ROSE_ASSERT(this != NULL);
266585 0 : visitor.visit(this);
266586 0 : }
266587 :
266588 : SgSubscriptExpression*
266589 0 : SgSubscriptExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
266590 : {
266591 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
266592 : // This function is currently only supported for the AST used the represent Binary executables.
266593 : if (0 /* isSgAsmNode(this) != NULL */)
266594 : {
266595 : // Support for regex specification.
266596 : std::string prefixCode = "REGEX:";
266597 : addNewAttribute(prefixCode + s,a);
266598 : }
266599 : #endif
266600 :
266601 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
266602 0 : return this;
266603 : }
266604 :
266605 : // *** COMMON CODE SECTION ENDS HERE ***
266606 :
266607 :
266608 : // End of memberFunctionString
266609 : // Start of memberFunctionString
266610 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
266611 :
266612 :
266613 : #if 0
266614 : //! Error checking support
266615 : /*! Verifies the following:
266616 : - working getVariant() member function
266617 : - calls base class's error() member function
266618 : Every class has one of these functions.
266619 : */
266620 : bool
266621 : SgSubscriptExpression::error()
266622 : {
266623 : // Put error checking here
266624 :
266625 : ROSE_ASSERT (this != NULL);
266626 : if (getVariant() != SUBSCRIPT_EXPR)
266627 : {
266628 : printf ("Error in SgSubscriptExpression::error(): SgSubscriptExpression object has a %s variant \n",
266629 : Cxx_GrammarTerminalNames[getVariant()].name);
266630 : // printf ("Error in SgSubscriptExpression::error() \n");
266631 : ROSE_ABORT();
266632 : }
266633 :
266634 : ROSE_ASSERT (getVariant() == SUBSCRIPT_EXPR);
266635 : return SgExpression::error();
266636 : }
266637 : #endif
266638 :
266639 :
266640 :
266641 : // End of memberFunctionString
266642 :
266643 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
266644 :
266645 75444 : SgSubscriptExpression* isSgSubscriptExpression ( SgNode* inputDerivedClassPointer )
266646 : {
266647 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
266648 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
266649 : // So to fix this we return NULL directly when the input is NULL and avoid the
266650 : // dynamic_cast in this case. This is likely a performance improvement as well.
266651 : // return dynamic_cast<SgSubscriptExpression*>(inputDerivedClassPointer);
266652 : // Milind Chabbi (8/28/2013): isSgSubscriptExpression uses table-driven castability instead of c++ default dynamic_cast
266653 : // this improves the running time performance by 10-20%.
266654 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSubscriptExpression*>(inputDerivedClassPointer);
266655 75444 : return IS_SgSubscriptExpression_FAST_MACRO(inputDerivedClassPointer);
266656 : }
266657 :
266658 : // DQ (11/8/2003): Added version of functions taking const pointer
266659 0 : const SgSubscriptExpression* isSgSubscriptExpression ( const SgNode* inputDerivedClassPointer )
266660 : {
266661 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
266662 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
266663 : // So to fix this we return NULL directly when the input is NULL and avoid the
266664 : // dynamic_cast in this case. This is likely a performance improvement as well.
266665 : // return dynamic_cast<const SgSubscriptExpression*>(inputDerivedClassPointer);
266666 : // Milind Chabbi (8/28/2013): isSgSubscriptExpression uses table-driven castability instead of c++ default dynamic_cast
266667 : // this improves the running time performance by 10-20%.
266668 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSubscriptExpression*>(inputDerivedClassPointer);
266669 0 : return IS_SgSubscriptExpression_FAST_MACRO(inputDerivedClassPointer);
266670 : }
266671 :
266672 :
266673 :
266674 : /* #line 266675 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266675 :
266676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
266677 :
266678 : /**
266679 : \brief Generated destructor
266680 :
266681 : This destructor is automatically generated (by ROSETTA). This destructor
266682 : only frees memory of data members associated with the parts of the current IR node which
266683 : are NOT traversed. Those data members that are part of a traversal can be freed using
266684 : a traversal (calling this destructor on all children in a post-order traversal). Such
266685 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
266686 :
266687 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
266688 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
266689 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
266690 :
266691 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
266692 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
266693 : pointers are not yet implemented to call delete on eash pointer in the container.
266694 : (This could be done by derivation from the STL containers to define containers that
266695 : automatically deleted their members.)
266696 :
266697 : */
266698 0 : SgSubscriptExpression::~SgSubscriptExpression () {
266699 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
266700 :
266701 :
266702 : // case: not a listType for lowerBound
266703 0 : p_lowerBound = NULL; // non list case
266704 : // case: not a listType for upperBound
266705 0 : p_upperBound = NULL; // non list case
266706 : // case: not a listType for stride
266707 0 : p_stride = NULL; // non list case
266708 :
266709 : }
266710 :
266711 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
266712 0 : }
266713 :
266714 :
266715 : /* #line 266716 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266716 :
266717 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
266718 :
266719 : // Generated constructor
266720 0 : SgSubscriptExpression::SgSubscriptExpression ( Sg_File_Info* startOfConstruct, SgExpression* lowerBound, SgExpression* upperBound, SgExpression* stride )
266721 0 : : SgExpression(startOfConstruct)
266722 : {
266723 : #ifdef DEBUG
266724 : // printf ("In SgSubscriptExpression::SgSubscriptExpression (Sg_File_Info* startOfConstruct, SgExpression* lowerBound, SgExpression* upperBound, SgExpression* stride) sage_class_name() = %s \n",sage_class_name());
266725 : #endif
266726 : #if 0
266727 : // debugging information!
266728 : printf ("In SgSubscriptExpression::SgSubscriptExpression (Sg_File_Info* startOfConstruct, SgExpression* lowerBound, SgExpression* upperBound, SgExpression* stride): this = %p = %s \n",this,this->class_name().c_str());
266729 : #endif
266730 :
266731 0 : p_lowerBound = lowerBound;
266732 0 : p_upperBound = upperBound;
266733 0 : p_stride = stride;
266734 :
266735 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
266736 :
266737 : #if 0
266738 : // DQ (7/30/2014): Call a virtual function.
266739 : std::string s = this->class_name();
266740 : #endif
266741 :
266742 : // Test the variant virtual function
266743 : // assert(SUBSCRIPT_EXPR == variant());
266744 0 : assert(SUBSCRIPT_EXPR == this->variant());
266745 0 : ROSE_ASSERT(SUBSCRIPT_EXPR == (int)(this->variantT()));
266746 0 : post_construction_initialization();
266747 :
266748 : // Test the isSgSubscriptExpression() function since it has been problematic
266749 0 : assert(isSgSubscriptExpression(this) != NULL);
266750 0 : }
266751 :
266752 : // Generated constructor (all data members)
266753 :
266754 : /* #line 266755 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266755 :
266756 :
266757 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
266758 :
266759 :
266760 : // ********************************************************
266761 : // member functions common across all array grammar objects
266762 : // ********************************************************
266763 :
266764 :
266765 :
266766 : /* #line 266767 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266767 :
266768 :
266769 :
266770 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
266771 :
266772 : // ********************************************************
266773 : // member functions specific to each node in the grammar
266774 : // ********************************************************
266775 :
266776 :
266777 : /* #line 266778 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266778 :
266779 : // Start of memberFunctionString
266780 : /* #line 8839 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
266781 :
266782 :
266783 : void
266784 0 : SgColonShapeExp::post_construction_initialization()
266785 0 : { }
266786 :
266787 :
266788 : SgType*
266789 0 : SgColonShapeExp::get_type() const
266790 : {
266791 : // printf ("In SgColonShapeExp::get_type(): Not clear what this type should be. \n");
266792 : // ROSE_ASSERT(false);
266793 :
266794 : #if 0
266795 : printf ("In SgColonShapeExp::get_type() \n");
266796 : #endif
266797 :
266798 0 : return SgTypeDefault::createType();
266799 : }
266800 :
266801 : #if 0
266802 : // DQ (3/20/2007): This is an older function now depricated.
266803 : int
266804 : SgColonShapeExp::replace_expression(SgExpression *o, SgExpression *n)
266805 : {
266806 : if(get_lowerBound()==o)
266807 : {
266808 : set_lowerBound(n);
266809 : return 1;
266810 : }
266811 : else
266812 : if(get_stride()==o)
266813 : {
266814 : set_stride(n);
266815 : return 1;
266816 : }
266817 : else
266818 : return 0;
266819 : }
266820 : #endif
266821 :
266822 :
266823 :
266824 : // End of memberFunctionString
266825 : // Start of memberFunctionString
266826 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
266827 :
266828 : // *** COMMON CODE SECTION BEGINS HERE ***
266829 :
266830 : #if 0
266831 : int
266832 : SgColonShapeExp::getVariant() const
266833 : {
266834 : // This function is used in ROSE while "variant()" is used in SAGE
266835 : assert(this != NULL);
266836 : return variant();
266837 : }
266838 : #endif
266839 :
266840 : // This function is used in ROSE in treeTraversal code
266841 : // eventually replaces getVariant() and variant()
266842 : // though after variant() has been removed for a while we will
266843 : // want to change the name of variantT() back to variant()
266844 : // (since the "T" was ment to stand for temporary).
266845 : // When this happens the variantT() will be depricated.
266846 : VariantT
266847 0 : SgColonShapeExp::variantT() const
266848 : {
266849 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
266850 0 : ROSE_ASSERT(this != NULL);
266851 0 : return V_SgColonShapeExp;
266852 : }
266853 :
266854 : #if 0
266855 : int
266856 : SgColonShapeExp::variant() const
266857 : {
266858 : // This function is used in SAGE
266859 : ROSE_ASSERT(this != NULL);
266860 : return TEMP_ColonShapeExp;
266861 : }
266862 : #endif
266863 :
266864 : ROSE_DLL_API const char*
266865 0 : SgColonShapeExp::sage_class_name() const
266866 : {
266867 0 : ROSE_ASSERT(this != NULL);
266868 0 : return "SgColonShapeExp";
266869 : }
266870 :
266871 : std::string
266872 0 : SgColonShapeExp::class_name() const
266873 : {
266874 0 : ROSE_ASSERT(this != NULL);
266875 0 : return "SgColonShapeExp";
266876 : }
266877 :
266878 : // DQ (11/26/2005): Support for visitor pattern mechanims
266879 : // (inferior to ROSE traversal mechanism, experimental).
266880 : void
266881 0 : SgColonShapeExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
266882 : {
266883 0 : ROSE_ASSERT(this != NULL);
266884 0 : visitor.visit(this);
266885 0 : }
266886 :
266887 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
266888 0 : void SgColonShapeExp::accept (ROSE_VisitorPattern & visitor) {
266889 0 : ROSE_ASSERT(this != NULL);
266890 0 : visitor.visit(this);
266891 0 : }
266892 :
266893 : SgColonShapeExp*
266894 0 : SgColonShapeExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
266895 : {
266896 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
266897 : // This function is currently only supported for the AST used the represent Binary executables.
266898 : if (0 /* isSgAsmNode(this) != NULL */)
266899 : {
266900 : // Support for regex specification.
266901 : std::string prefixCode = "REGEX:";
266902 : addNewAttribute(prefixCode + s,a);
266903 : }
266904 : #endif
266905 :
266906 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
266907 0 : return this;
266908 : }
266909 :
266910 : // *** COMMON CODE SECTION ENDS HERE ***
266911 :
266912 :
266913 : // End of memberFunctionString
266914 : // Start of memberFunctionString
266915 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
266916 :
266917 :
266918 : #if 0
266919 : //! Error checking support
266920 : /*! Verifies the following:
266921 : - working getVariant() member function
266922 : - calls base class's error() member function
266923 : Every class has one of these functions.
266924 : */
266925 : bool
266926 : SgColonShapeExp::error()
266927 : {
266928 : // Put error checking here
266929 :
266930 : ROSE_ASSERT (this != NULL);
266931 : if (getVariant() != TEMP_ColonShapeExp)
266932 : {
266933 : printf ("Error in SgColonShapeExp::error(): SgColonShapeExp object has a %s variant \n",
266934 : Cxx_GrammarTerminalNames[getVariant()].name);
266935 : // printf ("Error in SgColonShapeExp::error() \n");
266936 : ROSE_ABORT();
266937 : }
266938 :
266939 : ROSE_ASSERT (getVariant() == TEMP_ColonShapeExp);
266940 : return SgExpression::error();
266941 : }
266942 : #endif
266943 :
266944 :
266945 :
266946 : // End of memberFunctionString
266947 :
266948 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
266949 :
266950 0 : SgColonShapeExp* isSgColonShapeExp ( SgNode* inputDerivedClassPointer )
266951 : {
266952 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
266953 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
266954 : // So to fix this we return NULL directly when the input is NULL and avoid the
266955 : // dynamic_cast in this case. This is likely a performance improvement as well.
266956 : // return dynamic_cast<SgColonShapeExp*>(inputDerivedClassPointer);
266957 : // Milind Chabbi (8/28/2013): isSgColonShapeExp uses table-driven castability instead of c++ default dynamic_cast
266958 : // this improves the running time performance by 10-20%.
266959 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgColonShapeExp*>(inputDerivedClassPointer);
266960 0 : return IS_SgColonShapeExp_FAST_MACRO(inputDerivedClassPointer);
266961 : }
266962 :
266963 : // DQ (11/8/2003): Added version of functions taking const pointer
266964 0 : const SgColonShapeExp* isSgColonShapeExp ( const SgNode* inputDerivedClassPointer )
266965 : {
266966 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
266967 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
266968 : // So to fix this we return NULL directly when the input is NULL and avoid the
266969 : // dynamic_cast in this case. This is likely a performance improvement as well.
266970 : // return dynamic_cast<const SgColonShapeExp*>(inputDerivedClassPointer);
266971 : // Milind Chabbi (8/28/2013): isSgColonShapeExp uses table-driven castability instead of c++ default dynamic_cast
266972 : // this improves the running time performance by 10-20%.
266973 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgColonShapeExp*>(inputDerivedClassPointer);
266974 0 : return IS_SgColonShapeExp_FAST_MACRO(inputDerivedClassPointer);
266975 : }
266976 :
266977 :
266978 :
266979 : /* #line 266980 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
266980 :
266981 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
266982 :
266983 : /**
266984 : \brief Generated destructor
266985 :
266986 : This destructor is automatically generated (by ROSETTA). This destructor
266987 : only frees memory of data members associated with the parts of the current IR node which
266988 : are NOT traversed. Those data members that are part of a traversal can be freed using
266989 : a traversal (calling this destructor on all children in a post-order traversal). Such
266990 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
266991 :
266992 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
266993 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
266994 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
266995 :
266996 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
266997 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
266998 : pointers are not yet implemented to call delete on eash pointer in the container.
266999 : (This could be done by derivation from the STL containers to define containers that
267000 : automatically deleted their members.)
267001 :
267002 : */
267003 0 : SgColonShapeExp::~SgColonShapeExp () {
267004 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
267005 :
267006 :
267007 :
267008 : }
267009 :
267010 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
267011 0 : }
267012 :
267013 :
267014 : /* #line 267015 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267015 :
267016 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
267017 :
267018 : // Generated constructor
267019 0 : SgColonShapeExp::SgColonShapeExp ( Sg_File_Info* startOfConstruct )
267020 0 : : SgExpression(startOfConstruct)
267021 : {
267022 : #ifdef DEBUG
267023 : // printf ("In SgColonShapeExp::SgColonShapeExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
267024 : #endif
267025 : #if 0
267026 : // debugging information!
267027 : printf ("In SgColonShapeExp::SgColonShapeExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
267028 : #endif
267029 :
267030 :
267031 :
267032 : #if 0
267033 : // DQ (7/30/2014): Call a virtual function.
267034 : std::string s = this->class_name();
267035 : #endif
267036 :
267037 : // Test the variant virtual function
267038 : // assert(TEMP_ColonShapeExp == variant());
267039 0 : assert(TEMP_ColonShapeExp == this->variant());
267040 0 : ROSE_ASSERT(TEMP_ColonShapeExp == (int)(this->variantT()));
267041 0 : post_construction_initialization();
267042 :
267043 : // Test the isSgColonShapeExp() function since it has been problematic
267044 0 : assert(isSgColonShapeExp(this) != NULL);
267045 0 : }
267046 :
267047 : // Generated constructor (all data members)
267048 :
267049 : /* #line 267050 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267050 :
267051 :
267052 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
267053 :
267054 :
267055 : // ********************************************************
267056 : // member functions common across all array grammar objects
267057 : // ********************************************************
267058 :
267059 :
267060 :
267061 : /* #line 267062 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267062 :
267063 :
267064 :
267065 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
267066 :
267067 : // ********************************************************
267068 : // member functions specific to each node in the grammar
267069 : // ********************************************************
267070 :
267071 :
267072 : /* #line 267073 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267073 :
267074 : // Start of memberFunctionString
267075 : /* #line 8883 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
267076 :
267077 :
267078 : void
267079 69 : SgAsteriskShapeExp::post_construction_initialization()
267080 69 : { }
267081 :
267082 : SgType*
267083 68 : SgAsteriskShapeExp::get_type() const
267084 : {
267085 : // printf ("In SgAsteriskShapeExp::get_type(): Not clear what this type should be. \n");
267086 : // ROSE_ASSERT(false);
267087 :
267088 : #if 0
267089 : printf ("In SgAsteriskShapeExp::get_type() \n");
267090 : #endif
267091 :
267092 68 : return SgTypeDefault::createType();
267093 : }
267094 :
267095 : #if 0
267096 : // DQ (3/20/2007): This is an older function now depricated.
267097 : int
267098 : SgAsteriskShapeExp::replace_expression(SgExpression *o, SgExpression *n)
267099 : {
267100 : if(get_lowerBound()==o)
267101 : {
267102 : set_lowerBound(n);
267103 : return 1;
267104 : }
267105 : else
267106 : if(get_stride()==o)
267107 : {
267108 : set_stride(n);
267109 : return 1;
267110 : }
267111 : else
267112 : return 0;
267113 : }
267114 : #endif
267115 :
267116 :
267117 :
267118 : // End of memberFunctionString
267119 : // Start of memberFunctionString
267120 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
267121 :
267122 : // *** COMMON CODE SECTION BEGINS HERE ***
267123 :
267124 : #if 0
267125 : int
267126 : SgAsteriskShapeExp::getVariant() const
267127 : {
267128 : // This function is used in ROSE while "variant()" is used in SAGE
267129 : assert(this != NULL);
267130 : return variant();
267131 : }
267132 : #endif
267133 :
267134 : // This function is used in ROSE in treeTraversal code
267135 : // eventually replaces getVariant() and variant()
267136 : // though after variant() has been removed for a while we will
267137 : // want to change the name of variantT() back to variant()
267138 : // (since the "T" was ment to stand for temporary).
267139 : // When this happens the variantT() will be depricated.
267140 : VariantT
267141 38934 : SgAsteriskShapeExp::variantT() const
267142 : {
267143 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
267144 38934 : ROSE_ASSERT(this != NULL);
267145 38934 : return V_SgAsteriskShapeExp;
267146 : }
267147 :
267148 : #if 0
267149 : int
267150 : SgAsteriskShapeExp::variant() const
267151 : {
267152 : // This function is used in SAGE
267153 : ROSE_ASSERT(this != NULL);
267154 : return TEMP_AsteriskShapeExp;
267155 : }
267156 : #endif
267157 :
267158 : ROSE_DLL_API const char*
267159 138 : SgAsteriskShapeExp::sage_class_name() const
267160 : {
267161 138 : ROSE_ASSERT(this != NULL);
267162 138 : return "SgAsteriskShapeExp";
267163 : }
267164 :
267165 : std::string
267166 68 : SgAsteriskShapeExp::class_name() const
267167 : {
267168 68 : ROSE_ASSERT(this != NULL);
267169 68 : return "SgAsteriskShapeExp";
267170 : }
267171 :
267172 : // DQ (11/26/2005): Support for visitor pattern mechanims
267173 : // (inferior to ROSE traversal mechanism, experimental).
267174 : void
267175 0 : SgAsteriskShapeExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
267176 : {
267177 0 : ROSE_ASSERT(this != NULL);
267178 0 : visitor.visit(this);
267179 0 : }
267180 :
267181 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
267182 0 : void SgAsteriskShapeExp::accept (ROSE_VisitorPattern & visitor) {
267183 0 : ROSE_ASSERT(this != NULL);
267184 0 : visitor.visit(this);
267185 0 : }
267186 :
267187 : SgAsteriskShapeExp*
267188 0 : SgAsteriskShapeExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
267189 : {
267190 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
267191 : // This function is currently only supported for the AST used the represent Binary executables.
267192 : if (0 /* isSgAsmNode(this) != NULL */)
267193 : {
267194 : // Support for regex specification.
267195 : std::string prefixCode = "REGEX:";
267196 : addNewAttribute(prefixCode + s,a);
267197 : }
267198 : #endif
267199 :
267200 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
267201 0 : return this;
267202 : }
267203 :
267204 : // *** COMMON CODE SECTION ENDS HERE ***
267205 :
267206 :
267207 : // End of memberFunctionString
267208 : // Start of memberFunctionString
267209 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
267210 :
267211 :
267212 : #if 0
267213 : //! Error checking support
267214 : /*! Verifies the following:
267215 : - working getVariant() member function
267216 : - calls base class's error() member function
267217 : Every class has one of these functions.
267218 : */
267219 : bool
267220 : SgAsteriskShapeExp::error()
267221 : {
267222 : // Put error checking here
267223 :
267224 : ROSE_ASSERT (this != NULL);
267225 : if (getVariant() != TEMP_AsteriskShapeExp)
267226 : {
267227 : printf ("Error in SgAsteriskShapeExp::error(): SgAsteriskShapeExp object has a %s variant \n",
267228 : Cxx_GrammarTerminalNames[getVariant()].name);
267229 : // printf ("Error in SgAsteriskShapeExp::error() \n");
267230 : ROSE_ABORT();
267231 : }
267232 :
267233 : ROSE_ASSERT (getVariant() == TEMP_AsteriskShapeExp);
267234 : return SgExpression::error();
267235 : }
267236 : #endif
267237 :
267238 :
267239 :
267240 : // End of memberFunctionString
267241 :
267242 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
267243 :
267244 145 : SgAsteriskShapeExp* isSgAsteriskShapeExp ( SgNode* inputDerivedClassPointer )
267245 : {
267246 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
267247 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
267248 : // So to fix this we return NULL directly when the input is NULL and avoid the
267249 : // dynamic_cast in this case. This is likely a performance improvement as well.
267250 : // return dynamic_cast<SgAsteriskShapeExp*>(inputDerivedClassPointer);
267251 : // Milind Chabbi (8/28/2013): isSgAsteriskShapeExp uses table-driven castability instead of c++ default dynamic_cast
267252 : // this improves the running time performance by 10-20%.
267253 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAsteriskShapeExp*>(inputDerivedClassPointer);
267254 145 : return IS_SgAsteriskShapeExp_FAST_MACRO(inputDerivedClassPointer);
267255 : }
267256 :
267257 : // DQ (11/8/2003): Added version of functions taking const pointer
267258 0 : const SgAsteriskShapeExp* isSgAsteriskShapeExp ( const SgNode* inputDerivedClassPointer )
267259 : {
267260 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
267261 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
267262 : // So to fix this we return NULL directly when the input is NULL and avoid the
267263 : // dynamic_cast in this case. This is likely a performance improvement as well.
267264 : // return dynamic_cast<const SgAsteriskShapeExp*>(inputDerivedClassPointer);
267265 : // Milind Chabbi (8/28/2013): isSgAsteriskShapeExp uses table-driven castability instead of c++ default dynamic_cast
267266 : // this improves the running time performance by 10-20%.
267267 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAsteriskShapeExp*>(inputDerivedClassPointer);
267268 0 : return IS_SgAsteriskShapeExp_FAST_MACRO(inputDerivedClassPointer);
267269 : }
267270 :
267271 :
267272 :
267273 : /* #line 267274 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267274 :
267275 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
267276 :
267277 : /**
267278 : \brief Generated destructor
267279 :
267280 : This destructor is automatically generated (by ROSETTA). This destructor
267281 : only frees memory of data members associated with the parts of the current IR node which
267282 : are NOT traversed. Those data members that are part of a traversal can be freed using
267283 : a traversal (calling this destructor on all children in a post-order traversal). Such
267284 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
267285 :
267286 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
267287 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
267288 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
267289 :
267290 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
267291 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
267292 : pointers are not yet implemented to call delete on eash pointer in the container.
267293 : (This could be done by derivation from the STL containers to define containers that
267294 : automatically deleted their members.)
267295 :
267296 : */
267297 2 : SgAsteriskShapeExp::~SgAsteriskShapeExp () {
267298 1 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
267299 :
267300 :
267301 :
267302 : }
267303 :
267304 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
267305 2 : }
267306 :
267307 :
267308 : /* #line 267309 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267309 :
267310 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
267311 :
267312 : // Generated constructor
267313 0 : SgAsteriskShapeExp::SgAsteriskShapeExp ( Sg_File_Info* startOfConstruct )
267314 0 : : SgExpression(startOfConstruct)
267315 : {
267316 : #ifdef DEBUG
267317 : // printf ("In SgAsteriskShapeExp::SgAsteriskShapeExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
267318 : #endif
267319 : #if 0
267320 : // debugging information!
267321 : printf ("In SgAsteriskShapeExp::SgAsteriskShapeExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
267322 : #endif
267323 :
267324 :
267325 :
267326 : #if 0
267327 : // DQ (7/30/2014): Call a virtual function.
267328 : std::string s = this->class_name();
267329 : #endif
267330 :
267331 : // Test the variant virtual function
267332 : // assert(TEMP_AsteriskShapeExp == variant());
267333 0 : assert(TEMP_AsteriskShapeExp == this->variant());
267334 0 : ROSE_ASSERT(TEMP_AsteriskShapeExp == (int)(this->variantT()));
267335 0 : post_construction_initialization();
267336 :
267337 : // Test the isSgAsteriskShapeExp() function since it has been problematic
267338 0 : assert(isSgAsteriskShapeExp(this) != NULL);
267339 0 : }
267340 :
267341 : // Generated constructor (all data members)
267342 :
267343 : /* #line 267344 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267344 :
267345 :
267346 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
267347 :
267348 :
267349 : // ********************************************************
267350 : // member functions common across all array grammar objects
267351 : // ********************************************************
267352 :
267353 :
267354 :
267355 : /* #line 267356 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267356 :
267357 :
267358 :
267359 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
267360 :
267361 : // ********************************************************
267362 : // member functions specific to each node in the grammar
267363 : // ********************************************************
267364 :
267365 :
267366 : /* #line 267367 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267367 :
267368 : // Start of memberFunctionString
267369 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267370 :
267371 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267372 :
267373 : SgExpression*
267374 0 : SgImpliedDo::get_do_var_initialization () const
267375 : {
267376 0 : ROSE_ASSERT (this != NULL);
267377 :
267378 : #if 0
267379 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267380 : // used to trigger marking transformations for the token-based unparsing.
267381 : printf ("SgImpliedDo::get_do_var_initialization = %p = %s \n",this,this->class_name().c_str());
267382 : #endif
267383 :
267384 0 : return p_do_var_initialization;
267385 : }
267386 :
267387 : void
267388 0 : SgImpliedDo::set_do_var_initialization ( SgExpression* do_var_initialization )
267389 : {
267390 0 : ROSE_ASSERT (this != NULL);
267391 :
267392 : #if 0
267393 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267394 : // used to trigger marking transformations for the token-based unparsing.
267395 : printf ("SgImpliedDo::set_do_var_initialization = %p = %s \n",this,this->class_name().c_str());
267396 : #endif
267397 :
267398 0 : set_isModified(true);
267399 :
267400 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
267401 : if (p_do_var_initialization != NULL && do_var_initialization != NULL && p_do_var_initialization != do_var_initialization)
267402 : {
267403 : printf ("Warning: do_var_initialization = %p overwriting valid pointer p_do_var_initialization = %p \n",do_var_initialization,p_do_var_initialization);
267404 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
267405 : printf ("Error fails assertion (p_do_var_initialization != NULL && do_var_initialization != NULL && p_do_var_initialization != do_var_initialization) is false\n");
267406 : ROSE_ASSERT(false);
267407 : #endif
267408 : }
267409 : #endif
267410 0 : p_do_var_initialization = do_var_initialization;
267411 0 : }
267412 :
267413 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
267414 :
267415 :
267416 : // End of memberFunctionString
267417 : // Start of memberFunctionString
267418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267419 :
267420 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267421 :
267422 : SgExpression*
267423 0 : SgImpliedDo::get_last_val () const
267424 : {
267425 0 : ROSE_ASSERT (this != NULL);
267426 :
267427 : #if 0
267428 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267429 : // used to trigger marking transformations for the token-based unparsing.
267430 : printf ("SgImpliedDo::get_last_val = %p = %s \n",this,this->class_name().c_str());
267431 : #endif
267432 :
267433 0 : return p_last_val;
267434 : }
267435 :
267436 : void
267437 0 : SgImpliedDo::set_last_val ( SgExpression* last_val )
267438 : {
267439 0 : ROSE_ASSERT (this != NULL);
267440 :
267441 : #if 0
267442 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267443 : // used to trigger marking transformations for the token-based unparsing.
267444 : printf ("SgImpliedDo::set_last_val = %p = %s \n",this,this->class_name().c_str());
267445 : #endif
267446 :
267447 0 : set_isModified(true);
267448 :
267449 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
267450 : if (p_last_val != NULL && last_val != NULL && p_last_val != last_val)
267451 : {
267452 : printf ("Warning: last_val = %p overwriting valid pointer p_last_val = %p \n",last_val,p_last_val);
267453 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
267454 : printf ("Error fails assertion (p_last_val != NULL && last_val != NULL && p_last_val != last_val) is false\n");
267455 : ROSE_ASSERT(false);
267456 : #endif
267457 : }
267458 : #endif
267459 0 : p_last_val = last_val;
267460 0 : }
267461 :
267462 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
267463 :
267464 :
267465 : // End of memberFunctionString
267466 : // Start of memberFunctionString
267467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267468 :
267469 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267470 :
267471 : SgExpression*
267472 0 : SgImpliedDo::get_increment () const
267473 : {
267474 0 : ROSE_ASSERT (this != NULL);
267475 :
267476 : #if 0
267477 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267478 : // used to trigger marking transformations for the token-based unparsing.
267479 : printf ("SgImpliedDo::get_increment = %p = %s \n",this,this->class_name().c_str());
267480 : #endif
267481 :
267482 0 : return p_increment;
267483 : }
267484 :
267485 : void
267486 0 : SgImpliedDo::set_increment ( SgExpression* increment )
267487 : {
267488 0 : ROSE_ASSERT (this != NULL);
267489 :
267490 : #if 0
267491 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267492 : // used to trigger marking transformations for the token-based unparsing.
267493 : printf ("SgImpliedDo::set_increment = %p = %s \n",this,this->class_name().c_str());
267494 : #endif
267495 :
267496 0 : set_isModified(true);
267497 :
267498 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
267499 : if (p_increment != NULL && increment != NULL && p_increment != increment)
267500 : {
267501 : printf ("Warning: increment = %p overwriting valid pointer p_increment = %p \n",increment,p_increment);
267502 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
267503 : printf ("Error fails assertion (p_increment != NULL && increment != NULL && p_increment != increment) is false\n");
267504 : ROSE_ASSERT(false);
267505 : #endif
267506 : }
267507 : #endif
267508 0 : p_increment = increment;
267509 0 : }
267510 :
267511 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
267512 :
267513 :
267514 : // End of memberFunctionString
267515 : // Start of memberFunctionString
267516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267517 :
267518 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267519 :
267520 : SgExprListExp*
267521 0 : SgImpliedDo::get_object_list () const
267522 : {
267523 0 : ROSE_ASSERT (this != NULL);
267524 :
267525 : #if 0
267526 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267527 : // used to trigger marking transformations for the token-based unparsing.
267528 : printf ("SgImpliedDo::get_object_list = %p = %s \n",this,this->class_name().c_str());
267529 : #endif
267530 :
267531 0 : return p_object_list;
267532 : }
267533 :
267534 : void
267535 0 : SgImpliedDo::set_object_list ( SgExprListExp* object_list )
267536 : {
267537 0 : ROSE_ASSERT (this != NULL);
267538 :
267539 : #if 0
267540 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267541 : // used to trigger marking transformations for the token-based unparsing.
267542 : printf ("SgImpliedDo::set_object_list = %p = %s \n",this,this->class_name().c_str());
267543 : #endif
267544 :
267545 0 : set_isModified(true);
267546 :
267547 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
267548 : if (p_object_list != NULL && object_list != NULL && p_object_list != object_list)
267549 : {
267550 : printf ("Warning: object_list = %p overwriting valid pointer p_object_list = %p \n",object_list,p_object_list);
267551 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
267552 : printf ("Error fails assertion (p_object_list != NULL && object_list != NULL && p_object_list != object_list) is false\n");
267553 : ROSE_ASSERT(false);
267554 : #endif
267555 : }
267556 : #endif
267557 0 : p_object_list = object_list;
267558 0 : }
267559 :
267560 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
267561 :
267562 :
267563 : // End of memberFunctionString
267564 : // Start of memberFunctionString
267565 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267566 :
267567 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267568 :
267569 : SgScopeStatement*
267570 0 : SgImpliedDo::get_implied_do_scope () const
267571 : {
267572 0 : ROSE_ASSERT (this != NULL);
267573 :
267574 : #if 0
267575 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267576 : // used to trigger marking transformations for the token-based unparsing.
267577 : printf ("SgImpliedDo::get_implied_do_scope = %p = %s \n",this,this->class_name().c_str());
267578 : #endif
267579 :
267580 0 : return p_implied_do_scope;
267581 : }
267582 :
267583 : void
267584 0 : SgImpliedDo::set_implied_do_scope ( SgScopeStatement* implied_do_scope )
267585 : {
267586 0 : ROSE_ASSERT (this != NULL);
267587 :
267588 : #if 0
267589 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267590 : // used to trigger marking transformations for the token-based unparsing.
267591 : printf ("SgImpliedDo::set_implied_do_scope = %p = %s \n",this,this->class_name().c_str());
267592 : #endif
267593 :
267594 0 : set_isModified(true);
267595 :
267596 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
267597 : if (p_implied_do_scope != NULL && implied_do_scope != NULL && p_implied_do_scope != implied_do_scope)
267598 : {
267599 : printf ("Warning: implied_do_scope = %p overwriting valid pointer p_implied_do_scope = %p \n",implied_do_scope,p_implied_do_scope);
267600 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
267601 : printf ("Error fails assertion (p_implied_do_scope != NULL && implied_do_scope != NULL && p_implied_do_scope != implied_do_scope) is false\n");
267602 : ROSE_ASSERT(false);
267603 : #endif
267604 : }
267605 : #endif
267606 0 : p_implied_do_scope = implied_do_scope;
267607 0 : }
267608 :
267609 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
267610 :
267611 :
267612 : // End of memberFunctionString
267613 : // Start of memberFunctionString
267614 : /* #line 9031 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
267615 :
267616 :
267617 : void
267618 0 : SgImpliedDo::post_construction_initialization()
267619 0 : { }
267620 :
267621 : SgType*
267622 0 : SgImpliedDo::get_type() const
267623 : {
267624 : // printf ("In SgImpliedDo::get_type(): Not clear what this type should be (returning SgTypeDefault). \n");
267625 : // ROSE_ASSERT(false);
267626 : // return NULL;
267627 :
267628 : #if 1
267629 0 : printf ("In SgImpliedDo::get_type() \n");
267630 : #endif
267631 :
267632 0 : return SgTypeDefault::createType();
267633 : }
267634 :
267635 : #if 0
267636 : // DQ (3/20/2007): This is an older function now depricated.
267637 : int
267638 : SgImpliedDo::replace_expression(SgExpression* o, SgExpression* n)
267639 : {
267640 : if(get_object_list()==o)
267641 : {
267642 : set_object_list(isSgExprListExp(n));
267643 : return 1;
267644 : }
267645 : else
267646 : return 0;
267647 : }
267648 : #endif
267649 :
267650 :
267651 :
267652 : // End of memberFunctionString
267653 : // Start of memberFunctionString
267654 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
267655 :
267656 : // *** COMMON CODE SECTION BEGINS HERE ***
267657 :
267658 : #if 0
267659 : int
267660 : SgImpliedDo::getVariant() const
267661 : {
267662 : // This function is used in ROSE while "variant()" is used in SAGE
267663 : assert(this != NULL);
267664 : return variant();
267665 : }
267666 : #endif
267667 :
267668 : // This function is used in ROSE in treeTraversal code
267669 : // eventually replaces getVariant() and variant()
267670 : // though after variant() has been removed for a while we will
267671 : // want to change the name of variantT() back to variant()
267672 : // (since the "T" was ment to stand for temporary).
267673 : // When this happens the variantT() will be depricated.
267674 : VariantT
267675 0 : SgImpliedDo::variantT() const
267676 : {
267677 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
267678 0 : ROSE_ASSERT(this != NULL);
267679 0 : return V_SgImpliedDo;
267680 : }
267681 :
267682 : #if 0
267683 : int
267684 : SgImpliedDo::variant() const
267685 : {
267686 : // This function is used in SAGE
267687 : ROSE_ASSERT(this != NULL);
267688 : return IMPLIED_DO;
267689 : }
267690 : #endif
267691 :
267692 : ROSE_DLL_API const char*
267693 0 : SgImpliedDo::sage_class_name() const
267694 : {
267695 0 : ROSE_ASSERT(this != NULL);
267696 0 : return "SgImpliedDo";
267697 : }
267698 :
267699 : std::string
267700 0 : SgImpliedDo::class_name() const
267701 : {
267702 0 : ROSE_ASSERT(this != NULL);
267703 0 : return "SgImpliedDo";
267704 : }
267705 :
267706 : // DQ (11/26/2005): Support for visitor pattern mechanims
267707 : // (inferior to ROSE traversal mechanism, experimental).
267708 : void
267709 0 : SgImpliedDo::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
267710 : {
267711 0 : ROSE_ASSERT(this != NULL);
267712 0 : visitor.visit(this);
267713 0 : }
267714 :
267715 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
267716 0 : void SgImpliedDo::accept (ROSE_VisitorPattern & visitor) {
267717 0 : ROSE_ASSERT(this != NULL);
267718 0 : visitor.visit(this);
267719 0 : }
267720 :
267721 : SgImpliedDo*
267722 0 : SgImpliedDo::addRegExpAttribute(std::string s, AstRegExAttribute* a)
267723 : {
267724 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
267725 : // This function is currently only supported for the AST used the represent Binary executables.
267726 : if (0 /* isSgAsmNode(this) != NULL */)
267727 : {
267728 : // Support for regex specification.
267729 : std::string prefixCode = "REGEX:";
267730 : addNewAttribute(prefixCode + s,a);
267731 : }
267732 : #endif
267733 :
267734 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
267735 0 : return this;
267736 : }
267737 :
267738 : // *** COMMON CODE SECTION ENDS HERE ***
267739 :
267740 :
267741 : // End of memberFunctionString
267742 : // Start of memberFunctionString
267743 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
267744 :
267745 :
267746 : #if 0
267747 : //! Error checking support
267748 : /*! Verifies the following:
267749 : - working getVariant() member function
267750 : - calls base class's error() member function
267751 : Every class has one of these functions.
267752 : */
267753 : bool
267754 : SgImpliedDo::error()
267755 : {
267756 : // Put error checking here
267757 :
267758 : ROSE_ASSERT (this != NULL);
267759 : if (getVariant() != IMPLIED_DO)
267760 : {
267761 : printf ("Error in SgImpliedDo::error(): SgImpliedDo object has a %s variant \n",
267762 : Cxx_GrammarTerminalNames[getVariant()].name);
267763 : // printf ("Error in SgImpliedDo::error() \n");
267764 : ROSE_ABORT();
267765 : }
267766 :
267767 : ROSE_ASSERT (getVariant() == IMPLIED_DO);
267768 : return SgExpression::error();
267769 : }
267770 : #endif
267771 :
267772 :
267773 :
267774 : // End of memberFunctionString
267775 :
267776 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
267777 :
267778 0 : SgImpliedDo* isSgImpliedDo ( SgNode* inputDerivedClassPointer )
267779 : {
267780 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
267781 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
267782 : // So to fix this we return NULL directly when the input is NULL and avoid the
267783 : // dynamic_cast in this case. This is likely a performance improvement as well.
267784 : // return dynamic_cast<SgImpliedDo*>(inputDerivedClassPointer);
267785 : // Milind Chabbi (8/28/2013): isSgImpliedDo uses table-driven castability instead of c++ default dynamic_cast
267786 : // this improves the running time performance by 10-20%.
267787 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgImpliedDo*>(inputDerivedClassPointer);
267788 0 : return IS_SgImpliedDo_FAST_MACRO(inputDerivedClassPointer);
267789 : }
267790 :
267791 : // DQ (11/8/2003): Added version of functions taking const pointer
267792 0 : const SgImpliedDo* isSgImpliedDo ( const SgNode* inputDerivedClassPointer )
267793 : {
267794 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
267795 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
267796 : // So to fix this we return NULL directly when the input is NULL and avoid the
267797 : // dynamic_cast in this case. This is likely a performance improvement as well.
267798 : // return dynamic_cast<const SgImpliedDo*>(inputDerivedClassPointer);
267799 : // Milind Chabbi (8/28/2013): isSgImpliedDo uses table-driven castability instead of c++ default dynamic_cast
267800 : // this improves the running time performance by 10-20%.
267801 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgImpliedDo*>(inputDerivedClassPointer);
267802 0 : return IS_SgImpliedDo_FAST_MACRO(inputDerivedClassPointer);
267803 : }
267804 :
267805 :
267806 :
267807 : /* #line 267808 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267808 :
267809 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
267810 :
267811 : /**
267812 : \brief Generated destructor
267813 :
267814 : This destructor is automatically generated (by ROSETTA). This destructor
267815 : only frees memory of data members associated with the parts of the current IR node which
267816 : are NOT traversed. Those data members that are part of a traversal can be freed using
267817 : a traversal (calling this destructor on all children in a post-order traversal). Such
267818 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
267819 :
267820 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
267821 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
267822 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
267823 :
267824 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
267825 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
267826 : pointers are not yet implemented to call delete on eash pointer in the container.
267827 : (This could be done by derivation from the STL containers to define containers that
267828 : automatically deleted their members.)
267829 :
267830 : */
267831 0 : SgImpliedDo::~SgImpliedDo () {
267832 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
267833 :
267834 :
267835 : // case: not a listType for do_var_initialization
267836 0 : p_do_var_initialization = NULL; // non list case
267837 : // case: not a listType for last_val
267838 0 : p_last_val = NULL; // non list case
267839 : // case: not a listType for increment
267840 0 : p_increment = NULL; // non list case
267841 : // case: not a listType for object_list
267842 0 : p_object_list = NULL; // non list case
267843 : // case: not a listType for implied_do_scope
267844 0 : p_implied_do_scope = NULL; // non list case
267845 :
267846 : }
267847 :
267848 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
267849 0 : }
267850 :
267851 :
267852 : /* #line 267853 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267853 :
267854 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
267855 :
267856 : // Generated constructor
267857 0 : SgImpliedDo::SgImpliedDo ( Sg_File_Info* startOfConstruct, SgExpression* do_var_initialization, SgExpression* last_val, SgExpression* increment, SgExprListExp* object_list, SgScopeStatement* implied_do_scope )
267858 0 : : SgExpression(startOfConstruct)
267859 : {
267860 : #ifdef DEBUG
267861 : // printf ("In SgImpliedDo::SgImpliedDo (Sg_File_Info* startOfConstruct, SgExpression* do_var_initialization, SgExpression* last_val, SgExpression* increment, SgExprListExp* object_list, SgScopeStatement* implied_do_scope) sage_class_name() = %s \n",sage_class_name());
267862 : #endif
267863 : #if 0
267864 : // debugging information!
267865 : printf ("In SgImpliedDo::SgImpliedDo (Sg_File_Info* startOfConstruct, SgExpression* do_var_initialization, SgExpression* last_val, SgExpression* increment, SgExprListExp* object_list, SgScopeStatement* implied_do_scope): this = %p = %s \n",this,this->class_name().c_str());
267866 : #endif
267867 :
267868 0 : p_do_var_initialization = do_var_initialization;
267869 0 : p_last_val = last_val;
267870 0 : p_increment = increment;
267871 0 : p_object_list = object_list;
267872 0 : p_implied_do_scope = implied_do_scope;
267873 :
267874 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
267875 :
267876 : #if 0
267877 : // DQ (7/30/2014): Call a virtual function.
267878 : std::string s = this->class_name();
267879 : #endif
267880 :
267881 : // Test the variant virtual function
267882 : // assert(IMPLIED_DO == variant());
267883 0 : assert(IMPLIED_DO == this->variant());
267884 0 : ROSE_ASSERT(IMPLIED_DO == (int)(this->variantT()));
267885 0 : post_construction_initialization();
267886 :
267887 : // Test the isSgImpliedDo() function since it has been problematic
267888 0 : assert(isSgImpliedDo(this) != NULL);
267889 0 : }
267890 :
267891 : // Generated constructor (all data members)
267892 :
267893 : /* #line 267894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267894 :
267895 :
267896 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
267897 :
267898 :
267899 : // ********************************************************
267900 : // member functions common across all array grammar objects
267901 : // ********************************************************
267902 :
267903 :
267904 :
267905 : /* #line 267906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267906 :
267907 :
267908 :
267909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
267910 :
267911 : // ********************************************************
267912 : // member functions specific to each node in the grammar
267913 : // ********************************************************
267914 :
267915 :
267916 : /* #line 267917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
267917 :
267918 : // Start of memberFunctionString
267919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267920 :
267921 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267922 :
267923 : SgName
267924 0 : SgIOItemExpression::get_name () const
267925 : {
267926 0 : ROSE_ASSERT (this != NULL);
267927 :
267928 : #if 0
267929 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267930 : // used to trigger marking transformations for the token-based unparsing.
267931 : printf ("SgIOItemExpression::get_name = %p = %s \n",this,this->class_name().c_str());
267932 : #endif
267933 :
267934 0 : return p_name;
267935 : }
267936 :
267937 : void
267938 0 : SgIOItemExpression::set_name ( SgName name )
267939 : {
267940 0 : ROSE_ASSERT (this != NULL);
267941 :
267942 : #if 0
267943 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267944 : // used to trigger marking transformations for the token-based unparsing.
267945 : printf ("SgIOItemExpression::set_name = %p = %s \n",this,this->class_name().c_str());
267946 : #endif
267947 :
267948 0 : set_isModified(true);
267949 :
267950 0 : p_name = name;
267951 0 : }
267952 :
267953 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
267954 :
267955 :
267956 : // End of memberFunctionString
267957 : // Start of memberFunctionString
267958 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
267959 :
267960 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
267961 :
267962 : SgExpression*
267963 0 : SgIOItemExpression::get_io_item () const
267964 : {
267965 0 : ROSE_ASSERT (this != NULL);
267966 :
267967 : #if 0
267968 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267969 : // used to trigger marking transformations for the token-based unparsing.
267970 : printf ("SgIOItemExpression::get_io_item = %p = %s \n",this,this->class_name().c_str());
267971 : #endif
267972 :
267973 0 : return p_io_item;
267974 : }
267975 :
267976 : void
267977 0 : SgIOItemExpression::set_io_item ( SgExpression* io_item )
267978 : {
267979 0 : ROSE_ASSERT (this != NULL);
267980 :
267981 : #if 0
267982 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
267983 : // used to trigger marking transformations for the token-based unparsing.
267984 : printf ("SgIOItemExpression::set_io_item = %p = %s \n",this,this->class_name().c_str());
267985 : #endif
267986 :
267987 0 : set_isModified(true);
267988 :
267989 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
267990 : if (p_io_item != NULL && io_item != NULL && p_io_item != io_item)
267991 : {
267992 : printf ("Warning: io_item = %p overwriting valid pointer p_io_item = %p \n",io_item,p_io_item);
267993 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
267994 : printf ("Error fails assertion (p_io_item != NULL && io_item != NULL && p_io_item != io_item) is false\n");
267995 : ROSE_ASSERT(false);
267996 : #endif
267997 : }
267998 : #endif
267999 0 : p_io_item = io_item;
268000 0 : }
268001 :
268002 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268003 :
268004 :
268005 : // End of memberFunctionString
268006 : // Start of memberFunctionString
268007 : /* #line 8998 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
268008 :
268009 :
268010 : void
268011 0 : SgIOItemExpression::post_construction_initialization()
268012 0 : { }
268013 :
268014 : SgType*
268015 0 : SgIOItemExpression::get_type() const
268016 : {
268017 0 : printf ("In SgIOItemExpression::get_type(): Not clear what this type should be. \n");
268018 0 : ROSE_ASSERT(false);
268019 :
268020 : return NULL;
268021 : }
268022 :
268023 : #if 0
268024 : // DQ (3/20/2007): This is an older function now depricated.
268025 : int
268026 : SgIOItemExpression::replace_expression(SgExpression* o, SgExpression* n)
268027 : {
268028 : if(get_io_item()==o)
268029 : {
268030 : set_io_item(n);
268031 : return 1;
268032 : }
268033 : else
268034 : return 0;
268035 : }
268036 : #endif
268037 :
268038 :
268039 :
268040 : // End of memberFunctionString
268041 : // Start of memberFunctionString
268042 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
268043 :
268044 : // *** COMMON CODE SECTION BEGINS HERE ***
268045 :
268046 : #if 0
268047 : int
268048 : SgIOItemExpression::getVariant() const
268049 : {
268050 : // This function is used in ROSE while "variant()" is used in SAGE
268051 : assert(this != NULL);
268052 : return variant();
268053 : }
268054 : #endif
268055 :
268056 : // This function is used in ROSE in treeTraversal code
268057 : // eventually replaces getVariant() and variant()
268058 : // though after variant() has been removed for a while we will
268059 : // want to change the name of variantT() back to variant()
268060 : // (since the "T" was ment to stand for temporary).
268061 : // When this happens the variantT() will be depricated.
268062 : VariantT
268063 0 : SgIOItemExpression::variantT() const
268064 : {
268065 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
268066 0 : ROSE_ASSERT(this != NULL);
268067 0 : return V_SgIOItemExpression;
268068 : }
268069 :
268070 : #if 0
268071 : int
268072 : SgIOItemExpression::variant() const
268073 : {
268074 : // This function is used in SAGE
268075 : ROSE_ASSERT(this != NULL);
268076 : return IO_ITEM_EXPR;
268077 : }
268078 : #endif
268079 :
268080 : ROSE_DLL_API const char*
268081 0 : SgIOItemExpression::sage_class_name() const
268082 : {
268083 0 : ROSE_ASSERT(this != NULL);
268084 0 : return "SgIOItemExpression";
268085 : }
268086 :
268087 : std::string
268088 0 : SgIOItemExpression::class_name() const
268089 : {
268090 0 : ROSE_ASSERT(this != NULL);
268091 0 : return "SgIOItemExpression";
268092 : }
268093 :
268094 : // DQ (11/26/2005): Support for visitor pattern mechanims
268095 : // (inferior to ROSE traversal mechanism, experimental).
268096 : void
268097 0 : SgIOItemExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
268098 : {
268099 0 : ROSE_ASSERT(this != NULL);
268100 0 : visitor.visit(this);
268101 0 : }
268102 :
268103 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
268104 0 : void SgIOItemExpression::accept (ROSE_VisitorPattern & visitor) {
268105 0 : ROSE_ASSERT(this != NULL);
268106 0 : visitor.visit(this);
268107 0 : }
268108 :
268109 : SgIOItemExpression*
268110 0 : SgIOItemExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
268111 : {
268112 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
268113 : // This function is currently only supported for the AST used the represent Binary executables.
268114 : if (0 /* isSgAsmNode(this) != NULL */)
268115 : {
268116 : // Support for regex specification.
268117 : std::string prefixCode = "REGEX:";
268118 : addNewAttribute(prefixCode + s,a);
268119 : }
268120 : #endif
268121 :
268122 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
268123 0 : return this;
268124 : }
268125 :
268126 : // *** COMMON CODE SECTION ENDS HERE ***
268127 :
268128 :
268129 : // End of memberFunctionString
268130 : // Start of memberFunctionString
268131 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
268132 :
268133 :
268134 : #if 0
268135 : //! Error checking support
268136 : /*! Verifies the following:
268137 : - working getVariant() member function
268138 : - calls base class's error() member function
268139 : Every class has one of these functions.
268140 : */
268141 : bool
268142 : SgIOItemExpression::error()
268143 : {
268144 : // Put error checking here
268145 :
268146 : ROSE_ASSERT (this != NULL);
268147 : if (getVariant() != IO_ITEM_EXPR)
268148 : {
268149 : printf ("Error in SgIOItemExpression::error(): SgIOItemExpression object has a %s variant \n",
268150 : Cxx_GrammarTerminalNames[getVariant()].name);
268151 : // printf ("Error in SgIOItemExpression::error() \n");
268152 : ROSE_ABORT();
268153 : }
268154 :
268155 : ROSE_ASSERT (getVariant() == IO_ITEM_EXPR);
268156 : return SgExpression::error();
268157 : }
268158 : #endif
268159 :
268160 :
268161 :
268162 : // End of memberFunctionString
268163 :
268164 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
268165 :
268166 0 : SgIOItemExpression* isSgIOItemExpression ( SgNode* inputDerivedClassPointer )
268167 : {
268168 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
268169 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
268170 : // So to fix this we return NULL directly when the input is NULL and avoid the
268171 : // dynamic_cast in this case. This is likely a performance improvement as well.
268172 : // return dynamic_cast<SgIOItemExpression*>(inputDerivedClassPointer);
268173 : // Milind Chabbi (8/28/2013): isSgIOItemExpression uses table-driven castability instead of c++ default dynamic_cast
268174 : // this improves the running time performance by 10-20%.
268175 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIOItemExpression*>(inputDerivedClassPointer);
268176 0 : return IS_SgIOItemExpression_FAST_MACRO(inputDerivedClassPointer);
268177 : }
268178 :
268179 : // DQ (11/8/2003): Added version of functions taking const pointer
268180 0 : const SgIOItemExpression* isSgIOItemExpression ( const SgNode* inputDerivedClassPointer )
268181 : {
268182 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
268183 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
268184 : // So to fix this we return NULL directly when the input is NULL and avoid the
268185 : // dynamic_cast in this case. This is likely a performance improvement as well.
268186 : // return dynamic_cast<const SgIOItemExpression*>(inputDerivedClassPointer);
268187 : // Milind Chabbi (8/28/2013): isSgIOItemExpression uses table-driven castability instead of c++ default dynamic_cast
268188 : // this improves the running time performance by 10-20%.
268189 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIOItemExpression*>(inputDerivedClassPointer);
268190 0 : return IS_SgIOItemExpression_FAST_MACRO(inputDerivedClassPointer);
268191 : }
268192 :
268193 :
268194 :
268195 : /* #line 268196 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268196 :
268197 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
268198 :
268199 : /**
268200 : \brief Generated destructor
268201 :
268202 : This destructor is automatically generated (by ROSETTA). This destructor
268203 : only frees memory of data members associated with the parts of the current IR node which
268204 : are NOT traversed. Those data members that are part of a traversal can be freed using
268205 : a traversal (calling this destructor on all children in a post-order traversal). Such
268206 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
268207 :
268208 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
268209 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
268210 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
268211 :
268212 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
268213 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
268214 : pointers are not yet implemented to call delete on eash pointer in the container.
268215 : (This could be done by derivation from the STL containers to define containers that
268216 : automatically deleted their members.)
268217 :
268218 : */
268219 0 : SgIOItemExpression::~SgIOItemExpression () {
268220 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
268221 :
268222 :
268223 : // case: not a listType for name
268224 0 : p_name = ""; // non list case
268225 : // case: not a listType for io_item
268226 0 : p_io_item = NULL; // non list case
268227 :
268228 : }
268229 :
268230 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
268231 0 : }
268232 :
268233 :
268234 : /* #line 268235 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268235 :
268236 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
268237 :
268238 : // Generated constructor
268239 0 : SgIOItemExpression::SgIOItemExpression ( Sg_File_Info* startOfConstruct, SgName name, SgExpression* io_item )
268240 0 : : SgExpression(startOfConstruct)
268241 : {
268242 : #ifdef DEBUG
268243 : // printf ("In SgIOItemExpression::SgIOItemExpression (Sg_File_Info* startOfConstruct, SgName name, SgExpression* io_item) sage_class_name() = %s \n",sage_class_name());
268244 : #endif
268245 : #if 0
268246 : // debugging information!
268247 : printf ("In SgIOItemExpression::SgIOItemExpression (Sg_File_Info* startOfConstruct, SgName name, SgExpression* io_item): this = %p = %s \n",this,this->class_name().c_str());
268248 : #endif
268249 :
268250 0 : p_name = name;
268251 0 : p_io_item = io_item;
268252 :
268253 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
268254 :
268255 : #if 0
268256 : // DQ (7/30/2014): Call a virtual function.
268257 : std::string s = this->class_name();
268258 : #endif
268259 :
268260 : // Test the variant virtual function
268261 : // assert(IO_ITEM_EXPR == variant());
268262 0 : assert(IO_ITEM_EXPR == this->variant());
268263 0 : ROSE_ASSERT(IO_ITEM_EXPR == (int)(this->variantT()));
268264 0 : post_construction_initialization();
268265 :
268266 : // Test the isSgIOItemExpression() function since it has been problematic
268267 0 : assert(isSgIOItemExpression(this) != NULL);
268268 0 : }
268269 :
268270 : // Generated constructor (all data members)
268271 :
268272 : /* #line 268273 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268273 :
268274 :
268275 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
268276 :
268277 :
268278 : // ********************************************************
268279 : // member functions common across all array grammar objects
268280 : // ********************************************************
268281 :
268282 :
268283 :
268284 : /* #line 268285 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268285 :
268286 :
268287 :
268288 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
268289 :
268290 : // ********************************************************
268291 : // member functions specific to each node in the grammar
268292 : // ********************************************************
268293 :
268294 :
268295 : /* #line 268296 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268296 :
268297 : // Start of memberFunctionString
268298 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
268299 :
268300 : void
268301 59 : SgStatementExpression::post_construction_initialization()
268302 : {
268303 59 : }
268304 :
268305 :
268306 :
268307 : // End of memberFunctionString
268308 : // Start of memberFunctionString
268309 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268310 :
268311 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268312 :
268313 : SgStatement*
268314 118 : SgStatementExpression::get_statement () const
268315 : {
268316 118 : ROSE_ASSERT (this != NULL);
268317 :
268318 : #if 0
268319 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268320 : // used to trigger marking transformations for the token-based unparsing.
268321 : printf ("SgStatementExpression::get_statement = %p = %s \n",this,this->class_name().c_str());
268322 : #endif
268323 :
268324 118 : return p_statement;
268325 : }
268326 :
268327 : void
268328 0 : SgStatementExpression::set_statement ( SgStatement* statement )
268329 : {
268330 0 : ROSE_ASSERT (this != NULL);
268331 :
268332 : #if 0
268333 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268334 : // used to trigger marking transformations for the token-based unparsing.
268335 : printf ("SgStatementExpression::set_statement = %p = %s \n",this,this->class_name().c_str());
268336 : #endif
268337 :
268338 0 : set_isModified(true);
268339 :
268340 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
268341 : if (p_statement != NULL && statement != NULL && p_statement != statement)
268342 : {
268343 : printf ("Warning: statement = %p overwriting valid pointer p_statement = %p \n",statement,p_statement);
268344 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
268345 : printf ("Error fails assertion (p_statement != NULL && statement != NULL && p_statement != statement) is false\n");
268346 : ROSE_ASSERT(false);
268347 : #endif
268348 : }
268349 : #endif
268350 0 : p_statement = statement;
268351 0 : }
268352 :
268353 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268354 :
268355 :
268356 : // End of memberFunctionString
268357 : // Start of memberFunctionString
268358 : /* #line 8533 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
268359 :
268360 : SgType*
268361 118 : SgStatementExpression::get_type() const
268362 : {
268363 118 : SgType* returnType = NULL;
268364 :
268365 118 : ROSE_ASSERT(p_statement != NULL);
268366 :
268367 : // DQ (7/21/2006): For now we implement this partially and fix it up later.
268368 : // We might want to store the type explicitly since it might be difficult
268369 : // to compute for complex sequences of statements. It appears that the
268370 : // type is just the type of the expression in the last statement of the block,
268371 : // but it is not clear if it can be more complex than this!
268372 :
268373 : // The rules are: The last thing in the compound statement should be an expression
268374 : // followed by a semicolon; the value of this subexpression serves as the value of
268375 : // the entire construct. (If you use some other kind of statement last within the
268376 : // braces, the construct has type void, and thus effectively no value.).
268377 :
268378 : // printf ("SgStatementExpression::get_type() for GNU Statement Expression extension not implemented p_statement = %p = %s \n",p_statement,p_statement->class_name().c_str());
268379 : // ROSE_ASSERT(false);
268380 :
268381 : // This is the default case (we can look at the last statement of the block later)
268382 : // returnType = SgTypeVoid::createType();
268383 :
268384 : #if 0
268385 : printf ("In SgStatementExpression::get_type() \n");
268386 : #endif
268387 :
268388 : // DQ (8/6/2006): The rules for the type of a statement expression are that it is the
268389 : // type of the last expression in the statement list or void if the last statement is
268390 : // not an expression (expression statement, SgExpressionStatement).
268391 118 : SgBasicBlock* block = isSgBasicBlock(p_statement);
268392 118 : ROSE_ASSERT(block != NULL);
268393 :
268394 118 : SgStatementPtrList & statementList = block->getStatementList();
268395 :
268396 : // DQ (4/8/2015): Empty statement expressions have to be allowed.
268397 : // ROSE_ASSERT(statementList.empty() == false);
268398 118 : if (statementList.empty() == true)
268399 : {
268400 : // DQ (4/8/2015): After discusion, this might be better setup as a SgTypeUnknown instead of SgTypeVoid.
268401 0 : returnType = SgTypeVoid::createType();
268402 : }
268403 : else
268404 : {
268405 118 : SgStatement* lastStatement = *(statementList.rbegin());
268406 118 : SgExprStatement* expressionStatement = isSgExprStatement(lastStatement);
268407 118 : if (expressionStatement != NULL)
268408 : {
268409 : // The type of the statement expression is the
268410 : // SgExpression* expression = expressionStatement->get_the_expr();
268411 0 : SgExpression* expression = expressionStatement->get_expression();
268412 0 : ROSE_ASSERT(expression != NULL);
268413 0 : returnType = expression->get_type();
268414 : }
268415 : else
268416 : {
268417 : // This is the default type if last statement in block is not an expression statement (C++ standard)
268418 118 : returnType = SgTypeVoid::createType();
268419 : }
268420 : }
268421 :
268422 118 : ROSE_ASSERT(returnType != NULL);
268423 :
268424 : // printf ("SgStatementExpression::get_type() for GNU Statement Expression extension returnType = %s \n",returnType->class_name().c_str());
268425 :
268426 118 : return returnType;
268427 : }
268428 :
268429 :
268430 :
268431 : // End of memberFunctionString
268432 : // Start of memberFunctionString
268433 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
268434 :
268435 : // *** COMMON CODE SECTION BEGINS HERE ***
268436 :
268437 : #if 0
268438 : int
268439 : SgStatementExpression::getVariant() const
268440 : {
268441 : // This function is used in ROSE while "variant()" is used in SAGE
268442 : assert(this != NULL);
268443 : return variant();
268444 : }
268445 : #endif
268446 :
268447 : // This function is used in ROSE in treeTraversal code
268448 : // eventually replaces getVariant() and variant()
268449 : // though after variant() has been removed for a while we will
268450 : // want to change the name of variantT() back to variant()
268451 : // (since the "T" was ment to stand for temporary).
268452 : // When this happens the variantT() will be depricated.
268453 : VariantT
268454 9573 : SgStatementExpression::variantT() const
268455 : {
268456 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
268457 9573 : ROSE_ASSERT(this != NULL);
268458 9573 : return V_SgStatementExpression;
268459 : }
268460 :
268461 : #if 0
268462 : int
268463 : SgStatementExpression::variant() const
268464 : {
268465 : // This function is used in SAGE
268466 : ROSE_ASSERT(this != NULL);
268467 : return STMT_EXPR;
268468 : }
268469 : #endif
268470 :
268471 : ROSE_DLL_API const char*
268472 0 : SgStatementExpression::sage_class_name() const
268473 : {
268474 0 : ROSE_ASSERT(this != NULL);
268475 0 : return "SgStatementExpression";
268476 : }
268477 :
268478 : std::string
268479 59 : SgStatementExpression::class_name() const
268480 : {
268481 59 : ROSE_ASSERT(this != NULL);
268482 59 : return "SgStatementExpression";
268483 : }
268484 :
268485 : // DQ (11/26/2005): Support for visitor pattern mechanims
268486 : // (inferior to ROSE traversal mechanism, experimental).
268487 : void
268488 0 : SgStatementExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
268489 : {
268490 0 : ROSE_ASSERT(this != NULL);
268491 0 : visitor.visit(this);
268492 0 : }
268493 :
268494 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
268495 0 : void SgStatementExpression::accept (ROSE_VisitorPattern & visitor) {
268496 0 : ROSE_ASSERT(this != NULL);
268497 0 : visitor.visit(this);
268498 0 : }
268499 :
268500 : SgStatementExpression*
268501 0 : SgStatementExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
268502 : {
268503 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
268504 : // This function is currently only supported for the AST used the represent Binary executables.
268505 : if (0 /* isSgAsmNode(this) != NULL */)
268506 : {
268507 : // Support for regex specification.
268508 : std::string prefixCode = "REGEX:";
268509 : addNewAttribute(prefixCode + s,a);
268510 : }
268511 : #endif
268512 :
268513 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
268514 0 : return this;
268515 : }
268516 :
268517 : // *** COMMON CODE SECTION ENDS HERE ***
268518 :
268519 :
268520 : // End of memberFunctionString
268521 : // Start of memberFunctionString
268522 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
268523 :
268524 :
268525 : #if 0
268526 : //! Error checking support
268527 : /*! Verifies the following:
268528 : - working getVariant() member function
268529 : - calls base class's error() member function
268530 : Every class has one of these functions.
268531 : */
268532 : bool
268533 : SgStatementExpression::error()
268534 : {
268535 : // Put error checking here
268536 :
268537 : ROSE_ASSERT (this != NULL);
268538 : if (getVariant() != STMT_EXPR)
268539 : {
268540 : printf ("Error in SgStatementExpression::error(): SgStatementExpression object has a %s variant \n",
268541 : Cxx_GrammarTerminalNames[getVariant()].name);
268542 : // printf ("Error in SgStatementExpression::error() \n");
268543 : ROSE_ABORT();
268544 : }
268545 :
268546 : ROSE_ASSERT (getVariant() == STMT_EXPR);
268547 : return SgExpression::error();
268548 : }
268549 : #endif
268550 :
268551 :
268552 :
268553 : // End of memberFunctionString
268554 :
268555 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
268556 :
268557 1551 : SgStatementExpression* isSgStatementExpression ( SgNode* inputDerivedClassPointer )
268558 : {
268559 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
268560 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
268561 : // So to fix this we return NULL directly when the input is NULL and avoid the
268562 : // dynamic_cast in this case. This is likely a performance improvement as well.
268563 : // return dynamic_cast<SgStatementExpression*>(inputDerivedClassPointer);
268564 : // Milind Chabbi (8/28/2013): isSgStatementExpression uses table-driven castability instead of c++ default dynamic_cast
268565 : // this improves the running time performance by 10-20%.
268566 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStatementExpression*>(inputDerivedClassPointer);
268567 1551 : return IS_SgStatementExpression_FAST_MACRO(inputDerivedClassPointer);
268568 : }
268569 :
268570 : // DQ (11/8/2003): Added version of functions taking const pointer
268571 0 : const SgStatementExpression* isSgStatementExpression ( const SgNode* inputDerivedClassPointer )
268572 : {
268573 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
268574 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
268575 : // So to fix this we return NULL directly when the input is NULL and avoid the
268576 : // dynamic_cast in this case. This is likely a performance improvement as well.
268577 : // return dynamic_cast<const SgStatementExpression*>(inputDerivedClassPointer);
268578 : // Milind Chabbi (8/28/2013): isSgStatementExpression uses table-driven castability instead of c++ default dynamic_cast
268579 : // this improves the running time performance by 10-20%.
268580 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStatementExpression*>(inputDerivedClassPointer);
268581 0 : return IS_SgStatementExpression_FAST_MACRO(inputDerivedClassPointer);
268582 : }
268583 :
268584 :
268585 :
268586 : /* #line 268587 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268587 :
268588 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
268589 :
268590 : /**
268591 : \brief Generated destructor
268592 :
268593 : This destructor is automatically generated (by ROSETTA). This destructor
268594 : only frees memory of data members associated with the parts of the current IR node which
268595 : are NOT traversed. Those data members that are part of a traversal can be freed using
268596 : a traversal (calling this destructor on all children in a post-order traversal). Such
268597 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
268598 :
268599 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
268600 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
268601 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
268602 :
268603 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
268604 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
268605 : pointers are not yet implemented to call delete on eash pointer in the container.
268606 : (This could be done by derivation from the STL containers to define containers that
268607 : automatically deleted their members.)
268608 :
268609 : */
268610 0 : SgStatementExpression::~SgStatementExpression () {
268611 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
268612 :
268613 :
268614 : // case: not a listType for statement
268615 0 : p_statement = NULL; // non list case
268616 :
268617 : }
268618 :
268619 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
268620 0 : }
268621 :
268622 :
268623 : /* #line 268624 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268624 :
268625 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
268626 :
268627 : // Generated constructor
268628 0 : SgStatementExpression::SgStatementExpression ( Sg_File_Info* startOfConstruct, SgStatement* statement )
268629 0 : : SgExpression(startOfConstruct)
268630 : {
268631 : #ifdef DEBUG
268632 : // printf ("In SgStatementExpression::SgStatementExpression (Sg_File_Info* startOfConstruct, SgStatement* statement) sage_class_name() = %s \n",sage_class_name());
268633 : #endif
268634 : #if 0
268635 : // debugging information!
268636 : printf ("In SgStatementExpression::SgStatementExpression (Sg_File_Info* startOfConstruct, SgStatement* statement): this = %p = %s \n",this,this->class_name().c_str());
268637 : #endif
268638 :
268639 0 : p_statement = statement;
268640 :
268641 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
268642 :
268643 : #if 0
268644 : // DQ (7/30/2014): Call a virtual function.
268645 : std::string s = this->class_name();
268646 : #endif
268647 :
268648 : // Test the variant virtual function
268649 : // assert(STMT_EXPR == variant());
268650 0 : assert(STMT_EXPR == this->variant());
268651 0 : ROSE_ASSERT(STMT_EXPR == (int)(this->variantT()));
268652 0 : post_construction_initialization();
268653 :
268654 : // Test the isSgStatementExpression() function since it has been problematic
268655 0 : assert(isSgStatementExpression(this) != NULL);
268656 0 : }
268657 :
268658 : // Generated constructor (all data members)
268659 :
268660 : /* #line 268661 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268661 :
268662 :
268663 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
268664 :
268665 :
268666 : // ********************************************************
268667 : // member functions common across all array grammar objects
268668 : // ********************************************************
268669 :
268670 :
268671 :
268672 : /* #line 268673 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268673 :
268674 :
268675 :
268676 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
268677 :
268678 : // ********************************************************
268679 : // member functions specific to each node in the grammar
268680 : // ********************************************************
268681 :
268682 :
268683 : /* #line 268684 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
268684 :
268685 : // Start of memberFunctionString
268686 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
268687 :
268688 : void
268689 0 : SgAsmOp::post_construction_initialization()
268690 : {
268691 0 : }
268692 :
268693 :
268694 :
268695 : // End of memberFunctionString
268696 : // Start of memberFunctionString
268697 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268698 :
268699 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268700 :
268701 : SgAsmOp::asm_operand_constraint_enum
268702 0 : SgAsmOp::get_constraint () const
268703 : {
268704 0 : ROSE_ASSERT (this != NULL);
268705 :
268706 : #if 0
268707 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268708 : // used to trigger marking transformations for the token-based unparsing.
268709 : printf ("SgAsmOp::get_constraint = %p = %s \n",this,this->class_name().c_str());
268710 : #endif
268711 :
268712 0 : return p_constraint;
268713 : }
268714 :
268715 : void
268716 0 : SgAsmOp::set_constraint ( SgAsmOp::asm_operand_constraint_enum constraint )
268717 : {
268718 0 : ROSE_ASSERT (this != NULL);
268719 :
268720 : #if 0
268721 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268722 : // used to trigger marking transformations for the token-based unparsing.
268723 : printf ("SgAsmOp::set_constraint = %p = %s \n",this,this->class_name().c_str());
268724 : #endif
268725 :
268726 0 : set_isModified(true);
268727 :
268728 0 : p_constraint = constraint;
268729 0 : }
268730 :
268731 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268732 :
268733 :
268734 : // End of memberFunctionString
268735 : // Start of memberFunctionString
268736 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268737 :
268738 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268739 :
268740 : SgAsmOp::asm_operand_modifier_enum
268741 0 : SgAsmOp::get_modifiers () const
268742 : {
268743 0 : ROSE_ASSERT (this != NULL);
268744 :
268745 : #if 0
268746 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268747 : // used to trigger marking transformations for the token-based unparsing.
268748 : printf ("SgAsmOp::get_modifiers = %p = %s \n",this,this->class_name().c_str());
268749 : #endif
268750 :
268751 0 : return p_modifiers;
268752 : }
268753 :
268754 : void
268755 0 : SgAsmOp::set_modifiers ( SgAsmOp::asm_operand_modifier_enum modifiers )
268756 : {
268757 0 : ROSE_ASSERT (this != NULL);
268758 :
268759 : #if 0
268760 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268761 : // used to trigger marking transformations for the token-based unparsing.
268762 : printf ("SgAsmOp::set_modifiers = %p = %s \n",this,this->class_name().c_str());
268763 : #endif
268764 :
268765 0 : set_isModified(true);
268766 :
268767 0 : p_modifiers = modifiers;
268768 0 : }
268769 :
268770 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268771 :
268772 :
268773 : // End of memberFunctionString
268774 : // Start of memberFunctionString
268775 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268776 :
268777 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268778 :
268779 : SgExpression*
268780 0 : SgAsmOp::get_expression () const
268781 : {
268782 0 : ROSE_ASSERT (this != NULL);
268783 :
268784 : #if 0
268785 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268786 : // used to trigger marking transformations for the token-based unparsing.
268787 : printf ("SgAsmOp::get_expression = %p = %s \n",this,this->class_name().c_str());
268788 : #endif
268789 :
268790 0 : return p_expression;
268791 : }
268792 :
268793 : void
268794 0 : SgAsmOp::set_expression ( SgExpression* expression )
268795 : {
268796 0 : ROSE_ASSERT (this != NULL);
268797 :
268798 : #if 0
268799 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268800 : // used to trigger marking transformations for the token-based unparsing.
268801 : printf ("SgAsmOp::set_expression = %p = %s \n",this,this->class_name().c_str());
268802 : #endif
268803 :
268804 0 : set_isModified(true);
268805 :
268806 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
268807 : if (p_expression != NULL && expression != NULL && p_expression != expression)
268808 : {
268809 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
268810 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
268811 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
268812 : ROSE_ASSERT(false);
268813 : #endif
268814 : }
268815 : #endif
268816 0 : p_expression = expression;
268817 0 : }
268818 :
268819 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268820 :
268821 :
268822 : // End of memberFunctionString
268823 : // Start of memberFunctionString
268824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268825 :
268826 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268827 :
268828 : bool
268829 0 : SgAsmOp::get_recordRawAsmOperandDescriptions () const
268830 : {
268831 0 : ROSE_ASSERT (this != NULL);
268832 :
268833 : #if 0
268834 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268835 : // used to trigger marking transformations for the token-based unparsing.
268836 : printf ("SgAsmOp::get_recordRawAsmOperandDescriptions = %p = %s \n",this,this->class_name().c_str());
268837 : #endif
268838 :
268839 0 : return p_recordRawAsmOperandDescriptions;
268840 : }
268841 :
268842 : void
268843 0 : SgAsmOp::set_recordRawAsmOperandDescriptions ( bool recordRawAsmOperandDescriptions )
268844 : {
268845 0 : ROSE_ASSERT (this != NULL);
268846 :
268847 : #if 0
268848 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268849 : // used to trigger marking transformations for the token-based unparsing.
268850 : printf ("SgAsmOp::set_recordRawAsmOperandDescriptions = %p = %s \n",this,this->class_name().c_str());
268851 : #endif
268852 :
268853 0 : set_isModified(true);
268854 :
268855 0 : p_recordRawAsmOperandDescriptions = recordRawAsmOperandDescriptions;
268856 0 : }
268857 :
268858 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268859 :
268860 :
268861 : // End of memberFunctionString
268862 : // Start of memberFunctionString
268863 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268864 :
268865 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268866 :
268867 : bool
268868 0 : SgAsmOp::get_isOutputOperand () const
268869 : {
268870 0 : ROSE_ASSERT (this != NULL);
268871 :
268872 : #if 0
268873 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268874 : // used to trigger marking transformations for the token-based unparsing.
268875 : printf ("SgAsmOp::get_isOutputOperand = %p = %s \n",this,this->class_name().c_str());
268876 : #endif
268877 :
268878 0 : return p_isOutputOperand;
268879 : }
268880 :
268881 : void
268882 0 : SgAsmOp::set_isOutputOperand ( bool isOutputOperand )
268883 : {
268884 0 : ROSE_ASSERT (this != NULL);
268885 :
268886 : #if 0
268887 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268888 : // used to trigger marking transformations for the token-based unparsing.
268889 : printf ("SgAsmOp::set_isOutputOperand = %p = %s \n",this,this->class_name().c_str());
268890 : #endif
268891 :
268892 0 : set_isModified(true);
268893 :
268894 0 : p_isOutputOperand = isOutputOperand;
268895 0 : }
268896 :
268897 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268898 :
268899 :
268900 : // End of memberFunctionString
268901 : // Start of memberFunctionString
268902 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268903 :
268904 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268905 :
268906 : std::string
268907 0 : SgAsmOp::get_constraintString () const
268908 : {
268909 0 : ROSE_ASSERT (this != NULL);
268910 :
268911 : #if 0
268912 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268913 : // used to trigger marking transformations for the token-based unparsing.
268914 : printf ("SgAsmOp::get_constraintString = %p = %s \n",this,this->class_name().c_str());
268915 : #endif
268916 :
268917 0 : return p_constraintString;
268918 : }
268919 :
268920 : void
268921 0 : SgAsmOp::set_constraintString ( std::string constraintString )
268922 : {
268923 0 : ROSE_ASSERT (this != NULL);
268924 :
268925 : #if 0
268926 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268927 : // used to trigger marking transformations for the token-based unparsing.
268928 : printf ("SgAsmOp::set_constraintString = %p = %s \n",this,this->class_name().c_str());
268929 : #endif
268930 :
268931 0 : set_isModified(true);
268932 :
268933 0 : p_constraintString = constraintString;
268934 0 : }
268935 :
268936 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268937 :
268938 :
268939 : // End of memberFunctionString
268940 : // Start of memberFunctionString
268941 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
268942 :
268943 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
268944 :
268945 : std::string
268946 0 : SgAsmOp::get_name () const
268947 : {
268948 0 : ROSE_ASSERT (this != NULL);
268949 :
268950 : #if 0
268951 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268952 : // used to trigger marking transformations for the token-based unparsing.
268953 : printf ("SgAsmOp::get_name = %p = %s \n",this,this->class_name().c_str());
268954 : #endif
268955 :
268956 0 : return p_name;
268957 : }
268958 :
268959 : void
268960 0 : SgAsmOp::set_name ( std::string name )
268961 : {
268962 0 : ROSE_ASSERT (this != NULL);
268963 :
268964 : #if 0
268965 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
268966 : // used to trigger marking transformations for the token-based unparsing.
268967 : printf ("SgAsmOp::set_name = %p = %s \n",this,this->class_name().c_str());
268968 : #endif
268969 :
268970 0 : set_isModified(true);
268971 :
268972 0 : p_name = name;
268973 0 : }
268974 :
268975 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
268976 :
268977 :
268978 : // End of memberFunctionString
268979 : // Start of memberFunctionString
268980 : /* #line 8605 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
268981 :
268982 : SgType*
268983 0 : SgAsmOp::get_type() const
268984 : {
268985 0 : SgType* returnType = NULL;
268986 :
268987 0 : ROSE_ASSERT(p_expression != NULL);
268988 :
268989 : // printf ("SgAsmOp::get_type() for asm operand not implemented p_expression = %p = %s \n",p_expression,p_expression->class_name().c_str());
268990 : // ROSE_ASSERT(false);
268991 :
268992 : #if 0
268993 : printf ("In SgAsmOp::get_type() \n");
268994 : #endif
268995 :
268996 : // This is the default case (we can look at the last statement of the block later)
268997 0 : returnType = p_expression->get_type();
268998 0 : ROSE_ASSERT(returnType != NULL);
268999 :
269000 0 : return returnType;
269001 : }
269002 :
269003 :
269004 :
269005 : // End of memberFunctionString
269006 : // Start of memberFunctionString
269007 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
269008 :
269009 : // *** COMMON CODE SECTION BEGINS HERE ***
269010 :
269011 : #if 0
269012 : int
269013 : SgAsmOp::getVariant() const
269014 : {
269015 : // This function is used in ROSE while "variant()" is used in SAGE
269016 : assert(this != NULL);
269017 : return variant();
269018 : }
269019 : #endif
269020 :
269021 : // This function is used in ROSE in treeTraversal code
269022 : // eventually replaces getVariant() and variant()
269023 : // though after variant() has been removed for a while we will
269024 : // want to change the name of variantT() back to variant()
269025 : // (since the "T" was ment to stand for temporary).
269026 : // When this happens the variantT() will be depricated.
269027 : VariantT
269028 0 : SgAsmOp::variantT() const
269029 : {
269030 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
269031 0 : ROSE_ASSERT(this != NULL);
269032 0 : return V_SgAsmOp;
269033 : }
269034 :
269035 : #if 0
269036 : int
269037 : SgAsmOp::variant() const
269038 : {
269039 : // This function is used in SAGE
269040 : ROSE_ASSERT(this != NULL);
269041 : return ASM_OP;
269042 : }
269043 : #endif
269044 :
269045 : ROSE_DLL_API const char*
269046 0 : SgAsmOp::sage_class_name() const
269047 : {
269048 0 : ROSE_ASSERT(this != NULL);
269049 0 : return "SgAsmOp";
269050 : }
269051 :
269052 : std::string
269053 0 : SgAsmOp::class_name() const
269054 : {
269055 0 : ROSE_ASSERT(this != NULL);
269056 0 : return "SgAsmOp";
269057 : }
269058 :
269059 : // DQ (11/26/2005): Support for visitor pattern mechanims
269060 : // (inferior to ROSE traversal mechanism, experimental).
269061 : void
269062 0 : SgAsmOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
269063 : {
269064 0 : ROSE_ASSERT(this != NULL);
269065 0 : visitor.visit(this);
269066 0 : }
269067 :
269068 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
269069 0 : void SgAsmOp::accept (ROSE_VisitorPattern & visitor) {
269070 0 : ROSE_ASSERT(this != NULL);
269071 0 : visitor.visit(this);
269072 0 : }
269073 :
269074 : SgAsmOp*
269075 0 : SgAsmOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
269076 : {
269077 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
269078 : // This function is currently only supported for the AST used the represent Binary executables.
269079 : if (0 /* isSgAsmNode(this) != NULL */)
269080 : {
269081 : // Support for regex specification.
269082 : std::string prefixCode = "REGEX:";
269083 : addNewAttribute(prefixCode + s,a);
269084 : }
269085 : #endif
269086 :
269087 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
269088 0 : return this;
269089 : }
269090 :
269091 : // *** COMMON CODE SECTION ENDS HERE ***
269092 :
269093 :
269094 : // End of memberFunctionString
269095 : // Start of memberFunctionString
269096 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
269097 :
269098 :
269099 : #if 0
269100 : //! Error checking support
269101 : /*! Verifies the following:
269102 : - working getVariant() member function
269103 : - calls base class's error() member function
269104 : Every class has one of these functions.
269105 : */
269106 : bool
269107 : SgAsmOp::error()
269108 : {
269109 : // Put error checking here
269110 :
269111 : ROSE_ASSERT (this != NULL);
269112 : if (getVariant() != ASM_OP)
269113 : {
269114 : printf ("Error in SgAsmOp::error(): SgAsmOp object has a %s variant \n",
269115 : Cxx_GrammarTerminalNames[getVariant()].name);
269116 : // printf ("Error in SgAsmOp::error() \n");
269117 : ROSE_ABORT();
269118 : }
269119 :
269120 : ROSE_ASSERT (getVariant() == ASM_OP);
269121 : return SgExpression::error();
269122 : }
269123 : #endif
269124 :
269125 :
269126 :
269127 : // End of memberFunctionString
269128 :
269129 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
269130 :
269131 0 : SgAsmOp* isSgAsmOp ( SgNode* inputDerivedClassPointer )
269132 : {
269133 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
269134 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
269135 : // So to fix this we return NULL directly when the input is NULL and avoid the
269136 : // dynamic_cast in this case. This is likely a performance improvement as well.
269137 : // return dynamic_cast<SgAsmOp*>(inputDerivedClassPointer);
269138 : // Milind Chabbi (8/28/2013): isSgAsmOp uses table-driven castability instead of c++ default dynamic_cast
269139 : // this improves the running time performance by 10-20%.
269140 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAsmOp*>(inputDerivedClassPointer);
269141 0 : return IS_SgAsmOp_FAST_MACRO(inputDerivedClassPointer);
269142 : }
269143 :
269144 : // DQ (11/8/2003): Added version of functions taking const pointer
269145 0 : const SgAsmOp* isSgAsmOp ( const SgNode* inputDerivedClassPointer )
269146 : {
269147 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
269148 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
269149 : // So to fix this we return NULL directly when the input is NULL and avoid the
269150 : // dynamic_cast in this case. This is likely a performance improvement as well.
269151 : // return dynamic_cast<const SgAsmOp*>(inputDerivedClassPointer);
269152 : // Milind Chabbi (8/28/2013): isSgAsmOp uses table-driven castability instead of c++ default dynamic_cast
269153 : // this improves the running time performance by 10-20%.
269154 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAsmOp*>(inputDerivedClassPointer);
269155 0 : return IS_SgAsmOp_FAST_MACRO(inputDerivedClassPointer);
269156 : }
269157 :
269158 :
269159 :
269160 : /* #line 269161 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269161 :
269162 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
269163 :
269164 : /**
269165 : \brief Generated destructor
269166 :
269167 : This destructor is automatically generated (by ROSETTA). This destructor
269168 : only frees memory of data members associated with the parts of the current IR node which
269169 : are NOT traversed. Those data members that are part of a traversal can be freed using
269170 : a traversal (calling this destructor on all children in a post-order traversal). Such
269171 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
269172 :
269173 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
269174 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
269175 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
269176 :
269177 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
269178 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
269179 : pointers are not yet implemented to call delete on eash pointer in the container.
269180 : (This could be done by derivation from the STL containers to define containers that
269181 : automatically deleted their members.)
269182 :
269183 : */
269184 0 : SgAsmOp::~SgAsmOp () {
269185 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
269186 :
269187 0 : if (p_expression && p_expression->get_freepointer() == AST_FileIO::IS_VALID_POINTER()) { delete p_expression; }
269188 :
269189 : // case: not a listType for constraint
269190 0 : p_constraint = SgAsmOp::e_invalid; // non list case
269191 : // case: not a listType for modifiers
269192 0 : p_modifiers = SgAsmOp::e_unknown; // non list case
269193 : // case: not a listType for expression
269194 0 : p_expression = NULL; // non list case
269195 : // case: not a listType for recordRawAsmOperandDescriptions
269196 0 : p_recordRawAsmOperandDescriptions = false; // non list case
269197 : // case: not a listType for isOutputOperand
269198 0 : p_isOutputOperand = false; // non list case
269199 : // case: not a listType for constraintString
269200 0 : p_constraintString = ""; // non list case
269201 : // case: not a listType for name
269202 0 : p_name = ""; // non list case
269203 :
269204 : }
269205 :
269206 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
269207 0 : }
269208 :
269209 :
269210 : /* #line 269211 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269211 :
269212 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
269213 :
269214 : // Generated constructor
269215 0 : SgAsmOp::SgAsmOp ( Sg_File_Info* startOfConstruct, SgAsmOp::asm_operand_constraint_enum constraint, SgAsmOp::asm_operand_modifier_enum modifiers, SgExpression* expression )
269216 0 : : SgExpression(startOfConstruct)
269217 : {
269218 : #ifdef DEBUG
269219 : // printf ("In SgAsmOp::SgAsmOp (Sg_File_Info* startOfConstruct, SgAsmOp::asm_operand_constraint_enum constraint, SgAsmOp::asm_operand_modifier_enum modifiers, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
269220 : #endif
269221 : #if 0
269222 : // debugging information!
269223 : printf ("In SgAsmOp::SgAsmOp (Sg_File_Info* startOfConstruct, SgAsmOp::asm_operand_constraint_enum constraint, SgAsmOp::asm_operand_modifier_enum modifiers, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
269224 : #endif
269225 :
269226 0 : p_constraint = constraint;
269227 0 : p_modifiers = modifiers;
269228 0 : p_expression = expression;
269229 0 : p_recordRawAsmOperandDescriptions = false;
269230 0 : p_isOutputOperand = false;
269231 0 : p_constraintString = "";
269232 0 : p_name = "";
269233 :
269234 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
269235 :
269236 : #if 0
269237 : // DQ (7/30/2014): Call a virtual function.
269238 : std::string s = this->class_name();
269239 : #endif
269240 :
269241 : // Test the variant virtual function
269242 : // assert(ASM_OP == variant());
269243 0 : assert(ASM_OP == this->variant());
269244 0 : ROSE_ASSERT(ASM_OP == (int)(this->variantT()));
269245 0 : post_construction_initialization();
269246 :
269247 : // Test the isSgAsmOp() function since it has been problematic
269248 0 : assert(isSgAsmOp(this) != NULL);
269249 0 : }
269250 :
269251 : // Generated constructor (all data members)
269252 :
269253 : /* #line 269254 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269254 :
269255 :
269256 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
269257 :
269258 :
269259 : // ********************************************************
269260 : // member functions common across all array grammar objects
269261 : // ********************************************************
269262 :
269263 :
269264 :
269265 : /* #line 269266 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269266 :
269267 :
269268 :
269269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
269270 :
269271 : // ********************************************************
269272 : // member functions specific to each node in the grammar
269273 : // ********************************************************
269274 :
269275 :
269276 : /* #line 269277 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269277 :
269278 : // Start of memberFunctionString
269279 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
269280 :
269281 : void
269282 9 : SgLabelRefExp::post_construction_initialization()
269283 : {
269284 9 : }
269285 :
269286 :
269287 :
269288 : // End of memberFunctionString
269289 : // Start of memberFunctionString
269290 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
269291 :
269292 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
269293 :
269294 : SgLabelSymbol*
269295 8 : SgLabelRefExp::get_symbol () const
269296 : {
269297 8 : ROSE_ASSERT (this != NULL);
269298 :
269299 : #if 0
269300 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
269301 : // used to trigger marking transformations for the token-based unparsing.
269302 : printf ("SgLabelRefExp::get_symbol = %p = %s \n",this,this->class_name().c_str());
269303 : #endif
269304 :
269305 8 : return p_symbol;
269306 : }
269307 :
269308 : void
269309 0 : SgLabelRefExp::set_symbol ( SgLabelSymbol* symbol )
269310 : {
269311 0 : ROSE_ASSERT (this != NULL);
269312 :
269313 : #if 0
269314 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
269315 : // used to trigger marking transformations for the token-based unparsing.
269316 : printf ("SgLabelRefExp::set_symbol = %p = %s \n",this,this->class_name().c_str());
269317 : #endif
269318 :
269319 0 : set_isModified(true);
269320 :
269321 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
269322 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
269323 : {
269324 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
269325 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
269326 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
269327 : ROSE_ASSERT(false);
269328 : #endif
269329 : }
269330 : #endif
269331 0 : p_symbol = symbol;
269332 0 : }
269333 :
269334 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
269335 :
269336 :
269337 : // End of memberFunctionString
269338 : // Start of memberFunctionString
269339 : /* #line 3452 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
269340 :
269341 :
269342 : SgName
269343 3 : SgLabelRefExp::get_name() const
269344 : {
269345 3 : ROSE_ASSERT(p_symbol != NULL);
269346 3 : return p_symbol->get_name();
269347 : }
269348 :
269349 : int
269350 0 : SgLabelRefExp::get_numeric_label_value() const
269351 : {
269352 0 : ROSE_ASSERT(p_symbol != NULL);
269353 0 : return p_symbol->get_numeric_label_value();
269354 : }
269355 :
269356 : bool
269357 0 : SgLabelRefExp::isFunctionCallArgumentForAlternativeReturnType() const
269358 : {
269359 : // We might want to make sure that this is for a Fortran AST.
269360 :
269361 : // This is relevant more for type checking than for the unparing since a SgLabel expression will always be output using "*" syntax.
269362 :
269363 : // However initial results from this test is showing that the function type arguments list is at least sometime empty when it should not be.
269364 :
269365 0 : bool returnValue = false;
269366 :
269367 : #if 0
269368 : // SgFunctionCallExp* enclosingFunctionCall = SageInterface::getEnclosingNode<SgFunctionCallExp>(this);
269369 : SgNode* tmp_enclosingFunctionCall = SageInterface::getEnclosingNode<SgFunctionCallExp>(this);
269370 : ROSE_ASSERT(tmp_enclosingFunctionCall != NULL);
269371 :
269372 : SgNode* tmp_exprListExp = SageInterface::getEnclosingNode<SgExprListExp>(this);
269373 : ROSE_ASSERT(tmp_exprListExp != NULL);
269374 :
269375 : // Compute the index position of the current element (finish later)...
269376 : size_t positionInList = 1;
269377 :
269378 : SgFunctionCallExp* enclosingFunctionCall = isSgFunctionCallExp(tmp_enclosingFunctionCall);
269379 : ROSE_ASSERT(enclosingFunctionCall != NULL);
269380 :
269381 : SgExpression* tmp_functionRefExp = enclosingFunctionCall->get_function();
269382 : ROSE_ASSERT(tmp_functionRefExp != NULL);
269383 :
269384 : // Could this alternatively be a Fortran procedure pointer?
269385 : SgFunctionRefExp* functionRefExp = isSgFunctionRefExp(tmp_functionRefExp);
269386 : ROSE_ASSERT(functionRefExp != NULL);
269387 :
269388 : SgType* tmp_functionType = functionRefExp->get_type();
269389 : ROSE_ASSERT(tmp_functionRefExp != NULL);
269390 : SgFunctionType* functionType = isSgFunctionType(tmp_functionType);
269391 : ROSE_ASSERT(functionType != NULL);
269392 :
269393 : SgFunctionParameterTypeList* functionParameterTypeList = functionType->get_argument_list();
269394 : ROSE_ASSERT(functionParameterTypeList != NULL);
269395 :
269396 : SgTypePtrList & functionTypeArguments = functionParameterTypeList->get_arguments();
269397 :
269398 : printf ("functionTypeArguments.size() = %" PRIuPTR " \n",functionTypeArguments.size());
269399 : ROSE_ASSERT(positionInList < functionTypeArguments.size());
269400 :
269401 : SgType* tmp_thisParametersType = functionTypeArguments[positionInList];
269402 : ROSE_ASSERT(tmp_thisParametersType != NULL);
269403 :
269404 : SgTypeLabel* labelType = isSgTypeLabel(tmp_thisParametersType);
269405 :
269406 : returnValue = (labelType != NULL);
269407 :
269408 : printf ("In SgLabelRefExp::isFunctionCallArgumentForAlternativeReturnType(): returnValue = %s \n",returnValue ? "true" : "false");
269409 : #endif
269410 :
269411 0 : return returnValue;
269412 : }
269413 :
269414 : #if 0
269415 : const SgName &
269416 : SgLabelRefExp::get_name() const
269417 : {
269418 : ROSE_ASSERT(p_symbol != NULL);
269419 : return p_symbol->get_name();
269420 : }
269421 : #endif
269422 :
269423 :
269424 :
269425 : // End of memberFunctionString
269426 : // Start of memberFunctionString
269427 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
269428 :
269429 :
269430 : SgType*
269431 0 : SgLabelRefExp::get_type() const
269432 : {
269433 0 : ROSE_ASSERT(this != NULL);
269434 :
269435 : #if 0
269436 : printf ("In SgLabelRefExp::get_type() \n");
269437 : #endif
269438 :
269439 0 : SgSymbol* symbol = this->get_symbol();
269440 0 : if (symbol == NULL)
269441 : {
269442 0 : printf ("Error: In SgLabelRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
269443 : }
269444 0 : ROSE_ASSERT(symbol != NULL);
269445 :
269446 : // DQ (9/27/2006): Added assertion
269447 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
269448 :
269449 : // printf ("In SgLabelRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
269450 0 : SgType* type = symbol->get_type();
269451 0 : if (type == NULL)
269452 : {
269453 0 : printf ("Error: In SgLabelRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
269454 : }
269455 0 : ROSE_ASSERT(type != NULL);
269456 :
269457 : // return get_symbol()->get_type();
269458 0 : return type;
269459 : }
269460 :
269461 :
269462 :
269463 : // End of memberFunctionString
269464 : // Start of memberFunctionString
269465 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
269466 :
269467 : // *** COMMON CODE SECTION BEGINS HERE ***
269468 :
269469 : #if 0
269470 : int
269471 : SgLabelRefExp::getVariant() const
269472 : {
269473 : // This function is used in ROSE while "variant()" is used in SAGE
269474 : assert(this != NULL);
269475 : return variant();
269476 : }
269477 : #endif
269478 :
269479 : // This function is used in ROSE in treeTraversal code
269480 : // eventually replaces getVariant() and variant()
269481 : // though after variant() has been removed for a while we will
269482 : // want to change the name of variantT() back to variant()
269483 : // (since the "T" was ment to stand for temporary).
269484 : // When this happens the variantT() will be depricated.
269485 : VariantT
269486 390 : SgLabelRefExp::variantT() const
269487 : {
269488 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
269489 390 : ROSE_ASSERT(this != NULL);
269490 390 : return V_SgLabelRefExp;
269491 : }
269492 :
269493 : #if 0
269494 : int
269495 : SgLabelRefExp::variant() const
269496 : {
269497 : // This function is used in SAGE
269498 : ROSE_ASSERT(this != NULL);
269499 : return LABEL_REF;
269500 : }
269501 : #endif
269502 :
269503 : ROSE_DLL_API const char*
269504 0 : SgLabelRefExp::sage_class_name() const
269505 : {
269506 0 : ROSE_ASSERT(this != NULL);
269507 0 : return "SgLabelRefExp";
269508 : }
269509 :
269510 : std::string
269511 9 : SgLabelRefExp::class_name() const
269512 : {
269513 9 : ROSE_ASSERT(this != NULL);
269514 9 : return "SgLabelRefExp";
269515 : }
269516 :
269517 : // DQ (11/26/2005): Support for visitor pattern mechanims
269518 : // (inferior to ROSE traversal mechanism, experimental).
269519 : void
269520 0 : SgLabelRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
269521 : {
269522 0 : ROSE_ASSERT(this != NULL);
269523 0 : visitor.visit(this);
269524 0 : }
269525 :
269526 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
269527 0 : void SgLabelRefExp::accept (ROSE_VisitorPattern & visitor) {
269528 0 : ROSE_ASSERT(this != NULL);
269529 0 : visitor.visit(this);
269530 0 : }
269531 :
269532 : SgLabelRefExp*
269533 0 : SgLabelRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
269534 : {
269535 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
269536 : // This function is currently only supported for the AST used the represent Binary executables.
269537 : if (0 /* isSgAsmNode(this) != NULL */)
269538 : {
269539 : // Support for regex specification.
269540 : std::string prefixCode = "REGEX:";
269541 : addNewAttribute(prefixCode + s,a);
269542 : }
269543 : #endif
269544 :
269545 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
269546 0 : return this;
269547 : }
269548 :
269549 : // *** COMMON CODE SECTION ENDS HERE ***
269550 :
269551 :
269552 : // End of memberFunctionString
269553 : // Start of memberFunctionString
269554 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
269555 :
269556 :
269557 : #if 0
269558 : //! Error checking support
269559 : /*! Verifies the following:
269560 : - working getVariant() member function
269561 : - calls base class's error() member function
269562 : Every class has one of these functions.
269563 : */
269564 : bool
269565 : SgLabelRefExp::error()
269566 : {
269567 : // Put error checking here
269568 :
269569 : ROSE_ASSERT (this != NULL);
269570 : if (getVariant() != LABEL_REF)
269571 : {
269572 : printf ("Error in SgLabelRefExp::error(): SgLabelRefExp object has a %s variant \n",
269573 : Cxx_GrammarTerminalNames[getVariant()].name);
269574 : // printf ("Error in SgLabelRefExp::error() \n");
269575 : ROSE_ABORT();
269576 : }
269577 :
269578 : ROSE_ASSERT (getVariant() == LABEL_REF);
269579 : return SgExpression::error();
269580 : }
269581 : #endif
269582 :
269583 :
269584 :
269585 : // End of memberFunctionString
269586 :
269587 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
269588 :
269589 1351 : SgLabelRefExp* isSgLabelRefExp ( SgNode* inputDerivedClassPointer )
269590 : {
269591 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
269592 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
269593 : // So to fix this we return NULL directly when the input is NULL and avoid the
269594 : // dynamic_cast in this case. This is likely a performance improvement as well.
269595 : // return dynamic_cast<SgLabelRefExp*>(inputDerivedClassPointer);
269596 : // Milind Chabbi (8/28/2013): isSgLabelRefExp uses table-driven castability instead of c++ default dynamic_cast
269597 : // this improves the running time performance by 10-20%.
269598 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLabelRefExp*>(inputDerivedClassPointer);
269599 1351 : return IS_SgLabelRefExp_FAST_MACRO(inputDerivedClassPointer);
269600 : }
269601 :
269602 : // DQ (11/8/2003): Added version of functions taking const pointer
269603 0 : const SgLabelRefExp* isSgLabelRefExp ( const SgNode* inputDerivedClassPointer )
269604 : {
269605 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
269606 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
269607 : // So to fix this we return NULL directly when the input is NULL and avoid the
269608 : // dynamic_cast in this case. This is likely a performance improvement as well.
269609 : // return dynamic_cast<const SgLabelRefExp*>(inputDerivedClassPointer);
269610 : // Milind Chabbi (8/28/2013): isSgLabelRefExp uses table-driven castability instead of c++ default dynamic_cast
269611 : // this improves the running time performance by 10-20%.
269612 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLabelRefExp*>(inputDerivedClassPointer);
269613 0 : return IS_SgLabelRefExp_FAST_MACRO(inputDerivedClassPointer);
269614 : }
269615 :
269616 :
269617 :
269618 : /* #line 269619 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269619 :
269620 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
269621 :
269622 : /**
269623 : \brief Generated destructor
269624 :
269625 : This destructor is automatically generated (by ROSETTA). This destructor
269626 : only frees memory of data members associated with the parts of the current IR node which
269627 : are NOT traversed. Those data members that are part of a traversal can be freed using
269628 : a traversal (calling this destructor on all children in a post-order traversal). Such
269629 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
269630 :
269631 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
269632 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
269633 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
269634 :
269635 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
269636 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
269637 : pointers are not yet implemented to call delete on eash pointer in the container.
269638 : (This could be done by derivation from the STL containers to define containers that
269639 : automatically deleted their members.)
269640 :
269641 : */
269642 0 : SgLabelRefExp::~SgLabelRefExp () {
269643 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
269644 :
269645 :
269646 : // case: not a listType for symbol
269647 0 : p_symbol = NULL; // non list case
269648 :
269649 : }
269650 :
269651 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
269652 0 : }
269653 :
269654 :
269655 : /* #line 269656 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269656 :
269657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
269658 :
269659 : // Generated constructor
269660 0 : SgLabelRefExp::SgLabelRefExp ( Sg_File_Info* startOfConstruct, SgLabelSymbol* symbol )
269661 0 : : SgExpression(startOfConstruct)
269662 : {
269663 : #ifdef DEBUG
269664 : // printf ("In SgLabelRefExp::SgLabelRefExp (Sg_File_Info* startOfConstruct, SgLabelSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
269665 : #endif
269666 : #if 0
269667 : // debugging information!
269668 : printf ("In SgLabelRefExp::SgLabelRefExp (Sg_File_Info* startOfConstruct, SgLabelSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
269669 : #endif
269670 :
269671 0 : p_symbol = symbol;
269672 :
269673 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
269674 :
269675 : #if 0
269676 : // DQ (7/30/2014): Call a virtual function.
269677 : std::string s = this->class_name();
269678 : #endif
269679 :
269680 : // Test the variant virtual function
269681 : // assert(LABEL_REF == variant());
269682 0 : assert(LABEL_REF == this->variant());
269683 0 : ROSE_ASSERT(LABEL_REF == (int)(this->variantT()));
269684 0 : post_construction_initialization();
269685 :
269686 : // Test the isSgLabelRefExp() function since it has been problematic
269687 0 : assert(isSgLabelRefExp(this) != NULL);
269688 0 : }
269689 :
269690 : // Generated constructor (all data members)
269691 :
269692 : /* #line 269693 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269693 :
269694 :
269695 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
269696 :
269697 :
269698 : // ********************************************************
269699 : // member functions common across all array grammar objects
269700 : // ********************************************************
269701 :
269702 :
269703 :
269704 : /* #line 269705 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269705 :
269706 :
269707 :
269708 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
269709 :
269710 : // ********************************************************
269711 : // member functions specific to each node in the grammar
269712 : // ********************************************************
269713 :
269714 :
269715 : /* #line 269716 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269716 :
269717 : // Start of memberFunctionString
269718 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
269719 :
269720 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
269721 :
269722 : SgName
269723 0 : SgActualArgumentExpression::get_argument_name () const
269724 : {
269725 0 : ROSE_ASSERT (this != NULL);
269726 :
269727 : #if 0
269728 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
269729 : // used to trigger marking transformations for the token-based unparsing.
269730 : printf ("SgActualArgumentExpression::get_argument_name = %p = %s \n",this,this->class_name().c_str());
269731 : #endif
269732 :
269733 0 : return p_argument_name;
269734 : }
269735 :
269736 : void
269737 0 : SgActualArgumentExpression::set_argument_name ( SgName argument_name )
269738 : {
269739 0 : ROSE_ASSERT (this != NULL);
269740 :
269741 : #if 0
269742 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
269743 : // used to trigger marking transformations for the token-based unparsing.
269744 : printf ("SgActualArgumentExpression::set_argument_name = %p = %s \n",this,this->class_name().c_str());
269745 : #endif
269746 :
269747 0 : set_isModified(true);
269748 :
269749 0 : p_argument_name = argument_name;
269750 0 : }
269751 :
269752 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
269753 :
269754 :
269755 : // End of memberFunctionString
269756 : // Start of memberFunctionString
269757 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
269758 :
269759 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
269760 :
269761 : SgExpression*
269762 0 : SgActualArgumentExpression::get_expression () const
269763 : {
269764 0 : ROSE_ASSERT (this != NULL);
269765 :
269766 : #if 0
269767 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
269768 : // used to trigger marking transformations for the token-based unparsing.
269769 : printf ("SgActualArgumentExpression::get_expression = %p = %s \n",this,this->class_name().c_str());
269770 : #endif
269771 :
269772 0 : return p_expression;
269773 : }
269774 :
269775 : void
269776 0 : SgActualArgumentExpression::set_expression ( SgExpression* expression )
269777 : {
269778 0 : ROSE_ASSERT (this != NULL);
269779 :
269780 : #if 0
269781 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
269782 : // used to trigger marking transformations for the token-based unparsing.
269783 : printf ("SgActualArgumentExpression::set_expression = %p = %s \n",this,this->class_name().c_str());
269784 : #endif
269785 :
269786 0 : set_isModified(true);
269787 :
269788 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
269789 : if (p_expression != NULL && expression != NULL && p_expression != expression)
269790 : {
269791 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
269792 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
269793 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
269794 : ROSE_ASSERT(false);
269795 : #endif
269796 : }
269797 : #endif
269798 0 : p_expression = expression;
269799 0 : }
269800 :
269801 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
269802 :
269803 :
269804 : // End of memberFunctionString
269805 : // Start of memberFunctionString
269806 : /* #line 9087 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
269807 :
269808 :
269809 : void
269810 0 : SgActualArgumentExpression::post_construction_initialization()
269811 : {
269812 0 : ROSE_ASSERT(p_expression != NULL);
269813 0 : p_expression->set_parent(this);
269814 0 : }
269815 :
269816 : SgType*
269817 0 : SgActualArgumentExpression::get_type() const
269818 : {
269819 0 : ROSE_ASSERT(p_expression != NULL);
269820 :
269821 : #if 0
269822 : printf ("In SgActualArgumentExpression::get_type() \n");
269823 : #endif
269824 :
269825 0 : return p_expression->get_type();
269826 : }
269827 :
269828 :
269829 :
269830 : // End of memberFunctionString
269831 : // Start of memberFunctionString
269832 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
269833 :
269834 : // *** COMMON CODE SECTION BEGINS HERE ***
269835 :
269836 : #if 0
269837 : int
269838 : SgActualArgumentExpression::getVariant() const
269839 : {
269840 : // This function is used in ROSE while "variant()" is used in SAGE
269841 : assert(this != NULL);
269842 : return variant();
269843 : }
269844 : #endif
269845 :
269846 : // This function is used in ROSE in treeTraversal code
269847 : // eventually replaces getVariant() and variant()
269848 : // though after variant() has been removed for a while we will
269849 : // want to change the name of variantT() back to variant()
269850 : // (since the "T" was ment to stand for temporary).
269851 : // When this happens the variantT() will be depricated.
269852 : VariantT
269853 0 : SgActualArgumentExpression::variantT() const
269854 : {
269855 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
269856 0 : ROSE_ASSERT(this != NULL);
269857 0 : return V_SgActualArgumentExpression;
269858 : }
269859 :
269860 : #if 0
269861 : int
269862 : SgActualArgumentExpression::variant() const
269863 : {
269864 : // This function is used in SAGE
269865 : ROSE_ASSERT(this != NULL);
269866 : return ACTUAL_ARGUMENT_EXPRESSION;
269867 : }
269868 : #endif
269869 :
269870 : ROSE_DLL_API const char*
269871 0 : SgActualArgumentExpression::sage_class_name() const
269872 : {
269873 0 : ROSE_ASSERT(this != NULL);
269874 0 : return "SgActualArgumentExpression";
269875 : }
269876 :
269877 : std::string
269878 0 : SgActualArgumentExpression::class_name() const
269879 : {
269880 0 : ROSE_ASSERT(this != NULL);
269881 0 : return "SgActualArgumentExpression";
269882 : }
269883 :
269884 : // DQ (11/26/2005): Support for visitor pattern mechanims
269885 : // (inferior to ROSE traversal mechanism, experimental).
269886 : void
269887 0 : SgActualArgumentExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
269888 : {
269889 0 : ROSE_ASSERT(this != NULL);
269890 0 : visitor.visit(this);
269891 0 : }
269892 :
269893 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
269894 0 : void SgActualArgumentExpression::accept (ROSE_VisitorPattern & visitor) {
269895 0 : ROSE_ASSERT(this != NULL);
269896 0 : visitor.visit(this);
269897 0 : }
269898 :
269899 : SgActualArgumentExpression*
269900 0 : SgActualArgumentExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
269901 : {
269902 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
269903 : // This function is currently only supported for the AST used the represent Binary executables.
269904 : if (0 /* isSgAsmNode(this) != NULL */)
269905 : {
269906 : // Support for regex specification.
269907 : std::string prefixCode = "REGEX:";
269908 : addNewAttribute(prefixCode + s,a);
269909 : }
269910 : #endif
269911 :
269912 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
269913 0 : return this;
269914 : }
269915 :
269916 : // *** COMMON CODE SECTION ENDS HERE ***
269917 :
269918 :
269919 : // End of memberFunctionString
269920 : // Start of memberFunctionString
269921 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
269922 :
269923 :
269924 : #if 0
269925 : //! Error checking support
269926 : /*! Verifies the following:
269927 : - working getVariant() member function
269928 : - calls base class's error() member function
269929 : Every class has one of these functions.
269930 : */
269931 : bool
269932 : SgActualArgumentExpression::error()
269933 : {
269934 : // Put error checking here
269935 :
269936 : ROSE_ASSERT (this != NULL);
269937 : if (getVariant() != ACTUAL_ARGUMENT_EXPRESSION)
269938 : {
269939 : printf ("Error in SgActualArgumentExpression::error(): SgActualArgumentExpression object has a %s variant \n",
269940 : Cxx_GrammarTerminalNames[getVariant()].name);
269941 : // printf ("Error in SgActualArgumentExpression::error() \n");
269942 : ROSE_ABORT();
269943 : }
269944 :
269945 : ROSE_ASSERT (getVariant() == ACTUAL_ARGUMENT_EXPRESSION);
269946 : return SgExpression::error();
269947 : }
269948 : #endif
269949 :
269950 :
269951 :
269952 : // End of memberFunctionString
269953 :
269954 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
269955 :
269956 14 : SgActualArgumentExpression* isSgActualArgumentExpression ( SgNode* inputDerivedClassPointer )
269957 : {
269958 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
269959 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
269960 : // So to fix this we return NULL directly when the input is NULL and avoid the
269961 : // dynamic_cast in this case. This is likely a performance improvement as well.
269962 : // return dynamic_cast<SgActualArgumentExpression*>(inputDerivedClassPointer);
269963 : // Milind Chabbi (8/28/2013): isSgActualArgumentExpression uses table-driven castability instead of c++ default dynamic_cast
269964 : // this improves the running time performance by 10-20%.
269965 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgActualArgumentExpression*>(inputDerivedClassPointer);
269966 14 : return IS_SgActualArgumentExpression_FAST_MACRO(inputDerivedClassPointer);
269967 : }
269968 :
269969 : // DQ (11/8/2003): Added version of functions taking const pointer
269970 0 : const SgActualArgumentExpression* isSgActualArgumentExpression ( const SgNode* inputDerivedClassPointer )
269971 : {
269972 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
269973 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
269974 : // So to fix this we return NULL directly when the input is NULL and avoid the
269975 : // dynamic_cast in this case. This is likely a performance improvement as well.
269976 : // return dynamic_cast<const SgActualArgumentExpression*>(inputDerivedClassPointer);
269977 : // Milind Chabbi (8/28/2013): isSgActualArgumentExpression uses table-driven castability instead of c++ default dynamic_cast
269978 : // this improves the running time performance by 10-20%.
269979 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgActualArgumentExpression*>(inputDerivedClassPointer);
269980 0 : return IS_SgActualArgumentExpression_FAST_MACRO(inputDerivedClassPointer);
269981 : }
269982 :
269983 :
269984 :
269985 : /* #line 269986 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
269986 :
269987 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
269988 :
269989 : /**
269990 : \brief Generated destructor
269991 :
269992 : This destructor is automatically generated (by ROSETTA). This destructor
269993 : only frees memory of data members associated with the parts of the current IR node which
269994 : are NOT traversed. Those data members that are part of a traversal can be freed using
269995 : a traversal (calling this destructor on all children in a post-order traversal). Such
269996 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
269997 :
269998 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
269999 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
270000 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
270001 :
270002 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
270003 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
270004 : pointers are not yet implemented to call delete on eash pointer in the container.
270005 : (This could be done by derivation from the STL containers to define containers that
270006 : automatically deleted their members.)
270007 :
270008 : */
270009 0 : SgActualArgumentExpression::~SgActualArgumentExpression () {
270010 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
270011 :
270012 :
270013 : // case: not a listType for argument_name
270014 0 : p_argument_name = ""; // non list case
270015 : // case: not a listType for expression
270016 0 : p_expression = NULL; // non list case
270017 :
270018 : }
270019 :
270020 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
270021 0 : }
270022 :
270023 :
270024 : /* #line 270025 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270025 :
270026 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
270027 :
270028 : // Generated constructor
270029 0 : SgActualArgumentExpression::SgActualArgumentExpression ( Sg_File_Info* startOfConstruct, SgName argument_name, SgExpression* expression )
270030 0 : : SgExpression(startOfConstruct)
270031 : {
270032 : #ifdef DEBUG
270033 : // printf ("In SgActualArgumentExpression::SgActualArgumentExpression (Sg_File_Info* startOfConstruct, SgName argument_name, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
270034 : #endif
270035 : #if 0
270036 : // debugging information!
270037 : printf ("In SgActualArgumentExpression::SgActualArgumentExpression (Sg_File_Info* startOfConstruct, SgName argument_name, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
270038 : #endif
270039 :
270040 0 : p_argument_name = argument_name;
270041 0 : p_expression = expression;
270042 :
270043 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
270044 :
270045 : #if 0
270046 : // DQ (7/30/2014): Call a virtual function.
270047 : std::string s = this->class_name();
270048 : #endif
270049 :
270050 : // Test the variant virtual function
270051 : // assert(ACTUAL_ARGUMENT_EXPRESSION == variant());
270052 0 : assert(ACTUAL_ARGUMENT_EXPRESSION == this->variant());
270053 0 : ROSE_ASSERT(ACTUAL_ARGUMENT_EXPRESSION == (int)(this->variantT()));
270054 0 : post_construction_initialization();
270055 :
270056 : // Test the isSgActualArgumentExpression() function since it has been problematic
270057 0 : assert(isSgActualArgumentExpression(this) != NULL);
270058 0 : }
270059 :
270060 : // Generated constructor (all data members)
270061 :
270062 : /* #line 270063 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270063 :
270064 :
270065 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
270066 :
270067 :
270068 : // ********************************************************
270069 : // member functions common across all array grammar objects
270070 : // ********************************************************
270071 :
270072 :
270073 :
270074 : /* #line 270075 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270075 :
270076 :
270077 :
270078 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
270079 :
270080 : // ********************************************************
270081 : // member functions specific to each node in the grammar
270082 : // ********************************************************
270083 :
270084 :
270085 : /* #line 270086 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270086 :
270087 : // Start of memberFunctionString
270088 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
270089 :
270090 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
270091 :
270092 : std::string
270093 0 : SgUnknownArrayOrFunctionReference::get_name () const
270094 : {
270095 0 : ROSE_ASSERT (this != NULL);
270096 :
270097 : #if 0
270098 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270099 : // used to trigger marking transformations for the token-based unparsing.
270100 : printf ("SgUnknownArrayOrFunctionReference::get_name = %p = %s \n",this,this->class_name().c_str());
270101 : #endif
270102 :
270103 0 : return p_name;
270104 : }
270105 :
270106 : void
270107 0 : SgUnknownArrayOrFunctionReference::set_name ( std::string name )
270108 : {
270109 0 : ROSE_ASSERT (this != NULL);
270110 :
270111 : #if 0
270112 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270113 : // used to trigger marking transformations for the token-based unparsing.
270114 : printf ("SgUnknownArrayOrFunctionReference::set_name = %p = %s \n",this,this->class_name().c_str());
270115 : #endif
270116 :
270117 0 : set_isModified(true);
270118 :
270119 0 : p_name = name;
270120 0 : }
270121 :
270122 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
270123 :
270124 :
270125 : // End of memberFunctionString
270126 : // Start of memberFunctionString
270127 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
270128 :
270129 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
270130 :
270131 : SgExpression*
270132 0 : SgUnknownArrayOrFunctionReference::get_named_reference () const
270133 : {
270134 0 : ROSE_ASSERT (this != NULL);
270135 :
270136 : #if 0
270137 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270138 : // used to trigger marking transformations for the token-based unparsing.
270139 : printf ("SgUnknownArrayOrFunctionReference::get_named_reference = %p = %s \n",this,this->class_name().c_str());
270140 : #endif
270141 :
270142 0 : return p_named_reference;
270143 : }
270144 :
270145 : void
270146 0 : SgUnknownArrayOrFunctionReference::set_named_reference ( SgExpression* named_reference )
270147 : {
270148 0 : ROSE_ASSERT (this != NULL);
270149 :
270150 : #if 0
270151 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270152 : // used to trigger marking transformations for the token-based unparsing.
270153 : printf ("SgUnknownArrayOrFunctionReference::set_named_reference = %p = %s \n",this,this->class_name().c_str());
270154 : #endif
270155 :
270156 0 : set_isModified(true);
270157 :
270158 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
270159 : if (p_named_reference != NULL && named_reference != NULL && p_named_reference != named_reference)
270160 : {
270161 : printf ("Warning: named_reference = %p overwriting valid pointer p_named_reference = %p \n",named_reference,p_named_reference);
270162 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
270163 : printf ("Error fails assertion (p_named_reference != NULL && named_reference != NULL && p_named_reference != named_reference) is false\n");
270164 : ROSE_ASSERT(false);
270165 : #endif
270166 : }
270167 : #endif
270168 0 : p_named_reference = named_reference;
270169 0 : }
270170 :
270171 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
270172 :
270173 :
270174 : // End of memberFunctionString
270175 : // Start of memberFunctionString
270176 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
270177 :
270178 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
270179 :
270180 : SgExprListExp*
270181 0 : SgUnknownArrayOrFunctionReference::get_expression_list () const
270182 : {
270183 0 : ROSE_ASSERT (this != NULL);
270184 :
270185 : #if 0
270186 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270187 : // used to trigger marking transformations for the token-based unparsing.
270188 : printf ("SgUnknownArrayOrFunctionReference::get_expression_list = %p = %s \n",this,this->class_name().c_str());
270189 : #endif
270190 :
270191 0 : return p_expression_list;
270192 : }
270193 :
270194 : void
270195 0 : SgUnknownArrayOrFunctionReference::set_expression_list ( SgExprListExp* expression_list )
270196 : {
270197 0 : ROSE_ASSERT (this != NULL);
270198 :
270199 : #if 0
270200 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270201 : // used to trigger marking transformations for the token-based unparsing.
270202 : printf ("SgUnknownArrayOrFunctionReference::set_expression_list = %p = %s \n",this,this->class_name().c_str());
270203 : #endif
270204 :
270205 0 : set_isModified(true);
270206 :
270207 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
270208 : if (p_expression_list != NULL && expression_list != NULL && p_expression_list != expression_list)
270209 : {
270210 : printf ("Warning: expression_list = %p overwriting valid pointer p_expression_list = %p \n",expression_list,p_expression_list);
270211 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
270212 : printf ("Error fails assertion (p_expression_list != NULL && expression_list != NULL && p_expression_list != expression_list) is false\n");
270213 : ROSE_ASSERT(false);
270214 : #endif
270215 : }
270216 : #endif
270217 0 : p_expression_list = expression_list;
270218 0 : }
270219 :
270220 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
270221 :
270222 :
270223 : // End of memberFunctionString
270224 : // Start of memberFunctionString
270225 : /* #line 9069 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
270226 :
270227 :
270228 : void
270229 0 : SgUnknownArrayOrFunctionReference::post_construction_initialization()
270230 0 : { }
270231 :
270232 : SgType*
270233 0 : SgUnknownArrayOrFunctionReference::get_type() const
270234 : {
270235 0 : printf ("In SgUnknownArrayOrFunctionReference::get_type(): Not clear what this type should be (returning SgTypeDefault). \n");
270236 : // ROSE_ASSERT(false);
270237 : // return NULL;
270238 0 : return SgTypeDefault::createType();
270239 : }
270240 :
270241 :
270242 :
270243 : // End of memberFunctionString
270244 : // Start of memberFunctionString
270245 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
270246 :
270247 : // *** COMMON CODE SECTION BEGINS HERE ***
270248 :
270249 : #if 0
270250 : int
270251 : SgUnknownArrayOrFunctionReference::getVariant() const
270252 : {
270253 : // This function is used in ROSE while "variant()" is used in SAGE
270254 : assert(this != NULL);
270255 : return variant();
270256 : }
270257 : #endif
270258 :
270259 : // This function is used in ROSE in treeTraversal code
270260 : // eventually replaces getVariant() and variant()
270261 : // though after variant() has been removed for a while we will
270262 : // want to change the name of variantT() back to variant()
270263 : // (since the "T" was ment to stand for temporary).
270264 : // When this happens the variantT() will be depricated.
270265 : VariantT
270266 0 : SgUnknownArrayOrFunctionReference::variantT() const
270267 : {
270268 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
270269 0 : ROSE_ASSERT(this != NULL);
270270 0 : return V_SgUnknownArrayOrFunctionReference;
270271 : }
270272 :
270273 : #if 0
270274 : int
270275 : SgUnknownArrayOrFunctionReference::variant() const
270276 : {
270277 : // This function is used in SAGE
270278 : ROSE_ASSERT(this != NULL);
270279 : return TEMP_UnknownArrayOrFunctionReference;
270280 : }
270281 : #endif
270282 :
270283 : ROSE_DLL_API const char*
270284 0 : SgUnknownArrayOrFunctionReference::sage_class_name() const
270285 : {
270286 0 : ROSE_ASSERT(this != NULL);
270287 0 : return "SgUnknownArrayOrFunctionReference";
270288 : }
270289 :
270290 : std::string
270291 0 : SgUnknownArrayOrFunctionReference::class_name() const
270292 : {
270293 0 : ROSE_ASSERT(this != NULL);
270294 0 : return "SgUnknownArrayOrFunctionReference";
270295 : }
270296 :
270297 : // DQ (11/26/2005): Support for visitor pattern mechanims
270298 : // (inferior to ROSE traversal mechanism, experimental).
270299 : void
270300 0 : SgUnknownArrayOrFunctionReference::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
270301 : {
270302 0 : ROSE_ASSERT(this != NULL);
270303 0 : visitor.visit(this);
270304 0 : }
270305 :
270306 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
270307 0 : void SgUnknownArrayOrFunctionReference::accept (ROSE_VisitorPattern & visitor) {
270308 0 : ROSE_ASSERT(this != NULL);
270309 0 : visitor.visit(this);
270310 0 : }
270311 :
270312 : SgUnknownArrayOrFunctionReference*
270313 0 : SgUnknownArrayOrFunctionReference::addRegExpAttribute(std::string s, AstRegExAttribute* a)
270314 : {
270315 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
270316 : // This function is currently only supported for the AST used the represent Binary executables.
270317 : if (0 /* isSgAsmNode(this) != NULL */)
270318 : {
270319 : // Support for regex specification.
270320 : std::string prefixCode = "REGEX:";
270321 : addNewAttribute(prefixCode + s,a);
270322 : }
270323 : #endif
270324 :
270325 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
270326 0 : return this;
270327 : }
270328 :
270329 : // *** COMMON CODE SECTION ENDS HERE ***
270330 :
270331 :
270332 : // End of memberFunctionString
270333 : // Start of memberFunctionString
270334 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
270335 :
270336 :
270337 : #if 0
270338 : //! Error checking support
270339 : /*! Verifies the following:
270340 : - working getVariant() member function
270341 : - calls base class's error() member function
270342 : Every class has one of these functions.
270343 : */
270344 : bool
270345 : SgUnknownArrayOrFunctionReference::error()
270346 : {
270347 : // Put error checking here
270348 :
270349 : ROSE_ASSERT (this != NULL);
270350 : if (getVariant() != TEMP_UnknownArrayOrFunctionReference)
270351 : {
270352 : printf ("Error in SgUnknownArrayOrFunctionReference::error(): SgUnknownArrayOrFunctionReference object has a %s variant \n",
270353 : Cxx_GrammarTerminalNames[getVariant()].name);
270354 : // printf ("Error in SgUnknownArrayOrFunctionReference::error() \n");
270355 : ROSE_ABORT();
270356 : }
270357 :
270358 : ROSE_ASSERT (getVariant() == TEMP_UnknownArrayOrFunctionReference);
270359 : return SgExpression::error();
270360 : }
270361 : #endif
270362 :
270363 :
270364 :
270365 : // End of memberFunctionString
270366 :
270367 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
270368 :
270369 2603 : SgUnknownArrayOrFunctionReference* isSgUnknownArrayOrFunctionReference ( SgNode* inputDerivedClassPointer )
270370 : {
270371 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
270372 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
270373 : // So to fix this we return NULL directly when the input is NULL and avoid the
270374 : // dynamic_cast in this case. This is likely a performance improvement as well.
270375 : // return dynamic_cast<SgUnknownArrayOrFunctionReference*>(inputDerivedClassPointer);
270376 : // Milind Chabbi (8/28/2013): isSgUnknownArrayOrFunctionReference uses table-driven castability instead of c++ default dynamic_cast
270377 : // this improves the running time performance by 10-20%.
270378 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgUnknownArrayOrFunctionReference*>(inputDerivedClassPointer);
270379 2603 : return IS_SgUnknownArrayOrFunctionReference_FAST_MACRO(inputDerivedClassPointer);
270380 : }
270381 :
270382 : // DQ (11/8/2003): Added version of functions taking const pointer
270383 0 : const SgUnknownArrayOrFunctionReference* isSgUnknownArrayOrFunctionReference ( const SgNode* inputDerivedClassPointer )
270384 : {
270385 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
270386 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
270387 : // So to fix this we return NULL directly when the input is NULL and avoid the
270388 : // dynamic_cast in this case. This is likely a performance improvement as well.
270389 : // return dynamic_cast<const SgUnknownArrayOrFunctionReference*>(inputDerivedClassPointer);
270390 : // Milind Chabbi (8/28/2013): isSgUnknownArrayOrFunctionReference uses table-driven castability instead of c++ default dynamic_cast
270391 : // this improves the running time performance by 10-20%.
270392 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgUnknownArrayOrFunctionReference*>(inputDerivedClassPointer);
270393 0 : return IS_SgUnknownArrayOrFunctionReference_FAST_MACRO(inputDerivedClassPointer);
270394 : }
270395 :
270396 :
270397 :
270398 : /* #line 270399 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270399 :
270400 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
270401 :
270402 : /**
270403 : \brief Generated destructor
270404 :
270405 : This destructor is automatically generated (by ROSETTA). This destructor
270406 : only frees memory of data members associated with the parts of the current IR node which
270407 : are NOT traversed. Those data members that are part of a traversal can be freed using
270408 : a traversal (calling this destructor on all children in a post-order traversal). Such
270409 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
270410 :
270411 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
270412 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
270413 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
270414 :
270415 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
270416 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
270417 : pointers are not yet implemented to call delete on eash pointer in the container.
270418 : (This could be done by derivation from the STL containers to define containers that
270419 : automatically deleted their members.)
270420 :
270421 : */
270422 0 : SgUnknownArrayOrFunctionReference::~SgUnknownArrayOrFunctionReference () {
270423 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
270424 :
270425 :
270426 : // case: not a listType for name
270427 0 : p_name = ""; // non list case
270428 : // case: not a listType for named_reference
270429 0 : p_named_reference = NULL; // non list case
270430 : // case: not a listType for expression_list
270431 0 : p_expression_list = NULL; // non list case
270432 :
270433 : }
270434 :
270435 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
270436 0 : }
270437 :
270438 :
270439 : /* #line 270440 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270440 :
270441 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
270442 :
270443 : // Generated constructor
270444 0 : SgUnknownArrayOrFunctionReference::SgUnknownArrayOrFunctionReference ( Sg_File_Info* startOfConstruct )
270445 0 : : SgExpression(startOfConstruct)
270446 : {
270447 : #ifdef DEBUG
270448 : // printf ("In SgUnknownArrayOrFunctionReference::SgUnknownArrayOrFunctionReference (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
270449 : #endif
270450 : #if 0
270451 : // debugging information!
270452 : printf ("In SgUnknownArrayOrFunctionReference::SgUnknownArrayOrFunctionReference (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
270453 : #endif
270454 :
270455 0 : p_name = "";
270456 0 : p_named_reference = NULL;
270457 0 : p_expression_list = NULL;
270458 :
270459 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
270460 :
270461 : #if 0
270462 : // DQ (7/30/2014): Call a virtual function.
270463 : std::string s = this->class_name();
270464 : #endif
270465 :
270466 : // Test the variant virtual function
270467 : // assert(TEMP_UnknownArrayOrFunctionReference == variant());
270468 0 : assert(TEMP_UnknownArrayOrFunctionReference == this->variant());
270469 0 : ROSE_ASSERT(TEMP_UnknownArrayOrFunctionReference == (int)(this->variantT()));
270470 0 : post_construction_initialization();
270471 :
270472 : // Test the isSgUnknownArrayOrFunctionReference() function since it has been problematic
270473 0 : assert(isSgUnknownArrayOrFunctionReference(this) != NULL);
270474 0 : }
270475 :
270476 : // Generated constructor (all data members)
270477 :
270478 : /* #line 270479 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270479 :
270480 :
270481 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
270482 :
270483 :
270484 : // ********************************************************
270485 : // member functions common across all array grammar objects
270486 : // ********************************************************
270487 :
270488 :
270489 :
270490 : /* #line 270491 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270491 :
270492 :
270493 :
270494 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
270495 :
270496 : // ********************************************************
270497 : // member functions specific to each node in the grammar
270498 : // ********************************************************
270499 :
270500 :
270501 : /* #line 270502 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270502 :
270503 : // Start of memberFunctionString
270504 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
270505 :
270506 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
270507 :
270508 : SgType*
270509 0 : SgPseudoDestructorRefExp::get_object_type () const
270510 : {
270511 0 : ROSE_ASSERT (this != NULL);
270512 :
270513 : #if 0
270514 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270515 : // used to trigger marking transformations for the token-based unparsing.
270516 : printf ("SgPseudoDestructorRefExp::get_object_type = %p = %s \n",this,this->class_name().c_str());
270517 : #endif
270518 :
270519 0 : return p_object_type;
270520 : }
270521 :
270522 : void
270523 0 : SgPseudoDestructorRefExp::set_object_type ( SgType* object_type )
270524 : {
270525 0 : ROSE_ASSERT (this != NULL);
270526 :
270527 : #if 0
270528 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270529 : // used to trigger marking transformations for the token-based unparsing.
270530 : printf ("SgPseudoDestructorRefExp::set_object_type = %p = %s \n",this,this->class_name().c_str());
270531 : #endif
270532 :
270533 0 : set_isModified(true);
270534 :
270535 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
270536 : if (p_object_type != NULL && object_type != NULL && p_object_type != object_type)
270537 : {
270538 : printf ("Warning: object_type = %p overwriting valid pointer p_object_type = %p \n",object_type,p_object_type);
270539 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
270540 : printf ("Error fails assertion (p_object_type != NULL && object_type != NULL && p_object_type != object_type) is false\n");
270541 : ROSE_ASSERT(false);
270542 : #endif
270543 : }
270544 : #endif
270545 0 : p_object_type = object_type;
270546 0 : }
270547 :
270548 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
270549 :
270550 :
270551 : // End of memberFunctionString
270552 : // Start of memberFunctionString
270553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
270554 :
270555 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
270556 :
270557 : SgType*
270558 0 : SgPseudoDestructorRefExp::get_expression_type () const
270559 : {
270560 0 : ROSE_ASSERT (this != NULL);
270561 :
270562 : #if 0
270563 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270564 : // used to trigger marking transformations for the token-based unparsing.
270565 : printf ("SgPseudoDestructorRefExp::get_expression_type = %p = %s \n",this,this->class_name().c_str());
270566 : #endif
270567 :
270568 0 : return p_expression_type;
270569 : }
270570 :
270571 : void
270572 0 : SgPseudoDestructorRefExp::set_expression_type ( SgType* expression_type )
270573 : {
270574 0 : ROSE_ASSERT (this != NULL);
270575 :
270576 : #if 0
270577 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270578 : // used to trigger marking transformations for the token-based unparsing.
270579 : printf ("SgPseudoDestructorRefExp::set_expression_type = %p = %s \n",this,this->class_name().c_str());
270580 : #endif
270581 :
270582 0 : set_isModified(true);
270583 :
270584 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
270585 : if (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type)
270586 : {
270587 : printf ("Warning: expression_type = %p overwriting valid pointer p_expression_type = %p \n",expression_type,p_expression_type);
270588 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
270589 : printf ("Error fails assertion (p_expression_type != NULL && expression_type != NULL && p_expression_type != expression_type) is false\n");
270590 : ROSE_ASSERT(false);
270591 : #endif
270592 : }
270593 : #endif
270594 0 : p_expression_type = expression_type;
270595 0 : }
270596 :
270597 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
270598 :
270599 :
270600 : // End of memberFunctionString
270601 : // Start of memberFunctionString
270602 :
270603 :
270604 : // End of memberFunctionString
270605 : // Start of memberFunctionString
270606 : /* #line 8424 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
270607 :
270608 :
270609 : // DQ (7/19/2006): Function suggested by Jeremiah Willcock and fixed up for general use by DQ
270610 : // A better fix (later) will allow us to save the SgType and not use a SgDefaultType for the
270611 : // special case below.
270612 : SgType*
270613 0 : SgPseudoDestructorRefExp::get_type(void) const
270614 : {
270615 0 : ROSE_ASSERT(this != NULL);
270616 :
270617 : #if 0
270618 : printf ("In SgPseudoDestructorRefExp::get_type() \n");
270619 : #endif
270620 :
270621 : // DQ (8/5/2006): Now that we store the expression type explicitly this is a simpler function.
270622 0 : SgType* returnType = p_expression_type;
270623 :
270624 0 : ROSE_ASSERT(returnType != NULL);
270625 0 : return returnType;
270626 : }
270627 :
270628 :
270629 :
270630 : // End of memberFunctionString
270631 : // Start of memberFunctionString
270632 : /* #line 9357 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
270633 :
270634 : void
270635 0 : SgPseudoDestructorRefExp::post_construction_initialization()
270636 : {
270637 0 : SgMemberFunctionType *memFnType = new SgMemberFunctionType(SgTypeVoid::createType(), false, p_object_type);
270638 0 : set_expression_type(memFnType);
270639 0 : }
270640 :
270641 :
270642 : // DQ (1/18/2020): Adding name qualification support to SgPseudoDestructorRefExp.
270643 : int
270644 0 : SgPseudoDestructorRefExp::get_name_qualification_length () const
270645 : {
270646 0 : ROSE_ASSERT (this != NULL);
270647 0 : return p_name_qualification_length;
270648 : }
270649 :
270650 : // DQ (1/18/2020): Adding name qualification support to SgPseudoDestructorRefExp.
270651 : void
270652 0 : SgPseudoDestructorRefExp::set_name_qualification_length ( int name_qualification_length )
270653 : {
270654 0 : ROSE_ASSERT (this != NULL);
270655 : // This can't be called by the name qualification API (see test2015_26.C).
270656 : // set_isModified(true);
270657 :
270658 0 : p_name_qualification_length = name_qualification_length;
270659 0 : }
270660 :
270661 : // DQ (1/18/2020): Adding name qualification support to SgPseudoDestructorRefExp.
270662 : bool
270663 0 : SgPseudoDestructorRefExp::get_type_elaboration_required () const
270664 : {
270665 0 : ROSE_ASSERT (this != NULL);
270666 0 : return p_type_elaboration_required;
270667 : }
270668 :
270669 : // DQ (1/18/2020): Adding name qualification support to SgPseudoDestructorRefExp.
270670 : void
270671 0 : SgPseudoDestructorRefExp::set_type_elaboration_required ( bool type_elaboration_required )
270672 : {
270673 0 : ROSE_ASSERT (this != NULL);
270674 : // This can't be called by the name qualification API (see test2015_26.C).
270675 : // set_isModified(true);
270676 :
270677 0 : p_type_elaboration_required = type_elaboration_required;
270678 0 : }
270679 :
270680 : // DQ (1/18/2020): Adding name qualification support to SgPseudoDestructorRefExp.
270681 : bool
270682 0 : SgPseudoDestructorRefExp::get_global_qualification_required () const
270683 : {
270684 0 : ROSE_ASSERT (this != NULL);
270685 0 : return p_global_qualification_required;
270686 : }
270687 :
270688 : // DQ (1/18/2020): Adding name qualification support to SgPseudoDestructorRefExp.
270689 : void
270690 0 : SgPseudoDestructorRefExp::set_global_qualification_required ( bool global_qualification_required )
270691 : {
270692 0 : ROSE_ASSERT (this != NULL);
270693 :
270694 : // This can't be called by the name qualification API (see test2015_26.C).
270695 : // set_isModified(true);
270696 :
270697 0 : p_global_qualification_required = global_qualification_required;
270698 0 : }
270699 :
270700 :
270701 :
270702 : // End of memberFunctionString
270703 : // Start of memberFunctionString
270704 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
270705 :
270706 : // *** COMMON CODE SECTION BEGINS HERE ***
270707 :
270708 : #if 0
270709 : int
270710 : SgPseudoDestructorRefExp::getVariant() const
270711 : {
270712 : // This function is used in ROSE while "variant()" is used in SAGE
270713 : assert(this != NULL);
270714 : return variant();
270715 : }
270716 : #endif
270717 :
270718 : // This function is used in ROSE in treeTraversal code
270719 : // eventually replaces getVariant() and variant()
270720 : // though after variant() has been removed for a while we will
270721 : // want to change the name of variantT() back to variant()
270722 : // (since the "T" was ment to stand for temporary).
270723 : // When this happens the variantT() will be depricated.
270724 : VariantT
270725 0 : SgPseudoDestructorRefExp::variantT() const
270726 : {
270727 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
270728 0 : ROSE_ASSERT(this != NULL);
270729 0 : return V_SgPseudoDestructorRefExp;
270730 : }
270731 :
270732 : #if 0
270733 : int
270734 : SgPseudoDestructorRefExp::variant() const
270735 : {
270736 : // This function is used in SAGE
270737 : ROSE_ASSERT(this != NULL);
270738 : return PSEUDO_DESTRUCTOR_REF;
270739 : }
270740 : #endif
270741 :
270742 : ROSE_DLL_API const char*
270743 0 : SgPseudoDestructorRefExp::sage_class_name() const
270744 : {
270745 0 : ROSE_ASSERT(this != NULL);
270746 0 : return "SgPseudoDestructorRefExp";
270747 : }
270748 :
270749 : std::string
270750 0 : SgPseudoDestructorRefExp::class_name() const
270751 : {
270752 0 : ROSE_ASSERT(this != NULL);
270753 0 : return "SgPseudoDestructorRefExp";
270754 : }
270755 :
270756 : // DQ (11/26/2005): Support for visitor pattern mechanims
270757 : // (inferior to ROSE traversal mechanism, experimental).
270758 : void
270759 0 : SgPseudoDestructorRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
270760 : {
270761 0 : ROSE_ASSERT(this != NULL);
270762 0 : visitor.visit(this);
270763 0 : }
270764 :
270765 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
270766 0 : void SgPseudoDestructorRefExp::accept (ROSE_VisitorPattern & visitor) {
270767 0 : ROSE_ASSERT(this != NULL);
270768 0 : visitor.visit(this);
270769 0 : }
270770 :
270771 : SgPseudoDestructorRefExp*
270772 0 : SgPseudoDestructorRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
270773 : {
270774 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
270775 : // This function is currently only supported for the AST used the represent Binary executables.
270776 : if (0 /* isSgAsmNode(this) != NULL */)
270777 : {
270778 : // Support for regex specification.
270779 : std::string prefixCode = "REGEX:";
270780 : addNewAttribute(prefixCode + s,a);
270781 : }
270782 : #endif
270783 :
270784 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
270785 0 : return this;
270786 : }
270787 :
270788 : // *** COMMON CODE SECTION ENDS HERE ***
270789 :
270790 :
270791 : // End of memberFunctionString
270792 : // Start of memberFunctionString
270793 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
270794 :
270795 :
270796 : #if 0
270797 : //! Error checking support
270798 : /*! Verifies the following:
270799 : - working getVariant() member function
270800 : - calls base class's error() member function
270801 : Every class has one of these functions.
270802 : */
270803 : bool
270804 : SgPseudoDestructorRefExp::error()
270805 : {
270806 : // Put error checking here
270807 :
270808 : ROSE_ASSERT (this != NULL);
270809 : if (getVariant() != PSEUDO_DESTRUCTOR_REF)
270810 : {
270811 : printf ("Error in SgPseudoDestructorRefExp::error(): SgPseudoDestructorRefExp object has a %s variant \n",
270812 : Cxx_GrammarTerminalNames[getVariant()].name);
270813 : // printf ("Error in SgPseudoDestructorRefExp::error() \n");
270814 : ROSE_ABORT();
270815 : }
270816 :
270817 : ROSE_ASSERT (getVariant() == PSEUDO_DESTRUCTOR_REF);
270818 : return SgExpression::error();
270819 : }
270820 : #endif
270821 :
270822 :
270823 :
270824 : // End of memberFunctionString
270825 :
270826 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
270827 :
270828 2810440 : SgPseudoDestructorRefExp* isSgPseudoDestructorRefExp ( SgNode* inputDerivedClassPointer )
270829 : {
270830 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
270831 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
270832 : // So to fix this we return NULL directly when the input is NULL and avoid the
270833 : // dynamic_cast in this case. This is likely a performance improvement as well.
270834 : // return dynamic_cast<SgPseudoDestructorRefExp*>(inputDerivedClassPointer);
270835 : // Milind Chabbi (8/28/2013): isSgPseudoDestructorRefExp uses table-driven castability instead of c++ default dynamic_cast
270836 : // this improves the running time performance by 10-20%.
270837 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgPseudoDestructorRefExp*>(inputDerivedClassPointer);
270838 2810440 : return IS_SgPseudoDestructorRefExp_FAST_MACRO(inputDerivedClassPointer);
270839 : }
270840 :
270841 : // DQ (11/8/2003): Added version of functions taking const pointer
270842 0 : const SgPseudoDestructorRefExp* isSgPseudoDestructorRefExp ( const SgNode* inputDerivedClassPointer )
270843 : {
270844 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
270845 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
270846 : // So to fix this we return NULL directly when the input is NULL and avoid the
270847 : // dynamic_cast in this case. This is likely a performance improvement as well.
270848 : // return dynamic_cast<const SgPseudoDestructorRefExp*>(inputDerivedClassPointer);
270849 : // Milind Chabbi (8/28/2013): isSgPseudoDestructorRefExp uses table-driven castability instead of c++ default dynamic_cast
270850 : // this improves the running time performance by 10-20%.
270851 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgPseudoDestructorRefExp*>(inputDerivedClassPointer);
270852 0 : return IS_SgPseudoDestructorRefExp_FAST_MACRO(inputDerivedClassPointer);
270853 : }
270854 :
270855 :
270856 :
270857 : /* #line 270858 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270858 :
270859 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
270860 :
270861 : /**
270862 : \brief Generated destructor
270863 :
270864 : This destructor is automatically generated (by ROSETTA). This destructor
270865 : only frees memory of data members associated with the parts of the current IR node which
270866 : are NOT traversed. Those data members that are part of a traversal can be freed using
270867 : a traversal (calling this destructor on all children in a post-order traversal). Such
270868 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
270869 :
270870 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
270871 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
270872 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
270873 :
270874 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
270875 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
270876 : pointers are not yet implemented to call delete on eash pointer in the container.
270877 : (This could be done by derivation from the STL containers to define containers that
270878 : automatically deleted their members.)
270879 :
270880 : */
270881 0 : SgPseudoDestructorRefExp::~SgPseudoDestructorRefExp () {
270882 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
270883 :
270884 :
270885 : // case: not a listType for object_type
270886 0 : p_object_type = NULL; // non list case
270887 : // case: not a listType for expression_type
270888 0 : p_expression_type = NULL; // non list case
270889 : // case: not a listType for name_qualification_length
270890 0 : p_name_qualification_length = 0; // non list case
270891 : // case: not a listType for type_elaboration_required
270892 0 : p_type_elaboration_required = false; // non list case
270893 : // case: not a listType for global_qualification_required
270894 0 : p_global_qualification_required = false; // non list case
270895 :
270896 : }
270897 :
270898 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
270899 0 : }
270900 :
270901 :
270902 : /* #line 270903 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270903 :
270904 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
270905 :
270906 : // Generated constructor
270907 0 : SgPseudoDestructorRefExp::SgPseudoDestructorRefExp ( Sg_File_Info* startOfConstruct, SgType* object_type )
270908 0 : : SgExpression(startOfConstruct)
270909 : {
270910 : #ifdef DEBUG
270911 : // printf ("In SgPseudoDestructorRefExp::SgPseudoDestructorRefExp (Sg_File_Info* startOfConstruct, SgType* object_type) sage_class_name() = %s \n",sage_class_name());
270912 : #endif
270913 : #if 0
270914 : // debugging information!
270915 : printf ("In SgPseudoDestructorRefExp::SgPseudoDestructorRefExp (Sg_File_Info* startOfConstruct, SgType* object_type): this = %p = %s \n",this,this->class_name().c_str());
270916 : #endif
270917 :
270918 0 : p_object_type = object_type;
270919 0 : p_expression_type = NULL;
270920 0 : p_name_qualification_length = 0;
270921 0 : p_type_elaboration_required = false;
270922 0 : p_global_qualification_required = false;
270923 :
270924 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
270925 :
270926 : #if 0
270927 : // DQ (7/30/2014): Call a virtual function.
270928 : std::string s = this->class_name();
270929 : #endif
270930 :
270931 : // Test the variant virtual function
270932 : // assert(PSEUDO_DESTRUCTOR_REF == variant());
270933 0 : assert(PSEUDO_DESTRUCTOR_REF == this->variant());
270934 0 : ROSE_ASSERT(PSEUDO_DESTRUCTOR_REF == (int)(this->variantT()));
270935 0 : post_construction_initialization();
270936 :
270937 : // Test the isSgPseudoDestructorRefExp() function since it has been problematic
270938 0 : assert(isSgPseudoDestructorRefExp(this) != NULL);
270939 0 : }
270940 :
270941 : // Generated constructor (all data members)
270942 :
270943 : /* #line 270944 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270944 :
270945 :
270946 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
270947 :
270948 :
270949 : // ********************************************************
270950 : // member functions common across all array grammar objects
270951 : // ********************************************************
270952 :
270953 :
270954 :
270955 : /* #line 270956 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270956 :
270957 :
270958 :
270959 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
270960 :
270961 : // ********************************************************
270962 : // member functions specific to each node in the grammar
270963 : // ********************************************************
270964 :
270965 :
270966 : /* #line 270967 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
270967 :
270968 : // Start of memberFunctionString
270969 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
270970 :
270971 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
270972 :
270973 : SgVarRefExp*
270974 0 : SgCAFCoExpression::get_teamId () const
270975 : {
270976 0 : ROSE_ASSERT (this != NULL);
270977 :
270978 : #if 0
270979 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270980 : // used to trigger marking transformations for the token-based unparsing.
270981 : printf ("SgCAFCoExpression::get_teamId = %p = %s \n",this,this->class_name().c_str());
270982 : #endif
270983 :
270984 0 : return p_teamId;
270985 : }
270986 :
270987 : void
270988 0 : SgCAFCoExpression::set_teamId ( SgVarRefExp* teamId )
270989 : {
270990 0 : ROSE_ASSERT (this != NULL);
270991 :
270992 : #if 0
270993 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
270994 : // used to trigger marking transformations for the token-based unparsing.
270995 : printf ("SgCAFCoExpression::set_teamId = %p = %s \n",this,this->class_name().c_str());
270996 : #endif
270997 :
270998 0 : set_isModified(true);
270999 :
271000 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271001 : if (p_teamId != NULL && teamId != NULL && p_teamId != teamId)
271002 : {
271003 : printf ("Warning: teamId = %p overwriting valid pointer p_teamId = %p \n",teamId,p_teamId);
271004 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271005 : printf ("Error fails assertion (p_teamId != NULL && teamId != NULL && p_teamId != teamId) is false\n");
271006 : ROSE_ASSERT(false);
271007 : #endif
271008 : }
271009 : #endif
271010 0 : p_teamId = teamId;
271011 0 : }
271012 :
271013 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271014 :
271015 :
271016 : // End of memberFunctionString
271017 : // Start of memberFunctionString
271018 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271019 :
271020 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271021 :
271022 : SgExpression*
271023 0 : SgCAFCoExpression::get_teamRank () const
271024 : {
271025 0 : ROSE_ASSERT (this != NULL);
271026 :
271027 : #if 0
271028 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271029 : // used to trigger marking transformations for the token-based unparsing.
271030 : printf ("SgCAFCoExpression::get_teamRank = %p = %s \n",this,this->class_name().c_str());
271031 : #endif
271032 :
271033 0 : return p_teamRank;
271034 : }
271035 :
271036 : void
271037 0 : SgCAFCoExpression::set_teamRank ( SgExpression* teamRank )
271038 : {
271039 0 : ROSE_ASSERT (this != NULL);
271040 :
271041 : #if 0
271042 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271043 : // used to trigger marking transformations for the token-based unparsing.
271044 : printf ("SgCAFCoExpression::set_teamRank = %p = %s \n",this,this->class_name().c_str());
271045 : #endif
271046 :
271047 0 : set_isModified(true);
271048 :
271049 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271050 : if (p_teamRank != NULL && teamRank != NULL && p_teamRank != teamRank)
271051 : {
271052 : printf ("Warning: teamRank = %p overwriting valid pointer p_teamRank = %p \n",teamRank,p_teamRank);
271053 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271054 : printf ("Error fails assertion (p_teamRank != NULL && teamRank != NULL && p_teamRank != teamRank) is false\n");
271055 : ROSE_ASSERT(false);
271056 : #endif
271057 : }
271058 : #endif
271059 0 : p_teamRank = teamRank;
271060 0 : }
271061 :
271062 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271063 :
271064 :
271065 : // End of memberFunctionString
271066 : // Start of memberFunctionString
271067 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271068 :
271069 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271070 :
271071 : SgExpression*
271072 0 : SgCAFCoExpression::get_referData () const
271073 : {
271074 0 : ROSE_ASSERT (this != NULL);
271075 :
271076 : #if 0
271077 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271078 : // used to trigger marking transformations for the token-based unparsing.
271079 : printf ("SgCAFCoExpression::get_referData = %p = %s \n",this,this->class_name().c_str());
271080 : #endif
271081 :
271082 0 : return p_referData;
271083 : }
271084 :
271085 : void
271086 0 : SgCAFCoExpression::set_referData ( SgExpression* referData )
271087 : {
271088 0 : ROSE_ASSERT (this != NULL);
271089 :
271090 : #if 0
271091 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271092 : // used to trigger marking transformations for the token-based unparsing.
271093 : printf ("SgCAFCoExpression::set_referData = %p = %s \n",this,this->class_name().c_str());
271094 : #endif
271095 :
271096 0 : set_isModified(true);
271097 :
271098 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271099 : if (p_referData != NULL && referData != NULL && p_referData != referData)
271100 : {
271101 : printf ("Warning: referData = %p overwriting valid pointer p_referData = %p \n",referData,p_referData);
271102 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271103 : printf ("Error fails assertion (p_referData != NULL && referData != NULL && p_referData != referData) is false\n");
271104 : ROSE_ASSERT(false);
271105 : #endif
271106 : }
271107 : #endif
271108 0 : p_referData = referData;
271109 0 : }
271110 :
271111 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271112 :
271113 :
271114 : // End of memberFunctionString
271115 : // Start of memberFunctionString
271116 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
271117 :
271118 : void
271119 0 : SgCAFCoExpression::post_construction_initialization()
271120 : {
271121 0 : }
271122 :
271123 :
271124 :
271125 : // End of memberFunctionString
271126 : // Start of memberFunctionString
271127 : /* #line 9340 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
271128 :
271129 :
271130 : SgType*
271131 0 : SgCAFCoExpression::get_type() const
271132 : {
271133 0 : SgType* returnType = get_referData()->get_type();
271134 :
271135 : #if 0
271136 : printf ("In SgCAFCoExpression::get_type() \n");
271137 : #endif
271138 :
271139 0 : ROSE_ASSERT(returnType != NULL);
271140 0 : return returnType;
271141 : }
271142 :
271143 :
271144 :
271145 : // End of memberFunctionString
271146 : // Start of memberFunctionString
271147 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
271148 :
271149 : // *** COMMON CODE SECTION BEGINS HERE ***
271150 :
271151 : #if 0
271152 : int
271153 : SgCAFCoExpression::getVariant() const
271154 : {
271155 : // This function is used in ROSE while "variant()" is used in SAGE
271156 : assert(this != NULL);
271157 : return variant();
271158 : }
271159 : #endif
271160 :
271161 : // This function is used in ROSE in treeTraversal code
271162 : // eventually replaces getVariant() and variant()
271163 : // though after variant() has been removed for a while we will
271164 : // want to change the name of variantT() back to variant()
271165 : // (since the "T" was ment to stand for temporary).
271166 : // When this happens the variantT() will be depricated.
271167 : VariantT
271168 0 : SgCAFCoExpression::variantT() const
271169 : {
271170 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
271171 0 : ROSE_ASSERT(this != NULL);
271172 0 : return V_SgCAFCoExpression;
271173 : }
271174 :
271175 : #if 0
271176 : int
271177 : SgCAFCoExpression::variant() const
271178 : {
271179 : // This function is used in SAGE
271180 : ROSE_ASSERT(this != NULL);
271181 : return COARRAY_REF_EXPR;
271182 : }
271183 : #endif
271184 :
271185 : ROSE_DLL_API const char*
271186 0 : SgCAFCoExpression::sage_class_name() const
271187 : {
271188 0 : ROSE_ASSERT(this != NULL);
271189 0 : return "SgCAFCoExpression";
271190 : }
271191 :
271192 : std::string
271193 0 : SgCAFCoExpression::class_name() const
271194 : {
271195 0 : ROSE_ASSERT(this != NULL);
271196 0 : return "SgCAFCoExpression";
271197 : }
271198 :
271199 : // DQ (11/26/2005): Support for visitor pattern mechanims
271200 : // (inferior to ROSE traversal mechanism, experimental).
271201 : void
271202 0 : SgCAFCoExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
271203 : {
271204 0 : ROSE_ASSERT(this != NULL);
271205 0 : visitor.visit(this);
271206 0 : }
271207 :
271208 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
271209 0 : void SgCAFCoExpression::accept (ROSE_VisitorPattern & visitor) {
271210 0 : ROSE_ASSERT(this != NULL);
271211 0 : visitor.visit(this);
271212 0 : }
271213 :
271214 : SgCAFCoExpression*
271215 0 : SgCAFCoExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
271216 : {
271217 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
271218 : // This function is currently only supported for the AST used the represent Binary executables.
271219 : if (0 /* isSgAsmNode(this) != NULL */)
271220 : {
271221 : // Support for regex specification.
271222 : std::string prefixCode = "REGEX:";
271223 : addNewAttribute(prefixCode + s,a);
271224 : }
271225 : #endif
271226 :
271227 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
271228 0 : return this;
271229 : }
271230 :
271231 : // *** COMMON CODE SECTION ENDS HERE ***
271232 :
271233 :
271234 : // End of memberFunctionString
271235 : // Start of memberFunctionString
271236 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
271237 :
271238 :
271239 : #if 0
271240 : //! Error checking support
271241 : /*! Verifies the following:
271242 : - working getVariant() member function
271243 : - calls base class's error() member function
271244 : Every class has one of these functions.
271245 : */
271246 : bool
271247 : SgCAFCoExpression::error()
271248 : {
271249 : // Put error checking here
271250 :
271251 : ROSE_ASSERT (this != NULL);
271252 : if (getVariant() != COARRAY_REF_EXPR)
271253 : {
271254 : printf ("Error in SgCAFCoExpression::error(): SgCAFCoExpression object has a %s variant \n",
271255 : Cxx_GrammarTerminalNames[getVariant()].name);
271256 : // printf ("Error in SgCAFCoExpression::error() \n");
271257 : ROSE_ABORT();
271258 : }
271259 :
271260 : ROSE_ASSERT (getVariant() == COARRAY_REF_EXPR);
271261 : return SgExpression::error();
271262 : }
271263 : #endif
271264 :
271265 :
271266 :
271267 : // End of memberFunctionString
271268 :
271269 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
271270 :
271271 75237 : SgCAFCoExpression* isSgCAFCoExpression ( SgNode* inputDerivedClassPointer )
271272 : {
271273 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
271274 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
271275 : // So to fix this we return NULL directly when the input is NULL and avoid the
271276 : // dynamic_cast in this case. This is likely a performance improvement as well.
271277 : // return dynamic_cast<SgCAFCoExpression*>(inputDerivedClassPointer);
271278 : // Milind Chabbi (8/28/2013): isSgCAFCoExpression uses table-driven castability instead of c++ default dynamic_cast
271279 : // this improves the running time performance by 10-20%.
271280 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCAFCoExpression*>(inputDerivedClassPointer);
271281 75237 : return IS_SgCAFCoExpression_FAST_MACRO(inputDerivedClassPointer);
271282 : }
271283 :
271284 : // DQ (11/8/2003): Added version of functions taking const pointer
271285 0 : const SgCAFCoExpression* isSgCAFCoExpression ( const SgNode* inputDerivedClassPointer )
271286 : {
271287 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
271288 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
271289 : // So to fix this we return NULL directly when the input is NULL and avoid the
271290 : // dynamic_cast in this case. This is likely a performance improvement as well.
271291 : // return dynamic_cast<const SgCAFCoExpression*>(inputDerivedClassPointer);
271292 : // Milind Chabbi (8/28/2013): isSgCAFCoExpression uses table-driven castability instead of c++ default dynamic_cast
271293 : // this improves the running time performance by 10-20%.
271294 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCAFCoExpression*>(inputDerivedClassPointer);
271295 0 : return IS_SgCAFCoExpression_FAST_MACRO(inputDerivedClassPointer);
271296 : }
271297 :
271298 :
271299 :
271300 : /* #line 271301 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271301 :
271302 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
271303 :
271304 : /**
271305 : \brief Generated destructor
271306 :
271307 : This destructor is automatically generated (by ROSETTA). This destructor
271308 : only frees memory of data members associated with the parts of the current IR node which
271309 : are NOT traversed. Those data members that are part of a traversal can be freed using
271310 : a traversal (calling this destructor on all children in a post-order traversal). Such
271311 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
271312 :
271313 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
271314 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
271315 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
271316 :
271317 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
271318 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
271319 : pointers are not yet implemented to call delete on eash pointer in the container.
271320 : (This could be done by derivation from the STL containers to define containers that
271321 : automatically deleted their members.)
271322 :
271323 : */
271324 0 : SgCAFCoExpression::~SgCAFCoExpression () {
271325 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
271326 :
271327 :
271328 : // case: not a listType for teamId
271329 0 : p_teamId = NULL; // non list case
271330 : // case: not a listType for teamRank
271331 0 : p_teamRank = NULL; // non list case
271332 : // case: not a listType for referData
271333 0 : p_referData = NULL; // non list case
271334 :
271335 : }
271336 :
271337 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
271338 0 : }
271339 :
271340 :
271341 : /* #line 271342 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271342 :
271343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
271344 :
271345 : // Generated constructor
271346 0 : SgCAFCoExpression::SgCAFCoExpression ( Sg_File_Info* startOfConstruct, SgVarRefExp* teamId, SgExpression* teamRank, SgExpression* referData )
271347 0 : : SgExpression(startOfConstruct)
271348 : {
271349 : #ifdef DEBUG
271350 : // printf ("In SgCAFCoExpression::SgCAFCoExpression (Sg_File_Info* startOfConstruct, SgVarRefExp* teamId, SgExpression* teamRank, SgExpression* referData) sage_class_name() = %s \n",sage_class_name());
271351 : #endif
271352 : #if 0
271353 : // debugging information!
271354 : printf ("In SgCAFCoExpression::SgCAFCoExpression (Sg_File_Info* startOfConstruct, SgVarRefExp* teamId, SgExpression* teamRank, SgExpression* referData): this = %p = %s \n",this,this->class_name().c_str());
271355 : #endif
271356 :
271357 0 : p_teamId = teamId;
271358 0 : p_teamRank = teamRank;
271359 0 : p_referData = referData;
271360 :
271361 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
271362 :
271363 : #if 0
271364 : // DQ (7/30/2014): Call a virtual function.
271365 : std::string s = this->class_name();
271366 : #endif
271367 :
271368 : // Test the variant virtual function
271369 : // assert(COARRAY_REF_EXPR == variant());
271370 0 : assert(COARRAY_REF_EXPR == this->variant());
271371 0 : ROSE_ASSERT(COARRAY_REF_EXPR == (int)(this->variantT()));
271372 0 : post_construction_initialization();
271373 :
271374 : // Test the isSgCAFCoExpression() function since it has been problematic
271375 0 : assert(isSgCAFCoExpression(this) != NULL);
271376 0 : }
271377 :
271378 : // Generated constructor (all data members)
271379 :
271380 : /* #line 271381 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271381 :
271382 :
271383 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
271384 :
271385 :
271386 : // ********************************************************
271387 : // member functions common across all array grammar objects
271388 : // ********************************************************
271389 :
271390 :
271391 :
271392 : /* #line 271393 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271393 :
271394 :
271395 :
271396 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
271397 :
271398 : // ********************************************************
271399 : // member functions specific to each node in the grammar
271400 : // ********************************************************
271401 :
271402 :
271403 : /* #line 271404 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271404 :
271405 : // Start of memberFunctionString
271406 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271407 :
271408 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271409 :
271410 : SgExpression*
271411 0 : SgCudaKernelExecConfig::get_grid () const
271412 : {
271413 0 : ROSE_ASSERT (this != NULL);
271414 :
271415 : #if 0
271416 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271417 : // used to trigger marking transformations for the token-based unparsing.
271418 : printf ("SgCudaKernelExecConfig::get_grid = %p = %s \n",this,this->class_name().c_str());
271419 : #endif
271420 :
271421 0 : return p_grid;
271422 : }
271423 :
271424 : void
271425 0 : SgCudaKernelExecConfig::set_grid ( SgExpression* grid )
271426 : {
271427 0 : ROSE_ASSERT (this != NULL);
271428 :
271429 : #if 0
271430 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271431 : // used to trigger marking transformations for the token-based unparsing.
271432 : printf ("SgCudaKernelExecConfig::set_grid = %p = %s \n",this,this->class_name().c_str());
271433 : #endif
271434 :
271435 0 : set_isModified(true);
271436 :
271437 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271438 : if (p_grid != NULL && grid != NULL && p_grid != grid)
271439 : {
271440 : printf ("Warning: grid = %p overwriting valid pointer p_grid = %p \n",grid,p_grid);
271441 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271442 : printf ("Error fails assertion (p_grid != NULL && grid != NULL && p_grid != grid) is false\n");
271443 : ROSE_ASSERT(false);
271444 : #endif
271445 : }
271446 : #endif
271447 0 : p_grid = grid;
271448 0 : }
271449 :
271450 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271451 :
271452 :
271453 : // End of memberFunctionString
271454 : // Start of memberFunctionString
271455 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271456 :
271457 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271458 :
271459 : SgExpression*
271460 0 : SgCudaKernelExecConfig::get_blocks () const
271461 : {
271462 0 : ROSE_ASSERT (this != NULL);
271463 :
271464 : #if 0
271465 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271466 : // used to trigger marking transformations for the token-based unparsing.
271467 : printf ("SgCudaKernelExecConfig::get_blocks = %p = %s \n",this,this->class_name().c_str());
271468 : #endif
271469 :
271470 0 : return p_blocks;
271471 : }
271472 :
271473 : void
271474 0 : SgCudaKernelExecConfig::set_blocks ( SgExpression* blocks )
271475 : {
271476 0 : ROSE_ASSERT (this != NULL);
271477 :
271478 : #if 0
271479 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271480 : // used to trigger marking transformations for the token-based unparsing.
271481 : printf ("SgCudaKernelExecConfig::set_blocks = %p = %s \n",this,this->class_name().c_str());
271482 : #endif
271483 :
271484 0 : set_isModified(true);
271485 :
271486 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271487 : if (p_blocks != NULL && blocks != NULL && p_blocks != blocks)
271488 : {
271489 : printf ("Warning: blocks = %p overwriting valid pointer p_blocks = %p \n",blocks,p_blocks);
271490 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271491 : printf ("Error fails assertion (p_blocks != NULL && blocks != NULL && p_blocks != blocks) is false\n");
271492 : ROSE_ASSERT(false);
271493 : #endif
271494 : }
271495 : #endif
271496 0 : p_blocks = blocks;
271497 0 : }
271498 :
271499 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271500 :
271501 :
271502 : // End of memberFunctionString
271503 : // Start of memberFunctionString
271504 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271505 :
271506 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271507 :
271508 : SgExpression*
271509 0 : SgCudaKernelExecConfig::get_shared () const
271510 : {
271511 0 : ROSE_ASSERT (this != NULL);
271512 :
271513 : #if 0
271514 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271515 : // used to trigger marking transformations for the token-based unparsing.
271516 : printf ("SgCudaKernelExecConfig::get_shared = %p = %s \n",this,this->class_name().c_str());
271517 : #endif
271518 :
271519 0 : return p_shared;
271520 : }
271521 :
271522 : void
271523 0 : SgCudaKernelExecConfig::set_shared ( SgExpression* shared )
271524 : {
271525 0 : ROSE_ASSERT (this != NULL);
271526 :
271527 : #if 0
271528 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271529 : // used to trigger marking transformations for the token-based unparsing.
271530 : printf ("SgCudaKernelExecConfig::set_shared = %p = %s \n",this,this->class_name().c_str());
271531 : #endif
271532 :
271533 0 : set_isModified(true);
271534 :
271535 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271536 : if (p_shared != NULL && shared != NULL && p_shared != shared)
271537 : {
271538 : printf ("Warning: shared = %p overwriting valid pointer p_shared = %p \n",shared,p_shared);
271539 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271540 : printf ("Error fails assertion (p_shared != NULL && shared != NULL && p_shared != shared) is false\n");
271541 : ROSE_ASSERT(false);
271542 : #endif
271543 : }
271544 : #endif
271545 0 : p_shared = shared;
271546 0 : }
271547 :
271548 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271549 :
271550 :
271551 : // End of memberFunctionString
271552 : // Start of memberFunctionString
271553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271554 :
271555 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271556 :
271557 : SgExpression*
271558 0 : SgCudaKernelExecConfig::get_stream () const
271559 : {
271560 0 : ROSE_ASSERT (this != NULL);
271561 :
271562 : #if 0
271563 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271564 : // used to trigger marking transformations for the token-based unparsing.
271565 : printf ("SgCudaKernelExecConfig::get_stream = %p = %s \n",this,this->class_name().c_str());
271566 : #endif
271567 :
271568 0 : return p_stream;
271569 : }
271570 :
271571 : void
271572 0 : SgCudaKernelExecConfig::set_stream ( SgExpression* stream )
271573 : {
271574 0 : ROSE_ASSERT (this != NULL);
271575 :
271576 : #if 0
271577 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271578 : // used to trigger marking transformations for the token-based unparsing.
271579 : printf ("SgCudaKernelExecConfig::set_stream = %p = %s \n",this,this->class_name().c_str());
271580 : #endif
271581 :
271582 0 : set_isModified(true);
271583 :
271584 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271585 : if (p_stream != NULL && stream != NULL && p_stream != stream)
271586 : {
271587 : printf ("Warning: stream = %p overwriting valid pointer p_stream = %p \n",stream,p_stream);
271588 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271589 : printf ("Error fails assertion (p_stream != NULL && stream != NULL && p_stream != stream) is false\n");
271590 : ROSE_ASSERT(false);
271591 : #endif
271592 : }
271593 : #endif
271594 0 : p_stream = stream;
271595 0 : }
271596 :
271597 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271598 :
271599 :
271600 : // End of memberFunctionString
271601 : // Start of memberFunctionString
271602 : /* #line 9471 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
271603 :
271604 :
271605 :
271606 : // End of memberFunctionString
271607 : // Start of memberFunctionString
271608 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
271609 :
271610 : void
271611 0 : SgCudaKernelExecConfig::post_construction_initialization()
271612 : {
271613 0 : }
271614 :
271615 :
271616 :
271617 : // End of memberFunctionString
271618 : // Start of memberFunctionString
271619 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
271620 :
271621 : SgType*
271622 :
271623 0 : SgCudaKernelExecConfig::get_type() const
271624 : {
271625 0 : ROSE_ASSERT(this != NULL);
271626 :
271627 : #if 0
271628 : printf ("In SgCudaKernelExecConfig::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
271629 : #endif
271630 :
271631 : // DQ (10/31/2016): Debugging...
271632 : // return SgTypeDefault::createType();
271633 0 : SgType* returnType = SgTypeDefault::createType();
271634 :
271635 : #if 0
271636 : printf ("Leaving SgCudaKernelExecConfig::get_type() (default_get_type) returnType = %p \n",returnType);
271637 : #endif
271638 :
271639 0 : return returnType;
271640 : }
271641 :
271642 :
271643 :
271644 : // End of memberFunctionString
271645 : // Start of memberFunctionString
271646 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
271647 :
271648 : // *** COMMON CODE SECTION BEGINS HERE ***
271649 :
271650 : #if 0
271651 : int
271652 : SgCudaKernelExecConfig::getVariant() const
271653 : {
271654 : // This function is used in ROSE while "variant()" is used in SAGE
271655 : assert(this != NULL);
271656 : return variant();
271657 : }
271658 : #endif
271659 :
271660 : // This function is used in ROSE in treeTraversal code
271661 : // eventually replaces getVariant() and variant()
271662 : // though after variant() has been removed for a while we will
271663 : // want to change the name of variantT() back to variant()
271664 : // (since the "T" was ment to stand for temporary).
271665 : // When this happens the variantT() will be depricated.
271666 : VariantT
271667 0 : SgCudaKernelExecConfig::variantT() const
271668 : {
271669 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
271670 0 : ROSE_ASSERT(this != NULL);
271671 0 : return V_SgCudaKernelExecConfig;
271672 : }
271673 :
271674 : #if 0
271675 : int
271676 : SgCudaKernelExecConfig::variant() const
271677 : {
271678 : // This function is used in SAGE
271679 : ROSE_ASSERT(this != NULL);
271680 : return EXEC_CONF;
271681 : }
271682 : #endif
271683 :
271684 : ROSE_DLL_API const char*
271685 0 : SgCudaKernelExecConfig::sage_class_name() const
271686 : {
271687 0 : ROSE_ASSERT(this != NULL);
271688 0 : return "SgCudaKernelExecConfig";
271689 : }
271690 :
271691 : std::string
271692 0 : SgCudaKernelExecConfig::class_name() const
271693 : {
271694 0 : ROSE_ASSERT(this != NULL);
271695 0 : return "SgCudaKernelExecConfig";
271696 : }
271697 :
271698 : // DQ (11/26/2005): Support for visitor pattern mechanims
271699 : // (inferior to ROSE traversal mechanism, experimental).
271700 : void
271701 0 : SgCudaKernelExecConfig::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
271702 : {
271703 0 : ROSE_ASSERT(this != NULL);
271704 0 : visitor.visit(this);
271705 0 : }
271706 :
271707 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
271708 0 : void SgCudaKernelExecConfig::accept (ROSE_VisitorPattern & visitor) {
271709 0 : ROSE_ASSERT(this != NULL);
271710 0 : visitor.visit(this);
271711 0 : }
271712 :
271713 : SgCudaKernelExecConfig*
271714 0 : SgCudaKernelExecConfig::addRegExpAttribute(std::string s, AstRegExAttribute* a)
271715 : {
271716 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
271717 : // This function is currently only supported for the AST used the represent Binary executables.
271718 : if (0 /* isSgAsmNode(this) != NULL */)
271719 : {
271720 : // Support for regex specification.
271721 : std::string prefixCode = "REGEX:";
271722 : addNewAttribute(prefixCode + s,a);
271723 : }
271724 : #endif
271725 :
271726 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
271727 0 : return this;
271728 : }
271729 :
271730 : // *** COMMON CODE SECTION ENDS HERE ***
271731 :
271732 :
271733 : // End of memberFunctionString
271734 : // Start of memberFunctionString
271735 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
271736 :
271737 :
271738 : #if 0
271739 : //! Error checking support
271740 : /*! Verifies the following:
271741 : - working getVariant() member function
271742 : - calls base class's error() member function
271743 : Every class has one of these functions.
271744 : */
271745 : bool
271746 : SgCudaKernelExecConfig::error()
271747 : {
271748 : // Put error checking here
271749 :
271750 : ROSE_ASSERT (this != NULL);
271751 : if (getVariant() != EXEC_CONF)
271752 : {
271753 : printf ("Error in SgCudaKernelExecConfig::error(): SgCudaKernelExecConfig object has a %s variant \n",
271754 : Cxx_GrammarTerminalNames[getVariant()].name);
271755 : // printf ("Error in SgCudaKernelExecConfig::error() \n");
271756 : ROSE_ABORT();
271757 : }
271758 :
271759 : ROSE_ASSERT (getVariant() == EXEC_CONF);
271760 : return SgExpression::error();
271761 : }
271762 : #endif
271763 :
271764 :
271765 :
271766 : // End of memberFunctionString
271767 :
271768 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
271769 :
271770 0 : SgCudaKernelExecConfig* isSgCudaKernelExecConfig ( SgNode* inputDerivedClassPointer )
271771 : {
271772 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
271773 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
271774 : // So to fix this we return NULL directly when the input is NULL and avoid the
271775 : // dynamic_cast in this case. This is likely a performance improvement as well.
271776 : // return dynamic_cast<SgCudaKernelExecConfig*>(inputDerivedClassPointer);
271777 : // Milind Chabbi (8/28/2013): isSgCudaKernelExecConfig uses table-driven castability instead of c++ default dynamic_cast
271778 : // this improves the running time performance by 10-20%.
271779 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCudaKernelExecConfig*>(inputDerivedClassPointer);
271780 0 : return IS_SgCudaKernelExecConfig_FAST_MACRO(inputDerivedClassPointer);
271781 : }
271782 :
271783 : // DQ (11/8/2003): Added version of functions taking const pointer
271784 0 : const SgCudaKernelExecConfig* isSgCudaKernelExecConfig ( const SgNode* inputDerivedClassPointer )
271785 : {
271786 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
271787 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
271788 : // So to fix this we return NULL directly when the input is NULL and avoid the
271789 : // dynamic_cast in this case. This is likely a performance improvement as well.
271790 : // return dynamic_cast<const SgCudaKernelExecConfig*>(inputDerivedClassPointer);
271791 : // Milind Chabbi (8/28/2013): isSgCudaKernelExecConfig uses table-driven castability instead of c++ default dynamic_cast
271792 : // this improves the running time performance by 10-20%.
271793 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCudaKernelExecConfig*>(inputDerivedClassPointer);
271794 0 : return IS_SgCudaKernelExecConfig_FAST_MACRO(inputDerivedClassPointer);
271795 : }
271796 :
271797 :
271798 :
271799 : /* #line 271800 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271800 :
271801 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
271802 :
271803 : /**
271804 : \brief Generated destructor
271805 :
271806 : This destructor is automatically generated (by ROSETTA). This destructor
271807 : only frees memory of data members associated with the parts of the current IR node which
271808 : are NOT traversed. Those data members that are part of a traversal can be freed using
271809 : a traversal (calling this destructor on all children in a post-order traversal). Such
271810 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
271811 :
271812 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
271813 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
271814 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
271815 :
271816 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
271817 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
271818 : pointers are not yet implemented to call delete on eash pointer in the container.
271819 : (This could be done by derivation from the STL containers to define containers that
271820 : automatically deleted their members.)
271821 :
271822 : */
271823 0 : SgCudaKernelExecConfig::~SgCudaKernelExecConfig () {
271824 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
271825 :
271826 :
271827 : // case: not a listType for grid
271828 0 : p_grid = NULL; // non list case
271829 : // case: not a listType for blocks
271830 0 : p_blocks = NULL; // non list case
271831 : // case: not a listType for shared
271832 0 : p_shared = NULL; // non list case
271833 : // case: not a listType for stream
271834 0 : p_stream = NULL; // non list case
271835 :
271836 : }
271837 :
271838 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
271839 0 : }
271840 :
271841 :
271842 : /* #line 271843 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271843 :
271844 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
271845 :
271846 : // Generated constructor
271847 0 : SgCudaKernelExecConfig::SgCudaKernelExecConfig ( Sg_File_Info* startOfConstruct, SgExpression* grid, SgExpression* blocks, SgExpression* shared, SgExpression* stream )
271848 0 : : SgExpression(startOfConstruct)
271849 : {
271850 : #ifdef DEBUG
271851 : // printf ("In SgCudaKernelExecConfig::SgCudaKernelExecConfig (Sg_File_Info* startOfConstruct, SgExpression* grid, SgExpression* blocks, SgExpression* shared, SgExpression* stream) sage_class_name() = %s \n",sage_class_name());
271852 : #endif
271853 : #if 0
271854 : // debugging information!
271855 : printf ("In SgCudaKernelExecConfig::SgCudaKernelExecConfig (Sg_File_Info* startOfConstruct, SgExpression* grid, SgExpression* blocks, SgExpression* shared, SgExpression* stream): this = %p = %s \n",this,this->class_name().c_str());
271856 : #endif
271857 :
271858 0 : p_grid = grid;
271859 0 : p_blocks = blocks;
271860 0 : p_shared = shared;
271861 0 : p_stream = stream;
271862 :
271863 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
271864 :
271865 : #if 0
271866 : // DQ (7/30/2014): Call a virtual function.
271867 : std::string s = this->class_name();
271868 : #endif
271869 :
271870 : // Test the variant virtual function
271871 : // assert(EXEC_CONF == variant());
271872 0 : assert(EXEC_CONF == this->variant());
271873 0 : ROSE_ASSERT(EXEC_CONF == (int)(this->variantT()));
271874 0 : post_construction_initialization();
271875 :
271876 : // Test the isSgCudaKernelExecConfig() function since it has been problematic
271877 0 : assert(isSgCudaKernelExecConfig(this) != NULL);
271878 0 : }
271879 :
271880 : // Generated constructor (all data members)
271881 :
271882 : /* #line 271883 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271883 :
271884 :
271885 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
271886 :
271887 :
271888 : // ********************************************************
271889 : // member functions common across all array grammar objects
271890 : // ********************************************************
271891 :
271892 :
271893 :
271894 : /* #line 271895 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271895 :
271896 :
271897 :
271898 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
271899 :
271900 : // ********************************************************
271901 : // member functions specific to each node in the grammar
271902 : // ********************************************************
271903 :
271904 :
271905 : /* #line 271906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
271906 :
271907 : // Start of memberFunctionString
271908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
271909 :
271910 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
271911 :
271912 : SgFunctionDeclaration*
271913 0 : SgLambdaRefExp::get_functionDeclaration () const
271914 : {
271915 0 : ROSE_ASSERT (this != NULL);
271916 :
271917 : #if 0
271918 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271919 : // used to trigger marking transformations for the token-based unparsing.
271920 : printf ("SgLambdaRefExp::get_functionDeclaration = %p = %s \n",this,this->class_name().c_str());
271921 : #endif
271922 :
271923 0 : return p_functionDeclaration;
271924 : }
271925 :
271926 : void
271927 0 : SgLambdaRefExp::set_functionDeclaration ( SgFunctionDeclaration* functionDeclaration )
271928 : {
271929 0 : ROSE_ASSERT (this != NULL);
271930 :
271931 : #if 0
271932 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
271933 : // used to trigger marking transformations for the token-based unparsing.
271934 : printf ("SgLambdaRefExp::set_functionDeclaration = %p = %s \n",this,this->class_name().c_str());
271935 : #endif
271936 :
271937 0 : set_isModified(true);
271938 :
271939 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
271940 : if (p_functionDeclaration != NULL && functionDeclaration != NULL && p_functionDeclaration != functionDeclaration)
271941 : {
271942 : printf ("Warning: functionDeclaration = %p overwriting valid pointer p_functionDeclaration = %p \n",functionDeclaration,p_functionDeclaration);
271943 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
271944 : printf ("Error fails assertion (p_functionDeclaration != NULL && functionDeclaration != NULL && p_functionDeclaration != functionDeclaration) is false\n");
271945 : ROSE_ASSERT(false);
271946 : #endif
271947 : }
271948 : #endif
271949 0 : p_functionDeclaration = functionDeclaration;
271950 0 : }
271951 :
271952 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
271953 :
271954 :
271955 : // End of memberFunctionString
271956 : // Start of memberFunctionString
271957 : /* #line 9427 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
271958 :
271959 :
271960 0 : SgType* SgLambdaRefExp::get_type() const
271961 : {
271962 : #if 0
271963 : printf ("In SgLambdaRefExp::get_type() \n");
271964 : #endif
271965 :
271966 0 : return SageBuilder::buildVoidType();
271967 : }
271968 :
271969 : void
271970 0 : SgLambdaRefExp::post_construction_initialization()
271971 : {
271972 0 : }
271973 :
271974 : SgFunctionParameterList*
271975 0 : SgLambdaRefExp::get_parameterList()
271976 : {
271977 0 : ROSE_ASSERT(this != NULL);
271978 :
271979 0 : SgFunctionDeclaration* func_decl = this->get_functionDeclaration();
271980 0 : ROSE_ASSERT(func_decl != NULL);
271981 :
271982 0 : return func_decl->get_parameterList();
271983 : }
271984 :
271985 : SgStatement*
271986 0 : SgLambdaRefExp::get_body() {
271987 0 : ROSE_ASSERT(this != NULL);
271988 :
271989 0 : SgFunctionDeclaration* func_decl =
271990 0 : this->get_functionDeclaration();
271991 0 : ROSE_ASSERT(func_decl != NULL);
271992 :
271993 0 : SgFunctionDefinition* func_def =
271994 0 : func_decl->get_definition();
271995 0 : ROSE_ASSERT(func_def != NULL);
271996 :
271997 0 : return func_def->get_body();
271998 : }
271999 :
272000 :
272001 :
272002 : // End of memberFunctionString
272003 : // Start of memberFunctionString
272004 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
272005 :
272006 : // *** COMMON CODE SECTION BEGINS HERE ***
272007 :
272008 : #if 0
272009 : int
272010 : SgLambdaRefExp::getVariant() const
272011 : {
272012 : // This function is used in ROSE while "variant()" is used in SAGE
272013 : assert(this != NULL);
272014 : return variant();
272015 : }
272016 : #endif
272017 :
272018 : // This function is used in ROSE in treeTraversal code
272019 : // eventually replaces getVariant() and variant()
272020 : // though after variant() has been removed for a while we will
272021 : // want to change the name of variantT() back to variant()
272022 : // (since the "T" was ment to stand for temporary).
272023 : // When this happens the variantT() will be depricated.
272024 : VariantT
272025 0 : SgLambdaRefExp::variantT() const
272026 : {
272027 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
272028 0 : ROSE_ASSERT(this != NULL);
272029 0 : return V_SgLambdaRefExp;
272030 : }
272031 :
272032 : #if 0
272033 : int
272034 : SgLambdaRefExp::variant() const
272035 : {
272036 : // This function is used in SAGE
272037 : ROSE_ASSERT(this != NULL);
272038 : return LAMBDA_REF_EXP;
272039 : }
272040 : #endif
272041 :
272042 : ROSE_DLL_API const char*
272043 0 : SgLambdaRefExp::sage_class_name() const
272044 : {
272045 0 : ROSE_ASSERT(this != NULL);
272046 0 : return "SgLambdaRefExp";
272047 : }
272048 :
272049 : std::string
272050 0 : SgLambdaRefExp::class_name() const
272051 : {
272052 0 : ROSE_ASSERT(this != NULL);
272053 0 : return "SgLambdaRefExp";
272054 : }
272055 :
272056 : // DQ (11/26/2005): Support for visitor pattern mechanims
272057 : // (inferior to ROSE traversal mechanism, experimental).
272058 : void
272059 0 : SgLambdaRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
272060 : {
272061 0 : ROSE_ASSERT(this != NULL);
272062 0 : visitor.visit(this);
272063 0 : }
272064 :
272065 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
272066 0 : void SgLambdaRefExp::accept (ROSE_VisitorPattern & visitor) {
272067 0 : ROSE_ASSERT(this != NULL);
272068 0 : visitor.visit(this);
272069 0 : }
272070 :
272071 : SgLambdaRefExp*
272072 0 : SgLambdaRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
272073 : {
272074 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
272075 : // This function is currently only supported for the AST used the represent Binary executables.
272076 : if (0 /* isSgAsmNode(this) != NULL */)
272077 : {
272078 : // Support for regex specification.
272079 : std::string prefixCode = "REGEX:";
272080 : addNewAttribute(prefixCode + s,a);
272081 : }
272082 : #endif
272083 :
272084 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
272085 0 : return this;
272086 : }
272087 :
272088 : // *** COMMON CODE SECTION ENDS HERE ***
272089 :
272090 :
272091 : // End of memberFunctionString
272092 : // Start of memberFunctionString
272093 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
272094 :
272095 :
272096 : #if 0
272097 : //! Error checking support
272098 : /*! Verifies the following:
272099 : - working getVariant() member function
272100 : - calls base class's error() member function
272101 : Every class has one of these functions.
272102 : */
272103 : bool
272104 : SgLambdaRefExp::error()
272105 : {
272106 : // Put error checking here
272107 :
272108 : ROSE_ASSERT (this != NULL);
272109 : if (getVariant() != LAMBDA_REF_EXP)
272110 : {
272111 : printf ("Error in SgLambdaRefExp::error(): SgLambdaRefExp object has a %s variant \n",
272112 : Cxx_GrammarTerminalNames[getVariant()].name);
272113 : // printf ("Error in SgLambdaRefExp::error() \n");
272114 : ROSE_ABORT();
272115 : }
272116 :
272117 : ROSE_ASSERT (getVariant() == LAMBDA_REF_EXP);
272118 : return SgExpression::error();
272119 : }
272120 : #endif
272121 :
272122 :
272123 :
272124 : // End of memberFunctionString
272125 :
272126 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
272127 :
272128 0 : SgLambdaRefExp* isSgLambdaRefExp ( SgNode* inputDerivedClassPointer )
272129 : {
272130 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
272131 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
272132 : // So to fix this we return NULL directly when the input is NULL and avoid the
272133 : // dynamic_cast in this case. This is likely a performance improvement as well.
272134 : // return dynamic_cast<SgLambdaRefExp*>(inputDerivedClassPointer);
272135 : // Milind Chabbi (8/28/2013): isSgLambdaRefExp uses table-driven castability instead of c++ default dynamic_cast
272136 : // this improves the running time performance by 10-20%.
272137 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLambdaRefExp*>(inputDerivedClassPointer);
272138 0 : return IS_SgLambdaRefExp_FAST_MACRO(inputDerivedClassPointer);
272139 : }
272140 :
272141 : // DQ (11/8/2003): Added version of functions taking const pointer
272142 0 : const SgLambdaRefExp* isSgLambdaRefExp ( const SgNode* inputDerivedClassPointer )
272143 : {
272144 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
272145 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
272146 : // So to fix this we return NULL directly when the input is NULL and avoid the
272147 : // dynamic_cast in this case. This is likely a performance improvement as well.
272148 : // return dynamic_cast<const SgLambdaRefExp*>(inputDerivedClassPointer);
272149 : // Milind Chabbi (8/28/2013): isSgLambdaRefExp uses table-driven castability instead of c++ default dynamic_cast
272150 : // this improves the running time performance by 10-20%.
272151 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLambdaRefExp*>(inputDerivedClassPointer);
272152 0 : return IS_SgLambdaRefExp_FAST_MACRO(inputDerivedClassPointer);
272153 : }
272154 :
272155 :
272156 :
272157 : /* #line 272158 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272158 :
272159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
272160 :
272161 : /**
272162 : \brief Generated destructor
272163 :
272164 : This destructor is automatically generated (by ROSETTA). This destructor
272165 : only frees memory of data members associated with the parts of the current IR node which
272166 : are NOT traversed. Those data members that are part of a traversal can be freed using
272167 : a traversal (calling this destructor on all children in a post-order traversal). Such
272168 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
272169 :
272170 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
272171 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
272172 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
272173 :
272174 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
272175 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
272176 : pointers are not yet implemented to call delete on eash pointer in the container.
272177 : (This could be done by derivation from the STL containers to define containers that
272178 : automatically deleted their members.)
272179 :
272180 : */
272181 0 : SgLambdaRefExp::~SgLambdaRefExp () {
272182 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
272183 :
272184 :
272185 : // case: not a listType for functionDeclaration
272186 0 : p_functionDeclaration = NULL; // non list case
272187 :
272188 : }
272189 :
272190 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
272191 0 : }
272192 :
272193 :
272194 : /* #line 272195 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272195 :
272196 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
272197 :
272198 : // Generated constructor
272199 0 : SgLambdaRefExp::SgLambdaRefExp ( Sg_File_Info* startOfConstruct, SgFunctionDeclaration* functionDeclaration )
272200 0 : : SgExpression(startOfConstruct)
272201 : {
272202 : #ifdef DEBUG
272203 : // printf ("In SgLambdaRefExp::SgLambdaRefExp (Sg_File_Info* startOfConstruct, SgFunctionDeclaration* functionDeclaration) sage_class_name() = %s \n",sage_class_name());
272204 : #endif
272205 : #if 0
272206 : // debugging information!
272207 : printf ("In SgLambdaRefExp::SgLambdaRefExp (Sg_File_Info* startOfConstruct, SgFunctionDeclaration* functionDeclaration): this = %p = %s \n",this,this->class_name().c_str());
272208 : #endif
272209 :
272210 0 : p_functionDeclaration = functionDeclaration;
272211 :
272212 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
272213 :
272214 : #if 0
272215 : // DQ (7/30/2014): Call a virtual function.
272216 : std::string s = this->class_name();
272217 : #endif
272218 :
272219 : // Test the variant virtual function
272220 : // assert(LAMBDA_REF_EXP == variant());
272221 0 : assert(LAMBDA_REF_EXP == this->variant());
272222 0 : ROSE_ASSERT(LAMBDA_REF_EXP == (int)(this->variantT()));
272223 0 : post_construction_initialization();
272224 :
272225 : // Test the isSgLambdaRefExp() function since it has been problematic
272226 0 : assert(isSgLambdaRefExp(this) != NULL);
272227 0 : }
272228 :
272229 : // Generated constructor (all data members)
272230 :
272231 : /* #line 272232 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272232 :
272233 :
272234 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
272235 :
272236 :
272237 : // ********************************************************
272238 : // member functions common across all array grammar objects
272239 : // ********************************************************
272240 :
272241 :
272242 :
272243 : /* #line 272244 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272244 :
272245 :
272246 :
272247 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
272248 :
272249 : // ********************************************************
272250 : // member functions specific to each node in the grammar
272251 : // ********************************************************
272252 :
272253 :
272254 : /* #line 272255 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272255 :
272256 : // Start of memberFunctionString
272257 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272258 :
272259 : void
272260 0 : SgDictionaryExp::post_construction_initialization()
272261 : {
272262 0 : }
272263 :
272264 :
272265 :
272266 : // End of memberFunctionString
272267 : // Start of memberFunctionString
272268 :
272269 :
272270 : // End of memberFunctionString
272271 : // Start of memberFunctionString
272272 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272273 :
272274 : SgType*
272275 :
272276 0 : SgDictionaryExp::get_type() const
272277 : {
272278 0 : ROSE_ASSERT(this != NULL);
272279 :
272280 : #if 0
272281 : printf ("In SgDictionaryExp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
272282 : #endif
272283 :
272284 : // DQ (10/31/2016): Debugging...
272285 : // return SgTypeDefault::createType();
272286 0 : SgType* returnType = SgTypeDefault::createType();
272287 :
272288 : #if 0
272289 : printf ("Leaving SgDictionaryExp::get_type() (default_get_type) returnType = %p \n",returnType);
272290 : #endif
272291 :
272292 0 : return returnType;
272293 : }
272294 :
272295 :
272296 :
272297 : // End of memberFunctionString
272298 : // Start of memberFunctionString
272299 : /* #line 7119 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272300 :
272301 :
272302 : SgKeyDatumPairPtrList&
272303 0 : SgDictionaryExp::get_key_datum_pairs()
272304 0 : { return p_key_datum_pairs; }
272305 :
272306 : const SgKeyDatumPairPtrList&
272307 0 : SgDictionaryExp::get_key_datum_pairs() const
272308 0 : { return p_key_datum_pairs; }
272309 :
272310 : void
272311 0 : SgDictionaryExp::append_pair(SgKeyDatumPair *what)
272312 0 : { what->set_parent(this); p_key_datum_pairs.push_back(what); }
272313 :
272314 :
272315 :
272316 : // End of memberFunctionString
272317 : // Start of memberFunctionString
272318 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
272319 :
272320 : // *** COMMON CODE SECTION BEGINS HERE ***
272321 :
272322 : #if 0
272323 : int
272324 : SgDictionaryExp::getVariant() const
272325 : {
272326 : // This function is used in ROSE while "variant()" is used in SAGE
272327 : assert(this != NULL);
272328 : return variant();
272329 : }
272330 : #endif
272331 :
272332 : // This function is used in ROSE in treeTraversal code
272333 : // eventually replaces getVariant() and variant()
272334 : // though after variant() has been removed for a while we will
272335 : // want to change the name of variantT() back to variant()
272336 : // (since the "T" was ment to stand for temporary).
272337 : // When this happens the variantT() will be depricated.
272338 : VariantT
272339 0 : SgDictionaryExp::variantT() const
272340 : {
272341 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
272342 0 : ROSE_ASSERT(this != NULL);
272343 0 : return V_SgDictionaryExp;
272344 : }
272345 :
272346 : #if 0
272347 : int
272348 : SgDictionaryExp::variant() const
272349 : {
272350 : // This function is used in SAGE
272351 : ROSE_ASSERT(this != NULL);
272352 : return DICT_EXP;
272353 : }
272354 : #endif
272355 :
272356 : ROSE_DLL_API const char*
272357 0 : SgDictionaryExp::sage_class_name() const
272358 : {
272359 0 : ROSE_ASSERT(this != NULL);
272360 0 : return "SgDictionaryExp";
272361 : }
272362 :
272363 : std::string
272364 0 : SgDictionaryExp::class_name() const
272365 : {
272366 0 : ROSE_ASSERT(this != NULL);
272367 0 : return "SgDictionaryExp";
272368 : }
272369 :
272370 : // DQ (11/26/2005): Support for visitor pattern mechanims
272371 : // (inferior to ROSE traversal mechanism, experimental).
272372 : void
272373 0 : SgDictionaryExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
272374 : {
272375 0 : ROSE_ASSERT(this != NULL);
272376 0 : visitor.visit(this);
272377 0 : }
272378 :
272379 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
272380 0 : void SgDictionaryExp::accept (ROSE_VisitorPattern & visitor) {
272381 0 : ROSE_ASSERT(this != NULL);
272382 0 : visitor.visit(this);
272383 0 : }
272384 :
272385 : SgDictionaryExp*
272386 0 : SgDictionaryExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
272387 : {
272388 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
272389 : // This function is currently only supported for the AST used the represent Binary executables.
272390 : if (0 /* isSgAsmNode(this) != NULL */)
272391 : {
272392 : // Support for regex specification.
272393 : std::string prefixCode = "REGEX:";
272394 : addNewAttribute(prefixCode + s,a);
272395 : }
272396 : #endif
272397 :
272398 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
272399 0 : return this;
272400 : }
272401 :
272402 : // *** COMMON CODE SECTION ENDS HERE ***
272403 :
272404 :
272405 : // End of memberFunctionString
272406 : // Start of memberFunctionString
272407 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
272408 :
272409 :
272410 : #if 0
272411 : //! Error checking support
272412 : /*! Verifies the following:
272413 : - working getVariant() member function
272414 : - calls base class's error() member function
272415 : Every class has one of these functions.
272416 : */
272417 : bool
272418 : SgDictionaryExp::error()
272419 : {
272420 : // Put error checking here
272421 :
272422 : ROSE_ASSERT (this != NULL);
272423 : if (getVariant() != DICT_EXP)
272424 : {
272425 : printf ("Error in SgDictionaryExp::error(): SgDictionaryExp object has a %s variant \n",
272426 : Cxx_GrammarTerminalNames[getVariant()].name);
272427 : // printf ("Error in SgDictionaryExp::error() \n");
272428 : ROSE_ABORT();
272429 : }
272430 :
272431 : ROSE_ASSERT (getVariant() == DICT_EXP);
272432 : return SgExpression::error();
272433 : }
272434 : #endif
272435 :
272436 :
272437 :
272438 : // End of memberFunctionString
272439 :
272440 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
272441 :
272442 0 : SgDictionaryExp* isSgDictionaryExp ( SgNode* inputDerivedClassPointer )
272443 : {
272444 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
272445 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
272446 : // So to fix this we return NULL directly when the input is NULL and avoid the
272447 : // dynamic_cast in this case. This is likely a performance improvement as well.
272448 : // return dynamic_cast<SgDictionaryExp*>(inputDerivedClassPointer);
272449 : // Milind Chabbi (8/28/2013): isSgDictionaryExp uses table-driven castability instead of c++ default dynamic_cast
272450 : // this improves the running time performance by 10-20%.
272451 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDictionaryExp*>(inputDerivedClassPointer);
272452 0 : return IS_SgDictionaryExp_FAST_MACRO(inputDerivedClassPointer);
272453 : }
272454 :
272455 : // DQ (11/8/2003): Added version of functions taking const pointer
272456 0 : const SgDictionaryExp* isSgDictionaryExp ( const SgNode* inputDerivedClassPointer )
272457 : {
272458 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
272459 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
272460 : // So to fix this we return NULL directly when the input is NULL and avoid the
272461 : // dynamic_cast in this case. This is likely a performance improvement as well.
272462 : // return dynamic_cast<const SgDictionaryExp*>(inputDerivedClassPointer);
272463 : // Milind Chabbi (8/28/2013): isSgDictionaryExp uses table-driven castability instead of c++ default dynamic_cast
272464 : // this improves the running time performance by 10-20%.
272465 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDictionaryExp*>(inputDerivedClassPointer);
272466 0 : return IS_SgDictionaryExp_FAST_MACRO(inputDerivedClassPointer);
272467 : }
272468 :
272469 :
272470 :
272471 : /* #line 272472 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272472 :
272473 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
272474 :
272475 : /**
272476 : \brief Generated destructor
272477 :
272478 : This destructor is automatically generated (by ROSETTA). This destructor
272479 : only frees memory of data members associated with the parts of the current IR node which
272480 : are NOT traversed. Those data members that are part of a traversal can be freed using
272481 : a traversal (calling this destructor on all children in a post-order traversal). Such
272482 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
272483 :
272484 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
272485 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
272486 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
272487 :
272488 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
272489 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
272490 : pointers are not yet implemented to call delete on eash pointer in the container.
272491 : (This could be done by derivation from the STL containers to define containers that
272492 : automatically deleted their members.)
272493 :
272494 : */
272495 0 : SgDictionaryExp::~SgDictionaryExp () {
272496 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
272497 :
272498 :
272499 :
272500 : }
272501 :
272502 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
272503 0 : }
272504 :
272505 :
272506 : /* #line 272507 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272507 :
272508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
272509 :
272510 : // Generated constructor
272511 0 : SgDictionaryExp::SgDictionaryExp ( Sg_File_Info* startOfConstruct )
272512 0 : : SgExpression(startOfConstruct)
272513 : {
272514 : #ifdef DEBUG
272515 : // printf ("In SgDictionaryExp::SgDictionaryExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
272516 : #endif
272517 : #if 0
272518 : // debugging information!
272519 : printf ("In SgDictionaryExp::SgDictionaryExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
272520 : #endif
272521 :
272522 :
272523 :
272524 : #if 0
272525 : // DQ (7/30/2014): Call a virtual function.
272526 : std::string s = this->class_name();
272527 : #endif
272528 :
272529 : // Test the variant virtual function
272530 : // assert(DICT_EXP == variant());
272531 0 : assert(DICT_EXP == this->variant());
272532 0 : ROSE_ASSERT(DICT_EXP == (int)(this->variantT()));
272533 0 : post_construction_initialization();
272534 :
272535 : // Test the isSgDictionaryExp() function since it has been problematic
272536 0 : assert(isSgDictionaryExp(this) != NULL);
272537 0 : }
272538 :
272539 : // Generated constructor (all data members)
272540 :
272541 : /* #line 272542 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272542 :
272543 :
272544 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
272545 :
272546 :
272547 : // ********************************************************
272548 : // member functions common across all array grammar objects
272549 : // ********************************************************
272550 :
272551 :
272552 :
272553 : /* #line 272554 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272554 :
272555 :
272556 :
272557 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
272558 :
272559 : // ********************************************************
272560 : // member functions specific to each node in the grammar
272561 : // ********************************************************
272562 :
272563 :
272564 : /* #line 272565 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272565 :
272566 : // Start of memberFunctionString
272567 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272568 :
272569 : void
272570 0 : SgKeyDatumPair::post_construction_initialization()
272571 : {
272572 0 : }
272573 :
272574 :
272575 :
272576 : // End of memberFunctionString
272577 : // Start of memberFunctionString
272578 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
272579 :
272580 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
272581 :
272582 : SgExpression*
272583 0 : SgKeyDatumPair::get_key () const
272584 : {
272585 0 : ROSE_ASSERT (this != NULL);
272586 :
272587 : #if 0
272588 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
272589 : // used to trigger marking transformations for the token-based unparsing.
272590 : printf ("SgKeyDatumPair::get_key = %p = %s \n",this,this->class_name().c_str());
272591 : #endif
272592 :
272593 0 : return p_key;
272594 : }
272595 :
272596 : void
272597 0 : SgKeyDatumPair::set_key ( SgExpression* key )
272598 : {
272599 0 : ROSE_ASSERT (this != NULL);
272600 :
272601 : #if 0
272602 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
272603 : // used to trigger marking transformations for the token-based unparsing.
272604 : printf ("SgKeyDatumPair::set_key = %p = %s \n",this,this->class_name().c_str());
272605 : #endif
272606 :
272607 0 : set_isModified(true);
272608 :
272609 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
272610 : if (p_key != NULL && key != NULL && p_key != key)
272611 : {
272612 : printf ("Warning: key = %p overwriting valid pointer p_key = %p \n",key,p_key);
272613 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
272614 : printf ("Error fails assertion (p_key != NULL && key != NULL && p_key != key) is false\n");
272615 : ROSE_ASSERT(false);
272616 : #endif
272617 : }
272618 : #endif
272619 0 : p_key = key;
272620 0 : }
272621 :
272622 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
272623 :
272624 :
272625 : // End of memberFunctionString
272626 : // Start of memberFunctionString
272627 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
272628 :
272629 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
272630 :
272631 : SgExpression*
272632 0 : SgKeyDatumPair::get_datum () const
272633 : {
272634 0 : ROSE_ASSERT (this != NULL);
272635 :
272636 : #if 0
272637 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
272638 : // used to trigger marking transformations for the token-based unparsing.
272639 : printf ("SgKeyDatumPair::get_datum = %p = %s \n",this,this->class_name().c_str());
272640 : #endif
272641 :
272642 0 : return p_datum;
272643 : }
272644 :
272645 : void
272646 0 : SgKeyDatumPair::set_datum ( SgExpression* datum )
272647 : {
272648 0 : ROSE_ASSERT (this != NULL);
272649 :
272650 : #if 0
272651 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
272652 : // used to trigger marking transformations for the token-based unparsing.
272653 : printf ("SgKeyDatumPair::set_datum = %p = %s \n",this,this->class_name().c_str());
272654 : #endif
272655 :
272656 0 : set_isModified(true);
272657 :
272658 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
272659 : if (p_datum != NULL && datum != NULL && p_datum != datum)
272660 : {
272661 : printf ("Warning: datum = %p overwriting valid pointer p_datum = %p \n",datum,p_datum);
272662 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
272663 : printf ("Error fails assertion (p_datum != NULL && datum != NULL && p_datum != datum) is false\n");
272664 : ROSE_ASSERT(false);
272665 : #endif
272666 : }
272667 : #endif
272668 0 : p_datum = datum;
272669 0 : }
272670 :
272671 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
272672 :
272673 :
272674 : // End of memberFunctionString
272675 : // Start of memberFunctionString
272676 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272677 :
272678 : SgType*
272679 :
272680 0 : SgKeyDatumPair::get_type() const
272681 : {
272682 0 : ROSE_ASSERT(this != NULL);
272683 :
272684 : #if 0
272685 : printf ("In SgKeyDatumPair::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
272686 : #endif
272687 :
272688 : // DQ (10/31/2016): Debugging...
272689 : // return SgTypeDefault::createType();
272690 0 : SgType* returnType = SgTypeDefault::createType();
272691 :
272692 : #if 0
272693 : printf ("Leaving SgKeyDatumPair::get_type() (default_get_type) returnType = %p \n",returnType);
272694 : #endif
272695 :
272696 0 : return returnType;
272697 : }
272698 :
272699 :
272700 :
272701 : // End of memberFunctionString
272702 : // Start of memberFunctionString
272703 : /* #line 7135 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272704 :
272705 :
272706 :
272707 : // End of memberFunctionString
272708 : // Start of memberFunctionString
272709 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
272710 :
272711 : // *** COMMON CODE SECTION BEGINS HERE ***
272712 :
272713 : #if 0
272714 : int
272715 : SgKeyDatumPair::getVariant() const
272716 : {
272717 : // This function is used in ROSE while "variant()" is used in SAGE
272718 : assert(this != NULL);
272719 : return variant();
272720 : }
272721 : #endif
272722 :
272723 : // This function is used in ROSE in treeTraversal code
272724 : // eventually replaces getVariant() and variant()
272725 : // though after variant() has been removed for a while we will
272726 : // want to change the name of variantT() back to variant()
272727 : // (since the "T" was ment to stand for temporary).
272728 : // When this happens the variantT() will be depricated.
272729 : VariantT
272730 0 : SgKeyDatumPair::variantT() const
272731 : {
272732 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
272733 0 : ROSE_ASSERT(this != NULL);
272734 0 : return V_SgKeyDatumPair;
272735 : }
272736 :
272737 : #if 0
272738 : int
272739 : SgKeyDatumPair::variant() const
272740 : {
272741 : // This function is used in SAGE
272742 : ROSE_ASSERT(this != NULL);
272743 : return KEY_DATUM_PAIR;
272744 : }
272745 : #endif
272746 :
272747 : ROSE_DLL_API const char*
272748 0 : SgKeyDatumPair::sage_class_name() const
272749 : {
272750 0 : ROSE_ASSERT(this != NULL);
272751 0 : return "SgKeyDatumPair";
272752 : }
272753 :
272754 : std::string
272755 0 : SgKeyDatumPair::class_name() const
272756 : {
272757 0 : ROSE_ASSERT(this != NULL);
272758 0 : return "SgKeyDatumPair";
272759 : }
272760 :
272761 : // DQ (11/26/2005): Support for visitor pattern mechanims
272762 : // (inferior to ROSE traversal mechanism, experimental).
272763 : void
272764 0 : SgKeyDatumPair::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
272765 : {
272766 0 : ROSE_ASSERT(this != NULL);
272767 0 : visitor.visit(this);
272768 0 : }
272769 :
272770 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
272771 0 : void SgKeyDatumPair::accept (ROSE_VisitorPattern & visitor) {
272772 0 : ROSE_ASSERT(this != NULL);
272773 0 : visitor.visit(this);
272774 0 : }
272775 :
272776 : SgKeyDatumPair*
272777 0 : SgKeyDatumPair::addRegExpAttribute(std::string s, AstRegExAttribute* a)
272778 : {
272779 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
272780 : // This function is currently only supported for the AST used the represent Binary executables.
272781 : if (0 /* isSgAsmNode(this) != NULL */)
272782 : {
272783 : // Support for regex specification.
272784 : std::string prefixCode = "REGEX:";
272785 : addNewAttribute(prefixCode + s,a);
272786 : }
272787 : #endif
272788 :
272789 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
272790 0 : return this;
272791 : }
272792 :
272793 : // *** COMMON CODE SECTION ENDS HERE ***
272794 :
272795 :
272796 : // End of memberFunctionString
272797 : // Start of memberFunctionString
272798 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
272799 :
272800 :
272801 : #if 0
272802 : //! Error checking support
272803 : /*! Verifies the following:
272804 : - working getVariant() member function
272805 : - calls base class's error() member function
272806 : Every class has one of these functions.
272807 : */
272808 : bool
272809 : SgKeyDatumPair::error()
272810 : {
272811 : // Put error checking here
272812 :
272813 : ROSE_ASSERT (this != NULL);
272814 : if (getVariant() != KEY_DATUM_PAIR)
272815 : {
272816 : printf ("Error in SgKeyDatumPair::error(): SgKeyDatumPair object has a %s variant \n",
272817 : Cxx_GrammarTerminalNames[getVariant()].name);
272818 : // printf ("Error in SgKeyDatumPair::error() \n");
272819 : ROSE_ABORT();
272820 : }
272821 :
272822 : ROSE_ASSERT (getVariant() == KEY_DATUM_PAIR);
272823 : return SgExpression::error();
272824 : }
272825 : #endif
272826 :
272827 :
272828 :
272829 : // End of memberFunctionString
272830 :
272831 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
272832 :
272833 0 : SgKeyDatumPair* isSgKeyDatumPair ( SgNode* inputDerivedClassPointer )
272834 : {
272835 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
272836 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
272837 : // So to fix this we return NULL directly when the input is NULL and avoid the
272838 : // dynamic_cast in this case. This is likely a performance improvement as well.
272839 : // return dynamic_cast<SgKeyDatumPair*>(inputDerivedClassPointer);
272840 : // Milind Chabbi (8/28/2013): isSgKeyDatumPair uses table-driven castability instead of c++ default dynamic_cast
272841 : // this improves the running time performance by 10-20%.
272842 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgKeyDatumPair*>(inputDerivedClassPointer);
272843 0 : return IS_SgKeyDatumPair_FAST_MACRO(inputDerivedClassPointer);
272844 : }
272845 :
272846 : // DQ (11/8/2003): Added version of functions taking const pointer
272847 0 : const SgKeyDatumPair* isSgKeyDatumPair ( const SgNode* inputDerivedClassPointer )
272848 : {
272849 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
272850 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
272851 : // So to fix this we return NULL directly when the input is NULL and avoid the
272852 : // dynamic_cast in this case. This is likely a performance improvement as well.
272853 : // return dynamic_cast<const SgKeyDatumPair*>(inputDerivedClassPointer);
272854 : // Milind Chabbi (8/28/2013): isSgKeyDatumPair uses table-driven castability instead of c++ default dynamic_cast
272855 : // this improves the running time performance by 10-20%.
272856 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgKeyDatumPair*>(inputDerivedClassPointer);
272857 0 : return IS_SgKeyDatumPair_FAST_MACRO(inputDerivedClassPointer);
272858 : }
272859 :
272860 :
272861 :
272862 : /* #line 272863 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272863 :
272864 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
272865 :
272866 : /**
272867 : \brief Generated destructor
272868 :
272869 : This destructor is automatically generated (by ROSETTA). This destructor
272870 : only frees memory of data members associated with the parts of the current IR node which
272871 : are NOT traversed. Those data members that are part of a traversal can be freed using
272872 : a traversal (calling this destructor on all children in a post-order traversal). Such
272873 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
272874 :
272875 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
272876 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
272877 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
272878 :
272879 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
272880 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
272881 : pointers are not yet implemented to call delete on eash pointer in the container.
272882 : (This could be done by derivation from the STL containers to define containers that
272883 : automatically deleted their members.)
272884 :
272885 : */
272886 0 : SgKeyDatumPair::~SgKeyDatumPair () {
272887 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
272888 :
272889 :
272890 : // case: not a listType for key
272891 0 : p_key = NULL; // non list case
272892 : // case: not a listType for datum
272893 0 : p_datum = NULL; // non list case
272894 :
272895 : }
272896 :
272897 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
272898 0 : }
272899 :
272900 :
272901 : /* #line 272902 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272902 :
272903 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
272904 :
272905 : // Generated constructor
272906 0 : SgKeyDatumPair::SgKeyDatumPair ( Sg_File_Info* startOfConstruct, SgExpression* key, SgExpression* datum )
272907 0 : : SgExpression(startOfConstruct)
272908 : {
272909 : #ifdef DEBUG
272910 : // printf ("In SgKeyDatumPair::SgKeyDatumPair (Sg_File_Info* startOfConstruct, SgExpression* key, SgExpression* datum) sage_class_name() = %s \n",sage_class_name());
272911 : #endif
272912 : #if 0
272913 : // debugging information!
272914 : printf ("In SgKeyDatumPair::SgKeyDatumPair (Sg_File_Info* startOfConstruct, SgExpression* key, SgExpression* datum): this = %p = %s \n",this,this->class_name().c_str());
272915 : #endif
272916 :
272917 0 : p_key = key;
272918 0 : p_datum = datum;
272919 :
272920 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
272921 :
272922 : #if 0
272923 : // DQ (7/30/2014): Call a virtual function.
272924 : std::string s = this->class_name();
272925 : #endif
272926 :
272927 : // Test the variant virtual function
272928 : // assert(KEY_DATUM_PAIR == variant());
272929 0 : assert(KEY_DATUM_PAIR == this->variant());
272930 0 : ROSE_ASSERT(KEY_DATUM_PAIR == (int)(this->variantT()));
272931 0 : post_construction_initialization();
272932 :
272933 : // Test the isSgKeyDatumPair() function since it has been problematic
272934 0 : assert(isSgKeyDatumPair(this) != NULL);
272935 0 : }
272936 :
272937 : // Generated constructor (all data members)
272938 :
272939 : /* #line 272940 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272940 :
272941 :
272942 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
272943 :
272944 :
272945 : // ********************************************************
272946 : // member functions common across all array grammar objects
272947 : // ********************************************************
272948 :
272949 :
272950 :
272951 : /* #line 272952 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272952 :
272953 :
272954 :
272955 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
272956 :
272957 : // ********************************************************
272958 : // member functions specific to each node in the grammar
272959 : // ********************************************************
272960 :
272961 :
272962 : /* #line 272963 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
272963 :
272964 : // Start of memberFunctionString
272965 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
272966 :
272967 : void
272968 0 : SgComprehension::post_construction_initialization()
272969 : {
272970 0 : }
272971 :
272972 :
272973 :
272974 : // End of memberFunctionString
272975 : // Start of memberFunctionString
272976 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
272977 :
272978 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
272979 :
272980 : SgExpression*
272981 0 : SgComprehension::get_target () const
272982 : {
272983 0 : ROSE_ASSERT (this != NULL);
272984 :
272985 : #if 0
272986 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
272987 : // used to trigger marking transformations for the token-based unparsing.
272988 : printf ("SgComprehension::get_target = %p = %s \n",this,this->class_name().c_str());
272989 : #endif
272990 :
272991 0 : return p_target;
272992 : }
272993 :
272994 : void
272995 0 : SgComprehension::set_target ( SgExpression* target )
272996 : {
272997 0 : ROSE_ASSERT (this != NULL);
272998 :
272999 : #if 0
273000 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273001 : // used to trigger marking transformations for the token-based unparsing.
273002 : printf ("SgComprehension::set_target = %p = %s \n",this,this->class_name().c_str());
273003 : #endif
273004 :
273005 0 : set_isModified(true);
273006 :
273007 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273008 : if (p_target != NULL && target != NULL && p_target != target)
273009 : {
273010 : printf ("Warning: target = %p overwriting valid pointer p_target = %p \n",target,p_target);
273011 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273012 : printf ("Error fails assertion (p_target != NULL && target != NULL && p_target != target) is false\n");
273013 : ROSE_ASSERT(false);
273014 : #endif
273015 : }
273016 : #endif
273017 0 : p_target = target;
273018 0 : }
273019 :
273020 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273021 :
273022 :
273023 : // End of memberFunctionString
273024 : // Start of memberFunctionString
273025 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
273026 :
273027 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
273028 :
273029 : SgExpression*
273030 0 : SgComprehension::get_iter () const
273031 : {
273032 0 : ROSE_ASSERT (this != NULL);
273033 :
273034 : #if 0
273035 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273036 : // used to trigger marking transformations for the token-based unparsing.
273037 : printf ("SgComprehension::get_iter = %p = %s \n",this,this->class_name().c_str());
273038 : #endif
273039 :
273040 0 : return p_iter;
273041 : }
273042 :
273043 : void
273044 0 : SgComprehension::set_iter ( SgExpression* iter )
273045 : {
273046 0 : ROSE_ASSERT (this != NULL);
273047 :
273048 : #if 0
273049 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273050 : // used to trigger marking transformations for the token-based unparsing.
273051 : printf ("SgComprehension::set_iter = %p = %s \n",this,this->class_name().c_str());
273052 : #endif
273053 :
273054 0 : set_isModified(true);
273055 :
273056 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273057 : if (p_iter != NULL && iter != NULL && p_iter != iter)
273058 : {
273059 : printf ("Warning: iter = %p overwriting valid pointer p_iter = %p \n",iter,p_iter);
273060 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273061 : printf ("Error fails assertion (p_iter != NULL && iter != NULL && p_iter != iter) is false\n");
273062 : ROSE_ASSERT(false);
273063 : #endif
273064 : }
273065 : #endif
273066 0 : p_iter = iter;
273067 0 : }
273068 :
273069 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273070 :
273071 :
273072 : // End of memberFunctionString
273073 : // Start of memberFunctionString
273074 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
273075 :
273076 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
273077 :
273078 : SgExprListExp*
273079 0 : SgComprehension::get_filters () const
273080 : {
273081 0 : ROSE_ASSERT (this != NULL);
273082 :
273083 : #if 0
273084 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273085 : // used to trigger marking transformations for the token-based unparsing.
273086 : printf ("SgComprehension::get_filters = %p = %s \n",this,this->class_name().c_str());
273087 : #endif
273088 :
273089 0 : return p_filters;
273090 : }
273091 :
273092 : void
273093 0 : SgComprehension::set_filters ( SgExprListExp* filters )
273094 : {
273095 0 : ROSE_ASSERT (this != NULL);
273096 :
273097 : #if 0
273098 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273099 : // used to trigger marking transformations for the token-based unparsing.
273100 : printf ("SgComprehension::set_filters = %p = %s \n",this,this->class_name().c_str());
273101 : #endif
273102 :
273103 0 : set_isModified(true);
273104 :
273105 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273106 : if (p_filters != NULL && filters != NULL && p_filters != filters)
273107 : {
273108 : printf ("Warning: filters = %p overwriting valid pointer p_filters = %p \n",filters,p_filters);
273109 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273110 : printf ("Error fails assertion (p_filters != NULL && filters != NULL && p_filters != filters) is false\n");
273111 : ROSE_ASSERT(false);
273112 : #endif
273113 : }
273114 : #endif
273115 0 : p_filters = filters;
273116 0 : }
273117 :
273118 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273119 :
273120 :
273121 : // End of memberFunctionString
273122 : // Start of memberFunctionString
273123 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273124 :
273125 : SgType*
273126 :
273127 0 : SgComprehension::get_type() const
273128 : {
273129 0 : ROSE_ASSERT(this != NULL);
273130 :
273131 : #if 0
273132 : printf ("In SgComprehension::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
273133 : #endif
273134 :
273135 : // DQ (10/31/2016): Debugging...
273136 : // return SgTypeDefault::createType();
273137 0 : SgType* returnType = SgTypeDefault::createType();
273138 :
273139 : #if 0
273140 : printf ("Leaving SgComprehension::get_type() (default_get_type) returnType = %p \n",returnType);
273141 : #endif
273142 :
273143 0 : return returnType;
273144 : }
273145 :
273146 :
273147 :
273148 : // End of memberFunctionString
273149 : // Start of memberFunctionString
273150 : /* #line 7107 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273151 :
273152 :
273153 :
273154 : // End of memberFunctionString
273155 : // Start of memberFunctionString
273156 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
273157 :
273158 : // *** COMMON CODE SECTION BEGINS HERE ***
273159 :
273160 : #if 0
273161 : int
273162 : SgComprehension::getVariant() const
273163 : {
273164 : // This function is used in ROSE while "variant()" is used in SAGE
273165 : assert(this != NULL);
273166 : return variant();
273167 : }
273168 : #endif
273169 :
273170 : // This function is used in ROSE in treeTraversal code
273171 : // eventually replaces getVariant() and variant()
273172 : // though after variant() has been removed for a while we will
273173 : // want to change the name of variantT() back to variant()
273174 : // (since the "T" was ment to stand for temporary).
273175 : // When this happens the variantT() will be depricated.
273176 : VariantT
273177 0 : SgComprehension::variantT() const
273178 : {
273179 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
273180 0 : ROSE_ASSERT(this != NULL);
273181 0 : return V_SgComprehension;
273182 : }
273183 :
273184 : #if 0
273185 : int
273186 : SgComprehension::variant() const
273187 : {
273188 : // This function is used in SAGE
273189 : ROSE_ASSERT(this != NULL);
273190 : return COMPREHENSION;
273191 : }
273192 : #endif
273193 :
273194 : ROSE_DLL_API const char*
273195 0 : SgComprehension::sage_class_name() const
273196 : {
273197 0 : ROSE_ASSERT(this != NULL);
273198 0 : return "SgComprehension";
273199 : }
273200 :
273201 : std::string
273202 0 : SgComprehension::class_name() const
273203 : {
273204 0 : ROSE_ASSERT(this != NULL);
273205 0 : return "SgComprehension";
273206 : }
273207 :
273208 : // DQ (11/26/2005): Support for visitor pattern mechanims
273209 : // (inferior to ROSE traversal mechanism, experimental).
273210 : void
273211 0 : SgComprehension::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
273212 : {
273213 0 : ROSE_ASSERT(this != NULL);
273214 0 : visitor.visit(this);
273215 0 : }
273216 :
273217 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
273218 0 : void SgComprehension::accept (ROSE_VisitorPattern & visitor) {
273219 0 : ROSE_ASSERT(this != NULL);
273220 0 : visitor.visit(this);
273221 0 : }
273222 :
273223 : SgComprehension*
273224 0 : SgComprehension::addRegExpAttribute(std::string s, AstRegExAttribute* a)
273225 : {
273226 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
273227 : // This function is currently only supported for the AST used the represent Binary executables.
273228 : if (0 /* isSgAsmNode(this) != NULL */)
273229 : {
273230 : // Support for regex specification.
273231 : std::string prefixCode = "REGEX:";
273232 : addNewAttribute(prefixCode + s,a);
273233 : }
273234 : #endif
273235 :
273236 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
273237 0 : return this;
273238 : }
273239 :
273240 : // *** COMMON CODE SECTION ENDS HERE ***
273241 :
273242 :
273243 : // End of memberFunctionString
273244 : // Start of memberFunctionString
273245 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
273246 :
273247 :
273248 : #if 0
273249 : //! Error checking support
273250 : /*! Verifies the following:
273251 : - working getVariant() member function
273252 : - calls base class's error() member function
273253 : Every class has one of these functions.
273254 : */
273255 : bool
273256 : SgComprehension::error()
273257 : {
273258 : // Put error checking here
273259 :
273260 : ROSE_ASSERT (this != NULL);
273261 : if (getVariant() != COMPREHENSION)
273262 : {
273263 : printf ("Error in SgComprehension::error(): SgComprehension object has a %s variant \n",
273264 : Cxx_GrammarTerminalNames[getVariant()].name);
273265 : // printf ("Error in SgComprehension::error() \n");
273266 : ROSE_ABORT();
273267 : }
273268 :
273269 : ROSE_ASSERT (getVariant() == COMPREHENSION);
273270 : return SgExpression::error();
273271 : }
273272 : #endif
273273 :
273274 :
273275 :
273276 : // End of memberFunctionString
273277 :
273278 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
273279 :
273280 0 : SgComprehension* isSgComprehension ( SgNode* inputDerivedClassPointer )
273281 : {
273282 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
273283 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
273284 : // So to fix this we return NULL directly when the input is NULL and avoid the
273285 : // dynamic_cast in this case. This is likely a performance improvement as well.
273286 : // return dynamic_cast<SgComprehension*>(inputDerivedClassPointer);
273287 : // Milind Chabbi (8/28/2013): isSgComprehension uses table-driven castability instead of c++ default dynamic_cast
273288 : // this improves the running time performance by 10-20%.
273289 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgComprehension*>(inputDerivedClassPointer);
273290 0 : return IS_SgComprehension_FAST_MACRO(inputDerivedClassPointer);
273291 : }
273292 :
273293 : // DQ (11/8/2003): Added version of functions taking const pointer
273294 0 : const SgComprehension* isSgComprehension ( const SgNode* inputDerivedClassPointer )
273295 : {
273296 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
273297 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
273298 : // So to fix this we return NULL directly when the input is NULL and avoid the
273299 : // dynamic_cast in this case. This is likely a performance improvement as well.
273300 : // return dynamic_cast<const SgComprehension*>(inputDerivedClassPointer);
273301 : // Milind Chabbi (8/28/2013): isSgComprehension uses table-driven castability instead of c++ default dynamic_cast
273302 : // this improves the running time performance by 10-20%.
273303 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgComprehension*>(inputDerivedClassPointer);
273304 0 : return IS_SgComprehension_FAST_MACRO(inputDerivedClassPointer);
273305 : }
273306 :
273307 :
273308 :
273309 : /* #line 273310 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273310 :
273311 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
273312 :
273313 : /**
273314 : \brief Generated destructor
273315 :
273316 : This destructor is automatically generated (by ROSETTA). This destructor
273317 : only frees memory of data members associated with the parts of the current IR node which
273318 : are NOT traversed. Those data members that are part of a traversal can be freed using
273319 : a traversal (calling this destructor on all children in a post-order traversal). Such
273320 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
273321 :
273322 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
273323 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
273324 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
273325 :
273326 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
273327 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
273328 : pointers are not yet implemented to call delete on eash pointer in the container.
273329 : (This could be done by derivation from the STL containers to define containers that
273330 : automatically deleted their members.)
273331 :
273332 : */
273333 0 : SgComprehension::~SgComprehension () {
273334 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
273335 :
273336 :
273337 : // case: not a listType for target
273338 0 : p_target = NULL; // non list case
273339 : // case: not a listType for iter
273340 0 : p_iter = NULL; // non list case
273341 : // case: not a listType for filters
273342 0 : p_filters = NULL; // non list case
273343 :
273344 : }
273345 :
273346 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
273347 0 : }
273348 :
273349 :
273350 : /* #line 273351 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273351 :
273352 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
273353 :
273354 : // Generated constructor
273355 0 : SgComprehension::SgComprehension ( Sg_File_Info* startOfConstruct, SgExpression* target, SgExpression* iter, SgExprListExp* filters )
273356 0 : : SgExpression(startOfConstruct)
273357 : {
273358 : #ifdef DEBUG
273359 : // printf ("In SgComprehension::SgComprehension (Sg_File_Info* startOfConstruct, SgExpression* target, SgExpression* iter, SgExprListExp* filters) sage_class_name() = %s \n",sage_class_name());
273360 : #endif
273361 : #if 0
273362 : // debugging information!
273363 : printf ("In SgComprehension::SgComprehension (Sg_File_Info* startOfConstruct, SgExpression* target, SgExpression* iter, SgExprListExp* filters): this = %p = %s \n",this,this->class_name().c_str());
273364 : #endif
273365 :
273366 0 : p_target = target;
273367 0 : p_iter = iter;
273368 0 : p_filters = filters;
273369 :
273370 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
273371 :
273372 : #if 0
273373 : // DQ (7/30/2014): Call a virtual function.
273374 : std::string s = this->class_name();
273375 : #endif
273376 :
273377 : // Test the variant virtual function
273378 : // assert(COMPREHENSION == variant());
273379 0 : assert(COMPREHENSION == this->variant());
273380 0 : ROSE_ASSERT(COMPREHENSION == (int)(this->variantT()));
273381 0 : post_construction_initialization();
273382 :
273383 : // Test the isSgComprehension() function since it has been problematic
273384 0 : assert(isSgComprehension(this) != NULL);
273385 0 : }
273386 :
273387 : // Generated constructor (all data members)
273388 :
273389 : /* #line 273390 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273390 :
273391 :
273392 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
273393 :
273394 :
273395 : // ********************************************************
273396 : // member functions common across all array grammar objects
273397 : // ********************************************************
273398 :
273399 :
273400 :
273401 : /* #line 273402 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273402 :
273403 :
273404 :
273405 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
273406 :
273407 : // ********************************************************
273408 : // member functions specific to each node in the grammar
273409 : // ********************************************************
273410 :
273411 :
273412 : /* #line 273413 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273413 :
273414 : // Start of memberFunctionString
273415 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273416 :
273417 : void
273418 0 : SgListComprehension::post_construction_initialization()
273419 : {
273420 0 : }
273421 :
273422 :
273423 :
273424 : // End of memberFunctionString
273425 : // Start of memberFunctionString
273426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
273427 :
273428 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
273429 :
273430 : SgExpression*
273431 0 : SgListComprehension::get_element () const
273432 : {
273433 0 : ROSE_ASSERT (this != NULL);
273434 :
273435 : #if 0
273436 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273437 : // used to trigger marking transformations for the token-based unparsing.
273438 : printf ("SgListComprehension::get_element = %p = %s \n",this,this->class_name().c_str());
273439 : #endif
273440 :
273441 0 : return p_element;
273442 : }
273443 :
273444 : void
273445 0 : SgListComprehension::set_element ( SgExpression* element )
273446 : {
273447 0 : ROSE_ASSERT (this != NULL);
273448 :
273449 : #if 0
273450 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273451 : // used to trigger marking transformations for the token-based unparsing.
273452 : printf ("SgListComprehension::set_element = %p = %s \n",this,this->class_name().c_str());
273453 : #endif
273454 :
273455 0 : set_isModified(true);
273456 :
273457 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273458 : if (p_element != NULL && element != NULL && p_element != element)
273459 : {
273460 : printf ("Warning: element = %p overwriting valid pointer p_element = %p \n",element,p_element);
273461 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273462 : printf ("Error fails assertion (p_element != NULL && element != NULL && p_element != element) is false\n");
273463 : ROSE_ASSERT(false);
273464 : #endif
273465 : }
273466 : #endif
273467 0 : p_element = element;
273468 0 : }
273469 :
273470 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273471 :
273472 :
273473 : // End of memberFunctionString
273474 : // Start of memberFunctionString
273475 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
273476 :
273477 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
273478 :
273479 : SgExprListExp*
273480 0 : SgListComprehension::get_generators () const
273481 : {
273482 0 : ROSE_ASSERT (this != NULL);
273483 :
273484 : #if 0
273485 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273486 : // used to trigger marking transformations for the token-based unparsing.
273487 : printf ("SgListComprehension::get_generators = %p = %s \n",this,this->class_name().c_str());
273488 : #endif
273489 :
273490 0 : return p_generators;
273491 : }
273492 :
273493 : void
273494 0 : SgListComprehension::set_generators ( SgExprListExp* generators )
273495 : {
273496 0 : ROSE_ASSERT (this != NULL);
273497 :
273498 : #if 0
273499 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273500 : // used to trigger marking transformations for the token-based unparsing.
273501 : printf ("SgListComprehension::set_generators = %p = %s \n",this,this->class_name().c_str());
273502 : #endif
273503 :
273504 0 : set_isModified(true);
273505 :
273506 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273507 : if (p_generators != NULL && generators != NULL && p_generators != generators)
273508 : {
273509 : printf ("Warning: generators = %p overwriting valid pointer p_generators = %p \n",generators,p_generators);
273510 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273511 : printf ("Error fails assertion (p_generators != NULL && generators != NULL && p_generators != generators) is false\n");
273512 : ROSE_ASSERT(false);
273513 : #endif
273514 : }
273515 : #endif
273516 0 : p_generators = generators;
273517 0 : }
273518 :
273519 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273520 :
273521 :
273522 : // End of memberFunctionString
273523 : // Start of memberFunctionString
273524 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273525 :
273526 : SgType*
273527 :
273528 0 : SgListComprehension::get_type() const
273529 : {
273530 0 : ROSE_ASSERT(this != NULL);
273531 :
273532 : #if 0
273533 : printf ("In SgListComprehension::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
273534 : #endif
273535 :
273536 : // DQ (10/31/2016): Debugging...
273537 : // return SgTypeDefault::createType();
273538 0 : SgType* returnType = SgTypeDefault::createType();
273539 :
273540 : #if 0
273541 : printf ("Leaving SgListComprehension::get_type() (default_get_type) returnType = %p \n",returnType);
273542 : #endif
273543 :
273544 0 : return returnType;
273545 : }
273546 :
273547 :
273548 :
273549 : // End of memberFunctionString
273550 : // Start of memberFunctionString
273551 : /* #line 7110 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273552 :
273553 :
273554 :
273555 : // End of memberFunctionString
273556 : // Start of memberFunctionString
273557 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
273558 :
273559 : // *** COMMON CODE SECTION BEGINS HERE ***
273560 :
273561 : #if 0
273562 : int
273563 : SgListComprehension::getVariant() const
273564 : {
273565 : // This function is used in ROSE while "variant()" is used in SAGE
273566 : assert(this != NULL);
273567 : return variant();
273568 : }
273569 : #endif
273570 :
273571 : // This function is used in ROSE in treeTraversal code
273572 : // eventually replaces getVariant() and variant()
273573 : // though after variant() has been removed for a while we will
273574 : // want to change the name of variantT() back to variant()
273575 : // (since the "T" was ment to stand for temporary).
273576 : // When this happens the variantT() will be depricated.
273577 : VariantT
273578 0 : SgListComprehension::variantT() const
273579 : {
273580 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
273581 0 : ROSE_ASSERT(this != NULL);
273582 0 : return V_SgListComprehension;
273583 : }
273584 :
273585 : #if 0
273586 : int
273587 : SgListComprehension::variant() const
273588 : {
273589 : // This function is used in SAGE
273590 : ROSE_ASSERT(this != NULL);
273591 : return LIST_COMPREHENSION;
273592 : }
273593 : #endif
273594 :
273595 : ROSE_DLL_API const char*
273596 0 : SgListComprehension::sage_class_name() const
273597 : {
273598 0 : ROSE_ASSERT(this != NULL);
273599 0 : return "SgListComprehension";
273600 : }
273601 :
273602 : std::string
273603 0 : SgListComprehension::class_name() const
273604 : {
273605 0 : ROSE_ASSERT(this != NULL);
273606 0 : return "SgListComprehension";
273607 : }
273608 :
273609 : // DQ (11/26/2005): Support for visitor pattern mechanims
273610 : // (inferior to ROSE traversal mechanism, experimental).
273611 : void
273612 0 : SgListComprehension::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
273613 : {
273614 0 : ROSE_ASSERT(this != NULL);
273615 0 : visitor.visit(this);
273616 0 : }
273617 :
273618 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
273619 0 : void SgListComprehension::accept (ROSE_VisitorPattern & visitor) {
273620 0 : ROSE_ASSERT(this != NULL);
273621 0 : visitor.visit(this);
273622 0 : }
273623 :
273624 : SgListComprehension*
273625 0 : SgListComprehension::addRegExpAttribute(std::string s, AstRegExAttribute* a)
273626 : {
273627 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
273628 : // This function is currently only supported for the AST used the represent Binary executables.
273629 : if (0 /* isSgAsmNode(this) != NULL */)
273630 : {
273631 : // Support for regex specification.
273632 : std::string prefixCode = "REGEX:";
273633 : addNewAttribute(prefixCode + s,a);
273634 : }
273635 : #endif
273636 :
273637 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
273638 0 : return this;
273639 : }
273640 :
273641 : // *** COMMON CODE SECTION ENDS HERE ***
273642 :
273643 :
273644 : // End of memberFunctionString
273645 : // Start of memberFunctionString
273646 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
273647 :
273648 :
273649 : #if 0
273650 : //! Error checking support
273651 : /*! Verifies the following:
273652 : - working getVariant() member function
273653 : - calls base class's error() member function
273654 : Every class has one of these functions.
273655 : */
273656 : bool
273657 : SgListComprehension::error()
273658 : {
273659 : // Put error checking here
273660 :
273661 : ROSE_ASSERT (this != NULL);
273662 : if (getVariant() != LIST_COMPREHENSION)
273663 : {
273664 : printf ("Error in SgListComprehension::error(): SgListComprehension object has a %s variant \n",
273665 : Cxx_GrammarTerminalNames[getVariant()].name);
273666 : // printf ("Error in SgListComprehension::error() \n");
273667 : ROSE_ABORT();
273668 : }
273669 :
273670 : ROSE_ASSERT (getVariant() == LIST_COMPREHENSION);
273671 : return SgExpression::error();
273672 : }
273673 : #endif
273674 :
273675 :
273676 :
273677 : // End of memberFunctionString
273678 :
273679 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
273680 :
273681 0 : SgListComprehension* isSgListComprehension ( SgNode* inputDerivedClassPointer )
273682 : {
273683 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
273684 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
273685 : // So to fix this we return NULL directly when the input is NULL and avoid the
273686 : // dynamic_cast in this case. This is likely a performance improvement as well.
273687 : // return dynamic_cast<SgListComprehension*>(inputDerivedClassPointer);
273688 : // Milind Chabbi (8/28/2013): isSgListComprehension uses table-driven castability instead of c++ default dynamic_cast
273689 : // this improves the running time performance by 10-20%.
273690 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgListComprehension*>(inputDerivedClassPointer);
273691 0 : return IS_SgListComprehension_FAST_MACRO(inputDerivedClassPointer);
273692 : }
273693 :
273694 : // DQ (11/8/2003): Added version of functions taking const pointer
273695 0 : const SgListComprehension* isSgListComprehension ( const SgNode* inputDerivedClassPointer )
273696 : {
273697 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
273698 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
273699 : // So to fix this we return NULL directly when the input is NULL and avoid the
273700 : // dynamic_cast in this case. This is likely a performance improvement as well.
273701 : // return dynamic_cast<const SgListComprehension*>(inputDerivedClassPointer);
273702 : // Milind Chabbi (8/28/2013): isSgListComprehension uses table-driven castability instead of c++ default dynamic_cast
273703 : // this improves the running time performance by 10-20%.
273704 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgListComprehension*>(inputDerivedClassPointer);
273705 0 : return IS_SgListComprehension_FAST_MACRO(inputDerivedClassPointer);
273706 : }
273707 :
273708 :
273709 :
273710 : /* #line 273711 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273711 :
273712 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
273713 :
273714 : /**
273715 : \brief Generated destructor
273716 :
273717 : This destructor is automatically generated (by ROSETTA). This destructor
273718 : only frees memory of data members associated with the parts of the current IR node which
273719 : are NOT traversed. Those data members that are part of a traversal can be freed using
273720 : a traversal (calling this destructor on all children in a post-order traversal). Such
273721 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
273722 :
273723 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
273724 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
273725 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
273726 :
273727 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
273728 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
273729 : pointers are not yet implemented to call delete on eash pointer in the container.
273730 : (This could be done by derivation from the STL containers to define containers that
273731 : automatically deleted their members.)
273732 :
273733 : */
273734 0 : SgListComprehension::~SgListComprehension () {
273735 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
273736 :
273737 :
273738 : // case: not a listType for element
273739 0 : p_element = NULL; // non list case
273740 : // case: not a listType for generators
273741 0 : p_generators = NULL; // non list case
273742 :
273743 : }
273744 :
273745 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
273746 0 : }
273747 :
273748 :
273749 : /* #line 273750 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273750 :
273751 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
273752 :
273753 : // Generated constructor
273754 0 : SgListComprehension::SgListComprehension ( Sg_File_Info* startOfConstruct, SgExpression* element, SgExprListExp* generators )
273755 0 : : SgExpression(startOfConstruct)
273756 : {
273757 : #ifdef DEBUG
273758 : // printf ("In SgListComprehension::SgListComprehension (Sg_File_Info* startOfConstruct, SgExpression* element, SgExprListExp* generators) sage_class_name() = %s \n",sage_class_name());
273759 : #endif
273760 : #if 0
273761 : // debugging information!
273762 : printf ("In SgListComprehension::SgListComprehension (Sg_File_Info* startOfConstruct, SgExpression* element, SgExprListExp* generators): this = %p = %s \n",this,this->class_name().c_str());
273763 : #endif
273764 :
273765 0 : p_element = element;
273766 0 : p_generators = generators;
273767 :
273768 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
273769 :
273770 : #if 0
273771 : // DQ (7/30/2014): Call a virtual function.
273772 : std::string s = this->class_name();
273773 : #endif
273774 :
273775 : // Test the variant virtual function
273776 : // assert(LIST_COMPREHENSION == variant());
273777 0 : assert(LIST_COMPREHENSION == this->variant());
273778 0 : ROSE_ASSERT(LIST_COMPREHENSION == (int)(this->variantT()));
273779 0 : post_construction_initialization();
273780 :
273781 : // Test the isSgListComprehension() function since it has been problematic
273782 0 : assert(isSgListComprehension(this) != NULL);
273783 0 : }
273784 :
273785 : // Generated constructor (all data members)
273786 :
273787 : /* #line 273788 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273788 :
273789 :
273790 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
273791 :
273792 :
273793 : // ********************************************************
273794 : // member functions common across all array grammar objects
273795 : // ********************************************************
273796 :
273797 :
273798 :
273799 : /* #line 273800 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273800 :
273801 :
273802 :
273803 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
273804 :
273805 : // ********************************************************
273806 : // member functions specific to each node in the grammar
273807 : // ********************************************************
273808 :
273809 :
273810 : /* #line 273811 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
273811 :
273812 : // Start of memberFunctionString
273813 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273814 :
273815 : void
273816 0 : SgSetComprehension::post_construction_initialization()
273817 : {
273818 0 : }
273819 :
273820 :
273821 :
273822 : // End of memberFunctionString
273823 : // Start of memberFunctionString
273824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
273825 :
273826 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
273827 :
273828 : SgExpression*
273829 0 : SgSetComprehension::get_element () const
273830 : {
273831 0 : ROSE_ASSERT (this != NULL);
273832 :
273833 : #if 0
273834 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273835 : // used to trigger marking transformations for the token-based unparsing.
273836 : printf ("SgSetComprehension::get_element = %p = %s \n",this,this->class_name().c_str());
273837 : #endif
273838 :
273839 0 : return p_element;
273840 : }
273841 :
273842 : void
273843 0 : SgSetComprehension::set_element ( SgExpression* element )
273844 : {
273845 0 : ROSE_ASSERT (this != NULL);
273846 :
273847 : #if 0
273848 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273849 : // used to trigger marking transformations for the token-based unparsing.
273850 : printf ("SgSetComprehension::set_element = %p = %s \n",this,this->class_name().c_str());
273851 : #endif
273852 :
273853 0 : set_isModified(true);
273854 :
273855 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273856 : if (p_element != NULL && element != NULL && p_element != element)
273857 : {
273858 : printf ("Warning: element = %p overwriting valid pointer p_element = %p \n",element,p_element);
273859 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273860 : printf ("Error fails assertion (p_element != NULL && element != NULL && p_element != element) is false\n");
273861 : ROSE_ASSERT(false);
273862 : #endif
273863 : }
273864 : #endif
273865 0 : p_element = element;
273866 0 : }
273867 :
273868 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273869 :
273870 :
273871 : // End of memberFunctionString
273872 : // Start of memberFunctionString
273873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
273874 :
273875 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
273876 :
273877 : SgExprListExp*
273878 0 : SgSetComprehension::get_generators () const
273879 : {
273880 0 : ROSE_ASSERT (this != NULL);
273881 :
273882 : #if 0
273883 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273884 : // used to trigger marking transformations for the token-based unparsing.
273885 : printf ("SgSetComprehension::get_generators = %p = %s \n",this,this->class_name().c_str());
273886 : #endif
273887 :
273888 0 : return p_generators;
273889 : }
273890 :
273891 : void
273892 0 : SgSetComprehension::set_generators ( SgExprListExp* generators )
273893 : {
273894 0 : ROSE_ASSERT (this != NULL);
273895 :
273896 : #if 0
273897 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
273898 : // used to trigger marking transformations for the token-based unparsing.
273899 : printf ("SgSetComprehension::set_generators = %p = %s \n",this,this->class_name().c_str());
273900 : #endif
273901 :
273902 0 : set_isModified(true);
273903 :
273904 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
273905 : if (p_generators != NULL && generators != NULL && p_generators != generators)
273906 : {
273907 : printf ("Warning: generators = %p overwriting valid pointer p_generators = %p \n",generators,p_generators);
273908 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
273909 : printf ("Error fails assertion (p_generators != NULL && generators != NULL && p_generators != generators) is false\n");
273910 : ROSE_ASSERT(false);
273911 : #endif
273912 : }
273913 : #endif
273914 0 : p_generators = generators;
273915 0 : }
273916 :
273917 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
273918 :
273919 :
273920 : // End of memberFunctionString
273921 : // Start of memberFunctionString
273922 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273923 :
273924 : SgType*
273925 :
273926 0 : SgSetComprehension::get_type() const
273927 : {
273928 0 : ROSE_ASSERT(this != NULL);
273929 :
273930 : #if 0
273931 : printf ("In SgSetComprehension::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
273932 : #endif
273933 :
273934 : // DQ (10/31/2016): Debugging...
273935 : // return SgTypeDefault::createType();
273936 0 : SgType* returnType = SgTypeDefault::createType();
273937 :
273938 : #if 0
273939 : printf ("Leaving SgSetComprehension::get_type() (default_get_type) returnType = %p \n",returnType);
273940 : #endif
273941 :
273942 0 : return returnType;
273943 : }
273944 :
273945 :
273946 :
273947 : // End of memberFunctionString
273948 : // Start of memberFunctionString
273949 : /* #line 7113 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
273950 :
273951 :
273952 :
273953 : // End of memberFunctionString
273954 : // Start of memberFunctionString
273955 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
273956 :
273957 : // *** COMMON CODE SECTION BEGINS HERE ***
273958 :
273959 : #if 0
273960 : int
273961 : SgSetComprehension::getVariant() const
273962 : {
273963 : // This function is used in ROSE while "variant()" is used in SAGE
273964 : assert(this != NULL);
273965 : return variant();
273966 : }
273967 : #endif
273968 :
273969 : // This function is used in ROSE in treeTraversal code
273970 : // eventually replaces getVariant() and variant()
273971 : // though after variant() has been removed for a while we will
273972 : // want to change the name of variantT() back to variant()
273973 : // (since the "T" was ment to stand for temporary).
273974 : // When this happens the variantT() will be depricated.
273975 : VariantT
273976 0 : SgSetComprehension::variantT() const
273977 : {
273978 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
273979 0 : ROSE_ASSERT(this != NULL);
273980 0 : return V_SgSetComprehension;
273981 : }
273982 :
273983 : #if 0
273984 : int
273985 : SgSetComprehension::variant() const
273986 : {
273987 : // This function is used in SAGE
273988 : ROSE_ASSERT(this != NULL);
273989 : return SET_COMPREHENSION;
273990 : }
273991 : #endif
273992 :
273993 : ROSE_DLL_API const char*
273994 0 : SgSetComprehension::sage_class_name() const
273995 : {
273996 0 : ROSE_ASSERT(this != NULL);
273997 0 : return "SgSetComprehension";
273998 : }
273999 :
274000 : std::string
274001 0 : SgSetComprehension::class_name() const
274002 : {
274003 0 : ROSE_ASSERT(this != NULL);
274004 0 : return "SgSetComprehension";
274005 : }
274006 :
274007 : // DQ (11/26/2005): Support for visitor pattern mechanims
274008 : // (inferior to ROSE traversal mechanism, experimental).
274009 : void
274010 0 : SgSetComprehension::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
274011 : {
274012 0 : ROSE_ASSERT(this != NULL);
274013 0 : visitor.visit(this);
274014 0 : }
274015 :
274016 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
274017 0 : void SgSetComprehension::accept (ROSE_VisitorPattern & visitor) {
274018 0 : ROSE_ASSERT(this != NULL);
274019 0 : visitor.visit(this);
274020 0 : }
274021 :
274022 : SgSetComprehension*
274023 0 : SgSetComprehension::addRegExpAttribute(std::string s, AstRegExAttribute* a)
274024 : {
274025 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
274026 : // This function is currently only supported for the AST used the represent Binary executables.
274027 : if (0 /* isSgAsmNode(this) != NULL */)
274028 : {
274029 : // Support for regex specification.
274030 : std::string prefixCode = "REGEX:";
274031 : addNewAttribute(prefixCode + s,a);
274032 : }
274033 : #endif
274034 :
274035 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
274036 0 : return this;
274037 : }
274038 :
274039 : // *** COMMON CODE SECTION ENDS HERE ***
274040 :
274041 :
274042 : // End of memberFunctionString
274043 : // Start of memberFunctionString
274044 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
274045 :
274046 :
274047 : #if 0
274048 : //! Error checking support
274049 : /*! Verifies the following:
274050 : - working getVariant() member function
274051 : - calls base class's error() member function
274052 : Every class has one of these functions.
274053 : */
274054 : bool
274055 : SgSetComprehension::error()
274056 : {
274057 : // Put error checking here
274058 :
274059 : ROSE_ASSERT (this != NULL);
274060 : if (getVariant() != SET_COMPREHENSION)
274061 : {
274062 : printf ("Error in SgSetComprehension::error(): SgSetComprehension object has a %s variant \n",
274063 : Cxx_GrammarTerminalNames[getVariant()].name);
274064 : // printf ("Error in SgSetComprehension::error() \n");
274065 : ROSE_ABORT();
274066 : }
274067 :
274068 : ROSE_ASSERT (getVariant() == SET_COMPREHENSION);
274069 : return SgExpression::error();
274070 : }
274071 : #endif
274072 :
274073 :
274074 :
274075 : // End of memberFunctionString
274076 :
274077 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
274078 :
274079 0 : SgSetComprehension* isSgSetComprehension ( SgNode* inputDerivedClassPointer )
274080 : {
274081 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
274082 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
274083 : // So to fix this we return NULL directly when the input is NULL and avoid the
274084 : // dynamic_cast in this case. This is likely a performance improvement as well.
274085 : // return dynamic_cast<SgSetComprehension*>(inputDerivedClassPointer);
274086 : // Milind Chabbi (8/28/2013): isSgSetComprehension uses table-driven castability instead of c++ default dynamic_cast
274087 : // this improves the running time performance by 10-20%.
274088 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSetComprehension*>(inputDerivedClassPointer);
274089 0 : return IS_SgSetComprehension_FAST_MACRO(inputDerivedClassPointer);
274090 : }
274091 :
274092 : // DQ (11/8/2003): Added version of functions taking const pointer
274093 0 : const SgSetComprehension* isSgSetComprehension ( const SgNode* inputDerivedClassPointer )
274094 : {
274095 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
274096 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
274097 : // So to fix this we return NULL directly when the input is NULL and avoid the
274098 : // dynamic_cast in this case. This is likely a performance improvement as well.
274099 : // return dynamic_cast<const SgSetComprehension*>(inputDerivedClassPointer);
274100 : // Milind Chabbi (8/28/2013): isSgSetComprehension uses table-driven castability instead of c++ default dynamic_cast
274101 : // this improves the running time performance by 10-20%.
274102 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSetComprehension*>(inputDerivedClassPointer);
274103 0 : return IS_SgSetComprehension_FAST_MACRO(inputDerivedClassPointer);
274104 : }
274105 :
274106 :
274107 :
274108 : /* #line 274109 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274109 :
274110 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
274111 :
274112 : /**
274113 : \brief Generated destructor
274114 :
274115 : This destructor is automatically generated (by ROSETTA). This destructor
274116 : only frees memory of data members associated with the parts of the current IR node which
274117 : are NOT traversed. Those data members that are part of a traversal can be freed using
274118 : a traversal (calling this destructor on all children in a post-order traversal). Such
274119 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
274120 :
274121 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
274122 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
274123 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
274124 :
274125 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
274126 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
274127 : pointers are not yet implemented to call delete on eash pointer in the container.
274128 : (This could be done by derivation from the STL containers to define containers that
274129 : automatically deleted their members.)
274130 :
274131 : */
274132 0 : SgSetComprehension::~SgSetComprehension () {
274133 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
274134 :
274135 :
274136 : // case: not a listType for element
274137 0 : p_element = NULL; // non list case
274138 : // case: not a listType for generators
274139 0 : p_generators = NULL; // non list case
274140 :
274141 : }
274142 :
274143 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
274144 0 : }
274145 :
274146 :
274147 : /* #line 274148 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274148 :
274149 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
274150 :
274151 : // Generated constructor
274152 0 : SgSetComprehension::SgSetComprehension ( Sg_File_Info* startOfConstruct, SgExpression* element, SgExprListExp* generators )
274153 0 : : SgExpression(startOfConstruct)
274154 : {
274155 : #ifdef DEBUG
274156 : // printf ("In SgSetComprehension::SgSetComprehension (Sg_File_Info* startOfConstruct, SgExpression* element, SgExprListExp* generators) sage_class_name() = %s \n",sage_class_name());
274157 : #endif
274158 : #if 0
274159 : // debugging information!
274160 : printf ("In SgSetComprehension::SgSetComprehension (Sg_File_Info* startOfConstruct, SgExpression* element, SgExprListExp* generators): this = %p = %s \n",this,this->class_name().c_str());
274161 : #endif
274162 :
274163 0 : p_element = element;
274164 0 : p_generators = generators;
274165 :
274166 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
274167 :
274168 : #if 0
274169 : // DQ (7/30/2014): Call a virtual function.
274170 : std::string s = this->class_name();
274171 : #endif
274172 :
274173 : // Test the variant virtual function
274174 : // assert(SET_COMPREHENSION == variant());
274175 0 : assert(SET_COMPREHENSION == this->variant());
274176 0 : ROSE_ASSERT(SET_COMPREHENSION == (int)(this->variantT()));
274177 0 : post_construction_initialization();
274178 :
274179 : // Test the isSgSetComprehension() function since it has been problematic
274180 0 : assert(isSgSetComprehension(this) != NULL);
274181 0 : }
274182 :
274183 : // Generated constructor (all data members)
274184 :
274185 : /* #line 274186 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274186 :
274187 :
274188 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
274189 :
274190 :
274191 : // ********************************************************
274192 : // member functions common across all array grammar objects
274193 : // ********************************************************
274194 :
274195 :
274196 :
274197 : /* #line 274198 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274198 :
274199 :
274200 :
274201 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
274202 :
274203 : // ********************************************************
274204 : // member functions specific to each node in the grammar
274205 : // ********************************************************
274206 :
274207 :
274208 : /* #line 274209 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274209 :
274210 : // Start of memberFunctionString
274211 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274212 :
274213 : void
274214 0 : SgDictionaryComprehension::post_construction_initialization()
274215 : {
274216 0 : }
274217 :
274218 :
274219 :
274220 : // End of memberFunctionString
274221 : // Start of memberFunctionString
274222 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
274223 :
274224 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
274225 :
274226 : SgKeyDatumPair*
274227 0 : SgDictionaryComprehension::get_element () const
274228 : {
274229 0 : ROSE_ASSERT (this != NULL);
274230 :
274231 : #if 0
274232 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
274233 : // used to trigger marking transformations for the token-based unparsing.
274234 : printf ("SgDictionaryComprehension::get_element = %p = %s \n",this,this->class_name().c_str());
274235 : #endif
274236 :
274237 0 : return p_element;
274238 : }
274239 :
274240 : void
274241 0 : SgDictionaryComprehension::set_element ( SgKeyDatumPair* element )
274242 : {
274243 0 : ROSE_ASSERT (this != NULL);
274244 :
274245 : #if 0
274246 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
274247 : // used to trigger marking transformations for the token-based unparsing.
274248 : printf ("SgDictionaryComprehension::set_element = %p = %s \n",this,this->class_name().c_str());
274249 : #endif
274250 :
274251 0 : set_isModified(true);
274252 :
274253 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
274254 : if (p_element != NULL && element != NULL && p_element != element)
274255 : {
274256 : printf ("Warning: element = %p overwriting valid pointer p_element = %p \n",element,p_element);
274257 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
274258 : printf ("Error fails assertion (p_element != NULL && element != NULL && p_element != element) is false\n");
274259 : ROSE_ASSERT(false);
274260 : #endif
274261 : }
274262 : #endif
274263 0 : p_element = element;
274264 0 : }
274265 :
274266 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
274267 :
274268 :
274269 : // End of memberFunctionString
274270 : // Start of memberFunctionString
274271 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
274272 :
274273 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
274274 :
274275 : SgExprListExp*
274276 0 : SgDictionaryComprehension::get_generators () const
274277 : {
274278 0 : ROSE_ASSERT (this != NULL);
274279 :
274280 : #if 0
274281 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
274282 : // used to trigger marking transformations for the token-based unparsing.
274283 : printf ("SgDictionaryComprehension::get_generators = %p = %s \n",this,this->class_name().c_str());
274284 : #endif
274285 :
274286 0 : return p_generators;
274287 : }
274288 :
274289 : void
274290 0 : SgDictionaryComprehension::set_generators ( SgExprListExp* generators )
274291 : {
274292 0 : ROSE_ASSERT (this != NULL);
274293 :
274294 : #if 0
274295 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
274296 : // used to trigger marking transformations for the token-based unparsing.
274297 : printf ("SgDictionaryComprehension::set_generators = %p = %s \n",this,this->class_name().c_str());
274298 : #endif
274299 :
274300 0 : set_isModified(true);
274301 :
274302 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
274303 : if (p_generators != NULL && generators != NULL && p_generators != generators)
274304 : {
274305 : printf ("Warning: generators = %p overwriting valid pointer p_generators = %p \n",generators,p_generators);
274306 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
274307 : printf ("Error fails assertion (p_generators != NULL && generators != NULL && p_generators != generators) is false\n");
274308 : ROSE_ASSERT(false);
274309 : #endif
274310 : }
274311 : #endif
274312 0 : p_generators = generators;
274313 0 : }
274314 :
274315 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
274316 :
274317 :
274318 : // End of memberFunctionString
274319 : // Start of memberFunctionString
274320 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274321 :
274322 : SgType*
274323 :
274324 0 : SgDictionaryComprehension::get_type() const
274325 : {
274326 0 : ROSE_ASSERT(this != NULL);
274327 :
274328 : #if 0
274329 : printf ("In SgDictionaryComprehension::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
274330 : #endif
274331 :
274332 : // DQ (10/31/2016): Debugging...
274333 : // return SgTypeDefault::createType();
274334 0 : SgType* returnType = SgTypeDefault::createType();
274335 :
274336 : #if 0
274337 : printf ("Leaving SgDictionaryComprehension::get_type() (default_get_type) returnType = %p \n",returnType);
274338 : #endif
274339 :
274340 0 : return returnType;
274341 : }
274342 :
274343 :
274344 :
274345 : // End of memberFunctionString
274346 : // Start of memberFunctionString
274347 : /* #line 7116 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274348 :
274349 :
274350 :
274351 : // End of memberFunctionString
274352 : // Start of memberFunctionString
274353 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
274354 :
274355 : // *** COMMON CODE SECTION BEGINS HERE ***
274356 :
274357 : #if 0
274358 : int
274359 : SgDictionaryComprehension::getVariant() const
274360 : {
274361 : // This function is used in ROSE while "variant()" is used in SAGE
274362 : assert(this != NULL);
274363 : return variant();
274364 : }
274365 : #endif
274366 :
274367 : // This function is used in ROSE in treeTraversal code
274368 : // eventually replaces getVariant() and variant()
274369 : // though after variant() has been removed for a while we will
274370 : // want to change the name of variantT() back to variant()
274371 : // (since the "T" was ment to stand for temporary).
274372 : // When this happens the variantT() will be depricated.
274373 : VariantT
274374 0 : SgDictionaryComprehension::variantT() const
274375 : {
274376 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
274377 0 : ROSE_ASSERT(this != NULL);
274378 0 : return V_SgDictionaryComprehension;
274379 : }
274380 :
274381 : #if 0
274382 : int
274383 : SgDictionaryComprehension::variant() const
274384 : {
274385 : // This function is used in SAGE
274386 : ROSE_ASSERT(this != NULL);
274387 : return DICTIONARY_COMPREHENSION;
274388 : }
274389 : #endif
274390 :
274391 : ROSE_DLL_API const char*
274392 0 : SgDictionaryComprehension::sage_class_name() const
274393 : {
274394 0 : ROSE_ASSERT(this != NULL);
274395 0 : return "SgDictionaryComprehension";
274396 : }
274397 :
274398 : std::string
274399 0 : SgDictionaryComprehension::class_name() const
274400 : {
274401 0 : ROSE_ASSERT(this != NULL);
274402 0 : return "SgDictionaryComprehension";
274403 : }
274404 :
274405 : // DQ (11/26/2005): Support for visitor pattern mechanims
274406 : // (inferior to ROSE traversal mechanism, experimental).
274407 : void
274408 0 : SgDictionaryComprehension::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
274409 : {
274410 0 : ROSE_ASSERT(this != NULL);
274411 0 : visitor.visit(this);
274412 0 : }
274413 :
274414 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
274415 0 : void SgDictionaryComprehension::accept (ROSE_VisitorPattern & visitor) {
274416 0 : ROSE_ASSERT(this != NULL);
274417 0 : visitor.visit(this);
274418 0 : }
274419 :
274420 : SgDictionaryComprehension*
274421 0 : SgDictionaryComprehension::addRegExpAttribute(std::string s, AstRegExAttribute* a)
274422 : {
274423 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
274424 : // This function is currently only supported for the AST used the represent Binary executables.
274425 : if (0 /* isSgAsmNode(this) != NULL */)
274426 : {
274427 : // Support for regex specification.
274428 : std::string prefixCode = "REGEX:";
274429 : addNewAttribute(prefixCode + s,a);
274430 : }
274431 : #endif
274432 :
274433 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
274434 0 : return this;
274435 : }
274436 :
274437 : // *** COMMON CODE SECTION ENDS HERE ***
274438 :
274439 :
274440 : // End of memberFunctionString
274441 : // Start of memberFunctionString
274442 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
274443 :
274444 :
274445 : #if 0
274446 : //! Error checking support
274447 : /*! Verifies the following:
274448 : - working getVariant() member function
274449 : - calls base class's error() member function
274450 : Every class has one of these functions.
274451 : */
274452 : bool
274453 : SgDictionaryComprehension::error()
274454 : {
274455 : // Put error checking here
274456 :
274457 : ROSE_ASSERT (this != NULL);
274458 : if (getVariant() != DICTIONARY_COMPREHENSION)
274459 : {
274460 : printf ("Error in SgDictionaryComprehension::error(): SgDictionaryComprehension object has a %s variant \n",
274461 : Cxx_GrammarTerminalNames[getVariant()].name);
274462 : // printf ("Error in SgDictionaryComprehension::error() \n");
274463 : ROSE_ABORT();
274464 : }
274465 :
274466 : ROSE_ASSERT (getVariant() == DICTIONARY_COMPREHENSION);
274467 : return SgExpression::error();
274468 : }
274469 : #endif
274470 :
274471 :
274472 :
274473 : // End of memberFunctionString
274474 :
274475 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
274476 :
274477 0 : SgDictionaryComprehension* isSgDictionaryComprehension ( SgNode* inputDerivedClassPointer )
274478 : {
274479 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
274480 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
274481 : // So to fix this we return NULL directly when the input is NULL and avoid the
274482 : // dynamic_cast in this case. This is likely a performance improvement as well.
274483 : // return dynamic_cast<SgDictionaryComprehension*>(inputDerivedClassPointer);
274484 : // Milind Chabbi (8/28/2013): isSgDictionaryComprehension uses table-driven castability instead of c++ default dynamic_cast
274485 : // this improves the running time performance by 10-20%.
274486 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDictionaryComprehension*>(inputDerivedClassPointer);
274487 0 : return IS_SgDictionaryComprehension_FAST_MACRO(inputDerivedClassPointer);
274488 : }
274489 :
274490 : // DQ (11/8/2003): Added version of functions taking const pointer
274491 0 : const SgDictionaryComprehension* isSgDictionaryComprehension ( const SgNode* inputDerivedClassPointer )
274492 : {
274493 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
274494 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
274495 : // So to fix this we return NULL directly when the input is NULL and avoid the
274496 : // dynamic_cast in this case. This is likely a performance improvement as well.
274497 : // return dynamic_cast<const SgDictionaryComprehension*>(inputDerivedClassPointer);
274498 : // Milind Chabbi (8/28/2013): isSgDictionaryComprehension uses table-driven castability instead of c++ default dynamic_cast
274499 : // this improves the running time performance by 10-20%.
274500 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDictionaryComprehension*>(inputDerivedClassPointer);
274501 0 : return IS_SgDictionaryComprehension_FAST_MACRO(inputDerivedClassPointer);
274502 : }
274503 :
274504 :
274505 :
274506 : /* #line 274507 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274507 :
274508 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
274509 :
274510 : /**
274511 : \brief Generated destructor
274512 :
274513 : This destructor is automatically generated (by ROSETTA). This destructor
274514 : only frees memory of data members associated with the parts of the current IR node which
274515 : are NOT traversed. Those data members that are part of a traversal can be freed using
274516 : a traversal (calling this destructor on all children in a post-order traversal). Such
274517 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
274518 :
274519 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
274520 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
274521 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
274522 :
274523 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
274524 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
274525 : pointers are not yet implemented to call delete on eash pointer in the container.
274526 : (This could be done by derivation from the STL containers to define containers that
274527 : automatically deleted their members.)
274528 :
274529 : */
274530 0 : SgDictionaryComprehension::~SgDictionaryComprehension () {
274531 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
274532 :
274533 :
274534 : // case: not a listType for element
274535 0 : p_element = NULL; // non list case
274536 : // case: not a listType for generators
274537 0 : p_generators = NULL; // non list case
274538 :
274539 : }
274540 :
274541 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
274542 0 : }
274543 :
274544 :
274545 : /* #line 274546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274546 :
274547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
274548 :
274549 : // Generated constructor
274550 0 : SgDictionaryComprehension::SgDictionaryComprehension ( Sg_File_Info* startOfConstruct, SgKeyDatumPair* element, SgExprListExp* generators )
274551 0 : : SgExpression(startOfConstruct)
274552 : {
274553 : #ifdef DEBUG
274554 : // printf ("In SgDictionaryComprehension::SgDictionaryComprehension (Sg_File_Info* startOfConstruct, SgKeyDatumPair* element, SgExprListExp* generators) sage_class_name() = %s \n",sage_class_name());
274555 : #endif
274556 : #if 0
274557 : // debugging information!
274558 : printf ("In SgDictionaryComprehension::SgDictionaryComprehension (Sg_File_Info* startOfConstruct, SgKeyDatumPair* element, SgExprListExp* generators): this = %p = %s \n",this,this->class_name().c_str());
274559 : #endif
274560 :
274561 0 : p_element = element;
274562 0 : p_generators = generators;
274563 :
274564 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
274565 :
274566 : #if 0
274567 : // DQ (7/30/2014): Call a virtual function.
274568 : std::string s = this->class_name();
274569 : #endif
274570 :
274571 : // Test the variant virtual function
274572 : // assert(DICTIONARY_COMPREHENSION == variant());
274573 0 : assert(DICTIONARY_COMPREHENSION == this->variant());
274574 0 : ROSE_ASSERT(DICTIONARY_COMPREHENSION == (int)(this->variantT()));
274575 0 : post_construction_initialization();
274576 :
274577 : // Test the isSgDictionaryComprehension() function since it has been problematic
274578 0 : assert(isSgDictionaryComprehension(this) != NULL);
274579 0 : }
274580 :
274581 : // Generated constructor (all data members)
274582 :
274583 : /* #line 274584 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274584 :
274585 :
274586 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
274587 :
274588 :
274589 : // ********************************************************
274590 : // member functions common across all array grammar objects
274591 : // ********************************************************
274592 :
274593 :
274594 :
274595 : /* #line 274596 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274596 :
274597 :
274598 :
274599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
274600 :
274601 : // ********************************************************
274602 : // member functions specific to each node in the grammar
274603 : // ********************************************************
274604 :
274605 :
274606 : /* #line 274607 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274607 :
274608 : // Start of memberFunctionString
274609 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274610 :
274611 : void
274612 0 : SgNaryOp::post_construction_initialization()
274613 : {
274614 0 : }
274615 :
274616 :
274617 :
274618 : // End of memberFunctionString
274619 : // Start of memberFunctionString
274620 :
274621 :
274622 : // End of memberFunctionString
274623 : // Start of memberFunctionString
274624 : /* #line 5126 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274625 :
274626 :
274627 : SgExpressionPtrList&
274628 0 : SgNaryOp::get_operands()
274629 0 : { return p_operands; }
274630 :
274631 : const SgExpressionPtrList&
274632 0 : SgNaryOp::get_operands() const
274633 0 : { return p_operands; }
274634 :
274635 : VariantTList&
274636 0 : SgNaryOp::get_operators()
274637 0 : { return p_operators; }
274638 :
274639 : const VariantTList&
274640 0 : SgNaryOp::get_operators() const
274641 0 : { return p_operators; }
274642 :
274643 : void
274644 0 : SgNaryOp::append_operation(VariantT sg_operator, SgExpression* operand) {
274645 0 : ROSE_ASSERT(operand != NULL);
274646 0 : get_operands().push_back(operand);
274647 0 : get_operators().push_back(sg_operator);
274648 0 : operand->set_parent(this);
274649 0 : }
274650 :
274651 : int
274652 0 : SgNaryOp::replace_expression(SgExpression *o, SgExpression *n) {
274653 0 : SgExpressionPtrList::iterator i;
274654 0 : for (i = get_operands().begin(); i != get_operands().end(); ++i) {
274655 0 : if( (*i) == o) {
274656 0 : *i = n;
274657 0 : return 1;
274658 : }
274659 : }
274660 : return 0;
274661 : }
274662 :
274663 : int
274664 0 : SgNaryOp::length() const {
274665 0 : return get_operands().size();
274666 : }
274667 :
274668 : SgExpression*
274669 0 : SgNaryOp::get_next(int& i) const {
274670 0 : return get_operands()[i++];
274671 : }
274672 :
274673 : bool
274674 0 : SgNaryOp::empty() const {
274675 0 : return get_operands().empty();
274676 : }
274677 :
274678 :
274679 :
274680 : // End of memberFunctionString
274681 : // Start of memberFunctionString
274682 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
274683 :
274684 : // *** COMMON CODE SECTION BEGINS HERE ***
274685 :
274686 : #if 0
274687 : int
274688 : SgNaryOp::getVariant() const
274689 : {
274690 : // This function is used in ROSE while "variant()" is used in SAGE
274691 : assert(this != NULL);
274692 : return variant();
274693 : }
274694 : #endif
274695 :
274696 : // This function is used in ROSE in treeTraversal code
274697 : // eventually replaces getVariant() and variant()
274698 : // though after variant() has been removed for a while we will
274699 : // want to change the name of variantT() back to variant()
274700 : // (since the "T" was ment to stand for temporary).
274701 : // When this happens the variantT() will be depricated.
274702 : VariantT
274703 0 : SgNaryOp::variantT() const
274704 : {
274705 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
274706 0 : ROSE_ASSERT(this != NULL);
274707 0 : return V_SgNaryOp;
274708 : }
274709 :
274710 : #if 0
274711 : int
274712 : SgNaryOp::variant() const
274713 : {
274714 : // This function is used in SAGE
274715 : ROSE_ASSERT(this != NULL);
274716 : return NARY_EXPRESSION;
274717 : }
274718 : #endif
274719 :
274720 : ROSE_DLL_API const char*
274721 0 : SgNaryOp::sage_class_name() const
274722 : {
274723 0 : ROSE_ASSERT(this != NULL);
274724 0 : return "SgNaryOp";
274725 : }
274726 :
274727 : std::string
274728 0 : SgNaryOp::class_name() const
274729 : {
274730 0 : ROSE_ASSERT(this != NULL);
274731 0 : return "SgNaryOp";
274732 : }
274733 :
274734 : // DQ (11/26/2005): Support for visitor pattern mechanims
274735 : // (inferior to ROSE traversal mechanism, experimental).
274736 : void
274737 0 : SgNaryOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
274738 : {
274739 0 : ROSE_ASSERT(this != NULL);
274740 0 : visitor.visit(this);
274741 0 : }
274742 :
274743 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
274744 0 : void SgNaryOp::accept (ROSE_VisitorPattern & visitor) {
274745 0 : ROSE_ASSERT(this != NULL);
274746 0 : visitor.visit(this);
274747 0 : }
274748 :
274749 : SgNaryOp*
274750 0 : SgNaryOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
274751 : {
274752 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
274753 : // This function is currently only supported for the AST used the represent Binary executables.
274754 : if (0 /* isSgAsmNode(this) != NULL */)
274755 : {
274756 : // Support for regex specification.
274757 : std::string prefixCode = "REGEX:";
274758 : addNewAttribute(prefixCode + s,a);
274759 : }
274760 : #endif
274761 :
274762 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
274763 0 : return this;
274764 : }
274765 :
274766 : // *** COMMON CODE SECTION ENDS HERE ***
274767 :
274768 :
274769 : // End of memberFunctionString
274770 : // Start of memberFunctionString
274771 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
274772 :
274773 :
274774 : #if 0
274775 : //! Error checking support
274776 : /*! Verifies the following:
274777 : - working getVariant() member function
274778 : - calls base class's error() member function
274779 : Every class has one of these functions.
274780 : */
274781 : bool
274782 : SgNaryOp::error()
274783 : {
274784 : // Put error checking here
274785 :
274786 : ROSE_ASSERT (this != NULL);
274787 : if (getVariant() != NARY_EXPRESSION)
274788 : {
274789 : printf ("Error in SgNaryOp::error(): SgNaryOp object has a %s variant \n",
274790 : Cxx_GrammarTerminalNames[getVariant()].name);
274791 : // printf ("Error in SgNaryOp::error() \n");
274792 : ROSE_ABORT();
274793 : }
274794 :
274795 : ROSE_ASSERT (getVariant() == NARY_EXPRESSION);
274796 : return SgExpression::error();
274797 : }
274798 : #endif
274799 :
274800 :
274801 :
274802 : // End of memberFunctionString
274803 :
274804 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
274805 :
274806 0 : SgNaryOp* isSgNaryOp ( SgNode* inputDerivedClassPointer )
274807 : {
274808 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
274809 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
274810 : // So to fix this we return NULL directly when the input is NULL and avoid the
274811 : // dynamic_cast in this case. This is likely a performance improvement as well.
274812 : // return dynamic_cast<SgNaryOp*>(inputDerivedClassPointer);
274813 : // Milind Chabbi (8/28/2013): isSgNaryOp uses table-driven castability instead of c++ default dynamic_cast
274814 : // this improves the running time performance by 10-20%.
274815 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNaryOp*>(inputDerivedClassPointer);
274816 0 : return IS_SgNaryOp_FAST_MACRO(inputDerivedClassPointer);
274817 : }
274818 :
274819 : // DQ (11/8/2003): Added version of functions taking const pointer
274820 0 : const SgNaryOp* isSgNaryOp ( const SgNode* inputDerivedClassPointer )
274821 : {
274822 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
274823 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
274824 : // So to fix this we return NULL directly when the input is NULL and avoid the
274825 : // dynamic_cast in this case. This is likely a performance improvement as well.
274826 : // return dynamic_cast<const SgNaryOp*>(inputDerivedClassPointer);
274827 : // Milind Chabbi (8/28/2013): isSgNaryOp uses table-driven castability instead of c++ default dynamic_cast
274828 : // this improves the running time performance by 10-20%.
274829 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNaryOp*>(inputDerivedClassPointer);
274830 0 : return IS_SgNaryOp_FAST_MACRO(inputDerivedClassPointer);
274831 : }
274832 :
274833 :
274834 :
274835 : /* #line 274836 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274836 :
274837 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
274838 :
274839 : /**
274840 : \brief Generated destructor
274841 :
274842 : This destructor is automatically generated (by ROSETTA). This destructor
274843 : only frees memory of data members associated with the parts of the current IR node which
274844 : are NOT traversed. Those data members that are part of a traversal can be freed using
274845 : a traversal (calling this destructor on all children in a post-order traversal). Such
274846 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
274847 :
274848 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
274849 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
274850 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
274851 :
274852 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
274853 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
274854 : pointers are not yet implemented to call delete on eash pointer in the container.
274855 : (This could be done by derivation from the STL containers to define containers that
274856 : automatically deleted their members.)
274857 :
274858 : */
274859 0 : SgNaryOp::~SgNaryOp () {
274860 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
274861 :
274862 :
274863 :
274864 : }
274865 :
274866 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
274867 0 : }
274868 :
274869 :
274870 : /* #line 274871 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274871 :
274872 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
274873 :
274874 : // Generated constructor
274875 0 : SgNaryOp::SgNaryOp ( Sg_File_Info* startOfConstruct )
274876 0 : : SgExpression(startOfConstruct)
274877 : {
274878 : #ifdef DEBUG
274879 : // printf ("In SgNaryOp::SgNaryOp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
274880 : #endif
274881 : #if 0
274882 : // debugging information!
274883 : printf ("In SgNaryOp::SgNaryOp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
274884 : #endif
274885 :
274886 :
274887 :
274888 : #if 0
274889 : // DQ (7/30/2014): Call a virtual function.
274890 : std::string s = this->class_name();
274891 : #endif
274892 :
274893 : // Test the variant virtual function
274894 : // assert(NARY_EXPRESSION == variant());
274895 0 : assert(NARY_EXPRESSION == this->variant());
274896 0 : ROSE_ASSERT(NARY_EXPRESSION == (int)(this->variantT()));
274897 0 : post_construction_initialization();
274898 :
274899 : // Test the isSgNaryOp() function since it has been problematic
274900 0 : assert(isSgNaryOp(this) != NULL);
274901 0 : }
274902 :
274903 : // Generated constructor (all data members)
274904 :
274905 : /* #line 274906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274906 :
274907 :
274908 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
274909 :
274910 :
274911 : // ********************************************************
274912 : // member functions common across all array grammar objects
274913 : // ********************************************************
274914 :
274915 :
274916 :
274917 : /* #line 274918 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274918 :
274919 :
274920 :
274921 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
274922 :
274923 : // ********************************************************
274924 : // member functions specific to each node in the grammar
274925 : // ********************************************************
274926 :
274927 :
274928 : /* #line 274929 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
274929 :
274930 : // Start of memberFunctionString
274931 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274932 :
274933 : void
274934 0 : SgNaryBooleanOp::post_construction_initialization()
274935 : {
274936 0 : }
274937 :
274938 :
274939 :
274940 : // End of memberFunctionString
274941 : // Start of memberFunctionString
274942 : /* #line 5193 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
274943 :
274944 : SgType*
274945 0 : SgNaryBooleanOp::get_type() const
274946 : {
274947 0 : return SageBuilder::buildVoidType();
274948 : }
274949 :
274950 :
274951 : // End of memberFunctionString
274952 : // Start of memberFunctionString
274953 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
274954 :
274955 : // *** COMMON CODE SECTION BEGINS HERE ***
274956 :
274957 : #if 0
274958 : int
274959 : SgNaryBooleanOp::getVariant() const
274960 : {
274961 : // This function is used in ROSE while "variant()" is used in SAGE
274962 : assert(this != NULL);
274963 : return variant();
274964 : }
274965 : #endif
274966 :
274967 : // This function is used in ROSE in treeTraversal code
274968 : // eventually replaces getVariant() and variant()
274969 : // though after variant() has been removed for a while we will
274970 : // want to change the name of variantT() back to variant()
274971 : // (since the "T" was ment to stand for temporary).
274972 : // When this happens the variantT() will be depricated.
274973 : VariantT
274974 0 : SgNaryBooleanOp::variantT() const
274975 : {
274976 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
274977 0 : ROSE_ASSERT(this != NULL);
274978 0 : return V_SgNaryBooleanOp;
274979 : }
274980 :
274981 : #if 0
274982 : int
274983 : SgNaryBooleanOp::variant() const
274984 : {
274985 : // This function is used in SAGE
274986 : ROSE_ASSERT(this != NULL);
274987 : return NARY_BOOLEAN_OP;
274988 : }
274989 : #endif
274990 :
274991 : ROSE_DLL_API const char*
274992 0 : SgNaryBooleanOp::sage_class_name() const
274993 : {
274994 0 : ROSE_ASSERT(this != NULL);
274995 0 : return "SgNaryBooleanOp";
274996 : }
274997 :
274998 : std::string
274999 0 : SgNaryBooleanOp::class_name() const
275000 : {
275001 0 : ROSE_ASSERT(this != NULL);
275002 0 : return "SgNaryBooleanOp";
275003 : }
275004 :
275005 : // DQ (11/26/2005): Support for visitor pattern mechanims
275006 : // (inferior to ROSE traversal mechanism, experimental).
275007 : void
275008 0 : SgNaryBooleanOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
275009 : {
275010 0 : ROSE_ASSERT(this != NULL);
275011 0 : visitor.visit(this);
275012 0 : }
275013 :
275014 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
275015 0 : void SgNaryBooleanOp::accept (ROSE_VisitorPattern & visitor) {
275016 0 : ROSE_ASSERT(this != NULL);
275017 0 : visitor.visit(this);
275018 0 : }
275019 :
275020 : SgNaryBooleanOp*
275021 0 : SgNaryBooleanOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
275022 : {
275023 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
275024 : // This function is currently only supported for the AST used the represent Binary executables.
275025 : if (0 /* isSgAsmNode(this) != NULL */)
275026 : {
275027 : // Support for regex specification.
275028 : std::string prefixCode = "REGEX:";
275029 : addNewAttribute(prefixCode + s,a);
275030 : }
275031 : #endif
275032 :
275033 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
275034 0 : return this;
275035 : }
275036 :
275037 : // *** COMMON CODE SECTION ENDS HERE ***
275038 :
275039 :
275040 : // End of memberFunctionString
275041 : // Start of memberFunctionString
275042 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
275043 :
275044 :
275045 : #if 0
275046 : //! Error checking support
275047 : /*! Verifies the following:
275048 : - working getVariant() member function
275049 : - calls base class's error() member function
275050 : Every class has one of these functions.
275051 : */
275052 : bool
275053 : SgNaryBooleanOp::error()
275054 : {
275055 : // Put error checking here
275056 :
275057 : ROSE_ASSERT (this != NULL);
275058 : if (getVariant() != NARY_BOOLEAN_OP)
275059 : {
275060 : printf ("Error in SgNaryBooleanOp::error(): SgNaryBooleanOp object has a %s variant \n",
275061 : Cxx_GrammarTerminalNames[getVariant()].name);
275062 : // printf ("Error in SgNaryBooleanOp::error() \n");
275063 : ROSE_ABORT();
275064 : }
275065 :
275066 : ROSE_ASSERT (getVariant() == NARY_BOOLEAN_OP);
275067 : return SgNaryOp::error();
275068 : }
275069 : #endif
275070 :
275071 :
275072 :
275073 : // End of memberFunctionString
275074 :
275075 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
275076 :
275077 0 : SgNaryBooleanOp* isSgNaryBooleanOp ( SgNode* inputDerivedClassPointer )
275078 : {
275079 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
275080 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
275081 : // So to fix this we return NULL directly when the input is NULL and avoid the
275082 : // dynamic_cast in this case. This is likely a performance improvement as well.
275083 : // return dynamic_cast<SgNaryBooleanOp*>(inputDerivedClassPointer);
275084 : // Milind Chabbi (8/28/2013): isSgNaryBooleanOp uses table-driven castability instead of c++ default dynamic_cast
275085 : // this improves the running time performance by 10-20%.
275086 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNaryBooleanOp*>(inputDerivedClassPointer);
275087 0 : return IS_SgNaryBooleanOp_FAST_MACRO(inputDerivedClassPointer);
275088 : }
275089 :
275090 : // DQ (11/8/2003): Added version of functions taking const pointer
275091 0 : const SgNaryBooleanOp* isSgNaryBooleanOp ( const SgNode* inputDerivedClassPointer )
275092 : {
275093 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
275094 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
275095 : // So to fix this we return NULL directly when the input is NULL and avoid the
275096 : // dynamic_cast in this case. This is likely a performance improvement as well.
275097 : // return dynamic_cast<const SgNaryBooleanOp*>(inputDerivedClassPointer);
275098 : // Milind Chabbi (8/28/2013): isSgNaryBooleanOp uses table-driven castability instead of c++ default dynamic_cast
275099 : // this improves the running time performance by 10-20%.
275100 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNaryBooleanOp*>(inputDerivedClassPointer);
275101 0 : return IS_SgNaryBooleanOp_FAST_MACRO(inputDerivedClassPointer);
275102 : }
275103 :
275104 :
275105 :
275106 : /* #line 275107 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275107 :
275108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
275109 :
275110 : /**
275111 : \brief Generated destructor
275112 :
275113 : This destructor is automatically generated (by ROSETTA). This destructor
275114 : only frees memory of data members associated with the parts of the current IR node which
275115 : are NOT traversed. Those data members that are part of a traversal can be freed using
275116 : a traversal (calling this destructor on all children in a post-order traversal). Such
275117 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
275118 :
275119 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
275120 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
275121 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
275122 :
275123 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
275124 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
275125 : pointers are not yet implemented to call delete on eash pointer in the container.
275126 : (This could be done by derivation from the STL containers to define containers that
275127 : automatically deleted their members.)
275128 :
275129 : */
275130 0 : SgNaryBooleanOp::~SgNaryBooleanOp () {
275131 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
275132 :
275133 :
275134 :
275135 : }
275136 :
275137 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
275138 0 : }
275139 :
275140 :
275141 : /* #line 275142 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275142 :
275143 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
275144 :
275145 : // Generated constructor
275146 0 : SgNaryBooleanOp::SgNaryBooleanOp ( Sg_File_Info* startOfConstruct )
275147 0 : : SgNaryOp(startOfConstruct)
275148 : {
275149 : #ifdef DEBUG
275150 : // printf ("In SgNaryBooleanOp::SgNaryBooleanOp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
275151 : #endif
275152 : #if 0
275153 : // debugging information!
275154 : printf ("In SgNaryBooleanOp::SgNaryBooleanOp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
275155 : #endif
275156 :
275157 :
275158 :
275159 : #if 0
275160 : // DQ (7/30/2014): Call a virtual function.
275161 : std::string s = this->class_name();
275162 : #endif
275163 :
275164 : // Test the variant virtual function
275165 : // assert(NARY_BOOLEAN_OP == variant());
275166 0 : assert(NARY_BOOLEAN_OP == this->variant());
275167 0 : ROSE_ASSERT(NARY_BOOLEAN_OP == (int)(this->variantT()));
275168 0 : post_construction_initialization();
275169 :
275170 : // Test the isSgNaryBooleanOp() function since it has been problematic
275171 0 : assert(isSgNaryBooleanOp(this) != NULL);
275172 0 : }
275173 :
275174 : // Generated constructor (all data members)
275175 :
275176 : /* #line 275177 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275177 :
275178 :
275179 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
275180 :
275181 :
275182 : // ********************************************************
275183 : // member functions common across all array grammar objects
275184 : // ********************************************************
275185 :
275186 :
275187 :
275188 : /* #line 275189 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275189 :
275190 :
275191 :
275192 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
275193 :
275194 : // ********************************************************
275195 : // member functions specific to each node in the grammar
275196 : // ********************************************************
275197 :
275198 :
275199 : /* #line 275200 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275200 :
275201 : // Start of memberFunctionString
275202 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275203 :
275204 : void
275205 0 : SgNaryComparisonOp::post_construction_initialization()
275206 : {
275207 0 : }
275208 :
275209 :
275210 :
275211 : // End of memberFunctionString
275212 : // Start of memberFunctionString
275213 : /* #line 5181 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275214 :
275215 : SgType*
275216 0 : SgNaryComparisonOp::get_type() const
275217 : {
275218 : #if 1
275219 0 : printf ("In SgNaryComparisonOp::get_type() \n");
275220 : #endif
275221 :
275222 0 : return SageBuilder::buildBoolType();
275223 : }
275224 :
275225 :
275226 : // End of memberFunctionString
275227 : // Start of memberFunctionString
275228 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
275229 :
275230 : // *** COMMON CODE SECTION BEGINS HERE ***
275231 :
275232 : #if 0
275233 : int
275234 : SgNaryComparisonOp::getVariant() const
275235 : {
275236 : // This function is used in ROSE while "variant()" is used in SAGE
275237 : assert(this != NULL);
275238 : return variant();
275239 : }
275240 : #endif
275241 :
275242 : // This function is used in ROSE in treeTraversal code
275243 : // eventually replaces getVariant() and variant()
275244 : // though after variant() has been removed for a while we will
275245 : // want to change the name of variantT() back to variant()
275246 : // (since the "T" was ment to stand for temporary).
275247 : // When this happens the variantT() will be depricated.
275248 : VariantT
275249 0 : SgNaryComparisonOp::variantT() const
275250 : {
275251 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
275252 0 : ROSE_ASSERT(this != NULL);
275253 0 : return V_SgNaryComparisonOp;
275254 : }
275255 :
275256 : #if 0
275257 : int
275258 : SgNaryComparisonOp::variant() const
275259 : {
275260 : // This function is used in SAGE
275261 : ROSE_ASSERT(this != NULL);
275262 : return NARY_COMPARISON_OP;
275263 : }
275264 : #endif
275265 :
275266 : ROSE_DLL_API const char*
275267 0 : SgNaryComparisonOp::sage_class_name() const
275268 : {
275269 0 : ROSE_ASSERT(this != NULL);
275270 0 : return "SgNaryComparisonOp";
275271 : }
275272 :
275273 : std::string
275274 0 : SgNaryComparisonOp::class_name() const
275275 : {
275276 0 : ROSE_ASSERT(this != NULL);
275277 0 : return "SgNaryComparisonOp";
275278 : }
275279 :
275280 : // DQ (11/26/2005): Support for visitor pattern mechanims
275281 : // (inferior to ROSE traversal mechanism, experimental).
275282 : void
275283 0 : SgNaryComparisonOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
275284 : {
275285 0 : ROSE_ASSERT(this != NULL);
275286 0 : visitor.visit(this);
275287 0 : }
275288 :
275289 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
275290 0 : void SgNaryComparisonOp::accept (ROSE_VisitorPattern & visitor) {
275291 0 : ROSE_ASSERT(this != NULL);
275292 0 : visitor.visit(this);
275293 0 : }
275294 :
275295 : SgNaryComparisonOp*
275296 0 : SgNaryComparisonOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
275297 : {
275298 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
275299 : // This function is currently only supported for the AST used the represent Binary executables.
275300 : if (0 /* isSgAsmNode(this) != NULL */)
275301 : {
275302 : // Support for regex specification.
275303 : std::string prefixCode = "REGEX:";
275304 : addNewAttribute(prefixCode + s,a);
275305 : }
275306 : #endif
275307 :
275308 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
275309 0 : return this;
275310 : }
275311 :
275312 : // *** COMMON CODE SECTION ENDS HERE ***
275313 :
275314 :
275315 : // End of memberFunctionString
275316 : // Start of memberFunctionString
275317 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
275318 :
275319 :
275320 : #if 0
275321 : //! Error checking support
275322 : /*! Verifies the following:
275323 : - working getVariant() member function
275324 : - calls base class's error() member function
275325 : Every class has one of these functions.
275326 : */
275327 : bool
275328 : SgNaryComparisonOp::error()
275329 : {
275330 : // Put error checking here
275331 :
275332 : ROSE_ASSERT (this != NULL);
275333 : if (getVariant() != NARY_COMPARISON_OP)
275334 : {
275335 : printf ("Error in SgNaryComparisonOp::error(): SgNaryComparisonOp object has a %s variant \n",
275336 : Cxx_GrammarTerminalNames[getVariant()].name);
275337 : // printf ("Error in SgNaryComparisonOp::error() \n");
275338 : ROSE_ABORT();
275339 : }
275340 :
275341 : ROSE_ASSERT (getVariant() == NARY_COMPARISON_OP);
275342 : return SgNaryOp::error();
275343 : }
275344 : #endif
275345 :
275346 :
275347 :
275348 : // End of memberFunctionString
275349 :
275350 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
275351 :
275352 0 : SgNaryComparisonOp* isSgNaryComparisonOp ( SgNode* inputDerivedClassPointer )
275353 : {
275354 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
275355 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
275356 : // So to fix this we return NULL directly when the input is NULL and avoid the
275357 : // dynamic_cast in this case. This is likely a performance improvement as well.
275358 : // return dynamic_cast<SgNaryComparisonOp*>(inputDerivedClassPointer);
275359 : // Milind Chabbi (8/28/2013): isSgNaryComparisonOp uses table-driven castability instead of c++ default dynamic_cast
275360 : // this improves the running time performance by 10-20%.
275361 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNaryComparisonOp*>(inputDerivedClassPointer);
275362 0 : return IS_SgNaryComparisonOp_FAST_MACRO(inputDerivedClassPointer);
275363 : }
275364 :
275365 : // DQ (11/8/2003): Added version of functions taking const pointer
275366 0 : const SgNaryComparisonOp* isSgNaryComparisonOp ( const SgNode* inputDerivedClassPointer )
275367 : {
275368 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
275369 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
275370 : // So to fix this we return NULL directly when the input is NULL and avoid the
275371 : // dynamic_cast in this case. This is likely a performance improvement as well.
275372 : // return dynamic_cast<const SgNaryComparisonOp*>(inputDerivedClassPointer);
275373 : // Milind Chabbi (8/28/2013): isSgNaryComparisonOp uses table-driven castability instead of c++ default dynamic_cast
275374 : // this improves the running time performance by 10-20%.
275375 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNaryComparisonOp*>(inputDerivedClassPointer);
275376 0 : return IS_SgNaryComparisonOp_FAST_MACRO(inputDerivedClassPointer);
275377 : }
275378 :
275379 :
275380 :
275381 : /* #line 275382 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275382 :
275383 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
275384 :
275385 : /**
275386 : \brief Generated destructor
275387 :
275388 : This destructor is automatically generated (by ROSETTA). This destructor
275389 : only frees memory of data members associated with the parts of the current IR node which
275390 : are NOT traversed. Those data members that are part of a traversal can be freed using
275391 : a traversal (calling this destructor on all children in a post-order traversal). Such
275392 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
275393 :
275394 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
275395 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
275396 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
275397 :
275398 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
275399 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
275400 : pointers are not yet implemented to call delete on eash pointer in the container.
275401 : (This could be done by derivation from the STL containers to define containers that
275402 : automatically deleted their members.)
275403 :
275404 : */
275405 0 : SgNaryComparisonOp::~SgNaryComparisonOp () {
275406 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
275407 :
275408 :
275409 :
275410 : }
275411 :
275412 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
275413 0 : }
275414 :
275415 :
275416 : /* #line 275417 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275417 :
275418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
275419 :
275420 : // Generated constructor
275421 0 : SgNaryComparisonOp::SgNaryComparisonOp ( Sg_File_Info* startOfConstruct )
275422 0 : : SgNaryOp(startOfConstruct)
275423 : {
275424 : #ifdef DEBUG
275425 : // printf ("In SgNaryComparisonOp::SgNaryComparisonOp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
275426 : #endif
275427 : #if 0
275428 : // debugging information!
275429 : printf ("In SgNaryComparisonOp::SgNaryComparisonOp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
275430 : #endif
275431 :
275432 :
275433 :
275434 : #if 0
275435 : // DQ (7/30/2014): Call a virtual function.
275436 : std::string s = this->class_name();
275437 : #endif
275438 :
275439 : // Test the variant virtual function
275440 : // assert(NARY_COMPARISON_OP == variant());
275441 0 : assert(NARY_COMPARISON_OP == this->variant());
275442 0 : ROSE_ASSERT(NARY_COMPARISON_OP == (int)(this->variantT()));
275443 0 : post_construction_initialization();
275444 :
275445 : // Test the isSgNaryComparisonOp() function since it has been problematic
275446 0 : assert(isSgNaryComparisonOp(this) != NULL);
275447 0 : }
275448 :
275449 : // Generated constructor (all data members)
275450 :
275451 : /* #line 275452 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275452 :
275453 :
275454 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
275455 :
275456 :
275457 : // ********************************************************
275458 : // member functions common across all array grammar objects
275459 : // ********************************************************
275460 :
275461 :
275462 :
275463 : /* #line 275464 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275464 :
275465 :
275466 :
275467 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
275468 :
275469 : // ********************************************************
275470 : // member functions specific to each node in the grammar
275471 : // ********************************************************
275472 :
275473 :
275474 : /* #line 275475 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275475 :
275476 : // Start of memberFunctionString
275477 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275478 :
275479 : void
275480 0 : SgStringConversion::post_construction_initialization()
275481 : {
275482 0 : }
275483 :
275484 :
275485 :
275486 : // End of memberFunctionString
275487 : // Start of memberFunctionString
275488 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
275489 :
275490 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
275491 :
275492 : SgExpression*
275493 0 : SgStringConversion::get_expression () const
275494 : {
275495 0 : ROSE_ASSERT (this != NULL);
275496 :
275497 : #if 0
275498 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
275499 : // used to trigger marking transformations for the token-based unparsing.
275500 : printf ("SgStringConversion::get_expression = %p = %s \n",this,this->class_name().c_str());
275501 : #endif
275502 :
275503 0 : return p_expression;
275504 : }
275505 :
275506 : void
275507 0 : SgStringConversion::set_expression ( SgExpression* expression )
275508 : {
275509 0 : ROSE_ASSERT (this != NULL);
275510 :
275511 : #if 0
275512 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
275513 : // used to trigger marking transformations for the token-based unparsing.
275514 : printf ("SgStringConversion::set_expression = %p = %s \n",this,this->class_name().c_str());
275515 : #endif
275516 :
275517 0 : set_isModified(true);
275518 :
275519 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
275520 : if (p_expression != NULL && expression != NULL && p_expression != expression)
275521 : {
275522 : printf ("Warning: expression = %p overwriting valid pointer p_expression = %p \n",expression,p_expression);
275523 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
275524 : printf ("Error fails assertion (p_expression != NULL && expression != NULL && p_expression != expression) is false\n");
275525 : ROSE_ASSERT(false);
275526 : #endif
275527 : }
275528 : #endif
275529 0 : p_expression = expression;
275530 0 : }
275531 :
275532 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
275533 :
275534 :
275535 : // End of memberFunctionString
275536 : // Start of memberFunctionString
275537 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275538 :
275539 : SgType*
275540 :
275541 0 : SgStringConversion::get_type() const
275542 : {
275543 0 : ROSE_ASSERT(this != NULL);
275544 :
275545 : #if 0
275546 : printf ("In SgStringConversion::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
275547 : #endif
275548 :
275549 : // DQ (10/31/2016): Debugging...
275550 : // return SgTypeDefault::createType();
275551 0 : SgType* returnType = SgTypeDefault::createType();
275552 :
275553 : #if 0
275554 : printf ("Leaving SgStringConversion::get_type() (default_get_type) returnType = %p \n",returnType);
275555 : #endif
275556 :
275557 0 : return returnType;
275558 : }
275559 :
275560 :
275561 :
275562 : // End of memberFunctionString
275563 : // Start of memberFunctionString
275564 : /* #line 7138 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275565 :
275566 :
275567 :
275568 : // End of memberFunctionString
275569 : // Start of memberFunctionString
275570 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
275571 :
275572 : // *** COMMON CODE SECTION BEGINS HERE ***
275573 :
275574 : #if 0
275575 : int
275576 : SgStringConversion::getVariant() const
275577 : {
275578 : // This function is used in ROSE while "variant()" is used in SAGE
275579 : assert(this != NULL);
275580 : return variant();
275581 : }
275582 : #endif
275583 :
275584 : // This function is used in ROSE in treeTraversal code
275585 : // eventually replaces getVariant() and variant()
275586 : // though after variant() has been removed for a while we will
275587 : // want to change the name of variantT() back to variant()
275588 : // (since the "T" was ment to stand for temporary).
275589 : // When this happens the variantT() will be depricated.
275590 : VariantT
275591 0 : SgStringConversion::variantT() const
275592 : {
275593 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
275594 0 : ROSE_ASSERT(this != NULL);
275595 0 : return V_SgStringConversion;
275596 : }
275597 :
275598 : #if 0
275599 : int
275600 : SgStringConversion::variant() const
275601 : {
275602 : // This function is used in SAGE
275603 : ROSE_ASSERT(this != NULL);
275604 : return STR_CONV;
275605 : }
275606 : #endif
275607 :
275608 : ROSE_DLL_API const char*
275609 0 : SgStringConversion::sage_class_name() const
275610 : {
275611 0 : ROSE_ASSERT(this != NULL);
275612 0 : return "SgStringConversion";
275613 : }
275614 :
275615 : std::string
275616 0 : SgStringConversion::class_name() const
275617 : {
275618 0 : ROSE_ASSERT(this != NULL);
275619 0 : return "SgStringConversion";
275620 : }
275621 :
275622 : // DQ (11/26/2005): Support for visitor pattern mechanims
275623 : // (inferior to ROSE traversal mechanism, experimental).
275624 : void
275625 0 : SgStringConversion::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
275626 : {
275627 0 : ROSE_ASSERT(this != NULL);
275628 0 : visitor.visit(this);
275629 0 : }
275630 :
275631 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
275632 0 : void SgStringConversion::accept (ROSE_VisitorPattern & visitor) {
275633 0 : ROSE_ASSERT(this != NULL);
275634 0 : visitor.visit(this);
275635 0 : }
275636 :
275637 : SgStringConversion*
275638 0 : SgStringConversion::addRegExpAttribute(std::string s, AstRegExAttribute* a)
275639 : {
275640 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
275641 : // This function is currently only supported for the AST used the represent Binary executables.
275642 : if (0 /* isSgAsmNode(this) != NULL */)
275643 : {
275644 : // Support for regex specification.
275645 : std::string prefixCode = "REGEX:";
275646 : addNewAttribute(prefixCode + s,a);
275647 : }
275648 : #endif
275649 :
275650 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
275651 0 : return this;
275652 : }
275653 :
275654 : // *** COMMON CODE SECTION ENDS HERE ***
275655 :
275656 :
275657 : // End of memberFunctionString
275658 : // Start of memberFunctionString
275659 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
275660 :
275661 :
275662 : #if 0
275663 : //! Error checking support
275664 : /*! Verifies the following:
275665 : - working getVariant() member function
275666 : - calls base class's error() member function
275667 : Every class has one of these functions.
275668 : */
275669 : bool
275670 : SgStringConversion::error()
275671 : {
275672 : // Put error checking here
275673 :
275674 : ROSE_ASSERT (this != NULL);
275675 : if (getVariant() != STR_CONV)
275676 : {
275677 : printf ("Error in SgStringConversion::error(): SgStringConversion object has a %s variant \n",
275678 : Cxx_GrammarTerminalNames[getVariant()].name);
275679 : // printf ("Error in SgStringConversion::error() \n");
275680 : ROSE_ABORT();
275681 : }
275682 :
275683 : ROSE_ASSERT (getVariant() == STR_CONV);
275684 : return SgExpression::error();
275685 : }
275686 : #endif
275687 :
275688 :
275689 :
275690 : // End of memberFunctionString
275691 :
275692 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
275693 :
275694 0 : SgStringConversion* isSgStringConversion ( SgNode* inputDerivedClassPointer )
275695 : {
275696 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
275697 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
275698 : // So to fix this we return NULL directly when the input is NULL and avoid the
275699 : // dynamic_cast in this case. This is likely a performance improvement as well.
275700 : // return dynamic_cast<SgStringConversion*>(inputDerivedClassPointer);
275701 : // Milind Chabbi (8/28/2013): isSgStringConversion uses table-driven castability instead of c++ default dynamic_cast
275702 : // this improves the running time performance by 10-20%.
275703 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgStringConversion*>(inputDerivedClassPointer);
275704 0 : return IS_SgStringConversion_FAST_MACRO(inputDerivedClassPointer);
275705 : }
275706 :
275707 : // DQ (11/8/2003): Added version of functions taking const pointer
275708 0 : const SgStringConversion* isSgStringConversion ( const SgNode* inputDerivedClassPointer )
275709 : {
275710 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
275711 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
275712 : // So to fix this we return NULL directly when the input is NULL and avoid the
275713 : // dynamic_cast in this case. This is likely a performance improvement as well.
275714 : // return dynamic_cast<const SgStringConversion*>(inputDerivedClassPointer);
275715 : // Milind Chabbi (8/28/2013): isSgStringConversion uses table-driven castability instead of c++ default dynamic_cast
275716 : // this improves the running time performance by 10-20%.
275717 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgStringConversion*>(inputDerivedClassPointer);
275718 0 : return IS_SgStringConversion_FAST_MACRO(inputDerivedClassPointer);
275719 : }
275720 :
275721 :
275722 :
275723 : /* #line 275724 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275724 :
275725 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
275726 :
275727 : /**
275728 : \brief Generated destructor
275729 :
275730 : This destructor is automatically generated (by ROSETTA). This destructor
275731 : only frees memory of data members associated with the parts of the current IR node which
275732 : are NOT traversed. Those data members that are part of a traversal can be freed using
275733 : a traversal (calling this destructor on all children in a post-order traversal). Such
275734 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
275735 :
275736 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
275737 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
275738 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
275739 :
275740 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
275741 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
275742 : pointers are not yet implemented to call delete on eash pointer in the container.
275743 : (This could be done by derivation from the STL containers to define containers that
275744 : automatically deleted their members.)
275745 :
275746 : */
275747 0 : SgStringConversion::~SgStringConversion () {
275748 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
275749 :
275750 :
275751 : // case: not a listType for expression
275752 0 : p_expression = NULL; // non list case
275753 :
275754 : }
275755 :
275756 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
275757 0 : }
275758 :
275759 :
275760 : /* #line 275761 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275761 :
275762 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
275763 :
275764 : // Generated constructor
275765 0 : SgStringConversion::SgStringConversion ( Sg_File_Info* startOfConstruct, SgExpression* expression )
275766 0 : : SgExpression(startOfConstruct)
275767 : {
275768 : #ifdef DEBUG
275769 : // printf ("In SgStringConversion::SgStringConversion (Sg_File_Info* startOfConstruct, SgExpression* expression) sage_class_name() = %s \n",sage_class_name());
275770 : #endif
275771 : #if 0
275772 : // debugging information!
275773 : printf ("In SgStringConversion::SgStringConversion (Sg_File_Info* startOfConstruct, SgExpression* expression): this = %p = %s \n",this,this->class_name().c_str());
275774 : #endif
275775 :
275776 0 : p_expression = expression;
275777 :
275778 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
275779 :
275780 : #if 0
275781 : // DQ (7/30/2014): Call a virtual function.
275782 : std::string s = this->class_name();
275783 : #endif
275784 :
275785 : // Test the variant virtual function
275786 : // assert(STR_CONV == variant());
275787 0 : assert(STR_CONV == this->variant());
275788 0 : ROSE_ASSERT(STR_CONV == (int)(this->variantT()));
275789 0 : post_construction_initialization();
275790 :
275791 : // Test the isSgStringConversion() function since it has been problematic
275792 0 : assert(isSgStringConversion(this) != NULL);
275793 0 : }
275794 :
275795 : // Generated constructor (all data members)
275796 :
275797 : /* #line 275798 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275798 :
275799 :
275800 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
275801 :
275802 :
275803 : // ********************************************************
275804 : // member functions common across all array grammar objects
275805 : // ********************************************************
275806 :
275807 :
275808 :
275809 : /* #line 275810 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275810 :
275811 :
275812 :
275813 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
275814 :
275815 : // ********************************************************
275816 : // member functions specific to each node in the grammar
275817 : // ********************************************************
275818 :
275819 :
275820 : /* #line 275821 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
275821 :
275822 : // Start of memberFunctionString
275823 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275824 :
275825 : void
275826 0 : SgYieldExpression::post_construction_initialization()
275827 : {
275828 0 : }
275829 :
275830 :
275831 :
275832 : // End of memberFunctionString
275833 : // Start of memberFunctionString
275834 : /* #line 4469 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275835 :
275836 :
275837 :
275838 : // End of memberFunctionString
275839 : // Start of memberFunctionString
275840 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
275841 :
275842 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
275843 :
275844 : SgExpression*
275845 0 : SgYieldExpression::get_value () const
275846 : {
275847 0 : ROSE_ASSERT (this != NULL);
275848 :
275849 : #if 0
275850 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
275851 : // used to trigger marking transformations for the token-based unparsing.
275852 : printf ("SgYieldExpression::get_value = %p = %s \n",this,this->class_name().c_str());
275853 : #endif
275854 :
275855 0 : return p_value;
275856 : }
275857 :
275858 : void
275859 0 : SgYieldExpression::set_value ( SgExpression* value )
275860 : {
275861 0 : ROSE_ASSERT (this != NULL);
275862 :
275863 : #if 0
275864 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
275865 : // used to trigger marking transformations for the token-based unparsing.
275866 : printf ("SgYieldExpression::set_value = %p = %s \n",this,this->class_name().c_str());
275867 : #endif
275868 :
275869 0 : set_isModified(true);
275870 :
275871 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
275872 : if (p_value != NULL && value != NULL && p_value != value)
275873 : {
275874 : printf ("Warning: value = %p overwriting valid pointer p_value = %p \n",value,p_value);
275875 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
275876 : printf ("Error fails assertion (p_value != NULL && value != NULL && p_value != value) is false\n");
275877 : ROSE_ASSERT(false);
275878 : #endif
275879 : }
275880 : #endif
275881 0 : p_value = value;
275882 0 : }
275883 :
275884 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
275885 :
275886 :
275887 : // End of memberFunctionString
275888 : // Start of memberFunctionString
275889 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
275890 :
275891 : SgType*
275892 :
275893 0 : SgYieldExpression::get_type() const
275894 : {
275895 0 : ROSE_ASSERT(this != NULL);
275896 :
275897 : #if 0
275898 : printf ("In SgYieldExpression::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
275899 : #endif
275900 :
275901 : // DQ (10/31/2016): Debugging...
275902 : // return SgTypeDefault::createType();
275903 0 : SgType* returnType = SgTypeDefault::createType();
275904 :
275905 : #if 0
275906 : printf ("Leaving SgYieldExpression::get_type() (default_get_type) returnType = %p \n",returnType);
275907 : #endif
275908 :
275909 0 : return returnType;
275910 : }
275911 :
275912 :
275913 :
275914 : // End of memberFunctionString
275915 : // Start of memberFunctionString
275916 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
275917 :
275918 : // *** COMMON CODE SECTION BEGINS HERE ***
275919 :
275920 : #if 0
275921 : int
275922 : SgYieldExpression::getVariant() const
275923 : {
275924 : // This function is used in ROSE while "variant()" is used in SAGE
275925 : assert(this != NULL);
275926 : return variant();
275927 : }
275928 : #endif
275929 :
275930 : // This function is used in ROSE in treeTraversal code
275931 : // eventually replaces getVariant() and variant()
275932 : // though after variant() has been removed for a while we will
275933 : // want to change the name of variantT() back to variant()
275934 : // (since the "T" was ment to stand for temporary).
275935 : // When this happens the variantT() will be depricated.
275936 : VariantT
275937 0 : SgYieldExpression::variantT() const
275938 : {
275939 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
275940 0 : ROSE_ASSERT(this != NULL);
275941 0 : return V_SgYieldExpression;
275942 : }
275943 :
275944 : #if 0
275945 : int
275946 : SgYieldExpression::variant() const
275947 : {
275948 : // This function is used in SAGE
275949 : ROSE_ASSERT(this != NULL);
275950 : return YIELD_EXP;
275951 : }
275952 : #endif
275953 :
275954 : ROSE_DLL_API const char*
275955 0 : SgYieldExpression::sage_class_name() const
275956 : {
275957 0 : ROSE_ASSERT(this != NULL);
275958 0 : return "SgYieldExpression";
275959 : }
275960 :
275961 : std::string
275962 0 : SgYieldExpression::class_name() const
275963 : {
275964 0 : ROSE_ASSERT(this != NULL);
275965 0 : return "SgYieldExpression";
275966 : }
275967 :
275968 : // DQ (11/26/2005): Support for visitor pattern mechanims
275969 : // (inferior to ROSE traversal mechanism, experimental).
275970 : void
275971 0 : SgYieldExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
275972 : {
275973 0 : ROSE_ASSERT(this != NULL);
275974 0 : visitor.visit(this);
275975 0 : }
275976 :
275977 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
275978 0 : void SgYieldExpression::accept (ROSE_VisitorPattern & visitor) {
275979 0 : ROSE_ASSERT(this != NULL);
275980 0 : visitor.visit(this);
275981 0 : }
275982 :
275983 : SgYieldExpression*
275984 0 : SgYieldExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
275985 : {
275986 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
275987 : // This function is currently only supported for the AST used the represent Binary executables.
275988 : if (0 /* isSgAsmNode(this) != NULL */)
275989 : {
275990 : // Support for regex specification.
275991 : std::string prefixCode = "REGEX:";
275992 : addNewAttribute(prefixCode + s,a);
275993 : }
275994 : #endif
275995 :
275996 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
275997 0 : return this;
275998 : }
275999 :
276000 : // *** COMMON CODE SECTION ENDS HERE ***
276001 :
276002 :
276003 : // End of memberFunctionString
276004 : // Start of memberFunctionString
276005 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
276006 :
276007 :
276008 : #if 0
276009 : //! Error checking support
276010 : /*! Verifies the following:
276011 : - working getVariant() member function
276012 : - calls base class's error() member function
276013 : Every class has one of these functions.
276014 : */
276015 : bool
276016 : SgYieldExpression::error()
276017 : {
276018 : // Put error checking here
276019 :
276020 : ROSE_ASSERT (this != NULL);
276021 : if (getVariant() != YIELD_EXP)
276022 : {
276023 : printf ("Error in SgYieldExpression::error(): SgYieldExpression object has a %s variant \n",
276024 : Cxx_GrammarTerminalNames[getVariant()].name);
276025 : // printf ("Error in SgYieldExpression::error() \n");
276026 : ROSE_ABORT();
276027 : }
276028 :
276029 : ROSE_ASSERT (getVariant() == YIELD_EXP);
276030 : return SgExpression::error();
276031 : }
276032 : #endif
276033 :
276034 :
276035 :
276036 : // End of memberFunctionString
276037 :
276038 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
276039 :
276040 0 : SgYieldExpression* isSgYieldExpression ( SgNode* inputDerivedClassPointer )
276041 : {
276042 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
276043 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
276044 : // So to fix this we return NULL directly when the input is NULL and avoid the
276045 : // dynamic_cast in this case. This is likely a performance improvement as well.
276046 : // return dynamic_cast<SgYieldExpression*>(inputDerivedClassPointer);
276047 : // Milind Chabbi (8/28/2013): isSgYieldExpression uses table-driven castability instead of c++ default dynamic_cast
276048 : // this improves the running time performance by 10-20%.
276049 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgYieldExpression*>(inputDerivedClassPointer);
276050 0 : return IS_SgYieldExpression_FAST_MACRO(inputDerivedClassPointer);
276051 : }
276052 :
276053 : // DQ (11/8/2003): Added version of functions taking const pointer
276054 0 : const SgYieldExpression* isSgYieldExpression ( const SgNode* inputDerivedClassPointer )
276055 : {
276056 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
276057 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
276058 : // So to fix this we return NULL directly when the input is NULL and avoid the
276059 : // dynamic_cast in this case. This is likely a performance improvement as well.
276060 : // return dynamic_cast<const SgYieldExpression*>(inputDerivedClassPointer);
276061 : // Milind Chabbi (8/28/2013): isSgYieldExpression uses table-driven castability instead of c++ default dynamic_cast
276062 : // this improves the running time performance by 10-20%.
276063 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgYieldExpression*>(inputDerivedClassPointer);
276064 0 : return IS_SgYieldExpression_FAST_MACRO(inputDerivedClassPointer);
276065 : }
276066 :
276067 :
276068 :
276069 : /* #line 276070 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276070 :
276071 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
276072 :
276073 : /**
276074 : \brief Generated destructor
276075 :
276076 : This destructor is automatically generated (by ROSETTA). This destructor
276077 : only frees memory of data members associated with the parts of the current IR node which
276078 : are NOT traversed. Those data members that are part of a traversal can be freed using
276079 : a traversal (calling this destructor on all children in a post-order traversal). Such
276080 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
276081 :
276082 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
276083 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
276084 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
276085 :
276086 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
276087 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
276088 : pointers are not yet implemented to call delete on eash pointer in the container.
276089 : (This could be done by derivation from the STL containers to define containers that
276090 : automatically deleted their members.)
276091 :
276092 : */
276093 0 : SgYieldExpression::~SgYieldExpression () {
276094 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
276095 :
276096 :
276097 : // case: not a listType for value
276098 0 : p_value = NULL; // non list case
276099 :
276100 : }
276101 :
276102 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
276103 0 : }
276104 :
276105 :
276106 : /* #line 276107 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276107 :
276108 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
276109 :
276110 : // Generated constructor
276111 0 : SgYieldExpression::SgYieldExpression ( Sg_File_Info* startOfConstruct, SgExpression* value )
276112 0 : : SgExpression(startOfConstruct)
276113 : {
276114 : #ifdef DEBUG
276115 : // printf ("In SgYieldExpression::SgYieldExpression (Sg_File_Info* startOfConstruct, SgExpression* value) sage_class_name() = %s \n",sage_class_name());
276116 : #endif
276117 : #if 0
276118 : // debugging information!
276119 : printf ("In SgYieldExpression::SgYieldExpression (Sg_File_Info* startOfConstruct, SgExpression* value): this = %p = %s \n",this,this->class_name().c_str());
276120 : #endif
276121 :
276122 0 : p_value = value;
276123 :
276124 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
276125 :
276126 : #if 0
276127 : // DQ (7/30/2014): Call a virtual function.
276128 : std::string s = this->class_name();
276129 : #endif
276130 :
276131 : // Test the variant virtual function
276132 : // assert(YIELD_EXP == variant());
276133 0 : assert(YIELD_EXP == this->variant());
276134 0 : ROSE_ASSERT(YIELD_EXP == (int)(this->variantT()));
276135 0 : post_construction_initialization();
276136 :
276137 : // Test the isSgYieldExpression() function since it has been problematic
276138 0 : assert(isSgYieldExpression(this) != NULL);
276139 0 : }
276140 :
276141 : // Generated constructor (all data members)
276142 :
276143 : /* #line 276144 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276144 :
276145 :
276146 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
276147 :
276148 :
276149 : // ********************************************************
276150 : // member functions common across all array grammar objects
276151 : // ********************************************************
276152 :
276153 :
276154 :
276155 : /* #line 276156 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276156 :
276157 :
276158 :
276159 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
276160 :
276161 : // ********************************************************
276162 : // member functions specific to each node in the grammar
276163 : // ********************************************************
276164 :
276165 :
276166 : /* #line 276167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276167 :
276168 : // Start of memberFunctionString
276169 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
276170 :
276171 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
276172 :
276173 : SgTemplateFunctionSymbol*
276174 27731 : SgTemplateFunctionRefExp::get_symbol_i () const
276175 : {
276176 27731 : ROSE_ASSERT (this != NULL);
276177 :
276178 : #if 0
276179 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276180 : // used to trigger marking transformations for the token-based unparsing.
276181 : printf ("SgTemplateFunctionRefExp::get_symbol_i = %p = %s \n",this,this->class_name().c_str());
276182 : #endif
276183 :
276184 27731 : return p_symbol_i;
276185 : }
276186 :
276187 : void
276188 0 : SgTemplateFunctionRefExp::set_symbol_i ( SgTemplateFunctionSymbol* symbol_i )
276189 : {
276190 0 : ROSE_ASSERT (this != NULL);
276191 :
276192 : #if 0
276193 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276194 : // used to trigger marking transformations for the token-based unparsing.
276195 : printf ("SgTemplateFunctionRefExp::set_symbol_i = %p = %s \n",this,this->class_name().c_str());
276196 : #endif
276197 :
276198 0 : set_isModified(true);
276199 :
276200 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
276201 : if (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i)
276202 : {
276203 : printf ("Warning: symbol_i = %p overwriting valid pointer p_symbol_i = %p \n",symbol_i,p_symbol_i);
276204 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
276205 : printf ("Error fails assertion (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i) is false\n");
276206 : ROSE_ASSERT(false);
276207 : #endif
276208 : }
276209 : #endif
276210 0 : p_symbol_i = symbol_i;
276211 0 : }
276212 :
276213 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
276214 :
276215 :
276216 : // End of memberFunctionString
276217 : // Start of memberFunctionString
276218 :
276219 :
276220 : // End of memberFunctionString
276221 : // Start of memberFunctionString
276222 : /* #line 3808 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
276223 :
276224 :
276225 : void
276226 2792 : SgTemplateFunctionRefExp::post_construction_initialization()
276227 : {
276228 2792 : }
276229 :
276230 : SgTemplateFunctionSymbol*
276231 26626 : SgTemplateFunctionRefExp::get_symbol() const
276232 : {
276233 : // return isSgTemplateFunctionSymbol(get_symbol_i());
276234 26626 : return get_symbol_i();
276235 : }
276236 :
276237 : void
276238 0 : SgTemplateFunctionRefExp::set_symbol(SgTemplateFunctionSymbol * symbol)
276239 : {
276240 0 : set_symbol_i(symbol);
276241 0 : }
276242 :
276243 : SgTemplateFunctionDeclaration*
276244 0 : SgTemplateFunctionRefExp::getAssociatedFunctionDeclaration() const
276245 : {
276246 : // This is helpful in chasing down the associated declaration to this function reference.
276247 0 : SgTemplateFunctionDeclaration* returnFunctionDeclaration = NULL;
276248 0 : SgTemplateFunctionSymbol* functionSymbol = this->get_symbol();
276249 :
276250 0 : ROSE_ASSERT(functionSymbol != NULL);
276251 :
276252 0 : if (functionSymbol != NULL)
276253 0 : returnFunctionDeclaration = isSgTemplateFunctionDeclaration(functionSymbol->get_declaration());
276254 :
276255 0 : return returnFunctionDeclaration;
276256 : }
276257 :
276258 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
276259 : // so that we could avoid them setting the isModified flag which is a problem in the
276260 : // name qualification support for C++ (interfering with the token-based unparsing).
276261 : int
276262 71 : SgTemplateFunctionRefExp::get_name_qualification_length () const
276263 : {
276264 71 : ROSE_ASSERT (this != NULL);
276265 71 : return p_name_qualification_length;
276266 : }
276267 :
276268 : void
276269 0 : SgTemplateFunctionRefExp::set_name_qualification_length ( int name_qualification_length )
276270 : {
276271 0 : ROSE_ASSERT (this != NULL);
276272 : // This can't be called by the name qualification API (see test2015_26.C).
276273 : // set_isModified(true);
276274 :
276275 0 : p_name_qualification_length = name_qualification_length;
276276 0 : }
276277 :
276278 : bool
276279 0 : SgTemplateFunctionRefExp::get_type_elaboration_required () const
276280 : {
276281 0 : ROSE_ASSERT (this != NULL);
276282 0 : return p_type_elaboration_required;
276283 : }
276284 :
276285 : void
276286 0 : SgTemplateFunctionRefExp::set_type_elaboration_required ( bool type_elaboration_required )
276287 : {
276288 0 : ROSE_ASSERT (this != NULL);
276289 : // This can't be called by the name qualification API (see test2015_26.C).
276290 : // set_isModified(true);
276291 :
276292 0 : p_type_elaboration_required = type_elaboration_required;
276293 0 : }
276294 :
276295 : bool
276296 71 : SgTemplateFunctionRefExp::get_global_qualification_required () const
276297 : {
276298 71 : ROSE_ASSERT (this != NULL);
276299 71 : return p_global_qualification_required;
276300 : }
276301 :
276302 : void
276303 0 : SgTemplateFunctionRefExp::set_global_qualification_required ( bool global_qualification_required )
276304 : {
276305 0 : ROSE_ASSERT (this != NULL);
276306 :
276307 : // This can't be called by the name qualification API (see test2015_26.C).
276308 : // set_isModified(true);
276309 :
276310 0 : p_global_qualification_required = global_qualification_required;
276311 0 : }
276312 :
276313 :
276314 :
276315 : // End of memberFunctionString
276316 : // Start of memberFunctionString
276317 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
276318 :
276319 :
276320 : SgType*
276321 17177 : SgTemplateFunctionRefExp::get_type() const
276322 : {
276323 17177 : ROSE_ASSERT(this != NULL);
276324 :
276325 : #if 0
276326 : printf ("In SgTemplateFunctionRefExp::get_type() \n");
276327 : #endif
276328 :
276329 17177 : SgSymbol* symbol = this->get_symbol();
276330 17177 : if (symbol == NULL)
276331 : {
276332 0 : printf ("Error: In SgTemplateFunctionRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
276333 : }
276334 17177 : ROSE_ASSERT(symbol != NULL);
276335 :
276336 : // DQ (9/27/2006): Added assertion
276337 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
276338 :
276339 : // printf ("In SgTemplateFunctionRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
276340 17177 : SgType* type = symbol->get_type();
276341 17177 : if (type == NULL)
276342 : {
276343 0 : printf ("Error: In SgTemplateFunctionRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
276344 : }
276345 17177 : ROSE_ASSERT(type != NULL);
276346 :
276347 : // return get_symbol()->get_type();
276348 17177 : return type;
276349 : }
276350 :
276351 :
276352 :
276353 : // End of memberFunctionString
276354 : // Start of memberFunctionString
276355 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
276356 :
276357 : // *** COMMON CODE SECTION BEGINS HERE ***
276358 :
276359 : #if 0
276360 : int
276361 : SgTemplateFunctionRefExp::getVariant() const
276362 : {
276363 : // This function is used in ROSE while "variant()" is used in SAGE
276364 : assert(this != NULL);
276365 : return variant();
276366 : }
276367 : #endif
276368 :
276369 : // This function is used in ROSE in treeTraversal code
276370 : // eventually replaces getVariant() and variant()
276371 : // though after variant() has been removed for a while we will
276372 : // want to change the name of variantT() back to variant()
276373 : // (since the "T" was ment to stand for temporary).
276374 : // When this happens the variantT() will be depricated.
276375 : VariantT
276376 1071730 : SgTemplateFunctionRefExp::variantT() const
276377 : {
276378 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
276379 1071730 : ROSE_ASSERT(this != NULL);
276380 1071730 : return V_SgTemplateFunctionRefExp;
276381 : }
276382 :
276383 : #if 0
276384 : int
276385 : SgTemplateFunctionRefExp::variant() const
276386 : {
276387 : // This function is used in SAGE
276388 : ROSE_ASSERT(this != NULL);
276389 : return TEMPLATE_FUNCTION_REF;
276390 : }
276391 : #endif
276392 :
276393 : ROSE_DLL_API const char*
276394 0 : SgTemplateFunctionRefExp::sage_class_name() const
276395 : {
276396 0 : ROSE_ASSERT(this != NULL);
276397 0 : return "SgTemplateFunctionRefExp";
276398 : }
276399 :
276400 : std::string
276401 2179 : SgTemplateFunctionRefExp::class_name() const
276402 : {
276403 2179 : ROSE_ASSERT(this != NULL);
276404 2179 : return "SgTemplateFunctionRefExp";
276405 : }
276406 :
276407 : // DQ (11/26/2005): Support for visitor pattern mechanims
276408 : // (inferior to ROSE traversal mechanism, experimental).
276409 : void
276410 34899 : SgTemplateFunctionRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
276411 : {
276412 34899 : ROSE_ASSERT(this != NULL);
276413 34899 : visitor.visit(this);
276414 34899 : }
276415 :
276416 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
276417 0 : void SgTemplateFunctionRefExp::accept (ROSE_VisitorPattern & visitor) {
276418 0 : ROSE_ASSERT(this != NULL);
276419 0 : visitor.visit(this);
276420 0 : }
276421 :
276422 : SgTemplateFunctionRefExp*
276423 0 : SgTemplateFunctionRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
276424 : {
276425 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
276426 : // This function is currently only supported for the AST used the represent Binary executables.
276427 : if (0 /* isSgAsmNode(this) != NULL */)
276428 : {
276429 : // Support for regex specification.
276430 : std::string prefixCode = "REGEX:";
276431 : addNewAttribute(prefixCode + s,a);
276432 : }
276433 : #endif
276434 :
276435 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
276436 0 : return this;
276437 : }
276438 :
276439 : // *** COMMON CODE SECTION ENDS HERE ***
276440 :
276441 :
276442 : // End of memberFunctionString
276443 : // Start of memberFunctionString
276444 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
276445 :
276446 :
276447 : #if 0
276448 : //! Error checking support
276449 : /*! Verifies the following:
276450 : - working getVariant() member function
276451 : - calls base class's error() member function
276452 : Every class has one of these functions.
276453 : */
276454 : bool
276455 : SgTemplateFunctionRefExp::error()
276456 : {
276457 : // Put error checking here
276458 :
276459 : ROSE_ASSERT (this != NULL);
276460 : if (getVariant() != TEMPLATE_FUNCTION_REF)
276461 : {
276462 : printf ("Error in SgTemplateFunctionRefExp::error(): SgTemplateFunctionRefExp object has a %s variant \n",
276463 : Cxx_GrammarTerminalNames[getVariant()].name);
276464 : // printf ("Error in SgTemplateFunctionRefExp::error() \n");
276465 : ROSE_ABORT();
276466 : }
276467 :
276468 : ROSE_ASSERT (getVariant() == TEMPLATE_FUNCTION_REF);
276469 : return SgExpression::error();
276470 : }
276471 : #endif
276472 :
276473 :
276474 :
276475 : // End of memberFunctionString
276476 :
276477 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
276478 :
276479 8818 : SgTemplateFunctionRefExp* isSgTemplateFunctionRefExp ( SgNode* inputDerivedClassPointer )
276480 : {
276481 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
276482 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
276483 : // So to fix this we return NULL directly when the input is NULL and avoid the
276484 : // dynamic_cast in this case. This is likely a performance improvement as well.
276485 : // return dynamic_cast<SgTemplateFunctionRefExp*>(inputDerivedClassPointer);
276486 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
276487 : // this improves the running time performance by 10-20%.
276488 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateFunctionRefExp*>(inputDerivedClassPointer);
276489 8818 : return IS_SgTemplateFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
276490 : }
276491 :
276492 : // DQ (11/8/2003): Added version of functions taking const pointer
276493 1105 : const SgTemplateFunctionRefExp* isSgTemplateFunctionRefExp ( const SgNode* inputDerivedClassPointer )
276494 : {
276495 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
276496 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
276497 : // So to fix this we return NULL directly when the input is NULL and avoid the
276498 : // dynamic_cast in this case. This is likely a performance improvement as well.
276499 : // return dynamic_cast<const SgTemplateFunctionRefExp*>(inputDerivedClassPointer);
276500 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
276501 : // this improves the running time performance by 10-20%.
276502 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateFunctionRefExp*>(inputDerivedClassPointer);
276503 1105 : return IS_SgTemplateFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
276504 : }
276505 :
276506 :
276507 :
276508 : /* #line 276509 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276509 :
276510 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
276511 :
276512 : /**
276513 : \brief Generated destructor
276514 :
276515 : This destructor is automatically generated (by ROSETTA). This destructor
276516 : only frees memory of data members associated with the parts of the current IR node which
276517 : are NOT traversed. Those data members that are part of a traversal can be freed using
276518 : a traversal (calling this destructor on all children in a post-order traversal). Such
276519 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
276520 :
276521 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
276522 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
276523 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
276524 :
276525 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
276526 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
276527 : pointers are not yet implemented to call delete on eash pointer in the container.
276528 : (This could be done by derivation from the STL containers to define containers that
276529 : automatically deleted their members.)
276530 :
276531 : */
276532 932 : SgTemplateFunctionRefExp::~SgTemplateFunctionRefExp () {
276533 466 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
276534 :
276535 :
276536 : // case: not a listType for symbol_i
276537 466 : p_symbol_i = NULL; // non list case
276538 : // case: not a listType for name_qualification_length
276539 466 : p_name_qualification_length = 0; // non list case
276540 : // case: not a listType for type_elaboration_required
276541 466 : p_type_elaboration_required = false; // non list case
276542 : // case: not a listType for global_qualification_required
276543 466 : p_global_qualification_required = false; // non list case
276544 :
276545 : }
276546 :
276547 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
276548 932 : }
276549 :
276550 :
276551 : /* #line 276552 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276552 :
276553 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
276554 :
276555 : // Generated constructor
276556 6 : SgTemplateFunctionRefExp::SgTemplateFunctionRefExp ( Sg_File_Info* startOfConstruct, SgTemplateFunctionSymbol* symbol_i )
276557 6 : : SgExpression(startOfConstruct)
276558 : {
276559 : #ifdef DEBUG
276560 : // printf ("In SgTemplateFunctionRefExp::SgTemplateFunctionRefExp (Sg_File_Info* startOfConstruct, SgTemplateFunctionSymbol* symbol_i) sage_class_name() = %s \n",sage_class_name());
276561 : #endif
276562 : #if 0
276563 : // debugging information!
276564 : printf ("In SgTemplateFunctionRefExp::SgTemplateFunctionRefExp (Sg_File_Info* startOfConstruct, SgTemplateFunctionSymbol* symbol_i): this = %p = %s \n",this,this->class_name().c_str());
276565 : #endif
276566 :
276567 6 : p_symbol_i = symbol_i;
276568 6 : p_name_qualification_length = 0;
276569 6 : p_type_elaboration_required = false;
276570 6 : p_global_qualification_required = false;
276571 :
276572 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
276573 :
276574 : #if 0
276575 : // DQ (7/30/2014): Call a virtual function.
276576 : std::string s = this->class_name();
276577 : #endif
276578 :
276579 : // Test the variant virtual function
276580 : // assert(TEMPLATE_FUNCTION_REF == variant());
276581 6 : assert(TEMPLATE_FUNCTION_REF == this->variant());
276582 6 : ROSE_ASSERT(TEMPLATE_FUNCTION_REF == (int)(this->variantT()));
276583 6 : post_construction_initialization();
276584 :
276585 : // Test the isSgTemplateFunctionRefExp() function since it has been problematic
276586 6 : assert(isSgTemplateFunctionRefExp(this) != NULL);
276587 6 : }
276588 :
276589 : // Generated constructor (all data members)
276590 :
276591 : /* #line 276592 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276592 :
276593 :
276594 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
276595 :
276596 :
276597 : // ********************************************************
276598 : // member functions common across all array grammar objects
276599 : // ********************************************************
276600 :
276601 :
276602 :
276603 : /* #line 276604 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276604 :
276605 :
276606 :
276607 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
276608 :
276609 : // ********************************************************
276610 : // member functions specific to each node in the grammar
276611 : // ********************************************************
276612 :
276613 :
276614 : /* #line 276615 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
276615 :
276616 : // Start of memberFunctionString
276617 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
276618 :
276619 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
276620 :
276621 : SgTemplateMemberFunctionSymbol*
276622 53040 : SgTemplateMemberFunctionRefExp::get_symbol_i () const
276623 : {
276624 53040 : ROSE_ASSERT (this != NULL);
276625 :
276626 : #if 0
276627 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276628 : // used to trigger marking transformations for the token-based unparsing.
276629 : printf ("SgTemplateMemberFunctionRefExp::get_symbol_i = %p = %s \n",this,this->class_name().c_str());
276630 : #endif
276631 :
276632 53040 : return p_symbol_i;
276633 : }
276634 :
276635 : void
276636 0 : SgTemplateMemberFunctionRefExp::set_symbol_i ( SgTemplateMemberFunctionSymbol* symbol_i )
276637 : {
276638 0 : ROSE_ASSERT (this != NULL);
276639 :
276640 : #if 0
276641 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276642 : // used to trigger marking transformations for the token-based unparsing.
276643 : printf ("SgTemplateMemberFunctionRefExp::set_symbol_i = %p = %s \n",this,this->class_name().c_str());
276644 : #endif
276645 :
276646 0 : set_isModified(true);
276647 :
276648 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
276649 : if (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i)
276650 : {
276651 : printf ("Warning: symbol_i = %p overwriting valid pointer p_symbol_i = %p \n",symbol_i,p_symbol_i);
276652 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
276653 : printf ("Error fails assertion (p_symbol_i != NULL && symbol_i != NULL && p_symbol_i != symbol_i) is false\n");
276654 : ROSE_ASSERT(false);
276655 : #endif
276656 : }
276657 : #endif
276658 0 : p_symbol_i = symbol_i;
276659 0 : }
276660 :
276661 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
276662 :
276663 :
276664 : // End of memberFunctionString
276665 : // Start of memberFunctionString
276666 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
276667 :
276668 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
276669 :
276670 : int
276671 0 : SgTemplateMemberFunctionRefExp::get_virtual_call () const
276672 : {
276673 0 : ROSE_ASSERT (this != NULL);
276674 :
276675 : #if 0
276676 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276677 : // used to trigger marking transformations for the token-based unparsing.
276678 : printf ("SgTemplateMemberFunctionRefExp::get_virtual_call = %p = %s \n",this,this->class_name().c_str());
276679 : #endif
276680 :
276681 0 : return p_virtual_call;
276682 : }
276683 :
276684 : void
276685 0 : SgTemplateMemberFunctionRefExp::set_virtual_call ( int virtual_call )
276686 : {
276687 0 : ROSE_ASSERT (this != NULL);
276688 :
276689 : #if 0
276690 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276691 : // used to trigger marking transformations for the token-based unparsing.
276692 : printf ("SgTemplateMemberFunctionRefExp::set_virtual_call = %p = %s \n",this,this->class_name().c_str());
276693 : #endif
276694 :
276695 0 : set_isModified(true);
276696 :
276697 0 : p_virtual_call = virtual_call;
276698 0 : }
276699 :
276700 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
276701 :
276702 :
276703 : // End of memberFunctionString
276704 : // Start of memberFunctionString
276705 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
276706 :
276707 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
276708 :
276709 : int
276710 22 : SgTemplateMemberFunctionRefExp::get_need_qualifier () const
276711 : {
276712 22 : ROSE_ASSERT (this != NULL);
276713 :
276714 : #if 0
276715 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276716 : // used to trigger marking transformations for the token-based unparsing.
276717 : printf ("SgTemplateMemberFunctionRefExp::get_need_qualifier = %p = %s \n",this,this->class_name().c_str());
276718 : #endif
276719 :
276720 22 : return p_need_qualifier;
276721 : }
276722 :
276723 : void
276724 0 : SgTemplateMemberFunctionRefExp::set_need_qualifier ( int need_qualifier )
276725 : {
276726 0 : ROSE_ASSERT (this != NULL);
276727 :
276728 : #if 0
276729 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
276730 : // used to trigger marking transformations for the token-based unparsing.
276731 : printf ("SgTemplateMemberFunctionRefExp::set_need_qualifier = %p = %s \n",this,this->class_name().c_str());
276732 : #endif
276733 :
276734 0 : set_isModified(true);
276735 :
276736 0 : p_need_qualifier = need_qualifier;
276737 0 : }
276738 :
276739 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
276740 :
276741 :
276742 : // End of memberFunctionString
276743 : // Start of memberFunctionString
276744 :
276745 :
276746 : // End of memberFunctionString
276747 : // Start of memberFunctionString
276748 : /* #line 3901 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
276749 :
276750 :
276751 : void
276752 7304 : SgTemplateMemberFunctionRefExp::post_construction_initialization()
276753 : {
276754 7304 : }
276755 :
276756 : SgTemplateMemberFunctionSymbol*
276757 52856 : SgTemplateMemberFunctionRefExp::get_symbol() const
276758 : {
276759 : // return isSgTemplateMemberFunctionSymbol(get_symbol_i());
276760 52856 : return get_symbol_i();
276761 : }
276762 :
276763 : void
276764 0 : SgTemplateMemberFunctionRefExp::set_symbol(SgTemplateMemberFunctionSymbol * symbol)
276765 : {
276766 0 : set_symbol_i(symbol);
276767 0 : }
276768 :
276769 : // DQ (2/8/2009): I always wanted to have this function!
276770 : SgTemplateMemberFunctionDeclaration*
276771 0 : SgTemplateMemberFunctionRefExp::getAssociatedMemberFunctionDeclaration() const
276772 : {
276773 : // This is helpful in chasing down the associated declaration to this member function reference.
276774 0 : SgTemplateMemberFunctionDeclaration* returnMemberFunctionDeclaration = NULL;
276775 0 : SgTemplateMemberFunctionSymbol* memberFunctionSymbol = this->get_symbol();
276776 :
276777 0 : ROSE_ASSERT(memberFunctionSymbol != NULL);
276778 :
276779 0 : if (memberFunctionSymbol != NULL)
276780 0 : returnMemberFunctionDeclaration = isSgTemplateMemberFunctionDeclaration(memberFunctionSymbol->get_declaration());
276781 :
276782 0 : return returnMemberFunctionDeclaration;
276783 : }
276784 :
276785 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
276786 : // so that we could avoid them setting the isModified flag which is a problem in the
276787 : // name qualification support for C++ (interfering with the token-based unparsing).
276788 : int
276789 0 : SgTemplateMemberFunctionRefExp::get_name_qualification_length () const
276790 : {
276791 0 : ROSE_ASSERT (this != NULL);
276792 0 : return p_name_qualification_length;
276793 : }
276794 :
276795 : void
276796 0 : SgTemplateMemberFunctionRefExp::set_name_qualification_length ( int name_qualification_length )
276797 : {
276798 0 : ROSE_ASSERT (this != NULL);
276799 : // This can't be called by the name qualification API (see test2015_26.C).
276800 : // set_isModified(true);
276801 :
276802 0 : p_name_qualification_length = name_qualification_length;
276803 0 : }
276804 :
276805 : bool
276806 0 : SgTemplateMemberFunctionRefExp::get_type_elaboration_required () const
276807 : {
276808 0 : ROSE_ASSERT (this != NULL);
276809 0 : return p_type_elaboration_required;
276810 : }
276811 :
276812 : void
276813 0 : SgTemplateMemberFunctionRefExp::set_type_elaboration_required ( bool type_elaboration_required )
276814 : {
276815 0 : ROSE_ASSERT (this != NULL);
276816 : // This can't be called by the name qualification API (see test2015_26.C).
276817 : // set_isModified(true);
276818 :
276819 0 : p_type_elaboration_required = type_elaboration_required;
276820 0 : }
276821 :
276822 : bool
276823 0 : SgTemplateMemberFunctionRefExp::get_global_qualification_required () const
276824 : {
276825 0 : ROSE_ASSERT (this != NULL);
276826 0 : return p_global_qualification_required;
276827 : }
276828 :
276829 : void
276830 0 : SgTemplateMemberFunctionRefExp::set_global_qualification_required ( bool global_qualification_required )
276831 : {
276832 0 : ROSE_ASSERT (this != NULL);
276833 :
276834 : // This can't be called by the name qualification API (see test2015_26.C).
276835 : // set_isModified(true);
276836 :
276837 0 : p_global_qualification_required = global_qualification_required;
276838 0 : }
276839 :
276840 :
276841 :
276842 : // End of memberFunctionString
276843 : // Start of memberFunctionString
276844 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
276845 :
276846 :
276847 : SgType*
276848 47023 : SgTemplateMemberFunctionRefExp::get_type() const
276849 : {
276850 47023 : ROSE_ASSERT(this != NULL);
276851 :
276852 : #if 0
276853 : printf ("In SgTemplateMemberFunctionRefExp::get_type() \n");
276854 : #endif
276855 :
276856 47023 : SgSymbol* symbol = this->get_symbol();
276857 47023 : if (symbol == NULL)
276858 : {
276859 0 : printf ("Error: In SgTemplateMemberFunctionRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
276860 : }
276861 47023 : ROSE_ASSERT(symbol != NULL);
276862 :
276863 : // DQ (9/27/2006): Added assertion
276864 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
276865 :
276866 : // printf ("In SgTemplateMemberFunctionRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
276867 47023 : SgType* type = symbol->get_type();
276868 47023 : if (type == NULL)
276869 : {
276870 0 : printf ("Error: In SgTemplateMemberFunctionRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
276871 : }
276872 47023 : ROSE_ASSERT(type != NULL);
276873 :
276874 : // return get_symbol()->get_type();
276875 47023 : return type;
276876 : }
276877 :
276878 :
276879 :
276880 : // End of memberFunctionString
276881 : // Start of memberFunctionString
276882 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
276883 :
276884 : // *** COMMON CODE SECTION BEGINS HERE ***
276885 :
276886 : #if 0
276887 : int
276888 : SgTemplateMemberFunctionRefExp::getVariant() const
276889 : {
276890 : // This function is used in ROSE while "variant()" is used in SAGE
276891 : assert(this != NULL);
276892 : return variant();
276893 : }
276894 : #endif
276895 :
276896 : // This function is used in ROSE in treeTraversal code
276897 : // eventually replaces getVariant() and variant()
276898 : // though after variant() has been removed for a while we will
276899 : // want to change the name of variantT() back to variant()
276900 : // (since the "T" was ment to stand for temporary).
276901 : // When this happens the variantT() will be depricated.
276902 : VariantT
276903 2067220 : SgTemplateMemberFunctionRefExp::variantT() const
276904 : {
276905 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
276906 2067220 : ROSE_ASSERT(this != NULL);
276907 2067220 : return V_SgTemplateMemberFunctionRefExp;
276908 : }
276909 :
276910 : #if 0
276911 : int
276912 : SgTemplateMemberFunctionRefExp::variant() const
276913 : {
276914 : // This function is used in SAGE
276915 : ROSE_ASSERT(this != NULL);
276916 : return TEMPLATE_MEMBER_FUNCTION_REF;
276917 : }
276918 : #endif
276919 :
276920 : ROSE_DLL_API const char*
276921 0 : SgTemplateMemberFunctionRefExp::sage_class_name() const
276922 : {
276923 0 : ROSE_ASSERT(this != NULL);
276924 0 : return "SgTemplateMemberFunctionRefExp";
276925 : }
276926 :
276927 : std::string
276928 6834 : SgTemplateMemberFunctionRefExp::class_name() const
276929 : {
276930 6834 : ROSE_ASSERT(this != NULL);
276931 6834 : return "SgTemplateMemberFunctionRefExp";
276932 : }
276933 :
276934 : // DQ (11/26/2005): Support for visitor pattern mechanims
276935 : // (inferior to ROSE traversal mechanism, experimental).
276936 : void
276937 107632 : SgTemplateMemberFunctionRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
276938 : {
276939 107632 : ROSE_ASSERT(this != NULL);
276940 107632 : visitor.visit(this);
276941 107632 : }
276942 :
276943 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
276944 0 : void SgTemplateMemberFunctionRefExp::accept (ROSE_VisitorPattern & visitor) {
276945 0 : ROSE_ASSERT(this != NULL);
276946 0 : visitor.visit(this);
276947 0 : }
276948 :
276949 : SgTemplateMemberFunctionRefExp*
276950 0 : SgTemplateMemberFunctionRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
276951 : {
276952 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
276953 : // This function is currently only supported for the AST used the represent Binary executables.
276954 : if (0 /* isSgAsmNode(this) != NULL */)
276955 : {
276956 : // Support for regex specification.
276957 : std::string prefixCode = "REGEX:";
276958 : addNewAttribute(prefixCode + s,a);
276959 : }
276960 : #endif
276961 :
276962 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
276963 0 : return this;
276964 : }
276965 :
276966 : // *** COMMON CODE SECTION ENDS HERE ***
276967 :
276968 :
276969 : // End of memberFunctionString
276970 : // Start of memberFunctionString
276971 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
276972 :
276973 :
276974 : #if 0
276975 : //! Error checking support
276976 : /*! Verifies the following:
276977 : - working getVariant() member function
276978 : - calls base class's error() member function
276979 : Every class has one of these functions.
276980 : */
276981 : bool
276982 : SgTemplateMemberFunctionRefExp::error()
276983 : {
276984 : // Put error checking here
276985 :
276986 : ROSE_ASSERT (this != NULL);
276987 : if (getVariant() != TEMPLATE_MEMBER_FUNCTION_REF)
276988 : {
276989 : printf ("Error in SgTemplateMemberFunctionRefExp::error(): SgTemplateMemberFunctionRefExp object has a %s variant \n",
276990 : Cxx_GrammarTerminalNames[getVariant()].name);
276991 : // printf ("Error in SgTemplateMemberFunctionRefExp::error() \n");
276992 : ROSE_ABORT();
276993 : }
276994 :
276995 : ROSE_ASSERT (getVariant() == TEMPLATE_MEMBER_FUNCTION_REF);
276996 : return SgExpression::error();
276997 : }
276998 : #endif
276999 :
277000 :
277001 :
277002 : // End of memberFunctionString
277003 :
277004 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
277005 :
277006 15820 : SgTemplateMemberFunctionRefExp* isSgTemplateMemberFunctionRefExp ( SgNode* inputDerivedClassPointer )
277007 : {
277008 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
277009 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
277010 : // So to fix this we return NULL directly when the input is NULL and avoid the
277011 : // dynamic_cast in this case. This is likely a performance improvement as well.
277012 : // return dynamic_cast<SgTemplateMemberFunctionRefExp*>(inputDerivedClassPointer);
277013 : // Milind Chabbi (8/28/2013): isSgTemplateMemberFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
277014 : // this improves the running time performance by 10-20%.
277015 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateMemberFunctionRefExp*>(inputDerivedClassPointer);
277016 15820 : return IS_SgTemplateMemberFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
277017 : }
277018 :
277019 : // DQ (11/8/2003): Added version of functions taking const pointer
277020 184 : const SgTemplateMemberFunctionRefExp* isSgTemplateMemberFunctionRefExp ( const SgNode* inputDerivedClassPointer )
277021 : {
277022 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
277023 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
277024 : // So to fix this we return NULL directly when the input is NULL and avoid the
277025 : // dynamic_cast in this case. This is likely a performance improvement as well.
277026 : // return dynamic_cast<const SgTemplateMemberFunctionRefExp*>(inputDerivedClassPointer);
277027 : // Milind Chabbi (8/28/2013): isSgTemplateMemberFunctionRefExp uses table-driven castability instead of c++ default dynamic_cast
277028 : // this improves the running time performance by 10-20%.
277029 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateMemberFunctionRefExp*>(inputDerivedClassPointer);
277030 184 : return IS_SgTemplateMemberFunctionRefExp_FAST_MACRO(inputDerivedClassPointer);
277031 : }
277032 :
277033 :
277034 :
277035 : /* #line 277036 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277036 :
277037 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
277038 :
277039 : /**
277040 : \brief Generated destructor
277041 :
277042 : This destructor is automatically generated (by ROSETTA). This destructor
277043 : only frees memory of data members associated with the parts of the current IR node which
277044 : are NOT traversed. Those data members that are part of a traversal can be freed using
277045 : a traversal (calling this destructor on all children in a post-order traversal). Such
277046 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
277047 :
277048 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
277049 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
277050 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
277051 :
277052 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
277053 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
277054 : pointers are not yet implemented to call delete on eash pointer in the container.
277055 : (This could be done by derivation from the STL containers to define containers that
277056 : automatically deleted their members.)
277057 :
277058 : */
277059 3112 : SgTemplateMemberFunctionRefExp::~SgTemplateMemberFunctionRefExp () {
277060 1556 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
277061 :
277062 :
277063 : // case: not a listType for symbol_i
277064 1556 : p_symbol_i = NULL; // non list case
277065 : // case: not a listType for virtual_call
277066 1556 : p_virtual_call = 0; // non list case
277067 : // case: not a listType for need_qualifier
277068 1556 : p_need_qualifier = true; // non list case
277069 : // case: not a listType for name_qualification_length
277070 1556 : p_name_qualification_length = 0; // non list case
277071 : // case: not a listType for type_elaboration_required
277072 1556 : p_type_elaboration_required = false; // non list case
277073 : // case: not a listType for global_qualification_required
277074 1556 : p_global_qualification_required = false; // non list case
277075 :
277076 : }
277077 :
277078 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
277079 3112 : }
277080 :
277081 :
277082 : /* #line 277083 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277083 :
277084 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
277085 :
277086 : // Generated constructor
277087 226 : SgTemplateMemberFunctionRefExp::SgTemplateMemberFunctionRefExp ( Sg_File_Info* startOfConstruct, SgTemplateMemberFunctionSymbol* symbol_i, int virtual_call, int need_qualifier )
277088 226 : : SgExpression(startOfConstruct)
277089 : {
277090 : #ifdef DEBUG
277091 : // printf ("In SgTemplateMemberFunctionRefExp::SgTemplateMemberFunctionRefExp (Sg_File_Info* startOfConstruct, SgTemplateMemberFunctionSymbol* symbol_i, int virtual_call, int need_qualifier) sage_class_name() = %s \n",sage_class_name());
277092 : #endif
277093 : #if 0
277094 : // debugging information!
277095 : printf ("In SgTemplateMemberFunctionRefExp::SgTemplateMemberFunctionRefExp (Sg_File_Info* startOfConstruct, SgTemplateMemberFunctionSymbol* symbol_i, int virtual_call, int need_qualifier): this = %p = %s \n",this,this->class_name().c_str());
277096 : #endif
277097 :
277098 226 : p_symbol_i = symbol_i;
277099 226 : p_virtual_call = virtual_call;
277100 226 : p_need_qualifier = need_qualifier;
277101 226 : p_name_qualification_length = 0;
277102 226 : p_type_elaboration_required = false;
277103 226 : p_global_qualification_required = false;
277104 :
277105 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
277106 :
277107 : #if 0
277108 : // DQ (7/30/2014): Call a virtual function.
277109 : std::string s = this->class_name();
277110 : #endif
277111 :
277112 : // Test the variant virtual function
277113 : // assert(TEMPLATE_MEMBER_FUNCTION_REF == variant());
277114 226 : assert(TEMPLATE_MEMBER_FUNCTION_REF == this->variant());
277115 226 : ROSE_ASSERT(TEMPLATE_MEMBER_FUNCTION_REF == (int)(this->variantT()));
277116 226 : post_construction_initialization();
277117 :
277118 : // Test the isSgTemplateMemberFunctionRefExp() function since it has been problematic
277119 226 : assert(isSgTemplateMemberFunctionRefExp(this) != NULL);
277120 226 : }
277121 :
277122 : // Generated constructor (all data members)
277123 :
277124 : /* #line 277125 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277125 :
277126 :
277127 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
277128 :
277129 :
277130 : // ********************************************************
277131 : // member functions common across all array grammar objects
277132 : // ********************************************************
277133 :
277134 :
277135 :
277136 : /* #line 277137 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277137 :
277138 :
277139 :
277140 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
277141 :
277142 : // ********************************************************
277143 : // member functions specific to each node in the grammar
277144 : // ********************************************************
277145 :
277146 :
277147 : /* #line 277148 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277148 :
277149 : // Start of memberFunctionString
277150 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
277151 :
277152 : void
277153 53 : SgAlignOfOp::post_construction_initialization()
277154 : {
277155 53 : }
277156 :
277157 :
277158 :
277159 : // End of memberFunctionString
277160 : // Start of memberFunctionString
277161 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
277162 :
277163 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
277164 :
277165 : SgExpression*
277166 33 : SgAlignOfOp::get_operand_expr () const
277167 : {
277168 33 : ROSE_ASSERT (this != NULL);
277169 :
277170 : #if 0
277171 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277172 : // used to trigger marking transformations for the token-based unparsing.
277173 : printf ("SgAlignOfOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
277174 : #endif
277175 :
277176 33 : return p_operand_expr;
277177 : }
277178 :
277179 : void
277180 0 : SgAlignOfOp::set_operand_expr ( SgExpression* operand_expr )
277181 : {
277182 0 : ROSE_ASSERT (this != NULL);
277183 :
277184 : #if 0
277185 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277186 : // used to trigger marking transformations for the token-based unparsing.
277187 : printf ("SgAlignOfOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
277188 : #endif
277189 :
277190 0 : set_isModified(true);
277191 :
277192 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
277193 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
277194 : {
277195 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
277196 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
277197 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
277198 : ROSE_ASSERT(false);
277199 : #endif
277200 : }
277201 : #endif
277202 0 : p_operand_expr = operand_expr;
277203 0 : }
277204 :
277205 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
277206 :
277207 :
277208 : // End of memberFunctionString
277209 : // Start of memberFunctionString
277210 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
277211 :
277212 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
277213 :
277214 : SgType*
277215 69 : SgAlignOfOp::get_operand_type () const
277216 : {
277217 69 : ROSE_ASSERT (this != NULL);
277218 :
277219 : #if 0
277220 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277221 : // used to trigger marking transformations for the token-based unparsing.
277222 : printf ("SgAlignOfOp::get_operand_type = %p = %s \n",this,this->class_name().c_str());
277223 : #endif
277224 :
277225 69 : return p_operand_type;
277226 : }
277227 :
277228 : void
277229 0 : SgAlignOfOp::set_operand_type ( SgType* operand_type )
277230 : {
277231 0 : ROSE_ASSERT (this != NULL);
277232 :
277233 : #if 0
277234 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277235 : // used to trigger marking transformations for the token-based unparsing.
277236 : printf ("SgAlignOfOp::set_operand_type = %p = %s \n",this,this->class_name().c_str());
277237 : #endif
277238 :
277239 0 : set_isModified(true);
277240 :
277241 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
277242 : if (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type)
277243 : {
277244 : printf ("Warning: operand_type = %p overwriting valid pointer p_operand_type = %p \n",operand_type,p_operand_type);
277245 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
277246 : printf ("Error fails assertion (p_operand_type != NULL && operand_type != NULL && p_operand_type != operand_type) is false\n");
277247 : ROSE_ASSERT(false);
277248 : #endif
277249 : }
277250 : #endif
277251 0 : p_operand_type = operand_type;
277252 0 : }
277253 :
277254 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
277255 :
277256 :
277257 : // End of memberFunctionString
277258 : // Start of memberFunctionString
277259 :
277260 :
277261 : // End of memberFunctionString
277262 : // Start of memberFunctionString
277263 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
277264 :
277265 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
277266 :
277267 : bool
277268 3 : SgAlignOfOp::get_alignOfContainsBaseTypeDefiningDeclaration () const
277269 : {
277270 3 : ROSE_ASSERT (this != NULL);
277271 :
277272 : #if 0
277273 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277274 : // used to trigger marking transformations for the token-based unparsing.
277275 : printf ("SgAlignOfOp::get_alignOfContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
277276 : #endif
277277 :
277278 3 : return p_alignOfContainsBaseTypeDefiningDeclaration;
277279 : }
277280 :
277281 : void
277282 0 : SgAlignOfOp::set_alignOfContainsBaseTypeDefiningDeclaration ( bool alignOfContainsBaseTypeDefiningDeclaration )
277283 : {
277284 0 : ROSE_ASSERT (this != NULL);
277285 :
277286 : #if 0
277287 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277288 : // used to trigger marking transformations for the token-based unparsing.
277289 : printf ("SgAlignOfOp::set_alignOfContainsBaseTypeDefiningDeclaration = %p = %s \n",this,this->class_name().c_str());
277290 : #endif
277291 :
277292 0 : set_isModified(true);
277293 :
277294 0 : p_alignOfContainsBaseTypeDefiningDeclaration = alignOfContainsBaseTypeDefiningDeclaration;
277295 0 : }
277296 :
277297 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
277298 :
277299 :
277300 : // End of memberFunctionString
277301 : // Start of memberFunctionString
277302 : /* #line 5455 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
277303 :
277304 :
277305 : SgType*
277306 33 : SgAlignOfOp::get_type() const
277307 : {
277308 : // This function returns an unsigned integer representing the size of type
277309 : // (the unsigned int should match size_t, which may or may not be defined).
277310 :
277311 33 : ROSE_ASSERT(p_operand_expr != NULL || p_operand_type != NULL);
277312 :
277313 : #if 0
277314 : printf ("In SgAlignOfOp::get_type() \n");
277315 : #endif
277316 :
277317 33 : SgType* returnType = SgTypeUnsignedInt::createType();
277318 :
277319 33 : ROSE_ASSERT(returnType != NULL);
277320 33 : return returnType;
277321 : }
277322 :
277323 : // DQ (6/20/2013): Added alignment operator.
277324 : int
277325 0 : SgAlignOfOp::replace_expression (SgExpression *o, SgExpression *n)
277326 : {
277327 : // DQ (12/17/2006): This function should have the semantics that it will represent a
277328 : // structural change to the AST, thus it is free to set the parent of the new expression.
277329 :
277330 0 : ROSE_ASSERT(o != NULL);
277331 0 : ROSE_ASSERT(n != NULL);
277332 :
277333 0 : if (get_operand_expr() == o)
277334 : {
277335 0 : set_operand_expr(n);
277336 0 : return 1;
277337 : }
277338 : else
277339 : {
277340 0 : printf ("Warning: inside of SgAlignOfOp::replace_expression original SgExpression unidentified \n");
277341 0 : return 0;
277342 : }
277343 : }
277344 :
277345 : // DQ (6/11/2015): Moved these six access functions, they should not be generated by ROSETTA
277346 : // so that we could avoid them setting the isModified flag which is a problem in the
277347 : // name qualification support for C++ (interfering with the token-based unparsing).
277348 : int
277349 0 : SgAlignOfOp::get_name_qualification_length () const
277350 : {
277351 0 : ROSE_ASSERT (this != NULL);
277352 0 : return p_name_qualification_length;
277353 : }
277354 :
277355 : void
277356 0 : SgAlignOfOp::set_name_qualification_length ( int name_qualification_length )
277357 : {
277358 0 : ROSE_ASSERT (this != NULL);
277359 : // This can't be called by the name qualification API (see test2015_26.C).
277360 : // set_isModified(true);
277361 :
277362 0 : p_name_qualification_length = name_qualification_length;
277363 0 : }
277364 :
277365 : bool
277366 0 : SgAlignOfOp::get_type_elaboration_required () const
277367 : {
277368 0 : ROSE_ASSERT (this != NULL);
277369 0 : return p_type_elaboration_required;
277370 : }
277371 :
277372 : void
277373 0 : SgAlignOfOp::set_type_elaboration_required ( bool type_elaboration_required )
277374 : {
277375 0 : ROSE_ASSERT (this != NULL);
277376 : // This can't be called by the name qualification API (see test2015_26.C).
277377 : // set_isModified(true);
277378 :
277379 0 : p_type_elaboration_required = type_elaboration_required;
277380 0 : }
277381 :
277382 : bool
277383 0 : SgAlignOfOp::get_global_qualification_required () const
277384 : {
277385 0 : ROSE_ASSERT (this != NULL);
277386 0 : return p_global_qualification_required;
277387 : }
277388 :
277389 : void
277390 0 : SgAlignOfOp::set_global_qualification_required ( bool global_qualification_required )
277391 : {
277392 0 : ROSE_ASSERT (this != NULL);
277393 :
277394 : // This can't be called by the name qualification API (see test2015_26.C).
277395 : // set_isModified(true);
277396 :
277397 0 : p_global_qualification_required = global_qualification_required;
277398 0 : }
277399 :
277400 :
277401 :
277402 : // End of memberFunctionString
277403 : // Start of memberFunctionString
277404 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
277405 :
277406 : // *** COMMON CODE SECTION BEGINS HERE ***
277407 :
277408 : #if 0
277409 : int
277410 : SgAlignOfOp::getVariant() const
277411 : {
277412 : // This function is used in ROSE while "variant()" is used in SAGE
277413 : assert(this != NULL);
277414 : return variant();
277415 : }
277416 : #endif
277417 :
277418 : // This function is used in ROSE in treeTraversal code
277419 : // eventually replaces getVariant() and variant()
277420 : // though after variant() has been removed for a while we will
277421 : // want to change the name of variantT() back to variant()
277422 : // (since the "T" was ment to stand for temporary).
277423 : // When this happens the variantT() will be depricated.
277424 : VariantT
277425 7555 : SgAlignOfOp::variantT() const
277426 : {
277427 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
277428 7555 : ROSE_ASSERT(this != NULL);
277429 7555 : return V_SgAlignOfOp;
277430 : }
277431 :
277432 : #if 0
277433 : int
277434 : SgAlignOfOp::variant() const
277435 : {
277436 : // This function is used in SAGE
277437 : ROSE_ASSERT(this != NULL);
277438 : return ALIGNOF_OP;
277439 : }
277440 : #endif
277441 :
277442 : ROSE_DLL_API const char*
277443 0 : SgAlignOfOp::sage_class_name() const
277444 : {
277445 0 : ROSE_ASSERT(this != NULL);
277446 0 : return "SgAlignOfOp";
277447 : }
277448 :
277449 : std::string
277450 42 : SgAlignOfOp::class_name() const
277451 : {
277452 42 : ROSE_ASSERT(this != NULL);
277453 42 : return "SgAlignOfOp";
277454 : }
277455 :
277456 : // DQ (11/26/2005): Support for visitor pattern mechanims
277457 : // (inferior to ROSE traversal mechanism, experimental).
277458 : void
277459 703 : SgAlignOfOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
277460 : {
277461 703 : ROSE_ASSERT(this != NULL);
277462 703 : visitor.visit(this);
277463 703 : }
277464 :
277465 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
277466 0 : void SgAlignOfOp::accept (ROSE_VisitorPattern & visitor) {
277467 0 : ROSE_ASSERT(this != NULL);
277468 0 : visitor.visit(this);
277469 0 : }
277470 :
277471 : SgAlignOfOp*
277472 0 : SgAlignOfOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
277473 : {
277474 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
277475 : // This function is currently only supported for the AST used the represent Binary executables.
277476 : if (0 /* isSgAsmNode(this) != NULL */)
277477 : {
277478 : // Support for regex specification.
277479 : std::string prefixCode = "REGEX:";
277480 : addNewAttribute(prefixCode + s,a);
277481 : }
277482 : #endif
277483 :
277484 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
277485 0 : return this;
277486 : }
277487 :
277488 : // *** COMMON CODE SECTION ENDS HERE ***
277489 :
277490 :
277491 : // End of memberFunctionString
277492 : // Start of memberFunctionString
277493 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
277494 :
277495 :
277496 : #if 0
277497 : //! Error checking support
277498 : /*! Verifies the following:
277499 : - working getVariant() member function
277500 : - calls base class's error() member function
277501 : Every class has one of these functions.
277502 : */
277503 : bool
277504 : SgAlignOfOp::error()
277505 : {
277506 : // Put error checking here
277507 :
277508 : ROSE_ASSERT (this != NULL);
277509 : if (getVariant() != ALIGNOF_OP)
277510 : {
277511 : printf ("Error in SgAlignOfOp::error(): SgAlignOfOp object has a %s variant \n",
277512 : Cxx_GrammarTerminalNames[getVariant()].name);
277513 : // printf ("Error in SgAlignOfOp::error() \n");
277514 : ROSE_ABORT();
277515 : }
277516 :
277517 : ROSE_ASSERT (getVariant() == ALIGNOF_OP);
277518 : return SgExpression::error();
277519 : }
277520 : #endif
277521 :
277522 :
277523 :
277524 : // End of memberFunctionString
277525 :
277526 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
277527 :
277528 56 : SgAlignOfOp* isSgAlignOfOp ( SgNode* inputDerivedClassPointer )
277529 : {
277530 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
277531 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
277532 : // So to fix this we return NULL directly when the input is NULL and avoid the
277533 : // dynamic_cast in this case. This is likely a performance improvement as well.
277534 : // return dynamic_cast<SgAlignOfOp*>(inputDerivedClassPointer);
277535 : // Milind Chabbi (8/28/2013): isSgAlignOfOp uses table-driven castability instead of c++ default dynamic_cast
277536 : // this improves the running time performance by 10-20%.
277537 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAlignOfOp*>(inputDerivedClassPointer);
277538 56 : return IS_SgAlignOfOp_FAST_MACRO(inputDerivedClassPointer);
277539 : }
277540 :
277541 : // DQ (11/8/2003): Added version of functions taking const pointer
277542 30 : const SgAlignOfOp* isSgAlignOfOp ( const SgNode* inputDerivedClassPointer )
277543 : {
277544 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
277545 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
277546 : // So to fix this we return NULL directly when the input is NULL and avoid the
277547 : // dynamic_cast in this case. This is likely a performance improvement as well.
277548 : // return dynamic_cast<const SgAlignOfOp*>(inputDerivedClassPointer);
277549 : // Milind Chabbi (8/28/2013): isSgAlignOfOp uses table-driven castability instead of c++ default dynamic_cast
277550 : // this improves the running time performance by 10-20%.
277551 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAlignOfOp*>(inputDerivedClassPointer);
277552 30 : return IS_SgAlignOfOp_FAST_MACRO(inputDerivedClassPointer);
277553 : }
277554 :
277555 :
277556 :
277557 : /* #line 277558 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277558 :
277559 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
277560 :
277561 : /**
277562 : \brief Generated destructor
277563 :
277564 : This destructor is automatically generated (by ROSETTA). This destructor
277565 : only frees memory of data members associated with the parts of the current IR node which
277566 : are NOT traversed. Those data members that are part of a traversal can be freed using
277567 : a traversal (calling this destructor on all children in a post-order traversal). Such
277568 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
277569 :
277570 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
277571 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
277572 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
277573 :
277574 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
277575 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
277576 : pointers are not yet implemented to call delete on eash pointer in the container.
277577 : (This could be done by derivation from the STL containers to define containers that
277578 : automatically deleted their members.)
277579 :
277580 : */
277581 20 : SgAlignOfOp::~SgAlignOfOp () {
277582 10 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
277583 :
277584 :
277585 : // case: not a listType for operand_expr
277586 10 : p_operand_expr = NULL; // non list case
277587 : // case: not a listType for operand_type
277588 10 : p_operand_type = NULL; // non list case
277589 : // case: not a listType for expression_type
277590 10 : p_expression_type = NULL; // non list case
277591 : // case: not a listType for name_qualification_length
277592 10 : p_name_qualification_length = 0; // non list case
277593 : // case: not a listType for type_elaboration_required
277594 10 : p_type_elaboration_required = false; // non list case
277595 : // case: not a listType for global_qualification_required
277596 10 : p_global_qualification_required = false; // non list case
277597 : // case: not a listType for alignOfContainsBaseTypeDefiningDeclaration
277598 10 : p_alignOfContainsBaseTypeDefiningDeclaration = false; // non list case
277599 :
277600 : }
277601 :
277602 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
277603 20 : }
277604 :
277605 :
277606 : /* #line 277607 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277607 :
277608 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
277609 :
277610 : // Generated constructor
277611 0 : SgAlignOfOp::SgAlignOfOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type, SgType* expression_type )
277612 0 : : SgExpression(startOfConstruct)
277613 : {
277614 : #ifdef DEBUG
277615 : // printf ("In SgAlignOfOp::SgAlignOfOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type, SgType* expression_type) sage_class_name() = %s \n",sage_class_name());
277616 : #endif
277617 : #if 0
277618 : // debugging information!
277619 : printf ("In SgAlignOfOp::SgAlignOfOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr, SgType* operand_type, SgType* expression_type): this = %p = %s \n",this,this->class_name().c_str());
277620 : #endif
277621 :
277622 0 : p_operand_expr = operand_expr;
277623 0 : p_operand_type = operand_type;
277624 0 : p_expression_type = expression_type;
277625 0 : p_name_qualification_length = 0;
277626 0 : p_type_elaboration_required = false;
277627 0 : p_global_qualification_required = false;
277628 0 : p_alignOfContainsBaseTypeDefiningDeclaration = false;
277629 :
277630 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
277631 :
277632 : #if 0
277633 : // DQ (7/30/2014): Call a virtual function.
277634 : std::string s = this->class_name();
277635 : #endif
277636 :
277637 : // Test the variant virtual function
277638 : // assert(ALIGNOF_OP == variant());
277639 0 : assert(ALIGNOF_OP == this->variant());
277640 0 : ROSE_ASSERT(ALIGNOF_OP == (int)(this->variantT()));
277641 0 : post_construction_initialization();
277642 :
277643 : // Test the isSgAlignOfOp() function since it has been problematic
277644 0 : assert(isSgAlignOfOp(this) != NULL);
277645 0 : }
277646 :
277647 : // Generated constructor (all data members)
277648 :
277649 : /* #line 277650 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277650 :
277651 :
277652 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
277653 :
277654 :
277655 : // ********************************************************
277656 : // member functions common across all array grammar objects
277657 : // ********************************************************
277658 :
277659 :
277660 :
277661 : /* #line 277662 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277662 :
277663 :
277664 :
277665 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
277666 :
277667 : // ********************************************************
277668 : // member functions specific to each node in the grammar
277669 : // ********************************************************
277670 :
277671 :
277672 : /* #line 277673 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
277673 :
277674 : // Start of memberFunctionString
277675 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
277676 :
277677 : void
277678 0 : SgRangeExp::post_construction_initialization()
277679 : {
277680 0 : }
277681 :
277682 :
277683 :
277684 : // End of memberFunctionString
277685 : // Start of memberFunctionString
277686 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
277687 :
277688 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
277689 :
277690 : SgExpression*
277691 0 : SgRangeExp::get_start () const
277692 : {
277693 0 : ROSE_ASSERT (this != NULL);
277694 :
277695 : #if 0
277696 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277697 : // used to trigger marking transformations for the token-based unparsing.
277698 : printf ("SgRangeExp::get_start = %p = %s \n",this,this->class_name().c_str());
277699 : #endif
277700 :
277701 0 : return p_start;
277702 : }
277703 :
277704 : void
277705 0 : SgRangeExp::set_start ( SgExpression* start )
277706 : {
277707 0 : ROSE_ASSERT (this != NULL);
277708 :
277709 : #if 0
277710 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277711 : // used to trigger marking transformations for the token-based unparsing.
277712 : printf ("SgRangeExp::set_start = %p = %s \n",this,this->class_name().c_str());
277713 : #endif
277714 :
277715 0 : set_isModified(true);
277716 :
277717 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
277718 : if (p_start != NULL && start != NULL && p_start != start)
277719 : {
277720 : printf ("Warning: start = %p overwriting valid pointer p_start = %p \n",start,p_start);
277721 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
277722 : printf ("Error fails assertion (p_start != NULL && start != NULL && p_start != start) is false\n");
277723 : ROSE_ASSERT(false);
277724 : #endif
277725 : }
277726 : #endif
277727 0 : p_start = start;
277728 0 : }
277729 :
277730 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
277731 :
277732 :
277733 : // End of memberFunctionString
277734 : // Start of memberFunctionString
277735 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
277736 :
277737 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
277738 :
277739 : SgExpression*
277740 0 : SgRangeExp::get_end () const
277741 : {
277742 0 : ROSE_ASSERT (this != NULL);
277743 :
277744 : #if 0
277745 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277746 : // used to trigger marking transformations for the token-based unparsing.
277747 : printf ("SgRangeExp::get_end = %p = %s \n",this,this->class_name().c_str());
277748 : #endif
277749 :
277750 0 : return p_end;
277751 : }
277752 :
277753 : void
277754 0 : SgRangeExp::set_end ( SgExpression* end )
277755 : {
277756 0 : ROSE_ASSERT (this != NULL);
277757 :
277758 : #if 0
277759 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277760 : // used to trigger marking transformations for the token-based unparsing.
277761 : printf ("SgRangeExp::set_end = %p = %s \n",this,this->class_name().c_str());
277762 : #endif
277763 :
277764 0 : set_isModified(true);
277765 :
277766 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
277767 : if (p_end != NULL && end != NULL && p_end != end)
277768 : {
277769 : printf ("Warning: end = %p overwriting valid pointer p_end = %p \n",end,p_end);
277770 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
277771 : printf ("Error fails assertion (p_end != NULL && end != NULL && p_end != end) is false\n");
277772 : ROSE_ASSERT(false);
277773 : #endif
277774 : }
277775 : #endif
277776 0 : p_end = end;
277777 0 : }
277778 :
277779 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
277780 :
277781 :
277782 : // End of memberFunctionString
277783 : // Start of memberFunctionString
277784 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
277785 :
277786 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
277787 :
277788 : SgExpression*
277789 0 : SgRangeExp::get_stride () const
277790 : {
277791 0 : ROSE_ASSERT (this != NULL);
277792 :
277793 : #if 0
277794 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277795 : // used to trigger marking transformations for the token-based unparsing.
277796 : printf ("SgRangeExp::get_stride = %p = %s \n",this,this->class_name().c_str());
277797 : #endif
277798 :
277799 0 : return p_stride;
277800 : }
277801 :
277802 : void
277803 0 : SgRangeExp::set_stride ( SgExpression* stride )
277804 : {
277805 0 : ROSE_ASSERT (this != NULL);
277806 :
277807 : #if 0
277808 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
277809 : // used to trigger marking transformations for the token-based unparsing.
277810 : printf ("SgRangeExp::set_stride = %p = %s \n",this,this->class_name().c_str());
277811 : #endif
277812 :
277813 0 : set_isModified(true);
277814 :
277815 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
277816 : if (p_stride != NULL && stride != NULL && p_stride != stride)
277817 : {
277818 : printf ("Warning: stride = %p overwriting valid pointer p_stride = %p \n",stride,p_stride);
277819 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
277820 : printf ("Error fails assertion (p_stride != NULL && stride != NULL && p_stride != stride) is false\n");
277821 : ROSE_ASSERT(false);
277822 : #endif
277823 : }
277824 : #endif
277825 0 : p_stride = stride;
277826 0 : }
277827 :
277828 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
277829 :
277830 :
277831 : // End of memberFunctionString
277832 : // Start of memberFunctionString
277833 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
277834 :
277835 : SgType*
277836 :
277837 0 : SgRangeExp::get_type() const
277838 : {
277839 0 : ROSE_ASSERT(this != NULL);
277840 :
277841 : #if 0
277842 : printf ("In SgRangeExp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
277843 : #endif
277844 :
277845 : // DQ (10/31/2016): Debugging...
277846 : // return SgTypeDefault::createType();
277847 0 : SgType* returnType = SgTypeDefault::createType();
277848 :
277849 : #if 0
277850 : printf ("Leaving SgRangeExp::get_type() (default_get_type) returnType = %p \n",returnType);
277851 : #endif
277852 :
277853 0 : return returnType;
277854 : }
277855 :
277856 :
277857 :
277858 : // End of memberFunctionString
277859 : // Start of memberFunctionString
277860 : /* #line 7066 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
277861 :
277862 :
277863 0 : SgRangeExp* SgRangeExp::append(SgExpression *exp)
277864 : {
277865 : //start:end
277866 : //or start:increment:end
277867 :
277868 0 : ROSE_ASSERT(exp != NULL);
277869 :
277870 0 : if(p_start == NULL)
277871 : {
277872 0 : p_start = exp;
277873 : }
277874 : else
277875 : {
277876 0 : if(p_end == NULL)
277877 : {
277878 0 : p_end = exp;
277879 : }
277880 : else
277881 : {
277882 0 : if(p_stride == NULL)
277883 : {
277884 : //Swap stride with end. 1:2 then 1:2:3 comes, 2 was end. now 2 becomes stride
277885 0 : p_stride = p_end;
277886 0 : p_end = exp;
277887 : }
277888 : else
277889 : {
277890 : //cannot do more appends. Max 3 items allowed. Raise an error
277891 : return NULL;
277892 : }
277893 : }
277894 : }
277895 :
277896 0 : exp->set_parent(this);
277897 0 : return this;
277898 : }
277899 :
277900 :
277901 :
277902 : // End of memberFunctionString
277903 : // Start of memberFunctionString
277904 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
277905 :
277906 : // *** COMMON CODE SECTION BEGINS HERE ***
277907 :
277908 : #if 0
277909 : int
277910 : SgRangeExp::getVariant() const
277911 : {
277912 : // This function is used in ROSE while "variant()" is used in SAGE
277913 : assert(this != NULL);
277914 : return variant();
277915 : }
277916 : #endif
277917 :
277918 : // This function is used in ROSE in treeTraversal code
277919 : // eventually replaces getVariant() and variant()
277920 : // though after variant() has been removed for a while we will
277921 : // want to change the name of variantT() back to variant()
277922 : // (since the "T" was ment to stand for temporary).
277923 : // When this happens the variantT() will be depricated.
277924 : VariantT
277925 0 : SgRangeExp::variantT() const
277926 : {
277927 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
277928 0 : ROSE_ASSERT(this != NULL);
277929 0 : return V_SgRangeExp;
277930 : }
277931 :
277932 : #if 0
277933 : int
277934 : SgRangeExp::variant() const
277935 : {
277936 : // This function is used in SAGE
277937 : ROSE_ASSERT(this != NULL);
277938 : return RANGE_EXP;
277939 : }
277940 : #endif
277941 :
277942 : ROSE_DLL_API const char*
277943 0 : SgRangeExp::sage_class_name() const
277944 : {
277945 0 : ROSE_ASSERT(this != NULL);
277946 0 : return "SgRangeExp";
277947 : }
277948 :
277949 : std::string
277950 0 : SgRangeExp::class_name() const
277951 : {
277952 0 : ROSE_ASSERT(this != NULL);
277953 0 : return "SgRangeExp";
277954 : }
277955 :
277956 : // DQ (11/26/2005): Support for visitor pattern mechanims
277957 : // (inferior to ROSE traversal mechanism, experimental).
277958 : void
277959 0 : SgRangeExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
277960 : {
277961 0 : ROSE_ASSERT(this != NULL);
277962 0 : visitor.visit(this);
277963 0 : }
277964 :
277965 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
277966 0 : void SgRangeExp::accept (ROSE_VisitorPattern & visitor) {
277967 0 : ROSE_ASSERT(this != NULL);
277968 0 : visitor.visit(this);
277969 0 : }
277970 :
277971 : SgRangeExp*
277972 0 : SgRangeExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
277973 : {
277974 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
277975 : // This function is currently only supported for the AST used the represent Binary executables.
277976 : if (0 /* isSgAsmNode(this) != NULL */)
277977 : {
277978 : // Support for regex specification.
277979 : std::string prefixCode = "REGEX:";
277980 : addNewAttribute(prefixCode + s,a);
277981 : }
277982 : #endif
277983 :
277984 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
277985 0 : return this;
277986 : }
277987 :
277988 : // *** COMMON CODE SECTION ENDS HERE ***
277989 :
277990 :
277991 : // End of memberFunctionString
277992 : // Start of memberFunctionString
277993 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
277994 :
277995 :
277996 : #if 0
277997 : //! Error checking support
277998 : /*! Verifies the following:
277999 : - working getVariant() member function
278000 : - calls base class's error() member function
278001 : Every class has one of these functions.
278002 : */
278003 : bool
278004 : SgRangeExp::error()
278005 : {
278006 : // Put error checking here
278007 :
278008 : ROSE_ASSERT (this != NULL);
278009 : if (getVariant() != RANGE_EXP)
278010 : {
278011 : printf ("Error in SgRangeExp::error(): SgRangeExp object has a %s variant \n",
278012 : Cxx_GrammarTerminalNames[getVariant()].name);
278013 : // printf ("Error in SgRangeExp::error() \n");
278014 : ROSE_ABORT();
278015 : }
278016 :
278017 : ROSE_ASSERT (getVariant() == RANGE_EXP);
278018 : return SgExpression::error();
278019 : }
278020 : #endif
278021 :
278022 :
278023 :
278024 : // End of memberFunctionString
278025 :
278026 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
278027 :
278028 1045 : SgRangeExp* isSgRangeExp ( SgNode* inputDerivedClassPointer )
278029 : {
278030 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
278031 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
278032 : // So to fix this we return NULL directly when the input is NULL and avoid the
278033 : // dynamic_cast in this case. This is likely a performance improvement as well.
278034 : // return dynamic_cast<SgRangeExp*>(inputDerivedClassPointer);
278035 : // Milind Chabbi (8/28/2013): isSgRangeExp uses table-driven castability instead of c++ default dynamic_cast
278036 : // this improves the running time performance by 10-20%.
278037 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRangeExp*>(inputDerivedClassPointer);
278038 1045 : return IS_SgRangeExp_FAST_MACRO(inputDerivedClassPointer);
278039 : }
278040 :
278041 : // DQ (11/8/2003): Added version of functions taking const pointer
278042 0 : const SgRangeExp* isSgRangeExp ( const SgNode* inputDerivedClassPointer )
278043 : {
278044 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
278045 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
278046 : // So to fix this we return NULL directly when the input is NULL and avoid the
278047 : // dynamic_cast in this case. This is likely a performance improvement as well.
278048 : // return dynamic_cast<const SgRangeExp*>(inputDerivedClassPointer);
278049 : // Milind Chabbi (8/28/2013): isSgRangeExp uses table-driven castability instead of c++ default dynamic_cast
278050 : // this improves the running time performance by 10-20%.
278051 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRangeExp*>(inputDerivedClassPointer);
278052 0 : return IS_SgRangeExp_FAST_MACRO(inputDerivedClassPointer);
278053 : }
278054 :
278055 :
278056 :
278057 : /* #line 278058 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278058 :
278059 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
278060 :
278061 : /**
278062 : \brief Generated destructor
278063 :
278064 : This destructor is automatically generated (by ROSETTA). This destructor
278065 : only frees memory of data members associated with the parts of the current IR node which
278066 : are NOT traversed. Those data members that are part of a traversal can be freed using
278067 : a traversal (calling this destructor on all children in a post-order traversal). Such
278068 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
278069 :
278070 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
278071 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
278072 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
278073 :
278074 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
278075 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
278076 : pointers are not yet implemented to call delete on eash pointer in the container.
278077 : (This could be done by derivation from the STL containers to define containers that
278078 : automatically deleted their members.)
278079 :
278080 : */
278081 0 : SgRangeExp::~SgRangeExp () {
278082 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
278083 :
278084 :
278085 : // case: not a listType for start
278086 0 : p_start = NULL; // non list case
278087 : // case: not a listType for end
278088 0 : p_end = NULL; // non list case
278089 : // case: not a listType for stride
278090 0 : p_stride = NULL; // non list case
278091 :
278092 : }
278093 :
278094 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
278095 0 : }
278096 :
278097 :
278098 : /* #line 278099 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278099 :
278100 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
278101 :
278102 : // Generated constructor
278103 0 : SgRangeExp::SgRangeExp ( Sg_File_Info* startOfConstruct )
278104 0 : : SgExpression(startOfConstruct)
278105 : {
278106 : #ifdef DEBUG
278107 : // printf ("In SgRangeExp::SgRangeExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
278108 : #endif
278109 : #if 0
278110 : // debugging information!
278111 : printf ("In SgRangeExp::SgRangeExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
278112 : #endif
278113 :
278114 0 : p_start = NULL;
278115 0 : p_end = NULL;
278116 0 : p_stride = NULL;
278117 :
278118 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
278119 :
278120 : #if 0
278121 : // DQ (7/30/2014): Call a virtual function.
278122 : std::string s = this->class_name();
278123 : #endif
278124 :
278125 : // Test the variant virtual function
278126 : // assert(RANGE_EXP == variant());
278127 0 : assert(RANGE_EXP == this->variant());
278128 0 : ROSE_ASSERT(RANGE_EXP == (int)(this->variantT()));
278129 0 : post_construction_initialization();
278130 :
278131 : // Test the isSgRangeExp() function since it has been problematic
278132 0 : assert(isSgRangeExp(this) != NULL);
278133 0 : }
278134 :
278135 : // Generated constructor (all data members)
278136 :
278137 : /* #line 278138 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278138 :
278139 :
278140 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
278141 :
278142 :
278143 : // ********************************************************
278144 : // member functions common across all array grammar objects
278145 : // ********************************************************
278146 :
278147 :
278148 :
278149 : /* #line 278150 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278150 :
278151 :
278152 :
278153 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
278154 :
278155 : // ********************************************************
278156 : // member functions specific to each node in the grammar
278157 : // ********************************************************
278158 :
278159 :
278160 : /* #line 278161 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278161 :
278162 : // Start of memberFunctionString
278163 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
278164 :
278165 : void
278166 0 : SgMagicColonExp::post_construction_initialization()
278167 : {
278168 0 : }
278169 :
278170 :
278171 :
278172 : // End of memberFunctionString
278173 : // Start of memberFunctionString
278174 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
278175 :
278176 : SgType*
278177 :
278178 0 : SgMagicColonExp::get_type() const
278179 : {
278180 0 : ROSE_ASSERT(this != NULL);
278181 :
278182 : #if 0
278183 : printf ("In SgMagicColonExp::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
278184 : #endif
278185 :
278186 : // DQ (10/31/2016): Debugging...
278187 : // return SgTypeDefault::createType();
278188 0 : SgType* returnType = SgTypeDefault::createType();
278189 :
278190 : #if 0
278191 : printf ("Leaving SgMagicColonExp::get_type() (default_get_type) returnType = %p \n",returnType);
278192 : #endif
278193 :
278194 0 : return returnType;
278195 : }
278196 :
278197 :
278198 :
278199 : // End of memberFunctionString
278200 : // Start of memberFunctionString
278201 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
278202 :
278203 : // *** COMMON CODE SECTION BEGINS HERE ***
278204 :
278205 : #if 0
278206 : int
278207 : SgMagicColonExp::getVariant() const
278208 : {
278209 : // This function is used in ROSE while "variant()" is used in SAGE
278210 : assert(this != NULL);
278211 : return variant();
278212 : }
278213 : #endif
278214 :
278215 : // This function is used in ROSE in treeTraversal code
278216 : // eventually replaces getVariant() and variant()
278217 : // though after variant() has been removed for a while we will
278218 : // want to change the name of variantT() back to variant()
278219 : // (since the "T" was ment to stand for temporary).
278220 : // When this happens the variantT() will be depricated.
278221 : VariantT
278222 0 : SgMagicColonExp::variantT() const
278223 : {
278224 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
278225 0 : ROSE_ASSERT(this != NULL);
278226 0 : return V_SgMagicColonExp;
278227 : }
278228 :
278229 : #if 0
278230 : int
278231 : SgMagicColonExp::variant() const
278232 : {
278233 : // This function is used in SAGE
278234 : ROSE_ASSERT(this != NULL);
278235 : return MAGIC_COLON_EXP;
278236 : }
278237 : #endif
278238 :
278239 : ROSE_DLL_API const char*
278240 0 : SgMagicColonExp::sage_class_name() const
278241 : {
278242 0 : ROSE_ASSERT(this != NULL);
278243 0 : return "SgMagicColonExp";
278244 : }
278245 :
278246 : std::string
278247 0 : SgMagicColonExp::class_name() const
278248 : {
278249 0 : ROSE_ASSERT(this != NULL);
278250 0 : return "SgMagicColonExp";
278251 : }
278252 :
278253 : // DQ (11/26/2005): Support for visitor pattern mechanims
278254 : // (inferior to ROSE traversal mechanism, experimental).
278255 : void
278256 0 : SgMagicColonExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
278257 : {
278258 0 : ROSE_ASSERT(this != NULL);
278259 0 : visitor.visit(this);
278260 0 : }
278261 :
278262 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
278263 0 : void SgMagicColonExp::accept (ROSE_VisitorPattern & visitor) {
278264 0 : ROSE_ASSERT(this != NULL);
278265 0 : visitor.visit(this);
278266 0 : }
278267 :
278268 : SgMagicColonExp*
278269 0 : SgMagicColonExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
278270 : {
278271 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
278272 : // This function is currently only supported for the AST used the represent Binary executables.
278273 : if (0 /* isSgAsmNode(this) != NULL */)
278274 : {
278275 : // Support for regex specification.
278276 : std::string prefixCode = "REGEX:";
278277 : addNewAttribute(prefixCode + s,a);
278278 : }
278279 : #endif
278280 :
278281 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
278282 0 : return this;
278283 : }
278284 :
278285 : // *** COMMON CODE SECTION ENDS HERE ***
278286 :
278287 :
278288 : // End of memberFunctionString
278289 : // Start of memberFunctionString
278290 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
278291 :
278292 :
278293 : #if 0
278294 : //! Error checking support
278295 : /*! Verifies the following:
278296 : - working getVariant() member function
278297 : - calls base class's error() member function
278298 : Every class has one of these functions.
278299 : */
278300 : bool
278301 : SgMagicColonExp::error()
278302 : {
278303 : // Put error checking here
278304 :
278305 : ROSE_ASSERT (this != NULL);
278306 : if (getVariant() != MAGIC_COLON_EXP)
278307 : {
278308 : printf ("Error in SgMagicColonExp::error(): SgMagicColonExp object has a %s variant \n",
278309 : Cxx_GrammarTerminalNames[getVariant()].name);
278310 : // printf ("Error in SgMagicColonExp::error() \n");
278311 : ROSE_ABORT();
278312 : }
278313 :
278314 : ROSE_ASSERT (getVariant() == MAGIC_COLON_EXP);
278315 : return SgExpression::error();
278316 : }
278317 : #endif
278318 :
278319 :
278320 :
278321 : // End of memberFunctionString
278322 :
278323 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
278324 :
278325 0 : SgMagicColonExp* isSgMagicColonExp ( SgNode* inputDerivedClassPointer )
278326 : {
278327 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
278328 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
278329 : // So to fix this we return NULL directly when the input is NULL and avoid the
278330 : // dynamic_cast in this case. This is likely a performance improvement as well.
278331 : // return dynamic_cast<SgMagicColonExp*>(inputDerivedClassPointer);
278332 : // Milind Chabbi (8/28/2013): isSgMagicColonExp uses table-driven castability instead of c++ default dynamic_cast
278333 : // this improves the running time performance by 10-20%.
278334 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMagicColonExp*>(inputDerivedClassPointer);
278335 0 : return IS_SgMagicColonExp_FAST_MACRO(inputDerivedClassPointer);
278336 : }
278337 :
278338 : // DQ (11/8/2003): Added version of functions taking const pointer
278339 0 : const SgMagicColonExp* isSgMagicColonExp ( const SgNode* inputDerivedClassPointer )
278340 : {
278341 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
278342 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
278343 : // So to fix this we return NULL directly when the input is NULL and avoid the
278344 : // dynamic_cast in this case. This is likely a performance improvement as well.
278345 : // return dynamic_cast<const SgMagicColonExp*>(inputDerivedClassPointer);
278346 : // Milind Chabbi (8/28/2013): isSgMagicColonExp uses table-driven castability instead of c++ default dynamic_cast
278347 : // this improves the running time performance by 10-20%.
278348 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMagicColonExp*>(inputDerivedClassPointer);
278349 0 : return IS_SgMagicColonExp_FAST_MACRO(inputDerivedClassPointer);
278350 : }
278351 :
278352 :
278353 :
278354 : /* #line 278355 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278355 :
278356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
278357 :
278358 : /**
278359 : \brief Generated destructor
278360 :
278361 : This destructor is automatically generated (by ROSETTA). This destructor
278362 : only frees memory of data members associated with the parts of the current IR node which
278363 : are NOT traversed. Those data members that are part of a traversal can be freed using
278364 : a traversal (calling this destructor on all children in a post-order traversal). Such
278365 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
278366 :
278367 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
278368 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
278369 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
278370 :
278371 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
278372 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
278373 : pointers are not yet implemented to call delete on eash pointer in the container.
278374 : (This could be done by derivation from the STL containers to define containers that
278375 : automatically deleted their members.)
278376 :
278377 : */
278378 0 : SgMagicColonExp::~SgMagicColonExp () {
278379 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
278380 :
278381 :
278382 :
278383 : }
278384 :
278385 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
278386 0 : }
278387 :
278388 :
278389 : /* #line 278390 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278390 :
278391 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
278392 :
278393 : // Generated constructor
278394 0 : SgMagicColonExp::SgMagicColonExp ( Sg_File_Info* startOfConstruct )
278395 0 : : SgExpression(startOfConstruct)
278396 : {
278397 : #ifdef DEBUG
278398 : // printf ("In SgMagicColonExp::SgMagicColonExp (Sg_File_Info* startOfConstruct) sage_class_name() = %s \n",sage_class_name());
278399 : #endif
278400 : #if 0
278401 : // debugging information!
278402 : printf ("In SgMagicColonExp::SgMagicColonExp (Sg_File_Info* startOfConstruct): this = %p = %s \n",this,this->class_name().c_str());
278403 : #endif
278404 :
278405 :
278406 :
278407 : #if 0
278408 : // DQ (7/30/2014): Call a virtual function.
278409 : std::string s = this->class_name();
278410 : #endif
278411 :
278412 : // Test the variant virtual function
278413 : // assert(MAGIC_COLON_EXP == variant());
278414 0 : assert(MAGIC_COLON_EXP == this->variant());
278415 0 : ROSE_ASSERT(MAGIC_COLON_EXP == (int)(this->variantT()));
278416 0 : post_construction_initialization();
278417 :
278418 : // Test the isSgMagicColonExp() function since it has been problematic
278419 0 : assert(isSgMagicColonExp(this) != NULL);
278420 0 : }
278421 :
278422 : // Generated constructor (all data members)
278423 :
278424 : /* #line 278425 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278425 :
278426 :
278427 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
278428 :
278429 :
278430 : // ********************************************************
278431 : // member functions common across all array grammar objects
278432 : // ********************************************************
278433 :
278434 :
278435 :
278436 : /* #line 278437 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278437 :
278438 :
278439 :
278440 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
278441 :
278442 : // ********************************************************
278443 : // member functions specific to each node in the grammar
278444 : // ********************************************************
278445 :
278446 :
278447 : /* #line 278448 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278448 :
278449 : // Start of memberFunctionString
278450 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
278451 :
278452 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
278453 :
278454 : SgName
278455 872 : SgTypeTraitBuiltinOperator::get_name () const
278456 : {
278457 872 : ROSE_ASSERT (this != NULL);
278458 :
278459 : #if 0
278460 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
278461 : // used to trigger marking transformations for the token-based unparsing.
278462 : printf ("SgTypeTraitBuiltinOperator::get_name = %p = %s \n",this,this->class_name().c_str());
278463 : #endif
278464 :
278465 872 : return p_name;
278466 : }
278467 :
278468 : void
278469 0 : SgTypeTraitBuiltinOperator::set_name ( SgName name )
278470 : {
278471 0 : ROSE_ASSERT (this != NULL);
278472 :
278473 : #if 0
278474 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
278475 : // used to trigger marking transformations for the token-based unparsing.
278476 : printf ("SgTypeTraitBuiltinOperator::set_name = %p = %s \n",this,this->class_name().c_str());
278477 : #endif
278478 :
278479 0 : set_isModified(true);
278480 :
278481 0 : p_name = name;
278482 0 : }
278483 :
278484 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
278485 :
278486 :
278487 : // End of memberFunctionString
278488 : // Start of memberFunctionString
278489 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
278490 :
278491 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
278492 :
278493 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
278494 : const SgNodePtrList &
278495 691 : SgTypeTraitBuiltinOperator::get_args () const
278496 : {
278497 691 : assert (this != NULL);
278498 691 : return p_args;
278499 : }
278500 :
278501 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
278502 : SgNodePtrList &
278503 564 : SgTypeTraitBuiltinOperator::get_args ()
278504 : {
278505 564 : assert (this != NULL);
278506 :
278507 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
278508 : // As a rule only set_ access functions can set the isModified flag.
278509 : // set_isModified(true);
278510 :
278511 564 : return p_args;
278512 : }
278513 :
278514 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
278515 :
278516 :
278517 : // End of memberFunctionString
278518 : // Start of memberFunctionString
278519 : /* #line 4677 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
278520 :
278521 :
278522 : void
278523 428 : SgTypeTraitBuiltinOperator::post_construction_initialization()
278524 : {
278525 : // SgCallExpression::post_construction_initialization();
278526 428 : }
278527 :
278528 : SgType*
278529 150 : SgTypeTraitBuiltinOperator::get_type() const
278530 : {
278531 : // DQ (7/12/2013): These functions will almost always return a boolean type, but not always.
278532 :
278533 150 : SgType* returnType = NULL;
278534 :
278535 : #if 0
278536 : printf ("In SgTypeTraitBuiltinOperator::get_type() \n");
278537 : #endif
278538 :
278539 150 : if (get_name() == "__underlying_type")
278540 : {
278541 : // This returns an actual type and it is not clear now to handle this.
278542 0 : returnType = SgTypeDefault::createType();
278543 : }
278544 : else
278545 : {
278546 : // return boolean type.
278547 150 : returnType = SgTypeBool::createType();
278548 : }
278549 :
278550 150 : ROSE_ASSERT(returnType != NULL);
278551 150 : return returnType;
278552 : }
278553 :
278554 :
278555 :
278556 : // End of memberFunctionString
278557 : // Start of memberFunctionString
278558 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
278559 :
278560 : // *** COMMON CODE SECTION BEGINS HERE ***
278561 :
278562 : #if 0
278563 : int
278564 : SgTypeTraitBuiltinOperator::getVariant() const
278565 : {
278566 : // This function is used in ROSE while "variant()" is used in SAGE
278567 : assert(this != NULL);
278568 : return variant();
278569 : }
278570 : #endif
278571 :
278572 : // This function is used in ROSE in treeTraversal code
278573 : // eventually replaces getVariant() and variant()
278574 : // though after variant() has been removed for a while we will
278575 : // want to change the name of variantT() back to variant()
278576 : // (since the "T" was ment to stand for temporary).
278577 : // When this happens the variantT() will be depricated.
278578 : VariantT
278579 37574 : SgTypeTraitBuiltinOperator::variantT() const
278580 : {
278581 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
278582 37574 : ROSE_ASSERT(this != NULL);
278583 37574 : return V_SgTypeTraitBuiltinOperator;
278584 : }
278585 :
278586 : #if 0
278587 : int
278588 : SgTypeTraitBuiltinOperator::variant() const
278589 : {
278590 : // This function is used in SAGE
278591 : ROSE_ASSERT(this != NULL);
278592 : return TYPE_TRAIT_BUILTIN_OPERATOR;
278593 : }
278594 : #endif
278595 :
278596 : ROSE_DLL_API const char*
278597 16 : SgTypeTraitBuiltinOperator::sage_class_name() const
278598 : {
278599 16 : ROSE_ASSERT(this != NULL);
278600 16 : return "SgTypeTraitBuiltinOperator";
278601 : }
278602 :
278603 : std::string
278604 344 : SgTypeTraitBuiltinOperator::class_name() const
278605 : {
278606 344 : ROSE_ASSERT(this != NULL);
278607 344 : return "SgTypeTraitBuiltinOperator";
278608 : }
278609 :
278610 : // DQ (11/26/2005): Support for visitor pattern mechanims
278611 : // (inferior to ROSE traversal mechanism, experimental).
278612 : void
278613 5898 : SgTypeTraitBuiltinOperator::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
278614 : {
278615 5898 : ROSE_ASSERT(this != NULL);
278616 5898 : visitor.visit(this);
278617 5898 : }
278618 :
278619 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
278620 0 : void SgTypeTraitBuiltinOperator::accept (ROSE_VisitorPattern & visitor) {
278621 0 : ROSE_ASSERT(this != NULL);
278622 0 : visitor.visit(this);
278623 0 : }
278624 :
278625 : SgTypeTraitBuiltinOperator*
278626 0 : SgTypeTraitBuiltinOperator::addRegExpAttribute(std::string s, AstRegExAttribute* a)
278627 : {
278628 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
278629 : // This function is currently only supported for the AST used the represent Binary executables.
278630 : if (0 /* isSgAsmNode(this) != NULL */)
278631 : {
278632 : // Support for regex specification.
278633 : std::string prefixCode = "REGEX:";
278634 : addNewAttribute(prefixCode + s,a);
278635 : }
278636 : #endif
278637 :
278638 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
278639 0 : return this;
278640 : }
278641 :
278642 : // *** COMMON CODE SECTION ENDS HERE ***
278643 :
278644 :
278645 : // End of memberFunctionString
278646 : // Start of memberFunctionString
278647 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
278648 :
278649 :
278650 : #if 0
278651 : //! Error checking support
278652 : /*! Verifies the following:
278653 : - working getVariant() member function
278654 : - calls base class's error() member function
278655 : Every class has one of these functions.
278656 : */
278657 : bool
278658 : SgTypeTraitBuiltinOperator::error()
278659 : {
278660 : // Put error checking here
278661 :
278662 : ROSE_ASSERT (this != NULL);
278663 : if (getVariant() != TYPE_TRAIT_BUILTIN_OPERATOR)
278664 : {
278665 : printf ("Error in SgTypeTraitBuiltinOperator::error(): SgTypeTraitBuiltinOperator object has a %s variant \n",
278666 : Cxx_GrammarTerminalNames[getVariant()].name);
278667 : // printf ("Error in SgTypeTraitBuiltinOperator::error() \n");
278668 : ROSE_ABORT();
278669 : }
278670 :
278671 : ROSE_ASSERT (getVariant() == TYPE_TRAIT_BUILTIN_OPERATOR);
278672 : return SgExpression::error();
278673 : }
278674 : #endif
278675 :
278676 :
278677 :
278678 : // End of memberFunctionString
278679 :
278680 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
278681 :
278682 1281 : SgTypeTraitBuiltinOperator* isSgTypeTraitBuiltinOperator ( SgNode* inputDerivedClassPointer )
278683 : {
278684 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
278685 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
278686 : // So to fix this we return NULL directly when the input is NULL and avoid the
278687 : // dynamic_cast in this case. This is likely a performance improvement as well.
278688 : // return dynamic_cast<SgTypeTraitBuiltinOperator*>(inputDerivedClassPointer);
278689 : // Milind Chabbi (8/28/2013): isSgTypeTraitBuiltinOperator uses table-driven castability instead of c++ default dynamic_cast
278690 : // this improves the running time performance by 10-20%.
278691 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeTraitBuiltinOperator*>(inputDerivedClassPointer);
278692 1281 : return IS_SgTypeTraitBuiltinOperator_FAST_MACRO(inputDerivedClassPointer);
278693 : }
278694 :
278695 : // DQ (11/8/2003): Added version of functions taking const pointer
278696 691 : const SgTypeTraitBuiltinOperator* isSgTypeTraitBuiltinOperator ( const SgNode* inputDerivedClassPointer )
278697 : {
278698 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
278699 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
278700 : // So to fix this we return NULL directly when the input is NULL and avoid the
278701 : // dynamic_cast in this case. This is likely a performance improvement as well.
278702 : // return dynamic_cast<const SgTypeTraitBuiltinOperator*>(inputDerivedClassPointer);
278703 : // Milind Chabbi (8/28/2013): isSgTypeTraitBuiltinOperator uses table-driven castability instead of c++ default dynamic_cast
278704 : // this improves the running time performance by 10-20%.
278705 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeTraitBuiltinOperator*>(inputDerivedClassPointer);
278706 691 : return IS_SgTypeTraitBuiltinOperator_FAST_MACRO(inputDerivedClassPointer);
278707 : }
278708 :
278709 :
278710 :
278711 : /* #line 278712 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278712 :
278713 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
278714 :
278715 : /**
278716 : \brief Generated destructor
278717 :
278718 : This destructor is automatically generated (by ROSETTA). This destructor
278719 : only frees memory of data members associated with the parts of the current IR node which
278720 : are NOT traversed. Those data members that are part of a traversal can be freed using
278721 : a traversal (calling this destructor on all children in a post-order traversal). Such
278722 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
278723 :
278724 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
278725 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
278726 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
278727 :
278728 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
278729 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
278730 : pointers are not yet implemented to call delete on eash pointer in the container.
278731 : (This could be done by derivation from the STL containers to define containers that
278732 : automatically deleted their members.)
278733 :
278734 : */
278735 252 : SgTypeTraitBuiltinOperator::~SgTypeTraitBuiltinOperator () {
278736 84 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
278737 :
278738 :
278739 : // case: not a listType for name
278740 84 : p_name = ""; // non list case
278741 :
278742 : }
278743 :
278744 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
278745 168 : }
278746 :
278747 :
278748 : /* #line 278749 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278749 :
278750 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
278751 :
278752 : // Generated constructor
278753 0 : SgTypeTraitBuiltinOperator::SgTypeTraitBuiltinOperator ( Sg_File_Info* startOfConstruct, SgName name )
278754 0 : : SgExpression(startOfConstruct)
278755 : {
278756 : #ifdef DEBUG
278757 : // printf ("In SgTypeTraitBuiltinOperator::SgTypeTraitBuiltinOperator (Sg_File_Info* startOfConstruct, SgName name) sage_class_name() = %s \n",sage_class_name());
278758 : #endif
278759 : #if 0
278760 : // debugging information!
278761 : printf ("In SgTypeTraitBuiltinOperator::SgTypeTraitBuiltinOperator (Sg_File_Info* startOfConstruct, SgName name): this = %p = %s \n",this,this->class_name().c_str());
278762 : #endif
278763 :
278764 0 : p_name = name;
278765 :
278766 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
278767 :
278768 : #if 0
278769 : // DQ (7/30/2014): Call a virtual function.
278770 : std::string s = this->class_name();
278771 : #endif
278772 :
278773 : // Test the variant virtual function
278774 : // assert(TYPE_TRAIT_BUILTIN_OPERATOR == variant());
278775 0 : assert(TYPE_TRAIT_BUILTIN_OPERATOR == this->variant());
278776 0 : ROSE_ASSERT(TYPE_TRAIT_BUILTIN_OPERATOR == (int)(this->variantT()));
278777 0 : post_construction_initialization();
278778 :
278779 : // Test the isSgTypeTraitBuiltinOperator() function since it has been problematic
278780 0 : assert(isSgTypeTraitBuiltinOperator(this) != NULL);
278781 0 : }
278782 :
278783 : // Generated constructor (all data members)
278784 :
278785 : /* #line 278786 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278786 :
278787 :
278788 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
278789 :
278790 :
278791 : // ********************************************************
278792 : // member functions common across all array grammar objects
278793 : // ********************************************************
278794 :
278795 :
278796 :
278797 : /* #line 278798 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278798 :
278799 :
278800 :
278801 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
278802 :
278803 : // ********************************************************
278804 : // member functions specific to each node in the grammar
278805 : // ********************************************************
278806 :
278807 :
278808 : /* #line 278809 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
278809 :
278810 : // Start of memberFunctionString
278811 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
278812 :
278813 : void
278814 0 : SgCompoundLiteralExp::post_construction_initialization()
278815 : {
278816 0 : }
278817 :
278818 :
278819 :
278820 : // End of memberFunctionString
278821 : // Start of memberFunctionString
278822 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
278823 :
278824 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
278825 :
278826 : SgVariableSymbol*
278827 0 : SgCompoundLiteralExp::get_symbol () const
278828 : {
278829 0 : ROSE_ASSERT (this != NULL);
278830 :
278831 : #if 0
278832 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
278833 : // used to trigger marking transformations for the token-based unparsing.
278834 : printf ("SgCompoundLiteralExp::get_symbol = %p = %s \n",this,this->class_name().c_str());
278835 : #endif
278836 :
278837 0 : return p_symbol;
278838 : }
278839 :
278840 : void
278841 0 : SgCompoundLiteralExp::set_symbol ( SgVariableSymbol* symbol )
278842 : {
278843 0 : ROSE_ASSERT (this != NULL);
278844 :
278845 : #if 0
278846 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
278847 : // used to trigger marking transformations for the token-based unparsing.
278848 : printf ("SgCompoundLiteralExp::set_symbol = %p = %s \n",this,this->class_name().c_str());
278849 : #endif
278850 :
278851 0 : set_isModified(true);
278852 :
278853 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
278854 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
278855 : {
278856 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
278857 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
278858 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
278859 : ROSE_ASSERT(false);
278860 : #endif
278861 : }
278862 : #endif
278863 0 : p_symbol = symbol;
278864 0 : }
278865 :
278866 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
278867 :
278868 :
278869 : // End of memberFunctionString
278870 : // Start of memberFunctionString
278871 : /* #line 3448 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
278872 :
278873 :
278874 :
278875 : // End of memberFunctionString
278876 : // Start of memberFunctionString
278877 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
278878 :
278879 :
278880 : SgType*
278881 0 : SgCompoundLiteralExp::get_type() const
278882 : {
278883 0 : ROSE_ASSERT(this != NULL);
278884 :
278885 : #if 0
278886 : printf ("In SgCompoundLiteralExp::get_type() \n");
278887 : #endif
278888 :
278889 0 : SgSymbol* symbol = this->get_symbol();
278890 0 : if (symbol == NULL)
278891 : {
278892 0 : printf ("Error: In SgCompoundLiteralExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
278893 : }
278894 0 : ROSE_ASSERT(symbol != NULL);
278895 :
278896 : // DQ (9/27/2006): Added assertion
278897 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
278898 :
278899 : // printf ("In SgCompoundLiteralExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
278900 0 : SgType* type = symbol->get_type();
278901 0 : if (type == NULL)
278902 : {
278903 0 : printf ("Error: In SgCompoundLiteralExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
278904 : }
278905 0 : ROSE_ASSERT(type != NULL);
278906 :
278907 : // return get_symbol()->get_type();
278908 0 : return type;
278909 : }
278910 :
278911 :
278912 :
278913 : // End of memberFunctionString
278914 : // Start of memberFunctionString
278915 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
278916 :
278917 : // *** COMMON CODE SECTION BEGINS HERE ***
278918 :
278919 : #if 0
278920 : int
278921 : SgCompoundLiteralExp::getVariant() const
278922 : {
278923 : // This function is used in ROSE while "variant()" is used in SAGE
278924 : assert(this != NULL);
278925 : return variant();
278926 : }
278927 : #endif
278928 :
278929 : // This function is used in ROSE in treeTraversal code
278930 : // eventually replaces getVariant() and variant()
278931 : // though after variant() has been removed for a while we will
278932 : // want to change the name of variantT() back to variant()
278933 : // (since the "T" was ment to stand for temporary).
278934 : // When this happens the variantT() will be depricated.
278935 : VariantT
278936 0 : SgCompoundLiteralExp::variantT() const
278937 : {
278938 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
278939 0 : ROSE_ASSERT(this != NULL);
278940 0 : return V_SgCompoundLiteralExp;
278941 : }
278942 :
278943 : #if 0
278944 : int
278945 : SgCompoundLiteralExp::variant() const
278946 : {
278947 : // This function is used in SAGE
278948 : ROSE_ASSERT(this != NULL);
278949 : return COMPOUND_LITERAL;
278950 : }
278951 : #endif
278952 :
278953 : ROSE_DLL_API const char*
278954 0 : SgCompoundLiteralExp::sage_class_name() const
278955 : {
278956 0 : ROSE_ASSERT(this != NULL);
278957 0 : return "SgCompoundLiteralExp";
278958 : }
278959 :
278960 : std::string
278961 0 : SgCompoundLiteralExp::class_name() const
278962 : {
278963 0 : ROSE_ASSERT(this != NULL);
278964 0 : return "SgCompoundLiteralExp";
278965 : }
278966 :
278967 : // DQ (11/26/2005): Support for visitor pattern mechanims
278968 : // (inferior to ROSE traversal mechanism, experimental).
278969 : void
278970 0 : SgCompoundLiteralExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
278971 : {
278972 0 : ROSE_ASSERT(this != NULL);
278973 0 : visitor.visit(this);
278974 0 : }
278975 :
278976 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
278977 0 : void SgCompoundLiteralExp::accept (ROSE_VisitorPattern & visitor) {
278978 0 : ROSE_ASSERT(this != NULL);
278979 0 : visitor.visit(this);
278980 0 : }
278981 :
278982 : SgCompoundLiteralExp*
278983 0 : SgCompoundLiteralExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
278984 : {
278985 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
278986 : // This function is currently only supported for the AST used the represent Binary executables.
278987 : if (0 /* isSgAsmNode(this) != NULL */)
278988 : {
278989 : // Support for regex specification.
278990 : std::string prefixCode = "REGEX:";
278991 : addNewAttribute(prefixCode + s,a);
278992 : }
278993 : #endif
278994 :
278995 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
278996 0 : return this;
278997 : }
278998 :
278999 : // *** COMMON CODE SECTION ENDS HERE ***
279000 :
279001 :
279002 : // End of memberFunctionString
279003 : // Start of memberFunctionString
279004 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
279005 :
279006 :
279007 : #if 0
279008 : //! Error checking support
279009 : /*! Verifies the following:
279010 : - working getVariant() member function
279011 : - calls base class's error() member function
279012 : Every class has one of these functions.
279013 : */
279014 : bool
279015 : SgCompoundLiteralExp::error()
279016 : {
279017 : // Put error checking here
279018 :
279019 : ROSE_ASSERT (this != NULL);
279020 : if (getVariant() != COMPOUND_LITERAL)
279021 : {
279022 : printf ("Error in SgCompoundLiteralExp::error(): SgCompoundLiteralExp object has a %s variant \n",
279023 : Cxx_GrammarTerminalNames[getVariant()].name);
279024 : // printf ("Error in SgCompoundLiteralExp::error() \n");
279025 : ROSE_ABORT();
279026 : }
279027 :
279028 : ROSE_ASSERT (getVariant() == COMPOUND_LITERAL);
279029 : return SgExpression::error();
279030 : }
279031 : #endif
279032 :
279033 :
279034 :
279035 : // End of memberFunctionString
279036 :
279037 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
279038 :
279039 0 : SgCompoundLiteralExp* isSgCompoundLiteralExp ( SgNode* inputDerivedClassPointer )
279040 : {
279041 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
279042 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
279043 : // So to fix this we return NULL directly when the input is NULL and avoid the
279044 : // dynamic_cast in this case. This is likely a performance improvement as well.
279045 : // return dynamic_cast<SgCompoundLiteralExp*>(inputDerivedClassPointer);
279046 : // Milind Chabbi (8/28/2013): isSgCompoundLiteralExp uses table-driven castability instead of c++ default dynamic_cast
279047 : // this improves the running time performance by 10-20%.
279048 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCompoundLiteralExp*>(inputDerivedClassPointer);
279049 0 : return IS_SgCompoundLiteralExp_FAST_MACRO(inputDerivedClassPointer);
279050 : }
279051 :
279052 : // DQ (11/8/2003): Added version of functions taking const pointer
279053 0 : const SgCompoundLiteralExp* isSgCompoundLiteralExp ( const SgNode* inputDerivedClassPointer )
279054 : {
279055 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
279056 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
279057 : // So to fix this we return NULL directly when the input is NULL and avoid the
279058 : // dynamic_cast in this case. This is likely a performance improvement as well.
279059 : // return dynamic_cast<const SgCompoundLiteralExp*>(inputDerivedClassPointer);
279060 : // Milind Chabbi (8/28/2013): isSgCompoundLiteralExp uses table-driven castability instead of c++ default dynamic_cast
279061 : // this improves the running time performance by 10-20%.
279062 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCompoundLiteralExp*>(inputDerivedClassPointer);
279063 0 : return IS_SgCompoundLiteralExp_FAST_MACRO(inputDerivedClassPointer);
279064 : }
279065 :
279066 :
279067 :
279068 : /* #line 279069 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279069 :
279070 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
279071 :
279072 : /**
279073 : \brief Generated destructor
279074 :
279075 : This destructor is automatically generated (by ROSETTA). This destructor
279076 : only frees memory of data members associated with the parts of the current IR node which
279077 : are NOT traversed. Those data members that are part of a traversal can be freed using
279078 : a traversal (calling this destructor on all children in a post-order traversal). Such
279079 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
279080 :
279081 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
279082 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
279083 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
279084 :
279085 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
279086 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
279087 : pointers are not yet implemented to call delete on eash pointer in the container.
279088 : (This could be done by derivation from the STL containers to define containers that
279089 : automatically deleted their members.)
279090 :
279091 : */
279092 0 : SgCompoundLiteralExp::~SgCompoundLiteralExp () {
279093 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
279094 :
279095 :
279096 : // case: not a listType for symbol
279097 0 : p_symbol = NULL; // non list case
279098 :
279099 : }
279100 :
279101 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
279102 0 : }
279103 :
279104 :
279105 : /* #line 279106 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279106 :
279107 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
279108 :
279109 : // Generated constructor
279110 0 : SgCompoundLiteralExp::SgCompoundLiteralExp ( Sg_File_Info* startOfConstruct, SgVariableSymbol* symbol )
279111 0 : : SgExpression(startOfConstruct)
279112 : {
279113 : #ifdef DEBUG
279114 : // printf ("In SgCompoundLiteralExp::SgCompoundLiteralExp (Sg_File_Info* startOfConstruct, SgVariableSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
279115 : #endif
279116 : #if 0
279117 : // debugging information!
279118 : printf ("In SgCompoundLiteralExp::SgCompoundLiteralExp (Sg_File_Info* startOfConstruct, SgVariableSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
279119 : #endif
279120 :
279121 0 : p_symbol = symbol;
279122 :
279123 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
279124 :
279125 : #if 0
279126 : // DQ (7/30/2014): Call a virtual function.
279127 : std::string s = this->class_name();
279128 : #endif
279129 :
279130 : // Test the variant virtual function
279131 : // assert(COMPOUND_LITERAL == variant());
279132 0 : assert(COMPOUND_LITERAL == this->variant());
279133 0 : ROSE_ASSERT(COMPOUND_LITERAL == (int)(this->variantT()));
279134 0 : post_construction_initialization();
279135 :
279136 : // Test the isSgCompoundLiteralExp() function since it has been problematic
279137 0 : assert(isSgCompoundLiteralExp(this) != NULL);
279138 0 : }
279139 :
279140 : // Generated constructor (all data members)
279141 :
279142 : /* #line 279143 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279143 :
279144 :
279145 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
279146 :
279147 :
279148 : // ********************************************************
279149 : // member functions common across all array grammar objects
279150 : // ********************************************************
279151 :
279152 :
279153 :
279154 : /* #line 279155 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279155 :
279156 :
279157 :
279158 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
279159 :
279160 : // ********************************************************
279161 : // member functions specific to each node in the grammar
279162 : // ********************************************************
279163 :
279164 :
279165 : /* #line 279166 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279166 :
279167 : // Start of memberFunctionString
279168 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
279169 :
279170 : void
279171 0 : SgTypeExpression::post_construction_initialization()
279172 : {
279173 0 : }
279174 :
279175 :
279176 :
279177 : // End of memberFunctionString
279178 : // Start of memberFunctionString
279179 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
279180 :
279181 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
279182 :
279183 : SgType*
279184 0 : SgTypeExpression::get_type () const
279185 : {
279186 0 : ROSE_ASSERT (this != NULL);
279187 :
279188 : #if 0
279189 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279190 : // used to trigger marking transformations for the token-based unparsing.
279191 : printf ("SgTypeExpression::get_type = %p = %s \n",this,this->class_name().c_str());
279192 : #endif
279193 :
279194 0 : return p_type;
279195 : }
279196 :
279197 : void
279198 0 : SgTypeExpression::set_type ( SgType* type )
279199 : {
279200 0 : ROSE_ASSERT (this != NULL);
279201 :
279202 : #if 0
279203 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279204 : // used to trigger marking transformations for the token-based unparsing.
279205 : printf ("SgTypeExpression::set_type = %p = %s \n",this,this->class_name().c_str());
279206 : #endif
279207 :
279208 0 : set_isModified(true);
279209 :
279210 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
279211 : if (p_type != NULL && type != NULL && p_type != type)
279212 : {
279213 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
279214 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
279215 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
279216 : ROSE_ASSERT(false);
279217 : #endif
279218 : }
279219 : #endif
279220 0 : p_type = type;
279221 0 : }
279222 :
279223 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
279224 :
279225 :
279226 : // End of memberFunctionString
279227 : // Start of memberFunctionString
279228 : /* #line 9498 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
279229 :
279230 :
279231 :
279232 : // End of memberFunctionString
279233 : // Start of memberFunctionString
279234 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
279235 :
279236 : // *** COMMON CODE SECTION BEGINS HERE ***
279237 :
279238 : #if 0
279239 : int
279240 : SgTypeExpression::getVariant() const
279241 : {
279242 : // This function is used in ROSE while "variant()" is used in SAGE
279243 : assert(this != NULL);
279244 : return variant();
279245 : }
279246 : #endif
279247 :
279248 : // This function is used in ROSE in treeTraversal code
279249 : // eventually replaces getVariant() and variant()
279250 : // though after variant() has been removed for a while we will
279251 : // want to change the name of variantT() back to variant()
279252 : // (since the "T" was ment to stand for temporary).
279253 : // When this happens the variantT() will be depricated.
279254 : VariantT
279255 0 : SgTypeExpression::variantT() const
279256 : {
279257 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
279258 0 : ROSE_ASSERT(this != NULL);
279259 0 : return V_SgTypeExpression;
279260 : }
279261 :
279262 : #if 0
279263 : int
279264 : SgTypeExpression::variant() const
279265 : {
279266 : // This function is used in SAGE
279267 : ROSE_ASSERT(this != NULL);
279268 : return TYPE_EXPRESSION;
279269 : }
279270 : #endif
279271 :
279272 : ROSE_DLL_API const char*
279273 0 : SgTypeExpression::sage_class_name() const
279274 : {
279275 0 : ROSE_ASSERT(this != NULL);
279276 0 : return "SgTypeExpression";
279277 : }
279278 :
279279 : std::string
279280 0 : SgTypeExpression::class_name() const
279281 : {
279282 0 : ROSE_ASSERT(this != NULL);
279283 0 : return "SgTypeExpression";
279284 : }
279285 :
279286 : // DQ (11/26/2005): Support for visitor pattern mechanims
279287 : // (inferior to ROSE traversal mechanism, experimental).
279288 : void
279289 0 : SgTypeExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
279290 : {
279291 0 : ROSE_ASSERT(this != NULL);
279292 0 : visitor.visit(this);
279293 0 : }
279294 :
279295 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
279296 0 : void SgTypeExpression::accept (ROSE_VisitorPattern & visitor) {
279297 0 : ROSE_ASSERT(this != NULL);
279298 0 : visitor.visit(this);
279299 0 : }
279300 :
279301 : SgTypeExpression*
279302 0 : SgTypeExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
279303 : {
279304 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
279305 : // This function is currently only supported for the AST used the represent Binary executables.
279306 : if (0 /* isSgAsmNode(this) != NULL */)
279307 : {
279308 : // Support for regex specification.
279309 : std::string prefixCode = "REGEX:";
279310 : addNewAttribute(prefixCode + s,a);
279311 : }
279312 : #endif
279313 :
279314 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
279315 0 : return this;
279316 : }
279317 :
279318 : // *** COMMON CODE SECTION ENDS HERE ***
279319 :
279320 :
279321 : // End of memberFunctionString
279322 : // Start of memberFunctionString
279323 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
279324 :
279325 :
279326 : #if 0
279327 : //! Error checking support
279328 : /*! Verifies the following:
279329 : - working getVariant() member function
279330 : - calls base class's error() member function
279331 : Every class has one of these functions.
279332 : */
279333 : bool
279334 : SgTypeExpression::error()
279335 : {
279336 : // Put error checking here
279337 :
279338 : ROSE_ASSERT (this != NULL);
279339 : if (getVariant() != TYPE_EXPRESSION)
279340 : {
279341 : printf ("Error in SgTypeExpression::error(): SgTypeExpression object has a %s variant \n",
279342 : Cxx_GrammarTerminalNames[getVariant()].name);
279343 : // printf ("Error in SgTypeExpression::error() \n");
279344 : ROSE_ABORT();
279345 : }
279346 :
279347 : ROSE_ASSERT (getVariant() == TYPE_EXPRESSION);
279348 : return SgExpression::error();
279349 : }
279350 : #endif
279351 :
279352 :
279353 :
279354 : // End of memberFunctionString
279355 :
279356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
279357 :
279358 0 : SgTypeExpression* isSgTypeExpression ( SgNode* inputDerivedClassPointer )
279359 : {
279360 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
279361 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
279362 : // So to fix this we return NULL directly when the input is NULL and avoid the
279363 : // dynamic_cast in this case. This is likely a performance improvement as well.
279364 : // return dynamic_cast<SgTypeExpression*>(inputDerivedClassPointer);
279365 : // Milind Chabbi (8/28/2013): isSgTypeExpression uses table-driven castability instead of c++ default dynamic_cast
279366 : // this improves the running time performance by 10-20%.
279367 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypeExpression*>(inputDerivedClassPointer);
279368 0 : return IS_SgTypeExpression_FAST_MACRO(inputDerivedClassPointer);
279369 : }
279370 :
279371 : // DQ (11/8/2003): Added version of functions taking const pointer
279372 0 : const SgTypeExpression* isSgTypeExpression ( const SgNode* inputDerivedClassPointer )
279373 : {
279374 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
279375 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
279376 : // So to fix this we return NULL directly when the input is NULL and avoid the
279377 : // dynamic_cast in this case. This is likely a performance improvement as well.
279378 : // return dynamic_cast<const SgTypeExpression*>(inputDerivedClassPointer);
279379 : // Milind Chabbi (8/28/2013): isSgTypeExpression uses table-driven castability instead of c++ default dynamic_cast
279380 : // this improves the running time performance by 10-20%.
279381 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypeExpression*>(inputDerivedClassPointer);
279382 0 : return IS_SgTypeExpression_FAST_MACRO(inputDerivedClassPointer);
279383 : }
279384 :
279385 :
279386 :
279387 : /* #line 279388 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279388 :
279389 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
279390 :
279391 : /**
279392 : \brief Generated destructor
279393 :
279394 : This destructor is automatically generated (by ROSETTA). This destructor
279395 : only frees memory of data members associated with the parts of the current IR node which
279396 : are NOT traversed. Those data members that are part of a traversal can be freed using
279397 : a traversal (calling this destructor on all children in a post-order traversal). Such
279398 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
279399 :
279400 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
279401 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
279402 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
279403 :
279404 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
279405 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
279406 : pointers are not yet implemented to call delete on eash pointer in the container.
279407 : (This could be done by derivation from the STL containers to define containers that
279408 : automatically deleted their members.)
279409 :
279410 : */
279411 0 : SgTypeExpression::~SgTypeExpression () {
279412 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
279413 :
279414 :
279415 : // case: not a listType for type
279416 0 : p_type = NULL; // non list case
279417 :
279418 : }
279419 :
279420 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
279421 0 : }
279422 :
279423 :
279424 : /* #line 279425 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279425 :
279426 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
279427 :
279428 : // Generated constructor
279429 0 : SgTypeExpression::SgTypeExpression ( Sg_File_Info* startOfConstruct, SgType* type )
279430 0 : : SgExpression(startOfConstruct)
279431 : {
279432 : #ifdef DEBUG
279433 : // printf ("In SgTypeExpression::SgTypeExpression (Sg_File_Info* startOfConstruct, SgType* type) sage_class_name() = %s \n",sage_class_name());
279434 : #endif
279435 : #if 0
279436 : // debugging information!
279437 : printf ("In SgTypeExpression::SgTypeExpression (Sg_File_Info* startOfConstruct, SgType* type): this = %p = %s \n",this,this->class_name().c_str());
279438 : #endif
279439 :
279440 0 : p_type = type;
279441 :
279442 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
279443 :
279444 : #if 0
279445 : // DQ (7/30/2014): Call a virtual function.
279446 : std::string s = this->class_name();
279447 : #endif
279448 :
279449 : // Test the variant virtual function
279450 : // assert(TYPE_EXPRESSION == variant());
279451 0 : assert(TYPE_EXPRESSION == this->variant());
279452 0 : ROSE_ASSERT(TYPE_EXPRESSION == (int)(this->variantT()));
279453 0 : post_construction_initialization();
279454 :
279455 : // Test the isSgTypeExpression() function since it has been problematic
279456 0 : assert(isSgTypeExpression(this) != NULL);
279457 0 : }
279458 :
279459 : // Generated constructor (all data members)
279460 :
279461 : /* #line 279462 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279462 :
279463 :
279464 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
279465 :
279466 :
279467 : // ********************************************************
279468 : // member functions common across all array grammar objects
279469 : // ********************************************************
279470 :
279471 :
279472 :
279473 : /* #line 279474 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279474 :
279475 :
279476 :
279477 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
279478 :
279479 : // ********************************************************
279480 : // member functions specific to each node in the grammar
279481 : // ********************************************************
279482 :
279483 :
279484 : /* #line 279485 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279485 :
279486 : // Start of memberFunctionString
279487 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
279488 :
279489 : void
279490 0 : SgClassExp::post_construction_initialization()
279491 : {
279492 0 : }
279493 :
279494 :
279495 :
279496 : // End of memberFunctionString
279497 : // Start of memberFunctionString
279498 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
279499 :
279500 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
279501 :
279502 : SgClassSymbol*
279503 0 : SgClassExp::get_class_symbol () const
279504 : {
279505 0 : ROSE_ASSERT (this != NULL);
279506 :
279507 : #if 0
279508 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279509 : // used to trigger marking transformations for the token-based unparsing.
279510 : printf ("SgClassExp::get_class_symbol = %p = %s \n",this,this->class_name().c_str());
279511 : #endif
279512 :
279513 0 : return p_class_symbol;
279514 : }
279515 :
279516 : void
279517 0 : SgClassExp::set_class_symbol ( SgClassSymbol* class_symbol )
279518 : {
279519 0 : ROSE_ASSERT (this != NULL);
279520 :
279521 : #if 0
279522 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279523 : // used to trigger marking transformations for the token-based unparsing.
279524 : printf ("SgClassExp::set_class_symbol = %p = %s \n",this,this->class_name().c_str());
279525 : #endif
279526 :
279527 0 : set_isModified(true);
279528 :
279529 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
279530 : if (p_class_symbol != NULL && class_symbol != NULL && p_class_symbol != class_symbol)
279531 : {
279532 : printf ("Warning: class_symbol = %p overwriting valid pointer p_class_symbol = %p \n",class_symbol,p_class_symbol);
279533 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
279534 : printf ("Error fails assertion (p_class_symbol != NULL && class_symbol != NULL && p_class_symbol != class_symbol) is false\n");
279535 : ROSE_ASSERT(false);
279536 : #endif
279537 : }
279538 : #endif
279539 0 : p_class_symbol = class_symbol;
279540 0 : }
279541 :
279542 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
279543 :
279544 :
279545 : // End of memberFunctionString
279546 : // Start of memberFunctionString
279547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
279548 :
279549 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
279550 :
279551 : int
279552 0 : SgClassExp::get_pobj_class () const
279553 : {
279554 0 : ROSE_ASSERT (this != NULL);
279555 :
279556 : #if 0
279557 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279558 : // used to trigger marking transformations for the token-based unparsing.
279559 : printf ("SgClassExp::get_pobj_class = %p = %s \n",this,this->class_name().c_str());
279560 : #endif
279561 :
279562 0 : return p_pobj_class;
279563 : }
279564 :
279565 : void
279566 0 : SgClassExp::set_pobj_class ( int pobj_class )
279567 : {
279568 0 : ROSE_ASSERT (this != NULL);
279569 :
279570 : #if 0
279571 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279572 : // used to trigger marking transformations for the token-based unparsing.
279573 : printf ("SgClassExp::set_pobj_class = %p = %s \n",this,this->class_name().c_str());
279574 : #endif
279575 :
279576 0 : set_isModified(true);
279577 :
279578 0 : p_pobj_class = pobj_class;
279579 0 : }
279580 :
279581 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
279582 :
279583 :
279584 : // End of memberFunctionString
279585 : // Start of memberFunctionString
279586 : /* #line 7043 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
279587 :
279588 :
279589 :
279590 : // End of memberFunctionString
279591 : // Start of memberFunctionString
279592 : /* #line 8510 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
279593 :
279594 :
279595 : SgType*
279596 0 : SgClassExp::get_type() const
279597 : {
279598 0 : ROSE_ASSERT(get_class_symbol() != NULL);
279599 0 : ROSE_ASSERT(get_class_symbol()->get_type() != NULL);
279600 :
279601 : #if 0
279602 : printf ("In SgClassExp::get_type() \n");
279603 : #endif
279604 :
279605 0 : return get_class_symbol() -> get_type();
279606 : }
279607 :
279608 :
279609 :
279610 : // End of memberFunctionString
279611 : // Start of memberFunctionString
279612 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
279613 :
279614 : // *** COMMON CODE SECTION BEGINS HERE ***
279615 :
279616 : #if 0
279617 : int
279618 : SgClassExp::getVariant() const
279619 : {
279620 : // This function is used in ROSE while "variant()" is used in SAGE
279621 : assert(this != NULL);
279622 : return variant();
279623 : }
279624 : #endif
279625 :
279626 : // This function is used in ROSE in treeTraversal code
279627 : // eventually replaces getVariant() and variant()
279628 : // though after variant() has been removed for a while we will
279629 : // want to change the name of variantT() back to variant()
279630 : // (since the "T" was ment to stand for temporary).
279631 : // When this happens the variantT() will be depricated.
279632 : VariantT
279633 0 : SgClassExp::variantT() const
279634 : {
279635 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
279636 0 : ROSE_ASSERT(this != NULL);
279637 0 : return V_SgClassExp;
279638 : }
279639 :
279640 : #if 0
279641 : int
279642 : SgClassExp::variant() const
279643 : {
279644 : // This function is used in SAGE
279645 : ROSE_ASSERT(this != NULL);
279646 : return CLASS_NODE;
279647 : }
279648 : #endif
279649 :
279650 : ROSE_DLL_API const char*
279651 0 : SgClassExp::sage_class_name() const
279652 : {
279653 0 : ROSE_ASSERT(this != NULL);
279654 0 : return "SgClassExp";
279655 : }
279656 :
279657 : std::string
279658 0 : SgClassExp::class_name() const
279659 : {
279660 0 : ROSE_ASSERT(this != NULL);
279661 0 : return "SgClassExp";
279662 : }
279663 :
279664 : // DQ (11/26/2005): Support for visitor pattern mechanims
279665 : // (inferior to ROSE traversal mechanism, experimental).
279666 : void
279667 0 : SgClassExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
279668 : {
279669 0 : ROSE_ASSERT(this != NULL);
279670 0 : visitor.visit(this);
279671 0 : }
279672 :
279673 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
279674 0 : void SgClassExp::accept (ROSE_VisitorPattern & visitor) {
279675 0 : ROSE_ASSERT(this != NULL);
279676 0 : visitor.visit(this);
279677 0 : }
279678 :
279679 : SgClassExp*
279680 0 : SgClassExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
279681 : {
279682 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
279683 : // This function is currently only supported for the AST used the represent Binary executables.
279684 : if (0 /* isSgAsmNode(this) != NULL */)
279685 : {
279686 : // Support for regex specification.
279687 : std::string prefixCode = "REGEX:";
279688 : addNewAttribute(prefixCode + s,a);
279689 : }
279690 : #endif
279691 :
279692 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
279693 0 : return this;
279694 : }
279695 :
279696 : // *** COMMON CODE SECTION ENDS HERE ***
279697 :
279698 :
279699 : // End of memberFunctionString
279700 : // Start of memberFunctionString
279701 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
279702 :
279703 :
279704 : #if 0
279705 : //! Error checking support
279706 : /*! Verifies the following:
279707 : - working getVariant() member function
279708 : - calls base class's error() member function
279709 : Every class has one of these functions.
279710 : */
279711 : bool
279712 : SgClassExp::error()
279713 : {
279714 : // Put error checking here
279715 :
279716 : ROSE_ASSERT (this != NULL);
279717 : if (getVariant() != CLASS_NODE)
279718 : {
279719 : printf ("Error in SgClassExp::error(): SgClassExp object has a %s variant \n",
279720 : Cxx_GrammarTerminalNames[getVariant()].name);
279721 : // printf ("Error in SgClassExp::error() \n");
279722 : ROSE_ABORT();
279723 : }
279724 :
279725 : ROSE_ASSERT (getVariant() == CLASS_NODE);
279726 : return SgExpression::error();
279727 : }
279728 : #endif
279729 :
279730 :
279731 :
279732 : // End of memberFunctionString
279733 :
279734 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
279735 :
279736 0 : SgClassExp* isSgClassExp ( SgNode* inputDerivedClassPointer )
279737 : {
279738 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
279739 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
279740 : // So to fix this we return NULL directly when the input is NULL and avoid the
279741 : // dynamic_cast in this case. This is likely a performance improvement as well.
279742 : // return dynamic_cast<SgClassExp*>(inputDerivedClassPointer);
279743 : // Milind Chabbi (8/28/2013): isSgClassExp uses table-driven castability instead of c++ default dynamic_cast
279744 : // this improves the running time performance by 10-20%.
279745 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassExp*>(inputDerivedClassPointer);
279746 0 : return IS_SgClassExp_FAST_MACRO(inputDerivedClassPointer);
279747 : }
279748 :
279749 : // DQ (11/8/2003): Added version of functions taking const pointer
279750 0 : const SgClassExp* isSgClassExp ( const SgNode* inputDerivedClassPointer )
279751 : {
279752 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
279753 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
279754 : // So to fix this we return NULL directly when the input is NULL and avoid the
279755 : // dynamic_cast in this case. This is likely a performance improvement as well.
279756 : // return dynamic_cast<const SgClassExp*>(inputDerivedClassPointer);
279757 : // Milind Chabbi (8/28/2013): isSgClassExp uses table-driven castability instead of c++ default dynamic_cast
279758 : // this improves the running time performance by 10-20%.
279759 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassExp*>(inputDerivedClassPointer);
279760 0 : return IS_SgClassExp_FAST_MACRO(inputDerivedClassPointer);
279761 : }
279762 :
279763 :
279764 :
279765 : /* #line 279766 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279766 :
279767 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
279768 :
279769 : /**
279770 : \brief Generated destructor
279771 :
279772 : This destructor is automatically generated (by ROSETTA). This destructor
279773 : only frees memory of data members associated with the parts of the current IR node which
279774 : are NOT traversed. Those data members that are part of a traversal can be freed using
279775 : a traversal (calling this destructor on all children in a post-order traversal). Such
279776 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
279777 :
279778 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
279779 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
279780 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
279781 :
279782 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
279783 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
279784 : pointers are not yet implemented to call delete on eash pointer in the container.
279785 : (This could be done by derivation from the STL containers to define containers that
279786 : automatically deleted their members.)
279787 :
279788 : */
279789 0 : SgClassExp::~SgClassExp () {
279790 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
279791 :
279792 :
279793 : // case: not a listType for class_symbol
279794 0 : p_class_symbol = NULL; // non list case
279795 : // case: not a listType for pobj_class
279796 0 : p_pobj_class = 0; // non list case
279797 :
279798 : }
279799 :
279800 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
279801 0 : }
279802 :
279803 :
279804 : /* #line 279805 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279805 :
279806 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
279807 :
279808 : // Generated constructor
279809 0 : SgClassExp::SgClassExp ( Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, int pobj_class )
279810 0 : : SgExpression(startOfConstruct)
279811 : {
279812 : #ifdef DEBUG
279813 : // printf ("In SgClassExp::SgClassExp (Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, int pobj_class) sage_class_name() = %s \n",sage_class_name());
279814 : #endif
279815 : #if 0
279816 : // debugging information!
279817 : printf ("In SgClassExp::SgClassExp (Sg_File_Info* startOfConstruct, SgClassSymbol* class_symbol, int pobj_class): this = %p = %s \n",this,this->class_name().c_str());
279818 : #endif
279819 :
279820 0 : p_class_symbol = class_symbol;
279821 0 : p_pobj_class = pobj_class;
279822 :
279823 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
279824 :
279825 : #if 0
279826 : // DQ (7/30/2014): Call a virtual function.
279827 : std::string s = this->class_name();
279828 : #endif
279829 :
279830 : // Test the variant virtual function
279831 : // assert(CLASS_NODE == variant());
279832 0 : assert(CLASS_NODE == this->variant());
279833 0 : ROSE_ASSERT(CLASS_NODE == (int)(this->variantT()));
279834 0 : post_construction_initialization();
279835 :
279836 : // Test the isSgClassExp() function since it has been problematic
279837 0 : assert(isSgClassExp(this) != NULL);
279838 0 : }
279839 :
279840 : // Generated constructor (all data members)
279841 :
279842 : /* #line 279843 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279843 :
279844 :
279845 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
279846 :
279847 :
279848 : // ********************************************************
279849 : // member functions common across all array grammar objects
279850 : // ********************************************************
279851 :
279852 :
279853 :
279854 : /* #line 279855 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279855 :
279856 :
279857 :
279858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
279859 :
279860 : // ********************************************************
279861 : // member functions specific to each node in the grammar
279862 : // ********************************************************
279863 :
279864 :
279865 : /* #line 279866 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
279866 :
279867 : // Start of memberFunctionString
279868 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
279869 :
279870 : void
279871 600 : SgFunctionParameterRefExp::post_construction_initialization()
279872 : {
279873 600 : }
279874 :
279875 :
279876 :
279877 : // End of memberFunctionString
279878 : // Start of memberFunctionString
279879 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
279880 :
279881 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
279882 :
279883 : int
279884 67 : SgFunctionParameterRefExp::get_parameter_number () const
279885 : {
279886 67 : ROSE_ASSERT (this != NULL);
279887 :
279888 : #if 0
279889 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279890 : // used to trigger marking transformations for the token-based unparsing.
279891 : printf ("SgFunctionParameterRefExp::get_parameter_number = %p = %s \n",this,this->class_name().c_str());
279892 : #endif
279893 :
279894 67 : return p_parameter_number;
279895 : }
279896 :
279897 : void
279898 0 : SgFunctionParameterRefExp::set_parameter_number ( int parameter_number )
279899 : {
279900 0 : ROSE_ASSERT (this != NULL);
279901 :
279902 : #if 0
279903 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279904 : // used to trigger marking transformations for the token-based unparsing.
279905 : printf ("SgFunctionParameterRefExp::set_parameter_number = %p = %s \n",this,this->class_name().c_str());
279906 : #endif
279907 :
279908 0 : set_isModified(true);
279909 :
279910 0 : p_parameter_number = parameter_number;
279911 0 : }
279912 :
279913 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
279914 :
279915 :
279916 : // End of memberFunctionString
279917 : // Start of memberFunctionString
279918 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
279919 :
279920 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
279921 :
279922 : int
279923 0 : SgFunctionParameterRefExp::get_parameter_levels_up () const
279924 : {
279925 0 : ROSE_ASSERT (this != NULL);
279926 :
279927 : #if 0
279928 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279929 : // used to trigger marking transformations for the token-based unparsing.
279930 : printf ("SgFunctionParameterRefExp::get_parameter_levels_up = %p = %s \n",this,this->class_name().c_str());
279931 : #endif
279932 :
279933 0 : return p_parameter_levels_up;
279934 : }
279935 :
279936 : void
279937 0 : SgFunctionParameterRefExp::set_parameter_levels_up ( int parameter_levels_up )
279938 : {
279939 0 : ROSE_ASSERT (this != NULL);
279940 :
279941 : #if 0
279942 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279943 : // used to trigger marking transformations for the token-based unparsing.
279944 : printf ("SgFunctionParameterRefExp::set_parameter_levels_up = %p = %s \n",this,this->class_name().c_str());
279945 : #endif
279946 :
279947 0 : set_isModified(true);
279948 :
279949 0 : p_parameter_levels_up = parameter_levels_up;
279950 0 : }
279951 :
279952 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
279953 :
279954 :
279955 : // End of memberFunctionString
279956 : // Start of memberFunctionString
279957 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
279958 :
279959 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
279960 :
279961 : SgExpression*
279962 0 : SgFunctionParameterRefExp::get_parameter_expression () const
279963 : {
279964 0 : ROSE_ASSERT (this != NULL);
279965 :
279966 : #if 0
279967 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279968 : // used to trigger marking transformations for the token-based unparsing.
279969 : printf ("SgFunctionParameterRefExp::get_parameter_expression = %p = %s \n",this,this->class_name().c_str());
279970 : #endif
279971 :
279972 0 : return p_parameter_expression;
279973 : }
279974 :
279975 : void
279976 0 : SgFunctionParameterRefExp::set_parameter_expression ( SgExpression* parameter_expression )
279977 : {
279978 0 : ROSE_ASSERT (this != NULL);
279979 :
279980 : #if 0
279981 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
279982 : // used to trigger marking transformations for the token-based unparsing.
279983 : printf ("SgFunctionParameterRefExp::set_parameter_expression = %p = %s \n",this,this->class_name().c_str());
279984 : #endif
279985 :
279986 0 : set_isModified(true);
279987 :
279988 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
279989 : if (p_parameter_expression != NULL && parameter_expression != NULL && p_parameter_expression != parameter_expression)
279990 : {
279991 : printf ("Warning: parameter_expression = %p overwriting valid pointer p_parameter_expression = %p \n",parameter_expression,p_parameter_expression);
279992 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
279993 : printf ("Error fails assertion (p_parameter_expression != NULL && parameter_expression != NULL && p_parameter_expression != parameter_expression) is false\n");
279994 : ROSE_ASSERT(false);
279995 : #endif
279996 : }
279997 : #endif
279998 0 : p_parameter_expression = parameter_expression;
279999 0 : }
280000 :
280001 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280002 :
280003 :
280004 : // End of memberFunctionString
280005 : // Start of memberFunctionString
280006 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280007 :
280008 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280009 :
280010 : SgType*
280011 0 : SgFunctionParameterRefExp::get_parameter_type () const
280012 : {
280013 0 : ROSE_ASSERT (this != NULL);
280014 :
280015 : #if 0
280016 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280017 : // used to trigger marking transformations for the token-based unparsing.
280018 : printf ("SgFunctionParameterRefExp::get_parameter_type = %p = %s \n",this,this->class_name().c_str());
280019 : #endif
280020 :
280021 0 : return p_parameter_type;
280022 : }
280023 :
280024 : void
280025 600 : SgFunctionParameterRefExp::set_parameter_type ( SgType* parameter_type )
280026 : {
280027 600 : ROSE_ASSERT (this != NULL);
280028 :
280029 : #if 0
280030 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280031 : // used to trigger marking transformations for the token-based unparsing.
280032 : printf ("SgFunctionParameterRefExp::set_parameter_type = %p = %s \n",this,this->class_name().c_str());
280033 : #endif
280034 :
280035 600 : set_isModified(true);
280036 :
280037 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
280038 : if (p_parameter_type != NULL && parameter_type != NULL && p_parameter_type != parameter_type)
280039 : {
280040 : printf ("Warning: parameter_type = %p overwriting valid pointer p_parameter_type = %p \n",parameter_type,p_parameter_type);
280041 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
280042 : printf ("Error fails assertion (p_parameter_type != NULL && parameter_type != NULL && p_parameter_type != parameter_type) is false\n");
280043 : ROSE_ASSERT(false);
280044 : #endif
280045 : }
280046 : #endif
280047 600 : p_parameter_type = parameter_type;
280048 600 : }
280049 :
280050 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280051 :
280052 :
280053 : // End of memberFunctionString
280054 : // Start of memberFunctionString
280055 : /* #line 9501 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
280056 :
280057 :
280058 : SgType*
280059 667 : SgFunctionParameterRefExp::get_type() const
280060 : {
280061 : // DQ (8/11/2014): Added support for C++11 decltype used in new function return syntax.
280062 :
280063 667 : ROSE_ASSERT(this != NULL);
280064 :
280065 667 : SgType* returnType = NULL;
280066 :
280067 : #if 0
280068 : printf ("In SgFunctionParameterRefExp::get_type() \n");
280069 : #endif
280070 :
280071 : // ROSE_ASSERT(p_parameter_expression != NULL);
280072 667 : if (p_parameter_expression != NULL)
280073 : {
280074 0 : ROSE_ASSERT(p_parameter_type == NULL);
280075 0 : returnType = p_parameter_expression->get_type();
280076 0 : ROSE_ASSERT(returnType != NULL);
280077 : }
280078 : else
280079 : {
280080 667 : returnType = p_parameter_type;
280081 667 : ROSE_ASSERT(returnType != NULL);
280082 : }
280083 :
280084 667 : ROSE_ASSERT(returnType != NULL);
280085 667 : return returnType;
280086 : }
280087 :
280088 :
280089 :
280090 : // End of memberFunctionString
280091 : // Start of memberFunctionString
280092 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
280093 :
280094 : // *** COMMON CODE SECTION BEGINS HERE ***
280095 :
280096 : #if 0
280097 : int
280098 : SgFunctionParameterRefExp::getVariant() const
280099 : {
280100 : // This function is used in ROSE while "variant()" is used in SAGE
280101 : assert(this != NULL);
280102 : return variant();
280103 : }
280104 : #endif
280105 :
280106 : // This function is used in ROSE in treeTraversal code
280107 : // eventually replaces getVariant() and variant()
280108 : // though after variant() has been removed for a while we will
280109 : // want to change the name of variantT() back to variant()
280110 : // (since the "T" was ment to stand for temporary).
280111 : // When this happens the variantT() will be depricated.
280112 : VariantT
280113 43699 : SgFunctionParameterRefExp::variantT() const
280114 : {
280115 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
280116 43699 : ROSE_ASSERT(this != NULL);
280117 43699 : return V_SgFunctionParameterRefExp;
280118 : }
280119 :
280120 : #if 0
280121 : int
280122 : SgFunctionParameterRefExp::variant() const
280123 : {
280124 : // This function is used in SAGE
280125 : ROSE_ASSERT(this != NULL);
280126 : return FUNCTION_PARAMETER_REF_EXP;
280127 : }
280128 : #endif
280129 :
280130 : ROSE_DLL_API const char*
280131 0 : SgFunctionParameterRefExp::sage_class_name() const
280132 : {
280133 0 : ROSE_ASSERT(this != NULL);
280134 0 : return "SgFunctionParameterRefExp";
280135 : }
280136 :
280137 : std::string
280138 501 : SgFunctionParameterRefExp::class_name() const
280139 : {
280140 501 : ROSE_ASSERT(this != NULL);
280141 501 : return "SgFunctionParameterRefExp";
280142 : }
280143 :
280144 : // DQ (11/26/2005): Support for visitor pattern mechanims
280145 : // (inferior to ROSE traversal mechanism, experimental).
280146 : void
280147 9179 : SgFunctionParameterRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
280148 : {
280149 9179 : ROSE_ASSERT(this != NULL);
280150 9179 : visitor.visit(this);
280151 9179 : }
280152 :
280153 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
280154 0 : void SgFunctionParameterRefExp::accept (ROSE_VisitorPattern & visitor) {
280155 0 : ROSE_ASSERT(this != NULL);
280156 0 : visitor.visit(this);
280157 0 : }
280158 :
280159 : SgFunctionParameterRefExp*
280160 0 : SgFunctionParameterRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
280161 : {
280162 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
280163 : // This function is currently only supported for the AST used the represent Binary executables.
280164 : if (0 /* isSgAsmNode(this) != NULL */)
280165 : {
280166 : // Support for regex specification.
280167 : std::string prefixCode = "REGEX:";
280168 : addNewAttribute(prefixCode + s,a);
280169 : }
280170 : #endif
280171 :
280172 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
280173 0 : return this;
280174 : }
280175 :
280176 : // *** COMMON CODE SECTION ENDS HERE ***
280177 :
280178 :
280179 : // End of memberFunctionString
280180 : // Start of memberFunctionString
280181 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
280182 :
280183 :
280184 : #if 0
280185 : //! Error checking support
280186 : /*! Verifies the following:
280187 : - working getVariant() member function
280188 : - calls base class's error() member function
280189 : Every class has one of these functions.
280190 : */
280191 : bool
280192 : SgFunctionParameterRefExp::error()
280193 : {
280194 : // Put error checking here
280195 :
280196 : ROSE_ASSERT (this != NULL);
280197 : if (getVariant() != FUNCTION_PARAMETER_REF_EXP)
280198 : {
280199 : printf ("Error in SgFunctionParameterRefExp::error(): SgFunctionParameterRefExp object has a %s variant \n",
280200 : Cxx_GrammarTerminalNames[getVariant()].name);
280201 : // printf ("Error in SgFunctionParameterRefExp::error() \n");
280202 : ROSE_ABORT();
280203 : }
280204 :
280205 : ROSE_ASSERT (getVariant() == FUNCTION_PARAMETER_REF_EXP);
280206 : return SgExpression::error();
280207 : }
280208 : #endif
280209 :
280210 :
280211 :
280212 : // End of memberFunctionString
280213 :
280214 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
280215 :
280216 1973 : SgFunctionParameterRefExp* isSgFunctionParameterRefExp ( SgNode* inputDerivedClassPointer )
280217 : {
280218 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
280219 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
280220 : // So to fix this we return NULL directly when the input is NULL and avoid the
280221 : // dynamic_cast in this case. This is likely a performance improvement as well.
280222 : // return dynamic_cast<SgFunctionParameterRefExp*>(inputDerivedClassPointer);
280223 : // Milind Chabbi (8/28/2013): isSgFunctionParameterRefExp uses table-driven castability instead of c++ default dynamic_cast
280224 : // this improves the running time performance by 10-20%.
280225 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionParameterRefExp*>(inputDerivedClassPointer);
280226 1973 : return IS_SgFunctionParameterRefExp_FAST_MACRO(inputDerivedClassPointer);
280227 : }
280228 :
280229 : // DQ (11/8/2003): Added version of functions taking const pointer
280230 4786 : const SgFunctionParameterRefExp* isSgFunctionParameterRefExp ( const SgNode* inputDerivedClassPointer )
280231 : {
280232 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
280233 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
280234 : // So to fix this we return NULL directly when the input is NULL and avoid the
280235 : // dynamic_cast in this case. This is likely a performance improvement as well.
280236 : // return dynamic_cast<const SgFunctionParameterRefExp*>(inputDerivedClassPointer);
280237 : // Milind Chabbi (8/28/2013): isSgFunctionParameterRefExp uses table-driven castability instead of c++ default dynamic_cast
280238 : // this improves the running time performance by 10-20%.
280239 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionParameterRefExp*>(inputDerivedClassPointer);
280240 4786 : return IS_SgFunctionParameterRefExp_FAST_MACRO(inputDerivedClassPointer);
280241 : }
280242 :
280243 :
280244 :
280245 : /* #line 280246 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280246 :
280247 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
280248 :
280249 : /**
280250 : \brief Generated destructor
280251 :
280252 : This destructor is automatically generated (by ROSETTA). This destructor
280253 : only frees memory of data members associated with the parts of the current IR node which
280254 : are NOT traversed. Those data members that are part of a traversal can be freed using
280255 : a traversal (calling this destructor on all children in a post-order traversal). Such
280256 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
280257 :
280258 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
280259 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
280260 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
280261 :
280262 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
280263 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
280264 : pointers are not yet implemented to call delete on eash pointer in the container.
280265 : (This could be done by derivation from the STL containers to define containers that
280266 : automatically deleted their members.)
280267 :
280268 : */
280269 268 : SgFunctionParameterRefExp::~SgFunctionParameterRefExp () {
280270 134 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
280271 :
280272 :
280273 : // case: not a listType for parameter_number
280274 134 : p_parameter_number = -1; // non list case
280275 : // case: not a listType for parameter_levels_up
280276 134 : p_parameter_levels_up = -1; // non list case
280277 : // case: not a listType for parameter_expression
280278 134 : p_parameter_expression = NULL; // non list case
280279 : // case: not a listType for parameter_type
280280 134 : p_parameter_type = NULL; // non list case
280281 :
280282 : }
280283 :
280284 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
280285 268 : }
280286 :
280287 :
280288 : /* #line 280289 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280289 :
280290 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
280291 :
280292 : // Generated constructor
280293 600 : SgFunctionParameterRefExp::SgFunctionParameterRefExp ( Sg_File_Info* startOfConstruct, int parameter_number, int parameter_levels_up )
280294 600 : : SgExpression(startOfConstruct)
280295 : {
280296 : #ifdef DEBUG
280297 : // printf ("In SgFunctionParameterRefExp::SgFunctionParameterRefExp (Sg_File_Info* startOfConstruct, int parameter_number, int parameter_levels_up) sage_class_name() = %s \n",sage_class_name());
280298 : #endif
280299 : #if 0
280300 : // debugging information!
280301 : printf ("In SgFunctionParameterRefExp::SgFunctionParameterRefExp (Sg_File_Info* startOfConstruct, int parameter_number, int parameter_levels_up): this = %p = %s \n",this,this->class_name().c_str());
280302 : #endif
280303 :
280304 600 : p_parameter_number = parameter_number;
280305 600 : p_parameter_levels_up = parameter_levels_up;
280306 600 : p_parameter_expression = NULL;
280307 600 : p_parameter_type = NULL;
280308 :
280309 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
280310 :
280311 : #if 0
280312 : // DQ (7/30/2014): Call a virtual function.
280313 : std::string s = this->class_name();
280314 : #endif
280315 :
280316 : // Test the variant virtual function
280317 : // assert(FUNCTION_PARAMETER_REF_EXP == variant());
280318 600 : assert(FUNCTION_PARAMETER_REF_EXP == this->variant());
280319 600 : ROSE_ASSERT(FUNCTION_PARAMETER_REF_EXP == (int)(this->variantT()));
280320 600 : post_construction_initialization();
280321 :
280322 : // Test the isSgFunctionParameterRefExp() function since it has been problematic
280323 600 : assert(isSgFunctionParameterRefExp(this) != NULL);
280324 600 : }
280325 :
280326 : // Generated constructor (all data members)
280327 :
280328 : /* #line 280329 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280329 :
280330 :
280331 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
280332 :
280333 :
280334 : // ********************************************************
280335 : // member functions common across all array grammar objects
280336 : // ********************************************************
280337 :
280338 :
280339 :
280340 : /* #line 280341 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280341 :
280342 :
280343 :
280344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
280345 :
280346 : // ********************************************************
280347 : // member functions specific to each node in the grammar
280348 : // ********************************************************
280349 :
280350 :
280351 : /* #line 280352 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280352 :
280353 : // Start of memberFunctionString
280354 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
280355 :
280356 : void
280357 0 : SgLambdaExp::post_construction_initialization()
280358 : {
280359 0 : }
280360 :
280361 :
280362 :
280363 : // End of memberFunctionString
280364 : // Start of memberFunctionString
280365 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280366 :
280367 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280368 :
280369 : SgLambdaCaptureList*
280370 0 : SgLambdaExp::get_lambda_capture_list () const
280371 : {
280372 0 : ROSE_ASSERT (this != NULL);
280373 :
280374 : #if 0
280375 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280376 : // used to trigger marking transformations for the token-based unparsing.
280377 : printf ("SgLambdaExp::get_lambda_capture_list = %p = %s \n",this,this->class_name().c_str());
280378 : #endif
280379 :
280380 0 : return p_lambda_capture_list;
280381 : }
280382 :
280383 : void
280384 0 : SgLambdaExp::set_lambda_capture_list ( SgLambdaCaptureList* lambda_capture_list )
280385 : {
280386 0 : ROSE_ASSERT (this != NULL);
280387 :
280388 : #if 0
280389 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280390 : // used to trigger marking transformations for the token-based unparsing.
280391 : printf ("SgLambdaExp::set_lambda_capture_list = %p = %s \n",this,this->class_name().c_str());
280392 : #endif
280393 :
280394 0 : set_isModified(true);
280395 :
280396 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
280397 : if (p_lambda_capture_list != NULL && lambda_capture_list != NULL && p_lambda_capture_list != lambda_capture_list)
280398 : {
280399 : printf ("Warning: lambda_capture_list = %p overwriting valid pointer p_lambda_capture_list = %p \n",lambda_capture_list,p_lambda_capture_list);
280400 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
280401 : printf ("Error fails assertion (p_lambda_capture_list != NULL && lambda_capture_list != NULL && p_lambda_capture_list != lambda_capture_list) is false\n");
280402 : ROSE_ASSERT(false);
280403 : #endif
280404 : }
280405 : #endif
280406 0 : p_lambda_capture_list = lambda_capture_list;
280407 0 : }
280408 :
280409 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280410 :
280411 :
280412 : // End of memberFunctionString
280413 : // Start of memberFunctionString
280414 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280415 :
280416 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280417 :
280418 : SgClassDeclaration*
280419 0 : SgLambdaExp::get_lambda_closure_class () const
280420 : {
280421 0 : ROSE_ASSERT (this != NULL);
280422 :
280423 : #if 0
280424 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280425 : // used to trigger marking transformations for the token-based unparsing.
280426 : printf ("SgLambdaExp::get_lambda_closure_class = %p = %s \n",this,this->class_name().c_str());
280427 : #endif
280428 :
280429 0 : return p_lambda_closure_class;
280430 : }
280431 :
280432 : void
280433 0 : SgLambdaExp::set_lambda_closure_class ( SgClassDeclaration* lambda_closure_class )
280434 : {
280435 0 : ROSE_ASSERT (this != NULL);
280436 :
280437 : #if 0
280438 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280439 : // used to trigger marking transformations for the token-based unparsing.
280440 : printf ("SgLambdaExp::set_lambda_closure_class = %p = %s \n",this,this->class_name().c_str());
280441 : #endif
280442 :
280443 0 : set_isModified(true);
280444 :
280445 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
280446 : if (p_lambda_closure_class != NULL && lambda_closure_class != NULL && p_lambda_closure_class != lambda_closure_class)
280447 : {
280448 : printf ("Warning: lambda_closure_class = %p overwriting valid pointer p_lambda_closure_class = %p \n",lambda_closure_class,p_lambda_closure_class);
280449 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
280450 : printf ("Error fails assertion (p_lambda_closure_class != NULL && lambda_closure_class != NULL && p_lambda_closure_class != lambda_closure_class) is false\n");
280451 : ROSE_ASSERT(false);
280452 : #endif
280453 : }
280454 : #endif
280455 0 : p_lambda_closure_class = lambda_closure_class;
280456 0 : }
280457 :
280458 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280459 :
280460 :
280461 : // End of memberFunctionString
280462 : // Start of memberFunctionString
280463 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280464 :
280465 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280466 :
280467 : SgFunctionDeclaration*
280468 0 : SgLambdaExp::get_lambda_function () const
280469 : {
280470 0 : ROSE_ASSERT (this != NULL);
280471 :
280472 : #if 0
280473 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280474 : // used to trigger marking transformations for the token-based unparsing.
280475 : printf ("SgLambdaExp::get_lambda_function = %p = %s \n",this,this->class_name().c_str());
280476 : #endif
280477 :
280478 0 : return p_lambda_function;
280479 : }
280480 :
280481 : void
280482 0 : SgLambdaExp::set_lambda_function ( SgFunctionDeclaration* lambda_function )
280483 : {
280484 0 : ROSE_ASSERT (this != NULL);
280485 :
280486 : #if 0
280487 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280488 : // used to trigger marking transformations for the token-based unparsing.
280489 : printf ("SgLambdaExp::set_lambda_function = %p = %s \n",this,this->class_name().c_str());
280490 : #endif
280491 :
280492 0 : set_isModified(true);
280493 :
280494 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
280495 : if (p_lambda_function != NULL && lambda_function != NULL && p_lambda_function != lambda_function)
280496 : {
280497 : printf ("Warning: lambda_function = %p overwriting valid pointer p_lambda_function = %p \n",lambda_function,p_lambda_function);
280498 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
280499 : printf ("Error fails assertion (p_lambda_function != NULL && lambda_function != NULL && p_lambda_function != lambda_function) is false\n");
280500 : ROSE_ASSERT(false);
280501 : #endif
280502 : }
280503 : #endif
280504 0 : p_lambda_function = lambda_function;
280505 0 : }
280506 :
280507 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280508 :
280509 :
280510 : // End of memberFunctionString
280511 : // Start of memberFunctionString
280512 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280513 :
280514 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280515 :
280516 : bool
280517 0 : SgLambdaExp::get_is_mutable () const
280518 : {
280519 0 : ROSE_ASSERT (this != NULL);
280520 :
280521 : #if 0
280522 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280523 : // used to trigger marking transformations for the token-based unparsing.
280524 : printf ("SgLambdaExp::get_is_mutable = %p = %s \n",this,this->class_name().c_str());
280525 : #endif
280526 :
280527 0 : return p_is_mutable;
280528 : }
280529 :
280530 : void
280531 0 : SgLambdaExp::set_is_mutable ( bool is_mutable )
280532 : {
280533 0 : ROSE_ASSERT (this != NULL);
280534 :
280535 : #if 0
280536 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280537 : // used to trigger marking transformations for the token-based unparsing.
280538 : printf ("SgLambdaExp::set_is_mutable = %p = %s \n",this,this->class_name().c_str());
280539 : #endif
280540 :
280541 0 : set_isModified(true);
280542 :
280543 0 : p_is_mutable = is_mutable;
280544 0 : }
280545 :
280546 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280547 :
280548 :
280549 : // End of memberFunctionString
280550 : // Start of memberFunctionString
280551 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280552 :
280553 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280554 :
280555 : bool
280556 0 : SgLambdaExp::get_capture_default () const
280557 : {
280558 0 : ROSE_ASSERT (this != NULL);
280559 :
280560 : #if 0
280561 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280562 : // used to trigger marking transformations for the token-based unparsing.
280563 : printf ("SgLambdaExp::get_capture_default = %p = %s \n",this,this->class_name().c_str());
280564 : #endif
280565 :
280566 0 : return p_capture_default;
280567 : }
280568 :
280569 : void
280570 0 : SgLambdaExp::set_capture_default ( bool capture_default )
280571 : {
280572 0 : ROSE_ASSERT (this != NULL);
280573 :
280574 : #if 0
280575 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280576 : // used to trigger marking transformations for the token-based unparsing.
280577 : printf ("SgLambdaExp::set_capture_default = %p = %s \n",this,this->class_name().c_str());
280578 : #endif
280579 :
280580 0 : set_isModified(true);
280581 :
280582 0 : p_capture_default = capture_default;
280583 0 : }
280584 :
280585 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280586 :
280587 :
280588 : // End of memberFunctionString
280589 : // Start of memberFunctionString
280590 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280591 :
280592 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280593 :
280594 : bool
280595 0 : SgLambdaExp::get_default_is_by_reference () const
280596 : {
280597 0 : ROSE_ASSERT (this != NULL);
280598 :
280599 : #if 0
280600 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280601 : // used to trigger marking transformations for the token-based unparsing.
280602 : printf ("SgLambdaExp::get_default_is_by_reference = %p = %s \n",this,this->class_name().c_str());
280603 : #endif
280604 :
280605 0 : return p_default_is_by_reference;
280606 : }
280607 :
280608 : void
280609 0 : SgLambdaExp::set_default_is_by_reference ( bool default_is_by_reference )
280610 : {
280611 0 : ROSE_ASSERT (this != NULL);
280612 :
280613 : #if 0
280614 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280615 : // used to trigger marking transformations for the token-based unparsing.
280616 : printf ("SgLambdaExp::set_default_is_by_reference = %p = %s \n",this,this->class_name().c_str());
280617 : #endif
280618 :
280619 0 : set_isModified(true);
280620 :
280621 0 : p_default_is_by_reference = default_is_by_reference;
280622 0 : }
280623 :
280624 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280625 :
280626 :
280627 : // End of memberFunctionString
280628 : // Start of memberFunctionString
280629 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280630 :
280631 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280632 :
280633 : bool
280634 0 : SgLambdaExp::get_explicit_return_type () const
280635 : {
280636 0 : ROSE_ASSERT (this != NULL);
280637 :
280638 : #if 0
280639 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280640 : // used to trigger marking transformations for the token-based unparsing.
280641 : printf ("SgLambdaExp::get_explicit_return_type = %p = %s \n",this,this->class_name().c_str());
280642 : #endif
280643 :
280644 0 : return p_explicit_return_type;
280645 : }
280646 :
280647 : void
280648 0 : SgLambdaExp::set_explicit_return_type ( bool explicit_return_type )
280649 : {
280650 0 : ROSE_ASSERT (this != NULL);
280651 :
280652 : #if 0
280653 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280654 : // used to trigger marking transformations for the token-based unparsing.
280655 : printf ("SgLambdaExp::set_explicit_return_type = %p = %s \n",this,this->class_name().c_str());
280656 : #endif
280657 :
280658 0 : set_isModified(true);
280659 :
280660 0 : p_explicit_return_type = explicit_return_type;
280661 0 : }
280662 :
280663 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280664 :
280665 :
280666 : // End of memberFunctionString
280667 : // Start of memberFunctionString
280668 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280669 :
280670 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280671 :
280672 : bool
280673 0 : SgLambdaExp::get_has_parameter_decl () const
280674 : {
280675 0 : ROSE_ASSERT (this != NULL);
280676 :
280677 : #if 0
280678 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280679 : // used to trigger marking transformations for the token-based unparsing.
280680 : printf ("SgLambdaExp::get_has_parameter_decl = %p = %s \n",this,this->class_name().c_str());
280681 : #endif
280682 :
280683 0 : return p_has_parameter_decl;
280684 : }
280685 :
280686 : void
280687 0 : SgLambdaExp::set_has_parameter_decl ( bool has_parameter_decl )
280688 : {
280689 0 : ROSE_ASSERT (this != NULL);
280690 :
280691 : #if 0
280692 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280693 : // used to trigger marking transformations for the token-based unparsing.
280694 : printf ("SgLambdaExp::set_has_parameter_decl = %p = %s \n",this,this->class_name().c_str());
280695 : #endif
280696 :
280697 0 : set_isModified(true);
280698 :
280699 0 : p_has_parameter_decl = has_parameter_decl;
280700 0 : }
280701 :
280702 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280703 :
280704 :
280705 : // End of memberFunctionString
280706 : // Start of memberFunctionString
280707 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
280708 :
280709 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
280710 :
280711 : bool
280712 0 : SgLambdaExp::get_is_device () const
280713 : {
280714 0 : ROSE_ASSERT (this != NULL);
280715 :
280716 : #if 0
280717 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280718 : // used to trigger marking transformations for the token-based unparsing.
280719 : printf ("SgLambdaExp::get_is_device = %p = %s \n",this,this->class_name().c_str());
280720 : #endif
280721 :
280722 0 : return p_is_device;
280723 : }
280724 :
280725 : void
280726 0 : SgLambdaExp::set_is_device ( bool is_device )
280727 : {
280728 0 : ROSE_ASSERT (this != NULL);
280729 :
280730 : #if 0
280731 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
280732 : // used to trigger marking transformations for the token-based unparsing.
280733 : printf ("SgLambdaExp::set_is_device = %p = %s \n",this,this->class_name().c_str());
280734 : #endif
280735 :
280736 0 : set_isModified(true);
280737 :
280738 0 : p_is_device = is_device;
280739 0 : }
280740 :
280741 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
280742 :
280743 :
280744 : // End of memberFunctionString
280745 : // Start of memberFunctionString
280746 : /* #line 3542 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
280747 :
280748 :
280749 : SgType*
280750 0 : SgLambdaExp::get_type() const
280751 : {
280752 : // DQ (9/2/2014): I think we want this to be the return type of the function (deduced or not).
280753 :
280754 : #if 0
280755 : printf ("In SgLambdaExp::get_type() \n");
280756 : #endif
280757 :
280758 0 : return SageBuilder::buildVoidType(); // TODO this is wrong
280759 : }
280760 :
280761 :
280762 :
280763 : // End of memberFunctionString
280764 : // Start of memberFunctionString
280765 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
280766 :
280767 : // *** COMMON CODE SECTION BEGINS HERE ***
280768 :
280769 : #if 0
280770 : int
280771 : SgLambdaExp::getVariant() const
280772 : {
280773 : // This function is used in ROSE while "variant()" is used in SAGE
280774 : assert(this != NULL);
280775 : return variant();
280776 : }
280777 : #endif
280778 :
280779 : // This function is used in ROSE in treeTraversal code
280780 : // eventually replaces getVariant() and variant()
280781 : // though after variant() has been removed for a while we will
280782 : // want to change the name of variantT() back to variant()
280783 : // (since the "T" was ment to stand for temporary).
280784 : // When this happens the variantT() will be depricated.
280785 : VariantT
280786 0 : SgLambdaExp::variantT() const
280787 : {
280788 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
280789 0 : ROSE_ASSERT(this != NULL);
280790 0 : return V_SgLambdaExp;
280791 : }
280792 :
280793 : #if 0
280794 : int
280795 : SgLambdaExp::variant() const
280796 : {
280797 : // This function is used in SAGE
280798 : ROSE_ASSERT(this != NULL);
280799 : return LAMBDA_EXP;
280800 : }
280801 : #endif
280802 :
280803 : ROSE_DLL_API const char*
280804 0 : SgLambdaExp::sage_class_name() const
280805 : {
280806 0 : ROSE_ASSERT(this != NULL);
280807 0 : return "SgLambdaExp";
280808 : }
280809 :
280810 : std::string
280811 0 : SgLambdaExp::class_name() const
280812 : {
280813 0 : ROSE_ASSERT(this != NULL);
280814 0 : return "SgLambdaExp";
280815 : }
280816 :
280817 : // DQ (11/26/2005): Support for visitor pattern mechanims
280818 : // (inferior to ROSE traversal mechanism, experimental).
280819 : void
280820 0 : SgLambdaExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
280821 : {
280822 0 : ROSE_ASSERT(this != NULL);
280823 0 : visitor.visit(this);
280824 0 : }
280825 :
280826 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
280827 0 : void SgLambdaExp::accept (ROSE_VisitorPattern & visitor) {
280828 0 : ROSE_ASSERT(this != NULL);
280829 0 : visitor.visit(this);
280830 0 : }
280831 :
280832 : SgLambdaExp*
280833 0 : SgLambdaExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
280834 : {
280835 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
280836 : // This function is currently only supported for the AST used the represent Binary executables.
280837 : if (0 /* isSgAsmNode(this) != NULL */)
280838 : {
280839 : // Support for regex specification.
280840 : std::string prefixCode = "REGEX:";
280841 : addNewAttribute(prefixCode + s,a);
280842 : }
280843 : #endif
280844 :
280845 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
280846 0 : return this;
280847 : }
280848 :
280849 : // *** COMMON CODE SECTION ENDS HERE ***
280850 :
280851 :
280852 : // End of memberFunctionString
280853 : // Start of memberFunctionString
280854 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
280855 :
280856 :
280857 : #if 0
280858 : //! Error checking support
280859 : /*! Verifies the following:
280860 : - working getVariant() member function
280861 : - calls base class's error() member function
280862 : Every class has one of these functions.
280863 : */
280864 : bool
280865 : SgLambdaExp::error()
280866 : {
280867 : // Put error checking here
280868 :
280869 : ROSE_ASSERT (this != NULL);
280870 : if (getVariant() != LAMBDA_EXP)
280871 : {
280872 : printf ("Error in SgLambdaExp::error(): SgLambdaExp object has a %s variant \n",
280873 : Cxx_GrammarTerminalNames[getVariant()].name);
280874 : // printf ("Error in SgLambdaExp::error() \n");
280875 : ROSE_ABORT();
280876 : }
280877 :
280878 : ROSE_ASSERT (getVariant() == LAMBDA_EXP);
280879 : return SgExpression::error();
280880 : }
280881 : #endif
280882 :
280883 :
280884 :
280885 : // End of memberFunctionString
280886 :
280887 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
280888 :
280889 273982 : SgLambdaExp* isSgLambdaExp ( SgNode* inputDerivedClassPointer )
280890 : {
280891 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
280892 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
280893 : // So to fix this we return NULL directly when the input is NULL and avoid the
280894 : // dynamic_cast in this case. This is likely a performance improvement as well.
280895 : // return dynamic_cast<SgLambdaExp*>(inputDerivedClassPointer);
280896 : // Milind Chabbi (8/28/2013): isSgLambdaExp uses table-driven castability instead of c++ default dynamic_cast
280897 : // this improves the running time performance by 10-20%.
280898 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLambdaExp*>(inputDerivedClassPointer);
280899 273982 : return IS_SgLambdaExp_FAST_MACRO(inputDerivedClassPointer);
280900 : }
280901 :
280902 : // DQ (11/8/2003): Added version of functions taking const pointer
280903 0 : const SgLambdaExp* isSgLambdaExp ( const SgNode* inputDerivedClassPointer )
280904 : {
280905 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
280906 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
280907 : // So to fix this we return NULL directly when the input is NULL and avoid the
280908 : // dynamic_cast in this case. This is likely a performance improvement as well.
280909 : // return dynamic_cast<const SgLambdaExp*>(inputDerivedClassPointer);
280910 : // Milind Chabbi (8/28/2013): isSgLambdaExp uses table-driven castability instead of c++ default dynamic_cast
280911 : // this improves the running time performance by 10-20%.
280912 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLambdaExp*>(inputDerivedClassPointer);
280913 0 : return IS_SgLambdaExp_FAST_MACRO(inputDerivedClassPointer);
280914 : }
280915 :
280916 :
280917 :
280918 : /* #line 280919 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280919 :
280920 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
280921 :
280922 : /**
280923 : \brief Generated destructor
280924 :
280925 : This destructor is automatically generated (by ROSETTA). This destructor
280926 : only frees memory of data members associated with the parts of the current IR node which
280927 : are NOT traversed. Those data members that are part of a traversal can be freed using
280928 : a traversal (calling this destructor on all children in a post-order traversal). Such
280929 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
280930 :
280931 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
280932 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
280933 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
280934 :
280935 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
280936 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
280937 : pointers are not yet implemented to call delete on eash pointer in the container.
280938 : (This could be done by derivation from the STL containers to define containers that
280939 : automatically deleted their members.)
280940 :
280941 : */
280942 0 : SgLambdaExp::~SgLambdaExp () {
280943 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
280944 :
280945 :
280946 : // case: not a listType for lambda_capture_list
280947 0 : p_lambda_capture_list = NULL; // non list case
280948 : // case: not a listType for lambda_closure_class
280949 0 : p_lambda_closure_class = NULL; // non list case
280950 : // case: not a listType for lambda_function
280951 0 : p_lambda_function = NULL; // non list case
280952 : // case: not a listType for is_mutable
280953 0 : p_is_mutable = false; // non list case
280954 : // case: not a listType for capture_default
280955 0 : p_capture_default = false; // non list case
280956 : // case: not a listType for default_is_by_reference
280957 0 : p_default_is_by_reference = false; // non list case
280958 : // case: not a listType for explicit_return_type
280959 0 : p_explicit_return_type = false; // non list case
280960 : // case: not a listType for has_parameter_decl
280961 0 : p_has_parameter_decl = false; // non list case
280962 : // case: not a listType for is_device
280963 0 : p_is_device = false; // non list case
280964 :
280965 : }
280966 :
280967 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
280968 0 : }
280969 :
280970 :
280971 : /* #line 280972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
280972 :
280973 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
280974 :
280975 : // Generated constructor
280976 0 : SgLambdaExp::SgLambdaExp ( Sg_File_Info* startOfConstruct, SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function )
280977 0 : : SgExpression(startOfConstruct)
280978 : {
280979 : #ifdef DEBUG
280980 : // printf ("In SgLambdaExp::SgLambdaExp (Sg_File_Info* startOfConstruct, SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function) sage_class_name() = %s \n",sage_class_name());
280981 : #endif
280982 : #if 0
280983 : // debugging information!
280984 : printf ("In SgLambdaExp::SgLambdaExp (Sg_File_Info* startOfConstruct, SgLambdaCaptureList* lambda_capture_list, SgClassDeclaration* lambda_closure_class, SgFunctionDeclaration* lambda_function): this = %p = %s \n",this,this->class_name().c_str());
280985 : #endif
280986 :
280987 0 : p_lambda_capture_list = lambda_capture_list;
280988 0 : p_lambda_closure_class = lambda_closure_class;
280989 0 : p_lambda_function = lambda_function;
280990 0 : p_is_mutable = false;
280991 0 : p_capture_default = false;
280992 0 : p_default_is_by_reference = false;
280993 0 : p_explicit_return_type = false;
280994 0 : p_has_parameter_decl = false;
280995 0 : p_is_device = false;
280996 :
280997 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
280998 :
280999 : #if 0
281000 : // DQ (7/30/2014): Call a virtual function.
281001 : std::string s = this->class_name();
281002 : #endif
281003 :
281004 : // Test the variant virtual function
281005 : // assert(LAMBDA_EXP == variant());
281006 0 : assert(LAMBDA_EXP == this->variant());
281007 0 : ROSE_ASSERT(LAMBDA_EXP == (int)(this->variantT()));
281008 0 : post_construction_initialization();
281009 :
281010 : // Test the isSgLambdaExp() function since it has been problematic
281011 0 : assert(isSgLambdaExp(this) != NULL);
281012 0 : }
281013 :
281014 : // Generated constructor (all data members)
281015 :
281016 : /* #line 281017 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281017 :
281018 :
281019 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
281020 :
281021 :
281022 : // ********************************************************
281023 : // member functions common across all array grammar objects
281024 : // ********************************************************
281025 :
281026 :
281027 :
281028 : /* #line 281029 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281029 :
281030 :
281031 :
281032 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
281033 :
281034 : // ********************************************************
281035 : // member functions specific to each node in the grammar
281036 : // ********************************************************
281037 :
281038 :
281039 : /* #line 281040 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281040 :
281041 : // Start of memberFunctionString
281042 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281043 :
281044 : void
281045 183 : SgNoexceptOp::post_construction_initialization()
281046 : {
281047 183 : }
281048 :
281049 :
281050 :
281051 : // End of memberFunctionString
281052 : // Start of memberFunctionString
281053 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
281054 :
281055 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
281056 :
281057 : SgExpression*
281058 385 : SgNoexceptOp::get_operand_expr () const
281059 : {
281060 385 : ROSE_ASSERT (this != NULL);
281061 :
281062 : #if 0
281063 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281064 : // used to trigger marking transformations for the token-based unparsing.
281065 : printf ("SgNoexceptOp::get_operand_expr = %p = %s \n",this,this->class_name().c_str());
281066 : #endif
281067 :
281068 385 : return p_operand_expr;
281069 : }
281070 :
281071 : void
281072 0 : SgNoexceptOp::set_operand_expr ( SgExpression* operand_expr )
281073 : {
281074 0 : ROSE_ASSERT (this != NULL);
281075 :
281076 : #if 0
281077 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281078 : // used to trigger marking transformations for the token-based unparsing.
281079 : printf ("SgNoexceptOp::set_operand_expr = %p = %s \n",this,this->class_name().c_str());
281080 : #endif
281081 :
281082 0 : set_isModified(true);
281083 :
281084 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
281085 : if (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr)
281086 : {
281087 : printf ("Warning: operand_expr = %p overwriting valid pointer p_operand_expr = %p \n",operand_expr,p_operand_expr);
281088 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
281089 : printf ("Error fails assertion (p_operand_expr != NULL && operand_expr != NULL && p_operand_expr != operand_expr) is false\n");
281090 : ROSE_ASSERT(false);
281091 : #endif
281092 : }
281093 : #endif
281094 0 : p_operand_expr = operand_expr;
281095 0 : }
281096 :
281097 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
281098 :
281099 :
281100 : // End of memberFunctionString
281101 : // Start of memberFunctionString
281102 : /* #line 5555 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281103 :
281104 :
281105 : // DQ (2/4/2015): Added noexcept operator as part of C++11 support.
281106 : SgType*
281107 97 : SgNoexceptOp::get_type() const
281108 : {
281109 : // DQ (2/4/2015): This function returns a bool type (evaluating if exceptions are to be supported).
281110 :
281111 97 : ROSE_ASSERT(p_operand_expr != NULL);
281112 :
281113 : #if 0
281114 : printf ("In SgNoexceptOp::get_type() \n");
281115 : #endif
281116 :
281117 97 : SgType* returnType = SgTypeBool::createType();
281118 :
281119 97 : ROSE_ASSERT(returnType != NULL);
281120 97 : return returnType;
281121 : }
281122 :
281123 : #if 0
281124 : // DQ (2/4/2015): This function was required for the SgAlignOfOp, but I don't know if it is required for the SgNoexceptOp node.
281125 : int
281126 : SgNoexceptOp::replace_expression (SgExpression *o, SgExpression *n)
281127 : {
281128 : // DQ (12/17/2006): This function should have the semantics that it will represent a
281129 : // structural change to the AST, thus it is free to set the parent of the new expression.
281130 :
281131 : ROSE_ASSERT(o != NULL);
281132 : ROSE_ASSERT(n != NULL);
281133 :
281134 : if (get_operand_expr() == o)
281135 : {
281136 : set_operand_expr(n);
281137 : return 1;
281138 : }
281139 : else
281140 : {
281141 : printf ("Warning: inside of SgAlignOfOp::replace_expression original SgExpression unidentified \n");
281142 : return 0;
281143 : }
281144 : }
281145 : #endif
281146 :
281147 :
281148 :
281149 : // End of memberFunctionString
281150 : // Start of memberFunctionString
281151 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
281152 :
281153 : // *** COMMON CODE SECTION BEGINS HERE ***
281154 :
281155 : #if 0
281156 : int
281157 : SgNoexceptOp::getVariant() const
281158 : {
281159 : // This function is used in ROSE while "variant()" is used in SAGE
281160 : assert(this != NULL);
281161 : return variant();
281162 : }
281163 : #endif
281164 :
281165 : // This function is used in ROSE in treeTraversal code
281166 : // eventually replaces getVariant() and variant()
281167 : // though after variant() has been removed for a while we will
281168 : // want to change the name of variantT() back to variant()
281169 : // (since the "T" was ment to stand for temporary).
281170 : // When this happens the variantT() will be depricated.
281171 : VariantT
281172 32678 : SgNoexceptOp::variantT() const
281173 : {
281174 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
281175 32678 : ROSE_ASSERT(this != NULL);
281176 32678 : return V_SgNoexceptOp;
281177 : }
281178 :
281179 : #if 0
281180 : int
281181 : SgNoexceptOp::variant() const
281182 : {
281183 : // This function is used in SAGE
281184 : ROSE_ASSERT(this != NULL);
281185 : return NOEXCEPT_OP;
281186 : }
281187 : #endif
281188 :
281189 : ROSE_DLL_API const char*
281190 0 : SgNoexceptOp::sage_class_name() const
281191 : {
281192 0 : ROSE_ASSERT(this != NULL);
281193 0 : return "SgNoexceptOp";
281194 : }
281195 :
281196 : std::string
281197 146 : SgNoexceptOp::class_name() const
281198 : {
281199 146 : ROSE_ASSERT(this != NULL);
281200 146 : return "SgNoexceptOp";
281201 : }
281202 :
281203 : // DQ (11/26/2005): Support for visitor pattern mechanims
281204 : // (inferior to ROSE traversal mechanism, experimental).
281205 : void
281206 2484 : SgNoexceptOp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
281207 : {
281208 2484 : ROSE_ASSERT(this != NULL);
281209 2484 : visitor.visit(this);
281210 2484 : }
281211 :
281212 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
281213 0 : void SgNoexceptOp::accept (ROSE_VisitorPattern & visitor) {
281214 0 : ROSE_ASSERT(this != NULL);
281215 0 : visitor.visit(this);
281216 0 : }
281217 :
281218 : SgNoexceptOp*
281219 0 : SgNoexceptOp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
281220 : {
281221 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
281222 : // This function is currently only supported for the AST used the represent Binary executables.
281223 : if (0 /* isSgAsmNode(this) != NULL */)
281224 : {
281225 : // Support for regex specification.
281226 : std::string prefixCode = "REGEX:";
281227 : addNewAttribute(prefixCode + s,a);
281228 : }
281229 : #endif
281230 :
281231 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
281232 0 : return this;
281233 : }
281234 :
281235 : // *** COMMON CODE SECTION ENDS HERE ***
281236 :
281237 :
281238 : // End of memberFunctionString
281239 : // Start of memberFunctionString
281240 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
281241 :
281242 :
281243 : #if 0
281244 : //! Error checking support
281245 : /*! Verifies the following:
281246 : - working getVariant() member function
281247 : - calls base class's error() member function
281248 : Every class has one of these functions.
281249 : */
281250 : bool
281251 : SgNoexceptOp::error()
281252 : {
281253 : // Put error checking here
281254 :
281255 : ROSE_ASSERT (this != NULL);
281256 : if (getVariant() != NOEXCEPT_OP)
281257 : {
281258 : printf ("Error in SgNoexceptOp::error(): SgNoexceptOp object has a %s variant \n",
281259 : Cxx_GrammarTerminalNames[getVariant()].name);
281260 : // printf ("Error in SgNoexceptOp::error() \n");
281261 : ROSE_ABORT();
281262 : }
281263 :
281264 : ROSE_ASSERT (getVariant() == NOEXCEPT_OP);
281265 : return SgExpression::error();
281266 : }
281267 : #endif
281268 :
281269 :
281270 :
281271 : // End of memberFunctionString
281272 :
281273 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
281274 :
281275 267 : SgNoexceptOp* isSgNoexceptOp ( SgNode* inputDerivedClassPointer )
281276 : {
281277 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
281278 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
281279 : // So to fix this we return NULL directly when the input is NULL and avoid the
281280 : // dynamic_cast in this case. This is likely a performance improvement as well.
281281 : // return dynamic_cast<SgNoexceptOp*>(inputDerivedClassPointer);
281282 : // Milind Chabbi (8/28/2013): isSgNoexceptOp uses table-driven castability instead of c++ default dynamic_cast
281283 : // this improves the running time performance by 10-20%.
281284 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNoexceptOp*>(inputDerivedClassPointer);
281285 267 : return IS_SgNoexceptOp_FAST_MACRO(inputDerivedClassPointer);
281286 : }
281287 :
281288 : // DQ (11/8/2003): Added version of functions taking const pointer
281289 217 : const SgNoexceptOp* isSgNoexceptOp ( const SgNode* inputDerivedClassPointer )
281290 : {
281291 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
281292 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
281293 : // So to fix this we return NULL directly when the input is NULL and avoid the
281294 : // dynamic_cast in this case. This is likely a performance improvement as well.
281295 : // return dynamic_cast<const SgNoexceptOp*>(inputDerivedClassPointer);
281296 : // Milind Chabbi (8/28/2013): isSgNoexceptOp uses table-driven castability instead of c++ default dynamic_cast
281297 : // this improves the running time performance by 10-20%.
281298 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNoexceptOp*>(inputDerivedClassPointer);
281299 217 : return IS_SgNoexceptOp_FAST_MACRO(inputDerivedClassPointer);
281300 : }
281301 :
281302 :
281303 :
281304 : /* #line 281305 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281305 :
281306 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
281307 :
281308 : /**
281309 : \brief Generated destructor
281310 :
281311 : This destructor is automatically generated (by ROSETTA). This destructor
281312 : only frees memory of data members associated with the parts of the current IR node which
281313 : are NOT traversed. Those data members that are part of a traversal can be freed using
281314 : a traversal (calling this destructor on all children in a post-order traversal). Such
281315 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
281316 :
281317 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
281318 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
281319 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
281320 :
281321 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
281322 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
281323 : pointers are not yet implemented to call delete on eash pointer in the container.
281324 : (This could be done by derivation from the STL containers to define containers that
281325 : automatically deleted their members.)
281326 :
281327 : */
281328 72 : SgNoexceptOp::~SgNoexceptOp () {
281329 36 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
281330 :
281331 :
281332 : // case: not a listType for operand_expr
281333 36 : p_operand_expr = NULL; // non list case
281334 :
281335 : }
281336 :
281337 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
281338 72 : }
281339 :
281340 :
281341 : /* #line 281342 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281342 :
281343 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
281344 :
281345 : // Generated constructor
281346 0 : SgNoexceptOp::SgNoexceptOp ( Sg_File_Info* startOfConstruct, SgExpression* operand_expr )
281347 0 : : SgExpression(startOfConstruct)
281348 : {
281349 : #ifdef DEBUG
281350 : // printf ("In SgNoexceptOp::SgNoexceptOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr) sage_class_name() = %s \n",sage_class_name());
281351 : #endif
281352 : #if 0
281353 : // debugging information!
281354 : printf ("In SgNoexceptOp::SgNoexceptOp (Sg_File_Info* startOfConstruct, SgExpression* operand_expr): this = %p = %s \n",this,this->class_name().c_str());
281355 : #endif
281356 :
281357 0 : p_operand_expr = operand_expr;
281358 :
281359 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
281360 :
281361 : #if 0
281362 : // DQ (7/30/2014): Call a virtual function.
281363 : std::string s = this->class_name();
281364 : #endif
281365 :
281366 : // Test the variant virtual function
281367 : // assert(NOEXCEPT_OP == variant());
281368 0 : assert(NOEXCEPT_OP == this->variant());
281369 0 : ROSE_ASSERT(NOEXCEPT_OP == (int)(this->variantT()));
281370 0 : post_construction_initialization();
281371 :
281372 : // Test the isSgNoexceptOp() function since it has been problematic
281373 0 : assert(isSgNoexceptOp(this) != NULL);
281374 0 : }
281375 :
281376 : // Generated constructor (all data members)
281377 :
281378 : /* #line 281379 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281379 :
281380 :
281381 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
281382 :
281383 :
281384 : // ********************************************************
281385 : // member functions common across all array grammar objects
281386 : // ********************************************************
281387 :
281388 :
281389 :
281390 : /* #line 281391 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281391 :
281392 :
281393 :
281394 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
281395 :
281396 : // ********************************************************
281397 : // member functions specific to each node in the grammar
281398 : // ********************************************************
281399 :
281400 :
281401 : /* #line 281402 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281402 :
281403 : // Start of memberFunctionString
281404 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281405 :
281406 : void
281407 16591 : SgNonrealRefExp::post_construction_initialization()
281408 : {
281409 16591 : }
281410 :
281411 :
281412 :
281413 : // End of memberFunctionString
281414 : // Start of memberFunctionString
281415 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
281416 :
281417 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
281418 :
281419 : SgNonrealSymbol*
281420 111274 : SgNonrealRefExp::get_symbol () const
281421 : {
281422 111274 : ROSE_ASSERT (this != NULL);
281423 111274 : return p_symbol;
281424 : }
281425 :
281426 : void
281427 0 : SgNonrealRefExp::set_symbol ( SgNonrealSymbol* symbol )
281428 : {
281429 0 : ROSE_ASSERT (this != NULL);
281430 :
281431 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
281432 : if (p_symbol != NULL && symbol != NULL && p_symbol != symbol)
281433 : {
281434 : printf ("Warning: symbol = %p overwriting valid pointer p_symbol = %p \n",symbol,p_symbol);
281435 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
281436 : printf ("Error fails assertion (p_symbol != NULL && symbol != NULL && p_symbol != symbol) is false\n");
281437 : ROSE_ASSERT(false);
281438 : #endif
281439 : }
281440 : #endif
281441 0 : p_symbol = symbol;
281442 0 : }
281443 :
281444 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
281445 :
281446 :
281447 : // End of memberFunctionString
281448 : // Start of memberFunctionString
281449 :
281450 :
281451 : // End of memberFunctionString
281452 : // Start of memberFunctionString
281453 : /* #line 3403 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281454 :
281455 : int
281456 0 : SgNonrealRefExp::get_name_qualification_length () const
281457 : {
281458 0 : ROSE_ASSERT (this != NULL);
281459 0 : return p_name_qualification_length;
281460 : }
281461 :
281462 : void
281463 13148 : SgNonrealRefExp::set_name_qualification_length ( int name_qualification_length )
281464 : {
281465 13148 : ROSE_ASSERT (this != NULL);
281466 13148 : p_name_qualification_length = name_qualification_length;
281467 13148 : }
281468 :
281469 : bool
281470 0 : SgNonrealRefExp::get_type_elaboration_required () const
281471 : {
281472 0 : ROSE_ASSERT (this != NULL);
281473 0 : return p_type_elaboration_required;
281474 : }
281475 :
281476 : void
281477 13148 : SgNonrealRefExp::set_type_elaboration_required ( bool type_elaboration_required )
281478 : {
281479 13148 : ROSE_ASSERT (this != NULL);
281480 13148 : p_type_elaboration_required = type_elaboration_required;
281481 13148 : }
281482 :
281483 : bool
281484 0 : SgNonrealRefExp::get_global_qualification_required () const
281485 : {
281486 0 : ROSE_ASSERT (this != NULL);
281487 0 : return p_global_qualification_required;
281488 : }
281489 :
281490 : void
281491 13148 : SgNonrealRefExp::set_global_qualification_required ( bool global_qualification_required )
281492 : {
281493 13148 : ROSE_ASSERT (this != NULL);
281494 :
281495 13148 : p_global_qualification_required = global_qualification_required;
281496 13148 : }
281497 :
281498 :
281499 : // End of memberFunctionString
281500 : // Start of memberFunctionString
281501 : /* #line 8283 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281502 :
281503 :
281504 : SgType*
281505 77815 : SgNonrealRefExp::get_type() const
281506 : {
281507 77815 : ROSE_ASSERT(this != NULL);
281508 :
281509 : #if 0
281510 : printf ("In SgNonrealRefExp::get_type() \n");
281511 : #endif
281512 :
281513 77815 : SgSymbol* symbol = this->get_symbol();
281514 77815 : if (symbol == NULL)
281515 : {
281516 0 : printf ("Error: In SgNonrealRefExp::get_type(): symbol == NULL this = %p = %s \n",this,this->class_name().c_str());
281517 : }
281518 77815 : ROSE_ASSERT(symbol != NULL);
281519 :
281520 : // DQ (9/27/2006): Added assertion
281521 : // ROSE_ASSERT(get_symbol()->get_type() != NULL);
281522 :
281523 : // printf ("In SgNonrealRefExp::get_type(): symbol = %p = %s \n",symbol,symbol->class_name().c_str());
281524 77815 : SgType* type = symbol->get_type();
281525 77815 : if (type == NULL)
281526 : {
281527 0 : printf ("Error: In SgNonrealRefExp::get_type(): type == NULL symbol = %p = %s \n",symbol,symbol->class_name().c_str());
281528 : }
281529 77815 : ROSE_ASSERT(type != NULL);
281530 :
281531 : // return get_symbol()->get_type();
281532 77815 : return type;
281533 : }
281534 :
281535 :
281536 :
281537 : // End of memberFunctionString
281538 : // Start of memberFunctionString
281539 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
281540 :
281541 : // *** COMMON CODE SECTION BEGINS HERE ***
281542 :
281543 : #if 0
281544 : int
281545 : SgNonrealRefExp::getVariant() const
281546 : {
281547 : // This function is used in ROSE while "variant()" is used in SAGE
281548 : assert(this != NULL);
281549 : return variant();
281550 : }
281551 : #endif
281552 :
281553 : // This function is used in ROSE in treeTraversal code
281554 : // eventually replaces getVariant() and variant()
281555 : // though after variant() has been removed for a while we will
281556 : // want to change the name of variantT() back to variant()
281557 : // (since the "T" was ment to stand for temporary).
281558 : // When this happens the variantT() will be depricated.
281559 : VariantT
281560 4541640 : SgNonrealRefExp::variantT() const
281561 : {
281562 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
281563 4541640 : ROSE_ASSERT(this != NULL);
281564 4541640 : return V_SgNonrealRefExp;
281565 : }
281566 :
281567 : #if 0
281568 : int
281569 : SgNonrealRefExp::variant() const
281570 : {
281571 : // This function is used in SAGE
281572 : ROSE_ASSERT(this != NULL);
281573 : return NONREAL_REF;
281574 : }
281575 : #endif
281576 :
281577 : ROSE_DLL_API const char*
281578 0 : SgNonrealRefExp::sage_class_name() const
281579 : {
281580 0 : ROSE_ASSERT(this != NULL);
281581 0 : return "SgNonrealRefExp";
281582 : }
281583 :
281584 : std::string
281585 17804 : SgNonrealRefExp::class_name() const
281586 : {
281587 17804 : ROSE_ASSERT(this != NULL);
281588 17804 : return "SgNonrealRefExp";
281589 : }
281590 :
281591 : // DQ (11/26/2005): Support for visitor pattern mechanims
281592 : // (inferior to ROSE traversal mechanism, experimental).
281593 : void
281594 219810 : SgNonrealRefExp::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
281595 : {
281596 219810 : ROSE_ASSERT(this != NULL);
281597 219810 : visitor.visit(this);
281598 219810 : }
281599 :
281600 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
281601 0 : void SgNonrealRefExp::accept (ROSE_VisitorPattern & visitor) {
281602 0 : ROSE_ASSERT(this != NULL);
281603 0 : visitor.visit(this);
281604 0 : }
281605 :
281606 : SgNonrealRefExp*
281607 0 : SgNonrealRefExp::addRegExpAttribute(std::string s, AstRegExAttribute* a)
281608 : {
281609 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
281610 : // This function is currently only supported for the AST used the represent Binary executables.
281611 : if (0 /* isSgAsmNode(this) != NULL */)
281612 : {
281613 : // Support for regex specification.
281614 : std::string prefixCode = "REGEX:";
281615 : addNewAttribute(prefixCode + s,a);
281616 : }
281617 : #endif
281618 :
281619 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
281620 0 : return this;
281621 : }
281622 :
281623 : // *** COMMON CODE SECTION ENDS HERE ***
281624 :
281625 :
281626 : // End of memberFunctionString
281627 : // Start of memberFunctionString
281628 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
281629 :
281630 :
281631 : #if 0
281632 : //! Error checking support
281633 : /*! Verifies the following:
281634 : - working getVariant() member function
281635 : - calls base class's error() member function
281636 : Every class has one of these functions.
281637 : */
281638 : bool
281639 : SgNonrealRefExp::error()
281640 : {
281641 : // Put error checking here
281642 :
281643 : ROSE_ASSERT (this != NULL);
281644 : if (getVariant() != NONREAL_REF)
281645 : {
281646 : printf ("Error in SgNonrealRefExp::error(): SgNonrealRefExp object has a %s variant \n",
281647 : Cxx_GrammarTerminalNames[getVariant()].name);
281648 : // printf ("Error in SgNonrealRefExp::error() \n");
281649 : ROSE_ABORT();
281650 : }
281651 :
281652 : ROSE_ASSERT (getVariant() == NONREAL_REF);
281653 : return SgExpression::error();
281654 : }
281655 : #endif
281656 :
281657 :
281658 :
281659 : // End of memberFunctionString
281660 :
281661 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
281662 :
281663 2831110 : SgNonrealRefExp* isSgNonrealRefExp ( SgNode* inputDerivedClassPointer )
281664 : {
281665 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
281666 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
281667 : // So to fix this we return NULL directly when the input is NULL and avoid the
281668 : // dynamic_cast in this case. This is likely a performance improvement as well.
281669 : // return dynamic_cast<SgNonrealRefExp*>(inputDerivedClassPointer);
281670 : // Milind Chabbi (8/28/2013): isSgNonrealRefExp uses table-driven castability instead of c++ default dynamic_cast
281671 : // this improves the running time performance by 10-20%.
281672 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNonrealRefExp*>(inputDerivedClassPointer);
281673 2831110 : return IS_SgNonrealRefExp_FAST_MACRO(inputDerivedClassPointer);
281674 : }
281675 :
281676 : // DQ (11/8/2003): Added version of functions taking const pointer
281677 18701 : const SgNonrealRefExp* isSgNonrealRefExp ( const SgNode* inputDerivedClassPointer )
281678 : {
281679 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
281680 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
281681 : // So to fix this we return NULL directly when the input is NULL and avoid the
281682 : // dynamic_cast in this case. This is likely a performance improvement as well.
281683 : // return dynamic_cast<const SgNonrealRefExp*>(inputDerivedClassPointer);
281684 : // Milind Chabbi (8/28/2013): isSgNonrealRefExp uses table-driven castability instead of c++ default dynamic_cast
281685 : // this improves the running time performance by 10-20%.
281686 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNonrealRefExp*>(inputDerivedClassPointer);
281687 18701 : return IS_SgNonrealRefExp_FAST_MACRO(inputDerivedClassPointer);
281688 : }
281689 :
281690 :
281691 :
281692 : /* #line 281693 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281693 :
281694 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
281695 :
281696 : /**
281697 : \brief Generated destructor
281698 :
281699 : This destructor is automatically generated (by ROSETTA). This destructor
281700 : only frees memory of data members associated with the parts of the current IR node which
281701 : are NOT traversed. Those data members that are part of a traversal can be freed using
281702 : a traversal (calling this destructor on all children in a post-order traversal). Such
281703 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
281704 :
281705 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
281706 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
281707 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
281708 :
281709 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
281710 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
281711 : pointers are not yet implemented to call delete on eash pointer in the container.
281712 : (This could be done by derivation from the STL containers to define containers that
281713 : automatically deleted their members.)
281714 :
281715 : */
281716 7168 : SgNonrealRefExp::~SgNonrealRefExp () {
281717 3584 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
281718 :
281719 :
281720 : // case: not a listType for symbol
281721 3584 : p_symbol = NULL; // non list case
281722 : // case: not a listType for name_qualification_length
281723 3584 : p_name_qualification_length = 0; // non list case
281724 : // case: not a listType for type_elaboration_required
281725 3584 : p_type_elaboration_required = false; // non list case
281726 : // case: not a listType for global_qualification_required
281727 3584 : p_global_qualification_required = false; // non list case
281728 :
281729 : }
281730 :
281731 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
281732 7168 : }
281733 :
281734 :
281735 : /* #line 281736 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281736 :
281737 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
281738 :
281739 : // Generated constructor
281740 406 : SgNonrealRefExp::SgNonrealRefExp ( Sg_File_Info* startOfConstruct, SgNonrealSymbol* symbol )
281741 406 : : SgExpression(startOfConstruct)
281742 : {
281743 : #ifdef DEBUG
281744 : // printf ("In SgNonrealRefExp::SgNonrealRefExp (Sg_File_Info* startOfConstruct, SgNonrealSymbol* symbol) sage_class_name() = %s \n",sage_class_name());
281745 : #endif
281746 : #if 0
281747 : // debugging information!
281748 : printf ("In SgNonrealRefExp::SgNonrealRefExp (Sg_File_Info* startOfConstruct, SgNonrealSymbol* symbol): this = %p = %s \n",this,this->class_name().c_str());
281749 : #endif
281750 :
281751 406 : p_symbol = symbol;
281752 406 : p_name_qualification_length = 0;
281753 406 : p_type_elaboration_required = false;
281754 406 : p_global_qualification_required = false;
281755 :
281756 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
281757 :
281758 : #if 0
281759 : // DQ (7/30/2014): Call a virtual function.
281760 : std::string s = this->class_name();
281761 : #endif
281762 :
281763 : // Test the variant virtual function
281764 : // assert(NONREAL_REF == variant());
281765 406 : assert(NONREAL_REF == this->variant());
281766 406 : ROSE_ASSERT(NONREAL_REF == (int)(this->variantT()));
281767 406 : post_construction_initialization();
281768 :
281769 : // Test the isSgNonrealRefExp() function since it has been problematic
281770 406 : assert(isSgNonrealRefExp(this) != NULL);
281771 406 : }
281772 :
281773 : // Generated constructor (all data members)
281774 :
281775 : /* #line 281776 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281776 :
281777 :
281778 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
281779 :
281780 :
281781 : // ********************************************************
281782 : // member functions common across all array grammar objects
281783 : // ********************************************************
281784 :
281785 :
281786 :
281787 : /* #line 281788 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281788 :
281789 :
281790 :
281791 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
281792 :
281793 : // ********************************************************
281794 : // member functions specific to each node in the grammar
281795 : // ********************************************************
281796 :
281797 :
281798 : /* #line 281799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
281799 :
281800 : // Start of memberFunctionString
281801 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281802 :
281803 : void
281804 0 : SgFoldExpression::post_construction_initialization()
281805 : {
281806 0 : }
281807 :
281808 :
281809 :
281810 : // End of memberFunctionString
281811 : // Start of memberFunctionString
281812 : /* #line 4479 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281813 :
281814 :
281815 :
281816 : // End of memberFunctionString
281817 : // Start of memberFunctionString
281818 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
281819 :
281820 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
281821 :
281822 : SgExpression*
281823 0 : SgFoldExpression::get_operands () const
281824 : {
281825 0 : ROSE_ASSERT (this != NULL);
281826 :
281827 : #if 0
281828 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281829 : // used to trigger marking transformations for the token-based unparsing.
281830 : printf ("SgFoldExpression::get_operands = %p = %s \n",this,this->class_name().c_str());
281831 : #endif
281832 :
281833 0 : return p_operands;
281834 : }
281835 :
281836 : void
281837 0 : SgFoldExpression::set_operands ( SgExpression* operands )
281838 : {
281839 0 : ROSE_ASSERT (this != NULL);
281840 :
281841 : #if 0
281842 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281843 : // used to trigger marking transformations for the token-based unparsing.
281844 : printf ("SgFoldExpression::set_operands = %p = %s \n",this,this->class_name().c_str());
281845 : #endif
281846 :
281847 0 : set_isModified(true);
281848 :
281849 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
281850 : if (p_operands != NULL && operands != NULL && p_operands != operands)
281851 : {
281852 : printf ("Warning: operands = %p overwriting valid pointer p_operands = %p \n",operands,p_operands);
281853 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
281854 : printf ("Error fails assertion (p_operands != NULL && operands != NULL && p_operands != operands) is false\n");
281855 : ROSE_ASSERT(false);
281856 : #endif
281857 : }
281858 : #endif
281859 0 : p_operands = operands;
281860 0 : }
281861 :
281862 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
281863 :
281864 :
281865 : // End of memberFunctionString
281866 : // Start of memberFunctionString
281867 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
281868 :
281869 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
281870 :
281871 : std::string
281872 0 : SgFoldExpression::get_operator_token () const
281873 : {
281874 0 : ROSE_ASSERT (this != NULL);
281875 :
281876 : #if 0
281877 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281878 : // used to trigger marking transformations for the token-based unparsing.
281879 : printf ("SgFoldExpression::get_operator_token = %p = %s \n",this,this->class_name().c_str());
281880 : #endif
281881 :
281882 0 : return p_operator_token;
281883 : }
281884 :
281885 : void
281886 0 : SgFoldExpression::set_operator_token ( std::string operator_token )
281887 : {
281888 0 : ROSE_ASSERT (this != NULL);
281889 :
281890 : #if 0
281891 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281892 : // used to trigger marking transformations for the token-based unparsing.
281893 : printf ("SgFoldExpression::set_operator_token = %p = %s \n",this,this->class_name().c_str());
281894 : #endif
281895 :
281896 0 : set_isModified(true);
281897 :
281898 0 : p_operator_token = operator_token;
281899 0 : }
281900 :
281901 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
281902 :
281903 :
281904 : // End of memberFunctionString
281905 : // Start of memberFunctionString
281906 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
281907 :
281908 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
281909 :
281910 : bool
281911 0 : SgFoldExpression::get_is_left_associative () const
281912 : {
281913 0 : ROSE_ASSERT (this != NULL);
281914 :
281915 : #if 0
281916 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281917 : // used to trigger marking transformations for the token-based unparsing.
281918 : printf ("SgFoldExpression::get_is_left_associative = %p = %s \n",this,this->class_name().c_str());
281919 : #endif
281920 :
281921 0 : return p_is_left_associative;
281922 : }
281923 :
281924 : void
281925 0 : SgFoldExpression::set_is_left_associative ( bool is_left_associative )
281926 : {
281927 0 : ROSE_ASSERT (this != NULL);
281928 :
281929 : #if 0
281930 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
281931 : // used to trigger marking transformations for the token-based unparsing.
281932 : printf ("SgFoldExpression::set_is_left_associative = %p = %s \n",this,this->class_name().c_str());
281933 : #endif
281934 :
281935 0 : set_isModified(true);
281936 :
281937 0 : p_is_left_associative = is_left_associative;
281938 0 : }
281939 :
281940 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
281941 :
281942 :
281943 : // End of memberFunctionString
281944 : // Start of memberFunctionString
281945 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
281946 :
281947 : SgType*
281948 :
281949 0 : SgFoldExpression::get_type() const
281950 : {
281951 0 : ROSE_ASSERT(this != NULL);
281952 :
281953 : #if 0
281954 : printf ("In SgFoldExpression::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
281955 : #endif
281956 :
281957 : // DQ (10/31/2016): Debugging...
281958 : // return SgTypeDefault::createType();
281959 0 : SgType* returnType = SgTypeDefault::createType();
281960 :
281961 : #if 0
281962 : printf ("Leaving SgFoldExpression::get_type() (default_get_type) returnType = %p \n",returnType);
281963 : #endif
281964 :
281965 0 : return returnType;
281966 : }
281967 :
281968 :
281969 :
281970 : // End of memberFunctionString
281971 : // Start of memberFunctionString
281972 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
281973 :
281974 : // *** COMMON CODE SECTION BEGINS HERE ***
281975 :
281976 : #if 0
281977 : int
281978 : SgFoldExpression::getVariant() const
281979 : {
281980 : // This function is used in ROSE while "variant()" is used in SAGE
281981 : assert(this != NULL);
281982 : return variant();
281983 : }
281984 : #endif
281985 :
281986 : // This function is used in ROSE in treeTraversal code
281987 : // eventually replaces getVariant() and variant()
281988 : // though after variant() has been removed for a while we will
281989 : // want to change the name of variantT() back to variant()
281990 : // (since the "T" was ment to stand for temporary).
281991 : // When this happens the variantT() will be depricated.
281992 : VariantT
281993 0 : SgFoldExpression::variantT() const
281994 : {
281995 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
281996 0 : ROSE_ASSERT(this != NULL);
281997 0 : return V_SgFoldExpression;
281998 : }
281999 :
282000 : #if 0
282001 : int
282002 : SgFoldExpression::variant() const
282003 : {
282004 : // This function is used in SAGE
282005 : ROSE_ASSERT(this != NULL);
282006 : return FOLD_EXPR;
282007 : }
282008 : #endif
282009 :
282010 : ROSE_DLL_API const char*
282011 0 : SgFoldExpression::sage_class_name() const
282012 : {
282013 0 : ROSE_ASSERT(this != NULL);
282014 0 : return "SgFoldExpression";
282015 : }
282016 :
282017 : std::string
282018 0 : SgFoldExpression::class_name() const
282019 : {
282020 0 : ROSE_ASSERT(this != NULL);
282021 0 : return "SgFoldExpression";
282022 : }
282023 :
282024 : // DQ (11/26/2005): Support for visitor pattern mechanims
282025 : // (inferior to ROSE traversal mechanism, experimental).
282026 : void
282027 0 : SgFoldExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
282028 : {
282029 0 : ROSE_ASSERT(this != NULL);
282030 0 : visitor.visit(this);
282031 0 : }
282032 :
282033 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
282034 0 : void SgFoldExpression::accept (ROSE_VisitorPattern & visitor) {
282035 0 : ROSE_ASSERT(this != NULL);
282036 0 : visitor.visit(this);
282037 0 : }
282038 :
282039 : SgFoldExpression*
282040 0 : SgFoldExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
282041 : {
282042 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
282043 : // This function is currently only supported for the AST used the represent Binary executables.
282044 : if (0 /* isSgAsmNode(this) != NULL */)
282045 : {
282046 : // Support for regex specification.
282047 : std::string prefixCode = "REGEX:";
282048 : addNewAttribute(prefixCode + s,a);
282049 : }
282050 : #endif
282051 :
282052 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
282053 0 : return this;
282054 : }
282055 :
282056 : // *** COMMON CODE SECTION ENDS HERE ***
282057 :
282058 :
282059 : // End of memberFunctionString
282060 : // Start of memberFunctionString
282061 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
282062 :
282063 :
282064 : #if 0
282065 : //! Error checking support
282066 : /*! Verifies the following:
282067 : - working getVariant() member function
282068 : - calls base class's error() member function
282069 : Every class has one of these functions.
282070 : */
282071 : bool
282072 : SgFoldExpression::error()
282073 : {
282074 : // Put error checking here
282075 :
282076 : ROSE_ASSERT (this != NULL);
282077 : if (getVariant() != FOLD_EXPR)
282078 : {
282079 : printf ("Error in SgFoldExpression::error(): SgFoldExpression object has a %s variant \n",
282080 : Cxx_GrammarTerminalNames[getVariant()].name);
282081 : // printf ("Error in SgFoldExpression::error() \n");
282082 : ROSE_ABORT();
282083 : }
282084 :
282085 : ROSE_ASSERT (getVariant() == FOLD_EXPR);
282086 : return SgExpression::error();
282087 : }
282088 : #endif
282089 :
282090 :
282091 :
282092 : // End of memberFunctionString
282093 :
282094 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
282095 :
282096 0 : SgFoldExpression* isSgFoldExpression ( SgNode* inputDerivedClassPointer )
282097 : {
282098 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
282099 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
282100 : // So to fix this we return NULL directly when the input is NULL and avoid the
282101 : // dynamic_cast in this case. This is likely a performance improvement as well.
282102 : // return dynamic_cast<SgFoldExpression*>(inputDerivedClassPointer);
282103 : // Milind Chabbi (8/28/2013): isSgFoldExpression uses table-driven castability instead of c++ default dynamic_cast
282104 : // this improves the running time performance by 10-20%.
282105 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFoldExpression*>(inputDerivedClassPointer);
282106 0 : return IS_SgFoldExpression_FAST_MACRO(inputDerivedClassPointer);
282107 : }
282108 :
282109 : // DQ (11/8/2003): Added version of functions taking const pointer
282110 0 : const SgFoldExpression* isSgFoldExpression ( const SgNode* inputDerivedClassPointer )
282111 : {
282112 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
282113 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
282114 : // So to fix this we return NULL directly when the input is NULL and avoid the
282115 : // dynamic_cast in this case. This is likely a performance improvement as well.
282116 : // return dynamic_cast<const SgFoldExpression*>(inputDerivedClassPointer);
282117 : // Milind Chabbi (8/28/2013): isSgFoldExpression uses table-driven castability instead of c++ default dynamic_cast
282118 : // this improves the running time performance by 10-20%.
282119 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFoldExpression*>(inputDerivedClassPointer);
282120 0 : return IS_SgFoldExpression_FAST_MACRO(inputDerivedClassPointer);
282121 : }
282122 :
282123 :
282124 :
282125 : /* #line 282126 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282126 :
282127 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
282128 :
282129 : /**
282130 : \brief Generated destructor
282131 :
282132 : This destructor is automatically generated (by ROSETTA). This destructor
282133 : only frees memory of data members associated with the parts of the current IR node which
282134 : are NOT traversed. Those data members that are part of a traversal can be freed using
282135 : a traversal (calling this destructor on all children in a post-order traversal). Such
282136 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
282137 :
282138 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
282139 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
282140 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
282141 :
282142 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
282143 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
282144 : pointers are not yet implemented to call delete on eash pointer in the container.
282145 : (This could be done by derivation from the STL containers to define containers that
282146 : automatically deleted their members.)
282147 :
282148 : */
282149 0 : SgFoldExpression::~SgFoldExpression () {
282150 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
282151 :
282152 :
282153 : // case: not a listType for operands
282154 0 : p_operands = NULL; // non list case
282155 : // case: not a listType for operator_token
282156 0 : p_operator_token = ""; // non list case
282157 : // case: not a listType for is_left_associative
282158 0 : p_is_left_associative = false; // non list case
282159 :
282160 : }
282161 :
282162 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
282163 0 : }
282164 :
282165 :
282166 : /* #line 282167 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282167 :
282168 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
282169 :
282170 : // Generated constructor
282171 0 : SgFoldExpression::SgFoldExpression ( Sg_File_Info* startOfConstruct, SgExpression* operands, std::string operator_token, bool is_left_associative )
282172 0 : : SgExpression(startOfConstruct)
282173 : {
282174 : #ifdef DEBUG
282175 : // printf ("In SgFoldExpression::SgFoldExpression (Sg_File_Info* startOfConstruct, SgExpression* operands, std::string operator_token, bool is_left_associative) sage_class_name() = %s \n",sage_class_name());
282176 : #endif
282177 : #if 0
282178 : // debugging information!
282179 : printf ("In SgFoldExpression::SgFoldExpression (Sg_File_Info* startOfConstruct, SgExpression* operands, std::string operator_token, bool is_left_associative): this = %p = %s \n",this,this->class_name().c_str());
282180 : #endif
282181 :
282182 0 : p_operands = operands;
282183 0 : p_operator_token = operator_token;
282184 0 : p_is_left_associative = is_left_associative;
282185 :
282186 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
282187 :
282188 : #if 0
282189 : // DQ (7/30/2014): Call a virtual function.
282190 : std::string s = this->class_name();
282191 : #endif
282192 :
282193 : // Test the variant virtual function
282194 : // assert(FOLD_EXPR == variant());
282195 0 : assert(FOLD_EXPR == this->variant());
282196 0 : ROSE_ASSERT(FOLD_EXPR == (int)(this->variantT()));
282197 0 : post_construction_initialization();
282198 :
282199 : // Test the isSgFoldExpression() function since it has been problematic
282200 0 : assert(isSgFoldExpression(this) != NULL);
282201 0 : }
282202 :
282203 : // Generated constructor (all data members)
282204 :
282205 : /* #line 282206 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282206 :
282207 :
282208 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
282209 :
282210 :
282211 : // ********************************************************
282212 : // member functions common across all array grammar objects
282213 : // ********************************************************
282214 :
282215 :
282216 :
282217 : /* #line 282218 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282218 :
282219 :
282220 :
282221 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
282222 :
282223 : // ********************************************************
282224 : // member functions specific to each node in the grammar
282225 : // ********************************************************
282226 :
282227 :
282228 : /* #line 282229 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282229 :
282230 : // Start of memberFunctionString
282231 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
282232 :
282233 : void
282234 0 : SgAwaitExpression::post_construction_initialization()
282235 : {
282236 0 : }
282237 :
282238 :
282239 :
282240 : // End of memberFunctionString
282241 : // Start of memberFunctionString
282242 : /* #line 4474 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
282243 :
282244 :
282245 :
282246 : // End of memberFunctionString
282247 : // Start of memberFunctionString
282248 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
282249 :
282250 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
282251 :
282252 : SgExpression*
282253 0 : SgAwaitExpression::get_value () const
282254 : {
282255 0 : ROSE_ASSERT (this != NULL);
282256 :
282257 : #if 0
282258 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
282259 : // used to trigger marking transformations for the token-based unparsing.
282260 : printf ("SgAwaitExpression::get_value = %p = %s \n",this,this->class_name().c_str());
282261 : #endif
282262 :
282263 0 : return p_value;
282264 : }
282265 :
282266 : void
282267 0 : SgAwaitExpression::set_value ( SgExpression* value )
282268 : {
282269 0 : ROSE_ASSERT (this != NULL);
282270 :
282271 : #if 0
282272 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
282273 : // used to trigger marking transformations for the token-based unparsing.
282274 : printf ("SgAwaitExpression::set_value = %p = %s \n",this,this->class_name().c_str());
282275 : #endif
282276 :
282277 0 : set_isModified(true);
282278 :
282279 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
282280 : if (p_value != NULL && value != NULL && p_value != value)
282281 : {
282282 : printf ("Warning: value = %p overwriting valid pointer p_value = %p \n",value,p_value);
282283 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
282284 : printf ("Error fails assertion (p_value != NULL && value != NULL && p_value != value) is false\n");
282285 : ROSE_ASSERT(false);
282286 : #endif
282287 : }
282288 : #endif
282289 0 : p_value = value;
282290 0 : }
282291 :
282292 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
282293 :
282294 :
282295 : // End of memberFunctionString
282296 : // Start of memberFunctionString
282297 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
282298 :
282299 : SgType*
282300 :
282301 0 : SgAwaitExpression::get_type() const
282302 : {
282303 0 : ROSE_ASSERT(this != NULL);
282304 :
282305 : #if 0
282306 : printf ("In SgAwaitExpression::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
282307 : #endif
282308 :
282309 : // DQ (10/31/2016): Debugging...
282310 : // return SgTypeDefault::createType();
282311 0 : SgType* returnType = SgTypeDefault::createType();
282312 :
282313 : #if 0
282314 : printf ("Leaving SgAwaitExpression::get_type() (default_get_type) returnType = %p \n",returnType);
282315 : #endif
282316 :
282317 0 : return returnType;
282318 : }
282319 :
282320 :
282321 :
282322 : // End of memberFunctionString
282323 : // Start of memberFunctionString
282324 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
282325 :
282326 : // *** COMMON CODE SECTION BEGINS HERE ***
282327 :
282328 : #if 0
282329 : int
282330 : SgAwaitExpression::getVariant() const
282331 : {
282332 : // This function is used in ROSE while "variant()" is used in SAGE
282333 : assert(this != NULL);
282334 : return variant();
282335 : }
282336 : #endif
282337 :
282338 : // This function is used in ROSE in treeTraversal code
282339 : // eventually replaces getVariant() and variant()
282340 : // though after variant() has been removed for a while we will
282341 : // want to change the name of variantT() back to variant()
282342 : // (since the "T" was ment to stand for temporary).
282343 : // When this happens the variantT() will be depricated.
282344 : VariantT
282345 0 : SgAwaitExpression::variantT() const
282346 : {
282347 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
282348 0 : ROSE_ASSERT(this != NULL);
282349 0 : return V_SgAwaitExpression;
282350 : }
282351 :
282352 : #if 0
282353 : int
282354 : SgAwaitExpression::variant() const
282355 : {
282356 : // This function is used in SAGE
282357 : ROSE_ASSERT(this != NULL);
282358 : return AWAIT_EXPR;
282359 : }
282360 : #endif
282361 :
282362 : ROSE_DLL_API const char*
282363 0 : SgAwaitExpression::sage_class_name() const
282364 : {
282365 0 : ROSE_ASSERT(this != NULL);
282366 0 : return "SgAwaitExpression";
282367 : }
282368 :
282369 : std::string
282370 0 : SgAwaitExpression::class_name() const
282371 : {
282372 0 : ROSE_ASSERT(this != NULL);
282373 0 : return "SgAwaitExpression";
282374 : }
282375 :
282376 : // DQ (11/26/2005): Support for visitor pattern mechanims
282377 : // (inferior to ROSE traversal mechanism, experimental).
282378 : void
282379 0 : SgAwaitExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
282380 : {
282381 0 : ROSE_ASSERT(this != NULL);
282382 0 : visitor.visit(this);
282383 0 : }
282384 :
282385 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
282386 0 : void SgAwaitExpression::accept (ROSE_VisitorPattern & visitor) {
282387 0 : ROSE_ASSERT(this != NULL);
282388 0 : visitor.visit(this);
282389 0 : }
282390 :
282391 : SgAwaitExpression*
282392 0 : SgAwaitExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
282393 : {
282394 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
282395 : // This function is currently only supported for the AST used the represent Binary executables.
282396 : if (0 /* isSgAsmNode(this) != NULL */)
282397 : {
282398 : // Support for regex specification.
282399 : std::string prefixCode = "REGEX:";
282400 : addNewAttribute(prefixCode + s,a);
282401 : }
282402 : #endif
282403 :
282404 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
282405 0 : return this;
282406 : }
282407 :
282408 : // *** COMMON CODE SECTION ENDS HERE ***
282409 :
282410 :
282411 : // End of memberFunctionString
282412 : // Start of memberFunctionString
282413 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
282414 :
282415 :
282416 : #if 0
282417 : //! Error checking support
282418 : /*! Verifies the following:
282419 : - working getVariant() member function
282420 : - calls base class's error() member function
282421 : Every class has one of these functions.
282422 : */
282423 : bool
282424 : SgAwaitExpression::error()
282425 : {
282426 : // Put error checking here
282427 :
282428 : ROSE_ASSERT (this != NULL);
282429 : if (getVariant() != AWAIT_EXPR)
282430 : {
282431 : printf ("Error in SgAwaitExpression::error(): SgAwaitExpression object has a %s variant \n",
282432 : Cxx_GrammarTerminalNames[getVariant()].name);
282433 : // printf ("Error in SgAwaitExpression::error() \n");
282434 : ROSE_ABORT();
282435 : }
282436 :
282437 : ROSE_ASSERT (getVariant() == AWAIT_EXPR);
282438 : return SgExpression::error();
282439 : }
282440 : #endif
282441 :
282442 :
282443 :
282444 : // End of memberFunctionString
282445 :
282446 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
282447 :
282448 0 : SgAwaitExpression* isSgAwaitExpression ( SgNode* inputDerivedClassPointer )
282449 : {
282450 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
282451 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
282452 : // So to fix this we return NULL directly when the input is NULL and avoid the
282453 : // dynamic_cast in this case. This is likely a performance improvement as well.
282454 : // return dynamic_cast<SgAwaitExpression*>(inputDerivedClassPointer);
282455 : // Milind Chabbi (8/28/2013): isSgAwaitExpression uses table-driven castability instead of c++ default dynamic_cast
282456 : // this improves the running time performance by 10-20%.
282457 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAwaitExpression*>(inputDerivedClassPointer);
282458 0 : return IS_SgAwaitExpression_FAST_MACRO(inputDerivedClassPointer);
282459 : }
282460 :
282461 : // DQ (11/8/2003): Added version of functions taking const pointer
282462 0 : const SgAwaitExpression* isSgAwaitExpression ( const SgNode* inputDerivedClassPointer )
282463 : {
282464 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
282465 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
282466 : // So to fix this we return NULL directly when the input is NULL and avoid the
282467 : // dynamic_cast in this case. This is likely a performance improvement as well.
282468 : // return dynamic_cast<const SgAwaitExpression*>(inputDerivedClassPointer);
282469 : // Milind Chabbi (8/28/2013): isSgAwaitExpression uses table-driven castability instead of c++ default dynamic_cast
282470 : // this improves the running time performance by 10-20%.
282471 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAwaitExpression*>(inputDerivedClassPointer);
282472 0 : return IS_SgAwaitExpression_FAST_MACRO(inputDerivedClassPointer);
282473 : }
282474 :
282475 :
282476 :
282477 : /* #line 282478 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282478 :
282479 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
282480 :
282481 : /**
282482 : \brief Generated destructor
282483 :
282484 : This destructor is automatically generated (by ROSETTA). This destructor
282485 : only frees memory of data members associated with the parts of the current IR node which
282486 : are NOT traversed. Those data members that are part of a traversal can be freed using
282487 : a traversal (calling this destructor on all children in a post-order traversal). Such
282488 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
282489 :
282490 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
282491 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
282492 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
282493 :
282494 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
282495 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
282496 : pointers are not yet implemented to call delete on eash pointer in the container.
282497 : (This could be done by derivation from the STL containers to define containers that
282498 : automatically deleted their members.)
282499 :
282500 : */
282501 0 : SgAwaitExpression::~SgAwaitExpression () {
282502 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
282503 :
282504 :
282505 : // case: not a listType for value
282506 0 : p_value = NULL; // non list case
282507 :
282508 : }
282509 :
282510 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
282511 0 : }
282512 :
282513 :
282514 : /* #line 282515 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282515 :
282516 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
282517 :
282518 : // Generated constructor
282519 0 : SgAwaitExpression::SgAwaitExpression ( Sg_File_Info* startOfConstruct, SgExpression* value )
282520 0 : : SgExpression(startOfConstruct)
282521 : {
282522 : #ifdef DEBUG
282523 : // printf ("In SgAwaitExpression::SgAwaitExpression (Sg_File_Info* startOfConstruct, SgExpression* value) sage_class_name() = %s \n",sage_class_name());
282524 : #endif
282525 : #if 0
282526 : // debugging information!
282527 : printf ("In SgAwaitExpression::SgAwaitExpression (Sg_File_Info* startOfConstruct, SgExpression* value): this = %p = %s \n",this,this->class_name().c_str());
282528 : #endif
282529 :
282530 0 : p_value = value;
282531 :
282532 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
282533 :
282534 : #if 0
282535 : // DQ (7/30/2014): Call a virtual function.
282536 : std::string s = this->class_name();
282537 : #endif
282538 :
282539 : // Test the variant virtual function
282540 : // assert(AWAIT_EXPR == variant());
282541 0 : assert(AWAIT_EXPR == this->variant());
282542 0 : ROSE_ASSERT(AWAIT_EXPR == (int)(this->variantT()));
282543 0 : post_construction_initialization();
282544 :
282545 : // Test the isSgAwaitExpression() function since it has been problematic
282546 0 : assert(isSgAwaitExpression(this) != NULL);
282547 0 : }
282548 :
282549 : // Generated constructor (all data members)
282550 :
282551 : /* #line 282552 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282552 :
282553 :
282554 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
282555 :
282556 :
282557 : // ********************************************************
282558 : // member functions common across all array grammar objects
282559 : // ********************************************************
282560 :
282561 :
282562 :
282563 : /* #line 282564 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282564 :
282565 :
282566 :
282567 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
282568 :
282569 : // ********************************************************
282570 : // member functions specific to each node in the grammar
282571 : // ********************************************************
282572 :
282573 :
282574 : /* #line 282575 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282575 :
282576 : // Start of memberFunctionString
282577 : /* #line 8022 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
282578 :
282579 : void
282580 0 : SgChooseExpression::post_construction_initialization()
282581 : {
282582 0 : }
282583 :
282584 :
282585 :
282586 : // End of memberFunctionString
282587 : // Start of memberFunctionString
282588 : /* #line 4484 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
282589 :
282590 :
282591 :
282592 : // End of memberFunctionString
282593 : // Start of memberFunctionString
282594 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
282595 :
282596 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
282597 :
282598 : SgExpression*
282599 0 : SgChooseExpression::get_value () const
282600 : {
282601 0 : ROSE_ASSERT (this != NULL);
282602 :
282603 : #if 0
282604 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
282605 : // used to trigger marking transformations for the token-based unparsing.
282606 : printf ("SgChooseExpression::get_value = %p = %s \n",this,this->class_name().c_str());
282607 : #endif
282608 :
282609 0 : return p_value;
282610 : }
282611 :
282612 : void
282613 0 : SgChooseExpression::set_value ( SgExpression* value )
282614 : {
282615 0 : ROSE_ASSERT (this != NULL);
282616 :
282617 : #if 0
282618 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
282619 : // used to trigger marking transformations for the token-based unparsing.
282620 : printf ("SgChooseExpression::set_value = %p = %s \n",this,this->class_name().c_str());
282621 : #endif
282622 :
282623 0 : set_isModified(true);
282624 :
282625 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
282626 : if (p_value != NULL && value != NULL && p_value != value)
282627 : {
282628 : printf ("Warning: value = %p overwriting valid pointer p_value = %p \n",value,p_value);
282629 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
282630 : printf ("Error fails assertion (p_value != NULL && value != NULL && p_value != value) is false\n");
282631 : ROSE_ASSERT(false);
282632 : #endif
282633 : }
282634 : #endif
282635 0 : p_value = value;
282636 0 : }
282637 :
282638 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
282639 :
282640 :
282641 : // End of memberFunctionString
282642 : // Start of memberFunctionString
282643 : /* #line 8258 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Expression.code" */
282644 :
282645 : SgType*
282646 :
282647 0 : SgChooseExpression::get_type() const
282648 : {
282649 0 : ROSE_ASSERT(this != NULL);
282650 :
282651 : #if 0
282652 : printf ("In SgChooseExpression::get_type() (default_get_type) calling SgTypeDefault::createType() \n");
282653 : #endif
282654 :
282655 : // DQ (10/31/2016): Debugging...
282656 : // return SgTypeDefault::createType();
282657 0 : SgType* returnType = SgTypeDefault::createType();
282658 :
282659 : #if 0
282660 : printf ("Leaving SgChooseExpression::get_type() (default_get_type) returnType = %p \n",returnType);
282661 : #endif
282662 :
282663 0 : return returnType;
282664 : }
282665 :
282666 :
282667 :
282668 : // End of memberFunctionString
282669 : // Start of memberFunctionString
282670 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
282671 :
282672 : // *** COMMON CODE SECTION BEGINS HERE ***
282673 :
282674 : #if 0
282675 : int
282676 : SgChooseExpression::getVariant() const
282677 : {
282678 : // This function is used in ROSE while "variant()" is used in SAGE
282679 : assert(this != NULL);
282680 : return variant();
282681 : }
282682 : #endif
282683 :
282684 : // This function is used in ROSE in treeTraversal code
282685 : // eventually replaces getVariant() and variant()
282686 : // though after variant() has been removed for a while we will
282687 : // want to change the name of variantT() back to variant()
282688 : // (since the "T" was ment to stand for temporary).
282689 : // When this happens the variantT() will be depricated.
282690 : VariantT
282691 0 : SgChooseExpression::variantT() const
282692 : {
282693 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
282694 0 : ROSE_ASSERT(this != NULL);
282695 0 : return V_SgChooseExpression;
282696 : }
282697 :
282698 : #if 0
282699 : int
282700 : SgChooseExpression::variant() const
282701 : {
282702 : // This function is used in SAGE
282703 : ROSE_ASSERT(this != NULL);
282704 : return CHOOSE_EXPR;
282705 : }
282706 : #endif
282707 :
282708 : ROSE_DLL_API const char*
282709 0 : SgChooseExpression::sage_class_name() const
282710 : {
282711 0 : ROSE_ASSERT(this != NULL);
282712 0 : return "SgChooseExpression";
282713 : }
282714 :
282715 : std::string
282716 0 : SgChooseExpression::class_name() const
282717 : {
282718 0 : ROSE_ASSERT(this != NULL);
282719 0 : return "SgChooseExpression";
282720 : }
282721 :
282722 : // DQ (11/26/2005): Support for visitor pattern mechanims
282723 : // (inferior to ROSE traversal mechanism, experimental).
282724 : void
282725 0 : SgChooseExpression::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
282726 : {
282727 0 : ROSE_ASSERT(this != NULL);
282728 0 : visitor.visit(this);
282729 0 : }
282730 :
282731 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
282732 0 : void SgChooseExpression::accept (ROSE_VisitorPattern & visitor) {
282733 0 : ROSE_ASSERT(this != NULL);
282734 0 : visitor.visit(this);
282735 0 : }
282736 :
282737 : SgChooseExpression*
282738 0 : SgChooseExpression::addRegExpAttribute(std::string s, AstRegExAttribute* a)
282739 : {
282740 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
282741 : // This function is currently only supported for the AST used the represent Binary executables.
282742 : if (0 /* isSgAsmNode(this) != NULL */)
282743 : {
282744 : // Support for regex specification.
282745 : std::string prefixCode = "REGEX:";
282746 : addNewAttribute(prefixCode + s,a);
282747 : }
282748 : #endif
282749 :
282750 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
282751 0 : return this;
282752 : }
282753 :
282754 : // *** COMMON CODE SECTION ENDS HERE ***
282755 :
282756 :
282757 : // End of memberFunctionString
282758 : // Start of memberFunctionString
282759 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
282760 :
282761 :
282762 : #if 0
282763 : //! Error checking support
282764 : /*! Verifies the following:
282765 : - working getVariant() member function
282766 : - calls base class's error() member function
282767 : Every class has one of these functions.
282768 : */
282769 : bool
282770 : SgChooseExpression::error()
282771 : {
282772 : // Put error checking here
282773 :
282774 : ROSE_ASSERT (this != NULL);
282775 : if (getVariant() != CHOOSE_EXPR)
282776 : {
282777 : printf ("Error in SgChooseExpression::error(): SgChooseExpression object has a %s variant \n",
282778 : Cxx_GrammarTerminalNames[getVariant()].name);
282779 : // printf ("Error in SgChooseExpression::error() \n");
282780 : ROSE_ABORT();
282781 : }
282782 :
282783 : ROSE_ASSERT (getVariant() == CHOOSE_EXPR);
282784 : return SgExpression::error();
282785 : }
282786 : #endif
282787 :
282788 :
282789 :
282790 : // End of memberFunctionString
282791 :
282792 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
282793 :
282794 0 : SgChooseExpression* isSgChooseExpression ( SgNode* inputDerivedClassPointer )
282795 : {
282796 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
282797 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
282798 : // So to fix this we return NULL directly when the input is NULL and avoid the
282799 : // dynamic_cast in this case. This is likely a performance improvement as well.
282800 : // return dynamic_cast<SgChooseExpression*>(inputDerivedClassPointer);
282801 : // Milind Chabbi (8/28/2013): isSgChooseExpression uses table-driven castability instead of c++ default dynamic_cast
282802 : // this improves the running time performance by 10-20%.
282803 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgChooseExpression*>(inputDerivedClassPointer);
282804 0 : return IS_SgChooseExpression_FAST_MACRO(inputDerivedClassPointer);
282805 : }
282806 :
282807 : // DQ (11/8/2003): Added version of functions taking const pointer
282808 0 : const SgChooseExpression* isSgChooseExpression ( const SgNode* inputDerivedClassPointer )
282809 : {
282810 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
282811 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
282812 : // So to fix this we return NULL directly when the input is NULL and avoid the
282813 : // dynamic_cast in this case. This is likely a performance improvement as well.
282814 : // return dynamic_cast<const SgChooseExpression*>(inputDerivedClassPointer);
282815 : // Milind Chabbi (8/28/2013): isSgChooseExpression uses table-driven castability instead of c++ default dynamic_cast
282816 : // this improves the running time performance by 10-20%.
282817 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgChooseExpression*>(inputDerivedClassPointer);
282818 0 : return IS_SgChooseExpression_FAST_MACRO(inputDerivedClassPointer);
282819 : }
282820 :
282821 :
282822 :
282823 : /* #line 282824 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282824 :
282825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
282826 :
282827 : /**
282828 : \brief Generated destructor
282829 :
282830 : This destructor is automatically generated (by ROSETTA). This destructor
282831 : only frees memory of data members associated with the parts of the current IR node which
282832 : are NOT traversed. Those data members that are part of a traversal can be freed using
282833 : a traversal (calling this destructor on all children in a post-order traversal). Such
282834 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
282835 :
282836 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
282837 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
282838 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
282839 :
282840 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
282841 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
282842 : pointers are not yet implemented to call delete on eash pointer in the container.
282843 : (This could be done by derivation from the STL containers to define containers that
282844 : automatically deleted their members.)
282845 :
282846 : */
282847 0 : SgChooseExpression::~SgChooseExpression () {
282848 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
282849 :
282850 :
282851 : // case: not a listType for value
282852 0 : p_value = NULL; // non list case
282853 :
282854 : }
282855 :
282856 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
282857 0 : }
282858 :
282859 :
282860 : /* #line 282861 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282861 :
282862 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
282863 :
282864 : // Generated constructor
282865 0 : SgChooseExpression::SgChooseExpression ( Sg_File_Info* startOfConstruct, SgExpression* value )
282866 0 : : SgExpression(startOfConstruct)
282867 : {
282868 : #ifdef DEBUG
282869 : // printf ("In SgChooseExpression::SgChooseExpression (Sg_File_Info* startOfConstruct, SgExpression* value) sage_class_name() = %s \n",sage_class_name());
282870 : #endif
282871 : #if 0
282872 : // debugging information!
282873 : printf ("In SgChooseExpression::SgChooseExpression (Sg_File_Info* startOfConstruct, SgExpression* value): this = %p = %s \n",this,this->class_name().c_str());
282874 : #endif
282875 :
282876 0 : p_value = value;
282877 :
282878 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
282879 :
282880 : #if 0
282881 : // DQ (7/30/2014): Call a virtual function.
282882 : std::string s = this->class_name();
282883 : #endif
282884 :
282885 : // Test the variant virtual function
282886 : // assert(CHOOSE_EXPR == variant());
282887 0 : assert(CHOOSE_EXPR == this->variant());
282888 0 : ROSE_ASSERT(CHOOSE_EXPR == (int)(this->variantT()));
282889 0 : post_construction_initialization();
282890 :
282891 : // Test the isSgChooseExpression() function since it has been problematic
282892 0 : assert(isSgChooseExpression(this) != NULL);
282893 0 : }
282894 :
282895 : // Generated constructor (all data members)
282896 :
282897 : /* #line 282898 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282898 :
282899 :
282900 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
282901 :
282902 :
282903 : // ********************************************************
282904 : // member functions common across all array grammar objects
282905 : // ********************************************************
282906 :
282907 :
282908 :
282909 : /* #line 282910 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282910 :
282911 :
282912 :
282913 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
282914 :
282915 : // ********************************************************
282916 : // member functions specific to each node in the grammar
282917 : // ********************************************************
282918 :
282919 :
282920 : /* #line 282921 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
282921 :
282922 : // Start of memberFunctionString
282923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/flagMemberAccessFunctions.macro" */
282924 :
282925 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
282926 :
282927 : AstAttributeMechanism*
282928 0 : SgSymbol::get_attributeMechanism () const
282929 : {
282930 0 : ROSE_ASSERT (this != NULL);
282931 0 : return p_attributeMechanism;
282932 : }
282933 :
282934 : void
282935 0 : SgSymbol::set_attributeMechanism ( AstAttributeMechanism* attributeMechanism )
282936 : {
282937 0 : ROSE_ASSERT (this != NULL);
282938 :
282939 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
282940 : if (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism)
282941 : {
282942 : printf ("Warning: attributeMechanism = %p overwriting valid pointer p_attributeMechanism = %p \n",attributeMechanism,p_attributeMechanism);
282943 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
282944 : printf ("Error fails assertion (p_attributeMechanism != NULL && attributeMechanism != NULL && p_attributeMechanism != attributeMechanism) is false\n");
282945 : ROSE_ASSERT(false);
282946 : #endif
282947 : }
282948 : #endif
282949 0 : p_attributeMechanism = attributeMechanism;
282950 0 : }
282951 :
282952 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
282953 :
282954 :
282955 : // End of memberFunctionString
282956 : // Start of memberFunctionString
282957 : /* #line 2446 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Support.code" */
282958 :
282959 :
282960 : #if 0
282961 : // DQ (4/10/2006): Removed in favor of implementation at SgNode using
282962 : // a pointer and the interface represented directly at the SgNode
282963 : AstAttributeMechanism &
282964 : SgSymbol::attribute()
282965 : {
282966 : // DQ (1/2/2006): This function preserves as much of
282967 : // the syntax of attribute being a public data member.
282968 : if (p_attribute == NULL)
282969 : {
282970 : mprintf ("Error: p_attribute == NULL (node = %s) \n",class_name().c_str());
282971 : assert(false);
282972 : }
282973 :
282974 : return *p_attribute;
282975 : }
282976 : #endif
282977 :
282978 : void
282979 0 : SgSymbol::addNewAttribute( std::string s, AstAttribute* a )
282980 : {
282981 0 : if (get_attributeMechanism() == NULL)
282982 : {
282983 0 : set_attributeMechanism( new AstAttributeMechanism() );
282984 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
282985 : }
282986 0 : get_attributeMechanism()->add(s,a);
282987 0 : }
282988 :
282989 : void
282990 0 : SgSymbol::setAttribute( std::string s, AstAttribute* a )
282991 : {
282992 0 : if (get_attributeMechanism() == NULL)
282993 : {
282994 0 : set_attributeMechanism( new AstAttributeMechanism() );
282995 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
282996 : }
282997 0 : get_attributeMechanism()->set(s,a);
282998 0 : }
282999 :
283000 : AstAttribute*
283001 0 : SgSymbol::getAttribute(std::string s) const
283002 : {
283003 : //assert(get_attributeMechanism() != NULL); // Liao, bug 130 6/4/2008
283004 0 : if (attributeExists(s)==false) return NULL;
283005 0 : AstAttribute* returnValue = get_attributeMechanism()->operator[](s);
283006 0 : ROSE_ASSERT(returnValue != NULL);
283007 0 : return returnValue;
283008 : }
283009 :
283010 : void
283011 0 : SgSymbol::updateAttribute( std::string s, AstAttribute* a )
283012 : {
283013 : // formerly called: replace
283014 0 : ROSE_ASSERT(get_attributeMechanism() != NULL);
283015 0 : get_attributeMechanism()->replace(s,a);
283016 0 : }
283017 :
283018 : void
283019 0 : SgSymbol::removeAttribute(std::string s)
283020 : {
283021 0 : if (get_attributeMechanism())
283022 0 : get_attributeMechanism()->remove(s);
283023 :
283024 : // DQ (1/2/2006): If we have no more attributes then remove the attribute container
283025 0 : int remainingCount = numberOfAttributes();
283026 : // mprintf ("In AstTextAttributesHandling::visit(): remaining number of attributes = %d \n",remainingCount);
283027 0 : if (remainingCount == 0)
283028 : {
283029 0 : delete get_attributeMechanism();
283030 0 : set_attributeMechanism(NULL);
283031 : }
283032 0 : }
283033 :
283034 : bool
283035 0 : SgSymbol::attributeExists(std::string s) const
283036 : {
283037 0 : bool returnValue = false;
283038 0 : if (get_attributeMechanism() != NULL)
283039 0 : returnValue = get_attributeMechanism()->exists(s);
283040 0 : return returnValue;
283041 : }
283042 :
283043 : int
283044 0 : SgSymbol::numberOfAttributes() const
283045 : {
283046 0 : int returnValue = 0;
283047 0 : if (get_attributeMechanism() != NULL)
283048 0 : returnValue = get_attributeMechanism()->size();
283049 0 : return returnValue;
283050 : }
283051 :
283052 :
283053 :
283054 : // End of memberFunctionString
283055 : // Start of memberFunctionString
283056 : /* #line 127 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
283057 :
283058 : #if 1
283059 : // DQ (2/6/2007): This returns the basis for SgSymbol
283060 : SgNode*
283061 5022 : SgSymbol::get_symbol_basis() const
283062 : {
283063 5022 : return NULL;
283064 : }
283065 : #endif
283066 :
283067 : #if PHASED_OUT
283068 :
283069 : SgDeclarationStatement*
283070 : SgSymbol::get_declaration() const
283071 : {
283072 : // DQ (8/21/2013): Added function so that templated lower-level symbol table support will compile.
283073 : // Note that this function can not be called and returns an appropriate error message.
283074 :
283075 : printf ("ERROR: SgSymbol::get_declaration(): this function exists so that templated lower-level symbol table support will compile (please call this on an appropriate derived class of SgSymbol) \n");
283076 : ROSE_ASSERT(false);
283077 :
283078 : return NULL;
283079 : }
283080 : #endif /* PHASED_OUT */
283081 :
283082 : // This function has been implement to support testing of the scope of
283083 : // the declartion with the scope of where the symbols are placed
283084 : // (within the inserion and checking og symbol tables).
283085 : SgScopeStatement*
283086 1258820 : SgSymbol::get_scope() const
283087 : {
283088 1258820 : SgScopeStatement* scope = NULL;
283089 1258820 : const SgNode* basis = get_symbol_basis();
283090 :
283091 1258820 : ROSE_ASSERT(basis != NULL);
283092 : // printf ("In SgSymbol::get_scope(): basis = %p = %s \n",basis,basis->class_name().c_str());
283093 :
283094 1258820 : const SgInitializedName* initializedName = isSgInitializedName(basis);
283095 1258820 : if (initializedName != NULL)
283096 : {
283097 61749 : scope = initializedName->get_scope();
283098 : }
283099 :
283100 1258820 : const SgStatement* statement = isSgStatement(basis);
283101 1258820 : if (statement != NULL)
283102 : {
283103 1197070 : scope = statement->get_scope();
283104 : }
283105 :
283106 1258820 : ROSE_ASSERT(scope != NULL);
283107 1258820 : return scope;
283108 : }
283109 :
283110 :
283111 : SgName
283112 14326 : SgSymbol::get_mangled_name() const
283113 : {
283114 : // DQ (12/3/2011): refactoring of support for symbol tables and symbols.
283115 :
283116 14326 : SgName mangledName;
283117 14326 : const SgSymbol* symbolFromTable = this;
283118 14326 : ROSE_ASSERT(symbolFromTable != NULL);
283119 :
283120 14326 : switch(symbolFromTable->variantT())
283121 : {
283122 0 : case V_SgFunctionSymbol:
283123 0 : {
283124 0 : const SgFunctionSymbol* symbol = isSgFunctionSymbol(symbolFromTable);
283125 0 : assert(symbol != NULL);
283126 0 : SgFunctionDeclaration* functionDeclaration = symbol->get_declaration();
283127 :
283128 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283129 0 : ROSE_ASSERT(functionDeclaration != NULL);
283130 :
283131 0 : mangledName = functionDeclaration->get_mangled_name();
283132 :
283133 0 : break;
283134 : }
283135 :
283136 0 : case V_SgMemberFunctionSymbol:
283137 0 : {
283138 0 : const SgMemberFunctionSymbol* symbol = isSgMemberFunctionSymbol(symbolFromTable);
283139 0 : assert(symbol != NULL);
283140 0 : SgFunctionDeclaration* functionDeclaration = symbol->get_declaration();
283141 :
283142 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283143 0 : ROSE_ASSERT(functionDeclaration != NULL);
283144 :
283145 0 : mangledName = functionDeclaration->get_mangled_name();
283146 0 : break;
283147 : }
283148 :
283149 852 : case V_SgClassSymbol:
283150 852 : {
283151 852 : const SgClassSymbol* symbol = isSgClassSymbol(symbolFromTable);
283152 852 : assert(symbol != NULL);
283153 852 : SgClassDeclaration* classDeclaration = symbol->get_declaration();
283154 :
283155 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283156 852 : ROSE_ASSERT(classDeclaration != NULL);
283157 :
283158 852 : mangledName = classDeclaration->get_mangled_name();
283159 852 : break;
283160 : }
283161 :
283162 0 : case V_SgEnumFieldSymbol:
283163 0 : {
283164 0 : const SgEnumFieldSymbol* symbol = isSgEnumFieldSymbol(symbolFromTable);
283165 0 : assert(symbol != NULL);
283166 0 : SgInitializedName* enumFieldName = symbol->get_declaration();
283167 :
283168 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283169 0 : ROSE_ASSERT(enumFieldName != NULL);
283170 :
283171 0 : mangledName = enumFieldName->get_mangled_name();
283172 0 : break;
283173 : }
283174 :
283175 0 : case V_SgEnumSymbol:
283176 0 : {
283177 0 : const SgEnumSymbol* symbol = isSgEnumSymbol(symbolFromTable);
283178 0 : assert(symbol != NULL);
283179 0 : SgEnumDeclaration* enumDeclaration = symbol->get_declaration();
283180 :
283181 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283182 0 : ROSE_ASSERT(enumDeclaration != NULL);
283183 :
283184 0 : mangledName = enumDeclaration->get_mangled_name();
283185 0 : break;
283186 : }
283187 :
283188 5022 : case V_SgFunctionTypeSymbol:
283189 5022 : {
283190 5022 : const SgFunctionTypeSymbol* symbol = isSgFunctionTypeSymbol(symbolFromTable);
283191 5022 : assert(symbol != NULL);
283192 5022 : mangledName = symbol->get_name();
283193 :
283194 : // DQ (4/12/2019): I think this should be commented out since it generates output spew.
283195 : // printf ("A SgFunctionTypeSymbol also has a pointer to a SgType = %p \n",symbol->get_type());
283196 :
283197 5022 : break;
283198 : }
283199 :
283200 0 : case V_SgLabelSymbol:
283201 0 : {
283202 0 : const SgLabelSymbol* symbol = isSgLabelSymbol(symbolFromTable);
283203 0 : assert(symbol != NULL);
283204 0 : SgLabelStatement* labelStatement = symbol->get_declaration();
283205 :
283206 : // DQ (12/24/2007): Modified to reflect new implementation for Fortran numeric labels.
283207 : // mangledName = labelStatement->get_label();
283208 0 : if (labelStatement == NULL)
283209 : {
283210 0 : assert(symbol->get_numeric_label_value() >= 0);
283211 0 : mangledName = Rose::StringUtility::numberToString(symbol->get_numeric_label_value());
283212 : }
283213 : else
283214 : {
283215 0 : mangledName = labelStatement->get_label();
283216 : }
283217 : break;
283218 : }
283219 :
283220 0 : case V_SgNamespaceSymbol:
283221 0 : {
283222 0 : const SgNamespaceSymbol* symbol = isSgNamespaceSymbol(symbolFromTable);
283223 0 : assert(symbol != NULL);
283224 : #if 0
283225 : SgNamespaceDeclarationStatement* namespaceDeclaration = symbol->get_declaration();
283226 : mangledName = namespaceDeclaration->get_mangled_name();
283227 : printf ("A SgNamespaceSymbol also has a name = %s \n",symbol->get_name().str());
283228 : #else
283229 0 : if (symbol->get_isAlias() == true)
283230 : {
283231 0 : SgNamespaceAliasDeclarationStatement* namespaceAliasDeclarationStatement = symbol->get_aliasDeclaration();
283232 :
283233 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283234 0 : ROSE_ASSERT(namespaceAliasDeclarationStatement != NULL);
283235 :
283236 0 : mangledName = namespaceAliasDeclarationStatement->get_mangled_name();
283237 :
283238 0 : printf ("A SgNamespaceSymbol has an ALIAS with name = %s \n",symbol->get_name().str());
283239 : }
283240 : else
283241 : {
283242 0 : SgNamespaceDeclarationStatement* namespaceDeclaration = symbol->get_declaration();
283243 :
283244 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283245 0 : ROSE_ASSERT(namespaceDeclaration != NULL);
283246 :
283247 0 : mangledName = namespaceDeclaration->get_mangled_name();
283248 0 : printf ("A SgNamespaceSymbol also has a name = %s \n",symbol->get_name().str());
283249 : }
283250 : #endif
283251 : break;
283252 : }
283253 :
283254 0 : case V_SgTemplateSymbol:
283255 0 : {
283256 0 : const SgTemplateSymbol* symbol = isSgTemplateSymbol(symbolFromTable);
283257 0 : assert(symbol != NULL);
283258 0 : SgTemplateDeclaration* templateDeclaration = symbol->get_declaration();
283259 :
283260 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283261 0 : ROSE_ASSERT(templateDeclaration != NULL);
283262 :
283263 0 : mangledName = templateDeclaration->get_mangled_name();
283264 0 : break;
283265 : }
283266 :
283267 0 : case V_SgTypedefSymbol:
283268 0 : {
283269 0 : const SgTypedefSymbol* symbol = isSgTypedefSymbol(symbolFromTable);
283270 0 : ROSE_ASSERT(symbol != NULL);
283271 0 : SgTypedefDeclaration* typedefDeclaration = symbol->get_declaration();
283272 :
283273 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283274 0 : ROSE_ASSERT(typedefDeclaration != NULL);
283275 :
283276 0 : mangledName = typedefDeclaration->get_mangled_name();
283277 0 : break;
283278 : }
283279 :
283280 8452 : case V_SgVariableSymbol:
283281 8452 : {
283282 8452 : const SgVariableSymbol* symbol = isSgVariableSymbol(symbolFromTable);
283283 8452 : ROSE_ASSERT(symbol != NULL);
283284 8452 : SgInitializedName* initializedName = symbol->get_declaration();
283285 :
283286 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283287 8452 : ROSE_ASSERT(initializedName != NULL);
283288 :
283289 8452 : mangledName = initializedName->get_mangled_name();
283290 8452 : break;
283291 : }
283292 :
283293 0 : case V_SgAliasSymbol:
283294 0 : {
283295 0 : const SgAliasSymbol* symbol = isSgAliasSymbol(symbolFromTable);
283296 0 : ROSE_ASSERT(symbol != NULL);
283297 0 : mangledName = symbol->get_name();
283298 0 : break;
283299 : }
283300 :
283301 : // DQ (3/7/2012): Added support for new kind of symbol (required for test2004_77.C).
283302 0 : case V_SgTemplateFunctionSymbol:
283303 0 : {
283304 0 : const SgTemplateFunctionSymbol* symbol = isSgTemplateFunctionSymbol(symbolFromTable);
283305 0 : ROSE_ASSERT(symbol != NULL);
283306 0 : mangledName = symbol->get_name();
283307 0 : break;
283308 : }
283309 :
283310 0 : case V_SgTemplateClassSymbol:
283311 0 : {
283312 0 : const SgTemplateClassSymbol* symbol = isSgTemplateClassSymbol(symbolFromTable);
283313 0 : ROSE_ASSERT(symbol != NULL);
283314 0 : mangledName = symbol->get_name();
283315 0 : break;
283316 : }
283317 :
283318 : // DQ (3/8/2012): Added support for new kind of symbol (required for test2004_77.C).
283319 0 : case V_SgTemplateMemberFunctionSymbol:
283320 0 : {
283321 0 : const SgTemplateMemberFunctionSymbol* symbol = isSgTemplateMemberFunctionSymbol(symbolFromTable);
283322 0 : ROSE_ASSERT(symbol != NULL);
283323 0 : mangledName = symbol->get_name();
283324 0 : break;
283325 : }
283326 :
283327 0 : case V_SgNonrealSymbol:
283328 0 : {
283329 0 : const SgNonrealSymbol* symbol = isSgNonrealSymbol(symbolFromTable);
283330 0 : ROSE_ASSERT(symbol != NULL);
283331 0 : mangledName = symbol->get_name();
283332 0 : break;
283333 : }
283334 :
283335 : #if 1
283336 : // DQ (2/28/2018): Added support for C++11 specific symbol.
283337 0 : case V_SgTemplateTypedefSymbol:
283338 0 : {
283339 0 : const SgTemplateTypedefSymbol* symbol = isSgTemplateTypedefSymbol(symbolFromTable);
283340 0 : ROSE_ASSERT(symbol != NULL);
283341 0 : ROSE_ASSERT(symbol->get_declaration() != NULL);
283342 :
283343 : #if 0
283344 : // DQ (3/19/2016): Klocworks reports this as an issue (fix by adding assertion).
283345 : ROSE_ASSERT(typedefDeclaration != NULL);
283346 :
283347 : mangledName = typedefDeclaration->get_mangled_name();
283348 : #else
283349 : // DQ (2/28/2018): We need to handle the association of the symbol with either a
283350 : // SgTemplateTypedefDeclaration or a SgTemplateInstantiationTypedefDeclaration IR node.
283351 :
283352 0 : SgTemplateTypedefDeclaration* typedefDeclaration = isSgTemplateTypedefDeclaration(symbol->get_declaration());
283353 0 : if (typedefDeclaration != NULL)
283354 : {
283355 0 : mangledName = typedefDeclaration->get_mangled_name();
283356 : }
283357 : else
283358 : {
283359 0 : printf ("In SgSymbol::get_mangled_name(): symbol->get_declaration() = %p = %s \n",symbol->get_declaration(),symbol->get_declaration()->class_name().c_str());
283360 :
283361 0 : SgTemplateInstantiationTypedefDeclaration* typedefInstantiationDeclaration = isSgTemplateInstantiationTypedefDeclaration(symbol->get_declaration());
283362 0 : if (typedefInstantiationDeclaration != NULL)
283363 : {
283364 0 : mangledName = typedefInstantiationDeclaration->get_mangled_name();
283365 : }
283366 : else
283367 : {
283368 0 : printf ("ERROR: In SgSymbol::get_mangled_name(): symbol->get_declaration() = %p = %s \n",symbol->get_declaration(),symbol->get_declaration()->class_name().c_str());
283369 : }
283370 : }
283371 : #endif
283372 : break;
283373 : }
283374 : #endif
283375 0 : default:
283376 0 : {
283377 0 : mangledName = "unknown mangled name";
283378 0 : printf ("Error: SgSymbol not handled (%s) \n",symbolFromTable->class_name().c_str());
283379 :
283380 : // DQ (6/8/2007): Make this case fail so we can detect this error.
283381 0 : assert(false);
283382 : }
283383 : }
283384 :
283385 14326 : return mangledName;
283386 : }
283387 :
283388 :
283389 :
283390 : // End of memberFunctionString
283391 : // Start of memberFunctionString
283392 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
283393 :
283394 : // *** COMMON CODE SECTION BEGINS HERE ***
283395 :
283396 : #if 0
283397 : int
283398 : SgSymbol::getVariant() const
283399 : {
283400 : // This function is used in ROSE while "variant()" is used in SAGE
283401 : assert(this != NULL);
283402 : return variant();
283403 : }
283404 : #endif
283405 :
283406 : // This function is used in ROSE in treeTraversal code
283407 : // eventually replaces getVariant() and variant()
283408 : // though after variant() has been removed for a while we will
283409 : // want to change the name of variantT() back to variant()
283410 : // (since the "T" was ment to stand for temporary).
283411 : // When this happens the variantT() will be depricated.
283412 : VariantT
283413 7114880 : SgSymbol::variantT() const
283414 : {
283415 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
283416 7114880 : ROSE_ASSERT(this != NULL);
283417 7114880 : return V_SgSymbol;
283418 : }
283419 :
283420 : #if 0
283421 : int
283422 : SgSymbol::variant() const
283423 : {
283424 : // This function is used in SAGE
283425 : ROSE_ASSERT(this != NULL);
283426 : return SymbolTag;
283427 : }
283428 : #endif
283429 :
283430 : ROSE_DLL_API const char*
283431 0 : SgSymbol::sage_class_name() const
283432 : {
283433 0 : ROSE_ASSERT(this != NULL);
283434 0 : return "SgSymbol";
283435 : }
283436 :
283437 : std::string
283438 0 : SgSymbol::class_name() const
283439 : {
283440 0 : ROSE_ASSERT(this != NULL);
283441 0 : return "SgSymbol";
283442 : }
283443 :
283444 : // DQ (11/26/2005): Support for visitor pattern mechanims
283445 : // (inferior to ROSE traversal mechanism, experimental).
283446 : void
283447 0 : SgSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
283448 : {
283449 0 : ROSE_ASSERT(this != NULL);
283450 0 : visitor.visit(this);
283451 0 : }
283452 :
283453 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
283454 0 : void SgSymbol::accept (ROSE_VisitorPattern & visitor) {
283455 0 : ROSE_ASSERT(this != NULL);
283456 0 : visitor.visit(this);
283457 0 : }
283458 :
283459 : SgSymbol*
283460 0 : SgSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
283461 : {
283462 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
283463 : // This function is currently only supported for the AST used the represent Binary executables.
283464 : if (0 /* isSgAsmNode(this) != NULL */)
283465 : {
283466 : // Support for regex specification.
283467 : std::string prefixCode = "REGEX:";
283468 : addNewAttribute(prefixCode + s,a);
283469 : }
283470 : #endif
283471 :
283472 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
283473 0 : return this;
283474 : }
283475 :
283476 : // *** COMMON CODE SECTION ENDS HERE ***
283477 :
283478 :
283479 : // End of memberFunctionString
283480 : // Start of memberFunctionString
283481 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
283482 :
283483 :
283484 : #if 0
283485 : //! Error checking support
283486 : /*! Verifies the following:
283487 : - working getVariant() member function
283488 : - calls base class's error() member function
283489 : Every class has one of these functions.
283490 : */
283491 : bool
283492 : SgSymbol::error()
283493 : {
283494 : // Put error checking here
283495 :
283496 : ROSE_ASSERT (this != NULL);
283497 : if (getVariant() != SymbolTag)
283498 : {
283499 : printf ("Error in SgSymbol::error(): SgSymbol object has a %s variant \n",
283500 : Cxx_GrammarTerminalNames[getVariant()].name);
283501 : // printf ("Error in SgSymbol::error() \n");
283502 : ROSE_ABORT();
283503 : }
283504 :
283505 : ROSE_ASSERT (getVariant() == SymbolTag);
283506 : return SgNode::error();
283507 : }
283508 : #endif
283509 :
283510 :
283511 :
283512 : // End of memberFunctionString
283513 :
283514 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
283515 :
283516 108754000 : SgSymbol* isSgSymbol ( SgNode* inputDerivedClassPointer )
283517 : {
283518 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
283519 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
283520 : // So to fix this we return NULL directly when the input is NULL and avoid the
283521 : // dynamic_cast in this case. This is likely a performance improvement as well.
283522 : // return dynamic_cast<SgSymbol*>(inputDerivedClassPointer);
283523 : // Milind Chabbi (8/28/2013): isSgSymbol uses table-driven castability instead of c++ default dynamic_cast
283524 : // this improves the running time performance by 10-20%.
283525 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgSymbol*>(inputDerivedClassPointer);
283526 108754000 : return IS_SgSymbol_FAST_MACRO(inputDerivedClassPointer);
283527 : }
283528 :
283529 : // DQ (11/8/2003): Added version of functions taking const pointer
283530 1881210 : const SgSymbol* isSgSymbol ( const SgNode* inputDerivedClassPointer )
283531 : {
283532 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
283533 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
283534 : // So to fix this we return NULL directly when the input is NULL and avoid the
283535 : // dynamic_cast in this case. This is likely a performance improvement as well.
283536 : // return dynamic_cast<const SgSymbol*>(inputDerivedClassPointer);
283537 : // Milind Chabbi (8/28/2013): isSgSymbol uses table-driven castability instead of c++ default dynamic_cast
283538 : // this improves the running time performance by 10-20%.
283539 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgSymbol*>(inputDerivedClassPointer);
283540 1881210 : return IS_SgSymbol_FAST_MACRO(inputDerivedClassPointer);
283541 : }
283542 :
283543 :
283544 :
283545 : /* #line 283546 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283546 :
283547 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
283548 :
283549 : /**
283550 : \brief Generated destructor
283551 :
283552 : This destructor is automatically generated (by ROSETTA). This destructor
283553 : only frees memory of data members associated with the parts of the current IR node which
283554 : are NOT traversed. Those data members that are part of a traversal can be freed using
283555 : a traversal (calling this destructor on all children in a post-order traversal). Such
283556 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
283557 :
283558 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
283559 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
283560 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
283561 :
283562 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
283563 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
283564 : pointers are not yet implemented to call delete on eash pointer in the container.
283565 : (This could be done by derivation from the STL containers to define containers that
283566 : automatically deleted their members.)
283567 :
283568 : */
283569 97807 : SgSymbol::~SgSymbol () {
283570 97807 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
283571 :
283572 :
283573 : // case: not a listType for attributeMechanism
283574 97807 : p_attributeMechanism = NULL; // non list case
283575 :
283576 : }
283577 :
283578 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
283579 97807 : }
283580 :
283581 :
283582 : /* #line 283583 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283583 :
283584 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
283585 :
283586 : // Generated constructor
283587 2371620 : SgSymbol::SgSymbol ( )
283588 2371620 : : SgNode()
283589 : {
283590 : #ifdef DEBUG
283591 : // printf ("In SgSymbol::SgSymbol () sage_class_name() = %s \n",sage_class_name());
283592 : #endif
283593 : #if 0
283594 : // debugging information!
283595 : printf ("In SgSymbol::SgSymbol (): this = %p = %s \n",this,this->class_name().c_str());
283596 : #endif
283597 :
283598 2371620 : p_attributeMechanism = NULL;
283599 :
283600 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
283601 :
283602 : #if 0
283603 : // DQ (7/30/2014): Call a virtual function.
283604 : std::string s = this->class_name();
283605 : #endif
283606 :
283607 : // Test the variant virtual function
283608 : // assert(SymbolTag == variant());
283609 2371620 : assert(SymbolTag == this->variant());
283610 2371620 : ROSE_ASSERT(SymbolTag == (int)(this->variantT()));
283611 2371620 : post_construction_initialization();
283612 :
283613 : // Test the isSgSymbol() function since it has been problematic
283614 2371620 : assert(isSgSymbol(this) != NULL);
283615 2371620 : }
283616 :
283617 : // Generated constructor (all data members)
283618 :
283619 : /* #line 283620 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283620 :
283621 :
283622 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
283623 :
283624 :
283625 : // ********************************************************
283626 : // member functions common across all array grammar objects
283627 : // ********************************************************
283628 :
283629 :
283630 :
283631 : /* #line 283632 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283632 :
283633 :
283634 :
283635 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
283636 :
283637 : // ********************************************************
283638 : // member functions specific to each node in the grammar
283639 : // ********************************************************
283640 :
283641 :
283642 : /* #line 283643 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283643 :
283644 : // Start of memberFunctionString
283645 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
283646 :
283647 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
283648 :
283649 : SgInitializedName*
283650 1949260 : SgVariableSymbol::get_declaration () const
283651 : {
283652 1949260 : ROSE_ASSERT (this != NULL);
283653 :
283654 : #if 0
283655 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
283656 : // used to trigger marking transformations for the token-based unparsing.
283657 : printf ("SgVariableSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
283658 : #endif
283659 :
283660 1949260 : return p_declaration;
283661 : }
283662 :
283663 : void
283664 0 : SgVariableSymbol::set_declaration ( SgInitializedName* declaration )
283665 : {
283666 0 : ROSE_ASSERT (this != NULL);
283667 :
283668 : #if 0
283669 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
283670 : // used to trigger marking transformations for the token-based unparsing.
283671 : printf ("SgVariableSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
283672 : #endif
283673 :
283674 0 : set_isModified(true);
283675 :
283676 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
283677 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
283678 : {
283679 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
283680 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
283681 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
283682 : ROSE_ASSERT(false);
283683 : #endif
283684 : }
283685 : #endif
283686 0 : p_declaration = declaration;
283687 0 : }
283688 :
283689 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
283690 :
283691 :
283692 : // End of memberFunctionString
283693 : // Start of memberFunctionString
283694 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
283695 :
283696 : SgType*
283697 117832 : SgVariableSymbol::get_type() const
283698 : {
283699 117832 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
283700 : }
283701 :
283702 : #if 0
283703 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
283704 : SgNode*
283705 : SgVariableSymbol::get_symbol_basis() const
283706 : {
283707 : return get_type();
283708 : }
283709 : #endif
283710 :
283711 :
283712 : // End of memberFunctionString
283713 : // Start of memberFunctionString
283714 : /* #line 486 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
283715 :
283716 : SgName
283717 36239 : SgVariableSymbol::get_name() const
283718 : {
283719 : #if 0
283720 : // DQ (2/7/2020): Use this code since we are debugging a case when get_declaration() == NULL.
283721 :
283722 : printf ("Debugging long form of get_name(): this = %p = %s \n",this,this->class_name().c_str());
283723 : printf ("Debugging long form of get_name(): get_declaration() = %p \n",this->get_declaration());
283724 :
283725 : SgName theName;
283726 :
283727 : if (get_declaration() != NULL)
283728 : {
283729 : printf ("Debugging long form of get_name(): get_declaration() != NULL: get_declaration() = %p = %s \n",this->get_declaration(),this->get_declaration()->class_name().c_str());
283730 : theName = get_declaration()->get_name();
283731 : }
283732 : else
283733 : {
283734 : printf ("Debugging long form of get_name(): get_declaration() == NULL \n");
283735 : theName = SgName("undefined");
283736 : }
283737 :
283738 : printf ("Debugging long form of get_name(): theName = %s \n",theName.str());
283739 :
283740 : return theName;
283741 : #else
283742 36239 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
283743 : #endif
283744 : }
283745 :
283746 : #if 1
283747 : // DQ (2/6/2007): This returns the basis for the SgVariableSymbol (an SgInitializedName object)
283748 : SgNode*
283749 1267780 : SgVariableSymbol::get_symbol_basis() const
283750 : {
283751 1267780 : return get_declaration();
283752 : }
283753 : #endif
283754 :
283755 :
283756 :
283757 : // End of memberFunctionString
283758 : // Start of memberFunctionString
283759 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
283760 :
283761 : // *** COMMON CODE SECTION BEGINS HERE ***
283762 :
283763 : #if 0
283764 : int
283765 : SgVariableSymbol::getVariant() const
283766 : {
283767 : // This function is used in ROSE while "variant()" is used in SAGE
283768 : assert(this != NULL);
283769 : return variant();
283770 : }
283771 : #endif
283772 :
283773 : // This function is used in ROSE in treeTraversal code
283774 : // eventually replaces getVariant() and variant()
283775 : // though after variant() has been removed for a while we will
283776 : // want to change the name of variantT() back to variant()
283777 : // (since the "T" was ment to stand for temporary).
283778 : // When this happens the variantT() will be depricated.
283779 : VariantT
283780 5766230 : SgVariableSymbol::variantT() const
283781 : {
283782 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
283783 5766230 : ROSE_ASSERT(this != NULL);
283784 5766230 : return V_SgVariableSymbol;
283785 : }
283786 :
283787 : #if 0
283788 : int
283789 : SgVariableSymbol::variant() const
283790 : {
283791 : // This function is used in SAGE
283792 : ROSE_ASSERT(this != NULL);
283793 : return VARIABLE_NAME;
283794 : }
283795 : #endif
283796 :
283797 : ROSE_DLL_API const char*
283798 0 : SgVariableSymbol::sage_class_name() const
283799 : {
283800 0 : ROSE_ASSERT(this != NULL);
283801 0 : return "SgVariableSymbol";
283802 : }
283803 :
283804 : std::string
283805 58616 : SgVariableSymbol::class_name() const
283806 : {
283807 58616 : ROSE_ASSERT(this != NULL);
283808 58616 : return "SgVariableSymbol";
283809 : }
283810 :
283811 : // DQ (11/26/2005): Support for visitor pattern mechanims
283812 : // (inferior to ROSE traversal mechanism, experimental).
283813 : void
283814 588259 : SgVariableSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
283815 : {
283816 588259 : ROSE_ASSERT(this != NULL);
283817 588259 : visitor.visit(this);
283818 588259 : }
283819 :
283820 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
283821 0 : void SgVariableSymbol::accept (ROSE_VisitorPattern & visitor) {
283822 0 : ROSE_ASSERT(this != NULL);
283823 0 : visitor.visit(this);
283824 0 : }
283825 :
283826 : SgVariableSymbol*
283827 0 : SgVariableSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
283828 : {
283829 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
283830 : // This function is currently only supported for the AST used the represent Binary executables.
283831 : if (0 /* isSgAsmNode(this) != NULL */)
283832 : {
283833 : // Support for regex specification.
283834 : std::string prefixCode = "REGEX:";
283835 : addNewAttribute(prefixCode + s,a);
283836 : }
283837 : #endif
283838 :
283839 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
283840 0 : return this;
283841 : }
283842 :
283843 : // *** COMMON CODE SECTION ENDS HERE ***
283844 :
283845 :
283846 : // End of memberFunctionString
283847 : // Start of memberFunctionString
283848 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
283849 :
283850 :
283851 : #if 0
283852 : //! Error checking support
283853 : /*! Verifies the following:
283854 : - working getVariant() member function
283855 : - calls base class's error() member function
283856 : Every class has one of these functions.
283857 : */
283858 : bool
283859 : SgVariableSymbol::error()
283860 : {
283861 : // Put error checking here
283862 :
283863 : ROSE_ASSERT (this != NULL);
283864 : if (getVariant() != VARIABLE_NAME)
283865 : {
283866 : printf ("Error in SgVariableSymbol::error(): SgVariableSymbol object has a %s variant \n",
283867 : Cxx_GrammarTerminalNames[getVariant()].name);
283868 : // printf ("Error in SgVariableSymbol::error() \n");
283869 : ROSE_ABORT();
283870 : }
283871 :
283872 : ROSE_ASSERT (getVariant() == VARIABLE_NAME);
283873 : return SgSymbol::error();
283874 : }
283875 : #endif
283876 :
283877 :
283878 :
283879 : // End of memberFunctionString
283880 :
283881 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
283882 :
283883 5152410 : SgVariableSymbol* isSgVariableSymbol ( SgNode* inputDerivedClassPointer )
283884 : {
283885 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
283886 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
283887 : // So to fix this we return NULL directly when the input is NULL and avoid the
283888 : // dynamic_cast in this case. This is likely a performance improvement as well.
283889 : // return dynamic_cast<SgVariableSymbol*>(inputDerivedClassPointer);
283890 : // Milind Chabbi (8/28/2013): isSgVariableSymbol uses table-driven castability instead of c++ default dynamic_cast
283891 : // this improves the running time performance by 10-20%.
283892 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgVariableSymbol*>(inputDerivedClassPointer);
283893 5152410 : return IS_SgVariableSymbol_FAST_MACRO(inputDerivedClassPointer);
283894 : }
283895 :
283896 : // DQ (11/8/2003): Added version of functions taking const pointer
283897 8458 : const SgVariableSymbol* isSgVariableSymbol ( const SgNode* inputDerivedClassPointer )
283898 : {
283899 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
283900 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
283901 : // So to fix this we return NULL directly when the input is NULL and avoid the
283902 : // dynamic_cast in this case. This is likely a performance improvement as well.
283903 : // return dynamic_cast<const SgVariableSymbol*>(inputDerivedClassPointer);
283904 : // Milind Chabbi (8/28/2013): isSgVariableSymbol uses table-driven castability instead of c++ default dynamic_cast
283905 : // this improves the running time performance by 10-20%.
283906 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgVariableSymbol*>(inputDerivedClassPointer);
283907 8458 : return IS_SgVariableSymbol_FAST_MACRO(inputDerivedClassPointer);
283908 : }
283909 :
283910 :
283911 :
283912 : /* #line 283913 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283913 :
283914 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
283915 :
283916 : /**
283917 : \brief Generated destructor
283918 :
283919 : This destructor is automatically generated (by ROSETTA). This destructor
283920 : only frees memory of data members associated with the parts of the current IR node which
283921 : are NOT traversed. Those data members that are part of a traversal can be freed using
283922 : a traversal (calling this destructor on all children in a post-order traversal). Such
283923 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
283924 :
283925 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
283926 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
283927 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
283928 :
283929 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
283930 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
283931 : pointers are not yet implemented to call delete on eash pointer in the container.
283932 : (This could be done by derivation from the STL containers to define containers that
283933 : automatically deleted their members.)
283934 :
283935 : */
283936 17094 : SgVariableSymbol::~SgVariableSymbol () {
283937 8633 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
283938 :
283939 :
283940 : // case: not a listType for declaration
283941 8633 : p_declaration = NULL; // non list case
283942 :
283943 : }
283944 :
283945 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
283946 17094 : }
283947 :
283948 :
283949 : /* #line 283950 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283950 :
283951 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
283952 :
283953 : // Generated constructor
283954 63179 : SgVariableSymbol::SgVariableSymbol ( SgInitializedName* declaration )
283955 63179 : : SgSymbol()
283956 : {
283957 : #ifdef DEBUG
283958 : // printf ("In SgVariableSymbol::SgVariableSymbol (SgInitializedName* declaration) sage_class_name() = %s \n",sage_class_name());
283959 : #endif
283960 : #if 0
283961 : // debugging information!
283962 : printf ("In SgVariableSymbol::SgVariableSymbol (SgInitializedName* declaration): this = %p = %s \n",this,this->class_name().c_str());
283963 : #endif
283964 :
283965 63179 : p_declaration = declaration;
283966 :
283967 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
283968 :
283969 : #if 0
283970 : // DQ (7/30/2014): Call a virtual function.
283971 : std::string s = this->class_name();
283972 : #endif
283973 :
283974 : // Test the variant virtual function
283975 : // assert(VARIABLE_NAME == variant());
283976 63179 : assert(VARIABLE_NAME == this->variant());
283977 63179 : ROSE_ASSERT(VARIABLE_NAME == (int)(this->variantT()));
283978 63179 : post_construction_initialization();
283979 :
283980 : // Test the isSgVariableSymbol() function since it has been problematic
283981 63179 : assert(isSgVariableSymbol(this) != NULL);
283982 63179 : }
283983 :
283984 : // Generated constructor (all data members)
283985 :
283986 : /* #line 283987 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283987 :
283988 :
283989 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
283990 :
283991 :
283992 : // ********************************************************
283993 : // member functions common across all array grammar objects
283994 : // ********************************************************
283995 :
283996 :
283997 :
283998 : /* #line 283999 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
283999 :
284000 :
284001 :
284002 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284003 :
284004 : // ********************************************************
284005 : // member functions specific to each node in the grammar
284006 : // ********************************************************
284007 :
284008 :
284009 : /* #line 284010 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284010 :
284011 : // Start of memberFunctionString
284012 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
284013 :
284014 : SgType*
284015 1741 : SgTemplateVariableSymbol::get_type() const
284016 : {
284017 1741 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
284018 : }
284019 :
284020 : #if 0
284021 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
284022 : SgNode*
284023 : SgTemplateVariableSymbol::get_symbol_basis() const
284024 : {
284025 : return get_type();
284026 : }
284027 : #endif
284028 :
284029 :
284030 : // End of memberFunctionString
284031 : // Start of memberFunctionString
284032 : /* #line 486 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
284033 :
284034 : SgName
284035 52 : SgTemplateVariableSymbol::get_name() const
284036 : {
284037 : #if 0
284038 : // DQ (2/7/2020): Use this code since we are debugging a case when get_declaration() == NULL.
284039 :
284040 : printf ("Debugging long form of get_name(): this = %p = %s \n",this,this->class_name().c_str());
284041 : printf ("Debugging long form of get_name(): get_declaration() = %p \n",this->get_declaration());
284042 :
284043 : SgName theName;
284044 :
284045 : if (get_declaration() != NULL)
284046 : {
284047 : printf ("Debugging long form of get_name(): get_declaration() != NULL: get_declaration() = %p = %s \n",this->get_declaration(),this->get_declaration()->class_name().c_str());
284048 : theName = get_declaration()->get_name();
284049 : }
284050 : else
284051 : {
284052 : printf ("Debugging long form of get_name(): get_declaration() == NULL \n");
284053 : theName = SgName("undefined");
284054 : }
284055 :
284056 : printf ("Debugging long form of get_name(): theName = %s \n",theName.str());
284057 :
284058 : return theName;
284059 : #else
284060 52 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
284061 : #endif
284062 : }
284063 :
284064 : #if 1
284065 : // DQ (2/6/2007): This returns the basis for the SgVariableSymbol (an SgInitializedName object)
284066 : SgNode*
284067 38617 : SgTemplateVariableSymbol::get_symbol_basis() const
284068 : {
284069 38617 : return get_declaration();
284070 : }
284071 : #endif
284072 :
284073 :
284074 :
284075 : // End of memberFunctionString
284076 : // Start of memberFunctionString
284077 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
284078 :
284079 : // *** COMMON CODE SECTION BEGINS HERE ***
284080 :
284081 : #if 0
284082 : int
284083 : SgTemplateVariableSymbol::getVariant() const
284084 : {
284085 : // This function is used in ROSE while "variant()" is used in SAGE
284086 : assert(this != NULL);
284087 : return variant();
284088 : }
284089 : #endif
284090 :
284091 : // This function is used in ROSE in treeTraversal code
284092 : // eventually replaces getVariant() and variant()
284093 : // though after variant() has been removed for a while we will
284094 : // want to change the name of variantT() back to variant()
284095 : // (since the "T" was ment to stand for temporary).
284096 : // When this happens the variantT() will be depricated.
284097 : VariantT
284098 84321 : SgTemplateVariableSymbol::variantT() const
284099 : {
284100 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
284101 84321 : ROSE_ASSERT(this != NULL);
284102 84321 : return V_SgTemplateVariableSymbol;
284103 : }
284104 :
284105 : #if 0
284106 : int
284107 : SgTemplateVariableSymbol::variant() const
284108 : {
284109 : // This function is used in SAGE
284110 : ROSE_ASSERT(this != NULL);
284111 : return TEMPLATE_VARIABLE_NAME;
284112 : }
284113 : #endif
284114 :
284115 : ROSE_DLL_API const char*
284116 0 : SgTemplateVariableSymbol::sage_class_name() const
284117 : {
284118 0 : ROSE_ASSERT(this != NULL);
284119 0 : return "SgTemplateVariableSymbol";
284120 : }
284121 :
284122 : std::string
284123 552 : SgTemplateVariableSymbol::class_name() const
284124 : {
284125 552 : ROSE_ASSERT(this != NULL);
284126 552 : return "SgTemplateVariableSymbol";
284127 : }
284128 :
284129 : // DQ (11/26/2005): Support for visitor pattern mechanims
284130 : // (inferior to ROSE traversal mechanism, experimental).
284131 : void
284132 11765 : SgTemplateVariableSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
284133 : {
284134 11765 : ROSE_ASSERT(this != NULL);
284135 11765 : visitor.visit(this);
284136 11765 : }
284137 :
284138 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
284139 0 : void SgTemplateVariableSymbol::accept (ROSE_VisitorPattern & visitor) {
284140 0 : ROSE_ASSERT(this != NULL);
284141 0 : visitor.visit(this);
284142 0 : }
284143 :
284144 : SgTemplateVariableSymbol*
284145 0 : SgTemplateVariableSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
284146 : {
284147 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
284148 : // This function is currently only supported for the AST used the represent Binary executables.
284149 : if (0 /* isSgAsmNode(this) != NULL */)
284150 : {
284151 : // Support for regex specification.
284152 : std::string prefixCode = "REGEX:";
284153 : addNewAttribute(prefixCode + s,a);
284154 : }
284155 : #endif
284156 :
284157 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
284158 0 : return this;
284159 : }
284160 :
284161 : // *** COMMON CODE SECTION ENDS HERE ***
284162 :
284163 :
284164 : // End of memberFunctionString
284165 : // Start of memberFunctionString
284166 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
284167 :
284168 :
284169 : #if 0
284170 : //! Error checking support
284171 : /*! Verifies the following:
284172 : - working getVariant() member function
284173 : - calls base class's error() member function
284174 : Every class has one of these functions.
284175 : */
284176 : bool
284177 : SgTemplateVariableSymbol::error()
284178 : {
284179 : // Put error checking here
284180 :
284181 : ROSE_ASSERT (this != NULL);
284182 : if (getVariant() != TEMPLATE_VARIABLE_NAME)
284183 : {
284184 : printf ("Error in SgTemplateVariableSymbol::error(): SgTemplateVariableSymbol object has a %s variant \n",
284185 : Cxx_GrammarTerminalNames[getVariant()].name);
284186 : // printf ("Error in SgTemplateVariableSymbol::error() \n");
284187 : ROSE_ABORT();
284188 : }
284189 :
284190 : ROSE_ASSERT (getVariant() == TEMPLATE_VARIABLE_NAME);
284191 : return SgVariableSymbol::error();
284192 : }
284193 : #endif
284194 :
284195 :
284196 :
284197 : // End of memberFunctionString
284198 :
284199 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
284200 :
284201 1244 : SgTemplateVariableSymbol* isSgTemplateVariableSymbol ( SgNode* inputDerivedClassPointer )
284202 : {
284203 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
284204 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
284205 : // So to fix this we return NULL directly when the input is NULL and avoid the
284206 : // dynamic_cast in this case. This is likely a performance improvement as well.
284207 : // return dynamic_cast<SgTemplateVariableSymbol*>(inputDerivedClassPointer);
284208 : // Milind Chabbi (8/28/2013): isSgTemplateVariableSymbol uses table-driven castability instead of c++ default dynamic_cast
284209 : // this improves the running time performance by 10-20%.
284210 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateVariableSymbol*>(inputDerivedClassPointer);
284211 1244 : return IS_SgTemplateVariableSymbol_FAST_MACRO(inputDerivedClassPointer);
284212 : }
284213 :
284214 : // DQ (11/8/2003): Added version of functions taking const pointer
284215 0 : const SgTemplateVariableSymbol* isSgTemplateVariableSymbol ( const SgNode* inputDerivedClassPointer )
284216 : {
284217 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
284218 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
284219 : // So to fix this we return NULL directly when the input is NULL and avoid the
284220 : // dynamic_cast in this case. This is likely a performance improvement as well.
284221 : // return dynamic_cast<const SgTemplateVariableSymbol*>(inputDerivedClassPointer);
284222 : // Milind Chabbi (8/28/2013): isSgTemplateVariableSymbol uses table-driven castability instead of c++ default dynamic_cast
284223 : // this improves the running time performance by 10-20%.
284224 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateVariableSymbol*>(inputDerivedClassPointer);
284225 0 : return IS_SgTemplateVariableSymbol_FAST_MACRO(inputDerivedClassPointer);
284226 : }
284227 :
284228 :
284229 :
284230 : /* #line 284231 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284231 :
284232 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
284233 :
284234 : /**
284235 : \brief Generated destructor
284236 :
284237 : This destructor is automatically generated (by ROSETTA). This destructor
284238 : only frees memory of data members associated with the parts of the current IR node which
284239 : are NOT traversed. Those data members that are part of a traversal can be freed using
284240 : a traversal (calling this destructor on all children in a post-order traversal). Such
284241 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
284242 :
284243 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
284244 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
284245 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
284246 :
284247 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
284248 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
284249 : pointers are not yet implemented to call delete on eash pointer in the container.
284250 : (This could be done by derivation from the STL containers to define containers that
284251 : automatically deleted their members.)
284252 :
284253 : */
284254 344 : SgTemplateVariableSymbol::~SgTemplateVariableSymbol () {
284255 172 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
284256 :
284257 :
284258 :
284259 : }
284260 :
284261 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
284262 344 : }
284263 :
284264 :
284265 : /* #line 284266 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284266 :
284267 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
284268 :
284269 : // Generated constructor
284270 759 : SgTemplateVariableSymbol::SgTemplateVariableSymbol ( SgInitializedName* declaration )
284271 759 : : SgVariableSymbol(declaration)
284272 : {
284273 : #ifdef DEBUG
284274 : // printf ("In SgTemplateVariableSymbol::SgTemplateVariableSymbol (SgInitializedName* declaration) sage_class_name() = %s \n",sage_class_name());
284275 : #endif
284276 : #if 0
284277 : // debugging information!
284278 : printf ("In SgTemplateVariableSymbol::SgTemplateVariableSymbol (SgInitializedName* declaration): this = %p = %s \n",this,this->class_name().c_str());
284279 : #endif
284280 :
284281 :
284282 :
284283 : #if 0
284284 : // DQ (7/30/2014): Call a virtual function.
284285 : std::string s = this->class_name();
284286 : #endif
284287 :
284288 : // Test the variant virtual function
284289 : // assert(TEMPLATE_VARIABLE_NAME == variant());
284290 759 : assert(TEMPLATE_VARIABLE_NAME == this->variant());
284291 759 : ROSE_ASSERT(TEMPLATE_VARIABLE_NAME == (int)(this->variantT()));
284292 759 : post_construction_initialization();
284293 :
284294 : // Test the isSgTemplateVariableSymbol() function since it has been problematic
284295 759 : assert(isSgTemplateVariableSymbol(this) != NULL);
284296 759 : }
284297 :
284298 : // Generated constructor (all data members)
284299 :
284300 : /* #line 284301 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284301 :
284302 :
284303 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284304 :
284305 :
284306 : // ********************************************************
284307 : // member functions common across all array grammar objects
284308 : // ********************************************************
284309 :
284310 :
284311 :
284312 : /* #line 284313 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284313 :
284314 :
284315 :
284316 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284317 :
284318 : // ********************************************************
284319 : // member functions specific to each node in the grammar
284320 : // ********************************************************
284321 :
284322 :
284323 : /* #line 284324 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284324 :
284325 : // Start of memberFunctionString
284326 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
284327 :
284328 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
284329 :
284330 : SgNonrealDecl*
284331 314668 : SgNonrealSymbol::get_declaration () const
284332 : {
284333 314668 : ROSE_ASSERT (this != NULL);
284334 :
284335 : #if 0
284336 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
284337 : // used to trigger marking transformations for the token-based unparsing.
284338 : printf ("SgNonrealSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
284339 : #endif
284340 :
284341 314668 : return p_declaration;
284342 : }
284343 :
284344 : void
284345 0 : SgNonrealSymbol::set_declaration ( SgNonrealDecl* declaration )
284346 : {
284347 0 : ROSE_ASSERT (this != NULL);
284348 :
284349 : #if 0
284350 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
284351 : // used to trigger marking transformations for the token-based unparsing.
284352 : printf ("SgNonrealSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
284353 : #endif
284354 :
284355 0 : set_isModified(true);
284356 :
284357 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
284358 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
284359 : {
284360 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
284361 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
284362 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
284363 : ROSE_ASSERT(false);
284364 : #endif
284365 : }
284366 : #endif
284367 0 : p_declaration = declaration;
284368 0 : }
284369 :
284370 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
284371 :
284372 :
284373 : // End of memberFunctionString
284374 : // Start of memberFunctionString
284375 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
284376 :
284377 : SgType*
284378 77815 : SgNonrealSymbol::get_type() const
284379 : {
284380 77815 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
284381 : }
284382 :
284383 : #if 0
284384 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
284385 : SgNode*
284386 : SgNonrealSymbol::get_symbol_basis() const
284387 : {
284388 : return get_type();
284389 : }
284390 : #endif
284391 :
284392 :
284393 : // End of memberFunctionString
284394 : // Start of memberFunctionString
284395 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
284396 :
284397 : SgName
284398 1599 : SgNonrealSymbol::get_name() const
284399 : {
284400 1599 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
284401 : }
284402 :
284403 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
284404 : SgNode*
284405 106054 : SgNonrealSymbol::get_symbol_basis() const
284406 : {
284407 106054 : return get_declaration();
284408 : }
284409 :
284410 :
284411 : // End of memberFunctionString
284412 : // Start of memberFunctionString
284413 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
284414 :
284415 : // *** COMMON CODE SECTION BEGINS HERE ***
284416 :
284417 : #if 0
284418 : int
284419 : SgNonrealSymbol::getVariant() const
284420 : {
284421 : // This function is used in ROSE while "variant()" is used in SAGE
284422 : assert(this != NULL);
284423 : return variant();
284424 : }
284425 : #endif
284426 :
284427 : // This function is used in ROSE in treeTraversal code
284428 : // eventually replaces getVariant() and variant()
284429 : // though after variant() has been removed for a while we will
284430 : // want to change the name of variantT() back to variant()
284431 : // (since the "T" was ment to stand for temporary).
284432 : // When this happens the variantT() will be depricated.
284433 : VariantT
284434 2339660 : SgNonrealSymbol::variantT() const
284435 : {
284436 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
284437 2339660 : ROSE_ASSERT(this != NULL);
284438 2339660 : return V_SgNonrealSymbol;
284439 : }
284440 :
284441 : #if 0
284442 : int
284443 : SgNonrealSymbol::variant() const
284444 : {
284445 : // This function is used in SAGE
284446 : ROSE_ASSERT(this != NULL);
284447 : return NONREAL_SYMBOL;
284448 : }
284449 : #endif
284450 :
284451 : ROSE_DLL_API const char*
284452 0 : SgNonrealSymbol::sage_class_name() const
284453 : {
284454 0 : ROSE_ASSERT(this != NULL);
284455 0 : return "SgNonrealSymbol";
284456 : }
284457 :
284458 : std::string
284459 34576 : SgNonrealSymbol::class_name() const
284460 : {
284461 34576 : ROSE_ASSERT(this != NULL);
284462 34576 : return "SgNonrealSymbol";
284463 : }
284464 :
284465 : // DQ (11/26/2005): Support for visitor pattern mechanims
284466 : // (inferior to ROSE traversal mechanism, experimental).
284467 : void
284468 704852 : SgNonrealSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
284469 : {
284470 704852 : ROSE_ASSERT(this != NULL);
284471 704852 : visitor.visit(this);
284472 704852 : }
284473 :
284474 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
284475 0 : void SgNonrealSymbol::accept (ROSE_VisitorPattern & visitor) {
284476 0 : ROSE_ASSERT(this != NULL);
284477 0 : visitor.visit(this);
284478 0 : }
284479 :
284480 : SgNonrealSymbol*
284481 0 : SgNonrealSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
284482 : {
284483 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
284484 : // This function is currently only supported for the AST used the represent Binary executables.
284485 : if (0 /* isSgAsmNode(this) != NULL */)
284486 : {
284487 : // Support for regex specification.
284488 : std::string prefixCode = "REGEX:";
284489 : addNewAttribute(prefixCode + s,a);
284490 : }
284491 : #endif
284492 :
284493 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
284494 0 : return this;
284495 : }
284496 :
284497 : // *** COMMON CODE SECTION ENDS HERE ***
284498 :
284499 :
284500 : // End of memberFunctionString
284501 : // Start of memberFunctionString
284502 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
284503 :
284504 :
284505 : #if 0
284506 : //! Error checking support
284507 : /*! Verifies the following:
284508 : - working getVariant() member function
284509 : - calls base class's error() member function
284510 : Every class has one of these functions.
284511 : */
284512 : bool
284513 : SgNonrealSymbol::error()
284514 : {
284515 : // Put error checking here
284516 :
284517 : ROSE_ASSERT (this != NULL);
284518 : if (getVariant() != NONREAL_SYMBOL)
284519 : {
284520 : printf ("Error in SgNonrealSymbol::error(): SgNonrealSymbol object has a %s variant \n",
284521 : Cxx_GrammarTerminalNames[getVariant()].name);
284522 : // printf ("Error in SgNonrealSymbol::error() \n");
284523 : ROSE_ABORT();
284524 : }
284525 :
284526 : ROSE_ASSERT (getVariant() == NONREAL_SYMBOL);
284527 : return SgSymbol::error();
284528 : }
284529 : #endif
284530 :
284531 :
284532 :
284533 : // End of memberFunctionString
284534 :
284535 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
284536 :
284537 102126 : SgNonrealSymbol* isSgNonrealSymbol ( SgNode* inputDerivedClassPointer )
284538 : {
284539 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
284540 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
284541 : // So to fix this we return NULL directly when the input is NULL and avoid the
284542 : // dynamic_cast in this case. This is likely a performance improvement as well.
284543 : // return dynamic_cast<SgNonrealSymbol*>(inputDerivedClassPointer);
284544 : // Milind Chabbi (8/28/2013): isSgNonrealSymbol uses table-driven castability instead of c++ default dynamic_cast
284545 : // this improves the running time performance by 10-20%.
284546 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNonrealSymbol*>(inputDerivedClassPointer);
284547 102126 : return IS_SgNonrealSymbol_FAST_MACRO(inputDerivedClassPointer);
284548 : }
284549 :
284550 : // DQ (11/8/2003): Added version of functions taking const pointer
284551 0 : const SgNonrealSymbol* isSgNonrealSymbol ( const SgNode* inputDerivedClassPointer )
284552 : {
284553 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
284554 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
284555 : // So to fix this we return NULL directly when the input is NULL and avoid the
284556 : // dynamic_cast in this case. This is likely a performance improvement as well.
284557 : // return dynamic_cast<const SgNonrealSymbol*>(inputDerivedClassPointer);
284558 : // Milind Chabbi (8/28/2013): isSgNonrealSymbol uses table-driven castability instead of c++ default dynamic_cast
284559 : // this improves the running time performance by 10-20%.
284560 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNonrealSymbol*>(inputDerivedClassPointer);
284561 0 : return IS_SgNonrealSymbol_FAST_MACRO(inputDerivedClassPointer);
284562 : }
284563 :
284564 :
284565 :
284566 : /* #line 284567 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284567 :
284568 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
284569 :
284570 : /**
284571 : \brief Generated destructor
284572 :
284573 : This destructor is automatically generated (by ROSETTA). This destructor
284574 : only frees memory of data members associated with the parts of the current IR node which
284575 : are NOT traversed. Those data members that are part of a traversal can be freed using
284576 : a traversal (calling this destructor on all children in a post-order traversal). Such
284577 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
284578 :
284579 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
284580 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
284581 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
284582 :
284583 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
284584 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
284585 : pointers are not yet implemented to call delete on eash pointer in the container.
284586 : (This could be done by derivation from the STL containers to define containers that
284587 : automatically deleted their members.)
284588 :
284589 : */
284590 20320 : SgNonrealSymbol::~SgNonrealSymbol () {
284591 10160 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
284592 :
284593 :
284594 : // case: not a listType for declaration
284595 10160 : p_declaration = NULL; // non list case
284596 :
284597 : }
284598 :
284599 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
284600 20320 : }
284601 :
284602 :
284603 : /* #line 284604 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284604 :
284605 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
284606 :
284607 : // Generated constructor
284608 49325 : SgNonrealSymbol::SgNonrealSymbol ( SgNonrealDecl* declaration )
284609 49325 : : SgSymbol()
284610 : {
284611 : #ifdef DEBUG
284612 : // printf ("In SgNonrealSymbol::SgNonrealSymbol (SgNonrealDecl* declaration) sage_class_name() = %s \n",sage_class_name());
284613 : #endif
284614 : #if 0
284615 : // debugging information!
284616 : printf ("In SgNonrealSymbol::SgNonrealSymbol (SgNonrealDecl* declaration): this = %p = %s \n",this,this->class_name().c_str());
284617 : #endif
284618 :
284619 49325 : p_declaration = declaration;
284620 :
284621 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
284622 :
284623 : #if 0
284624 : // DQ (7/30/2014): Call a virtual function.
284625 : std::string s = this->class_name();
284626 : #endif
284627 :
284628 : // Test the variant virtual function
284629 : // assert(NONREAL_SYMBOL == variant());
284630 49325 : assert(NONREAL_SYMBOL == this->variant());
284631 49325 : ROSE_ASSERT(NONREAL_SYMBOL == (int)(this->variantT()));
284632 49325 : post_construction_initialization();
284633 :
284634 : // Test the isSgNonrealSymbol() function since it has been problematic
284635 49325 : assert(isSgNonrealSymbol(this) != NULL);
284636 49325 : }
284637 :
284638 : // Generated constructor (all data members)
284639 :
284640 : /* #line 284641 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284641 :
284642 :
284643 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284644 :
284645 :
284646 : // ********************************************************
284647 : // member functions common across all array grammar objects
284648 : // ********************************************************
284649 :
284650 :
284651 :
284652 : /* #line 284653 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284653 :
284654 :
284655 :
284656 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284657 :
284658 : // ********************************************************
284659 : // member functions specific to each node in the grammar
284660 : // ********************************************************
284661 :
284662 :
284663 : /* #line 284664 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284664 :
284665 : // Start of memberFunctionString
284666 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
284667 :
284668 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
284669 :
284670 : SgFunctionDeclaration*
284671 40705500 : SgFunctionSymbol::get_declaration () const
284672 : {
284673 40705500 : ROSE_ASSERT (this != NULL);
284674 :
284675 : #if 0
284676 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
284677 : // used to trigger marking transformations for the token-based unparsing.
284678 : printf ("SgFunctionSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
284679 : #endif
284680 :
284681 40705500 : return p_declaration;
284682 : }
284683 :
284684 : void
284685 7782 : SgFunctionSymbol::set_declaration ( SgFunctionDeclaration* declaration )
284686 : {
284687 7782 : ROSE_ASSERT (this != NULL);
284688 :
284689 : #if 0
284690 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
284691 : // used to trigger marking transformations for the token-based unparsing.
284692 : printf ("SgFunctionSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
284693 : #endif
284694 :
284695 7782 : set_isModified(true);
284696 :
284697 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
284698 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
284699 : {
284700 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
284701 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
284702 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
284703 : ROSE_ASSERT(false);
284704 : #endif
284705 : }
284706 : #endif
284707 7782 : p_declaration = declaration;
284708 7782 : }
284709 :
284710 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
284711 :
284712 :
284713 : // End of memberFunctionString
284714 : // Start of memberFunctionString
284715 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
284716 :
284717 : SgType*
284718 54357 : SgFunctionSymbol::get_type() const
284719 : {
284720 54357 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
284721 : }
284722 :
284723 : #if 0
284724 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
284725 : SgNode*
284726 : SgFunctionSymbol::get_symbol_basis() const
284727 : {
284728 : return get_type();
284729 : }
284730 : #endif
284731 :
284732 :
284733 : // End of memberFunctionString
284734 : // Start of memberFunctionString
284735 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
284736 :
284737 : SgName
284738 58863 : SgFunctionSymbol::get_name() const
284739 : {
284740 58863 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
284741 : }
284742 :
284743 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
284744 : SgNode*
284745 34588200 : SgFunctionSymbol::get_symbol_basis() const
284746 : {
284747 34588200 : return get_declaration();
284748 : }
284749 :
284750 :
284751 : // End of memberFunctionString
284752 : // Start of memberFunctionString
284753 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
284754 :
284755 : // *** COMMON CODE SECTION BEGINS HERE ***
284756 :
284757 : #if 0
284758 : int
284759 : SgFunctionSymbol::getVariant() const
284760 : {
284761 : // This function is used in ROSE while "variant()" is used in SAGE
284762 : assert(this != NULL);
284763 : return variant();
284764 : }
284765 : #endif
284766 :
284767 : // This function is used in ROSE in treeTraversal code
284768 : // eventually replaces getVariant() and variant()
284769 : // though after variant() has been removed for a while we will
284770 : // want to change the name of variantT() back to variant()
284771 : // (since the "T" was ment to stand for temporary).
284772 : // When this happens the variantT() will be depricated.
284773 : VariantT
284774 56446500 : SgFunctionSymbol::variantT() const
284775 : {
284776 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
284777 56446500 : ROSE_ASSERT(this != NULL);
284778 56446500 : return V_SgFunctionSymbol;
284779 : }
284780 :
284781 : #if 0
284782 : int
284783 : SgFunctionSymbol::variant() const
284784 : {
284785 : // This function is used in SAGE
284786 : ROSE_ASSERT(this != NULL);
284787 : return FUNCTION_NAME;
284788 : }
284789 : #endif
284790 :
284791 : ROSE_DLL_API const char*
284792 0 : SgFunctionSymbol::sage_class_name() const
284793 : {
284794 0 : ROSE_ASSERT(this != NULL);
284795 0 : return "SgFunctionSymbol";
284796 : }
284797 :
284798 : std::string
284799 774630 : SgFunctionSymbol::class_name() const
284800 : {
284801 774630 : ROSE_ASSERT(this != NULL);
284802 774630 : return "SgFunctionSymbol";
284803 : }
284804 :
284805 : // DQ (11/26/2005): Support for visitor pattern mechanims
284806 : // (inferior to ROSE traversal mechanism, experimental).
284807 : void
284808 627371 : SgFunctionSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
284809 : {
284810 627371 : ROSE_ASSERT(this != NULL);
284811 627371 : visitor.visit(this);
284812 627371 : }
284813 :
284814 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
284815 0 : void SgFunctionSymbol::accept (ROSE_VisitorPattern & visitor) {
284816 0 : ROSE_ASSERT(this != NULL);
284817 0 : visitor.visit(this);
284818 0 : }
284819 :
284820 : SgFunctionSymbol*
284821 0 : SgFunctionSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
284822 : {
284823 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
284824 : // This function is currently only supported for the AST used the represent Binary executables.
284825 : if (0 /* isSgAsmNode(this) != NULL */)
284826 : {
284827 : // Support for regex specification.
284828 : std::string prefixCode = "REGEX:";
284829 : addNewAttribute(prefixCode + s,a);
284830 : }
284831 : #endif
284832 :
284833 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
284834 0 : return this;
284835 : }
284836 :
284837 : // *** COMMON CODE SECTION ENDS HERE ***
284838 :
284839 :
284840 : // End of memberFunctionString
284841 : // Start of memberFunctionString
284842 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
284843 :
284844 :
284845 : #if 0
284846 : //! Error checking support
284847 : /*! Verifies the following:
284848 : - working getVariant() member function
284849 : - calls base class's error() member function
284850 : Every class has one of these functions.
284851 : */
284852 : bool
284853 : SgFunctionSymbol::error()
284854 : {
284855 : // Put error checking here
284856 :
284857 : ROSE_ASSERT (this != NULL);
284858 : if (getVariant() != FUNCTION_NAME)
284859 : {
284860 : printf ("Error in SgFunctionSymbol::error(): SgFunctionSymbol object has a %s variant \n",
284861 : Cxx_GrammarTerminalNames[getVariant()].name);
284862 : // printf ("Error in SgFunctionSymbol::error() \n");
284863 : ROSE_ABORT();
284864 : }
284865 :
284866 : ROSE_ASSERT (getVariant() == FUNCTION_NAME);
284867 : return SgSymbol::error();
284868 : }
284869 : #endif
284870 :
284871 :
284872 :
284873 : // End of memberFunctionString
284874 :
284875 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
284876 :
284877 3349270 : SgFunctionSymbol* isSgFunctionSymbol ( SgNode* inputDerivedClassPointer )
284878 : {
284879 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
284880 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
284881 : // So to fix this we return NULL directly when the input is NULL and avoid the
284882 : // dynamic_cast in this case. This is likely a performance improvement as well.
284883 : // return dynamic_cast<SgFunctionSymbol*>(inputDerivedClassPointer);
284884 : // Milind Chabbi (8/28/2013): isSgFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
284885 : // this improves the running time performance by 10-20%.
284886 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionSymbol*>(inputDerivedClassPointer);
284887 3349270 : return IS_SgFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
284888 : }
284889 :
284890 : // DQ (11/8/2003): Added version of functions taking const pointer
284891 2531 : const SgFunctionSymbol* isSgFunctionSymbol ( const SgNode* inputDerivedClassPointer )
284892 : {
284893 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
284894 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
284895 : // So to fix this we return NULL directly when the input is NULL and avoid the
284896 : // dynamic_cast in this case. This is likely a performance improvement as well.
284897 : // return dynamic_cast<const SgFunctionSymbol*>(inputDerivedClassPointer);
284898 : // Milind Chabbi (8/28/2013): isSgFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
284899 : // this improves the running time performance by 10-20%.
284900 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionSymbol*>(inputDerivedClassPointer);
284901 2531 : return IS_SgFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
284902 : }
284903 :
284904 :
284905 :
284906 : /* #line 284907 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284907 :
284908 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
284909 :
284910 : /**
284911 : \brief Generated destructor
284912 :
284913 : This destructor is automatically generated (by ROSETTA). This destructor
284914 : only frees memory of data members associated with the parts of the current IR node which
284915 : are NOT traversed. Those data members that are part of a traversal can be freed using
284916 : a traversal (calling this destructor on all children in a post-order traversal). Such
284917 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
284918 :
284919 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
284920 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
284921 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
284922 :
284923 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
284924 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
284925 : pointers are not yet implemented to call delete on eash pointer in the container.
284926 : (This could be done by derivation from the STL containers to define containers that
284927 : automatically deleted their members.)
284928 :
284929 : */
284930 30502 : SgFunctionSymbol::~SgFunctionSymbol () {
284931 18591 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
284932 :
284933 :
284934 : // case: not a listType for declaration
284935 18591 : p_declaration = NULL; // non list case
284936 :
284937 : }
284938 :
284939 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
284940 30502 : }
284941 :
284942 :
284943 : /* #line 284944 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284944 :
284945 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
284946 :
284947 : // Generated constructor
284948 851234 : SgFunctionSymbol::SgFunctionSymbol ( SgFunctionDeclaration* declaration )
284949 851234 : : SgSymbol()
284950 : {
284951 : #ifdef DEBUG
284952 : // printf ("In SgFunctionSymbol::SgFunctionSymbol (SgFunctionDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
284953 : #endif
284954 : #if 0
284955 : // debugging information!
284956 : printf ("In SgFunctionSymbol::SgFunctionSymbol (SgFunctionDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
284957 : #endif
284958 :
284959 851234 : p_declaration = declaration;
284960 :
284961 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
284962 :
284963 : #if 0
284964 : // DQ (7/30/2014): Call a virtual function.
284965 : std::string s = this->class_name();
284966 : #endif
284967 :
284968 : // Test the variant virtual function
284969 : // assert(FUNCTION_NAME == variant());
284970 851234 : assert(FUNCTION_NAME == this->variant());
284971 851234 : ROSE_ASSERT(FUNCTION_NAME == (int)(this->variantT()));
284972 851234 : post_construction_initialization();
284973 :
284974 : // Test the isSgFunctionSymbol() function since it has been problematic
284975 851234 : assert(isSgFunctionSymbol(this) != NULL);
284976 851234 : }
284977 :
284978 : // Generated constructor (all data members)
284979 :
284980 : /* #line 284981 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284981 :
284982 :
284983 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284984 :
284985 :
284986 : // ********************************************************
284987 : // member functions common across all array grammar objects
284988 : // ********************************************************
284989 :
284990 :
284991 :
284992 : /* #line 284993 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
284993 :
284994 :
284995 :
284996 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
284997 :
284998 : // ********************************************************
284999 : // member functions specific to each node in the grammar
285000 : // ********************************************************
285001 :
285002 :
285003 : /* #line 285004 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285004 :
285005 : // Start of memberFunctionString
285006 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285007 :
285008 : SgType*
285009 32175 : SgMemberFunctionSymbol::get_type() const
285010 : {
285011 32175 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
285012 : }
285013 :
285014 : #if 0
285015 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
285016 : SgNode*
285017 : SgMemberFunctionSymbol::get_symbol_basis() const
285018 : {
285019 : return get_type();
285020 : }
285021 : #endif
285022 :
285023 :
285024 : // End of memberFunctionString
285025 : // Start of memberFunctionString
285026 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285027 :
285028 : SgName
285029 42841 : SgMemberFunctionSymbol::get_name() const
285030 : {
285031 42841 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
285032 : }
285033 :
285034 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
285035 : SgNode*
285036 940514 : SgMemberFunctionSymbol::get_symbol_basis() const
285037 : {
285038 940514 : return get_declaration();
285039 : }
285040 :
285041 :
285042 : // End of memberFunctionString
285043 : // Start of memberFunctionString
285044 : /* #line 747 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285045 :
285046 :
285047 : SgMemberFunctionDeclaration*
285048 2006820 : SgMemberFunctionSymbol::get_declaration() const
285049 : {
285050 2006820 : SgFunctionDeclaration* funcionDeclaration = SgFunctionSymbol::get_declaration();
285051 2006820 : if (funcionDeclaration == NULL)
285052 : return NULL;
285053 2006820 : SgMemberFunctionDeclaration* memberFuncionDeclaration = isSgMemberFunctionDeclaration(funcionDeclaration);
285054 2006820 : ROSE_ASSERT(memberFuncionDeclaration != NULL);
285055 2006820 : return memberFuncionDeclaration;
285056 : }
285057 :
285058 : #if 1
285059 : // DQ (6/10/2007): This is now depricated in favor of a more uniform implementation for all symbols.
285060 : // This is used in the hidden list intersection code:
285061 : // astHiddenTypeAndDeclarationLists/HiddenList_Intersection.C
285062 : // and maybe else where as well.
285063 : SgClassDefinition*
285064 18080 : SgMemberFunctionSymbol::get_scope() const
285065 : {
285066 : // DQ (7/28/2007): Call the base class instead
285067 : // ROSE_ASSERT(get_declaration() != NULL);
285068 : // return get_declaration()->get_class_scope();
285069 18080 : SgScopeStatement* scope = SgSymbol::get_scope();
285070 18080 : ROSE_ASSERT(scope != NULL);
285071 18080 : SgClassDefinition* classDefinition = isSgClassDefinition(scope);
285072 :
285073 18080 : if (classDefinition == NULL)
285074 : {
285075 : #if PRINT_DEVELOPER_WARNINGS
285076 : printf ("In SgMemberFunctionSymbol::get_scope() (scope is not a SgClassDefinition, likely a pointer to member function): scope = %p = %s \n",scope,scope->class_name().c_str());
285077 : #endif
285078 : }
285079 : // ROSE_ASSERT(classDefinition != NULL);
285080 :
285081 18080 : return classDefinition;
285082 : }
285083 : #endif
285084 : #if 0
285085 : // DQ (2/6/2007): This returns the basis for the DECLARATION
285086 : SgNode*
285087 : SgMemberFunctionSymbol::get_symbol_basis() const
285088 : {
285089 : return get_declaration();
285090 : }
285091 : #endif
285092 :
285093 :
285094 : // End of memberFunctionString
285095 : // Start of memberFunctionString
285096 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
285097 :
285098 : // *** COMMON CODE SECTION BEGINS HERE ***
285099 :
285100 : #if 0
285101 : int
285102 : SgMemberFunctionSymbol::getVariant() const
285103 : {
285104 : // This function is used in ROSE while "variant()" is used in SAGE
285105 : assert(this != NULL);
285106 : return variant();
285107 : }
285108 : #endif
285109 :
285110 : // This function is used in ROSE in treeTraversal code
285111 : // eventually replaces getVariant() and variant()
285112 : // though after variant() has been removed for a while we will
285113 : // want to change the name of variantT() back to variant()
285114 : // (since the "T" was ment to stand for temporary).
285115 : // When this happens the variantT() will be depricated.
285116 : VariantT
285117 1630930 : SgMemberFunctionSymbol::variantT() const
285118 : {
285119 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
285120 1630930 : ROSE_ASSERT(this != NULL);
285121 1630930 : return V_SgMemberFunctionSymbol;
285122 : }
285123 :
285124 : #if 0
285125 : int
285126 : SgMemberFunctionSymbol::variant() const
285127 : {
285128 : // This function is used in SAGE
285129 : ROSE_ASSERT(this != NULL);
285130 : return MEMBER_FUNC_NAME;
285131 : }
285132 : #endif
285133 :
285134 : ROSE_DLL_API const char*
285135 0 : SgMemberFunctionSymbol::sage_class_name() const
285136 : {
285137 0 : ROSE_ASSERT(this != NULL);
285138 0 : return "SgMemberFunctionSymbol";
285139 : }
285140 :
285141 : std::string
285142 15996 : SgMemberFunctionSymbol::class_name() const
285143 : {
285144 15996 : ROSE_ASSERT(this != NULL);
285145 15996 : return "SgMemberFunctionSymbol";
285146 : }
285147 :
285148 : // DQ (11/26/2005): Support for visitor pattern mechanims
285149 : // (inferior to ROSE traversal mechanism, experimental).
285150 : void
285151 269492 : SgMemberFunctionSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
285152 : {
285153 269492 : ROSE_ASSERT(this != NULL);
285154 269492 : visitor.visit(this);
285155 269492 : }
285156 :
285157 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
285158 0 : void SgMemberFunctionSymbol::accept (ROSE_VisitorPattern & visitor) {
285159 0 : ROSE_ASSERT(this != NULL);
285160 0 : visitor.visit(this);
285161 0 : }
285162 :
285163 : SgMemberFunctionSymbol*
285164 0 : SgMemberFunctionSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
285165 : {
285166 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
285167 : // This function is currently only supported for the AST used the represent Binary executables.
285168 : if (0 /* isSgAsmNode(this) != NULL */)
285169 : {
285170 : // Support for regex specification.
285171 : std::string prefixCode = "REGEX:";
285172 : addNewAttribute(prefixCode + s,a);
285173 : }
285174 : #endif
285175 :
285176 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
285177 0 : return this;
285178 : }
285179 :
285180 : // *** COMMON CODE SECTION ENDS HERE ***
285181 :
285182 :
285183 : // End of memberFunctionString
285184 : // Start of memberFunctionString
285185 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
285186 :
285187 :
285188 : #if 0
285189 : //! Error checking support
285190 : /*! Verifies the following:
285191 : - working getVariant() member function
285192 : - calls base class's error() member function
285193 : Every class has one of these functions.
285194 : */
285195 : bool
285196 : SgMemberFunctionSymbol::error()
285197 : {
285198 : // Put error checking here
285199 :
285200 : ROSE_ASSERT (this != NULL);
285201 : if (getVariant() != MEMBER_FUNC_NAME)
285202 : {
285203 : printf ("Error in SgMemberFunctionSymbol::error(): SgMemberFunctionSymbol object has a %s variant \n",
285204 : Cxx_GrammarTerminalNames[getVariant()].name);
285205 : // printf ("Error in SgMemberFunctionSymbol::error() \n");
285206 : ROSE_ABORT();
285207 : }
285208 :
285209 : ROSE_ASSERT (getVariant() == MEMBER_FUNC_NAME);
285210 : return SgFunctionSymbol::error();
285211 : }
285212 : #endif
285213 :
285214 :
285215 :
285216 : // End of memberFunctionString
285217 :
285218 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
285219 :
285220 78324 : SgMemberFunctionSymbol* isSgMemberFunctionSymbol ( SgNode* inputDerivedClassPointer )
285221 : {
285222 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
285223 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
285224 : // So to fix this we return NULL directly when the input is NULL and avoid the
285225 : // dynamic_cast in this case. This is likely a performance improvement as well.
285226 : // return dynamic_cast<SgMemberFunctionSymbol*>(inputDerivedClassPointer);
285227 : // Milind Chabbi (8/28/2013): isSgMemberFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
285228 : // this improves the running time performance by 10-20%.
285229 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgMemberFunctionSymbol*>(inputDerivedClassPointer);
285230 78324 : return IS_SgMemberFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
285231 : }
285232 :
285233 : // DQ (11/8/2003): Added version of functions taking const pointer
285234 0 : const SgMemberFunctionSymbol* isSgMemberFunctionSymbol ( const SgNode* inputDerivedClassPointer )
285235 : {
285236 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
285237 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
285238 : // So to fix this we return NULL directly when the input is NULL and avoid the
285239 : // dynamic_cast in this case. This is likely a performance improvement as well.
285240 : // return dynamic_cast<const SgMemberFunctionSymbol*>(inputDerivedClassPointer);
285241 : // Milind Chabbi (8/28/2013): isSgMemberFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
285242 : // this improves the running time performance by 10-20%.
285243 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgMemberFunctionSymbol*>(inputDerivedClassPointer);
285244 0 : return IS_SgMemberFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
285245 : }
285246 :
285247 :
285248 :
285249 : /* #line 285250 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285250 :
285251 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
285252 :
285253 : /**
285254 : \brief Generated destructor
285255 :
285256 : This destructor is automatically generated (by ROSETTA). This destructor
285257 : only frees memory of data members associated with the parts of the current IR node which
285258 : are NOT traversed. Those data members that are part of a traversal can be freed using
285259 : a traversal (calling this destructor on all children in a post-order traversal). Such
285260 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
285261 :
285262 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
285263 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
285264 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
285265 :
285266 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
285267 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
285268 : pointers are not yet implemented to call delete on eash pointer in the container.
285269 : (This could be done by derivation from the STL containers to define containers that
285270 : automatically deleted their members.)
285271 :
285272 : */
285273 9906 : SgMemberFunctionSymbol::~SgMemberFunctionSymbol () {
285274 6000 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
285275 :
285276 :
285277 :
285278 : }
285279 :
285280 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
285281 9906 : }
285282 :
285283 :
285284 : /* #line 285285 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285285 :
285286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
285287 :
285288 : // Generated constructor
285289 26258 : SgMemberFunctionSymbol::SgMemberFunctionSymbol ( SgFunctionDeclaration* declaration )
285290 26258 : : SgFunctionSymbol(declaration)
285291 : {
285292 : #ifdef DEBUG
285293 : // printf ("In SgMemberFunctionSymbol::SgMemberFunctionSymbol (SgFunctionDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
285294 : #endif
285295 : #if 0
285296 : // debugging information!
285297 : printf ("In SgMemberFunctionSymbol::SgMemberFunctionSymbol (SgFunctionDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
285298 : #endif
285299 :
285300 :
285301 :
285302 : #if 0
285303 : // DQ (7/30/2014): Call a virtual function.
285304 : std::string s = this->class_name();
285305 : #endif
285306 :
285307 : // Test the variant virtual function
285308 : // assert(MEMBER_FUNC_NAME == variant());
285309 26258 : assert(MEMBER_FUNC_NAME == this->variant());
285310 26258 : ROSE_ASSERT(MEMBER_FUNC_NAME == (int)(this->variantT()));
285311 26258 : post_construction_initialization();
285312 :
285313 : // Test the isSgMemberFunctionSymbol() function since it has been problematic
285314 26258 : assert(isSgMemberFunctionSymbol(this) != NULL);
285315 26258 : }
285316 :
285317 : // Generated constructor (all data members)
285318 :
285319 : /* #line 285320 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285320 :
285321 :
285322 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
285323 :
285324 :
285325 : // ********************************************************
285326 : // member functions common across all array grammar objects
285327 : // ********************************************************
285328 :
285329 :
285330 :
285331 : /* #line 285332 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285332 :
285333 :
285334 :
285335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
285336 :
285337 : // ********************************************************
285338 : // member functions specific to each node in the grammar
285339 : // ********************************************************
285340 :
285341 :
285342 : /* #line 285343 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285343 :
285344 : // Start of memberFunctionString
285345 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285346 :
285347 : SgType*
285348 47601 : SgTemplateMemberFunctionSymbol::get_type() const
285349 : {
285350 47601 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
285351 : }
285352 :
285353 : #if 0
285354 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
285355 : SgNode*
285356 : SgTemplateMemberFunctionSymbol::get_symbol_basis() const
285357 : {
285358 : return get_type();
285359 : }
285360 : #endif
285361 :
285362 :
285363 : // End of memberFunctionString
285364 : // Start of memberFunctionString
285365 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285366 :
285367 : SgName
285368 7350 : SgTemplateMemberFunctionSymbol::get_name() const
285369 : {
285370 7350 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
285371 : }
285372 :
285373 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
285374 : SgNode*
285375 481221 : SgTemplateMemberFunctionSymbol::get_symbol_basis() const
285376 : {
285377 481221 : return get_declaration();
285378 : }
285379 :
285380 :
285381 : // End of memberFunctionString
285382 : // Start of memberFunctionString
285383 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
285384 :
285385 : // *** COMMON CODE SECTION BEGINS HERE ***
285386 :
285387 : #if 0
285388 : int
285389 : SgTemplateMemberFunctionSymbol::getVariant() const
285390 : {
285391 : // This function is used in ROSE while "variant()" is used in SAGE
285392 : assert(this != NULL);
285393 : return variant();
285394 : }
285395 : #endif
285396 :
285397 : // This function is used in ROSE in treeTraversal code
285398 : // eventually replaces getVariant() and variant()
285399 : // though after variant() has been removed for a while we will
285400 : // want to change the name of variantT() back to variant()
285401 : // (since the "T" was ment to stand for temporary).
285402 : // When this happens the variantT() will be depricated.
285403 : VariantT
285404 1432690 : SgTemplateMemberFunctionSymbol::variantT() const
285405 : {
285406 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
285407 1432690 : ROSE_ASSERT(this != NULL);
285408 1432690 : return V_SgTemplateMemberFunctionSymbol;
285409 : }
285410 :
285411 : #if 0
285412 : int
285413 : SgTemplateMemberFunctionSymbol::variant() const
285414 : {
285415 : // This function is used in SAGE
285416 : ROSE_ASSERT(this != NULL);
285417 : return TEMPLATE_MEMBER_FUNC_NAME;
285418 : }
285419 : #endif
285420 :
285421 : ROSE_DLL_API const char*
285422 0 : SgTemplateMemberFunctionSymbol::sage_class_name() const
285423 : {
285424 0 : ROSE_ASSERT(this != NULL);
285425 0 : return "SgTemplateMemberFunctionSymbol";
285426 : }
285427 :
285428 : std::string
285429 6871 : SgTemplateMemberFunctionSymbol::class_name() const
285430 : {
285431 6871 : ROSE_ASSERT(this != NULL);
285432 6871 : return "SgTemplateMemberFunctionSymbol";
285433 : }
285434 :
285435 : // DQ (11/26/2005): Support for visitor pattern mechanims
285436 : // (inferior to ROSE traversal mechanism, experimental).
285437 : void
285438 148443 : SgTemplateMemberFunctionSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
285439 : {
285440 148443 : ROSE_ASSERT(this != NULL);
285441 148443 : visitor.visit(this);
285442 148443 : }
285443 :
285444 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
285445 0 : void SgTemplateMemberFunctionSymbol::accept (ROSE_VisitorPattern & visitor) {
285446 0 : ROSE_ASSERT(this != NULL);
285447 0 : visitor.visit(this);
285448 0 : }
285449 :
285450 : SgTemplateMemberFunctionSymbol*
285451 0 : SgTemplateMemberFunctionSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
285452 : {
285453 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
285454 : // This function is currently only supported for the AST used the represent Binary executables.
285455 : if (0 /* isSgAsmNode(this) != NULL */)
285456 : {
285457 : // Support for regex specification.
285458 : std::string prefixCode = "REGEX:";
285459 : addNewAttribute(prefixCode + s,a);
285460 : }
285461 : #endif
285462 :
285463 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
285464 0 : return this;
285465 : }
285466 :
285467 : // *** COMMON CODE SECTION ENDS HERE ***
285468 :
285469 :
285470 : // End of memberFunctionString
285471 : // Start of memberFunctionString
285472 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
285473 :
285474 :
285475 : #if 0
285476 : //! Error checking support
285477 : /*! Verifies the following:
285478 : - working getVariant() member function
285479 : - calls base class's error() member function
285480 : Every class has one of these functions.
285481 : */
285482 : bool
285483 : SgTemplateMemberFunctionSymbol::error()
285484 : {
285485 : // Put error checking here
285486 :
285487 : ROSE_ASSERT (this != NULL);
285488 : if (getVariant() != TEMPLATE_MEMBER_FUNC_NAME)
285489 : {
285490 : printf ("Error in SgTemplateMemberFunctionSymbol::error(): SgTemplateMemberFunctionSymbol object has a %s variant \n",
285491 : Cxx_GrammarTerminalNames[getVariant()].name);
285492 : // printf ("Error in SgTemplateMemberFunctionSymbol::error() \n");
285493 : ROSE_ABORT();
285494 : }
285495 :
285496 : ROSE_ASSERT (getVariant() == TEMPLATE_MEMBER_FUNC_NAME);
285497 : return SgMemberFunctionSymbol::error();
285498 : }
285499 : #endif
285500 :
285501 :
285502 :
285503 : // End of memberFunctionString
285504 :
285505 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
285506 :
285507 98601 : SgTemplateMemberFunctionSymbol* isSgTemplateMemberFunctionSymbol ( SgNode* inputDerivedClassPointer )
285508 : {
285509 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
285510 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
285511 : // So to fix this we return NULL directly when the input is NULL and avoid the
285512 : // dynamic_cast in this case. This is likely a performance improvement as well.
285513 : // return dynamic_cast<SgTemplateMemberFunctionSymbol*>(inputDerivedClassPointer);
285514 : // Milind Chabbi (8/28/2013): isSgTemplateMemberFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
285515 : // this improves the running time performance by 10-20%.
285516 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateMemberFunctionSymbol*>(inputDerivedClassPointer);
285517 98601 : return IS_SgTemplateMemberFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
285518 : }
285519 :
285520 : // DQ (11/8/2003): Added version of functions taking const pointer
285521 0 : const SgTemplateMemberFunctionSymbol* isSgTemplateMemberFunctionSymbol ( const SgNode* inputDerivedClassPointer )
285522 : {
285523 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
285524 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
285525 : // So to fix this we return NULL directly when the input is NULL and avoid the
285526 : // dynamic_cast in this case. This is likely a performance improvement as well.
285527 : // return dynamic_cast<const SgTemplateMemberFunctionSymbol*>(inputDerivedClassPointer);
285528 : // Milind Chabbi (8/28/2013): isSgTemplateMemberFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
285529 : // this improves the running time performance by 10-20%.
285530 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateMemberFunctionSymbol*>(inputDerivedClassPointer);
285531 0 : return IS_SgTemplateMemberFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
285532 : }
285533 :
285534 :
285535 :
285536 : /* #line 285537 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285537 :
285538 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
285539 :
285540 : /**
285541 : \brief Generated destructor
285542 :
285543 : This destructor is automatically generated (by ROSETTA). This destructor
285544 : only frees memory of data members associated with the parts of the current IR node which
285545 : are NOT traversed. Those data members that are part of a traversal can be freed using
285546 : a traversal (calling this destructor on all children in a post-order traversal). Such
285547 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
285548 :
285549 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
285550 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
285551 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
285552 :
285553 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
285554 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
285555 : pointers are not yet implemented to call delete on eash pointer in the container.
285556 : (This could be done by derivation from the STL containers to define containers that
285557 : automatically deleted their members.)
285558 :
285559 : */
285560 4188 : SgTemplateMemberFunctionSymbol::~SgTemplateMemberFunctionSymbol () {
285561 2094 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
285562 :
285563 :
285564 :
285565 : }
285566 :
285567 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
285568 4188 : }
285569 :
285570 :
285571 : /* #line 285572 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285572 :
285573 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
285574 :
285575 : // Generated constructor
285576 9830 : SgTemplateMemberFunctionSymbol::SgTemplateMemberFunctionSymbol ( SgFunctionDeclaration* declaration )
285577 9830 : : SgMemberFunctionSymbol(declaration)
285578 : {
285579 : #ifdef DEBUG
285580 : // printf ("In SgTemplateMemberFunctionSymbol::SgTemplateMemberFunctionSymbol (SgFunctionDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
285581 : #endif
285582 : #if 0
285583 : // debugging information!
285584 : printf ("In SgTemplateMemberFunctionSymbol::SgTemplateMemberFunctionSymbol (SgFunctionDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
285585 : #endif
285586 :
285587 :
285588 :
285589 : #if 0
285590 : // DQ (7/30/2014): Call a virtual function.
285591 : std::string s = this->class_name();
285592 : #endif
285593 :
285594 : // Test the variant virtual function
285595 : // assert(TEMPLATE_MEMBER_FUNC_NAME == variant());
285596 9830 : assert(TEMPLATE_MEMBER_FUNC_NAME == this->variant());
285597 9830 : ROSE_ASSERT(TEMPLATE_MEMBER_FUNC_NAME == (int)(this->variantT()));
285598 9830 : post_construction_initialization();
285599 :
285600 : // Test the isSgTemplateMemberFunctionSymbol() function since it has been problematic
285601 9830 : assert(isSgTemplateMemberFunctionSymbol(this) != NULL);
285602 9830 : }
285603 :
285604 : // Generated constructor (all data members)
285605 :
285606 : /* #line 285607 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285607 :
285608 :
285609 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
285610 :
285611 :
285612 : // ********************************************************
285613 : // member functions common across all array grammar objects
285614 : // ********************************************************
285615 :
285616 :
285617 :
285618 : /* #line 285619 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285619 :
285620 :
285621 :
285622 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
285623 :
285624 : // ********************************************************
285625 : // member functions specific to each node in the grammar
285626 : // ********************************************************
285627 :
285628 :
285629 : /* #line 285630 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285630 :
285631 : // Start of memberFunctionString
285632 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285633 :
285634 : SgType*
285635 19041 : SgTemplateFunctionSymbol::get_type() const
285636 : {
285637 19041 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
285638 : }
285639 :
285640 : #if 0
285641 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
285642 : SgNode*
285643 : SgTemplateFunctionSymbol::get_symbol_basis() const
285644 : {
285645 : return get_type();
285646 : }
285647 : #endif
285648 :
285649 :
285650 : // End of memberFunctionString
285651 : // Start of memberFunctionString
285652 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
285653 :
285654 : SgName
285655 1844 : SgTemplateFunctionSymbol::get_name() const
285656 : {
285657 1844 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
285658 : }
285659 :
285660 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
285661 : SgNode*
285662 233743 : SgTemplateFunctionSymbol::get_symbol_basis() const
285663 : {
285664 233743 : return get_declaration();
285665 : }
285666 :
285667 :
285668 : // End of memberFunctionString
285669 : // Start of memberFunctionString
285670 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
285671 :
285672 : // *** COMMON CODE SECTION BEGINS HERE ***
285673 :
285674 : #if 0
285675 : int
285676 : SgTemplateFunctionSymbol::getVariant() const
285677 : {
285678 : // This function is used in ROSE while "variant()" is used in SAGE
285679 : assert(this != NULL);
285680 : return variant();
285681 : }
285682 : #endif
285683 :
285684 : // This function is used in ROSE in treeTraversal code
285685 : // eventually replaces getVariant() and variant()
285686 : // though after variant() has been removed for a while we will
285687 : // want to change the name of variantT() back to variant()
285688 : // (since the "T" was ment to stand for temporary).
285689 : // When this happens the variantT() will be depricated.
285690 : VariantT
285691 760597 : SgTemplateFunctionSymbol::variantT() const
285692 : {
285693 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
285694 760597 : ROSE_ASSERT(this != NULL);
285695 760597 : return V_SgTemplateFunctionSymbol;
285696 : }
285697 :
285698 : #if 0
285699 : int
285700 : SgTemplateFunctionSymbol::variant() const
285701 : {
285702 : // This function is used in SAGE
285703 : ROSE_ASSERT(this != NULL);
285704 : return TEMPLATE_FUNC_NAME;
285705 : }
285706 : #endif
285707 :
285708 : ROSE_DLL_API const char*
285709 0 : SgTemplateFunctionSymbol::sage_class_name() const
285710 : {
285711 0 : ROSE_ASSERT(this != NULL);
285712 0 : return "SgTemplateFunctionSymbol";
285713 : }
285714 :
285715 : std::string
285716 2368 : SgTemplateFunctionSymbol::class_name() const
285717 : {
285718 2368 : ROSE_ASSERT(this != NULL);
285719 2368 : return "SgTemplateFunctionSymbol";
285720 : }
285721 :
285722 : // DQ (11/26/2005): Support for visitor pattern mechanims
285723 : // (inferior to ROSE traversal mechanism, experimental).
285724 : void
285725 47426 : SgTemplateFunctionSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
285726 : {
285727 47426 : ROSE_ASSERT(this != NULL);
285728 47426 : visitor.visit(this);
285729 47426 : }
285730 :
285731 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
285732 0 : void SgTemplateFunctionSymbol::accept (ROSE_VisitorPattern & visitor) {
285733 0 : ROSE_ASSERT(this != NULL);
285734 0 : visitor.visit(this);
285735 0 : }
285736 :
285737 : SgTemplateFunctionSymbol*
285738 0 : SgTemplateFunctionSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
285739 : {
285740 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
285741 : // This function is currently only supported for the AST used the represent Binary executables.
285742 : if (0 /* isSgAsmNode(this) != NULL */)
285743 : {
285744 : // Support for regex specification.
285745 : std::string prefixCode = "REGEX:";
285746 : addNewAttribute(prefixCode + s,a);
285747 : }
285748 : #endif
285749 :
285750 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
285751 0 : return this;
285752 : }
285753 :
285754 : // *** COMMON CODE SECTION ENDS HERE ***
285755 :
285756 :
285757 : // End of memberFunctionString
285758 : // Start of memberFunctionString
285759 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
285760 :
285761 :
285762 : #if 0
285763 : //! Error checking support
285764 : /*! Verifies the following:
285765 : - working getVariant() member function
285766 : - calls base class's error() member function
285767 : Every class has one of these functions.
285768 : */
285769 : bool
285770 : SgTemplateFunctionSymbol::error()
285771 : {
285772 : // Put error checking here
285773 :
285774 : ROSE_ASSERT (this != NULL);
285775 : if (getVariant() != TEMPLATE_FUNC_NAME)
285776 : {
285777 : printf ("Error in SgTemplateFunctionSymbol::error(): SgTemplateFunctionSymbol object has a %s variant \n",
285778 : Cxx_GrammarTerminalNames[getVariant()].name);
285779 : // printf ("Error in SgTemplateFunctionSymbol::error() \n");
285780 : ROSE_ABORT();
285781 : }
285782 :
285783 : ROSE_ASSERT (getVariant() == TEMPLATE_FUNC_NAME);
285784 : return SgFunctionSymbol::error();
285785 : }
285786 : #endif
285787 :
285788 :
285789 :
285790 : // End of memberFunctionString
285791 :
285792 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
285793 :
285794 1476760 : SgTemplateFunctionSymbol* isSgTemplateFunctionSymbol ( SgNode* inputDerivedClassPointer )
285795 : {
285796 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
285797 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
285798 : // So to fix this we return NULL directly when the input is NULL and avoid the
285799 : // dynamic_cast in this case. This is likely a performance improvement as well.
285800 : // return dynamic_cast<SgTemplateFunctionSymbol*>(inputDerivedClassPointer);
285801 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
285802 : // this improves the running time performance by 10-20%.
285803 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateFunctionSymbol*>(inputDerivedClassPointer);
285804 1476760 : return IS_SgTemplateFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
285805 : }
285806 :
285807 : // DQ (11/8/2003): Added version of functions taking const pointer
285808 0 : const SgTemplateFunctionSymbol* isSgTemplateFunctionSymbol ( const SgNode* inputDerivedClassPointer )
285809 : {
285810 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
285811 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
285812 : // So to fix this we return NULL directly when the input is NULL and avoid the
285813 : // dynamic_cast in this case. This is likely a performance improvement as well.
285814 : // return dynamic_cast<const SgTemplateFunctionSymbol*>(inputDerivedClassPointer);
285815 : // Milind Chabbi (8/28/2013): isSgTemplateFunctionSymbol uses table-driven castability instead of c++ default dynamic_cast
285816 : // this improves the running time performance by 10-20%.
285817 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateFunctionSymbol*>(inputDerivedClassPointer);
285818 0 : return IS_SgTemplateFunctionSymbol_FAST_MACRO(inputDerivedClassPointer);
285819 : }
285820 :
285821 :
285822 :
285823 : /* #line 285824 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285824 :
285825 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
285826 :
285827 : /**
285828 : \brief Generated destructor
285829 :
285830 : This destructor is automatically generated (by ROSETTA). This destructor
285831 : only frees memory of data members associated with the parts of the current IR node which
285832 : are NOT traversed. Those data members that are part of a traversal can be freed using
285833 : a traversal (calling this destructor on all children in a post-order traversal). Such
285834 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
285835 :
285836 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
285837 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
285838 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
285839 :
285840 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
285841 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
285842 : pointers are not yet implemented to call delete on eash pointer in the container.
285843 : (This could be done by derivation from the STL containers to define containers that
285844 : automatically deleted their members.)
285845 :
285846 : */
285847 1360 : SgTemplateFunctionSymbol::~SgTemplateFunctionSymbol () {
285848 680 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
285849 :
285850 :
285851 :
285852 : }
285853 :
285854 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
285855 1360 : }
285856 :
285857 :
285858 : /* #line 285859 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285859 :
285860 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
285861 :
285862 : // Generated constructor
285863 3423 : SgTemplateFunctionSymbol::SgTemplateFunctionSymbol ( SgFunctionDeclaration* declaration )
285864 3423 : : SgFunctionSymbol(declaration)
285865 : {
285866 : #ifdef DEBUG
285867 : // printf ("In SgTemplateFunctionSymbol::SgTemplateFunctionSymbol (SgFunctionDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
285868 : #endif
285869 : #if 0
285870 : // debugging information!
285871 : printf ("In SgTemplateFunctionSymbol::SgTemplateFunctionSymbol (SgFunctionDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
285872 : #endif
285873 :
285874 :
285875 :
285876 : #if 0
285877 : // DQ (7/30/2014): Call a virtual function.
285878 : std::string s = this->class_name();
285879 : #endif
285880 :
285881 : // Test the variant virtual function
285882 : // assert(TEMPLATE_FUNC_NAME == variant());
285883 3423 : assert(TEMPLATE_FUNC_NAME == this->variant());
285884 3423 : ROSE_ASSERT(TEMPLATE_FUNC_NAME == (int)(this->variantT()));
285885 3423 : post_construction_initialization();
285886 :
285887 : // Test the isSgTemplateFunctionSymbol() function since it has been problematic
285888 3423 : assert(isSgTemplateFunctionSymbol(this) != NULL);
285889 3423 : }
285890 :
285891 : // Generated constructor (all data members)
285892 :
285893 : /* #line 285894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285894 :
285895 :
285896 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
285897 :
285898 :
285899 : // ********************************************************
285900 : // member functions common across all array grammar objects
285901 : // ********************************************************
285902 :
285903 :
285904 :
285905 : /* #line 285906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285906 :
285907 :
285908 :
285909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
285910 :
285911 : // ********************************************************
285912 : // member functions specific to each node in the grammar
285913 : // ********************************************************
285914 :
285915 :
285916 : /* #line 285917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
285917 :
285918 : // Start of memberFunctionString
285919 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
285920 :
285921 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
285922 :
285923 : SgSymbol*
285924 0 : SgRenameSymbol::get_original_symbol () const
285925 : {
285926 0 : ROSE_ASSERT (this != NULL);
285927 :
285928 : #if 0
285929 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
285930 : // used to trigger marking transformations for the token-based unparsing.
285931 : printf ("SgRenameSymbol::get_original_symbol = %p = %s \n",this,this->class_name().c_str());
285932 : #endif
285933 :
285934 0 : return p_original_symbol;
285935 : }
285936 :
285937 : void
285938 0 : SgRenameSymbol::set_original_symbol ( SgSymbol* original_symbol )
285939 : {
285940 0 : ROSE_ASSERT (this != NULL);
285941 :
285942 : #if 0
285943 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
285944 : // used to trigger marking transformations for the token-based unparsing.
285945 : printf ("SgRenameSymbol::set_original_symbol = %p = %s \n",this,this->class_name().c_str());
285946 : #endif
285947 :
285948 0 : set_isModified(true);
285949 :
285950 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
285951 : if (p_original_symbol != NULL && original_symbol != NULL && p_original_symbol != original_symbol)
285952 : {
285953 : printf ("Warning: original_symbol = %p overwriting valid pointer p_original_symbol = %p \n",original_symbol,p_original_symbol);
285954 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
285955 : printf ("Error fails assertion (p_original_symbol != NULL && original_symbol != NULL && p_original_symbol != original_symbol) is false\n");
285956 : ROSE_ASSERT(false);
285957 : #endif
285958 : }
285959 : #endif
285960 0 : p_original_symbol = original_symbol;
285961 0 : }
285962 :
285963 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
285964 :
285965 :
285966 : // End of memberFunctionString
285967 : // Start of memberFunctionString
285968 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
285969 :
285970 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
285971 :
285972 : SgName
285973 0 : SgRenameSymbol::get_new_name () const
285974 : {
285975 0 : ROSE_ASSERT (this != NULL);
285976 :
285977 : #if 0
285978 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
285979 : // used to trigger marking transformations for the token-based unparsing.
285980 : printf ("SgRenameSymbol::get_new_name = %p = %s \n",this,this->class_name().c_str());
285981 : #endif
285982 :
285983 0 : return p_new_name;
285984 : }
285985 :
285986 : void
285987 0 : SgRenameSymbol::set_new_name ( SgName new_name )
285988 : {
285989 0 : ROSE_ASSERT (this != NULL);
285990 :
285991 : #if 0
285992 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
285993 : // used to trigger marking transformations for the token-based unparsing.
285994 : printf ("SgRenameSymbol::set_new_name = %p = %s \n",this,this->class_name().c_str());
285995 : #endif
285996 :
285997 0 : set_isModified(true);
285998 :
285999 0 : p_new_name = new_name;
286000 0 : }
286001 :
286002 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
286003 :
286004 :
286005 : // End of memberFunctionString
286006 : // Start of memberFunctionString
286007 : /* #line 1182 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
286008 :
286009 : SgName
286010 0 : SgRenameSymbol::get_name() const
286011 : {
286012 0 : ROSE_ASSERT(p_original_symbol != NULL);
286013 :
286014 : #if 0
286015 : ROSE_ASSERT(get_isRenamed() == true);
286016 :
286017 : SgName name;
286018 : if (get_isRenamed() == true)
286019 : {
286020 : name = get_new_name();
286021 : }
286022 : else
286023 : {
286024 : name = get_original_symbol()->get_name();
286025 : }
286026 : #else
286027 : // This is a difference between SgAliasSymbol and SgRenameSymbol
286028 0 : SgName name = get_new_name();
286029 : #endif
286030 :
286031 0 : return name;
286032 : }
286033 :
286034 : SgNode*
286035 0 : SgRenameSymbol::get_symbol_basis() const
286036 : {
286037 0 : ROSE_ASSERT(p_original_symbol != NULL);
286038 0 : return get_original_symbol()->get_symbol_basis();
286039 : }
286040 :
286041 : SgType*
286042 0 : SgRenameSymbol::get_type() const
286043 : {
286044 0 : ROSE_ASSERT(p_original_symbol != NULL);
286045 0 : return get_original_symbol()->get_type();
286046 : }
286047 :
286048 : #if 0
286049 : // DQ (10/11/2008): This is derived from SgFunctionSymbol and so we don't require this member function?
286050 :
286051 : SgSymbol*
286052 : SgRenameSymbol::get_base() const
286053 : {
286054 : // DQ (10/9/2008): For a chain of aliased symbols, this function returns the last (non-aliased) symbol.
286055 : SgSymbol* nonAliasedSymbol = get_alias();
286056 : ROSE_ASSERT(nonAliasedSymbol != NULL);
286057 :
286058 : XXXXX
286059 :
286060 : This is not FINISHED!!!
286061 :
286062 : XXXXX
286063 :
286064 : SgAliasSymbol* aliasSymbol = isSgAliasSymbol (get_alias());
286065 : SgRenameSymbol* renameSymbol = isSgRenameSymbol(get_alias());
286066 : while (aliasSymbol != NULL || renameSymbol != NULL)
286067 : {
286068 : // This may be any symbol (even a SgAliasSymbol)
286069 : if (aliasSymbol != NULL)
286070 : {
286071 : nonAliasedSymbol = aliasSymbol->get_alias();
286072 : }
286073 : else
286074 : {
286075 : if (renameSymbol != NULL)
286076 : {
286077 : nonAliasedSymbol = renameSymbol->get_alias();
286078 : }
286079 : else
286080 : {
286081 : printf ("Error: aliasSymbol == NULL and renameSymbol == NULL \n");
286082 : ROSE_ASSERT(false);
286083 : }
286084 : }
286085 :
286086 : // Advance in the chain to the next SgAliasSymbol symbol
286087 : aliasSymbol = isSgAliasSymbol(aliasSymbol->get_alias());
286088 : }
286089 :
286090 : // Every chain of aliased symbols should have a non-aliased symbol at the end!
286091 : ROSE_ASSERT(nonAliasedSymbol != NULL);
286092 : return nonAliasedSymbol;
286093 : }
286094 : #endif
286095 :
286096 :
286097 :
286098 : // End of memberFunctionString
286099 : // Start of memberFunctionString
286100 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
286101 :
286102 : // *** COMMON CODE SECTION BEGINS HERE ***
286103 :
286104 : #if 0
286105 : int
286106 : SgRenameSymbol::getVariant() const
286107 : {
286108 : // This function is used in ROSE while "variant()" is used in SAGE
286109 : assert(this != NULL);
286110 : return variant();
286111 : }
286112 : #endif
286113 :
286114 : // This function is used in ROSE in treeTraversal code
286115 : // eventually replaces getVariant() and variant()
286116 : // though after variant() has been removed for a while we will
286117 : // want to change the name of variantT() back to variant()
286118 : // (since the "T" was ment to stand for temporary).
286119 : // When this happens the variantT() will be depricated.
286120 : VariantT
286121 0 : SgRenameSymbol::variantT() const
286122 : {
286123 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
286124 0 : ROSE_ASSERT(this != NULL);
286125 0 : return V_SgRenameSymbol;
286126 : }
286127 :
286128 : #if 0
286129 : int
286130 : SgRenameSymbol::variant() const
286131 : {
286132 : // This function is used in SAGE
286133 : ROSE_ASSERT(this != NULL);
286134 : return RENAME_SYMBOL;
286135 : }
286136 : #endif
286137 :
286138 : ROSE_DLL_API const char*
286139 0 : SgRenameSymbol::sage_class_name() const
286140 : {
286141 0 : ROSE_ASSERT(this != NULL);
286142 0 : return "SgRenameSymbol";
286143 : }
286144 :
286145 : std::string
286146 0 : SgRenameSymbol::class_name() const
286147 : {
286148 0 : ROSE_ASSERT(this != NULL);
286149 0 : return "SgRenameSymbol";
286150 : }
286151 :
286152 : // DQ (11/26/2005): Support for visitor pattern mechanims
286153 : // (inferior to ROSE traversal mechanism, experimental).
286154 : void
286155 0 : SgRenameSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
286156 : {
286157 0 : ROSE_ASSERT(this != NULL);
286158 0 : visitor.visit(this);
286159 0 : }
286160 :
286161 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
286162 0 : void SgRenameSymbol::accept (ROSE_VisitorPattern & visitor) {
286163 0 : ROSE_ASSERT(this != NULL);
286164 0 : visitor.visit(this);
286165 0 : }
286166 :
286167 : SgRenameSymbol*
286168 0 : SgRenameSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
286169 : {
286170 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
286171 : // This function is currently only supported for the AST used the represent Binary executables.
286172 : if (0 /* isSgAsmNode(this) != NULL */)
286173 : {
286174 : // Support for regex specification.
286175 : std::string prefixCode = "REGEX:";
286176 : addNewAttribute(prefixCode + s,a);
286177 : }
286178 : #endif
286179 :
286180 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
286181 0 : return this;
286182 : }
286183 :
286184 : // *** COMMON CODE SECTION ENDS HERE ***
286185 :
286186 :
286187 : // End of memberFunctionString
286188 : // Start of memberFunctionString
286189 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
286190 :
286191 :
286192 : #if 0
286193 : //! Error checking support
286194 : /*! Verifies the following:
286195 : - working getVariant() member function
286196 : - calls base class's error() member function
286197 : Every class has one of these functions.
286198 : */
286199 : bool
286200 : SgRenameSymbol::error()
286201 : {
286202 : // Put error checking here
286203 :
286204 : ROSE_ASSERT (this != NULL);
286205 : if (getVariant() != RENAME_SYMBOL)
286206 : {
286207 : printf ("Error in SgRenameSymbol::error(): SgRenameSymbol object has a %s variant \n",
286208 : Cxx_GrammarTerminalNames[getVariant()].name);
286209 : // printf ("Error in SgRenameSymbol::error() \n");
286210 : ROSE_ABORT();
286211 : }
286212 :
286213 : ROSE_ASSERT (getVariant() == RENAME_SYMBOL);
286214 : return SgFunctionSymbol::error();
286215 : }
286216 : #endif
286217 :
286218 :
286219 :
286220 : // End of memberFunctionString
286221 :
286222 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
286223 :
286224 0 : SgRenameSymbol* isSgRenameSymbol ( SgNode* inputDerivedClassPointer )
286225 : {
286226 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
286227 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
286228 : // So to fix this we return NULL directly when the input is NULL and avoid the
286229 : // dynamic_cast in this case. This is likely a performance improvement as well.
286230 : // return dynamic_cast<SgRenameSymbol*>(inputDerivedClassPointer);
286231 : // Milind Chabbi (8/28/2013): isSgRenameSymbol uses table-driven castability instead of c++ default dynamic_cast
286232 : // this improves the running time performance by 10-20%.
286233 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgRenameSymbol*>(inputDerivedClassPointer);
286234 0 : return IS_SgRenameSymbol_FAST_MACRO(inputDerivedClassPointer);
286235 : }
286236 :
286237 : // DQ (11/8/2003): Added version of functions taking const pointer
286238 0 : const SgRenameSymbol* isSgRenameSymbol ( const SgNode* inputDerivedClassPointer )
286239 : {
286240 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
286241 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
286242 : // So to fix this we return NULL directly when the input is NULL and avoid the
286243 : // dynamic_cast in this case. This is likely a performance improvement as well.
286244 : // return dynamic_cast<const SgRenameSymbol*>(inputDerivedClassPointer);
286245 : // Milind Chabbi (8/28/2013): isSgRenameSymbol uses table-driven castability instead of c++ default dynamic_cast
286246 : // this improves the running time performance by 10-20%.
286247 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgRenameSymbol*>(inputDerivedClassPointer);
286248 0 : return IS_SgRenameSymbol_FAST_MACRO(inputDerivedClassPointer);
286249 : }
286250 :
286251 :
286252 :
286253 : /* #line 286254 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286254 :
286255 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
286256 :
286257 : /**
286258 : \brief Generated destructor
286259 :
286260 : This destructor is automatically generated (by ROSETTA). This destructor
286261 : only frees memory of data members associated with the parts of the current IR node which
286262 : are NOT traversed. Those data members that are part of a traversal can be freed using
286263 : a traversal (calling this destructor on all children in a post-order traversal). Such
286264 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
286265 :
286266 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
286267 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
286268 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
286269 :
286270 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
286271 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
286272 : pointers are not yet implemented to call delete on eash pointer in the container.
286273 : (This could be done by derivation from the STL containers to define containers that
286274 : automatically deleted their members.)
286275 :
286276 : */
286277 0 : SgRenameSymbol::~SgRenameSymbol () {
286278 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
286279 :
286280 :
286281 : // case: not a listType for original_symbol
286282 0 : p_original_symbol = NULL; // non list case
286283 : // case: not a listType for new_name
286284 0 : p_new_name = ""; // non list case
286285 :
286286 : }
286287 :
286288 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
286289 0 : }
286290 :
286291 :
286292 : /* #line 286293 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286293 :
286294 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
286295 :
286296 : // Generated constructor
286297 0 : SgRenameSymbol::SgRenameSymbol ( SgFunctionDeclaration* declaration, SgSymbol* original_symbol, SgName new_name )
286298 0 : : SgFunctionSymbol(declaration)
286299 : {
286300 : #ifdef DEBUG
286301 : // printf ("In SgRenameSymbol::SgRenameSymbol (SgFunctionDeclaration* declaration, SgSymbol* original_symbol, SgName new_name) sage_class_name() = %s \n",sage_class_name());
286302 : #endif
286303 : #if 0
286304 : // debugging information!
286305 : printf ("In SgRenameSymbol::SgRenameSymbol (SgFunctionDeclaration* declaration, SgSymbol* original_symbol, SgName new_name): this = %p = %s \n",this,this->class_name().c_str());
286306 : #endif
286307 :
286308 0 : p_original_symbol = original_symbol;
286309 0 : p_new_name = new_name;
286310 :
286311 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
286312 :
286313 : #if 0
286314 : // DQ (7/30/2014): Call a virtual function.
286315 : std::string s = this->class_name();
286316 : #endif
286317 :
286318 : // Test the variant virtual function
286319 : // assert(RENAME_SYMBOL == variant());
286320 0 : assert(RENAME_SYMBOL == this->variant());
286321 0 : ROSE_ASSERT(RENAME_SYMBOL == (int)(this->variantT()));
286322 0 : post_construction_initialization();
286323 :
286324 : // Test the isSgRenameSymbol() function since it has been problematic
286325 0 : assert(isSgRenameSymbol(this) != NULL);
286326 0 : }
286327 :
286328 : // Generated constructor (all data members)
286329 :
286330 : /* #line 286331 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286331 :
286332 :
286333 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
286334 :
286335 :
286336 : // ********************************************************
286337 : // member functions common across all array grammar objects
286338 : // ********************************************************
286339 :
286340 :
286341 :
286342 : /* #line 286343 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286343 :
286344 :
286345 :
286346 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
286347 :
286348 : // ********************************************************
286349 : // member functions specific to each node in the grammar
286350 : // ********************************************************
286351 :
286352 :
286353 : /* #line 286354 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286354 :
286355 : // Start of memberFunctionString
286356 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
286357 :
286358 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
286359 :
286360 : SgName
286361 5843 : SgFunctionTypeSymbol::get_name () const
286362 : {
286363 5843 : ROSE_ASSERT (this != NULL);
286364 :
286365 : #if 0
286366 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
286367 : // used to trigger marking transformations for the token-based unparsing.
286368 : printf ("SgFunctionTypeSymbol::get_name = %p = %s \n",this,this->class_name().c_str());
286369 : #endif
286370 :
286371 5843 : return p_name;
286372 : }
286373 :
286374 : void
286375 0 : SgFunctionTypeSymbol::set_name ( SgName name )
286376 : {
286377 0 : ROSE_ASSERT (this != NULL);
286378 :
286379 : #if 0
286380 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
286381 : // used to trigger marking transformations for the token-based unparsing.
286382 : printf ("SgFunctionTypeSymbol::set_name = %p = %s \n",this,this->class_name().c_str());
286383 : #endif
286384 :
286385 0 : set_isModified(true);
286386 :
286387 0 : p_name = name;
286388 0 : }
286389 :
286390 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
286391 :
286392 :
286393 : // End of memberFunctionString
286394 : // Start of memberFunctionString
286395 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
286396 :
286397 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
286398 :
286399 : SgType*
286400 2483100 : SgFunctionTypeSymbol::get_type () const
286401 : {
286402 2483100 : ROSE_ASSERT (this != NULL);
286403 :
286404 : #if 0
286405 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
286406 : // used to trigger marking transformations for the token-based unparsing.
286407 : printf ("SgFunctionTypeSymbol::get_type = %p = %s \n",this,this->class_name().c_str());
286408 : #endif
286409 :
286410 2483100 : return p_type;
286411 : }
286412 :
286413 : void
286414 0 : SgFunctionTypeSymbol::set_type ( SgType* type )
286415 : {
286416 0 : ROSE_ASSERT (this != NULL);
286417 :
286418 : #if 0
286419 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
286420 : // used to trigger marking transformations for the token-based unparsing.
286421 : printf ("SgFunctionTypeSymbol::set_type = %p = %s \n",this,this->class_name().c_str());
286422 : #endif
286423 :
286424 0 : set_isModified(true);
286425 :
286426 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
286427 : if (p_type != NULL && type != NULL && p_type != type)
286428 : {
286429 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
286430 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
286431 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
286432 : ROSE_ASSERT(false);
286433 : #endif
286434 : }
286435 : #endif
286436 0 : p_type = type;
286437 0 : }
286438 :
286439 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
286440 :
286441 :
286442 : // End of memberFunctionString
286443 : // Start of memberFunctionString
286444 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
286445 :
286446 : // *** COMMON CODE SECTION BEGINS HERE ***
286447 :
286448 : #if 0
286449 : int
286450 : SgFunctionTypeSymbol::getVariant() const
286451 : {
286452 : // This function is used in ROSE while "variant()" is used in SAGE
286453 : assert(this != NULL);
286454 : return variant();
286455 : }
286456 : #endif
286457 :
286458 : // This function is used in ROSE in treeTraversal code
286459 : // eventually replaces getVariant() and variant()
286460 : // though after variant() has been removed for a while we will
286461 : // want to change the name of variantT() back to variant()
286462 : // (since the "T" was ment to stand for temporary).
286463 : // When this happens the variantT() will be depricated.
286464 : VariantT
286465 21689900 : SgFunctionTypeSymbol::variantT() const
286466 : {
286467 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
286468 21689900 : ROSE_ASSERT(this != NULL);
286469 21689900 : return V_SgFunctionTypeSymbol;
286470 : }
286471 :
286472 : #if 0
286473 : int
286474 : SgFunctionTypeSymbol::variant() const
286475 : {
286476 : // This function is used in SAGE
286477 : ROSE_ASSERT(this != NULL);
286478 : return FUNCTYPE_NAME;
286479 : }
286480 : #endif
286481 :
286482 : ROSE_DLL_API const char*
286483 0 : SgFunctionTypeSymbol::sage_class_name() const
286484 : {
286485 0 : ROSE_ASSERT(this != NULL);
286486 0 : return "SgFunctionTypeSymbol";
286487 : }
286488 :
286489 : std::string
286490 321383 : SgFunctionTypeSymbol::class_name() const
286491 : {
286492 321383 : ROSE_ASSERT(this != NULL);
286493 321383 : return "SgFunctionTypeSymbol";
286494 : }
286495 :
286496 : // DQ (11/26/2005): Support for visitor pattern mechanims
286497 : // (inferior to ROSE traversal mechanism, experimental).
286498 : void
286499 1199240 : SgFunctionTypeSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
286500 : {
286501 1199240 : ROSE_ASSERT(this != NULL);
286502 1199240 : visitor.visit(this);
286503 1199240 : }
286504 :
286505 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
286506 0 : void SgFunctionTypeSymbol::accept (ROSE_VisitorPattern & visitor) {
286507 0 : ROSE_ASSERT(this != NULL);
286508 0 : visitor.visit(this);
286509 0 : }
286510 :
286511 : SgFunctionTypeSymbol*
286512 0 : SgFunctionTypeSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
286513 : {
286514 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
286515 : // This function is currently only supported for the AST used the represent Binary executables.
286516 : if (0 /* isSgAsmNode(this) != NULL */)
286517 : {
286518 : // Support for regex specification.
286519 : std::string prefixCode = "REGEX:";
286520 : addNewAttribute(prefixCode + s,a);
286521 : }
286522 : #endif
286523 :
286524 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
286525 0 : return this;
286526 : }
286527 :
286528 : // *** COMMON CODE SECTION ENDS HERE ***
286529 :
286530 :
286531 : // End of memberFunctionString
286532 : // Start of memberFunctionString
286533 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
286534 :
286535 :
286536 : #if 0
286537 : //! Error checking support
286538 : /*! Verifies the following:
286539 : - working getVariant() member function
286540 : - calls base class's error() member function
286541 : Every class has one of these functions.
286542 : */
286543 : bool
286544 : SgFunctionTypeSymbol::error()
286545 : {
286546 : // Put error checking here
286547 :
286548 : ROSE_ASSERT (this != NULL);
286549 : if (getVariant() != FUNCTYPE_NAME)
286550 : {
286551 : printf ("Error in SgFunctionTypeSymbol::error(): SgFunctionTypeSymbol object has a %s variant \n",
286552 : Cxx_GrammarTerminalNames[getVariant()].name);
286553 : // printf ("Error in SgFunctionTypeSymbol::error() \n");
286554 : ROSE_ABORT();
286555 : }
286556 :
286557 : ROSE_ASSERT (getVariant() == FUNCTYPE_NAME);
286558 : return SgSymbol::error();
286559 : }
286560 : #endif
286561 :
286562 :
286563 :
286564 : // End of memberFunctionString
286565 :
286566 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
286567 :
286568 3219900 : SgFunctionTypeSymbol* isSgFunctionTypeSymbol ( SgNode* inputDerivedClassPointer )
286569 : {
286570 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
286571 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
286572 : // So to fix this we return NULL directly when the input is NULL and avoid the
286573 : // dynamic_cast in this case. This is likely a performance improvement as well.
286574 : // return dynamic_cast<SgFunctionTypeSymbol*>(inputDerivedClassPointer);
286575 : // Milind Chabbi (8/28/2013): isSgFunctionTypeSymbol uses table-driven castability instead of c++ default dynamic_cast
286576 : // this improves the running time performance by 10-20%.
286577 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgFunctionTypeSymbol*>(inputDerivedClassPointer);
286578 3219900 : return IS_SgFunctionTypeSymbol_FAST_MACRO(inputDerivedClassPointer);
286579 : }
286580 :
286581 : // DQ (11/8/2003): Added version of functions taking const pointer
286582 5837 : const SgFunctionTypeSymbol* isSgFunctionTypeSymbol ( const SgNode* inputDerivedClassPointer )
286583 : {
286584 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
286585 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
286586 : // So to fix this we return NULL directly when the input is NULL and avoid the
286587 : // dynamic_cast in this case. This is likely a performance improvement as well.
286588 : // return dynamic_cast<const SgFunctionTypeSymbol*>(inputDerivedClassPointer);
286589 : // Milind Chabbi (8/28/2013): isSgFunctionTypeSymbol uses table-driven castability instead of c++ default dynamic_cast
286590 : // this improves the running time performance by 10-20%.
286591 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgFunctionTypeSymbol*>(inputDerivedClassPointer);
286592 5837 : return IS_SgFunctionTypeSymbol_FAST_MACRO(inputDerivedClassPointer);
286593 : }
286594 :
286595 :
286596 :
286597 : /* #line 286598 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286598 :
286599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
286600 :
286601 : /**
286602 : \brief Generated destructor
286603 :
286604 : This destructor is automatically generated (by ROSETTA). This destructor
286605 : only frees memory of data members associated with the parts of the current IR node which
286606 : are NOT traversed. Those data members that are part of a traversal can be freed using
286607 : a traversal (calling this destructor on all children in a post-order traversal). Such
286608 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
286609 :
286610 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
286611 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
286612 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
286613 :
286614 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
286615 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
286616 : pointers are not yet implemented to call delete on eash pointer in the container.
286617 : (This could be done by derivation from the STL containers to define containers that
286618 : automatically deleted their members.)
286619 :
286620 : */
286621 36728 : SgFunctionTypeSymbol::~SgFunctionTypeSymbol () {
286622 18364 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
286623 :
286624 :
286625 : // case: not a listType for name
286626 18364 : p_name = ""; // non list case
286627 : // case: not a listType for type
286628 18364 : p_type = NULL; // non list case
286629 :
286630 : }
286631 :
286632 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
286633 36728 : }
286634 :
286635 :
286636 : /* #line 286637 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286637 :
286638 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
286639 :
286640 : // Generated constructor
286641 354607 : SgFunctionTypeSymbol::SgFunctionTypeSymbol ( SgName name, SgType* type )
286642 354607 : : SgSymbol()
286643 : {
286644 : #ifdef DEBUG
286645 : // printf ("In SgFunctionTypeSymbol::SgFunctionTypeSymbol (SgName name, SgType* type) sage_class_name() = %s \n",sage_class_name());
286646 : #endif
286647 : #if 0
286648 : // debugging information!
286649 : printf ("In SgFunctionTypeSymbol::SgFunctionTypeSymbol (SgName name, SgType* type): this = %p = %s \n",this,this->class_name().c_str());
286650 : #endif
286651 :
286652 354607 : p_name = name;
286653 354607 : p_type = type;
286654 :
286655 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
286656 :
286657 : #if 0
286658 : // DQ (7/30/2014): Call a virtual function.
286659 : std::string s = this->class_name();
286660 : #endif
286661 :
286662 : // Test the variant virtual function
286663 : // assert(FUNCTYPE_NAME == variant());
286664 354607 : assert(FUNCTYPE_NAME == this->variant());
286665 354607 : ROSE_ASSERT(FUNCTYPE_NAME == (int)(this->variantT()));
286666 354607 : post_construction_initialization();
286667 :
286668 : // Test the isSgFunctionTypeSymbol() function since it has been problematic
286669 354607 : assert(isSgFunctionTypeSymbol(this) != NULL);
286670 354607 : }
286671 :
286672 : // Generated constructor (all data members)
286673 :
286674 : /* #line 286675 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286675 :
286676 :
286677 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
286678 :
286679 :
286680 : // ********************************************************
286681 : // member functions common across all array grammar objects
286682 : // ********************************************************
286683 :
286684 :
286685 :
286686 : /* #line 286687 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286687 :
286688 :
286689 :
286690 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
286691 :
286692 : // ********************************************************
286693 : // member functions specific to each node in the grammar
286694 : // ********************************************************
286695 :
286696 :
286697 : /* #line 286698 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286698 :
286699 : // Start of memberFunctionString
286700 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
286701 :
286702 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
286703 :
286704 : SgClassDeclaration*
286705 1413370 : SgClassSymbol::get_declaration () const
286706 : {
286707 1413370 : ROSE_ASSERT (this != NULL);
286708 :
286709 : #if 0
286710 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
286711 : // used to trigger marking transformations for the token-based unparsing.
286712 : printf ("SgClassSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
286713 : #endif
286714 :
286715 1413370 : return p_declaration;
286716 : }
286717 :
286718 : void
286719 852 : SgClassSymbol::set_declaration ( SgClassDeclaration* declaration )
286720 : {
286721 852 : ROSE_ASSERT (this != NULL);
286722 :
286723 : #if 0
286724 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
286725 : // used to trigger marking transformations for the token-based unparsing.
286726 : printf ("SgClassSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
286727 : #endif
286728 :
286729 852 : set_isModified(true);
286730 :
286731 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
286732 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
286733 : {
286734 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
286735 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
286736 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
286737 : ROSE_ASSERT(false);
286738 : #endif
286739 : }
286740 : #endif
286741 852 : p_declaration = declaration;
286742 852 : }
286743 :
286744 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
286745 :
286746 :
286747 : // End of memberFunctionString
286748 : // Start of memberFunctionString
286749 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
286750 :
286751 : SgType*
286752 33297 : SgClassSymbol::get_type() const
286753 : {
286754 33297 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
286755 : }
286756 :
286757 : #if 0
286758 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
286759 : SgNode*
286760 : SgClassSymbol::get_symbol_basis() const
286761 : {
286762 : return get_type();
286763 : }
286764 : #endif
286765 :
286766 :
286767 : // End of memberFunctionString
286768 : // Start of memberFunctionString
286769 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
286770 :
286771 : SgName
286772 19960 : SgClassSymbol::get_name() const
286773 : {
286774 19960 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
286775 : }
286776 :
286777 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
286778 : SgNode*
286779 247408 : SgClassSymbol::get_symbol_basis() const
286780 : {
286781 247408 : return get_declaration();
286782 : }
286783 :
286784 :
286785 : // End of memberFunctionString
286786 : // Start of memberFunctionString
286787 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
286788 :
286789 : // *** COMMON CODE SECTION BEGINS HERE ***
286790 :
286791 : #if 0
286792 : int
286793 : SgClassSymbol::getVariant() const
286794 : {
286795 : // This function is used in ROSE while "variant()" is used in SAGE
286796 : assert(this != NULL);
286797 : return variant();
286798 : }
286799 : #endif
286800 :
286801 : // This function is used in ROSE in treeTraversal code
286802 : // eventually replaces getVariant() and variant()
286803 : // though after variant() has been removed for a while we will
286804 : // want to change the name of variantT() back to variant()
286805 : // (since the "T" was ment to stand for temporary).
286806 : // When this happens the variantT() will be depricated.
286807 : VariantT
286808 2427970 : SgClassSymbol::variantT() const
286809 : {
286810 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
286811 2427970 : ROSE_ASSERT(this != NULL);
286812 2427970 : return V_SgClassSymbol;
286813 : }
286814 :
286815 : #if 0
286816 : int
286817 : SgClassSymbol::variant() const
286818 : {
286819 : // This function is used in SAGE
286820 : ROSE_ASSERT(this != NULL);
286821 : return CLASS_NAME;
286822 : }
286823 : #endif
286824 :
286825 : ROSE_DLL_API const char*
286826 0 : SgClassSymbol::sage_class_name() const
286827 : {
286828 0 : ROSE_ASSERT(this != NULL);
286829 0 : return "SgClassSymbol";
286830 : }
286831 :
286832 : std::string
286833 13082 : SgClassSymbol::class_name() const
286834 : {
286835 13082 : ROSE_ASSERT(this != NULL);
286836 13082 : return "SgClassSymbol";
286837 : }
286838 :
286839 : // DQ (11/26/2005): Support for visitor pattern mechanims
286840 : // (inferior to ROSE traversal mechanism, experimental).
286841 : void
286842 116994 : SgClassSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
286843 : {
286844 116994 : ROSE_ASSERT(this != NULL);
286845 116994 : visitor.visit(this);
286846 116994 : }
286847 :
286848 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
286849 0 : void SgClassSymbol::accept (ROSE_VisitorPattern & visitor) {
286850 0 : ROSE_ASSERT(this != NULL);
286851 0 : visitor.visit(this);
286852 0 : }
286853 :
286854 : SgClassSymbol*
286855 0 : SgClassSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
286856 : {
286857 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
286858 : // This function is currently only supported for the AST used the represent Binary executables.
286859 : if (0 /* isSgAsmNode(this) != NULL */)
286860 : {
286861 : // Support for regex specification.
286862 : std::string prefixCode = "REGEX:";
286863 : addNewAttribute(prefixCode + s,a);
286864 : }
286865 : #endif
286866 :
286867 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
286868 0 : return this;
286869 : }
286870 :
286871 : // *** COMMON CODE SECTION ENDS HERE ***
286872 :
286873 :
286874 : // End of memberFunctionString
286875 : // Start of memberFunctionString
286876 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
286877 :
286878 :
286879 : #if 0
286880 : //! Error checking support
286881 : /*! Verifies the following:
286882 : - working getVariant() member function
286883 : - calls base class's error() member function
286884 : Every class has one of these functions.
286885 : */
286886 : bool
286887 : SgClassSymbol::error()
286888 : {
286889 : // Put error checking here
286890 :
286891 : ROSE_ASSERT (this != NULL);
286892 : if (getVariant() != CLASS_NAME)
286893 : {
286894 : printf ("Error in SgClassSymbol::error(): SgClassSymbol object has a %s variant \n",
286895 : Cxx_GrammarTerminalNames[getVariant()].name);
286896 : // printf ("Error in SgClassSymbol::error() \n");
286897 : ROSE_ABORT();
286898 : }
286899 :
286900 : ROSE_ASSERT (getVariant() == CLASS_NAME);
286901 : return SgSymbol::error();
286902 : }
286903 : #endif
286904 :
286905 :
286906 :
286907 : // End of memberFunctionString
286908 :
286909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
286910 :
286911 1728460 : SgClassSymbol* isSgClassSymbol ( SgNode* inputDerivedClassPointer )
286912 : {
286913 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
286914 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
286915 : // So to fix this we return NULL directly when the input is NULL and avoid the
286916 : // dynamic_cast in this case. This is likely a performance improvement as well.
286917 : // return dynamic_cast<SgClassSymbol*>(inputDerivedClassPointer);
286918 : // Milind Chabbi (8/28/2013): isSgClassSymbol uses table-driven castability instead of c++ default dynamic_cast
286919 : // this improves the running time performance by 10-20%.
286920 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgClassSymbol*>(inputDerivedClassPointer);
286921 1728460 : return IS_SgClassSymbol_FAST_MACRO(inputDerivedClassPointer);
286922 : }
286923 :
286924 : // DQ (11/8/2003): Added version of functions taking const pointer
286925 854 : const SgClassSymbol* isSgClassSymbol ( const SgNode* inputDerivedClassPointer )
286926 : {
286927 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
286928 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
286929 : // So to fix this we return NULL directly when the input is NULL and avoid the
286930 : // dynamic_cast in this case. This is likely a performance improvement as well.
286931 : // return dynamic_cast<const SgClassSymbol*>(inputDerivedClassPointer);
286932 : // Milind Chabbi (8/28/2013): isSgClassSymbol uses table-driven castability instead of c++ default dynamic_cast
286933 : // this improves the running time performance by 10-20%.
286934 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgClassSymbol*>(inputDerivedClassPointer);
286935 854 : return IS_SgClassSymbol_FAST_MACRO(inputDerivedClassPointer);
286936 : }
286937 :
286938 :
286939 :
286940 : /* #line 286941 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286941 :
286942 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
286943 :
286944 : /**
286945 : \brief Generated destructor
286946 :
286947 : This destructor is automatically generated (by ROSETTA). This destructor
286948 : only frees memory of data members associated with the parts of the current IR node which
286949 : are NOT traversed. Those data members that are part of a traversal can be freed using
286950 : a traversal (calling this destructor on all children in a post-order traversal). Such
286951 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
286952 :
286953 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
286954 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
286955 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
286956 :
286957 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
286958 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
286959 : pointers are not yet implemented to call delete on eash pointer in the container.
286960 : (This could be done by derivation from the STL containers to define containers that
286961 : automatically deleted their members.)
286962 :
286963 : */
286964 4552 : SgClassSymbol::~SgClassSymbol () {
286965 2848 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
286966 :
286967 :
286968 : // case: not a listType for declaration
286969 2848 : p_declaration = NULL; // non list case
286970 :
286971 : }
286972 :
286973 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
286974 4552 : }
286975 :
286976 :
286977 : /* #line 286978 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
286978 :
286979 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
286980 :
286981 : // Generated constructor
286982 19074 : SgClassSymbol::SgClassSymbol ( SgClassDeclaration* declaration )
286983 19074 : : SgSymbol()
286984 : {
286985 : #ifdef DEBUG
286986 : // printf ("In SgClassSymbol::SgClassSymbol (SgClassDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
286987 : #endif
286988 : #if 0
286989 : // debugging information!
286990 : printf ("In SgClassSymbol::SgClassSymbol (SgClassDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
286991 : #endif
286992 :
286993 19074 : p_declaration = declaration;
286994 :
286995 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
286996 :
286997 : #if 0
286998 : // DQ (7/30/2014): Call a virtual function.
286999 : std::string s = this->class_name();
287000 : #endif
287001 :
287002 : // Test the variant virtual function
287003 : // assert(CLASS_NAME == variant());
287004 19074 : assert(CLASS_NAME == this->variant());
287005 19074 : ROSE_ASSERT(CLASS_NAME == (int)(this->variantT()));
287006 19074 : post_construction_initialization();
287007 :
287008 : // Test the isSgClassSymbol() function since it has been problematic
287009 19074 : assert(isSgClassSymbol(this) != NULL);
287010 19074 : }
287011 :
287012 : // Generated constructor (all data members)
287013 :
287014 : /* #line 287015 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287015 :
287016 :
287017 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287018 :
287019 :
287020 : // ********************************************************
287021 : // member functions common across all array grammar objects
287022 : // ********************************************************
287023 :
287024 :
287025 :
287026 : /* #line 287027 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287027 :
287028 :
287029 :
287030 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287031 :
287032 : // ********************************************************
287033 : // member functions specific to each node in the grammar
287034 : // ********************************************************
287035 :
287036 :
287037 : /* #line 287038 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287038 :
287039 : // Start of memberFunctionString
287040 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
287041 :
287042 : SgType*
287043 117382 : SgTemplateClassSymbol::get_type() const
287044 : {
287045 117382 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
287046 : }
287047 :
287048 : #if 0
287049 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
287050 : SgNode*
287051 : SgTemplateClassSymbol::get_symbol_basis() const
287052 : {
287053 : return get_type();
287054 : }
287055 : #endif
287056 :
287057 :
287058 : // End of memberFunctionString
287059 : // Start of memberFunctionString
287060 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
287061 :
287062 : SgName
287063 0 : SgTemplateClassSymbol::get_name() const
287064 : {
287065 0 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
287066 : }
287067 :
287068 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
287069 : SgNode*
287070 102936 : SgTemplateClassSymbol::get_symbol_basis() const
287071 : {
287072 102936 : return get_declaration();
287073 : }
287074 :
287075 :
287076 : // End of memberFunctionString
287077 : // Start of memberFunctionString
287078 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
287079 :
287080 : // *** COMMON CODE SECTION BEGINS HERE ***
287081 :
287082 : #if 0
287083 : int
287084 : SgTemplateClassSymbol::getVariant() const
287085 : {
287086 : // This function is used in ROSE while "variant()" is used in SAGE
287087 : assert(this != NULL);
287088 : return variant();
287089 : }
287090 : #endif
287091 :
287092 : // This function is used in ROSE in treeTraversal code
287093 : // eventually replaces getVariant() and variant()
287094 : // though after variant() has been removed for a while we will
287095 : // want to change the name of variantT() back to variant()
287096 : // (since the "T" was ment to stand for temporary).
287097 : // When this happens the variantT() will be depricated.
287098 : VariantT
287099 1240190 : SgTemplateClassSymbol::variantT() const
287100 : {
287101 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
287102 1240190 : ROSE_ASSERT(this != NULL);
287103 1240190 : return V_SgTemplateClassSymbol;
287104 : }
287105 :
287106 : #if 0
287107 : int
287108 : SgTemplateClassSymbol::variant() const
287109 : {
287110 : // This function is used in SAGE
287111 : ROSE_ASSERT(this != NULL);
287112 : return TEMPLATE_CLASS_NAME;
287113 : }
287114 : #endif
287115 :
287116 : ROSE_DLL_API const char*
287117 0 : SgTemplateClassSymbol::sage_class_name() const
287118 : {
287119 0 : ROSE_ASSERT(this != NULL);
287120 0 : return "SgTemplateClassSymbol";
287121 : }
287122 :
287123 : std::string
287124 3903 : SgTemplateClassSymbol::class_name() const
287125 : {
287126 3903 : ROSE_ASSERT(this != NULL);
287127 3903 : return "SgTemplateClassSymbol";
287128 : }
287129 :
287130 : // DQ (11/26/2005): Support for visitor pattern mechanims
287131 : // (inferior to ROSE traversal mechanism, experimental).
287132 : void
287133 78742 : SgTemplateClassSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
287134 : {
287135 78742 : ROSE_ASSERT(this != NULL);
287136 78742 : visitor.visit(this);
287137 78742 : }
287138 :
287139 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
287140 0 : void SgTemplateClassSymbol::accept (ROSE_VisitorPattern & visitor) {
287141 0 : ROSE_ASSERT(this != NULL);
287142 0 : visitor.visit(this);
287143 0 : }
287144 :
287145 : SgTemplateClassSymbol*
287146 0 : SgTemplateClassSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
287147 : {
287148 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
287149 : // This function is currently only supported for the AST used the represent Binary executables.
287150 : if (0 /* isSgAsmNode(this) != NULL */)
287151 : {
287152 : // Support for regex specification.
287153 : std::string prefixCode = "REGEX:";
287154 : addNewAttribute(prefixCode + s,a);
287155 : }
287156 : #endif
287157 :
287158 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
287159 0 : return this;
287160 : }
287161 :
287162 : // *** COMMON CODE SECTION ENDS HERE ***
287163 :
287164 :
287165 : // End of memberFunctionString
287166 : // Start of memberFunctionString
287167 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
287168 :
287169 :
287170 : #if 0
287171 : //! Error checking support
287172 : /*! Verifies the following:
287173 : - working getVariant() member function
287174 : - calls base class's error() member function
287175 : Every class has one of these functions.
287176 : */
287177 : bool
287178 : SgTemplateClassSymbol::error()
287179 : {
287180 : // Put error checking here
287181 :
287182 : ROSE_ASSERT (this != NULL);
287183 : if (getVariant() != TEMPLATE_CLASS_NAME)
287184 : {
287185 : printf ("Error in SgTemplateClassSymbol::error(): SgTemplateClassSymbol object has a %s variant \n",
287186 : Cxx_GrammarTerminalNames[getVariant()].name);
287187 : // printf ("Error in SgTemplateClassSymbol::error() \n");
287188 : ROSE_ABORT();
287189 : }
287190 :
287191 : ROSE_ASSERT (getVariant() == TEMPLATE_CLASS_NAME);
287192 : return SgClassSymbol::error();
287193 : }
287194 : #endif
287195 :
287196 :
287197 :
287198 : // End of memberFunctionString
287199 :
287200 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
287201 :
287202 238054 : SgTemplateClassSymbol* isSgTemplateClassSymbol ( SgNode* inputDerivedClassPointer )
287203 : {
287204 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
287205 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
287206 : // So to fix this we return NULL directly when the input is NULL and avoid the
287207 : // dynamic_cast in this case. This is likely a performance improvement as well.
287208 : // return dynamic_cast<SgTemplateClassSymbol*>(inputDerivedClassPointer);
287209 : // Milind Chabbi (8/28/2013): isSgTemplateClassSymbol uses table-driven castability instead of c++ default dynamic_cast
287210 : // this improves the running time performance by 10-20%.
287211 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateClassSymbol*>(inputDerivedClassPointer);
287212 238054 : return IS_SgTemplateClassSymbol_FAST_MACRO(inputDerivedClassPointer);
287213 : }
287214 :
287215 : // DQ (11/8/2003): Added version of functions taking const pointer
287216 0 : const SgTemplateClassSymbol* isSgTemplateClassSymbol ( const SgNode* inputDerivedClassPointer )
287217 : {
287218 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
287219 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
287220 : // So to fix this we return NULL directly when the input is NULL and avoid the
287221 : // dynamic_cast in this case. This is likely a performance improvement as well.
287222 : // return dynamic_cast<const SgTemplateClassSymbol*>(inputDerivedClassPointer);
287223 : // Milind Chabbi (8/28/2013): isSgTemplateClassSymbol uses table-driven castability instead of c++ default dynamic_cast
287224 : // this improves the running time performance by 10-20%.
287225 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateClassSymbol*>(inputDerivedClassPointer);
287226 0 : return IS_SgTemplateClassSymbol_FAST_MACRO(inputDerivedClassPointer);
287227 : }
287228 :
287229 :
287230 :
287231 : /* #line 287232 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287232 :
287233 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
287234 :
287235 : /**
287236 : \brief Generated destructor
287237 :
287238 : This destructor is automatically generated (by ROSETTA). This destructor
287239 : only frees memory of data members associated with the parts of the current IR node which
287240 : are NOT traversed. Those data members that are part of a traversal can be freed using
287241 : a traversal (calling this destructor on all children in a post-order traversal). Such
287242 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
287243 :
287244 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
287245 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
287246 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
287247 :
287248 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
287249 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
287250 : pointers are not yet implemented to call delete on eash pointer in the container.
287251 : (This could be done by derivation from the STL containers to define containers that
287252 : automatically deleted their members.)
287253 :
287254 : */
287255 2288 : SgTemplateClassSymbol::~SgTemplateClassSymbol () {
287256 1144 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
287257 :
287258 :
287259 :
287260 : }
287261 :
287262 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
287263 2288 : }
287264 :
287265 :
287266 : /* #line 287267 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287267 :
287268 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
287269 :
287270 : // Generated constructor
287271 5538 : SgTemplateClassSymbol::SgTemplateClassSymbol ( SgClassDeclaration* declaration )
287272 5538 : : SgClassSymbol(declaration)
287273 : {
287274 : #ifdef DEBUG
287275 : // printf ("In SgTemplateClassSymbol::SgTemplateClassSymbol (SgClassDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
287276 : #endif
287277 : #if 0
287278 : // debugging information!
287279 : printf ("In SgTemplateClassSymbol::SgTemplateClassSymbol (SgClassDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
287280 : #endif
287281 :
287282 :
287283 :
287284 : #if 0
287285 : // DQ (7/30/2014): Call a virtual function.
287286 : std::string s = this->class_name();
287287 : #endif
287288 :
287289 : // Test the variant virtual function
287290 : // assert(TEMPLATE_CLASS_NAME == variant());
287291 5538 : assert(TEMPLATE_CLASS_NAME == this->variant());
287292 5538 : ROSE_ASSERT(TEMPLATE_CLASS_NAME == (int)(this->variantT()));
287293 5538 : post_construction_initialization();
287294 :
287295 : // Test the isSgTemplateClassSymbol() function since it has been problematic
287296 5538 : assert(isSgTemplateClassSymbol(this) != NULL);
287297 5538 : }
287298 :
287299 : // Generated constructor (all data members)
287300 :
287301 : /* #line 287302 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287302 :
287303 :
287304 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287305 :
287306 :
287307 : // ********************************************************
287308 : // member functions common across all array grammar objects
287309 : // ********************************************************
287310 :
287311 :
287312 :
287313 : /* #line 287314 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287314 :
287315 :
287316 :
287317 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287318 :
287319 : // ********************************************************
287320 : // member functions specific to each node in the grammar
287321 : // ********************************************************
287322 :
287323 :
287324 : /* #line 287325 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287325 :
287326 : // Start of memberFunctionString
287327 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
287328 :
287329 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
287330 :
287331 : SgTemplateDeclaration*
287332 0 : SgTemplateSymbol::get_declaration () const
287333 : {
287334 0 : ROSE_ASSERT (this != NULL);
287335 :
287336 : #if 0
287337 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
287338 : // used to trigger marking transformations for the token-based unparsing.
287339 : printf ("SgTemplateSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
287340 : #endif
287341 :
287342 0 : return p_declaration;
287343 : }
287344 :
287345 : void
287346 0 : SgTemplateSymbol::set_declaration ( SgTemplateDeclaration* declaration )
287347 : {
287348 0 : ROSE_ASSERT (this != NULL);
287349 :
287350 : #if 0
287351 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
287352 : // used to trigger marking transformations for the token-based unparsing.
287353 : printf ("SgTemplateSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
287354 : #endif
287355 :
287356 0 : set_isModified(true);
287357 :
287358 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
287359 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
287360 : {
287361 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
287362 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
287363 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
287364 : ROSE_ASSERT(false);
287365 : #endif
287366 : }
287367 : #endif
287368 0 : p_declaration = declaration;
287369 0 : }
287370 :
287371 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
287372 :
287373 :
287374 : // End of memberFunctionString
287375 : // Start of memberFunctionString
287376 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
287377 :
287378 : SgType*
287379 0 : SgTemplateSymbol::get_type() const
287380 : {
287381 0 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
287382 : }
287383 :
287384 : #if 0
287385 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
287386 : SgNode*
287387 : SgTemplateSymbol::get_symbol_basis() const
287388 : {
287389 : return get_type();
287390 : }
287391 : #endif
287392 :
287393 :
287394 : // End of memberFunctionString
287395 : // Start of memberFunctionString
287396 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
287397 :
287398 : SgName
287399 0 : SgTemplateSymbol::get_name() const
287400 : {
287401 0 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
287402 : }
287403 :
287404 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
287405 : SgNode*
287406 0 : SgTemplateSymbol::get_symbol_basis() const
287407 : {
287408 0 : return get_declaration();
287409 : }
287410 :
287411 :
287412 : // End of memberFunctionString
287413 : // Start of memberFunctionString
287414 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
287415 :
287416 : // *** COMMON CODE SECTION BEGINS HERE ***
287417 :
287418 : #if 0
287419 : int
287420 : SgTemplateSymbol::getVariant() const
287421 : {
287422 : // This function is used in ROSE while "variant()" is used in SAGE
287423 : assert(this != NULL);
287424 : return variant();
287425 : }
287426 : #endif
287427 :
287428 : // This function is used in ROSE in treeTraversal code
287429 : // eventually replaces getVariant() and variant()
287430 : // though after variant() has been removed for a while we will
287431 : // want to change the name of variantT() back to variant()
287432 : // (since the "T" was ment to stand for temporary).
287433 : // When this happens the variantT() will be depricated.
287434 : VariantT
287435 0 : SgTemplateSymbol::variantT() const
287436 : {
287437 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
287438 0 : ROSE_ASSERT(this != NULL);
287439 0 : return V_SgTemplateSymbol;
287440 : }
287441 :
287442 : #if 0
287443 : int
287444 : SgTemplateSymbol::variant() const
287445 : {
287446 : // This function is used in SAGE
287447 : ROSE_ASSERT(this != NULL);
287448 : return TEMPLATE_NAME;
287449 : }
287450 : #endif
287451 :
287452 : ROSE_DLL_API const char*
287453 0 : SgTemplateSymbol::sage_class_name() const
287454 : {
287455 0 : ROSE_ASSERT(this != NULL);
287456 0 : return "SgTemplateSymbol";
287457 : }
287458 :
287459 : std::string
287460 0 : SgTemplateSymbol::class_name() const
287461 : {
287462 0 : ROSE_ASSERT(this != NULL);
287463 0 : return "SgTemplateSymbol";
287464 : }
287465 :
287466 : // DQ (11/26/2005): Support for visitor pattern mechanims
287467 : // (inferior to ROSE traversal mechanism, experimental).
287468 : void
287469 0 : SgTemplateSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
287470 : {
287471 0 : ROSE_ASSERT(this != NULL);
287472 0 : visitor.visit(this);
287473 0 : }
287474 :
287475 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
287476 0 : void SgTemplateSymbol::accept (ROSE_VisitorPattern & visitor) {
287477 0 : ROSE_ASSERT(this != NULL);
287478 0 : visitor.visit(this);
287479 0 : }
287480 :
287481 : SgTemplateSymbol*
287482 0 : SgTemplateSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
287483 : {
287484 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
287485 : // This function is currently only supported for the AST used the represent Binary executables.
287486 : if (0 /* isSgAsmNode(this) != NULL */)
287487 : {
287488 : // Support for regex specification.
287489 : std::string prefixCode = "REGEX:";
287490 : addNewAttribute(prefixCode + s,a);
287491 : }
287492 : #endif
287493 :
287494 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
287495 0 : return this;
287496 : }
287497 :
287498 : // *** COMMON CODE SECTION ENDS HERE ***
287499 :
287500 :
287501 : // End of memberFunctionString
287502 : // Start of memberFunctionString
287503 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
287504 :
287505 :
287506 : #if 0
287507 : //! Error checking support
287508 : /*! Verifies the following:
287509 : - working getVariant() member function
287510 : - calls base class's error() member function
287511 : Every class has one of these functions.
287512 : */
287513 : bool
287514 : SgTemplateSymbol::error()
287515 : {
287516 : // Put error checking here
287517 :
287518 : ROSE_ASSERT (this != NULL);
287519 : if (getVariant() != TEMPLATE_NAME)
287520 : {
287521 : printf ("Error in SgTemplateSymbol::error(): SgTemplateSymbol object has a %s variant \n",
287522 : Cxx_GrammarTerminalNames[getVariant()].name);
287523 : // printf ("Error in SgTemplateSymbol::error() \n");
287524 : ROSE_ABORT();
287525 : }
287526 :
287527 : ROSE_ASSERT (getVariant() == TEMPLATE_NAME);
287528 : return SgSymbol::error();
287529 : }
287530 : #endif
287531 :
287532 :
287533 :
287534 : // End of memberFunctionString
287535 :
287536 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
287537 :
287538 21547 : SgTemplateSymbol* isSgTemplateSymbol ( SgNode* inputDerivedClassPointer )
287539 : {
287540 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
287541 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
287542 : // So to fix this we return NULL directly when the input is NULL and avoid the
287543 : // dynamic_cast in this case. This is likely a performance improvement as well.
287544 : // return dynamic_cast<SgTemplateSymbol*>(inputDerivedClassPointer);
287545 : // Milind Chabbi (8/28/2013): isSgTemplateSymbol uses table-driven castability instead of c++ default dynamic_cast
287546 : // this improves the running time performance by 10-20%.
287547 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateSymbol*>(inputDerivedClassPointer);
287548 21547 : return IS_SgTemplateSymbol_FAST_MACRO(inputDerivedClassPointer);
287549 : }
287550 :
287551 : // DQ (11/8/2003): Added version of functions taking const pointer
287552 0 : const SgTemplateSymbol* isSgTemplateSymbol ( const SgNode* inputDerivedClassPointer )
287553 : {
287554 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
287555 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
287556 : // So to fix this we return NULL directly when the input is NULL and avoid the
287557 : // dynamic_cast in this case. This is likely a performance improvement as well.
287558 : // return dynamic_cast<const SgTemplateSymbol*>(inputDerivedClassPointer);
287559 : // Milind Chabbi (8/28/2013): isSgTemplateSymbol uses table-driven castability instead of c++ default dynamic_cast
287560 : // this improves the running time performance by 10-20%.
287561 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateSymbol*>(inputDerivedClassPointer);
287562 0 : return IS_SgTemplateSymbol_FAST_MACRO(inputDerivedClassPointer);
287563 : }
287564 :
287565 :
287566 :
287567 : /* #line 287568 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287568 :
287569 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
287570 :
287571 : /**
287572 : \brief Generated destructor
287573 :
287574 : This destructor is automatically generated (by ROSETTA). This destructor
287575 : only frees memory of data members associated with the parts of the current IR node which
287576 : are NOT traversed. Those data members that are part of a traversal can be freed using
287577 : a traversal (calling this destructor on all children in a post-order traversal). Such
287578 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
287579 :
287580 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
287581 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
287582 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
287583 :
287584 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
287585 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
287586 : pointers are not yet implemented to call delete on eash pointer in the container.
287587 : (This could be done by derivation from the STL containers to define containers that
287588 : automatically deleted their members.)
287589 :
287590 : */
287591 0 : SgTemplateSymbol::~SgTemplateSymbol () {
287592 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
287593 :
287594 :
287595 : // case: not a listType for declaration
287596 0 : p_declaration = NULL; // non list case
287597 :
287598 : }
287599 :
287600 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
287601 0 : }
287602 :
287603 :
287604 : /* #line 287605 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287605 :
287606 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
287607 :
287608 : // Generated constructor
287609 0 : SgTemplateSymbol::SgTemplateSymbol ( SgTemplateDeclaration* declaration )
287610 0 : : SgSymbol()
287611 : {
287612 : #ifdef DEBUG
287613 : // printf ("In SgTemplateSymbol::SgTemplateSymbol (SgTemplateDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
287614 : #endif
287615 : #if 0
287616 : // debugging information!
287617 : printf ("In SgTemplateSymbol::SgTemplateSymbol (SgTemplateDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
287618 : #endif
287619 :
287620 0 : p_declaration = declaration;
287621 :
287622 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
287623 :
287624 : #if 0
287625 : // DQ (7/30/2014): Call a virtual function.
287626 : std::string s = this->class_name();
287627 : #endif
287628 :
287629 : // Test the variant virtual function
287630 : // assert(TEMPLATE_NAME == variant());
287631 0 : assert(TEMPLATE_NAME == this->variant());
287632 0 : ROSE_ASSERT(TEMPLATE_NAME == (int)(this->variantT()));
287633 0 : post_construction_initialization();
287634 :
287635 : // Test the isSgTemplateSymbol() function since it has been problematic
287636 0 : assert(isSgTemplateSymbol(this) != NULL);
287637 0 : }
287638 :
287639 : // Generated constructor (all data members)
287640 :
287641 : /* #line 287642 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287642 :
287643 :
287644 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287645 :
287646 :
287647 : // ********************************************************
287648 : // member functions common across all array grammar objects
287649 : // ********************************************************
287650 :
287651 :
287652 :
287653 : /* #line 287654 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287654 :
287655 :
287656 :
287657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287658 :
287659 : // ********************************************************
287660 : // member functions specific to each node in the grammar
287661 : // ********************************************************
287662 :
287663 :
287664 : /* #line 287665 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287665 :
287666 : // Start of memberFunctionString
287667 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
287668 :
287669 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
287670 :
287671 : SgEnumDeclaration*
287672 19882 : SgEnumSymbol::get_declaration () const
287673 : {
287674 19882 : ROSE_ASSERT (this != NULL);
287675 :
287676 : #if 0
287677 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
287678 : // used to trigger marking transformations for the token-based unparsing.
287679 : printf ("SgEnumSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
287680 : #endif
287681 :
287682 19882 : return p_declaration;
287683 : }
287684 :
287685 : void
287686 0 : SgEnumSymbol::set_declaration ( SgEnumDeclaration* declaration )
287687 : {
287688 0 : ROSE_ASSERT (this != NULL);
287689 :
287690 : #if 0
287691 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
287692 : // used to trigger marking transformations for the token-based unparsing.
287693 : printf ("SgEnumSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
287694 : #endif
287695 :
287696 0 : set_isModified(true);
287697 :
287698 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
287699 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
287700 : {
287701 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
287702 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
287703 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
287704 : ROSE_ASSERT(false);
287705 : #endif
287706 : }
287707 : #endif
287708 0 : p_declaration = declaration;
287709 0 : }
287710 :
287711 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
287712 :
287713 :
287714 : // End of memberFunctionString
287715 : // Start of memberFunctionString
287716 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
287717 :
287718 : SgType*
287719 144 : SgEnumSymbol::get_type() const
287720 : {
287721 144 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
287722 : }
287723 :
287724 : #if 0
287725 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
287726 : SgNode*
287727 : SgEnumSymbol::get_symbol_basis() const
287728 : {
287729 : return get_type();
287730 : }
287731 : #endif
287732 :
287733 :
287734 : // End of memberFunctionString
287735 : // Start of memberFunctionString
287736 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
287737 :
287738 : SgName
287739 0 : SgEnumSymbol::get_name() const
287740 : {
287741 0 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
287742 : }
287743 :
287744 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
287745 : SgNode*
287746 8288 : SgEnumSymbol::get_symbol_basis() const
287747 : {
287748 8288 : return get_declaration();
287749 : }
287750 :
287751 :
287752 : // End of memberFunctionString
287753 : // Start of memberFunctionString
287754 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
287755 :
287756 : // *** COMMON CODE SECTION BEGINS HERE ***
287757 :
287758 : #if 0
287759 : int
287760 : SgEnumSymbol::getVariant() const
287761 : {
287762 : // This function is used in ROSE while "variant()" is used in SAGE
287763 : assert(this != NULL);
287764 : return variant();
287765 : }
287766 : #endif
287767 :
287768 : // This function is used in ROSE in treeTraversal code
287769 : // eventually replaces getVariant() and variant()
287770 : // though after variant() has been removed for a while we will
287771 : // want to change the name of variantT() back to variant()
287772 : // (since the "T" was ment to stand for temporary).
287773 : // When this happens the variantT() will be depricated.
287774 : VariantT
287775 139110 : SgEnumSymbol::variantT() const
287776 : {
287777 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
287778 139110 : ROSE_ASSERT(this != NULL);
287779 139110 : return V_SgEnumSymbol;
287780 : }
287781 :
287782 : #if 0
287783 : int
287784 : SgEnumSymbol::variant() const
287785 : {
287786 : // This function is used in SAGE
287787 : ROSE_ASSERT(this != NULL);
287788 : return ENUM_NAME;
287789 : }
287790 : #endif
287791 :
287792 : ROSE_DLL_API const char*
287793 0 : SgEnumSymbol::sage_class_name() const
287794 : {
287795 0 : ROSE_ASSERT(this != NULL);
287796 0 : return "SgEnumSymbol";
287797 : }
287798 :
287799 : std::string
287800 1264 : SgEnumSymbol::class_name() const
287801 : {
287802 1264 : ROSE_ASSERT(this != NULL);
287803 1264 : return "SgEnumSymbol";
287804 : }
287805 :
287806 : // DQ (11/26/2005): Support for visitor pattern mechanims
287807 : // (inferior to ROSE traversal mechanism, experimental).
287808 : void
287809 12142 : SgEnumSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
287810 : {
287811 12142 : ROSE_ASSERT(this != NULL);
287812 12142 : visitor.visit(this);
287813 12142 : }
287814 :
287815 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
287816 0 : void SgEnumSymbol::accept (ROSE_VisitorPattern & visitor) {
287817 0 : ROSE_ASSERT(this != NULL);
287818 0 : visitor.visit(this);
287819 0 : }
287820 :
287821 : SgEnumSymbol*
287822 0 : SgEnumSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
287823 : {
287824 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
287825 : // This function is currently only supported for the AST used the represent Binary executables.
287826 : if (0 /* isSgAsmNode(this) != NULL */)
287827 : {
287828 : // Support for regex specification.
287829 : std::string prefixCode = "REGEX:";
287830 : addNewAttribute(prefixCode + s,a);
287831 : }
287832 : #endif
287833 :
287834 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
287835 0 : return this;
287836 : }
287837 :
287838 : // *** COMMON CODE SECTION ENDS HERE ***
287839 :
287840 :
287841 : // End of memberFunctionString
287842 : // Start of memberFunctionString
287843 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
287844 :
287845 :
287846 : #if 0
287847 : //! Error checking support
287848 : /*! Verifies the following:
287849 : - working getVariant() member function
287850 : - calls base class's error() member function
287851 : Every class has one of these functions.
287852 : */
287853 : bool
287854 : SgEnumSymbol::error()
287855 : {
287856 : // Put error checking here
287857 :
287858 : ROSE_ASSERT (this != NULL);
287859 : if (getVariant() != ENUM_NAME)
287860 : {
287861 : printf ("Error in SgEnumSymbol::error(): SgEnumSymbol object has a %s variant \n",
287862 : Cxx_GrammarTerminalNames[getVariant()].name);
287863 : // printf ("Error in SgEnumSymbol::error() \n");
287864 : ROSE_ABORT();
287865 : }
287866 :
287867 : ROSE_ASSERT (getVariant() == ENUM_NAME);
287868 : return SgSymbol::error();
287869 : }
287870 : #endif
287871 :
287872 :
287873 :
287874 : // End of memberFunctionString
287875 :
287876 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
287877 :
287878 31511 : SgEnumSymbol* isSgEnumSymbol ( SgNode* inputDerivedClassPointer )
287879 : {
287880 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
287881 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
287882 : // So to fix this we return NULL directly when the input is NULL and avoid the
287883 : // dynamic_cast in this case. This is likely a performance improvement as well.
287884 : // return dynamic_cast<SgEnumSymbol*>(inputDerivedClassPointer);
287885 : // Milind Chabbi (8/28/2013): isSgEnumSymbol uses table-driven castability instead of c++ default dynamic_cast
287886 : // this improves the running time performance by 10-20%.
287887 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEnumSymbol*>(inputDerivedClassPointer);
287888 31511 : return IS_SgEnumSymbol_FAST_MACRO(inputDerivedClassPointer);
287889 : }
287890 :
287891 : // DQ (11/8/2003): Added version of functions taking const pointer
287892 0 : const SgEnumSymbol* isSgEnumSymbol ( const SgNode* inputDerivedClassPointer )
287893 : {
287894 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
287895 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
287896 : // So to fix this we return NULL directly when the input is NULL and avoid the
287897 : // dynamic_cast in this case. This is likely a performance improvement as well.
287898 : // return dynamic_cast<const SgEnumSymbol*>(inputDerivedClassPointer);
287899 : // Milind Chabbi (8/28/2013): isSgEnumSymbol uses table-driven castability instead of c++ default dynamic_cast
287900 : // this improves the running time performance by 10-20%.
287901 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEnumSymbol*>(inputDerivedClassPointer);
287902 0 : return IS_SgEnumSymbol_FAST_MACRO(inputDerivedClassPointer);
287903 : }
287904 :
287905 :
287906 :
287907 : /* #line 287908 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287908 :
287909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
287910 :
287911 : /**
287912 : \brief Generated destructor
287913 :
287914 : This destructor is automatically generated (by ROSETTA). This destructor
287915 : only frees memory of data members associated with the parts of the current IR node which
287916 : are NOT traversed. Those data members that are part of a traversal can be freed using
287917 : a traversal (calling this destructor on all children in a post-order traversal). Such
287918 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
287919 :
287920 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
287921 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
287922 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
287923 :
287924 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
287925 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
287926 : pointers are not yet implemented to call delete on eash pointer in the container.
287927 : (This could be done by derivation from the STL containers to define containers that
287928 : automatically deleted their members.)
287929 :
287930 : */
287931 352 : SgEnumSymbol::~SgEnumSymbol () {
287932 176 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
287933 :
287934 :
287935 : // case: not a listType for declaration
287936 176 : p_declaration = NULL; // non list case
287937 :
287938 : }
287939 :
287940 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
287941 352 : }
287942 :
287943 :
287944 : /* #line 287945 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287945 :
287946 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
287947 :
287948 : // Generated constructor
287949 1490 : SgEnumSymbol::SgEnumSymbol ( SgEnumDeclaration* declaration )
287950 1490 : : SgSymbol()
287951 : {
287952 : #ifdef DEBUG
287953 : // printf ("In SgEnumSymbol::SgEnumSymbol (SgEnumDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
287954 : #endif
287955 : #if 0
287956 : // debugging information!
287957 : printf ("In SgEnumSymbol::SgEnumSymbol (SgEnumDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
287958 : #endif
287959 :
287960 1490 : p_declaration = declaration;
287961 :
287962 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
287963 :
287964 : #if 0
287965 : // DQ (7/30/2014): Call a virtual function.
287966 : std::string s = this->class_name();
287967 : #endif
287968 :
287969 : // Test the variant virtual function
287970 : // assert(ENUM_NAME == variant());
287971 1490 : assert(ENUM_NAME == this->variant());
287972 1490 : ROSE_ASSERT(ENUM_NAME == (int)(this->variantT()));
287973 1490 : post_construction_initialization();
287974 :
287975 : // Test the isSgEnumSymbol() function since it has been problematic
287976 1490 : assert(isSgEnumSymbol(this) != NULL);
287977 1490 : }
287978 :
287979 : // Generated constructor (all data members)
287980 :
287981 : /* #line 287982 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287982 :
287983 :
287984 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287985 :
287986 :
287987 : // ********************************************************
287988 : // member functions common across all array grammar objects
287989 : // ********************************************************
287990 :
287991 :
287992 :
287993 : /* #line 287994 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
287994 :
287995 :
287996 :
287997 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
287998 :
287999 : // ********************************************************
288000 : // member functions specific to each node in the grammar
288001 : // ********************************************************
288002 :
288003 :
288004 : /* #line 288005 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288005 :
288006 : // Start of memberFunctionString
288007 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
288008 :
288009 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
288010 :
288011 : SgInitializedName*
288012 104922 : SgEnumFieldSymbol::get_declaration () const
288013 : {
288014 104922 : ROSE_ASSERT (this != NULL);
288015 :
288016 : #if 0
288017 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
288018 : // used to trigger marking transformations for the token-based unparsing.
288019 : printf ("SgEnumFieldSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
288020 : #endif
288021 :
288022 104922 : return p_declaration;
288023 : }
288024 :
288025 : void
288026 0 : SgEnumFieldSymbol::set_declaration ( SgInitializedName* declaration )
288027 : {
288028 0 : ROSE_ASSERT (this != NULL);
288029 :
288030 : #if 0
288031 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
288032 : // used to trigger marking transformations for the token-based unparsing.
288033 : printf ("SgEnumFieldSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
288034 : #endif
288035 :
288036 0 : set_isModified(true);
288037 :
288038 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
288039 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
288040 : {
288041 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
288042 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
288043 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
288044 : ROSE_ASSERT(false);
288045 : #endif
288046 : }
288047 : #endif
288048 0 : p_declaration = declaration;
288049 0 : }
288050 :
288051 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
288052 :
288053 :
288054 : // End of memberFunctionString
288055 : // Start of memberFunctionString
288056 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
288057 :
288058 : SgType*
288059 0 : SgEnumFieldSymbol::get_type() const
288060 : {
288061 0 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
288062 : }
288063 :
288064 : #if 0
288065 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
288066 : SgNode*
288067 : SgEnumFieldSymbol::get_symbol_basis() const
288068 : {
288069 : return get_type();
288070 : }
288071 : #endif
288072 :
288073 :
288074 : // End of memberFunctionString
288075 : // Start of memberFunctionString
288076 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
288077 :
288078 : SgName
288079 0 : SgEnumFieldSymbol::get_name() const
288080 : {
288081 0 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
288082 : }
288083 :
288084 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
288085 : SgNode*
288086 93045 : SgEnumFieldSymbol::get_symbol_basis() const
288087 : {
288088 93045 : return get_declaration();
288089 : }
288090 :
288091 :
288092 : // End of memberFunctionString
288093 : // Start of memberFunctionString
288094 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
288095 :
288096 : // *** COMMON CODE SECTION BEGINS HERE ***
288097 :
288098 : #if 0
288099 : int
288100 : SgEnumFieldSymbol::getVariant() const
288101 : {
288102 : // This function is used in ROSE while "variant()" is used in SAGE
288103 : assert(this != NULL);
288104 : return variant();
288105 : }
288106 : #endif
288107 :
288108 : // This function is used in ROSE in treeTraversal code
288109 : // eventually replaces getVariant() and variant()
288110 : // though after variant() has been removed for a while we will
288111 : // want to change the name of variantT() back to variant()
288112 : // (since the "T" was ment to stand for temporary).
288113 : // When this happens the variantT() will be depricated.
288114 : VariantT
288115 389896 : SgEnumFieldSymbol::variantT() const
288116 : {
288117 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
288118 389896 : ROSE_ASSERT(this != NULL);
288119 389896 : return V_SgEnumFieldSymbol;
288120 : }
288121 :
288122 : #if 0
288123 : int
288124 : SgEnumFieldSymbol::variant() const
288125 : {
288126 : // This function is used in SAGE
288127 : ROSE_ASSERT(this != NULL);
288128 : return FIELD_NAME;
288129 : }
288130 : #endif
288131 :
288132 : ROSE_DLL_API const char*
288133 0 : SgEnumFieldSymbol::sage_class_name() const
288134 : {
288135 0 : ROSE_ASSERT(this != NULL);
288136 0 : return "SgEnumFieldSymbol";
288137 : }
288138 :
288139 : std::string
288140 6390 : SgEnumFieldSymbol::class_name() const
288141 : {
288142 6390 : ROSE_ASSERT(this != NULL);
288143 6390 : return "SgEnumFieldSymbol";
288144 : }
288145 :
288146 : // DQ (11/26/2005): Support for visitor pattern mechanims
288147 : // (inferior to ROSE traversal mechanism, experimental).
288148 : void
288149 38530 : SgEnumFieldSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
288150 : {
288151 38530 : ROSE_ASSERT(this != NULL);
288152 38530 : visitor.visit(this);
288153 38530 : }
288154 :
288155 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
288156 0 : void SgEnumFieldSymbol::accept (ROSE_VisitorPattern & visitor) {
288157 0 : ROSE_ASSERT(this != NULL);
288158 0 : visitor.visit(this);
288159 0 : }
288160 :
288161 : SgEnumFieldSymbol*
288162 0 : SgEnumFieldSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
288163 : {
288164 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
288165 : // This function is currently only supported for the AST used the represent Binary executables.
288166 : if (0 /* isSgAsmNode(this) != NULL */)
288167 : {
288168 : // Support for regex specification.
288169 : std::string prefixCode = "REGEX:";
288170 : addNewAttribute(prefixCode + s,a);
288171 : }
288172 : #endif
288173 :
288174 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
288175 0 : return this;
288176 : }
288177 :
288178 : // *** COMMON CODE SECTION ENDS HERE ***
288179 :
288180 :
288181 : // End of memberFunctionString
288182 : // Start of memberFunctionString
288183 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
288184 :
288185 :
288186 : #if 0
288187 : //! Error checking support
288188 : /*! Verifies the following:
288189 : - working getVariant() member function
288190 : - calls base class's error() member function
288191 : Every class has one of these functions.
288192 : */
288193 : bool
288194 : SgEnumFieldSymbol::error()
288195 : {
288196 : // Put error checking here
288197 :
288198 : ROSE_ASSERT (this != NULL);
288199 : if (getVariant() != FIELD_NAME)
288200 : {
288201 : printf ("Error in SgEnumFieldSymbol::error(): SgEnumFieldSymbol object has a %s variant \n",
288202 : Cxx_GrammarTerminalNames[getVariant()].name);
288203 : // printf ("Error in SgEnumFieldSymbol::error() \n");
288204 : ROSE_ABORT();
288205 : }
288206 :
288207 : ROSE_ASSERT (getVariant() == FIELD_NAME);
288208 : return SgSymbol::error();
288209 : }
288210 : #endif
288211 :
288212 :
288213 :
288214 : // End of memberFunctionString
288215 :
288216 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
288217 :
288218 18838 : SgEnumFieldSymbol* isSgEnumFieldSymbol ( SgNode* inputDerivedClassPointer )
288219 : {
288220 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
288221 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
288222 : // So to fix this we return NULL directly when the input is NULL and avoid the
288223 : // dynamic_cast in this case. This is likely a performance improvement as well.
288224 : // return dynamic_cast<SgEnumFieldSymbol*>(inputDerivedClassPointer);
288225 : // Milind Chabbi (8/28/2013): isSgEnumFieldSymbol uses table-driven castability instead of c++ default dynamic_cast
288226 : // this improves the running time performance by 10-20%.
288227 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgEnumFieldSymbol*>(inputDerivedClassPointer);
288228 18838 : return IS_SgEnumFieldSymbol_FAST_MACRO(inputDerivedClassPointer);
288229 : }
288230 :
288231 : // DQ (11/8/2003): Added version of functions taking const pointer
288232 0 : const SgEnumFieldSymbol* isSgEnumFieldSymbol ( const SgNode* inputDerivedClassPointer )
288233 : {
288234 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
288235 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
288236 : // So to fix this we return NULL directly when the input is NULL and avoid the
288237 : // dynamic_cast in this case. This is likely a performance improvement as well.
288238 : // return dynamic_cast<const SgEnumFieldSymbol*>(inputDerivedClassPointer);
288239 : // Milind Chabbi (8/28/2013): isSgEnumFieldSymbol uses table-driven castability instead of c++ default dynamic_cast
288240 : // this improves the running time performance by 10-20%.
288241 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgEnumFieldSymbol*>(inputDerivedClassPointer);
288242 0 : return IS_SgEnumFieldSymbol_FAST_MACRO(inputDerivedClassPointer);
288243 : }
288244 :
288245 :
288246 :
288247 : /* #line 288248 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288248 :
288249 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
288250 :
288251 : /**
288252 : \brief Generated destructor
288253 :
288254 : This destructor is automatically generated (by ROSETTA). This destructor
288255 : only frees memory of data members associated with the parts of the current IR node which
288256 : are NOT traversed. Those data members that are part of a traversal can be freed using
288257 : a traversal (calling this destructor on all children in a post-order traversal). Such
288258 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
288259 :
288260 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
288261 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
288262 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
288263 :
288264 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
288265 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
288266 : pointers are not yet implemented to call delete on eash pointer in the container.
288267 : (This could be done by derivation from the STL containers to define containers that
288268 : automatically deleted their members.)
288269 :
288270 : */
288271 1116 : SgEnumFieldSymbol::~SgEnumFieldSymbol () {
288272 558 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
288273 :
288274 :
288275 : // case: not a listType for declaration
288276 558 : p_declaration = NULL; // non list case
288277 :
288278 : }
288279 :
288280 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
288281 1116 : }
288282 :
288283 :
288284 : /* #line 288285 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288285 :
288286 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
288287 :
288288 : // Generated constructor
288289 7006 : SgEnumFieldSymbol::SgEnumFieldSymbol ( SgInitializedName* declaration )
288290 7006 : : SgSymbol()
288291 : {
288292 : #ifdef DEBUG
288293 : // printf ("In SgEnumFieldSymbol::SgEnumFieldSymbol (SgInitializedName* declaration) sage_class_name() = %s \n",sage_class_name());
288294 : #endif
288295 : #if 0
288296 : // debugging information!
288297 : printf ("In SgEnumFieldSymbol::SgEnumFieldSymbol (SgInitializedName* declaration): this = %p = %s \n",this,this->class_name().c_str());
288298 : #endif
288299 :
288300 7006 : p_declaration = declaration;
288301 :
288302 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
288303 :
288304 : #if 0
288305 : // DQ (7/30/2014): Call a virtual function.
288306 : std::string s = this->class_name();
288307 : #endif
288308 :
288309 : // Test the variant virtual function
288310 : // assert(FIELD_NAME == variant());
288311 7006 : assert(FIELD_NAME == this->variant());
288312 7006 : ROSE_ASSERT(FIELD_NAME == (int)(this->variantT()));
288313 7006 : post_construction_initialization();
288314 :
288315 : // Test the isSgEnumFieldSymbol() function since it has been problematic
288316 7006 : assert(isSgEnumFieldSymbol(this) != NULL);
288317 7006 : }
288318 :
288319 : // Generated constructor (all data members)
288320 :
288321 : /* #line 288322 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288322 :
288323 :
288324 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
288325 :
288326 :
288327 : // ********************************************************
288328 : // member functions common across all array grammar objects
288329 : // ********************************************************
288330 :
288331 :
288332 :
288333 : /* #line 288334 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288334 :
288335 :
288336 :
288337 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
288338 :
288339 : // ********************************************************
288340 : // member functions specific to each node in the grammar
288341 : // ********************************************************
288342 :
288343 :
288344 : /* #line 288345 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288345 :
288346 : // Start of memberFunctionString
288347 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
288348 :
288349 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
288350 :
288351 : SgTypedefDeclaration*
288352 1840230 : SgTypedefSymbol::get_declaration () const
288353 : {
288354 1840230 : ROSE_ASSERT (this != NULL);
288355 :
288356 : #if 0
288357 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
288358 : // used to trigger marking transformations for the token-based unparsing.
288359 : printf ("SgTypedefSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
288360 : #endif
288361 :
288362 1840230 : return p_declaration;
288363 : }
288364 :
288365 : void
288366 0 : SgTypedefSymbol::set_declaration ( SgTypedefDeclaration* declaration )
288367 : {
288368 0 : ROSE_ASSERT (this != NULL);
288369 :
288370 : #if 0
288371 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
288372 : // used to trigger marking transformations for the token-based unparsing.
288373 : printf ("SgTypedefSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
288374 : #endif
288375 :
288376 0 : set_isModified(true);
288377 :
288378 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
288379 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
288380 : {
288381 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
288382 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
288383 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
288384 : ROSE_ASSERT(false);
288385 : #endif
288386 : }
288387 : #endif
288388 0 : p_declaration = declaration;
288389 0 : }
288390 :
288391 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
288392 :
288393 :
288394 : // End of memberFunctionString
288395 : // Start of memberFunctionString
288396 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
288397 :
288398 : SgType*
288399 0 : SgTypedefSymbol::get_type() const
288400 : {
288401 0 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
288402 : }
288403 :
288404 : #if 0
288405 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
288406 : SgNode*
288407 : SgTypedefSymbol::get_symbol_basis() const
288408 : {
288409 : return get_type();
288410 : }
288411 : #endif
288412 :
288413 :
288414 : // End of memberFunctionString
288415 : // Start of memberFunctionString
288416 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
288417 :
288418 : SgName
288419 51 : SgTypedefSymbol::get_name() const
288420 : {
288421 51 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
288422 : }
288423 :
288424 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
288425 : SgNode*
288426 307904 : SgTypedefSymbol::get_symbol_basis() const
288427 : {
288428 307904 : return get_declaration();
288429 : }
288430 :
288431 :
288432 : // End of memberFunctionString
288433 : // Start of memberFunctionString
288434 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
288435 :
288436 : // *** COMMON CODE SECTION BEGINS HERE ***
288437 :
288438 : #if 0
288439 : int
288440 : SgTypedefSymbol::getVariant() const
288441 : {
288442 : // This function is used in ROSE while "variant()" is used in SAGE
288443 : assert(this != NULL);
288444 : return variant();
288445 : }
288446 : #endif
288447 :
288448 : // This function is used in ROSE in treeTraversal code
288449 : // eventually replaces getVariant() and variant()
288450 : // though after variant() has been removed for a while we will
288451 : // want to change the name of variantT() back to variant()
288452 : // (since the "T" was ment to stand for temporary).
288453 : // When this happens the variantT() will be depricated.
288454 : VariantT
288455 12225000 : SgTypedefSymbol::variantT() const
288456 : {
288457 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
288458 12225000 : ROSE_ASSERT(this != NULL);
288459 12225000 : return V_SgTypedefSymbol;
288460 : }
288461 :
288462 : #if 0
288463 : int
288464 : SgTypedefSymbol::variant() const
288465 : {
288466 : // This function is used in SAGE
288467 : ROSE_ASSERT(this != NULL);
288468 : return TYPEDEF_NAME;
288469 : }
288470 : #endif
288471 :
288472 : ROSE_DLL_API const char*
288473 0 : SgTypedefSymbol::sage_class_name() const
288474 : {
288475 0 : ROSE_ASSERT(this != NULL);
288476 0 : return "SgTypedefSymbol";
288477 : }
288478 :
288479 : std::string
288480 49958 : SgTypedefSymbol::class_name() const
288481 : {
288482 49958 : ROSE_ASSERT(this != NULL);
288483 49958 : return "SgTypedefSymbol";
288484 : }
288485 :
288486 : // DQ (11/26/2005): Support for visitor pattern mechanims
288487 : // (inferior to ROSE traversal mechanism, experimental).
288488 : void
288489 223774 : SgTypedefSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
288490 : {
288491 223774 : ROSE_ASSERT(this != NULL);
288492 223774 : visitor.visit(this);
288493 223774 : }
288494 :
288495 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
288496 0 : void SgTypedefSymbol::accept (ROSE_VisitorPattern & visitor) {
288497 0 : ROSE_ASSERT(this != NULL);
288498 0 : visitor.visit(this);
288499 0 : }
288500 :
288501 : SgTypedefSymbol*
288502 0 : SgTypedefSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
288503 : {
288504 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
288505 : // This function is currently only supported for the AST used the represent Binary executables.
288506 : if (0 /* isSgAsmNode(this) != NULL */)
288507 : {
288508 : // Support for regex specification.
288509 : std::string prefixCode = "REGEX:";
288510 : addNewAttribute(prefixCode + s,a);
288511 : }
288512 : #endif
288513 :
288514 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
288515 0 : return this;
288516 : }
288517 :
288518 : // *** COMMON CODE SECTION ENDS HERE ***
288519 :
288520 :
288521 : // End of memberFunctionString
288522 : // Start of memberFunctionString
288523 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
288524 :
288525 :
288526 : #if 0
288527 : //! Error checking support
288528 : /*! Verifies the following:
288529 : - working getVariant() member function
288530 : - calls base class's error() member function
288531 : Every class has one of these functions.
288532 : */
288533 : bool
288534 : SgTypedefSymbol::error()
288535 : {
288536 : // Put error checking here
288537 :
288538 : ROSE_ASSERT (this != NULL);
288539 : if (getVariant() != TYPEDEF_NAME)
288540 : {
288541 : printf ("Error in SgTypedefSymbol::error(): SgTypedefSymbol object has a %s variant \n",
288542 : Cxx_GrammarTerminalNames[getVariant()].name);
288543 : // printf ("Error in SgTypedefSymbol::error() \n");
288544 : ROSE_ABORT();
288545 : }
288546 :
288547 : ROSE_ASSERT (getVariant() == TYPEDEF_NAME);
288548 : return SgSymbol::error();
288549 : }
288550 : #endif
288551 :
288552 :
288553 :
288554 : // End of memberFunctionString
288555 :
288556 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
288557 :
288558 2900320 : SgTypedefSymbol* isSgTypedefSymbol ( SgNode* inputDerivedClassPointer )
288559 : {
288560 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
288561 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
288562 : // So to fix this we return NULL directly when the input is NULL and avoid the
288563 : // dynamic_cast in this case. This is likely a performance improvement as well.
288564 : // return dynamic_cast<SgTypedefSymbol*>(inputDerivedClassPointer);
288565 : // Milind Chabbi (8/28/2013): isSgTypedefSymbol uses table-driven castability instead of c++ default dynamic_cast
288566 : // this improves the running time performance by 10-20%.
288567 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTypedefSymbol*>(inputDerivedClassPointer);
288568 2900320 : return IS_SgTypedefSymbol_FAST_MACRO(inputDerivedClassPointer);
288569 : }
288570 :
288571 : // DQ (11/8/2003): Added version of functions taking const pointer
288572 51 : const SgTypedefSymbol* isSgTypedefSymbol ( const SgNode* inputDerivedClassPointer )
288573 : {
288574 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
288575 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
288576 : // So to fix this we return NULL directly when the input is NULL and avoid the
288577 : // dynamic_cast in this case. This is likely a performance improvement as well.
288578 : // return dynamic_cast<const SgTypedefSymbol*>(inputDerivedClassPointer);
288579 : // Milind Chabbi (8/28/2013): isSgTypedefSymbol uses table-driven castability instead of c++ default dynamic_cast
288580 : // this improves the running time performance by 10-20%.
288581 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTypedefSymbol*>(inputDerivedClassPointer);
288582 51 : return IS_SgTypedefSymbol_FAST_MACRO(inputDerivedClassPointer);
288583 : }
288584 :
288585 :
288586 :
288587 : /* #line 288588 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288588 :
288589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
288590 :
288591 : /**
288592 : \brief Generated destructor
288593 :
288594 : This destructor is automatically generated (by ROSETTA). This destructor
288595 : only frees memory of data members associated with the parts of the current IR node which
288596 : are NOT traversed. Those data members that are part of a traversal can be freed using
288597 : a traversal (calling this destructor on all children in a post-order traversal). Such
288598 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
288599 :
288600 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
288601 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
288602 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
288603 :
288604 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
288605 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
288606 : pointers are not yet implemented to call delete on eash pointer in the container.
288607 : (This could be done by derivation from the STL containers to define containers that
288608 : automatically deleted their members.)
288609 :
288610 : */
288611 7196 : SgTypedefSymbol::~SgTypedefSymbol () {
288612 3758 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
288613 :
288614 :
288615 : // case: not a listType for declaration
288616 3758 : p_declaration = NULL; // non list case
288617 :
288618 : }
288619 :
288620 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
288621 7196 : }
288622 :
288623 :
288624 : /* #line 288625 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288625 :
288626 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
288627 :
288628 : // Generated constructor
288629 56574 : SgTypedefSymbol::SgTypedefSymbol ( SgTypedefDeclaration* declaration )
288630 56574 : : SgSymbol()
288631 : {
288632 : #ifdef DEBUG
288633 : // printf ("In SgTypedefSymbol::SgTypedefSymbol (SgTypedefDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
288634 : #endif
288635 : #if 0
288636 : // debugging information!
288637 : printf ("In SgTypedefSymbol::SgTypedefSymbol (SgTypedefDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
288638 : #endif
288639 :
288640 56574 : p_declaration = declaration;
288641 :
288642 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
288643 :
288644 : #if 0
288645 : // DQ (7/30/2014): Call a virtual function.
288646 : std::string s = this->class_name();
288647 : #endif
288648 :
288649 : // Test the variant virtual function
288650 : // assert(TYPEDEF_NAME == variant());
288651 56574 : assert(TYPEDEF_NAME == this->variant());
288652 56574 : ROSE_ASSERT(TYPEDEF_NAME == (int)(this->variantT()));
288653 56574 : post_construction_initialization();
288654 :
288655 : // Test the isSgTypedefSymbol() function since it has been problematic
288656 56574 : assert(isSgTypedefSymbol(this) != NULL);
288657 56574 : }
288658 :
288659 : // Generated constructor (all data members)
288660 :
288661 : /* #line 288662 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288662 :
288663 :
288664 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
288665 :
288666 :
288667 : // ********************************************************
288668 : // member functions common across all array grammar objects
288669 : // ********************************************************
288670 :
288671 :
288672 :
288673 : /* #line 288674 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288674 :
288675 :
288676 :
288677 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
288678 :
288679 : // ********************************************************
288680 : // member functions specific to each node in the grammar
288681 : // ********************************************************
288682 :
288683 :
288684 : /* #line 288685 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288685 :
288686 : // Start of memberFunctionString
288687 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
288688 :
288689 : SgType*
288690 0 : SgTemplateTypedefSymbol::get_type() const
288691 : {
288692 0 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
288693 : }
288694 :
288695 : #if 0
288696 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
288697 : SgNode*
288698 : SgTemplateTypedefSymbol::get_symbol_basis() const
288699 : {
288700 : return get_type();
288701 : }
288702 : #endif
288703 :
288704 :
288705 : // End of memberFunctionString
288706 : // Start of memberFunctionString
288707 : /* #line 565 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
288708 :
288709 : SgName
288710 0 : SgTemplateTypedefSymbol::get_name() const
288711 : {
288712 0 : return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
288713 : }
288714 :
288715 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
288716 : SgNode*
288717 6642 : SgTemplateTypedefSymbol::get_symbol_basis() const
288718 : {
288719 6642 : return get_declaration();
288720 : }
288721 :
288722 :
288723 : // End of memberFunctionString
288724 : // Start of memberFunctionString
288725 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
288726 :
288727 : // *** COMMON CODE SECTION BEGINS HERE ***
288728 :
288729 : #if 0
288730 : int
288731 : SgTemplateTypedefSymbol::getVariant() const
288732 : {
288733 : // This function is used in ROSE while "variant()" is used in SAGE
288734 : assert(this != NULL);
288735 : return variant();
288736 : }
288737 : #endif
288738 :
288739 : // This function is used in ROSE in treeTraversal code
288740 : // eventually replaces getVariant() and variant()
288741 : // though after variant() has been removed for a while we will
288742 : // want to change the name of variantT() back to variant()
288743 : // (since the "T" was ment to stand for temporary).
288744 : // When this happens the variantT() will be depricated.
288745 : VariantT
288746 82667 : SgTemplateTypedefSymbol::variantT() const
288747 : {
288748 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
288749 82667 : ROSE_ASSERT(this != NULL);
288750 82667 : return V_SgTemplateTypedefSymbol;
288751 : }
288752 :
288753 : #if 0
288754 : int
288755 : SgTemplateTypedefSymbol::variant() const
288756 : {
288757 : // This function is used in SAGE
288758 : ROSE_ASSERT(this != NULL);
288759 : return TEMPLATE_TYPEDEF_NAME;
288760 : }
288761 : #endif
288762 :
288763 : ROSE_DLL_API const char*
288764 0 : SgTemplateTypedefSymbol::sage_class_name() const
288765 : {
288766 0 : ROSE_ASSERT(this != NULL);
288767 0 : return "SgTemplateTypedefSymbol";
288768 : }
288769 :
288770 : std::string
288771 1230 : SgTemplateTypedefSymbol::class_name() const
288772 : {
288773 1230 : ROSE_ASSERT(this != NULL);
288774 1230 : return "SgTemplateTypedefSymbol";
288775 : }
288776 :
288777 : // DQ (11/26/2005): Support for visitor pattern mechanims
288778 : // (inferior to ROSE traversal mechanism, experimental).
288779 : void
288780 21957 : SgTemplateTypedefSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
288781 : {
288782 21957 : ROSE_ASSERT(this != NULL);
288783 21957 : visitor.visit(this);
288784 21957 : }
288785 :
288786 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
288787 0 : void SgTemplateTypedefSymbol::accept (ROSE_VisitorPattern & visitor) {
288788 0 : ROSE_ASSERT(this != NULL);
288789 0 : visitor.visit(this);
288790 0 : }
288791 :
288792 : SgTemplateTypedefSymbol*
288793 0 : SgTemplateTypedefSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
288794 : {
288795 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
288796 : // This function is currently only supported for the AST used the represent Binary executables.
288797 : if (0 /* isSgAsmNode(this) != NULL */)
288798 : {
288799 : // Support for regex specification.
288800 : std::string prefixCode = "REGEX:";
288801 : addNewAttribute(prefixCode + s,a);
288802 : }
288803 : #endif
288804 :
288805 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
288806 0 : return this;
288807 : }
288808 :
288809 : // *** COMMON CODE SECTION ENDS HERE ***
288810 :
288811 :
288812 : // End of memberFunctionString
288813 : // Start of memberFunctionString
288814 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
288815 :
288816 :
288817 : #if 0
288818 : //! Error checking support
288819 : /*! Verifies the following:
288820 : - working getVariant() member function
288821 : - calls base class's error() member function
288822 : Every class has one of these functions.
288823 : */
288824 : bool
288825 : SgTemplateTypedefSymbol::error()
288826 : {
288827 : // Put error checking here
288828 :
288829 : ROSE_ASSERT (this != NULL);
288830 : if (getVariant() != TEMPLATE_TYPEDEF_NAME)
288831 : {
288832 : printf ("Error in SgTemplateTypedefSymbol::error(): SgTemplateTypedefSymbol object has a %s variant \n",
288833 : Cxx_GrammarTerminalNames[getVariant()].name);
288834 : // printf ("Error in SgTemplateTypedefSymbol::error() \n");
288835 : ROSE_ABORT();
288836 : }
288837 :
288838 : ROSE_ASSERT (getVariant() == TEMPLATE_TYPEDEF_NAME);
288839 : return SgTypedefSymbol::error();
288840 : }
288841 : #endif
288842 :
288843 :
288844 :
288845 : // End of memberFunctionString
288846 :
288847 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
288848 :
288849 2970 : SgTemplateTypedefSymbol* isSgTemplateTypedefSymbol ( SgNode* inputDerivedClassPointer )
288850 : {
288851 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
288852 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
288853 : // So to fix this we return NULL directly when the input is NULL and avoid the
288854 : // dynamic_cast in this case. This is likely a performance improvement as well.
288855 : // return dynamic_cast<SgTemplateTypedefSymbol*>(inputDerivedClassPointer);
288856 : // Milind Chabbi (8/28/2013): isSgTemplateTypedefSymbol uses table-driven castability instead of c++ default dynamic_cast
288857 : // this improves the running time performance by 10-20%.
288858 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgTemplateTypedefSymbol*>(inputDerivedClassPointer);
288859 2970 : return IS_SgTemplateTypedefSymbol_FAST_MACRO(inputDerivedClassPointer);
288860 : }
288861 :
288862 : // DQ (11/8/2003): Added version of functions taking const pointer
288863 0 : const SgTemplateTypedefSymbol* isSgTemplateTypedefSymbol ( const SgNode* inputDerivedClassPointer )
288864 : {
288865 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
288866 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
288867 : // So to fix this we return NULL directly when the input is NULL and avoid the
288868 : // dynamic_cast in this case. This is likely a performance improvement as well.
288869 : // return dynamic_cast<const SgTemplateTypedefSymbol*>(inputDerivedClassPointer);
288870 : // Milind Chabbi (8/28/2013): isSgTemplateTypedefSymbol uses table-driven castability instead of c++ default dynamic_cast
288871 : // this improves the running time performance by 10-20%.
288872 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgTemplateTypedefSymbol*>(inputDerivedClassPointer);
288873 0 : return IS_SgTemplateTypedefSymbol_FAST_MACRO(inputDerivedClassPointer);
288874 : }
288875 :
288876 :
288877 :
288878 : /* #line 288879 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288879 :
288880 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
288881 :
288882 : /**
288883 : \brief Generated destructor
288884 :
288885 : This destructor is automatically generated (by ROSETTA). This destructor
288886 : only frees memory of data members associated with the parts of the current IR node which
288887 : are NOT traversed. Those data members that are part of a traversal can be freed using
288888 : a traversal (calling this destructor on all children in a post-order traversal). Such
288889 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
288890 :
288891 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
288892 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
288893 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
288894 :
288895 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
288896 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
288897 : pointers are not yet implemented to call delete on eash pointer in the container.
288898 : (This could be done by derivation from the STL containers to define containers that
288899 : automatically deleted their members.)
288900 :
288901 : */
288902 640 : SgTemplateTypedefSymbol::~SgTemplateTypedefSymbol () {
288903 320 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
288904 :
288905 :
288906 :
288907 : }
288908 :
288909 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
288910 640 : }
288911 :
288912 :
288913 : /* #line 288914 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288914 :
288915 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
288916 :
288917 : // Generated constructor
288918 1494 : SgTemplateTypedefSymbol::SgTemplateTypedefSymbol ( SgTypedefDeclaration* declaration )
288919 1494 : : SgTypedefSymbol(declaration)
288920 : {
288921 : #ifdef DEBUG
288922 : // printf ("In SgTemplateTypedefSymbol::SgTemplateTypedefSymbol (SgTypedefDeclaration* declaration) sage_class_name() = %s \n",sage_class_name());
288923 : #endif
288924 : #if 0
288925 : // debugging information!
288926 : printf ("In SgTemplateTypedefSymbol::SgTemplateTypedefSymbol (SgTypedefDeclaration* declaration): this = %p = %s \n",this,this->class_name().c_str());
288927 : #endif
288928 :
288929 :
288930 :
288931 : #if 0
288932 : // DQ (7/30/2014): Call a virtual function.
288933 : std::string s = this->class_name();
288934 : #endif
288935 :
288936 : // Test the variant virtual function
288937 : // assert(TEMPLATE_TYPEDEF_NAME == variant());
288938 1494 : assert(TEMPLATE_TYPEDEF_NAME == this->variant());
288939 1494 : ROSE_ASSERT(TEMPLATE_TYPEDEF_NAME == (int)(this->variantT()));
288940 1494 : post_construction_initialization();
288941 :
288942 : // Test the isSgTemplateTypedefSymbol() function since it has been problematic
288943 1494 : assert(isSgTemplateTypedefSymbol(this) != NULL);
288944 1494 : }
288945 :
288946 : // Generated constructor (all data members)
288947 :
288948 : /* #line 288949 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288949 :
288950 :
288951 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
288952 :
288953 :
288954 : // ********************************************************
288955 : // member functions common across all array grammar objects
288956 : // ********************************************************
288957 :
288958 :
288959 :
288960 : /* #line 288961 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288961 :
288962 :
288963 :
288964 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
288965 :
288966 : // ********************************************************
288967 : // member functions specific to each node in the grammar
288968 : // ********************************************************
288969 :
288970 :
288971 : /* #line 288972 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
288972 :
288973 : // Start of memberFunctionString
288974 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
288975 :
288976 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
288977 :
288978 : SgLabelStatement*
288979 80 : SgLabelSymbol::get_declaration () const
288980 : {
288981 80 : ROSE_ASSERT (this != NULL);
288982 :
288983 : #if 0
288984 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
288985 : // used to trigger marking transformations for the token-based unparsing.
288986 : printf ("SgLabelSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
288987 : #endif
288988 :
288989 80 : return p_declaration;
288990 : }
288991 :
288992 : void
288993 0 : SgLabelSymbol::set_declaration ( SgLabelStatement* declaration )
288994 : {
288995 0 : ROSE_ASSERT (this != NULL);
288996 :
288997 : #if 0
288998 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
288999 : // used to trigger marking transformations for the token-based unparsing.
289000 : printf ("SgLabelSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
289001 : #endif
289002 :
289003 0 : set_isModified(true);
289004 :
289005 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
289006 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
289007 : {
289008 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
289009 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
289010 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
289011 : ROSE_ASSERT(false);
289012 : #endif
289013 : }
289014 : #endif
289015 0 : p_declaration = declaration;
289016 0 : }
289017 :
289018 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289019 :
289020 :
289021 : // End of memberFunctionString
289022 : // Start of memberFunctionString
289023 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289024 :
289025 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289026 :
289027 : SgStatement*
289028 36 : SgLabelSymbol::get_fortran_statement () const
289029 : {
289030 36 : ROSE_ASSERT (this != NULL);
289031 :
289032 : #if 0
289033 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289034 : // used to trigger marking transformations for the token-based unparsing.
289035 : printf ("SgLabelSymbol::get_fortran_statement = %p = %s \n",this,this->class_name().c_str());
289036 : #endif
289037 :
289038 36 : return p_fortran_statement;
289039 : }
289040 :
289041 : void
289042 10 : SgLabelSymbol::set_fortran_statement ( SgStatement* fortran_statement )
289043 : {
289044 10 : ROSE_ASSERT (this != NULL);
289045 :
289046 : #if 0
289047 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289048 : // used to trigger marking transformations for the token-based unparsing.
289049 : printf ("SgLabelSymbol::set_fortran_statement = %p = %s \n",this,this->class_name().c_str());
289050 : #endif
289051 :
289052 10 : set_isModified(true);
289053 :
289054 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
289055 : if (p_fortran_statement != NULL && fortran_statement != NULL && p_fortran_statement != fortran_statement)
289056 : {
289057 : printf ("Warning: fortran_statement = %p overwriting valid pointer p_fortran_statement = %p \n",fortran_statement,p_fortran_statement);
289058 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
289059 : printf ("Error fails assertion (p_fortran_statement != NULL && fortran_statement != NULL && p_fortran_statement != fortran_statement) is false\n");
289060 : ROSE_ASSERT(false);
289061 : #endif
289062 : }
289063 : #endif
289064 10 : p_fortran_statement = fortran_statement;
289065 10 : }
289066 :
289067 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289068 :
289069 :
289070 : // End of memberFunctionString
289071 : // Start of memberFunctionString
289072 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289073 :
289074 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289075 :
289076 : SgInitializedName*
289077 0 : SgLabelSymbol::get_fortran_alternate_return_parameter () const
289078 : {
289079 0 : ROSE_ASSERT (this != NULL);
289080 :
289081 : #if 0
289082 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289083 : // used to trigger marking transformations for the token-based unparsing.
289084 : printf ("SgLabelSymbol::get_fortran_alternate_return_parameter = %p = %s \n",this,this->class_name().c_str());
289085 : #endif
289086 :
289087 0 : return p_fortran_alternate_return_parameter;
289088 : }
289089 :
289090 : void
289091 0 : SgLabelSymbol::set_fortran_alternate_return_parameter ( SgInitializedName* fortran_alternate_return_parameter )
289092 : {
289093 0 : ROSE_ASSERT (this != NULL);
289094 :
289095 : #if 0
289096 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289097 : // used to trigger marking transformations for the token-based unparsing.
289098 : printf ("SgLabelSymbol::set_fortran_alternate_return_parameter = %p = %s \n",this,this->class_name().c_str());
289099 : #endif
289100 :
289101 0 : set_isModified(true);
289102 :
289103 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
289104 : if (p_fortran_alternate_return_parameter != NULL && fortran_alternate_return_parameter != NULL && p_fortran_alternate_return_parameter != fortran_alternate_return_parameter)
289105 : {
289106 : printf ("Warning: fortran_alternate_return_parameter = %p overwriting valid pointer p_fortran_alternate_return_parameter = %p \n",fortran_alternate_return_parameter,p_fortran_alternate_return_parameter);
289107 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
289108 : printf ("Error fails assertion (p_fortran_alternate_return_parameter != NULL && fortran_alternate_return_parameter != NULL && p_fortran_alternate_return_parameter != fortran_alternate_return_parameter) is false\n");
289109 : ROSE_ASSERT(false);
289110 : #endif
289111 : }
289112 : #endif
289113 0 : p_fortran_alternate_return_parameter = fortran_alternate_return_parameter;
289114 0 : }
289115 :
289116 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289117 :
289118 :
289119 : // End of memberFunctionString
289120 : // Start of memberFunctionString
289121 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289122 :
289123 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289124 :
289125 : int
289126 13 : SgLabelSymbol::get_numeric_label_value () const
289127 : {
289128 13 : ROSE_ASSERT (this != NULL);
289129 :
289130 : #if 0
289131 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289132 : // used to trigger marking transformations for the token-based unparsing.
289133 : printf ("SgLabelSymbol::get_numeric_label_value = %p = %s \n",this,this->class_name().c_str());
289134 : #endif
289135 :
289136 13 : return p_numeric_label_value;
289137 : }
289138 :
289139 : void
289140 4 : SgLabelSymbol::set_numeric_label_value ( int numeric_label_value )
289141 : {
289142 4 : ROSE_ASSERT (this != NULL);
289143 :
289144 : #if 0
289145 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289146 : // used to trigger marking transformations for the token-based unparsing.
289147 : printf ("SgLabelSymbol::set_numeric_label_value = %p = %s \n",this,this->class_name().c_str());
289148 : #endif
289149 :
289150 4 : set_isModified(true);
289151 :
289152 4 : p_numeric_label_value = numeric_label_value;
289153 4 : }
289154 :
289155 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289156 :
289157 :
289158 : // End of memberFunctionString
289159 : // Start of memberFunctionString
289160 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289161 :
289162 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289163 :
289164 : SgLabelSymbol::label_type_enum
289165 0 : SgLabelSymbol::get_label_type () const
289166 : {
289167 0 : ROSE_ASSERT (this != NULL);
289168 :
289169 : #if 0
289170 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289171 : // used to trigger marking transformations for the token-based unparsing.
289172 : printf ("SgLabelSymbol::get_label_type = %p = %s \n",this,this->class_name().c_str());
289173 : #endif
289174 :
289175 0 : return p_label_type;
289176 : }
289177 :
289178 : void
289179 8 : SgLabelSymbol::set_label_type ( SgLabelSymbol::label_type_enum label_type )
289180 : {
289181 8 : ROSE_ASSERT (this != NULL);
289182 :
289183 : #if 0
289184 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289185 : // used to trigger marking transformations for the token-based unparsing.
289186 : printf ("SgLabelSymbol::set_label_type = %p = %s \n",this,this->class_name().c_str());
289187 : #endif
289188 :
289189 8 : set_isModified(true);
289190 :
289191 8 : p_label_type = label_type;
289192 8 : }
289193 :
289194 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289195 :
289196 :
289197 : // End of memberFunctionString
289198 : // Start of memberFunctionString
289199 : /* #line 614 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
289200 :
289201 : SgName
289202 10 : SgLabelSymbol::get_name() const
289203 : {
289204 : // DQ (12/9/2007): This IR node has been modified to hold a SgStatement in addition
289205 : // to a SgLabelStatement. by leaving the pointer to a SgLabelStatement I don't change
289206 : // anything about how the C/C++ case works, but I have added a pointer to a SgStatement
289207 : // so that the Fortran support can reference any statement (to support numeric labels
289208 : // and non-numeric labels as well, though this is not yet implemented). I plan to
289209 : // merge the support for C/C++ and fortran a bit later after I am sure that this
289210 : // approach will work.
289211 :
289212 : // This handles the general case where for C/C++ the declaration statement is not set,
289213 : // but I think this should be an error. Except that we have to handle the case of a
289214 : // label with unassociated statement in C. So maybe we need to handle this case!
289215 :
289216 : // Previous implementation.
289217 : // return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
289218 :
289219 10 : SgName name;
289220 10 : if (get_declaration() != NULL)
289221 : {
289222 7 : name = get_declaration()->get_name();
289223 : }
289224 : else
289225 : {
289226 3 : SgStatement* fortranStatement = get_fortran_statement();
289227 : #if 0
289228 : ROSE_ASSERT(fortranStatement != NULL);
289229 :
289230 : // int numericLabel = fortranStatement->get_numeric_label();
289231 : int numericLabel = get_numeric_label_value();
289232 : // printf ("SgLabelSymbol::get_name(): numericLabel = %d \n",numericLabel);
289233 :
289234 : name = Rose::StringUtility::numberToString(numericLabel);
289235 : #else
289236 3 : if (fortranStatement != NULL)
289237 : {
289238 3 : int numericLabel = get_numeric_label_value();
289239 3 : name = Rose::StringUtility::numberToString(numericLabel);
289240 : }
289241 : else
289242 : {
289243 : // DQ (2/2/2011): Fortran specific code.
289244 0 : SgInitializedName* alternativeReturnDeclaration = get_fortran_alternate_return_parameter();
289245 0 : if (alternativeReturnDeclaration != NULL)
289246 : {
289247 0 : name = alternativeReturnDeclaration->get_name();
289248 : }
289249 : }
289250 : #endif
289251 : }
289252 :
289253 10 : return name;
289254 : }
289255 :
289256 : // DQ (2/1/2011): This function has the wrong semantics for the case of labels.
289257 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
289258 : SgNode*
289259 43 : SgLabelSymbol::get_symbol_basis() const
289260 : {
289261 : // DQ (12/9/2007): Modified (see comment above).
289262 : // return get_declaration();
289263 :
289264 : #if 0
289265 : // DQ (2/2/2011): This is OK since this is the C/C++ semantics.
289266 : // DQ (2/1/2011): This function has the wrong semantics for the case of labels.
289267 : // I am not clear how to handle this function, but I think it is required to support
289268 : // internal testing of the symbol tables. If we supported a pointer to the
289269 : // SgInitializedName object used in the function declaration's parameter list,
289270 : // then we could use that as a concept of declaration (similar to the semantics of
289271 : // a SgVariableSymbol).
289272 :
289273 : printf ("Error: This function has the wrong semantics for the case of labels. \n");
289274 : ROSE_ASSERT(false);
289275 : #endif
289276 :
289277 : // SgStatement* returnStatement = get_declaration();
289278 43 : SgLocatedNode* returnStatement = get_declaration();
289279 43 : if (returnStatement == NULL)
289280 : {
289281 18 : SgStatement* fortranStatement = get_fortran_statement();
289282 : #if 0
289283 : ROSE_ASSERT(fortranStatement != NULL);
289284 : returnStatement = fortranStatement;
289285 : #else
289286 18 : if (fortranStatement != NULL)
289287 : {
289288 : returnStatement = fortranStatement;
289289 : }
289290 : else
289291 : {
289292 0 : SgInitializedName* alternativeReturnDeclaration = get_fortran_alternate_return_parameter();
289293 0 : if (alternativeReturnDeclaration != NULL)
289294 : {
289295 0 : returnStatement = alternativeReturnDeclaration;
289296 : }
289297 : }
289298 : #endif
289299 : }
289300 :
289301 43 : return returnStatement;
289302 : }
289303 :
289304 : SgType*
289305 0 : SgLabelSymbol::get_type() const
289306 : {
289307 : // DQ (2/1/2011): Label symbols can only have a label type.
289308 0 : return SgTypeLabel::createType();
289309 : }
289310 :
289311 : // DQ (2/1/2011): Added support for named lable to handle arternative return parameters in Fortran.
289312 0 : SgLabelSymbol::SgLabelSymbol ( SgInitializedName* initializedName )
289313 0 : : SgSymbol()
289314 : {
289315 : // This constructor is used to support Fortran alternative return parameters in the function declaration.
289316 : // Note that we don't really use the name but I didn't want to make this a default constructor.
289317 :
289318 : // We could support a pointer to the SgInitializedName object used in the function declaration's parameter list.
289319 0 : ROSE_ASSERT(initializedName != NULL);
289320 :
289321 : // Verify that this is used correctly.
289322 0 : ROSE_ASSERT(initializedName->get_name() == "*");
289323 :
289324 : // Set the internal mode to support analysis...
289325 0 : p_label_type = e_alternative_return_type;
289326 :
289327 0 : set_fortran_alternate_return_parameter(initializedName);
289328 0 : }
289329 :
289330 :
289331 :
289332 : // End of memberFunctionString
289333 : // Start of memberFunctionString
289334 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
289335 :
289336 : // *** COMMON CODE SECTION BEGINS HERE ***
289337 :
289338 : #if 0
289339 : int
289340 : SgLabelSymbol::getVariant() const
289341 : {
289342 : // This function is used in ROSE while "variant()" is used in SAGE
289343 : assert(this != NULL);
289344 : return variant();
289345 : }
289346 : #endif
289347 :
289348 : // This function is used in ROSE in treeTraversal code
289349 : // eventually replaces getVariant() and variant()
289350 : // though after variant() has been removed for a while we will
289351 : // want to change the name of variantT() back to variant()
289352 : // (since the "T" was ment to stand for temporary).
289353 : // When this happens the variantT() will be depricated.
289354 : VariantT
289355 420 : SgLabelSymbol::variantT() const
289356 : {
289357 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
289358 420 : ROSE_ASSERT(this != NULL);
289359 420 : return V_SgLabelSymbol;
289360 : }
289361 :
289362 : #if 0
289363 : int
289364 : SgLabelSymbol::variant() const
289365 : {
289366 : // This function is used in SAGE
289367 : ROSE_ASSERT(this != NULL);
289368 : return LABEL_NAME;
289369 : }
289370 : #endif
289371 :
289372 : ROSE_DLL_API const char*
289373 0 : SgLabelSymbol::sage_class_name() const
289374 : {
289375 0 : ROSE_ASSERT(this != NULL);
289376 0 : return "SgLabelSymbol";
289377 : }
289378 :
289379 : std::string
289380 9 : SgLabelSymbol::class_name() const
289381 : {
289382 9 : ROSE_ASSERT(this != NULL);
289383 9 : return "SgLabelSymbol";
289384 : }
289385 :
289386 : // DQ (11/26/2005): Support for visitor pattern mechanims
289387 : // (inferior to ROSE traversal mechanism, experimental).
289388 : void
289389 36 : SgLabelSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
289390 : {
289391 36 : ROSE_ASSERT(this != NULL);
289392 36 : visitor.visit(this);
289393 36 : }
289394 :
289395 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
289396 0 : void SgLabelSymbol::accept (ROSE_VisitorPattern & visitor) {
289397 0 : ROSE_ASSERT(this != NULL);
289398 0 : visitor.visit(this);
289399 0 : }
289400 :
289401 : SgLabelSymbol*
289402 0 : SgLabelSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
289403 : {
289404 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
289405 : // This function is currently only supported for the AST used the represent Binary executables.
289406 : if (0 /* isSgAsmNode(this) != NULL */)
289407 : {
289408 : // Support for regex specification.
289409 : std::string prefixCode = "REGEX:";
289410 : addNewAttribute(prefixCode + s,a);
289411 : }
289412 : #endif
289413 :
289414 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
289415 0 : return this;
289416 : }
289417 :
289418 : // *** COMMON CODE SECTION ENDS HERE ***
289419 :
289420 :
289421 : // End of memberFunctionString
289422 : // Start of memberFunctionString
289423 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
289424 :
289425 :
289426 : #if 0
289427 : //! Error checking support
289428 : /*! Verifies the following:
289429 : - working getVariant() member function
289430 : - calls base class's error() member function
289431 : Every class has one of these functions.
289432 : */
289433 : bool
289434 : SgLabelSymbol::error()
289435 : {
289436 : // Put error checking here
289437 :
289438 : ROSE_ASSERT (this != NULL);
289439 : if (getVariant() != LABEL_NAME)
289440 : {
289441 : printf ("Error in SgLabelSymbol::error(): SgLabelSymbol object has a %s variant \n",
289442 : Cxx_GrammarTerminalNames[getVariant()].name);
289443 : // printf ("Error in SgLabelSymbol::error() \n");
289444 : ROSE_ABORT();
289445 : }
289446 :
289447 : ROSE_ASSERT (getVariant() == LABEL_NAME);
289448 : return SgSymbol::error();
289449 : }
289450 : #endif
289451 :
289452 :
289453 :
289454 : // End of memberFunctionString
289455 :
289456 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
289457 :
289458 933064 : SgLabelSymbol* isSgLabelSymbol ( SgNode* inputDerivedClassPointer )
289459 : {
289460 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
289461 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
289462 : // So to fix this we return NULL directly when the input is NULL and avoid the
289463 : // dynamic_cast in this case. This is likely a performance improvement as well.
289464 : // return dynamic_cast<SgLabelSymbol*>(inputDerivedClassPointer);
289465 : // Milind Chabbi (8/28/2013): isSgLabelSymbol uses table-driven castability instead of c++ default dynamic_cast
289466 : // this improves the running time performance by 10-20%.
289467 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgLabelSymbol*>(inputDerivedClassPointer);
289468 933064 : return IS_SgLabelSymbol_FAST_MACRO(inputDerivedClassPointer);
289469 : }
289470 :
289471 : // DQ (11/8/2003): Added version of functions taking const pointer
289472 0 : const SgLabelSymbol* isSgLabelSymbol ( const SgNode* inputDerivedClassPointer )
289473 : {
289474 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
289475 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
289476 : // So to fix this we return NULL directly when the input is NULL and avoid the
289477 : // dynamic_cast in this case. This is likely a performance improvement as well.
289478 : // return dynamic_cast<const SgLabelSymbol*>(inputDerivedClassPointer);
289479 : // Milind Chabbi (8/28/2013): isSgLabelSymbol uses table-driven castability instead of c++ default dynamic_cast
289480 : // this improves the running time performance by 10-20%.
289481 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgLabelSymbol*>(inputDerivedClassPointer);
289482 0 : return IS_SgLabelSymbol_FAST_MACRO(inputDerivedClassPointer);
289483 : }
289484 :
289485 :
289486 :
289487 : /* #line 289488 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289488 :
289489 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
289490 :
289491 : /**
289492 : \brief Generated destructor
289493 :
289494 : This destructor is automatically generated (by ROSETTA). This destructor
289495 : only frees memory of data members associated with the parts of the current IR node which
289496 : are NOT traversed. Those data members that are part of a traversal can be freed using
289497 : a traversal (calling this destructor on all children in a post-order traversal). Such
289498 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
289499 :
289500 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
289501 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
289502 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
289503 :
289504 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
289505 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
289506 : pointers are not yet implemented to call delete on eash pointer in the container.
289507 : (This could be done by derivation from the STL containers to define containers that
289508 : automatically deleted their members.)
289509 :
289510 : */
289511 0 : SgLabelSymbol::~SgLabelSymbol () {
289512 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
289513 :
289514 :
289515 : // case: not a listType for declaration
289516 0 : p_declaration = NULL; // non list case
289517 : // case: not a listType for fortran_statement
289518 0 : p_fortran_statement = NULL; // non list case
289519 : // case: not a listType for fortran_alternate_return_parameter
289520 0 : p_fortran_alternate_return_parameter = NULL; // non list case
289521 : // case: not a listType for numeric_label_value
289522 0 : p_numeric_label_value = -1; // non list case
289523 : // case: not a listType for label_type
289524 0 : p_label_type = SgLabelSymbol::e_unknown_label_type; // non list case
289525 :
289526 : }
289527 :
289528 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
289529 0 : }
289530 :
289531 :
289532 : /* #line 289533 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289533 :
289534 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
289535 :
289536 : // Generated constructor
289537 11 : SgLabelSymbol::SgLabelSymbol ( SgLabelStatement* declaration )
289538 11 : : SgSymbol()
289539 : {
289540 : #ifdef DEBUG
289541 : // printf ("In SgLabelSymbol::SgLabelSymbol (SgLabelStatement* declaration) sage_class_name() = %s \n",sage_class_name());
289542 : #endif
289543 : #if 0
289544 : // debugging information!
289545 : printf ("In SgLabelSymbol::SgLabelSymbol (SgLabelStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
289546 : #endif
289547 :
289548 11 : p_declaration = declaration;
289549 11 : p_fortran_statement = NULL;
289550 11 : p_fortran_alternate_return_parameter = NULL;
289551 11 : p_numeric_label_value = -1;
289552 11 : p_label_type = SgLabelSymbol::e_unknown_label_type;
289553 :
289554 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
289555 :
289556 : #if 0
289557 : // DQ (7/30/2014): Call a virtual function.
289558 : std::string s = this->class_name();
289559 : #endif
289560 :
289561 : // Test the variant virtual function
289562 : // assert(LABEL_NAME == variant());
289563 11 : assert(LABEL_NAME == this->variant());
289564 11 : ROSE_ASSERT(LABEL_NAME == (int)(this->variantT()));
289565 11 : post_construction_initialization();
289566 :
289567 : // Test the isSgLabelSymbol() function since it has been problematic
289568 11 : assert(isSgLabelSymbol(this) != NULL);
289569 11 : }
289570 :
289571 : // Generated constructor (all data members)
289572 :
289573 : /* #line 289574 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289574 :
289575 :
289576 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
289577 :
289578 :
289579 : // ********************************************************
289580 : // member functions common across all array grammar objects
289581 : // ********************************************************
289582 :
289583 :
289584 :
289585 : /* #line 289586 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289586 :
289587 :
289588 :
289589 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
289590 :
289591 : // ********************************************************
289592 : // member functions specific to each node in the grammar
289593 : // ********************************************************
289594 :
289595 :
289596 : /* #line 289597 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289597 :
289598 : // Start of memberFunctionString
289599 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289600 :
289601 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289602 :
289603 : SgType*
289604 0 : SgDefaultSymbol::get_type () const
289605 : {
289606 0 : ROSE_ASSERT (this != NULL);
289607 :
289608 : #if 0
289609 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289610 : // used to trigger marking transformations for the token-based unparsing.
289611 : printf ("SgDefaultSymbol::get_type = %p = %s \n",this,this->class_name().c_str());
289612 : #endif
289613 :
289614 0 : return p_type;
289615 : }
289616 :
289617 : void
289618 0 : SgDefaultSymbol::set_type ( SgType* type )
289619 : {
289620 0 : ROSE_ASSERT (this != NULL);
289621 :
289622 : #if 0
289623 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289624 : // used to trigger marking transformations for the token-based unparsing.
289625 : printf ("SgDefaultSymbol::set_type = %p = %s \n",this,this->class_name().c_str());
289626 : #endif
289627 :
289628 0 : set_isModified(true);
289629 :
289630 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
289631 : if (p_type != NULL && type != NULL && p_type != type)
289632 : {
289633 : printf ("Warning: type = %p overwriting valid pointer p_type = %p \n",type,p_type);
289634 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
289635 : printf ("Error fails assertion (p_type != NULL && type != NULL && p_type != type) is false\n");
289636 : ROSE_ASSERT(false);
289637 : #endif
289638 : }
289639 : #endif
289640 0 : p_type = type;
289641 0 : }
289642 :
289643 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289644 :
289645 :
289646 : // End of memberFunctionString
289647 : // Start of memberFunctionString
289648 : /* #line 598 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
289649 :
289650 : SgName
289651 0 : SgDefaultSymbol::get_name() const
289652 : {
289653 0 : return "Default_Symbol_Name";
289654 : }
289655 :
289656 : // DQ (2/6/2007): This returns the basis for the SHORT_DEFAULT_GET_NAME
289657 : SgNode*
289658 0 : SgDefaultSymbol::get_symbol_basis() const
289659 : {
289660 0 : return NULL;
289661 : }
289662 :
289663 :
289664 : // End of memberFunctionString
289665 : // Start of memberFunctionString
289666 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
289667 :
289668 : // *** COMMON CODE SECTION BEGINS HERE ***
289669 :
289670 : #if 0
289671 : int
289672 : SgDefaultSymbol::getVariant() const
289673 : {
289674 : // This function is used in ROSE while "variant()" is used in SAGE
289675 : assert(this != NULL);
289676 : return variant();
289677 : }
289678 : #endif
289679 :
289680 : // This function is used in ROSE in treeTraversal code
289681 : // eventually replaces getVariant() and variant()
289682 : // though after variant() has been removed for a while we will
289683 : // want to change the name of variantT() back to variant()
289684 : // (since the "T" was ment to stand for temporary).
289685 : // When this happens the variantT() will be depricated.
289686 : VariantT
289687 0 : SgDefaultSymbol::variantT() const
289688 : {
289689 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
289690 0 : ROSE_ASSERT(this != NULL);
289691 0 : return V_SgDefaultSymbol;
289692 : }
289693 :
289694 : #if 0
289695 : int
289696 : SgDefaultSymbol::variant() const
289697 : {
289698 : // This function is used in SAGE
289699 : ROSE_ASSERT(this != NULL);
289700 : return DEFAULT_NAME;
289701 : }
289702 : #endif
289703 :
289704 : ROSE_DLL_API const char*
289705 0 : SgDefaultSymbol::sage_class_name() const
289706 : {
289707 0 : ROSE_ASSERT(this != NULL);
289708 0 : return "SgDefaultSymbol";
289709 : }
289710 :
289711 : std::string
289712 0 : SgDefaultSymbol::class_name() const
289713 : {
289714 0 : ROSE_ASSERT(this != NULL);
289715 0 : return "SgDefaultSymbol";
289716 : }
289717 :
289718 : // DQ (11/26/2005): Support for visitor pattern mechanims
289719 : // (inferior to ROSE traversal mechanism, experimental).
289720 : void
289721 0 : SgDefaultSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
289722 : {
289723 0 : ROSE_ASSERT(this != NULL);
289724 0 : visitor.visit(this);
289725 0 : }
289726 :
289727 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
289728 0 : void SgDefaultSymbol::accept (ROSE_VisitorPattern & visitor) {
289729 0 : ROSE_ASSERT(this != NULL);
289730 0 : visitor.visit(this);
289731 0 : }
289732 :
289733 : SgDefaultSymbol*
289734 0 : SgDefaultSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
289735 : {
289736 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
289737 : // This function is currently only supported for the AST used the represent Binary executables.
289738 : if (0 /* isSgAsmNode(this) != NULL */)
289739 : {
289740 : // Support for regex specification.
289741 : std::string prefixCode = "REGEX:";
289742 : addNewAttribute(prefixCode + s,a);
289743 : }
289744 : #endif
289745 :
289746 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
289747 0 : return this;
289748 : }
289749 :
289750 : // *** COMMON CODE SECTION ENDS HERE ***
289751 :
289752 :
289753 : // End of memberFunctionString
289754 : // Start of memberFunctionString
289755 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
289756 :
289757 :
289758 : #if 0
289759 : //! Error checking support
289760 : /*! Verifies the following:
289761 : - working getVariant() member function
289762 : - calls base class's error() member function
289763 : Every class has one of these functions.
289764 : */
289765 : bool
289766 : SgDefaultSymbol::error()
289767 : {
289768 : // Put error checking here
289769 :
289770 : ROSE_ASSERT (this != NULL);
289771 : if (getVariant() != DEFAULT_NAME)
289772 : {
289773 : printf ("Error in SgDefaultSymbol::error(): SgDefaultSymbol object has a %s variant \n",
289774 : Cxx_GrammarTerminalNames[getVariant()].name);
289775 : // printf ("Error in SgDefaultSymbol::error() \n");
289776 : ROSE_ABORT();
289777 : }
289778 :
289779 : ROSE_ASSERT (getVariant() == DEFAULT_NAME);
289780 : return SgSymbol::error();
289781 : }
289782 : #endif
289783 :
289784 :
289785 :
289786 : // End of memberFunctionString
289787 :
289788 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
289789 :
289790 0 : SgDefaultSymbol* isSgDefaultSymbol ( SgNode* inputDerivedClassPointer )
289791 : {
289792 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
289793 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
289794 : // So to fix this we return NULL directly when the input is NULL and avoid the
289795 : // dynamic_cast in this case. This is likely a performance improvement as well.
289796 : // return dynamic_cast<SgDefaultSymbol*>(inputDerivedClassPointer);
289797 : // Milind Chabbi (8/28/2013): isSgDefaultSymbol uses table-driven castability instead of c++ default dynamic_cast
289798 : // this improves the running time performance by 10-20%.
289799 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgDefaultSymbol*>(inputDerivedClassPointer);
289800 0 : return IS_SgDefaultSymbol_FAST_MACRO(inputDerivedClassPointer);
289801 : }
289802 :
289803 : // DQ (11/8/2003): Added version of functions taking const pointer
289804 0 : const SgDefaultSymbol* isSgDefaultSymbol ( const SgNode* inputDerivedClassPointer )
289805 : {
289806 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
289807 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
289808 : // So to fix this we return NULL directly when the input is NULL and avoid the
289809 : // dynamic_cast in this case. This is likely a performance improvement as well.
289810 : // return dynamic_cast<const SgDefaultSymbol*>(inputDerivedClassPointer);
289811 : // Milind Chabbi (8/28/2013): isSgDefaultSymbol uses table-driven castability instead of c++ default dynamic_cast
289812 : // this improves the running time performance by 10-20%.
289813 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgDefaultSymbol*>(inputDerivedClassPointer);
289814 0 : return IS_SgDefaultSymbol_FAST_MACRO(inputDerivedClassPointer);
289815 : }
289816 :
289817 :
289818 :
289819 : /* #line 289820 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289820 :
289821 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
289822 :
289823 : /**
289824 : \brief Generated destructor
289825 :
289826 : This destructor is automatically generated (by ROSETTA). This destructor
289827 : only frees memory of data members associated with the parts of the current IR node which
289828 : are NOT traversed. Those data members that are part of a traversal can be freed using
289829 : a traversal (calling this destructor on all children in a post-order traversal). Such
289830 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
289831 :
289832 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
289833 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
289834 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
289835 :
289836 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
289837 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
289838 : pointers are not yet implemented to call delete on eash pointer in the container.
289839 : (This could be done by derivation from the STL containers to define containers that
289840 : automatically deleted their members.)
289841 :
289842 : */
289843 0 : SgDefaultSymbol::~SgDefaultSymbol () {
289844 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
289845 :
289846 :
289847 : // case: not a listType for type
289848 0 : p_type = NULL; // non list case
289849 :
289850 : }
289851 :
289852 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
289853 0 : }
289854 :
289855 :
289856 : /* #line 289857 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289857 :
289858 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
289859 :
289860 : // Generated constructor
289861 0 : SgDefaultSymbol::SgDefaultSymbol ( SgType* type )
289862 0 : : SgSymbol()
289863 : {
289864 : #ifdef DEBUG
289865 : // printf ("In SgDefaultSymbol::SgDefaultSymbol (SgType* type) sage_class_name() = %s \n",sage_class_name());
289866 : #endif
289867 : #if 0
289868 : // debugging information!
289869 : printf ("In SgDefaultSymbol::SgDefaultSymbol (SgType* type): this = %p = %s \n",this,this->class_name().c_str());
289870 : #endif
289871 :
289872 0 : p_type = type;
289873 :
289874 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
289875 :
289876 : #if 0
289877 : // DQ (7/30/2014): Call a virtual function.
289878 : std::string s = this->class_name();
289879 : #endif
289880 :
289881 : // Test the variant virtual function
289882 : // assert(DEFAULT_NAME == variant());
289883 0 : assert(DEFAULT_NAME == this->variant());
289884 0 : ROSE_ASSERT(DEFAULT_NAME == (int)(this->variantT()));
289885 0 : post_construction_initialization();
289886 :
289887 : // Test the isSgDefaultSymbol() function since it has been problematic
289888 0 : assert(isSgDefaultSymbol(this) != NULL);
289889 0 : }
289890 :
289891 : // Generated constructor (all data members)
289892 :
289893 : /* #line 289894 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289894 :
289895 :
289896 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
289897 :
289898 :
289899 : // ********************************************************
289900 : // member functions common across all array grammar objects
289901 : // ********************************************************
289902 :
289903 :
289904 :
289905 : /* #line 289906 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289906 :
289907 :
289908 :
289909 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
289910 :
289911 : // ********************************************************
289912 : // member functions specific to each node in the grammar
289913 : // ********************************************************
289914 :
289915 :
289916 : /* #line 289917 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
289917 :
289918 : // Start of memberFunctionString
289919 :
289920 :
289921 : // End of memberFunctionString
289922 : // Start of memberFunctionString
289923 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289924 :
289925 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289926 :
289927 : SgNamespaceDeclarationStatement*
289928 73400 : SgNamespaceSymbol::get_declaration () const
289929 : {
289930 73400 : ROSE_ASSERT (this != NULL);
289931 :
289932 : #if 0
289933 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289934 : // used to trigger marking transformations for the token-based unparsing.
289935 : printf ("SgNamespaceSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
289936 : #endif
289937 :
289938 73400 : return p_declaration;
289939 : }
289940 :
289941 : void
289942 0 : SgNamespaceSymbol::set_declaration ( SgNamespaceDeclarationStatement* declaration )
289943 : {
289944 0 : ROSE_ASSERT (this != NULL);
289945 :
289946 : #if 0
289947 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289948 : // used to trigger marking transformations for the token-based unparsing.
289949 : printf ("SgNamespaceSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
289950 : #endif
289951 :
289952 0 : set_isModified(true);
289953 :
289954 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
289955 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
289956 : {
289957 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
289958 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
289959 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
289960 : ROSE_ASSERT(false);
289961 : #endif
289962 : }
289963 : #endif
289964 0 : p_declaration = declaration;
289965 0 : }
289966 :
289967 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
289968 :
289969 :
289970 : // End of memberFunctionString
289971 : // Start of memberFunctionString
289972 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
289973 :
289974 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
289975 :
289976 : SgNamespaceAliasDeclarationStatement*
289977 52570 : SgNamespaceSymbol::get_aliasDeclaration () const
289978 : {
289979 52570 : ROSE_ASSERT (this != NULL);
289980 :
289981 : #if 0
289982 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289983 : // used to trigger marking transformations for the token-based unparsing.
289984 : printf ("SgNamespaceSymbol::get_aliasDeclaration = %p = %s \n",this,this->class_name().c_str());
289985 : #endif
289986 :
289987 52570 : return p_aliasDeclaration;
289988 : }
289989 :
289990 : void
289991 0 : SgNamespaceSymbol::set_aliasDeclaration ( SgNamespaceAliasDeclarationStatement* aliasDeclaration )
289992 : {
289993 0 : ROSE_ASSERT (this != NULL);
289994 :
289995 : #if 0
289996 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
289997 : // used to trigger marking transformations for the token-based unparsing.
289998 : printf ("SgNamespaceSymbol::set_aliasDeclaration = %p = %s \n",this,this->class_name().c_str());
289999 : #endif
290000 :
290001 0 : set_isModified(true);
290002 :
290003 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
290004 : if (p_aliasDeclaration != NULL && aliasDeclaration != NULL && p_aliasDeclaration != aliasDeclaration)
290005 : {
290006 : printf ("Warning: aliasDeclaration = %p overwriting valid pointer p_aliasDeclaration = %p \n",aliasDeclaration,p_aliasDeclaration);
290007 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
290008 : printf ("Error fails assertion (p_aliasDeclaration != NULL && aliasDeclaration != NULL && p_aliasDeclaration != aliasDeclaration) is false\n");
290009 : ROSE_ASSERT(false);
290010 : #endif
290011 : }
290012 : #endif
290013 0 : p_aliasDeclaration = aliasDeclaration;
290014 0 : }
290015 :
290016 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
290017 :
290018 :
290019 : // End of memberFunctionString
290020 : // Start of memberFunctionString
290021 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
290022 :
290023 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
290024 :
290025 : bool
290026 214 : SgNamespaceSymbol::get_isAlias () const
290027 : {
290028 214 : ROSE_ASSERT (this != NULL);
290029 :
290030 : #if 0
290031 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
290032 : // used to trigger marking transformations for the token-based unparsing.
290033 : printf ("SgNamespaceSymbol::get_isAlias = %p = %s \n",this,this->class_name().c_str());
290034 : #endif
290035 :
290036 214 : return p_isAlias;
290037 : }
290038 :
290039 : void
290040 0 : SgNamespaceSymbol::set_isAlias ( bool isAlias )
290041 : {
290042 0 : ROSE_ASSERT (this != NULL);
290043 :
290044 : #if 0
290045 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
290046 : // used to trigger marking transformations for the token-based unparsing.
290047 : printf ("SgNamespaceSymbol::set_isAlias = %p = %s \n",this,this->class_name().c_str());
290048 : #endif
290049 :
290050 0 : set_isModified(true);
290051 :
290052 0 : p_isAlias = isAlias;
290053 0 : }
290054 :
290055 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
290056 :
290057 :
290058 : // End of memberFunctionString
290059 : // Start of memberFunctionString
290060 : /* #line 1273 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
290061 :
290062 :
290063 : SgName
290064 1 : SgNamespaceSymbol::get_name() const
290065 : {
290066 : // DQ (8/30/2009): Added support for SgNamespaceAliasDeclarationStatement
290067 1 : SgName n;
290068 1 : if (p_isAlias == true)
290069 : {
290070 0 : n = (get_aliasDeclaration() != NULL) ? get_aliasDeclaration()->get_name() : SgName("undefined");
290071 : }
290072 : else
290073 : {
290074 1 : n = (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
290075 : }
290076 :
290077 : // return (get_declaration() != NULL) ? get_declaration()->get_name() : SgName("undefined");
290078 1 : return n;
290079 : }
290080 :
290081 : // DQ (2/6/2007): This returns the basis for the SHORT_GET_NAME
290082 : SgNode*
290083 19595 : SgNamespaceSymbol::get_symbol_basis() const
290084 : {
290085 : // DQ (8/30/2009): Added support for SgNamespaceAliasDeclarationStatement
290086 19595 : SgNode* declaration = NULL;
290087 19595 : if (p_isAlias == true)
290088 : {
290089 0 : declaration = get_aliasDeclaration();
290090 : }
290091 : else
290092 : {
290093 19595 : declaration = get_declaration();
290094 : }
290095 :
290096 : // return get_declaration();
290097 19595 : return declaration;
290098 : }
290099 :
290100 : void
290101 149 : SgNamespaceSymbol::post_construction_initialization()
290102 : {
290103 : // DQ (8/30/2009): Added support for namespace alias in the SgNamespaceSymbol
290104 :
290105 149 : ROSE_ASSERT(p_declaration != NULL || p_aliasDeclaration != NULL);
290106 149 : ROSE_ASSERT(p_declaration == NULL || p_aliasDeclaration == NULL);
290107 :
290108 : // Mark this symbol as representing a namespace alias
290109 149 : if (p_aliasDeclaration != NULL)
290110 0 : set_isAlias(true);
290111 149 : }
290112 :
290113 :
290114 :
290115 : // End of memberFunctionString
290116 : // Start of memberFunctionString
290117 : /* #line 547 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
290118 :
290119 : SgType*
290120 0 : SgNamespaceSymbol::get_type() const
290121 : {
290122 0 : return NULL;
290123 : }
290124 :
290125 : #if 0
290126 : // DQ (2/6/2007): This returns the basis for the EMPTY_GET_TYPE
290127 : SgNode*
290128 : SgNamespaceSymbol::get_symbol_basis() const
290129 : {
290130 : return NULL;
290131 : }
290132 : #endif
290133 :
290134 :
290135 : // End of memberFunctionString
290136 : // Start of memberFunctionString
290137 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
290138 :
290139 : // *** COMMON CODE SECTION BEGINS HERE ***
290140 :
290141 : #if 0
290142 : int
290143 : SgNamespaceSymbol::getVariant() const
290144 : {
290145 : // This function is used in ROSE while "variant()" is used in SAGE
290146 : assert(this != NULL);
290147 : return variant();
290148 : }
290149 : #endif
290150 :
290151 : // This function is used in ROSE in treeTraversal code
290152 : // eventually replaces getVariant() and variant()
290153 : // though after variant() has been removed for a while we will
290154 : // want to change the name of variantT() back to variant()
290155 : // (since the "T" was ment to stand for temporary).
290156 : // When this happens the variantT() will be depricated.
290157 : VariantT
290158 425098 : SgNamespaceSymbol::variantT() const
290159 : {
290160 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
290161 425098 : ROSE_ASSERT(this != NULL);
290162 425098 : return V_SgNamespaceSymbol;
290163 : }
290164 :
290165 : #if 0
290166 : int
290167 : SgNamespaceSymbol::variant() const
290168 : {
290169 : // This function is used in SAGE
290170 : ROSE_ASSERT(this != NULL);
290171 : return NAMESPACE_NAME;
290172 : }
290173 : #endif
290174 :
290175 : ROSE_DLL_API const char*
290176 0 : SgNamespaceSymbol::sage_class_name() const
290177 : {
290178 0 : ROSE_ASSERT(this != NULL);
290179 0 : return "SgNamespaceSymbol";
290180 : }
290181 :
290182 : std::string
290183 108 : SgNamespaceSymbol::class_name() const
290184 : {
290185 108 : ROSE_ASSERT(this != NULL);
290186 108 : return "SgNamespaceSymbol";
290187 : }
290188 :
290189 : // DQ (11/26/2005): Support for visitor pattern mechanims
290190 : // (inferior to ROSE traversal mechanism, experimental).
290191 : void
290192 1918 : SgNamespaceSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
290193 : {
290194 1918 : ROSE_ASSERT(this != NULL);
290195 1918 : visitor.visit(this);
290196 1918 : }
290197 :
290198 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
290199 0 : void SgNamespaceSymbol::accept (ROSE_VisitorPattern & visitor) {
290200 0 : ROSE_ASSERT(this != NULL);
290201 0 : visitor.visit(this);
290202 0 : }
290203 :
290204 : SgNamespaceSymbol*
290205 0 : SgNamespaceSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
290206 : {
290207 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
290208 : // This function is currently only supported for the AST used the represent Binary executables.
290209 : if (0 /* isSgAsmNode(this) != NULL */)
290210 : {
290211 : // Support for regex specification.
290212 : std::string prefixCode = "REGEX:";
290213 : addNewAttribute(prefixCode + s,a);
290214 : }
290215 : #endif
290216 :
290217 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
290218 0 : return this;
290219 : }
290220 :
290221 : // *** COMMON CODE SECTION ENDS HERE ***
290222 :
290223 :
290224 : // End of memberFunctionString
290225 : // Start of memberFunctionString
290226 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
290227 :
290228 :
290229 : #if 0
290230 : //! Error checking support
290231 : /*! Verifies the following:
290232 : - working getVariant() member function
290233 : - calls base class's error() member function
290234 : Every class has one of these functions.
290235 : */
290236 : bool
290237 : SgNamespaceSymbol::error()
290238 : {
290239 : // Put error checking here
290240 :
290241 : ROSE_ASSERT (this != NULL);
290242 : if (getVariant() != NAMESPACE_NAME)
290243 : {
290244 : printf ("Error in SgNamespaceSymbol::error(): SgNamespaceSymbol object has a %s variant \n",
290245 : Cxx_GrammarTerminalNames[getVariant()].name);
290246 : // printf ("Error in SgNamespaceSymbol::error() \n");
290247 : ROSE_ABORT();
290248 : }
290249 :
290250 : ROSE_ASSERT (getVariant() == NAMESPACE_NAME);
290251 : return SgSymbol::error();
290252 : }
290253 : #endif
290254 :
290255 :
290256 :
290257 : // End of memberFunctionString
290258 :
290259 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
290260 :
290261 117731 : SgNamespaceSymbol* isSgNamespaceSymbol ( SgNode* inputDerivedClassPointer )
290262 : {
290263 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
290264 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
290265 : // So to fix this we return NULL directly when the input is NULL and avoid the
290266 : // dynamic_cast in this case. This is likely a performance improvement as well.
290267 : // return dynamic_cast<SgNamespaceSymbol*>(inputDerivedClassPointer);
290268 : // Milind Chabbi (8/28/2013): isSgNamespaceSymbol uses table-driven castability instead of c++ default dynamic_cast
290269 : // this improves the running time performance by 10-20%.
290270 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgNamespaceSymbol*>(inputDerivedClassPointer);
290271 117731 : return IS_SgNamespaceSymbol_FAST_MACRO(inputDerivedClassPointer);
290272 : }
290273 :
290274 : // DQ (11/8/2003): Added version of functions taking const pointer
290275 1 : const SgNamespaceSymbol* isSgNamespaceSymbol ( const SgNode* inputDerivedClassPointer )
290276 : {
290277 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
290278 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
290279 : // So to fix this we return NULL directly when the input is NULL and avoid the
290280 : // dynamic_cast in this case. This is likely a performance improvement as well.
290281 : // return dynamic_cast<const SgNamespaceSymbol*>(inputDerivedClassPointer);
290282 : // Milind Chabbi (8/28/2013): isSgNamespaceSymbol uses table-driven castability instead of c++ default dynamic_cast
290283 : // this improves the running time performance by 10-20%.
290284 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgNamespaceSymbol*>(inputDerivedClassPointer);
290285 1 : return IS_SgNamespaceSymbol_FAST_MACRO(inputDerivedClassPointer);
290286 : }
290287 :
290288 :
290289 :
290290 : /* #line 290291 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290291 :
290292 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
290293 :
290294 : /**
290295 : \brief Generated destructor
290296 :
290297 : This destructor is automatically generated (by ROSETTA). This destructor
290298 : only frees memory of data members associated with the parts of the current IR node which
290299 : are NOT traversed. Those data members that are part of a traversal can be freed using
290300 : a traversal (calling this destructor on all children in a post-order traversal). Such
290301 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
290302 :
290303 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
290304 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
290305 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
290306 :
290307 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
290308 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
290309 : pointers are not yet implemented to call delete on eash pointer in the container.
290310 : (This could be done by derivation from the STL containers to define containers that
290311 : automatically deleted their members.)
290312 :
290313 : */
290314 56 : SgNamespaceSymbol::~SgNamespaceSymbol () {
290315 28 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
290316 :
290317 :
290318 : // case: not a listType for name
290319 28 : p_name = ""; // non list case
290320 : // case: not a listType for declaration
290321 28 : p_declaration = NULL; // non list case
290322 : // case: not a listType for aliasDeclaration
290323 28 : p_aliasDeclaration = NULL; // non list case
290324 : // case: not a listType for isAlias
290325 28 : p_isAlias = false; // non list case
290326 :
290327 : }
290328 :
290329 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
290330 56 : }
290331 :
290332 :
290333 : /* #line 290334 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290334 :
290335 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
290336 :
290337 : // Generated constructor
290338 149 : SgNamespaceSymbol::SgNamespaceSymbol ( SgName name, SgNamespaceDeclarationStatement* declaration, SgNamespaceAliasDeclarationStatement* aliasDeclaration, bool isAlias )
290339 149 : : SgSymbol()
290340 : {
290341 : #ifdef DEBUG
290342 : // printf ("In SgNamespaceSymbol::SgNamespaceSymbol (SgName name, SgNamespaceDeclarationStatement* declaration, SgNamespaceAliasDeclarationStatement* aliasDeclaration, bool isAlias) sage_class_name() = %s \n",sage_class_name());
290343 : #endif
290344 : #if 0
290345 : // debugging information!
290346 : printf ("In SgNamespaceSymbol::SgNamespaceSymbol (SgName name, SgNamespaceDeclarationStatement* declaration, SgNamespaceAliasDeclarationStatement* aliasDeclaration, bool isAlias): this = %p = %s \n",this,this->class_name().c_str());
290347 : #endif
290348 :
290349 149 : p_name = name;
290350 149 : p_declaration = declaration;
290351 149 : p_aliasDeclaration = aliasDeclaration;
290352 149 : p_isAlias = isAlias;
290353 :
290354 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
290355 :
290356 : #if 0
290357 : // DQ (7/30/2014): Call a virtual function.
290358 : std::string s = this->class_name();
290359 : #endif
290360 :
290361 : // Test the variant virtual function
290362 : // assert(NAMESPACE_NAME == variant());
290363 149 : assert(NAMESPACE_NAME == this->variant());
290364 149 : ROSE_ASSERT(NAMESPACE_NAME == (int)(this->variantT()));
290365 149 : post_construction_initialization();
290366 :
290367 : // Test the isSgNamespaceSymbol() function since it has been problematic
290368 149 : assert(isSgNamespaceSymbol(this) != NULL);
290369 149 : }
290370 :
290371 : // Generated constructor (all data members)
290372 :
290373 : /* #line 290374 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290374 :
290375 :
290376 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
290377 :
290378 :
290379 : // ********************************************************
290380 : // member functions common across all array grammar objects
290381 : // ********************************************************
290382 :
290383 :
290384 :
290385 : /* #line 290386 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290386 :
290387 :
290388 :
290389 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
290390 :
290391 : // ********************************************************
290392 : // member functions specific to each node in the grammar
290393 : // ********************************************************
290394 :
290395 :
290396 : /* #line 290397 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290397 :
290398 : // Start of memberFunctionString
290399 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
290400 :
290401 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
290402 :
290403 : SgInitializedName*
290404 0 : SgIntrinsicSymbol::get_declaration () const
290405 : {
290406 0 : ROSE_ASSERT (this != NULL);
290407 :
290408 : #if 0
290409 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
290410 : // used to trigger marking transformations for the token-based unparsing.
290411 : printf ("SgIntrinsicSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
290412 : #endif
290413 :
290414 0 : return p_declaration;
290415 : }
290416 :
290417 : void
290418 0 : SgIntrinsicSymbol::set_declaration ( SgInitializedName* declaration )
290419 : {
290420 0 : ROSE_ASSERT (this != NULL);
290421 :
290422 : #if 0
290423 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
290424 : // used to trigger marking transformations for the token-based unparsing.
290425 : printf ("SgIntrinsicSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
290426 : #endif
290427 :
290428 0 : set_isModified(true);
290429 :
290430 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
290431 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
290432 : {
290433 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
290434 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
290435 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
290436 : ROSE_ASSERT(false);
290437 : #endif
290438 : }
290439 : #endif
290440 0 : p_declaration = declaration;
290441 0 : }
290442 :
290443 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
290444 :
290445 :
290446 : // End of memberFunctionString
290447 : // Start of memberFunctionString
290448 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
290449 :
290450 : SgType*
290451 0 : SgIntrinsicSymbol::get_type() const
290452 : {
290453 0 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
290454 : }
290455 :
290456 : #if 0
290457 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
290458 : SgNode*
290459 : SgIntrinsicSymbol::get_symbol_basis() const
290460 : {
290461 : return get_type();
290462 : }
290463 : #endif
290464 :
290465 :
290466 : // End of memberFunctionString
290467 : // Start of memberFunctionString
290468 : /* #line 879 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
290469 :
290470 : SgName
290471 0 : SgIntrinsicSymbol::get_name() const
290472 : {
290473 : #if 1
290474 : // (original note from Sage II) this is less efficient but it does avoid a bug in Sun C++
290475 0 : SgName theName;
290476 :
290477 0 : if (get_declaration())
290478 : {
290479 0 : theName = get_declaration()->get_name();
290480 : }
290481 : else
290482 : {
290483 0 : theName = SgName("undefined");
290484 : }
290485 :
290486 0 : return theName;
290487 : #else
290488 : return (get_declaration) ? get_declaration()->get_name() : SgName("undefined");
290489 : #endif
290490 : }
290491 :
290492 : SgNode*
290493 0 : SgIntrinsicSymbol::get_symbol_basis() const
290494 : {
290495 0 : return get_declaration();
290496 : }
290497 :
290498 :
290499 :
290500 : // End of memberFunctionString
290501 : // Start of memberFunctionString
290502 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
290503 :
290504 : // *** COMMON CODE SECTION BEGINS HERE ***
290505 :
290506 : #if 0
290507 : int
290508 : SgIntrinsicSymbol::getVariant() const
290509 : {
290510 : // This function is used in ROSE while "variant()" is used in SAGE
290511 : assert(this != NULL);
290512 : return variant();
290513 : }
290514 : #endif
290515 :
290516 : // This function is used in ROSE in treeTraversal code
290517 : // eventually replaces getVariant() and variant()
290518 : // though after variant() has been removed for a while we will
290519 : // want to change the name of variantT() back to variant()
290520 : // (since the "T" was ment to stand for temporary).
290521 : // When this happens the variantT() will be depricated.
290522 : VariantT
290523 0 : SgIntrinsicSymbol::variantT() const
290524 : {
290525 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
290526 0 : ROSE_ASSERT(this != NULL);
290527 0 : return V_SgIntrinsicSymbol;
290528 : }
290529 :
290530 : #if 0
290531 : int
290532 : SgIntrinsicSymbol::variant() const
290533 : {
290534 : // This function is used in SAGE
290535 : ROSE_ASSERT(this != NULL);
290536 : return INTRINSIC_SYMBOL;
290537 : }
290538 : #endif
290539 :
290540 : ROSE_DLL_API const char*
290541 0 : SgIntrinsicSymbol::sage_class_name() const
290542 : {
290543 0 : ROSE_ASSERT(this != NULL);
290544 0 : return "SgIntrinsicSymbol";
290545 : }
290546 :
290547 : std::string
290548 0 : SgIntrinsicSymbol::class_name() const
290549 : {
290550 0 : ROSE_ASSERT(this != NULL);
290551 0 : return "SgIntrinsicSymbol";
290552 : }
290553 :
290554 : // DQ (11/26/2005): Support for visitor pattern mechanims
290555 : // (inferior to ROSE traversal mechanism, experimental).
290556 : void
290557 0 : SgIntrinsicSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
290558 : {
290559 0 : ROSE_ASSERT(this != NULL);
290560 0 : visitor.visit(this);
290561 0 : }
290562 :
290563 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
290564 0 : void SgIntrinsicSymbol::accept (ROSE_VisitorPattern & visitor) {
290565 0 : ROSE_ASSERT(this != NULL);
290566 0 : visitor.visit(this);
290567 0 : }
290568 :
290569 : SgIntrinsicSymbol*
290570 0 : SgIntrinsicSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
290571 : {
290572 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
290573 : // This function is currently only supported for the AST used the represent Binary executables.
290574 : if (0 /* isSgAsmNode(this) != NULL */)
290575 : {
290576 : // Support for regex specification.
290577 : std::string prefixCode = "REGEX:";
290578 : addNewAttribute(prefixCode + s,a);
290579 : }
290580 : #endif
290581 :
290582 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
290583 0 : return this;
290584 : }
290585 :
290586 : // *** COMMON CODE SECTION ENDS HERE ***
290587 :
290588 :
290589 : // End of memberFunctionString
290590 : // Start of memberFunctionString
290591 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
290592 :
290593 :
290594 : #if 0
290595 : //! Error checking support
290596 : /*! Verifies the following:
290597 : - working getVariant() member function
290598 : - calls base class's error() member function
290599 : Every class has one of these functions.
290600 : */
290601 : bool
290602 : SgIntrinsicSymbol::error()
290603 : {
290604 : // Put error checking here
290605 :
290606 : ROSE_ASSERT (this != NULL);
290607 : if (getVariant() != INTRINSIC_SYMBOL)
290608 : {
290609 : printf ("Error in SgIntrinsicSymbol::error(): SgIntrinsicSymbol object has a %s variant \n",
290610 : Cxx_GrammarTerminalNames[getVariant()].name);
290611 : // printf ("Error in SgIntrinsicSymbol::error() \n");
290612 : ROSE_ABORT();
290613 : }
290614 :
290615 : ROSE_ASSERT (getVariant() == INTRINSIC_SYMBOL);
290616 : return SgSymbol::error();
290617 : }
290618 : #endif
290619 :
290620 :
290621 :
290622 : // End of memberFunctionString
290623 :
290624 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
290625 :
290626 0 : SgIntrinsicSymbol* isSgIntrinsicSymbol ( SgNode* inputDerivedClassPointer )
290627 : {
290628 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
290629 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
290630 : // So to fix this we return NULL directly when the input is NULL and avoid the
290631 : // dynamic_cast in this case. This is likely a performance improvement as well.
290632 : // return dynamic_cast<SgIntrinsicSymbol*>(inputDerivedClassPointer);
290633 : // Milind Chabbi (8/28/2013): isSgIntrinsicSymbol uses table-driven castability instead of c++ default dynamic_cast
290634 : // this improves the running time performance by 10-20%.
290635 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgIntrinsicSymbol*>(inputDerivedClassPointer);
290636 0 : return IS_SgIntrinsicSymbol_FAST_MACRO(inputDerivedClassPointer);
290637 : }
290638 :
290639 : // DQ (11/8/2003): Added version of functions taking const pointer
290640 0 : const SgIntrinsicSymbol* isSgIntrinsicSymbol ( const SgNode* inputDerivedClassPointer )
290641 : {
290642 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
290643 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
290644 : // So to fix this we return NULL directly when the input is NULL and avoid the
290645 : // dynamic_cast in this case. This is likely a performance improvement as well.
290646 : // return dynamic_cast<const SgIntrinsicSymbol*>(inputDerivedClassPointer);
290647 : // Milind Chabbi (8/28/2013): isSgIntrinsicSymbol uses table-driven castability instead of c++ default dynamic_cast
290648 : // this improves the running time performance by 10-20%.
290649 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgIntrinsicSymbol*>(inputDerivedClassPointer);
290650 0 : return IS_SgIntrinsicSymbol_FAST_MACRO(inputDerivedClassPointer);
290651 : }
290652 :
290653 :
290654 :
290655 : /* #line 290656 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290656 :
290657 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
290658 :
290659 : /**
290660 : \brief Generated destructor
290661 :
290662 : This destructor is automatically generated (by ROSETTA). This destructor
290663 : only frees memory of data members associated with the parts of the current IR node which
290664 : are NOT traversed. Those data members that are part of a traversal can be freed using
290665 : a traversal (calling this destructor on all children in a post-order traversal). Such
290666 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
290667 :
290668 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
290669 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
290670 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
290671 :
290672 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
290673 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
290674 : pointers are not yet implemented to call delete on eash pointer in the container.
290675 : (This could be done by derivation from the STL containers to define containers that
290676 : automatically deleted their members.)
290677 :
290678 : */
290679 0 : SgIntrinsicSymbol::~SgIntrinsicSymbol () {
290680 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
290681 :
290682 :
290683 : // case: not a listType for declaration
290684 0 : p_declaration = NULL; // non list case
290685 :
290686 : }
290687 :
290688 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
290689 0 : }
290690 :
290691 :
290692 : /* #line 290693 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290693 :
290694 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
290695 :
290696 : // Generated constructor
290697 0 : SgIntrinsicSymbol::SgIntrinsicSymbol ( SgInitializedName* declaration )
290698 0 : : SgSymbol()
290699 : {
290700 : #ifdef DEBUG
290701 : // printf ("In SgIntrinsicSymbol::SgIntrinsicSymbol (SgInitializedName* declaration) sage_class_name() = %s \n",sage_class_name());
290702 : #endif
290703 : #if 0
290704 : // debugging information!
290705 : printf ("In SgIntrinsicSymbol::SgIntrinsicSymbol (SgInitializedName* declaration): this = %p = %s \n",this,this->class_name().c_str());
290706 : #endif
290707 :
290708 0 : p_declaration = declaration;
290709 :
290710 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
290711 :
290712 : #if 0
290713 : // DQ (7/30/2014): Call a virtual function.
290714 : std::string s = this->class_name();
290715 : #endif
290716 :
290717 : // Test the variant virtual function
290718 : // assert(INTRINSIC_SYMBOL == variant());
290719 0 : assert(INTRINSIC_SYMBOL == this->variant());
290720 0 : ROSE_ASSERT(INTRINSIC_SYMBOL == (int)(this->variantT()));
290721 0 : post_construction_initialization();
290722 :
290723 : // Test the isSgIntrinsicSymbol() function since it has been problematic
290724 0 : assert(isSgIntrinsicSymbol(this) != NULL);
290725 0 : }
290726 :
290727 : // Generated constructor (all data members)
290728 :
290729 : /* #line 290730 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290730 :
290731 :
290732 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
290733 :
290734 :
290735 : // ********************************************************
290736 : // member functions common across all array grammar objects
290737 : // ********************************************************
290738 :
290739 :
290740 :
290741 : /* #line 290742 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290742 :
290743 :
290744 :
290745 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
290746 :
290747 : // ********************************************************
290748 : // member functions specific to each node in the grammar
290749 : // ********************************************************
290750 :
290751 :
290752 : /* #line 290753 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
290753 :
290754 : // Start of memberFunctionString
290755 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
290756 :
290757 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
290758 :
290759 : SgModuleStatement*
290760 0 : SgModuleSymbol::get_declaration () const
290761 : {
290762 0 : ROSE_ASSERT (this != NULL);
290763 :
290764 : #if 0
290765 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
290766 : // used to trigger marking transformations for the token-based unparsing.
290767 : printf ("SgModuleSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
290768 : #endif
290769 :
290770 0 : return p_declaration;
290771 : }
290772 :
290773 : void
290774 0 : SgModuleSymbol::set_declaration ( SgModuleStatement* declaration )
290775 : {
290776 0 : ROSE_ASSERT (this != NULL);
290777 :
290778 : #if 0
290779 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
290780 : // used to trigger marking transformations for the token-based unparsing.
290781 : printf ("SgModuleSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
290782 : #endif
290783 :
290784 0 : set_isModified(true);
290785 :
290786 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
290787 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
290788 : {
290789 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
290790 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
290791 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
290792 : ROSE_ASSERT(false);
290793 : #endif
290794 : }
290795 : #endif
290796 0 : p_declaration = declaration;
290797 0 : }
290798 :
290799 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
290800 :
290801 :
290802 : // End of memberFunctionString
290803 : // Start of memberFunctionString
290804 : /* #line 547 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
290805 :
290806 : SgType*
290807 0 : SgModuleSymbol::get_type() const
290808 : {
290809 0 : return NULL;
290810 : }
290811 :
290812 : #if 0
290813 : // DQ (2/6/2007): This returns the basis for the EMPTY_GET_TYPE
290814 : SgNode*
290815 : SgModuleSymbol::get_symbol_basis() const
290816 : {
290817 : return NULL;
290818 : }
290819 : #endif
290820 :
290821 :
290822 : // End of memberFunctionString
290823 : // Start of memberFunctionString
290824 : /* #line 816 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
290825 :
290826 : SgName
290827 0 : SgModuleSymbol::get_name() const
290828 : {
290829 : #if 1
290830 : // (original note from Sage II) this is less efficient but it does avoid a bug in Sun C++
290831 0 : SgName theName;
290832 :
290833 0 : if (get_declaration())
290834 : {
290835 0 : theName = get_declaration()->get_name();
290836 : }
290837 : else
290838 : {
290839 0 : theName = SgName("undefined");
290840 : }
290841 :
290842 0 : return theName;
290843 : #else
290844 : return (get_declaration) ? get_declaration()->get_name() : SgName("undefined");
290845 : #endif
290846 : }
290847 :
290848 : // DQ (2/6/2007): This returns the basis for the SgModuleSymbol
290849 : SgNode*
290850 0 : SgModuleSymbol::get_symbol_basis() const
290851 : {
290852 0 : return get_declaration();
290853 : }
290854 :
290855 :
290856 :
290857 : // End of memberFunctionString
290858 : // Start of memberFunctionString
290859 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
290860 :
290861 : // *** COMMON CODE SECTION BEGINS HERE ***
290862 :
290863 : #if 0
290864 : int
290865 : SgModuleSymbol::getVariant() const
290866 : {
290867 : // This function is used in ROSE while "variant()" is used in SAGE
290868 : assert(this != NULL);
290869 : return variant();
290870 : }
290871 : #endif
290872 :
290873 : // This function is used in ROSE in treeTraversal code
290874 : // eventually replaces getVariant() and variant()
290875 : // though after variant() has been removed for a while we will
290876 : // want to change the name of variantT() back to variant()
290877 : // (since the "T" was ment to stand for temporary).
290878 : // When this happens the variantT() will be depricated.
290879 : VariantT
290880 0 : SgModuleSymbol::variantT() const
290881 : {
290882 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
290883 0 : ROSE_ASSERT(this != NULL);
290884 0 : return V_SgModuleSymbol;
290885 : }
290886 :
290887 : #if 0
290888 : int
290889 : SgModuleSymbol::variant() const
290890 : {
290891 : // This function is used in SAGE
290892 : ROSE_ASSERT(this != NULL);
290893 : return MODULE_SYMBOL;
290894 : }
290895 : #endif
290896 :
290897 : ROSE_DLL_API const char*
290898 0 : SgModuleSymbol::sage_class_name() const
290899 : {
290900 0 : ROSE_ASSERT(this != NULL);
290901 0 : return "SgModuleSymbol";
290902 : }
290903 :
290904 : std::string
290905 0 : SgModuleSymbol::class_name() const
290906 : {
290907 0 : ROSE_ASSERT(this != NULL);
290908 0 : return "SgModuleSymbol";
290909 : }
290910 :
290911 : // DQ (11/26/2005): Support for visitor pattern mechanims
290912 : // (inferior to ROSE traversal mechanism, experimental).
290913 : void
290914 0 : SgModuleSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
290915 : {
290916 0 : ROSE_ASSERT(this != NULL);
290917 0 : visitor.visit(this);
290918 0 : }
290919 :
290920 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
290921 0 : void SgModuleSymbol::accept (ROSE_VisitorPattern & visitor) {
290922 0 : ROSE_ASSERT(this != NULL);
290923 0 : visitor.visit(this);
290924 0 : }
290925 :
290926 : SgModuleSymbol*
290927 0 : SgModuleSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
290928 : {
290929 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
290930 : // This function is currently only supported for the AST used the represent Binary executables.
290931 : if (0 /* isSgAsmNode(this) != NULL */)
290932 : {
290933 : // Support for regex specification.
290934 : std::string prefixCode = "REGEX:";
290935 : addNewAttribute(prefixCode + s,a);
290936 : }
290937 : #endif
290938 :
290939 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
290940 0 : return this;
290941 : }
290942 :
290943 : // *** COMMON CODE SECTION ENDS HERE ***
290944 :
290945 :
290946 : // End of memberFunctionString
290947 : // Start of memberFunctionString
290948 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
290949 :
290950 :
290951 : #if 0
290952 : //! Error checking support
290953 : /*! Verifies the following:
290954 : - working getVariant() member function
290955 : - calls base class's error() member function
290956 : Every class has one of these functions.
290957 : */
290958 : bool
290959 : SgModuleSymbol::error()
290960 : {
290961 : // Put error checking here
290962 :
290963 : ROSE_ASSERT (this != NULL);
290964 : if (getVariant() != MODULE_SYMBOL)
290965 : {
290966 : printf ("Error in SgModuleSymbol::error(): SgModuleSymbol object has a %s variant \n",
290967 : Cxx_GrammarTerminalNames[getVariant()].name);
290968 : // printf ("Error in SgModuleSymbol::error() \n");
290969 : ROSE_ABORT();
290970 : }
290971 :
290972 : ROSE_ASSERT (getVariant() == MODULE_SYMBOL);
290973 : return SgSymbol::error();
290974 : }
290975 : #endif
290976 :
290977 :
290978 :
290979 : // End of memberFunctionString
290980 :
290981 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
290982 :
290983 0 : SgModuleSymbol* isSgModuleSymbol ( SgNode* inputDerivedClassPointer )
290984 : {
290985 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
290986 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
290987 : // So to fix this we return NULL directly when the input is NULL and avoid the
290988 : // dynamic_cast in this case. This is likely a performance improvement as well.
290989 : // return dynamic_cast<SgModuleSymbol*>(inputDerivedClassPointer);
290990 : // Milind Chabbi (8/28/2013): isSgModuleSymbol uses table-driven castability instead of c++ default dynamic_cast
290991 : // this improves the running time performance by 10-20%.
290992 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgModuleSymbol*>(inputDerivedClassPointer);
290993 0 : return IS_SgModuleSymbol_FAST_MACRO(inputDerivedClassPointer);
290994 : }
290995 :
290996 : // DQ (11/8/2003): Added version of functions taking const pointer
290997 0 : const SgModuleSymbol* isSgModuleSymbol ( const SgNode* inputDerivedClassPointer )
290998 : {
290999 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
291000 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
291001 : // So to fix this we return NULL directly when the input is NULL and avoid the
291002 : // dynamic_cast in this case. This is likely a performance improvement as well.
291003 : // return dynamic_cast<const SgModuleSymbol*>(inputDerivedClassPointer);
291004 : // Milind Chabbi (8/28/2013): isSgModuleSymbol uses table-driven castability instead of c++ default dynamic_cast
291005 : // this improves the running time performance by 10-20%.
291006 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgModuleSymbol*>(inputDerivedClassPointer);
291007 0 : return IS_SgModuleSymbol_FAST_MACRO(inputDerivedClassPointer);
291008 : }
291009 :
291010 :
291011 :
291012 : /* #line 291013 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291013 :
291014 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
291015 :
291016 : /**
291017 : \brief Generated destructor
291018 :
291019 : This destructor is automatically generated (by ROSETTA). This destructor
291020 : only frees memory of data members associated with the parts of the current IR node which
291021 : are NOT traversed. Those data members that are part of a traversal can be freed using
291022 : a traversal (calling this destructor on all children in a post-order traversal). Such
291023 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
291024 :
291025 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
291026 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
291027 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
291028 :
291029 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
291030 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
291031 : pointers are not yet implemented to call delete on eash pointer in the container.
291032 : (This could be done by derivation from the STL containers to define containers that
291033 : automatically deleted their members.)
291034 :
291035 : */
291036 0 : SgModuleSymbol::~SgModuleSymbol () {
291037 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
291038 :
291039 :
291040 : // case: not a listType for declaration
291041 0 : p_declaration = NULL; // non list case
291042 :
291043 : }
291044 :
291045 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
291046 0 : }
291047 :
291048 :
291049 : /* #line 291050 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291050 :
291051 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
291052 :
291053 : // Generated constructor
291054 0 : SgModuleSymbol::SgModuleSymbol ( SgModuleStatement* declaration )
291055 0 : : SgSymbol()
291056 : {
291057 : #ifdef DEBUG
291058 : // printf ("In SgModuleSymbol::SgModuleSymbol (SgModuleStatement* declaration) sage_class_name() = %s \n",sage_class_name());
291059 : #endif
291060 : #if 0
291061 : // debugging information!
291062 : printf ("In SgModuleSymbol::SgModuleSymbol (SgModuleStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
291063 : #endif
291064 :
291065 0 : p_declaration = declaration;
291066 :
291067 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
291068 :
291069 : #if 0
291070 : // DQ (7/30/2014): Call a virtual function.
291071 : std::string s = this->class_name();
291072 : #endif
291073 :
291074 : // Test the variant virtual function
291075 : // assert(MODULE_SYMBOL == variant());
291076 0 : assert(MODULE_SYMBOL == this->variant());
291077 0 : ROSE_ASSERT(MODULE_SYMBOL == (int)(this->variantT()));
291078 0 : post_construction_initialization();
291079 :
291080 : // Test the isSgModuleSymbol() function since it has been problematic
291081 0 : assert(isSgModuleSymbol(this) != NULL);
291082 0 : }
291083 :
291084 : // Generated constructor (all data members)
291085 :
291086 : /* #line 291087 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291087 :
291088 :
291089 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
291090 :
291091 :
291092 : // ********************************************************
291093 : // member functions common across all array grammar objects
291094 : // ********************************************************
291095 :
291096 :
291097 :
291098 : /* #line 291099 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291099 :
291100 :
291101 :
291102 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
291103 :
291104 : // ********************************************************
291105 : // member functions specific to each node in the grammar
291106 : // ********************************************************
291107 :
291108 :
291109 : /* #line 291110 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291110 :
291111 : // Start of memberFunctionString
291112 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
291113 :
291114 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
291115 :
291116 : SgInterfaceStatement*
291117 0 : SgInterfaceSymbol::get_declaration () const
291118 : {
291119 0 : ROSE_ASSERT (this != NULL);
291120 :
291121 : #if 0
291122 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291123 : // used to trigger marking transformations for the token-based unparsing.
291124 : printf ("SgInterfaceSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
291125 : #endif
291126 :
291127 0 : return p_declaration;
291128 : }
291129 :
291130 : void
291131 0 : SgInterfaceSymbol::set_declaration ( SgInterfaceStatement* declaration )
291132 : {
291133 0 : ROSE_ASSERT (this != NULL);
291134 :
291135 : #if 0
291136 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291137 : // used to trigger marking transformations for the token-based unparsing.
291138 : printf ("SgInterfaceSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
291139 : #endif
291140 :
291141 0 : set_isModified(true);
291142 :
291143 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
291144 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
291145 : {
291146 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
291147 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
291148 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
291149 : ROSE_ASSERT(false);
291150 : #endif
291151 : }
291152 : #endif
291153 0 : p_declaration = declaration;
291154 0 : }
291155 :
291156 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
291157 :
291158 :
291159 : // End of memberFunctionString
291160 : // Start of memberFunctionString
291161 : /* #line 547 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
291162 :
291163 : SgType*
291164 0 : SgInterfaceSymbol::get_type() const
291165 : {
291166 0 : return NULL;
291167 : }
291168 :
291169 : #if 0
291170 : // DQ (2/6/2007): This returns the basis for the EMPTY_GET_TYPE
291171 : SgNode*
291172 : SgInterfaceSymbol::get_symbol_basis() const
291173 : {
291174 : return NULL;
291175 : }
291176 : #endif
291177 :
291178 :
291179 : // End of memberFunctionString
291180 : // Start of memberFunctionString
291181 : /* #line 910 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
291182 :
291183 : SgName
291184 0 : SgInterfaceSymbol::get_name() const
291185 : {
291186 : #if 1
291187 : // (original note from Sage II) this is less efficient but it does avoid a bug in Sun C++
291188 0 : SgName theName;
291189 :
291190 0 : if (get_declaration())
291191 : {
291192 0 : theName = get_declaration()->get_name();
291193 : }
291194 : else
291195 : {
291196 0 : theName = SgName("undefined");
291197 : }
291198 :
291199 0 : return theName;
291200 : #else
291201 : return (get_declaration) ? get_declaration()->get_name() : SgName("undefined");
291202 : #endif
291203 : }
291204 :
291205 : SgNode*
291206 0 : SgInterfaceSymbol::get_symbol_basis() const
291207 : {
291208 0 : return get_declaration();
291209 : }
291210 :
291211 :
291212 :
291213 : // End of memberFunctionString
291214 : // Start of memberFunctionString
291215 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
291216 :
291217 : // *** COMMON CODE SECTION BEGINS HERE ***
291218 :
291219 : #if 0
291220 : int
291221 : SgInterfaceSymbol::getVariant() const
291222 : {
291223 : // This function is used in ROSE while "variant()" is used in SAGE
291224 : assert(this != NULL);
291225 : return variant();
291226 : }
291227 : #endif
291228 :
291229 : // This function is used in ROSE in treeTraversal code
291230 : // eventually replaces getVariant() and variant()
291231 : // though after variant() has been removed for a while we will
291232 : // want to change the name of variantT() back to variant()
291233 : // (since the "T" was ment to stand for temporary).
291234 : // When this happens the variantT() will be depricated.
291235 : VariantT
291236 0 : SgInterfaceSymbol::variantT() const
291237 : {
291238 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
291239 0 : ROSE_ASSERT(this != NULL);
291240 0 : return V_SgInterfaceSymbol;
291241 : }
291242 :
291243 : #if 0
291244 : int
291245 : SgInterfaceSymbol::variant() const
291246 : {
291247 : // This function is used in SAGE
291248 : ROSE_ASSERT(this != NULL);
291249 : return INTERFACE_SYMBOL;
291250 : }
291251 : #endif
291252 :
291253 : ROSE_DLL_API const char*
291254 0 : SgInterfaceSymbol::sage_class_name() const
291255 : {
291256 0 : ROSE_ASSERT(this != NULL);
291257 0 : return "SgInterfaceSymbol";
291258 : }
291259 :
291260 : std::string
291261 0 : SgInterfaceSymbol::class_name() const
291262 : {
291263 0 : ROSE_ASSERT(this != NULL);
291264 0 : return "SgInterfaceSymbol";
291265 : }
291266 :
291267 : // DQ (11/26/2005): Support for visitor pattern mechanims
291268 : // (inferior to ROSE traversal mechanism, experimental).
291269 : void
291270 0 : SgInterfaceSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
291271 : {
291272 0 : ROSE_ASSERT(this != NULL);
291273 0 : visitor.visit(this);
291274 0 : }
291275 :
291276 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
291277 0 : void SgInterfaceSymbol::accept (ROSE_VisitorPattern & visitor) {
291278 0 : ROSE_ASSERT(this != NULL);
291279 0 : visitor.visit(this);
291280 0 : }
291281 :
291282 : SgInterfaceSymbol*
291283 0 : SgInterfaceSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
291284 : {
291285 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
291286 : // This function is currently only supported for the AST used the represent Binary executables.
291287 : if (0 /* isSgAsmNode(this) != NULL */)
291288 : {
291289 : // Support for regex specification.
291290 : std::string prefixCode = "REGEX:";
291291 : addNewAttribute(prefixCode + s,a);
291292 : }
291293 : #endif
291294 :
291295 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
291296 0 : return this;
291297 : }
291298 :
291299 : // *** COMMON CODE SECTION ENDS HERE ***
291300 :
291301 :
291302 : // End of memberFunctionString
291303 : // Start of memberFunctionString
291304 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
291305 :
291306 :
291307 : #if 0
291308 : //! Error checking support
291309 : /*! Verifies the following:
291310 : - working getVariant() member function
291311 : - calls base class's error() member function
291312 : Every class has one of these functions.
291313 : */
291314 : bool
291315 : SgInterfaceSymbol::error()
291316 : {
291317 : // Put error checking here
291318 :
291319 : ROSE_ASSERT (this != NULL);
291320 : if (getVariant() != INTERFACE_SYMBOL)
291321 : {
291322 : printf ("Error in SgInterfaceSymbol::error(): SgInterfaceSymbol object has a %s variant \n",
291323 : Cxx_GrammarTerminalNames[getVariant()].name);
291324 : // printf ("Error in SgInterfaceSymbol::error() \n");
291325 : ROSE_ABORT();
291326 : }
291327 :
291328 : ROSE_ASSERT (getVariant() == INTERFACE_SYMBOL);
291329 : return SgSymbol::error();
291330 : }
291331 : #endif
291332 :
291333 :
291334 :
291335 : // End of memberFunctionString
291336 :
291337 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
291338 :
291339 0 : SgInterfaceSymbol* isSgInterfaceSymbol ( SgNode* inputDerivedClassPointer )
291340 : {
291341 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
291342 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
291343 : // So to fix this we return NULL directly when the input is NULL and avoid the
291344 : // dynamic_cast in this case. This is likely a performance improvement as well.
291345 : // return dynamic_cast<SgInterfaceSymbol*>(inputDerivedClassPointer);
291346 : // Milind Chabbi (8/28/2013): isSgInterfaceSymbol uses table-driven castability instead of c++ default dynamic_cast
291347 : // this improves the running time performance by 10-20%.
291348 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgInterfaceSymbol*>(inputDerivedClassPointer);
291349 0 : return IS_SgInterfaceSymbol_FAST_MACRO(inputDerivedClassPointer);
291350 : }
291351 :
291352 : // DQ (11/8/2003): Added version of functions taking const pointer
291353 0 : const SgInterfaceSymbol* isSgInterfaceSymbol ( const SgNode* inputDerivedClassPointer )
291354 : {
291355 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
291356 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
291357 : // So to fix this we return NULL directly when the input is NULL and avoid the
291358 : // dynamic_cast in this case. This is likely a performance improvement as well.
291359 : // return dynamic_cast<const SgInterfaceSymbol*>(inputDerivedClassPointer);
291360 : // Milind Chabbi (8/28/2013): isSgInterfaceSymbol uses table-driven castability instead of c++ default dynamic_cast
291361 : // this improves the running time performance by 10-20%.
291362 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgInterfaceSymbol*>(inputDerivedClassPointer);
291363 0 : return IS_SgInterfaceSymbol_FAST_MACRO(inputDerivedClassPointer);
291364 : }
291365 :
291366 :
291367 :
291368 : /* #line 291369 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291369 :
291370 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
291371 :
291372 : /**
291373 : \brief Generated destructor
291374 :
291375 : This destructor is automatically generated (by ROSETTA). This destructor
291376 : only frees memory of data members associated with the parts of the current IR node which
291377 : are NOT traversed. Those data members that are part of a traversal can be freed using
291378 : a traversal (calling this destructor on all children in a post-order traversal). Such
291379 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
291380 :
291381 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
291382 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
291383 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
291384 :
291385 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
291386 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
291387 : pointers are not yet implemented to call delete on eash pointer in the container.
291388 : (This could be done by derivation from the STL containers to define containers that
291389 : automatically deleted their members.)
291390 :
291391 : */
291392 0 : SgInterfaceSymbol::~SgInterfaceSymbol () {
291393 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
291394 :
291395 :
291396 : // case: not a listType for declaration
291397 0 : p_declaration = NULL; // non list case
291398 :
291399 : }
291400 :
291401 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
291402 0 : }
291403 :
291404 :
291405 : /* #line 291406 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291406 :
291407 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
291408 :
291409 : // Generated constructor
291410 0 : SgInterfaceSymbol::SgInterfaceSymbol ( SgInterfaceStatement* declaration )
291411 0 : : SgSymbol()
291412 : {
291413 : #ifdef DEBUG
291414 : // printf ("In SgInterfaceSymbol::SgInterfaceSymbol (SgInterfaceStatement* declaration) sage_class_name() = %s \n",sage_class_name());
291415 : #endif
291416 : #if 0
291417 : // debugging information!
291418 : printf ("In SgInterfaceSymbol::SgInterfaceSymbol (SgInterfaceStatement* declaration): this = %p = %s \n",this,this->class_name().c_str());
291419 : #endif
291420 :
291421 0 : p_declaration = declaration;
291422 :
291423 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
291424 :
291425 : #if 0
291426 : // DQ (7/30/2014): Call a virtual function.
291427 : std::string s = this->class_name();
291428 : #endif
291429 :
291430 : // Test the variant virtual function
291431 : // assert(INTERFACE_SYMBOL == variant());
291432 0 : assert(INTERFACE_SYMBOL == this->variant());
291433 0 : ROSE_ASSERT(INTERFACE_SYMBOL == (int)(this->variantT()));
291434 0 : post_construction_initialization();
291435 :
291436 : // Test the isSgInterfaceSymbol() function since it has been problematic
291437 0 : assert(isSgInterfaceSymbol(this) != NULL);
291438 0 : }
291439 :
291440 : // Generated constructor (all data members)
291441 :
291442 : /* #line 291443 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291443 :
291444 :
291445 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
291446 :
291447 :
291448 : // ********************************************************
291449 : // member functions common across all array grammar objects
291450 : // ********************************************************
291451 :
291452 :
291453 :
291454 : /* #line 291455 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291455 :
291456 :
291457 :
291458 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
291459 :
291460 : // ********************************************************
291461 : // member functions specific to each node in the grammar
291462 : // ********************************************************
291463 :
291464 :
291465 : /* #line 291466 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291466 :
291467 : // Start of memberFunctionString
291468 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
291469 :
291470 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
291471 :
291472 : SgInitializedName*
291473 0 : SgCommonSymbol::get_declaration () const
291474 : {
291475 0 : ROSE_ASSERT (this != NULL);
291476 :
291477 : #if 0
291478 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291479 : // used to trigger marking transformations for the token-based unparsing.
291480 : printf ("SgCommonSymbol::get_declaration = %p = %s \n",this,this->class_name().c_str());
291481 : #endif
291482 :
291483 0 : return p_declaration;
291484 : }
291485 :
291486 : void
291487 0 : SgCommonSymbol::set_declaration ( SgInitializedName* declaration )
291488 : {
291489 0 : ROSE_ASSERT (this != NULL);
291490 :
291491 : #if 0
291492 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291493 : // used to trigger marking transformations for the token-based unparsing.
291494 : printf ("SgCommonSymbol::set_declaration = %p = %s \n",this,this->class_name().c_str());
291495 : #endif
291496 :
291497 0 : set_isModified(true);
291498 :
291499 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
291500 : if (p_declaration != NULL && declaration != NULL && p_declaration != declaration)
291501 : {
291502 : printf ("Warning: declaration = %p overwriting valid pointer p_declaration = %p \n",declaration,p_declaration);
291503 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
291504 : printf ("Error fails assertion (p_declaration != NULL && declaration != NULL && p_declaration != declaration) is false\n");
291505 : ROSE_ASSERT(false);
291506 : #endif
291507 : }
291508 : #endif
291509 0 : p_declaration = declaration;
291510 0 : }
291511 :
291512 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
291513 :
291514 :
291515 : // End of memberFunctionString
291516 : // Start of memberFunctionString
291517 : /* #line 529 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
291518 :
291519 : SgType*
291520 0 : SgCommonSymbol::get_type() const
291521 : {
291522 0 : return (get_declaration() != NULL) ? get_declaration()->get_type() : NULL;
291523 : }
291524 :
291525 : #if 0
291526 : // DQ (2/6/2007): This returns the basis for the type based symbol (get_type for the SgFunctionTypeSymbol)
291527 : SgNode*
291528 : SgCommonSymbol::get_symbol_basis() const
291529 : {
291530 : return get_type();
291531 : }
291532 : #endif
291533 :
291534 :
291535 : // End of memberFunctionString
291536 : // Start of memberFunctionString
291537 : /* #line 848 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
291538 :
291539 : SgName
291540 0 : SgCommonSymbol::get_name() const
291541 : {
291542 : #if 1
291543 : // (original note from Sage II) this is less efficient but it does avoid a bug in Sun C++
291544 0 : SgName theName;
291545 :
291546 0 : if (get_declaration())
291547 : {
291548 0 : theName = get_declaration()->get_name();
291549 : }
291550 : else
291551 : {
291552 0 : theName = SgName("undefined");
291553 : }
291554 :
291555 0 : return theName;
291556 : #else
291557 : return (get_declaration) ? get_declaration()->get_name() : SgName("undefined");
291558 : #endif
291559 : }
291560 :
291561 : SgNode*
291562 0 : SgCommonSymbol::get_symbol_basis() const
291563 : {
291564 0 : return get_declaration();
291565 : }
291566 :
291567 :
291568 :
291569 : // End of memberFunctionString
291570 : // Start of memberFunctionString
291571 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
291572 :
291573 : // *** COMMON CODE SECTION BEGINS HERE ***
291574 :
291575 : #if 0
291576 : int
291577 : SgCommonSymbol::getVariant() const
291578 : {
291579 : // This function is used in ROSE while "variant()" is used in SAGE
291580 : assert(this != NULL);
291581 : return variant();
291582 : }
291583 : #endif
291584 :
291585 : // This function is used in ROSE in treeTraversal code
291586 : // eventually replaces getVariant() and variant()
291587 : // though after variant() has been removed for a while we will
291588 : // want to change the name of variantT() back to variant()
291589 : // (since the "T" was ment to stand for temporary).
291590 : // When this happens the variantT() will be depricated.
291591 : VariantT
291592 0 : SgCommonSymbol::variantT() const
291593 : {
291594 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
291595 0 : ROSE_ASSERT(this != NULL);
291596 0 : return V_SgCommonSymbol;
291597 : }
291598 :
291599 : #if 0
291600 : int
291601 : SgCommonSymbol::variant() const
291602 : {
291603 : // This function is used in SAGE
291604 : ROSE_ASSERT(this != NULL);
291605 : return COMMON_SYMBOL;
291606 : }
291607 : #endif
291608 :
291609 : ROSE_DLL_API const char*
291610 0 : SgCommonSymbol::sage_class_name() const
291611 : {
291612 0 : ROSE_ASSERT(this != NULL);
291613 0 : return "SgCommonSymbol";
291614 : }
291615 :
291616 : std::string
291617 0 : SgCommonSymbol::class_name() const
291618 : {
291619 0 : ROSE_ASSERT(this != NULL);
291620 0 : return "SgCommonSymbol";
291621 : }
291622 :
291623 : // DQ (11/26/2005): Support for visitor pattern mechanims
291624 : // (inferior to ROSE traversal mechanism, experimental).
291625 : void
291626 0 : SgCommonSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
291627 : {
291628 0 : ROSE_ASSERT(this != NULL);
291629 0 : visitor.visit(this);
291630 0 : }
291631 :
291632 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
291633 0 : void SgCommonSymbol::accept (ROSE_VisitorPattern & visitor) {
291634 0 : ROSE_ASSERT(this != NULL);
291635 0 : visitor.visit(this);
291636 0 : }
291637 :
291638 : SgCommonSymbol*
291639 0 : SgCommonSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
291640 : {
291641 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
291642 : // This function is currently only supported for the AST used the represent Binary executables.
291643 : if (0 /* isSgAsmNode(this) != NULL */)
291644 : {
291645 : // Support for regex specification.
291646 : std::string prefixCode = "REGEX:";
291647 : addNewAttribute(prefixCode + s,a);
291648 : }
291649 : #endif
291650 :
291651 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
291652 0 : return this;
291653 : }
291654 :
291655 : // *** COMMON CODE SECTION ENDS HERE ***
291656 :
291657 :
291658 : // End of memberFunctionString
291659 : // Start of memberFunctionString
291660 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
291661 :
291662 :
291663 : #if 0
291664 : //! Error checking support
291665 : /*! Verifies the following:
291666 : - working getVariant() member function
291667 : - calls base class's error() member function
291668 : Every class has one of these functions.
291669 : */
291670 : bool
291671 : SgCommonSymbol::error()
291672 : {
291673 : // Put error checking here
291674 :
291675 : ROSE_ASSERT (this != NULL);
291676 : if (getVariant() != COMMON_SYMBOL)
291677 : {
291678 : printf ("Error in SgCommonSymbol::error(): SgCommonSymbol object has a %s variant \n",
291679 : Cxx_GrammarTerminalNames[getVariant()].name);
291680 : // printf ("Error in SgCommonSymbol::error() \n");
291681 : ROSE_ABORT();
291682 : }
291683 :
291684 : ROSE_ASSERT (getVariant() == COMMON_SYMBOL);
291685 : return SgSymbol::error();
291686 : }
291687 : #endif
291688 :
291689 :
291690 :
291691 : // End of memberFunctionString
291692 :
291693 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
291694 :
291695 0 : SgCommonSymbol* isSgCommonSymbol ( SgNode* inputDerivedClassPointer )
291696 : {
291697 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
291698 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
291699 : // So to fix this we return NULL directly when the input is NULL and avoid the
291700 : // dynamic_cast in this case. This is likely a performance improvement as well.
291701 : // return dynamic_cast<SgCommonSymbol*>(inputDerivedClassPointer);
291702 : // Milind Chabbi (8/28/2013): isSgCommonSymbol uses table-driven castability instead of c++ default dynamic_cast
291703 : // this improves the running time performance by 10-20%.
291704 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgCommonSymbol*>(inputDerivedClassPointer);
291705 0 : return IS_SgCommonSymbol_FAST_MACRO(inputDerivedClassPointer);
291706 : }
291707 :
291708 : // DQ (11/8/2003): Added version of functions taking const pointer
291709 0 : const SgCommonSymbol* isSgCommonSymbol ( const SgNode* inputDerivedClassPointer )
291710 : {
291711 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
291712 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
291713 : // So to fix this we return NULL directly when the input is NULL and avoid the
291714 : // dynamic_cast in this case. This is likely a performance improvement as well.
291715 : // return dynamic_cast<const SgCommonSymbol*>(inputDerivedClassPointer);
291716 : // Milind Chabbi (8/28/2013): isSgCommonSymbol uses table-driven castability instead of c++ default dynamic_cast
291717 : // this improves the running time performance by 10-20%.
291718 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgCommonSymbol*>(inputDerivedClassPointer);
291719 0 : return IS_SgCommonSymbol_FAST_MACRO(inputDerivedClassPointer);
291720 : }
291721 :
291722 :
291723 :
291724 : /* #line 291725 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291725 :
291726 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
291727 :
291728 : /**
291729 : \brief Generated destructor
291730 :
291731 : This destructor is automatically generated (by ROSETTA). This destructor
291732 : only frees memory of data members associated with the parts of the current IR node which
291733 : are NOT traversed. Those data members that are part of a traversal can be freed using
291734 : a traversal (calling this destructor on all children in a post-order traversal). Such
291735 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
291736 :
291737 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
291738 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
291739 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
291740 :
291741 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
291742 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
291743 : pointers are not yet implemented to call delete on eash pointer in the container.
291744 : (This could be done by derivation from the STL containers to define containers that
291745 : automatically deleted their members.)
291746 :
291747 : */
291748 0 : SgCommonSymbol::~SgCommonSymbol () {
291749 0 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
291750 :
291751 :
291752 : // case: not a listType for declaration
291753 0 : p_declaration = NULL; // non list case
291754 :
291755 : }
291756 :
291757 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
291758 0 : }
291759 :
291760 :
291761 : /* #line 291762 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291762 :
291763 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
291764 :
291765 : // Generated constructor
291766 0 : SgCommonSymbol::SgCommonSymbol ( SgInitializedName* declaration )
291767 0 : : SgSymbol()
291768 : {
291769 : #ifdef DEBUG
291770 : // printf ("In SgCommonSymbol::SgCommonSymbol (SgInitializedName* declaration) sage_class_name() = %s \n",sage_class_name());
291771 : #endif
291772 : #if 0
291773 : // debugging information!
291774 : printf ("In SgCommonSymbol::SgCommonSymbol (SgInitializedName* declaration): this = %p = %s \n",this,this->class_name().c_str());
291775 : #endif
291776 :
291777 0 : p_declaration = declaration;
291778 :
291779 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
291780 :
291781 : #if 0
291782 : // DQ (7/30/2014): Call a virtual function.
291783 : std::string s = this->class_name();
291784 : #endif
291785 :
291786 : // Test the variant virtual function
291787 : // assert(COMMON_SYMBOL == variant());
291788 0 : assert(COMMON_SYMBOL == this->variant());
291789 0 : ROSE_ASSERT(COMMON_SYMBOL == (int)(this->variantT()));
291790 0 : post_construction_initialization();
291791 :
291792 : // Test the isSgCommonSymbol() function since it has been problematic
291793 0 : assert(isSgCommonSymbol(this) != NULL);
291794 0 : }
291795 :
291796 : // Generated constructor (all data members)
291797 :
291798 : /* #line 291799 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291799 :
291800 :
291801 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
291802 :
291803 :
291804 : // ********************************************************
291805 : // member functions common across all array grammar objects
291806 : // ********************************************************
291807 :
291808 :
291809 :
291810 : /* #line 291811 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291811 :
291812 :
291813 :
291814 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
291815 :
291816 : // ********************************************************
291817 : // member functions specific to each node in the grammar
291818 : // ********************************************************
291819 :
291820 :
291821 : /* #line 291822 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
291822 :
291823 : // Start of memberFunctionString
291824 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
291825 :
291826 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
291827 :
291828 : SgSymbol*
291829 3290130 : SgAliasSymbol::get_alias () const
291830 : {
291831 3290130 : ROSE_ASSERT (this != NULL);
291832 :
291833 : #if 0
291834 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291835 : // used to trigger marking transformations for the token-based unparsing.
291836 : printf ("SgAliasSymbol::get_alias = %p = %s \n",this,this->class_name().c_str());
291837 : #endif
291838 :
291839 3290130 : return p_alias;
291840 : }
291841 :
291842 : void
291843 0 : SgAliasSymbol::set_alias ( SgSymbol* alias )
291844 : {
291845 0 : ROSE_ASSERT (this != NULL);
291846 :
291847 : #if 0
291848 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291849 : // used to trigger marking transformations for the token-based unparsing.
291850 : printf ("SgAliasSymbol::set_alias = %p = %s \n",this,this->class_name().c_str());
291851 : #endif
291852 :
291853 0 : set_isModified(true);
291854 :
291855 : #if DEBUG_SAGE_ACCESS_FUNCTIONS
291856 : if (p_alias != NULL && alias != NULL && p_alias != alias)
291857 : {
291858 : printf ("Warning: alias = %p overwriting valid pointer p_alias = %p \n",alias,p_alias);
291859 : #if DEBUG_SAGE_ACCESS_FUNCTIONS_ASSERTION
291860 : printf ("Error fails assertion (p_alias != NULL && alias != NULL && p_alias != alias) is false\n");
291861 : ROSE_ASSERT(false);
291862 : #endif
291863 : }
291864 : #endif
291865 0 : p_alias = alias;
291866 0 : }
291867 :
291868 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
291869 :
291870 :
291871 : // End of memberFunctionString
291872 : // Start of memberFunctionString
291873 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
291874 :
291875 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
291876 :
291877 : bool
291878 9524 : SgAliasSymbol::get_isRenamed () const
291879 : {
291880 9524 : ROSE_ASSERT (this != NULL);
291881 :
291882 : #if 0
291883 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291884 : // used to trigger marking transformations for the token-based unparsing.
291885 : printf ("SgAliasSymbol::get_isRenamed = %p = %s \n",this,this->class_name().c_str());
291886 : #endif
291887 :
291888 9524 : return p_isRenamed;
291889 : }
291890 :
291891 : void
291892 0 : SgAliasSymbol::set_isRenamed ( bool isRenamed )
291893 : {
291894 0 : ROSE_ASSERT (this != NULL);
291895 :
291896 : #if 0
291897 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291898 : // used to trigger marking transformations for the token-based unparsing.
291899 : printf ("SgAliasSymbol::set_isRenamed = %p = %s \n",this,this->class_name().c_str());
291900 : #endif
291901 :
291902 0 : set_isModified(true);
291903 :
291904 0 : p_isRenamed = isRenamed;
291905 0 : }
291906 :
291907 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
291908 :
291909 :
291910 : // End of memberFunctionString
291911 : // Start of memberFunctionString
291912 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/dataMemberAccessFunctions.macro" */
291913 :
291914 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
291915 :
291916 : SgName
291917 0 : SgAliasSymbol::get_new_name () const
291918 : {
291919 0 : ROSE_ASSERT (this != NULL);
291920 :
291921 : #if 0
291922 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291923 : // used to trigger marking transformations for the token-based unparsing.
291924 : printf ("SgAliasSymbol::get_new_name = %p = %s \n",this,this->class_name().c_str());
291925 : #endif
291926 :
291927 0 : return p_new_name;
291928 : }
291929 :
291930 : void
291931 0 : SgAliasSymbol::set_new_name ( SgName new_name )
291932 : {
291933 0 : ROSE_ASSERT (this != NULL);
291934 :
291935 : #if 0
291936 : // DQ (6/12/2015): Added debugging support to trace setting of isModified flag
291937 : // used to trigger marking transformations for the token-based unparsing.
291938 : printf ("SgAliasSymbol::set_new_name = %p = %s \n",this,this->class_name().c_str());
291939 : #endif
291940 :
291941 0 : set_isModified(true);
291942 :
291943 0 : p_new_name = new_name;
291944 0 : }
291945 :
291946 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
291947 :
291948 :
291949 : // End of memberFunctionString
291950 : // Start of memberFunctionString
291951 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/listMemberAccessFunctions.macro" */
291952 :
291953 : // *** DATA ACCESS FUNCTION SECTION BEGINS HERE ***
291954 :
291955 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
291956 : const SgNodePtrList &
291957 0 : SgAliasSymbol::get_causal_nodes () const
291958 : {
291959 0 : assert (this != NULL);
291960 0 : return p_causal_nodes;
291961 : }
291962 :
291963 : // Note that we don't build a "set" function since the return by reference allows the operator= to be called
291964 : SgNodePtrList &
291965 229492 : SgAliasSymbol::get_causal_nodes ()
291966 : {
291967 229492 : assert (this != NULL);
291968 :
291969 : // DQ (4/14/2015): After discussion with Markus we agree that even non-const functions should not have to set the isModified flag.
291970 : // As a rule only set_ access functions can set the isModified flag.
291971 : // set_isModified(true);
291972 :
291973 229492 : return p_causal_nodes;
291974 : }
291975 :
291976 : // *** DATA ACCESS FUNCTION SECTION ENDS HERE ***
291977 :
291978 :
291979 : // End of memberFunctionString
291980 : // Start of memberFunctionString
291981 : /* #line 943 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Symbol.code" */
291982 :
291983 : SgName
291984 9524 : SgAliasSymbol::get_name() const
291985 : {
291986 9524 : ROSE_ASSERT(p_alias != NULL);
291987 :
291988 9524 : SgName name;
291989 9524 : if (get_isRenamed() == true)
291990 : {
291991 0 : name = get_new_name();
291992 : }
291993 : else
291994 : {
291995 9524 : name = get_alias()->get_name();
291996 : }
291997 :
291998 : #if 0
291999 : // DQ (1/21/2019): Adding debugging information.
292000 : printf ("In SgAliasSymbol::get_name(): name = %s \n",name.str());
292001 : #endif
292002 :
292003 9524 : return name;
292004 : }
292005 :
292006 : SgNode*
292007 2792030 : SgAliasSymbol::get_symbol_basis() const
292008 : {
292009 2792030 : ROSE_ASSERT(p_alias != NULL);
292010 2792030 : return get_alias()->get_symbol_basis();
292011 : }
292012 :
292013 : SgType*
292014 0 : SgAliasSymbol::get_type() const
292015 : {
292016 0 : ROSE_ASSERT(p_alias != NULL);
292017 0 : return get_alias()->get_type();
292018 : }
292019 :
292020 : SgSymbol*
292021 189256 : SgAliasSymbol::get_base() const
292022 : {
292023 : // DQ (10/9/2008): For a chain of aliased symbols, this function returns the last (non-aliased) symbol.
292024 189256 : SgSymbol* nonAliasedSymbol = get_alias();
292025 189256 : ROSE_ASSERT(nonAliasedSymbol != NULL);
292026 :
292027 189256 : SgAliasSymbol* aliasSymbol = isSgAliasSymbol(get_alias());
292028 189256 : while (aliasSymbol != NULL)
292029 : {
292030 : #if 0
292031 : // DQ (1/21/2019): Adding debugging information.
292032 : printf ("SgAliasSymbol::get_base(): We want to avoid chains of SgAliasSymbol symbols \n");
292033 : #endif
292034 : // This may be any symbol (even a SgAliasSymbol)
292035 0 : nonAliasedSymbol = aliasSymbol->get_alias();
292036 :
292037 : // Advance in the chain to the next SgAliasSymbol symbol
292038 0 : aliasSymbol = isSgAliasSymbol(aliasSymbol->get_alias());
292039 : }
292040 :
292041 : // Every chain of aliased symbols should have a non-aliased symbol at the end!
292042 189256 : ROSE_ASSERT(nonAliasedSymbol != NULL);
292043 189256 : return nonAliasedSymbol;
292044 : }
292045 :
292046 :
292047 : SgDeclarationStatement*
292048 0 : SgAliasSymbol::get_declaration() const
292049 : {
292050 : // DQ (4/14/2010): Added support for getting declarations from the alias symbols.
292051 :
292052 0 : ROSE_ASSERT(get_alias() != NULL);
292053 :
292054 0 : SgDeclarationStatement* returnValue = NULL;
292055 0 : switch (get_alias()->variantT())
292056 : {
292057 0 : case V_SgNamespaceSymbol:
292058 0 : {
292059 0 : SgNamespaceSymbol* symbol = isSgNamespaceSymbol(get_alias());
292060 0 : ROSE_ASSERT(symbol != NULL);
292061 0 : returnValue = symbol->get_declaration();
292062 0 : ROSE_ASSERT(returnValue != NULL);
292063 0 : break;
292064 : }
292065 :
292066 0 : case V_SgVariableSymbol:
292067 0 : {
292068 : // This case is a bit special since the SgInitializedName is not a declaration
292069 : // and thus the get_declaration() function does not return a SgDeclarationStatement.
292070 0 : SgVariableSymbol* symbol = isSgVariableSymbol(get_alias());
292071 0 : ROSE_ASSERT(symbol != NULL);
292072 0 : SgInitializedName* initializedName = isSgInitializedName(symbol->get_declaration());
292073 0 : ROSE_ASSERT(initializedName != NULL);
292074 0 : SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(initializedName->get_parent());
292075 0 : ROSE_ASSERT(variableDeclaration != NULL);
292076 0 : returnValue = variableDeclaration;
292077 0 : ROSE_ASSERT(returnValue != NULL);
292078 0 : break;
292079 : }
292080 :
292081 0 : case V_SgFunctionSymbol:
292082 0 : case V_SgMemberFunctionSymbol:
292083 0 : {
292084 0 : SgFunctionSymbol* symbol = isSgFunctionSymbol(get_alias());
292085 0 : ROSE_ASSERT(symbol != NULL);
292086 0 : returnValue = symbol->get_declaration();
292087 0 : ROSE_ASSERT(returnValue != NULL);
292088 0 : break;
292089 : }
292090 :
292091 0 : case V_SgTemplateClassSymbol:
292092 0 : case V_SgClassSymbol:
292093 0 : {
292094 0 : SgClassSymbol* symbol = isSgClassSymbol(get_alias());
292095 0 : ROSE_ASSERT(symbol != NULL);
292096 0 : returnValue = symbol->get_declaration();
292097 0 : ROSE_ASSERT(returnValue != NULL);
292098 0 : break;
292099 : }
292100 :
292101 0 : case V_SgEnumSymbol:
292102 0 : {
292103 0 : SgEnumSymbol* symbol = isSgEnumSymbol(get_alias());
292104 0 : ROSE_ASSERT(symbol != NULL);
292105 0 : returnValue = symbol->get_declaration();
292106 0 : ROSE_ASSERT(returnValue != NULL);
292107 0 : break;
292108 : }
292109 :
292110 0 : case V_SgEnumFieldSymbol:
292111 0 : {
292112 0 : SgEnumFieldSymbol* symbol = isSgEnumFieldSymbol(get_alias());
292113 0 : ROSE_ASSERT(symbol != NULL);
292114 0 : SgInitializedName* initializedName = isSgInitializedName(symbol->get_declaration());
292115 0 : ROSE_ASSERT(initializedName != NULL);
292116 :
292117 : // DQ (5/20/2010): Call the SgInitializedName::get_declaration() function directly instead.
292118 : // SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(initializedName->get_parent());
292119 : // ROSE_ASSERT(variableDeclaration != NULL);
292120 : // returnValue = variableDeclaration;
292121 0 : returnValue = initializedName->get_declaration();
292122 :
292123 0 : ROSE_ASSERT(returnValue != NULL);
292124 0 : break;
292125 : }
292126 : #if 0
292127 : // I don't think we want to handle this case (at least not as part of alias support)!
292128 : case V_SgLabelSymbol:
292129 : {
292130 : SgLabelSymbol* symbol = isSgLabelSymbol(get_alias());
292131 : ROSE_ASSERT(symbol != NULL);
292132 : returnValue = symbol->get_declaration();
292133 : ROSE_ASSERT(returnValue != NULL);
292134 : break;
292135 : }
292136 : #endif
292137 0 : case V_SgTemplateSymbol:
292138 0 : {
292139 0 : SgTemplateSymbol* symbol = isSgTemplateSymbol(get_alias());
292140 0 : ROSE_ASSERT(symbol != NULL);
292141 0 : returnValue = symbol->get_declaration();
292142 0 : ROSE_ASSERT(returnValue != NULL);
292143 0 : break;
292144 : }
292145 :
292146 0 : case V_SgTypedefSymbol:
292147 0 : {
292148 0 : SgTypedefSymbol* symbol = isSgTypedefSymbol(get_alias());
292149 0 : ROSE_ASSERT(symbol != NULL);
292150 0 : returnValue = symbol->get_declaration();
292151 0 : ROSE_ASSERT(returnValue != NULL);
292152 0 : break;
292153 : }
292154 :
292155 0 : case V_SgAliasSymbol:
292156 0 : {
292157 0 : SgAliasSymbol* symbol = isSgAliasSymbol(get_alias());
292158 0 : ROSE_ASSERT(symbol != NULL);
292159 0 : returnValue = symbol->get_declaration();
292160 0 : ROSE_ASSERT(returnValue != NULL);
292161 0 : break;
292162 : }
292163 :
292164 0 : default:
292165 0 : {
292166 0 : printf ("Error: default reached in switch inside of SgAliasSymbol::get_declaration() get_alias() = %p = %s \n",get_alias(),get_alias()->class_name().c_str());
292167 0 : ROSE_ASSERT(false);
292168 : }
292169 : }
292170 :
292171 : #if 0
292172 : // DQ (1/21/2019): Adding debugging information.
292173 : printf ("In SgAliasSymbol::get_declaration(): returnValue = %p = %s \n",returnValue,(returnValue != NULL) ? returnValue->class_name().c_str() : "null");
292174 : #endif
292175 :
292176 0 : return returnValue;
292177 : }
292178 :
292179 9379 : SgAliasSymbol::SgAliasSymbol( const SgAliasSymbol & X )
292180 : {
292181 : // DQ (2/28/2015): Added copy constructor to make sure that the causal_nodes is preserved across copies (used in SgScopeStatement::insert_symbol() function).
292182 : // This is a fix for Tristan's use of the copy constructor in the SgScopeStatement::insert_symbol() function).
292183 :
292184 9379 : p_alias = X.p_alias;
292185 9379 : p_isRenamed = X.p_isRenamed;
292186 9379 : p_new_name = X.p_new_name;
292187 9379 : p_causal_nodes = X.p_causal_nodes;
292188 :
292189 : #if 0
292190 : // DQ (1/21/2019): Adding debugging information.
292191 : printf ("In SgAliasSymbol copy constructor: p_causal_nodes.size() = %zu X.p_causal_nodes = %zu \n",p_causal_nodes.size(),X.p_causal_nodes.size());
292192 : #endif
292193 9379 : }
292194 :
292195 : // DQ (2/28/2015): Add this function so that we can check and for alias of SgAliasSymbol.
292196 : void
292197 959597 : SgAliasSymbol::post_construction_initialization()
292198 : {
292199 959597 : ROSE_ASSERT(p_alias != NULL);
292200 959597 : SgAliasSymbol* aliasSymbol = isSgAliasSymbol(p_alias);
292201 959597 : if (aliasSymbol != NULL)
292202 : {
292203 : #if 0
292204 : // DQ (1/21/2019): Adding debugging information.
292205 : printf ("WARNING: SgAliasSymbol build from another SgAliasSymbol is not allowed! (automating fix) \n");
292206 : #endif
292207 0 : p_alias = aliasSymbol->get_alias();
292208 :
292209 0 : SgAliasSymbol* aliasSymbol_nextLevel = isSgAliasSymbol(p_alias);
292210 0 : if (aliasSymbol_nextLevel != NULL)
292211 : {
292212 0 : printf ("ERROR: SgAliasSymbol build from another SgAliasSymbol is not allowed! \n");
292213 0 : ROSE_ASSERT(false);
292214 : }
292215 : }
292216 959597 : }
292217 :
292218 :
292219 :
292220 : // End of memberFunctionString
292221 : // Start of memberFunctionString
292222 : /* #line 355 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Common.code" */
292223 :
292224 : // *** COMMON CODE SECTION BEGINS HERE ***
292225 :
292226 : #if 0
292227 : int
292228 : SgAliasSymbol::getVariant() const
292229 : {
292230 : // This function is used in ROSE while "variant()" is used in SAGE
292231 : assert(this != NULL);
292232 : return variant();
292233 : }
292234 : #endif
292235 :
292236 : // This function is used in ROSE in treeTraversal code
292237 : // eventually replaces getVariant() and variant()
292238 : // though after variant() has been removed for a while we will
292239 : // want to change the name of variantT() back to variant()
292240 : // (since the "T" was ment to stand for temporary).
292241 : // When this happens the variantT() will be depricated.
292242 : VariantT
292243 31602500 : SgAliasSymbol::variantT() const
292244 : {
292245 : // DQ (7/30/2014): Added assertion so that we can make sure we have a valid IR node.
292246 31602500 : ROSE_ASSERT(this != NULL);
292247 31602500 : return V_SgAliasSymbol;
292248 : }
292249 :
292250 : #if 0
292251 : int
292252 : SgAliasSymbol::variant() const
292253 : {
292254 : // This function is used in SAGE
292255 : ROSE_ASSERT(this != NULL);
292256 : return ALIAS_SYMBOL;
292257 : }
292258 : #endif
292259 :
292260 : ROSE_DLL_API const char*
292261 0 : SgAliasSymbol::sage_class_name() const
292262 : {
292263 0 : ROSE_ASSERT(this != NULL);
292264 0 : return "SgAliasSymbol";
292265 : }
292266 :
292267 : std::string
292268 879809 : SgAliasSymbol::class_name() const
292269 : {
292270 879809 : ROSE_ASSERT(this != NULL);
292271 879809 : return "SgAliasSymbol";
292272 : }
292273 :
292274 : // DQ (11/26/2005): Support for visitor pattern mechanims
292275 : // (inferior to ROSE traversal mechanism, experimental).
292276 : void
292277 2042220 : SgAliasSymbol::executeVisitorMemberFunction (ROSE_VisitorPattern & visitor)
292278 : {
292279 2042220 : ROSE_ASSERT(this != NULL);
292280 2042220 : visitor.visit(this);
292281 2042220 : }
292282 :
292283 : // DXN (08/09/2010): the classic, i.e. Gof, visitor pattern:
292284 0 : void SgAliasSymbol::accept (ROSE_VisitorPattern & visitor) {
292285 0 : ROSE_ASSERT(this != NULL);
292286 0 : visitor.visit(this);
292287 0 : }
292288 :
292289 : SgAliasSymbol*
292290 0 : SgAliasSymbol::addRegExpAttribute(std::string s, AstRegExAttribute* a)
292291 : {
292292 : #ifdef ROSE_ENABLE_BINARY_ANALYSIS
292293 : // This function is currently only supported for the AST used the represent Binary executables.
292294 : if (0 /* isSgAsmNode(this) != NULL */)
292295 : {
292296 : // Support for regex specification.
292297 : std::string prefixCode = "REGEX:";
292298 : addNewAttribute(prefixCode + s,a);
292299 : }
292300 : #endif
292301 :
292302 : /* Return "this" so that it can be used with the build function interface to add regex attributes. */
292303 0 : return this;
292304 : }
292305 :
292306 : // *** COMMON CODE SECTION ENDS HERE ***
292307 :
292308 :
292309 : // End of memberFunctionString
292310 : // Start of memberFunctionString
292311 : /* #line 2611 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/Node.code" */
292312 :
292313 :
292314 : #if 0
292315 : //! Error checking support
292316 : /*! Verifies the following:
292317 : - working getVariant() member function
292318 : - calls base class's error() member function
292319 : Every class has one of these functions.
292320 : */
292321 : bool
292322 : SgAliasSymbol::error()
292323 : {
292324 : // Put error checking here
292325 :
292326 : ROSE_ASSERT (this != NULL);
292327 : if (getVariant() != ALIAS_SYMBOL)
292328 : {
292329 : printf ("Error in SgAliasSymbol::error(): SgAliasSymbol object has a %s variant \n",
292330 : Cxx_GrammarTerminalNames[getVariant()].name);
292331 : // printf ("Error in SgAliasSymbol::error() \n");
292332 : ROSE_ABORT();
292333 : }
292334 :
292335 : ROSE_ASSERT (getVariant() == ALIAS_SYMBOL);
292336 : return SgSymbol::error();
292337 : }
292338 : #endif
292339 :
292340 :
292341 :
292342 : // End of memberFunctionString
292343 :
292344 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarIsClassNameFunctionDefinitionMacros.macro" */
292345 :
292346 25509800 : SgAliasSymbol* isSgAliasSymbol ( SgNode* inputDerivedClassPointer )
292347 : {
292348 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
292349 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
292350 : // So to fix this we return NULL directly when the input is NULL and avoid the
292351 : // dynamic_cast in this case. This is likely a performance improvement as well.
292352 : // return dynamic_cast<SgAliasSymbol*>(inputDerivedClassPointer);
292353 : // Milind Chabbi (8/28/2013): isSgAliasSymbol uses table-driven castability instead of c++ default dynamic_cast
292354 : // this improves the running time performance by 10-20%.
292355 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<SgAliasSymbol*>(inputDerivedClassPointer);
292356 25509800 : return IS_SgAliasSymbol_FAST_MACRO(inputDerivedClassPointer);
292357 : }
292358 :
292359 : // DQ (11/8/2003): Added version of functions taking const pointer
292360 2628 : const SgAliasSymbol* isSgAliasSymbol ( const SgNode* inputDerivedClassPointer )
292361 : {
292362 : // DQ (4/8/2011): This is an issure reported by Insure++ (READ_NULL).
292363 : // When inputDerivedClassPointer is NULL the cast is a read of the NULL pointer.
292364 : // So to fix this we return NULL directly when the input is NULL and avoid the
292365 : // dynamic_cast in this case. This is likely a performance improvement as well.
292366 : // return dynamic_cast<const SgAliasSymbol*>(inputDerivedClassPointer);
292367 : // Milind Chabbi (8/28/2013): isSgAliasSymbol uses table-driven castability instead of c++ default dynamic_cast
292368 : // this improves the running time performance by 10-20%.
292369 : //return (inputDerivedClassPointer == NULL) ? NULL : dynamic_cast<const SgAliasSymbol*>(inputDerivedClassPointer);
292370 2628 : return IS_SgAliasSymbol_FAST_MACRO(inputDerivedClassPointer);
292371 : }
292372 :
292373 :
292374 :
292375 : /* #line 292376 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
292376 :
292377 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
292378 :
292379 : /**
292380 : \brief Generated destructor
292381 :
292382 : This destructor is automatically generated (by ROSETTA). This destructor
292383 : only frees memory of data members associated with the parts of the current IR node which
292384 : are NOT traversed. Those data members that are part of a traversal can be freed using
292385 : a traversal (calling this destructor on all children in a post-order traversal). Such
292386 : a traversal which deletes a whole AST is provided by DeleteSgTree(SgNode*).
292387 :
292388 : \internal All IR nodes with data members specified using setDataPrototype() within ROSETTA
292389 : are specified as NO_DELETE is also specified as DEF_TRAVERSAL. Those marked as
292390 : NO_TRAVERSAL can be marked as NO_DELETE or DEF_DELETE.
292391 :
292392 : \note All SgSymbol IR nodes are deleted when the symbol table is deleted. Currently most
292393 : SgType IR nodes are not deleted (since they are shared). Also, all STL lists of
292394 : pointers are not yet implemented to call delete on eash pointer in the container.
292395 : (This could be done by derivation from the STL containers to define containers that
292396 : automatically deleted their members.)
292397 :
292398 : */
292399 79272 : SgAliasSymbol::~SgAliasSymbol () {
292400 34691 : if (p_freepointer == AST_FileIO::IS_VALID_POINTER()) {
292401 :
292402 :
292403 : // case: not a listType for alias
292404 34691 : p_alias = NULL; // non list case
292405 : // case: not a listType for isRenamed
292406 34691 : p_isRenamed = false; // non list case
292407 : // case: not a listType for new_name
292408 34691 : p_new_name = ""; // non list case
292409 :
292410 : }
292411 :
292412 : /* #line 24 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarDestructorDefinitionMacros.macro" */
292413 69382 : }
292414 :
292415 :
292416 : /* #line 292417 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
292417 :
292418 : /* #line 1 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
292419 :
292420 : // Generated constructor
292421 959597 : SgAliasSymbol::SgAliasSymbol ( SgSymbol* alias, bool isRenamed, SgName new_name )
292422 959597 : : SgSymbol()
292423 : {
292424 : #ifdef DEBUG
292425 : // printf ("In SgAliasSymbol::SgAliasSymbol (SgSymbol* alias, bool isRenamed, SgName new_name) sage_class_name() = %s \n",sage_class_name());
292426 : #endif
292427 : #if 0
292428 : // debugging information!
292429 : printf ("In SgAliasSymbol::SgAliasSymbol (SgSymbol* alias, bool isRenamed, SgName new_name): this = %p = %s \n",this,this->class_name().c_str());
292430 : #endif
292431 :
292432 959597 : p_alias = alias;
292433 959597 : p_isRenamed = isRenamed;
292434 959597 : p_new_name = new_name;
292435 :
292436 : /* #line 15 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarConstructorDefinitionMacros.macro" */
292437 :
292438 : #if 0
292439 : // DQ (7/30/2014): Call a virtual function.
292440 : std::string s = this->class_name();
292441 : #endif
292442 :
292443 : // Test the variant virtual function
292444 : // assert(ALIAS_SYMBOL == variant());
292445 959597 : assert(ALIAS_SYMBOL == this->variant());
292446 959597 : ROSE_ASSERT(ALIAS_SYMBOL == (int)(this->variantT()));
292447 959597 : post_construction_initialization();
292448 :
292449 : // Test the isSgAliasSymbol() function since it has been problematic
292450 959597 : assert(isSgAliasSymbol(this) != NULL);
292451 959597 : }
292452 :
292453 : // Generated constructor (all data members)
292454 :
292455 : /* #line 292456 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
292456 :
292457 :
292458 : /* #line 6 "/home/yyan7/compiler/rexompiler/src/ROSETTA/Grammar/grammarClassDefinitionMacros.macro" */
292459 :
292460 :
292461 : // ********************************************************
292462 : // member functions common across all array grammar objects
292463 : // ********************************************************
292464 :
292465 :
292466 :
292467 : /* #line 292468 "../../../src/frontend/SageIII//Cxx_Grammar.C" */
292468 :
292469 :
292470 0 : void outputSizeOfIntermediateRepresentation()
292471 : {
292472 0 : printf (" Size of AstAttributeMechanism = %lu \n",(unsigned long) sizeof(AstAttributeMechanism));
292473 0 : printf (" Size of SgName = %lu \n",(unsigned long) sizeof(SgName));
292474 0 : printf (" Size of SgSymbolTable = %lu \n",(unsigned long) sizeof(SgSymbolTable));
292475 0 : printf (" Size of SgPragma = %lu \n",(unsigned long) sizeof(SgPragma));
292476 0 : printf (" Size of SgModifierNodes = %lu \n",(unsigned long) sizeof(SgModifierNodes));
292477 0 : printf (" Size of SgConstVolatileModifier = %lu \n",(unsigned long) sizeof(SgConstVolatileModifier));
292478 0 : printf (" Size of SgStorageModifier = %lu \n",(unsigned long) sizeof(SgStorageModifier));
292479 0 : printf (" Size of SgAccessModifier = %lu \n",(unsigned long) sizeof(SgAccessModifier));
292480 0 : printf (" Size of SgFunctionModifier = %lu \n",(unsigned long) sizeof(SgFunctionModifier));
292481 0 : printf (" Size of SgUPC_AccessModifier = %lu \n",(unsigned long) sizeof(SgUPC_AccessModifier));
292482 0 : printf (" Size of SgLinkageModifier = %lu \n",(unsigned long) sizeof(SgLinkageModifier));
292483 0 : printf (" Size of SgSpecialFunctionModifier = %lu \n",(unsigned long) sizeof(SgSpecialFunctionModifier));
292484 0 : printf (" Size of SgTypeModifier = %lu \n",(unsigned long) sizeof(SgTypeModifier));
292485 0 : printf (" Size of SgElaboratedTypeModifier = %lu \n",(unsigned long) sizeof(SgElaboratedTypeModifier));
292486 0 : printf (" Size of SgBaseClassModifier = %lu \n",(unsigned long) sizeof(SgBaseClassModifier));
292487 0 : printf (" Size of SgDeclarationModifier = %lu \n",(unsigned long) sizeof(SgDeclarationModifier));
292488 0 : printf (" Size of SgStructureModifier = %lu \n",(unsigned long) sizeof(SgStructureModifier));
292489 0 : printf (" Size of SgOpenclAccessModeModifier = %lu \n",(unsigned long) sizeof(SgOpenclAccessModeModifier));
292490 0 : printf (" Size of SgModifier = %lu \n",(unsigned long) sizeof(SgModifier));
292491 0 : printf (" Size of Sg_File_Info = %lu \n",(unsigned long) sizeof(Sg_File_Info));
292492 0 : printf (" Size of SgSourceFile = %lu \n",(unsigned long) sizeof(SgSourceFile));
292493 0 : printf (" Size of SgUnknownFile = %lu \n",(unsigned long) sizeof(SgUnknownFile));
292494 0 : printf (" Size of SgFile = %lu \n",(unsigned long) sizeof(SgFile));
292495 0 : printf (" Size of SgFileList = %lu \n",(unsigned long) sizeof(SgFileList));
292496 0 : printf (" Size of SgDirectory = %lu \n",(unsigned long) sizeof(SgDirectory));
292497 0 : printf (" Size of SgDirectoryList = %lu \n",(unsigned long) sizeof(SgDirectoryList));
292498 0 : printf (" Size of SgProject = %lu \n",(unsigned long) sizeof(SgProject));
292499 0 : printf (" Size of SgOptions = %lu \n",(unsigned long) sizeof(SgOptions));
292500 0 : printf (" Size of SgUnparse_Info = %lu \n",(unsigned long) sizeof(SgUnparse_Info));
292501 0 : printf (" Size of SgIncludeFile = %lu \n",(unsigned long) sizeof(SgIncludeFile));
292502 0 : printf (" Size of SgFuncDecl_attr = %lu \n",(unsigned long) sizeof(SgFuncDecl_attr));
292503 0 : printf (" Size of SgClassDecl_attr = %lu \n",(unsigned long) sizeof(SgClassDecl_attr));
292504 0 : printf (" Size of SgTypedefSeq = %lu \n",(unsigned long) sizeof(SgTypedefSeq));
292505 0 : printf (" Size of SgFunctionParameterTypeList = %lu \n",(unsigned long) sizeof(SgFunctionParameterTypeList));
292506 0 : printf (" Size of SgTemplateParameter = %lu \n",(unsigned long) sizeof(SgTemplateParameter));
292507 0 : printf (" Size of SgTemplateArgument = %lu \n",(unsigned long) sizeof(SgTemplateArgument));
292508 0 : printf (" Size of SgTemplateParameterList = %lu \n",(unsigned long) sizeof(SgTemplateParameterList));
292509 0 : printf (" Size of SgTemplateArgumentList = %lu \n",(unsigned long) sizeof(SgTemplateArgumentList));
292510 0 : printf (" Size of SgBitAttribute = %lu \n",(unsigned long) sizeof(SgBitAttribute));
292511 0 : printf (" Size of SgAttribute = %lu \n",(unsigned long) sizeof(SgAttribute));
292512 0 : printf (" Size of SgExpBaseClass = %lu \n",(unsigned long) sizeof(SgExpBaseClass));
292513 0 : printf (" Size of SgNonrealBaseClass = %lu \n",(unsigned long) sizeof(SgNonrealBaseClass));
292514 0 : printf (" Size of SgBaseClass = %lu \n",(unsigned long) sizeof(SgBaseClass));
292515 0 : printf (" Size of SgUndirectedGraphEdge = %lu \n",(unsigned long) sizeof(SgUndirectedGraphEdge));
292516 0 : printf (" Size of SgDirectedGraphEdge = %lu \n",(unsigned long) sizeof(SgDirectedGraphEdge));
292517 0 : printf (" Size of SgGraphNode = %lu \n",(unsigned long) sizeof(SgGraphNode));
292518 0 : printf (" Size of SgGraphEdge = %lu \n",(unsigned long) sizeof(SgGraphEdge));
292519 0 : printf (" Size of SgStringKeyedBidirectionalGraph = %lu \n",(unsigned long) sizeof(SgStringKeyedBidirectionalGraph));
292520 0 : printf (" Size of SgIntKeyedBidirectionalGraph = %lu \n",(unsigned long) sizeof(SgIntKeyedBidirectionalGraph));
292521 0 : printf (" Size of SgBidirectionalGraph = %lu \n",(unsigned long) sizeof(SgBidirectionalGraph));
292522 0 : printf (" Size of SgIncidenceDirectedGraph = %lu \n",(unsigned long) sizeof(SgIncidenceDirectedGraph));
292523 0 : printf (" Size of SgIncidenceUndirectedGraph = %lu \n",(unsigned long) sizeof(SgIncidenceUndirectedGraph));
292524 0 : printf (" Size of SgGraph = %lu \n",(unsigned long) sizeof(SgGraph));
292525 0 : printf (" Size of SgGraphNodeList = %lu \n",(unsigned long) sizeof(SgGraphNodeList));
292526 0 : printf (" Size of SgGraphEdgeList = %lu \n",(unsigned long) sizeof(SgGraphEdgeList));
292527 0 : printf (" Size of SgQualifiedName = %lu \n",(unsigned long) sizeof(SgQualifiedName));
292528 0 : printf (" Size of SgNameGroup = %lu \n",(unsigned long) sizeof(SgNameGroup));
292529 0 : printf (" Size of SgDimensionObject = %lu \n",(unsigned long) sizeof(SgDimensionObject));
292530 0 : printf (" Size of SgDataStatementGroup = %lu \n",(unsigned long) sizeof(SgDataStatementGroup));
292531 0 : printf (" Size of SgDataStatementObject = %lu \n",(unsigned long) sizeof(SgDataStatementObject));
292532 0 : printf (" Size of SgDataStatementValue = %lu \n",(unsigned long) sizeof(SgDataStatementValue));
292533 0 : printf (" Size of SgFormatItem = %lu \n",(unsigned long) sizeof(SgFormatItem));
292534 0 : printf (" Size of SgFormatItemList = %lu \n",(unsigned long) sizeof(SgFormatItemList));
292535 0 : printf (" Size of SgTypeTable = %lu \n",(unsigned long) sizeof(SgTypeTable));
292536 0 : printf (" Size of SgHeaderFileReport = %lu \n",(unsigned long) sizeof(SgHeaderFileReport));
292537 0 : printf (" Size of SgSupport = %lu \n",(unsigned long) sizeof(SgSupport));
292538 0 : printf (" Size of SgTypeUnknown = %lu \n",(unsigned long) sizeof(SgTypeUnknown));
292539 0 : printf (" Size of SgTypeChar = %lu \n",(unsigned long) sizeof(SgTypeChar));
292540 0 : printf (" Size of SgTypeSignedChar = %lu \n",(unsigned long) sizeof(SgTypeSignedChar));
292541 0 : printf (" Size of SgTypeUnsignedChar = %lu \n",(unsigned long) sizeof(SgTypeUnsignedChar));
292542 0 : printf (" Size of SgTypeShort = %lu \n",(unsigned long) sizeof(SgTypeShort));
292543 0 : printf (" Size of SgTypeSignedShort = %lu \n",(unsigned long) sizeof(SgTypeSignedShort));
292544 0 : printf (" Size of SgTypeUnsignedShort = %lu \n",(unsigned long) sizeof(SgTypeUnsignedShort));
292545 0 : printf (" Size of SgTypeInt = %lu \n",(unsigned long) sizeof(SgTypeInt));
292546 0 : printf (" Size of SgTypeSignedInt = %lu \n",(unsigned long) sizeof(SgTypeSignedInt));
292547 0 : printf (" Size of SgTypeUnsignedInt = %lu \n",(unsigned long) sizeof(SgTypeUnsignedInt));
292548 0 : printf (" Size of SgTypeLong = %lu \n",(unsigned long) sizeof(SgTypeLong));
292549 0 : printf (" Size of SgTypeSignedLong = %lu \n",(unsigned long) sizeof(SgTypeSignedLong));
292550 0 : printf (" Size of SgTypeUnsignedLong = %lu \n",(unsigned long) sizeof(SgTypeUnsignedLong));
292551 0 : printf (" Size of SgTypeVoid = %lu \n",(unsigned long) sizeof(SgTypeVoid));
292552 0 : printf (" Size of SgTypeGlobalVoid = %lu \n",(unsigned long) sizeof(SgTypeGlobalVoid));
292553 0 : printf (" Size of SgTypeWchar = %lu \n",(unsigned long) sizeof(SgTypeWchar));
292554 0 : printf (" Size of SgTypeFloat = %lu \n",(unsigned long) sizeof(SgTypeFloat));
292555 0 : printf (" Size of SgTypeDouble = %lu \n",(unsigned long) sizeof(SgTypeDouble));
292556 0 : printf (" Size of SgTypeLongLong = %lu \n",(unsigned long) sizeof(SgTypeLongLong));
292557 0 : printf (" Size of SgTypeSignedLongLong = %lu \n",(unsigned long) sizeof(SgTypeSignedLongLong));
292558 0 : printf (" Size of SgTypeUnsignedLongLong = %lu \n",(unsigned long) sizeof(SgTypeUnsignedLongLong));
292559 0 : printf (" Size of SgTypeLongDouble = %lu \n",(unsigned long) sizeof(SgTypeLongDouble));
292560 0 : printf (" Size of SgTypeFloat80 = %lu \n",(unsigned long) sizeof(SgTypeFloat80));
292561 0 : printf (" Size of SgTypeFloat128 = %lu \n",(unsigned long) sizeof(SgTypeFloat128));
292562 0 : printf (" Size of SgTypeString = %lu \n",(unsigned long) sizeof(SgTypeString));
292563 0 : printf (" Size of SgTypeBool = %lu \n",(unsigned long) sizeof(SgTypeBool));
292564 0 : printf (" Size of SgTypeFixed = %lu \n",(unsigned long) sizeof(SgTypeFixed));
292565 0 : printf (" Size of SgTypeMatrix = %lu \n",(unsigned long) sizeof(SgTypeMatrix));
292566 0 : printf (" Size of SgTypeTuple = %lu \n",(unsigned long) sizeof(SgTypeTuple));
292567 0 : printf (" Size of SgTypeNullptr = %lu \n",(unsigned long) sizeof(SgTypeNullptr));
292568 0 : printf (" Size of SgTypeComplex = %lu \n",(unsigned long) sizeof(SgTypeComplex));
292569 0 : printf (" Size of SgTypeImaginary = %lu \n",(unsigned long) sizeof(SgTypeImaginary));
292570 0 : printf (" Size of SgTypeDefault = %lu \n",(unsigned long) sizeof(SgTypeDefault));
292571 0 : printf (" Size of SgPointerMemberType = %lu \n",(unsigned long) sizeof(SgPointerMemberType));
292572 0 : printf (" Size of SgReferenceType = %lu \n",(unsigned long) sizeof(SgReferenceType));
292573 0 : printf (" Size of SgRvalueReferenceType = %lu \n",(unsigned long) sizeof(SgRvalueReferenceType));
292574 0 : printf (" Size of SgDeclType = %lu \n",(unsigned long) sizeof(SgDeclType));
292575 0 : printf (" Size of SgTypeOfType = %lu \n",(unsigned long) sizeof(SgTypeOfType));
292576 0 : printf (" Size of SgTypeCAFTeam = %lu \n",(unsigned long) sizeof(SgTypeCAFTeam));
292577 0 : printf (" Size of SgTypeUnsigned128bitInteger = %lu \n",(unsigned long) sizeof(SgTypeUnsigned128bitInteger));
292578 0 : printf (" Size of SgTypeSigned128bitInteger = %lu \n",(unsigned long) sizeof(SgTypeSigned128bitInteger));
292579 0 : printf (" Size of SgTypeLabel = %lu \n",(unsigned long) sizeof(SgTypeLabel));
292580 0 : printf (" Size of SgTemplateType = %lu \n",(unsigned long) sizeof(SgTemplateType));
292581 0 : printf (" Size of SgEnumType = %lu \n",(unsigned long) sizeof(SgEnumType));
292582 0 : printf (" Size of SgTypedefType = %lu \n",(unsigned long) sizeof(SgTypedefType));
292583 0 : printf (" Size of SgNonrealType = %lu \n",(unsigned long) sizeof(SgNonrealType));
292584 0 : printf (" Size of SgAutoType = %lu \n",(unsigned long) sizeof(SgAutoType));
292585 0 : printf (" Size of SgModifierType = %lu \n",(unsigned long) sizeof(SgModifierType));
292586 0 : printf (" Size of SgPartialFunctionModifierType = %lu \n",(unsigned long) sizeof(SgPartialFunctionModifierType));
292587 0 : printf (" Size of SgArrayType = %lu \n",(unsigned long) sizeof(SgArrayType));
292588 0 : printf (" Size of SgTypeEllipse = %lu \n",(unsigned long) sizeof(SgTypeEllipse));
292589 0 : printf (" Size of SgTypeCrayPointer = %lu \n",(unsigned long) sizeof(SgTypeCrayPointer));
292590 0 : printf (" Size of SgPartialFunctionType = %lu \n",(unsigned long) sizeof(SgPartialFunctionType));
292591 0 : printf (" Size of SgMemberFunctionType = %lu \n",(unsigned long) sizeof(SgMemberFunctionType));
292592 0 : printf (" Size of SgFunctionType = %lu \n",(unsigned long) sizeof(SgFunctionType));
292593 0 : printf (" Size of SgPointerType = %lu \n",(unsigned long) sizeof(SgPointerType));
292594 0 : printf (" Size of SgClassType = %lu \n",(unsigned long) sizeof(SgClassType));
292595 0 : printf (" Size of SgNamedType = %lu \n",(unsigned long) sizeof(SgNamedType));
292596 0 : printf (" Size of SgQualifiedNameType = %lu \n",(unsigned long) sizeof(SgQualifiedNameType));
292597 0 : printf (" Size of SgTypeChar16 = %lu \n",(unsigned long) sizeof(SgTypeChar16));
292598 0 : printf (" Size of SgTypeChar32 = %lu \n",(unsigned long) sizeof(SgTypeChar32));
292599 0 : printf (" Size of SgType = %lu \n",(unsigned long) sizeof(SgType));
292600 0 : printf (" Size of SgForStatement = %lu \n",(unsigned long) sizeof(SgForStatement));
292601 0 : printf (" Size of SgForInitStatement = %lu \n",(unsigned long) sizeof(SgForInitStatement));
292602 0 : printf (" Size of SgRangeBasedForStatement = %lu \n",(unsigned long) sizeof(SgRangeBasedForStatement));
292603 0 : printf (" Size of SgCatchStatementSeq = %lu \n",(unsigned long) sizeof(SgCatchStatementSeq));
292604 0 : printf (" Size of SgFunctionParameterList = %lu \n",(unsigned long) sizeof(SgFunctionParameterList));
292605 0 : printf (" Size of SgCtorInitializerList = %lu \n",(unsigned long) sizeof(SgCtorInitializerList));
292606 0 : printf (" Size of SgBasicBlock = %lu \n",(unsigned long) sizeof(SgBasicBlock));
292607 0 : printf (" Size of SgGlobal = %lu \n",(unsigned long) sizeof(SgGlobal));
292608 0 : printf (" Size of SgIfStmt = %lu \n",(unsigned long) sizeof(SgIfStmt));
292609 0 : printf (" Size of SgWhileStmt = %lu \n",(unsigned long) sizeof(SgWhileStmt));
292610 0 : printf (" Size of SgDoWhileStmt = %lu \n",(unsigned long) sizeof(SgDoWhileStmt));
292611 0 : printf (" Size of SgSwitchStatement = %lu \n",(unsigned long) sizeof(SgSwitchStatement));
292612 0 : printf (" Size of SgCatchOptionStmt = %lu \n",(unsigned long) sizeof(SgCatchOptionStmt));
292613 0 : printf (" Size of SgFunctionParameterScope = %lu \n",(unsigned long) sizeof(SgFunctionParameterScope));
292614 0 : printf (" Size of SgDeclarationScope = %lu \n",(unsigned long) sizeof(SgDeclarationScope));
292615 0 : printf (" Size of SgVariableDefinition = %lu \n",(unsigned long) sizeof(SgVariableDefinition));
292616 0 : printf (" Size of SgStmtDeclarationStatement = %lu \n",(unsigned long) sizeof(SgStmtDeclarationStatement));
292617 0 : printf (" Size of SgEnumDeclaration = %lu \n",(unsigned long) sizeof(SgEnumDeclaration));
292618 0 : printf (" Size of SgAsmStmt = %lu \n",(unsigned long) sizeof(SgAsmStmt));
292619 0 : printf (" Size of SgFunctionTypeTable = %lu \n",(unsigned long) sizeof(SgFunctionTypeTable));
292620 0 : printf (" Size of SgExprStatement = %lu \n",(unsigned long) sizeof(SgExprStatement));
292621 0 : printf (" Size of SgLabelStatement = %lu \n",(unsigned long) sizeof(SgLabelStatement));
292622 0 : printf (" Size of SgCaseOptionStmt = %lu \n",(unsigned long) sizeof(SgCaseOptionStmt));
292623 0 : printf (" Size of SgTryStmt = %lu \n",(unsigned long) sizeof(SgTryStmt));
292624 0 : printf (" Size of SgDefaultOptionStmt = %lu \n",(unsigned long) sizeof(SgDefaultOptionStmt));
292625 0 : printf (" Size of SgBreakStmt = %lu \n",(unsigned long) sizeof(SgBreakStmt));
292626 0 : printf (" Size of SgContinueStmt = %lu \n",(unsigned long) sizeof(SgContinueStmt));
292627 0 : printf (" Size of SgReturnStmt = %lu \n",(unsigned long) sizeof(SgReturnStmt));
292628 0 : printf (" Size of SgGotoStatement = %lu \n",(unsigned long) sizeof(SgGotoStatement));
292629 0 : printf (" Size of SgSpawnStmt = %lu \n",(unsigned long) sizeof(SgSpawnStmt));
292630 0 : printf (" Size of SgTemplateTypedefDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateTypedefDeclaration));
292631 0 : printf (" Size of SgTemplateInstantiationTypedefDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateInstantiationTypedefDeclaration));
292632 0 : printf (" Size of SgTypedefDeclaration = %lu \n",(unsigned long) sizeof(SgTypedefDeclaration));
292633 0 : printf (" Size of SgNullStatement = %lu \n",(unsigned long) sizeof(SgNullStatement));
292634 0 : printf (" Size of SgVariantStatement = %lu \n",(unsigned long) sizeof(SgVariantStatement));
292635 0 : printf (" Size of SgPragmaDeclaration = %lu \n",(unsigned long) sizeof(SgPragmaDeclaration));
292636 0 : printf (" Size of SgTemplateClassDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateClassDeclaration));
292637 0 : printf (" Size of SgTemplateMemberFunctionDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateMemberFunctionDeclaration));
292638 0 : printf (" Size of SgTemplateFunctionDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateFunctionDeclaration));
292639 0 : printf (" Size of SgTemplateVariableDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateVariableDeclaration));
292640 0 : printf (" Size of SgTemplateDeclaration = %lu \n",(unsigned long) sizeof(SgTemplateDeclaration));
292641 0 : printf (" Size of SgVariableDeclaration = %lu \n",(unsigned long) sizeof(SgVariableDeclaration));
292642 0 : printf (" Size of SgTemplateInstantiationDecl = %lu \n",(unsigned long) sizeof(SgTemplateInstantiationDecl));
292643 0 : printf (" Size of SgTemplateInstantiationDefn = %lu \n",(unsigned long) sizeof(SgTemplateInstantiationDefn));
292644 0 : printf (" Size of SgTemplateInstantiationFunctionDecl = %lu \n",(unsigned long) sizeof(SgTemplateInstantiationFunctionDecl));
292645 0 : printf (" Size of SgTemplateInstantiationMemberFunctionDecl = %lu \n",(unsigned long) sizeof(SgTemplateInstantiationMemberFunctionDecl));
292646 0 : printf (" Size of SgNonrealDecl = %lu \n",(unsigned long) sizeof(SgNonrealDecl));
292647 0 : printf (" Size of SgWithStatement = %lu \n",(unsigned long) sizeof(SgWithStatement));
292648 0 : printf (" Size of SgPassStatement = %lu \n",(unsigned long) sizeof(SgPassStatement));
292649 0 : printf (" Size of SgAssertStmt = %lu \n",(unsigned long) sizeof(SgAssertStmt));
292650 0 : printf (" Size of SgExecStatement = %lu \n",(unsigned long) sizeof(SgExecStatement));
292651 0 : printf (" Size of SgProgramHeaderStatement = %lu \n",(unsigned long) sizeof(SgProgramHeaderStatement));
292652 0 : printf (" Size of SgProcedureHeaderStatement = %lu \n",(unsigned long) sizeof(SgProcedureHeaderStatement));
292653 0 : printf (" Size of SgEntryStatement = %lu \n",(unsigned long) sizeof(SgEntryStatement));
292654 0 : printf (" Size of SgFortranNonblockedDo = %lu \n",(unsigned long) sizeof(SgFortranNonblockedDo));
292655 0 : printf (" Size of SgInterfaceStatement = %lu \n",(unsigned long) sizeof(SgInterfaceStatement));
292656 0 : printf (" Size of SgParameterStatement = %lu \n",(unsigned long) sizeof(SgParameterStatement));
292657 0 : printf (" Size of SgCommonBlock = %lu \n",(unsigned long) sizeof(SgCommonBlock));
292658 0 : printf (" Size of SgModuleStatement = %lu \n",(unsigned long) sizeof(SgModuleStatement));
292659 0 : printf (" Size of SgUseStatement = %lu \n",(unsigned long) sizeof(SgUseStatement));
292660 0 : printf (" Size of SgProcessControlStatement = %lu \n",(unsigned long) sizeof(SgProcessControlStatement));
292661 0 : printf (" Size of SgPrintStatement = %lu \n",(unsigned long) sizeof(SgPrintStatement));
292662 0 : printf (" Size of SgReadStatement = %lu \n",(unsigned long) sizeof(SgReadStatement));
292663 0 : printf (" Size of SgWriteStatement = %lu \n",(unsigned long) sizeof(SgWriteStatement));
292664 0 : printf (" Size of SgOpenStatement = %lu \n",(unsigned long) sizeof(SgOpenStatement));
292665 0 : printf (" Size of SgCloseStatement = %lu \n",(unsigned long) sizeof(SgCloseStatement));
292666 0 : printf (" Size of SgInquireStatement = %lu \n",(unsigned long) sizeof(SgInquireStatement));
292667 0 : printf (" Size of SgFlushStatement = %lu \n",(unsigned long) sizeof(SgFlushStatement));
292668 0 : printf (" Size of SgBackspaceStatement = %lu \n",(unsigned long) sizeof(SgBackspaceStatement));
292669 0 : printf (" Size of SgRewindStatement = %lu \n",(unsigned long) sizeof(SgRewindStatement));
292670 0 : printf (" Size of SgEndfileStatement = %lu \n",(unsigned long) sizeof(SgEndfileStatement));
292671 0 : printf (" Size of SgWaitStatement = %lu \n",(unsigned long) sizeof(SgWaitStatement));
292672 0 : printf (" Size of SgCAFWithTeamStatement = %lu \n",(unsigned long) sizeof(SgCAFWithTeamStatement));
292673 0 : printf (" Size of SgFormatStatement = %lu \n",(unsigned long) sizeof(SgFormatStatement));
292674 0 : printf (" Size of SgFortranDo = %lu \n",(unsigned long) sizeof(SgFortranDo));
292675 0 : printf (" Size of SgForAllStatement = %lu \n",(unsigned long) sizeof(SgForAllStatement));
292676 0 : printf (" Size of SgIOStatement = %lu \n",(unsigned long) sizeof(SgIOStatement));
292677 0 : printf (" Size of SgSyncAllStatement = %lu \n",(unsigned long) sizeof(SgSyncAllStatement));
292678 0 : printf (" Size of SgSyncImagesStatement = %lu \n",(unsigned long) sizeof(SgSyncImagesStatement));
292679 0 : printf (" Size of SgSyncMemoryStatement = %lu \n",(unsigned long) sizeof(SgSyncMemoryStatement));
292680 0 : printf (" Size of SgSyncTeamStatement = %lu \n",(unsigned long) sizeof(SgSyncTeamStatement));
292681 0 : printf (" Size of SgLockStatement = %lu \n",(unsigned long) sizeof(SgLockStatement));
292682 0 : printf (" Size of SgUnlockStatement = %lu \n",(unsigned long) sizeof(SgUnlockStatement));
292683 0 : printf (" Size of SgImageControlStatement = %lu \n",(unsigned long) sizeof(SgImageControlStatement));
292684 0 : printf (" Size of SgUpcNotifyStatement = %lu \n",(unsigned long) sizeof(SgUpcNotifyStatement));
292685 0 : printf (" Size of SgUpcWaitStatement = %lu \n",(unsigned long) sizeof(SgUpcWaitStatement));
292686 0 : printf (" Size of SgUpcBarrierStatement = %lu \n",(unsigned long) sizeof(SgUpcBarrierStatement));
292687 0 : printf (" Size of SgUpcFenceStatement = %lu \n",(unsigned long) sizeof(SgUpcFenceStatement));
292688 0 : printf (" Size of SgUpcForAllStatement = %lu \n",(unsigned long) sizeof(SgUpcForAllStatement));
292689 0 : printf (" Size of SgUpirSpmdStatement = %lu \n",(unsigned long) sizeof(SgUpirSpmdStatement));
292690 0 : printf (" Size of SgOmpLoopStatement = %lu \n",(unsigned long) sizeof(SgOmpLoopStatement));
292691 0 : printf (" Size of SgOmpScanStatement = %lu \n",(unsigned long) sizeof(SgOmpScanStatement));
292692 0 : printf (" Size of SgOmpTaskloopStatement = %lu \n",(unsigned long) sizeof(SgOmpTaskloopStatement));
292693 0 : printf (" Size of SgOmpTaskgroupStatement = %lu \n",(unsigned long) sizeof(SgOmpTaskgroupStatement));
292694 0 : printf (" Size of SgOmpDepobjStatement = %lu \n",(unsigned long) sizeof(SgOmpDepobjStatement));
292695 0 : printf (" Size of SgOmpTeamsStatement = %lu \n",(unsigned long) sizeof(SgOmpTeamsStatement));
292696 0 : printf (" Size of SgOmpCancellationPointStatement = %lu \n",(unsigned long) sizeof(SgOmpCancellationPointStatement));
292697 0 : printf (" Size of SgOmpDeclareMapperStatement = %lu \n",(unsigned long) sizeof(SgOmpDeclareMapperStatement));
292698 0 : printf (" Size of SgOmpCancelStatement = %lu \n",(unsigned long) sizeof(SgOmpCancelStatement));
292699 0 : printf (" Size of SgOmpDistributeStatement = %lu \n",(unsigned long) sizeof(SgOmpDistributeStatement));
292700 0 : printf (" Size of SgOmpMetadirectiveStatement = %lu \n",(unsigned long) sizeof(SgOmpMetadirectiveStatement));
292701 0 : printf (" Size of SgOmpSingleStatement = %lu \n",(unsigned long) sizeof(SgOmpSingleStatement));
292702 0 : printf (" Size of SgOmpTaskStatement = %lu \n",(unsigned long) sizeof(SgOmpTaskStatement));
292703 0 : printf (" Size of SgOmpTargetEnterDataStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetEnterDataStatement));
292704 0 : printf (" Size of SgOmpTargetExitDataStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetExitDataStatement));
292705 0 : printf (" Size of SgUpirWorksharingStatement = %lu \n",(unsigned long) sizeof(SgUpirWorksharingStatement));
292706 0 : printf (" Size of SgOmpForSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpForSimdStatement));
292707 0 : printf (" Size of SgOmpDoStatement = %lu \n",(unsigned long) sizeof(SgOmpDoStatement));
292708 0 : printf (" Size of SgOmpSectionsStatement = %lu \n",(unsigned long) sizeof(SgOmpSectionsStatement));
292709 0 : printf (" Size of SgOmpAtomicStatement = %lu \n",(unsigned long) sizeof(SgOmpAtomicStatement));
292710 0 : printf (" Size of SgUpirTaskStatement = %lu \n",(unsigned long) sizeof(SgUpirTaskStatement));
292711 0 : printf (" Size of SgOmpTargetDataStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetDataStatement));
292712 0 : printf (" Size of SgOmpTargetParallelForStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetParallelForStatement));
292713 0 : printf (" Size of SgOmpTargetParallelStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetParallelStatement));
292714 0 : printf (" Size of SgOmpDistributeSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpDistributeSimdStatement));
292715 0 : printf (" Size of SgOmpDistributeParallelForStatement = %lu \n",(unsigned long) sizeof(SgOmpDistributeParallelForStatement));
292716 0 : printf (" Size of SgOmpDistributeParallelForSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpDistributeParallelForSimdStatement));
292717 0 : printf (" Size of SgOmpTaskloopSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTaskloopSimdStatement));
292718 0 : printf (" Size of SgOmpTargetUpdateStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetUpdateStatement));
292719 0 : printf (" Size of SgOmpTargetParallelForSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetParallelForSimdStatement));
292720 0 : printf (" Size of SgOmpTargetParallelLoopStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetParallelLoopStatement));
292721 0 : printf (" Size of SgOmpTargetSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetSimdStatement));
292722 0 : printf (" Size of SgOmpTargetTeamsStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetTeamsStatement));
292723 0 : printf (" Size of SgOmpTargetTeamsDistributeStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetTeamsDistributeStatement));
292724 0 : printf (" Size of SgOmpTargetTeamsDistributeSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetTeamsDistributeSimdStatement));
292725 0 : printf (" Size of SgOmpTargetTeamsLoopStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetTeamsLoopStatement));
292726 0 : printf (" Size of SgOmpTargetTeamsDistributeParallelForStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetTeamsDistributeParallelForStatement));
292727 0 : printf (" Size of SgOmpTargetTeamsDistributeParallelForSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTargetTeamsDistributeParallelForSimdStatement));
292728 0 : printf (" Size of SgOmpMasterTaskloopSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpMasterTaskloopSimdStatement));
292729 0 : printf (" Size of SgOmpParallelMasterTaskloopStatement = %lu \n",(unsigned long) sizeof(SgOmpParallelMasterTaskloopStatement));
292730 0 : printf (" Size of SgOmpParallelMasterTaskloopSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpParallelMasterTaskloopSimdStatement));
292731 0 : printf (" Size of SgOmpTeamsDistributeStatement = %lu \n",(unsigned long) sizeof(SgOmpTeamsDistributeStatement));
292732 0 : printf (" Size of SgOmpTeamsDistributeSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTeamsDistributeSimdStatement));
292733 0 : printf (" Size of SgOmpTeamsDistributeParallelForStatement = %lu \n",(unsigned long) sizeof(SgOmpTeamsDistributeParallelForStatement));
292734 0 : printf (" Size of SgOmpTeamsDistributeParallelForSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpTeamsDistributeParallelForSimdStatement));
292735 0 : printf (" Size of SgOmpTeamsLoopStatement = %lu \n",(unsigned long) sizeof(SgOmpTeamsLoopStatement));
292736 0 : printf (" Size of SgOmpParallelMasterStatement = %lu \n",(unsigned long) sizeof(SgOmpParallelMasterStatement));
292737 0 : printf (" Size of SgOmpMasterTaskloopStatement = %lu \n",(unsigned long) sizeof(SgOmpMasterTaskloopStatement));
292738 0 : printf (" Size of SgOmpParallelLoopStatement = %lu \n",(unsigned long) sizeof(SgOmpParallelLoopStatement));
292739 0 : printf (" Size of SgOmpUnrollStatement = %lu \n",(unsigned long) sizeof(SgOmpUnrollStatement));
292740 0 : printf (" Size of SgOmpTileStatement = %lu \n",(unsigned long) sizeof(SgOmpTileStatement));
292741 0 : printf (" Size of SgUpirSimdStatement = %lu \n",(unsigned long) sizeof(SgUpirSimdStatement));
292742 0 : printf (" Size of SgOmpCriticalStatement = %lu \n",(unsigned long) sizeof(SgOmpCriticalStatement));
292743 0 : printf (" Size of SgOmpOrderedStatement = %lu \n",(unsigned long) sizeof(SgOmpOrderedStatement));
292744 0 : printf (" Size of SgUpirLoopStatement = %lu \n",(unsigned long) sizeof(SgUpirLoopStatement));
292745 0 : printf (" Size of SgUpirLoopParallelStatement = %lu \n",(unsigned long) sizeof(SgUpirLoopParallelStatement));
292746 0 : printf (" Size of SgUpirSyncStatement = %lu \n",(unsigned long) sizeof(SgUpirSyncStatement));
292747 0 : printf (" Size of SgUpirFieldBodyStatement = %lu \n",(unsigned long) sizeof(SgUpirFieldBodyStatement));
292748 0 : printf (" Size of SgOmpMasterStatement = %lu \n",(unsigned long) sizeof(SgOmpMasterStatement));
292749 0 : printf (" Size of SgOmpSectionStatement = %lu \n",(unsigned long) sizeof(SgOmpSectionStatement));
292750 0 : printf (" Size of SgOmpWorkshareStatement = %lu \n",(unsigned long) sizeof(SgOmpWorkshareStatement));
292751 0 : printf (" Size of SgOmpFlushStatement = %lu \n",(unsigned long) sizeof(SgOmpFlushStatement));
292752 0 : printf (" Size of SgOmpAllocateStatement = %lu \n",(unsigned long) sizeof(SgOmpAllocateStatement));
292753 0 : printf (" Size of SgOmpOrderedDependStatement = %lu \n",(unsigned long) sizeof(SgOmpOrderedDependStatement));
292754 0 : printf (" Size of SgUpirBodyStatement = %lu \n",(unsigned long) sizeof(SgUpirBodyStatement));
292755 0 : printf (" Size of SgUpirFieldStatement = %lu \n",(unsigned long) sizeof(SgUpirFieldStatement));
292756 0 : printf (" Size of SgBlockDataStatement = %lu \n",(unsigned long) sizeof(SgBlockDataStatement));
292757 0 : printf (" Size of SgImplicitStatement = %lu \n",(unsigned long) sizeof(SgImplicitStatement));
292758 0 : printf (" Size of SgStatementFunctionStatement = %lu \n",(unsigned long) sizeof(SgStatementFunctionStatement));
292759 0 : printf (" Size of SgWhereStatement = %lu \n",(unsigned long) sizeof(SgWhereStatement));
292760 0 : printf (" Size of SgNullifyStatement = %lu \n",(unsigned long) sizeof(SgNullifyStatement));
292761 0 : printf (" Size of SgEquivalenceStatement = %lu \n",(unsigned long) sizeof(SgEquivalenceStatement));
292762 0 : printf (" Size of SgDerivedTypeStatement = %lu \n",(unsigned long) sizeof(SgDerivedTypeStatement));
292763 0 : printf (" Size of SgAttributeSpecificationStatement = %lu \n",(unsigned long) sizeof(SgAttributeSpecificationStatement));
292764 0 : printf (" Size of SgAllocateStatement = %lu \n",(unsigned long) sizeof(SgAllocateStatement));
292765 0 : printf (" Size of SgDeallocateStatement = %lu \n",(unsigned long) sizeof(SgDeallocateStatement));
292766 0 : printf (" Size of SgContainsStatement = %lu \n",(unsigned long) sizeof(SgContainsStatement));
292767 0 : printf (" Size of SgSequenceStatement = %lu \n",(unsigned long) sizeof(SgSequenceStatement));
292768 0 : printf (" Size of SgElseWhereStatement = %lu \n",(unsigned long) sizeof(SgElseWhereStatement));
292769 0 : printf (" Size of SgArithmeticIfStatement = %lu \n",(unsigned long) sizeof(SgArithmeticIfStatement));
292770 0 : printf (" Size of SgAssignStatement = %lu \n",(unsigned long) sizeof(SgAssignStatement));
292771 0 : printf (" Size of SgComputedGotoStatement = %lu \n",(unsigned long) sizeof(SgComputedGotoStatement));
292772 0 : printf (" Size of SgAssignedGotoStatement = %lu \n",(unsigned long) sizeof(SgAssignedGotoStatement));
292773 0 : printf (" Size of SgNamelistStatement = %lu \n",(unsigned long) sizeof(SgNamelistStatement));
292774 0 : printf (" Size of SgImportStatement = %lu \n",(unsigned long) sizeof(SgImportStatement));
292775 0 : printf (" Size of SgAssociateStatement = %lu \n",(unsigned long) sizeof(SgAssociateStatement));
292776 0 : printf (" Size of SgFortranIncludeLine = %lu \n",(unsigned long) sizeof(SgFortranIncludeLine));
292777 0 : printf (" Size of SgNamespaceDeclarationStatement = %lu \n",(unsigned long) sizeof(SgNamespaceDeclarationStatement));
292778 0 : printf (" Size of SgNamespaceAliasDeclarationStatement = %lu \n",(unsigned long) sizeof(SgNamespaceAliasDeclarationStatement));
292779 0 : printf (" Size of SgNamespaceDefinitionStatement = %lu \n",(unsigned long) sizeof(SgNamespaceDefinitionStatement));
292780 0 : printf (" Size of SgUsingDeclarationStatement = %lu \n",(unsigned long) sizeof(SgUsingDeclarationStatement));
292781 0 : printf (" Size of SgUsingDirectiveStatement = %lu \n",(unsigned long) sizeof(SgUsingDirectiveStatement));
292782 0 : printf (" Size of SgTemplateInstantiationDirectiveStatement = %lu \n",(unsigned long) sizeof(SgTemplateInstantiationDirectiveStatement));
292783 0 : printf (" Size of SgStaticAssertionDeclaration = %lu \n",(unsigned long) sizeof(SgStaticAssertionDeclaration));
292784 0 : printf (" Size of SgTemplateClassDefinition = %lu \n",(unsigned long) sizeof(SgTemplateClassDefinition));
292785 0 : printf (" Size of SgTemplateFunctionDefinition = %lu \n",(unsigned long) sizeof(SgTemplateFunctionDefinition));
292786 0 : printf (" Size of SgClassDeclaration = %lu \n",(unsigned long) sizeof(SgClassDeclaration));
292787 0 : printf (" Size of SgClassDefinition = %lu \n",(unsigned long) sizeof(SgClassDefinition));
292788 0 : printf (" Size of SgFunctionDefinition = %lu \n",(unsigned long) sizeof(SgFunctionDefinition));
292789 0 : printf (" Size of SgScopeStatement = %lu \n",(unsigned long) sizeof(SgScopeStatement));
292790 0 : printf (" Size of SgMemberFunctionDeclaration = %lu \n",(unsigned long) sizeof(SgMemberFunctionDeclaration));
292791 0 : printf (" Size of SgFunctionDeclaration = %lu \n",(unsigned long) sizeof(SgFunctionDeclaration));
292792 0 : printf (" Size of SgIncludeDirectiveStatement = %lu \n",(unsigned long) sizeof(SgIncludeDirectiveStatement));
292793 0 : printf (" Size of SgDefineDirectiveStatement = %lu \n",(unsigned long) sizeof(SgDefineDirectiveStatement));
292794 0 : printf (" Size of SgUndefDirectiveStatement = %lu \n",(unsigned long) sizeof(SgUndefDirectiveStatement));
292795 0 : printf (" Size of SgIfdefDirectiveStatement = %lu \n",(unsigned long) sizeof(SgIfdefDirectiveStatement));
292796 0 : printf (" Size of SgIfndefDirectiveStatement = %lu \n",(unsigned long) sizeof(SgIfndefDirectiveStatement));
292797 0 : printf (" Size of SgIfDirectiveStatement = %lu \n",(unsigned long) sizeof(SgIfDirectiveStatement));
292798 0 : printf (" Size of SgDeadIfDirectiveStatement = %lu \n",(unsigned long) sizeof(SgDeadIfDirectiveStatement));
292799 0 : printf (" Size of SgElseDirectiveStatement = %lu \n",(unsigned long) sizeof(SgElseDirectiveStatement));
292800 0 : printf (" Size of SgElseifDirectiveStatement = %lu \n",(unsigned long) sizeof(SgElseifDirectiveStatement));
292801 0 : printf (" Size of SgEndifDirectiveStatement = %lu \n",(unsigned long) sizeof(SgEndifDirectiveStatement));
292802 0 : printf (" Size of SgLineDirectiveStatement = %lu \n",(unsigned long) sizeof(SgLineDirectiveStatement));
292803 0 : printf (" Size of SgWarningDirectiveStatement = %lu \n",(unsigned long) sizeof(SgWarningDirectiveStatement));
292804 0 : printf (" Size of SgErrorDirectiveStatement = %lu \n",(unsigned long) sizeof(SgErrorDirectiveStatement));
292805 0 : printf (" Size of SgEmptyDirectiveStatement = %lu \n",(unsigned long) sizeof(SgEmptyDirectiveStatement));
292806 0 : printf (" Size of SgIncludeNextDirectiveStatement = %lu \n",(unsigned long) sizeof(SgIncludeNextDirectiveStatement));
292807 0 : printf (" Size of SgIdentDirectiveStatement = %lu \n",(unsigned long) sizeof(SgIdentDirectiveStatement));
292808 0 : printf (" Size of SgLinemarkerDirectiveStatement = %lu \n",(unsigned long) sizeof(SgLinemarkerDirectiveStatement));
292809 0 : printf (" Size of SgC_PreprocessorDirectiveStatement = %lu \n",(unsigned long) sizeof(SgC_PreprocessorDirectiveStatement));
292810 0 : printf (" Size of SgClinkageStartStatement = %lu \n",(unsigned long) sizeof(SgClinkageStartStatement));
292811 0 : printf (" Size of SgClinkageEndStatement = %lu \n",(unsigned long) sizeof(SgClinkageEndStatement));
292812 0 : printf (" Size of SgClinkageDeclarationStatement = %lu \n",(unsigned long) sizeof(SgClinkageDeclarationStatement));
292813 0 : printf (" Size of SgOmpDeclareSimdStatement = %lu \n",(unsigned long) sizeof(SgOmpDeclareSimdStatement));
292814 0 : printf (" Size of SgOmpBarrierStatement = %lu \n",(unsigned long) sizeof(SgOmpBarrierStatement));
292815 0 : printf (" Size of SgOmpTaskyieldStatement = %lu \n",(unsigned long) sizeof(SgOmpTaskyieldStatement));
292816 0 : printf (" Size of SgOmpRequiresStatement = %lu \n",(unsigned long) sizeof(SgOmpRequiresStatement));
292817 0 : printf (" Size of SgOmpTaskwaitStatement = %lu \n",(unsigned long) sizeof(SgOmpTaskwaitStatement));
292818 0 : printf (" Size of SgOmpThreadprivateStatement = %lu \n",(unsigned long) sizeof(SgOmpThreadprivateStatement));
292819 0 : printf (" Size of SgMicrosoftAttributeDeclaration = %lu \n",(unsigned long) sizeof(SgMicrosoftAttributeDeclaration));
292820 0 : printf (" Size of SgEmptyDeclaration = %lu \n",(unsigned long) sizeof(SgEmptyDeclaration));
292821 0 : printf (" Size of SgDeclarationStatement = %lu \n",(unsigned long) sizeof(SgDeclarationStatement));
292822 0 : printf (" Size of SgUpirBaseStatement = %lu \n",(unsigned long) sizeof(SgUpirBaseStatement));
292823 0 : printf (" Size of SgStatement = %lu \n",(unsigned long) sizeof(SgStatement));
292824 0 : printf (" Size of SgVarRefExp = %lu \n",(unsigned long) sizeof(SgVarRefExp));
292825 0 : printf (" Size of SgNonrealRefExp = %lu \n",(unsigned long) sizeof(SgNonrealRefExp));
292826 0 : printf (" Size of SgCompoundLiteralExp = %lu \n",(unsigned long) sizeof(SgCompoundLiteralExp));
292827 0 : printf (" Size of SgLabelRefExp = %lu \n",(unsigned long) sizeof(SgLabelRefExp));
292828 0 : printf (" Size of SgClassNameRefExp = %lu \n",(unsigned long) sizeof(SgClassNameRefExp));
292829 0 : printf (" Size of SgFunctionRefExp = %lu \n",(unsigned long) sizeof(SgFunctionRefExp));
292830 0 : printf (" Size of SgMemberFunctionRefExp = %lu \n",(unsigned long) sizeof(SgMemberFunctionRefExp));
292831 0 : printf (" Size of SgTemplateFunctionRefExp = %lu \n",(unsigned long) sizeof(SgTemplateFunctionRefExp));
292832 0 : printf (" Size of SgTemplateMemberFunctionRefExp = %lu \n",(unsigned long) sizeof(SgTemplateMemberFunctionRefExp));
292833 0 : printf (" Size of SgSizeOfOp = %lu \n",(unsigned long) sizeof(SgSizeOfOp));
292834 0 : printf (" Size of SgAlignOfOp = %lu \n",(unsigned long) sizeof(SgAlignOfOp));
292835 0 : printf (" Size of SgNoexceptOp = %lu \n",(unsigned long) sizeof(SgNoexceptOp));
292836 0 : printf (" Size of SgTypeExpression = %lu \n",(unsigned long) sizeof(SgTypeExpression));
292837 0 : printf (" Size of SgLambdaExp = %lu \n",(unsigned long) sizeof(SgLambdaExp));
292838 0 : printf (" Size of SgUpcLocalsizeofExpression = %lu \n",(unsigned long) sizeof(SgUpcLocalsizeofExpression));
292839 0 : printf (" Size of SgUpcBlocksizeofExpression = %lu \n",(unsigned long) sizeof(SgUpcBlocksizeofExpression));
292840 0 : printf (" Size of SgUpcElemsizeofExpression = %lu \n",(unsigned long) sizeof(SgUpcElemsizeofExpression));
292841 0 : printf (" Size of SgVarArgStartOp = %lu \n",(unsigned long) sizeof(SgVarArgStartOp));
292842 0 : printf (" Size of SgVarArgStartOneOperandOp = %lu \n",(unsigned long) sizeof(SgVarArgStartOneOperandOp));
292843 0 : printf (" Size of SgVarArgOp = %lu \n",(unsigned long) sizeof(SgVarArgOp));
292844 0 : printf (" Size of SgVarArgEndOp = %lu \n",(unsigned long) sizeof(SgVarArgEndOp));
292845 0 : printf (" Size of SgVarArgCopyOp = %lu \n",(unsigned long) sizeof(SgVarArgCopyOp));
292846 0 : printf (" Size of SgTypeIdOp = %lu \n",(unsigned long) sizeof(SgTypeIdOp));
292847 0 : printf (" Size of SgConditionalExp = %lu \n",(unsigned long) sizeof(SgConditionalExp));
292848 0 : printf (" Size of SgNewExp = %lu \n",(unsigned long) sizeof(SgNewExp));
292849 0 : printf (" Size of SgDeleteExp = %lu \n",(unsigned long) sizeof(SgDeleteExp));
292850 0 : printf (" Size of SgThisExp = %lu \n",(unsigned long) sizeof(SgThisExp));
292851 0 : printf (" Size of SgSuperExp = %lu \n",(unsigned long) sizeof(SgSuperExp));
292852 0 : printf (" Size of SgClassExp = %lu \n",(unsigned long) sizeof(SgClassExp));
292853 0 : printf (" Size of SgRefExp = %lu \n",(unsigned long) sizeof(SgRefExp));
292854 0 : printf (" Size of SgAggregateInitializer = %lu \n",(unsigned long) sizeof(SgAggregateInitializer));
292855 0 : printf (" Size of SgCompoundInitializer = %lu \n",(unsigned long) sizeof(SgCompoundInitializer));
292856 0 : printf (" Size of SgConstructorInitializer = %lu \n",(unsigned long) sizeof(SgConstructorInitializer));
292857 0 : printf (" Size of SgAssignInitializer = %lu \n",(unsigned long) sizeof(SgAssignInitializer));
292858 0 : printf (" Size of SgBracedInitializer = %lu \n",(unsigned long) sizeof(SgBracedInitializer));
292859 0 : printf (" Size of SgExpressionRoot = %lu \n",(unsigned long) sizeof(SgExpressionRoot));
292860 0 : printf (" Size of SgMinusOp = %lu \n",(unsigned long) sizeof(SgMinusOp));
292861 0 : printf (" Size of SgUnaryAddOp = %lu \n",(unsigned long) sizeof(SgUnaryAddOp));
292862 0 : printf (" Size of SgNotOp = %lu \n",(unsigned long) sizeof(SgNotOp));
292863 0 : printf (" Size of SgPointerDerefExp = %lu \n",(unsigned long) sizeof(SgPointerDerefExp));
292864 0 : printf (" Size of SgAddressOfOp = %lu \n",(unsigned long) sizeof(SgAddressOfOp));
292865 0 : printf (" Size of SgMinusMinusOp = %lu \n",(unsigned long) sizeof(SgMinusMinusOp));
292866 0 : printf (" Size of SgPlusPlusOp = %lu \n",(unsigned long) sizeof(SgPlusPlusOp));
292867 0 : printf (" Size of SgBitComplementOp = %lu \n",(unsigned long) sizeof(SgBitComplementOp));
292868 0 : printf (" Size of SgRealPartOp = %lu \n",(unsigned long) sizeof(SgRealPartOp));
292869 0 : printf (" Size of SgImagPartOp = %lu \n",(unsigned long) sizeof(SgImagPartOp));
292870 0 : printf (" Size of SgConjugateOp = %lu \n",(unsigned long) sizeof(SgConjugateOp));
292871 0 : printf (" Size of SgCastExp = %lu \n",(unsigned long) sizeof(SgCastExp));
292872 0 : printf (" Size of SgThrowOp = %lu \n",(unsigned long) sizeof(SgThrowOp));
292873 0 : printf (" Size of SgArrowExp = %lu \n",(unsigned long) sizeof(SgArrowExp));
292874 0 : printf (" Size of SgDotExp = %lu \n",(unsigned long) sizeof(SgDotExp));
292875 0 : printf (" Size of SgDotStarOp = %lu \n",(unsigned long) sizeof(SgDotStarOp));
292876 0 : printf (" Size of SgArrowStarOp = %lu \n",(unsigned long) sizeof(SgArrowStarOp));
292877 0 : printf (" Size of SgEqualityOp = %lu \n",(unsigned long) sizeof(SgEqualityOp));
292878 0 : printf (" Size of SgLessThanOp = %lu \n",(unsigned long) sizeof(SgLessThanOp));
292879 0 : printf (" Size of SgGreaterThanOp = %lu \n",(unsigned long) sizeof(SgGreaterThanOp));
292880 0 : printf (" Size of SgNotEqualOp = %lu \n",(unsigned long) sizeof(SgNotEqualOp));
292881 0 : printf (" Size of SgLessOrEqualOp = %lu \n",(unsigned long) sizeof(SgLessOrEqualOp));
292882 0 : printf (" Size of SgGreaterOrEqualOp = %lu \n",(unsigned long) sizeof(SgGreaterOrEqualOp));
292883 0 : printf (" Size of SgAddOp = %lu \n",(unsigned long) sizeof(SgAddOp));
292884 0 : printf (" Size of SgSubtractOp = %lu \n",(unsigned long) sizeof(SgSubtractOp));
292885 0 : printf (" Size of SgMultiplyOp = %lu \n",(unsigned long) sizeof(SgMultiplyOp));
292886 0 : printf (" Size of SgDivideOp = %lu \n",(unsigned long) sizeof(SgDivideOp));
292887 0 : printf (" Size of SgIntegerDivideOp = %lu \n",(unsigned long) sizeof(SgIntegerDivideOp));
292888 0 : printf (" Size of SgModOp = %lu \n",(unsigned long) sizeof(SgModOp));
292889 0 : printf (" Size of SgAndOp = %lu \n",(unsigned long) sizeof(SgAndOp));
292890 0 : printf (" Size of SgOrOp = %lu \n",(unsigned long) sizeof(SgOrOp));
292891 0 : printf (" Size of SgBitXorOp = %lu \n",(unsigned long) sizeof(SgBitXorOp));
292892 0 : printf (" Size of SgBitAndOp = %lu \n",(unsigned long) sizeof(SgBitAndOp));
292893 0 : printf (" Size of SgBitOrOp = %lu \n",(unsigned long) sizeof(SgBitOrOp));
292894 0 : printf (" Size of SgBitEqvOp = %lu \n",(unsigned long) sizeof(SgBitEqvOp));
292895 0 : printf (" Size of SgCommaOpExp = %lu \n",(unsigned long) sizeof(SgCommaOpExp));
292896 0 : printf (" Size of SgLshiftOp = %lu \n",(unsigned long) sizeof(SgLshiftOp));
292897 0 : printf (" Size of SgRshiftOp = %lu \n",(unsigned long) sizeof(SgRshiftOp));
292898 0 : printf (" Size of SgPntrArrRefExp = %lu \n",(unsigned long) sizeof(SgPntrArrRefExp));
292899 0 : printf (" Size of SgScopeOp = %lu \n",(unsigned long) sizeof(SgScopeOp));
292900 0 : printf (" Size of SgAssignOp = %lu \n",(unsigned long) sizeof(SgAssignOp));
292901 0 : printf (" Size of SgPlusAssignOp = %lu \n",(unsigned long) sizeof(SgPlusAssignOp));
292902 0 : printf (" Size of SgMinusAssignOp = %lu \n",(unsigned long) sizeof(SgMinusAssignOp));
292903 0 : printf (" Size of SgAndAssignOp = %lu \n",(unsigned long) sizeof(SgAndAssignOp));
292904 0 : printf (" Size of SgIorAssignOp = %lu \n",(unsigned long) sizeof(SgIorAssignOp));
292905 0 : printf (" Size of SgMultAssignOp = %lu \n",(unsigned long) sizeof(SgMultAssignOp));
292906 0 : printf (" Size of SgDivAssignOp = %lu \n",(unsigned long) sizeof(SgDivAssignOp));
292907 0 : printf (" Size of SgModAssignOp = %lu \n",(unsigned long) sizeof(SgModAssignOp));
292908 0 : printf (" Size of SgXorAssignOp = %lu \n",(unsigned long) sizeof(SgXorAssignOp));
292909 0 : printf (" Size of SgLshiftAssignOp = %lu \n",(unsigned long) sizeof(SgLshiftAssignOp));
292910 0 : printf (" Size of SgRshiftAssignOp = %lu \n",(unsigned long) sizeof(SgRshiftAssignOp));
292911 0 : printf (" Size of SgIntegerDivideAssignOp = %lu \n",(unsigned long) sizeof(SgIntegerDivideAssignOp));
292912 0 : printf (" Size of SgExponentiationAssignOp = %lu \n",(unsigned long) sizeof(SgExponentiationAssignOp));
292913 0 : printf (" Size of SgConcatenationOp = %lu \n",(unsigned long) sizeof(SgConcatenationOp));
292914 0 : printf (" Size of SgNaryComparisonOp = %lu \n",(unsigned long) sizeof(SgNaryComparisonOp));
292915 0 : printf (" Size of SgNaryBooleanOp = %lu \n",(unsigned long) sizeof(SgNaryBooleanOp));
292916 0 : printf (" Size of SgBoolValExp = %lu \n",(unsigned long) sizeof(SgBoolValExp));
292917 0 : printf (" Size of SgStringVal = %lu \n",(unsigned long) sizeof(SgStringVal));
292918 0 : printf (" Size of SgShortVal = %lu \n",(unsigned long) sizeof(SgShortVal));
292919 0 : printf (" Size of SgCharVal = %lu \n",(unsigned long) sizeof(SgCharVal));
292920 0 : printf (" Size of SgUnsignedCharVal = %lu \n",(unsigned long) sizeof(SgUnsignedCharVal));
292921 0 : printf (" Size of SgWcharVal = %lu \n",(unsigned long) sizeof(SgWcharVal));
292922 0 : printf (" Size of SgChar16Val = %lu \n",(unsigned long) sizeof(SgChar16Val));
292923 0 : printf (" Size of SgChar32Val = %lu \n",(unsigned long) sizeof(SgChar32Val));
292924 0 : printf (" Size of SgUnsignedShortVal = %lu \n",(unsigned long) sizeof(SgUnsignedShortVal));
292925 0 : printf (" Size of SgIntVal = %lu \n",(unsigned long) sizeof(SgIntVal));
292926 0 : printf (" Size of SgEnumVal = %lu \n",(unsigned long) sizeof(SgEnumVal));
292927 0 : printf (" Size of SgUnsignedIntVal = %lu \n",(unsigned long) sizeof(SgUnsignedIntVal));
292928 0 : printf (" Size of SgLongIntVal = %lu \n",(unsigned long) sizeof(SgLongIntVal));
292929 0 : printf (" Size of SgLongLongIntVal = %lu \n",(unsigned long) sizeof(SgLongLongIntVal));
292930 0 : printf (" Size of SgUnsignedLongLongIntVal = %lu \n",(unsigned long) sizeof(SgUnsignedLongLongIntVal));
292931 0 : printf (" Size of SgUnsignedLongVal = %lu \n",(unsigned long) sizeof(SgUnsignedLongVal));
292932 0 : printf (" Size of SgFloatVal = %lu \n",(unsigned long) sizeof(SgFloatVal));
292933 0 : printf (" Size of SgDoubleVal = %lu \n",(unsigned long) sizeof(SgDoubleVal));
292934 0 : printf (" Size of SgLongDoubleVal = %lu \n",(unsigned long) sizeof(SgLongDoubleVal));
292935 0 : printf (" Size of SgFloat80Val = %lu \n",(unsigned long) sizeof(SgFloat80Val));
292936 0 : printf (" Size of SgFloat128Val = %lu \n",(unsigned long) sizeof(SgFloat128Val));
292937 0 : printf (" Size of SgNullptrValExp = %lu \n",(unsigned long) sizeof(SgNullptrValExp));
292938 0 : printf (" Size of SgVoidVal = %lu \n",(unsigned long) sizeof(SgVoidVal));
292939 0 : printf (" Size of SgFunctionParameterRefExp = %lu \n",(unsigned long) sizeof(SgFunctionParameterRefExp));
292940 0 : printf (" Size of SgTemplateParameterVal = %lu \n",(unsigned long) sizeof(SgTemplateParameterVal));
292941 0 : printf (" Size of SgUpcThreads = %lu \n",(unsigned long) sizeof(SgUpcThreads));
292942 0 : printf (" Size of SgUpcMythread = %lu \n",(unsigned long) sizeof(SgUpcMythread));
292943 0 : printf (" Size of SgComplexVal = %lu \n",(unsigned long) sizeof(SgComplexVal));
292944 0 : printf (" Size of SgNullExpression = %lu \n",(unsigned long) sizeof(SgNullExpression));
292945 0 : printf (" Size of SgVariantExpression = %lu \n",(unsigned long) sizeof(SgVariantExpression));
292946 0 : printf (" Size of SgStatementExpression = %lu \n",(unsigned long) sizeof(SgStatementExpression));
292947 0 : printf (" Size of SgAsmOp = %lu \n",(unsigned long) sizeof(SgAsmOp));
292948 0 : printf (" Size of SgCudaKernelExecConfig = %lu \n",(unsigned long) sizeof(SgCudaKernelExecConfig));
292949 0 : printf (" Size of SgCudaKernelCallExp = %lu \n",(unsigned long) sizeof(SgCudaKernelCallExp));
292950 0 : printf (" Size of SgLambdaRefExp = %lu \n",(unsigned long) sizeof(SgLambdaRefExp));
292951 0 : printf (" Size of SgTupleExp = %lu \n",(unsigned long) sizeof(SgTupleExp));
292952 0 : printf (" Size of SgListExp = %lu \n",(unsigned long) sizeof(SgListExp));
292953 0 : printf (" Size of SgDictionaryExp = %lu \n",(unsigned long) sizeof(SgDictionaryExp));
292954 0 : printf (" Size of SgKeyDatumPair = %lu \n",(unsigned long) sizeof(SgKeyDatumPair));
292955 0 : printf (" Size of SgComprehension = %lu \n",(unsigned long) sizeof(SgComprehension));
292956 0 : printf (" Size of SgListComprehension = %lu \n",(unsigned long) sizeof(SgListComprehension));
292957 0 : printf (" Size of SgSetComprehension = %lu \n",(unsigned long) sizeof(SgSetComprehension));
292958 0 : printf (" Size of SgDictionaryComprehension = %lu \n",(unsigned long) sizeof(SgDictionaryComprehension));
292959 0 : printf (" Size of SgMembershipOp = %lu \n",(unsigned long) sizeof(SgMembershipOp));
292960 0 : printf (" Size of SgNonMembershipOp = %lu \n",(unsigned long) sizeof(SgNonMembershipOp));
292961 0 : printf (" Size of SgIsOp = %lu \n",(unsigned long) sizeof(SgIsOp));
292962 0 : printf (" Size of SgIsNotOp = %lu \n",(unsigned long) sizeof(SgIsNotOp));
292963 0 : printf (" Size of SgStringConversion = %lu \n",(unsigned long) sizeof(SgStringConversion));
292964 0 : printf (" Size of SgYieldExpression = %lu \n",(unsigned long) sizeof(SgYieldExpression));
292965 0 : printf (" Size of SgFoldExpression = %lu \n",(unsigned long) sizeof(SgFoldExpression));
292966 0 : printf (" Size of SgChooseExpression = %lu \n",(unsigned long) sizeof(SgChooseExpression));
292967 0 : printf (" Size of SgAwaitExpression = %lu \n",(unsigned long) sizeof(SgAwaitExpression));
292968 0 : printf (" Size of SgSpaceshipOp = %lu \n",(unsigned long) sizeof(SgSpaceshipOp));
292969 0 : printf (" Size of SgSubscriptExpression = %lu \n",(unsigned long) sizeof(SgSubscriptExpression));
292970 0 : printf (" Size of SgColonShapeExp = %lu \n",(unsigned long) sizeof(SgColonShapeExp));
292971 0 : printf (" Size of SgAsteriskShapeExp = %lu \n",(unsigned long) sizeof(SgAsteriskShapeExp));
292972 0 : printf (" Size of SgIOItemExpression = %lu \n",(unsigned long) sizeof(SgIOItemExpression));
292973 0 : printf (" Size of SgImpliedDo = %lu \n",(unsigned long) sizeof(SgImpliedDo));
292974 0 : printf (" Size of SgExponentiationOp = %lu \n",(unsigned long) sizeof(SgExponentiationOp));
292975 0 : printf (" Size of SgUnknownArrayOrFunctionReference = %lu \n",(unsigned long) sizeof(SgUnknownArrayOrFunctionReference));
292976 0 : printf (" Size of SgActualArgumentExpression = %lu \n",(unsigned long) sizeof(SgActualArgumentExpression));
292977 0 : printf (" Size of SgUserDefinedBinaryOp = %lu \n",(unsigned long) sizeof(SgUserDefinedBinaryOp));
292978 0 : printf (" Size of SgPointerAssignOp = %lu \n",(unsigned long) sizeof(SgPointerAssignOp));
292979 0 : printf (" Size of SgCAFCoExpression = %lu \n",(unsigned long) sizeof(SgCAFCoExpression));
292980 0 : printf (" Size of SgDesignatedInitializer = %lu \n",(unsigned long) sizeof(SgDesignatedInitializer));
292981 0 : printf (" Size of SgMatrixExp = %lu \n",(unsigned long) sizeof(SgMatrixExp));
292982 0 : printf (" Size of SgRangeExp = %lu \n",(unsigned long) sizeof(SgRangeExp));
292983 0 : printf (" Size of SgMagicColonExp = %lu \n",(unsigned long) sizeof(SgMagicColonExp));
292984 0 : printf (" Size of SgElementwiseMultiplyOp = %lu \n",(unsigned long) sizeof(SgElementwiseMultiplyOp));
292985 0 : printf (" Size of SgPowerOp = %lu \n",(unsigned long) sizeof(SgPowerOp));
292986 0 : printf (" Size of SgElementwisePowerOp = %lu \n",(unsigned long) sizeof(SgElementwisePowerOp));
292987 0 : printf (" Size of SgElementwiseDivideOp = %lu \n",(unsigned long) sizeof(SgElementwiseDivideOp));
292988 0 : printf (" Size of SgLeftDivideOp = %lu \n",(unsigned long) sizeof(SgLeftDivideOp));
292989 0 : printf (" Size of SgElementwiseLeftDivideOp = %lu \n",(unsigned long) sizeof(SgElementwiseLeftDivideOp));
292990 0 : printf (" Size of SgElementwiseAddOp = %lu \n",(unsigned long) sizeof(SgElementwiseAddOp));
292991 0 : printf (" Size of SgElementwiseSubtractOp = %lu \n",(unsigned long) sizeof(SgElementwiseSubtractOp));
292992 0 : printf (" Size of SgMatrixTransposeOp = %lu \n",(unsigned long) sizeof(SgMatrixTransposeOp));
292993 0 : printf (" Size of SgElementwiseOp = %lu \n",(unsigned long) sizeof(SgElementwiseOp));
292994 0 : printf (" Size of SgInitializer = %lu \n",(unsigned long) sizeof(SgInitializer));
292995 0 : printf (" Size of SgSIMDLoad = %lu \n",(unsigned long) sizeof(SgSIMDLoad));
292996 0 : printf (" Size of SgSIMDBroadcast = %lu \n",(unsigned long) sizeof(SgSIMDBroadcast));
292997 0 : printf (" Size of SgSIMDStore = %lu \n",(unsigned long) sizeof(SgSIMDStore));
292998 0 : printf (" Size of SgSIMDPartialStore = %lu \n",(unsigned long) sizeof(SgSIMDPartialStore));
292999 0 : printf (" Size of SgSIMDScalarStore = %lu \n",(unsigned long) sizeof(SgSIMDScalarStore));
293000 0 : printf (" Size of SgSIMDGather = %lu \n",(unsigned long) sizeof(SgSIMDGather));
293001 0 : printf (" Size of SgSIMDExplicitGather = %lu \n",(unsigned long) sizeof(SgSIMDExplicitGather));
293002 0 : printf (" Size of SgSIMDScatter = %lu \n",(unsigned long) sizeof(SgSIMDScatter));
293003 0 : printf (" Size of SgSIMDAddOp = %lu \n",(unsigned long) sizeof(SgSIMDAddOp));
293004 0 : printf (" Size of SgSIMDSubOp = %lu \n",(unsigned long) sizeof(SgSIMDSubOp));
293005 0 : printf (" Size of SgSIMDMulOp = %lu \n",(unsigned long) sizeof(SgSIMDMulOp));
293006 0 : printf (" Size of SgSIMDDivOp = %lu \n",(unsigned long) sizeof(SgSIMDDivOp));
293007 0 : printf (" Size of SgSIMDFmaOp = %lu \n",(unsigned long) sizeof(SgSIMDFmaOp));
293008 0 : printf (" Size of SgSIMDBinaryOp = %lu \n",(unsigned long) sizeof(SgSIMDBinaryOp));
293009 0 : printf (" Size of SgUserDefinedUnaryOp = %lu \n",(unsigned long) sizeof(SgUserDefinedUnaryOp));
293010 0 : printf (" Size of SgPseudoDestructorRefExp = %lu \n",(unsigned long) sizeof(SgPseudoDestructorRefExp));
293011 0 : printf (" Size of SgUnaryOp = %lu \n",(unsigned long) sizeof(SgUnaryOp));
293012 0 : printf (" Size of SgCompoundAssignOp = %lu \n",(unsigned long) sizeof(SgCompoundAssignOp));
293013 0 : printf (" Size of SgBinaryOp = %lu \n",(unsigned long) sizeof(SgBinaryOp));
293014 0 : printf (" Size of SgNaryOp = %lu \n",(unsigned long) sizeof(SgNaryOp));
293015 0 : printf (" Size of SgValueExp = %lu \n",(unsigned long) sizeof(SgValueExp));
293016 0 : printf (" Size of SgExprListExp = %lu \n",(unsigned long) sizeof(SgExprListExp));
293017 0 : printf (" Size of SgFunctionCallExp = %lu \n",(unsigned long) sizeof(SgFunctionCallExp));
293018 0 : printf (" Size of SgCallExpression = %lu \n",(unsigned long) sizeof(SgCallExpression));
293019 0 : printf (" Size of SgTypeTraitBuiltinOperator = %lu \n",(unsigned long) sizeof(SgTypeTraitBuiltinOperator));
293020 0 : printf (" Size of SgExpression = %lu \n",(unsigned long) sizeof(SgExpression));
293021 0 : printf (" Size of SgTemplateVariableSymbol = %lu \n",(unsigned long) sizeof(SgTemplateVariableSymbol));
293022 0 : printf (" Size of SgVariableSymbol = %lu \n",(unsigned long) sizeof(SgVariableSymbol));
293023 0 : printf (" Size of SgFunctionTypeSymbol = %lu \n",(unsigned long) sizeof(SgFunctionTypeSymbol));
293024 0 : printf (" Size of SgTemplateClassSymbol = %lu \n",(unsigned long) sizeof(SgTemplateClassSymbol));
293025 0 : printf (" Size of SgClassSymbol = %lu \n",(unsigned long) sizeof(SgClassSymbol));
293026 0 : printf (" Size of SgTemplateSymbol = %lu \n",(unsigned long) sizeof(SgTemplateSymbol));
293027 0 : printf (" Size of SgEnumSymbol = %lu \n",(unsigned long) sizeof(SgEnumSymbol));
293028 0 : printf (" Size of SgEnumFieldSymbol = %lu \n",(unsigned long) sizeof(SgEnumFieldSymbol));
293029 0 : printf (" Size of SgTemplateTypedefSymbol = %lu \n",(unsigned long) sizeof(SgTemplateTypedefSymbol));
293030 0 : printf (" Size of SgTypedefSymbol = %lu \n",(unsigned long) sizeof(SgTypedefSymbol));
293031 0 : printf (" Size of SgTemplateFunctionSymbol = %lu \n",(unsigned long) sizeof(SgTemplateFunctionSymbol));
293032 0 : printf (" Size of SgTemplateMemberFunctionSymbol = %lu \n",(unsigned long) sizeof(SgTemplateMemberFunctionSymbol));
293033 0 : printf (" Size of SgLabelSymbol = %lu \n",(unsigned long) sizeof(SgLabelSymbol));
293034 0 : printf (" Size of SgDefaultSymbol = %lu \n",(unsigned long) sizeof(SgDefaultSymbol));
293035 0 : printf (" Size of SgNamespaceSymbol = %lu \n",(unsigned long) sizeof(SgNamespaceSymbol));
293036 0 : printf (" Size of SgIntrinsicSymbol = %lu \n",(unsigned long) sizeof(SgIntrinsicSymbol));
293037 0 : printf (" Size of SgModuleSymbol = %lu \n",(unsigned long) sizeof(SgModuleSymbol));
293038 0 : printf (" Size of SgInterfaceSymbol = %lu \n",(unsigned long) sizeof(SgInterfaceSymbol));
293039 0 : printf (" Size of SgCommonSymbol = %lu \n",(unsigned long) sizeof(SgCommonSymbol));
293040 0 : printf (" Size of SgRenameSymbol = %lu \n",(unsigned long) sizeof(SgRenameSymbol));
293041 0 : printf (" Size of SgMemberFunctionSymbol = %lu \n",(unsigned long) sizeof(SgMemberFunctionSymbol));
293042 0 : printf (" Size of SgFunctionSymbol = %lu \n",(unsigned long) sizeof(SgFunctionSymbol));
293043 0 : printf (" Size of SgAliasSymbol = %lu \n",(unsigned long) sizeof(SgAliasSymbol));
293044 0 : printf (" Size of SgNonrealSymbol = %lu \n",(unsigned long) sizeof(SgNonrealSymbol));
293045 0 : printf (" Size of SgSymbol = %lu \n",(unsigned long) sizeof(SgSymbol));
293046 0 : printf (" Size of SgCommonBlockObject = %lu \n",(unsigned long) sizeof(SgCommonBlockObject));
293047 0 : printf (" Size of SgInitializedName = %lu \n",(unsigned long) sizeof(SgInitializedName));
293048 0 : printf (" Size of SgLambdaCapture = %lu \n",(unsigned long) sizeof(SgLambdaCapture));
293049 0 : printf (" Size of SgLambdaCaptureList = %lu \n",(unsigned long) sizeof(SgLambdaCaptureList));
293050 0 : printf (" Size of SgOmpOrderedClause = %lu \n",(unsigned long) sizeof(SgOmpOrderedClause));
293051 0 : printf (" Size of SgOmpNowaitClause = %lu \n",(unsigned long) sizeof(SgOmpNowaitClause));
293052 0 : printf (" Size of SgOmpNogroupClause = %lu \n",(unsigned long) sizeof(SgOmpNogroupClause));
293053 0 : printf (" Size of SgOmpReadClause = %lu \n",(unsigned long) sizeof(SgOmpReadClause));
293054 0 : printf (" Size of SgOmpThreadsClause = %lu \n",(unsigned long) sizeof(SgOmpThreadsClause));
293055 0 : printf (" Size of SgOmpSimdClause = %lu \n",(unsigned long) sizeof(SgOmpSimdClause));
293056 0 : printf (" Size of SgOmpReverseOffloadClause = %lu \n",(unsigned long) sizeof(SgOmpReverseOffloadClause));
293057 0 : printf (" Size of SgOmpExtImplementationDefinedRequirementClause = %lu \n",(unsigned long) sizeof(SgOmpExtImplementationDefinedRequirementClause));
293058 0 : printf (" Size of SgOmpUnifiedAddressClause = %lu \n",(unsigned long) sizeof(SgOmpUnifiedAddressClause));
293059 0 : printf (" Size of SgOmpUnifiedSharedMemoryClause = %lu \n",(unsigned long) sizeof(SgOmpUnifiedSharedMemoryClause));
293060 0 : printf (" Size of SgOmpDynamicAllocatorsClause = %lu \n",(unsigned long) sizeof(SgOmpDynamicAllocatorsClause));
293061 0 : printf (" Size of SgOmpAtomicDefaultMemOrderClause = %lu \n",(unsigned long) sizeof(SgOmpAtomicDefaultMemOrderClause));
293062 0 : printf (" Size of SgOmpWriteClause = %lu \n",(unsigned long) sizeof(SgOmpWriteClause));
293063 0 : printf (" Size of SgOmpUpdateClause = %lu \n",(unsigned long) sizeof(SgOmpUpdateClause));
293064 0 : printf (" Size of SgOmpDepobjUpdateClause = %lu \n",(unsigned long) sizeof(SgOmpDepobjUpdateClause));
293065 0 : printf (" Size of SgOmpDestroyClause = %lu \n",(unsigned long) sizeof(SgOmpDestroyClause));
293066 0 : printf (" Size of SgOmpCaptureClause = %lu \n",(unsigned long) sizeof(SgOmpCaptureClause));
293067 0 : printf (" Size of SgOmpSeqCstClause = %lu \n",(unsigned long) sizeof(SgOmpSeqCstClause));
293068 0 : printf (" Size of SgOmpAcqRelClause = %lu \n",(unsigned long) sizeof(SgOmpAcqRelClause));
293069 0 : printf (" Size of SgOmpReleaseClause = %lu \n",(unsigned long) sizeof(SgOmpReleaseClause));
293070 0 : printf (" Size of SgOmpAcquireClause = %lu \n",(unsigned long) sizeof(SgOmpAcquireClause));
293071 0 : printf (" Size of SgOmpRelaxedClause = %lu \n",(unsigned long) sizeof(SgOmpRelaxedClause));
293072 0 : printf (" Size of SgOmpParallelClause = %lu \n",(unsigned long) sizeof(SgOmpParallelClause));
293073 0 : printf (" Size of SgOmpSectionsClause = %lu \n",(unsigned long) sizeof(SgOmpSectionsClause));
293074 0 : printf (" Size of SgOmpForClause = %lu \n",(unsigned long) sizeof(SgOmpForClause));
293075 0 : printf (" Size of SgOmpTaskgroupClause = %lu \n",(unsigned long) sizeof(SgOmpTaskgroupClause));
293076 0 : printf (" Size of SgOmpBeginClause = %lu \n",(unsigned long) sizeof(SgOmpBeginClause));
293077 0 : printf (" Size of SgOmpEndClause = %lu \n",(unsigned long) sizeof(SgOmpEndClause));
293078 0 : printf (" Size of SgOmpUntiedClause = %lu \n",(unsigned long) sizeof(SgOmpUntiedClause));
293079 0 : printf (" Size of SgOmpMergeableClause = %lu \n",(unsigned long) sizeof(SgOmpMergeableClause));
293080 0 : printf (" Size of SgOmpDefaultClause = %lu \n",(unsigned long) sizeof(SgOmpDefaultClause));
293081 0 : printf (" Size of SgOmpAtomicClause = %lu \n",(unsigned long) sizeof(SgOmpAtomicClause));
293082 0 : printf (" Size of SgOmpProcBindClause = %lu \n",(unsigned long) sizeof(SgOmpProcBindClause));
293083 0 : printf (" Size of SgOmpOrderClause = %lu \n",(unsigned long) sizeof(SgOmpOrderClause));
293084 0 : printf (" Size of SgOmpBindClause = %lu \n",(unsigned long) sizeof(SgOmpBindClause));
293085 0 : printf (" Size of SgOmpInbranchClause = %lu \n",(unsigned long) sizeof(SgOmpInbranchClause));
293086 0 : printf (" Size of SgOmpNotinbranchClause = %lu \n",(unsigned long) sizeof(SgOmpNotinbranchClause));
293087 0 : printf (" Size of SgOmpCollapseClause = %lu \n",(unsigned long) sizeof(SgOmpCollapseClause));
293088 0 : printf (" Size of SgOmpIfClause = %lu \n",(unsigned long) sizeof(SgOmpIfClause));
293089 0 : printf (" Size of SgOmpFinalClause = %lu \n",(unsigned long) sizeof(SgOmpFinalClause));
293090 0 : printf (" Size of SgOmpPriorityClause = %lu \n",(unsigned long) sizeof(SgOmpPriorityClause));
293091 0 : printf (" Size of SgUpirNumUnitsField = %lu \n",(unsigned long) sizeof(SgUpirNumUnitsField));
293092 0 : printf (" Size of SgOmpNumTeamsClause = %lu \n",(unsigned long) sizeof(SgOmpNumTeamsClause));
293093 0 : printf (" Size of SgOmpGrainsizeClause = %lu \n",(unsigned long) sizeof(SgOmpGrainsizeClause));
293094 0 : printf (" Size of SgOmpDetachClause = %lu \n",(unsigned long) sizeof(SgOmpDetachClause));
293095 0 : printf (" Size of SgOmpNumTasksClause = %lu \n",(unsigned long) sizeof(SgOmpNumTasksClause));
293096 0 : printf (" Size of SgOmpHintClause = %lu \n",(unsigned long) sizeof(SgOmpHintClause));
293097 0 : printf (" Size of SgOmpThreadLimitClause = %lu \n",(unsigned long) sizeof(SgOmpThreadLimitClause));
293098 0 : printf (" Size of SgOmpNontemporalClause = %lu \n",(unsigned long) sizeof(SgOmpNontemporalClause));
293099 0 : printf (" Size of SgOmpInclusiveClause = %lu \n",(unsigned long) sizeof(SgOmpInclusiveClause));
293100 0 : printf (" Size of SgOmpExclusiveClause = %lu \n",(unsigned long) sizeof(SgOmpExclusiveClause));
293101 0 : printf (" Size of SgOmpIsDevicePtrClause = %lu \n",(unsigned long) sizeof(SgOmpIsDevicePtrClause));
293102 0 : printf (" Size of SgOmpUseDevicePtrClause = %lu \n",(unsigned long) sizeof(SgOmpUseDevicePtrClause));
293103 0 : printf (" Size of SgOmpUseDeviceAddrClause = %lu \n",(unsigned long) sizeof(SgOmpUseDeviceAddrClause));
293104 0 : printf (" Size of SgOmpDeviceClause = %lu \n",(unsigned long) sizeof(SgOmpDeviceClause));
293105 0 : printf (" Size of SgOmpSafelenClause = %lu \n",(unsigned long) sizeof(SgOmpSafelenClause));
293106 0 : printf (" Size of SgOmpSimdlenClause = %lu \n",(unsigned long) sizeof(SgOmpSimdlenClause));
293107 0 : printf (" Size of SgOmpPartialClause = %lu \n",(unsigned long) sizeof(SgOmpPartialClause));
293108 0 : printf (" Size of SgOmpFullClause = %lu \n",(unsigned long) sizeof(SgOmpFullClause));
293109 0 : printf (" Size of SgOmpSizesClause = %lu \n",(unsigned long) sizeof(SgOmpSizesClause));
293110 0 : printf (" Size of SgUpirBranchField = %lu \n",(unsigned long) sizeof(SgUpirBranchField));
293111 0 : printf (" Size of SgUpirNestedLevelField = %lu \n",(unsigned long) sizeof(SgUpirNestedLevelField));
293112 0 : printf (" Size of SgUpirNestedParentField = %lu \n",(unsigned long) sizeof(SgUpirNestedParentField));
293113 0 : printf (" Size of SgUpirNestedChildField = %lu \n",(unsigned long) sizeof(SgUpirNestedChildField));
293114 0 : printf (" Size of SgUpirSyncField = %lu \n",(unsigned long) sizeof(SgUpirSyncField));
293115 0 : printf (" Size of SgUpirDataField = %lu \n",(unsigned long) sizeof(SgUpirDataField));
293116 0 : printf (" Size of SgUpirTargetField = %lu \n",(unsigned long) sizeof(SgUpirTargetField));
293117 0 : printf (" Size of SgUpirDataItemField = %lu \n",(unsigned long) sizeof(SgUpirDataItemField));
293118 0 : printf (" Size of SgOmpExpressionClause = %lu \n",(unsigned long) sizeof(SgOmpExpressionClause));
293119 0 : printf (" Size of SgOmpCopyprivateClause = %lu \n",(unsigned long) sizeof(SgOmpCopyprivateClause));
293120 0 : printf (" Size of SgOmpPrivateClause = %lu \n",(unsigned long) sizeof(SgOmpPrivateClause));
293121 0 : printf (" Size of SgOmpFirstprivateClause = %lu \n",(unsigned long) sizeof(SgOmpFirstprivateClause));
293122 0 : printf (" Size of SgOmpSharedClause = %lu \n",(unsigned long) sizeof(SgOmpSharedClause));
293123 0 : printf (" Size of SgOmpCopyinClause = %lu \n",(unsigned long) sizeof(SgOmpCopyinClause));
293124 0 : printf (" Size of SgOmpLastprivateClause = %lu \n",(unsigned long) sizeof(SgOmpLastprivateClause));
293125 0 : printf (" Size of SgOmpReductionClause = %lu \n",(unsigned long) sizeof(SgOmpReductionClause));
293126 0 : printf (" Size of SgOmpInReductionClause = %lu \n",(unsigned long) sizeof(SgOmpInReductionClause));
293127 0 : printf (" Size of SgOmpTaskReductionClause = %lu \n",(unsigned long) sizeof(SgOmpTaskReductionClause));
293128 0 : printf (" Size of SgOmpAllocateClause = %lu \n",(unsigned long) sizeof(SgOmpAllocateClause));
293129 0 : printf (" Size of SgOmpDependClause = %lu \n",(unsigned long) sizeof(SgOmpDependClause));
293130 0 : printf (" Size of SgOmpToClause = %lu \n",(unsigned long) sizeof(SgOmpToClause));
293131 0 : printf (" Size of SgOmpUsesAllocatorsClause = %lu \n",(unsigned long) sizeof(SgOmpUsesAllocatorsClause));
293132 0 : printf (" Size of SgOmpFromClause = %lu \n",(unsigned long) sizeof(SgOmpFromClause));
293133 0 : printf (" Size of SgOmpAffinityClause = %lu \n",(unsigned long) sizeof(SgOmpAffinityClause));
293134 0 : printf (" Size of SgOmpMapClause = %lu \n",(unsigned long) sizeof(SgOmpMapClause));
293135 0 : printf (" Size of SgOmpLinearClause = %lu \n",(unsigned long) sizeof(SgOmpLinearClause));
293136 0 : printf (" Size of SgOmpUniformClause = %lu \n",(unsigned long) sizeof(SgOmpUniformClause));
293137 0 : printf (" Size of SgOmpAlignedClause = %lu \n",(unsigned long) sizeof(SgOmpAlignedClause));
293138 0 : printf (" Size of SgOmpVariablesClause = %lu \n",(unsigned long) sizeof(SgOmpVariablesClause));
293139 0 : printf (" Size of SgOmpScheduleClause = %lu \n",(unsigned long) sizeof(SgOmpScheduleClause));
293140 0 : printf (" Size of SgOmpWhenClause = %lu \n",(unsigned long) sizeof(SgOmpWhenClause));
293141 0 : printf (" Size of SgOmpDistScheduleClause = %lu \n",(unsigned long) sizeof(SgOmpDistScheduleClause));
293142 0 : printf (" Size of SgOmpDefaultmapClause = %lu \n",(unsigned long) sizeof(SgOmpDefaultmapClause));
293143 0 : printf (" Size of SgOmpAllocatorClause = %lu \n",(unsigned long) sizeof(SgOmpAllocatorClause));
293144 0 : printf (" Size of SgOmpUsesAllocatorsDefination = %lu \n",(unsigned long) sizeof(SgOmpUsesAllocatorsDefination));
293145 0 : printf (" Size of SgOmpClause = %lu \n",(unsigned long) sizeof(SgOmpClause));
293146 0 : printf (" Size of SgRenamePair = %lu \n",(unsigned long) sizeof(SgRenamePair));
293147 0 : printf (" Size of SgInterfaceBody = %lu \n",(unsigned long) sizeof(SgInterfaceBody));
293148 0 : printf (" Size of SgHeaderFileBody = %lu \n",(unsigned long) sizeof(SgHeaderFileBody));
293149 0 : printf (" Size of SgLocatedNodeSupport = %lu \n",(unsigned long) sizeof(SgLocatedNodeSupport));
293150 0 : printf (" Size of SgToken = %lu \n",(unsigned long) sizeof(SgToken));
293151 0 : printf (" Size of SgLocatedNode = %lu \n",(unsigned long) sizeof(SgLocatedNode));
293152 0 : printf (" Size of SgNode = %lu \n",(unsigned long) sizeof(SgNode));
293153 0 : }
293154 :
293155 :
293156 :
293157 194 : void traverseMemoryPoolVisitorPattern ( ROSE_VisitorPattern & visitor )
293158 : {
293159 194 : SgName::traverseMemoryPoolVisitorPattern(visitor);
293160 194 : SgSymbolTable::traverseMemoryPoolVisitorPattern(visitor);
293161 194 : SgPragma::traverseMemoryPoolVisitorPattern(visitor);
293162 194 : SgModifierNodes::traverseMemoryPoolVisitorPattern(visitor);
293163 194 : SgConstVolatileModifier::traverseMemoryPoolVisitorPattern(visitor);
293164 194 : SgStorageModifier::traverseMemoryPoolVisitorPattern(visitor);
293165 194 : SgAccessModifier::traverseMemoryPoolVisitorPattern(visitor);
293166 194 : SgFunctionModifier::traverseMemoryPoolVisitorPattern(visitor);
293167 194 : SgUPC_AccessModifier::traverseMemoryPoolVisitorPattern(visitor);
293168 194 : SgLinkageModifier::traverseMemoryPoolVisitorPattern(visitor);
293169 194 : SgSpecialFunctionModifier::traverseMemoryPoolVisitorPattern(visitor);
293170 194 : SgTypeModifier::traverseMemoryPoolVisitorPattern(visitor);
293171 194 : SgElaboratedTypeModifier::traverseMemoryPoolVisitorPattern(visitor);
293172 194 : SgBaseClassModifier::traverseMemoryPoolVisitorPattern(visitor);
293173 194 : SgDeclarationModifier::traverseMemoryPoolVisitorPattern(visitor);
293174 194 : SgStructureModifier::traverseMemoryPoolVisitorPattern(visitor);
293175 194 : SgOpenclAccessModeModifier::traverseMemoryPoolVisitorPattern(visitor);
293176 194 : SgModifier::traverseMemoryPoolVisitorPattern(visitor);
293177 194 : Sg_File_Info::traverseMemoryPoolVisitorPattern(visitor);
293178 194 : SgSourceFile::traverseMemoryPoolVisitorPattern(visitor);
293179 194 : SgUnknownFile::traverseMemoryPoolVisitorPattern(visitor);
293180 194 : SgFile::traverseMemoryPoolVisitorPattern(visitor);
293181 194 : SgFileList::traverseMemoryPoolVisitorPattern(visitor);
293182 194 : SgDirectory::traverseMemoryPoolVisitorPattern(visitor);
293183 194 : SgDirectoryList::traverseMemoryPoolVisitorPattern(visitor);
293184 194 : SgProject::traverseMemoryPoolVisitorPattern(visitor);
293185 194 : SgOptions::traverseMemoryPoolVisitorPattern(visitor);
293186 194 : SgUnparse_Info::traverseMemoryPoolVisitorPattern(visitor);
293187 194 : SgIncludeFile::traverseMemoryPoolVisitorPattern(visitor);
293188 194 : SgFuncDecl_attr::traverseMemoryPoolVisitorPattern(visitor);
293189 194 : SgClassDecl_attr::traverseMemoryPoolVisitorPattern(visitor);
293190 194 : SgTypedefSeq::traverseMemoryPoolVisitorPattern(visitor);
293191 194 : SgFunctionParameterTypeList::traverseMemoryPoolVisitorPattern(visitor);
293192 194 : SgTemplateParameter::traverseMemoryPoolVisitorPattern(visitor);
293193 194 : SgTemplateArgument::traverseMemoryPoolVisitorPattern(visitor);
293194 194 : SgTemplateParameterList::traverseMemoryPoolVisitorPattern(visitor);
293195 194 : SgTemplateArgumentList::traverseMemoryPoolVisitorPattern(visitor);
293196 194 : SgBitAttribute::traverseMemoryPoolVisitorPattern(visitor);
293197 194 : SgAttribute::traverseMemoryPoolVisitorPattern(visitor);
293198 194 : SgExpBaseClass::traverseMemoryPoolVisitorPattern(visitor);
293199 194 : SgNonrealBaseClass::traverseMemoryPoolVisitorPattern(visitor);
293200 194 : SgBaseClass::traverseMemoryPoolVisitorPattern(visitor);
293201 194 : SgUndirectedGraphEdge::traverseMemoryPoolVisitorPattern(visitor);
293202 194 : SgDirectedGraphEdge::traverseMemoryPoolVisitorPattern(visitor);
293203 194 : SgGraphNode::traverseMemoryPoolVisitorPattern(visitor);
293204 194 : SgGraphEdge::traverseMemoryPoolVisitorPattern(visitor);
293205 194 : SgStringKeyedBidirectionalGraph::traverseMemoryPoolVisitorPattern(visitor);
293206 194 : SgIntKeyedBidirectionalGraph::traverseMemoryPoolVisitorPattern(visitor);
293207 194 : SgBidirectionalGraph::traverseMemoryPoolVisitorPattern(visitor);
293208 194 : SgIncidenceDirectedGraph::traverseMemoryPoolVisitorPattern(visitor);
293209 194 : SgIncidenceUndirectedGraph::traverseMemoryPoolVisitorPattern(visitor);
293210 194 : SgGraph::traverseMemoryPoolVisitorPattern(visitor);
293211 194 : SgGraphNodeList::traverseMemoryPoolVisitorPattern(visitor);
293212 194 : SgGraphEdgeList::traverseMemoryPoolVisitorPattern(visitor);
293213 194 : SgQualifiedName::traverseMemoryPoolVisitorPattern(visitor);
293214 194 : SgNameGroup::traverseMemoryPoolVisitorPattern(visitor);
293215 194 : SgDimensionObject::traverseMemoryPoolVisitorPattern(visitor);
293216 194 : SgDataStatementGroup::traverseMemoryPoolVisitorPattern(visitor);
293217 194 : SgDataStatementObject::traverseMemoryPoolVisitorPattern(visitor);
293218 194 : SgDataStatementValue::traverseMemoryPoolVisitorPattern(visitor);
293219 194 : SgFormatItem::traverseMemoryPoolVisitorPattern(visitor);
293220 194 : SgFormatItemList::traverseMemoryPoolVisitorPattern(visitor);
293221 194 : SgTypeTable::traverseMemoryPoolVisitorPattern(visitor);
293222 194 : SgHeaderFileReport::traverseMemoryPoolVisitorPattern(visitor);
293223 194 : SgSupport::traverseMemoryPoolVisitorPattern(visitor);
293224 194 : SgTypeUnknown::traverseMemoryPoolVisitorPattern(visitor);
293225 194 : SgTypeChar::traverseMemoryPoolVisitorPattern(visitor);
293226 194 : SgTypeSignedChar::traverseMemoryPoolVisitorPattern(visitor);
293227 194 : SgTypeUnsignedChar::traverseMemoryPoolVisitorPattern(visitor);
293228 194 : SgTypeShort::traverseMemoryPoolVisitorPattern(visitor);
293229 194 : SgTypeSignedShort::traverseMemoryPoolVisitorPattern(visitor);
293230 194 : SgTypeUnsignedShort::traverseMemoryPoolVisitorPattern(visitor);
293231 194 : SgTypeInt::traverseMemoryPoolVisitorPattern(visitor);
293232 194 : SgTypeSignedInt::traverseMemoryPoolVisitorPattern(visitor);
293233 194 : SgTypeUnsignedInt::traverseMemoryPoolVisitorPattern(visitor);
293234 194 : SgTypeLong::traverseMemoryPoolVisitorPattern(visitor);
293235 194 : SgTypeSignedLong::traverseMemoryPoolVisitorPattern(visitor);
293236 194 : SgTypeUnsignedLong::traverseMemoryPoolVisitorPattern(visitor);
293237 194 : SgTypeVoid::traverseMemoryPoolVisitorPattern(visitor);
293238 194 : SgTypeGlobalVoid::traverseMemoryPoolVisitorPattern(visitor);
293239 194 : SgTypeWchar::traverseMemoryPoolVisitorPattern(visitor);
293240 194 : SgTypeFloat::traverseMemoryPoolVisitorPattern(visitor);
293241 194 : SgTypeDouble::traverseMemoryPoolVisitorPattern(visitor);
293242 194 : SgTypeLongLong::traverseMemoryPoolVisitorPattern(visitor);
293243 194 : SgTypeSignedLongLong::traverseMemoryPoolVisitorPattern(visitor);
293244 194 : SgTypeUnsignedLongLong::traverseMemoryPoolVisitorPattern(visitor);
293245 194 : SgTypeLongDouble::traverseMemoryPoolVisitorPattern(visitor);
293246 194 : SgTypeFloat80::traverseMemoryPoolVisitorPattern(visitor);
293247 194 : SgTypeFloat128::traverseMemoryPoolVisitorPattern(visitor);
293248 194 : SgTypeString::traverseMemoryPoolVisitorPattern(visitor);
293249 194 : SgTypeBool::traverseMemoryPoolVisitorPattern(visitor);
293250 194 : SgTypeFixed::traverseMemoryPoolVisitorPattern(visitor);
293251 194 : SgTypeMatrix::traverseMemoryPoolVisitorPattern(visitor);
293252 194 : SgTypeTuple::traverseMemoryPoolVisitorPattern(visitor);
293253 194 : SgTypeNullptr::traverseMemoryPoolVisitorPattern(visitor);
293254 194 : SgTypeComplex::traverseMemoryPoolVisitorPattern(visitor);
293255 194 : SgTypeImaginary::traverseMemoryPoolVisitorPattern(visitor);
293256 194 : SgTypeDefault::traverseMemoryPoolVisitorPattern(visitor);
293257 194 : SgPointerMemberType::traverseMemoryPoolVisitorPattern(visitor);
293258 194 : SgReferenceType::traverseMemoryPoolVisitorPattern(visitor);
293259 194 : SgRvalueReferenceType::traverseMemoryPoolVisitorPattern(visitor);
293260 194 : SgDeclType::traverseMemoryPoolVisitorPattern(visitor);
293261 194 : SgTypeOfType::traverseMemoryPoolVisitorPattern(visitor);
293262 194 : SgTypeCAFTeam::traverseMemoryPoolVisitorPattern(visitor);
293263 194 : SgTypeUnsigned128bitInteger::traverseMemoryPoolVisitorPattern(visitor);
293264 194 : SgTypeSigned128bitInteger::traverseMemoryPoolVisitorPattern(visitor);
293265 194 : SgTypeLabel::traverseMemoryPoolVisitorPattern(visitor);
293266 194 : SgTemplateType::traverseMemoryPoolVisitorPattern(visitor);
293267 194 : SgEnumType::traverseMemoryPoolVisitorPattern(visitor);
293268 194 : SgTypedefType::traverseMemoryPoolVisitorPattern(visitor);
293269 194 : SgNonrealType::traverseMemoryPoolVisitorPattern(visitor);
293270 194 : SgAutoType::traverseMemoryPoolVisitorPattern(visitor);
293271 194 : SgModifierType::traverseMemoryPoolVisitorPattern(visitor);
293272 194 : SgPartialFunctionModifierType::traverseMemoryPoolVisitorPattern(visitor);
293273 194 : SgArrayType::traverseMemoryPoolVisitorPattern(visitor);
293274 194 : SgTypeEllipse::traverseMemoryPoolVisitorPattern(visitor);
293275 194 : SgTypeCrayPointer::traverseMemoryPoolVisitorPattern(visitor);
293276 194 : SgPartialFunctionType::traverseMemoryPoolVisitorPattern(visitor);
293277 194 : SgMemberFunctionType::traverseMemoryPoolVisitorPattern(visitor);
293278 194 : SgFunctionType::traverseMemoryPoolVisitorPattern(visitor);
293279 194 : SgPointerType::traverseMemoryPoolVisitorPattern(visitor);
293280 194 : SgClassType::traverseMemoryPoolVisitorPattern(visitor);
293281 194 : SgNamedType::traverseMemoryPoolVisitorPattern(visitor);
293282 194 : SgQualifiedNameType::traverseMemoryPoolVisitorPattern(visitor);
293283 194 : SgTypeChar16::traverseMemoryPoolVisitorPattern(visitor);
293284 194 : SgTypeChar32::traverseMemoryPoolVisitorPattern(visitor);
293285 194 : SgType::traverseMemoryPoolVisitorPattern(visitor);
293286 194 : SgForStatement::traverseMemoryPoolVisitorPattern(visitor);
293287 194 : SgForInitStatement::traverseMemoryPoolVisitorPattern(visitor);
293288 194 : SgRangeBasedForStatement::traverseMemoryPoolVisitorPattern(visitor);
293289 194 : SgCatchStatementSeq::traverseMemoryPoolVisitorPattern(visitor);
293290 194 : SgFunctionParameterList::traverseMemoryPoolVisitorPattern(visitor);
293291 194 : SgCtorInitializerList::traverseMemoryPoolVisitorPattern(visitor);
293292 194 : SgBasicBlock::traverseMemoryPoolVisitorPattern(visitor);
293293 194 : SgGlobal::traverseMemoryPoolVisitorPattern(visitor);
293294 194 : SgIfStmt::traverseMemoryPoolVisitorPattern(visitor);
293295 194 : SgWhileStmt::traverseMemoryPoolVisitorPattern(visitor);
293296 194 : SgDoWhileStmt::traverseMemoryPoolVisitorPattern(visitor);
293297 194 : SgSwitchStatement::traverseMemoryPoolVisitorPattern(visitor);
293298 194 : SgCatchOptionStmt::traverseMemoryPoolVisitorPattern(visitor);
293299 194 : SgFunctionParameterScope::traverseMemoryPoolVisitorPattern(visitor);
293300 194 : SgDeclarationScope::traverseMemoryPoolVisitorPattern(visitor);
293301 194 : SgVariableDefinition::traverseMemoryPoolVisitorPattern(visitor);
293302 194 : SgStmtDeclarationStatement::traverseMemoryPoolVisitorPattern(visitor);
293303 194 : SgEnumDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293304 194 : SgAsmStmt::traverseMemoryPoolVisitorPattern(visitor);
293305 194 : SgFunctionTypeTable::traverseMemoryPoolVisitorPattern(visitor);
293306 194 : SgExprStatement::traverseMemoryPoolVisitorPattern(visitor);
293307 194 : SgLabelStatement::traverseMemoryPoolVisitorPattern(visitor);
293308 194 : SgCaseOptionStmt::traverseMemoryPoolVisitorPattern(visitor);
293309 194 : SgTryStmt::traverseMemoryPoolVisitorPattern(visitor);
293310 194 : SgDefaultOptionStmt::traverseMemoryPoolVisitorPattern(visitor);
293311 194 : SgBreakStmt::traverseMemoryPoolVisitorPattern(visitor);
293312 194 : SgContinueStmt::traverseMemoryPoolVisitorPattern(visitor);
293313 194 : SgReturnStmt::traverseMemoryPoolVisitorPattern(visitor);
293314 194 : SgGotoStatement::traverseMemoryPoolVisitorPattern(visitor);
293315 194 : SgSpawnStmt::traverseMemoryPoolVisitorPattern(visitor);
293316 194 : SgTemplateTypedefDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293317 194 : SgTemplateInstantiationTypedefDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293318 194 : SgTypedefDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293319 194 : SgNullStatement::traverseMemoryPoolVisitorPattern(visitor);
293320 194 : SgVariantStatement::traverseMemoryPoolVisitorPattern(visitor);
293321 194 : SgPragmaDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293322 194 : SgTemplateClassDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293323 194 : SgTemplateMemberFunctionDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293324 194 : SgTemplateFunctionDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293325 194 : SgTemplateVariableDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293326 194 : SgTemplateDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293327 194 : SgVariableDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293328 194 : SgTemplateInstantiationDecl::traverseMemoryPoolVisitorPattern(visitor);
293329 194 : SgTemplateInstantiationDefn::traverseMemoryPoolVisitorPattern(visitor);
293330 194 : SgTemplateInstantiationFunctionDecl::traverseMemoryPoolVisitorPattern(visitor);
293331 194 : SgTemplateInstantiationMemberFunctionDecl::traverseMemoryPoolVisitorPattern(visitor);
293332 194 : SgNonrealDecl::traverseMemoryPoolVisitorPattern(visitor);
293333 194 : SgWithStatement::traverseMemoryPoolVisitorPattern(visitor);
293334 194 : SgPassStatement::traverseMemoryPoolVisitorPattern(visitor);
293335 194 : SgAssertStmt::traverseMemoryPoolVisitorPattern(visitor);
293336 194 : SgExecStatement::traverseMemoryPoolVisitorPattern(visitor);
293337 194 : SgProgramHeaderStatement::traverseMemoryPoolVisitorPattern(visitor);
293338 194 : SgProcedureHeaderStatement::traverseMemoryPoolVisitorPattern(visitor);
293339 194 : SgEntryStatement::traverseMemoryPoolVisitorPattern(visitor);
293340 194 : SgFortranNonblockedDo::traverseMemoryPoolVisitorPattern(visitor);
293341 194 : SgInterfaceStatement::traverseMemoryPoolVisitorPattern(visitor);
293342 194 : SgParameterStatement::traverseMemoryPoolVisitorPattern(visitor);
293343 194 : SgCommonBlock::traverseMemoryPoolVisitorPattern(visitor);
293344 194 : SgModuleStatement::traverseMemoryPoolVisitorPattern(visitor);
293345 194 : SgUseStatement::traverseMemoryPoolVisitorPattern(visitor);
293346 194 : SgProcessControlStatement::traverseMemoryPoolVisitorPattern(visitor);
293347 194 : SgPrintStatement::traverseMemoryPoolVisitorPattern(visitor);
293348 194 : SgReadStatement::traverseMemoryPoolVisitorPattern(visitor);
293349 194 : SgWriteStatement::traverseMemoryPoolVisitorPattern(visitor);
293350 194 : SgOpenStatement::traverseMemoryPoolVisitorPattern(visitor);
293351 194 : SgCloseStatement::traverseMemoryPoolVisitorPattern(visitor);
293352 194 : SgInquireStatement::traverseMemoryPoolVisitorPattern(visitor);
293353 194 : SgFlushStatement::traverseMemoryPoolVisitorPattern(visitor);
293354 194 : SgBackspaceStatement::traverseMemoryPoolVisitorPattern(visitor);
293355 194 : SgRewindStatement::traverseMemoryPoolVisitorPattern(visitor);
293356 194 : SgEndfileStatement::traverseMemoryPoolVisitorPattern(visitor);
293357 194 : SgWaitStatement::traverseMemoryPoolVisitorPattern(visitor);
293358 194 : SgCAFWithTeamStatement::traverseMemoryPoolVisitorPattern(visitor);
293359 194 : SgFormatStatement::traverseMemoryPoolVisitorPattern(visitor);
293360 194 : SgFortranDo::traverseMemoryPoolVisitorPattern(visitor);
293361 194 : SgForAllStatement::traverseMemoryPoolVisitorPattern(visitor);
293362 194 : SgIOStatement::traverseMemoryPoolVisitorPattern(visitor);
293363 194 : SgSyncAllStatement::traverseMemoryPoolVisitorPattern(visitor);
293364 194 : SgSyncImagesStatement::traverseMemoryPoolVisitorPattern(visitor);
293365 194 : SgSyncMemoryStatement::traverseMemoryPoolVisitorPattern(visitor);
293366 194 : SgSyncTeamStatement::traverseMemoryPoolVisitorPattern(visitor);
293367 194 : SgLockStatement::traverseMemoryPoolVisitorPattern(visitor);
293368 194 : SgUnlockStatement::traverseMemoryPoolVisitorPattern(visitor);
293369 194 : SgImageControlStatement::traverseMemoryPoolVisitorPattern(visitor);
293370 194 : SgUpcNotifyStatement::traverseMemoryPoolVisitorPattern(visitor);
293371 194 : SgUpcWaitStatement::traverseMemoryPoolVisitorPattern(visitor);
293372 194 : SgUpcBarrierStatement::traverseMemoryPoolVisitorPattern(visitor);
293373 194 : SgUpcFenceStatement::traverseMemoryPoolVisitorPattern(visitor);
293374 194 : SgUpcForAllStatement::traverseMemoryPoolVisitorPattern(visitor);
293375 194 : SgUpirSpmdStatement::traverseMemoryPoolVisitorPattern(visitor);
293376 194 : SgOmpLoopStatement::traverseMemoryPoolVisitorPattern(visitor);
293377 194 : SgOmpScanStatement::traverseMemoryPoolVisitorPattern(visitor);
293378 194 : SgOmpTaskloopStatement::traverseMemoryPoolVisitorPattern(visitor);
293379 194 : SgOmpTaskgroupStatement::traverseMemoryPoolVisitorPattern(visitor);
293380 194 : SgOmpDepobjStatement::traverseMemoryPoolVisitorPattern(visitor);
293381 194 : SgOmpTeamsStatement::traverseMemoryPoolVisitorPattern(visitor);
293382 194 : SgOmpCancellationPointStatement::traverseMemoryPoolVisitorPattern(visitor);
293383 194 : SgOmpDeclareMapperStatement::traverseMemoryPoolVisitorPattern(visitor);
293384 194 : SgOmpCancelStatement::traverseMemoryPoolVisitorPattern(visitor);
293385 194 : SgOmpDistributeStatement::traverseMemoryPoolVisitorPattern(visitor);
293386 194 : SgOmpMetadirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293387 194 : SgOmpSingleStatement::traverseMemoryPoolVisitorPattern(visitor);
293388 194 : SgOmpTaskStatement::traverseMemoryPoolVisitorPattern(visitor);
293389 194 : SgOmpTargetEnterDataStatement::traverseMemoryPoolVisitorPattern(visitor);
293390 194 : SgOmpTargetExitDataStatement::traverseMemoryPoolVisitorPattern(visitor);
293391 194 : SgUpirWorksharingStatement::traverseMemoryPoolVisitorPattern(visitor);
293392 194 : SgOmpForSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293393 194 : SgOmpDoStatement::traverseMemoryPoolVisitorPattern(visitor);
293394 194 : SgOmpSectionsStatement::traverseMemoryPoolVisitorPattern(visitor);
293395 194 : SgOmpAtomicStatement::traverseMemoryPoolVisitorPattern(visitor);
293396 194 : SgUpirTaskStatement::traverseMemoryPoolVisitorPattern(visitor);
293397 194 : SgOmpTargetDataStatement::traverseMemoryPoolVisitorPattern(visitor);
293398 194 : SgOmpTargetParallelForStatement::traverseMemoryPoolVisitorPattern(visitor);
293399 194 : SgOmpTargetParallelStatement::traverseMemoryPoolVisitorPattern(visitor);
293400 194 : SgOmpDistributeSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293401 194 : SgOmpDistributeParallelForStatement::traverseMemoryPoolVisitorPattern(visitor);
293402 194 : SgOmpDistributeParallelForSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293403 194 : SgOmpTaskloopSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293404 194 : SgOmpTargetUpdateStatement::traverseMemoryPoolVisitorPattern(visitor);
293405 194 : SgOmpTargetParallelForSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293406 194 : SgOmpTargetParallelLoopStatement::traverseMemoryPoolVisitorPattern(visitor);
293407 194 : SgOmpTargetSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293408 194 : SgOmpTargetTeamsStatement::traverseMemoryPoolVisitorPattern(visitor);
293409 194 : SgOmpTargetTeamsDistributeStatement::traverseMemoryPoolVisitorPattern(visitor);
293410 194 : SgOmpTargetTeamsDistributeSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293411 194 : SgOmpTargetTeamsLoopStatement::traverseMemoryPoolVisitorPattern(visitor);
293412 194 : SgOmpTargetTeamsDistributeParallelForStatement::traverseMemoryPoolVisitorPattern(visitor);
293413 194 : SgOmpTargetTeamsDistributeParallelForSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293414 194 : SgOmpMasterTaskloopSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293415 194 : SgOmpParallelMasterTaskloopStatement::traverseMemoryPoolVisitorPattern(visitor);
293416 194 : SgOmpParallelMasterTaskloopSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293417 194 : SgOmpTeamsDistributeStatement::traverseMemoryPoolVisitorPattern(visitor);
293418 194 : SgOmpTeamsDistributeSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293419 194 : SgOmpTeamsDistributeParallelForStatement::traverseMemoryPoolVisitorPattern(visitor);
293420 194 : SgOmpTeamsDistributeParallelForSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293421 194 : SgOmpTeamsLoopStatement::traverseMemoryPoolVisitorPattern(visitor);
293422 194 : SgOmpParallelMasterStatement::traverseMemoryPoolVisitorPattern(visitor);
293423 194 : SgOmpMasterTaskloopStatement::traverseMemoryPoolVisitorPattern(visitor);
293424 194 : SgOmpParallelLoopStatement::traverseMemoryPoolVisitorPattern(visitor);
293425 194 : SgOmpUnrollStatement::traverseMemoryPoolVisitorPattern(visitor);
293426 194 : SgOmpTileStatement::traverseMemoryPoolVisitorPattern(visitor);
293427 194 : SgUpirSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293428 194 : SgOmpCriticalStatement::traverseMemoryPoolVisitorPattern(visitor);
293429 194 : SgOmpOrderedStatement::traverseMemoryPoolVisitorPattern(visitor);
293430 194 : SgUpirLoopStatement::traverseMemoryPoolVisitorPattern(visitor);
293431 194 : SgUpirLoopParallelStatement::traverseMemoryPoolVisitorPattern(visitor);
293432 194 : SgUpirSyncStatement::traverseMemoryPoolVisitorPattern(visitor);
293433 194 : SgUpirFieldBodyStatement::traverseMemoryPoolVisitorPattern(visitor);
293434 194 : SgOmpMasterStatement::traverseMemoryPoolVisitorPattern(visitor);
293435 194 : SgOmpSectionStatement::traverseMemoryPoolVisitorPattern(visitor);
293436 194 : SgOmpWorkshareStatement::traverseMemoryPoolVisitorPattern(visitor);
293437 194 : SgOmpFlushStatement::traverseMemoryPoolVisitorPattern(visitor);
293438 194 : SgOmpAllocateStatement::traverseMemoryPoolVisitorPattern(visitor);
293439 194 : SgOmpOrderedDependStatement::traverseMemoryPoolVisitorPattern(visitor);
293440 194 : SgUpirBodyStatement::traverseMemoryPoolVisitorPattern(visitor);
293441 194 : SgUpirFieldStatement::traverseMemoryPoolVisitorPattern(visitor);
293442 194 : SgBlockDataStatement::traverseMemoryPoolVisitorPattern(visitor);
293443 194 : SgImplicitStatement::traverseMemoryPoolVisitorPattern(visitor);
293444 194 : SgStatementFunctionStatement::traverseMemoryPoolVisitorPattern(visitor);
293445 194 : SgWhereStatement::traverseMemoryPoolVisitorPattern(visitor);
293446 194 : SgNullifyStatement::traverseMemoryPoolVisitorPattern(visitor);
293447 194 : SgEquivalenceStatement::traverseMemoryPoolVisitorPattern(visitor);
293448 194 : SgDerivedTypeStatement::traverseMemoryPoolVisitorPattern(visitor);
293449 194 : SgAttributeSpecificationStatement::traverseMemoryPoolVisitorPattern(visitor);
293450 194 : SgAllocateStatement::traverseMemoryPoolVisitorPattern(visitor);
293451 194 : SgDeallocateStatement::traverseMemoryPoolVisitorPattern(visitor);
293452 194 : SgContainsStatement::traverseMemoryPoolVisitorPattern(visitor);
293453 194 : SgSequenceStatement::traverseMemoryPoolVisitorPattern(visitor);
293454 194 : SgElseWhereStatement::traverseMemoryPoolVisitorPattern(visitor);
293455 194 : SgArithmeticIfStatement::traverseMemoryPoolVisitorPattern(visitor);
293456 194 : SgAssignStatement::traverseMemoryPoolVisitorPattern(visitor);
293457 194 : SgComputedGotoStatement::traverseMemoryPoolVisitorPattern(visitor);
293458 194 : SgAssignedGotoStatement::traverseMemoryPoolVisitorPattern(visitor);
293459 194 : SgNamelistStatement::traverseMemoryPoolVisitorPattern(visitor);
293460 194 : SgImportStatement::traverseMemoryPoolVisitorPattern(visitor);
293461 194 : SgAssociateStatement::traverseMemoryPoolVisitorPattern(visitor);
293462 194 : SgFortranIncludeLine::traverseMemoryPoolVisitorPattern(visitor);
293463 194 : SgNamespaceDeclarationStatement::traverseMemoryPoolVisitorPattern(visitor);
293464 194 : SgNamespaceAliasDeclarationStatement::traverseMemoryPoolVisitorPattern(visitor);
293465 194 : SgNamespaceDefinitionStatement::traverseMemoryPoolVisitorPattern(visitor);
293466 194 : SgUsingDeclarationStatement::traverseMemoryPoolVisitorPattern(visitor);
293467 194 : SgUsingDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293468 194 : SgTemplateInstantiationDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293469 194 : SgStaticAssertionDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293470 194 : SgTemplateClassDefinition::traverseMemoryPoolVisitorPattern(visitor);
293471 194 : SgTemplateFunctionDefinition::traverseMemoryPoolVisitorPattern(visitor);
293472 194 : SgClassDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293473 194 : SgClassDefinition::traverseMemoryPoolVisitorPattern(visitor);
293474 194 : SgFunctionDefinition::traverseMemoryPoolVisitorPattern(visitor);
293475 194 : SgScopeStatement::traverseMemoryPoolVisitorPattern(visitor);
293476 194 : SgMemberFunctionDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293477 194 : SgFunctionDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293478 194 : SgIncludeDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293479 194 : SgDefineDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293480 194 : SgUndefDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293481 194 : SgIfdefDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293482 194 : SgIfndefDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293483 194 : SgIfDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293484 194 : SgDeadIfDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293485 194 : SgElseDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293486 194 : SgElseifDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293487 194 : SgEndifDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293488 194 : SgLineDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293489 194 : SgWarningDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293490 194 : SgErrorDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293491 194 : SgEmptyDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293492 194 : SgIncludeNextDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293493 194 : SgIdentDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293494 194 : SgLinemarkerDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293495 194 : SgC_PreprocessorDirectiveStatement::traverseMemoryPoolVisitorPattern(visitor);
293496 194 : SgClinkageStartStatement::traverseMemoryPoolVisitorPattern(visitor);
293497 194 : SgClinkageEndStatement::traverseMemoryPoolVisitorPattern(visitor);
293498 194 : SgClinkageDeclarationStatement::traverseMemoryPoolVisitorPattern(visitor);
293499 194 : SgOmpDeclareSimdStatement::traverseMemoryPoolVisitorPattern(visitor);
293500 194 : SgOmpBarrierStatement::traverseMemoryPoolVisitorPattern(visitor);
293501 194 : SgOmpTaskyieldStatement::traverseMemoryPoolVisitorPattern(visitor);
293502 194 : SgOmpRequiresStatement::traverseMemoryPoolVisitorPattern(visitor);
293503 194 : SgOmpTaskwaitStatement::traverseMemoryPoolVisitorPattern(visitor);
293504 194 : SgOmpThreadprivateStatement::traverseMemoryPoolVisitorPattern(visitor);
293505 194 : SgMicrosoftAttributeDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293506 194 : SgEmptyDeclaration::traverseMemoryPoolVisitorPattern(visitor);
293507 194 : SgDeclarationStatement::traverseMemoryPoolVisitorPattern(visitor);
293508 194 : SgUpirBaseStatement::traverseMemoryPoolVisitorPattern(visitor);
293509 194 : SgStatement::traverseMemoryPoolVisitorPattern(visitor);
293510 194 : SgVarRefExp::traverseMemoryPoolVisitorPattern(visitor);
293511 194 : SgNonrealRefExp::traverseMemoryPoolVisitorPattern(visitor);
293512 194 : SgCompoundLiteralExp::traverseMemoryPoolVisitorPattern(visitor);
293513 194 : SgLabelRefExp::traverseMemoryPoolVisitorPattern(visitor);
293514 194 : SgClassNameRefExp::traverseMemoryPoolVisitorPattern(visitor);
293515 194 : SgFunctionRefExp::traverseMemoryPoolVisitorPattern(visitor);
293516 194 : SgMemberFunctionRefExp::traverseMemoryPoolVisitorPattern(visitor);
293517 194 : SgTemplateFunctionRefExp::traverseMemoryPoolVisitorPattern(visitor);
293518 194 : SgTemplateMemberFunctionRefExp::traverseMemoryPoolVisitorPattern(visitor);
293519 194 : SgSizeOfOp::traverseMemoryPoolVisitorPattern(visitor);
293520 194 : SgAlignOfOp::traverseMemoryPoolVisitorPattern(visitor);
293521 194 : SgNoexceptOp::traverseMemoryPoolVisitorPattern(visitor);
293522 194 : SgTypeExpression::traverseMemoryPoolVisitorPattern(visitor);
293523 194 : SgLambdaExp::traverseMemoryPoolVisitorPattern(visitor);
293524 194 : SgUpcLocalsizeofExpression::traverseMemoryPoolVisitorPattern(visitor);
293525 194 : SgUpcBlocksizeofExpression::traverseMemoryPoolVisitorPattern(visitor);
293526 194 : SgUpcElemsizeofExpression::traverseMemoryPoolVisitorPattern(visitor);
293527 194 : SgVarArgStartOp::traverseMemoryPoolVisitorPattern(visitor);
293528 194 : SgVarArgStartOneOperandOp::traverseMemoryPoolVisitorPattern(visitor);
293529 194 : SgVarArgOp::traverseMemoryPoolVisitorPattern(visitor);
293530 194 : SgVarArgEndOp::traverseMemoryPoolVisitorPattern(visitor);
293531 194 : SgVarArgCopyOp::traverseMemoryPoolVisitorPattern(visitor);
293532 194 : SgTypeIdOp::traverseMemoryPoolVisitorPattern(visitor);
293533 194 : SgConditionalExp::traverseMemoryPoolVisitorPattern(visitor);
293534 194 : SgNewExp::traverseMemoryPoolVisitorPattern(visitor);
293535 194 : SgDeleteExp::traverseMemoryPoolVisitorPattern(visitor);
293536 194 : SgThisExp::traverseMemoryPoolVisitorPattern(visitor);
293537 194 : SgSuperExp::traverseMemoryPoolVisitorPattern(visitor);
293538 194 : SgClassExp::traverseMemoryPoolVisitorPattern(visitor);
293539 194 : SgRefExp::traverseMemoryPoolVisitorPattern(visitor);
293540 194 : SgAggregateInitializer::traverseMemoryPoolVisitorPattern(visitor);
293541 194 : SgCompoundInitializer::traverseMemoryPoolVisitorPattern(visitor);
293542 194 : SgConstructorInitializer::traverseMemoryPoolVisitorPattern(visitor);
293543 194 : SgAssignInitializer::traverseMemoryPoolVisitorPattern(visitor);
293544 194 : SgBracedInitializer::traverseMemoryPoolVisitorPattern(visitor);
293545 194 : SgExpressionRoot::traverseMemoryPoolVisitorPattern(visitor);
293546 194 : SgMinusOp::traverseMemoryPoolVisitorPattern(visitor);
293547 194 : SgUnaryAddOp::traverseMemoryPoolVisitorPattern(visitor);
293548 194 : SgNotOp::traverseMemoryPoolVisitorPattern(visitor);
293549 194 : SgPointerDerefExp::traverseMemoryPoolVisitorPattern(visitor);
293550 194 : SgAddressOfOp::traverseMemoryPoolVisitorPattern(visitor);
293551 194 : SgMinusMinusOp::traverseMemoryPoolVisitorPattern(visitor);
293552 194 : SgPlusPlusOp::traverseMemoryPoolVisitorPattern(visitor);
293553 194 : SgBitComplementOp::traverseMemoryPoolVisitorPattern(visitor);
293554 194 : SgRealPartOp::traverseMemoryPoolVisitorPattern(visitor);
293555 194 : SgImagPartOp::traverseMemoryPoolVisitorPattern(visitor);
293556 194 : SgConjugateOp::traverseMemoryPoolVisitorPattern(visitor);
293557 194 : SgCastExp::traverseMemoryPoolVisitorPattern(visitor);
293558 194 : SgThrowOp::traverseMemoryPoolVisitorPattern(visitor);
293559 194 : SgArrowExp::traverseMemoryPoolVisitorPattern(visitor);
293560 194 : SgDotExp::traverseMemoryPoolVisitorPattern(visitor);
293561 194 : SgDotStarOp::traverseMemoryPoolVisitorPattern(visitor);
293562 194 : SgArrowStarOp::traverseMemoryPoolVisitorPattern(visitor);
293563 194 : SgEqualityOp::traverseMemoryPoolVisitorPattern(visitor);
293564 194 : SgLessThanOp::traverseMemoryPoolVisitorPattern(visitor);
293565 194 : SgGreaterThanOp::traverseMemoryPoolVisitorPattern(visitor);
293566 194 : SgNotEqualOp::traverseMemoryPoolVisitorPattern(visitor);
293567 194 : SgLessOrEqualOp::traverseMemoryPoolVisitorPattern(visitor);
293568 194 : SgGreaterOrEqualOp::traverseMemoryPoolVisitorPattern(visitor);
293569 194 : SgAddOp::traverseMemoryPoolVisitorPattern(visitor);
293570 194 : SgSubtractOp::traverseMemoryPoolVisitorPattern(visitor);
293571 194 : SgMultiplyOp::traverseMemoryPoolVisitorPattern(visitor);
293572 194 : SgDivideOp::traverseMemoryPoolVisitorPattern(visitor);
293573 194 : SgIntegerDivideOp::traverseMemoryPoolVisitorPattern(visitor);
293574 194 : SgModOp::traverseMemoryPoolVisitorPattern(visitor);
293575 194 : SgAndOp::traverseMemoryPoolVisitorPattern(visitor);
293576 194 : SgOrOp::traverseMemoryPoolVisitorPattern(visitor);
293577 194 : SgBitXorOp::traverseMemoryPoolVisitorPattern(visitor);
293578 194 : SgBitAndOp::traverseMemoryPoolVisitorPattern(visitor);
293579 194 : SgBitOrOp::traverseMemoryPoolVisitorPattern(visitor);
293580 194 : SgBitEqvOp::traverseMemoryPoolVisitorPattern(visitor);
293581 194 : SgCommaOpExp::traverseMemoryPoolVisitorPattern(visitor);
293582 194 : SgLshiftOp::traverseMemoryPoolVisitorPattern(visitor);
293583 194 : SgRshiftOp::traverseMemoryPoolVisitorPattern(visitor);
293584 194 : SgPntrArrRefExp::traverseMemoryPoolVisitorPattern(visitor);
293585 194 : SgScopeOp::traverseMemoryPoolVisitorPattern(visitor);
293586 194 : SgAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293587 194 : SgPlusAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293588 194 : SgMinusAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293589 194 : SgAndAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293590 194 : SgIorAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293591 194 : SgMultAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293592 194 : SgDivAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293593 194 : SgModAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293594 194 : SgXorAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293595 194 : SgLshiftAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293596 194 : SgRshiftAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293597 194 : SgIntegerDivideAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293598 194 : SgExponentiationAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293599 194 : SgConcatenationOp::traverseMemoryPoolVisitorPattern(visitor);
293600 194 : SgNaryComparisonOp::traverseMemoryPoolVisitorPattern(visitor);
293601 194 : SgNaryBooleanOp::traverseMemoryPoolVisitorPattern(visitor);
293602 194 : SgBoolValExp::traverseMemoryPoolVisitorPattern(visitor);
293603 194 : SgStringVal::traverseMemoryPoolVisitorPattern(visitor);
293604 194 : SgShortVal::traverseMemoryPoolVisitorPattern(visitor);
293605 194 : SgCharVal::traverseMemoryPoolVisitorPattern(visitor);
293606 194 : SgUnsignedCharVal::traverseMemoryPoolVisitorPattern(visitor);
293607 194 : SgWcharVal::traverseMemoryPoolVisitorPattern(visitor);
293608 194 : SgChar16Val::traverseMemoryPoolVisitorPattern(visitor);
293609 194 : SgChar32Val::traverseMemoryPoolVisitorPattern(visitor);
293610 194 : SgUnsignedShortVal::traverseMemoryPoolVisitorPattern(visitor);
293611 194 : SgIntVal::traverseMemoryPoolVisitorPattern(visitor);
293612 194 : SgEnumVal::traverseMemoryPoolVisitorPattern(visitor);
293613 194 : SgUnsignedIntVal::traverseMemoryPoolVisitorPattern(visitor);
293614 194 : SgLongIntVal::traverseMemoryPoolVisitorPattern(visitor);
293615 194 : SgLongLongIntVal::traverseMemoryPoolVisitorPattern(visitor);
293616 194 : SgUnsignedLongLongIntVal::traverseMemoryPoolVisitorPattern(visitor);
293617 194 : SgUnsignedLongVal::traverseMemoryPoolVisitorPattern(visitor);
293618 194 : SgFloatVal::traverseMemoryPoolVisitorPattern(visitor);
293619 194 : SgDoubleVal::traverseMemoryPoolVisitorPattern(visitor);
293620 194 : SgLongDoubleVal::traverseMemoryPoolVisitorPattern(visitor);
293621 194 : SgFloat80Val::traverseMemoryPoolVisitorPattern(visitor);
293622 194 : SgFloat128Val::traverseMemoryPoolVisitorPattern(visitor);
293623 194 : SgNullptrValExp::traverseMemoryPoolVisitorPattern(visitor);
293624 194 : SgVoidVal::traverseMemoryPoolVisitorPattern(visitor);
293625 194 : SgFunctionParameterRefExp::traverseMemoryPoolVisitorPattern(visitor);
293626 194 : SgTemplateParameterVal::traverseMemoryPoolVisitorPattern(visitor);
293627 194 : SgUpcThreads::traverseMemoryPoolVisitorPattern(visitor);
293628 194 : SgUpcMythread::traverseMemoryPoolVisitorPattern(visitor);
293629 194 : SgComplexVal::traverseMemoryPoolVisitorPattern(visitor);
293630 194 : SgNullExpression::traverseMemoryPoolVisitorPattern(visitor);
293631 194 : SgVariantExpression::traverseMemoryPoolVisitorPattern(visitor);
293632 194 : SgStatementExpression::traverseMemoryPoolVisitorPattern(visitor);
293633 194 : SgAsmOp::traverseMemoryPoolVisitorPattern(visitor);
293634 194 : SgCudaKernelExecConfig::traverseMemoryPoolVisitorPattern(visitor);
293635 194 : SgCudaKernelCallExp::traverseMemoryPoolVisitorPattern(visitor);
293636 194 : SgLambdaRefExp::traverseMemoryPoolVisitorPattern(visitor);
293637 194 : SgTupleExp::traverseMemoryPoolVisitorPattern(visitor);
293638 194 : SgListExp::traverseMemoryPoolVisitorPattern(visitor);
293639 194 : SgDictionaryExp::traverseMemoryPoolVisitorPattern(visitor);
293640 194 : SgKeyDatumPair::traverseMemoryPoolVisitorPattern(visitor);
293641 194 : SgComprehension::traverseMemoryPoolVisitorPattern(visitor);
293642 194 : SgListComprehension::traverseMemoryPoolVisitorPattern(visitor);
293643 194 : SgSetComprehension::traverseMemoryPoolVisitorPattern(visitor);
293644 194 : SgDictionaryComprehension::traverseMemoryPoolVisitorPattern(visitor);
293645 194 : SgMembershipOp::traverseMemoryPoolVisitorPattern(visitor);
293646 194 : SgNonMembershipOp::traverseMemoryPoolVisitorPattern(visitor);
293647 194 : SgIsOp::traverseMemoryPoolVisitorPattern(visitor);
293648 194 : SgIsNotOp::traverseMemoryPoolVisitorPattern(visitor);
293649 194 : SgStringConversion::traverseMemoryPoolVisitorPattern(visitor);
293650 194 : SgYieldExpression::traverseMemoryPoolVisitorPattern(visitor);
293651 194 : SgFoldExpression::traverseMemoryPoolVisitorPattern(visitor);
293652 194 : SgChooseExpression::traverseMemoryPoolVisitorPattern(visitor);
293653 194 : SgAwaitExpression::traverseMemoryPoolVisitorPattern(visitor);
293654 194 : SgSpaceshipOp::traverseMemoryPoolVisitorPattern(visitor);
293655 194 : SgSubscriptExpression::traverseMemoryPoolVisitorPattern(visitor);
293656 194 : SgColonShapeExp::traverseMemoryPoolVisitorPattern(visitor);
293657 194 : SgAsteriskShapeExp::traverseMemoryPoolVisitorPattern(visitor);
293658 194 : SgIOItemExpression::traverseMemoryPoolVisitorPattern(visitor);
293659 194 : SgImpliedDo::traverseMemoryPoolVisitorPattern(visitor);
293660 194 : SgExponentiationOp::traverseMemoryPoolVisitorPattern(visitor);
293661 194 : SgUnknownArrayOrFunctionReference::traverseMemoryPoolVisitorPattern(visitor);
293662 194 : SgActualArgumentExpression::traverseMemoryPoolVisitorPattern(visitor);
293663 194 : SgUserDefinedBinaryOp::traverseMemoryPoolVisitorPattern(visitor);
293664 194 : SgPointerAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293665 194 : SgCAFCoExpression::traverseMemoryPoolVisitorPattern(visitor);
293666 194 : SgDesignatedInitializer::traverseMemoryPoolVisitorPattern(visitor);
293667 194 : SgMatrixExp::traverseMemoryPoolVisitorPattern(visitor);
293668 194 : SgRangeExp::traverseMemoryPoolVisitorPattern(visitor);
293669 194 : SgMagicColonExp::traverseMemoryPoolVisitorPattern(visitor);
293670 194 : SgElementwiseMultiplyOp::traverseMemoryPoolVisitorPattern(visitor);
293671 194 : SgPowerOp::traverseMemoryPoolVisitorPattern(visitor);
293672 194 : SgElementwisePowerOp::traverseMemoryPoolVisitorPattern(visitor);
293673 194 : SgElementwiseDivideOp::traverseMemoryPoolVisitorPattern(visitor);
293674 194 : SgLeftDivideOp::traverseMemoryPoolVisitorPattern(visitor);
293675 194 : SgElementwiseLeftDivideOp::traverseMemoryPoolVisitorPattern(visitor);
293676 194 : SgElementwiseAddOp::traverseMemoryPoolVisitorPattern(visitor);
293677 194 : SgElementwiseSubtractOp::traverseMemoryPoolVisitorPattern(visitor);
293678 194 : SgMatrixTransposeOp::traverseMemoryPoolVisitorPattern(visitor);
293679 194 : SgElementwiseOp::traverseMemoryPoolVisitorPattern(visitor);
293680 194 : SgInitializer::traverseMemoryPoolVisitorPattern(visitor);
293681 194 : SgSIMDLoad::traverseMemoryPoolVisitorPattern(visitor);
293682 194 : SgSIMDBroadcast::traverseMemoryPoolVisitorPattern(visitor);
293683 194 : SgSIMDStore::traverseMemoryPoolVisitorPattern(visitor);
293684 194 : SgSIMDPartialStore::traverseMemoryPoolVisitorPattern(visitor);
293685 194 : SgSIMDScalarStore::traverseMemoryPoolVisitorPattern(visitor);
293686 194 : SgSIMDGather::traverseMemoryPoolVisitorPattern(visitor);
293687 194 : SgSIMDExplicitGather::traverseMemoryPoolVisitorPattern(visitor);
293688 194 : SgSIMDScatter::traverseMemoryPoolVisitorPattern(visitor);
293689 194 : SgSIMDAddOp::traverseMemoryPoolVisitorPattern(visitor);
293690 194 : SgSIMDSubOp::traverseMemoryPoolVisitorPattern(visitor);
293691 194 : SgSIMDMulOp::traverseMemoryPoolVisitorPattern(visitor);
293692 194 : SgSIMDDivOp::traverseMemoryPoolVisitorPattern(visitor);
293693 194 : SgSIMDFmaOp::traverseMemoryPoolVisitorPattern(visitor);
293694 194 : SgSIMDBinaryOp::traverseMemoryPoolVisitorPattern(visitor);
293695 194 : SgUserDefinedUnaryOp::traverseMemoryPoolVisitorPattern(visitor);
293696 194 : SgPseudoDestructorRefExp::traverseMemoryPoolVisitorPattern(visitor);
293697 194 : SgUnaryOp::traverseMemoryPoolVisitorPattern(visitor);
293698 194 : SgCompoundAssignOp::traverseMemoryPoolVisitorPattern(visitor);
293699 194 : SgBinaryOp::traverseMemoryPoolVisitorPattern(visitor);
293700 194 : SgNaryOp::traverseMemoryPoolVisitorPattern(visitor);
293701 194 : SgValueExp::traverseMemoryPoolVisitorPattern(visitor);
293702 194 : SgExprListExp::traverseMemoryPoolVisitorPattern(visitor);
293703 194 : SgFunctionCallExp::traverseMemoryPoolVisitorPattern(visitor);
293704 194 : SgCallExpression::traverseMemoryPoolVisitorPattern(visitor);
293705 194 : SgTypeTraitBuiltinOperator::traverseMemoryPoolVisitorPattern(visitor);
293706 194 : SgExpression::traverseMemoryPoolVisitorPattern(visitor);
293707 194 : SgTemplateVariableSymbol::traverseMemoryPoolVisitorPattern(visitor);
293708 194 : SgVariableSymbol::traverseMemoryPoolVisitorPattern(visitor);
293709 194 : SgFunctionTypeSymbol::traverseMemoryPoolVisitorPattern(visitor);
293710 194 : SgTemplateClassSymbol::traverseMemoryPoolVisitorPattern(visitor);
293711 194 : SgClassSymbol::traverseMemoryPoolVisitorPattern(visitor);
293712 194 : SgTemplateSymbol::traverseMemoryPoolVisitorPattern(visitor);
293713 194 : SgEnumSymbol::traverseMemoryPoolVisitorPattern(visitor);
293714 194 : SgEnumFieldSymbol::traverseMemoryPoolVisitorPattern(visitor);
293715 194 : SgTemplateTypedefSymbol::traverseMemoryPoolVisitorPattern(visitor);
293716 194 : SgTypedefSymbol::traverseMemoryPoolVisitorPattern(visitor);
293717 194 : SgTemplateFunctionSymbol::traverseMemoryPoolVisitorPattern(visitor);
293718 194 : SgTemplateMemberFunctionSymbol::traverseMemoryPoolVisitorPattern(visitor);
293719 194 : SgLabelSymbol::traverseMemoryPoolVisitorPattern(visitor);
293720 194 : SgDefaultSymbol::traverseMemoryPoolVisitorPattern(visitor);
293721 194 : SgNamespaceSymbol::traverseMemoryPoolVisitorPattern(visitor);
293722 194 : SgIntrinsicSymbol::traverseMemoryPoolVisitorPattern(visitor);
293723 194 : SgModuleSymbol::traverseMemoryPoolVisitorPattern(visitor);
293724 194 : SgInterfaceSymbol::traverseMemoryPoolVisitorPattern(visitor);
293725 194 : SgCommonSymbol::traverseMemoryPoolVisitorPattern(visitor);
293726 194 : SgRenameSymbol::traverseMemoryPoolVisitorPattern(visitor);
293727 194 : SgMemberFunctionSymbol::traverseMemoryPoolVisitorPattern(visitor);
293728 194 : SgFunctionSymbol::traverseMemoryPoolVisitorPattern(visitor);
293729 194 : SgAliasSymbol::traverseMemoryPoolVisitorPattern(visitor);
293730 194 : SgNonrealSymbol::traverseMemoryPoolVisitorPattern(visitor);
293731 194 : SgSymbol::traverseMemoryPoolVisitorPattern(visitor);
293732 194 : SgCommonBlockObject::traverseMemoryPoolVisitorPattern(visitor);
293733 194 : SgInitializedName::traverseMemoryPoolVisitorPattern(visitor);
293734 194 : SgLambdaCapture::traverseMemoryPoolVisitorPattern(visitor);
293735 194 : SgLambdaCaptureList::traverseMemoryPoolVisitorPattern(visitor);
293736 194 : SgOmpOrderedClause::traverseMemoryPoolVisitorPattern(visitor);
293737 194 : SgOmpNowaitClause::traverseMemoryPoolVisitorPattern(visitor);
293738 194 : SgOmpNogroupClause::traverseMemoryPoolVisitorPattern(visitor);
293739 194 : SgOmpReadClause::traverseMemoryPoolVisitorPattern(visitor);
293740 194 : SgOmpThreadsClause::traverseMemoryPoolVisitorPattern(visitor);
293741 194 : SgOmpSimdClause::traverseMemoryPoolVisitorPattern(visitor);
293742 194 : SgOmpReverseOffloadClause::traverseMemoryPoolVisitorPattern(visitor);
293743 194 : SgOmpExtImplementationDefinedRequirementClause::traverseMemoryPoolVisitorPattern(visitor);
293744 194 : SgOmpUnifiedAddressClause::traverseMemoryPoolVisitorPattern(visitor);
293745 194 : SgOmpUnifiedSharedMemoryClause::traverseMemoryPoolVisitorPattern(visitor);
293746 194 : SgOmpDynamicAllocatorsClause::traverseMemoryPoolVisitorPattern(visitor);
293747 194 : SgOmpAtomicDefaultMemOrderClause::traverseMemoryPoolVisitorPattern(visitor);
293748 194 : SgOmpWriteClause::traverseMemoryPoolVisitorPattern(visitor);
293749 194 : SgOmpUpdateClause::traverseMemoryPoolVisitorPattern(visitor);
293750 194 : SgOmpDepobjUpdateClause::traverseMemoryPoolVisitorPattern(visitor);
293751 194 : SgOmpDestroyClause::traverseMemoryPoolVisitorPattern(visitor);
293752 194 : SgOmpCaptureClause::traverseMemoryPoolVisitorPattern(visitor);
293753 194 : SgOmpSeqCstClause::traverseMemoryPoolVisitorPattern(visitor);
293754 194 : SgOmpAcqRelClause::traverseMemoryPoolVisitorPattern(visitor);
293755 194 : SgOmpReleaseClause::traverseMemoryPoolVisitorPattern(visitor);
293756 194 : SgOmpAcquireClause::traverseMemoryPoolVisitorPattern(visitor);
293757 194 : SgOmpRelaxedClause::traverseMemoryPoolVisitorPattern(visitor);
293758 194 : SgOmpParallelClause::traverseMemoryPoolVisitorPattern(visitor);
293759 194 : SgOmpSectionsClause::traverseMemoryPoolVisitorPattern(visitor);
293760 194 : SgOmpForClause::traverseMemoryPoolVisitorPattern(visitor);
293761 194 : SgOmpTaskgroupClause::traverseMemoryPoolVisitorPattern(visitor);
293762 194 : SgOmpBeginClause::traverseMemoryPoolVisitorPattern(visitor);
293763 194 : SgOmpEndClause::traverseMemoryPoolVisitorPattern(visitor);
293764 194 : SgOmpUntiedClause::traverseMemoryPoolVisitorPattern(visitor);
293765 194 : SgOmpMergeableClause::traverseMemoryPoolVisitorPattern(visitor);
293766 194 : SgOmpDefaultClause::traverseMemoryPoolVisitorPattern(visitor);
293767 194 : SgOmpAtomicClause::traverseMemoryPoolVisitorPattern(visitor);
293768 194 : SgOmpProcBindClause::traverseMemoryPoolVisitorPattern(visitor);
293769 194 : SgOmpOrderClause::traverseMemoryPoolVisitorPattern(visitor);
293770 194 : SgOmpBindClause::traverseMemoryPoolVisitorPattern(visitor);
293771 194 : SgOmpInbranchClause::traverseMemoryPoolVisitorPattern(visitor);
293772 194 : SgOmpNotinbranchClause::traverseMemoryPoolVisitorPattern(visitor);
293773 194 : SgOmpCollapseClause::traverseMemoryPoolVisitorPattern(visitor);
293774 194 : SgOmpIfClause::traverseMemoryPoolVisitorPattern(visitor);
293775 194 : SgOmpFinalClause::traverseMemoryPoolVisitorPattern(visitor);
293776 194 : SgOmpPriorityClause::traverseMemoryPoolVisitorPattern(visitor);
293777 194 : SgUpirNumUnitsField::traverseMemoryPoolVisitorPattern(visitor);
293778 194 : SgOmpNumTeamsClause::traverseMemoryPoolVisitorPattern(visitor);
293779 194 : SgOmpGrainsizeClause::traverseMemoryPoolVisitorPattern(visitor);
293780 194 : SgOmpDetachClause::traverseMemoryPoolVisitorPattern(visitor);
293781 194 : SgOmpNumTasksClause::traverseMemoryPoolVisitorPattern(visitor);
293782 194 : SgOmpHintClause::traverseMemoryPoolVisitorPattern(visitor);
293783 194 : SgOmpThreadLimitClause::traverseMemoryPoolVisitorPattern(visitor);
293784 194 : SgOmpNontemporalClause::traverseMemoryPoolVisitorPattern(visitor);
293785 194 : SgOmpInclusiveClause::traverseMemoryPoolVisitorPattern(visitor);
293786 194 : SgOmpExclusiveClause::traverseMemoryPoolVisitorPattern(visitor);
293787 194 : SgOmpIsDevicePtrClause::traverseMemoryPoolVisitorPattern(visitor);
293788 194 : SgOmpUseDevicePtrClause::traverseMemoryPoolVisitorPattern(visitor);
293789 194 : SgOmpUseDeviceAddrClause::traverseMemoryPoolVisitorPattern(visitor);
293790 194 : SgOmpDeviceClause::traverseMemoryPoolVisitorPattern(visitor);
293791 194 : SgOmpSafelenClause::traverseMemoryPoolVisitorPattern(visitor);
293792 194 : SgOmpSimdlenClause::traverseMemoryPoolVisitorPattern(visitor);
293793 194 : SgOmpPartialClause::traverseMemoryPoolVisitorPattern(visitor);
293794 194 : SgOmpFullClause::traverseMemoryPoolVisitorPattern(visitor);
293795 194 : SgOmpSizesClause::traverseMemoryPoolVisitorPattern(visitor);
293796 194 : SgUpirBranchField::traverseMemoryPoolVisitorPattern(visitor);
293797 194 : SgUpirNestedLevelField::traverseMemoryPoolVisitorPattern(visitor);
293798 194 : SgUpirNestedParentField::traverseMemoryPoolVisitorPattern(visitor);
293799 194 : SgUpirNestedChildField::traverseMemoryPoolVisitorPattern(visitor);
293800 194 : SgUpirSyncField::traverseMemoryPoolVisitorPattern(visitor);
293801 194 : SgUpirDataField::traverseMemoryPoolVisitorPattern(visitor);
293802 194 : SgUpirTargetField::traverseMemoryPoolVisitorPattern(visitor);
293803 194 : SgUpirDataItemField::traverseMemoryPoolVisitorPattern(visitor);
293804 194 : SgOmpExpressionClause::traverseMemoryPoolVisitorPattern(visitor);
293805 194 : SgOmpCopyprivateClause::traverseMemoryPoolVisitorPattern(visitor);
293806 194 : SgOmpPrivateClause::traverseMemoryPoolVisitorPattern(visitor);
293807 194 : SgOmpFirstprivateClause::traverseMemoryPoolVisitorPattern(visitor);
293808 194 : SgOmpSharedClause::traverseMemoryPoolVisitorPattern(visitor);
293809 194 : SgOmpCopyinClause::traverseMemoryPoolVisitorPattern(visitor);
293810 194 : SgOmpLastprivateClause::traverseMemoryPoolVisitorPattern(visitor);
293811 194 : SgOmpReductionClause::traverseMemoryPoolVisitorPattern(visitor);
293812 194 : SgOmpInReductionClause::traverseMemoryPoolVisitorPattern(visitor);
293813 194 : SgOmpTaskReductionClause::traverseMemoryPoolVisitorPattern(visitor);
293814 194 : SgOmpAllocateClause::traverseMemoryPoolVisitorPattern(visitor);
293815 194 : SgOmpDependClause::traverseMemoryPoolVisitorPattern(visitor);
293816 194 : SgOmpToClause::traverseMemoryPoolVisitorPattern(visitor);
293817 194 : SgOmpUsesAllocatorsClause::traverseMemoryPoolVisitorPattern(visitor);
293818 194 : SgOmpFromClause::traverseMemoryPoolVisitorPattern(visitor);
293819 194 : SgOmpAffinityClause::traverseMemoryPoolVisitorPattern(visitor);
293820 194 : SgOmpMapClause::traverseMemoryPoolVisitorPattern(visitor);
293821 194 : SgOmpLinearClause::traverseMemoryPoolVisitorPattern(visitor);
293822 194 : SgOmpUniformClause::traverseMemoryPoolVisitorPattern(visitor);
293823 194 : SgOmpAlignedClause::traverseMemoryPoolVisitorPattern(visitor);
293824 194 : SgOmpVariablesClause::traverseMemoryPoolVisitorPattern(visitor);
293825 194 : SgOmpScheduleClause::traverseMemoryPoolVisitorPattern(visitor);
293826 194 : SgOmpWhenClause::traverseMemoryPoolVisitorPattern(visitor);
293827 194 : SgOmpDistScheduleClause::traverseMemoryPoolVisitorPattern(visitor);
293828 194 : SgOmpDefaultmapClause::traverseMemoryPoolVisitorPattern(visitor);
293829 194 : SgOmpAllocatorClause::traverseMemoryPoolVisitorPattern(visitor);
293830 194 : SgOmpUsesAllocatorsDefination::traverseMemoryPoolVisitorPattern(visitor);
293831 194 : SgOmpClause::traverseMemoryPoolVisitorPattern(visitor);
293832 194 : SgRenamePair::traverseMemoryPoolVisitorPattern(visitor);
293833 194 : SgInterfaceBody::traverseMemoryPoolVisitorPattern(visitor);
293834 194 : SgHeaderFileBody::traverseMemoryPoolVisitorPattern(visitor);
293835 194 : SgLocatedNodeSupport::traverseMemoryPoolVisitorPattern(visitor);
293836 194 : SgToken::traverseMemoryPoolVisitorPattern(visitor);
293837 194 : SgLocatedNode::traverseMemoryPoolVisitorPattern(visitor);
293838 194 : SgNode::traverseMemoryPoolVisitorPattern(visitor);
293839 194 : }
293840 :
293841 :
293842 :
293843 5342 : void traverseMemoryPoolNodes ( ROSE_VisitTraversal & visit )
293844 : {
293845 5342 : SgName::traverseMemoryPoolNodes(visit);
293846 5342 : SgSymbolTable::traverseMemoryPoolNodes(visit);
293847 5342 : SgPragma::traverseMemoryPoolNodes(visit);
293848 5342 : SgModifierNodes::traverseMemoryPoolNodes(visit);
293849 5342 : SgConstVolatileModifier::traverseMemoryPoolNodes(visit);
293850 5342 : SgStorageModifier::traverseMemoryPoolNodes(visit);
293851 5342 : SgAccessModifier::traverseMemoryPoolNodes(visit);
293852 5342 : SgFunctionModifier::traverseMemoryPoolNodes(visit);
293853 5342 : SgUPC_AccessModifier::traverseMemoryPoolNodes(visit);
293854 5342 : SgLinkageModifier::traverseMemoryPoolNodes(visit);
293855 5342 : SgSpecialFunctionModifier::traverseMemoryPoolNodes(visit);
293856 5342 : SgTypeModifier::traverseMemoryPoolNodes(visit);
293857 5342 : SgElaboratedTypeModifier::traverseMemoryPoolNodes(visit);
293858 5342 : SgBaseClassModifier::traverseMemoryPoolNodes(visit);
293859 5342 : SgDeclarationModifier::traverseMemoryPoolNodes(visit);
293860 5342 : SgStructureModifier::traverseMemoryPoolNodes(visit);
293861 5342 : SgOpenclAccessModeModifier::traverseMemoryPoolNodes(visit);
293862 5342 : SgModifier::traverseMemoryPoolNodes(visit);
293863 5342 : Sg_File_Info::traverseMemoryPoolNodes(visit);
293864 5342 : SgSourceFile::traverseMemoryPoolNodes(visit);
293865 5342 : SgUnknownFile::traverseMemoryPoolNodes(visit);
293866 5342 : SgFile::traverseMemoryPoolNodes(visit);
293867 5342 : SgFileList::traverseMemoryPoolNodes(visit);
293868 5342 : SgDirectory::traverseMemoryPoolNodes(visit);
293869 5342 : SgDirectoryList::traverseMemoryPoolNodes(visit);
293870 5342 : SgProject::traverseMemoryPoolNodes(visit);
293871 5342 : SgOptions::traverseMemoryPoolNodes(visit);
293872 5342 : SgUnparse_Info::traverseMemoryPoolNodes(visit);
293873 5342 : SgIncludeFile::traverseMemoryPoolNodes(visit);
293874 5342 : SgFuncDecl_attr::traverseMemoryPoolNodes(visit);
293875 5342 : SgClassDecl_attr::traverseMemoryPoolNodes(visit);
293876 5342 : SgTypedefSeq::traverseMemoryPoolNodes(visit);
293877 5342 : SgFunctionParameterTypeList::traverseMemoryPoolNodes(visit);
293878 5342 : SgTemplateParameter::traverseMemoryPoolNodes(visit);
293879 5342 : SgTemplateArgument::traverseMemoryPoolNodes(visit);
293880 5342 : SgTemplateParameterList::traverseMemoryPoolNodes(visit);
293881 5342 : SgTemplateArgumentList::traverseMemoryPoolNodes(visit);
293882 5342 : SgBitAttribute::traverseMemoryPoolNodes(visit);
293883 5342 : SgAttribute::traverseMemoryPoolNodes(visit);
293884 5342 : SgExpBaseClass::traverseMemoryPoolNodes(visit);
293885 5342 : SgNonrealBaseClass::traverseMemoryPoolNodes(visit);
293886 5342 : SgBaseClass::traverseMemoryPoolNodes(visit);
293887 5342 : SgUndirectedGraphEdge::traverseMemoryPoolNodes(visit);
293888 5342 : SgDirectedGraphEdge::traverseMemoryPoolNodes(visit);
293889 5342 : SgGraphNode::traverseMemoryPoolNodes(visit);
293890 5342 : SgGraphEdge::traverseMemoryPoolNodes(visit);
293891 5342 : SgStringKeyedBidirectionalGraph::traverseMemoryPoolNodes(visit);
293892 5342 : SgIntKeyedBidirectionalGraph::traverseMemoryPoolNodes(visit);
293893 5342 : SgBidirectionalGraph::traverseMemoryPoolNodes(visit);
293894 5342 : SgIncidenceDirectedGraph::traverseMemoryPoolNodes(visit);
293895 5342 : SgIncidenceUndirectedGraph::traverseMemoryPoolNodes(visit);
293896 5342 : SgGraph::traverseMemoryPoolNodes(visit);
293897 5342 : SgGraphNodeList::traverseMemoryPoolNodes(visit);
293898 5342 : SgGraphEdgeList::traverseMemoryPoolNodes(visit);
293899 5342 : SgQualifiedName::traverseMemoryPoolNodes(visit);
293900 5342 : SgNameGroup::traverseMemoryPoolNodes(visit);
293901 5342 : SgDimensionObject::traverseMemoryPoolNodes(visit);
293902 5342 : SgDataStatementGroup::traverseMemoryPoolNodes(visit);
293903 5342 : SgDataStatementObject::traverseMemoryPoolNodes(visit);
293904 5342 : SgDataStatementValue::traverseMemoryPoolNodes(visit);
293905 5342 : SgFormatItem::traverseMemoryPoolNodes(visit);
293906 5342 : SgFormatItemList::traverseMemoryPoolNodes(visit);
293907 5342 : SgTypeTable::traverseMemoryPoolNodes(visit);
293908 5342 : SgHeaderFileReport::traverseMemoryPoolNodes(visit);
293909 5342 : SgSupport::traverseMemoryPoolNodes(visit);
293910 5342 : SgTypeUnknown::traverseMemoryPoolNodes(visit);
293911 5342 : SgTypeChar::traverseMemoryPoolNodes(visit);
293912 5342 : SgTypeSignedChar::traverseMemoryPoolNodes(visit);
293913 5342 : SgTypeUnsignedChar::traverseMemoryPoolNodes(visit);
293914 5342 : SgTypeShort::traverseMemoryPoolNodes(visit);
293915 5342 : SgTypeSignedShort::traverseMemoryPoolNodes(visit);
293916 5342 : SgTypeUnsignedShort::traverseMemoryPoolNodes(visit);
293917 5342 : SgTypeInt::traverseMemoryPoolNodes(visit);
293918 5342 : SgTypeSignedInt::traverseMemoryPoolNodes(visit);
293919 5342 : SgTypeUnsignedInt::traverseMemoryPoolNodes(visit);
293920 5342 : SgTypeLong::traverseMemoryPoolNodes(visit);
293921 5342 : SgTypeSignedLong::traverseMemoryPoolNodes(visit);
293922 5342 : SgTypeUnsignedLong::traverseMemoryPoolNodes(visit);
293923 5342 : SgTypeVoid::traverseMemoryPoolNodes(visit);
293924 5342 : SgTypeGlobalVoid::traverseMemoryPoolNodes(visit);
293925 5342 : SgTypeWchar::traverseMemoryPoolNodes(visit);
293926 5342 : SgTypeFloat::traverseMemoryPoolNodes(visit);
293927 5342 : SgTypeDouble::traverseMemoryPoolNodes(visit);
293928 5342 : SgTypeLongLong::traverseMemoryPoolNodes(visit);
293929 5342 : SgTypeSignedLongLong::traverseMemoryPoolNodes(visit);
293930 5342 : SgTypeUnsignedLongLong::traverseMemoryPoolNodes(visit);
293931 5342 : SgTypeLongDouble::traverseMemoryPoolNodes(visit);
293932 5342 : SgTypeFloat80::traverseMemoryPoolNodes(visit);
293933 5342 : SgTypeFloat128::traverseMemoryPoolNodes(visit);
293934 5342 : SgTypeString::traverseMemoryPoolNodes(visit);
293935 5342 : SgTypeBool::traverseMemoryPoolNodes(visit);
293936 5342 : SgTypeFixed::traverseMemoryPoolNodes(visit);
293937 5342 : SgTypeMatrix::traverseMemoryPoolNodes(visit);
293938 5342 : SgTypeTuple::traverseMemoryPoolNodes(visit);
293939 5342 : SgTypeNullptr::traverseMemoryPoolNodes(visit);
293940 5342 : SgTypeComplex::traverseMemoryPoolNodes(visit);
293941 5342 : SgTypeImaginary::traverseMemoryPoolNodes(visit);
293942 5342 : SgTypeDefault::traverseMemoryPoolNodes(visit);
293943 5342 : SgPointerMemberType::traverseMemoryPoolNodes(visit);
293944 5342 : SgReferenceType::traverseMemoryPoolNodes(visit);
293945 5342 : SgRvalueReferenceType::traverseMemoryPoolNodes(visit);
293946 5342 : SgDeclType::traverseMemoryPoolNodes(visit);
293947 5342 : SgTypeOfType::traverseMemoryPoolNodes(visit);
293948 5342 : SgTypeCAFTeam::traverseMemoryPoolNodes(visit);
293949 5342 : SgTypeUnsigned128bitInteger::traverseMemoryPoolNodes(visit);
293950 5342 : SgTypeSigned128bitInteger::traverseMemoryPoolNodes(visit);
293951 5342 : SgTypeLabel::traverseMemoryPoolNodes(visit);
293952 5342 : SgTemplateType::traverseMemoryPoolNodes(visit);
293953 5342 : SgEnumType::traverseMemoryPoolNodes(visit);
293954 5342 : SgTypedefType::traverseMemoryPoolNodes(visit);
293955 5342 : SgNonrealType::traverseMemoryPoolNodes(visit);
293956 5342 : SgAutoType::traverseMemoryPoolNodes(visit);
293957 5342 : SgModifierType::traverseMemoryPoolNodes(visit);
293958 5342 : SgPartialFunctionModifierType::traverseMemoryPoolNodes(visit);
293959 5342 : SgArrayType::traverseMemoryPoolNodes(visit);
293960 5342 : SgTypeEllipse::traverseMemoryPoolNodes(visit);
293961 5342 : SgTypeCrayPointer::traverseMemoryPoolNodes(visit);
293962 5342 : SgPartialFunctionType::traverseMemoryPoolNodes(visit);
293963 5342 : SgMemberFunctionType::traverseMemoryPoolNodes(visit);
293964 5342 : SgFunctionType::traverseMemoryPoolNodes(visit);
293965 5342 : SgPointerType::traverseMemoryPoolNodes(visit);
293966 5342 : SgClassType::traverseMemoryPoolNodes(visit);
293967 5342 : SgNamedType::traverseMemoryPoolNodes(visit);
293968 5342 : SgQualifiedNameType::traverseMemoryPoolNodes(visit);
293969 5342 : SgTypeChar16::traverseMemoryPoolNodes(visit);
293970 5342 : SgTypeChar32::traverseMemoryPoolNodes(visit);
293971 5342 : SgType::traverseMemoryPoolNodes(visit);
293972 5342 : SgForStatement::traverseMemoryPoolNodes(visit);
293973 5342 : SgForInitStatement::traverseMemoryPoolNodes(visit);
293974 5342 : SgRangeBasedForStatement::traverseMemoryPoolNodes(visit);
293975 5342 : SgCatchStatementSeq::traverseMemoryPoolNodes(visit);
293976 5342 : SgFunctionParameterList::traverseMemoryPoolNodes(visit);
293977 5342 : SgCtorInitializerList::traverseMemoryPoolNodes(visit);
293978 5342 : SgBasicBlock::traverseMemoryPoolNodes(visit);
293979 5342 : SgGlobal::traverseMemoryPoolNodes(visit);
293980 5342 : SgIfStmt::traverseMemoryPoolNodes(visit);
293981 5342 : SgWhileStmt::traverseMemoryPoolNodes(visit);
293982 5342 : SgDoWhileStmt::traverseMemoryPoolNodes(visit);
293983 5342 : SgSwitchStatement::traverseMemoryPoolNodes(visit);
293984 5342 : SgCatchOptionStmt::traverseMemoryPoolNodes(visit);
293985 5342 : SgFunctionParameterScope::traverseMemoryPoolNodes(visit);
293986 5342 : SgDeclarationScope::traverseMemoryPoolNodes(visit);
293987 5342 : SgVariableDefinition::traverseMemoryPoolNodes(visit);
293988 5342 : SgStmtDeclarationStatement::traverseMemoryPoolNodes(visit);
293989 5342 : SgEnumDeclaration::traverseMemoryPoolNodes(visit);
293990 5342 : SgAsmStmt::traverseMemoryPoolNodes(visit);
293991 5342 : SgFunctionTypeTable::traverseMemoryPoolNodes(visit);
293992 5342 : SgExprStatement::traverseMemoryPoolNodes(visit);
293993 5342 : SgLabelStatement::traverseMemoryPoolNodes(visit);
293994 5342 : SgCaseOptionStmt::traverseMemoryPoolNodes(visit);
293995 5342 : SgTryStmt::traverseMemoryPoolNodes(visit);
293996 5342 : SgDefaultOptionStmt::traverseMemoryPoolNodes(visit);
293997 5342 : SgBreakStmt::traverseMemoryPoolNodes(visit);
293998 5342 : SgContinueStmt::traverseMemoryPoolNodes(visit);
293999 5342 : SgReturnStmt::traverseMemoryPoolNodes(visit);
294000 5342 : SgGotoStatement::traverseMemoryPoolNodes(visit);
294001 5342 : SgSpawnStmt::traverseMemoryPoolNodes(visit);
294002 5342 : SgTemplateTypedefDeclaration::traverseMemoryPoolNodes(visit);
294003 5342 : SgTemplateInstantiationTypedefDeclaration::traverseMemoryPoolNodes(visit);
294004 5342 : SgTypedefDeclaration::traverseMemoryPoolNodes(visit);
294005 5342 : SgNullStatement::traverseMemoryPoolNodes(visit);
294006 5342 : SgVariantStatement::traverseMemoryPoolNodes(visit);
294007 5342 : SgPragmaDeclaration::traverseMemoryPoolNodes(visit);
294008 5342 : SgTemplateClassDeclaration::traverseMemoryPoolNodes(visit);
294009 5342 : SgTemplateMemberFunctionDeclaration::traverseMemoryPoolNodes(visit);
294010 5342 : SgTemplateFunctionDeclaration::traverseMemoryPoolNodes(visit);
294011 5342 : SgTemplateVariableDeclaration::traverseMemoryPoolNodes(visit);
294012 5342 : SgTemplateDeclaration::traverseMemoryPoolNodes(visit);
294013 5342 : SgVariableDeclaration::traverseMemoryPoolNodes(visit);
294014 5342 : SgTemplateInstantiationDecl::traverseMemoryPoolNodes(visit);
294015 5342 : SgTemplateInstantiationDefn::traverseMemoryPoolNodes(visit);
294016 5342 : SgTemplateInstantiationFunctionDecl::traverseMemoryPoolNodes(visit);
294017 5342 : SgTemplateInstantiationMemberFunctionDecl::traverseMemoryPoolNodes(visit);
294018 5342 : SgNonrealDecl::traverseMemoryPoolNodes(visit);
294019 5342 : SgWithStatement::traverseMemoryPoolNodes(visit);
294020 5342 : SgPassStatement::traverseMemoryPoolNodes(visit);
294021 5342 : SgAssertStmt::traverseMemoryPoolNodes(visit);
294022 5342 : SgExecStatement::traverseMemoryPoolNodes(visit);
294023 5342 : SgProgramHeaderStatement::traverseMemoryPoolNodes(visit);
294024 5342 : SgProcedureHeaderStatement::traverseMemoryPoolNodes(visit);
294025 5342 : SgEntryStatement::traverseMemoryPoolNodes(visit);
294026 5342 : SgFortranNonblockedDo::traverseMemoryPoolNodes(visit);
294027 5342 : SgInterfaceStatement::traverseMemoryPoolNodes(visit);
294028 5342 : SgParameterStatement::traverseMemoryPoolNodes(visit);
294029 5342 : SgCommonBlock::traverseMemoryPoolNodes(visit);
294030 5342 : SgModuleStatement::traverseMemoryPoolNodes(visit);
294031 5342 : SgUseStatement::traverseMemoryPoolNodes(visit);
294032 5342 : SgProcessControlStatement::traverseMemoryPoolNodes(visit);
294033 5342 : SgPrintStatement::traverseMemoryPoolNodes(visit);
294034 5342 : SgReadStatement::traverseMemoryPoolNodes(visit);
294035 5342 : SgWriteStatement::traverseMemoryPoolNodes(visit);
294036 5342 : SgOpenStatement::traverseMemoryPoolNodes(visit);
294037 5342 : SgCloseStatement::traverseMemoryPoolNodes(visit);
294038 5342 : SgInquireStatement::traverseMemoryPoolNodes(visit);
294039 5342 : SgFlushStatement::traverseMemoryPoolNodes(visit);
294040 5342 : SgBackspaceStatement::traverseMemoryPoolNodes(visit);
294041 5342 : SgRewindStatement::traverseMemoryPoolNodes(visit);
294042 5342 : SgEndfileStatement::traverseMemoryPoolNodes(visit);
294043 5342 : SgWaitStatement::traverseMemoryPoolNodes(visit);
294044 5342 : SgCAFWithTeamStatement::traverseMemoryPoolNodes(visit);
294045 5342 : SgFormatStatement::traverseMemoryPoolNodes(visit);
294046 5342 : SgFortranDo::traverseMemoryPoolNodes(visit);
294047 5342 : SgForAllStatement::traverseMemoryPoolNodes(visit);
294048 5342 : SgIOStatement::traverseMemoryPoolNodes(visit);
294049 5342 : SgSyncAllStatement::traverseMemoryPoolNodes(visit);
294050 5342 : SgSyncImagesStatement::traverseMemoryPoolNodes(visit);
294051 5342 : SgSyncMemoryStatement::traverseMemoryPoolNodes(visit);
294052 5342 : SgSyncTeamStatement::traverseMemoryPoolNodes(visit);
294053 5342 : SgLockStatement::traverseMemoryPoolNodes(visit);
294054 5342 : SgUnlockStatement::traverseMemoryPoolNodes(visit);
294055 5342 : SgImageControlStatement::traverseMemoryPoolNodes(visit);
294056 5342 : SgUpcNotifyStatement::traverseMemoryPoolNodes(visit);
294057 5342 : SgUpcWaitStatement::traverseMemoryPoolNodes(visit);
294058 5342 : SgUpcBarrierStatement::traverseMemoryPoolNodes(visit);
294059 5342 : SgUpcFenceStatement::traverseMemoryPoolNodes(visit);
294060 5342 : SgUpcForAllStatement::traverseMemoryPoolNodes(visit);
294061 5342 : SgUpirSpmdStatement::traverseMemoryPoolNodes(visit);
294062 5342 : SgOmpLoopStatement::traverseMemoryPoolNodes(visit);
294063 5342 : SgOmpScanStatement::traverseMemoryPoolNodes(visit);
294064 5342 : SgOmpTaskloopStatement::traverseMemoryPoolNodes(visit);
294065 5342 : SgOmpTaskgroupStatement::traverseMemoryPoolNodes(visit);
294066 5342 : SgOmpDepobjStatement::traverseMemoryPoolNodes(visit);
294067 5342 : SgOmpTeamsStatement::traverseMemoryPoolNodes(visit);
294068 5342 : SgOmpCancellationPointStatement::traverseMemoryPoolNodes(visit);
294069 5342 : SgOmpDeclareMapperStatement::traverseMemoryPoolNodes(visit);
294070 5342 : SgOmpCancelStatement::traverseMemoryPoolNodes(visit);
294071 5342 : SgOmpDistributeStatement::traverseMemoryPoolNodes(visit);
294072 5342 : SgOmpMetadirectiveStatement::traverseMemoryPoolNodes(visit);
294073 5342 : SgOmpSingleStatement::traverseMemoryPoolNodes(visit);
294074 5342 : SgOmpTaskStatement::traverseMemoryPoolNodes(visit);
294075 5342 : SgOmpTargetEnterDataStatement::traverseMemoryPoolNodes(visit);
294076 5342 : SgOmpTargetExitDataStatement::traverseMemoryPoolNodes(visit);
294077 5342 : SgUpirWorksharingStatement::traverseMemoryPoolNodes(visit);
294078 5342 : SgOmpForSimdStatement::traverseMemoryPoolNodes(visit);
294079 5342 : SgOmpDoStatement::traverseMemoryPoolNodes(visit);
294080 5342 : SgOmpSectionsStatement::traverseMemoryPoolNodes(visit);
294081 5342 : SgOmpAtomicStatement::traverseMemoryPoolNodes(visit);
294082 5342 : SgUpirTaskStatement::traverseMemoryPoolNodes(visit);
294083 5342 : SgOmpTargetDataStatement::traverseMemoryPoolNodes(visit);
294084 5342 : SgOmpTargetParallelForStatement::traverseMemoryPoolNodes(visit);
294085 5342 : SgOmpTargetParallelStatement::traverseMemoryPoolNodes(visit);
294086 5342 : SgOmpDistributeSimdStatement::traverseMemoryPoolNodes(visit);
294087 5342 : SgOmpDistributeParallelForStatement::traverseMemoryPoolNodes(visit);
294088 5342 : SgOmpDistributeParallelForSimdStatement::traverseMemoryPoolNodes(visit);
294089 5342 : SgOmpTaskloopSimdStatement::traverseMemoryPoolNodes(visit);
294090 5342 : SgOmpTargetUpdateStatement::traverseMemoryPoolNodes(visit);
294091 5342 : SgOmpTargetParallelForSimdStatement::traverseMemoryPoolNodes(visit);
294092 5342 : SgOmpTargetParallelLoopStatement::traverseMemoryPoolNodes(visit);
294093 5342 : SgOmpTargetSimdStatement::traverseMemoryPoolNodes(visit);
294094 5342 : SgOmpTargetTeamsStatement::traverseMemoryPoolNodes(visit);
294095 5342 : SgOmpTargetTeamsDistributeStatement::traverseMemoryPoolNodes(visit);
294096 5342 : SgOmpTargetTeamsDistributeSimdStatement::traverseMemoryPoolNodes(visit);
294097 5342 : SgOmpTargetTeamsLoopStatement::traverseMemoryPoolNodes(visit);
294098 5342 : SgOmpTargetTeamsDistributeParallelForStatement::traverseMemoryPoolNodes(visit);
294099 5342 : SgOmpTargetTeamsDistributeParallelForSimdStatement::traverseMemoryPoolNodes(visit);
294100 5342 : SgOmpMasterTaskloopSimdStatement::traverseMemoryPoolNodes(visit);
294101 5342 : SgOmpParallelMasterTaskloopStatement::traverseMemoryPoolNodes(visit);
294102 5342 : SgOmpParallelMasterTaskloopSimdStatement::traverseMemoryPoolNodes(visit);
294103 5342 : SgOmpTeamsDistributeStatement::traverseMemoryPoolNodes(visit);
294104 5342 : SgOmpTeamsDistributeSimdStatement::traverseMemoryPoolNodes(visit);
294105 5342 : SgOmpTeamsDistributeParallelForStatement::traverseMemoryPoolNodes(visit);
294106 5342 : SgOmpTeamsDistributeParallelForSimdStatement::traverseMemoryPoolNodes(visit);
294107 5342 : SgOmpTeamsLoopStatement::traverseMemoryPoolNodes(visit);
294108 5342 : SgOmpParallelMasterStatement::traverseMemoryPoolNodes(visit);
294109 5342 : SgOmpMasterTaskloopStatement::traverseMemoryPoolNodes(visit);
294110 5342 : SgOmpParallelLoopStatement::traverseMemoryPoolNodes(visit);
294111 5342 : SgOmpUnrollStatement::traverseMemoryPoolNodes(visit);
294112 5342 : SgOmpTileStatement::traverseMemoryPoolNodes(visit);
294113 5342 : SgUpirSimdStatement::traverseMemoryPoolNodes(visit);
294114 5342 : SgOmpCriticalStatement::traverseMemoryPoolNodes(visit);
294115 5342 : SgOmpOrderedStatement::traverseMemoryPoolNodes(visit);
294116 5342 : SgUpirLoopStatement::traverseMemoryPoolNodes(visit);
294117 5342 : SgUpirLoopParallelStatement::traverseMemoryPoolNodes(visit);
294118 5342 : SgUpirSyncStatement::traverseMemoryPoolNodes(visit);
294119 5342 : SgUpirFieldBodyStatement::traverseMemoryPoolNodes(visit);
294120 5342 : SgOmpMasterStatement::traverseMemoryPoolNodes(visit);
294121 5342 : SgOmpSectionStatement::traverseMemoryPoolNodes(visit);
294122 5342 : SgOmpWorkshareStatement::traverseMemoryPoolNodes(visit);
294123 5342 : SgOmpFlushStatement::traverseMemoryPoolNodes(visit);
294124 5342 : SgOmpAllocateStatement::traverseMemoryPoolNodes(visit);
294125 5342 : SgOmpOrderedDependStatement::traverseMemoryPoolNodes(visit);
294126 5342 : SgUpirBodyStatement::traverseMemoryPoolNodes(visit);
294127 5342 : SgUpirFieldStatement::traverseMemoryPoolNodes(visit);
294128 5342 : SgBlockDataStatement::traverseMemoryPoolNodes(visit);
294129 5342 : SgImplicitStatement::traverseMemoryPoolNodes(visit);
294130 5342 : SgStatementFunctionStatement::traverseMemoryPoolNodes(visit);
294131 5342 : SgWhereStatement::traverseMemoryPoolNodes(visit);
294132 5342 : SgNullifyStatement::traverseMemoryPoolNodes(visit);
294133 5342 : SgEquivalenceStatement::traverseMemoryPoolNodes(visit);
294134 5342 : SgDerivedTypeStatement::traverseMemoryPoolNodes(visit);
294135 5342 : SgAttributeSpecificationStatement::traverseMemoryPoolNodes(visit);
294136 5342 : SgAllocateStatement::traverseMemoryPoolNodes(visit);
294137 5342 : SgDeallocateStatement::traverseMemoryPoolNodes(visit);
294138 5342 : SgContainsStatement::traverseMemoryPoolNodes(visit);
294139 5342 : SgSequenceStatement::traverseMemoryPoolNodes(visit);
294140 5342 : SgElseWhereStatement::traverseMemoryPoolNodes(visit);
294141 5342 : SgArithmeticIfStatement::traverseMemoryPoolNodes(visit);
294142 5342 : SgAssignStatement::traverseMemoryPoolNodes(visit);
294143 5342 : SgComputedGotoStatement::traverseMemoryPoolNodes(visit);
294144 5342 : SgAssignedGotoStatement::traverseMemoryPoolNodes(visit);
294145 5342 : SgNamelistStatement::traverseMemoryPoolNodes(visit);
294146 5342 : SgImportStatement::traverseMemoryPoolNodes(visit);
294147 5342 : SgAssociateStatement::traverseMemoryPoolNodes(visit);
294148 5342 : SgFortranIncludeLine::traverseMemoryPoolNodes(visit);
294149 5342 : SgNamespaceDeclarationStatement::traverseMemoryPoolNodes(visit);
294150 5342 : SgNamespaceAliasDeclarationStatement::traverseMemoryPoolNodes(visit);
294151 5342 : SgNamespaceDefinitionStatement::traverseMemoryPoolNodes(visit);
294152 5342 : SgUsingDeclarationStatement::traverseMemoryPoolNodes(visit);
294153 5342 : SgUsingDirectiveStatement::traverseMemoryPoolNodes(visit);
294154 5342 : SgTemplateInstantiationDirectiveStatement::traverseMemoryPoolNodes(visit);
294155 5342 : SgStaticAssertionDeclaration::traverseMemoryPoolNodes(visit);
294156 5342 : SgTemplateClassDefinition::traverseMemoryPoolNodes(visit);
294157 5342 : SgTemplateFunctionDefinition::traverseMemoryPoolNodes(visit);
294158 5342 : SgClassDeclaration::traverseMemoryPoolNodes(visit);
294159 5342 : SgClassDefinition::traverseMemoryPoolNodes(visit);
294160 5342 : SgFunctionDefinition::traverseMemoryPoolNodes(visit);
294161 5342 : SgScopeStatement::traverseMemoryPoolNodes(visit);
294162 5342 : SgMemberFunctionDeclaration::traverseMemoryPoolNodes(visit);
294163 5342 : SgFunctionDeclaration::traverseMemoryPoolNodes(visit);
294164 5342 : SgIncludeDirectiveStatement::traverseMemoryPoolNodes(visit);
294165 5342 : SgDefineDirectiveStatement::traverseMemoryPoolNodes(visit);
294166 5342 : SgUndefDirectiveStatement::traverseMemoryPoolNodes(visit);
294167 5342 : SgIfdefDirectiveStatement::traverseMemoryPoolNodes(visit);
294168 5342 : SgIfndefDirectiveStatement::traverseMemoryPoolNodes(visit);
294169 5342 : SgIfDirectiveStatement::traverseMemoryPoolNodes(visit);
294170 5342 : SgDeadIfDirectiveStatement::traverseMemoryPoolNodes(visit);
294171 5342 : SgElseDirectiveStatement::traverseMemoryPoolNodes(visit);
294172 5342 : SgElseifDirectiveStatement::traverseMemoryPoolNodes(visit);
294173 5342 : SgEndifDirectiveStatement::traverseMemoryPoolNodes(visit);
294174 5342 : SgLineDirectiveStatement::traverseMemoryPoolNodes(visit);
294175 5342 : SgWarningDirectiveStatement::traverseMemoryPoolNodes(visit);
294176 5342 : SgErrorDirectiveStatement::traverseMemoryPoolNodes(visit);
294177 5342 : SgEmptyDirectiveStatement::traverseMemoryPoolNodes(visit);
294178 5342 : SgIncludeNextDirectiveStatement::traverseMemoryPoolNodes(visit);
294179 5342 : SgIdentDirectiveStatement::traverseMemoryPoolNodes(visit);
294180 5342 : SgLinemarkerDirectiveStatement::traverseMemoryPoolNodes(visit);
294181 5342 : SgC_PreprocessorDirectiveStatement::traverseMemoryPoolNodes(visit);
294182 5342 : SgClinkageStartStatement::traverseMemoryPoolNodes(visit);
294183 5342 : SgClinkageEndStatement::traverseMemoryPoolNodes(visit);
294184 5342 : SgClinkageDeclarationStatement::traverseMemoryPoolNodes(visit);
294185 5342 : SgOmpDeclareSimdStatement::traverseMemoryPoolNodes(visit);
294186 5342 : SgOmpBarrierStatement::traverseMemoryPoolNodes(visit);
294187 5342 : SgOmpTaskyieldStatement::traverseMemoryPoolNodes(visit);
294188 5342 : SgOmpRequiresStatement::traverseMemoryPoolNodes(visit);
294189 5342 : SgOmpTaskwaitStatement::traverseMemoryPoolNodes(visit);
294190 5342 : SgOmpThreadprivateStatement::traverseMemoryPoolNodes(visit);
294191 5342 : SgMicrosoftAttributeDeclaration::traverseMemoryPoolNodes(visit);
294192 5342 : SgEmptyDeclaration::traverseMemoryPoolNodes(visit);
294193 5342 : SgDeclarationStatement::traverseMemoryPoolNodes(visit);
294194 5342 : SgUpirBaseStatement::traverseMemoryPoolNodes(visit);
294195 5342 : SgStatement::traverseMemoryPoolNodes(visit);
294196 5342 : SgVarRefExp::traverseMemoryPoolNodes(visit);
294197 5342 : SgNonrealRefExp::traverseMemoryPoolNodes(visit);
294198 5342 : SgCompoundLiteralExp::traverseMemoryPoolNodes(visit);
294199 5342 : SgLabelRefExp::traverseMemoryPoolNodes(visit);
294200 5342 : SgClassNameRefExp::traverseMemoryPoolNodes(visit);
294201 5342 : SgFunctionRefExp::traverseMemoryPoolNodes(visit);
294202 5342 : SgMemberFunctionRefExp::traverseMemoryPoolNodes(visit);
294203 5342 : SgTemplateFunctionRefExp::traverseMemoryPoolNodes(visit);
294204 5342 : SgTemplateMemberFunctionRefExp::traverseMemoryPoolNodes(visit);
294205 5342 : SgSizeOfOp::traverseMemoryPoolNodes(visit);
294206 5342 : SgAlignOfOp::traverseMemoryPoolNodes(visit);
294207 5342 : SgNoexceptOp::traverseMemoryPoolNodes(visit);
294208 5342 : SgTypeExpression::traverseMemoryPoolNodes(visit);
294209 5342 : SgLambdaExp::traverseMemoryPoolNodes(visit);
294210 5342 : SgUpcLocalsizeofExpression::traverseMemoryPoolNodes(visit);
294211 5342 : SgUpcBlocksizeofExpression::traverseMemoryPoolNodes(visit);
294212 5342 : SgUpcElemsizeofExpression::traverseMemoryPoolNodes(visit);
294213 5342 : SgVarArgStartOp::traverseMemoryPoolNodes(visit);
294214 5342 : SgVarArgStartOneOperandOp::traverseMemoryPoolNodes(visit);
294215 5342 : SgVarArgOp::traverseMemoryPoolNodes(visit);
294216 5342 : SgVarArgEndOp::traverseMemoryPoolNodes(visit);
294217 5342 : SgVarArgCopyOp::traverseMemoryPoolNodes(visit);
294218 5342 : SgTypeIdOp::traverseMemoryPoolNodes(visit);
294219 5342 : SgConditionalExp::traverseMemoryPoolNodes(visit);
294220 5342 : SgNewExp::traverseMemoryPoolNodes(visit);
294221 5342 : SgDeleteExp::traverseMemoryPoolNodes(visit);
294222 5342 : SgThisExp::traverseMemoryPoolNodes(visit);
294223 5342 : SgSuperExp::traverseMemoryPoolNodes(visit);
294224 5342 : SgClassExp::traverseMemoryPoolNodes(visit);
294225 5342 : SgRefExp::traverseMemoryPoolNodes(visit);
294226 5342 : SgAggregateInitializer::traverseMemoryPoolNodes(visit);
294227 5342 : SgCompoundInitializer::traverseMemoryPoolNodes(visit);
294228 5342 : SgConstructorInitializer::traverseMemoryPoolNodes(visit);
294229 5342 : SgAssignInitializer::traverseMemoryPoolNodes(visit);
294230 5342 : SgBracedInitializer::traverseMemoryPoolNodes(visit);
294231 5342 : SgExpressionRoot::traverseMemoryPoolNodes(visit);
294232 5342 : SgMinusOp::traverseMemoryPoolNodes(visit);
294233 5342 : SgUnaryAddOp::traverseMemoryPoolNodes(visit);
294234 5342 : SgNotOp::traverseMemoryPoolNodes(visit);
294235 5342 : SgPointerDerefExp::traverseMemoryPoolNodes(visit);
294236 5342 : SgAddressOfOp::traverseMemoryPoolNodes(visit);
294237 5342 : SgMinusMinusOp::traverseMemoryPoolNodes(visit);
294238 5342 : SgPlusPlusOp::traverseMemoryPoolNodes(visit);
294239 5342 : SgBitComplementOp::traverseMemoryPoolNodes(visit);
294240 5342 : SgRealPartOp::traverseMemoryPoolNodes(visit);
294241 5342 : SgImagPartOp::traverseMemoryPoolNodes(visit);
294242 5342 : SgConjugateOp::traverseMemoryPoolNodes(visit);
294243 5342 : SgCastExp::traverseMemoryPoolNodes(visit);
294244 5342 : SgThrowOp::traverseMemoryPoolNodes(visit);
294245 5342 : SgArrowExp::traverseMemoryPoolNodes(visit);
294246 5342 : SgDotExp::traverseMemoryPoolNodes(visit);
294247 5342 : SgDotStarOp::traverseMemoryPoolNodes(visit);
294248 5342 : SgArrowStarOp::traverseMemoryPoolNodes(visit);
294249 5342 : SgEqualityOp::traverseMemoryPoolNodes(visit);
294250 5342 : SgLessThanOp::traverseMemoryPoolNodes(visit);
294251 5342 : SgGreaterThanOp::traverseMemoryPoolNodes(visit);
294252 5342 : SgNotEqualOp::traverseMemoryPoolNodes(visit);
294253 5342 : SgLessOrEqualOp::traverseMemoryPoolNodes(visit);
294254 5342 : SgGreaterOrEqualOp::traverseMemoryPoolNodes(visit);
294255 5342 : SgAddOp::traverseMemoryPoolNodes(visit);
294256 5342 : SgSubtractOp::traverseMemoryPoolNodes(visit);
294257 5342 : SgMultiplyOp::traverseMemoryPoolNodes(visit);
294258 5342 : SgDivideOp::traverseMemoryPoolNodes(visit);
294259 5342 : SgIntegerDivideOp::traverseMemoryPoolNodes(visit);
294260 5342 : SgModOp::traverseMemoryPoolNodes(visit);
294261 5342 : SgAndOp::traverseMemoryPoolNodes(visit);
294262 5342 : SgOrOp::traverseMemoryPoolNodes(visit);
294263 5342 : SgBitXorOp::traverseMemoryPoolNodes(visit);
294264 5342 : SgBitAndOp::traverseMemoryPoolNodes(visit);
294265 5342 : SgBitOrOp::traverseMemoryPoolNodes(visit);
294266 5342 : SgBitEqvOp::traverseMemoryPoolNodes(visit);
294267 5342 : SgCommaOpExp::traverseMemoryPoolNodes(visit);
294268 5342 : SgLshiftOp::traverseMemoryPoolNodes(visit);
294269 5342 : SgRshiftOp::traverseMemoryPoolNodes(visit);
294270 5342 : SgPntrArrRefExp::traverseMemoryPoolNodes(visit);
294271 5342 : SgScopeOp::traverseMemoryPoolNodes(visit);
294272 5342 : SgAssignOp::traverseMemoryPoolNodes(visit);
294273 5342 : SgPlusAssignOp::traverseMemoryPoolNodes(visit);
294274 5342 : SgMinusAssignOp::traverseMemoryPoolNodes(visit);
294275 5342 : SgAndAssignOp::traverseMemoryPoolNodes(visit);
294276 5342 : SgIorAssignOp::traverseMemoryPoolNodes(visit);
294277 5342 : SgMultAssignOp::traverseMemoryPoolNodes(visit);
294278 5342 : SgDivAssignOp::traverseMemoryPoolNodes(visit);
294279 5342 : SgModAssignOp::traverseMemoryPoolNodes(visit);
294280 5342 : SgXorAssignOp::traverseMemoryPoolNodes(visit);
294281 5342 : SgLshiftAssignOp::traverseMemoryPoolNodes(visit);
294282 5342 : SgRshiftAssignOp::traverseMemoryPoolNodes(visit);
294283 5342 : SgIntegerDivideAssignOp::traverseMemoryPoolNodes(visit);
294284 5342 : SgExponentiationAssignOp::traverseMemoryPoolNodes(visit);
294285 5342 : SgConcatenationOp::traverseMemoryPoolNodes(visit);
294286 5342 : SgNaryComparisonOp::traverseMemoryPoolNodes(visit);
294287 5342 : SgNaryBooleanOp::traverseMemoryPoolNodes(visit);
294288 5342 : SgBoolValExp::traverseMemoryPoolNodes(visit);
294289 5342 : SgStringVal::traverseMemoryPoolNodes(visit);
294290 5342 : SgShortVal::traverseMemoryPoolNodes(visit);
294291 5342 : SgCharVal::traverseMemoryPoolNodes(visit);
294292 5342 : SgUnsignedCharVal::traverseMemoryPoolNodes(visit);
294293 5342 : SgWcharVal::traverseMemoryPoolNodes(visit);
294294 5342 : SgChar16Val::traverseMemoryPoolNodes(visit);
294295 5342 : SgChar32Val::traverseMemoryPoolNodes(visit);
294296 5342 : SgUnsignedShortVal::traverseMemoryPoolNodes(visit);
294297 5342 : SgIntVal::traverseMemoryPoolNodes(visit);
294298 5342 : SgEnumVal::traverseMemoryPoolNodes(visit);
294299 5342 : SgUnsignedIntVal::traverseMemoryPoolNodes(visit);
294300 5342 : SgLongIntVal::traverseMemoryPoolNodes(visit);
294301 5342 : SgLongLongIntVal::traverseMemoryPoolNodes(visit);
294302 5342 : SgUnsignedLongLongIntVal::traverseMemoryPoolNodes(visit);
294303 5342 : SgUnsignedLongVal::traverseMemoryPoolNodes(visit);
294304 5342 : SgFloatVal::traverseMemoryPoolNodes(visit);
294305 5342 : SgDoubleVal::traverseMemoryPoolNodes(visit);
294306 5342 : SgLongDoubleVal::traverseMemoryPoolNodes(visit);
294307 5342 : SgFloat80Val::traverseMemoryPoolNodes(visit);
294308 5342 : SgFloat128Val::traverseMemoryPoolNodes(visit);
294309 5342 : SgNullptrValExp::traverseMemoryPoolNodes(visit);
294310 5342 : SgVoidVal::traverseMemoryPoolNodes(visit);
294311 5342 : SgFunctionParameterRefExp::traverseMemoryPoolNodes(visit);
294312 5342 : SgTemplateParameterVal::traverseMemoryPoolNodes(visit);
294313 5342 : SgUpcThreads::traverseMemoryPoolNodes(visit);
294314 5342 : SgUpcMythread::traverseMemoryPoolNodes(visit);
294315 5342 : SgComplexVal::traverseMemoryPoolNodes(visit);
294316 5342 : SgNullExpression::traverseMemoryPoolNodes(visit);
294317 5342 : SgVariantExpression::traverseMemoryPoolNodes(visit);
294318 5342 : SgStatementExpression::traverseMemoryPoolNodes(visit);
294319 5342 : SgAsmOp::traverseMemoryPoolNodes(visit);
294320 5342 : SgCudaKernelExecConfig::traverseMemoryPoolNodes(visit);
294321 5342 : SgCudaKernelCallExp::traverseMemoryPoolNodes(visit);
294322 5342 : SgLambdaRefExp::traverseMemoryPoolNodes(visit);
294323 5342 : SgTupleExp::traverseMemoryPoolNodes(visit);
294324 5342 : SgListExp::traverseMemoryPoolNodes(visit);
294325 5342 : SgDictionaryExp::traverseMemoryPoolNodes(visit);
294326 5342 : SgKeyDatumPair::traverseMemoryPoolNodes(visit);
294327 5342 : SgComprehension::traverseMemoryPoolNodes(visit);
294328 5342 : SgListComprehension::traverseMemoryPoolNodes(visit);
294329 5342 : SgSetComprehension::traverseMemoryPoolNodes(visit);
294330 5342 : SgDictionaryComprehension::traverseMemoryPoolNodes(visit);
294331 5342 : SgMembershipOp::traverseMemoryPoolNodes(visit);
294332 5342 : SgNonMembershipOp::traverseMemoryPoolNodes(visit);
294333 5342 : SgIsOp::traverseMemoryPoolNodes(visit);
294334 5342 : SgIsNotOp::traverseMemoryPoolNodes(visit);
294335 5342 : SgStringConversion::traverseMemoryPoolNodes(visit);
294336 5342 : SgYieldExpression::traverseMemoryPoolNodes(visit);
294337 5342 : SgFoldExpression::traverseMemoryPoolNodes(visit);
294338 5342 : SgChooseExpression::traverseMemoryPoolNodes(visit);
294339 5342 : SgAwaitExpression::traverseMemoryPoolNodes(visit);
294340 5342 : SgSpaceshipOp::traverseMemoryPoolNodes(visit);
294341 5342 : SgSubscriptExpression::traverseMemoryPoolNodes(visit);
294342 5342 : SgColonShapeExp::traverseMemoryPoolNodes(visit);
294343 5342 : SgAsteriskShapeExp::traverseMemoryPoolNodes(visit);
294344 5342 : SgIOItemExpression::traverseMemoryPoolNodes(visit);
294345 5342 : SgImpliedDo::traverseMemoryPoolNodes(visit);
294346 5342 : SgExponentiationOp::traverseMemoryPoolNodes(visit);
294347 5342 : SgUnknownArrayOrFunctionReference::traverseMemoryPoolNodes(visit);
294348 5342 : SgActualArgumentExpression::traverseMemoryPoolNodes(visit);
294349 5342 : SgUserDefinedBinaryOp::traverseMemoryPoolNodes(visit);
294350 5342 : SgPointerAssignOp::traverseMemoryPoolNodes(visit);
294351 5342 : SgCAFCoExpression::traverseMemoryPoolNodes(visit);
294352 5342 : SgDesignatedInitializer::traverseMemoryPoolNodes(visit);
294353 5342 : SgMatrixExp::traverseMemoryPoolNodes(visit);
294354 5342 : SgRangeExp::traverseMemoryPoolNodes(visit);
294355 5342 : SgMagicColonExp::traverseMemoryPoolNodes(visit);
294356 5342 : SgElementwiseMultiplyOp::traverseMemoryPoolNodes(visit);
294357 5342 : SgPowerOp::traverseMemoryPoolNodes(visit);
294358 5342 : SgElementwisePowerOp::traverseMemoryPoolNodes(visit);
294359 5342 : SgElementwiseDivideOp::traverseMemoryPoolNodes(visit);
294360 5342 : SgLeftDivideOp::traverseMemoryPoolNodes(visit);
294361 5342 : SgElementwiseLeftDivideOp::traverseMemoryPoolNodes(visit);
294362 5342 : SgElementwiseAddOp::traverseMemoryPoolNodes(visit);
294363 5342 : SgElementwiseSubtractOp::traverseMemoryPoolNodes(visit);
294364 5342 : SgMatrixTransposeOp::traverseMemoryPoolNodes(visit);
294365 5342 : SgElementwiseOp::traverseMemoryPoolNodes(visit);
294366 5342 : SgInitializer::traverseMemoryPoolNodes(visit);
294367 5342 : SgSIMDLoad::traverseMemoryPoolNodes(visit);
294368 5342 : SgSIMDBroadcast::traverseMemoryPoolNodes(visit);
294369 5342 : SgSIMDStore::traverseMemoryPoolNodes(visit);
294370 5342 : SgSIMDPartialStore::traverseMemoryPoolNodes(visit);
294371 5342 : SgSIMDScalarStore::traverseMemoryPoolNodes(visit);
294372 5342 : SgSIMDGather::traverseMemoryPoolNodes(visit);
294373 5342 : SgSIMDExplicitGather::traverseMemoryPoolNodes(visit);
294374 5342 : SgSIMDScatter::traverseMemoryPoolNodes(visit);
294375 5342 : SgSIMDAddOp::traverseMemoryPoolNodes(visit);
294376 5342 : SgSIMDSubOp::traverseMemoryPoolNodes(visit);
294377 5342 : SgSIMDMulOp::traverseMemoryPoolNodes(visit);
294378 5342 : SgSIMDDivOp::traverseMemoryPoolNodes(visit);
294379 5342 : SgSIMDFmaOp::traverseMemoryPoolNodes(visit);
294380 5342 : SgSIMDBinaryOp::traverseMemoryPoolNodes(visit);
294381 5342 : SgUserDefinedUnaryOp::traverseMemoryPoolNodes(visit);
294382 5342 : SgPseudoDestructorRefExp::traverseMemoryPoolNodes(visit);
294383 5342 : SgUnaryOp::traverseMemoryPoolNodes(visit);
294384 5342 : SgCompoundAssignOp::traverseMemoryPoolNodes(visit);
294385 5342 : SgBinaryOp::traverseMemoryPoolNodes(visit);
294386 5342 : SgNaryOp::traverseMemoryPoolNodes(visit);
294387 5342 : SgValueExp::traverseMemoryPoolNodes(visit);
294388 5342 : SgExprListExp::traverseMemoryPoolNodes(visit);
294389 5342 : SgFunctionCallExp::traverseMemoryPoolNodes(visit);
294390 5342 : SgCallExpression::traverseMemoryPoolNodes(visit);
294391 5342 : SgTypeTraitBuiltinOperator::traverseMemoryPoolNodes(visit);
294392 5342 : SgExpression::traverseMemoryPoolNodes(visit);
294393 5342 : SgTemplateVariableSymbol::traverseMemoryPoolNodes(visit);
294394 5342 : SgVariableSymbol::traverseMemoryPoolNodes(visit);
294395 5342 : SgFunctionTypeSymbol::traverseMemoryPoolNodes(visit);
294396 5342 : SgTemplateClassSymbol::traverseMemoryPoolNodes(visit);
294397 5342 : SgClassSymbol::traverseMemoryPoolNodes(visit);
294398 5342 : SgTemplateSymbol::traverseMemoryPoolNodes(visit);
294399 5342 : SgEnumSymbol::traverseMemoryPoolNodes(visit);
294400 5342 : SgEnumFieldSymbol::traverseMemoryPoolNodes(visit);
294401 5342 : SgTemplateTypedefSymbol::traverseMemoryPoolNodes(visit);
294402 5342 : SgTypedefSymbol::traverseMemoryPoolNodes(visit);
294403 5342 : SgTemplateFunctionSymbol::traverseMemoryPoolNodes(visit);
294404 5342 : SgTemplateMemberFunctionSymbol::traverseMemoryPoolNodes(visit);
294405 5342 : SgLabelSymbol::traverseMemoryPoolNodes(visit);
294406 5342 : SgDefaultSymbol::traverseMemoryPoolNodes(visit);
294407 5342 : SgNamespaceSymbol::traverseMemoryPoolNodes(visit);
294408 5342 : SgIntrinsicSymbol::traverseMemoryPoolNodes(visit);
294409 5342 : SgModuleSymbol::traverseMemoryPoolNodes(visit);
294410 5342 : SgInterfaceSymbol::traverseMemoryPoolNodes(visit);
294411 5342 : SgCommonSymbol::traverseMemoryPoolNodes(visit);
294412 5342 : SgRenameSymbol::traverseMemoryPoolNodes(visit);
294413 5342 : SgMemberFunctionSymbol::traverseMemoryPoolNodes(visit);
294414 5342 : SgFunctionSymbol::traverseMemoryPoolNodes(visit);
294415 5342 : SgAliasSymbol::traverseMemoryPoolNodes(visit);
294416 5342 : SgNonrealSymbol::traverseMemoryPoolNodes(visit);
294417 5342 : SgSymbol::traverseMemoryPoolNodes(visit);
294418 5342 : SgCommonBlockObject::traverseMemoryPoolNodes(visit);
294419 5342 : SgInitializedName::traverseMemoryPoolNodes(visit);
294420 5342 : SgLambdaCapture::traverseMemoryPoolNodes(visit);
294421 5342 : SgLambdaCaptureList::traverseMemoryPoolNodes(visit);
294422 5342 : SgOmpOrderedClause::traverseMemoryPoolNodes(visit);
294423 5342 : SgOmpNowaitClause::traverseMemoryPoolNodes(visit);
294424 5342 : SgOmpNogroupClause::traverseMemoryPoolNodes(visit);
294425 5342 : SgOmpReadClause::traverseMemoryPoolNodes(visit);
294426 5342 : SgOmpThreadsClause::traverseMemoryPoolNodes(visit);
294427 5342 : SgOmpSimdClause::traverseMemoryPoolNodes(visit);
294428 5342 : SgOmpReverseOffloadClause::traverseMemoryPoolNodes(visit);
294429 5342 : SgOmpExtImplementationDefinedRequirementClause::traverseMemoryPoolNodes(visit);
294430 5342 : SgOmpUnifiedAddressClause::traverseMemoryPoolNodes(visit);
294431 5342 : SgOmpUnifiedSharedMemoryClause::traverseMemoryPoolNodes(visit);
294432 5342 : SgOmpDynamicAllocatorsClause::traverseMemoryPoolNodes(visit);
294433 5342 : SgOmpAtomicDefaultMemOrderClause::traverseMemoryPoolNodes(visit);
294434 5342 : SgOmpWriteClause::traverseMemoryPoolNodes(visit);
294435 5342 : SgOmpUpdateClause::traverseMemoryPoolNodes(visit);
294436 5342 : SgOmpDepobjUpdateClause::traverseMemoryPoolNodes(visit);
294437 5342 : SgOmpDestroyClause::traverseMemoryPoolNodes(visit);
294438 5342 : SgOmpCaptureClause::traverseMemoryPoolNodes(visit);
294439 5342 : SgOmpSeqCstClause::traverseMemoryPoolNodes(visit);
294440 5342 : SgOmpAcqRelClause::traverseMemoryPoolNodes(visit);
294441 5342 : SgOmpReleaseClause::traverseMemoryPoolNodes(visit);
294442 5342 : SgOmpAcquireClause::traverseMemoryPoolNodes(visit);
294443 5342 : SgOmpRelaxedClause::traverseMemoryPoolNodes(visit);
294444 5342 : SgOmpParallelClause::traverseMemoryPoolNodes(visit);
294445 5342 : SgOmpSectionsClause::traverseMemoryPoolNodes(visit);
294446 5342 : SgOmpForClause::traverseMemoryPoolNodes(visit);
294447 5342 : SgOmpTaskgroupClause::traverseMemoryPoolNodes(visit);
294448 5342 : SgOmpBeginClause::traverseMemoryPoolNodes(visit);
294449 5342 : SgOmpEndClause::traverseMemoryPoolNodes(visit);
294450 5342 : SgOmpUntiedClause::traverseMemoryPoolNodes(visit);
294451 5342 : SgOmpMergeableClause::traverseMemoryPoolNodes(visit);
294452 5342 : SgOmpDefaultClause::traverseMemoryPoolNodes(visit);
294453 5342 : SgOmpAtomicClause::traverseMemoryPoolNodes(visit);
294454 5342 : SgOmpProcBindClause::traverseMemoryPoolNodes(visit);
294455 5342 : SgOmpOrderClause::traverseMemoryPoolNodes(visit);
294456 5342 : SgOmpBindClause::traverseMemoryPoolNodes(visit);
294457 5342 : SgOmpInbranchClause::traverseMemoryPoolNodes(visit);
294458 5342 : SgOmpNotinbranchClause::traverseMemoryPoolNodes(visit);
294459 5342 : SgOmpCollapseClause::traverseMemoryPoolNodes(visit);
294460 5342 : SgOmpIfClause::traverseMemoryPoolNodes(visit);
294461 5342 : SgOmpFinalClause::traverseMemoryPoolNodes(visit);
294462 5342 : SgOmpPriorityClause::traverseMemoryPoolNodes(visit);
294463 5342 : SgUpirNumUnitsField::traverseMemoryPoolNodes(visit);
294464 5342 : SgOmpNumTeamsClause::traverseMemoryPoolNodes(visit);
294465 5342 : SgOmpGrainsizeClause::traverseMemoryPoolNodes(visit);
294466 5342 : SgOmpDetachClause::traverseMemoryPoolNodes(visit);
294467 5342 : SgOmpNumTasksClause::traverseMemoryPoolNodes(visit);
294468 5342 : SgOmpHintClause::traverseMemoryPoolNodes(visit);
294469 5342 : SgOmpThreadLimitClause::traverseMemoryPoolNodes(visit);
294470 5342 : SgOmpNontemporalClause::traverseMemoryPoolNodes(visit);
294471 5342 : SgOmpInclusiveClause::traverseMemoryPoolNodes(visit);
294472 5342 : SgOmpExclusiveClause::traverseMemoryPoolNodes(visit);
294473 5342 : SgOmpIsDevicePtrClause::traverseMemoryPoolNodes(visit);
294474 5342 : SgOmpUseDevicePtrClause::traverseMemoryPoolNodes(visit);
294475 5342 : SgOmpUseDeviceAddrClause::traverseMemoryPoolNodes(visit);
294476 5342 : SgOmpDeviceClause::traverseMemoryPoolNodes(visit);
294477 5342 : SgOmpSafelenClause::traverseMemoryPoolNodes(visit);
294478 5342 : SgOmpSimdlenClause::traverseMemoryPoolNodes(visit);
294479 5342 : SgOmpPartialClause::traverseMemoryPoolNodes(visit);
294480 5342 : SgOmpFullClause::traverseMemoryPoolNodes(visit);
294481 5342 : SgOmpSizesClause::traverseMemoryPoolNodes(visit);
294482 5342 : SgUpirBranchField::traverseMemoryPoolNodes(visit);
294483 5342 : SgUpirNestedLevelField::traverseMemoryPoolNodes(visit);
294484 5342 : SgUpirNestedParentField::traverseMemoryPoolNodes(visit);
294485 5342 : SgUpirNestedChildField::traverseMemoryPoolNodes(visit);
294486 5342 : SgUpirSyncField::traverseMemoryPoolNodes(visit);
294487 5342 : SgUpirDataField::traverseMemoryPoolNodes(visit);
294488 5342 : SgUpirTargetField::traverseMemoryPoolNodes(visit);
294489 5342 : SgUpirDataItemField::traverseMemoryPoolNodes(visit);
294490 5342 : SgOmpExpressionClause::traverseMemoryPoolNodes(visit);
294491 5342 : SgOmpCopyprivateClause::traverseMemoryPoolNodes(visit);
294492 5342 : SgOmpPrivateClause::traverseMemoryPoolNodes(visit);
294493 5342 : SgOmpFirstprivateClause::traverseMemoryPoolNodes(visit);
294494 5342 : SgOmpSharedClause::traverseMemoryPoolNodes(visit);
294495 5342 : SgOmpCopyinClause::traverseMemoryPoolNodes(visit);
294496 5342 : SgOmpLastprivateClause::traverseMemoryPoolNodes(visit);
294497 5342 : SgOmpReductionClause::traverseMemoryPoolNodes(visit);
294498 5342 : SgOmpInReductionClause::traverseMemoryPoolNodes(visit);
294499 5342 : SgOmpTaskReductionClause::traverseMemoryPoolNodes(visit);
294500 5342 : SgOmpAllocateClause::traverseMemoryPoolNodes(visit);
294501 5342 : SgOmpDependClause::traverseMemoryPoolNodes(visit);
294502 5342 : SgOmpToClause::traverseMemoryPoolNodes(visit);
294503 5342 : SgOmpUsesAllocatorsClause::traverseMemoryPoolNodes(visit);
294504 5342 : SgOmpFromClause::traverseMemoryPoolNodes(visit);
294505 5342 : SgOmpAffinityClause::traverseMemoryPoolNodes(visit);
294506 5342 : SgOmpMapClause::traverseMemoryPoolNodes(visit);
294507 5342 : SgOmpLinearClause::traverseMemoryPoolNodes(visit);
294508 5342 : SgOmpUniformClause::traverseMemoryPoolNodes(visit);
294509 5342 : SgOmpAlignedClause::traverseMemoryPoolNodes(visit);
294510 5342 : SgOmpVariablesClause::traverseMemoryPoolNodes(visit);
294511 5342 : SgOmpScheduleClause::traverseMemoryPoolNodes(visit);
294512 5342 : SgOmpWhenClause::traverseMemoryPoolNodes(visit);
294513 5342 : SgOmpDistScheduleClause::traverseMemoryPoolNodes(visit);
294514 5342 : SgOmpDefaultmapClause::traverseMemoryPoolNodes(visit);
294515 5342 : SgOmpAllocatorClause::traverseMemoryPoolNodes(visit);
294516 5342 : SgOmpUsesAllocatorsDefination::traverseMemoryPoolNodes(visit);
294517 5342 : SgOmpClause::traverseMemoryPoolNodes(visit);
294518 5342 : SgRenamePair::traverseMemoryPoolNodes(visit);
294519 5342 : SgInterfaceBody::traverseMemoryPoolNodes(visit);
294520 5342 : SgHeaderFileBody::traverseMemoryPoolNodes(visit);
294521 5342 : SgLocatedNodeSupport::traverseMemoryPoolNodes(visit);
294522 5342 : SgToken::traverseMemoryPoolNodes(visit);
294523 5342 : SgLocatedNode::traverseMemoryPoolNodes(visit);
294524 5342 : SgNode::traverseMemoryPoolNodes(visit);
294525 5342 : }
294526 :
294527 :
294528 :
294529 0 : void traverseRepresentativeNodes ( ROSE_VisitTraversal & visit )
294530 : {
294531 0 : SgName::visitRepresentativeNode(visit);
294532 0 : SgSymbolTable::visitRepresentativeNode(visit);
294533 0 : SgPragma::visitRepresentativeNode(visit);
294534 0 : SgModifierNodes::visitRepresentativeNode(visit);
294535 0 : SgConstVolatileModifier::visitRepresentativeNode(visit);
294536 0 : SgStorageModifier::visitRepresentativeNode(visit);
294537 0 : SgAccessModifier::visitRepresentativeNode(visit);
294538 0 : SgFunctionModifier::visitRepresentativeNode(visit);
294539 0 : SgUPC_AccessModifier::visitRepresentativeNode(visit);
294540 0 : SgLinkageModifier::visitRepresentativeNode(visit);
294541 0 : SgSpecialFunctionModifier::visitRepresentativeNode(visit);
294542 0 : SgTypeModifier::visitRepresentativeNode(visit);
294543 0 : SgElaboratedTypeModifier::visitRepresentativeNode(visit);
294544 0 : SgBaseClassModifier::visitRepresentativeNode(visit);
294545 0 : SgDeclarationModifier::visitRepresentativeNode(visit);
294546 0 : SgStructureModifier::visitRepresentativeNode(visit);
294547 0 : SgOpenclAccessModeModifier::visitRepresentativeNode(visit);
294548 0 : SgModifier::visitRepresentativeNode(visit);
294549 0 : Sg_File_Info::visitRepresentativeNode(visit);
294550 0 : SgSourceFile::visitRepresentativeNode(visit);
294551 0 : SgUnknownFile::visitRepresentativeNode(visit);
294552 0 : SgFile::visitRepresentativeNode(visit);
294553 0 : SgFileList::visitRepresentativeNode(visit);
294554 0 : SgDirectory::visitRepresentativeNode(visit);
294555 0 : SgDirectoryList::visitRepresentativeNode(visit);
294556 0 : SgProject::visitRepresentativeNode(visit);
294557 0 : SgOptions::visitRepresentativeNode(visit);
294558 0 : SgUnparse_Info::visitRepresentativeNode(visit);
294559 0 : SgIncludeFile::visitRepresentativeNode(visit);
294560 0 : SgFuncDecl_attr::visitRepresentativeNode(visit);
294561 0 : SgClassDecl_attr::visitRepresentativeNode(visit);
294562 0 : SgTypedefSeq::visitRepresentativeNode(visit);
294563 0 : SgFunctionParameterTypeList::visitRepresentativeNode(visit);
294564 0 : SgTemplateParameter::visitRepresentativeNode(visit);
294565 0 : SgTemplateArgument::visitRepresentativeNode(visit);
294566 0 : SgTemplateParameterList::visitRepresentativeNode(visit);
294567 0 : SgTemplateArgumentList::visitRepresentativeNode(visit);
294568 0 : SgBitAttribute::visitRepresentativeNode(visit);
294569 0 : SgAttribute::visitRepresentativeNode(visit);
294570 0 : SgExpBaseClass::visitRepresentativeNode(visit);
294571 0 : SgNonrealBaseClass::visitRepresentativeNode(visit);
294572 0 : SgBaseClass::visitRepresentativeNode(visit);
294573 0 : SgUndirectedGraphEdge::visitRepresentativeNode(visit);
294574 0 : SgDirectedGraphEdge::visitRepresentativeNode(visit);
294575 0 : SgGraphNode::visitRepresentativeNode(visit);
294576 0 : SgGraphEdge::visitRepresentativeNode(visit);
294577 0 : SgStringKeyedBidirectionalGraph::visitRepresentativeNode(visit);
294578 0 : SgIntKeyedBidirectionalGraph::visitRepresentativeNode(visit);
294579 0 : SgBidirectionalGraph::visitRepresentativeNode(visit);
294580 0 : SgIncidenceDirectedGraph::visitRepresentativeNode(visit);
294581 0 : SgIncidenceUndirectedGraph::visitRepresentativeNode(visit);
294582 0 : SgGraph::visitRepresentativeNode(visit);
294583 0 : SgGraphNodeList::visitRepresentativeNode(visit);
294584 0 : SgGraphEdgeList::visitRepresentativeNode(visit);
294585 0 : SgQualifiedName::visitRepresentativeNode(visit);
294586 0 : SgNameGroup::visitRepresentativeNode(visit);
294587 0 : SgDimensionObject::visitRepresentativeNode(visit);
294588 0 : SgDataStatementGroup::visitRepresentativeNode(visit);
294589 0 : SgDataStatementObject::visitRepresentativeNode(visit);
294590 0 : SgDataStatementValue::visitRepresentativeNode(visit);
294591 0 : SgFormatItem::visitRepresentativeNode(visit);
294592 0 : SgFormatItemList::visitRepresentativeNode(visit);
294593 0 : SgTypeTable::visitRepresentativeNode(visit);
294594 0 : SgHeaderFileReport::visitRepresentativeNode(visit);
294595 0 : SgSupport::visitRepresentativeNode(visit);
294596 0 : SgTypeUnknown::visitRepresentativeNode(visit);
294597 0 : SgTypeChar::visitRepresentativeNode(visit);
294598 0 : SgTypeSignedChar::visitRepresentativeNode(visit);
294599 0 : SgTypeUnsignedChar::visitRepresentativeNode(visit);
294600 0 : SgTypeShort::visitRepresentativeNode(visit);
294601 0 : SgTypeSignedShort::visitRepresentativeNode(visit);
294602 0 : SgTypeUnsignedShort::visitRepresentativeNode(visit);
294603 0 : SgTypeInt::visitRepresentativeNode(visit);
294604 0 : SgTypeSignedInt::visitRepresentativeNode(visit);
294605 0 : SgTypeUnsignedInt::visitRepresentativeNode(visit);
294606 0 : SgTypeLong::visitRepresentativeNode(visit);
294607 0 : SgTypeSignedLong::visitRepresentativeNode(visit);
294608 0 : SgTypeUnsignedLong::visitRepresentativeNode(visit);
294609 0 : SgTypeVoid::visitRepresentativeNode(visit);
294610 0 : SgTypeGlobalVoid::visitRepresentativeNode(visit);
294611 0 : SgTypeWchar::visitRepresentativeNode(visit);
294612 0 : SgTypeFloat::visitRepresentativeNode(visit);
294613 0 : SgTypeDouble::visitRepresentativeNode(visit);
294614 0 : SgTypeLongLong::visitRepresentativeNode(visit);
294615 0 : SgTypeSignedLongLong::visitRepresentativeNode(visit);
294616 0 : SgTypeUnsignedLongLong::visitRepresentativeNode(visit);
294617 0 : SgTypeLongDouble::visitRepresentativeNode(visit);
294618 0 : SgTypeFloat80::visitRepresentativeNode(visit);
294619 0 : SgTypeFloat128::visitRepresentativeNode(visit);
294620 0 : SgTypeString::visitRepresentativeNode(visit);
294621 0 : SgTypeBool::visitRepresentativeNode(visit);
294622 0 : SgTypeFixed::visitRepresentativeNode(visit);
294623 0 : SgTypeMatrix::visitRepresentativeNode(visit);
294624 0 : SgTypeTuple::visitRepresentativeNode(visit);
294625 0 : SgTypeNullptr::visitRepresentativeNode(visit);
294626 0 : SgTypeComplex::visitRepresentativeNode(visit);
294627 0 : SgTypeImaginary::visitRepresentativeNode(visit);
294628 0 : SgTypeDefault::visitRepresentativeNode(visit);
294629 0 : SgPointerMemberType::visitRepresentativeNode(visit);
294630 0 : SgReferenceType::visitRepresentativeNode(visit);
294631 0 : SgRvalueReferenceType::visitRepresentativeNode(visit);
294632 0 : SgDeclType::visitRepresentativeNode(visit);
294633 0 : SgTypeOfType::visitRepresentativeNode(visit);
294634 0 : SgTypeCAFTeam::visitRepresentativeNode(visit);
294635 0 : SgTypeUnsigned128bitInteger::visitRepresentativeNode(visit);
294636 0 : SgTypeSigned128bitInteger::visitRepresentativeNode(visit);
294637 0 : SgTypeLabel::visitRepresentativeNode(visit);
294638 0 : SgTemplateType::visitRepresentativeNode(visit);
294639 0 : SgEnumType::visitRepresentativeNode(visit);
294640 0 : SgTypedefType::visitRepresentativeNode(visit);
294641 0 : SgNonrealType::visitRepresentativeNode(visit);
294642 0 : SgAutoType::visitRepresentativeNode(visit);
294643 0 : SgModifierType::visitRepresentativeNode(visit);
294644 0 : SgPartialFunctionModifierType::visitRepresentativeNode(visit);
294645 0 : SgArrayType::visitRepresentativeNode(visit);
294646 0 : SgTypeEllipse::visitRepresentativeNode(visit);
294647 0 : SgTypeCrayPointer::visitRepresentativeNode(visit);
294648 0 : SgPartialFunctionType::visitRepresentativeNode(visit);
294649 0 : SgMemberFunctionType::visitRepresentativeNode(visit);
294650 0 : SgFunctionType::visitRepresentativeNode(visit);
294651 0 : SgPointerType::visitRepresentativeNode(visit);
294652 0 : SgClassType::visitRepresentativeNode(visit);
294653 0 : SgNamedType::visitRepresentativeNode(visit);
294654 0 : SgQualifiedNameType::visitRepresentativeNode(visit);
294655 0 : SgTypeChar16::visitRepresentativeNode(visit);
294656 0 : SgTypeChar32::visitRepresentativeNode(visit);
294657 0 : SgType::visitRepresentativeNode(visit);
294658 0 : SgForStatement::visitRepresentativeNode(visit);
294659 0 : SgForInitStatement::visitRepresentativeNode(visit);
294660 0 : SgRangeBasedForStatement::visitRepresentativeNode(visit);
294661 0 : SgCatchStatementSeq::visitRepresentativeNode(visit);
294662 0 : SgFunctionParameterList::visitRepresentativeNode(visit);
294663 0 : SgCtorInitializerList::visitRepresentativeNode(visit);
294664 0 : SgBasicBlock::visitRepresentativeNode(visit);
294665 0 : SgGlobal::visitRepresentativeNode(visit);
294666 0 : SgIfStmt::visitRepresentativeNode(visit);
294667 0 : SgWhileStmt::visitRepresentativeNode(visit);
294668 0 : SgDoWhileStmt::visitRepresentativeNode(visit);
294669 0 : SgSwitchStatement::visitRepresentativeNode(visit);
294670 0 : SgCatchOptionStmt::visitRepresentativeNode(visit);
294671 0 : SgFunctionParameterScope::visitRepresentativeNode(visit);
294672 0 : SgDeclarationScope::visitRepresentativeNode(visit);
294673 0 : SgVariableDefinition::visitRepresentativeNode(visit);
294674 0 : SgStmtDeclarationStatement::visitRepresentativeNode(visit);
294675 0 : SgEnumDeclaration::visitRepresentativeNode(visit);
294676 0 : SgAsmStmt::visitRepresentativeNode(visit);
294677 0 : SgFunctionTypeTable::visitRepresentativeNode(visit);
294678 0 : SgExprStatement::visitRepresentativeNode(visit);
294679 0 : SgLabelStatement::visitRepresentativeNode(visit);
294680 0 : SgCaseOptionStmt::visitRepresentativeNode(visit);
294681 0 : SgTryStmt::visitRepresentativeNode(visit);
294682 0 : SgDefaultOptionStmt::visitRepresentativeNode(visit);
294683 0 : SgBreakStmt::visitRepresentativeNode(visit);
294684 0 : SgContinueStmt::visitRepresentativeNode(visit);
294685 0 : SgReturnStmt::visitRepresentativeNode(visit);
294686 0 : SgGotoStatement::visitRepresentativeNode(visit);
294687 0 : SgSpawnStmt::visitRepresentativeNode(visit);
294688 0 : SgTemplateTypedefDeclaration::visitRepresentativeNode(visit);
294689 0 : SgTemplateInstantiationTypedefDeclaration::visitRepresentativeNode(visit);
294690 0 : SgTypedefDeclaration::visitRepresentativeNode(visit);
294691 0 : SgNullStatement::visitRepresentativeNode(visit);
294692 0 : SgVariantStatement::visitRepresentativeNode(visit);
294693 0 : SgPragmaDeclaration::visitRepresentativeNode(visit);
294694 0 : SgTemplateClassDeclaration::visitRepresentativeNode(visit);
294695 0 : SgTemplateMemberFunctionDeclaration::visitRepresentativeNode(visit);
294696 0 : SgTemplateFunctionDeclaration::visitRepresentativeNode(visit);
294697 0 : SgTemplateVariableDeclaration::visitRepresentativeNode(visit);
294698 0 : SgTemplateDeclaration::visitRepresentativeNode(visit);
294699 0 : SgVariableDeclaration::visitRepresentativeNode(visit);
294700 0 : SgTemplateInstantiationDecl::visitRepresentativeNode(visit);
294701 0 : SgTemplateInstantiationDefn::visitRepresentativeNode(visit);
294702 0 : SgTemplateInstantiationFunctionDecl::visitRepresentativeNode(visit);
294703 0 : SgTemplateInstantiationMemberFunctionDecl::visitRepresentativeNode(visit);
294704 0 : SgNonrealDecl::visitRepresentativeNode(visit);
294705 0 : SgWithStatement::visitRepresentativeNode(visit);
294706 0 : SgPassStatement::visitRepresentativeNode(visit);
294707 0 : SgAssertStmt::visitRepresentativeNode(visit);
294708 0 : SgExecStatement::visitRepresentativeNode(visit);
294709 0 : SgProgramHeaderStatement::visitRepresentativeNode(visit);
294710 0 : SgProcedureHeaderStatement::visitRepresentativeNode(visit);
294711 0 : SgEntryStatement::visitRepresentativeNode(visit);
294712 0 : SgFortranNonblockedDo::visitRepresentativeNode(visit);
294713 0 : SgInterfaceStatement::visitRepresentativeNode(visit);
294714 0 : SgParameterStatement::visitRepresentativeNode(visit);
294715 0 : SgCommonBlock::visitRepresentativeNode(visit);
294716 0 : SgModuleStatement::visitRepresentativeNode(visit);
294717 0 : SgUseStatement::visitRepresentativeNode(visit);
294718 0 : SgProcessControlStatement::visitRepresentativeNode(visit);
294719 0 : SgPrintStatement::visitRepresentativeNode(visit);
294720 0 : SgReadStatement::visitRepresentativeNode(visit);
294721 0 : SgWriteStatement::visitRepresentativeNode(visit);
294722 0 : SgOpenStatement::visitRepresentativeNode(visit);
294723 0 : SgCloseStatement::visitRepresentativeNode(visit);
294724 0 : SgInquireStatement::visitRepresentativeNode(visit);
294725 0 : SgFlushStatement::visitRepresentativeNode(visit);
294726 0 : SgBackspaceStatement::visitRepresentativeNode(visit);
294727 0 : SgRewindStatement::visitRepresentativeNode(visit);
294728 0 : SgEndfileStatement::visitRepresentativeNode(visit);
294729 0 : SgWaitStatement::visitRepresentativeNode(visit);
294730 0 : SgCAFWithTeamStatement::visitRepresentativeNode(visit);
294731 0 : SgFormatStatement::visitRepresentativeNode(visit);
294732 0 : SgFortranDo::visitRepresentativeNode(visit);
294733 0 : SgForAllStatement::visitRepresentativeNode(visit);
294734 0 : SgIOStatement::visitRepresentativeNode(visit);
294735 0 : SgSyncAllStatement::visitRepresentativeNode(visit);
294736 0 : SgSyncImagesStatement::visitRepresentativeNode(visit);
294737 0 : SgSyncMemoryStatement::visitRepresentativeNode(visit);
294738 0 : SgSyncTeamStatement::visitRepresentativeNode(visit);
294739 0 : SgLockStatement::visitRepresentativeNode(visit);
294740 0 : SgUnlockStatement::visitRepresentativeNode(visit);
294741 0 : SgImageControlStatement::visitRepresentativeNode(visit);
294742 0 : SgUpcNotifyStatement::visitRepresentativeNode(visit);
294743 0 : SgUpcWaitStatement::visitRepresentativeNode(visit);
294744 0 : SgUpcBarrierStatement::visitRepresentativeNode(visit);
294745 0 : SgUpcFenceStatement::visitRepresentativeNode(visit);
294746 0 : SgUpcForAllStatement::visitRepresentativeNode(visit);
294747 0 : SgUpirSpmdStatement::visitRepresentativeNode(visit);
294748 0 : SgOmpLoopStatement::visitRepresentativeNode(visit);
294749 0 : SgOmpScanStatement::visitRepresentativeNode(visit);
294750 0 : SgOmpTaskloopStatement::visitRepresentativeNode(visit);
294751 0 : SgOmpTaskgroupStatement::visitRepresentativeNode(visit);
294752 0 : SgOmpDepobjStatement::visitRepresentativeNode(visit);
294753 0 : SgOmpTeamsStatement::visitRepresentativeNode(visit);
294754 0 : SgOmpCancellationPointStatement::visitRepresentativeNode(visit);
294755 0 : SgOmpDeclareMapperStatement::visitRepresentativeNode(visit);
294756 0 : SgOmpCancelStatement::visitRepresentativeNode(visit);
294757 0 : SgOmpDistributeStatement::visitRepresentativeNode(visit);
294758 0 : SgOmpMetadirectiveStatement::visitRepresentativeNode(visit);
294759 0 : SgOmpSingleStatement::visitRepresentativeNode(visit);
294760 0 : SgOmpTaskStatement::visitRepresentativeNode(visit);
294761 0 : SgOmpTargetEnterDataStatement::visitRepresentativeNode(visit);
294762 0 : SgOmpTargetExitDataStatement::visitRepresentativeNode(visit);
294763 0 : SgUpirWorksharingStatement::visitRepresentativeNode(visit);
294764 0 : SgOmpForSimdStatement::visitRepresentativeNode(visit);
294765 0 : SgOmpDoStatement::visitRepresentativeNode(visit);
294766 0 : SgOmpSectionsStatement::visitRepresentativeNode(visit);
294767 0 : SgOmpAtomicStatement::visitRepresentativeNode(visit);
294768 0 : SgUpirTaskStatement::visitRepresentativeNode(visit);
294769 0 : SgOmpTargetDataStatement::visitRepresentativeNode(visit);
294770 0 : SgOmpTargetParallelForStatement::visitRepresentativeNode(visit);
294771 0 : SgOmpTargetParallelStatement::visitRepresentativeNode(visit);
294772 0 : SgOmpDistributeSimdStatement::visitRepresentativeNode(visit);
294773 0 : SgOmpDistributeParallelForStatement::visitRepresentativeNode(visit);
294774 0 : SgOmpDistributeParallelForSimdStatement::visitRepresentativeNode(visit);
294775 0 : SgOmpTaskloopSimdStatement::visitRepresentativeNode(visit);
294776 0 : SgOmpTargetUpdateStatement::visitRepresentativeNode(visit);
294777 0 : SgOmpTargetParallelForSimdStatement::visitRepresentativeNode(visit);
294778 0 : SgOmpTargetParallelLoopStatement::visitRepresentativeNode(visit);
294779 0 : SgOmpTargetSimdStatement::visitRepresentativeNode(visit);
294780 0 : SgOmpTargetTeamsStatement::visitRepresentativeNode(visit);
294781 0 : SgOmpTargetTeamsDistributeStatement::visitRepresentativeNode(visit);
294782 0 : SgOmpTargetTeamsDistributeSimdStatement::visitRepresentativeNode(visit);
294783 0 : SgOmpTargetTeamsLoopStatement::visitRepresentativeNode(visit);
294784 0 : SgOmpTargetTeamsDistributeParallelForStatement::visitRepresentativeNode(visit);
294785 0 : SgOmpTargetTeamsDistributeParallelForSimdStatement::visitRepresentativeNode(visit);
294786 0 : SgOmpMasterTaskloopSimdStatement::visitRepresentativeNode(visit);
294787 0 : SgOmpParallelMasterTaskloopStatement::visitRepresentativeNode(visit);
294788 0 : SgOmpParallelMasterTaskloopSimdStatement::visitRepresentativeNode(visit);
294789 0 : SgOmpTeamsDistributeStatement::visitRepresentativeNode(visit);
294790 0 : SgOmpTeamsDistributeSimdStatement::visitRepresentativeNode(visit);
294791 0 : SgOmpTeamsDistributeParallelForStatement::visitRepresentativeNode(visit);
294792 0 : SgOmpTeamsDistributeParallelForSimdStatement::visitRepresentativeNode(visit);
294793 0 : SgOmpTeamsLoopStatement::visitRepresentativeNode(visit);
294794 0 : SgOmpParallelMasterStatement::visitRepresentativeNode(visit);
294795 0 : SgOmpMasterTaskloopStatement::visitRepresentativeNode(visit);
294796 0 : SgOmpParallelLoopStatement::visitRepresentativeNode(visit);
294797 0 : SgOmpUnrollStatement::visitRepresentativeNode(visit);
294798 0 : SgOmpTileStatement::visitRepresentativeNode(visit);
294799 0 : SgUpirSimdStatement::visitRepresentativeNode(visit);
294800 0 : SgOmpCriticalStatement::visitRepresentativeNode(visit);
294801 0 : SgOmpOrderedStatement::visitRepresentativeNode(visit);
294802 0 : SgUpirLoopStatement::visitRepresentativeNode(visit);
294803 0 : SgUpirLoopParallelStatement::visitRepresentativeNode(visit);
294804 0 : SgUpirSyncStatement::visitRepresentativeNode(visit);
294805 0 : SgUpirFieldBodyStatement::visitRepresentativeNode(visit);
294806 0 : SgOmpMasterStatement::visitRepresentativeNode(visit);
294807 0 : SgOmpSectionStatement::visitRepresentativeNode(visit);
294808 0 : SgOmpWorkshareStatement::visitRepresentativeNode(visit);
294809 0 : SgOmpFlushStatement::visitRepresentativeNode(visit);
294810 0 : SgOmpAllocateStatement::visitRepresentativeNode(visit);
294811 0 : SgOmpOrderedDependStatement::visitRepresentativeNode(visit);
294812 0 : SgUpirBodyStatement::visitRepresentativeNode(visit);
294813 0 : SgUpirFieldStatement::visitRepresentativeNode(visit);
294814 0 : SgBlockDataStatement::visitRepresentativeNode(visit);
294815 0 : SgImplicitStatement::visitRepresentativeNode(visit);
294816 0 : SgStatementFunctionStatement::visitRepresentativeNode(visit);
294817 0 : SgWhereStatement::visitRepresentativeNode(visit);
294818 0 : SgNullifyStatement::visitRepresentativeNode(visit);
294819 0 : SgEquivalenceStatement::visitRepresentativeNode(visit);
294820 0 : SgDerivedTypeStatement::visitRepresentativeNode(visit);
294821 0 : SgAttributeSpecificationStatement::visitRepresentativeNode(visit);
294822 0 : SgAllocateStatement::visitRepresentativeNode(visit);
294823 0 : SgDeallocateStatement::visitRepresentativeNode(visit);
294824 0 : SgContainsStatement::visitRepresentativeNode(visit);
294825 0 : SgSequenceStatement::visitRepresentativeNode(visit);
294826 0 : SgElseWhereStatement::visitRepresentativeNode(visit);
294827 0 : SgArithmeticIfStatement::visitRepresentativeNode(visit);
294828 0 : SgAssignStatement::visitRepresentativeNode(visit);
294829 0 : SgComputedGotoStatement::visitRepresentativeNode(visit);
294830 0 : SgAssignedGotoStatement::visitRepresentativeNode(visit);
294831 0 : SgNamelistStatement::visitRepresentativeNode(visit);
294832 0 : SgImportStatement::visitRepresentativeNode(visit);
294833 0 : SgAssociateStatement::visitRepresentativeNode(visit);
294834 0 : SgFortranIncludeLine::visitRepresentativeNode(visit);
294835 0 : SgNamespaceDeclarationStatement::visitRepresentativeNode(visit);
294836 0 : SgNamespaceAliasDeclarationStatement::visitRepresentativeNode(visit);
294837 0 : SgNamespaceDefinitionStatement::visitRepresentativeNode(visit);
294838 0 : SgUsingDeclarationStatement::visitRepresentativeNode(visit);
294839 0 : SgUsingDirectiveStatement::visitRepresentativeNode(visit);
294840 0 : SgTemplateInstantiationDirectiveStatement::visitRepresentativeNode(visit);
294841 0 : SgStaticAssertionDeclaration::visitRepresentativeNode(visit);
294842 0 : SgTemplateClassDefinition::visitRepresentativeNode(visit);
294843 0 : SgTemplateFunctionDefinition::visitRepresentativeNode(visit);
294844 0 : SgClassDeclaration::visitRepresentativeNode(visit);
294845 0 : SgClassDefinition::visitRepresentativeNode(visit);
294846 0 : SgFunctionDefinition::visitRepresentativeNode(visit);
294847 0 : SgScopeStatement::visitRepresentativeNode(visit);
294848 0 : SgMemberFunctionDeclaration::visitRepresentativeNode(visit);
294849 0 : SgFunctionDeclaration::visitRepresentativeNode(visit);
294850 0 : SgIncludeDirectiveStatement::visitRepresentativeNode(visit);
294851 0 : SgDefineDirectiveStatement::visitRepresentativeNode(visit);
294852 0 : SgUndefDirectiveStatement::visitRepresentativeNode(visit);
294853 0 : SgIfdefDirectiveStatement::visitRepresentativeNode(visit);
294854 0 : SgIfndefDirectiveStatement::visitRepresentativeNode(visit);
294855 0 : SgIfDirectiveStatement::visitRepresentativeNode(visit);
294856 0 : SgDeadIfDirectiveStatement::visitRepresentativeNode(visit);
294857 0 : SgElseDirectiveStatement::visitRepresentativeNode(visit);
294858 0 : SgElseifDirectiveStatement::visitRepresentativeNode(visit);
294859 0 : SgEndifDirectiveStatement::visitRepresentativeNode(visit);
294860 0 : SgLineDirectiveStatement::visitRepresentativeNode(visit);
294861 0 : SgWarningDirectiveStatement::visitRepresentativeNode(visit);
294862 0 : SgErrorDirectiveStatement::visitRepresentativeNode(visit);
294863 0 : SgEmptyDirectiveStatement::visitRepresentativeNode(visit);
294864 0 : SgIncludeNextDirectiveStatement::visitRepresentativeNode(visit);
294865 0 : SgIdentDirectiveStatement::visitRepresentativeNode(visit);
294866 0 : SgLinemarkerDirectiveStatement::visitRepresentativeNode(visit);
294867 0 : SgC_PreprocessorDirectiveStatement::visitRepresentativeNode(visit);
294868 0 : SgClinkageStartStatement::visitRepresentativeNode(visit);
294869 0 : SgClinkageEndStatement::visitRepresentativeNode(visit);
294870 0 : SgClinkageDeclarationStatement::visitRepresentativeNode(visit);
294871 0 : SgOmpDeclareSimdStatement::visitRepresentativeNode(visit);
294872 0 : SgOmpBarrierStatement::visitRepresentativeNode(visit);
294873 0 : SgOmpTaskyieldStatement::visitRepresentativeNode(visit);
294874 0 : SgOmpRequiresStatement::visitRepresentativeNode(visit);
294875 0 : SgOmpTaskwaitStatement::visitRepresentativeNode(visit);
294876 0 : SgOmpThreadprivateStatement::visitRepresentativeNode(visit);
294877 0 : SgMicrosoftAttributeDeclaration::visitRepresentativeNode(visit);
294878 0 : SgEmptyDeclaration::visitRepresentativeNode(visit);
294879 0 : SgDeclarationStatement::visitRepresentativeNode(visit);
294880 0 : SgUpirBaseStatement::visitRepresentativeNode(visit);
294881 0 : SgStatement::visitRepresentativeNode(visit);
294882 0 : SgVarRefExp::visitRepresentativeNode(visit);
294883 0 : SgNonrealRefExp::visitRepresentativeNode(visit);
294884 0 : SgCompoundLiteralExp::visitRepresentativeNode(visit);
294885 0 : SgLabelRefExp::visitRepresentativeNode(visit);
294886 0 : SgClassNameRefExp::visitRepresentativeNode(visit);
294887 0 : SgFunctionRefExp::visitRepresentativeNode(visit);
294888 0 : SgMemberFunctionRefExp::visitRepresentativeNode(visit);
294889 0 : SgTemplateFunctionRefExp::visitRepresentativeNode(visit);
294890 0 : SgTemplateMemberFunctionRefExp::visitRepresentativeNode(visit);
294891 0 : SgSizeOfOp::visitRepresentativeNode(visit);
294892 0 : SgAlignOfOp::visitRepresentativeNode(visit);
294893 0 : SgNoexceptOp::visitRepresentativeNode(visit);
294894 0 : SgTypeExpression::visitRepresentativeNode(visit);
294895 0 : SgLambdaExp::visitRepresentativeNode(visit);
294896 0 : SgUpcLocalsizeofExpression::visitRepresentativeNode(visit);
294897 0 : SgUpcBlocksizeofExpression::visitRepresentativeNode(visit);
294898 0 : SgUpcElemsizeofExpression::visitRepresentativeNode(visit);
294899 0 : SgVarArgStartOp::visitRepresentativeNode(visit);
294900 0 : SgVarArgStartOneOperandOp::visitRepresentativeNode(visit);
294901 0 : SgVarArgOp::visitRepresentativeNode(visit);
294902 0 : SgVarArgEndOp::visitRepresentativeNode(visit);
294903 0 : SgVarArgCopyOp::visitRepresentativeNode(visit);
294904 0 : SgTypeIdOp::visitRepresentativeNode(visit);
294905 0 : SgConditionalExp::visitRepresentativeNode(visit);
294906 0 : SgNewExp::visitRepresentativeNode(visit);
294907 0 : SgDeleteExp::visitRepresentativeNode(visit);
294908 0 : SgThisExp::visitRepresentativeNode(visit);
294909 0 : SgSuperExp::visitRepresentativeNode(visit);
294910 0 : SgClassExp::visitRepresentativeNode(visit);
294911 0 : SgRefExp::visitRepresentativeNode(visit);
294912 0 : SgAggregateInitializer::visitRepresentativeNode(visit);
294913 0 : SgCompoundInitializer::visitRepresentativeNode(visit);
294914 0 : SgConstructorInitializer::visitRepresentativeNode(visit);
294915 0 : SgAssignInitializer::visitRepresentativeNode(visit);
294916 0 : SgBracedInitializer::visitRepresentativeNode(visit);
294917 0 : SgExpressionRoot::visitRepresentativeNode(visit);
294918 0 : SgMinusOp::visitRepresentativeNode(visit);
294919 0 : SgUnaryAddOp::visitRepresentativeNode(visit);
294920 0 : SgNotOp::visitRepresentativeNode(visit);
294921 0 : SgPointerDerefExp::visitRepresentativeNode(visit);
294922 0 : SgAddressOfOp::visitRepresentativeNode(visit);
294923 0 : SgMinusMinusOp::visitRepresentativeNode(visit);
294924 0 : SgPlusPlusOp::visitRepresentativeNode(visit);
294925 0 : SgBitComplementOp::visitRepresentativeNode(visit);
294926 0 : SgRealPartOp::visitRepresentativeNode(visit);
294927 0 : SgImagPartOp::visitRepresentativeNode(visit);
294928 0 : SgConjugateOp::visitRepresentativeNode(visit);
294929 0 : SgCastExp::visitRepresentativeNode(visit);
294930 0 : SgThrowOp::visitRepresentativeNode(visit);
294931 0 : SgArrowExp::visitRepresentativeNode(visit);
294932 0 : SgDotExp::visitRepresentativeNode(visit);
294933 0 : SgDotStarOp::visitRepresentativeNode(visit);
294934 0 : SgArrowStarOp::visitRepresentativeNode(visit);
294935 0 : SgEqualityOp::visitRepresentativeNode(visit);
294936 0 : SgLessThanOp::visitRepresentativeNode(visit);
294937 0 : SgGreaterThanOp::visitRepresentativeNode(visit);
294938 0 : SgNotEqualOp::visitRepresentativeNode(visit);
294939 0 : SgLessOrEqualOp::visitRepresentativeNode(visit);
294940 0 : SgGreaterOrEqualOp::visitRepresentativeNode(visit);
294941 0 : SgAddOp::visitRepresentativeNode(visit);
294942 0 : SgSubtractOp::visitRepresentativeNode(visit);
294943 0 : SgMultiplyOp::visitRepresentativeNode(visit);
294944 0 : SgDivideOp::visitRepresentativeNode(visit);
294945 0 : SgIntegerDivideOp::visitRepresentativeNode(visit);
294946 0 : SgModOp::visitRepresentativeNode(visit);
294947 0 : SgAndOp::visitRepresentativeNode(visit);
294948 0 : SgOrOp::visitRepresentativeNode(visit);
294949 0 : SgBitXorOp::visitRepresentativeNode(visit);
294950 0 : SgBitAndOp::visitRepresentativeNode(visit);
294951 0 : SgBitOrOp::visitRepresentativeNode(visit);
294952 0 : SgBitEqvOp::visitRepresentativeNode(visit);
294953 0 : SgCommaOpExp::visitRepresentativeNode(visit);
294954 0 : SgLshiftOp::visitRepresentativeNode(visit);
294955 0 : SgRshiftOp::visitRepresentativeNode(visit);
294956 0 : SgPntrArrRefExp::visitRepresentativeNode(visit);
294957 0 : SgScopeOp::visitRepresentativeNode(visit);
294958 0 : SgAssignOp::visitRepresentativeNode(visit);
294959 0 : SgPlusAssignOp::visitRepresentativeNode(visit);
294960 0 : SgMinusAssignOp::visitRepresentativeNode(visit);
294961 0 : SgAndAssignOp::visitRepresentativeNode(visit);
294962 0 : SgIorAssignOp::visitRepresentativeNode(visit);
294963 0 : SgMultAssignOp::visitRepresentativeNode(visit);
294964 0 : SgDivAssignOp::visitRepresentativeNode(visit);
294965 0 : SgModAssignOp::visitRepresentativeNode(visit);
294966 0 : SgXorAssignOp::visitRepresentativeNode(visit);
294967 0 : SgLshiftAssignOp::visitRepresentativeNode(visit);
294968 0 : SgRshiftAssignOp::visitRepresentativeNode(visit);
294969 0 : SgIntegerDivideAssignOp::visitRepresentativeNode(visit);
294970 0 : SgExponentiationAssignOp::visitRepresentativeNode(visit);
294971 0 : SgConcatenationOp::visitRepresentativeNode(visit);
294972 0 : SgNaryComparisonOp::visitRepresentativeNode(visit);
294973 0 : SgNaryBooleanOp::visitRepresentativeNode(visit);
294974 0 : SgBoolValExp::visitRepresentativeNode(visit);
294975 0 : SgStringVal::visitRepresentativeNode(visit);
294976 0 : SgShortVal::visitRepresentativeNode(visit);
294977 0 : SgCharVal::visitRepresentativeNode(visit);
294978 0 : SgUnsignedCharVal::visitRepresentativeNode(visit);
294979 0 : SgWcharVal::visitRepresentativeNode(visit);
294980 0 : SgChar16Val::visitRepresentativeNode(visit);
294981 0 : SgChar32Val::visitRepresentativeNode(visit);
294982 0 : SgUnsignedShortVal::visitRepresentativeNode(visit);
294983 0 : SgIntVal::visitRepresentativeNode(visit);
294984 0 : SgEnumVal::visitRepresentativeNode(visit);
294985 0 : SgUnsignedIntVal::visitRepresentativeNode(visit);
294986 0 : SgLongIntVal::visitRepresentativeNode(visit);
294987 0 : SgLongLongIntVal::visitRepresentativeNode(visit);
294988 0 : SgUnsignedLongLongIntVal::visitRepresentativeNode(visit);
294989 0 : SgUnsignedLongVal::visitRepresentativeNode(visit);
294990 0 : SgFloatVal::visitRepresentativeNode(visit);
294991 0 : SgDoubleVal::visitRepresentativeNode(visit);
294992 0 : SgLongDoubleVal::visitRepresentativeNode(visit);
294993 0 : SgFloat80Val::visitRepresentativeNode(visit);
294994 0 : SgFloat128Val::visitRepresentativeNode(visit);
294995 0 : SgNullptrValExp::visitRepresentativeNode(visit);
294996 0 : SgVoidVal::visitRepresentativeNode(visit);
294997 0 : SgFunctionParameterRefExp::visitRepresentativeNode(visit);
294998 0 : SgTemplateParameterVal::visitRepresentativeNode(visit);
294999 0 : SgUpcThreads::visitRepresentativeNode(visit);
295000 0 : SgUpcMythread::visitRepresentativeNode(visit);
295001 0 : SgComplexVal::visitRepresentativeNode(visit);
295002 0 : SgNullExpression::visitRepresentativeNode(visit);
295003 0 : SgVariantExpression::visitRepresentativeNode(visit);
295004 0 : SgStatementExpression::visitRepresentativeNode(visit);
295005 0 : SgAsmOp::visitRepresentativeNode(visit);
295006 0 : SgCudaKernelExecConfig::visitRepresentativeNode(visit);
295007 0 : SgCudaKernelCallExp::visitRepresentativeNode(visit);
295008 0 : SgLambdaRefExp::visitRepresentativeNode(visit);
295009 0 : SgTupleExp::visitRepresentativeNode(visit);
295010 0 : SgListExp::visitRepresentativeNode(visit);
295011 0 : SgDictionaryExp::visitRepresentativeNode(visit);
295012 0 : SgKeyDatumPair::visitRepresentativeNode(visit);
295013 0 : SgComprehension::visitRepresentativeNode(visit);
295014 0 : SgListComprehension::visitRepresentativeNode(visit);
295015 0 : SgSetComprehension::visitRepresentativeNode(visit);
295016 0 : SgDictionaryComprehension::visitRepresentativeNode(visit);
295017 0 : SgMembershipOp::visitRepresentativeNode(visit);
295018 0 : SgNonMembershipOp::visitRepresentativeNode(visit);
295019 0 : SgIsOp::visitRepresentativeNode(visit);
295020 0 : SgIsNotOp::visitRepresentativeNode(visit);
295021 0 : SgStringConversion::visitRepresentativeNode(visit);
295022 0 : SgYieldExpression::visitRepresentativeNode(visit);
295023 0 : SgFoldExpression::visitRepresentativeNode(visit);
295024 0 : SgChooseExpression::visitRepresentativeNode(visit);
295025 0 : SgAwaitExpression::visitRepresentativeNode(visit);
295026 0 : SgSpaceshipOp::visitRepresentativeNode(visit);
295027 0 : SgSubscriptExpression::visitRepresentativeNode(visit);
295028 0 : SgColonShapeExp::visitRepresentativeNode(visit);
295029 0 : SgAsteriskShapeExp::visitRepresentativeNode(visit);
295030 0 : SgIOItemExpression::visitRepresentativeNode(visit);
295031 0 : SgImpliedDo::visitRepresentativeNode(visit);
295032 0 : SgExponentiationOp::visitRepresentativeNode(visit);
295033 0 : SgUnknownArrayOrFunctionReference::visitRepresentativeNode(visit);
295034 0 : SgActualArgumentExpression::visitRepresentativeNode(visit);
295035 0 : SgUserDefinedBinaryOp::visitRepresentativeNode(visit);
295036 0 : SgPointerAssignOp::visitRepresentativeNode(visit);
295037 0 : SgCAFCoExpression::visitRepresentativeNode(visit);
295038 0 : SgDesignatedInitializer::visitRepresentativeNode(visit);
295039 0 : SgMatrixExp::visitRepresentativeNode(visit);
295040 0 : SgRangeExp::visitRepresentativeNode(visit);
295041 0 : SgMagicColonExp::visitRepresentativeNode(visit);
295042 0 : SgElementwiseMultiplyOp::visitRepresentativeNode(visit);
295043 0 : SgPowerOp::visitRepresentativeNode(visit);
295044 0 : SgElementwisePowerOp::visitRepresentativeNode(visit);
295045 0 : SgElementwiseDivideOp::visitRepresentativeNode(visit);
295046 0 : SgLeftDivideOp::visitRepresentativeNode(visit);
295047 0 : SgElementwiseLeftDivideOp::visitRepresentativeNode(visit);
295048 0 : SgElementwiseAddOp::visitRepresentativeNode(visit);
295049 0 : SgElementwiseSubtractOp::visitRepresentativeNode(visit);
295050 0 : SgMatrixTransposeOp::visitRepresentativeNode(visit);
295051 0 : SgElementwiseOp::visitRepresentativeNode(visit);
295052 0 : SgInitializer::visitRepresentativeNode(visit);
295053 0 : SgSIMDLoad::visitRepresentativeNode(visit);
295054 0 : SgSIMDBroadcast::visitRepresentativeNode(visit);
295055 0 : SgSIMDStore::visitRepresentativeNode(visit);
295056 0 : SgSIMDPartialStore::visitRepresentativeNode(visit);
295057 0 : SgSIMDScalarStore::visitRepresentativeNode(visit);
295058 0 : SgSIMDGather::visitRepresentativeNode(visit);
295059 0 : SgSIMDExplicitGather::visitRepresentativeNode(visit);
295060 0 : SgSIMDScatter::visitRepresentativeNode(visit);
295061 0 : SgSIMDAddOp::visitRepresentativeNode(visit);
295062 0 : SgSIMDSubOp::visitRepresentativeNode(visit);
295063 0 : SgSIMDMulOp::visitRepresentativeNode(visit);
295064 0 : SgSIMDDivOp::visitRepresentativeNode(visit);
295065 0 : SgSIMDFmaOp::visitRepresentativeNode(visit);
295066 0 : SgSIMDBinaryOp::visitRepresentativeNode(visit);
295067 0 : SgUserDefinedUnaryOp::visitRepresentativeNode(visit);
295068 0 : SgPseudoDestructorRefExp::visitRepresentativeNode(visit);
295069 0 : SgUnaryOp::visitRepresentativeNode(visit);
295070 0 : SgCompoundAssignOp::visitRepresentativeNode(visit);
295071 0 : SgBinaryOp::visitRepresentativeNode(visit);
295072 0 : SgNaryOp::visitRepresentativeNode(visit);
295073 0 : SgValueExp::visitRepresentativeNode(visit);
295074 0 : SgExprListExp::visitRepresentativeNode(visit);
295075 0 : SgFunctionCallExp::visitRepresentativeNode(visit);
295076 0 : SgCallExpression::visitRepresentativeNode(visit);
295077 0 : SgTypeTraitBuiltinOperator::visitRepresentativeNode(visit);
295078 0 : SgExpression::visitRepresentativeNode(visit);
295079 0 : SgTemplateVariableSymbol::visitRepresentativeNode(visit);
295080 0 : SgVariableSymbol::visitRepresentativeNode(visit);
295081 0 : SgFunctionTypeSymbol::visitRepresentativeNode(visit);
295082 0 : SgTemplateClassSymbol::visitRepresentativeNode(visit);
295083 0 : SgClassSymbol::visitRepresentativeNode(visit);
295084 0 : SgTemplateSymbol::visitRepresentativeNode(visit);
295085 0 : SgEnumSymbol::visitRepresentativeNode(visit);
295086 0 : SgEnumFieldSymbol::visitRepresentativeNode(visit);
295087 0 : SgTemplateTypedefSymbol::visitRepresentativeNode(visit);
295088 0 : SgTypedefSymbol::visitRepresentativeNode(visit);
295089 0 : SgTemplateFunctionSymbol::visitRepresentativeNode(visit);
295090 0 : SgTemplateMemberFunctionSymbol::visitRepresentativeNode(visit);
295091 0 : SgLabelSymbol::visitRepresentativeNode(visit);
295092 0 : SgDefaultSymbol::visitRepresentativeNode(visit);
295093 0 : SgNamespaceSymbol::visitRepresentativeNode(visit);
295094 0 : SgIntrinsicSymbol::visitRepresentativeNode(visit);
295095 0 : SgModuleSymbol::visitRepresentativeNode(visit);
295096 0 : SgInterfaceSymbol::visitRepresentativeNode(visit);
295097 0 : SgCommonSymbol::visitRepresentativeNode(visit);
295098 0 : SgRenameSymbol::visitRepresentativeNode(visit);
295099 0 : SgMemberFunctionSymbol::visitRepresentativeNode(visit);
295100 0 : SgFunctionSymbol::visitRepresentativeNode(visit);
295101 0 : SgAliasSymbol::visitRepresentativeNode(visit);
295102 0 : SgNonrealSymbol::visitRepresentativeNode(visit);
295103 0 : SgSymbol::visitRepresentativeNode(visit);
295104 0 : SgCommonBlockObject::visitRepresentativeNode(visit);
295105 0 : SgInitializedName::visitRepresentativeNode(visit);
295106 0 : SgLambdaCapture::visitRepresentativeNode(visit);
295107 0 : SgLambdaCaptureList::visitRepresentativeNode(visit);
295108 0 : SgOmpOrderedClause::visitRepresentativeNode(visit);
295109 0 : SgOmpNowaitClause::visitRepresentativeNode(visit);
295110 0 : SgOmpNogroupClause::visitRepresentativeNode(visit);
295111 0 : SgOmpReadClause::visitRepresentativeNode(visit);
295112 0 : SgOmpThreadsClause::visitRepresentativeNode(visit);
295113 0 : SgOmpSimdClause::visitRepresentativeNode(visit);
295114 0 : SgOmpReverseOffloadClause::visitRepresentativeNode(visit);
295115 0 : SgOmpExtImplementationDefinedRequirementClause::visitRepresentativeNode(visit);
295116 0 : SgOmpUnifiedAddressClause::visitRepresentativeNode(visit);
295117 0 : SgOmpUnifiedSharedMemoryClause::visitRepresentativeNode(visit);
295118 0 : SgOmpDynamicAllocatorsClause::visitRepresentativeNode(visit);
295119 0 : SgOmpAtomicDefaultMemOrderClause::visitRepresentativeNode(visit);
295120 0 : SgOmpWriteClause::visitRepresentativeNode(visit);
295121 0 : SgOmpUpdateClause::visitRepresentativeNode(visit);
295122 0 : SgOmpDepobjUpdateClause::visitRepresentativeNode(visit);
295123 0 : SgOmpDestroyClause::visitRepresentativeNode(visit);
295124 0 : SgOmpCaptureClause::visitRepresentativeNode(visit);
295125 0 : SgOmpSeqCstClause::visitRepresentativeNode(visit);
295126 0 : SgOmpAcqRelClause::visitRepresentativeNode(visit);
295127 0 : SgOmpReleaseClause::visitRepresentativeNode(visit);
295128 0 : SgOmpAcquireClause::visitRepresentativeNode(visit);
295129 0 : SgOmpRelaxedClause::visitRepresentativeNode(visit);
295130 0 : SgOmpParallelClause::visitRepresentativeNode(visit);
295131 0 : SgOmpSectionsClause::visitRepresentativeNode(visit);
295132 0 : SgOmpForClause::visitRepresentativeNode(visit);
295133 0 : SgOmpTaskgroupClause::visitRepresentativeNode(visit);
295134 0 : SgOmpBeginClause::visitRepresentativeNode(visit);
295135 0 : SgOmpEndClause::visitRepresentativeNode(visit);
295136 0 : SgOmpUntiedClause::visitRepresentativeNode(visit);
295137 0 : SgOmpMergeableClause::visitRepresentativeNode(visit);
295138 0 : SgOmpDefaultClause::visitRepresentativeNode(visit);
295139 0 : SgOmpAtomicClause::visitRepresentativeNode(visit);
295140 0 : SgOmpProcBindClause::visitRepresentativeNode(visit);
295141 0 : SgOmpOrderClause::visitRepresentativeNode(visit);
295142 0 : SgOmpBindClause::visitRepresentativeNode(visit);
295143 0 : SgOmpInbranchClause::visitRepresentativeNode(visit);
295144 0 : SgOmpNotinbranchClause::visitRepresentativeNode(visit);
295145 0 : SgOmpCollapseClause::visitRepresentativeNode(visit);
295146 0 : SgOmpIfClause::visitRepresentativeNode(visit);
295147 0 : SgOmpFinalClause::visitRepresentativeNode(visit);
295148 0 : SgOmpPriorityClause::visitRepresentativeNode(visit);
295149 0 : SgUpirNumUnitsField::visitRepresentativeNode(visit);
295150 0 : SgOmpNumTeamsClause::visitRepresentativeNode(visit);
295151 0 : SgOmpGrainsizeClause::visitRepresentativeNode(visit);
295152 0 : SgOmpDetachClause::visitRepresentativeNode(visit);
295153 0 : SgOmpNumTasksClause::visitRepresentativeNode(visit);
295154 0 : SgOmpHintClause::visitRepresentativeNode(visit);
295155 0 : SgOmpThreadLimitClause::visitRepresentativeNode(visit);
295156 0 : SgOmpNontemporalClause::visitRepresentativeNode(visit);
295157 0 : SgOmpInclusiveClause::visitRepresentativeNode(visit);
295158 0 : SgOmpExclusiveClause::visitRepresentativeNode(visit);
295159 0 : SgOmpIsDevicePtrClause::visitRepresentativeNode(visit);
295160 0 : SgOmpUseDevicePtrClause::visitRepresentativeNode(visit);
295161 0 : SgOmpUseDeviceAddrClause::visitRepresentativeNode(visit);
295162 0 : SgOmpDeviceClause::visitRepresentativeNode(visit);
295163 0 : SgOmpSafelenClause::visitRepresentativeNode(visit);
295164 0 : SgOmpSimdlenClause::visitRepresentativeNode(visit);
295165 0 : SgOmpPartialClause::visitRepresentativeNode(visit);
295166 0 : SgOmpFullClause::visitRepresentativeNode(visit);
295167 0 : SgOmpSizesClause::visitRepresentativeNode(visit);
295168 0 : SgUpirBranchField::visitRepresentativeNode(visit);
295169 0 : SgUpirNestedLevelField::visitRepresentativeNode(visit);
295170 0 : SgUpirNestedParentField::visitRepresentativeNode(visit);
295171 0 : SgUpirNestedChildField::visitRepresentativeNode(visit);
295172 0 : SgUpirSyncField::visitRepresentativeNode(visit);
295173 0 : SgUpirDataField::visitRepresentativeNode(visit);
295174 0 : SgUpirTargetField::visitRepresentativeNode(visit);
295175 0 : SgUpirDataItemField::visitRepresentativeNode(visit);
295176 0 : SgOmpExpressionClause::visitRepresentativeNode(visit);
295177 0 : SgOmpCopyprivateClause::visitRepresentativeNode(visit);
295178 0 : SgOmpPrivateClause::visitRepresentativeNode(visit);
295179 0 : SgOmpFirstprivateClause::visitRepresentativeNode(visit);
295180 0 : SgOmpSharedClause::visitRepresentativeNode(visit);
295181 0 : SgOmpCopyinClause::visitRepresentativeNode(visit);
295182 0 : SgOmpLastprivateClause::visitRepresentativeNode(visit);
295183 0 : SgOmpReductionClause::visitRepresentativeNode(visit);
295184 0 : SgOmpInReductionClause::visitRepresentativeNode(visit);
295185 0 : SgOmpTaskReductionClause::visitRepresentativeNode(visit);
295186 0 : SgOmpAllocateClause::visitRepresentativeNode(visit);
295187 0 : SgOmpDependClause::visitRepresentativeNode(visit);
295188 0 : SgOmpToClause::visitRepresentativeNode(visit);
295189 0 : SgOmpUsesAllocatorsClause::visitRepresentativeNode(visit);
295190 0 : SgOmpFromClause::visitRepresentativeNode(visit);
295191 0 : SgOmpAffinityClause::visitRepresentativeNode(visit);
295192 0 : SgOmpMapClause::visitRepresentativeNode(visit);
295193 0 : SgOmpLinearClause::visitRepresentativeNode(visit);
295194 0 : SgOmpUniformClause::visitRepresentativeNode(visit);
295195 0 : SgOmpAlignedClause::visitRepresentativeNode(visit);
295196 0 : SgOmpVariablesClause::visitRepresentativeNode(visit);
295197 0 : SgOmpScheduleClause::visitRepresentativeNode(visit);
295198 0 : SgOmpWhenClause::visitRepresentativeNode(visit);
295199 0 : SgOmpDistScheduleClause::visitRepresentativeNode(visit);
295200 0 : SgOmpDefaultmapClause::visitRepresentativeNode(visit);
295201 0 : SgOmpAllocatorClause::visitRepresentativeNode(visit);
295202 0 : SgOmpUsesAllocatorsDefination::visitRepresentativeNode(visit);
295203 0 : SgOmpClause::visitRepresentativeNode(visit);
295204 0 : SgRenamePair::visitRepresentativeNode(visit);
295205 0 : SgInterfaceBody::visitRepresentativeNode(visit);
295206 0 : SgHeaderFileBody::visitRepresentativeNode(visit);
295207 0 : SgLocatedNodeSupport::visitRepresentativeNode(visit);
295208 0 : SgToken::visitRepresentativeNode(visit);
295209 0 : SgLocatedNode::visitRepresentativeNode(visit);
295210 0 : SgNode::visitRepresentativeNode(visit);
295211 0 : }
295212 :
295213 :
295214 :
295215 0 : size_t memoryUsage ()
295216 : {
295217 0 : size_t count = 0;
295218 :
295219 0 : count += SgName::memoryUsage();
295220 0 : count += SgSymbolTable::memoryUsage();
295221 0 : count += SgPragma::memoryUsage();
295222 0 : count += SgModifierNodes::memoryUsage();
295223 0 : count += SgConstVolatileModifier::memoryUsage();
295224 0 : count += SgStorageModifier::memoryUsage();
295225 0 : count += SgAccessModifier::memoryUsage();
295226 0 : count += SgFunctionModifier::memoryUsage();
295227 0 : count += SgUPC_AccessModifier::memoryUsage();
295228 0 : count += SgLinkageModifier::memoryUsage();
295229 0 : count += SgSpecialFunctionModifier::memoryUsage();
295230 0 : count += SgTypeModifier::memoryUsage();
295231 0 : count += SgElaboratedTypeModifier::memoryUsage();
295232 0 : count += SgBaseClassModifier::memoryUsage();
295233 0 : count += SgDeclarationModifier::memoryUsage();
295234 0 : count += SgStructureModifier::memoryUsage();
295235 0 : count += SgOpenclAccessModeModifier::memoryUsage();
295236 0 : count += SgModifier::memoryUsage();
295237 0 : count += Sg_File_Info::memoryUsage();
295238 0 : count += SgSourceFile::memoryUsage();
295239 0 : count += SgUnknownFile::memoryUsage();
295240 0 : count += SgFile::memoryUsage();
295241 0 : count += SgFileList::memoryUsage();
295242 0 : count += SgDirectory::memoryUsage();
295243 0 : count += SgDirectoryList::memoryUsage();
295244 0 : count += SgProject::memoryUsage();
295245 0 : count += SgOptions::memoryUsage();
295246 0 : count += SgUnparse_Info::memoryUsage();
295247 0 : count += SgIncludeFile::memoryUsage();
295248 0 : count += SgFuncDecl_attr::memoryUsage();
295249 0 : count += SgClassDecl_attr::memoryUsage();
295250 0 : count += SgTypedefSeq::memoryUsage();
295251 0 : count += SgFunctionParameterTypeList::memoryUsage();
295252 0 : count += SgTemplateParameter::memoryUsage();
295253 0 : count += SgTemplateArgument::memoryUsage();
295254 0 : count += SgTemplateParameterList::memoryUsage();
295255 0 : count += SgTemplateArgumentList::memoryUsage();
295256 0 : count += SgBitAttribute::memoryUsage();
295257 0 : count += SgAttribute::memoryUsage();
295258 0 : count += SgExpBaseClass::memoryUsage();
295259 0 : count += SgNonrealBaseClass::memoryUsage();
295260 0 : count += SgBaseClass::memoryUsage();
295261 0 : count += SgUndirectedGraphEdge::memoryUsage();
295262 0 : count += SgDirectedGraphEdge::memoryUsage();
295263 0 : count += SgGraphNode::memoryUsage();
295264 0 : count += SgGraphEdge::memoryUsage();
295265 0 : count += SgStringKeyedBidirectionalGraph::memoryUsage();
295266 0 : count += SgIntKeyedBidirectionalGraph::memoryUsage();
295267 0 : count += SgBidirectionalGraph::memoryUsage();
295268 0 : count += SgIncidenceDirectedGraph::memoryUsage();
295269 0 : count += SgIncidenceUndirectedGraph::memoryUsage();
295270 0 : count += SgGraph::memoryUsage();
295271 0 : count += SgGraphNodeList::memoryUsage();
295272 0 : count += SgGraphEdgeList::memoryUsage();
295273 0 : count += SgQualifiedName::memoryUsage();
295274 0 : count += SgNameGroup::memoryUsage();
295275 0 : count += SgDimensionObject::memoryUsage();
295276 0 : count += SgDataStatementGroup::memoryUsage();
295277 0 : count += SgDataStatementObject::memoryUsage();
295278 0 : count += SgDataStatementValue::memoryUsage();
295279 0 : count += SgFormatItem::memoryUsage();
295280 0 : count += SgFormatItemList::memoryUsage();
295281 0 : count += SgTypeTable::memoryUsage();
295282 0 : count += SgHeaderFileReport::memoryUsage();
295283 0 : count += SgSupport::memoryUsage();
295284 0 : count += SgTypeUnknown::memoryUsage();
295285 0 : count += SgTypeChar::memoryUsage();
295286 0 : count += SgTypeSignedChar::memoryUsage();
295287 0 : count += SgTypeUnsignedChar::memoryUsage();
295288 0 : count += SgTypeShort::memoryUsage();
295289 0 : count += SgTypeSignedShort::memoryUsage();
295290 0 : count += SgTypeUnsignedShort::memoryUsage();
295291 0 : count += SgTypeInt::memoryUsage();
295292 0 : count += SgTypeSignedInt::memoryUsage();
295293 0 : count += SgTypeUnsignedInt::memoryUsage();
295294 0 : count += SgTypeLong::memoryUsage();
295295 0 : count += SgTypeSignedLong::memoryUsage();
295296 0 : count += SgTypeUnsignedLong::memoryUsage();
295297 0 : count += SgTypeVoid::memoryUsage();
295298 0 : count += SgTypeGlobalVoid::memoryUsage();
295299 0 : count += SgTypeWchar::memoryUsage();
295300 0 : count += SgTypeFloat::memoryUsage();
295301 0 : count += SgTypeDouble::memoryUsage();
295302 0 : count += SgTypeLongLong::memoryUsage();
295303 0 : count += SgTypeSignedLongLong::memoryUsage();
295304 0 : count += SgTypeUnsignedLongLong::memoryUsage();
295305 0 : count += SgTypeLongDouble::memoryUsage();
295306 0 : count += SgTypeFloat80::memoryUsage();
295307 0 : count += SgTypeFloat128::memoryUsage();
295308 0 : count += SgTypeString::memoryUsage();
295309 0 : count += SgTypeBool::memoryUsage();
295310 0 : count += SgTypeFixed::memoryUsage();
295311 0 : count += SgTypeMatrix::memoryUsage();
295312 0 : count += SgTypeTuple::memoryUsage();
295313 0 : count += SgTypeNullptr::memoryUsage();
295314 0 : count += SgTypeComplex::memoryUsage();
295315 0 : count += SgTypeImaginary::memoryUsage();
295316 0 : count += SgTypeDefault::memoryUsage();
295317 0 : count += SgPointerMemberType::memoryUsage();
295318 0 : count += SgReferenceType::memoryUsage();
295319 0 : count += SgRvalueReferenceType::memoryUsage();
295320 0 : count += SgDeclType::memoryUsage();
295321 0 : count += SgTypeOfType::memoryUsage();
295322 0 : count += SgTypeCAFTeam::memoryUsage();
295323 0 : count += SgTypeUnsigned128bitInteger::memoryUsage();
295324 0 : count += SgTypeSigned128bitInteger::memoryUsage();
295325 0 : count += SgTypeLabel::memoryUsage();
295326 0 : count += SgTemplateType::memoryUsage();
295327 0 : count += SgEnumType::memoryUsage();
295328 0 : count += SgTypedefType::memoryUsage();
295329 0 : count += SgNonrealType::memoryUsage();
295330 0 : count += SgAutoType::memoryUsage();
295331 0 : count += SgModifierType::memoryUsage();
295332 0 : count += SgPartialFunctionModifierType::memoryUsage();
295333 0 : count += SgArrayType::memoryUsage();
295334 0 : count += SgTypeEllipse::memoryUsage();
295335 0 : count += SgTypeCrayPointer::memoryUsage();
295336 0 : count += SgPartialFunctionType::memoryUsage();
295337 0 : count += SgMemberFunctionType::memoryUsage();
295338 0 : count += SgFunctionType::memoryUsage();
295339 0 : count += SgPointerType::memoryUsage();
295340 0 : count += SgClassType::memoryUsage();
295341 0 : count += SgNamedType::memoryUsage();
295342 0 : count += SgQualifiedNameType::memoryUsage();
295343 0 : count += SgTypeChar16::memoryUsage();
295344 0 : count += SgTypeChar32::memoryUsage();
295345 0 : count += SgType::memoryUsage();
295346 0 : count += SgForStatement::memoryUsage();
295347 0 : count += SgForInitStatement::memoryUsage();
295348 0 : count += SgRangeBasedForStatement::memoryUsage();
295349 0 : count += SgCatchStatementSeq::memoryUsage();
295350 0 : count += SgFunctionParameterList::memoryUsage();
295351 0 : count += SgCtorInitializerList::memoryUsage();
295352 0 : count += SgBasicBlock::memoryUsage();
295353 0 : count += SgGlobal::memoryUsage();
295354 0 : count += SgIfStmt::memoryUsage();
295355 0 : count += SgWhileStmt::memoryUsage();
295356 0 : count += SgDoWhileStmt::memoryUsage();
295357 0 : count += SgSwitchStatement::memoryUsage();
295358 0 : count += SgCatchOptionStmt::memoryUsage();
295359 0 : count += SgFunctionParameterScope::memoryUsage();
295360 0 : count += SgDeclarationScope::memoryUsage();
295361 0 : count += SgVariableDefinition::memoryUsage();
295362 0 : count += SgStmtDeclarationStatement::memoryUsage();
295363 0 : count += SgEnumDeclaration::memoryUsage();
295364 0 : count += SgAsmStmt::memoryUsage();
295365 0 : count += SgFunctionTypeTable::memoryUsage();
295366 0 : count += SgExprStatement::memoryUsage();
295367 0 : count += SgLabelStatement::memoryUsage();
295368 0 : count += SgCaseOptionStmt::memoryUsage();
295369 0 : count += SgTryStmt::memoryUsage();
295370 0 : count += SgDefaultOptionStmt::memoryUsage();
295371 0 : count += SgBreakStmt::memoryUsage();
295372 0 : count += SgContinueStmt::memoryUsage();
295373 0 : count += SgReturnStmt::memoryUsage();
295374 0 : count += SgGotoStatement::memoryUsage();
295375 0 : count += SgSpawnStmt::memoryUsage();
295376 0 : count += SgTemplateTypedefDeclaration::memoryUsage();
295377 0 : count += SgTemplateInstantiationTypedefDeclaration::memoryUsage();
295378 0 : count += SgTypedefDeclaration::memoryUsage();
295379 0 : count += SgNullStatement::memoryUsage();
295380 0 : count += SgVariantStatement::memoryUsage();
295381 0 : count += SgPragmaDeclaration::memoryUsage();
295382 0 : count += SgTemplateClassDeclaration::memoryUsage();
295383 0 : count += SgTemplateMemberFunctionDeclaration::memoryUsage();
295384 0 : count += SgTemplateFunctionDeclaration::memoryUsage();
295385 0 : count += SgTemplateVariableDeclaration::memoryUsage();
295386 0 : count += SgTemplateDeclaration::memoryUsage();
295387 0 : count += SgVariableDeclaration::memoryUsage();
295388 0 : count += SgTemplateInstantiationDecl::memoryUsage();
295389 0 : count += SgTemplateInstantiationDefn::memoryUsage();
295390 0 : count += SgTemplateInstantiationFunctionDecl::memoryUsage();
295391 0 : count += SgTemplateInstantiationMemberFunctionDecl::memoryUsage();
295392 0 : count += SgNonrealDecl::memoryUsage();
295393 0 : count += SgWithStatement::memoryUsage();
295394 0 : count += SgPassStatement::memoryUsage();
295395 0 : count += SgAssertStmt::memoryUsage();
295396 0 : count += SgExecStatement::memoryUsage();
295397 0 : count += SgProgramHeaderStatement::memoryUsage();
295398 0 : count += SgProcedureHeaderStatement::memoryUsage();
295399 0 : count += SgEntryStatement::memoryUsage();
295400 0 : count += SgFortranNonblockedDo::memoryUsage();
295401 0 : count += SgInterfaceStatement::memoryUsage();
295402 0 : count += SgParameterStatement::memoryUsage();
295403 0 : count += SgCommonBlock::memoryUsage();
295404 0 : count += SgModuleStatement::memoryUsage();
295405 0 : count += SgUseStatement::memoryUsage();
295406 0 : count += SgProcessControlStatement::memoryUsage();
295407 0 : count += SgPrintStatement::memoryUsage();
295408 0 : count += SgReadStatement::memoryUsage();
295409 0 : count += SgWriteStatement::memoryUsage();
295410 0 : count += SgOpenStatement::memoryUsage();
295411 0 : count += SgCloseStatement::memoryUsage();
295412 0 : count += SgInquireStatement::memoryUsage();
295413 0 : count += SgFlushStatement::memoryUsage();
295414 0 : count += SgBackspaceStatement::memoryUsage();
295415 0 : count += SgRewindStatement::memoryUsage();
295416 0 : count += SgEndfileStatement::memoryUsage();
295417 0 : count += SgWaitStatement::memoryUsage();
295418 0 : count += SgCAFWithTeamStatement::memoryUsage();
295419 0 : count += SgFormatStatement::memoryUsage();
295420 0 : count += SgFortranDo::memoryUsage();
295421 0 : count += SgForAllStatement::memoryUsage();
295422 0 : count += SgIOStatement::memoryUsage();
295423 0 : count += SgSyncAllStatement::memoryUsage();
295424 0 : count += SgSyncImagesStatement::memoryUsage();
295425 0 : count += SgSyncMemoryStatement::memoryUsage();
295426 0 : count += SgSyncTeamStatement::memoryUsage();
295427 0 : count += SgLockStatement::memoryUsage();
295428 0 : count += SgUnlockStatement::memoryUsage();
295429 0 : count += SgImageControlStatement::memoryUsage();
295430 0 : count += SgUpcNotifyStatement::memoryUsage();
295431 0 : count += SgUpcWaitStatement::memoryUsage();
295432 0 : count += SgUpcBarrierStatement::memoryUsage();
295433 0 : count += SgUpcFenceStatement::memoryUsage();
295434 0 : count += SgUpcForAllStatement::memoryUsage();
295435 0 : count += SgUpirSpmdStatement::memoryUsage();
295436 0 : count += SgOmpLoopStatement::memoryUsage();
295437 0 : count += SgOmpScanStatement::memoryUsage();
295438 0 : count += SgOmpTaskloopStatement::memoryUsage();
295439 0 : count += SgOmpTaskgroupStatement::memoryUsage();
295440 0 : count += SgOmpDepobjStatement::memoryUsage();
295441 0 : count += SgOmpTeamsStatement::memoryUsage();
295442 0 : count += SgOmpCancellationPointStatement::memoryUsage();
295443 0 : count += SgOmpDeclareMapperStatement::memoryUsage();
295444 0 : count += SgOmpCancelStatement::memoryUsage();
295445 0 : count += SgOmpDistributeStatement::memoryUsage();
295446 0 : count += SgOmpMetadirectiveStatement::memoryUsage();
295447 0 : count += SgOmpSingleStatement::memoryUsage();
295448 0 : count += SgOmpTaskStatement::memoryUsage();
295449 0 : count += SgOmpTargetEnterDataStatement::memoryUsage();
295450 0 : count += SgOmpTargetExitDataStatement::memoryUsage();
295451 0 : count += SgUpirWorksharingStatement::memoryUsage();
295452 0 : count += SgOmpForSimdStatement::memoryUsage();
295453 0 : count += SgOmpDoStatement::memoryUsage();
295454 0 : count += SgOmpSectionsStatement::memoryUsage();
295455 0 : count += SgOmpAtomicStatement::memoryUsage();
295456 0 : count += SgUpirTaskStatement::memoryUsage();
295457 0 : count += SgOmpTargetDataStatement::memoryUsage();
295458 0 : count += SgOmpTargetParallelForStatement::memoryUsage();
295459 0 : count += SgOmpTargetParallelStatement::memoryUsage();
295460 0 : count += SgOmpDistributeSimdStatement::memoryUsage();
295461 0 : count += SgOmpDistributeParallelForStatement::memoryUsage();
295462 0 : count += SgOmpDistributeParallelForSimdStatement::memoryUsage();
295463 0 : count += SgOmpTaskloopSimdStatement::memoryUsage();
295464 0 : count += SgOmpTargetUpdateStatement::memoryUsage();
295465 0 : count += SgOmpTargetParallelForSimdStatement::memoryUsage();
295466 0 : count += SgOmpTargetParallelLoopStatement::memoryUsage();
295467 0 : count += SgOmpTargetSimdStatement::memoryUsage();
295468 0 : count += SgOmpTargetTeamsStatement::memoryUsage();
295469 0 : count += SgOmpTargetTeamsDistributeStatement::memoryUsage();
295470 0 : count += SgOmpTargetTeamsDistributeSimdStatement::memoryUsage();
295471 0 : count += SgOmpTargetTeamsLoopStatement::memoryUsage();
295472 0 : count += SgOmpTargetTeamsDistributeParallelForStatement::memoryUsage();
295473 0 : count += SgOmpTargetTeamsDistributeParallelForSimdStatement::memoryUsage();
295474 0 : count += SgOmpMasterTaskloopSimdStatement::memoryUsage();
295475 0 : count += SgOmpParallelMasterTaskloopStatement::memoryUsage();
295476 0 : count += SgOmpParallelMasterTaskloopSimdStatement::memoryUsage();
295477 0 : count += SgOmpTeamsDistributeStatement::memoryUsage();
295478 0 : count += SgOmpTeamsDistributeSimdStatement::memoryUsage();
295479 0 : count += SgOmpTeamsDistributeParallelForStatement::memoryUsage();
295480 0 : count += SgOmpTeamsDistributeParallelForSimdStatement::memoryUsage();
295481 0 : count += SgOmpTeamsLoopStatement::memoryUsage();
295482 0 : count += SgOmpParallelMasterStatement::memoryUsage();
295483 0 : count += SgOmpMasterTaskloopStatement::memoryUsage();
295484 0 : count += SgOmpParallelLoopStatement::memoryUsage();
295485 0 : count += SgOmpUnrollStatement::memoryUsage();
295486 0 : count += SgOmpTileStatement::memoryUsage();
295487 0 : count += SgUpirSimdStatement::memoryUsage();
295488 0 : count += SgOmpCriticalStatement::memoryUsage();
295489 0 : count += SgOmpOrderedStatement::memoryUsage();
295490 0 : count += SgUpirLoopStatement::memoryUsage();
295491 0 : count += SgUpirLoopParallelStatement::memoryUsage();
295492 0 : count += SgUpirSyncStatement::memoryUsage();
295493 0 : count += SgUpirFieldBodyStatement::memoryUsage();
295494 0 : count += SgOmpMasterStatement::memoryUsage();
295495 0 : count += SgOmpSectionStatement::memoryUsage();
295496 0 : count += SgOmpWorkshareStatement::memoryUsage();
295497 0 : count += SgOmpFlushStatement::memoryUsage();
295498 0 : count += SgOmpAllocateStatement::memoryUsage();
295499 0 : count += SgOmpOrderedDependStatement::memoryUsage();
295500 0 : count += SgUpirBodyStatement::memoryUsage();
295501 0 : count += SgUpirFieldStatement::memoryUsage();
295502 0 : count += SgBlockDataStatement::memoryUsage();
295503 0 : count += SgImplicitStatement::memoryUsage();
295504 0 : count += SgStatementFunctionStatement::memoryUsage();
295505 0 : count += SgWhereStatement::memoryUsage();
295506 0 : count += SgNullifyStatement::memoryUsage();
295507 0 : count += SgEquivalenceStatement::memoryUsage();
295508 0 : count += SgDerivedTypeStatement::memoryUsage();
295509 0 : count += SgAttributeSpecificationStatement::memoryUsage();
295510 0 : count += SgAllocateStatement::memoryUsage();
295511 0 : count += SgDeallocateStatement::memoryUsage();
295512 0 : count += SgContainsStatement::memoryUsage();
295513 0 : count += SgSequenceStatement::memoryUsage();
295514 0 : count += SgElseWhereStatement::memoryUsage();
295515 0 : count += SgArithmeticIfStatement::memoryUsage();
295516 0 : count += SgAssignStatement::memoryUsage();
295517 0 : count += SgComputedGotoStatement::memoryUsage();
295518 0 : count += SgAssignedGotoStatement::memoryUsage();
295519 0 : count += SgNamelistStatement::memoryUsage();
295520 0 : count += SgImportStatement::memoryUsage();
295521 0 : count += SgAssociateStatement::memoryUsage();
295522 0 : count += SgFortranIncludeLine::memoryUsage();
295523 0 : count += SgNamespaceDeclarationStatement::memoryUsage();
295524 0 : count += SgNamespaceAliasDeclarationStatement::memoryUsage();
295525 0 : count += SgNamespaceDefinitionStatement::memoryUsage();
295526 0 : count += SgUsingDeclarationStatement::memoryUsage();
295527 0 : count += SgUsingDirectiveStatement::memoryUsage();
295528 0 : count += SgTemplateInstantiationDirectiveStatement::memoryUsage();
295529 0 : count += SgStaticAssertionDeclaration::memoryUsage();
295530 0 : count += SgTemplateClassDefinition::memoryUsage();
295531 0 : count += SgTemplateFunctionDefinition::memoryUsage();
295532 0 : count += SgClassDeclaration::memoryUsage();
295533 0 : count += SgClassDefinition::memoryUsage();
295534 0 : count += SgFunctionDefinition::memoryUsage();
295535 0 : count += SgScopeStatement::memoryUsage();
295536 0 : count += SgMemberFunctionDeclaration::memoryUsage();
295537 0 : count += SgFunctionDeclaration::memoryUsage();
295538 0 : count += SgIncludeDirectiveStatement::memoryUsage();
295539 0 : count += SgDefineDirectiveStatement::memoryUsage();
295540 0 : count += SgUndefDirectiveStatement::memoryUsage();
295541 0 : count += SgIfdefDirectiveStatement::memoryUsage();
295542 0 : count += SgIfndefDirectiveStatement::memoryUsage();
295543 0 : count += SgIfDirectiveStatement::memoryUsage();
295544 0 : count += SgDeadIfDirectiveStatement::memoryUsage();
295545 0 : count += SgElseDirectiveStatement::memoryUsage();
295546 0 : count += SgElseifDirectiveStatement::memoryUsage();
295547 0 : count += SgEndifDirectiveStatement::memoryUsage();
295548 0 : count += SgLineDirectiveStatement::memoryUsage();
295549 0 : count += SgWarningDirectiveStatement::memoryUsage();
295550 0 : count += SgErrorDirectiveStatement::memoryUsage();
295551 0 : count += SgEmptyDirectiveStatement::memoryUsage();
295552 0 : count += SgIncludeNextDirectiveStatement::memoryUsage();
295553 0 : count += SgIdentDirectiveStatement::memoryUsage();
295554 0 : count += SgLinemarkerDirectiveStatement::memoryUsage();
295555 0 : count += SgC_PreprocessorDirectiveStatement::memoryUsage();
295556 0 : count += SgClinkageStartStatement::memoryUsage();
295557 0 : count += SgClinkageEndStatement::memoryUsage();
295558 0 : count += SgClinkageDeclarationStatement::memoryUsage();
295559 0 : count += SgOmpDeclareSimdStatement::memoryUsage();
295560 0 : count += SgOmpBarrierStatement::memoryUsage();
295561 0 : count += SgOmpTaskyieldStatement::memoryUsage();
295562 0 : count += SgOmpRequiresStatement::memoryUsage();
295563 0 : count += SgOmpTaskwaitStatement::memoryUsage();
295564 0 : count += SgOmpThreadprivateStatement::memoryUsage();
295565 0 : count += SgMicrosoftAttributeDeclaration::memoryUsage();
295566 0 : count += SgEmptyDeclaration::memoryUsage();
295567 0 : count += SgDeclarationStatement::memoryUsage();
295568 0 : count += SgUpirBaseStatement::memoryUsage();
295569 0 : count += SgStatement::memoryUsage();
295570 0 : count += SgVarRefExp::memoryUsage();
295571 0 : count += SgNonrealRefExp::memoryUsage();
295572 0 : count += SgCompoundLiteralExp::memoryUsage();
295573 0 : count += SgLabelRefExp::memoryUsage();
295574 0 : count += SgClassNameRefExp::memoryUsage();
295575 0 : count += SgFunctionRefExp::memoryUsage();
295576 0 : count += SgMemberFunctionRefExp::memoryUsage();
295577 0 : count += SgTemplateFunctionRefExp::memoryUsage();
295578 0 : count += SgTemplateMemberFunctionRefExp::memoryUsage();
295579 0 : count += SgSizeOfOp::memoryUsage();
295580 0 : count += SgAlignOfOp::memoryUsage();
295581 0 : count += SgNoexceptOp::memoryUsage();
295582 0 : count += SgTypeExpression::memoryUsage();
295583 0 : count += SgLambdaExp::memoryUsage();
295584 0 : count += SgUpcLocalsizeofExpression::memoryUsage();
295585 0 : count += SgUpcBlocksizeofExpression::memoryUsage();
295586 0 : count += SgUpcElemsizeofExpression::memoryUsage();
295587 0 : count += SgVarArgStartOp::memoryUsage();
295588 0 : count += SgVarArgStartOneOperandOp::memoryUsage();
295589 0 : count += SgVarArgOp::memoryUsage();
295590 0 : count += SgVarArgEndOp::memoryUsage();
295591 0 : count += SgVarArgCopyOp::memoryUsage();
295592 0 : count += SgTypeIdOp::memoryUsage();
295593 0 : count += SgConditionalExp::memoryUsage();
295594 0 : count += SgNewExp::memoryUsage();
295595 0 : count += SgDeleteExp::memoryUsage();
295596 0 : count += SgThisExp::memoryUsage();
295597 0 : count += SgSuperExp::memoryUsage();
295598 0 : count += SgClassExp::memoryUsage();
295599 0 : count += SgRefExp::memoryUsage();
295600 0 : count += SgAggregateInitializer::memoryUsage();
295601 0 : count += SgCompoundInitializer::memoryUsage();
295602 0 : count += SgConstructorInitializer::memoryUsage();
295603 0 : count += SgAssignInitializer::memoryUsage();
295604 0 : count += SgBracedInitializer::memoryUsage();
295605 0 : count += SgExpressionRoot::memoryUsage();
295606 0 : count += SgMinusOp::memoryUsage();
295607 0 : count += SgUnaryAddOp::memoryUsage();
295608 0 : count += SgNotOp::memoryUsage();
295609 0 : count += SgPointerDerefExp::memoryUsage();
295610 0 : count += SgAddressOfOp::memoryUsage();
295611 0 : count += SgMinusMinusOp::memoryUsage();
295612 0 : count += SgPlusPlusOp::memoryUsage();
295613 0 : count += SgBitComplementOp::memoryUsage();
295614 0 : count += SgRealPartOp::memoryUsage();
295615 0 : count += SgImagPartOp::memoryUsage();
295616 0 : count += SgConjugateOp::memoryUsage();
295617 0 : count += SgCastExp::memoryUsage();
295618 0 : count += SgThrowOp::memoryUsage();
295619 0 : count += SgArrowExp::memoryUsage();
295620 0 : count += SgDotExp::memoryUsage();
295621 0 : count += SgDotStarOp::memoryUsage();
295622 0 : count += SgArrowStarOp::memoryUsage();
295623 0 : count += SgEqualityOp::memoryUsage();
295624 0 : count += SgLessThanOp::memoryUsage();
295625 0 : count += SgGreaterThanOp::memoryUsage();
295626 0 : count += SgNotEqualOp::memoryUsage();
295627 0 : count += SgLessOrEqualOp::memoryUsage();
295628 0 : count += SgGreaterOrEqualOp::memoryUsage();
295629 0 : count += SgAddOp::memoryUsage();
295630 0 : count += SgSubtractOp::memoryUsage();
295631 0 : count += SgMultiplyOp::memoryUsage();
295632 0 : count += SgDivideOp::memoryUsage();
295633 0 : count += SgIntegerDivideOp::memoryUsage();
295634 0 : count += SgModOp::memoryUsage();
295635 0 : count += SgAndOp::memoryUsage();
295636 0 : count += SgOrOp::memoryUsage();
295637 0 : count += SgBitXorOp::memoryUsage();
295638 0 : count += SgBitAndOp::memoryUsage();
295639 0 : count += SgBitOrOp::memoryUsage();
295640 0 : count += SgBitEqvOp::memoryUsage();
295641 0 : count += SgCommaOpExp::memoryUsage();
295642 0 : count += SgLshiftOp::memoryUsage();
295643 0 : count += SgRshiftOp::memoryUsage();
295644 0 : count += SgPntrArrRefExp::memoryUsage();
295645 0 : count += SgScopeOp::memoryUsage();
295646 0 : count += SgAssignOp::memoryUsage();
295647 0 : count += SgPlusAssignOp::memoryUsage();
295648 0 : count += SgMinusAssignOp::memoryUsage();
295649 0 : count += SgAndAssignOp::memoryUsage();
295650 0 : count += SgIorAssignOp::memoryUsage();
295651 0 : count += SgMultAssignOp::memoryUsage();
295652 0 : count += SgDivAssignOp::memoryUsage();
295653 0 : count += SgModAssignOp::memoryUsage();
295654 0 : count += SgXorAssignOp::memoryUsage();
295655 0 : count += SgLshiftAssignOp::memoryUsage();
295656 0 : count += SgRshiftAssignOp::memoryUsage();
295657 0 : count += SgIntegerDivideAssignOp::memoryUsage();
295658 0 : count += SgExponentiationAssignOp::memoryUsage();
295659 0 : count += SgConcatenationOp::memoryUsage();
295660 0 : count += SgNaryComparisonOp::memoryUsage();
295661 0 : count += SgNaryBooleanOp::memoryUsage();
295662 0 : count += SgBoolValExp::memoryUsage();
295663 0 : count += SgStringVal::memoryUsage();
295664 0 : count += SgShortVal::memoryUsage();
295665 0 : count += SgCharVal::memoryUsage();
295666 0 : count += SgUnsignedCharVal::memoryUsage();
295667 0 : count += SgWcharVal::memoryUsage();
295668 0 : count += SgChar16Val::memoryUsage();
295669 0 : count += SgChar32Val::memoryUsage();
295670 0 : count += SgUnsignedShortVal::memoryUsage();
295671 0 : count += SgIntVal::memoryUsage();
295672 0 : count += SgEnumVal::memoryUsage();
295673 0 : count += SgUnsignedIntVal::memoryUsage();
295674 0 : count += SgLongIntVal::memoryUsage();
295675 0 : count += SgLongLongIntVal::memoryUsage();
295676 0 : count += SgUnsignedLongLongIntVal::memoryUsage();
295677 0 : count += SgUnsignedLongVal::memoryUsage();
295678 0 : count += SgFloatVal::memoryUsage();
295679 0 : count += SgDoubleVal::memoryUsage();
295680 0 : count += SgLongDoubleVal::memoryUsage();
295681 0 : count += SgFloat80Val::memoryUsage();
295682 0 : count += SgFloat128Val::memoryUsage();
295683 0 : count += SgNullptrValExp::memoryUsage();
295684 0 : count += SgVoidVal::memoryUsage();
295685 0 : count += SgFunctionParameterRefExp::memoryUsage();
295686 0 : count += SgTemplateParameterVal::memoryUsage();
295687 0 : count += SgUpcThreads::memoryUsage();
295688 0 : count += SgUpcMythread::memoryUsage();
295689 0 : count += SgComplexVal::memoryUsage();
295690 0 : count += SgNullExpression::memoryUsage();
295691 0 : count += SgVariantExpression::memoryUsage();
295692 0 : count += SgStatementExpression::memoryUsage();
295693 0 : count += SgAsmOp::memoryUsage();
295694 0 : count += SgCudaKernelExecConfig::memoryUsage();
295695 0 : count += SgCudaKernelCallExp::memoryUsage();
295696 0 : count += SgLambdaRefExp::memoryUsage();
295697 0 : count += SgTupleExp::memoryUsage();
295698 0 : count += SgListExp::memoryUsage();
295699 0 : count += SgDictionaryExp::memoryUsage();
295700 0 : count += SgKeyDatumPair::memoryUsage();
295701 0 : count += SgComprehension::memoryUsage();
295702 0 : count += SgListComprehension::memoryUsage();
295703 0 : count += SgSetComprehension::memoryUsage();
295704 0 : count += SgDictionaryComprehension::memoryUsage();
295705 0 : count += SgMembershipOp::memoryUsage();
295706 0 : count += SgNonMembershipOp::memoryUsage();
295707 0 : count += SgIsOp::memoryUsage();
295708 0 : count += SgIsNotOp::memoryUsage();
295709 0 : count += SgStringConversion::memoryUsage();
295710 0 : count += SgYieldExpression::memoryUsage();
295711 0 : count += SgFoldExpression::memoryUsage();
295712 0 : count += SgChooseExpression::memoryUsage();
295713 0 : count += SgAwaitExpression::memoryUsage();
295714 0 : count += SgSpaceshipOp::memoryUsage();
295715 0 : count += SgSubscriptExpression::memoryUsage();
295716 0 : count += SgColonShapeExp::memoryUsage();
295717 0 : count += SgAsteriskShapeExp::memoryUsage();
295718 0 : count += SgIOItemExpression::memoryUsage();
295719 0 : count += SgImpliedDo::memoryUsage();
295720 0 : count += SgExponentiationOp::memoryUsage();
295721 0 : count += SgUnknownArrayOrFunctionReference::memoryUsage();
295722 0 : count += SgActualArgumentExpression::memoryUsage();
295723 0 : count += SgUserDefinedBinaryOp::memoryUsage();
295724 0 : count += SgPointerAssignOp::memoryUsage();
295725 0 : count += SgCAFCoExpression::memoryUsage();
295726 0 : count += SgDesignatedInitializer::memoryUsage();
295727 0 : count += SgMatrixExp::memoryUsage();
295728 0 : count += SgRangeExp::memoryUsage();
295729 0 : count += SgMagicColonExp::memoryUsage();
295730 0 : count += SgElementwiseMultiplyOp::memoryUsage();
295731 0 : count += SgPowerOp::memoryUsage();
295732 0 : count += SgElementwisePowerOp::memoryUsage();
295733 0 : count += SgElementwiseDivideOp::memoryUsage();
295734 0 : count += SgLeftDivideOp::memoryUsage();
295735 0 : count += SgElementwiseLeftDivideOp::memoryUsage();
295736 0 : count += SgElementwiseAddOp::memoryUsage();
295737 0 : count += SgElementwiseSubtractOp::memoryUsage();
295738 0 : count += SgMatrixTransposeOp::memoryUsage();
295739 0 : count += SgElementwiseOp::memoryUsage();
295740 0 : count += SgInitializer::memoryUsage();
295741 0 : count += SgSIMDLoad::memoryUsage();
295742 0 : count += SgSIMDBroadcast::memoryUsage();
295743 0 : count += SgSIMDStore::memoryUsage();
295744 0 : count += SgSIMDPartialStore::memoryUsage();
295745 0 : count += SgSIMDScalarStore::memoryUsage();
295746 0 : count += SgSIMDGather::memoryUsage();
295747 0 : count += SgSIMDExplicitGather::memoryUsage();
295748 0 : count += SgSIMDScatter::memoryUsage();
295749 0 : count += SgSIMDAddOp::memoryUsage();
295750 0 : count += SgSIMDSubOp::memoryUsage();
295751 0 : count += SgSIMDMulOp::memoryUsage();
295752 0 : count += SgSIMDDivOp::memoryUsage();
295753 0 : count += SgSIMDFmaOp::memoryUsage();
295754 0 : count += SgSIMDBinaryOp::memoryUsage();
295755 0 : count += SgUserDefinedUnaryOp::memoryUsage();
295756 0 : count += SgPseudoDestructorRefExp::memoryUsage();
295757 0 : count += SgUnaryOp::memoryUsage();
295758 0 : count += SgCompoundAssignOp::memoryUsage();
295759 0 : count += SgBinaryOp::memoryUsage();
295760 0 : count += SgNaryOp::memoryUsage();
295761 0 : count += SgValueExp::memoryUsage();
295762 0 : count += SgExprListExp::memoryUsage();
295763 0 : count += SgFunctionCallExp::memoryUsage();
295764 0 : count += SgCallExpression::memoryUsage();
295765 0 : count += SgTypeTraitBuiltinOperator::memoryUsage();
295766 0 : count += SgExpression::memoryUsage();
295767 0 : count += SgTemplateVariableSymbol::memoryUsage();
295768 0 : count += SgVariableSymbol::memoryUsage();
295769 0 : count += SgFunctionTypeSymbol::memoryUsage();
295770 0 : count += SgTemplateClassSymbol::memoryUsage();
295771 0 : count += SgClassSymbol::memoryUsage();
295772 0 : count += SgTemplateSymbol::memoryUsage();
295773 0 : count += SgEnumSymbol::memoryUsage();
295774 0 : count += SgEnumFieldSymbol::memoryUsage();
295775 0 : count += SgTemplateTypedefSymbol::memoryUsage();
295776 0 : count += SgTypedefSymbol::memoryUsage();
295777 0 : count += SgTemplateFunctionSymbol::memoryUsage();
295778 0 : count += SgTemplateMemberFunctionSymbol::memoryUsage();
295779 0 : count += SgLabelSymbol::memoryUsage();
295780 0 : count += SgDefaultSymbol::memoryUsage();
295781 0 : count += SgNamespaceSymbol::memoryUsage();
295782 0 : count += SgIntrinsicSymbol::memoryUsage();
295783 0 : count += SgModuleSymbol::memoryUsage();
295784 0 : count += SgInterfaceSymbol::memoryUsage();
295785 0 : count += SgCommonSymbol::memoryUsage();
295786 0 : count += SgRenameSymbol::memoryUsage();
295787 0 : count += SgMemberFunctionSymbol::memoryUsage();
295788 0 : count += SgFunctionSymbol::memoryUsage();
295789 0 : count += SgAliasSymbol::memoryUsage();
295790 0 : count += SgNonrealSymbol::memoryUsage();
295791 0 : count += SgSymbol::memoryUsage();
295792 0 : count += SgCommonBlockObject::memoryUsage();
295793 0 : count += SgInitializedName::memoryUsage();
295794 0 : count += SgLambdaCapture::memoryUsage();
295795 0 : count += SgLambdaCaptureList::memoryUsage();
295796 0 : count += SgOmpOrderedClause::memoryUsage();
295797 0 : count += SgOmpNowaitClause::memoryUsage();
295798 0 : count += SgOmpNogroupClause::memoryUsage();
295799 0 : count += SgOmpReadClause::memoryUsage();
295800 0 : count += SgOmpThreadsClause::memoryUsage();
295801 0 : count += SgOmpSimdClause::memoryUsage();
295802 0 : count += SgOmpReverseOffloadClause::memoryUsage();
295803 0 : count += SgOmpExtImplementationDefinedRequirementClause::memoryUsage();
295804 0 : count += SgOmpUnifiedAddressClause::memoryUsage();
295805 0 : count += SgOmpUnifiedSharedMemoryClause::memoryUsage();
295806 0 : count += SgOmpDynamicAllocatorsClause::memoryUsage();
295807 0 : count += SgOmpAtomicDefaultMemOrderClause::memoryUsage();
295808 0 : count += SgOmpWriteClause::memoryUsage();
295809 0 : count += SgOmpUpdateClause::memoryUsage();
295810 0 : count += SgOmpDepobjUpdateClause::memoryUsage();
295811 0 : count += SgOmpDestroyClause::memoryUsage();
295812 0 : count += SgOmpCaptureClause::memoryUsage();
295813 0 : count += SgOmpSeqCstClause::memoryUsage();
295814 0 : count += SgOmpAcqRelClause::memoryUsage();
295815 0 : count += SgOmpReleaseClause::memoryUsage();
295816 0 : count += SgOmpAcquireClause::memoryUsage();
295817 0 : count += SgOmpRelaxedClause::memoryUsage();
295818 0 : count += SgOmpParallelClause::memoryUsage();
295819 0 : count += SgOmpSectionsClause::memoryUsage();
295820 0 : count += SgOmpForClause::memoryUsage();
295821 0 : count += SgOmpTaskgroupClause::memoryUsage();
295822 0 : count += SgOmpBeginClause::memoryUsage();
295823 0 : count += SgOmpEndClause::memoryUsage();
295824 0 : count += SgOmpUntiedClause::memoryUsage();
295825 0 : count += SgOmpMergeableClause::memoryUsage();
295826 0 : count += SgOmpDefaultClause::memoryUsage();
295827 0 : count += SgOmpAtomicClause::memoryUsage();
295828 0 : count += SgOmpProcBindClause::memoryUsage();
295829 0 : count += SgOmpOrderClause::memoryUsage();
295830 0 : count += SgOmpBindClause::memoryUsage();
295831 0 : count += SgOmpInbranchClause::memoryUsage();
295832 0 : count += SgOmpNotinbranchClause::memoryUsage();
295833 0 : count += SgOmpCollapseClause::memoryUsage();
295834 0 : count += SgOmpIfClause::memoryUsage();
295835 0 : count += SgOmpFinalClause::memoryUsage();
295836 0 : count += SgOmpPriorityClause::memoryUsage();
295837 0 : count += SgUpirNumUnitsField::memoryUsage();
295838 0 : count += SgOmpNumTeamsClause::memoryUsage();
295839 0 : count += SgOmpGrainsizeClause::memoryUsage();
295840 0 : count += SgOmpDetachClause::memoryUsage();
295841 0 : count += SgOmpNumTasksClause::memoryUsage();
295842 0 : count += SgOmpHintClause::memoryUsage();
295843 0 : count += SgOmpThreadLimitClause::memoryUsage();
295844 0 : count += SgOmpNontemporalClause::memoryUsage();
295845 0 : count += SgOmpInclusiveClause::memoryUsage();
295846 0 : count += SgOmpExclusiveClause::memoryUsage();
295847 0 : count += SgOmpIsDevicePtrClause::memoryUsage();
295848 0 : count += SgOmpUseDevicePtrClause::memoryUsage();
295849 0 : count += SgOmpUseDeviceAddrClause::memoryUsage();
295850 0 : count += SgOmpDeviceClause::memoryUsage();
295851 0 : count += SgOmpSafelenClause::memoryUsage();
295852 0 : count += SgOmpSimdlenClause::memoryUsage();
295853 0 : count += SgOmpPartialClause::memoryUsage();
295854 0 : count += SgOmpFullClause::memoryUsage();
295855 0 : count += SgOmpSizesClause::memoryUsage();
295856 0 : count += SgUpirBranchField::memoryUsage();
295857 0 : count += SgUpirNestedLevelField::memoryUsage();
295858 0 : count += SgUpirNestedParentField::memoryUsage();
295859 0 : count += SgUpirNestedChildField::memoryUsage();
295860 0 : count += SgUpirSyncField::memoryUsage();
295861 0 : count += SgUpirDataField::memoryUsage();
295862 0 : count += SgUpirTargetField::memoryUsage();
295863 0 : count += SgUpirDataItemField::memoryUsage();
295864 0 : count += SgOmpExpressionClause::memoryUsage();
295865 0 : count += SgOmpCopyprivateClause::memoryUsage();
295866 0 : count += SgOmpPrivateClause::memoryUsage();
295867 0 : count += SgOmpFirstprivateClause::memoryUsage();
295868 0 : count += SgOmpSharedClause::memoryUsage();
295869 0 : count += SgOmpCopyinClause::memoryUsage();
295870 0 : count += SgOmpLastprivateClause::memoryUsage();
295871 0 : count += SgOmpReductionClause::memoryUsage();
295872 0 : count += SgOmpInReductionClause::memoryUsage();
295873 0 : count += SgOmpTaskReductionClause::memoryUsage();
295874 0 : count += SgOmpAllocateClause::memoryUsage();
295875 0 : count += SgOmpDependClause::memoryUsage();
295876 0 : count += SgOmpToClause::memoryUsage();
295877 0 : count += SgOmpUsesAllocatorsClause::memoryUsage();
295878 0 : count += SgOmpFromClause::memoryUsage();
295879 0 : count += SgOmpAffinityClause::memoryUsage();
295880 0 : count += SgOmpMapClause::memoryUsage();
295881 0 : count += SgOmpLinearClause::memoryUsage();
295882 0 : count += SgOmpUniformClause::memoryUsage();
295883 0 : count += SgOmpAlignedClause::memoryUsage();
295884 0 : count += SgOmpVariablesClause::memoryUsage();
295885 0 : count += SgOmpScheduleClause::memoryUsage();
295886 0 : count += SgOmpWhenClause::memoryUsage();
295887 0 : count += SgOmpDistScheduleClause::memoryUsage();
295888 0 : count += SgOmpDefaultmapClause::memoryUsage();
295889 0 : count += SgOmpAllocatorClause::memoryUsage();
295890 0 : count += SgOmpUsesAllocatorsDefination::memoryUsage();
295891 0 : count += SgOmpClause::memoryUsage();
295892 0 : count += SgRenamePair::memoryUsage();
295893 0 : count += SgInterfaceBody::memoryUsage();
295894 0 : count += SgHeaderFileBody::memoryUsage();
295895 0 : count += SgLocatedNodeSupport::memoryUsage();
295896 0 : count += SgToken::memoryUsage();
295897 0 : count += SgLocatedNode::memoryUsage();
295898 0 : count += SgNode::memoryUsage();
295899 :
295900 :
295901 0 : return count;
295902 : }
295903 :
295904 :
295905 4 : size_t numberOfNodes ()
295906 : {
295907 4 : size_t count = 0;
295908 :
295909 4 : count += SgName::numberOfNodes();
295910 4 : count += SgSymbolTable::numberOfNodes();
295911 4 : count += SgPragma::numberOfNodes();
295912 4 : count += SgModifierNodes::numberOfNodes();
295913 4 : count += SgConstVolatileModifier::numberOfNodes();
295914 4 : count += SgStorageModifier::numberOfNodes();
295915 4 : count += SgAccessModifier::numberOfNodes();
295916 4 : count += SgFunctionModifier::numberOfNodes();
295917 4 : count += SgUPC_AccessModifier::numberOfNodes();
295918 4 : count += SgLinkageModifier::numberOfNodes();
295919 4 : count += SgSpecialFunctionModifier::numberOfNodes();
295920 4 : count += SgTypeModifier::numberOfNodes();
295921 4 : count += SgElaboratedTypeModifier::numberOfNodes();
295922 4 : count += SgBaseClassModifier::numberOfNodes();
295923 4 : count += SgDeclarationModifier::numberOfNodes();
295924 4 : count += SgStructureModifier::numberOfNodes();
295925 4 : count += SgOpenclAccessModeModifier::numberOfNodes();
295926 4 : count += SgModifier::numberOfNodes();
295927 4 : count += Sg_File_Info::numberOfNodes();
295928 4 : count += SgSourceFile::numberOfNodes();
295929 4 : count += SgUnknownFile::numberOfNodes();
295930 4 : count += SgFile::numberOfNodes();
295931 4 : count += SgFileList::numberOfNodes();
295932 4 : count += SgDirectory::numberOfNodes();
295933 4 : count += SgDirectoryList::numberOfNodes();
295934 4 : count += SgProject::numberOfNodes();
295935 4 : count += SgOptions::numberOfNodes();
295936 4 : count += SgUnparse_Info::numberOfNodes();
295937 4 : count += SgIncludeFile::numberOfNodes();
295938 4 : count += SgFuncDecl_attr::numberOfNodes();
295939 4 : count += SgClassDecl_attr::numberOfNodes();
295940 4 : count += SgTypedefSeq::numberOfNodes();
295941 4 : count += SgFunctionParameterTypeList::numberOfNodes();
295942 4 : count += SgTemplateParameter::numberOfNodes();
295943 4 : count += SgTemplateArgument::numberOfNodes();
295944 4 : count += SgTemplateParameterList::numberOfNodes();
295945 4 : count += SgTemplateArgumentList::numberOfNodes();
295946 4 : count += SgBitAttribute::numberOfNodes();
295947 4 : count += SgAttribute::numberOfNodes();
295948 4 : count += SgExpBaseClass::numberOfNodes();
295949 4 : count += SgNonrealBaseClass::numberOfNodes();
295950 4 : count += SgBaseClass::numberOfNodes();
295951 4 : count += SgUndirectedGraphEdge::numberOfNodes();
295952 4 : count += SgDirectedGraphEdge::numberOfNodes();
295953 4 : count += SgGraphNode::numberOfNodes();
295954 4 : count += SgGraphEdge::numberOfNodes();
295955 4 : count += SgStringKeyedBidirectionalGraph::numberOfNodes();
295956 4 : count += SgIntKeyedBidirectionalGraph::numberOfNodes();
295957 4 : count += SgBidirectionalGraph::numberOfNodes();
295958 4 : count += SgIncidenceDirectedGraph::numberOfNodes();
295959 4 : count += SgIncidenceUndirectedGraph::numberOfNodes();
295960 4 : count += SgGraph::numberOfNodes();
295961 4 : count += SgGraphNodeList::numberOfNodes();
295962 4 : count += SgGraphEdgeList::numberOfNodes();
295963 4 : count += SgQualifiedName::numberOfNodes();
295964 4 : count += SgNameGroup::numberOfNodes();
295965 4 : count += SgDimensionObject::numberOfNodes();
295966 4 : count += SgDataStatementGroup::numberOfNodes();
295967 4 : count += SgDataStatementObject::numberOfNodes();
295968 4 : count += SgDataStatementValue::numberOfNodes();
295969 4 : count += SgFormatItem::numberOfNodes();
295970 4 : count += SgFormatItemList::numberOfNodes();
295971 4 : count += SgTypeTable::numberOfNodes();
295972 4 : count += SgHeaderFileReport::numberOfNodes();
295973 4 : count += SgSupport::numberOfNodes();
295974 4 : count += SgTypeUnknown::numberOfNodes();
295975 4 : count += SgTypeChar::numberOfNodes();
295976 4 : count += SgTypeSignedChar::numberOfNodes();
295977 4 : count += SgTypeUnsignedChar::numberOfNodes();
295978 4 : count += SgTypeShort::numberOfNodes();
295979 4 : count += SgTypeSignedShort::numberOfNodes();
295980 4 : count += SgTypeUnsignedShort::numberOfNodes();
295981 4 : count += SgTypeInt::numberOfNodes();
295982 4 : count += SgTypeSignedInt::numberOfNodes();
295983 4 : count += SgTypeUnsignedInt::numberOfNodes();
295984 4 : count += SgTypeLong::numberOfNodes();
295985 4 : count += SgTypeSignedLong::numberOfNodes();
295986 4 : count += SgTypeUnsignedLong::numberOfNodes();
295987 4 : count += SgTypeVoid::numberOfNodes();
295988 4 : count += SgTypeGlobalVoid::numberOfNodes();
295989 4 : count += SgTypeWchar::numberOfNodes();
295990 4 : count += SgTypeFloat::numberOfNodes();
295991 4 : count += SgTypeDouble::numberOfNodes();
295992 4 : count += SgTypeLongLong::numberOfNodes();
295993 4 : count += SgTypeSignedLongLong::numberOfNodes();
295994 4 : count += SgTypeUnsignedLongLong::numberOfNodes();
295995 4 : count += SgTypeLongDouble::numberOfNodes();
295996 4 : count += SgTypeFloat80::numberOfNodes();
295997 4 : count += SgTypeFloat128::numberOfNodes();
295998 4 : count += SgTypeString::numberOfNodes();
295999 4 : count += SgTypeBool::numberOfNodes();
296000 4 : count += SgTypeFixed::numberOfNodes();
296001 4 : count += SgTypeMatrix::numberOfNodes();
296002 4 : count += SgTypeTuple::numberOfNodes();
296003 4 : count += SgTypeNullptr::numberOfNodes();
296004 4 : count += SgTypeComplex::numberOfNodes();
296005 4 : count += SgTypeImaginary::numberOfNodes();
296006 4 : count += SgTypeDefault::numberOfNodes();
296007 4 : count += SgPointerMemberType::numberOfNodes();
296008 4 : count += SgReferenceType::numberOfNodes();
296009 4 : count += SgRvalueReferenceType::numberOfNodes();
296010 4 : count += SgDeclType::numberOfNodes();
296011 4 : count += SgTypeOfType::numberOfNodes();
296012 4 : count += SgTypeCAFTeam::numberOfNodes();
296013 4 : count += SgTypeUnsigned128bitInteger::numberOfNodes();
296014 4 : count += SgTypeSigned128bitInteger::numberOfNodes();
296015 4 : count += SgTypeLabel::numberOfNodes();
296016 4 : count += SgTemplateType::numberOfNodes();
296017 4 : count += SgEnumType::numberOfNodes();
296018 4 : count += SgTypedefType::numberOfNodes();
296019 4 : count += SgNonrealType::numberOfNodes();
296020 4 : count += SgAutoType::numberOfNodes();
296021 4 : count += SgModifierType::numberOfNodes();
296022 4 : count += SgPartialFunctionModifierType::numberOfNodes();
296023 4 : count += SgArrayType::numberOfNodes();
296024 4 : count += SgTypeEllipse::numberOfNodes();
296025 4 : count += SgTypeCrayPointer::numberOfNodes();
296026 4 : count += SgPartialFunctionType::numberOfNodes();
296027 4 : count += SgMemberFunctionType::numberOfNodes();
296028 4 : count += SgFunctionType::numberOfNodes();
296029 4 : count += SgPointerType::numberOfNodes();
296030 4 : count += SgClassType::numberOfNodes();
296031 4 : count += SgNamedType::numberOfNodes();
296032 4 : count += SgQualifiedNameType::numberOfNodes();
296033 4 : count += SgTypeChar16::numberOfNodes();
296034 4 : count += SgTypeChar32::numberOfNodes();
296035 4 : count += SgType::numberOfNodes();
296036 4 : count += SgForStatement::numberOfNodes();
296037 4 : count += SgForInitStatement::numberOfNodes();
296038 4 : count += SgRangeBasedForStatement::numberOfNodes();
296039 4 : count += SgCatchStatementSeq::numberOfNodes();
296040 4 : count += SgFunctionParameterList::numberOfNodes();
296041 4 : count += SgCtorInitializerList::numberOfNodes();
296042 4 : count += SgBasicBlock::numberOfNodes();
296043 4 : count += SgGlobal::numberOfNodes();
296044 4 : count += SgIfStmt::numberOfNodes();
296045 4 : count += SgWhileStmt::numberOfNodes();
296046 4 : count += SgDoWhileStmt::numberOfNodes();
296047 4 : count += SgSwitchStatement::numberOfNodes();
296048 4 : count += SgCatchOptionStmt::numberOfNodes();
296049 4 : count += SgFunctionParameterScope::numberOfNodes();
296050 4 : count += SgDeclarationScope::numberOfNodes();
296051 4 : count += SgVariableDefinition::numberOfNodes();
296052 4 : count += SgStmtDeclarationStatement::numberOfNodes();
296053 4 : count += SgEnumDeclaration::numberOfNodes();
296054 4 : count += SgAsmStmt::numberOfNodes();
296055 4 : count += SgFunctionTypeTable::numberOfNodes();
296056 4 : count += SgExprStatement::numberOfNodes();
296057 4 : count += SgLabelStatement::numberOfNodes();
296058 4 : count += SgCaseOptionStmt::numberOfNodes();
296059 4 : count += SgTryStmt::numberOfNodes();
296060 4 : count += SgDefaultOptionStmt::numberOfNodes();
296061 4 : count += SgBreakStmt::numberOfNodes();
296062 4 : count += SgContinueStmt::numberOfNodes();
296063 4 : count += SgReturnStmt::numberOfNodes();
296064 4 : count += SgGotoStatement::numberOfNodes();
296065 4 : count += SgSpawnStmt::numberOfNodes();
296066 4 : count += SgTemplateTypedefDeclaration::numberOfNodes();
296067 4 : count += SgTemplateInstantiationTypedefDeclaration::numberOfNodes();
296068 4 : count += SgTypedefDeclaration::numberOfNodes();
296069 4 : count += SgNullStatement::numberOfNodes();
296070 4 : count += SgVariantStatement::numberOfNodes();
296071 4 : count += SgPragmaDeclaration::numberOfNodes();
296072 4 : count += SgTemplateClassDeclaration::numberOfNodes();
296073 4 : count += SgTemplateMemberFunctionDeclaration::numberOfNodes();
296074 4 : count += SgTemplateFunctionDeclaration::numberOfNodes();
296075 4 : count += SgTemplateVariableDeclaration::numberOfNodes();
296076 4 : count += SgTemplateDeclaration::numberOfNodes();
296077 4 : count += SgVariableDeclaration::numberOfNodes();
296078 4 : count += SgTemplateInstantiationDecl::numberOfNodes();
296079 4 : count += SgTemplateInstantiationDefn::numberOfNodes();
296080 4 : count += SgTemplateInstantiationFunctionDecl::numberOfNodes();
296081 4 : count += SgTemplateInstantiationMemberFunctionDecl::numberOfNodes();
296082 4 : count += SgNonrealDecl::numberOfNodes();
296083 4 : count += SgWithStatement::numberOfNodes();
296084 4 : count += SgPassStatement::numberOfNodes();
296085 4 : count += SgAssertStmt::numberOfNodes();
296086 4 : count += SgExecStatement::numberOfNodes();
296087 4 : count += SgProgramHeaderStatement::numberOfNodes();
296088 4 : count += SgProcedureHeaderStatement::numberOfNodes();
296089 4 : count += SgEntryStatement::numberOfNodes();
296090 4 : count += SgFortranNonblockedDo::numberOfNodes();
296091 4 : count += SgInterfaceStatement::numberOfNodes();
296092 4 : count += SgParameterStatement::numberOfNodes();
296093 4 : count += SgCommonBlock::numberOfNodes();
296094 4 : count += SgModuleStatement::numberOfNodes();
296095 4 : count += SgUseStatement::numberOfNodes();
296096 4 : count += SgProcessControlStatement::numberOfNodes();
296097 4 : count += SgPrintStatement::numberOfNodes();
296098 4 : count += SgReadStatement::numberOfNodes();
296099 4 : count += SgWriteStatement::numberOfNodes();
296100 4 : count += SgOpenStatement::numberOfNodes();
296101 4 : count += SgCloseStatement::numberOfNodes();
296102 4 : count += SgInquireStatement::numberOfNodes();
296103 4 : count += SgFlushStatement::numberOfNodes();
296104 4 : count += SgBackspaceStatement::numberOfNodes();
296105 4 : count += SgRewindStatement::numberOfNodes();
296106 4 : count += SgEndfileStatement::numberOfNodes();
296107 4 : count += SgWaitStatement::numberOfNodes();
296108 4 : count += SgCAFWithTeamStatement::numberOfNodes();
296109 4 : count += SgFormatStatement::numberOfNodes();
296110 4 : count += SgFortranDo::numberOfNodes();
296111 4 : count += SgForAllStatement::numberOfNodes();
296112 4 : count += SgIOStatement::numberOfNodes();
296113 4 : count += SgSyncAllStatement::numberOfNodes();
296114 4 : count += SgSyncImagesStatement::numberOfNodes();
296115 4 : count += SgSyncMemoryStatement::numberOfNodes();
296116 4 : count += SgSyncTeamStatement::numberOfNodes();
296117 4 : count += SgLockStatement::numberOfNodes();
296118 4 : count += SgUnlockStatement::numberOfNodes();
296119 4 : count += SgImageControlStatement::numberOfNodes();
296120 4 : count += SgUpcNotifyStatement::numberOfNodes();
296121 4 : count += SgUpcWaitStatement::numberOfNodes();
296122 4 : count += SgUpcBarrierStatement::numberOfNodes();
296123 4 : count += SgUpcFenceStatement::numberOfNodes();
296124 4 : count += SgUpcForAllStatement::numberOfNodes();
296125 4 : count += SgUpirSpmdStatement::numberOfNodes();
296126 4 : count += SgOmpLoopStatement::numberOfNodes();
296127 4 : count += SgOmpScanStatement::numberOfNodes();
296128 4 : count += SgOmpTaskloopStatement::numberOfNodes();
296129 4 : count += SgOmpTaskgroupStatement::numberOfNodes();
296130 4 : count += SgOmpDepobjStatement::numberOfNodes();
296131 4 : count += SgOmpTeamsStatement::numberOfNodes();
296132 4 : count += SgOmpCancellationPointStatement::numberOfNodes();
296133 4 : count += SgOmpDeclareMapperStatement::numberOfNodes();
296134 4 : count += SgOmpCancelStatement::numberOfNodes();
296135 4 : count += SgOmpDistributeStatement::numberOfNodes();
296136 4 : count += SgOmpMetadirectiveStatement::numberOfNodes();
296137 4 : count += SgOmpSingleStatement::numberOfNodes();
296138 4 : count += SgOmpTaskStatement::numberOfNodes();
296139 4 : count += SgOmpTargetEnterDataStatement::numberOfNodes();
296140 4 : count += SgOmpTargetExitDataStatement::numberOfNodes();
296141 4 : count += SgUpirWorksharingStatement::numberOfNodes();
296142 4 : count += SgOmpForSimdStatement::numberOfNodes();
296143 4 : count += SgOmpDoStatement::numberOfNodes();
296144 4 : count += SgOmpSectionsStatement::numberOfNodes();
296145 4 : count += SgOmpAtomicStatement::numberOfNodes();
296146 4 : count += SgUpirTaskStatement::numberOfNodes();
296147 4 : count += SgOmpTargetDataStatement::numberOfNodes();
296148 4 : count += SgOmpTargetParallelForStatement::numberOfNodes();
296149 4 : count += SgOmpTargetParallelStatement::numberOfNodes();
296150 4 : count += SgOmpDistributeSimdStatement::numberOfNodes();
296151 4 : count += SgOmpDistributeParallelForStatement::numberOfNodes();
296152 4 : count += SgOmpDistributeParallelForSimdStatement::numberOfNodes();
296153 4 : count += SgOmpTaskloopSimdStatement::numberOfNodes();
296154 4 : count += SgOmpTargetUpdateStatement::numberOfNodes();
296155 4 : count += SgOmpTargetParallelForSimdStatement::numberOfNodes();
296156 4 : count += SgOmpTargetParallelLoopStatement::numberOfNodes();
296157 4 : count += SgOmpTargetSimdStatement::numberOfNodes();
296158 4 : count += SgOmpTargetTeamsStatement::numberOfNodes();
296159 4 : count += SgOmpTargetTeamsDistributeStatement::numberOfNodes();
296160 4 : count += SgOmpTargetTeamsDistributeSimdStatement::numberOfNodes();
296161 4 : count += SgOmpTargetTeamsLoopStatement::numberOfNodes();
296162 4 : count += SgOmpTargetTeamsDistributeParallelForStatement::numberOfNodes();
296163 4 : count += SgOmpTargetTeamsDistributeParallelForSimdStatement::numberOfNodes();
296164 4 : count += SgOmpMasterTaskloopSimdStatement::numberOfNodes();
296165 4 : count += SgOmpParallelMasterTaskloopStatement::numberOfNodes();
296166 4 : count += SgOmpParallelMasterTaskloopSimdStatement::numberOfNodes();
296167 4 : count += SgOmpTeamsDistributeStatement::numberOfNodes();
296168 4 : count += SgOmpTeamsDistributeSimdStatement::numberOfNodes();
296169 4 : count += SgOmpTeamsDistributeParallelForStatement::numberOfNodes();
296170 4 : count += SgOmpTeamsDistributeParallelForSimdStatement::numberOfNodes();
296171 4 : count += SgOmpTeamsLoopStatement::numberOfNodes();
296172 4 : count += SgOmpParallelMasterStatement::numberOfNodes();
296173 4 : count += SgOmpMasterTaskloopStatement::numberOfNodes();
296174 4 : count += SgOmpParallelLoopStatement::numberOfNodes();
296175 4 : count += SgOmpUnrollStatement::numberOfNodes();
296176 4 : count += SgOmpTileStatement::numberOfNodes();
296177 4 : count += SgUpirSimdStatement::numberOfNodes();
296178 4 : count += SgOmpCriticalStatement::numberOfNodes();
296179 4 : count += SgOmpOrderedStatement::numberOfNodes();
296180 4 : count += SgUpirLoopStatement::numberOfNodes();
296181 4 : count += SgUpirLoopParallelStatement::numberOfNodes();
296182 4 : count += SgUpirSyncStatement::numberOfNodes();
296183 4 : count += SgUpirFieldBodyStatement::numberOfNodes();
296184 4 : count += SgOmpMasterStatement::numberOfNodes();
296185 4 : count += SgOmpSectionStatement::numberOfNodes();
296186 4 : count += SgOmpWorkshareStatement::numberOfNodes();
296187 4 : count += SgOmpFlushStatement::numberOfNodes();
296188 4 : count += SgOmpAllocateStatement::numberOfNodes();
296189 4 : count += SgOmpOrderedDependStatement::numberOfNodes();
296190 4 : count += SgUpirBodyStatement::numberOfNodes();
296191 4 : count += SgUpirFieldStatement::numberOfNodes();
296192 4 : count += SgBlockDataStatement::numberOfNodes();
296193 4 : count += SgImplicitStatement::numberOfNodes();
296194 4 : count += SgStatementFunctionStatement::numberOfNodes();
296195 4 : count += SgWhereStatement::numberOfNodes();
296196 4 : count += SgNullifyStatement::numberOfNodes();
296197 4 : count += SgEquivalenceStatement::numberOfNodes();
296198 4 : count += SgDerivedTypeStatement::numberOfNodes();
296199 4 : count += SgAttributeSpecificationStatement::numberOfNodes();
296200 4 : count += SgAllocateStatement::numberOfNodes();
296201 4 : count += SgDeallocateStatement::numberOfNodes();
296202 4 : count += SgContainsStatement::numberOfNodes();
296203 4 : count += SgSequenceStatement::numberOfNodes();
296204 4 : count += SgElseWhereStatement::numberOfNodes();
296205 4 : count += SgArithmeticIfStatement::numberOfNodes();
296206 4 : count += SgAssignStatement::numberOfNodes();
296207 4 : count += SgComputedGotoStatement::numberOfNodes();
296208 4 : count += SgAssignedGotoStatement::numberOfNodes();
296209 4 : count += SgNamelistStatement::numberOfNodes();
296210 4 : count += SgImportStatement::numberOfNodes();
296211 4 : count += SgAssociateStatement::numberOfNodes();
296212 4 : count += SgFortranIncludeLine::numberOfNodes();
296213 4 : count += SgNamespaceDeclarationStatement::numberOfNodes();
296214 4 : count += SgNamespaceAliasDeclarationStatement::numberOfNodes();
296215 4 : count += SgNamespaceDefinitionStatement::numberOfNodes();
296216 4 : count += SgUsingDeclarationStatement::numberOfNodes();
296217 4 : count += SgUsingDirectiveStatement::numberOfNodes();
296218 4 : count += SgTemplateInstantiationDirectiveStatement::numberOfNodes();
296219 4 : count += SgStaticAssertionDeclaration::numberOfNodes();
296220 4 : count += SgTemplateClassDefinition::numberOfNodes();
296221 4 : count += SgTemplateFunctionDefinition::numberOfNodes();
296222 4 : count += SgClassDeclaration::numberOfNodes();
296223 4 : count += SgClassDefinition::numberOfNodes();
296224 4 : count += SgFunctionDefinition::numberOfNodes();
296225 4 : count += SgScopeStatement::numberOfNodes();
296226 4 : count += SgMemberFunctionDeclaration::numberOfNodes();
296227 4 : count += SgFunctionDeclaration::numberOfNodes();
296228 4 : count += SgIncludeDirectiveStatement::numberOfNodes();
296229 4 : count += SgDefineDirectiveStatement::numberOfNodes();
296230 4 : count += SgUndefDirectiveStatement::numberOfNodes();
296231 4 : count += SgIfdefDirectiveStatement::numberOfNodes();
296232 4 : count += SgIfndefDirectiveStatement::numberOfNodes();
296233 4 : count += SgIfDirectiveStatement::numberOfNodes();
296234 4 : count += SgDeadIfDirectiveStatement::numberOfNodes();
296235 4 : count += SgElseDirectiveStatement::numberOfNodes();
296236 4 : count += SgElseifDirectiveStatement::numberOfNodes();
296237 4 : count += SgEndifDirectiveStatement::numberOfNodes();
296238 4 : count += SgLineDirectiveStatement::numberOfNodes();
296239 4 : count += SgWarningDirectiveStatement::numberOfNodes();
296240 4 : count += SgErrorDirectiveStatement::numberOfNodes();
296241 4 : count += SgEmptyDirectiveStatement::numberOfNodes();
296242 4 : count += SgIncludeNextDirectiveStatement::numberOfNodes();
296243 4 : count += SgIdentDirectiveStatement::numberOfNodes();
296244 4 : count += SgLinemarkerDirectiveStatement::numberOfNodes();
296245 4 : count += SgC_PreprocessorDirectiveStatement::numberOfNodes();
296246 4 : count += SgClinkageStartStatement::numberOfNodes();
296247 4 : count += SgClinkageEndStatement::numberOfNodes();
296248 4 : count += SgClinkageDeclarationStatement::numberOfNodes();
296249 4 : count += SgOmpDeclareSimdStatement::numberOfNodes();
296250 4 : count += SgOmpBarrierStatement::numberOfNodes();
296251 4 : count += SgOmpTaskyieldStatement::numberOfNodes();
296252 4 : count += SgOmpRequiresStatement::numberOfNodes();
296253 4 : count += SgOmpTaskwaitStatement::numberOfNodes();
296254 4 : count += SgOmpThreadprivateStatement::numberOfNodes();
296255 4 : count += SgMicrosoftAttributeDeclaration::numberOfNodes();
296256 4 : count += SgEmptyDeclaration::numberOfNodes();
296257 4 : count += SgDeclarationStatement::numberOfNodes();
296258 4 : count += SgUpirBaseStatement::numberOfNodes();
296259 4 : count += SgStatement::numberOfNodes();
296260 4 : count += SgVarRefExp::numberOfNodes();
296261 4 : count += SgNonrealRefExp::numberOfNodes();
296262 4 : count += SgCompoundLiteralExp::numberOfNodes();
296263 4 : count += SgLabelRefExp::numberOfNodes();
296264 4 : count += SgClassNameRefExp::numberOfNodes();
296265 4 : count += SgFunctionRefExp::numberOfNodes();
296266 4 : count += SgMemberFunctionRefExp::numberOfNodes();
296267 4 : count += SgTemplateFunctionRefExp::numberOfNodes();
296268 4 : count += SgTemplateMemberFunctionRefExp::numberOfNodes();
296269 4 : count += SgSizeOfOp::numberOfNodes();
296270 4 : count += SgAlignOfOp::numberOfNodes();
296271 4 : count += SgNoexceptOp::numberOfNodes();
296272 4 : count += SgTypeExpression::numberOfNodes();
296273 4 : count += SgLambdaExp::numberOfNodes();
296274 4 : count += SgUpcLocalsizeofExpression::numberOfNodes();
296275 4 : count += SgUpcBlocksizeofExpression::numberOfNodes();
296276 4 : count += SgUpcElemsizeofExpression::numberOfNodes();
296277 4 : count += SgVarArgStartOp::numberOfNodes();
296278 4 : count += SgVarArgStartOneOperandOp::numberOfNodes();
296279 4 : count += SgVarArgOp::numberOfNodes();
296280 4 : count += SgVarArgEndOp::numberOfNodes();
296281 4 : count += SgVarArgCopyOp::numberOfNodes();
296282 4 : count += SgTypeIdOp::numberOfNodes();
296283 4 : count += SgConditionalExp::numberOfNodes();
296284 4 : count += SgNewExp::numberOfNodes();
296285 4 : count += SgDeleteExp::numberOfNodes();
296286 4 : count += SgThisExp::numberOfNodes();
296287 4 : count += SgSuperExp::numberOfNodes();
296288 4 : count += SgClassExp::numberOfNodes();
296289 4 : count += SgRefExp::numberOfNodes();
296290 4 : count += SgAggregateInitializer::numberOfNodes();
296291 4 : count += SgCompoundInitializer::numberOfNodes();
296292 4 : count += SgConstructorInitializer::numberOfNodes();
296293 4 : count += SgAssignInitializer::numberOfNodes();
296294 4 : count += SgBracedInitializer::numberOfNodes();
296295 4 : count += SgExpressionRoot::numberOfNodes();
296296 4 : count += SgMinusOp::numberOfNodes();
296297 4 : count += SgUnaryAddOp::numberOfNodes();
296298 4 : count += SgNotOp::numberOfNodes();
296299 4 : count += SgPointerDerefExp::numberOfNodes();
296300 4 : count += SgAddressOfOp::numberOfNodes();
296301 4 : count += SgMinusMinusOp::numberOfNodes();
296302 4 : count += SgPlusPlusOp::numberOfNodes();
296303 4 : count += SgBitComplementOp::numberOfNodes();
296304 4 : count += SgRealPartOp::numberOfNodes();
296305 4 : count += SgImagPartOp::numberOfNodes();
296306 4 : count += SgConjugateOp::numberOfNodes();
296307 4 : count += SgCastExp::numberOfNodes();
296308 4 : count += SgThrowOp::numberOfNodes();
296309 4 : count += SgArrowExp::numberOfNodes();
296310 4 : count += SgDotExp::numberOfNodes();
296311 4 : count += SgDotStarOp::numberOfNodes();
296312 4 : count += SgArrowStarOp::numberOfNodes();
296313 4 : count += SgEqualityOp::numberOfNodes();
296314 4 : count += SgLessThanOp::numberOfNodes();
296315 4 : count += SgGreaterThanOp::numberOfNodes();
296316 4 : count += SgNotEqualOp::numberOfNodes();
296317 4 : count += SgLessOrEqualOp::numberOfNodes();
296318 4 : count += SgGreaterOrEqualOp::numberOfNodes();
296319 4 : count += SgAddOp::numberOfNodes();
296320 4 : count += SgSubtractOp::numberOfNodes();
296321 4 : count += SgMultiplyOp::numberOfNodes();
296322 4 : count += SgDivideOp::numberOfNodes();
296323 4 : count += SgIntegerDivideOp::numberOfNodes();
296324 4 : count += SgModOp::numberOfNodes();
296325 4 : count += SgAndOp::numberOfNodes();
296326 4 : count += SgOrOp::numberOfNodes();
296327 4 : count += SgBitXorOp::numberOfNodes();
296328 4 : count += SgBitAndOp::numberOfNodes();
296329 4 : count += SgBitOrOp::numberOfNodes();
296330 4 : count += SgBitEqvOp::numberOfNodes();
296331 4 : count += SgCommaOpExp::numberOfNodes();
296332 4 : count += SgLshiftOp::numberOfNodes();
296333 4 : count += SgRshiftOp::numberOfNodes();
296334 4 : count += SgPntrArrRefExp::numberOfNodes();
296335 4 : count += SgScopeOp::numberOfNodes();
296336 4 : count += SgAssignOp::numberOfNodes();
296337 4 : count += SgPlusAssignOp::numberOfNodes();
296338 4 : count += SgMinusAssignOp::numberOfNodes();
296339 4 : count += SgAndAssignOp::numberOfNodes();
296340 4 : count += SgIorAssignOp::numberOfNodes();
296341 4 : count += SgMultAssignOp::numberOfNodes();
296342 4 : count += SgDivAssignOp::numberOfNodes();
296343 4 : count += SgModAssignOp::numberOfNodes();
296344 4 : count += SgXorAssignOp::numberOfNodes();
296345 4 : count += SgLshiftAssignOp::numberOfNodes();
296346 4 : count += SgRshiftAssignOp::numberOfNodes();
296347 4 : count += SgIntegerDivideAssignOp::numberOfNodes();
296348 4 : count += SgExponentiationAssignOp::numberOfNodes();
296349 4 : count += SgConcatenationOp::numberOfNodes();
296350 4 : count += SgNaryComparisonOp::numberOfNodes();
296351 4 : count += SgNaryBooleanOp::numberOfNodes();
296352 4 : count += SgBoolValExp::numberOfNodes();
296353 4 : count += SgStringVal::numberOfNodes();
296354 4 : count += SgShortVal::numberOfNodes();
296355 4 : count += SgCharVal::numberOfNodes();
296356 4 : count += SgUnsignedCharVal::numberOfNodes();
296357 4 : count += SgWcharVal::numberOfNodes();
296358 4 : count += SgChar16Val::numberOfNodes();
296359 4 : count += SgChar32Val::numberOfNodes();
296360 4 : count += SgUnsignedShortVal::numberOfNodes();
296361 4 : count += SgIntVal::numberOfNodes();
296362 4 : count += SgEnumVal::numberOfNodes();
296363 4 : count += SgUnsignedIntVal::numberOfNodes();
296364 4 : count += SgLongIntVal::numberOfNodes();
296365 4 : count += SgLongLongIntVal::numberOfNodes();
296366 4 : count += SgUnsignedLongLongIntVal::numberOfNodes();
296367 4 : count += SgUnsignedLongVal::numberOfNodes();
296368 4 : count += SgFloatVal::numberOfNodes();
296369 4 : count += SgDoubleVal::numberOfNodes();
296370 4 : count += SgLongDoubleVal::numberOfNodes();
296371 4 : count += SgFloat80Val::numberOfNodes();
296372 4 : count += SgFloat128Val::numberOfNodes();
296373 4 : count += SgNullptrValExp::numberOfNodes();
296374 4 : count += SgVoidVal::numberOfNodes();
296375 4 : count += SgFunctionParameterRefExp::numberOfNodes();
296376 4 : count += SgTemplateParameterVal::numberOfNodes();
296377 4 : count += SgUpcThreads::numberOfNodes();
296378 4 : count += SgUpcMythread::numberOfNodes();
296379 4 : count += SgComplexVal::numberOfNodes();
296380 4 : count += SgNullExpression::numberOfNodes();
296381 4 : count += SgVariantExpression::numberOfNodes();
296382 4 : count += SgStatementExpression::numberOfNodes();
296383 4 : count += SgAsmOp::numberOfNodes();
296384 4 : count += SgCudaKernelExecConfig::numberOfNodes();
296385 4 : count += SgCudaKernelCallExp::numberOfNodes();
296386 4 : count += SgLambdaRefExp::numberOfNodes();
296387 4 : count += SgTupleExp::numberOfNodes();
296388 4 : count += SgListExp::numberOfNodes();
296389 4 : count += SgDictionaryExp::numberOfNodes();
296390 4 : count += SgKeyDatumPair::numberOfNodes();
296391 4 : count += SgComprehension::numberOfNodes();
296392 4 : count += SgListComprehension::numberOfNodes();
296393 4 : count += SgSetComprehension::numberOfNodes();
296394 4 : count += SgDictionaryComprehension::numberOfNodes();
296395 4 : count += SgMembershipOp::numberOfNodes();
296396 4 : count += SgNonMembershipOp::numberOfNodes();
296397 4 : count += SgIsOp::numberOfNodes();
296398 4 : count += SgIsNotOp::numberOfNodes();
296399 4 : count += SgStringConversion::numberOfNodes();
296400 4 : count += SgYieldExpression::numberOfNodes();
296401 4 : count += SgFoldExpression::numberOfNodes();
296402 4 : count += SgChooseExpression::numberOfNodes();
296403 4 : count += SgAwaitExpression::numberOfNodes();
296404 4 : count += SgSpaceshipOp::numberOfNodes();
296405 4 : count += SgSubscriptExpression::numberOfNodes();
296406 4 : count += SgColonShapeExp::numberOfNodes();
296407 4 : count += SgAsteriskShapeExp::numberOfNodes();
296408 4 : count += SgIOItemExpression::numberOfNodes();
296409 4 : count += SgImpliedDo::numberOfNodes();
296410 4 : count += SgExponentiationOp::numberOfNodes();
296411 4 : count += SgUnknownArrayOrFunctionReference::numberOfNodes();
296412 4 : count += SgActualArgumentExpression::numberOfNodes();
296413 4 : count += SgUserDefinedBinaryOp::numberOfNodes();
296414 4 : count += SgPointerAssignOp::numberOfNodes();
296415 4 : count += SgCAFCoExpression::numberOfNodes();
296416 4 : count += SgDesignatedInitializer::numberOfNodes();
296417 4 : count += SgMatrixExp::numberOfNodes();
296418 4 : count += SgRangeExp::numberOfNodes();
296419 4 : count += SgMagicColonExp::numberOfNodes();
296420 4 : count += SgElementwiseMultiplyOp::numberOfNodes();
296421 4 : count += SgPowerOp::numberOfNodes();
296422 4 : count += SgElementwisePowerOp::numberOfNodes();
296423 4 : count += SgElementwiseDivideOp::numberOfNodes();
296424 4 : count += SgLeftDivideOp::numberOfNodes();
296425 4 : count += SgElementwiseLeftDivideOp::numberOfNodes();
296426 4 : count += SgElementwiseAddOp::numberOfNodes();
296427 4 : count += SgElementwiseSubtractOp::numberOfNodes();
296428 4 : count += SgMatrixTransposeOp::numberOfNodes();
296429 4 : count += SgElementwiseOp::numberOfNodes();
296430 4 : count += SgInitializer::numberOfNodes();
296431 4 : count += SgSIMDLoad::numberOfNodes();
296432 4 : count += SgSIMDBroadcast::numberOfNodes();
296433 4 : count += SgSIMDStore::numberOfNodes();
296434 4 : count += SgSIMDPartialStore::numberOfNodes();
296435 4 : count += SgSIMDScalarStore::numberOfNodes();
296436 4 : count += SgSIMDGather::numberOfNodes();
296437 4 : count += SgSIMDExplicitGather::numberOfNodes();
296438 4 : count += SgSIMDScatter::numberOfNodes();
296439 4 : count += SgSIMDAddOp::numberOfNodes();
296440 4 : count += SgSIMDSubOp::numberOfNodes();
296441 4 : count += SgSIMDMulOp::numberOfNodes();
296442 4 : count += SgSIMDDivOp::numberOfNodes();
296443 4 : count += SgSIMDFmaOp::numberOfNodes();
296444 4 : count += SgSIMDBinaryOp::numberOfNodes();
296445 4 : count += SgUserDefinedUnaryOp::numberOfNodes();
296446 4 : count += SgPseudoDestructorRefExp::numberOfNodes();
296447 4 : count += SgUnaryOp::numberOfNodes();
296448 4 : count += SgCompoundAssignOp::numberOfNodes();
296449 4 : count += SgBinaryOp::numberOfNodes();
296450 4 : count += SgNaryOp::numberOfNodes();
296451 4 : count += SgValueExp::numberOfNodes();
296452 4 : count += SgExprListExp::numberOfNodes();
296453 4 : count += SgFunctionCallExp::numberOfNodes();
296454 4 : count += SgCallExpression::numberOfNodes();
296455 4 : count += SgTypeTraitBuiltinOperator::numberOfNodes();
296456 4 : count += SgExpression::numberOfNodes();
296457 4 : count += SgTemplateVariableSymbol::numberOfNodes();
296458 4 : count += SgVariableSymbol::numberOfNodes();
296459 4 : count += SgFunctionTypeSymbol::numberOfNodes();
296460 4 : count += SgTemplateClassSymbol::numberOfNodes();
296461 4 : count += SgClassSymbol::numberOfNodes();
296462 4 : count += SgTemplateSymbol::numberOfNodes();
296463 4 : count += SgEnumSymbol::numberOfNodes();
296464 4 : count += SgEnumFieldSymbol::numberOfNodes();
296465 4 : count += SgTemplateTypedefSymbol::numberOfNodes();
296466 4 : count += SgTypedefSymbol::numberOfNodes();
296467 4 : count += SgTemplateFunctionSymbol::numberOfNodes();
296468 4 : count += SgTemplateMemberFunctionSymbol::numberOfNodes();
296469 4 : count += SgLabelSymbol::numberOfNodes();
296470 4 : count += SgDefaultSymbol::numberOfNodes();
296471 4 : count += SgNamespaceSymbol::numberOfNodes();
296472 4 : count += SgIntrinsicSymbol::numberOfNodes();
296473 4 : count += SgModuleSymbol::numberOfNodes();
296474 4 : count += SgInterfaceSymbol::numberOfNodes();
296475 4 : count += SgCommonSymbol::numberOfNodes();
296476 4 : count += SgRenameSymbol::numberOfNodes();
296477 4 : count += SgMemberFunctionSymbol::numberOfNodes();
296478 4 : count += SgFunctionSymbol::numberOfNodes();
296479 4 : count += SgAliasSymbol::numberOfNodes();
296480 4 : count += SgNonrealSymbol::numberOfNodes();
296481 4 : count += SgSymbol::numberOfNodes();
296482 4 : count += SgCommonBlockObject::numberOfNodes();
296483 4 : count += SgInitializedName::numberOfNodes();
296484 4 : count += SgLambdaCapture::numberOfNodes();
296485 4 : count += SgLambdaCaptureList::numberOfNodes();
296486 4 : count += SgOmpOrderedClause::numberOfNodes();
296487 4 : count += SgOmpNowaitClause::numberOfNodes();
296488 4 : count += SgOmpNogroupClause::numberOfNodes();
296489 4 : count += SgOmpReadClause::numberOfNodes();
296490 4 : count += SgOmpThreadsClause::numberOfNodes();
296491 4 : count += SgOmpSimdClause::numberOfNodes();
296492 4 : count += SgOmpReverseOffloadClause::numberOfNodes();
296493 4 : count += SgOmpExtImplementationDefinedRequirementClause::numberOfNodes();
296494 4 : count += SgOmpUnifiedAddressClause::numberOfNodes();
296495 4 : count += SgOmpUnifiedSharedMemoryClause::numberOfNodes();
296496 4 : count += SgOmpDynamicAllocatorsClause::numberOfNodes();
296497 4 : count += SgOmpAtomicDefaultMemOrderClause::numberOfNodes();
296498 4 : count += SgOmpWriteClause::numberOfNodes();
296499 4 : count += SgOmpUpdateClause::numberOfNodes();
296500 4 : count += SgOmpDepobjUpdateClause::numberOfNodes();
296501 4 : count += SgOmpDestroyClause::numberOfNodes();
296502 4 : count += SgOmpCaptureClause::numberOfNodes();
296503 4 : count += SgOmpSeqCstClause::numberOfNodes();
296504 4 : count += SgOmpAcqRelClause::numberOfNodes();
296505 4 : count += SgOmpReleaseClause::numberOfNodes();
296506 4 : count += SgOmpAcquireClause::numberOfNodes();
296507 4 : count += SgOmpRelaxedClause::numberOfNodes();
296508 4 : count += SgOmpParallelClause::numberOfNodes();
296509 4 : count += SgOmpSectionsClause::numberOfNodes();
296510 4 : count += SgOmpForClause::numberOfNodes();
296511 4 : count += SgOmpTaskgroupClause::numberOfNodes();
296512 4 : count += SgOmpBeginClause::numberOfNodes();
296513 4 : count += SgOmpEndClause::numberOfNodes();
296514 4 : count += SgOmpUntiedClause::numberOfNodes();
296515 4 : count += SgOmpMergeableClause::numberOfNodes();
296516 4 : count += SgOmpDefaultClause::numberOfNodes();
296517 4 : count += SgOmpAtomicClause::numberOfNodes();
296518 4 : count += SgOmpProcBindClause::numberOfNodes();
296519 4 : count += SgOmpOrderClause::numberOfNodes();
296520 4 : count += SgOmpBindClause::numberOfNodes();
296521 4 : count += SgOmpInbranchClause::numberOfNodes();
296522 4 : count += SgOmpNotinbranchClause::numberOfNodes();
296523 4 : count += SgOmpCollapseClause::numberOfNodes();
296524 4 : count += SgOmpIfClause::numberOfNodes();
296525 4 : count += SgOmpFinalClause::numberOfNodes();
296526 4 : count += SgOmpPriorityClause::numberOfNodes();
296527 4 : count += SgUpirNumUnitsField::numberOfNodes();
296528 4 : count += SgOmpNumTeamsClause::numberOfNodes();
296529 4 : count += SgOmpGrainsizeClause::numberOfNodes();
296530 4 : count += SgOmpDetachClause::numberOfNodes();
296531 4 : count += SgOmpNumTasksClause::numberOfNodes();
296532 4 : count += SgOmpHintClause::numberOfNodes();
296533 4 : count += SgOmpThreadLimitClause::numberOfNodes();
296534 4 : count += SgOmpNontemporalClause::numberOfNodes();
296535 4 : count += SgOmpInclusiveClause::numberOfNodes();
296536 4 : count += SgOmpExclusiveClause::numberOfNodes();
296537 4 : count += SgOmpIsDevicePtrClause::numberOfNodes();
296538 4 : count += SgOmpUseDevicePtrClause::numberOfNodes();
296539 4 : count += SgOmpUseDeviceAddrClause::numberOfNodes();
296540 4 : count += SgOmpDeviceClause::numberOfNodes();
296541 4 : count += SgOmpSafelenClause::numberOfNodes();
296542 4 : count += SgOmpSimdlenClause::numberOfNodes();
296543 4 : count += SgOmpPartialClause::numberOfNodes();
296544 4 : count += SgOmpFullClause::numberOfNodes();
296545 4 : count += SgOmpSizesClause::numberOfNodes();
296546 4 : count += SgUpirBranchField::numberOfNodes();
296547 4 : count += SgUpirNestedLevelField::numberOfNodes();
296548 4 : count += SgUpirNestedParentField::numberOfNodes();
296549 4 : count += SgUpirNestedChildField::numberOfNodes();
296550 4 : count += SgUpirSyncField::numberOfNodes();
296551 4 : count += SgUpirDataField::numberOfNodes();
296552 4 : count += SgUpirTargetField::numberOfNodes();
296553 4 : count += SgUpirDataItemField::numberOfNodes();
296554 4 : count += SgOmpExpressionClause::numberOfNodes();
296555 4 : count += SgOmpCopyprivateClause::numberOfNodes();
296556 4 : count += SgOmpPrivateClause::numberOfNodes();
296557 4 : count += SgOmpFirstprivateClause::numberOfNodes();
296558 4 : count += SgOmpSharedClause::numberOfNodes();
296559 4 : count += SgOmpCopyinClause::numberOfNodes();
296560 4 : count += SgOmpLastprivateClause::numberOfNodes();
296561 4 : count += SgOmpReductionClause::numberOfNodes();
296562 4 : count += SgOmpInReductionClause::numberOfNodes();
296563 4 : count += SgOmpTaskReductionClause::numberOfNodes();
296564 4 : count += SgOmpAllocateClause::numberOfNodes();
296565 4 : count += SgOmpDependClause::numberOfNodes();
296566 4 : count += SgOmpToClause::numberOfNodes();
296567 4 : count += SgOmpUsesAllocatorsClause::numberOfNodes();
296568 4 : count += SgOmpFromClause::numberOfNodes();
296569 4 : count += SgOmpAffinityClause::numberOfNodes();
296570 4 : count += SgOmpMapClause::numberOfNodes();
296571 4 : count += SgOmpLinearClause::numberOfNodes();
296572 4 : count += SgOmpUniformClause::numberOfNodes();
296573 4 : count += SgOmpAlignedClause::numberOfNodes();
296574 4 : count += SgOmpVariablesClause::numberOfNodes();
296575 4 : count += SgOmpScheduleClause::numberOfNodes();
296576 4 : count += SgOmpWhenClause::numberOfNodes();
296577 4 : count += SgOmpDistScheduleClause::numberOfNodes();
296578 4 : count += SgOmpDefaultmapClause::numberOfNodes();
296579 4 : count += SgOmpAllocatorClause::numberOfNodes();
296580 4 : count += SgOmpUsesAllocatorsDefination::numberOfNodes();
296581 4 : count += SgOmpClause::numberOfNodes();
296582 4 : count += SgRenamePair::numberOfNodes();
296583 4 : count += SgInterfaceBody::numberOfNodes();
296584 4 : count += SgHeaderFileBody::numberOfNodes();
296585 4 : count += SgLocatedNodeSupport::numberOfNodes();
296586 4 : count += SgToken::numberOfNodes();
296587 4 : count += SgLocatedNode::numberOfNodes();
296588 4 : count += SgNode::numberOfNodes();
296589 :
296590 :
296591 4 : return count;
296592 : }
296593 :
|
